version 2 protocol, test in main

protocol/main.c

@@ -2,36 +2,119 @@
 #include "stdio.h"
 
 int main(){
+//    union convert_float sample;
+//    sample.fVal = 135;
+//    union convert_float sample2;
+//    for(int i = 0; i < sizeof sample.buf; i++){
+//        printf("buffer %d: %d\n", i, sample.buf[i]);
+//        sample2.buf[i] = sample.buf[i];
+//    }
+//
+//    printf("float: %f\n", sample2.fVal);
+
+//    union convert_char sample;
+//    sample.cVal = "world_word_z";
+//    union convert_char sample2;
+//    for(int i = 0; i < sizeof sample.buf; i++){
+//        printf("buffer %d: %d\n", i, sample.buf[i]);
+//        sample2.buf[i] = sample.buf[i];
+//    }
+//
+//    printf("char: %s\n", sample2.cVal);
+
+
+//    char a[64];
+//    float f = 3.14159;  // number to start with
+//
+//    snprintf(a, sizeof a, "%f", f);   // point a to f's location
+//
+//    float num = atof(a);
+//
+//    printf("%s\n", a);
+//    printf("%f", num);
+//
+//    // print float & byte array as hex
+//    printf("float: %f\n", f);
+//    printf("byte array: %hhX:%hhX:%hhX:%hhX\n", \
+//    a[0], a[1], a[2], a[3]);
+
+//    uint8_t num;
+//    sscanf(a, "%s", &num);
+//    float s = atof(a);
+//    printf("%f\n", s);
+
+//    float vIn = -1.07231;
+//    char *vOut[4];
+//    _gcvt_s(vOut,sizeof(vOut),vIn,9);
+//
+//    float vA = (float)strtod(vOut,NULL);
+//
+//    printf("\n%f", vA);
+
     printf("Test number\n");
-    char number = 112;
+    struct message messNum;
+    messNum.numbers[0] = 12.134;
+    messNum.numbers[1] = 135.123;
+    messNum.numbers[2] = 5214.12;
+    messNum.numbers[3] = 12345.12345;
+    messNum.len_str = 0;
+    messNum.len_numbers = 4;
+
     uint8_t buffer_number[] = {};
     size_t len_buffer_number;
-    protocol_encode_number(number, buffer_number, &len_buffer_number);
+    protocol_encode(messNum, buffer_number, &len_buffer_number);
     for (int i = 0; i < len_buffer_number; i++){
         printf("buffer %d: %d\n", i, buffer_number[i]);
     }
 
     printf("---------------------------------------\n");
 
-    char encode_message_number[] = {};
+    struct message respNum;
-    size_t len_message_number;
+    protocol_decode(buffer_number, len_buffer_number, &respNum);
-    protocol_decode(buffer_number, len_buffer_number, encode_message_number, &len_message_number);
+    for (int i = 0; i < 4; i++){
-    printf("number: %d\n", encode_message_number[0]);
+        printf("number %d: %f\n", i, respNum.numbers[i]);
+    }
 
     printf("\nTest word\n");
-    char* word = "word";
+    struct message messStr;
+    messStr.str = "word_war";
+    messStr.len_str = sizeof messStr.str;
+    messStr.len_numbers = 0;
+    uint8_t bufferStr[] = {};
+    size_t len_bufferStr;
+    protocol_encode(messStr, bufferStr, &len_bufferStr);
+    for (int i = 0; i < len_bufferStr; i++){
+        printf("buffer %d: %d\n", i, bufferStr[i]);
+    }
+
+    printf("---------------------------------------\n");
+
+    struct message respStr;
+    protocol_decode(bufferStr, len_bufferStr, &respStr);
+    printf("message: %s\n", respStr.str);
+
+    printf("\nTest number + word\n");
+
+    struct message mess;
+    mess.numbers[0] = 12.134;
+    mess.numbers[1] = 135.123;
+    mess.len_numbers = 2;
+    mess.str = "word_war_sas";
+    mess.len_str = sizeof mess.str;
     uint8_t buffer[] = {};
     size_t len_buffer;
-    protocol_encode_word(word, strlen(word), buffer, &len_buffer);
+    protocol_encode(mess, buffer, &len_buffer);
     for (int i = 0; i < len_buffer; i++){
         printf("buffer %d: %d\n", i, buffer[i]);
     }
 
     printf("---------------------------------------\n");
 
-    char encode_message[] = {};
+    struct message resp;
-    size_t len_message;
+    protocol_decode(buffer, len_buffer, &resp);
-    protocol_decode(buffer, len_buffer, encode_message, &len_message);
+    for (int i = 0; i < resp.len_numbers; i++){
-    printf("message: %s\n", encode_message);
+        printf("numbers %d: %f\n", i, resp.numbers[i]);
-    return 0;
+    }
+    printf("message: %s\n", resp.str);
+
 }

