Plusieurs boutons sur une seule entrée Arduino

head

Si pour un projet Arduino vous venez à manquer de broches d’entrée/sorties mais qu’il vous faut encore ajouter quelques boutons de commande, cette astuce va surement vous intéresser.

 

6 boutons sur 1 entrée Arduino

 

La technique est simple et ne nécessite pas forcément un Arduino pour fonctionner, n’importe quel microcontrôleur fera l’affaire.

On utilise un pont diviseur de tension dont une des deux résistances est en réalité un jeu de résistances de valeurs différentes qui sont connecté par le biais de boutons poussoirs.

On utilise une entrée analogique du microcontrôleur pour lire la valeur de la tension à la sortie du pont diviseur. Cette tension est bien sûr dépendante du bouton sur lequel on appui, ce dernier peux donc être retrouvé facilement grâce à quelques ligne de code.

Voici un schéma pour mieux comprendre :

Copie de s8-page-001

Fig.1 : Schéma du pont diviseur multiple

 

La technique consiste alors à mesurer la valeur donnée par le convertisseur analogique-numérique du microcontrôleur pour chaque boutons poussoir.

Voilà un exemple avec un Arduino Nano (CAN 10 bits et VCC = 3,3V) :

Bouton appuyé

BP 1

BP 2

BP 3

BP 4

BP 5

BP 6

Aucun
Valeur de sortie

0

65

180

305

485

670

1023

Fig.2 : Tableau des valeurs de sortie du convertisseur analogique-numérique pour le montage de la fig.1

 

Il s’agit enfin de tester la valeur donnée par le CAN avec une valeur prise au milieu de l’écart de valeur entre deux boutons poussoir afin avoir une bonne marge :

Valeur = analogRead(A0);

