Supervision de la serre (Web et Android)

Mon père a construit une serre il y a peu, et je me suis dit que ce serait intéressant d’analyser quelques données et pourquoi pas ensuite les exploiter ensuite afin de gérer l’ouverture automatique de celle-ci.

C’était aussi l’occasion de trouver une utilisation à mon Akeru (Arduino made in SnootLab qui utilise le réseau Sigfox) qui dormait depuis un moment.

Superviser ? Oui, mais quoi ?

Dans une serre, il y a deux choses importantes, la température et l’humidité. J’ai fouillé dans mon bazar et j’ai trouvé tout un tas de capteurs. Voilà ce que j’ai retenu :

  • Une sonde DS1820 étanche pour mesurer la température extérieure.
  • Une sonde DHT22 pour mesurer la température intérieure et l’humidité.
  • Un capteur RGB / Proximité / Lumière qui servira pour savoir s’il fait jour ou non et aussi pour déclencher l’affichage des valeurs en passant la main devant.
  • Une matrice de LED gérée par un MAX7219.
  • Et donc un Akeru (Arduino équipé d’un modem Sigfox).

La mise en place

Le câblage et l’utilisation de ce matériel est suffisamment simple, j’ai donc fait des programmes individuels afin de tester chaque capteur puis j’ai tout mis dans un sketch afin de récupérer toutes les données…. et ce fut un échec, pas assez de mémoire disponible sur l’atmega.

J’ai donc fait quelques tests et cherché comment réduire la taille de mon sketch. En premiers lieux j’ai mis toutes les chaînes constantes qui sont dans me « Serial.print » en progmem grâce à la fonction F mais ce n’était pas suffisant.

Je me suis alors penché sur les librairies. Par exemple pour la DHT22 j’utilisais la librairie de chez Adafruits qui est très bien mais qui occupe beaucoup de mémoire. 

Après avoir testé toutes les librairies pour les DHT j’ai choisi la TroykaDHT qui prend deux fois moins de place. J’ai fait de même pour la librairie du capteur RGB/Lumière (la Sparkfun est bien plus gourmande que celle d’Adafruit) et pour la gestion de la matrice de LED (je voulais utiliser la MD_Parola qui s’ajoute à la librairie MAX72XX pour proposer des fonctions de scrolling et d’autres dont je n’avais pas besoin j’ai donc codé le scrolling directement dans mon sketch).

Ces changements m’ont permis de diviser par 2 la taille de mon programme, il n’occupe donc que 60% de la mémoire ce qui me permettra d’ajouter des fonctionnalités plus tard comme un capteur de pluie, l’ouverture via un moteur …

Lecture des données

Le modem envoie des données sur le réseau Sigfox (un réseau bas débit disponible partout en France et dans beaucoup d’autres pays) qui les renvoie via un « callback » sur un serveur maison où je les stocke dans une base de données. J’ai ensuite fait une petite interface en utilisant chartJS afin de les visualiser.

Et sur ANDROID ?

Eh bien j’ai fait très simple; en utilisant l’objet « WebView » du SDK Android on peut encapsuler un site web dans une application.

package eu.rouanetnet.serreleminade;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.webkit.WebSettings;
import android.webkit.WebView;


public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

WebView myWebView = (WebView) findViewById(R.id.web1);
WebSettings webSettings = myWebView.getSettings();
webSettings.setJavaScriptEnabled(true);
myWebView.loadUrl("https://rouanetnet.eu/tempMazamet/");
}
}

Attention à ne pas oublier d’ajouter cette ligne dans le manifest sans quoi votre application n’accèdera pas a internet et vous ne verrez rien dans votre appli.

<uses-permission android:name="android.permission.INTERNET"></uses-permission>

Vous trouverez bientôt le code sur mon github.

L’IOT au service de l’IT

En cette période estivale caniculaire, un onduleur n’a pas supporté l’arrêt inopiné de la climatisation et a rendu l’âme, merci au fabricant de ne pas avoir inclus de sécurité liée à la température… Du coup nous avons commencé à regarder les solutions afin d’être prévenu en cas de surchauffe et j’en ai profité pour faire un petit POC avec du matériel de récupération que j’avais à la maison.

