main.cpp

00001 //SCIENTIFIC CAN ID'S 201 TO 255
00002 
00003 /***********
00004  Open box1  ||201|0|| can frame id 
00005  201 indirizzamento al sottosistema (scatole)
00006  202 indirizzamento dal sottosistema (scatole)
00007  203/4 indirizzamento dal sottosistema (envi)
00008  0  id scatola 1
00009  
00010  nel dato
00011  100 chiudi
00012  101 apri
00013  102 leggi
00014 
00015 
00016  CAN RX priorità piu bassa
00017  envi priorità normale
00018  box alta
00019 
00020 
00021 
00022 
00023 Costruzione frame CAN
00024  void sci::buildFrame(struct can_frame &frame, uint8_t id, can_commands command, int32_t value)
00025 {
00026  int len = 0;
00027  uint32_t new_id = id;
00028  new_id |= (uint32_t)command << 8;
00029  new_id |= 0x80000000;  100|0 0000 0000 0000 0  000 0000| 0000 0000
00030  frame.can_id = new_id;
00031 
00032  frame.data[len++] = value >> 24;
00033  frame.data[len++] = value >> 16;
00034  frame.data[len++] = value >> 8;
00035  frame.data[len++] = value;
00036 
00037  frame.can_dlc = len;
00038 }
00039 ************/
00040 #include "BOX.h"
00041 #include "mbed.h"
00042 #include "ENVIROMENTAL.h"
00043 
00044 //EVENT FLAGS
00045 #define OPEN_BOX  101
00046 #define CLOSE_BOX 100
00047 #define SEND_BOX_DATA_REQUEST 102
00048 
00049 Thread can_rx_thd;
00050 Thread box_thd;
00051 Thread envi_thd;
00052 
00053 EventFlags event_flags;
00054 
00055 CAN can(PB_8, PB_9);
00056 CANMessage msg;
00057 CANFormat CANextended;
00058 
00059 BOX box1(PA_9, PA_8, PB_0, PA_0, 1000, PA_4);
00060 BOX box2(PC_9, PC_8, PB_1, PA_1, 1000, PA_5);
00061 BOX box3(PC_7, PC_6, PB_2, PA_2, 1000, PA_6);
00062 I2C i2c(PB_7,PB_6);
00063 ENVIROMENTAL envi(PB_7, PB_6, PA_3, i2c);
00064 
00065 unsigned char box_sel;
00066 unsigned char box_cmd;
00067 
00068 char message_out[8];
00069 char envi_tx[8];
00070 char data_box[3][8];
00071 
00072 uint32_t new_id(int command, int id)
00073 {
00074     uint32_t id_message = id;
00075     id_message |= (uint32_t)command << 8;
00076     id_message |= 0x80000000;
00077 
00078     return id_message;
00079 }
00080 void box()
00081 {
00082     uint32_t flag_read = 0; 
00083     box1.initialize();
00084     box2.initialize(); 
00085     box3.initialize();
00086     int weight = 0;
00087     int resistence = 0;
00088     float temperature = 0;
00089     while(1)
00090     {
00091         flag_read = event_flags.wait_any(OPEN_BOX | CLOSE_BOX | SEND_BOX_DATA_REQUEST); //trigger this theand only if
00092         switch (flag_read)
00093         {
00094             case OPEN_BOX:
00095                 switch(box_sel)
00096                 {
00097                     case 1:
00098                         box1.move_servo(1000);
00099                         //open box 1
00100                         break;
00101                     case 2:
00102                         box2.move_servo(1000);
00103                         //open box 2
00104                         break;
00105                     case 3:
00106                         box3.move_servo(1000);
00107                         //open box 3
00108                         break;
00109                     default: break;
00110                 }
00111                 break;
00112             case CLOSE_BOX:
00113                 switch(box_sel)
00114                 {
00115                     case 1:
00116                         box2.move_servo(2200);
00117                         //close box 1
00118                         break;
00119                     case 2:
00120                         box2.move_servo(2200);
00121                         //close box 2
00122                         break;
00123                     case 3:
00124                         box2.move_servo(2200);
00125                         //close box 3
00126                         break;
00127                     default: break;
00128                 }
00129                 break;
00130 
00131             case SEND_BOX_DATA_REQUEST:
00132             //for every data request, a measure is made and then the data is sended on CAN
00133                 switch(box_sel)
00134                 {
00135                     case 1:
00136                         //make measurements box 1
00137                         weight = box1.get_weight();
00138                         resistence = box1.get_resistance();  //bisogna ancora "impacchettare i dati"
00139                         temperature = box1.get_temp();
00140                         //temperature 4 bytes
00141                         *(float*)(data_box[0]) = temperature;
00142                         //weight 2 bytes 
00143                         data_box[0][4] = (char)(weight >> 8);
00144                         data_box[0][5] = (char)(weight);
00145                         //resistence 2 bytes
00146                         data_box[0][6] = (char)(resistence >> 8);
00147                         data_box[0][7] = (char)(resistence);
00148                         break;
00149                     case 2:
00150                         //make measurements box 2
00151                         weight = box2.get_weight();
00152                         resistence = box2.get_resistance();
00153                         temperature = box2.get_temp();
00154                         //temperature 4 bytes
00155                         *(float*)(data_box[1]) = temperature;
00156                         //weight 2 bytes 
00157                         data_box[1][4] = (char)(weight >> 8);
00158                         data_box[1][5] = (char)(weight);
00159                         //resistence 2 bytes
00160                         data_box[1][6] = (char)(resistence >> 8);
00161                         data_box[1][7] = (char)(resistence);
00162                         break;
00163                     case 3:
00164                         //make measurements box 3
00165                         weight = box3.get_weight();
00166                         resistence = box3.get_resistance();
00167                         temperature = box3.get_temp();
00168                         //temperature 4 bytes
00169                         *(float*)(data_box[2]) = temperature;
00170                         //weight 2 bytes 
00171                         data_box[2][4] = (char)(weight >> 8);
00172                         data_box[2][5] = (char)(weight);
00173                         //resistence 2 bytes
00174                         data_box[2][6] = (char)(resistence >> 8);
00175                         data_box[2][7] = (char)(resistence);
00176                         break;
00177                     default: break;
00178                 }
00179                 for(int i=0; i<8; i++)
00180                 {
00181                     message_out[i] = data_box[box_sel][i];
00182                 }
00183                 can.write(CANMessage(new_id(202, box_sel),message_out, 8));
00184                 break;
00185             default: break;
00186         }
00187     }
00188 }
00189 
00190 void can_rx()
00191 {
00192     while(1)
00193     {
00194         can.read(msg);
00195 
00196         switch (msg.id)
00197         {
00198             case 201:
00199                 box_sel = msg.data[0];
00200                 box_cmd = msg.data[1];
00201                 event_flags.set(OPEN_BOX);
00202                 break;
00203             case 202:
00204                 box_sel = msg.data[0];
00205                 box_cmd = msg.data[1];
00206                 event_flags.set(CLOSE_BOX);
00207                 break;
00208             case 203:
00209                 box_sel = msg.data[0];
00210                 event_flags.set(SEND_BOX_DATA_REQUEST);
00211                 break;
00212 
00213         }
00214     }
00215 }
00216 
00217 void environmental() //make measurements and send to the can bus every second
00218 {     
00219     float temp,CO;
00220     uint32_t hum;
00221     int32_t pres;
00222     int lumen, infrared, uv;
00223 
00224    temp = envi.get_temp();    //return temperature from SI7021
00225   hum = envi.get_humidity(); //return humidity from SI7021
00226   pres =  envi.get_pressure();    //return pressure in Pa from MBP280
00227   CO = envi.get_CO();  //return CO from  mq-7
00228   lumen =  envi.get_lumen();   //return visible lumen from TSL2561
00229   infrared = envi.get_infrared();   //return infrared lumen from TSL2561
00230   uv = envi.get_uv();    //return uv intensity from VEML6070
00231   
00232   envi_tx[1]=(char)(temp);
00233   envi_tx[2]=(char)(hum);
00234   envi_tx[3]=(char)(pres);
00235   envi_tx[4]=(char)(CO);
00236   envi_tx[5]=(char)(lumen);
00237   envi_tx[6]=(char)(infrared);
00238   envi_tx[7]=(char)(uv);  
00239   
00240     
00241     can.write(CANMessage(210, envi_tx, 8));
00242         osDelay(1000);
00243 }
00244 
00245 
00246 int main()
00247 { 
00248     can.frequency(125000);
00249     box_thd.start(mbed::callback(box));
00250     envi_thd.start(environmental);
00251     can_rx_thd.start(can_rx);
00252 }
00253 
00254