Je débute avec Eagle alors mon schéma n’est pas forcément très clair, mais bon…

Le voici au format Eagle

• Prise SENSORS: branchement des capteurs
• Prise TTL: Branchement d’un convertisseur USB/TTL pour reprogrammer l’arduino.
• Prise STROBE: Sortie pour la prise de commande du flash ou de l’appareil photo suivant l’usage.
• Prise POWER: Alimentation 5V par transfo ou pack de piles.

Les 4 boutons permettent de se ballader dans les menus pour choisir les capteurs et changer les valeurs.

Il reste quelques ports dispo sur l’arduino pour un usage futur…

Je n’ai pas mis le schéma des capteurs. Vous pouvez en trouver plein sur le playground arduino ici. Il suffit d’utiliser une prise jack 3.5mm male et de la brancher sur la prise SENSORS. Vous avez alors VCC,  GND, DATA. Où DATA est un voltage entre 0 et 5 v.

Je ne suis pas sûr que mon système soit utilisable tel quel chez vous, mais vous pouvez vous en inspirer pour créer le votre. En tout cas, chez moi ça marche très bien

Pour ce qui est du code, le voici:

[code]

#include <LCD4Bit.h>

//BUG ?
#undef int()
// END BUG
#include <stdio.h>

LCD4Bit lcd = LCD4Bit(2);

//#define DEBUG 1

// global defs
#define shootPin  11
#define sensorPin 4
#define bt1Pin 3
#define bt2Pin 4
#define bt3Pin 5
#define bt4Pin 6
#define ledPin 13 //digital

#define MAXMENU 4

#define MENUSENSOR 1
#define MENUSTROBEDELAY 2
#define MENURUN 3

#define MODESENSOR 1

#define NO 0
#define YES 1
#define TEST 2

#define SOUNDSENSOR 0
#define IRSENSOR 1
#define CONTACTSENSOR 2
#define LIGHTSENSOR 3

volatile unsigned int menu0Pos = MENUSENSOR;
volatile unsigned int debounce = 0;
volatile unsigned int modeSensor = 0;
volatile unsigned int modeDrop= 0;
volatile unsigned int modeApp = MODESENSOR;
volatile unsigned int sensorType = IRSENSOR;
volatile unsigned int firstPass = 0;
volatile unsigned int sndLevel = 0;

volatile int strobeDelay = 10;

void setup() {
pinMode(ledPin,OUTPUT);
pinMode(shootPin,OUTPUT);
pinMode(bt1Pin,INPUT);
pinMode(bt2Pin,INPUT);
pinMode(bt3Pin,INPUT);
pinMode(bt4Pin,INPUT);
setLed(1);
lcd.init();

/*lcd.commandWrite(0x0F);//cursor on, display on, blink on.  (nasty!)
*/
lcd.clear();
lcd.printIn("equinoxefr.org");
lcd.cursorTo(2, 0);  //line=2, x=0.
lcd.printIn("Photo lab v0.3");
delay(2000);
fillLine(2,"FW Trigger");
delay(2000);
lcd.clear();
setLed(0);
#ifdef DEBUG
Serial.begin (9600);
Serial.println("start");                // a personal quirk
#endif
}

