byte buffer[2];

// Функция для вычисления CRC-16 (возвращает CRC код)
uint16_t calculateCyclicRedundancyCode(const uint8_t *data, uint16_t length) {
    uint16_t crc = 0xFFFF;  // Инициализация CRC (Modbus стандарт)
    
    for (uint16_t i = 0; i < length; i++) {
        crc ^= (uint16_t)data[i];  // XOR с очередным байтом данных
        
        for (uint8_t j = 0; j < 8; j++) {
            if (crc & 0x0001) {  // Если младший бит = 1
                crc >>= 1;       // Сдвиг вправо
                crc ^= 0xA001;    // XOR с полиномом 0xA001 (0x8005 в обратном порядке)
            } else {
                crc >>= 1;       // Просто сдвиг, если бит = 0
            }
        }
    }
    
    return crc;  // Возвращаем вычисленный CRC код
}

uint8_t calculateCRC8_SAE(const uint8_t *data, uint16_t length) {
    uint8_t crc = 0xFF;         // Начальное значение
    const uint8_t polynomial = 0x1D; // Полином 0x1D
    
    for (uint16_t i = 0; i < length; i++) {
        crc ^= data[i];
        for (uint8_t j = 0; j < 8; j++) {
            if (crc & 0x80) {
                crc = (crc << 1) ^ polynomial;
            } else {
                crc <<= 1;
            }
        }
    }
    return crc ^ 0xFF; // Финальный XOR
}

uint8_t CRC8(uint16_t data) {
    uint8_t crc = 0xFF;         // Начальное значение CRC
    const uint8_t polynomial = 0x1D; // Полином (x^8 + x^5 + x^4 + 1)
    
    // Обрабатываем каждый байт числа (4 байта для uint32_t)
    for (uint8_t byteIndex = 0; byteIndex < 2; byteIndex++) {
        // Извлекаем очередной байт (начиная со старшего)
        uint8_t currentByte = (data >> (0 + byteIndex * 8)) & 0xFF;
        
        // Обновляем CRC для текущего байта
        crc ^= currentByte;
        
        // Обрабатываем каждый бит в байте
        for (uint8_t bitIndex = 0; bitIndex < 8; bitIndex++) {
            if (crc & 0x80) {      // Если младший бит = 1
                crc = (crc << 1) ^ polynomial; // Сдвиг + XOR
            } else {
                crc <<= 1;         // Просто сдвиг
            }
        }
    }
    
    return crc ^ 0xFF; // Возвращаем CRC код
}

uint8_t crc8SH(uint8_t data) {
  uint8_t crc = 0xFF;
  const uint8_t poly = 0x2F;
  crc ^= data;

  for(uint8_t i = 0; i < 8; i++) {
    if(crc & 0x80) {
      crc = (crc << 1) ^ poly;
    }
    else {
      crc <<= 1;
    }
  }

  return crc ^ 0xFF; 
}

// Пример использования
void setup() {
  Serial.begin(9600);

  
  // Пример данных (можно заменить на любые числовые данные)
  uint8_t testData[] = {200, 0};
  uint8_t tData = 200;
  uint16_t dataLength = sizeof(testData);
  
  uint16_t bigVal = 600;
  // Serial.println(bigVal, BIN);
// указатель ptrB на адрес &bigVal
// приведённый к (byte*)
  byte* ptrB = (byte*)&bigVal;
  // разбиваем на байты
  byte bigVal_1 = *ptrB;
  byte bigVal_2 = *(ptrB + 1);
  // Serial.println(bigVal_1);
  int qa = 32000;
  writeData((byte*)&qa, sizeof(qa));

  int aq = 0;
  readData((byte*)&aq, sizeof(aq));
  Serial.println(crc8SH(20), HEX);
  
  // Вычисляем CRC код
  uint16_t crcCode = calculateCRC8_SAE(testData, dataLength);
  
  // Выводим результат в Serial Monitor
  Serial.print("Cyclic Redundancy Code (CRC-16): ");
  Serial.println(crcCode, HEX);  // Вывод в HEX формате
}

void loop() {

}

void writeData(byte* data, int length) {
  int i = 0;
  while (length--) {
    buffer[i] = *(data + i);
    i++;
  }
}
void readData(byte* data, int length) {
  int i = 0;
  while (length--) {
    *(data + i) = buffer[i];
    i++;
  }
}