Étude de CI: Bascules (flip flops) de type D (CD4013)

Dans le cadre de cette série d'articles qui consiste à sortir de mes tiroirs un vieux circuit intégré poussiéreux afin de découvrir à quoi il pourrait bien servir, je vous présente aujourd'hui le CD4013, qui comporte deux bascules (flip flops) de type D.

Une bascule est une mémoire (à un seul bit!):  lorsqu'on le désire, on peut faire en sorte que sa sortie prend le même niveau logique (0 ou 1) que l'entrée.  La sortie peut ensuite conserver ce niveau logique aussi longtemps qu'on le désire, peu importe ce qui arrive à l'entrée.

Description du CD4013

La figure ci-contre montre le brochage du CD4013.

Les pins 7 et 14 servent à l'alimentation du circuit intégré:  j'utiliserai une alimentation de 5 V (pin 7 à GND et pin 14 à +5 V).

Le niveau logique 0 correspondra donc à 0 volt, alors que le niveau logique 1 correspondra à 5 volts.

Les pins de la première bascule se situent du côté gauche.  Lorsque le signal de la pin 3 (horloge) passe de 0 à 1, la pin 1 (sortie Q) prend le même niveau logique que la pin 5 (entrée D) et conserve ce niveau logique jusqu'au prochain passage de 0 à 1 par la pin 3.

La pin 2 est une sortie complémentaire Ǭ (remarquez la barre au-dessus du symbole), qui prend toujours le niveau contraire de la sortie Q.

Lorsque la pin 6 (set) est au niveau logique 1,  la sortie (pin 1) prend le niveau logique 1.  Lorsque la pin 4 (reset) est au niveau logique 1, la sortie (pin 1) prend le niveau logique 0.


1) Vérification du fonctionnement de base

Pour s'assurer que nous avons bien compris comment ça marche, on teste ça sur une breadboard:  un bouton poussoir pour actionner l'entrée "D", un autre bouton poussoir pour actionner l'horloge, une LED indiquant l'état de la sortie "Q", et une autre (facultative) pour indiquer l'état de la sortie complémentaire "Ǭ".

(Nous n'utiliserons pas les pins SET et RESET:  elles sont donc branchées à GND).

Au départ, la sortie Q (pin 1) devrait être à zéro:  la LED qui y est branchée sera donc éteinte (la sortie complémentaire Ǭ sera allumée, puisqu'elle est toujours dans l'état contraire à la sortie Q).

L'état des LEDs devrait changer uniquement lorsque vous appuyez sur le bouton qui contrôle l'horloge (pin 3):

Si vous appuyez sur le bouton d'horloge pendant que le bouton de l'entrée D est enfoncé, la LED de la sortie Q s'allume (niveau logique 1).

Si vous appuyez sur le bouton d'horloge pendant que le bouton de l'entrée D n'est pas enfoncé, la LED de la sortie Q s'éteint (niveau logique 0).

Les deux sorties "mémorisent" l'état de l'entrée uniquement lorsque vous appuyez sur le bouton d'horloge (lorsque la pin 3 passe de l'état 0 à l'état 1).  Sinon, elle conservent leur état sans se soucier de l'état de la pin d'entrée.

2) Transformation en bascule de type T (toggle)

Nous allons maintenant transformer notre bascule de type D en une bascule de type T (toggle).  Pour ce faire, il s'agit de relier la sortie Ǭ (pin 2) à l'entrée D (pin 5).  Cette entrée sera donc contrôlée par la sortie plutôt que par un bouton.

Nous n'avons besoin que d'un seul bouton, qui contrôlera l'horloge (pin 3).  Mais attention:   il est nettement préférable d'utiliser un bouton sans rebond, sinon les résultats risquent d'être quelque peu aléatoires.  Pour des résultats impeccables, vous pouvez utiliser des interrupteurs sans rebond à base de bascules de Schmitt. Pour ma part, je me suis contenté d'ajouter un condensateur de 100 nF en parallèle avec le bouton, avec des résultats très satisfaisants.

Alors qu'est-ce que ça donne, maintenant?  Vous appuyez sur le bouton:  la LED s'allume (et demeure allumée même si vous relâchez le bouton).  Vous appuyez à nouveau sur le bouton:  la LED s'éteint.

