Archive for the 'Computers' Category

Mon petit BB-8 fait maison

Monday, February 8th, 2016

Après avoir vu le dernier Star Wars, comme de nombreux geeks, j’ai été épaté par le petit droïde BB-8, et comme de nombreux geeks, j’ai eu très envie d’essayer d’en faire un.

J’ai commencé par dégoter une sphère en plastique de 300mm, et une de 180mm (qui ressemblait plus, d’après mon pied à coulisse, à une sphère de 160mm quand je l’ai reçu…) ; une paire de moteurs. Puis j’ai sorti la boîte à électronique du placard, avec en projet : me lancer et résoudre les problèmes comme ils viennent, plutôt que de  commencer par planifier plein de trucs et de perdre courage au milieu.

DSC_0526

Le début était plutôt facile : enlever les parties inutiles des boules, puis les poncer pour que la peinture tienne (et qu’elles soient bien lisses).

DSC_0534

Ensuite quelques petits calculs pour savoir où placer le châssis le plus bas possible, une petite découpe de contre-plaqué, et j’ai commencé par fixer les moteurs.

DSC_0541

J’ai ensuite ajouté la batterie, le plus bas possible pour essayer de stabiliser le tout le mieux possible :

DSC_0544

Spoiler alert : Cette batterie USB, bien que capable de sortir 2.4A en 5V, n’a pas la pêche nécessaire pour faire bouger quoi que ce soit. Elle s’est vue remplacée par une batterie LiPo 2S que j’utilisais pour mes voitures radiocommandées.

DSC_0550

Puis j’ai commencé la partie facile (pour moi) : un peu de programmation Arduino. J’ai utilisé un récepteur 2.4GHz standard, et ajouté un gyroscope électronique 3 axes, imaginant pouvoir l’utiliser pour compenser un peu le tangage. Enfin, j’ai utilisé un shield moteurs Adafruit pour les moteurs.

DSC_0558

Le résultat.. Spoiler alert : le gyro ne sert à rien, car les moteurs à courant continu et réducteurs sont bien trop imprécis pour compenser quoi que ce soit. Même s’ils l’étaient, ils pourraient compenser le tangage (d’avant en arrière) mais pas le roulis (latéral).

Enfin si, le gyro sert à couper les moteurs et faire marche arrière quand on va droit dans un mur (sinon, le châssis commence à grimper dans la boule et la tête finit par tomber en arrière.)

DSC_0563

Après l’upgrade de batterie, le premier test était plutôt encourageant :

Et voilà les difficultés qui commencent, avec l’ajout du mât :

DSC_0562

Et de la tête, dotée d’aimants pour la maintenir en place (avec ceux du mât en dessous), et des billes multi-directionnelles pour rouler librement sur le corps.

12552541_10205407629492323_2296425100086899696_n

Spoiler alert :les toutes petites billes multidirectionnelles sont bourrées de frottements et roulent très mal. D’autre part, trop d’approximation dans le placement des aimants les faisaient frotter contre le corps, occasionnant de disgracieux grincements (et de disgracieuses chutes de tête).

Mais bon, c’était prometteur. Donc je me suis lancé dans la peinture.

DSC_0565

DSC_0569

DSC_0570

DSC_0571

Après plusieurs heures de masquage, peinture, démasquage, jurons, remasquage, repeinture, etc, je suis arrivé à un résultat imparfait mais pas trop honteux.

DSC_0573

J’ai donc continué avec la tête… (Ici, les “yeux”)

DSC_0574

DSC_0576

Mais à mon grand désespoir, le simple poids des deux yeux (pourtant fabriqués en véritables boules de Noël) entrainait inexorablement la tête vers le sol. J’ai fini par me décider qu’elle était irrécupérable, et je l’ai toute refaite, cette fois ci avec une boule en polystyrène (de la bonne taille cette fois !), et pendant que j’y étais, j’ai refait tout le mécanisme avec de meilleurs aimants, de meilleures billes multidirectionnelles (trois fois plus grosses et sur roulements), et surtout, de meilleures mesures.

DSC_0578

DSC_0589

Et le résultat rend plutôt bien, si vous voulez mon avis !

DSC_0593

