Auteur/autrice : LordGG

La pizza napolitaine DIY ! ;)

Alors rien à voir avec les sujets abordés habituellement sur ce blog, mais je suis tellement fan de cette découverte, que j’avais envie de la partager, et après tout, on reste dans le Do It Yourself 🙂

pizza_01

J’adore les pizzas, j’en fais souvent des maisons, mais le fait est que la pâte ne ressemble jamais à celle qu’on peut déguster dans une vraie pizzeria : une pâte fine, moelleuse et croustillante à la fois. Le succès dépend essentiellement de 2 paramètres :

  • la réalisation de la pâte (farine spécifique, temps de maturation etc.)
  • la cuisson : elle doit être très rapide et puissante. Ainsi la pâte ne sèche pas, reste moelleuse à l’intérieur et la garniture garde toute sa saveur.

Avant tout chose : ce billet découle de la découverte d’un topic incroyable lancé sur le forum du site Hardware.fr. Il contient actuellement plus de 1300 pages de messages au sujet des techniques, recettes, « hacks », expériences etc. autour de la pizza faite maison, et tout particulièrement, la fameuse pizza napolitaine. Le premier message résume l’essentiel pour bien commencer et j’en recommande fortement la lecture, ce billet porte sur mes premières expériences.

Les fours domestiques sont limités en température (même si quelques mâlins ont trouvé le moyen d’utiliser leur four en mode pyrolyse pour faire cuire leurs pizzas). La solution est de se tourner vers un four à pizza pour particulier. On trouve beaucoup de produits décevants, mais quelques uns sortent du lot, en particulier le G3 Ferrari. Je l’ai eu pour 70€ lors d’une promo sur Amazon Italie, en général, on le trouve autour de 100€. Ce four a la particularité de chauffer à près de 400°C (résistance au dessus et résistance sous la pierre réfractaire). Ce four peut même monter encore plus haut, il a été bridé suite à de nouvelles normes européennes, mais peut être facilement débridé et même moddé, on y reviendra. Pour ma part, je l’utilise pour le moment tel quel, sans modification.

pizza_00

La pâte

C’est l’élément essentiel. Pour obtenir un résultat proche de la vraie pizza napolitaine, il faut utiliser une farine appropriée : de la farine italienne type ’00’. Il  existe différents moulins (producteurs) qui déclinent leurs farines en plusieurs gammes (le choix de la gamme dépendra essentiellement du temps de maturation). Pour le moment, j’ai testé des farines Spadoni (PZ1), Quaglia (Petra3) et Caputo (Classica). Ces farines type ’00’ sont assez difficiles à trouver en France. Certaines épiceries fines italiennes en proposent, et parfois on en trouve en grandes surfaces. Sur Paris, l’épicerie fine RAP offre un bon choix et sont très sympa. Sur Internet, je suis tombé sur un site très pro, avec un service client réactif, connaisseur et commerçant : Gustini.fr. Les frais de port sont acceptables. A défaut de farine type ’00’, on peut se rabattre sur de la T45 si les placards sont vides (mais c’est quand même dommage).

Il est recommandé d’utiliser de la levure fraîche de boulanger (ou de bière). On en trouve en grande surface, sous forme de cube (vers le rayon boulangerie).

Les ingrédients pour la pâte sont très basiques : eau, levure, farine, sel. Et c’est tout. La quantité de levure va dépendre du temps qu’on laissera « maturer » la pâte. Pour réaliser 6 pâtons de 220g en prévoyant 16 heures de maturation à température ambiante, j’utilise les quantités suivantes :

Farine: 793 g
Eau: 507 g (64 %)
Sel: 20 g (40 g/lit)
Levure: 0.84 g (1.66 g/lit)

Pour déterminer ces proportions, j’utilise un petit programme développé par Rafbor du forum Hardware.Fr, RafCalc. Le lien est disponible dans sa signature, ou en cliquant ici.

Avant de se lancer, je recommande le visionnage de ces 2 vidéos, qui aideront à visualiser les différentes opérations :
Impasto a mano pizza napoletana
Impasto napoletano , la mia versione

Passons à la réalisation de nos pâtons, voici comment je m’y prends :

