Raspberry Pi 3 B+
S'abrègera  "rpi" par la suite

par Michel Vonlanthen HB9AFO

Mis à jour le  8 décembre 2018

 

Description de la mise en route de la Framboise (rapsberry en anglais) à l'occasion d'un cours que j'ai récemment suivi au Microclub Lausanne. Le but initial était de me familiariser avec Linux et, sous cet aspect, c'est plutôt réussi. Mais ce n'est pas de la tarte d'où mon envie de relater mes heurs et malheurs afin d'enlever les ronces sous les pieds de mes copains qui voudront aussi s'y mettre. Ce qui suit est donc dérivé des notes que j'ai prises et du support du cours donné par Yves Masur au Microclub Lausanne en novembre-décembre 2018. Je le remercie très sincèrement  de m'avoir ainsi permis de faire mes premiers pas en Linux sur le Rasperry Pi.  

ATTENTION: A ce stade, le texte qui suit n'est qu'un pense-bête que j'ai écrit au fur et à mesure de ma fréquentation du cours et pas un cours de Raspberry Pi ou de Linux à proprement parler. Une fois le cours "digéré", il est possible que je le re-écrive afin qu'il soit vraiment lisible par un néophyte.  Après chaque séance de cours, j'ai cependant refait toutes les manips décrites par ce texte et je peux assurer qu'elles fonctionnent.

 

Data sheet (PDF en anglais)
 

  • Carte mère Raspberry Pi 3 type B+
  • Processeur Broadcom BCM2837B0 Cortex-A53 64-bit SoC @ 1,4 GHz
  • Mémoire: 1 Go LPDDR2 SDRAM
  • Connexions sans fil : Bluetooth 4.2 BLE, Wi-Fi Dual Band b/g/n/ac
  • Connexion filaire: Gigabit Ethernet
  • Décodage et encodage H.264 1080p30
  • Support PoE (PoE HAT non fourni)
  • Lecteur de carte micro-SD
  • Header GPIO 40 broches
  • Support du boot PXE
  • Port caméra CSI pour connecter la caméra Raspberry Pi
  • Port d'affichage DSI pour connecter l'écran tactile Raspberry Pi
  • 4 x USB 2.0
  • Compatible avec les accessoires du Pi 3 Model B
  • Alimentation: 5V / 2.5A max (0,5A à vide)

 

On peut l'acheter partout, et même chez Interdiscount pour 39,95 Fr!

Caractéristiques en français sur le site LDLC

Ce qui a changé

 

Pinout GPIO en détail

 

 

 


1. Préparation de la mémoire

 

La carte mémoire (32GB de préférence) doit être chargée avec le système d'exploitation du Raspberry Pi, Linux. Pour ma part, j'ai reçu la carte déjà chargée avec le système Raspian Stretch. Pour le faire soi-même:

 

  1. Télécharger l'image de Raspbian Stretch ici: https://www.raspberrypi.org/downloads/raspbian/
    On peut télécharger 3 versons différentes, la Lite, la minimum, la Stretch et la Full. Les trois conviennent mais prendre la Stretch de préférence, elle suffira largement à nos besoins.
     

  2. Dézipper dans le répertoire courant C:\users\nom d'utilisateur\téléchargements 
    Cela nous donne l'image à charger sur le rpi: 2018-11-13-raspbian-stretch.img
     

  3. Lancer Win32 Disk Imager télécharger ici si ce n'est pas encore fait + l'installer).
    Donner "Fichier image", le nom de l'image (fichier) à écrire sur la mémoire, dans mon cas "2018-11-13-raspbian-stretch.img" et celle de la mémoire à flasher ("F:" dans  mon cas) et cliquer sur "Ecrire".
    L'écriture dure 3-4 minutes et une partition nommée "boot" est créée sur la mémoire. A la fin on obtient "Ecriture réussie".

    Attention: Le programme va ensuite vous proposer de formater la carte: NE PAS LE FAIRE ! La carte contient du Linux, raison pour laquelle Windows n'arrive pas à la lire et propose de la formater.




     

  4. Ensuite on peut lancer Windows Explorateur afin d'examiner le contenu de la mémoire.
    On voit qu'il y a une partition appelée "Boot", avec une une foule de fichiers à l'intérieur. 
     

  5. Il faut ensuite créer  un fichier vide appelé "SSH" (sans extension) dans la partition \boot, au moyen de la console Windows. Pour cela, aller dans la partition appelée "Boot" de la mémoire en tapant F: (ou autre si votre carte porte un autre numéro, à voir avec Windows Explorer). Puis taper: echo . >ssh :

     

    Microsoft Windows [version 10.0.17134.407]
    (c) 2018 Microsoft Corporation. Tous droits réservés.

    C:\Users\VON>F:

    F:\>echo . >ssh


    Le fichier "SSH" (sans extension) est créé dans la partition "Boot". Il sera automatiquement effacé lors du  premier démarrage.  Ensuite insérer la mémoire dans son emplacement sur la carte Raspberry Pi en ayant au préalable mis ce dernier hors tension (précaution habituelle à prendre).

 

