L’assignation d’un état LOW/HIGH sur une pin de votre Arduino, se fait couramment à l’aide de la méthode digitalWrite(pin, state). RazorConcepts nous présentait il y a quelques semaines une nouvelle méthode pour assigner des états aux pins de votre Arduino. Jugeant cette méthode très intéressante, j’ai décider d’aller aujourd’hui un peu plus loin dans l’explication de cette technique.

La méthode consiste en effet à assigner directement des valeurs (binaires ou hexadécimal) aux variables PORTB PORTC et PORTD, correspondant au trois encarts ci-dessous.

Chacun de ces ports du micro-contrôleur utilisé par l’Arduino possède de 6 à 8 entrées/sorties. Ainsi, à chaque pins de la platine correspond un couple PORT / numéro d’entrée/sortie.

// sortie 543210
//        ↓↓↓↓↓↓
PORTC = 0b110110;

• Notation explicite
• Passer une sortie spécifique à l’état HIGH
• Passer une sortie à l’état LOW
• Notation groupée, basculement simultané
• Inverser l’état d’une sortie
• Gain de poids, gain de perfs
• Conclusion

Notation explicite

Si vous souhaitez modifier l’ensemble des états de plusieurs sorties d’un même PORT, il est possible d’écrire explicitement la valeur (complète) de ce dernier. On souhaite par exemple définir les états des pins digitales 7, 5 et 2 de l’Arduino à HIGH, et les pins 6, 4, 3, 1 et 0 à LOW. Les pins digitales 0 à 7 de l’Arduino correspondent aux sorties 0 à 7 du PORTD.

// sortie 76543210
//        ↓↓↓↓↓↓↓↓
PORTD = 0b10100100;
PORTD = 0xA4; // notation hexadécimale

L’état 1, symbolise l’état HIGH, l’état 0, l’état LOW. Le numéro de sortie commence à zéro et part de la droite vers la gauche (du LSB au MSB). Pour la conversion binaire, hexadécimale, rien de plus simple qu’une requête Google

Les assignations explicites peuvent s’avérer utile dans la méthode setup() visant à initialiser l’état de votre circuit. Il permet également de rendre votre code source plus pro, et plus légé

Passer une sortie spécifique à l’état HIGH

Prenons comme exemple le passage de la pin digitale 3 à HIGH. Le schéma nous montre que la pin digital 3 se trouve sur le PORT D3.

//  sortie 76543210
//         ↓↓↓↓↓↓↓↓
PORTD |= 0b00001000 (PORT PD3)

ou encore avec l’une des notations suivantes

PORTD |= 0b1000
PORTD |= 1 << 3;
PORTD |= _BV(3);

Le shortcut _BV est définit dans ./hardware/tools/avr/avr/include/avr/sfr_defs.h de l’IDE Arduino. Contrairement à l’assignation explicite, ces opérations, utilisant la porte logique OR, ne modifie que l’état de la ou des sorties souhaitées.

Passer une sortie à l’état LOW

Nous souhaitons, définir l’état de la pin digitale 11 à LOW, soit le PORT B, sortie 3. C’est à l’aide des portes logiques AND et NOT que nous pouvons écrire :

PORTB &= ~0b00001000

Ou l’une de ces notations équivalentes :

PORTB &=  0b11110111
PORTB &=  B11110111 // constante
PORTB &= ~(1<<3)
PORTB &= ~_BV(PB3);
PORTB &= ~_BV(3);
// Ou enfin, en hexadécimal
PORTB &= ~0x8;
PORTB &= 0xF7;

Les constantes B* sont définies de B0 à B11111111

Notation groupée

Si les sorties, dont on souhaite modifier l’état, se trouvent sur le même port, il est possible de grouper l’ensemble des instructions en une seule. Nous souhaitons dans notre exemple passer les pins 6, 2 et 1 à LOW. Commençons par écrire chacune des trois instructions nécessaires à cet exemple.

PORTD &= ~B01000000  // sortie 6, port D
PORTD &= ~B00000100  // sortie 2, port D
PORTD &= ~B00000010  // sortie 1, port D

