Construisez des projets physiques avec Python sur le Raspberry Pi – Real Python

By | juin 1, 2020

Python pas cher

La Raspberry Pi est l'une des principales cartes informatiques physiques du marché. Des amateurs qui créent des projets de bricolage aux étudiants qui apprennent à programmer pour la première fois, les gens utilisent le Raspberry Pi tous les jours pour interagir avec le monde qui les entoure. Python est intégré au Raspberry Pi, vous pouvez donc prendre vos compétences et commencer à créer vos propres projets Raspberry Pi dès aujourd'hui.

Apprendre à connaître le Raspberry Pi

Le Raspberry Pi est un ordinateur à carte unique développé par la Raspberry Pi Foundation, une organisation caritative basée au Royaume-Uni. Conçu à l'origine pour fournir aux jeunes une option informatique abordable pour apprendre à programmer, il a développé un énorme succès dans les communautés de fabricants et de bricoleurs en raison de sa taille compacte, de son environnement Linux complet et de ses entrées-sorties à usage général (GPIO) broches.

Avec toutes les fonctionnalités et capacités intégrées à cette petite carte, les projets et les cas d'utilisation du Raspberry Pi ne manquent pas.

Voici quelques exemples de projets:

Si vous pouvez penser à un projet qui gagnerait à avoir un ordinateur de la taille d'une carte de crédit, alors quelqu'un a probablement utilisé un Raspberry Pi pour le faire. Le Raspberry Pi est un moyen fantastique de donner vie à vos idées de projet Python.

Présentation de la carte Raspberry Pi

Le Raspberry Pi est disponible dans une variété de facteurs de forme pour différents cas d'utilisation. Dans ce didacticiel, vous examinerez la version la plus récente, le Raspberry Pi 4.

Vous trouverez ci-dessous la disposition de la carte du Raspberry Pi 4. Bien que cette disposition soit légèrement différente des modèles précédents du Raspberry Pi, la plupart des connexions sont les mêmes. La configuration décrite dans la section suivante doit être la même pour un Raspberry Pi 3 et un Raspberry Pi 4:

Composants de la carte Raspberry Pi 4

La carte Raspberry Pi 4 contient les composants suivants:

  • Broches d'entrée-sortie à usage général: Ces broches sont utilisées pour connecter le Raspberry Pi à des composants électroniques.

  • Port Ethernet: Ce port connecte le Raspberry Pi à un réseau câblé. Le Raspberry Pi intègre également le WiFi et le Bluetooth pour les connexions sans fil.

  • Deux ports USB 3.0 et deux ports USB 2.0: Ces ports USB sont utilisés pour connecter des périphériques comme un clavier ou une souris. Les deux ports noirs sont USB 2.0 et les deux ports bleus sont USB 3.0.

  • Prise AV: Cette prise AV vous permet de connecter des haut-parleurs ou des écouteurs au Raspberry Pi.

  • Port du module de caméra: Ce port est utilisé pour connecter le module de caméra Raspberry Pi officiel, qui permet au Raspberry Pi de capturer des images.

  • Ports HDMI: Ces ports HDMI connectent le Raspberry Pi à des moniteurs externes. Le Raspberry Pi 4 dispose de deux ports micro HDMI, ce qui lui permet de piloter deux moniteurs distincts en même temps.

  • Port d'alimentation USB: Ce port USB alimente le Raspberry Pi. Le Raspberry Pi 4 a un USB Type-C port, tandis que les anciennes versions du Pi ont un micro USB Port.

  • Port d'affichage externe: Ce port est utilisé pour connecter l'écran tactile officiel Raspberry Pi de sept pouces pour une entrée tactile sur le Raspberry Pi.

  • Emplacement pour carte microSD (sous la carte): Cet emplacement de carte est destiné à la carte microSD qui contient le système d'exploitation et les fichiers du Raspberry Pi.

Un peu plus loin dans ce didacticiel, vous utiliserez les composants ci-dessus pour configurer votre Raspberry Pi.

Raspberry Pi vs Arduino

Les gens se demandent souvent quelle est la différence entre un Raspberry Pi et un Arduino. L'Arduino est un autre appareil largement utilisé en informatique physique. Bien qu'il y ait un certain chevauchement dans les capacités de l'Arduino et du Raspberry Pi, il existe quelques différences distinctes.

La plate-forme Arduino fournit une interface matérielle et logicielle pour la programmation des microcontrôleurs. Un microcontrôleur est un circuit intégré qui vous permet de lire des entrées et d'envoyer des sorties vers des composants électroniques. Les cartes Arduino ont généralement une mémoire limitée, elles sont donc souvent utilisées pour exécuter à plusieurs reprises un seul programme qui interagit avec l'électronique.

Le Raspberry Pi est un ordinateur à usage général basé sur Linux. Il possède un système d'exploitation complet avec une interface graphique qui est capable d'exécuter de nombreux programmes différents en même temps.

Le Raspberry Pi est livré avec une variété de logiciels préinstallés, y compris un navigateur Web, une suite bureautique, un terminal et même Minecraft. Le Raspberry Pi dispose également de WiFi et Bluetooth intégrés pour se connecter à Internet et aux périphériques externes.

Pour exécuter Python, le Raspberry Pi est souvent le meilleur choix, car vous obtenez une installation Python à part entière sans aucune configuration.

Configuration du Raspberry Pi

Contrairement à l'Arduino, qui ne nécessite qu'un câble USB et un ordinateur pour être installé, le Raspberry Pi a plus de configuration matérielle pour être opérationnel. Cependant, après la configuration initiale, certains de ces périphériques ne seront plus nécessaires.

Matériel requis

Le matériel suivant est requis pour la configuration initiale de votre Raspberry Pi. Si vous vous connectez à votre Raspberry Pi via SSH, que vous examinerez plus loin dans ce didacticiel, une partie du matériel ci-dessous ne sera pas nécessaire après la configuration initiale.

Moniteur

Vous aurez besoin d'un moniteur pendant l'installation et la configuration initiales du système d'exploitation. Si vous utilisez SSH pour vous connecter à votre Raspberry Pi, vous n'aurez pas besoin du moniteur après la configuration. Assurez-vous que votre moniteur dispose d'une entrée HDMI.

