Horloge à mots

IMG_0928Pour la fin de l’année 2016, j’ai eu envie de créer une nouvelle horloge (ma dernière réalisation datant de fin 2013 avec une horloge à galvanomètre). Il y a quelques années j’avais lu cet article, dans la langue de Shakespeare, sur une horloge à mots . Le concept me plaisait et après une (très) longue gestation, j’ai décidé de concevoir la mienne, mais auf französisch !!
.
.

.,

Capture d’écran 2017-01-04 à 16.36.56Il me fallait donc commencer par créer un ensemble de mots disposés plus ou moins en carré permettant d’afficher l’heure courante. Pour éviter de dériver vers une solution difficile à gérer, j’ai pris le parti d’afficher l’heure par bloc de 5 minutes. Ce qui, avec l’utilisation des mots  « QUART », « MOINS », « LE » et « ET » m’a permis de n’utiliser que 9 mots pour exprimer les minutes, soit 23 mots au total avec les heures.
23 ? plutôt pas mal…et pourquoi ? parce que 24-1=23  bien évidement !!!
Plus sérieusement, 23 mots à illuminer c’est comme 23 bits à 0 ou 1. Et 23 bits tiennent dans 3 octets (24 bits)….on en reparlera plus loin quand il s’agira de penser à électronique qui prendra tout cela en charge.
Comme le montre la copie d’écran du fichier Excel ci-dessus, il m’a fallu ensuite assembler ces mots d’une part pour former ce « presque carré » recherché, mais aussi, pour faire en sorte que les chiffres(mots) apparaissent dans le désordre (ma touche perso ;-) )
.
Capture d’écran 2017-01-04 à 16.38.39J’avais donc mon assemblage. Maintenant, il me fallait le rendre présentable et en faire quelque chose d’esthétique. Ayant vu une publicité pour des impressions de photos sur plaque de plexiglas (acrylique), j’ai pris le risque de m’aventurer vers cette solution, en partant du principe que la plaque devait offrir une légère transparence pouvant être rétro-éclairée avec une ou plusieurs leds très lumineuses.
Comme j’avais trouvé un sympathique cadre en bois pour servir de support à l’ensemble de l’horloge, il ne me restait plus qu’a créer une image de  30x30cm. Pour ce faire, j’ai utilisé le « clone » libre d’Illustrator, c’est à dire: Inkscape. J’ai utilisé du noir pour le fond et du blanc pour la police de caractère afin d’obtenir le contraste le plus élevé possible. Ne sachant pas ce que j’allais obtenir en rétro-éclairant, c’était plus prudent (et au final un peu plus « design » <- à prononcer « déssigne » comme feu mon grand-père).

IMG_0827Une bonne dizaine de jours plus tard, j’ai reçu ma plaque imprimée, que je me suis empressé de placer à l’intérieur du cadre. Un premier test avec une lampe de poche placée derrière a fini de me rassurer, le concept était bon !

Pour l’étape suivante, il fallait en premier lieu créer une boite à l’arrière du cadre afin d’y placer un cloisonnement en carton permettant de séparer chaque mot. Pour réaliser les parois de la boite, j’ai utilisé une chute de medium retaillée et collée à la colle vinylique. J’ai pu utiliser la même colle pour assembler les différents morceaux de carton. Pour le fond, qui a vocation à accueillir les leds, j’ai utilisé le même carton épais.

IMG_0820

IMG_0822

IMG_0825

IMG_0824

 

 

 

 

 

 

 .

 .

 .

.

.

.

.

.

IMG_0826


.

Passons maintenant à l’électronique, comme je l’évoquais précédemment, 23 mots étaient à gérer. J’avais testé précédemment, dans la V2 de la domotique, une solution permettant de réduire le nombre de pins utilisé en sortie en utilisant des registres à décalage. Pour rappel, le registre à décalage transforme, en entrée,  un signal « série » sur deux fils (horloge et signal) sur lesquels on fait transiter les 8 bits d’un octet, et, en sortie, il active (ou pas) 8 sorties en parallèle. Dans le cas de l’horloge, 3 registres à décalage chainés les uns à la suite des autres permettent d’illuminer chacun des 23 mots (le tout étant commandé par seulement 3 pins d’un arduino).
Ce qui permet d’utiliser l’un des plus petits arduino de la gamme: le « nano ».
Je n’ai pas pu utilisé le 74HC595 comme modèle de registre à décalage  (comme pour ma domotique). En effet, celui-ci étant surtout conçu pour de la logique et non de la puissance, il n’était pas en mesure de délivrer le courant nécessaire à une dizaine de LEDs en simultané. J’ai donc opté pour un TPIC6B595N qui est capable de fournir 150mA par pin de sortie (de quoi subvenir largement aux besoins du montage). La grosse différence entre ces deux composants vient des sorties. Sur le  TPIC6B595N, un « 1 » logique se traduit par une mise à la  masse et non un +5v comme sur le 74HC595. Cela demande juste de câbler les cathodes des LEDs vers les pins de sortie, l’anode étant commune et alimentée en +5V.
Comme pour l’horloge à galvanomètre, la partie temps réel, s’appuie sur un chip DS3231 packagé en breakout (beaucoup plus précis qu’un DS1307 -> il ne dérive que d’une à deux minutes par an).  Pour rappel la communication avec l’arduino se fait via le bus I2C.

