Raspberry PI est un appareil aux performances suffisantes pour que des robots puissent être construits sur sa base, capables de reconnaître des images, d'effectuer un travail humain et d'autres appareils similaires pour automatiser et effectuer des actions de calcul complexes. Parce que fréquence d'horloge Processeur Raspberry PI 3 mb. 1,2 GHz et sa largeur de bits est de 32 bits, alors le Raspberry PI 3 est bien supérieur à l'Arduino habituel, dont la fréquence d'horloge est généralement de 16 MHz et le bit du microcontrôleur est de 8 bits, Arduino prend certainement sa place dans la réalisation d'opérations qui ne nécessitent pas grande performance, mais quand il ne suffit plus Raspberry PI " vient à la rescousse " et couvre une si large gamme applications possibles que vous pouvez être absolument sûr de l'opportunité d'acheter cet ordinateur monocarte Raspberry PI 3 (peut être commandé via le lien). Parce que Raspberry PI est un ordinateur, pour l'utiliser, vous devez y installer un système d'exploitation (bien qu'il existe des solutions de contournement, il est toujours mieux et plus facile d'installer un système d'exploitation (OS plus loin)). Il existe de nombreux systèmes d'exploitation qui peuvent être installés sur le Raspberry Pi, mais l'un des plus populaires (à utiliser avec le Raspberry Pi), le plus adapté aux débutants, est le système d'exploitation Raspbian. Afin d'installer un système d'exploitation sur un Raspberry Pi, vous avez besoin d'une carte micro sd avec un expandeur pour pouvoir l'insérer dans ordinateur ordinaire et écrivez des guêpes dessus. La carte SD doit avoir au moins 4 Go de mémoire lors de l'installation de la version complète de Raspbian et au moins 8 Go pour l'installation des versions minimales de Raspbian. Les versions minimales peuvent ou non avoir interface graphique et beaucoup de tout ce qui peut être considéré comme superflu et prend de la place. Pour éviter les problèmes de manque fichiers requis, vous pouvez mettre la version complète. Vous pouvez utiliser une carte SD de classe 10 avec 32 Go de mémoire (testée pour fonctionner (voir la vidéo ci-dessous)). Après avoir acheté une carte mémoire, vous devez l'insérer dans l'ordinateur dans l'emplacement approprié, puis recherchez avec quelle lettre le disque est apparu dans la section "mon ordinateur" et rappelez-vous, vous devez alors télécharger le système d'exploitation à partir du site officiel https : //www.raspberrypi.org/downloads/raspbian / en cliquant sur le bouton "Télécharger ZIP" sous "RASPBIAN JESSIE" pour télécharger la version complète ou sous "RASPBIAN JESSIE LITE" pour télécharger la version allégée, mais pour les débutants il vaut mieux choisissez "RASPBIAN JESSIE" c'est-à-dire version complète. Après avoir téléchargé l'archive "RASPBIAN JESSIE", vous devez la décompresser, puis télécharger le programme (ou à partir d'ici https://yadi.sk/d/SGGe1lMNs69YQ), l'installer, l'ouvrir, puis vous devez spécifier la lettre de lecteur (mémorisé plus tôt) dans le coin supérieur droit, recherchez l'image os décompressée
Et appuyez sur le bouton "écrire".
Après cela, une fenêtre d'avertissement apparaîtra et dans cette fenêtre, vous devez cliquer sur le bouton "Oui",
Une fois l'enregistrement terminé et une fenêtre apparaît informant d'un enregistrement réussi (Write Successful), vous devez cliquer sur le bouton "Ok" dans cette fenêtre.
Fermez ensuite le programme, retirez la carte SD en toute sécurité et insérez-le dans Raspberry Pi.
Ensuite, vous pouvez vous connecter à Raspberry Pi clavier usb(ou ps2 via), souris et moniteur usb ou TV via câble HDMI ou vous pouvez connecter un câble Ethernet (mais c'est pour les utilisateurs avancés, nous considérerons donc la première option ci-dessous). Après cela, vous devez connecter l'alimentation via micro USB par exemple de chargeur depuis un smartphone. Après avoir branché l'alimentation, l'installation du système d'exploitation commencera. En règle générale, dans les nouvelles versions (au moment d'écrire ces lignes) de l'OS, la possibilité de communiquer avec le Raspberry Pi via SSH est déjà configurée, et donc, afin de configurer la communication avec le Raspberry Pi 3 via wifi, il suffit de configurer uniquement le wifi. Pour ce faire, dans le coin supérieur droit de l'écran se trouve une icône sur laquelle vous devez cliquer et sélectionner le wifi,
Saisissez ensuite le mot de passe de ce wifi dans la zone de texte qui apparaît,
Après ces étapes, le wifi sur le Raspberry Pi 3 sera configuré puis il sera possible de programmer le Raspberry Pi 3 à distance via le wifi sans utiliser de fils. Après avoir configuré le Raspberry Pi 3, vous pouvez l'éteindre en tapant sudo halt dans la ligne de commande (dans le programme LXTerminal, qui peut être ouvert en double-cliquant sur l'icône du programme) ou en appuyant sur les boutons d'arrêt correspondants en mode graphique, après l'arrêt final, vous pouvez couper l'alimentation et la prochaine fois que le Raspberry Pi 3 est mis sous tension, allumez-le avec le wifi. Maintenant, pour programmer le Raspberry Pi 3 via le wifi, vous devez savoir quelle est son adresse IP. Pour ce faire, vous devez alimenter le Raspberry Pi 3, attendre que le système d'exploitation soit chargé, accéder à l'interface Web du routeur (en entrant 192.168.1.1 dans la ligne du navigateur ou ce dont vous avez besoin pour entrer dans l'interface Web, entrez votre identifiant et votre mot de passe), recherchez l'onglet DHCP Baux ou quelque chose de similaire, trouvez-y une ligne avec framboise et adresse IP de Raspberry Pi 3.
Ensuite, vous devez ouvrir le programme PuTTY (s'il n'est pas là, puis télécharger (ou) et installer) mettre le port 22, vous connecter via SSH, entrer l'adresse IP du Raspberry Pi 3 dans le "Nom d'hôte (ou adresse IP )" domaine,
Appuyez ensuite sur le bouton "Ouvrir" en bas de la fenêtre, puis il apparaîtra fenêtre noire avec une proposition d'entrer un login. Le login par défaut est "pi" - vous devez le saisir et appuyer sur Entrée. Ensuite, vous devez entrer un mot de passe, par défaut "framboise". Lorsque vous entrez un mot de passe, il ne s'affiche pas - c'est normal. Une fois le mot de passe entré en lettres invisibles, vous devez appuyer sur Entrée et si tout a été fait correctement, nous aurons accès au Raspberry Pi 3, sinon, vous devrez répéter les étapes. Après avoir accédé au Raspberry Pi 3, vous pouvez le programmer, vous devez d'abord entrer dans le dossier "pi" pour cela, vous devez entrer la commande
Et appuyez sur entrée (après cd, un espace est requis).
Vous pouvez maintenant ouvrir éditeur de texte nano. Nano est un éditeur de texte spécial que l'on trouve sur la plupart des systèmes d'exploitation de type Linux dans lequel vous pouvez écrire un programme pour le Raspberry Pi. Pour ouvrir cet éditeur et créer en même temps un fichier avec le nom "first" et l'extension "py", vous devez entrer la commande
Et appuyez sur Entrée. L'éditeur nano s'ouvrira et vous remarquerez que son interface est légèrement différente, mais il s'agit essentiellement du même champ noir dans lequel vous devez entrer des commandes. Parce que nous voulons contrôler les ports d'entrée / sortie généraux (GPIO), puis avant de démarrer le programme de contrôle de ces ports, vous devez leur connecter un périphérique afin que vous puissiez voir que le contrôle a été effectué. Il faut aussi noter que les broches configurées en sorties sur le Raspberry Pi peuvent produire un très faible courant (je suppose que jusqu'à 25mA) et étant donné que le Raspberry Pi n'est toujours pas l'appareil le moins cher, il est fortement recommandé de faire attention à ce que la charge sur les broches n'est pas trop importante. Les voyants LED de faible puissance peuvent généralement être utilisés avec le Raspberry Pi. un petit courant suffit pour qu'ils brillent. Pour la première fois, vous pouvez réaliser un appareil avec un connecteur, deux LED connectées en contre-parallèle et une résistance d'une résistance de 220 Ohm connectée en série avec les LED. Parce que la résistance de la résistance est de 220 Ohm, le courant doit traverser cette résistance et il n'y a pas de chemins parallèles de son passage, la tension aux bornes est de 3,3V, alors le courant ne sera pas supérieur à 3,3 / 220 = 0,015A = 15mA. Vous pouvez le connecter à des GPIO libres, par exemple, à 5 et 13 comme dans le schéma
(brochage tiré de https://en.wikipedia.org/wiki/Raspberry_Pi), cela pourrait ressembler à ceci :
Une fois que tout est proprement et correctement connecté et qu'il est certain que rien ne brûlera, vous pouvez copier le premier programme simple dans l'éditeur NANO langage Python
Importer RPi.GPIO en tant que GPIO
heure d'importation
GPIO.setmode (GPIO.BCM)
GPIO.setup (13, GPIO.OUT)
GPIO.setup (5, GPIO.OUT)
GPIO.sortie (13, vrai)
GPIO.sortie (5, Faux)
temps.sommeil (1)
GPIO.sortie (13, Faux)
GPIO.sortie (5, vrai)
temps.sommeil (1)
GPIO.sortie (13, vrai)
GPIO.sortie (5, Faux)
temps.sommeil (1)
GPIO.sortie (13, Faux)
GPIO.sortie (5, vrai)
temps.sommeil (1)
GPIO.sortie (13, vrai)
GPIO.sortie (5, Faux)
temps.sommeil (1)
GPIO.sortie (13, Faux)
GPIO.sortie (5, vrai)
temps.sommeil (1)
GPIO.cleanup ()
Puis appuyez
Après avoir quitté l'éditeur NANO, vous pouvez entrer la commande
Sudo python first.py
Après cela, les LED clignotent plusieurs fois. Ceux. réussi à gérer les ports d'E/S usage général par wifi ! Examinons maintenant le programme et découvrons comment cela s'est passé.
Ligne:
Importer RPi.GPIO en tant que GPIO
Il s'agit d'une connexion à la bibliothèque "GPIO" pour contrôler les broches.
Ligne:
Il s'agit de la connexion de la bibliothèque "time" pour les délais.
Vient ensuite le paramétrage du mode GPIO :
GPIO.setmode (GPIO.BCM)
Configuration des broches 5 et 13 en sorties :
GPIO.setup (13, GPIO.OUT)
GPIO.setup (5, GPIO.OUT)
Définition d'un un logique à la broche 13, définition d'un zéro logique à la broche 5:
GPIO.sortie (13, vrai)
GPIO.sortie (5, Faux)
Retard
Définition d'un zéro logique à la broche 13, définition d'un un logique à la broche 5 :
GPIO.sortie (13, Faux)
GPIO.sortie (5, vrai)
Traduit toutes les conclusions en l'état initial et le programme se termine. Donc vous pouvez contrôler toutes les broches libres via wifi et si vous faites une alimentation 5V à partir d'une batterie, vous pouvez déjà en faire robot autonome ou un appareil non lié à quoi que ce soit de stationnaire par des fils. Le langage de programmation Python (Python) diffère des langages similaires en C, par exemple, au lieu d'un point-virgule, pour terminer une commande, Python utilise un saut de ligne, au lieu d'accolades, il utilise le retrait de la marge de gauche, ce qui est fait avec la touche Tab. En général, Python est un langage très intéressant qui produit un code simple et facile à lire. Une fois le travail (ou le jeu) avec Raspberry PI 3 terminé, vous pouvez l'éteindre avec la commande
Et après un arrêt complet, coupez l'alimentation. Lorsque l'alimentation est appliquée, le Raspberry PI 3 s'allume et vous pouvez à nouveau travailler (ou jouer) avec. Vous pouvez commander Raspberry pi 3 sur http://ali.pub/91xb2. Comment c'est fait Configuration de la framboise Le PI 3 et la gestion de ses broches sont visibles dans la vidéo :
Après un clignotement réussi des LED, vous pouvez démarrer une étude à grande échelle cet ordinateur et créer des projets en utilisant les capacités de Raspberry PI 3 qui ne sont limitées que par votre imagination !
Un diagramme schématique de la connexion du bouton est illustré à la Figure 12. Veuillez noter que sur planche à pain la LED de l'exemple de la première partie de l'article reste connectée, mais elle n'est pas représentée dans le schéma actuel.
Comme vous pouvez le voir sur le schéma, si le bouton n'est pas enfoncé, l'entrée GPIO5 sera connectée via une résistance au bus 3,3 V. Le port d'entrée RPi a une impédance d'entrée élevée, donc la tension sur la ligne d'entrée sera proche à 3,3 V. Cela signifie que lorsque le bouton est relâché, le RPi détectera l'état de l'entrée comme "log. une". Lorsque le bouton est enfoncé, la tension d'entrée sera de 0 V, ce qui correspond à « log. 0 ".
Pour ce circuit simple, la valeur de résistance de R1 n'est pas critique et peut être comprise entre 1 kΩ et 47 kΩ, cependant, les valeurs basses doivent être évitées, car cela augmente le courant consommé lorsque le bouton est enfoncé.
Le code source du programme de lecture de l'état du bouton est disponible dans la rubrique téléchargements (fichier nommé Listing_4 (Bouton) .txt). Enregistrez le code dans un fichier nommé bouton-test.py et lancez-le avec la commande
sudo python bouton-test.py.
Le résultat de l'exécution du programme est affiché à l'écran sous la forme d'un message sur l'état actuel du bouton et le nombre de clics dessus. Lors de l'exécution de cet exemple, vous remarquerez que parfois la valeur du compteur devient supérieure au nombre réel de clics sur le bouton, et cela est dû au rebond des contacts. À peu près la même chose se produit lorsque le bouton est relâché. La solution est d'utiliser un mécanisme anti-rebond. Ce mécanisme peut être soit matériel, soit logiciel, ce dernier étant le plus courant. Dans le code source donné dans le fichier Listing_5 (Button_Debounce) .txt, la suppression du rebond des contacts des boutons est mise en œuvre et le comptage du nombre de pressions sur les boutons sera plus précis. La seule différence par rapport au code précédent est que maintenant la deuxième vérification de l'état de l'entrée est effectuée avec un retard de 20 ms - pendant ce temps, le rebond des contacts s'arrête.
Autre exemple : le voltmètre
Comme vous le savez, les cartes RPi n'ont que des ports d'E/S numériques, mais dans le monde réel, il existe des valeurs analogiques qui peuvent avoir besoin d'être mesurées ou surveillées. L'exemple suivant illustre la conversion d'une valeur analogique en signal numérique qui peut être lu à l'aide des entrées RPi.
Un exemple est un voltmètre très simple mais précis avec une plage de mesure de 0 ... 1 V (Figures 13, 14). Veuillez noter qu'il ne peut pas remplacer un multimètre portable car il n'a pas les circuits de protection nécessaires et peut tomber en panne tout seul ou endommager la carte RPi s'il est utilisé pour quelque chose en dehors de la portée des exemples décrits ici.
Le circuit utilise une puce AD654 (convertisseur tension-fréquence), qui génère des impulsions carrées à une fréquence dépendante de la tension d'entrée. La sortie numérique Fout du microcircuit est connectée à l'entrée GPIO5 (broche 29 du connecteur GPIO). Fréquence maximale impulsions rectangulaires avec les valeurs nominales des éléments indiquées sur le schéma, elle est de 10 kHz, par conséquent, pour déterminer la tension d'entrée, nous avons besoin d'un système de référence de temps précis. Le code de cet exemple (fichier Listing_6 (Voltmètre) .txt) est écrit en C et utilise la bibliothèque wirepi écrite par Gordon Henderson. Tout d'abord, installez la bibliothèque câblagepi, pour lequel exécuter les commandes suivantes :
développement mkdir
développement de cd
git clone git : //git.drogon.net/wiringPi
câblage cdPi
./construire
Enregistrez le code dans un fichier nommé voltmètre.c et compilez-le avec la commande
gcc -o voltmètre -lrt -lwiringPi voltmètre.c.
Pour exécuter le programme, exécutez la commande suivante :
sudo ./voltmètre.
Pour améliorer la précision des mesures, le programme utilise la moyenne des données. La durée des impulsions carrées d'entrée est rapidement mesurée 64 fois, puis les valeurs obtenues sont additionnées et divisées par 64. À la fin des calculs, un délai d'une seconde est inclus pour effectuer d'autres processus, puis le le cycle de mesure est répété
Plusieurs éléments du circuit du voltmètre affectent également la précision de la mesure. Le condensateur C1 et la résistance R1 définissent les caractéristiques de conversion, il est donc conseillé de choisir un condensateur à film polypropylène et une résistance précise avec une tolérance de 1%. Vous pouvez utiliser une résistance de coupe. L'alimentation 5V du circuit provient du connecteur GPIO, mais la valeur réelle peut être légèrement différente de 5V, il est donc préférable d'utiliser une alimentation séparée et plus précise.
Pour vérification rapide Les circuits peuvent utiliser un diviseur de tension composé de deux résistances. Le schéma de connexion du diviseur est affiché sur le côté gauche du circuit du voltmètre (Figure 12). Si les résistances sont des résistances de précision et que la tension d'alimentation est exactement de 5 V, la tension à la sortie du diviseur est de 0,04950 V. La mesure réelle du logiciel est de 0,04991 V. Pas mal pour un projet aussi simple !
Les diodes Schottky D1 et D2 sont facultatives dans le circuit, mais fortement recommandées, car elles fourniront une certaine protection au microcircuit si une tension en dehors de la plage 0 ... 1 V est accidentellement appliquée à l'entrée.
Entrées sécurisées
Le RPi peut être protégé contre les hautes tensions accidentelles en ajoutant des circuits supplémentaires aux entrées utilisées. Dans certains cas, une alternative très bonne et peu coûteuse au circuit illustré ci-dessous (Figure 15) est un optocoupleur qui peut protéger les entrées RPi des tensions jusqu'à 60 V et gérer l'inversion de polarité. Le BC547B de la figure 14 peut être remplacé par un 2N3904 ou un BC549. La dissipation de puissance de la résistance R1 peut être de 0,25 W à des tensions d'entrée allant jusqu'à 50 V, sinon 0,5 W est préférable.
Le circuit inverse le signal d'entrée, passant à "log. 0 "lorsque la tension d'entrée est supérieure à 2 V.
Connexion à la logique 5 volts
La connexion directe d'appareils avec des sorties logiques 5V aux entrées RPi peut endommager la carte. Dans ce cas, il existe de nombreuses solutions.
Si l'état de la sortie logique 5 volts change relativement lentement, vous pouvez envisager d'utiliser un diviseur résistif à l'entrée RPi, mais cette méthode n'est pas applicable aux circuits rapides. Alors bien plus bonne décision utilisera une puce tampon. Pour des vitesses moyennes (jusqu'à 100 kHz), un circuit avec un MOSFET à canal N ZVN2110A est tout à fait adapté (Figure 16). Ce circuit inverse également le signal d'entrée.
Le transistor montré dans le schéma peut être remplacé par un ZVNL120A ou VN10LP.
Lors de la soudure transistors à effet de champ des précautions de base doivent être suivies. Lors de l'assemblage de l'appareil, installez d'abord la résistance R3, puis retirez le MOSFET de l'emballage de protection et soudez-le dans le circuit. La résistance R3 fournira une certaine protection.
Vitesse de fonctionnement et gigue
L'interrogation de l'état des boutons et le contrôle des LED sont des événements relativement lents, mesurés en dizaines et centaines de millisecondes. Des signaux à vitesse beaucoup plus élevée sont parfois rencontrés. Par exemple, une télécommande de téléviseur émet des impulsions lumineuses infrarouges à une vitesse de 40 000 fois par seconde. Malgré le fait que le processeur principal RPi soit cadencé à 1 GHz, le sous-système d'E/S fonctionnant à cette vitesse n'est pas pris en charge pour un certain nombre de raisons, tant matérielles que logicielles. Nous examinerons certains aspects programmatiques liés au sujet de l'article.
RPi fonctionne sur un système d'exploitation (OS) multitâche Linux. Le système peut prendre le contrôle de votre programme de manière préventive pour effectuer d'autres tâches. Tout cela se passe assez rapidement, il semble donc que la souris fonctionne toujours pendant que votre programme est en cours d'exécution, mais en réalité, le système d'exploitation ne donne à votre programme et au code du pilote de votre souris que de courtes périodes de temps.
Cela n'a généralement pas d'importance, mais lorsque vous devez gérer des événements courts ou de haute précision, cela peut être un problème qui se manifeste (par exemple) par une gigue.
De plus, le choix du langage de programmation est important, car certaines bibliothèques sont mieux adaptées que d'autres. Les codes interprétés et compilés peuvent s'exécuter à des vitesses différentes. En bref, si une synchronisation très précise des événements est requise, vous devrez peut-être écrire un pilote Linux ou utiliser du matériel externe (par exemple, un autre microcontrôleur ou logique et générateur).
Un des bonnes questions important pour plus pleine utilisation Les capacités de RPi sont la rapidité avec laquelle les états logiques des sorties GPIO peuvent être modifiés à l'aide des bibliothèques Python, C et du script de commande décrit ci-dessus.
Pour le savoir, un code a été écrit pour basculer périodiquement l'état logique du port de sortie auquel l'oscilloscope était connecté. Le résultat est présenté dans le tableau 1.
| Tableau 1. | Fréquence de commutation maximale des sorties à en utilisant divers langages de programmation |
||||||||||||||||
|
|||||||||||||||||
Cependant, il est toujours important de se souvenir de la gigue, qui accompagne nécessairement le travail du système d'exploitation Linux. Pour le cas d'une simple commutation de la LED, ce n'est bien entendu pas un problème. La nature de la gigue peut être vue sur un oscilloscope en mode de superposition multicanal lorsqu'il est synchronisé avec un signal commun (Figure 17). Notez que la gigue peut prendre de nombreuses valeurs, même si les signaux sont discrètement espacés de 4 ns (250 MHz) en raison de la conception matérielle du RPi.
Conclusion
Vous avez maintenant vu que l'en-tête GPIO à 40 broches sur les cartes RPi peut être utilisé pour une variété de projets, de la commande de LED aux circuits électroniques pour mesurer des valeurs analogiques. Avec un petit circuit d'adaptation de niveau logique supplémentaire, le RPi peut interagir avec des appareils de 5 volts. Avec Python, il est très facile de contrôler les sorties, tout comme il n'est pas difficile de lire l'état des entrées, et la bibliothèque wirepi simplifie grandement le contrôle pour les programmeurs C.
En termes d'interfaces externes, le Raspberry Pi, comme les autres petits ordinateurs monocarte, ne diffère pas beaucoup d'un PC de bureau ordinaire. La carte RPi a Ports USB pour clavier et souris, port HDMI pour l'affichage. Cependant, du fait que RPi est beaucoup plus compact et moins cher qu'un PC, il devient possible de les utiliser dans différents systèmes et les applications où les PC ou les ordinateurs portables ne sont pas à leur place.
Souvent, il y a un désir de connecter des "choses" non standard à un PC. Par exemple, vous pouvez utiliser un ordinateur pour mesurer les niveaux de luminosité et contrôler automatiquement l'éclairage, ou pour déclencher une alarme lorsqu'un intrus est détecté.
Plus largement, il s'agit du désir d'utiliser un ordinateur pour contrôler des circuits électroniques (sorties) et de recevoir des informations de circuits ou de dispositifs (entrées).
C'est là que l'avantage évident du RPi et des autres SBC vient d'une différence clé entre les ordinateurs monocarte et les PC : les ordinateurs monocarte ont des ports d'E/S à usage général, ce que les gros PC n'ont pas (Figure 1).
Grâce à ces broches (broches), le RPi peut communiquer avec le monde électronique, composé (mais sans s'y limiter) de capteurs, d'indicateurs et d'actionneurs.
Dans cet article, nous examinerons des exemples de schémas pouvant être utilisés "en l'état" (ou modifiés et étendus), ainsi que des exemples de code dans plusieurs langages de programmation.
Connecteur d'extension Raspberry Pi
La figure 2 montre l'emplacement et le brochage du connecteur d'extension Raspberry Pi. Les premières conclusions de tels connecteurs sur cartes de circuits imprimés peut généralement être identifié par le tampon carré sur la couche inférieure de la planche. Le connecteur d'extension RPi à 40 broches fournit des entrées et des sorties numériques compatibles avec niveaux logiques 3.3 B.
La compatibilité avec les niveaux logiques de 3,3 V signifie que le RPi interprétera un niveau d'entrée proche de 0 V comme un « 0 » logique et un niveau supérieur à 2 V comme un « 1 » logique. L'application de tensions supérieures à 3,3 à l'entrée peut endommager le RPi. Ainsi, lorsque le port GPIO est configuré en sortie, le RPi le réglera sur une tension proche de 0 ou 3,3 V.
Dans cet article, nous parlerons des broches marquées sur la figure 2 en rose, blanc, rouge et orange. Le reste des ports est utilisé par des interfaces de données série.
Sorties numériques RPi
Premiers pas : contrôler la LED
L'exemple le plus simple d'utilisation des sorties est de contrôler une LED ou une ampoule, ou une sorte de variateur ou de moteur. Pour convertir le signal de sortie RPi en quelque chose qui contrôlera appareil souhaité, un circuit électronique est généralement requis. Tout ce qui est nécessaire pour une petite LED est une résistance de limitation de courant en série qui protège la LED et la sortie RPi. La résistance de la résistance est choisie dans la plage de 100 Ohm ... 1 kOhm, en fonction de la LED utilisée et de la luminosité requise lorsqu'elle est réglée sur "1" logique en sortie.
La connexion de la LED aux broches GPIO à l'aide d'une carte d'essai sans soudure est illustrée à la figure 3, et le circuit lui-même est illustré à la figure 4. La connexion GND (0V) a été prise à partir de la broche 6 de l'en-tête GPIO, en utilisant le port GPIO22 (broche 15 ) pour piloter la LED. Tout port GPIO marqué en rose sur la figure 2 peut être utilisé.
Une fois toutes les connexions établies et vérifiées, vous pouvez commencer à écrire du code ou un script pour contrôler la LED. Le choix de la langue vous appartient. Un exemple sur langue populaire Python est contenu dans (Liste 1).
Liste 1. Exemple de programme Python pour un simple clignotement de LED.
heure d'importation
importer RPi.GPIO en tant que GPIO
GPIO.setmode (GPIO.BCM)
GPIO.setup (22, GPIO.OUT)
GPIO.sortie (22, vrai)
temps.sommeil (3)
GPIO.cleanup ()
Enregistrez le code dans un fichier nommé led-test.py puis lancez-le en exécutant la commande :
sudo python led-test.py
Un autre programme (Liste 2) montre un exemple de pilotage d'une LED. La LED clignote 10 fois. (Remarque : en Python, contrairement aux autres langages de programmation, il est important d'utiliser l'indentation dans votre code).
Liste 2. Code source Python (la LED clignote 10 fois).
# La LED est connectée au GPIO22 (broche 15)
heure d'importation
importer RPi.GPIO en tant que GPIO
GPIO.setmode (GPIO.BCM)
pour x dans la plage (0,10) :
GPIO.setup (22, GPIO.OUT)
GPIO.sortie (22, vrai)
temps.sommeil (0.05)
GPIO.sortie (22, Faux)
temps.sommeil (0,45)
GPIO.cleanup ()
Une autre façon de contrôler les ports GPIO consiste à utiliser un script Shell (script shell). Cette méthode semble un peu plus compliquée (si vous n'aimez pas écrire des scripts), mais c'est bien juste pour élargir vos horizons, car de nombreux langages de programmation vous permettent souvent d'exécuter des scripts de commandes, et si nécessaire, cela peut être l'un des les moyens rapides de contrôler les ports GPIO à partir d'autres langues. ... De plus, la méthode de la liste 3 est standard sur toutes les plates-formes, votre code peut donc être porté sur d'autres cartes.
Liste 3. Script de commande (Shell script) pour contrôler la LED connectée au GPIO22 du Raspberry Pi.
#! / bin / sh
GPIO_PATH = / sys / classe / gpio
LED_PIN = 22 #GPIO 22 est la broche 15
echo "$ LED_PIN"> $ GPIO_PATH / exporter
echo "out"> $ GPIO_PATH / gpio $ LED_PIN / direction
echo "1"> $ GPIO_PATH / gpio $ LED_PIN / valeur
dormir 1
echo "$ LED_PIN"> $ GPIO_PATH / désexporter
La première ligne du script ressemble à un commentaire, mais elle indique shell Linux quoi faire avec le script au moment de l'exécution, vous ne pouvez donc pas le modifier. Le reste des lignes de script est utilisé pour contrôler le port GPIO correspondant, le configurer en tant que sortie, le mettre à l'état haut et le retarder d'1 seconde. Enfin, le port est libéré pour permettre à d'autres programmes de l'utiliser.
Un autre langage de programmation courant que vous pouvez rencontrer est C, ou son frère aîné C ++. Exemples de code source en C ou C ++ sera donné ci-dessous lorsque nous commencerons à travailler avec des entrées numériques.
Générateur de sons
Suite exemple intéressant l'utilisation de plusieurs ports GPIO pour contrôler le générateur de tonalité peut être utilisée. Le RPi dispose d'une prise casque, mais souvent un simple signal ou une série de signaux de tonalités différentes suffit pour notifier des événements (par exemple, pour un réveil).
Schéma de principe d'un générateur simple signaux sonores fait sur un microcircuit minuterie intégrale L'ICM7555 est illustré à la figure 5. L'assemblage de la maquette est illustré à la figure 6. En faisant varier les valeurs de résistance et de condensateur, vous pouvez créer différentes tonalités et sons.
Le générateur est contrôlé via deux ports RPi GPIO. Une sortie (GPIO22) est utilisée pour activer ou désactiver le son, et l'autre (GPIO27) est utilisée pour basculer entre les deux fréquences de signal alternatives. Si vous le souhaitez, vous pouvez sélectionner d'autres tons en modifiant les valeurs des composants C1, R1 et R2.
Le code source d'un programme Python qui génère plusieurs effets sonores est présenté dans le listing 4. Enregistrez le code dans un fichier nommé ton-test.py puis lancez-le avec la commande
sudo python tone-test.py.
Liste 4. Programme de contrôle du générateur de signaux sonores.
heure d'importation
importer RPi.GPIO en tant que GPIO
GPIO.setmode (GPIO.BCM)
GPIO.setup (22, GPIO.OUT) # Générateur On/Off
GPIO.setup (27, GPIO.OUT) # Changer la clé
GPIO.sortie (22, vrai)
pour x dans la plage (0,5) :
GPIO.sortie (27, vrai)
temps.sommeil (0.1)
GPIO.sortie (27, Faux)
temps.sommeil (0.2)
GPIO.sortie (22, Faux)
temps.sommeil (0,5)
Pour x dans la plage (0,5) :
GPIO.sortie (22, vrai)
temps.sommeil (0.1)
GPIO.sortie (22, Faux)
temps.sommeil (0.2)
GPIO.sortie (27, vrai)
temps.sommeil (0.2)
Pour x dans la plage (0,5) :
GPIO.sortie (22, vrai)
temps.sommeil (0.05)
GPIO.sortie (22, Faux)
temps.sommeil (0.05)
Pour x dans la plage (0,10) :
GPIO.sortie (22, vrai)
temps.sommeil (0.1)
GPIO.sortie (22, Faux)
temps.sommeil (0.1)
temps.sommeil (1)
GPIO.cleanup ()
Notez que le circuit est alimenté en 3,3V (broche 1 de l'en-tête GPIO). N'utilisez cette source que si vous êtes sûr que votre circuit ne consomme pas de courant important. Le rail d'alimentation 3,3 V peut être chargé jusqu'à 50 mA. Si nécessaire, vous pouvez utiliser un régulateur de tension séparé 5 V - 3.3. B et connectez-le à l'alimentation 5V disponible sur la broche 2 de l'en-tête GPIO.
Les circuits évoqués ci-dessus sont alimentés en basse tension et consomment un faible courant, mais il est parfois nécessaire de contrôler des appareils externes suffisamment puissants. Plusieurs manières typiques de résoudre de tels problèmes sont décrites ci-dessous.
Connexion à des dispositifs logiques de 5 volts
L'utilisation du RPi pour contrôler les appareils 5 volts ne nécessite aucun schémas supplémentaires... Les entrées logiques d'un appareil 5V fonctionneront normalement avec les sorties 3,3V des ports RPi.
LED basse consommation
Les LED bleues et blanches de faible puissance peuvent nécessiter des tensions supérieures à 3,3 V. Le moyen le plus simple de contrôler une seule LED consiste à utiliser un commutateur à transistor qui commute le courant de bus de 5 V (Figure 7). La résistance de la résistance R1 est calculée en fonction de caractéristiques techniques LED spécifique, transistor - n'importe quel n-p-n taper.
Appareils puissants
Le moyen le plus simple et le plus courant de contrôler des appareils puissants alimentés par un courant alternatif ou courant continu(mais pas du secteur), est l'utilisation d'un relais avec un interrupteur à transistor (Figure 8). Presque tout fera l'affaire transistors npn en particulier les populaires BC547B, 2N3904 et BC549. De plus, si dispositif externe peut fonctionner à partir de 5 V, vous pouvez alimenter le relais à partir de la broche 2 du connecteur GPIO. Mais dans ce cas, il ne faut pas oublier la consommation actuelle. Sinon, le relais peut être connecté à une source d'alimentation externe, en prenant des précautions contre le contact avec stress externe sur RPi.
Appareils alimentés sur secteur
Des précautions particulières doivent être prises lors de la manipulation de tout circuit ou appareil qui contrôle directement une source d'alimentation CA. La plupart d'entre eux ne répondent tout simplement pas aux normes de sécurité, malgré le fait que certains fabricants prétendent le contraire. Une approche suffisamment sûre consiste à trouver une solution clé en main télécommande un fabricant réputé proposé par un fournisseur réputé qui utilise l'infrarouge ou technologies sans fil... Par exemple, Energenie propose des prises réseau radiocommandées avec un petit module émetteur radio (Figure 9) qui se branche directement sur le connecteur GPIO du RPi, ainsi que des exemples de programmes Python.
Groupe de relais, LED ou autres dispositifs
L'ancien circuit intégré ULN2803 peut être utilisé pour piloter plusieurs LED, relais ou autres appareils alimentés en 12 V et consommant moins de 200 mA. Le microcircuit est un jeu de huit clés basé sur un transistor Darlington. L'une des options de connexion de l'ULN2803 au RPi est illustrée à la Figure 10.
Moteurs à courant continu de faible puissance
La solution optimale pour contrôler les moteurs à courant continu avec RPi est l'utilisation de pilotes spécialisés ou de cartes d'extension, dont certaines peuvent être connectées à des moteurs pas à pas ou à plusieurs moteurs brushless.
5
Lecteur audio Hi-Fi basé sur un mini-ordinateur Raspberry Pi. Partie 1. Alimentation pour Raspberry Pi (5V, 2A)
La chaîne C31, R15 fournit un état zéro du déclencheur lorsque l'alimentation est connectée à un réseau 220 V.
Le délai d'arrêt est nécessaire car après l'arrêt du logiciel, une fois tous les GPIO éteints, la mémoire flash du mini-ordinateur est accessible pendant 2-3 secondes supplémentaires (le système d'exploitation y est installé). C'est un autre petit problème qui doit être pris en compte avec cette alimentation.
Logiciel
Le code du programme émettant le signal "RPi_OFF"#include "stdlib.h" #include "bcm2835.h" #define PIN_12 RPI_V2_GPIO_P1_12 #define PIN_07 RPI_V2_GPIO_P1_07 int init_system (void) (if (! bcm2835_init ()) (! bcm2835_init ()_in) (bcm2835_init ()) (! bcm2835_init ()_in;bcm28_ing (PIN_07, BCM2835_GPIO_FSEL_INPT); // en entrée) int main (int argc, char * argv, char * enpv) (if (! init_system ()) return 1; bcm2835_gpio_write (PIN_12, HIGH); // (Machine chargée // attend de bas niveau (boutons d'arrêt) tandis que (bcm2835_gpio_lev (PIN_07)) retard (50); système ("poweroff"); retour 0;)
Ce code que j'ai inclus dans le fichier principal Logiciel, ici c'est juste comme exemple de travail pour la familiarisation ou la répétition. Ensuite, vous devez ajouter ce programme au démarrage. Pour cela, dans le fichier /etc/rc.localà la fin avant SORTIE 0 ajouter:
# ! / bin / sh …… /programs/autorun.sh & EXIT 0
Le dossier du projet "programs.zip" peut être téléchargé dans la section "Fichiers" en bas de l'article. autorun.sh est notre script exécutable qui lancera le programme. En lui:
# ! / bin / sh ./programs/project_pin_on/bin/pin12on exit 0
Contrôleur PWM DP408P (1M0880) dans une alimentation à découpage
Ici, il convient de prêter attention à la merveilleuse puce de contrôleur PWM DP408P (analogique 1M0880). DP408P fonctionne à 25 KHz, 1M0880 - 64 KHz. Lors de mes tests, tentatives pour faire des transformateurs idéaux, etc., j'ai eu l'impression qu'il est impossible de tuer une puce. Sans circuits d'amortissement, je l'ai allumé, surchargé, elle ne se souciait de rien. Je recommande la puce à ceux qui ont d'abord décidé de construire un convertisseur flyback. Je n'ai jamais brûlé un seul microcircuit. DP408P peut être utilisé dans les anciens moniteurs CRT SAMSUNG. Malheureusement, il n'y a pas de fiche technique pour cela, mais j'avais aussi 1M0880 en stock et, à la suite de la comparaison, il s'est avéré qu'ils sont presque les mêmes.Le microcircuit s'allume dès que sa tension d'alimentation dépasse 15 V. Le microcircuit s'éteint lorsque la tension d'alimentation tombe à 8,5-9 V. C'est-à-dire qu'une fois le microcircuit allumé, la tension ne doit pas nécessairement être de 15 V ou plus. , mais c'est souhaitable.
Si la tension d'alimentation dépasse 27 V (25 V pour 1M0880), la protection se déclenche et le microcircuit est éteint. La prochaine tentative de mise sous tension n'aura lieu qu'après avoir coupé l'alimentation, si la tension d'alimentation chute en dessous de 8,5-9 V et dépasse à nouveau 15 V.
Lors du test, par exemple, d'un transformateur fraîchement enroulé, il est pratique d'alimenter d'abord le PWM à partir d'un unité de laboratoire nutrition. Nous devons nous souvenir de la séquence d'alimentation en tension: d'abord, 308 V haut, puis 15 V.
Un redresseur D5 séparé est utilisé pour le démarrage initial. A cause de R6 et C18, la tension d'alimentation atteint 15 V peu après l'apparition de 308 V. Le PWM démarre en consommant environ 20 mA. Et si vous ne connectez pas l'enroulement d'auto-alimentation, C18 est déchargé et le microcircuit est éteint. Ensuite, le condensateur sera à nouveau chargé et le processus de démarrage sera répété à nouveau.
À la fin, nous connectons l'enroulement d'auto-alimentation. Il est nécessaire d'enrouler l'enroulement de manière à ce que la tension de 15-17 V soit à la charge minimale - charge à vide (dans mon cas, environ 0,25 W).
Dans ce bloc d'alimentation, je n'ai pas utilisé de transformateurs maison, j'ai utilisé un transformateur d'un adaptateur AC/DC foudroyé comme celui-ci :
Figure 4. Donneurs de transformateurs d'impulsions
Cet adaptateur était alimenté par une sorte de routeur ou de commutateur, je ne me souviens pas déjà, avec les paramètres déclarés 5V 2A MAX.
Le truc, c'est que je n'ai pas réussi à enrouler le transformateur mieux que celui-ci. Comme je ne suis pas sorti, les émissions lorsque le transistor de puissance du microcircuit était fermé étaient plus importantes qu'avec ce transformateur chinois. Bien, OK!
Avec l'oeil armé
Voyons ce qui se passe:
Figure 5... Oscillogramme (pin-1 IC1), charge 2,1A (drain du transistor de puissance).
Figure 6... Oscillogramme (broche-1 IC1), charge 2,1 A. (Coupe en rafale par amortisseur)
Figure 7. Oscillogramme (pin-1 IC1), charge 50 mA. (Drain du transistor de puissance).
Figure 8. Oscillogramme (pin-1 IC1), charge 2,1 A. (38 nS à 300 V).
Par température : résistance d'amortissement avec une charge de 2,1 A = 50 ° C, DP408 = 37 ° C, transformateur = 40 ° C. La température a été mesurée avec un thermomètre sans contact pour bébés.
Et une autre photo de la construction
Figure 9. Alimentation - vue du côté gauche.
Figure 10. Alimentation - vue de dessous.
Figure 11. Planche A2.
Sur l'image 11 planche A2. Trois LED de couleurs différentes et un bouton en dessous. Dans le boîtier, le bouton a un verre (voir vidéo), donc les LED extrêmes sont courbées pour qu'elles brillent vers le centre. La carte est faite par analogie avec la carte native du magnétoscope (j'ai utilisé le boitier du magnétoscope).
Vidéo
Le système n'est pas optimisé, donc "Malina" prend beaucoup de temps à charger et le lecteur flash avec le système d'exploitation est lent. Ensuite, je vais insérer le vraiNous continuons d'envisager l'utilisation d'un ordinateur Raspberry Pi pour la domotique. Comme vous vous en souvenez, dans les versions précédentes, nous avons reçu des informations générales sur le Raspberry Pi, appris comment installer et configurer le système d'exploitation. framboise, s'est familiarisé avec le cadre WebIOPi et ses capacités à travailler avec les ports GPIO, en particulier, comment contrôler les E/S discrètes et comment fonctionne le port série UART.
Aujourd'hui, je vais essayer de vous familiariser avec le schéma structurel général du système domotique prévu, qui sera créé à l'aide de Tarte aux framboises. (Fig. 1).
Figure. une
Le système domotique se compose de serveur central lié par interface RS485 avec installé dans chaque pièce contrôleurs, et tous sont connectés aux contrôleurs périphériques (divers appareils gestion, contrôle, régulation, protection). L'avantage d'une telle architecture réseau est qu'il n'est pas nécessaire de tirer des fils de chaque appareil au serveur, mais il suffit de connecter les contrôleurs auxquels ils sont connectés avec deux paires de fils - une paire est alimentée, et l'autre est utilisé pour l'interface RS 485. la logique de travail est conçue de telle manière que la défaillance d'un contrôleur ou même d'un serveur central ne devrait pas affecter les performances du reste du système. En d'autres termes, l'architecture du système domotique doit être distribué et décentralisé... Cette architecture rappelle celle largement utilisée dans les projets commerciaux " Maison intelligente"Pneu Bus intelligent.
En tant que serveur central du système domotique, il est utilisé Tarte aux framboises ... il est installéserveur Webà travers lequel l'utilisateur à partir de n'importe quel appareil de communication (smartphone, ordinateur portable, tablette) via le navigateur peut recevoir des informations sur tous les processus se produisant dans la maison et, en conséquence, les contrôler. Accès à la toile le serveur de saisie du login et du mot de passe peut être obtenu à la fois depuis le domicile réseau local et depuis Internet viaWi -routeur Fi.
Vers le port sérieUART Tarte aux framboises via l'appareil correspondant via l'interface Connexion RS 485 contrôleursqui ont l'ensemble requis d'entrées/sorties. En plus de RS 485 se connecte modem GSMaccéder au système viacellulaire ou alors réseau téléphonique fixeau cas où il n'y aurait aucun moyen d'accéder à Internet à l'endroit où se trouve l'utilisateur. L'accès dans ce cas s'effectue également en saisissant un mot de passe.
Comme indiqué précédemment, le Raspberry Pi possède ses propres ports. GPIO qui peut être utilisé pour diverses fonctions. Nous utilisons UART GPIO pour organiser l'interface RS 485, et le reste des ports est toujours libre. Par conséquent, il est assez logique qu'en plus de connecter des capteurs et des actionneurs à des contrôleurs, certains éléments d'un système domotique puissent être connectés directement aux ports GPIO du Raspberry Pi via dispositif tamponà condition que de tels éléments n'aient pas besoin de poser de longues communications. Par exemple, il peut s'agir d'un capteur de pression atmosphérique ou d'un capteur de contrôle de température qui contrôle le refroidissement du Raspberry Pi lui-même. Dans le schéma fonctionnel, la connexion directe aux ports du Raspberry Pi est illustrée via le module tampon. GPIO.
Puisque lors de la première étape de la mise en œuvre pratique de notre système, nous organiserons la connexion du port UART Raspberry Pi au contrôleur via l'interface Rs 485, ainsi que de connecter des appareils exécutifs directement aux ports d'entrée / sortie GPIO , je suggère de terminer d'abord l'installation et la configuration Tarte aux framboises pour accomplir ces tâches.
Donc, si vous lisez les trois parties précédentes de la revue, vous avez terminé l'installation du framework WebIOPi, a essayé de contrôler les ports, vérifié le fonctionnement de l'UART en mode d'échange bidirectionnel via le programme de terminal, puis il reste très peu de choses à faire pour terminer les réglages.
On va dans le fichier de configuration avec la commande :
sudo nano / etc /webiopi /configuration
et définissez les paramètres suivants [ GPIO](fig. 2)
4 = SORTIE 0
7 = SORTIE 0
8 = SORTIE 0
25 = SORTIE 0
24 = SORTIE 0
Figure. 2
Au chapitre [ HTTPServeurConfiguration]vous devez écrire la ligne :
doc-root = / home / pi / myproject / html
Ce sera le chemin d'accès au dossier que nous créerons ensuite pour stocker la page de l'interface Web indice.html... Bien sûr, il était possible de créer ce dossier à un autre endroit, après avoir enregistré le chemin approprié, mais afin d'éviter toute confusion et problèmes à l'avenir, restons-en à l'uniformité (Fig. 3)
exportation gpio = 4, 7, 8, 25, 24
gpio-post-valeur = vrai
gpio-post-fonction = vrai
mappage de périphérique = vrai
Figure. quatre
Dans le fichier de configuration, les paramètres sont terminés. Nous les sauvegardons en appuyant sur le raccourci clavierCtrl et O, puis clique Entreret laisse la commandeCtrl et X.
Créer sur disque Tarte aux framboises dossiers pour stocker notre projet. Pour ce faire, et effectivement pour travailler avec des fichiers sur le disque Raspberry Pi, vous pouvez utiliser le gestionnaire de fichiersqui a été mentionné. L'imbrication des dossiers créés doit être la suivante :
/ home / pi / monprojet / html(fig. 5)
Figure. cinq
Pour vérifier l'exactitude des opérations effectuées, décompressez l'archive du fichier de test dans le dossier html... Le fichier doit y apparaître indice.html... Entrer adresse réseau Raspberry Pi, login et mot de passe ( webiopi / framboise). Redémarrez WebIOPi avec la commande :
sudo /etc/init.d/webiopi redémarrer
Après cela, vous devriez voir une interface Web de test (Fig. 6). En utilisant cette interface, vous pouvez contrôler les sorties GPIO 4 , 7 , 8 , 24 , 25 en cliquant sur le bouton correspondant. Haut niveau la sortie est affichée en orange, faible - en noir. Après chaque clic sur le bouton, l'état de la sortie est inversé. Pour un contrôle visuel des commandes exécutées, des LED peuvent être connectées à ces sorties via des résistances de limitation de courant. 300 - 470 Ohm.
Figure. 6
Si vous réussissez, les paramètres sont corrects. Dans le prochain numéro de notre revue, nous passerons à la mise en œuvre pratique dans le matériel du premier étage du système domotique.