carte Micro SD

Le Raspberry Pi utilise une carte microSD pour stocker le système d'exploitation et les fichiers. Si vous achetez un kit Raspberry Pi, il contiendra une carte microSD préformatée à utiliser. Si vous achetez une carte microSD séparément, vous devrez la formater vous-même. Recherchez une carte microSD avec au moins 16 Go de capacité.

Clavier et souris

Un clavier et une souris USB sont requis lors de la configuration initiale du Raspberry Pi. Une fois la configuration terminée, vous pouvez passer à l'utilisation des versions Bluetooth de ces périphériques si vous préférez. Plus loin dans ce didacticiel, vous verrez comment se connecter au Raspberry Pi via SSH. Si vous choisissez de vous connecter de cette manière, un clavier et une souris physiques ne sont pas requis après la configuration initiale.

Câbles HDMI

Vous aurez besoin d'un câble HDMI pour connecter le Raspberry Pi à un moniteur. Différents modèles de Raspberry Pi ont des exigences de câble HDMI différentes:

Raspberry Pi 4 Raspberry Pi 3/2/1 Raspberry Pi Zero
micro HDMI HDMI mini HDMI
micro HDMI vers HDMI HDMI vers HDMI mini HDMI vers HDMI

Selon votre modèle, vous devrez peut-être acheter un câble ou un adaptateur HDMI spécial.

Source de courant

Le Raspberry Pi utilise une connexion USB pour alimenter la carte. Encore une fois, différents modèles de Raspberry Pi ont des exigences de connexion et d'alimentation USB différentes.

Voici les exigences de connexion et d'alimentation pour les différents modèles:

Raspberry Pi 4 Raspberry Pi 3/2/1 / Zero
USB-C Micro USB
Au moins 3,0 ampères Au moins 2,5 ampères

Pour éviter toute confusion lors de la sélection d'une alimentation, il est recommandé d'utiliser l'alimentation officielle de votre Raspberry Pi 4 ou d'un autre modèle.

Matériel en option

Vous pouvez utiliser toute une gamme de matériel supplémentaire avec le Raspberry Pi pour étendre ses capacités. Les éléments matériels répertoriés ci-dessous ne sont pas nécessaires pour utiliser votre Raspberry Pi mais seraient utiles à avoir sous la main.

Cas

Il est agréable d'avoir un étui pour votre Raspberry Pi pour éviter que ses composants ne soient endommagés lors d'une utilisation normale. Lors de la sélection d'un boîtier, assurez-vous que vous achetez le type correct pour votre modèle de Raspberry Pi.

Haut-parleurs

Si vous souhaitez écouter de la musique ou du son à partir de votre Raspberry Pi, vous aurez besoin de haut-parleurs. Il peut s'agir de n'importe quel haut-parleur standard doté d'une prise 3,5 mm. Vous pouvez connecter les haut-parleurs au Raspberry Pi à l'aide de la prise AV sur le côté de la carte.

Logiciel

Le système d'exploitation du Raspberry Pi est stocké sur une carte microSD. Si votre carte ne provient pas d'un kit Raspberry Pi officiel, vous devrez alors y installer le système d'exploitation.

Il existe plusieurs façons de configurer le système d'exploitation sur votre Raspberry Pi. Vous pouvez en savoir plus sur les différentes options d'installation sur le site Web de Raspberry Pi.

Dans cette section, vous examinerez deux façons d'installer Raspbian, le système d'exploitation Raspberry Pi officiellement pris en charge, basé sur Debian Linux.

Option 2: installer Raspbian à partir de NOOBS

Si, pour une raison quelconque, vous ne pouvez pas utiliser l'imageur Raspberry Pi, vous pouvez télécharger NOOBS (Nouveau logiciel prêt à l'emploi) et utilisez-le pour installer Raspbian sur une carte microSD. Tout d'abord, rendez-vous sur la page de téléchargement de NOOBS pour télécharger la dernière version. Cliquez sur Télécharger ZIP sous le premier NOOBS option:

Page de téléchargement NOOBS

NOOBS commencera le téléchargement sur votre système.

Une fois le fichier ZIP téléchargé, décompressez le contenu vers un emplacement sur votre ordinateur. Vous allez copier ces fichiers sur la carte SD sous peu, mais vous devez d'abord formater correctement la carte SD.

Vous utiliserez l'officiel Formateur de carte mémoire SD de l'Association SD. Rendez-vous sur le site Web de SD Association pour télécharger le formateur. Faites défiler vers le bas et téléchargez le formateur SD pour Windows ou macOS:

Téléchargement du formateur SD

Une fois le formateur de carte mémoire SD téléchargé, vous êtes prêt à formater votre carte SD pour l'utiliser sur le Raspberry Pi.

Après avoir téléchargé le formateur SD, ouvrez l'application. Pour formater la carte SD, vous devez procéder comme suit:

  1. Insérez la carte SD dans votre ordinateur.
  2. Sélectionnez la carte SD dans le Sélectionnez la carte menu déroulant.
  3. Clique le Formatage rapide option sous Options de formatage.
  4. Entrer NOOBS dans le Étiquette de volume champ de texte.

Une fois les éléments ci-dessus terminés, cliquez sur Format:

SD Formatter Quick

Avant de formater la carte, vous serez invité à confirmer l'opération, car elle effacera toutes les données de la carte. Cliquez sur Continuer pour commencer le formatage de la carte SD. La mise en forme peut prendre quelques minutes:

SD Formatter Confirm

Une fois le formatage terminé, vous devrez copier les fichiers NOOBS que vous avez décompressés précédemment sur la carte SD. Sélectionnez tous les fichiers que vous avez extraits précédemment:

Copie du formateur SD NOOBS

Faites-les glisser sur la carte SD:

Copie SD Formatter NOOBS Drag

Maintenant que NOOBS est installé sur votre carte SD, éjectez la carte de votre ordinateur. Tu y es presque! Dans la section suivante, vous allez effectuer la configuration finale de votre Raspberry Pi.

Configuration finale

