Labs Pibrella

1. Carte Pibrella

https://www.diigo.com/outliner/fd6yst/pibrella?key=ck20nxkxx4

1.1. Description

PiBrella est une carte d'extension pour Raspberry Pi à usage multiple avec son, lumière, entrées et sorties. Elle prend un nombre élevé de broches GPIO tout en laissant les bus série, SPI et i2c libres.

PiBrella est conçu pour pouvoir fournir plus de courant que ne peut le faire le GPIO du Raspberry-Pi et la carte dispose même d'un connecteur d'alimentation USB pour fournir plus de puissance aux moteurs, relais et solénoïdes connectés sur les sorties (26 broches (pins) et 13 broches GPIO actifs)

Carte pibrella
Figure 6 : Carte pibrella
Emplacements carte pibrella
Figure 7 : Emplacements carte pibrella

Source : https://fr.pinout.xyz/pinout/pibrella

1.2. Montage

  1. Arrêtez le Raspberry Pi et déconnectez l'alimentation. Veuillez toujours arrêter proprement votre Pi avant de connecter des modules complémentaires.
  2. Fixez votre carte Pibrella. Elle s'insère bien sur l'en-tête GPIO pour le couvrir complètement.
  3. Connectez l'alimentation à la carte Pibrella. La prise ressemble à celle de votre Pi.

1.3. Installation des librairies Pibrella

sudo apt-get update && sudo apt-get -y upgrade
sudo apt-get -y install python-pip git

sudo pip install pibrella

git clone http://github.com/pimoroni/pibrella
cd pibrella/examples

ls -l
total 16
-rwxr-xr-x 1 pi pi  258 May  7 20:22 random-blink.py
-rwxr-xr-x 1 pi pi 2903 May  7 20:22 react.py
-rwxr-xr-x 1 pi pi 1120 May  7 20:22 siren.py
-rwxr-xr-x 1 pi pi 1123 May  7 20:22 test.py

cat siren.py
#!/usr/bin/env python

import os
import signal
import sys
import time

import pibrella


sys.path.insert(1, os.path.join(sys.path[0], '..'))

# Pulse all of the lights

TIME_ON = 0.2
TIME_OFF = 0.2
FADE_ON = 0.2
FADE_OFF = 0.2

# Play a siren

siren_stopped = True

def siren():
    if siren_stopped == True:
        pibrella.buzzer.stop()
        return True
    for x in xrange(-30,30,2):
        pibrella.buzzer.note(x)
        time.sleep(0.01)
    for x in reversed(xrange(-30,30,2)):
        pibrella.buzzer.note(x)
        time.sleep(0.01)


pibrella.async_start('siren',siren)

def start_siren():
    global siren_stopped
    siren_stopped = False
    pibrella.light.pulse(TIME_ON, TIME_OFF, FADE_ON, FADE_OFF)

def stop_siren():
    global siren_stopped
    siren_stopped = True
    pibrella.light.stop()

def handle_button(button):
    global siren_stopped
    if siren_stopped == True:
        start_siren()
        print("Starting Siren")
    else:
        stop_siren()
        print("Stopping Siren")

pibrella.button.released(handle_button)

# Sleep for 20 seconds

#time.sleep(20)

signal.pause()

# Exit!

sudo python siren.py

1.4. Un second exemple : Alarme

Source : http://pibrella.com/#projects

Entrer dans le shell Python.

sudo python -i

Ecrire un bout de code.

import pibrella
pibrella.buzzer.fail()
pibrella.light.pulse(0.2)

En terminer.

quit()

1.5. Un troisième exemple : une intrusion

Entrer dans le shell Python.

sudo python -i

Ecrire un bout de code.

# burglar alarm! (catches grinches and gruffalos)
import pibrella, signal

def alarm(pin):
   pibrella.buzzer.fail()        # make some noise
   pibrella.light.pulse()        # flash lights

def reset(pin):
   pibrella.light.stop()         # reset alarm

pibrella.input.a.changed(alarm)  # listen for intruder
pibrella.button.pressed(reset)   # in case of stupid cat

signal.pause()                   # waiting for intruder

Maintenant, activez l'entrée A ! Connectez les 2 broches de l'entrée A avec un fil ou une résistance. (Appuyez sur le gros bouton rouge pour réinitialiser)

1.6. Premières étapes

Source : https://github.com/pimoroni/pibrella/blob/master/README.md

Lancer le shell Python.

sudo python -i

Charger la librairie Pibrella qui va configurer les GPIO et collecter toutes les entrées et sorties en objets manipulables.

import pibrella

Allumer la LED rouge.

pibrella.light.red.on()

Eteindre la LED rouge.

pibrella.light.red.off()

Les collections ( lights, inputs, outputs ) permettent de contrôler un groupe de choses en même temps. Pour éteindre toutes les LEDs.

