Travaux Pratiques

Prog. Systèmes embarqués

Enseignant: M. Nejmeddine Bahri

 Sommaire

TP1: Programmation et compilation des programmes C et python

sous Linux

TP2: Gestion des entrées/sorties numériques de Raspberry

TP3: Gestion des entrées/sorties analogiques de Raspberry

TP4: Acquisition de la température/Humidité et affichage sur LCD

TP5: Gestion de la communication série (RS232/Bluetooth) avec

Raspberry: Application pour la domotique

TP6: Computer vision avec Raspberry

TP7: Raspberry et l'Internet des objets (Internet of Things IOT)

 TP1: Programmation et compilation des programmes C et
python sous Linux

I- Prise en main du Raspberry Pi

- Préparation de la carte SD
Télécharger Raspbian
Première étape, télécharger le système d’exploitation Raspbian. C’est totalement gratuit !
Pour ce faire, il suffit de se rendre sur le site officiel du Raspberry Pi dans la rubrique dédiée aux
téléchargements.

Installer Raspbian sur une carte SD depuis Windows

Une fois que vous avez récupéré l’archive ZIP de Raspbian, dé-zippez-la et vous obtiendrez un fichier
image.
Vous ne pourrez pas directement coller cette image sur votre carte SD. Il faudra auparavant utiliser un
logiciel pour installer correctement l’image de Raspbian.
Ainsi, nous allons utiliser celui qui est recommandé c’est à dire Win32 Disk Imager.

Dans « image file », sélectionnez le fichier image de Raspbian que vous avez téléchargé. Dans
« device », choisissez la lettre correspondant à votre lecteur de carte SD.
Cliquez sur Write et attendez quelques instants. Le logiciel va installer Raspbian sur votre carte SD.
Un message de confirmation apparaîtra une fois l’opération terminée.
Vous pouvez retirer la carte SD du lecteur. Raspbian est installé sur votre carte !

- Démarrage et authentification :
Brancher son Raspberry Pi
Ensuite, il est nécessaire de préparer les branchements de son Raspberry Pi afin qu’il puisse fonctionner.
Il a besoin d’alimentation électrique, d’une carte SD et d’autres périphériques facultatifs : clavier, souris,
réseau…

Pour certaines versions du Raspbian il faut taper au cours du démarrage: startx pour travailler en mode
graphique
Utilisateur : pi
Password : raspberry

Configurer Raspbian
Lorsque vous arrivez ici, normalement votre ordinateur a dû démarrer et afficher l’écran de
paramétrage de Raspbian.

On se retrouve face à un menu plutôt fourni permettant de configurer Raspbian :

 info : donne simplement des informations sur l’écran de paramétrage. Pas super utile.
 expand_rootfs : par défaut, la distribution utilisera seulement 2 GB d’espace sur la carte
SD. Si vous avez une carte avec plus d’espaces (4Go ou +), vous pouvez dire par cette
commande à Raspbian d’utiliser tout l’espace disponible sur la carte.
 overscan : utile pour modifier l’affichage afin qu’il s’adapte à du 16/9. Avec des écrans et
télé récentes, cette commande est inutile.
 configure_keyboard : pour configurer le clavier
 change_pass : pour changer le mot de passe de l’utilisateur par défaut (pi)
 change_locale : pour définir le jeu de caractères à utiliser
 change_timezone : pour afficher l’heure en fonction de sa zone géographique
 memory_split : pour répartir la mémoire physique entre le GPU (processeur graphique) et
le CPU (processeur). Par défaut, le GPU utilise 64Mo.
 overclock : permet d’augmenter la performance des processeurs et de la RAM en
augmentant leur cadence. Ces modifications peuvent réduire la durée de vie du micro-PC. 5
overclocking types sont prêts à l’emploi :

 ssh : pour activer le SSH. Déjà activé par défaut.

  boot_behaviour : pour indiquer si l’on souhaite utiliser le Pi en mode graphique ou en
mode texte.
 update : pour mettre à jour le système
Une fois que vous avez terminé, il ne vous reste plus qu’à sélectionner « Finish ».
Et voilà, vous devriez arriver sur le bureau de Raspbian !

Enfin, si vous souhaitez retrouver l’écran de paramétrage de Raspbian, il suffit de saisir cette
commande dans un terminal :

sudo raspi-config

- Clavier
Par défaut, le clavier (keyboard layout) est configuré pour les claviers UK (anglais/américain) sur les
différentes distributions pour Pi.

Il faut donc modifier le layout utilisé par le système. Les claviers Azerty se décline en deux layouts
très proches: le layout (FR) et le Layout (BE).
Pour modifier le layout:

sudo nano /etc/default/keyboard

Dans le fichier, Remplacez le "gb" par "fr" de façon à avoir la ligne suivante:

