Publié le

Détecteur de filament sur Octoprint

Ayant plusieurs projets en cours (dont un système de double extrusion pour la Micro delta Rework d’Emotiontech) le blog est un peu mit de coté pour le moment.

Je suis aussi en train de refaire mon bureau, du coup je me suis penché sur la Prusa i3 pour modifier quelques petites choses et je viens d’ajouter un détecteur de filament car j’en ai un peu marre de finir mes bobines sans m’en rendre compte et de devoir refaire un print.

De base il vous faut Octoprint (si vous ne l’avez pas => mon article sur Octoprint).

J’ai branché un switch en pull-up sur le gpio 17 (c’est du BCM sur la carte c’est donc le pin 11).

Je me suis fait un petit boitier passe fil pour mettre mon switch et ensuite je suis allé configurer Octoprint :

Voici mes configurations :

Etape 1 : Dans les paramètres, Serial Connection, dans Advanced Options j’ai coché la case « Log position on pause » c’est ce qui va me permettre de sauvegarder la position de la tête au moment de la mise en pause.

Etape 2 : Dans Gcode Scripts, deux choses à ajouter :

{% if pause_position.x is not none %}
; relative XYZE
G91
M83

; retract filament, move Z slightly upwards
G1 Z+5 E-5 F4500

; absolute XYZE
M82
G90

; move to a safe rest position, adjust as necessary
G1 X0 Y0
{% endif %}
{% if pause_position.x is not none %}
; relative extruder
M83

; prime nozzle
G1 E-5 F4500
G1 E5 F4500
G1 E5 F4500

; absolute E
M82

; absolute XYZ
G90

; reset E
G92 E{{ pause_position.e }}

; move back to pause position XYZ
G1 X{{ pause_position.x }} Y{{ pause_position.y }} Z{{ pause_position.z }} F4500

; reset to feed rate before pause if available
{% if pause_position.f is not none %}G1 F{{ pause_position.f }}{% endif %}
{% endif %}

Ca me permet de bouger ma tête d’impression et de la remettre à sa place sans aucune manipulation.

Etape 3 : Installer le plugin Filament Sensor (1.0.1) (pas le reloaded hein, celui là, l’autre j’ai pas testé). 

Etape 4 : Modifier config.yaml ajouter en debut de fichier s’il n’y a pas déjà de sous groupe plugin :

plugins:
  filament:
    bounce: 400
    pin: 17

et une fois le fichier sauvé, relancer OctoPrint avec

sudo service OctoPrint restart

Il ne reste plus qu’a lancer une impression sans filament dans l’extruder pour vérifier que tout fonctionne !

 

Publié le

MicroDelta Rework d’Emotiontech

Quelle surprise en ouvrant les cadeaux ce matin, le père Nöel m’a porté une MicroDelta Rework d’EmotionTech !

1. Le montage :

Alors je voulais faire des photos pendant le montage, mais je suis allé si vite (2h15) malgré le fait que je ne me sois pas pressé, que j’en ai pas fait.Le guide de montage est assez bien fait, du coup pas de modification particulière du manuel.

Ma seule remarque est sur le balisage des pièces, il est trop peu présent à mon goût (et tout le monde ne sais pas ce qu’est une thermistance :D).

2. OctoPrint :

2.1 Préliminaires :

N’aimant pas Repetier Host (qui sur mac il faut le dire n’est pas terrible), je suis parti naturellement vers Octoprint, qui a mon sens, est bien plus pratique (et qui équipe déjà ma Prusa i3 et ma Sculptr).

Donc on reprend un RapberryPi, on installe la dernière version d’OctoPrint et on le personnalise (franchement j’adore le modifier maintenant que je sais un peu comment faire, par la suite je vais essayer de mettre mes modifications sous forme d’AddOn pour que ça soit plus pratique).

Avant ça, j’ai préparé une petite boite pour mon RaspberryPi et je lui ai ajouté deux relais (un qui va « remplacer » le bouton On/Off de la MicroDelta, et l’autre qui va me servir à contrôler l’éclairage !).

Voici les fichiers STL de ma box :

STL Files
  • couvercle-pi-micro
Color:
Render:
Capture:
Download STL
STL Files
  • base-pi-micro
Color:
Render:
Capture:
Download STL

Et voici mon câblage :

L’alimentation de la MicroDelta est donc sur le pin physique 11 et l’éclairage sur le pin physique 12 (on verra dans un petit moment comment je configure tout ça, c’est pas forcément les valeurs de pins qu’on utilise par la suite).

2.2 Configuration d’OctoPrint :

Ici on a plusieurs choses à configurer. C’est déjà des modifications que j’ai fait pour la Prusa i3 et la Sculptr, mais je vais les reprendre ici :

  • Allumage automatique de l’éclairage (et coupe quand l’impression est finie),
  • Coupure de l’alimentation de la Micro Delta
  • Ajout des options de calibration dans Octoprint.

2.2.1 Allumage/Extinction automatique de l’éclairage :

Je gère l’éclairage avec un petit script en python exécuté toutes les minutes qui « regarde » dans quel état est mon imprimante. Dès que l’état passe à « Printing » l’éclairage s’allume, sinon il se coupe.

Avant de créer le script, il faut récupérer l’APIKey d’OctoPrint : pour cela on va dans Settings / API et hop, pour ma part l’APIKey est : AE10C82822B042AC97F0B32236365BB7.

Ainsi que d’installer deux petites choses :

Requests :

sudo apt-get python-requests

Rpi.GPIO :

./oprint/bin/pip install RPi.GPIO

Je crée donc un script state.py qui va récupérer les infos :

import sys
import requests
import os
import time
import glob
import RPi.GPIO as GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT)

for i in range(0,59) :
 r = requests.get("http://192.168.1.46/api/printer?apikey=AE10C82822B042AC97F0B32236365BB7")
 reponse = r.content.split()
 etat = reponse[14].strip(',')
 if etat == "true": GPIO.output(12, GPIO.LOW)
 else : GPIO.output(12, GPIO.HIGH)
 time.sleep(1)

Vous pouvez vous amuser à mettre dans votre navigateur http://192.168.1.46/api/printer?apikey=AE10C82822B042AC97F0B32236365BB7

dans mon cas j’obtient :

{
  "state": {
    "flags": {
      "closedOrError": false, 
      "error": false, 
      "operational": true, 
      "paused": false, 
      "printing": false, 
      "ready": true, 
      "sdReady": false
    }, 
    "text": "Operational"
  }, 
  "temperature": {
    "bed": {
      "actual": 17.5, 
      "offset": 0, 
      "target": 0.0
    }, 
    "tool0": {
      "actual": 18.2, 
      "offset": 0, 
      "target": 0.0
    }
  }
}

On voit que l’état de printing est à false, c’est cette valeur que je viens récupérer (avec mon split).

