vendredi 25 avril 2014

Étude de CI: Registre à décalage 74HC165

Après avoir exploré le fonctionnement du registre à décalage 74HC595 qui permet, entre autres choses, d'ajouter des sorties numériques supplémentaires à votre Arduino, nous étudions aujourd'hui son complément, le 74HC165 qui vous permettra, en cas de besoin, d'ajouter des entrées numériques supplémentaires à votre Arduino (vous pouvez, par exemple, brancher à l'Arduino un nombre quasi illimité d'interrupteurs).

Car alors que le 74HC595 est doté d'une entrée série et de 8 sorties parallèles, c'est exactement le contraire pour le 74HC165:  il comporte 8 entrées parallèles et une sortie série.

Sur le schéma de brochage ci-contre, les 8 entrées sont identifiées par les symboles D0, D1, D2, etc.  Chaque entrée pourrait, par exemple, être reliée à un interrupteur permettant de sélectionner le niveau logique bas (0 V) ou haut (5 V).

Q7 (pin 9) est la sortie, et la pin 7 (Q7 avec une barre au-dessus) est une sortie complémentaire dont l'état est toujours contraire à Q7.

La pin 10 (DS) est une entrée série, qui sera utile lorsque vous désirez relier plusieurs HC165 en cascade (elle sera alors reliée à la sortie Q7 du HC165 précédent).

Lorsque la pin 1 PL (pour parallel load) est au niveau logique bas (0 V), l'état des 8 entrées parallèle (D0 à D7) est mémorisée par le HC165.  La sortie Q7 prend alors le même état logique que l'entrée D7.   Lorsque la pin 1 "PL" est au niveau logique haut (5 V), l'entrée série DS est activée.

Chaque fois que la pin 2 "CP" (horloge) passe de 0 à 5 V, les états logiques sont décalées d'une position dans le registre (DS vers D0, D0 vers D1, etc., et Q7 prend la nouvelle valeur de D7.

Si cette description rapide vous apparaît quelque peu nébuleuse, je vous invite à construire sur breadboard un petit circuit d'expérimentation avec le HC165.  On pourrait toujours utiliser 8 interrupteurs pour contrôler l'état de nos 8 entrées, mais pour plus de simplicité, on peut se contenter de les relier manuellement au potentiel approprié au moyen de câbles conducteurs.  Une exception, toutefois:  le signal d'horloge (pin 2) doit être contrôlé par un interrupteur sans rebond, question d'éviter...les rebonds (voir cet article sur la façon de construire des interrupteurs sans rebond).  Si vous utilisez un interrupteur qui n'est pas doté d'un mécanisme anti-rebond, vous risquez d'envoyer 2 ou 3 signaux d'horloge consécutifs lorsque vous désirez en produire un seul.

Réalisons donc notre circuit d'expérimentation:  nous alimentons le CI en branchant la pin 8 à la masse (GND) et la pin 16 à 5 V (si vous ne disposez pas d'une source d'alimentation continue de 5 V, vous pouvez utiliser la sortie 5 V d'un Arduino, ou mettre 3 piles AA en série).  La pin 15 (clock enable) doit être activée en la reliant à la masse (GND).

