Kit Compagnon Arduino Nano – Composants et Outils Essentiels pour l'Électronique DIY

Composants et fournitures

Arduino Nano R3	×	1
Câble USB-A vers Mini-USB	×	1
Résistance 10k Ω (2x 220 Ω, 1x 1k, 4.7k, 47k, 100k Ω)	×	4
Potentiomètre mono-tour 10k Ω	×	1
Bouton poussoir SparkFun 12mm	×	2
Interrupteur à glissière	×	3
Connecteur femelle 8 positions 1 rangée (0,1")	×	4
Connecteur mâle 36 positions 1 rangée long (0,1")	×	2
Écran LCD RGB 16x2 Adafruit	×	1
Support 4 piles AA	×	1

Outils et machines nécessaires

Fer à souder (standard)

Pistolet à colle chaude (standard)

À propos de ce projet

Le Companion IC est un dispositif multifonction au design original : horloge, ohmmètre, capacimètre et testeur de diodes ! Il s'allume en appuyant sur la broche 1 du boîtier IC. Gardez-le sur votre établi pour tester rapidement composants et vérifier l'heure. Alimentable par piles ou via USB si une alimentation est disponible près de votre poste de travail.

Je voulais depuis longtemps publier un projet mais je n'avais jamais trouvé d'idée assez originale jusqu'à présent ! L'idée m'est venue quand j'ai voulu tester des condensateurs pour vérifier s'ils étaient défectueux. Je n'avais qu'un multimètre sans fonction capacimètre. En recherchant, j'ai découvert que l'Arduino pouvait le faire. J'ai décidé d'en construire un, mais voir les broches inutilisées de l'Arduino ne me satisfaisait pas, alors j'ai ajouté un ohmmètre à changement de calibre automatique, un testeur rapide de LED/diodes et une horloge RTC ! Je voulais aussi pouvoir mesurer directement en branchant le composant, sans sondes. Le design devait être unique, d'où l'idée du boîtier IC après réflexion.

Mise à jour (07/01/2016) : Test de continuité optionnel ajouté, voir la section commentaires.

Cet article explique en détail comment j'ai réalisé ce projet et comment vous pouvez le reproduire. Il est accessible aux débutants : 2-3 semaines d'expérience Arduino/électronique suffisent !

Le design est modifiable : vous pouvez ajouter ou retirer des fonctionnalités selon vos besoins. J'ai réalisé le boîtier en carton, mais avec les compétences adéquates, vous pouvez utiliser du bois ou l'impression 3D.

J'ai essayé de photographier chaque étape (beaucoup de photos par étape !). La plupart ont été reprises plusieurs fois pour obtenir le meilleur angle/lumière, mais quelques-unes restent légèrement floues car tenir le tout à deux mains est parfois difficile.

J'ai découpé le code et le câblage en étapes, exactement comme je l'ai construit. Le code est fortement commenté et bien indenté. Au fur et à mesure, nous combinerons toutes les parties pour créer le Companion IC final. Cela devrait aider à bien comprendre. Sinon, dites-le-moi en commentaire.

Même si vous ne le construisez pas, essayez sur breadboard ou lisez au moins une fois : il y a forcément une méthode, une astuce ou quelque chose que vous pourrez réutiliser un jour (sérieusement, on ne sait jamais quand ça clique !)

Étape 1 : Outils et composants nécessaires

Liste des composants et matériaux (liens magasin pour référence) :

• 1x Arduino Nano V3, j'ai utilisé un clone CH340G – eBay
• Câble Mini USB pour Arduino Nano – Mini pas Micro !
• Carton – boîte d'emballage, épaisseur ~2mm. Demandez à vos voisins, amis, récupérez si nécessaire.
• 4x Résistance 10k Ω – faciles à trouver
• 2x Résistance 220 Ω – faciles à trouver
• 1x Résistances (1k, 4.7k, 47k, 100k) Ω – faciles à trouver
• 1x Petit potentiomètre 10k Ω, pour contraste LCD, n'importe quel petit modèle – eBay
• 2x Micro bouton poussoir, pour reset et changement de mode, modèles standards breadboard
• 3x Petits interrupteurs à glissière, pour activer rétroéclairage, broches 0 et 1, à désactiver lors de l'utilisation série – eBay
• 1x Interrupteur poussoir verrouillé/maintenu, pour interrupteur principal – eBay
• Quelques condensateurs, diodes, LEDs pour tests, vous les utiliserez de toute façon un jour.
• 4x Barrette connecteur femelle – eBay (40 broches par barrette)
• 2x Barrette connecteur mâle – eBay (40 broches par barrette)
• 1x Écran LCD 16x2 caractères – eBay
• 1x Module RTC DS3231 ou DS1307 – N'achetez pas de modèles bon marché sur eBay. Ils utilisent des puces contrefaites et sont imprécis. Achetez celui-ci, celui-ci ou celui-ci. N'importe lequel fonctionnera.
• 4x Piles AA (ou AAA. L'utilisation de AAA est plus facile mais capacité moindre)
• 1x Support 4 AA (ou AAA) piles, version plate – eBay
• Fil monobrin, type breadboard, calibre 22
• Nappe câble (ou fils torsadés fins) – eBay
• 2x Petits écrou et boulon – ceux de mon vieux jeu Meccano (boulons 1,3cm)
• Peinture acrylique noire et pinceaux

Outils nécessaires :

• Fer à souder
• Soudure
• Tresse à dessouder (quand vous ratez !)
• Pistolet à colle
• Ruban de masquage
• Scotch transparent
• Dénudeur, pince coupante
• Cutter bien affûté
• Ciseaux bien affûtés

Étape 2 : Ohmmètre – Concept

Le principe de base de la mesure de résistance repose sur le diviseur de tension.

Les valeurs des résistances sont modifiables, changez r1, r2, etc. Définissez aussi les plages (pour l'autorange) en conséquence. Voir le code ci-dessous, téléchargeable dans les fichiers à la fin, et testez l'ohmmètre sur breadboard.

Si c'est votre première configuration du Nano, le pilote CH340G est téléchargeable ici (Windows 7, 8, 8.1, 10). Utilisateurs Mac voir ici.

Sélectionnez « Arduino Nano » dans le menu cartes et le bon port COM. Téléversez !

Code ohmmètre

// Broche analogique pour mesurer la résistance
int Apin = 7;
// Valeurs des résistances r1 à r5
float r1 = 1000;
float r2 = 4700;
float r3 = 10000;
float r4 = 47000;
float r5 = 100000;
// Broches des résistances r1 à r5
int r1_pin = 2;
int r2_pin = 3;
int r3_pin = 4;
int r4_pin = 5;
int r5_pin = 6;
float reading = 0; // Lecture broche analogique
float R = 0;       // Résistance calculée
String finalR;     // Valeur finale avec unités
int caseno;        // Pour debug, numéro de cas
// On divise la plage en 5 cas
// cas1 : < 2850
// cas2 : 2850 à 7350
// cas3 : 7350 à 28500
// cas4 : 28500 à 73500
// cas5 : > 73500
#include <stdlib.h> // Pour conversion float vers string, fonction String(float,n)

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

void loop() {
  // D'abord mesure avec résistance 1kΩ
  // Désactive R2, R3, R4, R5
  digitalWrite(r2_pin, LOW);
  pinMode(r2_pin, INPUT);
  digitalWrite(r3_pin, LOW);
  pinMode(r3_pin, INPUT);
  digitalWrite(r4_pin, LOW);
  pinMode(r4_pin, INPUT);
  digitalWrite(r5_pin, LOW);
  pinMode(r5_pin, INPUT);
  pinMode(r1_pin, OUTPUT);
  digitalWrite(r1_pin, HIGH);
  // Lecture et calcul
  reading = analogRead(Apin);
  R = (reading * r1) / (1023 - reading);
  // Si valeur < 2850, finalR = valeur (avec 1kΩ)
  if (R < 2850) {
    caseno = 1;
    if (R < 1000) {
      finalR = String(R, 2) + "Ohm";
    } else {
      R = R / 1000;
      finalR = String(R, 2) + "kOhm";
    }
  }
  // Si entre 2850 et 7350, utilise 4.7kΩ
  else if (R >= 2850 && R < 7350) {
    caseno = 2;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r3_pin, LOW);
    pinMode(r3_pin, INPUT);
    digitalWrite(r4_pin, LOW);
    pinMode(r4_pin, INPUT);
    digitalWrite(r5_pin, LOW);
    pinMode(r5_pin, INPUT);
    pinMode(r2_pin, OUTPUT);
    digitalWrite(r2_pin, HIGH);
    reading = analogRead(Apin);
    R = (reading * r2) / (1023 - reading) / 1000;
    finalR = String(R, 2) + "kOhm";
  }
  // Si entre 7350 et 28500, utilise 10kΩ
  else if (R >= 7350 && R < 28500) {
    caseno = 3;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r2_pin, LOW);
    pinMode(r2_pin, INPUT);
    digitalWrite(r4_pin, LOW);
    pinMode(r4_pin, INPUT);
    digitalWrite(r5_pin, LOW);
    pinMode(r5_pin, INPUT);
    pinMode(r3_pin, OUTPUT);
    digitalWrite(r3_pin, HIGH);
    reading = analogRead(Apin);
    R = (reading * r3) / (1023 - reading) / 1000;
    finalR = String(R, 2) + "kOhm";
  }
  // Si entre 28500 et 73500, utilise 47kΩ
  else if (R >= 28500 && R < 73500) {
    caseno = 4;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r2_pin, LOW);
    pinMode(r2_pin, INPUT);
    digitalWrite(r3_pin, LOW);
    pinMode(r3_pin, INPUT);
    digitalWrite(r5_pin, LOW);
    pinMode(r5_pin, INPUT);
    pinMode(r4_pin, OUTPUT);
    digitalWrite(r4_pin, HIGH);
    reading = analogRead(Apin);
    R = (reading * r4) / (1023 - reading) / 1000;
    finalR = String(R, 2) + "kOhm";
  }
  // Si > 73500, utilise 100kΩ
  else if (R >= 73500) {
    caseno = 5;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r2_pin, LOW);
    pinMode(r2_pin, INPUT);
    digitalWrite(r3_pin, LOW);
    pinMode(r3_pin, INPUT);
    digitalWrite(r4_pin, LOW);
    pinMode(r4_pin, INPUT);
    pinMode(r5_pin, OUTPUT);
    digitalWrite(r5_pin, HIGH);
    reading = analogRead(Apin);
    R = (reading * r5) / (1023 - reading) / 1000;
    finalR = String(R, 2) + "kOhm";
  }
  Serial.println(finalR);
  Serial.println(" ");
  delay(1000);
}

