Raspberry Pi "Lampe de notification Honwaka" Partie 3

Aide à surveiller avec Raspberry Pi

Dans cette série, nous allons créer une lampe de notification à l'aide de Raspberry Pi.

Cette fois, la troisième fois, c'est la partie principale qui contrôle l'ensemble de la "lampe de notification". Cette série est maintenant terminée.

Présentation d'Abu

Alert Buster (Abu en abrégé) est chargé d'acquérir les informations d'alerte OpsGenie via le détecteur, d'identifier l'état de l'objet surveillé et de régler l'affichage LED. C'est aussi le travail d'Abu de sonner le carillon une seule fois lorsqu'une nouvelle alerte se produit.

Un seul état peut afficher le "voyant de notification" pour l'état d'alerte qui peut exister plus d'une fois en même temps. Par conséquent, donnez la priorité aux états pour afficher l'état de priorité le plus élevé.

Relation entre l'état géré par Abu et l'affichage

Abu gère les 6 types suivants. Il existe deux niveaux, "Erreur" et "Avertissement". «Erreur» signifie quelque chose à traiter rapidement, et «avertissement» signifie quelque chose qui n'est pas pressé mais qui doit être confirmé. Il y a deux états, qu'ils aient été reconnus ou non.

«Inconnu» est utilisé lorsque l'état est inconnu, par exemple immédiatement après le démarrage ou en raison d'un problème de réseau. Décidez de la couleur à attribuer à chaque état et du cycle de clignotement. Pour les noms de couleur tels que "Magenta", utilisez ceux définis dans Led.COLORS dans l'article précédent.

Abu traite ces états comme une seule valeur entière "valeur d'état". Pour "valeur d'état", attribuez chaque valeur de bit du nombre binaire afin qu'il soit facile à manipuler dans le calcul de bit. "Normal" signifie que tous les bits sont à 0, donc il n'y a pas d'allocation de bits.

En interne, la somme logique de 7 bits, y compris les indicateurs de contrôle du carillon dans le tableau ci-dessus, est utilisée comme une valeur d'état. Par exemple, s'il y a une nouvelle erreur qui n'a pas encore été reconnue (avant que le carillon ne retentisse), la valeur d'état est 0x22.

La valeur d'état est représentée par une seule valeur entière qui a une signification pour chaque bit, mais vous pouvez utiliser le type Set de Python en mettant l'accent sur la lisibilité.

carillon

Comment sonner

Lorsqu'une nouvelle erreur ou un nouvel avertissement est détecté, le carillon ne retentit qu'une seule fois pour le rendre plus facile à remarquer. Le carillon lit le fichier son préparé en le passant à la commande aplay.

python

$ aplay --quiet /usr/share/sounds/alsa/Rear_Center.wav

À l'avance, connectez un haut-parleur à la prise pour écouteurs ou au port USB de l'unité principale et réglez-le de manière à ce que le son puisse être entendu. Référence: https://www.google.co.jp/search?q=raspberrypi+aplay

source sonore

La source sonore du carillon peut être n'importe quel format pris en charge par aplay. À Abu, j'ai utilisé ce qui suit de freesound.org. Si vous vous enregistrez en tant qu'utilisateur, vous pouvez le télécharger, alors vérifiez la licence et utilisez-la.

• Warning J'ai choisi un son modeste, du moment que je pouvais le remarquer. 112860__paulnorthyorks__eighties-synth.wav http://www.freesound.org/people/paulnorthyorks/sounds/112860/

• Error J'ai choisi un son qui semble tendu. Le son suivant est traité pour créer et utiliser une source sonore qui se répète 3 fois. 204425__jaraxe__alarmx3.wav http://www.freesound.org/people/JarAxe/sounds/204425/ J'ai utilisé Audacity pour le traitement.

Comportement d'Abu

Le travail d'Abu est le suivant.

--Initialiser le détecteur

• Lancez LED Deamon
• Répétez ce qui suit --Appeler Detector pour obtenir une liste d'alertes --Recueillir des listes d'alertes et créer des valeurs de statut --Réglez l'affichage LED en fonction de la valeur d'état
• Faire retentir le carillon s'il y a une nouvelle erreur ou un nouvel avertissement --Dormez 1 minute

méthode de départ

$ ./abu.py ********-****-****-****-************

