Connection bluetooth entre Arduino et Raspberry Pi 3

100% Complete

Une connexion bluetooth permet la transmission d'informations dans les 2 sens. Il est donc possible d’envoyer des données issue d'un capteur et de recevoir des instruction de la part d'une application ou d'un "maitre".

Il faut

Arduino Uno + Capteur température & humidité + module Bluetooth
Raspberry Pi 3 (car contient du Bluetooth nativement)

Câblage Arduino

BLUETOOTH : connexion entre Arduino et Raspberry Pi

Programme Arduino

// ------------------------------------------------------------------
// Module Bluetooth
//      VCC : 5V
//      GND: GND
//      TX: 11
//      RX : 10
#include <SoftwareSerial.h>
#define pinBluetooth_rx 11 // Broche 11 en tant que RX, à raccorder sur TX du HC-05
#define pinBluetooth_tx 10 // Broche 10 en tant que TX, à raccorder sur RX du HC-05
SoftwareSerial SerialBluetooth(pinBluetooth_rx, pinBluetooth_tx);
// ------------------------------------------------------------------
// DHT11, ( Capteur Temperature + Humidité )
//      VCC: 5V or 3V
//      GND: GND
//      DATA: pinDHT11
#include <SimpleDHT.h>
int pinDHT11 = 6;
SimpleDHT11 dht11;
int err = SimpleDHTErrSuccess;
void setup() {
// INITIALISATION PORT SERIAL BLUETOOTH
pinMode(pinBluetooth_rx, INPUT);
pinMode(pinBluetooth_tx, OUTPUT);
SerialBluetooth.begin(9600);
// INITIALISATION CAPTEUR DHT11
pinMode(pinDHT11, INPUT_PULLUP);
Serial.begin(9600);
Serial.println("Attente du caractère 'm' pour afficher les données");
}
int command;
void loop() {
// when characters arrive over the serial port...
if (SerialBluetooth.available()) {
    command = SerialBluetooth.read();
    if ( command == '0' ) {
      // Lecture du capteur de temperature
      getTemperature();
    } else {
      Serial.println(command);
    }
}
}
void getTemperature() {
byte temperature = 0;
byte humidity = 0;
if ((err = dht11.read(pinDHT11, &temperature, &humidity, NULL)) != SimpleDHTErrSuccess) {
    // Si on n'arrive pas à lire les données.
    Serial.print("Read DHT11 failed, err="); Serial.println(err); delay(1000);
    return;
}
Serial.print((int)temperature);
Serial.print("°C, ");
Serial.print((int)humidity);
Serial.println("%");
SerialBluetooth.print((int)temperature);
SerialBluetooth.print(",");
SerialBluetooth.println((int)humidity);
}

On va lire les données du capteur de température et d'humidité et on les envoie sur le port série.

Configuration Raspberry Pi

Il est possible de faire l'appairage de l'Arduino en utilisant l'interface Graphique de Raspian mais du fait que l'accès à la Raspberry est souvent fait par SSH, nous ne détaillerons que l'installation en ligne de commande.

De base la version Raspbian contient un module de gestion Bluetooth, ceci dit si ce n'est pas le cas il est possible de le rajouter en tapant en ligne de commande :

sudo apt-get install bluetooth pi-bluetooth blueman

Vérification de l'install du manager bluetooth :

hciconfig

hci0:   Type: Primary Bus: UART
        BD Address: B8:27:EB:29:46:68 ACL MTU: 1021:8 SCO MTU: 64:1
        UP RUNNING
        RX bytes:1637 acl:0 sco:0 events:113 errors:0
        TX bytes:7976 acl:0 sco:0 commands:113 errors:0

hci0 > correspond à notre adaptateur Bluetooth