L’opération étant la même (passage à LOW) et concernant les sorties d’un même port (le D), il est donc possible les additionner

pin D6 => PD6  0b01000000
pin D2 => PD2  0b00000100
pin D1 => PD1  0b00000010
               __________
on additionne  0b01000110

L’opération “groupée” à effectuer est donc

PORTD &= ~0b01000110
//           ↑   ↑↑
//           6   21  fixe les sorties 6,2 et 1 du PORT D à LOW
//                   sans modifier l'état des autres sorties

Ce type de programmation permet donc un basculement simultané (en un cycle processeur) de plusieurs sorties. Dans le meilleur des cas, 9 cycles processeurs sont nécessaires avec la méthode classique digitalWrite.

Explication sur l’opération AND NOT &=~..

gardons notre exemple du triple passage à LOW (sorties 6, 2 et 1).

~ est l’opérateur NOT qui permet “d’inverser” la valeur des bits
~..000001000110  =  ..111110111001

le nombre de 1 devant la notation binaire dépends de l’architecture du microprocesseur (ici 8 bits)

On peut donc écrire,

  //       7 543  0
  //       ↓ ↓↓↓  ↓    keep on if on
PORTD &= 0b10111001
  //        ↑   ↑↑
  //        6   21     switch off if on

On renseigne enfaite ici les bits à maintenir allumé, si ils le sont déjà.

Ainsi, dans ce même exemple (mettre pin 6,2, et 1 à LOW) supposons, au hasard, un état du port D initial à 0b01011101

Nous appliquons l’opération PORTD &= ~B01000110 vu précédemment, qui peut également s’écrire :

PORTD &= 0b10111001
PORTD = PORTD & 0b10111001
PORTD = 0b01011101 & 0b10111001 

//      0b01011101
//  &   0b10111001
//      ----------
//      0b00011001
//        ↑↑↑↑↑↑↑↑
// sortie 76543210

On applique l’opération AND sur chaque bit, (rappel : 0b1 & 0b1 = 0b1)

l’état final, 0b00011001, montre donc bien une modification de l’état des sorties 6 et 2 à LOW (la pin 1 étant déjà à LOW). Cette opération n’a eu aucune incidence sur l’état des autres pins, comme souhaité ; le tout en un seul cycle.

Inverser l’état d’une sortie

Exemple : nous souhaitons inverser l’état de la sortie 5 et 7 du PORTD. Dans un cas concret, deux LED clignotant en alternance l’une de l’autre sur les pins digitales 5 et 7.

int state = 1;

void setup() {}
void loop() {
  if(state==1) { // on réalise l'alternance à l'aide d'une variable
    state = 0;
    digitalWrite(5, LOW);
    digitalWrite(7, HIGH);
  }
  else {
    state = 1;
    digitalWrite(5, HIGH);
    digitalWrite(7, LOW);
  }
  delay(1000); // on attend 1 seconde
}

Avec les opérations binaires, la fonction XOR nous permet d’écrire

void setup() {
  PORTD = B10000000; // on définit l'état initial
}
void loop() {
  //sorties 7 5
  //        ↓ ↓
  PORTD ^= B10100000; // ou PORTD ^= 0xA0;
  delay(1000);
}

Une fois compilée, on obtient une ROM de 550 bytes en opération binaire contre 846 bytes en écriture standard.

Autre avantage, si l’on souhaite modifier l’état initial (pour par exemple faire clignoter les LEDs ensembles), une seule modification suffit, l’état initial de PORTD.

Gain de poids, gain de performances

Voici un exemple simple mettant en œuvre un chenillard à 8 LEDs. En écriture “binaire”

int lednum = 0;

void setup(){}
void loop() {
  PORTD = 1 << lednum; // un seul cycle processeur
  delay(1000);
  lednum++;
  if(lednum==8) lednum = 0;
}

Le même algorithme en écriture standard

int lednum = 0;

void setup(){}
void loop() {
  digitalWrite(0, LOW); // on éteint l'ensemble des LED
  digitalWrite(1, LOW);
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  digitalWrite(6, LOW);
  digitalWrite(7, LOW);
  digitalWrite(lednum, HIGH);
  delay(1000);
  lednum++;
  if(lednum==8) lednum = 0;
}