Ce comportement se comprend facilement:  l'entrée D est toujours dans le même état que la sortie Ǭ, donc dans l'état contraire à la sortie Q.  Lorsque l'horloge passe de 0 à 1, Q prend la valeur de D, qui est le contraire de ce qu'était Q auparavant.

3) Fabrication d'un compteur binaire

Il est possible de fabriquer un compteur binaire en reliant plusieurs bascules de type T en cascade. Les pins D et Ǭ de la première bascule sont reliées à l'horloge de la deuxième bascule, et ainsi de suite.

Voici, par exemple, un compteur binaire à 4 bits, construit au moyen de 4 bascules (donc deux circuits intégrés CD4013).

Au départ, toutes les LEDs sont éteintes:  c'est le nombre binaire 0000.

Vous appuyez une première fois sur le bouton, qui actionne l'horloge de la bascule A:  la sortie Q de la bascule A se met au niveau 1, ce qui allume la LED A  (nombre binaire 0001).

Mais notez que la sortie Ǭ de la bascule A est reliée à l'horloge de la bascule B.  Lors du premier appui sur le bouton, cette sortie est passée de 1 à 0, ce qui n'entraîne aucun changement de la bascule B.

Deuxième appui sur le bouton:  la bascule A change d'état:  sa sortie Q prend le niveau 0 (la LED A s'éteint) et sa sortie Ǭ prend le niveau 1, ce qui entraîne un changement d'état pour la bascule B (la LED B s'allume), ce qui correspond au nombre binaire 0010.

...et ainsi de suite jusqu'au nombre binaire 1111 (qui correspond à 15 en décimal).

Si ça vous amuse, rien ne vous empêche d'augmenter le nombre de bits.

4) Diviseur de fréquence

Si vous avez construit le compteur binaire de l'étape précédente,  vous pouvez remarquer qu'à mesure qu'on progresse dans notre chaînage de bascules, la fréquence est de plus en plus lente:

la LED A change d'état chaque fois qu'on appuie sur le bouton, mais:
on doit appuyer 2 fois sur le bouton pour que la LED B change d'état
on doit appuyer 4 fois sur le bouton pour que la LED C change d'état
on doit appuyer 8 fois sur le bouton pour que la LED D change d'état

Donc si vous soumettez l'horloge d'une bascule de type T à un signal périodique (oscillant entre 0 et 5 V), la fréquence à la sortie de la bascule sera divisée par deux.

Ci-dessous:  c'est le même circuit qu'à l'étape précédente, mais le bouton a été remplacé par un NE555 produisant un signal  périodique (j'aurais pu produire ce signal au moyen d'un Arduino, mais j'ai préféré compléter cette petite exploration en demeurant "vintage":  pas de microcontrôleurs aujourd'hui).

Voilà!  Il ne me reste plus qu'à espérer que cet article sur les flip flops ne sera pas un flop (sinon, je flippe!).

Yves Pelletier   (Twitter, Facebook)

Fabriquons notre propre pont en H

Jusqu'à maintenant, dans chaque projet impliquant le contrôle d'un ou deux moteurs DC par un microcontrôleur, j'ai utilisé un circuit intégré spécialement conçu à cette fin, comme le populaire L293D.  Mais il est très facile de construire soi-même un contrôleur de moteur à partir de quelques transistors, et c'est ce que nous allons faire aujourd'hui.

Pourquoi un contrôleur de moteur?

Supposons que vous avez décidé de contrôler un moteur au moyen d'une carte Arduino (ou un autre microcontrôleur):  pourquoi ne pas simplement brancher le moteur directement sur une de ses sorties?

Les raisons sont multiples.  D'abord, pour protéger l'Arduino.  La résistance d'un moteur n'est souvent pas très grande:  si vous soumettez le moteur à une tension de 5 V, le courant qui traverse la sortie de l'Arduino pourrait dépasser significativement les valeurs tolérables par l'Arduino.  De plus, un bobinage en rotation dans un champ magnétique génère une tension (c'est le principe de la génératrice) qui pourrait également être dommageable pour l'Arduino.  Et dans bien des cas, votre moteur nécessitera une tension supérieure à 5 V pour fonctionner correctement.

La solution:  un transistor!  Un petit courant issu de la sortie de l'Arduino permet de contrôler un courant plus intense circulant dans le moteur.

Pourquoi un pont en H?

Le circuit illustré plus haut (impliquant un seul transistor) est parfait si vous désirez que votre moteur tourne toujours dans la même direction:  si la sortie numéro 5 de l'Arduino est à 5 V, le moteur tourne.  Si la sortie numéro 5 est à 0 V, le moteur ne tourne plus (et vous pouvez contrôler la vitesse de rotation du moteur grâce à la modulation par largeur d'impulsion "PWM").

