Diff: Pixy.cpp

Revision:

4:5982d904f7aa

Parent:

3:1e4c6d7a0053

--- a/Pixy.cpp	Thu May 31 17:36:49 2018 +0000
+++ b/Pixy.cpp	Fri Jun 01 10:11:53 2018 +0000
@@ -1,4 +1,7 @@
 #include "Pixy.h"
+/**
+ * Constructeur de l'objet
+ */
 
 PIXY::PIXY(PinName tx, PinName rx, int debit)
 {
@@ -13,22 +16,24 @@
 
 }
 
-
+/**
+ * Programme d'interruption gérant la réception des octets envoyés par la caméra sur la liaison série
+ */
 void PIXY::getPixyByte ()
 {
-    static T_msgBuffer      msgBuffer;
-    static T_wordBuffer     wordBuffer;
-    static T_pixyState      PIXY_state = none;
-    static Byte             byteCount = 0;
-    static int              PIXY_synced = 0;
+    static T_msgBuffer      msgBuffer;                              // Buffer de réception 32 bits
+    static T_wordBuffer     wordBuffer;                             // Buffer de réception 16 bits
+    static T_pixyState      PIXY_state = none;                      // Variable d'etat de la liaison 
+    static Byte             byteCount = 0;                          // Nb d'octets lu
+    static int              PIXY_synced = 0;                        // Etat de la liaison Pixy <-> carte
     Word                    i, somme;
     Byte                    dummy;
-    static Byte             PIXY_nbCCObjet = 0, PIXY_wCCObjet = 0;
-    static Byte             PIXY_nbNMObjet = 0, PIXY_wNMObjet = 0;
+    static Byte             PIXY_nbCCObjet = 0, PIXY_wCCObjet = 0;  // Variable interne de la FIFO Color Code
+    static Byte             PIXY_nbNMObjet = 0, PIXY_wNMObjet = 0;  // Variable interne de la FIFO normale
 
     Pixy_check = 0;
 
-    dummy = _Pixy->getc();                                                                // On stocke l'octet reçu dans une variable temporaire
+    dummy = _Pixy->getc();                                                              // On stocke l'octet reçu dans une variable temporaire
 
     if (!PIXY_synced) {                                                                 // Si la camera et la carte ne sont pas synchronisées
         msgBuffer.octet[byteCount] = dummy;                                             // On stocke l'octet reçu dans la première case dispo du tableau temporaire
@@ -80,7 +85,7 @@
                     byteCount++;                                                // On passe à l'octet suivant
                 } else {                                                        // Quand elle est pleine
                     byteCount = 0;                                              // On réinitialise
-                    PIXY_state = begin;                                         // On retourne à l'aiguillage
+                    PIXY_state = begin;                                         // On prépare le retour à l'aiguillage
 
                     // On calcule la somme de contrôle
                     somme = Pixy_NMFIFO[PIXY_wNMObjet].NMbloc.signature + Pixy_NMFIFO[PIXY_wNMObjet].NMbloc.x + Pixy_NMFIFO[PIXY_wNMObjet].NMbloc.y + Pixy_NMFIFO[PIXY_wNMObjet].NMbloc.width + Pixy_NMFIFO[PIXY_wNMObjet].NMbloc.height;
@@ -89,7 +94,7 @@
                         if (PIXY_wNMObjet < 19)     PIXY_wNMObjet++;            // On incrémente le pointeur d'écriture dans la FIFO Objet
                         else                        PIXY_wNMObjet = 0;
                         if (PIXY_nbNMObjet < 19)    PIXY_nbNMObjet++;           // On dit que l'on a un objet de plus
-                        else                        FlagPixyOverflow = 1;       // Si on a plus de 20 objets (en attente) => Overflow
+                        else                        FlagPixyOverflow = 1;       // Si on a plus de 20 objets en attente => Overflow
                     }
                 }
                 break;