Pour connaître l'état logique de la sortie Q7, nous utiliserons  une LED protégée par une résistance d'au moins 330 Ω (vous pouvez aussi mesurer le signal de sortie au moyen d'un voltmètre, si vous préférez).

Initialement, la pin 1 (PL) est à 5 V, et la pin 2 (CP), reliée à un interrupteur sans rebond, est à 0 V (l'anti-rebond de l'interrupteur n'est pas représenté sur le circuit illustré ci-dessous).

Maintenant, ajustons le niveau logique des entrées, en essayant d'utiliser un motif que nous pourrons ensuite reconnaître.  Allons-y pour:
DS (pin 10) à 5 V
D0 (pin 11) à 0 V
D1 (pin 12) à 5 V
D2 (pin 13) à 0 V
D3 (pin 14) à 5 V
D4 (pin 3) à 5 V
D5 (pin 4) à 0 V
D6 (pin 5) à 0 V
D7 (pin 6) à 5 V

Ça devrait ressembler à ceci (le dessin ne montre pas la source de tension de 5 V):



Le registre comporte 8 mémoires, chacune d'entre elles pouvant être au niveau logique haut ou bas. Commençons par transférer en mémoire l'état des pins D0 à D7:  pour ce faire, vous mettez temporairement la pin 1 à 0 V, puis vous la remettez à 5 V (au moyen du fil jaune sur le circuit ci-dessus).

Le tableau ci-dessous montre l'état de chacune des mémoires du registre:



Vous devriez constater que la LED s'est allumée:  la sortie Q7 prend toujours le même état logique que la mémoire associée à D7, qui est dans l'état logique haut.

Envoyons maintenant un front ascendant sur le signal d'horloge:  on appuie une seule fois sur le bouton sans rebond de façons à faire passer temporairement la pin 2 de 0 V à 5 V.  Ce signal d'horloge cause un décalage des valeurs placées en mémoire (c'est pour cette raison que ça s'appelle un registre à décalage):  la mémoire D7 prend la valeur qui était précédemment dans D6, D6 prend la valeur qui était précédemment dans D5, et ainsi de suite jusqu'à D0, qui mémorise le niveau logique de l'entrée DS (pin 10).

Le tableau ci-dessous montre le nouveau contenu des mémoires:


Puisque le niveau de la mémoire D7 est maintenant bas, la sortie Q7 s'est mise à 0 V et la LED est maintenant éteinte.

On appuie à nouveau sur le bouton relié à la pin 2, et les valeurs sont à nouveau décalées d'une position:


La LED demeure éteinte, puisque la mémoire D7 est encore au niveau bas.

Pour varier un peu, on peut mettre l'entrée DS (pin 10) à 0 V avant d'appuyer à nouveau sur le bouton de la pin 2:




Chaque fois que vous appuyez sur le bouton, c'est maintenant la valeur 0 (de l'entrée DS) qui s'installera dans la mémoire D0.

Et vous pouvez continuer d'appuyer sur le bouton de la pin 2 pour constater que la LED s'allume ou s'éteint selon les valeurs mises en mémoire.

Supposons maintenant qu'on décide de changer l'état logique des entrées:  plaçons les toutes à 5 V, sauf DS qu'on laisse à 0 V.



Pour que ces changements aient un impact sur l'état des mémoires, il faut impérativement mettre temporairement la pin 1 à 0 V.


À vous d'expérimenter avec le circuit jusqu'à ce que vous ayez compris le fonctionnement du CI à votre entière satisfaction.  La LED devrait être allumée les 7 premières fois que vous appuyez sur le bouton, puis demeurer éteinte ensuite.

Maintenant, que nous comprenons bien son fonctionnement, tentons une application pratique:  relions le 74HC165 à un Arduino, afin que ce dernier puisse lire l'état des 8 entrées du HC165.

Le circuit:  Le HC165 est alimenté par la sortie 5 V de l'Arduino, on n'a plus besoin de la LED, ni de l'interrupteur sans rebond.  La pin 2 du HC165 est commandée par la pin 2 de l'Arduino, et la pin 1 du HC165 est contrôlée par la pin 3 de l'Arduino.  La pin 9 du HC165 (sortie) est reliée à la pin 4 de l'Arduino. Vous branchez les 8 entrées du HC165 comme vous voulez:  certaines d'entre elles à 5 V, d'autres à 0 V.


Et voici un sketch qui affiche l'état de chaque entrée du 74HC165 dans le moniteur série du logiciel Arduino:


Yves Pelletier (Twitter:  @ElectroAmateur)


lundi 21 avril 2014

Robot éviteur d'obstacles version 2.0


Il y a quelques mois, j'avais construit un robot éviteur d'obstacles muni d'un capteur à ultrasons HC-SR04.  Mais ce robot avait une vision périphérique très limitée: il ne détectait que les obstacles situés directement devant lui, et ses roues s'accrochaient régulièrement dans des obstacles qui n'avaient pas été détectés.

Cette nouvelle version du robot est munie de 3 capteurs à ultrasons HC-SR04 situés côte à côte à l'avant du robot.  Les deux capteurs situés sur les côtés sont légèrement inclinés vers l'extérieur, ce qui élargit encore un peu plus le champ de vision du robot.

En plus du champ de vision amélioré, l'ajout des deux capteurs supplémentaires permet de faire tourner le robot du bon côté:  si un obstacle est détecté en avant à droite, mais pas à gauche, on fera tourner le robot vers la gauche, et vice-versa si  un obstacle est détecté à gauche mais pas à droite.

Matériel 

C'est le même matériel que la dernière fois, mais avec deux capteurs HC-SR04 supplémentaires:  un châssis pour robot à deux roues motrices (chaque roue étant directement reliée à un motoréducteur), un Arduino Uno (en fait c'est un Duemilanove, mais peu importe), un contrôleur de moteur L293D, 3 sondes ultrasonores HC-SR04, 6 piles AA rechargeables NiMh pour alimenter les moteurs, et une pile de 9 V pour alimenter l'Arduino.