Une fois compilé on obtient ici un programme 588 bytes contre 886 bytes avec le premier code source.

Sur ces quelques exemples concrets, le gain en poids est de l’ordre de 35 %. Toutefois, si l’on soustrait à ces tailles de programme les 436 bytes occupés par un programme vide (afin de ne retenir uniquement la taille de l’espace occupé par les instructions propres au programme). On obtient une taille de 152 bytes contre 450 bytes, soit une réduction de 66% du code.

Conclusion

Outre le gain de taille, crucial sur un microprocesseur de ce type, le gain en performances. Un benchmark réalisé par RazorConcepts montre des temps de réponse 10 fois supérieurs à la fonction standard digitalWrite() proposée par l’IDE Arduino.

Bien entendu, je vous ai présenté ici les exemples “qui vont bien” (même PORT, opérations simples,.. ). Il y a fort à parier que dans d’autre cas, plus spécifiques, les instructions binaires ne soit pas nécessairement un choix très judicieux.

Ainsi, à moins de frôler dangereusement la limite imposée par votre micro-contrôleur (16 ou 32K), l’utilisation de cette technique reste dédiée aux librairies, aux montages nécessitant une réactivité accrue, ou ceux nécessitant des changements d’état simultanés.

Trois opérations à retenir :

• le OR (|=) qui permet de modifier la valeur des bits choisi à 1, et donc de passer les sorties à l’état HIGH.
• le AND NOT (différent de NAND !) (&=~) qui permettra de “soustraire 1″ aux bits choisis, et permet donc de mettre des sorties à l’état LOW
• le XOR (^=) qui permettra d’inverser l’état des sorties renseignées pas un bit positif

D’un point de vue software, le code utilisé pour le projet (open source, PDE) est réellement intéressant dans la mesure où la détection ne tient pas compte de la vitesse à laquelle le “motif” secret est réalisé.

La librairie utilisée (ZIP) (mirroir) est assez bien conçue. Orientée objet, elle est capable de gérer plusieurs télécommandes. Voici un exemple d’utilisation en mode single-remote :

#include  // lib Apple Remote

AppleRemoteSender rmt = AppleRemoteSender(13); // LED-IR pin 13

void setup()
{
    attachInterrupt(0, rmt.play, RISING); // boutton sur pin 0
}

Avec ce code, relativement simple, à chaque impulsion sur la pin 0 de la platine Arduino, le signal play/pause est envoyé au mac, et iTunes par exemple joue / s’arrête de jouer (Documentation sur la fonction attachInterrupt).

Avec des logiciels freeware comme Remote Buddy il vous devient possible de faire faire quasiment n’importe quoi à votre Mac avec la complicité de votre Arduino. Tâchez de vous en inspirer pour les concours du moment.

Pour palier à ce problème “financier”, Hobby Robotics, nous présentait il y a environ 2 mois une solution alternative, bien plus accessible, nous permettant de faire communiquer deux platines Arduino. Vendu chez SparkFun [1], le module RF (TX et RX), vous offre une connectivité unidirectionnelle à moins de $10.

Let’s make robots nous publie aujourd’hui un test de cette solution. Les résultats semblent concluants et conformes aux promesses du fabricant. Le lien s’établit encore à 150 mètres avec un débit de 2400 bauds (largement suffisant selon l’application).

La librairie utilisée quant à elle, VirtualWire (ZIP), développée par Mike McCauley, permet la transmission de messages avec checksum entre les deux Arduino dûment équipées. Concrètement, le checksum (somme de contrôle) permet de vérifier l’intégrité des données reçues, pour en demander une nouvelle copie en cas de transmission défaillante par exemple. En attendant livraison de votre commande, je vous conseille la documentation très détaillée sur l’utilisation de la libraire VirtualWire (PDF).

[1] ceci n’est pas un billet sponsorisé

• un Arduino Mega,
• un Arduino PRO,
• un screw shield (pour visser votre câblage, à votre Arduino).

