Modifications

Afin de vous aider à mieux comprendre la façon dont nous avons réalisé notre projet, nous avons rédigé ce document tutoriel. Cela devrait vous permettre de réussir à reprendre les différentes étapes du projet si nécessaire.

Afin de vous aider à mieux comprendre la façon dont nous avons réalisé notre projet, nous avons rédigé ce document tutoriel. Cela devrait vous permettre de réussir à reprendre les différentes étapes du projet si nécessaire.

=Projet 1 : Carte d'alimentation=

=Projet 1 : Carte d'alimentation=

==Procédure générale==

==Procédure générale==

Pour pouvoir utiliser notre application vous devez :  

Pour pouvoir utiliser notre application vous devez :  

*Télécharger les applis et docs nécessaires + l'application Polybot (voir section ci-dessous)

*Télécharger les applis et docs nécessaires + l'application Polybot (voir section "Télécharger l'application")

*Câbler le module sur la STM32 (voir section ci-dessous)

*Câbler le module sur la STM32 (voir section "Cablâge des modules")

*Connecter le téléphone/tablette au module Bluetooth dans les paramètres généraux

*Connecter le téléphone/tablette au module Bluetooth dans les paramètres généraux

*Lancer l'application (le robot doit être allumé)

*Lancer l'application (le robot doit être allumé)

*Installer de "Cx Explorateur de fichier"  

*Installer de "Cx Explorateur de fichier"  

*Brancher votre mobile sur un ordinateur

*Brancher votre mobile sur un ordinateur

*Télécharger le dossier AppInventor à ce lien : (créer sur le drive polybot)

