dani/CommandStation-EX
1
0
Fork 0
mirror of https://github.com/DCC-EX/CommandStation-EX.git synced 2024-11-23 08:06:13 +01:00
Code Releases Activity

Ack Management compiles

Browse Source 
but remains untested
This commit is contained in:
Asbelos 2020-06-07 13:48:42 +01:00
parent b2b6886b52
commit 0ad395a63a
6 changed files with 288 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

250
DCC.cpp
View File

@ -1,6 +1,7 @@
#include "DCC.h" #include "DCC.h"
#include "DCCWaveform.h" #include "DCCWaveform.h"
#include "DIAG.h" #include "DIAG.h"
#include "Hardware.h"
// This module is responsible for converting API calls into // This module is responsible for converting API calls into
// messages to be sent to the waveform generator. // messages to be sent to the waveform generator.
@ -20,7 +21,7 @@ void DCC::begin() {
} }
void DCC::setThrottle( uint16_t cab, uint8_t tSpeed, bool tDirection) { void DCC::setThrottle( uint16_t cab, uint8_t tSpeed, bool tDirection) {
byte speedCode= tSpeed + (tSpeed > 0) + tDirection * 128; // max speed is 126, but speed codes range from 2-127 (0=stop, 1=emergency stop) byte speedCode = tSpeed + (tSpeed > 0) + tDirection * 128; // max speed is 126, but speed codes range from 2-127 (0=stop, 1=emergency stop)
setThrottle2(cab, speedCode); setThrottle2(cab, speedCode);
// retain speed for loco reminders // retain speed for loco reminders
updateLocoReminder(cab, speedCode ); updateLocoReminder(cab, speedCode );
@ -100,58 +101,88 @@ void DCC::writeCVBitMain(int cab, int cv, byte bNum, bool bValue) {
b[nB++] = lowByte(cab); b[nB++] = lowByte(cab);
b[nB++] = cv1(WRITE_BIT_MAIN, cv); // any CV>1023 will become modulus(1024) due to bit-mask of 0x03 b[nB++] = cv1(WRITE_BIT_MAIN, cv); // any CV>1023 will become modulus(1024) due to bit-mask of 0x03
b[nB++] = cv2(cv); b[nB++] = cv2(cv);
b[nB++] = WRITE_BIT | (bValue?BIT_ON:BIT_OFF) | bNum; b[nB++] = WRITE_BIT | (bValue ? BIT_ON : BIT_OFF) | bNum;
DCCWaveform::mainTrack.schedulePacket(b, nB, 4); DCCWaveform::mainTrack.schedulePacket(b, nB, 4);
} }
bool DCC::writeCVByte(int cv, byte bValue) {
uint8_t message[] = {cv1(WRITE_BYTE, cv), cv2(cv), bValue};
DCCWaveform::progTrack.schedulePacket(message, sizeof(message), 6); // NMRA recommends 6 write or reset packets for decoder recovery time
return verifyCVByte(cv, bValue);
}
bool DCC::verifyCVByte(int cv, byte value) {
byte message[] = { cv1(VERIFY_BYTE, cv), cv2(cv), value};
return DCCWaveform::progTrack.schedulePacketWithAck(message, sizeof(message), 5);
}
bool DCC::writeCVBit(int cv, byte bNum, bool bValue) { const ackOp WRITE_BIT0_PROG[] = {
if (bNum>=8) return false; BASELINE,
byte instruction=WRITE_BIT | bValue?BIT_ON:BIT_OFF | bNum; W0,WACK,
byte message[] = {cv1(BIT_MANIPULATE, cv), cv2(cv), instruction }; V0, WACK, // validate bit is 0
DCCWaveform::progTrack.schedulePacket(message, sizeof(message), 6); // NMRA recommends 6 write or reset packets for decoder recovery time ITC1, // if acked, callback(1)
return verifyCVBit(cv, bNum, bValue); FAIL // callback (-1)
} };
const ackOp WRITE_BIT1_PROG[] = {
BASELINE,
W1,WACK,
V1, WACK, // validate bit is 1
ITC1, // if acked, callback(1)
FAIL // callback (-1)
};
bool DCC::verifyCVBit(int cv, byte bNum, bool bValue) {
if (bNum>=8) return false;
byte instruction=VERIFY_BIT | bValue?BIT_ON:BIT_OFF | bNum;
byte message[] = {cv1(BIT_MANIPULATE, cv), cv2(cv), instruction };
return DCCWaveform::progTrack.schedulePacketWithAck(message, sizeof(message), 5); // NMRA recommends 6 write or reset packets for decoder recovery time
}
int DCC::readCVBit(int cv, byte bNum) { const ackOp READ_BIT_PROG[] = {
if (bNum>=8) return -1; BASELINE,
if (verifyCVBit(cv, bNum,true)) return 1; V1, WACK, // validate bit is 1
// failed verify might be a zero, or an error so must check again ITC1, // if acked, callback(1)
if (verifyCVBit(cv, bNum,false)) return 0; V0, WACK, // validate bit is zero
return -1; ITC0, // if acked callback 0
FAIL // bit not readable
};
const ackOp WRITE_BYTE_PROG[] = {
BASELINE,
WB,WACK, // Write
VB,WACK, // validate byte
ITC1, // if ok callback (1)
FAIL // callback (-1)
};
const ackOp READ_CV_PROG[] = {
BASELINE,
ZERO, //clear bit and byte values
// each bit is validated against 1 (no need for zero validation as entire byte is validated at the end)
V1, WACK, MERGE, // read and merge bit 0
V1, WACK, MERGE, // read and merge bit 1 etc
V1, WACK, MERGE,
V1, WACK, MERGE,
V1, WACK, MERGE,
V1, WACK, MERGE,
V1, WACK, MERGE,
V1, WACK, MERGE,
VB, WACK, ITCB, // verify merged byte and return it if acked ok
FAIL }; // verification failed
void DCC::writeCVByte(int cv, byte byteValue, ACK_CALLBACK callback) {
ackManagerSetup(cv, byteValue, WRITE_BYTE_PROG, callback);
} }
int DCC::readCV(int cv) { void DCC::writeCVBit(int cv, byte bitNum, bool bitValue, ACK_CALLBACK callback) {
byte value = 0; if (bitNum >= 8) callback(-1);
// get each bit individually by validating against a one. else ackManagerSetup(cv, bitNum, bitValue?WRITE_BIT1_PROG:WRITE_BIT0_PROG, callback);
for (int bNum = 0; bNum < 8; bNum++) { }
value += verifyCVBit(cv,bNum,true) << bNum;
}
return verifyCVByte(cv, value) ? value : -1; void DCC::readCVBit(int cv, byte bitNum, ACK_CALLBACK callback) {
if (bitNum >= 8) callback(-1);
else ackManagerSetup(cv, bitNum,READ_BIT_PROG, callback);
}
void DCC::readCV(int cv, ACK_CALLBACK callback) {
ackManagerSetup(cv, 0,READ_CV_PROG, callback);
} }
void DCC::loop() { void DCC::loop() {
DCCWaveform::loop(); // powwer overload checks DCCWaveform::loop(); // power overload checks
ackManagerLoop();
// if the main track transmitter still has a pending packet, skip this loop. // if the main track transmitter still has a pending packet, skip this loop.
if ( DCCWaveform::mainTrack.packetPending) return; if ( DCCWaveform::mainTrack.packetPending) return;
@ -172,24 +203,26 @@ void DCC::loop() {
} }
} }
int DCC::getLocoId() { void DCC::getLocoId(ACK_CALLBACK callback) {
switch (readCVBit(29,5)) { callback(-1); // Not yet implemented
case 1: //
// long address : get CV#17 and CV#18 // switch (readCVBit(29, 5)) {
{ // case 1:
int cv17=readCV(17); // // long address : get CV#17 and CV#18
// {
if (cv17<0) break; // int cv17 = readCV(17);
int cv18=readCV(18); //
if (cv18<0) break; // if (cv17 < 0) break;
return cv18 + ((cv17 - 192) <<8); // int cv18 = readCV(18);
} // if (cv18 < 0) break;
case 0: // short address in CV1 // return cv18 + ((cv17 - 192) << 8);
return readCV(1); // }
default: // No response or loco // case 0: // short address in CV1
break; // return readCV(1);
} // default: // No response or loco
return -1; // break;
// }
// return -1;
} }
///// Private helper functions below here ///////////////////// ///// Private helper functions below here /////////////////////
@ -220,7 +253,110 @@ void DCC::updateLocoReminder(int loco, byte speedCode) {
} }
speedTable[reg].loco = loco; speedTable[reg].loco = loco;
speedTable[reg].speedCode = speedCode; speedTable[reg].speedCode = speedCode;
} }
DCC::LOCO DCC::speedTable[MAX_LOCOS]; DCC::LOCO DCC::speedTable[MAX_LOCOS];
int DCC::nextLoco = 0; int DCC::nextLoco = 0;
//ACK MANAGER
ackOp const * DCC::ackManagerProg;
byte DCC::ackManagerByte;
int DCC::ackManagerCv;
byte DCC::ackManagerBitNum;
bool DCC::ackReceived;
int DCC::ackTriggerMilliamps;
ACK_CALLBACK DCC::ackManagerCallback;
void DCC::ackManagerSetup(int cv, byte byteValue, ackOp const program[], ACK_CALLBACK callback) {
ackManagerCv = cv;
ackManagerProg = program;
ackManagerByte = byteValue;
ackManagerCallback = callback;
ackManagerBitNum=0;
}
void DCC::ackManagerLoop() {
while (ackManagerProg) {
// breaks from this switch will step to next prog entry
// returns from this switch will stay on same entry (typically WACK waiting and when all finished.)
byte opcode=*ackManagerProg;
switch (opcode) {
case W0: // write bit
case W1: // write bit
{
byte instruction = WRITE_BIT | (opcode==W1 ? BIT_ON : BIT_OFF) | ackManagerByte;
byte message[] = {cv1(BIT_MANIPULATE, ackManagerCv), cv2(ackManagerCv), instruction };
DCCWaveform::progTrack.schedulePacket(message, sizeof(message), 6);
}
break;
case WB: // write byte
{
byte message[] = {cv1(WRITE_BYTE, ackManagerCv), cv2(ackManagerCv), ackManagerByte};
DCCWaveform::progTrack.schedulePacket(message, sizeof(message), 6);
}
break;
case VB: // Issue validate Byte packet
{
byte message[] = { cv1(VERIFY_BYTE, ackManagerCv), cv2(ackManagerCv), ackManagerByte};
DCCWaveform::progTrack.schedulePacket(message, sizeof(message), 5);
}
break;
case V0:
case V1: // Issue validate bit=0 or bit=1 packet
{
byte instruction = VERIFY_BIT | (opcode==V0?BIT_OFF:BIT_ON) | ackManagerByte;
byte message[] = {cv1(BIT_MANIPULATE, ackManagerCv), cv2(ackManagerCv), instruction };
DCCWaveform::progTrack.schedulePacket(message, sizeof(message), 5);
}
break;
case WACK: // wait for ack (or absence of ack)
if (DCCWaveform::progTrack.sentResetsSincePacket > 6) {
ackReceived = false;
break; // move on to next prog step
}
if (Hardware::getCurrentMilliamps(false) > ackTriggerMilliamps) {
ackReceived = true;
DCCWaveform::progTrack.killRemainingRepeats();
break; // move on tho next step
}
return; // maintain place for next poll cycle.
case ITC0:
case ITC1: // If True Callback(0 or 1) (if prevous WACK got an ACK)
if (ackReceived) {
ackManagerProg = NULL;
(ackManagerCallback)(opcode==ITC0?0:1);
return;
}
break;
case ITCB: // If True callback(byte)
if (ackReceived) {
ackManagerProg = NULL;
(ackManagerCallback)(ackManagerByte);
return;
}
break;
case MERGE: // Merge previous wack response with byte value and increment bit number (use for reading CV bytes)
ackManagerByte <<= 1;
if (ackReceived) ackManagerByte |= 1;
ackManagerBitNum++;
break;
case FAIL: // callback(-1)
ackManagerProg = NULL;
(ackManagerCallback)(-1);
return;
case ZERO:
ackManagerBitNum=0;
ackManagerByte=0;
break;
case BASELINE:
if (DCCWaveform::progTrack.sentResetsSincePacket < 6) return; // try again later
ackTriggerMilliamps=Hardware::getCurrentMilliamps(false) + ACK_MIN_PULSE;
break;
} // end of switch
ackManagerProg++;
}
}