Attention:

Ne jamais retirer la carte mémoire alors que le rpi est sous tension sous peine de la détruire irrémédiablement. Prendre la même précaution avec le PC: ne retirer la carte lue, par exemple, sur un port USB qu'après avoir invoqué la procédure d'extraction des périphériques USB en cliquant sur l'icône  (en bas à droite sur le bureau de Windows)


2. Préparation du PC

 

Une seule chose  à faire: partager la connexion Wi-fi. Ceci pour que le Raspberry Pi puisse accéder à Internet.

 

Attention, quelquefois le partage se désactive sans raison apparente. Si la liaison avec le rpi est interrompue, commencez par contrôler ce point!

Pour cela, il faut aller dans les "Paramètres" en cliquant, avec le bouton droit de la souris, sur l'icône   de la barre  des tâches. Ensuite sélectionner "Paramètres", puis "Réseau et Internet" et sur "Wi-fi". A droite il y a "Paramètres associés". Cliquez sur "Modifier les options d'adaptateur". On obtient ceci:
 

 


(Le bas de la fenêtre est coupé)

 

Sélectionnez "Wi-fi" et demandez les propriétés (bouton droit de la souris). Ensuite sélectionnez "Partage" et vous obtenez ceci:

 

 

 

Si elle n'y est pas, cochez la croix du haut et laissez vide celle du bas, comme sur la figure ci-dessus. Ensuite cliquez sur "OK" et revenez au bureau.

D'autres chemins sont possibles pour arriver à la carte Wi-fi, notamment en cliquant sur l'icône , puis  sur "Paramètres réseau et Internet".

 


3. Mise en route physique

 

  1. Il faut tout d'abord alimenter la carte au moyen par la prise micro USB. La consommat4ion à vide est de 400mA environ ce qui permet d'utiliser une prise USB d'un PC ou notebook. Par la suite, il sera nécessaire d'utiliser une alimentation externe capable de délivrer 2,5A.
     

  2. Relier  la carte au PC par l'intermédiaire d'un câble Ethernet RJ45. Puisqu' 'il s'agit d'une liaison directe d'ordinateur à ordinateur, et pas via un routeur, il faudra prendre un câble croisé. Suivant le PC, ce n'est toutefois peut-être pas nécessaire, les modèles actuels faisant automatiquement le croisement eux-mêmes.
     

  3. En alimentant la carte, la led rouge près du port Micro-USB s'allume et la LED du port Ethernet clignote, ce qui indique que la carte est bien alimentée et que le port Ethernet fonctionne.
     

  4. La led du port Ethernet s'allume en jaune ce qui indique que la vitesse est de 100Mb/s. Elle clignote  lorsqu'il y a de l'activité.


4. Contrôle de la connexion Ethernet

 

Il faut utiliser la console Windows pour cela:
 

Sous Windows, recherchez  le mot "CMD" (icône "loupe" en bas à gauche du bureau). CMD.EXE s'affiche. Cliquez dessus et la fenêtre noire de la console s'affiche à l'écran avec, dans mon cas:
 

Microsoft Windows [version 10.0.17134.407]
(c) 2018 Microsoft Corporation. Tous droits réservés.

C:\Users\VON>

 

Taper ipconfig ce qui affiche l'état des ports IP. On doit y trouver entre autres un port dont l'adresse est 192.168.137.1, l'important étant le "137" qui indique que le Raspberry Pi est connecté au PC par la ligne Ethernet et que la carte Ethernet du PC a l'adresse IP 192.168..137.1.


