Shield 4 moteurs ADAFRUIT 1438 pour Arduino

Fiche technique : http://www.mouser.com/ds/2/737/adafruit-motor-shield-v2-for-arduino-932775.pdf

Ce shield pour Arduino permet de commander quatre moteurs analogiques en courant haché, sous une tension maximum de 12 volts, et une intensité allant jusqu'à 1,2 ampères par sortie moteur.
Chacune de ces quatre sorties moteur est réglable, en sens du courant et en tension moyenne, indépendamment des autres, par l'Arduino.
Il est commandé par le bus I2C de l'Arduino, et dispose de 32 adresses possibles pour ce bus, ce qui permet à l'Arduino d'en gérer jusqu'à 32 exemplaires, soit jusqu'à 128 sorties moteur indépendantes.
Les connecteurs à souder
Le gros défaut (au moins pour moi...): il est livré avec les connecteurs en kit, à souder soi-même.
Cela dit, c'est peut-être aussi un avantage, car les connecteurs livrés avec ne sont pas du bon modèle, car ne permettant pas d'empiler d'autres shields par dessus.

Le shield avec les mauvais_connecteurs


Les connecteurs corrects, à commander à part


Le shield avec les bons connecteurs (mais sans celui du bus SPI)

Les branchements

Les prises à brancher.

Il faut d'abord procéder bien sûr à la soudure des connecteurs...
On vérifie que l'adresse I2c du shield est correcte (on verra les détails plus loin)
On enfiche le shield sur l’Arduino en vérifiant que les pattes SDA et SCL de l’Arduino et du shield sont bien électriquement reliées.
Ensuite, et dans l'ordre qu'on veut :

Sur le bornier marqué "5-12 volts", on visse les deux fils venant d'une alimentation convenant à ce qu'on va alimenter (Attention au Plus et au Moins !)

• Pour alimenter des cantons : alimentation 12 volts, ou transfo "N" réglé sur 12 volts.
  
• Pour alimenter des commandes d'aiguillages type "KATO" : alimentation 12 volts.
  
• Pour alimenter des éclairages : alimentation fixe choisie entre 5 et 12 volts, selon les types d'ampoules.
  

