commit 4458f231ff56e7a33c116a86e52fc4cde7300873 Author: Samuel Date: Sun Jul 12 16:09:57 2026 +0200 Module communication diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..216ebc7 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,9 @@ +project(Mod_Communication C) + +add_library(Mod_Communication + Servomoteur.c +) + +target_link_libraries(Mod_Communication + pico_stdlib +) diff --git a/Readme.md b/Readme.md new file mode 100644 index 0000000..437c9cd --- /dev/null +++ b/Readme.md @@ -0,0 +1,65 @@ +Submodule Servomoteurs pour le RP2040 +===================================== + +Ceci est un submodule git pour intégrer facilement le support des servomoteurs à un projet. +On crée ce Submodule en se servant de la documentation disponible ici : https://git-scm.com/book/en/v2/Git-Tools-Submodules + +Utilisation +=========== + +Ajout du sub-module +------------------- + +Ajouter ce submodule à votre projet. Dans un terminal, dans le répertoire de votre projet, entrez : + + git submodule add https://git.poivron-robotique.fr/Keuronde/RP2040_Servomoteurs.git + +Ajouter le fichier nouvellement créé .gitmodules à votre projet. + + git add .gitmodules + +Configuration de la compilation +------------------------------- + +Dans le fichier CMakeLists.txt, ajouter le dossier du sub module: + + add_subdirectory(RP2040_Servomoteurs) + +Dans le fichier CMakeLists.txt, ajouter la bibliothèque RP2040_Servomoteur : + + target_link_libraries(Modele_RPiPico + ... + RP2040_Servomoteur + ) + +Intégration au code source +-------------------------- + +Ajout du fichier d'include : + + #include "RP2040_Servomoteurs/Servomoteur.h" + +Initilisation du module : + + Servomoteur_Init(); + +Envoie d'une consigne au servomoteur : + + Servomoteur_set(num_gpio, position); + +Avec : +- num_gpio : le numéro de la GPIO du RP2040 +- position : la position du servomoteur, qui correspond à un temps haut du signal compris généralement en 0,5 et 2,5 ms (en fonction des servomoteurs). le fichier _Servomoteur.h_ contient des valeurs d'exemple. + +Cas où vous clonez un projet contenant des submodules +----------------------------------------------------- + +Après avoir cloné le projet, initilisez les submodules: + + git submodule init + + git submodule update + +Pour récupérer les dernières mise à jour des sub-modules : + + git submodule update --remote diff --git a/communication.c b/communication.c new file mode 100644 index 0000000..ab79b67 --- /dev/null +++ b/communication.c @@ -0,0 +1,151 @@ +#include "pico/error.h" +#include +#include "communication.h" +#include "messagerie.h" +#include "tusb.h" + +#define TAMPON_TAILLE 1020 + +struct com_reception_buffer_t{ + char tampon[TAMPON_TAILLE]; // Tampon tournant - 1er niveau de tampon + unsigned int index_tampon_ecriture, index_tampon_lecture; +}; + +struct com_reception_buffer_t com_reception_buffer; + + +void communication_init(){ + com_reception_buffer.index_tampon_ecriture=0; + com_reception_buffer.index_tampon_lecture=0; +} + +/// @brief Incrémente l'index du tampon tournant +/// @param index +/// @return +void increment_index(unsigned int *index){ + *index = 1 + *index ; + if((*index) >= TAMPON_TAILLE){ + *index = 0; + } +} + +/// @brief augmente la position l'index du tampon tournant +/// @param index +/// @return +void augmente_index(unsigned int *index, unsigned int offset){ + *index = offset + *index ; + if((*index) >= TAMPON_TAILLE){ + *index -= TAMPON_TAILLE; + } +} + +/// @brief Vérifie si des caractères ont été reçu par la liaison série +/// et analyse si un message valide a été reçu. +void communication_reception_message(){ + int input_char; + int chaîne_octets_reçus[TAMPON_TAILLE]; + unsigned int index_chaine_recue; + unsigned int index_tampon; + struct message_t message; + // Si un caractère est reçu, ajout du caractère au tampon tournant + + /// TODO: Tester le code suivant à la place de while get_char(); + /* + char nb_recu=0; + if(tud_cdc_available()){ + char tampon_usb[128]; + nb_recu = tud_cdc_read(tampon_usb, 128); + // copie dans le tampon tournant + for(int i=0; i= TAMPON_TAILLE){ + com_reception_buffer.index_tampon_ecriture = 0; + } + com_reception_buffer.tampon[com_reception_buffer.index_tampon_ecriture] = input_char; + } + }*/ + + input_char = stdio_getchar_timeout_us(0); + while(input_char != PICO_ERROR_TIMEOUT){ + com_reception_buffer.index_tampon_ecriture++; + if(com_reception_buffer.index_tampon_ecriture >= TAMPON_TAILLE){ + com_reception_buffer.index_tampon_ecriture = 0; + } + com_reception_buffer.tampon[com_reception_buffer.index_tampon_ecriture] = input_char; + + // Caractère suivant ? + input_char = stdio_getchar_timeout_us(0); + } + + // Copie du tampon tournant dans une chaine + // Parce que c'est plus simple à traiter + index_chaine_recue = 0; + index_tampon = com_reception_buffer.index_tampon_lecture; + if(index_tampon != com_reception_buffer.index_tampon_ecriture){ + while(index_tampon != com_reception_buffer.index_tampon_ecriture){ + chaîne_octets_reçus[index_chaine_recue] = com_reception_buffer.tampon[index_tampon]; + index_chaine_recue++; + increment_index(&index_tampon); + } + chaîne_octets_reçus[index_chaine_recue] = com_reception_buffer.tampon[index_tampon]; + index_chaine_recue++; + increment_index(&index_tampon); + } + + // Traitement + // Si on trouve le début du message + // Si on trouve la taille du message + // Si le caractère de fin est bien à la fin du message + int fin_message = 0; + for(int i=0; i ... ... + if(i + 2 < index_chaine_recue){ + // Test début message + if(chaîne_octets_reçus[i] == 0xFF && chaîne_octets_reçus[i+1] == 0xFF){ + //printf("Debut message: 0xFF 0xFF\n"); + // Taille du message (sans l'entête) + uint8_t offset = chaîne_octets_reçus[i+2]; + if(i + 2 + offset < index_chaine_recue){ + // printf("Message totalement reçu, taille %d\n", offset); + // Test fin message + if(chaîne_octets_reçus[i + 2 + offset] == 0x00){ + // printf("Fin message OK\n"); + // Lecture du message + message.type = 'b'; // Message binaire (par opposition à un message Texte) + message.taille_donnees = offset - 1; + for(int index_donnees = 0; index_donnees < message.taille_donnees; index_donnees++){ + message.donnees[index_donnees] = chaîne_octets_reçus[index_donnees + i + 3]; + } + fin_message = i + 2 + offset; + messagerie_put_message(message); + }else{ + // printf("Fin message NOK, attendu 0x00, recu %x\n", chaîne_octets_reçus[i + 2 + offset]); + } + } + } + } + if(chaîne_octets_reçus[i] == '>'){ + message.type = chaîne_octets_reçus[i]; + message.taille_donnees=0; + while(message.taille_donnees + i < index_chaine_recue){ + message.donnees[message.taille_donnees] = chaîne_octets_reçus[i+message.taille_donnees]; + if(message.donnees[message.taille_donnees] == '\n'){ + i = i + message.taille_donnees; + message.taille_donnees++; + message.donnees[message.taille_donnees] = '\0'; + messagerie_put_message (message); + fin_message = i; + break; + } + message.taille_donnees++; + } + } + } + + // Mettre à jour l'index de lecture du tampon tournant + augmente_index(&(com_reception_buffer.index_tampon_lecture), fin_message); + +} diff --git a/communication.h b/communication.h new file mode 100644 index 0000000..a074357 --- /dev/null +++ b/communication.h @@ -0,0 +1,3 @@ + +void communication_reception_message(void); +void communication_init(void); diff --git a/messagerie_applicative.c b/messagerie_applicative.c new file mode 100644 index 0000000..5130c65 --- /dev/null +++ b/messagerie_applicative.c @@ -0,0 +1,61 @@ +#include +#include "messagerie_applicative.h" + +uint8_t memoire_echange[0xFF]; + + + +bool mise_a_jour_position = false; +bool mise_a_jour_mode = false; +bool mise_a_jour_pwm = false; +bool mise_a_jour_vitesse_roues = false; +bool mise_a_jour_vitesse_robot = false; +bool mise_a_jour_trajectoire = false; +bool mise_a_jour_config_trajet = false; +bool mise_a_jour_cde_inv_traj = false; + +void get_données_reçues(uint8_t * dst, unsigned int taille, uint8_t registre){ + memcpy(dst, &(memoire_echange[registre]), taille); +} + +void mise_données_dans_échange(uint8_t * source, unsigned int taille, uint8_t registre){ + memcpy(&(memoire_echange[registre]), source, taille); +} + +void écriture_données(unsigned int adresse, uint8_t donnée){ + if( adresse < 11){ // 0x0B + // Position du robot + mise_a_jour_position = true; + }else if(adresse <= 12){ // 0x0C + // Read only + + }else if(adresse <= 13){ // 0x0D + // Mode + mise_a_jour_mode = true; + }else if(adresse <= 17){ // 0x11 + // PWM moteur + mise_a_jour_pwm = true; + }else if(adresse <= 25){ // 0x19 + // Vitesse roues + mise_a_jour_vitesse_roues = true; + }else if(adresse <= 33){ // 0x21 + // Vitesse robot + mise_a_jour_vitesse_robot = true; + }else if(adresse <= 0x59){ // + // Trajectoire + mise_a_jour_trajectoire = true; + }else if(adresse <= 0x61){ + // Trajet config + mise_a_jour_config_trajet = true; + }else if(adresse <= 0x62){ + // Trajet config + mise_a_jour_cde_inv_traj = true; + }else { + // Hors mémoire + return; + } + + memoire_echange[adresse] = donnée; + + +} diff --git a/messagerie_applicative.h b/messagerie_applicative.h new file mode 100644 index 0000000..1854b2e --- /dev/null +++ b/messagerie_applicative.h @@ -0,0 +1,17 @@ +#include +#include + +void écriture_données(unsigned int adresse, uint8_t donnée); +void get_données_reçues(uint8_t * dst, unsigned int taille, uint8_t registre); +void mise_données_dans_échange(uint8_t * source, unsigned int taille, uint8_t registre); + +extern uint8_t memoire_echange[]; + +extern bool mise_a_jour_position; +extern bool mise_a_jour_mode; +extern bool mise_a_jour_pwm; +extern bool mise_a_jour_vitesse_roues; +extern bool mise_a_jour_vitesse_robot; +extern bool mise_a_jour_trajectoire; +extern bool mise_a_jour_config_trajet; +extern bool mise_a_jour_cde_inv_traj;