Calendrier de l’Avent Raspberry Pi 2017 · Calendrier de l’Avent Raspberry Pi 2017 Commander un...

Calendrier de l’Avent Raspberry Pi 2017

Commander un circuit électronique simple avec un PC ou même un ordinateur portable – même s’il ne s’agit que de quelques voyants LED – implique des efforts à peine raisonnables pour le programmateur débutant. Le PC ne dispose simplement pas des interfaces nécessaires à cet effet. En outre, le système d’exploitation Windows n’est pas très indiqué pour communiquer avec les systèmes électroniques.

Le Raspberry Pi est – même s’il n’en donne pas l’impression de prime abord – un ordinateur à part entière. Il est certes plus lent que les PC modernes habituels, mais il faut aussi noter que le Raspberry Pi est bien plus petit et surtout plus abordable qu’un PC.

Le présent calendrier de l’Avent contient une expérience matérielle avec le Raspberry Pi pour chaque nouvelle journée. Les expériences sont programmées avec Scratch ou Python. Ces deux langages de programmation sont préinstallés sur le Raspberry Pi. Toutes les expériences fonc-tionnent avec le Raspberry Pi 3.

Brève description des principaux composants

Platine enfichable Le calendrier de l’Avent est équipé d’une platine enfichable pour la réalisation rapide des connexions électroniques, sans nécessité de soudage. Les composants électroniques peuvent donc directement être enfichés dans un circuit imprimé.

Sur cette platine enfichable, toutes les rangées longitudinales extérieures sont reliées entre elles par des contacts (X et Y). Ces rangées de contacts sont souvent utilisées comme pôles positif et négatif pour l’alimentation électrique des circuits. Sur les autres rangées de contacts, cinq contacts (A à E et F à J) sont respectivement reliés en diagonale, alors qu’un vide est laissé au centre de la platine. Ainsi, les plus grands composants peuvent y être enfichés et câblés vers l’extérieur.

Les connexions de la platine enfichable.

Voyants LED Les voyants LED (ou diodes électroluminescentes) s’allument lorsque le courant les traverse dans le sens du débit. Les voyants LED sont repré-sentés sur les circuits par un triangle en forme de flèche, qui indique le sens du débit partant du pôle positif vers le pôle négatif ou vers le fil de terre. Un voyant LED laisse traverser autant de courant que possible dans le sens du débit, sa résistance est faible. Pour limiter le débit de courant et donc empêcher que les voyants LED se grillent, une résistance en série de 220 ohms est généralement installée entre la broche GPIO utilisée et l’anode du voyant LED ou entre la cathode et la broche de terre. Cette résistance en série protège aussi la sortie GPIO du Raspberry Pi contre les trop grandes intensités de courant. Les voyants LED du calendrier de l’Avent possèdent déjà une résistance en série et peuvent donc être direc-tement raccordés aux broches GPIO.

Dans quel sens raccorder les voyants LED ? Les deux fils de raccordement d’un voyant LED ont des longueurs différentes. Le fil le plus long cor-respond au pôle positif, l’anode, tandis que le plus court correspond à la cathode. C’est facile à retenir : le signe positif a un trait de plus que le signe négatif et son fil est donc un peu plus long. En outre, la plupart des voyants LED sont aplatis côté négatif, un peu comme pour le signe négatif. C’est également facile à retenir : cathode = court = bord.

Schéma de câblage d’un voyant LED avec résistance en série.

LED RGB Un voyant LED normal s’allume toujours dans une seule couleur. Les voyants LED RGB utilisés pour le calendrier de l’Avent peuvent s’allumer dans plusieurs couleurs au choix. Ici, trois voyants LED de couleurs différentes sont en principe installés dans un boîtier transparent. Chacun de ces trois voyants LED dispose de sa propre anode via laquelle il est relié à la broche GPIO. La cathode qui est reliée au fil de terre est disponible en un seul exemplaire. C’est pourquoi un voyant LED RGB a quatre fils de raccordement.

Broches de raccordement d’un voyant LED RGB.

Les fils de raccordement des voyants LED RGB ont des longueurs différentes, afin de faciliter leur identification. Contrairement aux voyants LLED normaux, la cathode est le fil le plus long ici.

Les voyants LED RGB fonctionnent comme trois voyants LED individuels et ont donc besoin aussi de trois résistances en série. Celles-ci sont également préinstallées dans les voyants LED RGB du calendrier de l’Avent.

Résistance Les résistances sont utilisées pour limiter le courant des composants électroniques délicats, ainsi que comme résistances en série pour les voyants LED. L’unité de mesure de la résistance est l’ohm. 1000 ohms correspondent à un kiloohm, abrégé kohm. 1000 kohms correspondent à un mé-gohm, abrégé Mohm. Le symbole oméga Ω est souvent utilisé aussi pour exprimer l’ohm.

Schéma de câblage interne pour un voyant LED RGB à trois résistances en série.

Les anneaux colorés sur les résistances indiquent la valeur de la résistance. Avec un peu de pratique, ils seront nettement plus faciles à identifier que de minuscules chiffres que l’on ne retrouve désormais plus que sur les vieilles résistances en série.

La plupart des résistances possèdent quatre anneaux colorés de ce type. Les deux premiers anneaux colorés représentent les chiffres, le troisième est un multiplicateur, et le quatrième la tolérance. Cet anneau de tolérance est en général de couleur dorée ou argentée, ce qui n’est pas le cas pour les premiers anneaux. Ainsi le sens de lecture est toujours clair. La valeur de tolérance en elle-même n’est guère importante dans l’univers de l’électronique numérique. Le tableau montre la signification des anneaux colorés sur les résistances.

Le sens de montage d’une résistance n’est pas important. Pour les voyants LED cependant, le sens de montage joue un rôle déterminant.

Servo Le servo est un petit moteur à un bras sur lequel des objets peuvent être fixés. Grâce à un signal de commande, il peut être tourné dans n’importe quel angle. Les servos ont trois fils de raccordement, dont deux pour l’alimentation électrique, et un troisième sur lequel le servo reçoit les signaux de commande.

Câble de raccordement GPIO Les câbles de raccordement colorés sont munis d’une douille sur les deux faces, qui correspond à une broche GPIO du Raspberry Pi. Les voyants LED et autres composants peuvent être directement branchés dans ces douilles. Des barrettes à broches sont également disponibles, qui sont enfichées dans la platine enfichable pour relier les câbles de raccordement aux rangées de contact. Chaque barrette à broches dispose de trois broches indépendantes, c’est-à-dire qui ne sont pas électriquement reliées.

Affectation des broches GPIO.

Couleur Valeur de la résistance en ohms

1. Anneau (Puissance de dix)

2. Anneau (unité)

3. Anneau (Multiplicateur)

4. Anneau (Tolérance)

Argent 10−2 = 0,01 ±10%

Or 10−1 = 0,1 ±5%

Noir 0 100 = 1

Marron 1 1 101 = 10 ±1%

Rouge 2 2 102 = 100 ±2%

Orange 3 3 103 = 1.000

Jaune 4 4 104 = 10.000

Vert 5 5 105 = 100.000 ±0,5%

Bleu 6 6 106 = 1.000.000 ±0,25%

Violet 7 7 107 = 10.000.000 ±0,1%

Gris 8 8 108 = 100.000.000 ±0,05%

Blanc 9 9 109 = 1.000.000.000

Précautions Ne jamais relier les broches GPIO en désordre et attendre voir ce qui va se passer. Les broches GPIO ne sont pas toutes librement programmables. Certaines sont prévues pour l’alimentation électrique et d’autres sont strictement réservées à d’autres fins. Certaines broches GPIO sont directement reliées aux connexions du processeur, un court-circuit peut endommager irréversiblement le Raspberry Pi. Si deux broches sont reliées entre elles via un commu-tateur ou un voyant LED, il faudra toujours installer une résistance de protection au milieu. Une l’exception sont les voyants LED avec résistance en série préinstallée. Pour les signaux logiques, il faudra toujours utiliser la broche Pin 1 qui fournit une puissance de +3,3 V et qui peut être sollicitée jusqu’à 50 mA. La broche Pin 6 est le fil de terre réservé aux signaux logiques. Les broches Pin 2 et 4 fournissent un courant de +5 V pour l’alimentation électrique du matériel ex-terne. On peut utiliser autant de courant ici que le bloc d’alimentation USB du Raspberry Pi peut fournir. Cependant, il faudra éviter de relier les broches à une entrée GPIO.

1er jour

Aujourd’hui dans le calendrier de l’Avent • 1 voyant LED rouge avec résistance en série préinstallée

• 1 câble de raccordement GPIO

Préparer le Raspberry Pi Pour mettre le Raspberry Pi en service vous avez besoin de ce qui suit :

• Clavier USB et souris

• Câble HDMI pour l’écran

• Câble réseau

• Carte micro SD avec système d’exploitation Raspbian Jessie

• Chargeur de téléphone portable micro USB comme bloc d’alimentation (au moins 2 A)

Le bloc d’alimentation doit être raccordé en dernier, ce qui permet le démarrage automatique du Raspberry Pi. Il n’existe pas d’interrupteur Marche/Arrêt.

Brève description de la procédure d’installation du système d’exploitation Pour tous ceux dont le Raspberry Pi ne dispose pas encore de la version Raspbian actuelle, la procédure d’installation du système est décrite en dix étapes ici :

1. Télécharger NOOBS (minimum version 2.0.0) à partir de www.raspberrypi.org/downloads sur le PC et décompresser le fichier Zip sur le disque dur.

2. Si la carte SD a déjà été utilisée, la formater dans le PC avec le programme SD-Formatter : www.sdcard.org/downloads/formatter_4. Activer la fonction Format Size Adjustment (la carte SD doit avoir une capacité minimale de 4 Go).

3. Copier les fichiers et sous-répertoires de NOOBS sur la carte SD.

4. Retirer la carte SD du PC et l’introduire dans le Raspberry Pi, puis le redémarrer. Sélectionner Français comme langue d’installation. Le clavier français est automatiquement sélectionné.

5. Cocher la case du système d’exploitation Raspbian présélectionné et cliquer sur Install en haut à gauche. Après confirmation de la question de sécurité informant que les données de la carte mémoire seront écrasées, l’installation démarre, elle dure quelques minutes.

6. Raspberry Pi redémarre une fois l’installation terminée.

7. Sous Paramètres dans le menu, démarrer l’outil Raspberry Pi Configuration.

8. Dans l’onglet Localisation, sélectionner dans le champ Fuseau horaire les options Europe et Paris. La langue et le clavier devraient automa-tiquement passer en mode français.

9. Dans l’onglet Interfaces, régler le commutateur SSH sur Actif si vous souhaitez transférer des données du PC vers le Raspberry Pi via le PC.

10. Cliquer sur OK et redémarrer le Raspberry Pi via l’option de menu Shutdown. Vous pouvez ignorer le message d’avertissement qui s’affiche éventuellement en raison d’un mot de passe incorrect.

Le voyant LED s’allume. L’expérience montre comment les voyants LED sont raccordés. Veillez à monter les voyants LED dans le bon sens. La cathode (fil court) est reliée à la broche GND du Raspberry Pi, alors que l’anode (fil long) est reliée à la broche GPIO 4. Relier simplement le voyant LED directement avec le câble de raccordement GPIO. Tous les schémas d’assemblage de circuits sont disponibles en couleur dans l’espace de téléchargement du ca-lendrier de l’Avent, afin de faciliter l’identification des fils.

Composants : 1 voyant LED rouge avec résistance en série intégrée, 2 câbles de raccordement GPIO

Le premier voyant LED du Raspberry Pi s’allume.

L’ensemble est commandé via un programme dans Scratch.

Programmes à télécharger

Les programmes utilisés dans le calendrier de l’Avent et les schémas d’assemblage sont disponibles en téléchargement ici : www.buch.cd. Entrer le code 15002-8 dans le champ de saisie pour ce produit.

Ouvrir la page Web directement via le navigateur préinstallé sur le Raspberry Pi et télécharger le fichier Zip dans le répertoire Home /home/pi.

Démarrer le gestionnaire de fichiers sur le Raspberry Pi. Il affiche automatiquement le répertoire Home au démarrage. Cliquez avec le bouton droit sur le fichier Zip téléchargé et sélectionner dans le menu contextuel Extraire ici. L’archive contient 25 répertoires au total, chaque journée est enregistrée dans un répertoire distinct. Il existe aussi un répertoire général.

Le programme Scratch est préinstallé sur le Raspberry Pi sous l’option de menu Développement et est considéré comme l'un des langages de programmation les plus faciles à apprendre. Depuis la version Raspbian Jessie, le programme Scratch prend en charge l’interface GPIO du Raspberry Pi. La prise en charge GPIO doit être activée avant la première utilisation via l’option de menu Modifier/Démarrer serveur GPIO.

