slave

проверка массива на ноль и целостность

SPI/master/master.ino

@@ -0,0 +1,129 @@
+//master
+#include <avr/io.h>
+#include <util/delay.h>
+
+#define DDR_SPI DDRB
+#define DD_MOSI PB3
+#define DD_MISO PB4
+#define DD_SCK PB5
+#define DD_SS PB2
+
+void SPI_MasterInit(void)
+{
+    DDR_SPI = (1 << DD_MOSI) | (1 << DD_SCK) | (1 << DD_SS);
+    DDRB |= (1<<DDB2);  // set SS as output
+
+    SPCR = (1 << SPE) | (1 << MSTR);
+}
+
+void Print(byte *data2, int lenght){
+  for(int i = 0; i < lenght; i++) {
+    Serial.print(data2[i]);
+    Serial.print(" ");
+  }
+}
+
+void SPI_MasterTransmit(char *data, int length)
+{
+  PORTB &= ~(1<<2);
+
+  // Serial.println();
+  int size = sizeof(data) / sizeof(data[0]);
+  
+  if (data[size - 1] == SPDR){
+    Serial.println("Privet") ;   
+  }
+  byte check = 0;
+  byte spdr[length];
+  Serial.println();
+  for(int i = 0; i < length; i++) {
+    SPDR = data[i]; // отправляем байт массива
+    Serial.print(data[i], HEX);
+    Serial.print(" ");
+    while (!(SPSR & (1 << SPIF))); // ждем, пока байт передастся
+  }
+  PORTB |= (1<<2);
+
+  
+  // Print(spdr, length);
+  // return check;
+  // //ждем, пока придет контрольная сумма
+  // while (!(SPSR & (1 << SPIF)));
+  // uint8_t received_checksum = SPDR;
+
+  // // вычисляем контрольную сумму XOR для принятых данных
+  // uint8_t calculated_checksum = calculateXORChecksum((byte*)data, length);
+  // Serial.println();
+  // Serial.println(received_checksum);
+  // // проверяем, совпадает ли принятая контрольная сумма с вычисленной
+  // if (received_checksum == calculated_checksum) {
+  //   Serial.println("\nChecksum is correct");
+    
+  // } else {
+  //   Serial.println("\nChecksum is incorrect");
+  // }
+}
+
+void setup()
+{
+  Serial.begin(9600);
+  SPI_MasterInit();   
+  Serial.println("Master Initialization ");
+}
+
+// Функция для вычисления контрольной суммы XOR
+byte calculateXORChecksum(byte *data, int length) {
+  byte checksum = 0;
+  for (int i = 0; i < length -1; i++) {
+    checksum ^= data[i];
+  }
+  return checksum;
+}
+
+void loop()
+{
+    char data[5] = {6, 1, 3, 8, 0};
+    
+    int length = sizeof(data);
+
+    const int last = data [ (sizeof(data) / sizeof(data[0]))-1];
+    
+    byte checking = calculateXORChecksum(data, length); 
+    int size = sizeof(data) / sizeof(data[0]);
+    data[size - 1] = checking;
+    // Serial.println(last);
+    
+    SPI_MasterTransmit(data, length);
+    _delay_ms(1000);
+
+    char data2[5] = {6, 9, 7, 10, 0};
+    int length2 = sizeof(data2);
+    const int last2 = data2 [ (sizeof(data2) / sizeof(data2[0]))-1];
+    byte checking2 = calculateXORChecksum(data2, length2); 
+    int size2 = sizeof(data2) / sizeof(data2[0]);
+    data2[size2 - 1] = checking2;
+    SPI_MasterTransmit(data2, length2);    
+
+    _delay_ms(1000);
+
+    char data3[5] = {6, 11, 12, 13, 0};
+    int length3 = sizeof(data3);
+    const int last3 = data3 [ (sizeof(data3) / sizeof(data3[0]))-1];
+    byte checking3 = calculateXORChecksum(data3, length3); 
+    int size3 = sizeof(data3) / sizeof(data3[0]);
+    data3[size3 - 1] = checking3;
+    SPI_MasterTransmit(data3, length3);    
+
+    _delay_ms(1000);
+    // ожидаем ответа
+    // while (!(SPSR & (1 << SPIF)));
+    // byte response = SPDR;
+    // if (response == 0x55) { // 0x55 - успешный ответ
+    //   Serial.println("Command executed successfully");
+    // } else if (response == 0xAA) { // 0xAA - ошибка контрольной суммы
+    //   Serial.println("Error: Checksum does not match");
+    // } else { // другие значения - неизвестный ответ
+    //   Serial.println("Error: Unknown response");
+    // }
+    
+}

SPI/slave/slave.ino

