mirror of
https://github.com/DCC-EX/CommandStation-EX.git
synced 2024-12-24 13:21:23 +01:00
366 lines
12 KiB
C++
366 lines
12 KiB
C++
/*
|
|
* © 2021 Neil McKechnie
|
|
* © 2021-2023 Harald Barth
|
|
* © 2020-2023 Chris Harlow
|
|
* © 2022-2023 Colin Murdoch
|
|
* All rights reserved.
|
|
*
|
|
* This file is part of CommandStation-EX
|
|
*
|
|
* This is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* It is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with CommandStation. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
// THIS file is an extension of the RMFT2 class
|
|
// normally found in EXRAIL2.cpp
|
|
|
|
#include <Arduino.h>
|
|
#include "defines.h"
|
|
#include "EXRAIL2.h"
|
|
#include "DCC.h"
|
|
#include "KeywordHasher.h"
|
|
|
|
// This filter intercepts <> commands to do the following:
|
|
// - Implement RMFT specific commands/diagnostics
|
|
// - Reject/modify JMRI commands that would interfere with RMFT processing
|
|
|
|
void RMFT2::ComandFilter(Print * stream, byte & opcode, byte & paramCount, int16_t p[]) {
|
|
(void)stream; // avoid compiler warning if we don't access this parameter
|
|
|
|
switch(opcode) {
|
|
|
|
case 'D':
|
|
if (p[0]=="EXRAIL"_hk) { // <D EXRAIL ON/OFF>
|
|
diag = paramCount==2 && (p[1]=="ON"_hk || p[1]==1);
|
|
opcode=0;
|
|
}
|
|
break;
|
|
|
|
case '/': // New EXRAIL command
|
|
if (parseSlash(stream,paramCount,p)) opcode=0;
|
|
break;
|
|
|
|
case 'A': // <A address aspect>
|
|
if (paramCount!=2) break;
|
|
// Ask exrail if this is just changing the aspect on a
|
|
// predefined DCCX_SIGNAL. Because this will handle all
|
|
// the IFRED and ONRED type issues at the same time.
|
|
if (signalAspectEvent(p[0],p[1])) opcode=0; // all done
|
|
break;
|
|
|
|
case 'L':
|
|
// This entire code block is compiled out if LLC macros not used
|
|
if (!(compileFeatures & FEATURE_LCC)) return;
|
|
static int lccProgCounter=0;
|
|
static int lccEventIndex=0;
|
|
|
|
if (paramCount==0) { //<L> LCC adapter introducing self
|
|
LCCSerial=stream; // now we know where to send events we raise
|
|
opcode=0; // flag command as intercepted
|
|
|
|
// loop through all possible sent/waited events
|
|
for (int progCounter=lccProgCounter;; SKIPOP) {
|
|
byte exrailOpcode=GET_OPCODE;
|
|
switch (exrailOpcode) {
|
|
case OPCODE_ENDEXRAIL:
|
|
stream->print(F("<LR>\n")); // ready to roll
|
|
lccProgCounter=0; // allow a second pass
|
|
lccEventIndex=0;
|
|
return;
|
|
|
|
case OPCODE_LCC:
|
|
StringFormatter::send(stream,F("<LS x%h>\n"),getOperand(progCounter,0));
|
|
SKIPOP;
|
|
lccProgCounter=progCounter;
|
|
return;
|
|
|
|
case OPCODE_LCCX: // long form LCC
|
|
StringFormatter::send(stream,F("<LS x%h%h%h%h>\n"),
|
|
getOperand(progCounter,1),
|
|
getOperand(progCounter,2),
|
|
getOperand(progCounter,3),
|
|
getOperand(progCounter,0)
|
|
);
|
|
SKIPOP;SKIPOP;SKIPOP;SKIPOP;
|
|
lccProgCounter=progCounter;
|
|
return;
|
|
|
|
case OPCODE_ACON: // CBUS ACON
|
|
case OPCODE_ACOF: // CBUS ACOF
|
|
StringFormatter::send(stream,F("<LS x%c%h%h>\n"),
|
|
exrailOpcode==OPCODE_ACOF?'1':'0',
|
|
getOperand(progCounter,0),getOperand(progCounter,1));
|
|
SKIPOP;SKIPOP;
|
|
lccProgCounter=progCounter;
|
|
return;
|
|
|
|
// we stream the hex events we wish to listen to
|
|
// and at the same time build the event index looku.
|
|
|
|
case OPCODE_ONLCC:
|
|
StringFormatter::send(stream,F("<LL %d x%h%h%h:%h>\n"),
|
|
lccEventIndex,
|
|
getOperand(progCounter,1),
|
|
getOperand(progCounter,2),
|
|
getOperand(progCounter,3),
|
|
getOperand(progCounter,0)
|
|
);
|
|
SKIPOP;SKIPOP;SKIPOP;SKIPOP;
|
|
// start on handler at next
|
|
onLCCLookup[lccEventIndex]=progCounter;
|
|
lccEventIndex++;
|
|
lccProgCounter=progCounter;
|
|
return;
|
|
|
|
case OPCODE_ONACON:
|
|
case OPCODE_ONACOF:
|
|
StringFormatter::send(stream,F("<LL %d x%c%h%h>\n"),
|
|
lccEventIndex,
|
|
exrailOpcode==OPCODE_ONACOF?'1':'0',
|
|
getOperand(progCounter,0),getOperand(progCounter,1)
|
|
);
|
|
SKIPOP;SKIPOP;
|
|
// start on handler at next
|
|
onLCCLookup[lccEventIndex]=progCounter;
|
|
lccEventIndex++;
|
|
lccProgCounter=progCounter;
|
|
return;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (paramCount==1) { // <L eventid> LCC event arrived from adapter
|
|
int16_t eventid=p[0];
|
|
bool reject = eventid<0 || eventid>=countLCCLookup;
|
|
if (!reject) {
|
|
startNonRecursiveTask(F("LCC"),eventid,onLCCLookup[eventid]);
|
|
opcode=0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 'J': // throttle info commands
|
|
if (paramCount<1) return;
|
|
switch(p[0]) {
|
|
case "A"_hk: // <JA> returns automations/routes
|
|
if (paramCount==1) {// <JA>
|
|
StringFormatter::send(stream, F("<jA"));
|
|
routeLookup->stream(stream);
|
|
StringFormatter::send(stream, F(">\n"));
|
|
opcode=0;
|
|
return;
|
|
}
|
|
if (paramCount==2) { // <JA id>
|
|
int16_t id=p[1];
|
|
StringFormatter::send(stream,F("<jA %d %c \"%S\">\n"),
|
|
id, getRouteType(id), getRouteDescription(id));
|
|
|
|
if (compileFeatures & FEATURE_ROUTESTATE) {
|
|
// Send any non-default button states or captions
|
|
int16_t statePos=routeLookup->findPosition(id);
|
|
if (statePos>=0) {
|
|
if (routeStateArray[statePos])
|
|
StringFormatter::send(stream,F("<jB %d %d>\n"), id, routeStateArray[statePos]);
|
|
if (routeCaptionArray[statePos])
|
|
StringFormatter::send(stream,F("<jB %d \"%S\">\n"), id,routeCaptionArray[statePos]);
|
|
}
|
|
}
|
|
opcode=0;
|
|
return;
|
|
}
|
|
break;
|
|
case "M"_hk:
|
|
// NOTE: we only need to handle valid calls here because
|
|
// DCCEXParser has to have code to handle the <J<> cases where
|
|
// exrail isnt involved anyway.
|
|
// This entire code block is compiled out if STASH macros not used
|
|
if (!(compileFeatures & FEATURE_STASH)) return;
|
|
if (paramCount==1) { // <JM>
|
|
StringFormatter::send(stream,F("<jM %d>\n"),maxStashId);
|
|
opcode=0;
|
|
break;
|
|
}
|
|
if (paramCount==2) { // <JM id>
|
|
if (p[1]<=0 || p[1]>maxStashId) break;
|
|
StringFormatter::send(stream,F("<jM %d %d>\n"),
|
|
p[1],stashArray[p[1]]);
|
|
opcode=0;
|
|
break;
|
|
}
|
|
if (paramCount==3) { // <JM id cab>
|
|
if (p[1]<=0 || p[1]>maxStashId) break;
|
|
stashArray[p[1]]=p[2];
|
|
opcode=0;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
default: // other commands pass through
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool RMFT2::parseSlash(Print * stream, byte & paramCount, int16_t p[]) {
|
|
|
|
if (paramCount==0) { // STATUS
|
|
StringFormatter::send(stream, F("<* EXRAIL STATUS"));
|
|
RMFT2 * task=loopTask;
|
|
while(task) {
|
|
if ((compileFeatures & FEATURE_BLINK)
|
|
&& (task->blinkState==blink_high || task->blinkState==blink_low)) {
|
|
StringFormatter::send(stream,F("\nID=%d,PC=%d,BLINK=%d"),
|
|
(int)(task->taskId),task->progCounter,task->blinkPin
|
|
);
|
|
}
|
|
else {
|
|
StringFormatter::send(stream,F("\nID=%d,PC=%d,LOCO=%d%c,SPEED=%d%c"),
|
|
(int)(task->taskId),task->progCounter,task->loco,
|
|
task->invert?'I':' ',
|
|
task->speedo,
|
|
task->forward?'F':'R'
|
|
);
|
|
}
|
|
task=task->next;
|
|
if (task==loopTask) break;
|
|
}
|
|
// Now stream the flags
|
|
for (int id=0;id<MAX_FLAGS; id++) {
|
|
byte flag=flags[id];
|
|
if (flag & ~TASK_FLAG & ~SIGNAL_MASK) { // not interested in TASK_FLAG only. Already shown above
|
|
StringFormatter::send(stream,F("\nflags[%d] "),id);
|
|
if (flag & SECTION_FLAG) StringFormatter::send(stream,F(" RESERVED"));
|
|
if (flag & LATCH_FLAG) StringFormatter::send(stream,F(" LATCHED"));
|
|
}
|
|
}
|
|
|
|
if (compileFeatures & FEATURE_SIGNAL) {
|
|
// do the signals
|
|
// flags[n] represents the state of the nth signal in the table
|
|
for (int sigslot=0;;sigslot++) {
|
|
SIGNAL_DEFINITION slot=getSignalSlot(sigslot);
|
|
if (slot.type==sigtypeNoMoreSignals) break; // end of signal list
|
|
if (slot.type==sigtypeContinuation) continue; // continueation of previous line
|
|
byte flag=flags[sigslot] & SIGNAL_MASK; // obtain signal flags for this ids
|
|
StringFormatter::send(stream,F("\n%S[%d]"),
|
|
(flag == SIGNAL_RED)? F("RED") : (flag==SIGNAL_GREEN) ? F("GREEN") : F("AMBER"),
|
|
slot.id);
|
|
}
|
|
}
|
|
|
|
if (compileFeatures & FEATURE_STASH) {
|
|
for (int i=1;i<=maxStashId;i++) {
|
|
if (stashArray[i])
|
|
StringFormatter::send(stream,F("\nSTASH[%d] Loco=%d"),
|
|
i, stashArray[i]);
|
|
}
|
|
}
|
|
|
|
StringFormatter::send(stream,F(" *>\n"));
|
|
return true;
|
|
}
|
|
switch (p[0]) {
|
|
case "PAUSE"_hk: // </ PAUSE>
|
|
if (paramCount!=1) return false;
|
|
DCC::setThrottle(0,1,true); // pause all locos on the track
|
|
pausingTask=(RMFT2 *)1; // Impossible task address
|
|
return true;
|
|
|
|
case "RESUME"_hk: // </ RESUME>
|
|
if (paramCount!=1) return false;
|
|
pausingTask=NULL;
|
|
{
|
|
RMFT2 * task=loopTask;
|
|
while(task) {
|
|
if (task->loco) task->driveLoco(task->speedo);
|
|
task=task->next;
|
|
if (task==loopTask) break;
|
|
}
|
|
}
|
|
return true;
|
|
|
|
|
|
case "START"_hk: // </ START [cab] route >
|
|
if (paramCount<2 || paramCount>3) return false;
|
|
{
|
|
int route=(paramCount==2) ? p[1] : p[2];
|
|
uint16_t cab=(paramCount==2)? 0 : p[1];
|
|
int pc=routeLookup->find(route);
|
|
if (pc<0) return false;
|
|
RMFT2* task=new RMFT2(pc);
|
|
task->loco=cab;
|
|
}
|
|
return true;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// check KILL ALL here, otherwise the next validation confuses ALL with a flag
|
|
if (p[0]=="KILL"_hk && p[1]=="ALL"_hk) {
|
|
while (loopTask) loopTask->kill(F("KILL ALL")); // destructor changes loopTask
|
|
return true;
|
|
}
|
|
|
|
// all other / commands take 1 parameter
|
|
if (paramCount!=2 ) return false;
|
|
|
|
switch (p[0]) {
|
|
case "KILL"_hk: // Kill taskid|ALL
|
|
{
|
|
if ( p[1]<0 || p[1]>=MAX_FLAGS) return false;
|
|
RMFT2 * task=loopTask;
|
|
while(task) {
|
|
if (task->taskId==p[1]) {
|
|
task->kill(F("KILL"));
|
|
return true;
|
|
}
|
|
task=task->next;
|
|
if (task==loopTask) break;
|
|
}
|
|
}
|
|
return false;
|
|
|
|
case "RESERVE"_hk: // force reserve a section
|
|
return setFlag(p[1],SECTION_FLAG);
|
|
|
|
case "FREE"_hk: // force free a section
|
|
return setFlag(p[1],0,SECTION_FLAG);
|
|
|
|
case "LATCH"_hk:
|
|
return setFlag(p[1], LATCH_FLAG);
|
|
|
|
case "UNLATCH"_hk:
|
|
return setFlag(p[1], 0, LATCH_FLAG);
|
|
|
|
case "RED"_hk:
|
|
doSignal(p[1],SIGNAL_RED);
|
|
return true;
|
|
|
|
case "AMBER"_hk:
|
|
doSignal(p[1],SIGNAL_AMBER);
|
|
return true;
|
|
|
|
case "GREEN"_hk:
|
|
doSignal(p[1],SIGNAL_GREEN);
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|