void loop() {
int val=0;
int keyFactor=1;

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  SENSOR SECTION
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (modeSensor)
{
while (1)
{
val=analogRead(sensorPin);
switch (sensorType)
{
case LIGHTSENSOR:

if (val > 500)
{
shoot();
}
//      char buffer[50];
//      strobeDelay=getValue(strobeDelay,-1,9999);
//      itoa(strobeDelay,buffer,DEC);
//      fillLine(2,buffer);
break;

case IRSENSOR:

if (val < 900)
{
shoot();
}
//      char buffer[50];
//      strobeDelay=getValue(strobeDelay,-1,9999);
//      itoa(strobeDelay,buffer,DEC);
//      fillLine(2,buffer);
break;

case SOUNDSENSOR:
if (firstPass)
{
fillLine(2,"Getting snd level");
sndLevel=soundLevel();
clearLcdLine(2);
firstPass=0;
}
val = analogRead(sensorPin);

if ((val > (sndLevel + 40)) && (val < 1024))
{
shoot();
}

break;

case CONTACTSENSOR:
if ( val < 500)
{
shoot();
}
break;
}
}
}

/*
#ifdef DEBUG
Serial.println(menu0Pos,DEC);
#endif
*/
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  MENU SECTION
/////////////////////////////////////////////////////////////////////////////////////////////////////////////

switch (menu0Pos)
{
case MENUSTROBEDELAY:
fillLine(1,"Strobe delay ms");
modeSensor=0;
strobeDelay=getValue(strobeDelay,-1,9999);
if (strobeDelay==-1)
{
fillLine(2,"not used");
}
else
{
char buffer[50];
itoa(strobeDelay,buffer,DEC);
fillLine(2,buffer);
}
break;
case MENUSENSOR:
fillLine(1,"Select sensor");
sensorType=getValue(sensorType,0,3);
switch(sensorType)
{
case SOUNDSENSOR:
fillLine(2,"SOUND");
firstPass=1;
break;
case IRSENSOR:
fillLine(2,"IR BARRIER");
break;
case CONTACTSENSOR:
fillLine(2,"CONTACT");
break;
case LIGHTSENSOR:
fillLine(2,"IR LIGHT");
break;
}
//digitalWrite(ledPin, HIGH);
modeSensor=0;
break;

case MENURUN:
if (!modeSensor)
{
fillLine(1,"***SHOOT MODE***");
}
modeSensor=1;
break;
}
getMenu();
}

//
//  soundLevel()
//
int soundLevel()
{
int value=analogRead(sensorPin);

Serial.println("Getting sound level...");
for(int i=0; i < 50 && !modeSensor; i++)
{
value = ( value + analogRead(sensorPin) ) / 2;
delay(50);
}
Serial.println("Done!");

return value;

}

void clearLcdLine(int line)
{
lcd.cursorTo(line, 0);
lcd.printIn("                     ");
}

void fillLine(int line,char* str)
{
char buffer[21];
int len=strlen(str);
for (int i=0;i<20;i++)
{
if (i < len)
{
buffer[i]=str[i];
}
else
{
buffer[i]=' ';
}
}
lcd.cursorTo(line,0);
lcd.printIn(buffer);
}

void shoot()
{
if (strobeDelay > 0 )
{
delay(strobeDelay);
}
digitalWrite(shootPin,HIGH);
delay(10);
digitalWrite(shootPin,LOW);
fillLine(2,"Shoot !");
digitalWrite(ledPin,HIGH);
delay(3000);
digitalWrite(ledPin,LOW);
clearLcdLine(2);

}

void getMenu()
{
int bt1=digitalRead(bt3Pin);
int bt2=digitalRead(bt4Pin);

if (!bt1 && !bt2)
{
return;
}

if (bt1 && menu0Pos < MAXMENU)
{
menu0Pos++;
}
if (bt2 && menu0Pos > 0)
{
menu0Pos--;
}

}

int getValue(int value, int mini, int maxi)
{
unsigned int keyFactor=1;
int bt1=digitalRead(bt1Pin);
int bt2=digitalRead(bt2Pin);

if  (value < 50 )
{
keyFactor=1;
}
else
{
if (value >= 50 )
{
keyFactor=10;
}
}
if  ( bt1 )
{
value+=keyFactor;
}
if  ( bt2 )
{
value-=keyFactor;
}

if ( value <= mini)
{
value=mini;
}
else
{
if (value >= maxi)
{
value=maxi;
}
}
/*
if ( bt1 && bt2 )
{
modeSensor=0;
fillLine(2,"switch off");
}
*/
return value;

}

void setLed(int value)
{
if (value)
{
digitalWrite(ledPin,HIGH);
}
else
{
digitalWrite(ledPin,LOW);
}
}
[/code]

C’est aussi pour moi l’occasion de tester un nouveau média, la diffusion de vidéo. Si ça se passe bien, je compte faire de temps en temps des vidéos sur le démontage ou la modification d’objets courants, un peu comme les modifs faites sur le routeur WL500GP.

Télécharger en MP4

Pour réaliser ce petit robot, j’ai farfouillé dans mon sac de récupération. Il faut:

• 1 µC ATEMGA8 ou équivalent
• 1 télémètre à IR sharp
• 2 condensateurs
• 1 régulateur LM78L05
• 1 H-bridge L298
• 1 pile 9V
• 2 moteurs DC
• Une vieille souris à martyriser.
• 2 LED + 1 résistance de 150 ohms

Voilà, un bon fer à souder, une dremel et un peu de patience… et vous voilà partis. C’est amusant à construire et ça plait beaucoup aux enfants

J’ai du modifier la configuration du compilateur Arduino pour qu’il supporte mon ATMEGA8 cadencé à 8MHz au lieu de 16 et dont la programmation se fait en SPI et non en série.

Le matériel nécessaire: Une carte arduino, 3 résistances 150 ohms, 1 led RGB, 1 capteur de proximité SHARP G2D120 ou équivalent, une balle de ping-pong.

La led RGB est branchée sur la masse (GND), et sur les ports 9, 10, 11 de l’arduino au travers des résistances de 150 ohms. La balle de ping-pong percée d’un trou de 5mm sert de diffuseur à la led.

Le capteur SHARP est branché sur l’entrée analogique 0, VCC (5v) et la masse (GND).

Sur le principe l’arduino change de couleur toutes les 100 ms ( ce qui permet de faire varier les tons de couleurs assez rapidement). Si vous approchez un objet ou votre main de la boite, le capteur évalue la distance, plus celle-ci et faible et plus le cycle des couleurs est rapide. Si vous vous éloignez, le cycle de couleur reprend sa vitesse normale.

Voilà le code source:

[code]

#define PIN_RED           10
#define PIN_GREEN        9
#define PIN_BLUE          11
#define PIN_SHARP       0
#define WAIT              100

int waiting = WAIT;

void color(int r, int g, int b)
{
analogWrite(PIN_RED,   r);
analogWrite(PIN_GREEN, g);
analogWrite(PIN_BLUE,  b);
}

void setup()
{

pinMode(PIN_RED,   OUTPUT);
pinMode(PIN_GREEN, OUTPUT);
pinMode(PIN_BLUE,  OUTPUT);
pinMode(PIN_SHARP,INPUT);
}

void loop()
{

for (int i = 0; i < 256; i++){
color(255, i, 0);
set_delay();
delay(waiting);
}

for (int i = 0; i < 256; i++){
color(255 - i, 255, 0);
set_delay();
delay(waiting);
}

for (int i = 0; i < 256; i++){
color(0, 255, i);
set_delay();
delay(waiting);
}

for (int i = 0; i < 256; i++){
color(0, 255 - i, 255);
set_delay();
delay(waiting);
}

for (int i = 0; i < 256; i++){
color(i, 0, 255);
set_delay();
delay(waiting);
}

for (int i = 0; i < 256; i++){
color(255, 0, 255 - i);
set_delay();
delay(waiting);
}
}

void set_delay()
{
int analogValue1 = analogRead(PIN_SHARP);
if (  analogValue1 < 100 )
{
waiting = WAIT;
}
else
{
waiting = WAIT / (analogValue1 / 10);
}

}
[/code]

Ils ont permis d’ouvrir aux artistes, bricoleurs, enseignants, le monde des µC avec une certaine simplicité d’accès. Et bien voilà, côté développement PC, il y a aussi processing, un language tournant autour de java avec de nombreuses librairies pour faciliter les interactions avec l’utilisateur.

Les programmes compilés sont des .JAR multi plateformes qui simplifient grandement la diffusion. Il ne s’agit pas d’un language permettant de créer de grosse applications, mais plutôt de petits programmes pour un usage ciblé: reconnaissance de couleur avec une webcam, pilotage du PC avec une manette de WII…

Processing est inter connectable avec un arduino, on peut ainsi agir sur le micro contrôleur depuis le PC ou bien l’inverse. De quoi ouvrir la voie à de nombreuses expérimentations: robotique, capteurs…

Plus récemment, un nouvel IDE est sorti, tout droit dérivé de processing. Il s’agit de Mobile, la version pour téléphones de processing.

J’ai testé, c’est impressionnant, en un rien de temps, vous pouvez sortir une application pour votre téléphone, utilisant le réseau, le bluetooth, l’affichage… La version mobile n’est livrée pour le moment que pour Windows et OsX mais une personne sur le forum propose déjà un paquet tgz pour linux

