Pinguino et afficheur LCD

Voici quelques petites recommandations pour l'utilisation d'un afficheur LCD de type Hitachi HD44780 (2 lignes de 16 caractères chacune) avec un Pinguino.


Connexions de l'afficheur au Pinguino


J'ai utilisé le mode 4 bits, question d'économiser quelques pins sur le Pinguino, ça peut toujours être utile pour brancher autre chose.

Tel qu'illustré ci-dessus, les branchements sont:
LCD GND - Pinguino GND
LCD Vcc - Pinguino 5 V
LCD V0 - Curseur d'un potentiomètre allant de 0 à 5 V (ajustement du contraste)
LCD Rs - Pinguino pin 0
LCD R/W - Pinguino GND
LCD E - Pinguino pin 1
LCD D0 - pas branché
LCD D1 - pas branché
LCD D2 - pas branché
LCD D3 - pas branché
LCD D4 - Pinguino pin 2
LCD D5 - Pinguino pin 3
LCD D6 - Pinguino pin 4
LCD D7 - Pinguino pin 5

Pour connaître la numérotation des entrées/sorties de votre modèle de Pinguino, référez-vous au site pinguino.cc (pour cette expérience, j'ai utilisé un Pinguino 4550).

Côté logiciel, un sketch destiné à l'Arduino ne nécessitera que quelques rares modifications pour fonctionner correctement avec le Pinguino.  La principale différence, à mon avis, c'est qu'avec Pinguino la fonction lcd.print ne fonctionne que pour afficher des strings, alors qu'avec Arduino on peut tout aussi bien lui passer un nombre en argument.  Il existe pour Pinguino la fonction lcd.printNumber, mais d'après ce que j'ai constaté elle ne fonctionne que pour des nombres entiers.

Pour afficher une valeur décimale non-entière, on doit donc utiliser la fonction lcd.printf.  Les programmeurs expérimentés en langage C sont familiers avec printf, dont la syntaxe est loin d'être conviviale, à mon avis.  Ainsi, pour afficher "Tension:  2,01 V" , où 2,01 est le contenu d'une variable de type float intitulée "nombre", j'ai dû écrire:

lcd.printf("Tension: %04f V", nombre); 

Le symbole "%" indique l'endroit où le contenu de la variable sera inséré à l'intérieur du string, "04" permet de régler le nombre de décimales qui seront affichées, et "f" indique que la variable est de type float.

Ça fonctionne, mais sur cet aspect je préfère de loin la convivialité de la syntaxe Arduino!

Voici donc l'adaptation pour le Pinguino d'un sketch que j'avais utilisé pour l'Arduino il y a quelques années:  l'afficheur LCD indique en volts la tension à l'entrée analogique 1 du Pinguino.  Sur la deuxième ligne, une jauge de type "bar graph" ajoute une information visuelle supplémentaire.

La tension à l'entrée analogique 1 du Pinguino peut provenir, par exemple, d'un potentiomètre.

	/********************************************************************
	LCD Bargraph
	La tension mesurée sur la pin A0 du Pinguino est affichée sur un LCD
	16 X 2. Un bargraphe offre également une représentation visuelle de
	la mesure.
	Branchements du LCD:
	* LCD RS pin : digital pin 0
	* LCD E pin : digital pin 1
	* LCD D4 pin : digital pin 2
	* LCD D5 pin : digital pin 3
	* LCD D6 pin : digital pin 4
	* LCD D7 pin : digital pin 5
	* LCD R/W pin : ground
	* Potentiometre 10K: curseur à digital pin 3
	*
	* Plus de détails:
	* http://electroniqueamateur.blogspot.com/2014/09/pinguino-et-afficheur-lcd.html
	*
	********************************************************************/
	float vieilleJauge = 0; // valeur précédente de la jauge
	void setup()
	{
	// initialisation du LCD en mode 4 bits
	lcd.pins(0, 1, 2, 3, 4, 5, 0, 0, 0, 0);
	// 16 colonnes, 2 lignes
	lcd.begin(16, 2);
	}
	void loop()
	{
	int i;
	float nombre = analogRead(A0); // on récupère le voltage sur la broche 2
	float jauge = map(nombre, 0, 1023, 0, 16); // on sépare la valeur en 16 morceaux pour le bargraph
	nombre = nombre / 1023.0 * 5.0; // conversion en volts
	// on place le curseur pour écrire au début de la première ligne
	lcd.setCursor(0, 0);
	lcd.printf("Tension: %04f V", nombre);
	if (jauge > vieilleJauge) { // on vérifie si le nombre a augmenté
	for (i = 0; jauge >= i; i++) {
	lcd.setCursor(i, 1); // curseur dans la deuxième ligne
	lcd.write(1023); // écriture d'un rectangle noir
	}
	}
	if (jauge <= vieilleJauge) { // si le nombre a diminué
	for (i = 15; jauge <= i; i--) { //compte à rebours
	lcd.setCursor(i, 1); // curseur dans la deuxième ligne
	lcd.write(1022); // écriture d'un rectangle blanc
	}
	}
	vieilleJauge = jauge;
	delay(200);
	}

view raw lcd_bargraph.pde hosted with ❤ by GitHub

Yves Pelletier (Twitter:  @ElectroAmateur)

Amplificateurs opérationnels (3): Le multivibrateur astable

Lors des deux premiers articles ce cette série portant sur les applications de l'amplificateur opérationnel, nous avons construit un comparateur et un suiveur de tension.

Pour ce troisième article, nous allons construire un un multivibrateur astable qui produira un signal en créneau: le signal alternera rapidement entre une tension constante positive et une tension constante négative.

Encore une fois, j'ai utilisé un UA741, mais il y a fort à parier que la plupart des modèles d'amplificateur opérationnel d'usage général feront l'affaire.  C'est une alimentation ATX d'ordinateur qui m'a permis d'alimenter l'amplificateur avec une tension bipolaire de ±12 V.

Voici le schéma du circuit:

Lorsque la tension de sortie de l'amplificateur est positive, le condensateur se charge et la tension à l'entrée inverseuse augmente.  Lorsque cette dernière devient supérieure à la tension à l'entrée non-inverseuse, la tension de sortie devient négative, ce qui oblige le condensateur à se décharger, puis à se charger avec la polarité inverse jusqu'à ce que la tension de sortie change de polarité à nouveau.

Il en résulte un signal en créneau d'environ 450 Hz, oscillant entre -12 V et +12 V environ.   Si vous modifiez R1, R2, R3 ou C1, la fréquence sera différente.

Pour obtenir un vibrateur dont la fréquence est ajustable, vous pouvez remplacer la résistance R1 par un potentiomètre.  De plus, l'ajout d'un deuxième potentiomètre à la sortie vous permet de modifier l'amplitude du signal, si désiré.

Article suivant:  Amplificateurs opérationnels (4):  intégrateur et le différentiateur
Article précédent:  Amplificateurs opérationnels (1):  comparateur



Yves Pelletier (Twitter:  @ElectroAmateur)

Amplificateurs opérationnels (2): Le suiveur de tension

Nous avons vu dans le premier article de cette série qu'en mode comparateur, seuls deux états sont possibles à la sortie de l'amplificateur opérationnel: une tension positive ou une tension négative.

Toutefois, l'amplificateur opérationnel est bel et bien un composant analogique:  sa tension de sortie peut varier de façon continue de façon à prendre une infinité de valeurs différentes possibles.  Mais pour ce faire, il faut une contre-réaction:  une des entrées doit être reliée à la sortie.

La contre-réaction la plus simple, c'est un fil conducteur reliant la sortie à l'entrée inverseuse:  ce montage s'appelle "suiveur de tension".

Faisons une petite analyse de ce circuit.  Deux points reliés par un conducteur se trouvent au même potentiel électrique. Donc, pour ce circuit,  V_sortie =  V ^-.

D'autre part, nous avons présenté cette équation dans le billet précédent:

                     V_sortie = A ( V⁺ - V ^- )

... on peut aussi l'écrire de cette façon:     V ⁺ - V ^- = V_sortie / A

... et puisque A est à toute fin pratique infini, il en découle que V ⁺ = V ^-  (les deux tensions d'entrée sont égales entre elles).

Puisque V_sortie =  V ^- et V ⁺ = V ^- ,  il en découle que V_sortie =  V ⁺ : la tension de sortie sera identique à la tension appliquée sur l'entrée non-inverseuse.


Ici, j'en entend qui s'exclament:  à quoi peut bien servir un amplificateur dont la tension de sortie est identique à la tension d'entrée!?!?  Ce truc ne sert à rien!?!

Voici un exemple où ça peut être très utile:

Supposons qu'à l'intérieur d'un circuit alimenté par une source de 5 V, vous avez besoin d'une tension de 2,5 V; une solution simple consiste à utiliser un diviseur de tension constitué de deux résistances identiques montées en série (supposons deux résistances de 10 K).

Tout va bien:  vous mesurez maintenant 2,5 V à l'endroit où les deux résistances sont branchées ensemble.

Mais qu'arrive-t-il si vous alimentez une résistance de 1K à partir de ce diviseur de tension?

Ça ne va plus du tout!  La présence de la résistance de charge est venue perturber les caractéristiques de votre diviseur de tension, et on lit maintenant une tension de 0,4 V là où on espérait obtenir 2,5 V!

Voici un remède efficace:  vous insérez un suiveur de tension entre le diviseur de tension et sa résistance charge.

Cette fois, la tension de 2,5 V est intégralement transmise à la résistance de charge.

Pourquoi ça fonctionne?  À cause de l'énorme impédance d'entrée  de l'amplificateur opérationnel, tout le courant qui traverse la résistance R1 doit aussi traverser R2:  le diviseur de tension est donc complètement isolé de la résistance de charge.

Yves Pelletier (Twitter:  @ElectroAmateur)

Amplificateurs opérationnels (1): le comparateur

J'amorce aujourd'hui une série d'articles portant sur les nombreuses applications d'un composant incroyablement polyvalent:  l'amplificateur opérationnel.

Bien sûr, comme son nom l'indique, l'amplificateur opérationnel peut être utilisé pour amplifier un signal électrique.  Mais on peut également l'utiliser pour effectuer des opérations mathématiques comme l'intégrale ou la dérivée (d'où le qualificatif "opérationnel"), pour filtrer un signal comportant des fréquences indésirables, pour produire un signal périodique , pour débiter un courant d'intensité constante, etc.

Un amplificateur opérationnel est constitué de deux broches d'alimentation (une positive Vcc+, l'autre négative Vcc-), de deux entrées (l'entrée inverseuse V ^- et l'entrée non-inverseuse V⁺) et d'une sortie.  Il s'agit d'un amplificateur différentiel:  il produit à sa sortie une version amplifiée de la différence de potentiel entre ses deux entrées.   Ce comportement peut être décrit par l'opération mathématique suivante:

V_sortie = A ( V⁺ - V ^- )

...où A représente le gain de l'amplificateur, qui est tellement grand (typiquement de l'ordre de 1 million) que, pour simplifier les calculs, on peut considérer qu'il est infini!   De plus, l'impédance d'entrée de l'amplificateur opérationnel est très grande (idéalement infinie) alors que son impédance de sortie est très faible (idéalement nulle).


Assez de théorie pour l'instant:  expérimentons!

Vous aurez besoin, bien entendu,  d'un amplificateur opérationnel.  J'ai personnellement utilisé un LM741 (ou UA741), qui est un modèle de base très répandu et qui existe depuis plusieurs années, mais à peu près n'importe quel autre modèle d'amplificateur opérationnel d'usage général devrait faire l'affaire.  Si vous avez déjà un amplificateur opérationnel, peu importe son modèle, essayez-le; ça fonctionnera probablement.


Le 741 est vendu sous la forme d'un circuit intégré à 8 pins.  Mais vous pouvez également vous procurer des circuits intégrés qui comportent 2 ou 4 amplificateurs opérationnels (ce qui est parfois bien pratique lorsqu'on veut utiliser plusieurs amplificateurs opérationnels dans le même circuit). Il s'agit que vous consultiez la fiche technique de votre modèle pour connaître l'assignation des pins.