Ça roule aussi beaucoup mieux, même s’il y a encore quelques vibrations parasites et qu’il puisse semble que BB-8 a bu un coup ou deux de trop :

Ça m’a pris trois semaines d’arriver à ce point de la construction. Je n’en avais pas encore tout à fait marre, donc j’ai amélioré deux-trois trucs. Principalement, je n’avais pas envie de devoir ouvrir BB-8 à chaque fois que je voulais l’allumer. J’ai donc bricolé un interrupteur magnétique (avec un aimant et un trombone. N’essayez pas avec un vieux capteur de compteur de vélo, ça ne supporte pas l’ampérage, et ça s’auto-soude au premier essai. Ne me demandez pas comment je le sais.)

Évidemment, pour repérer l’interrupteur magnétique de l’extérieur et en approcher les aimants, ce n’est pas évident, mais bon, ça marche quand même car je connais à peu près la hauteur du châssis et je l’ai positionné à peu près à l’ “avant” (qui se repère par l’oeil de BB-8).

DSC_0591

J’ai aussi ajouté une paire de relais, qui sont utilisés pour que l’Arduino puisse s’auto-éteindre au bout de deux minutes sans signal de la télécommande. Cela me permet de ne pas avoir à l’ouvrir pour l’éteindre non plus.

DSC_0590

Et enfin, j’ai collé un mini testeur de batterie LiPo, pour qu’il puisse bipper quand la batterie commence à se vider dangereusement (je dis dangereusement, parce que les LiPo c’est susceptible, ça peut prendre feu si on les regarde de travers).

Voilà, je considère mon petit BB-8 terminé, même s’il est loin d’être parfait ! Je crois que ce n’était pas le plus simple des robots pour un premier, mais bon, je me suis bien amusé à le construire. Peut-être que la prochaine fois je ferai un R2D2, qui, bien que plus demandeur au niveau carrosserie, sera “les doigts dans le nez” niveau mécanique.

Après la construction, je suis allé voir sur Youtube des vidéos d’autres constructeurs de BB-8, et c’est plutôt amusant de voir combien de solutions il y a pour faire rouler une boule sur elle-même. Il y en a de très simples avec une voiture télécommandée dans la boule, d’autres roulent par transmission direct et tournent via une roue inertielle ; d’autres encore sont des robots holonomes équipés de roues multi-directionnelles (très amusant à voir rouler), certains utilisent une transmission indirecte comme le mien, mais une roue inertielle pour tourner (Ce type est bon, mais il a aussi accès à pléthore de matériel, et j’aime à croire que je pourrais faire bien mieux si j’avais des imprimantes 3D, des usineuses CNC, tout le tintouin ET QU’ON ME PAYAIT POUR ÇA), et enfin le modèle de cet ado de 17 ans fonctionne exactement comme le mien, mais bordel ce môme est doué.

Self-shutting-down Arduino

Saturday, February 6th, 2016

I have recently finished building my own BB-8 robot (more on that later!) and faced the problem of not wanting to open its body to power it on and off. I came up with the following idea.

self-shutting-down-arduino_schem

Here, the battery is connected to the Arduino’s ground and a simple relay’s ground. The positive lead of the battery is connected to the NO (normally open) pin of the relay, and the Arduino’s VIN pin is connected to the MAIN pin of the relay. So, as long as the relay’s open, no current goes to the Arduino. To start the Arduino, I’ve also connected a push button to the NO and MAIN pins of the relay. When I push the button (in BB-8’s case, it’s a magnetic button), this lets the Arduino boot up.

The only thing needed then, in order to be able to release the button and have the Arduino stay powered, is to close the relay programmaticaly :

 

#define POWER_PIN 2
void setup() {
  pinMode(POWER_PIN, OUTPUT);
  digitalWrite(POWER_PIN, LOW);
}

Then you only need to keep the button pressed during the Arduino’s bootup, and as soon as you hear the relay click, you can release it.

Now, to power off the Arduino, it’s just a matter of setting the relevant pin HIGH on a predefined condition (in BB-8’s case, it’s after 60 seconds of RC signal loss):

