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

w

Browse Source
This commit is contained in:
Qukich 2023-12-25 20:11:27 +03:00
parent ecdac7b3d3
commit 671c3ba048
14 changed files with 233 additions and 387 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
.gitignore vendored Normal file
View File

@ -0,0 +1,9 @@
hdlc1.c
hdlc1.h
hdlc_frame.c
hdlc_frame.h
main1.c
uart.c
uart.h
!./hdlc

2
.idea/modules.xml generated
View File

@ -2,7 +2,7 @@
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/Display_Avr_3.iml" filepath="$PROJECT_DIR$/.idea/Display_Avr_3.iml" />
<module fileurl="file://$PROJECT_DIR$/.idea/untitled1.iml" filepath="$PROJECT_DIR$/.idea/untitled1.iml" />
</modules>
</component>
</project>

6
CMakeLists.txt Normal file
View File

@ -0,0 +1,6 @@
cmake_minimum_required(VERSION 3.25)
project(untitled1 C)
set(CMAKE_C_STANDARD 11)
add_executable(untitled1 hdlc/fcs.h hdlc/fcs.c hdlc/hdlc.h hdlc/hdlc.c hdlc/main.c hdlc/client.c)

125
client.c
View File

@ -1,125 +0,0 @@
#include "client.h"
#include <stdio.h>
#include <fcntl.h>
#define START_FLAG 0x7E
#define END_FLAG 0x7E
void init_Client(Client* client, bool test_is_valid, uint8_t address) {
client->TEST_IS_VALID = test_is_valid;
client->address = address;
client->_send_sequence_number = 0;
client->poll_final = 1;
client->_receive_sequence_number = 0;
}
void connect(Client* client) {
UFrame u_frame;
init_UFrame(&u_frame, client->address, client->poll_final, "BP", NULL, 0);
uint8_t result[256];
create_frame(&u_frame.base, result);
// Wait for acknowledgment frame
bool flag = true;
uint8_t data;
while(flag){
data = uart_read();
if (data > 0){
flag = false;
}
}
HDLCFrame frame;
init_HDLCFrame(&frame, 0, 0, &data + 3, 256 - 6);
if (validate(&data, 256)) {
return;
} else {
// Connection failed
}
}
void send(Client* client, uint8_t* data, size_t data_length) {
connect(client);
IFrame i_frame;
init_IFrame(&i_frame, client->address, client->_receive_sequence_number, client->poll_final, client->_send_sequence_number, data, data_length);
uint8_t result[256];
create_frame(&i_frame.base, result);
uart_send_byte(*i_frame.base.data);
client->_send_sequence_number++;
}
void receive_data(uint8_t* recivedData) {
bool flag = true;
while(flag){
*recivedData = uart_read();
if (recivedData > 0){
flag = false;
}
}
}
#include <stdbool.h>
bool validate(const uint8_t* frame, size_t length) {
if (length < 4 || frame[0] != START_FLAG || frame[length - 1] != END_FLAG) {
// Invalid frame length or missing start/end flag
return false;
}
uint16_t received_fcs = (frame[length - 3] << 8) | frame[length - 2];
uint16_t calculated_fcs = 0xFFFF;
for (size_t i = 1; i < length - 3; i++) {
uint8_t byte = frame[i];
calculated_fcs = (calculated_fcs >> 8) ^ (calculated_fcs << 8) ^ byte;
calculated_fcs &= 0xFFFF;
}
return received_fcs == calculated_fcs;
}
int sendSerialData(const char* port, uint8_t* data, size_t length) {
int serial_port = open(port, O_RDWR);
if (serial_port < 0) {
perror("Error opening the serial port");
return -1;
}
ssize_t bytes_written = write(serial_port, data, length);
if (bytes_written < 0) {
perror("Error writing to the serial port");
return -1;
}
close(serial_port);
return bytes_written;
}
int receiveSerialData(const char* port, uint8_t* data, int length) {
int serial_port = open(port, O_RDWR); // Replace "port" with your serial port device
if (serial_port < 0) {
perror("Error opening the serial port");
return -1;
}
ssize_t bytes_read = read(serial_port, data, length);
if (bytes_read < 0) {
perror("Error reading from the serial port");
return -1;
}
close(serial_port);
return bytes_read;
}

24
client.h
View File