Lancement de la découverte des périphériques bluetooth (le module de l'Arduino) en utilisant l'interface de commande Bluetooth bluetoothctl :

bluetoothctl
[NEW] Controller B8:27:EB:29:46:68 raspberrypi [default]
[bluetooth]# agent on
Agent registered
[bluetooth]# power on
Changing power on succeeded
[bluetooth]# scan on
Discovery started
[CHG] Controller B8:27:EB:29:46:68 Discovering: yes
[NEW] Device 00:0E:EA:CF:22:8E 00-0E-EA-CF-22-8E
[CHG] Device 00:0E:EA:CF:22:8E LegacyPairing: no
[CHG] Device 20:17:04:24:91:15 Name: HC-05
...

20:17:04:24:91:15 correspond à l'identification du périphérique. On va utiliser cette identification par la suite (la votre peut bien évidement être différente).

Pour que la Raspberry puisse utiliser l'Arduino par la connexion bluetooth il est nécessaire de faire l'appairage du périphérique avec la commande :

[bluetooth]# pair 20:17:04:24:91:15
Attempting to pair with 20:17:04:24:91:15
[CHG] Device 20:17:04:24:91:15 Connected: yes
Request PIN code
[agent] Enter PIN code: 1234
[CHG] Device 20:17:04:24:91:15 UUIDs: 00001101-0000-1000-8000-00805f9b34fb
[CHG] Device 20:17:04:24:91:15 ServicesResolved: yes
[CHG] Device 20:17:04:24:91:15 Paired: yes
Pairing successful
[CHG] Device 20:17:04:24:91:15 ServicesResolved: no
[CHG] Device 20:17:04:24:91:15 Connected: no
[CHG] Device 20:17:04:24:91:15 RSSI: -73

Connexion à l'Arduino :

[bluetooth]# connect 20:17:04:24:91:15
Attempting to connect to 20:17:04:24:91:15
[CHG] Device 20:17:04:24:91:15 Connected: yes
[CHG] Device 20:17:04:24:91:15 ServicesResolved: yes

Vérification de l'appairage à l'Arduino :

[bluetooth]# info 20:17:04:24:91:15
Device 20:17:04:24:91:15
        Name: HC-05
        Alias: HC-05
        Class: 0x001f00
        Paired: yes
        Trusted: yes
        Blocked: no
        Connected: no
        LegacyPairing: yes
        UUID: Serial Port               (00001101-0000-1000-8000-00805f9b34fb)
        RSSI: -46

La ligne UUID indique que l'Arduino utilise un port série.
Il est possible d'avoir la liste des périphériques appairés en tapant la commande : paired-devices

Les deux périphériques sont maintenant associés. Cela signifie qu'il sont donc capable de communiquer en utilisant le Bluetooth, il reste encore à mettre en place un protocole de communication pour qu'ils puissent échanger des données comme sur un port série.

Reconnexion Bluetooth au reboot du Raspberry

La commande :

rfcomm connect 0 20:17:04:24:91:15 &

permet de connecter le module HT-50 à la Raspberry.

Afin de ne pas perdre la connexion bluetooth entre le raspberry Pi et le module HT-50 à chaque reboot, il faut rajouter dans la tache cron, on va créer un fichier de commande qui sera exécuté :

vi reconnectionBluetooth.sh

#/bin/sh
rfcomm connect 0 20:17:04:24:91:15 &

Dans les tâches cron de root, on rajoute :

sudo crontab -e

@reboot sh /home/pi/reconnectionBluetooth.sh

Mise en place d'un programme Python

Iinstallation des librairies "serial" et "bluez" sur la Raspberry Pi :

sudo apt-get install python-serial python-bluez

Le programme Python suivant permet d'envoyer une commande à notre Arduino pour faire clignoter la led :

vi bluetooth_serial_test.py

et taper les lignes :

#! /usr/bin/python
import serial
from time import sleep
bluetoothSerial = serial.Serial( "/dev/rfcomm0", baudrate=9600 )
# On envoie la commande de recuperation de temperature et humidite
bluetoothSerial.write( str("0") )
print bluetoothSerial.readline()

Execution du programme :

python bluetooth_serial_test.py

Magic mirror

80% Complete

Affichage des informations captées par les Arduino sur un écran dissimulé derrière un miroir.

Il faut

Raspberry Pi 3
Logiciel open source MagicMirror2

Montage

Je suis parti de la dimension de ma plaque de verre et j'ai construit virtuellement une boite autour en utilisant le logiciel Fusion 360 de Autodesk.

Conception 3D du boitier du mirroir dans Fusion 360 de Autodesk

La zone peinte en noir sera l'emplacement du mirroir.

Percage des montannt pour l'aération de l'écran et de la Raspberry Pi

Il y a de très forte chances pour que l'écran du magic mirror ne fasse pas exactement la dimension du mirroir, il est donc nécessaire d'ajouter des cales.

Peinture (à la bommbe) des cales pour ne pas qu'elles apparaissent en transparence sous la vitre.

Les bordures de l'écran n'y échappent pas non plus : il faut les peindre en noir

Pose du mirroir et test des emboitements des différentes pièces.

Il ne reste plus qu'à mettre le tout dans la douche...

Installation logiciel

L'installation de Magic mirror est un jeux d'enfant sur une version stretch_full de Raspian (pour une raspberry Pi3, donc).

Magic mirror à besoin d'une interface graphique de raspian, il faut donc faire l’installation complète, et non pas la version lite (pour ne pas à avoir toutes les librairies graphiques à ajouter par la suite à la main).

Installer la version complète de raspian sketch. Une fois l'install finalisée, selon les indications de Magic Mirror, il faut, dans une fenêtre en ligne de commande, taper l'auto-installation :

bash -c "$(curl -sL https://raw.githubusercontent.com/MichMich/MagicMirror/master/installers/raspberry.sh)"

Configuration MagicMirror

Le fichier de paramétrage de Magic Mirror se trouve dans le répertoire /home/pi/MagicMirror/config :

vi /home/pi/MagicMirror/config/config.js

Voir : https://github.com/MichMich/MagicMirror#modules

Affichage des informations envoyées par les Arduinos

A faire

Connexion d'une sonde DHT11 sur une Raspberry

100% Complete

Le branchement d'une sonde DHT11 sur une raspberry Pi 3 est très simple lorsqu'on prends le problème par le bon bout.

Il faut

Sonde DHT11 (environ 5€ chez Gotronic)

Câblage

Câblage d'une sonde DHT11 sur une raspberry Pi 3

Logiciel

Installer les librairies Adafruit et python :

git clone https://github.com/adafruit/Adafruit_Python_DHT.git

cd Adafruit_Python_DHT

sudo apt-get update

sudo apt-get install build-essential python-dev python-openssl

sudo python setup.py install

L'accès au GPio est obligatoirement à faire un sudo sur Raspberry.Test d'exemple avec un DHT11 branché sur le port gpio 4 :

cd /home/pi/Adafruit_Python_DHT/examples

./AdafruitDHT.py 11 4

Va retourner un truc dans le style :

Temp=20.0* Humidity=75.0%

Attention, la sonde ne répond qu'une fois par seconde.

Extinction de l'écran avec le Raspberry Pi

100% Complete

Le but est de couper physiquement l'alimentation de l'écran lorsque personne n'est devant, comme si on utilisait un interupteur.
Pour cela on va utiliser un détecteur PIR et un relais pour couper l'alimentation de l'écran.

Il faut

Capteur PIR
Relais
Raspberry Pi 3

Câblage

Câblage d'un capteur PIR et d'un Relais sur la raspberry Pi

Programme Python

Installation de l'environnement python (optionnel)

Plus exactement, de la dernière version de développement de Python et des paquets nécessaire (PGIO) en utilisant PIP :

sudo apt-get update

sudo apt-get install python-pip python-dev gcc

sudo pip install rpi.gpio

Le programme Python

Sur la pin 5 on branche le SIGnal du relais et sur la 11 le SIGnal du PIR.

Dans un fichier pirdetection.py écrire :

import RPi.GPIO as GPIO
import time

PinPIR = 11
PinRelay = 5
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(PinPIR, GPIO.IN)         #Read output from PIR motion sensor
GPIO.setup(PinRelay, GPIO.OUT)
while True:
       i=GPIO.input(PinPIR)     # Lecture de l'etat du PIR
       if i==0:
             GPIO.output(PinRelay, i) #Extinction de l'ecran
             time.sleep(0.1)
       elif i==1:               #When output from motion sensor is HIGH
             GPIO.output(PinRelay, i) #Allumage de l'ecran
             time.sleep(60 * 10)        # Wait for 10 minutes

Il faut maintenant que ce script Python soit exécuté en tâche de fond à chaque démarrage de la Raspberry. Pour cela :

sudo crontab -e

et rajouter en fin de fichier :

@reboot sudo python /home/pi/pirdetection.py > ~/pirdetection.log