Maintenant que vous avez la carte microSD et le matériel requis prêts, la dernière étape consiste à tout connecter ensemble et à configurer le système d'exploitation. Commençons par connecter tous les périphériques:

  1. Insérez la carte microSD dans la fente pour carte au bas du Raspberry Pi.
  2. Connectez le clavier et la souris à l'un des quatre ports USB.
  3. Connectez un écran à l'un des ports HDMI à l'aide d'un câble HDMI spécifique à votre modèle Raspberry Pi.
  4. Connectez une alimentation au port d'alimentation USB.

Avec les périphériques connectés, allez-y et allumez votre Raspberry Pi pour configurer le système d'exploitation. Si vous avez installé Raspbian avec l'imageur Raspberry Pi, vous n'avez rien d'autre à faire. Vous pouvez passer à la section suivante pour terminer la configuration.

Si vous avez installé NOOBS sur votre carte SD, vous devrez effectuer quelques étapes supplémentaires pour installer Raspbian sur la carte SD:

  1. Tout d'abord, allumez le Raspberry Pi pour charger le NOOBS interface.
  2. Cochez ensuite la case à côté de Raspbian dans la liste des logiciels à installer.
  3. Enfin, cliquez sur le Installer dans le coin supérieur gauche de l'interface pour commencer l'installation de Raspbian sur la carte SD.

Une fois l'installation terminée, le Raspberry Pi redémarrera et vous serez démarré dans Raspbian pour terminer l'assistant de configuration.

Assistant de configuration

Au premier démarrage, Raspbian fournit un assistant de configuration pour vous aider à configurer votre mot de passe, définir vos paramètres régionaux, sélectionner un réseau WiFi et mettre à jour le système d'exploitation. Continuez et suivez ces étapes comme indiqué.

Une fois que vous avez terminé les étapes, redémarrez le système d'exploitation et vous serez prêt à commencer à programmer Python sur le Raspberry Pi!

Exécuter Python sur le Raspberry Pi

L'une des meilleures choses à propos de l'utilisation de Python sur le Raspberry Pi est que Python est un citoyen de première classe sur la plate-forme. La Fondation Raspberry Pi a spécifiquement choisi Python comme langue principale en raison de sa puissance, de sa polyvalence et de sa facilité d'utilisation. Python est préinstallé sur Raspbian, vous serez donc prêt à commencer dès le départ.

Vous disposez de nombreuses options différentes pour écrire Python sur le Raspberry Pi. Dans ce didacticiel, vous examinerez deux choix populaires:

  • En utilisant le Éditeur Mu
  • Modification à distance sur SSH

Commençons par regarder l’utilisation de l’éditeur Mu pour écrire Python sur le Raspberry Pi.

Utilisation de l'éditeur Mu

Le système d'exploitation Raspbian est livré avec plusieurs IDE Python préinstallés que vous pouvez utiliser pour écrire vos programmes. L'un de ces IDE est Mu. Il se trouve dans le menu principal:

Icône Raspberry Pi → Programmation → Mu

Lorsque vous ouvrez Mu pour la première fois, vous aurez la possibilité de sélectionner le mode Python pour l'éditeur. Pour le code de ce didacticiel, vous pouvez sélectionner Python 3:

Écran d'ouverture de l'éditeur MU

Il est possible que Mu ne soit pas préinstallé sur votre version de Raspbian. Si Mu n'est pas installé, vous pouvez toujours l'installer en vous rendant à l'emplacement du fichier suivant:

Icône Raspberry Pi → Préférences → Logiciel recommandé

Cela ouvrira une boîte de dialogue contenant les logiciels recommandés pour votre Raspberry Pi. Cochez la case à côté de Mu et cliquez sur D'accord pour l'installer:

Installation MU

Bien que Mu fournisse un excellent éditeur pour démarrer avec Python sur le Raspberry Pi, vous voudrez peut-être quelque chose de plus robuste. Dans la section suivante, vous vous connecterez à votre Raspberry Pi via SSH.

Modification à distance via SSH

Souvent, vous ne voudrez pas passer du temps à brancher un moniteur, un clavier et une souris pour écrire Python sur le Raspberry Pi. Heureusement, Raspbian vous permet de vous connecter à distance au Raspberry Pi via SSH. Dans cette section, vous apprendrez comment activer et utiliser SSH pour programmer Python sur le Raspberry Pi.

Activer SSH

Avant de pouvoir vous connecter au Raspberry Pi via SSH, vous devez activer l'accès SSH à l'intérieur du Raspberry Pi Préférences région. Activez SSH en accédant au chemin de fichier suivant:

Icône Raspberry Pi → Préférences → Configuration Raspberry Pi

Une fois la configuration affichée, sélectionnez l'onglet Interfaces puis activez l'option SSH:

Activer SSH

Vous avez activé SSH sur le Raspberry Pi. Vous devez maintenant obtenir l'adresse IP du Raspberry Pi pour pouvoir vous y connecter à partir d'un autre ordinateur.

Déterminer l'adresse IP du Raspberry Pi

Pour accéder à distance au Raspberry Pi, vous devez déterminer l'adresse IP du Raspberry Pi sur votre réseau local. Pour déterminer l'adresse IP, vous devez accéder au Terminal application. Vous pouvez accéder au Terminal ici:

Icône Raspberry Pi → Accessoires → Terminal

Une fois le terminal ouvert, entrez ce qui suit dans l'invite de commande:

pi @ raspberrypi: ~ $ hostname -I

Cela affichera l'adresse IP actuelle de votre Raspberry Pi. Avec cette adresse IP, vous pouvez désormais vous connecter à distance à votre Raspberry Pi.

Connectez-vous au Raspberry Pi

En utilisant l'adresse IP du Raspberry Pi, vous pouvez désormais y accéder via un autre ordinateur:

Vous serez invité à saisir le mot de passe que vous avez créé lors de l'exécution de l'assistant de configuration lors de l'installation de Raspbian. Si vous n'avez pas défini de mot de passe, le mot de passe par défaut est framboise. Saisissez le mot de passe et, une fois connecté, vous verrez l'invite de commande Raspberry Pi:

