main.cpp

00001 #include "mbed.h"
00002 #include "CAN.h"
00003 #include "stdio.h"
00004 #include "stdlib.h"
00005 #include "string.h"
00006 #include "EthernetNetIf.h"
00007 #include "TCPSocket.h"
00008 
00009 Ticker ticker;      
00010 Serial pc(USBTX, USBRX);
00011 EthernetNetIf eth;
00012 DigitalOut write_activity(LED1); //CAN activity
00013 DigitalOut read_activity(LED2);
00014 DigitalOut ethernet_activity(LED3);    //Ethernet activity
00015 DigitalOut live(LED4);           //program running
00016 CAN can1(p9, p10);  // rd, td Transmitter
00017 CAN can2(p30, p29); // rd, td Monitor
00018 
00019 TCPSocket tcp;  //The listening port where requests are queued
00020 TCPSocket* link; //The port where accepted requests can communicate
00021 
00022 Host local(IpAddr(130,144,3,9), 24682); //mbed IP
00023 Host client;
00024 
00025 TCPSocketErr accErr;
00026 
00027 int counter = 0;
00028 int shift = 0;
00029 char candata[8];
00030 char pc_msg[128];
00031 char pc_canmsg[128];
00032 CANType pc_type;
00033 CANFormat pc_format;
00034 int pc_ID; //standard 11bit ID
00035 //int pc_IDe; //extended 29 (not used yet)
00036 int pc_length;
00037 int pcd0; int pcd1; int pcd2; int pcd3; int pcd4; int pcd5; int pcd6; int pcd7; //8 bytes data
00038 CANMessage msg;
00039 int size;
00040 char test;
00041 char *dump;
00042 char *buffer;
00043 
00044 
00045 /************************************************************************************
00046  *                                   CAN STUFF                                      *
00047  ************************************************************************************/
00048 void setdata(int d0, int d1, int d2, int d3, int d4, int d5, int d6, int d7) {
00049     candata[0] = (char) (d0); // LSB
00050     candata[1] = (char) (d1);
00051     candata[2] = (char) (d2);
00052     candata[3] = (char) (d3);
00053     candata[4] = (char) (d4);
00054     candata[5] = (char) (d5);
00055     candata[6] = (char) (d6);
00056     candata[7] = (char) (d7); // MSB
00057 }
00058 
00059 void canread() {
00060     pc.printf("Read:    [ ID: %d", msg.id);
00061     pc.printf(" Length: %d", msg.len);
00062     pc.printf(" Data: %x", msg.data[0]);
00063     pc.printf(" %x", msg.data[1]);
00064     pc.printf(" %x", msg.data[2]);
00065     pc.printf(" %x", msg.data[3]);
00066     pc.printf(" %x", msg.data[4]);
00067     pc.printf(" %x", msg.data[5]);
00068     pc.printf(" %x", msg.data[6]);
00069     pc.printf(" %x", msg.data[7]);
00070     pc.printf(" Type: %d", msg.type);
00071     pc.printf(" Format: %d ]\n", msg.format);
00072     
00073     read_activity = !read_activity;  //Blink!
00074     
00075     sprintf(pc_canmsg,"!%d %d %d %d %x %x %x %x %x %x %x %x",
00076     msg.format, msg.type, msg.id, msg.len, 
00077     msg.data[0], msg.data[1], msg.data[2], msg.data[3], 
00078     msg.data[4], msg.data[5], msg.data[6], msg.data[7]);
00079     link->send(pc_canmsg,sizeof(pc_canmsg));
00080 
00081 }
00082 
00083 void pc_msg_read() {
00084     // Data to be sent as ("_" = space):
00085     //!<format>_<type>_<ID>_<length>_<d0>_<d1>_<d2>_<d3>_<d4>_<d5>_<d6>_<d7> 
00086     for(shift=0;shift<128;shift++) {
00087         pc_msg[shift] = pc_msg[shift+1];
00088     }
00089     // Read pc_msg and extract all data
00090     sscanf(pc_msg,"%d %d %d %d %x %x %x %x %x %x %x %x",
00091     &pc_format, &pc_type, &pc_ID, &pc_length, 
00092     &pcd0, &pcd1, &pcd2, &pcd3, &pcd4, &pcd5, &pcd6, &pcd7);
00093     
00094     // Printing extracted data, mostly for testing
00095     pc.printf("Entered: [ ID: %d ",pc_ID);
00096     pc.printf("length: %d ",pc_length);
00097     pc.printf("data: %x %x %x %x %x %x %x %x ",
00098     pcd0, pcd1, pcd2, pcd3, pcd4, pcd5, pcd6, pcd7);
00099     pc.printf("type: %d ",pc_type);
00100     pc.printf("format: %d ]\n",pc_format);
00101     
00102     // Setting the data to CANMessage.data format
00103     setdata(pcd0, pcd1, pcd2, pcd3, pcd4, pcd5, pcd6, pcd7);
00104     
00105     // Transmitting CANMessage
00106     if(pc_type==0) {
00107         if(can1.write(CANMessage(pc_ID,candata,(char)pc_length,pc_type,pc_format))) {
00108             pc.printf("MBED:    [ Message compiled and sent. ]\n");
00109             write_activity = !write_activity;
00110         }
00111     }
00112     else if(pc_type==1) {
00113         if(can1.write(CANMessage(pc_ID,pc_format))) {
00114             pc.printf("MBED:    [ RTR Message compiled and sent. ]\n");
00115             write_activity = !write_activity;
00116         }
00117     }
00118 }
00119 
00120 
00121 /************************************************************************************
00122  *                                   TCP STUFF                                      *
00123  ************************************************************************************/
00124 void eth_act() {
00125     ethernet_activity = !ethernet_activity;
00126 } 
00127  
00128 void tcperrcheck(TCPSocketErr tcpsocketerr,char *phase) {
00129     switch(tcpsocketerr) {
00130     case TCPSOCKET_SETUP:   printf("Err:Setup\n");      break;  //TCPSocket not properly configured.
00131     case TCPSOCKET_TIMEOUT: printf("Err:Timeout\n");    break;  //Connection timed out.
00132     case TCPSOCKET_IF:      printf("Err:Interface\n");  break;  //Interface has problems, does not exist or is not initialized.
00133     case TCPSOCKET_MEM:     printf("Err:Memory\n");     break;  //Not enough mem.
00134     case TCPSOCKET_INUSE:   printf("Err:In use\n");     break;  //Interface / Port is in use.
00135     case TCPSOCKET_EMPTY:   printf("Err:Empty\n");      break;  //Connections queue is empty.
00136     case TCPSOCKET_RST:     printf("Err:Reset\n");      break;  //Connection was reset by remote host.
00137     case TCPSOCKET_OK:      if(phase == "bind") printf("Bound to port\n");
00138                             if(phase == "listen") printf("Listening\n");
00139                             if(phase == "accept") printf("Accepted: ");
00140                             break;  //Success.
00141     }
00142 }
00143 
00144 void onLinkSocketEvent(TCPSocketEvent e) {
00145     switch(e) {
00146         case TCPSOCKET_CONNECTED: eth_act(); printf("TCP Socket Connected\r\n"); break;
00147         case TCPSOCKET_WRITEABLE: eth_act(); printf("TCP Socket Writable\r\n"); break;
00148         case TCPSOCKET_READABLE: {
00149             //Can now read some data...
00150             eth_act(); 
00151             printf("TCP Socket Readable\r\n");
00152             // Read in any available data into the buffer
00153             int len = link->recv(pc_msg, 128);
00154             test = pc_msg[0];
00155             if (test == '!') {          // See if it's a valid message
00156                 pc_msg_read();          // Valid => read the message and extract the data
00157             }
00158             else {                      // Invalid data or leftover characters
00159                 pc.printf("Dumped:%s\n",pc_msg);
00160                 memset(pc_msg, 0, sizeof(pc_msg));
00161                 printf("%s",pc_msg);
00162             }
00163         }
00164         break;
00165         case TCPSOCKET_CONTIMEOUT: eth_act(); printf("TCP Socket Timeout\r\n"); break;
00166         case TCPSOCKET_CONRST: eth_act(); printf("TCP Socket CONRST\r\n"); break;
00167         case TCPSOCKET_CONABRT: eth_act(); printf("TCP Socket CONABRT\r\n"); break;
00168         case TCPSOCKET_ERROR: eth_act(); printf("TCP Socket Error\r\n"); break;
00169         case TCPSOCKET_DISCONNECTED: {
00170             //Close socket...
00171             printf("TCP Socket Disconnected\r\n");        
00172             link->close();
00173         }
00174         break;
00175         default: printf("DEFAULT\r\n"); 
00176     }
00177 }
00178 
00179 void onTCPSocketEvent(TCPSocketEvent e) {
00180     switch(e) {
00181         case TCPSOCKET_CONNECTED: eth_act(); printf("Connected\n"); break;
00182         case TCPSOCKET_ACCEPT: {
00183             eth_act();
00184             accErr = tcp.accept(&client,&link);
00185             tcperrcheck(accErr,"accept");
00186             link->setOnEvent(&onLinkSocketEvent);
00187             IpAddr clientIp = client.getIp();
00188             printf("Incoming TCP connection from %d.%d.%d.%d\r\n", 
00189             clientIp[0], clientIp[1], clientIp[2], clientIp[3]);
00190         }
00191         break;
00192         case TCPSOCKET_READABLE: eth_act(); printf("Readable\n"); break;
00193         case TCPSOCKET_WRITEABLE: eth_act(); printf("Writeable\n"); break;
00194         case TCPSOCKET_CONTIMEOUT: eth_act(); printf("Timeout\n"); break;
00195         case TCPSOCKET_CONRST: eth_act(); printf("Reset\n"); break;
00196         case TCPSOCKET_CONABRT: eth_act(); printf("Aborted\n"); break;
00197         case TCPSOCKET_ERROR: eth_act(); printf("Error\n"); break;
00198         case TCPSOCKET_DISCONNECTED: eth_act(); printf("Disconnected\n"); tcp.close(); break;    
00199     }
00200 }
00201 
00202 int main() {
00203     //----------------Initialization-----------------------
00204     can2.frequency(1000000);             //kbit/s
00205     can1.frequency(1000000);
00206     can2.monitor(1); //Works without this, in my case.
00207     pc.baud(115200); //Tested, works. Set terminal to the same. Also works with the c file.
00208     
00209     //Ethernet setup
00210     printf("Setting up ethernet\n");
00211     EthernetErr ethErr = eth.setup();
00212     if (ethErr) {
00213         printf("Error %d in setup.\n", ethErr);
00214         return -1;
00215     }
00216     IpAddr ip = eth.getIp();
00217     printf("Setup OK. ");
00218     printf("MBED IP is %d.%d.%d.%d\n", ip[0], ip[1], ip[2], ip[3]);
00219 
00220     //Generate method to deal with requests
00221     tcp.setOnEvent(&onTCPSocketEvent); 
00222     
00223     //Bind to local port
00224     printf("Init bind... ");
00225     TCPSocketErr bindErr = tcp.bind(local);
00226     tcperrcheck(bindErr, "bind");
00227             
00228     //Listen to local port
00229     printf("Init listen... ");
00230     TCPSocketErr listenErr = tcp.listen();
00231     tcperrcheck(listenErr, "listen");
00232     
00233     //Start timer
00234     Timer tmr;
00235     tmr.start();
00236     
00237 
00238     pc.printf("Please enter !<format>_<type>_<ID>_<length>_<d0>_<d1>_<d2>_<d3>_<d4>_<d5>_<d6>_<d7> ('_' = space)\n");
00239     while(1) {
00240         Net::poll();
00241         if(tmr.read() > 1) //Every second
00242         {
00243             tmr.reset();
00244             live=!live; //Show that we are alive
00245         }
00246         if (can2.read(msg)) {
00247             canread(); //Read when interupted.
00248         }
00249     }
00250 }