1/ Dans un grand verre, verser l’eau, ajouter la levure fraîche (mélanger doucement jusqu’à dissolution complète) – peser la levure avec une balance de précision (+/- 0.1g)
2/ Verser le verre dans un grand saladier et ajouter les 3/4 de la farine et mélanger un peu
3/ Couvrir et laisser reposer 15 minutes
4/ Pétrir la pâte en ajoutant le 1/4 restant de farine et le sel au fur et à mesure jusqu’à ce que la pâte ne colle plus (il est important de ne pas mélanger le sel dans l’eau au début, car il attaquerait la levure)
5/ Couvrir et laisser reposer 10 min
6/ Faire une dizaine de rabats pour incorporer de l’air jusqu’au point pâte (élastique, non cassante), répéter si nécessaire
7/ Couvrir et laisser reposer 10 minutes
8/ Faire une grosse boule et laisser reposer 1h heure (pointage) sous cellophane

pizza_02
9/ Former les pâtons et les placer dans un tupperware légèrement huilé. On trouve facilement des  vidéos qui montrent des techniques de boulage.

pizza_03 pizza_04
10/ Laisser reposer le temps prévu

La maturation peut se faire à TA (température ambiante) (2 à 24 heures selon la quantité de levure et la farine utilisées) ou au frigo, dans ce cas la maturation sera plus longue (compter 3-5 jours).

L’avancement de la maturation s’observe grâce à toutes les petites bulles d’air qui se forment :

pizza_05

Plus la maturation aura été longue, plus la pâte sera légère, facile à digérer et meilleur en sera le goût.

Les pâtons peuvent également être congelés. Je les fais par 6, parce que ça prend un peu de temps et ça me permet d’avoir des stocks pour me faire une pizza rapidement (compter 3 heures de décongélation à TA).

Abaisse des pâtons

J’utilise de la semoule de blé fine pour facilité l’abaisse du pâton (sinon il est beaucoup trop « collant ») : quand je sors le pâton de son tupperware, j’imprègne sa surface de cette semoule (à défaut, on utilisera de la farine). On étale le pâton à la main. Ne surtout pas utiliser de rouleau de pâtissier ! Il chasserait les petites bulles d’air qu’on a mis du temps à faire apparaître et la pâte perdrait en légèreté. Je commence par appuyer avec les doigts au centre du pâton pour repousser la pâte vers l’extérieur. Je termine la mise en forme en étirant la pâte. Là, ça vient avec la pratique et je suis moi-même encore un novice 😉 Youtube regorge de vidéos qui illustrent différentes techniques pour abaisser nos pâtons.

pizza_06 pizza_07

Une fois la pâte prête, on la dépose sur le support en double demies-lunes, puis on ajoute la garniture (d’abord la sauce tomate, puis la mozza, puis le reste). La pizza est prête à être cuite !

Enfournement et cuisson

Je laisse préchauffer l’appareil pendant 15 minutes à 2.5, puis je le laisse ouvert 5 minutes : la pierre va un peu refroidir et la chauffe va redémarrer. A ce moment là je passe le thermostat à 3 (max) pour être sûr que l’appareil chauffe durant toute la cuisson. 5 minutes plus tard, la pizza est prête ! 🙂

La sauce tomate

Voici comme je prépare la sauce tomate : j’utilise des tomates concassées de qualité vendues en conserves (Cirio, Mutti…). Je vide la conserve dans une assiette creuse, je prends juste les tomates en coupant la partie dure, je malaxe le tout avec les doigts (surtout ne pas les mixer pour ne pas éclater les pépins, ça donnerait un goût acide), un petit passage à la passoire pour retirer le gros de l’eau et je rajoute un peu de sel, du parmesan, de l’origan et un tout petit peu d’ail.

La mozzarella

Il faut utiliser de la mozzarella Buffala. On la trouve sous forme de boules dans des sachets remplis d’eau. Avant de pouvoir l’utiliser, il va falloir la débarrasser d’un maximum de son eau : on coupera la boule en lanières que l’on déposera dans une assiette pendant quelques heures, le temps de laisser l’eau dégorger.

pizza_08

Ci-dessous, quelques photos de mes premiers essais, on peut voir que la pâte présente des alvéoles, elle est légère, moelleuse et croustillante, tout en restant assez fine.

pizza_09 pizza_10 pizza_11

Quelques unes de mes premières pizzas sont visibles ici. Pour aller plus loin, il faudra tester différentes farines, différentes durées de maturation et imaginer toutes sortes de garnitures 🙂

Mais dans tous les cas, je ne rachèterai pas de si tôt une pizza industrielle ou venant de chez Domino’s Hut Rabbit 😉

Bonus

Bien sûr, si ce n’est déjà fait, un tour sur le topic « Pizza maison » H-FR s’impose 🙂

Le forum de la Fédération des Pizzaïolos regorge d’infos et de conseils intéressants.