Maintenant que vous savez comment vous connecter, vous êtes prêt à commencer à programmer Python sur le Raspberry Pi. Vous pouvez commencer immédiatement à l'aide de Python REPL:

pi @ raspberrypi: ~ $ python3

Tapez du Python pour l'exécuter sur le Raspberry Pi:

>>>

>>> impression("Bonjour de votre Raspberry Pi!")
Bonjour de votre Raspberry Pi!

Génial, vous utilisez Python sur le Raspberry Pi!

Créer un projets python Annuaire

Avant de commencer à créer des projets avec Python sur le Raspberry Pi, c'est une bonne idée de configurer un répertoire dédié pour votre code. Le Raspberry Pi possède un système de fichiers complet avec de nombreux répertoires différents. Avoir une place réservée pour votre code Python aidera à garder tout organisé et facile à trouver.

Créons un répertoire appelé projets python où vous pouvez stocker du code Python pour vos projets.

Utilisation de Mu

Si vous prévoyez d'utiliser Mu pour terminer les projets de ce didacticiel, vous pouvez l'utiliser maintenant pour créer le projets python annuaire. Pour créer ce répertoire, vous devez procéder comme suit:

  1. Ouvrez Mu en allant à Icône Raspberry Pi → Programmation → Mu.
  2. Cliquez sur Nouveau dans la barre de menus pour créer un fichier vide.
  3. Cliquez sur sauver dans la barre de menus.
  4. Accédez au / accueil / pi dans la liste déroulante du répertoire.
  5. Clique le Créer un nouveau dossier dans le coin supérieur droit.
  6. Nommez ce nouveau répertoire projets python et frapper Entrer.
  7. Cliquez sur Annuler fermer.

Vous avez créé un répertoire dédié pour votre code Python. Rendez-vous à la section suivante pour en savoir plus sur l'interaction avec les composants physiques en Python.

Sur SSH

Si vous préférez utiliser SSH pour accéder à votre Raspberry Pi, vous utiliserez la ligne de commande pour créer le projets python annuaire.

Créons le projets python annuaire. Si vous n'êtes pas actuellement connecté au Raspberry Pi, utilisez l'adresse IP du Raspberry Pi vers SSH depuis votre ordinateur:

Une fois connecté, vous verrez l'invite de commande Raspberry Pi:

Par défaut, lorsque vous SSH dans le Raspberry Pi, vous commencerez dans le / accueil / pi annuaire. Confirmez cela maintenant en exécutant pwd:

pi @ framboise: ~ $ pwd
/ accueil / pi

Si, pour une raison quelconque, vous n'êtes pas / accueil / pi répertoire, puis basculez vers celui-ci en utilisant cd / home / pi:

pi @ raspberry: ~ / Desktop $ CD / accueil / pi
pi @ framboise: ~ $ pwd
/ accueil / pi

Maintenant dans le / accueil / pi répertoire, créez un nouveau projets python annuaire:

pi @ framboise: ~ $ mkdir python-projects

Avec le projets python répertoire créé, utilisez projets cd python pour aller dans le répertoire:

pi @ framboise: ~ $ CD projets python
pi @ raspberry: ~ / python-projects $

Génial! Vous êtes prêt à commencer à coder vos premiers circuits à l'aide de Python sur le Raspberry Pi.

Interaction avec les composants physiques

Dans cette section, vous apprendrez à interagir avec différents composants physiques à l'aide de Python sur le Raspberry Pi.

Vous utiliserez la bibliothèque gpiozero qui est préinstallée sur Raspbian. Il fournit une interface facile à utiliser pour interagir avec une variété de périphériques GPIO connectés au Raspberry Pi.

Composants electroniques

Avant de programmer sur le Raspberry Pi, vous aurez besoin de quelques composants électroniques pour construire les projets dans les sections à venir. Vous devriez pouvoir trouver chacun des articles ci-dessous sur Amazon ou dans votre magasin d'électronique local.

Planche à pain

UNE planche à pain est un outil essentiel lors de la construction de circuits. Il vous permet de prototyper rapidement votre circuit sans avoir à souder les composants ensemble.

Les maquettes suivent une disposition générale. Sur les côtés droit et gauche, deux rails longent la planche à pain. Chaque trou sur ces rails est connecté. Généralement, ceux-ci sont désignés positifs (Tension, ou VCC) et négatif (sol, ou GND).

Sur la plupart des platines, rail positif est marqué d'un signe positif (+) et aura une ligne rouge à côté. le rail négatif est marqué d'un signe négatif (-) et comporte une ligne bleue à côté.

À l'intérieur de la planche, rails de composants courir perpendiculairement aux rails positifs et négatifs sur les côtés de la planche à pain. Chacun de ces rails contient des trous pour placer des composants.

Tous les trous d'un seul rail sont connectés. Au milieu, une gouttière sépare les deux côtés de la planche à pain. Les rails des côtés opposés de la gouttière ne sont pas connectés.

Ceci est illustré dans le diagramme suivant:

Disposition de la maquette

Dans le schéma ci-dessus, trois couleurs sont utilisées pour marquer les différents types de rails de planche à pain:

  • Rouge: Rail positif
  • Noir: Rail négatif
  • Bleu: Rails de composants

Plus loin dans ce didacticiel, vous utiliserez ces différents rails pour créer des circuits complets qui se connectent au Raspberry Pi.

Fils de cavalier

Les fils de cavalier vous permettent de prototyper les connexions de votre circuit sans avoir à souder les chemins entre les broches GPIO et les composants. Ils existent en trois types différents:

  1. Mâle à mâle
  2. Femelle à mâle
  3. Femelle à femelle

Il serait bon d'avoir au moins dix à vingt de chaque type lorsque vous construisez vos projets Raspberry Pi en Python.

Autres composants

Avec les fils de la planche à pain et des cavaliers, les projets de ce didacticiel utiliseront les composants suivants:

Avec les composants requis en main, examinons comment les connecter au Raspberry Pi à l'aide des broches GPIO.

Broches GPIO

Le Raspberry Pi dispose de quarante broches GPIO le long du bord supérieur de la carte. Vous pouvez utiliser ces broches GPIO pour connecter le Raspberry Pi à des composants externes.