Démarrer le serveur GPIO dans Scratch.

Pas besoin de saisir de code de programmation pour la programmation dans Scratch. Les blocs seront simplement liés par fonction glis-ser-déposer. La palette de blocs dans la partie gauche de la fenêtre Scratch contient les blocs disponibles classés par thèmes.

Vous pouvez compiler le programme vous-même sur l’écran ou utiliser le programme 01led01 du dossier de téléchargement du calendrier de l’Avent. Cliquer pour cela sur Ouvrir dans le menu Fichier puis cliquer sur le bouton pi dans la fenêtre de dialogue qui s’ouvre pour sélectionner le répertoire Home personnel dans lequel les programmes téléchargés sont sauvegardés.

Ce programme Scratch 01led01 permet que le voyant LED s’allume pendant une demi-seconde.

Cliquer dans Scratch en haut à gauche sur l’icône gauche Commande. Les blocs de commande s’affichent alors dans la palette de blocs à gauche. Seuls les blocs jaunes sont nécessaires pour ce premier programme.

Faites simplement glisser et déposer les blocs requis de la palette de blocs vers la fenêtre de script au centre de Scratch.

Le bloc Clic sur (drapeau vert) sert à démarrer un programme. Les éléments de script suivants sont exécutés en cas de clic sur le drapeau vert en haut à droite dans Scratch. Le bloc est arrondi en haut, ce qui signifie qu’il ne peut s’insérer en dessous d’aucun autre bloc. Il doit toujours être en tête.

Les commandes GPIO sont exécutées via le bloc Scratch envoie... à tous. La désignation respective de la broche et les mots clés correspon-dants sont saisis dans le champ de texte. Cliquer pour ce faire dans le champ de texte dans le bloc, puis sélectionner Nouveau/edit... et entrer le texte.

Au début, la broche GPIO 4 est définie comme sortie avec la commande config4out. Chaque broche GPIO peut être définie comme sortie ou comme entrée.

Dans la prochaine étape, un nouveau bloc Scratch envoie... à tous permet d’activer le voyant LED raccordé à la broche GPIO 4 avec le texte gpio4on.

Le programme fait ensuite une pause d’une demi-seconde. Scratch propose un bloc distinct à cet effet : pause de...sec.. Comme beaucoup de programmes américains, Scratch utilise le point comme séparateur décimal et non la virgule comme en France. Ainsi, une demi-seconde est saisie 0.5 et non 0,5.

Enfin, un nouveau bloc Scratch envoie... à tous permet de désactiver à nouveau le voyant LED raccordé à la broche GPIO 4 avec le texte gpio4off.

Le programme démarre lorsque vous cliquez en haut à droite sur le drapeau vert dans la fenêtre Scratch.

2e jour

Aujourd’hui dans le calendrier de l’Avent • 1 Platine enfichable (SYB 46)

• 1 voyant LED vert avec résistance en série préinstallée

• 1 câble de raccordement GPIO

• 2 barrettes à broches (3 broches)

Deux voyants LED clignotent en alternance en rouge et en vert L’expérience du 2e jour permet aux deux voyants LED de s’allumer en alternance en rouge et en vert. L’ensemble est commandé via une boucle infinie dans Scratch.

Composants : 1 platine enfichable, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED vert avec résistance en série intégrée, 3 câbles de raccordement GPIO, 2 barrettes à broches (3 broches)

Deux voyants LED clignotent sur le Raspberry Pi.

Nous utilisons cette fois une platine enfichable pour le montage du circuit, comme pour la plupart des expériences de ce calendrier de l’Avent. Utiliser les barrettes à broches fournies pour relier les câbles de raccordement GPIO à la platine enfichable.

Le programme Au début, les deux broches GPIO 4 et 10 sont définies comme sorties avec les commandes config4out et config10out.

Une boucle infinie garantit le clignotement continu des deux voyants LED, jusqu’à ce que l’utilisateur clique sur l’icône d’arrêt rouge en haut à droite dans Scratch.

Si le voyant LED rouge relié à la broche 4 est allumé alors que le voyant vert relié à la broche 10 est éteint, le programme patiente une de-mi-seconde. Ensuite, le voyant LED relié à la broche 10 sera allumé et le voyant rouge relié à la broche 4 sera éteint de la même manière. Le cycle reprend après une autre demi-seconde.

Le programme 02led02 commande les deux voyants LED.

3e jour

Aujourd’hui dans le calendrier de l’Avent • 2 câbles de raccordement GPIO

Deux voyants LED clignotent en alternance en rouge et en vert avec Python L’ expérience du 3e jour permet à nouveau aux deux voyants LED de s’allumer en alternance en rouge et en vert. Sauf que nous utilisons Python cette fois, au lieu de Scratch.

Composants : 1 platine enfichable, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED vert avec résistance en série intégrée, 3 câbles de rac-cordement GPIO, 2 barrettes à broches (3 broches)

Deux voyants LED clignotent sur le Raspberry Pi.

Python est également préinstallé sur le Raspberry Pi, dans deux versions différentes. Python 3 n’est pas facile, il s’agit d’une version plus récente de Python 2 comme son nom le laisse présumer. Les langages utilisent en partie une autre syntaxe. Les programmes ne sont donc pas à 100% compatibles. Beaucoup de bibliothèques externes sont disponibles uniquement pour l’une des deux versions. Les développeurs de programmes Python doivent donc toujours communiquer à leurs utilisateurs avec quelle version un programme fonctionne. Dans ce calendrier de l’Avent, nous utiliserons toujours la version moderne Python 3.

Démarrer le programme Python 3 dans l’option de menu Développement. IDLE est un environnement de programmation et de développement complet pour Python. Aucun composant supplémentaire n’est requis pour le début de la programmation.

Cliquer sur File/Open pour ouvrir le programme 03led02.py dans le dossier de téléchargement ou bien ouvrir une nouvelle fenêtre dans Py-thon-Shell en cliquant sur File/New, puis saisir le nom du programme.

Le programme Le programme est pratiquement identique au programme Scratch du 2e jour, à une différence cruciale près : les voyants LED ne clignotent pas en permanence, mais dix fois exactement.

#!/usr/bin/python

import RPi.GPIO as GPIO

import time

GPIO.setmode(GPIO.BCM)

GPIO.setup(4, GPIO.OUT)


for i in range(10):

GPIO.output(4, True)

GPIO.output(10, False)

time.sleep(0.5)



time.sleep(0.5)

GPIO.cleanup()

Le programme fonctionne comme suit #!/usr/bin/python

Les programmes Python qui sont démarrés à partir de la ligne de commande doivent toujours commencer par la ligne ci-dessus. Cela n’est pas nécessaire pour les programmes qui sont uniquement démarrés via la fenêtre Python-Shell. Pour des raisons de compatibilité, vous devriez toutefois vous habituer à insérer cette ligne au début de chaque programme Python.


import time

Un grand avantage de Python est l’ajout facile de nouvelles fonctions à partir des bibliothèques de fonctions. Il existe des bibliothèques prêtes à l’emploi pour quasiment toutes les tâches. Beaucoup de tâches standard n’ont donc plus besoin d’être programmées. La bibliothèque RPI.GPIO est importée pour la prise en charge des broches GPIO, tandis que la bibliothèque time contient des fonctions de temps, pour réaliser par exemple une temporisation entre le clignotement des deux voyants LED.


La bibliothèque RPi.GPIO prend en charge deux méthodes de désignation des broches. En mode BCM, les numéros de port GPIO connus sont utilisés exactement comme dans Scratch. En mode BOARD, les désignations correspondent aux numéros de broches du circuit imprimé du Raspberry Pi. Le mode utilisé est habituellement le mode BCM. Ainsi, et pour faciliter la comparaison des programmes Python avec les programmes Scratch, nous utiliserons également le mode BCM dans ce calendrier de l’Avent.



La fonction GPIO.setup initialise une broche GPIO comme sortie ou entrée. Le premier paramètre désigne la broche en fonction du mode prédéfini, BCM ou BOARD, avec son numéro GPIO ou son numéro de broche. Le deuxième paramètre peut être soit GPIO.OUT pour une sortie, soit GPIO.IN pour une entrée.

for i in range(10):

Les boucles contenant for traitent un nombre précis de cycles. Ici, il est possible de saisir un chiffre simple, une plage de valeurs ou une fonction de calcul dans le paramètre range().

Les indentations sont importantes dans Python La plupart des langages de programmation utilisent les indentations pour les boucles de programme ou pour les décisions, afin de rendre le code du programme plus clair. Ces indentations ne sont pas seu-lement utilisées pour une meilleure visibilité dans Python, mais elles sont absolument nécessaires aussi pour la logique du programme. En revanche, ce langage n’utilise pas de caractères spéciaux pour marquer la fin des boucles ou des décisions.



Les lignes indentées sont exécutées une fois dans chaque séquence de boucle. La fonction GPIO.output définit le statut d’une broche GPIO. Chaque broche peut avoir deux statuts différents. True active la broche, False la désactive à nouveau. Les lignes ci-dessus activent les voyants LED reliés à la broche GPIO 4 et désactivent les voyants LED reliés à la broche GPIO 10.

time.sleep(0.5)

Le programme fait une pause d’une demi-seconde.



time.sleep(0.5)

Ensuite, les voyants LED reliés à la broche GPIO 10 sont activés et les voyants LED reliés à la broche GPIO 4 sont désactivés. Le programme fait ensuite une nouvelle pause d’une demi-seconde.

GPIO.cleanup()

La dernière ligne n’est plus indentée, elle sera exécutée uniquement lorsque la boucle aura atteint le dernier cycle de la séquence. À la fin d’un programme, il faudra réinitialiser toutes les broches GPIO utilisées pour éviter les messages d’avertissement lors du démarrage du programme suivant. La ligne ci-dessus exécute cette commande une seule fois pour toutes les broches initialisées par le programme. Les broches qui ont été initialisées par d’autres programmes restent inchangées. Ainsi, le cycle des autres programmes fonctionnant potentiellement en parallèle ne sera pas perturbé.

4e jour

Aujourd’hui dans le calendrier de l’Avent • 1 bouton

• 1 barrette à broches (3 broches)

Commuter les voyants LED avec le bouton L’expérience du 4e ne commute pas automatiquement les voyants LED, mais uniquement lorsque l’utilisateur appuie sur un bouton.

Composants : 1 platine enfichable, 1 voyant LED rouge avec résistance

en série intégrée, 1 voyant LED vert avec résistance en série préinstallée, 1 bouton, 5 câbles de raccordement GPIO, 3 barrettes à broches (3 broches)

Commuter les voyants LED avec le bouton.

Le programme Le programme fonctionne comme celui du 2e jour. Ici aussi, les deux voyants LED sont allumés et éteints en alternance via une boucle infinie. Contrairement au programme précédent, la commutation ne se fait pas après un temps défini, mais uniquement lorsque l’utilisateur a actionné le bouton.

Le programme 04taster01 commande les deux voyants LED à l’aide d’un bouton.

Au début, la broche GPIO 7 est définie comme entrée en plus des deux autres sorties. Les entrées du Raspberry Pi traitent les signaux logiques numériques. Si une entrée est reliée à une tension de +3,3 V, elle reçoit le signal logique High, ce qui correspond à 1 dans Scratch ; si une entrée est reliée à GND, elle reçoit le signal logique Low, ce qui correspond à 0 dans Scratch.

Attention N’utilisez jamais les broches +5 V du Raspberry Pi pour les signaux logiques dans les circuits. La tension de 5 V entraînerait la surcharge des entrées GPIO et l’endommagement du Raspberry Pi.

Une pression sur le bouton relie dans notre circuit la broche GPIO 7 à la tension de +3,3 V. Si le bouton est relâché, l’entrée obtient un statut indéfini, ce qui ne doit jamais arriver en électronique numérique. Pour de tels cas, toutes les broches GPIO sont équipées de résistances dites Pull-down, qui ramènent une entrée sans signal automatiquement sur Low.

Définissez la broche GPIO pour le bouton avec la commande config7inpulldown afin d’activer la résistance Pull-down intégrée au niveau de l’entrée.

Lorsqu’un voyant LED s’allume, le programme n’attend plus un certain temps spécifique, mais s’arrête jusqu’à ce qu’un événement spécifique se produise grâce au bloc attendre jusqu’à.... Dans ce cas jusqu’à ce que la broche GPIO 7 obtienne la valeur 1, soit jusqu’à ce que le bouton soit actionné.

Pour la requête proprement dite, le bloc attendre jusqu’à... contient un champ allongé à extrémités pointues. Il faut ajouter ici un bloc de la palette verte de blocs Opérateurs. Glisser et déposer le bloc affichant le signe égal dans le champ de joker du bloc attendre jusqu’à....