Étape 3 : Capacimètre – Concept

Le code ci-dessous est basé sur le concept de Paul Badger (2008). La tension d'un condensateur à une constante de temps vaut 63,2% de la tension de charge. Un condensateur se charge à 63,2% de sa capacité totale en une constante de temps.

Code capacimètre

/* RCTiming_capacitance_meter
 * Concept de Paul Badger 2008
 * La tension du condensateur à une constante de temps = 63.2% de la tension de charge.
 * Un condensateur se remplit à 63.2% de sa capacité totale en 1 Constante de Temps */
int analogPin = 0;       // Broche analogique pour tension condensateur
int chargePin = 7;       // Broche charge condensateur - connectée à une extrémité de la résistance de charge
int dischargePin = 12;   // Broche décharge condensateur, aussi utilisée pour test diode (checkPin1)
float resistorValue = 10000.0; // Résistance 10kΩ utilisée
unsigned long startTime;
unsigned long elapsedTime;
float microFarads;
float nanoFarads;

void setup() {
  pinMode(chargePin, OUTPUT);
  digitalWrite(chargePin, LOW);
  Serial.begin(9600);
}

void loop() {
  digitalWrite(chargePin, HIGH);
  startTime = millis();
  while (analogRead(analogPin) < 648) {
    // 647 = 63.2% de 1023, tension pleine échelle
  }
  elapsedTime = millis() - startTime;
  // Conversion ms en secondes (10^-3) et Farads en microFarads (10^6), net 10^3 (1000)
  microFarads = ((float)elapsedTime / resistorValue) * 1000;
  Serial.print(elapsedTime);
  Serial.print(" mS ");
  if (microFarads > 1) {
    Serial.print((long)microFarads);
    Serial.println(" microFarads");
  } else {
    nanoFarads = microFarads * 1000.0;
    Serial.print((long)nanoFarads);
    Serial.println(" nanoFarads");
  }
  // Décharge du condensateur
  digitalWrite(chargePin, LOW);
  pinMode(dischargePin, OUTPUT);
  digitalWrite(dischargePin, LOW);
  while (analogRead(analogPin) > 0) {
    // Attend décharge complète
  }
  pinMode(dischargePin, INPUT);
}