XKBLAYOUT="fr"

Réglage de l’heure :

sudo date 0413144917

Sat Apr 13 14:49:00 UTC 2017
 Reboot : Primordial sinon les changements ne prennent pas effet!

sudo reboot

- Mise à jour des paquets

Dans le terminal des commandes, tapez :

sudo apt-get update

sudo apt-get upgrade

Apt-get est un outil logiciel à utiliser en ligne de commande. Il permet d'effectuer l'installation et
la désinstallation de paquets en provenance d'un dépôt APT (serveurs qui contiennent un ensemble
de paquets).

L'option update met à jour la liste des fichiers disponibles dans les dépôts APT présents dans le
fichier de configuration /etc/apt/sources.list. L'exécuter régulièrement est une bonne pratique,
afin de maintenir à jour votre liste de paquets disponibles.

L'option upgrade met à jour tous les paquets installés sur le système vers les dernières versions
(couramment utilisé).

- Démarrage de Raspberry à distance en mode SSH

Démarrer Raspberry en mode SSH en utilisant le client SSH Putty.
 - Démarrage de Raspberry à distance en mode graphique
Travailler en mode graphique en utilisant le serveur/client VNC

- Programmation et compilation des applications C et python sous

Linux
En utilisant les commandes Linux sous le terminal de commandes:

1- Créer un dossier test sous le répertoire /home/pi.

2- Dans le dossier test, créer deux dossiers nommés respectivement source et header.
3- Dans le dossier source, créer deux fichiers: test.c et main.c.
4- Dans le dossier header, créer un fichier: test.h.
5- Dans le fichier test.c, écrire une fonction nommée calcul qui prend comme paramètre
un tableau T de 20 entiers et qui permet de déterminer et afficher le nombre de 0, le
nombre des entiers positifs et le nombre des entiers négatifs (0 est un entier positif).
6- Le fichier test.h contient la déclaration de la fonction calcul.
7- Dans le fichier main.c, remplir un tableau T de 20 entiers et l’afficher sur l’écran puis
faire appel à la fonction calcul.
8- Créer un fichier Makefile dans le dossier source comportant les instructions
nécessaires pour compiler cette application tout en générant le fichier objets .o pour
chaque fichier source .c.
9- Dans le même fichier Makefile, créer une cible nommée CLEAN qui permet de
supprimer tous les fichiers temporaires .o générés après la compilation.
10- Créer une autre cible nommée sup_exec qui permet de supprimer le fichier exécutable
généré après la compilation.
11- Au niveau du terminal, taper les commandes linux qui permettent de compiler et
exécuter cette application.
12- Utiliser les cibles CLEAN et sup-exec décrites dans le Makefile pour supprimer les
fichiers temporaires et le fichier exécutable générés.
13- Réécrire cette application mais cette fois en utilisant le langage PYTHON. Utiliser
deux fichiers: main.py et test.py.
14- Exécuter cette application sous le terminal en utilisant la commande Linux adéquate.
 TP2: Gestion des entrées sorties numérique de Raspberry

Objectif: programmer les entrées/sorties numériques de la carte Raspberry en utilisant le

langage python et C.

- Gestion d’une sortie (LED)

Montage :

Code :

Compilation et exécution :

sudo python nom_du_programme.py

Pour quitter « ctrl+c »

Si vous essayiez de ré-exécuter le programme une autre fois, un message de warning est affiché
« This channel is already in use »
Pour ignorer le message ajouter la ligne suivant au programme juste après l’import des bibliothèques :
« GPIO.setwarnings(False) ».
 - Programmation en C en utilisant la bibliothèque WiringPi:
Code :

 Enregistrer ce fichier sous le nom blink

avec l’extension .c (blink.c)

 Pour compiler taper dans LXterminal:

gcc -Wall -o blink blink.c –lwiringPi

 Pour l’exécuter taper:

sudo ./blink

- Acquisition d’une entrée (bouton poussoir)

Montage : Code :
 - PIR Motion Detector

Montage : Code :

- Contrôle GPIO avec Scratch

Comment contrôler les broches GPIO avec le Raspberry Pi en Scratch

Votre Raspberry Pi doit être connecté à Internet pour installer le logiciel mais la connexion n'est pas
nécessaire pour lancer ScratchGPIO.

sudo wget http://db.tt/jCIVXBJE -O /boot/install_scratch_gpio.sh

Ensuite, tapez et lancez :

sudo /boot/install_scratch_gpio.sh