Matériel nécessaire

  • Un Akeru pour envoyer les informations via le réseau SIGFOX
  • Une sonde DS18B20
  • Une résistance 4.7K pour la sonde
  • Un module de charge de batteries Lipo
  • Une batterie Lipo
  • Un petit écran Oled pour afficher la température

On câble tout ça et voila le résultat (sans scotch ni colle !)

Sur le backend Sigfox j’ai juste ajouté un callback qui envoie un email à chaque réception d’information, soit toutes les 12 minutes. Cela évite de dépasser la limite de message journalière et il nous en reste pour envoyer des alertes en cas dépassement du seuil de température d’alerte que nous avons fixé.

Les tests étant concluants je pense explorer cette piste (en Sigfox ou LoraWan) afin de surveiller quelques paramètre dans nos salles critiques.

Le Blagotron

Mais qu’est ce donc ? Tout simplement un distributeur de blagues.

L’idée est venue à cause de grâce à Lionel B, voisin de bureau qui nous raconte tous les jours pas mal de blagues. Il fallait donc trouver un « remplaçant » pendant ses congés.

Comment ça marche ?

L’idée d’origine était d’avoir un simple bouton qui lorsque l’on appuie dessus imprime un blague. Donc c’est assez simple mais pour rajouter un coté vintage je me suis senti obligé de ressortir encore une fois le Minitel.

Mise en oeuvre

Il faut :
1 – Arduino UNO.
1 – Raspi / Ordi
1 – Minitel
1 – Imprimante a ticket

Blagotron

L’Arduino est relié au Minitel via son port DIN et sert d’interface série entre celui-ci et le Raspi mais aussi à afficher l’interface sur l’écran du minitel. J’utilise la librairie de Jerome Saint-Clair aka 01010101 qui est issue du travail du Tetalab (Fabrice, Renaud, PG, Phil et Liodel). Il faut sur le Minitel désactiver l’echo « Fnct + T E ».
Un script python écoute sur le port série les informations envoyées depuis le Minitel via l’Arduino et sélectionne ensuite la blague à imprimer puis l’envoie à l’imprimante.
Pour la partie impression j’utilise une imprimante chinoise pas chère qui peut être utilisée directement en python avec la librairie python-escpos.

Utilisation

L’utilisation est simple, on choisit un thème de blague avec le clavier du minitel et ensuite elle est imprimée.

Petite vidéo de démonstration :

Le code sera très prochainement disponible ici.

Un peu de délire

En 1992, un jeu d’un nouveau genre est apparu sur nos écrans. Un jeu que l’on pourrait qualifier de jeu « Online visiophonique » !
Le principe de l’émission était simple, un jeu vidéo pour attirer les geeks en herbe et une présentatrice sympathique (la très sexy Karen Cheryl) pour faire grimper un peu plus l’audience.
Dans sa première version, le principe du jeu est plutôt basique, il s’agit de diriger le personnage via les touches 4 et 6 de son téléphone. Nous allons donc voir comment recréer facilement ce système de contrôle. Cette émission se nommait « Hugo Délire ».

Karen

Comment ça marche ?

Grace au DTMF (non ce n’est pas la dernière insulte à la mode mais plutôt l’abréviation de dual-tone multi-frequency ou fréquences vocales pour les français), on peut savoir sur quelle touche la personne appuie en fonction de la fréquence sonore et diriger ainsi le personnage en fonction.

DTMF

Mise en oeuvre

Il faut :
1 – Arduino UNO.
1 – Décodeur DTMF MT8870 .
1 – Ligne téléphonique avec un téléphone.
1 – Un PC avec le jeux Hugo et l’émulateur qui va bien (le jeux original tournait sur Amiga mais par souci de facilité j’ai utilisé la version PS1).
On connecte donc l’écouteur du téléphone au décodeur DTMF qui lui même est connecté à l’Arduino qui est lui même connecté au PC.

Montage

On relie donc :

