Crc.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_CRC_HXX_
#define _UTILS_CRC_HXX_
 
#include <stdint.h>
#include <stddef.h>
 
#ifndef CRC8DALLAS_TABLE_SIZE
#define CRC8DALLAS_TABLE_SIZE 16
#endif
#ifndef CRC16CCITT_TABLE_SIZE
#define CRC16CCITT_TABLE_SIZE 256
#endif
 
 
uint16_t crc_16_ibm(const void* data, size_t length_bytes);
 
void crc3_crc16_ibm(const void* data, size_t length_bytes, uint16_t* checksum);
 
class Crc8DallasMaxim
{
public:
    Crc8DallasMaxim()
        : state_(0)
    {
    }
 
    void init()
    {
        state_ = 0;
    }
 
    uint8_t get()
    {
        return state_;
    }
 
    bool check_ok()
    {
        return (state_ == 0);
    }
 
    bool check_ok(uint8_t checksum_byte)
    {
        return (state_ == checksum_byte);
    }
 
    void update0(uint8_t message_byte)
    {
        uint8_t data = state_ ^ message_byte;
        uint8_t crc = 0;
        if (data & 1)
        {
            crc ^= 0x5e;
        }
        if (data & 2)
        {
            crc ^= 0xbc;
        }
        if (data & 4)
        {
            crc ^= 0x61;
        }
        if (data & 8)
        {
            crc ^= 0xc2;
        }
        if (data & 0x10)
        {
            crc ^= 0x9d;
        }
        if (data & 0x20)
        {
            crc ^= 0x23;
        }
        if (data & 0x40)
        {
            crc ^= 0x46;
        }
        if (data & 0x80)
        {
            crc ^= 0x8c;
        }
        state_ = crc;
    }
 
    void update16(uint8_t message_byte)
    {
        uint8_t data = state_ ^ message_byte;
        state_ = tableLo16[data & 0xf] ^ tableHi16[data >> 4];
    }
 
    void update256(uint8_t message_byte)
    {
        state_ = table256[state_ ^ message_byte];
    }
 
    void update(uint8_t message_byte)
    {
#if CRC8DALLAS_TABLE_SIZE == 0
        update0(message_byte);
#elif CRC8DALLAS_TABLE_SIZE == 16
        update16(message_byte);
#elif CRC8DALLAS_TABLE_SIZE == 256
        update256(message_byte);
#else
#error "Invalid value for CRC8DALLAS_TABLE_SIZE"
#endif
    }
 
private:
    // Of the static tables here only those will be linked into a binary which
    // have been used there.
 
    static const uint8_t table256[256];
 
    static const uint8_t tableHi16[16];
 
    static const uint8_t tableLo16[16];
 
    uint8_t state_;
}; // Crc8DallasMaxim
 
class Crc16CCITT
{
public:
    Crc16CCITT()
        : state_(0xFFFF)
    {
    }
 
    void init()
    {
        state_ = 0xFFFF;
    }
 
    uint16_t get()
    {
        return state_;
    }
 
    bool check_ok()
    {
        return (state_ == 0);
    }
 
    bool check_ok(uint16_t checksum)
    {
        return (state_ == checksum);
    }
 
    void update16(uint8_t message_byte)
    {
        uint8_t data = (state_ >> 8) ^ message_byte;
        state_ = (state_ << 8) ^
            tableLo16[data & 0xF] ^ tableHi16[data >> 4];
    }
 
    void update256(uint8_t message_byte)
    {
        state_ = (state_ << 8) ^ table256[(state_ >> 8) ^ message_byte];
    }
 
    void update(uint8_t message_byte)
    {
#if CRC16CCITT_TABLE_SIZE == 16
        update16(message_byte);
#elif CRC16CCITT_TABLE_SIZE == 256
        update256(message_byte);
#else
#error "Invalid value for CRC16CCITT_TABLE_SIZE"
#endif
    }
 
    void crc(const void* data, size_t length_bytes)
    {
        const uint8_t *payload = static_cast<const uint8_t*>(data);
        init();
        for (size_t i = 0; i < length_bytes; ++i)
        {
            update(payload[i]);
        }
    }
 
private:
    // Of the static tables here only those will be linked into a binary which
    // have been used there.
 
    static const uint16_t table256[256];
 
    static const uint16_t tableHi16[16];
 
    static const uint16_t tableLo16[16];
 
    uint16_t state_;
}; // Crc16CCITT
 
static inline void crc3_crc16_ccitt(
    const void* data, size_t length_bytes, uint16_t checksum[3])
{
    const uint8_t* payload = static_cast<const uint8_t*>(data);
 
    Crc16CCITT crc_all;
    Crc16CCITT crc_even;
    Crc16CCITT crc_odd;
 
    for (size_t i = 0; i < length_bytes; ++i)
    {
        crc_all.update(payload[i]);
        if (i & 0x1)
        {
            // odd index bytes
            crc_odd.update(payload[i]);
        }
        else
        {
            // even index byte
            crc_even.update(payload[i]);
        }
    }
 
    checksum[0] = crc_all.get();
    checksum[1] = crc_even.get();
    checksum[2] = crc_odd.get();
}
 
#endif // _UTILS_CRC_HXX_