Étape 4 : Test de diode

La broche analogique est tirée à 5V via la résistance 10k Ω. Elle lit 1023 quand rien n'est connecté. D12 est mis en OUTPUT, LOW.

Quand une diode est polarisée en direct entre broche analogique (5V) et D12 (GND), la broche analogique lit 100-400. En inverse, courant résiduel très faible, lecture 900-1023. On identifie ainsi facilement l'anode et la cathode de toute diode, utile pour tester rapidement LEDs et diodes.

Code test diode

String state = "null";
int checkPin1 = 12;
int checkPin2 = 6;

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

void loop() {
  pinMode(checkPin1, OUTPUT);
  digitalWrite(checkPin1, LOW);
  // Lecture analogique normalement tirée à 5V par résistance 10k, lecture nulle = 1023
  // En polarisation directe, broche analogique connectée à checkPin1 (LOW), lecture < 1023
  // Courant résiduel en inverse aussi, seuil 700 pour différencier
  if (analogRead(checkPin2) < 700) {
    state = "forward";
  }
  Serial.println(state);
  Serial.println(analogRead(checkPin2));
  state = "null";
  delay(500);
}

Étape 5 : Horloge temps réel (RTC)

Le RTC maintient secondes, minutes, heures, jour, date, mois, année. Il continue de compter même sans alimentation externe grâce à sa pile bouton. La fin de mois est ajustée automatiquement (mois < 31 jours, années bissextiles).

Quel que soit le module, on utilise 4 broches : Vcc, GND, SDA et SCL. Sur Arduino Nano/Uno, SDA = A4, SCL = A5. Pour autres Arduino, recherchez !

Nous utiliserons la bibliothèque « RTClib » qui simplifie grandement la mise à l'heure et la lecture. Téléchargeable ici (cliquez « Download ZIP », extrayez « RTClib-master » dans votre dossier libraries Arduino. Plus d'infos sur l'installation de bibliothèques.)

Pour régler l'heure, téléchargez « RTC_set_time.ino » joint à cette étape et décommentez :

rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

Pour utiliser l'heure de compilation de votre ordinateur. Ou :

rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0)); // année, mois, jour, heure, minute, secondes

Pour une heure personnalisée.

Connectez comme indiqué et téléversez. Ouvrez le Moniteur série à 9600 bauds pour voir l'heure actuelle. Revérifiez après quelques heures pour constater la précision du RTC.

Important : recommentez ces lignes et re-téléversez après avoir réglé l'heure une fois. Sinon, l'heure sera réinitialisée à chaque reset de l'Arduino !

Code RTC

// Fonctions date/heure avec DS1307 RTC via I2C et Wire
#include <Wire.h>
#include <RTClib.h>
RTC_DS1307 rtc; // Création objet rtc
char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