– L’écouteur du téléphone au module DTMF via une prise jack (n’ayant pas de ligne fixe j’ai utilisé un portable, l’Iphone de droite).
– Le module DTMF a l’Arduino (STQ -> 5, les pins 1,2,3,4 vers leur homologues sur .l’arduino)
– l’Arduino en USB au PC

Setup

Voici le lien vers le code Arduino qui utilise UnoJoy pour que l’arduino soit reconnu comme un Joystick afin de l’utiliser dans l’émulateur.
Il ne reste plus qu’a lancer le jeu, appeler la ligne téléphonique en question et jouer 🙂

Restauration d’un flipper : Part 1

Depuis deux ans j’ai récupéré un flipper Staal Gunmen, une machine made in France de 1979. Comme beaucoup de choses que je récupère il ne fonctionne pas et est en mauvais (très mauvais) état.

Au boulot !

Commençons par le fronton (partie supérieure du flipper qui affiche le score). Chose étrange, le bois utilisé pour le flipper est du contreplaqué couvert d’une épaisseur (5 mm) d’aggloméré sur lequel il y a la peinture. Comme il n’a pas été entreposé dans un endroit sain, l’agglo s’est dégradé et ne semble pas récupérable.

fronton

On emploie alors les grands moyens et on fait sauter la couche d’agglo et on la remplace par du contre plaqué de 5 mm. Après de longues heures de travail, pas mal de colle, de pâte à bois et quelques coups de rouleaux de peinture le résultat est plutôt satisfaisant.

fronton_new

Il reste à faire les décors mais ce sera pour plus tard.

Un peu d’arduino

Je souhaite réutiliser au maximum les éléments d’origine, mais malheureusement sur ces flippers les cartes mères ont tendance à lâcher à causse des CPU de mauvaise qualité… Donc pas le choix, il faut tout refaire avec les moyens du bord. Sur le fronton les afficheurs 7 segments utilisent des circuits assez standard j’ai donc pu les faire tourner sans problème avec un arduino. Bien sur tout le code sera disponible sur mon github.

afficheur.jpg

Aux pieds !

Comme je le disais plus haut les flippers et l’humidité ne font pas bon ménage, les pieds sont assez fatigués …Les voici après un petit coup (quelques heures) de grattage intensif.

Il ne reste qu’a les lustrer pour que ça brille …

 

 

 

Développer sur Méga Drive : Part 2

Comme précisé dans le dernier articles nous allons parlé ici de Debug et de JoyPad.

Debug