Cadeau de la maison, arduinofun nous indique explicitement qu’il est possible de concourir avec le même projet chez leur confrère Instructables.
Objectif de ce concours : montrer les possibilités de la platine aux autres utilisateurs, la condition essentielle pour participer au concours étant d’y publier le code source utilisé. C’est ici une excellente initiative.

void buzz(int targetPin, long frequency, long length) {
  long delayValue = 1000000/frequency/2;
  long numCycles = frequency * length/ 1000;
  for (long i=0; i < numCycles; i++)
  {
    digitalWrite(targetPin,HIGH);
    delayMicroseconds(delayValue);
    digitalWrite(targetPin,LOW);
    delayMicroseconds(delayValue);
  }
}

// utilisation
buzz(4, 2500, 1000); // buzz sur pin 4 à 2500Hz

Voici l’une des fonctions les plus intéressantes selon moi, qui a inspiré le projet, (infos détaillées sur le blog de Rob Faludi) à essayer telle quelle si un buzzeur vous tombait par hasard sous la main.

L’ensemble de la démarche est très détaillée, c’est un véritable how-to qu’on nous offre. Le matériel utilisé :

• une Arduino, naturellement
• un clavier PS2
• un iPhone jailbreaké
• un serveur VNC sur l’iPhone, il serait donc possible de simuler des touchers d’écran (idée à creuser).
• un mini client VNC qui écoute le port “série” de l’iPhone.

Voir l’article

Source : blog Arduino

• ComputerWorld : Qu’est ce qui a poussé au développement de l’Arduino ?

Tom Igoe: Il y avait une poignée d’écoles enseignant les micro-contrôleurs à des non-technologues en utilisant une méthode que nous avons appelé le calcul physique (physical computing). Nous avons tous besoin d’outils pour enseigner qui soit plus simple que les outils d’ingénierie existant sur le marché. Le Basic Stamp, et plus tard le BX-24 de NetMedia, étaient correct mais ne correspond pas réellement non plus aux outils que nous utilisions pour enseigner la programmation (Hypercard, Director, et ensuite Processing). Puis, à Ivrea en 2002, ont alors été créés Programa2003, Wiring, puis enfin Arduino.

• L’équipe de développement d’Arduino était alors composée de Massimo Banzi, David Cuartielles, Gianluca Martino, David Mellis, Nicholas Zambetti – qui furent les pionniers – et vous-même. Quel rôle avez vous joué dans ce projet ?

Massimo à développé l’environnement Programa2003 pour micro-contrôleurs PIC, un outils simple de développement sous MacOs (la plupart des étudiants d’Ivrea étant des Mac users). L’outil a facilité l’enseignement de la programmation sur micro-contrôleurs. Cela, combiné avec l’IDE Processing (open source) a servi d’exemple à d’Hernando Barragán pour développer la platine Wiring ainsi que son environnement. Rapidement, Massimo (professeur à Ivrea), David Cuatielles (chercheur à Ivrea), et Gianluca Martino (ingénieur, recruté pour développer du matériel pour les projets des élèves) ont développé une plus petite, et moins coûteux platine, la platine Arduino. C’est avec Mellis et Zambetti (étudiants à Ivrea à l’époque), qu’ils ont amélioré la base du Wiring, et élaboré une platine et son IDE utilisable en dehors de l’université.

Je les ai rejoint en 2005, contribuant aux bêta tests avec une autre école, ITP (ayant une population étudiante plus importante qu’Ivrea), et plus tard, en aidant à la rédaction de la documentation. J’ai également présenté l’équipe à certains distributeurs aux États-Unis afin que nous puissions créer un marché ici, ainsi qu’en Europe. Aujourd’hui, Gianluca et Massimo s’occupent de l’essentiel de la conception matériel, Mellis Dave coordonne ou écrit la plupart des logiciels, David Cuartielles travaille sur des logiciels ainsi que des tests sur Linux et gère le site Internet, et je travaille sur la documentation ainsi que des tests, à un degré moindre.

Nous travaillons tous ensemble sur la direction du projet, les relations avec les fabricants et les nouveaux développements. Gianluca gère l’ensemble des distributeurs ainsi que son entreprise, Smart Projects, fabricant principal de la board. Zambetti a quitté l’équipe , mais reste un collaborateur occasionnel lorsque sa vie professionnelle le permet.