pibrella.light.off()

Pour allumer toutes les LEDs

pibrella.light.on()

1.7. LEDs clignotantes et à pulsation

Les LEDs peuvent être pulsée, décolorée, clignotantes et stroboscopiques.

pibrella.light.red.blink(ON_TIME, OFF_TIME)

Par pulsation.

pibrella.light.red.pulse(FADE_IN_TIME, FADE_OUT_TIME, ON_TIME, OFF_TIME)

Voici des équivalents.

pibrella.light.red.pulse(0, 0, 1, 1)
pibrella.light.red.blink(1, 1)

Un fondu d'une luminosité à l'autre.

pibrella.light.red.fade(0, 100, 2) # From 0 to 100% in 2 seconds

1.8. Entrées et sorties

Les collections d'entrée et de sortie correspondent aux quatre pins d'entrée et quatre pins de sortie de la carte Pibrella. Ceux-ci sont nommés a, b, c, d pour les entrées et e, f, g, h pour les sorties - vous verrez ces étiquettes sur la carte elle-même.

Pour activer la sortie "e".

pibrella.output.e.on()

On peut aussi écrire une valeur explicite :

  • 1 correspond à "on/high"

  • 0 correspond à "off/low"

    pibrella.output.e.write(1)

C'est utile si on souhaite activer et désactiver un pin par programmation ou écrire une valeur d'entrée directement sur une sortie.

Et on peut écrire simultanément sur l'ensemble de la collection de sortie si on le souhaite.

pibrella.output.write(1)

Les entrées fonctionnent de manière semblable sauf qu'on les lit au lieu de les écrire en "on" ou en "off".

Pour lire une seule entrée.

my_value = pibrella.input.a.read()

Ou pour lire toutes les entrées dans un dictionnaire.

inputs = pibrella.input.read()
input_a = inputs['a']

1.9. Le bouton

Le bouton de la carte Pibrella est juste une autre entrée. Il dispose toutefois d'une résistance pull-down qui l'empêche de lire les fluctuations électriques aléatoires comme des pressions de bouton.

Comme toute autre entrée, vous pouvez lire l'état du bouton à tout moment:

pibrella.button.read()

1.10. Le buzzer

Le buzzer est juste une autre sortie. Cependant, le fait de l'allumer et de l'éteindre ne vous rapportera pas beaucoup plus qu'un simple pop, il faut le basculer rapidement pour obtenir un son continu. Nous avons fourni des fonctions pour cela.

D'abord, on peut buzzer sur une fréquence spécifique.

pibrella.buzzer.buzz( frequency )

Ou jouer une note (on peut utiliser des valeurs positives et négatives ici, avec 0 à A à 440Hz).

pibrella.buzzer.note( 1 )

Ou jouer une tonalité incluse.

pibrella.buzzer.fail()
pibrella.buzzer.success()

1.11. Manipulation d'événements

"changed", "pressed", "released".

Si on veut capturer un état de changement d'entrée et exécuter une fonction spécifique, on peut utiliser "changed" (changé), "pressed" (pressé) et "released" (relâché) sur l'une des entrées ou sur le bouton. "changed" (changé) se déclenchera quand une broche passera de 1 (high / on) à 0 (low / off) ou vice versa. "pressed" (pressé) se déclenche quand il passe de 0 à 1, et "released" (relâché) quand il passe de 1 à 0.

Par exemple.

def button_pressed(pin):
    print("You pressed the button!")

pibrella.button.pressed(button_pressed)

pibrella.pause()

La commande pibrella.pause () est ici pour empêcher la sortie immédiate du programme et permet de maintenir votre programme occupé.

Le paramètre "pin" de la fonction bouton pressé est le pin de la carte Pibrella qui a déclenché l'évènement, dans ce cas "pin" sera égal à "pibrella.button".

def button_changed(pin):
    if pin.read() == 1:
        print("You pressed the button!")
    else:
        print("You released the button!")

pibrella.button.changed(button_changed)

pibrella.pause()

Pour allumer une LED lorsque vous appuyez sur le bouton, votre code devrait ressembler à ceci:

import pibrella

def button_changed(pin):
    pibrella.light.red.write(pin.read())

pibrella.button.changed(button_changed)

pibrella.pause()

1.12. Référence rapide

Toutes les entrées, sorties et LEDs de la carte Pibrella sont stockées dans des collections. On peut référencer une broche par son nom ou son index de l'une des trois manières suivantes.

pibrella.light[0]        # By index
pibrella.light['red']    # By name, for use with a variable
pibrella.light.red       # By name

On peut également se référer à une collection entière en une seule fois, simplement en omettant l'index ou le nom:

pibrella.light

Aides