C’est un peu la base quand on développe de pouvoir debugger son programme afin de savoir ce qu’il se passe et pouvoir résoudre d’éventuels problèmes. Le SDK fournis tout le nécessaire pour débugger en alliance avec Gens KMod (menu CPU->Debug). Il y a différents items dans le menue permetant de voir pas mal de choses (registres des cpu, video, son, …). Nous allons utiliser la méthode la plus simple, les messages; elle permet simplement d’envoyer des messages dans une console un peu comme si vous utilisiez des « printf ». Pour cela c’est très simple il suffit d’utiliser la fonction KDebug_Alert qui prend en paramètre un string et le tour est joué (ne pas oublier le #include <kdebug.h> pour inclure les entêtes de debug).

 

#include <genesis.h>
 #include <kdebug.h>
 
 int main()
 {
 
        VDP_drawText("GENESIS HELLO !", 1, 1);
        KDebug_Alert("debug genesis hello");
 
        while(1)
        {
                VDP_waitVSync();
        }
        return (0);
 }

 

Une fois la rom chargée, en allant dans CPU->Debug->Messages nous voyons notre magnifique message de debug apparaître, facile mais très utile.

debug_1

 

JoyPad

Passons maintenant aux contrôles. Le JoyPad de base avait 3 boutons (A B C), un bouton start et une croix directionnelle puis il y a eu ensuite une version avec 6 boutons et d’autres type de contrôleurs (souris, clavier, pistolet…) qui sont aussi géré par le SDK. La capture des événements se fait pas un callback que l’on défini dans le main avec la fonction JOY_setEventHandler(nom_de_la_fonction_de_callback).  Cette fonction prend trois paramètres (u16 joy, u16 changed, u16 state) :

  • joy étant le joypad utilisé (JOY_1, JOY_2, …)
  • changed définie si un bouton a été pressé
  • state définie si un bouton à été relâché

 

Petit code pour mieux comprendre ….

 

#include <genesis.h>
 #include <kdebug.h>
 
 
 void handleJoyEvent(u16 joy, u16 changed, u16 state)
 {
    KDebug_Alert("joy callback");
    if (joy == JOY_1)
    {
        if (state & BUTTON_UP)
        {
            KDebug_Alert("up press");
        }
        else if (changed & BUTTON_UP)
        {
            KDebug_Alert("up rel");
        }
    }
 }
 
 
 int main()
 {
 
 
        JOY_setEventHandler(handleJoyEvent);
 
 
        VDP_drawText("GENESIS HELLO !", 1, 1);
        KDebug_Alert("debug genesis hello");
 
        while(1)
        {
                VDP_waitVSync();
        }
        return (0);
 }

 

Le résultat

 

debug_2

Fin de cette deuxième partie…. Dans la suite nous parlerons de l’affichage.

 

Scan to pancakes

Le chandeleur est passée mais il est toujours temps de manger quelques crêpes. Pour ce dernier « bricolage » j’ai essayé de faire avec un maximum de récupération et un minimum d’investissement.

Quoi que c’est ?

Tout simplement une imprimante à pancakes. Le principe est simple, on se déplace sur 2 axes et on dépose de la pâte sur une plaque de cuisson.

 

Liste du matériel nécessaire

Que j’ai acheté :

  • Une plancha basique 20€
  • Une pompe avec tube 20€
  • Deux bouteilles à sauce 4€
  • Un shield CNC 15€

Que j’avais déjà :

  • Un relais
  • Une alimentation 12V
  • Deux vieux scanner
  • Des tasseaux de bois
  • Un Arduino
  • De la quincaillerie

Commençons le montage

Les vieux scanners sont parfaits pour ce genre de bricole car ils embarquent des moteurs pas à pas et sont montés avec des axes rectifiés. Les plus récent sont tout en plastique et donc ne peuvent pas faire l’affaire. Pour l’axe Y, j’ai ouvert le premier scanner et je l’ai posé tel quel. J’ai fixé un joli cadre fait avec les tasseaux de bois sur le support de la lampe du scanner. Puis j’ai fixé en haut de celui-ci l’autre bas de scanner découpé sur le sens de la longueur. A ce niveau là, les deux axes sont en place, il ne reste plus qu’à placer le système de dépôt de pâte.

  

J’ai pensé à plusieurs solutions :

La seringue : solution très précise mais qui nécessite un montage plus compliqué et sa faible contenance rendra plus complexe l’utilisation de la machine et le remplissage.

Une pompe : elle servirait à pomper le liquide avec un tuyaux et le faire sortir dans un autre tuyaux à l’axe opposé. Cela paraît une bonne idée mais les quelques tests effectués ont démontré que de la pâte coule toujours un peu même quand on ne pompe pas.

La pompe à vide : l’idée est d’avoir un contenant dans lequel on met la pâte et l’on empêche la pâte de tomber en aspirant. Quand la pâte doit tomber, on relâche la pression et la gravité fait son travail.

La dernière solution est donc la plus efficace, même si je n’utilise pas vraiment une pompe à vide cela fonctionne bien. Il reste cependant deux défauts, en aspirant la pâte se sèche dans la buse il faut parfois la déboucher et surtout il faut être un grand maître dans l’art du pancacke (merci Philippe) pour réussir une pâte assez fluide mais pas trop:)

impression réalisée par le Tiers-Lieu Fontgrande-Carmaux pour le fablab festival 2017

Et pour le soft ?

Notre montage étant terminé il a fallu penser au coté logiciel. Si l’on regarde de plus près, la machine ressemble beaucoup à une découpe laser ou à un plotter. J’ai donc regardé ce qu’il se fait de ce coté et je me suis orienté vers le firmware GRBL avec un plugin GCODE pour Insckape.

