Struggling to port Bitwise CRC to Xojo

[code]unsigned char crc_table1[0x100] =
{0x00,0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x81,0x91,0xA1,0xB1,0xC1,0xD1,0xE1,0xF1,
0x12,0x02,0x32,0x22,0x52,0x42,0x72,0x62,0x93,0x83,0xB3,0xA3,0xD3,0xC3,0xF3,0xE3,
0x24,0x34,0x04,0x14,0x64,0x74,0x44,0x54,0xA5,0xB5,0x85,0x95,0xE5,0xF5,0xC5,0xD5,
0x36,0x26,0x16,0x06,0x76,0x66,0x56,0x46,0xB7,0xA7,0x97,0x87,0xF7,0xE7,0xD7,0xC7,
0x48,0x58,0x68,0x78,0x08,0x18,0x28,0x38,0xC9,0xD9,0xE9,0xF9,0x89,0x99,0xA9,0xB9,
0x5A,0x4A,0x7A,0x6A,0x1A,0x0A,0x3A,0x2A,0xDB,0xCB,0xFB,0xEB,0x9B,0x8B,0xBB,0xAB,
0x6C,0x7C,0x4C,0x5C,0x2C,0x3C,0x0C,0x1C,0xED,0xFD,0xCD,0xDD,0xAD,0xBD,0x8D,0x9D,
0x7E,0x6E,0x5E,0x4E,0x3E,0x2E,0x1E,0x0E,0xFF,0xEF,0xDF,0xCF,0xBF,0xAF,0x9F,0x8F,
0x91,0x81,0xB1,0xA1,0xD1,0xC1,0xF1,0xE1,0x10,0x00,0x30,0x20,0x50,0x40,0x70,0x60,
0x83,0x93,0xA3,0xB3,0xC3,0xD3,0xE3,0xF3,0x02,0x12,0x22,0x32,0x42,0x52,0x62,0x72,
0xB5,0xA5,0x95,0x85,0xF5,0xE5,0xD5,0xC5,0x34,0x24,0x14,0x04,0x74,0x64,0x54,0x44,
0xA7,0xB7,0x87,0x97,0xE7,0xF7,0xC7,0xD7,0x26,0x36,0x06,0x16,0x66,0x76,0x46,0x56,
0xD9,0xC9,0xF9,0xE9,0x99,0x89,0xB9,0xA9,0x58,0x48,0x78,0x68,0x18,0x08,0x38,0x28,
0xCB,0xDB,0xEB,0xFB,0x8B,0x9B,0xAB,0xBB,0x4A,0x5A,0x6A,0x7A,0x0A,0x1A,0x2A,0x3A,
0xFD,0xED,0xDD,0xCD,0xBD,0xAD,0x9D,0x8D,0x7C,0x6C,0x5C,0x4C,0x3C,0x2C,0x1C,0x0C,
0xEF,0xFF,0xCF,0xDF,0xAF,0xBF,0x8F,0x9F,0x6E,0x7E,0x4E,0x5E,0x2E,0x3E,0x0E,0x1E};

unsigned char crc_table2[0x100] =
{0x00,0x21,0x42,0x63,0x84,0xA5,0xC6,0xE7,0x08,0x29,0x4A,0x6B,0x8C,0xAD,0xCE,0xEF,
0x31,0x10,0x73,0x52,0xB5,0x94,0xF7,0xD6,0x39,0x18,0x7B,0x5A,0xBD,0x9C,0xFF,0xDE,
0x62,0x43,0x20,0x01,0xE6,0xC7,0xA4,0x85,0x6A,0x4B,0x28,0x09,0xEE,0xCF,0xAC,0x8D,
0x53,0x72,0x11,0x30,0xD7,0xF6,0x95,0xB4,0x5B,0x7A,0x19,0x38,0xDF,0xFE,0x9D,0xBC,
0xC4,0xE5,0x86,0xA7,0x40,0x61,0x02,0x23,0xCC,0xED,0x8E,0xAF,0x48,0x69,0x0A,0x2B,
0xF5,0xD4,0xB7,0x96,0x71,0x50,0x33,0x12,0xFD,0xDC,0xBF,0x9E,0x79,0x58,0x3B,0x1A,
0xA6,0x87,0xE4,0xC5,0x22,0x03,0x60,0x41,0xAE,0x8F,0xEC,0xCD,0x2A,0x0B,0x68,0x49,
0x97,0xB6,0xD5,0xF4,0x13,0x32,0x51,0x70,0x9F,0xBE,0xDD,0xFC,0x1B,0x3A,0x59,0x78,
0x88,0xA9,0xCA,0xEB,0x0C,0x2D,0x4E,0x6F,0x80,0xA1,0xC2,0xE3,0x04,0x25,0x46,0x67,
0xB9,0x98,0xFB,0xDA,0x3D,0x1C,0x7F,0x5E,0xB1,0x90,0xF3,0xD2,0x35,0x14,0x77,0x56,
0xEA,0xCB,0xA8,0x89,0x6E,0x4F,0x2C,0x0D,0xE2,0xC3,0xA0,0x81,0x66,0x47,0x24,0x05,
0xDB,0xFA,0x99,0xB8,0x5F,0x7E,0x1D,0x3C,0xD3,0xF2,0x91,0xB0,0x57,0x76,0x15,0x34,
0x4C,0x6D,0x0E,0x2F,0xC8,0xE9,0x8A,0xAB,0x44,0x65,0x06,0x27,0xC0,0xE1,0x82,0xA3,
0x7D,0x5C,0x3F,0x1E,0xF9,0xD8,0xBB,0x9A,0x75,0x54,0x37,0x16,0xF1,0xD0,0xB3,0x92,
0x2E,0x0F,0x6C,0x4D,0xAA,0x8B,0xE8,0xC9,0x26,0x07,0x64,0x45,0xA2,0x83,0xE0,0xC1,
0x1F,0x3E,0x5D,0x7C,0x9B,0xBA,0xD9,0xF8,0x17,0x36,0x55,0x74,0x93,0xB2,0xD1,0xF0};