Circuit

Là encore, je n'ai rien changé aux branchements du robot initial, ce qui explique au moins partiellement l'utilisation quelque peu désordonnée des différentes pins de l'Arduino.

Le schéma ci-dessous indique les branchements du L293D à l'Arduino, aux deux moteurs et à son alimentation.  Ne pas oublier de relier ensemble toutes les masses:  le GND de l'Arduino, les 4 pins GND du L293D et la pin GND de chaque capteur HC-SR04 sont toutes reliées ensemble.


Chaque capteur ultrasonore est muni de 4 pins:  la pin Vcc est reliée à la sortie 5 V de l'Arduino (ou à la pin 16 du L293D) et, comme je l'ai indiqué plus haut, la pin GND qui doit être reliée aux GND de l'Arduino.

Il nous reste à brancher les pins qui permettent l'échange d'information entre chaque capteur ultrasonore et l'Arduino.  Puisque les pins disponibles sur l'Arduino devenaient rares, j'ai décidé d'utiliser les pins A0, A1, A2 et A3 comme des entrées/sorties numériques plutôt que comme des entrées analogiques.  C'est permis! Pour ce faire, il s'agit d'utiliser dans le sketch les fonctions digitalRead ou digitalWrite.

Capteur A (à droite)      
        Pin Trig à Arduino 12
        Pin Echo à Arduino 11

Capteur B (au centre)    
        Pin Trig à Arduino A0
        Pin Echo à Arduino A1
    
Capteur C (à gauche)
        Pin Trig à Arduino A2
        Pin Echo à Arduino A3
     
Le sketch:



Comportement du robot:  


Le robot tourne à gauche s'il perçoit la présence d'un obstacle en avant à droite, et il tourne à droite s'il perçoit la présente d'un obstacle en avant à gauche.  Si l'obstacle est droit devant, il tourne à droite.  Il n'est doté d'aucune mémoire, ce qui peut le rendre assez hésitant lorsqu'il arrive face à un coin de mur, mais le sketch induit juste assez d'asymétrie pour éviter que le robot se prenne dans une boucle sans fin.  Il finit généralement par trouver une voie de sortie, même si ce n'est pas toujours de la façon la plus élégante et efficace!

Yves Pelletier (Twitter:  @ElectroAmateur)

dimanche 6 avril 2014

Étude de CI: registre à décalage HC595

J'inaugure aujourd'hui une nouvelle série d'articles qui consistera à explorer le fonctionnement d'un circuit intégré.  Pour cette première livraison, j'ai choisi le registre à décalage HC595, dont voici la fiche technique.

Ce circuit intégré est largement utilisé pour augmenter le nombre de sorties d'un microcontrôleur. Votre Arduino ne comporte pas suffisamment de sorties pour une application précise?  Vous y ajoutez un ou plusieurs registres à décalage et le problème est réglé!

Le registre à décalage HC595 comporte 16 pins.  8 d'entre elles (QA, QB, etc) sont des sorties qui peuvent prendre une valeur logique haute ou basse. L'état de ces 8 sorties dépendra des informations envoyées à l'entrée du signal série (pin numéro 14) ainsi qu'aux entrées d'horloge (pins numéros 11 et 12).

Chaque sortie du registre à décalage est associée à une mémoire qui peu prendre la valeur logique 0 et 1.

Chaque fois que la pin 11 passe du niveau logique 0 au niveau logique 1 (donc de 0 V à 5 V), le contenu de chaque mémoire est décalé d'une position:  la mémoire associée à la pin 7 prend le contenu de la mémoire associée à la pin 6, la mémoire associée à la pin 6 prend le contenu de la mémoire associée à la pin 5, etc.   Et la mémoire associée à la pin 15?  Elle prend la valeur qui correspond à l'état de la pin 14:  0 si la pin 14 est à 0 V, 1 si la pin 14 est à 5 V.