• En étiez-vous à essayer de résoudre un problème en particulier ?

Nous voulions un outil pour enseigner l’informatique physique, particulièrement la programmation de micro-contrôleurs, aux artistes et designers, ceux à qui nous enseignons. Les aprioris de ceux qui viennent d’un milieu autre que les sciences informatiques ou en génie électrique sont très différentes, et nous voulions des outils qui correspondent à cette diversité.

• D’où vient le nom Arduino?

Arduino a été le premier roi de la région dans laquelle est situé Ivrea, nom également employé par un bar local où les étudiants et les professeurs d’Ivrea se rassemblaient.

• Y at-il eu des difficultés particulières, voire frustrantes à surmonter dans le développement de l’Arduino?

Le plus grand défi n’a pas réellement été un choix technique, mais plutôt un choix culturel. La plupart des gens en informatique ou en génie électriques que j’ai rencontrés ont une image bien forgée sur la façon d’apprendre le développement autour d’un micro-contrôleurs : apprendre en un premier temps la loi d’Ohm et la loi de Thévenin, etc. Viennent alors les circuits à transistors et des amplificateurs opérationnels, enfin les circuits intégrés les plus simples (IC). Parfois vous apprendrez à utiliser un oscilloscope ou un multimètre, si cela est nécessaire.

Ont vous présente alors enfin les micro-contrôleurs, à commencer par la structure interne et les registres de mémoire. Ensuite, vous découvrez le langage assembleur, et d’ici là, «bien sûr», vous connaissez le C et l’environnement en ligne de commande, si vous êtes prêt pour, disons, CCS C (sur PIC) ou AVR Studio. Et 90% de cela est fait sous Windows, parce que 90% du monde fonctionne sous Windows, il est donc logique d’y développer dessus.

De nos jours, un grand nombre de personnes amené à coder sur des micro-contrôleurs ne viennent pas de ce contexte. Ils ont grandi en considérant que l’interface graphique de l’ordinateur était son interface principale. Ils supposent aussi que vous pouvez apprendre en copiant et modifiant le code, un peu comme ce qu’offre le navigateur internet avec le ‘view source’. La plupart d’entre eux ne veulent pas réellement être des programmeurs, ils veulent juste “utiliser” la programmation et les circuits pour arriver à leur fins. J’entends par là créer une œuvre d’art, alimenter automatiquement la gamelle son chat, ou concevoir un nouveau dispositif d’ergothérapie.

Ces gens ne sont pas officiellement formé comme des ingénieurs, mais veulent construire des choses. Nous enseignons à des étudiants. C’est en accord avec leur façon de penser que nous avons conçu l’Arduino.

• Qu’auriez vous fait différemment dans le développement de l’Arduino, si vous aviez eu la possibilité?

Je pense que le principal changement que nous aurions pu faire aurait été d’uniformiser l’espace entre les pins 7 et 8! Nous avons pas mal d’ennuis à cause de cette erreur, mais nous avons maintenu le non-espacement standard pour maintenir la compatibilité ascendante des boards (NDLR : et leur shield).

Cependant, d’une manière générale, je ne pense pas qu’il y ait une réponse à “Que feriez-vous différemment”, car lorsque nous rencontrons quelque chose que nous aurions du faire différemment, nous le faisons différemment.

Les changements sont plus délicat, maintenant que nous avons beaucoup d’utilisateurs, mais restent encore possibles.

• Pourquoi avoir choisi respectivement ‘Wiring’ et ‘Processing’ comme bases pour le langage Arduino et son environnement ?

Car ils avaient déjà leur place à Ivrea (et ITP) à l’époque, et parce qu’ils étaient de meilleurs dispositifs d’enseignement pour nos étudiants comparés aux autres disponibles à l’époque.

Processing en particulier apportait de gros changement au sein des écoles d’art et de design enseignant la programmation, car les étudiants “y arrivaient”. Il était donc logique d’offrir un environnement de développement (IDE) basé sur celui-ci. Programa2003, Wiring, et Arduino ont tous grandi à partir de Processing en succession rapide.

