Code de demonstration du pilotage des moteurs

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.13)
 
 include(pico_sdk_import.cmake)
 
-project(PAMI_Cours C CXX ASM)
+project(PAMI_Cours_Moteurs C CXX ASM)
 set(CMAKE_C_STNDARD 11)
 set(CMAKE_CXX_STANDARD 17)
 
@@ -10,27 +10,30 @@ set(PICO_EXAMPLES_PATH ${PROJECT_SOURCE_DIR})
 
 pico_sdk_init()
 
-add_executable(PAMI_Cours
+add_executable(PAMI_Cours_Moteurs
   main.c
+
+  Moteurs.c
   Teleplot.c
+  Temps.c
 )
 
-target_include_directories(PAMI_Cours PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+target_include_directories(PAMI_Cours_Moteurs PRIVATE ${CMAKE_CURRENT_LIST_DIR})
 
-target_link_libraries(PAMI_Cours
-  hardware_i2c 
+target_link_libraries(PAMI_Cours_Moteurs
   hardware_uart 
+  hardware_pwm 
   pico_stdlib
   pico_multicore
   pico_cyw43_arch_lwip_poll
 )
 
-pico_enable_stdio_usb(PAMI_Cours 1)
-pico_enable_stdio_uart(PAMI_Cours 1)
+pico_enable_stdio_usb(PAMI_Cours_Moteurs 1)
+pico_enable_stdio_uart(PAMI_Cours_Moteurs 1)
 
-pico_add_extra_outputs(PAMI_Cours)
+pico_add_extra_outputs(PAMI_Cours_Moteurs)
 
 add_custom_target(Flash
-    DEPENDS PAMI_Cours
-    COMMAND sudo picotool load -f ${PROJECT_BINARY_DIR}/PAMI_Cours.uf2
+    DEPENDS PAMI_Cours_Moteurs
+    COMMAND sudo picotool load -f ${PROJECT_BINARY_DIR}/PAMI_Cours_Moteurs.uf2
 )

Moteurs.c

@@ -0,0 +1,86 @@
+#include "hardware/pwm.h"
+#include "Moteurs.h"
+
+#define MOTEUR_A_SENS1 7
+#define MOTEUR_A_SENS2 13
+#define MOTEUR_A_VITESSE 27 //5B
+#define MOTEUR_B_SENS1 10
+#define MOTEUR_B_SENS2 5
+#define MOTEUR_B_VITESSE 9 //4B
+
+uint slice_moteur_A, slice_moteur_B, slice_moteur_C;
+
+/// @brief Initialisation les entrées / sorties requises pour les moteurs
+void Moteur_init(){
+    gpio_init(MOTEUR_A_SENS1);
+	gpio_init(MOTEUR_A_SENS2);
+	gpio_init(MOTEUR_B_SENS1);
+	gpio_init(MOTEUR_B_SENS2);
+	gpio_set_dir(MOTEUR_A_SENS1, GPIO_OUT);
+	gpio_set_dir(MOTEUR_A_SENS2, GPIO_OUT);
+	gpio_set_dir(MOTEUR_B_SENS1, GPIO_OUT);
+	gpio_set_dir(MOTEUR_B_SENS2, GPIO_OUT);
+	gpio_put(MOTEUR_A_SENS1, 0);
+	gpio_put(MOTEUR_A_SENS2, 0);
+	gpio_put(MOTEUR_B_SENS1, 0);
+	gpio_put(MOTEUR_B_SENS2, 0);
+
+	gpio_set_function(MOTEUR_A_VITESSE, GPIO_FUNC_PWM);
+	gpio_set_function(MOTEUR_B_VITESSE, GPIO_FUNC_PWM);
+	pwm_set_wrap(5, (uint16_t)65535);
+	pwm_set_wrap(4, (uint16_t)65535);
+	pwm_set_chan_level(5, PWM_CHAN_B, 0);
+	pwm_set_chan_level(4, PWM_CHAN_B, 0);
+	pwm_set_enabled(5, true);
+	pwm_set_enabled(4, true);
+
+    Moteur_set_commande(MOTEUR_A, 0);
+    Moteur_set_commande(MOTEUR_B, 0);
+}
+
+
+/// @brief Configure le PWM et la broche de sens en fonction de la vitesse et du moteur
+/// @param moteur : Moteur (voir enum t_moteur)
+/// @param vitesse : Vitesse entre -32767 et 32767
+void Moteur_set_commande(enum t_moteur moteur, int16_t vitesse ){
+    uint16_t u_vitesse;
+
+    // Le PWM accepte 16 bits de résolution, on se remet sur 16 bits (et non sur 15 + signe)
+    if (vitesse < 0){
+        u_vitesse = -vitesse;
+    }else{
+        u_vitesse = vitesse;
+    }
+    u_vitesse = u_vitesse * 2;
+
+    switch(moteur){
+        case MOTEUR_A:
+            pwm_set_chan_level(5, PWM_CHAN_B, u_vitesse);
+            if(vitesse > 0){
+                gpio_put(MOTEUR_A_SENS1, 0);
+                gpio_put(MOTEUR_A_SENS2, 1);
+            }else{
+                gpio_put(MOTEUR_A_SENS1, 1);
+                gpio_put(MOTEUR_A_SENS2, 0);
+            }
+            break;
+
+        case MOTEUR_B:
+            pwm_set_chan_level(4, PWM_CHAN_B, u_vitesse);
+            if(vitesse < 0){
+                gpio_put(MOTEUR_B_SENS1, 0);
+	            gpio_put(MOTEUR_B_SENS2, 1);
+            }else{
+                gpio_put(MOTEUR_B_SENS1, 1);
+	            gpio_put(MOTEUR_B_SENS2, 0);
+            }
+            break;
+
+    }
+
+}
+
+void Moteur_stop(void){
+    Moteur_set_commande(MOTEUR_A, 0);
+    Moteur_set_commande(MOTEUR_B, 0);
+}

Moteurs.h

@@ -0,0 +1,15 @@
+#include "pico/stdlib.h"
+
+#ifndef MOTEURS_H
+#define MOTEURS_H
+enum t_moteur {
+    MOTEUR_A=0,
+    MOTEUR_B=1
+};
+#endif
+
+#define MOTEUR_MAX_COMMANDE 32767
+
+void Moteur_init(void);
+void Moteur_set_commande(enum t_moteur moteur, int16_t vitesse );
+void Moteur_stop(void);

Readme.md

@@ -1,13 +1,10 @@
-De l’art de déplacer un robot avec classe - Teleplot
-====================================================
+De l’art de déplacer un robot avec classe - Commande des moteurs
+================================================================
 
 Le but est de vous proposer une série d’articles vous présentant les arcanes du déplacement d’un robot, en fournissant à chaque étape une idée de démonstration et les principales pistes de débogage. Les articles sont disponibles ici : [Wiki Eurobot](https://www.eurobot.org/wiki/fr/informatics/de_l_art_de_deplacer_son_robot_avec_classe)
 
-Teleplot
---------
+Commande des moteurs
+-------------------
 
-Cette première étape consiste à transmettre des données depuis le robot vers un ordinateur, au format [Teleplot](https://teleplot.fr/) afin d'avoir de joli graphique. Pour profiter des graphiques, il faut avoir Teleplot d'installé sur l'ordinateur, le plus simple étant d'utiliser le plugin pour VS Code.
+Ajout des fichiers pour gérer les moteurs. Le code principal fait évoluer la vitesse des moteurs progressivement en fonction du temps.
 
-Le code fourni est un peu compliqué pour ce qu'il fait car il gère à la fois le cas du transfert par la liaison série et le transfert par la liaison UDP/Wifi. Dans le cas d'un transfert par UDP, il est très avantageux de mettre en place un système de tampon pour grouper les envois.
-
-Pour que le code fonctionne, vous devez copier le fichier *wifi_settings.h.default* en *wifi_settings.h* puis l'éditer, même si vous n'utilisez pas le WIFI.

Teleplot.c

@@ -14,6 +14,10 @@ ip_addr_t addr;
 long teleplote_temps_ms;
 bool teleplot_temps_fige;
 
+
+/// @brief Initialise le module Teleplot, 
+/// @param  
+/// @return /
 int Teleplot_init(void){
 #ifdef WIFI_ENABLE
     if (cyw43_arch_init()) {

Temps.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include "pico/stdlib.h"
+#include "Temps.h"
+
+uint32_t temps_ms=0;
+bool temps_est_init=false;
+struct repeating_timer timer;
+
+/// @brief Fonction qui incrément notre temps_ms de 1, appelé par interruption toutes les 1 ms.
+/// @param t : necessaire uniquement à cause du SDK du RPi Pico.
+bool Temps_increment(struct repeating_timer *t){
+    temps_ms++;
+    return true;
+}
+
+/// @brief Crée l'interruption qui appellera la fonction Temps_increment toutes les 1 ms.
+void Temps_init(void){
+    if(!temps_est_init){
+        temps_ms=0;
+        add_repeating_timer_ms(-1, Temps_increment, NULL, &timer);
+        temps_est_init = true;
+    }
+}
+
+/// @brief Renvoie le temps actuel, depuis l'appel de Temps_init, en millisecondes
+uint32_t Temps_get_temps_ms(void){
+    return temps_ms;
+}

Temps.h

@@ -0,0 +1,5 @@
+#include "pico/stdlib.h"
+
+bool Temps_increment(struct repeating_timer *t);
+void Temps_init(void);
+uint32_t Temps_get_temps_ms(void);

main.c

@@ -4,12 +4,17 @@
  * SPDX-License-Identifier: BSD-3-Clause
 */
 #include "pico/stdlib.h"
+#include "Moteurs.h"
 #include "Teleplot.h"
+#include "Temps.h"
 #include <stdio.h>
+#include <math.h>
 
 void setup(void);
 void loop(void);
 
+int valeur = 1;
+
 void main(void)
 {
     setup();
@@ -21,11 +26,12 @@ void main(void)
 void setup(void){
 	stdio_init_all();
 	Teleplot_init();
+	Temps_init();
+	Moteur_init();
 }
 
 void loop(void){
-	printf("Exemple\n");
-	Teleplot_add_variable_int("t", 2);
-	Teleplot_envoie_tampon();
-	sleep_ms(1000);
+	float t = (float) Temps_get_temps_ms() / 1000. ;
+	Moteur_set_commande(MOTEUR_A, sin(t * 3.14) * MOTEUR_MAX_COMMANDE) ;
+	Moteur_set_commande(MOTEUR_B, sin(t * 3.14) * MOTEUR_MAX_COMMANDE) ;
 }