Playarduino

Playarduino

Vous êtes ici : Playarduino / Blog

Un bon livre libre sur l'Arduino en français, en téléchargement gratuit

C'est au cours de la consultation de mes statistiques de visites, back-links, tout ça, que j'ai découvert un excellent ouvrage sur l'Arduino, en français de surcroit.


 
Cet ouvrage de 120 pages, disponible gratuitement en ligne chez flossmanuals (ou en version papier livrée) est co-écris par une dizaine de co-auteurs, contributeurs.
Vous y trouverez un chapitre sur les bases de l'électronique, une présentation complète de l'IDE officiel, des conventions de codage, des méthodologies de travail, ainsi qu'une demi douzaine de projets expliqués pas à pas.

Arduino Painting Machine


Fort de constater que la créativité n'avait pas suffisament de place dans le monde de l'informatique, Kris Temmerman, nous presentait il y a quelques jours son imprimante à gouache DIY. Une façon originale de faire un pied de nez à la "perfection" induite par la machine et son raisonnement booléen.

I was always interested to remove the perfection from computer graphics. So thought it would be fun to try to make the most obvious thing first. A machine that uses a paint brush to print a drawing.



Materiel utilisé :

  • Une Arduino DUE, 
  • une Samsung galaxy note 10.1 et son stylet sensible à la pression 
  • 3 Steppers pour l'axe X/Y (2 rails X + 1 rail Y)
  • 1 servo pour la hauteur du pinceau.
 
Tandis que la position du stylet sur la tablette android positionne le pinceau à l'aide des 3 steppers, la pression du stylet influe sur la pression du pinceau. Le code source du projet est disponible sur Github neuroprod/npPaintingMachine
 
On regrette cepandant que la très grosse partie de code soit embarquée sur la tablette et non dans la board. L'arduino ne sert finalement ici que d'interface I/O
On salue toutefois la qualité de la réalisation, l'idée lumineuse et la patience dont a fait preuve son concepteur

Consulter l'article complet par Kris Temmerman

Booster le temps de réponse de votre Arduino

Hardcoding

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 aux sorties préfixées par PB, PC, et PD du schéma 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

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

Arduino Mega

Voici le mapping des 70 sorties de l'ATmega1280 de l'Arduino Mega pour les 54 sorties "digitales" :
// sortie   7  6  5  4  3  2  1  0
//          ↓  ↓  ↓  ↓  ↓  ↓  ↓  ↓
PORTL      42 43 44 45 46 47 48 49
PORTG             4       39 40 41
PORTD      38          18 19 20 21
PORTC      30 31 32 33 34 35 36 37
PORTA      22 23 24 25 26 27 28 29
PORTH          9  8  7  6    16 17
PORTJ                        14 15
PORTB      13 12 11 10 50 51 52 53
PORTE             3  2  5     1  0
pour les 16 sorties analogiques :
// sortie   7  6  5  4  3  2  1  0
//          ↓  ↓  ↓  ↓  ↓  ↓  ↓  ↓
PORTF       7  6  5  4  3  2  1  0
PORTK      15 14 13 12 11 10  9  8

Trouvez le mot de passe, ouvrez la porte

L'Arduino n'est jamais en reste lorsqu'il s'agit d'épater son public à coup d'inventions délurées. Aujourd'hui c'est Steve Hoefer qui nous propose d'entrer chez lui, sans clé. Bien loin de la reconnaissance vocale sésame ouvre toi, l'Arduino est ici mise en oeuvre pour "écouter" la façon dont vous frappez la porte, décidant ensuite ou non d'actionner la serrure à l'aide d'un moteur.

Le buzzeur détecte donc le "toquage" de porte ? C'est exactement cela, un buzzeur contient une surface piezo-électrique, qui vibre lorsqu'on l'alimente en courant, et à l'inverse produit un (faible) courant lorsqu'on la fait vibrer. Très astucieux pour détecter les vibrations d'une porte.