Ce qui donne le schéma suivant:horloge_leds_schéma

Pour la conception du schéma, du PCB et sa fabrication, j’ai utilisé Fritzing.
Le service de gravure de PCB en ligne offert dans ce logiciel est un peu onéreux mais la qualité du produit reçu est vraiment bonne: gravure double couche, vernis protecteur, cuivre étamé

 horloge_leds_circuit imprimé

Le PCB après conception prêt à être envoyé au service de gravure offert par Fritzing

 

 

 

Voila ce que cela donne suite à la mise en place des composants (le résultat est plutôt compact).

IMG_0846

Puis après câblage des différents blocs de leds:

IMG_0929

 

Une petite vidéo montrant le démarrage de la « bête ».
Afin de vérifier le bon fonctionnement de chaque bloc de leds, ceux-ci sont allumés en cascade. De même lors de la synchro entre l’arduino et l’horloge temps réel, le mot « ET » est illuminé si l’opération c’est déroulée correctement (le mots « MOINS » l’étant si la synchro est impossible).

Le code source est relativement court (350 lignes).
Il est dispo ici.

Domotique revisitée ;-)

IMG_0926La première version de ma domotique m’a accompagné pendant 3 ans, mais il était temps de faire évoluer tout cela !!!

D’une part pour ces relais qui n’arrêtaient pas de « claquer » à chaque action sur les volets ou à chaque déclenchement du chauffage, et d’autre part pour cette interface graphique façon « minitel » d’un autre temps ;-)

Ce qui a donné un cahier des charges en deux parties:
– trouver un moyen de remplacer les relais par une autre solution
– avoir une véritable interface graphique digne de ce nom

Les relais:
pour la V1 de la domotique j’avais utilisé deux cartes de 16 relais où chacune des 32 entrées de commande était relié à un pin de l’arduino méga. Au delà du problème de bruit des relais, cela utilisait un trop grand nombre de sorties du microcontrôleur (à mon gout). Pour réduire ce nombre, il fallait passer par un système permettant un quelconque multiplexage des commandes. J’ai cherché à utiliser en premier lieu une solution basée sur une carte avec des relais sur bus I2C. J’en ai trouvé facilement un modèle 8 relais en vente sur Ebay. Si cette solution était intéressante du point de vue du nombre de pin utilisés (2 pins: SDA et SCL), cela ne résolvait en rien mon problème de bruit.

DSCF4892Je suis donc tourné vers une solution en deux partie. La première partie a consisté a utiliser une carte équipée de 8 relais « OMRON SSR G3MB-202P ». Ces relais sont des SSR (Solid State Relay), c’est à dire qu’il sont composés de composants électroniques ne faisant pas appel à des pièces mécaniques (donc pas de bruit !! ;-) ). Plus précisément, il s’agit d’un opto-coupleur (led+detecteur) qui commande un ensemble de transistors MOSFET en mode relais.
C’est la solution idéale dans mon cas, plus de bruit, pas de mécanique, donc, virtuellement inusable.
Concernant la deuxième parie de ma solution, il fallait que je trouve un moyen de réduire le nombre de pins utilisés, pour cela, je me suis intéressée aux registres à décalage. Derrière ce gros mot se cache un composant simple d’emploi qui permet de transformer un signal série en signal parallèle. Pour être plus clair, on envoie un signal d’horloge sur une patte et sur une autre on envoie les différents bits constituant un octet, en conséquence le composant va retranscrire cet octet en activant ou pas (0 ou 1) 8 pattes de sortie. Le registre à décalage le plus commun est le 74HC595, il a l’avantage d’être facilement chainable (on peut en commander 4 à la suite avec les mêmes fils), et de fonctionner très bien avec la bibliothèque « ShiftOut » développée pour les arduino.
domotique1_bb

Le schéma ci-dessous montre comment à partir de 5 fils (+5V; 0V; data; clock; latch) commander 32 sorties. Ce qui signifie qu’avec quatre 74HC595, il est possible de commander 4 cartes de 8 relais, le tout à partir de 3 pins (hors alim). Afin de réaliser quelque chose de compacte, j’ai souhaité faire mon propre circuit PCB plutôt que d’utiliser une plaque de prototypage et une multitude de fils volants. Je l’ai conçu avec le logiciel Fritzing qui permet de faire toutes les étapes depuis le schéma, en passant par le PCB, jusqu’à la demande de fabrication sur le net.
domotique1_circuit imprimé

Comme le montre ce dessin du PCB, je l’ai fait graver en double couche afin de minimiser sa taille. En bas se trouvent les entrées (2 pins d’alim+3 pins) et au milieu, chaque barre fourni l’alim et la commande de 2 cartes relais (+-12345678).

.
.
.

.

.

.

Et voila le résultat: Les 4 cartes et le PCB en dessous (en blanc). Le relais 1 de la quatrième carte est activé dans cet exemple.

IMG_0319

L’interface graphique:

J’ai cherché pendant plusieurs mois une solution simple et peu onéreuse permettant d’avoir une interface graphique correcte, mais sans grand succès. Jusqu’au jour où je suis tombé sur un billet expliquant comment utiliser une liaison serie entre un arduino et un Raspberry Pi afin d’utiliser le Raspberry pi comme carte graphique HDMI moyennant un programme en python coté Pi interprétant les commandes passée sur le port série par l’arduino. Si c’est encore trop obscur, lisez l’article, le principe y est bien expliqué.
Le plus dur a été d’apprendre à programmer en python pour analyser les trames série, gérer l’écran tactile (vu comme une souris USB par le RasPi), afficher des images, rafraichir l’écran et renvoyer des trames à l’arduino en retour de toute action. Le code du programme python est dispo ici (le corps du programme commence à partie de la ligne 422).
Encore merci à Gilles pour sa maquette d’interface graphique ;-)
La vidéo ci-dessous montre le fonctionnement de la chose:

L’énorme avantage d’un Raspberry Pi comme carte graphique est d’avoir pu réduire au maximum le code utile du coté de l’arduino. Par rapport à la V1 de la domotique le code passe d’environ 1700 lignes à 850. Avec cette nouvelle version la tache principale de l’arduino est désormais d’exécuter les taches planifiées (volets), et de gérer le chauffage.
Le code est dispo ici

L’ensemble de l’électronique avant remontage ;-)

IMG_0457

Afficheur moto 2

IMG_0258une petite modification de ma réalisation précédente…
Et oui, l’écran OLED, c’est très bien de nuit ou au fond du garage… mais en pleine journée, ce n’est pas vraiment l’idéal. Pour être franc, c’est totalement illisible !!

Je me suis donc tourné vers la plus simple des solutions: un écran LCD simple de 4×12.
Pour éviter un nombre de fils trop important, j’ai utilisé un petit module LCD-I2c afin de ne cabler que 4 fils entre le boitier et l’afficheur (+5v;GND;SDA;SCL)

A noter que ce type de d’écran n’est pas des plus fréquent. Ce sont les 4×20 que l’on trouve le plus facilement. Néanmoins, dans mon cas, la place libre entre mon compte-tour et le tachymètre étant plutôt restreinte, j’ai du opter pour cette version moins large.

Pour afficher la valeur du rapport engagé, je me suis tourné vers la possibilité qu’offre le HD44780 (chip le plus courant utilisé dans les afficheurs LCD en mode caractère) de créer jusqu’à 8 caractères personnalisés. Ensuite, il suffit de combiner ces caractère spéciaux pour créer un caractère « géant » sur 3 lignes et 4 colonnes.

le code source est dispo ici comme d’habitude ;-)

afficheur moto

10Nouvelle moto égal nouvelles idées….
Suite à l’achat de ma nouvelle moto, j’ai voulu concevoir un système me permettant de connaitre le rapport de boite de vitesse engagé (point mort, 1ère, 2ème, 3ème; etc…). Et puis, de fil en aiguille, je me suis dit qu’il me fallait quelques infos supplémentaires à afficher: l’heure, la température ambiante, et pourquoi pas la vitesse….

beaucoup d’infos à afficher et par conséquent beaucoup de capteurs et autres systèmes externes à connecter à un arduino….
De prime abord, j’ai pensé à ces solutions:
Pour la vitesse: un capteur a effet de champ sur la roue arrière ou avant, avec gestion des interruption coté arduino
Pour l’heure: une horloge temps réel type DS1307
Pour la détection du rapport engagé: soit un capteur dans la boite de vitesse, soit…(attention cela se corse) deux capteurs: un sur l’allumage et un sur l’une des roues . On divise ensuite les deux frequences obtenues et le ratio resultant est unique pour chacun des rapports de la boite de vitesse. Par contre, il faut détecter, alors, chaque appuie sur le levier d’embrayage puisque cela fausse les calculs (en débrayant, plus de liaison physique entre le moteur, la boite et les roues, le régime moteur tombe… et tout calcul devient impossible). Ce qui, sur route n’est pas gênant, mais qui rend le système complétement inutile en milieu urbain où l’on joue beaucoup de l’embrayage à faible vitesse….
Pour la température: un éternel capteur onewire type DS18S20 ou DS18B20

Ce qui nous donne au mieux 4 capteurs/systèmes, au pire 5… cela fait beaucoup quand l’on pense qu’il faut en un ajouter avec l’afficheur à gérer !!
Donc, essayons de simplifier la chose…
Et pourquoi ne pas utiliser un petit capteur GPS pour récupérer l’heure et la vitesse? Les prix ont fortement baissé (autour d’une trentaine d’euros) et l’emploi est très simple du fait du standard NMEA de formatage des trames de données renvoyées par les GPS (connecté à un port série). De plus, une très bonne bibliothèque pour arduino existe: TinyGPS
Ok, c’est déjà ça de gagné, deux éléments externes ont été réunis en un, et le tout sans avoir à tirer des fils partout sur la moto, ni de chose à étalonner….