@@ -0,0 +1,197 @@
+#include <avr/io.h>
+#include <util/delay.h>
+#include <GyverOLED.h>
+
+#define DDR_SPI DDRB
+#define DD_MOSI PB3
+#define DD_MISO PB4
+#define DD_SCK PB5
+#define DD_SS PB2
+
+GyverOLED<SSD1306_128x64, OLED_NO_BUFFER> oled;
+
+static int index = 0;
+static int arIndex = 0;
+static byte data[255];
+static byte ar1[5];
+static byte ar2[5];
+static byte ar3[5];
+
+
+
+void SPI_SlaveInit(void)
+{
+    DDR_SPI = (1 << DD_MISO);
+
+    SPCR = (1 << SPE) | (1 << SPIE);
+}
+
+ISR(SPI_STC_vect)
+{
+    char received = SPDR;
+    data[index] = received;
+    index++;
+}
+
+void setup()
+{
+    Serial.begin(2000000);
+    oled.init();        // инициализация
+    oled.clear();       // очистка
+
+    SPI_SlaveInit();
+    Serial.println();
+    Serial.println("Initialization ");
+}
+
+void SetCommand(byte *data2){
+  // oled.clear();
+  byte command = data2[0];
+  // Отрезать 1 элемент от оставшихся
+  byte result[index];
+  byte *ptr = &data2[1];
+  strcpy(result, ptr);
+  Serial.print("\nReceived command: ");
+  Serial.println(command);
+  switch (command){
+      case 6:
+          AddSymbol(result);
+          break;
+
+  }
+}
+
+
+void AddSymbol(byte *symbols){
+  Serial.print("Received Add: ");
+  
+  // _delay_ms(1000);
+  for(int i = 0; i < index - 1; i++) {
+      Serial.print(symbols[i]);
+      Serial.print(" ");
+      oled.println(symbols[i]);
+  }
+  Serial.println();
+}
+
+
+// Функция для вычисления контрольной суммы XOR
+byte calculateXORChecksum(byte *data, int length) {
+    byte checksum = 0;
+    for (int i = 0; i < length - 1; i++) {
+        checksum ^= data[i];
+    }
+    return checksum;
+}
+
+// Вывод массива
+void arrayOut(byte *arr,int size){
+  Serial.print("Array: ");
+  for(int i = 0;i<size;i++){
+    Serial.print(arr[i]);
+    Serial.print(" ");
+  }
+  Serial.println(".");
+}
+
+// Проверка массива на ноль
+bool checkArray(byte* arr, int size) {
+    for (int i = 0; i < size; i++) {
+        if (arr[i] != 0) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void loop() {
+  if(PINB & (1 << 2))
+  {
+    if(index > 0)
+    {
+      
+      if (arIndex == 0){
+        arIndex = 1;
+        memcpy(ar1,data,5);
+      }else{
+        if(arIndex == 1){
+          arIndex = 2;
+          memcpy(ar2,data,5);
+        }else{
+          arIndex = 0;
+          memcpy(ar3,data,5);
+        }
+      }
+      byte sum = 0;
+      
+      //arrayOut(ar1,5);
+      int lenght = 5;
+      sum = calculateXORChecksum(ar1, lenght);
+      bool checkNull = false;
+      //oled.clear();
+      byte last_1 = ar1[index - 1];
+      if (last_1 == sum)
+      {
+        Serial.println();
+        Serial.println("Старт вывода массивов");
+        Serial.println(sum);
+        checkNull = checkArray(ar1, lenght);
+        if(checkNull == true)
+        {
+          //oled.home();        // курсор в 0,0
+          //oled.setScale(3);   // масштаб текста (1..4)
+          
+          SetCommand(ar1);
+          
+        }
+
+        Serial.println("Стоп вывода массивов");
+        index = 0;
+        return;
+      }
+
+      //arrayOut(ar2,5);
+      sum = calculateXORChecksum(ar2, lenght);
+
+      byte last_2 = ar2[index - 1];
+      if (last_2 == sum)
+      {
+        Serial.println();
+        Serial.println("Старт вывода массивов");
+        Serial.println(sum);
+        checkNull = checkArray(ar2, lenght);
+        if(checkNull == true)
+        {
+          SetCommand(ar2);
+        }
+
+        Serial.println("Стоп вывода массивов");
+        index = 0;
+        return;
+      }
+
+      //arrayOut(ar3,5);
+      sum = calculateXORChecksum(ar3, lenght);
+
+      byte last_3 = ar3[index - 1];
+      if (last_3 == sum)
+      {
+        Serial.println();
+        Serial.println("Старт вывода массивов");
+        Serial.println(sum);
+        checkNull = checkArray(ar3, lenght);
+        if(checkNull == true)
+        {
+          SetCommand(ar3);
+        }
+
+        Serial.println("Стоп вывода массивов");
+        index = 0;
+        return;
+      }
+
+      Serial.println("Nothing ...");
+      index=0;
+    }
+  }
+}