Berechnung der Modbus RTU CRC-16

Ich bin die Implementierung einer software, wo ich Lesen und schreiben von Daten im Modbus-RTU-protocolo über die serielle. Für die, die ich brauche zu berechnen, die zwei CRC-byte am Ende des Strings von bytes, aber ich bin unfähig dies zu tun.

Suche im gesamten web, fand ich zwei Funktionen, scheint die Berechnung der CRC korrekt:

WORD CRC16 (const BYTE *nData, WORD wLength)
{
    static const WORD wCRCTable[] = {
       0X0000, 0XC0C1, 0XC181, 0X0140, 0XC301, 0X03C0, 0X0280, 0XC241,
       0XC601, 0X06C0, 0X0780, 0XC741, 0X0500, 0XC5C1, 0XC481, 0X0440,
       0XCC01, 0X0CC0, 0X0D80, 0XCD41, 0X0F00, 0XCFC1, 0XCE81, 0X0E40,
       0X0A00, 0XCAC1, 0XCB81, 0X0B40, 0XC901, 0X09C0, 0X0880, 0XC841,
       0XD801, 0X18C0, 0X1980, 0XD941, 0X1B00, 0XDBC1, 0XDA81, 0X1A40,
       0X1E00, 0XDEC1, 0XDF81, 0X1F40, 0XDD01, 0X1DC0, 0X1C80, 0XDC41,
       0X1400, 0XD4C1, 0XD581, 0X1540, 0XD701, 0X17C0, 0X1680, 0XD641,
       0XD201, 0X12C0, 0X1380, 0XD341, 0X1100, 0XD1C1, 0XD081, 0X1040,
       0XF001, 0X30C0, 0X3180, 0XF141, 0X3300, 0XF3C1, 0XF281, 0X3240,
       0X3600, 0XF6C1, 0XF781, 0X3740, 0XF501, 0X35C0, 0X3480, 0XF441,
       0X3C00, 0XFCC1, 0XFD81, 0X3D40, 0XFF01, 0X3FC0, 0X3E80, 0XFE41,
       0XFA01, 0X3AC0, 0X3B80, 0XFB41, 0X3900, 0XF9C1, 0XF881, 0X3840,
       0X2800, 0XE8C1, 0XE981, 0X2940, 0XEB01, 0X2BC0, 0X2A80, 0XEA41,
       0XEE01, 0X2EC0, 0X2F80, 0XEF41, 0X2D00, 0XEDC1, 0XEC81, 0X2C40,
       0XE401, 0X24C0, 0X2580, 0XE541, 0X2700, 0XE7C1, 0XE681, 0X2640,
       0X2200, 0XE2C1, 0XE381, 0X2340, 0XE101, 0X21C0, 0X2080, 0XE041,
       0XA001, 0X60C0, 0X6180, 0XA141, 0X6300, 0XA3C1, 0XA281, 0X6240,
       0X6600, 0XA6C1, 0XA781, 0X6740, 0XA501, 0X65C0, 0X6480, 0XA441,
       0X6C00, 0XACC1, 0XAD81, 0X6D40, 0XAF01, 0X6FC0, 0X6E80, 0XAE41,
       0XAA01, 0X6AC0, 0X6B80, 0XAB41, 0X6900, 0XA9C1, 0XA881, 0X6840,
       0X7800, 0XB8C1, 0XB981, 0X7940, 0XBB01, 0X7BC0, 0X7A80, 0XBA41,
       0XBE01, 0X7EC0, 0X7F80, 0XBF41, 0X7D00, 0XBDC1, 0XBC81, 0X7C40,
       0XB401, 0X74C0, 0X7580, 0XB541, 0X7700, 0XB7C1, 0XB681, 0X7640,
       0X7200, 0XB2C1, 0XB381, 0X7340, 0XB101, 0X71C0, 0X7080, 0XB041,
       0X5000, 0X90C1, 0X9181, 0X5140, 0X9301, 0X53C0, 0X5280, 0X9241,
       0X9601, 0X56C0, 0X5780, 0X9741, 0X5500, 0X95C1, 0X9481, 0X5440,
       0X9C01, 0X5CC0, 0X5D80, 0X9D41, 0X5F00, 0X9FC1, 0X9E81, 0X5E40,
       0X5A00, 0X9AC1, 0X9B81, 0X5B40, 0X9901, 0X59C0, 0X5880, 0X9841,
       0X8801, 0X48C0, 0X4980, 0X8941, 0X4B00, 0X8BC1, 0X8A81, 0X4A40,
       0X4E00, 0X8EC1, 0X8F81, 0X4F40, 0X8D01, 0X4DC0, 0X4C80, 0X8C41,
       0X4400, 0X84C1, 0X8581, 0X4540, 0X8701, 0X47C0, 0X4680, 0X8641,
       0X8201, 0X42C0, 0X4380, 0X8341, 0X4100, 0X81C1, 0X8081, 0X4040 };

    BYTE nTemp;
    WORD wCRCWord = 0xFFFF;

    while (wLength--)
    {
        nTemp = *nData++ ^ wCRCWord;
        wCRCWord >>= 8;
        wCRCWord  ^= wCRCTable[nTemp];
    }
    return wCRCWord;
} //End: CRC16

