[PYTHON] J'ai essayé d'utiliser la console Pi I / F du kit de démarrage Raspeye IoT de Mechatrax "anyPi"
introduction
Dans cet article, j'utiliserai l'équipement dont je dispose à l'exception de la PiConsole I / F, mais la PiConsole I / F est un élément fourni exclusivement pour le kit de démarrage Raspeye IoT de Mechatrax "[anyPi] [anyPi URL]". C'est vrai, il semble qu'il ne soit pas vendu séparément. J'apprécierais votre attention.
"[AnyPi] [anyPi URL]" est un kit de démarrage pour l'IoT qui vous permet de connecter Raspai à Internet en 3 minutes dans presque toutes les régions du Japon, même si vous ne disposez pas d'un environnement de connexion Internet. Je vais vous présenter.
[
](http: / /www.youtube.com/watch?v=NhrIYOyh4wc)
(Le lien est une vidéo.)
Les articles suivants sont basés sur l'hypothèse qu'ils ont été assemblés selon les sites [anyPi] et [anyPi URL].
Équipement utilisé
L'équipement suivant est utilisé dans cet article. Aucune soudure ou traitement n'est requis.
- PiConsole I/F --Razpai 3
- 3GPI -Câble USB mini B (pour série) --Adaptateur pour courant alternatif (↑↑↑ Jusqu'à présent, ce qui est inclus dans [anyPi] [anyPi URL]) (↓↓↓ Les éléments suivants ne sont pas inclus dans [anyPi] [anyPi URL]: Peu importe si certains échantillons ne peuvent pas être exécutés sauf pour PC)
--PC (machine Windows)
- Capteur de température de connexion I2C (http://akizukidenshi.com/catalog/g/gM-06675/)
- PiCamera
- planche à pain
- Câble de sauteur montant approprié
Puisqu'il a un connecteur d'en-tête qui peut être directement connecté à la tarte à la râpe, il s'agit d'une structure à trois étages avec 3GPI avec un connecteur d'en-tête similaire. Je me suis souvenu de PC / 104 et GP-IB (HP-IB).
Le script créé comme exemple est téléchargé sur le github suivant.
https://github.com/syasuder/piconsole-sample
Si la copie est problématique, veuillez utiliser le clone, etc.
Connectez-vous à Razpai avec une connexion série à partir d'un ordinateur personnel (système Win)
(Si vous vous connectez via un réseau local câblé / sans fil et que vous utilisez l'émulateur de terminal via ssh, ignorez cette section et passez aux principes de base.)
Le PiConsole I / F dispose d'un circuit de conversion USB / série (UART). Vous pouvez accéder à la série de Raspeye en le connectant simplement à votre PC avec un câble USB mini B.
De plus, le numéro de série est défini sur tty par défaut, vous n'avez donc rien à faire simplement en le connectant.
Vous pouvez dire que vous n'avez rien à faire en lançant l'émulateur de terminal (TeraTerm est utilisé ici) puis en allumant Raspeye. 115,200bps, 8 bits de données, 1 bit d'arrêt, pas de parité.
・ Sortie série pendant le démarrage de la tarte à la râpe
Cependant, lorsque vous vous connectez à la PiConsole I / F via USB pour la première fois, l'installation du pilote prendra un certain temps, vous ne pourrez donc peut-être pas voir ce journal de démarrage. S'il s'agissait de Windows 8.1 à portée de main, il a été reconnu par le pilote fourni avec le système d'exploitation, mais cela a quand même pris des dizaines de secondes.
・ Port COM reconnu
Par conséquent, l'écran de l'émulateur de terminal que vous voyez pour la première fois peut ressembler à ce qui suit.
・ Il fait noir lorsque vous vous connectez pour la première fois
Dans ce cas, appuyez sur la touche Entrée. Vous devriez voir une invite de connexion.
・ La connexion est possible
Essayez de vous connecter en tant qu'utilisateur par défaut de Raspeye.
Nom d'utilisateur: pi Mot de passe: framboise
Sur l'émulateur de terminal
Raspbian GNU/Linux 8 raspberrypi ttyAMA0
raspberrypi login: pi
Password:
Last login: Mon Feb 8 16:03:40 JST 2016 on ttyAMA0
Linux raspberrypi 4.1.17-v7+ #834 SMP Mon Feb 1 15:17:54 GMT 2016 armv7l
The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.
Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Si vous avez l'habitude de vous connecter avec ssh via LAN, vous pouvez être dérouté par la borne de connexion série. Ici, seules les deux mesures suivantes sont prises. (Référence: [Qiita: Communication série avec RaspberryPi3] URL pour la communication série avec RaspberryPi3)
- Taille du terminal
- Prend en charge 256 couleurs
Commencez par vérifier le problème.
・ La taille du terminal est décevante
Sur l'émulateur de terminal
pi@raspberrypi:~$ stty rows 36; stty columns 128
pi@raspberrypi:~$ export TERM=xterm-256color; source ~/.bashrc
・ Spacieux et 256 couleurs
Modifiez le nombre de lignes et de chiffres en fonction de votre environnement.
Après cela, il peut être utilisé de la même manière qu'un terminal connecté avec ssh, mais il est préférable de mettre à jour ou d'ajouter des packages, etc. via un LAN filaire / sans fil. Si vous utilisez un environnement LAN compatible DHCP, branchez simplement le câble LAN filaire.
Je pense que l'un des avantages de la connexion en série est que l'émulateur de terminal peut être laissé ouvert même lorsque l'alimentation de Raspeye est activée et désactivée. En fonction de la fonctionnalité de l'émulateur de terminal, trouvez-vous que la reconnexion via ssh est un problème?
Édition de base
De là, nous vérifierons le fonctionnement de chaque fonction installée dans la PiConsole I / F individuellement.
GPIO
Commencez par vérifier le fonctionnement des boutons, des LED et du buzzer.
Utilisez la commande gpio. La commande gpio peut être utilisée sans l'installer, mais il semble que l'image 3GPI 3gpi-20160208-2gb.img ne prend pas en charge Raspeye 3 comme indiqué ci-dessous.
Sur l'émulateur de terminal
pi@raspberrypi:~ $ gpio readall
Oops - unable to determine board type... model: 8
・ ・ ・
pi@raspberrypi:~ $ gpio -v
gpio version: 2.31
Copyright (c) 2012-2015 Gordon Henderson
This is free software with ABSOLUTELY NO WARRANTY.
For details type: gpio -warranty
Raspberry Pi Details:
Type: Unknown08, Revision: 02, Memory: 1024MB, Maker: Sony
Device tree is enabled.
This Raspberry Pi supports user-level GPIO access.
-> See the man-page for more details
Il dit "Type: Inconnu 08". Par conséquent, mettez à jour le package de câblage.
Sur l'émulateur de terminal
pi@raspberrypi:~ $ sudo apt-get install wiringpi
・ ・ ・
pi@raspberrypi:~ $ gpio -v
gpio version: 2.32
Copyright (c) 2012-2015 Gordon Henderson
This is free software with ABSOLUTELY NO WARRANTY.
For details type: gpio -warranty
Raspberry Pi Details:
Type: Pi 3, Revision: 02, Memory: 1024MB, Maker: Sony
* Device tree is enabled.
* This Raspberry Pi supports user-level GPIO access.
-> See the man-page for more details
-> ie. export WIRINGPI_GPIOMEM=1
Reconnu comme "Type: Pi 3". Il existe différents paramètres dans gpio de Raspeye, vérifiez d'abord les paramètres d'origine.
Sur l'émulateur de terminal
pi@raspberrypi:~ $ gpio readall
+-----+-----+---------+------+---+---Pi 3---+---+------+---------+-----+-----+
| BCM | wPi | Name | Mode | V | Physical | V | Mode | Name | wPi | BCM |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
| | | 3.3v | | | 1 || 2 | | | 5v | | |
| 2 | 8 | SDA.1 | ALT0 | 1 | 3 || 4 | | | 5V | | |
| 3 | 9 | SCL.1 | ALT0 | 1 | 5 || 6 | | | 0v | | |
| 4 | 7 | GPIO. 7 | IN | 1 | 7 || 8 | 1 | ALT0 | TxD | 15 | 14 |
| | | 0v | | | 9 || 10 | 1 | ALT0 | RxD | 16 | 15 |
| 17 | 0 | GPIO. 0 | OUT | 0 | 11 || 12 | 0 | IN | GPIO. 1 | 1 | 18 |
| 27 | 2 | GPIO. 2 | OUT | 0 | 13 || 14 | | | 0v | | |
| 22 | 3 | GPIO. 3 | IN | 1 | 15 || 16 | 0 | IN | GPIO. 4 | 4 | 23 |
| | | 3.3v | | | 17 || 18 | 0 | IN | GPIO. 5 | 5 | 24 |
| 10 | 12 | MOSI | IN | 0 | 19 || 20 | | | 0v | | |
| 9 | 13 | MISO | IN | 0 | 21 || 22 | 0 | IN | GPIO. 6 | 6 | 25 |
| 11 | 14 | SCLK | IN | 0 | 23 || 24 | 1 | IN | CE0 | 10 | 8 |
| | | 0v | | | 25 || 26 | 1 | IN | CE1 | 11 | 7 |
| 0 | 30 | SDA.0 | IN | 1 | 27 || 28 | 1 | IN | SCL.0 | 31 | 1 |
| 5 | 21 | GPIO.21 | IN | 1 | 29 || 30 | | | 0v | | |
| 6 | 22 | GPIO.22 | IN | 1 | 31 || 32 | 0 | IN | GPIO.26 | 26 | 12 |
| 13 | 23 | GPIO.23 | IN | 0 | 33 || 34 | | | 0v | | |
| 19 | 24 | GPIO.24 | IN | 1 | 35 || 36 | 1 | IN | GPIO.27 | 27 | 16 |
| 26 | 25 | GPIO.25 | IN | 0 | 37 || 38 | 0 | IN | GPIO.28 | 28 | 20 |
| | | 0v | | | 39 || 40 | 0 | IN | GPIO.29 | 29 | 21 |
+-----+-----+---------+------+---+----++----+---+------+---------+-----+-----+
| BCM | wPi | Name | Mode | V | Physical | V | Mode | Name | wPi | BCM |
+-----+-----+---------+------+---+---Pi 3---+---+------+---------+-----+-----+
Laissez-moi vous expliquer un peu le tableau ci-dessus. La colonne Physique correspond au numéro de broche de la broche d'en-tête Rasppie. Dans cet article, le numéro gpio utilise le soi-disant «numéro GPIO», donc dans le tableau ci-dessus, il correspond au numéro inscrit dans la colonne «BCM». Le numéro GPIO est également utilisé dans le script. Par exemple, GPIO20 est sur la broche 38 de la broche d'en-tête.
Maintenant que vous savez comment vérifier l'association des numéros GPIO, commençons par L Pika. Allumez la LED.
Sur l'émulateur de terminal
pi@raspberrypi:~ $ gpio -g mode 20 out
pi@raspberrypi:~ $ gpio -g mode 21 out
pi@raspberrypi:~ $ gpio -g write 20 1
(La LED rouge s'allume)
pi@raspberrypi:~ $ gpio -g write 21 1
(La LED rouge / jaune s'allume)
pi@raspberrypi:~ $ gpio -g write 20 0
pi@raspberrypi:~ $ gpio -g write 21 0
・ État de l'éclairage LED rouge / jaune
Vérifiez l'IO de l'I / F PiConsole avant le reste de la vérification.
Tableau 1: GPIO utilisé avec PiConsole I / F
| Nom GPIO | Code PIN | Réglage | une fonction |
|---|---|---|---|
| GPIO20 | 38 | production | LED1(rouge) |
| GPIO21 | 40 | production | LED2(Jaune) |
| GPIO25 | 22 | production | avertisseur sonore |
| GPIO19 | 35 | contribution | SW1(blanc) |
| GPIO16 | 36 | contribution | SW2(noir) |
Ce qui suit ne fait pas fonctionner les broches directement.
Tableau 2: GPIO utilisé avec PiConsole I / F
| Nom GPIO | Code PIN | une fonction |
|---|---|---|
| GPIO2 | 3 | LCD SDA |
| GPIO3 | 5 | LCD SCL |
| GPIO14 | 8 | Conversion USB232(TXD) |
| GPIO15 | 10 | Conversion USB232(RXD) |
Nous allons continuer. C'est un buzzer. Cela fait un bruit assez fort.
Sur l'émulateur de terminal
pi@raspberrypi:~ $ gpio -g mode 25 out
pi@raspberrypi:~ $ gpio -g write 25 1
pi@raspberrypi:~ $ gpio -g write 25 0
Vient ensuite SW. SW devient «0» lorsqu'il est enfoncé. (Logique dite négative)
Sur l'émulateur de terminal
pi@raspberrypi:~ $ gpio -g read 19
1
pi@raspberrypi:~ $ gpio -g read 19
0
(État enfoncé du bouton blanc SW1)
pi@raspberrypi:~ $ gpio -g read 16
1
pi@raspberrypi:~ $ gpio -g read 16
0
(État enfoncé du bouton noir SW2)
C'est tout pour vérifier GPIO.
I2C
Le module à cristaux liquides est connecté à la tarte aux râpes via le bus I2C. Pour utiliser le bus I2C, I2C doit être activé dans raspi-config.
raspi-config>Advanced Options>I2C
Installez l'outil pour vérifier le fonctionnement.
Sur l'émulateur de terminal
pi@raspberrypi:~ $ sudo apt-get install i2c-tools
Étant donné que I2C est un bus, vous pouvez connecter plusieurs appareils à la suite. Cela signifie que vous devez identifier l'appareil. Vérifiez l'état de reconnaissance de l'appareil avec l'outil que vous avez installé immédiatement.
Sur l'émulateur de terminal
pi@raspberrypi:~ $ sudo i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- 3e --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
Ce «3e» est l'adresse du module à cristaux liquides. Pour vérifier le fonctionnement du module à cristaux liquides, utilisez le script "[Qiita: écran LCD AQM0802A / ST7032i utilisant WiringPi-Python] URL de l'écran LCD AQM0802A / ST7032i utilisant WiringPi-Python". J'ai besoin du module python de câblagepi, alors installez-le avec pip3.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ sudo pip3 install wiringpi
Modifiez la ligne suivante du script dans l'article Qiita ci-dessus.
import wiringpi2 as wp
Où est-ce que c'est
import wiringpi as wp
Changer en.
Une fois exécuté, le ticker sera affiché sur l'écran LCD.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ python3 st7032i.py
C'est tout pour vérifier le fonctionnement d'I2C.
Exemple 1: la LED s'allume lorsque le bouton est enfoncé
Écrivons un simple script python en utilisant câblagepi. Le premier est la coopération entre les boutons et les LED.
・ Exemple que la LED s'allume lorsque le bouton est enfoncé
b1.py
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import wiringpi as wp
PIN_SW1_WHITE = 19
PIN_SW2_BLACK = 16
PIN_LED1_RED = 20
PIN_LED2_YELLOW = 21
PIN_BUZZER = 25
if __name__ == '__main__':
wp.wiringPiSetupGpio()
wp.pinMode(20,1)
wp.pinMode(21,1)
wp.pinMode(25,1)
while True:
sw1 = wp.digitalRead(PIN_SW1_WHITE)
sw2 = wp.digitalRead(PIN_SW2_BLACK)
#Puisque sw est une logique négative, inverser et régler sur la sortie LED
wp.digitalWrite(PIN_LED1_RED, ~sw1 & 1)
wp.digitalWrite(PIN_LED2_YELLOW, ~sw2 & 1)
wp.delay(250)
Exécutez comme suit.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ sudo python3 b1.py
Appuyez sur SW1 (blanc) pour allumer LED1 (rouge), et appuyez sur SW2 (noir) pour allumer LED2 (jaune).
Exemple 2: appuyez et maintenez le bouton pour redémarrer / arrêter
Vous pouvez travailler avec tout ce que vous pouvez faire avec un script python. Dans cet exemple, la détection de SW press est décrite dans un style d'interruption avec câblagePiISR.
b2.py
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import wiringpi as wp
PIN_SW1_WHITE = 19
PIN_SW2_BLACK = 16
PIN_LED1_RED = 20
PIN_LED2_YELLOW = 21
PIN_BUZZER = 25
import os
#Appuyez et maintenez pendant 1 seconde ou plus pour retourner True
def is_long_pushed(pin):
count = 0;
while count < 4:
state = wp.digitalRead(pin)
if state != 0:
return False
count = count + 1
wp.delay(250)
return True
#Rappel avec sw1 enfoncé
def sw1_callback():
if is_long_pushed(PIN_SW1_WHITE):
print("reboot")
os.system("sudo reboot")
else:
print("reboot cancel")
#Rappel avec sw2 enfoncé
def sw2_callback():
if is_long_pushed(PIN_SW2_BLACK):
print("shutdown")
os.system("sudo poweroff")
else:
print("shutdown cancel")
if __name__ == '__main__':
wp.wiringPiSetupGpio()
wp.pinMode(20,1)
wp.pinMode(21,1)
wp.pinMode(25,1)
#Déclenchement de chute car c'est une logique négative
wp.wiringPiISR(PIN_SW1_WHITE, wp.GPIO.INT_EDGE_FALLING, sw1_callback)
wp.wiringPiISR(PIN_SW2_BLACK, wp.GPIO.INT_EDGE_FALLING, sw2_callback)
while True:
wp.delay(250)
Je le ferai.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ sudo python3 b1.py
(SW1(blanc)Appui long)
reboot
[ 3388.810715] reboot: Restarting system
・ ・ ・
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ sudo python3 b1.py
(SW2(noir)Appui long)
shutdown
[ 123.228773] reboot: Power down
・ ・ ・
Exemple 3: Appuyez sur le bouton pour afficher l'adresse IP actuelle sur l'écran LCD
C'est simple car la classe utilisée pour vérifier le fonctionnement du module à cristaux liquides est importée et utilisée. Enregistrez-le sous st7032i.py.
b3.py
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import wiringpi as wp
PIN_SW1_WHITE = 19
PIN_SW2_BLACK = 16
PIN_LED1_RED = 20
PIN_LED2_YELLOW = 21
PIN_BUZZER = 25
import sys, socket, struct
from fcntl import ioctl
SIOCGIFADDR = 0x8915
from st7032i import St7032iLCD as LCD
I2C_ADDR_LCD = 0x3e
def get_ip(interface):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
ifreq = struct.pack(b'16s16x', interface)
ifaddr = ioctl(s.fileno(), SIOCGIFADDR, ifreq)
finally:
s.close()
_, sa_family, port, in_addr = struct.unpack(b'16sHH4s8x', ifaddr)
return (socket.inet_ntoa(in_addr))
if __name__ == '__main__':
wp.wiringPiSetupGpio()
wp.pinMode(20,1)
wp.pinMode(21,1)
wp.pinMode(25,1)
while True:
sw1 = wp.digitalRead(PIN_SW1_WHITE)
sw2 = wp.digitalRead(PIN_SW2_BLACK)
if sw1 == 0:
ip_addr_eth0 = get_ip(b'eth0')
lcd = LCD(I2C_ADDR_LCD)
lcd.clear()
wp.delay(500)
lcd.set_cursor(0, 0)
lcd.print(ip_addr_eth0)
wp.delay(250)
Je vais essayer.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ sudo python3 b3.py
Si vous appuyez sur le commutateur noir, l'adresse de l'interface eth0 sera affichée sur l'écran LCD.
・ Affichage de l'adresse IP
Si vous changez la partie'eth0 'du script en'ppp0', l'adresse 3G ppp sera affichée.
Exemple 4: Appuyez sur le bouton pour afficher la température actuelle sur l'écran LCD
(Si vous ne disposez pas d'un module de capteur de température connecté I2C, ignorez cet élément.)
Câblez en vous référant au matériau du module du capteur de température pour la connexion I2C (http://akizukidenshi.com/catalog/g/gM-06675/). C'est facile car il n'y en a que quatre.
・ Table de correspondance des broches (le numéro de code PIN sur le côté du module est temporaire)
| Côté module capteur de température | (Code PIN) | Code PIN | Côté tarte Razz |
|---|---|---|---|
| VDD | (1) | 1 | 3.3v |
| SDA | (3) | 3 | SDA |
| SCL | (2) | 5 | SCL |
| GND | (4) | 6 | GND |
-Schéma de câblage du module de capteur de température
Dans l'image ci-dessus, il s'agit d'une tarte à la râpe, mais le câblage réel est effectué sur la broche d'en-tête du PiConsole I / F.
À ce stade, l'un est une broche de cavalier mâle et l'autre est une broche de cavalier femelle, mais si les deux ont des broches de cavalier femelles, aucune carte d'expérimentation n'est requise. Cela peut être plus pratique si vous expérimentez avec un capteur de température.
Vérifiez d'abord s'il est reconnu par le bus I2C.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ gpio i2cdetect
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- 3e --
40: -- -- -- -- -- -- -- -- 48 -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- -- --
«48» est l'adresse du module du capteur de température. Ici, je l'ai confirmé avec la commande gpio. Il semble qu'il soit reconnu normalement.
Une préparation supplémentaire est nécessaire. Le module de capteur de température utilisé ici peut mesurer avec la résolution originale de 16 bits avec un petit réglage. Reportez-vous à «[Activer la condition de démarrage répété I2C sur Raspberry Pi] URL pour activer la condition de démarrage répété I2C sur Raspberry Pi».
shell-session:/etc/modprobe.d/i2c.conf
options i2c_bcm2708 combined=1
Après avoir créé le fichier ci-dessus, redémarrez Raspai.
Ensuite, c'est un script. Vérifiez d'abord le fonctionnement du module de capteur de température seul.
adt7410.py
#!/usr/bin/python
# -*- coding: utf-8 -*-
import wiringpi as wp
import time
I2C_ADDR_THERMO = 0x48
#2 conversion de représentation complémentaire
# http://stackoverflow.com/questions/1604464/twos-complement-in-python
def twos_comp(val, bits):
"""compute the 2's compliment of int value val"""
if (val & (1 << (bits - 1))) != 0: # if sign bit is set e.g., 8bit: 128-255
val = val - (1 << bits) # compute negative value
return val # return positive value as is
class ADT7410:
"""
ADT7410 thermometer control class
"""
def __init__(self, i2c_addr = I2C_ADDR_THERMO):
self.i2c = wp.I2C()
self.fd = self.i2c.setup(i2c_addr)
#Réglez la résolution sur 16 bits
self._write(0x003, 0x80)
def _write(self, offset, data):
self.i2c.writeReg8(self.fd, offset, data)
def _read(self, offset):
datum = self.i2c.readReg8(self.fd, offset)
return datum
def read_temp(self):
msb = self._read(0x00)
lsb = self._read(0x01)
temp = (msb << 8 | lsb) # MSB, LSB
temp = twos_comp(temp, 16)
return temp
if __name__ == '__main__':
thermo = ADT7410(I2C_ADDR_THERMO)
while True:
temp = thermo.read_temp()
print("Temperature:%6.2f" % (temp / 128.0))
time.sleep(1)
Le script ci-dessus fonctionne par lui-même, alors exécutez-le pour vérifier l'opération.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ python3 adt7410.py
Temperature: 27.98
Temperature: 28.02
Temperature: 27.98
・ ・ ・
La température est affichée toutes les secondes, donc c'est OK si une valeur proche de la température ambiante est affichée. Assurez-vous également que la température change en touchant le CI avec votre doigt.
Vous pouvez maintenant utiliser le module du capteur de température. Le script pour "Si vous appuyez sur le bouton" est le suivant.
b4.py
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import wiringpi as wp
PIN_SW1_WHITE = 19
PIN_SW2_BLACK = 16
PIN_LED1_RED = 20
PIN_LED2_YELLOW = 21
PIN_BUZZER = 25
from st7032i import St7032iLCD as LCD
I2C_ADDR_LCD = 0x3e
from adt7410 import ADT7410 as THERMO
I2C_ADDR_THERMO = 0x48
if __name__ == '__main__':
wp.wiringPiSetupGpio()
wp.pinMode(20,1)
wp.pinMode(21,1)
wp.pinMode(25,1)
lcd = LCD(I2C_ADDR_LCD)
thermo = THERMO(I2C_ADDR_THERMO)
while True:
sw1 = wp.digitalRead(PIN_SW1_WHITE)
sw2 = wp.digitalRead(PIN_SW2_BLACK)
if sw2 == 0:
temp = thermo.read_temp() / 128.0
lcd.clear()
wp.delay(250)
lcd.set_cursor(0, 0)
lcd.print("{0:6.2f}".format(temp))
wp.delay(250)
Exécutez et appuyez sur SW2 (noir) pour afficher la température sur l'écran à cristaux liquides.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ sudo python3 b4.py
Exemple 5: le buzzer retentit lorsque la valeur du capteur de température dépasse le seuil
(Si vous ne disposez pas d'un module de capteur de température connecté I2C, ignorez cet élément.)
b5.py
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import wiringpi as wp
PIN_SW1_WHITE = 19
PIN_SW2_BLACK = 16
PIN_LED1_RED = 20
PIN_LED2_YELLOW = 21
PIN_BUZZER = 25
from adt7410 import ADT7410 as THERMO
I2C_ADDR_THERMO = 0x48
if __name__ == '__main__':
wp.wiringPiSetupGpio()
wp.pinMode(20,1)
wp.pinMode(21,1)
wp.pinMode(25,1)
thermo = THERMO(I2C_ADDR_THERMO)
t1 = 32.0 #Seuil 1
print("threshold t1:{0:6.2f}".format(t1))
while True:
sw1 = wp.digitalRead(PIN_SW1_WHITE)
sw2 = wp.digitalRead(PIN_SW2_BLACK)
temp = thermo.read_temp() / 128.0
print("{0:6.2f}".format(temp))
if temp > t1:
print("over t1")
wp.digitalWrite(PIN_BUZZER, 1)
else:
wp.digitalWrite(PIN_BUZZER, 0)
wp.delay(500)
Faisons le. Le seuil étant réglé à 32 ° C, l'avertisseur retentit dès que vous le touchez avec votre doigt. Le buzzer s'arrêtera lorsque vous relâcherez votre doigt et tomberez sous le seuil.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ sudo python3 b5.py
threshold t1: 32.00
30.59
30.50
30.49
30.99
31.42
31.74
31.97
32.15
over t1
32.28
over t1
32.40
over t1
32.52
over t1
32.42
over t1
32.17
over t1
31.98
31.70
Exemple 6: afficher l'état de la connexion 3GPI sur l'écran LCD
3 Affiche l'état de la connexion GPI sur l'écran LCD. En ce qui concerne le réglage APN de la connexion 3G PI 3G, il s'agit d'un miso avant, mais "[Qiita: Test de connexion caméra Cat Pi avec SIM DMM.com] [URL de test de connexion caméra Cat Pi avec SIM DMM.com]" etc. Réglez-le en référence à.
Network Manager est utilisé dans 3GPI pour gérer les connexions, alors préparez-vous à l'utiliser depuis Python.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ sudo apt-get install python3-dbus
・ ・ ・
pi@raspberrypi:~/sandbox $ sudo pip3 install python-networkmanager
À propos, dans l'environnement actuel basé sur 3gpi-20160208-2gb.img de l'image pour 3GPI, le module dbus n'a pas pu être installé à partir de pip3.
Vérifiez auprès de l'interprète.
Vérifiez Network Manager
Python 3.4.2 (default, Oct 19 2014, 13:31:11)
[GCC 4.9.1] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import NetworkManager
>>> NetworkManager.NetworkManager.Version
'0.9.10.0'
>>> [(dev.Interface, dev.SpecificDevice().__class__.__name__)
... for dev in NetworkManager.NetworkManager.GetDevices()]
[('lo', 'Generic'), ('eth0', 'Wired'), ('ttyUSB3', 'Modem')]
Pour connaître l'état de la connexion, reportez-vous à la partie suivante de info.py dans l'exemple de python-networkmanager.
print("%-30s %s" % ("Overall state:", c('state', NetworkManager.NetworkManager.State)))
Le script a été créé à partir de l'exemple 3.
b6.py
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import wiringpi as wp
PIN_SW1_WHITE = 19
PIN_SW2_BLACK = 16
PIN_LED1_RED = 20
PIN_LED2_YELLOW = 21
PIN_BUZZER = 25
from st7032i import St7032iLCD as LCD
I2C_ADDR_LCD = 0x3e
import NetworkManager
c = NetworkManager.const
if __name__ == '__main__':
wp.wiringPiSetupGpio()
wp.pinMode(20,1)
wp.pinMode(21,1)
wp.pinMode(25,1)
lcd = LCD(I2C_ADDR_LCD)
while True:
sw1 = wp.digitalRead(PIN_SW1_WHITE)
sw2 = wp.digitalRead(PIN_SW2_BLACK)
if sw1 == 0:
lcd.clear()
wp.delay(250)
lcd.set_cursor(0, 0)
lcd.print("state:")
state = "{0}".format(c('state', NetworkManager.NetworkManager.State))
lcd.set_cursor(0, 1)
lcd.print(state)
wp.delay(500)
Chaque fois que vous exécutez et appuyez sur SW1 (blanc), ce qui suit s'affiche.
state: disconnected
Activez 3gpi avec l'utilitaire 3gpictl et l'affichage devrait changer.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ 3gpictl --poweron
Si votre terminal est uniquement série, vous pouvez exécuter le script en arrière-plan et exécuter 3g pictl au premier plan.
Sur l'émulateur de terminal
pi@raspberrypi:~/sandbox $ sudo python3 b6.py &
Dans l'environnement actuel, il passe de l'état déconnecté comme suit.
・ Passer de déconnecté à connecté
↓↓↓
↓↓↓
Version avancée
Créez un exemple légèrement plus compliqué que la version de base.
Application 1: Minuterie de nouilles de tasse mise en œuvre (bouton, buzzer et cristal liquide)
Implémentez une simple minuterie de nouilles.
spécification
--Bouton 2 Blanc appuyez pour basculer entre 3, 4 et 5 minutes --Appuyez sur le bouton 1 noir pour démarrer --Afficher le temps restant sur l'écran LCD --Le buzzer sonne le moment venu --Le buzzer s'arrête en appuyant sur le bouton 1/2
la mise en oeuvre
C'est un peu long.
a1.py
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import wiringpi as wp
PIN_SW1_WHITE = 19
PIN_SW2_BLACK = 16
PIN_LED1_RED = 20
PIN_LED2_YELLOW = 21
PIN_BUZZER = 25
from st7032i import St7032iLCD as LCD
I2C_ADDR_LCD = 0x3e
from datetime import timedelta, datetime
class RamenTimer:
"""
ramen-timer class
"""
def __init__(self):
self.lcd = LCD(I2C_ADDR_LCD)
self.lcd.clear()
self.timer = 3
self.sw1_old = 1
self.sw2_old = 1
def beep(self, duration = 100):
wp.digitalWrite(PIN_BUZZER, 1)
wp.delay(duration)
wp.digitalWrite(PIN_BUZZER, 0)
def proc_inputs(self):
sw1 = wp.digitalRead(PIN_SW1_WHITE)
if sw1 == 0 and self.sw1_old == 1:
sw1_pushed = True
else:
sw1_pushed = False
self.sw1_old = sw1
sw2 = wp.digitalRead(PIN_SW2_BLACK)
if sw2 == 0 and self.sw2_old == 1:
sw2_pushed = True
else:
sw2_pushed = False
self.sw2_old = sw2
return (sw1_pushed, sw2_pushed)
def timer_select(self):
while True:
(sw1, sw2) = self.proc_inputs()
if sw1:
return
if sw2:
self.beep()
self.timer = self.timer + 1
if self.timer > 5:
self.timer = 3
self.lcd.clear()
self.lcd.set_cursor(0, 0)
self.lcd.print("{0}:00".format(self.timer))
wp.delay(100)
def timer_run(self):
start = datetime.now()
while True:
(sw1, sw2) = self.proc_inputs()
if sw1:
return False
delta = datetime.now() - start
elapse = delta.seconds
self.lcd.clear()
self.lcd.set_cursor(0, 0)
self.lcd.print("{0}:{1:02d}".format(int(elapse/60), elapse % 60))
if elapse >= self.timer*60:
return True
wp.delay(250)
def timer_buzz(self):
count = 0
while True:
(sw1, sw2) = self.proc_inputs()
if sw1 or sw2:
wp.digitalWrite(PIN_BUZZER, 0)
return
if count in [0, 2, 4]:
wp.digitalWrite(PIN_BUZZER, 1)
else:
wp.digitalWrite(PIN_BUZZER, 0)
if count in [0, 2, 4, 6, 8]:
wp.digitalWrite(PIN_LED1_RED, 1)
else:
wp.digitalWrite(PIN_LED1_RED, 0)
count = (count + 1) % 10
wp.delay(100)
if __name__ == '__main__':
wp.wiringPiSetupGpio()
wp.pinMode(20,1)
wp.pinMode(21,1)
wp.pinMode(25,1)
wp.digitalWrite(PIN_BUZZER, 0)
rt = RamenTimer()
rt.timer_select()
ret = rt.timer_run()
if ret:
rt.timer_buzz()
Le bouton est déclenché par «lorsqu'il est enfoncé et relâché». Le buzzer est implémenté de sorte qu'il sonne trois fois plus court. Si vous appuyez sur le bouton pendant le décompte de la minuterie, il se terminera à mi-course. Vous pouvez voir les tracas liés à la création d'une interface utilisateur avec GPIO.
Application 2: PiCamera
(Si vous ne disposez pas du module PiCamera, ignorez cet élément.)
Ceci est un exemple pour prendre une photo lorsque vous appuyez sur le bouton.
Pour utiliser PiCamera, vous devez activer la caméra dans raspi-config.
raspi-config＞Enable Camera
Après le redémarrage, vous pouvez utiliser la caméra avec les commandes raspistill et raspivid.
Le script a été créé en coupant et en collant le minuteur de nouilles.
a2.py
#!/usr/bin/env python3
# -*- coding:utf-8 -*-
import wiringpi as wp
PIN_SW1_WHITE = 19
PIN_SW2_BLACK = 16
PIN_LED1_RED = 20
PIN_LED2_YELLOW = 21
PIN_BUZZER = 25
from st7032i import St7032iLCD as LCD
I2C_ADDR_LCD = 0x3e
import os
from datetime import timedelta, datetime
class DamnCamera:
"""
damn camera class
"""
def __init__(self):
self.lcd = LCD(I2C_ADDR_LCD)
self.lcd.clear()
self.sw1_old = 1
self.sw2_old = 1
def beep(self, duration = 100):
wp.digitalWrite(PIN_BUZZER, 1)
wp.delay(duration)
wp.digitalWrite(PIN_BUZZER, 0)
def proc_inputs(self):
sw1 = wp.digitalRead(PIN_SW1_WHITE)
if sw1 == 0 and self.sw1_old == 1:
sw1_pushed = True
else:
sw1_pushed = False
self.sw1_old = sw1
sw2 = wp.digitalRead(PIN_SW2_BLACK)
if sw2 == 0 and self.sw2_old == 1:
sw2_pushed = True
else:
sw2_pushed = False
self.sw2_old = sw2
return (sw1_pushed, sw2_pushed)
def run(self):
while True:
(sw1, sw2) = self.proc_inputs()
if sw1:
return False
if sw2:
self.lcd.clear()
self.lcd.set_cursor(0, 0)
self.lcd.print("<capturing...>")
self.beep()
fn = datetime.now().strftime('%m%d_%H%M%S.jpg')
os.system("raspistill -o {0}".format(fn))
self.lcd.clear()
self.lcd.set_cursor(0, 0)
self.lcd.print("{0}".format(fn))
self.beep(200)
wp.delay(250)
if __name__ == '__main__':
wp.wiringPiSetupGpio()
wp.pinMode(20,1)
wp.pinMode(21,1)
wp.pinMode(25,1)
wp.digitalWrite(PIN_BUZZER, 0)
cam = DamnCamera()
cam.run()
Lorsque vous appuyez sur SW2 (noir), une courte sonnerie retentit et vous prenez une photo. Lorsque l'image enregistrée est terminée, le buzzer retentit pendant une longue période et le nom du fichier s'affiche sur l'écran LCD. Appuyez sur SW1 (blanc) pour terminer.
Application 3: anti-rebond
Si vous exécutez la boucle avec un délai de l'ordre de 100 [msec] sur python comme l'exemple de la version de base, ce sera une contre-mesure contre le bavardage dans une certaine mesure. Je ne pense pas que cela me dérange trop. D'un autre côté, si vous utilisez le câblagePiISR comme dans l'exemple 2, vous souffrirez d'un phénomène de bavardage.
Quoi qu'il en soit, ce qui suit est un script python qui capture le phénomène de bavardage. Un saut de ligne est ajouté de manière appropriée.
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111110000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000110000000000000000000000000011111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111
Le script ressemble à ceci: Je l'ai fait plusieurs fois et j'ai simplement appuyé sur le bouton plusieurs fois pour obtenir le phénomène ci-dessus.
Observation bavarde
while True:
sw1 = wp.digitalRead(PIN_SW1)
wp.digitalWrite(PIN_LED_RED, ~sw1 & 1)
print(sw1, end='')
Un tour de la boucle while est exécuté en moins de 1 msec. La partie "... 0001100 ..." dans le résultat ci-dessus est considérée comme le phénomène de bavardage. Si vous écrivez le script sans y penser, le bouton n'a en fait été pressé qu'une seule fois, mais il a été appuyé deux fois.
Le bavardage SW dans les opérations de l'interface utilisateur peut ne pas sembler un gros problème si vous ne vous souciez pas de l'opérabilité, mais le bavardage peut souvent conduire à chasser des bogues dans des programmes inexistants, donc au moins Il doit être pris en charge par un logiciel. Si le bavardage d'entrée va directement à la sortie, cela pose des problèmes plus graves. Par exemple, la durée de vie des motoréducteurs sera extrêmement courte.
Bien que ce soit une contre-mesure gênante contre un tel bavardage, la réactivité de l'entrée se détériore en fonction de la contre-mesure, qu'elle soit dure ou douce. Par exemple, si vous insérez une minuterie ou un filtre avec un circuit CR, l'entrée sera retardée en conséquence. Cela signifie que ce sera un problème avec les boutons et les capteurs qui frappent à plusieurs reprises à grande vitesse.
Par conséquent, il n'y a en fait aucune «contre-mesure efficace de bavardage dans tous les cas». Il y a un compromis. L'important n'est peut-être pas de reprendre l'histoire de «ne vous inquiétez pas car il y a une hystérésis» ou «il n'y a pas de bavardage dans l'interrupteur à mercure». Le bavardage est un phénomène de l'ordre de la milliseconde au mieux, donc même un oshiro bon marché peut être suffisamment observé, il peut donc être bon de le vérifier de vos propres yeux.
Dans tous les cas, les mesures réellement nécessaires ne peuvent pas être décidées uniquement par le logiciel, elles doivent donc être prises en compte pour le matériel et l'ensemble du système.
finalement
Le PiConsole I / F a une structure simple de LED, de bouton, de buzzer et de cristal liquide, mais il s'adapte de manière très compacte car il est directement connecté à Raspeye et dispose également d'une conversion USB série. Il semble amusant de le transporter avec un ordinateur portable et de le démontrer.
・ Republié 3 histoires
Vous trouverez ci-dessous une image d'une configuration d'E / S similaire sur une maquette.
・ Chargement des spaghettis
C'est assez ennuyeux. Je ne peux pas appuyer sur le bouton car le fil de liaison est sur le chemin. Avec PiConsole I / F, c'est un plug-and-play qui peut être utilisé immédiatement après la connexion.
En outre, le PiConsole I / F a des broches d'en-tête comme 3GPI, vous pouvez donc facilement l'étendre en ajoutant des périphériques comme dans cet article.
Nous espérons que cet article vous sera utile pour le développement d'appareils IoT.
Merci pour la lecture.
Lien
[[anyPi] URL anyPi [Site de Mechatrax] URL de Mechatrax [3GPI] [URL de 3GPI] [Article sur la caméra Cat Pi] [URL de la caméra Cat Pi avec Raspberry et 3GPI] [Article du robinet OA de la télécommande] URL du robinet OA de la télécommande [Système Pimetry avec 3GPI et OBDII] URL du système Pimetry avec 3GPI et OBDII [Image SD avec 3GPI] [URL de l'image SD avec 3GPI] [Qiita: Communication série avec RaspberryPi3] URL pour la communication série avec RaspberryPi3 [Qiita: écran LCD AQM0802A / ST7032i utilisant WiringPi-Python] URL de l'écran LCD AQM0802A / ST7032i utilisant WiringPi-Python [Activer la condition de démarrage répété I2C sur Raspberry Pi] URL pour activer la condition de démarrage répété I2C sur Raspberry Pi [Qiita: Test de connexion SIM Cat Pi Camera-DMM.com] [URL de test de connexion SIM Cat Pi Camera-DMM.com]
[Caméra Cat Pi-URL du test de connexion avec SIM de DMM.com]: http://qiita.com/syasuda/items/5def33db425aaf05bf6d#dmmcom%E3%81%AEsim%E3%81%A7%E6%8E%A5 % E7% B6% 9A% E3% 83% 86% E3% 82% B9% E3% 83% 88
Recommended Posts