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

139
hdlc/client.c
View File

@ -1,31 +1,46 @@
#include "client.h"
#include "hdlc.h"
#include "stdio.h"
#include "stdbool.h"
#define CONNECT_FRAME_PERIOD 200
#define SIZE_DATA_BUFFER 64
#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_ALL_BUFFERS_FILL -2
struct Client hdlc_client;
#define ERR_INVALID_PARAMS -3
#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];
struct Client init_hdlc_client(enum HDLCState *state){
return hdlc_client;
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;
}
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){
@ -33,39 +48,27 @@ void connect(struct Client* client){
}
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;
}
if (!FLAG_FILL_BUFFER1){
for(int i = 0; i < SIZE_DATA_BUFFER; i++){
buffer_data[0][i] = data[i];
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];
}
}
FLAG_FILL_BUFFER1 = true;
} 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 {
if (i == COUNT_BUFFERS - 1){
return ERR_ALL_BUFFERS_FILL;
}
}
client->state = READY_STATE;
client->state = RECIVING;
};
int get_frame(struct Client *client, uint8_t buffer[], size_t lenBuffer) {
@ -76,10 +79,11 @@ int get_frame(struct Client* client, uint8_t buffer[], size_t lenBuffer){
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 S_FRAME: %d\n", ret);
printf("err in get_frame ACK: %d\n", ret);
}
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:
control_send.frame = I_FRAME;
control_send.seq_no = 1;
if (FLAG_FILL_BUFFER1 && !FLAG_SEND_BUFFER1){
int ret = hdlc_frame_data(&control_send, buffer_data[0], SIZE_DATA_BUFFER, buffer, &lenBuffer);
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 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 (ret < 0){
printf("err in get_frame I_FRAME: %d\n", ret);
if (i == COUNT_BUFFERS - 1){
return ERR_ALL_BUFFERS_FILL;
}
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;
}
@ -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){
if (client->connecting_frame_timeout <= 0){
return ERR_FRAME_TIME_OUT;
}
hdlc_control_t recv_control;
uint8_t recive[len_buffer];
int ret = hdlc_get_data(&recv_control, buffer, len_buffer, recive,
&len_buffer);
if (ret < 0){
printf("err in get_raw_data: %d\n", ret);
if (recv_control.seq_no != client->number_seq_frame){
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;
}

7
hdlc/client.h
View File

@ -10,16 +10,19 @@ enum HDLCState {
READY_STATE, // Состояние принятия
CONNECTING, // состояние соединения
DISCONNECTING, // состояния отключения
RECIVED // состояние приема и отправки
RECIVING // состояние приема и отправки
};
struct Client{
enum HDLCState state;
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);
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);

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);
// Only DATA frames should contain data
if (control->frame == HDLC_FRAME_DATA) {
if (control->frame == I_FRAME) {
// Calculate FCS and escape data
for (i = 0; i < src_len; i++) {
fcs = calc_fcs(fcs, src[i]);

30
hdlc/main.c
View File

@ -6,21 +6,31 @@
int main(){
struct Client hdlc;
init_hdlc_client(2, 64, 200, &hdlc);
connect(&hdlc);
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));
uint8_t send[64];
uint8_t buffer[134];
for (int i = 0; i < sizeof(send); i++) {
send[i] = (uint8_t) (rand() % 0x70);
for (int i = 0; i < 200; i++){
hdlc_timeout_handler(&hdlc, 1);
hdlc_get_raw_data(&hdlc, buffer_for_ex, sizeof(buffer_for_ex));
}
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

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