(Ce n'est que le haut de la fenêtre)
 

Il faut encore trouver l'adresse IP du Raspberry Pi avec le logiciel Portscan. On peut le télécharger ici.
Sans rien changer d'autre, il faut donner l'adresse de début du scan des adresses IP: 192.168.137.0 et l'adresse de fin: 192.168.137.255 et cliquer sur "Scan". On obtient le contenu (qui peut varier d'un PC à un autre) de la figure ci-dessous:


 

Attention: Le rpi garde en mémoire les anciennes connexions si bien qu'on a plusieurs adresses pour le même nom de domaine "raspberrypi.mshome.net". Dans les faits, un seul répondra à un ping.

 

Il faut faire un ping (envoi d'une demande de connexion au rpi) sur l'adresse du rpi, ici ping 192.168.137.87.

Dans les statistiques on a "perte = 0%" ce qui indique que tout est en ordre et c'est bien la bonne adresse du rpi. Notez que le DHCP (Dynamic Host Configuration  Protocol) a imposé l'adresse 192.168.137.87 au rpi et le DNS (Domain Name Server) lui a attribué le nom de domaine raspberrypi.mshome.net.

 

 

La première étape est terminée: le Raspberry Pi est connecté au notebook via le réseau Ethernet et ce dernier peut accéder à Internet par Wi-fi. On sait maintenant que

  • la carte Ethernet du PC répond à l'adresse 192.168.137.1 

  • et que le Raspberry Pi répond à l'adresse IP 192.168.137.87 (sur mon pc) et au nom de domaine raspberrypi.mshome.net.

 


5. Communication PC-rpi


Le Raspberry Pi peut travailler sous Linux de deux façons différentes: soit à l'aide d'un écran-clavier-souris dédié, soit à l'aide d'un PC sous Windows via la connexion Ethernet, ce que nous avons ici. Cependant, la structure des fichiers Linux est différente de celle des fichiers Windows ce qui nous oblige à utilise un logiciel de communication spécifique: PuTTY - a free SSH and telnet client for Windows. Il faut donc télécharger ce logiciel puis l'installer, ce qui est facile puisqu'il suffit de suivre les instructions que donne le programme d'installation.

 

Manuel de PuTTY

 

Au démarrage on obtient ceci:

 

 

 

Il faut donner l'adresse IP ou le nom de domaine du Raspberry Pi raspberrypi.mshome.net. Ce dernier est préférable car l'adresse IP peut varier d'une session  de travail à une autre en fonction de celle que délivre le DHCP du PC. Il faut donc inscrire raspberrypi.mshome.net dans le champ *Host name". C'est le nom qu'on obtient avec le logiciel Portscan. Ceci fait, cliquez sur "Open" pour démarre le travail en Linux sur le Raspberry Pi.
 

Le travail se fait en ligne de commandes, la souris est inopérante.

 

Il faut tout d'abord se logger avec:

  • Login as (nom utilisateur): pi

  • Password:                           raspberry

 

 

 

 

A partir de là on travaille en Linux sur le Raspberry Pi.

 


6. Les commandes Linux

 

C'est le logiciel PuTTY qui permet de commander le Raspberry Pi en mode ligne de commande via le lan (local area network).

 

Description des commandes

 

Le prompt est pi@raspberrypi ~& ce qui signifie que l'utilisateur s'appelle pi et que la ligne est raspberrypi  (de raspberrypi.mshome.net). Le tilde ~ signifie qu'on est dans le répertoire de base d l'utilisateur Pi. Le & redonne la main au process.

 

sudo est l'opérateur système (substitude user), l'opérateur "root" (de base), le super utilisateur.
 

[Alt Gr] 7  = |   (pipe)
[Alt Gr] \   = \

[Alt Gr] ~  =  ~

 

 

˄    (UP ou flèche en haut)   Remonte l'historique des commandes
˅    (DOWN ou flèche en bas)   Descend l'historique des commandes
 
history
 
  Liste tout l'historique des commandes. Une commande peut être rappelée avec
! Nocde . Les commandes se trouvent dans le fichier .bash_history
    Comment imprimer cet historique ?

ifconfig

  Donne les paramètres du LAN
clear   Vide la console
xxx --help   Aide sur la commande xxx. Ex: clear --help
man xxx   Manuel de la commande xxx. Ex: man clear

whoami

  Affiche l'utilisateur courant. Ex: pi

cat  /proc/cpuinfo

  Affiche les caractéristiques du cpu

cat  /proc/meminfo

  Affiche les caractéristiques de la mémoire
uname -a   Affiche la version de l'OS
lsusb   Affiche les périphériques connectés en USB
free   Affiche la mémoire libre
sudo halt   Arrêt: de la machine. Il faut restarter le RPI pour reprendre
sudo shutdown -h now   idem
sudo reboot   idem
     
Mise à jour de la mémoire    
sudo apt-get update   met à jour des fichiers déjà installés
sudo apt-get upgrade   met à jour le système complet y compris le noyau (ça prend du temps)
     
Configuration des paramètres de la carte    
sudo raspi-config   ouvre la fenêtre de paramétrage du RPI
     
Manipulation de fichiers   Chaque fichier a 8 attributs de permission: RWXRWXRWX: R=Read, W=Write, X=Exécution. 1er groupe= User, 2ème= Groupe,  3ème=Other: 
pwd   affiche le répertoire où on se trouve
dir
 
  liste le contenu du répertoire courant (que les noms)
avec -a = dir des fichiers cachés (qui commencent par un point)
avec -r  = récursif avec les sous-répertoires
df -h   liste le contenu du répertoire courant avec les détails
ls -il
 
  liste le contenu du répertoire courant avec les attributs des fichiers:
 
cd ..
 
  Recule d'un répertoire dans l'arborescence (attention à l'espace et cd et .. !)
Sans les deux points: avance d'un répertoire
cd /nomrep   va dans le répertoire "nomrep"
    Identique au DIR
cd ~   Aller à la racine de pi (~ = [AltGr ~]
     
touch  [fichier]   Créer le [fichier] ou met la date à jour s'il existe déjà
    Affiche les fichiers et leurs attributs
chmod ugo=rwx [fichier]   Met les bits RWX à jour pour les groupes UGO
nano [fichier]   Démarre l'éditeur Nano dans le [fichier]
rm  [fichier]   Efface le  [fichier]
wget [url file]   Lit un fichier internet et le copie dans le répertoire courant
     
     

 

 


7. Configuration du Raspberry Pi

 

Avec PuTTY, envoyer la commande sudo raspi-config

 

 


 

 

A compléter:

 

4. Localisation  
   a) Change locale fr_CH.UTF-8
   b) Time zone Europe
   c)  
   d) Wi-fi country CH Switzerland
   
