/*

#include "stm32f0xx_hal.h"

//------------------------------------------------------------------------------
//  Includes Files
//------------------------------------------------------------------------------
#include "flash.h"

//------------------------------------------------------------------------------
// Global Variables
//------------------------------------------------------------------------------
flash_t Flash;


//------------------------------------------------------------------------------
// Private Variables
//------------------------------------------------------------------------------




//------------------------------------------------------------------------------
// Function Name  : init_FLASH
// Description    : Initializes flash variables
// Input          : None
// Output         : None
// Return         : None
//------------------------------------------------------------------------------
void init_FLASH(void)
{
	uint16_t i,count=0,size;
	uint16_t test;
	uint32_t  flash_adr;
	uint8_t  *flash_ptr;

	size = sizeof(Flash)-1;
	flash_adr = ENDADDR - size;
	flash_adr -= 2;
	flash_ptr = (uint8_t *)flash_adr;

	// Check if flash is blank
	for(i=0;i<size;i++)
	{
		test = *flash_ptr;
		if(test==0xFF) count++;
	}

	// IF Blank, loads default values into flash
	if(count==size)
		flash_load(Flash_default_value);
	else // Not blank
	{
		flash_load(Flash_good_cksum);
	}
}


//------------------------------------------------------------------------------
// Function Name  : flash_load
// Description    :
// Input          : None
// Output         : None
// Return         :
//------------------------------------------------------------------------------
void flash_load(uint8_t flash_test)
{

	switch(flash_test)
	{
	case Flash_error:
		return;//or something

	case Flash_write:
		flash_erase();
		flash_write();
		flash_checksum();
		break;

	case Flash_good_cksum:
		flash_read();
		break;
	}

	// Load Globals
	Reg.control = Flash.ctrl;
	Reg.debug   = Flash.debug;
	Reg.stream  = Flash.stream;
	Reg.option  = Flash.option;
}


//------------------------------------------------------------------------------
// Function Name  : flash_read
// Description    :
// Input          : None
// Output         : None
// Return         : None
//------------------------------------------------------------------------------
void flash_read(void)
{
	uint16_t  i,size;
	uint32_t  flash_adr;
	uint8_t  *flash_ptr;
	uint8_t  *Struct_ptr;

	taskENTER_CRITICAL();

	size = sizeof(Flash)-1; // in Bytes
	flash_adr = ENDADDR - size;
	flash_ptr = (uint8_t *)flash_adr;
	Struct_ptr = (uint8_t *)&Flash;

	for(i=0;i<size;i++)
		*Struct_ptr++ = *flash_ptr++;

	taskEXIT_CRITICAL();
}


//------------------------------------------------------------------------------
// Function Name  : flash_write
// Description    :
// Input          : None
// Output         : None
// Return         : None
//------------------------------------------------------------------------------
void flash_write(void)
{
	uint16_t  i,size,length;
	uint32_t flash_adr;
	uint16_t Data;
	uint16_t  *Struct_ptr;

	taskENTER_CRITICAL();
	FLASH_Unlock();

	size = sizeof(Flash)-1; // in Bytes
	flash_adr = ENDADDR-size;
	Struct_ptr = (uint16_t *)&Flash;

	if(size%2==0)
		length = size/2;
	else
		length = size/2+1;

	for(i=0;i<length;i++)
	{
		Data = *Struct_ptr;
		FLASH_ProgramHalfWord(flash_adr,Data);
		Struct_ptr +=1;
		flash_adr +=2;
	}

	FLASH_Lock();
	taskEXIT_CRITICAL();
}


//------------------------------------------------------------------------------
// Function Name  : flash_checksum
// Description    :
// Input          : None
// Output         : None
// Return         : None
//------------------------------------------------------------------------------
void flash_checksum(void)
{
	uint8_t cksum0=0,cksum1=0;
	uint16_t  i,size,checksum;
	uint32_t flash_adr;
	uint8_t  *flash_ptr;

	taskENTER_CRITICAL();
	FLASH_Unlock();

	size = sizeof(Flash)-1; // in Bytes
	flash_adr = ENDADDR-size;
	flash_ptr = (uint8_t *)flash_adr;

	for(i=1; i < size; i++)
	{
		cksum0 += *flash_ptr++;
		cksum1 += cksum0;
	}
	checksum = MAKEWORD(cksum1,cksum0);
	flash_adr -= 2;
	FLASH_ProgramHalfWord(flash_adr,checksum);

	FLASH_Lock();
	taskEXIT_CRITICAL();
}


//------------------------------------------------------------------------------
// Function Name  : flash_erase
// Description    : Erase flash_values that are stored
// Input          : None
// Output         : None
// Return         : None
//------------------------------------------------------------------------------
void flash_erase(void)
{
	FLASH_Status FLASHStatus;
	uint32_t StartAddr;
	uint32_t end_addr;
	uint32_t NbrOfPage;
	uint32_t EraseCounter;

	taskENTER_CRITICAL();

	FLASHStatus = FLASH_COMPLETE;
	end_addr = ENDADDR;
	NbrOfPage = abs( (sizeof(Flash)-1)/0x400 )+1;   // Number of pages to be erased
	StartAddr = (end_addr+1) - (0x400*NbrOfPage);   // Starting address to be erased

	// Unlock the Flash Program Erase controller
	FLASH_Unlock();

	// Clear All pending flags
	FLASH_ClearFlag(FLASH_FLAG_BSY | FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);

	// Erase the FLASH pages
	for(EraseCounter = 0; (EraseCounter < NbrOfPage) && (FLASHStatus == FLASH_COMPLETE); EraseCounter++)
		FLASHStatus = FLASH_ErasePage(StartAddr + (PageSize * EraseCounter));

	FLASH_Lock();

	taskEXIT_CRITICAL();
}
*/