La disposition des broches ci-dessous montre les différents types de broches et leurs emplacements. Cette disposition est basée sur une vue aérienne des broches avec les ports USB du Raspberry Pi face à vous:

Disposition des broches GPIO

Le Raspberry Pi propose cinq types de broches différents:

  1. GPIO: Ce sont des broches à usage général qui peuvent être utilisées pour l'entrée ou la sortie.
  2. 3V3: Ces broches fournissent une source d'alimentation de 3,3 V pour les composants. 3,3 V est également la tension interne fournie par toutes les broches GPIO.
  3. 5V: Ces broches fournissent une source d'alimentation de 5 V, la même que l'entrée d'alimentation USB qui alimente le Raspberry Pi. Certains composants, tels que le capteur de mouvement infrarouge passif, nécessitent 5 V.
  4. GND: Ces broches fournissent une connexion à la terre pour les circuits.
  5. ADV: Ces broches spéciales sont avancées et ne sont pas traitées dans ce didacticiel.

Dans la section suivante, vous utiliserez ces différents types de broches pour configurer votre premier composant, un bouton tactile.

Bouton tactile

Pour votre premier circuit, vous allez connecter un bouton tactile au Raspberry Pi. Un bouton tactile est un interrupteur électronique qui, lorsqu'il est enfoncé, ferme un circuit. Lorsqu'un circuit est fermé, le Raspberry Pi enregistre un SUR signal. Vous pouvez utiliser ce signal ON pour déclencher différentes actions.

Dans ce projet, vous utiliserez un bouton tactile pour exécuter différentes fonctions Python en fonction de l'état du bouton. Commençons par câbler le bouton au Raspberry Pi:

  1. Connectez un de femme à homme fil de connexion du Raspberry Pi GND épingler au rail négatif de la planche à pain.
  2. Placez un bouton tactile sur la gouttière au milieu de la planche à pain.
  3. Connectez un homme à homme fil de pontage rail négatif de la planche à pain à la ligne où le bouton jambe en bas à gauche est placé.
  4. Connectez un de femme à homme fil de connexion du Raspberry Pi GPIO4 épingler à la ligne de la planche à pain où le bouton jambe en bas à droite est placé.

Vous pouvez confirmer votre câblage avec le schéma ci-dessous:

Diagramme du bouton tactile

Maintenant que votre circuit est branché, écrivons le code Python pour lire l'entrée à partir du bouton.

À l'intérieur de projets python répertoire que vous avez créé précédemment, enregistrez un nouveau fichier appelé button.py. Si vous utilisez SSH pour accéder à votre Raspberry Pi, créez le fichier comme ceci:

pi @ raspberrypi: ~ / cd projets python
pi @ raspberrypi: ~ / python-projects $ touchez button.py

Si vous utilisez Mu, créez le fichier en procédant comme suit:

  1. Clique le Nouveau élément du menu.
  2. Cliquez sur sauver.
  3. Accédez au / accueil / pi / projets-python annuaire.
  4. Enregistrez le fichier sous button.py.

Une fois le fichier créé, vous êtes prêt à commencer le codage. Commencez par importer le Bouton classe du gpiozero module. Vous devrez également importer pause du signal module. Vous allez voir pourquoi vous avez besoin pause plus tard:

de gpiozero importation Bouton
de signal importation pause

Créez une instance de la Bouton classe et passez le numéro de broche comme paramètre. Dans ce cas, vous utilisez le GPIO4 épingler, donc vous passerez 4 comme paramètre:

Ensuite, définissez les fonctions qui seront appelées pour les différents événements de bouton disponibles sur un Bouton exemple:

def button_pressed():
    impression("Le bouton a été enfoncé")

def button_held():
    impression("Le bouton était maintenu")

def button_released():
    impression("Le bouton est sorti")

le Bouton La classe a trois propriétés d'événement: .when_pressed, .when_held, et .when_released. Ces propriétés peuvent être utilisées pour connecter différentes fonctions d'événement.

Tandis que le .when_pressed et .when_released les propriétés sont explicites, .when_held nécessite une brève explication. Si une fonction est définie sur .when_held , elle ne sera appelée que si le bouton est maintenu enfoncé pendant un certain temps.

Le temps d'attente pour .when_held est déterminé par le .hold_time propriété sur le Bouton exemple. La valeur par défaut pour .hold_time est une seconde. Vous pouvez remplacer cela en passant un flotte valeur lors de la création d'un Bouton exemple:

bouton = Bouton(4, hold_time=2,5)
bouton.when_held = button_held

Cela créera un Bouton exemple qui attendra deux secondes et demie après avoir appuyé et maintenu le bouton avant d'appeler le button_held () une fonction.

Maintenant que vous connaissez les différentes propriétés d'événement sur Bouton, définissez chacun d'eux sur leurs fonctions respectives que vous avez définies précédemment:

bouton.quand_appuyé = button_pressed
bouton.when_held = button_held
bouton.when_released = button_released

Génial! Vous avez configuré les événements de votre bouton. La dernière chose que vous devez faire est d'appeler pause() à la fin du fichier. Appel pause() est nécessaire pour que le programme reste à l'écoute des différents événements. Si ce n'était pas le cas, le programme s'exécuterait une fois et se fermerait.

Votre programme final devrait ressembler à ceci:

de gpiozero importation Bouton
de signal importation pause

bouton = Bouton(4)

def button_pressed():
    impression("Le bouton a été enfoncé")

def button_held():
    impression("Le bouton était maintenu")

def button_released():
    impression("Le bouton est sorti")

bouton.quand_appuyé = button_pressed
bouton.when_held = button_held
bouton.when_released = button_released

pause()

Une fois le câblage terminé et le code configuré, vous êtes prêt à essayer votre premier circuit. À l'intérieur du projets python répertoire, exécutez le programme:

pi @ raspberrypi: ~ / python-projects $ python3 button.py

Si vous utilisez Mu, assurez-vous d'abord que le fichier est enregistré, puis cliquez sur Courir pour démarrer le programme.

Le programme est maintenant en cours d'exécution et écoute les événements. Appuyez sur le bouton et vous devriez voir ce qui suit dans la console:

