2016-12-16 18:40:37 -04:00
|
|
|
/*
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
interfaces to ArduPilot collection of CRCs.
|
|
|
|
*/
|
2018-09-11 06:48:30 -03:00
|
|
|
#pragma once
|
2016-12-16 18:40:37 -04:00
|
|
|
|
2022-11-20 21:45:41 -04:00
|
|
|
#include <stdint.h>
|
|
|
|
|
2019-04-24 03:51:28 -03:00
|
|
|
uint16_t crc_crc4(uint16_t *data);
|
2017-03-22 03:12:48 -03:00
|
|
|
uint8_t crc_crc8(const uint8_t *p, uint8_t len);
|
2022-04-26 22:09:20 -03:00
|
|
|
uint8_t crc8_generic(const uint8_t *buf, const uint16_t buf_len, const uint8_t polynomial); // CRC8 that does not use a lookup table for generic polynomials
|
2020-04-30 16:35:18 -03:00
|
|
|
uint8_t crc8_dvb_s2(uint8_t crc, uint8_t a);
|
|
|
|
uint8_t crc8_dvb(uint8_t crc, uint8_t a, uint8_t seed);
|
2020-08-04 17:43:23 -03:00
|
|
|
uint8_t crc8_dvb_s2_update(uint8_t crc, const void *data, uint32_t length);
|
2021-06-29 11:13:07 -03:00
|
|
|
uint8_t crc8_dvb_update(uint8_t crc, const uint8_t* buf, const uint16_t buf_len);
|
2021-07-02 22:38:53 -03:00
|
|
|
uint8_t crc8_maxim(const uint8_t *data, uint16_t length);
|
2023-05-01 08:32:43 -03:00
|
|
|
uint8_t crc8_sae(const uint8_t *data, uint16_t length);
|
2018-03-18 02:01:27 -03:00
|
|
|
uint16_t crc_xmodem_update(uint16_t crc, uint8_t data);
|
2019-02-06 06:51:48 -04:00
|
|
|
uint16_t crc_xmodem(const uint8_t *data, uint16_t len);
|
2018-04-14 08:08:45 -03:00
|
|
|
uint32_t crc_crc32(uint32_t crc, const uint8_t *buf, uint32_t size);
|
2019-10-27 08:50:01 -03:00
|
|
|
uint32_t crc32_small(uint32_t crc, const uint8_t *buf, uint32_t size);
|
2020-04-14 07:29:59 -03:00
|
|
|
uint32_t crc_crc24(const uint8_t *bytes, uint16_t len);
|
2021-06-06 03:16:55 -03:00
|
|
|
uint16_t crc_crc16_ibm(uint16_t crc_accum, uint8_t *data_blk_ptr, uint16_t data_blk_size);
|
2019-05-19 09:05:36 -03:00
|
|
|
|
2023-11-28 22:02:03 -04:00
|
|
|
// checksum used by SPORT/FPort. For each byte, adds it to a 16-bit
|
|
|
|
// sum, then adds those two bytes together. Returns the complement of
|
|
|
|
// the final sum.
|
|
|
|
uint8_t crc_sum8_with_carry(const uint8_t *p, uint8_t len);
|
2020-10-26 03:32:52 -03:00
|
|
|
|
2019-05-19 09:05:36 -03:00
|
|
|
// Copyright (C) 2010 Swift Navigation Inc.
|
|
|
|
// Contact: Fergus Noble <fergus@swift-nav.com>
|
2019-04-19 07:45:13 -03:00
|
|
|
uint16_t crc16_ccitt(const uint8_t *buf, uint32_t len, uint16_t crc);
|
2023-10-26 04:55:03 -03:00
|
|
|
uint16_t crc16_ccitt_r(const uint8_t *buf, uint32_t len, uint16_t crc, uint16_t out);
|
2019-04-19 07:45:13 -03:00
|
|
|
|
2021-04-27 04:01:46 -03:00
|
|
|
// CRC16_CCITT algorithm using the GDL90 parser method which is non-standard
|
|
|
|
// https://www.faa.gov/nextgen/programs/adsb/archival/media/gdl90_public_icd_reva.pdf
|
|
|
|
uint16_t crc16_ccitt_GDL90(const uint8_t *buf, uint32_t len, uint16_t crc);
|
|
|
|
|
2021-03-02 14:48:34 -04:00
|
|
|
uint16_t calc_crc_modbus(const uint8_t *buf, uint16_t len);
|
|
|
|
|
|
|
|
uint16_t crc_fletcher16(const uint8_t * buffer, uint32_t len);
|
2019-04-19 07:45:13 -03:00
|
|
|
|
2019-10-06 02:36:19 -03:00
|
|
|
// generate 64bit FNV1a hash from buffer
|
|
|
|
#define FNV_1_OFFSET_BASIS_64 14695981039346656037UL
|
|
|
|
void hash_fnv_1a(uint32_t len, const uint8_t* buf, uint64_t* hash);
|
|
|
|
|
2022-02-04 21:41:09 -04:00
|
|
|
// CRC-64-WE using the polynomial of 0x42F0E1EBA9EA3693
|
|
|
|
uint64_t crc_crc64(const uint32_t *data, uint16_t num_words);
|
2023-06-06 00:56:02 -03:00
|
|
|
|
|
|
|
// return the parity of byte - "1" if there is an odd number of bits
|
|
|
|
// set, "0" if there is an even number of bits set
|
|
|
|
uint8_t parity(uint8_t byte);
|
2023-06-26 11:02:15 -03:00
|
|
|
|
|
|
|
// sums the bytes in the supplied buffer, returns that sum mod 256
|
|
|
|
// (i.e. shoved into a uint8_t)
|
|
|
|
uint8_t crc_sum_of_bytes(uint8_t *data, uint16_t count);
|