void setup() {
  Serial.begin(9600);
  rtc.begin();
  // Ligne suivante règle RTC à date/heure de compilation
  // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  // Cette ligne règle RTC avec date/heure explicite, ex: 21 janv 2014 3h
  // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}

void loop() {
  DateTime now = rtc.now();
  Serial.print(now.year());
  Serial.print('/');
  Serial.print(now.month());
  Serial.print('/');
  Serial.print(now.day());
  Serial.print(" (");
  Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
  Serial.print(") ");
  Serial.print(now.hour());
  Serial.print(':');
  Serial.print(now.minute());
  Serial.print(':');
  Serial.print(now.second());
  Serial.println();
  Serial.println();
  delay(1000);
}

Étape 6 : Assemblage final

Voici le circuit final combinant tous les éléments. Le code principal et le fichier Fritzing sont joints à la fin.

Téléchargez Fritzing depuis fritzing.org si ce n'est pas fait.

Extrayez Main_code.rar et ouvrez Main_file_rtc.ino. J'ai mis toutes les déclarations de variables dans un fichier header definations.h, ajouté automatiquement à l'ouverture du code principal.

Les différentes parties sont des fonctions : Clock(), findResistance(), findCapacitance() et diodeTest(), chacune dans un onglet séparé pour lisibilité et facilité de modification. Le fichier principal vérifie l'état du « bouton mode » et appelle la fonction appropriée.

Les autres détails sont expliqués dans le code.

Après test sur breadboard, nous sommes prêts à construire le boîtier IC !

Note : Le buzzer, s'il n'est pas encore utilisé, peut servir pour une fonction de continuité par exemple.

Étape 7 : Préparation des interrupteurs

Prenez les 3 interrupteurs à glissière avec 3 paires de fils ~10cm. J'ai utilisé de la nappe câble.

Dénudez légèrement (max 5mm) et tordez les brins. Étamez 2 broches adjacentes de chaque interrupteur. Maintenez en place pendant la soudure (j'ai utilisé une pince lourde).

Si vous n'avez jamais soudé, c'est le moment d'apprendre. YouTube regorge de tutoriels, les leçons de PACE sont excellentes.

Ensuite, « étamez » les fils : fer sur le fil, peu de soudure entre fer et fil pour créer pont thermique, puis appliquez la soudure directement sur le fil, côté opposé au fer. Retirez soudure, puis fer. Vidéo sur cette technique.

Soudez un fil étamé sur chaque broche de l'interrupteur. Notez que j'ai mis les fils foncés du même côté.

Répétez pour le bouton poussoir (bouton reset). Ne soudez pas sur les contacts normalement fermés du bouton.

Étape 8 : Fabrication du boîtier – Découpe du gabarit

Téléchargez « Layout_Final_A3.pdf » ou « Layout_Final_ANSI_B.pdf » selon votre format papier. Imprimez sur A3 (29,7 x 42,0 cm) ou ANSI B (11 x 17 pouces). Sélectionnez le bon format papier, orientation, et option « Taille réelle » à l'impression. Vérifiez la précision : le petit angle en bas à droite doit faire 2cm x 2cm.

Découpez un morceau de carton légèrement plus grand que le gabarit. Faites des rouleaux de scotch double-face, collez aux endroits indiqués, puis collez la feuille sur le carton.

Utilisez ciseaux affûtés ou cutter avec règle pour découper le contour extérieur. Le cutter donne de meilleurs résultats. La plupart ont des lames cassables par segments pour avoir un tranchant neuf. Placez un autre carton ou bois dessous pour des coupes plus nettes.

Erreur fréquente : ne pas bien maintenir la règle sur la ligne. Ne vous précipitez pas.

Étape 9 : Fabrication du boîtier – Rainurage et pliage

Avec cutter et règle, rainurez soigneusement toutes les lignes de pliage, sauf la ligne centrale de la zone LCD. Pliez toutes les parties pliables et corrigez les rainures incomplètes.

Pour la moitié inférieure (base) :

Poncez les 4 premiers bords en biseau, appliquez colle chaude au pistolet (un côté à la fois), assemblez et maintenez 30-60 sec le temps que la colle refroidisse.

Percez deux trous à l'épingle comme indiqué, élargissez au crayon pour passer le boulon. Serrez l'écrou à l'intérieur, mettez un point de colle chaude (sur l'écrou seulement !), laissez refroidir. Retirez le boulon au tournevis.

Puis pliez les deux rabats latéraux vers l'intérieur et collez. La partie extérieure du rabat doit être légèrement inclinée, la partie centrale plate.

Étape 10 : Fabrication du boîtier – Ajout des interrupteurs

Prenez les 3 interrupteurs à glissière avec fils soudés, mesurez le rectangle nécessaire. Marquez sur le côté gauche du boîtier (vu de l'extérieur). Découpez au cutter, poncez légèrement l'intérieur pour retirer les aspérités.

Placez le premier interrupteur, maintenez et collez un côté. Laissez refroidir. Répétez pour les deux autres, puis collez les côtés restants. Note : Les broches câblées des interrupteurs doivent être du même côté.

Faites un trou de l'autre côté pour le bouton reset. Maintenez le bouton et collez. Pliez le rabat inférieur vers l'intérieur et collez.

Étape 11 : Fabrication du boîtier – Partie supérieure (couvercle)

Poncez les bords et collez les rabats latéraux vers l'intérieur (comme pour la base) pour la partie supérieure.

Étape 12 : Fabrication du boîtier – Ajout du LCD

Rainurez la ligne centrale (pas fait avant car délicat et se détend vite).

Repliez le couvercle sur la base et vérifiez l'alignement, espace suffisant pour les broches IC. (Voir photo)

Découpez les rabats de recouvrement comme sur les images.

Placez le LCD au centre de la zone LCD, marquez au crayon. Avec règle, tracez le rectangle et découpez soigneusement au cutter. Pliez la fenêtre LCD et collez les charnières pour les maintenir. Insérez le LCD et ajustez si nécessaire.

Enfin, collez les 4 coins du LCD (pas trop de colle) et mettez en place.

Étape 13 : Fabrication du boîtier – Rabats finaux

Poncez, ajustez et fermez le rabat triangulaire.

Fabriquez une petite pièce comme indiquée et collez-la sur le couvercle. Percez deux trous, élargissez au crayon pour passer le boulon et verrouiller le couvercle sur la base.

Étape 14 : Le circuit imprimé – Ajustement dimensions

Découpez le PCB universel à la bonne taille pour qu'il rentre dans le boîtier. Le mien fait 2x4 pouces. Pour couper : règle et cutter, passez plusieurs fois des deux côtés, ça casse net.

Placez-le à l'intérieur. Si la colle des rabats soulève le PCB, réchauffez la colle pour l'aplatir ou réduisez légèrement le PCB.

Découpez une petite partie pour que les 3 interrupteurs rentrent et que le PCB entre entièrement.

Étape 15 : Le circuit imprimé – Arduino Nano

Découpez les connecteurs femelles à la bonne taille pour l'Arduino.

Placez-le au centre du bord du PCB et soudez toutes les broches.

Étape 16 : Le circuit imprimé – Ohmmètre

Avant toute connexion sur le PCB, revérifiez depuis le schéma final.

Pour l'ohmmètre, commencez par une résistance 1k Ω sur la broche D2 de l'Arduino. Placez l'Arduino et repérez la broche. Au dos, pliez comme indiqué et soudez.

Faites de même pour les 4 autres résistances : 4,7k, 10k, 47k et 100k Ω.

Note : Garder toutes les bandes de tolérance (bande dorée) du même côté est une bonne pratique, ex: HAUT et DROITE.

Reliez les seconds bouts des résistances et soudez sur A7.

Étape 17 : Le circuit imprimé – Capacimètre et test diode

Capacimètre :

Soudez une résistance 220 Ω de D12 à A0. Et une résistance 10k Ω de A0 à D7.

Note : D7 (broche digitale) est aussi utilisée pour la broche de données LCD D4.

Test diode :

Soudez la résistance de rappel 10k Ω de A6 à +5V.

Étape 18 : Fabrication des connecteurs LCD

On utilise seulement les 6 premières et 6 dernières broches du LCD. Broches D0-D3 inutilisées. On fera des connecteurs seulement pour les broches utilisées. Recommandé car brancher/débrancher un connecteur 16 broches devient très difficile une fois le montage fini.

Découpez 2x connecteurs femelle 6 broches et 2x mâle 6 broches. Prenez nappe 6 fils, ~5-6 cm.

Dénudez, étamez les fils. Étamez aussi les broches des connecteurs. Soudez un par un comme pour les interrupteurs.

Appliquez colle chaude pour sécuriser les fils.

Étape 19 : Le circuit imprimé – Connexions LCD

Placez le PCB dans le boîtier. Branchez le connecteur sur le LCD et voyez où le port femelle doit être sur le PCB, soudez-le.

Laissez 4-5 rangées de points derrière le port LCD. L'interrupteur d'alimentation y sera ajouté plus tard.

Mesurez la longueur de fil monobrin pour connecter les broches de données (D4, D5, D6, D7) du LCD aux broches digitales (D7, D8, D9, D10) de l'Arduino, respectivement.

Ajoutez le potentiomètre 10k Ω : bornes latérales sur Vcc, GND et broche centrale sur V0.

Connectez Vss (GND) du LCD à GND, Vdd à +5V. Connectez aussi R/W à GND.

Broche Arduino	LCD
D7	D4
D8	D5
D9	D6
D10	D7
GND	Vss (GND)
+5V	Vdd

Étape 20 : Le circuit imprimé – Module RTC

J'ai dessoudé les connecteurs 90° d'origine du module et mis des broches droites pour qu'il soit plat sur le PCB.

Soudez un connecteur femelle 4 broches et reliez à Vcc, GND, SDA vers A4 et SCL vers A5.

Étape 21 : Fabrication du boîtier – Bouton mode

Marquez un cercle ~1cm de diamètre au coin broche 1 du boîtier IC. Marquez le centre avec une épingle, élargissez au crayon. Puis utilisez un outil adapté pour atteindre 1cm. Poncez l'intérieur et collez à la colle chaude.

Découpez un morceau de PCB universel (10-11 points x 5 points). Insérez et soudez le bouton poussoir, résistances 220 et 10k Ω comme indiqué.

Prenez nappe 3 fils ~15cm. Étamez les bouts et soudez comme indiqué. Notez quelle couleur va où, utile pour le câblage final.

Coupez 2 petits morceaux de gomme et placez-les sur les extrémités de la plaque. La hauteur doit faire que le bouton soit sous le niveau intérieur du carton vu de l'extérieur. J'ai utilisé 4mm.

Fixez avec colle chaude comme indiqué.

Étape 22 : Fabrication du boîtier – Points de test

Découpez 6x connecteurs femelle 6 broches. Poncez les côtés pour lisser.

Marquez les positions et découpez les fentes. Insérez et collez de l'intérieur.

Mettez un peu de soudure sur toutes les broches et utilisez un fil dénudé pour les relier. Assurez-vous que toutes sont connectées. Ne chauffe pas trop pour perfectionner : chauffer une broche chauffe aussi les voisines.

Prenez nappe 6 fils, étamez et soudez sur chaque fente. Notez que j'ai mis les couleurs foncées côté négatif. Collez à la colle chaude pour fixer.

Étape 23 : Les pieds

Téléchargez « Legs_A4.pdf » ou « Legs_ANSI_A.pdf » selon votre format. Imprimez sur A4 (21 x 29,7 cm) ou ANSI A (8,5 x 11 pouces). Vérifiez format, orientation, option « Taille réelle ». Confirmez la précision : le rectangle doit faire 8,4 x 11,8 cm.

Découpez, rainurez et collez comme le boîtier principal, voir images.

Étape 24 : Finition brillante !

Découpez feuille aluminium 1x2 pouces et collez-la soigneusement, pli par pli, sur les extrémités des pieds avec colle métal-carton. J'ai utilisé Fevibond.

Ensuite collez un morceau couvrant tous les sommets des pieds (comme montré), découpez lentement au cutter. Faites attention. L'aluminium a tendance à se déchirer sur les côtés. Utilisez quelque chose de plat pour bien faire adhérer l'aluminium entre les pieds.

Maintenant recouvrez de scotch transparent, comme pour l'aluminium, pour protéger des objets pointus.

Étape 25 : L'interrupteur d'alimentation

Mesurez et coupez la patte de l'interrupteur en le positionnant correctement. Maintenez temporairement les autres broches avec du scotch pour bien placer la broche 1.

Mélangez bien le m-seal (mastic époxy, durcit beaucoup). Appliquez comme sur les images et utilisez poudre + surface plane pour façonner. Laissez sécher.

Comblez aussi les éventuels trous restants dans le boîtier.

Note : On ne peut pas utiliser la colle chaude ici car elle reste caoutchouteuse, l'interrupteur a besoin d'un matériau dur et cassant.

Étape 26 : Interrupteur d'alimentation vers PCB

Une fois le m-seal sec, replacez pour vérifier.

Découpez 3 broches femelle et mâle, placez sur PCB aligné avec les broches de l'interrupteur. Soudez la partie femelle.

Étamez les pattes de l'interrupteur et les broches mâle, soudez-les. Vérifiez l'ajustement.

Testez l'interrupteur en appuyant avec un doigt derrière pour soutenir. Nous ajouterons une tige de support plus tard.

Connectez une broche latérale du connecteur femelle (interrupteur) à Vin. Je m'en suis rendu compte tard et j'ai eu beaucoup de mal.

Fixez le connecteur avec colle chaude.

Étape 27 : Fabrication du port USB

Placez le PCB correctement (avec Arduino) et découpez un rectangle pour le port Mini USB.

Retirez un peu de plastique du câble USB pour qu'il s'insère bien sur l'Arduino. Testez la connexion.

Étape 28 : Autres finitions

J'ai retiré toutes les LEDs de l'Arduino Nano et aussi la LED d'alimentation de mon module RTC. Elles consomment inutilement, ce qui compte sur batterie.

Poncez le m-seal sec pour qu'il se fonde dans le carton. Nettoyez la poudre avec un essuie-tout humide avant de peindre.

J'ai aussi ajouté un buzzer pour certaines fonctions. Les buzzers sont sensibles, n'utilisez pas trop de chaleur en soudant !

Étape 29 : Place à la peinture !

N'utilisez pas de peinture épaisse directe, ça fait des traces de pinceau. Diluez suffisamment.

Évitez les micro-bulles : elles apparaissent si vous tamponnez trop le pinceau.

Ne peignez pas la charnière du couvercle, la peinture la bloquerait.

C'est juste une couche de base. Une deuxième couche sera ajoutée pour la finition.

Étape 30 : Soudure de tous les fils

Reportez-vous au schéma de circuit avant toute connexion.

D'abord connectez le bouton reset : une extrémité sur RST, l'autre sur GND.

Ensuite, l'interrupteur rétroéclairage : une extrémité sur +5V, l'autre sur 'A' (Anode) de la LED de rétroéclairage. Connectez aussi 'K' (Cathode) à GND.

Puis l'interrupteur RS : une extrémité sur RS, l'autre sur broche D1 (TX).

Enfin l'interrupteur Enable : une extrémité sur 'E' (Enable), l'autre sur broche D0 (RX).

Interrupteur	Connexions
Reset (bouton poussoir)	RST et GND
Rétroéclairage (glissière)	+5V et A
RS (glissière)	D1 (TX) et RS
Enable (glissière)	D0 (RX) et E

Note : Broches D0 et D1 connectées via interrupteurs car les laisser connectées pose parfois problème lors de l'utilisation Série (pour debug).

Cela termine le câblage de base. Collez à la colle chaude après double vérification.

Puis connectez les 3 fils du bouton changement de mode : résistance 10k de rappel à GND. Résistance 220 Ω vers broche D11 et broche d'entrée vers +5V ou VCC.

Enfin connectez les 6 fils des emplacements de test à leurs emplacements appropriés (voir images).

Test	Positif	Négatif
Résistance	A7	GND
Capacité	A0	GND
Diode	A6	D12

Note : Tous les +5V et GND sont communs, connectez au point le plus pratique.

Étape 31 : Ajout du compartiment piles

Placez le compartiment piles sur le couvercle, découpez pour l'insérer de façon à pouvoir fermer le couvercle.

Soudez des fils sur le compartiment, dénudés et étamés. Soudez le positif sur la broche centrale de l'interrupteur d'alimentation et le négatif sur la masse.

Collez le PCB sur la base après toutes les connexions.

Tordez les fils et mettez en place. Insérez les piles (le compartiment s'élargit légèrement) et collez le compartiment au couvercle.

Étape 32 : Ajout des pieds

Découpez la partie intérieure des pieds pour qu'ils s'emboîtent bien. Collez en place.

Testez la broche de l'interrupteur d'alimentation, vérifiez l'ajustement. Retirez, ajoutez une tige métallique, morceau de bois ou tout élément rigide de bonne longueur pour empêcher l'interrupteur de reculer. Collez en place.

Vérifiez l'interrupteur, il doit s'actionner souplement.

Allumez l'IC et testez toutes les fonctions. Si ça ne marche pas, passez au dépannage.

Étape 33 : Finitions finales !

Utilisez du M-seal (ou équivalent) pour combler les petits espaces autour de la zone de test et du bouton mode. Après séchage, poncez bien et appliquez une deuxième couche de peinture.

Fabriquez le bouton avec un petit morceau de carton, peignez-le noir et recouvrez de scotch (fini brillant). Mettez une micro-goutte de colle et collez le bouton en place.

Étape 34 : Problèmes et dépannage

Faites tout correctement. C'est la partie la plus fastidieuse de tout projet et vous ne voulez pas y arriver juste parce que vous avez soudé les mauvaises broches !

• Revérifiez chaque joint soudé et assurez-vous qu'il ne touche pas le voisin. Utilisez le test continuité du multimètre.
• Après avoir coupé les pattes composants/fils, assurez-vous qu'elles ne tombent pas sous le PCB. Cela créerait des courts-circuits.
• Notez tout ce qu'il faut retenir dans un carnet, ne faites pas confiance à votre mémoire.
• Si le LCD n'affiche rien, vérifiez le réglage du contraste. Assurez-vous que les interrupteurs broches 0 et 1 sont ON. Vérifiez toutes les connexions LCD-Arduino au test continuité. Utilisez des fils breadboard là où votre multimètre n'atteint pas.
• Téléversez le programme « Hello World » LCD pour voir si le problème vient du code.
• Si une fonction ne marche pas, vérifiez ses connexions et comparez avec le code.
• Et surtout, gardez vos animaux curieux avec leurs esprits malins loin de votre espace de travail ! :p

Étape 35 : Ce que j'ai fait, quelques erreurs commises

Pendant les tests des circuits et avec une idée approximative du projet, j'ai opté pour le design IC. J'ai mesuré de vrais CIs, pris les ratios de longueur, calculé l'angle (trigonométrie) ~80°. Puis défini longueur/largeur intérieure et construit dessus (voir image). Une fois le gabarit planifié, j'ai commencé à le dessiner précisément sur grand papier. Après avoir galéré à tracer des lignes précises, j'ai compris que ce travail devait se faire sur ordinateur ! J'ai appris les bases de la CAO et réussi le gabarit. :) Mais ce gabarit n'a pas fonctionné et j'ai dû refaire toute la découpe et fabrication du boîtier. (Voir images)

En retirant les LEDs du Nano, j'ai forcé sur une LED récalcitrante et arraché un plot du PCB. Dessoudez toujours sans forcer/appliquer de pression sur les joints, les plots sont fragiles et s'arrachent facilement si vous ne restez pas calme.

Quand toutes les soudures étaient faites et le projet près de finir, par excitation et précipitation, j'ai collé le PCB dans le boîtier avant d'ajouter le compartiment piles. J'ai dû refaire fondre la colle chaude au fer à souder (attention à ne pas fondre l'isolant des fils) et sortir le PCB pour souder les fils du compartiment. Le fer se nettoie après.

La pile du module RTC gênait la fermeture, j'ai donc dessoudé le support de pile (Attention : dessoudez seulement pile retirée !) et ajouté des rallonges pour placer la pile sur les côtés où il y a de la place.

Tous les PDF de gabarits, fichiers CAO et le code principal sont téléchargeables ici : Google Drive

Code

Extrait de code #1 – Ohmmètre

// Broche analogique pour mesurer la résistance
int Apin = 7;
// Valeurs r1 à r5
float r1 = 1000;
float r2 = 4700;
float r3 = 10000;
float r4 = 47000;
float r5 = 100000;
// Broches r1 à r5
int r1_pin = 2;
int r2_pin = 3;
int r3_pin = 4;
int r4_pin = 5;
int r5_pin = 6;
float reading = 0;
float R = 0;
String finalR;
int caseno;
// 5 cas de plage
// cas1 : < 2850
// cas2 : 2850 à 7350
// cas3 : 7350 à 28500
// cas4 : 28500 à 73500
// cas5 : > 73500
#include <stdlib.h> // Pour String(float,n)

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

void loop() {
  // Mesure avec 1kΩ, désactive R2-R5
  digitalWrite(r2_pin, LOW);
  pinMode(r2_pin, INPUT);
  digitalWrite(r3_pin, LOW);
  pinMode(r3_pin, INPUT);
  digitalWrite(r4_pin, LOW);
  pinMode(r4_pin, INPUT);
  digitalWrite(r5_pin, LOW);
  pinMode(r5_pin, INPUT);
  pinMode(r1_pin, OUTPUT);
  digitalWrite(r1_pin, HIGH);
  reading = analogRead(Apin);
  R = (reading * r1) / (1023 - reading);
  if (R < 2850) {
    caseno = 1;
    if (R < 1000) {
      finalR = String(R, 2) + "Ohm";
    } else {
      R = R / 1000;
      finalR = String(R, 2) + "kOhm";
    }
  }
  else if (R >= 2850 && R < 7350) {
    caseno = 2;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r3_pin, LOW);
    pinMode(r3_pin, INPUT);
    digitalWrite(r4_pin, LOW);
    pinMode(r4_pin, INPUT);
    digitalWrite(r5_pin, LOW);
    pinMode(r5_pin, INPUT);
    pinMode(r2_pin, OUTPUT);
    digitalWrite(r2_pin, HIGH);
    reading = analogRead(Apin);
    R = (reading * r2) / (1023 - reading) / 1000;
    finalR = String(R, 2) + "kOhm";
  }
  else if (R >= 7350 && R < 28500) {
    caseno = 3;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r2_pin, LOW);
    pinMode(r2_pin, INPUT);
    digitalWrite(r4_pin, LOW);
    pinMode(r4_pin, INPUT);
    digitalWrite(r5_pin, LOW);
    pinMode(r5_pin, INPUT);
    pinMode(r3_pin, OUTPUT);
    digitalWrite(r3_pin, HIGH);
    reading = analogRead(Apin);
    R = (reading * r3) / (1023 - reading) / 1000;
    finalR = String(R, 2) + "kOhm";
  }
  else if (R >= 28500 && R < 73500) {
    caseno = 4;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r2_pin, LOW);
    pinMode(r2_pin, INPUT);
    digitalWrite(r3_pin, LOW);
    pinMode(r3_pin, INPUT);
    digitalWrite(r5_pin, LOW);
    pinMode(r5_pin, INPUT);
    pinMode(r4_pin, OUTPUT);
    digitalWrite(r4_pin, HIGH);
    reading = analogRead(Apin);
    R = (reading * r4) / (1023 - reading) / 1000;
    finalR = String(R, 2) + "kOhm";
  }
  else if (R >= 73500) {
    caseno = 5;
    digitalWrite(r1_pin, LOW);
    pinMode(r1_pin, INPUT);
    digitalWrite(r2_pin, LOW);
    pinMode(r2_pin, INPUT);
    digitalWrite(r3_pin, LOW);
    pinMode(r3_pin, INPUT);
    digitalWrite(r4_pin, LOW);
    pinMode(r4_pin, INPUT);
    pinMode(r5_pin, OUTPUT);
    digitalWrite(r5_pin, HIGH);
    reading = analogRead(Apin);
    R = (reading * r5) / (1023 - reading) / 1000;
    finalR = String(R, 2) + "kOhm";
  }
  Serial.println(finalR);
  Serial.println(" ");
  delay(1000);
}

