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

242
DCC.cpp
View File

@ -1,6 +1,7 @@
#include "DCC.h"
#include "DCCWaveform.h"
#include "DIAG.h"
#include "Hardware.h"
// This module is responsible for converting API calls into
// messages to be sent to the waveform generator.
@ -105,53 +106,83 @@ void DCC::writeCVBitMain(int cab, int cv, byte bNum, bool bValue) {
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) {
if (bNum>=8) return false;
byte instruction=WRITE_BIT | bValue?BIT_ON:BIT_OFF | bNum;
byte message[] = {cv1(BIT_MANIPULATE, cv), cv2(cv), instruction };
DCCWaveform::progTrack.schedulePacket(message, sizeof(message), 6); // NMRA recommends 6 write or reset packets for decoder recovery time
return verifyCVBit(cv, bNum, bValue);
}
const ackOp WRITE_BIT0_PROG[] = {
BASELINE,
W0,WACK,
V0, WACK, // validate bit is 0
ITC1, // if acked, callback(1)
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) {
if (bNum>=8) return -1;
if (verifyCVBit(cv, bNum,true)) return 1;
// failed verify might be a zero, or an error so must check again
if (verifyCVBit(cv, bNum,false)) return 0;
return -1;
const ackOp READ_BIT_PROG[] = {
BASELINE,
V1, WACK, // validate bit is 1
ITC1, // if acked, callback(1)
V0, WACK, // validate bit is zero
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) {
byte value = 0;
// get each bit individually by validating against a one.
for (int bNum = 0; bNum < 8; bNum++) {
value += verifyCVBit(cv,bNum,true) << bNum;
void DCC::writeCVBit(int cv, byte bitNum, bool bitValue, ACK_CALLBACK callback) {
if (bitNum >= 8) callback(-1);
else ackManagerSetup(cv, bitNum, bitValue?WRITE_BIT1_PROG:WRITE_BIT0_PROG, callback);
}
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() {
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 ( DCCWaveform::mainTrack.packetPending) return;
@ -172,24 +203,26 @@ void DCC::loop() {
}
}
int DCC::getLocoId() {
switch (readCVBit(29,5)) {
case 1:
// long address : get CV#17 and CV#18
{
int cv17=readCV(17);
if (cv17<0) break;
int cv18=readCV(18);
if (cv18<0) break;
return cv18 + ((cv17 - 192) <<8);
}
case 0: // short address in CV1
return readCV(1);
default: // No response or loco
break;
}
return -1;
void DCC::getLocoId(ACK_CALLBACK callback) {
callback(-1); // Not yet implemented
//
// switch (readCVBit(29, 5)) {
// case 1:
// // long address : get CV#17 and CV#18
// {
// int cv17 = readCV(17);
//
// if (cv17 < 0) break;
// int cv18 = readCV(18);
// if (cv18 < 0) break;
// return cv18 + ((cv17 - 192) << 8);
// }
// case 0: // short address in CV1
// return readCV(1);
// default: // No response or loco
// break;
// }
// return -1;
}
///// Private helper functions below here /////////////////////
@ -224,3 +257,106 @@ void DCC::updateLocoReminder(int loco, byte speedCode) {
DCC::LOCO DCC::speedTable[MAX_LOCOS];
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 "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 {
public:
@ -12,19 +29,20 @@ class DCC {
// Public DCC API functions
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 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);
static void setAccessory(int aAdd, byte aNum, bool activate) ;
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:
struct LOCO {
@ -38,6 +56,20 @@ private:
static byte cv1(byte opcode, 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 #
static const byte SET_SPEED=0x3f;
static const byte WRITE_BYTE_MAIN = 0xEC;
@ -50,4 +82,5 @@ private:
static const byte BIT_ON=0x08;
static const byte BIT_OFF=0x00;
};
#endif

37
DCCEXParser.cpp
View File

@ -22,7 +22,6 @@ const char VERSION[]="99.666";
void DCCEXParser::parse(Stream & stream,const char *com) {
(void) EEPROM; // tell compiler not to warn thi is unused
int p[MAX_PARAMS];
bool result;
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)
* where VALUE is a number from 0-255 as read from the requested CV, or -1 if verificaiton read fails
*/
result=DCC::writeCVByte(p[0],p[1]);
StringParser::send(stream,F("<r%d|%d|%d %d>"), p[2], p[3],p[0],result?p[1]:-1);
if (!stashCallback(stream,p)) break;
DCC::writeCVByte(p[0],p[1],callback_W);
return;
/***** 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)
* where VALUE is a number from 0-1 as read from the requested CV bit, or -1 if verificaiton read fails
*/
result=DCC::writeCVBit(p[0],p[1],p[2]);
StringParser::send(stream,F("<r%d|%d|%d %d %d>"), p[3],p[4], p[0],p[1],result?p[2]:-1);
if (!stashCallback(stream,p)) break;
DCC::writeCVBit(p[0],p[1],p[2],callback_B);
return;
/***** 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)
* where VALUE is a number from 0-255 as read from the requested CV, or -1 if read could not be verified
*/
StringParser::send(stream,F("<r%d|%d|%d %d>"),p[1],p[2],p[0],DCC::readCV(p[0]));
if (!stashCallback(stream,p)) break;
DCC::readCV(p[0],callback_R);
return;
/***** TURN ON POWER FROM MOTOR SHIELD TO TRACKS ****/
@ -388,6 +385,28 @@ bool DCCEXParser::parseS(Stream & stream, int params, int p[]) {
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:
static const int MAX_PARAMS=10; // longest command sent in
static bool parseT(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 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"

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() {
// set currentBit to be the next bit to be sent.
@ -179,7 +182,7 @@ void DCCWaveform::interrupt2() {
memcpy( transmitPacket, isMainTrack ? idlePacket : resetPacket, sizeof(idlePacket));
transmitLength = sizeof(idlePacket);
transmitRepeats = 0;
sentResetsSincePacket++;
if (sentResetsSincePacket<250) sentResetsSincePacket++;
}
}
}
@ -210,45 +213,6 @@ void DCCWaveform::schedulePacket(const byte buffer[], byte byteCount, byte repea
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() {
return lastCurrent;
}

3
DCCWaveform.h
View File

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