Theo Le Paih / 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@27:bee63ac9b70b, 2020-01-21 (annotated)

Committer:
theolp
Date:
Tue Jan 21 12:59:37 2020 +0000
Revision:
27:bee63ac9b70b
Parent:
26:a56cc5d715e9 
Last

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