Prüfcodeberechnung eines IR Telegramms

Moin!

ich habe hier eine Fernbedienung, die per IR ein Telegramm sendet. Das Telegramm besteht aus 9 Byte. Das letzte Nibble scheint dabei eine Art Prüfsumme oder etwas ähnliches zu sein.

Ich bin nun auf der Suche danach, wie dieses letzte Nibble zustande kommt. Hier ein paar besipiele von validen Telegrammen, die ich aufgezeichnet habe:

11110000000011100011001101011000100110001010110100010100000000111111 0000
11110001000011100011001101011000100110001010110100010100000000111111 1111
11110010000011100011001101011000100110001010110100010100000000111111 1110
11110011000011100011001101011000100110001010110100010100000000111111 1101
11110100000011100011001101011000100110001010110100010100000000111111 1100
11100011000011100011001101011000100110001010110100010100000000111111 0010
11100011000011100011000001011000100110001010110100010100000101111111 1100
11100011000011100010110101011000100110001010110100010100000110111111 1100

Es geht mir also darum, wie der Hersteller dieser keinem mir bekannten Standart folgenden Fernbedienung für einen Pelletofen diese Prüfsumme am Ende bestimmt - leider komme ich nicht weiter.
Zuerst dachte ich es könnten einfache Parity-Bits aller Nibbles sein - aber weder 0 noch 1 auf Odd oder Even ergibt einen Sinn für mich. Da mein Wissen in dem Bereich sehr begrenzt ist, wende ich mich mal an euch…