Cela va installer tous les logiciels supplémentaires requis et quelques exemples simples.
Vous pouvez maintenant lancer l'i cône Scratch spéciale (Scratch GPIO) de votre bureau. C'est en fait
une version normale de Scratch, elle lance juste un petit programme Python en arrière-plan pour
communiquer avec le GPIO. Si d'autres programmes Python accédant au GPI O tournent déjà,
l'ouverture de Scratch GPIO peut planter votre Pi . Pour éviter cela, ouvrez une fenêtre LX Terminal et
lancez :

sudo killall python

Pour tester l'accès au GPIO dans Scratch, cliquez sur Fichier>Ouvrir et sélectionnez blink11 dans
/home/pi /Scratch. Une fois le programme chargé, cliquez sur le drapeau vert et votre LED devrait
clignoter : allumée 1 seconde, éteinte 2 secondes.

Modifier le programme pour allumer LED avec une touche de clavier :

Cliquer sur « controls » puis choisir « When Key pressed »

Placer-le au-dessus « forever »

Maintenant changer la touche pour activer le clignotement de la LED en cliquant sur « space »
 TP3: Gestion des entrées/sorties analogiques de Raspberry

Objectif: programmer les entrées/sorties analogiques de la carte Raspberry en utilisant le

langage python et C.

Analogue input :
Le Pi n'inclus pas de convertisseur Analogique/Digital mais un convertisseur ADC externe tel que le
MCP3008 peut être utilisé avec du code Python pour faire une lecture analogique en utilisant le
protocole SPI Serial Peripheral Interface.
Voici une liste de quelques entrées analogiques qui peuvent être lue avec ce montage:

 Un potentiomètre
 Une Photorésistance
 Un FSR (résistance sensible à la force) voir notre FSR et Flex Sensor.
 Un senseur de température comme le TMP36
Montage :
Les connexions entre le MCP3008 et le Raspberry Pi sont les suivantes:

MCP3008 VDD (pin 16) → Raspberry 3,3 V

MCP3008 VREF (pin 15) → Raspberry 3,3 V
MCP3008 AGND (pin 14) →; Raspberry GND
MCP3008 CLK (pin 13) → Raspberry SCLK
MCP3008 DOUT (pin 12) → Raspberry MISO
MCP3008 DIN (pin 11) → Raspberry MOSI
MCP3008 CS (pin 10) → Raspberry CE0
MCP3008 DGND (pin 9) → Raspberry GND
Brochage
SCLK - Broche 23 - GPIO #11 (aussi appelée "CLK")
MOSI - Broche 19 - GPIO #10
MISO - Broche 21 - GPIO #9
CE0 - Broche 24 - GPIO #8 (aussi appelée "CS0")
CE1 - Broche 26 - GPIO #7 (aussi appelée "CS1")
Configuration SPI :
Sélectionner “Advanced Options” choisir “SPI”
Une fenêtre vous demande si vous voulez activer l’interface ARM SPI :
Sélectionner “Yes”  puis “Ok”
Sélectionner “Finish”  redémarrer la raspberry PI  SPI est activé
Installation de la bibliothèque SPI SPIdev :

sudo apt-get install python-dev

mkdir python-spi
cd python-spi
git clone https://github.com/doceme/py-spidev.git
cd py-spidev
sudo python setup.py install

Le code : lecture de la valeur lue sur la voie CH0 du CAN MCP3008

- PWM
La modulation de largeur d'impulsions (MLI ; en anglais : Pulse Width Modulation, soit PWM), est une
technique couramment utilisée pour synthétiser des signaux continus à l'aide des circuits à
fonctionnement tout ou rien, ou plus généralement à états discrets.
Remarque :
Pour raspberry il y’a deux types de PWM : Hardware PWM et Software PWM
- Hardware PWM : pin GPIO12
- Software PWM : avec programmation de n’importe quel pin à travers la bibliothèque RPi.GPIO

- Varier l’intensité de l’éclairement d’une LED branchée sur GPIO11.

Code :

- p = GPIO.PWM(11, 50) # active GPIO11 en mode

PWM avec la fréquence 50Hz sous le nom “p”
- p.start(5) # démarrer la génération de pwm avec
dutyCycle = 5%
- p.ChangeDutyCycle(10) # changer DutyCycle 10%
- time.sleep(3)
- p.stop() # arreter le génération de pwm
- GPIO.cleanup() # désactiver tt les GPIO

- Controller un moteur DC
Les ponts en H
Pour quoi l'utiliser ?
Les fonctions du pont en H sont :
 fournir de forts courants aux moteurs en permettant leur contrôle par le microcontrôleur.
 pouvoir inverser la tension aux bornes du moteur pour inverser le sens de rotation.
 Controller un moteur pas à pas (stepper motor)

Code :
 - Servo motors