Cet opérateur est toujours vrai lorsque les deux valeurs à gauche et à droite du signe égal sont égales.

Dans notre cas, la valeur de la broche GPIO 7 doit être égale à la valeur 1. Le chiffre 1 correspond à High. Entrez donc le chiffre 1 dans le champ de texte de droite du bloc vert.

Cliquez ensuite une fois sur le drapeau vert en haut à droite pour démarrer le programme encore incomplet. Cela permet de définir les broches GPIO. Cliquez ensuite à nouveau sur le panneau d’arrêt rouge.

Pour l’interrogation d’entrées GPIO, le bloc Valeur du capteur... de la palette bleue de blocs Capter est utilisé. Sélectionnez le capteur GPIO-7 dans la liste déroulante du bloc bleu. Outre quelques capteurs prédéfinis, toutes les broches GPIO définies comme entrées sont proposées. C’est pourquoi il a fallu brièvement démarrer le programme.

Glissez et déposez ensuite le bloc bleu Valeur du capteur... dans le champ de gauche du bloc vert au sein du bloc attendre jusqu’à....

Le programme fait ensuite une pause de 0,2 seconde à l’aide du bloc patienter...sec.. Cela empêche que le bouton soit immédiatement identifié comme étant actionné lorsque le programme reste en marche. L'utilisateur dispose du temps défini pour relâcher le bouton.

C’est seulement après que les voyants LED seront commutés, puis le programme attend à nouveau que l’utilisateur appuie sur le bouton.

Duplication des blocs

Lors de la compilation d’un programme Scratch, vous n’avez pas besoin de créer chaque fois des combinaisons de blocs similaires. Faites un clic droit sur le premier bloc à dupliquer. Cliquez ensuite sur Dupliquer dans le menu. Tous les blocs sous-jacents seront automatiquement dupliqués. Les blocs dupliqués peuvent ensuite être insérés à l’endroit souhaité du programme.

5e jour


Commuter les voyants LED de la pyramide de Noël avec Python Le programme du 5e jour utilise Python pour commuter deux voyants LED avec un bouton. Les voyants LED peuvent être reliés à la pyramide de Noël cette fois ci et sont directement raccordés au Raspberry Pi via les câbles de raccordement GPIO.

Composants : 1 platine enfichable, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED vert avec résistance en série intégrée, 1 bouton, 6 câbles de raccordement GPIO, 1 barrette à broches (3 broches)

Deux voyants LED sur la pyramide et un bouton sur la platine enfichable.

La pyramide de Noël Au dos du calendrier de l’Avent se trouvent deux pièces à découper qui forment une pyramide de Noël lorsqu’elles sont assemblées.

Les deux composants de la pyramide de Noël.

Pliez la partie ovale le long des lignes pointillées et entaillez les segments de ligne courts sur les deux pièces. Les trous circulaires de la partie triangulaire sont prévus pour les voyants LED. Assemblez ensuite la pyramide de Noël comme illustré.

L’assemblage de la pyramide de Noël s’effectue de la manière suivante.

Le programme Contrairement au programme Scratch de la veille, le voyant LED rouge relié à la broche 4 s’allume avec le programme Python 05pyramide01.py tant que le bouton est appuyé. Une fois que le bouton est relâché, c’est le voyant LED vert relié à la broche 10 qui s’allume.

#!/usr/bin/python


import time




GPIO.setup(7, GPIO.IN, GPIO.PUD_DOWN)

try:

while True:

if GPIO.input(7)==True:



else:



except KeyboardInterrupt:

GPIO.cleanup()

Le programme fonctionne comme suit GPIO.setup(7, GPIO.IN, GPIO.PUD_DOWN)

Après l’initialisation déjà connue des broches GPIO pour les voyants LED, la broche 7 est initialisée comme entrée pour le bouton. Le paramètre GPIO.PUD_DOWN active la résistance Pull-down interne.

try:

while True:

Ces lignes initient une boucle infinie avec option d’arrêt. La boucle while fonctionne à l’infini puisque la condition True est toujours vraie. La commande try activée en amont permet cependant une condition d’arrêt un peu plus bas dans except.

if GPIO.input(7)==True:



else:



Le mot if (si en français) introduit une condition. Si cette condition est remplie, la partie indentée suivante du programme est exécutée.

== n’est pas égal à = Le double signe égal == correspond à une requête d’égalité, tandis que le signe égal simple = est utilisée pour les affectations de variables.

En cas d’actionnement du bouton de la broche 7, celle-ci obtient la valeur True. Le voyant LED relié à la broche 4 est allumé, tandis que le voyant LED relié à la broche 10 est éteint.

L’élément de programme à exécuter si la condition est remplie peut être accompagné d’un autre bloc contenant le mot clé else. L’élément de programme suivant est exécuté si la condition n’est pas remplie.

Si le bouton de la broche 7 n’est pas actionné, le voyant LED relié à la broche 10 est allumé, tandis que le voyant LED relié à la broche 4 est éteint.


GPIO.cleanup()

Le raccourci clavier [Ctrl]+[C] permet de déclencher la condition d’arrêt. Cela arrête la boucle et les broches GPIO sont réinitialisées.

6e jour

Aujourd’hui dans le calendrier de l’Avent • 1 voyant LED jaune avec résistance en série intégrée

Le chat Scratch active les voyants LED Le chat sur la plate-forme Scratch, dans le panneau en haut en droite, n’est pas une simple figure symbolique de Scratch, mais plutôt un objet librement programmable pouvant exécuter les actions les plus diverses. Dans l’expérience du 6e jour, le chat va fonctionner à travers trois bandes de couleur différentes – vert, jaune et rouge – activées en arrière-plan. Les voyants LED correspondants seront activés en fonction de la couleur d’arrière-plan activée par le chat.

Composants : 1 platine enfichable, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED jaune avec résistance en série intégrée, 1 voyant LED vert avec résistance en série, 4 câbles de raccordement GPIO, 2 barrettes à broches (3 broches)

Le chat de Scratch active trois voyants LED.

Le programme Le programme utilise la plate-forme Scratch, une fenêtre de sortie graphique en haut à droite de l’écran Scratch. L’image d’arrière-plan peut être peinte avec le programme de peinture installé dans Scratch.

Le programme 06katze01 permet au chat Scratch de commander trois voyants LED.

Le programme de peinture d’arrière-plan de Scratch.

Pour modifier l’arrière-plan, cliquez dans la palette d’objets en haut à droite de l’écran Scratch sur l’icône blanche de scène.

La fenêtre du programme Scratch est vide, puisque les blocs de programme ne peuvent pas être directement utilisés pour la plate-forme. Cliquez en haut sur l’onglet Arrière-plans puis sélectionnez Modifier. Le programme de peinture démarre alors, offrant les fonctions essentielles d’un logiciel graphique simple.

Utilisez l’icône du rectangle et la palette de couleurs à gauche en bas pour peindre trois barres de couleur verte, jaune et rouge en arrière-plan.

Fermez ensuite le programme de peinture en cliquant sur OK, puis cliquez sur le chat en bas à droite de la palette d’objets, dénommé ici Objekt1, puis cliquez à nouveau sur l’onglet Scripts dans lequel vous compilez le programme.

Après le démarrage, les trois broches GPIO sont d’abord définies comme sorties pour les voyants LED : config4out, config22out, config11out.

Ensuite le chat est placé dans la position de sortie de la barre verte sur le bord gauche de la plate-forme. Pour ce faire, nous utilisons le bloc aller à x:... y:... de la palette de blocs Mouvement. Le chat est ainsi amené à une position de coordonnées absolue.

La plate-forme Scratch s’étend longitudinalement entre les coordonnées -240 et 240 dans la direction horizontale x. Par défaut, le chat est positionné sur 0,0, exactement au centre. Ayant lui-même une longitude de 100, il obtient une bonne position de départ avec les coordonnées x:-150 y:0 entrées dans le bloc pour se déplacer à travers la plate-forme.

Une boucle infinieest alors activée, qui produit un mouvement continu du chat.

Une autre boucle est activée au sein de celle-ci, qui est répétée 30 fois exactement. Étant donné que le chat doit effectuer dix unités de coordonnées à chaque pas dans la direction x, il atteint au bout de 30 répétitions à x:150 y:0 la position de retour au bord droit de la plate-forme.

Trois commandes si...sinon se succèdent dans la boucle, dont chacune vérifie si le chat touche une couleur d’arrière-plan spécifique. Dans ce cas, le bloc est exécuté au sein de la parenthèse supérieure si. Si ce n’est pas le cas, l’autre bloc de la parenthèse inférieure sinon sera exécuté.

Pour la vérification, nous utilisons le bloc si la couleur... est touchée de la palette de blocs Capter. Cliquez sur le champ coloré du bloc, un curseur apparaît sous forme de pipette, permettant de sélectionner la couleur souhaitée par clic sur la plate-forme Scratch.

La première interrogation si...sinon vérifie si le chat a touché la couleur verte de la barre médiane. Si c'est le cas, le voyant LED vert relié à la broche 11 sera allumé (gpio11on). Si le chat ne touche pas la barre verte au moment de l’interrogation, le voyant LED s’éteint

(gpio11off).

C’est de la même manière que la deuxième interrogation si...sinon allume et éteint le voyant LED jaune relié à la broche 22 en cas de contact de la barre jaune. La troisième interrogation si...sinon allume et éteint le voyant LED relié à la broche 4 en cas de contact avec la barre rouge.

Le chat effectue ensuite un déplacement de dix unités de coordonnées. Le bloc fait...xx pas de la palette de blocs Mouvement déplace rela-tivement un objet de sa position actuelle, contrairement au bloc aller à x:... y:... utilisé au départ, qui déplace un objet jusqu’à une position de coordonnées absolue.

Pour permettre un meilleur suivi des mouvements, le programme patiente 0,2 secondes après chaque pas, avant que la boucle interne redémarre et que le chat fasse le prochain pas.

Si le chat a atteint le côté droit de la plate-forme après 30 pas, il devra faire une rotation à 180 degrés. Pour ce faire, nous utilisons le bloc rotation... degrés de la palette de blocs Mouvement. Afin que le chat ne soit pas inversé après la rotation, activez l’icône de double flèche au-dessus de la zone de script du chat.

La boucle infinie est alors activée et le chat retourne à sa position de départ. Les mouvements utilisés n’étant que des mouvements relatifs, il n’est pas nécessaire de faire la distinction entre la marche à droite et la marche à gauche dans le script.

Ce symbole permet de commuter entre la rotation et la marche à gauche/droite.

7e jour


Activer les voyants LED avec une appli de smartphone Certains des circuits assemblés avec ce calendrier de l’Avent sont commandés via une appli mobile. Pour ce faire, il faudra programmer un site Web mobile et y accéder à partir du smartphone. Le site Web mobile fonctionne sur n’importe quel smartphone avec connexion WLAN et navi-gateur installé. En outre, vous pouvez accéder au site programmé via le navigateur du Raspberry Pi ou du PC. Il est important que le smartphone et le Raspberry Pi se trouvent sur le même réseau. Vous devrez également effectuer les étapes suivantes :

• Étape 1 : installer le serveur Web

• Étape 2 : installer PHP5

Étape 1 : installer le serveur Web

Afin que le site Web puisse fonctionner sur Raspberry Pi et puisse être ouvert à partir de votre smartphone, il est nécessaire d’installer un serveur Web. Nous utilisons le serveur Apache HTTP. Pour l’installation, ouvrez LXTerminal via le menu Accessoires.

Entrez la commande suivante dans la fenêtre ouverte du LXTerminal :

sudo apt‐get install apache2

Le serveur Web est ensuite téléchargé et installé. Vous pouvez tester l’installation directement via le smartphone (ou via le navigateur du Raspberry Pi). Il vous faut pour cela l’adresse IP du Raspberry Pi. Pour ce faire, déplacez la souris au-dessus du symbole de réseau en haut à droite sur le bureau.

Ouvrez le navigateur à partir de votre smartphone et entrez http://<IP‐Adresse Raspberry PI>. La capture d’écran illustrative affiche l’adresse http://192.168.178.44.

Cliquez sur l’élément de menu pour ouvrir l’invite de commandes.

Le bureau du Raspberry Pi affiche l’adresse IP.

La page de test sur le smartphone. L’installation du serveur Web est ainsi terminée.

L’adresse affichée sur votre Raspberry Pi sera probablement différente. Vous pouvez aussi tester le serveur Web via le navigateur de votre Raspberry Pi. Entrez pour cela l’adresse http://localhost pour que la page de test s’affiche dans le navigateur.

Étape 2 : installer PHP5

La commande phpinfo() fournit des informations système sur l’installation PHP sous forme d’une page Web.

Après le test réussi du serveur Web, il vous faudra installer PHP5. Démarrez pour cela LXTerminal et mettez à jour le système via la commande suivante :

sudo apt‐get update