Appuyez et maintenez le bouton pendant au moins une seconde, et vous devriez voir la sortie suivante:

Enfin, lorsque vous relâchez le bouton, vous devriez voir ce qui suit:

Impressionnant! Vous venez de câbler et de coder votre premier circuit en utilisant Python sur le Raspberry Pi.

Depuis que vous avez utilisé pause() dans votre code, vous devrez arrêter manuellement le programme. Si vous exécutez le programme dans Mu, vous pouvez cliquer sur Arrêtez pour quitter le programme. Si vous l'exécutez à partir de la ligne de commande, vous pouvez arrêter le programme avec Ctrl+C.

Avec ce premier circuit sous votre ceinture, vous êtes prêt à commencer à contrôler certains autres composants.

LED

Pour votre prochain circuit, vous utiliserez Python pour allumer et éteindre une LED chaque seconde. LED signifie diode électroluminescente, et ces composants produisent de la lumière lorsqu'un courant est appliqué. Vous constaterez qu’ils sont utilisés partout dans l’électronique.

Chaque LED a deux pattes. La jambe la plus longue est la jambe positive, ou anode. Le courant électrique pénètre dans la LED à travers cette jambe. La jambe la plus courte est la jambe négative, ou cathode). Le courant sort de la LED à travers cette jambe.

Le courant ne peut circuler que dans une direction à travers une LED, alors assurez-vous que vous connectez les cavaliers à la jambe appropriée de la LED.

Voici les étapes à suivre pour câbler ce circuit:

  1. Connectez un de femme à homme fil de connexion du Raspberry Pi GND épingler au rail négatif de la planche à pain.

  2. Placer un LED dans deux trous sur la planche à pain qui sont côte à côte mais pas dans la même rangée.

  3. Placer le jambe plus longue et positive de la LED dans le trou sur le côté droit.

  4. Placer le jambe plus courte et négative de la LED dans le trou sur le côté gauche.

  5. Placer une extrémité d'un Résistance 330 Ω dans un trou dans la même rangée de planche à pain que le jambe négative de la LED.

  6. Placez l'autre extrémité de la résistance dans le rail négatif de la planche à pain

  7. Connectez un de femme à homme fil de connexion du Raspberry Pi GPIO4 épingler à un trou dans la même rangée de planche à pain que le jambe positive de la LED.

Vous pouvez confirmer votre câblage avec le schéma ci-dessous:

Diagramme LED

Si le câblage semble bon, alors vous êtes prêt à écrire du Python pour faire clignoter la LED. Commencez par créer un fichier pour ce circuit à l'intérieur du projets python annuaire. Appeler ce fichier led.py:

pi @ raspberrypi: ~ / python-projects $ toucher led.py

Dans ce code, vous allez créer une instance de la LED classe et appeler son .cligner() pour allumer et éteindre la LED. le .cligner() La méthode a un délai d'expiration par défaut d'une seconde. La LED continue de clignoter chaque seconde jusqu'à ce que le programme soit quitté.

Commencez par importer LED du gpiozero module et pause du signal module:

de gpiozero importation LED
de signal importation pause

Ensuite, créez une instance de LED appelé LED. Définissez la broche GPIO sur 4:

Appeler le .cligner() méthode sur LED:

Enfin, ajoutez un appel à pause() pour vous assurer que le programme ne se ferme pas:

Votre programme complet devrait ressembler à ceci:

de gpiozero importation Avertisseur sonore
de signal importation pause

LED = LED(4)
LED.cligner()

pause()

Enregistrez le fichier et exécutez-le pour voir le voyant clignoter:

pi @ raspberrypi: ~ / python-projects $ python3 led.py

La LED devrait maintenant clignoter toutes les secondes. Lorsque vous avez fini d'admirer votre code Python en action, arrêtez le programme avec Ctrl+C ou Arrêtez à Mu.

Vous savez maintenant comment contrôler une LED avec Python sur le Raspberry Pi. Pour le prochain circuit, vous utiliserez Python pour produire du son à partir du Raspberry Pi.

Avertisseur sonore

Dans ce circuit, vous allez câbler un ronfleur piézo actif au Raspberry Pi. Un buzzer piézo émet une tonalité lorsque le courant est appliqué. En utilisant ce composant, votre Raspberry Pi pourra générer du son.

Like LEDs, a buzzer has a positive and negative leg. The positive leg of the buzzer will either be longer than the negative leg or there will be a positive sign (+) on the top of the buzzer showing which leg is the positive leg.

Let’s go ahead and wire up the buzzer:

  1. Place a buzzer on the breadboard, noting the placement of the buzzer’s positive leg.

  2. Connect a female-to-male jumper wire from the Raspberry Pi’s GND pin to a hole in the same breadboard row as the negative leg of the buzzer.

  3. Connect a female-to-male jumper wire from the Raspberry Pi’s GPIO4 pin to a hole in the same breadboard row as the positive leg of the buzzer.

Confirm your wiring against the diagram below:

Buzzer Diagram

With the wiring set up, let’s move on to the code. Create a file for this circuit inside the python-projects annuaire. Call this file buzzer.py:

pi@raspberrypi:~/python-projects $ touch buzzer.py

In this code, you’ll create an instance of the Buzzer class and call it’s .beep() method to make the buzzer beep on and off. le .beep() method’s first two parameters are on_time et off_time. These parameters take a float value to set how long the buzzer should beep on and off. The default value for both is one second.

Start by importing Buzzer du gpiozero module and pause du signal module:

de gpiozero importation Buzzer
de signal importation pause

Next, create an instance of Buzzer called buzzer. Set the GPIO pin to 4:

Call the .beep() method on buzzer. Set the on_time et off_time parameters to 0.5. This will make the buzzer beep every half second:

Finally, add a call to pause() to make sure the program doesn’t exit:

Your complete program should look like this:

de gpiozero importation LED
de signal importation pause

buzzer = Buzzer(4)
buzzer.beep(0.5, 0.5)

pause()

Save the file and run it to hear the buzzer beep on and off every half second:

pi@raspberrypi:~/python-projects $ python3 buzzer.py

You should hear the buzzer sound on and off until you stop the program with Ctrl+C ou Stop in Mu.

