Modifications

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)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.  

*On synchronise donc 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. Il faut aussi accordé l'horloge de l'application afin qu'elle soit en phase avec le code de la STM32

*(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.

*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 (par exemple : -9999). 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))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>

*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>

  uint8_t MCP233_readEncoderCountM1(MCP233_t *mcp, int32_t *count) et <br>

  uint8_t MCP233_readEncoderCountM1(MCP233_t *mcp, int32_t *count)  

  uint8_t MCP233_readEncoderCountM2(MCP233_t *mcp, int32_t *count) <br>

  uint8_t MCP233_readEncoderCountM2(MCP233_t *mcp, int32_t *count)  

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.

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. <br>

*(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>

En ce qui concerne la valeur de la tension de la batterie, il faut récupérer cette valeur sur le bus CAN1 car cette valeur est gérée par une autre STM32 qui communique avec notre STM32 par bus CAN. La communication n'étant pas encore en place, nous ne pouvons pas encore récupérer la valeur de tension. Mais nous avons mis tout en place pour implémenter cette fonctionnalité. <br>

*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>

(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>

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>

  distRd = distRd + encRd;   

  distRg = distRg + encRg;  <br>

  distRg = distRg + encRg;   

  distTot = ((M_PI*2*R/incr)*(distRd+distRg))/2;  (à noter que le résultat est en mm ici) <br>

  distTot = ((M_PI*2*R/incr)*(distRd+distRg))/2;  (à noter que le résultat est en mm ici)  

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>

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>

  dist = (M_PI*2*R/incr)*((encRd+encRg)/2); //en mm   

  speed = (dist/time)*100; // en cm/s  <br>

  speed = (dist/time)*100; // en cm/s   

Pour la position (x,y) du robot, on calcule d'abord l'angle du robot par rapport à son angle d'origine : <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>

angle = ((M_PI*2*R/incr)*((distRd-distRg)/LargRobot));  //angle en radian   

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>

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>

  posx = (cos(angle)*dist)+posx;  //posx en mm   

  posy = (sin(angle)*dist)+posy;  //posy en mm  <br>

  posy = (sin(angle)*dist)+posy;  //posy en mm   

*(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>

*(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_enco,"%5d",(int)distTot);    // distance parcourue en mm   

  sprintf(buff_tens,"%5d",(int)Voltage);    // pas encore opérationnel  <br>

  sprintf(buff_tens,"%5d",(int)Voltage);    // pas encore opérationnel   

  sprintf(buff_vit,"%5d",(int)speed);  <br>

  sprintf(buff_vit,"%5d",(int)speed);   

  sprintf(buff_posx,"%5d",(int)posx);    // en mm  <br>

  sprintf(buff_posx,"%5d",(int)posx);    // en mm   

  sprintf(buff_posy,"%5d",(int)posy);    // en mm  <br>

  sprintf(buff_posy,"%5d",(int)posy);    // en mm   

On passe ensuite à l'envoie. On utilise la fonction mise à disposition par l'outil STM32CubeIDE : <br>

On passe ensuite à l'envoie. On utilise la fonction mise à disposition par l'outil STM32CubeIDE : <br>

  HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);  <br>

  HAL_StatusTypeDef HAL_UART_Transmit_IT(UART_HandleTypeDef *huart, uint8_t *pData, uint16_t Size);   

L'argument (UART_HandleTypeDef *huart) sert à sélectionner l'uart sur lequel est branché notre module HC-06 <br>

L'argument (UART_HandleTypeDef *huart) sert à sélectionner l'uart sur lequel est branché notre module HC-06 <br>

L'argument (uint8_t *pData) est celui sur lequel on va rentrer notre buffer où est contenue la données (on mettra (int8_t*)buffer car la fonction attend un buffer en int8_t* alors que notre buffer est en format char de base). <br>

L'argument (uint8_t *pData) est celui sur lequel on va rentrer notre buffer où est contenue la données (on mettra (int8_t*)buffer car la fonction attend un buffer en int8_t* alors que notre buffer est en format char de base). <br>