La liste des courses : 2 couples résistance/LED pour informer du statut du détecteur, le trio classique pour le moteur : transistor, diode (pour l'anti-retour), résistance.

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é.

Contrôler sans fil votre Mac avec une Arduino


La folie du sans fil semble s'emparer de l'Arduino ces derniers temps. Chez Instructables.com aujourd'hui, DIY Apple Remote Shield for the Arduino, un projet très intéressant pour tous les bricoleurs Mac Addict. Il s'agit en effet de reproduire les signaux infra-rouges envoyés par l'Apple Remote.

Le projet se présente sous forme d'un shield maison, 5 boutons, 2 LEDs infra-rouges. L'ensemble doit coûter peut-être 1 euro (en dehors de l'Arduino), le tout pourrait même simplement se récupérer d'une vielle télécommande qui traîne dans un carton au grenier.

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. 

Communication entre deux Arduino à moins de $10

Faire communiquer 2 platines Arduino sans fil n'est pas sans frais. Plusieurs solutions existent aujourd'hui. Du module Xbee, au module Bluetooth, en passant pourquoi pas par un module Wifi ; l'ensemble de ces solutions restent très onéreuses. Un module BT par exemple coûte presque une centaine d'euro, une Arduino BT (Arduino avec BlueTooth onboard) revient quant à elle à 150$ chez SparkFun. Sans oublier qu'il vous faudra en acquérir généralement une paire.

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é ;)

Une pluie de cadeaux pour les créatifs Arduino

Je vous parlais il y a quelques temps d'un contest Arduino organisé par Instructables.com, dont la date de soumission prendra fin dans tout juste 2 semaines. C'est aujourd'hui au tour d'arduinofun.com de proposer des lots pour son propre concours. La date de soumission est fixée au 31 décembre 2009. Les résultats seront annoncés le 8 janvier 2010. En jeu :
  • 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.

Utiliser un buzzeur avec l'Arduino


Un tutoriel fort intéressant chez Instructables.com, qui nous explique comment buzzer. Ce tutoriel est d'autant plus intéressant, dans la mesure où il ne se borne pas à émettre une succession de fréquences sur une durée plus ou moins longue, mais bien de simuler une sorte de vibrato rendant là chose moins "sonnerie de téléphone monophonique", et plus agréable. Enfin, à vous de juger.

On saluera l'originalité du montage vidéo. D'un point de vue technique rien d'exceptionnel pourtant, le matériel requis reste simple, l'Arduino toujours au coeur de l'exploit, un buzzeur et du code. L'ensemble des libraries utilisées sont open-source

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.

Qui prétendait que l'iPhone n'avait pas de (vrai) clavier ?

Encore un exemple aujourd'hui des innombrables possibilités offertes par l'Arduino. Ben Kurtz, consultant puis directeur en sécurité informatique (en d'autres termes, un "hacker") s'est attaqué à l'iPhone en y apportant de quoi y connecter un clavier PS/2 (rien que ça). Sa motivation, nous explique-t-il, ses doigts "ronds", trop "ronds" pour le téléphone d'Apple.



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 (Archive)

Arduino bon pour la nature

Smart Projects, la société italienne principal fabricant de l'Arduino Duemilanove, Mega, et Mini, a signé avec le projet ZeroImpact / Lifegat afin de réduire son impact sur l'environnement et de compenser ses émissions de CO2 issues de la fabrication des boards Arduino. Cet engagement de l'entreprise vise à restaurer et à protéger 25 000 mètres carrés de la forêt tropicale du Costa Rica. En effet, pour chaque board Arduino fabriquée par Smart Projects, un demi mètre carré de forêt tropicale sera restauré ou protégé contre la déforestation. Mesure en vigueur depuis le début de la production de l'Arduino Mega dans un effort de protection de l'environnement. En conclusion : manger de l'Arduino, c'est bon pour la planète. Source : blog Arduino
Haut de page