rework validate

.idea/.gitignore

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

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?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

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

hdlc/client.c

@@ -0,0 +1,128 @@
+#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, void* serial_port) {
+    client->TEST_IS_VALID = test_is_valid;
+    client->address = address;
+    client->_send_sequence_number = 0;
+    client->poll_final = 1;
+    client->_receive_sequence_number = 0;
+    client->serial_port = serial_port;
+}
+
+
+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);
+
+    void* serial_port = client->serial_port;
+    sendSerialData(serial_port, u_frame.base.data, u_frame.base.data_length);
+    // Wait for acknowledgment frame
+    bool flag = true;
+    uint8_t  data[u_frame.base.data_length];
+    while(flag){
+        int bytes_received = receiveSerialData(serial_port, data, 256);
+        if (bytes_received > 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);
+
+    sendSerialData(client->serial_port, i_frame.base.data, i_frame.base.data_length);
+
+    client->_send_sequence_number++;
+}
+
+void receive_data(Client* client, uint8_t* recivedData, int lenRecived) {
+    void* serial_port = client->serial_port;
+    bool flag = true;
+    while(flag){
+        int bytes_received = receiveSerialData(serial_port, recivedData, lenRecived);
+        if (bytes_received > 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;
+}

hdlc/client.h

@@ -0,0 +1,28 @@
+
+
+#ifndef CLIENT_H
+#define CLIENT_H
+
+#include "hdlc_frame.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;
+    void* serial_port; // Указатель на объект последовательного порта
+} Client;
+
+void init_Client(Client* client, bool test_is_valid, uint8_t address, void* serial_port);
+void connect(Client* client);
+void send(Client* client, uint8_t* data, size_t data_length);
+void receive_data(Client* client, uint8_t* recivedData, int lenRecived);
+bool validate(const uint8_t* frame, size_t length);
+int sendSerialData(const char* port, uint8_t* data, size_t length);
+int receiveSerialData(const char* port, uint8_t* data, int length);
+
+#endif

hdlc/hdlc_frame.c

@@ -0,0 +1,108 @@
+#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/hdlc_frame.h

@@ -0,0 +1,45 @@
+#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