Installez PHP5 via la commande suivante :

sudo apt‐get install php5

Testez ensuite l’installation. Restez pour ce faire dans LXTerminal. Entrez la commande cd /var/www pour passer au répertoire et entrer les droits d’écriture de tous les utilisateurs pour le répertoire HTML /var/www/html :

chmod ‐R a+w html

La commande cd html permet de passer au répertoire HTML, tandis que la commande touch phpinfo.php permet de créer un fichier vierge portant le nom phpinfo.php. Ouvrez ce fichier pour l’éditer avec la commande nano phpinfo.php. Entrez le code source suivant dans le fichier :

<?php

phpinfo();

?>

Sauvegardez le fichier avec le raccourci clavier [Ctrl]+[O]. L’éditeur demande de saisir un nom de fichier. Confirmez la proposition avec la touche [Enter]. Fermez l’éditeur avec le raccourci clavier [Ctrl]+[X].

Ouvrez le fichier dans le navigateur en entrant http://<IP-Adresse-Raspberry-Pi>/phpinfo.php sur votre smartphone ou http://localhost/phpinfo.php dans le navigateur du Raspberry Pi.

Réalisation du projet Vous avez maintenant réuni toutes les conditions pour la réalisation de la première appli mobile. Nous devons commencer par assembler le circuit. Nous avons besoin des composants suivants à cet effet.

Composants : 1 platine enfichable, 1 voyant LED rouge avec résis-tance en série intégrée, 2 câbles de raccordement GPIO, 2 barrettes à broches (3 broches)

L’appli permet d’allumer un voyant LED qui s’éteindra à nouveau après expiration du temps défini.

Le programme Le programme Python 07led.py du répertoire tag07 est utilisé pour la commande du voyant LED. Le voyant LED s’allume, puis s’éteint à nouveau au bout d’une seconde. Vous pouvez influencer la durée d’éclairage avec la commande time.sleep(1). Le paramètre est la durée en secondes, dans ce cas donc une seconde.

#!/usr/bin/python


import time




time.sleep(1)

GPIO.cleanup()

L’appli Le site Web mobile est créé au moyen d’un modèle. Vous trouverez ce modèle dans le répertoire app_vorlage de l’archive de téléchargement. Ce répertoire contient le fichier index.php et le répertoire css. Le répertoire css contient quant à lui les modèles de style pour l’appli mobile. Le fichier index.php est le modèle proprement dit de l’appli. Ce modèle sera nécessaire pour des journées différentes.

Étape 1 : copier le modèle dans le répertoire du serveur Web

Le contenu de /var/www/html/tag07 après que le modèle a été copié.

Ouvrez le LXTerminal et allez au répertoire /var/www/html :

cd /var/www/html

Créez dans ce répertoire un nouveau répertoire portant le nom tag07 :

mkdir tag07

Allez au répertoire et copiez le contenu du répertoire app_vorlage ainsi que le fichier 07led.py dans le répertoire nouvellement créé. Le répertoire devrait maintenant se présenter comme illustré ci-contre.

Vous pouvez maintenant ouvrir le modèle dans le navigateur du Raspberry Pi via l’adresse http://localhost/tag07/index.php.

Étape 2 : adapter le modèle

Le modèle copié dans le navigateur du Raspberry Pi.

Ouvrez ensuite le fichier index.php à partir du répertoire tag07 en entrant nano index.php dans LXTerminal. Le fichier contient entre autres le bloc suivant :

<form action="index.php" method="post">

</form>

Ce bloc représente un formulaire qui permet d’envoyer des commandes au serveur Web et donc au Raspberry Pi. Un bouton est nécessaire pour éteindre le voyant LED. Modifiez pour cela le bloc comme suit :


<input name="licht_an" id="licht_an" type="submit" value="Licht an" style="background‐color: #4180C5">

</form>

Vous créez ainsi un bouton bleu avec l’inscription Éclairage actif. Pour changer la couleur, modifiez la valeur dans background‐color. Pour éditer le texte, adaptez-le dans value. Sauvegardez le fichier avec [Ctrl]+[O] puis fermez l’éditeur avec [Ctrl]+[X]. Entrez http://localhost/tag07/index.php pour ouvrir à nouveau le fichier index.php dans le navigateur.

Le modèle adapté dans le navigateur du Raspberry Pi.

Il faut maintenant associer le modèle au script Python. L’ouverture du script s’effectue via PHP. Modifiez le début du fichier index.php comme suit :

<head>

<?php

if ($_POST["licht_an"])

echo shell_exec(‘sudo /var/www/html/tag07/07led.py’);

?>

<title>Conrad Raspberry Pi Adventskalender</title>

Ouvrez à nouveau le fichier avec nano index.php. La ligne <?php introduit la section PHP et la ligne ?> la termine. En cliquant sur le bouton Éclairage actif, une post-requête est envoyée qui est évaluée par le site. Vous pouvez accéder aux valeurs transmises avec $_POST. Pour la défi-nition du bouton, nous avons réglé l’ID et le nom du bouton sur licht_an :

<input name="licht_an" id="licht_an" type="submit" value="Licht an" style="background‐color: #4180C5">

Dans l’interrogation If, la commande $_POST["licht_an"] permet de vérifier si le bouton a été actionné (dans ce cas la valeur est alors transmise). Dans ce cas, le script Python est ouvert via la commande echo shell_exec. Le site Web mobile est maintenant prêt.

Rien ne se passe encore si vous ouvrez la page dans le navigateur et cliquez sur le bouton. Il vous faut d’abord définir les privilèges.

Étape 3 : définir les privilèges

Ouvrez à nouveau LXTerminal et allez au répertoire du jour 7 via la commande cd /var/www/html/tag07. Donnez le droit d’exécution au fichier :

chmod a+x 07led.py

Vous devez maintenant autoriser le serveur Web à exécuter ce script. Pour ce faire, exécutez la commande suivante :

sudo visudo

Entrez ensuite la ligne suivante :

www‐data ALL=(ALL) NOPASSWD: /var/www/html/tag07/07led.py

Sauvegardez le fichier avec [Ctrl]+[O] puis fermez-le avec le raccourci clavier [Ctrl]+[X].

Étape 4 : test de l’appli

Vous y êtes arrivé et pouvez maintenant tester l’appli sur votre smartphone. Démarrez le navigateur sur votre smartphone ; accédez à la page via

http://<IP-Adresse Raspberry Pi/tag07/index.php et cliquez sur le bouton Éclairage actif. L’éclairage devrait maintenant s’allumer.

Vous pouvez maintenant activer l’éclairage via le smartphone.

8e jour

Aujourd’hui dans le calendrier de l’Avent • 1 bouton

Variation des voyants LED Les voyants LED peuvent avoir deux états différents : allumés et éteints. Cela vaut aussi pour les ports GPIO définis comme sorties numériques. Il serait donc théoriquement impossible de varier un voyant LED.

Une petite astuce permet cependant de régler la luminosité d’un voyant LED sur un port GPIO numérique. Si on laisse un voyant LED clignoter suffisamment vite, l’œil humain ne parvient plus à percevoir le clignotement. La technique de la modulation d’impulsions en durée (PWM) produit un signal à impulsions qui s’active et se désactive en intervalles très courts. La tension du signal ne varie jamais, seul le rapport entre le niveau False (0 V) et le niveau True (+3,3 V) varie. Le rapport cyclique indique le rapport entre la longueur de l’état activé et la durée totale d’un cycle de commutation. Plus le rapport cyclique est court, plus la durée d’éclairage du voyant LED est courte dans un cycle de commutation. Ainsi, le voyant LED semble plus sombre qu’un voyant LED activé en permanence.

Composants : 1 platine enfichable, 1 voyant LED jaune avec résistance en série intégrée, 2 boutons, 6 câbles de raccordement GPIO, 3 barrettes à broches (3 broches)

À gauche : rapport cyclique de 50% – à droite : rapport cyclique de 20%.

Les deux boutons varient l’éclairage des voyants LED.

L’un des câbles de raccordement GPIO est utilisé pour relier deux rangées de contact de la platine enfichable via lesquelles les deux boutons sont raccordés au port +3,3-V-Pn du Raspberry Pi.

Le programme

L’un des deux boutons rend progressivement l’éclairage du voyant LED plus clair, tandis que l’autre l’assombrit un peu

plus à chaque actionnement

Le programme 08pwm01 permet de varier l’éclairage d’un voyant LED au moyen de deux boutons.

Le programme commence par définir la broche GPIO 4 comme sortie avec fonction PWM. Pour une broche ainsi définie, Scratch propose des

Variables dans Scratch Les variables sont de petits espaces mémoire dans lesquels un programme enregistre un chiffre ou quoi que ce soit d’autre. Ces mémoires de variables sont automatiquement effacées à la fermeture du programme. Les variables doivent préalablement être créées dans la palette de blocs Variables avant de pouvoir être utilisées. Vous pouvez ensuite glisser et déposer le symbole des variables nouvellement créées de la palette de blocs vers le champ d’un bloc prévu à cet effet dans le programme. La palette de blocs dispose en outre de différents blocs supplémentaires permettant de lire ou de modifier les variables.

fonctions spéciales pour la commande d’un signal PWM.

La variable pwm préalablement définie sera ensuite réglée sur la valeur 0. Dans cet état, la broche PWM est complètement désactivée. Une boucle infinie interroge ensuite les deux boutons, modifie la variable pwm lorsqu’un bouton a été actionné et règle la broche GPIO 4 sur la nouvelle valeur.

Les interrogations « si » vérifient deux conditions avec un bloc et. Ces deux conditions doivent être remplies pour pouvoir régler la variable pwm vers le haut ou vers le bas.

Il faut d’une part actionner le bouton, et d’autre part la variable pwm ne peut pas dépasser le seuil de 500 ou de 0. Ainsi il est vérifié lors de l’augmentation de la valeur si elle est encore inférieure à 500, alors qu’elle doit être supérieure à 0 lors de la réduction de la valeur.

Pour chaque variable, un bloc sera créé dans la palette de blocs Variables, que vous pourrez utiliser dans d’autres blocs Scratch pour évaluer le contenu de ces variables.

Le bloc modifier… de… modifie relativement la variable par rapport à la valeur actuelle. Dans ce cas, la valeur 10 est ajoutée ou soustraite.

Indépendamment du résultat des deux interrogations si, la broche GPIO est réglée sur la valeur actuelle des variables.

Pour cela nous utilisons le bloc relie … …, qui relient deux textes différents en un seul texte en les insérant l’un après l’autre. Les chiffres sont traités ici comme du texte. Ils ne sont donc pas additionnés mais également insérés l’un après l’autre.

Entrez la chaîne de caractères gpio4pwm dans le premier champ du bloc, puis déplacez la variable pwm dans le deuxième champ. Ainsi une broche PWM est réglée sur une valeur spécifique.

Le voyant LED s’allume avec le niveau de luminosité réglé, puis la boucle infinie redémarre et interroge à nouveau pour savoir si un bouton a été actionné.

9e jour

Aujourd’hui dans le calendrier de l’Avent • 1 barrette à broches (3 broches)

Variation des voyants LED avec Python L’expérience du 9e jour permet de varier l’éclairage d’un voyant LED avec deux boutons via un programme Python. Le principe est semblable à celui du programme Scratch du jour 8.

Composants : 1 platine enfichable, 1 voyant LED jaune avec résistance en série intégrée, 2 boutons, 6 câbles de raccordement GPIO, 3 bar-rettes à broches (3 broches)

Les deux boutons varient l’éclairage du voyant LED.

Le programme Le programme 09pwm01.py montre comment les signaux PWM sont émis avec Python.

#!/usr/bin/python


import time

Formatiert: Englisch (USA)


LED = 4

T1 = 16

T2 = 7

GPIO.setup(LED, GPIO.OUT)

GPIO.setup(T1, GPIO.IN, GPIO.PUD_DOWN)

GPIO.setup(T2, GPIO.IN, GPIO.PUD_DOWN)

pwm = 0

p = GPIO.PWM(LED, 50)

p.start(pwm)

try:

while True:

if GPIO.input(T1)==True and pwm<100:

pwm += 10

if GPIO.input(T2)==True and pwm>0:

pwm ‐= 10

p.ChangeDutyCycle(pwm)

time.sleep(0.1)


p.stop()

GPIO.cleanup()

Le programme fonctionne comme suit LED = 4

T1 = 16

T2 = 7

Nous utilisons cette fois des variables pour les numéros des broches utilisées pour le voyant LED et pour les deux boutons. Cela rend le pro-gramme plus compréhensible, puisqu’on voit immédiatement de quelle broche il s’agit. En outre, le circuit est facile à assembler, il suffit de changer la broche à l’endroit correspondant.