Pibrella a une petite aide intégrée. Pour connaître les noms des LEDs, des entrées ou des entrées.

pibrella.lights

pibrella.inputs

pibrella.outputs

LEDs

Les méthodes suivantes sont disponibles pour les LEDs de la carte pibrella.

.on()       # Allume le LED
.off()      # Etient le LED
.high()     # Allume le LED
.low()      # Etient le LED

.toggle() # Bascule l'état des lumières de allumé à éteint et éteint à allumé
# Si les LEDs clignotent / pulsent, la bascule les éteint toujours

.pulse( transition_on, transition_off, time_on, time_off )    # pulsations légères, valeurs en secondes
.blink( time_on, time_off )     # clignotement léger, valeurs en secondes
.write( value )                 # Allume si la valeur = 1, ou éteint si la valeur = 0

Sorties

Une sortie peut faire tout ce qu'un LED peut faire, ils sont identiques dans tout sauf le nom!

Entrées

Les méthodes suivantes sont disponibles pour chaque entrée Pibrella.

Général

 pibrella.pause () # Wrapper signal.pause(), idéal pour mettre votre application en pause après avoir appelé un clignotement, une impulsion ou une boucle

 pibrella.loop (nom_fonction) # Passez une fonction de pibrella à exécuter encore et encore, de manière asynchrone
 # Vous devez appeler pibrella.pause() après lui avoir donné une fonction pour faire une boucle, sinon le code échouera

1.13. Projets programme Disco

Source : https://github.com/raspberrypilearning/pibrella-intro/blob/master/worksheet.md

Projet 1 : Créer un programme de lumières aléatoires

En plus d'utiliser la bibliothèque pibrella dans un programme simple, vous pouvez également utiliser les fonctionnalités d'autres bibliothèques comme random ettime.

  1. Créez un nouveau fichier Python en tapant nano disco.py dans une fenêtre LXTerminal ou sur la ligne de commande. Un nouveau fichier de texte vide s'ouvre.

  2. Sur la première ligne, importez les bibliothèques que vous devrez utiliser:

    import pibrella, random, time

  3. Puis étiquetez chacune des LEDs comme ceci:

    red = pibrella.light.red
amber = pibrella.light.amber
green = pibrella.light.green

    Chaque étiquette est appelée une variable. Les variables sont utilisées ici pour stocker une longue commande comme raccourci pour l'étape suivante.

  4. En dessous, ajoutez les noms de couleurs à une liste comme celle-ci :

    colour = [red, amber, green]

    Des éléments, comme les couleurs, peuvent être stockés dans une liste et recevoir un nom en Python. Vous pouvez aussi écrire la liste comme ceci color = [pibrella.light.red, pibrella.light.amber, pibrella.light.green] au lieu d'utiliser des noms de variables pour stocker la commande.

  5. Maintenant que vous avez configuré le programme, créez une boucle en utilisant while True: qui sélectionne une couleur aléatoire dans la liste des couleurs, puis allume et éteint la lumière correspondante pendant 0,2 seconde. Attention à l'identation :

    while True:
   result = random.choice(colour)
   time.sleep(1)
   result.pulse(0.2)

    Au sein de cette boucle, qui se répète indéfiniment, vous avez utilisé la fonction random.choice pour sélectionner une couleur de la liste que vous avez créée aléatoirement, puis la stocker dans la variable appelée result. Après 1 seconde, le LED de couleur qui a été sélectionnée au hasard et puis est ensuite stocké dans la variable de résultat result qui va pulser pendant 0,2 seconde.

  6. Enregistrez et quittez en appuyant sur CTRL et X sur le clavier, puis sur Y ou O pour oui.

  7. Pour exécuter votre programme, tapez sudo python disco.py.
  8. Comme vous avez utilisé une boucle continue, ce programme ne se termine pas tant que vous n'appuyez pas sur les touches CTRL et C du clavier pour l'interrompre.

Projet 2 : Boucler 5 fois

Maintenant que vous avez un "disco light" en boucle, ajoutons du code pour qu'il ne se répète qu'un certain nombre de fois, plutôt que pour toujours.

  1. Ouvrez votre programme disco en tapant nano disco.py dans une fenêtre LXTerminal ou depuis la ligne de commande.
  2. A l'aide des flèches de votre clavier, naviguez vers le bas juste en dessous de la liste des couleurs et avant la boucle while. Tapez n = 0 pour stocker la valeur numérique 0 en tant que variable.

  3. Puis modifier la boucle while :

    n = 0

