Peter Cooper
test code for our MBED board
Diff: can.c
- Revision:
- 1:6877bb99aa17
- Parent:
- 0:9edfcca7cd25
--- a/can.c Tue Jan 12 16:49:56 2010 +0000
+++ b/can.c Wed May 04 08:30:52 2011 +0000
@@ -1,8 +1,9 @@
#include "mbed.h"
-#include "diags.h"
-#include "CAN.h"
-
-Ticker ticker;
+#include "useful.h"
+#include "led.h"
+#include "cmd.h" /* used to get at the command code */
+#include "can_layer.h"
+#include "can.h"
// CAN_RS pin at Philips PCA82C250 can bus controller.
// activate transceiver by pulling this pin to GND.
@@ -15,42 +16,447 @@
CAN can(p30, p29);
int can_cnt=0;
+extern char station_id;
+char *can_str;
/******************************************/
/* */
-/* Can Bus Tests */
+/* Can Bus Send a string to remote add */
+/* */
+/******************************************/
+void can_send_string(char remote, char *str)
+{
+ unsigned char buf[0x8];
+ int len = strlen(str);
+ int id;
+ int cnt = 0;
+ int sub;
+ int pt = 0;
+
+ if(len > 128){
+ lprintf("Max string lenght of 128 bytes, current string %d bytes long, not sending\n",len);
+ return;
+ }
+
+ /* Set up the TX buffer for start packet */
+ can_clear_data(buf);
+ buf[0] = station_id; /* who we are */
+ buf[1] = len; /* number of bytes been sent, overall */
+ buf[2] = (len/8)+1; /* guess at how many packets it should be */
+
+ id = can_build_id(station_id,remote,CAN_SPRT);
+ if(!can.write(CANMessage(id, (char *)buf, 8))) {
+ lprintf("Error sending %s packet (%03x),",cancmd[CAN_SPRT],id);
+ can_dump_buffer(buf);
+ lprintf("\n");
+ return;
+ }
+ /* About to send the data */
+ sub = 1;
+ pt = 0;
+ while(sub > 0){
+ can_clear_data(buf);
+ sub = can_build_data(len,pt,(unsigned char*)str,buf);
+ id = can_build_id(station_id,remote,CAN_PRT);
+ if(!can.write(CANMessage(id | cnt, (char *)buf, 8))) {
+ lprintf("Error sending %s packet PRT (%03x),",cancmd[CAN_PRT],id);
+ can_dump_buffer(buf);
+ lprintf("\n");
+ } else {
+ pt = sub;
+ }
+ wait(0.1);
+ cnt++;
+ }
+
+ /* Set up the TX buffer for end packet */
+ can_clear_data(buf);
+ buf[0] = station_id; /* Who we are */
+ buf[1] = len; /* number of bytes sent */
+ buf[2] = cnt; /* atual packet count */
+ id = can_build_id(station_id,remote,CAN_EPRT);
+ if(!can.write(CANMessage(id, (char *)buf, 8))) {
+ lprintf("Error sending %s packet EPRT (%03x),",cancmd[CAN_EPRT],id);
+ can_dump_buffer(buf);
+ lprintf("\n");
+ return;
+ }
+}
+/******************************************/
+/* */
+/* Can Bus Send raw data to remote add */
+/* */
+/******************************************/
+void can_send_raw(char remote, char *str)
+{
+ lprintf("In Can Send String with '%02x%02x%02x%02x%02x%02x%02x%02x' going to %d\n",
+ str[0],str[1],str[2],str[3],str[4],str[5],str[6],str[7], remote);
+}
+/******************************************/
+/* */
+/* Can Bus Send BUS Reset */
+/* */
+/******************************************/
+void can_send_sync(void)
+{
+ unsigned char buf[0x8];
+ int id;
+
+ can_clear_data(buf);
+ id = can_build_id(0,0,CAN_SYNC);
+ if(!can.write(CANMessage(id, (char *)buf, 8))) {
+ lprintf("Error sending %s packet SYNC (%03x),",cancmd[CAN_SYNC],id);
+ lprintf("\n");
+ return;
+ }
+}
+/******************************************/
/* */
+/* Can Bus Send Intger to remote add */
+/* mode = 0, Int, mode = 1, Time */
/* */
+/******************************************/
+void can_send_int(int remote,int value,char mode)
+{
+ unsigned char buf[0x8];
+ int id;
+
+ can_clear_data(buf);
+ if(mode==0)
+ id = can_build_id(station_id,remote,CAN_INT);
+ else if(mode == 1)
+ id = can_build_id(station_id,remote,CAN_TIME);
+ else {
+ lprintf("can_send_int: unknown mode with %d\n",mode);
+ return;
+ }
+ buf[0]=value & 0x000000ff;
+ buf[1]=(value >> 8) & 0x000000ff;
+ buf[2]=(value >> 16) & 0x000000ff;
+ buf[3]=(value >> 24) & 0x000000ff;
+ if(!can.write(CANMessage(id, (char *)buf, 8))) {
+ lprintf("Error sending %s packet INT (%03x),",cancmd[CAN_INT],id);
+ can_dump_buffer(buf);
+ lprintf("\n");
+ return;
+ }
+}
+/******************************************/
/* */
+/* Can Bus Send Who is Out there mes */
+/* */
+/******************************************/
+void can_send_who(void)
+{
+ unsigned char buf[0x8];
+ int id;
+
+ can_clear_data(buf);
+ buf[0]=station_id;
+ id = can_build_id(station_id,0,CAN_WHOIS);
+ if(!can.write(CANMessage(id, (char *)buf, 8))) {
+ lprintf("Error sending %s packet WhoIs (%03x),",cancmd[CAN_WHOIS],id);
+ can_dump_buffer(buf);
+ lprintf("\n");
+ return;
+ }
+}
+/******************************************/
+/* */
+/* Can Bus Send I Am Out there mes */
+/* */
+/******************************************/
+void can_send_iam(int from)
+{
+ unsigned char buf[0x8];
+ int id;
+
+ can_clear_data(buf);
+ buf[0]=station_id;
+ buf[1]=from;
+ id = can_build_id(station_id,from,CAN_IAM);
+ if(!can.write(CANMessage(id, (char *)buf, 8))) {
+ lprintf("Error sending %s packet I'm Here (%03x),",cancmd[CAN_IAM],id);
+ can_dump_buffer(buf);
+ lprintf("\n");
+ return;
+ }
+}
+/******************************************/
+/* */
+/* CAN Bus Send a ticker message */
+/* */
+/******************************************/
+void can_ticker_tx(int v)
+{
+ unsigned char buf[0x8];
+ int id;
+
+ can_clear_data(buf);
+ buf[0]=station_id;
+ buf[4]=v;
+ id = can_build_id(station_id,0,CAN_IAM);
+ if(!can.write(CANMessage(id, (char *)buf, 8))) {
+ lprintf("Error sending %s packet CAN Ticker (%03x),",cancmd[CAN_IAM],id);
+ can_dump_buffer(buf);
+ lprintf("\n");
+ return;
+ }
+}
+/******************************************/
+/* */
+/* CAN Bus receiver, show the messages */
/* */
/******************************************/
-void send() {
- static char counter = 0;
- if (can.write(CANMessage(0x200, &counter, 1))) {
- printf("CanTx--> id: 0x200 dlc: 1 data: %x\n\r", counter);
- counter++;
- } else {
- printf("CanTx--> id: 0x200 dlc: 1 data: %x ERROR\n\r", counter);
- can.reset();
+void can_receive(void)
+{
+ CANMessage msg;
+ int pt;
+ time_t seconds;
+
+ if(can.read(msg)) {
+ switch(can_decode_id(msg.id,CAN_GET_CMD)){
+ case CAN_SYNC :
+ lprintf("CAN SYNC MESSAGE< what do we do :-)\n");
+ break;
+ case CAN_RAW :
+ break;
+ case CAN_SPRT :
+ if(can_str != NULL){
+ lprintf("trying to start a string packet, when the buffer is in use\n");
+ } else {
+ can_str = can_buffer_create(msg.data[1]+2);
+ }
+ break;
+ case CAN_EPRT :
+ find_cmd(can_str);
+ free(can_str);
+ can_str = NULL;
+ break;
+ case CAN_INT :
+ lprintf("Recieved an int 0x%08x\n", msg.data[0] | msg.data[1]<<8 | msg.data[2]<<16 | msg.data[3]<<24);
+ break;
+ case CAN_TIME :
+ seconds = msg.data[0] | msg.data[1]<<8 | msg.data[2]<<16 | msg.data[3]<<24;
+ set_time(seconds);
+ break;
+ case CAN_WHOIS :
+ wait(station_id/10);
+ can_send_iam(msg.data[0]);
+ break;
+ case CAN_IAM :
+ lprintf("Can_I_AM responce station id %02x, you where %02x\n",
+ msg.data[0],msg.data[1]);
+ break;
+ case CAN_PRT :
+ pt = can_decode_id(msg.id,CAN_GET_CNT);
+ can_str[(pt*8)+0] = msg.data[0];
+ can_str[(pt*8)+1] = msg.data[1];
+ can_str[(pt*8)+2] = msg.data[2];
+ can_str[(pt*8)+3] = msg.data[3];
+ can_str[(pt*8)+4] = msg.data[4];
+ can_str[(pt*8)+5] = msg.data[5];
+ can_str[(pt*8)+6] = msg.data[6];
+ can_str[(pt*8)+7] = msg.data[7];
+ break;
+ default :
+ lprintf("CAN receive, unknown message %d\n",can_decode_id(msg.id,CAN_GET_CMD));
+ }
}
- if(can_cnt==0){
- led_on(3);
- can_cnt=1;
- } else {
- led_off(3);
- can_cnt=0;
- }
- // toggle led1 after every transmission
}
-void test_can(int loop)
+
+/******************************************/
+/* */
+/* Setup the CAN bus for use */
+/* */
+/******************************************/
+void can_init(void)
{
// 500kbit/s
- can.frequency(500000);
+ // can.frequency(500000);
+ // 10kbits/s, for testing
+ can.frequency(10000);
// activate external can transceiver
can_Pca82c250SlopePin = 0;
- can_cnt=loop;
- // every 500ms
- ticker.attach(&send, 0.5);
+ can_str = NULL; /* Mark the input buffer as free */
+}
+/******************************************/
+/* */
+/* Setup the CAN message ID */
+/* */
+/******************************************/
+int can_build_id(char station, char dest, int cmd)
+{
+ int add, dst,c = 0,id = 0;
+ add = station << 8;
+ dst = dest << 4;
- printf("CAN message ticker started\n\r");
-}
\ No newline at end of file
+ switch(cmd) {
+ case CAN_SYNC :
+ c = 0;
+ add = 0;
+ dst = 0;
+ break;
+ case CAN_RAW :
+ c = 1;
+ break;
+ case CAN_SPRT :
+ c = 2;
+ break;
+ case CAN_EPRT :
+ c = 3;
+ break;
+ case CAN_INT :
+ c = 4;
+ break;
+ case CAN_TIME :
+ c = 5;
+ break;
+ case CAN_S2 :
+ c = 6;
+ break;
+ case CAN_S3 :
+ c = 7;
+ break;
+ case CAN_S4 :
+ c = 8;
+ break;
+ case CAN_S5 :
+ c = 9;
+ break;
+ case CAN_S6 :
+ c = 0xa;
+ break;
+ case CAN_S7 :
+ c = 0xb;
+ break;
+ case CAN_S8 :
+ c = 0xc;
+ break;
+ case CAN_S9 :
+ c = 0xd;
+ break;
+ case CAN_WHOIS :
+ c = 0xe;
+ break;
+ case CAN_IAM :
+ c = 0xf;
+ break;
+ case CAN_PRT :
+ c = 0x80;
+ break;
+ default :
+ lprintf("CAN Message Selector switch, unknown message %d\n",cmd);
+ return(-1);
+ }
+ /* Build the message ID */
+ id = c | add | dst;
+ return(id);
+}
+/******************************************/
+/* */
+/* Get the data from the can message ID */
+/* */
+/******************************************/
+int can_decode_id(int id, int what)
+{
+ switch(what){
+ case CAN_SENDER_ID : /* Who sent the message */
+ return((id & 0xf00)>>8);
+ case CAN_OUR_ID : /* who is it for */
+ return((id &0x070)>>4);
+ case CAN_IS_PRT : /* is it a string packet */
+ return((id &0x080));
+ case CAN_GET_CNT : /* Get the packet count value */
+ return((id & 0x00f));
+ case CAN_GET_CMD : /* count and cmd live on the first 4 bits */
+ if(can_decode_id(id,CAN_IS_PRT))
+ return(CAN_PRT);
+ return((id & 0x00f));
+ default :
+ lprintf("Unknown CAN Id decode request %02x\n",what);
+ return(0);
+ }
+}
+/******************************************/
+/* */
+/* Build a buffer for transmit, from a */
+/* source buffer, of variable length */
+/* this code is re-entrant, state held */
+/* in the parent routine */
+/* Safe for raw, and string data */
+/* */
+/******************************************/
+int can_build_data(int len, int pt, unsigned char *data, unsigned char *buffer)
+{
+ int a = 0;
+ int px;
+
+ px = pt;
+
+ while(a!=MAX_CAN_BUF){
+ if(px<=len){
+ buffer[a] = data[px];
+ px++;
+ } else {
+ buffer[a] = 0x00;
+ }
+ a++;
+ }
+ if(px <= len)
+ return(px);
+ else
+ return(0);
+}
+/******************************************/
+/* */
+/* Clear the TX buffer to Zero's */
+/* Safe for raw, and string data */
+/* */
+/******************************************/
+void can_clear_data(unsigned char *buffer)
+{
+ int a = 0;
+ while(a != MAX_CAN_BUF){
+ buffer[a] = 0x00;
+ a++;
+ }
+}
+/******************************************/
+/* */
+/* Dump the TX buffer to the user */
+/* Safe for raw, and string data */
+/* */
+/******************************************/
+void can_dump_buffer(unsigned char *buffer)
+{
+ int a = 0;
+ lprintf(" ");
+ while(a != MAX_CAN_BUF){
+ lprintf("%02x",buffer[a]);
+ if(buffer[a] > 0x20 & buffer[a] < 0x7f)
+ lprintf("(%c),",buffer[a]);
+ else
+ lprintf(", ");
+ a++;
+ }
+}
+/******************************************/
+/* */
+/* Create a new string buffer for can RX */
+/* */
+/******************************************/
+char *can_buffer_create(int size)
+{
+ char *str;
+ int pt;
+
+ str = (char *)malloc(sizeof(char)*size);
+ pt = 0;
+ while(pt!=size){
+ str[pt]='\0';
+ pt++;
+ }
+ return(str);
+}
+