ICS-Microprocessor-2020/Display_Avr_3
5
0
Fork 0
Code Issues 6 Pull Requests Projects Releases Wiki Activity

Compare commits

base: ICS-Microprocessor-2020:3f78f6b38fbae363ec6bd061bf003b3e31684354
Branches Tags
ICS-Microprocessor-2020:dev
ICS-Microprocessor-2020:uart
ICS-Microprocessor-2020:hdlc-interface
ICS-Microprocessor-2020:lcd1602_v2
ICS-Microprocessor-2020:i2c
ICS-Microprocessor-2020:master
..
compare: ICS-Microprocessor-2020:941a9feef6d17d3da60803a73c6e11bdc1696de3
Branches Tags
ICS-Microprocessor-2020:dev
ICS-Microprocessor-2020:uart
ICS-Microprocessor-2020:hdlc-interface
ICS-Microprocessor-2020:lcd1602_v2
ICS-Microprocessor-2020:i2c
ICS-Microprocessor-2020:master

No commits in common. "3f78f6b38fbae363ec6bd061bf003b3e31684354" and "941a9feef6d17d3da60803a73c6e11bdc1696de3" have entirely different histories.
3f78f6b38f ... 941a9feef6

3 changed files with 106 additions and 103 deletions
Show Stats Expand all files Collapse all files

150
hdlc/client.c
View File

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

24
hdlc/client.h
View File

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

35
hdlc/main.c
View File

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