1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
//
// srecord - manipulate eprom load files
// Copyright (C) 2000-2003, 2006-2010, 2012 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser 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 Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
//
// See http://www.joegeluso.com/software/articles/ccitt.htm for a great
// write-up on the CRC16 calculation.
//
#ifndef SRECORD_CRC16_H
#define SRECORD_CRC16_H
#include <stddef.h>
namespace srecord
{
/**
* The crc16 class is used to represent the running value of a 16-bit
* cyclic redundancy check of series of bytes.
*
* Note: this CRC16 works for systems that process the leaast
* significant bit of each byte first, and working to wards the most
* significant bit.
*
* If you were expecting MSB first (you may not even know it) this
* code will give you "wrong" answers. Try using the bitrev filter.
*/
class crc16
{
public:
// See http://en.wikipedia.org/wiki/Cyclic_redundancy_check
// for table of polynomials.
enum
{
/**
* X.25, V.41, HDLC, XMODEM, Bluetooth, SD, CRC-CCITT
*/
polynomial_ccitt = 0x1021,
/**
* CRC-16-IBM, Bisync, Modbus, USB, ANSI X3.28, CRC-16-ANSI
*/
polynomial_ansi = 0x8005,
/**
* CRC-16-DNP, DNP, IEC 870, M-Bus
*/
polynomial_dnp = 0x3D65,
/**
* CRC-16-DECT
*/
polynomial_dect = 0x0589,
/**
* CRC-16-T10-DIF, SCSI DIF
*/
polynomial_t10_dif = 0x8BB7,
};
/**
* The polynomial_by_name class method is used to take the name
* of a CRC-16 polynamlial, and return the value of the CRC-16
* polynomial corresponding to that name.
*/
static int polynomial_by_name(const char *name);
enum seed_mode_t
{
seed_mode_ccitt,
seed_mode_xmodem,
seed_mode_broken
};
/**
* The destructor.
*/
virtual ~crc16();
enum bit_direction_t
{
bit_direction_most_to_least,
bit_direction_least_to_most,
};
/**
* The default constructor.
*
* @param seed_mode
* This selects which CRC16 calculation seed is to be used.
* @param augment
* This is true if the 16-zero-bit augmentation is desired.
* This is the default. False if no augmentation is desired.
* @param polynomial
* The checksum polynomial.
* @param bitdir
* The direction of bits in a characters as they pass through
* the algorithm.
*/
crc16(seed_mode_t seed_mode = seed_mode_ccitt, bool augment = true,
unsigned short polynomial = polynomial_ccitt,
bit_direction_t bitdir = bit_direction_most_to_least);
/**
* The copy constructor.
*/
crc16(const crc16 &);
/**
* The assignment operator.
*/
crc16 &operator=(const crc16 &);
/**
* The get method is used to obtain the running value of the cyclic
* redundancy check.
*/
unsigned short get() const;
/**
* The next method is used to advance the state by one byte.
*/
void next(unsigned char);
/**
* The nextbuf method is used to advance the state by a series of bytes.
*/
void nextbuf(const void *, size_t);
/**
* The print_table method may be used to print the table being used.
* This is principally for debugging the table generation process.
*/
void print_table(void) const;
private:
/**
* The state instance variable is used to remember the running
* value of the 16-bit cyclic redundancy check.
*/
unsigned short state;
/**
* The augment instance variable is used to remember whether or
* not the 16 zero bits of augmentation are to be processed before
* reporting the result.
*/
bool augment;
/**
* The polynomial instance variable is used to remember the CRC
* polynomial being calculated with. Note that if the bitdir is
* low-to-high then the bits in the polynomial will be reversed.
*/
unsigned short polynomial;
/**
* The bitdir instance variable is sued to remember the direction
* of bits in a characters as they pass through the algorithm.
*/
bit_direction_t bitdir;
/**
* The table instance variable is used to remember the results of 8
* shift-and-process operations for each byte value. This is used
* to improve efficiency. It is filled in the the #calculate_table
* method, called from the constructor.
*/
unsigned short table[256];
/**
* The calculate_table method is called by the constructor to fill
* in the #table instance variable.
*/
void calculate_table(void);
/**
* The updcrc method is to add another byte of data to the running
* CRC state. It is called by the #next and next_buf methods.
*/
inline unsigned short updcrc(unsigned char c, unsigned short state) const;
};
};
#endif // SRECORD_CRC16_H
|