Le principe
Pour commander un servomoteur, il faut lui envoyer une impulsion comprise entre 1 ms et 2 ms, répéter
cette impulsion toutes les 20 ms pour maintenir l'axe du servomoteur en position.
La position neutre du servomoteur correspond à une impulsion de 1,5 ms.
- 1ms : -90° en angle de sortie
- 1.5ms : 0° en angle de sortie
- 2ms : +90° en angle de sortie
Le déplacement angulaire total est de 180°.

Montage et code
 - Exécuter plus d'un programme de contrôle au même temps

Code1 : Code2 :

Exécuter les deux programme en ajoutant le symbole & à la fin de chaque ligne

sudo python blink1.py &

sudo python blink2.py &

On vous renvoie les informations.

[1] : c'est le numéro du processus en arrière-plan.
2577 : c'est le numéro d'identification général du processus.
Cette information vous permet de tuer le processus avec kill si nécessaire.

sudo kill 2577

sudo kill 2579

Autre méthode sans numéro d’identification :

sudo killall sudo python blink1.py

 - Auto Start dans Raspberry Pi

Exécuter un script après la connexion

Comment exécuter automatiquement un script après la connexion.

Étape 1: Ouvrez une session de terminal et modifier le fichier /etc/profile

sudo nano /etc/profile

Étape 2: Ajoutez le nom et le chemin de votre script suivit de & à la fin du fichier

sudo python /home/pi/python_programme_1.py &

sudo python /home/pi/python_programme_2.py &
/home/pi/your_programe_1.sh &
/home/pi/your_programe_2.sh &

Exemple : Programme_1.sh
#!/bin/sh
cd home/pi/
sudo python your_python_sript.py &
exit 0
cd /

Étape 3: Enregistrer et quitter

 TP4: Acquisition de la température/Humidité et affichage sur
LCD

Objectif: Acquisition d'une grandeur physique( Température) et affichage sur un LCD

Matériel

 Raspberry Pi
 Un capteur de temperature et humidité DHT11
 Un afficheur LCD 16x2
 Un potentiomètre
Montage :

Réaliser le montage de la figure ci-dessous

Configuration du l'afficheur LCD

##### Télécharger la bibliothèque Adafruit_Python_CharLCD

https://github.com/adafruit/Adafruit_Python_CharLCD

#####Installer les dépendances suivantes:

sudo apt-get update
sudo apt-get install build-essential python-dev python-smbus
python-pip

#####Installer l bibliothèque RPi.GPIO:

sudo pip install RPi.GPIO

#####Exécuter la commande suivante

sudo python setup.py install

Configuration du capteur DHT11

##### Télécharger la bibliothèque Adafruit_Python_DHT

https://github.com/adafruit/Adafruit_Python_DHT

#####Installer les dépendances suivantes:

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

#####Exécuter la commande suivante

sudo python setup.py install

Le code

import sys
import time
import Adafruit_DHT
import Adafruit_CharLCD as LCD

# Raspberry Pi pin configuration:

lcd_rs = 27 # Note this might need to be changed to 21
for older revision Pi's.
lcd_en = 22
lcd_d4 = 25
lcd_d5 = 24
lcd_d6 = 23
lcd_d7 = 18
#lcd_backlight = 4

# Define LCD column and row size for 16x2 LCD.

lcd_columns = 16
lcd_rows = 2
# Initialize the LCD using the pins above.
lcd = LCD.Adafruit_CharLCD(lcd_rs, lcd_en, lcd_d4, lcd_d5,
lcd_d6, lcd_d7,
lcd_columns, lcd_rows)

# Define DHT sensor type and RPi pin connected to data pin of
the sensor.
sensor = Adafruit_DHT.DHT11
pin = 17
lcd.set_cursor(3,0)
lcd.message("hello Nejmeddine")
print "hello pi"
time.sleep(1)
while 1:
# Try to grab a sensor reading. Use the read_retry method
which will retry up
# to 15 times to get a sensor reading (waiting 2 seconds
between each retry).
humidity, temperature = Adafruit_DHT.read_retry(sensor,
pin)

# Un-comment the line below to convert the temperature to

Fahrenheit.
# temperature = temperature * 9/5.0 + 32

if humidity is not None and temperature is not None:

