Archive for the 'Computers' Category

Self-shutting-down Arduino

samedi, février 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

Ma Machine Inutile, découverte d’Arduino

dimanche, janvier 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

Quitcount 1.5

dimanche, juillet 19th, 2009

Since I’ve blogged about my little Quitcount tool, I’ve received a Hungarian translation from Páder Rezső, a German translation from Fabian Affolter, and an Italian translation from Salvatore de Paolis, and fixes from a few other people (most of them I already know from Claws Mail, heh :-) Thanks guys! I’ve released 1.5 to have them in a tarball, because this little tool will probably end up packaged in a few distros :-)

Politicards à la con

jeudi, juin 11th, 2009

Levebvre, porte-parole de l’UMP, après que le conseil constitutionnel aie tranché en défaveur de certains points de la loi création et internet (Hadopi): « Les socialistes […] n’ont pas de quoi être fiers. […] après le recours devant le Conseil constitutionnel, ils auront des comptes à rendre aux artistes et dans les urnes« .

Riester: « Le texte permettait déjà aux internautes de déposer un recours devant le juge. On gagne une étape, on va directement au juge. Donc le caractère dissuasif sera encore plus fort« . À part le fait que ta loi foulait la présomption d’innocence aux pieds, t’as tout compris…

Veut-il dire qu’ils auraient préféré passer une loi anticonstitutionnelle sans rien demander à personne ? Y’en a vraiment qui doutent de rien…

Enfin, je me rends compte que bien que ces gens m’indignent, j’arrive mal à expliquer pourquoi. Mon avocat préféré y arrive beaucoup mieux.

Statistiques sur les mesures ANFR (Agence Nationale des Fréquences)

jeudi, juin 4th, 2009

À force de lire des articles sur les ondes pulsées du réseau GSM, qui nous émettraient trop fort dans les cerveaux, provoquant des cancers et des maux de têtes (mais pas dans cet ordre), j’ai voulu voir par moi-même l’étendue des dégâts concernant ces antennes.

Il paraît que le consensus scientifique est qu’un seuil d’exposition inférieur à 0.6V/m est réputé non dangereux pour la santé, et certaines associations comme Robin des Toits militent pour atteindre un tel seuil partout sur le territoire. Le but est noble, mais le ton alarmiste et je n’aime pas le ton alarmiste, surtout que les médias relaient (héhé) bien souvent les cris Au Loup sans aucune analyse derrière.

N’étant jamais si bien servi que par moi-même, après avoir regardé sur le site de l’ANFR, Cartoradio, à combien de V/m j’étais exposé à la maison, et après avoir trouvé ces chiffres (entre 0.11 et 0.51 V/m selon la bande) très peu inquiétants, je me suis demandé si j’étais juste chanceux ou si la plupart des antennes relais arrosaient déjà relativement peu.

J’ai donc enregistré toutes les pages de mesures de l’ANFR de la numéro 1 à la numéro 16328, modulo celles qui n’existent pas, grâce à ce script ; notez bien qu’une pause de 2 secondes a été insérée entre chaque enregistrement, pour le cas improbable où j’aurai pu mettre leur serveur à genoux à moi tout seul.

Profitant du fait que chacune des pages est sur le même modèle, j’ai ensuite extrait les valeurs correspondant aux émetteurs GSM avec ce script vers ce fichier CSV, que j’ai ensuite importé dans une base MySQL (car je suis nul en tableur) afin de pouvoir manipuler toutes ces données. Pour ceux qui sont nuls en base de données, il est aussi possible de l’importer dans un tableur en utilisant le séparateur de champ « , ». Pour ceux qui ne font pas confiance au fichier CSV, mes scripts sont disponibles pour le refaire.

Voici quelques résultats. J’ai été surpris de voir le niveau moyen et médian augmenter au fil des années : j’aurais pensé que, la technologie évoluant, les émissions auraient nécessité moins de puissance. J’ai aussi été surpris de voir une médiane inférieure ou égale à 0.6V/s : suite au bourrage de crâne des médias, je supposais qu’on était assaillis d’ondes néfastes en permanence. Ceci dit, ce schéma sur la FAQ de l’ANFR a tendance à montrer qu’il faut, pour être irradié dans les règles de l’art, se mettre pile en face d’une antenne relais. En dessous, on ne risque pas grand chose.

