jeudi 15 décembre 2016

Étude de CI: Exploration du timer 555


Mis sur le marché en 1971, le 555 est un grand classique de l'électronique même si, à l'ère des microcontrôleurs à prix modique, ses possibilités vous sembleront peut-être quelque peu limitées.

Le 555 est une minuterie:  on peut l'utiliser pour générer une impulsion de durée prédéterminée (mode monostable) ou une oscillation de fréquence prédéterminée (mode astable).

Je vous propose ici trois petites expériences simple à réaliser sur breadboard, qui vous permettront d'explorer les trois modes d'utilisation du 555:  monostable, bistable et astable.

Mais avant tout, commençons par une brève description du circuit intégré, qui comporte 8 broches:
  • Il est alimenté au moyen des pins 1 (GND) et 8 (VCC).  La tension d'alimentation peut prendre n'importe quelle valeur située entre 4,5 V et 16 V.

  • La pin 2 "TRIGGER" est la gachette:  une entrée qui déclenche le début du chronométrage lorsqu'elle est soumise à une tension basse (1/3 de Vcc ou moins).
  • La pin 3 "OUTPUT" est la sortie.  Elle peut être basse (quelques millivolts) ou haute (environ 1,7 V de moins que VCC).
  • La pin 4 "RESET" est une entrée qui permet la réinitialisation de la minuterie (lorsqu'elle est soumise à une tension nulle)
  • La pin 5 "CONTROL", rarement utilisée, est une entrée qui permet de modifier la tension de référence pour qu'elle soit autre chose que la valeur par défaut (2/3 de VCC).
  • La pin 6 "TRESHOLD" est le seuil:  une entrée qui déclenche la fin de la minuterie lorsqu'elle est soumise à une tension supérieure à la tension de la pin "CONTROL" (par défaut: 2/3 de VCC).
  • La pin 7 "DISCHARGE":  sortie qui permet la décharge d'un condensateur.  C'est la durée de la charge de ce condensateur qui influencera le temps pendant lequel la sortie (pin 3) sera haute.
En bref:  la sortie (pin 3) est généralement basse.  Mais si la gachette (pin 2) est mise à 0 V, la sortie devient haute jusqu'à ce que le seuil (pin 6) soit soumis à une tension supérieure à (2/3)*VCC.  À ce moment, la sortie redevient basse.

Fonctionnement en mode bistable

Voici le schéma d'un circuit dans lequel le 555 est en mode bistable.  Une LED est utilisée pour visualiser l'état de la sortie.  Le schéma indique une tension d'alimentation de 5 V mais, comme je le mentionnais plus haut, ça peut être beaucoup plus si vous le préférez (au besoin, augmentez la résistance de protection de la LED).


Dans ce mode, le 555 se comporte comme une bascule (flip-flop) et non comme une minuterie:   lorsque vous appuyez sur le bouton qui est lié à la gachette (pin 2), cette dernière est temporairement soumise à une tension nulle, ce qui a pour effet de mettre la sortie (pin 3) dans son état haut:  la LED s'allume, et elle demeure allumée même après avoir relâché le bouton (le 555 agit donc comme une mémoire: il se "souvient" que le bouton a été enfoncé, même s'il ne l'est plus).

Pour éteindre la LED, il s'agit d'appuyer sur le bouton qui est relié à la pin 4 (reset).  Là encore, la LED demeure éteinte après que vous ayez relâché le bouton.

Comme je le disais plus haut, lorsque la gachette est mise à 0 V, la sortie devient haute jusqu'à ce que la pin 6 soit soumise à une tension supérieure aux 2/3 de VCC:  en mode bistable, cette situation n'arrive jamais, puisque la pin 6, étant reliée à la masse (GND), demeure toujours à 0 V.




Fonctionnement en mode monostable

Modifions maintenant notre circuit pour que le 555 fonctionne plutôt en mode monostable.  Par rapport au circuit précédent, rien ne change en ce qui concerne les pins 1, 2, 3, 5 et 8. Par contre, la pin 4 est directement reliée à 5 V.  Observez également les pins 6 et 7:  elles sont reliées ensemble par un fil conducteur, ainsi qu'à un condensateur (relié à la masse) et une résistance (reliée à 5 V).



Cette fois, lorsque vous appuyez sur le bouton, la LED s'allume pendant quelques secondes, et finit par s'éteindre d'elle même.



Le temps pendant lequel la LED demeure allumée après qu'on ait relâché le bouton dépend de la valeur de la résistance et du condensateur branchés aux pins 6 et 7.  Le temps nécessaire pour que notre petit circuit RC atteigne une charge équivalent aux 2/3 de VCC est donné par l'équation suivante:

     t = ln(3) * RC

Ici, j'ai utilisé une résistance de 220 kΩ (R = 220 000 Ω) et un condensateur de 10 μF (C = 0,000010 F):

    t = ln(3) * 220 000 * 0,000010 = 2,2 s

La LED reste donc allumée pendant environ 2,2 s.

Il est également possible d'utiliser un calculateur en ligne.

Il va sans dire que vous pouvez modifier la valeur de la résistance et/ou de la capacité afin que le comportement du circuit corresponde à vos besoins.

Si le coeur vous en dit, vous pouvez utiliser un multimètre pour mesurer la tension de la pin 6:  suite à l'appui sur le bouton, cette tension augmente progressivement jusqu'à atteindre 3,3 V (ce qui correspond aux 2/3 de 5 V):  c'est à ce moment que la LED s'éteint.

J'ai récemment utilisé un 555 en mode monostable pour transformer un véhicule radiocommandé en robot autonome.

Fonctionnement en mode astable

Il ne nous reste plus qu'à expérimenter le mode astable, dans lequel la LED clignotera sans arrêt.  Si on le compare au circuit monostable ci-dessus, les pins 1, 3, 4, 5 et 8 ne subissent aucune modification.

Le fil conducteur qui reliait les pins 6 et 7, toutefois, est remplacé par une résistance, et la pin 2 est reliée à la pin 6.


Cette fois, la LED clignote (plutôt lentement) de façon autonome.  Avec les valeurs de résistances et de capacité indiquées sur le schéma, elle devrait être allumée longtemps, et éteinte brièvement.





Cette fois, les valeurs de résistance et de capacité permettent de contrôler deux paramètres:  le temps pendant lequel la LED est allumée, et le temps pendant lequel la LED est éteinte:

        temps LED allumée = ln(2) * C * (R1 + R2)

        temps LED éteinte = ln(2) * C * R2

(R2 étant la résistance qui fait le lien entre la pin 6 et la pin 7)

Avec les valeurs indiquées dans le schéma ci-dessus, on obtient les valeurs suivantes:

     temps LED allumée = ln (2) * 0,00001 * (220000 + 220000) = 3,0 s

     temps LED éteinte = ln(2) * 0,00001 * 220000 = 1,5 s

La LED s'allume pendant 3 secondes, puis s'éteint pendant 1,5 s.

Si vous préférez, vous pouvez utiliser une page web qui fera le calcul pour vous.

Dans le passé, j'ai publié quelques projets impliquant le 555 en mode astable: fabrication d'un métronome, de l'Atari Punk Console, et d'un oscillateur pour pratiquer le code morse.

Yves Pelletier   (TwitterFacebook)


mardi 6 décembre 2016

Calculer la résistance de protection d'une LED

Lorsque vous branchez une LED dans un circuit, il faut toujours lui associer une résistance de protection, sinon votre LED risque de ne pas survivre bien longtemps.  Mais comment choisir la bonne valeur de résistance?


Commençons par énumérer les trois paramètres que vous devez connaître avant d'effectuer votre calcul:
  • La tension de seuil de votre LED.  C'est la différence de potentiel aux bornes de la LED quand elle est allumée.  Elle tourne généralement autour de 2 ou 3 V, mais la valeur exacte dépend  de la couleur émise par la LED (1,5 V pour l'infrarouge, 2 V pour le rouge, 3,3 V pour le bleu...).  Si vous disposez de la fiche technique de votre LED, c'est ce qui s'appelle "forward voltage".  Vous pouvez aussi la mesurer au moyen d'un multimètre (commencez par calculer une valeur temporaire de résistance en supposant une tension de seuil de 2 V, puis mesurez la tension aux bornes de la LED pendant qu'elle est allumée).
  • Le courant optimal pour votre LED.  On retrouve cette donnée dans la fiche technique de la LED ("forward current").   Il est souvent de 20 mA. Remarquez qu'il n'y a rien de tragique à allumer une LED avec un courant plus faible que la valeur optimale (la LED sera seulement moins brillante, et la différence ne sera peut-être même pas perceptible à l'oeil). Évitez toutefois les courants trop intenses:  si la LED ne grille pas immédiatement, sa durée de vie risque d'être sérieusement compromise.
  • La tension d'alimentation.  Il s'agit peut être d'une sortie de votre carte Arduino, de 4 piles AA en série, d'une alimentation de laboratoire...peu importe:  vous devez connaître la tension qui servira à alimenter votre LED.  Au besoin, mesurez-la au moyen d'un multimètre.  Cette tension doit être supérieure à la tension de seuil de la LED.

Le calcul:  la loi d'Ohm

Tout le monde connaît la loi d'Ohm, qui stipule que la tension est égale au produit de la résistance par le courant.

                         Loi d'Ohm:       U = RI

Encore faut-il l'utiliser correctement!

La loi d'Ohm s'applique à la résistance, et non à la LED.  Dans l'équation, "U" représente donc la tension aux bornes de la résistance.

Un premier exemple (une seule LED):

Supposons que vous désirez brancher une LED rouge à la sortie d'une carte Arduino.  Vous avez vérifié que la tension de seuil de votre LED est de 2 V, et votre Arduino génère une tension de 5 V.   La tension aux bornes de la résistance sera donc:

    5 V - 2 V = 3 V

On récapitule:  puisque la résistance et la LED sont branchées en série avec l'alimentation, elle sont traversées par le même courant de 20 mA, et elles se partagent la tension d'alimentation (2 V pour la LED, 3 V pour la résistance).

Nous sommes maintenant prêts à appliquer la loi d'Ohm à la résistance:

U = RI

3 = R (0,020)

R = 3 / (0,020) = 150 ohms

Un deuxième exemple (2 LEDs en série):

Vous désirez brancher alimenter deux LEDs bleues reliées en série au moyen d'une batterie de 9 V. La tension de seuils de vos LED est de 3,3 V.



Une fois allumée, chaque LED bleue consommera 3,3 V.  La tension aux bornes de la résistance sera donc:

9 V - 3,3 V - 3,3 V  = 2,4 V

La résistance doit donc être traversée par un courant de 20 mA lorsqu'elle est soumise à une tension de 2,4 V.

Nous appliquons à nouveau la loi d'Ohm à la résistance:

U = RI

2,4 = R (0,020)

R = 2,4 / (0,020) = 120 ohms

Un calculateur en ligne

Si vous êtes pressé ou paresseux, vous pouvez utiliser une page web qui fera le calcul pour vous.

Yves Pelletier   (TwitterFacebook)

samedi 3 décembre 2016

Robotisation d'une voiture radiocommandée, 2e version

Voici une nouvelle tentative de transformer une voiture radiocommandée (dont on a égaré la télécommande) en un véhicule robotisé autonome.  Une expérience similaire (qui date de quelques mois) impliquait l'utilisation d'une carte Arduino et d'un circuit intégré L293D, et d'un modèle de véhicule comportant deux moteurs.

Une première mise en garde s'impose:  bien que ce type de transformation puisse s'avérer amusante, ces véhicules sont conçus pour rouler plutôt rapidement:  pour cette raison il est peu probable que vous obteniez un résultat comparable à une base de robot spécialement conçue à cette fin.

Le véhicule à modifier

C'est le bas de gamme absolu des véhicules radiocommandés, destiné à de jeunes enfants.  À l'origine, la télécommande ne comportait qu'une manette qui ne pouvait occuper que deux positions: marche avant, ou marche arrière.  Si le véhicule est en marche avant, l'essieu avant s'aligne de façon à permettre un mouvement en ligne droite.  Si le véhicule est en marche arrière, l'essieu avant s'oriente de façon à ce que le véhicule recule en tournant selon un arc de cercle.


La propulsion est assurée par un seul moteur qui fait tourner l'essieu arrière.  Ce moteur est muni d'une roue d'engrenage comportant 10 dents.  Cette roue entraîne la rotation d'une roue d'engrenage de 26 dents, qui est solidaire d'une roue de 8 dents, qui elle-même entraîne la rotation d'une roue de 32 dents qui est collée à l'essieu arrière.  Ce mécanisme permet aux roues du véhicule de tourner environ 10 fois moins rapidement que le moteur (ce qui demeure une vitesse beaucoup plus rapide que celle d'une plate-forme spécialement conçue pour être robotisée).



Le véhicule comporte également un interrupteur marche/arrêt, ainsi qu'un compartiment pouvant contenir 4 piles AA.  Nous espérons pouvoir utiliser ces parties telles quelles à l'intérieur de notre robot autonome.

Comportement souhaité

Les possibilités de ce véhicule sont limitées:  il peut avancer en ligne droite, reculer en tournant, ou demeurer immobile.  Le projet consiste donc à munir le véhicule d'un détecteur de collision: un simple interrupteur fixé au pare-choc avant, qui établira un contact électrique en cas de choc avec un obstacle.

(On peut ajouter une rallonge à la tige métallique pour améliorer la détection)

L'état normal du véhicule consiste donc à avancer en ligne droite.  Mais si il percute un obstacle, il reculera en tournant pendant quelques secondes, puis repartira en ligne droite dans une direction différente de la direction initiale.

Contrainte supplémentaire: pas d'Arduino!

Mon premier réflexe aurait consisté à programmer une carte Arduino pour contrôler le moteur de la façon souhaitée, mais le comportement de notre robot sera tellement minimaliste que j'aurais eu l'impression de tuer un moustique au moyen d'un bazooka.  J'ai donc choisi de concevoir un circuit ne comportant pas le moindre microcontrôleur, comme dans le bon vieux temps.

1er étage:  un 555 en configuration monostable

Lorsque le détecteur de collision est actionné, le véhicule doit se mettre à reculer pendant quelques secondes.   Le détecteur de collision (qui est, rappelons-le, un interrupteur), est donc branché à un 555 configuré en monostable (voir le schéma ci-dessous).


N.B.:  Les schémas prévoient une alimentation de 5 V, mais vous pouvez utiliser une alimentation un peu plus puissante).

En temps normal, pendant que l'interrupteur n'est pas actionné, l'entrée du 555 (pin 2) est à 5 volts et sa sortie (pin 3) est à 0 V.

Mais il s'agit d'appuyer brièvement sur l'interrupteur pour que l'entrée du 555 soit mise à 0 V, ce qui place la sortie à 5 V pendant environ 2,5 secondes.

Cette durée est déterminée par la valeur de la résistance et du condensateur branchés aux pins 6 et 7 du 555:

     durée = 1,1 * R * C = 1,1 * 220 000 * 0,00001 = 2,42 s

Pour que le véhicule recule plus longtemps, il s'agit donc d'augmenter la valeur de la résistance ou la capacité du condensateur.

2e étage:  un amplificateur opérationnel

Nous disposons donc d'une tension qui est nulle quand le moteur doit être en marche avant, et qui devient 5 V lorsque le moteur doit se mette en marche arrière.

Notre pont en H (3e étage), toutefois, comporte deux entrées.  En marche avant, sa première entrée devra être à 5 V pendant que la deuxième sera à 0 V, alors que ce sera le contraire en marche arrière.

Après avoir exploré des solutions comportant un transistor ou une porte NON, j'ai finalement opté pour un amplificateur opérationnel configuré en comparateur de tension.

J'ai choisi le modèle TLC2272, qui fonctionne bien avec une alimentation simple et qui est "rail to rail", c'est à dire que sa tension de sortie est égale à sa tension d'alimentation.  (Dans un premier temps, j'avais utilisé un LM358:  ça fonctionnait, mais la tension de sortie était considérablement plus faible que la tension d'alimentation).


Les deux amplificateurs opérationnels inclus sur le circuit intégré sont utilisés afin de comparer la tension provenant du 555 à une tension de référence de 2,5 V (obtenue au moyen d'un diviseur de tension).

Lorsque la tension provenant du 555 est basse, la tension de sortie de l'amplificateur de gauche est de 5 V, alors que celle de l'amplificateur de droite est de 0 V.  Lorsque la tension provenant du 555 est haute, la tension de sortie de l'amplificateur de gauche est de 0 V, et celle de l'amplificateur de droite est de 5 V.

3e étage:  un pont en H

J'ai fabriqué un pont en H à partir de 4 transistors (pour plus d'informations sur le fonctionnement du pont en H, voir cet article).

J'ai expérimenté différents modèles de transistor et, parmi ceux que j'ai essayés, c'est la combinaison 2N4403 et 2N4401 qui a donné les meilleurs résultats (c'est l'option qui nécessitait la plus faible tension pour faire tourner le moteur).

Et ça fonctionne?

Oui... et non.  Pour faire tourner un moteur, aucun problème.  Le moteur tourne allègrement en marche avant, sauf lorsqu'on appuie sur le bouton, auquel cas il se met en marche arrière pendant 2 secondes et demi avant de se remettre à tourner dans le sens initial.  C'est très exactement ce qu'on espérait.

Les choses se corsent lorsque le moteur en question est chargé de faire avancer le véhicule.  Là, on manque sérieusement de puissance et le couple du moteur est insuffisant à moins d'augmenter l'alimentation à une bonne dizaine de volts­.  Et dire que j'espérais utiliser le compartiment à pile déjà présent sur le véhicule, qui permet d'accueillir 4 piles AA...

Il faut dire que, d'un point de vue mécanique, mon véhicule est une catastrophe:   le système d'engrenages qui transmet le mouvement du moteur vers les roues a tendance à bloquer très facilement, ce qui ne m'encourage pas tellement à poursuivre ce projet...

Sinon, il faudrait tenter d'améliorer le rendement du pont en H.  Tel que mentionné dans cet article du site Robot Room, la qualité des transistors peut faire une énorme différence.

Yves Pelletier   (TwitterFacebook)

lundi 7 novembre 2016

Utilisation de la carte µLogic16 en mode entrée/sortie

Il y a quelques semaines, je vous parlais de la carte µLogic16, conçue en France par BS Electronics. À cette occasion, nous avions exploré le mode logique, qui a la particularité de permettre le contrôle de la carte au moyen d'un schéma de circuit logique (logiciel Logicontrol).

Aujourd'hui, nous allons explorer une autre façon de piloter la carte µLogic16:  il s'agit du mode entrée/sortie, qui permet de contrôler les sorties et de connaître l'état des entrées au moyen de commandes envoyées à partir d'un ordinateur.

Branchement de la carte à l'ordinateur

Il faut d'abord brancher la carte µLogic16 à un port USB de l'ordinateur.  S'il s'agit de votre première utilisation de la carte sur cet ordinateur, les pilotes seront automatiquement installés.



Choix d'un logiciel pour la communication

Pour communiquer avec la carte au moyen d'un ordinateur, n'importe quel logiciel permettant la communication série fera l'affaire: logiControl, putty, TeraTerm, le moniteur série de l'IDE Arduino, etc.

LogiControl

Un avantage d'utiliser logiControl, c'est qu'il a été spécialement conçu pour la carte µLogic16.  Par conséquent, vous n'avez pratiquement aucun réglage à effectuer.

Vous cliquez d'abord sur le bouton "Connect" afin de créer un lien avec la carte.

Vous écrivez ensuite vos commandes dans le champ "Cmd" situé dans le coin inférieur droit de la fenêtre, et vous cliquez sur le bouton "Send" pour les envoyer.

Putty

Si vous préférez utiliser Putty, vous devez choisir "Serial" dans le dialogue de démarrage, en plus de choisir le port série correspondant à la carte (c'était COM13 dans mon cas, mais j'ai dû aller fouiner dans le gestionnaire de périphériques pour le savoir) et une vitesse de 115200 bauds.


Cliquez ensuite  sur "Serial" dans la liste de gauche.  Les informations qui apparaissent dans cette fenêtre doivent être Data Bits:  8, Stop Bits:  1, Parity:  None et Flow control:  None.




Moniteur série Arduino

Si vous êtes déjà familier avec la programmation d'Arduino, nul besoin d'installer un nouveau logiciel:  le moniteur série de l'IDE Arduino fera parfaitement l'affaire.

Après avoir démarré le logiciel, il faut sélectionner le port série qui correspond à la carte µLogic16.


On affiche ensuite le moniteur série, puis on règle la vitesse de communication à 115200 bauds, et on sélectionne l'option "Retour de chariot".



Envoi de commandes à la carte

Dans un premier temps, nous sélectionnons le mode "entrée/sortie" en envoyant la commande "MODE IO"
(La carte répond "OK")




Pour vérifier rapidement que tout fonctionne correctement, allumons la LED "user" intégrée à la carte:  il s'agit d'envoyer le message "LEDON" (si tout va bien, la carte répond "OK" et la LED s'allume).  On peut éteindre la LED à nouveau en envoyant la commande "LEDOFF".



Réglons les 8 pins du port A pour qu'elles soient des entrées.  La commande à envoyer est "PORTA IN".   (La carte devrait encore répondre "OK").

Pour lire l'état de l'entrée 0 du port A, on écrit "READ PA0".  La carte répond "1" si l'entrée est à 5 V, et "0" si l'entrée est à 0 V.  Nous pouvons évidemment lire de la même façon l'état des entrées PA1, PA2, etc.




Réglons maintenant les 8 pins du port B pour qu'elles soient des sorties, en écrivant la commande "PORTB OUT".   (La carte répond "OK")

Pour régler la sortie 0 du port B à 5 volts, on écrit "SET PB0".   Pour la régler à 0 volt, on écrit "CLR PB0".



Pour la liste complète des commandes, veuillez vous référer au manuel d'instruction de la carte µLogic16.

Yves Pelletier   (TwitterFacebook)

lundi 31 octobre 2016

Utilisation du "Data Logging Shield" (Arduino)


Je me souviens d'une époque (pas si lointaine) où je n'achetais pratiquement jamais de shield pour Arduino, parce que les prix me semblaient inutilement élevés.  Ainsi, lors de la réalisation d'un montage destiné à compiler des mesures de températures et de luminosité, j'avais utilisé, en plus des capteurs nécessaires,  un module RTC (horloge temps réel), un lecteur de carte SD, un convertisseur de niveau logique (requis par le lecteur de carte SD), etc.

J'avais alors fait remarquer qu'un shield tout fait était vendu par Adafruit, mais au prix de 14 USD, ça me semblait un luxe inutile.

Les temps ont bien changé.  De nos jours, vous pouvez facilement trouver sur eBay des clones du Data Logging Shield conçu par Adafruit pour aussi peu que 3 USD (frais de port inclus).

Résultat:  de nos jours, même pour un radin comme moi, il n'y a aucune raison de se priver d'un data logging shield prêt à l'utilisation.

Le shield comporte un lecteur de carte SD, une horloge temps réel et un convertisseur de niveau logique, en plus de deux LEDs que vous pouvez, au besoin, lier à la pin Arduino de votre choix.  Il ne reste donc plus qu'à brancher les capteurs.

L'horloge

Pour que l'horloge temps réel DS1307 fonctionne correctement, il faut insérer une pile CR1220 (qui n'était pas fournie avec le shield que j'ai acheté).  Cette horloge utilise le protocole i2c.

Pour utiliser l'horloge, vous devez installer la bibliothèque RTClib, qui n'est généralement pas incluse avec l'IDE Arduino.  Le sketch d'exemple "ds1307" fourni avec la bibliothèque vous permettra de vérifier que votre horloge fonctionne correctement (si elle n'affiche pas l'heure et la date correcte, exécutez l'exemple "ds1307" après avoir décommenté la ligne "RTC.adjust(DateTime(__DATE__, __TIME__));"





Le lecteur de cartes SD

Le lecteur de carte SD utilise quant à lui le protocole SPI.  La bibliothèque SD est déjà installée par défaut avec l'IDE Arduino.  Pour vous assurer que le lecteur fonctionne correctement, vous pouvez exécuter le sketch "CardInfo" fourni avec la bibliothèque SD...


...mais attention:  dans ce sketch, vous devez modifier la constante "chipSelect" et lui assigner la valeur "10".


Les LEDs indicatrices

Le shield comporte également deux LEDs (L1 et L2) qui peuvent être connectées à n'importe quelle sortie de l'Arduino.  Grâce à deux petits bouts de fil conducteur, j'ai relié la LED "L1" à la sortie 5 de l'Arduino, et la LED "L2" à la sortie 4 (un fer à souder est requis ici).

Ces LEDs peuvent être utilisées pour vous permettre de savoir si votre data logger fonctionne correctement lorsqu'il n'est pas connecté à un ordinateur (une LED peut s'allumer ou clignoter pendant que les mesures sont prises, une autre peut indiquer la fin de la prise de mesure, etc.).

Un exemple de sketch

Pour cet exemple de sketch, j'ai supposé la présence de deux capteurs analogiques branchés respectivement aux entrées A0 et A1 du shield.  Il ne vous restera qu'à adapter le code pour qu'il gère les capteurs qui vous conviennent, peu importe qu'ils soient analogiques ou numériques.

Des mesures sont prises toutes les 10 secondes:  il est facile de modifier cette fréquence, stockée dans la constante "DELAI_MESURES".

Chaque fois qu'une mesure est prise, elle est affichée dans le moniteur série, si ce dernier est actif (ce qui sera surtout utile pour vérifier le fonctionnement correct du dispositif).  De plus (et surtout), elle est enregistrée dans un fichier "csv" ("comma separated values") qui pourra facilement être ouvert et traité avec un tableur comme, par exemple,  Excel.  Notez que j'utilise la convention qui permettra aux fichiers d'être correctement interprétée par la version française d'Excel:  les données sont séparées par des points virgules plutôt que par des virgules.

La LED "L1" clignote pour indiquer que le data logger est en fonctionnement (si vous oubliez d'insérer une carte SD lors du démarrage du sketch, la LED ne s'allumera pas).

La LED "L2" s'allume temporairement chaque fois que le data logger effectue des mesures et les enregistre sur la carte SD.



Voici ce qu'affiche le moniteur série pendant la prise de mesures:


Et voici le fichier "RAPPOR00.CSV" qui a été enregistré sur la carte SD, après ouverture dans Excel:


Les données peuvent ensuite être présentées sous forme de graphiques.



Yves Pelletier   (TwitterFacebook)

dimanche 23 octobre 2016

Une première exploration de la carte µLogic16


µLogic16 est une carte d'interface mise au point en France par BS Electronics. Particularité intéressante: elle est accompagnée d'un logiciel (LogiControl) qui permet  de la piloter au moyens de représentations schématiques de circuits logiques.

Son concepteur m'en ayant gentiment expédié un exemplaire, je partage aujourd'hui mes premières expérimentations avec cette carte.

La carte µLogic16

Basée sur le microcontrôleur STM32F33, la carte mesure 4 cm X 5 cm (un peu plus que la moitié d'une carte Arduino).  Elle comporte deux ports qui peuvent être configurés en entrée ou en sortie (8 entrées/sorties par port).   Les connecteurs sont de robustes borniers à vis.

Lorsque vous branchez la carte à un ordinateur pour la première fois (par son connecteur mini usb), les pilotes nécessaires sont automatiquement installés.



Le logiciel Logicontrol

On peut télécharger le logiciel sur la page de BS Electronics.  Il s'agit ensuite d'exécuter l'application "LogiControl.exe" (Windows seulement).

Une fois dans l'application, un clic sur le bouton "Connect" crée un lien entre l'application Logicontrol et la carte µLogic 16.



Premier projet:  faire clignoter une LED

Puisque la carte comporte une LED verte qui peut être contrôlée par l'utilisateur, notre premier essai consistera à faire clignoter cette LED.

Nous allons donc créer un nouveau fichier (Menu File / New)...


On choisit une destination et un nom pour le fichier, on règle "Device" à "µLogic16", puis on clique sur le bouton "Create".


Ici, les choses deviennent intéressantes:  les entrées/sorties des deux ports apparaissent à l'écran, ainsi que la LED intégrée à la carte.  De plus, de nouveaux menus nous permettent d'ajouter des composants sur le schéma.


Dans le menu "Special", on trouve un article intitulé "Clock":


...ce menu permet de faire apparaître une horloge réglée par défaut à une fréquence de 1 Hz (cliquez là où vous voulez placer l'horloge).
En cliquant sur les deux terminaux (19 et 18), on peut relier l'horloge à la LED:

Ce schéma devrait être suffisant pour faire clignoter la LED à une fréquence de 1 Hz (si cette fréquence ne vous convient pas, un clic droit sur le schéma de l'horloge vous permettra de la modifier).

Il nous reste à transmettre l'information à la carte µLogic 16.  Pour ce faire, vous cliquez d'abord sur le bouton "Import", et vous choisissez "From Schematic":


Puis, vous cliquez sur le bouton "Program Device".

Mission accomplie:  la LED verte intégrée sur la carte se met à clignoter.

Deuxième projet:  des boutons, des LEDs et des portes logiques

Dans un deuxième temps, j'ai voulu ajouter un peu d'interactivité tout en testant les entrées et sorties de la carte.  Le but, cette fois, est de contrôler deux LEDs au moyen d'un même bouton poussoir:  une première LED qui est habituellement éteinte mais qui s'allume lorsqu'on appuie sur le bouton, et une deuxième LED qui est habituellement allumée mais qui s'éteint lorsqu'on appuie sur le bouton.

Le circuit réel construit sur breadboard consiste en un bouton poussoir qui permettra de contrôler l'entrée 0 du port A de la carte, et de deux LEDs qui seront contrôlées respectivement par les sorties 0 et 3 du port B.



Construisons maintenant le circuit virtuel, dans Logicontrol, qui déterminera le comportement de la carte µLogic16.

Après avoir créé un nouveau fichier (menu File / New)...



...je fais un clic droit sur la représentation du port B, afin de le configurer en mode "sortie" (output):


Un second clic droit sur le port B me permet de le déplacer face au port A (après avoir cliqué sur le bouton "move":


Pour que la sortie B0 prenne systématiquement le même état logique que l'entrée A0, je clique sur le connecteur de A0, et ensuite sur le connecteur de B0:



Dans le menu "Gate", je sélectionne une porte NON (Not):


... que je déplace entre A3 et B3.


Je clique entre la sortie de la porte NON et la sortie B3, afin de les relier entre elles.  Je clique également sur l'entrée de la porte NON et le câble qui relie déjà A0 et B0:


De cette façon, la sortie B3 de la carte sera systématiquement dans l'état logique contraire à celui de l'entrée A0.

Il ne reste plus qu'à essayer notre circuit:  on clique sur le bouton "Import", puis sur "From Schematic", et finalement sur "Program Device".

Résultat, tel que prévu:  une des LEDs installées sur la breadboard s'allume quand on appuie sur le bouton et s'éteint lorsqu'on relâche le bouton.  L'autre LED est allumée quand le bouton est relâchée, et éteinte quand on appuie sur le bouton.

Troisième projet:  un compteur binaire 8 bits


Dans cette troisième expérience exploratoire, j'ai utilisé le compteur binaire 8 bits offert dans le logiciel Logicontrol.


Cette fois, le circuit réel sur breadboard est constitué de 8 LEDs, chacune d'entre elle étant contrôlée par une des sorties du port B de la carte µLogic16.




Pour la construction du circuit virtuel dans le logiciel Logicontrol, il faut choisir un compteur (Counter) dans le menu "Component".


On ajoute ensuite une horloge ("Clock", dans le menu "Special") qu'on relie à l'entrée "CK" du compteur, et on relie chaque sortie du compteur à une pin du port B (qui a préalablement été configuré en sortie):


Comme c'était le cas dans les projets précédents,  on clique sur le bouton "Import", puis sur "From Schematic", et finalement sur "Program Device".

Sur la breaboard, les 8 LEDs s'allument en alternance de façon à présenter les nombres binaires de 0 jusqu'à 255.

Pour pous d'informations:  BS Electronics


Yves Pelletier   (TwitterFacebook)
Related Posts Plugin for WordPress, Blogger...