Great! So far you’ve learned how to control three different types of electronic components with Python on the Raspberry Pi. For the next circuit, let’s take a look at a slightly more complex component.

Motion Sensor

In this circuit, you’ll be connecting a passive infrared (PIR) motion sensor to the Raspberry Pi. A passive infrared motion sensor detects any motion in its field of vision and sends a signal back to the Raspberry Pi.

Adjusting the Sensor

When using a motion sensor, you may need to adjust how sensitive it is to motion and how long it will send out a signal after motion is detected.

You can make adjustments using two dials on the side of the sensor. You’ll know which dials they are because they’ll have a cross-shaped indentation in the center, which can be adjusted with a Phillips-head screwdriver.

The image below shows these dials on the side of the motion sensor:

Motion Sensor Adjustment Dials

As the image shows, the left dial sets the signal timeout and the right dial sets the sensor sensitivity. You can turn these dials clockwise or counterclockwise to adjust them:

  • Clockwise increases the timeout and sensitivity.
  • Counterclockwise decreases the timeout and sensitivity.

You can adjust these based on your project needs, but for this tutorial turn both dials counterclockwise all the way. This will set them to their lowest values.

Once you’ve adjusted the motion sensor, you’re ready to set up the wiring. The motion sensor’s design doesn’t allow it to easily connect to a breadboard. You’ll need to connect the Raspberry Pi’s GPIO pins directement to the pins on the motion sensor with jumper wires.

The image below shows the placement of the pins on the underside of the motion sensor:

Motion Sensor Pins

You can see there are three pins:

  1. VCC for voltage
  2. EN DEHORS for communicating with the Raspberry Pi
  3. GND for ground

Using these pins, you need to take the following steps:

  1. Connect a female-to-female jumper wire from the Raspberry Pi’s 5V pin to the sensor’s VCC pin.
  2. Connect a female-to-female jumper wire from the Raspberry Pi’s GPIO4 pin to the sensor’s EN DEHORS pin.
  3. Connect a female-to-female jumper wire from the Raspberry Pi’s GND pin to the sensor’s GND pin.

Now confirm the wiring with the diagram below:

PIR Diagram

With the motion sensor adjusted and wired to the Raspberry PI, let’s take a look at the Python code for detecting motion. Start by creating a file for this circuit inside the python-projects annuaire. Call this file pir.py:

pi@raspberrypi:~/python-projects $ touch pir.py

The code for this circuit is going to be similar to the button circuit you made previously. You’ll create an instance of the MotionSensor class and pass in the GPIO pin number 4 as the parameter. You’ll then define two functions and set them to the .when_motion et .when_no_motion properties on the MotionSensor instance.

Let’s take a look at the code:

de gpiozero importation MotionSensor
de signal importation pause

motion_sensor = MotionSensor(4)

def motion():
    impression("Motion detected")

def no_motion():
    impression("Motion stopped")

impression("Readying sensor...")
motion_sensor.wait_for_no_motion()
impression("Sensor ready")

motion_sensor.when_motion = motion
motion_sensor.when_no_motion = no_motion

pause()

motion() is set to the .when_motion property and is called when the sensor detects motion. no_motion() is set to the .when_no_motion property and is called when motion has stopped for a certain period. This time is determined by the timeout dial on the side of the sensor.

You’ll notice that before the .when_motion et .when_no_motion properties are set, there is a call to .wait_for_no_motion() sur le MotionSensor instance. This method will pause the execution of the code until the motion sensor no longer detects any motion. This is so that the sensor will ignore any initial motion that may occur as the program is starting up.

Save the code and run it to try out your motion detection circuit:

pi@raspberrypi:~/python-projects $ python3 pir.py
Readying sensor...
Sensor ready

Wave your hand in front of the sensor. When motion is first detected, motion() is called and the following is displayed in the console:

Now stop waving your hand in front of the sensor. After a few seconds, the following will be displayed:

Great! You can now detect motion with your Raspberry Pi. Once you’re done waving at your Raspberry Pi, go ahead and hit Ctrl+C in the command line or press Stop in Mu to terminate the program.

With this final circuit, you’ve learned how to use Python on the Raspberry Pi to control four different components. In the next section, you’ll tie all of this together in a full project.

Building a Motion-Activated Alarm System

Now that you’ve had the chance to connect the Raspberry Pi to a variety of inputs and outputs, you’re going to create a project that uses what you’ve learned so far.

In this project, you’ll build a motion-activated alarm system that will flash an LED and sound an alarm when it detects motion in a room. On top of this, you’ll use Python to save a timestamp to a CSV file detailing each time motion occurs.

Wiring

Here are the steps to complete the wiring:

  1. Relier female-to-male jumper wires from the Raspberry Pi’s 5V et GND pins to the positive et negative rails on the side of the breadboard.

  2. Place an LED on the breadboard and connect the Raspberry Pi’s GPIO14 pin to the LED with a female-to-male jumper wire.

  3. Connectez le LED’s negative leg to the breadboard’s negative rail through a 330 Ω resistor.

  4. Place a buzzer on the breadboard and connect the Raspberry Pi’s GPIO15 pin to the buzzer with a female-to-male jumper wire.

  5. Connectez le buzzer’s negative leg to the breadboard’s negative rail avec un male-to-male jumper wire.

  6. Connect a female-to-male jumper wire from the breadboard’s positive rail to the sensor’s VCC pin.

  7. Connect a female-to-female jumper wire from the Raspberry Pi’s GPIO4 pin to the sensor’s EN DEHORS pin.

  8. Connect a female-to-male jumper wire from the breadboard’s negative rail to the sensor’s GND pin.

Confirm the wiring against the diagram below:

Full Project Diagram

Okay, now that you have the circuit wired up, let’s dig into the Python code to set up your motion-activated alarm system.

Code

As usual, start by creating a file for this project inside the python-projects annuaire. For this project, call this file motion_detector.py:

pi@raspberrypi:~/python-projects $ touch motion_detector.py

The first thing you want to do is import the csv module so you can save a timestamp when motion is detected. Also, import Chemin du pathlib module so you can reference your CSV file:

