147 lines
3.9 KiB
C
147 lines
3.9 KiB
C
#include "client.h"
|
|
#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
|
|
#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];
|
|
|
|
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){
|
|
client->state = CONNECTING;
|
|
}
|
|
|
|
int send_data(struct Client* client, uint8_t* data, size_t data_len){
|
|
if (client->state != READY_STATE){
|
|
return ERR_INVALID_STATE;
|
|
}
|
|
|
|
if (client->size_data_buffer < 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];
|
|
}
|
|
}
|
|
|
|
if (i == COUNT_BUFFERS - 1){
|
|
return ERR_ALL_BUFFERS_FILL;
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
hdlc_control_t recv_control;
|
|
uint8_t recive[len_buffer];
|
|
|
|
int ret = hdlc_get_data(&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;
|
|
}
|
|
|
|
switch (recv_control.frame) {
|
|
case S_FRAME:
|
|
client->state = READY_STATE;
|
|
break;
|
|
case I_FRAME:
|
|
break;
|
|
case S_FRAME_NACK:
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void hdlc_timeout_handler(struct Client* client, int delta_time){
|
|
client->connecting_frame_timeout -= delta_time;
|
|
} |