Nous l’avons vu plus haut, la détection du rapport engagé risque de ne pas être une partie de plaisir…Et, c’est là où un obscur dieu grec de la mobylette entre en scène…. Je m’explique: ma moto d’origine coréenne (bon ça va, elle est pas cher, mais elle roule bien.  hein !!) est issue du sous-traitant historique de suzuki et partage beaucoup de pièce avec la production de la marque japonaise… Oui c’est bien, mais pas suffisant..certes !!
Je continue…sur la version plus récente de ma moto, une injection a été greffée et le capteur (vissé sur le coté de la sortie de boite de vitesse) qui donne l’info « point mort » au tableau de bord et à l’injection a été remplacé par une nouvelle version (issue de la banque suzuki) dont la configuration laisse présager quelque chose de sympa pour mon aventure. Un petite photo valant mieux qu’un long discours, je vous laisse constater par vous même.

3Voici donc les deux capteurs, à gauche le nouveau modèle, à droite l’ancien. Le premier constat: il y a beaucoup plus de contacts sur le nouveau!!! Alors, comment cela fonctionne?

Dans la boite, un picot en cuivre situé sur un disque, tourne d’une vingtaine de dégrées lorsque que l’on monte ou l’on descend un rapport et décrit, en gros, 3/4 de tour sur une boite cinq. Sur l’ancien modèle, le picot ne peut faire contact qu’à un seul endroit: quand la boite est au point mort, ce qui met le seul fil du capteur à la masse et permet d’allumer la lampe verte (neutral) du tableau de bord. Sur le nouveau, un rapide constat permet de voir qu’il est au départ prévu pour une boite six (ce qui prouve bien qu’il vient d’une banque d’organes et qu’il a été ré-adapté au modèle injection en n’utilisant que deux fils). Je me suis donc procuré le nouveau modèle avec pour objectif de le désosser et de voir ce qu’il serait possible de faire avec.

Et c’est là, où le dieu grec de la mobylette intervient une deuxième fois !!!! J’ai pu souder un câble à 6 fils au nouveau capteur, noyer le tout dans du silicone haute température et le remettre en place sur ma boite en continuant à utiliser le fil du point mort pour mon tableau de bord….
13

Tous les éléments sont maintenant présents pour commencer la réalisation. Un premier test sur une plaque d’essai avec un petit afficheur LCD 2X16 m’a permis de tester la cohabitation des différents éléments:
1

Bien évidement, mon bureau ne se déplace pas à 98 km/h !!! C’était un test d’affichage lol. Par contre l’heure indiquée est bien en provenance du GPS. Ce petit afficheur était très lumineux mais malheureusement sa largeur était un obstacle à l’intégration entre les deux compteur du tableau de bord. Je me suis donc tourné vers un afficheur OLED carré d’1,5 pouce de diagonale.

Pour traiter le signal en provenance de la boite de vitesse (mise à la masse de l’un des cinq rapport + point mort) j’avais la possibilité de dédier six pins de l’arduino (chaque pin étant configuré en pullup pour la détection de la mise à la masse).
Les premiers tests sur plaque d’essai ont été concluants, mais malheureusement cela n’a pas fonctionné in-situ. En effet la capteur baigne dans l’huile moteur et le picot qui fait contact avec le capteur n’est pas forcement un très bon conducteur.
La solution consistait donc tout comme pour la lampe « point mort » du tableau de bord à faire passer un courant suffisamment fort dans le capteur (quelques mA à minima contre les µA de l’arduino en direct).
Je suis donc passé par un classique un pont diviseur de tension. Avantage, un seul pin de l’arduino utilisé comme ADC (mesure d’une tension 0-5V), le pont ,par sa configuration, se chargeant de faire circuler l’intensité suffisante pour rendre le montage opérationnel. Comme je voulais conserver la lampe point mort, j’ai ajouté une diode pour ne pas perturber le pont (en evitant des retours de tension), et comme je suis prudent, j’en ai ajouté une sur chaque retour à la masse du pont afin d’isoler chaque élément.
Pour obtenir une alimentation un peu plus stabilisée, je suis passé par un 7810 (qui fourni 10V à partir des 12.8V-13.8V de la batterie), avec une division de base par un peu plus de deux cela donne 4.7V max injecté dans l’arduino….Par la même occasion le 7810 fourni également l’alimentation de l’arduino (ceinture et bretelles)
8bis

Un petit peu de soudure plus tard:
4

avec le concours de mon imprimante 3D un petit boitier à cacher sous la selle:
7

ce qui donne en vidéo :-)

L’animation de démarrage avec en parallèle l’acquisition des données GPS (1 min max)

Passage des rapports sur la béquille centrale et affichage en mode jour (le passage jour/nuit se fait en fonction de l’heure et d’une table coucher/lever du soleil cf code source plus bas)

le source est disponible comme d’habitude sur github:
https://github.com/Chnalex/arduino/blob/master/tb_bord_moto.ino
Il est relativement volumineux après compilation (93% des 28ko d’un arduino micro) du fait du stockage en mémoire flash des bitmaps qui servent afficher les nombres et autres valeurs. En effet, l’afficheur OLED basé sur un chip SSD1351 est piloté par la bibliothèque GFX d’adafruit et celle-ci ne contient qu’une font 5×7 pixels qui s’avère extrêmement laide quand on la zoom (pas d’antialiasing et gros pixels moches)

QuBéTank

IMG_20150406_183234