Un mot concernant le mod de cet appareil. Evidemment, ce n’est pas recommandé, pour des questions de sécurité et de garantie. Ce merveilleux petit four peut être modifié pour être encore plus efficace ! Les 3 principaux mods sont les suivants :

  • débridage du thermostat, pour monter autour de 500°C
  • ajout d’un moule à tarte en guise de « cloche » à chaleur
  • changement de la résistance par un modèle plus puissant

Présentation des mods sur H-FR (scroller un petit peu pour tomber sur la partie concernant le G3Ferrari)
Vidéo du mod du thermostat
Une autre vidéo sur le thermostat

Si la vis du variateur de thermostat est fixée, il faudra tordre une petite pâte du mécanisme qui bloque la position maximale (et permettre d’aller un peu plus loin).

Pour le moment, je n’ai fait aucune de ces modifications sur mon appareil car le résultat est déjà plus que satisfaisant.

Bon appétit, et retour à la technique pour le prochain article 😉

Projet R.I.P.E.R. : étage batteries

La pause fun avec BB-8 étant terminée, on se remet aux choses sérieuses avec l’étage du robot qui contiendra les batteries. On reprend donc où on en était resté il y a quelques semaines : Projet R.I.P.E.R. (Robotic Intelligent Platform for Entertainment and Research).

Les choix concernant l’alimentation sont expliqués ici : Autonomie et alimentation d’un robot.

Une batterie de 7.2V/5Ah sera dédiée à l’alimentation des moteurs CC et servomoteurs, l’autre alimentera tout l’électronique du robot. Il pourra fonctionner au choix, sur batteries ou sur alimentation secteur (via régulation 12V). La bascule se fera automatiquement.

On pourra recharger les batteries du robot sans les sortir du chassis, via 2 connecteurs jack.

Voici le modèle 3D :

00_EtageBatteries

Et la sortie d’impression :

On commence par installer les connecteurs jack femelles :

  • Les 2 à l’avant permettront la recharge des batteries
  • Les 2 sur les côtés à l’arrière permettront d’alimenter l’étage supérieur (contrôle des moteurs et alimentation du robot)
  • Le connecteur du milieu est l’entrée pour une alimentation fixe de l’ensemble du robot

Le circuit électronique utilise le principe de commutation par diodes, décrit ici. Quand l’alimentation fixe du robot est coupée (12V), les batteries prennent automatiquement le relais (7.2V). Voici le schéma de la carte :

07_EtageBatteriesSchema

Les Jx sont des borniers, Cx des diodes Schottky. J3 est l’arrivée de l’alimentation fixe en 12V. J7 et J8 sont connectés aux prises jack de rechargement des batteries. Les borniers J1 et J2 permettent de raccorder les 2 batteries. Enfin, J4 et J8 sont les sorties vers les connecteurs jack qui alimenteront l’électronique et les moteurs du robot.

Après installation des 2 batteries :

J’ai également imprimé un couvercle, essentiellement pour des raisons esthétiques, en gardant une ouverture pour l’évacuation de la chaleur.

Le bloc prendra ensuite place dans le châssis.

J’espère que le diamètre des fils sera suffisant pour le courant qui circulera. J’ai été contraint d’utiliser des borniers plus petits que prévu initialement pour des raisons de place. On verra bien 🙂

BB-8 DIY (contrôlé par la Force ;)

Après quelques mois passés à bosser sur un gros projet, je m’offre une petite pause de fun pour un petit BB-8 fait maison, parce qu’il est vraiment trop mignon 😉 (vidéo disponible à la fin de l’article).

A la base, je voulais juste faire une une figurine et puis je me suis dit que ça serait sympa de l’animer un peu. Alors il ne se déplace pas, mais il tourne la tête, émet des sons et détecte les obstacles devant lui : un simple passage de la main devant lui déclenchera différentes animations.

Ci-dessous, l’ensemble des éléments utilisés (électronique, pièces imprimées, capteur ultrasons, servomoteur…). Le modèle 3D n’est pas de moi, il vient d’ici. J’ai fait des trous dans le corps pour pouvoir passer l’axe de la tête et imprimé des joints pour assembler le tout (+ le support).

Après ponçage, enduit, peinture et vernis, il ne reste plus qu’à assembler le tout.

L’image suivante représente le « cerveau » de BB-8 : un simple Arduino Nano, un buzzer et 3 borniers à visser (alimentation et capteur ultrasons).