Und

uint CRC16_2(QByteArray buf, int len)
{
  uint crc = 0xFFFF;

  for (int pos = 0; pos < len; pos++)
  {
    crc ^= (uint)buf[pos];          //XOR byte into least sig. byte of crc

    for (int i = 8; i != 0; i--) {    //Loop over each bit
      if ((crc & 0x0001) != 0) {      //If the LSB is set
        crc >>= 1;                    //Shift right and XOR 0xA001
        crc ^= 0xA001;
      }
      else                            //Else LSB is not set
        crc >>= 1;                    //Just shift right
    }
  }
  //Note, this number has low and high bytes swapped, so use it accordingly (or swap bytes)
  return crc;
}

Das problem ist, dass ich soll kommen zwei hex-bytes CRC-zahlen, während diese Funktion liefert einen integer-Wert. Zum Beispiel für "01" (1 byte), ich sollte ein "7E80" während ich bekomme "21695", und ich bin nicht in der Lage ist zu tun, irgendeine Art von Konvertierung von diesem auf, die hex-Daten.

Meine Frage ist daher: wie komme ich aus dem ganzzahligen Ergebnis der double-hex-Ergebnis benötigt? Ich habe versucht ein paar Optionen, aber ohne Erfolg.

Hinweis: ich verwende Qt, also wenn man eine Lösung finden könnten, die Umsetzung QByteArray oder anderen Qt-freundlichen code, ich werde froh sein. So oder so eine Lösung, die nicht mit Qt, C oder C++ ist nutzlos 😛

Die Formatierung, die Sie drucken wollen, es als dezimal statt hexadezimal. Versuchen Sie z.B. std::cout << std::hex << value << '\n';. Obwohl der Dezimalwert 21695 ist nicht das gleiche wie hexadezimal 0x7e80.
Frage ist ähnlich wie diese one, aber für eine andere Programmiersprache. Jedoch, dass noch interessant sein könnte für Sie, wenn Sie wünschen zu berechnen, CRC, ohne die Verwendung einer Tabelle.

InformationsquelleAutor Momergil | 2013-10-13

c++crc16 hex modbus qt

5

Laut MODBUS over serial line specification and implementation guide V1.02, die CRC gesendet wird little-endian (low-byte zuerst).

Ich habe keine Ahnung, obwohl, wie Sie kam mit erst irgendwelche hexadezimal-bytes für den CRC. MODBUS RTU ist ein binäres Protokoll, und die CRC wird in zwei bytes gesendet, nicht als vier hexadezimale Ziffern!