@ -1,24 +0,0 @@
#ifndef CLIENT_H
#define CLIENT_H
#include "hdlc_frame.h"
#include "uart_module.h"
#include <stdbool.h>
#include <stddef.h> // Для использования size_t
#include <stdint.h>
typedef struct {
bool TEST_IS_VALID;
uint8_t address;
uint8_t _send_sequence_number;
uint8_t poll_final;
uint8_t _receive_sequence_number;
} Client;
void init_Client(Client* client, bool test_is_valid, uint8_t address);
void connect(Client* client);
void send(Client* client, uint8_t* data, size_t data_length);
void receive_data(uint8_t* recivedData);
bool validate(const uint8_t* frame, size_t length);
#endif

115
hdlc/client.c Normal file
View File

@ -0,0 +1,115 @@
#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;
#define ERR_INVALID_DATA_SIZE -1
#define ERR_ALL_BUFFERS_FILL -2
struct Client hdlc_client;
uint8_t buffer_data[COUNT_BUFFERS][SIZE_DATA_BUFFER];
struct Client init_hdlc_client(enum HDLCState *state){
return hdlc_client;
}
void connect(struct Client* client){
client->state = CONNECTING;
}
int send_data(struct Client* client, uint8_t* data, size_t data_len){
if (data_len > 64){
return ERR_INVALID_DATA_SIZE;
}
if (!FLAG_FILL_BUFFER1){
for(int i = 0; i < SIZE_DATA_BUFFER; i++){
buffer_data[0][i] = data[i];
}
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 {
return ERR_ALL_BUFFERS_FILL;
}
client->state = READY_STATE;
};
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 = HDLC_FRAME_ACK;
control_send.seq_no = 1;
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 = HDLC_FRAME_DATA;
control_send.seq_no = 1;
int ret = hdlc_frame_data(&control_send, buffer_data[0], SIZE_DATA_BUFFER, buffer, &lenBuffer);
if (ret < 0){
printf("err in get_frame DATA: %d\n", ret);
}
break;
}
// Yf
return 0;
}
int hdlc_get_raw_data(struct Client* client, uint8_t buffer[], size_t len_buffer){
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.frame == HDLC_FRAME_ACK){
client->state = IDLE_STATE;
}
return 0;
}
void hdlc_timeout_handler(struct Client* client, int delta_time){
client->connecting_frame_timeout -= delta_time;
}

30
hdlc/client.h Normal file
View File

@ -0,0 +1,30 @@
#ifndef CLIENT_H
#define CLIENT_H
#include <stdint.h>
#include <stdbool.h>
enum HDLCState {
UNINITIALIZED_STATE = 0, // состояние до инцилизации
IDLE_STATE, // Состояние ожидания начала
READY_STATE, // Состояние принятия
CONNECTING, // состояние соединения
DISCONNECTING, // состояния отключения
RECIVED // состояние приема и отправки
};
struct Client{
enum HDLCState state;
int connecting_frame_timeout; //-1
};
//название функций
struct Client init_hdlc_client(enum HDLCState *state);
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);
//принимает буффер с уарта
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);
#endif //CLIENT_H

41
hdlc/fcs.c Normal file
View File

@ -0,0 +1,41 @@
#include "fcs.h"
/*
* CRC-Type: CRC16 CCIT
* Polynomial: 0x1021 (x^16+x^12+x^5+1)
* Lookup Table: Reflected
*/
static const unsigned short fcstab[256] = {
0x0000, 0x1189, 0x2312, 0x329b,
0x4624, 0x57ad, 0x6536, 0x74bf, 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c,
0xdbe5, 0xe97e, 0xf8f7, 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c,
0x75b7, 0x643e, 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff,
0xe876, 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, 0x3183,
0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 0xbdcb, 0xac42,
0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, 0x4204, 0x538d, 0x6116,
0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, 0xce4c, 0xdfc5, 0xed5e, 0xfcd7,
0x8868, 0x99e1, 0xab7a, 0xbaf3, 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1,
0x0528, 0x37b3, 0x263a, 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960,
0xbbfb, 0xaa72, 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630,
0x17b9, 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 0xffcf,
0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 0x8408, 0x9581,
0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 0x0840, 0x19c9, 0x2b52,
0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, 0x9489, 0x8500, 0xb79b, 0xa612,
0xd2ad, 0xc324, 0xf1bf, 0xe036, 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5,
0x4f6c, 0x7df7, 0x6c7e, 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7,
0xc03c, 0xd1b5, 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74,
0x5dfd, 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, 0xc60c,
0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 0x4a44, 0x5bcd,
0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, 0xd68d, 0xc704, 0xf59f,
0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 0x5ac5, 0x4b4c, 0x79d7, 0x685e,
0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a,
0xb0a3, 0x8238, 0x93b1, 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb,
0x0e70, 0x1ff9, 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9,
0x8330, 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 };
FCS_SIZE calc_fcs(FCS_SIZE fcs, unsigned char value) {
return (fcs >> 8) ^ fcstab[(fcs ^ value) & 0xff];
}