Il vous faudra aussi une source d'alimentation continue bipolaire capable de fournir une tension positive et une tension négative.  Une alimentation ATX d'ordinateur constitue une solution économique et tout à fait efficace:  c'est d'ailleurs ce que j'ai utilisé.   La pin numéro 4 du LM741 est donc reliée à la sortie -12 V, alors que la pin numéro 7 est reliée à la sortie +12 V de la source d'alimentation.

À l'entrée non inverseuse (pin 3 du LM741), j'applique une tension de référence de 2,5 V au moyen d'un diviseur de tension constitué de deux résistances identiques de 10 kΩ alimentées  par une tension continue de 5 volts.

À l'entrée inverseuse (pin 2 du LM741), je branche un potentiomètre, ce qui me permettra d'appliquer une tension variant entre 0 et 5 volts.

À la sortie de l'amplificateur opérationnel:  deux LEDs indicatrices (chacune étant accompagnée d'une résistance de protection) permettront de connaître la polarité du signal de sortie.  Vous pouvez également brancher un voltmètre à la sortie.

Tournez le potentiomètre de façon à faire varier la tension à l'entrée inverseuse:  vous devriez constater que lorsque la tension à l'entrée inverseuse est plus grande que la tension à l'entrée non-inverseuse, la LED verte s'allume.  Lorsque c'est l'inverse, c'est la LED rouge qui est allumée.

