Waël Hazami
/
Lib_PIXY2
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Diff: pixy2.cpp
- Revision:
- 12:7493191dd1dc
- Parent:
- 11:68ef9f85e40e
- Child:
- 14:c0eda1e35a00
diff -r 68ef9f85e40e -r 7493191dd1dc pixy2.cpp
--- a/pixy2.cpp Tue Mar 12 14:16:53 2019 +0000
+++ b/pixy2.cpp Tue Mar 12 16:51:31 2019 +0000
@@ -330,26 +330,25 @@
if (msg->pixType == PIXY2_REP_VERS) { // On vérifie que la trame est du type convenable
version = (T_pixy2Version*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
// On mappe le pointeur de version sur la donnée stockée dans la FIFO (ligne précédente)
- etat = idle; // Et on annoce que la pixy est libre
} else {
if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
- // On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
+ // 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
}
} else cr = PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur aussi !
} else { // S'il n'y a pas de checksum (pas normal mais on ne sait jamais)
if (msg->pixType == PIXY2_REP_VERS) { // On vérifie que la trame est du type convenable
version = (T_pixy2Version*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
- // Si le checksum et le type sont bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
- etat = idle; // Et on annoce que la pixy est libre
+ // Si le type est bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
} else {
if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
- // On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
+ // 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
}
}
+ etat = idle; // Et on annoce que la pixy est libre
break;
default : // Dans tous les autres cas
@@ -378,7 +377,57 @@
if (msg->pixType == PIXY2_REP_RESOL) { // On vérifie que la trame est du type convenable
resolution = (T_pixy2Resolution*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
// Si le checksum et le type sont bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
- etat = idle; // Et on annoce que la pixy est libre
+ } else {
+ if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
+ cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
+ // 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
+ }
+ } else cr = PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur aussi !
+ } else { // S'il n'y a pas de checksum (pas normal mais on ne sait jamais)
+ if (msg->pixType == PIXY2_REP_RESOL) { // On vérifie que la trame est du type convenable
+ resolution = (T_pixy2Resolution*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // Si le type est bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ } else {
+ if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
+ cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // 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
+ }
+ }
+ etat = idle; // Et on annoce que la pixy est libre
+ break;
+
+ default : // Dans tous les autres cas
+ cr = PIXY2_BUSY; // On signale que la caméra est occupée.
+ break;
+ }
+ return cr;
+}
+
+
+T_pixy2ErrorCode PIXY2::pixy2_setCameraBrightness (Byte brightness){
+
+ T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[rPointer];
+ T_pixy2ErrorCode cr = PIXY2_OK;
+ T_pixy2ReturnCode retour;
+
+ switch (etat) {
+ case idle : // Si la caméra est inactive
+ PIXY2::pixy2_sndSetCameraBrightness (brightness); // On envoie la trame de règlage de la luminosité
+ etat = messageSent; // On passe à l'attente du message de réponse
+ rPointer = wPointer; // On enregistre la position du pointeur de FIFO
+ 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
+ if (frameContainChecksum) { // Si la trame contient un checksum
+ if ( pixy2_validateChecksum (&Pixy2_buffer[rPointer]) ) { // On lance la validation du checksum
+ if (msg->pixType == PIXY2_ACK) { // On vérifie que la trame est du type convenable
+ retour = *(T_pixy2ReturnCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
+ // Si le checksum et le type sont bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ if (retour.pixReturn != PIXY2_OK) cr = (T_pixy2ErrorCode) retour.pixReturn;
+ // Si la Pixy n'aquite pas l'ordre, on retourne l'erreur signalée
} else {
if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
@@ -387,17 +436,71 @@
}
} else cr = PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur aussi !
} else { // S'il n'y a pas de checksum (pas normal mais on ne sait jamais)
- if (msg->pixType == PIXY2_REP_RESOL) { // On vérifie que la trame est du type convenable
- resolution = (T_pixy2Resolution*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
- // Si le checksum et le type sont bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
- etat = idle; // Et on annoce que la pixy est libre
+ if (msg->pixType == PIXY2_ACK) { // On vérifie que la trame est du type convenable
+ retour = *(T_pixy2ReturnCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // Si le type est bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ if (retour.pixReturn != PIXY2_OK) cr = (T_pixy2ErrorCode) retour.pixReturn;
+ // Si la Pixy n'aquite pas l'ordre, on retourne l'erreur signalée
} else {
if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
// On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
- }else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur
+ }else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur
}
}
+ etat = idle; // Et on annoce que la pixy est libre
+ break;
+
+ default : // Dans tous les autres cas
+ cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
+ break;
+ }
+ return cr;
+}
+
+T_pixy2ErrorCode PIXY2::pixy2_setServos (Word s0, Word s1){
+
+ T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[rPointer];
+ T_pixy2ErrorCode cr = PIXY2_OK;
+ T_pixy2ReturnCode retour;
+
+ switch (etat) {
+ case idle : // Si la caméra est inactive
+ PIXY2::pixy2_sndSetServo (s0, s1); // On envoie la trame de règlage des servos moteurs
+ etat = messageSent; // On passe à l'attente du message de réponse
+ rPointer = wPointer; // On enregistre la position du pointeur de FIFO
+ 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
+ if (frameContainChecksum) { // Si la trame contient un checksum
+ if ( pixy2_validateChecksum (&Pixy2_buffer[rPointer]) ) { // On lance la validation du checksum
+ if (msg->pixType == PIXY2_ACK) { // On vérifie que la trame est du type convenable
+ retour = *(T_pixy2ReturnCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
+ // Si le checksum et le type sont bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ if (retour.pixReturn != PIXY2_OK) cr = (T_pixy2ErrorCode) retour.pixReturn;
+ // Si la Pixy n'aquite pas l'ordre, on retourne l'erreur signalée
+ } else {
+ if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
+ cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
+ // On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
+ }else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur
+ }
+ } else cr = PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur aussi !
+ } else { // S'il n'y a pas de checksum (pas normal mais on ne sait jamais)
+ if (msg->pixType == PIXY2_ACK) { // On vérifie que la trame est du type convenable
+ retour = *(T_pixy2ReturnCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // Si le type est bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ if (retour.pixReturn != PIXY2_OK) cr = (T_pixy2ErrorCode) retour.pixReturn;
+ // Si la Pixy n'aquite pas l'ordre, on retourne l'erreur signalée
+ } else {
+ if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
+ cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
+ }else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur
+ }
+ }
+ etat = idle; // Et on annoce que la pixy est libre
break;
default : // Dans tous les autres cas
@@ -407,21 +510,166 @@
return cr;
}
+T_pixy2ErrorCode PIXY2::pixy2_setLED (Byte red, Byte green, Byte blue){
-T_pixy2ErrorCode PIXY2::pixy2_setCameraBrightness (Byte brightness){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_setServos (Word s0, Word s1){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_setLED (Byte red, Byte green, Byte blue){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_setLamp (Byte upper, Byte lower){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_getFPS (T_pixy2ReturnCode *framerate){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_getBlocks (Byte sigmap, Byte maxBloc){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_getMainFeature (Byte features){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_getAllFeature (Byte features){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_setMode (Byte mode){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_setNexTurn (Word angle){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_setDefaultTurn (Word angle){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_setVector (Byte vectorIndex){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_ReverseVector (void){return 0;}
-T_pixy2ErrorCode PIXY2::pixy2_getRGB (Word x, Word y, Byte saturate, T_pixy2Pixel *pixel){return 0;}
+ T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[rPointer];
+ T_pixy2ErrorCode cr = PIXY2_OK;
+ T_pixy2ReturnCode retour;
+
+ switch (etat) {
+ case idle : // Si la caméra est inactive
+ PIXY2::pixy2_sndSetLED (red, green, blue); // On envoie la trame de règlage des composantes de la LED RGB
+ etat = messageSent; // On passe à l'attente du message de réponse
+ rPointer = wPointer; // On enregistre la position du pointeur de FIFO
+ 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
+ if (frameContainChecksum) { // Si la trame contient un checksum
+ if ( pixy2_validateChecksum (&Pixy2_buffer[rPointer]) ) { // On lance la validation du checksum
+ if (msg->pixType == PIXY2_ACK) { // On vérifie que la trame est du type convenable
+ retour = *(T_pixy2ReturnCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
+ // Si le checksum et le type sont bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ if (retour.pixReturn != PIXY2_OK) cr = (T_pixy2ErrorCode) retour.pixReturn;
+ // Si la Pixy n'aquite pas l'ordre, on retourne l'erreur signalée
+ } else {
+ if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
+ cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
+ // On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
+ }else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur
+ }
+ } else cr = PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur aussi !
+ } else { // S'il n'y a pas de checksum (pas normal mais on ne sait jamais)
+ if (msg->pixType == PIXY2_ACK) { // On vérifie que la trame est du type convenable
+ retour = *(T_pixy2ReturnCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // Si le type est bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ if (retour.pixReturn != PIXY2_OK) cr = (T_pixy2ErrorCode) retour.pixReturn;
+ // Si la Pixy n'aquite pas l'ordre, on retourne l'erreur signalée
+ } else {
+ if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
+ cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
+ }else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur
+ }
+ }
+ etat = idle; // Et on annoce que la pixy est libre
+ break;
+
+ default : // Dans tous les autres cas
+ cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
+ break;
+ }
+ return cr;
+}
+
+T_pixy2ErrorCode PIXY2::pixy2_setLamp (Byte upper, Byte lower){
+
+ T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[rPointer];
+ T_pixy2ErrorCode cr = PIXY2_OK;
+ T_pixy2ReturnCode retour;
+
+ switch (etat) {
+ case idle : // Si la caméra est inactive
+ PIXY2::pixy2_sndSetLamp (upper, lower); // On envoie la trame de règlage d'allumage des lumières de contraste
+ etat = messageSent; // On passe à l'attente du message de réponse
+ rPointer = wPointer; // On enregistre la position du pointeur de FIFO
+ 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
+ if (frameContainChecksum) { // Si la trame contient un checksum
+ if ( pixy2_validateChecksum (&Pixy2_buffer[rPointer]) ) { // On lance la validation du checksum
+ if (msg->pixType == PIXY2_ACK) { // On vérifie que la trame est du type convenable
+ retour = *(T_pixy2ReturnCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
+ // Si le checksum et le type sont bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ if (retour.pixReturn != PIXY2_OK) cr = (T_pixy2ErrorCode) retour.pixReturn;
+ // Si la Pixy n'aquite pas l'ordre, on retourne l'erreur signalée
+ } else {
+ if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
+ cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
+ // On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
+ }else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur
+ }
+ } else cr = PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur aussi !
+ } else { // S'il n'y a pas de checksum (pas normal mais on ne sait jamais)
+ if (msg->pixType == PIXY2_ACK) { // On vérifie que la trame est du type convenable
+ retour = *(T_pixy2ReturnCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // Si le type est bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ if (retour.pixReturn != PIXY2_OK) cr = (T_pixy2ErrorCode) retour.pixReturn;
+ // Si la Pixy n'aquite pas l'ordre, on retourne l'erreur signalée
+ } else {
+ if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
+ cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
+ }else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur
+ }
+ }
+ etat = idle; // Et on annoce que la pixy est libre
+ break;
+
+ default : // Dans tous les autres cas
+ cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
+ break;
+ }
+ return cr;
+}
+
+T_pixy2ErrorCode PIXY2::pixy2_getFPS (T_pixy2ReturnCode *framerate){
+
+ T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[rPointer];
+ T_pixy2ErrorCode cr = PIXY2_OK;
+
+ switch (etat) {
+ case idle : // Si la caméra est inactive
+ PIXY2::pixy2_sndGetFPS(); // On envoie la trame de règlage d'allumage des lumières de contraste
+ etat = messageSent; // On passe à l'attente du message de réponse
+ rPointer = wPointer; // On enregistre la position du pointeur de FIFO
+ 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
+ if (frameContainChecksum) { // Si la trame contient un checksum
+ if ( pixy2_validateChecksum (&Pixy2_buffer[rPointer]) ) { // On lance la validation du checksum
+ if (msg->pixType == PIXY2_ACK) { // On vérifie que la trame est du type convenable
+ framerate = (T_pixy2ReturnCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
+ // Si le checksum et le type sont bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ } else {
+ if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
+ cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_CSHEADERSIZE];
+ // On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
+ }else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur
+ }
+ } else cr = PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur aussi !
+ } else { // S'il n'y a pas de checksum (pas normal mais on ne sait jamais)
+ if (msg->pixType == PIXY2_ACK) { // On vérifie que la trame est du type convenable
+ framerate = (T_pixy2ReturnCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // Si le type est bon, on mappe le pointeur de résultat sur la FIFO (ligne précédente)
+ } else {
+ if (msg->pixType == PIXY2_ERROR) { // Si on reçoit une trame d'erreur
+ cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[rPointer + PIXY2_NCSHEADERSIZE];
+ // On mappe le résultat sur la donnée stockée dans la FIFO (ligne précédente)
+ }else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur
+ }
+ }
+ etat = idle; // Et on annoce que la pixy est libre
+ break;
+
+ default : // Dans tous les autres cas
+ cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
+ break;
+ }
+ return cr;
+}
+
+T_pixy2ErrorCode PIXY2::pixy2_getBlocks (Byte sigmap, Byte maxBloc){return PIXY2_OK;}
+T_pixy2ErrorCode PIXY2::pixy2_getMainFeature (Byte features){return PIXY2_OK;}
+T_pixy2ErrorCode PIXY2::pixy2_getAllFeature (Byte features){return PIXY2_OK;}
+T_pixy2ErrorCode PIXY2::pixy2_setMode (Byte mode){return PIXY2_OK;}
+T_pixy2ErrorCode PIXY2::pixy2_setNexTurn (Word angle){return PIXY2_OK;}
+T_pixy2ErrorCode PIXY2::pixy2_setDefaultTurn (Word angle){return PIXY2_OK;}
+T_pixy2ErrorCode PIXY2::pixy2_setVector (Byte vectorIndex){return PIXY2_OK;}
+T_pixy2ErrorCode PIXY2::pixy2_ReverseVector (void){return PIXY2_OK;}
+T_pixy2ErrorCode PIXY2::pixy2_getRGB (Word x, Word y, Byte saturate, T_pixy2Pixel *pixel){return PIXY2_OK;}
T_pixy2ErrorCode PIXY2::pixy2_validateChecksum (Byte* tab){
Word i, sum = 0;
@@ -429,6 +677,6 @@
for (i=0; i<*(tab+3);i++) sum = sum + *(tab + PIXY2_CSHEADERSIZE + i);
tmp = (T_Word*) (tab+4);
- if (tmp->mot == sum) return 0;
+ if (tmp->mot == sum) return PIXY2_OK;
else return PIXY2_BAD_CHECKSUM;
}