Sur le bornier marqué "M1", on visse les deux fils alimentant un appareil (Il y aura une borne Plus et une Moins, qui risquent de s'inverser au cours du temps !)

• Pour alimenter un canton : on relie chacune des deux files de rails à l'une des deux bornes, directement, ou en branchant en série un détecteur de consommation si on veut faire faire du cantonnement à l'Arduino.
  Il n'y a aucun danger à brancher ces deux fils au hasard, il faudra juste les inverser si la locomotive démarre dans le mauvais sens.
  
• Pour alimenter une commande d'aiguillage type "KATO" : on branche chacun des deux fils de commande sur une des deux bornes.
  Il n'y a aucun danger à brancher ces deux fils au hasard, il faudra juste les inverser si l'aiguillage bascule du mauvais côté.
  
• Pour alimenter un éclairage avec des ampoules à incandescence : on branche chacun des deux fils de commande sur une des deux bornes.
  Il n'y a aucun danger à brancher ces deux fils au hasard, et l'éclairage fonctionnera quelque soit le branchement.
  
• Pour alimenter un éclairage avec des LED : on branche chacun des deux fils de commande sur une des deux bornes, mais ...
  DANGER ! si le courant circule dans le mauvais sens, il y aura fort risque de destruction des LEDS, sauf si elles sont protégées contre un inversion du sens du courant.
  

Pour les borniers marqués "M2" à "M4", on opère évidemment de même.

Le bus I2C
Bien qu'inconnu en général du grand public, le bus I2C est extrêmement répandu, et vous en utilisez probablement déjà plusiueurs chaque jour, cachés dans les voitures, téléviseurs, chaînes HI-FI et autres réfrigérateurs et machines à laver.
Il y est utilisé pour faire dialoguer entre eux les différents composants électroniques/informatiques composant tous ces appareils.
Pour ceux qui s'intéressent aux détails de ce bus, en tapant "Bus I2C" dans n'importe quel moteur de recherche, on obtient des dizaines de sites proposant chacun de nombreuses pages d'explications.

Pour les autres, il n'est pas nécessaire de tout connaître, voici ce qu'il suffit de comprendre pour programmer un périphérique quelconque utilisant ce Bus pour dialoguer avec un arduino ou équivalent :
Ce bus comprend deux fils principaux : "SDA" et "SCL" (noms officiels).
Chaque composant utilisant ce bus a une patte "SDA" relié au fil "SDA" et une patte "SCL" relié au fil "SCL".
Il a aussi une troisième patte relié à la masse du composant.
Si des composants ont des masses différentes, ces masses devront être reliées entre elles par un troisième fil.
L'un des composants est le Grand Chef, responsable du bus. En langage informatique, on l'appelle "Le Maître".
Dans notre montage, c'est l’Arduino qui va tenir ce rôle.
Tous les autres composants obéissent au Maître, exécutent les ordres qu'il leur a envoyé et éventuellement, lui renvoient des informations.
En langage informatique, on les appelle "Les Esclaves".(Désolé pour les âmes sensibles...)
Toutes les données (ordres du Maître et renseignements des Esclaves) circulent sur le fil "SDA".
Ce fil joue ainsi le rôle du fil télégraphique d'autrefois, sauf qu'il véhicule des 0 et des 1 au lieu de points et de traits.

"SDA" : .--- -.-. -... ;Merci, Luky Luke...

Le fil "SCL", lui, est un fil dit "d'horloge" qui permet à tous les composants de travailler en cadence.
Il joue un peu le même rôle que le type, sur les galères,qui tapait sur ses tambours pour que les rameurs rament en cadence.
Mais pourquoi je pense aux galères, moi subitement ???

"SCL" : Bong...Bong...Bong...Bong...Bong...; Merci, Asterix...


Fonctionnement du bus I2C
Pour bien comprendre ce fonctionnement en détails, le mieux est d'aller lire toutes les pages l'expliquant sur le WEB.
Mais dans notre cas, ce n'est pas nécessaire, il suffit d'en comprendre seulement les grandes idées.
Pour cela, on peut faire une analogie :.
Imaginons une très grande usine toute neuve, avec 128 halls numérotés de 0 à 127, et donnant tous sur un très long couloir.
Certains de ces halls, suivant les besoins, vont être occupés par des bureaux, des ateliers,..., chacun avec un responsable. Les autres halls vont être laissés vides.
Chaque responsable est capable de lire (et comprendre, car, de 0 à 128, c'est en notation décimale) le numéro de son hall.
L'arduino , qui est le "Maître", seul a envoyer des ordres aux autres (les "Esclaves"), occupe l'un quelconque de ces halls.
Quand il veut envoyer un ordre à quelqu'un, il rédige cet ordre sur une feuille de papier, la glisse dans une enveloppe, et écrit sur l'enveloppe l'adresse du hall destinataire et au verso l'adresse de son propre hall.
Puis il remet cette enveloppe à un coursier qui fait des allers-retours dans le couloir.
Le coursier présente l'enveloppe à tous les "Esclaves".
Celui qui constate que l'adresse sur l'enveloppe est identique à celle de son hall récupère cette enveloppe, l'ouvre, lit l'ordre et l'exécute ou le fait exécuter par ses employés.
Si une réponse et attendu, l'"Esclave" la rédige sur une feuille qu'il glisse dans une enveloppe avec au recto l'adresse du hall du "Maître", et au verso l'adresse de propre hall.




A suivre .
A lire prochainement :

Modifier l'adresse I2C du shield ADAFRUIT 1438

Programmation du shield ADAFRUIT 1438

Adressage du shield

Notion d'octet
Pour ceux qui ne veulent pas se plonger dans l'informatique ou les mathématiques, il est nécessaire d'en comprendre quelques notions de base.
Un octet peut être considéré comme un ensemble de huit "choses" classées dans un ordre précis, chaque "chose" pouvant prendre une valeur parmi deux possibles :
Exemples de couples de valeurs

• Vrai/Faux
  
• OUI/NON
  
• un/zéro
  
• "Y'a du courant..."/"Y'a pas du courant..."
  
• etc...
  

Si on représente l'état de chaque "chose" par un chiffre 1 (pour "Vrai"/"OUI"/"un"/"Y'a du courant...") ou 0 sinon, et en respectant le classement de ces "choses", on obtient une chaîne de huit caractères un et zéro qui peut être manipulé comme un nombre en notation binaire, compris entre 00000000 et 11111111.
(Chaque chiffre (0 ou 1) s'appellera un "bit", le plus à droit, bit de poids faible, porte le numéro zéro, et en allant vers la gauche, on aura des bits de poids de plus en plus fort, le plus fort ayant le bit de numéro sept (7, car on commence à compter à 0).)
Traduit en notation "de tout le monde" (décimale), on obtient un nombre entre 0 et 255.
Traduit en notation "pour l'ordinateur" (hexadécimale), on obtient un nombre entre 00 et FF.
Ces trois notations sont équivalentes.

Modifier l'adresse I2C du shield ADAFRUIT 1438
Pour indiquer à quel "esclave" l'arduino -ou tout autre "Maître"- s'adresse, il place en début de message un octet contenant l'adresse du destinataire.
Toutefois, le bit de poids le plus fort (le bit 7) est utilisé pour autre chose.
On ne dispose donc que de 128 valeurs possibles d'adresse, allant de 0 à 127 en décimal (pour les himains), de 0 à EF pour l'arduino, et de 0000000 à 1111111 pour le fer à souder.
Quand un message circule sur le bus I2C, chaque "esclave" lit l'octet de l'adresse, et compare les sept bits de poids faible à ceux qu'il a en mémoire
Si les deux sont identiques, le message est pour lui. Il lit donc la suite et l'exécute

Principe de la modification d'adresse :

Sans soudure : patte au niveau logique "0"

Avec soudure : patte au niveau logique "1"

Emplacement des points à souder :

Avec soudure : patte au niveau logique "1"


Comment trouver les points à souder ?
Il faut d'abord choisuir une adresse I2C, et s'assurer qu'elle est libre.
Pour cela, je me suis d'abord fabriqué un outil : un plan d'adressage I2C
En réalité, ce pdf est généré à partir d'une feuille de calcul OpenOffice)
Ce fichier contient 128 lignes correspondant aux 128 adresses I2C possibles..
Sur chaque ligne figure la même adresse sous trois notations différentes :

• Colonne de gauche, en noir : notation décimale, pour les humains
  
• Colonnes centrales, en bleu : notation hexadécimale, pour les ordinateurs.
  pour la notation hexadécimale, devant la valeur, en bleu foncé, il faut rajouter la chaîne de caractères "0x", le chiffre zéro suivi de la lettre ixe minuscule, en bleu clair, pour indiquer à l'informatique que nous sommes en hexadécimal)
  
• Colonne de droite, en gris : notation binaire, pour le fer à souder...
  

Adresse à utiliser : 105 (décimale) 0x69 (hexadécimal)

Recherche de la ligne 105 ou 0x69

Alignement des cinq derniers chiffres avec les points à souder

Soudure des points correspondant aux chiffres "1"

Pour illustrer plus facilement la suite, prenons l'exemple d'un réseau fictif (dont le plan n'a aucune importance...) :


Pour un tel réseau, il va falloir :

• Un premier shield qui va gérer les cantons 1 à 4, et que l'humain peut appeler "Cantons_1_4", les sorties "moteur" 1 à 4 de ce shield alimentant respectivement les cantons 1 à 4.
  
• Un second shield qui va gérer les cantons 5 à 8, et que l'humain peut appeler "Cantons_5_8", les sorties "moteur" 1 à 4 de ce shield alimentant respectivement les cantons 5 à 8.
  
• Un troisième shield qui va gérer les aiguillages 1 à 4, et que l'humain peut appeler "Aiguilles_1_4", les sorties "moteur" 1 à 4 de ce shield alimentant respectivement les aiguillages 1 à 4.
  
• Un quatrième shield qui va gérer les aiguillages 5 à 8, et que l'humain peut appeler "Aiguilles_5_8", les sorties "moteur" 1 à 4 de ce shield alimentant respectivement les aiguillages 5 à 8.
  
• Un cinquième shield qui va gérer l'éclairage de la route, avec allumage progressif des lampadaires le soir, et que l'humain paut appeler "Eclairage_Route", la sortie "moteur" 1 de ce shield alimentant les lampadaires, et les sortes "moteur" 2 à 4 restant libres.
  

Il faut maintenant donner une adresse I2C à chaque shield pour que l'informatique s'y retrouve.
Certaines adresses sont à éliminer, par exemple si vous utilisez en plus des modules grove baromètre/thermomètre :


Les adresses 118/119 (0x76/0x77) ne sont plus disponibles :


On peut choisir le plan d'adressage suivant :


Ce qui donne les points de soudure :

Soudures pour l'adresse décimale 96 hexadécimale : 0x60 binaire : 1100000 (Cantons 1..4)

Soudures pour l'adresse décimale 97 hexadécimale : 0x61 binaire : 1100001 (Cantons 5..

Soudures pour l'adresse décimale 98 hexadécimale : 0x62 binaire : 1100010 (Aiguillages 1..4)

Soudures pour l'adresse décimale 99 hexadécimale : 0x63 binaire : 1100011 (Aiguillages 5..

Soudures pour l'adresse décimale 100 hexadécimale : 0x64 binaire : 1100100 (Eclairage route)

A suivre : Programmation du shield ADAFRUIT 1438

Programmation du shield ADAFRUIT 1438
Programmation : notions de base
Nous sommes en présence de deux "entités" qui ne se comprennent pas.
D'un côté, "l'humain" qui peux parler plusieurs langues : français, allemand, anglais, néerlandais,... mais aussi des lagages "informatiques" : Basic, Pascal, C, C++, php,...
De l'autre côté, l'ordinateur, qui ne comprends aucun de ces langages, mais seulement le code machine, une suite d'octets lisible (difficilement) par seulement quelques initiés, et pratiquement impossible à écrire pour tout humain.
Il va donc falloir trouver un interprète pour permettre à l'ordinateur de comprendre l'Humain.
Il en existe de deux sortes :
Pour les langages les plus simples (Basic, php,...), on utilise des "interpréteurs"
Pour les autres langages (Pascal, C, C++,...), on utilise des "compilateurs", plus efficaces, mais plus complqués d'utilisation

Programmation : C++

Le principe est simple :

• L'humain écrit un texte en C++ sur un bout de papier
  
• Il le tape ensuite dans un fichier d'extension ".cpp"
  
• Il le traite avec le compilateur C++, qui va écrire un nouveau fichier exécutable (.exe)
  
• Ce fichier exécutable peut être ensuite installé dans tous les ordinateurs souhaités
  

Programmation de l'Arduino

L'Arduino utilise le langage C++, qui est ...heu... un peu ardu...
Heureusement, les concepteurs de l'Arduino et de ses périphériques se sont arrangés pour faciliter grandement la tâche des non-programmeurs professionnels
99% au moins du code C++ est déjà écrit, et rangé dans des "bibliothèques" prêtes à l'emploi, et le "petit bout" restant est la partie la plus facile à écrire.
De plus, il existe un éditeur gratuit spécialement conçu pour programmer un Arduino.
Pour le télécharger, faites une recherche avec les mots-clé "téléchargement" "éditeur" "Arduino" "français"

Editeur spécialisé pour Arduino, version efn français

Pour écrire le texte, les menus Fichier et Edition fonctionnent de la même façon que pour les autres éditeurs et traitements de texte
Pour insérer une bibliothèque, le menu (pas évident au départ) propose une option "Inclure une bibliothèque". Il suffit alors de cliquer sur le nom d'une bibliothèque dans la liste proposée, et c'est tout.
Pour lancer le compilateur, il suffit alors de cliquer sur "Croquis", puis "Vérifier/Compiler".
Si aucune erreur n'a été détectée, et si l'Arduino est relié à l'ordinateur par son câble USB, on clique sur "Croquis", puis "téléverser".
L'arduino reçoit alors le programme, et le démarre automatiquement.


Réapitulatif

Ecriture du programme
Le programme s'appelle (étrangement) un "croquis" en français et un "sketch"en anglais
Il est sauvegardé dans un fichier de type "*.ino"

Il se décompose en trois parties

La partie "Déclarations"

Cette partie s'adresse au compilateur, et non à l'Arduino
Elle lui indique quelles bibliothèques il devra aller chercher pour faire son travail.
Si les bibliothèques pour le shield n'apparaissent pas dans la liste, c'est que vous devez d'abord les télécharger chez son constructeur :
https://learn.adafruit.com/adafruit-motor-shield-v2-for-arduino/install-software

Inclusion des bibliothèques


La partie "Setup"

Cette partie a deux rôle à jouer.
D'abord, elle permet d'indiquer au compilateur quels sont les shields à utiliser, et sur quels pattes de l'arduino ils seront utilisés.
Exemple, avec le réseau fictif ci-dessous :


Réseau fictif exemple

Chaque shield doit être déclaré et décrit par une ligne :
Adafruit_MotorShield {nom humain du shield}=Adafruit_MotorShield({Adresse hexadécimale sur le bus I2C});
ATTENTION !
Dans les parties de texte en gras, il faut respecter STRICTEMENT les majuscules/minuscules, les espaces et la ponctuation !
Exemple : pour le shield gérant les cantons 5 à 8 depuis l'adresse I2C 0x61, on obtient :

Déclaration indiquent au compilateur que le shield gérant les cantons 5 à 8 s'appelle "Cantons_5_8" et est à l'adresse I2C "0x61"

Mais ce ne sont pas les shields, mais leurs sorties moteurs que nous allons manipuler.
Il faut donc maintenant donner un nom compréhensible par l'humain à chaque sortie moteur, et indiquer au compilateur où il pourra le trouver.
Chaque sortie moteur de chaque shield doit être déclaré et décrit par une ligne :
Adafruit_DCMotor *{nom humain du moteur}={Nom humain du shield auquel il appartient}.getMotor({numéro du moteur sur le shield});
ATTENTION !
Dans les parties de texte en gras, il faut respecter STRICTEMENT les majuscules/minuscules, les espaces, la ponctuation et le "*"!
Exemple : pour le moteur gérant le canton 6 (depuis le moteur numéro 2 du shield "Cantons_5_8"), on obtient :

Déclaration indiquent au compilateur que le canton 6 est géré par le moteur n°2 du shield "Cantons_5_8"


Correspondance entre un shield et les lignes de déclaration


Le SetUp pour 8 cantons.

Pour le réseau fictif, il reste encore trois shields à déclarer, (les aiguillages et l'éclairage),soit :

les aiguillages et l'éclairage.

Ces déclarations sont à insérer juste avant l'accolade fermante du setup :

Les accolades du setup...



A suivre : les ordres qu'on peut donner dans la boucle "Loop", et l'état du réseau au démarrage du réseau

Bonjour

Super Tuto Merci Jicébé

DAN57FRN a écrit:

Bonjour

Super Tuto Merci Jicébé

Merci !

La suite bientôt, promis.

Bonjour,
Très interessant… on pourrait l'associer via I2C avec ce shield PWM 16 channel qui via des minis servos peuvent commander les aiguillages… et ainsi avoir un système de traction et d'aiguillage particulierement complet pour une somme très modique…
Merci…

mistigris a écrit:

Bonjour,
Très intéressant… on pourrait l'associer via I2C avec ce shield PWM 16 channel qui via des minis servos peuvent commander les aiguillages… et ainsi avoir un système de traction et d'aiguillage particulierement complet pour une somme très modique…
Merci…

Je ne connaissait pas encore ce shield.
Je viens d'étudier sa notice.
Effectivement, il semble très intéressant : possibilité de commander par l’Arduino tous les aiguillages commandés par un servo-moteur, et non une ou deux bobines d'électroaimants.
Et avec un adressage I2C modifiable sur 6 bits (6 points à souder), on peut donc en chaîner jusqu'à6, ce qui fait une possibilité de commander jusqu'à 1024 aiguillages !
Attention toutefois, si une adresse I2C est déjà prise pour autre chose, elle ne peut plus être utilisée par un PWM 16 channel, de même que toute adresse utilisée par un PWM 16 channel ne peut plus être utilisée par autre chose...