Merge remote-tracking branch 'origin/dev' into dev

hdlc/client.c

@@ -20,12 +20,12 @@ void init_hdlc_client(struct Client* client, int connecting_frame_timeout){
     connecting_frame_timeout_bf = connecting_frame_timeout;
     client->current_index_frame = 20;
 
-//    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;
+    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 hdlc_connect(struct Client* client){
@@ -36,7 +36,7 @@ void hdlc_connect(struct Client* client){
     client->current_index_frame = client->frameS.seq_no;
 }
 
-int hdlc_send_data(struct Client* client, uint8_t* data, size_t data_len){
+int hdlc_send_data(struct Client* client, uint8_t data[], size_t data_len){
     if (client->state != READY_STATE){
         return ERR_INVALID_STATE;
     }
@@ -49,7 +49,7 @@ int hdlc_send_data(struct Client* client, uint8_t* data, size_t data_len){
 
     client->frameI.seq_no = 0;
     client->frameI.frame = I_FRAME;
-    client->data_i_frame = *data;
+    client->data_i_frame = data;
     client->len_data_i_frame = data_len;
     client->current_index_frame = client->frameI.seq_no;
 
@@ -59,7 +59,7 @@ int hdlc_send_data(struct Client* client, uint8_t* data, size_t data_len){
 
 int hdlc_get_raw_frame(struct Client *client, uint8_t* buffer, size_t lenBuffer) {
     if(client->state == RECIVING){
-        int ret = hdlc_frame_data(client->frameI, &client->data_i_frame,
+        int ret = hdlc_frame_data(&client->frameI, client->data_i_frame,
                                   client->len_data_i_frame, buffer, &lenBuffer);
         if (ret < 0){
             printf("err in get_frame: %d\n", ret);
@@ -67,7 +67,7 @@ int hdlc_get_raw_frame(struct Client *client, uint8_t* buffer, size_t lenBuffer)
     }
 
     if (client->state == CONNECTING){
-        int ret = hdlc_frame_data(client->frameS, NULL, 0, buffer, &lenBuffer);
+        int ret = hdlc_frame_data(&client->frameS, NULL, 0, buffer, &lenBuffer);
 
         if (ret < 0){
             printf("err in get_frame: %d\n", ret);
@@ -75,7 +75,7 @@ int hdlc_get_raw_frame(struct Client *client, uint8_t* buffer, size_t lenBuffer)
     }
 
     if (client->state == DISCONNECTING){
-        int ret = hdlc_frame_data(client->frame_rej, NULL, 0, buffer, &lenBuffer);
+        int ret = hdlc_frame_data(&client->frame_rej, NULL, 0, buffer, &lenBuffer);
 
         if (ret < 0){
             printf("err in get_frame: %d\n", ret);
@@ -89,7 +89,7 @@ int hdlc_decode_recived_raw_data(struct Client* client, uint8_t* buffer, size_t
     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 (ret < 0) {
@@ -108,8 +108,11 @@ int hdlc_decode_recived_raw_data(struct Client* client, uint8_t* buffer, size_t
             client->state = READY_STATE;
             break;
         case I_FRAME:
-            *recived_data = buffer[3];
-            *len_recived_data = sizeof(buffer[3]);
+            for (int i = 0; i < sizeof(recive)-2; i++){
+                recived_data[i] = recive[i];
+            }
+
+            *len_recived_data = sizeof(recive)-2;
             break;
         case S_FRAME_NACK:
             client->state = DISCONNECTING;

hdlc/client.h

@@ -18,10 +18,10 @@ struct Client{
     enum HDLCState state;
     int connecting_frame_timeout; //-1
     uint8_t current_index_frame;
-    //hdlc_state_t current_state_hdlc;
+    hdlc_state_t current_state_hdlc;
     hdlc_control_t frameS;
     hdlc_control_t frameI;
-    uint8_t data_i_frame;
+    uint8_t* data_i_frame;
     size_t len_data_i_frame;
 //    hdlc_control_t frame3;
 //    hdlc_control_t frame4;
@@ -31,7 +31,7 @@ struct Client{
 //название функций
 void init_hdlc_client(struct Client* client, int connecting_frame_timeout);
 void hdlc_connect(struct Client* client);
-int hdlc_send_data(struct Client* client, uint8_t* data, size_t data_len);
+int hdlc_send_data(struct Client* client, uint8_t data[], size_t data_len);
 int hdlc_get_raw_frame(struct Client *client, uint8_t* buffer, size_t lenBuffer);
 //принимает буффер с уарта
 int hdlc_decode_recived_raw_data(struct Client* client, uint8_t* buffer, size_t len_buffer, uint8_t* recived_data, size_t* len_recived_data);

hdlc/hdlc.c

@@ -122,7 +122,8 @@ int hdlc_get_data(hdlc_control_t *control, uint8_t *src,
 
 //int hdlc_get_data_with_state(hdlc_state_t *state, hdlc_control_t *control, const char *src,
 //                               unsigned int src_len, char *dest, unsigned int *dest_len)
-int hdlc_get_data_with_state(hdlc_state_t *state, hdlc_control_t *control, uint8_t *src,
+int
+hdlc_get_data_with_state(hdlc_state_t *state, hdlc_control_t *control, uint8_t *src,
                              size_t src_len, uint8_t *dest, size_t *dest_len){
     int ret;
     char value;

hdlc/main.c

@@ -1,42 +1,40 @@
 //#include "hdlc.h"
-
+#include "stdio.h"
 #include "client.h"
 
 int main(){
     struct Client hdlc;
     init_hdlc_client(&hdlc, 200);
-    hdlc_control_t frame;
-    hdlc_connect(&hdlc, &frame);
+    hdlc_connect(&hdlc);
     uint8_t buffer_for_ex[20];
     uint8_t fake_buffer;
-    hdlc_get_raw_frame(&hdlc, &frame, &buffer_for_ex, sizeof(buffer_for_ex));
+    hdlc_get_raw_frame(&hdlc, buffer_for_ex, sizeof(buffer_for_ex));
 
     for (int i = 0; i < 200; i++){
         int z = hdlc_timeout_handler(&hdlc, 1);
         hdlc_decode_recived_raw_data(&hdlc, &fake_buffer, sizeof(fake_buffer), 0, 0);
     }
 
-    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), 0, 0);
+    hdlc_get_raw_frame(&hdlc, buffer_for_ex, sizeof(buffer_for_ex));
+    int i = hdlc_decode_recived_raw_data(&hdlc, buffer_for_ex, sizeof(buffer_for_ex), 0, 0);
     if (i < 0){
         printf("err connect: %d\n", i);
     }
 
-    hdlc_control_t frame_data;
-    uint8_t data = 33;
-    hdlc_send_data(&hdlc, &frame_data, &data, sizeof(data));
-    uint8_t buffer_for_ex_data[7];
+    uint8_t data[] = {32, 233, 132, 102, 12, 12, 44, 121, 34};
+    hdlc_send_data(&hdlc, data, sizeof(data));
+    uint8_t buffer_for_ex_data[20];
 
-    hdlc_get_raw_frame(&hdlc, &frame_data, &buffer_for_ex_data, sizeof(buffer_for_ex_data));
+    hdlc_get_raw_frame(&hdlc, buffer_for_ex_data, 20);
 
     //printf("first_ex:%d\n", buffer_for_ex_data[0]);
-    uint8_t recived_data;
-    size_t len_recived_data;
-    int x = hdlc_decode_recived_raw_data(&hdlc, &buffer_for_ex_data, sizeof(buffer_for_ex_data), &recived_data, &len_recived_data);
+    uint8_t recivedData[] = {};
+    size_t len_recived_data = 0;
+    int x = hdlc_decode_recived_raw_data(&hdlc, buffer_for_ex_data, 20, recivedData, &len_recived_data);
     if (x < 0){
         printf("err send: %d\n", x);
     }
-    printf("recived data: %d\n", recived_data);
+    printf("recived data: %d\n", recivedData[1]);