Mais dans bien des cas, on veut que le moteur tourne parfois dans une direction, et parfois dans l'autre (par exemple:  pour un robot qui est capable d'avancer et de reculer).  Et c'est là qu'un pont en H devient incontournable.

Voici un schéma de pont en H constitué de 4 transistors (on peut aussi faire un pont en H avec des interrupteurs ou avec des relais).

Lorsque la tension de la pin 6 de l'Arduino est de 5 V et que la tension de la pin 5 est nulle, les transistors Q1 et Q3 forment un trajet conducteur et le courant circule vers la droite dans le moteur.

Si on inverse la polarité, ce sont les deux autres transistors qui deviennent conducteurs, et le courant circule maintenant vers la gauche dans le moteur.

Les diodes servent à protéger le microcontrôleur contre les courant générés par la rotation du moteur.

Expérimentation sur breadboard

Vous pouvez facilement construire un pont en H sur une breadboard afin d'explorer son fonctionnement.  Vous aurez besoin de deux transistors PNP et deux transistors NPN.  N'importe quel transistor commun fera l'affaire si vous contrôlez un petit moteur DC fonctionnant sous quelques volts (des transistors de puissance sont nécessaires si votre moteur est plus énergivore).  J'ai fait ce test avec des 2N3906 et 2N3904 (un choix adéquat pour expérimenter, mais qui serait plus discutable pour une application réelle, tel que discuté dans ce blog) .

Sketch Arduino

Voici le sketch utilisé: le moteur tourne lentement dans une direction pendant 5 secondes, puis il tourne rapidement dans l'autre direction pendant 5 autres secondes.  La vitesse du moteur est contrôlée par PWM (modulation par largeur d'impulsion), c'est pourquoi vous devez vous assurer d'utiliser des sorties de l'Arduino qui supportent le PWM (comme par exemples les pins 5 et 6).

Pour la rotation à vitesse plus lente, il se peut que vous soyez obligés d'augmenter le rapport cyclique utilisé dans le sketch, si vous constatez que votre moteur ne tourne que dans une seule direction.




 

Construction d'un Franken-pont-en-H

Suite à cet essai concluant, j'ai décidé construire un pont en H plus permanent,soudé sur une perfboard.  Pour qu'il soit plus polyvalent, je tenais à utiliser des gros transistors de puissance (format TO-220) à la place des petits transistors que j'avais utilisé dans mon circuit expérimental.  De cette façon, je n'aurai pas à m'inquiéter outre-mesure de la possibilité que mes transistors grillent en cas de courant trop élevé.

Mais en cette époque où les revendeurs chinois nous proposent de robustes contrôleurs complets à base de L298 pour moins de $2 (alors qu'un véritable L298 coûte beaucoup plus cher que ça...), je voulais que ma construction soit pertinente d'un point de vue économique.

Je vous présente donc mon Franken-pont-en-H:  un pont en H constitué exclusivement de composants de récup qui ne m'ont rien coûté (bon, d'accord:  j'ai payé pour le bout de perfboard, et pour les connecteurs car ils sont neufs).   Le tout fonctionne correctement, évidemment.

Yves Pelletier   (Twitter, Facebook)

Chronométrer une chute libre avec Arduino

Voici une petite expérience scientifique qui nous permettra de déterminer expérimentalement l'accélération gravitationnelle à la surface de la terre qui est, théoriquement, égale à 9,8 m/s².

Les habitués de ce blog me feront peut-être remarquer que nous l'avons déjà fait (à la même date, l'an passé!)...vous avez raison! Mais cette fois, nous allons procéder de façon différente.

Le principe:

On laisse tomber un objet d'une hauteur connue, et on mesure le temps nécessaire pour qu'il atteigne le sol.  On peut donc calculer son accélération, en supposant (avec raison) qu'elle est constante.

Le problème:  

Si vous laissez tomber l'objet d'une distance de un ou deux mètres, il atteint le sol en moins d'une seconde.  Vous ne pouvez donc pas chronométrer sa chute en contrôlant manuellement un chronomètre, même si vous considérez que vos réflexes sont très aiguisés!  Il faut concevoir un système qui démarre automatiquement le chronomètre dès le départ de l'objet, et qui interrompt automatiquement le chronomètre à l'arrivée de l'objet.