Pourquoi?  Rappelez-vous de notre équation mathématique du début:

V_sortie = A ( V⁺ - V ^- )

Si V⁺ est plus grand que V ^-, le contenu de la parenthèse est positif et V_sortie prendra donc une très grande valeur positive.
Si V⁺ est plus petit que V ^-, le contenu de la parenthèse est négatif et V_sortie prendra donc une très grande valeur négative.

En théorie, le gain "A" est infiniment grand, donc le résultat de l'équation sera +∞ ou -∞.  En pratique, toutefois, la tension de sortie ne peut pas dépasser les ±12 V de l'alimentation;  donc la tension de sortie sera d'environ +12 V lorsque V⁺ est plus grand que V ^-,  et d'environ -12 V lorsque V⁺ est plus petit que V ^-.

Mais attention:  si vous avez besoin d'un comparateur dans un circuit, il est nettement préférable d'utiliser un circuit intégré spécialement dédié à cette fin (entre autres choses:  il sera plus rapide, comportera une hystérésis, etc.)

Prochain article:  le suiveur de tension.

Yves Pelletier (Twitter:  @ElectroAmateur)

Explorons les portes logiques

Lorsqu'on a l'habitude d'utiliser des microcontrôleurs, on a trop facilement tendance à snober les portes logiques.  Il est tellement facile de programmer notre Arduino pour qu'il ait un comportement comparable à une combinaison (parfois fort complexe) de portes logiques, que l'utilisation d'éléments de circuits non-programmables conçus pour effectuer une seule fonction logique élémentaire peut nous sembler inutilement contraignante.

