fix, add protocol and example in dir hdlc

hdlc/client.c

@@ -2,10 +2,6 @@
 #include "hdlc.h"
 #include "stdio.h"
 
-#define CONNECT_FRAME_PERIOD 200
-#define SIZE_DATA_BUFFER 64
-#define COUNT_BUFFERS 4
-
 #define ERR_INVALID_DATA_SIZE -1
 #define ERR_ALL_BUFFERS_FILL -2
 #define ERR_INVALID_PARAMS -3
@@ -14,120 +10,91 @@
 #define ERR_INVALID_SEQ_NUMBER_FRAME -6
 #define ERR_TIMEOUT_ANSWER -7
 
-uint8_t buffer_data[COUNT_BUFFERS][SIZE_DATA_BUFFER];
+#define SIZE_DATA_BUFFERS 64
 
-int init_hdlc_client(int count_buffers, int size_data_buffer, int connecting_frame_timeout, struct Client* client){
-    if (count_buffers <= 0){
-        return ERR_INVALID_PARAMS;
-    }
-
-    if (size_data_buffer <= 0){
-        return ERR_INVALID_PARAMS;
-    }
-
-    if (connecting_frame_timeout <= 0){
-        return ERR_INVALID_PARAMS;
-    }
+int connecting_frame_timeout_bf;
 
+void init_hdlc_client(struct Client* client, int connecting_frame_timeout){
     client->state = IDLE_STATE;
     client->connecting_frame_timeout = connecting_frame_timeout;
-    client->count_buffers = count_buffers;
-    client->size_data_buffer = size_data_buffer;
-    client->number_seq_frame = 0;
+    connecting_frame_timeout_bf = connecting_frame_timeout;
 
-    for (int i = 0; i < sizeof(buffer_data); i++){
-        for (int x = 0; x < sizeof(buffer_data[i]); x++){
-            buffer_data[i][x] = -1;
-        }
-    }
-    return 0;
+    client->current_state_hdlc.control_escape = 0;
+    client->current_state_hdlc.fcs = FCS_INIT_VALUE;
+    client->current_state_hdlc.start_index = -1;
+    client->current_state_hdlc.end_index = -1;
+    client->current_state_hdlc.src_index = 0;
+    client->current_state_hdlc.dest_index = 0;
 }
 
-void connect(struct Client* client){
+void connect(struct Client* client, hdlc_control_t* frame){
     client->state = CONNECTING;
+
+    client->frameS.seq_no = 0;
+    client->frameS.frame = S_FRAME;
+
+    *frame = client->frameS;
+
+//    if (client->frame1.seq_no == -4){
+//        client->frame1.seq_no = 0;
+//        client->frame1.frame = S_FRAME;
+//
+//        *frame = client->frame1;
+//    } else if (client->frame1.seq_no == -4){
+//        client->frame1.seq_no = 0;
+//        client->frame1.frame = S_FRAME;
+//
+//        *frame = client->frame1;
+//    }
 }
 
-int send_data(struct Client* client, uint8_t* data, size_t data_len){
+int send_data(struct Client* client, hdlc_control_t* frame, uint8_t* data, size_t data_len){
     if (client->state != READY_STATE){
         return ERR_INVALID_STATE;
     }
 
-    if (client->size_data_buffer < data_len){
+    client->state = RECIVING;
+
+    if (SIZE_DATA_BUFFERS < data_len){
         return ERR_INVALID_DATA_SIZE;
     }
 
-    for(int i = 0; i < COUNT_BUFFERS; i++){
-        if (buffer_data[i][0] == -1){
-            for (int x = 0; x < data_len; x++){
-                buffer_data[i][x] = data[x];
-            }
-        }
+    client->frameI.seq_no = 0;
+    client->frameI.frame = I_FRAME;
+    client->data_i_frame = *data;
+    client->len_data_i_frame = data_len;
 
-        if (i == COUNT_BUFFERS - 1){
-            return ERR_ALL_BUFFERS_FILL;
-        }
-    }
+    *frame = client->frameI;
 
     client->state = RECIVING;
 };
 
-int get_frame(struct Client *client, uint8_t buffer[], size_t lenBuffer) {
-    hdlc_control_t control_send;
-
-    switch (client->state) {
-        case CONNECTING:
-            if (client->connecting_frame_timeout <= 0){
-                control_send.frame = S_FRAME;
-                control_send.seq_no = 1;
-                client->number_seq_frame = control_send.seq_no;
-
-                int ret = hdlc_frame_data(&control_send, NULL, 0, buffer, &lenBuffer);
-                if (ret < 0){
-                    printf("err in get_frame ACK: %d\n", ret);
-                }
-
-                client->connecting_frame_timeout = CONNECT_FRAME_PERIOD;
-            }
-            break;
-        case READY_STATE:
-            control_send.frame = I_FRAME;
-            control_send.seq_no = 1;
-            for(int i = 0; i < COUNT_BUFFERS; i++){
-                if (buffer_data[i][0] == -1){
-                    int ret = hdlc_frame_data(&control_send, buffer_data[i], SIZE_DATA_BUFFER, buffer, &lenBuffer);
-                    if (ret < 0){
-                        printf("err in get_frame DATA: %d\n", ret);
-                    }
-                }
-
-                if (i == COUNT_BUFFERS - 1){
-                    return ERR_ALL_BUFFERS_FILL;
-                }
-            }
-            break;
+int hdlc_get_raw_frame(struct Client *client, hdlc_control_t* frame, uint8_t buffer[], size_t lenBuffer) {
+    if (frame->frame = S_FRAME){
+        int ret = hdlc_frame_data(frame, NULL, 0, buffer, &lenBuffer);
+        if (ret < 0){
+            printf("err in get_frame: %d\n", ret);
+        }
+    } else {
+        int ret = hdlc_frame_data(frame, &client->data_i_frame,
+                                  client->len_data_i_frame, buffer, &lenBuffer);
+        if (ret < 0){
+            printf("err in get_frame: %d\n", ret);
+        }
     }
 
-//   Yf
-
     return 0;
 }
 
-int hdlc_get_raw_data(struct Client* client, uint8_t buffer[], size_t len_buffer){
-    if (client->connecting_frame_timeout <= 0){
-        return ERR_FRAME_TIME_OUT;
-    }
-
+int hdlc_decode_recived_raw_data(struct Client* client, uint8_t buffer[], size_t len_buffer){
     hdlc_control_t recv_control;
     uint8_t recive[len_buffer];
 
-    int ret = hdlc_get_data(&recv_control, buffer, len_buffer, recive,
+    int ret = hdlc_get_data_with_state(&client->current_state_hdlc, &recv_control, buffer, len_buffer, recive,
                             &len_buffer);
-    if (recv_control.seq_no != client->number_seq_frame){
-        return ERR_INVALID_SEQ_NUMBER_FRAME;
-    }
 
-    if (ret < 0 && client->connecting_frame_timeout < 0){
-        return ERR_TIMEOUT_ANSWER;
+    if (ret < 0) {
+        return ret;
     }
 
     switch (recv_control.frame) {
@@ -137,11 +104,20 @@ int hdlc_get_raw_data(struct Client* client, uint8_t buffer[], size_t len_buffer
         case I_FRAME:
             break;
         case S_FRAME_NACK:
+            client->state = DISCONNECTING;
+            client->frame_rej.seq_no = 0;
+            client->frame_rej.frame = S_FRAME_NACK;
             break;
     }
+
+    client->connecting_frame_timeout = connecting_frame_timeout_bf;
     return 0;
 }
 
-void hdlc_timeout_handler(struct Client* client, int delta_time){
+int hdlc_timeout_handler(struct Client* client, int delta_time){
     client->connecting_frame_timeout -= delta_time;
+
+    if (client->connecting_frame_timeout <= 0){
+        return ERR_FRAME_TIME_OUT;
+    }
 }

hdlc/client.h

@@ -3,6 +3,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "hdlc.h"
 
 enum HDLCState {
     UNINITIALIZED_STATE = 0,  // состояние до инцилизации
@@ -16,18 +17,23 @@ enum HDLCState {
 struct Client{
     enum HDLCState state;
     int connecting_frame_timeout; //-1
-    int size_data_buffer;
-    int count_buffers;
-    int number_seq_frame;
+    hdlc_state_t current_state_hdlc;
+    hdlc_control_t frameS;
+    hdlc_control_t frameI;
+    uint8_t data_i_frame;
+    size_t len_data_i_frame;
+//    hdlc_control_t frame3;
+//    hdlc_control_t frame4;
+    hdlc_control_t frame_rej;
 };
 
 //название функций
-int init_hdlc_client(int count_buffers, int size_data_buffer, int connecting_frame_timeout, struct Client* client);
-void connect(struct Client* client);
-int send_data(struct Client* client, uint8_t* data, size_t data_len);
-int get_frame(struct Client *client, uint8_t buffer[], size_t lenBuffer);
+void init_hdlc_client(struct Client* client, int connecting_frame_timeout);
+void connect(struct Client* client, hdlc_control_t* frame);
+int send_data(struct Client* client, hdlc_control_t* frame, uint8_t* data, size_t data_len);
+int hdlc_get_raw_frame(struct Client *client, hdlc_control_t* frame, uint8_t buffer[], size_t lenBuffer);
 //принимает буффер с уарта
-int hdlc_get_raw_data(struct Client* client, uint8_t buffer[], size_t len_buffer);
-void hdlc_timeout_handler(struct Client* client, int delta_time);
+int hdlc_decode_recived_raw_data(struct Client* client, uint8_t buffer[], size_t len_buffer);
+int hdlc_timeout_handler(struct Client* client, int delta_time);
 
 #endif //CLIENT_H

hdlc/main.c

@@ -6,20 +6,35 @@
 
 int main(){
     struct Client hdlc;
-    init_hdlc_client(2, 64, 200, &hdlc);
-    connect(&hdlc);
-    uint8_t frame_data[8];
-    uint8_t buffer_for_ex[8];
-    get_frame(&hdlc, frame_data, sizeof(frame_data));
+    init_hdlc_client(&hdlc, 200);
+    hdlc_control_t frame;
+    connect(&hdlc, &frame);
+    uint8_t buffer_for_ex[25];
+    uint8_t fake_buffer[2];
+    hdlc_get_raw_frame(&hdlc, &frame, buffer_for_ex, sizeof(buffer_for_ex));
 
     for (int i = 0; i < 200; i++){
-        hdlc_timeout_handler(&hdlc, 1);
-        hdlc_get_raw_data(&hdlc, buffer_for_ex, sizeof(buffer_for_ex));
+        int z = hdlc_timeout_handler(&hdlc, 1);
+        if (z < 0){
+            printf("%d\n", z);
+        }
+        hdlc_decode_recived_raw_data(&hdlc, fake_buffer, sizeof(fake_buffer));
     }
 
-    get_frame(&hdlc, frame_data, sizeof(frame_data));
-    int i = hdlc_get_raw_data(&hdlc, frame_data, sizeof(frame_data));
-    printf("%d", i);
+    hdlc_get_raw_frame(&hdlc, &frame, buffer_for_ex, sizeof(buffer_for_ex));
+    int i = hdlc_decode_recived_raw_data(&hdlc, buffer_for_ex, sizeof(buffer_for_ex));
+    printf("%d\n", i);
+
+    hdlc_control_t frame_data;
+    uint8_t data = 003;
+    send_data(&hdlc, &frame_data, &data, sizeof(data));
+    uint8_t buffer_for_ex_data[128];
+
+    hdlc_get_raw_frame(&hdlc, &frame_data, buffer_for_ex_data, sizeof(buffer_for_ex_data));
+
+    i = hdlc_decode_recived_raw_data(&hdlc, buffer_for_ex_data, sizeof(buffer_for_ex_data));
+    printf("%d\n", i);
+
 
 
 //    uint8_t send[64];