crc.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2024 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UTILITY_CRC_HPP
#define M5_UTILITY_CRC_HPP
 
#include <cstdint>
#include <cstddef>
#include "misc.hpp"
 
namespace m5 {
namespace utility {
 
class CRC8 {
public:
    CRC8() = delete;
    CRC8(const uint8_t init, const uint8_t polynomial, const bool refIn, const bool refOut, const uint8_t xorout)
        : _crc{init}, _init(init), _polynomial{polynomial}, _xorout{xorout}, _refIn{refIn}, _refOut{refOut}
    {
    }
    inline uint8_t range(const uint8_t* data, size_t len)
    {
        auto crc = calculate(data, len, _init, _polynomial, _refIn, _refOut, _xorout, false);
        return finalize(crc, _refOut, _xorout);
    }
    inline uint8_t update(const uint8_t* data, size_t len)
    {
        _crc = calculate(data, len, _crc, _polynomial, _refIn, _refOut, _xorout, false);
        return finalize(_crc, _refOut, _xorout);
    }
    inline uint8_t value() const
    {
        return finalize(_crc, _refOut, _xorout);
    }
    static uint8_t calculate(const uint8_t* data, size_t len, const uint8_t init, const uint8_t polynomial,
                             const bool refIn, const bool refOut, const uint8_t xorout, bool do_finalize = true)
    {
        uint8_t crc{init};
        while (len--) {
            uint8_t e = refIn ? reverseBitOrder(*data) : *data;
            ++data;
            crc ^= e;
            uint_fast8_t cnt{8};
            while (cnt--) {
                if (crc & 0x80) {
                    crc = (crc << 1) ^ polynomial;
                } else {
                    crc <<= 1;
                }
            }
        }
        return do_finalize ? finalize(crc, refOut, xorout) : crc;
    }
 
protected:
    static inline uint8_t finalize(const uint8_t value, const bool refOut, const uint8_t xorout)
    {
        return (refOut ? reverseBitOrder(value) : value) ^ xorout;
    }
 
private:
    uint8_t _crc{}, _init{}, _polynomial{}, _xorout{};
    bool _refIn{}, _refOut{};
};
 
class CRC16 {
public:
    CRC16() = delete;
    CRC16(const uint16_t init, const uint16_t polynomial, const bool refIn, const bool refOut, const uint16_t xorout)
        : _crc{init}, _init{init}, _polynomial{polynomial}, _xorout{xorout}, _refIn{refIn}, _refOut{refOut}
    {
    }
    inline uint16_t range(const uint8_t* data, size_t len)
    {
        auto crc = calculate(data, len, _init, _polynomial, _refIn, _refOut, _xorout, false);
        return finalize(crc, _refOut, _xorout);
    }
    inline uint16_t update(const uint8_t* data, size_t len)
    {
        _crc = calculate(data, len, _crc, _polynomial, _refIn, _refOut, _xorout, false);
        return finalize(_crc, _refOut, _xorout);
    }
    inline uint16_t value() const
    {
        return finalize(_crc, _refOut, _xorout);
    }
    static uint16_t calculate(const uint8_t* data, size_t len, const uint16_t init, const uint16_t polynomial,
                              const bool refIn, const bool refOut, const uint16_t xorout, bool do_finalize = true)
    {
        uint16_t crc{init};
        while (len--) {
            uint8_t e{refIn ? reverseBitOrder(*data) : *data};
            ++data;
            crc ^= (e << 8);
            uint_fast8_t cnt{8};
            while (cnt--) {
                if (crc & 0x8000) {
                    crc = (crc << 1) ^ polynomial;
                } else {
                    crc <<= 1;
                }
            }
        }
        return do_finalize ? finalize(crc, refOut, xorout) : crc;
    }
 
protected:
    static inline uint16_t finalize(const uint16_t value, const bool refOut, const uint16_t xorout)
    {
        return (refOut ? reverseBitOrder(value) : value) ^ xorout;
    }
 
private:
    uint16_t _crc{}, _init{}, _polynomial{}, _xorout{};
    bool _refIn{}, _refOut{};
};
 
class CRC8_Checksum : public CRC8 {
public:
    CRC8_Checksum() : CRC8(0xFF, 0x31, false, false, 0x00)
    {
    }
};
 
}  // namespace utility
}  // namespace m5
 
#endif