buffersize updates

README.md

@@ -38,25 +38,21 @@ SimpleSerialProtocol has a very simple API so it should be very easy to implemen
 The protocol works as following, each packet has 3 seperate stages.
 
 ### ID
-This could be the device or service you want to reach.
+ID of packet (device)
 
-### Command
-This is the command you want to send to the device or service.
+### Type
+Type of packet (action)
 
 ### Data
-This is the data you want to send to the device or service.
+Data of packet (data)
 
 Of course you could change the use of any of these values to fit your needs.
 A complete packet would look like this:
 
 ```
-<ID_HERE:COMMAND_HERE:DATA_HERE>
+ID - TYPE - DATA
 ```
 
-As you can see the packet starts and ends with ``< - >`` characters and the stages are seperated with `` : `` characters.
-
-`This means you can't use any of these characters as data in the packets!!`
-
 Include SSP and define a new device.
 ```c++
 #include <SimpleSerialProtocol.h>
@@ -66,12 +62,12 @@ SimpleSerialProtocol device;
 ```
 
 Initialize the serial device and connection.
-First parameter is the serial channel. For example; the mega 2560 has 4 serial channels (RX0/TX0 through RX3/TX3) 
+First parameter is a serial object. For example; the mega 2560 has 4 serial channels (RX0/TX0 through RX3/TX3) so Serial, Serial1, Serial2 ... etc.
 Second parameter is the baud rate. 
 ```c++
 void setup() {
     // Initialize serial device on index 0 with a baud rate of 115200
-    device.init(0, 115200);
+    device.init(Serial, 115200);
 }
 ```
 
@@ -80,7 +76,7 @@ Now create a method (with a packet parameter) which will be called when a packet
 void onPacket(Packet packet) {
   Serial.println("Received Packet!");
   Serial.println(packet.id);
-  Serial.println(packet.command);
+  Serial.println(packet.type);
   Serial.println(packet.data);
   Serial.println("----------------");
 }
