can.cpp

00001 #include "mbed.h"
00002 #include "car_config.hpp"
00003 #include "net.hpp"
00004 #include "can.hpp"
00005 #include "rtos.h"
00006 
00007 /*** GLOBAL DATA ***/
00008 
00009 //message buffers
00010 can_cmd_body_t can_cmd_body;
00011 can_sts_body_t can_sts_body;
00012 can_cmd_engine_t can_cmd_engine;
00013 can_cmd_time_t can_cmd_time;
00014 can_cmd_diag_t can_cmd_diag;
00015 can_sts_diag_t can_sts_diag;
00016 can_cmd_camera_t can_cmd_camera;
00017 
00018 /*** LOCAL DATA ***/
00019 
00020 //transceiver
00021 static CAN can(HW_CAN_TX, HW_CAN_RX);
00022 
00023 //countdown for missing messages
00024 uint8 can_missing[CAN_RX_PERIODIC_MSG];
00025 
00026 /*** LOCAL FUNCTION PROTOTYPES ***/
00027 
00028 //read if there are messages in the buffer
00029 void can_rx();
00030 
00031 //send pending messages
00032 void can_tx();
00033 
00034 /*** GLOBAL FUNCTIONS ***/
00035 
00036 void init_can()
00037 {
00038   for (int i = 0; i < CAN_RX_PERIODIC_MSG; i++)
00039     can_missing[i] = CAN_MISSING_DETECTION;
00040 }
00041 
00042 void thread_can (void const *args)
00043 {
00044   while(1) {
00045     can_rx();
00046     can_tx();
00047     Thread::wait(CAN_THREAD_PERIOD);
00048   }
00049 }
00050 
00051 bool can_msg_is_missing (uint8 msg_id)
00052 {
00053   if (msg_id < CAN_RX_PERIODIC_MSG)
00054     return (can_missing[msg_id] == 0);
00055   return true;
00056 }
00057 
00058 /*** LOCAL FUNCTIONS ***/
00059 
00060 void can_rx () {
00061   CANMessage message;
00062 
00063   do {
00064     if (can.read(message) == 0)
00065       break;
00066     switch(message.id) {
00067 #ifdef NET_RX_CMD_BODY
00068       case CAN_CMD_BODY_ID:
00069         can_cmd_body.payload.buf[0] = message.data[0];
00070         can_cmd_body.payload.buf[1] = message.data[1];
00071         can_cmd_body.payload.buf[2] = message.data[2];
00072         can_cmd_body.payload.buf[3] = message.data[3];
00073         can_cmd_body.flag = CAN_FLAG_RECEIVED;
00074         can_missing[CAN_MISSING_CMD_BODY_ID] = CAN_MISSING_DETECTION+1;
00075         break;
00076 #endif
00077 #ifdef NET_RX_STS_BODY
00078       case CAN_STS_BODY_ID:
00079         can_sts_body.payload.buf[0] = message.data[0];
00080         can_sts_body.payload.buf[1] = message.data[1];
00081         can_sts_body.payload.buf[2] = message.data[2];
00082         can_sts_body.payload.buf[3] = message.data[3];
00083         can_sts_body.payload.buf[4] = message.data[4];
00084         can_sts_body.payload.buf[5] = message.data[5];
00085         can_sts_body.payload.buf[6] = message.data[6];
00086         can_sts_body.payload.buf[7] = message.data[7];
00087         can_sts_body.flag = CAN_FLAG_RECEIVED;
00088         can_missing[CAN_MISSING_STS_BODY_ID] = CAN_MISSING_DETECTION+1;
00089         break;
00090 #endif
00091 #ifdef NET_RX_CMD_ENGINE
00092       case CAN_CMD_ENGINE_ID:
00093         can_cmd_engine.payload.buf[0] = message.data[0];
00094         can_cmd_engine.payload.buf[1] = message.data[1];
00095         can_cmd_engine.payload.buf[2] = message.data[2];
00096         can_cmd_engine.payload.buf[3] = message.data[3];
00097         can_cmd_engine.flag = CAN_FLAG_RECEIVED;
00098         can_missing[CAN_MISSING_CMD_ENGINE_ID] = CAN_MISSING_DETECTION+1;
00099         break;
00100 #endif
00101 #ifdef NET_RX_CMD_TIME
00102       case CAN_CMD_TIME_ID:
00103         can_cmd_time.payload.buf[0] = message.data[0];
00104         can_cmd_time.payload.buf[1] = message.data[1];
00105         can_cmd_time.payload.buf[2] = message.data[2];
00106         can_cmd_time.payload.buf[3] = message.data[3];
00107         can_cmd_time.flag = CAN_FLAG_RECEIVED;
00108         break;
00109 #endif
00110 #ifdef NET_RX_CMD_DIAG
00111       case CAN_CMD_DIAG_ID:
00112         can_cmd_diag.payload.buf[0] = message.data[0];
00113         can_cmd_diag.payload.buf[1] = message.data[1];
00114         can_cmd_diag.payload.buf[2] = message.data[2];
00115         can_cmd_diag.payload.buf[3] = message.data[3];
00116         can_cmd_diag.payload.buf[4] = message.data[4];
00117         can_cmd_diag.payload.buf[5] = message.data[5];
00118         can_cmd_diag.payload.buf[6] = message.data[6];
00119         can_cmd_diag.payload.buf[7] = message.data[7];
00120         can_cmd_diag.flag = CAN_FLAG_RECEIVED;
00121         break;
00122 #endif
00123 #ifdef NET_RX_STS_DIAG
00124       case CAN_STS_DIAG_ID:
00125         can_sts_diag.payload.buf[0] = message.data[0];
00126         can_sts_diag.payload.buf[1] = message.data[1];
00127         can_sts_diag.payload.buf[2] = message.data[2];
00128         can_sts_diag.payload.buf[3] = message.data[3];
00129         can_sts_diag.flag = CAN_FLAG_RECEIVED;
00130         break;
00131 #endif
00132 #ifdef NET_RX_CMD_CAMERA
00133       case CAN_CMD_CAMERA_ID:
00134         can_cmd_camera.payload.buf[0] = message.data[0];
00135         can_cmd_camera.payload.buf[1] = message.data[1];
00136         can_cmd_camera.flag = CAN_FLAG_RECEIVED;
00137         can_missing[CAN_MISSING_CMD_CAMERA_ID] = CAN_MISSING_DETECTION+1;
00138         break;
00139 #endif
00140       default:
00141         break;
00142     };
00143   } while(1);
00144 
00145   for (int i = 0; i < CAN_RX_PERIODIC_MSG; i++)
00146     if (can_missing[i] > 0)
00147       can_missing[i]--;
00148 }
00149 
00150 void can_tx () {
00151   /** periodic messages */
00152 #ifdef NET_TX_CMD_BODY
00153   if (can_cmd_body.flag == 0) {
00154     wait(2); //wait 2 milliseconds between 2 consecutive transmissions
00155     if (!can.write(CANMessage(CAN_CMD_BODY_ID,
00156                               (char*)(&(can_cmd_body.payload.buf)),
00157                               CAN_CMD_PAYLOAD_BODY)))
00158       printf("SEND CMD_BODY NOT OK\r\n");
00159     can_cmd_body.flag = CAN_CMD_BODY_PERIOD;
00160   }
00161   can_cmd_body.flag--;
00162 #endif
00163 #ifdef NET_TX_STS_BODY
00164   if (can_sts_body.flag == 0) {
00165     wait(2); //wait 2 milliseconds between 2 consecutive transmissions
00166     if (!can.write(CANMessage(CAN_STS_BODY_ID,
00167                               (char*)(&(can_sts_body.payload.buf)),
00168                               CAN_STS_PAYLOAD_BODY)))
00169       printf("SEND STS_BODY NOT OK\r\n");
00170     can_sts_body.flag = CAN_STS_BODY_PERIOD;
00171   }
00172   can_sts_body.flag--;
00173 #endif
00174 #ifdef NET_TX_CMD_ENGINE
00175   if (can_cmd_engine.flag == 0) {
00176     wait(2); //wait 2 milliseconds between 2 consecutive transmissions
00177     if (!can.write(CANMessage(CAN_CMD_ENGINE_ID,
00178                               (char*)(&(can_cmd_engine.payload.buf)),
00179                               CAN_CMD_PAYLOAD_ENGINE)))
00180       printf("SEND CMD_ENGINE NOT OK\r\n");
00181     can_cmd_engine.flag = CAN_CMD_ENGINE_PERIOD;
00182   }
00183   can_cmd_engine.flag--;
00184 #endif
00185 #ifdef NET_TX_CMD_CAMERA
00186   if (can_cmd_camera.flag == 0) {
00187     wait(2); //wait 2 milliseconds between 2 consecutive transmissions
00188     if (!can.write(CANMessage(CAN_CMD_CAMERA_ID,
00189                               (char*)(&(can_cmd_camera.payload.buf)),
00190                               CAN_CMD_PAYLOAD_CAMERA)))
00191       printf("SEND CMD_CAMERA NOT OK\r\n");
00192     can_cmd_camera.flag = CAN_CMD_CAMERA_PERIOD;
00193   }
00194   can_cmd_camera.flag--;
00195 #endif
00196 
00197   /** event messages */
00198 #ifdef NET_TX_CMD_DIAG
00199   if (can_cmd_diag.flag == CAN_FLAG_SEND) {
00200     wait(2); //wait 2 milliseconds between 2 consecutive transmissions
00201     if (!can.write(CANMessage(CAN_CMD_DIAG_ID,
00202                              (char*)(&(can_cmd_diag.payload.buf)),
00203                              CAN_CMD_PAYLOAD_DIAG)))
00204       printf("SEND CMD_DIAG NOT OK\r\n");
00205     can_cmd_diag.flag = CAN_FLAG_EMPTY;
00206   }
00207 #endif
00208 #ifdef NET_TX_STS_DIAG
00209   if (can_sts_diag.flag == CAN_FLAG_SEND) {
00210     wait(2); //wait 2 milliseconds between 2 consecutive transmissions
00211     if (!can.write(CANMessage(CAN_STS_DIAG_ID,
00212                              (char*)(&(can_sts_diag.payload.buf)),
00213                              CAN_STS_PAYLOAD_DIAG)))
00214       printf("SEND STS_DIAG NOT OK\r\n");
00215     can_sts_diag.flag = CAN_FLAG_EMPTY;
00216   }
00217 #endif
00218 #ifdef NET_TX_CMD_TIME
00219   if (can_cmd_time.flag == CAN_FLAG_SEND) {
00220     wait(2); //wait 2 milliseconds between 2 consecutive transmissions
00221     if (!can.write(CANMessage(CAN_CMD_TIME_ID,
00222                              (char*)(&(can_cmd_time.payload.buf)),
00223                              CAN_CMD_PAYLOAD_TIME)))
00224       printf("SEND CMD_TIME NOT OK\r\n");
00225     can_cmd_time.flag = CAN_FLAG_EMPTY;
00226   }
00227 #endif
00228 }