Pour finir, ceux qui veulent se lancer dans le monde de l’Arduino et du « controle des objets », peuvent regarder un ouvrage très bien chez O’reilly: « Making things talk ».

Vous pouvez acheter le bouquin ou le PDF (sans drm ) ici.

Bon développement

Dans mes cartons, j’ai quelques arduinos qui trainent, une matrice de led, et quelques autres composants. Aller, en avant, au fer à souder

Hop, on vide le jouet à coups de Dremel pour faire de la place. Le clavier est découpé pour laisser place à la matrice de led.

Le système se compose d’un contrôleur arduino qui pilote une matrice de 64 leds au travers d’un MAX7219. Le capteur, lui est basé sur deux tiges métalliques, la résistivité de la terre variant avec l’eau, elle est amplifiée par un transistor 2N2222 avant de se connecter à une entrée analogique de l’arduino.

La plante est heureuse lorsqu’on l’arrose. Pour vous remercier de cette eau providentielle, la sentinelle tux affiche des petits coeurs pendant quelques secondes avant de sourire. Dès que l’humidité baisse (simulé en enlevant la sonde) tux fait la tête, il est temps d’arroser

Le tout est relié au PC pour l’alimentation en 5V et la programmation de l’arduino (et le débug dans minicom). On pourrait très bien imaginer mettre un relais avec une pompe sur le µC pour arroser automatiquement vos plantes. Ce n’est pas le but ici mais c’est simple à faire, une résistance, un relais, un transistor et une diode suffisent à rajouter cette fonctionnalité. On peut aussi mettre plusieurs capteurs dans les pots de fleurs.

Je n’ai pas mis de schéma, mon circuit est largement inspiré de ce qui se fait chez botanicalls. Si quelqu’un veut le détail exact, je peux vous le faire avec un coup de Kicad

Pour ceux qui se posent la question, oui c’est totalement inutile… donc parfaitement indispensable

EDIT (18/10/2008)

Voilà le code vite fait qui pilote la matrice de led.

[code]

#include <Binary.h>
#include <Sprite.h>
#include <Matrix.h>

Matrix myMatrix = Matrix(2, 4, 3);
int analogPin = 5;
int val = 0;
int oldval = 1000;
Sprite smile = Sprite(
8, 8,
B00000000,
B00000000,
B00100100,
B00000000,
B01000010,
B00100100,
B00011000,
B00000000
);

Sprite bad = Sprite(
8, 8,
B00000000,
B00000000,
B00100100,
B00000000,
B00011000,
B00100100,
B01000010,
B00000000
);

Sprite nosmile = Sprite(
8, 8,
B00000000,
B00000000,
B01000010,
B00000000,
B00000000,
B00000000,
B00111100,
B00000000
);

Sprite love = Sprite(
8, 8,
B00000000,
B01100110,
B01011010,
B01000010,
B01000010,
B00100100,
B00011000,
B00000000
);

void setup()
{
Serial.begin(9600);          //  setup serial
myMatrix.clear(); // clear display
}

void loop()
{
val = analogRead(analogPin);    // read the input pin
Serial.print("Sensor level: ");
Serial.println(val);             // debug value

if (val  > (oldval + 40))
{
for (int i=0;i<10;i++)
{
myMatrix.clear(); // clear display
delay(1000);
myMatrix.write(0, 0, love);
delay(1000);
}
}

if (val  > 700)
{
myMatrix.clear(); // clear display
myMatrix.write(0, 0, smile);
delay(10000);
}
else
{
if (val > 400 && val <=700)
{
myMatrix.clear(); // clear display
myMatrix.write(0, 0, nosmile);
delay(10000);
}
else
{
if (val <= 400)
{
myMatrix.clear(); // clear display
myMatrix.write(0, 0, bad);
delay(10000);
}
}
}
oldval = val;
}

[/code]

Voilà un exemple de mes tests du jour avec de gouttes d’eau et d’huile:

Le cœur du circuit est un ATMEGA 168 avec le firmware Arduino. Le boitier dispose d’une LED  de contrôle, d’un écran LCD pour le paramétrage et de 4 boutons.

