xbee.cpp

00001 #include "xbee.h"
00002 
00003 Timeout timeOut;
00004 AnalogOut led_error(p18);
00005 void LED_TurnOff()
00006 {
00007     led_error = 0;
00008 }
00009 
00010 //--------------------------------------------------------------//
00011 // Fonction d'envoie de données pour ZigBee (Transmit request)
00012 // Testé et fonctionnel
00013 //--------------------------------------------------------------//
00014 void send(Serial* COM, CArray* message)
00015 {
00016     short opt_size = 0;
00017     COM->putc(0x7E); // Start delimiter
00018     COM->putc(0x00); // length MSB is always 0
00019     
00020     if (message->_FrameType == 0x08) // Les commandes AT ne reçoivent pas d'addresses
00021     {
00022         COM->putc(6);
00023     }
00024     else
00025     {
00026         COM->putc(message->size + 12 + message->opt_size);
00027     }
00028 
00029     COM->putc(message->_FrameType);
00030     COM->putc(0x01); // Frame ID
00031     
00032     if (message->_FrameType != 0x08) // Les commandes AT ne reçoivent pas d'addresses
00033     {
00034         COM->putc(message->_64bit.bit[0]);
00035         COM->putc(message->_64bit.bit[1]);
00036         COM->putc(message->_64bit.bit[2]);
00037         COM->putc(message->_64bit.bit[3]);
00038         COM->putc(message->_64bit.bit[4]);
00039         COM->putc(message->_64bit.bit[5]);
00040         COM->putc(message->_64bit.bit[6]);
00041         COM->putc(message->_64bit.bit[7]);
00042         COM->putc(message->_16bit.bit[0]);
00043         COM->putc(message->_16bit.bit[1]);
00044         
00045         for (int i = 0; i < message->opt_size; i++)
00046         {
00047             opt_size += message->options[i];
00048             COM->putc(message->options[i]);
00049         }
00050     }
00051     
00052     for (int j = 0; j < message->size; j++)
00053     {
00054         COM->putc(message->_ptr[j]);
00055     }
00056     COM->putc(calculate_checksum(message, 
00057         message->_FrameType + 
00058         0x01 +
00059         opt_size +      
00060         message->_16bit.bit[0] + 
00061         message->_16bit.bit[1] + 
00062         message->_64bit.bit[0] + 
00063         message->_64bit.bit[1] + 
00064         message->_64bit.bit[2] + 
00065         message->_64bit.bit[3] + 
00066         message->_64bit.bit[4] + 
00067         message->_64bit.bit[5] + 
00068         message->_64bit.bit[6] + 
00069         message->_64bit.bit[7]
00070     ));
00071 }
00072 //--------------------------------------------------------------//
00073 
00074 //--------------------------------------------------------------//
00075 // Fonction pour la réception de données (Packet Receive)
00076 // Testé et fonctionnel
00077 //--------------------------------------------------------------//
00078 void read(Serial* COM, CArray* returnValue)
00079 {
00080     char BYTE_ID = 0;
00081     char opts = 0;
00082     bool bIsTrame = false;
00083     while (true)
00084     if (COM->readable())
00085     {            
00086         char value = COM->getc();
00087         
00088         if (bIsTrame)
00089         {
00090             switch (BYTE_ID)
00091             {
00092             case 1:
00093                 break;
00094             case 2: // on ignore le 1, car c'est toujours 0x00
00095                 returnValue->size = value - 12;
00096                 break;
00097             case 3:                  
00098                 if (value != 0x90)
00099                     return;
00100                 returnValue->_FrameType = value;
00101                 break;
00102             case 4:
00103             case 5:
00104             case 6:
00105             case 7:
00106             case 8:
00107             case 9:
00108             case 10:
00109             case 11:
00110                 returnValue->_64bit.bit[BYTE_ID - 4] = value;
00111                 break;
00112             case 12:
00113             case 13: // <-- Addresse 16 bit de l'envoyeur ici
00114                 returnValue->_16bit.bit[BYTE_ID - 12] = value;
00115                 break;
00116             case 14: // je gère pas les options pour là
00117                 opts = value;
00118                 break;
00119             default:
00120                 if (BYTE_ID < 15 + returnValue->size)
00121                 {
00122                     if (returnValue->_ptr == NULL)
00123                         returnValue->_ptr = new char[returnValue->size];
00124                         
00125                     returnValue->_ptr[BYTE_ID - 15] = value;
00126                     break;
00127                 }
00128                 // Finalement, le checksum. On vérifie que c'est bon
00129                 if (value != calculate_checksum(returnValue, 
00130                         0x90 +
00131                         opts + 
00132                         returnValue->_16bit.bit[0] + 
00133                         returnValue->_16bit.bit[1] + 
00134                         returnValue->_64bit.bit[0] + 
00135                         returnValue->_64bit.bit[1] + 
00136                         returnValue->_64bit.bit[2] + 
00137                         returnValue->_64bit.bit[3] + 
00138                         returnValue->_64bit.bit[4] + 
00139                         returnValue->_64bit.bit[5] + 
00140                         returnValue->_64bit.bit[6] + 
00141                         returnValue->_64bit.bit[7]
00142                 ))
00143                 {
00144                     // Gestion d'erreur ici?
00145                     led_error = 1;
00146                     timeOut.attach(LED_TurnOff, 1);
00147                 }
00148                 return;
00149             }
00150         }
00151         else if (value == 0x7E)
00152             bIsTrame = true;
00153         else
00154             return;
00155 
00156         //wait_ms(3); // petit sleep pour recevoir un nouveau byte
00157         BYTE_ID++;
00158     }
00159 }
00160 //--------------------------------------------------------------//
00161 
00162 //--------------------------------------------------------------//
00163 // Fonction de checksum pour le protocole ZigBee
00164 // Testé et fonctionnel
00165 //--------------------------------------------------------------//
00166 char calculate_checksum(CArray* message, short header_size)
00167 {
00168     short sum = header_size;
00169     if (message != NULL)
00170     {
00171         for (int i = 0; i < message->size; i++)
00172         {
00173             sum += message->_ptr[i];
00174         }
00175     }
00176     return 0xFF - (sum & 0x00FF);
00177 }
00178 //--------------------------------------------------------------//
00179 
00180 void setPAN(Serial* COM, short pan_id)
00181 {
00182     CArray DATA_TO_SEND;
00183     for (int j = 0; j < 8; j++) // Je force tout à 0 pour les addresses
00184         DATA_TO_SEND._64bit.bit[j] = 0;
00185     DATA_TO_SEND._16bit.bit[0] = 0;
00186     DATA_TO_SEND._16bit.bit[1] = 0;
00187     DATA_TO_SEND.opt_size = 0;
00188     
00189     DATA_TO_SEND._FrameType = 0x08; // AT Command
00190     DATA_TO_SEND.size = 4;
00191     DATA_TO_SEND._ptr = new char[4];
00192     DATA_TO_SEND._ptr[0] = 'I';
00193     DATA_TO_SEND._ptr[1] = 'D';
00194     DATA_TO_SEND._ptr[2] = pan_id >> 8;
00195     DATA_TO_SEND._ptr[3] = pan_id & 0x00FF;
00196     
00197     send(COM, &DATA_TO_SEND);
00198     
00199     delete DATA_TO_SEND._ptr;
00200 }