Le code est disponible ici. C’est pas super propre mais bon, ça fait l’affaire. J’ai eu de petits soucis d’incompatibilité entre différentes librairies car elles utilisaient les mêmes interrupts : Servo, NewPing, Tone (ou même NewTone pour éviter le conflit avec NewPing). Au final, je n’utilise aucune librairie pour piloter le buzzer).

Vue du boitier une fois tous les composants en place :

Le servomoteur est fixé au centre du boitier :

Pour prolonger l’axe du servomoteur, j’ai utilisé un tube (qui remontera jusqu’à la tête) et imprimé 2 joints qui s’emboîtent dans le tube de PVC : le premier a un emplacement prévu pour intégrer le connecteur à la tête du servomoteur (en noir, que j’ai découpé d’un support vendu avec le servo) et le second qui permet de faire la jonction avec la tête).

Au passage, le socle au dessus du servo est constitué de 2 pièces : la première permet de surélever le support au dessus des vis du servo et le second est un cône qui donnera l’illusion d’une dune (le sable a été saupoudré sur une couche de colle à bois) parce qu’on rencontre BB-8 dans le désert ;).

Aperçu du système de rotation de la tête :

A l’arrière : un interrupteur et un connecteur USB (le robot peut fonctionner sur USB ou sur pile, au choix) :

Et voilà !

Pour finir, une démonstration de notre petit BB-8 en vidéo 🙂

 

Tous les fichiers sont disponibles ici (modèles Sketchup, fichiers STL et code pour le Arduino Nano). Les fichiers STL du robot en lui-même sont à récupérer sur Thingiverse comme indiqué plus haut.

Projet R.I.P.E.R. (Robotic Intelligent Platform for Entertainment and Research)

Désolé, ça commence par beaucoup d’explications textuelles, mais des schémas plus éloquents sont à la fin 🙂

J’ai passé ces deux derniers mois à tester pas mal de choses : moteurs, capteurs, amplis audio, écrans, microcontrôleurs, matériaux, montages, mini-PC… C’était intéressant, mais le but est bien évidemment d’utiliser tout ça pour créer un robot 🙂

Dans ce billet, je vais essayer de formaliser toutes les idées qui me trottent dans la tête depuis quelques temps et décrire où je veux aller.

Jusqu’ici j’ai fabriqué quelques robots assez simples, avec des comportements limités à des tâches précises (et avec un petit microcontrôleur en guise de cerveau). Une fois le robot terminé, il l’était vraiment et je passais à autre chose. Cette fois, je veux réaliser une véritable plateforme robotique, très polyvalente pour explorer différents domaines de la robotique :

  • Le SLAM pour Simultaneous Localization And Mapping (ou cartographie et localisation simultanées). C’est un ensemble de techniques qui permettent à un robot de connaître sa position et de découvrir son environnement.
  • La synthèse vocale (TTS : Text To Speech), pour lui permettre de communiquer avec des êtres humains par la voix.
  • La reconnaissance vocale (SR : Speech Recognition ou STT)
  • Langage, conversation avec un humain
  • Intelligence artificielle et apprentissage
  • Utilisation d’internet (accès à des services, bases de connaissances…)
  • Vision : reconnaissance de formes et de visages, tracking
  • Algorithmes d’évitement d’obstacles (Virtual Force Field algorithm)
  • Pilote de la domotique
  • Télé-présence et surveillance
  • « Humanisation » : permettre au robot d’exprimer des émotions (mouvements, yeux…), lui donner un comportement moins prévisible avec des micro gestes aléatoires (clignement des yeux…), des tics de langages etc.
  • Extensibilités : possibilité de lui ajouter des modules pour lui donner de nouvelles capacités (module pour analyser la qualité de l’air, piloter la domotique, changer la fonction de ses bras/mains : poignée, pince, lasers…)
  • Personnalité, comportements, humeurs, humour…
  • …

La plateforme devra être suffisamment évoluée pour approfondir tous ces sujets sans devoir refaire un nouveau robot à chaque fois. En gros, il ne sera jamais vraiment terminé 🙂

Les applications qui en découlent sont illimitées :

  • Accompagnement, stimulation et surveillance/assistance des personnes âgées ou en difficulté
  • Télé-présence : pouvoir prendre le contrôle du robot à distance et se déplacer / communiquer grâce à lui, comme si on y était
  • « Chef d’orchestre » domotique et sécurité (détection et signalisation d’intrus, pilote du chauffage, de la télé, de la musique, de l’humidité, simulation de présence…)
  • Jukebox à la demande
  • Occuper le chat (en le faisant jouer avec un laser etc.)
  • Assistant personnel à domicile (domotique, lecture des e-mails et autres notifications, actualités, météo, discussions, gestion de l’agenda et rappel de rendez-vous, mémos, réveil…)
  • Coach personnel
  • Station d’analyse de l’air, détection de produits dangereux/toxiques
  • Exploration de zones dangereuses/inaccessibles pour l’homme
  • Conquérir le monde…

