Diff: main.cpp

Revision:

5:d28a689b1635

Parent:

4:954ae88b6664

diff -r 954ae88b6664 -r d28a689b1635 main.cpp
--- a/main.cpp	Mon Oct 10 13:16:16 2016 +0000
+++ b/main.cpp	Fri Oct 14 13:12:34 2016 +0000
@@ -54,6 +54,203 @@
 #else
 DigitalOut led(LED1);
 #endif
+typedef unsigned char byte;
+unsigned short crc16(byte byteArray[], int length)
+{
+    unsigned char x;
+    unsigned short crc = 0xFFFF;
+    for (int i = 0; i < length; i++) {
+        x = crc >> 8 ^ byteArray[i];
+        x ^= x >> 4;
+        crc = (crc << 8) ^ ((unsigned short)(x << 12)) ^ ((unsigned short)(x << 5)) ^ ((unsigned short)x);
+    }
+    return crc;
+}
+
+void float2Bytes(float val, byte* bytes_array)
+{
+    union {
+        float float_variable;
+        byte temp_array[4];
+    } u;
+    u.float_variable = val;
+    memcpy(bytes_array, u.temp_array, 4);
+}
+
+class Position
+{
+public:
+    bool north;
+    bool south;
+    bool east;
+    bool west;
+    short degLon;
+    short degLat;
+    float minutesLong;
+    float minutesLat;
+    float secondesLong;
+    float secondesLat;
+
+    Position(bool north, bool south, bool east, bool west, short degLon, short degLat, float minutesLong, float minutesLat, float secondesLong, float secondesLat) {
+        this->north = north;
+        this->south = south;
+        this->east = east;
+        this->west = west;
+        this->degLon = degLon;
+        this->degLat = degLat;
+        this->minutesLong = minutesLong;
+        this->minutesLat = minutesLat;
+        this->secondesLong = secondesLong;
+        this->secondesLat = secondesLat;
+    }
+
+    Position(byte* posBytes) {
+        this->north = (posBytes[0] & 1);
+        this->south = (posBytes[0] & 2) >> 1;
+        this->east = (posBytes[0] & 4) >> 2;
+        this->west = (posBytes[0] & 8) >> 3;
+        this->degLon = posBytes[1] * 256 + posBytes[2];
+        this->degLat = posBytes[3] * 256 + posBytes[4];
+        this->minutesLong = *(float *)(posBytes + 5);
+        this->minutesLat = *(float *)(posBytes + 9);
+        this->secondesLong = *(float *)(posBytes + 13);
+        this->secondesLat = *(float *)(posBytes + 17);
+    }
+
+    byte* GetBytes() {
+        byte* posByte = (byte*)malloc(21 * sizeof(byte));
+        posByte[0] = 0;
+        if (this->north) {
+            posByte[0] = posByte[0] | 1;
+        }
+        if (this->south) {
+            posByte[0] = posByte[0] | 2;
+        }
+        if (this->east) {
+            posByte[0] = posByte[0] | 4;
+        }
+        if (this->west) {
+            posByte[0] = posByte[0] | 8;
+        }
+        posByte[1] = (this->degLon & 0xFF00) >> 8; //Bits de poids fort du short
+        posByte[2] = (this->degLon & 0x00FF); //Bits de poids faible
+        posByte[3] = (this->degLat & 0xFF00) >> 8; //Bits de poids fort du short
+        posByte[4] = (this->degLat & 0x00FF); //Bits de poids faible
+        float2Bytes(this->minutesLong, posByte + 5);
+        float2Bytes(this->minutesLat, posByte + 9);
+        float2Bytes(this->secondesLong, posByte + 13);
+        float2Bytes(this->secondesLat, posByte + 17);
+        return posByte;
+    }
+};
+class Date
+{
+public:
+    byte jour;
+    byte mois;
+    byte annee;
+    byte heure;
+    byte minutes;
+    byte secondes;
+
+    byte* GetBytes() {
+        byte* dateByte = (byte*)malloc(6 * sizeof(byte));
+        dateByte[0] = this->jour;
+        dateByte[1] = this->mois;
+        dateByte[2] = this->annee;
+        dateByte[3] = this->heure;
+        dateByte[4] = this->minutes;
+        dateByte[5] = this->secondes;
+        return dateByte;
+    }
+
+    Date(byte jour, byte mois, byte annee, byte heure, byte minutes, byte secondes) {
+        this->jour = jour;
+        this->mois = mois;
+        this->annee = annee;
+        this->heure = heure;
+        this->minutes = minutes;
+        this->secondes = secondes;
+    }
+
+    Date(byte* dateBytes) {
+        this->jour = dateBytes[0];
+        this->mois = dateBytes[1];
+        this->annee = dateBytes[2];
+        this->heure = dateBytes[3];
+        this->minutes = dateBytes[4];
+        this->secondes = dateBytes[5];
+    }
+
+};
+
+class Content
+{
+public:
+    short IDLapin;
+    Position* positionLapin;
+    Date* dateLapin;
+
+    byte* GetBytes() {
+        byte* contByte = (byte*)malloc(29 * sizeof(byte));
+        contByte[0] = (this->IDLapin & 0xFF00) << 8;
+        contByte[1] = (this->IDLapin & 0x00FF);
+        byte* dateBytes = this->dateLapin->GetBytes();
+        byte* positionBytes = this->positionLapin->GetBytes();
+        memcpy(contByte + 2, dateBytes, 6);
+        memcpy(contByte + 8, positionBytes, 21);
+        free(positionBytes);
+        free(dateBytes);
+        return contByte;
+    }
+
+    Content(short IDLapin, Position* positionLapin, Date* dateLapin) {
+        this->IDLapin = IDLapin;
+        this->positionLapin = positionLapin;
+        this->dateLapin = dateLapin;
+    }
+
+    Content(byte* contentBytes) {
+        this->IDLapin = contentBytes[0] * 256 + contentBytes[1];
+        byte* positionBytes = (byte*)malloc(21 * sizeof(byte));
+        byte* dateBytes = (byte*)malloc(6 * sizeof(byte));
+        memcpy(dateBytes, contentBytes + 2, 6);
+        memcpy(positionBytes, contentBytes + 8, 21);
+        this->positionLapin = (Position*)(new Position(positionBytes));
+        this->dateLapin =  (Date*)(new Date(dateBytes));
+        free(dateBytes);
+        free(positionBytes);
+    }
+};
+
+byte* CreateMessageBytes(Content* messageContent)
+{
+    byte* messByte = (byte*)malloc(32 * sizeof(byte));
+    messByte[0] = 20;
+    byte* contentBytes = messageContent->GetBytes();
+    unsigned short gotHash = crc16(contentBytes, 29);
+    messByte[1] = (gotHash & 0xFF00) >> 8;
+    messByte[2] = (gotHash & 0x00FF);
+    memcpy(messByte + 3, contentBytes, 29);
+    free(contentBytes);
+    return messByte;
+}
+
+enum MessageCheckResult { CORRECT = 1, CORRUPTED = 0, NOTFORUS = -1 };
+MessageCheckResult IsCorrectMessage(byte* bytesReceived, int mLength)
+{
+    if (mLength != 32) {
+        return NOTFORUS;
+    }
+    if (bytesReceived[0] != 20) {
+        return NOTFORUS;
+    }
+    if (crc16(bytesReceived + 3, 29) != (bytesReceived[1] * 256 + bytesReceived[2])) {
+        return CORRUPTED;
+    }
+    return CORRECT;
+}
+
 
 /*
  *  Global variables declarations
@@ -147,9 +344,11 @@
 
 #endif
 
-    Radio.Rx( 10*RX_TIMEOUT_VALUE  );
+    Radio.Rx(RX_TIMEOUT_VALUE  );
 
     while( 1 ) {
+       // Radio.Rx( 100*RX_TIMEOUT_VALUE  );
+        //SendStr("Bonjour Baudouin");
     }
 
 }
@@ -178,13 +377,16 @@
     RssiValue = rssi;
     SnrValue = snr;
     State = RX;
-    int i = 0;
-    for(i = 0; i<BufferSize ; i++) {
-        debug("%c", Buffer[i]);
+    debug_if( DEBUG_MESSAGE, "\n\r> Message recu\n\r" );
+    //debug("\r\n");
+    //debug("SNR = %d\r\n",snr);
+    //debug("RSSI = %d\r\n",rssi);
+    if (IsCorrectMessage(Buffer,BufferSize) == 1){
+        Content contentReceived = Content(Buffer+3);
+        debug("%d %d %d %d %d %d", contentReceived.dateLapin->jour, contentReceived.dateLapin->mois,contentReceived.dateLapin->annee ,contentReceived.dateLapin->heure, contentReceived.dateLapin->minutes, contentReceived.dateLapin->secondes);
     }
-    debug_if( DEBUG_MESSAGE, "\n\r> Message recu\n\r" );
     
-     Radio.Rx( 10*RX_TIMEOUT_VALUE  );
+    Radio.Rx(RX_TIMEOUT_VALUE  );
 }
 
 void OnTxTimeout( void )
@@ -200,6 +402,7 @@
     Buffer[ BufferSize ] = 0;
     State = RX_TIMEOUT;
     debug_if( DEBUG_MESSAGE, "> OnRxTimeout\n\r" );
+    Radio.Rx(RX_TIMEOUT_VALUE  );
 }
 
 void OnRxError( void )
@@ -207,5 +410,6 @@
     Radio.Sleep( );
     State = RX_ERROR;
     debug_if( DEBUG_MESSAGE, "> OnRxError\n\r" );
+    Radio.Rx( 10*RX_TIMEOUT_VALUE  );
 }