Comment prendre en main la Raspberry Pi

La Raspberry Pi est un ordinateur de la taille d’une carte de crédit. Il est conçu et fabriqué par la fondation Raspberry qui est une organisation à but non lucratif dévouée à la fabrication d’ordinateurs et de programmes les plus accessibles possible. La mission originelle du projet Raspberry fut de concevoir un ordinateur aussi bon marché que possible ayant de bonnes capacités de programmation. Ainsi, pouvoir le mettre dans les mains des étudiants. Ce guide vise donc à poser les fondations de l’utilisation de la Raspberry Pi et ainsi faciliter sa prise en main.

Attention. Cet article s'adresse à des gens ayant de bonnes bases en informatique.

Éléments nécessaires

Une Raspberry Pi
Une carte SD de classe 4 (minimum 8 GB)
Un chargeur micro-USB
Un clavier USB
Une souris USB
Un câble vidéo HDMI
Un écran avec port HDMI
Un câble Ethernet pour se connecter à internet (facultatif, mais recommandé)

Partie 1

Partie 1 sur 12:
Installer l’OS

1
Comprenez ce qu'est NOOBS (New Out Of Box Stoftware). Il s'agit d'un gestionnaire d’installation des différents systèmes d’exploitation utilisable avec la Raspberry Pi. Son but est de nous faciliter l’installation du/des systèmes d’exploitation (OS) de notre choix. C’est donc le premier contact que nous aurons avec la partie logicielle de notre microordinateur. Les systèmes d’exploitation suivants sont inclus dans NOOBS :
- Raspbian
- Pidora
- OpenELELC
- RaspBMC
- RISC OS
- Arch Linus
- Les équipements requis pour ce tutoriel sont :
- Un PC
- Une carte SD de classe 4 de minimum 8 GB
  - Le coffret d’origine contenant la Raspberry Pi contient déjà une carte mémoire SD avec NOOBS préinstallé. Les étapes qui suivent, ne sont donc utile qu’en cas d’installation sur une nouvelle carte SD.
Publicité

Partie 2

Partie 2 sur 12:
Télécharger NOOBS

1
Vous pouvez télécharger "NOOBS" à l'adresse suivante : NOOBS

Partie 3

Partie 3 sur 12:
Formater la carte SD

1
Il est impératif d’avoir une carte SD de minimum 4 GB. Cependant 8 GB est la taille recommandée.

Publicité

Partie 4

Partie 4 sur 12:
Copier NOOBS sur la carte SD

1
Procédez à l'extraction des fichiers. Extrayez les documents issus du fichier zip nommé NOOBS téléchargé lors de la première étape. Copiez les fichiers extraits sur la carte SD récemment formatée. Attention toutefois au fait que dans certains cas, les fichiers extraits peuvent aller dans un nouveau dossier et dans ce cas il est préférable de copier les fichiers eux-mêmes plutôt que le dossier.
- Au premier démarrage, la liste des systèmes d’exploitation disponible à l’installation s’affichera.

Partie 5

Partie 5 sur 12:
Prendre en main de la Raspberry pi

1
Pour utiliser la Raspberry Pi, suivez les étapes suivantes.
- Insérez la carte SD dans la Raspberry jusqu’à entendre un « click ».
- Branchez le câble HDMI et reliez-le à l’écran. Pensez à brancher et allumer
- l’écran. Alimentez la Raspberry avec le chargeur micro USB
- Branchez le clavier et la souris dans n’importe quel port USB.
- Après avoir fait ces étapes, vous verrez apparaitre sur votre moniteur que le logiciel NOOBS est en train de se charger. Une fois le chargement effectué, une liste de systèmes d’opération pouvant être installés va alors apparaitre. Raspbian est l’OS recommandé pour l’installation. Sélectionner Raspbian et cliquer sur le bouton « installer» situé dans le haut de la fenêtre.
2
L’installation prend approximativement 20 minutes. Une fois l’installation terminée, un écran noir à commandes apparait. Il faudra alors entrer, lorsque le programme le demandera, le nom d’utilisateur : « pi » ainsi que le mot de passe : « raspberry ». Ensuite, tapez ce qui suit dans la ligne de commande et appuyez sur la touche "Entrer":
```
startx
```
3
Félicitations ! Vous être parvenu à installer l’environnement nécessaire à l’utilisation de votre Raspberry pi :) ! Nous allons maintenant passer à la configuration du réseau.

Publicité

Partie 6

Partie 6 sur 12:
Configurer le réseau

