Ruche numérique

La ruche numérique

Le projet

Notre ruche numérique a pour objectif de donner à l’apiculteur des informations issues de sa ruche.

Les mesures et fonctionnalités  prévues

  • mesure des températures interne et externe
  • mesure des taux d’humidité interne et externe
  • poids (permet de se faire une idée de la quantité de miel produite)
  • comptage des abeilles sur la plateforme d’envol. (donnera un niveau d’activité)
  • historisation des mesures
  • administration du système via navigateur web
  • collecte des informations

Restrictions

Les ruches sont le plus souvent hors de portée des réseaux informatiques filaires ou hertziens, nous prévoyons donc un système non connecté à internet mais qui via un « hotspot » wifi (point accès wifi)  permettra la connexion de l’apiculteur passant voir sa ruche.

Réalisation

Le matériel

  • raspberry pi 3
  • caméra raspberry
  • carte additionnelle pour la sauvegarde de la date et heure
  • bloc support de piles pour l’alimentation
  • boîtier
  • capteurs (température, humidité, poids)

Les logiciels

  • distribution raspbian lite
  • motion pour les images
  • Mariadb pour la base de données
  • RaspAP pour le hotspot
  • un logiciel à trouver pour les mesures, probablement en cherchant du côté des projets de station météo à base de raspberry pi

Les opérations

Actions réalisées

  • Installation et mise à jour de la raspbian lite
  • installation RaspAP
  • Tests et configuration RaspAP
  • Installation Mariadb
  • Configuration compte root
  • Installation Motion
  • Configuration et tests Motion
  • Identification de la bibliothèque python à utiliser pour le comptage : pillow

Actions à réaliser

  • connexion motion avec mariadb,
  • installation des capteurs de mesure,
  • Configuration et tests des mesures,
  • montage général : boîtier, caméra, bloc piles,
  • Programmation  du comptage,
  • Programmation du site web pi-ruche,
  • Étalonnage du comptage
  • etc.

Comptage

Une très belle et très complexe solution aurait été d’utiliser des logiciels de reconnaissance de forme pour déterminer le nombre de silhouettes d’abeilles sur une image.

Sans parler de la complexité à mettre çà en place il est certain que les temps de traitement seraient trop longs avec un raspberry.

Nous procéderons à un  comptage statistique. On adoptera une plateforme d’envol claire afin de faire contraste avec les abeilles. Ensuite la bibliothèque pillow va nous fournir pour chaque image analysée un histogramme des pixels clarté et nombre.

A partir de là un étalonnage sera nécessaire pour obtenir un tableau comme celui-ci :

  • 0% de points sombres  0 abeilles
  • 5% de points sombres  x abeilles
  • 10% de points sombres  y abeilles
  • etc jusqu’à 100%

L’étalonnage se fera par un comptage manuel sur images fixes jpeg.

On essaiera mathématiquement de filtrer les problèmes de luminosité variable. On essaiera aussi d’éviter les problèmes de plateforme partiellement au soleil.

Historisation des données

On utilisera le SGBD Mariadb pour historiser les données acquises.

La table pourrait avoir les champs suivants :

  • date et heure de mesure,
  • température intérieure,
  • température extérieure,
  • humidité intérieure,
  • humidité extérieure,
  • nombre d’abeilles,
  • nom de l’image stockée.

Voilà ! Yapuka !

Merci pour vos suggestions et participations.

Animation de Noël

Panneau

La Vilaine Bidouille cherche des volontaires pour monter une animation de Noël. Ce serait une adaptation du parcours électrique en mode « fourchette à fondue géante ». Au lieu d’avoir un anneau qui passe autour d’un fil de fer tordu, la fourchette doit passer dans une fente usinée dans un grand panneau sans toucher les bords. Pour la déco, le départ serait une casserole de fondue et l’arrivée la bouche d’un savoyard.
La Vilaine Bidouille cherche donc des gens avec un bon coup de pinceau, un goût prononcé pour la menuiserie, l’électronique ou la programmation. Lever Le Rideau nous met à disposition une cabane type « marché de Noël ». Y-a-plus qu’à !
Quelques croquis de l’idée de base pour exciter votre imagination.

Panneau
Visuel du panneau
Parcours
Autre parcours possible
Photo
Inscription par photo
Système
Schéma de principe du système

CAISSE A SAVON

Samedi 9 juin 2018, la Vilaine Bidouille met de côté les outils numériques pour fabriquer une caisse à savon avec des restes d’ateliers.

