143
modifications
Modifications
→Affichage des données
On commence par envoyer le flag, nous avons choisi de lui donner la valeur -100. Ce flag nous sera utile pour la suite car cela signalera à l'application qui réceptionne les données quand nous serons au début de la boucle while du code. Cela permet donc de synchroniser l'envoi des données.
On commence par envoyer le flag, nous avons choisi de lui donner la valeur -100. Ce flag nous sera utile pour la suite car cela signalera à l'application qui réceptionne les données quand nous serons au début de la boucle while du code. Cela permet donc de synchroniser l'envoi des données.
On convertit ensuite chacune des valeurs a envoyer en texte afin de pouvoir les envoyer sous forme de texte à l'aide de la fonction sprintf.
On convertit ensuite chacune des valeurs a envoyer en texte afin de pouvoir les envoyer sous forme de texte à l'aide de la fonction sprintf.
*parler de la synchronisation de la clock de l'appli avec la synchronisation des Delay.
*(parler de la synchronisation de la clock de l'appli avec la synchronisation des Delay)On synchronise ensuite les données de manières temporelles, afin que l'application reçoive les données régulièrement et est le temps de les traiter et de les afficher, d'où la présence de "osDelay" dans le code de la stm32.
*parler de la valeur du flag
*(parler de la valeur du flag)Afin de synchroniser l'arriver des données, on envoie un flag qui équivaut à une valeur fixe, reconnaissable facilement et difficilement atteignable par les autres valeurs des autres buffers. Celui-ci permet donc de signaler à l'application, qu'un cycle d'envoie des données commence.
*parler de comment on récupére les données dans le code du robot (encodeurs et tension)
*(parler de comment on récupére les données dans le code du robot (encodeurs et tension))Les encodeurs sont gérer par un contrôleur MCP233 sur le robot, qui est connecté à l'UART1 de la stm32. On doit donc récupérer les valeurs des encodeurs à travers l'UART1 et le MCP233. On utilise des fonctions déjà crées par les équipes de Polybot, à savoir : <br>
*parler des calculs pour déterminer les valeurs de la vitesse et de la position.
uint8_t MCP233_readEncoderCountM1(MCP233_t *mcp, int32_t *count) et <br>
*parler des différentes lignes de code : sprintf, hal_uart_transmit, osDelay(200)...
uint8_t MCP233_readEncoderCountM2(MCP233_t *mcp, int32_t *count) <br>
Elles permettent de récupérer les valeurs d'incrémentation des encodeurs et les stockent à des adresses (int32_t *count). L'argument (MCP233_t *mcp) permet quant à lui de lire dans le contrôleur MCP233.
*(parler des calculs pour déterminer les valeurs de la vitesse et de la position) Afin d'obtenir les différentes données à envoyer, à savoir la vitesse, la distance parcourue, ainsi que la position (x,y) du robot, nous devons mettre en place des calculs spécifiques. On notera que l'on ne peut pas reset les encodeurs car ceux ci servent aussi à asservir les moteurs du robot en position. On va donc d'abord mettre en place quelques lignes permettant de faire nos calculs comme si nous avions un reset des encodeurs : <br>
(lignes de code) <br>
On en vient maintenant aux calculs en eux même. Pour la distance totale parcourue, on met en place des variables qui calculent le cumul des incréments des encodeurs depuis le démarrage du robot, on calcule ensuite la moyenne des valeurs (des 2 encodeurs) afin d'obtenir la distance parcourue par le centre du robot. Finalement, on vient multiplier cette résultante par 2xpixR/incr (incr étant le nombre incréments de l'encodeurs lorsqu'il effectue un tour et R le rayon des encodeurs) : <br>
distRd = distRd + encRd; <br>
distRg = distRg + encRg; <br>
distTot = ((M_PI*2*R/incr)*(distRd+distRg))/2; (à noter que le résultat est en mm ici) <br>
Pour la vitesse, on doit d'abord calculer la distance parcourue par le robot entre 2 prises de valeurs d'encodeurs, afin d'avoir une vitesse le plus instantané possible. On calcule donc cette distance exactement de la même manière que précédemment sauf qu'on ne cumule pas les valeurs d'incréments des encodeurs, en effet, on veut ici les valeurs d'incrémentation momentanées. On vient ensuite faire un rapport dist/time (dist étant la valeur que l'on vient de calculer, time étant le temps d'exécution d'une boucle d'envoie des données, on estime sa valeur par rapport aux "osDelay") : <br>
dist = (M_PI*2*R/incr)*((encRd+encRg)/2); //en mm <br>
speed = (dist/time)*100; // en cm/s <br>
Pour la position (x,y) du robot, on calcule d'abord l'angle du robot par rapport à son angle d'origine : <br>
angle = ((M_PI*2*R/incr)*((distRd-distRg)/LargRobot)); //angle en radian <br>
On calcule ensuite les positions x et y en faisant respictivement le cosinus et sinus de l'angle multiplié par la distance parcourue entre 2 relevés d'encodeurs auxquels on ajoute les positions precédentes afin de pouvoir voir le robot se déplacer comme s'il était dans un repère orthonormé : <br>
posx = (cos(angle)*dist)+posx; //posx en mm <br>
posy = (sin(angle)*dist)+posy; //posy en mm <br>
*(parler des différentes lignes de code : sprintf, hal_uart_transmit, osDelay(200)...) On en vient maintenant à l'envoie des données. On commence par concaténer nos valeurs à envoyer dans des buffer char grâce à la fonction sprintf : <br>
sprintf(buff_enco,"%5d",(int)distTot); // distance parcourue en mm <br>
sprintf(buff_tens,"%5d",(int)Voltage); // pas encore opérationnel <br>
sprintf(buff_vit,"%5d",(int)speed); <br>
sprintf(buff_posx,"%5d",(int)posx); // en mm <br>
sprintf(buff_posy,"%5d",(int)posy); // en mm <br>
On passe ensuite à l'envoie. On utilise la fonction : <br>
HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size); <br>
L'argument (UART_HandleTypeDef *huart) sert
*dire qu'après on peut tester sur le vrai robot
*dire qu'après on peut tester sur le vrai robot