Et voila… je m’étais fixé pour objectif de finir ce projet pour le Festival d’Art Numérique organisé par les étudiants de l’IUT MMI de castres et je l’ai finie à temps. Il ne me reste plus qu’a trouver un nouveau projet pour la prochaine édition à laquelle je compte bien participer 😉

 

la machine au fablab festival 2017

la machine au fablab festival 2017

On en parle ici : http://www.ladepeche.fr/article/2017/05/14/2574356-une-imprimante-3d-pour-fabriquer-des-gateaux.html

 

UNOJOY, l’ami des Arduino et des arcades ?

J’avais depuis quelques temps une borne Sega Rally qui trainait dans un coin (oui le gros truc avec les sièges et volant). Après de multiples tentatives de réparation j’ai opté pour une solution simple mais efficace, vider le tout et mettre un PC avec des émulateurs et des jeux.

sega-rally-twin-sit-down-racing-arcade-machine

Avantages :

  • Alléger le tout
  • Pouvoir jouer à plein de jeux

Inconvénients :

  • Perte du retour de force
  • Beaucoup de travail
  • Se faire huer par les puristes

J’ai donc commencé par tout désosser, remplacé les écrans par des écrans LCD, refait les parties bois, tout repeint … Vient alors le moment de remonter la borne et de tout câbler. Pendant toutes ces étapes une question restait alors sans réponse… que faire pour le volant. J’ai pensé utiliser un volant du marché mais souhaitant conserver au maximum le design de la borne cela n’allait pas, et un jour je suis tombé sur UNOJOY.

UNOJOY permet de transformer son Arduino en Joystick en utilisant les entrées analogiques et numériques, ceci est tout simplement génial.

UNOJOY fonctionne sur Arduino Uno, Mega et Leonardo; en gros ça reprogramme l’atmega 8U2 ou 16U2 (suivant la carte utilisée) pour faire reconnaître l’Arduino comme un joystick par le PC (mais apparement aussi la ps3).

windows

Avant cette étape il faut bien sûr câbler le tout et vérifier que ça fonctionne, pour cela un petit outil Processing permet de voir en live si les contrôles fonctionnent bien.

processing

En cas de contrôles un peu plus complexe (comme la boîte de vitesse sur ma borne) il est possible d’adapter le code (UnoJoyArduinoSample.ino) afin de gérer ces contrôles.

vitesses

Voici le petit hack pour utiliser mon levier à 4 vitesses avec trois Switchs qui sont connectés sur les pins numérique 2, 3 et 4 :

controllerData.triangleOn = LOW;

controllerData.circleOn = LOW;

controllerData.squareOn = LOW;

controllerData.crossOn = LOW;

  

//  operator to invert the readings from the pins

if (!digitalRead(2)&& digitalRead(3))

  controllerData.triangleOn=HIGH;

else if (!digitalRead(3) && !digitalRead(4))

  controllerData.circleOn=HIGH;

else if (!digitalRead(3))

  controllerData.squareOn=HIGH;

else if (!digitalRead(4))

   controllerData.crossOn=HIGH;  

On envoie ensuite le code sur l’Arduino, puis on lance le petit bat qui le transforme en périphérique de jeux et le tour est joué. Il est bien sûr possible de transformer à nouveau sa carte en Arduino avec un autre bat.

Je vous ferai découvrir très prochainement une réalisation utilisant UnoJoy, « stay tuned » comme on dit !

Le code de UnoJoy : https://github.com/AlanChatham/UnoJoy

Développez sur Galileo avec Eclipse

 

Il y a quelque temps je vous avais parlé de la carte Intel Galileo que nous avions utilisé pour s’amuser avec le coté « Arduino ». Ce coup-ci je vous propose de voir rapidement comment installer son environnement de développement C/C++ dédié.

  •  Installation de l’OS sur la carte SD

Pour pouvoir utiliser pleinement la carte Galileo, il faut installer sur une carte µSD un Linux plus complet que celui embarqué dans la carte. Il faut donc se procurer une carte d’au moins 2 Go et télécharger l’image du système ici : https://software.intel.com/en-us/iot/downloads

