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.

[AnyPi-This alone, 3 minutes n'importe où Raspberry Pie IoT Starter Kit by Mechatrax](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.

--PC (machine Windows)

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).

PIC_20160924_113657.jpg

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 20160924134713.png

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 20160924160537.png

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 20160924135104.png

Dans ce cas, appuyez sur la touche Entrée. Vous devriez voir une invite de connexion.

・ La connexion est possible 20160924135113.png

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)

Commencez par vérifier le problème.

・ La taille du terminal est décevante 20160924141306.png

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 20160924162812.png

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 PIC_20160924_194759.jpg

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

2016-09-26-12h16m46s770.png

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 PIC_20160925_151334.jpg

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 adt7410配線.png

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.

PIC_20160925_124627.jpg

À 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.

PIC_20160925_124742.jpg

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

PIC_20160925_155544.jpg

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é 2016-09-26-14h35m56s985.png.jpg ↓↓↓ 2016-09-26-14h36m21s407.png.jpg ↓↓↓ 2016-09-26-14h36m25s606.png.jpg

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 PIC_20160924_113657.jpg

Vous trouverez ci-dessous une image d'une configuration d'E / S similaire sur une maquette.

・ Chargement des spaghettis PIC_20160924_112139.jpg

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

J'ai essayé d'utiliser la console Pi I / F du kit de démarrage Raspeye IoT de Mechatrax "anyPi"
J'ai essayé d'automatiser l'arrosage du pot avec Raspberry Pi
Envoyer des données depuis Raspberry Pi à l'aide d'AWS IOT
J'ai essayé d'utiliser le filtre d'image d'OpenCV
J'ai essayé d'utiliser l'API de Sakenowa Data Project
Je voulais faire fonctionner le moteur avec une tarte à la râpe, alors j'ai essayé d'utiliser la carte de commande du moteur de Waveshare
J'ai essayé d'utiliser la bibliothèque Python de Ruby avec PyCall
J'ai essayé de refactoriser le modèle CNN de TensorFlow en utilisant TF-Slim
J'ai essayé d'exécuter Movidius NCS avec python de Raspberry Pi3
J'ai essayé la reconnaissance faciale du problème du rire en utilisant Keras.
J'ai essayé d'automatiser [une certaine tâche] à l'aide d'une tarte à la râpe
[Python] J'ai essayé de collecter des données en utilisant l'API de wikipedia
J'ai essayé d'utiliser PI Fu pour générer un modèle 3D d'une personne à partir d'une image
J'ai envoyé les données de Raspberry Pi à GCP (gratuit)
J'ai essayé d'obtenir l'index de la liste en utilisant la fonction énumérer
J'ai regardé les méta-informations de BigQuery et essayé de les utiliser
J'ai essayé d'utiliser GrabCut d'OpenCV
J'ai essayé d'utiliser l'API checkio
J'ai essayé de livrer du courrier depuis Node.js et Python en utilisant le service de livraison de courrier (SendGrid) d'IBM Cloud!
J'ai essayé de transformer l'image du visage en utilisant sparse_image_warp de TensorFlow Addons
J'ai essayé d'obtenir les résultats de Hachinai en utilisant le traitement d'image
J'ai essayé d'appeler l'API de prédiction du modèle d'apprentissage automatique de WordPress
Paramètres initiaux pour l'utilisation du kit de démarrage et de la caméra Grove Pi + avec Raspberry Pi
J'ai essayé d'extraire et d'illustrer l'étape de l'histoire à l'aide de COTOHA
J'ai essayé l'histoire courante de l'utilisation du Deep Learning pour prédire la moyenne Nikkei
En utilisant COTOHA, j'ai essayé de suivre le cours émotionnel de la course aux meros.
J'ai essayé l'histoire courante de prédire la moyenne Nikkei à l'aide du Deep Learning (backtest)
J'ai essayé le serveur asynchrone de Django 3.0
J'ai essayé d'utiliser l'API UnityCloudBuild de Python
J'ai essayé d'estimer le rapport de circonférence π de manière probabiliste
J'ai essayé d'utiliser Headless Chrome de Selenium
Essayez le capteur Grove Pi + Starter Kit
J'ai essayé d'utiliser l'API BigQuery Storage
J'ai essayé de prédire la détérioration de la batterie lithium-ion en utilisant le SDK Qore
J'ai essayé de notifier la mise à jour de "Hameln" en utilisant "Beautiful Soup" et "IFTTT"
[Python] J'ai essayé de juger l'image du membre du groupe d'idols en utilisant Keras
Connectez-vous à la console Raspberry PI et affichez les informations IP et SD locales
J'ai tweeté l'éclairement de la pièce avec Raspberry Pi, Arduino et un capteur optique
J'ai essayé de créer un environnement Ubuntu 20.04 LTS + ROS2 avec Raspberry Pi 4
J'ai essayé d'exécuter Flask sur Raspberry Pi 3 Model B + en utilisant Nginx et uWSGI
J'ai joué à Ruina du RPG Tsukuru 2000 ~ The Story of the Abandoned City ~ sur Raspberry Pi
Utilisation du capteur de température numérique à 1 fil DS18B20 avec Raspberry Pi de Python
J'ai essayé la fonction de tableau croisé dynamique des pandas
J'ai essayé l'analyse par grappes de la carte météo
J'ai essayé d'accéder à l'API Qiita depuis le début
vprof - J'ai essayé d'utiliser le profileur pour Python
J'ai essayé de trouver le rapport de circonférence par 100 millions de chiffres
J'ai essayé L-Chika avec Razpai 4 (édition Python)
J'ai essayé d'utiliser l'API Google Cloud Vision
Lancement automatique des programmes Raspberry Pi à l'aide de Systemd
J'ai essayé de corriger la forme trapézoïdale de l'image
J'ai essayé d'utiliser le module Datetime de Python
Sonnez le buzzer en utilisant python sur Raspberry Pi 3!