Archives du mot-clé Arduino

« The Unnecessary Bubble »

Me revoilà aujourd’hui avec une création totalement inutile, d’où ce titre « The Unnecessary Bubble ».

The Unnecessary Bubble

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]

Processing & Mobile, 2 platerformes de développement autour de JAVA

Il y a quelques temps j’avais présenté les micro controleurs Arduino, objet assez génial, pas cher ( <30€ ) avec une plateforme de développement openSource, disponible pour Linux, MacOS et Windows.

Arduino

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.

Processing

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

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.

Mobile

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 :-)

Mobile

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

Making the things talk

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

Bon développement :-)

Arduino Tux prend soin de vos plantes ;-)

Voilà un gadget plutôt marrant. J’ai récupéré un jouet cassé qui partait à la poubelle. Un jouet en forme de tux, ça ne se jette pas ! Pourquoi ne pas le transformer en une sentinelle qui veille sur vos plantes pour voir si elles sont bien arrosées…

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]

Arduino PhotoLab

Ca y est, je viens de terminer la mise au point de la première version de mon « Arduino PhotoLab », derrière ce nom se cache un petit circuit fait maison qui permet de piloter mon EOS 400D pour prendre des photos à haute vitesse ( goutte d’eau, orage, bris de verre…).

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

Impact ! (Serie)

Impact ! (Serie)

Impact ! (Serie)

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.

Arduino PhotoLab

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

Arduino PhotoLab

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.

Arduino PhotoLab

Arduino PhotoLab

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.

Arduino PhotoLab

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…).