void readSystemEEPROM(void)
{
uint8_t* start = (uint8_t*)(&systemConfig);
uint8_t* end = (uint8_t*)(&systemConfig + 1);
///////////////////////////////////
setSPIdivisor(EEPROM_SPI, 2); // 18 MHz SPI clock
systemConfigaddr.value = SYSTEM_EEPROM_ADDR;
///////////////////////////////////
ENABLE_EEPROM;
spiTransfer(EEPROM_SPI, READ_DATA);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[2]);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[1]);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[0]);
while (start < end)
*start++ = spiTransfer(EEPROM_SPI, 0x00);
DISABLE_EEPROM;
delayMicroseconds(2);
///////////////////////////////////
if ( crcCheckVal != crc32B((uint32_t*)(&systemConfig), // CRC32B[systemConfig CRC32B[systemConfig]]
(uint32_t*)(&systemConfig + 1)))
{
evrPush(EVR_SystemCRCFail,0);
systemConfig.CRCFlags |= CRC_HistoryBad;
}
else if ( systemConfig.CRCFlags & CRC_HistoryBad )
{
evrPush(EVR_ConfigBadSystemHistory,0);
}
///////////////////////////////////
if (systemConfig.yawDirection >= 0)
systemConfig.yawDirection = 1.0f;
else
systemConfig.yawDirection = -1.0f;
}
void readSensorEEPROM(void)
{
uint8_t* start = (uint8_t*)(&sensorConfig);
uint8_t* end = (uint8_t*)(&sensorConfig + 1);
///////////////////////////////////
setSPIdivisor(EEPROM_SPI, 2); // 18 MHz SPI clock
sensorConfigAddr.value = SENSOR_EEPROM_ADDR;
///////////////////////////////////
ENABLE_EEPROM;
spiTransfer(EEPROM_SPI, READ_DATA);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[2]);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[1]);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[0]);
while (start < end)
*start++ = spiTransfer(EEPROM_SPI, 0x00);
DISABLE_EEPROM;
delayMicroseconds(2);
///////////////////////////////////
if ( crcCheckVal != crc32B((uint32_t*)(&sensorConfig), // CRC32B[sensorConfig CRC32B[sensorConfig]]
(uint32_t*)(&sensorConfig + 1)))
{
evrPush(EVR_SensorCRCFail,0);
sensorConfig.CRCFlags |= CRC_HistoryBad;
}
else if ( sensorConfig.CRCFlags & CRC_HistoryBad )
{
evrPush(EVR_ConfigBadSensorHistory,0);
}
///////////////////////////////////
accConfidenceDecay = 1.0f / sqrt(sensorConfig.accelCutoff);
}
int writeEEPROM(void)
{
FLASH_Status status;
int32_t i;
eepromConfig_t *src = &eepromConfig;
uint32_t *dst = (uint32_t*)FLASH_WRITE_EEPROM_ADDR;
// there's no reason to write these values to EEPROM, they'll just be noise
zeroPIDstates();
if ( src->CRCFlags & CRC_HistoryBad )
evrPush(EVR_ConfigBadHistory,0);
src->CRCAtEnd[0] = crc32B( (uint32_t*)&src[0], src->CRCAtEnd);
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
status = FLASH_EraseSector(FLASH_Sector_1, VoltageRange_3);
///////////////////////////////////
i = -1;
while ( FLASH_COMPLETE == status && i++ < eepromConfigNUMWORD )
status = FLASH_ProgramWord((uint32_t)&dst[i], ((uint32_t*)src)[i]);
if ( FLASH_COMPLETE != status )
evrPush( -1 == i ? EVR_FlashEraseFail : EVR_FlashProgramFail, status);
///////////////////////////////////
FLASH_Lock();
readEEPROM();
return status;
}
void readEEPROM(void)
{
eepromConfig_t *dst = &eepromConfig;
*dst = *(eepromConfig_t*)FLASH_WRITE_EEPROM_ADDR;
if ( crcCheckVal != crc32B((uint32_t*)(&eepromConfig), // CRC32BeepromConfig CRC32B[eepromConfig]]
(uint32_t*)(&eepromConfig + 1)))
{
evrPush(EVR_FlashCRCFail,0);
dst->CRCFlags |= CRC_HistoryBad;
}
else if ( dst->CRCFlags & CRC_HistoryBad )
evrPush(EVR_ConfigBadHistory,0);
///////////////////////////////////
if (eepromConfig.yawDirection >= 0)
eepromConfig.yawDirection = 1.0f;
else
eepromConfig.yawDirection = -1.0f;
}
uint8_t writeEEPROM(void)
{
// there's no reason to write these values to EEPROM, they'll just be noise
zeroPIDintegralError();
zeroPIDstates();
FLASH_Status status;
int i;
uint32_t *dst = (uint32_t*)FLASH_WRITE_EEPROM_ADDR;
eepromConfig_t *src = &eepromConfig;
if ( src->CRCFlags & CRC_HistoryBad )
evrPush(EVR_ConfigBadHistory,0);
src->CRCAtEnd[0] = crc32B( (uint32_t*)&src[0], src->CRCAtEnd);
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPERR);
i = -1;
status = FLASH_ErasePage(FLASH_WRITE_EEPROM_ADDR);
while ( status == FLASH_COMPLETE && i++ < eepromConfigNUMWORD )
status = FLASH_ProgramWord((uint32_t)&dst[i], ((uint32_t*)src)[i]);
if ( status != FLASH_COMPLETE )
evrPush( -1 == i ? EVR_FlashEraseFail : EVR_FlashProgramFail, status);
FLASH_Lock();
readEEPROM();
return status;
}
void cliPrintSystemConfig(void)
{
uint32_t old_crc = systemConfig.CRCAtEnd[0];
uint8_t *by = (uint8_t*)&systemConfig;
int i, j;
systemConfig.CRCAtEnd[0] = crc32B((uint32_t*)(&systemConfig), // CRC32B[systemConfig]
(uint32_t*)(&systemConfig.CRCAtEnd));
if (systemConfig.CRCFlags & CRC_HistoryBad)
evrPush(EVR_ConfigBadHistory, 0);
for (i = 0; i < ceil((float)sizeof(systemConfig) / LINE_LENGTH); i++)
{
for (j = 0; j < min(LINE_LENGTH, sizeof(systemConfig) - LINE_LENGTH * i); j++)
cliPortPrintF("%02X", by[i * LINE_LENGTH + j]);
cliPortPrint("\n");
}
systemConfig.CRCAtEnd[0] = old_crc;
}
uint32_t crc32bEEPROM(eepromConfig_t *e, int includeCRCAtEnd)
{
return crc32B((uint32_t*)e, includeCRCAtEnd ? (uint32_t*)(e + 1) : e->CRCAtEnd);
}
uint8_t writeEEPROM(void)
{
FLASH_Status status;
int32_t i;
///////////////////////////////////
if (eepromConfig.receiverType == SPEKTRUM)
{
USART_Cmd(USART6, DISABLE);
TIM_Cmd(TIM6, DISABLE);
if (eepromConfig.slaveSpektrum == true)
USART_Cmd(UART4, DISABLE);
}
///////////////////////////////////
eepromConfig_t *src = &eepromConfig;
uint32_t *dst = (uint32_t*)FLASH_WRITE_EEPROM_ADDR;
// there's no reason to write these values to EEPROM, they'll just be noise
zeroPIDintegralError();
zeroPIDstates();
if ( src->CRCFlags & CRC_HistoryBad )
evrPush(EVR_ConfigBadHistory,0);
src->CRCAtEnd[0] = crc32B( (uint32_t*)&src[0], src->CRCAtEnd);
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
status = FLASH_EraseSector(FLASH_Sector_1, VoltageRange_3);
///////////////////////////////////
i = -1;
while ( FLASH_COMPLETE == status && i++ < eepromConfigNUMWORD )
status = FLASH_ProgramWord((uint32_t)&dst[i], ((uint32_t*)src)[i]);
if ( FLASH_COMPLETE != status )
evrPush( -1 == i ? EVR_FlashEraseFail : EVR_FlashProgramFail, status);
///////////////////////////////////
FLASH_Lock();
readEEPROM();
if (eepromConfig.receiverType == SPEKTRUM)
{
primarySpektrumState.reSync = 1;
TIM_Cmd(TIM6, ENABLE);
USART_Cmd(USART6, ENABLE);
if (eepromConfig.slaveSpektrum == true)
{
slaveSpektrumState.reSync = 1;
USART_Cmd(UART4, ENABLE);
}
}
///////////////////////////////////
return status;
}
void eepromCLI()
{
char c;
sensorConfig_t sensorRam;
systemConfig_t systemRam;
uint8_t eepromQuery = 'x';
uint8_t *p;
uint8_t *end;
uint8_t secondNibble;
uint8_t validQuery = false;
uint16_t i;
uint32_t c1, c2;
uint32_t size;
uint32_t time;
uint32_t charsEncountered;
///////////////////////////////////////////////////////////////////////////////
cliBusy = true;
cliPortPrint("\nEntering EEPROM CLI....\n\n");
while(true)
{
cliPortPrint("EEPROM CLI -> ");
while ((cliPortAvailable() == false) && (validQuery == false));
if (validQuery == false)
eepromQuery = cliPortRead();
cliPortPrint("\n");
switch(eepromQuery)
{
///////////////////////////
case 'a': // config struct data
c1 = sensorConfig.CRCAtEnd[0];
c2 = crc32B((uint32_t*)(&sensorConfig), // CRC32B[sensorConfig]
(uint32_t*)(&sensorConfig.CRCAtEnd));
cliPortPrintF("Sensor EEPROM structure information:\n");
cliPortPrintF("Version : %d\n", sensorConfig.version);
cliPortPrintF("Size : %d\n", sizeof(sensorConfig));
cliPortPrintF("CRC on last read : %08X\n", c1);
cliPortPrintF("Current CRC : %08X\n", c2);
if ( c1 != c2 )
cliPortPrintF(" CRCs differ. Current Sensor Config has not yet been saved.\n");
cliPortPrintF("CRC Flags :\n");
cliPortPrintF(" History Bad : %s\n", sensorConfig.CRCFlags & CRC_HistoryBad ? "true" : "false" );
validQuery = false;
break;
///////////////////////////
case 'b': // Write out to Console in Hex. (RAM -> console)
// we assume the flyer is not in the air, so that this is ok;
cliPortPrintF("\n");
cliPrintSensorEEPROM();
cliPortPrintF("\n");
if (crcCheckVal != crc32B((uint32_t*)(&sensorConfig), // CRC32B[sensorConfig CRC32B[sensorConfig]]
(uint32_t*)(&sensorConfig + 1)))
{
cliPortPrint("NOTE: in-memory sensor config CRC invalid; there have probably been\n");
cliPortPrint(" changes to sensor config since the last write to flash/eeprom.\n");
}
validQuery = false;
break;
///////////////////////////
case 'c': // Read Sensor Config -> RAM
cliPortPrint("Re-reading Sensor EEPROM.\n");
readSensorEEPROM();
validQuery = false;
break;
///////////////////////////
case 'd': // Read Console -> Sensor RAM
charsEncountered = 0;
secondNibble = 0;
size = sizeof(sensorConfig);
time = millis();
p = (uint8_t*)&sensorRam;
end = (uint8_t*)(&sensorRam + 1);
///////////////////////
cliPortPrintF("Ready to read in sensor config. Expecting %d (0x%03X) bytes as %d\n", size, size, size * 2);
cliPortPrintF("hexadecimal characters, optionally separated by [ \\n\\r_].\n");
cliPortPrintF("Times out if no character is received for %dms\n", TIMEOUT);
memset(p, 0, end - p);
while (p < end)
{
while (!cliPortAvailable() && millis() - time < TIMEOUT) {}
time = millis();
c = cliPortAvailable() ? cliPortRead() : '\0';
int8_t hex = parse_hex(c);
int ignore = c == ' ' || c == '\n' || c == '\r' || c == '_' ? true : false;
if (c != '\0') // assume the person isn't sending null chars
charsEncountered++;
if (ignore)
continue;
if (hex == -1)
break;
*p |= secondNibble ? hex : hex << 4;
p += secondNibble;
secondNibble ^= 1;
}
if (c == 0)
{
cliPortPrintF("Did not receive enough hex chars! (got %d, expected %d)\n",
(p - (uint8_t*)&sensorRam) * 2 + secondNibble, size * 2);
}
else if (p < end || secondNibble)
{
cliPortPrintF("Invalid character found at position %d: '%c' (0x%02x)",
charsEncountered, c, c);
}
// HJI else if (crcCheckVal != crc32B((uint32_t*)(&sensorConfig), // CRC32B[sensorConfig CRC32B[sensorConfig]]
// HJI (uint32_t*)(&sensorConfig + 1)))
// HJI {
// HJI cliPortPrintF("CRC mismatch! Not writing to in-memory config.\n");
// HJI cliPortPrintF("Here's what was received:\n\n");
// HJI cliPrintSensorEEPROM();
// HJI }
else
{
// check to see if the newly received sytem config
// actually differs from what's in-memory
for (i = 0; i < size; i++)
if (((uint8_t*)&sensorRam)[i] != ((uint8_t*)&sensorConfig)[i])
break;
if (i == size)
{
cliPortPrintF("NOTE: Uploaded Sensor Config was Identical to RAM Config.\n");
}
else
{
sensorConfig = sensorRam;
cliPortPrintF("Sensor RAM Config updated!\n");
cliPortPrintF("NOTE: Sensor Config not written to EEPROM; use 'w' to do so.\n");
}
}
// eat the next 100ms (or whatever Timeout is) of characters,
// in case the person pasted too much by mistake or something
time = millis();
while (millis() - time < TIMEOUT)
if (cliPortAvailable())
cliPortRead();
validQuery = false;
break;
///////////////////////////
case 'h': // Clear Bad Sensor History Flag
cliPortPrintF("Clearing Bad Sensor History Flag.\n");
sensorConfig.CRCFlags &= ~CRC_HistoryBad;
validQuery = false;
break;
///////////////////////////
case 'v': // Reset Sensor EEPROM Parameters
cliPortPrint( "\nSensor EEPROM Parameters Reset....(not rebooting)\n" );
checkSensorEEPROM(true);
validQuery = false;
break;
///////////////////////////
case 'w': // Write to Sensor EEPROM
cliPortPrint("\nWriting Sensor EEPROM Parameters....\n");
writeSensorEEPROM();
validQuery = false;
break;
///////////////////////////
case 'x': // exit EEPROM CLI
cliPortPrint("\nExiting EEPROM CLI....\n\n");
cliBusy = false;
return;
break;
///////////////////////////
case 'A': // config struct data
c1 = systemConfig.CRCAtEnd[0];
zeroPIDstates();
c2 = crc32B((uint32_t*)(&systemConfig), // CRC32B[systemConfig]
(uint32_t*)(&systemConfig.CRCAtEnd));
cliPortPrintF("System EEPROM structure information:\n");
cliPortPrintF("Version : %d\n", systemConfig.version);
cliPortPrintF("Size : %d\n", sizeof(systemConfig));
cliPortPrintF("CRC on last read : %08X\n", c1);
cliPortPrintF("Current CRC : %08X\n", c2);
if ( c1 != c2 )
cliPortPrintF(" CRCs differ. Current SystemConfig has not yet been saved.\n");
cliPortPrintF("CRC Flags :\n");
cliPortPrintF(" History Bad : %s\n", systemConfig.CRCFlags & CRC_HistoryBad ? "true" : "false" );
validQuery = false;
break;
///////////////////////////
case 'B': // Write out to Console in Hex. (RAM -> console)
// we assume the flyer is not in the air, so that this is ok;
// these change randomly when not in flight and can mistakenly
// make one think that the in-memory eeprom struct has changed
zeroPIDstates();
cliPortPrintF("\n");
cliPrintSystemConfig();
cliPortPrintF("\n");
if (crcCheckVal != crc32B((uint32_t*)(&systemConfig), // CRC32B[systemConfig CRC32B[systemConfig]]
(uint32_t*)(&systemConfig + 1)))
{
cliPortPrint("NOTE: in-memory system config CRC invalid; there have probably been\n");
cliPortPrint(" changes to system config since the last write to flash/eeprom.\n");
}
validQuery = false;
break;
///////////////////////////
case 'C': // Read System Config -> RAM
cliPortPrint("Re-reading System EEPROM.\n");
readSystemEEPROM();
validQuery = false;
break;
///////////////////////////
case 'D': // Read Console -> System RAM
charsEncountered = 0;
secondNibble = 0;
size = sizeof(systemConfig);
time = millis();
p = (uint8_t*)&systemRam;
end = (uint8_t*)(&systemRam + 1);
///////////////////////
cliPortPrintF("Ready to read in system config. Expecting %d (0x%03X) bytes as %d\n", size, size, size * 2);
cliPortPrintF("hexadecimal characters, optionally separated by [ \\n\\r_].\n");
cliPortPrintF("Times out if no character is received for %dms\n", TIMEOUT);
memset(p, 0, end - p);
while (p < end)
{
while (!cliPortAvailable() && millis() - time < TIMEOUT) {}
time = millis();
c = cliPortAvailable() ? cliPortRead() : '\0';
int8_t hex = parse_hex(c);
int ignore = c == ' ' || c == '\n' || c == '\r' || c == '_' ? true : false;
if (c != '\0') // assume the person isn't sending null chars
charsEncountered++;
if (ignore)
continue;
if (hex == -1)
break;
*p |= secondNibble ? hex : hex << 4;
p += secondNibble;
secondNibble ^= 1;
}
if (c == 0)
{
cliPortPrintF("Did not receive enough hex chars! (got %d, expected %d)\n",
(p - (uint8_t*)&systemRam) * 2 + secondNibble, size * 2);
}
else if (p < end || secondNibble)
{
cliPortPrintF("Invalid character found at position %d: '%c' (0x%02x)",
charsEncountered, c, c);
}
// HJI else if (crcCheckVal != crc32B((uint32_t*)(&systemConfig), // CRC32B[systemConfig CRC32B[systemConfig]]
// HJI (uint32_t*)(&systemConfig + 1)))
// HJI {
// HJI cliPortPrintF("CRC mismatch! Not writing to in-memory config.\n");
// HJI cliPortPrintF("Here's what was received:\n\n");
// HJI cliPrintSystemConfig();
// HJI }
else
{
// check to see if the newly received sytem config
// actually differs from what's in-memory
zeroPIDstates();
for (i = 0; i < size; i++)
if (((uint8_t*)&systemRam)[i] != ((uint8_t*)&systemConfig)[i])
break;
if (i == size)
{
cliPortPrintF("NOTE: Uploaded System Config was Identical to RAM Config.\n");
}
else
{
systemConfig = systemRam;
cliPortPrintF("System RAM Config updated!\n");
cliPortPrintF("NOTE: System Config not written to EEPROM; use 'W' to do so.\n");
}
}
// eat the next 100ms (or whatever Timeout is) of characters,
// in case the person pasted too much by mistake or something
time = millis();
while (millis() - time < TIMEOUT)
if (cliPortAvailable())
cliPortRead();
validQuery = false;
break;
///////////////////////////
case 'H': // Clear Bad System History Flag
cliPortPrintF("Clearing Bad System History Flag.\n");
systemConfig.CRCFlags &= ~CRC_HistoryBad;
validQuery = false;
break;
///////////////////////////
case 'V': // Reset System EEPROM Parameters
cliPortPrint( "\nSystem EEPROM Parameters Reset....(not rebooting)\n" );
checkSystemEEPROM(true);
validQuery = false;
break;
///////////////////////////
case 'W': // Write out to System EEPROM
cliPortPrint("\nWriting System EEPROM Parameters....\n");
writeSystemEEPROM();
validQuery = false;
break;
///////////////////////////
case '?':
// 0 1 2 3 4 5 6 7
// 01234567890123456789012345678901234567890123456789012345678901234567890123456789
cliPortPrintF("\n");
cliPortPrintF("'a' Display Sensor Config Information 'A' Display System Config Information\n");
cliPortPrintF("'b' Write Sensor Config -> Console 'B' Write System Config - > Console\n");
cliPortPrintF("'c' Read Sensor Config -> RAM 'C' Read System Config -> RAM\n");
cliPortPrintF("'d' Read Console -> Sensor RAM 'D' Read Console -> System RAM\n");
cliPortPrintF("'h' Clear Sensor CRC Bad History flag 'H' Clear System CRC Bad History flag\n");
cliPortPrintF("'v' Reset Sensor Config to Default 'V' Reset System Config to Default\n");
cliPortPrintF("'w' Write Sensor Config -> EEPROM 'W' Write System Config -> EEPROM\n");
cliPortPrintF("'x' Exit EEPROM CLI '?' Command Summary\n");
cliPortPrintF("\n");
break;
///////////////////////////
}
}
}
void writeSystemEEPROM(void)
{
uint16_t byteCount;
uint8_t pageIndex;
uint8_t* start = (uint8_t*)(&systemConfig);
uint8_t* end = (uint8_t*)(&systemConfig + 1);
///////////////////////////////////
// there's no reason to write these values to EEPROM, they'll just be noise
zeroPIDstates();
if (systemConfig.CRCFlags & CRC_HistoryBad)
evrPush(EVR_ConfigBadSystemHistory,0);
systemConfig.CRCAtEnd[0] = crc32B((uint32_t*)(&systemConfig), // CRC32B[systemConfig]
(uint32_t*)(&systemConfig.CRCAtEnd));
///////////////////////////////////
setSPIdivisor(EEPROM_SPI, 2); // 18 MHz SPI clock
systemConfigaddr.value = SYSTEM_EEPROM_ADDR;
///////////////////////////////////
// Sector Erase
writeEnable();
ENABLE_EEPROM;
spiTransfer(EEPROM_SPI, SECTOR_ERASE_64KB);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[2]);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[1]);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[0]);
DISABLE_EEPROM;
delayMicroseconds(2);
eepromBusy();
///////////////////////////////////
// Program Page(s)
for (pageIndex = 0; pageIndex < ((sizeof(systemConfig) / 256) + 1); pageIndex++)
{
writeEnable();
ENABLE_EEPROM;
spiTransfer(EEPROM_SPI, PAGE_PROGRAM_256_BYTES);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[2]);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[1]);
spiTransfer(EEPROM_SPI, systemConfigaddr.bytes[0]);
for (byteCount = 0; byteCount < 256; byteCount++)
{
spiTransfer(EEPROM_SPI, *start++);
if (start >= end)
break;
}
DISABLE_EEPROM;
delayMicroseconds(2);
eepromBusy();
systemConfigaddr.value += 0x0100;
}
readSystemEEPROM();
}
void writeSensorEEPROM(void)
{
uint16_t byteCount;
uint8_t pageIndex;
uint8_t* start = (uint8_t*)(&sensorConfig);
uint8_t* end = (uint8_t*)(&sensorConfig + 1);
///////////////////////////////////
if (sensorConfig.CRCFlags & CRC_HistoryBad)
evrPush(EVR_ConfigBadSensorHistory,0);
sensorConfig.CRCAtEnd[0] = crc32B((uint32_t*)(&sensorConfig), // CRC32B[sensorConfig]
(uint32_t*)(&sensorConfig.CRCAtEnd));
///////////////////////////////////
setSPIdivisor(EEPROM_SPI, 2); // 18 MHz SPI clock
sensorConfigAddr.value = SENSOR_EEPROM_ADDR;
///////////////////////////////////
// Sector Erase
writeEnable();
ENABLE_EEPROM;
spiTransfer(EEPROM_SPI, SECTOR_ERASE_64KB);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[2]);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[1]);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[0]);
DISABLE_EEPROM;
delayMicroseconds(2);
eepromBusy();
///////////////////////////////////
// Program Page(s)
for (pageIndex = 0; pageIndex < ((sizeof(sensorConfig) / 256) + 1); pageIndex++)
{
writeEnable();
ENABLE_EEPROM;
spiTransfer(EEPROM_SPI, PAGE_PROGRAM_256_BYTES);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[2]);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[1]);
spiTransfer(EEPROM_SPI, sensorConfigAddr.bytes[0]);
for (byteCount = 0; byteCount < 256; byteCount++)
{
spiTransfer(EEPROM_SPI, *start++);
if (start >= end)
break;
}
DISABLE_EEPROM;
delayMicroseconds(2);
eepromBusy();
sensorConfigAddr.value += 0x0100;
}
readSensorEEPROM();
}
uint8_t writeEEPROM(void)
{
FLASH_Status status;
int32_t i;
///////////////////////////////////
if (eepromConfig.receiverType == SPEKTRUM)
{
USART_Cmd(USART6, DISABLE);
TIM_Cmd(TIM6, DISABLE);
if (eepromConfig.slaveSpektrum == true)
USART_Cmd(UART4, DISABLE);
}
///////////////////////////////////
eepromConfig_t *src = &eepromConfig;
uint32_t *dst = (uint32_t*)FLASH_WRITE_EEPROM_ADDR;
if ( src->CRCFlags & CRC_HistoryBad )
evrPush(EVR_ConfigBadHistory,0);
src->CRCAtEnd = crc32B((uint32_t*)(&eepromConfig), // CRC32B[eepromConfig]
(uint32_t*)(&eepromConfig.CRCAtEnd));
///////////////////////////////////
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
status = FLASH_EraseSector(FLASH_Sector_1, VoltageRange_3);
///////////////////////////////////
i = -1;
while (FLASH_COMPLETE == status && i++ < eepromConfigSizeUint32)
status = FLASH_ProgramWord((uint32_t)&dst[i], ((uint32_t*)src)[i]);
if ( FLASH_COMPLETE != status )
evrPush( -1 == i ? EVR_FlashEraseFail : EVR_FlashProgramFail, status);
///////////////////////////////////
FLASH_Lock();
readEEPROM();
///////////////////////////////////
if (eepromConfig.receiverType == SPEKTRUM)
{
primarySpektrumState.reSync = 1;
TIM_Cmd(TIM6, ENABLE);
USART_Cmd(USART6, ENABLE);
if (eepromConfig.slaveSpektrum == true)
{
slaveSpektrumState.reSync = 1;
USART_Cmd(UART4, ENABLE);
}
}
///////////////////////////////////
return status;
}
uint8_t writeEEPROM(void)
{
FLASH_Status status;
int32_t i;
///////////////////////////////////
if (eepromConfig.receiverType == SPEKTRUM)
{
USART_Cmd(USART2, DISABLE);
TIM_Cmd(TIM2, DISABLE);
}
///////////////////////////////////
eepromConfig_t *src = &eepromConfig;
uint32_t *dst = (uint32_t*)FLASH_WRITE_EEPROM_ADDR;
// there's no reason to write these values to EEPROM, they'll just be noise
zeroPIDstates();
if (src->CRCFlags & CRC_HistoryBad)
evrPush(EVR_ConfigBadHistory,0);
src->CRCAtEnd[0] = crc32B( (uint32_t*)&src[0], src->CRCAtEnd);
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPRTERR);
status = FLASH_ErasePage(FLASH_WRITE_EEPROM_ADDR);
///////////////////////////////////
i = -1;
while (status == FLASH_COMPLETE && i++ < eepromConfigNUMWORD)
status = FLASH_ProgramWord((uint32_t)&dst[i], ((uint32_t*)src)[i]);
if (status != FLASH_COMPLETE)
evrPush( i == -1 ? EVR_FlashEraseFail : EVR_FlashProgramFail, status);
///////////////////////////////////
FLASH_Lock();
readEEPROM();
///////////////////////////////////
if (eepromConfig.receiverType == SPEKTRUM)
{
primarySpektrumState.reSync = 1;
TIM_Cmd(TIM2, ENABLE);
USART_Cmd(USART2, ENABLE);
}
///////////////////////////////////
return status;
}