5. Interfacing options  
   a) Caméra  
   b) SSH Enabled (il l'est déjà)
   c) VNC Enabled (Accepter par Y l'utilisation de l'espace disque)
   d) SPI Enabled
   e) I2C Enabled
   f) Serial  
   g) 1-Wire Enabled
   h) Remote GPIO Enabled

 

Après avoir complété ces champs (les autres sont pour le moment laissés tels-quels), il faut fermer cette fenêtre en cliquant sur <Finish> (utiliser al touche TAB). Ensuite taper sudo reboot
 

La ligne est coupée ce qui est normal:

 


 

 

Il faut ensuite couper et remettre l'alimentation du rpi (Raspberry Pi) afin de le faire redémarrer.

Redémarrer PuTTY. L'adresse IP du rpi reste en principe la même.

 

Il faut faire le login avec pi et raspberry et on obtient:

 

 

On remarque que le message d'erreur de zone n'existe plus puisqu'on vient de le définir dans la configuration.

 


8. Librairie Wiring Pi

 

Permet de lire/écrire sur les GPIO (General Purpose Input Output) du Raspberry Pi.

 

Il faut commencer par installer l'environnement GIT (gestion décentralisée de versions):

Installation de GIT: sudo apt-get install git-core

 

Contrôle que tout est installé  sudo dpkg --get selections | grep git

(Le "|" s'obtient avec [AltGr 7] )

 

Ensuite cloner Wiring Pi:

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

 

Ensuite aller dans le répertoire: cd wiringPi

et compiler wiring Pi: sudo ./build

A la fin on reçoit: all done

 

Contrôle du fonctionnement: gpio -v

 

Lecture de tous les port s: gpio readall

On obtient:

 

+-----+-----+---------+------+---+---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  | 0 | IN   | TxD     | 15  | 14  |
|     |     |
0v      |      |   | 9  || 10 | 1 | IN   | 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 3---+---+------+---------+-----+-----+

 

On voit sur ce tableau que la pin GPIO 0 est la pin 11 du connecteur.
 

ATTENTION: la numération des pins de Wiring Pi (wPi)  est différente de cette du rpi  (BCM)!
 

 

Pilotage d'une LED:

 

Brancher une résistance de 330 Ohms en série avec une LED entre la pin 11 (= GPIO 0) du connecteur et la pin 9  (masse). La cathode de la LED, le fil court, côté masse).

 