L’intérieur de la boite. C’est mal rangé mais ça marche

Le boitier dispose de 5 entrées / sorties:

1. un port série pour mettre à jour le firmware
2. une sortie pour le premier servomoteur
3. une sortie pour le deuxième servomoteur
4. une sortie pour une commande de flash
5. une entrée pour un capteur analogique. actuellement j’ai fait 3 capteurs: un de contact, un capteur sonore et un capteur IR.

Voilà la zone de test . J’ai fabriqué une boite en carton peinte en blanc pour la prise des photos. Un goutte est projetée avec une seringue, lors de la traversée de la demi-sphère rouge, elle est détectée par une barrière IR. Le PhotoLab attend alors un délai réglable (ici 305ms)  avant de déclencher le flash.

Principe de fonctionnement:

1. On place la pièce dans le noir.
2. L’appareil photo est déclenché manuellement avec une télécommande. Il est paramétré pour une pose de 4 seconde. Le temps de faire tomber une goutte.
3. On appuie sur la seringue pour lacher une goutte.
4. La goutte est détectée. le photolab attend quelques milli secondes.
5. Le flash est déclenché. Il illumine la pièce et fige la photo.
6. Les 4 secondes sont écoulées, l’appareil photo referme l’obturateur.

Le système est assez basique actuellement mais ça fonctionne, j’arrive a prendre en photo trois gouttes sur cinq à peu près. Par la suite, de simple mise à jour du logiciel me permettront de contrôler 2 servomoteurs pour effectuer de grosses photos panoramiques automatiquement. J’ai commandé 2 servos d’une puissance de 10Kg pour ça

Si ça intéresse quelqu’un, je peux mettre le schéma en ligne (enfin il faut d’abord que je le fasse…).

Un petit gadget rigolo à fabriquer: Une LED qui réagit à la température. Le système est solaire donc entièrement autonome. Amusant

• Une commande de console Wii, branchée sur une carte arduino, pour piloter un servomoteur. Des perspective intéressantes pour la robotique. Surtout vu le prix de la manette (20€ alors qu’elle contient un joystick et un accéléromètre 3 axes) par rapport à celui de l’accéléromètre 3 axes seul (40€).

• voilà mon prochain projet: un contrôleur pour la photographie à haute-vitesse. Franck Fleurey m’a devancé avec son projet.

Je compte faire à peu près la même chose mais avec un Arduino au lieu d’un ATMEGA classique. Je viens de récupérer le dernier composant qui me manquait ( un triac 400V que j’ai récupéré sur le variateur de mon aspirateur, ben oui, ça ne sert à rien un variateur sur un aspirateur ), je vais bientôt pouvoir me lancer.

De retour à la maison, je démarre la bête et pars à sa découverte. Je ne vais pas vous refaire sa description ni son éloge, les blogs en parlant sont dèjà très nombreux. Je vais seulement vous détailler les différentes manipulations que j’ai réalisé pour adapter la bête à mes besoins.

Tout d’abord, un constat simple, pour plaire au plus grand nombre, les polices de caractère sont énormes. On peut y remédier de différentes façons:

• Pour les applications KDE: lancez un terminal Alt + Ctrl + t puis tapez kcontrol, là dans le réglage des polices, passez les toutes à 8.
• ensuite, pour les application GTK: lancez un terminal Alt + Ctrl + t puis tapez kate ~/.gtkrc-2.0 et placez dedans gtk-font-name = « Sans 8″
• Pour firefox, il faut modifier le fichier userChrome.css et passer la police de 10 à 8. Ensuite, il faut installer l’extension FullScreen. Tout est détaillé dans ce très bon article.

Bon, maintenant il va falloir s’attaquer à l’interface graphique. Beaucoup changent l’application d’asus pour un bureau complet. Personnellement, je préfère la garder, je la trouve sympa et conviviale pour une petite machine qui va servir souvent peu de temps (prise de note, mails, visio…). Seulement, les critiques faites par les utilisateurs sont justes, cette interface n’est pas très simple à customiser. J’ai donc décidé de modifier le comportement du système pour pouvoir ou non l’utiliser par appui sur une simple combinaison de touches en fonction de l’usage du pc.

