Merge branch 'feat/pwm_doc'

Author: FreedGB

TODO.md

@@ -6,11 +6,12 @@
 
 
 ## Utilisation STM32
-- [ ] Installation de STM32Cube IDE et MX (à détailler)
+- [x] Installation de STM32Cube IDE et MX (à détailler)
 	- [ ] Workspace avec STM32CubeIDE
-- [ ] Installation de l'extension VSCode (à détailler)
-- [ ] Utilisation de l'extension VSCode
+- [x] Installation de l'extension VSCode (à détailler)
+- [x] Utilisation de l'extension VSCode
 - [ ] Structure des dossiers (Src et Inc)
+- [ ] Commande des moteurs pas à pas
 
 ## Usinage 3D
 -[ ] setup le post process et la machine en premier

docs/.vitepress/config.mts

@@ -127,20 +127,32 @@ export default defineConfig({
           link: "/Info/",
         },
         {
-          text: "Divers",
+          text: "Débuter avec STM32",
           collapsed: false,
           items: [
+            { text: "Installations", link: "/Info/STM32/Installation" },
+            { text: "Création de l'IOC", link: "/Info/STM32/CreationIOC" },
+            { text: "Configuration de IDE", link: "/Info/STM32/ConfigIDE" },
+          ],
+        },
+        {
+          text: "Signaux PWM",
+          collapsed: false,
+          items: [
+            { text: "STM32", link: "/Info/PWM/STM32" },
             {
-              text: "Cartes utilisées",
-              link: "/Info/Cartes",
-            },
-            {
-              text: "Raspberry",
-              link: "/Info/RaspiLinux",
-            },
-            {
-              text: "Connexion SSH",
-              link: "/Info/ConnexionSSH",
+              text: "PCA9685",
+              collapsed: true,
+              items: [
+                {
+                  text: "Utiliser la librairie",
+                  link: "/Info/PWM/PCA9685/Librairie",
+                },
+                {
+                  text: "Implémentation",
+                  link: "/Info/PWM/PCA9685/Implementation",
+                },
+              ],
             },
           ],
         },
@@ -154,15 +166,7 @@ export default defineConfig({
             { text: "Créer une librairie", link: "/Info/CMake/Librairie" },
           ],
         },
-        {
-          text: "Débuter avec STM32",
-          collapsed: false,
-          items: [
-            { text: "Installations", link: "/Info/STM32/Installation" },
-            { text: "Création de l'IOC", link: "/Info/STM32/CreationIOC" },
-            { text: "Configuration de IDE", link: "/Info/STM32/ConfigIDE" },
-          ],
-        },
+        
         {
           text: "Bus CAN",
           collapsed: false,
@@ -285,23 +289,20 @@ export default defineConfig({
           ],
         },
         {
-          text: "Signaux PWM",
+          text: "Divers",
           collapsed: false,
           items: [
-            { text: "STM32", link: "/Info/PWM/STM32" },
             {
-              text: "PCA9685",
-              collapsed: true,
-              items: [
-                {
-                  text: "Utiliser la librairie",
-                  link: "/Info/PWM/PCA9685/Librairie",
-                },
-                {
-                  text: "Implémentation",
-                  link: "/Info/PWM/PCA9685/Implementation",
-                },
-              ],
+              text: "Cartes utilisées",
+              link: "/Info/Cartes",
+            },
+            {
+              text: "Raspberry",
+              link: "/Info/RaspiLinux",
+            },
+            {
+              text: "Connexion SSH",
+              link: "/Info/ConnexionSSH",
             },
           ],
         },

docs/Contribuer/Credits.md

@@ -87,6 +87,14 @@ const members = [
       { icon: 'codeberg', link: 'https://codeberg.org/NoAccount1' }
     ]
   },
+  {
+    avatar: 'https://www.github.com/FreedGB.png',
+    name: 'FreedGB',
+    title: 'Contributeur',
+    links: [
+      { icon: 'github', link: 'https://www.github.com/FreedGB' },
+    ]
+  }
 ]
 </script>
 

docs/Info/PWM/STM32.md

@@ -3,56 +3,79 @@ title: STM32
 description: Comment générer un signal PWM sur un microcontrôleur STM32
 ---
 
-# STM32
+# Génération de signaux PWM avec STM32 
+
+## Définition
 
 Le PWM (Pulse Width Modulation) consiste à moduler la largeur d'une impulsion pour contrôler la puissance moyenne délivrée à un composant.
 C'est un signal carré dont le rapport cyclique (temps haut / temps total) est variable :
 <img src="/images/Info/PWM/signals.webp" alt="PWM">
 
-Deux paramètres sont à prendre en compte :
+Sur les microcontrôleurs STM32, la génération des signaux PWM se fait à l'aide des timers. 
+
+## Timers et interruptions
+
+Un **timer** est un circuit logique numérique qui permet de compter, en incrémentant une valeur à chaque cycle d'horloge. Voici une vidéo très instructive qui en explique le fonctionnement, ainsi que la notion d'interruption.
 
