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

rework send frames and init client

Browse Source
This commit is contained in:
Qukich 2024-01-12 14:17:34 +03:00
parent 26c316f47a
commit 941a9feef6
5 changed files with 101 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

141
hdlc/client.c
View File

@ -1,31 +1,46 @@
#include "client.h" #include "client.h"
#include "hdlc.h" #include "hdlc.h"
#include "stdio.h" #include "stdio.h"
#include "stdbool.h"
#define CONNECT_FRAME_PERIOD 200 #define CONNECT_FRAME_PERIOD 200
#define SIZE_DATA_BUFFER 64 #define SIZE_DATA_BUFFER 64
#define COUNT_BUFFERS 4 #define COUNT_BUFFERS 4
bool FLAG_FILL_BUFFER1 = false;
bool FLAG_FILL_BUFFER2 = false;
bool FLAG_FILL_BUFFER3 = false;
bool FLAG_FILL_BUFFER4 = false;
bool FLAG_SEND_BUFFER1 = false;
bool FLAG_SEND_BUFFER2 = false;
bool FLAG_SEND_BUFFER3 = false;
bool FLAG_SEND_BUFFER4 = false;
#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
struct Client hdlc_client; #define ERR_INVALID_STATE -4
#define ERR_FRAME_TIME_OUT -5
#define ERR_INVALID_SEQ_NUMBER_FRAME -6
#define ERR_TIMEOUT_ANSWER -7
uint8_t buffer_data[COUNT_BUFFERS][SIZE_DATA_BUFFER]; uint8_t buffer_data[COUNT_BUFFERS][SIZE_DATA_BUFFER];
struct Client init_hdlc_client(enum HDLCState *state){ int init_hdlc_client(int count_buffers, int size_data_buffer, int connecting_frame_timeout, struct Client* client){
return hdlc_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;
}
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;
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;
} }
void connect(struct Client* client){ void connect(struct Client* client){
@ -33,42 +48,30 @@ void connect(struct Client* client){
} }
int send_data(struct Client* client, uint8_t* data, size_t data_len){ int send_data(struct Client* client, uint8_t* data, size_t data_len){
if (data_len > 64){ if (client->state != READY_STATE){
return ERR_INVALID_STATE;
}
if (client->size_data_buffer < data_len){
return ERR_INVALID_DATA_SIZE; return ERR_INVALID_DATA_SIZE;
} }
if (!FLAG_FILL_BUFFER1){ for(int i = 0; i < COUNT_BUFFERS; i++){
for(int i = 0; i < SIZE_DATA_BUFFER; i++){ if (buffer_data[i][0] == -1){
buffer_data[0][i] = data[i]; for (int x = 0; x < data_len; x++){
buffer_data[i][x] = data[x];
}
} }
FLAG_FILL_BUFFER1 = true; if (i == COUNT_BUFFERS - 1){
} else if (!FLAG_FILL_BUFFER2){
for(int i = 0; i < SIZE_DATA_BUFFER; i++){
buffer_data[1][i] = data[i];
}
FLAG_FILL_BUFFER2 = true;
} else if (!FLAG_FILL_BUFFER3){
for(int i = 0; i < SIZE_DATA_BUFFER; i++){
buffer_data[2][i] = data[i];
}
FLAG_FILL_BUFFER3 = true;
} if (!FLAG_FILL_BUFFER4){
for(int i = 0; i < SIZE_DATA_BUFFER; i++){
buffer_data[3][i] = data[i];
}
FLAG_FILL_BUFFER4 = true;
} else {
return ERR_ALL_BUFFERS_FILL; return ERR_ALL_BUFFERS_FILL;
} }
}
client->state = READY_STATE; client->state = RECIVING;
}; };
int get_frame(struct Client* client, uint8_t buffer[], size_t lenBuffer){ int get_frame(struct Client *client, uint8_t buffer[], size_t lenBuffer) {
hdlc_control_t control_send; hdlc_control_t control_send;
switch (client->state) { switch (client->state) {
@ -76,10 +79,11 @@ int get_frame(struct Client* client, uint8_t buffer[], size_t lenBuffer){
if (client->connecting_frame_timeout <= 0){ if (client->connecting_frame_timeout <= 0){
control_send.frame = S_FRAME; control_send.frame = S_FRAME;
control_send.seq_no = 1; control_send.seq_no = 1;
client->number_seq_frame = control_send.seq_no;
int ret = hdlc_frame_data(&control_send, NULL, 0, buffer, &lenBuffer); int ret = hdlc_frame_data(&control_send, NULL, 0, buffer, &lenBuffer);
if (ret < 0){ if (ret < 0){
printf("err in get_frame S_FRAME: %d\n", ret); printf("err in get_frame ACK: %d\n", ret);
} }
client->connecting_frame_timeout = CONNECT_FRAME_PERIOD; client->connecting_frame_timeout = CONNECT_FRAME_PERIOD;
@ -88,33 +92,17 @@ int get_frame(struct Client* client, uint8_t buffer[], size_t lenBuffer){
case READY_STATE: case READY_STATE:
control_send.frame = I_FRAME; control_send.frame = I_FRAME;
control_send.seq_no = 1; control_send.seq_no = 1;
if (FLAG_FILL_BUFFER1 && !FLAG_SEND_BUFFER1){ for(int i = 0; i < COUNT_BUFFERS; i++){
int ret = hdlc_frame_data(&control_send, buffer_data[0], SIZE_DATA_BUFFER, buffer, &lenBuffer); if (buffer_data[i][0] == -1){
int ret = hdlc_frame_data(&control_send, buffer_data[i], SIZE_DATA_BUFFER, buffer, &lenBuffer);
if (ret < 0){ if (ret < 0){
printf("err in get_frame I_FRAME: %d\n", ret); printf("err in get_frame DATA: %d\n", ret);
} }
FLAG_SEND_BUFFER1 = true;
} }
if (FLAG_FILL_BUFFER2 && !FLAG_SEND_BUFFER2){
int ret = hdlc_frame_data(&control_send, buffer_data[1], SIZE_DATA_BUFFER, buffer, &lenBuffer); if (i == COUNT_BUFFERS - 1){
if (ret < 0){ return ERR_ALL_BUFFERS_FILL;
printf("err in get_frame I_FRAME: %d\n", ret);
} }
FLAG_SEND_BUFFER2 = true;
}
if (FLAG_FILL_BUFFER3 && !FLAG_SEND_BUFFER3){
int ret = hdlc_frame_data(&control_send, buffer_data[2], SIZE_DATA_BUFFER, buffer, &lenBuffer);
if (ret < 0){
printf("err in get_frame I_FRAME: %d\n", ret);
}
FLAG_SEND_BUFFER3 = true;
}
if (FLAG_FILL_BUFFER4 && !FLAG_SEND_BUFFER4){
int ret = hdlc_frame_data(&control_send, buffer_data[3], SIZE_DATA_BUFFER, buffer, &lenBuffer);
if (ret < 0){
printf("err in get_frame I_FRAME: %d\n", ret);
}
FLAG_SEND_BUFFER4 = true;
} }
break; break;
} }
@ -125,16 +113,31 @@ int get_frame(struct Client* client, uint8_t buffer[], size_t lenBuffer){
} }
int hdlc_get_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(&recv_control, buffer, len_buffer, recive, int ret = hdlc_get_data(&recv_control, buffer, len_buffer, recive,
&len_buffer); &len_buffer);
if (ret < 0){ if (recv_control.seq_no != client->number_seq_frame){
printf("err in get_raw_data: %d\n", ret); return ERR_INVALID_SEQ_NUMBER_FRAME;
} }
if (recv_control.frame == HDLC_FRAME_ACK){
client->state = IDLE_STATE; if (ret < 0 && client->connecting_frame_timeout < 0){
return ERR_TIMEOUT_ANSWER;
}
switch (recv_control.frame) {
case S_FRAME:
client->state = READY_STATE;
break;
case I_FRAME:
break;
case S_FRAME_NACK:
break;
} }
return 0; return 0;
} }

9
hdlc/client.h
View File

@ -10,19 +10,22 @@ enum HDLCState {
READY_STATE, // Состояние принятия READY_STATE, // Состояние принятия
CONNECTING, // состояние соединения CONNECTING, // состояние соединения
DISCONNECTING, // состояния отключения DISCONNECTING, // состояния отключения
RECIVED // состояние приема и отправки RECIVING // состояние приема и отправки
}; };
struct Client{ struct Client{
enum HDLCState state; enum HDLCState state;
int connecting_frame_timeout; //-1 int connecting_frame_timeout; //-1
int size_data_buffer;
int count_buffers;
int number_seq_frame;
}; };
//название функций //название функций
struct Client init_hdlc_client(enum HDLCState *state); int init_hdlc_client(int count_buffers, int size_data_buffer, int connecting_frame_timeout, struct Client* client);
void connect(struct Client* client); void connect(struct Client* client);
int send_data(struct Client* client, uint8_t* data, size_t data_len); 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); int get_frame(struct Client *client, uint8_t buffer[], size_t lenBuffer);
//принимает буффер с уарта //принимает буффер с уарта
int hdlc_get_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);
void hdlc_timeout_handler(struct Client* client, int delta_time); void hdlc_timeout_handler(struct Client* client, int delta_time);

2
hdlc/hdlc.c
View File

@ -236,7 +236,7 @@ int hdlc_frame_data(hdlc_control_t *control, uint8_t *src,
hdlc_escape_value(value, dest, &dest_index); hdlc_escape_value(value, dest, &dest_index);
// Only DATA frames should contain data // Only DATA frames should contain data
if (control->frame == HDLC_FRAME_DATA) { if (control->frame == I_FRAME) {
// Calculate FCS and escape data // Calculate FCS and escape data
for (i = 0; i < src_len; i++) { for (i = 0; i < src_len; i++) {
fcs = calc_fcs(fcs, src[i]); fcs = calc_fcs(fcs, src[i]);

30
hdlc/main.c
View File

@ -6,21 +6,31 @@
int main(){ int main(){
struct Client hdlc; struct Client hdlc;
init_hdlc_client(2, 64, 200, &hdlc);
connect(&hdlc); connect(&hdlc);
uint8_t frame_data[8]; uint8_t frame_data[8];
get_frame(&hdlc, frame_data, sizeof(frame_data), 0, 0); uint8_t buffer_for_ex[8];
get_frame(&hdlc, frame_data, sizeof(frame_data));
hdlc_get_raw_data(&hdlc, frame_data, sizeof(frame_data)); for (int i = 0; i < 200; i++){
hdlc_timeout_handler(&hdlc, 1);
uint8_t send[64]; hdlc_get_raw_data(&hdlc, buffer_for_ex, sizeof(buffer_for_ex));
uint8_t buffer[134];
for (int i = 0; i < sizeof(send); i++) {
send[i] = (uint8_t) (rand() % 0x70);
} }
send_data(&hdlc, send, sizeof(send_data));
//get_frame(&hdlc, buffer, sizeof(buffer), send_data, sizeof(send_data));
hdlc_get_raw_data(&hdlc, buffer, sizeof(buffer)); get_frame(&hdlc, frame_data, sizeof(frame_data));
int i = hdlc_get_raw_data(&hdlc, frame_data, sizeof(frame_data));
printf("%d", i);
// uint8_t send[64];
// uint8_t buffer[134];
// for (int i = 0; i < sizeof(send); i++) {
// send[i] = (uint8_t) (rand() % 0x70);
// }
// send_data(&hdlc, send, sizeof(send_data));
// //get_frame(&hdlc, buffer, sizeof(buffer), send_data, sizeof(send_data));
//
// hdlc_get_raw_data(&hdlc, buffer, sizeof(buffer));
// test 1 // test 1

56
hdlc_frame.h
View File

@ -1,56 +0,0 @@
#ifndef HDLC_FRAME_H
#define HDLC_FRAME_H
#include <stdint.h>
#include <stdbool.h>
typedef struct {
uint8_t address;
uint8_t control;
uint8_t* data;
size_t data_length;
int timeout;
} HDLCFrame;
void init_HDLCFrame(HDLCFrame* frame, uint8_t address, uint8_t control, uint8_t* data, size_t data_length);
uint16_t calculate_fcs(const HDLCFrame *frame, size_t i);
void create_frame(const HDLCFrame* frame, uint8_t* buffer);
typedef struct {
HDLCFrame base;
uint8_t receive_sequence_number;
uint8_t poll_final;
uint8_t send_sequence_number;
} IFrame;
void init_IFrame(IFrame* frame, uint8_t address, uint8_t receive_sequence_number, uint8_t poll_final,
uint8_t send_sequence_number, uint8_t* data, size_t data_length);
typedef struct {
HDLCFrame base;
uint8_t receive_sequence_number;
uint8_t poll_final;
const char* frame_type;
} SFrame;
enum SFrameType{
RR,
RNR,
REJ,
SREJ
};
void init_SFrame(SFrame* frame, uint8_t address, uint8_t receive_sequence_number, uint8_t poll_final,
enum SFrameType frame_type);
typedef struct {
HDLCFrame base;
uint8_t poll_final;
const char* frame_type;
} UFrame;
void init_UFrame(UFrame* frame, uint8_t address, uint8_t poll_final, const char* frame_type, uint8_t* data, size_t data_length);
bool validate_fcs(const uint8_t* frame, size_t length);
#endif