• Un port USB d’ordinateur.
• Un chargeur secteur 5v.
• Un panneau solaire.

Le montage se base sur 2 cartes open hardware provenant de 2 fournisseurs bien connus sparkfun et Adafruit industries.

L’une des cartes sert de support au MAX1555. Elle comporte 2 entrées et 2 sorties.

En entrée:

• Un port d’alimentation 2.1mm.
• Un mini usb.

En sortie:

• La batterie Lipo.
• la sortie 3.7v vers le mintyboost.

Elle est disponible préassemblée chez sparkfun

La batterie provient aussi de chez Sparkfun. C’est une batterie 1 élément de 2000 mAh.

L’autre partie, est un kit de chez Adafruit. Le mintyboost. Il n’a qu’un but: élever la tension de la batterie de 3.7v à 5v. Le kit est très simple, il faut moins de 15 min pour l’assembler.

Les instructions d’assemblage, les schémas et tout la documentation sont en ligne sur le site de ladyada.

Le panneau solaire provient lui aussi de chez adafruit.

Dernière étape: assembler l’ensemble dans un boitier de petite taille. J’ai choisi un boitier robuste en aluminium qui n’aura aucun mal à trainer dans un sac à dos.

L’intérieur du boitier. Comme vous pouvez le constater, on peut encore réduire un peu l’encombrement.

Mon téléphone en charge. Le chargeur peut assurer à peu près une charge et demi du téléphone sans l’aide du panneau solaire. Avec le panneau il faut une dizaine d’heures pour recharger complètement la batterie du chargeur. Le chargeur est suffisamment petit pour rester dans un sac à portée de main. Quand vous partez en randonnée, il suffit juste d’emporter en plus le panneau solaire que l’on fixera sur le dessus du sac à dos par exemple.

L’avantage c’est qu’il peut être utilisé avec ou sans la partie solaire. Celle-ci assure une totale autonomie: rechargement de la batterie « tampon » dans la journée et charge des périphériques USB la nuit par exemple.

En se qui concerne la facture, elle est relativement élevée: ~90$ Ce chiffre pourrait être fortement réduit  en faisant nous même le circuit. Comme il s’agit d’un prototype, j’ai préféré rester sur le kit, plus simple à assembler.

• Pour le petit hélicoptère, le rotor de queue ne tourne plus, du coup impossible d’avancer ou de reculer.

• A priori la panne vient soit de la télécommande ( potentiomètre HS ) ou de l’appareil lui-même. Etant donné que c’est l’hélico qui tombe plus que la télécommande, j’ai parié sur lui. Là encore plusieurs hypothèses:

1. Le PCB est fendu à cause des chutes
2. Un fil s’est coupé
3. Le moteur du rotor est H.S
4. Les transistors de contrôle (H-bridge) du moteur sont morts

Pour le savoir, il faut ouvrir la bête. Quelques vis plus loin, on accède à la carte et à la batterie.

Sous celle-ci, deux fils qui vont au moteur de queue. L’un d’eux est coupé au ras de la soudure côté PCB. Au moins une panne facile à trouver sans équipements de test. Juste de bon yeux

Un coup de fer à souder plus loin, on peut tester. Ça marche, et hop un jouet qui ne finira pas à la poubelle (enfin pas tout de suite…).

• Deuxième objet de la journée, le chargeur. Un bruit épouvantable dès que l’on charge des piles. Facile à identifier, c’est le ventilateur de refroidissement des piles qui vibre.

Allez hop, on démonte la bête. La réparation est toute simple:

1. Le ventilateur est nettoyé de toutes les poussières qui déséquilibrent les pales
2. Le ventilateur est calé dans son logement à l’aide de colle à chaud. Ça lui évitera de vibrer.

Le tout en vidéo:

La publication sur le planet est ouverte à tout le monde, il suffit de posséder un blog et des articles en français sur le sujet, et de nous le signaler par le biais du formulaire approprié.

L’adresse de ce planet est : http://planet.madeinfr.org/

BusPirate, sous ce drôle de nom ce cache une petite « carte » électronique (opensource / openhardware valant moins de 30$ ) permettant de communiquer sur les lignes de données d’un grand nombre de composants, c’est d’une grande aide pour tester, débugger et apprendre… Les protocoles suivants sont supportés actuellement par le firmware 2.8:

