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

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
}