QuBéTank ? kesako ?
– « Qu » comme Quentin
– « Tank » comme tank lol
– « QuBéTank » comme cubetto Certes…mais cela ne nous avance pas beaucoup….

Tout a commencé il y a un peu plus d’un an en découvrant le projet d’une petite startup (Primo) qui a réalisé un outil éducatif (cubetto) permettant d’apprendre aux enfants de 3 ans (et plus) la logique de programmation d’une séquence d’actions sur un pupitre. Séquence, qui ensuite est transmise sans fil à un petit robot en forme de cube qui se déplace ensuite en conséquence. Ce concept pour ceux, comme moi, dont l’entrée dans le monde merveilleux de l’informatique c’est fait par le biais du plan informatique pour tous de Fabius en 1985 (ou inversement, pour ceux qui ont réussi à survivre au plan informatique pour tous ;-) ) , se souviendront du Logo… Ce langage qui à l’époque nous apprenait à déplacer une tortue pour réaliser des dessins (pour ceux qui ne connaissent pas, je recommande le très bon article de wikipedia sur le Logo).

J’ai voulu reprendre le principe du cubetto pour le repenser à ma sauce….Une télécommande avec afficheur LCD enregistre la séquence à réaliser (comme un accumulateur), puis lorsque l’on appuie sur le bouton « départ », la télécommande transmet via un port série sans fil crypté le tout au robot pour exécution. Le petit cube en bois du cubetto a été un peu déstructuré à la demande du futur utilisateur, qui du haut de ses quatre an et demi, a voulu un châssis à chenilles (« et avec un truc pour mettre canon, comme ça, ça fera un tank!!!! »).

Exit donc les petites formes en bois à poser sur des emplacements vides du pupitre, je suis parti d’un boiter plus compact ou les séquences seraient saisies en pressant quatre boutons poussoirs (avant – arrière – gauche – droite), le tout s’affichant sur un écran LCD. Deux autres boutons étant dédiés aux fonctions d’exécution et de remise à zéro de la séquence.

IMG_20150406_183141

Comme pour mes autres réalisations, j’ai fait découper et graver au laser la plaque de  fond du pupitre chez formulor.de

IMG_0844
La conception du pupitre est relativement simple et fait appel à un arduino . Mais pour une fois, j’ai voulu faire un peu plus dans le DIY (Do It Yourself), et je me suis appuyé sur une version à monter soi même: le Boarduino (un simple PCB sur lequel on soude les composants de base, puis on plug dessus un ATMEGA 328 avec un bootloader arduino).

IMG_0840

L’ensemble des boutons n’est relié qu’à une seule entrée analogique de l’arduino via un réseau de résistance connecté au +5V (l’appui sur un bouton précis génère une tension de sortie qui lui est propre). L’afficheur lcd 2×40 est piloté via un module lcd/I2C qui est directement relié aux bornes du bus I2C de l’arduino.  Pour le port série sans fil, j’ai utilisé un module APC220 dont le branchement est extrêmement simple (un TX et un RX)

Le code source du pupitre hébergé sur github:   https://github.com/Chnalex/arduino/blob/master/qubetank%28telecommande%29

IMG_0783

Cadeau de Noël oblige, la partie robot est basée sur un chassis plutôt bien fini acheté chez roboshop. L’ensemble est mu par deux moteurs DC  (un par bloc chenille).

Comme pour la partie pupitre, un boarduino relié à un deuxième module APC220 (pour recevoir la séquence envoyée par la télécommande). Et le hasard faisant bien les choses, j’ai pu utiliser l’antenne comme faux canon et satisfaire la demande du mini-commanditaire… Par contre, les arduino n’ayant pas d’étage de puissance capable de piloter les moteurs, j’ai du utiliser un double pont en H relié en amont à l’arduino et en aval aux moteurs, pour réaliser cet asservissement.

Afin d’ajouter un peu de réalisme j’ai utilisé l’une des pattes PWM de l’arduino pour attaquer un transistor connecté à un mini haut parleur, et via la bibliotheque PCM l’arduino joue le son d’un canon (en mono 8bit – 8khz) stocké dans son programme. Bon le son est un peu cracra (8khz comme échantillonnage c’est pas top), mais c’est sympa. Et comme un tank qui tire est soumis à un effet de recul, chaque exécution de séquence se termine donc par le bruit du canon suivi d’un leger recul (marche arriere toute pendant 80ms)

IMG_20150406_183215

le code source du robot/tank sur gtihub:
https://github.com/Chnalex/arduino/blob/master/qubetank

Et voila comment faire un cadeau de noël éducatif et drôle ;-)

Puissance 4 …robotisé…

IMG_0400

Le puissance 4….un grand classique de notre enfance et un projet qui a muri  presque 3 ans !

Tout a commencé en 2011 quand j’ai fais l’acquisition d’un bras robotisé piloté par une carte lynxmotion SSC-32. Cette carte à la particularité d’accepter en entrée un ensemble de commandes textuelles via un port série, et en sortie de piloter jusqu’à 32 servomoteurs (type modélisme). Le commandes sont très simples et prennent la forme suivante:
par exemple pour déplacer le servo n°2 à la position 750 (0.75ms soit 45°), il suffit de passer le séquence suivante « #2 P750 T1000″ (T<duree> représente le temps en ms que le servo prendra pour effectuer le mouvement). un peu de théorie sur la commande des servomoteurs: ici
De son coté, le bras est constitué d’un ensemble de 6 servos, il comprend une épaule (2 axes), un avant bras (1 axe), un bras un poignet (1 axe), et une pince (1 axe).

