added clear_buffer

.idea/.gitignore

@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml

.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<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" />
-    </modules>
-  </component>
-</project>

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

Readme.md

@@ -13,4 +13,3 @@
 
 Деркачев Андрей
 * Соединения и рефактор блоков UART, HDLC и вывода
-* Работа с I2C

UART/circular_buf.c

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "circular_buf.h"
+
+
+void clear_buffer(struct circular_buffer* cb) {
+	cb->buf_head = 0;
+	cb->buf_tail = 0;
+}
+// Проверка, пустой ли буфер
+int buffer_empty(const struct circular_buffer* cb) {
+	return cb->buf_head == cb->buf_tail;
+}
+// Проверка, заполнен ли буфер
+int buffer_full(const struct circular_buffer* cb) {
+	return (cb->buf_tail + 1) % BUFFER_SIZE == cb->buf_head; //проверяем следующее число, если оно будет совпадать с индексом головы то будет false, при совпадении вывод true
+}
+// Запись в буфер
+void write_buffer(struct circular_buffer* cb, int value) {
+	if (buffer_full(cb)) { // проверяем, заполнен ли буфер
+		return;
+	}
+	cb->buffer[cb->buf_tail] = value;// записываем значение в элемент массива в хвост
+	cb->buf_tail = (cb->buf_tail + 1) % BUFFER_SIZE;// присваивается cb->buf_tail, обновляется его значение на следующий индекс в буфере
+}
+// Чтение элемента
+int read_buffer(struct circular_buffer* cb) {
+	if (buffer_empty(cb)) { // проверка на пустоту
+		return -1;// -1  как индикатор в случае ошибки
+	}
+	int value = cb->buffer[cb->buf_head]; // чтение по индексу головы
+	cb->buf_head = (cb->buf_head + 1) % BUFFER_SIZE; // увеличиваем индекс на 1
+	return value;
+}
+
+

UART/circular_buf.h

@@ -0,0 +1,18 @@
+#ifndef CIRCULAR_BUFFER_H
+#define CIRCULAR_BUFFER_H
+
+#define BUFFER_SIZE 32
+
+struct circular_buffer{
+	unsigned char buffer[BUFFER_SIZE];
+	unsigned char buf_head;
+	unsigned char buf_tail;
+};
+
+void clear_buffer(struct circular_buffer* cb);
+int buffer_empty(const struct circular_buffer* cb);
+int buffer_full(const struct circular_buffer* cb);
+void write_buffer(struct circular_buffer* cb, int value);
+int read_buffer(struct circular_buffer* cb);
+
+#endif /* CIRCULAR_BUFFER_H */

UART/uart.c

@@ -0,0 +1,63 @@
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <stdint.h>
+#include <string.h>
+#include "circular_buf.h"
+#include "uart.h"
+
+struct circular_buffer uartRxBuffer;
+struct circular_buffer uartTxBuffer;
+
+void UART_init(void) {
+	UCSR0B = (1 << RXEN0) | (1 << TXEN0) | (1 << RXCIE0) | (1<<TXCIE0) | (1 << UDRIE0); // прерывание по приему и передаче
+	UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
+	UBRR0H = 0;
+	UBRR0L = 103;
+}
+
+void UART_send(uint8_t* data, size_t length) {
+	for (size_t i = 0; i < length; i++) {
+		if (!buffer_full(&uartTxBuffer)) {
+			write_buffer(&uartTxBuffer, data[i]);
+			} else {
+			break; // если буфер передачи заполнен, то отправка прерывается
+		}
+	}
+	UCSR0B |= (1 << TXCIE0); // включаем прерывание по завершении передачи
+	clear_buffer(&uartTxBuffer);
+}
+
+// Получение данных из буфера
+int UART_receive(uint8_t* data, size_t length) {
+    char overflow = 0;  // Флаг переполнения, который устанавливается, если превышен размер массива 
+    uint32_t byteCount = 0;  // Счетчик байтов, принятых из буфера приема
+    // Пока буфер приема не пуст и не превышен лимит длины массива,
+    // функция продолжает читать байты из буфера и сохранять их в массив data.
+    while (!buffer_empty(&uartRxBuffer) && byteCount < length) {
+        int reader = read_buffer(&uartRxBuffer);  // Прием и запись символа в переменную
+        data[byteCount] = reader;  // Запись в массив с индексом byteCount
+        byteCount++;
+    }
+    // Проверка переполнения
+    if (byteCount > length) {
+        overflow = 1;
+    }
+	clear_buffer(&uartRxBuffer);
+    return overflow ? -1 : byteCount;  // Возвращает количество успешно принятых байт или -1 в случае переполнения
+}
+
+// прерывание по завершению приема
+ISR(USART_RX_vect) {
+	uint8_t data = UDR0; // читаем из регистра UDR0
+	if (!buffer_full(&uartRxBuffer)) {
+		write_buffer(&uartRxBuffer, data);// записываем символ в буфер приема
+	}
+}
+
+ISR(USART_TX_vect) {
+	if (!buffer_empty(&uartTxBuffer)) {
+		UDR0 = read_buffer(&uartTxBuffer);
+	} else {
+		UCSR0B &= ~(1 << TXCIE0); // отключаем прерывание, когда все данные отправлены
+	}
+}

UART/uart.h

@@ -0,0 +1,13 @@
+#ifndef UART_H
+#define UART_H
+#include <stdint.h> 
+#include <stddef.h>
+
+#define F_CPU 16000000
+
+void UART_init(void);
+void UART_send(uint8_t* data, size_t length);
+int UART_receive(uint8_t* data, size_t length);
+
+
+#endif /* UART_H */

client.c

@@ -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;
-}

client.h

@@ -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

hdlc_frame.c

@@ -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;
-}

hdlc_frame.h

@@ -1,45 +0,0 @@
-#ifndef HDLC_FRAME_H
-#define HDLC_FRAME_H
-
-#include <stdint.h>
-
-typedef struct {
-    uint8_t address;
-    uint8_t control;
-    uint8_t* data;
-    size_t data_length;
-} 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);
-
-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;
-
-void init_SFrame(SFrame* frame, uint8_t address, uint8_t receive_sequence_number, uint8_t poll_final,
-                 const char* 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);
-
-#endif

main.c

@@ -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);
-		}
-
-    }
-}

uart_module.c

@@ -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;
-}

uart_module.h

@@ -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_ */