Extrait de code #2 – Capacimètre

/* RCTiming_capacitance_meter
 * Concept Paul Badger 2008
 * Tension condensateur à 1 constante de temps = 63.2% tension charge
 * Condensateur rempli à 63.2% en 1 Constante de Temps */
int analogPin = 0;
int chargePin = 7;
int dischargePin = 12;
float resistorValue = 10000.0;
unsigned long startTime;
unsigned long elapsedTime;
float microFarads;
float nanoFarads;

void setup() {
  pinMode(chargePin, OUTPUT);
  digitalWrite(chargePin, LOW);
  Serial.begin(9600);
}

void loop() {
  digitalWrite(chargePin, HIGH);
  startTime = millis();
  while (analogRead(analogPin) < 648) {
    // 647 = 63.2% de 1023
  }
  elapsedTime = millis() - startTime;
  microFarads = ((float)elapsedTime / resistorValue) * 1000;
  Serial.print(elapsedTime);
  Serial.print(" mS ");
  if (microFarads > 1) {
    Serial.print((long)microFarads);
    Serial.println(" microFarads");
  } else {
    nanoFarads = microFarads * 1000.0;
    Serial.print((long)nanoFarads);
    Serial.println(" nanoFarads");
  }
  digitalWrite(chargePin, LOW);
  pinMode(dischargePin, OUTPUT);
  digitalWrite(dischargePin, LOW);
  while (analogRead(analogPin) > 0) {}
  pinMode(dischargePin, INPUT);
}

Extrait de code #3 – Test diode

String state = "null";
int checkPin1 = 12;
int checkPin2 = 6;

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

void loop() {
  pinMode(checkPin1, OUTPUT);
  digitalWrite(checkPin1, LOW);
  if (analogRead(checkPin2) < 700) {
    state = "forward";
  }
  Serial.println(state);
  Serial.println(analogRead(checkPin2));
  state = "null";
  delay(500);
}

Extrait de code #4 – RTC

// Date/heure avec DS1307 RTC via I2C et Wire
#include <Wire.h>
#include <RTClib.h>
RTC_DS1307 rtc;
char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

void setup() {
  Serial.begin(9600);
  rtc.begin();
  // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
}

void loop() {
  DateTime now = rtc.now();
  Serial.print(now.year());
  Serial.print('/');
  Serial.print(now.month());
  Serial.print('/');
  Serial.print(now.day());
  Serial.print(" (");
  Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
  Serial.print(") ");
  Serial.print(now.hour());
  Serial.print(':');
  Serial.print(now.minute());
  Serial.print(':');
  Serial.print(now.second());
  Serial.println();
  Serial.println();
  delay(1000);
}

GitHub

https://github.com/adafruit/RTClib

Schémas

Main_Schematic.fzz