Cynopolis/SerialMessage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactored to have a pure virtual bas class and added telnet capability

Browse Source
This commit is contained in:
Quinn
2024-08-07 08:57:07 -04:00
parent 6281fc9e7c
commit b5d9c9d666
5 changed files with 379 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
BluetoothSerialMessage.h
View File

@@ -2,18 +2,19 @@
#include "SerialMessage.h"
#include <BluetoothSerial.h>
template <uint16_t byteSize>
class BluetoothSerialMessage : public SerialMessage<byteSize>{
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
class BluetoothSerialMessage : public SerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>{
public:
/**
* @brief Construct a new Bluetooth Serial Message object
*/
BluetoothSerialMessage(BluetoothSerial *serial);
void Init(uint32_t baudRate) override{this->Init();}
/**
* @brief Initialize the BluetoothSerialMessage object
*/
void Init(uint32_t baudRate = 115200) override;
void Init();
/**
* @brief prints the args array to the serial monitor
@@ -28,32 +29,30 @@ class BluetoothSerialMessage : public SerialMessage<byteSize>{
uint32_t dataAvailable() override;
BluetoothSerial *serial;
};
template <uint16_t byteSize>
char BluetoothSerialMessage<byteSize>::getChar(){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
char BluetoothSerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::getChar(){
return serial->read();
}
template <uint16_t byteSize>
uint32_t BluetoothSerialMessage<byteSize>::dataAvailable(){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
uint32_t BluetoothSerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::dataAvailable(){
return serial->available();
}
template <uint16_t byteSize>
BluetoothSerialMessage<byteSize>::BluetoothSerialMessage(BluetoothSerial *serial){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
BluetoothSerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::BluetoothSerialMessage(BluetoothSerial *serial){
this->serial = serial;
}
template <uint16_t byteSize>
void BluetoothSerialMessage<byteSize>::Init(uint32_t baudRate){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void BluetoothSerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::Init(){
serial->begin("MiniBot");
}
template <uint16_t byteSize>
void BluetoothSerialMessage<byteSize>::PrintArgs(){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void BluetoothSerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::PrintArgs(){
serial->print("Current number of args: ");
serial->println(this->populatedArgs);
for (int i = 0; i < this->populatedArgs; i++) {

187
Message.h Normal file
View File

@@ -0,0 +1,187 @@
/**
* @file Message.h
* @brief This file contains the Message base class which is can be inherited to
* parse serial messages over any type of protocol
* @version 1.0.0
* @author Quinn Henthorne. Contact: quinn.henthorne@gmail.com
*/
#pragma once
#include <cstdint>
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
class Message{
public:
/**
* @brief Initialize the Message object
*/
virtual void Init(uint32_t baudRate);
/**
* @brief Prints the args array to the serial monitor
*/
virtual void PrintArgs() = 0;
/**
* @brief Update the Message object and parse any data that's available
*/
void Update();
/**
* @brief Returns true if there is new data available
* @return true if there is new data available
*/
bool IsNewData();
/**
* @brief Clears the new data flag
*/
void ClearNewData();
/**
* @brief Return a pointer to the args array
* @return a pointer to the args array
*/
int32_t * GetArgs();
/**
* @brief Returns the number of args that have been populated for the current message
* @return the number of args that have been populated for the current message
*/
uint32_t GetArgsLength();
/**
* @brief Returns the number of args that have been populated for the current message
* @return the number of args that have been populated for the current message
*/
uint32_t GetPopulatedArgs();
protected:
enum SerialState : uint8_t{
IDLE,
NEW_DATA,
DATA_RECIEVED,
RECIEVE_IN_PROGRESS
};
Message() = default;
/**
* @brief reads the serial data and stores it in the data array
* @return the next character in the serial buffer
*/
virtual char getChar() = 0;
/**
* @brief returns the number of bytes available in the serial buffer
* @return the number of bytes available in the serial buffer
*/
virtual uint32_t dataAvailable() = 0;
/**
* @brief Takes in any available serial data and reads it into the buffer if our start character is hit.
* Also marks what state the Message object is in
*/
void readSerial();
void parseData();
SerialState state{IDLE};
char data[SERIAL_BUFFER_SIZE]; // an array to store the received data
char temp_data[SERIAL_BUFFER_SIZE]; // an array that will be used with strtok()
uint32_t ndx{0};
uint32_t populatedArgs{0}; // the number of args that have been populated for the current message
int32_t args[MAX_ARGS];
const char startMarker = '!';
const char endMarker = ';';
};
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void Init(uint32_t baudRate){
Serial.println("You called Message::Init! This should NEVER happen!");
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void Message<SERIAL_BUFFER_SIZE, MAX_ARGS>::readSerial(){
char c;
// read the incoming serial data:
while (this->dataAvailable() > 0 && this->state != SerialState::DATA_RECIEVED) {
// get the neext character in the serial buffer
c = this->getChar();
// only execute this if the startMarker has been received
// if the incoming character is the endMarker clean up and set the flags
if (this->state == SerialState::RECIEVE_IN_PROGRESS) {
if (c == endMarker) {
data[ndx] = '\0'; // terminate the string
ndx = 0;
this->state = SerialState::DATA_RECIEVED;
}
// if the incoming character is not the endMarker
else {
// add it to the data array
data[ndx] = c;
ndx++; // increment the data array index
// if the index is greater than the maximum data array size,
// keep overwriting the last element until the endMarker is received.
if (ndx >= SERIAL_BUFFER_SIZE) {
ndx = SERIAL_BUFFER_SIZE - 1;
}
}
}
// if the incoming character is the startMarker, set the recvInProgress flag
else if (c == startMarker) {
this->state = SerialState::RECIEVE_IN_PROGRESS;
}
}
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void Message<SERIAL_BUFFER_SIZE, MAX_ARGS>::parseData() { // split the data into its parts
this->populatedArgs = 0; // reset the populated args counter
char * indx; // this is used by strtok() as an index
int i = 0;
indx = strtok(temp_data, ","); // get the first part - the string
while(indx != NULL){
this->args[i] = atoi(indx);
populatedArgs++;
i++;
indx = strtok(NULL, ","); // this continues where the previous call left off
}
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void Message<SERIAL_BUFFER_SIZE, MAX_ARGS>::Update(){
readSerial();
if (this->state == SerialState::DATA_RECIEVED) {
strcpy(temp_data, data);
// this temporary copy is necessary to protect the original data
// because strtok() used in parseData() replaces the commas with \0
parseData();
this->state = SerialState::NEW_DATA;
}
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
bool Message<SERIAL_BUFFER_SIZE, MAX_ARGS>::IsNewData(){
return this->state == SerialState::NEW_DATA;
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void Message<SERIAL_BUFFER_SIZE, MAX_ARGS>::ClearNewData(){
this->state = SerialState::IDLE;
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
int32_t * Message<SERIAL_BUFFER_SIZE, MAX_ARGS>::GetArgs(){
return args;
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
uint32_t Message<SERIAL_BUFFER_SIZE, MAX_ARGS>::GetArgsLength(){
return MAX_ARGS;
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
uint32_t Message<SERIAL_BUFFER_SIZE, MAX_ARGS>::GetPopulatedArgs(){
return populatedArgs;
}

194
SerialMessage.h
View File

@@ -6,16 +6,15 @@
* @author Quinn Henthorne. Contact: quinn.henthorne@gmail.com
*/
#ifndef SERIALMESSAGE_H
#define SERIALMESSAGE_H
#pragma once
#include "Arduino.h"
#include <Arduino.h>
template <uint16_t byteSize>
class SerialMessage{
#include "Message.h"
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
class SerialMessage : public Message<SERIAL_BUFFER_SIZE, MAX_ARGS>{
public:
// @warning Never use this to construct a SerialMessage object
SerialMessage() = delete;
/**
* @brief Construct a new Serial Message object
*/
@@ -24,202 +23,57 @@ class SerialMessage{
/**
* @brief Initialize the SerialMessage object
*/
virtual void Init(unsigned int baud_rate = 115200);
/**
* @brief Update the SerialMessage object and parse any data that's available
*/
void Update();
/**
* @brief Returns true if there is new data available
* @return true if there is new data available
*/
bool IsNewData();
/**
* @brief Clears the new data flag
*/
virtual void ClearNewData();
/**
* @brief Return a pointer to the args array
* @return a pointer to the args array
*/
int32_t * GetArgs();
/**
* @brief Returns the number of args that have been populated for the current message
* @return the number of args that have been populated for the current message
*/
uint32_t GetArgsLength();
/**
* @brief Returns the number of args that have been populated for the current message
* @return the number of args that have been populated for the current message
*/
uint32_t GetPopulatedArgs();
void Init(unsigned int baudRate) override;
/**
* @brief Prints the args array to the serial monitor
*/
virtual void PrintArgs();
void PrintArgs() override;
protected:
enum SerialState : uint8_t{
IDLE,
NEW_DATA,
DATA_RECIEVED,
RECIEVE_IN_PROGRESS
};
virtual void readSerial();
virtual void parseData();
/**
* @brief reads the serial data and stores it in the data array
* @return the next character in the serial buffer
*/
virtual char getChar();
char getChar() override;
/**
* @brief returns the number of bytes available in the serial buffer
* @return the number of bytes available in the serial buffer
*/
virtual uint32_t dataAvailable();
SerialState state{IDLE};
char data[byteSize]; // an array to store the received data
char temp_data[byteSize]; // an array that will be used with strtok()
uint32_t ndx{0};
static constexpr uint16_t args_length{30};
uint32_t populatedArgs{0}; // the number of args that have been populated for the current message
int32_t args[args_length];
const char startMarker = '!';
const char endMarker = ';';
uint32_t dataAvailable() override;
private:
HardwareSerial *serial{nullptr};
};
template <uint16_t byteSize>
char SerialMessage<byteSize>::getChar(){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
char SerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::getChar(){
return this->serial->read();
}
template <uint16_t byteSize>
uint32_t SerialMessage<byteSize>::dataAvailable(){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
uint32_t SerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::dataAvailable(){
return this->serial->available();
}
template <uint16_t byteSize>
SerialMessage<byteSize>::SerialMessage(HardwareSerial *serial) :
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
SerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::SerialMessage(HardwareSerial *serial) :
serial(serial){}
template <uint16_t byteSize>
void SerialMessage<byteSize>::Init(unsigned int baud_rate){
this->serial->begin(baud_rate);
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void SerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::Init(uint32_t baudRate){
this->serial->begin(baudRate);
}
template <uint16_t byteSize>
void SerialMessage<byteSize>::readSerial(){
char c;
// read the incoming serial data:
while (this->dataAvailable() > 0 && this->state != SerialState::DATA_RECIEVED) {
// get the neext character in the serial buffer
c = this->getChar();
// only execute this if the startMarker has been received
// if the incoming character is the endMarker clean up and set the flags
if (this->state == SerialState::RECIEVE_IN_PROGRESS) {
if (c == endMarker) {
data[ndx] = '\0'; // terminate the string
ndx = 0;
this->state = SerialState::DATA_RECIEVED;
}
// if the incoming character is not the endMarker
else {
// add it to the data array
data[ndx] = c;
ndx++; // increment the data array index
// if the index is greater than the maximum data array size,
// keep overwriting the last element until the endMarker is received.
if (ndx >= byteSize) {
ndx = byteSize - 1;
}
}
}
// if the incoming character is the startMarker, set the recvInProgress flag
else if (c == startMarker) {
this->state = SerialState::RECIEVE_IN_PROGRESS;
}
}
}
template <uint16_t byteSize>
void SerialMessage<byteSize>::parseData() { // split the data into its parts
this->populatedArgs = 0; // reset the populated args counter
char * indx; // this is used by strtok() as an index
int i = 0;
indx = strtok(temp_data, ","); // get the first part - the string
while(indx != NULL){
this->args[i] = atoi(indx);
populatedArgs++;
i++;
indx = strtok(NULL, ","); // this continues where the previous call left off
}
}
template <uint16_t byteSize>
void SerialMessage<byteSize>::Update(){
readSerial();
if (this->state == SerialState::DATA_RECIEVED) {
// for debug only:
// Serial.print("Received:");
// Serial.print(data);
// Serial.println(":End");
strcpy(temp_data, data);
// this temporary copy is necessary to protect the original data
// because strtok() used in parseData() replaces the commas with \0
parseData();
//PrintArgs();
this->state = SerialState::NEW_DATA;
}
}
template <uint16_t byteSize>
bool SerialMessage<byteSize>::IsNewData(){
return this->state == SerialState::NEW_DATA;
}
template <uint16_t byteSize>
void SerialMessage<byteSize>::ClearNewData(){
this->state = SerialState::IDLE;
}
template <uint16_t byteSize>
int32_t * SerialMessage<byteSize>::GetArgs(){
return args;
}
template <uint16_t byteSize>
uint32_t SerialMessage<byteSize>::GetArgsLength(){
return args_length;
}
template <uint16_t byteSize>
uint32_t SerialMessage<byteSize>::GetPopulatedArgs(){
return populatedArgs;
}
template <uint16_t byteSize>
void SerialMessage<byteSize>::PrintArgs(){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void SerialMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::PrintArgs(){
return;
this->serial->print("Current number of args: ");
this->serial->println(this->populatedArgs);
for (int i = 0; i < populatedArgs; i++) {
this->serial->print(args[i]);
for (int i = 0; i < this->populatedArgs; i++) {
this->serial->print(this->args[i]);
this->serial->print(" ");
}
this->serial->println();
}
#endif
}

138
TelnetMessage.h Normal file
View File

@@ -0,0 +1,138 @@
#pragma once
#include <ESPTelnet.h>
#include "SerialMessage.h"
#include "WiFi.h"
#include "GlobalPrint.h"
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
class TelnetMessage : public Message<SERIAL_BUFFER_SIZE, MAX_ARGS>{
public:
/**
* @brief Construct a new Bluetooth Serial Message object
*/
TelnetMessage(ESPTelnet *telnet) :
telnet(telnet){}
void Init(uint32_t baudRate) override{this->Init();}
/**
* @brief Initialize the TelnetMessage object
* @pre The WiFi object must have a state of WL_CONNECTED
*/
void Init();
/**
* @brief prints the args array to the telnet monitor
*/
void PrintArgs() override;
void SetString(const char * data);
void SetOnInputRecieved(void (*callback)(String data));
private:
/**
* @brief reads the telnet data and stores it in the data array
*/
char getChar() override;
/**
* @brief returns the amount of data available
*/
uint32_t dataAvailable() override;
static void onConnectCallback(String ip);
static void onConnectionAttemptCallback(String ip);
static void onReconnectCallback(String ip);
static void onDisconnectCallback(String ip);
ESPTelnet *telnet;
const char * incomingData = nullptr;
uint32_t incomingDataLength{0};
uint32_t incomingDataCharIndex{0};
};
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void TelnetMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::onConnectCallback(String ip) {
GlobalPrint::Print("- Telnet: ");
GlobalPrint::Print(ip);
GlobalPrint::Println(" connected");
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void TelnetMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::onConnectionAttemptCallback(String ip) {
GlobalPrint::Print("- Telnet: ");
GlobalPrint::Print(ip);
GlobalPrint::Println(" failed to connect");
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void TelnetMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::onReconnectCallback(String ip) {
GlobalPrint::Print("- Telnet: ");
GlobalPrint::Print(ip);
GlobalPrint::Println(" reconnected");
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void TelnetMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::onDisconnectCallback(String ip) {
GlobalPrint::Print("- Telnet: ");
GlobalPrint::Print(ip);
GlobalPrint::Println(" disconnected");
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void TelnetMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::SetOnInputRecieved(void (*callback)(String data)){
this->telnet->onInputReceived(callback);
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
char TelnetMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::getChar(){
// Stop us from reading any more data if there's nothing more to read
if(this->incomingData == nullptr || this->incomingDataLength == 0){
return this->endMarker;
}
char output = this->incomingData[this->incomingDataCharIndex];
this->incomingDataCharIndex++;
// GlobalPrint::Println("Char Idx:" + String(this->incomingDataCharIndex) + ", Data Length:" + String(this->incomingDataLength) + ", Char:" + output);
return output;
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void TelnetMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::SetString(const char * data){
this->incomingDataLength = strlen(data);
this->incomingDataCharIndex = 0;
this->incomingData = data;
this->Update();
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
uint32_t TelnetMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::dataAvailable(){
if(this->incomingData == nullptr){
return 0;
}
return this->incomingDataLength - this->incomingDataCharIndex;
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void TelnetMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::Init(){
telnet->begin(23);
// set all of our callbacks
telnet->onConnect(TelnetMessage::onConnectCallback);
telnet->onConnectionAttempt(TelnetMessage::onConnectionAttemptCallback);
telnet->onReconnect(TelnetMessage::onReconnectCallback);
telnet->onDisconnect(TelnetMessage::onDisconnectCallback);
}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void TelnetMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::PrintArgs(){
telnet->print("Current number of args: ");
telnet->println(this->populatedArgs);
for (int i = 0; i < this->populatedArgs; i++) {
telnet->print(this->args[i]);
telnet->print(" ");
}
telnet->println();
}

30
USBMessage.h
View File

@@ -2,14 +2,14 @@
#include "SerialMessage.h"
#include <Arduino.h>
template <uint16_t byteSize>
class USBMessage : public SerialMessage<byteSize>{
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
class USBMessage : public Message<SERIAL_BUFFER_SIZE, MAX_ARGS>{
public:
/**
* @brief Construct a new Bluetooth Serial Message object
* @brief Construct a new USB Serial Message object
*/
USBMessage(USBCDC *serial);
void Init(uint32_t baudRate = 115200) override;
void Init(uint32_t baudRate) override;
/**
* @brief prints the args array to the serial monitor
*/
@@ -23,26 +23,26 @@ class USBMessage : public SerialMessage<byteSize>{
};
template <uint16_t byteSize>
char USBMessage<byteSize>::getChar(){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
USBMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::USBMessage(USBCDC *USBSerial) : serial(USBSerial){}
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
char USBMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::getChar(){
return serial->read();
}
template <uint16_t byteSize>
uint32_t USBMessage<byteSize>::dataAvailable(){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
uint32_t USBMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::dataAvailable(){
return serial->available();
}
template <uint16_t byteSize>
USBMessage<byteSize>::USBMessage(USBCDC *serial) : serial(serial){}
template <uint16_t byteSize>
void USBMessage<byteSize>::Init(uint32_t baudRate){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void USBMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::Init(uint32_t baudRate){
serial->begin();
}
template <uint16_t byteSize>
void USBMessage<byteSize>::PrintArgs(){
template <uint32_t SERIAL_BUFFER_SIZE, uint32_t MAX_ARGS>
void USBMessage<SERIAL_BUFFER_SIZE, MAX_ARGS>::PrintArgs(){
serial->print("Current number of args: ");
serial->println(this->populatedArgs);
for (int i = 0; i < this->populatedArgs; i++) {