void loop() {
  /* do your normal stuff */

  if (now() - rc_signal_lost > 60) {
    power_off();
}

void power_off() {
  digitalWrite(POWER_PIN, HIGH);
}

In my case, the circuit is more complicated, because I’m using a 2S LiPo battery. These things hate being over-discharged, so I added a LiPo battery tester which beeps when the cells’ voltage drop below a certain level. The tester is plugged on the three charge balancing leads of the LiPo battery, which allow to test each cell independantly. So, in my bot I have wired two relays, one of them for each cell’s positive lead. This allows to have the LiPo battery tester without having it draining the power when the bot is off.

Here is the schematics for my bot:

self-shutting-down-arduino_schem

HP Laserjet P3005: fuser disassembly and gear kit replacement

Friday, January 23rd, 2015

Here’s how to disassemble the fuser on an HP LaserJet P3005 printer, and replace the gear kit (which is a part that fails often, reference CB414-67923). First remove the sliding plastic part at the back of the printer, then remove these two screws :

1

Then remove the big plastic panel, bottom first so it disengages at the top.

Lift these two little tabs so you pull the part they’re attached on towards you, and remove it:

2

Remove the screw holding the next panel in place (then remove it by putting the cable at the left away, and be careful not to break the clip at the right). I don’t think this is necessary, in reality. I did it because I didn’t know where I was going.

3

Then unplug the fuser cables (the cover on the power panel comes off with no screws) :

4

5

And unscrew the four screws :

6

You can then pull the fuser away and reach the gears. From left to right, the first one has a plastic tab keeping it in place, which you can pull with a little screwdriver. The second one is free when you remove the first. The third one is freed by the fourth, which is held in place by a weird little plastic piece. The sizes of the pieces are rather close but not identical, watch out for that. More details on this part of the procedure.

7

How to act like an idiot and cost a free software project money

Thursday, March 13th, 2014

A few monthes ago, a user made us a €5 donation for Claws Mail’s Windows version. Then asked me over email and Facebook friend request for support on “error messages that pop is starting up prior to sm something da da da” (actual quote).

7i2dq

I just replied that this seemed like he’d need to enable POP before SMTP, and that he’d get better support on the users mailing list.

And this person then filed a chargeback at his credit card company, and consequently, Paypal withdrew €5 from my account, and withdrew an extra €16 the bank charged for processing.

This got me a little disgruntled, to say the least, so I sent Paypal screenshots of the user’s email support request and Facebook friend request, and Paypal forwarded those to the bank.

Yesterday I got news that the bank resolved this in our favor (and I do hope our indelicate user got a scolding :-)), and the €5 reappeared on my account.

The €16 processing charges, though, seem lost forever.

7i2f5

Full story about Claws Mail donations – what they are for, what they aren’t for.

Ma Machine Inutile, découverte d’Arduino

Sunday, January 19th, 2014

Ça faisait quelque temps que j’avais envie de m’intéresser à la plateforme Arduino, une petite carte électronique à peine plus grosse qu’une carte de crédit, très peu chère et qui permet de faire plein de choses – électronique, domotique, robotique, … très facilement pour quiconque connaît un tout petit peu la programmation. Le web fourmille de forums et de tutoriaux qui facilitent grandement les choses, et un tout un tas de capteurs et actuateurs à bas prix sont disponibles facilement : détecteurs de lumière, accéléromètres, même des puces GPS ! et côté actuateurs, servos, moteurs, lumières, relais (pour commander des circuits haute tension), ….

Bref il ne me manquait que l’idée d’un premier robot pour me lancer, et je suis tombé par hasard sur le concept de la Most Useless Machine of the World, un tout petit robot tout simple, qui ne sert à rien, mais que l’on peut compliquer si on en a envie, et je me suis dit que ce serait un super premier projet.

Voilà ce que ça donne, présenté par mon fils Gaspard (mes deux enfants sont fans du robot, ils vont être déçus quand je vais l’apporter au travail) :

On m’a demandé les plans, donc voici !