47
DCC.h
View File

@ -3,6 +3,23 @@
#include <Arduino.h> #include <Arduino.h>
#include "Config.h" #include "Config.h"
typedef void (*ACK_CALLBACK)(int result);
enum ackOp { // Program opcodes for the ack Manager
W0,W1, // issue write bit
WB, // issue write byte
VB, // Issue validate Byte packet
V0, // Issue validate bit=0 packet
V1, // issue validate bit=1 packlet
WACK, // wait for ack (or absence of ack)
ITC1, // If True Callback(1) (if prevous WACK got an ACK)
ITC0, // If True callback(0);
ITCB, // IOf True callback(byte)
MERGE, // Merge previous wack response with byte value and increment bit number (use for readimng CV bytes)
FAIL, // callback(-1)
ZERO, // Clear bit and byte
BASELINE // ensure enough resets sent before starting and obtain baseline
};
class DCC { class DCC {
public: public:
@ -12,19 +29,20 @@ class DCC {
// Public DCC API functions // Public DCC API functions
static void setThrottle( uint16_t cab, uint8_t tSpeed, bool tDirection); static void setThrottle( uint16_t cab, uint8_t tSpeed, bool tDirection);
static int readCV(int cv);
static int readCVBit(int cv, byte bNum); // -1 for error
static bool writeCVByte(int cv, byte bValue) ;
static bool verifyCVByte(int cv,byte bValue);
static bool writeCVBit(int cv, byte bNum, bool bValue);
static bool verifyCVBit(int cv, byte bNum, bool bValue);
static void writeCVByteMain(int cab, int cv, byte bValue); static void writeCVByteMain(int cab, int cv, byte bValue);
static void writeCVBitMain(int cab, int cv, byte bNum, bool bValue); static void writeCVBitMain(int cab, int cv, byte bNum, bool bValue);
static void setFunction( int cab, byte fByte, byte eByte); static void setFunction( int cab, byte fByte, byte eByte);
static void setFunction( int cab, byte fByte); static void setFunction( int cab, byte fByte);
static void setAccessory(int aAdd, byte aNum, bool activate) ; static void setAccessory(int aAdd, byte aNum, bool activate) ;
static bool writeTextPacket( byte *b, int nBytes); static bool writeTextPacket( byte *b, int nBytes);
static int getLocoId();
// ACKable progtrack calls bitresults callback 0,0 or -1, cv returns value or -1
static void readCV(int cv, ACK_CALLBACK callback);
static void readCVBit(int cv, byte bitNum, ACK_CALLBACK callback); // -1 for error
static void writeCVByte(int cv, byte byteValue, ACK_CALLBACK callback) ;
static void writeCVBit(int cv, byte bitNum, bool bitValue, ACK_CALLBACK callback);
static void getLocoId(ACK_CALLBACK callback);
private: private:
struct LOCO { struct LOCO {
@ -38,6 +56,20 @@ private:
static byte cv1(byte opcode, int cv); static byte cv1(byte opcode, int cv);
static byte cv2(int cv); static byte cv2(int cv);
// ACK MANAGER
static ackOp const * ackManagerProg;
static byte ackManagerByte;
static byte ackManagerBitNum;
static int ackManagerCv;
static bool ackReceived;
static int ackTriggerMilliamps;
static ACK_CALLBACK ackManagerCallback;
static void ackManagerSetup(int cv, byte bitNumOrbyteValue, ackOp const program[], ACK_CALLBACK callback);
static void ackManagerLoop();
// NMRA codes # // NMRA codes #
static const byte SET_SPEED=0x3f; static const byte SET_SPEED=0x3f;
static const byte WRITE_BYTE_MAIN = 0xEC; static const byte WRITE_BYTE_MAIN = 0xEC;
@ -50,4 +82,5 @@ private:
static const byte BIT_ON=0x08; static const byte BIT_ON=0x08;
static const byte BIT_OFF=0x00; static const byte BIT_OFF=0x00;
}; };
#endif #endif

37
DCCEXParser.cpp
View File

@ -22,7 +22,6 @@ const char VERSION[]="99.666";
void DCCEXParser::parse(Stream & stream,const char *com) { void DCCEXParser::parse(Stream & stream,const char *com) {
(void) EEPROM; // tell compiler not to warn thi is unused (void) EEPROM; // tell compiler not to warn thi is unused
int p[MAX_PARAMS]; int p[MAX_PARAMS];
bool result;
int params=StringParser::parse(com+1,p,MAX_PARAMS); int params=StringParser::parse(com+1,p,MAX_PARAMS);
@ -146,9 +145,8 @@ void DCCEXParser::parse(Stream & stream,const char *com) {
* returns: <r CALLBACKNUM|CALLBACKSUB|CV Value) * returns: <r CALLBACKNUM|CALLBACKSUB|CV Value)
* where VALUE is a number from 0-255 as read from the requested CV, or -1 if verificaiton read fails * where VALUE is a number from 0-255 as read from the requested CV, or -1 if verificaiton read fails
*/ */
if (!stashCallback(stream,p)) break;
result=DCC::writeCVByte(p[0],p[1]); DCC::writeCVByte(p[0],p[1],callback_W);
StringParser::send(stream,F("<r%d|%d|%d %d>"), p[2], p[3],p[0],result?p[1]:-1);
return; return;
/***** WRITE CONFIGURATION VARIABLE BIT TO ENGINE DECODER ON PROGRAMMING TRACK ****/ /***** WRITE CONFIGURATION VARIABLE BIT TO ENGINE DECODER ON PROGRAMMING TRACK ****/
@ -166,9 +164,8 @@ void DCCEXParser::parse(Stream & stream,const char *com) {
* returns: <r CALLBACKNUM|CALLBACKSUB|CV BIT VALUE) * returns: <r CALLBACKNUM|CALLBACKSUB|CV BIT VALUE)
* where VALUE is a number from 0-1 as read from the requested CV bit, or -1 if verificaiton read fails * where VALUE is a number from 0-1 as read from the requested CV bit, or -1 if verificaiton read fails
*/ */
if (!stashCallback(stream,p)) break;
result=DCC::writeCVBit(p[0],p[1],p[2]); DCC::writeCVBit(p[0],p[1],p[2],callback_B);
StringParser::send(stream,F("<r%d|%d|%d %d %d>"), p[3],p[4], p[0],p[1],result?p[2]:-1);
return; return;
/***** READ CONFIGURATION VARIABLE BYTE FROM ENGINE DECODER ON PROGRAMMING TRACK ****/ /***** READ CONFIGURATION VARIABLE BYTE FROM ENGINE DECODER ON PROGRAMMING TRACK ****/
@ -184,8 +181,8 @@ void DCCEXParser::parse(Stream & stream,const char *com) {
* returns: <r CALLBACKNUM|CALLBACKSUB|CV VALUE) * returns: <r CALLBACKNUM|CALLBACKSUB|CV VALUE)
* where VALUE is a number from 0-255 as read from the requested CV, or -1 if read could not be verified * where VALUE is a number from 0-255 as read from the requested CV, or -1 if read could not be verified
*/ */
if (!stashCallback(stream,p)) break;
StringParser::send(stream,F("<r%d|%d|%d %d>"),p[1],p[2],p[0],DCC::readCV(p[0])); DCC::readCV(p[0],callback_R);
return; return;
/***** TURN ON POWER FROM MOTOR SHIELD TO TRACKS ****/ /***** TURN ON POWER FROM MOTOR SHIELD TO TRACKS ****/
@ -388,6 +385,28 @@ bool DCCEXParser::parseS(Stream & stream, int params, int p[]) {
return false; return false;
} }
int DCCEXParser::stashP[MAX_PARAMS];
bool DCCEXParser::stashBusy=false;
Stream & DCCEXParser::stashStream=Serial; // only to keep compiler happy
bool DCCEXParser::stashCallback(Stream & stream, int p[MAX_PARAMS]) {
if (stashBusy) return false;
stashBusy=true;
stashStream=stream;
memcpy(stashP,p,MAX_PARAMS*sizeof(p[0]));
return true;
}
void DCCEXParser::callback_W(int result) {
StringParser::send(stashStream,F("<r%d|%d|%d %d>"), stashP[2], stashP[3],stashP[0],result==1?stashP[1]:-1);
stashBusy=false;
}
void DCCEXParser::callback_B(int result) {
StringParser::send(stashStream,F("<r%d|%d|%d %d %d>"), stashP[3],stashP[4], stashP[0],stashP[1],result==1?stashP[2]:-1);
stashBusy=false;
}
void DCCEXParser::callback_R(int result) {
StringParser::send(stashStream,F("<r%d|%d|%d %d>"),stashP[1],stashP[2],stashP[0],result);
stashBusy=false;
}

11
DCCEXParser.h
View File

@ -6,11 +6,20 @@ struct DCCEXParser
private: private:
static const int MAX_PARAMS=10; // longest command sent in
static bool parseT(Stream & stream, int params, int p[]); static bool parseT(Stream & stream, int params, int p[]);
static bool parseZ(Stream & stream, int params, int p[]); static bool parseZ(Stream & stream, int params, int p[]);
static bool parseS(Stream & stream, int params, int p[]); static bool parseS(Stream & stream, int params, int p[]);
static const int MAX_PARAMS=10; // longest command sent in static int stashP[MAX_PARAMS];
static bool stashBusy;
static Stream & stashStream;
static bool stashCallback(Stream & stream, int p[MAX_PARAMS]);
static void callback_W(int result);
static void callback_B(int result);
static void callback_R(int result);
}; };
#define BOARD_NAME "not yet configured" #define BOARD_NAME "not yet configured"

