Diff: pixy2.cpp

Revision:

22:5f76404e2cbc

Parent:

20:8e3adcaab290

Child:

23:d6bbc4ec1f22

--- a/pixy2.cpp	Mon Apr 08 13:41:43 2019 +0000
+++ b/pixy2.cpp	Thu Nov 21 08:31:58 2019 +0000
@@ -1,11 +1,13 @@
 #include "pixy2.h"
 
+extern  int sommeDeControle,sommeRecue;
+
 PIXY2::PIXY2(PinName tx, PinName rx, int debit)
-{
+{   
     _Pixy2 = new Serial (tx, rx, debit);
     _Pixy2->attach (callback(this,&PIXY2::pixy2_getByte));
     etat = idle;
-    Pixy2_buffer = (Byte*) malloc (0x100);
+    Pixy2_buffer = (Byte*) malloc (0x100); 
 }
 
 PIXY2::~PIXY2()
@@ -56,6 +58,7 @@
     
     Pixy2_buffer[wPointer] = _Pixy2->getc();                                        // On stocke l'octet reçu dans la première case dispo du buffer de réception
     
+    
     switch (etat) {
         case messageSent :                                                          // Si on a envoyé une requete => on attend un entête
             if (wPointer > 0) {                                                     // On attend d'avoir reçu 2 octets
@@ -65,10 +68,10 @@
                     hPointer = wPointer - 1;                                        // On initialise le pointeur de l'entête
                     if (buffer->mot == PIXY2_SYNC) {
                         frameContainChecksum = 0;                                   // Si c'est un entête sans checksum, on mémorise qu'il n'y a pas de checksum à vérifier
-                        dPointer = hPointer + 4;
+                        dPointer = hPointer + PIXY2_NCSHEADERSIZE;
                     } else {
                         frameContainChecksum = 1;                                   // Sinon, on mémorise qu'il y a un checksum à vérifier
-                        dPointer = hPointer + 6;
+                        dPointer = hPointer + PIXY2_CSHEADERSIZE;
                     }
                 }                                                                   // Si on n'a pas de mot d'entête on attend d'en trouver un...
             }
@@ -83,7 +86,9 @@
             break;
 
         case receivingData :                                                        // Si on est en train de recevoir des données.
-            if (wPointer == ((dataSize - 1) + dPointer)) etat = dataReceived;       // Quand on a reçu toutes les données promises on dit que c'est OK
+            if (wPointer == ((dataSize - 1) + dPointer)) { 
+                etat = dataReceived;                                                // Quand on a reçu toutes les données promises on dit que c'est OK         
+            }
             break;
 
         default : // On ne traite volontairement ici pas tous les cas, en particulier idle et dataReceived. C'est à la fonction de le faire ! Le reste est lié à des réceptions de données.
@@ -339,7 +344,7 @@
 /*  La fonction est bloquante à l'envoi (pas vraiment le choix), mais elle est non bloquante en réception. On essayera de faire une fonction non bloquante en envoi avec write, mais c'est pas la priorité.
 Le principe c'est de stocker dans un buffer circulaire les données au fur et à mesure qu'elle sont reçues et de traiter uniquement en castant les infos. Pour cela, il faut recevoir et stocker. */
 
-T_pixy2ErrorCode PIXY2::pixy2_getVersion (T_pixy2Version *version){
+T_pixy2ErrorCode PIXY2::pixy2_getVersion (T_pixy2Version **ptrVersion){
 
     T_pixy2RcvHeader    *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
     T_pixy2ErrorCode    cr = PIXY2_OK;
@@ -355,18 +360,20 @@
             
         case dataReceived :                                                         // Quand on a reçu l'intégralité du message
             if (frameContainChecksum) {                                             // Si la trame contient un checksum
-                if ( !pixy2_validateChecksum (&Pixy2_buffer[hPointer]) ) {          // On lance la validation du checksum
+                if ( pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0 ) {      // On lance la validation du checksum
                     return PIXY2_BAD_CHECKSUM;                                      // Si le checksum est faux on retourne une erreur
                 }
             }
             if (msg->pixType == PIXY2_REP_VERS) {                                   // On vérifie que la trame est du type convenable (REPONSE VERSION)
-                version = (T_pixy2Version*) &Pixy2_buffer[dPointer];                // On mappe le pointeur de structure sur le buffer de réception.
+                *ptrVersion =   (T_pixy2Version*) &Pixy2_buffer[dPointer];          // On mappe le pointeur de structure sur le buffer de réception.
+                ptr =           (char*)  &Pixy2_buffer[dPointer];
+                                                                                        
             } else {                                                                // Si ce n'est pas le bon type
                 if (msg->pixType == PIXY2_REP_ERROR) {                              // Cela pourrait être une trame d'erreur
                     cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer];              // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
                 } else cr = PIXY2_TYPE_ERROR;                                       // Si le type ne correspond à rien de normal on signale une erreur de type.
             }
-            etat = idle;                                                            // On annoce que la pixy est libre
+            etat = idle;                                                            // On annonce que la pixy est libre
             break;
 
         default :                                                                   // Dans tous les autres cas
@@ -376,7 +383,7 @@
     return cr;
 }
 
-T_pixy2ErrorCode PIXY2::pixy2_getResolution (T_pixy2Resolution *resolution){
+T_pixy2ErrorCode PIXY2::pixy2_getResolution (T_pixy2Resolution **ptrResolution){
 
     T_pixy2RcvHeader    *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
     T_pixy2ErrorCode    cr = PIXY2_OK;
@@ -397,7 +404,7 @@
                 }
             }
             if (msg->pixType == PIXY2_REP_RESOL) {                                  // On vérifie que la trame est du type convenable (REPONSE RESOLUTION)
-                resolution = (T_pixy2Resolution*) &Pixy2_buffer[dPointer];          // On mappe le pointeur de structure sur le buffer de réception.
+                *ptrResolution = (T_pixy2Resolution*) &Pixy2_buffer[dPointer];      // On mappe le pointeur de structure sur le buffer de réception.
             } else {                                                                // Si ce n'est pas le bon type
                 if (msg->pixType == PIXY2_REP_ERROR) {                              // Cela pourrait être une trame d'erreur
                     cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer];              // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
@@ -937,6 +944,13 @@
     
     for (i=0; i<*(tab+3);i++)   sum = sum + *(tab + PIXY2_CSHEADERSIZE + i);
     tmp = (T_Word*) (tab+4);
+    
     if (tmp->mot == sum) return PIXY2_OK;
-    else return PIXY2_BAD_CHECKSUM;
+    else {
+        if (_DEBUG_) {
+            sommeDeControle = sum;
+            sommeRecue = tmp->mot;
+        }
+        return PIXY2_BAD_CHECKSUM;
+    }
 }