Modbus over usb

[elogicca]

Trying to figure this out, incoming is fine but on outgoing my crc is apparently wrong... the sample only contains holding regs

[code]
#include <18F4455.h>
#device adc=10

#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN
#use delay(clock=48000000)


#define MODBUS_SERIAL_RX_BUFFER_SIZE 32
#define MODBUS_OUR_ADDRESS 1

#include<usb_cdc.h>

int1 modbus_serial_new=0;
int8 data_buf[MODBUS_SERIAL_RX_BUFFER_SIZE];
const int8 modbus_serial_wait=50;


enum {MODBUS_GETSLAVE, MODBUS_GETFUNC, MODBUS_GETADDRESS_HIGH,MODBUS_GETADDRESS_LOW,MODBUS_GETQTY_HIGH,MODBUS_GETQTY_LOW, MODBUS_GETDATA, MODBUS_DONE}

modbus_serial_state = 0;

struct
{
int8 slave;
int8 address_high;
int8 address_low;
int8 qty_high;
int8 qty_low;
int16 qty;
int8 len; //number of bytes in the message received
int8 func; //the function of the message received
int8 data[MODBUS_SERIAL_RX_BUFFER_SIZE]; //data of the message received
} modbus_rx;


int16 modbus_serial_crc;

void response(void);

void Clear_Incoming_Buffer(void)
{
while(usb_cdc_kbhit())
{
usb_cdc_getc();
}
}

void Calc_CRC(int8 data)
{
int16 crc;
int16 x;

x = make8(modbus_serial_crc,1) ^ data;
x ^= x>>4;

crc = (modbus_serial_crc << 8) ^ (x << 12) ^ (x <<5) ^ x;

crc &= 0xffff;

modbus_serial_crc = crc;
}


void modbus_serial_putc(int8 c)
{
usb_cdc_putc(c);

Calc_CRC(c);

delay_us(4000);
}

void MODBUS_ENABLE_TIMEOUT(int1 enable)
{
disable_interrupts(INT_TIMER2);

if (enable)
{
set_timer2(0);
clear_interrupt(INT_TIMER2);
enable_interrupts(INT_TIMER2);
}
}

#int_timer2
void modbus_timeout_now(void)
{
if((modbus_serial_state == MODBUS_GETDATA) && (modbus_serial_crc == 0x0000) && (!modbus_serial_new))
{
modbus_rx.len-=2;
modbus_serial_new=TRUE;
}
else
{
modbus_serial_new=FALSE;
modbus_serial_crc = 0xFFFF;
modbus_serial_state=MODBUS_GETSLAVE;
MODBUS_ENABLE_TIMEOUT(FALSE);
response();
}
}


void modbus_send(int8 to, int8 func, int8* data, int8 len)
{
int8 i;
int8 crc_low, crc_high;

modbus_serial_crc =0xFFFF;

modbus_serial_new=FALSE;

Clear_Incoming_Buffer();

delay_us(4000);

modbus_serial_putc(to);

modbus_serial_putc(func);

modbus_serial_putc(len);

for (i=0;i<len;i++)
{
modbus_serial_putc(*data);
data++;
}

crc_high = make8(modbus_serial_crc,1);
crc_low = make8(modbus_serial_crc,0);

modbus_serial_putc(crc_high);
modbus_serial_putc(crc_low);

delay_us(4000);

}


void read_holding_registers_rsp(int8 address, int8 register_count, int8 *reg_data)
{
int8 i;

for(i=0; i < register_count; i++)
{
data_buf[i] = *reg_data;
reg_data++;
}

modbus_send(address, 0x03, &(data_buf[0]), register_count);
}


void response()
{
int8 PendantStatus[4];

switch(modbus_rx.func)
{
case 0x01:
break;
case 0x02:
break;
case 0x03:
PendantStatus[0] = 0x10;
PendantStatus[1] = 0x01;
read_holding_registers_rsp(MODBUS_OUR_ADDRESS,modbus_rx.qty,&(PendantStatus[0]));
break;
case 0x04:
break;
case 0x05:
break;
case 0x06:
break;
case 0x07:
break;
case 0x08:
break;
case 0x10:
break;
case 0x11:
break;
}
}

void getusbdata()
{
char c;

c=usb_cdc_getc();

if (!modbus_serial_new)
{
if(modbus_serial_state == MODBUS_GETSLAVE)
{
modbus_serial_crc = 0xFFFF;
modbus_rx.slave = c;
modbus_serial_state++;
modbus_rx.len = 0;
}
else if(modbus_serial_state == MODBUS_GETFUNC)
{
modbus_rx.func = c;
modbus_serial_state++;
}
else if(modbus_serial_state == MODBUS_GETADDRESS_HIGH)
{
modbus_rx.address_high = c;
modbus_serial_state++;
}
else if(modbus_serial_state == MODBUS_GETADDRESS_LOW)
{
modbus_rx.address_low = c;
modbus_serial_state++;
}
else if(modbus_serial_state == MODBUS_GETQTY_HIGH)
{
modbus_rx.qty_high = c;
modbus_serial_state++;
}
else if(modbus_serial_state == MODBUS_GETQTY_LOW)
{
modbus_rx.qty_low = c;
modbus_rx.qty = make16(modbus_rx.qty_high,modbus_rx.qty_low);
modbus_serial_state++;
}
else if(modbus_serial_state == MODBUS_GETDATA)
{
if (modbus_rx.len>=MODBUS_SERIAL_RX_BUFFER_SIZE) {modbus_rx.len=MODBUS_SERIAL_RX_BUFFER_SIZE-1;}
modbus_rx.data[modbus_rx.len]=c;
modbus_rx.len++;
}

Calc_CRC(c);

MODBUS_ENABLE_TIMEOUT(TRUE);
}
}



void main()
{
setup_adc_ports(NO_ANALOGS);
setup_adc(ADC_OFF);
setup_psp(PSP_DISABLED);
setup_spi(FALSE);
setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DIV_BY_16,249,5);

usb_cdc_init();

usb_init();

while(!usb_cdc_connected()) {}

Clear_Incoming_Buffer();

for(;;)
{
usb_task();

if (usb_enumerated())
{
if(usb_cdc_kbhit())
{
getusbdata();
}
}
}
}
[/code]

any suggestions?

[Neutone]

This might help.
Its not based on a USB connection but it does meet MODBUS specs for a few functions and it compiles well.

This is a good document to develop from.
At a quick glance I saw several things that are a problem in the code you posted.
I don't think your CRC formula is right. Modicon Modbus Protocol Reference Guide PI–MBUS–300 Rev. J page 112 has an example of the bit shift method.
MODBUS and CCS do not store Int16 variables in the same byte order. When decoding and encoding packets the byte order needs to be swapped when coping registers.

[Guest]

Ok so it's running now, i accept and process the holding regs crc chechs ok, input data is 010300000001840A

so slave 1 function 3 address 0000 count 0001, the response sent back is 01030100f048 so slave 1 function 3 1 count 00 data and chksum, the chksums ae correct but i get a response back invalid checksum...... fom the master