18
hdlc/fcs.h Normal file
View File

@ -0,0 +1,18 @@
#ifndef FCS_H
#define FCS_H
#define FCS_INIT_VALUE 0xFFFF /* FCS initialization value. */
#define FCS_GOOD_VALUE 0xF0B8 /* FCS value for valid frames. */
#define FCS_INVERT_MASK 0xFFFF /* Invert the FCS value accordingly to the specification */
#define FCS_SIZE unsigned short
/**
* Calculates a new FCS based on the current value and value of data.
*
* @param fcs Current FCS value
* @param value The value to be added
* @returns Calculated FCS value
*/
FCS_SIZE calc_fcs(FCS_SIZE fcs, unsigned char value);
#endif

108
hdlc_frame.c
View File

@ -1,108 +0,0 @@
#include "hdlc_frame.h"
#include <string.h>
#define START_FLAG 0x7E
#define END_FLAG 0x7E
#define ESCAPE_FLAG 0x7D
#define ESCAPE_XOR 0x20
void init_HDLCFrame(HDLCFrame* frame, uint8_t address, uint8_t control, uint8_t* data, size_t data_length) {
frame->address = address;
frame->control = control;
frame->data = data;
frame->data_length = data_length;
}
uint16_t calculate_fcs(const HDLCFrame *frame, size_t i) {
uint16_t fcs = 0xFFFF;
uint8_t data_bytes[2 + frame->data_length];
data_bytes[0] = frame->address;
data_bytes[1] = frame->control;
memcpy(data_bytes + 2, frame->data, frame->data_length);
for (size_t i = 0; i < frame->data_length + 2; i++) {
uint8_t byte = data_bytes[i];
fcs = (fcs >> 8) ^ (fcs << 8) ^ byte;
fcs &= 0xFFFF;
}
return fcs;
}
void create_frame(const HDLCFrame* frame, uint8_t* result) {
size_t index = 0;
result[index++] = START_FLAG;
result[index++] = frame->address;
result[index++] = frame->control;
if (frame->data != NULL) {
for (size_t i = 0; i < frame->data_length; i++) {
uint8_t byte = frame->data[i];
if (byte == START_FLAG || byte == END_FLAG || byte == ESCAPE_FLAG) {
result[index++] = ESCAPE_FLAG;
result[index++] = byte ^ ESCAPE_XOR;
} else {
result[index++] = byte;
}
}
}
uint16_t fcs = calculate_fcs(frame, 0);
result[index++] = fcs & 0xFF;
result[index++] = (fcs >> 8) & 0xFF;
result[index++] = END_FLAG;
}
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) {
init_HDLCFrame(&frame->base, address,
((receive_sequence_number & 0b111) << 6) | ((poll_final & 0b1) << 4) |
((send_sequence_number & 0b111) << 1) | 0,
data, data_length);
frame->receive_sequence_number = receive_sequence_number;
frame->poll_final = poll_final;
frame->send_sequence_number = send_sequence_number;
}
void init_SFrame(SFrame* frame, uint8_t address, uint8_t receive_sequence_number, uint8_t poll_final,
const char* frame_type) {
uint8_t frame_type_value;
if (strcmp(frame_type, "RR") == 0) {
frame_type_value = 0;
} else if (strcmp(frame_type, "RNR") == 0) {
frame_type_value = 1;
} else if (strcmp(frame_type, "REJ") == 0) {
frame_type_value = 2;
} else if (strcmp(frame_type, "SREJ") == 0) {
frame_type_value = 3;
} else {
// Handle error
return;
}
init_HDLCFrame(&frame->base, address,
((receive_sequence_number & 0b111) << 6) | ((poll_final & 0b1) << 5) |
((frame_type_value & 0b111) << 2) | 1,
NULL, 0);
frame->receive_sequence_number = receive_sequence_number;
frame->poll_final = poll_final;
frame->frame_type = frame_type;
}
void init_UFrame(UFrame* frame, uint8_t address, uint8_t poll_final, const char* frame_type,
uint8_t* data, size_t data_length) {
uint8_t frame_type_value;
if (strcmp(frame_type, "BP") == 0) {
frame_type_value = 63;
} else {
// Handle error
return;
}
init_HDLCFrame(&frame->base, address, (frame_type_value << 2) | 3, data, data_length);
frame->poll_final = poll_final;
frame->frame_type = frame_type;
}