print('Temp={0:0.1f} °C
Humidity={1:0.1f}%'.format(temperature, humidity))
lcd.clear()
lcd.set_cursor(2,0)
lcd.message('Temp={0:0.1f} C \n
Humidity={1:0.1f}%'.format(temperature, humidity))
else:
print('Failed to get reading. Try again!')
sys.exit(1)
 TP5: Gestion de la communication série avec Raspberry:
Application pour la domotique

- Interface RS-232 :
Les UART (Universal Asynchronous Receiver Transmitter) assurent l’émission et la réception
asynchrone.
Sur le Raspberry Pi, les niveaux sont 0v, 3.3v, TXD : Port GPIO14, RXD : Port GPIO15
Par défaut l’UART du Raspberry Pi sert de port de débug pour Linux.
Libérer l’UART du mode debug

1ère méthode:

Executer la commande sudo raspi-config et aller vers advanced options -> serial. Choisir disabled. 
/dev/ttyAMA0 est maintenant un port Linux libre

2ème méthode:

Empêcher l’émission de messages du Kernel et l’activation du mode debugging sur l’UART

Sudo nano /boot/cmdline.txt

Supprimer :

console=ttyAMA0,115200 kgdboc=ttyAMA0,115200

Enregistrer et redémarrer :

sudo reboot

/dev/ttyAMA0 est maintenant un port Linux libre

Test de connexion

Récupérer la bibliothèque Python

sudo apt-get install python-serial

Exemple 1 : demoUART.py

import serial

port = serial.Serial("/dev/ttyAMA0", baudrate=115200,

timeout=3.0)
# le programme redemarre toutes les 3s

while True:
port.write("\r\nEcrire quelque chose:")
rcv = port.read(10) # lit 10 caracteres
port.write("\r\nVous avez ecrit :" + repr(rcv))
# l’appel de la function repr() n’est pas indispensable

Exemple 2: utilisation de l’UART ; programmation en langagge C avec WiringPi:

Teste du port série :

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <wiringPi.h>
#include <wiringSerial.h>
int main ()
{
int i=0;
int fd ;
int nb_char=0;
char donnee;
fd = serialOpen ("/dev/ttyAMA0", 9600); // configuration et
ouverture du port serie
if (wiringPiSetup () == -1)
{
fprintf (stdout, "oops: %s\n", strerror (errno)) ;
return 1 ;
}
while (i<10)
{
printf ("nombre envoye -> %02d\n", i) ; // affiche
sur le terminal le nombre qui va être envoyé
serialPutchar (fd, i) ; // envoi via TX le nombre i
delay(100); // attente de 100 ms
donnee = serialGetchar (fd); // récupération du
caractère
printf ("nombre recu ->%02d\n\n", donnee) ; //
affichage du caractere recu
i++; // incrémentation de i;
}
serialClose (fd); // fermeture du port série;
return 0 ;
}
Sur la carte raspberry Pi, relier les pattes Rx et Tx du GPIO afin de recevoir les données envoyées, cela
permet de tester le fonctionnement sans utiliser un autre périphérique. Compiler et exécuter le code
présenté ci-dessus.

- Utilisation du module Bluetooth HC05 :

Matériel:

 Raspberry Pi,
 Module Bluetooth HC05
 Smartphone
 Application Android
 led et resistance

Connexion de HC05 avec la Raspberry Pi

Raspberry Pins | Bluetooth Pins

RX (Pin 10) ———> TX
TX (Pin 8) ———> RX
5V ———> VCC
GND ———> GND
Installation de l'application Android Led-controller.apk

Télécharger l'application Led-Controller à partir de ce lien et l'installer sur votre Smartphone.

https://github.com/Mayoogh/Arduino-Bluetooth-Basic

Le programme:

Exécuter ce programme sur la carte Raspberry.

import serial
import RPi.GPIO as GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(40, GPIO.OUT)

serialPort = serial.Serial("/dev/ttyAMA0", 9600, timeout = 2)

while True:
data = serialPort.read(1) #lire 1 octet
if (data == "0"):
GPIO.output(40, 0)
print("led eteinte\n")
if (data == "1"):
GPIO.output(40, 1)
print("led alumee\n")

Associez votre appareil au module Bluetooth HC05 et par la suite appuyer sur ON/OFF au niveau de
l'application Android. L'état de la Led branchée sur la pin 40 doit être changé.
 - Utilisation du module Bluetooth intégré pour Raspberry Pi3 :
La carte Raspberry PI3 intègre un module Bluetooth intégré. Dans ce cas, HC05 ou HC06 ne sera plus
utile. On peut directement travaille avec le Bluetooth intégré.

Configuration du Bluetooth intégré

Installer les dépendances ci-dessous:

sudo apt-get update

sudo apt-get install python-pip python-dev ipython
sudo apt-get install bluetooth libbluetooth-dev
sudo pip install pybluez
sudo apt-get install -y libusb-dev libdbus-1-dev libglib2.0-
dev libudev-dev libical-dev libreadline-dev
sudo apt-get install pi-bluetooth
sudo apt-get install bluetooth bluez blueman

Le programme

Exécuter ce programme sur la carte Raspberry.

import bluetooth
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(40, GPIO.OUT)
GPIO.setwarnings(False)

server_socket = bluetooth.BluetoothSocket(bluetooth.RFCOMM)

port = 1
server_socket.bind(("", port))
server_socket.listen(1)

client_socket, address = server_socket.accept()

print "Accepted connection from ", address
try:
while 1:
data = client_socket.recv(1024)
print "Received: %s" % data
if (data == "0"):
GPIO.output(40, 0)
if (data == "1"):
GPIO.output(40, 0)

finally:
print("Cleaning Up!")
GPIO.cleanup()
client_socket.close()
server_socket.close()
L'application Android BlueTerm

1. Télécharger l'application Android BlueTerm et l'installer sur votre Smartphone à partir de Play
store
2. Associez votre appareil avec le Bluetooth de Raspberry

Lancer l'exécution en écrivant au niveau de l'application le caractère '1' ou '0' pour allumer ou éteindre la
Led branchée sur la pin 40 de la carte Raspberry.
 TP6: Computer Vision avec Raspberry

Computer Vision
- Utilisation d’une USB webcam standard:
Tout d'abord, installez le paquet fswebcam:

sudo apt-get install fswebcam

Entrez la commande de fswebcam suivi par un nom de fichier, et une photo sera prise avec la webcam,
et enregistré dans le fichier spécifié:

fswebcam image.jpg

Cette commande affiche les informations suivantes:

--- Opening /dev/video0...

Trying source module v4l2...
/dev/video0 opened.
No input was specified, using the first.
Adjusting resolution from 384x288 to 352x288.
--- Capturing frame...
Corrupt JPEG data: 2 extraneous bytes before marker 0xd4
Captured frame in 0.00 seconds.
--- Processing captured image...
Writing JPEG image to 'image.jpg'.

Préciser la résolution

La webcam utilisée dans cet exemple a une résolution de 1280x720. Afin de spécifier la résolution que
je veux, utilisez l'option -r:

fswebcam –r 1280x720 image2.jpg

Pas de bannière :

fswebcam -r 1280x720 --no-banner image3.jpg

Pour arrêter fswebcam:

pkill fswebcam
 - Serveur webcam avec motion: video streaming
Motion est un système de surveillance assez complet. Il est extrêmement personnalisable : détection de
mouvement, enregistrement image par image, enregistrement vidéo, etc.. Son installation est aussi
simple que précédemment :

# sudo apt-get install motion

On va s’intéresser maintenant au fichier de configuration :

# sudo nano /etc/motion/motion.conf

Modifiez motion.conf en fonction de vos besoins. Pour ma part, j'ai modifié uniquement ces lignes :

daemon on
process_id_file /home/pi/motion/motion.pid
width 640
height 480
webcam_quality 75
webcam_motion on
webcam_localhost off

Le daemon (service) motion est désactivé par défaut, pour l'autoriser :

# sudo nano /etc/default/motion // modifier

start_motion_daemon=yes

Un redémarrage est nécessaire

sudo reboot

Puis démarrer motion :

# motion

La mise en service de base est faite, le flux de la webcam se fait en pointant sur http://ip_du_RPi:8081
 - OpenCV
(Open Computer Vision) est une bibliothèque graphique libre, spécialisée dans le traitement d'images et
vidéos, calculs matriciels et les algorithmes d’apprentissage etc.
L'installation d'OpenCV pour Python

sudo apt-get install –y python-opencv

sudo apt-get install –y libcv-dev libopencv-dev libcv2.3
opencv-doc

test de la lib openCV :

git clone https://github.com/mvartani76/RPi-OpenCV-Face-Rec-

Python.git
cd RPi-OpenCV-Face-Rec-Python »
python test_python_openCV.py »

Résultat:

Reconnaissance faciale en python:

Dans le même dossier RPi-OpenCV-Face-Rec-Python
Tapez dans le terminal la commande:

python fd_python_openCV.py --cascade=face.xml 0

Traitement de vidéo avec OpenCV:
Taper le code python ci-dessous et déterminer quelles sont les différentes fonctions traitées par ce
programmes en analysant les vidéos affichées sur l'écran.

import numpy as np
import cv2,cv
port=0
capture = cv2.VideoCapture(port) #read the video
#capture = cv2.VideoCapture('output3.avi') #read the video
capture.set(3,320.0) #set the size
capture.set(4,240.0) #set the size
capture.set(5,15) #set the frame rate
#define the codec and create video writer object
fourcc=cv2.cv.FOURCC(*'XVID')
out=cv2.VideoWriter('output.avi',fourcc,20.0,(320,240))

while (capture.isOpened()):
flag, frame = capture.read() #read the video in frames
if flag==True:

gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)#convert each frame

to grayscale.
blur=cv2.GaussianBlur(gray,(5,5),0)#blur the
grayscale image

th_max,th_img=cv2.threshold(gray,0,255,cv2.THRESH_BINARY+cv2.T
HRESH_OTSU)
th_min=0.5*th_max
edge=cv2.Canny(gray,th_max,th_min)
#frame=cv2.flip(frame,0) #inverser l'image
cv2.imshow('frame_rgb',frame) #show video
cv2.imshow('grayscale',gray) #show video
cv2.imshow('filter',blur) #show video
cv2.imshow('edges',edge) #show video
out.write(frame) #save video
cv2.waitKey(1)
else:
capture.release()
out.release()
cv2.destroyAllWindows()
 TP6: Raspberry et l'Internet des objet: IOT

Internet des objets

L'internet des objets est « un réseau de réseaux qui permet, via des systèmes d’identification
électronique normalisés et sans fil, d’identifier et de communiquer numériquement avec des objets
physiques afin de pouvoir mesurer et échanger des données entre les mondes physiques et virtuels.
- WebIOPi
Webiopi est une application web qui permet de contrôler les broches GPIO du raspberry depuis une
interface web. L’interface permet ainsi de changer l’état d’une broche de « IN » à « OUT » ou
inversement comme l’image ci-dessous.

Pour modifier les états, il faut :

Cliquer sur la touche OUT > IN pour changer de direction GPIO .
Cliquer sur la broche pour changer l’état de sortie GPIO .

Installation

wget http://sourceforge.net/projects/webiopi/files/WebIOPi-
0.7.0.tar.gz
tar xvzf WebIOPi-0.7.0.tar.gz
cd WebIOPi-0.7.0
sudo ./setup.sh

Démarrer/Arrêter le service :

$ sudo python -m webiopi

Ou
sudo /etc/init.d/webiopi start
sudo /etc/init.d/webiopi stop

Démarrer WebIOPi au démarrage du système :

sudo update-rc.d webiopi defaults

sudo reboot
 Modifier le port HTTP :

On se déplace dans le répertoire du soft.

cd /etc/webiopi/config

Puis il vous suffit de remplacer la ligne correspondant au port souhaité :

[HTTP]
[HTTP]
enabled = true
port = 8000
passwd-file = /etc/webiopi/passwd
doc-root = /home/pi/webiopi/examples/scripts/macros
welcome-file = index.html

Première utilisation

Ouvrez un navigateur sur une machine de votre réseau, tapez l'URL http://[IP]:8000/webiopi/, ou utilisez
localhost sur votre Pi si vous avez un clavier et un écran connectés dessus. Vous serez alors invité à vous
connecter, l'utilisateur par défaut est webiopi et le mot de passe est raspberry.
Vous devriez alors accéder à la page suivante :

Une fois sur l’interface web, il vous suffit de choisir le lien d’en-tête GPIO sur la page principale:
Avec cet écran par défaut, vous pouvez modifier les fonctions du GPIO d'entrée à sortie, et changer l'état
des broches. Il suffit de cliquer sur les boutons IN/OUT, et sur chaque broche pour changer son état
lorsqu' elle est réglée en sortie.
- SERVEUR WEB
L’ordinateur Raspberry Pi est connecté en réseau par un connecteur Ethernet et/ou une liaison WIFI. Il
peut devenir un serveur WEB permettant le contrôle distant de processus ou la transmission à distance
des données à travers Internet.

Exemple1 : Commander des LED connectées sur Raspberry Pi via une page
web en utilisant le serveur web Apache

Suivez les instructions présentées dans le lien ci-dessous:

http://www.framboise314.fr/une-interface-web-simple-et-intuitive-pour-le-raspberry-pi-12/

1) Installation du serveur Appache et l’interpréteur php