*Télécharger le dossier AppInventor à ce lien : [https://drive.google.com/drive/folders/1-9vrBf9ciiOXk0jMBe_aJsc4PlTqDaVl?usp=sharing Dossier AppInventor]

*Copier/coller ce dossier AppInventor dans votre téléphone (dans le stockage général)

*Dézippez puis copier/coller ce dossier AppInventor dans votre téléphone (dans le stockage général)

*Depuis votre téléphone, téléchargez l'application au format .apk au lien suivant : (mettre lien Drive) puis suivez les consignes jusque l'installation de l'application

*Depuis votre téléphone, téléchargez l'application au format .apk au lien suivant : [https://drive.google.com/file/d/1X_COMQBpWy7zllDSmKVcEQrs_f51KMpv/view?usp=sharing Application Polybot]

*Puis suivez les consignes jusque l'installation de l'application

*Lancez l'application puis continuez de suivre les étapes de la section : Procédure Générale

*Lancez l'application puis continuez de suivre les étapes de la section : Procédure Générale

*Si vous souhaitez modifier l'application, vous devez télécharger le fichier .aia au lien suivant : (mettre lien drive); ouvrir la page web MIT app inventor et téléchager dessus le .aia

Si vous souhaitez modifier l'application, vous devez :

*Télécharger le fichier .aia au lien suivant : [https://drive.google.com/file/d/1XvCx8m_984NGFHAy1XcAURyGfx47GXMH/view?usp=sharing Application .aia]

*Ouvrir la page web MIT App inventor et y charger le fichier .aia

ATTENTION vous ne pouvez pas modifier le code de la STM32 sans modifier le code Scratch de l'application.

'''ATTENTION''' vous ne pouvez pas modifier le code de la STM32 sans modifier le code Scratch de l'application (dans certains cas) !

Rappels des différents Screen crées :  

 

Voici les différents Screen crées :  

* Screen 1 : Page de lancement avec logo Polybot

* Screen 1 : Page de lancement avec logo Polybot

* Screen 2 : Choix des valeurs à afficher et choix de stocker ou non les données affichées

* Screen 2 : Choix des valeurs à afficher et choix de stocker ou non les données affichées

* Screen 3 : Affichage des données souhaitées

* Screen 3 : Affichage des données souhaitées

 

[[Fichier:Screen1.png|150px|vignette|centré|Screen 1 de l'application]]

[[Fichier:Screen1.png|250px|vignette|centré|Screen 1 de l'application]]

[[Fichier:Screen2.png|150px|vignette|centré|Screen 2 de l'application]]

[[Fichier:Screen2.png|250px|vignette|centré|Screen 2 de l'application]]

[[Fichier:Appli2.png|150px|vignette|centré|Screen 3 de l'application]]

[[Fichier:Appli2.png|250px|vignette|centré|Screen 3 de l'application]]

 

 

[[Projet_5A_2020_2021/Tuto utilisation et modification|Tutoriel d’utilisation]]

<br>

<br>

Étant donné que nous avons utilisé App Inventor pour réaliser notre application, nous avons uniquement pu utiliser du Scratch pour coder le fonctionnement de l'appli. Malheureusement ce langage de programmation sous forme de blocs entraine souvent de grosses suites de blocs pas toujours très lisibles. Nous allons donc essayer de vous expliquer clairement et simplement ce que nous avons réalisé pour chaque Screen.

Étant donné que nous avons utilisé App Inventor pour réaliser notre application, nous avons uniquement pu utiliser du Scratch pour coder le fonctionnement de l'appli. Malheureusement ce langage de programmation sous forme de blocs entraine souvent de grosses suites de blocs pas toujours très lisibles. Nous allons donc essayer de vous expliquer clairement et simplement ce que nous avons réalisé pour chaque Screen.

*Screen 1 : on affiche simplement le logo de Polybot pendant 4 secondes puis on ouvre le Screen suivant.

*Screen 1 : on affiche simplement le logo de Polybot pendant 4 secondes puis on ouvre le Screen suivant. La fonction "when clock1.timer" va permettre de synchroniser des actions (lance une sorte de chrono). Dans la partie interface, on peut choisir la fréquence de la Clock (par exemple 1s ou 200ms).

[[Fichier:Code1.png|vignette|centré|Code pour le Screen 1 ]]

[[Fichier:Code1.png|vignette|centré|Code pour le Screen 1 ]]

*Screen 2 : on initialise les variables globales qui nous indiqueront si les valeurs ont été cochées (1) ou décochées (0), c'est à dire si on souhaite les afficher par la suite ou non. On aura donc une variables globale pour chaque donnée à afficher (distance parcourue, tension, vitesse, position...).

*Screen 2 : on initialise les variables globales qui nous indiqueront si les valeurs ont été cochées (1) ou décochées (0), c'est à dire si on souhaite les afficher par la suite ou non. On aura donc une variables globale pour chaque donnée à afficher (distance parcourue, tension, vitesse, position...).

[[Fichier:Code2 2.png|vignette|centré|Stockage des variables]]

[[Fichier:Code2 2.png|vignette|centré|Stockage des variables]]

*Screen 3 : à l'ouverture du Screen on va récupérer les valeurs des variables globales dans la base de donnée. En fonction de leur valeur (0 ou 1) on rendra visible ou non les données correspondantes. Par exemple, si la variable box_tension vaut 1 alors les valeurs de la tension seront rendues invisibles sur l'écran.

*Screen 3 : à l'ouverture du Screen on va récupérer les valeurs des variables globales dans la base de donnée. En fonction de leur valeur (0 ou 1) on rendra visible ou non les données correspondantes. Par exemple, si la variable box_tension vaut 1 alors les valeurs de la tension seront rendues invisibles sur l'écran. On met donc toutes ces fonctions dans le bloc "when Screen3.initialize", c'est à dire qu'on passera une fois dans ce bloc lors du lancement du screen.

[[Fichier:Code3 1.png|vignette|centré|Récupération des variables globales]]

[[Fichier:Code3 1.png|vignette|centré|Récupération des variables globales]]

On configure ensuite le bouton qui nous permet d'aller nous connecter au périphérique souhaité (ici notre module HC-06). Il affiche la liste des périphériques Bluetooth connecté, après en avoir sélectionné un on affiche "Périphérique Connecté".

On configure ensuite le bouton qui nous permet d'aller nous connecter au périphérique souhaité (ici notre module HC-06). Il affiche la liste des périphériques Bluetooth connecté, après en avoir sélectionné un on affiche "Périphérique Connecté".

[[Fichier:Code3 3.png|vignette|700px|centré|Réception et affichage des données]]

[[Fichier:Code3 3.png|vignette|700px|centré|Réception et affichage des données]]

====Stockage des données====

====Stockage des données====

==Explication du code et lien vers le Git==

==Explication du code et lien vers le Git==

===Code STMCubeIDE===

===Explication du Code STMCubeIDE===

Pour réaliser la communication UART entre la STM32 et notre module Bluetooth, on commence par brancher les câbles comme mentionnées un peu plus haut. On doit ensuite configurer notre projet sur STMCubeIDE. Pour cela il suffit de sélectionner l'UART, de l'activer puis de régler certains paramètres.

Comme nous l'avons expliqué dans le rapport nous avons utilisé les fonctions suivantes dans notre code sur STMCubeIDE ;

On pourra ainsi modifier le baudrate, la structure de la trame (nombre de bit de stop, nombre de bits de données...), activer ou non les interruptions... Dans notre cas, on choisira le mode Asynchrone pour l'UART, un baudrate de 9600 et on activera les interruptions.

 

Une fois ces réglages réalisés, notre communication est opérationnelle. On pourra ainsi utiliser différentes fonctions dans le code de la STM32 pour envoyer les données sur les pins de l'UART4.

  '''HAL_UART_Transmit_IT'''(&huart4, (uint8_t*) txt_a_envoyer,sizeof(txt_a_envoyer));

  '''HAL_UART_Transmit_IT'''(&huart4, (uint8_t*) txt_a_envoyer,sizeof(txt_a_envoyer));

  '''HAL_Delay'''(temps) qu'on remplacera par osDelay(temps) avec l'utilisation de FreeRTOS

  '''HAL_Delay'''(temps) qu'on remplacera par osDelay(temps) avec l'utilisation de FreeRTOS

[[Fichier:Terminal text.png|200px|vignette|centré|Réception des données ]]

[[Fichier:Terminal text.png|200px|vignette|centré|Réception des données ]]

'''Choix des valeurs à afficher'''<br>

Pour rappel, nous avons affichés à l'écran les données suivantes :  

Nous avons discuté avec les autres groupes travaillant sur le robot pour savoir quels types d'informations ils aimeraient que l'on affiche sur notre écran.

Nous allons donc afficher les données suivantes :

*Tension de la batterie

*Tension de la batterie

*Distance parcourue

*Distance parcourue

*Vitesse du robot

*Vitesse du robot

*Coordonnées du robot (position)

*Coordonnées du robot (position x et y)

 

 

<br>

<br>

Pour transmettre les différentes valeurs souhaitées, nous avons ajouté dans le code de la STM les fonctions mentionnées plus haut.  

Pour transmettre les différentes valeurs souhaitées, nous avons ajouté dans le code de la STM les fonctions mentionnées plus haut.  

On envoie ensuite les données dans un ordre précis : on commence par envoyer le flag qui va nous permettre de marquer le début de chaque nouveau while, nous avons choisi de lui donner la valeur -9999 car cette valeur ne peut être atteinte par aucune autre données que nous affichons. Il n'y a donc pas de problème possible de ce côté là. 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 envoie ensuite les données dans un ordre précis : on commence par envoyer le flag qui va nous permettre de marquer le début de chaque nouveau while, nous avons choisi de lui donner la valeur -9999 car cette valeur ne peut être atteinte par aucune autre données que nous affichons. Il n'y a donc pas de problème possible de ce côté là. 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.

*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 au début de chaque boucle (plus facile pour calculer la différence de tour par rapport à la boucle précédente) 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. On commence par stocker les valeurs des encodeurs avant que ceux ci soient mis à jour avec la fonction de lecture des encodeurs, on récupère ensuite les nouvelles valeurs puis on réalise la différence entre ces 2 valeurs. On obtient alors le nombre de tours en plus (ou en moins dans le cas d'une marche arrière) par rapport au while précédent.

*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 au début de chaque boucle (plus facile pour calculer la différence de tour par rapport à la boucle précédente) 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. On commence par stocker les valeurs des encodeurs avant que ceux ci soient mis à jour avec la fonction de lecture des encodeurs, on récupère ensuite les nouvelles valeurs puis on réalise la différence entre ces 2 valeurs. On obtient alors le nombre de tours en plus (ou en moins dans le cas d'une marche arrière) par rapport au while précédent.

  encRg_save = encRg;

  encRg_save = encRg + encRg_save; //encRg_save et encRd_save sont définis ici pour être la valeur des encodeurs avant le relèvement des encodeurs

  encRd_save = encRd;

  encRd_save = encRd + encRd_save;

  MCP233_readEncoderCountM1(&mcp,&encRg);

  MCP233_readEncoderCountM1(&mcp,&encRg); //relèvement de la valeurs des encodeurs et mises dans encRg (encodeur gauche)

  MCP233_readEncoderCountM2(&mcp,&encRd);

  MCP233_readEncoderCountM2(&mcp,&encRd); //relèvement de la valeurs des encodeurs et mises dans encRd (encodeur droit)

  encRg = encRg - encRg_save;

  encRg = encRg - encRg_save; //on corrige ici encRg et encRd pour qu'ils correspondent aux valeurs d'encodeurs d'un cycle (et non total)

  encRd = encRd - encRd_save;

  encRd = encRd - encRd_save;

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 2*pi*R/incr (incr étant le nombre incréments de l'encodeurs lorsqu'il effectue un tour et R le rayon des encodeurs). Dans notre cas on aura incr = 4096 et R=44mm. <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 2*pi*R/incr (incr étant le nombre incréments de l'encodeurs lorsqu'il effectue un tour et R le rayon des encodeurs). Dans notre cas on aura incr = 4096 et R=44mm. <br>

  distRd = distRd + encRd;   

  distRd = distRd + encRd;  //calcul de la valeur total de l'encodeur droit depuis le démarrage du robot

  distRg = distRg + encRg;   

  distRg = distRg + encRg;  //calcul de la valeur total de l'encodeur gauche depuis le démarrage du robot

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

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

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   

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

  HAL_UART_Transmit_IT(&huart3, (uint8_t*) buff_posy,sizeof(buff_posy)); // position y

  HAL_UART_Transmit_IT(&huart3, (uint8_t*) buff_posy,sizeof(buff_posy)); // position y

  osDelay(400);

  osDelay(400);

===Récupérer le code général===

 

 

===Récupérer du code général===

Pour pouvoir accéder au code général du robot vous devez :

Pour pouvoir accéder au code général du robot vous devez :

*Créer un compte GitLab

*Créer un compte GitLab

*Contacter le responsable de Polybot pour qu'il vous donne l'accès aux Git de polybot

*Contacter le responsable de Polybot (Errikos Messara) pour qu'il vous donne l'accès aux Git de Polybot

*Accéder au dossier concerné

*Accéder au dossier concerné

*Télécharger le master

*Télécharger le master

<br>

<br>

Si vous souhaitez uniquement regarder la tâche relative à notre partie du projet, vous pourrez la trouver sous format .txt au lien suivant : METTRE LE LIEN DE NOTRE CODE

Si vous souhaitez uniquement regarder la tâche relative à notre partie du projet, vous pourrez la trouver sous format .txt au lien suivant : [https://drive.google.com/file/d/1vw60jSFCPwRbrCF2yBndYtXRUh3kE4vX/view?usp=sharing Code .txt]

==Utilisation des modules Bluetooth HC-06==

==Utilisation des modules Bluetooth HC-06==

|}

|}

===Traiter les données enregistrées - Tracer la trajectoire du robot===

===Voir et traiter les données enregistrées - Tracer la trajectoire du robot===

*Ouvrir le fichier "stockage_data_robot.csv" qui se trouve dans le dossier AppInventor/asset

*Sélectionner le tableau en entier

*Ouvrir l'application "Cx Explorateur de fichiers" (ou connecter votre périphérique à un PC)

*Aller sur "Données" puis cliquer sur "Convertir" :  

->délimité, virgule, identif de texte ", standart TERMINER

 

*Sélection de pos x et pos y  

*Insertion nuage de point

*Ouvrez sur le PC le fichier "stockage_data_robot.csv" qui se trouve dans le dossier AppInventor/asset de votre téléphone

*Sélectionner le tableau de données en entier

*Cliquer sur "Données" puis cliquer sur "Convertir" et choisir : délimité, virgule, identif de texte ", standard puis TERMINER

*Sélectionnez les colonnes de pos x et pos y  

*Cliquez sur "Insertion nuage de point" et vous obtiendrez le tracé de votre trajectoire

 

REMARQUE : Vous ne pourrez pas enregistrer le fichier, il faudra l'enregistrer sous un autre nom et un autre format.

===Idée : communication entre 2 modules (1 sur chaque robot)===

*Un module Bluetooth peut être connecté à un seul périphérique à la fois. Donc si on veut faire communiquer les robots entre eux + recevoir les données sur l'application, il faudrait installer 2 modules Bluetooth sur chaque robot (1 pour la communication avec l'autre robot et 1 pour la communication avec l'application).

*Le module Bluetooth HC-06 ne fonctionne que comme un esclave (il ne peut pas être pas être maître) il ne pourra donc pas envoyer d'ordre à un autre module. Dans ce cas, il faudra que les modules utilisés pour faire communiquer les 2 robots entre eux soit des modèles HC-05; qui fonctionnent en maître/esclave (contrairement au HC-06).

*Une fois ces conditions réunies il devrait être tout a fait possible de réaliser une communications entre les 2 robots.