Et pourtant, mine de rien, les portes logiques, ça peut être amusant...


La porte ET (AND Gate)

La porte "ET" comporte une sortie et au moins deux entrées.  La sortie prend le niveau logique HAUT à la condition que toutes les entrées se trouvent au niveau logique HAUT.  Il s'agit qu'une ou plusieurs entrées se trouvent au niveau logique BAS pour que la sortie soit également au niveau logique BAS.  (Dans cet article, nous considérons que le niveau logique BAS correspond à potentiel  de 0 V, et que le niveau logique HAUT correspond à un potentiel de 5 V.)

Table de vérité d'une porte ET

Entrée 1	Entrée 2	Sortie
0	0	0
1	0	0
0	1	0
1	1	1

Les circuits intégrés 74HC08 et 4081 comportent quatre portes ET; chacune de ces 4 portes comporte deux entrées et une sortie. Lorsque vous connaissez le brochage du circuit intégré  (qui n'est pas le même selon qu'il s'agit du 74HC08 ou du 4081), il est facile de l'expérimenter.  Notez que le circuit doit obligatoirement être alimenté (au moyen de ses pins 7 et 14) pour être fonctionnel.  Pour voir l'état de la sortie, vous pouvez utiliser un voltmètre, ou une LED indicatrice.

Il n'est toutefois pas obligatoire de disposer d'un tel circuit intégré pour expérimenter avec une porte ET.  Vous pouvez construire une porte ET au moyen de deux diodes et d'une résistance.  Si l'une ou l'autre des entrées est à 0 V, la diode reliée à cet entrée est passante et la sortie est donc reliée à 0 V par l'entremise de la diode.  Il faut que les deux entrées soit à 5 V pour qu'aucun courant ne circule dans la résistance et que la sortie soit également à 5 V (la chute de potentiel dans la résistance est alors nulle).

Expérimentez-le!  C'est beaucoup mieux en vrai que dans les livres...  J'ai utilisé une résistance de 10K et des diodes 1N4148, mais n'importe quel type de diode devrait faire l'affaire (vous pouvez même utiliser des LEDs, qui s'allumeront lorsqu'un courant les traverse).

La porte ET peut également être réalisée au moyen de deux transistors:  pour que la sortie soit à 5 V, il faut que les deux jonctions collecteur-émetteur soient conductrices, donc que les deux entrées soient à 5 V.  Aussitôt qu'une entrée se trouve à 0 V, le transistor qui lui est associé empêche la circulation du courant dans la résistance R3, donc la sortie sera à 0 V.

J'ai utilisé des transistors 2N2222 avec  R1 = R2 = 10 K et R3 = 4K7. Mais n'importe quel transistor NPN devrait faire l'affaire.

La porte OU (OR Gate)

La porte "OU" comporte également une sortie et au moins deux entrées.  La sortie prend le niveau logique HAUT lorsqu'au moins une de ses entrées se trouve au niveau logique HAUT.  Si les toutes les entrées sont au niveau logique BAS, alors la sortie sera également au niveau logique BAS.

Table de vérité d'une porte OU

Entrée 1	Entrée 2	Sortie
0	0	0
1	0	1
0	1	1
1	1	1

Les circuits intégrés 74HC32 et 4071 comportent quatre portes OU à deux entrées.  Encore une fois, notre vie aurait été simplifiée si l'assignation des pins avait été la même sur les deux CI, mais les concepteurs en ont décidé autrement.


De toute façon, vous pouvez construire votre propre porte OU, sans le moindre composant spécialisé, en utilisant des diodes ou des transistors.

Voici le schéma d'une porte OU réalisée au moyen de deux diodes et d'une résistance.  Lorsqu'au moins un des signaux d'entrée est HAUT (5 V), la diode est passante et ce  potentiel de 5 V est presque complètement transmis à la sortie.  Si les deux signaux sont bas, la diode est bloquante, aucun courant ne peut donc circuler dans la résistance (la chute de potentiel de cette dernière est donc nulle), et la sortie est à un potentiel de 0.  J'ai utilisé une résistance de 10K.

Vous pouvez également construire une porte OU avec une combinaison de transistors.  Pour qu'un courant circule dans la résistance R3, il s'agit qu'un ou l'autre des deux transistors le laisse circuler, ce qui sera le cas si une ou l'autre des entrées est à 5 V afin qu'un courant circule dans la base.

Encore une fois, j'ai utilisé des transistors 2N2222, R1 = R2 = 10K et R3 = 4K7.


La porte OU EXCLUSIF (XOR)

La sortie d'une porte "OU EXCLUSIF" prend l'était logique "HAUT" si une seule de ses entrées est à l'état logique "HAUT", mais pas l'autre.   En d'autres mots, la sortie sera basse si les deux entrées sont dans le même état logique, et la sortie sera haute si les deux entrées sont des des états différents.

Table de vérité d'une porte OU EXCLUSIF

Entrée 1	Entrée 2	Sortie
0	0	0
1	0	1
0	1	1
1	1	0

Les circuits intégrés 74HC86 et 4070 comportent des portes de type OU EXCLUSIF.

La construction d'une porte OU EXCLUSIF au moyen de diodes ou de transistor semble assez complexe mais, comme nous le verrons plus loin, nous pouvons en construire une en combinant d'autres portes logiques.

La porte NON (NOT)

La porte "NON" ne comporte qu'une seule entrée, et une sortie. Elle se contente d'inverser le signal:  si le signal d'entrée est HAUT, le signal de sortie est BAS.  Si le signal d'entrée est BAS, alors le signal de sortie est HAUT.

Table de vérité d'une porte NON

Entrée	Sortie
0	1
1	0

Les circuits intégrés 74HC04 et 4069 comportent 6 portes NON...

, et on peut très facilement en construire une en utilisant un transistor (transistor 2N2222, R1 = 10K et R2 = 1K).

À partir de là, on peut définir une porte qui est le contraire des 3 portes précédentes:  la porte NON-ET, la porte NON-OU, et la porte NON-OU EXCLUSIF...

La porte NON-ET (NAND)

La porte NON-ET fait exactement le contraire d'une porte ET, donc sa sortie est basse uniquement si toutes ses entrées sont hautes.

Table de vérité d'une porte NON-ET

Entrée 1	Entrée 2	Sortie
0	0	1
1	0	1
0	1	1
1	1	0

On retrouve 4 portes NON-ET sur les circuits intégrés 74HC00 et 4011,,,

...et on peut en construire une avec deux transistors (2N2222, R1 = R2 = 10K et R3 = 4K7).

:

La porte NON-OU (NOR)

Sans trop de surprise, la porte NON-OU fait le contraire d'une porte OU, donc sa sortie est haute seulement si toutes ses entrées sont basses.

Table de vérité d'une porte NON-OU

Entrée 1	Entrée 2	Sortie
0	0	1
1	0	0
0	1	0
1	1	0

Vous trouverez des circuits intégrés spécialement conçus pour remplir cette fonction:   74HC02 et 4001.

Et voici le circuit à base de transistors qui permet d'obtenir une porte NON-OU (transistors 2N2222, R1 = R2 = 10K et R3 = 4K7).
.

La porte NON-OU EXCLUSIF  (XNOR)

Et comme vous l'avez déjà deviné, la porte NON-OU EXCLUSIF fait le contraire d'une porte OU-EXCLUSIF:  la sortie est haute lorsque les deux entrées sont dans le même état, et la sortie est basse lorsque les deux entrées sont dans des états différents.

Table de vérité d'une porte NON-OU EXCLUSIF

Entrée 1	Entrée 2	Sortie
0	0	1
1	0	0
0	1	0
1	1	1

Le circuit intégré 4077 comporte des portes NON-OU EXCLUSIF.

Construire des portes logiques en combinant d'autres portes logiques

Une dernière remarque:  il est souvent possible de créer une porte logique en combinant plusieurs autres portes logiques.  Bien sûr, vous aurez deviné qu'une porte ET combinée à une porte NON aura le même comportement qu'une porte NON-ET.

Mais il y a mieux:  les portes NON-ET et les portes NON-OU sont universelles, car n'importe quel type de porte peut être construit au moyen d'une combinaison de plusieurs portes NON-ET ou d'une combinaison de plusieurs portes NON-OU.

Voici comment combiner des portes NON-ET pour obtenir toutes les autres portes:

En quoi ça peut être utile?   Supposons que dans un même circuit, vous avez besoin d'une porte NON, d'une porte ET et d'une porte NON-ET.  Une option possible consisterait à utiliser un circuit intégré pour la porte NON (en utilisant une seule de ses 6 portes), un circuit intégré pour la porte ET (en utilisant une seule de ses 4 portes) et un circuit intégré pour la porte NON-ET (en utilisant une seule de ses 4 portes).  Mais vous pouvez obtenir le même résultat au moyen d'un seul circuit intégré comportant 4 portes NON-ET!


Yves Pelletier (Twitter:  @ElectroAmateur)

Une partie des informations présentées ici provient de l'article "Logic Gates Fundamentals",  publié dans le numéro d'avril 1987 du magazine Radio Electronics.

Contrôler un moteur DC en python avec le Raspberry Pi

Cet article a été mis à jour le 1er novembre 2020, afin d'être pleinement compatible avec Python 3.

Voilà un certain temps que je n'ai pas joué avec mon Raspberry Pi...pourquoi ne pas l'utiliser pour contrôler un (ou deux) moteur(s) à courant continu?

Nous allons faire un petit programme en python qui fera varier le sens et la vitesse de rotation du moteur.  Vous allez voir:  ce n'est pas tellement compliqué, et ça pourrait servir de point de départ pour un excellent projet de robot...


Le double pont en H L293D

Commençons par une mise en garde:  il est hors de question de brancher directement le moteur aux broches GPIO du Raspberry Pi:  les courants assez intenses qui sont nécessaires pour faire tourner le moteur pourraient s'avérer très néfastes pour la santé de votre Raspberry Pi.  Nous allons plutôt contrôler le moteur par l'intermédiaire d'un circuit intégré spécialement conçu pour ce genre d'utilisation:  le L293D.

Grâce à ce circuit intégré, l'intensité de courant traversant les fragiles broches du Raspberry Pi sera beaucoup plus faible que celle qui traversera le moteur.  De plus, un moteur en rotation agit un peu comme un générateur de courant:  le L293D comporte des diodes intégrées qui protégeront votre Raspberry Pi contre ce courant parasite.

Le circuit

D'abord, un petit rappel de la numérotation des broches GPIOs du Raspberry Pi.   Dans les instructions qui suivent, j'utiliserai exclusivement la notation BOARD (plutôt que BCM).

Et voici le brochage du L293D:

Les broches 4, 5, 12 et 13 du L293D doivent toutes être reliées à la masse (les broches GND) du Raspberry Pi (la broche numéro 6, par exemple).  Comme tous les circuits intégrés, le L293D doit être alimenté, et c'est la broche16 qui est désignée pour recevoir cette alimentation.  Une des sorties 5 V du Raspberry Pi (la broche numéro 2, par exemple) fera parfaitement l'affaire.  Cette tension sert uniquement à alimenter le circuit intégré:  elle n'est pas transmise au moteur.

Pour alimenter le moteur, on utilise la broche 8 du L293D.  Mais attention:  il n'est pas du tout conseillé d'utiliser les broches du Raspberry Pi pour cette fonction.  Nous allons donc utiliser une alimentation autonome comme, par exemple, des piles (la tension de votre assemblage de piles sera choisie de façon à ne pas dépasser ce que peut tolérer votre moteur).  La borne positive de l'alimentation du moteur doit être reliée à la broche 8 du L293D, et la borne négative doit être reliée à la masse (du L293D et du Raspberry Pi).

On peut brancher deux moteurs DC à un même L293D:  les broches situées du côté gauche du CI sont réservées au premier moteur, et les broches du côté droit sont pour le deuxième (s'il y a lieu).

Commençons par un seul moteur.  Le moteur lui-même se branche aux broches 3 et 6 du L293D.

La broche 1 du L293D est la broche "enable" (activation) du premier moteur.  Le moteur tournera à sa vitesse maximale si cette broche est soumise au signal logique "HAUT", et il ne tournera pas si elle se trouve au signal logique "BAS".  Si on veut que le moteur tourne à une vitesse réduite, il s'agit de soumettre cette broche à un signal qui alterne rapidement entre "HAUT" et "BAS":  c'est ce qu'on appelle la modulation de largeur d'impulsion, ou PWM pour pulse width modulation.    Relions donc la broche 1 du L293D à la broche 22 du Raspberry Pi,

Il reste deux autres broches du L293D à raccorder au Raspberry Pi:  le moteur tournera dans un sens lorsque la broche 2 sera soumise au signal logique "HAUT"  et la broche 7 sera soumise au signal logique "BAS", et tournera dans l'autre sens si la broche 2 est à "BAS" pendant que la broche 7 est à "HAUT". Branchez la broche 2 du L293D à la broche 18 du Raspberry Pi, et la broche 7 du L293D à la broche 16 du Raspberry Pi.

Programme en langage Python

Voici un petit programme en Python qui montre comment contrôler le moteur:  on le fait d'abord tourner dans un sens à haute vitesse pendant 5 secondes, puis à basse vitesse.  Ensuite, on inverse le sens de sa rotation, d'abord à basse vitesse, et ensuite à haute vitesse.

	#!/usr/bin/python
	# -*- coding:utf-8 -*-
	'''
	Controle d'un moteur à courant continu par le Raspberry Pi
	Plus de details:
	http://electroniqueamateur.blogspot.com/2014/09/controler-un-moteur-dc-en-python-avec.html
	'''
	import RPi.GPIO as GPIO
	from time import sleep
	GPIO.setmode(GPIO.BOARD) ##je prefere la numerotation BOARD plutot que BCM
	Moteur1A = 16 ## premiere entrée du premier moteur, pin 16
	Moteur1B = 18 ## deuxieme entrée du premier moteur, pin 18
	Moteur1E = 22 ## enable du premier moteur, pin 22
	GPIO.setup(Moteur1A,GPIO.OUT) ## ces trois broches du Raspberry Pi sont des sorties
	GPIO.setup(Moteur1B,GPIO.OUT)
	GPIO.setup(Moteur1E,GPIO.OUT)
	pwm = GPIO.PWM(Moteur1E,50) ## pwm de la broche 22 a une frequence de 50 Hz
	pwm.start(100) ## on commemnce avec un rapport cyclique de 100%
	print ("Rotation sens direct, vitesse maximale (rapport cyclique 100%)")
	GPIO.output(Moteur1A,GPIO.HIGH)
	GPIO.output(Moteur1B,GPIO.LOW)
	GPIO.output(Moteur1E,GPIO.HIGH)
	sleep(5) ## on laisse tourner le moteur 5 secondes avec des parametres
	pwm.ChangeDutyCycle(40) ## modification du rapport cyclique a 40%
	print ("Rotation sens direct, au ralenti (rapport cyclique 40%)")
	sleep(5)
	print ("Rotation sens inverse, au ralenti (rapport cyclique 40%)")
	GPIO.output(Moteur1A,GPIO.LOW)
	GPIO.output(Moteur1B,GPIO.HIGH)
	sleep(5)
	pwm.ChangeDutyCycle(100)
	print ("Rotation sens inverse, vitesse maximale (rapport cyclique 100%)")
	sleep(5)
	print ("Arret du moteur")
	GPIO.output(Moteur1E,GPIO.LOW)
	pwm.stop() ## interruption du pwm
	GPIO.cleanup()

view raw moteur_un.py hosted with ❤ by GitHub

Deux moteurs

Vous pouvez ajouter un deuxième moteur si le coeur vous en dit.  Le moteur se branche aux broches 11 et 14 du L293D.  On peut ensuite brancher la broche 9 du L293D à la broche 23 du Raspberry Pi, la broche 10 du L293D à la broche 21 du Raspberry Pi, et la broche 15 du L293D à la broche 19 du Raspberry Pi.

Le schéma ci-dessous illustre les branchements du deuxième moteur (j'ai enlevé le premier moteur pour plus de clarté):

Voici un programme qui illustre comment on peut contrôler les deux moteurs de façon simultanée.

	## Controle de deux moteurs DC par le Raspberry Pi
	# Plus d'infos:
	# http://electroniqueamateur.blogspot.com/2014/09/controler-un-moteur-dc-en-python-avec.html
	import RPi.GPIO as GPIO
	from time import sleep
	GPIO.setmode(GPIO.BOARD) ##je prefere la numerotation BOARD plutot que BCM
	Moteur1A = 16 ## premiere sortie du premier moteur, broche 16
	Moteur1B = 18 ## deuxieme sortie de premier moteur, broche 18
	Moteur1E = 22 ## enable du premier moteur, broche 22
	Moteur2A = 19 ## premiere sortie du deuxieme moteur, broche 19
	Moteur2B = 21 ## deuxieme sortie de deuxieme moteur, broche 21
	Moteur2E = 23 ## enable du deuxieme moteur, broche 22
	GPIO.setup(Moteur1A,GPIO.OUT) ## ces 6 broches du Raspberry Pi sont des sorties
	GPIO.setup(Moteur1B,GPIO.OUT)
	GPIO.setup(Moteur1E,GPIO.OUT)
	GPIO.setup(Moteur2A,GPIO.OUT)
	GPIO.setup(Moteur2B,GPIO.OUT)
	GPIO.setup(Moteur2E,GPIO.OUT)
	pwm1 = GPIO.PWM(Moteur1E,50) ## pwm de la broche 22 a une frequence de 50 Hz
	pwm1.start(100) ## on commemnce avec un rapport cyclique de 100%
	pwm2 = GPIO.PWM(Moteur2E,50) ## pwm de la broche 23 a une frequence de 50 Hz
	pwm2.start(20) ## on commemnce avec un rapport cyclique de 100%
	print ("Moteur 1 sens direct, rapide. Moteur 2 sens direct, lent.")
	GPIO.output(Moteur1A,GPIO.HIGH)
	GPIO.output(Moteur1B,GPIO.LOW)
	GPIO.output(Moteur1E,GPIO.HIGH)
	GPIO.output(Moteur2A,GPIO.HIGH)
	GPIO.output(Moteur2B,GPIO.LOW)
	GPIO.output(Moteur2E,GPIO.HIGH)
	sleep(5) ## on laisse tourner les moteur 5 secondes avec des parametres
	print ("Moteur 1 sens direct, lent. Moteur 2 sens inverse, lent.")
	pwm1.ChangeDutyCycle(20) ## modification du rapport cyclique a 20%
	GPIO.output(Moteur2A,GPIO.LOW)
	GPIO.output(Moteur2B,GPIO.HIGH)
	sleep(5)
	print ("Moteur 1 sens inverse, lent. Moteur 2 sens inverse, rapide.")
	pwm2.ChangeDutyCycle(100) ## modification du rapport cyclique a 100%
	GPIO.output(Moteur1A,GPIO.LOW)
	GPIO.output(Moteur1B,GPIO.HIGH)
	sleep(5)
	print ("Arret des moteurs")
	GPIO.output(Moteur1E,GPIO.LOW)
	GPIO.output(Moteur2E,GPIO.LOW)
	pwm1.stop() ## interruption du pwm
	pwm2.stop()
	GPIO.cleanup()

view raw moteurs_deux.py hosted with ❤ by GitHub

N'hésitez pas à consulter mes autres tutoriels concernant le Raspberry Pi.

Sources: Je me suis d'abord basé sur cet article, mais puisque l'auteur ne faisait pas varier la vitesse du moteur, j'ai dû me documenter ailleurs concernant le PWM.


Yves Pelletier (Twitter:  @ElectroAmateur)