La fonction GPIO.PWM() de la bibliothèque GPIO est déterminante pour l’émission des signaux PWM. Cette fonction requiert deux paramètres : la broche GPIO et la fréquence du signal PWM. Dans notre cas, la broche GPIO est définie via la variable LED, tandis que la fréquence est de 50 Hertz (oscillations par seconde).

Pourquoi est-ce que la fréquence de 50 Hertz est la fréquence idéale pour PWM L’œil humain ne perçoit pas les changements de lumière plus rapides que 20 Hertz. Étant donné que le réseau à courant alternatif utilise une fréquence de 50 Hertz en Europe, de nombreux luminaires clignotent à cette fréquence. Si un voyant LED clignote à une fréquence de plus de 20 Hertz, mais inférieure à 50 Hertz, cela peut causer des interférences avec d’autres sources de lumière et l’effet de variation n’est plus uniforme.

GPIO.PWM() génère un objet qui est enregistré dans les variables p. De tels objets sont bien plus que de simples variables. Les objets peuvent avoir diverses propriétés et être influencés par les méthodes. Les méthodes sont indiquées directement derrière le nom de l’objet, avec un simple point comme marque de séparation.

p.start(pwm)

La méthode start() lance la génération du signal PWM. Il faudra encore indiquer un rapport cyclique. Le rapport cyclique est de 0 dans notre cas, qui a préalablement été enregistré dans les variables pwm. Le voyant LED est donc toujours éteint. Contrairement à Scratch où les valeurs PWM se situent entre 0 et 500, Python utilise des valeurs comprises entre 0 et 100, qui correspondent directement au pourcentage de temps pendant lequel la broche est activée au court d’un cycle de fréquence. Une valeur PWM de 25 permet donc au voyant LED de rester allumé pendant un quart du temps, alors qu’il est éteint pendant le temps restant du cycle.

try:

while True:

if GPIO.input(T1)==True and pwm<100:

pwm += 10

if GPIO.input(T2)==True and pwm>0:

pwm ‐= 10

Une nouvelle boucle infinie démarre, qui interroge d’abord les deux boutons et qui modifie la variable pwm comme dans le programme Scratch, tant que les seuils ne sont pas atteints.


Dans chaque cycle de boucle, la méthode ChangeDutyCycle() règle le rapport cyclique de l’objet PWM sur la valeur actuelle de la variable pwm.

time.sleep(0.1)

Le programme fait ensuite une pause de 0,1 seconde jusqu’au prochain cycle de la boucle. Cela empêche qu’une pression accidentellement prolongée du bouton soit analysée comme plusieurs pressions du bouton.


p.stop()

GPIO.cleanup()

Le raccourci clavier [Ctrl]+[C] permet de couper le signal PWM avant la réinitialisation des broches GPIO.

10e jour


Variation des voyants LED avec l’appli L’expérience du 10e jour permet de varier l’éclairage d’un voyant LED via une appli mobile. Les composants suivants sont requis pour l’assemblage du circuit :

Composants : 1 platine enfichable, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED jaune avec résistance en série intégrée, 4 câbles de raccordement GPIO

L’éclairage des deux voyants LED est varié via une appli mobile.

Le programme La variation de l’éclairage des voyants LED s’effectue au moyen d’une appli. Il faudra un bouton pour augmenter et abaisser la luminosité. Un script Python est exécuté à l’actionnement du bouton. Deux programmes sont requis puisque deux actions différentes doivent être exécutées. Pour augmenter la luminosité utilisez le programme 10pwm_auf.py :

#!/usr/bin/python

#10pwm_auf.py


import time


LED = 4


pwm = 0


p.start(pwm)

while pwm<100:

pwm += 5


time.sleep(0.1)

p.stop()

GPIO.cleanup()

Formatiert: Französisch (Frankreich)

Pour réduire la luminosité utilisez le programme 10pwm_ab.py :

#!/usr/bin/python

#10pwm_ab.py


import time


LED = 22


pwm = 100


p.start(pwm)

while pwm>0:

pwm ‐= 5


time.sleep(0.1)

p.stop()

GPIO.cleanup()

L’appli Si vous n’avez pas encore installé le serveur Web et PHP5, procédez comme décrit au jour 7.

Pour la réalisation de l’appli, il faudra à nouveau effectuer les mêmes quatre étapes que celles du jour 7.


Vous devrez d’abord commencer par copier à nouveau le modèle app_vorlage dans un répertoire du serveur Web. Procédez selon l’étape 1 du 7e jour. Nommez votre répertoire tag10 au lieu de tag07.


Ouvrez le fichier index.php à partir du répertoire tag10 en entrant nano index.php dans LXTerminal. Ajoutez les boutons nécessaires au bloc form vide :


<input name="hoch" id="hoch" type="submit" value="Hochdimmen"

style="background‐color: #4180C5">

<input name="runter" id="runter" type="submit" value="Runterdimmen"


</form>

Cela permet de créer deux boutons bleus avec les inscriptions Augmentation et Réduction. Sauvegardez le fichier avec [Ctrl]+[O] puis fermez l’éditeur avec [Ctrl]+[X]. Ouvrez à nouveau le fichier index.php dans le navigateur via http://localhost/tag10/index.php.

Le modèle doit maintenant être associé aux deux scripts Python. Modifiez pour cela le début du fichier index.php comme suit :

<head>

<?php

if ($_POST["hoch"])

echo shell_exec(‘sudo /var/www/html/tag10/10pwm_auf.py’);

elseif ($_POST["runter"])

echo shell_exec(‘sudo /var/www/html/tag10/10pwm_ab.py’);

?>


Le site Web mobile est prêt et vous pouvez maintenant passer à la définition des droits.

Étape 3 : définir les droits

Ouvrez à nouveau LXTerminal et allez au répertoire du jour 10 via la commande cd /var/www/html/tag10. Définissez des droits d’exécution pour les scripts :

chmod a+x 10*.py

Formatiert: Französisch (Frankreich)


sudo visudo

Entrez les lignes suivantes :

www‐data ALL=(ALL) NOPASSWD: /var/www/html/tag10/10pwm_auf.py

www‐data ALL=(ALL) NOPASSWD: /var/www/html/tag10/10pwm_ab.py



Vous y êtes arrivé et pouvez maintenant tester l’appli sur votre smartphone. Démarrez le navigateur sur votre smartphone et ouvrez la page http://<IP-Adresse Raspberry Pi/tag10/index.php pour pouvoir varier l’éclairage.

Vous pouvez maintenant varier l’éclairage via le smartphone.

11e jour

Aujourd’hui dans le calendrier de l’Avent • 1 servo

Commande du servo Un servo est un petit moteur qui fait tourner un bras de servo ou d’autres pièces mobiles dans une position spécifique. La plupart des servos ont une plage de rotation de 180 degrés et n’effectuent donc pas beaucoup de séquences de rotation comme sur les moteurs classiques.

Composants : 1 servo, 1 barrette à broches (3 broches), 3 câbles de raccordement GPIO

Commande du servo avec un programme Scratch.

Dans cet expérience, le servo est raccordé directement au Raspberry Pi via un câble de raccordement GPIO et une barrette à broches, sans la platine enfichable. Les fils rouge et noir servent à l’alimentation électrique, alors que le servo reçoit les signaux de commande sur le fil jaune.

Le programme Scratch propose des codes spéciaux pour la commande du servo, tandis que cette commande est initiée par des signaux PWM dans d’autres langages de programmation.

Le programme 11servo01 commande un servo via des actions du clavier.

Cette fois, le programme est composé de plusieurs blocs indépendants qui sont déclenchés par divers événements. Un clic sur le drapeau vert dans Scratch permet de définir la broche 18 comme sortie pour le signal de commande du servo, tandis que la variable s est réglée sur 0. Celle-ci est utilisée pour le signal de commande.

Scratch fournit un signal de commande au servo, qui correspond au pourcentage du déport maximal dans une direction. À 0%, le servo se trouve en position médiane, à 100% il est en position de butée (en général environ 90 degrés), et à -100% il se trouve au niveau de l’autre butée.

Directement après l’initialisation, le bloc relie… … permet d’envoyer le signal servo18%0. 18 correspond ici à la broche GPIO et 0 à l’angle du servo.

Trois blocs Si bouton … appuyé démarrent automatiquement les actions lorsque le bouton correspondant est actionné sur le clavier. Aucune boucle de programme n’est requise dans Scratch pour attendre l’action correspondante, comme c’est le cas pour les boutons raccordés.

La touche [Pfeilæ] règle la variable s sur -100 et tourne le servo jusqu’à une butée ; la touche [PfeilÆ] règle la variable s sur 100 et tourne le servo jusqu’à l’autre butée. La touche [Pfeil½] tourne le servo dans la position médiane.

Les servos ont tendance à ne pas s’immobiliser dans une position spécifique, mais à trembler légèrement. La [toucheEspace] envoie la commande servo18stop et désactive ainsi la broche GPIO. Le servo s’immobilise. Le programme doit ensuite être réactivé via le drapeau vert pour pouvoir

commander à nouveau le servo.

12e jour

Aujourd’hui dans le calendrier de l’Avent • 1 bras de servo avec vis de fixation

Vissez le bras de servo sur le servo à partir du haut en vous servant de la vis courte.

Le servo tourne avec Python L’expérience du 12e jour permet de commander le servo au moyen de deux boutons. Une pression sur l’un des deux boutons permet de tourner le servo d’un pas vers la gauche, tandis que la pression sur l’autre bouton permet de le tourner d’un pas vers la droite.

Composants : 1 servo, 2 boutons, 4 barrettes à broches (3 broches), 6 câbles de raccordement GPIO

Le servo est commandé au moyen de deux boutons.

Veillez lors de l’assemblage du circuit exactement aux rangées de la platine enfichable illustrées dans la figure. Le signal +3,3 V du servo est également utilisé comme signal High pour les boutons.

Le programme Le programme 12servo03.py est similaire au programme de variation de l’éclairage d’un voyant LED au moyen de deux boutons. Python ne disposant pas de fonctions propres aux servos, des signaux PWM seront utilisés comme pour les voyants LED.

À un signal PWM de 50 Hertz, la valeur de 2,5 correspond à une extrémité de la plage de rotation du servo, et la valeur 12,5 correspond à l’autre extrémité.

#!/usr/bin/python


import time

servoPIN = 18

t1 = 16

t2 = 7

pwm = 7.5


GPIO.setup(servoPIN, GPIO.OUT)