sudo apt-get update && sudo apt-get upgrade

sudo apt-get install apache2 php5 libapache2-mod-php5

2) Donner des droits au dossier d’apache

Ceci permettra de facilement administrer les sites. Pour cela, lancez les commandes suivantes :

sudo chown -R pi:www-data /var/www/

sudo chmod -R 770 /var/www/

3) Création de l’interface web

4) Réaliser le montage suivant

5) Aller dans le dossier /var/www et remplacer le
fichier index.html par le fichier index.php donné
avec l’exercice et copier tout le contenu du dossier
fournir dans /var/www

6) Tapez l’adresse ip de votre raspberry Pi sur un

navigateur web et la page web sera affichée.
Enjoy !!!!

Exemple2 : Commander une LED branchée sur le gpio4 du Raspberry Pi via une page
web en utilisant le module webpy

Le module webpy contient un serveur web interne.

Suivez les instructions présentées dans ce lien :
https://itechnofrance.wordpress.com/2013/02/04/piloter-les-ports-gpio-partir-dun-
navigateur-internet/

Procédure de création d’un site WEB avec webpy

Télécharger et installer le module

wget http://webpy.org/static/web.py-0.37.tar.gz
tar -xzvf web.py-0.37.tar.gz (décompression)
cd web.py-0.37
sudo python setup.py install