Liste de courses

  • Une boîte en bois (que vous pouvez aussi construire vous même, j’ai fait la mienne en balsa de 5 mm), de dimensions intérieures minimum 14 x 10 x 6 cm, mais vous pouvez tabler sur 17 x 13 x 7 pour avoir plus de place)
  • Une carte Arduino, Arduino Uno par exemple car elle dispose d’un port USB qui peut servir d’alimentation et d’une alimentation, c’est plus pratique pour une première carte – j’ai vu qu’il existe des Mini ou Pro Mini, qui consomment moins en veille, mais pour lesquelles il faut fournir une alimentation stabilisée et un adaptateur USB/Série. Bref, Uno pour commencer c’est parfait.
  • Deux servos d’entrée de gamme (3 kg de couple suffiront largement, la vitesse importe peu, la pignonnerie nylon non plus :-))
  • Un interrupteur à levier et une résistance 10 kOhmsà
  • Optionnellement, un relais soit simple (mais il faut alors faire un peu plus d’électronique), soit facile à utiliser sur plateforme Arduino.

La première étape consiste à faire les branchements. Le plus simple est d’acheter quelques fils de prototypage et une platine de prototypage, mais sinon la soudure fonctionne bien aussi. Côté Arduino on peut planter des fils étamés avec de la soudure dans les broches.

Il faut que l’Arduino ouvre la boîte, lance le bras qui va rappuyer sur l’interrupteur, rentre le bras puis referme la boîte lorsqu’on appuie sur l’interrupteur.

Arduino a justement un exemple pour lire l’état d’un interrupteur : http://arduino.cc/en/Tutorial/DigitalReadSerial

Pour pouvoir lire de manière fiable si une broche est HIGH (alimentée) ou LOW (non) il faut qu’elle soit mise à la masse quand elle ne l’est pas (sinon elle “flotte” à un potentiel indéterminé). Je compte brancher l’interrupteur à la broche 2, donc je connecte la broche 2 et la broche GND (ground) avec la résistance, et la broche +5V à la broche 2 avec l’interrupteur au milieu :

DSC_9148

Ensuite, je compte alimenter les servos avec le relais pour ne pas gaspiller de courant quand la boîte ne fait rien. Le relais est contrôlé par une petite tension au borne d’un solénoïde qui permet de déplacer mécaniquement un interrupteur. J’ai choisi un relais simple à interfacer avec l’Arduino, je branche donc sa masse avec celle de l’Arduino, son VCC (+5V) avec le +5V Arduino, et sa broche de contrôle sur la broche 3 de l’Arduino :

DSC_9149

Puis, l’alimentation des servos : leur masse est en commun avec celle de l’Arduino, leur + est lui coupé ou non par le relais. On branche donc le NO (normalement ouvert) du relais aux + des servos, et le C (Commun) du relais au +5V de l’Arduino :

DSC_9150

Et enfin, on branche le fil Signal des servos aux broches 4 et 5 de l’Arduino, respectivement :

DSC_9151

Avant de faire le montage définitif, il faut vérifier le code et calibrer les servos (sinon ils vont se jeter dans la boîte et quelque chose va se casser, et ce sera pas marrant). Le code, donc. L’installation de l’environnement Arduino est facile et cross-platform (et tout leur code est libre !). Une fois que c’est fait, on peut programmer. Un programme Arduino se compose de deux fonctions principales et obligatoires, setup() exécutée au démarrage, puis loop() exécutée en boucle. Nous allons utiliser la bibliothèque de contrôle de servos, donc nous l’incluons :

#include <Servo.h>
void setup() {
}
void loop() {
}

Puis on spécifie quelques constantes pour se souvenir plus facilement des broches, des sens de déplacements et des bornes des mouvements des servos (pour l’instant à 0-45 car on n’a pas testé) :

#include <Servo.h>
int brocheInter = 2;
int brocheRelais = 3;
int brocheServoBoite = 4;
int brocheServoBras = 5;
Servo servoBoite;
int departBoite = 0; /* Ces angles seront à adapter */
int finBoite = 45;
Servo servoBras;
int departBras = 0;
int finBras = 45;
int angleLeveBras = 1; /* Pour lever le bras on procèdera degré par degré jusqu'à 
                        * ce que l'interrupteur soit refermé */
void setup() {
}
void loop() {
}

