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; }