Apple-2-HW
/
TommyPROM
mirror of https://github.com/TomNisbet/TommyPROM.git
2
0
Fork 1
Code Issues Projects Releases Wiki Activity
TommyPROM/TommyPROM/TommyPROM.ino

932 lines
24 KiB
C++
Raw Permalink Blame History

/**
* Read and write parallel EEPROMS with an interctive command-line interface.
* Modules are available for ATMEL 28C series EEPROMs and Intel 8755A EPROMS.
* Many other parallel EPROM/EEPROMs can be read, but not written, using the
* 28C code.
*
* The 28C module supports block writes for better performance and
* Software Data Protection (SDP) unlocking.
*
* ROM images are moved to and from a host computer using XMODEM. This is
* available in a number of terminal programs, such as TeraTerm and Minicom.
*
* The default hardware uses two 74LS164 shift registers as the low and
* high address registers.
**/
#include "Configure.h"
#include "CmdStatus.h"
#include "XModem.h"
static const char * MY_VERSION = "3.7";
// Global status
CmdStatus cmdStatus;
// Declare a global PROM device depending on the device type that is
// defined in Configure.h
#if defined(PROM_IS_28C)
// Define a device for a 28C256 EEPROM with the following parameters:
// 32K byte device capacity
// 64 byte block writes
// 10ms max write time
// Data polling supported
PromDevice28C prom(32 * 1024L, 64, 10, true);
//PromDevice28C prom(8 * 1024L, 0, 10, true); // 28C64 with no page writes
//PromDevice28C prom(2 * 1024L, 0, 10, true); // 28C16 with no page writes
#elif defined(PROM_IS_27)
// Define a device for a 2764 EPROM with the following parameters:
// 8K byte device capacity
// Program using dedicated WR pin
// 1000us (1ms) write pulse
// Max 15 write attempts
// 4x overwrite pulse (4 * writePulseLength * numberOfPulsesWritten)
// (true) verify data byte after writing
//PromDevice27 prom(8 * 1024L, E27C_PGM_WE, 1000L, 15, 4); // 2764 with SEEQ intelligent programming
//PromDevice27 prom(32 * 1024L, E27C_PGM_WE, 1000L, 25, 3); // 27C256 with SEEQ intelligent programming
PromDevice27 prom(32 * 1024L, E27C_PGM_CE, 100L, 25, 0); // M27C256 with Presto II intelligent programming
//PromDevice27 prom(32 * 1024L, E27C_PGM_CE, 1000L, 25, 3); // M27256 with fast programming
//PromDevice27 prom(2 * 1024L, E27C_PGM_WE, 50000L, 1, 0); // 2716 with single 50ms write
//PromDevice27 prom(512 * 1024L, E27C_PGM_CE, 100L, 11, 0); // 27C040 with Atmel rapid programming, CE connected to CE#/PGM#
//PromDevice27 prom(32 * 1024L, E27C_PGM_CE, 100L, 25, 0); // W27C257/W27E257 with 100uS program pulse on CE
//PromDevice27 prom(64 * 1024L, E27C_PGM_CE, 100L, 1, 0, false); // W27C512 with single 100uS program pulse on CE, no verify
//PromDevice27 prom(256 * 1024L, E27C_PGM_WE, 20L, 1, 0, false); // SST27SF020 with single 20us write, no verify
#elif defined(PROM_IS_SST39SF)
// Define a device for anSST39SF Flash with the following parameters:
// 512K byte device capacity
// 10us max write time
// Data polling supported
//PromDeviceSST39SF prom(128 * 1024L, 10, true); // SST39SF010
//PromDeviceSST39SF prom(256 * 1024L, 10, true); // SST39SF020
PromDeviceSST39SF prom(512 * 1024L, 10, true); // SST39SF040
#elif defined(PROM_IS_SST28SF)
// Define a device for anSST28SF Flash with the following parameters:
// 512K byte device capacity
// 40us max write time
// Data polling supported
PromDeviceSST28SF prom(512 * 1024L, 40, true);
#elif defined(PROM_IS_8755A)
// Define a device for an Intel 8755A with a fixed size of 2K and no other parameters.
PromDevice8755A prom(2 * 1024L);
#elif defined(PROM_IS_23)
PromDevice23 prom(2 * 1024L); // 2316
// Additional device-specific code goes here...
//#elif defined(PROM_IS...
#else
#error "Must define a PROM type in Configure.h"
#endif
// Global XModem driver
XModem xmodem(prom, cmdStatus);
/*****************************************************************************/
/*****************************************************************************/
/**
* CLI parse functions
*/
const char hex[] = "0123456789abcdef";
const uint32_t unspec = ~0;
inline uint32_t if_unspec(uint32_t val, uint32_t repl) { return val == unspec? repl: val; }
enum {
// CLI Commands
CMD_INVALID,
CMD_BLANK,
CMD_CHECKSUM,
CMD_DUMP,
CMD_ERASE,
CMD_FILL,
CMD_INFO,
CMD_LOCK,
CMD_POKE,
CMD_READ,
CMD_UNLOCK,
CMD_WRITE,
CMD_ZAP,
CMD_SCAN,
CMD_TEST,
CMD_PATTERN_FILL,
CMD_LAST_STATUS
};
// Read a line of data from the serial connection.
char * readLine(char * buffer, int len)
{
for (int ix = 0; (ix < len); ix++)
{
buffer[ix] = 0;
}
// read serial data until linebreak or buffer is full
char c = ' ';
int ix = 0;
do {
if (Serial.available())
{
c = Serial.read();
if ((c == '\b') && (ix > 0))
{
// Backspace, forget last character
--ix;
}
buffer[ix++] = c;
Serial.write(c);
}
} while ((c != '\n') && (c != '\r') && (ix < len));
buffer[ix - 1] = 0;
return buffer;
}
byte parseCommand(char c)
{
byte cmd = CMD_INVALID;
// Convert the command to lowercase.
if ((c >= 'A') && (c <= 'Z')) {
c |= 0x20;
}
switch (c)
{
case 'b': cmd = CMD_BLANK; break;
case 'c': cmd = CMD_CHECKSUM; break;
case 'd': cmd = CMD_DUMP; break;
case 'e': cmd = CMD_ERASE; break;
case 'f': cmd = CMD_FILL; break;
case 'i': cmd = CMD_INFO; break;
case 'l': cmd = CMD_LOCK; break;
case 'p': cmd = CMD_POKE; break;
case 'r': cmd = CMD_READ; break;
case 'u': cmd = CMD_UNLOCK; break;
case 'w': cmd = CMD_WRITE; break;
case 'z': cmd = CMD_ZAP; break;
case 's': cmd = CMD_SCAN; break;
case 't': cmd = CMD_TEST; break;
case '!': cmd = CMD_PATTERN_FILL;break;
case '/': cmd = CMD_LAST_STATUS; break;
default: cmd = CMD_INVALID; break;
}
return cmd;
}
/************************************************************
* convert a single hex character [0-9a-fA-F] to its value
* @param char c single character (digit)
* @return byte value of the digit (0-15)
************************************************************/
byte hexDigit(char c)
{
if ((c >= '0') && (c <= '9'))
{
return c - '0';
}
else if ((c >= 'a') && (c <= 'f'))
{
return c - 'a' + 10;
}
else if ((c >= 'A') && (c <= 'F'))
{
return c - 'A' + 10;
}
else
{
return 0xff;
}
}
/************************************************************
* Convert a hex string to a uint32_t value.
* Skips leading spaces and terminates on the first non-hex
* character. Leading zeroes are not required.
*
* No error checking is performed - if no hex is found then
* defaultValue is returned. Similarly, a hex string of more than
* 8 digits will return the value of the last 8 digits.
* @param pointer to string with the hex value of the word (modified)
* @return unsigned int represented by the digits
************************************************************/
uint32_t getHex32(char *& pData, uint32_t defaultValue=unspec)
{
uint32_t u32 = 0;
while (isspace(*pData))
{
++pData;
}
if (isxdigit(*pData))
{
while (isxdigit(*pData)) {
u32 = (u32 << 4) | hexDigit(*pData++);
}
}
else
{
u32 = defaultValue;
}
return u32;
}
void printByte(byte b)
{
char line[3];
line[0] = hex[b >> 4];
line[1] = hex[b & 0x0f];
line[2] = '\0';
Serial.print(line);
}
void printWord(word w)
{
char line[5];
line[0] = hex[(w >> 12) & 0x0f];
line[1] = hex[(w >> 8) & 0x0f];
line[2] = hex[(w >> 4) & 0x0f];
line[3] = hex[(w) & 0x0f];
line[4] = '\0';
Serial.print(line);
}
/*
* Prints a 32 bit value as a hex.
*
* Note that no values over 5 digits are used in
* this appication, so only 5 digits are printed.*/
void printHex32(uint32_t u32)
{
char line[6];
line[0] = hex[(u32 >> 16) & 0x0f];
line[1] = hex[(u32 >> 12) & 0x0f];
line[2] = hex[(u32 >> 8) & 0x0f];
line[3] = hex[(u32 >> 4) & 0x0f];
line[4] = hex[(u32) & 0x0f];
line[5] = '\0';
Serial.print(line);
}
// If the user presses a key then pause until they press another. Return true if
// Ctrl-C is pressed.
bool checkForBreak()
{
if (Serial.available())
{
if (Serial.read() == 0x03)
{
return true;
}
while (!Serial.available())
{}
if (Serial.read() == 0x03)
{
return true;
}
}
return false;
}
/*****************************************************************************/
/*****************************************************************************/
/**
* Command implementations
*/
/**
* Compute a 16 bit checksum from PROM data
*
* Note that this always reads an even number of bytes from the
* device and will read one byte beyond the specified end
* address if an odd number of bytes is specified by start and
* end.
*/
word checksumBlock(uint32_t start, uint32_t end)
{
word checksum = 0;
#if 1
for (uint32_t addr = start; (addr <= end); addr += 2)
{
word w = prom.readData(addr);
w <<= 8;
w |= prom.readData(addr + 1);
checksum += w;
}
#else
uint16_t crc = 0xffff;
for (uint32_t addr = start; (addr <= end); addr++)
{
crc = crc ^ (uint16_t(prom.readData(addr)) << 8);
for (int ix = 0; (ix < 8); ix++)
{
if (crc & 0x8000)
{
crc = (crc << 1) ^ 0x1021;
}
else
{
crc <<= 1;
}
}
}
checksum = crc;
#endif
return checksum;
}
/**
* Read data from the device and dump it in hex and ascii.
**/
uint32_t dumpBlock(uint32_t start, uint32_t end)
{
char line[81];
// 01234567891 234567892 234567893 234567894 234567895 234567896 234567897 23456789
// 01234: 01 23 45 67 89 ab cf ef 01 23 45 67 89 ab cd ef 1.2.3.4. 5.6.7.8.
int count = 0;
memset(line, ' ', sizeof(line));
char * pHex = line;
char * pChar = line + 59;
for (uint32_t addr = start; (addr <= end); addr++)
{
if (count == 0)
{
//print out the address at the beginning of the line
pHex = line;
pChar = line + 59;
*pHex++ = hex[(addr >> 16) & 0x0f];
*pHex++ = hex[(addr >> 12) & 0x0f];
*pHex++ = hex[(addr >> 8) & 0x0f];
*pHex++ = hex[(addr >> 4) & 0x0f];
*pHex++ = hex[(addr) & 0x0f];
*pHex++ = ':';
*pHex++ = ' ';
}
byte data = prom.readData(addr);
*pHex++ = hex[data >> 4];
*pHex++ = hex[data & 0x0f];
*pHex++ = ' ';
*pChar++ = ((data < 32) | (data >= 127)) ? '.' : data;
if ((count & 3) == 3)
{
*pHex++ = ' ';
}
if ((count & 7) == 7)
{
*pChar++ = ' ';
}
if ((++count >= 16) || (addr == end))
{
*pChar = '\0';
Serial.println(line);
if (checkForBreak())
{
return addr;
}
memset(line, ' ', sizeof(line));
count = 0;
}
}
if (count)
{
Serial.println();
}
return end+1;
}
/**
* Fill a block of PROM data with a single value.
*
* @param start - start address
* @param end - end address
* @param val - data byte to write to all addresses
*/
void fillBlock(uint32_t start, uint32_t end, byte val)
{
enum { BLOCK_SIZE = 32 };
byte block[BLOCK_SIZE];
for (int ix = 0; ix < BLOCK_SIZE; ix++)
{
block[ix] = val;
}
for (uint32_t addr = start; (addr <= end); addr += BLOCK_SIZE)
{
uint32_t writeLen = ((end - addr + 1) < BLOCK_SIZE) ? (end - addr + 1) : uint32_t(BLOCK_SIZE);
if (!prom.writeData(block, writeLen, addr))
{
cmdStatus.error("Write failed");
return;
}
}
}
/**
* Verify that a block of PROM contains the all FF erased value.
*
* @param start - start address
* @param end - end address
*/
void erasedBlockCheck(uint32_t start, uint32_t end)
{
for (uint32_t addr = start; (addr <= end); addr ++)
{
byte val = prom.readData(addr);
if (val != 0xff)
{
cmdStatus.error("Block is not erased");
cmdStatus.setValueHex(0, "addr", addr);
cmdStatus.setValueHex(1, "value", val);
return;
}
}
cmdStatus.info("Block is erased");
}
/**
* Write a series of bytes from the command line to the PROM.
*
* @param cursor - pointer to command line text
*/
void pokeBytes(char * pCursor)
{
uint32_t val;
uint32_t start;
unsigned byteCtr = 0;
enum { BLOCK_SIZE = 32 };
byte data[BLOCK_SIZE];
//first value returned is the starting address
start = getHex32(pCursor, 0);
while (((val = getHex32(pCursor)) != unspec) && (byteCtr < BLOCK_SIZE))
{
data[byteCtr++] = byte(val);
}
if (byteCtr > 0)
{
if (!prom.writeData(data, byteCtr, start))
{
cmdStatus.error("Write failed");
return;
}
}
else
{
cmdStatus.error("Missing address or data");
return;
}
delay(100);
if (!prom.is_readback_safe()) {
// This chip uses the CE line for write control, so don't do the read because it
// could cause a write operation that would corrupt the data.
cmdStatus.info("Poke complete");
return;
}
for (unsigned ix = 0; ix < byteCtr ; ix++)
{
byte val = prom.readData(start + ix);
if (val != data[ix])
{
cmdStatus.error("Verify failed");
cmdStatus.setValueHex(0, "addr", start + ix);
cmdStatus.setValueHex(1, "read", val);
cmdStatus.setValueHex(2, "expected", data[ix]);
return;
}
}
cmdStatus.info("Poke successful");
}
/**
* Write a 32 byte test pattern to the PROM device and verify it
* by reading back. The pattern includes a walking 1 and a
* walking zero, which may help to detect pins that are tied
* together or swapped.
*
* @param start - start address
*/
void zapTest(uint32_t start)
{
byte testData[] =
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe,
0x00, 0xff, 0x55, 0xaa, '0', '1', '2', '3'
};
if (!prom.writeData(testData, sizeof(testData), start))
{
cmdStatus.error("Write failed");
return;
}
delay(100);
if (!prom.is_readback_safe()) {
// This chip uses the CE line for write control, so don't do the read because it
// could cause a write operation that would corrupt the data.
cmdStatus.info("Write test complete");
return;
}
for (unsigned ix = 0; ix < sizeof(testData); ix++)
{
byte val = prom.readData(start + ix);
if (val != testData[ix])
{
cmdStatus.error("Verify failed");
cmdStatus.setValueHex(0, "addr", start + ix);
cmdStatus.setValueHex(1, "read", val);
cmdStatus.setValueHex(2, "expected", testData[ix]);
return;
}
}
cmdStatus.info("Write test successful");
}
void printRetStatus(ERET status)
{
switch (status) {
case RET_OK: Serial.println(F("OK")); break;
case RET_FAIL: Serial.println(F("FAILED")); break;
case RET_NOT_SUPPORT: Serial.println(F("NOT SUPPORTED")); break;
}
}
#ifdef ENABLE_DEBUG_COMMANDS
/**
* Runs through a range of addresses, reading a single address
* multiple times. Fails if all of the reads for an address do
* not produce that same value.
*
* @param start - start address
* @param end - end address
*/
void scanBlock(uint32_t start, uint32_t end)
{
enum { SCAN_TESTS = 10 };
for (uint32_t addr = start; (addr <= end); addr++)
{
byte values[SCAN_TESTS];
values[0] = prom.readData(addr);
bool fail = false;
for (int ix = 1; (ix < SCAN_TESTS); ix++)
{
values[ix] = prom.readData(addr);
if (values[ix] != values[0])
{
fail = true;
}
}
if (fail)
{
printHex32(addr);
Serial.print(": ");
for (int ix = 0; (ix < SCAN_TESTS); ix++)
{
printByte(values[ix]);
Serial.print(" ");
}
Serial.println();
cmdStatus.error("Repeated reads returned different values");
cmdStatus.setValueHex(0, "addr", addr);
break;
}
if (addr == 0xffff) break;
}
}
/**
* Reads a single address in the PROM multiple times and fails
* if all of the reads do not produce the same value.
*
* @param addr - address to test
*/
void testAddr(uint32_t addr)
{
enum { NUM_TESTS = 100 };
bool fail = false;
byte value;
byte firstValue = prom.readData(addr);
for (int ix = 1; (ix < NUM_TESTS); ix++)
{
value = prom.readData(addr);
if (value != firstValue)
{
fail = true;
}
}
if (fail)
{
cmdStatus.error("Repeated reads returned different values");
cmdStatus.setValueHex(0, "addr", addr);
cmdStatus.setValueHex(1, "first read", firstValue);
cmdStatus.setValueHex(2, "last read", value);
}
else
{
cmdStatus.info("Read test passed");
}
}
/**
* Fill a PROM with a test pattern
*
* Each 8-byte block contains two bytes of 256-byte block number
* followed by six bytes of byte number.
* 00000 00 00 02 03 04 05 06 07 00 00 0a 0b 0c 0d 0e 0f
* 00010 00 00 12 13 14 15 16 17 00 00 1a 1b 1c 1d 1e 1f
* 00020 00 00 22 23 24 25 26 27 00 00 2a 2b 2c 2d 2e 2f
* ...
* 000f0 00 00 f2 f3 f4 f5 f6 f7 00 00 fa fb fc fd fe ff
* 00100 00 01 02 03 04 05 06 07 00 01 0a 0b 0c 0d 0e 0f
* 00010 00 01 12 13 14 15 16 17 00 01 1a 1b 1c 1d 1e 1f
* ...
* 3fff0 03 ff f2 f3 f4 f5 f6 f7 03 ff fa fb fc fd fe ff
*/
void patternFill()
{
enum { BLOCK_SIZE = 32 };
byte block[BLOCK_SIZE];
Serial.print("Filling with pattern from 0 to ");
printHex32(prom.end());
Serial.print("...");
for (uint32_t addr = 0; (addr <= prom.end()); addr += BLOCK_SIZE)
{
for (unsigned ix = 0; (ix < BLOCK_SIZE); ix+= 2)
{
if ((ix & 7) == 0)
{
block[ix] = (addr >> 16) & 0xff;
block[ix+1] = (addr >> 8) & 0xff;
}
else
{
block[ix] = (addr + ix) & 0xff;
block[ix+1] = (addr + ix + 1) & 0xff;
}
}
if (!prom.writeData(block, BLOCK_SIZE, addr))
{
cmdStatus.error("Write failed");
return;
}
}
}
#endif /* ENABLE_DEBUG_COMMANDS */
/************************************************
* MAIN
*************************************************/
uint32_t addr = 0;
void setup()
{
// Do this first so that it initializes all of the hardware pins into a
// non-harmful state. The Arduino or the target EEPROM could be damaged
// if both writing to the data bus at the same time.
prom.begin();
Serial.begin(115200);
}
/**
* main loop that runs infinite times, parsing a given command and
* executing read or write requestes.
**/
char line[120];
void loop()
{
uint32_t w;
uint32_t numBytes;
Serial.print("\n>");
Serial.flush();
readLine(line, sizeof(line));
Serial.println();
byte cmd = parseCommand(line[0]);
char * pCursor = line+1;
uint32_t start = getHex32(pCursor);
uint32_t end = getHex32(pCursor);
uint32_t val = getHex32(pCursor);
static uint32_t dump_next = 0;
if ((cmd != CMD_LAST_STATUS) && (cmd != CMD_INVALID))
{
cmdStatus.clear();
}
switch (cmd)
{
case CMD_BLANK:
erasedBlockCheck(if_unspec(start, 0), if_unspec(end, prom.end()));
break;
case CMD_CHECKSUM:
start = if_unspec(start, 0);
end = if_unspec(end, prom.end());
w = checksumBlock(start, end);
Serial.print(F("Checksum "));
printWord(start);
Serial.print(F("-"));
printWord(end);
Serial.print(F(" = "));
printWord(w);
Serial.println();
break;
case CMD_DUMP:
start = if_unspec(start, dump_next);
dump_next = dumpBlock(start, if_unspec(end, start + 0xff));
break;
case CMD_ERASE:
if (start == unspec || end == unspec)
{
Serial.println(F("Erase requires explicit start, end"));
}
else
{
printRetStatus(prom.erase(start, end));
}
break;
case CMD_FILL:
if (start == unspec || end == unspec || val == unspec)
{
Serial.println(F("Fill requires explicit start, end and value"));
}
else
{
prom.resetDebugStats();
fillBlock(start, end, (byte)val);
}
break;
case CMD_INFO:
prom.printDebugStats();
break;
case CMD_LOCK:
Serial.print(F("Writing the lock code to enable Software Write Protect mode: "));
printRetStatus(prom.enableSoftwareWriteProtect());
break;
case CMD_POKE:
prom.resetDebugStats();
pokeBytes(line+1);
break;
case CMD_READ:
start = if_unspec(start, 0);
end = if_unspec(end, prom.end());
if (xmodem.SendFile(start, end - start + 1))
{
cmdStatus.info("Send complete.");
cmdStatus.setValueDec(0, "NumBytes", end - start + 1);
}
break;
case CMD_UNLOCK:
Serial.print(F("Writing the unlock code to disable Software Write Protect mode: "));
printRetStatus(prom.disableSoftwareWriteProtect());
break;
case CMD_WRITE:
prom.resetDebugStats();
start = if_unspec(start, 0);
numBytes = xmodem.ReceiveFile(start);
if (numBytes)
{
cmdStatus.info("Success writing to EEPROM device.");
cmdStatus.setValueDec(0, "NumBytes", numBytes);
}
else
{
xmodem.Cancel();
}
break;
case CMD_ZAP:
prom.resetDebugStats();
zapTest(if_unspec(start, 0));
break;
#ifdef ENABLE_DEBUG_COMMANDS
case CMD_SCAN:
scanBlock(if_unspec(start, 0), if_unspec(end, prom.end()));
break;
case CMD_TEST:
testAddr(if_unspec(start, 0));
break;
case CMD_PATTERN_FILL:
patternFill();
break;
#endif /* ENABLE_DEBUG_COMMANDS */
case CMD_LAST_STATUS:
Serial.println(F("Status of last command:"));
break;
default:
Serial.print(F("TommyPROM "));
Serial.print(MY_VERSION);
Serial.print(F(" - "));
Serial.println(prom.getName());
Serial.println();
Serial.println(F("Valid commands are:"));
Serial.println(F(" Bsssss eeeee - Check to see if device range is Blank/erased (all FF)"));
Serial.println(F(" Csssss eeeee - Compute Checksum from device"));
Serial.println(F(" Dsssss eeeee - Dump bytes from device to terminal"));
Serial.println(F(" Esssss eeeee - Erase address range on device (needed for some Flash)"));
Serial.println(F(" Fsssss eeeee dd - Fill block on device with fixed value"));
Serial.println(F(" I - Print debug Info"));
Serial.println(F(" L - Lock (enable) device Software Data Protection"));
Serial.println(F(" Psssss dd dd... - Poke (write) values to device (up to 32 values)"));
Serial.println(F(" Rsssss eeeee - Read from device and save to XMODEM CRC file"));
Serial.println(F(" U - Unlock (disable) device Software Data Protection"));
Serial.println(F(" Wsssss - Write to device from XMODEM CRC file"));
Serial.println(F(" Zsssss - Zap (burn) a 32 byte test pattern"));
#ifdef ENABLE_DEBUG_COMMANDS
Serial.println();
Serial.println(F(" Ssssss eeeee - Scan addresses (read each 10x)"));
Serial.println(F(" Tsssss - Test read address (read 100x)"));
Serial.println(F(" ! - Fill entire device with a test pattern"));
#endif /* ENABLE_DEBUG_COMMANDS */
break;
}
if (!cmdStatus.isClear() || (cmd == CMD_LAST_STATUS))
{
Serial.println();
cmdStatus.printStatus();
}
}
Reference in New Issue View Git Blame Copy Permalink