Diff: pixy2.cpp

Revision:

28:f1dd68d07aec

Parent:

27:bee63ac9b70b

--- a/pixy2.cpp	Tue Jan 21 12:59:37 2020 +0000
+++ b/pixy2.cpp	Mon Feb 03 09:33:58 2020 +0000
@@ -1,9 +1,9 @@
 #include "pixy2.h"
 
 extern  int sommeDeControle,sommeRecue;
-extern char *ptr;
+extern Serial pc;
 
-PIXY2::PIXY2(PinName tx, PinName rx, int debit)
+PIXY2::PIXY2(PinName tx, PinName rx, int debit) : Pixy2_numBlocks(0), Pixy2_numVectors(0), Pixy2_numIntersections(0), Pixy2_numBarcodes(0)
 {   
     _Pixy2 = new Serial (tx, rx, debit);
     _Pixy2->attach (callback(this,&PIXY2::pixy2_getByte));
@@ -16,6 +16,19 @@
     free (Pixy2_buffer);
 }
 
+// POUR DEBUG //
+T_Pixy2State PIXY2::getEtat()
+{
+    return this->etat;
+}
+
+void PIXY2::affDataSize()
+{
+    pc.printf("dataSize : %d\n\r", this->dataSize);
+}
+// Pour détail d'une trame (a mettre dans la fct correspondante) :
+//pc.printf("pixSync : %d, pixType : %d, pixLength : %d, pixChecksum : %d\n\r", msg->pixSync, msg->pixType, msg->pixLength, msg->pixChecksum);
+
 /* Le programme utilise l'interruption de la liaison série pour recevoir le message et avancer la machine d'état pour permettre au programme de ne pas être bloquant en réception.
    Lorsqu'on appelle une fonction, elle retourne le code -2 pour signifier que le message de réponse de la caméra n'est pas completement reçu...
    Les étapes de fonctionnement sont les suivantes :
@@ -66,7 +79,7 @@
                 buffer = (T_Word*) &Pixy2_buffer[wPointer-1];                       // On pointe la structure sur les 2 derniers octets reçus
                 if ((buffer->mot == PIXY2_CSSYNC) || (buffer->mot == PIXY2_SYNC)) { // Si c'est un mot d'entête
                     etat = receivingHeader;                                         // On passe à l'état réception de l'entête
-                    hPointer = wPointer - 1;                                        // On initialise le pointeur de l'entête
+                    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 + PIXY2_NCSHEADERSIZE;
@@ -83,12 +96,14 @@
                                                                                     // Si on a reçu 6 octets pour une trame avec checksum ou 4 pour une trame sans checksum, c'est à dire un entête complet
                 etat = receivingData;                                               // On dit que l'on va de recevoir des données
                 dataSize = Pixy2_buffer[hPointer + 3];                              // On enregistre la taille de la payload
-            }
+                if (dataSize == 0)                                                  // Si on reçoit rien, on reset le processus
+                    etat = idle;
+            }    
             break;
 
-        case receivingData :                                                        // Si on est en train de recevoir des données.
+        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         
+                etat = dataReceived;                                          // Quand on a reçu toutes les données promises on dit que c'est OK         
             }
             break;
 
@@ -185,7 +200,7 @@
     T_pixy2SendBuffer   msg;
     int                 i = 0, dataSize = 2;
     msg.frame.header.pixSync = PIXY2_SYNC;
-    msg.frame.header.pixType = PIXY2_SET_LED;
+    msg.frame.header.pixType = PIXY2_SET_LAMP;
     msg.frame.header.pixLength = dataSize;
     msg.frame.data[0] = upper;
     msg.frame.data[1] = lower;
@@ -327,7 +342,7 @@
 
 T_pixy2ErrorCode PIXY2::pixy2_sndGetRGB (Word x, Word y, Byte saturate){
     T_pixy2SendBuffer   msg;
-    int                 i = 0, dataSize = 3;
+    int                 i = 0, dataSize = 5;
     msg.frame.header.pixSync = PIXY2_SYNC;
     msg.frame.header.pixType = PIXY2_ASK_VIDEO;
     msg.frame.header.pixLength = dataSize;
@@ -555,7 +570,7 @@
     return cr;
 }
 
-T_pixy2ErrorCode PIXY2::pixy2_getFPS (T_pixy2ReturnCode *framerate){
+T_pixy2ErrorCode PIXY2::pixy2_getFPS (T_pixy2ReturnCode **framerate){
 
     T_pixy2RcvHeader    *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
     T_pixy2ErrorCode    cr = PIXY2_OK;
@@ -576,7 +591,7 @@
                 }
             }
             if (msg->pixType == PIXY2_REP_FPS) {                                    // On vérifie que la trame est du type convenable (REPONSE FPS)
-                framerate = (T_pixy2ReturnCode*) &Pixy2_buffer[dPointer];           // On mappe le pointeur de structure sur le buffer de réception.
+                *framerate = (T_pixy2ReturnCode*) &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
@@ -643,11 +658,10 @@
             return PIXY2_BAD_CHECKSUM;                                              // Si le checksum est faux on retourne une erreur
         }
     }
-    if (msg->pixType == PIXY2_REP_LINE) {                                           // On vérifie que la trame est du type convenable (REPONSE LIGNE)
+    if (msg->pixType == PIXY2_REP_LINE) {                                       // On vérifie que la trame est du type convenable (REPONSE LIGNE)
         fPointer = dPointer;                                                        // On pointe sur la premiere feature
         do {
             lineFeature = (T_pixy2LineFeature*) &Pixy2_buffer[fPointer];            // On mappe le pointeur de structure sur le buffer de réception des features.
-            ptr = (char*) &Pixy2_buffer[fPointer];
             if (lineFeature->fType == PIXY2_VECTOR) {                               // On regarde si le type est vecteur
                 Pixy2_numVectors = lineFeature->fLength / sizeof(T_pixy2Vector);    // Si oui, on compte combien il y a de vecteurs
                 fdPointer = fPointer + 2;                                           // On pointe sur le premier élément de la feature
@@ -674,7 +688,7 @@
             }
         } while(fPointer < ((dataSize - 1) + dPointer));                            // Tant qu'il y a des données à traiter
     } else {                                                                        // Si ce n'est pas le bon type
-        if (msg->pixType == PIXY2_REP_ERROR) {                                      // Cela pourrait être une trame d'erreur
+        if (msg->pixType == PIXY2_REP_ERROR) {                                      // Cela pourrait être une trame d'erreur ou quand on ne reçoit rien
             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.
     }
@@ -690,10 +704,10 @@
     switch (etat) {
         case idle :                                                                 // Si la caméra est inactive
             wPointer = 0;                                                           // On remonte en haut du buffer
-            cr = PIXY2::pixy2_sndGetLineFeature(0, features);                       // On envoie la trame de demande de suivi de ligne
-            if (cr!= PIXY2_OK) return cr;                                           // S'il y a une erreur lors de l'envoi on ejecte !
+            cr = PIXY2::pixy2_sndGetLineFeature(0, features);                      // On envoie la trame de demande de suivi de ligne
+            if (cr!= PIXY2_OK) return cr;                                          // S'il y a une erreur lors de l'envoi on ejecte !
             etat = messageSent;                                                     // On passe à l'attente du message de réponse
-            cr = PIXY2_BUSY;                                                        // On signale à l'utilisateur que la caméra est maintenant occupée
+            cr = PIXY2_BUSY;                                                    // On signale à l'utilisateur que la caméra est maintenant occupée
             break;
             
         case dataReceived :                                                         // Quand on a reçu l'intégralité du message
@@ -901,7 +915,7 @@
     return cr;
 }
 
-T_pixy2ErrorCode PIXY2::pixy2_getRGB (Word x, Word y, Byte saturate, T_pixy2Pixel *pixel){
+T_pixy2ErrorCode PIXY2::pixy2_getRGB (Word x, Word y, Byte saturate, T_pixy2Pixel **pixel){
 
     T_pixy2RcvHeader    *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
     T_pixy2ErrorCode    cr = PIXY2_OK;
@@ -915,14 +929,14 @@
             cr = PIXY2_BUSY;                                                        // On signale à l'utilisateur que la caméra est maintenant occupée
             break;
             
-        case dataReceived :                                                         // Quand on a reçu l'intégralité du message
+        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]) != 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_ACK) {                                    // On vérifie que la trame est du type convenable (REPONSE ACK)
-                pixel = (T_pixy2Pixel*) &Pixy2_buffer[dPointer];                    // On mappe le pointeur de structure sur le buffer de réception.
+                *pixel = (T_pixy2Pixel*) &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