par Tom Parkin (Copyright © 2010) exemple email CHEZ exemple POINT com
traduction par Adeline Hirsch (tous droits réservés) adelinehirsch CHEZ gmail POINT com
relecture
Linux est l’un des systèmes d’exploitation les plus évolutifs qui existe aujourd’hui, tant sur de minuscules ordinateurs à carte unique embarqué, que sur les blocs de calculs intensifs. Cependant il y aura toujours des applications informatiques qui ne sont pas adaptés à Linux ; Effectivement, n’importe quel système d’exploitation comporte des surcharges inutiles. Des appareils répondant à cette niche sont nombreux et variés, allant d’appareils PIC de plus faible puissance à des microprocesseurs de meilleur capacités (tels que ceux basés autour de la vénérable puce 8051 d’Intel). En général, chaque appareil ou famille d’appareils est livré avec sa propre pile de logiciel et d’environnement de développement, et jusqu’à présent, toutes les options de développement de ce niveau ont une chose en commun : une conception et un logiciel qui leurs ai propre.
Cela va changer. Bien que presque aussi dynamique et diversifié que l'écosystème de logiciels Open Source, un mouvement de matériel Open Source naissant est tranquillement en train de développer des licences ouvertes de conceptions matérielles pour une large gamme d'applications. Au niveau le plus fondamental, le projet Open Cores vise à développer des conceptions matérielles d’Open Source pour les puces, allant de contrôleurs de mémoire aux modèles de processeurs. Au niveau d'une couche d'abstraction supérieur, des projets tels que le Open Graphics Project développent des conceptions de société de matériel utilisant des composants off-the-shelf. Assis quelque part dans l’entre deux, le projet Arduino vise à fournir une plate-forme de microcontrôleur à usage général, intégrant la conception de la carte Open Source avec des outils de développement de logiciels Open Source.
Arduino a été conçu en 2005 par des étudiants dans une école de design italien, qui était frustrée par le manque de simples plates-formes puissantes pour leurs élèves, à utiliser comme base pour des projets. Dans le style open-source classique, ils ont décidés de construire le leur, et après quelques jours de piratage créatif, le module Arduino embryonnaire est né. Depuis, cela a évolué en un outil pédagogique pour devenir un prototypage rapide et une plate-forme d’amateur avec une communauté mondiale d'utilisateurs.
Le cœur d’Arduino est constitué d'un microcontrôleur 8 bits de la gamme de puces megaAVR d'Atmel, qui est complétée avec des en-têtes E/S et d'une connexion USB ou RS232 pour le téléchargement de code. C'est une conception simple qui conserve une courbe d'apprentissage peu profonde et offre une souplesse remarquable. Propriétés qui, en liaison avec l'octroi de licences open-source de la conception de circuits et de logiciels de pile de l'appareil, ont conduit à une impressionnante diversité d'applications. Non seulement les pirates Arduino explorent ce territoire de tradition geek comme un contrôleur de la Wii-nunchuk pour une rame, ils développent également des projets extrêmement concret allant dans le sens d'un contrôleur pour un réfrigérateur de bière, pour ne pas mentionner de repousser les limites de l'informatique musicale créativite, avec un laser MIDI "harpe".
En accord avec l'héritage open-source d'Arduino, tous les outils nécessaires pour développer un code Arduino se dérouleront sur une plateforme Linux, et le reste de cet article va fournir un tutoriel pour débuter avec le piratage Arduino.
Ce tutoriel a été testé en utilisant un système Crunchbang Linux 32 bits, qui est basée sur Ubuntu 9.04. Lorsque c’est possible, les instructions ont été écrites pour être transférables à d'autres distributions avec un minimum d'efforts.
Tout d'abord, il est nécessaire de se procurer le matériel Arduino. Bien qu'il soit possible de construire un Arduino à la main en utilisant des composants largement disponibles, il est préférable d'acheter une carte préconstruite à partir de l'un des nombreux sites de bricoleurs qui les stockent. Cela évite la nécessité de soudures potentiellement sujettes à erreur ou l’assemblage de planches à pain dès les premiers stades de développement Arduino. Les Arduino prédéfinis peuvent provenir des sites Web liés à celui du projet Arduino, et sont relativement pas cher. Au moment où je rédige, le tarif est d'environ 20 GBP ou 25 USD.
Une fois la carte Arduino obtenue, il est temps de créer un environnement de développement sur un PC Linux. La façon la plus simple de le faire est d'utiliser un module Arduino avec environnement de développement intégré (IDE). Il s'agit d'une application Java qui fournira un soutien pour l'édition de code source et la compilation, téléchargement d’image binaire pour le module Arduino, et une série de terminaux de communication, le tout dans une seule application.
La dernière version d'Arduino IDE au moment où je rédige, est la version 0018. Il est recommandé d’utiliser la dernière version d'IDE.
# Crée un noveau dossier pour y stocker l’IDE
mkdir arduino
cd arduino
# Télécharge l’archive IDE depuis le web
wget http://arduino.googlecode.com/files/arduino-0018.tgz
# Extrait les fichiers de l’archive IDE
tar -xzf arduino-0018.tgz
Depuis que l'IDE Arduino est un programme Java, un Java Runtime Environment approprié doit être installé sur un PC hôte. De plus, l'IDE repose sur des logiciels supplémentaires: GCC pour la compilation du code, binutils et libc pour la création d'une image exécutable du microprocesseur Arduino, et avrdude pour la communication entre le PC hôte et la carte Arduino.
Les privilèges du super-utilisateur seront requis pour installer ces logiciels sur le PC hôte: pour la démonstration on a besoin d’utiliser sudo.
# Installe le JRE de Sun
sudo aptitude install sun-java6-jre
# Installe le compilateur AVR etles outils d’exécution
sudo aptitude install gcc-avr binutils-avr avr-libc
# Installe les outils de communication AVR
sudo aptitude install avrdude
L’Arduino contemporains tels que le Duemilanove, communique avec l'ordinateur hôte via une connexion USB-série. Afin d'accéder à ce nœud de périphérique en tant qu'utilisateur normal sur le PC hôte, il peut être nécessaire d'ajouter votre utilisateur à un groupe avec les droits d'accès au nœud.
# Premièrement, connectez l’Arduino au PC hote via un cable USB
# Ensuite, verifiez la sortie dmesg du PC hote
dmesg | grep -i "usb serial"
[ 1054.569782] USB Serial support registered for generic
[ 1054.569860] usbserial: USB Serial Driver core
[ 1054.594282] USB Serial support registered for FTDI USB Serial Device
[ 1054.594433] ftdi_sio 2-1:1.0: FTDI USB Serial Device converter detected
[ 1054.594651] usb 2-1: FTDI USB Serial Device converter now attached to ttyUSB0
# la sortie dmesg insinue que l’appareil est connecté à ttyUSB0,
# verifies donc les droits d’accès au noeud de l’appareil.
ls -l /dev/ttyUSB0
crw-rw---- 1 root dialout 188, 0 2010-03-09 22:13 /dev/ttyUSB0
# Le groupe "dialout" accède à /dev/ttyUSB0, donc ajoutez l’utilisateur "tom" à ce groupe.
# Vous devez remplacer “Tom” par votre prope nom de login bien évidemment!
sudo usermod -a -G dialout tom
Avec le logiciel de support installé et l'accès au nœud de périphérique USB-série Arduino configuré, l'IDE peut être lancée:
cd arduino-0018
. / Arduino
La carte Arduino Duemilanove est alimentée par le bus USB. Tout ce qui doit être requit pour que cela fonctionne et obtenir de la place, est de le brancher sur votre PC Linux, via un câble USB.
Le module Arduino IDE est assez intuitive et facile à utiliser. Pour illustrer les procédures de base nécessaires à la construction et le téléchargement de code, nous allons utiliser une démonstration de projet simple qui utilise la construction interne LED sur la carte Arduino Duemilanove pour faire clignoter un message en Morse.
/*
* morse.pde
*
* Un exemple de code en Morse de lumière clignotante Arduindo pour Linux Gazette
*
* Tom Parkin, Mars 2010
* tom.parkin@gmail.com
*/
/* Broche numérique d'E/S 13 est une LED sur la carte Duemilanove */
static const int ledPin = 13;
/* Lettres encapsulés/ association de code pour du codage Morse */
struct {
char letter;
char *code;
} morse_letter_t;
/*
* Spécifications du codage Morse, voir wikipedia pour plus d'informations:
* http://en.wikipedia.org/wiki/Morse_code
*/
#define DOTLEN 250
#define DOT ( pulseLed(ledPin, DOTLEN) )
#define DASH ( pulseLed(ledPin, 3*DOTLEN) )
#define SYMBOLSPACE ( delay(DOTLEN) )
#define LETTERSPACE ( delay(3*DOTLEN) )
#define WORDSPACE ( delay(7*DOTLEN) )
morse_letter_t alphabet[] = {
{ 'A', ".-" },
{ 'B', "-..." },
{ 'C', "-.-." },
{ 'D', "-.." },
{ 'E', "." },
{ 'F', "..-." },
{ 'G', "--." },
{ 'H', "...." },
{ 'I', ".." },
{ 'J', ".---" },
{ 'K', "-.-" },
{ 'L', ".-.." },
{ 'M', "--" },
{ 'N', "-." },
{ 'O', "---" },
{ 'P', ".--." },
{ 'Q', "--.-" },
{ 'R', ".-." },
{ 'S', "..." },
{ 'T', "-" },
{ 'U', "..-" },
{ 'V', "...-" },
{ 'W', ".--" },
{ 'X', "-..-" },
{ 'Y', "-.--" },
{ 'Z', "--.." },
{ 0, NULL }
};
/* La function setup pour Arduino */
void setup()
{
pinMode(ledPin, OUTPUT);
}
/* Tourne la LED attaché à 'pin' sur des ‘ms’ milliseconds*/
void pulseLed(int pin, unsigned int milliseconds)
{
digitalWrite(pin, HIGH);
delay(milliseconds);
digitalWrite(pin, LOW);
}
/* Flashe 'letter' en morse sur la LED, basé sur la recherche d’'alphabet'*/
bool encodeLetter(char letter, morse_letter_t *alphabet)
{
int i;
char *code = NULL;
/* Recherche la letter spécifique à l’alphabet */
for (i=0; alphabet[i].letter != 0; i++) {
if (alphabet[i].letter == letter) {
code = alphabet[i].code;
}
}
if (!code) return false;
/* Affiche la lettre */
for (i=0; i < strlen(code); i++) {
if (code[i] == '.') {
DOT;
} else {
DASH;
}
SYMBOLSPACE;
}
return true;
}
/* Flashe 'word' en morse sur LED, base sur la recherche d’'alphabet' */
bool encodeWord(char *word, morse_letter_t *alphabet)
{
int i;
for (i=0; i < strlen(word); i++) {
encodeLetter(word[i], alphabet);
LETTERSPACE;
}
return true;
}
/* Boucle 'main' d’Arduino */
void loop()
{
delay(5000);
encodeWord("LINUX", alphabet);
WORDSPACE;
encodeWord("GAZETTE", alphabet);
WORDSPACE;
}
Il y a un ensemble de points à noter à propos de ce simple "sketch" Arduino (NB: un "sketch" est le terme Arduino pour un projet). Tout d'abord, même si elle ressemble à du code C, les lecteurs perspicaces auront remarqué que ce n'est pas vraiment un programme complet. C'est parce que le module Arduino IDE fournit un grand nombre de fonctionnalités de base derrière les coulisses, laissant le programmeur se concentrer sur la tâche à accomplir plutôt que sur les subtilités de la conduite d'une broche donnée E/S élevée, par exemple.
Une référence complète à l'environnement Arduino est disponible via le site Arduino. Essentiellement, il se résume à une bibliothèque de fonctions utiles (par exemple delay (), ce qui retarde l'exécution du programme pour le nombre spécifié de millisecondes), et deux rappels qui appellent le code Arduino de base pour permettre à un sketch donnée de faire son travail. Comme indiqué plus haut, ces rappels sont setup () pour la configuration initiale, et la fonction loop() pour la boucle principale du programme.
Pour importer ce code dans l'IDE Arduino, lancer l'IDE puis cliquez sur Fichier -> Nouveau pour créer un nouveau sketch. Copiez et collez le code dans la fenêtre de l'éditeur, puis l'enregistrer (Fichier -> Enregistrer) avec un nom de fichier explicite.
Maintenant configurez l'IDE pour communiquer avec votre carte Arduino.
Tout d'abord, demander à l'IDE d’utiliser le port série auquel votre Arduino est attaché en cliquant sur Outils -> Port série et en sélectionnant le port série que nous avons déterminé auparavant (ce qui était / dev/ttyUSB0, dans notre exemple). Selon votre distribution, vous devrez peut-être connecter Arduino à ce port pour qu’il apparaîsse.
Une fois cela fait, mettre l'IDE pour compiler le code pour votre appareil Arduino spécifique en cliquant sur Outils -> Board. Dans votre case auteur, cochez Arduino Duemilanove ou Nano w/ATMega328, qui est la plus récente carte Arduino au moment où je rédige.
Finalement, pour compiler et télécharger le code sur le module Arduino, cliquez Sketch -> Verify/Compile, puis File -> Upload to I/O board. Facile!
Si tout s'est déroulé comme prévu, le module Arduino IDE devrait charger l'application du codage morse compilé sur la carte. Recherchez les lumières TX et RX clignotants sur la carte pour indiquer que la communication est en cours. La carte doit immédiatement exécuter le programme. Après quelques secondes, le module Arduino devrait commencer à clignoter un message en codage Morse avec la LED verte.
Bien que l'IDE Arduino est un excellent outil, les développeurs qui le souhaitent, peuvent utiliser leurs éditeurs favoris à la place pour la génération de code. Ceci est devenus possible en utilisant facilement un excellent script arduino_make.sh de Kimmo Kulovesi, qui exploite les fichiers de construction internes utilisées par l'IDE pour effectuer la compilation et téléchargement du processus Arduino de base de la ligne de commande.
Le mouvement du matériel Open Source est de plus en plus ce qui démontre que la puissance de développement ouvert n'est pas limitée au domaine du logiciel. Le projet Arduino s'appui sur le meilleur du matériel et des logiciels afin d'offrir une grande plate-forme de micro multi-usages Open Source. Que vous soyez un logiciel pirate à la recherche d'une entrée facile dans le monde des appareils intégrés, un enseignant à la recherche d'un dispositif pour fonder un cours d'électronique, ou un concepteur de matériel chevronné en quête d'un environnement de prototypage rapide, vous devez jeter un coup d’œil sur le module Arduino.
Tom Parkin
Tom Parkin a été fasciné par le fonctionnement interne de technologies numérique, depuis que son père lui avait ramené un VIC-20 au milieu des années quatre-vingt. Après avoir passé la plupart de son enfance a démonter des ordinateurs de plusieurs de façons différentes et inventives, il a décidé d'apprendre à les monter à nouveau, une motivation qui l'a amené à entreprendre un degré MEng en Systèmes électroniques ingénieux en 2000. Depuis sa sortie, il a poursuivi une carrière dans le génie logiciel embarqué, et maintenant il sent qu'il a probablement été plus responsable d'ordinateurs qui fonctionnent que d'ordinateurs cassés.
Adaptation française de la Gazette Linux
L'adaptation française de ce document a été réalisée dans le cadre du Projet de traduction de la Gazette Linux
Cet article est publié selon les termes de la Open Publication License. La Linux Gazette n'est ni produite, ni sponsorisée, ni avalisée par notre hébergeur principal, SSC, Inc.
Vous pourrez lire d'autres articles traduits et en apprendre plus sur ce projet en visitant notre site http://www.traduc.org/Gazette_Linux
Si vous souhaitez apporter votre contribution, n'hésitez pas à nous rejoindre, nous serons heureux de vous accueillir.