********-****-****-****-************Pour la partie, spécifiez la clé api opsgenie introduite dans l'article précédent. Lors de l'enregistrement dans cron pour qu'il démarre automatiquement au démarrage du système d'exploitation, il est recommandé de l'ajouter à cron comme suit, par exemple.

$ crontab -e
@reboot cd path-to-module-dir;./abu.py ********-****-****-****-************ >/dev/nul 2>&1

Code source

abu.py

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


import time
import os
from opsgenie import OpsGenie
from led_deamon import LedDeamon


class Abu(object):
    DOWN = 1
    ERR_UNACKED = 2
    WARN_UNACKED = 4
    ERR_ACKED = 8
    WARN_ACKED = 16
    ERR_NEW = 32
    WARN_NEW = 64
    NORMAL = 0
    ERROR_SOUND = "./204425__jaraxe__alarm-2.wav"
    WARNING_SOUND = "./112860__paulnorthyorks__eighties-synth.wav"

    STATE_MAP = {
        DOWN: {"color": "Magenta", "interval": "0"},
        ERR_UNACKED: {"color": "Red", "interval": "0.5"},
        WARN_UNACKED: {"color": "Yellow", "interval": "4"},
        ERR_ACKED: {"color": "Green", "interval": "4"},
        WARN_ACKED: {"color": "Green", "interval": "8"},
        NORMAL: {"color": "Blue", "interval": "8"}}

    def _state2mode(self, state):
        if state == Abu.NORMAL:
            return Abu.STATE_MAP[Abu.NORMAL]
        for s in (Abu.DOWN, Abu.ERR_UNACKED, Abu.WARN_UNACKED,
                  Abu.ERR_ACKED, Abu.WARN_ACKED):
            if state & s:
                return Abu.STATE_MAP[s]
        else:
            return Abu.STATE_MAP[Abu.NORMAL]
            return None

    def __init__(self, url, api_key):
        self.opsgenie = OpsGenie(url, api_key)

    def _summarize(self, list):
        state = Abu.NORMAL
        if list is None:
            state = Abu.DOWN
        else:
            for l in list:
                if l["error"]:
                    if l["acknowledged"]:
                        state |= Abu.ERR_ACKED
                    else:
                        state |= Abu.ERR_UNACKED
                        if l["new"]:
                            state |= Abu.ERR_NEW
                else:
                    if l["acknowledged"]:
                        state |= Abu.WARN_ACKED
                    else:
                        state |= Abu.WARN_UNACKED
                        if l["new"]:
                            state |= Abu.WARN_NEW
        return state

    def start(self):
        ld = LedDeamon()
        ld.set_mode(self._state2mode(Abu.DOWN))
        ld.start()
        while True:
            alert_list = self.opsgenie.detector()
            # print alert_list
            state = self._summarize(alert_list)
            # print hex(state)
            mode = self._state2mode(state)
            if mode:
                ld.set_mode(mode)
            if state & Abu.ERR_NEW:
                os.system("aplay " + Abu.ERROR_SOUND + "&")
            else:
                if state & Abu.WARN_NEW:
                    os.system("aplay " + Abu.WARNING_SOUND + "&")
            time.sleep(60)

if __name__ == '__main__':
    import sys

    if len(sys.argv) != 2:
        print("Usage: %s 'api-key for your OpsGenie account'." % sys.argv[0])
        print("Example: %s ********-****-****-****-************." % sys.argv[0])
        print("You can get your OpsGenie account at https://www.opsgenie.com.")
        exit()
    apiKey = sys.argv[1]
    a = Abu(apiKey)
    a.start()

Regarder en arrière

Étudiants Python, j'ai essayé d'utiliser Raspberry Pi. Il existe également des bibliothèques GPIO bon marché, puissantes et faciles à utiliser, et j'ai trouvé qu'elles conviennent parfaitement à ces utilisations. Il y a eu des problèmes tels que le contrôle de la couleur des LED par PWM, le traitement asynchrone, la gestion des valeurs d'état, la coopération OpsGenie, etc., mais heureusement, nous avons pu trouver une solution raisonnable pour chacun, et nous avons pu la compléter. J'ai fait. La "lampe de signalisation" produite cette fois-ci se fond dans l'atmosphère du lieu de travail sans aucune gêne, et est utile en fonctionnement réel. Si vous êtes intéressé, essayez-le.

Cette série se termine par cet article, mais je le posterai à nouveau quand j'aurai l'idée suivante.