Je vous montre ici la suite des commandes dans le shell python (plus compréhensible :

>>> r=requests.get("http://192.168.1.46/api/printer?apikey=AE10C82822B042AC97F0B32236365BB7")
>>> reponse = r.content.split()
>>> reponse
['{', '"state":', '{', '"flags":', '{', '"closedOrError":', 'false,', '"error":', 'false,', '"operational":', 'true,', '"paused":', 'false,', '"printing":', 'false,', '"ready":', 'true,', '"sdReady":', 'false', '},', '"text":', '"Operational"', '},', '"temperature":', '{', '"bed":', '{', '"actual":', '17.6,', '"offset":', '0,', '"target":', '0.0', '},', '"tool0":', '{', '"actual":', '18.2,', '"offset":', '0,', '"target":', '0.0', '}', '}', '}']
>>>

Voilà à quoi ressemble le vecteur « réponse », je récupère sa 15ème valeur qui correspond donc à reponse[15] (et oui, la numérotation commence à zéro !).

Normalement, l’éclairage doit être opérationnel dès à présent !

2.2.2 Alimentation de la MicroDelta Rework :

Pour la mettre en place, on va ajouter un petit programme qui va nous permettre de contrôler nos GPIO (On en a pas eu besoin pour l’éclairage car python gère le GPIO dans ce cas).

On commence donc par installer WiringPi :

sudo apt-get update 
sudo apt-get upgrade
 
sudo apt-get install git-core
 
git clone git://git.drogon.net/wiringPi
 
cd wiringPi
./build

Une fois installé, on va tester voir si tout fonctionne :

gpio readall

et voici le genre de réponse qu’on doit obtenir :

 +-----+-----+---------+------+---+---Pi 3---+---+------+---------+-----+-----+
 | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
 +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
 |     |     |    3.3v |      |   |  1 || 2  |   |      | 5v      |     |     |
 |   2 |   8 |   SDA.1 |   IN | 1 |  3 || 4  |   |      | 5V      |     |     |
 |   3 |   9 |   SCL.1 |   IN | 1 |  5 || 6  |   |      | 0v      |     |     |
 |   4 |   7 | GPIO. 7 |   IN | 1 |  7 || 8  | 1 | ALT5 | TxD     | 15  | 14  |
 |     |     |      0v |      |   |  9 || 10 | 1 | ALT5 | RxD     | 16  | 15  |
 |  17 |   0 | GPIO. 0 |   IN | 1 | 11 || 12 | 1 | IN   | GPIO. 1 | 1   | 18  |
 |  27 |   2 | GPIO. 2 |   IN | 0 | 13 || 14 |   |      | 0v      |     |     |
 |  22 |   3 | GPIO. 3 |   IN | 0 | 15 || 16 | 0 | IN   | GPIO. 4 | 4   | 23  |
 |     |     |    3.3v |      |   | 17 || 18 | 0 | IN   | GPIO. 5 | 5   | 24  |
 |  10 |  12 |    MOSI |   IN | 0 | 19 || 20 |   |      | 0v      |     |     |
 |   9 |  13 |    MISO |   IN | 0 | 21 || 22 | 0 | IN   | GPIO. 6 | 6   | 25  |
 |  11 |  14 |    SCLK |   IN | 0 | 23 || 24 | 1 | IN   | CE0     | 10  | 8   |
 |     |     |      0v |      |   | 25 || 26 | 1 | IN   | CE1     | 11  | 7   |
 |   0 |  30 |   SDA.0 |   IN | 1 | 27 || 28 | 1 | IN   | SCL.0   | 31  | 1   |
 |   5 |  21 | GPIO.21 |   IN | 1 | 29 || 30 |   |      | 0v      |     |     |
 |   6 |  22 | GPIO.22 |   IN | 1 | 31 || 32 | 0 | IN   | GPIO.26 | 26  | 12  |
 |  13 |  23 | GPIO.23 |   IN | 0 | 33 || 34 |   |      | 0v      |     |     |
 |  19 |  24 | GPIO.24 |   IN | 0 | 35 || 36 | 0 | IN   | GPIO.27 | 27  | 16  |
 |  26 |  25 | GPIO.25 |   IN | 0 | 37 || 38 | 0 | IN   | GPIO.28 | 28  | 20  |
 |     |     |      0v |      |   | 39 || 40 | 0 | IN   | GPIO.29 | 29  | 21  |
 +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
 | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
 +-----+-----+---------+------+---+---Pi 3---+---+------+---------+-----+-----+

Je vous ai dit tout à l’heure que l’alimentation de notre imprimante serait sur le gpio physique 11 qui correspond dans le cas de WiringPi au 0 (on le lit dans la colonne wPi).

Du coup on va aller rajouter quelques lignes dans init.d pour qu’il passe en sortie (OUT) au lieu d’entrée (IN) ;

sudo nano /etc/rc.local

Et on ajoute ce que j’écris en violet :

#!/bin/sh -e
#
# rc.local
#
# This script is executed at the end of each multiuser runlevel.
# Make sure that the script will "exit 0" on success or any other
# value on error.
#
# In order to enable or disable this script just change the execution
# bits.
#
# By default this script does nothing.

# Print the IP address
_IP=$(hostname -I) || true
if [ "$_IP" ]; then
  printf "My IP address is %s\n" "$_IP"
fi

/usr/local/bin/gpio write 0 0
/usr/local/bin/gpio mode 0 out
exit 0

Au prochain démarrage du RaspberryPi, le Gpio 0 sera donc en sortie et aura la valeur zéro.

Maintenant on va aller ajouter quelques lignes dans le fichier .octoprint/config.yaml

system:
  actions:
  - action: printer on
    command: gpio write 0 1
    name: Printer On
  - action: printer off
    command: gpio write 0 0
    name: Printer Off

Et un petit menu va apparaitre quand on clique sur System : Printer On et Printer Off

 

2.2.3 Ajout de la calibration dans OctoPrint.

Voici un extrait de la calibration sur Mac dans la notice de la MicroDelta Rework :

OctoPrint a un terminal, donc je pourrais taper les commandes successivement depuis mon iPad, mais je suis bien trop flemmard pour ca !

Je vais donc ajouter un bouton pour chaque étape :

  • Origine qui envoie G28
  • Palpage 3 points pour G32
  • Palpage multi points pour G31
  • Sauvegarde du calibrage pour M374
  • Réglage hauteur max pour M306 Z0 et M500 (oui on oublie pas la sauvegarde hein !)

Du coup je vais ajouter dans .octoprint/config.yaml ceci :

controls:
- children:
  - commands:
    - G28
    name: Origine
  - commands:
    - G32
    name: Palpage 3 points
  - commands:
    - G31
    name: Palpage multi points
  - commands:
    - M374
    name: Sauvegarde du calibrage
  - commands:
    - M306 Z0
    - M500
    name: Reglage hauteur max
  layout: horizontal
  name: Calibration

 

Du coup dans l’onglet Control d’Octoprint j’obtient les commandes que j’ai ajouté sous forme de petits boutons :

 

3. Améliorations :

Je ne peux pas m’en empêcher, je suis obligé de modifier les imprimantes que je monte…

3.1 Ajout d’un éclairage :

Qui dit OctoPrint, dit caméra pour surveiller à distance, mais le soir je ne laisse pas le bureau allumé non plus !

Il me fallait donc une solution d’éclairage, facile à ajouter et fonctionnelle !

Elle sera en deux parties :

  • Un éclairage « en haut » de la Micro Delta Rework,
  • Un sur la tête d’impression.

Pour l’éclairage en haut, j’ai imprimé les deux pièces suivantes :

STL Files
  • base led
Color:
Render:
Capture:
Download STL
STL Files
  • Led delta
Color:
Render:
Capture:
Download STL

ma première pièce vient s’intercaler entre le haut de la plateforme et la base led pour permettre de faire passer les cables de l’extrudeur et de la tête, le socle led ressemble à ça une fois le bandeau led ajouté et soudé :

3.2 Le support bobine :

La bobine à plat, je sais qu’elle peut « sauter » de son emplacement, du coup je l’ai fait droit pour l’instant (je ferai d’autres modifications donc pour le moment j’utiliserai celui là :

STL Files
  • support bobine Micro delta
Color:
Render:
Capture:
Download STL

Avec son tube porte rouleau :

STL Files
  • tube delta
Color:
Render:
Capture:
Download STL

J’hésite encore à le placer au dessus de la MicroDelta ou à le placer sur le bureau (ça à mon avis je vais vite me décider)

3.3 Le support Camera :

Vu que je veux fixer une caméra, il faut bien créer le support !

Mais avant toute chose, il faut réfléchir à la connexion de la caméra !

Sur ma Prusa i3, le RaspberryPi est dans le caisson de l’imprimante, donc un cable de 60cm pour caméra était suffisant.

La pour la MicroDelta, la boite de RaspberryPi est déportée (il me faudrait 1m de cable pour être tranquille et le cable plat est vraiment pas top.

J’ai donc cherché une autre solution pour fixer la caméra et j’ai trouvé ça : https://www.tindie.com/products/freto/pi-camera-hdmi-cable-extension/ c’est un petit adaptateur qui va permettre de connecter la camera avec un cable HDMI (et bien sur il va nous falloir un cable HDMI souple : https://www.amazon.fr/Câble-HDMI-Ultra-Slim-antérieures/dp/B00W1VQKDC/ref=sr_1_1?ie=UTF8&qid=1481557659&sr=8-1&keywords=cable+hdmi+souple).

Voilà dans un premier temps le support caméra, qui lui aussi évoluera par la suite !

STL Files
  • hdmicase_top
Color:
Render:
Capture:
Download STL
STL Files
  • hdmicase_bottom
Color:
Render:
Capture:
Download STL
STL Files
  • tige-cam
Color:
Render:
Capture:
Download STL
STL Files
  • base cam
Color:
Render:
Capture:
Download STL

3.4 Les raccords à olive :

Personnellement j’aime pas ça ! Mais quand je dis que j’aime pas c’est que je les ai en horreur !

Combien de fois j’ai cassé un fil et obligé de dévisser les raccords, mal enfoncé la tube PTFE et l’olive est morte…

Bref du coup j’avais prévu le coup et je les ai remplacé par des pneufits full métal bien plus pratiques à mon sens.

J’en ai aussi monté un en entrée de l’extrudeur pour ne pas risquer un éventuel frottement entre le fil et le filetage à l’entrée.

3.5 Les tendeurs pour courroie :

J’ai découvert ces petits ressorts pour tendre les courroies que je trouve très pratique et que j’utilise déjà sur la Sculptr, du coup comme il m’en reste, je les monte sur mes courroies.

4. Premiers tests :

Une bonne qualité d’impression, je suis assez bluffé, mais si j’ai un peu loupé ma grenouille (Layer trop haut, remplissage un peu faible du coup j’ai un petit trou).

5. Simplify3D :

Dans un soucis pratique, j’ai créé un profil pour la MDR dans Simplify3D MicroDeltaRework.fff marre de jongler entre Simplify3d et Cura.

Pour ceux qui n’ont pas Simplify3D, je vous propose mon start g-code perso qui est assez pratique :

G21        ;metric values
G90        ;absolute positioning
M107       ;start with the fan off
G28   ;move to endstops
G92 E0                  ;zero the extruded length
G1 X-70 Z100 F7000      ;se déplace en X-70 Z100
G1 F200 E5              ;extrude 5mm of feed stock
G4 P30000               ; pause de 30 sec
G92 E0                  ;zero the extruded length again
;Put printing message on LCD screen
M117 Printing...

Qui permet d’extruder un peu de fil avant une pause de 30sec avant le début de l’impression !

Publié le

Sculptr Delta

En début d’été j’ai commencé à monter la Sculptr d’ Ottavio Bortolin (ici). Pendant le montage, j’ai modifié quelques pièces (désolé je ne peux pas m’en empêcher) elles sont disponibles ici.

Bon par manque de temps, je ne vais pas revenir vers le montage, car même sans notice elle est très simple à monter (et franchement je me suis éclater sans notice !).

Pour la calibration, c’est là que les ennuis commencent (non mais ça va c’est pas la mort, il faut juste bien comprendre comment ça fonctionne ! Après ça va tout seul je le fais les yeux fermés maintenant).

Pour la calibration, je me suis servi de ce tutoriel recommandé par Ottavio.

Enfin ait le but de la calibration (pour résumer un peu) est de définie des offsets pour les 3 end-stops de manière a avoir un déplacement parallèle au plateau et à la bonne hauteur.

1. Définir des « tours »

On définit trois tours : X, Y et Z qui vont nous permettre de calibrer nos endstops :

deltachart

Avec la Sculptr, les coordonnées de mes trois points X, Y et Z sont :

  • Pour X : X-52 Y-30
  • Pour Y : X52 Y-30
  • Pour Z : X0 Y60

2. Calibration :

Pour lancer la calibration, on fait un premier G28 pour percuter les endstops et être du coup en haut, puis on descend sur X :

G28
G1 X-52 Y-30 Z5 F7000

On est donc théoriquement et donc faussement à une distance du plateau de 5mm au dessus du point X.

On place une feuille de papier sous la tête et on descend tranquillement pour que la buse effleure le papier.

On fait un petit M114 et on regarde la valeur de Z

exemple :

X:-52.00 Y:-30.00 Z:-4.00

ici Z nous donne -4, donc en gros pour que la buse touche le plateau on a un écart de 4 mm, réglons se problème :

M666 X-4
M500 (ça c'est pour l'enregistrer)

La je dis à mon endstop qu’en fait il est 4mm trop haute et je corrige le problème !

Ensuite je passe à la tour Y :

G28 (on refait toujours un g28 pour tenir compte de la correction
G1 X52 Y-30 Z5 F7000

On est donc sur la tour Y, et on refait comme pour la tour X (bout de papier, on descend …)

On fait un M114 et on obtient :

X:52.00 Y:-30.00 Z:-8.00

On a une correction de 8mm à faire sur Y donc on tape :

M666 X-4 Y-8
M500

Oui, on oublie pas de reporter la valeur de correction sur X, sinon elle repasse à zéro et c’est le gros bordel !

Un petit G28 et on passe sur la tour Z et on refait pareil.

Attention cependant, au second passage, si par exemple on effleure le plateau en X avec Z=-0.5 par exemple, la nouvelle il faudra enlever -0.5 à la valeur précédente soit dans mon exemple on tapait au début M666 X-4 on va taper M66 X-4.5 (sans oublier les valeurs Y et Z).

Si par contre on a Z=0.5 on va ajouter cette valeur à la précédente donc M66X-3.5.

 

Personnellement, je répète 4 fois ces étapes pour ajuster mes valeurs et ainsi quand je lance un

G1 X0 Y0 Z5 F7000

Pour être au centre de mon plateau, en baissant de 5 mm la buse est à bonne hauteur.

Note importante :

Au début, au centre j’avais 2mm de trop (en gros sur X, Y et Z j’étais ok, mais au centre j’étais 2mm trop haut). 

En fait j’ai du aller modifier Marlin/ configuration.h et augmenter un peu le rayon de ma Delta :

#define DELTA_RADIUS 78

Et là c’est parfait.

3. Pour aller plus loin : Octoprint.

Je suis tombé amoureux de ça pour contrôler mes imprimantes 3D. du coup j’ai regardé un peu comment je pouvais automatiser certaines taches, et voir pour ma calibration comment le simplifier un peu :

Je suis donc allé ajouter ceci dans config.yaml (dans le dossier .octoprint)

controls:
  - name: Calibration
    layout: horizontal
    children:
    - commands:
      - G1 X-52 Y-30 Z5 F7000
      name: Tour X
    - commands:
      - G1 X52 Y-30 Z5 F7000
      name: Tour Y
    - commands:
      - G1 X0 Y60 Z5 F7000
      name: Tour Z
    - commands:
      - G28
      name: Home
    - commands:
      - G1 X0 Y0 Z5 F7000
      name: centre
    - name: Sauver
      commands:
      - M666 X%(XPOS)s Y%(YPOS)s Z%(ZPOS)s
      - M500
      input:
      - default: 0
        name: X
        parameter: XPOS
      - default: 0
        name: Y
        parameter: YPOS
      - default: 0
        name: Z
        parameter: ZPOS
  - name: Reporting
    children:
    - name: Get Position
      command: M114
      regex: "X:([-+]?[0-9.]+) Y:([-+]?[0-9.]+) Z:([-+]?[0-9.]+) E:([-+]?[0-9.]+)"
      template: "Position: X={0}, Y={1}, Z={2}, E={3}"

un petit reboot d’Octoprint et me voila avec ces nouvelles commandes dans l’onglet control :

sans-titre

Du coup je ne tape plus de commandes, j’ai juste à mettre mes valeurs de correction dans calibration, de sauver (qui envoie le M666 et le M500), j’ai le reporting pour avoir mon Z, bref je gagne un temps monstre !

Voici la vidéo :

Note : J’étofferai un peu plus l’article quand j’aurai un peu plus de temps !).

 

Publié le

Une box domotique sur RaspberryPi avec Domoticz !

Depuis un (grand) moment j’avais envie de me faire une box domotique pour un peu tout surveiller.

Début des vacances donc je me suis lancé !

1. La base : la box

Pour installer la box rien de plus simple : Un Raspberry Pi 2 (mon 3 me sert de serveur d’impression pour l’imprimante 3D) et on récupère une image de Domoticz ici.

Une fois récupérée, on utilise Win32DiskImager pour créer la carte Sd du Rasp.

J’y ai ajouté un Z-stick pour pouvoir contrôler des périphériques Z-Wave.

2. Configuration du Z-stick

Pour l’installer un petit tour sur Réglages – Matériel et on ajoute OpenZWave USB, on sélectionne le bon port et c’est parti pour installer les périphériques Z-Wave (je passe rapidement, c’est pas le plus passionnant et on trouve beaucoup de doc sur ça sur internet).

3. Ajout de la station météo Netatmo

L’an dernier j’ai fait des scrips php dans tous les sens pour récupérer les infos de la station météo, j’ai fait des graphes … Mais le soucis est la centralisation des données.

Ici c’est un jeu d’enfant, on ajoute dans matériel Netatmo, on renseigne l’identifiant et le mot de passe et ça récupère tout !

4. Une sonde de température sur le Rasp ?

Tiens j’ai vu qu’on pouvait mettre une sonde de température sur le Rasp pour avoir la température soit à proximité du Rasp, soit dans la pièce !

Cool j’ai une sonde DS18B20 en filaire qui traine !

Voici le schéma de branchement :

raspds18b20

Dans matériel on ajoute 1-Wire (System) et ça roule ! On a la température de la sonde !

 

Question : Il sert à quoi ton blog c’est tout simple ?

Réponse : On va attaquer le plus « dur »

5. Interfaçage avec Kodi (média player)

Pour le fun, j’ai installé Kodi sur mon pc, j’avais envie de créer une petite règle : quand je met mon film en pause ça allume la lumière et quand je reprend la lecture ça éteint la lumière.

J’ai donc installé Kodi (ex XBMC) et je suis allé réglé dans Système – Paramètres – Service – Serveur web :

Kodi

On coche « Autoriser le contrôle à distance via HTTP »

on relève le numéro de port et on va ajouter un nouveau matériel dans Domoticz : Kodi Media Server.

Une fois ajouté on clique sur Réglages :

kodi2

Kodi est donc configuré sur Domoticz, je vais aller créer un Evènement pour allumer/éteindre ma lampe !

Direction Réglages – Plus d’options – Evènement

Ca ressemble beaucoup à Scratch c’est à dire de la programmation par glisser/déposer.

Voilà à quoi ressemble mon événement :

Kodi3

Du coup quand je met en pause sur Kodi la lumière s’allume, quand je remet en lecture ça coupe !

6. Interfaçage avec Octoprint :

Alors je fais du graduel en difficulté, je n’ai pas tout fait dans cet ordre (et Octoprint je l’ai fait en deux fois).

Ce que je voulais avec Octoprint est de pouvoir récupérer les températures de la tête et du lit ainsi que la vidéo.

6.1 Récupérer la vidéo :

Il y a deux solutions : soit ajouter une webcam (mais alors le résultat est très très très moche donc je passe), soit utiliser l’onglet Perso (qui permet d’afficher un peu tout ce qu’on veut).

J’ai choisit la seconde option qui est plus propre :

Il faut aller dans le dossier /domoticz/www/templates, j’ai créé un fichier cam3d.html avec le contenu suivant :

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang="fr" xml:lang="fr">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
  <title>Webcams</title>
<style type="text/CSS">
  h2     {
color:#4E632C;
}

#main {
max-width:960px;
margin:auto;
position:relative;
}
#cam1 {
width:900px;
position:absolute;
}

</style>
</head>
<body>
<div id="cam1">
 <h2>Webcam Imprimante 3D</h2>

<img src="http://192.168.1.56/webcam/?action=stream"></img>
</div>

</div>
</div>
</body>
</html>

Et j’obtient la page suivante dans l’onglet perso :

cam3d

Youpi ! Je vois l’impression en direct depuis Domoticz (avec la solution de simplicité).

Pour info voici ce que ça fait en ajoutant une webcam :

cam3d2

On a vu moins moche quand même !

6.2 Récupérer les infos de l’imprimante 3D

Ah ah ah alors là c’est le plus fun (pas le plus dur, mais le plus fun je me suis bien amusé).

6.2.1 Créer un matériel virtuel dans Domoticz :

On ajoute dans matériel un « Dummy » qui va en fait être un groupe de capteurs virtuels.

Je l’ai appelé « Imprimante 3D »

On clique ensuite sur Créer des capteurs virtuels. J’en ai créé 3 : deux de type température (pour la tête et pour le lit) et un de type interrupteur (pour savoir si l’imprimante est en impression ou à l’arrêt) et je relève leurs idx.

Ici j’ai les idx 23, 24, 25

octo

6.2.2 Récupérer les infos d’Octoprint :

Alors petit tour sur le guide de l’API d’Octoprint, la requête est assez simple :

http://192.168.1.56/api/printer?apikey=1EF6D3B280D44A589F29BBE1BEBA73C4

(pour l’API key il faut prendre la votre hein)

Un coup dans chrome pour voir ce que ça donne :

{
  "sd": {
    "ready": false
  }, 
  "state": {
    "flags": {
      "closedOrError": false, 
      "error": false, 
      "operational": true, 
      "paused": false, 
      "printing": true, 
      "ready": true, 
      "sdReady": false
    }, 
    "text": "Printing"
  }, 
  "temperature": {
    "bed": {
      "actual": 45.3, 
      "offset": 0, 
      "target": 45.0
    }, 
    "tool0": {
      "actual": 209.8, 
      "offset": 0, 
      "target": 210.0
    }
  }
}

Ah plutôt cool avec cette requête j’obtient directement les infos que j’ai besoin ! Youpi !

Bon maintenant, il faut voir comment récupérer les valeurs et les envoyer à Domoticz !

6.2.3 Un petit coup de Python !

J’aurai pu faire du C, du Pearl… Mais j’avais envie de faire un petit programme en Python (que je n’ai pas touché depuis environ 10 ans).

déjà première étape on va installer un petit paquet pour faire les requêtes :

sudo apt-get install python-requests

Il est lancé ? Alors amusons nous un peu avant d’attaquer le programme !

On lance python dans le bash !

>>> import requests >>> r = requests.get(« http://192.168.1.56/api/printer?apikey=1EF6D3B280D44A589F29BBE1BEBA73C4 ») >>> r.content ‘{\n « sd »: {\n « ready »: false\n }, \n « state »: {\n « flags »: {\n « closedOrError »: false, \n « error »: false, \n « operational »: true, \n « paused »: false, \n « printing »: true, \n « ready »: true, \n « sdReady »: false\n }, \n « text »: « Printing »\n }, \n « temperature »: {\n « bed »: {\n « actual »: 44.7, \n « offset »: 0, \n « target »: 45.0\n }, \n « tool0 »: {\n « actual »: 210.4, \n « offset »: 0, \n « target »: 210.0\n }\n }\n}’ 

Wahooo j’ai mes données ! Amusons nous à les formater un peu !

Découpons un peu tout ça :

>>> reponse = r.content.split() >>> reponse [‘{‘, ‘ »sd »:’, ‘{‘, ‘ »ready »:’, ‘false’, ‘},’, ‘ »state »:’, ‘{‘, ‘ »flags »:’, ‘{‘, ‘ »closedOrError »:’, ‘false,’, ‘ »error »:’, ‘false,’, ‘ »operational »:’, ‘true,’, ‘ »paused »:’, ‘false,’, ‘ »printing »:’, ‘true,’, ‘ »ready »:’, ‘true,’, ‘ »sdReady »:’, ‘false’, ‘},’, ‘ »text »:’, ‘ »Printing »‘, ‘},’, ‘ »temperature »:’, ‘{‘, ‘ »bed »:’, ‘{‘, ‘ »actual »:’, ‘44.7,’, ‘ »offset »:’, ‘0,’, ‘ »target »:’, ‘45.0’, ‘},’, ‘ »tool0″:’, ‘{‘, ‘ »actual »:’, ‘210.4,’, ‘ »offset »:’, ‘0,’, ‘ »target »:’, ‘210.0’, ‘}’, ‘}’, ‘}’] 

Cherchons ce qui nous intéresse :

>>> reponse[19]
'true,'

J’ai un soucis ! il me rajoute une virgule à la fin :

>>> reponse[19]
'true,'
>>> reponse[19].strip(',')
'true'

Ah c’est mieux ! Mais mon interrupteur ne sais voir que « On » et « Off » dans domoticz, formatons tout ça :

>>> etatbouton = reponse[19].strip(',')
>>> etatbouton
'true'
>>> if etatbouton == "true": etatbouton = "On"
...
>>> etatbouton
'On'

Bon je crois qu’on est bon ! Petit tour sur la doc json de Domoticz

  • Interrupteur :
    http://192.168.1.37:8080/json.htm?type=command&param=switchlight&idx=25&switchcmd=
  • Température :
    http://192.168.1.37:8080/json.htm?type=command&param=udevice&idx=23&nvalue=0&svalue=12.3

Plus qu’à faire un petit script python domoticz.py :

import sys
import requests

r = requests.get("http://192.168.1.56/api/printer?apikey=1EF6D3B280D44A589F29BBE1BEBA73C4")
reponse = r.content.split()
bed =  reponse[33].strip(',')
tete = reponse[42].strip(',')
etat = reponse[19].strip(',')

base1 = "http://192.168.1.37:8080/json.htm?type=command&param=udevice&idx=24&nvalue=0&svalue="
base2 = "http://192.168.1.37:8080/json.htm?type=command&param=udevice&idx=23&nvalue=0&svalue="
base3 = "http://192.168.1.37:8080/json.htm?type=command&param=switchlight&idx=25&switchcmd="

if etat == "true": etat = 'On'
else : etat = 'Off'

sendbed = base1 + bed
sendtete = base2 + tete
sendetat = base3 + etat

requests.get(sendbed)
requests.get(sendtete)
requests.get(sendetat)

Un petit test pour voir si ça modifie bien les valeurs dans Domoticz :

python domoticz.py

si ça fonctionne on va aller l’ajouter dans le cron pour exécuter le script toutes les minutes :

sudo crontab -e

Et on crée la règle :

# Edit this file to introduce tasks to be run by cron.
#
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
#
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').#
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
#
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
#
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
#
# For more information see the manual pages of crontab(5) and cron(8)
#
# m h  dom mon dow   command

*/1 * * * * /usr/bin/python /home/pi/domoticz.py

7. HomeBridge

Avec la béta d’iOS 10, une nouvelle application « Domicile » est arrivée, elle permet de controler les équipements domotiques certifiés HomeKit avec iOS et TvOS.

Il y a un moyen de l’utiliser avec Domoticz : HomeBrigde

7.1 Installation :

Allez plein de commandes à taper dans le shell ! Youpi !

sudo npm install -g homebridge --unsafe-perm

C’est tout ? Ben oui c’est tout !

7.2 Configuration :

On installe en premier le pluggin pour Domoticz :

sudo npm install -g homebridge-edomoticz

on va dans le dossier /home/pi/.homebridge et on crée un fichier config.json :

{
    "bridge": {
        "name": "Homebridge",
        "username": "CC:22:3D:E3:CE:30",
        "port": 51826,
        "pin": "031-45-154"
    },

    "description": "This is an example configuration file with one fake accessory and one fake platform. You can use this as a template for creating your own configuration file containing devices you actually own.",

"platforms": [
        {
            "platform": "eDomoticz",
            "name": "eDomoticz",
            "server": "127.0.0.1",
            "port": "8080",
            "ssl": 0,
            "roomid": 0
        }
    ],
    "accessories": []
}

On teste HomeBridge en lançant la commande « homebridge » si tout va bien :

homebridge

Et on a plus qu’à ajouter le périphérique Domoticz avec l’application Domicile d’Apple !

8. MySensors !

J’ai commencé à jouer avec les Arduinos l’an dernier quand j’ai voulu faire un monitoring de ma piscine.

Je m’étais fait un mini-site qui récupérait les infos de la piscine pour pouvoir la surveiller à distance.

J’ai repris mon projet cette année pour l’intégrer à Domoticz.

8.1 MySensors c’est quoi ?

MySensors c’est un un arduino connecté sur le Rasp qui fait office de serveur NRF et d’autres arduinos en mode client.

Je vous conseille un petit tout sur MySensors pour plus de détails.

8.2 Coté serveur :

8.2.1 Matériel :

  • Arduino Uno
  • 1 Module NRF24L01
  • Des cables

8.2.2 Installation du serveur

Alors là je ne rentre pas dans le détail, je ne vais pas reprendre le guide vous le trouverez ici pour les branchements et ici pour la mise en place du serveur.

8.2.3 Ajout dans Domoticz

On va encore ajouter un matériel : MySensors Gateway USB

arduino 1

8.3 Coté client :

Un an que je repousse, mais quand il faut il faut ! Voilà comment je surveille ma piscine :

  • Température de l’eau
  • pH
  • Température et humidité du bloc de filtration
  • Pression du filtre à sable

Je compte ajouter un détecteur de fuite, je l’ai, mais pas monté.

8.3.1 Le montage :

Piscine_bb

8.3.2 Le programme :

#include <LiquidCrystal_I2C.h>
#include <SPI.h>
#include <OneWire.h>
#include <DallasTemperature.h>
#include "DHT.h"
#include <Wire.h>
#include <MySensor.h>

// Configuration MySensors
MySensor gw;
#define CHILD_ID_TEMP 0
#define CHILD_ID_PH 1
#define CHILD_ID_PRESSION 2

MyMessage msgTemp(CHILD_ID_TEMP, V_TEMP);
MyMessage msgPh(CHILD_ID_PH, V_VOLTAGE);
MyMessage msgPres(CHILD_ID_PRESSION, V_PRESSURE);

boolean metric = true;

//Déclarations de l'écran
LiquidCrystal_I2C lcd(0x27, 16, 2);
#define SensorPin A2
#define etalonnagepH A1

// Déclaration des sondes DS18B20
int DS18S20_Pin = 3;
OneWire ds(DS18S20_Pin);

// Déclaration DHT :
#define DHTTYPE DHT11
#define DHTPIN 4
DHT dht(DHTPIN, DHTTYPE);

// Capteur pression filtre
float valeur ;
int analog = A0;



void setup() {
  Serial.begin(9600);
  lcd.begin();
  lcd.backlight();
  lcd.setCursor(0,0);
 
  dht.begin();
  lcd.print("Connection");
  lcd.clear();

  lcd.print("Temp : ");
  lcd.setCursor(2,1);
  lcd.print("pH : ");

   gw.begin();
   gw.sendSketchInfo("Piscine","1.5");

   gw.present(CHILD_ID_TEMP, S_TEMP);
   gw.present(CHILD_ID_PH, S_MULTIMETER);
   gw.present(CHILD_ID_PRESSION, S_BARO);
  

   metric = gw.getConfig().isMetric;
  
}

void loop() {
  // Requête du DS18B20 :
  float mesure = getTemp();

  // Requete du DHT22 :
  float tdht = dht.readTemperature();
  float hdht = dht.readHumidity();
  float voltage = getpH();
  float Offset = (analogRead(etalonnagepH)-512.0)/500;
  float pH = 7-(2.5-voltage/200)/(0.257179+0.000941468*mesure) +Offset;

  //PRESSION
  valeur = analogRead(analog);
  float pression = 3*valeur*5/1023-3*0.47;
      
  // AFFICHAGE SUR LE LCD :
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Temp");
  lcd.setCursor(7,0);
  lcd.print(mesure);
  lcd.print(" C");
  lcd.setCursor(0,1);
  lcd.print("pH");
  lcd.setCursor(7,1);
  lcd.print(pH);
  lcd.setCursor(12,1);
  delay(5000);
  
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Temp b");
   lcd.setCursor(7,0);
  lcd.print(tdht);
  lcd.print(" C");
  lcd.setCursor(0,1);
  lcd.print("hum b");
  lcd.setCursor(7,1);
  lcd.print(hdht);
  lcd.setCursor(12,1);
  delay(5000);

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Temp");
   lcd.setCursor(7,0);
  lcd.print(mesure);
  lcd.print(" C");
  lcd.setCursor(0,1);
  lcd.print("pH");
  lcd.setCursor(7,1);
  lcd.print(pH);
  lcd.setCursor(12,1);
  delay(5000);

  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print("Filtre");
  lcd.setCursor(7,0);
  lcd.print(pression);

  lcd.setCursor(0,1);
  if (pression < 0.5) {
  lcd.print("Pression faible");
  }
  if (pression >= 0.5 && pression <= 1.1) {
  lcd.print("Pression ok");
  }
  if (pression > 1.1 && pression <= 1.5) {
  lcd.print("Pression haute");
  }
  if (pression >1.5)
  {
    lcd.print("URGENT");
  }

  delay(5000);

  
  gw.send(msgTemp.set(mesure, 2));
  gw.send(msgPh.set(pH, 2));
  gw.send(msgPres.set(pression, 2));
  
}

float getpH(){
 
  float temp = getTemp();
// float temp = 25.00;
static float pHValue,voltage;

voltage = analogRead(SensorPin) ;

//voltage = analogRead(SensorPin);

return voltage;
//return pHValue ;
}

float getTemp(){
 //returns the temperature from one DS18S20 in DEG Celsius

 byte data[12];
 byte addr[8];

 if ( !ds.search(addr)) {
   //no more sensors on chain, reset search
   ds.reset_search();
   return -1000;
 }

 if ( OneWire::crc8( addr, 7) != addr[7]) {
   Serial.println("CRC is not valid!");
   return -1000;
 }

 if ( addr[0] != 0x10 && addr[0] != 0x28) {
   Serial.print("Device is not recognized");
   return -1000;
 }

 ds.reset();
 ds.select(addr);
 ds.write(0x44,1); // start conversion, with parasite power on at the end

 byte present = ds.reset();
 ds.select(addr);  
 ds.write(0xBE); // Read Scratchpad

 
 for (int i = 0; i < 9; i++) { // we need 9 bytes
  data[i] = ds.read();
 }
 
 ds.reset_search();
 
 byte MSB = data[1];
 byte LSB = data[0];

 float tempRead = ((MSB << 8) | LSB); //using two's compliment
 float TemperatureSum = tempRead / 16;
 
 return TemperatureSum;
 
}

9. Et la boite dans tout ça ?

C’est bien joli d’avoir un imprimante 3D, encore faut il s’en servir ! Je me suis donc fait une petite boite pour ranger tout ça !

vRUi0a77

Et histoire de tester mon nouveau pluggin :

STL Files
  • Domoticz-box
Color:
Render:
Capture:
Download STL

Attention c’est pas le bon modèle !

Voici les pièces de la version corrigée :

Base uno :

STL Files
  • base uno
Color:
Render:
Capture:
Download STL

Contour :

STL Files
  • contour
Color:
Render:
Capture:
Download STL

Couvercle

STL Files
  • couvercle
Color:
Render:
Capture:
Download STL

Base Raspi

STL Files
  • base pi
Color:
Render:
Capture:
Download STL

 

Publié le

Retour sur la configuration d’Octoprint

Je reprend ici l’article Imprimante 3D – Améliorations pour expliquer un peu plus comme j’ai monté mon serveur d’impression. Je vais même vous donner la liste de matériel nécessaire !

1 . Le matériel :

  • Une imprimante 3D (ouais ça sert à rien d’aller plus loin si on en a pas)
  • Un raspberry pi 3 (Sur amazon par exemple même si je le trouve un peu cher ici).
  • Un module relais double 5V (ici).
  • Une alimentation ATX (pour info j’ai celle ci)
  • Des rallonges pour alimentation pour conserver la garantie de l’alim (ici)
  • Une carte SD, moi j’ai pris une 64GB bien regarder la vitesse de transfert (ici).
  • Un port usb femelle récupéré sur un vieux PC ( ca ressemble à ca)
  • Une camera pour le pi (ici)

2. Le montage :

Sur les alimentations ATX, si on connecte le fil vert avec le fil noir, l’alimentation se met en marche. Il y a aussi le fil violet qui est un +5V continu (indépendant de la marche ou l’arrêt par le fil vert de l’alimentation).

Je place donc un relais qui va contacter ma masse avec le fil vert pour alimenter l’imprimante 3D.

Voilà le schéma sur Fritzing :

raspi_bb

L’avantage du double relais est qu’il peut du coup commander autre chose (par exemple moi il contrôle l’éclairage de la cam).

3. La configuration :

Je ne vais pas reprendre l’installation d’Octoprint ici, vous la trouverez sur le site d’Octoprint.

Une fois octoprint installé, on va aller le configurer (soit si on a un écran branché dessus, moi je fais avec ma télé en HDMI, soit par ssh)

On commence par installer WiringPi :

sudo apt-get update 
sudo apt-get upgrade

sudo apt-get install git-core

git clone git://git.drogon.net/wiringPi

cd wiringPi
./build

On fait un petit test en lançant

gpio readall

et on observe quelque chose comme ça :

+-----+-----+---------+------+---+---Pi 3---+---+------+---------+-----+-----+
 | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
 +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
 |     |     |    3.3v |      |   |  1 || 2  |   |      | 5v      |     |     |
 |   2 |   8 |   SDA.1 |   IN | 1 |  3 || 4  |   |      | 5V      |     |     |
 |   3 |   9 |   SCL.1 |   IN | 1 |  5 || 6  |   |      | 0v      |     |     |
 |   4 |   7 | GPIO. 7 |   IN | 1 |  7 || 8  | 1 | ALT5 | TxD     | 15  | 14  |
 |     |     |      0v |      |   |  9 || 10 | 1 | ALT5 | RxD     | 16  | 15  |
 |  17 |   0 | GPIO. 0 |   IN | 0 | 11 || 12 | 0 | OUT  | GPIO. 1 | 1   | 18  |
 |  27 |   2 | GPIO. 2 |  OUT | 1 | 13 || 14 |   |      | 0v      |     |     |
 |  22 |   3 | GPIO. 3 |   IN | 0 | 15 || 16 | 0 | IN   | GPIO. 4 | 4   | 23  |
 |     |     |    3.3v |      |   | 17 || 18 | 0 | IN   | GPIO. 5 | 5   | 24  |
 |  10 |  12 |    MOSI |   IN | 0 | 19 || 20 |   |      | 0v      |     |     |
 |   9 |  13 |    MISO |   IN | 0 | 21 || 22 | 0 | IN   | GPIO. 6 | 6   | 25  |
 |  11 |  14 |    SCLK |   IN | 0 | 23 || 24 | 1 | IN   | CE0     | 10  | 8   |
 |     |     |      0v |      |   | 25 || 26 | 1 | IN   | CE1     | 11  | 7   |
 |   0 |  30 |   SDA.0 |   IN | 1 | 27 || 28 | 1 | IN   | SCL.0   | 31  | 1   |
 |   5 |  21 | GPIO.21 |   IN | 1 | 29 || 30 |   |      | 0v      |     |     |
 |   6 |  22 | GPIO.22 |   IN | 1 | 31 || 32 | 0 | IN   | GPIO.26 | 26  | 12  |
 |  13 |  23 | GPIO.23 |   IN | 0 | 33 || 34 |   |      | 0v      |     |     |
 |  19 |  24 | GPIO.24 |   IN | 0 | 35 || 36 | 0 | IN   | GPIO.27 | 27  | 16  |
 |  26 |  25 | GPIO.25 |   IN | 0 | 37 || 38 | 0 | IN   | GPIO.28 | 28  | 20  |
 |     |     |      0v |      |   | 39 || 40 | 0 | IN   | GPIO.29 | 29  | 21  |
 +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
 | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
 +-----+-----+---------+------+---+---Pi 3---+---+------+---------+-----+-----+

On voit ici que mon GPIO1 et mon GPIO2 sont configurés en OUT (ce qui m’intéresse pour contrôler mon relais !), on va aller les configurer :

sudo nano /etc/rc.local

Et on ajoute juste avant « exit 0 » la ligne :

/usr/local/bin/gpio write 1 0
/usr/local/bin/gpio mode 1 out
/usr/local/bin/gpio write 2 1
/usr/local/bin/gpio mode 2 out

Les lignes 1 et 3 définissent l’état de mes pins au démarrage du Raspi.

Ctrl+X et on valide par Y pour enregistrer la configuration.

Maintenant on va aller ajouter ça à l’interface d’octoprint :

sudo nano ~/.octoprint/config.yaml

Dans la partie « action » on va aller rajouter :

  - action: Printer on
    command: gpio write 1 0
    name: Printer On
  - action: Printer off
    command: gpio write 1 1
    name: Printer Off
  - action: Eclairage on
    command: gpio write 2 0
    name: Eclairage On
  - action: Eclairage off
    command: gpio write 2 1
    name: Eclairage Off

Soit :

system:
  actions:
  - action: shutdown
    async: true
    command: sudo shutdown -h now
    confirm: You are about to shutdown the system.
    ignore: true
    name: Shutdown
  - action: reboot
    async: true
    command: sudo shutdown -r now
    confirm: You are about to reboot the system
    ignore: true
    name: Reboot
  - action: restart
    async: true
    command: sudo service octoprint restart
    confirm: You are about to restart OctoPrint
    ignore: true
    name: Restart OctoPrint
  - action: Printer on
    command: gpio write 1 0
    name: Printer On
  - action: Printer off
    command: gpio write 1 1
    name: Printer Off
  - action: Eclairage on
    command: gpio write 2 0
    name: Eclairage On
  - action: Eclairage off
    command: gpio write 2 1
    name: Eclairage Off

Et du coup on a ces deux entrées dans le menu :

Capture

4. La cam :

Pour la cam, je vous renvoie à l’aide d’Octoprint que vous trouverez ici (pas envie de faire un copier coller du bouzin).

5. Ajout du wifi :

Bon j’ai un CPL qui m’a lâché, donc j’ai voulu connecter le Rasp en Wifi.

Une petit manipulation à faire :

sudo nano /etc/network/interfaces

Le fichier se présente de cette façon :

auto lo
iface lo inet loopback

auto eth0
allow-hotplug eth0
iface eth0 inet manual

auto wlan0
allow-hotplug wlan0
#iface wlan0 inet manual
#wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf


auto wlan1
allow-hotplug wlan1
# iface wlan1 inet manual
# wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

on va aller rajouter ces deux lignes dans « auto wlan0 » juste après « allow-hotplug wlan0 » :

 wpa-ssid "nom du réseau"
 wpa-psk "Mot de passe"

on ferme, on reboot et voilà on est en wifi !

Publié le

Imprimante 3D – Améliorations

Comme je l’ai dit dans l’article précédent, j’ai fait quelques améliorations à mon imprimante 3D.

1. Le tapis chauffant :

Pour avoir une meilleure accroche et éviter que les pièces ce décollent, j’ai ajouté un plateau chauffant de type MK2a.

Le seul point est son alimentation, il a besoin d’un peu plus de 11A en 12V pour fonctionner, donc il faut ajouter une alimentation style pc assez puissante pour le faire fonctionner.

kit-de-cama-caliente-mk2a_800x800

Voici je kit que j’ai pris. Il vient se placer sous le plateau en verre et chauffe assez rapidement.

Suite à l’installation du plateau chauffant, il faut aller modifier le firmware de l’imprimante pour pouvoir l’utiliser :

il suffit juste de modifier dans le fichier configuration.h la valeur

#define TEMP_SENSOR_BED 0

En

#define TEMP_SENSOR_BED 1

On charge le firmware et c’est bon.

2. Octoprint (serveur d’impression réseau) :

Ah j’ai ressorti mon RaspberryPi pour l’occasion !

Pourquoi ne pas s’en faire un petit serveur d’impression qui va aussi nous permettre d’éteindre et d’allumer l’imprimante 3D ?

Chose pratique, on peut télécharger une image pour le Rasp avec octoprint préinstallé (pour éviter de devoir tout configurer à la main) c’est OctoPi.

Ca permet de surveiller l’impression (avec une caméra, voir ou on en est …) très pratique et extrêmement simple à utiliser !

Je prépare mon fichier .gcode sous Cura, et je l’upload directement via l’interface Octoprint.

La je suis en train d’implémenter un ajout pour pouvoir allumer/éteindre l’alimentation de l’imprimante 3D directement via Octoprint :

Sur les alimentations ATX, si on connecte le fil vert avec le fil noir, l’alimentation se met en marche. Il y a aussi le fil violet qui est un +5V continu (indépendant de la marche ou l’arrêt par le fil vert de l’alimentation).

Je place donc un relais qui va contacter ma masse avec le fil vert pour alimenter l’imprimante 3D.

Un petit tour en ssh sur le Rasp pour préparer tout ça :

On commence par installer WiringPi :

sudo apt-get install git-core

sudo apt-get update
sudo apt-get upgrade

git clone git://git.drogon.net/wiringPi

cd wiringPi
./build

On fait un petit test en lançant

gpio readall

et on observe quelque chose comme ça :

+-----+-----+---------+------+---+---Pi 2---+---+------+---------+-----+-----+
 | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
 +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
 |     |     |    3.3v |      |   |  1 || 2  |   |      | 5v      |     |     |
 |   2 |   8 |   SDA.1 |   IN | 1 |  3 || 4  |   |      | 5V      |     |     |
 |   3 |   9 |   SCL.1 |   IN | 1 |  5 || 6  |   |      | 0v      |     |     |
 |   4 |   7 | GPIO. 7 |   IN | 1 |  7 || 8  | 0 | OUT  | TxD     | 15  | 14  |
 |     |     |      0v |      |   |  9 || 10 | 1 | ALT0 | RxD     | 16  | 15  |
 |  17 |   0 | GPIO. 0 |   IN | 0 | 11 || 12 | 0 | IN   | GPIO. 1 | 1   | 18  |
 |  27 |   2 | GPIO. 2 |   IN | 0 | 13 || 14 |   |      | 0v      |     |     |
 |  22 |   3 | GPIO. 3 |   IN | 0 | 15 || 16 | 0 | IN   | GPIO. 4 | 4   | 23  |
 |     |     |    3.3v |      |   | 17 || 18 | 0 | IN   | GPIO. 5 | 5   | 24  |
 |  10 |  12 |    MOSI |   IN | 0 | 19 || 20 |   |      | 0v      |     |     |
 |   9 |  13 |    MISO |   IN | 0 | 21 || 22 | 0 | IN   | GPIO. 6 | 6   | 25  |
 |  11 |  14 |    SCLK |   IN | 0 | 23 || 24 | 1 | IN   | CE0     | 10  | 8   |
 |     |     |      0v |      |   | 25 || 26 | 1 | IN   | CE1     | 11  | 7   |
 |   0 |  30 |   SDA.0 |   IN | 1 | 27 || 28 | 1 | IN   | SCL.0   | 31  | 1   |
 |   5 |  21 | GPIO.21 |   IN | 1 | 29 || 30 |   |      | 0v      |     |     |
 |   6 |  22 | GPIO.22 |   IN | 1 | 31 || 32 | 0 | IN   | GPIO.26 | 26  | 12  |
 |  13 |  23 | GPIO.23 |   IN | 0 | 33 || 34 |   |      | 0v      |     |     |
 |  19 |  24 | GPIO.24 |   IN | 0 | 35 || 36 | 0 | IN   | GPIO.27 | 27  | 16  |
 |  26 |  25 | GPIO.25 |   IN | 0 | 37 || 38 | 0 | IN   | GPIO.28 | 28  | 20  |
 |     |     |      0v |      |   | 39 || 40 | 0 | IN   | GPIO.29 | 29  | 21  |
 +-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
 | BCM | wPi |   Name  | Mode | V | Physical | V | Mode | Name    | wPi | BCM |
 +-----+-----+---------+------+---+---Pi 2---+---+------+---------+-----+-----+

On voit ici que mon GPIO15 est configuré en OUT (ce qui m’intéresse pour contrôler mon relais !)

un petit coup pour qu’il soit toujours actif en OUT :

sudo nano /etc/rc.local

Et on ajoute juste avant « exit 0 » la ligne :

/usr/local/bin/gpio mode 15 out

Ctrl+X et on valide par Y pour enregistrer la configuration.

Maintenant on va aller ajouter ça à l’interface d’octoprint :

sudo nano ~/.octoprint/config.yaml

iDans la partie « action » on va aller rajouter :

- action: Printer on
command: gpio write 15 1
name: Printer On
- action: Printer off
command: gpio write 15 0
name: Printer Off

Soit :

 actions:
  - action: shutdown
    async: true
    command: sudo shutdown -h now
    confirm: You are about to shutdown the system.
    ignore: true
    name: Shutdown
  - action: reboot
    async: true
    command: sudo shutdown -r now
    confirm: You are about to reboot the system
    ignore: true
    name: Reboot
  - action: restart
    async: true
    command: sudo service octoprint restart
    confirm: You are about to restart OctoPrint
    ignore: true
    name: Restart OctoPrint
  - action: Printer on
    command: gpio write 15 1
    name: Printer On
  - action: Printer off
    command: gpio write 15 0
    name: Printer Off

Et du coup on a ces deux entrées dans le menu :

5697edde807b8_OctoPrint-GoogleChrome.jpg.43028aa36a7cb5ed227261b6a7514b52

Petit rajout : Octoprint possède de nombreux plugins dont « email notifier » qui envoi un mail quand l’impression est finie.

Pour l’utiliser il faut refaire un peu de ssh :

sudo pip install keyrings.alt
sudo pip install yagmail

On lance ensuite python avec :

~/oprint/bin/python

Puis :

>> import yagmail
>> yagmail.register('mygmailusername', 'mygmailpassword')

Ajout du wifi :

Bon j’ai un CPL qui m’a lâché, donc j’ai voulu connecter le Rasp en Wifi.

Une petit manipulation à faire :

sudo nano /etc/network/interfaces

Le fichier se présente de cette façon :

auto lo
iface lo inet loopback

auto eth0
allow-hotplug eth0
iface eth0 inet manual

auto wlan0
allow-hotplug wlan0
#iface wlan0 inet manual
#wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf


auto wlan1
allow-hotplug wlan1
# iface wlan1 inet manual
# wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

on va aller rajouter ces deux lignes dans « auto wlan0 » juste après « allow-hotplug wlan0 » :

 wpa-ssid "nom du réseau"
 wpa-psk "Mot de passe"

on ferme, on reboot et voilà on est en wifi !

3. Le capteur inductif :

Bon là on complique un peu (beaucoup en fait).

J’ai pris cette sonde sur eBay et je me suis imprimé son support.

J’ai monté ma sonde et j’ai attaqué les réglages.

La sonde est une sonde 12V donc on doit réduire la sortie de la sonde pour ne pas endommager la carte ramps !

Raccordement sonde

Une fois fait on déconnecte le capteur de fin de course Zmin et on vient y brancher notre sonde.

Il est temps d’étalonner notre capteur !

Je me suis servit d’Octoprint pour commander l’imprimante pendant les manipulations, c’est très pratique !

  1. Première étape, on va aller placer l’extrudeuse au centre du plateau (icône home quand on est dans l’onglet control).
  2. Avec un marqueur on fait une petit croix juste en dessous de la buse d’impression.
  3. On coupe l’alimentation de l’imprimante (alors on coupe juste la partie sur le 12V, le cable USB doit rester branché sur le Rasp).
  4. On descend la tête manuellement (oui oui, en pesant tourner les moteurs à la main) pour ajuster notre zéro (on doit pouvoir passer une feuille sous la buse, même manipulation que quand on règle le niveau en manuel).
  5. Dans octoprint on va dans terminal et on envoie la commande : G92 X0 Y0 Z0
  6. On remet l’alimentation 12V de l’imprimante
  7. On va dans Control et on va aller déplacer la sonde de telle manière à ce qu’elle soit positionnée et centrée sur la croix (ainsi on va connaitre le décalage entre notre sonde et la buse).
  8. En jouant avec les moteur on fait varier la hauteur de l’axe Z pour trouver la position à laquelle le capteur s’enclenche (la led éclaire faiblement / fortement).
  9. Une fois cette étape faite, on lance dans l’onglet terminal la commande M114 (qui va nous donner la position de l’extruder par rapport à la position qu’on a définie comme le zéro à l’étape 5).
  10. Et on relève les valeurs obtenues en résultat (chez moi ça donne X 23 Y 28 Z 4.7) (on les notes sur un papier).
  11. Maintenant on va aller préparer le firmware pour que le niveau devienne automatique :
  • Dans configuration.h :

On commente la ligne (avec // en début de ligne) :

#define ENDSTOPPULLUP_ZMIN

On dé-commente la ligne (on vire les //) :

#define ENABLE_AUTO_BED_LEVELING

On règle ensuite le rectangle de palpage (que je vais surement modifier, mais je ne dis pas pourquoi) :

 // set the rectangle in which to probe
    #define LEFT_PROBE_BED_POSITION 15
    #define RIGHT_PROBE_BED_POSITION 160
    #define BACK_PROBE_BED_POSITION 160
    #define FRONT_PROBE_BED_POSITION 20

Le nombre de alpages, j’en veux 4 donc je met deux (mais je vais tester avec 9, donc 3, normalement à cette étape rien à faire c’est déjà à deux, mais on vérifie) :

   #define AUTO_BED_LEVELING_GRID_POINTS 2

Et ensuite on va aller définir les réglages du capteur :

#define X_PROBE_OFFSET_FROM_EXTRUDER -23
#define Y_PROBE_OFFSET_FROM_EXTRUDER -28
#define Z_PROBE_OFFSET_FROM_EXTRUDER -4.7

Et là vous retrouvez les valeurs du point 10, avec juste un signe négatif devant (le signe négatif EST INDISPENSABLE !).

On modifie encore deux trois valeurs (ça donne de la rapidité au niveau automatique).

 #define Z_RAISE_BEFORE_HOMING 10       // (in mm) Raise Z before homing (G28) for Probe Clearance.
                                        // Be sure you have this distance over your Z_MAX_POS in case

  #define Z_RAISE_BEFORE_PROBING 1    //How much the extruder will be raised before traveling to the first probing point.
  #define Z_RAISE_BETWEEN_PROBINGS 1  //How much the extruder will be raised when traveling from between next probing points
  • Dans configuration_adv.h :

On dé-commente la ligne

#define ENDSTOPS_ONLY_FOR_HOMING // If defined the endstops will only be used for homing
  • Dans ultralcd.cpp

On commente la ligne (on vire l’entrée dans le menu du lcd qui lance le niveau du plateau, vu qu’il sera fait automatiquement à chaque impression) :

MENU_ITEM(function, MSG_LEVEL_PLATE, function_config_level_bed);
  • Dans Cura :

On va aller modifier GCODE de départ :

; -- START GCODE --
;Sliced at: {day} {date} {time}
;Basic settings: Layer height: {layer_height} Walls: {wall_thickness} Fill: {fill_density}
;Print time: {print_time}
;Filament used: {filament_amount}m {filament_weight}g
;Filament cost: {filament_cost}
;Uncomment to add your own temperature line
;M109 S{print_temperature}
;Uncomment to add your own bed temperature line
;M190 S{print_bed_temperature}
G21                     ;metric values
G90                     ;absolute positioning
M107                    ;start with the fan off
G28 X0 Y0               ;move X/Y to min endstops
G28 Z0                  ;move Z to min endstops
G1 Z15.0 F1200          ;move the platform down 15mm
G92 E0                  ;zero the extruded length
G1 F200 E20             ;extrude 20mm of feed stock
G92 E0                  ;zero the extruded length again
G1 F{travel_speed}
;Uncomment to put a printing message on LCD screen
;M117 Printing...
; -- end of START GCODE --

On modifie les lignes 14 et 15 :

; -- START GCODE --
;Sliced at: {day} {date} {time}
;Basic settings: Layer height: {layer_height} Walls: {wall_thickness} Fill: {fill_density}
;Print time: {print_time}
;Filament used: {filament_amount}m {filament_weight}g
;Filament cost: {filament_cost}
;Uncomment to add your own temperature line
;M109 S{print_temperature}
;Uncomment to add your own bed temperature line
;M190 S{print_bed_temperature}
G21                     ;metric values
G90                     ;absolute positioning
M107                    ;start with the fan off
G28                     ;move X/Y to min endstops
G29                     ;AUTOLEVEL
G1 Z15.0 F1200          ;move the platform down 15mm
G92 E0                  ;zero the extruded length
G1 F200 E20             ;extrude 20mm of feed stock
G92 E0                  ;zero the extruded length again
G1 F{travel_speed}
;Uncomment to put a printing message on LCD screen
;M117 Printing...
; -- end of START GCODE --

 

 

Publié le

Station météo maison couplée à une station Netatmo Part.1

Les modules additionnels Netatmo étant un peu cher, j’ai décidé de me faire des petits modules maison avec un ESP8266 et des ds18b20/DHT11-22.

Bien sur, je n’ai pas envie de faire un truc tout moche, donc pour les graphiques je me suis penché sur Highstocks.

Alors d’entrée j’ai bloqué : on doit utiliser du Javascript et moi je sais pas en faire… Ça commence bien…

Alors j’ai essayé de comprendre quand même, mais l’import des données avec json.encode() dans le php m’a un peu saoulé car sur les démos de Highstocks, c’était pas encodé pareil… Du coup sauce maison !

Pour la partie base de donnée, il suffit de regarder mes tutos précédents pour alimenter la BDD avec les relevés Netamo.

1. Encodage des données pour Highstock :

En regardant les démos, j’ai vu que le format des données étaient du style :

[
[data1,data2],
[data1,data2],
[data1,data2],
[data1,data2],
[data1,data2],
[data1,data2],
[data1,data2]
]

Du coup, je me suis fait un fichier temperaturenetatmo.php qui quand je l’exécute m’affiche les données sous cette forme :

<?php
include('connexionDB.php');

$date = 1445538928*1000;
echo "[";
$i=0;
$sth = mysql_query("SELECT datemesure, temp_int, temp_ext, pres, hum_int, hum_ext FROM netatmo");
$rows = array();

while($r = mysql_fetch_array($sth)) {
    if (date("I",time())==0){
    	if (($r["datemesure"]+3600)*1000-$date > 30*60*1000)
    	{
    		$date2 = $date + 1000;
    		$rows[] = "[".$date2.",null,null,null,null,null]";
    		$i = $i +1;
    	}
    	$date = ($r['datemesure']+3600)*1000 ;
    	$rows[] = "[".$date.",".$r["temp_int"].",".$r["temp_ext"].",".$r["pres"].",".$r["hum_int"].",".$r["hum_ext"]."]";
    	$i = $i +1;
	}
	else {
		if (($r["datemesure"]+3600)*1000-$date > 10*360*1000)
    	{
    		$date2 = $date + 1000;
    		$rows[] = "[".$date2.",null]";
    		$i = $i +1;
    	}
		$date = ($r['datemesure']+3600)*1000 ;
		$rows[] = "[".$date.",".$r["temp_int"].",".$r["temp_ext"].",".$r["pres"].",".$r["hum_int"].",".$r["hum_ext"]."]";
        $i = $i+1;
	}
}
for ($j = 0 ; $j<$i-1; $j ++){
	echo $rows[$j];
	echo ",";
}
echo $rows[$i-1];
echo "]";

mysql_close($con);
?>

Quelques précisions :

$date = 1445538928*1000;

Est la PREMIERE date de ma table (elle me permet de définir mes « null » quand il n’y a pas de données dans un intervalle de 30 minutes.

On remarque aussi que je multiplie toutes mes dates par 1000 : le temps en javascript prend en compte les milisecondes, on multiplie donc le timestamp php qui lui ne les prend pas.

Voici un extrait de la sortie :

[
[1428155100000,20.4,14.4,1015.1,67,61],
[1428156900000,20.5,14.3,1014.9,67,63],
[1428158700000,20.2,14.4,1014.6,68,63],
[1428158701000,null,null,null,null,null],
[1428176700000,20.4,12.1,1014.1,67,74]
]

La première partie est finie (j’y ai passé 3 jours quand même (en comptant le temps passé avec json.encode() ).

2. La partie Highstock :

Avant de vous dire le pourquoi du comment, voilà ce que je voulais obtenir :

chart

C’est là que la déprime a commencé… Heureusement que les démos sur Highstocks sont pas mal, je me suis inspiré de :

Et voilà mon code :

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <title>Surveillance maison</title>
        <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>



<script type="text/javascript">



$(function () {
    var highchartsOptions = Highcharts.setOptions(Highcharts.theme);
Highcharts.setOptions({
lang: {

months: ["Janvier "," Février ","Mars "," Avril "," Mai "," Juin "," Juillet "," Août "," Septembre ",
" Octobre "," Novembre "," Décembre"],
weekdays: ["Dim "," Lun "," Mar "," Mer "," Jeu "," Ven "," Sam"],
shortMonths: ['Jan', 'Fev', 'Mar', 'Avr', 'Mai', 'Juin', 'Juil','Août', 'Sept', 'Oct', 'Nov', 'Déc'],
decimalPoint: ',',
resetZoom: 'Reset zoom',
resetZoomTitle: 'Reset zoom à 1:1',
downloadPNG: "Télécharger au format PNG image",
downloadJPEG: "Télécharger au format JPEG image",
downloadPDF: "Télécharger au format PDF document",
downloadSVG: "Télécharger au format SVG vector image",
exportButtonTitle: "Exporter image ou document",
printChart: "Imprimer le graphique",
loading: "Chargement...",
rangeSelectorFrom: "Du",
rangeSelectorTo: "au"
 }

});
    $.getJSON('temperaturenetatmo.php', function (data) {

        // split the data set into temp_int and temp_ext
        var temp_int = [],
            temp_ext = [],
            rose = [],
            pression = [],
            hum_int = [],
            hum_ext = [],
            dataLength = data.length,
            // set the allowed units for data grouping


            i = 0;

        for (i; i < dataLength; i += 1) {
            temp_int.push([
                data[i][0], // the date
                data[i][1], // température intérieure

            ]);

            temp_ext.push([
                data[i][0], // the date
                data[i][2] // température extérieure
            ]);

            rose.push([
                data[i][0], // the date
                (Math.pow(data[i][5] /100,0.125)  )*(112+0.9*data[i][2])+0.1*data[i][2]-112 // point de rosée
            ]);

             pression.push([
                data[i][0], // the date
                data[i][3] // pression
            ]);
            hum_int.push([
                data[i][0], // the date
                data[i][4] // hum int
            ]);
            hum_ext.push([
                data[i][0], // the date
                data[i][5] // hum ext
            ]);
            }


        // create the chart
        $('#container2').highcharts('StockChart', {

             rangeSelector : {
                buttons : [ {
                    type : 'hour',
                    count : 12,
                    text : '12h'
                },{
                    type : 'day',
                    count : 1,
                    text : '1j'
                },{
                    type : 'day',
                    count : 7,
                    text : '1s'
                },{
                    type : 'month',
                    count : 1,
                    text : '1m'
                }, {
                    type : 'all',
                    count : 1,
                    text : 'Tout'
                }],
                selected : 1
            },

            title: {
                text: 'Données Netatmo'
            },

            yAxis: [{

                labels: {
                    align: 'right',
                    x: -3
                },
                title: {
                    text: 'Température'
                },
                height: '30%',
                lineWidth: 2
            }, {
                labels: {
                    align: 'right',
                    x: -3
                },
                height: '30%',
                offset: 0,
                lineWidth: 2
            },{
                labels: {
                    align: 'right',
                    x: -3
                },
                title: {
                    text: 'Pression'
                },
                top: '35%',
                height: '30%',
                offset: 0,
                lineWidth: 2,
                plotLines: [{
                value: 1015,
                width: 1,
                color: 'red',
                zIndex : 2,
            }],
            },{
                labels: {
                    align: 'right',
                    x: -3
                },
                title: {
                    text: 'Humidité'
                },
                top: '70%',
                height: '25%',
                offset: 0,
                lineWidth: 2
            },{
                labels: {
                    align: 'right',
                    x: -3
                },
                top: '70%',
                height: '25%',
                offset: 0,
                lineWidth: 2
            }],
            xAxis: {
                ordinal: false,
                alternateGridColor: '#F0FFFF'
            },
            tooltip: {
                    xDateFormat: '%a %d %b %H:%M'

                },
            plotOptions: {
                line: {
                    connectNulls: false
                        }
            },
            series: [{
                name: 'T° Intérieure',
                data: temp_int,
                tooltip: {
                    valueDecimals: 2,
                    valueSuffix:' °C'
                }
            }, {
                name: 'T° Extérieure',
                data: temp_ext,
                yAxis:0,
                tooltip: {
                    valueDecimals: 2,
                    valueSuffix:' °C'
                }
            },{
                name: 'Point de Rosée',
                data: rose,
                yAxis:0,
                tooltip: {
                    valueDecimals: 2,
                    valueSuffix:' °C'
                }
            },{
                name: 'Pression',
                data: pression,
                yAxis: 2,
                tooltip: {
                    valueDecimals: 0,
                    valueSuffix:' hPa'
                }
            },
            {
                name: 'Humidité intérieur',
                data: hum_int,
                yAxis: 3,
                tooltip: {
                    valueDecimals: 0,
                    valueSuffix:' %'
                }
            },{
                name: 'Humidité extérieur',
                data: hum_ext,
                yAxis: 3,
                tooltip: {
                    valueDecimals: 0,
                    valueSuffix:' %'
                }
            }]
        });
    });
});


</script>

<script src="http://code.highcharts.com/stock/highstock.js"></script>
<script src="http://code.highcharts.com/stock/modules/exporting.js"></script>
    </head>
    <body>

       <div id="container2" style="width: 50%; height: 95%; float: left; "></div>


    </body>
</html>

 

Publié le

Mes premiers pas avec mon Raspberry pi 2

Depuis la sortie du Raspberry Pi, je voulais m’en offrir un, mais je n’ai jamais sauté le pas.

Cette semaine je me suis enfin décidé et j’ai reçu hier mon Raspberry Pi 2 !

Bien entendu j’avais déjà un projet en tête quand je l’ai commandé : faire un serveur IOT avec EasyIOT.

 

Installation du Raspberry Pi :

Première étape, créer une carte micro SD avec le système Raspbian.

Je ne vais pas détailler ici comment j’ai créé la carte micro SD car la documentation est très bien faite.

Une fois la carte prête, direction le Raspberry Pi.

J’ai configuré mon Raspberry Pi sans écran (pratique de le configurer en se connectant par ssh depuis mon iMac).

 

Réglages initiaux :

Par défaut le nom d’utilisateur du Rasperry Pi est « pi » et le mot de passe « raspberry ».

Pour la connection ssh, il suffit de taper dans le terminal

ssh pi@192.168.1.66

(En remplaçant 192.168.1.66 par l’adresse ip du Raspberry Pi).

La première étape est de changer le mot de passe de l’utilisateur « pi » :

pi@raspberrypi ~ $ sudo raspi-config

La fenêtre de configuration s’affiche :

config

On se place sur le choix 2, on valide et :

Capture2

On valide et on se retrouve dans le shell. On tape le mot de passe on valide avec entrée, on le confirme avec entrée.

La première étape est finie !

On va voir maintenant comment installer EasyIOT !

 

Installation de EasyIOT :

Première chose à faire, aller faire un tout sur iot-playground.

Je pourrais vous dire de suivre le tuto, mais j’ai eu quelques galères donc autant les partager ici.

 

Téléchargement d’EasyIOT :

J’ai eu quelques soucis avec la version v0.9, donc j’ai décidé d’installer la version v0.8, il se télécharge ici.

Je l’ai extrait sur le bureau et direction le terminal :

imac-de-jean-pierre:~ jp$ cd Desktop/
imac-de-jean-pierre:Desktop jp$ tar cf easy.tar easyiot
imac-de-jean-pierre:Desktop jp$ sftp pi@192.168.1.66
pi@192.168.1.66's password:
Connected to 192.168.1.66.
sftp> put easy.tar
Uploading easy.tar to /home/pi/easy.tar
easy.tar                                      100% 4559KB   4.5MB/s   00:01
sftp> exit

Direction le terminal avec la connexion ssh ouverte (oui ce terminal on ne le ferme pas) :

pi@raspberrypi ~ $ tar xf easy.tar
pi@raspberrypi ~ $ rm easy.tar

On a ainsi extrait notre dossier et effacé notre archive.

 

Préparation avant la configuration d’EasyIOT :

Petit tour de nouveau dans la configuration du Raspberry Pi :

sudo raspi-config

Choix 8 « Advanced Options », choix A6 « SPI »

« Would you like the SPI interface to be enabled » => Yes.

On valide.

« Would you like the SPi kernel module to be loaded by default ? » => Yes

Si le système ne le demande pas, on fait un petit reboot :

sudo reboot

On va connecter un module NRF24L01+ au Raspberry Pi (je ne l’utilise pas encore, mais on va quand même le connecter).

Attention là aussi avec le tuto, le modèle du Raspberry pi présenté n’est pas un Pi 2.

Untitled Sketch_bb

Installation de MONO :

Allez on attaque l’installation de Mono :

sudo apt-get update
sudo apt-gat upgrade
sudo apt-get install mono-complete

Ca prend en gros 5 minutes, des fois moins.

Configuration de EasyIOT :

Première étape, on se place dans le dossier d’EasyIOT pour changer les permission de fichiers  :

cd /home/easyiot
sudo chown -R root log
sudo chmod -R 644 log
sudo chown -R root config
sudo chmod -R 644 config

Je rajoute une étape par rapport au tuto sur IOT Playground car sinon les mesures n’étaient pas sauvegardées dans la base de données :

sudo chown -R EasyIoTDatabase.sqlite

Pour nous simplifier la vie, on va lancer EasyIOT comme un service (il sera donc lancé au démarrage du Raspberry PI) :

On commence par télécharger l’archive easyiot

Un petit coup de sftp comme tout à l’heure pour l’envoyer sur le Raspberry Pi, on repasse sur la console ssh (note on est toujours dans le dossier easyiot) et :

sudo mv ../easyiot.tar /etc/init.d/
sudo tar xf /etc/init.d/easyiot
sudo rm easyiot.tar

Il ne nous reste plus qu’à terminer la configuration pour le lancement automatique :

sudo chmod +x /etc/init.d/easyiot
sudo chmod +x startup.sh
sudo update-rc.d easyiot defaults

On peut stopper et mettre en en route le service avec les commandes :

sudo /etc/init.d/easyiot stop

sudo /etc/init.d/easyiot start

A présent EasyIOT est installé sur le Raspberry Pi et fonctionnel.

Prochaine étape ajouter un capteur température !