More adventures of the SLOG file transfer

// The FTP transfer utility
// Do NOT look to this for coding style pointers. QAD code.

//pragma(1) // pragma(1) Forces a compiler output listing be shown

int bSetupOk
int u8RxD
int iCRC,iRxState,iRxStuffed,iRxCMD,iRxLength,iRxCnt
str sRxData
int iTxCRC

const
  {
  // Comms stuff
  bSTUFF = $A6
  bSOM = $A7
  cmdGetDirectory = $44
  cmdReadFile = $52
  cmdWriteFile = $57
  cmdResetLogger = $5A
  cmdCRCFile = $43
  cmdDeleteFile = $A0
  cmdRenameFile = $A1
  cmdCopyFile = $A2
  // Oh, for enumerated types...
  sRxIdle = 0
  sRxExpCMD = 1
  sRxExpLEN0 = 2
  sRxExpLEN1 = 3
  sRxExpLEN2 = 4
  sRxExpDATA = 5
  sRxExpCRCL = 6
  sRxExpCRCH = 7
  }

// Forwards
int vHandleRxChar(int u8RxD);
int vHandleRxMsg();
int vHandleTxByte(int u8TxD);
int vHandleTxData(int iCMD, str sDATA);

// Setup the ESP port and BT port
bSetupOk = devicesetup(devESP,500000,parityNONE,2)
// Assume we are setup
iRxState = sRxIdle
iRxStuffed=0
// Now, we wait for a command
repeat
  while rxwait(devESP)<1
    {
    // We should sleep here
    }
  // We have at least one character waiting
  vHandleRxChar(rxread(devESP,u8))
until false

// Handle sending a stuffed byte
int vHandleTxByte(int u8TxD)
  {
  // CRC the damned thing
  crc16(iTxCRC,u8TxD)
  // Send it
  if u8TxD = bSTUFF
    {
    txwrite(devESP,u8 bSTUFF, 0)
    }
  else if u8TxD = bSOM
    {
    txwrite(devESP,u8 bSTUFF, 1)
    }
  else
    txwrite(devESP,u8 u8TxD)
  }

// Handle a received character
int vHandleRxChar(int u8RxD)
  {
  if u8RxD = bSOM
    {
    iRxState = sRxExpCMD
    iCRC = $FFFF
    }
  else if u8RxD = bSTUFF
    iRxStuffed = bSTUFF
  else
    {
    // Unstuff data bytes
    u8RxD+=iRxStuffed
    iRxStuffed=0;

    switch (iRxState)
      {
      case sRxExpCMD // Expect CMD
        iRxCMD = u8RxD
        crc16(iCRC,u8RxD)
        iRxState = sRxExpLEN0
        break
      case sRxExpLEN0 // Expect LEN LSB
        iRxLength = u8RxD
        crc16(iCRC,u8RxD)
        iRxState = sRxExpLEN1
        break
      case sRxExpLEN1 // Expect LEN MSB
        iRxLength += u8RxD * $100
        crc16(iCRC,u8RxD)
        iRxState = sRxExpLEN2
        break
      case sRxExpLEN2 // Expect LEN MSB
        iRxLength += u8RxD * $10000
        crc16(iCRC,u8RxD)
        // Do we have any data?
        sRxData = ""
        iRxCnt = 0
        if iRxLength>0
          iRxState = sRxExpDATA
        else
          iRxState = sRxExpCRCL
        break
      case sRxExpDATA
        sRxData = sRxData + chr$(u8RxD)
        crc16(iCRC,u8RxD)
        if ++iRxCnt >= iRxLength
          iRxState = sRxExpCRCL
        break;
      case sRxExpCRCL
        if u8RxD <> (iCRC and $FF)
          iRxState = sRxIdle
        else
          iRxState = sRxExpCRCH
        break;
      case sRxExpCRCH
        if u8RxD = (iCRC >> 8)
          {
          pragma(2)
          vHandleRxMsg()
          }
        iRxState = sRxIdle
        break;
      }
    }
  }

// Send a reply
int vHandleTxData(int iCMD, str sDATA)
  {
  int i,iLength,iTxCRCCopy

  txwrite(devESP,u8 bSOM)
  iTxCRC = $FFFF
  vHandleTxByte(iCMD)
  iLength = length(sDATA)
  vHandleTxByte(iLength and $FF)
  vHandleTxByte((iLength >> 8) and $FF)
  vHandleTxByte((iLength >> 16) and $FF)
  i=0
  while i<iLength
    {
    while txfree(devESP) < 2
      {
      // Should sleep here
      }
    // Send the next character (byte)
    vHandleTxByte(asc(mid$(sDATA,i++,1)))
    }
  // Now, send the CRC (Using a copy so we do not change it)
  iTxCRCCopy=iTxCRC
  vHandleTxByte(iTxCRCCopy)
  vHandleTxByte(iTxCRCCopy >> 8)
  }

// Extract a filename
string sGetRxFileName(int Offset)
  {
  int len

  len = asc(mid$(sRxData,Offset,1))
  return mid$(sRxData,Offset+1,len)
  }

// Handle a received message
int vHandleRxMsg()
  {
  string sFN,sFN2,sFile,sReply
  int iFileHandle,iFileError

  switch(iRxCMD)
    {
    case cmdGetDirectory
      vHandleTxData(cmdGetDirectory,filedir("/"))
      break

    case cmdReadFile
      sFN = sGetRxFileName(0)
      // Read the files contents
      iFileError = 1 // Assume an error if we cant even open the file
      iFileHandle=fileopen(sFN)
      // If we managed to open it, read the contents
      if iFileHandle
        {
        iFileError = 0
        // This will set an error if it couldnt read the file
        sFile = fileread(iFileHandle,iFileError, string -1) // Read as many are available
        fileclose(iFileHandle)
        }
      // If it was okay, send it
      if iFileError = 0
        {
        sReply = chr$(length(sFN)) + sFN + sFile
        vHandleTxData(cmdWriteFile,sReply)
        }
      else
        {
        // Else just reply with the filename
        sReply = chr$(length(sFN)) + sFN
        vHandleTxData(cmdWriteFile,sReply)
        }
      break

    case cmdWriteFile
      sFN = sGetRxFileName(0)
      println "Write a file",sFN
      break

    case cmdCRCFile
      sFN = sGetRxFileName(0)
      println "CRC a file",sFN
      break

    case cmdDeleteFile
      sFN = sGetRxFileName(0)
      filedelete(sFN)
      break

    case cmdRenameFile
      sFN = sGetRxFileName(0)
      sFN2 = sGetRxFileName(length(sFN)+1)
      filerename(sFN,sFN2)
      break

    case cmdCopyFile
      sFN = sGetRxFileName(0)
      sFN2 = sGetRxFileName(length(sFN)+1)
      filecopy(sFN,sFN2)
      break

    case cmdResetLogger
      reset // We just unceremoniously reset.
      break

    default
      println "Unknown command..."
    }
  }