Browse Source

ucrc16: provide lightweight CRC16 implementation

pr/spi.typo
Martine Lenders 6 years ago committed by Martine Lenders
parent
commit
107bf0ae63
  1. 21
      sys/checksum/doc.txt
  2. 53
      sys/checksum/ucrc16.c
  3. 5
      sys/include/checksum/crc16_ccitt.h
  4. 82
      sys/include/checksum/ucrc16.h

21
sys/checksum/doc.txt

@ -1,4 +1,5 @@
/*
* Copyright 2016 Freie Universität Berlin
* Copyright 2016 Ludwig Knüpfer <ludwig.knuepfer@fu-berlin.de>
*
* This file is subject to the terms and conditions of the GNU Lesser
@ -10,4 +11,24 @@
* @defgroup sys_checksum Checksum
* @ingroup sys
* @brief Checksum function libraries
*
* This module provides a number of checksum functions. Most notably is the
* @ref sys_checksum_crc16_ccitt and the @ref sys_checksum_ucrc16 modules which
* provide support for the CRC16 checksum.
*
* @ref sys_checksum_crc16_ccitt only provides an implementation of the CCITT
* flavor of CRC16 (polynomial @$ x^{16} + x^{12} + x^{5} + 1 @$) for big-endian
* numbers with starting seed `0x1d0f` (though others can be provided), while
* @ref sys_checksum_ucrc16 is more generalized, since it takes the
* hexadecimal representation as a parameter and provides functions and
* standardized polynomials for both big- and little-endian numbers.
*
* The caveat of @ref sys_checksum_ucrc16 is that it is significantly slower
* (approximately factor 8) than @ref sys_checksum_crc16_ccitt since the latter
* is able to calculate the checksum byte-wise, while the first calculates
* needs to calculate it bit-wise. @ref sys_checksum_crc16_ccitt achieves this
* advantage by using a look-up table that provides the checksum for every
* possible byte-value. It thus trades of memory against speed. If your
* platform is rather small equipped in memory you should prefer the
* @ref sys_checksum_ucrc16 version.
*/

53
sys/checksum/ucrc16.c

@ -0,0 +1,53 @@
/*
* Copyright (C) 2016 Freie Universität Berlin
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*/
/**
* @{
*
* @file
* @author Martine Lenders <m.lenders@fu-berlin.de>
*/
#include <assert.h>
#include <inttypes.h>
#include "checksum/ucrc16.h"
#define UINT8_BIT_SIZE (8U)
#define UINT16_BIT_SIZE (16U)
#define LEFTMOST_BIT_SET(value) ((value) & 0x8000U)
#define RIGHTMOST_BIT_SET(value) ((value) & 0x0001U)
uint16_t ucrc16_calc_be(const uint8_t *buf, size_t len, uint16_t poly,
uint16_t seed)
{
assert(buf != NULL);
for (unsigned c = 0; c < len; c++, buf++) {
uint32_t tmp = seed ^ (*buf << (UINT16_BIT_SIZE - UINT8_BIT_SIZE));
for (unsigned i = 0; i < UINT8_BIT_SIZE; i++) {
tmp = LEFTMOST_BIT_SET(tmp) ? ((tmp << 1) ^ poly) : (tmp << 1);
}
seed = tmp & UINT16_MAX;
}
return seed;
}
uint16_t ucrc16_calc_le(const uint8_t *buf, size_t len, uint16_t poly,
uint16_t seed)
{
assert(buf != NULL);
for (unsigned c = 0; c < len; c++, buf++) {
seed ^= (*buf);
for (unsigned i = 0; i < UINT8_BIT_SIZE; i++) {
seed = RIGHTMOST_BIT_SET(seed) ? ((seed >> 1) ^ poly) : (seed >> 1);
}
}
return seed;
}
/** @} */

5
sys/include/checksum/crc16_ccitt.h

@ -17,6 +17,11 @@
* crc16_ccitt_update() with the desired start value
* instead of crc16_ccitt_calc().
*
* There is a more generalized version in @ref sys_checksum_ucrc16,
* that does not utilize a look-up table as this implementation
* does (and is thus also for more memory efficient). Its caveat
* however is that it is slower by about factor 8 than this version.
*
* @{
* @file
* @author Ludwig Knüpfer <ludwig.knuepfer@fu-berlin.de>

82
sys/include/checksum/ucrc16.h

@ -0,0 +1,82 @@
/*
* Copyright (C) 2016 Freie Universität Berlin
*
* This file is subject to the terms and conditions of the GNU Lesser
* General Public License v2.1. See the file LICENSE in the top level
* directory for more details.
*/
/**
* @defgroup sys_checksum_ucrc16 CRC16 (lightweight)
* @ingroup sys_checksum
* @brief Lightweight CRC16 checksum algorithms
*
* This CRC16 implementation does not use pre-calculated lookup tables and is
* thus very lightweight (memory-wise), but as a caveat slower (about factor 8)
* than the version with pre-calculated lookup tables.
*
* Additionally compared to @ref sys_checksum_crc_ccitt this is a generalized
* implementation. One can easily exchange generator polynomials and starting
* seeds.
*
* @{
*
* @file
* @brief ucrc16 definitions
*
* @author Martine Lenders <m.lenders@fu-berlin.de>
*/
#ifndef UCRC16_H_
#define UCRC16_H_
#include <stdint.h>
#include <stdlib.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* @{
* @brief Various generator polynomials
*/
#define UCRC16_CCITT_POLY_BE (0x1021) /**< CRC16-CCITT polynomial (big-endian) */
#define UCRC16_CCITT_POLY_LE (0x8408) /**< CRC16-CCITT polynomial (little-endian) */
/** *} */
/**
* @brief Calculate CRC16 (big-endian version)
*
* @param[in] buf Start of memory are to checksum
* @param[in] len Number of bytes in @p buf to calculate checksum for
* @param[in] poly The generator polynomial for the checksum
* @param[in] seed The seed (starting value) for the checksum
*
* @return Checksum of the specified memory area based on @p seed and @p poly
*
* @note The return value is not the complement of the sum but the sum itself
*/
uint16_t ucrc16_calc_be(const uint8_t *buf, size_t len, uint16_t poly,
uint16_t seed);
/**
* @brief Calculate CRC16 (little-endian version)
*
* @param[in] buf Start of memory are to checksum
* @param[in] len Number of bytes in @p buf to calculate checksum for
* @param[in] poly The generator polynomial for the checksum
* @param[in] seed The seed (starting value) for the checksum
*
* @return Checksum of the specified memory area based on @p seed and @p poly
*
* @note The return value is not the complement of the sum but the sum itself
*/
uint16_t ucrc16_calc_le(const uint8_t *buf, size_t len, uint16_t poly,
uint16_t seed);
#ifdef __cplusplus
}
#endif
#endif /* UCRC16_H_ */
/** @} */
Loading…
Cancel
Save