@@ -92,7 +88,7 @@ void loop() {
 ```
 To send packets you can use the ``sendPacket`` method.
 ```c++
-deviceOne.sendPacket("IDPacket", "Commandhere", "testtest");
+deviceOne.sendPacket("IDPacket", "Typehere", "testtest");
 ```
 ## Contributing
 Pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.

examples/ssp/ssp.ino

@@ -8,25 +8,22 @@ SimpleSerialProtocol deviceOne;
 void onPacket(Packet packet) {
     Serial.println("Received Packet!");
     Serial.println(packet.id);
-    Serial.println(packet.command);
+    Serial.println(packet.type);
     Serial.println(packet.data);
     Serial.println("----------------");
 
     // To send a packet
-    deviceOne.sendPacket("IDPacket", "Commandhere", "testtest");
+    deviceOne.sendPacket("IDPacket", "TypeHere", "testtest");
 }
 
 void setup() {
     // Initialize (deviceOne) serial device on index 0 with a baud rate of 115200.
-    deviceOne.init(0, 115200);
+    deviceOne.init(Serial, 115200);
 }
 
 void loop() {
     // Call receive packets function (looping) to handle incoming serial packets.
     // If a complete packet has been received it will call the callback function (onPacket).
     deviceOne.receivePackets(onPacket);
-    
-    // Small delay to not over overwork CPU.
-    delay(1);
 }
 

library.json

@@ -1,6 +1,6 @@
 {
     "name": "SimpleSerialProtocol",
-    "version": "1.1.0",
+    "version": "1.9.0",
     "description": "Easy-to-use serial protocol system for arduino type devices.",
     "keywords": "Serial, Connectivity, USB, Simple",
     "repository":

src/Packet.h

@@ -21,6 +21,6 @@
 struct Packet
 {
     char * id;
-    char * command;
+    char * type;
     char * data;
 };

src/SerialConnection.h

@@ -18,15 +18,14 @@
 *
 */
 
+#include <Arduino.h>
+
 class SerialConnection
 {
     private:
-        byte serialBufferSize = 300;
-        char serialBuffer[300];
-        char serialData[300] = {0};
-
-        const char packetStartMarker = '<';
-        const char packetEndMarker = '>';
+        int serialTransmitBufferSize = 960;
+        int serialBufferSize = 1024;
+        char serialBuffer[1024];
 
         // Receiving a new packet
         boolean newSerialData = false;
@@ -41,34 +40,21 @@ class SerialConnection
         Stream *serialRefrence;
 
     public:
-        void init(int serialIndex, unsigned long serialBaud);
-        void send(char * data);
+        const char packetStartMarker = 180;
+        const char packetMidMarker = 196;
+        const char packetEndMarker = 195;
+
+        void init(HardwareSerial &serialHandle, unsigned long serialBaud);
+        void send(char* data);
         char* handle();
-        char* getPacketMarker(int type);
-        int getBufferSize();
+        int getTransmitBufferSize();
         
 };
 
-void SerialConnection::init(int serialIndex, unsigned long serialBaud) {
-    if (serialIndex == 0) {
-        Serial.begin(serialBaud);
-        serialRefrence = &Serial;
-    } 
-    
-    else if (serialIndex == 1) {
-        Serial1.begin(serialBaud);
-        serialRefrence = &Serial1;
-    }
-
-    else if (serialIndex == 2) {
-        Serial2.begin(serialBaud);
-        serialRefrence = &Serial2;
-    }
-
-    else if (serialIndex == 3) {
-        Serial3.begin(serialBaud);
-        serialRefrence = &Serial3;
-    }
+void SerialConnection::init(HardwareSerial &serialHandle, unsigned long serialBaud) {
+    // serialBuffer[serialBufferSize] = {0};
+    serialRefrence = &serialHandle;
+    serialHandle.begin(serialBaud);
 };
 
 char* SerialConnection::handle() {
@@ -105,18 +91,10 @@ char* SerialConnection::handle() {
     return NULL;
 };
 
-void SerialConnection::send(char * data) {
+void SerialConnection::send(char* data) {
     serialRefrence->println(data);
 };
 
-char* SerialConnection::getPacketMarker(int type) {
-    if (type == 0) {
-        return "<";
-    } else {
-        return ">";
-    }
-};
-
-int SerialConnection::getBufferSize() {
-    return (int)serialBufferSize;
+int SerialConnection::getTransmitBufferSize() {
+    return (int)serialTransmitBufferSize;
 };

src/SimpleSerialProtocol.h

@@ -18,6 +18,8 @@
 *
 */
 
+#include <Arduino.h>
+
 #include "Packet.h"
 #include "SerialConnection.h"
 
@@ -26,23 +28,13 @@ class SimpleSerialProtocol
     private:
         SerialConnection serialConnection;
     public:
-        bool init(int deviceIndex, unsigned long baud);
+        bool init(HardwareSerial &serialHandle, unsigned long baud);
         bool receivePackets(void (*callback)(Packet));
         bool sendPacket(char* ID, char* command, char* data);
 };
 
-bool SimpleSerialProtocol::init(int deviceIndex, unsigned long baud) {
-    // Check if device index is in range
-    if (deviceIndex < 0 || deviceIndex > 4) {
-        return false;
-    }
-
-    // Init serial connection
-    serialConnection.init(deviceIndex, baud);
-    
-    // Serial Connection Delay
-    delay(5);
-
+bool SimpleSerialProtocol::init(HardwareSerial &serialHandle, unsigned long baud) {
+    serialConnection.init(serialHandle, baud);
     return true;
 };
 
@@ -52,30 +44,32 @@ bool SimpleSerialProtocol::receivePackets(void (*callback)(Packet)) {
 
     // Check if received a complete buffer
     if (receivedBuffer != NULL) {
-        int bufferSize = serialConnection.getBufferSize();
-
         // Buffer pointer
         char* strtokIndex;
-        char id[bufferSize / 2];
-        char command[bufferSize / 2];
-        char data[bufferSize / 2];
+
+        // Marker
+        char marker[1] = "";
+        marker[0] = serialConnection.packetMidMarker;
 
         // Get ID
-        strtokIndex = strtok(receivedBuffer, ":");
+        strtokIndex = strtok(receivedBuffer, marker);
+        char id[strlen(strtokIndex)];
         strcpy(id, strtokIndex);
 
-        // Get Command
-        strtokIndex = strtok(NULL, ":");
-        strcpy(command, strtokIndex);
-
+        // Get Type
+        strtokIndex = strtok(NULL, marker);
+        char type[strlen(strtokIndex)];
+        strcpy(type, strtokIndex);
+        
         // Get Data
-        strtokIndex = strtok(NULL, ":");
+        strtokIndex = strtok(NULL, marker);
+        char data[strlen(strtokIndex)];
         strcpy(data, strtokIndex);
 
         // Pack received data into packet
         Packet packet;
         packet.id = id;
-        packet.command = command;
+        packet.type = type;
         packet.data = data;
 
         // Call pointer callback function
@@ -89,14 +83,23 @@ bool SimpleSerialProtocol::receivePackets(void (*callback)(Packet)) {
     return false;
 };
 
-bool SimpleSerialProtocol::sendPacket(char* ID, char* command, char* data) {
+bool SimpleSerialProtocol::sendPacket(char* id, char* type, char* data) {
     // Create new packet buffer
-    char serialPacketBuffer[serialConnection.getBufferSize()];
+    char serialPacketBuffer[serialConnection.getTransmitBufferSize()];
 
     // Pack data in buffer
-    sprintf(serialPacketBuffer, "%s%s:%s:%s%s", serialConnection.getPacketMarker(0), ID, command, data, serialConnection.getPacketMarker(1));
-
+    sprintf(serialPacketBuffer, "%c%s%c%s%c%s%c", 
+        serialConnection.packetStartMarker, 
+        id, 
+        serialConnection.packetMidMarker,
+        type,
+        serialConnection.packetMidMarker,
+        data, 
+        serialConnection.packetEndMarker
+    );
+    
     // Send buffer to serial device
     serialConnection.send(serialPacketBuffer);
+
     return true;
 };