La solution:  

Une carte Arduino, et deux interrupteurs un peu particuliers.

L'interrupteur de départ:

Au départ, notre objet est maintenu en place par une pince serre-joint à ressort:  en appuyant sur les poignées de la pince, nous libérons l'objet.  Nous prendrons soin d'utiliser un objet en métal:  lorsqu'il se trouve entre les mâchoires de la pinces, un courant peut circuler d'une mâchoire à l'autre.

Aussitôt que l'objet en métal n'est plus en contact avec la pince, le courant ne circule plus...

Dans mon cas, la pince est elle-même en métal, ce qui fait qu'elle conduit toujours l'électricité, peu importe que ses mâchoires soient ouvertes ou fermées.  J'ai donc recouvert les deux mâchoires d'un ruban gommé isolant, sur lequel j'ai collé deux petites plaques conductrices auxquelles j'ai soudé des fils conducteurs et une résistance "pull down" de 33 kΩ (la valeur exacte de la résistance n'a pas d'importance).

Donc lorsque l'objet métallique est coincé entre les deux mâchoires de la pince, le courant passe dans la résistance, et une tension de 5 V est acheminée à l'Arduino.  Lorsqu'on libère l'objet, le courant ne passe plus et une tension de 0 V est acheminée à l'Arduino.

L'interrupteur d'arrivée:

Pour détecter l'impact de l'objet sur le plancher, j'ai utilisé un bouton poussoir soudé à une résistance "pull down" de 33 kΩ (mais une fois encore, la valeur exacte de la résistance n'est pas importante).

Bien sûr, ce serait problématique d'aligner le montage de façon à s'assurer que l'objet tombe précisément sur ce minuscule bouton poussoir...  Pour augmenter la surface de mon détecteur, j'ai inséré ce bouton-poussoir entre deux plaques rigides reliées par une charnière (dans mon cas, la charnière, c'était simplement du ruban gommé).

Un peu par hasard j'ai obtenu une situation idéale pour laquelle le poids de la plaque du haut était déjà presque suffisant pour actionner le bouton.  Il s'agissait de déposer l'objet sur la plaque pour que le bouton s'enfonce.

Donc lorsque l'objet n'est pas sur la plaque, le courant ne peut pas passer à travers la résistance, et une tension de 0 V est acheminée à l'Arduino.  Aussitôt que l'objet tombe sur la plaque, le courant passe à travers la résistance et une tension de 5 V est acheminée à l'Arduino.

L'objet en chute libre:

On veut un objet qui conduit l'électricité, et qui est assez massif pour actionner l'interrupteur d'arrivée et pour rendre négligeable la friction de l'air:  un petit objet en métal, donc.  J'ai utilisé une douille de clé à cliquet.

Le circuit:

C'est ultra-simple:  nos deux interrupteurs un peu spéciaux sont branchés à l'Arduino.

Le sketch:

Le sketch est également très simple.  Au départ, on vérifie que les deux interrupteurs sont dans l'état prévu. On note le temps (millis()) au départ de l'objet, et on le note à nouveau à son arrivée au sol.  Il ne reste plus qu'à afficher la durée de la chute dans le moniteur série.

La variable "enChute" prend la valeur "0" avant la chute (l'objet est encore dans la pince à ressort), "1" pendant la chute (l'objet n'est plus dans la pince, mais n'a pas encore atteint le sol), et "2" quand la chute est terminée (l'objet a actionné l'interrupteur d'arrivée).

Avant de prendre une nouvelle mesure, on appuie sur le bouton reset de l'Arduino.




Les résultats:

Voici quelques durées de chutes mesurées au moyen de ce dispositif, avec une hauteur de chute de 132,5 cm:

518 ms, 511 ms, 512 ms, 511 ms, 511 ms, 514 ms, 507 m

...donc une durée moyenne de 512 ms

Puisque la vitesse initiale de l'objet était nulle, on peu calculer l'accélération de cette façon:

a = 2 * hauteur / (durée)² = 2 * 1,325 / (0,512)² = 10,1 m/s²

... ce qui n'est pas très loin des 9,8 m/s² prévus.

Yves Pelletier   (Twitter, Facebook)