atelier extérieur
Atelier extérieur
Prémontage
Prémontage

Securisation du périmètre
Securisation du périmètre
Premiers essais
Premiers essais

Retour sur le bizarbre

Bizarbre

arbreNous avions présenté rapidement notre Bizarbre dans un précédent article. 

Etant données les questions techniques qui nous ont été posées, voici le détail complet du tuto.

Matériel :

      un PC équipé de :

o    Processing

o    Arduino

      Une carte Arduino

      Une carte MPR121 de chez Adafruit

      Fils de cuivre rigides

      Des pommes

      Un câble USB

      De la connectique entre Arduino et MPR121

Logiciels et bibliothèques :

      Processing

      Arduino

Fichiers :

      Fichiers MP3 avec les histoires enregistrées

 

Etape 1 : Construire un arbre

Equipez vous d’une bibliothécaire munie d’une scie, de pots de peinture et de contre-plaqué épais. Laissez faire le temps. Et vous obtenez un belle arbre en bois.

Etape 2 : Suspendre les pommes

Il faudra une pomme par histoire et une supplémentaire pour faire la touche “stop”. Nous avons utilisé du petit fil de cuivre. La partie dénudée traverse la pomme pour assurer un bon contact avec le fruit. Nous avons utilisé des aiguilles à poisson pour percer les pommes.

Etape 3 : Préparer de la carte Arduino

La carte utilisée est une Duemillanove.

Au lancement de l’interface de programmation Arduino, il faut ajouter les bibliothèques suivante pour pouvoir communiquer avec les capteurs capacitifs MPR121

Etape 4 : Connecter l’Arduino à la MPR121

Câblage assez simple.

Connecter Vin à l’alimentation. Sur un Arduino, ça revient à alimenter en 5V.
Connecter GND à la masse commune à la puissance et aux données.

Connecter SCL à la fiche I2C clock SCL sur l’Arduino. Sur une UNO, c’est A5 ; sur une Mega, digital 21 ; sur Leonardo/Micro, digital 3.

Connecter SDA sur la fiche I2C data SDA sur l’Arduino. Sur une UNO, c’est A4 ; sur une Mega, digital 20 ; sur Leonardo/Micro, digital 2.

Etape 5 : Programmer la carte Arduino

Ouvrir l’interface Arduino (IDE) sur le PC et brancher la carte Arduino avec le câble USB.

Bien repérer le numéro de port de la carte. Pour ça, il y pleins de tutos sur internet. Inutile de surcharger celui-ci.

Télécharger la librairie master.zip pour que la carte Arduino puisse communiquer avec le capteur MPR121. Renommer le dossier décompressé en Adafruit_MPR121 et vérifier qu’il contient bien le fichier Adafruit_MPR121.cpp et Adafruit_MPR121.h.

Placer ce dossier Adafruit_MPR121 dans le dossier des librairies du logiciel Arduino arduinosketchfolder/libraries/. Si c’est votre première librairie, il faudra sans doute créer ce dossier. Arrêter et redémarrer l’IDE Arduino.

Si jamais vous avez un doute allez chercher l’info à la source chez Adafruit.

Tapez le programme suivant :

 

/*********************************************************
Arbre  histoire pour la mediathque d’Allaire (cote arduino)
Auteur : Cyrille Laulier
        www.lebiosphere.net
Date   : le 26/02/2016

Ce programme Arduino va de paire avec le programme Processing
arbreAHistoires
Grace  une carte MPR121 de chez Adafruit, la carte Arduino
detecte le contact de la main d’un enfant sur un fruit.
Elle envoie ensuite le numero du fruit au PC via le port serie
Sur le PC, Processing regarde le numero et lance la lecture
de l’histoire correspondante
**********************************************************/
#include <Wire.h>
#include « Adafruit_MPR121.h »
// declaration de l’objet « cap » qui est le capteur MPR121
Adafruit_MPR121 cap = Adafruit_MPR121();

// Garder la trace du dernier contact touche
// pour savoir quand un bouton est « relache »
uint16_t lasttouched = 0;
uint16_t currtouched = 0;

void setup() {
 Serial.begin(9600);
 // adresse par defaut 0x5A, si alimentation 3.3V alors 0x5B
 // si cablage SDA alors 0x5C et si SCL alors 0x5D
 if (!cap.begin(0x5A)) {
   Serial.println(« MPR121 introuvable, verifier le cablage »);
   while (1);
 }
 Serial.write(0);
}