Pour déployer l’image :

  1. mettre la SD dans un pc linux ou Mac OSX
  2. décompresser le fichier : bunzip2 -c iot-devkit-latest-mmcblkp0.direct.bz2
  3. si elle se monte automatiquement, la démonter : umount /mnt/machinbidule
  4. copier l’image (remplacer diskX par le device correspondant à votre carte SD) :

dd of=iot-devkit-latest-mmcblkp0.direct of=/dev/diskX bs=8m

Et voila, la carte est prête a être installée dans la Galileo.

  • Installation du IOTDK IDE

Le IOTDK IDE est un Eclipse packagé avec tout ce qu’il faut pour utiliser à fond sa Galileo en C ou C++. L’installation est ultra simple, on télécharge https://software.intel.com/en-us/iot/downloads, on dézippe et on lance la commande : devkit.lancher … zou trop facile:)

  • Compilation et envoie d’un projet d’Eclipse à la carte Galileo.

Dans le panneau de gauche « Project Explorer » on ouvre le projet 4 (ccp onboard led blink), le code est déjà tout fait pour faire clignoter sa LED. On clique alors sur l’icône représentée par un marteau et ça compile le projet pour nous.

Ensuite pour l’envoyer sur la carte il faut paramétrer Eclipse, sur la droite de l’écran on clique sur « Remote System Eplorer »

image00

Puis sur la gauche, clic droit sur « Galileo » et « Properties », on entre alors les bonnes infos pour se connecter à la carte (ip, nom, …)

image02

Maintenant on envoie !!! On clique sur la flèche à droite de l’icône Run :

image01

Puis on sélectionne le projet en version Debug et ça envoie et exécute directement  le binaire sur la carte.

Amusez vous bien.

Unboxing et Opening du Tile

The Tile est un projet Kickstarter qui avait récolté quelques millions de dollars.

Le « Tile » est un petit objet (37x37x5mm) qui permet de retrouver un objet perdu dans sa maison ou “ailleurs dans le monde”. Prix 25$.

Unboxing

1

Une boite toute simple en carton et mousse, ça rend quand même pas mal.

2

On peut voir un trou permettant de le fixer à son trousseau de clefs mais il est aussi fourni avec un adhésif double-face  pour pouvoir le coller n’importe ou.

Comment que ça marche ???

Rien de sorcier; c’est un périphérique Bluetooth que l’on appaire avec son smartphone et qui via une application dédiée permet de faire sonner le “Tile” en cas de perte.

La promesse de pouvoir retrouvé son objet “partout dans le monde” réside sur le fait que en cas de perte votre “Tile” vous pourrez le retrouver si vous le déclarez perdu dans l’application et qu’une personne possédant l’application sur son smartphone passe assez près de l’objet pour en faire remonter un position très approximative sur une carte.

Et dedans, quoi qu’il y a ?

Ben oui je suis curieux et ça n’est pas nouveau, on sort un petit tournevis et hop, ouverture de la bête.

IMG_20150204_141321

Nous voyons ici un belle pile (annoncée avec une durée de vie de 1 an), un petit bouton (le gros rond doré à gauche) qui sert à appairer le “Tile” avec un périphérique Android ou iOS, tout plein de petits composants annexes et le plus important (celui caché sous l’étiquette avec une QRcode) le chipset Bluetooth.


IMG_20150204_141428

Au dos rien de spécial, juste les connecteurs qui dépassent pour faire contact avec le piezo qui fera de la musique quand vous perdez votre bidule.

Reparlons du chipset BT, c’est un nRF51822 de chez Nodric Semiconductor. C’est un chipset intéressant pour les raisons suivantes :

  • Supporte le BT 4.1
  • Consomme très peu (9.7mA en TX et 8 en RX)
  • L’est petit (6x6mm)
  • Embarque un proc ARM Cortex M0 avec 128K de falsh et 16K de ram
  • 2.2€ pièce

Soit un très bon rapport qualité, utilité, performance, prix.

Et voilà la fin de notre aventure au cœur du « Tile ».