Mon premier projet était de faire commander le bras par ma réplique d’Apple I, et de laisser cette antique bécane gérer la logique des mouvements et l’IA. Bon, c’était sans compter sur sa terrifiante puissance de calcul à 1mhz. Sachant que je suis une tanche en assembleur, le programme devait tourner en basic, donc en interprété….résultat très décevant: juste pour l’IA il fallait de 1 à 3 min pour déterminer le coup à jouer.
Néanmoins, en faisant tourner le programme sur mon macbook, on pouvait obtenir ceci:

Avec un embryon de plateau de jeu réalisé avec des glissières en alu….

Ok, ce n’est pas l’idéal…. il était temps de réfléchir à quelque chose de plus « pro » qui utilise le vrai plateau de jeu d’un puissance 4, d’un distributeur de jeton (en prenant en compte le coté « rugueux » des jetons d’origine). Bref, du boulot en perspective….et puis d’autre projets sont apparus (domotique, radio, machine inutile + plein d’autres choses….).
2 ans et demi plus tard, après quelques tentatives infructueuses, j’ai décidé de reprendre le projet de zéro:

1) utiliser un plateau de jeu d’origine

La seule solution a été de surélever considérablement le bras pour que celui-ci domine le plateau et qu’il puisse déposer convenablement les jetons dans chacune des têtes de colonne. Solution mise en pratique par l’utilisation de pieds de table en acier de chez « Lee Roy Mèreline »
IMG_0409

 

2) les jetons et les distributeurs de jetons

Concernant les jetons, j’ai rapidement abandonné ceux d’origine pour un ensemble de cylindre que j’ai fait découper au laser dans le l’acrylique de 5mm d’épaisseur (formulor.de).
Le gros avantage réside dans le fait de pouvoir, dans une pile,  faire glisser sans difficultés le jeton du bas sans frottement (pour peu que la dite pile soit maintenue bien évidement).  Le distributeur pouvant, dans ce cas, prendre simplement la forme d’un parallélépipède vertical contenant la pile  et possédant une ouverture en bas suffisante pour en saisir un.
Ce qui donne:

3) L’électronique

Ayant pris un peu d’assurance avec les arduino’s, j’ai abandonné interfaçage avec mon « Apple I » et je suis parti sur une solution à base de « micro » (toujours pour son coté compacte). L’arduino micro étant comme tous ses grands frères très à l’aise pour communiquer sur un port série, il n’y avait donc aucun soucis à piloter la carte SSC-32 avec cette solution.

IMG_0398

3) L’IHM

Interaction minimaliste mais fonctionnelle au maximum…donc un afficheur LCD 4×20 (sur bus I2c) pour indiquer les phases du jeu, et un ensemble « LED + bouton poussoir » au pied de chaque colonne numérotée de 1 à 7.
Pour intégrer le tout, je me suis à nouveau appuyé sur les possibilités offertes par formulor.de, j’ai donc dessiné et fait découper un assemblage de plaques d’acrylique de 3mm qui forment un réceptacle à jetons sous le plateau et qui se termine en console abritant les boutons et les leds, coté joueur. Les LEDs sont pilotées chacune individuellement par une sortie numérique. Les boutons poussoirs, pour leur part, sont montés sur des ponts diviseurs de tension et reliés en sortie à une unique entrée analogique de l’arduino (pour faire simple bouton1=0.5V, bouton2=1V, bouton3=1.5V, etc..)
IMG_0407
une petite démonstration par la pratique??

une partie gagnée

comme d’hab, un petit lien vers le source hébergé sur GitHub: https://github.com/Chnalex/arduino/blob/master/puissance4.ino

Radioduino !!

radio-011-Large.jpg

Après le bureau, la cuisine !!!!
En trainant mes guetres sur le site de sparkfun, j’ai repéré un tuner FM piloté un bus I2C (changement de fréquence, recherche auto de station, données RDS), une nouvelle idée farfelue à germée….Réaliser une radio FM pour la cuisine avec pele-mèle: Un barometre, une horloge temps reel, un decodeur RDS avancé (refonte en profondeur de la bibliothèque d’origine fournie par sparkfun), un compte minute pour cuisiner, un ampli audio commandé par un simple potard, un joystick comme moyen d’interagir……et bien-sur, tout ça devant tenir dans un boitier de moins d’un mètre cube!!!!!!!!!!!!!

Pour changer un peu, j’ai utilisé un nouveau venu: l’arduino Micro, qui se distingue du nano par le fait qu’il intégrè le même microcontrôleur que l’arduino leonardo – un ATmega32u4. Cette puce a le gros avantage d’intégrer un port usb natif évitant de passer par un convertisseur série/usb, donc moins de composants sur le PCB. L’ATmega32u4 et sa gestion de l’usb permet aussi à l’arduino micro de simuler un clavier ou une souris.