Pour créer cette plateforme voici les composants que je compte utiliser (dont la plupart ont été testés dans les articles précédents) :

  • Le cerveau supérieur : un mini-PC sous forme de clé HDMI avec un processeur Intel Atom CherryTrail (4 coeurs), 4Go de RAM, 32 Go de mémoire eMMC. Ces « PC » consomment peu, sont très légers et compacts, offrent des possibilités intéressantes en terme d’IA, sans compter l’accès au Bluetooth et au Wifi (et donc à Internet). Pour une centaine d’euros !
  • La moelle épinière : un Arduino MEGA (Pro Mini), qui aura la charge de transmettre les messages entre le cerveau (mini-PC) et le reste du corps du robot (capteurs, actuateurs : moteurs, écrans, HP…).
  • Un anneau de sonars : 12 capteurs ultrasoniques SRF05 pilotés par un Arduino Nano, lui-même connecté à la moelle épinière par le bus I2C. Les capteurs détecteront les obstacles tout autour du robot.
  •  Capteurs d’environnements : boussole (référentiel directionnel), détecteur de luminosité (LDR), détecteur de distance IR (pour éviter les chutes)
  • La tête : webcam USB avec microphone pour récupérer l’image et le son (et la voix) (Logitech c920), matrice de capteurs thermiques pour identifier les sources de chaleur (humains, animaux, feu…) (TPA81), Pixy CMUCam5 pour reconnaître et traquer des objets, 2 matrices de 8×8 LEDs pour émuler les yeux, un bargraphe de 5 LEDs pour animer la bouche, émetteur/récepteur IR pour piloter certains appareils, des LEDs puissantes pour éclairer dans l’obscurité. Le tout sera piloté par un autre Arduino Nano, lui-même connecté à la moelle épinière par le bus I2C.
  • Le cou : une tourelle « pan-tilt » constituée de 2 servomoteurs pour bouger la tête de haut en bas et de gauche à droite.
  • Un ampli et un haut-parleur pour émettre la voix du robot, de la musique ou des sons. Connecté sur la sortie son du mini-PC.
  • Quelques périphériques pour interagir « manuellement » avec le robot (écran OLED, boutons, buzzer).
  • HUB USB : pour connecter le mini-PC, la webcam, l’Arduino MEGA (+ de nouveaux périphériques)
  • Bras : 3-4 servomoteurs et la possibilité d’y attacher un module (pince, laser…)
  • Des cartes de contrôle des moteurs et servomoteurs (raccordés à la moelle épinière)
  • Moteurs CC avec encodeurs et un châssis. J’ai opté pour un châssis à chenilles, type tank : facile à diriger et une meilleure adaptation au terrain que les roues.
  • Alimentation : une première batterie Ni-MH de 7.2V / 5000mA pour les moteurs CC et servomoteurs (bras et cou). Une seconde batterie identique pour tout l’électronique (bas niveau, hub et PC). J’ai opté pour du Ni-Mh pour des raisons de sécurité (je veux pouvoir le laisser allumé même si personne n’est à la maison). La moelle épinière (MEGA) surveillera l’état des batteries. Le robot pourra aussi fonctionner sur une alimentation externe (12 V).

Pour concrétiser tout ça, voici une « maquette » de R.I.P.E.R., ce n’est pas très joli, mais ça a le mérite de clarifier un peu la cible 😉

Maquette_RIPER

Le schéma suivant décrit l’architecture du robot et recense toutes les interfaces nécessaires. Le détail de chaque carte n’est pas représenté pour faciliter la lecture. Cliquer sur le schéma pour le voir en taille réelle :

ArchiRIPERmini

Et voilà, il y a plus qu’à…;)

 

Boussole et interférences électromagnétiques

Dans un précédent article, je testais le fonctionnement d’une boussole électronique avec un Arduino.

Si elle marchait très bien dans des conditions optimales, il était apparu que la proximité d’un champ magnétique suffisamment puissant la rendait complètement inopérationnelle. On observe ce phénomène lorsqu’on approche un aimant d’une boussole : l’aiguille perd le nord, le champ magnétique de l’aimant prenant le dessus sur le champ magnétique terrestre.