if (Valeur< 32)   Serial.println("BP 1);

else if (Valeur< 119)  Serial.println("BP 2); 
else if (Valeur< 232)  Serial.println("BP 3; 
else if (Valeur< 368)  Serial.println("BP 4); 
else if (Valeur< 572)  Serial.println("BP 5); 
else if (Valeur< 846)  Serial.println("BP 6); 
else if (Valeur> 846)  Serial.println("Aucun");

Dans cet exemple j’affiche simplement dans la console série le numéro du bouton qui a été pressé mais libre à vous d’y faire ce que vous voulez.

 

6 boutons + interruption sur 2 entrées Arduino

 

Parfois il se peut que votre programme soit occupé par une tache, et pendant ce temps-là vous ne pouvez pas utiliser les boutons poussoirs connectés à votre microcontrôleur.

Heureusement celui-ci dispose de broches d’interruptions matérielles. Lorsque l’une d’elle est activée, au moindre changement d’état de celle-ci, le programme se met en pause pour exécuter une fonction particulière que vous pouvez définir.

Lorsque cette fonction a fini de s’exécuter le programme reprend là où il s’était arrêté.

On utilise le même montage que précédemment mais avec une porte OU à diode qui permet d’actionner l’interruption dès que l’un des boutons poussoir est pressé.

s8-page-001

Fig.3 : Schéma du pont diviseur multiple avec diodes d’interruptions

 

Par exemple, pour un Arduino UNO, les broches D2 et D3 peuvent être configurés avec une interruption1. Dans notre cas nous paramétrons l’interruption pour quelle se déclenche sur niveau bas :

attachInterrupt(0, Fonction_interruption, LOW); //interruption sur broche D2 (interrupt 0)

La fonction “Fonction_interruption()” est appelée dès que la broche D2 passe à l’état bas (LOW).

Voici le programme complet :

const byte bouton = A0;  //Entrée analogique des 6 boutons
byte BP_appuye = 0;  //Variable stockant le bouton appuyé

 

void setup() {
  pinMode(bouton, INPUT); //entrée analogique des boutons réglée en entrée
  attachInterrupt(0, InterruptBouton, LOW); //interruption sur pin D2 (interrupt 0)
}

 

void loop()    {

 

}

 

void InterruptBouton()  {
  int ValeurBouton = analogRead(bouton);
  if (ValeurBouton < 32) BP_appuye = 1;
  else if (ValeurBouton < 119) BP_appuye = 2;
  else if (ValeurBouton < 232) BP_appuye = 3;
  else if (ValeurBouton < 368) BP_appuye = 4;
  else if (ValeurBouton < 572) BP_appuye = 5;
  else if (ValeurBouton < 846) BP_appuye = 6;
  else if (ValeurBouton > 846) BP_appuye = 0;
}

Comme vous pouvez le voir je n’ai rien mis dans la fonction Arduino loop, à vous d’y placer votre programme.

 

Références :

Construction d’un système d’alarme (Partie 3)

ba

Dans la première partie je vous avais rapidement exposé le projet tandis que dans la deuxième, j’avais fait du shoping pour trouver les composants nécessaires au module de détection de mouvement.

 

Dans cette troisième partie j’aimerais vous parler plus en détail du circuit imprimé, de la tentative de réduction de consommation du système et de la programmation associée.

 

J’avais commencé par graver moi-même un premier prototype du circuit imprimé du détecteur de mouvement grâce à la technique dont je vous avais parlé il y a quelques mois.

 

RevB_circuit imprimé

Figure 1 - Capture du logiciel Fritzing, circuit du détecteur de mouvements

 

Le cœur du circuit est un microcontrôleur Atmel ATMEGA328. Celui-ci communique avec un module radio nRF24L01+ par l’intermédiaire d’un bus SPI.

 

Après avoir validé ce circuit, je l’ai fait fabriquer afin que celui-ci ait une apparence plus professionnelle et soit plus résistant.

J’ai utilisé le service d’Elecrow qui m’a permis d’avoir 10 copies de cette carte pour un prix d’environ 13€.

 

clip_image004 clip_image006

Figure 2 - Photos recto/verso du circuit imprimé

 

Je voulais tester un circuit imprimé de couleur blanche, et je trouve que ça rend super bien. En revanche les pistes ne sont plus très visibles et le circuit est bien plus salissant lors de la soudure.

 

Monté, le circuit est identique au prototype :

clip_image008

Figure 3 - Photo de l'intérieur du module de détection de mouvement monté

 

Comme expliqué dans la partie 2, j’ai préféré utiliser plusieurs modules tout fait plutôt que de réaliser ces circuits moi-même :

· Un circuit de charge de la batterie Lithium-ion par USB

clip_image009

· Le circuit de traitement du signal du capteur de mouvement (PIR)

clip_image010

· Le circuit du module radio nRF24L01+

clip_image011

Cela permet de diminuer la complexité du travail et surement même d’économiser de l’argent.

 

Concernant la consommation du module, j’utilise maintenant la bibliothèque Arduino Low-power.

Elle me permet de faire chuter la consommation électrique grâce à un système d’interruption.

 

Le petit circuit du détecteur de mouvement infrarouge que j’utilise contient un circuit de traitement de signal et offre une sortie de type tout-ou-rien. C’est-à-dire que lorsque que le capteur voit quelque chose devant lui, sa sortie est à l’état 1 (5V) et s’il ne vois rien sa sortie est à 0.

clip_image013

Figure 4 - Photo du dos du module de détecteur infrarouge (PIR)

 

Cette sortie tout-ou-rien est reliée à la broche D2 du microcontrôleur Arduino. Cette broche dispose d’une fonction d’interruption, c’est-à-dire qu’elle peut réveiller l’Arduino lorsque qu’un changement d’état lui est appliqué.

 

L’Arduino est donc plongé dans un sommeil très peu consommateur d’énergie jusqu’à ce que le module infrarouge détecte un mouvement et fasse changer d’état cette broche d’interruption.

 

En utilisant la bibliothèque « sleep » standard, j’obtenais une consommation en veille de 180µA sous 4,2V. Maintenant la consommation chute à 70µA, ce qui nous fait en théorie une autonomie de 2 ans et 3 mois pour une batterie de 2Ah.

L’autonomie réelle n’attendra surement jamais ça, mais la facilité de rechargement des détecteurs (une simple prise USB comme un téléphone) l’emporte.

 

Elément

Consommation en veille sous 4,2V

Microcontrôleur ATMEGA328

11µA

Module radio nRF24L01+

1,8µA

Capteur PIR

57µA

Figure 5 - Consommation électrique des différents éléments du module de détections de mouvements

 

Le système n’est bien évidement pas toujours en veille, voici les différentes phases de fonctionnement et leur consommation associés. Je n’ai pas pu chronométrer la durée de ces phases mais elles sont extrêmement courtes :

 

Veille

Mouvement détecté, envoi de l’alerte

Mise en veille

Veille

70µA

240µA

170µA

70µA

Figure 6 - Phases de fonctionnements et leur consommation

 

Et pour finir voici le programme Arduino utilisé : Programme détecteur de mouvement.

 

A bientôt.

Construction d’un système d’alarme (Partie2)

ban

Cet article est la suite de l’article Construction d’un système d’alarme (Partie1).

 

J’avais terminé la première partie avec une simple communication sans fil entre deux Arduino, aujourd’hui je vais vous présenter une partie de la solution matérielle que j’ai choisie ainsi qu’un prototype du logiciel.

 

Comme dit précédemment j’ai choisi la plateforme Arduino pour sa facilité de programmation. Les différents modules de l’alarme intègreront un microcontrôleur Atmel ATMega328. La communication sans fil se fera à l’aide de modules nRF24L01+.

 

Les modules capteurs de mouvement :

 

Les modules capteurs de mouvement seront des petits modules sans fil et autonome placé de manière stratégique dans mon habitation, j’en prévois pour l’instant 5 pour surveiller les zones proches des entrées (portes et fenêtres).

 

Le capteur infrarouge (P.I.R.) :

 

Comme je vous l’ais dis, je cherche à créer un système simple et peu cher.

Voici le capteur de mouvement que j’ai utilisé :

pir

 

C’est un module de 25*35mm qui comprend un capteur infrarouge et une lentille permettant un grand angle de vision (le dôme).

 

Pour un lot de 10, ce genre de module me coute 0,75€ par pièce sur le site Alibaba.

 

Le module comprend une puce permettant de traiter le signal et de m’indiquer simplement par un 1 logique si il y a un mouvement ou par un 0 si tout est calme.

 

Accumulateur 18650L’alimentation électrique :

 

Le détecteur de mouvement doit pouvoir fonctionner sans être recharger pendant plusieurs mois, pour cela j’utilise un accumulateur au lithium de type 18650.

Celui-ci délivre une tension nominale de 3,7V et possède une capacité de 2,6Ah.

Le ordinateur portables traditionnels en contiennent souvent 4 ou 8, j’ai récupéré les miens mais ils coutent environs 5€ pièce.

 

 

Porte AccuLa consommation totale au repos est d’environ 180µA, ce qui, en théorie permettrait d’alimenter le détecteur de mouvement pendant 1 an et 8 mois. Ce fameux accumulateur est placé dans un socle adapté, acheté pour 0,50€ pour un lot de 10 sur Alibaba.

 

 

Enfin, pour recharger cet accumulateur j’utilise un petit module de charge qui accepte un câble mini-USB d’un côté et une batterie lithium de l’autre. Cela me permet de recharger très facilement ces détecteurs de mouvement.Chargeur Lithium

Ce module coute 0,60€ pour un lot de 5 encore sur Alibaba.

 

 

Le boitier

 

Je devais choisir un boitier assez petit pour que le détecteur de mouvement reste assez discret mais assez grand pour accueillir tous les éléments.

Boitier

Le boitier choisi est en plastique noir, il mesure 100*60*30mm et tous les éléments rentrent parfaitement dedans.

Ce boitier coute 1,81$ sur le site FastTech.

 

J’ai fait un trou rond sur le dessus pour y laisser passer la lentille du capteur infrarouge. Et un deuxième trous sur la tranche du bas pour y faire passer le port mini-USB de recharge.

 

 

2014-11-11 15.05.25

J’ai essayé aussi une version blanche (dont j’ai un peu raté le trou rond du capteur infrarouge).

 

 

 

 

 

 

 

 

 

 

 

 

Le circuit électronique

 

Voici le schéma (moche) du système :

schema

Comme vous pouvez le constater, j’utilise un régulateur 3,3V de type MCP1700 pour alimenter l’émetteur sans fil nFR24l01+ et le capteur infrarouge (PIR).

Le microcontrôleur en revanche est directement alimenté par l’accumulateur.

 

J’ai utilisé la méthode de création de circuit imprimé dont je vous avais parlé il y a quelques temps pour faire un prototype. Voilà à quoi ça ressemble après que tous les éléments soit monté :

2014-11-11 19.25.01

 

Le programme

 

Le programme du capteur de mouvement est très simple :

Lorsque le capteur infrarouge (PIR) détecte un mouvement, sa sortie est à 1. Cette sortie est branchée sur le microcontrôleur, et dès que celui-ci détecte cet état logique haut, il se réveil et envoi une alerte grâce au module de communication sans fil.

Dès qu’il n’y a plus de mouvement, celui-ci envoi un deuxième message pour en informer le central. Puis il se met en veille.

Ce programme utilise la bibliothèque Arduino Mirf.

 

Le lien du programme Arduino : Mouvement.ino

 

Ce programme est bien sûr un prototype, en effet celui-ci se contente d’envoyer une simple valeur pour alerter le central.

 

Le test

 

J’ai monté un prototype du central, avec deux LED indiquant lequel des deux capteurs que j’ai construits a détecté un mouvement : (Ne faite pas attention à la carte Neoduino, c’est simplement un Arduino avec une breadboard).

2014-11-11 19.56.35

Le programme répond bien et la porté est très bonne (couvre tout mon domicile).

 

Voilà ! C’est tout pour aujourd’hui. A bientôt pour la suite de ce projet.

Construction d’un système d’alarme (Partie1)

ban

J’ai décidé il y a peu, de me construire mon propre système d’alarme. En plus d’un besoin de protéger mon lieu d’habitation (ou du moins de m’alerter d’une présence) je pense que ce projet me permettra d’apprendre et d’expérimenter pas mal de chose.

 

Mon but est d’utiliser des composants peu chers et facilement utilisables. J’ai par exemple choisi d’utiliser des microcontrôleurs AVR compatibles avec le logiciel Arduino pour me faciliter la tâche.

 

J’envisage différents modules qui communiqueront ensemble par radiofréquences :

  • Des modules de détection (chiens de garde) : capteurs de mouvement ou d’ouverture, voire de fumée.
  • Un module que j’appellerai « portier ». Placé à cote de la porte d’entrée, permet d’activer et de désactiver le système d’alarme.
  • Un central, connecté au réseau mobile pour me prévenir par SMS d’une intrusion. Relié également à une sirène extérieure.

 

Le chalenge est de faire des modules sans fils et, pour les modules de détection, alimentés par des accumulateurs électriques. La durée de vie de ces derniers devra être de quelques années.

 

Je tiens également à créer des interfaces intuitives et un système facile à utiliser pour les autres personnes de la maison.

 

Voici un schéma rapide du système que je compte réaliser :

CCI20092014_00001

 

 

Communication sans fils :

 

La communication sans fils se fera grâce à des modules émetteur-récepteur nRF24L01+. Ce sont des modules radiofréquences à 2,4GHz assez faciles à mettre en place et avec une très faible consommation compte tenu de leurs capacités. En plus ils ne coutent pas cher.

 

image

 

Ma première expérience avec ces modules a été d’allumer une LED à distance. Pour cela j’utilise deux Arduino et la bibliothèque Mirf.

image41N5J94JbUL._SX300_

Ces modules utilisent le bus SPI de l’Arduino (SCK-MOSI-MISO) et deux autres ports qui sont configurables (CE et CSN) et sont par défaut sur D9 et D10 dans la bibliothèque Mirf.

Attention ces modules peuvent être alimenté uniquement en 3,3V. Les ports d’entrée/sortie sont néanmoins compatibles avec un microcontrôleur 5V.

 

 

Comme vous l’avez peut-être remarqué ces modules nRF24L01+ sont peu pratiques à utiliser sur une plaque de prototypage (breadboard), j’ai donc fabriqué des petits adaptateurs.

2014-09-20 22.33.55

Pour tester la liaison il suffit de flasher le programme d’exemple de la bibliothèque Mirf nommé « ping_server » sur le premier Arduino et « ping_client » sur le deuxième. Ouvrez ensuite un moniteur série et vous pourrez voir le délais en millisecondes qu’il y a dans la communication entre les deux Arduino.

 

Voila, le projet en est à ce stade aujourd’hui. J’espère pouvoir vite poster la suite.

 

Liens utiles :

[Arduino] Transmission valeur analogique par nRF24L01+, sur skyduino.wordpress.com

Low-Power Wireless Sensor Node, sur maniacbug.wordpress.com

nRF24L01, sur playground.arduino.cc

Créer un circuit imprimé rapidement

banniere
J’ai trouvé il y a peu une technique de gravure de circuit imprimé que je trouve excellente, non seulement elle utilise des produits disponibles dans tout les magasins de bricolage pour pas trop cher mais en plus elle permet une précision remarquable. Je  partage donc cette technique avec vous.

La technique consiste à imprimer le circuit sur du papier glacé avec une imprimante laser pour ensuite le transférer sur la plaque de cuivre avec un fer à repasser. Puis enfin graver le cuivre avec un mélange particulier.

/!\Cette technique présente un danger puisqu’elle nécessite l’emploi de produits nocifs. Il faudra donc porter des gants, des lunettes et ne pas respirer les vapeurs/!\


Il vous faudra un petit peu de matos :
  • Une plaque cuivré en époxy, bakélite ou autre avec du cuivre sur une seule face. J’achète les miennes chez Tayda pour 1,4€ la plaque de 15*15cm.
  • Une imprimante laser. C’est très important car c’est le toner de l’imprimante qui vas protéger les pistes que vous voulez tracer.
  • De l’acide chlorhydrique  à environs 30%. Produit nocif, utilisé notamment dans le traitement des piscines.
  • De l’eau oxygénée à 130 volumes. Produit nocif, utilisé notamment pour le blanchissement du bois.
  • De l’eau du robinet, aussi appelée monoxyde de dihydrogène, vous en avez surement déjà bu (-:
  • Du papier glacé type papier publicitaire.
  • Un fer à repasser, usé de préférence, la manipulation risque de le salir, vos chemises seront crades sinon, c’est pas top.
  • Des bocaux en verre, pour verser les différents réactifs. Anciens pots de moutarde acceptés.
  • Une grosse cuillère pour faire les dosages.
  • Un récipient où placer votre circuit imprimé pour la réaction. J’utilise un truc plat de peinture, très pratique et permet de ne pas gâcher des réactifs.
  • De l’acétone pour nettoyer le toner après la gravure.
  • Un papier à poncer avec des petits grains comme du 40 ou du 80.
  • Une petite perceuse/visseuse ou un outils de type dremel avec un support à colonne pour faire les trous des composants.
  • Un foret de 1mm. J’utilise des foret pour le métal.
  • Un logiciel de conception de circuit imprimé comme Fritzing que j’utilise pour sa simplicité.
La première chose à faire est réaliser ou récupérer le typon (image du circuit imprimé) que vous souhaitez graver.
J’utilise le logiciel Fritzing que je trouve très simple d’utilisation et qui permet de créer un fichier pdf du circuit que vous pouvez imprimer directement.
fritzing
Il existe des tas de tutoriel notamment sur le site Fritzing pour apprendre à le faire.

Un conseil, moins il a de cuivre à enlever et plus la réaction sera rapide et efficace, penser donc à remplir de cuivre toutes les parties du circuit où il n’y à pas de piste (remplissage de la masse), comme sur l’image ci dessous :
plan_de_masse
Je vous conseille une largeur de piste minimale de 24mil (1mil = un millième de pouce). Des pistes plus fines fonctionnerons parfois très bien mais c’est plus sûr pour commencer.
Vous pouvez également bien sûr récupérer un fichier d’un circuit déjà fait sur internet.

Il s’agit maintenant d’imprimer ce typon sur le papier glacé avec votre imprimante toner. Si le papier glacé que vous avez découpé d’un magazine n’as pas la taille d’une feuille A4 vous pouvez le coller avec un bâton de colle sur une feuille de papier.
Vous devez également penser à l’imprimer dans le bon sens car la face avec les pistes de cuivre est la face inférieur. Avec Fritzing il faut juste imprimer la face inférieur dans le sens normal.
Avant de lancer l’impression pensez à régler votre imprimante de façon à ce qu’elle crache le plus de toner possible, désactiver l’économie de toner, pousser la densité et la résolution à fond.

Vous voila avec votre circuit imprimé sur votre feuille de papier glacé. La prochaine étape consiste à transférer le toner à l’aide d’un fer à repasser.
Placer l’image du circuit contre la face cuivré du circuit que vous aurez préalablement découpé avec une scie à métaux ou un dremel par exemple et légèrement poncé et nettoyé à l’acétone.

Appliquez le fer à repasser réglé sur la plus haute température sur l’ensemble. Pas besoin de bouger le fer s’il est assez grand mais vous pouvez un peu appuyez dessus. Un conseil, ne faites pas ça sur une table à repasser mais plutôt sur un établi.
Le toner va se transférer sur la face cuivrée en environs 3 minutes de chauffe. Vous n’avez aucun moyens de vérifiez que c’est prêt mais l’opération n’est pas définitive, vous pouvez donc réimprimer le circuit et recommencer si le toner ne s’est pas complètement transféré.
fer

Ensuite placer votre plaque sous l’eau du robinet, utilisez un peu de savon pour aider à retirer le papier. Fait attention au toner car il est un peu fragile. Vous devriez vous retrouver avec quelque chose comme ça :
IMG_20140116_204734
Si le circuit n’est pas bien imprimé, frottez le tout avec le papier à poncer et recommencez.

L’étape suivant est la plus dangereuse, enfilez donc vos gants, lunettes et si possible masque de protection.
Commencez par préparer le matériel :
matosbac

Sachez que pour 1 litre d’acide chlorhydrique et 1 litre d’eau oxygénée vous en aurez pour environs 10€ en magasin de bricolage et vous pourrez réaliser des dizaines de circuits.
Ne faites le mélange qu’au dernier moment car il ne se conserve pas et n’est utilisable qu’une fois.
Le mélange dans les proportions normales est le suivant :
  • 4 doses d’eau du robinet
  • 2 doses d’acide chlorhydrique
  • 1 dose d’eau oxygénée

Et toujours dans cet ordre. Ne versez jamais de l’eau dans de l’acide !

En fonction de votre récipient, vous devrez peut-être utiliser plusieurs fois ces doses. C’est pourquoi le récipient à peinture (voir photo au dessus) est bien utile.

Plongez ensuite votre plaque dans le mélange, des petites bulles devraient apparaitre. Vous pouvez tout au long de la gravure remuer un peu le mélange.
Le temps de gravure dépend des quantité d’acide et d’eau oxygénée mais aussi de la surface de cuivre à dissoudre. J’ai pour habitude de laisser la plaque environs 10 minutes. La gravure est terminée lorsque vous ne voyez absolument plus de cuivre. Vous pouvez sortir la plaque à l’aide d’une pince pour observer l’avancement.

Après la gravure placez la plaque dans de l’eau du robinet pour stopper la réaction.
Vérifiez qu’il ne reste pas de cuivre visible, vous pouvez replonger un peu la carte s’il en reste.

Il s’agit maintenant d’enlever le toner qui reste sur les pistes, pour cela prenez un essuie-tout et mettez un peu d’acétone dessus puis frottez la carte jusqu'à ce qu’il n’y ais plus une trace de toner :
IMG_20140116_213512
Votre circuit imprimé est maintenant presque prêt, il ne vous reste plus qu’à percer les trous et à souder les composants.
Pour le perçage j’utilise un dremel monté sur un support à colonne mais j’ai aussi déjà testé, et c’est faisable avec une petite perceuse/visseuse qui ne tourne pas trop vite. Utilisez un foret de 1mm.
dremel


Et voila, avec ça vous pouvez créer n’importe quel circuit simple face en peu de temps et d’argent.

Un écran HD44780 sur bus I2C

1407906-1360x768-[DesktopNexus.com]_thumb[32]

Les écrans HD44780 sont surement les plus utilisés dans le monde de la bidouille Arduino, notamment grâce au fait qu'ils soient peu chers (3€ en chine et environs 10€ chez nous) et plutôt simples à utiliser.

Le problème de ces écrans est le fait qu'ils utilisent un bus de données parallèle sur 4 bits et que 2 bornes de plus sont nécessaire à leur fonctionnement. On se retrouve donc avec un écran qui a besoin de 6 pins de notre microcontrôleur pour fonctionner. L'Arduino par exemple ne possède que 14 pins, ce qui en consomme presque la moitié.

Heureusement la plupart des microcontrôleurs (dont celui de l'Arduino) possède un bus I²C qui une méthode de connexion très simple sur seulement 2 bornes et sur lequel on peut connecter un grand nombre de périphérique. Donc sur ces 2 bornes I²C on va pouvoir connecter
une horloge par exemple ou dans notre cas, un extenseur 8 bits pour faire fonctionner notre écran.

Cet extenseur 8 bits est le PCF8574, il coute entre 1 et 2€. C'est un composant traversant de 16 pins. Il en existe différentes variantes comme le PCF8574AP que j'ai, mais ils fonctionneront tous de façon similaire.
Voici le montage simple : Ce montage requière un potentiomètre de 10KOhm pour régler le contraste de l'écran.



Le PCF8574 possède 3 bornes d'adresse pour permettre d'utiliser par exemple plusieurs écrans sur les même bornes I²C.

Ces 3 broches sont A0, A1 et A2 (voir schéma ci-dessous). Si vous désirez n'utiliser qu'un seul écran, il faut mettre ces trois broches sur 0v. Ce qui donne une adresse 0x38 pour les PCF8574A et 0x20 pour PCF8574.


Je me suis donc fabriqué une petite carte d'essai avec tout le nécessaire dessus :


Voici le schéma des bornes de l'écran LCD HD44780:

Pour information, la borne RS sert à sélectionner le registre dans lequel on écrit, la borne R/W permet de commuter entre lecture et écriture, on souhaite seulement "écrire" sur l'écran dont elle sera tout le temps à 0v. Et la borne E permet d'activer l'écriture dans un registre.

Mais tout ça est trop compliqué à faire "manuellement", sur Arduino une bibliothèque va le faire pour nous, on n'aura juste à lui dire quoi afficher sur l'écran.

Cette bibliothèque nommée LiquidCrystal_I2C utilise la même mise en forme que la bibliothèque LiquidCrystal intégré par défaut au logiciel Arduino. Je vous invite donc à la télécharger ici et à l'installer dans votre répertoire C:\Program Files (x86)\Arduino\libraries .

Voici un exemple de code :
#include <Wire.h>  //bibliothèque sériel
#include <LiquidCrystal_I2C.h> //bibliothèque du couple extenseur i2c + écran

LiquidCrystal_I2C lcd(0x38,16,2);
//L'adresse de l'écran : 0x38 (trois pin d’adresse sur GND) pour un écran de 
//16 colonnes et 2 lignes

void setup()
{
lcd.init(); //on initialise l'écran
lcd.clear(); //on vide l'écran
}

void loop()
{
lcd.setCursor(0,0); //on se place en haut à gauche de l'écran
lcd.print("Salut"); //on affiche du texte

lcd.setCursor(0,1); //on se place sur la deuxième ligne à gauche
lcd.print((millis())/1000); //on affiche nombre de seconde depuis l'allumage

delay(1000);
}
 
Quelques liens :

Contrôler des afficheurs 8 segments avec le MAX7219

1407906-1360x768-[DesktopNexus.com]_thumb[32]

Le MAX7219 est un contrôleur série d'afficheur 8 segments. Il permet de contrôler jusqu’à 8 afficheurs de 8 segments, donc 64 LEDs. On peu également les coupler pour contrôler un nombre infini de LED.
Il est très facilement utilisable avec les cartes Arduino grâce à la bibliothèque
LedControl.
Ce contrôleur fonctionne uniquement avec les afficheurs à cathode (borne -) commune.
Cette puce est trouvable à presque 10€ mais il existe des copie fonctionnant parfaitement qui se vendent environs 2€ sur internet (c'est ce que j'ai choisi).

La puce est de type traversante, donc parfait pour une breadboard et possède 24 pins. Voici le schéma :


Elle peut donc s'utiliser facilement avec une résistance de 10Kohms et un condensateur de 0,1µF.
Notez que la résistance détermine le courant traversant l'ensemble des LEDs, il peut donc être utile de légèrement la modifier, mais 10Kohms est une bonne valeur pour commencer.
Sachez que lorsque que vous tenez un afficheur 8 segment à l'endroit, la borne 1 est celle en bas à gauche et la dernière borne est celle en haut a gauche.

Je me suis donc fabriqué une petite carte regroupant tout ces composants et des connecteurs bien pratiques.


Pour l'utiliser avec Arduino, il vous faut :
  • un Arduino (évidement)
  • l'IDE d'Arduino installé sur votre ordinateur
  • un ou plusieurs afficheur 8 segments à cathode commune (ou une matrice de LED)
  • la bibliothèque LedControl installé: playground.arduino.cc/Main/LedControl

Voyons un peu le code :

#include "LedControl.h"   //on ajoute la bibliotheque LedControl

//LedControl afficheur1=LedControl(DataIn,CLK,LOAD,nombre de MAX7219);
LedControl afficheur1=LedControl(12,11,10,1);


// prises de l'arduino sur lesquelles est branche le contrôleur.

void setup() {
afficheur1.shutdown(0, false); // allumer l'afficheur
afficheur1.setIntensity(0, 15); // regler la luminosite au maximum
afficheur1.clearDisplay(0); //vider l'afficheur

}

void loop() {
//afficheur1.setDigit(puce max7219, afficheur, nombre, point);
afficheur1.setDigit(0,0,8,false);


//on affiche un 8 sur le premier afficheur du premier MAX7219 avec le point décimal éteins
afficheur1.setDigit(0,1,1,true);


//on affiche un 1 sur le deuxième afficheur du premier MAX7219 avec le point décimal allume

}



Voici le résultat, on a bien le 8, puis le 1 et enfin le point décimal :









Quelques liens :




Une horloge sur bus I2C

1407906-1360x768-[DesktopNexus.com]_thumb[32]

Si votre arduino a besoin de se souvenir de l'heure qu'il est, et ce même après l'avoir débranché, vous avez besoin d'une RTC (real time clock ou horloge temps réel).
Le circuit RTC le plus répandus est le DS1307 et ce n'est pas pour rien; il est très simple, se branche sur bus I²C et ne coute que 1€ chez la plupart des vendeurs.
 

Le circuit DS1307 possède 8 pattes, mais une n'est pas utile, il s'utilise avec deux résistances de pull-up de 10kohms, un cristal à 32 768 kHZ et en option une pile de +3v de type CR2032.


Le SDA est la borne A4 de l'arduino et le SCL la borne A5.
Vous pouvez bien évidement acheter des modules tout fait mais je ne trouve pas ça marrant donc je me suis soudé moi-même le petit circuit en rajoutant un condensateur de 0.1µF entre le +5v et le GND.

Ensuite pour contrôler ça avec Arduino, j'utilise une librairie RTC classique : rtc-library.rar
Voici un exemple de code Arduino :

#include <Wire.h>
#include "RTClib.h"

RTC_DS1307 RTC;

void setup () {
Serial.begin(9600);

Wire.begin();
RTC.begin();

if (! RTC.isrunning()) {
Serial.println("Le RTC ne marche pas");
// mise à l'heure :
RTC.adjust(DateTime(__DATE__, __TIME__));
}


}

void loop () {
DateTime now = RTC.now();

Serial.print(now.year(), DEC); //on affiche la date et l'heure sur le port série
Serial.print('/');
Serial.print(now.month(), DEC);
Serial.print('/');
Serial.print(now.day(), DEC);
Serial.print(' ');
Serial.print(now.hour(), DEC);
Serial.print(':');
Serial.print(now.minute(), DEC);
Serial.print(':');
Serial.print(now.second(), DEC);
Serial.println();

Serial.print(" depuis 1970 = ");
Serial.print(now.unixtime());
Serial.print("sec = ");
Serial.print(now.unixtime() / 86400L);
Serial.println("jours");


Serial.println();
delay(1000);
}



Une petite horloge que j'ai monté :










Quelques liens :