void loop() {
 // recuperation des touches appuyees
 currtouched = cap.touched();
 // controle de tous les contacts et envoi sur port serie
 for (uint8_t i=0; i<12; i++) {
   // it if *is* touched and *wasnt* touched before, alert!
   if ((currtouched & _BV(i)) && !(lasttouched & _BV(i)) ) {
     Serial.write(i);
   }
 }
 // pour tour suivant
 lasttouched = currtouched;
 delay(100);
}

 

 

Envoyez ce programme dans la carte Arduino.

Etape 6 : Connecter la MPR121 aux pommes

Câblage encore plus simple. On a dix pommes pour les histoires et une pomme “stop” qui interrompt toutes les lectures.

Pour la pomme “stop”, on plante un fil électrique rigide dans la pomme qu’on connecte à l’entrée 0 de la MPR121.

Pour les autres pommes, on fait pareil sur les entrée de 1 à 10. Dans notre cas, nous n’avions enregistré que 8 histoires. Alors nous n’avons câblé que 8 pommes en plus du “stop”.

Etape 7 : Préparer Processing

On oublie un peu l’électronique pour revenir sur le PC.

Installer et lancer Processing.

On importe la bibliothèque Minim pour pouvoir manipuler du son. Pour cela, dans l’interface Processing, il suffit d’aller dans le menu Sketch > Import Library… > Minim audio. C’est fait.

Etape 8 : Programmer Processing

Dans la fenêtre Processing, on va taper le programme. Le programme est le suivant :

import processing.serial.*;
import ddf.minim.*;

Minim minim;
AudioPlayer hist01,hist02,hist03,hist04,hist05,hist06,hist07,hist08,hist09,hist10;
Serial port;
int val;

void setup() {
 fullScreen();
 String arduinoPort= »COM3″;
 port=new Serial(this, arduinoPort, 9600);
 
 minim = new Minim(this);
 hist01 = minim.loadFile(« chewinggum.mp3 »);
 hist02 = minim.loadFile(« bouteille.mp3 »);
 hist03 = minim.loadFile(« chocolat.mp3 »);
 hist04 = minim.loadFile(« Saucisse.mp3 »);
 hist05 = minim.loadFile(« Minuscule.mp3 »);
 hist06 = minim.loadFile(« envers.mp3 »);
 hist07 = minim.loadFile(« envers.mp3 »);
 hist08 = minim.loadFile(« envers.mp3 »);
 hist09 = minim.loadFile(« histoire09.mp3 »);
 hist10 = minim.loadFile(« histoire10.mp3 »);
 //song.play();
}

void draw() {
 if (port.available() > 0) {
   val=port.read();
 }
 background(map(val,0,10,0,255));
 rect(40,(val+1)*50-10,360,20);
 if (val==1) {
   hist01.rewind();
   hist01.play();
 }
 if (val==2) {
   hist02.rewind();
   hist02.play();
 }
 if (val==3) {
   hist03.rewind();
   hist03.play();
 }
 if (val==4) {
   hist04.rewind();
   hist04.play();
 }
 if (val==5) {
   hist05.rewind();
   hist05.play();
 }
 if (val==6) {
   hist06.rewind();
   hist06.play();
 }
 if (val==7) {
   hist07.rewind();
   hist07.play();
 }
 if (val==8) {
   hist08.rewind();
   hist08.play();
 }
 if (val==9) {
   hist09.rewind();
   hist09.play();
 }
 if (val==10) {
   hist10.rewind();
   hist10.play();
 }
 if (val==0) {
   hist01.pause();
   hist02.pause();
   hist03.pause();
   hist04.pause();
   hist05.pause();
   hist06.pause();
   hist07.pause();
   hist08.pause();
   hist09.pause();
   hist10.pause();
 }
 val=99;
}

 

Enregistrer ce programme sous le nom de arbreHistoires_processing.pde.

On peut l’optimiser. Si j’avais eu 200 histoires avec 201 pommes, j’aurais utilisé la programmation orientée objet.

On voit que le programme appelle des fichiers joints. Vous pouvez enregistrer vos propres histoires ou les récupérer sur mon site Google. Il faut les coller dans le même dossier que le fichier du programme arbreHistoires_processing.pde.

Etape 9 : Connecter le PC

Le plus facile de tous les câblages. Il faut s’assurer que l’IDE d’Arduino ne tourne pas sur le PC. Il faut brancher la carte Arduino au PC via le câble USB. Et lancer le programme arbreHistoires_processing.pde en appuyant sur la flèche “Play” de Processing. Pensez à monter le son.