Maintenant il va falloir créer une arborescence :

cd / (racine)
mkdir webpyserver (le dossier du serveur)
cd /webpyserver
mkdir templates (contiendra les pages html dont index.html
mkdir static (feuille de style CSS éventuelle)
Le dossier webpyserver contiendra le fichier Python à exécuter; le dossier webpyserver/templates
contiendra une page HTML et le dossier webpyserver/static contiendra une feuille de style au format
CSS.
Réalisation du site WEB
Dans le dossier webpyserver, créér le fichier gpio4.py
Ce programme récupère les données des GPIO et gère l’interface homme-machine de la page Web.

#!/usr/bin/env python
import web
import RPi.GPIO as GPIO
from web import form
# definit GPIO4 en sortie
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT)
# definit la page de nom index pour le site web
urls = (‘/’, ‘index’)
dossier_web = web.template.render(‘templates’)
app = web.application(urls, globals())
# definit les boutons a afficher
ma_forme = form.Form(
form.Button("btn", id = "btnon", value = "on", html = "On", class_ = "bouton_on"),
form.Button("btn", id = "btnoff", value = "off", html = "Off", class_ = "bouton_off")
)
# definit l action a effectuer quand la page index est appelee
class index:
# utilise quand la page est demandee
def GET(self):
forme = ma_forme()
return dossier_web.index(forme, "Raspberry Pi control GPIO4")
 # utilise quand une forme web est soumise
