[PYTHON] Ich habe versucht, die Pi Console I / F von Mechatraxs Raspeye IoT Starter Kit "anyPi" zu verwenden.
Einführung
In diesem Artikel werde ich die Ausrüstung verwenden, die ich außer der PiConsole I / F habe, aber die PiConsole I / F ist ein gebündeltes Produkt exklusiv für Mechatraxs Raspeye IoT-Starterkit "[anyPi] anyPi URL". Das stimmt, es scheint, dass es nicht separat verkauft wird. Ich würde mich über Ihre Aufmerksamkeit freuen.
"[AnyPi] anyPi URL" ist ein Starter-Kit für IoT, mit dem Sie Raspai in fast allen Regionen Japans in 3 Minuten mit dem Internet verbinden können, auch wenn Sie keine Internetverbindungsumgebung haben. Ich werde dich vorstellen.
[
](http: / /www.youtube.com/watch?v=NhrIYOyh4wc)
(Der Link ist ein Video.)
Die folgenden Artikel basieren auf der Annahme, dass sie gemäß den Websites [anyPi] und anyPi URL zusammengestellt wurden.
Verwendete Ausrüstung
Die folgenden Geräte werden in diesem Artikel verwendet. Es ist kein Löten oder Verarbeiten erforderlich.
- PiConsole I/F
- Raspai 3
- 3GPI
- USB Mini B Kabel (für serielle)
- AC Adapter (↑↑↑ Bis zu diesem Punkt, was in [anyPi] anyPi URL enthalten ist) (↓ ↓ ↓ Folgendes ist in [anyPi] anyPi URL nicht enthalten: Es gibt kein Problem, wenn einige Samples außer PC nicht ausgeführt werden können.)
--PC (Windows-Maschine)
- I2C-Verbindungstemperatursensor (http://akizukidenshi.com/catalog/g/gM-06675/)
- PiCamera
- Brotbrett
- Überbrückungskabel angemessene Menge
Da es einen Header-Anschluss hat, der direkt mit dem Raspelkuchen verbunden werden kann, handelt es sich um eine dreistöckige Konfiguration mit 3GPI mit einem ähnlichen Header-Anschluss. Ich erinnerte mich an PC / 104 und GP-IB (HP-IB).
Das als Beispiel erstellte Skript wird auf den folgenden Github hochgeladen.
https://github.com/syasuder/piconsole-sample
Wenn das Kopieren schwierig ist, verwenden Sie bitte Klon usw.
Melden Sie sich mit einer seriellen Verbindung von einem PC (Win-System) bei Raspeye an.
(Wenn Sie eine Verbindung über Kabel / WLAN herstellen und den Terminalemulator über ssh verwenden, überspringen Sie diesen Abschnitt und fahren Sie mit den Grundlagen fort.)
Die PiConsole I / F verfügt über eine USB / Seriell (UART) -Konvertierungsschaltung. Sie können auf die Seriennummer von Raspeye zugreifen, indem Sie sie einfach mit einem USB-Mini-B-Kabel an Ihren PC anschließen.
Darüber hinaus ist die Seriennummer standardmäßig auf tty eingestellt, sodass Sie nichts tun müssen, indem Sie sie nur anschließen.
Sie können feststellen, dass Sie nichts tun müssen, indem Sie den Terminalemulator starten (hier wird TeraTerm verwendet) und dann die Stromversorgung von Raspeye einschalten. 115.200 Bit / s, 8 Datenbits, 1 Stoppbit, keine Parität.
・ Serielle Ausgabe während des Raspetortenstarts
Wenn Sie jedoch zum ersten Mal über USB eine Verbindung zur PiConsole I / F herstellen, dauert es einige Zeit, bis der Treiber installiert ist, sodass Sie dieses Startprotokoll möglicherweise nicht sehen können. Wenn es sich um Windows 8.1 handelte, wurde es vom mit dem Betriebssystem gelieferten Treiber erkannt, aber es dauerte immer noch einige zehn Sekunden.
・ COM-Anschluss erkannt
Daher sieht der Bildschirm des Terminalemulators, den Sie zum ersten Mal sehen, möglicherweise wie folgt aus.
・ Es ist pechschwarz, wenn Sie zum ersten Mal eine Verbindung herstellen
Drücken Sie in diesem Fall die Eingabetaste. Sie sollten eine Anmeldeaufforderung sehen.
・ Login ist möglich
Versuchen Sie, sich als Standardbenutzer von Raspeye anzumelden.
Benutzername: pi Passwort: Himbeere
Auf dem Terminalemulator
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.
Wenn Sie es gewohnt sind, über LAN eine Verbindung mit ssh herzustellen, kann das serielle Verbindungsterminal Sie verwirren. Hier werden nur die folgenden zwei Maßnahmen ergriffen. (Referenz: [Qiita: Serielle Kommunikation mit RaspberryPi3] URL für die serielle Kommunikation mit RaspberryPi3)
- Endgröße
- Unterstützt 256 Farben
Überprüfen Sie zunächst das Problem.
・ Die Terminalgröße ist enttäuschend
Auf dem Terminalemulator
pi@raspberrypi:~$ stty rows 36; stty columns 128
pi@raspberrypi:~$ export TERM=xterm-256color; source ~/.bashrc
・ Geräumig und 256 Farben
Ändern Sie die Anzahl der Zeilen und Ziffern entsprechend Ihrer Umgebung.
Danach kann es auf die gleiche Weise wie ein mit ssh verbundenes Terminal verwendet werden, es ist jedoch besser, Pakete usw. über Kabel / WLAN zu aktualisieren oder hinzuzufügen. Wenn Sie eine DHCP-fähige LAN-Umgebung verwenden, schließen Sie einfach das kabelgebundene LAN-Kabel an.
Ich denke, einer der Vorteile einer seriellen Verbindung besteht darin, dass der Terminalemulator auch dann offen bleiben kann, wenn die Stromversorgung von Raspeye ein- und ausgeschaltet wird. Dies hängt von der Funktion des Terminalemulators ab. Ist es jedoch schwierig, die Verbindung über ssh wiederherzustellen?
Basisausgabe
Von hier aus überprüfen wir den Betrieb jeder in der PiConsole I / F installierten Funktion einzeln.
GPIO
Überprüfen Sie zunächst die Funktion der Tasten, LEDs und des Summers.
Verwenden Sie den Befehl gpio. Der Befehl gpio kann ohne Installation verwendet werden, aber das 3GPI-Image 3gpi-20160208-2gb.img scheint Raspeye 3 nicht zu unterstützen, wie unten gezeigt.
Auf dem Terminalemulator
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
Es heißt "Typ: Unbekannt 08". Aktualisieren Sie daher das Wiringpi-Paket.
Auf dem Terminalemulator
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
Anerkannt als "Typ: Pi 3". Es gibt verschiedene Einstellungen in gpio von Raspeye, überprüfen Sie also zuerst die ursprünglichen Einstellungen.
Auf dem Terminalemulator
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---+---+------+---------+-----+-----+
Lassen Sie mich ein wenig über die obige Tabelle erklären. Die Spalte "Physikalisch" entspricht der Pin-Nummer des Rasppie-Header-Pins. In diesem Artikel verwendet die GPIO-Nummer die sogenannte "GPIO-Nummer". In der obigen Tabelle entspricht sie also der in der Spalte "BCM" angegebenen Nummer. Die GPIO-Nummer wird auch im Skript verwendet. Zum Beispiel befindet sich GPIO20 an Pin 38 des Header-Pins.
Nachdem Sie nun wissen, wie Sie die GPIO-Nummernzuordnung überprüfen können, beginnen wir mit L Pika. Schalten Sie die LED ein.
Auf dem Terminalemulator
pi@raspberrypi:~ $ gpio -g mode 20 out
pi@raspberrypi:~ $ gpio -g mode 21 out
pi@raspberrypi:~ $ gpio -g write 20 1
(Rote LED leuchtet auf)
pi@raspberrypi:~ $ gpio -g write 21 1
(Rote / gelbe LED leuchtet auf)
pi@raspberrypi:~ $ gpio -g write 20 0
pi@raspberrypi:~ $ gpio -g write 21 0
・ Roter / gelber LED-Beleuchtungsstatus
Überprüfen Sie vor dem Rest der Prüfung die E / A der PiConsole-E / A.
Tabelle 1: GPIO für PiConsole I / F.
| GPIO-Name | PIN Nummer | Aufbau | Funktion |
|---|---|---|---|
| GPIO20 | 38 | Ausgabe | LED1(rot) |
| GPIO21 | 40 | Ausgabe | LED2(Gelb) |
| GPIO25 | 22 | Ausgabe | Summer |
| GPIO19 | 35 | Eingang | SW1(Weiß) |
| GPIO16 | 36 | Eingang | SW2(schwarz) |
Im Folgenden werden die Pins nicht direkt betätigt.
Tabelle 2: GPIO, das mit PiConsole I / F verwendet wird
| GPIO-Name | PIN Nummer | Funktion |
|---|---|---|
| GPIO2 | 3 | LCD SDA |
| GPIO3 | 5 | LCD SCL |
| GPIO14 | 8 | USB232-Konvertierung(TXD) |
| GPIO15 | 10 | USB232-Konvertierung(RXD) |
Lass uns weitermachen. Es ist ein Summer. Es macht ein ziemlich lautes Geräusch.
Auf dem Terminalemulator
pi@raspberrypi:~ $ gpio -g mode 25 out
pi@raspberrypi:~ $ gpio -g write 25 1
pi@raspberrypi:~ $ gpio -g write 25 0
Als nächstes kommt SW. SW wird beim Drücken zu '0'. (Sogenannte negative Logik)
Auf dem Terminalemulator
pi@raspberrypi:~ $ gpio -g read 19
1
pi@raspberrypi:~ $ gpio -g read 19
0
(SW1 weiße Taste gedrückt Zustand)
pi@raspberrypi:~ $ gpio -g read 16
1
pi@raspberrypi:~ $ gpio -g read 16
0
(SW2 schwarzer Knopf gedrückt Zustand)
Das ist alles für die Überprüfung von GPIO.
I2C
Das Flüssigkristallmodul ist über den I2C-Bus mit dem Raspelkuchen verbunden. Um den I2C-Bus nutzen zu können, muss I2C in raspi-config aktiviert sein.
raspi-config>Advanced Options>I2C
Installieren Sie das Tool zur Überprüfung des Betriebs.
Auf dem Terminalemulator
pi@raspberrypi:~ $ sudo apt-get install i2c-tools
Da I2C ein Bus ist, können Sie mehrere Geräte hintereinander verbinden. Das heißt, Sie müssen das Gerät identifizieren. Überprüfen Sie den Erkennungsstatus des Geräts mit dem sofort installierten Tool.
Auf dem Terminalemulator
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: -- -- -- -- -- -- -- --
Diese '3e' ist die Adresse des Flüssigkristallmoduls. Verwenden Sie das Skript "[Qiita: AQM0802A / ST7032i LCD-Anzeige mit WiringPi-Python] [URL der AQM0802A / ST7032i LCD-Anzeige mit WiringPi-Python]", um die Funktion des Flüssigkristallmoduls zu überprüfen. Ich brauche das Python-Modul von wiringpi, also installiere es mit pip3.
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ sudo pip3 install wiringpi
Ändern Sie die folgende Zeile des Skripts im obigen Qiita-Artikel.
import wiringpi2 as wp
Wo ist es
import wiringpi as wp
Ändern.
Bei der Ausführung wird der Ticker auf dem LCD-Bildschirm angezeigt.
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ python3 st7032i.py
Das ist alles, um den Betrieb von I2C zu überprüfen.
Beispiel 1: Die LED leuchtet auf, wenn die Taste gedrückt wird
Schreiben wir ein einfaches Python-Skript mit wiringpi. Erstens ist die Zusammenarbeit zwischen Tasten und LEDs.
・ Beispiel, dass die LED leuchtet, wenn die Taste gedrückt wird
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)
#Da sw eine negative Logik ist, invertieren und auf LED-Ausgang setzen
wp.digitalWrite(PIN_LED1_RED, ~sw1 & 1)
wp.digitalWrite(PIN_LED2_YELLOW, ~sw2 & 1)
wp.delay(250)
Führen Sie wie folgt aus.
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ sudo python3 b1.py
Drücken Sie SW1 (weiß), um LED1 (rot) einzuschalten, und drücken Sie SW2 (schwarz), um LED2 (gelb) einzuschalten.
Beispiel 2: Halten Sie die Taste gedrückt, um neu zu starten / herunterzufahren
Sie können mit allem arbeiten, was Sie mit einem Python-Skript tun können. In diesem Beispiel wird die Erkennung der SW-Presse in einem Interrupt-Stil mit wiringPiISR beschrieben.
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
#Halten Sie mindestens 1 Sekunde lang gedrückt, um True zurückzugeben
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
#Rückruf bei gedrücktem sw1
def sw1_callback():
if is_long_pushed(PIN_SW1_WHITE):
print("reboot")
os.system("sudo reboot")
else:
print("reboot cancel")
#Rückruf bei gedrücktem sw2
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)
#Fall Trigger, weil es negative Logik ist
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)
Ich werde das machen.
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ sudo python3 b1.py
(SW1(Weiß)Lange drücken)
reboot
[ 3388.810715] reboot: Restarting system
・ ・ ・
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ sudo python3 b1.py
(SW2(schwarz)Lange drücken)
shutdown
[ 123.228773] reboot: Power down
・ ・ ・
Beispiel 3: Drücken Sie die Taste, um die aktuelle IP-Adresse auf dem LCD anzuzeigen
Dies ist einfach, da die Klasse, mit der der Betrieb des Flüssigkristallmoduls überprüft wird, importiert und verwendet wird. Speichern Sie es als 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)
Ich werde es versuchen.
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ sudo python3 b3.py
Wenn Sie den schwarzen Schalter drücken, wird die Adresse der eth0-Schnittstelle auf dem LCD angezeigt.
・ IP-Adressanzeige
Wenn Sie den Teil'eth0' im Skript in'ppp0 'ändern, wird die 3G-ppp-Adresse angezeigt.
Beispiel 4: Drücken Sie die Taste, um die aktuelle Temperatur auf dem LCD anzuzeigen
(Wenn Sie kein I2C-angeschlossenes Temperatursensormodul haben, überspringen Sie diesen Punkt.)
Verdrahten Sie unter Bezugnahme auf das Material des Temperatursensormoduls für die I2C-Verbindung (http://akizukidenshi.com/catalog/g/gM-06675/). Es ist einfach, weil es nur vier gibt.
・ PIN-Korrespondenztabelle (PIN-Nummer auf der Modulseite ist temporär)
| Seite des Temperatursensormoduls | (PIN Nummer) | PIN Nummer | Razz Pie Seite |
|---|---|---|---|
| VDD | (1) | 1 | 3.3v |
| SDA | (3) | 3 | SDA |
| SCL | (2) | 5 | SCL |
| GND | (4) | 6 | GND |
- Schaltplan des Temperatursensormoduls
Im obigen Bild handelt es sich um eine Raspeltorte, die eigentliche Verkabelung erfolgt jedoch mit dem Header-Pin der PiConsole I / F.
Zu diesem Zeitpunkt ist einer ein männlicher Überbrückungsstift und der andere ein weiblicher Überbrückungsstift. Wenn jedoch beide weibliche Überbrückungsstifte haben, ist kein Steckbrett erforderlich. Dies kann praktischer sein, wenn Sie mit einem Temperatursensor experimentieren.
Überprüfen Sie zunächst, ob es vom I2C-Bus erkannt wird.
Auf dem Terminalemulator
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' ist die Adresse des Temperatursensormoduls. Hier habe ich es mit dem Befehl gpio bestätigt. Es scheint, dass es normal erkannt wird.
Weitere Vorbereitungen sind erforderlich. Das hier verwendete Temperatursensormodul kann mit einer kleinen Einstellung mit der ursprünglichen 16-Bit-Auflösung messen. Siehe "[I2C-Wiederholungsstartbedingung auf Raspberry Pi aktivieren] URL zum Aktivieren der I2C-Wiederholungsstartbedingung auf Raspberry Pi".
shell-session:/etc/modprobe.d/i2c.conf
options i2c_bcm2708 combined=1
Starten Sie Raspai nach dem Erstellen der obigen Datei neu.
Dann ist es ein Skript. Überprüfen Sie zunächst nur den Betrieb des Temperatursensormoduls.
adt7410.py
#!/usr/bin/python
# -*- coding: utf-8 -*-
import wiringpi as wp
import time
I2C_ADDR_THERMO = 0x48
#2 Komplementdarstellung Umwandlung
# 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)
#Stellen Sie die Auflösung auf 16 Bit ein
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)
Das obige Skript funktioniert von selbst. Führen Sie es aus, um den Vorgang zu überprüfen.
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ python3 adt7410.py
Temperature: 27.98
Temperature: 28.02
Temperature: 27.98
・ ・ ・
Die Temperatur wird jede Sekunde angezeigt, daher ist es in Ordnung, wenn ein Wert nahe der Raumtemperatur angezeigt wird. Stellen Sie außerdem sicher, dass sich die Temperatur ändert, indem Sie den IC mit Ihrem Finger berühren.
Sie können jetzt das Temperatursensormodul verwenden. Das Skript für "Wenn Sie die Taste drücken" lautet wie folgt.
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)
Führen Sie SW2 (schwarz) aus und drücken Sie es, um die Temperatur auf dem Flüssigkristallbildschirm anzuzeigen.
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ sudo python3 b4.py
Beispiel 5: Der Summer ertönt, wenn der Wert vom Temperatursensor den Schwellenwert überschreitet
(Wenn Sie kein I2C-angeschlossenes Temperatursensormodul haben, überspringen Sie diesen Punkt.)
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 #Schwelle 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)
Machen wir das. Da der Schwellenwert auf 32 ° C eingestellt ist, ertönt der Summer, sobald Sie ihn mit dem Finger berühren. Der Summer stoppt, wenn Sie Ihren Finger loslassen und die Schwelle unterschreiten.
Auf dem Terminalemulator
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
Beispiel 6: Zeigen Sie den 3GPI-Verbindungsstatus auf dem LCD an
3 Zeigt den GPI-Verbindungsstatus auf dem LCD an. In Bezug auf die APN-Einstellung der 3G PI 3G-Verbindung handelt es sich um ein Front-Miso, aber "[Qiita: Cat Pi-Kameraverbindungstest mit DMM.com-SIM] [Cat Pi-Kameraverbindungstest-URL mit DMM.com-SIM]" usw. Stellen Sie es mit Bezug auf ein.
Network Manager wird in 3GPI zum Verwalten von Verbindungen verwendet. Bereiten Sie sich also auf die Verwendung in Python vor.
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ sudo apt-get install python3-dbus
・ ・ ・
pi@raspberrypi:~/sandbox $ sudo pip3 install python-networkmanager
Übrigens konnte in der vorliegenden Umgebung, die auf 3gpi-20160208-2gb.img des Images für 3GPI basiert, das dbus-Modul nicht über pip3 installiert werden.
Fragen Sie beim Dolmetscher nach.
Überprüfen Sie den Netzwerkmanager
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')]
Informationen zum Verbindungsstatus finden Sie im folgenden Teil von info.py im Beispiel von python-networkmanager.
print("%-30s %s" % ("Overall state:", c('state', NetworkManager.NetworkManager.State)))
Das Skript wurde basierend auf Beispiel 3 erstellt.
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)
Jedes Mal, wenn Sie SW1 (weiß) ausführen und drücken, wird Folgendes angezeigt.
state: disconnected
Schalten Sie 3gpi mit dem Dienstprogramm 3gpictl ein und die Anzeige sollte sich ändern.
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ 3gpictl --poweron
Wenn Ihr Terminal nur seriell ist, können Sie das Skript im Hintergrund und 3g pictl im Vordergrund ausführen.
Auf dem Terminalemulator
pi@raspberrypi:~/sandbox $ sudo python3 b6.py &
In der vorliegenden Umgebung ändert es sich wie folgt vom getrennten Zustand.
・ Wechseln Sie von getrennt zu verbunden
↓↓↓
↓↓↓
Erweiterte Version
Erstellen Sie ein Beispiel, das etwas komplizierter als die Basisversion ist.
Anwendung 1: Implementierter Cup-Nudel-Timer (Knopf, Summer und Flüssigkristall)
Implementieren Sie einen einfachen Tassen-Nudel-Timer.
Spezifikation
- Taste 2 Weiß drücken, um zwischen 3, 4 und 5 Minuten zu wechseln
- Drücken Sie zum Starten die Taste 1 schwarz
- Zeigen Sie die verbleibende Zeit auf dem LCD an
- Summer ertönt, wenn es soweit ist
- Der Summer stoppt durch Drücken der Taste 1/2
Implementierung
Es ist ein bisschen lang.
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()
Die Taste wird ausgelöst durch "beim Drücken und Loslassen". Der Summer ist so implementiert, dass er dreimal kürzer klingt. Wenn Sie die Taste während der Timer-Zählung drücken, endet sie zur Hälfte. Sie können den Aufwand beim Erstellen einer Benutzeroberfläche mit GPIO sehen.
Anwendung 2: PiCamera
(Wenn Sie das PiCamera-Modul nicht haben, überspringen Sie diesen Punkt.)
Dies ist ein Beispiel, um ein Bild aufzunehmen, wenn Sie die Taste drücken.
Um PiCamera verwenden zu können, müssen Sie die Kamera in raspi-config aktivieren.
raspi-config＞Enable Camera
Nach dem Neustart können Sie die Kamera mit den Befehlen raspistill und raspivid verwenden.
Das Skript wurde durch Ausschneiden und Einfügen des Cup Noodle Timers erstellt.
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()
Wenn Sie SW2 (schwarz) drücken, ertönt ein kurzer Summer und Sie machen ein Bild. Wenn das gespeicherte Bild fertig ist, ertönt eine lange Zeit der Summer und der Dateiname wird auf dem LCD-Bildschirm angezeigt. Drücken Sie zum Beenden SW1 (weiß).
Anwendung 3: Entprellen
Wie im Beispiel der Basisversion ist es eine Gegenmaßnahme gegen ein gewisses Rattern, wenn Sie die Schleife mit einer Verzögerung von 100 [ms] in Python ausführen. Ich denke nicht, dass es mich zu sehr stört. Wenn Sie dagegen wie in Beispiel 2 WiringPiISR verwenden, tritt ein Ratter-Phänomen auf.
Wie auch immer, das Folgende ist ein Python-Skript, das das Chattering-Phänomen erfasst. Ein Zeilenumbruch wird entsprechend hinzugefügt.
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111110000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000110000000000000000000000000011111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111111111111111111111111111111111111111111111111111
11111111111111111111111111111111
Das Skript sieht folgendermaßen aus: Ich habe dies einige Male getan und nur ein paar Mal den Knopf gedrückt, um das obige Phänomen zu erhalten.
Geschwätzige Beobachtung
while True:
sw1 = wp.digitalRead(PIN_SW1)
wp.digitalWrite(PIN_LED_RED, ~sw1 & 1)
print(sw1, end='')
Eine Runde der while-Schleife wird in weniger als 1 ms ausgeführt. Der Teil von "... 0001100 ..." im obigen Ergebnis wird als das Rattern angesehen. Wenn Sie das Skript schreiben, ohne darüber nachzudenken, wurde die Schaltfläche tatsächlich nur einmal gedrückt, aber zweimal.
SW-Chattering in UI-Vorgängen scheint keine große Sache zu sein, wenn Sie sich nicht um die Bedienbarkeit kümmern, aber Chattering kann häufig dazu führen, dass Fehler in nicht vorhandenen Programmen verfolgt werden Es sollte von Software unterstützt werden. Wenn das Eingangs-Chattering direkt zum Ausgang geht, verursacht dies schwerwiegendere Probleme. Beispielsweise wird die Lebensdauer von Getriebemotoren extrem verkürzt.
Obwohl dies eine problematische Gegenmaßnahme gegen ein solches Rattern ist, verschlechtert sich die Reaktionsfähigkeit der Eingabe in Abhängigkeit von der Gegenmaßnahme, ob sie hart oder weich ist. Wenn Sie beispielsweise einen Timer oder Filter mit einer CR-Schaltung einfügen, wird die Eingabe entsprechend verzögert. Dies bedeutet, dass es ein Problem mit Tasten und Sensoren gibt, die wiederholt mit hoher Geschwindigkeit schlagen.
Daher gibt es eigentlich keine "wirksame Gegenmaßnahme zum Rattern auf jeden Fall". Es gibt einen Kompromiss. Das Wichtigste ist möglicherweise nicht, die Geschichte von "Keine Sorge, weil es eine Hysterese gibt" oder "Es tritt kein Rattern im Quecksilberschalter auf" zu nehmen. Rattern ist bestenfalls ein Phänomen in der Größenordnung von ms, so dass selbst billiges Oshiro ausreichend beobachtet werden kann. Daher kann es sinnvoll sein, es mit eigenen Augen zu überprüfen.
In jedem Fall können die tatsächlich erforderlichen Maßnahmen nicht nur von der Software bestimmt werden, daher sollten sie für die Hardware und das gesamte System berücksichtigt werden.
Schließlich
Das PiConsole I / F hat eine einfache Struktur aus LED, Taste, Summer und Flüssigkristall, ist jedoch direkt mit Raspeye verbunden und verfügt über eine serielle USB-Konvertierung, sodass es sehr kompakt passt. Es scheint Spaß zu machen, es mit einem Notebook-PC zu tragen und zu demonstrieren.
・ 3 Geschichten neu gepostet
Unten sehen Sie ein Bild einer ähnlichen E / A, die auf einem Steckbrett eingerichtet ist.
・ Laden von Spaghetti
Es ist ziemlich nervig. Ich kann den Knopf nicht drücken, weil das Überbrückungskabel im Weg ist. Mit PiConsole I / F ist es ein Plug-and-Play, das unmittelbar nach dem Anschließen verwendet werden kann.
Das PiConsole I / F verfügt außerdem über Header-Pins wie 3GPI, sodass Sie es einfach erweitern können, indem Sie Geräte wie in diesem Artikel hinzufügen.
Wir hoffen, dass Sie diesen Artikel für die Entwicklung von IoT-Geräten nützlich finden.
Danke fürs Lesen.
Verknüpfung
[[anyPi] anyPi URL [Mechatrax's Seite] Mechatrax's URL [3GPI] [URL von 3GPI] [Artikel zur Cat Pi-Kamera] [URL der Cat Pi-Kamera mit Himbeere und 3GPI] [Fernbedienungs-OA-Tap-Artikel] [Fernbedienungs-OA-Tap-URL] [Pimetriesystem mit 3GPI und OBDII] URL des Pimetriesystems mit 3GPI und OBDII [SD-Image mit 3GPI] [URL des SD-Images mit 3GPI] [Qiita: Serielle Kommunikation mit RaspberryPi3] URL für die serielle Kommunikation mit RaspberryPi3 [Qiita: AQM0802A / ST7032i-LCD-Anzeige mit WiringPi-Python] [URL der AQM0802A / ST7032i-LCD-Anzeige mit WiringPi-Python] [I2C-Wiederholungsstartbedingung auf Raspberry Pi aktivieren] URL zum Aktivieren der I2C-Wiederholungsstartbedingung auf Raspberry Pi [Qiita: SIM-Verbindungstest für Cat Pi-Kamera-DMM.com] [URL für SIM-Verbindungstest für Cat Pi-Kamera-DMM.com]
[Cat Pi Kamera-URL des Verbindungstests mit SIM von 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