44
DCCWaveform.cpp
View File

@ -137,6 +137,9 @@ bool DCCWaveform::interrupt1() {
} }
void DCCWaveform::killRemainingRepeats() {
transmitRepeats=0; // will go idle at end of current packet
}
void DCCWaveform::interrupt2() { void DCCWaveform::interrupt2() {
// set currentBit to be the next bit to be sent. // set currentBit to be the next bit to be sent.
@ -179,7 +182,7 @@ void DCCWaveform::interrupt2() {
memcpy( transmitPacket, isMainTrack ? idlePacket : resetPacket, sizeof(idlePacket)); memcpy( transmitPacket, isMainTrack ? idlePacket : resetPacket, sizeof(idlePacket));
transmitLength = sizeof(idlePacket); transmitLength = sizeof(idlePacket);
transmitRepeats = 0; transmitRepeats = 0;
sentResetsSincePacket++; if (sentResetsSincePacket<250) sentResetsSincePacket++;
} }
} }
} }
@ -210,45 +213,6 @@ void DCCWaveform::schedulePacket(const byte buffer[], byte byteCount, byte repea
packetPending = true; packetPending = true;
} }
// Wait until there is no packet pending, then make this pending
bool DCCWaveform::schedulePacketWithAck(const byte buffer[], byte byteCount, byte repeats) {
if (isMainTrack) return false;
int baseline=0;
for (int i=0;i<ACK_BASELINE_SAMPLES;i++) {
baseline += Hardware::getCurrentMilliamps(isMainTrack);
}
baseline/=ACK_BASELINE_SAMPLES;
int upTrigger=baseline+ACK_MIN_PULSE;
DIAG(F("\nACK baseline=%d upT=%d "),baseline, upTrigger);
schedulePacket(buffer,byteCount,repeats);
while (packetPending); // wait until transmitter has started transmitting the message
unsigned long timeout = millis() + ACK_TIMEOUT;
int maxCurrent = 0;
bool result = false;
int upsamples = 0;
// Monitor looking for an ack signal rise of at least 60mA but keep going for the timeout
while (timeout > millis()) {
int current = Hardware::getCurrentMilliamps(isMainTrack);
maxCurrent = max(maxCurrent, current);
if (current>upTrigger) {
result=true;
upsamples++;
}
}
// The following DIAG is really useful as it can show how long and how far the
// current changes during an ACK from the decoder.
DIAG(F("ack=%d max=%d, up=%d"), result, maxCurrent, upsamples);
return result;
}
int DCCWaveform::getLastCurrent() { int DCCWaveform::getLastCurrent() {
return lastCurrent; return lastCurrent;
} }

3
DCCWaveform.h
View File

@ -46,10 +46,9 @@ class DCCWaveform {
void checkPowerOverload(); void checkPowerOverload();
int getLastCurrent(); int getLastCurrent();
void schedulePacket(const byte buffer[], byte byteCount, byte repeats); void schedulePacket(const byte buffer[], byte byteCount, byte repeats);
bool schedulePacketWithAck(const byte buffer[], byte byteCount, byte repeats);
volatile bool packetPending; volatile bool packetPending;
volatile byte sentResetsSincePacket; volatile byte sentResetsSincePacket;
void killRemainingRepeats();
private: private: