[PYTHON] Raspberry Pi "Lampe de notification Honwaka" Partie 1

Aide à surveiller avec Raspberry Pi

Créez un appareil qui vous informe doucement des notifications du système avec Raspberry Pi. Le but est comme ça.

• Recevez les modifications pour être notifié du Cloud
• Si vous trouvez un changement, faites-le nous savoir avec une lampe et un carillon
• Différentes couleurs, vitesses de clignotement et types de carillon en fonction du contenu de la notification

Obtenez Raspberry Pi

J'ai acheté RaspberryPi sur Amazon.

Le boîtier spécial ci-joint a une ouverture dans la partie prise GPIO et convient pour se connecter à la base à l'extérieur du boîtier.

Configuration du système

La configuration du voyant de notification est la suivante.

Dans cet article, j'écrirai sur la partie matérielle de "Color LED" et la partie "Led Driver" qui l'exploite.

Matériel

Faites le matériel de la "lampe de notification". Le mécanisme de fonctionnement de la LED de RaspberryPi est presque le même que ["L Chika" écrit par de nombreuses personnes](http://qiita.com/search?utf8= ✓ & sort = rel & q = L Chika + raspberryPi & sort = rel) est.

Il existe différents types de LED de couleur, et il existe différentes méthodes de contrôle de la luminosité et de la couleur, mais ici, nous allons concevoir en fonction de ce qui suit.

• Lecteur LED d'alimentation avec matrice de transistors La sortie GPIO du Raspberry Pi est amplifiée par un transistor (array) afin qu'un courant suffisant puisse circuler à travers la LED Power.

• Contrôle de la couleur par logiciel PWM (Puls Width Moduration) Un circuit qui peut activer / désactiver indépendamment chaque couleur RVB en utilisant GPIO de sorte que la luminosité des trois LED de couleur puisse être librement contrôlée par un logiciel.

Schéma de câblage

Vous pouvez modifier le port GPIO à utiliser. Dans ce cas, modifiez la définition du programme décrit plus loin.

Pièces d'occasion

J'ai acheté les pièces chez Akizuki Denshi Trading (vente par correspondance).

Outils et consommables

Les outils et consommables suivants sont recommandés pour la production.

Placement des pièces

L'aspect du carton produit est le suivant.

Une prise à 40 broches est située à l'arrière de l'extrémité droite pour la connexion avec le Raspberry Pi. Cette douille à broche a une longue broche, mais si vous la soudez à la pointe sans la couper, vous pouvez la connecter juste dans la position où la base repose sur le boîtier. Sur la photo, la partie grise en haut au centre de la carte est le "bouton poussoir", mais il n'est pas utilisé dans cette explication, veuillez donc l'ignorer. La base de la LED Power est en aluminium, veillez donc à ne pas laisser le câblage toucher les bords. Bien que non visibles sur la photo, trois résistances de 47Ω sont situées sous la LED.

Led Driver Le module qui contrôle la couleur et le clignotement de la LED s'appelle ici "Led Driver". La "lampe de notification" est configurée en tant que processus enfant du processus appelant afin de pouvoir fonctionner de manière asynchrone avec le module de niveau supérieur.

La fonctionnalité du Led Driver est simple. Si vous spécifiez «Couleur» et «Cycle de clignotement (secondes)», le voyant continuera à clignoter tel quel. Si vous modifiez la spécification pendant le processus de clignotement, elle sera reflétée dans 1 seconde.

La configuration du module est la suivante.

• Classe LED qui effectue le clignotement des LED
• Classe LedDeamon qui gère la désamonisation et la communication inter-processus

Les files d'attente IPC sont utilisées pour communiquer avec Deamon. LedDeamon passera à l'affichage par défaut de l'état Down si le réglage du mode d'éclairage (set_mode) n'est pas exécuté pendant 80 secondes. Il s'agit d'une fonction de détection de descente du programme supérieur.

Pour plus de détails, consultez le code source ci-dessous.

Je suis nouveau sur Python, donc j'attends avec impatience votre chaleureux tsukkomi!

Méthode d'exécution du test:

python

$ sudo ./led.py

led.py

#! /usr/bin/env python
# -*- coding: utf-8 -*-

import RPi.GPIO as GPIO
import time


class Led(object):
    # Define your GPIO Ports
    RED_PORT = 13
    GREEN_PORT = 26
    BLUE_PORT = 5

    # Controll resolution Params
    # You don't have to change following 3 Params usually
    FREQUENCY = 200  # PWM Frequency
    RESOLUTION = 50.0  # Brightness control per span
    SPAN = 1.0  # Drive time in second at one call

    # Brightness
    MAX_BRIGHTNESS = 1.0 # Master Brightness parameter 0.1 - 1.0

    # Color Table
    # You can append your own colors
    COLORS = {
        "Red": [1.0, 0.0, 0.0],
        "Pink": [1.0, 0.3, 0.3],
        "Green": [0.0, 1.0, 0.0],
        "LightGreen": [0.2, 1.0, 0.2],
        "Blue": [0.0, 0.0, 1.0],
        "LightBlue": [0.3, 0.3, 1.0],
        "Yellow": [1.0, 1.0, 0.0],
        "Orange": [1.0, 0.3, 0.0],
        "Cyan": [0.0, 1.0, 1.0],
        "Lime": [0.0, 1.0, 0.3],
        "Magenta": [1.0, 0.0, 1.0],
        "Violet": [0.3, 0.0, 1.0],
        "White": [1.0, 1.0, 1.0],
        "Black": [0.0, 0.0, 0.0]
    }
    # Color index for Color Table
    RED = 0
    GREEN = 1
    BLUE = 2

    def color_names(self):
        return Led.COLORS.keys()

    def __init__(self):
        self.phase = 0.0
        self.color = Led.COLORS["Black"]

        GPIO.setmode(GPIO.BCM)

        # set GPIO port as output
        GPIO.setup(Led.RED_PORT, GPIO.OUT)
        GPIO.setup(Led.GREEN_PORT, GPIO.OUT)
        GPIO.setup(Led.BLUE_PORT, GPIO.OUT)

        # set port as software PWM with f Hz
        self.red = GPIO.PWM(Led.RED_PORT, Led.FREQUENCY)
        self.green = GPIO.PWM(Led.GREEN_PORT, Led.FREQUENCY)
        self.blue = GPIO.PWM(Led.BLUE_PORT, Led.FREQUENCY)

        # start software PWM with 0.0%
        self.red.start(0.0)
        self.green.start(0.0)
        self.blue.start(0.0)
        return

    def _set_brightness(self, brightness):
        percent = Led.MAX_BRIGHTNESS * (brightness ** 2) * 100.0
        # set duty cycle
        self.red.ChangeDutyCycle(min(100.0, percent * self.color[Led.RED]))
        self.green.ChangeDutyCycle(min(100.0, percent * self.color[Led.GREEN]))
        self.blue.ChangeDutyCycle(min(100.0, percent * self.color[Led.BLUE]))

    def set(self, color, interval):
        # Color name to RGB value
        self.color = Led.COLORS[color]

        # interval in second
        self.interval = float(interval)

        # control resolution parameter
        if self.interval > 0.0:
            self.pitch = 1.0 / (Led.RESOLUTION * self.interval)

        # Reset phase
        self.phase = 0.0

    def run(self):
        if self.interval == 0.0:
            # No Blink
            self._set_brightness(0.5)
            time.sleep(Led.SPAN)
        else:
            for i in range(int(Led.RESOLUTION * Led.SPAN)):
                self.phase += self.pitch
                if self.phase >= 1.0:
                    self.phase = 0.0
                if self.phase < 0.5:
                    br = self.phase * 2.0
                else:
                    br = 1.0 - ((self.phase - 0.5) * 2.0)
                # keep a little light
                br += 0.0001
                self._set_brightness(br)
                time.sleep(1.0 / Led.RESOLUTION)

    def destroy(self):
        self.red.stop()
        self.green.stop()
        self.blue.stop()
        GPIO.cleanup()

if __name__ == ("__main__"):

    l = Led()
    l.set("Blue", 0.5)
    l.run()
    l.set("Black", 0)
    l.run()
    for interval in [0, 0.5, 1.0]:
        print("- Inrerval = %2.1f" % interval )
        for c in l.color_names():
            if c == "Black":
                continue
            print(c)
            l.set(c, interval)
            for i in range(max(1, int(interval * 2.0))):
                l.run()
    l.destroy()

Méthode d'exécution du test:

python

$ sudo ./led_deamon.py

led_deamon.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-


import time
import multiprocessing
import Queue
from led import Led


class LedDeamon(object):
    DOWN = {"color": "Magenta", "interval": 0}

    def __init__(self):
        self.queue = multiprocessing.Queue()
        self.lighting_mode = None

    def start(self):
        p = multiprocessing.Process(target=self._led_control, args=(self.queue, ))
        # Set deamon flug to kill process when parent process died
        p.daemon = True
        p.start()

    def set_mode(self, lightning_mode):
        self.queue.put(lightning_mode)

    # Child loop
    def _led_control(self, queue):
        count = 0
        lighting_mode = LedDeamon.DOWN
        self.led = Led()
        while True:
            # get mode from queue
            try:
                lighting_mode = self.queue.get(False)
                count = 0
                # print("lighting_mode = %s" % lighting_mode)
            except Queue.Empty:
                count += 1
                # parent seems dead
                if count > 80:
                    lighting_mode = LedDeamon.DOWN
            self._drive(lighting_mode)  # Drive for about 1 sec.

    def _drive(self, lighting_mode):
        if self.lighting_mode != lighting_mode:
            self.lighting_mode = lighting_mode
            self.led.set(lighting_mode["color"], lighting_mode["interval"])
            # print("lighting_mode = %s" % lighting_mode)
        self.led.run()

if __name__ == '__main__':
    mode_map = {
        "DOWN": {"color": "Magenta", "interval": 0},
        "ERR_UNACKED": {"color": "Red", "interval": 0.5},
        "WARN_UNACKED": {"color": "Yellow", "interval": 2},
        "ERR_ACKED": {"color": "Green", "interval": 4},
        "WARN_ACKED": {"color": "Green", "interval": 8},
        "NORMAL": {"color": "Blue", "interval": 8}}

    # Create and start LED Driver
    ld = LedDeamon()
    ld.set_mode(mode_map["NORMAL"])
    ld.start()
    time.sleep(8)
    ld.set_mode(mode_map["ERR_UNACKED"])
    time.sleep(8)
    ld.set_mode(mode_map["WARN_UNACKED"])
    time.sleep(8)
    ld.set_mode(mode_map["ERR_ACKED"])
    time.sleep(8)
    ld.set_mode(mode_map["WARN_ACKED"])
    time.sleep(8)
    ld.set_mode(mode_map["DOWN"])
    time.sleep(8)

Limites

• Ne prend pas en compte l'utilisation simultanée de plusieurs processus
• Contrôle logiciel complet, il peut donc clignoter un peu sous la charge du système.
• Si GPIO est utilisé à d'autres fins, il doit être modifié.
• Puisqu'il est contrôlé par logiciel, il consomme un peu de CPU. Le processus Python représente environ 2,5% de 1Core. Il semble qu'il consomme environ 1% du total 4Core.

prime

C'est ainsi qu'il brille lorsqu'un problème important survient. Lorsqu'il est combiné avec un carillon approprié, vous pouvez créer un sentiment d'urgence. (Je ne veux pas trop le voir ...)

Le couvercle en forme de dôme qui recouvre la LED est une diversion du cache de la lumière LED qui a été vendu chez Daiso. En fait, la partie la plus difficile de la production de matériel était de trouver cette couverture. (Lol)

Calendrier suivant

La prochaine fois, j'écrirai sur le module Detector qui contrôle les notifications.