Envoyer la command gpio mode 0 out afin de mettre D0 en mode sortie.

Ensuite gpio write 0 1 ce qui met cette pin à "1" (à + 3.3 Volts). La LED s'allume.

Avec     gpio write 0 0   la LED s'éteint.

 

 

Faire clignoter la LED avec le batch blink.sh
 

Il faut être dans le répertoire pi et taper: ./wiringPi/examples/blink.sh &

Linux donne alors le numéro du processus, par exemple  [1] 3174

Pour arrêter le batch, il faudra faire: kill 3174

 

# blink.sh:
# LED Pin - wiringPi pin 0 is BCM_GPIO 17.

PIN=0

gpio mode $PIN out

while true; do
gpio write $PIN 1
sleep 0.5
gpio write $PIN 0
sleep 0.5
done

Ce batch est une suite de commandes WiringPi
 

 

Faire clignoter la LED avec le soft en C blink.c

 

/*
* blink.c:
*/

#include <stdio.h>
#include <wiringPi.h>

// LED Pin - wiringPi pin 0 is BCM_GPIO 17.

#define LED 0

int main (void)
{
printf ("TEST HB9AFO Raspberry Pi blink\n") ;

wiringPiSetup () ;
pinMode (LED, OUTPUT) ;

for (;;)
{
digitalWrite (LED, HIGH) ; // On
delay (500) ; // mS
digitalWrite (LED, LOW) ; // Off
delay (500) ;
}
return 0 ;
}

Code source en langage C
 

 

Il faut aller dans le répertoire avec: cd wiringPi/examples

Ensuite compiler et linker blink: sudo make blink

blink est compilé et linké ce qui donne:

[CC] blink.c le code est compilé

[link]             le code est linké

 

Pour lancer le programme: ./blink

La LED clignote.

Pour arrêter, taper: [ctrl] c

 


9. Base se données

 

MySQL est la base de données (récemment acquise par Oracle) la plus populaire au monde mais elle est un peu trop conséquente pour les besoins modestes que nous pouvons avoir avec le rpi. Nous allons donc mettre en route la base MariaDB , la petite soeur gratuite de MySQL et la préférée des développeurs open-source.

 

Il faudra installer le langage Python que nous utiliserons pour programmer l'application et la base de données MariaDB.
 

Il faut tout d'abord mettre à jour tout ce qui se trouve sur le rpi avec: sudo apt-get update

Ensuite installer Python:  sudo apt-get install python-mariadb

Et la base de données elle-même: sudo apt-get install mariadb-server


Ca prendra de la place sur la carte SD. Accepter-le si on vous pose la question.

 


Mise en route de la base

Démarrez ensuite le paramétrage initial  de la base: sudo mysql_secure_installation

La base demande tout d'abord de créer un mot de passe, qui sera le mot de passe d'administration de MariaDB, par exemple xxxxxx. Ensuite, chaque base de données créée aura son propre mot de passe.
 

Set root password? [Y/n] Y

New password:

Re-enter new password:

Password updated successfully!

Reloading privilege tables..

... Success!

 

N'oubliez-pas de l'écrire à quelque part car si vous l'oubliez la base sera inaccessible. Respecter la casse (majuscules-minuscules). Ensuite répondez aux questions:

 

Remove anonymous users? [Y/n] n

... skipping.
Disallow root login remotely? [Y/n] n

... skipping.

Remove test database and access to it? [Y/n] n

... skipping.

Reloading the privilege tables will ensure that all changes made so far

will take effect immediately.

Reload privilege tables now? [Y/n] Y

... Success!

 

Ensuite redémarrez le service: sudo systemctl restart mariadb.service


Création d'un utilisateur et d'une base de données