• Comment comparer l’Arduino aux BASIC Stamp, PICS, etc. ? Qu’est-ce qui en fait un meilleur choix ?

Il existe un certain nombre de choses que nous avons essayé d’améliorer.

Le langage Arduino est un ensemble de méthodes en C / C + + qui le rend plus facile à comprendre pour les débutants.
Contrairement au Stamp PBASIC, l’Arduino possède toutes les fonctions puissantes de C (passage de paramètres, variables locales, et ainsi de suite) conscrites dans une syntaxe lisible. PBASIC était lisible et facile pour les débutants, mais il était si limitée que même les débutants atteignaient rapidement ses limites

L’expérience utilisateur de l’Arduino est plus proche de l’utilisateur “consommateur”.
Il n’est pas nécessaire de s’attarder sur un programmeur hardware (contrairement aux environnements PIC), il se branche directement au port USB (contrairement au STAMP). La compilation et l’upload du nouveau code à votre contrôleur est réalisé en un seul clic. Les noms de méthodes sont “verbeux”, et plus proche dans l’esprit à la langue de tous les jours que le C, l’assembleur, ou tout autre langages de bas niveau.

Idéalement, l’expérience utilisateur est conçue pour minimiser le temps entre l’idée et la conception sur la board, tout en maintenant la puissance et la souplesse des composantes sous-jacentes autant que possible.

Arduino incarne ce que j’appelle “glass box encapsulation”.
Cela signifie que vous n’avez pas besoin de regarder le code de bas niveau qui comprend les bibliothèques si vous ne voulez pas le faire, mais vous pouvez si vous le souhaitez. NDLR: c’est un peu ici l’esprit du langage python, ou plus généralement même des frameworks OS.

Les bibliothèques sont compilées uniquement lorsque vous compilez votre sketch final. Donc, si vous voulez les modifier, vous le pouvez. Si vous souhaitez inclure du C “non-Arduino-style” dans votre code, vous le pouvez. Si vous voulez inclure du code assembleur brut, vous le pouvez.  L’”encapsulation box” est toujours là, mais vous pouvez voir à travers si vous le voulez.

Les contrôleurs de niveau comme le STAMP n’inclus pas cela. Et les environnements de niveau inférieur ne réalisent pas l’abstraction au même niveau que nous le faisons.
La board comprend un serial bootloader sur le micro-contrôleur, et un adaptateur USB/série, vous n’avez donc pas à vous préoccuper de l’interfaçage ou de la compatibilité ordinateur/micro-contrôleur.
La board possède également un prise d’alimentation jack et switch automatiquement entre l’alimentation USB et l’alimentation externe, toujours dans le but de simplifier le passage ordinateur / fonctionnement stand-alone. NDLR : il est également possible d’alimenter la board via les pins GND et + 5V (alimentation non régulée).

Le prix de la board reste raisonnable (moins cher qu’une board STAMP) et le logiciel est gratuit.
Nous voulons que les gens pense développement, plutôt que de voir leur contrôleur comme une seule unité qu’ils ne peuvent pas se permettre de dupliquer.

Le tout est open source, afin que vous puissiez faire votre propre version de celui-ci si vous avez envie de faire.
Le nombre de fork nous montre que la platine est réellement utile à certains de nos utilisateurs. La continuité des ventes de la platine officielle, elle, nous indique que d’autres ont aussi la valeur de la commodité.

Dès le début, le logiciel a été multi-plateformes.
Enseigner dans les écoles où les élèves sont à 90% sous Mac, à été une énorme amélioration pour nous.

À ITP, nous avons réussi à “libérer” un laboratoire du support du logiciel propriétaire (Windows-only) que nous utilisions alors pour le PIC. Les étudiants apprécient de pouvoir utiliser des outils sur n’importe quel système d’exploitation avec lesquels ils sont familiers.

• Quel impact pensez-vous que cette décision a-t-elle eu?

