Module communication

CMakeLists.txt

@@ -0,0 +1,9 @@
+project(Mod_Communication C)
+
+add_library(Mod_Communication
+    Servomoteur.c
+)
+
+target_link_libraries(Mod_Communication
+    pico_stdlib
+)

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

communication.c

@@ -0,0 +1,151 @@
+#include "pico/error.h"
+#include <stdio.h>
+#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<nb_recu; i++){
+            input_char = tampon_usb[i];
+            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;
+        }
+    }*/
+    
+    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<index_chaine_recue; i++){
+        int index_fin_message = 0;
+        // Com v2
+        // OxFF OxFF <taille> ... ... <fin (0x00)>
+        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);
+
+}

communication.h

@@ -0,0 +1,3 @@
+
+void communication_reception_message(void);
+void communication_init(void);

messagerie_applicative.c

@@ -0,0 +1,61 @@
+#include <string.h>
+#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;
+
+
+}

messagerie_applicative.h

@@ -0,0 +1,17 @@
+#include <stdint.h>
+#include <stdbool.h>
+
+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;