1 unit crcm_cat;
2 
3 {Catalogue of "Rocksoft^tm Model" parameters}
4 
5 
6 interface
7 
8 
9 (*************************************************************************
10 
11  DESCRIPTION     :  Catalogue of "Rocksoft^tm Model" parameters
12 
13  REQUIREMENTS    :  TP5-7, D1-D7/D9-D10/D12/D17-D18/D25S, FPC, VP
14 
15  EXTERNAL DATA   :  ---
16 
17  MEMORY USAGE    :  ---
18 
19  DISPLAY MODE    :  ---
20 
21  REFERENCES      :  [1] Ross Williams' public domain C sources crcmodel.c, crcmodel.h
22                         in "A Painless Guide to CRC Error Detection Algorithms"
23                         http://www.ross.net/crc/download/crc_v3.txt
24                     [2] Greg Cook's Catalogue of Parameterised CRC Algorithms
25                         http://reveng.sourceforge.net/crc-catalogue/
26                     [3] Thomas Pircher's PYCRC
27                         http://www.tty1.net/pycrc/crc-models.html
28                     [4] Danjel McGougan's Universal_crc
29                         http://mcgougan.se/universal_crc/
30 
31 
32  Version  Date      Author      Modification
33  -------  --------  -------     ------------------------------------------
34  0.10     11.07.08  W.Ehrhardt  From crcmodel: CRC32_Zip, CRC16_CCITT, CRC24_PGP
35  0.11     11.07.08  we          Add Greg Cook's catalogue
36  0.12     11.07.08  we          Changed CRC8_ICODE.check to $7E, calculated with [4]
37  0.13     12.07.08  we          Additional parameters from pycrc catalogue
38  0.14     12.07.08  we          Added alias descriptions
39  0.15     01.12.08  we          8 new parameter records from [2]
40  0.16     25.04.09  we          Added CRC-10, CRC-16/CCITT from [2]
41  0.17     04.06.09  we          Added CRC-5/ITU, CRC-32/Q  from [2]
42  0.18     01.10.09  we          CRC-8/ITU, CRC-8/MAXIM, CRC-16/MAXIM, CRC-16/T10-DIF from [2]
43  0.19     13.03.10  we          Added ten new parameter records from [2]
44  0.20     09.12.13  we          Added 12 new parameter records from [2], split CRC6_DARC/A
45  0.21     16.08.15  we          Removed $ifdef DLL / stdcall
46  0.22     04.05.17  we          Added 31 new parameter records from [2]
47 **************************************************************************)
48 
49 (*-------------------------------------------------------------------------
50  (C) Copyright 2008-2017 Wolfgang Ehrhardt
51 
52  This software is provided 'as-is', without any express or implied warranty.
53  In no event will the authors be held liable for any damages arising from
54  the use of this software.
55 
56  Permission is granted to anyone to use this software for any purpose,
57  including commercial applications, and to alter it and redistribute it
58  freely, subject to the following restrictions:
59 
60  1. The origin of this software must not be misrepresented; you must not
61     claim that you wrote the original software. If you use this software in
62     a product, an acknowledgment in the product documentation would be
63     appreciated but is not required.
64 
65  2. Altered source versions must be plainly marked as such, and must not be
66     misrepresented as being the original software.
67 
68  3. This notice may not be removed or altered from any source distribution.
69 ----------------------------------------------------------------------------*)
70 
71 uses
72  crcmodel;
73 
74 {---------------------------------------------------------------------------}
75 {---------------------------------------------------------------------------}
76 
77 const
78          CRC3_GSM: TCRCParam = (poly   : $3;         {V0.22, [2]}
79                                 init   : $0;
80                                 xorout : $7;
81                                 check  : $4;
82                                 width  : 3;
83                                 refin  : false;
84                                 refout : false;
85                                 name   : 'CRC-3/GSM');
86 
87 const
88         CRC3_ROHC: TCRCParam = (poly   : $3;         {V0.19, [2]}
89                                 init   : $7;
90                                 xorout : $0;
91                                 check  : $6;
92                                 width  : 3;
93                                 refin  : true;
94                                 refout : true;
95                                 name   : 'CRC-3/ROHC');
96 
97 const
98   CRC4_INTERLAKEN: TCRCParam = (poly   : $3;         {V0.22, [2]}
99                                 init   : $f;
100                                 xorout : $f;
101                                 check  : $b;
102                                 width  : 4;
103                                 refin  : false;
104                                 refout : false;
105                                 name   : 'CRC-4/INTERLAKEN');
106 
107 const
108          CRC4_ITU: TCRCParam = (poly   : $3;         {V0.15, [2]}
109                                 init   : $0;
110                                 xorout : $0;
111                                 check  : $7;
112                                 width  : 4;
113                                 refin  : true;
114                                 refout : true;
115                                 name   : 'CRC-4/ITU');
116 
117 const
118          CRC5_EPC: TCRCParam = (poly   : $09;        {V0.17, [2]}
119                                 Init   : $09;
120                                 XorOut : 00;
121                                 Check  : 00;
122                                 Width  : 5;
123                                 RefIn  : False;
124                                 RefOut : False;
125                                 name   : 'CRC-5/EPC');
126 
127 const
128          CRC5_ITU: TCRCParam = (poly   : $15;        {V0.15, [2]}
129                                 init   : $0;
130                                 xorout : $0;
131                                 check  : $07;
132                                 width  : 5;
133                                 refin  : true;
134                                 refout : true;
135                                 name   : 'CRC-5/ITU');
136 
137 const
138          CRC5_USB: TCRCParam = (poly   : $05;
139                                 init   : $1F;
140                                 xorout : $1F;
141                                 check  : $19;
142                                 width  : 5;
143                                 refin  : true;
144                                 refout : true;
145                                 name   : 'CRC-5/USB');
146 
147 const
148          CRC6_ITU: TCRCParam = (poly   : $03;        {V0.15, [2]}
149                                 init   : $00;
150                                 xorout : $00;
151                                 check  : $06;
152                                 width  : 6;
153                                 refin  : true;
154                                 refout : true;
155                                 name   : 'CRC-6/ITU');
156 
157 const
158    CRC6_CDMA2000A: TCRCParam = (poly   : $27;        {V0.20, [2]}
159                                 init   : $3f;
160                                 xorout : $00;
161                                 check  : $0d;
162                                 width  : 6;
163                                 refin  : false;
164                                 refout : false;
165                                 name   : 'CRC-6/CDMA2000-A');
166 
167 const
168    CRC6_CDMA2000B: TCRCParam = (poly   : $07;        {V0.20, [2]}
169                                 init   : $3f;
170                                 xorout : $00;
171                                 check  : $3b;
172                                 width  : 6;
173                                 refin  : false;
174                                 refout : false;
175                                 name   : 'CRC-6/CDMA2000-B');
176 
177 const
178         CRC6_DARC: TCRCParam = (poly   : $19;        {V0.20, [2]}
179                                 init   : $00;
180                                 xorout : $00;
181                                 check  : $26;
182                                 width  : 6;
183                                 refin  : true;
184                                 refout : true;
185                                 name   : 'CRC-6/DARC');
186 
187 const
188        CRC6_DARCA: TCRCParam = (poly   : $19;        {V0.20, renamed to DARC-A}
189                                 init   : $00;
190                                 xorout : $00;
191                                 check  : $19;
192                                 width  : 6;
193                                 refin  : true;
194                                 refout : false;
195                                 name   : 'CRC-6/DARC-A');
196 const
197          CRC6_GSM: TCRCParam = (poly   : $2f;        {V0.22, [2]}
198                                 init   : $00;
199                                 xorout : $3f;
200                                 check  : $13;
201                                 width  : 6;
202                                 refin  : false;
203                                 refout : false;
204                                 name   : 'CRC-6/GSM');
205 
206 
207 const
208              CRC7: TCRCParam = (poly   : $09;        {V0.15, [2]}
209                                 init   : $00;
210                                 xorout : $00;
211                                 check  : $75;
212                                 width  : 7;
213                                 refin  : false;
214                                 refout : false;
215                                 name   : 'CRC-7');
216 
217 const
218         CRC7_ROHC: TCRCParam = (poly   : $4F;        {V0.19, [2]}
219                                 init   : $7F;
220                                 xorout : $0;
221                                 check  : $53;
222                                 width  : 7;
223                                 refin  : true;
224                                 refout : true;
225                                 name   : 'CRC-7/ROHC');
226 const
227         CRC7_UMTS: TCRCParam = (poly   : $45;        {V0.22, [2]}
228                                 init   : $00;
229                                 xorout : $00;
230                                 check  : $61;
231                                 width  : 7;
232                                 refin  : false;
233                                 refout : false;
234                                 name   : 'CRC-7/UMTS');
235 const
236              CRC8: TCRCParam = (poly   : $07;
237                                 init   : $00;
238                                 xorout : $00;
239                                 check  : $F4;
240                                 width  : 8;
241                                 refin  : false;
242                                 refout : false;
243                                 name   : 'CRC-8');
244 
245 const
246      CRC8_AUTOSAR: TCRCParam = (poly   : $2f;        {V0.22, [2]}
247                                 init   : $ff;
248                                 xorout : $ff;
249                                 check  : $df;
250                                 width  : 8;
251                                 refin  : false;
252                                 refout : false;
253                                 name   : 'CRC-8/AUTOSAR');
254 
255 const
256     CRC8_CDMA2000: TCRCParam = (poly   : $9b;        {V0.20, [2]}
257                                 init   : $ff;
258                                 xorout : $00;
259                                 check  : $da;
260                                 width  : 8;
261                                 refin  : false;
262                                 refout : false;
263                                 name   : 'CRC-8/CDMA2000');
264 
265 const
266         CRC8_DARC: TCRCParam = (poly   : $39;        {V0.19, [2]}
267                                 init   : $00;
268                                 xorout : $00;
269                                 check  : $15;
270                                 width  : 8;
271                                 refin  : true;
272                                 refout : true;
273                                 name   : 'CRC-8/DARC');
274 const
275       CRC8_DVB_S2: TCRCParam = (poly   : $d5;        {V0.22, [2]}
276                                 init   : $00;
277                                 xorout : $00;
278                                 check  : $bc;
279                                 width  : 8;
280                                 refin  : false;
281                                 refout : false;
282                                 name   : 'CRC-8/DVB-S2');
283 
284 
285 
286 const
287          CRC8_EBU: TCRCParam = (poly   : $1d;        {V0.20, [2]}
288                                 init   : $ff;
289                                 xorout : $00;
290                                 check  : $97;
291                                 width  : 8;
292                                 refin  : true;
293                                 refout : true;
294                                 name   : 'CRC-8/EBU');
295 const
296        CRC8_GSM_A: TCRCParam = (poly   : $1d;        {V0.22, [2]}
297                                 init   : $00;
298                                 xorout : $00;
299                                 check  : $37;
300                                 width  : 8;
301                                 refin  : false;
302                                 refout : false;
303                                 name   : 'CRC-8/GSM-A');
304 const
305        CRC8_GSM_B: TCRCParam = (poly   : $49;        {V0.22, [2]}
306                                 init   : $00;
307                                 xorout : $ff;
308                                 check  : $94;
309                                 width  : 8;
310                                 refin  : false;
311                                 refout : false;
312                                 name   : 'CRC-8/GSM-B');
313 
314 const
315        CRC8_ICODE: TCRCParam = (poly   : $1D;
316                                 init   : $FD;
317                                 xorout : $00;
318                                 check  : $7E;        {calculated with [4]}
319                                 width  : 8;
320                                 refin  : false;
321                                 refout : false;
322                                 name   : 'CRC-8/I-CODE');
323 
324 const
325          CRC8_ITU: TCRCParam = (poly   : $07;        {V0.18, [2]}
326                                 init   : $00;
327                                 xorout : $55;
328                                 check  : $A1;
329                                 width  : 8;
330                                 refin  : false;
331                                 refout : false;
332                                 name   : 'CRC-8/ITU');
333 
334 const
335          CRC8_LTE: TCRCParam = (poly   : $9b;        {V0.22, [2]}
336                                 init   : $00;
337                                 xorout : $00;
338                                 check  : $ea;
339                                 width  : 8;
340                                 refin  : false;
341                                 refout : false;
342                                 name   : 'CRC-8/LTE');
343 const
344        CRC8_MAXIM: TCRCParam = (poly   : $31;        {V0.18, [2]}
345                                 init   : $00;
346                                 xorout : $00;
347                                 check  : $A1;
348                                 width  : 8;
349                                 refin  : true;
350                                 refout : true;
351                                 name   : 'CRC-8/MAXIM');
352                                {Alias  : 'CRC-8/Dallas-1-Wire'}   {Ref: [3]}
353 const
354   CRC8_OPENSAFETY: TCRCParam = (poly   : $2f;        {V0.22, [2]}
355                                 init   : $00;
356                                 xorout : $00;
357                                 check  : $3e;
358                                 width  : 8;
359                                 refin  : false;
360                                 refout : false;
361                                 name   : 'CRC-8/OPENSAFETY');
362 
363 
364 const
365         CRC8_ROHC: TCRCParam = (poly   : $07;        {V0.19, [2]}
366                                 init   : $FF;
367                                 xorout : $0;
368                                 check  : $D0;
369                                 width  : 8;
370                                 refin  : true;
371                                 refout : true;
372                                 name   : 'CRC-8/ROHC');
373 const
374    CRC8_SAE_J1850: TCRCParam = (poly   : $1d;        {V0.22, [2]}
375                                 init   : $ff;
376                                 xorout : $ff;
377                                 check  : $4b;
378                                 width  : 8;
379                                 refin  : false;
380                                 refout : false;
381                                 name   : 'CRC-8/SAE-J1850');
382 
383 const
384        CRC8_WCDMA: TCRCParam = (poly   : $9B;        {V0.19, [2]}
385                                 init   : $00;
386                                 xorout : $00;
387                                 check  : $25;
388                                 width  : 8;
389                                 refin  : true;
390                                 refout : true;
391                                 name   : 'CRC-8/WCDMA');
392 
393 const
394             CRC10: TCRCParam = (poly   : $233;       {V0.16, [2]}
395                                 init   : $000;
396                                 xorout : $000;
397                                 check  : $199;
398                                 width  : 10;
399                                 refin  : false;
400                                 refout : false;
401                                 name   : 'CRC-10');
402 
403 const
404    CRC10_CDMA2000: TCRCParam = (poly   : $3d9;       {V0.22, [2]}
405                                 init   : $3ff;
406                                 xorout : $000;
407                                 check  : $233;
408                                 width  : 10;
409                                 refin  : false;
410                                 refout : false;
411                                 name   : 'CRC-10/CDMA2000');
412 const
413         CRC10_GSM: TCRCParam = (poly   : $175;       {V0.22, [2]}
414                                 init   : $000;
415                                 xorout : $3ff;
416                                 check  : $12a;
417                                 width  : 10;
418                                 refin  : false;
419                                 refout : false;
420                                 name   : 'CRC-10/GSM');
421 
422 const
423             CRC11: TCRCParam = (poly   : $385;
424                                 init   : $01A;
425                                 xorout : $000;
426                                 check  : $5A3;
427                                 width  : 11;
428                                 refin  : false;
429                                 refout : false;
430                                 name   : 'CRC-11');
431 
432 const
433        CRC11_UMTS: TCRCParam = (poly   : $307;       {V0.22, [2]}
434                                 init   : $000;
435                                 xorout : $000;
436                                 check  : $061;
437                                 width  : 11;
438                                 refin  : false;
439                                 refout : false;
440                                 name   : 'CRC-11/UMTS');
441 const
442             CRC12: TCRCParam = (poly   : $80F;       {V0.19, [2]}
443                                 init   : $000;
444                                 xorout : $000;
445                                 check  : $DAF;
446                                 width  : 12;
447                                 refin  : false;
448                                 refout : true;
449                                 name   : 'CRC-12');
450 
451 const
452    CRC12_CDMA2000: TCRCParam = (poly   : $f13;       {V0.20, [2]}
453                                 init   : $fff;
454                                 xorout : $000;
455                                 check  : $d4d;
456                                 width  : 12;
457                                 refin  : false;
458                                 refout : false;
459                                 name   : 'CRC-12/CDMA2000');
460 
461 const
462        CRC12_DECT: TCRCParam = (poly   : $80f;       {V0.20, [2]}
463                                 init   : $000;
464                                 xorout : $000;
465                                 check  : $f5b;
466                                 width  : 12;
467                                 refin  : false;
468                                 refout : false;
469                                 name   : 'CRC-12/DECT');
470 const
471         CRC12_GSM: TCRCParam = (poly   : $d31;       {V0.22, [2]}
472                                 init   : $000;
473                                 xorout : $fff;
474                                 check  : $b34;
475                                 width  : 12;
476                                 refin  : false;
477                                 refout : false;
478                                 name   : 'CRC-12/GSM');
479 const
480        CRC12_UMTS: TCRCParam = (poly   : $80f;       {V0.22, [2]}
481                                 init   : $000;
482                                 xorout : $000;
483                                 check  : $daf;
484                                 width  : 12;
485                                 refin  : false;
486                                 refout : true;
487                                 name   : 'CRC-12/UMTS');
488 const
489         CRC13_BBC: TCRCParam = (poly   : $1cf5;      {V0.20, [2]}
490                                 init   : $0000;
491                                 xorout : $0000;
492                                 check  : $04fa;
493                                 width  : 13;
494                                 refin  : false;
495                                 refout : false;
496                                 name   : 'CRC-13/BBC');
497 
498 const
499        CRC14_DARC: TCRCParam = (poly   : $0805;      {V0.19, [2]}
500                                 init   : $0000;
501                                 xorout : $0000;
502                                 check  : $082D;
503                                 width  : 14;
504                                 refin  : true;
505                                 refout : true;
506                                 name   : 'CRC-14/DARC');
507 const
508         CRC14_GSM: TCRCParam = (poly   : $202d;      {V0.22, [2]}
509                                 init   : $0000;
510                                 xorout : $3fff;
511                                 check  : $30ae;
512                                 width  : 14;
513                                 refin  : false;
514                                 refout : false;
515                                 name   : 'CRC-14/GSM');
516 
517 const
518             CRC15: TCRCParam = (poly   : $4599;
519                                 init   : $0000;
520                                 xorout : $0000;
521                                 check  : $059E;
522                                 width  : 15;
523                                 refin  : false;
524                                 refout : false;
525                                 name   : 'CRC-15');
526 
527 const
528     CRC15_MPT1327: TCRCParam = (poly   : $6815;      {V0.20, [2]}
529                                 init   : $0000;
530                                 xorout : $0001;
531                                 check  : $2566;
532                                 width  : 15;
533                                 refin  : false;
534                                 refout : false;
535                                 name   : 'CRC-15/MPT1327');
536 
537 const
538        CRC16_ARC:  TCRCParam = (poly   : $8005;
539                                 init   : $0000;
540                                 xorout : $0000;
541                                 check  : $BB3D;
542                                 width  : 16;
543                                 refin  : true;
544                                 refout : true;
545                                 name   : 'CRC-16/ARC');
546                                {alias  : 'CRC-16/LHA'}
547 
548 const
549        CRC16_ATOM: TCRCParam = (poly   : $002D;
550                                 init   : $0000;
551                                 xorout : $0000;
552                                 check  : $4287;
553                                 width  : 16;
554                                 refin  : true;
555                                 refout : true;
556                                 name   : 'CRC-16/ATOM');
557 
558 const
559           CRC16_A: TCRCParam = (poly   : $1021;      {V0.22, [2]}
560                                 init   : $c6c6;
561                                 xorout : $0000;
562                                 check  : $bf05;
563                                 width  : 16;
564                                 refin  : true;
565                                 refout : true;
566                                 name   : 'CRC-A');
567 const
568   CRC16_AUG2_CITT: TCRCParam = (poly   : $1021;
569                                 init   : $84C0;
570                                 xorout : $0000;
571                                 check  : $19CF;
572                                 width  : 16;
573                                 refin  : false;
574                                 refout : false;
575                                 name   : 'CRC-16/AUG-2-CCITT');
576                                {alias  : 'CRC-16/SPI-FUJITSU'}
577                                {alias  : 'CRC-16/AUG-2-CITT')}
578 
579 const
580    CRC16_AUG_CITT: TCRCParam = (poly   : $1021;
581                                 init   : $1D0F;
582                                 xorout : $0000;
583                                 check  : $E5CC;
584                                 width  : 16;
585                                 refin  : false;
586                                 refout : false;
587                                 name   : 'CRC-16/AUG-CCITT');
588                                {alias  : 'CRC-16/AUG-CITT')}
589 
590 const
591     CRC16_BT_CHIP: TCRCParam = (poly   : $1021;
592                                 init   : $FFFF;
593                                 xorout : $0000;
594                                 check  : $89F6;
595                                 width  : 16;
596                                 refin  : true;
597                                 refout : false;
598                                 name   : 'CRC-16/BT-CHIP');
599 
600 const
601     CRC16_BUYPASS: TCRCParam = (poly   : $8005;
602                                 init   : $0000;
603                                 xorout : $0000;
604                                 check  : $FEE8;
605                                 width  : 16;
606                                 refin  : false;
607                                 refout : false;
608                                 name   : 'CRC-16/BUYPASS');
609 
610 const
611    CRC16_CDMA2000: TCRCParam = (poly   : $c867;      {V0.20, [2]}
612                                 init   : $ffff;
613                                 xorout : $0000;
614                                 check  : $4c06;
615                                 width  : 16;
616                                 refin  : false;
617                                 refout : false;
618                                 name   : 'CRC-16/CDMA2000');
619 
620 const
621        CRC16_CITT: TCRCParam = (poly   : $1021;
622                                 init   : $FFFF;
623                                 xorout : $0000;
624                                 check  : $29B1;
625                                 width  : 16;
626                                 refin  : false;
627                                 refout : false;
628                                 name   : 'CRC-16/CCITT');       {V0.16}
629                                {alias  : 'CRC-16/CCITT-FALSE'}
630 const
631         CRC16_CMS: TCRCParam = (poly   : $8005;      {V0.22, [2]}
632                                 init   : $ffff;
633                                 xorout : $0000;
634                                 check  : $aee7;
635                                 width  : 16;
636                                 refin  : false;
637                                 refout : false;
638                                 name   : 'CRC-16/CMS');
639 const
640       CRC16_DECTX: TCRCParam = (poly   : $0589;      {V0.20, [2]}
641                                 init   : $0000;
642                                 xorout : $0000;
643                                 check  : $007f;
644                                 width  : 16;
645                                 refin  : false;
646                                 refout : false;
647                                 name   : 'CRC-16/DECT-X');
648 
649 const
650      CRC16_DDS110: TCRCParam = (poly   : $8005;      {V0.19, [2]}
651                                 init   : $800D;
652                                 xorout : $0000;
653                                 check  : $9ECF;
654                                 width  : 16;
655                                 refin  : false;
656                                 refout : false;
657                                 name   : 'CRC-16/DDS-110');
658 
659 const
660         CRC16_DNP: TCRCParam = (poly   : $3D65;
661                                 init   : $0000;
662                                 xorout : $FFFF;
663                                 check  : $EA82;
664                                 Width  : 16;
665                                 RefIn  : true;
666                                 RefOut : true;
667                                 Name   : 'CRC-16/DNP');
668 
669 const
670    CRC16_EN_13757: TCRCParam = (poly   : $3D65;      {V0.15, [2]}
671                                 init   : $0000;
672                                 xorout : $FFFF;
673                                 check  : $C2B7;
674                                 width  : 16;
675                                 refin  : false;
676                                 refout : false;
677                                 name   : 'CRC-16/EN-13757');
678 
679 const
680     CRC16_GENIBUS: TCRCParam = (poly   : $1021;      {V0.22, [2]}
681                                 init   : $ffff;
682                                 xorout : $ffff;
683                                 check  : $d64e;
684                                 width  : 16;
685                                 refin  : false;
686                                 refout : false;
687                                 name   : 'CRC-16/GENIBUS');
688 const
689         CRC16_GSM: TCRCParam = (poly   : $1021;      {V0.22, [2]}
690                                 init   : $0000;
691                                 xorout : $ffff;
692                                 check  : $ce3c;
693                                 width  : 16;
694                                 refin  : false;
695                                 refout : false;
696                                 name   : 'CRC-16/GSM');
697 const
698       CRC16_ICODE: TCRCParam = (poly   : $1021;
699                                 init   : $FFFF;
700                                 xorout : $FFFF;
701                                 check  : $D64E;
702                                 width  : 16;
703                                 refin  : false;
704                                 refout : false;
705                                 name   : 'CRC-16/I-CODE');
706                                {alias  :  CRC-16/GENIBUS}
707 
708 const
709      CRC16_KERMIT: TCRCParam = (poly   : $1021;
710                                 init   : $0000;
711                                 xorout : $0000;
712                                 check  : $2189;
713                                 width  : 16;
714                                 refin  : true;
715                                 refout : true;
716                                 name   : 'CRC-16/KERMIT');
717                                {alias  : 'CRC-16/CCITT-TRUE'}
718 const
719      CRC16_LJ1200: TCRCParam = (poly   : $6f63;      {V0.22, [2]}
720                                 init   : $0000;
721                                 xorout : $0000;
722                                 check  : $bdf4;
723                                 width  : 16;
724                                 refin  : false;
725                                 refout : false;
726                                 name   : 'CRC-16/LJ1200');
727 
728 const
729       CRC16_MAXIM: TCRCParam = (poly   : $8005;     {V0.18, [2]}
730                                 init   : $0000;
731                                 xorout : $FFFF;
732                                 check  : $44C2;
733                                 width  : 16;
734                                 refin  : true;
735                                 refout : true;
736                                 name   : 'CRC-16/MAXIM');
737 const
738     CRC16_MCRF4XX: TCRCParam = (poly   : $1021;
739                                 init   : $FFFF;
740                                 xorout : $0000;
741                                 check  : $6F91;
742                                 width  : 16;
743                                 refin  : true;
744                                 refout : true;
745                                 name   : 'CRC-16/MCRF4XX');
746 
747 const
748      CRC16_MODBUS: TCRCParam = (poly   : $8005;
749                                 init   : $FFFF;
750                                 xorout : $0000;
751                                 check  : $4B37;
752                                 width  : 16;
753                                 refin  : true;
754                                 refout : true;
755                                 name   : 'CRC-16/MODBUS');
756 
757 const
758 CRC16_OPENSAFETY_A: TCRCParam= (poly   : $5935;      {V0.22, [2]}
759                                 init   : $0000;
760                                 xorout : $0000;
761                                 check  : $5d38;
762                                 width  : 16;
763                                 refin  : false;
764                                 refout : false;
765                                 name   : 'CRC-16/OPENSAFETY-A');
766 const
767 CRC16_OPENSAFETY_B: TCRCParam= (poly   : $755b;      {V0.22, [2]}
768                                 init   : $0000;
769                                 xorout : $0000;
770                                 check  : $20fe;
771                                 width  : 16;
772                                 refin  : false;
773                                 refout : false;
774                                 name   : 'CRC-16/OPENSAFETY-B');
775 
776 const
777    CRC16_PROFIBUS: TCRCParam = (poly   : $1dcf;      {V0.22, [2]}
778                                 init   : $ffff;
779                                 xorout : $ffff;
780                                 check  : $a819;
781                                 width  : 16;
782                                 refin  : false;
783                                 refout : false;
784                                 name   : 'CRC-16/PROFIBUS');
785 const
786           CRC16_R: TCRCParam = (poly   : $0589;      {Ref: [3]}
787                                 init   : $0000;
788                                 xorout : $0001;
789                                 check  : $007E;
790                                 width  : 16;
791                                 refin  : false;
792                                 refout : false;
793                                 name   : 'CRC-16/R');
794 
795 const
796      CRC16_RIELLO: TCRCParam = (poly   : $1021;      {V0.16, [2]}
797                                 init   : $B2AA;
798                                 xorout : $0000;
799                                 check  : $63D0;
800                                 width  : 16;
801                                 refin  : true;
802                                 refout : true;
803                                 name   : 'CRC-16/RIELLO');
804 
805 const
806     CRC16_T10_DIF: TCRCParam = (poly   : $8BB7;      {V0.18, [2]}
807                                 init   : $0000;
808                                 xorout : $0000;
809                                 check  : $D0DB;
810                                 width  : 16;
811                                 refin  : false;
812                                 refout : false;
813                                 name   : 'CRC-16/T10-DIF');
814 
815 const
816    CRC16_TELEDISK: TCRCParam = (poly   : $A097;      {V0.19, [2]}
817                                 init   : $0000;
818                                 xorout : $0000;
819                                 check  : $0FB3;
820                                 width  : 16;
821                                 refin  : false;
822                                 refout : false;
823                                 name   : 'CRC-16/TELEDISK');
824 
825 const
826    CRC16_TMS37157: TCRCParam = (poly   : $1021;      {V0.20, [2]}
827                                 init   : $89ec;
828                                 xorout : $0000;
829                                 check  : $26b1;
830                                 width  : 16;
831                                 refin  : true;
832                                 refout : true;
833                                 name   : 'CRC-16/TMS37157');
834 
835 const
836         CRC16_USB: TCRCParam = (poly   : $8005;
837                                 init   : $FFFF;
838                                 xorout : $FFFF;
839                                 check  : $B4C8;
840                                 width  : 16;
841                                 refin  : true;
842                                 refout : true;
843                                 name   : 'CRC-16/USB');
844 const
845         CRC16_X25: TCRCParam = (poly   : $1021;
846                                 init   : $FFFF;
847                                 xorout : $FFFF;
848                                 check  : $906E;
849                                 width  : 16;
850                                 refin  : true;
851                                 refout : true;
852                                 name   : 'CRC-16/X-25');
853                                {alias  : 'CRC-16/IBM-SDLC'}
854                                {alias  : 'CRC-16/ISO-HDLC'}
855 
856 const
857     CRC16_XKERMIT: TCRCParam = (poly   : $8408;
858                                 init   : $0000;
859                                 xorout : $0000;
860                                 check  : $0C73;
861                                 width  : 16;
862                                 refin  : true;
863                                 refout : true;
864                                 name   : 'CRC-16/X-KERMIT');
865                                {alias  : 'X-XMODEM'}
866 
867 const
868      CRC16_ZMODEM: TCRCParam = (poly   : $1021;
869                                 init   : $0000;
870                                 xorout : $0000;
871                                 check  : $31C3;
872                                 width  : 16;
873                                 refin  : false;
874                                 refout : false;
875                                 name   : 'CRC-16/ZMODEM');
876                                {alias  : 'XMODEM'}
877                                {alias  : 'CRC-16/ACORN'}
878 const
879         CRC24_BLE: TCRCParam = (poly   : $00065b;    {V0.22, [2]}
880                                 init   : $555555;
881                                 xorout : $000000;
882                                 check  : $c25a56;
883                                 width  : 24;
884                                 refin  : true;
885                                 refout : true;
886                                 name   : 'CRC-24/BLE');
887 
888 const
889  CRC24_INTERLAKEN: TCRCParam = (poly   : $328b63;    {V0.22, [2]}
890                                 init   : $ffffff;
891                                 xorout : $ffffff;
892                                 check  : $b4f3e6;
893                                 width  : 24;
894                                 refin  : false;
895                                 refout : false;
896                                 name   : 'CRC-24/INTERLAKEN');
897 
898 const
899       CRC24_LTE_B: TCRCParam = (poly   : $800063;    {V0.22, [2]}
900                                 init   : $000000;
901                                 xorout : $000000;
902                                 check  : $23ef52;
903                                 width  : 24;
904                                 refin  : false;
905                                 refout : false;
906                                 name   : 'CRC-24/LTE-B');
907 
908 const
909       CRC24_LTE_A: TCRCParam = (poly   : $864cfb;    {V0.22, [2]}
910                                 init   : $000000;
911                                 xorout : $000000;
912                                 check  : $cde703;
913                                 width  : 24;
914                                 refin  : false;
915                                 refout : false;
916                                 name   : 'CRC-24/LTE-A');
917 
918 const
919        CRC24_PGP:  TCRCParam = (poly   : $864CFB;
920                                 init   : $B704CE;
921                                 xorout : 0;
922                                 check  : $21CF02;
923                                 width  : 24;
924                                 refin  : false;
925                                 refout : false;
926                                 name   : 'CRC24/PGP');
927                                {alias  : 'CRC-24'}
928                                {alias  : 'CRC-24/OPENPGP'}
929 
930 const
931    CRC24_FLEXRAYA: TCRCParam = (poly   : $5D6DCB;
932                                 init   : $FEDCBA;
933                                 xorout : $000000;
934                                 check  : $7979BD;
935                                 width  : 24;
936                                 refin  : false;
937                                 refout : false;
938                                 name   : 'CRC-24/FLEXRAY-A');
939 
940 const
941    CRC24_FLEXRAYB: TCRCParam = (poly   : $5D6DCB;
942                                 init   : $ABCDEF;
943                                 xorout : $000000;
944                                 check  : $1F23B8;
945                                 width  : 24;
946                                 refin  : false;
947                                 refout : false;
948                                 name   : 'CRC-24/FLEXRAY-B');
949 const
950        CRC30_CDMA: TCRCParam = (poly   : $2030b9c7;  {V0.22, [2]}
951                                 init   : $3fffffff;
952                                 xorout : $3fffffff;
953                                 check  : $04c34abf;
954                                 width  : 30;
955                                 refin  : false;
956                                 refout : false;
957                                 name   : 'CRC-30/CDMA');
958 const
959     CRC31_PHILIPS: TCRCParam = (poly   : $04c11db7;  {V0.20, [2]}
960                                 init   : $7fffffff;
961                                 xorout : $7fffffff;
962                                 check  : $0ce9e46c;
963                                 width  : 31;
964                                 refin  : false;
965                                 refout : false;
966                                 name   : 'CRC-31/PHILIPS');
967 
968 {Note: longint typecasts avoid some compiler warnings/errors}
969 const
970     CRC32_AUTOSAR: TCRCParam = (poly   : longint($f4acfb13);  {V0.22, [2]}
971                                 init   : longint($ffffffff);
972                                 xorout : longint($ffffffff);
973                                 check  : $1697d06a;
974                                 width  : 32;
975                                 refin  : true;
976                                 refout : true;
977                                 name   : 'CRC-32/AUTOSAR');
978 
979 const
980         CRC32_Zip: TCRCParam = (poly   : longint($04C11DB7);
981                                 init   : longint($FFFFFFFF);
982                                 xorout : longint($FFFFFFFF);
983                                 check  : longint($CBF43926);
984                                 width  : 32;
985                                 refin  : true;
986                                 refout : true;
987                                 name   : 'CRC32/Zip');
988                                {alias  : 'CRC-32'}
989                                {alias  : 'CRC-32/ADCCP'}
990                                {alias  : 'PKZIP'}
991 
992 const
993       CRC32_BZIP2: TCRCParam = (poly   : longint($04C11DB7);  {V0.15, [2]}
994                                 init   : longint($FFFFFFFF);
995                                 xorout : longint($FFFFFFFF);
996                                 check  : longint($FC891918);
997                                 width  : 32;
998                                 refin  : false;
999                                 refout : false;
1000                                 name   : 'CRC-32/BZIP2');
1001 
1002 const
1003           CRC32_C: TCRCParam = (poly   : longint($1EDC6F41);
1004                                 init   : longint($FFFFFFFF);
1005                                 xorout : longint($FFFFFFFF);
1006                                 check  : longint($E3069283);
1007                                 width  : 32;
1008                                 refin  : true;
1009                                 refout : true;
1010                                 name   : 'CRC32/C');
1011                                {alias  : 'CRC-32/ISCSI'}
1012                                {alias  : 'CRC-32/CASTAGNOLI'}
1013 
1014 const
1015           CRC32_D: TCRCParam = (poly   : longint($A833982B);  {V0.15, [2]}
1016                                 init   : longint($FFFFFFFF);
1017                                 xorout : longint($FFFFFFFF);
1018                                 check  : longint($87315576);
1019                                 width  : 32;
1020                                 refin  : true;
1021                                 refout : true;
1022                                 name   : 'CRC-32/D');
1023 
1024 const
1025      CRC32_JAMCRC: TCRCParam = (poly   : longint($04C11DB7);
1026                                 init   : longint($FFFFFFFF);
1027                                 xorout : longint($00000000);
1028                                 check  : longint($340BC6D9);
1029                                 width  : 32;
1030                                 refin  : true;
1031                                 refout : true;
1032                                 name   : 'CRC-32/JAMCRC');
1033 
1034 const
1035       CRC32_MPEG2: TCRCParam = (poly   : longint($04C11DB7);  {V0.15, [2]}
1036                                 init   : longint($FFFFFFFF);
1037                                 xorout : longint($00000000);
1038                                 check  : longint($0376E6E7);
1039                                 width  : 32;
1040                                 refin  : false;
1041                                 refout : false;
1042                                 name   : 'CRC-32/MPEG-2');
1043 
1044 const
1045       CRC32_POSIX: TCRCParam = (poly   : longint($04C11DB7);
1046                                 init   : longint($00000000);
1047                                 xorout : longint($FFFFFFFF);
1048                                 check  : longint($765E7680);
1049                                 width  : 32;
1050                                 refin  : false;
1051                                 refout : false;
1052                                 name   : 'CRC-32/POSIX');
1053                                {alias  : 'CKSUM'}
1054 
1055 const
1056           CRC32_Q: TCRCParam = (poly   : longint($814141AB);  {V0.17, [2]}
1057                                 Init   : longint($00000000);
1058                                 XorOut : longint($00000000);
1059                                 Check  : longint($3010BF7F);
1060                                 Width  : 32;
1061                                 RefIn  : False;
1062                                 RefOut : False;
1063                                 Name   : 'CRC-32/Q');
1064 
1065 const
1066        CRC32_XFER: TCRCParam = (poly   : longint($000000AF);
1067                                 init   : longint($00000000);
1068                                 xorout : longint($00000000);
1069                                 check  : longint($BD0BE338);
1070                                 width  : 32;
1071                                 refin  : false;
1072                                 refout : false;
1073                                 name   : 'CRC-32/XFER');
1074 
1075 
1076 implementation
1077 
1078 end.
1079