Nous pensons que l’ouverture est bénéfique à l’innovation. Le caractère open source de celui-ci a eu un impact énorme sur sa propagation, je pense. Il y a des tonnes de clones sur le marché. Beaucoup d’entre eux ne cherchent même pas une clientèle au-delà de leurs amis, étudiants, etc. Mais il y a une grande valeur d’apprentissage à faire votre propre version d’un outil que vous utilisez.

Je pense que beaucoup de personnes font un clone tout simplement parce qu’ils le peuvent, et qu’ils pensent que ça va être fun. Dans le processus, ils apprennent quelque chose, et ils deviennent vite accroc à en apprendre plus. Cela n’arriverait pas si la plate-forme était fermée.

• Nous avons entendu les développeurs ont exprimé le souhait que le nom “Arduino” (ou dérivé) soit exclusif au produit officiel et ne puisse pas être utilisés pour des travaux dérivés sans autorisation. Est-ce exact et si oui, pourquoi prendre cette mesure ?

C’est vrai, nous avons déposé la marque. Il est assez fréquent de le faire en open source. Si vous prenez par exemple Linux, MySQL, Apache, ou Ubuntu, par exemple, ils sont tous des marques déposés, bien qu’open-source. Ainsi, ces derniers sont nos modèles. Il y a certaines raisons pour lesquelles nous avons choisi pour ce faire.

Premièrement, le nom porte la responsabilité. Alors que nous sommes ravi que des gens utilisent les fichiers typons ou le code que nous avons créé, nous pensons que nommer une chose devrait rester unique.

Quand une personne achète une Arduino, elle devrait pouvoir compter sur le constructeur derrière elle. Nous l’avons fait, pour les fabricants à qui nous avons autorisées le nom, car nous travaillons étroitement avec eux pour assurer un niveau de qualité et de facilité d’utilisation dont nous sommes fiers.

Si, d’autre part, quelqu’un achète une board appelée Arduino auprès d’un constructeur avec lequel nous n’avons aucun contact, et l’envoie ensuite à nous ou l’un de nos fabricants pour réparation ou remplacement, nous, ou le fabricant, ne pourraient assurer un service correct. Nous ne pouvons pas garantir un niveau de qualité avec quelqu’un qui ne travail pas avec nous.

Deuxièmement, les noms de produit fonctionnent un peu comme les noms de personnes: Si j’écris un article et je “cite” Trevor Clarke, vous seriez probablement satisfait, mais si j’écris et “signe” Trevor Clarke, vous n’apprécieriez probablement pas. Vous n’auriez aucun moyen de s’assurer que l’article était factuellement exacte, ou représentait vos opinions. Mais il y a votre nom dessus. Nous ressentons la même chose concernant la platine et son IDE.

Si vous voulez utiliser les typons Arduino ou le code source pour faire votre propre board (en citant simplement le projet) c’est parfait. Si vous voulez l’appeler “Arduino-compatibles”, c’est très bien aussi. Mais nous préférons vous voire attribuer à votre propre board son propre nom.

Enfin, il y a une raison financière au maintient de la marque. Le hardware rend l’entreprise commercialement autonome, mais le software (non monétisé) ne se suffit pas à lui même. Nous facturons des frais de licence à des fabricants sous licence pour chaque board qu’ils vendent. Cet argent sert à financer la maintenance et le développement du logiciel et du site Web. Il permet à chacun de nous de prendre quelques heures par semaine, hors de nos autres emplois, à maintenir les éléments du système Arduino qui ne peuvent se suffirent à eux même.

Vous pouvez faire des travaux dérivés sans autorisation, c’est juste le nom qui est une marque déposée. La plupart des clones n’ont pas demandé notre permission, pas plus qu’ils en ont besoin, tant qu’ils ne sont pas appelés «Arduino». Il y a des tonnes de *duinos qui sont très bien [..].

• Vous-même, avez vous utilisé l’Arduino pour un projet ?

Je l’utilise tout le temps. Le premier usage que j’en ai eu s’est fait avec le reste de l’équipe, le développement d’un prototype pour une entreprise d’éclairage en Italie. Ce projet m’a montré à quel point cette plateforme pouvait être utile. Je l’utilise également dans mon enseignement.  C’est la première plateforme hardware qui puisse servir à l’enseignement des étudiants et au milieu professionnel en même temps.

