par Anne-Laure DELPECH | 12 Juin 2016 | arduino
J’ai un clavier à 12 touches qui ressemble beaucoup à celui ci, sur amazon.fr. Je fais un essai pour voir si j’arrive à en lire les touches lorsque je le connecte à un arduino Uno.
Identification des broches
le clavier présente 10 connecteurs mais il suffit de souder les 8 du milieu.
Ensuite, avec un multimètre réglé sur 2KΩ, on regarde quels fils se connectent lorsqu’on appuie sur une touche.
Numéroter les broches de 1 à 8 : de droite à gauche lorsqu’on voit le clavier.
Le clavier est matriciel : chaque touche correspond à une colonne et une ligne que j’ai numéroté arbitrairement comme dans ce schéma :

Pour savoir quelle broche est connectée à quelle colonne ou ligne, il faut déterminer quels sont les associations de broches qui entrent en contact lorsqu’on appuie sur une touche. Ainsi si j’appuie sur 1, en voyant quelles broches entrent en contact, je déterminerai que l’une des deux est « row 1 » et l’autre est « col 1 ».
J’ai déterminé que la broche 7 et la broche 4 sont connectées lorsque j’appuie sur la touche 2. J’ai continué jusqu’à ce que j’ai assez d’informations pour identifier le rôle de chaque broche.
broche |
broche |
touche |
7 |
4 |
2 |
7 |
3 |
5 |
7 |
2 |
8 |
7 |
1 |
0 |
8 |
1 |
* |
6 |
1 |
# |
1 |
1 |
D |
J’en ai donc déduit que les broches correspondent à :
broche |
broche |
1 |
Row 4 |
2 |
Row 3 |
3 |
Row 2 |
4 |
Row 1 |
5 |
Col 4 |
6 |
Col 3 |
7 |
Col 2 |
8 |
Col 1 |
Connexion à l’Arduino