int main(int argc, char *arg[])
{
unsigned char test[256]=“HelloWorld! Testing…”;
unsigned short crc;
int i, len;
int last,chr;

printf("====== CRC test ==========\

");
len = strlen(test);

crc = 0xFFFF;
crc = ccitt_updcrc(crc, test, len);
crc = ~crc; //Ones Compliment
SWAP2(crc);

printf("0x%.4X\

",crc);

test[len] = (crc & 0xFF);
test[len+1] = (crc>>8);

crc = 0xFFFF;
crc = ccitt_updcrc(crc, test, len+2);
printf("0x%.4X\

“,crc);
if(crc==0x1D0F)
printf(”…CORRECT!
“);
else
printf(”…FAIL!
");

printf("====== END CRC test ==========\

");

unsigned short ccitt_updcrc(unsigned short crc, unsigned char *buf, int length)
{
int y;
unsigned char a,x;
unsigned char crcH = (crc >> 8); //Shifts Right 8 (bitwise shiftright)
unsigned char crcL = (crc & 0xFF); // Bitwise AND

if(length==0)
	return crc;

for(y=0;y<length;y++)
{
	a = crcH;
	a ^= buf[y]; //Bitwise XOR =
	x = a;
	a = crc_table1[x]; 
	a ^= crcL; //Bitwise XOR = 
	crcH = a;
	a = crc_table2[x];
	crcL = a;
}		

crc = ((unsigned short)crcH << 8) | crcL; //Binary Shift Left 8  | = Binary OR Operator

return crc;

}[/code]

show what you have attempted… and why you think it doesn’t work…

The reason sample not included is quite embarrassing :smiley: . I’m working on reverse engineering the Xband Modem, however, I’m not C savvy, and i’m kind of new to this whole bitwise / bitshifting stuff. Why I’m using a realbasic classic build involves the fact that it’s the only other machine I have lying around with a working modem (Besides the courier attached to my WinBox, however, I need two modems to do certain types of tests.) Here is the start of my not knowing entirely what i’m doing implementation :

Interesting note for the mac lovers : The Xband Modem used the Appletalk Datastream protocol

00 (start of message byte)

6F 21 00 00 00 00 00 00 00 00 04 00 81 (13-byte ADSP header, source ConnID $6F21, 1kB receive window, open connection request)

01 00 00 00 00 00 00 00 (this is also part of the ADSP open connection dialog.)

11 60 (checksum for bit error detection)
10 03 (DLE + ETX ASCII characters indicating end of message)
https://s29.postimg.org/a3j5ss9p3/adsp.jpg

That screenshot though!
(nothing useful to add, just love Classic Mac OS)

Few side notes : The c comments are my figuring out of conversion functions (They could be wrong), I know there are some things that are epic wrong with the screenshot I poseted, but I was in the middle of changing some things. Also probably a wrong use of &h, as i’m still learning how to handle HEX usage

  1. new desktop project
  2. add a textarea to window1
  3. window1.open
Dim test As memoryblock = "HelloWorld! Testing..."
test.LittleEndian = False

Dim crc As UInt16
Dim i, Len As Integer
Dim last,Chr As Integer

textarea1.appendtext "====== CRC test ==========" + EndOfLine 
Len = test.Size

crc = &hFFFF
crc = ccitt_updcrc(crc, test, Len)
crc = Bitwise.OnesComplement(crc) //Ones Compliment
crc = swap2(crc)

textarea1.appendtext Hex(crc) + EndOfLine

test.size = test.size + 2

test.Uint8Value(Len) = (crc And &hFF)
test.Uint8Value(Len+1) = bitwise.shiftright(crc, 8, 16)

crc = &hFFFF
crc = ccitt_updcrc(crc, test, Len+2)

textarea1.appendtext Hex(crc) + EndOfLine

If crc= &h1D0F then
  textarea1.appendtext "...CORRECT!" + EndOfLine 
Else
  textarea1.appendtext "...FAIL!" + EndOfLine 
End If

textarea1.appendtext "====== END CRC test ==========" + EndOfLine 
  1. add SWAP2 method
Private Function swap2(input as uint16) as uint16
  Dim mb As New MemoryBlock(2)
  
  mb.UInt16Value(0) = Input
  Dim tmp As UInt8 = mb.Uint8value(0)
  mb.UInt8Value(0) = mb.UInt8Value(1) 
  mb.UInt8Value(1) =   tmp
  
  return mb.UInt16Value(0)
End Function
  1. add ccitt_updatecrc method
Protected Function ccitt_updcrc(crc As UInt16, buf As memoryblock, length As Integer) as UInt16
  
  Dim crc_table1(&h100) As Uint32 = Array(&h00,&h10,&h20,&h30,&h40,&h50,&h60,&h70,&h81,&h91,&hA1,&hB1,&hC1,&hD1,&hE1,&hF1,_
  &h12,&h02,&h32,&h22,&h52,&h42,&h72,&h62,&h93,&h83,&hB3,&hA3,&hD3,&hC3,&hF3,&hE3,_
  &h24,&h34,&h04,&h14,&h64,&h74,&h44,&h54,&hA5,&hB5,&h85,&h95,&hE5,&hF5,&hC5,&hD5,_
  &h36,&h26,&h16,&h06,&h76,&h66,&h56,&h46,&hB7,&hA7,&h97,&h87,&hF7,&hE7,&hD7,&hC7,_
  &h48,&h58,&h68,&h78,&h08,&h18,&h28,&h38,&hC9,&hD9,&hE9,&hF9,&h89,&h99,&hA9,&hB9,_
  &h5A,&h4A,&h7A,&h6A,&h1A,&h0A,&h3A,&h2A,&hDB,&hCB,&hFB,&hEB,&h9B,&h8B,&hBB,&hAB,_
  &h6C,&h7C,&h4C,&h5C,&h2C,&h3C,&h0C,&h1C,&hED,&hFD,&hCD,&hDD,&hAD,&hBD,&h8D,&h9D,_
  &h7E,&h6E,&h5E,&h4E,&h3E,&h2E,&h1E,&h0E,&hFF,&hEF,&hDF,&hCF,&hBF,&hAF,&h9F,&h8F,_
  &h91,&h81,&hB1,&hA1,&hD1,&hC1,&hF1,&hE1,&h10,&h00,&h30,&h20,&h50,&h40,&h70,&h60,_
  &h83,&h93,&hA3,&hB3,&hC3,&hD3,&hE3,&hF3,&h02,&h12,&h22,&h32,&h42,&h52,&h62,&h72,_
  &hB5,&hA5,&h95,&h85,&hF5,&hE5,&hD5,&hC5,&h34,&h24,&h14,&h04,&h74,&h64,&h54,&h44,_
  &hA7,&hB7,&h87,&h97,&hE7,&hF7,&hC7,&hD7,&h26,&h36,&h06,&h16,&h66,&h76,&h46,&h56,_
  &hD9,&hC9,&hF9,&hE9,&h99,&h89,&hB9,&hA9,&h58,&h48,&h78,&h68,&h18,&h08,&h38,&h28,_
  &hCB,&hDB,&hEB,&hFB,&h8B,&h9B,&hAB,&hBB,&h4A,&h5A,&h6A,&h7A,&h0A,&h1A,&h2A,&h3A,_
  &hFD,&hED,&hDD,&hCD,&hBD,&hAD,&h9D,&h8D,&h7C,&h6C,&h5C,&h4C,&h3C,&h2C,&h1C,&h0C,_
  &hEF,&hFF,&hCF,&hDF,&hAF,&hBF,&h8F,&h9F,&h6E,&h7E,&h4E,&h5E,&h2E,&h3E,&h0E,&h1E)
  
  Dim crc_table2(&h100) As Uint32 = Array(&h00,&h21,&h42,&h63,&h84,&hA5,&hC6,&hE7,&h08,&h29,&h4A,&h6B,&h8C,&hAD,&hCE,&hEF,_
  &h31,&h10,&h73,&h52,&hB5,&h94,&hF7,&hD6,&h39,&h18,&h7B,&h5A,&hBD,&h9C,&hFF,&hDE,_
  &h62,&h43,&h20,&h01,&hE6,&hC7,&hA4,&h85,&h6A,&h4B,&h28,&h09,&hEE,&hCF,&hAC,&h8D,_
  &h53,&h72,&h11,&h30,&hD7,&hF6,&h95,&hB4,&h5B,&h7A,&h19,&h38,&hDF,&hFE,&h9D,&hBC,_
  &hC4,&hE5,&h86,&hA7,&h40,&h61,&h02,&h23,&hCC,&hED,&h8E,&hAF,&h48,&h69,&h0A,&h2B,_
  &hF5,&hD4,&hB7,&h96,&h71,&h50,&h33,&h12,&hFD,&hDC,&hBF,&h9E,&h79,&h58,&h3B,&h1A,_
  &hA6,&h87,&hE4,&hC5,&h22,&h03,&h60,&h41,&hAE,&h8F,&hEC,&hCD,&h2A,&h0B,&h68,&h49,_
  &h97,&hB6,&hD5,&hF4,&h13,&h32,&h51,&h70,&h9F,&hBE,&hDD,&hFC,&h1B,&h3A,&h59,&h78,_
  &h88,&hA9,&hCA,&hEB,&h0C,&h2D,&h4E,&h6F,&h80,&hA1,&hC2,&hE3,&h04,&h25,&h46,&h67,_
  &hB9,&h98,&hFB,&hDA,&h3D,&h1C,&h7F,&h5E,&hB1,&h90,&hF3,&hD2,&h35,&h14,&h77,&h56,_
  &hEA,&hCB,&hA8,&h89,&h6E,&h4F,&h2C,&h0D,&hE2,&hC3,&hA0,&h81,&h66,&h47,&h24,&h05,_
  &hDB,&hFA,&h99,&hB8,&h5F,&h7E,&h1D,&h3C,&hD3,&hF2,&h91,&hB0,&h57,&h76,&h15,&h34,_
  &h4C,&h6D,&h0E,&h2F,&hC8,&hE9,&h8A,&hAB,&h44,&h65,&h06,&h27,&hC0,&hE1,&h82,&hA3,_
  &h7D,&h5C,&h3F,&h1E,&hF9,&hD8,&hBB,&h9A,&h75,&h54,&h37,&h16,&hF1,&hD0,&hB3,&h92,_
  &h2E,&h0F,&h6C,&h4D,&hAA,&h8B,&hE8,&hC9,&h26,&h07,&h64,&h45,&hA2,&h83,&hE0,&hC1,_
  &h1F,&h3E,&h5D,&h7C,&h9B,&hBA,&hD9,&hF8,&h17,&h36,&h55,&h74,&h93,&hB2,&hD1,&hF0)
  
  
  
  Dim y As Integer
  Dim a,x As UInt8
  Dim crcH As UInt8 = Bitwise.ShiftRight(crc,8,16) //Shifts Right 8 (bitwise shiftright)
  Dim crcL As UInt8 = crc And &hFF // Bitwise AND
  
  If length=0 Then
    Return crc
  End If
  
  For y = 0 To length-1
    a = crcH
    a = BitwiseXor(a,buf.Uint8Value(y)) //Bitwise XOR =
    x = a
    a = crc_table1(x)
    a = BitwiseXor(a,crcL) //Bitwise XOR = 
    crcH = a
    a = crc_table2(x)
    crcL = a
  Next
  
  crc = BitWise.ShiftLeft(crcH,8,16) Or crcL  //Binary Shift Left 8 | = Binary OR Operator
  
  Return crc
  
End Function

I use the following for Modbus CRC checking:
(uses the following global integer table for speed and avoids having to shift)

[code]Public Sub InitCRC16()
CRC16tbl(0)=&H0000
CRC16tbl(1)=&HC0C1
CRC16tbl(2)=&HC181
CRC16tbl(3)=&H0140
CRC16tbl(4)=&HC301
CRC16tbl(5)=&H03C0
CRC16tbl(6)=&H0280
CRC16tbl(7)=&HC241
CRC16tbl(8)=&HC601
CRC16tbl(9)=&H06C0
CRC16tbl(10)=&H0780
CRC16tbl(11)=&HC741
CRC16tbl(12)=&H0500
CRC16tbl(13)=&HC5C1
CRC16tbl(14)=&HC481
CRC16tbl(15)=&H0440
CRC16tbl(16)=&HCC01
CRC16tbl(17)=&H0CC0
CRC16tbl(18)=&H0D80
CRC16tbl(19)=&HCD41
CRC16tbl(20)=&H0F00
CRC16tbl(21)=&HCFC1
CRC16tbl(22)=&HCE81
CRC16tbl(23)=&H0E40
CRC16tbl(24)=&H0A00
CRC16tbl(25)=&HCAC1
CRC16tbl(26)=&HCB81
CRC16tbl(27)=&H0B40
CRC16tbl(28)=&HC901
CRC16tbl(29)=&H09C0
CRC16tbl(30)=&H0880
CRC16tbl(31)=&HC841
CRC16tbl(32)=&HD801
CRC16tbl(33)=&H18C0
CRC16tbl(34)=&H1980
CRC16tbl(35)=&HD941
CRC16tbl(36)=&H1B00
CRC16tbl(37)=&HDBC1
CRC16tbl(38)=&HDA81
CRC16tbl(39)=&H1A40
CRC16tbl(40)=&H1E00
CRC16tbl(41)=&HDEC1
CRC16tbl(42)=&HDF81
CRC16tbl(43)=&H1F40
CRC16tbl(44)=&HDD01
CRC16tbl(45)=&H1DC0
CRC16tbl(46)=&H1C80
CRC16tbl(47)=&HDC41
CRC16tbl(48)=&H1400
CRC16tbl(49)=&HD4C1
CRC16tbl(50)=&HD581
CRC16tbl(51)=&H1540
CRC16tbl(52)=&HD701
CRC16tbl(53)=&H17C0
CRC16tbl(54)=&H1680
CRC16tbl(55)=&HD641
CRC16tbl(56)=&HD201
CRC16tbl(57)=&H12C0
CRC16tbl(58)=&H1380
CRC16tbl(59)=&HD341
CRC16tbl(60)=&H1100
CRC16tbl(61)=&HD1C1
CRC16tbl(62)=&HD081
CRC16tbl(63)=&H1040
CRC16tbl(64)=&HF001
CRC16tbl(65)=&H30C0
CRC16tbl(66)=&H3180
CRC16tbl(67)=&HF141
CRC16tbl(68)=&H3300
CRC16tbl(69)=&HF3C1
CRC16tbl(70)=&HF281
CRC16tbl(71)=&H3240
CRC16tbl(72)=&H3600
CRC16tbl(73)=&HF6C1
CRC16tbl(74)=&HF781
CRC16tbl(75)=&H3740
CRC16tbl(76)=&HF501
CRC16tbl(77)=&H35C0
CRC16tbl(78)=&H3480
CRC16tbl(79)=&HF441
CRC16tbl(80)=&H3C00
CRC16tbl(81)=&HFCC1
CRC16tbl(82)=&HFD81
CRC16tbl(83)=&H3D40
CRC16tbl(84)=&HFF01
CRC16tbl(85)=&H3FC0
CRC16tbl(86)=&H3E80
CRC16tbl(87)=&HFE41
CRC16tbl(88)=&HFA01
CRC16tbl(89)=&H3AC0
CRC16tbl(90)=&H3B80
CRC16tbl(91)=&HFB41
CRC16tbl(92)=&H3900
CRC16tbl(93)=&HF9C1
CRC16tbl(94)=&HF881
CRC16tbl(95)=&H3840
CRC16tbl(96)=&H2800
CRC16tbl(97)=&HE8C1
CRC16tbl(98)=&HE981
CRC16tbl(99)=&H2940
CRC16tbl(100)=&HEB01
CRC16tbl(101)=&H2BC0
CRC16tbl(102)=&H2A80
CRC16tbl(103)=&HEA41
CRC16tbl(104)=&HEE01
CRC16tbl(105)=&H2EC0
CRC16tbl(106)=&H2F80
CRC16tbl(107)=&HEF41
CRC16tbl(108)=&H2D00
CRC16tbl(109)=&HEDC1
CRC16tbl(110)=&HEC81
CRC16tbl(111)=&H2C40
CRC16tbl(112)=&HE401
CRC16tbl(113)=&H24C0
CRC16tbl(114)=&H2580
CRC16tbl(115)=&HE541
CRC16tbl(116)=&H2700
CRC16tbl(117)=&HE7C1
CRC16tbl(118)=&HE681
CRC16tbl(119)=&H2640
CRC16tbl(120)=&H2200
CRC16tbl(121)=&HE2C1
CRC16tbl(122)=&HE381
CRC16tbl(123)=&H2340
CRC16tbl(124)=&HE101
CRC16tbl(125)=&H21C0
CRC16tbl(126)=&H2080
CRC16tbl(127)=&HE041
CRC16tbl(128)=&HA001
CRC16tbl(129)=&H60C0
CRC16tbl(130)=&H6180
CRC16tbl(131)=&HA141
CRC16tbl(132)=&H6300
CRC16tbl(133)=&HA3C1
CRC16tbl(134)=&HA281
CRC16tbl(135)=&H6240
CRC16tbl(136)=&H6600
CRC16tbl(137)=&HA6C1
CRC16tbl(138)=&HA781
CRC16tbl(139)=&H6740
CRC16tbl(140)=&HA501
CRC16tbl(141)=&H65C0
CRC16tbl(142)=&H6480
CRC16tbl(143)=&HA441
CRC16tbl(144)=&H6C00
CRC16tbl(145)=&HACC1
CRC16tbl(146)=&HAD81
CRC16tbl(147)=&H6D40
CRC16tbl(148)=&HAF01
CRC16tbl(149)=&H6FC0
CRC16tbl(150)=&H6E80
CRC16tbl(151)=&HAE41
CRC16tbl(152)=&HAA01
CRC16tbl(153)=&H6AC0
CRC16tbl(154)=&H6B80
CRC16tbl(155)=&HAB41
CRC16tbl(156)=&H6900
CRC16tbl(157)=&HA9C1
CRC16tbl(158)=&HA881
CRC16tbl(159)=&H6840
CRC16tbl(160)=&H7800
CRC16tbl(161)=&HB8C1
CRC16tbl(162)=&HB981
CRC16tbl(163)=&H7940
CRC16tbl(164)=&HBB01
CRC16tbl(165)=&H7BC0
CRC16tbl(166)=&H7A80
CRC16tbl(167)=&HBA41
CRC16tbl(168)=&HBE01
CRC16tbl(169)=&H7EC0
CRC16tbl(170)=&H7F80
CRC16tbl(171)=&HBF41
CRC16tbl(172)=&H7D00
CRC16tbl(173)=&HBDC1
CRC16tbl(174)=&HBC81
CRC16tbl(175)=&H7C40
CRC16tbl(176)=&HB401
CRC16tbl(177)=&H74C0
CRC16tbl(178)=&H7580
CRC16tbl(179)=&HB541
CRC16tbl(180)=&H7700
CRC16tbl(181)=&HB7C1
CRC16tbl(182)=&HB681
CRC16tbl(183)=&H7640
CRC16tbl(184)=&H7200
CRC16tbl(185)=&HB2C1
CRC16tbl(186)=&HB381
CRC16tbl(187)=&H7340
CRC16tbl(188)=&HB101
CRC16tbl(189)=&H71C0
CRC16tbl(190)=&H7080
CRC16tbl(191)=&HB041
CRC16tbl(192)=&H5000
CRC16tbl(193)=&H90C1
CRC16tbl(194)=&H9181
CRC16tbl(195)=&H5140
CRC16tbl(196)=&H9301
CRC16tbl(197)=&H53C0
CRC16tbl(198)=&H5280
CRC16tbl(199)=&H9241
CRC16tbl(200)=&H9601
CRC16tbl(201)=&H56C0
CRC16tbl(202)=&H5780
CRC16tbl(203)=&H9741
CRC16tbl(204)=&H5500
CRC16tbl(205)=&H95C1
CRC16tbl(206)=&H9481
CRC16tbl(207)=&H5440
CRC16tbl(208)=&H9C01
CRC16tbl(209)=&H5CC0
CRC16tbl(210)=&H5D80
CRC16tbl(211)=&H9D41
CRC16tbl(212)=&H5F00
CRC16tbl(213)=&H9FC1
CRC16tbl(214)=&H9E81
CRC16tbl(215)=&H5E40
CRC16tbl(216)=&H5A00
CRC16tbl(217)=&H9AC1
CRC16tbl(218)=&H9B81
CRC16tbl(219)=&H5B40
CRC16tbl(220)=&H9901
CRC16tbl(221)=&H59C0
CRC16tbl(222)=&H5880
CRC16tbl(223)=&H9841
CRC16tbl(224)=&H8801
CRC16tbl(225)=&H48C0
CRC16tbl(226)=&H4980
CRC16tbl(227)=&H8941
CRC16tbl(228)=&H4B00
CRC16tbl(229)=&H8BC1
CRC16tbl(230)=&H8A81
CRC16tbl(231)=&H4A40
CRC16tbl(232)=&H4E00
CRC16tbl(233)=&H8EC1
CRC16tbl(234)=&H8F81
CRC16tbl(235)=&H4F40
CRC16tbl(236)=&H8D01
CRC16tbl(237)=&H4DC0
CRC16tbl(238)=&H4C80
CRC16tbl(239)=&H8C41
CRC16tbl(240)=&H4400
CRC16tbl(241)=&H84C1
CRC16tbl(242)=&H8581
CRC16tbl(243)=&H4540
CRC16tbl(244)=&H8701
CRC16tbl(245)=&H47C0
CRC16tbl(246)=&H4680
CRC16tbl(247)=&H8641
CRC16tbl(248)=&H8201
CRC16tbl(249)=&H42C0
CRC16tbl(250)=&H4380
CRC16tbl(251)=&H8341
CRC16tbl(252)=&H4100
CRC16tbl(253)=&H81C1
CRC16tbl(254)=&H8081
CRC16tbl(255)=&H4040
End Sub

Public Function MBCRC16(CData As String, DLen As Integer) as Integer
'************************************************************************
'* CRC Compute for Modbus Data String - uses table for speed
'************************************************************************
dim i,CRC as Integer
CRC=65535 ’ start the CRC (some CRCs start with a different value)
for i=1 to DLen
CRC=BitwiseXor(MSB(CRC),CRC16tbl(BitwiseXor(BitwiseAnd(CRC,&HFF),AscB(MidB(CData,i,1)))))
next
return CRC
End Function

'need these functions as well…
Public Function LSB(longval as integer) as integer
Return(BitwiseAnd(longval,&HFF))
End Function

Public Function MSB(longval as integer) as integer
Return(longval\256)
End Function

'*** CRC checksum of string buffer MBData ***
csword=MBCRC16(MBData,LenB(MBData))[/code]

make sure you call InitCRC first - hope this helps
sorry it’s kind of a mess it was written long ago…

FYI
I was the one who originally requested the bitwise functions be added…
I sent them this request:
3. Could the AND and OR operators be made to work with integers to do bitwise
ANDing and ORing?

and later got the following included in an update - got more than I asked for!

REALbasic Release DR1r34 (May 12th, 1998)
„ BitwiseAnd(v1 as integer, v2 as integer) as integer
„ BitwiseOr(v1 as integer, v2 as integer) as integer
„ BitwiseXor(v1 as integer, v2 as integer) as integer

Please use the Code tags to post code.

unsigned char crc_table1[0x100] =
  {0x00,0x10,0x20,0x30,0x40,0x50,0x60,0x70,0x81,0x91,0xA1,0xB1,0xC1,0xD1,0xE1,0xF1,
  0x12,0x02,0x32,0x22,0x52,0x42,0x72,0x62,0x93,0x83,0xB3,0xA3,0xD3,0xC3,0xF3,0xE3,
  0x24,0x34,0x04,0x14,0x64,0x74,0x44,0x54,0xA5,0xB5,0x85,0x95,0xE5,0xF5,0xC5,0xD5,
  0x36,0x26,0x16,0x06,0x76,0x66,0x56,0x46,0xB7,0xA7,0x97,0x87,0xF7,0xE7,0xD7,0xC7,
  0x48,0x58,0x68,0x78,0x08,0x18,0x28,0x38,0xC9,0xD9,0xE9,0xF9,0x89,0x99,0xA9,0xB9,
  0x5A,0x4A,0x7A,0x6A,0x1A,0x0A,0x3A,0x2A,0xDB,0xCB,0xFB,0xEB,0x9B,0x8B,0xBB,0xAB,
  0x6C,0x7C,0x4C,0x5C,0x2C,0x3C,0x0C,0x1C,0xED,0xFD,0xCD,0xDD,0xAD,0xBD,0x8D,0x9D,
  0x7E,0x6E,0x5E,0x4E,0x3E,0x2E,0x1E,0x0E,0xFF,0xEF,0xDF,0xCF,0xBF,0xAF,0x9F,0x8F,
  0x91,0x81,0xB1,0xA1,0xD1,0xC1,0xF1,0xE1,0x10,0x00,0x30,0x20,0x50,0x40,0x70,0x60,
  0x83,0x93,0xA3,0xB3,0xC3,0xD3,0xE3,0xF3,0x02,0x12,0x22,0x32,0x42,0x52,0x62,0x72,
  0xB5,0xA5,0x95,0x85,0xF5,0xE5,0xD5,0xC5,0x34,0x24,0x14,0x04,0x74,0x64,0x54,0x44,
  0xA7,0xB7,0x87,0x97,0xE7,0xF7,0xC7,0xD7,0x26,0x36,0x06,0x16,0x66,0x76,0x46,0x56,
  0xD9,0xC9,0xF9,0xE9,0x99,0x89,0xB9,0xA9,0x58,0x48,0x78,0x68,0x18,0x08,0x38,0x28,
  0xCB,0xDB,0xEB,0xFB,0x8B,0x9B,0xAB,0xBB,0x4A,0x5A,0x6A,0x7A,0x0A,0x1A,0x2A,0x3A,
  0xFD,0xED,0xDD,0xCD,0xBD,0xAD,0x9D,0x8D,0x7C,0x6C,0x5C,0x4C,0x3C,0x2C,0x1C,0x0C,
  0xEF,0xFF,0xCF,0xDF,0xAF,0xBF,0x8F,0x9F,0x6E,0x7E,0x4E,0x5E,0x2E,0x3E,0x0E,0x1E};

unsigned char crc_table2[0x100] =
  {0x00,0x21,0x42,0x63,0x84,0xA5,0xC6,0xE7,0x08,0x29,0x4A,0x6B,0x8C,0xAD,0xCE,0xEF,
  0x31,0x10,0x73,0x52,0xB5,0x94,0xF7,0xD6,0x39,0x18,0x7B,0x5A,0xBD,0x9C,0xFF,0xDE,
  0x62,0x43,0x20,0x01,0xE6,0xC7,0xA4,0x85,0x6A,0x4B,0x28,0x09,0xEE,0xCF,0xAC,0x8D,
  0x53,0x72,0x11,0x30,0xD7,0xF6,0x95,0xB4,0x5B,0x7A,0x19,0x38,0xDF,0xFE,0x9D,0xBC,
  0xC4,0xE5,0x86,0xA7,0x40,0x61,0x02,0x23,0xCC,0xED,0x8E,0xAF,0x48,0x69,0x0A,0x2B,
  0xF5,0xD4,0xB7,0x96,0x71,0x50,0x33,0x12,0xFD,0xDC,0xBF,0x9E,0x79,0x58,0x3B,0x1A,
  0xA6,0x87,0xE4,0xC5,0x22,0x03,0x60,0x41,0xAE,0x8F,0xEC,0xCD,0x2A,0x0B,0x68,0x49,
  0x97,0xB6,0xD5,0xF4,0x13,0x32,0x51,0x70,0x9F,0xBE,0xDD,0xFC,0x1B,0x3A,0x59,0x78,
  0x88,0xA9,0xCA,0xEB,0x0C,0x2D,0x4E,0x6F,0x80,0xA1,0xC2,0xE3,0x04,0x25,0x46,0x67,
  0xB9,0x98,0xFB,0xDA,0x3D,0x1C,0x7F,0x5E,0xB1,0x90,0xF3,0xD2,0x35,0x14,0x77,0x56,
  0xEA,0xCB,0xA8,0x89,0x6E,0x4F,0x2C,0x0D,0xE2,0xC3,0xA0,0x81,0x66,0x47,0x24,0x05,
  0xDB,0xFA,0x99,0xB8,0x5F,0x7E,0x1D,0x3C,0xD3,0xF2,0x91,0xB0,0x57,0x76,0x15,0x34,
  0x4C,0x6D,0x0E,0x2F,0xC8,0xE9,0x8A,0xAB,0x44,0x65,0x06,0x27,0xC0,0xE1,0x82,0xA3,
  0x7D,0x5C,0x3F,0x1E,0xF9,0xD8,0xBB,0x9A,0x75,0x54,0x37,0x16,0xF1,0xD0,0xB3,0x92,
  0x2E,0x0F,0x6C,0x4D,0xAA,0x8B,0xE8,0xC9,0x26,0x07,0x64,0x45,0xA2,0x83,0xE0,0xC1,
  0x1F,0x3E,0x5D,0x7C,0x9B,0xBA,0xD9,0xF8,0x17,0x36,0x55,0x74,0x93,0xB2,0xD1,0xF0};

int main(int argc, char *arg[])
{
  unsigned char test[256]="HelloWorld! Testing..."; 
  unsigned short crc;
  int i, len;
  int last,chr;

  printf("====== CRC test ==========\
");
  len = strlen(test);

  crc = 0xFFFF;
  crc = ccitt_updcrc(crc, test, len);
  crc = ~crc; //Ones Compliment
  SWAP2(crc);

  printf("0x%.4X\
",crc);

  test[len] = (crc & 0xFF);
  test[len+1] = (crc>>8);

  crc = 0xFFFF;
  crc = ccitt_updcrc(crc, test, len+2);
  printf("0x%.4X\
",crc);
  if(crc==0x1D0F)
  printf("...CORRECT!\
");
  else
  printf("...FAIL!\
");

  printf("====== END CRC test ==========\
");
} // THIS WAS MISSING ABOVE

unsigned short ccitt_updcrc(unsigned short crc, unsigned char *buf, int length)
{
  int y;
  unsigned char a,x;
  unsigned char crcH = (crc >> 8); //Shifts Right 8 (bitwise shiftright)
  unsigned char crcL = (crc & 0xFF); // Bitwise AND

  if(length==0)
    return crc;

  for(y=0;y<length;y++)
  {
    a = crcH;
    a ^= buf[y]; //Bitwise XOR =
    x = a;
    a = crc_table1[x]; 
    a ^= crcL; //Bitwise XOR = 
    crcH = a;
    a = crc_table2[x];
    crcL = a;
  }

  crc = ((unsigned short)crcH << 8) | crcL; //Binary Shift Left 8 | = Binary OR Operator

  return crc;
}

Here’s my attempt. I didn’t test it against anything, but hopefully it will give you a starting point.

Public Function ccitt_updcrc(crc As Integer, buffer As MemoryBlock) as Integer
  dim crc_table1() as UInt32 = array( _
  &h00, &h10, &h20, &h30, &h40, &h50, &h60, &h70, &h81, &h91, &hA1, &hB1, &hC1, &hD1, &hE1, &hF1,  _
  &h12, &h02, &h32, &h22, &h52, &h42, &h72, &h62, &h93, &h83, &hB3, &hA3, &hD3, &hC3, &hF3, &hE3,  _
  &h24, &h34, &h04, &h14, &h64, &h74, &h44, &h54, &hA5, &hB5, &h85, &h95, &hE5, &hF5, &hC5, &hD5,  _
  &h36, &h26, &h16, &h06, &h76, &h66, &h56, &h46, &hB7, &hA7, &h97, &h87, &hF7, &hE7, &hD7, &hC7,  _
  &h48, &h58, &h68, &h78, &h08, &h18, &h28, &h38, &hC9, &hD9, &hE9, &hF9, &h89, &h99, &hA9, &hB9,  _
  &h5A, &h4A, &h7A, &h6A, &h1A, &h0A, &h3A, &h2A, &hDB, &hCB, &hFB, &hEB, &h9B, &h8B, &hBB, &hAB,  _
  &h6C, &h7C, &h4C, &h5C, &h2C, &h3C, &h0C, &h1C, &hED, &hFD, &hCD, &hDD, &hAD, &hBD, &h8D, &h9D,  _
  &h7E, &h6E, &h5E, &h4E, &h3E, &h2E, &h1E, &h0E, &hFF, &hEF, &hDF, &hCF, &hBF, &hAF, &h9F, &h8F,  _
  &h91, &h81, &hB1, &hA1, &hD1, &hC1, &hF1, &hE1, &h10, &h00, &h30, &h20, &h50, &h40, &h70, &h60,  _
  &h83, &h93, &hA3, &hB3, &hC3, &hD3, &hE3, &hF3, &h02, &h12, &h22, &h32, &h42, &h52, &h62, &h72,  _
  &hB5, &hA5, &h95, &h85, &hF5, &hE5, &hD5, &hC5, &h34, &h24, &h14, &h04, &h74, &h64, &h54, &h44,  _
  &hA7, &hB7, &h87, &h97, &hE7, &hF7, &hC7, &hD7, &h26, &h36, &h06, &h16, &h66, &h76, &h46, &h56,  _
  &hD9, &hC9, &hF9, &hE9, &h99, &h89, &hB9, &hA9, &h58, &h48, &h78, &h68, &h18, &h08, &h38, &h28,  _
  &hCB, &hDB, &hEB, &hFB, &h8B, &h9B, &hAB, &hBB, &h4A, &h5A, &h6A, &h7A, &h0A, &h1A, &h2A, &h3A,  _
  &hFD, &hED, &hDD, &hCD, &hBD, &hAD, &h9D, &h8D, &h7C, &h6C, &h5C, &h4C, &h3C, &h2C, &h1C, &h0C,  _
  &hEF, &hFF, &hCF, &hDF, &hAF, &hBF, &h8F, &h9F, &h6E, &h7E, &h4E, &h5E, &h2E, &h3E, &h0E, &h1E _
  )
  
  dim crc_table2() as UInt32 = array ( _
  &h00, &h21, &h42, &h63, &h84, &hA5, &hC6, &hE7, &h08, &h29, &h4A, &h6B, &h8C, &hAD, &hCE, &hEF,  _
  &h31, &h10, &h73, &h52, &hB5, &h94, &hF7, &hD6, &h39, &h18, &h7B, &h5A, &hBD, &h9C, &hFF, &hDE,  _
  &h62, &h43, &h20, &h01, &hE6, &hC7, &hA4, &h85, &h6A, &h4B, &h28, &h09, &hEE, &hCF, &hAC, &h8D,  _
  &h53, &h72, &h11, &h30, &hD7, &hF6, &h95, &hB4, &h5B, &h7A, &h19, &h38, &hDF, &hFE, &h9D, &hBC,  _
  &hC4, &hE5, &h86, &hA7, &h40, &h61, &h02, &h23, &hCC, &hED, &h8E, &hAF, &h48, &h69, &h0A, &h2B,  _
  &hF5, &hD4, &hB7, &h96, &h71, &h50, &h33, &h12, &hFD, &hDC, &hBF, &h9E, &h79, &h58, &h3B, &h1A,  _
  &hA6, &h87, &hE4, &hC5, &h22, &h03, &h60, &h41, &hAE, &h8F, &hEC, &hCD, &h2A, &h0B, &h68, &h49,  _
  &h97, &hB6, &hD5, &hF4, &h13, &h32, &h51, &h70, &h9F, &hBE, &hDD, &hFC, &h1B, &h3A, &h59, &h78,  _
  &h88, &hA9, &hCA, &hEB, &h0C, &h2D, &h4E, &h6F, &h80, &hA1, &hC2, &hE3, &h04, &h25, &h46, &h67,  _
  &hB9, &h98, &hFB, &hDA, &h3D, &h1C, &h7F, &h5E, &hB1, &h90, &hF3, &hD2, &h35, &h14, &h77, &h56,  _
  &hEA, &hCB, &hA8, &h89, &h6E, &h4F, &h2C, &h0D, &hE2, &hC3, &hA0, &h81, &h66, &h47, &h24, &h05,  _
  &hDB, &hFA, &h99, &hB8, &h5F, &h7E, &h1D, &h3C, &hD3, &hF2, &h91, &hB0, &h57, &h76, &h15, &h34,  _
  &h4C, &h6D, &h0E, &h2F, &hC8, &hE9, &h8A, &hAB, &h44, &h65, &h06, &h27, &hC0, &hE1, &h82, &hA3,  _
  &h7D, &h5C, &h3F, &h1E, &hF9, &hD8, &hBB, &h9A, &h75, &h54, &h37, &h16, &hF1, &hD0, &hB3, &h92,  _
  &h2E, &h0F, &h6C, &h4D, &hAA, &h8B, &hE8, &hC9, &h26, &h07, &h64, &h45, &hA2, &h83, &hE0, &hC1,  _
  &h1F, &h3E, &h5D, &h7C, &h9B, &hBA, &hD9, &hF8, &h17, &h36, &h55, &h74, &h93, &hB2, &hD1, &hF0 _
  )
  
  dim crcH as UInt32 = Bitwise.ShiftRight(crc, 8)
  dim crcL as UInt32 = crc and &hFF
  
  if buffer.Size = 0 then
    return crc
  end if
  
  for y as integer = 0 to buffer.Size - 1
    
    dim a as UInt32 = crcH
    a = a xor buffer.Byte(y)
    dim x as UInt32 = a
    a = crc_table1(x) 
    a = a xor crcL
    crcH = a
    a = crc_table2(x)
    crcL = a
  next
  
  crc = Bitwise.ShiftLeft(crcH, 8) or crcL
  
  return crc
End Function

[quote=337049:@Kem Tekinay]Here’s my attempt. I didn’t test it against anything, but hopefully it will give you a starting point.
[/quote]
I did test mine and it passed the test case as included in the code :stuck_out_tongue:

Thank you guys! I’ll tear apart all of the provided examples so I can wrap my head around all of this, I beyond appreciate it

Darn it, I missed your post. Oh well, a fun exercise anyway.

mostly search & replace except for a handful of lines in the C loop