Quant au wifi, à 0.3V/m à 40 centimètres de la borne, à mon avis, ce n’est pas vraiment la peine de flipper du hotspot de l’hôtel d’à côté. Robin des Toits mentionne aussi la dangerosité du Bluetooth (portée de 10 à 100 mètres) ou encore des tags RFID (portée de quelques centimètres dans la majorité des cas – on trouve par exemple un tag RFID dans les systèmes de déverrouillage de portes à ventouse) ; de mon côté, j’émets (huhu) quelques doutes là dessus. L’ANFR ne mesure même pas ce type d’émission.

Ceci dit, on fait dire ce qu’on veut aux statistiques, donc j’enjoins quiconque est intéressé de faire ses propres statistiques, à partir du fichier CSV, et de me prouver que mon cerveau est déjà fondu.

Quelques chiffres que j’ai trouvé intéressants :

Nombre total de mesures : 14829
Nombre de mesures avec signal <= 0.6 V/m : 9584 (64.63 % du total) (entre 0 et 0.6 V/m :9584 – 64.63 % du total)
Nombre de mesures avec signal <= 1 V/m : 11500 (77.55 % du total) (entre 0.6 et 1 V/m :1916 – 12.92 % du total)
Nombre de mesures avec signal <= 2 V/m : 13429 (90.56 % du total) (entre 1 et 2 V/m :1929 – 13.01 % du total)
Nombre de mesures avec signal <= 4 V/m : 14353 (96.79 % du total) (entre 2 et 4 V/m :924 – 6.23 % du total)
Nombre de mesures avec signal <= 10 V/m : 14780 (99.67 % du total) (entre 4 et 10 V/m :427 – 2.88 % du total)
Nombre de mesures avec signal <= 20 V/m : 14821 (99.95 % du total) (entre 10 et 20 V/m :41 – 0.28 % du total)
Nombre de mesures avec signal <= 30 V/m : 14827 (99.99 % du total) (entre 20 et 30 V/m :6 – 0.04 % du total)
Nombre de mesures avec signal <= 50 V/m : 14829 (100 % du total) (entre 30 et 50 V/m :2 – 0.01 % du total)

chart_power_5vphp

Nombre de mesures par puissance, de 0 à 5 V/m

chart_power_50vphp

Nombre de mesures par puissance, de 5 à 50 V/m

Les quatre mesures dont le signal est supérieur à 25 V/m sont : 8165, 8166 et 8181 (même endroit) et 13919. La distance de mesure est de 1, 3, 3 et 5 mètres pour chacune d’elles et la zone de mesure est interdite au public.

Moyennes :

Moyenne des 227 mesures en 2001 :0.67 V/m – médiane 0.3 V/m – distance moyenne* : 53.83 m
Moyenne des 741 mesures en 2002 :0.5 V/m – médiane 0.2 V/m – distance moyenne* : 66.68 m
Moyenne des 1632 mesures en 2003 :0.57 V/m – médiane 0.3 V/m – distance moyenne* : 80.79 m
Moyenne des 1737 mesures en 2004 :0.7 V/m – médiane 0.4 V/m – distance moyenne* : 63.71 m
Moyenne des 1941 mesures en 2005 :0.84 V/m – médiane 0.4 V/m – distance moyenne* : 72.4 m
Moyenne des 2634 mesures en 2006 :0.9 V/m – médiane 0.4 V/m – distance moyenne* : 72.29 m
Moyenne des 2380 mesures en 2007 :0.89 V/m – médiane 0.4 V/m – distance moyenne* : 62.7 m
Moyenne des 2525 mesures en 2008 :0.97 V/m – médiane 0.5 V/m – distance moyenne* : 66.5 m
Moyenne des 1007 mesures en 2009 :1.08 V/m – médiane 0.6 V/m – distance moyenne* : 81.23 m
Moyenne des 14829 mesures :0.83 V/m – médiane 0.4 V/m – distance moyenne* : 69.73 m

Moyenne et médiane des mesures, par an

Moyenne et médiane des mesures, par an

*: les distances sont faussées par la présence de données vides et de données floues dans les données ANFR (’50 m – 100 m’ compte pour 50, ‘<50 m’ compte 0, par exemple).

news for few, stuff no-one cares about