broche |
broche |
arduino |
1 |
Row 4 |
8 |
2 |
Row 3 |
9 |
3 |
Row 2 |
10 |
4 |
Row 1 |
11 |
5 |
Col 4 |
4 |
6 |
Col 3 |
5 |
7 |
Col 2 |
6 |
8 |
Col 1 |
7 |
Sketch
La bibliothèque keypad.h permet de gérer facilement un tel clavier matriciel. Voir cet article sur Arduino Playground.
Ce sketch lit correctement chaque touche appuyée et l’affiche dans la console série :
#include <Keypad.h>
const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
//define the cymbols on the buttons of the keypads
char keys[ROWS][COLS] = {
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = {11, 10, 9, 8}; //rows 1 to 4
byte colPins[COLS] = {7, 6, 5, 4}; //columns 4 to 1
//initialize an instance of class NewKeypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS);
void setup(){
Serial.begin(9600);
Serial.println("Setup done");
}
Si j’appuie sur les touches 1, 2, 3, A, 4, 5, 6, B, 7, 8, 9, C, *, 0, # puis D, j’obtiens l’affichage suivant dans la console série.
Setup done
key : 1
key : 2
key : 3
key : A
key : 4
key : 5
key : 6
key : B
key : 7
key : 8
key : 9
key : C
key : *
key : 0
key : #
key : D
Tout fonctionne donc parfaitement.
Et maintenant ?
Si j’ai besoin d’utiliser un tel clavier sur un arduino, je sais maintenant comment faire !
par Anne-Laure DELPECH | 8 Juin 2016 | arduino
Un collègue du FabLab de Quimper m’a prêté deux afficheurs LCD jamais utilisés. Ils devraient en principe fonctionner avec un arduino. J’essaie donc !
Les trois afficheurs
Deux afficheurs prêtés :
L’un comporte les indications suivantes : CLCD sur le contrôleur et GDM1604B sur l’afficheur. Il ressemble à ce produit de Lextronic (35.15 €), avec une fiche technique (pdf) et un manuel utilisateur chez ComFile.
L’autre : ALCD sur le contrôleur et PMC 2004E-SBLW ou PC-2004E6-2 Rev 1 sur l’afficheur. Il paraît correspondre à cet afficheur 2 x 16 caractères de Lextronic (27.5 €).
Les deux produits semblent conçus par Comfile pour les microcontrôleurs PicBasic. Je ne parviens pas à trouver d’information intéressante sur la façon de les connecter à un arduino et surtout de les commander via les contrôleurs.
Je décide donc d’utiliser un des afficheurs sans son contrôleur pour voir ce que l’on peut en faire.
Afficheurs achetés
J’ai également acheté un jeu de 5 afficheurs LCD très économiques : Ecrans LCD 16×2 HD44780 Controleur Retro-eclairage Bleu, sur amazon.fr, à 7.24 € les 5 (oui, les 5…)
Description d’un afficheur LCD
J’ai déconnecté le contrôleur ALCD de l’afficheur PMC 2004E-SBLW. Je me retrouve avec un afficheur pourvu de 16 broches males, numérotées de 1 à 16.
La page « Arduino – Hello World » indique que de nombreux afficheurs LCD à 16 broches sont compatibles avec le driver Hitachi HD44780 (ce qui est annoncé pour l’afficheur acheté, pas pour les deux prêtés). Un autre article sur codingcolor.com montre en photo les connecteurs.
Et l’afficheur acheté séparément contient aussi 16 broches.
Connexion des 16 broches de l’afficheur LCD
Pendant un bout de temps, les trois afficheurs affichent des carrés foncés mais pas le texte prévu… J’ai fini par me rendre compte que j’avais connecté DB11 à DB14 de l’afficheur sur les broches 4 à 1 de l’arduino et non 5 à 2….
Note : on peut remplacer le potentiomètre par un fil entre GND et la broche 3 de l’afficheur avec une résistance de 1 à 1.5 kΩ. Avec mon afficheur j’ai mis une résistance de 1 KΩ et l’affichage est très bien.
Connexions à l’arduino
afficheur |
fonction |
arduino |
1 |
VSS |
GND |
2 |
VDD |
5V |
3 |
contraste |
potentiomètre |
4 |
RS (register select) |
D12 |
5 |
R/W Read / Write |
GND |
6 |
H/L enable |
D11 |
7 |
DB0 (data 0) |
– |
8 |
DB1 (data 1) |
– |
9 |
DB2 (data 2) |
– |
10 |
DB3 (data 3) |
– |
11 |
DB4 (data 4) |
5 |
12 |
DB5 (data 5) |
4 |
13 |
DB6 (data 6) |
3 |
14 |
DB7 (data 7) |
2 |
15 |
LED + (5V) rétro-éclairage |
220 Ω puis 5V |
16 |
LED – (GND) |
Résistance 220 ohm |
schéma (frietzing)

Sketch arduino (issu d’un exemple) : test-lcd-display-yves.ino
Et le résultat, pour les 3 afficheurs, avec le même sketch. La seule chose qu’il faut régler c’est le contraste avec le potentiomètre.

Et on voit que les deux derniers afficheurs sont faits pour 4 lignes, il faudrait modifier le sketch pour en tirer partie.
par Anne-Laure DELPECH | 8 Juin 2016 | arduino
Après l’essai d’un afficheur 7 segments prêté par un collègue du FabLab de Quimper, j’ai acheté un afficheur vraiment pas cher (2.64€ livraison comprise) et je l’essaie.
L’afficheur 7 segments essayé
Il s’agit d’un afficheur de marque Toogoo, à 8 chiffres, avec un circuit intégré MAX7219 , disponible ici sur Amazon.fr pour 2.64 €.
Mon objectif
Il s’agit simplement de vérifier que je sais le connecter à un arduino Uno puis vérifier que je parviens à afficher quelque chose avec. Je n’en ai pas encore l’utilité.
Connexion à l’arduino
Après lecture de quelques pages web, dont celle-ci (en anglais, tronixstuff), j’ai compris à quoi servaient les deux jeux de 5 connecteurs présents sur l’afficheur :

Du côté gauche, on trouve les connecteurs qui seront reliés à l’arduino. Du côté droit, on trouve les broches qui permettent de relier d’autres afficheurs identiques en série.
Le circuit MAX 7219 gère jusqu’à 64 leds (soit 8 chiffres de 8 leds chacun avec le point). On peut chainer les afficheurs pour en mettre deux ou trois à la suite.
Pour cet essai, je ne connecte qu’un afficheur de 8 chiffres. J’utilise donc la sortie 5V de l’arduino pour l’alimenter. Mais attention, il est possible que ça ne soit pas faisable s’il y avait plus d’un afficheur, chaque led consommant environ 15 mA (pour du rouge).
Voici les connexions que je réalise :
afficheur |
arduino |
VCC |
5V |
GND |
GND |
D IN |
2 |
CS |
3 |
CLK |
4 |
Programmation de l’afficheur
On utilisera la librairie ledcontrol, téléchargeable sur GitHub, pour les MAX 7219 ou 7221. Pour installer une librairie dans un arduino, voir cet article.
Utilisation de la librairie : cf cette page du site arduino.
Puis j’utilise un sketch exemple de cette librairie (LCDemo7segment). Je modifie simplement les broches utilisées (2, 4 et 3 au lieu de 12, 11 et 10) et ça fonctionne.
Le sketch utilisé : Max7219-7Segment.ino
Le résultat

Et maintenant ?
Je vais utiliser cet afficheur sur le NoRobo prochainement !
par Anne-Laure DELPECH | 8 Juin 2016 | arduino
Les librairies (bibliothèques en bon français) sont du code qui simplifie l’utilisation d’un capteur, d’une fonctionnalité. Elles sont chargées dans l’arduino si nécessaire. Nous allons voir ici comment faire concrètement pour les charger.
Quand charger une librairie ?
Dès qu’un sketch arduino contient une ligne ressemblant à #include « LedControl.h » , il appelle une librairie (ici la bibliothèque LedControl). Lors de la compilation préalable à la programmation de l’arduino, l’interface arduino vérifie que la librairie est bien disponible. Si ce n’est pas le cas, un message d’erreur s’affiche et l’arduino ne peut pas recevoir le sketch.
Il est donc nécessaire de mettre la librairie à disposition de l’IDE avant de lancer la compilation.
Comment faire ?
utilisation du gestionnaire de librairies
Le gestionnaire de librairies permet d’afficher la liste des librairies prêtes à l’emploi ou prêtes à installer. 
Pour plus de précisions, voir ce document arduino.
Importation d’un fichier zip
Si je veux par exemple ajouter la librairie LedControl disponible ici sur GitHub, je clique sur le bouton vert « Clone or download » (1) puis sur « Download ZIP » (2) :

J’obtiens un fichier nommé « LedControl-master.zip ». J’ai deux possibilités : par l’interface arduino ou par l’ajout manuel d’un répertoire.
méthode par l’interface arduino
La plus simple est d’utiliser la fonctionnalité ‘ajouter la bibliothèque zip » de l’interface arduino.

Je clique sur « ajouter la bibliothèque ZIP » puis je choisis le fichier LedControl-master.zip que j’ai téléchargé précédemment. La bibliothèque s’installe et devient visible dans le gestionnaire de bibliothèques.
méthode manuelle
Dans certains cas la bibliothèque contient de nombreuses versions et je ne veux pas toutes les installer. Par exemple, si je n’ai pas d’arduino Yun, je peux éviter d’encombrer mon ordinateur en l’installant.
Dans ce cas,
- fermer l’interface arduino ;
- dezipper le fichier téléchargé et y sélectionner le ou les répertoires que je veux réellement installer (Copier).
- coller ces répertoires dans le répertoire « user/ Documents\Arduino\libraries »
- redémarrer l’interface arduino, la ou les librairies sont maintenant disponibles.
par Anne-Laure DELPECH | 5 Juin 2016 | arduino
Commander deux relais 220 V à partir d’un arduino Nano, avec un téléphone android connecté en bluetooth : c’est possible pour moins de 10 €. Voici le tutoriel complet.
Cet article est l’aboutissement d’un travail d’essais et recherches relatés dans des articles précédents :
Maintenant je fais la synthèse pour une réutilisation dans d’autres configurations.
Avant toute chose, RAPPEL : on travaille avec du 220V et les risques sont réels !

Commander deux relais 220V avec un arduino Nano
Le schéma de connexions :

Les photos du montage :
J’ai enfermé toutes les connexions 220 V dans une boîte en plastique. L’arduino (puis le module bluetooth) sont à l’extérieur de la boîte.

Photo du premier essai :
J’ai préféré brancher l’arduino sur une alimentation USB spécifique (pas mon ordinateur) et je me suis installée sur la terrasse. Noter que la boîte en plastique sécurise bien l’installation 220V.

Le sketch arduino :
test-fanch-relais-new.ino, un sketch qui allume une lampe lorsque le signal envoyé par l’arduino est LOW.
Commander par bluetooth et smartphone Android
Le schéma de montage (côté faible tension – le cablage haute tension n’est pas modifié) est le suivant :

Quant au sketch, c’est celui que j’ai utilisé précédemment avec deux relais plus gros, mais il y a une différence essentielle : l’allumage est réalisé lorsque l’arduino envoie un signal LOW et non pas HIGH comme avec les autres relais.
Notre nouvel algorithme est donc légèrement différent :
bool up = true; // pas d'ordre de montée
bool down = true; // pas d'ordre de descente
Si up est false ou down est false (il faut bouger le store)
si up est false ET down est false
on a un big problème, le moteur va devenir fou
sinon
allumer ou éteindre selon la valeur de up ou de down
Le sketch qui fonctionne est celui ci : Relais-BT-V1-2016-06-05.ino
Le résultat :
Lorsque j’appuie sur le bouton « UP » de mon smartphone,

la lampe « UP » s’allume !

Et si j’allume les deux boutons à la fois, il ne se passe rien, tout comme s’ils sont tous deux éteints. Tout fonctionne donc correctement.
Et maintenant ?
En cas d’utilisation d’un autre modèle de relais, bien vérifier si c’est un signal LOW ou HIGH qui génère l’allumage.
Pour une utilisation définitive, il faudra réaliser un boîtier plus compact et plus sécurisé. On pourra s’inspirer des plans suivants :
On en profitera pour admirer cette belle boîte qui permet de transporter un arduino Uno et un breadboard sur 3dhubs.
Tout est prêt maintenant pour que Fanch puisse mettre son store chez lui en tant que prototype !
par Anne-Laure DELPECH | 5 Juin 2016 | arduino
J’ai acheté quelques relais 220 V pa chers (2.11 €, livraison comprise) pour arduino. Une commande 5V en provenance de l’arduino déclenche l’ouverture ou la fermeture d’un contact 220V.
Description des relais achetés
Je les ai achetés à la boutique « Universal Color » sur Amazon.fr, au prix de 2.11 € l’unité (voir le produit ici). Le seul inconvénient est que le délai de livraison est de l’ordre de 3 semaines. J’ai vu ensuite qu’on trouve également ce relais double chez TiptopBoard ici pour un prix plus élevé, mais une livraison très rapide. L’avantage de TipTopBoards est qu’il y a un tutoriel d’utilisation, en général bien fait, pour la plupart des produits vendus. Malheureusement dans ce cas, le tutoriel n’est pas précis du tout…
Les relais sont des songle (R) srd 05VDC-SL-C. J’ai trouvé différentes sources d’information, mais aucune qui paraisse complète et fiable… :
How to Set Up a 5V Relay on the Arduino
Et aussi :
- en espagnol, avec un schéma bien fait, pour les raspberry Pi ou arduino, ici
- en français, mais pour alimenter des leds 5V, dans ce tutoriel.
- Voir aussi cet article en anglais, qui semble suggérer que l’isolation n’est correcte qu’en enlevant le cavalier qui relie JD-VCC et VCC
- La description sur ce site de vente en ligne est bien faite et claire. Un site à garder en mémoire car il parait bien documenté, avec des tarifs raisonnables.Un exemple avec des leds dans cet article en espagnol aussi.
- et enfin, cet article qui paraît bien fait, en anglais, qui explique comment brancher une ampoule et la commander par un arduino.
Premiers essais pour comprendre
Comme je veux utiliser ces relais pour des applications 220V, il faut absolument que je comprennes comment fonctionnent ces relais et surtout comment on assure l’isolation totale entre les parties 220V et les parties basses tension.
Pour comprendre le principe général, je teste d’abord avec deux leds alimentée en 5V à partir de l’arduino Nano selon le schéma de connexion suivant (résistance 330 à 1000 ohm) :

Le sketch utilisé est une variante du sketch utilisé dans un autre article sur des relais 220V plus chers (arduino et relais pour commander du 220 V).
/*
* test moteur fanch 4/6/2016
*
* !!! NE PAS UTILISER AVEC UN MOTEUR
* --- les deux relais peuvent être sur 1 simultanément dans cette version
* !!!
*
* Nouveaux relais pas chers
* Le relais met sur ON lorsqu'il ne reçoit pas d'impulsion....
* arduino Nano R3
*
*/
const int montee = 3; // broche 3 pour le relais "montée" K1 / led Rouge
const int descente = 4 ; // broche 4 pour le relais "descente" K2 / led verte
bool up = false; // pas d'ordre de montée
bool down = false; // pas d'ordre de descente
char etat = 'S'; // single quote, it's not a constant...
void setup() {
// initialize digital pin 13 as an output.
pinMode(montee, OUTPUT);
pinMode(descente,OUTPUT);
// démarrer le port série
Serial.begin(57600);
Serial.println("Setup fait" );
// vider le buffer RX
// while (Serial.available()) Serial.read();
}
// the loop function runs over and over again forever
void loop() {
Serial.println("------------------" );
Serial.print("UP " );
action_store(true, false); // single quote for string
Serial.print("DOWN " );
action_store(false, true); // single quote for string
Serial.print("BIG PROBLEME " );
action_store(true, true); // single quote for string
Serial.print("Stand By " );
action_store(false, false); // single quote for string
}
void action_store(bool sens1, bool sens2) {
bool red = sens1 ;
bool green = sens2 ;
Serial.print(" | RED : ");
Serial.print(red);
Serial.print(" | GREEN : ");
Serial.println(green);
motor_go(montee, sens1) ;
motor_go(descente, sens2) ;
delay(3000) ;
}
void motor_go(int sens, bool action ) {
digitalWrite(sens, action); // actionne le moteur "sens"
etat = sens ;
}
Ce sketch m’a permis de comprendre comment brancher la sortie des relais :

C = Common, c’est l’arrivée de courant pour l’équipement à allumer ou éteindre. Dans ce schéma en 5V, mais peut aller jusqu’à 220V et 10A.
NC = « normally closed ». Le contact NO est OUVERT lorsqu’on envoie un signal HIGH de l’arduino, fermé lorsque le signal est à LOW
NO = « normally open ». Le contact NC est FERME lorsqu’on envoie un signal HIGH de l’arduino, ouvert lorsque le signal est à LOW
J’ai donc connecté les leds à NO pour qu’elles soient actionnées lorsque l’arduino Nano envoie un signal.
ATTENTION : lorsque l’arduino est éteint, les deux leds ne sont pas alimentées avec ce schéma, mais un test au multimètre montre que le contact est établi entre C et NO, que je laisse le jumper ou non, alors que le contact entre C et NC est bien ouvert. Si je branche les moteurs comme ça, ils vont se retrouver en marche lorsque l’arduino sera éteint…
Le rôle du jumper….
J’ai lu dans plusieurs articles que le jumper JD-VCC vers VCC doit être enlevé lorsqu’on veut isoler parfaitement les deux réseaux, l’un haute tension et l’autre basse tension.
Je crois comprendre à quoi il sert : on peut alimenter le relais avec 5V indépendants de l’arduino si on le souhaite. Dans ce cas, on enlève le jumper et on connecte JD-VCC à du 5V indépendant et GND juste à côté au neutre de l’alimentation indépendante.
Mais avant de tester en 220V, il faut que j’en sois certaine… Je dois vérifier qu’il n’y a pas de contact entre les deux côtés du relais
Essai avec des leds alimentées en 12V
Visiblement le jumper a une fonction lorsqu’on utilise une alimentation indépendante pour les équipements relayés. Je fais donc des essais avec une alimentation 5V.
Je vais alimenter le côté des leds par une alimentation spécifique 12V, en mettant les bonnes résistances, je ne devrais pas les casser.
De l’autre côté l’arduino sera en 5V via USB.
Et je testerai d’enlever le cavalier et d’alimenter le relais avec du 5V indépendant.

Ce montage me sert à faire des tests. L’alimentation 12V étant toujours en route, que se passe-t-il quand :
- j’enlève le cavalier entre JST-VCC et VCC
- Je débranche l’alimentation de l’arduino
Lorsque l’arduino est éteint : les led sont toutes deux allumées
Lorsque le cavalier est enlevé : le relais fonctionne (on voit les led de K1 et K2 s’allumer et s’éteindre selon la séquence) mais les leds restent allumées en permanence…
Lorsque le cavalier est enlevé, si je place le +5V de l’arduino sur le JST-VCC ou le VCC de cette zone, avec le GND de l’arduino sur le GND de cette zone, c’est comme si j’avais placé le cavalier.
Conclusion sur un branchement correct en 12V
Le schéma correct de fonctionnement est le suivant (noter que les alimentations des leds sont maintenant connectées à NC et pas NO :

Quant au sketch, il fonctionne correctement avec le contenu suivant :
/*
* test moteur fanch 4/6/2016
*
* !!! NE PAS UTILISER AVEC UN MOTEUR
* --- les deux relais peuvent être sur 1 simultanément dans cette version
* !!!
*
* Nouveaux relais pas chers
* Le relais met sur ON lorsqu'il ne reçoit pas d'impulsion....
* arduino Nano R3
*
*/
const int montee = 3; // broche 3 pour le relais "montée" K1 / led Rouge
const int descente = 4 ; // broche 4 pour le relais "descente" K2 / led verte
void setup() {
// initialize digital pin 13 as an output.
pinMode(montee, OUTPUT);
pinMode(descente,OUTPUT);
// démarrer le port série
Serial.begin(57600);
Serial.println("Setup fait" );
// vider le buffer RX
// while (Serial.available()) Serial.read();
}
// the loop function runs over and over again forever
void loop() {
Serial.println("------------------" );
Serial.print("DOWN - VERT ON " );
action_store(true, false); // single quote for string
Serial.print("UP - ROUGE ON " );
action_store(false, true); // single quote for string
Serial.print("Stand By - Rouge et vert OFF " );
action_store(true, true); // single quote for string
Serial.print("BIG PROBLEME - Rouge et vert ON " );
// action_store(false, false); // Do not run this if le moteur du store est connecté !
Serial.println(" DO NOTHING !");
}
void action_store(bool red, bool green) {
Serial.print(" | RED : ");
Serial.print(red);
Serial.print(" | GREEN : ");
Serial.println(green);
motor_go(montee, red) ;
motor_go(descente, green) ;
delay(3000) ;
}
void motor_go(int sens, bool action ) {
digitalWrite(sens, action); // actionne le relais "sens"
}
Noter que la led rouge s’allume lorsqu’on lui envoie (FALSE / 0) et s’éteint lorsqu’on lui envoie (TRUE / 1).
Noter aussi que j’ai fait en sorte que le cas « big problem » n’allume pas les led pour qu’on ne risque pas de bousiller le moteur des stores si on essaie avec ce sketch.
Dans la console série – réglée à 57600 bauds – on lit en boucle le texte suivant :
——————
DOWN – VERT ON | RED : 1 | GREEN : 0
UP – ROUGE ON | RED : 0 | GREEN : 1
Stand By – Rouge et vert OFF | RED : 1 | GREEN : 1
BIG PROBLEME – Rouge et vert ON DO NOTHING !
Et la led verte s’allume bien lorsque red est à 1 et green à 0
Essais avec du 220V

Maintenant j’essaie avec deux ampoules branchées sur du 220 V !
Mesures de sécurité
Dessiner le schéma de fonctionnement général, en mettant toutes les hautes tensions d’un côté, bien séparées des basses tensions.

Dessiner un schéma utilisant des connecteurs type domino pour simplifier le changement d’éléments commandés.

Mettre tous ces composants dans une boîte. Fermer la boîte avant de brancher la prise et l’arduino.
Bilan :
Ca fonctionne correctement, je ne me suis pas électrocutée et je n’ai pas fait sauter les fusibles de la maison !
Pour voir les photos du montage tel que schématisé ici et pour aller plus loin (commande bluetooth), c’est dans un prochain article.
par Anne-Laure DELPECH | 4 Juin 2016 | arduino
J’ai acheté un arduino nano V3, un tout petit arduino qui ne coûte que 3.66 €, livraison comprise (sur amazon ici) ! Pour ce prix, il est livré avec un cable USB et des connecteurs femelles sont soudés sur la carte, c’est incroyable !
Voici un descriptif de son fonctionnement, très simple.
Fiche descriptive
Voir sur le site arduino, en anglais.
Programmation
L’arduino nano se programme comme un arduino uno classique : on connecte le cable usb fourni à l’ordinateur et à l’arduino puis on ouvre l’interface IDE arduino.
Il suffit de définir le type de carte (dans outils) comme arduino nano. On peut ensuite téléverser un programme dans l’arduino nano. J’ai utilisé l’exemple blink et j’ai bien une led qui clignote sur l’arduino nano (en rouge). Facile !
Connexions
Les connexions sont semblables sur le nano et sur le uno, mais moins accessibles sur le nano.
Voici la vue générale :

Et le détail des différents connecteurs :

Et maintenant
Je peux utiliser un arduino nano comme j’aurais utilisé un arduino Uno !
par Anne-Laure DELPECH | 22 Mai 2016 | arduino
L’objectif de ce premier essai est de commander un store motorisé par le biais d’un arduino commandé en bluetooth d’un smartphone android.
L’objectif
Le moteur du store est relié à 4 fils (voir l’article de Fanch ici) :
- un fil jaune/ vert de terre
- un fil bleu de neutre
- un fil noir pour un des sens de rotation
- un fil marron pour l’autre sens
Le moteur contient des fins de course, on n’a donc pas besoin de les gérer.
L’objectif est donc de commander deux relais par l’intermédiaire d’un arduino équipé de bluetooth. Un relais sera relié au fil noir, l’autre au fil marron.
Prototypes
J’utilise deux relais « solid state » G3NA-220B (fiche technique ici, en pdf). Ils sont un peu surdimensionnés mais utiles en attendant la réception d’autres relais.
prototype n°1 : 2 lampes par liaison série

Je n’ai pas respecté les codes couleur… A revoir pour la version définitive !
Ce sketch (test-fanch-serie.ino) allume la lampe « Montée » lorsque je tape 0 dans la console série. SI je tape 1, c’est la lampe descente qui s’allume.
Ajout d’un module bluetooth
Paramétrage du module (HC-06) selon les modalités décrites dans cet article. Attention n°1 le sketch doit être changé pour que BTSerie.begin(9600); et non 57600 baud puisqu’un module neuf est paramétré par défaut à 9600 bauds.
Pour une raison que j’ignore, le sketch ne répondait à aucune autre instruction que AT (il répondait OK. J’ai donc modifié le sketch pour envoyer les instructions au HC-06 directement dans le setup…
J’ai donc modifié le sketch pour que le setup fasse les réglages suivants en direct, sans que j’ai à saisir des choses dans la console série.
- Demande le N° de version
- donne le nom store au module HC-06
- donne la vitesse 57600 baud au HC-06
BTSerie.print("AT+VERSION");
delay(1000);
BTSerie.print("AT+NAMEstore");
delay(1000);
BTSerie.print("AT+BAUD7");
delay(1000);
La console série affiche alors OKlinvorV1.8OKsetnameOK57600, donc les instructions ont été prises en compte.
Le sketch correspondant est celui-ci : BlueTooth-AT-commands-2016-05-22.ino
J’éteinds l’arduino. Je le redémarre. Le module ne communique maintenant plus qu’à 57600 baud avec l’arduino.
Proto n°2 : Interaction avec une appli Android
J’ajoute d’abord le module bluetooth HC-06 paramétré précédemment.

Commande de deux lampes par arduino Uno en bluetooth (HC-06)
Je vais utiliser l’application android JoystickBluetooth Commander (que j’utilise déjà dans le NoRobo – cf cet article).
I faut que :
- appui sur bouton 1 = montée pendant 3 secondes
- appui sur bouton 2 = descente pendant 3 secondes
- un deuxième appui sur l’un des deux boutons annule l’ordre
- si bouton 1 allumé, on ne peut pas simultanément descendre
- si bouton 2 allumé, on ne peut pas simultanément monter
en pseudocode, ça veut dire ce qui suit :
bool up = false;
bool down = false;
Si up est true ou down est true (il faut bouger le store)
si up est true ET down est true
on a un big problème, le moteur va devenir fou
sinon
allumer ou éteindre selon la valeur de up ou de down
Le sketch (test-fanch-BT-1.ino) permet de réaliser ça avec l’application Joystick Bluetooth commander connectée au module bluetooth « store » réglé à une vitesse de 57600 bauds.
Et voilà le résultat :

l’écran du smartphone android

Le résultat : la lampe « descente » est allumée
Ca fonctionne correctement car il est effectivement impossible d’allumer les deux lampes à la fois (ce qui casserait le moteur).
Maintenant, il n’y a plus qu’à tester in situ !
par Anne-Laure DELPECH | 8 Mai 2016 | arduino
Quelqu’un m’a prêté un afficheur 7 segments qu’il n’avait jamais eu l’occasion d’essayer. Il s’agit d’un module « CSG-4S » comme celui ci, sur Lextronic.fr.
Comme trop souvent, il a été impossible de trouver de la documentation précise pour ce module. Le fabricant, Comfile ne documente que l’utilisation avec des PicBasic, des microcontrôleurs.
J’ai été mise sur la voie par un forum arduino, dans lequel quelqu’un annonçait avoir décollé l’étiquette sur son afficheur. J’ai décollé l’énorme étiquette « contrôle qualité » qui masquait le microprocesseur figurant sur le module. Et banco ! C’est un microprocesseur SAA1064, et on trouve plein d’informations sur son utilisation avec un arduino, et en particulier ce tutoriel de 2011, sur tronixstuff.com.
Le module afficheur 7 segments CSG-4S
Il y a une fiche technique pour ce module, qui date de 1991. J’y ai trouvé les informations suivantes :
- tension d’alimentation : 5V
- Les broches SDA et SCL sont compatibles I2C
- SDA et SCL peuvent recevoir 5V en entrée (ce n’est pas toujours le cas sur les afficheurs 7 segments)
La connexion avec l’arduino Uno
SDA et SDL permettent la connexion selon le protocole I2C. Je les ai donc (?) connecté respectivement à A5 et A4 de l’arduino.

La programmation de l’afficheur
J’ai tout simplement essayé deux des sketchs présentés sur le tutoriel de Tronixstuff :
Ci-dessous des photos de l’afficheur avec le deuxième sketch.

Et maintenant ?
Je vais rendre cet afficheur. Mais je vais essayer d’en utiliser un pour le NoRobo.
par Anne-Laure DELPECH | 8 Mai 2016 | arduino
J’ai acheté un indicateur de tension pour batterie Lipo 2S à 6S, avec affichage et alarme. J’ai commandé ce composant sur Amazon, boutique Universal Color, pour 3.04 €. Mon but ici est de regarder comment il fonctionne, de l’essayer dans divers cas afin de décider ensuite quand et comment l’utiliser.
Le composant
Le composant est livré sans notice, et les informations lors de la commande étaient minimes. Je savais simplement qu’il s’utilise pour des batteries Li-Po 2S-6S (7.4V ~ 11.1V).
J’ai dû aller regarder plein d’images sur internet avant de comprendre le principe d’utilisation.
Utilisation avec une batterie Lipo
Comment faire la connexion ?
On connecte toujours le fil noir (le – de la batterie) sur la borne – du testeur. Le fil rouge (le +) est donc « au dessus » lorsqu’on regarde l’affichage dans le bon sens, avec les « . » vers le bas.
On utilise le connecteur JST-XH qui sert en principe pour l’équilibrage (la charge par exemple), pas le deuxième connecteur (prise BEC/JST, caché en dessous dans la photo) qui ne sert que pour alimenter un circuit.

Connexion d’une batterie 2S (7.4V)
Une fois connecté, l’afficheur indique brièvement combien de cellules contient la batterie qui y est connectée. Puis il affiche en alternance les informations suivantes : n°1 / 4.16 / n°2 / 4.16 / ALL / 8.33, comme sur les photos ci-dessous.

Noter qu’avec un voltmètre, la tension mesurée aux bornes de la batterie (connecteur BEC/JST) est de 7.85V…


Connexion d’une batterie 3S (11.1V)


Je n’ai pas vérifié la tension de cette batterie 3S avec un voltmètre.
Connexion de piles rechargeables
Le module ne fonctionne pas si je branche le – de 6 piles AA (en principe 9V) au – du module et le + à la première broche du module. Il mesure alors 0 volts (photo ci-dessous).

Il faut que je branche le + des 6 piles à la deuxième broche du module, comme s’il s’agissait d’une batterie 2S. Le module affiche alors n°1, n°2, ALL et la tension totale, 8.16 V :

Conclusion
Un moyen satisfaisant d’afficher la tension d’une batterie Lipo ou de piles rechargeables.
Je n’ai pas pu tester l’alarme.
Sur un robot qui reste sous les yeux de l’utilisateur, c’est une bonne solution pour éviter d’abîmer la batterie. Mais il vaudrait sans doute mieux un système qui transmet l’information à l’arduino pour qu’il puisse couper le robot si la batterie est trop faible.
Commentaires récents