@@ -100,7 +105,7 @@
                 if (byteCount < 13) byteCount++;                                // tant que la structure n'est pas pleine on passe à l'octet suivant
                 else {                                                          // Quand elle est pleine
                     byteCount = 0;                                              // On réinitialise
-                    PIXY_state = begin;                                         // On retourne à l'aiguillage
+                    PIXY_state = begin;                                         // On prepare le retour à l'aiguillage
 
                     // On calcule la somme de contrôle
                     somme = Pixy_CCFIFO[PIXY_wCCObjet].CCbloc.signature + Pixy_CCFIFO[PIXY_wCCObjet].CCbloc.x + Pixy_CCFIFO[PIXY_wCCObjet].CCbloc.y + Pixy_CCFIFO[PIXY_wCCObjet].CCbloc.width + Pixy_CCFIFO[PIXY_wCCObjet].CCbloc.height + Pixy_CCFIFO[PIXY_wCCObjet].CCbloc.angle;
@@ -128,17 +133,20 @@
                 PIXY_nbNMObjet = 0;
                 byteCount = 0;
 
-                wordBuffer.octet[byteCount%2] = dummy;                          // on stocke les octets reçus
+                // Comme on est dans une interruption, si on est ici c'est qu'on a reçu le code 0000, mais aussi le premier octet de la suite (le 0x55 du start)
+                // On va donc le stocker ici dans le tableau de réception du start.
+                wordBuffer.octet[byteCount%2] = dummy;                          // on stocke l'octet reçu
                 byteCount++;
+
                 PIXY_state = waitForStart;                                      // On passe en attente de la deuxième partie du code
                 break;
 
             case waitForStart :                                                 // Si on a reçu le code de début d'une nouvelle trame.
 
-                wordBuffer.octet[byteCount%2] = dummy;                          // on stocke les octets reçus
+                wordBuffer.octet[byteCount%2] = dummy;                          // on stocke l'octet reçu (ça en fait 2 avec celui reçu precedemment
                 byteCount++;
-                if (byteCount == 2) {                                           // Quand on a 2 octets
-                    byteCount = 0;
+                if (byteCount == 2) {                                           // On verifie quand même si on a bien 2 octets
+                    byteCount = 0;                                              // Si oui, on remet à 0 le comptage
                     if (wordBuffer.mot == 0xaa55) {                             // On vérifie qu'on a bien reçu l'entête de depart
                         PIXY_state = begin;                                     // Si c'est le cas, alors tout va bien et on va à l'aiguillage
                     } else {                                                    // Si ce n'est pas le cas
@@ -151,6 +159,9 @@
     }
 }
 
+/**
+ *  Transmet le nombre d'objets par catégorie dans la dernière trame reçue
+ */
 int PIXY::detectedObject (int* nbNM, int* nbCC)
 {
     *nbNM = (int)Pixy_NMObjet;
@@ -160,6 +171,9 @@
     return 0;
 }
 
+/**
+ *  Permet la lecture du plus ancien bloc CC de la FIFO se trouvant dans la dernière trame reçue
+ */
 T_pixyCCBloc PIXY::getCCBloc (void)
 {
     T_pixyCCBloc dummy;
@@ -181,6 +195,9 @@
     return dummy;
 }
 
+/**
+ *  Permet la lecture du plus ancien bloc NM de la FIFO se trouvant dans la dernière trame reçue
+ */
 T_pixyNMBloc PIXY::getNMBloc (void)
 {
     T_pixyNMBloc dummy;
@@ -202,6 +219,9 @@
     return dummy;
 }
 
+/**
+ * Permet le réglage de la luminosité
+ */
 void PIXY::setBrightness (Byte brightness)
 {
     _Pixy->putc(0); //Start
@@ -209,6 +229,9 @@
     _Pixy->putc(brightness);
 }
 
+/**
+ * Indique si une nouvelle image est disponible pour le traitement
+ */
 int PIXY::checkNewImage (void)
 {
     if (FlagPixy) {
@@ -219,6 +242,9 @@
     }
 }
 
+/**
+ * Indique l'état de la liaison entre la carte et la camera
+ */
 int PIXY::checkPixy (void)
 {
     return Pixy_check;