Mais jusque là, seul l'état des mémoires associées aux sorties à changé:  l'état des sorties elles-mêmes ne changera que lorsque la pin 12 passera du niveau logique 0 au niveau logique 1:  à ce moment, chaque sortie prendra l'état logique correspondant au contenu de la mémoire qui lui est associée.

Vous me suivez?  ... Hum...la meilleure façon, c'est d'essayer vous-mêmes!

Pour bien comprendre le comportement d'un registre à décalage, je vous invite à construire sur un breadboard un petit circuit d'expérimentation qui consistera en un HC595 (évidemment), une alimentation continue de 5 V, 8 LEDs qui indiqueront l'état des sorties, et 3 interrupteurs sans rebond pour contrôler l'état des 3 principales entrées (je vous réfère à cet article pour la construction d'un module de 6 interrupteurs sans rebonds).  Si vous ne disposez pas du matériel nécessaire (ou si vous n'aimez pas construire des circuits électroniques, auquel cas je ne sais pas ce que vous êtes venus faire ici!), vous pouvez toujours vous rabattre sur ce simulateur en ligne, mais c'est moins amusant.

En ce qui concerne l'alimentation, le HC595 tolère n'importe quelle source de tension continue située entre 2 et 6 V:  j'utiliserai 5 V pour cette expérience (vous n'avez pas de source de tension de 5 V?  Vous pouvez utiliser la sortie 5 V d'un Arduino, ou encore 3 piles AA placées en série).

Mais attention:  d'après la fiche technique,  l'intensité de courant traversant le circuit intégré. ne doit pas dépasser 70 mA:  il faut donc prendre soin d'accompagner chaque LED d'une résistance de protection suffisante pour que le courant à travers celle-ci ne dépasse pas un huitième de 70 mA, soit 8,75 mA. Puisque la chute de potentiel aux bornes d'une LED rouge avoisine 2 V, il y aura 3 V aux bornes de la résistance. Selon la loi d'Ohm, nous avons donc besoin d'une résistance égale à (3 V)/(0,00875 A), soit 343 Ω. Alors on choisit la résistance conventionnelle la plus proche, soit 390 Ω.

Voici donc notre montage.  L'alimentation de 5 V est branchée aux pins 16 (+) et 8 (-). Chacune des sorties (pins 15, 1, 2, 3, 4, 5, 6, 7) est reliée à une LED en série avec une résistance de 390 Ω. Chacune des entrées (pins 11, 12 et 14) est reliée à un interrupteur de façon à ce que l'entrée prenne une valeur logique haute lorsqu'on appuie sur le bouton.  Le schéma ne comporte aucun anti-rebond pour les interrupteurs, mais au minimum l'interrupteur relié à la pin 11 devrait être sans rebonds, sinon vous risquez d'obtenir des résultats assez imprévisibles.  La pin 13 (output enable) est reliée à la masse en permanence, et c'est le contraire pour la pin 10  (reset), qu'on désactive en la maintenant à 5 V.



Prêts à expérimenter?  Au départ, lorsque vous alimentez le circuit, il est possible que certaines des LEDs soient déjà allumées.  Si c'est le cas, initialisez votre circuit par une des deux méthodes suivantes:

1) Branchez temporairement la pin 10 à la masse (0 V) avant de la brancher à nouveau à 5 V
ou
2) Appuyez 8 fois sur le bouton qui est relié à la pin 11, et ensuite appuyez une fois sur le bouton qui est relié à la pin 12.

Si tout va bien, vos 8 LEDs sont maintenant éteintes, ce qui indique que chacune des 8 sorties est au niveau logique bas (0 V).


Maintenant, appuyez sur le bouton qui est relié à la pin 14 pour envoyer un signal logique haut.  Tout en le maintenant enfoncé, appuyez brièvement sur le bouton qui est relié à la pin 11:  Aucune LED ne s'allume, mais l'état des mémoires à changé: la mémoire associée à la pin 15 est maintenant haute (car la pin 14 était dans cet état lorsque la pin 11 est passée de bas à haut), et le contenu de chaque mémoire est décalé d'une position.