Ziel ist es am Ende Bit 0 bis 68 mit meinen gewünschten Daten zu füllen (siehe https://github.com/pascaltippelt/Wamsler-IR-Remote ), darauf dann das letzte Nibble zu berechnen und das Telegramm abzusenden.

Habt ihr eine Idee?

Bei den ersten 4 Beispielen ist die Summe aus dem 2. und letzten Nibble 0. Aber wenn das 1. Nibble nicht 1111 ist, dann sieht es schon wieder anders aus. Immehin könnte man vermuten, daß die Prüfsumme irgendwie aus den Nibbeln berechnet wird.

Hallo
verXORe mal die Nibbles und schaue ob so die Prüfsumme berechnet wird.
Und wenn nicht, dann noch einmal mit einem NXOR probieren.

XOR funktioniert nicht mit den ersten paar Beispielen. Ich tippe auf Summe der Nibbles.

DrDiettrich:
XOR funktioniert nicht mit den ersten paar Beispielen. Ich tippe auf Summe der Nibbles.

Ich habe ein wenig gespielt :slight_smile:
Und zusätzlich noch einen weiteren Datensatz von der Website geholt.

Summe der Nibbles, Modulo 16, und das Ergebnis negiert:
Das gibt stimmige Ergebnisse in 8 von 9 Fällen (Fehler nur bei Datensatz 5).

Hier der sehr provisorische Sketch:

/*
  TESTDATEN
  0:  11110000000011100011001101011000100110001010110100010100000000111111 0000
  1:  11110001000011100011001101011000100110001010110100010100000000111111 1111
  2:  11110010000011100011001101011000100110001010110100010100000000111111 1110
  3:  11110011000011100011001101011000100110001010110100010100000000111111 1101
  4:  11110100000011100011001101011000100110001010110100010100000000111111 1100
  5:  11100011000011100011001101011000100110001010110100010100000000111111 0010  // ???
  6:  11100011000011100011000001011000100110001010110100010100000101111111 1100
  7:  11100011000011100010110101011000100110001010110100010100000110111111 1100
  8:  11110011100011100011001101011000100110001010110100010101000011001111 1011  // von https://github.com/pascaltippelt/Wamsler-IR-Remote
  */

byte test[9][18] = {
  // 0:
  { 0b1111, 0b0000, 0b0000, 0b1110,
    0b0011, 0b0011, 0b0101, 0b1000,
    0b1001, 0b1000, 0b1010, 0b1101,
    0b0001, 0b0100, 0b0000, 0b0011,
    0b1111, 0b0000
  },
  // 1:
  { 0b1111, 0b0001, 0b0000, 0b1110,
    0b0011, 0b0011, 0b0101, 0b1000,
    0b1001, 0b1000, 0b1010, 0b1101,
    0b0001, 0b0100, 0b0000, 0b0011,
    0b1111, 0b1111
  },
  // 2:
  { 0b1111, 0b0010, 0b0000, 0b1110,
    0b0011, 0b0011, 0b0101, 0b1000,
    0b1001, 0b1000, 0b1010, 0b1101,
    0b0001, 0b0100, 0b0000, 0b0011,
    0b1111, 0b1110
  },
  // 3:
  { 0b1111, 0b0011, 0b0000, 0b1110,
    0b0011, 0b0011, 0b0101, 0b1000,
    0b1001, 0b1000, 0b1010, 0b1101,
    0b0001, 0b0100, 0b0000, 0b0011,
    0b1111, 0b1101
  },
  // 4:
  { 0b1111, 0b0100, 0b0000, 0b1110,
    0b0011, 0b0011, 0b0101, 0b1000,
    0b1001, 0b1000, 0b1010, 0b1101,
    0b0001, 0b0100, 0b0000, 0b0011,
    0b1111, 0b1100
  },
  // 5:
  { 0b1110, 0b0011, 0b0000, 0b1110,
    0b0011, 0b0011, 0b0101, 0b1000,
    0b1001, 0b1000, 0b1010, 0b1101,
    0b0001, 0b0100, 0b0000, 0b0011,
    0b1111, 0b0010
  },
  // 6:
  { 0b1110, 0b0011, 0b0000, 0b1110,
    0b0011, 0b0000, 0b0101, 0b1000,
    0b1001, 0b1000, 0b1010, 0b1101,
    0b0001, 0b0100, 0b0001, 0b0111,
    0b1111, 0b1100
  },
  // 7:
  { 0b1110, 0b0011, 0b0000, 0b1110,
    0b0010, 0b1101, 0b0101, 0b1000,
    0b1001, 0b1000, 0b1010, 0b1101,
    0b0001, 0b0100, 0b0001, 0b1011,
    0b1111, 0b1100
  },
  { 0b1111, 0b0011, 0b1000, 0b1110,
    0b0011, 0b0011, 0b0101, 0b1000,
    0b1001, 0b1000, 0b1010, 0b1101,
    0b0001, 0b0101, 0b0000, 0b1100,
    0b1111, 0b1011
  }
};

void setup() {
  Serial.begin(9600);

  for (byte i = 0; i < 9; i++) {
    uint16_t summe = 0;
    for (byte j = 0; j < 17; j++) {
      summe = summe + test[i][j];
    }
    uint8_t myCheck = summe % 16;          // Summe der Nibbles % 16
    uint8_t myCheckNot = ~ (myCheck + 0b11110000);  // Reduzieren auf 4 Bit und Negation
    Serial.print(summe);
    Serial.print('\t');
    Serial.print(myCheck);
    Serial.print('\t');
    Serial.print(myCheckNot, BIN);
    Serial.print('\t');
    Serial.print(test[i][17], BIN);
    Serial.print('\t');
    if (test[i][17] == myCheckNot) Serial.print("OK");
    Serial.println();
  }
}

void loop() { }

8 von 9 Fälle passend ist natürlich nicht der ganz große Durchbruch :slight_smile:
Könnte aber auch sein, dass es im Datensatz 5 einen Fehler gibt.
Oder der Ansatz ist falsch.

Naja für Bletchley Park wäre das schon mal nicht sooo schlecht :slight_smile:

Wenn der TO noch ein paar zusätzliche Datensätze (Telegramme) zur Verfügung stellen könnte…

Nur für's Protokoll: :) Problem wurde gelöst. Nähere Infos hier: https://www.mikrocontroller.net/topic/511335

Ist ja nett daß der TO uns darüber informiert. grrrrrr
Grüße Uwe

Ja, ich war auch noch am Knobeln. @uxomm: Danke!