PingPong/Core/Src/EEPROM.c

#include "EEPROM.h"
#include "pca9685.h"
#include "usbd_cdc_if.h"
#include "Print.h"

		
MemoryStatus saveShot(unsigned char number, Shot* shot)
{
	if(FLASH_WriteBlock(START_ADR_SHOT, number, (uint8_t*)shot) == EEPROM_OK){
		return EEPROM_OK;
	}
   return EEPROM_FAIL;
}

MemoryStatus getShot(unsigned char number, Shot *shot)
{
	if(FLASH_ReadBlock(START_ADR_SHOT, number, (uint8_t*)&shot) != EEPROM_OK){
		return EEPROM_FAIL;
	}
	if(!shot->isExist){
		return EEPROM_MISSING_ELEMENT;
	}
	return EEPROM_OK;
}

MemoryStatus saveProg(unsigned char number, Program* prog)
{
	MemoryStatus result = EEPROM_OK;
	for(uint16_t i = 0; i < MAX_NUMBER_SHOTS_IN_PROGRAMS; ++i){
		Shot shot;
		MemoryStatus stat = getShot(prog->shots[i].id, &shot);
		if(!(stat == EEPROM_OK || stat == EEPROM_MISSING_ELEMENT)){
			return EEPROM_FAIL;
		}
		if(!shot.isExist){
			//todo: add to shotRequest order
			result = EEPROM_MISSING_ELEMENT;
		}
	}
	if(FLASH_WriteBlock(START_ADR_PROGRAM, number, (uint8_t*)prog) != EEPROM_OK){
		return EEPROM_FAIL;
	}
   return result;
}

MemoryStatus getProg( unsigned char number, Program* prog)
{
	if(FLASH_ReadBlock(START_ADR_PROGRAM, number, (uint8_t*)&prog) != EEPROM_OK){
		return EEPROM_FAIL;
	}

	if(!prog->header.isExist){
		return EEPROM_MISSING_ELEMENT;
	}

	return EEPROM_OK;
}

MemoryStatus saveMacro(unsigned char number, Macro* macro)
{
	MemoryStatus result = EEPROM_OK;
	for (uint16_t i = 0; i < MAX_NUMBER_PROGRAMS_IN_MACRO; ++i) {
		Program prog;
		MemoryStatus stat = getProg(macro->programs[i].id, &prog);
		if(!(stat == EEPROM_OK || stat == EEPROM_MISSING_ELEMENT)){
					return EEPROM_FAIL;
				}
		if(!prog.header.isExist){
			result = EEPROM_MISSING_ELEMENT;
			//todo: add to programRequest order
		}
	}

	if(FLASH_WriteBlock(START_ADR_PROGRAM, number, (uint8_t*)macro) != EEPROM_OK){
		return EEPROM_FAIL;
	}

	return result;
}

MemoryStatus getMacro( unsigned char number, Macro* macro)
{
	if(FLASH_ReadBlock(START_ADR_PROGRAM, number, (uint8_t*)&macro) != EEPROM_OK){
		return EEPROM_FAIL;
	}

	if(!macro->header.isExist){
		return EEPROM_MISSING_ELEMENT;
	}
	return EEPROM_OK;
}

MemoryStatus FLASH_WriteBlock(uint16_t startAddr, uint8_t number, uint8_t *writeData)
{
	HAL_StatusTypeDef result;
	uint8_t dataSize;
	// protect and select
	switch (startAddr) {
		case START_ADR_STAT:
			number = 0;
			dataSize = STAT_BLOCKSIZE;
			break;
		case START_ADR_SHOT:
			dataSize = SHOT_BLOCKSIZE;
			if(number > MAX_NUMBER_SHOTS)
				return EEPROM_OUT_OF_RANGE;
			break;
		case START_ADR_PROGRAM:
			dataSize = PROGRAM_BLOCKSIZE;
			if(number > MAX_NUMBER_PROGRAMS)
				return EEPROM_OUT_OF_RANGE;
			break;
		case START_ADR_MACRO:
			dataSize = MACRO_BLOCKSIZE;
			if(number > MAX_NUMBER_MACRO)
				return EEPROM_OUT_OF_RANGE;
			break;
		default:
			return EEPROM_WRONG_STARTADDR;
			break;
	}

	uint16_t blockAddr16 = (uint16_t)(startAddr + (uint16_t)(number*dataSize));
	uint8_t  blockAddr[2] = {HIBYTE(blockAddr16), LOBYTE(blockAddr16)};

  unsigned char Buf[dataSize+2];
  memset(Buf, 0x00, sizeof(Buf));
	Buf[0] = blockAddr[0];
	Buf[1] = blockAddr[1];
	
	for( unsigned char i = 0; i < (dataSize); i++ ) Buf[i+2] = writeData[i];
		
	result = HAL_I2C_Master_Transmit(&hi2c1, (AT24C_ADRESS << 1), Buf, (dataSize + 2), 10);
	HAL_Delay(1);
	return result;
}

MemoryStatus FLASH_ReadBlock(uint16_t startAddr, uint8_t number, uint8_t *readData){
	HAL_StatusTypeDef result;
	uint8_t dataSize;
	// protect and select
	switch (startAddr) {
		case START_ADR_STAT:
			number = 0;
			dataSize = STAT_BLOCKSIZE;
			break;
		case START_ADR_SHOT:
			dataSize = SHOT_BLOCKSIZE;
			if(number > MAX_NUMBER_SHOTS)
				return EEPROM_OUT_OF_RANGE;
			break;
		case START_ADR_PROGRAM:
			dataSize = PROGRAM_BLOCKSIZE;
			if(number > MAX_NUMBER_PROGRAMS)
				return EEPROM_OUT_OF_RANGE;
			break;
		case START_ADR_MACRO:
			dataSize = MACRO_BLOCKSIZE;
			if(number > MAX_NUMBER_MACRO)
				return EEPROM_OUT_OF_RANGE;
			break;
		default:
			return EEPROM_WRONG_STARTADDR;
			break;
	}

	memset(readData, 0x00, dataSize);

	uint16_t blockAddr16 = (uint16_t)(startAddr + (uint16_t)(number*dataSize));
	uint8_t  blockAddr[2] = {HIBYTE(blockAddr16), LOBYTE(blockAddr16)};

	result = HAL_I2C_Master_Transmit(&hi2c1, (AT24C_ADRESS << 1), blockAddr, 2, 10);
	HAL_Delay(1);
	result = HAL_I2C_Master_Receive(&hi2c1, (AT24C_ADRESS << 1), readData, dataSize, 10);
	HAL_Delay(1);
	return result;
}