Maintenant, on initialise les broches et les servos :

 void setup() {
  /* on spécifie que la broche est liée un capteur */
  pinMode(brocheInter, INPUT);

  /* On éteint le relais */
  digitalWrite(brocheRelais, LOW);

  /* Puis on spécifie que la broche est liée à un actuateur */
  pinMode(brocheRelais, OUTPUT);

  /* On "attache" les servos à leur broche de controle */
  servoBoite.attach(brocheServoBoite);
  servoBras.attach(brocheServoBras);

  /* On initialise les servos avec leur angle de départ */
  servoBoite.write(departBoite);
  servoBras.write(departBras);
}

Puis, dans loop, on va regarder à chaque début de boucle si l’interrupteur est HIGH (ou LOW, ça dépend du sens de montage de l’interrupteur !), et en fonction, allumer les servos (et les ré-éteindre à la fin) :

void loop() {
  /* L'interrupteur est il ouvert ? */
  if(digitalRead(brocheInter) == LOW) {
    /*  Oui ! il faut le refermer ! */

    /* Allumons les servos */    
    digitalWrite(brocheRelais, HIGH);

    /* On ouvre la boite avec le servo du couvercle */
    /* On tend le servo du bras */
    /* On range le servo du bras */
    /* On ferme la boite */
    /* Mais pour l'instant, on attend juste deux secondes */
    delay(2000);

    /* Eteignons les servos */
    digitalWrite(brocheRelais, LOW);
  }
}

Ça a l’air de marcher ! alors c’est parti pour bouger nos servos ! (Pendant les tests, n’oubliez pas de ré-éteindre l’interrupteur vous-même)

void loop() {
  /* L'interrupteur est il ouvert ? */
  if(digitalRead(brocheInter) == LOW) {
    /*  Oui ! il faut le refermer ! */

    /* Allumons les servos */    
    digitalWrite(brocheRelais, HIGH);

    /* On ouvre la boite avec le servo du couvercle */
    servoBoite.write(finBoite);
    /* On attend un peu, sinon ça va trop vite dans la séquence
     * pour les servos. */
    delay(200);

    /* On tend le bras du servo, pas plus loin que sa fin de course
     * et seulement jusqu'à ce que l'interrupteur soit rebasculé.
     */
    int angleServoBras = servoBras.read();
    while (angleServoBras != finBras && digitalRead(brocheInter == LOW)) {
      angleServoBras = angleServoBras + angleLeveBras;
      servoBras.write(angleServoBras);
      /* On attend pour que le servo aie le temps de bouger */
      delay(20);
    }
    /* On parcourt un dernier degré, sinon l'interrupteur ne bascule pas 
     * et revient quand le servo le lache. */
    servoBras.write(angleServoBras + angleLeveBras);
    delay(20);

    /*On range le servo du bras */
    servoBras.write(departBras);
    delay(200);

    /* On ferme la boite */
    servoBoite.write(departBoite);
    delay(200);

    /* Eteignons les servos */
    digitalWrite(brocheRelais, LOW);
  }
}

Une fois que tout le code fonctionne, il ne reste plus qu’à positionner les servos et l’interrupteur dans la boîte pour régler les angles de départ et de fin de course. Puis à finaliser le montage.

Pour mes servos, les angles sont de 76° (fermé) à 45° (ouvert) pour  l’ouverture de la boîte, et de 138° à 60° pour le bras. Comme ils sont “à l’envers”, j’ai utilisé la variable angleLeveBras (= -1) pour un code plus naturel.

Pour le bras du robot, j’ai fait un petit montage avec du balsa de 2mm :

IMG_20140114_205936_820.1

La boîte :

IMG_20140114_235042_119.1

IMG_20140114_235121_541.1

Pour le couvercle qui se soulève, un simple élastique entre la paroi et le couvercle fait le travail de retour et le tient collé au bord :

DSC_9154

Pour le couvercle côté interrupteur, j’ai mis des guides pour le caler, mais des vis sont sans doute plus simples et plus solides. Je n’ai pas osé les vis sur du balsa :

DSC_9155

Et voilà le tout :

DSC_9156

Amusez-vous bien ! Pour moi, j’ai adapté le programme pour faire plein de trucs différents (vitesse, hésitations, etc). Voici le programme qui tourne sur mon Arduino : useless_machine_c.ino

news for few, stuff no-one cares about