radio 008 (Medium)

D’un point de vue composants/modules, beaucoup de déjà vu: horloge temps réel I2C snootlab, capteur de pression atmo Bosch BMP085, écran  LCD 4×20 sur bus I2C.

les trois nouveautés sont:
– le tuner FM I2C Si4703
– l’ampli miniature a base d’un TPA2005D1
joystick analogique avec click provenant des manettes de PS2

Pas de grand mystère pour le joystick, il est composé de deux potentiomètres dont on récupère la valeur de la tension issue du pont diviseur sur une entrée analogique de l’arduino.
Concernant le tuner FM, beaucoup de travail concernant la bibliothèque de traitement des signaux RDS. Celle fournie par sparkfun étant plutôt embryonnaire, il a fallu que je me plonge dans les spécifications de la norme RDS, afin de développer ma propre version de la bibliothèque pour afficher le RadioText en plus de la station (et pour ne pas m’arrêter en si bon chemin, j’ai implémenté la quasi totalité des fonctions RDS possibles AF-TA-PS-CT-RT-PI-TP-PTY). La bibliothèque est un fork de l’originale: https://github.com/Chnalex/Si4703_FM_Tuner_Evaluation_Board/tree/master/Libraries/Si4703_Breakout
elle est en court d’intégration dans le source initial….mais ce n’est pas très réactif coté sparkfun….. ;-)
L’ampli, pour sa part,  est très simple d’emploi (entrée,sortie, emplacement pour un potentiomètre, alim). Il est de classe D, il fonctionne comme une alimentation à découpage (signal PWM comme pour l’horloge à galva) la bobine de l’HP servant à lisser le signal. Ce qui donne une très bonne qualité de restitution pour un ampli de cette taille (2cm X 2cm, conso quelques dizaines de mA, rendu 1.4W, rapport signal/bruit 97Db), et surtout sans effet de chauffe.

radio 007 (Medium)

La façade… c’est aussi une des composantes de la réussite du projet. J’ai trouvé sur un forum une référence à un site en Allemagne permettant de concevoir en ligne (via une appli web type CAO) des objets en 2D (découpe et gravure) sur différents matériaux :
http://www.formulor.de/createDesign
pour la façade, j’ai choisi une plaque d’acrylique très fine (1.5mm) de couleur noire

radio 005 (Medium)

un peu de scotch double-face avant d’appliquer la façade sur le boitier

 

 

radio 004 (Medium)

 

 

 

 

la façade avant

radio 006 (Medium)

 

 

 

 

 

le résultat ….

 

 

 

 

 

une petite vidéo du démarrage (init, splashscreen, infos RDS ->PS puis RT)

 

vidéo du fonctionnement  du compte-minutes ….. ;-)

comme toujours, un petit tour par le source:

https://github.com/Chnalex/arduino/blob/master/radioduino.ino

 

Horloge à galvanomètres

IMG_0848

Quoi de mieux qu’une petite horloge de bureau atypique, avec un look analogique (comble de la supercherie totalement numérique dans les faits).
Et comme afficher l’heure c’est bien mais que donner un semblant de prévision météo c’est mieux, pourquoi ne pas y adjoindre un capteur de pression atmosphérique ainsi qu’un capteur de température.

comme toujours, un arduino nano sera au cœur du montage pour son coté compact. Le pilotage des trois  galvanomètres (heures, minutes, secondes) est assuré par les sorties « analogiques » (qui n’ont d’analogique que le nom, puisqu’il s’agit de sorties PWM en réalité  <- modulation de largeur d’impulsion 0-5V avec une fréquence d’environ 500Hz). Mais, oh miracle de l’électronique à l’ancienne, le galvanomètre étant composé d’une bobine (et souvent d’une résistance en plus), celle-ci lisse le signal pour donner une valeur continue (l’idéal eut été d’y adjoindre un petit condensateur…mais cela fonctionne parfaitement sans). Pour la partie, horloge temps réel le même Module I2C pour pour la domotique est utilisé, idem pour le capteur de température où un DS18B20 Onewire sera installé.
IMG_0852

La petite nouveauté réside dans l’utilisation d’un capteur I2C BMP085 de chez Bosh (module bleu vertical à droite de l’image)

Donc au final beaucoup d’analogique piloté, une pincé d’I2C, un soupçon de Onewire,
ce qui donne ça… dans le boitier définitif:

IMG_0851

les trois boutons poussoirs visibles sur le dessus sont là pour régler/recaler manuellement l’horloge interne (cf code source), ils sont alimentés en +5V et chacun ferme un circuit de pont diviseur. La lecture de la valeur étant effectuée sur l’une des entrées analogiques.

Le source sur GitHub: https://github.com/Chnalex/arduino/blob/master/horloge-galvanometre.ino

 

Domotique – où comment gérer mes volets et ma chaudière…..

IMG_0378

La machine inutile n’était qu’un galop d’essai pour aborder l’arduino… pour  notre nouvelle maison, j’avais comme projet de gérer la future chaudière à granulés ainsi que l’ensemble des volets roulants (à commandes radios – cf photo)

