Une liaison série UART permet une communication entre deux systèmes électroniques, elle est par exemple utilisée par votre carte Arduino lors de l'envoie du programme ou lors de la communication avec un ordinateur.

Schéma d'une communication UART

	ATMega328	ATMega644
Flash [ko]	32	64
RAM [ko]	32	64
ROM [ko]	1	2
IO	23	32
ADC	8	8

Photo de la carte pour l'ATMEGA644 nue

Photo de la carte pour l'ATMEGA644 assemblée

J'utilise ensuite un écran LCD de type ILI9341 pour afficher de différentes couleurs les messages venant des deux lignes séries surveillées.

Photo de l'écran d'affichage

J'ai monté tout ça sur une carte à trou avec deux interrupteurs pour désactiver à la demande l'affichage d'une des deux lignes de la communication série (pour n'écouter qu'un seul coté de la liaison par exemple), un bouton permettant de parcourir les différentes vitesse de communication (en bauds) et deux LED pour afficher sur quelle ligne série a eu lieu la dernière communication.

Photo du système

J'ai placé un tampon à base d'amplificateurs opérationnels en montage suiveur sur les deux lignes séries pour qu'il n'y ait aucunes chances qu’elles soient perturbées par "l'espion".

Schéma du double AOP LM358 configuré en deux montages suiveurs

Il me suffit donc d'alimenter ma carte en 5V et je peux ensuite surveiller une liaison série UART sans la perturber.

Il est sans doute largement possible d'améliorer le montage par exemple avec une carte SD pour enregistrer les données de communication etc... Mais ce petit montage m’a suffi pour faire fonctionner le module GSM que je souhaitais.


Voici le programme Arduino utilisé :

#include "SPI.h"
#include "Adafruit_GFX.h"
#include "Adafruit_ILI9341.h"
#define TFT_DC 3
#define TFT_CS 4
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC);

char inchar1;  //caractère entrant
char inchar2;
String message1 = ""; //message entier
String message2 = "";

const byte led1 = 0;
const byte led2 = 2;
const byte act1 = A5;
const byte act2 = A7;
const byte bp = A2;

unsigned int ixe = 11; //position x d'écriture

#include <EEPROM.h>
const byte addrEE = 52;  //on enregistre la vitesse de la communication dans la case 52

byte selbaudrate = 2; //on sélectionne 9600 bauds au début
unsigned long baudrate = 0;

void setup() {

  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(act1, INPUT_PULLUP);
  pinMode(act2, INPUT_PULLUP);
  pinMode(bp, INPUT_PULLUP);

  fctchangebaud(); //on initialise la liaison série et l'interface graphique
}

void loop() {

  if (digitalRead(bp) == LOW) {
    delay(5); //anti-rebond
    if (selbaudrate == 7) selbaudrate = 0;
    else selbaudrate++;
    EEPROM.write(addrEE, selbaudrate);
    fctchangebaud();
  }

  if(digitalRead(act1) == LOW) {

    while (Serial.available() && message1.length() < 53) {
      inchar1 = Serial.read();
      message1 += inchar1;
      delay(10);  //le temps que le prochain caractère arrive, IMPORTANT !
    }

    message1.trim();
    if (message1 != "") {
      digitalWrite(led1, LOW);
      digitalWrite(led2, HIGH);

      if (ixe > 230) {
        ixe = 11;
        tft.fillScreen(ILI9341_BLACK);
        tft.setCursor(0, 0);
        tft.setTextColor(ILI9341_WHITE);
        tft.print("SERIAL MONITOR - ");
        tft.print(baudrate);
        tft.print(" bauds");
        tft.drawLine(0, 9, 320, 9, ILI9341_WHITE);
      }

      tft.setCursor(1, ixe);
      tft.setTextColor(ILI9341_GREEN);
      tft.print(message1);
      ixe = ixe + 10;
    }
  }
  else while(Serial.available()) Serial.read();  //on vide quand même le buffer de l'autre serial

  if(digitalRead(act2) == LOW) {

    while (Serial1.available() && message2.length() < 53) {
      inchar2 = Serial1.read();
      message2 += inchar2;
      delay(10);  //le temps que le prochain caractère arrive, IMPORTANT !
    }

    message2.trim();
    if (message2 != "") {
      digitalWrite(led2, LOW);
      digitalWrite(led1, HIGH);

      if (ixe > 230) {
        ixe = 11;
        tft.fillScreen(ILI9341_BLACK);
        tft.setCursor(0, 0);
        tft.setTextColor(ILI9341_WHITE);
        tft.print("SERIAL MONITOR - ");
        tft.print(baudrate);
        tft.print(" bauds");
        tft.drawLine(0, 9, 320, 9, ILI9341_WHITE);
      }

      tft.setCursor(1, ixe);
      tft.setTextColor(ILI9341_RED);
      tft.print(message2);
      ixe = ixe + 10;

    }
  }
  else while(Serial1.available()) Serial1.read();  //on vide quand même le buffer de l'autre serial

  message1 = ""; //Vide la variable "message"
  message2 = "";
}

void fctchangebaud()  {

  Serial.end();
  Serial1.end();

  switch (selbaudrate) {
  case 0:
    baudrate = 2400;
    break;
  case 1:
    baudrate = 4800;
    break;
  case 2:
    baudrate = 9600;
    break;
  case 3:
    baudrate = 19200;
    break;
  case 4:
    baudrate = 28800;
    break;
  case 5:
    baudrate = 38400;
    break;
  case 6:
    baudrate = 57600;
    break;
  case 7:
    baudrate = 115200;
    break;
  }

  Serial.begin(baudrate);
  Serial1.begin(baudrate);

  tft.begin();
  tft.setRotation(3);
  tft.fillScreen(ILI9341_BLACK);
  tft.setCursor(0, 0);
  tft.setTextColor(ILI9341_WHITE);
  tft.setTextSize(1);
  tft.print("SERIAL MONITOR - ");
  tft.print(baudrate);
  tft.print(" bauds");
  tft.drawLine(0, 9, 320, 9, ILI9341_WHITE);

  ixe = 11;

}

Et voici le schéma électrique complet du système (cliquez pour agrandir) :

Schéma éléctrique du moniteur série matériel

A bientôt !

Liens externes :
Bibliothèque Sanguino : https://github.com/Lauszus/Sanguino
Bibliothèque ILI9341 : https://github.com/adafruit/Adafruit_ILI9341
ATMega644 : http://www.atmel.com/devices/ATMEGA644.aspx

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 :

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é.

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 interruption¹. 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 :

• https://www.arduino.cc/en/Reference/AttachInterrupt
• http://www.mon-club-elec.fr/pmwiki_reference_arduino/pmwiki.php?n=Main.AttachInterrupt

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.

 

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€.

 

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 :

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

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

· Le circuit du module radio nRF24L01+

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.

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.

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é :

 

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.

 

L’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.

 

 

La 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.

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.

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.

 

 

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 :

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é :

 

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).

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.

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 :

 

 

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.

 

 

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.

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.

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

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.

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 :

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é.


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 :

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 :

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 :

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.



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

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.