CommandStation-EX/DCCWaveform.cpp

/*
 *  @ 2024 Arkadiusz Hahn 
 *  © 2021 Neil McKechnie
 *  © 2021 Mike S
 *  © 2021 Fred Decker
 *  © 2020-2022 Harald Barth
 *  © 2020-2021 Chris Harlow
 *  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/>.
 */
#ifndef ARDUINO_ARCH_ESP32
  // This code is replaced entirely on an ESP32
#include <Arduino.h>

#include "DCCWaveform.h"
#include "TrackManager.h"
#include "DCCTimer.h"
#include "DCCACK.h"
#include "DIAG.h"


DCCWaveform  DCCWaveform::mainTrack(PREAMBLE_BITS_MAIN, true);
DCCWaveform  DCCWaveform::progTrack(PREAMBLE_BITS_PROG, false);

bool DCCWaveform::supportsRailcom=false;
bool DCCWaveform::useRailcom=false;

// This bitmask has 9 entries as each byte is trasmitted as a zero + 8 bits.
const byte bitMask[] = {0x00, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};

const byte idlePacket[] = {0xFF, 0x00, 0xFF};
const byte resetPacket[] = {0x00, 0x00, 0x00};


// For each state of the wave  nextState=stateTransform[currentState] 
const WAVE_STATE stateTransform[]={
   /* WAVE_START   -> */ WAVE_PENDING,
   /* WAVE_MID_1   -> */ WAVE_START,
   /* WAVE_HIGH_0  -> */ WAVE_MID_0,
   /* WAVE_MID_0   -> */ WAVE_LOW_0,
   /* WAVE_LOW_0   -> */ WAVE_START,
   /* WAVE_PENDING (should not happen) -> */ WAVE_PENDING};

// For each state of the wave, signal pin is HIGH or LOW   
const bool signalTransform[]={
   /* WAVE_START   -> */ HIGH,
   /* WAVE_MID_1   -> */ LOW,
   /* WAVE_HIGH_0  -> */ HIGH,
   /* WAVE_MID_0   -> */ LOW,
   /* WAVE_LOW_0   -> */ LOW,
   /* WAVE_PENDING (should not happen) -> */ LOW};

void DCCWaveform::begin() {
  // supportsRailcom depends on hardware capability
  supportsRailcom = TrackManager::isRailcomCapable();
  // useRailcom is user switchable at run time. 
  useRailcom=supportsRailcom;
  
  if (useRailcom) {
    DIAG(F("Railcom is enabled"));
  } else {
    DIAG(F("Railcom is disabled"));
  }

  TrackManager::setCutout(false,false);
  TrackManager::setPROGCutout(false,false);

  DCCTimer::begin(DCCWaveform::interruptHandler);     
}

void DCCWaveform::loop() {
 // empty placemarker in case ESP32 needs something here 
}


bool DCCWaveform::setUseRailcom(bool on) {
  if (!supportsRailcom) return false; 
  useRailcom=on;
  if (!on) {
    // turn off any existing cutout 
    TrackManager::setCutout(false);
    TrackManager::setPROGCutout(false);
  }
  return true;
}


#pragma GCC push_options
#pragma GCC optimize ("-O3")
void DCCWaveform::interruptHandler() {
  

  // call the timer edge sensitive actions for progtrack and maintrack
  // member functions would be cleaner but have more overhead
  byte sigMain= signalTransform[mainTrack.state];
  byte sigProg=TrackManager::progTrackSyncMain?  sigMain : signalTransform[progTrack.state];
  
  // Set the signal state for both tracks
  TrackManager::setDCCSignal(sigMain);
  TrackManager::setPROGSignal(sigProg);

  // Refresh the values in the ADCee object buffering the values of the ADC HW
  ADCee::scan();

  // WAVE_START is at start of bit where we need to find
  // out if this is an railcom start or stop time
  if (useRailcom) {
    if ((mainTrack.state==WAVE_START) || (mainTrack.state== WAVE_MID_1))  mainTrack.railcom2();
    if ((progTrack.state==WAVE_START) || (progTrack.state== WAVE_MID_1))  progTrack.railcom2();
  } 

  // Move on in the state engine
  mainTrack.state=stateTransform[mainTrack.state];    
  progTrack.state=stateTransform[progTrack.state];    
  
  // WAVE_PENDING means we dont yet know what the next bit is
  if ((mainTrack.state==WAVE_PENDING) || (mainTrack.state== WAVE_START))  mainTrack.interrupt2();  
  if ((progTrack.state==WAVE_PENDING) || (progTrack.state == WAVE_START))  {
    progTrack.interrupt2();
  } else {
    DCCACK::checkAck(progTrack.getResets());
  } 
}
#pragma GCC pop_options