Dans le cas d’un robot, c’est problématique parce que les moteurs et haut-parleurs contiennent de puissants aimants. J’avais constaté qu’à partir d’une distance de 15 cm environ, mes moteurs ne gênaient plus trop la boussole, mais ça reste assez contraignant.

Il existent des matériaux qui permettent de dévier les champs magnétiques, notamment le Mu-Metal. Il est essentiellement constitué de fer et de nickel et a subit des traitements spécifiques qui lui confèrent une forte perméabilité magnétique. Le Mu-Metal est très utilisé pour le blindage magnétique (câbles, disques durs…).

C’est plus compliqué à se procurer que la plupart des autres composants d’un robot, mais on en trouve sous forme de ruban adhésif ou de plaque. J’ai commandé une petite plaque autocollante de 10cmx10cm (0.01mm d’épaisseur) pour une quinzaine d’euros sur ebay (on doit pouvoir trouver moins cher, mais en petite quantité, c’est plus difficile).

Pour aller droit au but, ça marche vraiment très bien ! La preuve en vidéo :

 

Récepteur/émetteur IR : clonage d’une télécommande

Encore un sujet qui m’a posé quelques problèmes, finalement liés à une télécommande un peu particulière.

Je ne suis pas encore sûr à 100% d’intégrer un récepteur et un émetteur infrarouge dans mon robot. Mais il peut-être intéressant de permettre à un robot de piloter les équipements de la maison.

Une LED infrarouge (cadre bleu sur la photo) permettra d’envoyer des signaux à ces équipements. Il faut utiliser des LED IR avec une longueur d’onde de 940nm (celles que j’utilise : 1.1-1.4V, 100 mw, 50 mA).

Pour piloter la LED avec l’Arduino Nano, j’ai utilisé un transistor NPN (BCX38C). Sachant que les sorties du Nano sont limitées à 40mA au grand maximum, je ne voulais pas prendre de risque et j’ai préféré prendre le courant directement sur l’alim. Avec une résistance de 82 Ohms (R = (5 – 1.3)/0.05 = 74 Ohms). Je mesure avec l’ampèremètre une trentaine de mA. Le transistor est donc facultatif.

Un récepteur IR (cadre jaune sur la photo, un TSOP38238)  permettra de capturer les signaux d’une télécommande pour pouvoir les restituer plus tard avec notre LED (lorsqu’on appuiera sur un bouton).

J’ai utilisé la librairie IRremote de Kim Shirriff, qui a réglé toutes mes difficultés. Elle gère un large panel de type de signaux. L’exemple IRrecord est le programme que j’ai utilisé pour mes tests (il permet d’apprendre un signal et de le restituer lorsqu’un bouton est appuyé). Un tutorial disponible ici.

Ecran OLED SSD1306 128×64 SPI

Cet article fait suite à celui-ci.

En faisant le tour des différents périphériques i2c que je compte utiliser pour mon robot, j’ai eu la mauvaise surprise de voir que la boussole et l’écran OLED partageaient la même adresse sur le bus i2c (x3C). Aucun des 2 modules ne permet de modifier l’adresse comme c’est le cas pour certains périphériques.

J’ai donc commandé le même écran OLED, dont je suis très satisfait, mais dans sa déclinaison SPI afin d’éviter les conflits sur le bus i2c. Ca a été plus compliqué que prévu, d’où ce court article.

La première difficulté concerne le raccordement de l’écran à l’Arduino. Certains connecteurs sont nommés de manière peu éloquente : Gnd, Vcc (jusque là, ça va), D0, D1, RES, DC, CS.

Voici les bonnes correspondances, écran –> Arduino :

  • GND –> GND (masse)
  • VCC –> 3.3V à 5V (alimentation)
  • D0 –> SCK
  • D1 –> MOSI
  • RES –> un pin digital (c’est pour le reset)
  • DC –> un pin digital (data/command)
  • CS –> SS

Second problème, logiciel pour changer. J’utilise toujours la librairie U8glib dont je suis très content. Par contre, les constructeurs proposés dans les différents exemples de code ne fonctionnent pas : il faut passer au constructeur le numéro du pin RESET ! J’ai utilisé le constructeur suivant dans mes tests (avec un Arduino Nano) :

U8GLIB_SSD1306_128X64 u8g(13, 11, 10, 9, 4);

// SW SPI Com: SCK = 13 (D0 sur oled), MOSI = 11 (D1 sur oled), CS = 10 (CS sur oled), A0 = 9 (DC sur OLED), !!RESET = 4 (RES)!!

