Périphériques point PDF

(version du 01/06/2023)

Ce document présente une liste de périphériques couramment utilisés à l’ESEO dans les projets
microcontrôleurs.

Pour chaque périphérique, vous pouvez notamment trouver ici, en une page, selon les cas :

- Pinout (brochage, liste des signaux)

- Principe de fonctionnement
- Explication sur les librairies logicielles fournies
- Liens webs pertinents
- …

Tout projet dont les périphériques ne seraient pas dans cette liste doit faire l’objet d’une validation spécifique
par l’enseignant.

Ce document ne se veut pas exhaustif ! Il donne quelques pistes et conseils, il explique quelques
généralités et vous invite à poursuivre ensuite vos investigations sur Internet ou dans le code
des librairies mises à votre disposition.

Pour certains périphériques, des conseils sont donnés en vert à propos des détails que vous pourriez
avantageusement aborder dans votre soutenance.

Ce document n’a pas vocation à être terminé. Il est susceptible d’évoluer régulièrement. Vos
remarques et suggestions sont les bienvenues. ( samuel.poiraud@eseo.fr)
Table des matières
1. Périphériques internes : Timer (PWM)........................................................................................................ 4
2. Périphériques internes : Mémoire flash ...................................................................................................... 5
3. Périphériques internes : RTC (horloge temps réel) ..................................................................................... 5
4. Périphériques internes : I2C ........................................................................................................................ 6
5. Périphériques internes : SPI ........................................................................................................................ 7
6. Périphériques internes : Systick .................................................................................................................. 8
7. Périphériques internes : ADC ...................................................................................................................... 9
8. Périphériques internes : UART .................................................................................................................. 10
9. Périphériques internes : IT Externes ......................................................................................................... 11
10. Ecran TFT ILI9341 240x320 (tactile)....................................................................................................... 12
11. Ecran e-paper ........................................................................................................................................ 14
12. Matrice de Leds 8x8............................................................................................................................... 15
13. Ruban de Leds pilotables ....................................................................................................................... 16
14. Leds WS2812 ......................................................................................................................................... 17
15. LED de puissance ................................................................................................................................... 18
16. Cube de LED : utilisation d’un driver à registre à décalage ................................................................... 19
17. Module Bluetooth HC-05....................................................................................................................... 20
18. Capteur de température MCP9701 ....................................................................................................... 21
19. Capteur de température sans contact MLX90614 ................................................................................ 22
20. Capteur de pression BMP180 ................................................................................................................ 23
21. Capteur d’humidité DHT11.................................................................................................................... 24
22. Capteur de couleur / mouvement APDS9960 ....................................................................................... 25
23. Télémètre à ultrasons HC-SR04 ............................................................................................................. 26
24. Télémètre infrarouge GP2YA21YKOF .................................................................................................... 27
25. Télémètre infrarouge à temps de vol ST VL53L0................................................................................... 28
26. Photorésistances ................................................................................................................................... 29
27. Capteur de luminosité BH1750FVI ........................................................................................................ 30
28. Capteur à effet Hall................................................................................................................................ 31
29. Microphone préamplifié........................................................................................................................ 32
30. Capteurs MEMS MPU6050 (accéléromètre, gyroscope, magnétomètre) ............................................ 33
31. Détecteur de fumée et capteur d’éthanol ............................................................................................ 34
32. Capteur de pouls ................................................................................................................................... 35
33. Capteur de courant isolé ....................................................................................................................... 36
34. Lecteur de code barre ........................................................................................................................... 37
35. Lecteur NFC X-NUCLEO-NFC03A1.......................................................................................................... 38
36. Emission/Réception infra-rouge TSOP 38238 ....................................................................................... 39
37. Digital to Analog Converter (DAC - MCP4921) ...................................................................................... 40
40. Ampli Audio PAM8403 .......................................................................................................................... 41
41. Clavier matriciel ..................................................................................................................................... 42
42. Capteur de présence optique CNY70 .................................................................................................... 43
43. Microrupteur ......................................................................................................................................... 44
44. Servomoteur .......................................................................................................................................... 45
45. Moteur pas à pas et driver TB6600 ....................................................................................................... 46
46. Moteur à courant continu et pont en H BD6221 .................................................................................. 48
47. Ponts en H ............................................................................................................................................. 49
48. Châssis à motoréducteurs ..................................................................................................................... 50
49. Ventilateur ............................................................................................................................................. 51
50. Gâche électrique, électrovannes et électroaimants ............................................................................. 52
 1. Périphériques internes : Timer (PWM)

Le STM32F103 dispose de plusieurs périphériques TIMERs dont les fonctionnalités sont diverses.

Le cœur du timer, c’est un compteur. Plusieurs bits permettent de les configurer :

- Compter / décompter
- Les événements comptés peuvent être en provenance de l’extérieur, ou de la clock interne
- Un pré-diviseur (prescaler) peut réduire le rythme de comptage
- Le timer peut revenir automatiquement à 0 lorsqu’il atteint un nombre donné
- Des signaux PWM peuvent être générés par comparaison entre le compteur et des variables connues
- Une routine d’interruption peut être déclenchée lorsque le timer a fini de compter…

Un module logiciel stm32f1_timer.c/h vous donne accès à (une petite) partie des fonctionnalités de ces timers.
Un module spécifique stm32f1_pwm.c/h, un peu redondant, est également fourni.

- TIMER_run_us Lance un timer à la période demandée

- TIMER_read Lit la valeur courante du compteur
- TIMER_write Ecrit une nouvelle valeur du compteur. Peu utile.
- TIMER_set_period Modifie la période du timer
- TIMER_set_prescaler Modifie le prédiviseur du timer
- TIMER_enable_PWM Active la production d’un signal PWM
- TIMER_set_duty Modifie le rapport cyclique du signal PWM
- TIMER_get_phandler Renvoie la structure handler utilisée pour gérer le timer
- TIMER_stop Arrêter le timer

Ces fonctions peuvent être (re)définies par l’utilisateur. Elles sont appelées dans les routines d’ITs des timers
concernés. (x vaut 1 à 4).
- TIMERx_user_handler_it

Lorsque l’on produit un signal PWM, la broche sur laquelle ce signal est disponible est imposée par
l’architecture du microcontrôleur.
Le fichier PORTS_STM32F1.xlsx vous donne la liste des broches pouvant sortir ces signaux. Chaque timer
peut disposer de plusieurs canaux. En voici des exemples expliqués :
- 2.CH3 : timer 2, canal 3
- 1.CH4 : timer 1, canal 4
- 1.CH2N : timer 1, canal 2 négatif (le signal produit ici est l’inverse du 1.CH2).
- 2.CH3® : ‘remap’ possible du timer 2, canal 3. (l’argument remap sert à cela)
 2. Périphériques internes : Mémoire flash

Naturellement, le microcontrôleur est doté d’une mémoire flash. Cette mémoire non volatile lui permet de
conserver le programme lorsque l’alimentation n’est plus disponible.

Mais on peut aussi utiliser une partie de cette mémoire pour stocker des variables ou des paramètres qui
doivent être conservés « sur le long terme ».

Attention toutefois :
- L’écriture en flash est ‘lente’ (ordre de grandeur : 5ms). C’est beaucoup plus lent qu’une écriture en
RAM qui s’effectue en quelques dizaines de ns !
- On ne peut écrire que des ‘0’. (écrire des ‘1’ impose un ‘effacement’ du secteur où se trouve la case
concernée, ce secteur comptant 256 octets). Cela rallonge le temps nécessaire !
- La flash s’use à chaque écriture. Le constructeur recommande de ne pas dépasser 10000 écritures d’un
même secteur. Dans la pratique, le test d’usure est facile à faire… en quelques heures, on peut avoir
écrit plusieurs centaines de milliers de fois au même endroit, et on atteint les dysfonctionnements.

Un module logiciel simpliste (stm32f1_flash.c/h) est mis à votre disposition dans /lib/bsp.

 Lisez bien les commentaires des fonctions :

o void FLASH_set_word(uint32_t index, uint32_t data)
o uint32_t FLASH_read_word(uint32_t index)

La fonction FLASH_kill ne doit pas être utilisée. Mais vous pouvez la lire.
Elle a permis lors d’un test de mettre en évidence la bonne tenue de la flash d’un STM32F103, qui a bien
fonctionné jusqu’à 1,65 millions d’écritures ! (loin au-delà les recommandations du constructeur !)

3. Périphériques internes : RTC (horloge temps réel)

L’horloge temps réel est un périphérique semblable à un timer.

- Elle connait le nombre de jours par mois, le nombre de mois dans l’année, de secondes par minute…
- Elle connait les années bissextiles
- Elle dispose d’une alarme réglable
Dès qu’on a réglé son heure et sa date, elle compte et conserve ainsi l’heure qu’il est.

On peut l’utiliser dès que notre dispositif a besoin de « l’heure courante » ou la « date ».

Il ne faut pas la confondre avec un timer. Elle n’a pas vocation à être utilisée pour des tâches « répétitives à
chaque seconde ou à chaque heure ».

Une fonction de démonstration est disponible dans le module logiciel lib/bsp/stm32f1_rtc.c/h

 Parcourez cette fonction DEMO_RTC_process_main() attentivement !

Astuce : afin de faciliter vos tests, vous pourriez être amenés à provoquer un écoulement rapide du temps.
Utilisez pour cela la fonction RTC_set_time_acceleration !
 4. Périphériques internes : I2C
