Serial command handler Improvements Help.

Projects Programming
14

tbillion:
id prefer hardware flow control.. but bluetooth modules dont do that... well hm06 doesnt anyway ... i dont particularily care how it is done, more or less it just cant be blocking, and if it missed part of the message it needs to chuc out the whole message ..

how hacky it turns out when im done is the only difference..

so this is a bit of overkill, but it will do what you want to do... which is pop out a message once you receive one...

In the constructor, define which Serial, the maximum message length, the start and end markers (use '\0' or NULL for no start marker, though NULL will generate a compiler warning which you may ignore) and the callback function to handle parsing the message...

#include <SoftwareSerial.h>

#define MAX_SERIAL_PORTS 5 // ToDo: define by device type

class SerialMessenger {
  public:
    SerialMessenger(HardwareSerial& device, size_t maxMessageLength, char startMarker, char endMarker, void (*parseFunction)(const char*)) {
      startMkr = startMarker;
      endMkr = endMarker;
      instances[instanceCount++] = this; 
      hwStream = &device; 
      callback = parseFunction;
      bufferSize = maxMessageLength;
      incomingMessage = new char[bufferSize + 1];
    }
    SerialMessenger(SoftwareSerial& device, size_t maxMessageLength, char startMarker, char endMarker, void (*parseFunction)(const char*)) {
      startMkr = startMarker;
      endMkr = endMarker;
      instances[instanceCount++] = this; 
      swStream = &device; 
      callback = parseFunction;
      bufferSize = maxMessageLength;
      incomingMessage = new char[bufferSize + 1];
    }
    ~SerialMessenger(){ free(incomingMessage); incomingMessage = NULL;}
    void begin(uint32_t baudRate);
    char* checkForValidMessage(const char startMarker, const char endMarker);
    static void update(void);
    
  private:
    HardwareSerial* hwStream;
    SoftwareSerial* swStream;
    Stream* stream;
    void (*callback)(const char*);
    char* incomingMessage;
    size_t bufferSize;
    size_t idx = 0;
    char startMkr;
    char endMkr;
    static size_t instanceCount;
    static SerialMessenger* instances[MAX_SERIAL_PORTS];
    enum State{
      WAITING,
      PARSING,
    }state = WAITING;
};

size_t SerialMessenger::instanceCount = 0;
SerialMessenger* SerialMessenger::instances[MAX_SERIAL_PORTS] = {nullptr};

void SerialMessenger::update()
{
  for (size_t i = 0; i < instanceCount; i++)
  {
    if (const char* message = instances[i]->checkForValidMessage(instances[i]->startMkr, instances[i]->endMkr))
    {
      instances[i]->callback(message);
    }
  }
}

char* SerialMessenger::checkForValidMessage(const char startMarker, const char endMarker) //, const char checksumToken)
{
  stream = !hwStream? (Stream*)swStream : hwStream;
  if (stream->available())
  {
    if (state == WAITING)
    {
      if(startMkr)
      {
        if (stream->read() == startMarker)
        {
          state = PARSING;
        }
        return nullptr;
      }
      else
      {
        state = PARSING;
      }
    }
    else if (state == PARSING)
    {
      incomingMessage[idx] = stream->read();
      if (incomingMessage[idx] == endMarker)
      {
        incomingMessage[idx] = '\0';
        idx = 0;
        if(startMkr) 
        {
          state = WAITING;
        }
        return incomingMessage;
      }
      else
      {
        idx++;
        if (idx > bufferSize - 1)
        {
          stream->println(F("Error, mssg length"));  //<< Error back to sender
          idx = 0;
          incomingMessage[idx] = '\0';
          if(startMkr)
          {
            state = WAITING;
          }
        }
      } 
    }
  }
  return nullptr;
}

void SerialMessenger::begin(uint32_t baudRate)
{
  if (hwStream)
  {
    hwStream->begin(baudRate);
  }
  else
  {
    swStream->begin(baudRate);
  }
}

/***********************************************************/
/**************** Class Definition Complete ****************/
/***********************************************************/

void parseMssg(const char* mssg);
//void softSerialMssg(const char* mssg);

SoftwareSerial softSerial(4,5);

SerialMessenger serial(Serial, 16, '<', '>', parseMssg);  
//SerialMessenger sw(softSerial, '\0', '\n', softSerialMssg);
//SerialMessenger serial1(Serial1);

void setup()
{
  serial.begin(57600);
  //sw.begin(19200);
  //serial1.begin(57600);
}


void loop()
{
  SerialMessenger::update();
}

void parseMssg(const char* mssg)
{
  Serial.println(mssg);
}

//void softSerialMssg(const char* mssg)
//{
//  Serial.println(mssg);
//}

Test it in your Serial monitor using current configuration and sending:

<Hello World!>

into the Serial Monitor

let me know if that gets you somewhere...