Arduino Mega… Mini !

J’adore les Arduino Nano, ils ne coûtent rien, prennent très peu de place, sont très faciles à intégrer dans des petits projets et offrent toutes les fonctionnalités de leur grand frère le Uno.

L’Arduino MEGA est particulièrement intéressant pour les plus gros projets. Ils offrent bien sûr beaucoup plus d’entrées/sorties analogiques et digitales, mais c’est au niveau de la mémoire qu’ils se démarquent :

  • EEPROM : 4 Ko contre 1 Ko pour le Nano/Uno
  • SRAM : 8 Ko contre 2 Ko pour le Nano/Uno
  • Flash : 256 Ko contre 32 Ko pour le Nano/Uno

L’Arduino MEGA permet donc de s’affranchir d’un certain niveau de contraintes vis-à-vis de la mémoire, qui peut rapidement venir à manquer. Mais au contraire du Nano, il est énorme ! C’est vraiment une carte de prototypage, assez difficile à intégrer dans des projets finaux.

Le meilleur de ces 2 mondes existe ! 🙂

Ce n’est pas une carte qui existe officiellement chez Arduino, mais en cherchant un peu, on la trouve : la Meduino Mega2560 Pro Mini. Je l’ai commandée sur ebay, expédiée depuis la Chine (aucun vendeur européen). Elle est totalement compatible avec le Arduino Mega2560, simplement beaucoup plus compacte.

J’avais besoin de la quantité de mémoire de la MEGA, mais ça taille était vraiment un problème (sans parler de la fiabilité des connecteurs pour un produit fini).

Après avoir soudé les pins (y en a quand même autour de 80), j’ai lancé un petit test avec un écran OLED. Ça a fonctionné parfaitement du premier coup, la carte est vraiment vue comme un Arduino Mega2560 ! 🙂

 

Boussole électronique : HMC5883 / HMC5983

Pour gérer les déplacements et la localisation d’un robot, il faut connaître ses coordonnées et son orientation (la direction dans laquelle il regarde). Une boussole lui fournira un référentiel pour lui permettre de définir son orientation.

J’ai commandé les 2 modules suivants pour faire mes tests : le HMC5883 et le HMC5983 (on les trouve facilement pour 3€ sur ebay, banggood et autres vendeurs) :

En fait, j’avais déjà un HMC5883, j’ai commandé un HMC5983 qui est son successeur et qui apporte quelques améliorations mineures (SPI, compensation de la température…).

C’est là que mes mésaventures ont commencé : le module HMC5983 peut s’alimenter en 5V (le 5983 tournant à 3.3V), donc je l’ai bêtement connecté à mon Arduino. Mais il marchait très mal (quelques secondes au mieux). J’ai contacté le vendeur (bsfrance sur ebay) qui m’a répondu très rapidement : le module peut s’alimenter en 5V, mais le niveau logique pour les pins i2c est lui toujours à 3.3V ! Bref, il me faut un convertisseur de niveaux pour l’utiliser correctement. C’est commandé, en espérant que le 5983 n’est pas été abîmé par mes tests à 5V.

En attendant, je suis passé sur mon HMC5883, qui lui a été beaucoup plus tolérant : le niveau logique à 5V ne pose pas de problème.

Voici le montage de test :

Un Arduino Nano (non visible), le module HMC5883 (à gauche) et un servomoteur. Le but est que lorsque l’on fait tourner la boussole électronique (le 5883), l’axe du servomoteur se déplace du même angle (par rapport au nord). On voit sur la photos que le HMC5883, la boussole manuelle et l’axe du servomoteur sont tous orientés au nord.

La librairie de Adafruit fonctionne très bien, c’est celle que j’utilise pour le moment.

Voici la démo en vidéo :

Le code source est disponible ici.

C’est un bon début. Je m’inquiétais aussi des effets que pouvaient avoir les éléments magnétiques du robot sur la boussole. Les moteurs ainsi que le haut-parleur contiennent des aimants assez puissants. Et je n’avais pas tord de m’en inquiéter, la preuve un images :

Comme on peut le voir, les moteurs comme le HP rendent la boussole totalement inutilisable. C’est facheux, mais on ne va pas se laisser abattre :

  • il existe peut-être des moyens de calibrer la boussole pour compenser les interférences environnantes fixes (qui ne varient pas), à creuser
  • Quand je recevrai le convertisseur de niveaux, je testerai le HMC5983, il sera peut-être moins sensible aux interférences
  • A partir d’une quinzaine de centimètres, les interférences deviennent négligeables, je pourrai ajuster le design du robot pour éloigner au maximum la boussole des moteurs et du HP (voir même le surélever sur une petite tourelle).