// An instance of this class handles the DCC transmissions for one track. (main or prog)
// Interrupts are marshalled via the statics.
// A track has a current transmit buffer, and a pending buffer.
// When the current buffer is exhausted, either the pending buffer (if there is one waiting) or an idle buffer.



DCCWaveform::DCCWaveform( byte preambleBits, bool isMain) {
  isMainTrack = isMain;
  packetPending = false;
  memcpy(transmitPacket, idlePacket, sizeof(idlePacket));
  state = WAVE_START;
  // The +1 below is to allow the preamble generator to create the stop bit
  // for the previous packet. 
  requiredPreambles = preambleBits+1; 
  requiredPreambles <<=1;  // double the number of preamble wave halves

  remainingPreambles=0; 
  bytes_sent = 0;
  bits_sent = 0;
}

#pragma GCC push_options
#pragma GCC optimize ("-O3")
void DCCWaveform::railcom2() {
  bool cutout;
  if (remainingPreambles==(requiredPreambles-4)) { 
    cutout=true;
  } else if (remainingPreambles==(requiredPreambles-11)) {  
    cutout=false;
  } else {
    return; // neither start or end of cutout, do nothing
  }

  if (isMainTrack) {
    if (TrackManager::progTrackSyncMain) {// we are main track and synced so we take care of prog track as well
        TrackManager::setPROGCutout(cutout,true);
    }
    TrackManager::setCutout(cutout,true);
  } else {
    if (!TrackManager::progTrackSyncMain) {// we are prog track and not synced so we take care of ourselves
        TrackManager::setPROGCutout(cutout,true);
    } 
  }
}
#pragma GCC pop_options



#pragma GCC push_options
#pragma GCC optimize ("-O3")
void DCCWaveform::interrupt2() {
  // calculate the next bit to be sent:
  // set state WAVE_MID_1  for a 1=bit
  //        or WAVE_HIGH_0 for a 0 bit.

  if (remainingPreambles > 0 ) {
    if (state==WAVE_PENDING) {
      state=WAVE_MID_1;  // switch state to trigger LOW on next interrupt
    }
    remainingPreambles--;
  
    // Update free memory diagnostic as we don't have anything else to do this time.
    // Allow for checkAck and its called functions using 22 bytes more.
    DCCTimer::updateMinimumFreeMemoryISR(22); 
    return;
  }
  
  if (state==WAVE_PENDING) {
    // Wave has gone HIGH but what happens next depends on the bit to be transmitted
    // beware OF 9-BIT MASK  generating a zero to start each byte
    state=(transmitPacket[bytes_sent] & bitMask[bits_sent])? WAVE_MID_1 : WAVE_HIGH_0; 
    bits_sent++;

    // If this is the last bit of a byte, prepare for the next byte
 
    if (bits_sent == 9) { // zero followed by 8 bits of a byte
      //end of Byte
      bits_sent = 0;
      bytes_sent++;
      // if this is the last byte, prepere for next packet
      if (bytes_sent >= transmitLength) {
        // end of transmission buffer... repeat or switch to next message
        bytes_sent = 0;
        remainingPreambles = requiredPreambles;
		
        if (transmitRepeats > 0) {
          transmitRepeats--;
        }
        else if (packetPending) {
          // Copy pending packet to transmit packet
          // a fixed length memcpy is faster than a variable length loop for these small lengths
          // for (int b = 0; b < pendingLength; b++) transmitPacket[b] = pendingPacket[b];
          memcpy( transmitPacket, pendingPacket, sizeof(pendingPacket));
          
          transmitLength = pendingLength;
          transmitRepeats = pendingRepeats;
          packetPending = false;
          clearResets();
        }
        else {
          // Fortunately reset and idle packets are the same length
          memcpy( transmitPacket, isMainTrack ? idlePacket : resetPacket, sizeof(idlePacket));
          transmitLength = sizeof(idlePacket);
          transmitRepeats = 0;
          if (getResets() < 250) sentResetsSincePacket++; // only place to increment (private!)
        }
      }
    }  
  }
}
#pragma GCC pop_options