while n < 5:
   result = random.choice(colour)
   time.sleep(1)
   result.pulse(0.2)
   n = n + 1

    Au lieu de donner la commande while True: pour boucler pour toujours, vous avez utilisé while n <5: alors que n est inférieur ou égal à la valeur 5. Cela signifie que cette boucle ne se répète que sin contient une valeur inférieure à 5 ou 5. Vous avez déjà défini la valeur de n sur 0 avant le démarrage de la boucle. Ensuite, en bas de la boucle, vous avez ajouté la ligne n = n + 1 qui ajoutera 1 à la valeur à chaque tour de la boucle. Par exemple, 0 + 1, puis 1 + 1, puis 2 + 1, etc., chaque fois que vous stockez la nouvelle valeur dans la variable n.

  4. Enregistrez et quittez en appuyant sur CTRL et X sur le clavier, puis sur Y ou O pour oui.

  5. Pour exécuter votre programme, tapez sudo python disco.py.

Projet 3 : Utiliser une fonction pour stocker votre boucle de lumière disco

Les fonctions vous permettent de stocker des parties de code pour pouvoir les réutiliser plus tard. Mettons votre nouvelle boucle dans une fonction.

  1. Avec votre programme disco.py ouvert, naviguez jusqu'à la ligne n = 0 et enveloppez votre code dans une fonction comme celle-ci:

    def disco():
   n = 0
   while n < 5:
       result = random.choice(colour)
       time.sleep(1)
       result.pulse(0.2)
       n = n + 1

    Si vous lancez votre programme maintenant, rien ne se passera. Comme les variables, vous avez donné un nom à ce morceau de code mais ous ne l'avez pas encore appelé pour fonctionner !

  2. Sous la boucle, tapez disco().

  3. Maintenant, sauvegardez et exécutez le code pour voir ce qui se passe!

Projet 4: Utiliser un bouton pour démarrer votre programme Disco

Maintenant que vous avez un programme disco Pibrella fonctionnel, vous pouvez commencer à utiliser certains des autres éléments sur la carte Pibrella, par exemple un bouton d'entrée pour déclencher le programme. Placer le code de bouclage dans une fonction rend les choses plus aisées.

  1. Sous la fonction disco, créez une boucle répétitive infinie :

    while True:
   if pibrella.button.read():
       disco()

    L'intérieur de la boucle est une condition, ce qui signifie que la fonction disco ne sera déclenchée que si la condition est remplie. Dans ce cas, la condition est remplie lorsque le bouton est enfoncé.

  2. Enregistrez votre code et exécutez-le pour voir ce qui se passe.

  3. Vous avez peut-être remarqué que les lumières clignotent maintenant. Vous pouvez sortir de la boucle continue après 5 secondes en tapant break à l'intérieur de la boucle while True: :

    while True:
   if pibrella.button.read():
       disco()
       time.sleep(5)
       break

1.14. Exemple de feu de signalisation

Cet exemple pourrait trouver des adaptations.

Source : https://github.com/johnblackmore/pibrella-adventures

## Basic (UK) Traffic Light Example
#
# When the Pibrella button is pressed, loop through the traffic light sequence.
# In the UK this is Red and Amber, Green, Amber, Red.

import pibrella, time

# Traffic light sequence, each light represents the red, amber and green light values and a time delay
sequence = [
    [1, 1, 0, 1],
    [0, 0, 1, 5],
    [0, 1, 0, 2],
    [1, 0, 0, 1]
]

# Callback function to process button presses
def button_changed(pin):
    if pin.read() == 1:
        traffic_light()

# Simple function to loop the traffic light sequence
def traffic_light():
    for i in sequence:
        pibrella.light.red.write(i[0])
        pibrella.light.yellow.write(i[1])
        pibrella.light.green.write(i[2])
        time.sleep(i[3])

# Set initial state (red light)
pibrella.light.red.on()

# Register the button press callback
pibrella.button.changed(button_changed)

# Wait for input
pibrella.pause()

1.15. Lumières aléatoires

cd ~/pibrella/examples

cat random-blink.py
#!/usr/bin/env python

import random
import time

import pibrella


"""
This example will blink an LED at random
"""

while True:
  with random.choice(pibrella.light) as l: # Pick a random light
    l.on()
    time.sleep(0.5)
    l.off()
    time.sleep(0.5)

sudo python random-blink.py

1.16. Jeux de réaction

Appuyer le plus vite possible sur le bouton quand le LED rouge s'allume.

cd ~/pibrella/examples
sudo python react.py

1.17. Sources à consulter

2. Node-Red

2.1. JavaScript

JavaScript est un langage de programmation de scripts principalement employé dans les pages web interactives mais aussi pour les serveurs avec l'utilisation (par exemple) de Node.js. A ne pas confondre avec Java.

2.2. Node.js

Node.js est une plateforme logicielle libre et événementielle en JavaScript orientée vers les applications réseau qui doivent pouvoir monter en charge.

Elle utilise la machine virtuelle V8 et implémente sous licence MIT les spécifications CommonJS.