def POST(self):
userdata = web.input()
if userdata.btn == "on":
GPIO.output(4,True) # Allume la LED
if userdata.btn == "off":
GPIO.output(4,False) # Eteind la LED
# recharge la page web
raise web.seeother(‘/’)
# programme
if __name__ == ‘__main__’:
app.run()

Dans le sous dossier templates créer le fichier index.html C’est la page html d’accueil du site Web, elle
est ici simplifiée au maximum.

$def with (form, title)

<!doctype html>
<html>
<head>
<title>$title</title>
</head>

<body>
<br />
<form class="form" method="post">
$:form.render()
</form>
</body>
</html>

Maintenant il suffit de lancer la commande python gpio4.py pour démarrer le serveur Web, puis à partir
d’un navigateur, taper l’adresse IP du Raspberry en utilisant le port 8080
ip : XXX.XXX.XXX.XXX :8080
; voilà le résultat

- Firebase
Firebase est une plate-forme de développement d' applications Web et mobiles développée par
Firebase en 2011, puis acquise par Google en 2014.

Firebase fournit une base de données en temps réel et un backend en tant que service. Le service
fournit aux développeurs d'applications une API qui permet aux données d'application d'être
synchronisées entre les clients et stockées sur le cloud de Firebase.

Cette base de données temps réel peut être exploitée dans le domaine de l'IOT pour lire/écrire l'état
des capteurs/actionneurs ainsi que stocker en temps réel des grandeurs physiques telles que la
température, l'humidité, la pression etc...

NB: Il faut avoir un compte Gmail pour s'inscrire et avoir un compte sur cette base.

Programme pour enregistrer les valeurs de la température et l'humidité lues à

partir du capteur DHT11 dans la base temps réel de FIrebase.

import RPi.GPIO as GPIO

import time
import sys
import Adafruit_DHT

sensor = Adafruit_DHT.DHT11
pin = 17
firebase = firebase.FirebaseApplication('https://smarthome-b93d0.firebaseio.com/', None)
while True:

humidity, temperature = Adafruit_DHT.read_retry(sensor, pin)

 if humidity is not None and temperature is not None:
print('Temp={0:0.1f}* Humidity={1:0.1f}%'.format(temperature, humidity))
put1= firebase.put('salon','/humidity', humidity)
put2= firebase.put('salon','/temperature', temperature)

else:
print('Failed to get reading. Try again!')
sys.exit(1)

Programme pour commander des lampes en lisant la valeur/état de chaque lampe

à partir de la base de Firebase.

Pour commander les lampes, l'utilisateur peut modifier la base en changeant le 0 par 1 et le 1 par 0 pour
chaque lampe.

from firebase import firebase

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BOARD)
GPIO.setwarnings(False)

GPIO.setup(11,GPIO.OUT)
GPIO.setup(12,GPIO.OUT)
GPIO.setup(13,GPIO.OUT)

firebase = firebase.FirebaseApplication('https://smarthome-3b867.firebaseio.com/', None)

while True:
led1=firebase.get('/chambre/lampe1', None)
led2=firebase.get('/chambre/lampe2', None)
led3=firebase.get('/cuisine/lampe', None)

print led1,led2,led3
GPIO.output(11,led1)
GPIO.output(12,led2)
GPIO.output(13,led3)