// Wait until there is no packet pending, then make this pending
void DCCWaveform::schedulePacket(const byte buffer[], byte byteCount, byte repeats) {
  if (byteCount > MAX_PACKET_SIZE) return; // allow for chksum
  while (packetPending);

  byte checksum = 0;
  for (byte b = 0; b < byteCount; b++) {
    checksum ^= buffer[b];
    pendingPacket[b] = buffer[b];
  }
  // buffer is MAX_PACKET_SIZE but pendingPacket is one bigger
  pendingPacket[byteCount] = checksum;
  pendingLength = byteCount + 1;
  pendingRepeats = repeats;
  packetPending = true;
  clearResets();
}
bool DCCWaveform::getPacketPending() {
  return packetPending;
}
#endif

#ifdef ARDUINO_ARCH_ESP32
#include "DCCWaveform.h"
#include "DCCACK.h"

DCCWaveform  DCCWaveform::mainTrack(PREAMBLE_BITS_MAIN, true);
DCCWaveform  DCCWaveform::progTrack(PREAMBLE_BITS_PROG, false);
RMTChannel *DCCWaveform::rmtMainChannel = NULL;
RMTChannel *DCCWaveform::rmtProgChannel = NULL;

DCCWaveform::DCCWaveform(byte preambleBits, bool isMain) {
  isMainTrack = isMain;
  requiredPreambles = preambleBits;
}
void DCCWaveform::begin() {
  for(const auto& md: TrackManager::getMainDrivers()) {
    pinpair p = md->getSignalPin();
    if(rmtMainChannel) {
      //DIAG(F("added pins %d %d to MAIN channel"), p.pin, p.invpin);
      rmtMainChannel->addPin(p); // add pin to existing main channel
    } else {
      //DIAG(F("new MAIN channel with pins %d %d"), p.pin, p.invpin);
      rmtMainChannel = new RMTChannel(p, true); /* create new main channel */
    }
  }
  MotorDriver *md = TrackManager::getProgDriver();
  if (md) {
    pinpair p = md->getSignalPin();
    if (rmtProgChannel) {
      //DIAG(F("added pins %d %d to PROG channel"), p.pin, p.invpin);
      rmtProgChannel->addPin(p); // add pin to existing prog channel
    } else {
      //DIAG(F("new PROGchannel with pins %d %d"), p.pin, p.invpin);
      rmtProgChannel = new RMTChannel(p, false);
    }
  }
}

void DCCWaveform::schedulePacket(const byte buffer[], byte byteCount, byte repeats) {
  if (byteCount > MAX_PACKET_SIZE) return; // allow for chksum
  
  byte checksum = 0;
  for (byte b = 0; b < byteCount; b++) {
    checksum ^= buffer[b];
    pendingPacket[b] = buffer[b];
  }
  // buffer is MAX_PACKET_SIZE but pendingPacket is one bigger
  pendingPacket[byteCount] = checksum;
  pendingLength = byteCount + 1;
  pendingRepeats = repeats;
// DIAG repeated commands (accesories)
//  if (pendingRepeats > 0)
//    DIAG(F("Repeats=%d on %s track"), pendingRepeats, isMainTrack ? "MAIN" : "PROG");
  // The resets will be zero not only now but as well repeats packets into the future
  clearResets(repeats+1);
  {
    int ret;
    do {
      if(isMainTrack) {
	if (rmtMainChannel != NULL)
	  ret = rmtMainChannel->RMTfillData(pendingPacket, pendingLength, pendingRepeats);
      } else {
	if (rmtProgChannel != NULL)
	  ret = rmtProgChannel->RMTfillData(pendingPacket, pendingLength, pendingRepeats);
      }
    } while(ret > 0);
  }
}

bool DCCWaveform::getPacketPending() {
  if(isMainTrack) {
    if (rmtMainChannel == NULL)
      return true;
    return rmtMainChannel->busy();
  } else {
    if (rmtProgChannel == NULL)
      return true;
    return rmtProgChannel->busy();
  }
}
void IRAM_ATTR DCCWaveform::loop() {
  DCCACK::checkAck(progTrack.getResets());
}
#endif