Etape 10 : Faire un lâcher d’enfants

Tout est dans le titre. Les enfants vont toucher une pomme. Au simple contact, le PC va commencer la lecture de l’histoire associée. Il suffit d’appuyer sur la pomme “STOP” pour faire silence.

Etape 11 : Penser à la suite

Comme chaque bidouille, elle laisse un sentiment d’imperfection une fois réalisée. Une frustration. En fait, c’est nul. Ce n’est pas comme ça qu’on aurait dû avoir une approche complètement différente. On voit les fils qui dépassent de partout, les enfants mangent les pommes, ça monopolise un PC et des enceintes, l’erreur de câblage est facile à faire, il n’y a pas d’image…

Aussi, je fais un appel à contribution. Qui est motivé pour :

      Trouver le moyen de connecter un haut-parleur directement à l’Arduino ?

      Forger des pommes en or (ou accessoirement en bronze) ?

      Trouver un moyen de cacher les câbles, voire les cartes électroniques, dans l’épaisseur du bois de l’arbre ?

      Rendre la carte Arduino capable de gérer les sons et les images sans PC ?

      Connecter l’Arduino à un vidéo projecteur ?

      Concevoir un shield pour brancher toutes les petites cartes électroniques à l’Arduino sans fils ?

      Raconter de nouvelles histoires d’arbres ?

Pour toute question, truc qui ne marche pas, bug, difficultés et autre, n’hésitez pas à vous retrousser les manches et à suer sang et eau pour obtenir un résultat satisfaisant. Ou bien passez nous voir à la Vilaine Bidouille.

Cyrille Laulier, www.lebiosphere.net

 

Ma douche sauvée par la Bidouille d’Allaire

J’ai acheté une paroi de douche et une porte coulissante en verre sur le bon coin.
Je pensais avoir fait une bonne affaire, mais pas tant que ça :
ayant posé le placo, fait la plomberie, monté la paroi de douche, posé le carrelage ; je pensais pouvoir bientôt terminer la douche !!!

Mais voilà, au moment du montage de la porte, nous réalisons qu’il manque deux supports en plastique qui tiennent et guident une roulette dans une gorge…..

Je me précipite alors sur internet pour retrouver cette pièce manquante, impossible à trouver !

J’avais cependant trouver les roulettes sur un site ukrainien mais il me manquait les deux supports !

L’histoire se termine bien grâce à l’atelier Bioduille d’Allaire du Vendredi soir à la Médiathèque qui parvient à modéliser et imprimer ces deux pièces maîtresses, une gauche et une droite, symétriques !
Comme quoi, c’est bien utile ces petites bidouilles !

 

Sandrine

Course d’escargots du 10 mars

Course

Ca avance doucement.

Course
presque prêts pour le départ

En attendant le départ les programmes qui vont enregistrer les images et les passer en boucle sont prêts.

import picamera
import time

with picamera.PiCamera() as camera :
    camera.start_preview()
    frame= 1
    while (frame<100):
        camera.capture('/home/pi/animation/frame%d.jpg' %frame)
        frame += 1
        camera.stop_preview()
        time.sleep(4.0)
escarMotion.py
import pygame
from pygame.locals import *
import time

pygame.init()

fenetre = pygame.display.set_mode((1440,900),RESIZABLE)

continuer = 1
nb = 1

while continuer:
    try:
        fond=pygame.image.load("/home/pi/animation/frame{}.jpg".format(nb)).convert()
    except:
        nb=1
        fond=pygame.image.load("/home/pi/animation/frame{}.jpg".format(nb)).convert()
    finally:
        fenetre.blit(fond,(0,0))
        pygame.display.flip()
        time.sleep(0.1)
        nb=nb+1
affichage

Prenez une Raspberry Pi 3 avec une caméra. Lancez le premier script puis le second pendant que le premier tourne encore.

Il ne manque que des volontaires pour faire le parcours.

Retour sur le Yéti

yeti
yeti
yeti ouest france

Voici avec un peu de retard le support pdf de l’animation à la médiathèque de Redon sur la carte Raspberry Pi embarquée dans le yéti de la station des 5000 de Redon

171125_Yeti

Vous y trouverez l’essentiel pour utiliser les entrées/sorties, un peu de Python et quelques astuces pour démarrer automatiquement des scripts au boot de la carte.

Si quelqu’un peut expliquer simplement comment ajouter un Watchdog au yéti, je suis preneur.

Passez de bonnes vacances.