Robot amusant: le MouseBot

Voici un petit gadget pour amuser les enfants: une souris d’ordinateur transformée en souris… mécanique…

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.

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.

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


[youtube:http://fr.youtube.com/watch?v=HkiBnyzf6eY]

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.

[youtube:http://fr.youtube.com/watch?v=9DGADNzL1Pw]

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]