Change to the fix for the wifiTrax WFD-30,

Change to the fix for the_wifiTrax WFD-30, so that leading CR+LF is always sent
         - Removal of setSpeedCommandShouldBeSenttwice(bool twice)

README.md

@@ -115,9 +115,10 @@ WiThrottleProtocolDelegate *delegate
 This variable holds a pointer to a class that subclasses the ```WiThrottleProtocolDelegate``` class.  Once this is set, various methods will be called when protocol commands come in and have been processed.
 
 ```
-setSpeedCommandShouldBeSentTwice(bool twice)
+setCommandsNeedLeadingCrLf(bool needed);
 ```
-This should be set to true for wifiTrax to get around a fault in their implementation of WiThrottle protocol.
+For some reason WifiTrax WFD-30 system don't respond unless the commands are preceeded with CR+LF
+These will be sent if the SSID name contains "wftrx_"
 
 ### Fast Time 
 ```

library.properties

@@ -1,5 +1,5 @@
 name=WiThrottleProtocol
-version=1.1.10
+version=1.1.11
 author=David Zuhn <zoo@statebeltrailway.org>, Luca Dentella <luca@dentella.it>, Peter Akers <akersp62@gmail.com>
 maintainer=Peter Akers <akersp62@gmail.com>
 sentence=JMRI WiThrottle Protocol implementation

src/WiThrottleProtocol.cpp

@@ -57,7 +57,6 @@ void WiThrottleProtocol::init() {
 
     // output buffer
     outboundBuffer = "";
-    outboundBufferCommandsNeedsToBeSentTwice = "";
     outboundCmdsTimeLastSent = millis();
 
 	// init heartbeat
@@ -141,8 +140,8 @@ void WiThrottleProtocol::setDeviceID(String deviceId) {
     sendDelayedCommand(command);
 }
 
-void WiThrottleProtocol::setSpeedCommandsNeedToBeSentTwice(bool twice) {
-    speedCommandsNeedToBeSentTwice = twice;
+void WiThrottleProtocol::setCommandsNeedLeadingCrLf(bool needed) {
+    commandsNeedLeadingCrLf = needed;
 }
 
 
@@ -190,17 +189,9 @@ bool WiThrottleProtocol::check() {
 }
 
 void WiThrottleProtocol::sendCommand(String cmd) {
-    sendCommand(cmd, 0);
-}
-
-void WiThrottleProtocol::sendCommand(String cmd, bool twice) {
     if (stream) {
         // TODO: what happens when the write fails?
         stream->println(cmd);
-        if (twice) {
-            stream->println(cmd);
-            console->println("==> Sending Twice !!!!!!!!!!!");
-        }
         if (server) {
             stream->println("");
         }
@@ -209,56 +200,41 @@ void WiThrottleProtocol::sendCommand(String cmd, bool twice) {
 }
 
 void WiThrottleProtocol::sendDelayedCommand(String cmd) {
-    sendDelayedCommand(cmd, 0);
-}
-
-void WiThrottleProtocol::sendDelayedCommand(String cmd, bool twice) {
     if (stream) {
         // TODO: what happens when the write fails?
 
         if (cmd.length()>0) {
             outboundBuffer = outboundBuffer + cmd + '\n';
-            outboundBufferCommandsNeedsToBeSentTwice = outboundBufferCommandsNeedsToBeSentTwice + ((twice) ? "Y" : "N") +"\n";
-            // console->print("sendDelayedCommand() : "); console->print(cmd); console->print(" - twice: "); console->println(((twice) ? "Y" : "N"));
-            // console->println(" XTwice: ");  console->println(outboundBufferCommandsNeedsToBeSentTwice);
         }
 
         if ( (outboundBuffer.length()>0) &&((millis()-outboundCmdsTimeLastSent) > outboundCmdsMininumDelay) ) {
             // console->print("sendDelayedCommand() : Flushing outbound buffer - delay: "); console->print(outboundCmdsMininumDelay); console->print(" Buffer: ");  console->println(outboundBuffer);
             int end = outboundBuffer.indexOf("\n");
-            int endTwice = outboundBufferCommandsNeedsToBeSentTwice.indexOf("\n");
             String thisCmd = outboundBuffer; // default to sending the lot
-            bool thisTwice = false;
             if (end>0) {
                 thisCmd = outboundBuffer.substring(0,end);
-                thisTwice = (outboundBufferCommandsNeedsToBeSentTwice.substring(0,endTwice)=="Y") ? true : false;
                 end++;
-                endTwice++;
                 outboundBuffer = outboundBuffer.substring(end);
-                outboundBufferCommandsNeedsToBeSentTwice = outboundBufferCommandsNeedsToBeSentTwice.substring(endTwice);
                 if (outboundBuffer.length()>0) {
                     console->print("sendDelayedCommand() : deferring cmds: "); console->println(outboundCmdsMininumDelay); 
                     console->println(" Buffer: ");  console->println(outboundBuffer);
-                    console->println(" Twice: ");  console->println(outboundBufferCommandsNeedsToBeSentTwice);
                 }
             } else if (end==0) {
                 thisCmd = "";
                 outboundBuffer = outboundBuffer.substring(end+1);
             } else {
                 thisCmd = outboundBuffer;
-                thisTwice = twice;
                 outboundBuffer = "";
             }
 
             if (thisCmd.length()>0) {
                 outboundCmdsTimeLastSent = millis();
-                stream->println(thisCmd);
-                if (thisTwice) {
-                    stream->println(thisCmd);
-                    // console->println("==> Sending Twice !!!!!!!!!!!");
-                    console->print("==> "); console->print(thisCmd);
-                    console->print(" ("); console->print(millis()); console->println(")");
+                if (commandsNeedLeadingCrLf) {
+                    stream->write(0x0D);
+                    stream->write(0x0A);
                 }
+                stream->println(thisCmd);
+
                 if (server) {
                     stream->println("");
                 }
@@ -1261,7 +1237,7 @@ bool WiThrottleProtocol::setSpeed(char multiThrottle, int speed, bool forceSend)
             + PROPERTY_SEPARATOR
             + "V"
             + String(speed);
-        sendDelayedCommand(cmd, speedCommandsNeedToBeSentTwice);
+        sendDelayedCommand(cmd);
         currentSpeed[multiThrottleIndex] = speed;
     }
     return true;
@@ -1316,7 +1292,7 @@ bool WiThrottleProtocol::setDirection(char multiThrottle, String address, Direct
         else {
             cmd += "1";
         }
-        sendDelayedCommand(cmd, speedCommandsNeedToBeSentTwice);
+        sendDelayedCommand(cmd);
 
         if (address.equals(ALL_LOCOS_ON_THROTTLE)) {
             currentDirection[multiThrottleIndex] = direction;

src/WiThrottleProtocol.h

@@ -26,6 +26,25 @@
  *
  */
 
+/*
+Version information:
+
+1.1.11   - Change to the fix for the _wifiTrax WFD-30, so that leading CR+LF is always sent
+         - Removal of setSpeedCommandShouldBeSenttwice(bool twice)
+1.1.10   - discarded
+1.1.9    - discarded         
+1.1.8    - Addition of setSpeedCommandShouldBeSenttwice(bool twice)
+1.1.7    - Addition of minimum time separation/delay between commands sent
+1.1.6    - Change to support 32 functions
+1.1.5    - Adjust the aggressive heartbeat
+1.1.4    - Use more aggressive heartbeat commands
+1.1.3    - Add add ability to specify which loco in a consist is sent a function co…
+1.1.2    - Bug fix
+1.1.1    - Improve consist support
+1.1.0    - Muiti-throttle support added
+
+*/
+
 #ifndef WITHROTTLE_H
 #define WITHROTTLE_H
 
@@ -147,7 +166,7 @@ class WiThrottleProtocol
 	void setDelegate(WiThrottleProtocolDelegate *delegate, int delayBetweenCommandsSent);
     void setLogStream(Stream *console);
 
-    void setSpeedCommandsNeedToBeSentTwice(bool twice);
+    void setCommandsNeedLeadingCrLf(bool needed);
 
 	void connect(Stream *stream);
     void connect(Stream *stream, int delayBetweenCommandsSent);
@@ -229,10 +248,9 @@ class WiThrottleProtocol
     Stream *console;
 	NullStream nullStream;
     String outboundBuffer;
-    String outboundBufferCommandsNeedsToBeSentTwice;
     double outboundCmdsTimeLastSent;
     int outboundCmdsMininumDelay;
-    bool speedCommandsNeedToBeSentTwice = false;
+    bool commandsNeedLeadingCrLf = false;
 
 	WiThrottleProtocolDelegate *delegate = NULL;
 
@@ -264,9 +282,7 @@ class WiThrottleProtocol
     bool checkHeartbeat();
 
     void sendCommand(String cmd);
-    void sendCommand(String cmd, bool twice);
     void sendDelayedCommand(String cmd);
-    void sendDelayedCommand(String cmd, bool twice);
 
     void setCurrentFastTime(const String& s);