GPIO.setup(t1, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

GPIO.setup(t2, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)

p = GPIO.PWM(servoPIN, 50)

p.start(pwm)

try:

while True:

if GPIO.input(t1) == True and pwm < 12.5:

pwm += 2.5


time.sleep(0.5)

p.ChangeDutyCycle(0)

if GPIO.input(t2) == True and pwm > 2.5:

pwm ‐= 2.5


time.sleep(0.5)



p.stop()

GPIO.cleanup()

Le programme fonctionne comme suit servoPIN = 18

t1 = 16

t2 = 7

pwm = 7.5

Au début du programme, des variables sont définies pour les broches GPIO utilisées. La variable pwm est réglée sur une valeur PWM de 7,5, ce qui correspond à la position médiane du servo.

L’initialisation des broches GPIO et du signal PWM correspond à la procédure de variation d’un voyant LED.

if GPIO.input(t1) == True and pwm < 12.5:

pwm += 2.5


time.sleep(0.5)


Les boutons sont à nouveau vérifiés au sein de la boucle infinie. Si un bouton a été actionné et si le seuil n’est pas encore atteint, la variable pwm est modifiée de 2,5 unités dans la direction correspondante.

Le signal PWM est ensuite réglé sur la nouvelle valeur via p.ChangeDutyCycle(pwm), transmettant ainsi une impulsion de commande au servo.

Après une temporisation d’une demi-seconde, le signal PWM est réglé sur 0. Cela empêche le tremblement du servo. Cela peut se produire puisqu’un signal PWM généré par logiciel peut toujours avoir de faibles tolérances.

Le raccourci clavier [Ctrl]+[C] permet de couper le signal PWM et de réinitialiser les broches GPIO.

13e jour

Aujourd’hui dans le calendrier de l’Avent • 1 x pâte à modeler

Formez un pied pour le servo avec la pâte à modeler, afin que celui-ci ne puisse pas basculer facilement. Dans les autres expériences, la pâte à modeler sera aussi utilisée à d’autres fins.

Commande du servo via l’appli Aujourd’hui, on utilisera le circuit du jour 11. La commande du servo s’effectuera au moyen d’une appli mobile.

Composants : 1 servo, 1 barrette à broches (3 broches), 3 câbles de raccordement GPIO

Vous avez déjà assemblé le circuit avant-hier.

Le programme La rotation du servo s’effectue au moyen d’une appli. Il faudra un bouton pour la rotation à gauche et à droite. Un script Python doit être exécuté à l’actionnement du bouton. Deux programmes sont requis puisque deux actions différentes doivent être exécutées. Pour la rotation à gauche, utilisez le programme 13servo_re.py :

#!/usr/bin/python

#13servo_li.py


import time

servoPIN = 18

pwm = 12.5




p.start(pwm)

time.sleep(0.5)


p.stop()

GPIO.cleanup()

Pour la rotation à droite, utilisez le programme 13servo_re.py :

#!/usr/bin/python

#13servo_re.py


import time

servoPIN = 18

pwm = 2.5




p.start(pwm)

time.sleep(0.5)


p.stop()

GPIO.cleanup()








<input name="servo_links" id="servo_links" type="submit"

value="Servo links" style="background‐color: #4180C5">

<input name="servo_rechts" id="servo_rechts" type="submit"

value="Servo rechts" style="background‐color: #4180C5">

</form>

Cela permet de créer deux boutons bleus avec les inscriptions Servo gauche et Servo droite. Sauvegardez le fichier avec [Ctrl]+[O] puis fermez l’éditeur avec [Ctrl]+[X]. Ouvrez à nouveau le fichier index.php dans le navigateur via http://localhost/tag13/index.php.

Le modèle doit maintenant être associé aux deux scripts Python. Modifiez pour ce faire le début du fichier index.php comme suit :

<head>

<?php

if ($_POST["servo_links"])

echo shell_exec(‘sudo /var/www/html/tag13/13servo_li.py’);

elseif ($_POST["servo_rechts"])

echo shell_exec(‘sudo /var/www/html/tag13/13servo_re.py’);

?>




Ouvrez à nouveau LXTerminal et allez au répertoire du jour 13 via la commande cd /var/www/html/tag13. Définissez des droits d’exécution pour les scripts :

chmod a+x 13*.py


sudo visudo


www‐data ALL=(ALL) NOPASSWD: /var/www/html/tag13/13servo_li.py

www‐data ALL=(ALL) NOPASSWD: /var/www/html/tag13/13servo_re.py



Vous y êtes arrivé et pouvez maintenant tester l’appli sur votre smartphone. Pour ce faire, démarrez le navigateur sur votre smartphone et ouvrez la page http://<IP-Adresse Raspberry Pi/tag13/index.php pour pouvoir faire tourner le servo.

Vous pouvez maintenant commander le servo à partir du smartphone.

14e jour

Aujourd’hui dans le calendrier de l’Avent • 1 résistance de 20 mégohms (rouge-noir-bleu)

• 1 barrette à broches (3 broches)

Contact tactile à base de pâte à modeler Les feux de circulation, les gâches électriques, les interrupteurs et les automates sont de nos jours souvent commandés avec des capteurs tactiles qu’il suffit d’effleurer. Les boutons qu’il faut effectivement actionner sont de plus en plus rares. L’expérience du 14e jour permet de commander un jeu de hasard via un contact tactile simple.

Composants : 1 platine enfichable, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED jaune avec résistance en série intégrée, 1 voyant LED vert avec résistance en série intégrée, 1 résistance de 20 mégohms (rouge-noir-bleu), 7 câbles de raccordement GPIO, 5 bar-rettes à broches (3 broches), 1 contact à en pâte à modeler

Les capteurs tactiles fonctionnent comme suit La broche GPIO définie comme entrée est reliée au port +3,3 V via une résistance à très haute impédance (20 mégohms), donnant lieu à un signal certes faible, mais clairement défini comme High. Un individu qui n’est pas suspendu dans l’air est toujours relié à la terre et transmet un niveau Low via la peau conductrice. S’il touche alors un capteur tactile, le signal High faible est surclassé par le niveau Low nettement plus fort de la main, ce qui amène la broche GPIO au niveau Low.

Cependant, de nombreux facteurs tels que les chaussures et le sol influencent le niveau de résistance entre la main et la terre. La liaison à la terre est à son maximum lorsqu’on se promène pieds nus sur un gazon humide. Cela fonctionne généralement bien aussi sur les sols en pierre. Les planchers en bois isolent plus et les planchers en plastique sont même souvent chargés en ondes positives. Si le capteur tactile ne fonctionne pas, touchez simultanément la barrette à broches sur le bornier de mise à la terre de la platine enfichable et le capteur proprement dit. La liaison à la terre est ainsi établie dans tous les cas.

La pâte à modeler conduit le courant presqu’aussi bien que la peau humaine. Elle permet de créer n’importe quelle forme et il est plus facile de toucher un contact en pâte à modeler qu’un simple bout de fil. La surface avec laquelle la main touche le contact est nettement plus grande. Les « mauvais contacts » sont donc moins probables. Enfichez une barrette à broches dans un morceau de pâte à modeler et raccordez-y un câble de raccordement GPIO dont l’extrémité sera reliée à une autre barrette à broches sur la platine enfichable. Si vous avez besoin d’un contact de masse, vous pouvez aussi poser un morceau de pâte à modeler sur les broches dirigées evrs le haut afin d’obtenir un meilleur contact avec la main.

Le capteur tactile active le voyant LED.

Le programme 14knete01 permet de faire clignoter trois voyants LED en alternance à courts intervalles.

Le programme Le programme 14knete01 permet de faire clignoter trois voyants LED en alternance à courts intervalles tant que le contact en pâte à modeler est touché. Un voyant LED s’allume de manière aléatoire une fois que ce contact est relâché.

Pour que les contacts tactiles fonctionnent, il faudra d’abord désactiver la résistance Pull-up interne de la broche GPIO 20, qui est toujours activée par défaut sur le Raspberry Pi. Cela est effectué par la ligne supplémentaire pullnone de la commande GPIO config20in servant à l’initialisation de l’entrée GPIO au début du programme.

Au début de la boucle principale du programme, un bloc attendre jusqu’à…- attend que la valeur de la broche GPIO 20 passe à 0 parce que le contact en pâte à modeler aura été touché.

Une boucle répéter jusqu’à… s’active ensuite jusqu’à ce que la valeur de la broche GPIO 20 passe à 1, parce que le contact en pâte à modeler aura été relâché. Au sein de la boucle, les trois voyants LED sont brièvement allumés et éteints l’un après l’autre.

Lorsque le contact en pâte à modeler est relâché, tous les voyants LED sont toujours éteints, puisque l’interrogation s’effectue seulement au début de chaque nouveau cycle de boucle. Dans ce cas, la boucle est désactivée et un voyant LED aléatoire s’allume.

Pour l’algorithme de choix aléatoire, des broches GPIO avec numéros séquentiels seront utilisés dans le circuit. Ainsi, la commande peut être réalisée avec un nombre aléatoire compris entre 9 et 11.

Le programme génère un nombre aléatoire compris entre 9 et 11. Deux blocs relie imbriqués génèrent alors l’une des chaînes de caractères suivantes : gpio9on, gpio10on, gpio11on.

Le voyant LED activé par la chaîne de caractères reste allumé lorsque la boucle infinie redémarre et attend que le contact en pâte à modeler soit touché. Le cycle aléatoire éteint chaque voyant LED au moins une fois après une séquence complète, après 0,05 seconde. C’est pourquoi le programme ne prévoit pas de commande pour la désactivation du voyant LED activé de manière aléatoire.

Comment sont générés les nombres aléatoires ? On croit généralement que rien ne se produit au hasard dans un programme, mais comment un pro-gramme peut-il donc générer des nombres aléatoires ? Si on divise un grand nombre premier par une valeur quelconque, on obtient à partir de la xe décimale des chiffres qui ne sont quasiment plus prévi-sibles. Ils varient aussi sans aucune régularité au fur et à mesure qu’on augmente le diviseur. Ce résultat semble certes être le fruit du hasard, mais il peut être reproduit à tout moment avec un programme identique ou par l’interrogation multiple du même programme. Si on prend cependant un nombre composé de certains de ces chiffres et qu’on le divise à son tour par un nombre obtenu à partir de la seconde d’horloge actuelle ou du contenu d’un emplacement de stockage de l’ordinateur, on obtient un résultat qui n’est pas reproductible et qui est qualifié de nombre aléatoire.

15e jour

Aujourd’hui dans le calendrier de l’Avent • 1 voyant LED RGB avec résistances en série intégrées

Jeux de couleurs RGB L’expérience du 15e jour permet d’allumer automatiquement un voyant LED RGB successivement dans différentes couleurs.

Composants : 1 platine enfichable, 1 voyant LED RGB avec résistances en série intégrées, 4 câbles de raccordement GPIO, 3 barrettes à broches (3 broches)

Voyant LED RGB sur les broches GPIO 23, 24, 25.

Le programme Le programme 15rgbled01 active et désactive successivement diverses des trois composantes de couleur des voyants LED RGB. Étant donné que deux couleurs sont temporairement activées, le voyant LED RGB s’allume en alternance dans différentes couleurs mélangées.

Le programme 15rgbled01 commande un voyant LED RGB.

La variable z est réglée sur 5 au début. Elle commande le temps entre l’activation des différentes couleurs et donc la vitesse de clignotement des voyants LED RGB. La variable s’affiche sur la plate-forme Scratch avec un régulateur. Ainsi, l’utilisateur peut régler la vitesse de manière interactive pendant le cycle du programme. Ces régulateurs peuvent être affichés/masqués en cliquant avec le bouton droit sur la variable dans la plate-forme Scratch. Étant donné que les régulateurs peuvent uniquement être réglés sur des valeurs entières, la variable z indique le temps en dixièmes de seconde.

Après l’initialisation des sorties GPIO utilisées, seule la broche 24 est activée. Le voyant LED RGB s’allume en vert. Les autres broches sont ensuite activées et désactivées l’une après l’autre. Le délai d’attente entre les commutations est réglé en dixièmes de seconde au moyen de la variable z et peut être modifié par l’utilisateur de manière interactive via le régulateur sur la plate-forme Scratch.

16e jour

Aujourd’hui dans le calendrier de l’Avent • 1 voyant LED RGB avec résistances en série préinstallées

Mélange de couleurs RGB L’expérience du 16e jour montre des dégradés de couleurs différents sur les deux voyants LED RGB qui peuvent être modifiés de manière interac-tive par l’utilisateur sur l’écran. Les couleurs mélangées et les dégradés de couleurs se produisent lorsqu’on règle la luminosité des différentes couleurs d’un voyant LED RGB de manière différente à travers des signaux PWM.

Composants : 1 platine enfichable, 2 voyants LED RGB avec résistances en série intégrée, 7 câbles de raccordement GPIO, 5 barrettes à broches (3 broches)

Deux voyants LED RGB présentent des dégradés de couleurs différents.

Le programme Le programme 16rgbled02 modifie les trois couleurs des deux voyants LED RGB de manière cyclique via des signaux PWM. Différentes durées de cycle sont utilisées ici pour produire des dégradés de couleurs différents et apparemment irréguliers.

Le programme se compose de blocs de programme en grande partie similaires qui commandent chacun une couleur des deux voyants LED RGB. Ils démarrent tous, de manière indépendante l’un de l’autre, au moment où l’utilisateur clique sur le drapeau vert.

Le programme utilise douze variables qui s’affichent toutes sur la plate-forme : r1, g1 et b1 contiennent les valeurs de couleur actuelles du premier voyant LED RGB, r2, g2 et b2 contiennent les valeurs de couleur actuelles du deuxième voyant LED RGB.

Les variables r1z, g1z et b1z contiennent les temporisations entre les différentes commutations des trois couleurs du premier voyant LED RGB en dixièmes de seconde, r2z, g2z et b2z contiennent les valeurs correspondantes pour le deuxième voyant LED RGB. Ces valeurs temporelles peuvent être réglées de manière interactive avec le régulateur pour influencer les effets de couleur.

Chaque bloc de programme modifie le signal PWM d’une composante de couleur en dix incréments de 0 à 500 et vice-versa. Le réglage différent des différentes couleurs permet d’obtenir différents jeux de couleurs.

Le programme 16rgbled02 commande deux voyants LED RGB via PWM.

17e jour

Aujourd’hui dans le calendrier de l’Avent • 1 voyant LED bleu avec résistance en série intégrée

• 1 modèle de découpe pour l’instrument d’affichage au dos

Affichage analogique avec servo L’expérience du 17e jour utilise le servo comme instrument d’affichage analogique pour afficher la position d’une figure sur la plate-forme Scratch. La position est en outre indiquée à travers quatre voyants LED de couleur.

Composants : 1 platine enfichable, 1 servo, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED jaune avec résistance en série intégrée, 1 voyant LED vert avec résistance en série intégrée, 1 voyant LED bleu avec résistance en série intégrée, 8 câbles de rac-cordement GPIO, 4 barrettes à broches (3 broches)

Découpez l’échelle au dos du carton du calendrier de l’Avent et fixez-la sur le servo jusqu’à ce qu’elle s’encliquette sur le servo. Découpez ensuite aussi le pointeur. Il sera fixé sur le servo uniquement après qu’il aura été amené dans la position de départ via le programme.

Servo et quatre voyants LED.

Le pointeur et l’échelle pour le servo.

Le programme Dans le programme 17servo02, l’utilisateur déplace une figure de manière interactive sur la plate-forme Scratch. Sa position est indiquée par le servo et quatre voyants LED.

Le programme 17servo02 commande quatre voyants LED et un servo à partir de la position d’une figure.

Une boucle infinie vérifie constamment les couleurs qui touchent la figure à l’écran et active ensuite les voyants LED dans les couleurs corres-pondantes.

Cette figure est déplacée sur la plate-forme Scratch et sa position est affichée.

La variable s est réglée sur une valeur obtenue à partir de la position y de l’objet divisée par 1,8. La position y de la figure peut être une valeur comprise entre –180 et +180, alors que des valeurs comprises entre –100 et +100 sont requises pour le servo – ce qui explique la nécessité de conversion.

Démarrez le programme en cliquant sur le drapeau vert, puis glissez et déposez la figure sur le bord inférieur, jusqu’à ce que le champ Objekt1 y-Position affiche la valeur 0 et que le voyant LED bleu s’allume. Fixez le pointeur sur le servo de telle sorte qu’il pointe sur le chiffre 0 de l’échelle. Le servo indique maintenant la position actuelle lorsque vous déplacez une figure.

18e jour


Pyramide rotative de Noël Les trois voyants LED sont directement raccordés au Raspberry Pi via les câbles de raccordement GPIO. Ils sont enfichés dans les positions de la pyramide prévues à cet effet. Placez la pyramide sur le bras du servo de sorte qu’elle puisse tourner. Si elle ne tient pas bien, vous pouvez retirer la vis du bras de servo sans l’ôter, puis revissez celle-ci dans le bras du servo à partir du bas de la pyramide. Pour que la pyramide puisse tourner librement, les voyants LED sont reliés à la platine enfichable au moyen de deux câbles de raccordement GPIO connectés en série. Un câble serait trop court et limiterait la mobilité de la pyramide. Tous les six fils des voyants LED sont prolongés par six autres fils au moyen de deux barrettes à broches à trois pôles.

Composants : 1 servo, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED jaune avec résistance en série intégrée, 1 voyant LED vert avec résistance en série intégrée, 15 câbles de raccordement GPIO, 3 barrettes à broches (3 broches)

Servo et trois voyants LED directement raccordés au Raspberry Pi sans platine enfichable.

Le programme Le programme 18pyramide01 est composé de deux blocs de programme indépendants qui commandent la rotation de la pyramide et le cligno-

tement des voyants LED. Les vitesses peuvent être réglées de manière indépendante via le régulateur sur la plate-forme Scratch.

Le programme 18pyramide01 commande la rotation et le clignotement de la pyramide.

La variable dreh contient la temporisation entre les deux mouvements de rotation en secondes. Celle-ci peut être réglée sur une valeur minimale d’une seconde avec le régulateur, puisque le servo a besoin d’un certain temps pour effectuer ses mouvements. Le servo tourne dans une boucle infinie toujours comprise entre les positions 0, 100, 0 et -100.

La variable blink contient la durée d’éclairage d’un voyant LED en dixièmes de seconde. Les trois voyants LED s’allument l’un après l’autre pendant ce temps défini. La commutation vers un autre voyant LED s’effectue sans temporisation. Ainsi un voyant LED est toujours allumé.

19e jour

Aujourd’hui dans le calendrier de l’Avent • 1 câble de raccordement GPIO

Pyramide rotative de Noël avec commande par bouton L’expérience du 19e jour permet de commander la pyramide rotative et clignotante de Noël avec un bouton via un programme Python. Les voyants LED de la pyramide sont à nouveau raccordés au moyen de deux câbles de raccordement GPIO connectés respectivement en série.

Composants : 1 servo, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED jaune avec résistance en série intégrée, 1 voyant LED vert avec résistance en série intégrée, 1 bouton, 16 câbles de raccordement GPIO, 5 barrettes à broches (3 broches)

Voyants LED sur la pyramide rotative de Noël avec un bouton sur la platine enfichable.

Veillez à un assemblage correct. Le bouton et le servo utilisent la même rangée de contacts pour le signal +5 V.

Le programme Le programme 19pyramide05.py fait tourner la pyramide sur le servo en alternance dans les deux directions. Les voyants LED s’allument succes-sivement comme un chenillard. Une pression sur le bouton change la direction du chenillard.

#!/usr/bin/python


import time

LED = [[17, 22, 10],[10, 22, 17]]

x = 0

t1 = 8

servoPIN = 21


GPIO.setup(t1, GPIO.IN, GPIO.PUD_DOWN)


pwm = 2.5

a = 2.5


p.start(pwm)

for i in LED[0]:

GPIO.setup(i, GPIO.OUT)

try:

while True:


pwm += a

if pwm==12.5 or pwm==2.5:

a = ‐a

time.sleep(0.2)


for i in LED[x]:

GPIO.output(i, True)

time.sleep(0.2)

GPIO.output(i, False)

if GPIO.input(t1) == True:

x = 1‐x


p.stop()

GPIO.cleanup()

Le programme fonctionne comme suit LED = [[17, 22, 10],[10, 22, 17]]

x = 0

Les broches des trois voyants LED sont définies comme une liste imbriquée. Le premier élément de la liste est une autre liste des trois numéros de broches, le deuxième élément de la liste est une liste des numéros de broches inversés. La variable x sera utilisée plus tard pour choisir l’une de ces deux listes. La numérotation des éléments de la liste commence toujours par 0. Les deux éléments de cette liste ont donc les numéros LED[0] et LED[1].

for i in LED[0]:


Les trois broches GPIO sont initialisées via la liste LED[0]. Étant donné que les deux listes contiennent des numéros de broches identiques, il est possible d’utiliser aussi l’autre liste.


pwm += a

Dans la boucle infinie, le servo est réglé sur la valeur pwm actuelle à chaque cycle de boucle. À chaque nouveau cycle, cette valeur est augmentée de 2.5 par rapport à la variable a réglée plus tôt.

if pwm==12.5 or pwm==2.5:

a = ‐a

Si le servo a atteint l’une des positions de fin de course, le signe algébrique de la variable a est modifié afin que le servo puisse tourner dans la direction opposée lors du prochain cycle de boucle.

time.sleep(0.2)


Après une temporisation de 0,2 seconde, le servo reçoit un signal PWM avec une valeur 0 afin d’empêcher le tremblement habituel.

for i in LED[x]:


time.sleep(0.2)


if GPIO.input(t1) == True:

x = 1‐x

Une nouvelle boucle démarre qui commande les trois voyants LED et les allume successivement pendant une durée respective de 0,2 seconde. Le bouton est interrogé à chaque nouveau cycle de cette boucle. Si le bouton a été appuyé, la variable x passe de 0 à 1 ou vice-versa. Ainsi, l’autre liste des voyants LED est respectivement utilisée pour le chenillard, ce qui modifie aussi la direction.

Après un cycle du chenillard, la boucle infinie redémarre et tourne le servo d’un incrément, puis lance un autre cycle de chenillard.

Le raccourci clavier [Ctrl]+[C] permet de couper le signal PWM et de réinitialiser les broches GPIO.

20e jour

Aujourd’hui dans le calendrier de l’Avent • 1 câble de raccordement GPIO

Pyramide rotative de Noël avec commande par appli Aujourd’hui la pyramide de Noël sera commandée via une appli mobile.

Composants : 1 servo, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED jaune avec résistance en série intégrée, 1 voyant LED vert avec résistance en série intégrée, 15 câbles de raccor-dement GPIO, 3 barrettes à broches (3 broches)

Servo et trois voyants LED directement raccordés au Raspberry Pi sans platine enfichable.

Le programme La rotation de la pyramide et la commutation des voyants LED sont commandées ci-dessous via une appli. Il faudra respectivement un bouton pour la rotation à gauche et à droite. Il faudra respectivement un bouton aussi pour le chenillard et le clignotement des voyants LED. Un script Python est requis pour chacune des quatre fonctions. Utilisez le programme 20servo_li.py pour la rotation de la pyramide vers la gauche :

#!/usr/bin/python

#20servo_li.py


import time

servoPIN = 21

pwm = 12.5




p.start(pwm)

time.sleep(0.5)


p.stop()

GPIO.cleanup()

Utilisez le programme 20servo_re.py pour la rotation de la pyramide vers la droite :

#!/usr/bin/python

#20servo_re.py


import time

servoPIN = 21

pwm = 2.5




p.start(pwm)

time.sleep(0.5)


p.stop()

GPIO.cleanup()

Pour la commutation du chenillard, utilisez le programme 20pyramide_lauflicht.py :

#!/usr/bin/python

#20pyramide_lauflicht.py


import time

LED = [17, 22, 10]


for i in LED:


for j in range(3):

for i in LED:


time.sleep(0.2)


GPIO.cleanup()

Utilisez le programme 20pyramide_blink.py pour activer la fonction de clignotement :

#!/usr/bin/python

#20pyramide_blink.py


import time

LED = [17, 22, 10]


for i in LED:


for j in range(3):

for i in LED:


time.sleep(0.2)

for i in LED:


time.sleep(0.2)

GPIO.cleanup()



Étape 1 Appli : copier le modèle dans le répertoire du serveur Web


Étape 2 Appli : adapter le modèle



<input name="servo_links" id="servo_links" type="submit"

value="Pyramide links" style="background‐color: #4180C5">

<input name="servo_rechts" id="servo_rechts" type="submit"

value="Pyramide rechts" style="background‐color: #4180C5">

<input name="lauflicht" id="lauflicht" type="submit"

value="Lauflicht" style="background‐color: #4180C5">

<input name="blinken" id="blinken" type="submit" value="Blinken"


</form>

Cela permet de créer quatre boutons bleus avec les inscriptions Pyramide gauche, Pyramide droite, Chenillard et Clignotement. Sauvegardez le fichier avec [Ctrl]+[O] puis fermez l’éditeur avec [Ctrl]+[X]. Ouvrez le fichier index.php dans le navigateur via http://localhost/tag20/index.php.

Le modèle doit maintenant être associé aux deux scripts Python. Modifiez pour ce faire le début du fichier index.php comme suit :

<head>

<?php

if ($_POST["servo_links"])

echo shell_exec(‘sudo /var/www/html/tag20/20servo_li.py’);

elseif ($_POST["servo_rechts"])

echo shell_exec(‘sudo /var/www/html/tag20/20servo_re.py’);

elseif ($_POST["lauflicht"])

echo shell_exec(‘sudo /var/www/html/tag20/20pyramide_lauflicht.py’);

elseif ($_POST["blinken"])

echo shell_exec(‘sudo /var/www/html/tag20/20pyramide_blink.py’)

?>




Ouvrez pour ce faire à nouveau LXTerminal et accédez au répertoire du jour 20 à travers la commande cd /var/www/html/tag20. Définissez des droits d’exécution pour les scripts :

chmod a+x 20*.py


sudo visudo

Vous pouvez maintenant commander la pyramide et les voyants LED à partir du smartphone.


www‐data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20servo_li.py

www‐data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20servo_re.py

www‐data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20pyramide_lauflicht.py

www‐data ALL=(ALL) NOPASSWD: /var/www/html/tag20/20pyramide_blink.py



Vous y êtes arrivé et pouvez maintenant tester l’appli sur votre smartphone. Pour ce faire, démarrez le navigateur sur votre smartphone, accédez à la page via l’adresse http://<IP-Adresse Raspberry Pi/tag20/index.php pour pouvoir commander la pyramide de Noël.

21e jour

Aujourd’hui dans le calendrier de l’Avent • 1 résistance de 20 mégohms

Pyramide rotative de Noël avec commande en pâte à modeler Dans l’expérience du 21e jour, deux contacts en pâte à modeler commandent, via un programme Python, le clignotement des voyants LED de la pyramide de Noël qui ne tourne pas cette fois ci. Puisque la pyramide ne tourne pas aujourd’hui, des câbles GPIO simples suffisent pour les voyants LED. Il n’est pas nécessaire de les prolonger avec un deuxième câble. Ainsi, les barrettes à broches existantes peuvent être utilisées pour les deux contacts en pâte à modeler.

Composants : 1 platine enfichable, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED jaune avec résistance en série intégrée, 1 voyant LED vert avec résistance en série intégrée, 2 résistances de 20 mégohms (rouge-noir-bleu), 11 câbles de raccordement GPIO, 5 barrettes à broches (3 broches), 2 contacts en pâte à modeler

Deux contacts en pâte à modeler commandent les trois voyants LED de la pyramide de Noël

Le programme Le programme 21knete03.py montre comment les contacts en pâte à modeler sont asservis avec Python. Si l’utilisateur touche l’un des contacts en pâte à modeler, les voyants LED se mettent à clignoter comme un chenillard. S’il touche le deuxième contact, tous les trois voyants se mettent à clignoter.

#!/usr/bin/python


import time

LED = [17, 22, 10]

k1 = 13

k2 = 20


GPIO.setup(k1, GPIO.IN)

GPIO.setup(k2, GPIO.IN)

for i in LED:


try:

while True:

while GPIO.input(k1) == False:

for i in LED:


time.sleep(0.1)



for i in LED:


time.sleep(0.1)

for i in LED:


time.sleep(0.1)


GPIO.cleanup()

Le programme fonctionne comme suit LED = [17, 22, 10]

k1 = 13

k2 = 20

Les broches GPIO des voyants LED sont à nouveau enregistrées sous forme de liste, les broches des contacts en pâte à modeler dans les variables k1 et k2.


for i in LED:


time.sleep(0.1)


Deux boucles while fonctionnent au sein de la boucle infinie. Chaque boucle fonctionne jusqu’à ce que l’un des contacts en pâte à modeler soit actionné. Dans la première boucle while s’active une boucle for qui allume les trois voyants LED successivement pour une durée respective de 0,1 seconde.


for i in LED:


time.sleep(0.1)

for i in LED:


time.sleep(0.1)

Si l’utilisateur touche l’autre contact en pâte à modeler, tous les trois voyants LED s’allument immédiatement l’un après l’autre, puis s’éteignent tous à nouveau après une temporisation de 0,1 seconde. Cela apparaît comme un clignotement simultané de tous les trois voyants LED.

22e jour

Aujourd’hui dans le calendrier de l’Avent • 1 barrette à broches (3 broches)

Commande de la pyramide rotative de Noël avec la pâte à modeler L’expérience du 22e se base sur l’expérience du 18e jour, à la seule différence que les voyants LED clignotent uniquement et la pyramide se déplace uniquement lorsque l’utilisateur touche le contact en pâte à modeler. Les voyants LED de la pyramide sont à nouveau raccordés au moyen de deux câbles de raccordement GPIO connectés respectivement en série.

Composants : 1 servo, 1 platine enfichable, 1 voyant LED rouge avec résistance en série intégrée, 1 voyant LED jaune avec résistance en série intégrée, 1 voyant LED vert avec résistance en série intégrée, 1 résistance de 20 mégohms (rouge-noir-bleu), 17 câbles de raccorde-ment GPIO, 6 barrettes à broches (3 broches), 1 contact en pâte à modeler

Commande de la pyramide rotative de Noël avec un contact en pâte à modeler.

Le programme Le programme 22pyramide02 est similaire au programme du 18e jour avec deux blocs indépendants qui commandent la rotation de la pyramide et les effets de clignotement des voyants LED. Des interrogations de capteur sont intégrées en lieu et place des boucles infinies. Pour commencer, un bloc attendre jusqu’à…- attend que la valeur de la broche GPIO 8 passe à 0 parce que le contact en pâte à modeler aura été touché. Une boucle répéter jusqu’à… s’active ensuite jusqu’à ce que la valeur de la broche GPIO 8 passe à 1, parce que le contact en pâte à modeler aura été relâché.

Le programme 22pyramide02 permet de commander la pyramide avec un contact en pâte à modeler.

En raison de la rotation relativement lente du servo, les voyants LED cessent presque immédiatement de clignoter lorsque le contact en pâte à modeler est relâché, alors que le servo tourne encore pendant un moment.

Un bloc est également intégré ici, qui à l’actionnement de la [touche Espace], envoie la commande servo18stop et désactive donc la broche GPIO. Le servo s’immobilise et ne tremble plus non plus.

23e jour

Aujourd’hui dans le calendrier de l’Avent • 1 voyant LED RGB avec résistances en série intégrées

Jeux de couleur RGB avec Python L’expérience du 23e jour permet que trois voyants LED RGB s’allument automatiquement dans plusieurs couleurs au moyen de signaux PWM.

Composants : 1 platine enfichable, 3 voyants LED RGB avec résis-tances en série intégrées, 10 câbles de raccordement GPIO, 5 barrettes à broches (3 broches)

Trois voyants LED RGB avec résistances en série.

Le programme Le programme 23rgbled03.py permet de produire des effets de variation de couleurs sur les voyants LED RGB à travers le système chromatique HSV.

Systèmes chromatiques HSV et RGB Le système chromatique RGB utilisé jusqu’ici dans tous les pro-grammes décrit les couleurs comme trois composantes : rouge, vert et bleu, qui peuvent être mélangées entre elles. Il est relativement difficile pour un individu de se représenter une couleur mélangée. Le système chromatique HSV décrit quant à lui les couleurs à travers les valeurs H = Hue (valeur de couleur), S = Saturation (saturation) et V = Value (luminosité). Une simple modification de la valeur H permet de définir toutes les couleurs du spectre de couleurs à pleine intensité lorsque les deux autres valeurs sont réglées sur Maximum.

#!/usr/bin/python


import time

import colorsys


LED1 = [21, 20, 16]

LED2 = [12, 7, 8]

LED3 = [25, 24, 23]

p1 = [0, 0, 0]

p2 = [0, 0, 0]

p3 = [0, 0, 0]

for i in range(3):

GPIO.setup(LED1[i], GPIO.OUT)



for i in range(3):

p1[i] = GPIO.PWM(LED1[i], 50)

p1[i].start(0)


p2[i].start(0)


p3[i].start(0)

try:

while True:

for i in range(100):

rgb1 = colorsys.hsv_to_rgb(i/100, 1, 1)

x2 = i+20

if x2 > 100:

x2 ‐= 100

rgb2 = colorsys.hsv_to_rgb(x2/100, 1, 1)

x3 = i+40

if x3 > 100:

x3 ‐= 100


for j in range(3):

p1[j].ChangeDutyCycle(rgb1[j])



time.sleep(0.1)


for i in range(3):

p1[i].stop()

p2[i].stop()

p3[i].stop()

GPIO.cleanup()

Le programme fonctionne comme suit import colorsys

En plus des bibliothèques déjà connues, la bibliothèque colorsys est importée pour la conversion entre les systèmes chromatiques HSV et RGB.

LED1 = [21, 20, 16]

LED2 = [12, 7, 8]

LED3 = [25, 24, 23]

Les numéros de broches de tous les trois voyants LED RGB sont sauvegardés dans une liste séparée.

p1 = [0, 0, 0]

p2 = [0, 0, 0]

p3 = [0, 0, 0]

Trois listes sont ensuite créées pour le total de neuf signaux PWM des trois voyants LED RGB.

for i in range(3):




Une boucle définit toutes les brochés GPIO utilisées comme étant des sorties.

for i in range(3):


p1[i].start(0)


p2[i].start(0)


p3[i].start(0)

Une autre boucle configure les neuf signaux PWM au total et les démarre tous avec la valeur 0. Tous les voyants LED RGB sont éteints.

Le système chromatique HSV utilise typiquement les valeurs comprises entre 0 et 100 pour l’échelle de couleurs, contrairement au système RGB qui utilise des valeurs comprises entre 0 et 255. Dans Python, les deux systèmes chromatiques utilisent des valeurs comprises entre 0,0 et 1,0.

for i in range(100):

rgb1 = colorsys.hsv_to_rgb(i/100, 1, 1)

Une boucle effectue un cycle de 0 à 99 pour la conversion. Dans cette boucle, les valeurs RGB du premier voyant LED RGB seront recalculées à chaque nouveau cycle de boucle par conversion de la valeur HSV en valeur RGB par le compteur de cycles via la fonction colorsys.hsv_to_rgb(). Cette fonction fournit automatiquement une liste de trois valeurs qui est sauvegardée dans la variable rgb1.

x2 = i+20

if x2 > 100:

x2 ‐= 100


Le deuxième voyant LED RGB obtient une valeur HSV décalée de 20 unités par rapport au premier voyant LED. La conversion s’effectue ici selon la même formule et la valeur est sauvegardée dans la variable rgb2. Si le résultat de l’addition effectuée par le compteur de cycles dépasse le seuil de 100, une valeur de 100 est automatiquement soustraite, de telle sorte que le calcul recommence à 0.

x3 = i+40

if x3 > 100:

x3 ‐= 100


C’est de la même manière que la valeur de couleur du troisième voyant LED RGB est ajusté à la valeur HSV du premier voyant LED par addition du chiffre 40. Le deuxième et le troisième voyant LED RGB sont ainsi légèrement décalés dans le spectre des couleurs par rapport au premier voyant.

for j in range(3):




time.sleep(0.1)

Une boucle règle ensuite les signaux PWM des trois voyants LED RGB sur les valeurs RGB calculées et patiente 0,1 seconde avant de calculer les valeurs des couleurs suivantes.


for i in range(3):

p1[i].stop()

p2[i].stop()

p3[i].stop()

GPIO.cleanup()

Si l’utilisateur coupe le programme avec le raccourci clavier [Ctrl]+[C], tous les neuf signaux PWM seront coupés et les broches GPIO réinitialisées.

24e jour

Aujourd’hui dans le calendrier de l’Avent • 1 code de téléchargement

• 1 modèle de découpe pour l’instrument d’affichage au dos

Horloge pour le compte à rebours jusqu’au prochain calendrier de l’Avent Une horloge affiche le compte à rebours jusqu’au prochain calendrier de l’Avent et joue une mélodie correspondant à chaque saison. Téléchargez à cet effet les mélodies sur www.buch.cd en vous servant du code de téléchargement qui se cache derrière la case de ce jour. Extraire l’archive Zip dans le répertoire Home /home/pi.

Composants : 1 servo, 1 barrette à broches (3 broches), 3 câbles de raccordement GPIO, code de téléchargement pour la musique

Vous trouverez au dos du calendrier de l’Avent une échelle de douze mois que vous pouvez fixer sur le servo.

Servo pour la commande de l’horloge.

L’échelle pour les douze mois.

Le programme Le programme 24uhr01.py indique avec le servo combien de mois il faut encore attendre jusqu'au prochain calendrier de l’Avent et joue une mélodie.

#!/usr/bin/python


import time

import subprocess

servoPIN = 21




p.start(0)

zeit = time.localtime()

m = zeit.tm_mon

pwm = (m/12*10)+2.5


time.sleep(0.5)


if m<4:

subprocess.Popen(["omxplayer", "lied1.mp3"])

elif m<7:


elif m<10:


elif m<12:


else:


p.stop()

GPIO.cleanup()

Le programme fonctionne comme suit import subprocess

La bibliothèque subprocess est importée en plus des bibliothèques déjà connues. Elle permet de démarrer les programmes de lignes de commande Linux à partir d’un programme Python.

Comme on le sait déjà, la broche GPIO est définie comme sortie par le servo et un signal PWM est transmis.

zeit = time.localtime()

L’heure actuelle est mémorisée dans l’objet zeit (heure). À cet effet on utilise la fonction time.localtime() de la bibliothèque time. Le résultat est une structure de données composée de plusieurs valeurs individuelles.

m = zeit.tm_mon

Le mois est lu dans l’objet temps et enregistré dans la variable m. Le mois est un chiffre compris entre 1 (janvier) et 12 (décembre).

pwm = (m/12*10)+2.5


Le chiffre correspondant au mois permet de calculer la valeur PWM correspondante dans la plage de rotation du servo et de régler le servo sur cette valeur.

time.sleep(0.5)


Après une temporisation d’une demi-seconde, le servo reçoit la valeur PWM 0 afin d’empêcher le tremblement. Il s’immobilise à la position définie préalablement.

if m<4:


Si le mois actuel est inférieur à 4 (janvier à mars), la mélodie lied1.mp3 est jouée. Pour ce faire, on utilise la fonction subprocess.Popen() qui lance dans ce cas le lecteur omxplayer basé sur la ligne de commande.

elif m<7:


elif m<10:


elif m<12:


Les commandes derrière elif sont exécutées si aucune interrogation n’a au préalable founi la valeur True. Ainsi, il est possible de réaliser un nombre illimité d’interrogations les unes après les autres. Des mélodies différentes sont jouées en fonction du mois actuel (avril à juin, juillet à septembre, octobre à novembre).

else:


Si aucune des interrogations n’a fourni la valeur True, le mois actuel est décembre. La mélodie lied5.mp3 est jouée dans ce cas.

Pour finir, le signal PWM est arrêté et les broches GPIO réinitialisées.

Joyeux Noël !

Calendrier de l’Avent Raspberry Pi 2017 · Calendrier de l’Avent Raspberry Pi 2017 Commander un...

Documents

Transcript of Calendrier de l’Avent Raspberry Pi 2017 · Calendrier de l’Avent Raspberry Pi 2017 Commander un...