Pour que ces modifications deviennent visibles, il s'agit d'appuyer brièvement sur le bouton qui est relié à la pin 12:  chaque sortie prend alors la valeur stockée dans sa mémoire (et la LED reliée à la pin 15 s'allume).


Envoyons un deuxième signal logique haut.  Encore une fois, vous appuyez sur le bouton qui est relié à la pin 14 et, tout en le maintenant enfoncé, vous appuyez sur le bouton qui est relié à la pin 11.   Toutes les valeurs étant décalées d'une position, l'état des mémoires est maintenant le suivant:


Et l'état des mémoires est transféré aux sorties lorsque vous appuyez sur le bouton de la pin 12:


Pour envoyer un signal logique bas, vous appuyez sur le bouton de la pin 11 sans appuyer sur le bouton de la pin 14.  La mémoire de la pin 15 prendra donc une valeur basse, et toutes les autres valeurs sont décalées d'une position:


Et vous appuyez encore une fois sur le bouton de la pin 12 pour que les sorties soient modifiées en conséquence.

Entrée d'une nouvelle valeur logique haute (on enfonce le bouton de la pin 11 pendant que le bouton de la pin 15 est déjà enfoncé):


On appuie sur le bouton de la pin 12:


Entrée d'une nouvelle valeur basse (bouton de la pin 11 seulement):


On appuie sur le bouton de la pin 12:


Dans la plupart des applications, on commence par régler une par une l'état des mémoires, et leur transfert vers les sorties n'est effectué qu'à la fin, lorsque toutes les mémoires ont la valeur désirée.

Ainsi, pour allumer toutes les LEDs en même temps, vous envoyez 8 messages hauts consécutifs (vous appuyez 8 fois de suite sur le bouton de la pin 11 tout en maintenant le bouton de la pin 15 enfoncé), et vous n'appuyez sur le bouton 12 qu'à la toute fin.

Pour terminer, voyons comment nous pouvons contrôler un registre à décalage au moyen d'un Arduino.  Nous n'avons plus besoin des 3 interrupteurs, ni de la source d'alimentation externe qui sera remplacée par la sortie 5 V de l'Arduino.  La pin 2 de l'Arduino est reliée à la pin 15 du 595, la pin 3 de l'Arduino est reliée à la pin 12 du 595, et la pin 4 de l'Arduino est reliée à la pin 11 du 595 (n'oubliez pas de relier toutes les masses:  GND de l'Arduino avec la pin 8 du 595).



Le sketch ci-dessous allume les 4 LEDs impaires pendant 1 seconde, puis les 4 LEDs paires.  Comme nous le verrons ensuite, ce n'est pas nécessairement la façon la plus simple de procéder, mais vous pouvez constater que l'Arduino gère les pins 11, 12 et 15 du 595 de la même façon que vous le faisiez avec les interrupteurs.

---
---

Mieux encore:  il existe une fonction conçue spécialement pour contrôler un registre à décalage:  la fonction ShiftOut.  Comme vous pouvez le constater dans le sketch ci-dessous (qui accomplit exactement la même action que le sketch précédent), il s'agit de passer à la fonction shiftOut un nombre binaire de 8 bits indiquant l'état désiré de chacune des 8 sorties du registre à décalage, la fonction s'occupe automatiquement de la gestion des pins 11 et 15 du 595 (il ne nous reste plus qu'à gérer la pin 12).

---
---

Et la pin 9 du 595, elle sert à quoi?  Il s'agit d'une sortie qui permet d'ajouter un deuxième registre à décalage (on branche la pin 9 du premier registre à la pin 15 du second).  Lorsque la pin 11 passe de 0 V à 5 V, la valeur qui était stockée dans la mémoire associée à la pin 7 est transférée à la pin 9 (vous pouvez vous en convaincre en ajoutant une neuvième LED reliée à cette pin).  En pratique, ça nous permet d'ajouter un deuxième registre à décalage:  il s'agit de relier la pin 9 du 1er registre à la pin 15 du deuxième, et vos 3 interrupteurs contrôlent maintenant l'état de 16 sorties!  (Et rien ne vous empêche d'ajouter un 3e registre relié au 2e, puis un quatrième relié au 3e, etc.).

Yves Pelletier (Twitter:  @ElectroAmateur)

samedi 5 avril 2014

Exploration de la carte STM32 Nucleo

Aujourd'hui, je vous parle de mes premières expérimentations avec la carte de prototypage STM32 Nucleo, mise sur le marché en février dernier par ST Microelectronics.  J'ai fait l'essai du plus modeste des 4 modèles présentement disponibles, soit le Nucleo-F030R8 (mémoire flash de 64K, alors que c'est 512K pour le F401RE).