- pour gérer la chaudière, un ou deux capteurs de température font l’affaire (un par étage, pour leur facilité d’utilisation et un nbr restreint de fils -2- j’ai opté pour des capteur DS18B20 sur bus Dallas Onewire). La commande de son coté est gérée par un simple relais. La chaudière à granulés ayant une inertie importante (mise en route sur 10minutes, temps de chauffe d’au moins 3/4 d’heure, extinction en 15 minutes), une régulation évoluée est inadaptée et pour tout dire, plutôt néfaste à ce type d’installation, donc pas de PID mais une simple régulation par hystérésis (ex: pour une consigne à 19°, déclenchement à 18.5° et arrêt à 19.5°)
– pour gérer les volets…rien de plus simple, en tout cas sur le papier ! Les télécommandes comprennent trois boutons poussoirs (monter-arret-descendre) donc 3 relais par télécommande, mais comme il y a 9 télécommandes….il faut 27 relais !!!!! Il est temps de IMG_0382penser à industrialiser les relais….le choix c’est donc porté sur deux cartes 16 relais pour microcontrôleur. Achat bien pratique sur Ebay, par contre le gros défaut est quelles fonctionnent en logique inversée. Il faut penser dès l’initialisation de l’arduino à placer toutes les sorties pilotant les cartes en HIGH, ce qui place les relais en OFF (un peu bête quand même)
Maintenant que la gestion de fond est faite, il est temps de penser à l’IHM…..est surtout d’éviter de poluer le salon (où se trouve la chaudière/poêle à granulés) avec des fils, des cartes, des alims et autre relais et LEDs. Un panneau de commande décorrélé de la partie « électronique » est la meilleure solution. Toujours dans un soucis de simplicité d’esthétique et d’utilisation, j’ai préféré me tourner vers un simple moniteur 10 pouces 16/9eme équipé d’un touchscreen resistif. Bon ok pour le touchscreen, le concept n’est pas trop compliqué, 4 fils à alimenter d’une certaine manière pour obtenir la valeur en X et d’une autre manière pour obtenir la valeur en Y en fonction de l’endroit où se situe la pression sur la dalle. Les convertisseurs analogique->numérique (ADC) des arduino’s savent très bien lire une valeur de tension en entrée (pont de résistance -> diviseur de tension généré par le touchscreen). Le problème est comment envoyer un signal sur le moniteur (qui accepte du composite, VGA ou HDMI). Là, oh miracle, d’autres ont déjà résolus le problème !!!! Il s’agit de la carte vidéo la plus basique du monde :  la Tellymate de chez Batsocks. Le concept est d’une simplicité déconcertante: on envoie sur un port série les textes à afficher (ainsi que leur emplacement sur une grille 38×25 caractères) et en sortie un signal vidéo composite est généré. Ce n’est pas très sexy, plutôt TTY, mais efficace (je pense néanmoins à faire évoluer la chose en utilisant un raspberry Pi en guise de carte video HDMI. l’article qui m’a mis la puce à l’oreille ).

Assez de blabla… un peu de photos

IMG_0377

- un arduino mega (bcp de ram de flash et surtout suffisamment d’entrées/sorties pour gérer les 32 relais)
– une horloge temps réel sur bus I2C de chez snootlab à  très faible dérive (10sec à 1minute max de décalage par an). Ce n’est pas le point fort des arduino, il faut donc en passer par là.

- un petit afficheur LCD 4×20 sur bus I2C, comme répéteur des infos vitales (puisque nous ne sommes pas dans la même pièce que le panneau de commande…).
– une carte vidéo tellymate
– 2 carte 16 relais
– 2 capteurs de température DS18B20

IMG_0380

le répéteur LCD

IMG_0381

un petit zoom, à droite l’horloge temps réel

Comme le programme est conséquent (un peu plus de 2700 lignes), il pèse 38ko compilé.
le code source sur mon espace GitHub: https://github.com/Chnalex/arduino/blob/master/domotique.ino

une petite vidéo de démo de l’IHM:

useless machine – le grand n’importe quoi …

 

tout a commencé le jour où j’ai reçu un lien vers cette video : https://www.youtube.com/watch?v=Z86V_ICUCD4&html5=1&noredirect=1

je l’avoue, j’ai voulu faire la mienne…. c’était l’occasion rêvée pour commencer une première réalisation à base d’arduino

Photo 023 (Medium)La machine inutile par excellence…
– 1 arduino nano (pour le coté compacte)
-1 inter
-1 servomoteur avec un bras permettant d’action l’inter
– un afficheur LCD (encore plus inutile), histoire de tester la librairie LiquidCrytal
– un boitier fait maison en contreplaqué teinté façon 70’s

Photo 027 (Medium)

l’intérieur de la bête un peu fouillis…

 

 

 

Photo 026 (Medium)

 

 

Le bras prêt à surgir….

 

 

 

Photo 028 (Medium)

 

 

 

Le servomoteur

 

 

 

une petite vidéo de démo qui parle d’elle même pour ceux qui n’auraient pas encore saisi le concept.

 

le code source (d’une grande complexité ;-) ) qui fait un petit 9ko compilé
a retrouver sur mon espace sur GitHub: https://github.com/Chnalex/arduino/blob/master/useless-machine.ino