Hier ist, wie Sie es tun würde, mit dem CRC16 Funktion, die Sie zur Verfügung gestellt.
```
QByteArray makeRTUFrame(int slave, int function, const QByteArray & data) {
    Q_ASSERT(data.size() <= 252);
    QByteArray frame;
    QDataStream ds(&frame, QIODevice::WriteOnly);
    ds.setByteOrder(QDataStream::LittleEndian);
    ds << quint8(slave) << quint8(function);
    ds.writeRawData(data.constData(), data.size());
    int const crc = CRC16((BYTE*)frame.constData(), frame.size());
    ds << quint16(crc);
    return frame;
}
```
- Vielen Dank für die schnelle Antwort. Sowie, nicht zu vergessen die Notwendigkeit einer (BYTE*) Daten vor.constData() in der CRC16-Funktion, sind Sie positiv diese Funktion von Euch funktioniert? 😛 ich habe versucht, es zu testen, gegen ein Excel-sheet von SimplyModbus.ca und ich konnte nicht machen die CRC-Werte übereinstimmen (Hinweis: Kommissionierung der daraus resultierenden QByteArray und zeigt in der qdebug() als toHex()). Ich bin froh, wenn Sie versuchen, es durch youserlf 🙂
- Die CRC berechnet werden mussten über den gesamten Rahmen. Ich habe bearbeitet den code, um das zu beheben. Dies zeigt, dass Sie versuchen, verwenden Sie code, die Sie nicht verstehen, in der industriellen Automatisierung-Einstellungen. Ich hoffe, dass niemand getötet wird.
- Haha, keine Sorge gibt 🙂 ich habe mich gerade gefragt: in der Modbus-protocolo braucht man das mount pack mit: salve-Adresse (ok), Befehl/Funktion (ok) und dann die register-Nummer und dann die Daten -, während Ihre Funktion nur die Daten hat. In diesem Fall ist, wie muss ich das einfügen dieser in Ihrer Funktion? Nur das hinzufügen einer <<quint8(registrieren)? Hinweis: ich war nicht in der Lage zu überprüfen, ob der CRC wird richtig gemacht, indem es als gut. Nur um sicher zu sein, hast du überprüfen, ob deine CRC-Berechnung ist die Arbeit mit z.B. Einfach Modbus s CRC calculator? xD (ich hoffe, du hast nicht verrückt, für mich bitten, daß ^^)
- Sie hat die Funktion zu verwenden, ist es nicht meine Aufgabe, es für Sie zu überprüfen. Sie können es selbst tun. Ebenso die data - parameter ist die MODBUS-Nutzlast, hat die register-Nummer und so weiter. Sie müssen in der Lage sein zu verstehen, diesen code und ändern Sie es, wie Sie sehen, passen. Es ist ein Ausgangspunkt, nicht eine fertige Lösung. SO ist nicht kostenlos-outsourcing.
InformationsquelleAutor Kuba Ober
7
```
unsigned int CRC16_2(unsigned char *buf, int len)
{  
  unsigned int crc = 0xFFFF;
  for (int pos = 0; pos < len; pos++)
  {
  crc ^= (unsigned int)buf[pos];    //XOR byte into least sig. byte of crc

  for (int i = 8; i != 0; i--) {    //Loop over each bit
    if ((crc & 0x0001) != 0) {      //If the LSB is set
      crc >>= 1;                    //Shift right and XOR 0xA001
      crc ^= 0xA001;
    }
    else                            //Else LSB is not set
      crc >>= 1;                    //Just shift right
    }
  }

  return crc;
}
```
im Art von einem noob mich, butttt-

benutzte ich den code u zur Verfügung gestellt und es selber getestet, und als u sagte, dass es nicht richtig funktioniert, aber dann merkte ich, es war vorbei, hex-chars, so dass ich nur geändert uint char und Kontrollen-für mich zumindest.

