Waël Hazami / Mbed 2 deprecated 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.

Dependencies:   mbed

pixy2.cpp@28:f1dd68d07aec, 2020-02-03 (annotated)

Committer:
Wael_H
Date:
Mon Feb 03 09:33:58 2020 +0000
Revision:
28:f1dd68d07aec
Parent:
27:bee63ac9b70b 
library Pixy2

Who changed what in which revision?

UserRevisionLine numberNew contents of line
haarkon 0:dde1b9d6c9d6 1 #include "pixy2.h"
haarkon 0:dde1b9d6c9d6 2
theolp 22:5f76404e2cbc 3 extern int sommeDeControle,sommeRecue;
Wael_H 28:f1dd68d07aec 4 extern Serial pc;
theolp 22:5f76404e2cbc 5
Wael_H 28:f1dd68d07aec 6 PIXY2::PIXY2(PinName tx, PinName rx, int debit) : Pixy2_numBlocks(0), Pixy2_numVectors(0), Pixy2_numIntersections(0), Pixy2_numBarcodes(0)
theolp 22:5f76404e2cbc 7 {
haarkon 0:dde1b9d6c9d6 8 _Pixy2 = new Serial (tx, rx, debit);
haarkon 0:dde1b9d6c9d6 9 _Pixy2->attach (callback(this,&PIXY2::pixy2_getByte));
haarkon 0:dde1b9d6c9d6 10 etat = idle;
theolp 22:5f76404e2cbc 11 Pixy2_buffer = (Byte*) malloc (0x100);
haarkon 0:dde1b9d6c9d6 12 }
haarkon 0:dde1b9d6c9d6 13
haarkon 19:007d361c8d66 14 PIXY2::~PIXY2()
haarkon 19:007d361c8d66 15 {
haarkon 19:007d361c8d66 16 free (Pixy2_buffer);
haarkon 19:007d361c8d66 17 }
haarkon 19:007d361c8d66 18
Wael_H 28:f1dd68d07aec 19 // POUR DEBUG //
Wael_H 28:f1dd68d07aec 20 T_Pixy2State PIXY2::getEtat()
Wael_H 28:f1dd68d07aec 21 {
Wael_H 28:f1dd68d07aec 22 return this->etat;
Wael_H 28:f1dd68d07aec 23 }
Wael_H 28:f1dd68d07aec 24
Wael_H 28:f1dd68d07aec 25 void PIXY2::affDataSize()
Wael_H 28:f1dd68d07aec 26 {
Wael_H 28:f1dd68d07aec 27 pc.printf("dataSize : %d\n\r", this->dataSize);
Wael_H 28:f1dd68d07aec 28 }
Wael_H 28:f1dd68d07aec 29 // Pour détail d'une trame (a mettre dans la fct correspondante) :
Wael_H 28:f1dd68d07aec 30 //pc.printf("pixSync : %d, pixType : %d, pixLength : %d, pixChecksum : %d\n\r", msg->pixSync, msg->pixType, msg->pixLength, msg->pixChecksum);
Wael_H 28:f1dd68d07aec 31
haarkon 3:6ba43af28440 32 /* 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.
haarkon 3:6ba43af28440 33 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...
haarkon 3:6ba43af28440 34 Les étapes de fonctionnement sont les suivantes :
haarkon 3:6ba43af28440 35
haarkon 3:6ba43af28440 36 * idle : La caméra n'a pas été solicité => on envoi le message de requête.
haarkon 3:6ba43af28440 37 * messageSent : La requête a été transmise, mais la réponse n'est pas encore arrivée.
haarkon 3:6ba43af28440 38 * receivingHeader : Le mot de synchro a été reçu, le reste de l'entête est en cours de réception.
haarkon 19:007d361c8d66 39 * receivingData : L'entête a été intégralement reçu (et traité) et on est en train de recevoir la payload.
haarkon 3:6ba43af28440 40 * dataReceived : La réponse a été intégralement reçue et est disponible pour le traitement (et la libération).
haarkon 19:007d361c8d66 41
haarkon 19:007d361c8d66 42 On utilise plusieurs pointeurs :
haarkon 19:007d361c8d66 43 * wPointer est le pointeur d'écriture des octets reçus dans le buffer de réception
haarkon 19:007d361c8d66 44 * hPointer est le pointeur de l'entête du message
haarkon 19:007d361c8d66 45 * dPointer est le pointeur de la zone de données
haarkon 19:007d361c8d66 46
haarkon 19:007d361c8d66 47 On rajoute une variable : dataSize, qui définit la quantité de données à recevoir (issue de l'entête)
haarkon 19:007d361c8d66 48
haarkon 19:007d361c8d66 49 **** COMMENT CA MARCHE ****
haarkon 19:007d361c8d66 50
haarkon 19:007d361c8d66 51 Au début wPointer = 0. Quand wPointer est supérieur à 1 (donc qu'on a reçu au moins 2 octets), on regarde si on a reçu le code de début de trame 0xC1AF
haarkon 19:007d361c8d66 52 Si ce n'est pas le cas, on continue de recevoir les octets et on les stock jusqu'à trouver le code de début de trame.
haarkon 19:007d361c8d66 53 Quand on trouve le code, on enregistre le point de départ (c'est hPointer) comme étant la position actuelle du wPointer-1.
haarkon 19:007d361c8d66 54 A partir de ça, on attend de recevoir les 4 premiers octets de l'entête :
haarkon 19:007d361c8d66 55 * start of frame (hPointer et hPointer + 1)
haarkon 19:007d361c8d66 56 * identification du type (hPointer + 2)
haarkon 19:007d361c8d66 57 * taille des données (hPointer + 3)
haarkon 19:007d361c8d66 58 Et ensuite si on a une trame avec un checksum (normal) :
haarkon 19:007d361c8d66 59 * le checksum (hPointer + 4 et hPointer + 5)
haarkon 19:007d361c8d66 60 * les données (hPointer + 6 et +)
haarkon 19:007d361c8d66 61 Et si on a une trame sans checksum (pas normal) :
haarkon 19:007d361c8d66 62 * les données (hPointer + 4 et +)
haarkon 19:007d361c8d66 63
haarkon 19:007d361c8d66 64 On continue alors de recevoir des octets jusqu'à ce que wPointer soit égal à dPointer + dataSize - 1
haarkon 19:007d361c8d66 65 par exemple si la data fait 4 octets et une trame avec checksum, on reçoit tant que wPointer est inférieur à 9 (6 + 4 - 1)
haarkon 19:007d361c8d66 66 ou pour la même quantité de données mais avec une trame sans checksum 7 (4 + 4 - 1)...
haarkon 3:6ba43af28440 67 */
haarkon 3:6ba43af28440 68
haarkon 0:dde1b9d6c9d6 69 void PIXY2::pixy2_getByte () // Interruption de la pixy2
haarkon 0:dde1b9d6c9d6 70 {
haarkon 0:dde1b9d6c9d6 71 T_Word *buffer;
haarkon 0:dde1b9d6c9d6 72
haarkon 18:190e3987e274 73 Pixy2_buffer[wPointer] = _Pixy2->getc(); // On stocke l'octet reçu dans la première case dispo du buffer de réception
haarkon 0:dde1b9d6c9d6 74
theolp 22:5f76404e2cbc 75
haarkon 0:dde1b9d6c9d6 76 switch (etat) {
haarkon 3:6ba43af28440 77 case messageSent : // Si on a envoyé une requete => on attend un entête
haarkon 18:190e3987e274 78 if (wPointer > 0) { // On attend d'avoir reçu 2 octets
haarkon 18:190e3987e274 79 buffer = (T_Word*) &Pixy2_buffer[wPointer-1]; // On pointe la structure sur les 2 derniers octets reçus
haarkon 18:190e3987e274 80 if ((buffer->mot == PIXY2_CSSYNC) || (buffer->mot == PIXY2_SYNC)) { // Si c'est un mot d'entête
haarkon 3:6ba43af28440 81 etat = receivingHeader; // On passe à l'état réception de l'entête
Wael_H 28:f1dd68d07aec 82 hPointer = wPointer - 1; // On initialise le pointeur de l'entête
haarkon 19:007d361c8d66 83 if (buffer->mot == PIXY2_SYNC) {
haarkon 19:007d361c8d66 84 frameContainChecksum = 0; // Si c'est un entête sans checksum, on mémorise qu'il n'y a pas de checksum à vérifier
theolp 22:5f76404e2cbc 85 dPointer = hPointer + PIXY2_NCSHEADERSIZE;
haarkon 19:007d361c8d66 86 } else {
haarkon 19:007d361c8d66 87 frameContainChecksum = 1; // Sinon, on mémorise qu'il y a un checksum à vérifier
theolp 22:5f76404e2cbc 88 dPointer = hPointer + PIXY2_CSHEADERSIZE;
haarkon 19:007d361c8d66 89 }
haarkon 19:007d361c8d66 90 } // Si on n'a pas de mot d'entête on attend d'en trouver un...
haarkon 0:dde1b9d6c9d6 91 }
haarkon 0:dde1b9d6c9d6 92 break;
haarkon 0:dde1b9d6c9d6 93
haarkon 18:190e3987e274 94 case receivingHeader : // Si on est en train de recevoir un entête (entre le SYNC et... La fin de l'entête)
haarkon 19:007d361c8d66 95 if ((frameContainChecksum && ((wPointer - hPointer) == (PIXY2_CSHEADERSIZE - 1))) || (!frameContainChecksum && ((wPointer - hPointer) == (PIXY2_NCSHEADERSIZE - 1)))) {
haarkon 18:190e3987e274 96 // 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
haarkon 18:190e3987e274 97 etat = receivingData; // On dit que l'on va de recevoir des données
haarkon 19:007d361c8d66 98 dataSize = Pixy2_buffer[hPointer + 3]; // On enregistre la taille de la payload
Wael_H 28:f1dd68d07aec 99 if (dataSize == 0) // Si on reçoit rien, on reset le processus
Wael_H 28:f1dd68d07aec 100 etat = idle;
Wael_H 28:f1dd68d07aec 101 }
haarkon 0:dde1b9d6c9d6 102 break;
haarkon 0:dde1b9d6c9d6 103
Wael_H 28:f1dd68d07aec 104 case receivingData : // Si on est en train de recevoir des données.
theolp 22:5f76404e2cbc 105 if (wPointer == ((dataSize - 1) + dPointer)) {
Wael_H 28:f1dd68d07aec 106 etat = dataReceived; // Quand on a reçu toutes les données promises on dit que c'est OK
theolp 22:5f76404e2cbc 107 }
haarkon 0:dde1b9d6c9d6 108 break;
haarkon 0:dde1b9d6c9d6 109
haarkon 0:dde1b9d6c9d6 110 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.
haarkon 0:dde1b9d6c9d6 111 break;
haarkon 0:dde1b9d6c9d6 112 }
haarkon 19:007d361c8d66 113 wPointer++; // on pointe la case suivante du buffer de réception
haarkon 18:190e3987e274 114
haarkon 0:dde1b9d6c9d6 115 }
haarkon 0:dde1b9d6c9d6 116
haarkon 11:68ef9f85e40e 117 T_pixy2ErrorCode PIXY2::pixy2_sndGetVersion (void){
haarkon 10:ea759846c2d5 118 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 119 int i = 0, dataSize = 0;
haarkon 0:dde1b9d6c9d6 120 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 121 msg.frame.header.pixType = PIXY2_ASK_VERS;
haarkon 18:190e3987e274 122 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 123 do {
haarkon 0:dde1b9d6c9d6 124 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 125 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 126 i++;
haarkon 0:dde1b9d6c9d6 127 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 128 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 129 }
haarkon 0:dde1b9d6c9d6 130
haarkon 11:68ef9f85e40e 131 T_pixy2ErrorCode PIXY2::pixy2_sndGetResolution (void){
haarkon 10:ea759846c2d5 132 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 133 int i = 0, dataSize = 1;
haarkon 0:dde1b9d6c9d6 134 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 135 msg.frame.header.pixType = PIXY2_ASK_RESOL;
haarkon 18:190e3987e274 136 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 137 msg.frame.data[0] = 0;
haarkon 0:dde1b9d6c9d6 138 do {
haarkon 0:dde1b9d6c9d6 139 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 140 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 141 i++;
haarkon 0:dde1b9d6c9d6 142 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 143 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 144 }
haarkon 0:dde1b9d6c9d6 145
haarkon 11:68ef9f85e40e 146 T_pixy2ErrorCode PIXY2::pixy2_sndSetCameraBrightness (Byte brightness){
haarkon 10:ea759846c2d5 147 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 148 int i = 0, dataSize = 1;
haarkon 0:dde1b9d6c9d6 149 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 150 msg.frame.header.pixType = PIXY2_SET_BRIGHT;
haarkon 18:190e3987e274 151 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 152 msg.frame.data[0] = brightness;
haarkon 0:dde1b9d6c9d6 153 do {
haarkon 0:dde1b9d6c9d6 154 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 155 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 156 i++;
haarkon 0:dde1b9d6c9d6 157 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 158 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 159 }
haarkon 0:dde1b9d6c9d6 160
haarkon 11:68ef9f85e40e 161 T_pixy2ErrorCode PIXY2::pixy2_sndSetServo (Word s0, Word s1){
haarkon 10:ea759846c2d5 162 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 163 int i = 0, dataSize = 4;
haarkon 0:dde1b9d6c9d6 164 T_Word tmp;
haarkon 0:dde1b9d6c9d6 165 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 166 msg.frame.header.pixType = PIXY2_SET_SERVOS;
haarkon 18:190e3987e274 167 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 168 tmp.mot = s0;
haarkon 0:dde1b9d6c9d6 169 msg.frame.data[0] = tmp.octet[0];
haarkon 0:dde1b9d6c9d6 170 msg.frame.data[1] = tmp.octet[1];
haarkon 0:dde1b9d6c9d6 171 tmp.mot = s1;
haarkon 0:dde1b9d6c9d6 172 msg.frame.data[2] = tmp.octet[0];
haarkon 0:dde1b9d6c9d6 173 msg.frame.data[3] = tmp.octet[1];
haarkon 0:dde1b9d6c9d6 174 do {
haarkon 0:dde1b9d6c9d6 175 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 176 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 177 i++;
haarkon 0:dde1b9d6c9d6 178 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 179 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 180 }
haarkon 0:dde1b9d6c9d6 181
haarkon 11:68ef9f85e40e 182 T_pixy2ErrorCode PIXY2::pixy2_sndSetLED (Byte red, Byte green, Byte blue){
haarkon 10:ea759846c2d5 183 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 184 int i = 0, dataSize = 3;
haarkon 0:dde1b9d6c9d6 185 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 186 msg.frame.header.pixType = PIXY2_SET_LED;
haarkon 18:190e3987e274 187 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 188 msg.frame.data[0] = red;
haarkon 0:dde1b9d6c9d6 189 msg.frame.data[1] = green;
haarkon 0:dde1b9d6c9d6 190 msg.frame.data[2] = blue;
haarkon 0:dde1b9d6c9d6 191 do {
haarkon 0:dde1b9d6c9d6 192 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 193 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 194 i++;
haarkon 0:dde1b9d6c9d6 195 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 196 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 197 }
haarkon 0:dde1b9d6c9d6 198
haarkon 11:68ef9f85e40e 199 T_pixy2ErrorCode PIXY2::pixy2_sndSetLamp (Byte upper, Byte lower){
haarkon 10:ea759846c2d5 200 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 201 int i = 0, dataSize = 2;
haarkon 0:dde1b9d6c9d6 202 msg.frame.header.pixSync = PIXY2_SYNC;
Wael_H 28:f1dd68d07aec 203 msg.frame.header.pixType = PIXY2_SET_LAMP;
haarkon 18:190e3987e274 204 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 205 msg.frame.data[0] = upper;
haarkon 0:dde1b9d6c9d6 206 msg.frame.data[1] = lower;
haarkon 0:dde1b9d6c9d6 207 do {
haarkon 0:dde1b9d6c9d6 208 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 209 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 210 i++;
haarkon 0:dde1b9d6c9d6 211 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 212 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 213 }
haarkon 0:dde1b9d6c9d6 214
haarkon 11:68ef9f85e40e 215 T_pixy2ErrorCode PIXY2::pixy2_sndGetFPS (void){
haarkon 10:ea759846c2d5 216 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 217 int i = 0, dataSize = 0;
haarkon 0:dde1b9d6c9d6 218 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 219 msg.frame.header.pixType = PIXY2_ASK_FPS;
haarkon 18:190e3987e274 220 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 221 do {
haarkon 0:dde1b9d6c9d6 222 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 223 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 224 i++;
haarkon 0:dde1b9d6c9d6 225 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 226 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 227 }
haarkon 0:dde1b9d6c9d6 228
haarkon 11:68ef9f85e40e 229 T_pixy2ErrorCode PIXY2::pixy2_sndGetBlocks (Byte sigmap, Byte maxBloc){
haarkon 10:ea759846c2d5 230 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 231 int i = 0, dataSize = 2;
haarkon 0:dde1b9d6c9d6 232 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 233 msg.frame.header.pixType = PIXY2_ASK_BLOC;
haarkon 18:190e3987e274 234 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 235 msg.frame.data[0] = sigmap;
haarkon 0:dde1b9d6c9d6 236 msg.frame.data[1] = maxBloc;
haarkon 0:dde1b9d6c9d6 237 do {
haarkon 0:dde1b9d6c9d6 238 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 239 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 240 i++;
haarkon 0:dde1b9d6c9d6 241 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 242 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 243 }
haarkon 0:dde1b9d6c9d6 244
haarkon 19:007d361c8d66 245 T_pixy2ErrorCode PIXY2::pixy2_sndGetLineFeature (Byte type, Byte feature){
haarkon 10:ea759846c2d5 246 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 247 int i = 0, dataSize = 2;
haarkon 0:dde1b9d6c9d6 248 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 249 msg.frame.header.pixType = PIXY2_ASK_LINE;
haarkon 18:190e3987e274 250 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 251 msg.frame.data[0] = type;
haarkon 0:dde1b9d6c9d6 252 msg.frame.data[1] = feature;
haarkon 0:dde1b9d6c9d6 253 do {
haarkon 0:dde1b9d6c9d6 254 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 255 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 256 i++;
haarkon 0:dde1b9d6c9d6 257 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 258 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 259 }
haarkon 0:dde1b9d6c9d6 260
haarkon 11:68ef9f85e40e 261 T_pixy2ErrorCode PIXY2::pixy2_sndSetMode (Byte mode){
haarkon 10:ea759846c2d5 262 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 263 int i = 0, dataSize = 1;
haarkon 0:dde1b9d6c9d6 264 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 265 msg.frame.header.pixType = PIXY2_SET_MODE;
haarkon 18:190e3987e274 266 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 267 msg.frame.data[0] = mode;
haarkon 0:dde1b9d6c9d6 268 do {
haarkon 0:dde1b9d6c9d6 269 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 270 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 271 i++;
haarkon 0:dde1b9d6c9d6 272 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 273 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 274 }
haarkon 0:dde1b9d6c9d6 275
haarkon 19:007d361c8d66 276 T_pixy2ErrorCode PIXY2::pixy2_sndSetNextTurn (Word angle){
haarkon 10:ea759846c2d5 277 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 278 int i = 0, dataSize = 2;
haarkon 0:dde1b9d6c9d6 279 T_Word tmp;
haarkon 0:dde1b9d6c9d6 280 tmp.mot = angle;
haarkon 0:dde1b9d6c9d6 281 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 282 msg.frame.header.pixType = PIXY2_SET_TURN;
haarkon 18:190e3987e274 283 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 284 tmp.mot = angle;
haarkon 0:dde1b9d6c9d6 285 msg.frame.data[0] = tmp.octet[0];
haarkon 0:dde1b9d6c9d6 286 msg.frame.data[1] = tmp.octet[1];
haarkon 0:dde1b9d6c9d6 287 do {
haarkon 0:dde1b9d6c9d6 288 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 289 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 290 i++;
haarkon 0:dde1b9d6c9d6 291 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 292 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 293 }
haarkon 0:dde1b9d6c9d6 294
haarkon 11:68ef9f85e40e 295 T_pixy2ErrorCode PIXY2::pixy2_sndSetDefaultTurn (Word angle){
haarkon 10:ea759846c2d5 296 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 297 int i = 0, dataSize = 2;
haarkon 0:dde1b9d6c9d6 298 T_Word tmp;
haarkon 0:dde1b9d6c9d6 299 tmp.mot = angle;
haarkon 0:dde1b9d6c9d6 300 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 301 msg.frame.header.pixType = PIXY2_SET_DEFTURN;
haarkon 18:190e3987e274 302 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 303 tmp.mot = angle;
haarkon 0:dde1b9d6c9d6 304 msg.frame.data[0] = tmp.octet[0];
haarkon 0:dde1b9d6c9d6 305 msg.frame.data[1] = tmp.octet[1];
haarkon 0:dde1b9d6c9d6 306 do {
haarkon 0:dde1b9d6c9d6 307 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 308 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 309 i++;
haarkon 0:dde1b9d6c9d6 310 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 311 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 312 }
haarkon 0:dde1b9d6c9d6 313
haarkon 11:68ef9f85e40e 314 T_pixy2ErrorCode PIXY2::pixy2_sndSetVector (Byte vectorIndex){
haarkon 10:ea759846c2d5 315 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 316 int i = 0, dataSize = 1;
haarkon 0:dde1b9d6c9d6 317 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 318 msg.frame.header.pixType = PIXY2_SET_VECTOR;
haarkon 18:190e3987e274 319 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 320 msg.frame.data[0] = vectorIndex;
haarkon 0:dde1b9d6c9d6 321 do {
haarkon 0:dde1b9d6c9d6 322 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 323 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 324 i++;
haarkon 0:dde1b9d6c9d6 325 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 326 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 327 }
haarkon 0:dde1b9d6c9d6 328
haarkon 11:68ef9f85e40e 329 T_pixy2ErrorCode PIXY2::pixy2_sndReverseVector (void){
haarkon 10:ea759846c2d5 330 T_pixy2SendBuffer msg;
haarkon 0:dde1b9d6c9d6 331 int i = 0, dataSize = 0;
haarkon 0:dde1b9d6c9d6 332 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 333 msg.frame.header.pixType = PIXY2_SET_REVERSE;
haarkon 18:190e3987e274 334 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 335 do {
haarkon 0:dde1b9d6c9d6 336 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 337 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 338 i++;
haarkon 0:dde1b9d6c9d6 339 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 340 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 341 }
haarkon 0:dde1b9d6c9d6 342
haarkon 11:68ef9f85e40e 343 T_pixy2ErrorCode PIXY2::pixy2_sndGetRGB (Word x, Word y, Byte saturate){
haarkon 10:ea759846c2d5 344 T_pixy2SendBuffer msg;
Wael_H 28:f1dd68d07aec 345 int i = 0, dataSize = 5;
haarkon 0:dde1b9d6c9d6 346 msg.frame.header.pixSync = PIXY2_SYNC;
haarkon 0:dde1b9d6c9d6 347 msg.frame.header.pixType = PIXY2_ASK_VIDEO;
haarkon 18:190e3987e274 348 msg.frame.header.pixLength = dataSize;
haarkon 0:dde1b9d6c9d6 349 msg.frame.data[0] = x;
haarkon 0:dde1b9d6c9d6 350 msg.frame.data[1] = y;
haarkon 0:dde1b9d6c9d6 351 msg.frame.data[2] = saturate;
haarkon 0:dde1b9d6c9d6 352 do {
haarkon 0:dde1b9d6c9d6 353 while(!_Pixy2->writable());
haarkon 0:dde1b9d6c9d6 354 _Pixy2->putc(msg.data[i]);
haarkon 0:dde1b9d6c9d6 355 i++;
haarkon 0:dde1b9d6c9d6 356 } while (i<(PIXY2_NCSHEADERSIZE+dataSize));
haarkon 5:28e47187bb5c 357 return PIXY2_OK;
haarkon 0:dde1b9d6c9d6 358 }
haarkon 0:dde1b9d6c9d6 359
haarkon 0:dde1b9d6c9d6 360 /* 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é.
haarkon 0:dde1b9d6c9d6 361 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. */
haarkon 0:dde1b9d6c9d6 362
theolp 22:5f76404e2cbc 363 T_pixy2ErrorCode PIXY2::pixy2_getVersion (T_pixy2Version **ptrVersion){
haarkon 0:dde1b9d6c9d6 364
haarkon 18:190e3987e274 365 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 11:68ef9f85e40e 366 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 0:dde1b9d6c9d6 367
haarkon 0:dde1b9d6c9d6 368 switch (etat) {
haarkon 3:6ba43af28440 369 case idle : // Si la caméra est inactive
haarkon 18:190e3987e274 370 wPointer = 0; // On remonte en haut du buffer
haarkon 14:c0eda1e35a00 371 cr = PIXY2::pixy2_sndGetVersion(); // On envoie la trame de demande de la version
haarkon 14:c0eda1e35a00 372 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 3:6ba43af28440 373 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 5:28e47187bb5c 374 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 0:dde1b9d6c9d6 375 break;
haarkon 0:dde1b9d6c9d6 376
haarkon 3:6ba43af28440 377 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 3:6ba43af28440 378 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 379 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 380 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 10:ea759846c2d5 381 }
haarkon 0:dde1b9d6c9d6 382 }
haarkon 19:007d361c8d66 383 if (msg->pixType == PIXY2_REP_VERS) { // On vérifie que la trame est du type convenable (REPONSE VERSION)
theolp 23:d6bbc4ec1f22 384 *ptrVersion = (T_pixy2Version*) &Pixy2_buffer[dPointer]; // On mappe le pointeur de structure sur le buffer de réception.
haarkon 19:007d361c8d66 385 } else { // Si ce n'est pas le bon type
haarkon 19:007d361c8d66 386 if (msg->pixType == PIXY2_REP_ERROR) { // Cela pourrait être une trame d'erreur
haarkon 19:007d361c8d66 387 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 388 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 19:007d361c8d66 389 }
theolp 22:5f76404e2cbc 390 etat = idle; // On annonce que la pixy est libre
haarkon 0:dde1b9d6c9d6 391 break;
haarkon 0:dde1b9d6c9d6 392
haarkon 3:6ba43af28440 393 default : // Dans tous les autres cas
haarkon 5:28e47187bb5c 394 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 0:dde1b9d6c9d6 395 break;
haarkon 0:dde1b9d6c9d6 396 }
haarkon 0:dde1b9d6c9d6 397 return cr;
haarkon 0:dde1b9d6c9d6 398 }
haarkon 0:dde1b9d6c9d6 399
theolp 22:5f76404e2cbc 400 T_pixy2ErrorCode PIXY2::pixy2_getResolution (T_pixy2Resolution **ptrResolution){
haarkon 3:6ba43af28440 401
haarkon 18:190e3987e274 402 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 11:68ef9f85e40e 403 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 3:6ba43af28440 404
haarkon 3:6ba43af28440 405 switch (etat) {
haarkon 3:6ba43af28440 406 case idle : // Si la caméra est inactive
haarkon 18:190e3987e274 407 wPointer = 0; // On remonte en haut du buffer
haarkon 14:c0eda1e35a00 408 cr = PIXY2::pixy2_sndGetResolution(); // On envoie la trame de demande de la résolution
haarkon 14:c0eda1e35a00 409 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 3:6ba43af28440 410 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 5:28e47187bb5c 411 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 3:6ba43af28440 412 break;
haarkon 3:6ba43af28440 413
haarkon 3:6ba43af28440 414 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 3:6ba43af28440 415 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 416 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 417 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 12:7493191dd1dc 418 }
haarkon 12:7493191dd1dc 419 }
haarkon 19:007d361c8d66 420 if (msg->pixType == PIXY2_REP_RESOL) { // On vérifie que la trame est du type convenable (REPONSE RESOLUTION)
theolp 22:5f76404e2cbc 421 *ptrResolution = (T_pixy2Resolution*) &Pixy2_buffer[dPointer]; // On mappe le pointeur de structure sur le buffer de réception.
haarkon 19:007d361c8d66 422 } else { // Si ce n'est pas le bon type
haarkon 19:007d361c8d66 423 if (msg->pixType == PIXY2_REP_ERROR) { // Cela pourrait être une trame d'erreur
haarkon 19:007d361c8d66 424 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 425 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 19:007d361c8d66 426 }
haarkon 18:190e3987e274 427 etat = idle; // On annoce que la pixy est libre
haarkon 18:190e3987e274 428 break;
haarkon 18:190e3987e274 429
haarkon 18:190e3987e274 430 default : // Dans tous les autres cas
haarkon 18:190e3987e274 431 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 18:190e3987e274 432 break;
haarkon 18:190e3987e274 433 }
haarkon 18:190e3987e274 434 return cr;
haarkon 18:190e3987e274 435 }
haarkon 18:190e3987e274 436
haarkon 18:190e3987e274 437 T_pixy2ErrorCode PIXY2::pixy2_setCameraBrightness (Byte brightness){
haarkon 18:190e3987e274 438
haarkon 18:190e3987e274 439 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 18:190e3987e274 440 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 18:190e3987e274 441
haarkon 18:190e3987e274 442 switch (etat) {
haarkon 18:190e3987e274 443 case idle : // Si la caméra est inactive
haarkon 18:190e3987e274 444 wPointer = 0; // On remonte en haut du buffer
haarkon 18:190e3987e274 445 cr = PIXY2::pixy2_sndSetCameraBrightness (brightness); // On envoie la trame de règlage de la luminosité
haarkon 18:190e3987e274 446 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 18:190e3987e274 447 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 18:190e3987e274 448 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 18:190e3987e274 449 break;
haarkon 18:190e3987e274 450
haarkon 18:190e3987e274 451 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 18:190e3987e274 452 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 453 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 454 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 19:007d361c8d66 455 }
haarkon 19:007d361c8d66 456 }
haarkon 19:007d361c8d66 457 if ((msg->pixType == PIXY2_REP_ACK) || (msg->pixType == PIXY2_REP_ERROR)) {
haarkon 18:190e3987e274 458 // On vérifie que la trame est du type convenable (ACK ou ERREUR)
haarkon 19:007d361c8d66 459 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 460 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 18:190e3987e274 461 etat = idle; // On annoce que la pixy est libre
haarkon 18:190e3987e274 462 break;
haarkon 18:190e3987e274 463
haarkon 18:190e3987e274 464 default : // Dans tous les autres cas
haarkon 18:190e3987e274 465 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 18:190e3987e274 466 break;
haarkon 18:190e3987e274 467 }
haarkon 18:190e3987e274 468 return cr;
haarkon 18:190e3987e274 469 }
haarkon 18:190e3987e274 470
haarkon 18:190e3987e274 471 T_pixy2ErrorCode PIXY2::pixy2_setServos (Word s0, Word s1){
haarkon 18:190e3987e274 472
haarkon 18:190e3987e274 473 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 18:190e3987e274 474 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 18:190e3987e274 475
haarkon 18:190e3987e274 476 switch (etat) {
haarkon 18:190e3987e274 477 case idle : // Si la caméra est inactive
haarkon 18:190e3987e274 478 wPointer = 0; // On remonte en haut du buffer
haarkon 18:190e3987e274 479 cr = PIXY2::pixy2_sndSetServo (s0, s1); // On envoie la trame de règlage des servos moteurs
haarkon 18:190e3987e274 480 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 18:190e3987e274 481 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 18:190e3987e274 482 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 18:190e3987e274 483 break;
haarkon 18:190e3987e274 484
haarkon 18:190e3987e274 485 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 18:190e3987e274 486 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 487 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 488 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 19:007d361c8d66 489 }
haarkon 19:007d361c8d66 490 }
haarkon 19:007d361c8d66 491 if ((msg->pixType == PIXY2_REP_ACK) || (msg->pixType == PIXY2_REP_ERROR)) {
haarkon 18:190e3987e274 492 // On vérifie que la trame est du type convenable (ACK ou ERREUR)
haarkon 19:007d361c8d66 493 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 494 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 18:190e3987e274 495 etat = idle; // On annoce que la pixy est libre
haarkon 12:7493191dd1dc 496 break;
haarkon 12:7493191dd1dc 497
haarkon 12:7493191dd1dc 498 default : // Dans tous les autres cas
haarkon 12:7493191dd1dc 499 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 12:7493191dd1dc 500 break;
haarkon 12:7493191dd1dc 501 }
haarkon 12:7493191dd1dc 502 return cr;
haarkon 12:7493191dd1dc 503 }
haarkon 12:7493191dd1dc 504
haarkon 18:190e3987e274 505 T_pixy2ErrorCode PIXY2::pixy2_setLED (Byte red, Byte green, Byte blue){
haarkon 12:7493191dd1dc 506
haarkon 18:190e3987e274 507 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 12:7493191dd1dc 508 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 12:7493191dd1dc 509
haarkon 12:7493191dd1dc 510 switch (etat) {
haarkon 12:7493191dd1dc 511 case idle : // Si la caméra est inactive
haarkon 18:190e3987e274 512 wPointer = 0; // On remonte en haut du buffer
haarkon 18:190e3987e274 513 cr = PIXY2::pixy2_sndSetLED (red, green, blue); // On envoie la trame de règlage des composantes de la LED RGB
haarkon 14:c0eda1e35a00 514 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 12:7493191dd1dc 515 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 12:7493191dd1dc 516 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 12:7493191dd1dc 517 break;
haarkon 12:7493191dd1dc 518
haarkon 12:7493191dd1dc 519 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 12:7493191dd1dc 520 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 521 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 522 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 19:007d361c8d66 523 }
haarkon 19:007d361c8d66 524 }
haarkon 19:007d361c8d66 525 if ((msg->pixType == PIXY2_REP_ACK) || (msg->pixType == PIXY2_REP_ERROR)) {
haarkon 18:190e3987e274 526 // On vérifie que la trame est du type convenable (ACK ou ERREUR)
haarkon 19:007d361c8d66 527 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 528 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 18:190e3987e274 529 etat = idle; // On annoce que la pixy est libre
haarkon 3:6ba43af28440 530 break;
haarkon 3:6ba43af28440 531
haarkon 3:6ba43af28440 532 default : // Dans tous les autres cas
haarkon 18:190e3987e274 533 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 12:7493191dd1dc 534 break;
haarkon 12:7493191dd1dc 535 }
haarkon 12:7493191dd1dc 536 return cr;
haarkon 12:7493191dd1dc 537 }
haarkon 12:7493191dd1dc 538
haarkon 12:7493191dd1dc 539 T_pixy2ErrorCode PIXY2::pixy2_setLamp (Byte upper, Byte lower){
haarkon 12:7493191dd1dc 540
haarkon 18:190e3987e274 541 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 12:7493191dd1dc 542 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 12:7493191dd1dc 543
haarkon 12:7493191dd1dc 544 switch (etat) {
haarkon 12:7493191dd1dc 545 case idle : // Si la caméra est inactive
haarkon 18:190e3987e274 546 wPointer = 0; // On remonte en haut du buffer
haarkon 14:c0eda1e35a00 547 cr = PIXY2::pixy2_sndSetLamp (upper, lower); // On envoie la trame de règlage d'allumage des lumières de contraste
haarkon 18:190e3987e274 548 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 12:7493191dd1dc 549 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 12:7493191dd1dc 550 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 12:7493191dd1dc 551 break;
haarkon 12:7493191dd1dc 552
haarkon 12:7493191dd1dc 553 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 12:7493191dd1dc 554 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 555 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 556 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 19:007d361c8d66 557 }
haarkon 19:007d361c8d66 558 }
haarkon 19:007d361c8d66 559 if ((msg->pixType == PIXY2_REP_ACK) || (msg->pixType == PIXY2_REP_ERROR)) {
haarkon 18:190e3987e274 560 // On vérifie que la trame est du type convenable (ACK ou ERREUR)
haarkon 19:007d361c8d66 561 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 562 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 18:190e3987e274 563 etat = idle; // On annoce que la pixy est libre
haarkon 12:7493191dd1dc 564 break;
haarkon 12:7493191dd1dc 565
haarkon 12:7493191dd1dc 566 default : // Dans tous les autres cas
haarkon 18:190e3987e274 567 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 12:7493191dd1dc 568 break;
haarkon 12:7493191dd1dc 569 }
haarkon 12:7493191dd1dc 570 return cr;
haarkon 12:7493191dd1dc 571 }
haarkon 12:7493191dd1dc 572
Wael_H 28:f1dd68d07aec 573 T_pixy2ErrorCode PIXY2::pixy2_getFPS (T_pixy2ReturnCode **framerate){
haarkon 12:7493191dd1dc 574
haarkon 18:190e3987e274 575 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 12:7493191dd1dc 576 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 12:7493191dd1dc 577
haarkon 12:7493191dd1dc 578 switch (etat) {
haarkon 12:7493191dd1dc 579 case idle : // Si la caméra est inactive
haarkon 18:190e3987e274 580 wPointer = 0; // On remonte en haut du buffer
haarkon 18:190e3987e274 581 cr = PIXY2::pixy2_sndGetFPS(); // On envoie la trame de demande du Framerate
haarkon 18:190e3987e274 582 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 12:7493191dd1dc 583 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 12:7493191dd1dc 584 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 12:7493191dd1dc 585 break;
haarkon 12:7493191dd1dc 586
haarkon 12:7493191dd1dc 587 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 12:7493191dd1dc 588 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 589 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 590 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 12:7493191dd1dc 591 }
haarkon 12:7493191dd1dc 592 }
haarkon 19:007d361c8d66 593 if (msg->pixType == PIXY2_REP_FPS) { // On vérifie que la trame est du type convenable (REPONSE FPS)
Wael_H 28:f1dd68d07aec 594 *framerate = (T_pixy2ReturnCode*) &Pixy2_buffer[dPointer]; // On mappe le pointeur de structure sur le buffer de réception.
haarkon 19:007d361c8d66 595 } else { // Si ce n'est pas le bon type
haarkon 19:007d361c8d66 596 if (msg->pixType == PIXY2_REP_ERROR) { // Cela pourrait être une trame d'erreur
haarkon 19:007d361c8d66 597 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 598 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 19:007d361c8d66 599 }
haarkon 18:190e3987e274 600 etat = idle; // On annoce que la pixy est libre
haarkon 12:7493191dd1dc 601 break;
haarkon 12:7493191dd1dc 602
haarkon 12:7493191dd1dc 603 default : // Dans tous les autres cas
haarkon 18:190e3987e274 604 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 12:7493191dd1dc 605 break;
haarkon 12:7493191dd1dc 606 }
haarkon 12:7493191dd1dc 607 return cr;
haarkon 12:7493191dd1dc 608 }
haarkon 12:7493191dd1dc 609
haarkon 18:190e3987e274 610 T_pixy2ErrorCode PIXY2::pixy2_getBlocks (Byte sigmap, Byte maxBloc){
haarkon 18:190e3987e274 611
haarkon 18:190e3987e274 612 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 18:190e3987e274 613 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 18:190e3987e274 614
haarkon 18:190e3987e274 615 switch (etat) {
haarkon 18:190e3987e274 616 case idle : // Si la caméra est inactive
haarkon 18:190e3987e274 617 wPointer = 0; // On remonte en haut du buffer
haarkon 18:190e3987e274 618 cr = PIXY2::pixy2_sndGetBlocks(sigmap, maxBloc); // On envoie la trame de demande de blocs de couleur
haarkon 18:190e3987e274 619 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 18:190e3987e274 620 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 18:190e3987e274 621 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 18:190e3987e274 622 break;
haarkon 18:190e3987e274 623
haarkon 18:190e3987e274 624 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 18:190e3987e274 625 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 626 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 627 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 18:190e3987e274 628 }
haarkon 18:190e3987e274 629 }
haarkon 19:007d361c8d66 630 if (msg->pixType == PIXY2_REP_BLOC) { // On vérifie que la trame est du type convenable (REPONSE BLOCS)
haarkon 19:007d361c8d66 631 Pixy2_blocks = (T_pixy2Bloc*) &Pixy2_buffer[dPointer]; // On mappe le pointeur de structure sur le buffer de réception.
haarkon 19:007d361c8d66 632 Pixy2_numBlocks = dataSize / sizeof(T_pixy2Bloc); // On indique le nombre de blocs reçus
haarkon 19:007d361c8d66 633 } else { // Si ce n'est pas le bon type
haarkon 19:007d361c8d66 634 if (msg->pixType == PIXY2_REP_ERROR) { // Cela pourrait être une trame d'erreur
haarkon 19:007d361c8d66 635 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 636 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 19:007d361c8d66 637 }
haarkon 18:190e3987e274 638 etat = idle; // On annoce que la pixy est libre
haarkon 18:190e3987e274 639 break;
haarkon 18:190e3987e274 640
haarkon 18:190e3987e274 641 default : // Dans tous les autres cas
haarkon 18:190e3987e274 642 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 18:190e3987e274 643 break;
haarkon 18:190e3987e274 644 }
haarkon 18:190e3987e274 645 return cr;
haarkon 18:190e3987e274 646 }
haarkon 18:190e3987e274 647
haarkon 19:007d361c8d66 648 T_pixy2ErrorCode PIXY2::pixy2_getFeatures (){
haarkon 19:007d361c8d66 649
haarkon 19:007d361c8d66 650 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 19:007d361c8d66 651 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 19:007d361c8d66 652 T_pixy2LineFeature* lineFeature;
theolp 27:bee63ac9b70b 653 int fPointer; // Pointeur sur une feature entière
theolp 27:bee63ac9b70b 654 int fdPointer; // Pointeur sur un élément à l'intérieur d'une feature
haarkon 19:007d361c8d66 655
haarkon 19:007d361c8d66 656 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 657 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 658 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 19:007d361c8d66 659 }
haarkon 19:007d361c8d66 660 }
Wael_H 28:f1dd68d07aec 661 if (msg->pixType == PIXY2_REP_LINE) { // On vérifie que la trame est du type convenable (REPONSE LIGNE)
haarkon 19:007d361c8d66 662 fPointer = dPointer; // On pointe sur la premiere feature
haarkon 19:007d361c8d66 663 do {
haarkon 19:007d361c8d66 664 lineFeature = (T_pixy2LineFeature*) &Pixy2_buffer[fPointer]; // On mappe le pointeur de structure sur le buffer de réception des features.
haarkon 19:007d361c8d66 665 if (lineFeature->fType == PIXY2_VECTOR) { // On regarde si le type est vecteur
theolp 26:a56cc5d715e9 666 Pixy2_numVectors = lineFeature->fLength / sizeof(T_pixy2Vector); // Si oui, on compte combien il y a de vecteurs
theolp 27:bee63ac9b70b 667 fdPointer = fPointer + 2; // On pointe sur le premier élément de la feature
theolp 27:bee63ac9b70b 668 Pixy2_vectors = (T_pixy2Vector*) &Pixy2_buffer[fdPointer]; // On mappe le résultat
theolp 27:bee63ac9b70b 669 fPointer += lineFeature->fLength + 2; // On déplace le pointeur de données et on recommence
haarkon 19:007d361c8d66 670 cr |= PIXY2_VECTOR;
haarkon 19:007d361c8d66 671 }
haarkon 19:007d361c8d66 672 if (lineFeature->fType == PIXY2_INTERSECTION) { // On regarde si le type est intersection
haarkon 19:007d361c8d66 673 Pixy2_numIntersections = lineFeature->fLength / sizeof(T_pixy2Intersection);
haarkon 19:007d361c8d66 674 // Si oui, on compte combien il y a d'intersections
theolp 27:bee63ac9b70b 675 fdPointer = fPointer + 2; // On pointe sur le premier élément de la feature
theolp 27:bee63ac9b70b 676 Pixy2_intersections = (T_pixy2Intersection*) &Pixy2_buffer[fdPointer];
haarkon 19:007d361c8d66 677 // On mappe le résultat sur l'entête de l'intersection
theolp 27:bee63ac9b70b 678 fPointer += lineFeature->fLength + 2; // On déplace le pointeur de données et on recommence
haarkon 19:007d361c8d66 679 cr |= PIXY2_INTERSECTION;
haarkon 19:007d361c8d66 680 }
theolp 26:a56cc5d715e9 681 if (lineFeature->fType == PIXY2_BARCODE) { // On regarde si le type est codebarre
theolp 26:a56cc5d715e9 682 Pixy2_numBarcodes = lineFeature->fLength / sizeof(T_pixy2BarCode);
theolp 26:a56cc5d715e9 683 // Si oui, on compte combien il y a de codebarre
theolp 27:bee63ac9b70b 684 fdPointer = fPointer + 2; // On pointe sur le premier élément de la feature
theolp 27:bee63ac9b70b 685 Pixy2_barcodes = (T_pixy2BarCode*) &Pixy2_buffer[fdPointer]; // On mappe le résultat
theolp 27:bee63ac9b70b 686 fPointer += lineFeature->fLength + 2; // On déplace le pointeur de données et on recommence
theolp 26:a56cc5d715e9 687 cr |= PIXY2_BARCODE;
theolp 26:a56cc5d715e9 688 }
haarkon 19:007d361c8d66 689 } while(fPointer < ((dataSize - 1) + dPointer)); // Tant qu'il y a des données à traiter
haarkon 19:007d361c8d66 690 } else { // Si ce n'est pas le bon type
Wael_H 28:f1dd68d07aec 691 if (msg->pixType == PIXY2_REP_ERROR) { // Cela pourrait être une trame d'erreur ou quand on ne reçoit rien
haarkon 19:007d361c8d66 692 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 693 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 19:007d361c8d66 694 }
haarkon 19:007d361c8d66 695 etat = idle; // On annoce que la pixy est libre
haarkon 19:007d361c8d66 696 return cr;
haarkon 19:007d361c8d66 697 }
haarkon 19:007d361c8d66 698
haarkon 19:007d361c8d66 699
haarkon 19:007d361c8d66 700 T_pixy2ErrorCode PIXY2::pixy2_getMainFeature (Byte features){
haarkon 19:007d361c8d66 701
haarkon 19:007d361c8d66 702 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 19:007d361c8d66 703
haarkon 19:007d361c8d66 704 switch (etat) {
haarkon 19:007d361c8d66 705 case idle : // Si la caméra est inactive
haarkon 19:007d361c8d66 706 wPointer = 0; // On remonte en haut du buffer
Wael_H 28:f1dd68d07aec 707 cr = PIXY2::pixy2_sndGetLineFeature(0, features); // On envoie la trame de demande de suivi de ligne
Wael_H 28:f1dd68d07aec 708 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 19:007d361c8d66 709 etat = messageSent; // On passe à l'attente du message de réponse
Wael_H 28:f1dd68d07aec 710 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 19:007d361c8d66 711 break;
haarkon 19:007d361c8d66 712
haarkon 19:007d361c8d66 713 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 19:007d361c8d66 714 cr = PIXY2::pixy2_getFeatures(); // On appelle la fonction de traitement.
haarkon 19:007d361c8d66 715 break;
haarkon 19:007d361c8d66 716
haarkon 19:007d361c8d66 717 default : // Dans tous les autres cas
haarkon 19:007d361c8d66 718 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 19:007d361c8d66 719 break;
haarkon 19:007d361c8d66 720 }
haarkon 19:007d361c8d66 721 return cr;
haarkon 19:007d361c8d66 722 }
haarkon 19:007d361c8d66 723
haarkon 19:007d361c8d66 724 T_pixy2ErrorCode PIXY2::pixy2_getAllFeature (Byte features){
haarkon 19:007d361c8d66 725 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 19:007d361c8d66 726
haarkon 19:007d361c8d66 727 switch (etat) {
haarkon 19:007d361c8d66 728 case idle : // Si la caméra est inactive
haarkon 19:007d361c8d66 729 wPointer = 0; // On remonte en haut du buffer
haarkon 19:007d361c8d66 730 cr = PIXY2::pixy2_sndGetLineFeature(1, features); // On envoie la trame de demande de suivi de ligne
haarkon 19:007d361c8d66 731 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 19:007d361c8d66 732 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 19:007d361c8d66 733 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 19:007d361c8d66 734 break;
haarkon 19:007d361c8d66 735
haarkon 19:007d361c8d66 736 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 19:007d361c8d66 737 cr = PIXY2::pixy2_getFeatures(); // On appelle la fonction de traitement.
haarkon 19:007d361c8d66 738 break;
haarkon 19:007d361c8d66 739
haarkon 19:007d361c8d66 740 default : // Dans tous les autres cas
haarkon 19:007d361c8d66 741 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 19:007d361c8d66 742 break;
haarkon 19:007d361c8d66 743 }
haarkon 19:007d361c8d66 744 return cr;
haarkon 19:007d361c8d66 745 }
haarkon 19:007d361c8d66 746
haarkon 19:007d361c8d66 747 T_pixy2ErrorCode PIXY2::pixy2_setMode (Byte mode)
haarkon 19:007d361c8d66 748 {
haarkon 19:007d361c8d66 749 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 19:007d361c8d66 750 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 19:007d361c8d66 751
haarkon 19:007d361c8d66 752 switch (etat) {
haarkon 19:007d361c8d66 753 case idle : // Si la caméra est inactive
haarkon 19:007d361c8d66 754 wPointer = 0; // On remonte en haut du buffer
haarkon 19:007d361c8d66 755 cr = PIXY2::pixy2_sndSetMode (mode); // On envoie la trame de règlage du mode de fonctionnement du suivi de ligne
haarkon 19:007d361c8d66 756 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 19:007d361c8d66 757 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 19:007d361c8d66 758 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 19:007d361c8d66 759 break;
haarkon 19:007d361c8d66 760
haarkon 19:007d361c8d66 761 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 19:007d361c8d66 762 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 763 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 764 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 19:007d361c8d66 765 }
haarkon 19:007d361c8d66 766 }
haarkon 19:007d361c8d66 767 if ((msg->pixType == PIXY2_REP_ACK) || (msg->pixType == PIXY2_REP_ERROR)) {
haarkon 19:007d361c8d66 768 // On vérifie que la trame est du type convenable (ACK ou ERREUR)
haarkon 19:007d361c8d66 769 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 770 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 19:007d361c8d66 771 etat = idle; // On annoce que la pixy est libre
haarkon 19:007d361c8d66 772 break;
haarkon 19:007d361c8d66 773
haarkon 19:007d361c8d66 774 default : // Dans tous les autres cas
haarkon 19:007d361c8d66 775 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 19:007d361c8d66 776 break;
haarkon 19:007d361c8d66 777 }
haarkon 19:007d361c8d66 778 return cr;
haarkon 19:007d361c8d66 779 }
haarkon 19:007d361c8d66 780
haarkon 19:007d361c8d66 781 T_pixy2ErrorCode PIXY2::pixy2_setNextTurn (sWord angle)
haarkon 19:007d361c8d66 782 {
haarkon 19:007d361c8d66 783 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 19:007d361c8d66 784 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 19:007d361c8d66 785
haarkon 19:007d361c8d66 786 switch (etat) {
haarkon 19:007d361c8d66 787 case idle : // Si la caméra est inactive
haarkon 19:007d361c8d66 788 wPointer = 0; // On remonte en haut du buffer
haarkon 19:007d361c8d66 789 cr = PIXY2::pixy2_sndSetNextTurn (angle); // On envoie la trame de choix de l'angle du prochain virage
haarkon 19:007d361c8d66 790 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 19:007d361c8d66 791 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 19:007d361c8d66 792 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 19:007d361c8d66 793 break;
haarkon 19:007d361c8d66 794
haarkon 19:007d361c8d66 795 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 19:007d361c8d66 796 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 797 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 798 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 19:007d361c8d66 799 }
haarkon 19:007d361c8d66 800 }
haarkon 19:007d361c8d66 801 if ((msg->pixType == PIXY2_REP_ACK) || (msg->pixType == PIXY2_REP_ERROR)) {
haarkon 19:007d361c8d66 802 // On vérifie que la trame est du type convenable (ACK ou ERREUR)
haarkon 19:007d361c8d66 803 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 804 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 19:007d361c8d66 805 etat = idle; // On annoce que la pixy est libre
haarkon 19:007d361c8d66 806 break;
haarkon 19:007d361c8d66 807
haarkon 19:007d361c8d66 808 default : // Dans tous les autres cas
haarkon 19:007d361c8d66 809 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 19:007d361c8d66 810 break;
haarkon 19:007d361c8d66 811 }
haarkon 19:007d361c8d66 812 return cr;
haarkon 19:007d361c8d66 813 }
haarkon 19:007d361c8d66 814
haarkon 19:007d361c8d66 815 T_pixy2ErrorCode PIXY2::pixy2_setDefaultTurn (sWord angle)
haarkon 19:007d361c8d66 816 {
haarkon 19:007d361c8d66 817 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 19:007d361c8d66 818 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 19:007d361c8d66 819
haarkon 19:007d361c8d66 820 switch (etat) {
haarkon 19:007d361c8d66 821 case idle : // Si la caméra est inactive
haarkon 19:007d361c8d66 822 wPointer = 0; // On remonte en haut du buffer
haarkon 19:007d361c8d66 823 cr = PIXY2::pixy2_sndSetDefaultTurn (angle); // On envoie la trame de choix de l'angle par défaut des virages
haarkon 19:007d361c8d66 824 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 19:007d361c8d66 825 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 19:007d361c8d66 826 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 19:007d361c8d66 827 break;
haarkon 19:007d361c8d66 828
haarkon 19:007d361c8d66 829 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 19:007d361c8d66 830 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 831 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 832 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 19:007d361c8d66 833 }
haarkon 19:007d361c8d66 834 }
haarkon 19:007d361c8d66 835 if ((msg->pixType == PIXY2_REP_ACK) || (msg->pixType == PIXY2_REP_ERROR)) {
haarkon 19:007d361c8d66 836 // On vérifie que la trame est du type convenable (ACK ou ERREUR)
haarkon 19:007d361c8d66 837 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 838 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 19:007d361c8d66 839 etat = idle; // On annoce que la pixy est libre
haarkon 19:007d361c8d66 840 break;
haarkon 19:007d361c8d66 841
haarkon 19:007d361c8d66 842 default : // Dans tous les autres cas
haarkon 19:007d361c8d66 843 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 19:007d361c8d66 844 break;
haarkon 19:007d361c8d66 845 }
haarkon 19:007d361c8d66 846 return cr;
haarkon 19:007d361c8d66 847 }
haarkon 19:007d361c8d66 848
haarkon 19:007d361c8d66 849 T_pixy2ErrorCode PIXY2::pixy2_setVector (Byte vectorIndex)
haarkon 19:007d361c8d66 850 {
haarkon 19:007d361c8d66 851 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 19:007d361c8d66 852 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 19:007d361c8d66 853
haarkon 19:007d361c8d66 854 switch (etat) {
haarkon 19:007d361c8d66 855 case idle : // Si la caméra est inactive
haarkon 19:007d361c8d66 856 wPointer = 0; // On remonte en haut du buffer
haarkon 19:007d361c8d66 857 cr = PIXY2::pixy2_sndSetVector (vectorIndex); // On envoie la trame de choix du vecteur à suivre
haarkon 19:007d361c8d66 858 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 19:007d361c8d66 859 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 19:007d361c8d66 860 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 19:007d361c8d66 861 break;
haarkon 19:007d361c8d66 862
haarkon 19:007d361c8d66 863 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 19:007d361c8d66 864 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 865 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 866 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 19:007d361c8d66 867 }
haarkon 19:007d361c8d66 868 }
haarkon 19:007d361c8d66 869 if ((msg->pixType == PIXY2_REP_ACK) || (msg->pixType == PIXY2_REP_ERROR)) {
haarkon 19:007d361c8d66 870 // On vérifie que la trame est du type convenable (ACK ou ERREUR)
haarkon 19:007d361c8d66 871 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 872 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 19:007d361c8d66 873 etat = idle; // On annoce que la pixy est libre
haarkon 19:007d361c8d66 874 break;
haarkon 19:007d361c8d66 875
haarkon 19:007d361c8d66 876 default : // Dans tous les autres cas
haarkon 19:007d361c8d66 877 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 19:007d361c8d66 878 break;
haarkon 19:007d361c8d66 879 }
haarkon 19:007d361c8d66 880 return cr;
haarkon 19:007d361c8d66 881 }
haarkon 19:007d361c8d66 882
haarkon 19:007d361c8d66 883
haarkon 19:007d361c8d66 884 T_pixy2ErrorCode PIXY2::pixy2_ReverseVector (void)
haarkon 19:007d361c8d66 885 {
haarkon 19:007d361c8d66 886 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 19:007d361c8d66 887 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 19:007d361c8d66 888
haarkon 19:007d361c8d66 889 switch (etat) {
haarkon 19:007d361c8d66 890 case idle : // Si la caméra est inactive
haarkon 19:007d361c8d66 891 wPointer = 0; // On remonte en haut du buffer
haarkon 19:007d361c8d66 892 cr = PIXY2::pixy2_sndReverseVector (); // On envoie la trame d'inversion de l'image (haut en bas et bas en haut)
haarkon 19:007d361c8d66 893 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 19:007d361c8d66 894 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 19:007d361c8d66 895 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 19:007d361c8d66 896 break;
haarkon 19:007d361c8d66 897
haarkon 19:007d361c8d66 898 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 19:007d361c8d66 899 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 900 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 19:007d361c8d66 901 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 19:007d361c8d66 902 }
haarkon 19:007d361c8d66 903 }
haarkon 19:007d361c8d66 904 if ((msg->pixType == PIXY2_REP_ACK) || (msg->pixType == PIXY2_REP_ERROR)) {
haarkon 19:007d361c8d66 905 // On vérifie que la trame est du type convenable (ACK ou ERREUR)
haarkon 19:007d361c8d66 906 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 19:007d361c8d66 907 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 19:007d361c8d66 908 etat = idle; // On annoce que la pixy est libre
haarkon 19:007d361c8d66 909 break;
haarkon 19:007d361c8d66 910
haarkon 19:007d361c8d66 911 default : // Dans tous les autres cas
haarkon 19:007d361c8d66 912 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 19:007d361c8d66 913 break;
haarkon 19:007d361c8d66 914 }
haarkon 19:007d361c8d66 915 return cr;
haarkon 19:007d361c8d66 916 }
haarkon 19:007d361c8d66 917
Wael_H 28:f1dd68d07aec 918 T_pixy2ErrorCode PIXY2::pixy2_getRGB (Word x, Word y, Byte saturate, T_pixy2Pixel **pixel){
haarkon 19:007d361c8d66 919
haarkon 20:8e3adcaab290 920 T_pixy2RcvHeader *msg = (T_pixy2RcvHeader*) &Pixy2_buffer[hPointer];
haarkon 20:8e3adcaab290 921 T_pixy2ErrorCode cr = PIXY2_OK;
haarkon 20:8e3adcaab290 922
haarkon 20:8e3adcaab290 923 switch (etat) {
haarkon 20:8e3adcaab290 924 case idle : // Si la caméra est inactive
haarkon 20:8e3adcaab290 925 wPointer = 0; // On remonte en haut du buffer
haarkon 20:8e3adcaab290 926 cr = PIXY2::pixy2_sndGetRGB(x, y, saturate); // On envoie la trame de demande de la couleur (RGB) d'un carée de pixel
haarkon 20:8e3adcaab290 927 if (cr!= PIXY2_OK) return cr; // S'il y a une erreur lors de l'envoi on ejecte !
haarkon 20:8e3adcaab290 928 etat = messageSent; // On passe à l'attente du message de réponse
haarkon 20:8e3adcaab290 929 cr = PIXY2_BUSY; // On signale à l'utilisateur que la caméra est maintenant occupée
haarkon 20:8e3adcaab290 930 break;
haarkon 20:8e3adcaab290 931
Wael_H 28:f1dd68d07aec 932 case dataReceived : // Quand on a reçu l'intégralité du message
haarkon 20:8e3adcaab290 933 if (frameContainChecksum) { // Si la trame contient un checksum
theolp 25:2a2fcb9e4775 934 if (pixy2_validateChecksum (&Pixy2_buffer[hPointer]) != 0) { // On lance la validation du checksum
haarkon 20:8e3adcaab290 935 return PIXY2_BAD_CHECKSUM; // Si le checksum est faux on retourne une erreur
haarkon 20:8e3adcaab290 936 }
haarkon 20:8e3adcaab290 937 }
haarkon 20:8e3adcaab290 938 if (msg->pixType == PIXY2_REP_ACK) { // On vérifie que la trame est du type convenable (REPONSE ACK)
Wael_H 28:f1dd68d07aec 939 *pixel = (T_pixy2Pixel*) &Pixy2_buffer[dPointer]; // On mappe le pointeur de structure sur le buffer de réception.
haarkon 20:8e3adcaab290 940 } else { // Si ce n'est pas le bon type
haarkon 20:8e3adcaab290 941 if (msg->pixType == PIXY2_REP_ERROR) { // Cela pourrait être une trame d'erreur
haarkon 20:8e3adcaab290 942 cr = *(T_pixy2ErrorCode*) &Pixy2_buffer[dPointer]; // Si c'est le cas, on copie le code d'erreur reçu dans la variable de retour
haarkon 20:8e3adcaab290 943 } else cr = PIXY2_TYPE_ERROR; // Si le type ne correspond à rien de normal on signale une erreur de type.
haarkon 20:8e3adcaab290 944 }
haarkon 20:8e3adcaab290 945 etat = idle; // On annoce que la pixy est libre
haarkon 20:8e3adcaab290 946 break;
haarkon 20:8e3adcaab290 947
haarkon 20:8e3adcaab290 948 default : // Dans tous les autres cas
haarkon 20:8e3adcaab290 949 cr = PIXY2_BUSY; // On signale que la caméra est occupée.
haarkon 20:8e3adcaab290 950 break;
haarkon 20:8e3adcaab290 951 }
haarkon 20:8e3adcaab290 952 return cr;
haarkon 20:8e3adcaab290 953 }
haarkon 20:8e3adcaab290 954
haarkon 20:8e3adcaab290 955
haarkon 0:dde1b9d6c9d6 956
haarkon 11:68ef9f85e40e 957 T_pixy2ErrorCode PIXY2::pixy2_validateChecksum (Byte* tab){
haarkon 1:dd81f4065b6b 958 Word i, sum = 0;
haarkon 1:dd81f4065b6b 959 T_Word *tmp;
haarkon 0:dde1b9d6c9d6 960
haarkon 1:dd81f4065b6b 961 for (i=0; i<*(tab+3);i++) sum = sum + *(tab + PIXY2_CSHEADERSIZE + i);
haarkon 1:dd81f4065b6b 962 tmp = (T_Word*) (tab+4);
theolp 22:5f76404e2cbc 963
haarkon 12:7493191dd1dc 964 if (tmp->mot == sum) return PIXY2_OK;
theolp 22:5f76404e2cbc 965 else {
theolp 22:5f76404e2cbc 966 if (_DEBUG_) {
theolp 22:5f76404e2cbc 967 sommeDeControle = sum;
theolp 22:5f76404e2cbc 968 sommeRecue = tmp->mot;
theolp 22:5f76404e2cbc 969 }
theolp 22:5f76404e2cbc 970 return PIXY2_BAD_CHECKSUM;
theolp 22:5f76404e2cbc 971 }
haarkon 1:dd81f4065b6b 972 }