J’ai d’abord commencé par « virer » icewm pour le remplacer par fluxbox. Vous trouverez un script à la fin de l’article qui vous permettra de faire ça facilement.
Je me trouve donc avec un nouveau Window Manager que j’ai paramétré avec le multi bureaux.

Les différentes étapes à suivre:

1. Ajouter les dépots debian etch dans apt.
2. Installer fluxbox / fluxconf
3. Configurer fluxbox pour le eeepc
4. Créer un script pour activer / désactiver l’interface Asus.

Sauvegardez vos données avant de bricoler votre eeepc

Téléchargez le script ci-dessous en tapant dans un terminal:

wget http://www.equinoxefr.org/public/configeeepc.sh

sh configeeepc.sh

Voilà quelques applications tournant sur le eeepc:

Fluxbox avec l’interface asus

Fluxbox seul (Maison + a)

l’ide Arduino sur eeepc

Le soft de mon oscilloscope (bitscope)

Google en fullscreen avec Firefox

Quelques raccourcis:

• Maison + a: lancer / fermer l’interface asus
• Maison + t: Terminal
• Maison + i: Firefox
• Alt + F1: Bureau 1
• Alt + F2: Bureau 2
• Alt + F3: Bureau 3
• Alt + F4: Bureau 4

Personellement j’utilise sur mon eeepc:

• firefox
• openoffice
• pidgin
• skype
• ssh
• ICAClient
• gftp
• pan
• liferea
• arduino
• bitscope dso
• grisbi
• webcam
• LauncherTools

Pour info, voici le script que vous avez téléchargé.

#! /bin/sh

echo "Installation..."

sudo cp /etc/apt/sources.list /etc/apt/sources.old

sudo cp /usr/bin/startsimple.sh /usr/bin/startsimple.old

cd /tmp

wget http://www.equinoxefr.org/public/config_eeepc.tgz

sudo tar xvf config_eeepc.tgz -C /

sudo apt-get update

sudo apt-get install fluxbox fluxconf

echo "Termine. Redemarrez votre eeepc"

J’ai fait les différentes manip à la main, du coup le script n’est pas testé. Merci de me faire un retour en cas de problème. Si votre eeepc ne se lance plus,il vous reste la restauration en appuyant sur F9 ou en utilisant le DVD d’asus.

ATTENTION: du fait de l’ajout des sources debian etch, si lors d’une installation, apt vous propose de mettre a jour un grand nombre de paquets,annulez tout, vous risquez de compromettre la stabilité du système !

Après 3 longues semaines d’attente, je viens de recevoir ma carte de développement Arduino Diecimila.

Je l’ai commandé sur le site adafruit pour 22 €. Ce qui en fait certainement la carte de développement embarqué la moins chère du marché. En plus c’est de l’OpenHardware ( en dehors du µC ) et le soft de l’OpenSource.

La carte est construite autour d’un processeur ATMEGA 168 (compatible ATMEGA8) cadencé à 16MHz avec 16Ko de mémoire flash. Elle dispose d’un port USB qui peut servir à la programmation du µC mais aussi à interagir avec le PC (protocole série). Côté entrée sorties, elle est plutôt bien fournie avec 14 ports Digital I/O dont 6 avec sortie PWM et 6 ports analogiques.

La grande force de cette carte est certainement le prix mais aussi sa facilité de programmation. Elle est programmable en C avec un logiciel de développement extrêmement simple ( compatible Linux, Mac, Win )

Il faut par exemple faire un simple int i=analogRead(3) pour récupérer la valeur d’une entrée analogique comme un capteur IR sharp connecté au port 3. De quoi s’amuser sans être un pro de l’assembleur…

Voilà, il me tarde de tester tout ca

Le premier projet va être une carte de pilotage de mon appareil Photo Canon EOS 400D pour réaliser des photos "ultra rapides" à l’aide d’une barrière IR (chute d’une goutte d’eau) ou d’un microphone (éclatement d’un ballon).

P.S: En réalité je n’ai pas réussi à attendre du coup je me suis fabriqué une carte sur une plaque d’essais à l’aide d’un µC ATMEGA8 qui trainait dans mes affaires… je vous fait un petit billet là dessus dès que j’ai 5 min.

Toutes les infos sur la technologie arduino sont dispos ici