ich sogar berechnet eine Probe von hand zu überprüfen.
- Dank Roney für die Antwort, obwohl ich ' ll am Ende mit Kuba version, da ich bereits überprüft, es =]
- es war Adams Antwort. Roney war einfach leicht zu Bearbeiten.
- Yeap. Credits Adam Lam.
- ok Jungs, sorry 🙂
- Bitte nicht verwenden Sie diese Codes in der Produktion. Es gibt keine Notwendigkeit, jemals solche Methoden der CRC-Berechnung, außer Debuggen.
- interessant ... aber warum?
- Weil es langsam durch Verarbeitung der Eingabe von Daten ein bit zu einer Zeit. Dies ist natürlich von unschätzbarem Wert, wenn Sie schreiben Ihre eigene Implementierung und debugging-da können Sie im Grunde look in das CRC-output-register bei jedem Schritt des Prozesses. Allerdings, dieser einfache benchmark zeigt, dass die Byte für Byte untersucht-version ist 5 bis 6 mal schneller auf meinem Rechner. Auch wenn Sie sind in einem sehr Speicher-eingeschränkten Umgebung, auf 512 bytes (in diesem Fall) des nur-lese-Speicher können Sie mit einer großen Beschleunigung.
- Vielen Dank für die wertvollen Informationen. Die wichtigste motivation meiner Frage, in der Tat, ich habe gesehen, das gleiche Stück code in einem Reifen-source-code, den ich verwende .. naja, ich wollte nicht studieren, seinen Effekt auf die Geschwindigkeit und damit die Fehlerquote .. ich werde.
InformationsquelleAutor Adam Lam

Versuchte ich mit dem ersten Beispiel der code, den Sie geschrieben hier (die man mit Hilfe der Tabelle), und ich fand heraus, dass es einen Fehler mit index. Um den code korrekt läuft, müssen Sie den Zugriff auf die Tabelle in das Gebiet begrenzt durch seine Größe.

wCRCWord  ^= wCRCTable[(nTemp & 0xFF)];

Also der ganze code, das gibt richtigen Wert für MODBUS CRC16 ist unten aufgeführt. Die Anzahl zurückgegeben hat bereits wurde ersetzt durch Lo-und Hi-byte.

WORD CRC16 (const BYTE *nData, WORD wLength)
{
    static const WORD wCRCTable[] = {
    0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
    0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
    0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
    0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
    0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
    0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
    0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
    0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
    0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
    0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
    0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
    0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
    0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
    0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
    0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
    0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
    0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
    0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
    0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
    0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
    0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
    0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
    0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
    0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
    0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
    0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
    0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
    0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
    0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
    0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
    0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
    0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040 };

    BYTE nTemp;
    WORD wCRCWord = 0xFFFF;

    while (wLength--)
    {
        nTemp = *nData++ ^ wCRCWord;
        wCRCWord >>= 8;
        wCRCWord  ^= wCRCTable[(nTemp & 0xFF)];
    }
    return wCRCWord;
} //End: CRC16

Sie sagte, dass Die Zahl zurückgegeben wurde bereits getauscht Lo-und Hi-byte. Sind Sie sicher, dass für die vorgestellten code? Ich denke, dass dieser code gibt regelmäßige CRC-Wort, und ein Benutzer hat, um swap-bytes, bevor die Verkettung zu einem Telegramm wie folgt: wCRCWord = (wCRCWord<<8) | (wCRCWord>>8). Betrachten Sie beispielsweise eine einfache Nachricht in hex: 11 03 00 6B 00 03. Der CRC-Wert wird berechnet, indem dieser code für den betrachteten Rahmen ist 87 76, und die komplette Nachricht wird 11 03 00 6B 00 03 76 87 (Beispiel von hier: simplymodbus.ca/ASCII.htm)

InformationsquelleAutor Michal Fiala

0

Hier sind meine zwei Cent.
Erste Sache, die Sie nicht zurückkehren, zwei Werte in eine Funktion, so
1. Anhängen zwei Werte in dem array(denken Sie daran, zu entfernen const)
2. Rückgabe einer struct mit diesen zwei Werten.
3. Proccess Rückgabewert wie folgt
```
WORD n = CRC16(nData,wLength);
WORD x = (0xFF00&n)>>8,y=0x00FF&n;
printf("0x%04x\n", n); //to check original value
printf("0x%02x\t0x%02x\n",x,y); //to check separated values
```
Versuchen Sie dies und lassen Sie mich wissen.

InformationsquelleAutor Devidas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.