mirror of https://github.com/ARMmbed/mbed-os.git
CRC class implementation
CRC class `MbedCRC.h` is templated class created to support hardware/software CRCs. Default CRC will be hardware CRC when support for HAL is available. Polynomial tables are available for 8/16 bit CCITT, 7/16 bit for SD card and 32-bit ANSI. Polynomial table implementation will be used if Hardware CRC is not available. In case device does not have hardware CRC and polynomial table is not supported, CRC is still available and is computed runtime bit by bit for all data input.pull/5911/head
deepikabhavnani
parent
9ebefcd63d
commit
afe8834bb8
|
|
@ -0,0 +1,463 @@
|
|||
/* mbed Microcontroller Library
|
||||
* Copyright (c) 2017 ARM Limited
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#ifndef MBED_CRC_API_H
|
||||
#define MBED_CRC_API_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "drivers/TableCRC.h"
|
||||
|
||||
#if defined ( __CC_ARM )
|
||||
#pragma diag_suppress 62 // Shift count is negative
|
||||
#elif defined ( __GNUC__ )
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wshift-count-negative"
|
||||
#endif
|
||||
|
||||
namespace mbed {
|
||||
/** \addtogroup drivers */
|
||||
/** @{*/
|
||||
|
||||
/** CRC Polynomial value
|
||||
*
|
||||
* Different polynomial values supported
|
||||
*/
|
||||
typedef enum crc_polynomial {
|
||||
POLY_OTHER = 0,
|
||||
POLY_8BIT_CCITT = 0x07, // x8+x2+x+1
|
||||
POLY_7BIT_SD = 0x9, // x7+x3+1;
|
||||
POLY_16BIT_CCITT = 0x1021, // x16+x12+x5+1
|
||||
POLY_16BIT_IBM = 0x8005, // x16+x15+x2+1
|
||||
POLY_32BIT_ANSI = 0x04C11DB7, // x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
|
||||
} crc_polynomial_t;
|
||||
|
||||
/** CRC object provides CRC generation through hardware/software
|
||||
*
|
||||
* @tparam polynomial CRC polynomial value in hex
|
||||
* @tparam width CRC polynomial width
|
||||
*/
|
||||
|
||||
template <uint32_t polynomial=POLY_32BIT_ANSI, uint8_t width=32>
|
||||
class MbedCRC
|
||||
{
|
||||
public:
|
||||
typedef uint64_t crc_data_size_t;
|
||||
|
||||
/** Lifetime of CRC object
|
||||
*
|
||||
* @param initial_xor Inital value/seed to Xor (Default ~0x0)
|
||||
* @param final_xor Final Xor value (Default ~0x0)
|
||||
* @param reflect_data
|
||||
* @param reflect_remainder
|
||||
*/
|
||||
MbedCRC(uint32_t initial_xor, uint32_t final_xor, bool reflect_data, bool reflect_remainder);
|
||||
MbedCRC();
|
||||
virtual ~MbedCRC()
|
||||
{
|
||||
// Do nothing
|
||||
}
|
||||
|
||||
/** Initialize a CRC module
|
||||
*
|
||||
* @return 0 on success or a negative error code on failure
|
||||
*/
|
||||
int32_t init(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** Deinitialize a CRC module
|
||||
*
|
||||
* @return 0 on success, negative error code on failure
|
||||
*/
|
||||
int32_t deinit(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** Compute CRC for the data input
|
||||
*
|
||||
* @param buffer Data bytes
|
||||
* @param size Size of data
|
||||
* @param crc CRC is the output value
|
||||
* @return 0 on success, negative error code on failure
|
||||
*/
|
||||
int32_t compute(void *buffer, crc_data_size_t size, uint32_t *crc)
|
||||
{
|
||||
int32_t status;
|
||||
if (0 != (status = compute_partial_start(crc))) {
|
||||
*crc = 0;
|
||||
return status;
|
||||
}
|
||||
if (0 != (status = compute_partial(buffer, size, crc))) {
|
||||
*crc = 0;
|
||||
return status;
|
||||
}
|
||||
if (0 != (status = compute_partial_stop(crc))) {
|
||||
*crc = 0;
|
||||
return status;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** Compute partial CRC for the data input.
|
||||
*
|
||||
* CRC data if not available fully, CRC can be computed in parts with available data.
|
||||
* Previous CRC output should be passed as argument to the current compute_partial call.
|
||||
* @pre: Call \ref compute_partial_start to start the partial CRC calculation.
|
||||
* @post: Call \ref compute_partial_stop to get the final CRC value.
|
||||
*
|
||||
* @param buffer Data bytes
|
||||
* @param size Size of data
|
||||
* @param crc CRC value is intermediate CRC value filled by API.
|
||||
* @return 0 on success or a negative error code on failure
|
||||
* @note: CRC as output in compute_partial is not final CRC value, call @ref compute_partial_stop
|
||||
* to get final correct CRC value.
|
||||
*/
|
||||
int32_t compute_partial(void *buffer, crc_data_size_t size, uint32_t *crc)
|
||||
{
|
||||
if (NULL == _crc_table) {
|
||||
// Compute Slow CRC
|
||||
return bitwise_compute_partial(buffer, size, crc);
|
||||
} else {
|
||||
// Table CRC
|
||||
return table_compute_partial(buffer, size, crc);
|
||||
}
|
||||
}
|
||||
|
||||
/** Compute partial start, indicate start of partial computation
|
||||
*
|
||||
* This API should be called before performing any partial computation
|
||||
* with compute_partial API.
|
||||
*
|
||||
* @param crc Initial CRC value set by the API
|
||||
* @return 0 on success or a negative in case of failure
|
||||
* @note: CRC is an out parameter and must be reused with compute_partial
|
||||
* and compute_partial_stop without any modifications in application.
|
||||
*/
|
||||
int32_t compute_partial_start(uint32_t *crc)
|
||||
{
|
||||
MBED_ASSERT(crc != NULL);
|
||||
*crc = _initial_value;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** Get the final CRC value of partial computation.
|
||||
*
|
||||
* CRC value available in partial computation is not correct CRC, as some
|
||||
* algorithms require remainder to be reflected and final value to be XORed
|
||||
* This API is used to perform final computation to get correct CRC value.
|
||||
*
|
||||
* @param crc CRC result
|
||||
*/
|
||||
int32_t compute_partial_stop(uint32_t *crc)
|
||||
{
|
||||
MBED_ASSERT(crc != NULL);
|
||||
uint32_t p_crc = *crc;
|
||||
if ((width < 8) && (NULL == _crc_table)) {
|
||||
p_crc = (uint32_t)(p_crc << (8 - width));
|
||||
}
|
||||
*crc = (reflect_remainder(p_crc) ^ _final_xor) & get_crc_mask();
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** Get the current CRC polynomial
|
||||
*
|
||||
* @return Polynomial value
|
||||
*/
|
||||
uint32_t get_polynomial(void) const
|
||||
{
|
||||
return polynomial;
|
||||
}
|
||||
|
||||
/** Get the current CRC width
|
||||
*
|
||||
* @return CRC width
|
||||
*/
|
||||
uint8_t get_width(void) const
|
||||
{
|
||||
return width;
|
||||
}
|
||||
|
||||
private:
|
||||
uint32_t _initial_value;
|
||||
uint32_t _final_xor;
|
||||
bool _reflect_data;
|
||||
bool _reflect_remainder;
|
||||
uint32_t *_crc_table;
|
||||
|
||||
/** Get the current CRC data size
|
||||
*
|
||||
* @return CRC data size in bytes
|
||||
*/
|
||||
uint8_t get_data_size(void) const
|
||||
{
|
||||
return (width <= 8 ? 1 : (width <= 16 ? 2 : 4));
|
||||
}
|
||||
|
||||
/** Get the top bit of current CRC
|
||||
*
|
||||
* @return Top bit is set high for respective data width of current CRC
|
||||
* Top bit for CRC width less then 8 bits will be set as 8th bit.
|
||||
*/
|
||||
uint32_t get_top_bit(void) const
|
||||
{
|
||||
return (width < 8 ? (1u << 7) : (uint32_t)(1ul << (width - 1)));
|
||||
}
|
||||
|
||||
/** Get the CRC data mask
|
||||
*
|
||||
* @return CRC data mask is generated based on current CRC width
|
||||
*/
|
||||
uint32_t get_crc_mask(void) const
|
||||
{
|
||||
return (width < 8 ? ((1u << 8)-1) : (uint32_t)((uint64_t)(1ull << width) - 1));
|
||||
}
|
||||
|
||||
/** Final value of CRC is reflected
|
||||
*
|
||||
* @param data final crc value, which should be reflected
|
||||
* @return Reflected CRC value
|
||||
*/
|
||||
uint32_t reflect_remainder(uint32_t data) const
|
||||
{
|
||||
if (_reflect_remainder) {
|
||||
uint32_t reflection = 0x0;
|
||||
uint8_t const nBits = (width < 8 ? 8 : width);
|
||||
|
||||
for (uint8_t bit = 0; bit < nBits; ++bit) {
|
||||
if (data & 0x01) {
|
||||
reflection |= (1 << ((nBits - 1) - bit));
|
||||
}
|
||||
data = (data >> 1);
|
||||
}
|
||||
return (reflection);
|
||||
} else {
|
||||
return data;
|
||||
}
|
||||
}
|
||||
|
||||
/** Data bytes are reflected
|
||||
*
|
||||
* @param data value to be reflected
|
||||
* @return Reflected data value
|
||||
*/
|
||||
uint32_t reflect_bytes(uint32_t data) const
|
||||
{
|
||||
if(_reflect_data) {
|
||||
uint32_t reflection = 0x0;
|
||||
|
||||
for (uint8_t bit = 0; bit < 8; ++bit) {
|
||||
if (data & 0x01) {
|
||||
reflection |= (1 << (7 - bit));
|
||||
}
|
||||
data = (data >> 1);
|
||||
}
|
||||
return (reflection);
|
||||
} else {
|
||||
return data;
|
||||
}
|
||||
}
|
||||
|
||||
/** Bitwise CRC computation
|
||||
*
|
||||
* @param buffer data buffer
|
||||
* @param size size of the data
|
||||
* @param crc CRC value is filled in, but the value is not the final
|
||||
* @return 0 on success or a negative error code on failure
|
||||
*/
|
||||
int32_t bitwise_compute_partial(const void *buffer, crc_data_size_t size, uint32_t *crc) const
|
||||
{
|
||||
MBED_ASSERT(crc != NULL);
|
||||
MBED_ASSERT(buffer != NULL);
|
||||
|
||||
const uint8_t *data = static_cast<const uint8_t *>(buffer);
|
||||
uint32_t p_crc = *crc;
|
||||
|
||||
if (width < 8) {
|
||||
uint8_t data_byte;
|
||||
for (crc_data_size_t byte = 0; byte < size; byte++) {
|
||||
data_byte = reflect_bytes(data[byte]);
|
||||
for (uint8_t bit = 8; bit > 0; --bit) {
|
||||
p_crc <<= 1;
|
||||
if (( data_byte ^ p_crc) & get_top_bit()) {
|
||||
p_crc ^= polynomial;
|
||||
}
|
||||
data_byte <<= 1;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (crc_data_size_t byte = 0; byte < size; byte++) {
|
||||
p_crc ^= (reflect_bytes(data[byte]) << (width - 8));
|
||||
|
||||
// Perform modulo-2 division, a bit at a time
|
||||
for (uint8_t bit = 8; bit > 0; --bit) {
|
||||
if (p_crc & get_top_bit()) {
|
||||
p_crc = (p_crc << 1) ^ polynomial;
|
||||
} else {
|
||||
p_crc = (p_crc << 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
*crc = p_crc & get_crc_mask();
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** CRC computation using ROM tables
|
||||
*
|
||||
* @param buffer data buffer
|
||||
* @param size size of the data
|
||||
* @param crc CRC value is filled in, but the value is not the final
|
||||
* @return 0 on success or a negative error code on failure
|
||||
*/
|
||||
int32_t table_compute_partial(const void *buffer, crc_data_size_t size, uint32_t *crc) const
|
||||
{
|
||||
MBED_ASSERT(crc != NULL);
|
||||
MBED_ASSERT(buffer != NULL);
|
||||
|
||||
const uint8_t *data = static_cast<const uint8_t *>(buffer);
|
||||
uint32_t p_crc = *crc;
|
||||
uint8_t data_byte = 0;
|
||||
|
||||
if (width <= 8) {
|
||||
uint8_t *crc_table = (uint8_t *)_crc_table;
|
||||
for (crc_data_size_t byte = 0; byte < size; byte++) {
|
||||
data_byte = reflect_bytes(data[byte]) ^ p_crc;
|
||||
p_crc = crc_table[data_byte];
|
||||
}
|
||||
} else if (width <= 16) {
|
||||
uint16_t *crc_table = (uint16_t *)_crc_table;
|
||||
for (crc_data_size_t byte = 0; byte < size; byte++) {
|
||||
data_byte = reflect_bytes(data[byte]) ^ (p_crc >> (width - 8));
|
||||
p_crc = crc_table[data_byte] ^ (p_crc << 8);
|
||||
}
|
||||
} else {
|
||||
uint32_t *crc_table = (uint32_t *)_crc_table;
|
||||
for (crc_data_size_t byte = 0; byte < size; byte++) {
|
||||
data_byte = reflect_bytes(data[byte]) ^ (p_crc >> (width - 8));
|
||||
p_crc = crc_table[data_byte] ^ (p_crc << 8);
|
||||
}
|
||||
}
|
||||
*crc = p_crc & get_crc_mask();
|
||||
return 0;
|
||||
}
|
||||
|
||||
/** Constructor init called from all specialized cases of constructor
|
||||
* Note: All construtor common code should be in this function.
|
||||
*/
|
||||
void mbed_crc_ctor(void) const
|
||||
{
|
||||
MBED_STATIC_ASSERT(width <= 32, "Max 32-bit CRC supported");
|
||||
}
|
||||
};
|
||||
|
||||
/* Default values for different types of polynomials
|
||||
*/
|
||||
template <uint32_t polynomial, uint8_t width>
|
||||
MbedCRC<polynomial, width>::MbedCRC(uint32_t initial_xor, uint32_t final_xor, bool reflect_data, bool reflect_remainder):
|
||||
_initial_value(initial_xor), _final_xor(final_xor), _reflect_data(reflect_data), _reflect_remainder(reflect_remainder), _crc_table(NULL)
|
||||
{
|
||||
mbed_crc_ctor();
|
||||
}
|
||||
|
||||
template<>
|
||||
MbedCRC<POLY_32BIT_ANSI, 32>::MbedCRC(uint32_t initial_xor, uint32_t final_xor, bool reflect_data, bool reflect_remainder):
|
||||
_initial_value(initial_xor), _final_xor(final_xor), _reflect_data(reflect_data), _reflect_remainder(reflect_remainder),
|
||||
_crc_table((uint32_t *)Table_CRC_32bit_ANSI)
|
||||
{
|
||||
mbed_crc_ctor();
|
||||
}
|
||||
|
||||
template<>
|
||||
MbedCRC<POLY_8BIT_CCITT, 8>::MbedCRC(uint32_t initial_xor, uint32_t final_xor, bool reflect_data, bool reflect_remainder):
|
||||
_initial_value(initial_xor), _final_xor(final_xor), _reflect_data(reflect_data), _reflect_remainder(reflect_remainder),
|
||||
_crc_table((uint32_t *)Table_CRC_8bit_CCITT)
|
||||
{
|
||||
mbed_crc_ctor();
|
||||
}
|
||||
|
||||
template<>
|
||||
MbedCRC<POLY_7BIT_SD, 7>::MbedCRC(uint32_t initial_xor, uint32_t final_xor, bool reflect_data, bool reflect_remainder):
|
||||
_initial_value(initial_xor), _final_xor(final_xor), _reflect_data(reflect_data), _reflect_remainder(reflect_remainder),
|
||||
_crc_table((uint32_t *)Table_CRC_7Bit_SD)
|
||||
{
|
||||
mbed_crc_ctor();
|
||||
}
|
||||
|
||||
template<>
|
||||
MbedCRC<POLY_16BIT_CCITT, 16>::MbedCRC(uint32_t initial_xor, uint32_t final_xor, bool reflect_data, bool reflect_remainder):
|
||||
_initial_value(initial_xor), _final_xor(final_xor), _reflect_data(reflect_data), _reflect_remainder(reflect_remainder),
|
||||
_crc_table((uint32_t *)Table_CRC_16bit_CCITT)
|
||||
{
|
||||
}
|
||||
|
||||
template<>
|
||||
MbedCRC<POLY_16BIT_IBM, 16>::MbedCRC(uint32_t initial_xor, uint32_t final_xor, bool reflect_data, bool reflect_remainder):
|
||||
_initial_value(initial_xor), _final_xor(final_xor), _reflect_data(reflect_data), _reflect_remainder(reflect_remainder),
|
||||
_crc_table((uint32_t *)Table_CRC_16bit_IBM)
|
||||
{
|
||||
mbed_crc_ctor();
|
||||
}
|
||||
|
||||
template<>
|
||||
MbedCRC<POLY_32BIT_ANSI, 32>::MbedCRC():
|
||||
_initial_value(~(0x0)), _final_xor(~(0x0)), _reflect_data(true), _reflect_remainder(true),
|
||||
_crc_table((uint32_t *)Table_CRC_32bit_ANSI)
|
||||
{
|
||||
mbed_crc_ctor();
|
||||
}
|
||||
|
||||
template<>
|
||||
MbedCRC<POLY_16BIT_IBM, 16>::MbedCRC():
|
||||
_initial_value(0), _final_xor(0), _reflect_data(true), _reflect_remainder(true),
|
||||
_crc_table((uint32_t *)Table_CRC_16bit_IBM)
|
||||
{
|
||||
mbed_crc_ctor();
|
||||
}
|
||||
|
||||
template<>
|
||||
MbedCRC<POLY_16BIT_CCITT, 16>::MbedCRC():
|
||||
_initial_value(~(0x0)), _final_xor(0), _reflect_data(false), _reflect_remainder(false),
|
||||
_crc_table((uint32_t *)Table_CRC_16bit_CCITT)
|
||||
{
|
||||
mbed_crc_ctor();
|
||||
}
|
||||
|
||||
template<>
|
||||
MbedCRC<POLY_7BIT_SD, 7>::MbedCRC():
|
||||
_initial_value(0), _final_xor(0), _reflect_data(false), _reflect_remainder(false),
|
||||
_crc_table((uint32_t *)Table_CRC_7Bit_SD)
|
||||
{
|
||||
mbed_crc_ctor();
|
||||
}
|
||||
|
||||
template<>
|
||||
MbedCRC<POLY_8BIT_CCITT, 8>::MbedCRC():
|
||||
_initial_value(0), _final_xor(0), _reflect_data(false), _reflect_remainder(false),
|
||||
_crc_table((uint32_t *)Table_CRC_8bit_CCITT)
|
||||
{
|
||||
mbed_crc_ctor();
|
||||
}
|
||||
|
||||
#if defined ( __CC_ARM )
|
||||
#elif defined ( __GNUC__ )
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
|
||||
/** @}*/
|
||||
} // namespace mbed
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,150 @@
|
|||
/* mbed Microcontroller Library
|
||||
* Copyright (c) 2017 ARM Limited
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef TABLE_CRC_H
|
||||
#define TABLE_CRC_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
namespace mbed {
|
||||
/** \addtogroup drivers */
|
||||
/** @{*/
|
||||
|
||||
const uint8_t Table_CRC_7Bit_SD[] = {
|
||||
0x0, 0x12, 0x24, 0x36, 0x48, 0x5a, 0x6c, 0x7e, 0x90, 0x82, 0xb4, 0xa6, 0xd8, 0xca, 0xfc, 0xee,
|
||||
0x32, 0x20, 0x16, 0x4, 0x7a, 0x68, 0x5e, 0x4c, 0xa2, 0xb0, 0x86, 0x94, 0xea, 0xf8, 0xce, 0xdc,
|
||||
0x64, 0x76, 0x40, 0x52, 0x2c, 0x3e, 0x8, 0x1a, 0xf4, 0xe6, 0xd0, 0xc2, 0xbc, 0xae, 0x98, 0x8a,
|
||||
0x56, 0x44, 0x72, 0x60, 0x1e, 0xc, 0x3a, 0x28, 0xc6, 0xd4, 0xe2, 0xf0, 0x8e, 0x9c, 0xaa, 0xb8,
|
||||
0xc8, 0xda, 0xec, 0xfe, 0x80, 0x92, 0xa4, 0xb6, 0x58, 0x4a, 0x7c, 0x6e, 0x10, 0x2, 0x34, 0x26,
|
||||
0xfa, 0xe8, 0xde, 0xcc, 0xb2, 0xa0, 0x96, 0x84, 0x6a, 0x78, 0x4e, 0x5c, 0x22, 0x30, 0x6, 0x14,
|
||||
0xac, 0xbe, 0x88, 0x9a, 0xe4, 0xf6, 0xc0, 0xd2, 0x3c, 0x2e, 0x18, 0xa, 0x74, 0x66, 0x50, 0x42,
|
||||
0x9e, 0x8c, 0xba, 0xa8, 0xd6, 0xc4, 0xf2, 0xe0, 0xe, 0x1c, 0x2a, 0x38, 0x46, 0x54, 0x62, 0x70,
|
||||
0x82, 0x90, 0xa6, 0xb4, 0xca, 0xd8, 0xee, 0xfc, 0x12, 0x0, 0x36, 0x24, 0x5a, 0x48, 0x7e, 0x6c,
|
||||
0xb0, 0xa2, 0x94, 0x86, 0xf8, 0xea, 0xdc, 0xce, 0x20, 0x32, 0x4, 0x16, 0x68, 0x7a, 0x4c, 0x5e,
|
||||
0xe6, 0xf4, 0xc2, 0xd0, 0xae, 0xbc, 0x8a, 0x98, 0x76, 0x64, 0x52, 0x40, 0x3e, 0x2c, 0x1a, 0x8,
|
||||
0xd4, 0xc6, 0xf0, 0xe2, 0x9c, 0x8e, 0xb8, 0xaa, 0x44, 0x56, 0x60, 0x72, 0xc, 0x1e, 0x28, 0x3a,
|
||||
0x4a, 0x58, 0x6e, 0x7c, 0x2, 0x10, 0x26, 0x34, 0xda, 0xc8, 0xfe, 0xec, 0x92, 0x80, 0xb6, 0xa4,
|
||||
0x78, 0x6a, 0x5c, 0x4e, 0x30, 0x22, 0x14, 0x6, 0xe8, 0xfa, 0xcc, 0xde, 0xa0, 0xb2, 0x84, 0x96,
|
||||
0x2e, 0x3c, 0xa, 0x18, 0x66, 0x74, 0x42, 0x50, 0xbe, 0xac, 0x9a, 0x88, 0xf6, 0xe4, 0xd2, 0xc0,
|
||||
0x1c, 0xe, 0x38, 0x2a, 0x54, 0x46, 0x70, 0x62, 0x8c, 0x9e, 0xa8, 0xba, 0xc4, 0xd6, 0xe0, 0xf2
|
||||
};
|
||||
|
||||
const uint8_t Table_CRC_8bit_CCITT[] = {
|
||||
0x0, 0x7, 0xe, 0x9, 0x1c, 0x1b, 0x12, 0x15, 0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
|
||||
0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65, 0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
|
||||
0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5, 0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
|
||||
0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85, 0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
|
||||
0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2, 0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
|
||||
0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2, 0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
|
||||
0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32, 0x1f, 0x18, 0x11, 0x16, 0x3, 0x4, 0xd, 0xa,
|
||||
0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42, 0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
|
||||
0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c, 0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
|
||||
0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec, 0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
|
||||
0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c, 0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
|
||||
0x19, 0x1e, 0x17, 0x10, 0x5, 0x2, 0xb, 0xc, 0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
|
||||
0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b, 0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
|
||||
0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b, 0x6, 0x1, 0x8, 0xf, 0x1a, 0x1d, 0x14, 0x13,
|
||||
0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb, 0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
|
||||
0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb, 0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
|
||||
};
|
||||
|
||||
const uint16_t Table_CRC_16bit_CCITT[] = {
|
||||
0x0, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b,
|
||||
0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, 0x1231, 0x210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
|
||||
0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x420, 0x1401,
|
||||
0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
|
||||
0x3653, 0x2672, 0x1611, 0x630, 0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738,
|
||||
0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x840, 0x1861, 0x2802, 0x3823,
|
||||
0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, 0x5af5, 0x4ad4, 0x7ab7, 0x6a96,
|
||||
0x1a71, 0xa50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
|
||||
0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0xc60, 0x1c41, 0xedae, 0xfd8f, 0xcdec, 0xddcd,
|
||||
0xad2a, 0xbd0b, 0x8d68, 0x9d49, 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0xe70,
|
||||
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0x9188, 0x81a9, 0xb1ca, 0xa1eb,
|
||||
0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080, 0xa1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
|
||||
0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x2b1, 0x1290, 0x22f3, 0x32d2,
|
||||
0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
|
||||
0x34e2, 0x24c3, 0x14a0, 0x481, 0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8,
|
||||
0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
|
||||
0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827,
|
||||
0x18c0, 0x8e1, 0x3882, 0x28a3, 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
|
||||
0x4a75, 0x5a54, 0x6a37, 0x7a16, 0xaf1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d,
|
||||
0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0xcc1,
|
||||
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74,
|
||||
0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
|
||||
};
|
||||
|
||||
const uint16_t Table_CRC_16bit_IBM[] = {
|
||||
0x0, 0x8005, 0x800f, 0xa, 0x801b, 0x1e, 0x14, 0x8011, 0x8033, 0x36, 0x3c, 0x8039,
|
||||
0x28, 0x802d, 0x8027, 0x22, 0x8063, 0x66, 0x6c, 0x8069, 0x78, 0x807d, 0x8077, 0x72,
|
||||
0x50, 0x8055, 0x805f, 0x5a, 0x804b, 0x4e, 0x44, 0x8041, 0x80c3, 0xc6, 0xcc, 0x80c9,
|
||||
0xd8, 0x80dd, 0x80d7, 0xd2, 0xf0, 0x80f5, 0x80ff, 0xfa, 0x80eb, 0xee, 0xe4, 0x80e1,
|
||||
0xa0, 0x80a5, 0x80af, 0xaa, 0x80bb, 0xbe, 0xb4, 0x80b1, 0x8093, 0x96, 0x9c, 0x8099,
|
||||
0x88, 0x808d, 0x8087, 0x82, 0x8183, 0x186, 0x18c, 0x8189, 0x198, 0x819d, 0x8197, 0x192,
|
||||
0x1b0, 0x81b5, 0x81bf, 0x1ba, 0x81ab, 0x1ae, 0x1a4, 0x81a1, 0x1e0, 0x81e5, 0x81ef, 0x1ea,
|
||||
0x81fb, 0x1fe, 0x1f4, 0x81f1, 0x81d3, 0x1d6, 0x1dc, 0x81d9, 0x1c8, 0x81cd, 0x81c7, 0x1c2,
|
||||
0x140, 0x8145, 0x814f, 0x14a, 0x815b, 0x15e, 0x154, 0x8151, 0x8173, 0x176, 0x17c, 0x8179,
|
||||
0x168, 0x816d, 0x8167, 0x162, 0x8123, 0x126, 0x12c, 0x8129, 0x138, 0x813d, 0x8137, 0x132,
|
||||
0x110, 0x8115, 0x811f, 0x11a, 0x810b, 0x10e, 0x104, 0x8101, 0x8303, 0x306, 0x30c, 0x8309,
|
||||
0x318, 0x831d, 0x8317, 0x312, 0x330, 0x8335, 0x833f, 0x33a, 0x832b, 0x32e, 0x324, 0x8321,
|
||||
0x360, 0x8365, 0x836f, 0x36a, 0x837b, 0x37e, 0x374, 0x8371, 0x8353, 0x356, 0x35c, 0x8359,
|
||||
0x348, 0x834d, 0x8347, 0x342, 0x3c0, 0x83c5, 0x83cf, 0x3ca, 0x83db, 0x3de, 0x3d4, 0x83d1,
|
||||
0x83f3, 0x3f6, 0x3fc, 0x83f9, 0x3e8, 0x83ed, 0x83e7, 0x3e2, 0x83a3, 0x3a6, 0x3ac, 0x83a9,
|
||||
0x3b8, 0x83bd, 0x83b7, 0x3b2, 0x390, 0x8395, 0x839f, 0x39a, 0x838b, 0x38e, 0x384, 0x8381,
|
||||
0x280, 0x8285, 0x828f, 0x28a, 0x829b, 0x29e, 0x294, 0x8291, 0x82b3, 0x2b6, 0x2bc, 0x82b9,
|
||||
0x2a8, 0x82ad, 0x82a7, 0x2a2, 0x82e3, 0x2e6, 0x2ec, 0x82e9, 0x2f8, 0x82fd, 0x82f7, 0x2f2,
|
||||
0x2d0, 0x82d5, 0x82df, 0x2da, 0x82cb, 0x2ce, 0x2c4, 0x82c1, 0x8243, 0x246, 0x24c, 0x8249,
|
||||
0x258, 0x825d, 0x8257, 0x252, 0x270, 0x8275, 0x827f, 0x27a, 0x826b, 0x26e, 0x264, 0x8261,
|
||||
0x220, 0x8225, 0x822f, 0x22a, 0x823b, 0x23e, 0x234, 0x8231, 0x8213, 0x216, 0x21c, 0x8219
|
||||
};
|
||||
|
||||
const uint32_t Table_CRC_32bit_ANSI[] = {
|
||||
0x0, 0x4c11db7, 0x9823b6e, 0xd4326d9, 0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
|
||||
0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
|
||||
0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
|
||||
0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
|
||||
0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039, 0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
|
||||
0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
|
||||
0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
|
||||
0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
|
||||
0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
|
||||
0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16, 0x18aeb13, 0x54bf6a4, 0x808d07d, 0xcc9cdca,
|
||||
0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
|
||||
0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
|
||||
0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
|
||||
0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
|
||||
0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e, 0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
|
||||
0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
|
||||
0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
|
||||
0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
|
||||
0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
|
||||
0x315d626, 0x7d4cb91, 0xa97ed48, 0xe56f0ff, 0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
|
||||
0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
|
||||
0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
|
||||
0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
|
||||
0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
|
||||
0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640, 0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
|
||||
0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
|
||||
0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30, 0x29f3d35, 0x65e2082, 0xb1d065b, 0xfdc1bec,
|
||||
0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
|
||||
0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
|
||||
0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18, 0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
|
||||
0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
|
||||
0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
|
||||
};
|
||||
} // namespace mbed
|
||||
|
||||
/** @}*/
|
||||
#endif
|
||||
Loading…
Reference in New Issue