Edit du 21/11/2015 :

J’ai reçu les convertisseurs de niveau et j’ai retesté le HMC5983 et ce n’est pas mieux (même avec un autre HMC5983, c’est pareil).

J’ai mis la main sur une librairie spécifique au 5983 (dispo ici, qui fonctionne très bien avec le 5883 aussi). Et je vois qu’il y a beaucoup de lectures en erreur (50%). Au moins, avec cette librairie, j’arrive facilement à écarter les erreurs et obtenir des données utilisables. Par contre, si je lis trop rapidement le capteur, les données ne sont plus exploitables… (en gros, jusqu’à une lecture toutes les 100ms, ça va).

Bref, j’ai perdu bien assez de temps avec ce capteur. J’ai trouvé très peu de cas d’utilisation avec un Arduino, ça n’aide pas. J’aurais aimé comprendre ce qui ne tourne pas rond mais tant pis, j’utiliserai le HMC5883 qui lui ne pose aucun problème.

Dernier point concernant les interférences, j’ai commandé une feuille de Mu-metal, qui est un matériau qui à la faculté de bloquer/dévier les champs magnétiques. Il me permettra d’isoler un peu les moteurs et le HP pour limiter les interférences sur la boussole.

Pixy CMUcam5 : un capteur de vision intelligent

La Pixy MCUcam est une caméra intelligente, elle est capable de reconnaître et suivre des objets grâce à leur couleur. Elle peut apprendre jusqu’à 7 signatures et est très performante (50 analyses d’image par seconde). Elle propose un large panel d’interfaces (i2c, série, SPI, USB…). La page du produit est ici (projet financé via Kickstarter).

Elle est dispo chez Lextronic (entre autres) à 69€. Ça peut sembler cher, mais vu ce qu’elle propose, ça me paraît très raisonnable.

Sur PC, on peut la connecter via USB et utiliser un logiciel pour la tester et la configurer. Sur la vidéo suivante, elle traque 2 objets (précédemment appris).

Comme on peut le voir, la camera sait identifier sur l’image la présence de certains objets. A chaque analyse elle renvoie les coordonnées et les tailles des objets identifiés.

Les performances sont vraiment impressionnantes. Il y a par contre des conditions à respecter : le capteur est basé sur un algorithme de filtrage des couleurs (il analyse la teinte et la saturation de chaque pixel). Les conditions d’éclairage peuvent avoir un impact sur l’efficacité du capteur, ça reste à tester plus en profondeur. De nombreuses options sont disponibles pour ajuster les conditions de reconnaissance. C’est avec des couleurs vives que le capteur marche le mieux.

Si l’application PC est pratique pour les tests et la configuration, c’est avec un Arduino que je l’interfacerai. La camera dispose d’un port pour une nappe de 10 fils. Le câble livré avec n’en contient que 6 et est prévu pour une connexion via SPI. Je compte l’utiliser en i2c, il faudra donc prévoir un nouveau câble. Voici le détail des connexions sur le port de la Pixy CMUcam5 :

Ci-dessous, l’ordre des pins pour les connecteurs mâles et femelles des nappes :

Je ferai un câble spécifique pour la connexion i2c, en attendant j’utilise simplement des câbles de prototypage.

Et voici la démo (fournie en exemple avec la librairie Arduino) en i2c :

A chaque analyse, le capteur renvoie la liste des signatures détectées (sig), les coordonnées (x,y) et la taille en pixel (width/height):

On voit qu’il y a un peu de bruit, il faudra trouver le moyen de filtrer tout ça. Mais les possibilités de ce capteur sont immenses.

Le code source est ici (et provient des exemples de la librairie fournie pour Arduino, je n’ai rien inventé).

Je compte notamment l’utiliser pour mettre en place des algos de SLAM (Simultaneous Localization And Mapping, soit en français: cartographie et localisation simultanées).

L’idée est d’apprendre au capteur un certain nombre d’objets qui serviront de balises de repérage. Quand le capteur identifiera un marqueur, le robot pourra en déduire la pièce dans laquelle il se trouve. Encore mieux, grâce à la taille retournée par le capteur, il pourra estimer la distance qui le sépare de ce marqueur. Le robot saura que sa position est un point sur un cercle de rayon X autour du capteur. Enfin, grâce à une boussole, il saura identifier précisément ce point !

Ça c’est la théorie, on verra la pratique plus tard 🙂