Sommaire 1 De l'installation du système d'exploitation au premier programme Python 1.1 De quoi avez-vous besoin ? 1.1.1 Chargeur pour téléphone portable à prise micro-USB 1.1.2 Carte mémoire 1.1.3 Clavier 1.1.4 Souris 1.1.5 Câble réseau 1.1.6 Câble HDMI 1.1.7 Câble audio 1.1.8 Câble vidéo composite jaune (FBAS) 1.2 Installer le système d'exploitation Raspbian 1.2.1 Préparer la carte mémoire sur l'ordinateur 1.2.2 Installateur de logiciel NOOBS 1.2.3 Les voyants LED sur le Raspberry Pi 1.2.
6 Variation de l'intensité lumineuse des LED par modulation de la largeur des impulsions 6.1.1 Voilà comment cela fonctionne 6.1.2 Faire varier l'intensité lumineuse de deux LED indépendamment l'une de l'autre 6.1.3 Voilà comment cela fonctionne 53 56 57 59 7 Indicateur à LED montrant l'espace disponible des cartes mémoires 7.1.1 Voilà comment cela fonctionne 60 63 8 Dé graphique 8.1.1 Voilà comment cela fonctionne 65 67 9 Horloge analogique sur l'écran 9.1.
1 De l'installation du système d'exploitation au premier programme Python Quasiment aucun appareil électronique dans sa catégorie de prix n'a fait autant parler de lui ces derniers mois que le Raspberry Pi. Le Raspberry Pi est, même si cela ne se voit pas à première vue, un ordinateur complet de la taille d'une carte de crédit - disponible à un prix très raisonnable.
1.1.1 Chargeur pour téléphone portable à prise micro-USB Un chargeur moderne pour téléphone portable suffit pour faire fonctionner le Raspberry Pi. Les anciens chargeurs construits avec les premières technologies de recharge via USB ne sont pas assez puissants. Si vous utilisez un périphérique USB à forte consommation électrique comme un disque dur sans alimentation externe, vous devrez utiliser un bloc d'alimentation plus puissant.
1.1.7 Câble audio Un casque audio ou des enceintes pour ordinateur peuvent être utilisées sur le Raspberry Pi via un câble audio avec prises jack de 3,5 mm. Le signal audio est également disponible via le câble HDMI. Aucun câble audio n'est nécessaire pour les téléviseurs ou moniteurs HDMI. Si un moniteur d'ordinateur est connecté via un câble HMDI avec adaptateur DVI, le signal audio est en général perdu à ce point de sorte que vous avez besoin d'utiliser à nouveau la sortie audio analogique. 1.1.
La carte mémoire sera effacée Nous vous recommandons d'utiliser une carte mémoire vide pour l'installation du système d'exploitation. S'il y a des données sur la carte mémoire, elles seront effacées irréversiblement au cours du processus de reformatage, pendant l'installation du système d'exploitation. 1.2.2 Installateur de logiciel NOOBS Le « New Out Of Box Software » (NOOBS) est un installateur particulièrement simple pour le système d'exploitation du Raspberry Pi.
Fig. 1.2: Les voyants LED de statut sur le Raspberry Pi 1.2.4 Le premier démarrage sur le Raspberry Pi À l'issue de l'installation, le Raspberry Pi redémarre et lance automatiquement l'outil de configuration raspi-config. Vous devez ici choisir uniquement dans Enable Boot to Desktop l'option Desktop Log in as user ‘pi’. La langue [française] et le clavier [français] sont automatiquement sélectionnés ainsi que d'autres réglages importants. Après un redémarrage, le bureau graphique LXDE devient disponible.
Fig. 1.3: Le Desktop LXDE (bureau LXDE) sur Raspberry Pi ressemble beaucoup à celui de Windows XP. La version Raspbian de Linux pour le Raspberry Pi utilise l'interface LXDE (Lightweight X11 Desktop Environment), qui, d'une part, a besoin de très peu de ressource système et qui, d'autre part, ressemble fortement au menu de démarrage et au gestionnaire de fichiers de votre interface habituelle de Windows. Application Linux Même la connexion utilisateur caractéristique de Linux s'effectue en arrière-plan.
1.3.1 Enregistrer vos fichiers sur le Raspberry Pi La gestion des fichiers est un peu différente sur Linux par rapport à Windows mais cela n'est pas plus difficile. Raspbian offre un gestionnaire de fichiers qui ressemble beaucoup à l'explorateur de Windows. Cependant, il y a une différence important par rapport à Windows : Linux ne sépare pas strictement en fonction des lecteurs. Tous les fichiers se trouvent dans un seul système de fichier unique.
Fig. 1.5: ... ou à ceci. Combien d'espace reste-t-il disponible sur la carte mémoire ? Contrairement aux disques durs des ordinateurs qui sont en permanence pleins - grâce à sa carte mémoire, le Raspberry Pi peut fonctionner beaucoup plus vite. Il est d'autant plus important d'avoir toujours de l'espace libre et disponible sur la carte mémoire en un clin d'œil. La barre d'état du gestionnaire de programme en bas de la fenêtre indique à droite l'espace libre et disponible de la carte mémoire. 1.
Python 2.7.3 est lancé avec le symbole IDLE sur le bureau. En un clin d'œil, une fenêtre de saisie avec une invite de commande s'affiche ici à l'écran. Fig. 1.6: La fenêtre de saisie du Python-Shell. Dans cette fenêtre, vous ouvrez les programmes Python existants, vous en écrivez de nouveaux ou vous pouvez directement modifier les commandes Python de manière interactive, sans avoir à écrire un vrai programme. Entrez p. ex.
Cartes flash Python Python est le langage de programmation idéal pour commencer à apprendre à programmer. Seule la syntaxe et les règles de mises en page sont un peu étranges. Pour vous aider à programmer, les éléments importants de la syntaxe du langage Python sont décrits brièvement sous la forme « d'antisèche ». Elle repose sur les cartes flash de David Whale. Vous trouverez tout ce dont vous avez besoin à l'adresse bit.ly/pythonflashcards.
Fig. 1.8: Le réglage correct pour afficher les [accents] dans Python. 4. Lancez maintenant le jeu avec la touche [F5] ou le point de menu Run/Run Module. 5. Par souci de simplicité, le jeu renonce à l'interface graphique, au texte explicatif ou aux questions de plausibilité de la réponse. L'ordinateur génère en arrière-plan un chiffre aléatoire compris entre 0 et 1000. Il suffit d'entrer votre réponse et vous saurez si le chiffre cherché est plus grand ou plus petit.
Fig. 1.9: Deviner le chiffre dans Python. 1.4.2 Voilà comment cela fonctionne Comme le jeu fonctionne, vous pouvez l'essayer facilement. Vous vous posez naturellement quelques questions maintenant : Qu'est-ce qu'il se passe en arrière-plan ? Qu'est-ce que ces lignes de programme signifient ? import random Pour générer le chiffre aléatoire, un module de Python externe nommé random est importé. Il contient différentes fonctions nécessaire pour générer le chiffre aléatoire. chiffre = random.
Comment les chiffres aléatoires sont-ils générés ? On pense communément que rien ne peut se produire au hasard dans un programme. Alors, comment est-ce qu'un programme peut générer un chiffre aléatoire ? Si l'on divise un grand nombre premier par n'importe quel chiffre, on obtient des chiffres à x décimales qui peuvent être devinés difficilement. Ils changent sans aucune régularité lorsque l'on augmente régulièrement le diviseur.
i += 1 Dans chaque cas – donc plus indenté – le compteur i, qui compte le nombre de tentatives, est augmenté de 1. Cette ligne avec l'opérateur += veut dire la même chose que i = i + 1. print "Vous avez trouvé le chiffre à la ",i,"e réponse" Cette ligne est plus indentée ce qui signifie que la boucle while est également quittée.
Attention ! En aucun cas, vous ne devez connecter les broches GPI entre elles et attendre la suite des événements. Suivez impérativement les instructions suivantes : Certaines broches GPIO sont directement connectées aux bornes du processeur et un court-circuit peut endommager irréversiblement le Raspberry Pi. Si vous connectez deux broches ensemble via un interrupteur ou une LED, il faut toujours intercaler une pré-résistance.
• 4x Résistances de 220 Ω (Rouge-Rouge-Marron) • 12x Câbles de connexion (Circuit imprimé – Raspberry Pi) • fil de connexion d'env. 1 m 2.1.1 Cartes de circuits imprimés Deux cartes de circuit imprimé sont incluses dans le kit pour construire rapidement des circuits électroniques. Les composants électroniques peuvent être directement branchés sur une trame à perforation avec des distances standard, sans avoir à les souder.
de fil avec un petit coupe-fil comme décrit dans chaque expérience. Pour pouvoir mieux insérer le fil dans la carte de circuit imprimé, il est recommandé de couper le fil de manière légèrement oblique de sorte à créer une sorte de pointe. Dénudez la gaine isolante aux deux extrémités sur une longueur d'environ un demicentimètre. 2.1.
Le kit d'apprentissage contient des résistances de trois valeurs différentes : Valeur 1. Anneau (1er chiffre ; dizaine) 2. Anneau (2e chiffre) 3. Anneau (Multiplicat eur) 4. Anneau (Toléranc e) Usage 220 Ω Rouge Rouge Marron Or Pré-résistance pour LED 1 kΩ Marron Noir. Rouge Or Résistance de protection pour les entrées GPIO 10 kΩ Marron Noir. Orange. Or Résistance Pull-Down pour les entrées GPIO Tableau 2.
Fig. 2.3: Construction de la carte pour connecter une LED.
Fig. 2.4: Le premier voyant LED sur le Raspberry Pi Dans cette première expérience, le Raspberry Pi est uniquement utilisé comme alimentation électrique de la LED. La LED s'allume toujours sans avoir besoin de logiciel. Dans l'expérience suivante, vous installerez un bouton dans la ligne d'alimentation de la LED. La LED s'allume maintenant uniquement si vous appuyez sur le bouton. Aucun logiciel n'est également requis ici.
Fig. 2.
Fig. 2.6: LED avec bouton sur le Raspberry Pi. 2.3 GPIO avec Python Pour pouvoir utiliser les ports GPIO avec un programme Python, vous devez installer la bibliothèque PythonGPIO. Si vous n'êtes pas certain(e) si tous les modules nécessaires sont installés, installez une fois les versions actuelles avec les commandes suivantes : sudo apt-get update sudo apt-get install python-dev sudo apt-get install python-rpi.
2.4 Allumer et éteindre une LED Branchez, comme indiqué sur la figure, une LED via une pré-résistance de 220 Ω (Rouge-Rouge-Marron) sur le port GPIO 25 (broche 22) et non plus directement sur la prise de + 3,3 V. Connectez le pôle moins de la LED au fil de terre du Raspberry Pi (broche 6) via le rail de masse de la carte de circuit imprimé. Composants nécessaires : 1x Carte de circuit imprimé 1x LED rouge 1x résistance de 220 Ω 2x Câbles de connexion Le programme suivant led.
Fig. 2.7: Une LED sur le port GPIO 25 2.4.1 Voilà comment cela fonctionne L'exemple montre les fonctions de base les plus importantes de la bibliothèque RPi.GPIO. import RPi.GPIO as GPIO La bibliothèque RPi.GPIO doit être importée dans chaque programme Python où elle doit être utilisée. Cette manière d'écrire permet de consulter toutes les fonctions de la bibliothèque via le préfixe GPIO.
Numérotation des ports GPIO La bibliothèque RPi.GPIO supporte différentes méthodes pour affecter les ports. Dans le mode BCM, les numéros de port GPIO connus sont utilisés, qui peuvent également être utilisés à partir des lignes de commande ou dans les scripts de Shell. Dans le mode alternatif BOARD, l'affectation des numéros de broches de 1 à 26 correspondent à la carte Raspberry Pi. GPIO.setup(25, GPIO.OUT) La fonction GPIO.setup initialise un port GPIO comme une sortie ou une entrée.
• Créez une copie du symbole de bureau IDLE préinstallé. Pour ce faire, procédez comme suit : • Faites un clic droit de souris sur le symbole IDLE du bureau et sélectionnez Copier dans le menu contextuel. Fig. 2.8: Copier le symbole IDLE du bureau. Ensuite faites un clic droit de souris sur le bureau et sélectionnez Coller dans le menu contextuel. Comme il existe déjà un raccourci bureau avec le même nom, un message indiquant que vous essayez de faire une copie s'affiche à l'écran.
Fig. 2.9: Message affiché lors de la duplication d'un raccourci bureau Faites maintenant un clic droit de souris sur la copie du symbole de bureau et sélectionnez Leafpad dans le menu contextuel. Les raccourcis bureau sont des fichiers texte dans Linux, qui peuvent être modifiés à l'aide d'un éditeur de texte. Fig. 2.10: Le raccourci bureau dans l'éditeur de texte Leafpad Effectuez ici les deux modifications montrées dans la figure : • Modifiez le champ Name en IDLE GPIO.
3 Feu de signalisation Allumer et éteindre une seule LED peut être amusant au début mais cela ne nécessite pas vraiment un ordinateur pour le faire. Un feu de signalisation avec son cycle de lumière typique passant du vert au jaune, du jaune au rouge puis une combinaison de rouge-jaune pour revenir au vert, est facile à réaliser avec trois LED et permet de montrer des techniques supplémentaires de programmation dans Python. Montez le circuit montré dans la figure sur la carte de circuit imprimé.
Fig. 3.2: Un feu de signalisation simple Le programme ampel01.py contrôle le feu de circulation : import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) rouge = 0; jaune = 1; vert = 2 Feu_de_circulation=[4,18,23] GPIO.setup(Feu_de_circulation[rouge], GPIO.OUT, initial=False) GPIO.setup(Feu_de_circulation[jaune], GPIO.OUT, initial=False) GPIO.setup(Feu_de_circulation[vert], GPIO.OUT, initial=True) print ("Ctrl+C arrête le programme") try: while True: time.sleep(2) GPIO.
GPIO.output(Feu_de_circulation[jaune],True) time.sleep(0.6) GPIO.output(Feu_de_circulation[jaune],False); GPIO.output(Feu_de_circulation[rouge],True) time.sleep(2) GPIO.output(Feu_de_circulation[jaune],True) time.sleep(0.6) GPIO.output(Feu_de_circulation[rouge],False); GPIO.output(Feu_de_circulation[jaune],False) GPIO.output(Feu_de_circulation[vert],True) except KeyboardInterrupt: GPIO.cleanup() 3.1.1 Voilà comment cela fonctionne Les premières lignes sont déjà connues.
de programme associé sous try: est ensuite exécuté normalement. Si une exception système se provient pendant ce temps – cela peut être une erreur ou également la combinaison de touche [Ctrl]+[C], le programme est interrompu et l'instruction except à la fin du programme est exécutée. except KeyboardInterrupt: GPIO.cleanup() Cette combinaison de touches déclenche un KeyboardInterrupt et la boucle est quittée automatiquement. La dernière ligne ferme les ports GPIO utilisés et éteint toutes les LED.
4 Feu pour piétons Dans l'expérience suivante, nous ajoutons un feu pour piéton au feu de signalisation, qui montre une lumière clignotante pour les piétons pendant la phase rouge du feu de circulation, comme cela est utilisé dans certains pays. Vous pouvez naturellement aussi installer dans le programme les feux pour piétons avec des lumières rouge et verte que l'on trouve en Europe centrale mais ce kit d'apprentissage ne contient qu'une LED en plus des LED déjà utilisées dans le feu de circulation.
Fig. 4.2: Feu de circulation avec feu clignotant pour piéton Le programme ampel02.py contrôle le nouveau système de feu de signalisation : Le programme a été légèrement développé par rapport à la version précédente. import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) rouge = 0; jaune = 1; vert = 2, bleu = 3 Feu_de_circulation=[4,18,23,24] GPIO.setup(Feu_de_circulation[rouge], GPIO.OUT, initial=False) GPIO.setup(Feu_de_circulation[jaune], GPIO.OUT, initial=False) GPIO.
time.sleep(2) GPIO.output(Feu_de_circulation[vert],False); GPIO.output(Feu_de_circulation[jaune],True) time.sleep(0.6) GPIO.output(Feu_de_circulation[jaune],False); GPIO.output(Feu_de_circulation[rouge],True) time.sleep(0.6) for i in range(10): GPIO.output(Feu_de_circulation[bleu],True); time.sleep(0.05) GPIO.output(Feu_de_circulation[bleu],False); time.sleep(0.05) time.sleep(0.6) GPIO.output(Feu_de_circulation[jaune],True); time.sleep(0.6) GPIO.output(Feu_de_circulation[rouge],False) GPIO.
time.sleep(0.6) Avec un retard de 0,6 seconde après le dernier cycle de boucle, le cycle de commutation normal du feu de circulation est poursuivi par l'allumage simultané de la LED jaune et de la LED rouge (déjà allumée). Rien de nouveau jusqu'à maintenant. Ce qui est vraiment intéressant, c'est le feu pour piéton, lorsqu'il ne fonctionne pas automatiquement mais qu'il doit d'abord être activé en appuyant sur un bouton, comme c'est le cas pour de nombreux feux pour piétons.
Fig. 4.4: Touche avec résistance de protection et résistance Pull-Down sur une entrée GPIO Montez un bouton selon la figure suivante en utilisant les deux résistances dans le circuit. Fig. 4.5: Construction de la carte pour le feu pour piéton « activé sur demande ».
Composants nécessaires : 1x Carte de circuit imprimé 1x LED rouge 1x LED jaune 1x LED verte 1x LED bleue 4x résistances de 220 Ω 1x Bouton 1x résistance de 1 kΩ 1x résistance de 10 kΩ 7x câbles de connexion 1x cavalier court La barre de contact en bas de la figure du bouton est connectée avec le fil + 3,3 V du Raspberry Pi (broche 1) via le rail plus de la carte de circuit imprimé. Pour connecter le bouton avec le rail plus, nous utilisons un cavalier court pour garder le dessin clair.
Fig. 4.6: Feu clignotant pour piéton avec bouton Le programme ampel03.py contrôle le nouveau système de feu de signalisation avec le bouton pour le feu clignotant pour piéton # -*- coding: utf-8 -*import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) rouge = 0; jaune = 1; vert = 2; bleu = 3; bouton = 4 Feu_de_circulation=[4,18,23,24,25] GPIO.setup(Feu_de_circulation[rouge], GPIO.OUT, initial=False) GPIO.setup(Feu_de_circulation[jaune], GPIO.OUT, initial=False) GPIO.
GPIO.setup(Feu_de_circulation[bleu], GPIO.OUT, initial=False) GPIO.setup(Feu_de_circulation[bouton], GPIO.IN) print ("Appuyer sur le bouton pour activer le feu clignotant pour piétons , Ctrl+C arrête le programme") try: while True: if GPIO.input(Feu_de_circulation[bouton])==True: GPIO.output(Feu_de_circulation[vert],False) GPIO.output(Feu_de_circulation[jaune],True) time.sleep(0.6) GPIO.output(Feu_de_circulation[jaune],False) GPIO.output(Feu_de_circulation[rouge],True) time.sleep(0.
Plus tard, le jeu de caractères ANSI a été introduit parallèlement au jeu de caractère ASCII. Il est utilisé par les anciennes versions de Windows et présente encore une fois les mêmes erreurs. Pour parfaire la confusion des langues, les [accents français] et les autres lettres avec des accents ont été classés dans un autre endroit du jeu de caractères dans la norme ASCII. Pour résoudre ce problème, l'Unicode a été introduit dans les années 1990.
while True: if GPIO.input(Feu_de_circulation[bouton])==True: Dans la boucle infinie, une requête est maintenant intégrée. Les instructions suivantes sont d'abord exécutées lorsque le port GPIO 25 donne la valeur True et que l'utilisateur appuie également sur le bouton. Jusqu'à ce moment, le feu de circulation reste dans sa phase verte. La poursuite de la boucle correspond essentiellement au déroulement du dernier programme.
Composants nécessaires : 1x Carte de circuit imprimé 1x LED rouge 1x LED jaune 1x LED verte 1x LED bleue 4x résistances de 220 Ω 5x câbles de connexion Fig. 5.2: Quatre LED avec pré-résistances. Grâce à différents motifs clignotants à LED, nous expliquons plusieurs boucles et méthodes de programmation en Python. Le programme suivant propose différents motifs à LED qui peuvent être choisis par l'utilisateur en utilisant le clavier.
Le programme ledmuster.py permet de faire clignoter les LED de différentes façons. # -*- coding: utf-8 -*import RPi.GPIO as GPIO import time import random GPIO.setmode(GPIO.BCM) LED = [4,18,23,24] for i in LED: GPIO.setup(i, GPIO.OUT, initial=0) z = len(LED); w = 5; t = 0.
for i in range(w*z): j = random.randint(0,z-1) GPIO.output(LED[j], True); time.sleep(t) GPIO.output(LED[j], False) else: print ("Entrée invalide") except KeyboardInterrupt: GPIO.cleanup() 5.1.1 Voilà comment cela fonctionne La première ligne du programme avec la définition du codage UTF-8 et l'importation des bibliothèques requises sont déjà connues grâce aux expériences précédentes. La bibliothèque random est importée en plus pour générer un motif clignotant aléatoire.
Pour garder le programme universel et facile à modifier, trois autres variables sont maintenant définies : z Nombre de LED Le nombre de LED est automatiquement repris à l'aide de la fonction len() à partir de la liste LED. w Répétitions Chaque motif doit être répété cinq fois par défaut pour être mieux reconnu. Ce nombre peut être modifié selon vos souhaits et s'applique ensuite à tous les motifs. t Temps Cette variable indique la durée de l'allumage de la LED lorsqu'elle clignote.
les noms de variables sont directement interprétés. Dans la plupart de cas, raw_input() est également le meilleur choix car vous n'avez pas besoin de vous occuper des nombreuses entrées possibles. Le programme attend jusqu'à ce que l'utilisateur entre une lettre et appuie sur le bouton [Enter]. Selon le chiffre que l'utilisateur a entré, un motif donné doit maintenant être affiché avec les LED. Pour le vérifier, nous utilisons une construction if...elif...else.
for i in range(w): for j in range(z): GPIO.output(LED[j], GPIO.output(LED[j], for j in range(z-1, -1, GPIO.output(LED[j], GPIO.output(LED[j], True); time.sleep(t) False) -1): True); time.sleep(t) False) Des boucles imbriquées les unes dans les autres sont également utilisées ici. Après la première boucle interne, qui correspond à la partie du programme décrite ci-dessus, après que la LED avec le numéro 3 s'est allumée, une autre boucle pour le chenillard allant à contresens commence.
La première boucle interne allume les LED les unes après les autres avec un retard. À la fin de la boucle qui est reconnaissable par l'indentation de la ligne time.sleep(2*t), on attend pendant deux fois le temps de retard. Pendant ce temps, toutes les LED sont allumées. Après cela, une nouvelle boucle commence, qui décompte en arrière et qui éteint les LED, une par une.
Entrée invalide Pour tous les programmes qui nécessitent une entrée de l'utilisateur, on doit intercepter les entrées incorrectes. Si l'utilisateur entre une réponse imprévue, le programme doit y répondre. else: print ("Entrée invalide") Si l'utilisateur a entré quelque chose d'autre, l'instruction donnée sous else est exécutée. On rencontre toujours cette partie de requête si aucune des autres requêtes ne fournit de véritable résultat. Dans notre cas, le programme affiche un message à l'écran.
Fig. 6.
Fig. 6.3: Une LED sur le port GPIO 18 Le programme leddimmen01.py fait varier l'intensité lumineuse de la LED cycliquement et utilise pour ce faire une fonctionnalité propre PWM de la bibliothèque GPIO. Le signal PWM est généré comme un processus spécifique. De cette façon, une LED dont l'intensité lumineuse varie (presque) peut être utilisée comme une source lumineuse normale dans un programme. import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM); LED = 18 GPIO.setup(LED, GPIO.
6.1.1 Voilà comment cela fonctionne Une partie de ce programme vous est familière, certains éléments ne vous disent rien car nous faisons ici une petit tour dans la programmation orientée objet. Les bibliothèques sont importées au début, comme vous le savez déjà. Cette fois, une seule variable, LED, est fixée pour le port GPIO 18, qui est initialisé comme une sortie.
Après que la LED a atteint sa pleine luminosité, une deuxième boucle régule son intensité dans le sens inverse selon le même schéma. Cette boucle compte à rebours à partir de 100, avec des décréments de -2. Ce cycle se répète jusqu'à ce que l'utilisateur appuie sur la combinaison de touches [Ctrl]+[C]. except KeyboardInterrupt: p.stop(); GPIO.cleanup() Le KeyboardInterrupt déclenche immédiatement la méthode stop() de l'objet PWM. Cette méthode arrête la génération du signal PWM.
Composants nécessaires : 1x Carte de circuit imprimé 1x LED jaune 1x LED rouge 2x Résistances de 220 Ω 3x Câbles de connexion Fig. 6.5: Une deuxième LED sur le port GPIO 25 Le programme leddimmen02.py fait varier cycliquement l'intensité d'une LED pendant que l'autre LED éclaire avec une forte intensité avec la première LED, puis ne diminue pas d'intensité dans un autre cycle, éclaire de nouveau avec 0 et clignote rapidement. import RPi.
GPIO.setmode(GPIO.BCM); LED = [18,25] GPIO.setup(LED[0], GPIO.OUT); GPIO.setup(LED[1], GPIO.OUT) print ("Ctrl+C arrête le programme") p = GPIO.PWM(LED[0], 50); q = GPIO.PWM(LED[1], 50) p.start(0) q.start(0) try: while True: for c in range(0, 101, 2): p.ChangeDutyCycle(c); q.ChangeDutyCycle(c) time.sleep(0.1) q.ChangeFrequency(10) for c in range(0, 101, 2): p.ChangeDutyCycle(100-c); q.ChangeDutyCycle(c) time.sleep(0.1) q.ChangeFrequency(50) except KeyboardInterrupt: p.stop(); GPIO.cleanup() 6.1.
La deuxième boucle commence maintenant, par souci de simplicité, cette fois également avec un comptage croissant. Pour la première LED, à partir de l'objet PWM p, dont l'intensité doit être réduite pas à pas dans ce cycle, la valeur correspondante pour le rapport cyclique est calculée à chaque cycle. Pour la deuxième LED, à partir de l'objet PWM q, le rapport cyclique est simplement augmenté à nouveau. L'effet de clignotement est causé par le changement de fréquence. q.
Fig. 7.2: Construction de la carte pour l'indicateur à LED montrant l'espace disponible dans les cartes mémoires.
Fig. 7.3: Les trois LED indiquent l'espace mémoire disponible sur la carte mémoire. Le programme speicheranzeige.py fournit différents affichages par LED en fonction de l'espace mémoire libre sur la carte mémoire : Espace mémoire libre Affichage par LED < 1 Mo Rouge De 1 Mo à 10 Mo Rouge-Jaune De 10 Mo à 100 Mo Jaune De 100 Mo à 500 Mo Jaune-Vert > 500 Mo Vert Tableau 7.1: L’état de remplissage de la carte mémoire est ainsi affiché.
import RPi.GPIO as GPIO import time import os g1 = 1; g2 = 10; g3 = 100; g4 = 500 GPIO.setmode(GPIO.BCM) LED = [4,18,23] for i in range(3): GPIO.setup(LED[i], GPIO.OUT, initial=False) print ("Ctrl+C arrête le programme") try: while True : s = os.statvfs('/') f = s.f_bsize * s.f_bavail / 1000000 if f < g1: x = "100" elif f < g2: x = "110" elif f < g3: x = "010" elif f < g4: x = "011" else: x = "001" for i in range(3): GPIO.output(LED[i], int(x[i])) time.sleep(1.0) except KeyboardInterrupt: GPIO.
GPIO.setmode(GPIO.BCM) LED = [4,18,23] for i in range(3): GPIO.setup(LED[i], GPIO.OUT, initial=False) Une liste définit le numéro de port GPIO des trois LED. Après cela, une boucle initialise les trois ports GPIO comme des sorties et toutes les LEDS sont éteintes. Également dans cette expérience, nous utilisons une construction try...except et une boucle infinie pour que le programme s'exécute et se répète toujours automatiquement, jusqu'à ce que l'utilisateur l'arrête en appuyant sur [Ctrl]+[C].
Une boucle définit/fixe les valeurs de sortie pour les trois LED. Toutes les LED obtiennent successivement la valeur numérique de chaque chiffre à partir de la chaîne de caractères 0 ou 1. Les valeurs 0 et 1 peuvent également être utilisées comme False et True pour activer ou inactiver les sorties GPIO. La fonction int() calcule à partir d'un chiffre de ces valeurs numériques. Le chiffre est lu par le compteur de boucle i à partir d'une certaine position de la chaîne de caractères du motif. time.sleep(1.
# -*- coding: utf-8 -*import pygame, sys, random from pygame.locals import * pygame.init() FELD = pygame.display.set_mode((320, 320)) pygame.display.set_caption("Dé") BLEU = (0, 0, 255); BLANC = (255, 255, 255) P1 = ((160, 160)); P2 = ((60, 60)); P3 = ((160, 60)); P4 = ((260, 60)) P5 = ((60, 260)); P6 = ((160, 260)); P7 = ((260, 260)) mainloop = True print "Appuyer sur n'importe quelle touche pour lancer le dé, sur [échap] pour quitter le jeu" while mainloop: for event in pygame.event.get(): if event.
Fonctionne sans sudo Étant donné que ce programme n'a besoin d'aucun port GPIO, il fonctionne aussi sans privilège de superutilisateur. Vous pouvez facilement lancer l'IDE de Python via le symbole de bureau IDLE. 8.1.1 Voilà comment cela fonctionne Ce programme affiche de nombreuses nouvelles fonctions, en particulier pour les affichages graphiques avec la bibliothèque PyGame qui peut être évidemment utilisée pour les jeux mais également pour afficher d'autres graphismes à l'écran.
Ces lignes définissent le centre du point du dé. Les trois axes du point du dé sont placés sur la zone de dessin de 320 x 320 pixels avec les coordonnées 60, 160 et 260. Le système de coordonnées pour l'infographie Chaque point dans une fenêtre ou sur un objet-surface est représenté par ses coordonnées x et y. L'origine du système de coordonnées n'est pas à gauche en bas comme on l'apprend à l'école mais à gauche en haut.
mainloop = True Les bases sont ainsi créées et le vrai jeu peut commencer. print "Appuyer sur n'importe quelle touche pour lancer le dé, sur [échap] pour quitter le jeu" Cette ligne explique brièvement à l'utilisateur ce qu'il faut faire. Chaque fois que vous appuyez sur une touche du clavier, vous relancez le dé. print écrit toujours dans la fenêtre Python-Shell, et non dans la nouvelle fenêtre graphique. while mainloop: La boucle principale du jeu commence maintenant.
Cette ligne écrit seulement pour contrôler le résultat du lancer de dé dans la fenêtre du Python-Shell. Vous pouvez également omettre cette ligne si vous souhaitez renoncer à l'affichage textuel. print CHIFFRE if CHIFFRE == 1: pygame.draw.circle(CHAMP, BLANC, P1, 40) Les six requêtes suivent maintenant le même schéma. Lorsque le chiffre aléatoire du lancer de dé a une certaine valeur, un à six points de dé sont dessinés en conséquence. La fonction pygame.draw.
Fig. 8.3: Les six résultats possibles du lancer de dé.
La boucle recommence immédiatement et attend que l'utilisateur appuie sur une touche. Si pendant la boucle mainloop est spécifiée sur False, parce que l'utilisateur a arrêté le jeu, la boucle ne continue plus et la ligne suivante est exécutée à la place : pygame.quit() Cette ligne arrête le module PyGame, ce qui ferme également la fenêtre graphique et par conséquent l'ensemble du programme.
Le programme uhr01.py affiche une horloge analogique à l'écran : import pygame, time from pygame.locals import * from math import sin, cos, radians pygame.init() ROUGE = (255, 0, 0); BLANC = (255, 255, 255); NOIR = (0, 0, 0) CHAMP = pygame.display.set_mode((400, 400)) CHAMP.fill(BLANC) MX = 200; MY = 200; MP = ((MX, MY)) def point(A, W): w1 = radians(W * 6 – 90); x1 = int(MX + A * cos(w1)) y1 = int(MY + A * sin(w1)); return((x1, y1)) for i in range(60): pygame.draw.
CHAMP = pygame.display.set_mode((400, 400)); CHAMP.fill(BLANC) Une fenêtre de 400 x 400 pixel est ouverte et complétement colorée en blanc. MX = 200; MY = 200; MP = ((MX, MY)) Trois variables déterminent les coordonnées du point central(centre)à partir duquel tous les autres éléments graphiques, le cadran et les aiguilles sont placés. Les variables MX et MY contiennent les coordonnées x et y du point central, la variable MP le point central comme point, tel qu'il est utilisé pour les fonctions graphiques.
Une boucle dessine successivement les 60 points-minutes sur un cercle. Tous les points sont déterminés avec la fonction point(). Ils sont à la même distance du point central, qui est toujours éloigné de 10 pixels du bord de la fenêtre avec 190 pixels en quatre quadrants. Les points ont un rayon de 2 pixels. for i in range(12): pygame.draw.circle(CHAMP, NOIR, point(190, i * 5), 4) Une deuxième boucle dessine 12 cercles plus grands qui marquent les heures sur le cadran.
hm = (h + m / 60.0) * 5 La variable hm enregistre l'angle de l'aiguille des heures en unité-minute telle qu'elle est utilisée dans l'ensemble du programme. Pour ce faire, 1/60 de la valeur des minutes est ajoutée à l'heure actuelle. À chaque minute, l'aiguille de l'heure se déplace 1/60 d'une heure. La valeur calculée est multipliée par 5 parce que l'aiguille des heures avance de 5 unités-minutes sur le cadran en une heure. if s1 <> s: La durée d'un cycle de boucle n'est pas connue dans le programme.
Cette ligne dessine l'aiguille des secondes comme une ligne rouge large de 2 pixels et longue de 180 pixels à partir du point central, avec un angle qui est donné par la valeur des secondes. s1 = s La seconde qui vient d'être affichée est maintenant dans la variable s1, pour comparer cette valeur et la seconde actuelle dans le prochain cycle de boucle. pygame.display.set_caption("Heure actuelle : " + time.asctime()) Cette ligne écrit l'heure actuelle sous forme numérique dans le titre de la fenêtre.
Composants nécessaires : 1x Carte de circuit imprimé 1x LED rouge 1x Résistance de 220 Ω 2x Câbles de connexion Fig. 10.1: Une LED unique sur le port GPIO 4 Branchez une LED via une pré-résistance sur le port GPIO 4. Le programme ledtk01.py va allumer cette LED. import RPi.GPIO as GPIO from Tkinter import * LED = 4; GPIO.setmode(GPIO.BCM); GPIO.setup(LED,GPIO.
def LedAllumée(): GPIO.output(LED,True) def LedÉteinte(): GPIO.output(LED,False) root = Tk(); root.title("LED") Label(root, text="Veuillez cliquer sur le bouton, pour allumer et éteindre la LED").pack() Button(root, text="Allumée", command=LedAllumée).pack(side=LEFT) Button(root, text="Éteinte", command=LedÉteinte).pack(side=LEFT) root.mainloop() GPIO.cleanup() Fig. 10.2: Voilà à quoi la boîte de dialogue ressemble. 10.1.
root = Tk() Tkinter travaille avec ce qu'on appelle des widgets. Il s'agit d'éléments d'écran indépendants dans la plupart de cas pour contenir différents éléments de la boîte de dialogue. Chaque programme a besoin d'un widget root à partir duquel tous les autres objets sont appelés. Ce widget root est toujours nommé Tk(),génère automatiquement une fenêtre et initialise la bibliothèque Tkinter. L'objet root.title("LED") dans Tkinter fournit différentes méthodes pour différentes fins.
root.mainloop() Le programme principal se compose uniquement d'une seule ligne. Elle lance la boucle principale mainloop(), une méthode du widget root. Cette boucle du programme attend que l'utilisateur actionne un des widget et déclenche ainsi une action. Le symbole en haut à droite pour fermer la fenêtre n'a pas besoin d'être spécialement défini avec Tkinter. Si l'utilisateur ferme la fenêtre principale root, la boucle principale mainloop() est automatiquement quittée. GPIO.
Fig. 10.4: Construction de la carte pour l'expérience 10.
Fig. 10.5: Quatre LED clignotent avec des motifs différents. Le programme ledtk02.py est basé sur le programme précédent mais les boutons radio et les fonctions pour le chenillard à LED et les motifs clignotant sont étendues. import RPi.GPIO as GPIO import time from Tkinter import * GPIO.setmode(GPIO.BCM) LED = [4,18,23,24] for i in LED: GPIO.setup(i, GPIO.OUT, initial=0) w = 5; t = 0.
] root = Tk(); root.title("LED"); v = IntVar(); v.set(1) def LedEin(): e = v.get() if e == 1: for i in range(w): for j in range(4): GPIO.output(LED[j], True) time.sleep(t) GPIO.output(LED[j], False) elif e == 2: for i in range(w): for j in range(4): GPIO.output(LED[j], True) time.sleep(t) for j in range(4): GPIO.output(LED[j], False) time.sleep(t) else: for i in range(w): for j in range(4): GPIO.output(LED[3-j], True); time.sleep(t) GPIO.
motif = [ ("Chenillard vers la gauche",1), ("Clignoter",2), ("Chenillard vers la droite",3) ] Les textes des trois motifs disponibles sont définis sous forme de liste spécifique. Chacun des trois éléments de la liste consiste en quelques valeurs, chacun comprenant le texte affiché et la valeur numérique qui doit être retournée plus tard lors du choix du bouton radio. root = Tk(); root.
Dans le deuxième cas, toutes les quatre LED sont allumées à la suite simultanément, elles éclairent ensuite pendant 0,2 secondes puis sont éteintes en même temps. else: for i in range(w): for j in range(4): GPIO.output(LED[3-j], True); time.sleep(t) GPIO.output(LED[3-j], False) Le troisième cas ressemble au premier sauf que les LED sont comptées à l'envers et que, par conséquent, le chenillard court dans le sens inverse. Après avoir défini la fonction, les éléments de l'interface graphique sont créés.
Lancez le programme et choisissez un motif de LED via une des boutons radio. Le premier choix est présélectionné via la variable v. Si vous utilisez les boutons radio dans une boîte de dialogue, vous devez toujours définir une pré-sélection judicieuse pour ne jamais obtenir de résultat indéfini si l'utilisateur ne fait aucun choix. En cliquant sur Start, vous lancez le motif choisi et il s'exécute cinq fois. Vous pouvez ensuite choisir un autre motif. 10.
] root = Tk(); root.title("LED"); v = IntVar(); v.set(1); g = IntVar(); g.set(5) def LedEin(): e = v.get() t = 1.0/g.get() if e == 1: for i in range(w): for j in range(4): GPIO.output(LED[j], True); time.sleep(t) GPIO.output(LED[j], False) elif e == 2: for i in range(w): for j in range(4): GPIO.output(LED[j], True) time.sleep(t) for j in range(4): GPIO.output(LED[j], False) time.sleep(t) else: for i in range(w): for j in range(4): GPIO.output(LED[3-j], True): time.sleep(t) GPIO.
La fonction qui permet de faire clignoter les LED correspond aussi à l'exemple précédent, avec cependant une différence. La variable t pour la durée de clignotement est déterminée à partir de la valeur g du curseur. Étant donné qu'un utilisateur fait le lien intuitivement en un clin d'œil avec une vitesse plus élevée, le curseur placé à droite retourne une valeur plus élevée.
11 Pitance avec les LED À la fin des années 1970, avant la vraie époque des jeux informatiques, il y avait un jeu électronique avec quatre ampoules de couleur, qui a même été nominé pour le jeu de l'année en 1979. Le jeu était vendu en Allemagne sous le nom Senso. Atari l'a reproduit avec un jeu nommé Touch Me de la taille d'une grosse calculatrice. Un autre jeu semblable est sorti sous le nom Einstein. Senso a été commercialisé sous le nom Simon pour sa version anglophone.
extrémités à l'aide d'une lame coupante. Pliez ces morceaux de fil pour obtenir une forme en U. Vous pouvez ensuite connecter deux rangées sur une carte de circuit imprimé. Fig. 11.
Fig. 11.3: PiDance avec LED et des boutons sur les deux cartes de circuit imprimé Les boutons sont montés à côté des LED associées. Les deux rangées longitudinales centrales des cartes de circuit imprimé des deux côté du point de jonction servent de conducteur 0 V et + 3,3 V pour le circuit. Le programme pidance01.py contient le jeu terminé. # -*- coding: utf-8 -*import time, random import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) rchiffre = 10; couleur = [] for i in range(rchiffre): Couleur.append(random.
return 2 if(GPIO.input(BOUT[3])): return 3 ok = True for tour in range(1, rchiffre +1): print "Tour", tour for i in range(tour): LEDallumée(couleur[i], 1) for i in range(tour): bouton = Appuyer() LEDallumée(bouton, 0.2) if(bouton != couleur[i]): print "Perdu !" print "Vous avez réussi jusqu'au tour ", tour – 1, "." for j in range(4): GPIO.output(LED[j], True) for j in range(4): time.sleep(0.5) GPIO.output(LED[j], False) ok = False break if(ok == False): break time.sleep(0.
LED = [23,24,25,8] for i in LED: GPIO.setup(i, GPIO.OUT, initial=False) Les ports GPIO pour les LED sont configurés comme des sorties selon le schéma connu dans une liste LED et ils sont tous inactivés. BOUT = [4,17,21,22] for i in BOUT: GPIO.setup(i, GPIO.IN) Suivant le même principe, les ports GPIO sont configurés comme des entrées pour les quatre boutons dans une liste BOUT. Les bases sont ainsi créées et elles définissent encore deux fonctions qui sont nécessaires plusieurs fois dans le programme.
print "Tour", tour Le tour actuel est indiqué dans la fenêtre Python-Shell. for i in range(tour): LEDallumée(couleur[i], 1) Le programme exécute maintenant le motif que le joueur doit se rappeler. Selon le nombre actuel de tours, plusieurs LED s'allument successivement en fonction de la liste couleur spécifiée au début du programme, avec des couleurs choisies aléatoirement. Comme le compteur tour commence à 1, une seule LED s'allume déjà pendant le premier tour.
if(ok == False): break si ok est sur False, la boucle externe est également interrompue et il n'y a pas de tours supplémentaires. time.sleep(0.5) Si les entrées ont répété correctement la séquence, le programme attend pendant 0,5 seconde jusqu'à ce que le tour suivant commence. if(ok == True): Le programme arrive à cet endroit si les boucles se sont toutes exécutées, si le joueur a entré correctement toutes les séquences, ou si la boucle précédente a été interrompue par une erreur du jeu.
Mentions légales © 2014 Franzis Verlag GmbH, Richard-Reitzner-Allee 2, 85540 Haar bei München www.elo-web.de Auteur : Christian Immler ISBN 978-3-645-10145-5 Tous droits réservés, y compris en ce qui concerne la reproduction photomécanique et le stockage sur les supports électroniques. La création et la distribution de copies sur papier, sur des supports de données ou sur Internet, en particulier dans le format PDF, n'est autorisée qu'avec la permission expresse de l'éditeur, sous peine de poursuites.