Parmi les modules natifs de Node.js, on retrouve http qui permet le développement de serveur HTTP. Il est donc possible de se passer de serveurs web tels que Nginx ou Apache lors du déploiement de sites et d'applications web développés avec Node.js.

2.3. Node-RED

Node-RED est un outil de programmation basé sur les flux, original développé par l'équipe Emerging Technology Services d'IBM et maintenant membre de la JS Fondation.

Inventée par J. Paul Morrison dans les années 1970, la programmation basée sur les flux est une façon de décrire le comportement d'une application sous la forme d'un réseau de boîtes noires, ou "noeuds" comme on les appelle dans Node-RED. Chaque "noeud" a un but bien défini ; on lui donne des données, il en fait quelque chose et ensuite il les transmet. Le réseau est responsable du flux de données entre les noeuds.

C'est un modèle qui se prête très bien à une représentation visuelle et le rend plus accessible à un plus grand nombre d'utilisateurs. Si quelqu'un peut décomposer un problème en étapes discrètes, il peut regarder un flux et avoir une idée de ce qu'il fait; sans avoir à comprendre les différentes lignes de code dans chaque noeud.

Node-RED consiste en une exécution basée sur Node.js que vous appelez dans un navigateur Web pour accéder à l'éditeur de flux. Dans le navigateur, vous créez votre application en faisant glisser les noeuds de votre palette dans un espace de travail et vous pouvez commencer à les relier entre eux. En un seul clic, l'application est redéployée (deploy) dans l'environnement d'exécution où elle est exécutée.

La palette de nœuds peut être facilement étendue en installant de nouveaux noeuds créés par la communauté et les flux que vous créez peuvent être facilement partagés en tant que fichiers JSON.

En bref, pour l'histoire, Node-RED a vu le jour début 2013 sous la forme d'un projet parallèle de Nick O'Leary et Dave Conway-Jones du groupe IBM Emerging Technology Services. Démarré comme une preuve de concept pour visualiser et manipuler les correspondances entre les sujets MQTT, Node-RED est rapidement devenu un outil beaucoup plus général qui pourrait facilement être étendu dans n'importe quelle direction. Il a été ouvert en septembre 2013 et a été développé à l'extérieur depuis, ce qui en a fait l'un des projets fondateurs de la JS Fondation en octobre 2016.

2.4. Installation de Node-RED sur Rpi

Pour installer ou mettre à jour en utilisant la commande de script de mise à niveau Node-RED.