importation csv
de pathlib importation Chemin

Next, import datetime du datetime module so you can create a timestamp of the motion event:

de datetime importation datetime

Finally, import the required component classes from gpiozero as well as pause du signal module:

de gpiozero importation LED, Buzzer, MotionSensor
de signal importation pause

With the imports ready, you can set up the three electronic components you’ll be using. Create instances of the LED, Buzzer, et MotionSensor classes. For each of these, pass in their pin numbers as parameters:

led = LED(14)
buzzer = Buzzer(15)
motion_sensor = MotionSensor(4)

Next, define the location of a CSV file that will store a timestamp each time motion is detected. You’ll call it detected_motion.csv. Create a dictionary to hold the timestamp values that will be written to the CSV:

output_csv_path = Chemin("detected_motion.csv")
motion = 
    "start_time": Aucun,
    "end_time": Aucun,

Create a method that saves the timestamp data to a CSV file. When the file is first created, a header row is added:

def write_to_csv():
    first_write = ne pas output_csv_path.is_file()

    avec ouvert(output_csv_path, "a") comme file:
        field_names = motion.clés()
        writer = csv.DictWriter(file, field_names)
        si first_write:
            writer.writeheader()
        writer.writerow(motion)

Define a start_motion() une fonction. This function will have several behaviors:

  • Start blinking the led on and off every half second
  • Make the buzzer beep
  • Save the start_time timestamp to the motion dictionary

Add a call to print() so you can watch the events occur while the program is running:

def start_motion():
    led.blink(0.5, 0.5)
    buzzer.beep(0.5, 0.5)
    motion[[[["start_time"] = datetime.now()
    impression("motion detected")

Then define an end_motion() function that will have the following behaviors:

  • Turn off the led et buzzer
  • Save the end_time horodatage
  • Appel write_to_csv() to save the motion data to the CSV file
  • Reset the motion dictionary

You’ll also check that a motion["start_time"] value exists before running any of the other code. You only want to write to the CSV if a start_time timestamp was recorded:

def end_motion():
    si motion[[[["start_time"]:
        led.de()
        buzzer.de()
        motion[[[["end_time"] = datetime.now()
        write_to_csv()
        motion[[[["start_time"] = Aucun
        motion[[[["end_time"] = Aucun
    impression("motion ended")

Add a call to .wait_for_no_motion() so that any initial motion is ignored:

impression("Readying sensor...")
motion_sensor.wait_for_no_motion()
impression("Sensor ready")

Set the .when_motion et .when_no_motion properties on the MotionSensor exemple:

motion_sensor.when_motion = start_motion
motion_sensor.when_no_motion = end_motion

Finally, end the code with a call to pause() to keep the program running. The full Python code should look like this:

importation csv
de pathlib importation Chemin
de datetime importation datetime
de gpiozero importation LED, Buzzer, MotionSensor
de signal importation pause

led = LED(14)
buzzer = Buzzer(15)
motion_sensor = MotionSensor(4)

output_csv_path = Chemin("detected_motion.csv")
motion = 
    "start_time": Aucun,
    "end_time": Aucun,


def write_to_csv():
    first_write = ne pas output_csv_path.is_file()

    avec ouvert(output_csv_path, "a") comme file:
        field_names = motion.clés()
        writer = csv.DictWriter(file, field_names)
        si first_write:
            writer.writeheader()
        writer.writerow(motion)

def start_motion():
    led.blink(0.5, 0.5)
    buzzer.beep(0.5, 0.5)
    motion[[[["start_time"] = datetime.now()
    impression("motion detected")

def end_motion():
    si motion[[[["start_time"]:
        led.de()
        buzzer.de()
        motion[[[["end_time"] = datetime.now()
        write_to_csv()
        motion[[[["start_time"] = Aucun
        motion[[[["end_time"] = Aucun
    impression("motion ended")

impression("Readying sensor...")
motion_sensor.wait_for_no_motion()
impression("Sensor ready")

motion_sensor.when_motion = start_motion
motion_sensor.when_no_motion = end_motion

pause()

Save the file and run it to test out your new motion detector alarm:

pi@raspberrypi:~/python-projects $ python3 motion_detector.py
Readying sensor...
Sensor ready

Now if you wave your hand in front of the motion detector, then the buzzer should start beeping and the LED should flash. If you stop moving for a few seconds, then the alarm should stop. In the console you should see the following:

pi@raspberrypi:~/python-projects $ python3 motion_detector.py
Readying sensor...
Sensor ready
motion detected
motion ended
motion detected
motion ended
...

Go ahead and stop the program with Stop in Mu or Ctrl+C. Let’s check out the CSV file that was generated:

pi@raspberrypi:~/python-projects $ cat detected_motion.csv
start_time,end_time
2020-04-21 10:53:07.052609,2020-04-21 10:53:13.966061
2020-04-21 10:56:56.477952,2020-04-21 10:57:03.490855
2020-04-21 10:57:04.693970,2020-04-21 10:57:12.007095

As you can see, the timestamps for the motion’s start_time et end_time have been added to the CSV file.

Toutes nos félicitations! You’ve created a non-trivial electronics project with Python on the Raspberry Pi.

Next Steps

You don’t have to stop here. There are many ways you could improve this project by leveraging the capabilities of Python on the Raspberry Pi.

Here are some ways to level up this project:

  • Connect the Raspberry Pi Camera Module and have it take a photo whenever motion is detected.

  • Connect a speaker to the Raspberry Pi and use PyGame to play a sound file to intimidate an intruder.

  • Add a button to the circuit to allow a user to manually toggle motion detection on or off.

There are many ways to upgrade this project. Let us know what you come up with!

Conclusion

The Raspberry Pi is an amazing computing device that just keeps getting better. It’s packed with features that make it the go-to device for physical computing.

In this tutorial, you’ve learned how to:

  • Set up a Raspberry Pi and run Python code on it
  • Read input from capteurs
  • Send output to electronic components
  • Build a cool project using Python on the Raspberry Pi

Python is the perfect complement to the Raspberry Pi, and with the skills you’ve learned you’re ready to tackle cool and innovative physical computing projects. We can’t wait to hear what you build!