Shield 4 moteurs ADAFRUIT 1438 pour Arduino

Besoin d'aide pour réaliser un montage sur votre maquette ?
Jicebe
Messages : 410
Inscription : 19 déc. 2013, 10:24
Type de centrale : Analogique et numérique
Localisation : Paris
Contact :

Shield 4 moteurs ADAFRUIT 1438 pour Arduino

Message par Jicebe »

Shield 4 moteurs ADAFRUIT 1438 pour Arduino
Image
Fiche technique : http://www.mouser.com/ds/2/737/adafruit ... 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.
Image
[font=Comic Sans Ms]Le shield avec les mauvais_connecteurs[/font]

Image
[font=Comic Sans Ms]Les connecteurs corrects, à commander à part[/font]

Image
[font=Comic Sans Ms]Le shield avec les bons connecteurs (mais sans celui du bus SPI)[/font]

Les branchements
Image
[font=Comic Sans Ms]Les prises à brancher.[/font]

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.
Image
[font=Comic Sans Ms]"SDA" : .--- -.-. -... ;Merci, Luky Luke...[/font]

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 ???
Image
[font=Comic Sans Ms]"SCL" : Bong...Bong...Bong...Bong...Bong...; Merci, Asterix...[/font]


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
Jicebe
Messages : 410
Inscription : 19 déc. 2013, 10:24
Type de centrale : Analogique et numérique
Localisation : Paris
Contact :

Re: Shield 4 moteurs ADAFRUIT 1438 pour Arduino

Message par Jicebe »

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 :
[tr]
[td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... veau_0.jpg[/img] [i][color=olive] Sans soudure : patte au niveau logique "0" [/color][/i] [/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... veau_1.jpg[/img] [i][color=olive] Avec soudure : patte au niveau logique "1" [/color][/i] [/td][/tr]

Emplacement des points à souder :
Image
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...
Image

[tr]
[td]Adresse à utiliser : 105 (décimale) 0x69 (hexadécimal)[/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... droite.jpg[/img] [/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... 101001.jpg[/img] [i][color=olive]Recherche de la ligne 105 ou 0x69[/color][/i] [/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... droite.jpg[/img] [/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... 101001.jpg[/img] [i][color=olive]Alignement des cinq derniers chiffres avec les points à souder[/color][/i] [/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... droite.jpg[/img] [/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... udures.jpg[/img] [i][color=olive]Soudure des points correspondant aux chiffres "1"[/color][/i] [/td][/tr]

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

Pour un tel réseau, il va falloir :
  • Un premier shield qui va gérer les cantons 1 à 4, et que l'humain paut 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 paut 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 paut 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 paut 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 à élimner, par exemple si vous utilisez en plus des modules grove baromètre/thermomètre :
Image

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

On peut choisir le plan d'adressage suivant :
Image

Ce qui donne les points de soudure :
[tr][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... 8/0x60.jpg[/img] [i][color=olive]Soudures pour l'adresse décimale 96 hexadécimale : 0x60 binaire : 1100000 (Cantons 1..4)[/color][/i] [/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... 8/0x61.jpg[/img] [i][color=olive]Soudures pour l'adresse décimale 97 hexadécimale : 0x61 binaire : 1100001 (Cantons 5..8)[/color][/i] [/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... 8/0x62.jpg[/img] [i][color=olive]Soudures pour l'adresse décimale 98 hexadécimale : 0x62 binaire : 1100010 (Aiguillages 1..4)[/color][/i] [/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... 8/0x63.jpg[/img] [i][color=olive]Soudures pour l'adresse décimale 99 hexadécimale : 0x63 binaire : 1100011 (Aiguillages 5..8)[/color][/i] [/td][td][img]http://jcbecker.free.fr/Modelisme/Mes_M ... 8/0x64.jpg[/img] [i][color=olive]Soudures pour l'adresse décimale 100 hexadécimale : 0x64 binaire : 1100100 (Eclairage route)[/color][/i] [/td][/tr]


A suivre : Programmation du shield ADAFRUIT 1438
Andre
Messages : 1342
Inscription : 16 sept. 2013, 16:41
Type de centrale : Analogique
Localisation : Tournai

Re: Shield 4 moteurs ADAFRUIT 1438 pour Arduino

Message par Andre »

Ici, on retrouve Jean claude le prof!
Tes élèves ont du apprendre de belles choses avec toi .
Jicebe
Messages : 410
Inscription : 19 déc. 2013, 10:24
Type de centrale : Analogique et numérique
Localisation : Paris
Contact :

Re: Shield 4 moteurs ADAFRUIT 1438 pour Arduino

Message par Jicebe »

Andre a écrit :Ici, on retrouve Jean claude le prof!
Tes élèves ont du apprendre de belles choses avec toi .

Fi, donc, jeune homme, que de familiarités...

Image

Môssieur le Professeur, je vous prie !


En fait, je le fais autant pour moi, pour avoir l'esprit clair, que pour les autres...
C'est nécessaire pour aborder toute la partie programmation en toute sérénité,
Image
et résister à l'envie de tout jeter par la fenêtre, arduino, shields et ordinateur, au bout d'un certain temps...
Avatar de l’utilisateur
Philippe
Messages : 1457
Inscription : 09 sept. 2013, 12:22
Type de centrale : Numérique
Localisation : Wavre

Re: Shield 4 moteurs ADAFRUIT 1438 pour Arduino

Message par Philippe »

Lol, j'ai tout compris jusqu'aux branchement M2 et M4 mais après, :? ...
Bon j'ai bien compris que cela servait soit au fonctionnement des moteurs pour aiguillages ou tout autre type d'accessoires, mais que cela apporte-t-il de plus que ce qui est déjà prévu par les fabricants, j'ai un peu de mal à comprendre, à part le prix peut-être ?
Dsl mais l'électronique c'est pas trop mon fort,Jepe, même si tout cela est très bien expliqué et très bien documenté.
Un élève qui demande qu'à apprendre ;)
Un aspect essentiel de la créativité est de ne pas avoir peur d'échouer. Dr. Edwin Land
Jicebe
Messages : 410
Inscription : 19 déc. 2013, 10:24
Type de centrale : Analogique et numérique
Localisation : Paris
Contact :

Re: Shield 4 moteurs ADAFRUIT 1438 pour Arduino

Message par Jicebe »

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élechargement" "éditeur" "Arduino" "français"
Image
[font=Comic Sans Ms]Editeur spécialisé pour Arduino, version efn français[/font]

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.

Image
[font=Comic Sans Ms]Réapitulatif[/font]

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-mot ... l-software
Image
[font=Comic Sans Ms]Inclusion des bibliothèques[/font]


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 :

Image
[font=Comic Sans Ms]Réseau fictif exemple[/font]

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 :
Image
[font=Comic Sans Ms]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"[/font]

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 :
Image
[font=Comic Sans Ms]Déclaration indiquent au compilateur que le canton 6 est géré par le moteur n°2 du shield "Cantons_5_8"[/font]

Image
[font=Comic Sans Ms]Correspondance entre un shield et les lignes de déclaration[/font]

Image
[font=Comic Sans Ms]Le SetUp pour 8 cantons.[/font]

Pour le réseau fictif, il reste encore trois shields à déclarer, (les aiguillages et l'éclairage),soit :
Image
[font=Comic Sans Ms]les aiguillages et l'éclairage.[/font]

Ces déclarations sont à insérer juste avant l'accolade fermante du setup :
Image
[font=Comic Sans Ms]Les accolades du setup...[/font]



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