[PYTHON] Raspberry Pi "Honwaka Benachrichtigungslampe" Teil 1

Hilfe bei der Überwachung mit Raspberry Pi

Erstellen Sie mit Raspberry Pi ein Gerät, das Sie sanft über Benachrichtigungen vom System benachrichtigt. Das Ziel ist so.

• Änderungen werden von der Cloud benachrichtigt
• Wenn Sie eine Änderung finden, lassen Sie es uns mit einer Lampe und einem Glockenspiel wissen
• Unterschiedliche Farben, Blinkgeschwindigkeiten und Glockenspiele je nach Inhalt der Benachrichtigung

Holen Sie sich Raspberry Pi

Ich habe RaspberryPi bei Amazon gekauft.

Der angebrachte Sonderfall hat eine Öffnung im GPIO-Sockelteil und eignet sich zum Anschluss an die Basis außerhalb des Gehäuses.

Systemkonfiguration

Die Konfiguration der Benachrichtigungslampe ist wie folgt.

In diesem Artikel werde ich über den Hardware-Teil von "Color LED" und den "Led Driver" -Teil schreiben, der ihn bedient.

Hardware-

Machen Sie die Hardware der "Benachrichtigungslampe". Der Mechanismus zum Betreiben der LED von RaspberryPi ist fast der gleiche wie ["L Chika", geschrieben von vielen Leuten](http://qiita.com/search?utf8= ✓ & sort = rel & q = L Chika + raspberryPi & sort = rel) ist.

Es gibt verschiedene Arten von Farb-LEDs und verschiedene Steuermethoden für Helligkeit und Farbe. Hier werden wir jedoch auf der Grundlage der folgenden Punkte entwerfen.

• Power LED-Laufwerk mit Transistor-Array Der GPIO-Ausgang des Raspberry Pi wird durch einen Transistor (Array) verstärkt, so dass ausreichend Strom durch die Power-LED fließen kann.

• Farbsteuerung durch Software PWM (Puls Width Moduration) Eine Schaltung, die jede RGB-Farbe durch Betreiben von GPIO unabhängig ein- und ausschalten kann, sodass die Helligkeit der drei Farb-LEDs per Software frei gesteuert werden kann.

Schaltplan

Sie können den zu verwendenden GPIO-Port ändern. Ändern Sie in diesem Fall die Definition des später beschriebenen Programms.

Gebrauchtteile

Ich habe die Teile bei Akizuki Denshi Trading (Versandhandel) gekauft.

Werkzeuge und Verbrauchsmaterialien

Die folgenden Werkzeuge und Verbrauchsmaterialien werden für die Produktion empfohlen.

Teileplatzierung

Das Aussehen der hergestellten Platte ist wie folgt.

Auf der Rückseite des rechten Endes befindet sich eine 40-polige Stiftbuchse für den Anschluss an den Raspberry Pi. Diese Stiftbuchse hat einen langen Stift. Wenn Sie ihn jedoch an der Spitze löten, ohne ihn zu schneiden, können Sie ihn nur an der Stelle anschließen, an der die Basis auf dem Gehäuse aufliegt. Auf dem Foto ist der graue Teil in der oberen Mitte der Platine der "Druckschalter", der in dieser Erklärung jedoch nicht verwendet wird. Bitte ignorieren Sie ihn. Die Basis der Power-LED besteht aus Aluminium. Achten Sie daher darauf, dass die Verkabelung nicht die Kanten berührt. Obwohl auf dem Foto nicht sichtbar, befinden sich drei 47Ω-Widerstände unter der LED.

Led Driver Das Modul, das die Farbe und das Blinken der LED steuert, wird hier als "LED-Treiber" bezeichnet. Die "Benachrichtigungslampe" ist als untergeordneter Prozess des aufrufenden Prozesses konfiguriert, so dass sie asynchron mit dem übergeordneten Modul arbeiten kann.

Die Funktionalität des LED-Treibers ist einfach. Wenn Sie "Farbe" und "Blinkzyklus (Sekunden)" angeben, blinkt die LED unverändert weiter. Wenn Sie die Spezifikation während des Blinkvorgangs ändern, wird sie innerhalb von 1 Sekunde angezeigt.

Die Modulkonfiguration ist wie folgt.

• LED-Klasse, die LED blinkt
• LedDeamon-Klasse, die die Deamonisierung und die Kommunikation zwischen Prozessen übernimmt

IPC-Warteschlangen werden zur Kommunikation mit Deamon verwendet. LedDeamon wechselt in die Standardanzeige für den Status "Down", wenn die Einstellung für den Beleuchtungsmodus (set_mode) 80 Sekunden lang nicht ausgeführt wird. Dies ist eine Funktion zum Erkennen des oberen Programms.

Einzelheiten finden Sie im folgenden Quellcode.

Ich bin neu in Python und freue mich auf dein warmes Tsukkomi!

Testausführungsmethode:

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

Testausführungsmethode:

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)

Einschränkungen

• Berücksichtigt nicht die gleichzeitige Verwendung mehrerer Prozesse
• Volle Softwaresteuerung, so dass es unter Last auf dem System leicht flackern kann.
• Wenn GPIO für andere Zwecke verwendet wird, muss es geändert werden.
• Da es softwaregesteuert ist, verbraucht es etwas CPU. Der Python-Prozess macht etwa 2,5% von 1Core aus. Es scheint, dass es ungefähr 1% des gesamten 4Core verbraucht.

Bonus

So leuchtet es, wenn ein wichtiges Problem auftritt. In Kombination mit einem geeigneten Glockenspiel können Sie ein Gefühl der Dringlichkeit erzeugen. (Ich will es nicht zu viel sehen ...)

Die kuppelförmige Abdeckung, die die LED abdeckt, ist eine Ablenkung der LED-Lichtabdeckung, die bei Daiso verkauft wurde. Tatsächlich war es der schwierigste Teil der Hardware-Produktion, dieses Cover zu finden. (Lol)

Nächster Zeitplan

Nächstes Mal werde ich über das Modul Detektor schreiben, das Benachrichtigungen steuert.