bash <(curl -sL https://raw.githubusercontent.com/node-red/raspbian-deb-package/master/resources/update-nodejs-and-nodered)

sudo systemctl enable nodered.service

2.5. Ajout d'un noeud

Procédure d'ajout d'un noeud (https://flows.nodered.org/?num_pages=1)

cd ~/.node-red
npm install node-red-{example node name}

Installation du noeud pibrella.

cd ~/.node-red
npm install node-red-node-pibrella
sudo reboot

2.6. Traffic Light Simulator

Input and Output controls for Pibrella on Raspberry Pi

Flux du lab Traffic Light Simulator
Figure 8 : Flux du lab Traffic Light Simulator
[
    {
        "id": "79097754.9d1008",
        "type": "rpi-gpio in",
        "z": "18cae352.8e61fd",
        "name": "red button",
        "pin": "23",
        "intype": "tri",
        "x": 220.31746673583984,
        "y": 948.7460508346558,
        "wires": [
            [
                "c67ca9d5.dee8c8"
            ]
        ]
    },
    {
        "id": "caa28bcf.fa1ec8",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "red",
        "pin": "13",
        "x": 741.3174667358398,
        "y": 1062.7460508346558,
        "wires": []
    },
    {
        "id": "93fb6475.cc9ec8",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "green",
        "pin": "7",
        "x": 1076.3174667358398,
        "y": 1172.7460508346558,
        "wires": []
    },
    {
        "id": "a5be988a.307c48",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "amber",
        "pin": "11",
        "x": 565.3174667358398,
        "y": 1013.7460508346558,
        "wires": []
    },
    {
        "id": "d170d63.0c5e528",
        "type": "delay",
        "z": "18cae352.8e61fd",
        "name": "",
        "pauseType": "delay",
        "timeout": "5",
        "timeoutUnits": "seconds",
        "rate": "1",
        "rateUnits": "second",
        "randomFirst": "1",
        "randomLast": "5",
        "randomUnits": "seconds",
        "x": 562.3174667358398,
        "y": 1061.7460508346558,
        "wires": [
            [
                "caa28bcf.fa1ec8",
                "b4d9ee9b.b9122",
                "ae7203e7.f294"
            ]
        ]
    },
    {
        "id": "b4d9ee9b.b9122",
        "type": "delay",
        "z": "18cae352.8e61fd",
        "name": "",
        "pauseType": "delay",
        "timeout": "10",
        "timeoutUnits": "seconds",
        "rate": "1",
        "rateUnits": "second",
        "randomFirst": "1",
        "randomLast": "5",
        "randomUnits": "seconds",
        "x": 743.3174667358398,
        "y": 1108.7460508346558,
        "wires": [
            [
                "b12d97db.ebf498",
                "9e8fbbbc.daaa38"
            ]
        ]
    },
    {
        "id": "b12d97db.ebf498",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "amber",
        "pin": "11",
        "x": 917.3174667358398,
        "y": 1108.7460508346558,
        "wires": []
    },
    {
        "id": "9e8fbbbc.daaa38",
        "type": "delay",
        "z": "18cae352.8e61fd",
        "name": "",
        "pauseType": "delay",
        "timeout": "5",
        "timeoutUnits": "seconds",
        "rate": "1",
        "rateUnits": "second",
        "randomFirst": "1",
        "randomLast": "5",
        "randomUnits": "seconds",
        "x": 932.3174667358398,
        "y": 1171.7460508346558,
        "wires": [
            [
                "93fb6475.cc9ec8",
                "d4a1805d.081f1"
            ]
        ]
    },
    {
        "id": "ae7203e7.f294",
        "type": "function",
        "z": "18cae352.8e61fd",
        "name": "0",
        "func": "msg.payload = 0;\n\n\nreturn msg;",
        "outputs": 1,
        "x": 745.3174667358398,
        "y": 1019.7460508346558,
        "wires": [
            [
                "4e806e7a.9f6ed"
            ]
        ]
    },
    {
        "id": "4e806e7a.9f6ed",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "amber",
        "pin": "11",
        "x": 892.3174667358398,
        "y": 1019.7460508346558,
        "wires": []
    },
    {
        "id": "d4a1805d.081f1",
        "type": "function",
        "z": "18cae352.8e61fd",
        "name": "0",
        "func": "msg.payload = 0;\n\n\nreturn msg;",
        "outputs": 1,
        "x": 1074.3174667358398,
        "y": 1131.7460508346558,
        "wires": [
            [
                "8e502ad3.72f6c8",
                "b7290695.3cb028"
            ]
        ]
    },
    {
        "id": "b7290695.3cb028",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "red",
        "pin": "13",
        "x": 1230.3174667358398,
        "y": 1143.7460508346558,
        "wires": []
    },
    {
        "id": "8e502ad3.72f6c8",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "amber",
        "pin": "11",
        "x": 1228.3174667358398,
        "y": 1099.7460508346558,
        "wires": []
    },
    {
        "id": "c67ca9d5.dee8c8",
        "type": "function",
        "z": "18cae352.8e61fd",
        "name": "rising edge",
        "func": "if (msg.payload == 1)\n{\n  return msg;\n}\nelse\n{\n  return null;\n}\n",
        "outputs": 1,
        "x": 355.31746673583984,
        "y": 949.7460508346558,
        "wires": [
            [
                "a5be988a.307c48",
                "d170d63.0c5e528",
                "7b7a0e4d.15e3"
            ]
        ]
    },
    {
        "id": "7b7a0e4d.15e3",
        "type": "function",
        "z": "18cae352.8e61fd",
        "name": "0",
        "func": "msg.payload = 0;\n\n\nreturn msg;",
        "outputs": 1,
        "x": 566.3174667358398,
        "y": 964.7460508346558,
        "wires": [
            [
                "9f95082e.8a4708"
            ]
        ]
    },
    {
        "id": "9f95082e.8a4708",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "green",
        "pin": "7",
        "x": 723.3174667358398,
        "y": 963.7460508346558,
        "wires": []
    },
    {
        "id": "67545769.bfc408",
        "type": "inject",
        "z": "18cae352.8e61fd",
        "name": "initialise to green",
        "topic": "",
        "payload": "1",
        "repeat": "",
        "crontab": "",
        "once": false,
        "x": 229.31746673583984,
        "y": 865.746036529541,
        "wires": [
            [
                "6c3ffc3a.1bba34"
            ]
        ]
    },
    {
        "id": "b37bb59f.47e5d8",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "green",
        "pin": "7",
        "x": 554.3174667358398,
        "y": 879.7460508346558,
        "wires": []
    },
    {
        "id": "1fadc29c.6a01dd",
        "type": "function",
        "z": "18cae352.8e61fd",
        "name": "0",
        "func": "msg.payload = 0;\n\n\nreturn msg;",
        "outputs": 1,
        "noerr": 0,
        "x": 560.3174667358398,
        "y": 826.7460508346558,
        "wires": [
            [
                "97949c1c.841bd",
                "e447c19a.3922b"
            ]
        ]
    },
    {
        "id": "97949c1c.841bd",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "amber",
        "pin": "11",
        "x": 698.3174667358398,
        "y": 803.7460508346558,
        "wires": []
    },
    {
        "id": "e447c19a.3922b",
        "type": "rpi-gpio out",
        "z": "18cae352.8e61fd",
        "name": "red",
        "pin": "13",
        "x": 696.3174667358398,
        "y": 848.7460508346558,
        "wires": []
    },
    {
        "id": "6c3ffc3a.1bba34",
        "type": "delay",
        "z": "18cae352.8e61fd",
        "name": "",
        "pauseType": "delay",
        "timeout": "1",
        "timeoutUnits": "seconds",
        "rate": "1",
        "rateUnits": "second",
        "randomFirst": "1",
        "randomLast": "5",
        "randomUnits": "seconds",
        "x": 388.31746673583984,
        "y": 866.7460508346558,
        "wires": [
            [
                "1fadc29c.6a01dd",
                "b37bb59f.47e5d8"
            ]
        ]
    },
    {
        "id": "105d33b8.58904c",
        "type": "comment",
        "z": "18cae352.8e61fd",
        "name": "traffic light simulator - push the red button!",
        "info": "",
        "x": 305.3174819946289,
        "y": 771.412769317627,
        "wires": []
    }
]

2.7. Lab Twitter

Flux du lab Twitter
Figure 9 : Flux du lab Twitter
[
    {
        "id": "4f4c115b.b9b8c",
        "type": "tab",
        "label": "pibrella twitter",
        "disabled": false,
        "info": ""
    },
    {
        "id": "c8047d70.90478",
        "type": "rpi-pibrella in",
        "z": "4f4c115b.b9b8c",
        "name": "Red button #redled",
        "pin": "Red Button",
        "read": false,
        "x": 285.5,
        "y": 248,
        "wires": [
            [
                "bc404312.ede54"
            ]
        ]
    },
    {
        "id": "c13b8e4a.b1af1",
        "type": "debug",
        "z": "4f4c115b.b9b8c",
        "name": "",
        "active": true,
        "tosidebar": true,
        "console": false,
        "tostatus": false,
        "complete": "false",
        "x": 925.5,
        "y": 133,
        "wires": []
    },
    {
        "id": "bc404312.ede54",
        "type": "switch",
        "z": "4f4c115b.b9b8c",
        "name": "",
        "property": "payload",
        "propertyType": "msg",
        "rules": [
            {
                "t": "eq",
                "v": "1",
                "vt": "str"
            }
        ],
        "checkall": "true",
        "repair": false,
        "outputs": 1,
        "x": 481.5,
        "y": 248,
        "wires": [
            [
                "8c019734.aa9f68"
            ]
        ]
    },
    {
        "id": "8c019734.aa9f68",
        "type": "function",
        "z": "4f4c115b.b9b8c",
        "name": "tag + timestamp",
        "func": "msg.payload = \"#redled \" + new Date().toString();\nreturn msg;",
        "outputs": 1,
        "noerr": 0,
        "x": 688.5,
        "y": 247,
        "wires": [
            [
                "c13b8e4a.b1af1",
                "b48e4f16.304e9",
                "8bca00da.05563"
            ]
        ]
    },
    {
        "id": "5ba72bf0.e5f144",
        "type": "trigger",
        "z": "4f4c115b.b9b8c",
        "op1": "1",
        "op2": "0",
        "op1type": "str",
        "op2type": "str",
        "duration": "5",
        "extend": false,
        "units": "s",
        "reset": "",
        "bytopic": "all",
        "name": "",
        "x": 501.5,
        "y": 412,
        "wires": [
            [
                "8f465102.d37f9",
                "2116a5f7.66d95a"
            ]
        ]
    },
    {
        "id": "8f465102.d37f9",
        "type": "rpi-pibrella out",
        "z": "4f4c115b.b9b8c",
        "name": "",
        "pin": "Red LED",
        "set": false,
        "level": "0",
        "out": "out",
        "x": 741.5,
        "y": 411,
        "wires": []
    },
    {
        "id": "b48e4f16.304e9",
        "type": "twitter out",
        "z": "4f4c115b.b9b8c",
        "twitter": "",
        "name": "Tweet @feglab",
        "x": 932.5,
        "y": 196,
        "wires": []
    },
    {
        "id": "8078dfcf.be61",
        "type": "twitter in",
        "z": "4f4c115b.b9b8c",
        "twitter": "",
        "tags": "#redled",
        "user": "false",
        "name": "#redled tag catch",
        "topic": "tweets",
        "inputs": 0,
        "x": 273.5,
        "y": 412,
        "wires": [
            [
                "5ba72bf0.e5f144"
            ]
        ]
    },
    {
        "id": "2116a5f7.66d95a",
        "type": "rpi-pibrella out",
        "z": "4f4c115b.b9b8c",
        "name": "",
        "pin": "Buzzer ",
        "set": false,
        "level": "0",
        "out": "out",
        "x": 736.5,
        "y": 497,
        "wires": []
    },
    {
        "id": "b2a7b089.d2dca",
        "type": "rpi-pibrella out",
        "z": "4f4c115b.b9b8c",
        "name": "",
        "pin": "Green LED",
        "set": true,
        "level": "0",
        "out": "out",
        "x": 1108.5,
        "y": 246,
        "wires": []
    },
    {
        "id": "8bca00da.05563",
        "type": "trigger",
        "z": "4f4c115b.b9b8c",
        "op1": "1",
        "op2": "0",
        "op1type": "str",
        "op2type": "str",
        "duration": "3",
        "extend": false,
        "units": "s",
        "reset": "",
        "bytopic": "all",
        "name": "",
        "x": 911.5,
        "y": 246,
        "wires": [
            [
                "b2a7b089.d2dca"
            ]
        ]
    },
    {
        "id": "1f08f815.f2d758",
        "type": "comment",
        "z": "4f4c115b.b9b8c",
        "name": "Envoi d'un tweet",
        "info": "Le bouton envoit un tweet avec le hastag #redled et un timestamp",
        "x": 277.5,
        "y": 174,
        "wires": []
    },
    {
        "id": "3ad4c9d0.ae9486",
        "type": "comment",
        "z": "4f4c115b.b9b8c",
        "name": "Réception d'un tweet",
        "info": "A la réception d'un tweet avec le hashtag #redled la LED rouge s'allume et le buzzer s'enclenche",
        "x": 287.5,
        "y": 338,
        "wires": []
    }
]

2.8. Lab Picam Photobooth

2.9. Lab Appel SIP

Ce Lab s'intègre au déploiement de raspbx et relève juste de la preuve de concept.

Sur le raspberry pi avec la carte pibrella, installer linphone :

sudo apt-get update
sudo apt-get install linphone-nogtk

Créer un script dans /home/pi/sipcall.sh

#!/bin/bash
proc=$(ps aux | egrep "linphonec --pipe" | awk '{print $2}') ; kill -9 ${proc}
/usr/bin/linphonecsh init
sleep 3
/usr/bin/linphonecsh register --host raspbx00 --username 3303 --password test1234
sleep 3
/usr/bin/linphonecsh dial "sip:2202@raspbx00"
sleep 3
proc=$(ps aux | egrep "linphonec" | awk '{print $2}') ; kill -9 ${proc}

Dans Node-Red, le flux suivant exécute le script et allume la LED rouge pendant 9 secondes.

Flux bouton rouga / appel SIP
Figure 10 : Flux bouton rouga / appel SIP
[{"id":"28c50c57.cc9684","type":"exec","z":"7cf14d54.8b0744","command":"sudo bash -x /home/pi/sipcall.sh","addpay":true,"append":"","useSpawn":"true","timer":"","oldrc":false,"name":"","x":580.5,"y":273.5,"wires":[["12af2c1a.dfde14"],[],[]]},{"id":"f574d105.ad4be","type":"rpi-pibrella in","z":"7cf14d54.8b0744","name":"","pin":"Red Button","read":false,"x":135.5,"y":243,"wires":[["8b712ca5.fc59f","f2adcc8.a55a33"]]},{"id":"12af2c1a.dfde14","type":"debug","z":"7cf14d54.8b0744","name":"","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"false","x":815.5,"y":260,"wires":[]},{"id":"8b712ca5.fc59f","type":"trigger","z":"7cf14d54.8b0744","op1":"1","op2":"0","op1type":"str","op2type":"str","duration":"1","extend":false,"units":"s","reset":"","bytopic":"all","name":"","x":332.5,"y":274,"wires":[["28c50c57.cc9684"]]},{"id":"66aca6b.a723458","type":"rpi-pibrella out","z":"7cf14d54.8b0744","name":"","pin":"Red LED","set":false,"level":"0","out":"out","x":507.5,"y":199,"wires":[]},{"id":"f2adcc8.a55a33","type":"trigger","z":"7cf14d54.8b0744","op1":"1","op2":"0","op1type":"str","op2type":"str","duration":"9","extend":false,"units":"s","reset":"","bytopic":"all","name":"","x":331.5,"y":200,"wires":[["66aca6b.a723458"]]}]

Le destinataire sonne ...

Pour des scripts de communication SIP, il est préférable d'utiliser la librairie PJSIP.

...

2.10. Lab Node-RED HTTP

...

results matching ""

    No results matching ""