Mois : février 2017

Nous utilisions, au travail, un système de cloches complètement archaïque qui datait de Mathusalem (ou presque). La programmation de cette cloche était très complexe et aucune documentation n’était disponible. Puisque la programmation de la cloche avait été faite avant le changement de date des changements d’heures en Amérique du Nord (2007) et que personne ne semblait savoir comment programmer le changement d’heure de la cloche, je devais changer, 4 fois par année, l’heure du système. De plus, notre ancien système prenait du retard (environ 10 minutes par année). Alors, lorsqu’on m’a demandé s’il était possible d’ajouter une deuxième cloche à notre système, j’ai proposé de créer un nouveau système digne de notre siècle pour remplacer notre vieillerie.

Matériel requis :

• 2 fils Dupont mâle/femelle (rouge)
• 1 fil Dupont mâle/femelle (noir)
• 2 fils Dupont mâle/mâle (rouge)
• 6 fils Dupont mâle/mâle (noir)
• 2 cloches Ajax Scientific Deluxe Electric Bell (ASIN: B00EPQKIXE)
• 1 planche de montage expérimental (breadboard)
• 1 puce à circuit intégré ULN2003A
• 1 Raspberry Pi (B+ v1.2 dans mon cas)
• 1 connecteur DC femelle 2.1 pour planche de montage expérimental
• 1 adaptateur DC-16V 1A
• 1 carte micro SD 4Go (ou plus)
• 1 chargeur micro USB
• 1 fil réseau

Matériel optionnel :

• 1 cable HDMI
• 1 écran compatible HDMI
• 1 clavier USB

Étape 1 : préparer le Raspberry Pi.

Téléchargez et extraire Raspbian Jessie Lite sur un ordinateur pouvant lire les cartes SD (ou utiliser un adaptateur micro SD/USB), puis montez l’image sur la carte SD.

Sous Linux :

dd bs=4M if=/chemin/vers/2017-01-11-raspbian-jessie-lite.img of=/dev/sdX

En remplaçant /chemin/vers/ par l’emplacement où se trouve le fichier image et /dev/sdX par le périphérique correspondant à la carte micro SD.

Sous Windows :

Utilisez un programme tel que Win32 Disk Imager pour transférer l’image sur la carte micro SD.

Puis, insérez la carte micro SD dans le Raspberry Pi (RPi) et démarrer celui-ci. Connectez-vous sur le RPi en utilisant l’utilisateur pi et le mot de passe raspberry, puis lancer l’utilitaire raspi-config.

sudo raspi-config

Nous allons d’abord étendre le système de fichier en choisissant l’option 1. Ensuite, nous devons activer quelques options avancées notamment SPI, I2C et accessoirement SSH (afin de simplifier la gestion).

Nous pouvons maintenant choisir l’option Finish et redémarrer le RPi. Nous pouvons vérifier que les modules sont bel et bien installés à l’aide de la commande suivante.

lsmod | grep -E '(spi|i2c)'

Maintenant, nous allons mettre les paquets apt à jour, puis installer certains paquets nécessaires au fonctionnement de notre projet.

sudo apt-get update && sudo apt-get upgrade
sudo apt-get install git build-essential libi2c-dev python-dev python3-pip python-pip libffi-dev i2c-tools python2.7-dev python3-dev libevent-dev
sudo pip install spidev
sudo pip install smbus-cffi

Voilà, le RPi est prêt pour l’utilisation des entêtes GPIO.

Étape 2 : création du fichier pi_bell.py.

Créons un nouveau fichier pi_bell.py dans le sous-répertoire pi_bell répertoire « home » de l’utilisateur pi ou clonons simplement mon référentiel GitLab. Il est conseillé de cloner le référentiel plutôt que de créer le fichier, puisque le référentiel sera possiblement mis à jour.

mkdir ~/pi_bell
nano ~/pi_bell/pi_bell.py

Puis, compions le contenu du fichier.

#!/usr/bin/python
# -*- coding: latin-1 -*-

__author__ = "Julien Bonnier <[email protected]>"
__copyright__ = "Copyright 2017, Julien Bonnier"
__license__ = "GPL"
__maintainer__ = "Julien Bonnier"
__email__ = "[email protected]"

__date__ = "$2017-02-21 13:53$"
__version__ = "0.0.0.20170221.1353"
__status__ = "Production"

# Import des modules
from datetime import datetime
from threading import Timer
import time
import sys
import atexit

try:
	import RPi.GPIO as GPIO
except ImportError as e:
	print "RPi GPIO module not installed."
	print "Application will abort."
	sys.exit()
except:
	print "Unexpected error:", sys.exc_info()[0]
	sys.exit()

# Declaration de variables
bell_pins = [11, 12]	#gpio 17, 18
ring_time = 3			#secondes

# Initialisation de la numerotation et des E/S
def setupGPIO():
	GPIO.setmode(GPIO.BOARD)
	for pin in bell_pins:
		GPIO.setup(pin, GPIO.OUT, initial = GPIO.LOW)

def init():
	setupGPIO()
	ring()

# On fait sonner la cloche.
def ring():
	for pin in bell_pins:
		GPIO.output(pin, GPIO.HIGH)
	time.sleep(ring_time)
	for pin in bell_pins:
		GPIO.output(pin, GPIO.LOW)

def quit():
	print "Exiting..."
	try:
		GPIO.cleanup()
		print "GPIO cleaned up!"
	except:
		print "Unexpected error:", sys.exc_info()[0]
		
if __name__ == '__main__': 
	init()

atexit.register(quit)

Ou, clonons simplement le référentiel GitLab comme suit :

git clone https://gitlab.com/j.bonnier/pi_bell.git

Consulter le référentiel GitLab.

Étape 3 : Brancher les composantes.

Avertissement : il est conseillé d’éteindre le RPi avant d’y connecter d’autres composantes. De plus, veuillez redoubler de prudence en jouant avec les courants électriques.

Cette étape est plutôt simple, nous n’avons qu’à connecter les composantes en conformité avec le schéma suivant.

Étape 4 : Tester le fonctionnement du système.

À cette étape, le système de cloches devrait être fonctionnel. Pour tester le bon fonctionnement de celui-ci, nous devons taper la commande suivante dans la console.

python ~/pi_bell/pi_bell.py

Si vous obtenez un message d’erreur comme celui-ci :

RuntimeError: No access to /dev/mem. Try running as root!

Vous essayez probablement d’exécuter la commande en tant qu’un utilisateur autre que pi. Par défaut, l’utilisateur pi a accès aux GPIO. Vous pouvez toutefois ajouter quelques groupes à votre utilisateur pour lui donner accès au contrôle des GPIO. Par exemple, pour autoriser l’utilisateur julien à contrôler les GPIO, j’entrerais la commande suivante.

sudo usermod -a -G gpio,i2c,spi julien

Étape 5 : Programmer la cloche.

La programmation de la cloche se fait à l’aide des crontabs.

Afin de ne pas effacer les crontabs que nous pourrions déjà avoir, nous en faisons une sauvegarde dans un fichier temporaire nommé cron.tmp  auquel nous allons ajouter quelques lignes. Dans cet exemple, nous allons programmer les cloches pour qu’elles sonnent à midi et à 16 h 30 tous les jours de semaine (du lundi au vendredi). Puis, nous allons mettre à jour les crontabs et finalement nous effaçons notre fichier temporaire.

crontab -l > cron.tmp
echo "00 12 * * 1-5 python /home/pi/pi_bell/pi_bell.py" >> cron.tmp
echo "30 16 * * 1-5 python /home/pi/pi_bell/pi_bell.py" >> cron.tmp
crontab cron.tmp
rm cron.tmp

Voilà!

Nous avons maintenant une cloche moderne qui sonnera quand et comme nous le voulons!