Arduino / boarduino : Plateforme open source de développement électronique à base de microcontrolleur ARM Atmega8 / AtMega168

Développer sur de l'embarqué n'a jamais été aussi facile. Muni d'une carte électronique à base de microcontrolleur AVR ATMEGA168 à 17.5$, d'un environnement de développement intégré (IDE) open source permettant de développer en Wiring (pratiquement du C) et d'envoyer son programme sur la cible, vous allez pouvoir envisager de développer simplement de petites applications tenant dans 16K de mémoire flash, et controllant de multiples périphériques....

Boaduino Le concept Arduino est né en Italie. Le cap des 10000 cartes produites a été passé en Aout 2007 ce qui démontre bien la popularité du montage. Il est aussi bien utilisé pour commander de petits robots, a des fins d'éducation, pour de la commande moteurs, pour des vêtements électroniques, pour faire des réseaux de capteurs, des sculptures électroniques... Il n'y a pas de limite à son utilisation.

De nombreux autres fabricants on décliné le concept, parfois dans des formes assez inattendues.. (voir en bas de ce post, la liste des sites proposant des cartes basées sur le même concept). Il est ainsi très facile de trouver une carte dont le format, les caractéristiques et le prix seront adaptées à votre projet...

La Carte

Basé sur un microcontrolleur Atmega8 pour les premières générations (8Ko de flash) et d'un Atmega168 pour les dernières générations (16Ko de flash, 1Ko de Ram, 512 Octets d'e2prom), ces cartes proposent sur une surface réduite :

  • Le microcontrolleur
  • Un bouton de reset
  • Un oscillateur à quartz (Arduino) ou à résonateur céramique (Boardino) à 16 Mhz ou 20 Mhz. Certaines cartes utilisent même l'étage d'oscillation intégré au composant (oscillateur R/C!!), mais au détriment de la précision de l'horloge et de la vitesse.
  • Un étage de régulation 5V embarqué, permettant d'alimenter la carte par un adaptateur secteur de 7 à 12V. Cet étage peut e pas être utilisé, si on souhaite alimenter la carte par le port USB.
  • Un connecteur ICSP à 6 broches permettant la reprogrammation in situ, mais nous verrons plus loin qu'il n'est pas indispensable d'utiliser ce connecteur pour programmer la carte
  • D'une liaison série, soit au travers d'un connecteur USB intégré à la carte par l'intermédiaire d'un composant FT232, soit par un connecteur RS232 standard, soit au format TTL (attention, convertisseur TTL/RS232 requis pour branchement sur PC...). Cette liaison permet d'envoyer le programme sur la cible par l'intermédiaire de l'IDE, comme nous le verrons plus loin.
  • 14 entrées / sorties numériques donc 6 avec sortie PWM (modulation de largeur d'impulsion) pour commandes moteur à courant continu et permettant de sortie jusqu'à 40ma par sortie.
  • 6 entrées analogiques 10 bits, avec calibration intégrée sur du 5V, bien qu'il soit possible de fournir une référence de tension sur une broche "Aref" (analog reference)
  • Sur l'atmega168, support des communications I2C et SPI, bien que dans ce cas trois broches d'entrée/sortie soient détournées de leur usage premier

L'Arduino originale, modèle diecimilia. A noter les connecteurs permettant de brancher une carte sur le dessus pour le prototypage, le connecteur USB et le connecteur pour l'alimentation.

A moins de 18$, ce kit 'Boarduino' représente une aubaine pour faire du développement... Points clés : sa petite taille et la connectique en dessous, car la carte est livrée avec une plaque à essais, permettant de faire des montages sans soudure. Par contre, la liaison série est au format TTL 5V, nécessitant un câble d'adaptation TTL/RS232 ou TTL/USB en option.

De nombreuses autre variantes existent, comme la lilipad, spécialement étudiée pour les vêtements électroniques, passerait même à la machine en choisissant sa lessive (non, cest pas un gag...)

Le Logiciel :

L'environnement de développement est un modèle du genre. Joli, facile à utiliser et à installer, il dispose de tout ce qu'il faut pour développer vos applications :

  • Un éditeur intégré, avec coloration syntaxique
  • Compilation simple par un simple bouton, avec affichage des erreurs dans l'ide.
  • De nombreux exemples de programmation, permettant de démarrer très vite
  • Des bibliothèques très simples à utiliser et permettant de mettre en œuvre des fonctions complexes comme la programmation de l'e2prom, la gestion de liaisons séries supplémentaire uniquement par soft (sans uart, donc), la gestion de moteurs pas à pas, etc..
  • La gestion d'un programmateur in situ pour reprogrammer le chargeur de démarrage (boot loader)
  • Et surtout la gestion de l'envoi de votre programme à la cible par une liaison série directe, ou émulée au travers d'un port USB.

C'est vraiment ce point qui a fait le succès de ces cartes. Un chargeur de démarrage est intégré à la carte, et prend 2Ko sur les 16Ko de flash. Grâce à ce chargeur, l'environnement de développement est capable de télécharger dans la carte votre programme, en prenant bien soin de ne pas écraser le chargeur. Du coup, les cycles de compilation / programmation du composant / test sont très simplifiés : il suffit d'appuyer sur un unique bouton qui fait le tout...

Le language utilisé est une variante du langage Wiring, lui même étant une variante du C. La référence de ce langage se trouve ici : http://www.arduino.cc/en/Reference/HomePage. C'est très facile à utiliser.

L'environnement de développement fonctionne sous Linux, Mac OS et toutes versions de Windows (y compris Vista).

Premiers pas :

Au risque de me répéter, il existe 2 méthodes pour développer sur la carte : soit en branchant le câble USB ou la liaison série, soit en branchant un programmateur In situ. Cette dernière méthode est moins bien intégrée dans la version 10 de l'environnement de développement, car si on peut programmer le booloader, on ne peut pas encore envoyer l'application. Deux bonnes nouvelles, cette fonction sera de retour dans la version 11 d'une part, et j'ai trouvé une méthode pour l'intégrer d'autre part (voir en bas de ce post).

La méthode 'USB ou série' est à privilégier pour les débutants. En effet, sa mise en œuvre est réellement très simple et permet tout de suite de débuter avec la carte. Quelqu'un de plus expérimenté préfèrera la méthode ICSP, car elle permettra non seulement de jouer avec le kit de développement, mais également de programmer d'autre cibles, d'autres composants vierges avec le chargeur de démarrage ou l'application, etc... Bref de ne pas se limiter à la carte d'évaluation.

Une vue de la cible et des 2 méthodes de programmation peut être consultée ICI :

Les 2 méthodes permettent d'alimenter la carte, en plus d'une troisième disponible sur la carte (connecteur 7 à 12V). Il est possible de raccorder le programmateur ICSP et le cable USB en même temps, mais dans ce cas il faudra soit enlever le jumper d'alimentation du programmateur ICSP, soit positionner le jumper d'alimentation de la boarduio sur 'ext' (alimentation externe).

Cartes additionnelles :

Il existe de nombreuses cartes qui peuvent se plugger sur le design original de la carte. Voir par exemple sur http://www.arduino.cc/en/Main/ArduinoShields. De nombreuses fonctions sont au rendez vous, comme de la commande moteur pas à pas, des modules Xbee, bluetooth, des cartes de prototypage, etc...

Les différents constructeurs :

Références :

Hacks :

  • Utiliser le programmateur USBTiny pour envoyer son programme à partir de l'environnement arduino (testé avec boarduino) :

Pour ce faire, il faut créer une nouvelle carte dans le fichier de description situé dans (rép. d'instal de l'ide)\arduino-0010\hardware\boards.txt en ajoutant à la fin :

##############################################################

boarduino.name=Boarduino Dieciemilia via USBTiny

boarduino.upload.protocol=usbtiny
boarduino.upload.maximum_size=14336
boarduino.upload.speed=19200

boarduino.bootloader.low_fuses=0xff
boarduino.bootloader.high_fuses=0xdd
boarduino.bootloader.extended_fuses=0x00
boarduino.bootloader.path=atmega168
boarduino.bootloader.file=ATmegaBOOT_168_diecimila.hex
boarduino.bootloader.unlock_bits=0x3F
boarduino.bootloader.lock_bits=0x0F

boarduino.build.mcu=atmega168
boarduino.build.f_cpu=16000000L
boarduino.build.core=arduino

Il suffit ensuite de sélectionner cette nouvelle carte dans le menu Tools/Board de l'ide. Attention toutefois, il faut reprogrammer le loader avant d'envoyer l'application, et ce à chaque fois...