-- La fréquence du signal : elle est fixe et dépend du composant (ex : 50Hz pour un servo-moteur analogique)
-- Le temps haut du signal : il est variable et fixe le rapport pour chaque cycle
+<iframe width="100%" height="415" src="https://www.youtube.com/embed/VfbW6nfG4kw?si=nHV48kzDUsvhJzZw" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
 
-## Paramétrage de la carte
+Parlons un peu plus en détails de l'architecture des timers dans les microcontrôleurs STM32 (timesptamp : 3:39 de la vidéo). Comme vous pouvez le voir dans l'onglet `Clock configuration` du fichier `.ioc` sur STM32CubeMX, l'horloge interne du microcontrôleur (représenté par `HCLK`) est divisée en deux bus (`APB1` et `APB2`), et chaque bus est relié à plusieurs timers. C'est en réalité la fréquence des bus (`APB_ peripheral clock`) qui est la valeur qui sera divisée par le `prescaler` dans la configuration des timers (à ne pas confondre avec les `prescaler`s de la configuration de l'horloge).
 
-Avant de régler le timer, il faut configurer la clock que va utiliser le timer (menu `Clock Configuration`).
-Ici, on utilise le timer `TIM1` qui est sur le bus `APB2` et qui a une fréquence de 4MHz :
-<img src="/images/Info/PWM/clock_config.webp" alt="Prescaler clock">
+Il est donc possible de modifier la fréquence de l'horloge de chaque bus de manière indépendante en modifiant les variables `APB_ peripheral clock`, mais cela devient assez vite chaotique à gérer à cause des `prescaler`s de la configuration de l'horloge (vous pouvez essayez si vous aimez souffir). Nous conseillons de faire comme dans la vidéo : modifier **uniquement** la fréquence de l'horloge du microcontrôleur (`HCLK`), et choisir le `prescaler` de chacun des timers que vous souhaitez utiliser pour votre fréquence de comptage.
 
-> Pour trouver quelle clock le timer utilise, il faut regarder la [datasheet](https://www.st.com/resource/en/datasheet/stm32l432kc.pdf) du microcontrôleur, dans la section `Memory mapping` (ici, page 60).
 > [!TIP]
+> Puisque les timers d'un microcontrôleur STM32 peuvent avoir des spécificités différentes, il est conseillé regarder la [datasheet](https://www.st.com/resource/en/datasheet/stm32l432kc.pdf) pour choisir vos timers.
 
-Ensuite, on peut régler le timer TIM1 qu'on utilisera pour générer le signal PWM.
-Ici, l'objectif était d'avoir trois signaux, d'où le mode PWM sur 3 channels :
-<img src="/images/Info/PWM/timer_config.webp" alt="TIM1">
+Maintenant que vous savez ce qu'est un timer, et comment le manipuler, nous verrons comment l'utiliser pour générer des signaux PWM.
 
-Il est aussi nécessaire de calculer la valeur du prescaler à partir de la clock (4MHz),
-du compteur utilisé (4096) et de la fréquence voulue (50Hz) : `4MHz ÷ (4096*50Hz) - 1 = 18`.
 
-## Génération du signal
+## Signal PWM simple
 
-Pour commencer la génération du signal, il faut utiliser la fonction `HAL_TIM_PWM_Start` :
+Voici une vidéo qui explique très bien comment générer des signaux PWM avec un microcontrôleur STM32.
 
-```c
-// htim1 et TIM_CHANNEL_X sont automatiquement générés par CubeMX
-HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
-HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_2);
-HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_3);
-```
+<iframe width="100%" height="415" src="https://www.youtube.com/embed/AjN58ceQaF4?si=QPCLBDvGKuvLXI2D" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
 
-Maintenant que le signal est généré, il est possible de modifier le compte de chaque channel :
+Il y a quelques points à ajouter à cette vidéo.
 
-```c
-htim1.Instance->CCR1 = 205; // Channel 1
-htim1.Instance->CCR2 = 410; // Channel 2
-htim1.Instance->CCR3 = 615; // Channel 3
-```
+- La première chose est qu'il est possible de modifier les valeurs de `prescaler`, `counter period` et `pulse` directement dans le code. Les fonctions sont respectivement `__HAL_TIM_SET_PRESCALER()`, `__HAL_TIM_SET_AUTORELOAD()` et `__HAL_TIM_SET_COMPARE()`.
+
+- La deuxième chose est que certains channels sont suivis d'un suffixe "N" (ex. `PWM Generation CH2N`). Il s'agit de sorties complémentées, c'est-à-dire que le `pulse` définit la période à l'état BAS, et non à l'état HAUT comme pour les channels classiques. Ainsi, le rapport cyclique y est inversé. Pour lancer un PWM sur un tel channel, on utilise plutôt `HAL_TIMEx_PWMN_Start()`.
+
+- La troisième : on peut bien sûr arrêter un signal PWM avec `HAL_TIM_PWM_Stop()` pour les channels normaux et `HAL_TIMEx_PWMN_Stop()` pour les channes complémentés.
+
+- Enfin la quatrième : le microcontrôleur que nous utilisons (Nucleo L432KC) n'a pas de broches pour activer un mode "téléversement" et un mode "lancement".
+
+## Signal PWM en mode interruption
+
+Il est possible de générer des signaux PWM avec interruptions.
+
+Pour ce faire, il faut d'abord activer le mode interruption du timer dans l'onglet `NVIC Settings` au niveau du fichier `.ioc`.
+
+<img src="/images/Info/PWM/pwm_it_config.webp" alt="DMA config">
+
+Puis, au niveau du code, on lance le signal PWM en mode IT `HAL_TIM_PWM_Start_IT()`. Il faudra ensuite définir le contenu de la fonction exécutée à chaque interruption `HAL_TIM_PWM_PulseFinishedCallback()`.
+
+
+## Signal PWM avec DMA
+
+La génération d'un signal PWM en mode **DMA** (Direct Access Memory) consiste à modifier le duty cycle du signal PWM  à chaque fin de période. Pour ce faire, chaque valeur du CCR (la période à l'état haut) est renseignée dans un tableau, et à chaque fin d'impulsion du signal, la valeur suivante est chargée. On obtient donc un signal PWM à duty cycle variable.
+
+Pour ce faire, on active le mode DMA dans l'onglet `DMA Settings` dans le fichier `.ioc`.
+
+<img src="/images/Info/PWM/pwm_dma_config.webp" alt="DMA config">
+
+Il y a deux modes :
+
+- **normal** : Une fois arrivé à la fin du tableau, la génération du signal s'arrête.
+- **circular** : Une fois arrivé à la fin du tableau, on reprend du début du tableau.
 
-Enfin, pour arrêter la génération du signal, il faut utiliser la fonction `HAL_TIM_PWM_Stop` :
+Niveau code, il suffit de définir un tableau de `unit16_t`, donner la valeur de chaque CCR dans le tableau, et appeler la fonction `HAL_TIM_PWM_Start_DMA()`. Voici un exemple assez parlant, extrait du site [Controllerstech](https://controllerstech.com/pwm-in-stm32/) très explicatif, avec un `ARR = 100` :
 
 ```c
-HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
-HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_2);
-HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_3);
-```
+uint16_t pwmData[11];
+pwmData[0] = 10; pwmData[1] = 20; pwmData[2] = 30;
+pwmData[3] = 40; pwmData[4] = 50; pwmData[5] = 60;
+pwmData[6] = 70; pwmData[7] = 80; pwmData[8] = 90;
+pwmData[9] = 100;pwmData[10] = 0;
+HAL_TIM_PWM_Start_DMA(&htim1, TIM_CHANNEL_1, (uint32_t *)pwmData, 11);
+```

docs/Info/STM32/CreationIOC.md

@@ -32,7 +32,7 @@ Vous tombez maintenant sur l'interface de configuration des broches de la puce d
 
 - Les broches entrées - sorties
 - Les horloges (`Clock Configuration`)
-- Les timers (génération de PWM par exemple)
+- Les timers (génération de [PWM](/Info/PWM/STM32.md) par exemple)
 - Les connectivités (UART, SPI, I2C, CAN, USB, ...)
 - Les fonctionnalités (interrupts, DMA, ...)
 - etc.

docs/Info/STM32/CubeMX.md

@@ -17,7 +17,7 @@ Pour cela, rendez-vous sur [le site officiel de STM Electronics](https://www.st.
 
 ## Installation de l'IDE
 
-- ### STM32CubeIDE
+### STM32CubeIDE
 
 C'est, dans une certaine mesure, la manière la plus facile de développer sur STM32 (même si sa prise en main est fastidieuse). Lancé en 2015 et basé sur Eclipse, cet IDE permet de rédiger, compiler et débuger du code sur la STM32.
 
@@ -28,7 +28,7 @@ Sur Linux, il est possible que le fichier d'installation ne soit pas exécutable
 > Si vous utilisez `flatpak` sur Linux : `flatpak install flathub com.st.STM32CubeIDE`
 > (ne nécessite pas de donner son email, nom et prénom).
 
-- ### STM32CubeIDE for Visual Studio Code
+### STM32CubeIDE for Visual Studio Code
 
 C'est la dernière nouveauté (2025)! Il s'agit d'une extension de VSCode qui permet d'obtenir les mêmes fonctionnalités que STM32CubeIDE tout en restant sur VSCode (qui est bien plus aisé à prendre en main).