15
hdlc_frame.h
View File

@ -2,17 +2,19 @@
#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* result);
void create_frame(const HDLCFrame* frame, uint8_t* buffer);
typedef struct {
HDLCFrame base;
@ -31,8 +33,15 @@ typedef struct {
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,
const char* frame_type);
enum SFrameType frame_type);
typedef struct {
HDLCFrame base;
@ -42,4 +51,6 @@ typedef struct {
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

25
main.c
View File

@ -1,25 +0,0 @@
#include <stdint.h>
#include "config.h"
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include "uart_hal.h"
int main(void)
{
//example
uint8_t data = 'A';
uart_init(9600,0);
uart_send_byte(data);
sei();
while (1)
{
if(uart_read_count() > 0){
data = uart_read();
uart_send_byte(data);
}
}
}

82
uart_module.c
View File

@ -1,82 +0,0 @@
#include "uart_hal.h"
volatile static uint8_t rx_buffer[RX_BUFFER_SIZE] = {0};
volatile static uint16_t rx_count = 0;
volatile static uint8_t uart_tx_busy = 1;
// кольцевой буффер
ISR(USART_RX_vect){
volatile static uint16_t rx_write_pos = 0;
rx_buffer[rx_write_pos] = UDR0;
rx_count++;
rx_write_pos++;
if(rx_write_pos >= RX_BUFFER_SIZE){
rx_write_pos = 0;
}
}
ISR(USART_TX_vect){
uart_tx_busy = 1;
}
void uart_init(uint32_t baud,uint8_t high_speed){
uint8_t speed = 16;
if(high_speed != 0){
speed = 8;
UCSR0A |= 1 << U2X0;
}
baud = (F_CPU/(speed*baud)) - 1;
UBRR0H = (baud & 0x0F00) >> 8;
UBRR0L = (baud & 0x00FF);
UCSR0B |= (1 << TXEN0) | (1 << RXEN0) | (1 << TXCIE0) | (1 << RXCIE0);
}
void uart_send_byte(uint8_t c){
while(uart_tx_busy == 0);
uart_tx_busy = 0;
UDR0 = c;
}
void uart_send_array(uint8_t *c,uint16_t len){
for(uint16_t i = 0; i < len;i++){
uart_send_byte(c[i]);
}
}
void uart_send_string(uint8_t *c){
uint16_t i = 0;
do{
uart_send_byte(c[i]);
i++;
}while(c[i] != '\0');
uart_send_byte(c[i]);
}
uint16_t uart_read_count(void){
return rx_count;
}
uint8_t uart_read(void){
static uint16_t rx_read_pos = 0;
uint8_t data = 0;
data = rx_buffer[rx_read_pos];
rx_read_pos++;
rx_count--;
if(rx_read_pos >= RX_BUFFER_SIZE){
rx_read_pos = 0;
}
return data;
}

20
uart_module.h
View File

@ -1,20 +0,0 @@
#ifndef UART_HAL_H_
#define UART_HAL_H_
#include <stdint.h>
#include "config.h"
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#define RX_BUFFER_SIZE 128
void uart_init(uint32_t baud,uint8_t high_speed);
void uart_send_byte(uint8_t c);
void uart_send_array(uint8_t *c,uint16_t len);
void uart_send_string(uint8_t *c);
uint16_t uart_read_count(void);
uint8_t uart_read(void);
#endif /* UART_HAL_H_ */