1
Connectez-vous à internet. Une fois que la Raspberry Pi est fonctionnelle, ce qu’il faut faire ensuite c’est mettre en place une connexion au réseau internet pour la Raspberry Pi. Une fois que cela sera effectué, vous serez en mesure de surfer sur internet tout comme avec un tout autre ordinateur. Il existe deux manières de configurer sa connexion, de manière filaire (avec un câble Ethernet) ou sans fil via Wi-Fi. Suivez ces étapes pour parvenir à configurer votre réseau.

Configurer un réseau filaire

1
Les équipements nécessaires sont :
- une Raspberry Pi fonctionnelle (cf. Prise en main Raspberry Pi )
- un câble Ethernet
2
Il suffit de connecter une des têtes du câble Ethernet à l’orifice prévu sur la Raspberry Pi et l’autre au modem ou routeur d’accès à internet. À la suite de cela, la Raspberry Pi sera automatiquement connectée à internet.

Publicité

Configurer un réseau sans fil (SSH/wifi)

1
Les équipements nécessaires sont :
- une Raspberry Pi fonctionnelle (cf. Prise en main Raspberry Pi 3)
- une clé USB wifi
2
Branchez la clé USB wifi sur l’un des ports encore disponibles de la Raspberry Pi.
3
Ouvrez le service de configuration wifi en appuyant sur l’icône se trouvant dans le menu.
- Après avoir ouvert le service, vous verrez l’interface suivante s’afficher.
4
Cliquez sur le bouton scan. Une nouvelle fenêtre apparaitra. Dès lors, il faudra doublecliquer sur le réseau que l’on souhaite utiliser.
5
Entrez le mot de passe. Saisissez le mot de passe d’accès au réseau dans le champ PSK (Pre-Shared Key) comme montré ci-dessous.
- Désormais, cliquez sur "Save" (sauvegarder) et ajoutez le réseau. Après avoir fait cela, vous serez connecté au réseau internet.
Publicité

Partie 7

Partie 7 sur 12:
Installer Geany IDE

1
Geany est un éditeur de texte léger utilisant GTK+ et Scintilla et incluant les fonctions élémentaires d'un environnement de développement intégré. Pensé pour avoir peu de dépendances et démarrer rapidement, Il supporte les langages C/C++, Java, JavaScript, PHP, HTML, CSS, Python, Perl, Ruby, Pascal et Haskell.
2
Ouvrez l’invite de commande dans le menu.
3
Entrez la ligne de commande "sudo root" pour être dans le dossier racine de Raspberry. Dès lors, entrez le nom d’utilisateur "pi" et mot de passe "raspberry".
4
Entrez la ligne de commande suivante.
```
apt- get install python geany xterm
```
5
L'installation prend quelques secondes.
6
Ouvrez l’IDE Geany dans le menu.

7

9
Vous pouvez dès à présent écrire votre premier programme en créant votre premier fichier dans l'onglet "file".

10

11
Une fois votre code écrit, il vous suffit de l'enregistrer et de compiler le code.

Publicité

Partie 8

Partie 8 sur 12:
Piloter un moteur DC en Python (Partie câblage)

Dans cette partie, nous allons vous montrer comment câbler un moteur DC à la Raspberry Pi et comment créer un petit programme en python capable de faire varier la vitesse de rotation et le sens d'un moteur DC.

1
Ce petit tuto vous aidera sans doute ultérieurement pour la réalisation de votre projet robot.
2
Comprenez le principe. Tout d'abord, vous devez savoir que le moteur DC ne se branche pas directement sur les pins GPIO de la Raspberry Pi. En effet, le courant qui servira à faire tourner le/les moteurs sera assez élevé pour notre petite Raspberry Pi et celle-ci pourrait être endommagée.
- C'est pour cette raison que nous allons utiliser un chip conçu pour contrôler jusqu'à deux moteurs DC. Le chip L293D.
- Une caractéristique importante de la Raspberry Pi est la rangée de pins GPIO située au coin de la carte. N'importe laquelle des pins GPIO peut être désignée en programmation comme une pin d'entrée ou de sortie.
3
Procédez au câblage du L293D.
- Les pins 4, 5, 12 et 13 du L293D doivent être reliées au GND comme on peut le voir sur l'image. La pin 16 du L293D permet que celui-ci soit alimenté. On l'alimentera en 5V. Cette tension n'est pas transmise au moteur, mais uniquement au chip L293D.
- Afin d'alimenter le moteur, on utilisera la pin 8 du L293D (borne positive) connecté à des piles ou une batterie. La borne négative doit être branchée à la masse (GND). Attention à ne pas dépasser la limite de tension prévue pour le moteur.
4
Connectez le moteur. Pour connecter le premier moteur, il suffit de le brancher aux pins 3 et 6 (Output 1A et 1B) du chip L293D.

Publicité

Partie 9