• 1-Wire
• I2C
• SPI
• JTAG
• Asynchronous serial
• MIDI
• PC keyboard
• HD44780 LCD
• 2- and 3-wire libraries with bitwise pin control
• Scriptable binary bitbang, 1-Wire, I2C, SPI, and UART modes

Comme toujours avec les produits « open », les mise à jour sont  très fréquentes pour le plus grand bonheur de l’utilisateur.

Voici un petit screencast rapide qui vous montrera comment mettre à jour votre carte Buspirate depuis MacOSX.

Vous devez normalement disposer de python sur votre Mac. Une connaissance du « terminal » est aussi requise.

http://blip.tv/file/2780303

A voir en plein écran, sinon c’est illisible…

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]

Cinq minutes plus tard, me voici avec mon nouveau jouet, certes un peu plus encombrant mais oh combien plus pratique.

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.

Nous allons utiliser une alimentation d’un vieux scanner qui nous donne 5V. A première vue, le signal issu de l’oscilloscope nous parait correct.

Seulement voilà, en changeant d’échelle, on se rend vite compte que le courant n’est pas si « propre » que ça. De nombreux parasites sont présents. Ils peuvent introduire des « bugs » dans vos circuits électroniques, qui n’a pas cherché pendant des heures pourquoi son µC plantait ou avait un fonctionnement erratique…

Et bien voilà, la solution, connue de tous les amateurs d’électronique mais parfois oubliée, consiste à ajouter un condensateur de filtrage sur la ligne d’alimentation. Le résultat (ici un condo plastique 33nF de récup) est très parlant, le signal est bien plus stable (il n’est pas parfait, le condensateur n’est pas forcément le mieux choisi).

Un truc tout bête mais qu’il est bon de rappeler de temps en temps

Le cahier des charges est assez simple:

• La machine doit rester bon marché
• Il s’agit d’une petite fraiseuse de bureau et non d’un routeur de 2x3m
• Elle devra fonctionner sous EMC2 (Linux Ubuntu 8.04)
  
• Elle devra être suffisement précise pour réaliser des gravures de circuits imprimés.
• La conception se fera au feeling, je suis incapable de concevoir une telle machine sur plans.

J’ai choisi des matériaux faciles à trouver, il s’agit de tube carré en aluminium vendu en barres de 1 mètre chez LeroyMerlin, de tige filetée de 6mm, de boulons de 6mm et de roulements à billes de roller et d’autres récupérés dans des imprimantes ainsi que du tube de 25mm en acier pour la potence de l’axe Z.

La motorisation est assurée par 3 moteurs pas à pas unipolaires 4.1V 1.1A acheté chez Technimaniacs, les prix sont très corrects et le service parfait à recommander. Je n’ai pas réutilisé les anciens moteurs, ils nécessitaient d’être démultipliés ce qui me faisait perdre en précision, de plus, leur puissance était vraiment limite.

Pour ce qui est de l’électronique, il s’agit de la même carte que ma première fraiseuse, un kit de chez HobbyCnc. Elle a le mérite de bien fonctionner et d’être très bon marché par rapport à la concurrence. Le pilotage ce fait cette fois sous linux avec EMC2. Un excellent logiciel opensource de pilotage de fraiseuse.

La chaine logiciel (opensource)utilisée est la suivante:

• Qcad pour le dessin des pièces. Les fichiers sont enregistrés en DXF

• Gcnccam pour générer le GCODE

• Ensuite c’est axis qui est utilisé comme interface à EMC2.

EMC2 est installé sur une ubuntu 8.04 avec un noyau temps réel RTLinux. C’est absolument nécessaire sur ce type de machine afin de garantir la précision du fraisage.

Pour la gravure de circuits imprimés, il y a Eagle et un script de génération du Gcode. Je ne suis pas certain que ce soit facilement faisable avec Kicad

Voici quelques photos de la machine construite. Le seul gros problème rencontré: un axe des Z trop souple donc une machine très imprécise. Je l’ai donc entièrement refait en acier soudé au chalumeau. Il est maintenant très rigide. Pour le reste, c’est assez simple, un châssis rectangulaire en aluminium dans lequel vient coulisser le mobile de l’axe des Y. C’est sur ce mobile Y que vient glisser le plateau de fraisage. L’axe des Z qui porte la dremel est guidé par des rails en alu. Des roulements de roller maintiennent le chariot Z en place.

Voilà une petite vidéo de test avec le fichier de démo d’Axis. Le fraisage ne se termine pas la course de ma machine étant trop limitée. Pour un premier test, la précision est au rendez-vous.

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]