Dans mes projets personnels, j’ai développé une nouvelle version de mon “horloge e-mail” (une horloge qui fait tic tac à chaque nouveau message reçu) utilisant l’Arduino. J’ai également conçu une litière à chat qui m’envoie un e-mail avec une photo du chat; un outils de mesure de la qualité de l’air.. [..] et plus encore. Je l’utilise en classe à peu près tous les jours.

• Avez-vous déjà vu l’Arduino utilisé d’une manière que vous n’auriez pas souhaité ?

Eh bien, l’Arduino est destinée à être déployée dans une grande variété de cas, donc pas vraiment. J’estime que la seule chose pour laquelle je ne souhaite pas qu’il soit utilisé soit pour faire mal aux gens ou de causer des dommages. J’espère ne jamais la voir utilisé en ce sens.

• Avez-vous des conseils pour les “up-and-coming hardware hackers”?

Patience. Persistance. Et douches fréquentes. Je résous la plupart de mes problèmes dans la douche. (NDLR : euhh.. erreur de traduction ?)

• Enfin, y’a-t-il autre chose que vous aimeriez ajouter?

Merci à tous ceux qui ont utilisé Arduino! Nous avons beaucoup de plaisir à travailler sur ce projet, et il est incroyablement gratifiant de voir les choses réalisées par les utilisateurs, qu’on ne pensait pas être possible grâce au fruit de notre travail.

interview original (en)

Pour les moins aventuriers ou bricoleur d’entre vous, je vous conseille une platine officielle assemblée de type duemilanove, diecemila ou mega. Ces trois types de platines ont été conçues pour accueillir des shields qui s’emboîtent parfaitement afin de multiplier les possibilités de votre Arduino. Comptez une vingtaine d’euros pour une duemilanove, n’hésitez pas non plus à faire un tour sur Ebay, c’est un l’endroit rêvé pour l’acquérir à prix mini, le prix variant généralement selon le choix du µ-contrôleur (ATMEL ATMEGA168 ou 328).

Les plus courageux pourraient se laisser tenter par une seeeduino apportant quelques améliorations à son homologue officiel. Pour les plus bricoleurs cette fois ci, la méthode – la plus économique probablement – consiste concevoir vous-même votre Arduino.

Plus élégant enfin, en achetant un kit à monter/souder soi-même. Je vous conseille une freeduino, la plupart des ces platines étant assez réussies (selon le fabricant). Kit complet disponible chez Nkcelectronics avec tutoriel détaillé sur le montage.

Concevoir son Arduino compatible

Concevoir son Arduino (soi-même, sans kit) n’est pas extrêmement compliqué en soit, vous trouverez les schémas sur le site officiel (rappelons-le, le projet étant open source, de l’hardware au software). Toutefois, voici quelques pièges à éviter.

Le choix du micro-contrôleur en est un premier. Vous trouverez sans peine sur internet des µ-contrôleurs ATMEL ATMEGA168/328 à faible coût (1 ou 2 euros), toutefois ces derniers ne seront pas opérationnel pour l’IDE Arduino. En effet, il vous faudra y « flasher » un bootloader qui “écoutent” automatiquement à leur mise sous tension, la présence d’un nouveau programme à mettre en place. Pour flasher le bootloader, il vous faudra donc acquérir (en plus du micro-contrôleur) un AVR Programmer aux alentours de 50 euros. Je vous conseille donc vivement de prendre un ATMEGA préprogrammé à peine plus cher (4 euros) qui vous évitera l’achat d’un AVR programmer.

La soudure quant à elle présente un autre piège. Il vous est en effet possible de souder directement le µ-contrôleur sur votre circuit. Mais cela implique deux inconvénients majeurs :

• un risque lié à la surchauffe du µ-contrôleur.
• la difficulté à le remplacer en cas de destruction liée à une mauvaise manipulation (dans le genre j’envoie 48volts entre 2 pins du circuit intégré, on ne sait jamais).

Pour palier à ces deux inconvénients, je vous préconise l’utilisation d’un socket.