Partie 9 sur 12:
Terminer les branchements

1
La pin 1 du chip L293D est la pin "enable" du premier moteur. Lorsque cette pin est à l'état logique "haut", le moteur tourne à sa vitesse max et lorsque cette pin est à l'état logique "bas", le moteur est à l'arrêt. Afin de permettre une vitesse réduite au moteur, il suffit de jouer sur ces deux états en les alternants très rapidement. C'est ce qu'on appelle la "PWM" (Modulation de la largeur d'impulsion). Nous allons donc relier la pin 1 du chip L293D à la pin 22 de la Raspberry Pi afin de contrôler la vitesse.
- Afin de contrôler le sens de rotation du moteur, il faut s'amuser avec les pins 2 et 7 du chip L293D. Lorsque la pin 2 est à l'état "haut" et que la pin 7 est à l'état "bas", le moteur tournera dans un sens. Si l'on inverse les deux états logiques entre ces deux pins, le moteur tournera dans l'autre sens. Nous allons brancher la pin 2 du chip l293D sur la pin 18 de la Raspberry et la pin 7 du chip l293D sur la pin 16 de la Raspberry.

Partie 10

Partie 10 sur 12:
Piloter un moteur DC en Python (partie programmation)

1
Ce petit code permet de contrôler le sens et la vitesse de rotation d'un moteur. Celui-ci tourne d'abord dans un sens avec une vitesse élevée pendant 3 secondes. Puis à vitesse réduite. Ensuite, le sens de rotation est inversé et le moteur tourne à vitesse réduite puis avec une vitesse élevée. Nous vous laissons maintenant explorer ce code :
```
import RPi.GPIO as GPIO
from time import sleep
GPIO.setmode(GPIO.BOARD)
```

2

On peut à présent, configurer les ports du GPIO.

Moteur1A = 16      ## Sortie A du premier moteur, pin 16
Moteur1B = 18      ## Sortie B du premier moteur, pin 18
Moteur1E = 22      ## Enable du premier moteur, pin 22
GPIO.setup(Moteur1A,GPIO.OUT)  ## On met les 3 pins en sortie (OUT)
GPIO.setup(Moteur1B,GPIO.OUT)
GPIO.setup(Moteur1E,GPIO.OUT)

3

On configure ici la PWM.

pwm = GPIO.PWM(Moteur1E,50)   ## Pin 22 en PWM à une fréquence de 50Hz
pwm.start(100)   ## on commemnce avec un rapport cyclique de 100%

4

On active les états des ports GPIO.

print "Rotation sens direct, vitesse max avec un rapport cyclique de 100%"
GPIO.output(Moteur1A,GPIO.HIGH)
GPIO.output(Moteur1B,GPIO.LOW)
GPIO.output(Moteur1E,GPIO.HIGH)

5
À présent, on laisse tourner le moteur 3 secondes.
```
sleep(3)
```
6
On modifie le rapport cyclique à 20 % afin de réduire la vitesse.
```
pwm.ChangeDutyCycle(20)
```
Publicité

7

print "Rotation sens direct, avec un rapport cyclique de 20%"
sleep(3)
print "Rotation sens inverse, avec un rapport cyclique de 20%"
GPIO.output(Moteur1A,GPIO.LOW)
GPIO.output(Moteur1B,GPIO.HIGH)
sleep(3)
pwm.ChangeDutyCycle(100)
print"Rotation sens inverse, vitesse maximale (rapport cyclique 100%)"
sleep(3)
print "Arret du moteur"
GPIO.output(Moteur1E,GPIO.LOW)
pwm.stop()    ##  arrêt de la PWM
GPIO.cleanup()

Partie 11

Partie 11 sur 12:
1er challenge

1
Réalisez un petit code avec deux moteurs cette fois-ci. À vous de jouer !

Utiliser le capteur à ultrason HC-SR04 (câblage)

1
Les équipements requis pour cette étape sont :
- un module ultrasons HC-SR04,
- une résistance de 1 kΩ,
- une résistance de 2 kΩ,
- des câbles de connexion,
- une Breadbord
- Le capteur à ultrasons HC-SR04 permet de mesurer une distance de 2 à 400 cm en envoyant des signaux sonores à 40 kHz. En fonction du temps qui sépare l'émission de la réception du signal ultrason, on trouve par un calcul la distance.
2
Le HC-SR04 possède 4 broches :
- une broche (Gnd), utilisée pour mettre le module à la masse (0 V),
- une broche de sortie (Echo), utilisée pour informer de la fin de l'émission du train d'ultrasons et de son retour après réflexion sur l'obstacle,
- une broche d'entrée (Trig pour Trigger), utilisée pour déclencher l'émission du train d'ultrasons,
- une broche (Vcc), utilisée pour alimenter le capteur en 5 V.
  - La tension de sortie délivrée par la broche Echo est de 5 V. Or, la broche d'entrée (GPIO) de la Rapsberry Pi est conçue pour du 3,3 V au maximum.