Basé sur un microcontrôleur ARM Cortex 32 bits STM32, cette carte est dotée  de connecteurs femelles qui respectent la norme Arduino UNO:  on peut donc brancher au Nucléo un shield qui a été conçu pour l'Arduino, et programmer le Nucleo en utilisant la numérotation de pins Arduino (D0 à D13 et A0 à A5). La carte est également munie de connecteurs mâles (appelés Morpho, une norme propre à ST):  et là, c'est du sérieux, puisqu'on a accès à chacune des 64 pins du microcontrôleurs.


Autre aspect intéressant:  son prix:  une dizaine d'euros environ.  De toute évidence, ST utilise une stratégie similaire à celle utilisée par Texas avec ses cartes Launchpad.  Je suppose que leur but n'est pas de faire des profits sur les cartes elles-mêmes, mais plutôt de promouvoir l'utilisation de le leurs microcontrôleurs.

Petite anecdote:  selon la paperasse qui accompagnait mon colis (expédié au Québec depuis les États-Unis), ma carte Nucleo a été assemblée en France.



La carte arrive avec un programme d'exemple qui s'exécutera aussitôt que vous la brancherez au port USB d'un ordinateur:  une LED clignote, et la fréquence du clignotement change lorsque vous appuyez sur le bouton bleu.  Bon, rien de bien spectaculaire.

Pour programmer la carte, vous pouvez toujours installer un gros logiciel spécialisé sur le disque dur de votre ordinateur, mais ce n'est pas nécessaire puisque Nucleo est compatible avec mbed, un compilateur en ligne auquel vous accédez au moyen de n'importe quel fureteur web (c'est particulièrement pratique si vous avez l'habitude de programmer sur plusieurs ordinateurs différents).  Après avoir choisi un nom d'utilisateur et un mot de passe, vous pouvez cliquer sur le bouton "Compiler" pour accéder au compilateur.



Une fois dans le compilateur, le bouton "Import" vous donne accès à des centaines d'exemples (un peu comme si vous étiez dans github).  Il y a de la redondance, toutefois:  les trois premiers programmes que j'ai ouverts faisaient tous exactement la même chose, c'est à dire faire clignoter la LED intégrée à la carte.

Lorsque vous avez rédigé votre programme, vous cliquez sur le bouton "Compile", qui permet d'enregistrer sur l'ordinateur un fichier exécutable .bin qu'on upload ensuite dans le microcontrôleur en copiant le fichier dans la carte, comme si cette dernière était une clé USB.



Je vous présente ci-dessous trois petits programmes que j'ai conçus en me basant sur ceux qui étaient fournis.

Comme le veut la tradition, commençons par faire clignoter quelques LEDs:   trois LEDs sont branchées aux pins D2, D3 et D4 (qui occupent la même position que les pins 2, 3 et 4 de l'Arduino), avec leur résistance de protection bien entendu (150 Ω ou un peu plus, puisque la tension de sortie du Nucleo est de 3,3 V). Les 3 LEDs s'allument en alternance.


---

---

Comme vous pouvez le constater, ce n'est pas la même syntaxe qu'un sketch Arduino, mais ce n'est pas plus compliqué.

Maintenant qu'on sait allumer une LED, essayons de lire l'état d'un bouton.  La plupart des exemples disponibles allument la LED de la carte au moyen du bouton de la carte, pour changer en voici un qui permet d'allumer une LED (branchée à D3) en appuyant sur un bouton externe (branché à D2):


---

---

Pour terminer, tentons de lire un signal analogique.  Trois LEDs branchées à D2, D3 et D4 s'allumeront en fonction du signal envoyé en A0 par un potentiomètre:  plus le signal analogique est élevé, plus le nombre de LEDs allumées est grand.


---

---

Premières impressions:  pas chère, performante (si je me fie aux spécifications du fabricant), et plutôt facile à utiliser.

La carte Nucleo F030R8 utilisée pour la rédaction de cet article a été fournie gratuitement par ST Microelectronics.

Lire aussi:  STM32 Nucleo et afficheur LCD


Yves Pelletier (Twitter:  @ElectroAmateur)
Related Posts Plugin for WordPress, Blogger...