(Exemple de la base "Températures" de l'exercice)

Démarrez la base: mariadb -u root -p -h localhost

Il faut donner le mot de passe précédemment créé.

Pour la suite, nous serons en SQL (Structured Query Language) dans l'environnement de MariaDB.
Le prompt sera >.  Les commandes peuvent être tapées en majuscules ou en minuscules, contrairement à Linux.
Elles se termineront pas un point-virgule ;


(Pour la suite, exemple de la base "Températures" de l'exercice précédent)
 

mariaDB ([none)]>
 
Ensuite il faut  :

  • Créer la base de données « temperatures » et l’utiliser

  • Créer l’utilisateur logger et son pw password

  • Lui donner les privilèges pour tout faire (ALL)

Commande SQL à donner:

CREATE DATABASE temperatures;

USE temperatures;
 

CREATE USER 'logger'@'localhost' IDENTIFIED BY 'password';
L'utilisateur s'appelle logger et son mot de passe est password.
 

GRANT ALL PRIVILEGES ON temperatures.* TO 'logger'@'localhost';
 

FLUSH PRIVILEGES;

 

Sortir par:  quit;
 

Ensuite il faut créer les tables en se loggant avec: mariadb -u logger -p -h localhost

 

MariaDB [(none)]> USE temperatures;

Database changed
 

MariaDB [(temperatures)]> CREATE TABLE temperaturedata (dateandtime DATETIME, sensor VARCHAR(32), temperature  DOUBLE, humidity DOUBLE);
 

La table "temperaturedata" contiendra 3 champs:

  • dateandtime, la date et l'heure via leurs variables

  • trigged sensor, caractère 32

  • temperature, double math

  • humidity, double math

Tester ensuite ce qui vient d'être défini avec la commande:

 

MariaDB [temperatures]> DESCRIBE temperaturedata;

+----------------------+----------------+------+------+----------+--------+
| Field                    | Type            | Null  | Key | Default | Extra |
+----------------------+----------------+------+------+----------+--------+
| dateandtime       | datetime     | YES |         | NULL  |            |
| triggedsensor    | varchar(32) | YES |         | NULL  |            |
| triggedlimit         | varchar(10) | YES |         | NULL  |            |
| lasttemperature | varchar(10) | YES |         | NULL  |            |
+---------------------+-----------------+------+------+----------+--------+
4 rows in set (0.02 sec)

En cas de faute de frappe, il vaut mieux effacer la table avec: DROP TABLE temperaturedata;
et la re-écrire.
 

Tester ensuite la table (vide) avec SELECT *;

Et terminer par Quit;

 

La table est maintenant créée et prête à être utilisée.

 


 

EXERCICE: Installation du soft d'enregistrement de température
 

Les programmes sont sur Github. 
Se positionner à la racine du client "Pi" sur le rpi avec cd /home/pi ou
cd ~

git clone https://github.com/jjpFin/DHT22-TemperatureLogger

Chargement des sources en Python et du fichier config.json pour collecter les données.

 

S'il faut rechrarger une nouvelle version, il vaut mieux effacer tout le répertoire au préalable avec:
sudo rm -r DHT22-TemperatureLogger/


Configuration de l'exercice

 

cd DHT22-TemperatureLogger

nano config.json
(on utilise l'éditeur "Nano".

 

{

"mysql":[{

"host":"localhost",

"user":"logger",

"password":"password",

"database":"temperatures"

}],

 

"sensors":

[[{"name":"Inside"},{"gpio":"4"},{"sensorType":"22"},{"temperatureLowLimit":"18"},{"temperatureHighLimit":"24"},{"temperatureThreshold":"5"},{"humidityLowLimit":"10"},{"humidityHighLimit":"60"},{"humidityThreshold":"10"}]],

 

"mailInfo":[{

"senderaddress":"email@gmail.com",

"receiveraddress":"emailwarnings@gmail.com",

"username":"username",

"password":"password",

"subjectmessage":"Info from temperature logger",

"subjectwarning":"Warning from temperature logger"

}],

"sqlBackupDump":[{

"backupDumpEnabled":"y",

"backupDay":"1",

"backupHour":"23",

"backupDumpPath":"/home/pi/DHT22-TemperatureLogger/Backups/"

}],

"weeklyAverages":[{

"weeklyAverageSendingEnabled":"y",

"weekDayForSendingAverages":"1",

"hourOfTheDayForSendingAverages":"23"

}],

"useFahrenheits":"n",

"mailSendingTimeoutInFullHours":"1",

"adafruitPath":"/home/pi/Adafruit_Python_DHT/examples/AdafruitDHT.py"

}

 

Vérification des librairies Adafruit


cd Adafruit_Python_DHT/examples

Adafruit_Python_DHT/examples $ sudo python_adafruitDHT.py 22 4

(paramètres 22 = DHT22 ; 4 = GPIO 4)

 

On doit obtenir:

Temp=20.5*c  Humidity 53-6%

 

Exécution: sudo python AdafruitDHT.py 22 4

 


10. CRONTAB, envoi automatique de commandes

 

La commande Crontab tourne en permanence mais elle est sans effet tant que les 5 paramètres qui déterminent la cadence d'envoi des commandes n'auront pas été renseignés (par défaut on a * * * * * *). Ces paramètre sont contenus dans une ligne du fichier Crontab. Pour l'éditer: crontab -e
 

Si c'est la première utilisation, choisissez l'éditeur nano en répondant par  2

 

Dans le fichier crontab, la ligne à éditer est celle-ci: # 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
 

Elle débute par les 5 paramètres qui déterminent la cadence de répétition de la commande.

mm hh jj MMM JJJ <tâche>

 

où (Wikipedia):

  • mm représente les minutes (de 0 à 59)

  • hh représente l'heure (de 0 à 23)

  • jj représente le numéro du jour du mois (de 1 à 31)

  • MMM représente l'abréviation du nom du mois (jan, feb, ...) ou bien le numéro du mois (de 1 à 12)

  • JJJ représente l'abréviation du nom du jour ou bien le numéro du jour dans la semaine :

    • 0 = dimanche

    • 1 = lundi

    • 2 = mardi

    • 6 = samedi

    • 7 = dimanche (représenté deux fois pour les deux types de semaine)

  • Suivis de la tâche à exécuter

Si on met aucun paramètre, soit * * * * * * , la tâche est envoyée chaque minute. C'est la cadence la plus rapide.

 

Exemples:

 

28 22 * * 1 df >> /tmp/df.log
Le résultat de la commande df est envoyé chaque lundi (1) à 22h28 dans le fichier /tmp/df.log
 
* * * * * df >> /tmp/df.log
Le résultat de la commande df est envoyé chaque minute  dans le fichier /tmp/df.log
 
 
Auparavant il faut éditer le fichier de configuration afin de démarrer crontab:
sudo nano /etc/rsyslog.conf

Et décommenter la ligne si ce n'est pas déjà fait:
#cron.* /var/log/cron.log (enlever le #)

11. Installer un site web

 

Le logiciel le plus installé est Apache mais c'est NGINX, plus léger et plus adapté à un petit ordinateur comme le rpi que nous allons installer.

 

Commencez par mettre à jour ce qui est déjà installé sur la carte mémoire du rpi: sudo apt-get update

 

Ensuite installer NGINX: sudo apt-get install nginx

 

Puis sudo apt-get install nginx php-fpm php-mysql php-cli

afin d'installer PHP, les commandes Mysql (identiques à MariaDB) et cli (ligne de commande)

 

Ceci fait, après quelques minutes de chargement, démarrer le serveur: sudo /etc/init.d/nginx start


 

Test du serveur

 

Lancez un  navigateur avec l'adresse du rpi: raspberrypi.mshome.net dans mon cas.

 

Ou alors avec l'adresse IP donnée par une recherche des ports connectés faite avec le logiciel Portscan.exe.
Par exemple: http://102.168.137.54

 

On doit obtenir la page qui suit:

 

 

 

 

Imposer une page d'accueil

 

Afin de pouvoir afficher une page HTM, HTML ou PHP, il faut l'indiquer dans le ficher de configuration de NGINX lequel sera mis en route au démarrage: sudo nano /etc/nginx/sites-available/default 

 

Pour le moment, c'est le fichier index.nginx-debian.html qui est exécuté. Il faut donc éditer la ligne qui suit:
# Add index.php to the list if you are using php

afin d'y rajoujter index.php:

index index.html index.htm index.php index.nginx-debian.html

 

Cette ligne indique l'ordre dans lequel la page de démarrage sera affichée si ces 4 fichiers se trouvent dans la racine du serveur. Un  seul suffit bien-sûr.

 

 

 

 

 

Activer PHP (si on en a besoin)

 

Ensuite il faut activer PHP en dé-commentant (enlever le # du début de ligne) de ce même fichier de configuration de la ligne:

# location ~ \.php$ {
 

Ne pas oublier la } à la fin

 

 

 

Ensuite il faut re-démarrer le service NGINX: sudo /etc/init.d/nginx restart

A contrôler avec: systemctl status nginx.service

 

Et aussi le service php-fpm: sudo /etc/init.d/php7.0-fpm restart

A contrôler avec: sudo /etc/init.d/php7.0-fpm status

 

 

Répertoire où mettre les fichers HTML ou PHP

 

C'est le répertoire /var/www/html/

 

Il faut encore pouvoir les y écrire ce qui nécessite de modifier les droits sur ces répertoires:

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

sudo chmod -R 770 /var/www/html

 

 

Tester index.html

 

Il ne reste plus ensuite qu'à tester ces différents fichiers. Pour cela il faut créer un fichier index.html dans le répertoire /var/www/html

avec "test de NGINX en html" avec le mini-éditeur Nano:
 

nano /var/www/html/index.html

Test du fichier index.html

 

On doit ensuite pouvoir lire Test du fichier index.html dans le navigateur lorsqu'on le démarre. S'il le faut, faire un rafraîchissement de la page d'accueil avec la touche [F5]

 

Ensuite effacer ce fichier afin qu'il ne gêne pas l'affichage de index-php.

rm /var/www/html/index.html

 

 

Tester index.php

 

Editer comme  ci-dessus:

 

nano /var/www/html/index.php

Test du fichier index.php

 

On doit ensuite pouvoir lire Test du fichier index.php dans le navigateur lorsqu'on le démarre. S'il le faut, faire un rafraîchissement de la page d'accueil avec la touche [F5]

 

Si vous avez pu obtenir ces deux pages d'accueil, NGINX et php sont bien installés et fonctionnent. Il suffira ensuite de construire le site en y mettant les fichiers nécessaires soit en HTML soit en PHP.

 

Par exemple, une seule page index.html composée avec le logiciel FrontPage qui affiche un titre et une une photo.

 

 

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
<html><head>

</head>
<body style="text-align: right; " text="#000000" topmargin="0" leftmargin="0" rightmargin="0" bottommargin="0" marginwidth="0" marginheight="0" bgcolor="#FFFFFF" background="fond_page.gif">

<div align="center">
<div align="center">
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<blockquote>
<div align="center">
&nbsp;<table border="0" width="800" cellspacing="1" bgcolor="#FFCC00">
<tr>
<td>
<div align="center">
<p style="margin-top: 0; margin-bottom: 0" align="center">
<b><font face="Arial" size="7">VON</font></b></div>
</td>


</tr>
</table>
</div>
<p style="margin-top: 0; margin-bottom: 0">&nbsp;</p>
<p style="margin-top: 0; margin-bottom: 0">
<font face="Arial" size="2">
<a href="USA_20120529_3262.JPG" target="_top">
<img border="0" src="USA_20120529_3262_m.JPG" width="800" height="600"></a><br>
&nbsp;</font></p>
<p style="margin-top: 0; margin-bottom: 0">
&nbsp;</p>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
</blockquote>
</div>
</div>

Code source de la page index.html

 

 

La photo voeux avec Yilian Canizares_m.jpg doit évidemment se trouver dans le répertoire /var/www/html/ en compagnie du fichier index.html créé ci-dessus. Lorsqu'on démarre un navigateur (ici Mozilla Firefox) et qu'on lui donne soit l'adresse IP http://192.168.137.87   soit le nom de domaine http://raspberrypi.mshome.net on obtient le contenu de la page index.html.

 

 

 

 

Le logiciel gratuit WinSCP est parfait pour faire des transferts de fichiers entre le répertoire de travail de votre PC et le rpi.

 


 

 

 

 

 

 

 

 

 

 

 

 

Divers


Fichier de configuration

 

Problème de sortie HDMI


Problème de boot:

  • Quand la machine démarre c'est presque une brique. Elle regarde si elle a une SD et là elle la lit, et exécute.
  • Si pas de SD, elle regarde s'il y a un système disponible sur un volume connecté à un port USB, et elle l'exécute.
  • Si pas de volume via USB, elle démarre le réseau et demande une adresse IP à tout hasard. C'est toujours une brique à cette étape.
    Coup de bol, il y a un serveur BOOTP/DHCP à l'écoute, il donne une IP (et l'adresse du serveur TFTP à contacter)
    Du coup la brique passe à l'étape suivante, demander les fichiers de boot au serveur TFTP, elle les reçoit et exécute le système.