- Nous allons donc, afin d'éviter d'endommager le Rapsberry Pi, utiliser un pont diviseur de tension constitué de deux résistances afin d'abaisser la tension de sortie du capteur.
3
Il vous suffit dès lors, comme vous pouvez le voir ci-dessus de brancher :
- la pin "Vcc" au 5 V de la Raspberry Pi (fil rouge)
- la pin "Trig" sur la broche GPIO 23 (pin 16) de la Raspberry (fil jaune)
- la pin "Echo" sur la broche GPIO 24 (pin 18) de la Raspberry (fil bleu)
- la pin "GND" au GND de la Raspberry (fil noir)
4
N'oubliez pas vos deux petites résistances !
- Le capteur est à présent connecté à la Raspberry Pi. C'est parti pour la programmation en python !
Publicité

Utiliser le capteur à ultrason HC-SR04 (partie programmation)

1
Il faut, dans un premier temps, importer les différentes bibliothèques pour :
- la gestion des ports GPIO.
- la gestion de l'horloge
  import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM)
2
Il faut ensuite identifier les différentes broches que nous allons utiliser. Dans notre cas, la broche de sortie "GPIO 23" (TRIG :signal de déclenchement au capteur ultrason) et la broche d'entrée "GPIO 24" (ECHO: acquisition du signal en retour).
```
TRIG = 23
ECHO = 24
```

3

On peut à présent configurer les ports du GPIO.

GPIO.setup(TRIG, GPIO.OUT)
GPIO.setup(ECHO, GPIO.IN)

4
Afin de s'assurer que la broche "Trig" est initialement à l'état bas, nous allons la mettre en "False" et donner un temps d'attente afin que le capteur puisse s'initialiser.
```
GPIO.output(TRIG, False)
print "Waiting For Sensor To Settle"
time.sleep(2)
```
5
Le capteur ultrason a besoin d'une impulsion de 10 µs afin d'activer son module. Pour créer l'impulsion de déclenchement, la broche Trig doit être forcée à l'état haut pendant 10 µs et ensuite elle doit être remise à l'état bas :
```
GPIO.output(TRIG, True)
time.sleep(0.00001)
GPIO.output(TRIG, False)
```
6
Pour horodater les différents évènements qui proviennent du changement d'état d'une broche, nous utiliserons une boucle while et la fonction time.time(). Détectez le changement d'état du signal. La première étape consiste à détecter et horodater l'instant qui précède juste le changement d'état du signal Echo de l'état bas à l'état haut. Cet instant (pulse_start) sera celui de la fin de l'émission du train d'ultrasons par le capteur.
```
while GPIO.input(ECHO) == 0:
    pulse_start = time.time()
```
7
Une fois le train d'ultrasons émis, la broche Echo restera à l'état haut jusqu'au retour des ultrasons réfléchis par l'obstacle. On cherche alors à détecter à nouveau le basculement du signal Echo à l'état bas. Cet instant horodaté (pulse_end) sera celui de la détection du retour des ultrasons.
```
while GPIO.input(ECHO) == 1:
    pulse_end = time.time()
```
8
On peut connaitre la durée d'impulsion (pulse_duration) en calculant la différence entre les deux pulses :
```
pulse_duration = pulse_end - pulse_start
```
9
Afin de connaitre la distance, on applique la formule :
```
distance = pulse_duration * 17150
```
10
Nous allons arrondir notre distance à deux décimales :
```
distance = round(distance, 2)
```
11
Pour afficher la distance en "cm" :
```
print "Distance: ", distance, " cm"
```
12
Afin de réinitialiser les pins GPIO on rajoute :
```
GPIO.cleanup()
```
13
Il suffit maintenant de sauvegarder le code en le nommant "distance_capteur" par exemple et de le lancer dans l'invite de commande :
```
sudo python distance_capteur.py
```
14
Félicitation ! vous êtes capable de piloter un moteur ainsi que de détecter une distance avec le capteur à ultrason !

Publicité

Partie 12

Partie 12 sur 12:
2e challenge

1
Si vous disposez de ce véhicule à trois roues. Avec ce que vous avez appris jusqu'à maintenant, vous devez être capable de piloter ce véhicule afin qu'il puisse former un "E" lorsqu'il se déplace. Il sera également capable de s'arrêter s'il rencontre un obstacle à l'aide des capteurs à ultrason.
2
À vous de jouer !

Publicité