[extraits de la page Wikipedia : https://fr.wikipedia.org/wiki/I2C]

I2C est un bus série synchrone bidirectionnel half-duplex.

Plusieurs équipements, soit maîtres, soit esclaves, peuvent être connectés au bus.
Les échanges ont toujours lieu entre un seul maître et un (ou tous les) esclave(s), toujours à l'initiative du
maître (jamais de maître à maître ou d'esclave à esclave).

La connexion est réalisée par l'intermédiaire de deux lignes :

 SDA (Serial Data Line) : ligne de données bidirectionnelle,
 SCL (Serial Clock Line) : ligne d'horloge de synchronisation bidirectionnelle.
Il ne faut également pas oublier la masse qui doit être commune aux équipements.

Les 2 lignes sont tirées au niveau de tension VDD à travers des résistances de pull-up (RP).

Les équipements connectés au bus le sont par des sorties de type drain ouvert (ou collecteur ouvert) sur les
deux lignes SDA et SCL. Les équipements sont donc câblés sur le bus par le principe du « ET câblé », ce qui
veut dire qu'en cas d'émission simultanée de deux équipements, la valeur 0 écrase la valeur 1. Au repos, le bus
est au niveau haut (à travers les résistances de pull-up RP).
On dit donc :
 que l'état logique « 0 » ou « LOW » est l'état « dominant »,
 que l'état logique « 1 » ou « HIGH » est l'état « récessif ».

Vitesses ‘courantes’ : 100 kbits/s à 400 kbits/s. Chaque octet transmis fait l’objet d’un bit d’acquittement par
le destinataire.
---
La brique logicielle stm32f1_adc.c/h fournit des fonctions utiles pour interfacer un périphérique I2C.

Le STM32F103 dispose de 2 périphériques I2C : I2C1 et I2C2.

Par défaut, l’I2C1 est relié aux broches PB8 (SCL) et PB9 (SDA). En activant la macro I2C1_ON_PB6_PB7
dans config.h, il est possible de relier l’I2C1 aux broches PB6 (SCL) et PB7 (SDA).

De nombreux composants interfacés en I2C l’utilisent sous forme d’accès à leurs registres internes. En plus de
l’adresse du composant concerné, chaque lecture ou écriture utilise donc l’adresse d’un registre interne à ce
composant.
Pour cela, les fonctions suivantes demandent un paramètre ‘reg’ :
- I2C_Write écriture dans un registre du composant
- I2C_WriteMulti écritures multiples à partir d’un registre du composant
- I2C_Read lecture d’un registre du composant
- I2C_ReadMulti lectures multiples à partir d’un registre du composant
Pour les composants qui n’utilisent pas cette pratique, les fonctions suivantes sont utilisables :
- I2C_ReadNoRegister lecture simple
- I2C_ReadMultiNoRegister lecture simple multiple
- I2C_WriteNoRegister écriture simple
- I2C_WriteMultiNoRegister écriture simple multiple
 5. Périphériques internes : SPI

Le bus SPI est un bus série synchrone bidirectionnel.

Pour ‘n’ esclaves, il est constitué de n+3 fils :
- SCK : Horloge produite par le maître
- MOSI (Master Output Slave Input) : données envoyées par le maître
- MISO (Master Input Slave Output) : données envoyées par l’esclave
- CSn (Chip Select) : un fil par esclave… Actif à l’état bas.

Lorsque le Chip Select d’un esclave est imposé à l’état bas, cet esclave écoute ce qui est transmis sur le bus.
Chaque envoi sur le bus SPI est un « échange » de données. (1 octet sur MOSI, 1 sur MISO).
(Souvent, à cause de la situation ou du protocole d’échange, l’un de ces 2 octets n’a pas d’intérêt. L’octet nul
peut alors être utilisé comme remplissage.)

La vitesse d’un bus SPI atteint typiquement 1Mbits/s… parfois plus (5Mbits/s, 10Mbits/s…)

---
La brique logicielle stm32f1_spi.c/h fournit des fonctions utiles pour interfacer un périphérique SPI.

Le STM32F103 dispose de 2 périphériques SPI : SPI1 et SPI2.

Par défaut, le SPI1 est relié aux broches PA5 (SCK), PA6 (MISO) et PA7 (MOSI).
En activant la macro SPI1_ON_PB3_PB4_PB5 dans config.h, il est possible de relier le SPI1 aux broches PB3
(SCK), PB4 (MISO) et PB5 (MOSI).

Le SPI2 est relié aux broches PB13 (SCK), PB14 (MISO) et PB15 (MOSI).

Si le microcontrôleur à le rôle du ‘maître SPI’, les Chips Selects peuvent être associés à n’importe quel GPIO.

Les fonctions suivantes sont utilisables :

- SPI_WriteRead écriture + lecture simple
- SPI_WriteReadBuffer écriture + lecture simple multiples
- SPI_ReadNoRegister lecture simple
- SPI_ReadMultiNoRegister lecture simple multiple
- SPI_WriteNoRegister écriture simple
- SPI_WriteMultiNoRegister écriture simple multiple

Certains composants n’étant pas compatible avec des vitesses trop rapides, la modification de la vitesse du bus
SPI peut se faire en agissant sur le prédiviseur (Prescaler) :
- SPI_setBaudRate
 6. Périphériques internes : Systick

Le STM32F103 est doté de plusieurs timers, dont certains disposent de fonctionnalités annexes (génération de
signaux PWM, acquisitions externes, comparaisons, …)

Le systick est un timer simplifié, exclusivement conçu pour cadencer le déroulement d’une application dans le
temps. Il est déjà configuré au rythme d’1ms par la fonction HAL_init() que nous appelons au tout début du
main, notamment parce qu’il est utilisé par certaines fonctionnalités de la librairie HAL fournie par le
fabriquant.

Dès lors, la fonction Systick_Handler() est appelée en interruption à chaque ms.

Nous avons conçu un module logiciel qui permet d’associer au systick une liste de fonctions dont on veut
déclencher des appels périodiques.
Ainsi, vous disposez de la fonction :
bool_e Systick_add_callback_function(callback_fun_t func);

Cette fonction attend en paramètre un « pointeur sur fonction » (désolé).

Elle enregistre cette « adresse de fonction » dans un tableau.
Puis, lors de chaque routine d’interruption du timer Systick, ce tableau sera parcouru et chaque fonction qui
s’y trouve sera appelée !

Pour l’utiliser, c’est très simple :

______________________

void process_ms(void) //on définit la fonction que l’on souhaite voir appelée à chaque ms
{
//Le code placé ici sera donc exécuté périodiquement, chaque ms
}
______________________
#include "systick.h" //ne pas oublier l’include...
//puis, quelque part dans l'initialisation
Systick_add_callback_function(&process_ms);
//ajoute la fonction process_ms à la liste des fonctions à appeler à chaque ms.

De façon annexe, la fonction SYSTICK_get_time_us peut être utilisée pour « connaître le temps courant en
µs ». (sur 32 bits, ce qui déborde en un peu plus d’1h).
 7. Périphériques internes : ADC

Le périphérique ADC (Analog to Digital Converter) permet d’acquérir une tension analogique et de la
convertir en un nombre, exploitable dans le programme.
Expliquons comment la mesure s’effectue.
Vous connaissez le principe du juste prix ?
Quel était le prix de ce magnifique microprocesseur i4004, en 1971, premier né d’une longue série.
(740kHz, 2300 transistors, 92 000 opérations par secondes !)
$512 ? C’est moins.  0
$256 ? C’est moins.  0
$128 ? C’est plus.  1
$192 ? C’est plus  1
$224 ? C’est moins.  0
$208 ? C’est moins.  0
$200 ? C’est plus.  1
$204 ? C’est moins.  0
$202 ? C’est plus.  1
$203 ? Gagné !  1
(on remarque que 0b0011001011 = 203) (aujourd’hui, cet objet de collection est négocié à plus de $1500)
Ce même procédé d’approximation successive est appliqué à la tension analogique lorsqu’elle est
échantillonnée par le périphérique ADC.

1- un ‘petit’ condensateur (intégré dans le microcontrôleur) est chargé par la tension d’entrée souhaitée.
(cela permet de stabiliser la valeur mesurée). On parle d’échantillonneur-bloqueur.
2- successivement, des comparaisons sont effectuées, selon la dichotomie présentée ci-dessus. La
résolution de l’ADC donne le nombre de comparaisons. (souvent 8, 10 ou 12 bits par exemple).
3- on obtient un nombre qui est mis à disposition par le périphérique, dans un registre.
Deux références (+ et -) encadrent ces grandeurs. Ces références ne sont pas forcément 0V et VDD… On
peut souvent choisir d’amener des tensions références.

Le STM32 dispose d’un ADC sur 12 bits (références : 0V et 3V). Le nombre obtenu va donc de 0 à 4095.
Nombre_obtenu = tension * 4096 / 3V.
Attention, il ne faut pas confondre résolution et précision.
Une balance de cuisine peut être résolue au microgramme, alors que sa précision est de 10g. C’est idiot. A
l’inverse, une précision de 10g pour une résolution de 100g permet d’être sûr que le résultat présenté est
correct. Une résolution de x bits nous donne x étapes pour s’approcher du résultat.
Le module logiciel stm32f1_adc.c/h qui vous est fourni permet de :
- Initialiser l’ADC1 du microcontrôleur, dont la lecture des entrées analogique sera cadencée
au rythme d’1 mesure par ms (grâce au timer 3).
o void ADC_init(void)
- Consulter à tout moment la valeur du dernier échantillon disponible pour le canal souhaité
o int16_t ADC_getValue(adc_id_e channel)
- Savoir si une nouvelle donnée est disponible depuis notre précédente demande
o bool_e ADC_is_new_sample_available(void)
- Faire appeler automatiquement après chaque échantillonnage une fonction dont l’adresse est
fournie en paramètre à la fonction :
o void ADC_set_callback_function(callback_fun_t callback)

Dans config.h, chaque canal souhaité doit être activé selon cet exemple :
#define USE_BSP_TIMER 1 //Utilisation de stm32f1_timer.c/h
#define USE_ADC 1 //Utilisation de stm32f1_adc.c/h

//On active le canal AN10 qui correspond à la broche PC0, notée A5 sur la Nucleo
#define USE_AN10 1 //Broche correspondante : PC0
Lorsque vous modifiez le contenu de config.h, prenez l’habitude de demander ensuite à eclipse de rafraîchir sa lecture des fichiers pour
qu’il prenne conscience des changements impliqués (cela impacte les soulignements en rouge dans Eclipse, mais n’a aucune influence sur la
compilation) : Bouton-droit sur le projet -> Index -> Freshen All Files
 8. Périphériques internes : UART

L’UART (ou USART) est un périphérique permettant la communication d’information sur un bus série
asynchrone (ou Synchrone, mais nous n’en parlons pas ici).

Un bus UART est mono ou bidirectionnel et est constitué de 2 à 3 fils :

- Tx (facultatif) : données à transmettre
- Rx (facultatif) : données à recevoir
- GND !

Attention, il faut penser à croiser : le Tx d’un émetteur vers le Rx du

récepteur (et vice-versa).

Contrairement aux bus I2C et SPI, les données sont ici échangées sans signal horloge ! Il faut donc que le
récepteur opère à la même vitesse que le transmetteur. Ils sont configurés pour cela.

Exemple de vitesses courantes : 9600 bits/sec ; 38400 bits/sec ; 115200 bits/sec.

L’état de repos est le niveau haut logique. On s’intéresse ici au mode le plu courant : 8-N-1 (8 bits de données,
pas de bit de parité, 1 bit de stop).
Tout octet à transmettre compte 10 bits :
- 1 bit de start, toujours à 0 (sinon on ne saurait pas quand commence l’envoi !).
- 8 bits utiles
- 1 bit de stop, toujours à 1 (cela permet notamment de se resynchroniser pour l’octet suivant)

source des images :

https://people.ece.cornell.edu/land/courses/ece4760/PIC32/index_UART.html

La librairie stm32f1_uart.c/h donne accès aux 3 UART qui équipent le STM32F103.

Les envois et les réceptions sont « bufferisés » afin de ne pas perdre de données en réception (Rx) (et
accessoirement de ne pas bloquer le programme trop longtemps (Tx)).
- UART_putc envoi d’un caractère
- UART_puts envoi d’une chaine de caractères
- UART_data_ready indique si un octet a été reçu
- UART_get_next_byte permet de récupérer (dans l’ordre) le prochain octet ayant été reçu

Il est possible d’envoyer des chaînes « formatées » :

- En utilisant sprintf dans un tableau, lequel tableau peut ensuite être transmis par UART_puts
- En utilisant printf (après avoir redirigé le flux stdout, en ayant appelé SYS_set_std_usart)

L’acquisition de trames de plusieurs octets est possible, notamment en suivant les conseils évoqués dans la
mission sun_tracker ou dans ‘votre projet – partie software’.
 9. Périphériques internes : IT Externes

On souhaite parfois exécuter une fonction à chaque changement d’état d’une broche d’entrée du
microcontrôleur. Dans cette situation, il n’est pas absolument nécessaire de scruter la broche en
permanence.

Dans le cas d’un bouton poussoir, nous recommandons toutefois d’avoir recours à la scrutation
régulière (par exemple toutes les 10ms, dans une interruption timer). Cela présente l’avantage de
constituer naturellement un anti-rebond logiciel…
Mais dans le cas où l’événement qui survient sur la broche doit être traité immédiatement, le recours
aux ITs externe s’avère nécessaire.

Exemples :
- Réception d’un signal en provenance d’une télécommande infrarouge.
- Réception d’un évènement d’alarme en provenance d’un périphérique externe
- Datation précise d’un echo provenant d’un télémètre ultrason
- …
Fonction d’interruption Broches portant
Le STM32F103 est capable de détecter un le numéro
changement d’état sur l’ensemble de ses EXTI0_IRQHandler 0 (PA0, PB0, …)
broches. Toutefois, le nombre de vecteurs EXTI1_IRQHandler 1 (PA1, PB1, …)
d’interruptions étant limités, il faut considérer EXTI2_IRQHandler 2
les regroupements suivants. Dans la pratique, il EXTI3_IRQHandler 3
est conseillé de ne pas utiliser deux broches
EXTI4_IRQHandler 4
portant un numéro similaire car il est difficile
EXTI9_5_IRQHandler 5à9
de les distinguer (par exemple PA2 et PB2).
EXTI15_10_IRQHandler 10 à 15

Un module logiciel simplifiant l’utilisation de ces ITs externe est proposé : /lib/bsp/stm32f1_exti.c.

1- Configurez la broche souhaitée en mode IT (sur front montant, descendant, ou les deux) :

BSP_GPIO_PinCfg(GPIOA, GPIO_Pin_4, GPIO_MODE_IT_RISING_FALLING, GPIO_PULLUP,

GPIO_SPEED_FREQ_HIGH);

2- Appelez la fonction EXTIT_set_callback() selon les exemples ci-dessous :

EXTIT_set_callback(&ma_fonction, EXTI_gpiopin_to_pin_number(GPIO_Pin_4), TRUE);

ou :
EXTIT_set_callback(&ma_fonction, 4, TRUE);

3- Vous pouvez ensuite activer ou désactiver l’appel de votre fonction à chaque changement de
la broche, en utilisant :
EXTIT_enable()
EXTIT_disable()

La fonction ma_fonction sera alors appelée ‘immédiatement’ dès qu’un changement d’état se
présentera sur la broche.
 10. Ecran TFT ILI9341 240x320 (tactile)

L’écran TFT ILI9341 est un écran de 2,4" pouvant afficher 240x320 pixels.
Certaines versions sont dotées d’un dalle tactile (dont la précision n’est pas excellente).
On reconnait ces versions « avec tactile » à la présence du contrôleur XPT2046 au verso.

Le contrôleur de l’écran (ILI9341) et celui du tactile (XPT2046) se pilotent avec un bus SPI.
Il faut donc relier ces broches à l’un des périphériques SPI du microcontrôleur.

Pinout (les couleurs concernent les photos ci-dessous, pour relier l’écran à la Nucleo) :

La LED verte de la carte Nucleo étant reliée à la même broche que la ligne d’horloge du bus SPI
qui pilote l’écran, il est normal que l’éclairage de la LED soit impacté lorsque l’on utilise l’écran !
VCC marron +3V3 (ou +5V)
GND rouge GND
CS orange PA12
RESETjaune PA9
D/C vert PA8
MOSI bleu PA7 (mosi)
SCK violet PA5 (sck)
LED gris +3V3
MISO blanc PA6 (miso)
T_CK PA5 (sck)
T_CS noir PA11
T_DIN PA7 (mosi)
T_DOUT PA6 (miso)
T_IRQ PA15

Les broches « T_... »

correspondent au tactile.

Les broches RESET, D/C, CS, T_CS, T_IRQ peuvent être relié à n’importe quel GPIO.
Les ports indiqués ci-dessus correspondent cependant à la configuration par défaut du driver fourni.
Sur le DEEP PCB, les ports sont différents, il faut donc corriger le logiciel en conséquence
(stm32f1_ili9341.h).

Pensez à bien relier cet écran par une barrette femelle soudée sur votre PCB.
Dans les librairies logicielles fournies, un pilote permet d’utiliser cet écran TFT.
//Dans config.h, localiser les lignes suivantes, et remplacez les 0 par des 1 pour activer ces modules :
#define USE_SCREEN_TFT_ILI9341 1
#define USE_FONT11x18 1

//Ajoutez en début de fichier main.c

#include "tft_ili9341/stm32f1_ili9341.h"

//Ajouter dans la fonction main(), juste avant la boucle while(1) de tâche de fond :
ILI9341_Init();
ILI9341_Fill(ILI9341_COLOR_WHITE);
ILI9341_DrawCircle(20,20,5,ILI9341_COLOR_BLUE);
ILI9341_DrawLine(20,20,100,20,ILI9341_COLOR_RED);
ILI9341_DrawLine(20,20,20,100,ILI9341_COLOR_RED);
ILI9341_Putc(110,11,'x',&Font_11x18,ILI9341_COLOR_BLUE,ILI9341_COLOR_WHITE);
ILI9341_Putc(15,110,'y',&Font_11x18,ILI9341_COLOR_BLUE,ILI9341_COLOR_WHITE);
ILI9341_Puts(200,200, "chaine", &Font_11x18, ILI9341_COLOR_BROWN,
ILI9341_COLOR_WHITE);

 Parcourez le module logiciel stm32f1_ili9341 pour y consulter la liste des fonctionnalités

disponibles.

Dalle tactile

Certains modèles d’écrans TFT ILI9341 est dotés d’une dalle tactile ; gérée par le contrôleur XPT2046.
Cette dalle est indépendante de la partie affichage de l’écran, mais pour plus de commodité, le driver fourni
dans /lib/bsp/tft_ili9341/stm32f1_xpt2046 peut exprimer les coordonnées mesurées dans une unité
correspondant aux pixels sur l’écran.

La précision de cette fonctionnalité tactile est limitée, il est recommandé de ne pas exiger plus fin que 50 px.

Une astuce originale permet d’améliorer sensiblement la précision. Il

faut pour cela homogénéiser le plan de masse. Dans les cas où le
support de carte SD est inutilisé par votre application (c’est
généralement le cas), vous pouvez tenter le bricolage douteux mais
efficace présenté sur la photo ci-contre. Il vous faudra gratter
légèrement le verni au cutter afin de faire apparaître le cuivre.
Ce regroupement de broches ainsi forcé par une bonne dose d’étain
est ensuite relié au GND sur votre PCB support par la barrette
mâle qui s’y trouve soudée…

La fonction de démo présentée (XPT2046_demo) montre notamment

comment on peut afficher un curseur correspondant au point pressé. Vous remarquerez la mémorisation du
précédent curseur affiché, qui permet de l’effacer avant l’affichage du nouveau curseur.

Après un appel a XPT2046_init(), il est possible d’appeler périodiquement la fonction

XPT2046_getMedianCoordinates(&x, &y, XPT2046_COORDINATE_SCREEN_RELATIVE)
Cette fonction renvoie TRUE si un appui est détecté. Les pointeurs x et y sont alors remplis et indiquent la
coordonnée de l’appui.

Il existe plusieurs modèles d’écrans, dont certains n’ont pas le même câblage ; cela provoque une inversion de
l’un des axes (selon la configuration portrait ou paysage choisie, cette inversion peut porter sur x ou sur y).
Si vous constatez une telle inversion, il suffit d’inverser l’axe en cause de cette façon :
x = 320 – x;
 11. Ecran e-paper
Nous disposons (en très petite quantité) d’écrans e-paper.

Ces écrans ont la faculté de ne pas consommer de courant lorsqu’ils affichent : un apport d’énergie n’est
nécessaire que pour modifier l’affichage.

Par ailleurs, le temps de rafraîchissement est long (env. 2 secondes) et durant ce rafraîchissement, il y a
plusieurs étapes durant lesquels une alternance noir/blanc peut être observée. Cet écran ne peut donc être
utilisé que pour des usages où les données affichées ne changent que rarement… et généralement dans un
contexte où l’énergie disponible est limitée (ou bien absente à certains moments).

pin default description

Busy PB0
Reset PA1 0:reset/1:set
DC PC1 Data (1)/Command (0)
CS PA4 | SPI Chip Select
CLK PA5 | SPI SCK
DIN PA7 | SPI MOSI
GND GND
VCC 3.3V – 5V

www.waveshare.com/wiki/4.2inch_e-Paper_Module

L’ensemble des broches sont configurables et peuvent utiliser n’importe quel GPIO (sauf CLK et DIN,
forcément en lien avec un bus SPI !)
Cette configuration est disponible dans config.h
#if USE_EPAPER
//...
#endif

Pour en savoir plus sur l’utilisation de la librairie logicielle, rendez-vous dans lib/bsp/epaper/epaper_demo.c

Dans cette librairie, on utilise un « grand » tableau en RAM (1 bit par pixel) pour représenter l’image qui sera
envoyée à l’écran. Pour un écran de 300*400 pixels, ce tableau occupe 300*400 bits, soit 15000 octets, soit 75%
de la RAM. A la compilation, s’il s’avère que la RAM est pleine, il faudra peut-être user d’un subterfuge afin
que ça rentre. Ouvrez le fichier LinkerScript.ld, et modifiez ces lignes :
_Min_Heap_Size = 0x100; /* required amount of heap */
_Min_Stack_Size = 0x200; /* required amount of stack */
 12. Matrice de Leds 8x8

Cette matrice est composée de 64 leds adressables WS2812.

On utilise +5V, GND et Din.

Plusieurs matrices peuvent être chaînées (Dout de l’une allant vers Din de la suivante).

Attention, parfois, ces matrices sont routées en « serpentin », la 9ème LED est donc sous la 8ème … donc la
16ème se trouve sous la 1ère et la 17ème sous la 16ème…
A vous de vérifier cela !

Le DEEP PCB dispose d’une sortie permettant de piloter ces LEDs adressables.

+ Voir le chapitre 14.

En soutenance : selon les projets, vous pouvez aborder la façon dont vous avez construit et
rempli les structures de données représentant les pixels dans votre logiciel.
Vous pouvez également expliquer le fonctionnement des WS2812 et ce qu’elles attendent
comme signal.
 13. Ruban de Leds pilotables

Ces rubans sont constitués de leds adressables WS2812.

Ils existent dans plusieurs variantes :
- Quantité de leds/m
- Ruban noir ou blanc
- Protection silicone (IP65) ou plastique entourant
complètement le ruban (IP67)

Le DEEP PCB dispose d’une sortie permettant de piloter

ces LEDs adressables.

+ Voir le chapitre 14.

 14. Leds WS2812

En ruban ou en matrice, ces leds adressables WS2812 contiennent : 3 leds

(Rouge, Vert, Bleu).
Chacune d’elle peut afficher une quantité de lumière, quantifiable de 0 à
255. Il faut donc 24 bits pour décrire l’état de chaque LED.

A puissance max, il faut compter de l’ordre de 50mA par LED.

Lien vers la datasheet : https://cdn-shop.adafruit.com/datasheets/WS2812.pdf

Chaque LED reçoit GND et +5V. Les LEDs sont ensuite chainées. ‘Dout’ d’une LED va vers ‘Din’ de la
suivante.
Scénario permettant de comprendre le fonctionnement :
- Le microcontrôleur pilote le ‘Din’ de la première LED.
- Chaque bit envoyé est une combinaison d’un ‘1’ logique et d’un ‘0’ logique. La durée de ces états
informe d’un bit à 0 ou 1.
- Cette première LED reçoit les 24 premiers bits… puis envoi le 25ème et les suivants à la LED d’après
- La seconde LED consomme ainsi les 24 bits suivants, et ainsi de suite.
- Pour un ruban ou une matrice de 10 leds, on doit donc envoyer 10*24=240 bits.
- Une « pause » dans l’envoi d’au moins 50µs permet à chaque LED de considérer que le prochain bit
sera pour elle… c’est ainsi que l’on peut rafraîchir l’affichage avec une autre combinaison.

Les contraintes temporelles pour chaque bit sont très fortes, il n’est pas simple de les respecter en C (les
durées d’exécutions dépendent des options de compilations). C’est pourquoi le pilote logiciel fourni fait appel à
une fonction rédigée en assembleur… et spécifiquement réglée en durée pour le F103 cadencé à 64MHz.

 Faites un tour dans le fichier lib/bsp/ws2812/MatrixLed/WS2812S.c

En soutenance : vous pouvez expliquer le fonctionnement des WS2812. N’hésitez pas également
à expliquer brièvement le fonctionnement des couches basses de la librairie fournie.
Si vous parvenez à bâtir une librairie assurant le pilotage par DMA agissant sur le rapport
cyclique de l’output compare d’un timer, vous pouvez gagner des points. Notons que
comprendre la phrase précédente est déjà une étape valorisable.
 15. LED de puissance

Dans certains projets, on souhaite disposer de LEDs de puissance présentant un éclairement important.

 Attention à la dangerosité de ces LEDs, ne les regardez pas directement, et envisagez des
protections physiques durant vos tests (un bout de papier correctement scotché au PCB supportant
les LEDs est une option efficace).

Les broches du microcontrôleur ne sont pas conçues pour fournir un courant important (l’ordre de grandeur
maximal est autour de 10mA).
Pour une LED de puissance, il convient donc d’utiliser une interface de puissance ; typiquement un MOSFET.

Sachez que les tensions de coude des LEDs blanches sont généralement autour de 3V.
Il vous faudra prendre cela en compte dans le calcul du dimensionnement de la résistance série de protection.

Voici un exemple de calcul pour un cas concret de dimensionnement.

---

Dans cet exemple, on souhaite utiliser la LED « 158302250 » du fabricant Würth Elektronik.
(https://www.we-online.fr/catalog/datasheet/158302250.pdf)

Pour un éclairage correspondant à 50mA (l’éclairage fournit est à peu près proportionnel au courant forward),
on obtient un point de fonctionnement à 3,2V.

 Si mon alimentation 5V est utilisée pour piloter cette LED, on a donc une chute de 5-3,2 = 1,8V, à
dissiper dans une résistance.
 Cette résistance doit donc valoir Rs = U / I = 1,8 / 0,050 = 36 Ohm
 Je choisis donc une résistance de 33 Ohm (ou de 47…) Et je refais le calcul dans l’autre sens pour
déterminer le courant finalement obtenu, proche de mon objectif initial.
 Attention à la puissance dissipée par cette résistance : P = Rs*I² = U*I = 1,8*50m = 90mW.
o Dans cet exemple, une résistance standard 1/4W peut suffire.
o Dans d’autres exemples, il faudra utiliser une résistance 1W ou 3W.

En soutenance : abordez le point de fonctionnement choisi (ou subi !) dans votre contexte.
(Dans la LED et dans la résistance série : courant, tension, puissance).
 16. Cube de LED : utilisation d’un driver à registre à décalage

Vous souhaitez piloter un nombre important de LEDs ou fabriquer un cube de LEDs ?

Voici quelques pistes et conseils.

Dès que votre projet compte plus d’une dizaine de LEDs environ, il est pertinent de faire appel à un
composant spécifique pour assurer le pilotage de ces LEDs : un driver de LEDs.

Nous déconseillons d’attaquer de trop gros cubes, qui s’avèrent fastidieux à câbler et à piloter.
Si vous êtes vraiment très motivés (et que vous avez des semaines de vacances devant vous !) sachez
qu’un étudiant a réalisé un cube de 9*9*9 LEDs tricolores, il y a quelques années.

Dans le cadre d’un projet d’électronique numérique, privilégiez par exemple un cube 3x3x3.

Pour un cube (par exemple de 4 étages), il faut généralement associer ce ou ces drivers à des
transistors PMOS qui pilotent les étages. On découpe ainsi le temps en 4 périodes. A chaque
période :
1- On bloque les 4 PMOS
2- On met à jour le registre à décalage du driver de LEDs
3- On sature l’un des 4 PMOS, les autres sont maintenus bloqués.
Si ce balayage est assez rapide, l’utilisateur ne perçoit pas l’effet de clignotement !

Driver de led, STP16CP05

https://www.st.com/resource/en/datasheet/stp16cp05.pdf

Ce driver, que nous conseillons d’utiliser dans le package SO-24 ; peut piloter jusqu’à 16 LEDs et y
réguler le courant. Ce driver « amène le GND » au LED, dont les anodes doivent être reliées au
Vcc, en permanence, ou à travers des transistors PMOS. Plusieurs drivers peuvent être chainés
(SDO  SDI).

Il est possible de régler le courant asservi dans les LEDs en dimensionnant la résistance placée entre
R-EXT et GND.
Pensez à relier l’entrée (Output Enable) à 0.
Pour mettre à jour l’état des sorties du driver, il faut respecter les étapes suivantes :
1- Présenter un bit sur l’entrée SDI
2- Provoquer une impulsion sur l’entrée CLK
3- Présenter un second bit sur SDI (les bits glissent les uns derrières les autres dans le registre)
4- … et ainsi de suite, en fonction du nombre de bits demandés
5- Provoquer une impulsion sur l’entrée LE (Latch Enable). Les sorties sont alors mises à jour

Consultez les fichiers lib/bsp/DriverLed_STP16CP05/stp16cp05.c pour en savoir plus.

Une fonction de test est également proposée : STP16CP05_test. Libre à vous de deviner son
comportement.
 17. Module Bluetooth HC-05

Le module Bluetooth HC-05 est un module Bluetooth pouvant être

configuré comme un maître ou un esclave.
Il communique en UART (3,3 ou 5V).

Avec deux modules HC-05, il est donc possible de remplacer une liaison
UART filaire par une liaison équivalente sans fil.

pin default description

en x non relié
Vcc Vcc +5V
GND GND GND
TXD PA3 (Rx) Tx du device, relié à Rx du microcontrôleur
RXD PA2 (Tx) Rx du device, relié à Tx du microcontrôleur
state x non relié
3.3 - sortie du régulateur intégré

En Bluetooth, c’est le maître qui se connecte à l’esclave.

Il existe deux situations typiques d’utilisation du HC-05 dans la plupart des projets :
- Connexion entre un device bluetooth (smartphone…qui joue le rôle du maître) et un HC-05 (esclave)
- Connexion entre deux HC-05

Pour configurer un module HC-05, il faut entrer dans un mode « AT », et lui envoyer des « commandes AT ».
Suivez pour cela les étapes suivantes :
 Utiliser la page 8 du document "votre projet partie software" pour relier le Rx de la Nucleo au Tx du
HC-05 et vice-versa. (Attention, les broches PA2 et PA3 ne sont pas reliées sur la Nucleo, mais dispos sur la sonde de débogage)
 Ouvrir le port COM à 38400 bauds/sec
 Entrer en mode AT en appuyant sur le bouton pendant l'arrivée de l'alim.
 on doit observer un clignotement régulier rapide
 Insérer ensuite les commandes AT suivantes :
(sources : https://www.instructables.com/id/How-to-Configure-HC-05-Bluetooth-Module-As-Master-/)

Esclave :
AT+RMAAD (To clear any paired devices)
AT+ROLE=0 (To set it as slave)
AT+ADDR (Pour pouvoir noter l'adresse, qui sera utile pour configurer le maitre)
AT+UART=115200,0,0 (To fix the baud rate at 115200)
AT+NAME=LENOMSOUHAITE
NB: attention, l'adresse est reçue au format : +ADDR:21:13:14968
Alors qu'il faut lire ceci (le 0 manquant dans cet exemple n’est pas affiché !) : 21:13:014968

Maitre :
AT+RMAAD (To clear any paired devices)
AT+ROLE=1 (To set it as master)
AT+CMODE=0 (To connect the module to the specified Bluetooth address)
AT+BIND=xxxx,xx,xxxxxx (L’adresse de l’esclave auquel on se connecte, attention, ce sont des virgules !)
AT+UART=115200,0,0 (To fix the baud rate at 115200)
AT+NAME=LENOMSOUHAITE

 Débranchez/rebranchez ensuite les modules, un clignotement lent signifie la bonne connexion.

 Testez alors l’envoi d’octet entre les modules (en vous référant au chapitre 8 sur l’UART)
En soutenance : décrivez les données que vous transmettez, et votre protocole le cas échéant.
 18. Capteur de température MCP9701

Le capteur de température MCP9701 est un capteur analogique fournissant une tension qui évolue
proportionnellement à sa température. Il est peu précis (de l’ordre du °C) mais simple à intégrer et peu
couteux.

Son intégration matérielle suggère fortement l’utilisation

d’un condensateur de découplage de 100nF placé au plus
près de son alimentation, afin de stabiliser cette
alimentation localement.

Un filtre passe bas est également possible pour diminuer

les risques liés au bruit.

Sa sortie doit être reliée à une entrée analogique.

La librairie stm32f1_adc.c/h fournit permettra d’acquérir un nombre image de la tension analogique mesurée.

Vous devez consulter la datasheet du MCP9701 pour y trouver le gain et l’offset que votre code doit prendre
en compte.
http://ww1.microchip.com/downloads/en/devicedoc/20001942g.pdf

Posez-vous les bonnes questions :

- Quelle est la plage de l’ADC (en tension et en nombre obtenu)
- Comment convertir ce nombre en tension ? En degré celcius ?
- Mes calculs peuvent-ils déborder dans certains cas ?

En soutenance : décrivez le calcul qui vous a permis de déterminer une température à partir des
donnée acquises depuis l’ADC.
 19. Capteur de température sans contact MLX90614

Le capteur de température MLX90614 est un capteur qui mesure la

température d’un objet placé devant lui, en mesurant la longueur d’onde
d’infrarouge émise par cet objet.

En effet, chaque objet dont la température est non nulle (différente de 0°K)
émet une lumière qui dépend de sa couleur. (Vous êtes des sources de
lumière infrarouge !)

Il est cependant recommandé de viser des surfaces « non réfléchissantes ».

La donnée acquise par le capteur est accessible depuis une liaison I2C.

pin default description

Vin Vcc 3 à 5V
GND GND
SCL PB8 | I2C clock
SDA PB9 | I2C Data

Sa consommation est de l’ordre de 1,3mA. Il est recommandé d’alimenter ce capteur directement depuis
une broche du microcontrôleur. Cela permet de le reseter si besoin, notamment lors du reset du
microcontrôleur.

Une librairie logicielle est fournie : lisez les commentaires dans /lib/bsp/MLX90614.c

En soutenance : vous pouvez donner votre ressenti sur le fonctionnement et les limites de ce
capteur. N’hésitez pas à montrer un exemple de trame I2C, acquise à l’oscilloscope.
 20. Capteur de pression BMP180

Le capteur de pression BMP180 est un composant CMS (boitier QFN) fonctionnant en I2C.
Pour vos développements, il est généralement disponible déjà soudé sur une breakout board intégrant un
régulateur de tension.

Ce composant intègre également un capteur de température.

pin default description

Vcc Vcc 3,3 à 5V
GND GND
SCL PB8 | I2C clock
SDA PB9 | I2C Data
3.3 - sortie du régulateur intégré

Une librairie logicielle est disponible dans lib/bsp/bmp180.

Activez USE_BMP180 dans config.h et parcourez la fonction BMP180_demo.

Après avoir initialisé le capteur, il est possible de lui demander de mesurer la température ou la pression.

Si l’on assume que la pression atmosphérique est de 1013hPa au niveau de la mer, alors on peut utiliser ce
capteur pour estimer notre altitude !
Dans tous les cas, si l’on assume que la pression est constante d’un point de vue météo, on peut utiliser ce
capteur pour estimer une différence d’altitude entre deux instants.

Mais attention, il n’est pas possible d’obtenir de façon cohérente à la fois l’altitude et la pression (l’un doit
être connu ou assumé pour trouver l’autre !)

Généralement, ces capteurs sont utilisés à des fins météorologiques. On doit alors obtenir la pression
« équivalente au niveau de la mer ». (Celle qui est donnée par les présentateurs météo, et qui sont
indépendante de l’altitude de la mesure !)
Il faut pour cela connaître l’altitude, et appeler la fonction BMP180_GetPressureAtSeaLevel.

En soutenance : vous pouvez donner votre ressenti sur le fonctionnement et les limites de ce
capteur. N’hésitez pas à montrer un exemple de trame I2C, acquise à l’oscilloscope.
 21. Capteur d’humidité DHT11

Le capteur d’humidité DHT11 permet d’estimer l’humidité de l’air. Il est également doté d’un capteur de
température.

Datasheet : https://www.mouser.com/datasheet/2/758/DHT11-Technical-Data-Sheet-Translated-Version-
1143054.pdf

pin description
Vcc Vcc (3 à 5V)
Data GPIO (PullUp)
GND GND
)

Ce capteur communique de façon bidirectionnelle avec le microcontrôleur, avec un seul fil !

Pour éviter les risques liés au court-circuit, le fil de signal est relié à Vcc avec une résistance de pull up (par
exemple 4,7k ou 10k). La broche du microcontrôleur doit être configuré en opendrain
(GPIO_MODE_OUTPUT_OD) afin de ne jamais imposer l’état logique haut !

Un condensateur de découplage de 100nF doit être placé au plus près de son alimentation, afin de stabiliser
cette alimentation localement.

Lisez les chapitres 3, 4 et 5 de la datasheet !

Vous en saurez plus sur les 40 bits envoyés par le capteur lorsqu’on le stimule par un pulse d’au moins 50us.

Parcourez ensuite le code de la librairie /lib/bsp/dht11

Dans la fonction DHT11_demo(), on voit notamment la nécessité d’un appel périodique à
DHT11_state_machine_get_datas(…)

Lorsque cette machine à état renvoie END_OK, cela signifie qu’une trame a été correctement reçue ! Les
données remplies dans les pointeurs fournis sont donc utilisables !

En soutenance : vous pouvez décrire le fonctionnement de la librairie fournie. Il est également

intéressant d’aborder les spécificités de la communication ‘one wire’ utilisée par ce capteur.
Un exemple de trame à l’oscilloscope peut être montré.
 22. Capteur de couleur / mouvement APDS9960

Le capteur APDS9960 intègre une LED infrarouge, et plusieurs photodiodes, sensibles aux couleurs RGB, et
orientées selon plusieurs directions.

Datasheet : https://cdn.sparkfun.com/assets/learn_tutorials/3/2/1/Avago-APDS-9960-datasheet.pdf

Il permet ainsi de remplir plusieurs rôles :

- Capteur de gestes (passage de la main dans une direction donnée…)
- Capteur couleur (plutôt efficace dans une ambiance à luminosité connue)
- Mesure de luminosité ambiante
- Détection de présence (approximatif…)

Ce capteur communique sur un bus I2C.

Il est généralement monté sur une breakout board facilitant son
intégration pour des tests.
Une barrette SIP mâle 6 points doit être soudée sur ce capteur. Une
barrette femelle 6 points l’accueillera sur votre PCB.

pin default description

VL - (sortie de pilotage de LED)
GND GND
Vcc Vcc 2,4V à 3,6V
SDA PB9 | I2C Data
SCL PB8 | I2C clock
Int PC9 (ou autre broche)

La librairie logicielle disponible dans /lib/bsp/APDS9960 vous

explique comment utiliser ce composant selon votre but.
Lisez-y les commentaires disponibles dans apds9960.c

Si votre objectif concerne la détection d’une couleur, il est conseillé de

placer le capteur à quelques mm de la zone à détecter, et de s’assurer
que la zone est correctement éclairée, par exemple en utilisant une
LED de puissance (voir chapitre 15).

Attention, sur certains modèles de breakout board il est nécessaire de souder une goutte d’étain pour relier les
résistances de pull-up du bus I2C. (Voir sur la photo ci-dessus, à droite, la goutte sur I2C PU).

En soutenance : vous pouvez expliquer le principe de votre algorithme pour reconnaître les
couleurs. Il est également possible de montrer un exemple de trame I2C, acquise à
l’oscilloscope.
 23. Télémètre à ultrasons HC-SR04

Le télémètre HC-SR04 est un capteur de distance à Ultrason.

Plutôt bas de gamme, il fonctionne sur la base de la mesure de temps entre l’émission d’un signal ultrason et
son retour sur un récepteur. Le signal émis est une suite de pulses à 40kHz.

Plafond

HC-SR04
Ce capteur est adapté à la détection d’un objet massif Signal US Feuille A4
et parallèle au capteur. En effet, le son peut facilement orientée à
rebondir, comme dans l’exemple ci-contre où le plafond 45°
est visible par réflexion sur la feuille de papier.

pin description
VCC +5V
Trig GPIO au choix (accepte le 3,3V)
Echo GPIO (tolérant 5V !) au choix
GND GND

Le microcontrôleur doit envoyer sur l’entrée « Trig » un pulse à

l’état haut durant au moins 10µs.
Au-delà d’un certain temps, le signal « Echo » passe à l’état
haut. Une mesure de la durée de cet echo renseigne sur le temps
mis par l’onde ultrason pour parcourir l’aller-retour avec l’objet
mesuré.

Connaissant la vitesse du son dans l’air (et assumant que le rôle

de la température est négligeable), on peut alors déterminer la
distance.

Une brique logicielle est proposée dans /lib/bsp/hc-sr04

Dans ce module logiciel, les broches echo sont gérées par des interruptions externes. Si vous souhaitez utiliser
plusieurs capteurs, il est donc conseillé d’utiliser des broches portant des numéros différents (par exemple
PB10, PB11, PB12, … en évitant PA10, PA11, PA12… et en évitant strictement les broches analogiques qui
ne sont pas tolérantes 5V !)

Certains de ces modules sortent l’Echo en 3,3V. Il n’est alors pas utile d’avoir recourt au pont diviseur… dans
ce cas, Recho- peut être retirée.

Analysez le contenu de la fonction HCSR04_demo_state_machine() qui contient une machine d’états

assurant des mesures régulières (100ms) d’un capteur relié aux broches PB6 (echo) et PC7 (trig).

En soutenance : expliquez le fonctionnement de la librairie fournie ! Vous pouvez également

revenir brièvement sur le principe physique de la mesure et sur les conditions qui en affectent le
fonctionnement (cible à 45° / cible ‘très’ ponctuelle / impact de la température ambiante…)
 24. Télémètre infrarouge GP2YA21YKOF

Datasheet : https://global.sharp/products/device/lineup/data/pdf/datasheet/gp2y0a21yk_e.pdf

Il existe plusieurs méthodes pour estimer la distance d’un objet à partir de lumière. La plus évidente consiste à
compter le temps que la lumière met à parcourir cette distance. Mais compte tenu de la vitesse de la lumière,
plutôt rapide, cela suppose une électronique rapide et potentiellement couteuse.
Mais une autre méthode existe !

Empruntons cette belle image au site

https://wiki.eprolabs.com/index.php?title=IR_Distance_Sensor_GP2YOA21YK :

La LED infrarouge émet une lumière. La matrice PSD la reçoit sur

une ligne de récepteurs.
Si cette lumière est allée frapper un objet proche (P1), son rayon
est fortement dévié jusqu’au point U1.
Si cette lumière est allée frapper un objet lointain (P2), son rayon
est moins dévié, jusqu’au point U2.

En analysant la réception sur sa ligne de réception ; le capteur

obtient ainsi une idée de la distance de l’objet ciblé !

L’ensemble du traitement est réalisé par le capteur qui nous fournit

une information analogique en sortie. (Approximativement en 1/d)

Les distances mesurées par ce capteur vont jusqu’à 80cm.

Attention, la sortie fournit n’est pas bijective.

Si le capteur est placé face à un objet proche
(moins de 6cm), on ne peut pas savoir s’il s’agit
d’un objet proche ou plus lointain.

Une astuce, dans certains contextes, peut consister

à s’assurer une « distance de retrait » minimale
entre l’objet mesuré et le capteur.

Le capteur doit être alimenté en 5V. Sa sortie

ne dépassant pas 3,1V, il est possible de l’envoyer
directement sur une entrée analogique d’un
STM32F103 !

pin description
rouge Vcc (+ 5V)
noir GND
jaune signal (analogique)

En soutenance : vous pouvez expliquer le principe physique exploité par ce capteur. Il est aussi
possible d’évoquer l’algorithme mis en place pour exploiter les données fournies. Dans certains
cas, la non bijectivité de la courbe est un problème et peut être évoquée.
 25. Télémètre infrarouge à temps de vol ST VL53L0

Le capteur VL53L0 fourni par ST Microelectronics est un télémètre à temps de vol qui mesure la
durée de trajet d’une lumière infrarouge réfléchie par un objet placé en face… dont on déduit la
distance.

Des résistances de
tirage doivent être
ajoutées sur les deux
lignes du bus I2C, vers
le 3,3V.
Valeurs recommandées :
2kOhm.

pin description
1 ---
2 I2C SCL (PB9)
3 nReset
4 I2C SDA (PB8)
5 Vcc (3,3V max !)
6 GND

Attention à ne pas poser le doigt sur le capteur et à le maintenir protégé de la poussière. Cela
pourrait altérer son bon fonctionnement.

Si vous souhaitez utiliser plusieurs capteurs, chacun doit disposer de sa propre broche reset. En effet,
on peut ainsi les allumer les uns après les autres et leur envoyer une nouvelle adresse différente de
l’adresse par défaut. C’est ainsi que procède le driver logiciel fourni.

Une fonction de démo est disponible dans /lib/bsp/VL53L0X/vl53l0_demo.c.

Plusieurs modes de mesures sont disponibles : privilégiant soit la qualité de la mesure, soit sa
rapidité, soit sa distance maximale. Cette démo configure le capteur dans un mode de mesure
rapide. Ainsi, de 1 à 8 capteurs peuvent être consultés en seulement 21ms !

Attention à ne pas confondre le VL53L0 avec son petit frère : le VL53L1, que l’on
peut reconnaitre à sa face aux deux rectangles dorés (ci-contre).
La librairie pour ce composant est disponible sur demande ; et nécessite un travail
de portage non réalisé à ce jour.
 26. Photorésistances

Une photorésistance est un composant dont la résistance varie selon la lumière qu’il reçoit.

Son temps de réponse est long : de l’ordre de la seconde. Il n’est donc pas
envisageable de transmettre des données facilement (dans ce cas, orientez-vous vers
des photodiodes ou phototransistors).
Il est idéal pour détecter si la lumière ambiante correspond au jour ou à la nuit.
On peut également s’en servir pour avoir une idée approchée de la lumière ambiante
(asservissement d’un éclairage…) ou pour détecter l’ouverture d’une boîte opaque.

Ces capteurs sont simples à mettre en œuvre : un simple pont diviseur est suffisant !

Les librairies Altium fournies n’incluent pas de photorésistance. (Il est toutefois possible d’utiliser le symbole
d’une résistance ; et l’empreinte PCB d’une diode 5mm, qui dispose d’un écart interbroche acceptable.)

L’ADC acceptant jusqu’à 3,3V, ce schéma est préconisé :

La résistance Rs est à dimensionner en fonction de l’ordre de grandeur des luminosités à détecter, et du

modèle de photorésistances. 10kΩ est généralement un bon compromis.

En soutenance : indiquez les valeurs mesurées, en précisant les conditions de luminosité

correspondantes.
 27. Capteur de luminosité BH1750FVI

Le capteur BH1750FVI permet de mesurer la luminosité ambiante.

https://www.mouser.fr/datasheet/2/348/Rohm_11162017_ROHMS34826-1-1279292.pdf

Pin description
VCC +3,3V
SCL PB8 | I2C clock
SDA PB9 | I2C Data
ADD  GND (ou VCC si capteur n°2)
GND GND

Des résistances de tirage de 4,7kΩ au 3,3V sont déjà placées sur les lignes du bus I2C.

Deux modes de fonctionnements existent :

- (OT) One-shot (une seule mesure, à la demande)
- (CON) Continu (mesure en boucle, il faut alors l’éteindre explicitement)

Plusieurs résolutions sont disponibles (mode conseillé = High resolution mode 1) :

Abr. Mode Temps de mesure Résolution

H2 High resolution mode 2 120 ms 0.5 lx
H1 High resolution mode 1 120 ms 1 lx
L Low resolution 16 ms 4 lx

Il est possible de brancher 2 capteurs BH1750FVI sur le même I2C :

- l’un doit avoir sa broche ADDR reliée au GND (adresse = 0x23)
- l’autre doit avoir sa broche ADDR reliée au 3,3V (adresse = 0x5C)

Référez-vous à la fonction BH1750FVI_demo() du module logiciel lib/bsp/BH1750FVI.

En soutenance : N’hésitez pas à montrer un exemple de trame I2C, acquise à l’oscilloscope.

 28. Capteur à effet Hall

La détection de présence d’un aimant peut se faire par plusieurs méthodes.

- Non traitée dans ce document : l’interrupteur à lame souple (ILS).

- Capteur à effet hall.

Exemple de référence : https://fr.farnell.com/hamlin/55100-3h-02-a/capteur-a-effet-hall/dp/5052567

Ce capteur dispose d’une sortie (en bleu), en collecteur ouvert.

Il faut donc tirer cette sortie au 3,3V via une résistance (10kΩ).

Un condensateur de 100nF est recommandé aux bornes de son

alimentation pour la stabiliser.

fil description
rouge VCC (5V typique : (3,8V à 24V))
noir GND
bleu signal en opendrain (tirage 10kΩ au 3,3V)

En présence d’un aimant, la sortie du capteur est imposée à l’état bas.

 29. Microphone préamplifié

L’intégration d’un microphone miniature nécessite généralement l’adjonction d’un amplificateur afin de
pouvoir acquérir le signal avec l’ADC d’un microcontrôleur.
Il existe des breakout board qui intègrent directement cet amplificateur.

L’une des possibilités pour réaliser cette fonction

d’amplification est d’utiliser le composant MAX9812 que l’on
retrouve couramment sur ces breakout board.
(datasheet :
https://datasheets.maximintegrated.com/en/ds/MAX9812-
MAX9813L.pdf)
Nous avons parfois ce modèle :
MAX4466

Lorsque l’on dispose de ce module complet, on peut directement utiliser une barrette
femelle pour relier le microphone préamplifié à l’ADC de notre microcontrôleur.

Observez bien le pinout qui dépend du modèle !

pin description
VCC 3,3V
GND GND
SIGNAL vers une entrée analogique

Si votre application nécessite des acquisitions d’échantillons régulières, utilisez la fonction

ADC_set_callback_function(&callback) du module logiciel stm32f1_adc.
Vous pourrez ainsi faire en sorte que votre fonction « callback() » soit appelée exactement à chaque
échantillon acquis par l’ADC !

En soutenance : évoquez l’algorithme mis en place pour interpréter les données en provenance
de ce microphone. Dans certains cas, une vue ‘oscilloscope’ du signal obtenu peut être
pertinent.
 30. Capteurs MEMS MPU6050 (accéléromètre, gyroscope,
magnétomètre)

Le capteur MPU6050 regroupe 3 fonctionnalités :

- Accéléromètre 3 axe
- Gyroscope 3 axes
- Capteur de température

Il communique avec le microcontrôleur via I2C.

pin default description

Vcc A0 3,3V (pilotable…)
GND GND
SCL PB8 | I2C clock
SDA PB9 | I2C Data
Les 4 autres broches ne sont pas utiles dans
les contextes les plus courants.

ATTENTION, il est conseillé de relier la broche

VCC à un GPIO du microcontrôleur. On pourra
ainsi alimenter le capteur directement via ce
GPIO. C’est peu élégant, mais nécessaire pour
pouvoir provoquer un reset au début du
programme.

 Voir le fichier : stm32f1_mpu6050.c.

En soutenance : ce capteur ayant été présenté et utilisé précédemment, attardez-vous sur la

façon dont vous utiliser les données qu’il renvoie.
 31. Détecteur de fumée et capteur d’éthanol

Le détecteur de fumée MQ2 dispose d’une sortie tout ou rien

D0, et d’une sortie analogique A0.
La sortie numérique est activée à l’état bas en présence de
fumée.

Pour vos tests, inutile de provoquer de la fumée ; utilisez

simplement le gaz d’un briquet.

Courant consommé : 150mA à 5V.

Un potentiomètre permet de régler de seuil de sensibilité de

la sortie tout ou rien.

Dans le même genre, ce capteur d’éthanol

MQ-3 est théoriquement sensé mesurer la
présence d’éthanol.
 32. Capteur de pouls

Ce capteur de pouls « low cost » fonctionne sur le principe de la variation de

la lumière réfléchie par le doigt posé sur le capteur.

Il intègre une mise en forme du signal acquis par la photodiode.

Observez bien le pinout qui pourrait dépendre du modèle !

pin description
VCC 3,3V
GND GND
SIGNAL vers une entrée analogique

L’acquisition de ce signal suppose un échantillonnage régulier.

Consultez le chapitre 7 sur le périphérique ADC.

Vous devez ensuite imaginer un algorithme (par exemple sous la forme d’une machine à états) ; afin de
déduire le pouls mesuré à partir du signal.

Il est conseillé :
- D’observer le signal reçu à l’oscilloscope
- Durant le développement, de sortir les valeurs mesurées sur une liaison série, pour en faciliter l’analyse

En soutenance : vous pouvez donner votre ressenti sur le fonctionnement et les limites de ce
capteur. Expliquez l’algorithme que vous avez mis en œuvre pour traiter les données qu’il
renvoie.
 33. Capteur de courant isolé

Il existe plusieurs solutions pour mesurer le courant consommé par une charge.

1- Une « Résistance-shunt »
2- Un capteur de courant isolé (à effet hall)

La solution de la résistance shunt est assez simple, elle consiste à placer une résistance entre le GND et le
GND de la charge. La résistance est dimensionnée pour présenter un bon compromis entre chute de tension
maximale admissible (lorsque le courant max est atteint), et chute de tension minimale mesurable par le
microcontrôleur. Ce compromis est parfois un vrai dilemme. Dans certain cas, il n’y a pas de solution à ce
compromis.

Le capteur de courant isolé assure une mesure ‘active’ du courant consommé par une charge.

Deux exemples sont proposés et disponibles : ACS722LLCTR-05-AB-T ou ACS711KLCTR-12AB-T

Datasheet : https://www.allegromicro.com/~/media/Files/Datasheets/ACS722-Datasheet.ashx

Vcc : alimentation (3,3V)

Viout : tension proportionnelle au courant mesuré
(Pour le modèle ACS722LLCTR-05AB-T : 264mV/A)

Le courant mesuré est celui qui circule entre IP+ et IP-.

 34. Lecteur de code barre

Ce module fabriqué par ScanHome, et

disponible dans une version TTL,
assure la lecture de codes barre 1D et
de QRCode 2D.

Sa configuration s’effectue en lui

montrant des QrCodes spécifiques
imprimés.

Sa sortie UART permet de récupérer

les informations des codes barre visés.

Il est utile de démonter le connecteur

DB9 fournit lorsque l’on souhaite
accéder facilement aux potentiels de la
liaison série.

http://www.scanhome.net/02300054/php/picshow.php?menuid=7&getproductlistid=126099&lang=3

En soutenance : vous pouvez évoquer la méthode de configuration utilisée, ainsi que la nature
des données transmises sur la liaison série.
 35. Lecteur NFC X-NUCLEO-NFC03A1

Le shield NFC X-NUCLEO-NFC03A1 intègre un chip

CR95HF et son antenne, conçus pour dialoguer avec des tags
NFC/RFID à 13,56MHz.

Ce chip est multi-protocoles (cohabitant sur cette bande de

fréquence) :
 ISO/IEC 14443 Type A and B
 ISO/IEC 15693
 ISO IEC18092
 MIFARE® Classic(a)

Ce shield peut se poser sur une carte Nucleo (connecteurs

standard Arduino). Ou bien sur un PCB respectant cet
espacement. L’empreinte de ce composant est disponible
dans la librairie Altium ‘circuits intégrés’.

La brique logicielle /lib/bsp/NFC03A1 est disponible.

Consultez la fonction NFC03A1_demo().

Il est recommandé d’utiliser les mêmes broches que celles

proposées par défaut, afin de minimiser les modifications du
logiciel. Certaines broches sont toutefois configurables.
Il faut relier l’ensemble des broches ci-dessous :

pin défaut alternatives possibles

3V3 3,3V
GND GND
SPI_SCK PA5 ou autre SPI…
SPI_MISO PA6 ou autre SPI…
SPI_MOSI PA7 ou autre SPI…
SPI_CS PB6 ou autre GPIO
Interface_pin PC7 ou autre GPIO
IRQIN PA9 ou autre GPIO

IRQOUT PA10 ou autre GPIO

Sur le DEEP PCB, l’emplacement ‘Shield Arduino’ permet de

relier ce lecteur NFC.

En soutenance : vous pouvez expliquer une utilisation de la librairie fournie, et votre façon de
gérer les tags lus. Dans certains cas, le stockage des tags est également intéressant à évoquer
(permanent, temporaire, modifiable ou non, …)
 36. Emission/Réception infra-rouge TSOP 38238

Avant-propos : ATTENTION, il existe plusieurs références

similaires pour ce type de récepteur, dont les pinouts
varient !
Assurez-vous de savoir quel composant vous avez en main
et vérifiez sur sa datasheet que le pinout correspond.
Le DEEP PCB est compatible avec le modèle TSOP38238.

Le transfert de donnée en infrarouge est utilisé couramment par les

télécommandes.

La chaîne d’acquisition qu’il faut associer à une photodiode pour

interpréter les signaux reçus nécessite de nombreuses étapes : amplification, filtrage, démodulation. Des
composants intégrant l’ensemble de ces étapes existent. Ils sont conçus pour détecter une fréquence donnée
(typiquement 38Khz).

Si votre projet consiste à acquérir les signaux émis par une

télécommande existante, vous devez simplement interpréter les
signaux démodulés par ce TSOP.

Si votre projet inclut à la fois l’émetteur et le récepteur, vous devez

également générer le signal pilotant une LED infrarouge.
Dans ce cas, l’utilisation d’un MOSFET N est appropriée pour le
pilotage de la LED Infrarouge. Il est utile de veiller à piloter ce
MOSFET à partir d’une broche reliée à un timer ! (voir chapitre 1)

Dans cette même situation, une librairie vous est proposée.

Dans lib/bsp/ir, les modules ir_emitter et it_receiver peuvent gérer
l’envoi la transmission de données par IR entre deux microcontrôleurs.

Vous pouvez vous inspirer de ir_receiver si votre projet consiste à

recevoir des informations émises par une télécommande existante.
 37. Digital to Analog Converter (DAC - MCP4921)

Un DAC est un composant capable de produire une ‘tension analogique’ en sortie.

Plus exactement, il dispose d’un certain nombre de tensions possible en sortie. (2N pour un DAC N bits).

Le MCP4921 présenté dans cet exemple, et pour lequel vous disposez

d’une librairie dans /lib/bsp/dac_mcp4921 est un DAC 12 bits.

Datasheet :
http://ww1.microchip.com/downloads/en/devicedoc/21897b.pdf

 Suggestion : appelez la fonction DAC_demo et observez la

broche VOUTA à l’oscilloscope !
 Lisez les commentaires disponibles dans le header dac_mcp4921.h
Ils donnent quelques informations utiles sur les modes de fonctionnement de ce composant.

En soutenance : il est intéressant de montrer un exemple de signal produit en sortie de DAC.

Vous pouvez également montrer un exemple de trame SPI, acquise à l’oscilloscope.
 40. Ampli Audio PAM8403

Cet ampli audio monté sur breakout board peut

piloter en stereo deux haut-parleur jusqu’à 2x 3W.

pin description
output :
-rout haut-parleur droite
+rout haut-parleur droite
+lout haut-parleur gauche
-lout haut-parleur gauche
power :
- GND
+ +5V
input :
D’un point de vue hardware, le composant peut être
L entrée left
représenté par une barrette de 11 points… dont 2 n’existent
G GND
pas (entre les 3 blocs présentés ci-dessus).
R entrée right

L’entrée de cet ampli peut être fourni par :

- Soit une sortie PWM du microcontrôleur (qu’il conviendra de piloter à la fréquence souhaitée et au
rapport cyclique de 50% afin de produire la note voulue)
- Soit une sortie d’un DAC (voir le chapitre sur le DAC MPC4921), pour une plus grande richesse
harmonique (production de sinus / autre forme d’onde…)

Attention à fournir un +5V pouvant fournir un courant suffisant (la consommation de l’ampli dépend du son
à produire et du haut-parleur…)

Les entrées L et R peuvent être reliées si la source est en « mono ».

 41. Clavier matriciel

Un clavier est dit matriciel lorsque les touches sont câblées en lignes
et colonnes de façon à économiser des broches.

Pour un clavier 16 touches, on

compte 4+4 broches. (4*4=16)
Pour un clavier 12 touches, il
faut 4+3 broches (4*3=12)

Chaque appui provoque la liaison entre une ligne et une colonne.

Afin de lire l’état d’un tel clavier, il convient :

- d’attribuer la fonction d’entrées aux lignes, et de Balayage temporel
sorties aux colonnes (ou le contraire !)
Out0
- de choisir un état par défaut (haut ou bas) sur les
entrées en y ajoutant des résistances de tirage. Out1
- de réaliser un balayage temporel sur les sorties : à
chaque instant du balayage, toutes les sorties sont Out2
pilotées à l’état par défaut (récessif) sauf 1 qui est
Out3
dans l’état opposé (dominant). t
- De scruter les entrées pour voir si on reçoit l’état
dominant ; ce qui indiquerait qu’un bouton est appuyé.

Attention, les brochages des claviers sont différents selon les modèles ! Il faut donc identifier les
positions des lignes et des colonnes avec le clavier dont vous disposez !
Pour cela, il faut utiliser un ohmmètre, et procéder ainsi :
- Appuyer sur un bouton, identifier le couple de broches qui sont reliées par ce bouton
- Appuyer ensuite sur le bouton voisin de la même colonne, et identifier le couple de broches
- La broche en commun pour ces deux boutons correspond à leur colonne
- On peut alors identifier les broches des lignes en utilisant cette colonne
- Il reste ensuite à identifier les broches des autres colonnes en utilisant une ligne !
Notez que cette démarche nécessite au minimum 5mn, de la rigueur, un crayon, un papier…

Le pilote logiciel disponible dans

lib/bsp/matrix_keyboard est
configurable pour chaque broche
du microcontrôleur.

En soutenance : expliquez le
principe de fonctionnement du
balayage. Vous pouvez également
expliquer le fonctionnement de la
librairie fournie.
 42. Capteur de présence optique CNY70

Lien vers la datasheet : https://docs.rs-online.com/dc23/0900766b80e2fbf3.pdf

Ce capteur se compose d’une LED infrarouge et

d’un phototransistor.

Attention à la position de chaque broche (voir la

TOP view ci-dessus).

L’empreinte du composant n’est pas directement

disponible sur Altium, mais vous pouvez utiliser
celle d’une barrette femelle 2X2.

Lorsque l’on place un objet réfléchissant la lumière à

proximité du capteur, la lumière de la LED est envoyée
au phototransistor qui entre alors en saturation.

Calcul de la résistance série :

- Si 100 Ohm : Iled = (5 -1,25)/100 = 37 mA
- Si 75 Ohm : Iled = (5 -1,25)/75 = 50 mA

Côté code : débrouillez-vous, la simple lecture de l’état du GPIO suffit !

En soutenance : expliquez le principe de fonctionnement du capteur et de sa mise en œuvre

(Donnez le rôle de chaque résistance !) Dans certains cas, vous pouvez évoquer ses limites de
fonctionnement.
 43. Microrupteur

Pour détecter la position physique d’un objet (actionneur, obstacle, …), rien
de plus simple qu’un microrupteur.

Ces interrupteurs sont parfois dotés d’une lamelle ou d’une roulette.

Certains modèles disposent de 3 broches ; une broche commune est en
contact avec 1 broche au repos, et 1 autre broche à l’état appuyé.

Pour un calage précis, n’hésitez pas à utiliser l’effet d’hystérésis (détection en marche avant, puis fin
de détection en marche arrière).

Sur le DEEP PCB, il est possible d’utiliser les connecteurs JinputX. En remplaçant Rs0 par un fil,
et Rpu0 par une résistance de 10k.

En soutenance : évoquez votre choix de montage (pull-up / pull-down / avec ou sans filtrage).
 44. Servomoteur

Un servomoteur est un ensemble contenant : un moteur + un

réducteur + un capteur de position + l’électronique de pilotage.

Bien qu’on puisse considérer que cet ensemble dispose d’une

« forme d’intelligence » il ne s’agit pas d’un « cerveau-moteur1 ».
L’étymologie du mot ‘servo’ vient de ‘service’. Ce moteur est
‘asservit’, il rend ‘service’ et répond à une consigne.
Images : https://www.servocity.com/how-does-a-servo-work

Cette consigne2 doit lui être présentée sous forme d’une impulsion dont la durée informe le
servomoteur de la position souhaitée. Comme il a la mémoire courte, il faut lui répéter régulièrement
cette impulsion (typiquement toutes les 10 à 20ms).

Durée de Position
l’impulsion demandée
1ms(3) à fond à gauche !
… …entre les deux…
1,5ms …au milieu…
… …entre les deux…
2ms(4) à fond à droite !

Il convient de sous-traiter la fabrication du signal à un périphérique timer, en particulier en

générant un signal PWM.

Référez-vous à la mission sun-tracker, ou au module logiciel : lib/bsp/stm32f1_timer.c/h

Prenez l’habitude de vérifier le signal produit à l’oscilloscope avant de brancher le servomoteur.

GND 5V Signal
PA8 (Timer1 – CH1)
Noir Rouge Jaune
Marron Rouge Orange
Noir Rouge Blanc

Sur le DEEP PCB, 4 connecteurs sont disponibles :

1
ça, c’est vous, là, maintenant !
2
Il existe de nombreux types de servomoteurs, on s’intéresse ici aux petits servomoteurs de modélisme.
3,4 Selon le modèle exact de servomoteur, les butées peuvent être ‘un peu au-delà ces valeurs standards’.
 45. Moteur pas à pas et driver TB6600

Cet article disponible sur Wikipedia explique ce qu’est un moteur pas à pas :
https://fr.wikipedia.org/wiki/Moteur_pas_%C3%A0_pas

Pour faire tourner le rotor, il faut parcourir successivement les états d’une
séquence dans laquelle chaque ‘micro-pas’ (step) correspond à un état des
courants dans les bobines du moteur. Le moteur Nema17 qui sert
d’exemple à ce chapitre dispose de 200 pas par tour.

Le moteur cherche alors à maintenir sa position sur le micro-pas demandé.

Il présente donc un fort couple à vitesse nulle (contrairement à un moteur
à courant continu) !

A contrario, la vitesse maximale d’un moteur pas à pas est faible (de l’ordre d’un tour par seconde,
soit 60 tours par minutes (rpm) contre 10000 rpm pour un moteur DC).

On s’intéresse ici aux moteurs bipolaires, conçus avec deux bobines. Ces bobines peuvent être
pilotées avec 2 ponts en H. La séquence de 8 huitièmes de pas ci-dessous est alors utilisable :

(sources : Wikipedia)

Ce pilotage par pont en H présente l’inconvénient de piloter les bobines en « tension ». Dans l’idéal,
il est préférable d’asservir le courant à la valeur nominale recommandée par le constructeur. On
règle ainsi le couple de maintien du moteur.

Il existe des interfaces de pilotages qui facilitent cela. Notamment le TB6600 :

Ce driver est présenté à la page suivante.
Driver de moteur pas à pas : TB6600.

- Réglage possible du courant asservi !

- Plusieurs modes de fonctionnement : pas simple, demi-pas, quarts-de pas…. Jusqu’au 1/32
pas ! (Obtenu par pourcentage du courant asservi dans chaque bobine).
- Gestion automatique des pas, provoqués par de simples impulsions
- Pilotable en sens et en activation

ATTENTION, les entrées du TB6600 sont constituées d’optocoupleurs ; qui permettent d’isoler
électriquement la partie commande de la partie puissance (le signal tout ou rien est transmis par un
couple « led + phototransistor » à l’intérieur de l’optocoupleur !)
Ces optocoupleurs sont conçus pour fonctionner en +5V. Dans la pratique, ils fonctionnent parfois
également en +3.3V.

Nous recommandons le montage suivant, en choisissant impérativement des broches tolérantes 5V et

configurées en open-drain (GPIO_MODE_OUTPUT_OD).

Les moteurs « NEMA17 » sont conçus pour un courant asservi autour de 1,5A.
https://reprap.org/wiki/NEMA_17_Stepper_motor

Réglez méthodiquement les switchs

selon les modes de fonctionnements
choisis.

Bien respecter les couleurs des fils du

moteur. Le symptôme en cas
d’inversion ; vibration du moteur.

Les signaux à envoyer sont les suivants :

ENA+, DIR+, PUL+ : 5V.
ENA- : 0V pour désactiver le pont. Ce couple de broche peut être laissée en l’air.
DIR- : 0V pour un sens, 5V pour l’autre sens
PUL- : 5V au repos ; impulsion à 0V pendant au moins 10us pour provoquer un mouvement

La fréquence maximale des impulsions dépend du réglage des micro-pas. Si la vitesse demandée est
trop rapide, le moteur ‘décroche’ et saute des pas ! Si le couple à fournir est important, une rampe
d’accélération peut s’avérer nécessaire ! (Facile à dire, un peu plus difficile à coder).

Conseil : commencez avec une vitesse d’un pas toutes les 100ms, avec un réglage en 8 micro-pas.
Si vous voulez ensuite un nombre de micro-pas importants (meilleure fluidité du moteur), n’hésitez
pas à configurer en 32ème de pas ! Cela nécessite bien sûr des impulsions plus fréquentes pour une
même vitesse du moteur.

En soutenance : évoquez le mode de micro-pas choisi, expliquez le fonctionnement des librairies

utilisées.
 46. Moteur à courant continu et pont en H

Quel qu’il soit, le pilotage d’un moteur à courant continu nécessite une interface de puissance, car le
microcontrôleur ne peut pas fournir la puissance électrique nécessaire.

Dans les cas les plus simples, lorsque l’on souhaite par exemple piloter le moteur dans un seul sens
et en tout ou rien, un simple transistor est utilisable.
Si l’on souhaite disposer de plusieurs vitesses, un seul transistor est encore une solution envisageable.
Mais pour les applications où l’on souhaite faire fonctionner le moteur dans plusieurs sens, et à
vitesse réglables, il est indispensable d’avoir recourt à un pont en H.

Ce qu’il faut savoir sur le moteur à courant continu.

Dans une situation normale, ces moteurs se comportent ‘environ’ ainsi :
- Vitesse proportionnelle à la tension imposée aux bornes du moteur
- Courant consommé proportionnel au couple mécanique fourni par le moteur
- Ainsi, les puissances consommée et fournie par le moteur est :
o Puissance électrique : courant*tension
o Puissance mécanique : couple*vitesse
- Le rendement d’un moteur électrique est généralement autour de 80% (+/-20%.. ^^ !)
Dans une situation anormale, tout ce qui est écrit au-dessus est faux :
- Exemple 1 ; moteur maintenu mécaniquement bloqué malgré une tension à ses bornes
(vitesse nulle, tension non nulle)
- Exemple 2 ; moteur totalement libre, aucun couple fourni, courant non nul (frottements)

Principe de fonctionnement du pont en H.

En électronique, on aime la commutation. Car, dans les deux états du transistor en commutation
(bloqué ou saturé), la puissance consommée par le transistor est faible :
- Bloqué : P=U*I = U*0 = 0
- Saturé : P=U*I = 0*I = 0 (on néglige ici les pertes : Rdson*I²= pas beaucoup)
Pour obtenir une tension moyenne variable, et faire ainsi varier la vitesse d’un moteur, on
« découpe » le temps en alternant très vite ces deux états. La variation du pourcentage du temps où
le moteur est alimenté résulte en une vitesse variable.

Un pont en H est constitué de 4 transistors.

Ce montage a la particularité de permettre d’alimenter le
moteur dans les deux sens !
- Si les switchs 1 et 4 sont fermés, il tourne dans un sens.
- Si les switchs 2 et 3 sont fermés, il tourne dans l’autre.
- Si les switchs 3 et 4 (ou 1 et 2 !) sont fermés, le moteur est
court-circuité, ce qui correspond à un freinage forcé.
- Si tous les switchs sont ouverts, le moteur est en roue libre.

Le chapitre 47 présente plusieurs modèles de ponts en H et leurs mises en œuvre.

 47. Ponts en H, quelques modèles (BD6221…)

Quelques modèles de ponts en H.

Le dimensionnement d’un pont en H dépend essentiellement du courant maximal à fournir au
moteur, et de la tension maximale.

BD6221 : modèle suggéré pour des moteurs entre 6V et 18V ; <1A

(attention, ce pont ne peut pas être alimenté <6V, donc pas avec un +5V !)
http://rohmfs.rohm.com/en/products/databook/datasheet/ic/motor/dc/bd622x-e.pdf

Le signal PWM est envoyé soit sur FIN (Forward In), soit sur RIN (Reverse In). L’autre broche
(respectivement RIN et FIN) est alors maintenue à l’état bas (Low).

Le DEEP PCB fournis deux empreintes de

BD6221.

TB6612FNG : double pont sur breakout board

https://www.mouser.fr/datasheet/2/408/TB6612FNG_datasheet_en_20141001-708260.pdf
On envoie le signal PWM sur l’entrée du même nom.
Les broches IN1 et IN2 indiquent le sens souhaité
(l’une de ces broches doit recevoir un 1 tandis que l’autre reçoit 0).

La broche STBY doit être maintenue à l’état Haut.

LMD18200T : modèle proposé pour des moteurs <42V ; <3A

http://www.ti.com/general/docs/suppproductinfo.tsp?distId=26&gotoUrl=http%3A%2F%2Fwww.ti.com%2Flit%2Fgpn%2Flmd18200
Attention à respecter le montage fourni en page 7 de la datasheet (sans oublier les condensateurs de
bootstrap de 10nF ; la résistance de 2,7k est facultative).
La broche PWM reçoit le signal PWM. La broche DIR permet de choisir le sens. Le moteur est
branché entre SINK et SOURCE.
 48. Châssis à motoréducteurs

Nous disposons de plusieurs plateformes motorisées qui peuvent notamment servir à réaliser de petits robots.

Ces plateformes sont équipées de moto-réducteurs à courant continu. (généralement pour une tension nominale
de l’ordre de 7,5V).

En effet, un moteur à courant continu présente un couple assez faible et une vitesse élevée (de l’ordre de 5000
tours par minutes). Il est donc d’usage d’associer à ces moteurs un réducteur à engrenage qui diminue la
vitesse et augmente le couple. On obtient alors une vitesse de la roue (à la tension nominale du moteur) de
l’ordre d’1 tour par seconde.

Selon les stocks, nous disposons de plusieurs modèles de châssis : 4 roues motrices, 2 chenilles…

Vous devez parfois exercez vos talents de mécaniciens,

les châssis étant livrés non montés. Soyez précis, et ne
forcez pas trop sur l’axe moteur en y insérant les
roues, ces axes sont fragiles.

Selon les modèles, attention à bien isoler votre PCB

des parties métalliques du châssis !

Pour piloter ces moteurs, on peut utiliser des ponts en

H (1 par moteur).

(Voir le chapitre concernant les ponts en H

dans ce document !)

Il est possible (peu recommandé) de relier ensemble

deux moteurs… : il ne sera bien sûr pas possible
d’avoir des sens et vitesse différents sur ces moteurs.

Fréquence de PWM recommandée : 20kHz, on évite ainsi de produire des sifflements audibles.

La consommation de ces moteurs est de l’ordre de quelques centaines de mA (autour de 500mA en blocage).
Pour chaque moteur, un pont en H dimensionné pour 1A est recommandé. Le BD6221, suggéré dans le schéma
fourni, fonctionne correctement avec ces moteurs.
 49. Ventilateur

Un ventilateur (pour PC par exemple) est un moteur à

courant continu, sans balai.

2 broches suffisent pour le piloter :

- rouge : +12V
- noir : GND
Mais il dispose parfois :
- d’un fil de pilotage… voir selon le modèle
- d’un fil de mesure de vitesse… voir selon le modèle

Il n’est soit évidemment pas possible de l’alimenter

directement à partir d’une broche du microcontrôleur.

Son pilotage en « tout ou rien » reste toutefois très simple

avec un MOSFET N. (schéma ci-contre).

Ce type de ventilateur intègre une électronique de pilotage

qui assure la commutation du courant dans les différentes
bobines qui le constituent.

Pour ces raisons, il n’est absolument pas envisageable

d’alimenter le ventilateur « à l’envers ».

Pour ces mêmes raisons, il n’est pas ‘nominalement acceptable’ de piloter ce ventilateur à partir d’un signal
PWM... mais cela fonctionne.

Il est alors recommandé

- de rester dans la plage +5V<->+12V (en utilisant un rapport cyclique approprié)
- d’utiliser une fréquence assez élevée (typiquement 20kHz)
- de placer un condensateur qui lisse l’alimentation. Ce filtrage capacitif doit permettre de maintenir
une ondulation négligeable de la tension d’alimentation.
 50. Gâche électrique, électrovannes et électroaimants

La gâche électrique d'une porte est constituée d’un électroaimant qui

tire le loquet de la serrure lorsqu'il est alimenté, libérant ainsi la
porte.

D’un point de vue électrique, un électroaimant est assimilable à une

inductance en série avec une faible résistance. (Ce n’est qu’un fil de
cuivre bobiné !)
Le champ magnétique produit lorsque cette bobine est alimentée
produit une force qui peut agir sur un loquet ou tout élément
magnétique.

Attention à la puissance dissipée ! Sur de nombreux modèles, il ne

faut pas alimenter la gâche ou l’électroaimant en permanence !
Une mesure de la résistance équivalente permet de calculer cette
puissance dissipée.

Si R = 30Ω et U = 12V
 I = U / R = 0,4 A
 P = U2/R = 4,8W !

Le pilotage d’une telle gâche ne peut pas se faire directement par une
broche du microcontrôleur. Un pilotage via NMOS est approprié.

N’oubliez pas d’insérer une diode de roue libre aux bornes de la gâche
pour éviter qu’une surtension ne soit créé par la bobine lors de
l’ouverture du MOSFET. (La bobine s’opposant au changement
instantané du courant, elle crée une tension qui peut s’avérer
destructrice, la diode assure la continuité du courant, jusqu’à
dissipation de l’énergie emmagasinée dans l’inductance).

Un condensateur réservoir (1000µF ?) peut être recommandé afin de

fournir localement l’appel de courant nécessaire lors de la fermeture
du MOSFET.

La même technologie est utilisée dans les électrovannes, utilisées pour contrôler en
tout ou rien l’écoulement d’un liquide ou d’un gaz.

En soutenance : évoquer les grandeurs

électriques en jeu (courant, tension,
puissance).
Chapitres qui pourraient être rédigés ultérieurement…

51. Phototransistor
52. Haut-parleur
53. Ampli audio MAX98357
54. Pixycam
55. …