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 processFlightCommands(void)
{
uint8_t channel;
if ( rcActive == true )
{
// Read receiver commands
for (channel = 0; channel < 8; channel++)
rxCommand[channel] = (float)rxRead(eepromConfig.rcMap[channel]);
rxCommand[ROLL] -= eepromConfig.midCommand; // Roll Range -1000:1000
rxCommand[PITCH] -= eepromConfig.midCommand; // Pitch Range -1000:1000
rxCommand[YAW] -= eepromConfig.midCommand; // Yaw Range -1000:1000
rxCommand[THROTTLE] -= eepromConfig.midCommand - MIDCOMMAND; // Throttle Range 2000:4000
rxCommand[AUX1] -= eepromConfig.midCommand - MIDCOMMAND; // Aux1 Range 2000:4000
rxCommand[AUX2] -= eepromConfig.midCommand - MIDCOMMAND; // Aux2 Range 2000:4000
rxCommand[AUX3] -= eepromConfig.midCommand - MIDCOMMAND; // Aux3 Range 2000:4000
rxCommand[AUX4] -= eepromConfig.midCommand - MIDCOMMAND; // Aux4 Range 2000:4000
}
// Set past command in detent values
for (channel = 0; channel < 3; channel++)
previousCommandInDetent[channel] = commandInDetent[channel];
// Apply deadbands and set detent discretes'
for (channel = 0; channel < 3; channel++)
{
if ((rxCommand[channel] <= DEADBAND) && (rxCommand[channel] >= -DEADBAND))
{
rxCommand[channel] = 0;
commandInDetent[channel] = true;
}
else
{
commandInDetent[channel] = false;
if (rxCommand[channel] > 0)
{
rxCommand[channel] = (rxCommand[channel] - DEADBAND) * DEADBAND_SLOPE;
}
else
{
rxCommand[channel] = (rxCommand[channel] + DEADBAND) * DEADBAND_SLOPE;
}
}
}
///////////////////////////////////
// Check for low throttle
if ( rxCommand[THROTTLE] < eepromConfig.minCheck )
{
// Check for disarm command ( low throttle, left yaw ), will disarm immediately
if ( (rxCommand[YAW] < (eepromConfig.minCheck - MIDCOMMAND)) && (armed == true) )
{
armed = false;
zeroPIDintegralError();
zeroPIDstates();
}
// Check for gyro bias command ( low throttle, left yaw, aft pitch, right roll )
if ( (rxCommand[YAW ] < (eepromConfig.minCheck - MIDCOMMAND)) &&
(rxCommand[ROLL ] > (eepromConfig.maxCheck - MIDCOMMAND)) &&
(rxCommand[PITCH] < (eepromConfig.minCheck - MIDCOMMAND)) )
{
computeMPU6000RTData();
pulseMotors(3);
}
// Check for arm command ( low throttle, right yaw), must be present for 1 sec before arming
if ((rxCommand[YAW] > (eepromConfig.maxCheck - MIDCOMMAND) ) && (armed == false) && (execUp == true))
{
armingTimer++;
if ( armingTimer > 50 )
{
zeroPIDintegralError();
zeroPIDstates();
armed = true;
armingTimer = 0;
}
}
else
{
armingTimer = 0;
}
}
///////////////////////////////////
// Check for armed true and throttle command > minThrottle
if ((armed == true) && (rxCommand[THROTTLE] > eepromConfig.minThrottle))
holdIntegrators = false;
else
holdIntegrators = true;
///////////////////////////////////
// Check AUX1 for rate, attitude, or GPS mode (3 Position Switch) NOT COMPLETE YET....
if ((rxCommand[AUX1] > MIDCOMMAND) && (flightMode == RATE))
{
flightMode = ATTITUDE;
setPIDintegralError(ROLL_ATT_PID, 0.0f);
setPIDintegralError(PITCH_ATT_PID, 0.0f);
setPIDintegralError(HEADING_PID, 0.0f);
setPIDstates(ROLL_ATT_PID, 0.0f);
setPIDstates(PITCH_ATT_PID, 0.0f);
setPIDstates(HEADING_PID, 0.0f);
}
else if ((rxCommand[AUX1] <= MIDCOMMAND) && (flightMode == ATTITUDE))
{
flightMode = RATE;
setPIDintegralError(ROLL_RATE_PID, 0.0f);
setPIDintegralError(PITCH_RATE_PID, 0.0f);
setPIDintegralError(YAW_RATE_PID, 0.0f);
setPIDstates(ROLL_RATE_PID, 0.0f);
setPIDstates(PITCH_RATE_PID, 0.0f);
setPIDstates(YAW_RATE_PID, 0.0f);
}
///////////////////////////////////
if ((commandInDetent[YAW] == true) && (flightMode == ATTITUDE))
headingHoldEngaged = true;
else
headingHoldEngaged = false;
///////////////////////////////////
// Check AUX2 for altitude hold mode (2 Position Switch)
if ((rxCommand[AUX2] > MIDCOMMAND) && (previousAUX2State <= MIDCOMMAND)) // Rising edge detection
{
altitudeHoldState = ENGAGED;
altitudeHoldThrottleValue = rxCommand[THROTTLE];
}
else if ((rxCommand[AUX2] <= MIDCOMMAND) && (previousAUX2State > MIDCOMMAND)) // Falling edge detection
{
altitudeHoldState = DISENGAGED;
}
previousAUX2State = rxCommand[AUX2];
///////////////////////////////////
}
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 processFlightCommands(void)
{
uint8_t channel;
if (rcActive == true)
{
// Read receiver commands
for (channel = 0; channel < 8; channel++)
{
if (eepromConfig.receiverType == SPEKTRUM)
rxCommand[channel] = (float)spektrumRead(eepromConfig.rcMap[channel]);
else
rxCommand[channel] = (float)ppmRxRead(eepromConfig.rcMap[channel]);
}
rxCommand[ROLL] -= eepromConfig.midCommand; // Roll Range -1000:1000
rxCommand[PITCH] -= eepromConfig.midCommand; // Pitch Range -1000:1000
rxCommand[YAW] -= eepromConfig.midCommand; // Yaw Range -1000:1000
rxCommand[THROTTLE] -= eepromConfig.midCommand - MIDCOMMAND; // Throttle Range 2000:4000
rxCommand[AUX1] -= eepromConfig.midCommand - MIDCOMMAND; // Aux1 Range 2000:4000
rxCommand[AUX2] -= eepromConfig.midCommand - MIDCOMMAND; // Aux2 Range 2000:4000
rxCommand[AUX3] -= eepromConfig.midCommand - MIDCOMMAND; // Aux3 Range 2000:4000
rxCommand[AUX4] -= eepromConfig.midCommand - MIDCOMMAND; // Aux4 Range 2000:4000
}
// Set past command in detent values
for (channel = 0; channel < 3; channel++)
previousCommandInDetent[channel] = commandInDetent[channel];
// Apply deadbands and set detent discretes'
for (channel = 0; channel < 3; channel++)
{
if ((rxCommand[channel] <= DEADBAND) && (rxCommand[channel] >= -DEADBAND))
{
rxCommand[channel] = 0;
commandInDetent[channel] = true;
}
else
{
commandInDetent[channel] = false;
if (rxCommand[channel] > 0)
{
rxCommand[channel] = (rxCommand[channel] - DEADBAND) * DEADBAND_SLOPE;
}
else
{
rxCommand[channel] = (rxCommand[channel] + DEADBAND) * DEADBAND_SLOPE;
}
}
}
///////////////////////////////////
// Check for low throttle
if ( rxCommand[THROTTLE] < eepromConfig.minCheck )
{
// Check for disarm command ( low throttle, left yaw )
if (((rxCommand[YAW] < (eepromConfig.minCheck - MIDCOMMAND)) && (armed == true)) && (verticalModeState == ALT_DISENGAGED_THROTTLE_ACTIVE))
{
disarmingTimer++;
if (disarmingTimer > eepromConfig.disarmCount)
{
zeroPIDintegralError();
zeroPIDstates();
armed = false;
disarmingTimer = 0;
}
}
else
{
disarmingTimer = 0;
}
// Check for gyro bias command ( low throttle, left yaw, aft pitch, right roll )
if ( (rxCommand[YAW ] < (eepromConfig.minCheck - MIDCOMMAND)) &&
(rxCommand[ROLL ] > (eepromConfig.maxCheck - MIDCOMMAND)) &&
(rxCommand[PITCH] < (eepromConfig.minCheck - MIDCOMMAND)) )
{
computeMPU6000RTData();
pulseMotors(3);
}
// Check for arm command ( low throttle, right yaw)
if ((rxCommand[YAW] > (eepromConfig.maxCheck - MIDCOMMAND) ) && (armed == false) && (execUp == true))
{
armingTimer++;
if (armingTimer > eepromConfig.armCount)
{
zeroPIDintegralError();
zeroPIDstates();
armed = true;
armingTimer = 0;
}
}
else
{
armingTimer = 0;
}
}
///////////////////////////////////
// Check for armed true and throttle command > minThrottle
if ((armed == true) && (rxCommand[THROTTLE] > eepromConfig.minThrottle))
holdIntegrators = false;
else
holdIntegrators = true;
///////////////////////////////////
// Check AUX1 for rate, attitude, or GPS mode (3 Position Switch) NOT COMPLETE YET....
if ((rxCommand[AUX1] > MIDCOMMAND) && (flightMode == RATE))
{
flightMode = ATTITUDE;
setPIDintegralError(ROLL_ATT_PID, 0.0f);
setPIDintegralError(PITCH_ATT_PID, 0.0f);
setPIDintegralError(HEADING_PID, 0.0f);
setPIDstates(ROLL_ATT_PID, 0.0f);
setPIDstates(PITCH_ATT_PID, 0.0f);
setPIDstates(HEADING_PID, 0.0f);
}
else if ((rxCommand[AUX1] <= MIDCOMMAND) && (flightMode == ATTITUDE))
{
flightMode = RATE;
setPIDintegralError(ROLL_RATE_PID, 0.0f);
setPIDintegralError(PITCH_RATE_PID, 0.0f);
setPIDintegralError(YAW_RATE_PID, 0.0f);
setPIDstates(ROLL_RATE_PID, 0.0f);
setPIDstates(PITCH_RATE_PID, 0.0f);
setPIDstates(YAW_RATE_PID, 0.0f);
}
///////////////////////////////////
// Check yaw in detent and flight mode to determine hdg hold engaged state
if ((commandInDetent[YAW] == true) && (flightMode == ATTITUDE) && (headingHoldEngaged == false))
{
headingHoldEngaged = true;
setPIDintegralError(HEADING_PID, 0.0f);
setPIDstates(YAW_RATE_PID, 0.0f);
headingReference = heading.mag;
}
if (((commandInDetent[YAW] == false) || (flightMode != ATTITUDE)) && (headingHoldEngaged == true))
{
headingHoldEngaged = false;
}
///////////////////////////////////
// Vertical Mode Command Processing
verticalReferenceCommand = rxCommand[THROTTLE] - eepromConfig.midCommand;
// Set past altitude reference in detent value
previousVertRefCmdInDetent = vertRefCmdInDetent;
// Apply deadband and set detent discrete'
if ((verticalReferenceCommand <= ALT_DEADBAND) && (verticalReferenceCommand >= -ALT_DEADBAND))
{
verticalReferenceCommand = 0;
vertRefCmdInDetent = true;
}
else
{
vertRefCmdInDetent = false;
if (verticalReferenceCommand > 0)
{
verticalReferenceCommand = (verticalReferenceCommand - ALT_DEADBAND) * ALT_DEADBAND_SLOPE;
}
else
{
verticalReferenceCommand = (verticalReferenceCommand + ALT_DEADBAND) * ALT_DEADBAND_SLOPE;
}
}
///////////////////////////////////
// Vertical Mode State Machine
switch (verticalModeState)
{
case ALT_DISENGAGED_THROTTLE_ACTIVE:
if ((rxCommand[AUX2] > MIDCOMMAND) && (previousAUX2State <= MIDCOMMAND)) // AUX2 Rising edge detection
{
verticalModeState = ALT_HOLD_FIXED_AT_ENGAGEMENT_ALT;
setPIDintegralError(HDOT_PID, 0.0f);
setPIDintegralError(H_PID, 0.0f);
setPIDstates(HDOT_PID, 0.0f);
setPIDstates(H_PID, 0.0f);
altitudeHoldReference = hEstimate;
throttleReference = rxCommand[THROTTLE];
}
break;
///////////////////////////////
case ALT_HOLD_FIXED_AT_ENGAGEMENT_ALT:
if ((vertRefCmdInDetent == true) || eepromConfig.verticalVelocityHoldOnly)
verticalModeState = ALT_HOLD_AT_REFERENCE_ALTITUDE;
if ((rxCommand[AUX2] <= MIDCOMMAND) && (previousAUX2State > MIDCOMMAND)) // AUX2 Falling edge detection
verticalModeState = ALT_DISENGAGED_THROTTLE_INACTIVE;
if ((rxCommand[AUX4] > MIDCOMMAND) && (previousAUX4State <= MIDCOMMAND)) // AUX4 Rising edge detection
verticalModeState = ALT_DISENGAGED_THROTTLE_ACTIVE;
break;
///////////////////////////////
case ALT_HOLD_AT_REFERENCE_ALTITUDE:
if ((vertRefCmdInDetent == false) || eepromConfig.verticalVelocityHoldOnly)
verticalModeState = VERTICAL_VELOCITY_HOLD_AT_REFERENCE_VELOCITY;
if ((rxCommand[AUX2] <= MIDCOMMAND) && (previousAUX2State > MIDCOMMAND)) // AUX2 Falling edge detection
verticalModeState = ALT_DISENGAGED_THROTTLE_INACTIVE;
if ((rxCommand[AUX4] > MIDCOMMAND) && (previousAUX4State <= MIDCOMMAND)) // AUX4 Rising edge detection
verticalModeState = ALT_DISENGAGED_THROTTLE_ACTIVE;
break;
///////////////////////////////
case VERTICAL_VELOCITY_HOLD_AT_REFERENCE_VELOCITY:
if ((vertRefCmdInDetent == true) && !eepromConfig.verticalVelocityHoldOnly)
{
verticalModeState = ALT_HOLD_AT_REFERENCE_ALTITUDE;
altitudeHoldReference = hEstimate;
}
if ((rxCommand[AUX2] <= MIDCOMMAND) && (previousAUX2State > MIDCOMMAND)) // AUX2 Falling edge detection
{
verticalModeState = ALT_DISENGAGED_THROTTLE_INACTIVE;
altitudeHoldReference = hEstimate;
}
if ((rxCommand[AUX4] > MIDCOMMAND) && (previousAUX4State <= MIDCOMMAND)) // AUX4 Rising edge detection
verticalModeState = ALT_DISENGAGED_THROTTLE_ACTIVE;
break;
///////////////////////////////
case ALT_DISENGAGED_THROTTLE_INACTIVE:
if (((rxCommand[THROTTLE] < throttleCmd + THROTTLE_WINDOW) && (rxCommand[THROTTLE] > throttleCmd - THROTTLE_WINDOW)) ||
eepromConfig.verticalVelocityHoldOnly)
verticalModeState = ALT_DISENGAGED_THROTTLE_ACTIVE;
if ((rxCommand[AUX2] > MIDCOMMAND) && (previousAUX2State <= MIDCOMMAND)) // AUX2 Rising edge detection
verticalModeState = ALT_HOLD_FIXED_AT_ENGAGEMENT_ALT;
if ((rxCommand[AUX4] > MIDCOMMAND) && (previousAUX4State <= MIDCOMMAND)) // AUX4 Rising edge detection
verticalModeState = ALT_DISENGAGED_THROTTLE_ACTIVE;
break;
}
previousAUX2State = rxCommand[AUX2];
previousAUX4State = rxCommand[AUX4];
///////////////////////////////////
}
void eepromCLI()
{
uint32_t c1, c2;
uint8_t eepromQuery = 'x';
uint8_t validQuery = false;
cliBusy = true;
cliPrint("\nEntering EEPROM CLI....\n\n");
while(true)
{
cliPrint("EEPROM CLI -> ");
while ((cliAvailable() == false) && (validQuery == false));
if (validQuery == false)
eepromQuery = cliRead();
cliPrint("\n");
switch(eepromQuery)
{
// 'a' is the standard "print all the information" character
case 'a': // config struct data
c1 = eepromConfig.CRCAtEnd[0];
zeroPIDintegralError();
zeroPIDstates();
c2 = crc32bEEPROM(&eepromConfig, false);
cliPrintF("Config structure information:\n");
cliPrintF("Version : %d\n", eepromConfig.version );
cliPrintF("Size : %d\n", sizeof(eepromConfig) );
cliPrintF("CRC on last read : %08X\n", c1 );
cliPrintF("Current CRC : %08X\n", c2 );
if ( c1 != c2 )
cliPrintF(" CRCs differ. Current Config has not yet been saved.\n");
cliPrintF("CRC Flags :\n");
cliPrintF(" History Bad : %s\n", eepromConfig.CRCFlags & CRC_HistoryBad ? "true" : "false" );
validQuery = false;
break;
///////////////////////////
case 'c': // 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
zeroPIDintegralError();
zeroPIDstates();
cliPrintF("\n");
cliPrintEEPROM(&eepromConfig);
cliPrintF("\n");
if (crcCheckVal != crc32bEEPROM(&eepromConfig, true))
{
cliPrint("NOTE: in-memory config CRC invalid; there have probably been changes to\n");
cliPrint(" eepromConfig since the last write to flash/eeprom.\n");
}
validQuery = false;
break;
///////////////////////////
case 'H': // clear bad history flag
cliPrintF("Clearing Bad History flag.\n");
eepromConfig.CRCFlags &= ~CRC_HistoryBad;
validQuery = false;
break;
///////////////////////////
case 'C': // Read in from Console in hex. Console -> RAM
;
uint32_t sz = sizeof(eepromConfig);
eepromConfig_t e;
uint8_t *p = (uint8_t*)&e;
uint8_t *end = (uint8_t*)(&e + 1);
uint32_t t = millis();
enum { Timeout = 100 }; // timeout is in ms
int second_nibble = 0; // 0 or 1
char c;
uint32_t chars_encountered = 0;
cliPrintF("Ready to read in config. Expecting %d (0x%03X) bytes as %d\n",
sz, sz, sz * 2);
cliPrintF("hexadecimal characters, optionally separated by [ \\n\\r_].\n");
cliPrintF("Times out if no character is received for %dms\n", Timeout);
memset(p, 0, end - p);
while (p < end)
{
while (!cliAvailable() && millis() - t < Timeout) {}
t = millis();
c = cliAvailable() ? cliRead() : '\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
chars_encountered++;
if (ignore)
continue;
if (hex == -1)
break;
*p |= second_nibble ? hex : hex << 4;
p += second_nibble;
second_nibble ^= 1;
}
if (c == 0)
{
cliPrintF("Did not receive enough hex chars! (got %d, expected %d)\n",
(p - (uint8_t*)&e) * 2 + second_nibble, sz * 2);
}
else if (p < end || second_nibble)
{
cliPrintF("Invalid character found at position %d: '%c' (0x%02x)",
chars_encountered, c, c);
}
else if (crcCheckVal != crc32bEEPROM(&e, true))
{
cliPrintF("CRC mismatch! Not writing to in-memory config.\n");
cliPrintF("Here's what was received:\n\n");
cliPrintEEPROM(&e);
}
else
{
// check to see if the newly received eeprom config
// actually differs from what's in-memory
zeroPIDintegralError();
zeroPIDstates();
int i;
for (i = 0; i < sz; i++)
if (((uint8_t*)&e)[i] != ((uint8_t*)&eepromConfig)[i])
break;
if (i == sz)
{
cliPrintF("NOTE: uploaded config was identical to in-memory config.\n");
}
else
{
eepromConfig = e;
cliPrintF("In-memory config updated!\n");
cliPrintF("NOTE: 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
t = millis();
while (millis() - t < Timeout)
if (cliAvailable())
cliRead();
validQuery = false;
break;
///////////////////////////
case 'E': // Read in from EEPROM. (EEPROM -> RAM)
cliPrint("Re-reading EEPROM.\n");
readEEPROM();
validQuery = false;
break;
///////////////////////////
case 'x': // exit EEPROM CLI
cliPrint("\nExiting EEPROM CLI....\n\n");
cliBusy = false;
return;
break;
///////////////////////////
case 'W':
case 'e': // Write out to EEPROM. (RAM -> EEPROM)
cliPrint("\nWriting EEPROM Parameters....\n\n");
writeEEPROM();
validQuery = false;
break;
///////////////////////////
case 'f': // Write out to sdCard FILE. (RAM -> FILE)
validQuery = false;
break;
///////////////////////////
case 'F': // Read in from sdCard FILE. (FILE -> RAM)
validQuery = false;
break;
///////////////////////////
case 'V': // Reset EEPROM Parameters
cliPrint( "\nEEPROM Parameters Reset....(not rebooting)\n" );
checkFirstTime(true);
validQuery = false;
break;
///////////////////////////
case '?':
// 0 1 2 3 4 5 6 7
// 01234567890123456789012345678901234567890123456789012345678901234567890123456789
cliPrintF("\n");
cliPrintF("'a' Display in-RAM config information\n");
cliPrintF("'c' Write in-RAM -> Console (as Hex) 'C' Read Console (as Hex) -> in-RAM\n");
cliPrintF("'e' Write in-RAM -> EEPROM 'E' Read EEPROM -> in-RAM\n");
cliPrintF("'f' Write in-RAM -> sd FILE (Not yet imp) 'F' Read sd FILE -> in-RAM (Not imp)\n");
cliPrintF(" 'H' Clear CRC Bad History flag\n");
cliPrintF(" 'V' Reset in-RAM config to default.\n");
cliPrintF("'x' Exit EEPROM CLI '?' Command Summary\n");
cliPrintF("\n");
cliPrintF("For compatability: 'W' Write in-RAM -> EEPROM\n");
cliPrintF("\n");
break;
///////////////////////////
}
}
}