protocol/protocol.c

@@ -1,39 +1,56 @@
 #include "protocol.h"
 
-void protocol_decode(uint8_t encode_message[], size_t len_encode_message, char decode_message[], size_t* len_decode_message){
+void protocol_decode(uint8_t encode_message[], size_t len_encode_message, struct message* decode_message){
-    int count = 0;
+    int count_number = 0;
     for(int i = 0; i < len_encode_message; i++){
-        switch (encode_message[i]) {
+        if (encode_message[i] == FLAG_NUMBER){
-            case FLAG_NUMBER:
+            union convert_float sample;
+            for (int z = 0; z < sizeof sample.buf; z++){
                 i++;
-                decode_message[count++] = encode_message[i]; // max 127
+                sample.buf[z] = encode_message[i];
-                i++;
+            }
-                break;
+            decode_message->numbers[count_number++] = sample.fVal;
-            case FLAG_WORD:
+            decode_message->len_numbers++;
+        }
+
+
+        if (encode_message[i] == FLAG_WORD){
+            int count_word = 0;
             i++;
+            union convert_char sample;
             for (int z = 0; z < encode_message[i]; z++){
                 i++;
-                    decode_message[count++] = encode_message[i];
+                sample.buf[z] = encode_message[i];
             }
-                break;
+            decode_message->str = sample.cVal;
+            decode_message->len_str = count_word;
         }
     }
-    *len_decode_message = count;
+    decode_message->len_numbers = count_number;
 }
 
-void protocol_encode_number(char number, uint8_t encode_message[], size_t* len_encode_message){
+void protocol_encode(struct message message, uint8_t encode_message[], size_t* len_encode_message){
-    int count = 0;
+    size_t count = 0;
+    if (message.len_numbers > 0){
+        for (int i = 0; i < message.len_numbers; i++){
             encode_message[count++] = FLAG_NUMBER;
-    encode_message[count++] = number;
+            union convert_float sample;
-    *len_encode_message = count;
+            sample.fVal = message.numbers[i];
+            for (int z = 0; z < sizeof sample.buf; z++){
+                encode_message[count++] = sample.buf[z];
+            }
+        }
     }
 
-void protocol_encode_word(char decode_word[], size_t len_encode_word, uint8_t encode_message[], size_t* len_encode_message){
+    if (message.len_str > 0){
-    int count = 0;
         encode_message[count++] = FLAG_WORD;
-    encode_message[count++] = len_encode_word;
+        encode_message[count++] = message.len_str;
-    for (int i = 0; i < len_encode_word; i++){
+        union convert_char sample;
-        encode_message[count++] = decode_word[i];
+        sample.cVal = message.str;
+        for (int i = 0; i < message.len_str; i++){
+            encode_message[count++] = sample.buf[i];
         }
+    }
+
     *len_encode_message = count;
 }

protocol/protocol.h

@@ -3,12 +3,30 @@
 
 #include <stdint.h>
 #include <string.h>
+#include <stdlib.h>
+#include "stdio.h"
 
 #define FLAG_NUMBER 0
 #define FLAG_WORD 1
 
-void protocol_decode(uint8_t encode_message[], size_t len_encode_message, char decode_message[], size_t* len_decode_message);
+struct message{
-void protocol_encode_number(char number, uint8_t encode_message[], size_t* len_encode_message);
+    float numbers[4];
-void protocol_encode_word(char decode_word[], size_t len_encode_word, uint8_t encode_message[], size_t* len_encode_message);
+    size_t len_numbers;
+    char* str;
+    size_t len_str;
+};
+
+union convert_float{
+    float fVal;
+    uint8_t buf[4];
+};
+
+union convert_char{
+    char* cVal;
+    uint8_t buf[64];
+};
+
+void protocol_decode(uint8_t encode_message[], size_t len_encode_message, struct message* decode_message);
+void protocol_encode(struct message message, uint8_t encode_message[], size_t* len_encode_message);
 
 #endif //PROTOCOL_H