Planet RaspFR

Bienvenue sur ce planet dédié au Raspberry Pi
mais aussi autres micro-ordinateurs et aux imprimantes 3D de type DIY.

Si vous voulez ajouter votre blog, n'hésitez pas à nous contacter.
Nous vous donnons rendez-vous sur le forum RaspFR

Relevé de la télé-information sur Domoticz grâce à un Eco-devices

Aujourd’hui, nous allons vous présenter un guide permettant d’avoir un relevé de la télé-information sur Domoticz grâce à un Eco-devices.

Cela permettra de pouvoir suivre votre consommation sur l’interface domotique et de faire des scénarios en rapport avec ces consommations.

Vous pourrez alors grâce à un minimum de configuration économiser de l’énergie grâce à la remonté d’information sur votre serveur Domoticz.

Pré-requis / présentation :

DSC00162

Pour les besoins du test, nous avons utilisé du câble électrique 1.5mm², mais afin d’éviter les perturbations, nous vous conseillons sur de longue distance, d’utiliser du câble de téléphone, ou du câble réseau avec paire torsadée

Schéma électrique :

Eco1

Intégration de l’Eco-devices à Domoticz :

Il faut impérativement que la télé-information soit activée par EDF. Si ce n’est pas le cas, il faudra les appeler pour avoir accès à la télé-information.

Il faut aussi que le compteur EDF soit branché à l’Eco-Devices sur le même réseau que le Raspberry, avant d’attaquer le guide.

Pour intégrer l’Eco-Devices à Domoticz, c’est très simple.

Il suffit d’aller sur le dashboard de Domoticz.

Pour ce faire :

  • Ouvrez une page internet
  • Dans la barre d’adresse tapez : http://IPdomoticz:8080 (remplacer bien sûr IPdomoticz par l’ip de votre serveur Domoticz)

2016-07-21_144401

  • Cliquez sur le lien “Hardware”.

Cette page s’affiche alors :

2016-07-21_133626

  • Rentrez un nom à votre Eco-devices
  • Dans le menu déroulant Type, choisissez “Eco Devices via LAN interface”
  • Dans le champ Remote address, rentez l’adresse IP de votre Eco-Devices
  • Dans le champ Port, rentez “80”.
  • Cliquer enfin sur “Add”

L’Eco-devices devrait alors s’afficher dans le tableau au dessus.

Bien vérifier que dans les logs de domoticz, il n’y ai pas de message d’erreur Eco-devices.

2016-07-20_154752

Si vous avez des messages d’erreur, vérifiez la version de Domoticz et de votre Eco-devices et au besoin faite les mises à jour.

Intégration des compteurs virtuels sur Domoticz:

Pour intégrer les compteurs, il vous faut ajouter un matériel pour les compteurs virtuels.

Pour ce faire : 

  • Allez dans le dashboard de Domoticz :

2016-07-21_144401

  • Cliquer alors sur “Hardware”.
  • Entrez dans le champs Name : “COMPTEURVIRTUEL” par exemple
  • Choisir dans la liste déroulante pour le champ type : “Dummy (Does nothing use for virtual switches only)”
  • Cliquez ensuite sur le bouton “Add”
  • Dans le tableau au dessus “Dummy” devrait apparaître comme sur la copie d’écran ci-dessous :

2016-07-21_133718

  • Cliquez alors sur le bouton “Dashboard” en haut pour revenir au premier écran.

2016-07-21_144401

  • Cliquez alors sur “Devices”.

La page suivante apparaîtra :

2016-07-21_133745

  • Cliquez alors sur Not Used en haut à droite du tableau (il se peut que le compteur virtuel n’apparaisse que 5 minutes après la synchronisation entre les deux périphériques étant par défaut défini comme cela. N’hésitez pas à rafraîchir la page, si ce n’est pas le cas).
  • Vous devriez alors voir le périphérique ECODEVICE dans le tableau apparaître, comme sur la copie d’écran ci-dessous :

2016-07-21_140106

  • Pour activer ce compteur, cliquez sur le bouton vert avec une flèche blanche

Sans titre

  • Une fenêtre avec le nom Add Device devrait apparaître :

2016-07-21_140124

  • Indiquez le nom que vous souhaitez pour ce compteur.
  • Cliquez ensuite sur Add Device. Le compteur ECODEVICES devrait alors apparaître dans les compteurs Used et AllDevices
  • Pour voir votre compteur maintenant cliquer sur le bouton “Utility” en haut à droite de la fenêtre :

2016-07-21_150004

  • Vous aurez accès au graphique grâce au bouton “Log”

2016-07-21_150144

La synchronisation par défaut se fait toutes les 5 minutes.

Vous pourrez alors le vérifier dans les Logs de Domoticz.

Capture

Conclusion

Vous pourrez maintenant avoir un relevé et des graphiques de votre consommation électrique grâce à l’Eco-devices sur Domoticz.

Cet article Relevé de la télé-information sur Domoticz grâce à un Eco-devices est apparu en premier sur ..:: Planète-Domotique : Le Blog ::...

La Saga Blink : Un Raspberry pour faire clignoter une LED !

SagaBlink_250pxJe dis toujours : « Avant de vous lancer dans un projet de tondeuse à gazon guidée par GPS avec évitement d’obstacles à laser et retour vidéo, apprenez déjà à allumer une LED 🙂  » …
yell_blEnfin, vous faites comme vous voulez, ce n’est que mon avis… Patrice nous propose dans son premier article pour framboise314 de faire clignoter une LED avec un Raspberry Pi … Un tracteur pour déplacer un œuf me direz vous !
Mais La Saga Blink aborde de nombreuse façons de le faire. Au menu: bash, Python, nodejs, wiringpi, pigpio, Rpi.GPIO …

Introduction

LED_breadboard

Figure 1 : RaspberryPi et sa LED

Rien de neuf sous les tropiques car il existe une multitude de tutoriels, de présentations et autres billets sur le sujet. La présentation s’adresse aux débutants expérimentés c’est à dire ceux qui disposent d’un Raspberry Pi opérationnel et qui n’ont pas peur d’utiliser la console pour l’élaboration des programmes. Les experts n’ont pas besoin de cette présentation et la trouveront certainement inutile.
Il faut, à un moment donné, un début.
Faire clignoter une LED sur le Raspberry Pi ou autres cartes consœurs (Arduino, ChipKit, LaunchPad, etc…) est le pendant du traditionnel « Hello World ! » de l’apprentissage d’un langage de programmation.

 Base d’expérimentation.

Pour notre expérimentation, il nous faut :

  • Un raspberry Pi opérationnel,
  • Une LED,
  • Une résistance de 330 Ω (ou entre 330 et 470 Ω).

 Schéma électronique

connexion_LED_shema

Figure 2 : Schéma électronique

L’anode de la diode LED (patte longue) est raccordée à la sortie GPIO23 (broche 16 du connecteur P5).
La cathode (patte courte) est reliée à la masse du Raspberry Pi (Ground), par exemple la pin 20 du connecteur P5.
La résistance R1 sert à limiter le courant traversant la LED. Plus cette résistance est élevée et moins le courant sera élevé. Attention, une résistance trop faible risque de détruire la sortie GPIO par dépassement du courant maximal.

Schéma de câblage

LED_GPIO

Figure 3 : connexion directe Raspberry Pi 3

Le câblage est simple et demande que peu de composants. On peut le réaliser avec un cobbler comme sur la photo de la figure 1 ou par une connexion directe sur le port GPIO du raspberry (voir figure 3).
Le cobbler est un accessoire qui permet de déporter les pins du GPIO vers une plaque d’essai (breadboard).

connexion_LED_photoRemarque : Le RPI3 de la photo figure 3 est équipé de l’écran officiel de la Fondation mais non utilisé dans les expérimentations qui suivent.

Cahier des charges.

Tout programmeur qui se respecte doit disposer ou établir un cahier des charges qui défini les différentes opérations à réaliser. Dans notre cas, il sera très simple.
Notre cahier des charges :

  1. allumer la led,
  2. attendre 1 seconde,
  3. éteindre la led,
  4. attendre 1 seconde,
  5. continuer en 1) (on répète indéfiniment la boucle)

Organigramme

organigramme1L’organigramme est une représentation graphique du déroulement de notre programme. Il comporte les différentes étapes qui permettront une transcription dans un langage donné.

Le premier pavé, qui nous intéresse, est « Initialisation » qui consiste à préparer la pin GPIO23 pour qu’elle puisse piloter la led.

Après cette phase, il faut allumer la LED.

Puis attendre x secondes (dans notre cas 1 sec.).

Après cette attente, on éteint la LED.

Suivi d’une nouvelle attente de x secondes (1 sec. pour notre exemple).

Et finalement, on reprend le cycle en allumant la LED et cela indéfiniment (boucle infinie).

Programmation.

Les différents programmes abordés dans la suite peuvent être exécutés sur toutes les versions du Raspberry Pi (type A, B, jusqu’au RPI3 y compris le Zero).
La saisie des programmes se fait via un éditeur de texte graphique (par exemple geany) ou en mode console (par exemple nano).

5mm-blinking-red-led
L’accès au Raspberry Pi peut se faire via son interface écran HDMI / clavier ou bien par l’intermédiaire d’un connexion à distance (mode console ou graphique).
Pour ma part, j’utilise une connexion console via une liaison SSH.
Dans la suite, nous verrons quelques programmes qui effectuent tous les mêmes actions (allumer / éteindre la LED) mais dans des langages différents.

Bash

Dans l’os Linux tout est « fichier » donc nous ferons des opérations de création, lecture, écriture et suppression de fichiers.

Programme

Pour saisir ce programme, il faut faire dans la console :

 nano blink90.sh 

Cette commande ouvre un fichier texte vide appelé bilnk90.sh (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
La combinaison Ctrl+o signifie l’appuie sur la touche Ctrl ainsi que la touche o.
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

#!/bin/bash
#Programme classique LED clignotante
#Led rouge sur GPIO23 via une résistance de 330 Ohms
#logiciel            : bash
#cible               : raspberry Pi
#date de création    : 17/06/2016
#date de mise à jour : 18/06/2016
#version             : 1.0
#auteur              : icarePetibles
#référence           : 
#Remarques           : Pour fonctionner, il faut être sous super utilisateur
#                      Il faut rendre le fichier exécutable avec
#                      sudo chmod +x blink90.sh
#                      Pour exécuter le fichier, il faut faire
#                      sudo ./blink90.sh
#
#Attention : Ce script à des effets de bord lorsqu'on interrompt la boucle
#            infinie par Ctrl-C. On a des messages d'errreur lors de la relance
#            du script mais fonctionne néanmoins
#
echo "23" > /sys/class/gpio/export                  #assigne pin
echo "out" > /sys/class/gpio/gpio23/direction       #en sortie
while true;                                         #boucle infinie
  do
    echo "1" > /sys/class/gpio/gpio23/value         #allume led
#    echo "Led allumée"                              #message IHM
    sleep 1;                                        #attente 1 sec
    echo "0" > /sys/class/gpio/gpio23/value         #éteint led
#    echo "Led éteinte"                              #message IHM
    sleep 1;                                        #attente 1 sec
  done
#fin script

Si l’on supprime les lignes de commentaires, il ne reste plus que 9 lignes.
Les commentaires sont importants si l’on souhaite reprendre un programme après quelques jours car notre mémoire n’est pas fiable. Ce qui était évident lors de l’écriture du programme devient incompréhensible. On peut également insérer des remarques concernant l’utilisation du programme (lignes 11 à 20).
Les lignes 21 et 22 correspondent à la phase « Initialisation« .
L’allumage de la LED se fait ligne 25 suivi d’une attente d’une seconde ligne 27.
L’extinction de la led se fait ligne 28 suivi de l’attente ligne 30.
Si l’on dé-commandante les lignes 26 et 29, le programme affiche également l’état de la LED dans la console.

Exécution du programme.

Pour exécuter ce programme bash, il faut le rendre exécutable avec la commande :

sudo chmod +x blink90.sh

Et pour l’exécuter :

sudo ./blink90.sh

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier (voir la remarque lignes 17 à 19 du programme).

Python

Le pilotage des ports GPIO, sous Python s’appuie sur des bibliothèques. Les bibliothèques RPi.GPIO et gpiozero sont incluses dans les versions de Python. Nous utiliserons également les bibliothèques pigpio et wiringpi qui devront être installées sous Python.

Rpi.GPIO

Programme

Pour saisir ce programme, il faut faire dans la console :

nano blink01.py

Cette commande ouvre un fichier texte vide appelé bilnk01.py (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
Programme classique LED clignotante
Led rouge sur GPIO23 via une résistance de 330 Ohms
logiciel            : python 3.4.2
cible               : raspberry Pi
date de création    : 08/06/2016
date de mise à jour : 08/06/2016
version             : 1.0
auteur              : icarePetibles
référence           : 
"""
#-------------------------------------------------------------------------------
# Bibliothèques
#-------------------------------------------------------------------------------
import RPi.GPIO as GPIO                 #bibliothèque RPi.GPIO
import time                             #bibliothèque time
#-------------------------------------------------------------------------------
GPIO.setwarnings(False)                 #désactive le mode warning

GPIO.setmode(GPIO.BCM)                  #utilisation des numéros de ports du
                                        #processeur
GPIO.setup(23, GPIO.OUT)                #mise en sortie du port GPIO 23 (broche
                                        #16 du connecteur)
if __name__ == '__main__':
    """
    Programme par défaut
    """
#    print(sys.version)                  #affiche version python
    print("Début du programme LED clignotante")
                                        #message IHM
    while True :                        #boucle infinie
        GPIO.output(23, GPIO.HIGH)      #sortie 23 high
        time.sleep(1)                   #attente 1 seconde
        GPIO.output(23, GPIO.LOW)       #sortie 23 low
        time.sleep(1)                   #attente 1 seconde
#-------------------------------------------------------------------------------

Les lignes 20 à 24 correspondent à la phase « Initialisation ».
L’allumage de la LED se fait ligne 34 suivi d’une attente d’une seconde ligne 35.
L’extinction de la LED se fait ligne 36 suivie de l’attente ligne 37.
La ligne 31 transmet un message console signalant le démarrage du programme.

Exécution du programme

Pour exécuter ce programme, il faut lancer la commande suivante dans la console Linux :

python3 blink01.py

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier.

Commentaire bibliothèque

La documentation concernant cette librairie est faible au niveau de la toile. On trouvera quelques informations sur le site :
https://sourceforge.net/p/raspberry-gpio-python/wiki/Home/

On peut également avoir des informations sous Python par les commandes suivantes :

python3
 >>> import Rpi.GPIO as gp
 >>> help(gp)

Rappel : pour sortir de l’interpréteur python, il suffit de faire Ctrl+d

Remarque : le contenu de cette librairie est étique et ne gère pas les bus I²C ou SPI.

gpiozero

Programme

Pour saisir ce programme, il faut faire dans la console :

nano blink20.py

Cette commande ouvre un fichier texte vide appelé bilnk20.py (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
Programme classique LED clignotante
Led rouge sur GPIO23 via une résistance de 330 Ohms
logiciel            : python 3.4.2
cible               : raspberry Pi
date de création    : 09/06/2016
date de mise à jour : 09/06/2016
version             : 1.0
auteur              : icarePetibles
référence           : https://gpiozero.readthedoc.io/en/v1.2.0/
"""
#-------------------------------------------------------------------------------
# Bibliothèques
#-------------------------------------------------------------------------------
from gpiozero import LED                #bibliothèque gpiozero
from time import sleep                  #sleep de la bibliothèque time
#-------------------------------------------------------------------------------
if __name__ == '__main__':
    """
    Programme par défaut
    """
    led = LED(23)                       #instance LED sur GPIO23
    while True:                         #boucle infinie
        led.on()                        #allume led
        sleep(0.5)                      #pause 0.5 sec
        led.off()                       #éteind led
        sleep(0.5)                      #pause 0.5 sec
#-------------------------------------------------------------------------------

La ligne 24 correspond à la phase « Initialisation ».
L’allumage de la LED se fait ligne 26 suivi d’une attente d’une demi-seconde ligne 27. L’extinction de la LED se fait ligne 28 suivi de l’attente ligne 29.

Exécution du programme

Pour exécuter ce programme, il faut lancer la commande suivante dans la console Linux :

python3 blink20.py

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier.

Commentaire bibliothèque

La documentation pour cette librairie peut être consultée sur le site :
https://gpiozero.readthedocs.io/en/v1.2.0/
On peut également avoir quelques informations supplémentaires par les commandes suivantes :

python3
>>> import gpiozero
>>> help(gpiozero)

Rappel : pour sortir de l’interpréteur Python, il suffit de faire Ctrl+d

Remarque : le contenu de cette librairie est nettement plus riche en méthodes que la précédente et gère le bus I²C ou SPI.

wiringpi

Programme

Pour utiliser la bibliothèque wiringpi, il faut l’installer au préalable. On trouvera la procédure l’installation sous le lien :
https://github.com/WiringPi/WiringPi-Python/
Pour saisir ce programme, il faut faire dans la console :

nano blink60.py

Cette commande ouvre un fichier texte vide appelé bilnk60.py (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
Programme classique LED clignotante
Led rouge sur GPIO23 via une résistance de 330 Ohms
logiciel            : python 3.4.2
cible               : raspberry Pi
date de création    : 21/06/2016
date de mise à jour : 21/06/2016
version             : 1.0
auteur              : icarePetibles
référence           : wiringpi.com
Remarques           : 
"""
#-------------------------------------------------------------------------------
# Bibliothèques
#-------------------------------------------------------------------------------
import wiringpi                         #bibliothèque wiringpi
#-------------------------------------------------------------------------------
if __name__ == '__main__':
    """
    Programme par défaut
    """
    print("\nDébut du programme LED clignotante")
                                        #messages IHM
    LED = 4                             #sortie LED sur GPIO23 = 4 mode wiringpi
    DUREE = 1000                        #durée demi période = 1 sec
    ON = 1
    OFF = 0
    wiringpi.wiringPiSetup()            #mode wiringpi ou "pseudo Arduino"
    wiringpi.pinMode(LED, 1)            #pi en sortie sortie
    wiringpi.digitalWrite(LED, OFF)     #led éteinte
    while True:                         #boucle infinie
        wiringpi.digitalWrite(LED, ON)  #allume led
        wiringpi.delay(DUREE)           #attente DUREE
        wiringpi.digitalWrite(LED, OFF) #éteind led
        wiringpi.delay(DUREE)           #attente DUREE
#-------------------------------------------------------------------------------

Les lignes 30 à 32 correspondent à la phase « Initialisation ».
L’allumage de la LED se fait ligne 34 suivi d’une attente d’une seconde ligne 35.
L’extinction de la LED se fait ligne 36 suivi de l’attente ligne 37.
La ligne 24 transmet un message console signalant le démarrage du programme.

Exécution du programme

Pour exécuter ce programme, il faut lancer la commande suivante dans la console Linux avec les privilèges root :

sudo python3 blink60.py

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier.

Commentaire bibliothèque

La documentation pour cette librairie peut être consultée sur le site :
http://wiringpi.com/reference/

On peut également avoir quelques informations supplémentaires par les commandes suivantes :

python3
>>> import wiringpi
>>> help(wiringpi)

Rappel : pour sortir de l’interpréteur python, il suffit de faire Ctrl+d

Remarque : le contenu de cette librairie est également très riche en méthodes et gère le bus I²C ou SPI.

Langage C

Le pilotage des ports GPIO, sous C s’appuie sur la bibliothèque wiringPi. L’installation de cette bibliothèque et décrite sur le site de wiringPi sous le lien : http://wiringpi.com/download-and-install/

wiringPi

Programme

Pour saisir ce programme, il faut faire dans la console :

nano blink80.c

Cette commande ouvre un fichier texte vide appelé blink80.c (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

/* -----------------------------------------------------------------------------
Programme classique LED clignotante
Led rouge sur GPIO23 (4) via une résistance de 330 ohms
os                  : RPi Linux 4.4.13+
logiciel            : gcc (Raspbian 4.9.2-10) 4.9.2
cible               : raspberry Pi
date de création    : 21/06/2016
date de mise à jour : 22/06/2016
version             : 1.0
auteur              : icarePetibles
référence           : www.wiringpi.com
Remarques           :
----------------------------------------------------------------------------- */
/* -----------------------------------------------------------------------------
Bibliothèques
----------------------------------------------------------------------------- */
#include <stdio.h>                     //utilisé pour printf()
#include <wiringPi.h>                  //bibliothèque wiringPi
//------------------------------------------------------------------------------
#define LED 4                          //numéro led = GPIO23
int main(void){                        //programme principale
    printf("Led clignotante\n");       //IHM
    wiringPiSetup();                   //numérotation wiringPi ou "pseudo Arduino"
    pinMode(LED, OUTPUT);              //pin en sortie
    for(;;){                           //boucle infinie
        digitalWrite(LED, HIGH);       //allume led
        delay (500);                   //attente 0.5 sec
        digitalWrite(LED, LOW);        //éteint led
        delay (500);                   //attente 0.5 sec
    }
    return(0);                         //code sortie
}
//------------------------------------------------------------------------------

Les lignes 23 et 24 correspondent à la phase « Initialisation ».
L’allumage de la LED se fait ligne 26 suivi d’une attente de 0.5 seconde ligne 27.
L’extinction de la LED se fait ligne 28 suivie de l’attente ligne 29.
La ligne 22 transmet un message console signalant le démarrage du programme.

Exécution du programme

Pour exécuter se programme, il faut d’abord le compiler. La compilation se fait par la commande ci-dessous (en mode console) :

gcc -Wall -o blink80 blink80.c -lwiringPi

Le résultat de la compilation est un fichier : blink80

Lancement du programme :

sudo ./blink80

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier.

Commentaire bibliothèque

La documentation pour cette librairie peut être consultée sur le site :
http://wiringpi.com/reference/

Cette bibliothèque est la même que celle utilisée au paragraphe 4.3 mais qui elle était adaptée à Python.

Perso

Une petite récréation avec une bibliothèque GPIO personnelle qui n’apporte rien de particulier et elle est même un tantinet « capillotracté ».

La bibliothèque se compose de 2 fichiers ipsGPIO.h (fichier entête) et ipsGPIO.c (fichier fonctions) qui sont utilisés dans le programme blink50.c pour piloter le port GPIO du Raspberry Pi.

Programme

Bibliothèque perso

Pour saisir ce programme ipsGPIO.h, il faut faire dans la console :

nano ipsGPIO.h

Cette commande ouvre un fichier texte vide appelé ipsGPIO.h (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

/* -----------------------------------------------------------------------------
Programme classique LED clignotante
Fichier entête de ipsGPIO.c
os                  : RPi Linux 4.4.13+ (Jessie)
logiciel            : gcc (Raspbian 4.9.2-10) 4.9.2
cible               : raspberry Pi
date de création    : 26/06/2016
date de mise à jour : 28/06/2016
version             : 1.0
auteur              : icarePetibles
référence           :
Remarques           :
----------------------------------------------------------------------------- */
#ifndef IPS_H
#define IPS_H
//directives constantes
#define ENTREE 0
#define SORTIE 1
#define DESACTIVE 2
#define HAUT 1
#define BAS 0
#define VRAI 1
#define FAUX 0
//prototypes fonctions
void afficheLn(const char * nom);      //eq. println()
void affiche(const char * nom);        //eq. print()
void modeBroche(int, int);             //eq. pinMode()
void ecritureDigitale(int, int);       //eq. digitalWrite()
void dormir(unsigned int);             //eq. delay()
unsigned long int mTemps(void);        //eq. millis()
#endif

Ce fichier contient les définitions des constantes et les prototypes des fonctions.
Pour saisir ce programme ipsGPIO.c, il faut faire dans la console :

nano ipsGPIO.c

Cette commande ouvre un fichier texte vide appelé ipsGPIO.c (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

/* -----------------------------------------------------------------------------
Programme classique LED clignotante
Fichier bibliothèque ipsGPIO.c
os                  : RPi Linux 4.4.13+ (Jessie)
logiciel            : gcc (Raspbian 4.9.2-10) 4.9.2
cible               : raspberry Pi
date de création    : 26/06/2016
date de mise à jour : 28/06/2016
version             : 1.0
auteur              : icarePetibles
référence           :
Remarques           :
----------------------------------------------------------------------------- */
/* -----------------------------------------------------------------------------
Bibliothèques
----------------------------------------------------------------------------- */
#include <stdio.h>                     //bibliothèque entrées/sorties
#include <string.h>                    //manipulation chaîne
#include <stdlib.h>                    //conversion nombre et autres
#include <unistd.h>                    //types et constantes
#include "ipsGPIO.h"                   //bibliothèque ipsGPIO
/* ----------------------------------------------------------------------------
Fonction affichage avec retour ligne suivant
SYNTAXE : afficheLn("texte")
eq. println()
---------------------------------------------------------------------------- */
void afficheLn(const char * nom){
    printf("%s\n", nom);               //IHM
}
/* ----------------------------------------------------------------------------
Fonction affichage sans retour ligne suivant
SYNTAXE : affiche("texte")
eq. print()
---------------------------------------------------------------------------- */
void affiche(const char * nom){
    printf("%s", nom);                 //IHM
}
/* ----------------------------------------------------------------------------
Fonction définition du mode de fonctionnement de la broche
SYNTAXE : modeBroche(BROCHE, MODE)
BROCHE  : Port GPIOXX
MODE    : ENTREE = 0, SORTIE = 1 ou DESACTIVEE = 2
eq. pinMode()
---------------------------------------------------------------------------- */
void modeBroche(int broche, int mode){
    char bufferBroche[10];             //buffer de conversion
    sprintf(bufferBroche, "%d", broche);
                                       //conversion int en string
    char commande[50] = "";            //buffer commande

    if(mode == 1){			           //broche en sortie
        //commande bash pour assigner le port
        //echo PIN > /sys/class/gpio/export
        strcpy(commande, "echo ");     //composition commande par concaténation
        strcat(commande, bufferBroche);//composition commande
        strcat(commande, " > /sys/class/gpio/export");
                                       //composition commande
        system(commande);              //envoi commande système
        //commande bash pour assigner le port en sortie
        //echo out > /sys/class/gpio/gpioPIN/direction
        strcpy(commande, "echo out > /sys/class/gpio/gpio");
                                       //composition commande par concaténation
        strcat(commande, bufferBroche);//composition commande
        strcat(commande, "/direction");//composition commande
        system(commande);              //envoi commande système

    } else if(mode == 2){		       //broche déactivée

        //commande bash pour désactiver le port
        //echo PIN > /sys/class/gpio/unexport
        strcpy(commande, "echo ");
        strcat(commande, bufferBroche);
        strcat(commande, " > /sys/class/gpio/unexport");
        system(commande);

    } else {				           //broche en entrée *** en attente ***
//        //commande bash pour assigner le port
//        //echo PIN > /sys/class/gpio/export
//        strcpy(commande, "echo ");     //composition commande par concaténation
//        strcat(commande, bufferBroche);//composition commande
//        strcat(commande, " > /sys/class/gpio/export");
//                                       //composition commande
//        system(commande);              //envoi commande système
//        //commande bash pour assigner le port en entrée
//        //echo in > /sys/class/gpio/gpioPIN/direction
//        strcpy(commande, "echo in > /sys/class/gpio/gpio");
//                                       //composition commande par concaténation
//        strcat(commande, bufferBroche);//composition commande
//        strcat(commande, "/direction");//composition commande
//        system(commande);              //envoi commande système
    }
}
/* ----------------------------------------------------------------------------
Fonction écriture état de sortie de la broche
SYNTAXE : ecritureDigitale(BROCHE, ETAT)
BROCHE  : XX (Port GPIOXX)
ETAT    : HAUT = 1 = 3.3V ou BAS = 0 = 0V
eq. digitalWrite()
---------------------------------------------------------------------------- */
void ecritureDigitale(int broche, int etat){
    char bufferBroche[10];             //buffer de conversion
    sprintf(bufferBroche, "%d", broche);
                                       //conversion int en string
    char commande[50] = "";            //buffer commande
    if(etat == 1){                     //état HAUT
        //commande bash pour état haut
        //echo 1 > /sys/class/gpio/gpioPIN/value
        strcpy(commande, "echo 1 > /sys/class/gpio/gpio");
                                       //composition commande par concaténation
        strcat(commande, bufferBroche);//composition commande
        strcat(commande, "/value");    //composition commande
        system(commande);              //envoi commande système
    } else {                           //état BAS
        //commande bash pour état bas
        //echo 0 > /sys/class/gpio/gpioPIN/value
        strcpy(commande, "echo 0 > /sys/class/gpio/gpio");
                                       //composition commande par concaténation
        strcat(commande, bufferBroche);//composition commande
        strcat(commande, "/value");    //composition commande
        system(commande);              //envoi commande système
    }
}
/* ----------------------------------------------------------------------------
Fonction attente blocante
SYNTAXE : dormir(TEMPS)
TEMPS   : XX (en milli-seconde)
eq. delay()
---------------------------------------------------------------------------- */
void dormir(unsigned int temps){
	temps = temps * 1000;              //temps en micro-seconde
	usleep(temps);                     //attente
}
/* ----------------------------------------------------------------------------
Fonction retourne le temps système
SYNTAXE : TEMPS = mTemps()
TEMPS   : XX (en milli-seconde)
eq. millis()
---------------------------------------------------------------------------- */
unsigned long int mTemps(void){
    unsigned long int temps = 0;       //variable enttière
    double uptime, idleTime;           //variables décimales
    FILE* fp;                          //variable fichier
    fp = fopen("/proc/uptime", "r");   //ouverture fichier en lecture
    fscanf(fp, "%lf %lf\n", uptime, idleTime);
                                       //lecture données
    fclose(fp);                        //fermeture fichier
    temps = (unsigned long int)(uptime * 1000);
                                       //mise en forme sec en msec
    return temps;                      //retour temps
}
/* ------------------------------------------------------------------------- */

Le principe de ce programme est relativement simple puisqu’on appelle des commandes « bash » à partir d’un programme en C (system(commande)).
Les commentaires du programme sont auto-suffisants pour la compréhension.

Programme blink

Pour saisir ce programme blink50.c, il faut faire dans la console :

nano blink50.c

Cette commande ouvre un fichier texte vide appelé blink50.c (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

/* -----------------------------------------------------------------------------
Programme classique LED clignotante
Led rouge sur GPIO23 via une résistance de 330 ohms
os                  : RPi Linux 4.4.13+ (Jessie)
logiciel            : gcc (Raspbian 4.9.2-10) 4.9.2
cible               : raspberry Pi
date de création    : 22/06/2016
date de mise à jour : 22/06/2016
version             : 1.0
auteur              : icarePetibles
référence           : 
Remarques           :
----------------------------------------------------------------------------- */
/* -----------------------------------------------------------------------------
Bibliothèques
----------------------------------------------------------------------------- */
#include <stdio.h>                      //bibliothèque entrées/sorties
#include "ipsGPIO.h"                    //bibliothèque ipsGPIO

#define LED 23                          //led sur GPIO23

int main(void){                         //programme principal
    affiche("Led clignotante");         //IHM
    afficheLn(" by icarePetibles");     //IHM
    modeBroche(LED, SORTIE);            //GPIO23 en sortie
    for(;;){                            //boucle infinie
        ecritureDigitale(LED, HAUT);    //allume led
        dormir(1000);                   //attente
        ecritureDigitale(LED, BAS);     //éteint led
        dormir(1000);                   //attente
    }
    return 0;                           //code sortie
}

La syntaxe utilisée est proche de celle de wiringPi ou Arduino mais en français.
La ligne 25 correspondent à la phase « Initialisation ».
L’allumage de la LED se fait ligne 27 suivi d’une attente d’une seconde ligne 28.
L’extinction de la LED se fait ligne 29 suivie de l’attente ligne 30.
Les lignes 23 et 24 transmettent des messages console signalant le démarrage du programme.

Exécution du programme

Pour exécuter ce programme, il faut d’abord le compiler. La compilation se fait par la commande ci-dessous (en mode console) pour les différents fichiers C en créant des fichier objet :

gcc -c ipsGPIO.c
 gcc -c blink50.c

Et pour terminer, il faut créer le fichier final via l’éditeur de lien :

gcc -o blink50 blink50.o ipsGPIO.o

Le résultat de la compilation est un fichier : blink50

Lancement du programme :

sudo ./blink50

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier.

Remarque : On peut supprimer les fichiers objets (.o) du répertoire courant par :

rm *.o

Commentaire bibliothèque

Cette bibliothèque n’a rien d’extraordinaire mais montre uniquement que l’on peut arriver à ses fins avec un peu d’imagination et peu de moyens.

Comme souvent les solutions ou les erreurs se trouvent localisées entre la chaise et le clavier.

Cette bibliothèque fera certainement l’objet de mise à jour lors d’une autre « Saga ».

Conclusion intermédiaire

La première partie de notre expérimentation se termine. On aurait pu faire la même chose avec d’autres langages de programmation.
Les programmes réalisés ne me conviennent pas, principalement pour les raisons suivantes :

  • Lorsqu’on sort de la boucle infinie par une sortie sauvage du genre Ctrl+c, on abandonne la boucle en laissant la sortie GPIO dans un état incertain (ce n’est pas très propre)
  • Le temps d’attente dans les boucles est du type bloquant, c’est-à-dire que la tâche attend la fin avant de faire autre chose. On peut admettre ce type de programmation pour une démonstration mais pas dans un programme réel.
  • Si on avait réalisé d’autres traitements informatiques dans la boucle sans fin, ils auraient subit des retards d’exécution à cause des attentes bloquantes de la boucle.

On peut corriger cette situation par les programmes qui suivent.

Organigramme

organigramme2

Figure 5 : Organigramme

Il comporte les différentes étapes qui permettront une transcription dans un langage donné.
Le premier pavé, qui nous intéresse, est « Initialisation » qui consiste à préparer la pin GPIO23 pour qu’elle puisse piloter la LED.
Après cette phase, on teste si un caractère a été saisi au clavier, si c’est le cas, on sort de la boucle sans fin en éteignant la LED et on désalloue la ressource GPIO.
Dans le cas contraire, on teste si la LED a été allumée ou éteinte pendant un temps égal ou supérieur à DUREE.
Si c’est le cas, on permute l’état de la LED.
Dans le cas contraire, on peut traiter une autre tâche, puis on boucle pour refaire les mêmes opérations.

Bash

Programme

Pour cette partie du programme qui traite des valeurs décimales, il y a lieu d’installer le paquet bc pour que bash puisse faire les traitements correspondants.

sudo apt-get update
 sudo apt-get install bc

Pour saisir ce programme, il faut faire dans la console :

nano blink93.sh

Cette commande ouvre un fichier texte vide appelé blink93.sh (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

#!/bin/bash
#Programme classique LED clignotante
#Led rouge sur GPIO23 via une résistance de 330 Ohms
#Ajout Gestion Ctrl-C
#Ajout attente non bloquante
#Ajout vérification mode super utilisateur
#logiciel            : bash
#cible               : raspberry Pi
#date de création    : 18/06/2016
#date de mise à jour : 18/07/2016
#version             : 1.0
#auteur              : icarePetibles
#référence           : 
#Remarques           : Pour fonctionner, il faut être sous super utilisateur
#                      Il faut rendre le fichier exécutable avec
#                      sudo chmod +x blink93.sh
#                      Pour exécuter le fichier, il faut faire
#                      sudo ./blink93.sh
#
LEDPIN=23                                           #GPIO23
OFF=0                                               #variable éteindre
ON=1                                                #variable allumée
DUREE=1000                                          #demi-période
ETATLED=0                                           #led éteinte
#vérification si accès root
#if [ $EUID -ne 0 ]                                  #si $EUID différent de 0
if [ $EUID != "0" ]                                 #si $EUID différent de 0
then                                                #alors
    echo "Il faut être root pour exécuter le script. Essaye sudo $0"
    exit                                            #sortie
fi                                                  #fin if

#Procédure de netoyage, éteind led, désactive la sortie
cleanup()
{
    PIN=$1                                          #paramètre transmis
#    echo $PIN                                       #affiche paramètre transmis
                                                    #dans notre cas 23
    echo $OFF > /sys/class/gpio/gpio$PIN/value      #led éteinte
    echo $PIN > /sys/class/gpio/unexport            #désactive port
    echo                                            #esthétique
    echo Interruption                               #message IHM
    echo Led éteinte et pin désactivée              #message IHM
    echo Fin script                                 #message de fin
    exit                                            #sortie
}
#lecture temps
function mTemps()
{
    ligne=`cat /proc/uptime`                        #lit uptime et idletime
                                                    #valeurs décimales
    mTemps=$(echo "$ligne" | cut -f 1 -d ' ')       #extrait uptime
    mTemps=$(echo "$mTemps*1000" |bc)               #multiplie par 1000 pour
                                                    #avoir des msec
    mTemps=${mTemps%%.*}                            #float to int
    return $mTemps                                  #valeur mTemps
}
#programme principal
echo Led clignotante                                #message de début
echo ctrl-c pour sortir de la boucle                #IHM
#Setup pin et direction - Cature Control-C SIGHUP SIGKILL
echo $LEDPIN > /sys/class/gpio/export               #assigne pin 23
echo out > /sys/class/gpio/gpio$LEDPIN/direction    #pin 23 en sortie
#trap "cleanup $LEDPIN" 1 2 15                       #capture SIGNAL
trap "cleanup $LEDPIN" SIGHUP SIGINT SIGTERM        #capture SIGNAL et lance la
                                                    #la procédure cleanup avec
                                                    #le paramètre 23
mTemps                                              #lecture référence temps
valeurPrecedente=$mTemps                            #sauve temps msec
while true                                          #boucle infinie
  do                                                #faire
    mTemps                                          #lecture référence temps
    valeurActuelle=$mTemps                          #sauve temps msec
    let "diff=$valeurActuelle - $valeurPrecedente"  #calcule durée état
    if [ $diff -ge $DUREE ]                         #si temps écoulé >= DUREE
    then                                            #alors
        valeurPrecedente=$valeurActuelle            #init valeur précédente
        if [ $ETATLED -eq $ON ]                     #si led allumée
        then                                        #alors
            echo $OFF > /sys/class/gpio/gpio$LEDPIN/value
                                                    #éteint led
#            echo Led éteinte                        #affichage console
            ETATLED=$OFF                            #led éteinte
        else                                        #sinon
            echo $ON > /sys/class/gpio/gpio$LEDPIN/value
                                                    #allume led
#            echo Led allumée                        #affichage console
            ETATLED=$ON                             #led allumée
        fi
    fi
    #
    #Autres traitements
    #
  done                                              #fin do
#Fin du script

Les différentes variables sont définies aux lignes 20 à 24, si l’on souhaite modifier la fréquence du clignotement, il suffit de changer la valeur de DUREE (en milli-seconde).
En ligne 27, on teste si on est en mode « sudo » avec le message ad hoc (pas nécessaire dans notre cas).
La fonction cleanup(), ligne 34, permet une sortie « propre » de la boucle sans fin en éteignant la LED et en désactivant le port.
La fonction mTemps(), ligne 48, permet de mesurer le temps écoulé depuis le démarrage du Raspberry PI. Elle permet de mesurer la durée d’allumage/d’extinction de la LED.
Les lignes 62 et 63 correspondent à la phase « Initialisation ».
La ligne 65 capture le signal Ctrl+c et lance la fonction cleanup avec le paramètre correspondant à la LED.
L’allumage (ligne 85) ou l’extinction (ligne 80) de la LED est réalisé lorsque la différence entre valeurPrecedente et valeurActuelle est supérieure ou égale à DUREE.

Exécution du programme

Pour exécuter ce programme bash, il faut le rendre exécutable avec la commande :

sudo chmod +x blink93.sh

Et pour l’exécuter :

sudo ./blink93.sh

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier.

Python

Rpi.GPIO

Programme

Pour saisir ce programme, il faut faire dans la console :

nano blink04.py

Cette commande ouvre un fichier texte vide appelé blink04.py (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
Programme classique LED clignotante
Led rouge sur GPIO23 via une résistance de 330 Ohms
Ajout d'une possibilité de sortie de la boucle sans fin
Ajout temporisation non bloquante
logiciel            : python 3.4.2
cible               : raspberry Pi
date de création    : 08/06/2016
date de mise à jour : 19/07/2016
version             : 1.0
auteur              : icarePetibles
référence           : 
"""
#-------------------------------------------------------------------------------
# Bibliothèques
#-------------------------------------------------------------------------------
import RPi.GPIO as GPIO                 #bibliothèque RPi.GPIO
import time                             #bibliothèque time
#-------------------------------------------------------------------------------
if __name__ == '__main__':
    """
    Programme par défaut
    """
#-------------------------------------------------------------------------------
# Constantes
#-------------------------------------------------------------------------------
    DUREE = 0.5                         #durée demi période = 0.5 sec
    LED = 23                            #sortie LED sur GPIO23
#-------------------------------------------------------------------------------
    GPIO.setwarnings(False)             #désactive le mode warning
    GPIO.setmode(GPIO.BCM)              #utilisation des numéros de ports du
                                        #processeur
    GPIO.setup(LED, GPIO.OUT)           #mise en sortie du port GPIO 23 (broche
                                        #16 du connecteur)
    print("\nDébut du programme LED clignotante")
    print("Arrêt du clignotement par ctrl+c")
                                        #messages IHM
    GPIO.output(LED, GPIO.HIGH)         #initialisation sortie 23 allume led
    etatLed = True                      #led allumée
    previousTime = time.time()          #valeur time précédente
    try:
        while True :                    #boucle infinie
            currentTime = time.time()   #sauve time actuel
            if abs(currentTime - previousTime) >= DUREE:
                                        #si temps écoulé >= à DUREE
                previousTime = currentTime
                                        #nouveau time précédent
                if etatLed:             #si led allumée
                    GPIO.output(LED, GPIO.LOW)
                                        #éteind led
                    etatLed = False     #led éteinte
                else:                   #si led éteinte
                    GPIO.output(LED, GPIO.HIGH)
                                        #allume led
                    etatLed = True      #led allumée
    #capture du ctrl+c et sortie boucle
    except KeyboardInterrupt:
        GPIO.output(LED, GPIO.LOW)      #Eteint la LED
        GPIO.cleanup()                  #remet toutes pins en entrée
        print("\nFin du programme\n")   #IHM
#-------------------------------------------------------------------------------

La phase « Initialisation » est faite aux lignes 32 à 36.
L’allumage (ligne 55) ou l’extinction (ligne 51) de la LED est réalisé lorsque la différence entre previousTime et currentTime est supérieure ou égale à DUREE.
La ligne 59 capture le signal Ctrl+c qui éteint la LED et libère les ressources GPIO.

Exécution du programme

Pour exécuter ce programme, il faut lancer la commande suivante dans la console Linux :

python3 blink04.py

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier.

gpiozero

Programme

Je déroge un peu de l’organigramme du chapitre 7, sinon on a toujours la même structure du programme. Il existe dans la bibliothèque gpiozero une fonction blink().
Pour saisir ce programme, il faut faire dans la console :

nano blink25.py

Cette commande ouvre un fichier texte vide appelé blink25.py (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
Programme classique LED clignotante
Led rouge sur GPIO23 via une résistance de 330 Ohms
logiciel            : python 3.4.2
cible               : raspberry Pi
date de création    : 09/06/2016
date de mise à jour : 19/07/2016
version             : 1.0
auteur              : icarePetibles
référence           : https://gpiozero.readthedoc.io/en/v1.2.0/
"""
#-------------------------------------------------------------------------------
# Bibliothèques
#-------------------------------------------------------------------------------
from gpiozero import LED                #bibliothèque gpiozero
#-------------------------------------------------------------------------------
if __name__ == '__main__':
    """
    Programme par défaut
    """
    DUREE = 0.5                         #durée demi-période
    print("\nDébut du programme LED clignotante")
    print("Arrêter le clignotement - ctrl+c")
                                        #messages IHM
    led = LED(23)                       #instance LED sur GPIO23
    led.blink(DUREE, DUREE)             #clignote avec valeur par défaut
    try:
        while True :                    #boucle infinie
            pass                        #circuler, il n'y a rien à voir
    except KeyboardInterrupt:           #capture ctrl+c
        print("\nFin du programme\n")   #IHM
#-------------------------------------------------------------------------------
# Documentation
#-------------------------------------------------------------------------------
#    led.blink(0.01, 1, 10, True)        #voir Documentation (1)
#pause() (attente signal) est remplacé par la boucle infinie while True  
#(1)
#led.blink(on_time=1, off_time=1, n=None, background=True)
#on_time    = nombre de secondes (float) led allumée
#off_time   = nombre de secondes (float) led éteinte
#n          = nombre de clignotement - None = en continu
#background = True (défaut) - démarre une tâche (thread) de clignotement 
#             d'arrière plan et retour
#background = Flase -retour que si le clignotement et fini (att. avec la valeur
#             par défaut de n, on n'aura jamais de retour
#-------------------------------------------------------------------------------

La structure de ce programme est très simple. La phase « Initialisation » se résume à la ligne 27.
Pour le clignotement de la LED, tout est ligne 28. Le reste n’est que de l’habillage et l’attente de capture du Ctrl+c.
L’utilisation de led.blink() fait clignoter la LED avec les paramètres par défaut, c’est à dire en continu avec une demi-période de 1 seconde.

Syntaxe : Led.blink(on_time=1, off_time=1, n=None, background=True)
	on_time = durée d'allumage led (en sec)
	off_time = durée d'extinction led (en sec)
	n = nombre de clignotement (n=None clignotement continu)
	background = principe d'exécution de la tâche
		True (par défaut) = démarre la tâche et retourne
False = retour après la fin du clignotement (Attention : avec n=None et background=False, on n'aura plus la main).

Exécution du programme

Pour exécuter ce programme, il faut lancer la commande suivante dans la console Linux :

python3 blink25.py

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier.

wiringpi

Programme

Pour l’installation de la bibliothèque voir le paragraphe 4.3.1.
Pour saisir ce programme, il faut faire dans la console :

nano blink62.py

Cette commande ouvre un fichier texte vide appelé blink62.py (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
Programme classique LED clignotante
Led rouge sur GPIO23 via une résistance de 330 Ohms
Ajout sortie boucle infinie et attente non blocante
logiciel            : python 3.4.2
cible               : raspberry Pi
date de création    : 21/06/2016
date de mise à jour : 19/07/2016
version             : 1.0
auteur              : icarePetibles
référence           : www.wiringpi.com
Remarques           : à exécuter avec les privilèges root
"""
#-------------------------------------------------------------------------------
# Bibliothèques
#-------------------------------------------------------------------------------
import wiringpi                         #bibliothèque wiringpi
#-------------------------------------------------------------------------------
if __name__ == '__main__':
    """
    Programme par défaut
    """
    print("\nDébut du programme LED clignotante")
    print("Arrêter le clignotement - ctrl+c")
                                        #messages IHM
    LED = 4                             #sortie LED sur GPIO23 = 4 mode wiringpi
    DUREE = 500                         #durée demi période = 0.5 sec
    ON = 1
    OFF = 0
    wiringpi.wiringPiSetup()            #mode wiringpi ou "pseudo Arduino"
    wiringpi.pinMode(LED, 1)            #pi en sortie sortie
    wiringpi.digitalWrite(LED, OFF)     #led éteinte
    etatLed = False                     #sauve temps précédent (en msec)
    previousTime = wiringpi.millis()
    try:
        while True:                     #boucle infinie
            currentTime = wiringpi.millis()
                                        #sauve temps actuel
            if (currentTime - previousTime) >= DUREE:
                                        #si temps écoulé >= à DUREE (en msec)
                previousTime = currentTime
                                        #sauve temps précédent (en msec)
                if etatLed:             #si led allumée
                    wiringpi.digitalWrite(LED, OFF)
                                        #éteind led
                    etatLed = False     #led éteinte
                else:                   #si led éteinte
                    wiringpi.digitalWrite(LED, ON)
                                        #allume led
                    etatLed = True      #led allumée
    except KeyboardInterrupt:           #capture ctrl+c
        wiringpi.digitalWrite(LED, OFF) #éteind led
        wiringpi.pinMode(LED, 0)        #pin en entrée
        print("\nFin du programme\n")   #IHM
#-------------------------------------------------------------------------------

La structure de ce programme est identique à ceux que l’on a déjà vu jusqu’à présent.

Exécution du programme

Pour exécuter ce programme, il faut lancer la commande suivante dans la console Linux :

sudo python3 blink62.py

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier.

pigpio

Pour utiliser la bibliothèque pigpio, il faut l’installer au préalable. On trouvera la procédure l’installation sous le lien :
http://abyz.co.uk/rpi/pigpio/download.html

Programme

Ce programme, pour changer, utilise une autre méthode pour sortir de la boucle infinie. La saisie non bloquante d’un caractère clavier est incluse dans un module Python indépendant.
Pour saisir ce programme, il faut faire dans la console :

nano saisieCarac.py

Cette commande ouvre un fichier texte vide appelé saisieCarac.py (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
Saisie caractère clavier non blocante
logiciel            : python 3.4.2
cible               : raspberry Pi
date de création    : 08/06/2016
date de mise à jour : 16/06/2016
version             : 1.0
auteur              : icarePetibles
référence           : http://home.wlu.edu/~levys/software/kbhit.py
"""
#-------------------------------------------------------------------------------
# Bibliothèques
#-------------------------------------------------------------------------------
import os                               #système d'exploitation
import sys                              #informations système
import termios                          #interface posix et contrôle I/O tty
import atexit                           #nettoyage et enrégistrement fonctions
from select import select               #accès contrôles I/O plateforme
#-------------------------------------------------------------------------------
# Classe KBHit
#-------------------------------------------------------------------------------
class KBHit:
#-------------------------------------------------------------------------------
    def __init__(self):
        """
        Création d'un objet KBHit que l'on peut appeler pour faire différentes
        choses
        """
        #Remarque : On ne traite pas le cas de windows
        #Sauvegade les paramètres du terminal
        self.fd = sys.stdin.fileno()    #la méthode fileno() renvoie le 
                                        #descripteur de fichier d'un objet de
                                        #type fichier
        self.new_term = termios.tcgetattr(self.fd)
        self.old_term = termios.tcgetattr(self.fd)
                                        #retourne une liste contenant les 
                                        #attributs tty pour le descripteur de
                                        #fichier fd
        self.new_term[3] = (self.new_term[3] ~termios.ICANON ~termios.ECHO)
                                        #ICANON désactivé et ECHO désactivé
        termios.tcsetattr(self.fd, termios.TCSAFLUSH, self.new_term)
                                        #fixe les attributs tty pour le 
                                        #descripteur de fichier fd à partir des 
                                        #attributs, qui est une liste comme 
                                        #celle retournée par tcgetattr()
        #Réinitialisation terminal normal et sortie
        atexit.register(self.set_normal_term)
                                        #enrégistre la fonction à exécuter à la
                                        #fin
#-------------------------------------------------------------------------------
    def set_normal_term(self):
        """
        Reset vers le mode normal du terminal
        """
        #Remarque : On ne traite pas le cas de windows
        termios.tcsetattr(self.fd, termios.TCSAFLUSH, self.old_term)
                                        #fixe les attributs tty pour le 
                                        #descripteur de fichier fd à partir des 
                                        #attributs, qui est une liste comme 
                                        #celle retournée par tcgetattr()
#-------------------------------------------------------------------------------
    def getch(self):
        """
        Renvoi le caractère du clavier après un appel KBHit().
        """
        s = ''
        #Remarque : On ne traite pas le cas de windows
        return sys.stdin.read(1)        #lecture du caractère de stdin
#-------------------------------------------------------------------------------
    def kbhit(self):
        """
        Retourne True si un caractère a été frappé au clavier, sinon False
        """
        #Remarque : On ne traite pas le cas de windows
        dr, dw, de = select([sys.stdin], [], [], 0)
        return dr != []                 #True ou False
#-------------------------------------------------------------------------------
#Test
#-------------------------------------------------------------------------------
if __name__ == "__main__":
    kb = KBHit()                        #instance KBHit()
    print("Début du programme")
    print("Appuyer sur une touche, ou ESC pour sortir")

    while True:                         #boucle sans fin
        if kb.kbhit():                  #si touche clavier
            c = kb.getch()              #lecture touche
            if ord(c) == 27:            #si ESC
                break                   #sortie de la boucle sans fin
            print(c)                    #affiche le caractère

    kb.set_normal_term()                #terminal en mode normal
    print("Fin du programme")           #message HIM
#-------------------------------------------------------------------------------

Les lignes 82 à 95 permettent de tester le programme de saisie.
Pour saisir ce programme blink, il faut faire dans la console :

nano blink41.py

Cette commande ouvre un fichier texte vide appelé blink41.py (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ees commentaires sont représentés ci-dessous.

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
Programme classique LED clignotante
Led rouge sur GPIO23 via une résistance de 330 Ohms
Ajout sortie boucle infinie
Ajout test pigpiod existe
Ajout temporisation non bloquante
logiciel            : python 3.4.2
cible               : raspberry Pi
date de création    : 09/06/2016
date de mise à jour : 19/06/2016
version             : 1.0
auteur              : icarePetibles
référence           : abyz.co.uk/rpi/pigpio/index.html
Remarques           : 
"""
#-------------------------------------------------------------------------------
# Bibliothèques
#-------------------------------------------------------------------------------
from saisieCarac import *               #saisie caractère non blocante
import time                             #bibliothèque time
import pigpio                           #bibliothèque pigpio
import os                               #bibliothèque os
#-------------------------------------------------------------------------------
if __name__ == '__main__':
    """
    Programme par défaut
    """
#Test si pigpiod existe sinon lance sudo pigpiod
    if os.system('pidof pigpiod >/dev/null') == 256:
        os.system('sudo pigpiod >/dev/null')
        print("'sudo pigpiod' lancé par le programme")
#-------------------------------------------------------------------------------
    kb = KBHit()                        #instance KBHit()
    print("\nDébut du programme LED clignotante")
    print("Arrêter le clignotement - appuyer sur 'q'")
                                        #messages IHM
    LED = 23                            #sortie LED sur GPIO23
    DUREE = 0.5                         #durée demi période = 0.5 sec
    ON = 1                              #esthétique
    OFF = 0                             #esthétique
    pi = pigpio.pi()                    #connection à la tâche pigpiod
    pi.set_mode(LED, pigpio.OUTPUT)     #configure pin en sortie
    pi.write(LED, ON)                   #sortie 23 allume led
    etatLed = True                      #led allumée
    previousTime = pi.get_current_tick()
                                        #valeur time précédente (en micro-sec)
    while True:                         #boucle infinie
        if kb.kbhit():                  #test si touche appuiée
            c = kb.getch()              #lecture de la touche
            if c.lower() == "q":        #touche q ou Q
                break                   #sortie de boucle infinie
        currentTime = pi.get_current_tick()
                                        #sauve time actuel (en micro-sec)
        if pigpio.tickDiff(previousTime, currentTime)/1000000.0 >= DUREE:
                                        #si temps écoulé >= à DUREE (en sec)
            previousTime = currentTime  #nouveau time précédent
            if etatLed:                 #si led allumée
                pi.write(LED, OFF)      #éteind led
                etatLed = False         #led éteinte
            else:                       #si led éteinte
                pi.write(LED, ON)       #allume led
                etatLed = True          #led allumée
        
    pi.set_mode(LED, pigpio.INPUT)      #nettoyage
    kb.set_normal_term()                #rétablie le terminal normal
    print("\nFin du programme\n")       #message IHM
    pi.stop()                           #déconnexion
#-------------------------------------------------------------------------------

Pour exécuter ce programme, il faut lancer au préalable une tâche de fond qui assure le contrôle des autres tâches. Si vous l’oubliez, les lignes 31 à 33 le feront pour vous.
Ligne 21, on importe les fonctions pour la saisie non bloquante d’un caractère au clavier.
Les lignes 50 à 53 permettent de sortir de la boucle infinie si l’on saisie ‘q’ ou ‘Q’ au clavier.
Le reste du programme nous est familier.

Exécution du programme

Pour exécuter ce programme, il faut lancer la commande suivante dans la console Linux :

python3 blink41.py

Pour sortir de la boucle infinie, il suffit de faire un q ou Q au clavier.

Commentaire bibliothèque

La documentation pour cette librairie peut être consultée sur le site :
http://abyz.co.uk/rpi/pigpio/python.html

On peut également avoir quelques informations supplémentaires par les commandes suivantes :

python3
>>> import pigpio
>>> help(pigpio)

Rappel : pour sortir de l’interpréteur Python, il suffit de faire Ctrl+d

Graphique tkinter

Un peu de graphisme pour piloter notre LED.

LED_allumee

Figure 6 : LED allumée

LED_eteinte

Figure 7 : LED éteinte

Programme

Pour saisir ce programme, il faut faire dans la console :

nano blink70.py

Cette commande ouvre un fichier texte vide appelé blink70.py (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

#!/usr/bin/python3
# -*- coding:utf-8 -*-
"""
Programme led clignotante avec interface graphique
os                  : RPi Linux 4.4.13+
logiciel            : python3.4.2
cible               : raspberry Pi
date de création    : 25/06/2016
date de mise à jour : 25/06/2016
version             : 1.0
auteur              : icarePetibles
référence           :
Remarques           :
"""
#-------------------------------------------------------------------------------
# Bibliothèques
#-------------------------------------------------------------------------------
from tkinter import *                  #bibliothèque graphique tkinter
import RPi.GPIO as GPIO                #bibliothèque RPi.GPIO
#-------------------------------------------------------------------------------
#variables et constantes
DUREE = 500                            #1/2 période du clignotement led
largeur = 26                           #largeur canvas
hauteur = 26                           #hauteur canvas

ledOn   = '#ff0000'                    #led allumée couleur rouge
ledOff  = '#B1B1B1'                    #led éteinte couleur grise
etatLed = False                        #led éteinte
#-------------------------------------------------------------------------------
#fonctions
#-------------------------------------------------------------------------------
def maj():
    """Bascule état led en fonction de DUREE"""
    global etatLed                     #variable global - pas très orthodose
                                       #mais pour faire simple
    if(etatLed):                       #si led allumée
        etatLed=False                  #led éteinte
        GPIO.output(23, GPIO.LOW)      #sortie 23 low - led éteinte
        des1.itemconfig(lumiere, fill=ledOff)
                                       #affiche la led éteinte
    else:                              #si led éteinte
        etatLed=True                   #led éteinte
        GPIO.output(23, GPIO.HIGH)     #sortie 23 high - led allumée
        des1.itemconfig(lumiere, fill=ledOn)
                                       #affiche la led allumée
    des1.update_idletasks()            #force le rafraîchissement graphique
    des1.after(DUREE, maj)             #appel maj après écoulement DUREE
#-------------------------------------------------------------------------------
def quitter():
    """Quitte l'application"""
    GPIO.output(23, GPIO.LOW)          #sortie 23 low
    GPIO.setup(23, GPIO.IN)            #GPIO23 en entrée
    quit()                             #sortie de mainloop
    destroy()                          #détruit l'objet ainsi que les enfants
#-------------------------------------------------------------------------------
def initialisation():
    """Initialisation"""
    GPIO.setwarnings(False)            #désactive le mode warning
    GPIO.setmode(GPIO.BCM)             #numérotation ports processeur
    GPIO.setup(23, GPIO.OUT)           #sortie sur GPIO23
    GPIO.output(23, GPIO.LOW)          #sortie 23 low
#-------------------------------------------------------------------------------
#programme pricipal
#-------------------------------------------------------------------------------
fen = Tk()                             #instance Tk
fen.title('La saga Blink')             #titre de la fenêtre
fen.iconbitmap('@framboise.xbm')       #icon de l'application
largApplication = 300                  #largeur de l'application
hautApplication = 110                  #hauteur de l'application
largDisplay = fen.winfo_screenwidth()  #largeur de l'écran en pixels
hautDisplay = fen.winfo_screenheight() #hauteur de l'écran en pixels
posX = int((largDisplay - largApplication)/2)
                                       #position X de l'appli pour être centrer
posY = int((hautDisplay - hautApplication)/2)
                                       #position Y de l'appli pour être centrer
fen.geometry('{}x{}+{}+{}'.format(largApplication, hautApplication, posX, posY))
                                       #taille et position de la fenêtre
fen.resizable(False, False)            #ne permet pas le re-dimensionnement
fen.protocol('WM_DELETE_WINDOW', quitter)
                                       #sortie par la petite croix (X)
#-------------------------------------------------------------------------------
#création objets graphiques
#-------------------------------------------------------------------------------
tex1=Label(fen, text='La saga Blink - Led clignotante', font="Tahoma 12 bold", fg="blue")
                                       #label message
tex1.pack(padx=5, pady=5)              #activation graphique

des1=Canvas(fen, width=largeur, height=hauteur, bd=0)
                                       #canvas pour le dessin de la led
center=int(largeur/2)
r=int((largeur-2)/2)
lumiere=des1.create_oval(center-r+1, center-r+1,center+r, center+r, fill=ledOff, outline="")
                                       #dessine led avec couleur éteinte
des1.pack()                            #activation graphique

bou1=Button(fen, text='Quitter', font="Tahoma 10", command=quitter)
                                       #button pour quitter l'application
bou1.pack(padx=5, pady=5)              #activation graphique

tex2=Label(fen, text='icarePetibles ', font="Tahoma 7")
                                        #label auteur 😉
tex2.pack(side=RIGHT)                  #activation graphique
#-------------------------------------------------------------------------------
initialisation()                       #paramètres de départ
maj()                                  #lance le 'Blink'
fen.mainloop()                         #boucle infinie graphique
fen.destroy()                          #destruction de la fenêtre
#-------------------------------------------------------------------------------

Normalement pour ce type de programme, la logique voudrait que l’on crée une classe pour l’application. Mais pour que le programme soit plus lisible, ce n’est pas le cas.
Notre programme comporte trois fonctions (initialisation, quitter et maj).

initialisation() : déclare et initialise le port GPIO via la bibliothèque RPi.GPIO (on aurait pu faire la même chose avec les autres bibliothèques).

quitter() : éteint la LED, libère la ressource port GPIO, sort de la boucle infinie et détruit le graphique. Cette fonction est appelée par le bouton quitter ou la petite croix (à droite et en haut de la fenêtre graphique).

maj() : cette fonction est appelée toutes les DUREE pour permuter l’état de la LED et l’affichage graphique.

Dans les lignes 65 à 78, on construit le support de notre fenêtre application. A la ligne 79, on capture le clic sur la petite croix.
Dans les lignes 84 à 102, on implémente les labels, bouton, canvas et dessin (LED).

Ligne 104 : on lance l’initialisation.
Ligne 105 : on déclenche le clignotement de la LED.
Ligne 106 : on active la boucle infinie graphique.
Ligne 107 : on détruit l’application graphique.

Exécution du programme

Pour exécuter ce programme, il faut lancer la commande suivante dans la console Linux dans l’environnement graphique :

python3 blink70.py

Pour sortir de la boucle infinie, il suffit de cliquer sur le bouton Quitter ou sur la petite croix.

Langage C

wiringPi

Pour ce programme, on utilise la même méthode pour sortir de la boucle infinie que pour pigpio. La saisie non bloquante d’un caractère clavier est incluse dans un fichier .h. Les experts du C vont voir tout rouge car on ne met pas de code dans un fichier .h, mais cela fonctionne et l’on fera mieux dans le prochain source. 🙂

Programme

Pour saisir ce programme, il faut faire dans la console :

nano saisieCarac.h

Cette commande ouvre un fichier texte vide appelé saisieCarac.h (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.


/* -----------------------------------------------------------------------------
Programme saisie non bloquante caractère au clavier
os                  : RPi Linux 4.4.13+
logiciel            : gcc (Raspbian 4.9.2-10) 4.9.2
cible               : raspberry Pi
date de création    : 22/06/2016
date de mise à jour : 22/06/2016
version             : 1.0
auteur              : icarePetibles
référence           : 
Remarques           :
----------------------------------------------------------------------------- */
#ifndef saisieCarac_h
#define saisieCarac_h
/* -----------------------------------------------------------------------------
Bibliothèques
----------------------------------------------------------------------------- */
#include <stdio.h>                     //bibliothèque standard
#include <termios.h>                   //bibliothèque entrées/sorties terminal
#include <unistd.h>                    //bibliothèque constantes symboliques
#include <fcntl.h>                     //bibliothèque descripteur de fichier
/* -------------------------------------------------------------------------- */
int kbhit(void){                       //fonction indiquant si frappe clavier
    struct termios oldt, newt;
    int ch;
    int oldf;
    
    tcgetattr(STDIN_FILENO, oldt);    //sauve paramètres terminal
    newt = oldt;
    newt.c_lflag = ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, newt);
                                       //nouveaux paramètres terminal
    oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
    fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
    
    ch = getchar();                    //lecture caractère
    
    tcsetattr(STDIN_FILENO, TCSANOW, oldt);
                                       //restaure paramètres terminal
    fcntl(STDIN_FILENO, F_SETFL, oldf);
    
    if(ch != EOF){
        ungetc(ch, stdin);             //replace le caractère dans le flux stdin
                                       //affiche le caractère dans la console
        return 1;                      //valeur de retour caractère saisie
    }
    return 0;                          //valeur de retour pas de caractère
}
/* -------------------------------------------------------------------------- */
#endif

Pour saisir le programme blink, il faut faire dans la console :

nano blink81.c

Cette commande ouvre un fichier texte vide appelé blink81.c (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

/* -----------------------------------------------------------------------------
Programme classique LED clignotante
Led rouge sur GPIO23 (4) via une résistance de 330 ohms
Ajout sortie boucle infinie et attente non blocante
os                  : RPi Linux 4.4.13+
logiciel            : gcc (Raspbian 4.9.2-10) 4.9.2
cible               : raspberry Pi
date de création    : 22/06/2016
date de mise à jour : 22/06/2016
version             : 1.0
auteur              : icarePetibles
référence           : www.wiringpi.com
Remarques           :
----------------------------------------------------------------------------- */
/* -----------------------------------------------------------------------------
Bibliothèques
----------------------------------------------------------------------------- */
#include <stdio.h>                     //bibliothèque entrées/sorties
#include <wiringPi.h>                  //bibliothèque wiringPi
#include "saisieCarac.h"               //fonction saisie caractère non bloquant
#include <ctype.h>                     //bibliothèque pour tolower()
//------------------------------------------------------------------------------
#define LED 4                          //numéro led = GPIO23
#define DUREE 1000
int main(void){                        //programme principal
    int c;                             //stocke touche clavier
    unsigned int valeurActuelle = 0;
    unsigned int valeurPrecedente = 0;
    int etatLed = FALSE;
    printf("Led clignotante\n");       //IHM
    printf("'q' pour arrêter le clignotement\n");
    wiringPiSetup();                   //numérotation wiringPi ou "pseudo Arduino"
    pinMode(LED, OUTPUT);              //pin en sortie
    digitalWrite(LED, LOW);            //led éteinte
    valeurPrecedente = millis();
    for(;;){                           //boucle infinie
        if(kbhit())                    //si touche saisie
            c = getchar();             //lecture touche
        if(tolower(c) == 'q')          //test si 'q' ou 'Q'
            break;                     //sortie de la boucle
        valeurActuelle = millis();
        if(valeurActuelle - valeurPrecedente >= DUREE){
            valeurPrecedente = valeurActuelle;
            if(etatLed){
                digitalWrite(LED, LOW);
                etatLed = FALSE;
            } else {
                digitalWrite(LED, HIGH);
                etatLed = TRUE;
            }
        }
    }

    digitalWrite(LED, LOW);            //éteint led
    pinMode(LED, INPUT);               //pi en entrée
    printf("\nFin du programme\n");    //IHM
    return(0);                         //code sortie
}
//------------------------------------------------------------------------------

Rien de neuf par rapport à ce que l’on a vu dans les programmes précédents.

Exécution du programme

Pour exécuter se programme, il faut d’abord le compiler. La compilation se fait par la commande ci-dessous (en mode console) :

gcc -Wall -o blink81 blink81.c -lwiringPi

Le résultat de la compilation est un fichier : blink81

Lancement du programme :

sudo ./blink81

Pour sortir de la boucle infinie, il suffit de faire un ‘q’ ou ‘Q’ au clavier.

Perso

Programme

Ce programme se compose d’un fichier blink52.c et de deux bibliothèques externes (saisieCarac.h et ipsGPIO.h). La bibliothèque ipsGPIO.h est la même que celle du paragraphe 5.2.

saisieCarac.h et saisieCarac.c

Pour saisir le programme saisieCarac.h, il faut faire dans la console :

nano saisieCarac.h

Cette commande ouvre un fichier texte vide appelé saisieCarac.h (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.


/* -----------------------------------------------------------------------------
Programme saisie non bloquante caractère au clavier
Fichier entête de saisieCarac.c
os                  : RPi Linux 4.4.13+ (Jessie)
logiciel            : gcc (Raspbian 4.9.2-10) 4.9.2
cible               : raspberry Pi
date de création    : 26/06/2016
date de mise à jour : 28/06/2016
version             : 1.0
auteur              : icarePetibles
référence           :
Remarques           :
----------------------------------------------------------------------------- */
#ifndef SAISIE_CARAC_h
#define SAISIE_CARAC_h
/* -------------------------------------------------------------------------- */
//prototypes fonctions
int kbhit(void);
/* -------------------------------------------------------------------------- */
#endif

Pour saisir le programme saisieCarac.c, il faut faire dans la console :

nano saisieCarac.c

Cette commande ouvre un fichier texte vide appelé saisieCarac.c (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.


/* -----------------------------------------------------------------------------
Programme saisie non bloquante caractère au clavier
os                  : RPi Linux 4.4.13+
logiciel            : gcc (Raspbian 4.9.2-10) 4.9.2
cible               : raspberry Pi
date de création    : 22/06/2016
date de mise à jour : 22/06/2016
version             : 1.0
auteur              : icarePetibles
référence           : 
Remarques           :
------
/* -----------------------------------------------------------------------------
Bibliothèques
----------------------------------------------------------------------------- */
#include <stdio.h>                     //bibliothèque standard
#include <termios.h>                   //bibliothèque entrées/sorties terminal
#include <unistd.h>                    //bibliothèque constantes symboliques
#include <fcntl.h>                     //bibliothèque descripteur de fichier
#include "saisieCarac.h"               //
/* -------------------------------------------------------------------------- */
int kbhit(void){                       //fonction indiquant si frappe clavier
    struct termios oldt, newt;
    int ch;
    int oldf;
    
    tcgetattr(STDIN_FILENO, oldt);    //sauve paramètres terminal
    newt = oldt;
    newt.c_lflag = ~(ICANON | ECHO);
    tcsetattr(STDIN_FILENO, TCSANOW, newt);
                                       //nouveaux paramètres terminal
    oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
    fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
    
    ch = getchar();                    //lecture caractère
    
    tcsetattr(STDIN_FILENO, TCSANOW, oldt);
                                       //restaure paramètres terminal
    fcntl(STDIN_FILENO, F_SETFL, oldf);
    
    if(ch != EOF){
        ungetc(ch, stdin);             //replace le caractère dans le flux stdin
                                       //affiche le caractère dans la console
        return 1;                      //valeur de retour caractère saisie
    }
    return 0;                          //valeur de retour pas de caractère
}
/* -------------------------------------------------------------------------- */

ipsGPIO.h et ipsGPIO.c

voir paragraphe 5.2.1.1

blink52.c

Pour saisir le programme blink52.c, il faut faire dans la console :

nano blink52.c

Cette commande ouvre un fichier texte vide appelé blink52.c (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

/* -----------------------------------------------------------------------------
Programme classique LED clignotante
Led rouge sur GPIO23 via une résistance de 330 ohms
Ajout sortie boucle infinie
Ajout attente non blocante
os                  : RPi Linux 4.4.13+ (Jessie)
logiciel            : gcc (Raspbian 4.9.2-10) 4.9.2
cible               : raspberry Pi
date de création    : 26/06/2016
date de mise à jour : 28/06/2016
version             : 1.0
auteur              : icarePetibles
référence           :
Remarques           :
----------------------------------------------------------------------------- */
/* -----------------------------------------------------------------------------
Bibliothèques
----------------------------------------------------------------------------- */
#include <stdio.h>                      //bibliothèque entrées/sorties
#include <ctype.h>                      //manipulation caractères
#include "ipsGPIO.h"                    //bibliothèque ipsGPIO
#include "saisieCarac.h"                //saisie caractère non blocant

#define DUREE 500                       //1/2 période clignotant
#define LED 23                          //led sur GPIO23

int main(void){                         //programme principal
    int c;                              //caractère clavier
    unsigned long int valeurActuelle = 0;
                                        //sauve temps actuel
    unsigned long int valeurPrecedente = 0;
                                        //sauve temsp précédent
    int etatLed = FAUX;                 //led éteinte
    affiche("Led clignotante");         //IHM
    afficheLn(" by icarePetibles");     //IHM
    afficheLn("'q' ou 'Q' pour sortir");//IHM
    modeBroche(LED, SORTIE);            //GPIO23 en sortie
    ecritureDigitale(LED, BAS);         //éteind led
    valeurPrecedente = mTemps();        //temps
    for(;;){                            //boucle infinie
        if(kbhit())                     //si touche saisie
            c = getchar();              //lecture touche
        if(tolower(c) == 'q')           //test si 'q' ou 'Q'
            break;                      //sortie boucle
        valeurActuelle = mTemps();      //temps
        if(valeurActuelle - valeurPrecedente >= DUREE){
                                        //si temps écoulé supérieure DUREE
            valeurPrecedente = valeurActuelle;
                                        //temps
            if(etatLed){                //si led allumée
                ecritureDigitale(LED, BAS);
                                        //éteind la led
                etatLed = FAUX;         //led éteinte
            }else{                      //si led éteinte
                ecritureDigitale(LED, HAUT);
                                        //éteind la led
                etatLed = VRAI;         //led éteinte
            }                           //fin (etat led)
        }                               //fin test DUREE
    }                                   //fin boucle infinie
    ecritureDigitale(LED, BAS);         //éteind led
    modeBroche(LED, DESACTIVE);         //désactive pin LED
    afficheLn("\nFin du programme");    //IHM
    return 0;                           //code sortie
}                                       //fin programme

Exécution du programme

Pour exécuter se programme, il faut d’abord le compiler. La compilation se fait par la commande ci-dessous (en mode console) pour les différents fichiers C en créant des fichier objet :

gcc -c ipsGPIO.c
gcc -c saisieCarac.c
gcc -c blink52.c

Et pour terminer, il faut créer le fichier final via l’éditeur de lien :

gcc -o blink52 blink52.o ipsGPIO.o saisieCarac.o

Le résultat de la compilation est un fichier : blink52

Lancement du programme :

sudo ./blink52

Pour sortir de la boucle infinie, il suffit de faire q ou Q au clavier.

Remarque : On peut supprimer les fichiers objets (.o) du répertoire courant par :

rm *.o

Node.js

Un langage qui fait beaucoup parler et qui devient de plus en plus populaire (à surveiller). C’est quoi node.js ? C’est simplement du Javascript mais côté serveur contrairement à la version classique qui s’exécute côté client. Pour en savoir plus, il suffit de consulter les tutoriels sur le net ou des ouvrages spécialisés.

Ce langage est séduisant et l’on peut créer un serveur web en 3 à 4 lignes.

Pour ma part, je suis relativement « étanche » à ce langage et, mes vieux neurones ont du mal à s’adapter, aux fonctions avec des fonctions en paramètres qui s’exécutent de manière non bloquantes.

Pour notre application, nous n’utiliserons pas le concept serveur web mais comme un langage traditionnel.

Programme

Le programme utilise un module complémentaire « onoff« . La procédure d’installation ainsi que la documentation sont disponibles sous le lien :
https://www.npmjs.com/package/onoff

Pour les plus curieux, on trouvera sous https://www.npmjs.com/, la liste impressionnante des modules disponibles.

Pour saisir le programme, il faut faire dans la console :

nano blink02.js

Cette commande ouvre un fichier texte vide appelé blink02.js (pour la sauvegarde faire Ctrl+o et pour sortir Ctrl+x).
Le contenu du programme et de ses commentaires sont représentés ci-dessous.

/* -----------------------------------------------------------------------------
Programme classique LED clignotante
Led rouge sur GPIO23 via une résistance de 330 ohms
os                  : RPi Linux 4.4.13+ (Jessie)
logiciel            : node v0.12.6
cible               : raspberry Pi
date de création    : 26/06/2016
date de mise à jour : 20/07/2016
version             : 1.0
auteur              : icarePetibles
référence           : https://www.npmjs.com/package/onoff
Remarques           :
----------------------------------------------------------------------------- */
var Gpio = require('onoff').Gpio,      //module onoff
    led = new Gpio(23, 'out');         //led sur GPIO23 et en sortie

DUREE = 500                            //demi-période clignotement (msec)

console.log('Début programme led clignotante');
console.log("'Sortie de la boucle infinie par ctrl+c'");
                                       //IHM

var iv = setInterval(function(){       //appel toutes les x milli-sec
    led.writeSync(led.readSync() === 0 ? 1 : 0)
}, DUREE);                               //durée de répétition

function exit(){                       //sortie de la boucle infinie
    clearInterval(iv);                 //arrêt clignotement
    led.writeSync(0);                  //éteint led
    led.unexport();                    //unexport GPIO et libère la resssource
    console.log('\nFin programme');    //IHM
    process.exit();                    //arrêt node
}
process.on('SIGINT', exit);            //capture du ^C et exécute exit()

Exécution programme

Pour exécuter ce programme, il faut lancer la commande suivante dans la console Linux :

node blink02.js

Pour sortir de la boucle infinie, il suffit de faire un Ctrl+c au clavier.

Conclusion

La saga pourrait continuer pendant des semaines et des semaines ou des pages et des pages. Finalement on va se trouver dans une situation de bis repetita.

On aurait pu utiliser d’autres langages (console ou graphique) pour commander notre port GPIO, comme Java, Scratch, Node-RED, C++, Pascal, Fortran, PHP, Javascript, etc…

green_blMais tout à une fin.

Peut être à bientôt pour une prochaine saga (pushButton, I2C, SPI, 1-Wire, interruption, etc…)

Sources

Vous pouvez télécharger l’ensemble des sources ici :
http://psl.ibidouille.net/Images_forum/raspberryPi/sagaBlink.zip

Partage de fichiers samba avec le Raspberry Pi

Pour diverses raisons, vous pouvez être amené à transférer des fichiers par le réseau vers votre Raspberry pi, ou au contraire en récupérer. Il est également possible de modifier directement un fichier par le réseau, pratique pour programmer le Raspberry Pi. Il existe pour cela de nombreuses solutions, mais nous verrons dans ce billet l’utilisation du protocole SMB, via le logiciel samba, qui permet de faire des « partages Windows » en reproduisant le protocole de ce système. Si ce n’est pas nécessairement le meilleur protocole pour tous les usages, il sera accessible depuis les postes sous Linux, Unix, Windows, ou encore MacOS, et donc probablement le plus répandu. Nous verrons ici comment installer et configurer tout cela sur votre Raspberry pi.

Nous verrons tout d’abord une fiche rapide pour réaliser le partage du répertoire home , sans explications, puis dans une seconde partie, nous verrons la même chose et d’autres en plus, mais cette fois ci avec des explications détaillées.

En résumé : fiche rapide

Samba possède de nombreuses options de configuration. Dans cette section du billet, nous faisons un récapitulatif rapide des étapes pour partager le home de l’utilisateur pi sous une raspbian :

Première étape : installer samba

Pour cela on se connecte au système sur un terminal pour lancer la commande suivante :

sudo apt-get install samba samba-common-bin

Seconde étape : configurer le partage

Il faut maintenant modifier le fichier de configuration de samba pour ajouter le partage voulu, en collant ceci à la fin, dans la section « shares« :

[[pihome]]
comment = code folder
path = /home/pi
writeable = yes
browseable = yes
read only = no
create mask = 0755

Troisième étape : définir le mot de passe utilisateur

Samba utilise des mots de passe différents de ceux du système, par défaut. Si nous essayons de nous connecter tout de suite, on n’y arrivera pas.  Il faut donc lancer dans un terminal la commande suivante :

sudo smbpasswd -a pi

On pourra ainsi définir le mot de passe pour l’utilisateur pi pour samba.

Quatrième étape (optionnelle) : changer le nom de la machine

Si vous souhaitez changer le nom de machine qui apparaitra sur le réseau, il suffit d’utiliser l’utilitaire raspi-config :

sudo raspi-config

Choisissez alors dans le menu l’option 8 Advanced options, puis l’option A2 Hostname. Passez le message, puis saisissez le nom souhaité en respectant les instructions.
Faites ensuite Finish, puis acceptez de redémarrer le système.

Redémarrer samba pour appliquer des modifications

Si vous redémarrez le pi, les modifications seront prises en compte. Mais ce n’est pas nécessaire, et il suffit de redémarrer le service samba quand on a modifié son fichier de configuration :

sudo service samba restart

Installation des logiciels

La première étape sera d’installer les logiciels requis. Commençons tout d’abord par samba. Pour cela, ouvrez un terminal ou une session ssh, puis tapez la commande suivante :

sudo apt-get install samba samba-common-bin

On vous demandera alors une confirmation, à laquelle vous pourrez répondre par « o » pour oui. Le système téléchargera et installera alors les fichiers requis.

sudo apt-get install samba samba-common-bin

sudo apt-get install samba samba-common-bin

En cas d’erreur suite à la commande précédente, n’hésitez pas à faire une mise à jour de la liste des paquets via un sudo apt-get update, toujours dans un terminal.

 

Configuration

Passons maintenant à la configuration du service. Selon ce que vous souhaitez, il faudra configurer d’une façon ou d’une autre celui ci, pour permettre l’accès aux utilisateurs autorisés seulement, à tout le monde, autoriser l’écriture ou non, etc…

Configuration pour un accès avec mot de passe

Si nous souhaitons pouvoir accéder à un répertoire en se connectant avec un nom d’utilisateur et un mot de passe, il faudra que cet utilisateur existe sur le Raspberry pi. Commençons tout d’abord par voir comment configurer le système permettre de se connecter avec l’utilisateur pi qui existe par défaut.

Pour cela, il faut modifier le fichier de configuration de samba, en faisant par exemple :

sudo nano /etc/samba/smb.conf

Si l’on souhaite partager le répertoire code on ajoutera par exemple ceci :

[code]
comment = code folder
path = /home/pi/code
writeable = yes
browseable = yes
read only = no
create mask = 0755

Dès lors, nous avons créé un partage accessible depuis le réseau. Toutefois, si l’on essaie tout de suite d’y accéder, cela ne fonctionnera pas, car l’utilisateur n’a pas de mot de passe défini pour samba. Pour y remédier, nous allons utiliser la commande smbpasswd :

sudo smbpasswd -a pi

Nous pourrons changer également le paramètre security, en dé-commentant la ligne suivante du fichier smb.conf :

security = user

Il suffit pour cela d’enlever le # présent devant. Cette ligne se trouve dans la partie authentication.
Cela permet d’augmenter la sécurité du système, puisqu’il faudra un compte utilisateur valide sur le système.

Par défaut, cela ajoutera également le partage du répertoire home (pi)

On peut alors appliquer les changements en redémarrant le service samba via la commande suivante :

sudo service samba restart

Pour accéder aux partages définis, il faudra ouvrir l’adresse réseau \\adresse_IP_du_RaspberryPi, puis ouvrir le partage. Il faudra alors ouvrir le partage et saisir les identifiants.

Configurer le serveur pour voir son nom sur le réseau simplement

Nous souhaitons maintenant pouvoir accéder à notre partage réseau sans avoir à connaitre son IP. Pour cela, il sera nécessaire de définir un nom pour le serveur.

Pour cela nous activerons le support wins, en dé-commentant/ajoutant/modifiant la ligne suivante

wins support = yes

Nous allons également changer/définir le nom d’hôte du Raspberry Pi. Pour cela deux solutions simples existent, nous rappellerons ici la première, qui est d’utiliser l’utilitaire intégré à Raspbian, raspi-config :

sudo raspi-config

Choisissez alors dans le menu l’option 8 Advanced options, puis l’option A2 Hostname. Passez le message, puis saisissez le nom souhaité en respectant les instructions.
Faites ensuite Finish, puis acceptez de redémarrer le système.

Pour plus d’informations sur le sujet (tutoriel détaillé avec les deux méthodes et illustrations), voyez ce billet que nous avons posté plus tôt.

Dès lors, il sera possible d’accéder au partage par le nom de la machine pour peu qu’elle soit sur le même réseau que les autres. Si nous n’avions pas défini le nom de la machine, celui ci aurait été raspberrypi par défaut, ce qui posera problème si plusieurs machines du même nom ont un service samba qui tourne.

On peut également forcer un nom d’hôte pour samba, en ajoutant la ligne suivante dans /etc/samba/smb.conf :

netbios name = nom_machine

Dans ce cas, le nom affiché dans les partages sera celui ci plutôt que le nom défini.

 

Ajouter des accès en lecture seule pour les utilisateurs invités (guest)

Voyons maintenant comment permettre aux utilisateurs non enregistrés (invités, ou guest) de pouvoir accéder à des fichiers (téléchargement), sans pour autant leur permettre de les modifier.

Il faudra pour cela ajouter dans le fichier smb.conf un partage comme le suivant :

[[public]]
        path = /home/pi/partage_lecture
        comment = partage accessible en lecture aux utilisateurs
        writable = yes
        guest ok = yes
        guest account = ftp
        guest only = no
        create mask = 0755 

 

La ligne qui permet l’accès aux utilisateurs invités est guest ok = yes.

Nous avons ici indiqué que les utilisateurs invités se connectent en tant que ftp, un utilisateur qui fonctionne généralement pour cet usage.  Trouvez plus d’informations dans la doc de samba relative à ce sujet sur ce lien (en).

 

Cet article Partage de fichiers samba avec le Raspberry Pi est apparu en premier sur Slog.

Un boitier pour faire une fausse caméra factice…

camera_lidl_250pxIl est pas beau ce boîtier de caméra factice ? Depuis ce matin dans les magasins LIDL (je n’ai pas d’action 🙁 ) on trouve cette caméra factice pour la modique somme de … 6,90€ !
Dans le catalogue « officiel » en ligne ça ne figure pas mais c’était dans le catalogue local, rubrique Soldes.
A ce prix là ça valait le coup d’essayer, surtout que les dimensions me semblaient intéressantes pour loger un Pi Zero…

Une caméra factice pour le Raspberry Pi

Un boîtier de caméra pas cher

Au jour dit, c’est à dire aujourd’hui, je fais donc un tour au LIDL du coin. Il y a toujours plein de gadgets et j’aime bien voir à quoi ça ressemble.

camera_lidl_20

Yesss il y en a ! Bin oui des fois il y a des trucs intéressants sur le catalogue et « Désolé on n’en a pas reçu » 🙁
Allez j’adopte une caméra factice ! Je la ramène délicatement à la maison avant de l’extirper de sa boîte.

camera_lidl_18Elle est protégée par un sac en plastique (on a plus le droit d’en avoir en caisse, mais il y en a toujours en boîte 😉
Une fois sortie (ci-dessus) elle a belle allure, non ? Tout est bien entendu en plastique (pour le prix vous ne pensiez pas avoir de l’aluminium quand même) mais ça présente bien.

Le contenu de la boîte

camera_lidl_14Au fond de la boîte on trouve les piles pour faire clignoter la LED, les vis et les chevilles pour fixer la caméra sur un mur et même…

Une notice à faire peur !

Une notice en plusieurs langues et qui fait plusieurs pages (14). Plus que certains autres appareils (enceintes Bluetooth, batteries de secours pour smartphone etc.)
Je pense que le gars qui a rédigé ça n’a jamais eu de bol, le pauvre !

lidl_0001
On apprend ainsi qu’il faut vérifier si l’appareil n’est pas endommagé. Dans ce cas ne pas le mettre en service 🙂 (il y a quand même 2 piles, une résistance et une LED à l’intérieur, faisez gaffe ! (non, ce n’est pas une faute, c’est voulu).
Sachez qu’il faut avoir plus de 8 ans pour utiliser cette merveille de la technologie moderne, et avoir des capacités physiques, psychiques et sensorielles non limitées. Si les personnes manquent d’expérience, elles doivent être surveillées et instruits de l’utilisation de l’appareil. Il faut aussi comprendre les risques dus à l’utilisation de l’appareil. Les enfants ne doivent pas jouer avec et l’entretien ne doit pas être fait par un enfant sans surveillance.
OUF ! je pense que ses gamins devaient être terribles 🙂

lidl_0002Après on passe aux piles ! Il y en a 2 quand même et là on a droit au danger de mort. Il faut consulter un médecin en cas d’ingestion 🙂 En gros (au moins du caractère 24 en gras) on apprend qu’il y a risque d’explosion ! En cas de fuite des piles il faut les retirer tout de suite de l’appareil… si vous touchez l’acide d’une pile rincez et courez chez le médecin!

lidl_0003Enfin, rien que de lire la notice on comprend mieux ce qu’est le principe de précaution 🙂 Je vous mets en copie ces pages, juste pour le plaisir !
Bon on va quand même regarder ce boîtier de plus près je suis prêt à assumer tous les risques (faut être un peu casse-cou pour acheter une boîte en plastique chez LIDL 🙂 )

Le système d’orientation

camera_lidl_06L’orientation de la caméra est confiée à une rotule. Une fois la caméra orientée, on serre la vis en tournant le bouton (à gauche sur la photo) et la rotule se bloque. Simple et efficace (et pas cher).

La fausse devanture

camera_lidl_07Là on s’y croirait : Deux (fausses) rangées de LED infrarouge pour la vision nocturne, une fausse lentille. De loin l’illusion est parfaite. Devant tout ça un morceau de plastique transparent.

Le capot

camera_lidl_15

Le capot est destiné à protéger le boîtier de la pluie et la face avant du soleil. Il se retire simplement en le faisant glisser vers l’avant.

camera_lidl_13Sur le côté l’inscription CCD camera 🙂

camera_lidl_16Ma foi de loin ça ressemble à une vraie caméra. La seule vraie LED est située en bas (elle est un peu différente des autres). C’est une LED clignotante (vous n’imaginiez quand même pas qu’ils allaient ajouter un circuit pour faire clignoter la LED… Même pas un bon vieux 555.

camera_lidl_19Le capot est enlevé. On voit ici sur le côté du boîtier la glissière dans laquelle le capot coulisse. Ainsi qu’une étiquette :

camera_lidl_02Elle confirme que la caméra est IP44 :

  • Le premier 4 signifie : Protégé contre les corps solides supérieurs à 1 mm.
  • Le second 4 signifie : Protégé contre les projections d’eau de toutes directions.

La face cachée

camera_lidl_17A l’arrière de la caméra factice un cache obture le boîtier.

camera_lidl_12Bien entendu le câble factice n’est relié à… rien, juste un coup de colle à chaud pour le fixer. Mais bon, le passage est fait pour un « vrai » câble 🙂 Ça ne se voit peut-être pas bien sur cette photo (un peu en haut à gauche quand même) mais le capot est équipé d’un joint caoutchouc qui devrait assurer une relative étanchéité à ce niveau.

Le boîtier de piles

camera_lidl_03Sur le dessus de la caméra factice, une fois le capot enlevé on découvre le logement des piles. Il est fermé par une trappe vissée. Comme c’est situé sous le capot amovible, il y a peu de risques que l’eau s’infiltre.

camera_lidl_04La trappe révèle le logement prévu pour 2 piles AA. A noter encore une fois la présence d’un joint autour du boîtier de piles pour améliorer l’étanchéité.

On met quoi là dedans ?

camera_lidl_05Ma foi, après démontage du capot arrière, cette photo montre la taille comparée du Raspberry Pi Zero et celle de la caméra factice…. hmmmm ça devrait rentrer 🙂 On regarde…

A l’intérieur dedans

camera_lidl_10Un Raspberry Pi Zero dans son boîtier entre parfaitement et il reste de la place entre le Pi Zero et le bas du boîtier de piles qu’on voit en haut du boîtier. La caméra n’est pas du bon côté mais elle tiendra sans problème côté façade. Je n’ai pas encore démonté la façade mais ça ne saurait tarder 🙂

camera_lidl_11Les deux fils (le rouge et le noir, comme dirait  Stendhal) vont des piles à la LED en passant par une résistance. c’est tout soudé en l’air (vu le prix, vous pensiez trouver un circuit imprimé avec un microcontrôleur ?)

Il reste de la place !

camera_lidl_09Largement assez pour glisser une clé USB WiFi TP-Link WN722N. Bon, faudra percer un trou pour passer l’antenne sur le côté et étanchéifier au silicone, mais ça devrait le faire.

camera_lidl_08Par contre pour la prise USB j’ai essayé avec un adaptateur pour le Pi Zero et là… Grand moment de solitude. La sortie de prise n’est pas coudée et ça ne passe pas. Il faudra donc sortir le fer à souder et relier directement l’USB de la clé WiFi sur les pastilles du Raspberry Pi Zero.

Les caractéristiques

  • Longueur du boîtier (sans le capot supérieur) 10 cm
  • Diamètre 6cm
  • Longueur du pied 15 cm
  • Poids 260 g
  • Protection IP44

 Conclusion

camera_lidl_01Bon, voilà c’est tout pour le moment mais j’ai pensé que l’info pourrait être intéressante. Il reste à virer la fausse lentille pour la remplacer par la caméra du Raspberry Pi, et à remplacer quelques fausses LED par des vraies LED infrarouge pour accéder à la vision nocturne.

Je ne pourrai pas m’atteler à ces modifs avant un petit moment donc si vous avez trouvé ce boîtier et fait les modifs, vous avez le droit (le devoir ?) de les décrire sur framboise314 qui vous accueillera avec plaisir ! Il faudra sans doute régler les problèmes de condensation qui ne manqueront pas de se produire au niveau du plastique de la face avant…

Pour 6,90€ voilà une caméra factice qui se transforme en vraie caméra et protège raisonnablement le Raspberry Pi. Alors est-ce que ça devient une fausse caméra factice ? ou une vraie fausse caméra ou une fausse vraie caméra… Je ne sais plus…

Si votre LIDL n’a pas cette caméra, cherchez chez les marchands en ligne français ou pas avec les mot clés caméra factice, fake caméra… vous devriez ramener quelque chose dans vos filets 🙂

Pour trouver l’inspiration visitez ces pages qui devraient vous donner des idées :

Raspberry Pi, caméra, timelapse

Raspberry : timelapse et sondes

Le boîtier est différent mais la réalisation est bien décrite 🙂

Bonne bidouille avec ce boîtier et n’hésitez pas à dire ce que vous en pensez dans les commentaires ci-dessous. Ils sont faits pour ça !

Lecture de code-barres avec le Raspberry Pi

barcode_250pxMalgré les QR-codes et autres lecteurs NFC, l’utilisation des codes barres ne se réduit pas. Depuis l’adoption de la norme UPC par le commerce de détail à la fin des années 70, les codes barres font parti de notre quotidien.
Vous les trouvez sur tous le produits vendus en supermarché ou en commerce à distance, les livres, revues….

Il y a quelque temps je vous avais présenté le test une enceinte Bluetooth AUKEY qui donne de bons résultats avec le Raspberry Pi 3. Elle me sert toujours pour écouter de la musique en écrivant les articles du blog.
Apparemment AUKEY est content de ce test et m’a proposé de tester un lecteur de code-barres sans fil pour vérifier qu’il fonctionne sur le Raspberry Pi. C’était l’occasion de récupérer une douchette scanner de code-barres et de revenir sur les codes-barres sur lesquels j’avais eu l’occasion de travailler professionnellement… dans les années 80 🙂
J’intervenais alors sur des systèmes de pointage horaire ou encore du suivi de production de moteurs… Déjà la traçabilité puisqu’on lisait le code de la personne qui intervenait en fabrication sur les éléments du moteur, le code de la pièce et qu’on enregistrait les temps d’intervention 🙁

============= Article sponsorisé =============

Lire les code-barres avec un Raspberry Pi

Code-barre, codes-barres, code à barres…

L’orthographe de notre sujet du jour n’est pas aussi nette que les barres qui composent le code :). Après s’être appelé code à barres il est devenu le code-barres (bin oui il y a plusieurs barres) et codes-barres au pluriel. On trouve aussi parfois codabar… Pour nos voisins anglo-saxons, c’est barcode qu’on le nomme.

Le code-barres : pour quoi faire ?

Le code à barres permet d’identifier un produit rapidement et il offre d’autres avantages : voici quelques utilisations courantes du code à barres :

  • Entrer un produit en stock
  • Sortir un produit du stock
  • Connaître le prix du produit
  • Lancer automatiquement une commande
  • Assurer la traçabilité d’un produit, d’un colis
  • Gérer des prêts de livres, de films

Quelques types de code-barres utilisés

Parmi la quantité de codes disponibles (voir les sources) voici quelques exemples qui vous rappelleront sans doute des choses… Avec un décryptage de ces codes. Mais si vous voulez en savoir plus, faites un tour chez Gomaro.

Code39

barcode-code39Le code 39 est le code-barres le plus utilisé dans les applications industrielles. Il est alphanumérique et permet de coder 43 caractères : 0-9, A-Z, plus quelques symboles (– , . , Espace, * , $ , / , + , %). Ce code-barres est de longueur variable, bidirectionnel (il se lit dans les deux sens). Son nom provient de sa structure qui est de 3 parmi 9.

Free_3_of_9_(Code_39_barcode)_600px
Chaque caractère est toujours composé de 9 éléments : 5 barres et 4 espaces.
Chaque barre ou espace est large ou étroit et 3 parmi les 9 éléments sont toujours larges. C’est d’ailleurs ce qui est à l’origine de son nom : Code 39

Code-barre 128

barcode-code128Le code-barres 128 est un code utilisé en transport, santé, industrie et distribution. Chaque caractère est composé de 11 modules blancs ou noirs. Ces 11 modules composent 3 barres et 3 espaces. La largeur de chaque barre et espace varie de 1 à 4 modules. Le caractère STOP est composé de 13 modules.

Code EAN13

EAN signifie European Article Numbering = Numérotation Européenne des articles.

barcode-EAN13-hortensiaCelui là vous le connaissez forcément, c’est celui qu’on trouve sur tous les produits vendus en supermarché. Il diffère de l’UPC qui suit par l’affichage de 13 chiffres au lieu de 12… D’où son nom EAN13 !
Celui-ci a été pris sur un Hortensia rouge vendu en jardinerie. Au début du code 33 représente la France.

UPC-EANLe code peut se décomposer comme sur l’image à gauche ( © Gomaro) : le préfixe est le code du pays, le N° de participant identifie l’entreprise.
Le N° d’article désigne l’article de ce fabricant.
Enfin un dernier chiffre sert de clé de vérification pour s’assurer que le code a été lu correctement.

barcode-EAN13-livre-pi2Celui-là est pas mal aussi… C’est un code débutant par 978, ce qui indique que c’est un livre. Ici c’est donc aussi le N° ISBN du livre (ah oui, c’est le Raspberry Pi 2 de chez ENI 🙂 )… L’ISBN (International Standard Book Number ou Numéro international normalisé du livre) est un numéro international qui permet d’identifier de manière unique chaque édition de chaque livre publié, que son support soit numérique ou sur papier. Il est destiné à simplifier la gestion informatique pour tous les intervenants de la chaîne du livre (imprimeur, éditeur, libraire, bibliothèque, etc.).

codebarre-ISBN_Pi2Après le code 978 qui indique que ce code concerne un livre, l’ISBN se décompose ainsi :

  • 1 chiffre pour le groupe
  • 6 chiffres pour l’éditeur
  • 2 chiffres pour le titre
  • 1 clé de vérification

Code-barres UPC

barcodeUPC-A-Raspi3C’est un équivalent américain du code EAN13. Historiquement le code universel des produits (en anglais Universal Product Code) est le premier système d’identification numérique utilisé aux États-Unis et au Canada, pour les articles vendus en magasin. Il a été inventé dans les années 1970 par George Laurer, ingénieur chez IBM, et adopté en mai 1973. Celui qui est représenté ci-dessus figure sur… la boîte d’un Raspberry Pi 3 made in UK, distribué par Kubii.

UPC_principeDans le code-barres, chaque chiffre est représenté par un agencement de barres et d’espace, au nombre de sept en tout.

Selon que le chiffre se trouve dans la partie gauche (L) ou droite (R), sa représentation diffère. Les R sont le complément à 1 des L.  Cette différence a pour but de permettre la reconnaissance du produit, que la lecture soit faite de gauche à droite, ou vice-versa.Les barres de garde, surlignées en vert, séparent deux groupes de six chiffres.

Depuis 2004, l’organisme de réglementation Uniform Code Council oblige tous les systèmes commerciaux de reconnaissance de code-barres à reconnaître l’UPC et l’EAN dès la fin de 2004.

Lecteur Code Barre sans Fil AUKEY

Livré rapidement par Amazon, le scanner code-barres AUKEY BS-W2 arrive dans une boîte qui annonce clairement le produit qu’elle contient :

boite1Une fois la couverture enlevée (elle se glisse tout simplement) on arrive à une boîte de carton fort dans laquelle le scanner de code-barres est maintenu par un emplacement en creux dans le support intérieur.

douchette_boite2Une fois sortie du sachet en plastique, on a en main une espèce de pistolet Laser à ravir un fan de Star Wars (quand ils sortiront le même au format sabre, je suis preneur 🙂 ). Sous le carton intermédiaire qui porte la douchette, on trouve le reste des accessoires.

douchette_contenu_boiteDe gauche à droite devant la scannette on trouve : Un manuel d’instruction qui comporte les codes-barres destinés à programmer et configurer le lecteur, le câble USB servant à relier le scanner à la prise USB d’un PC pour transférer les données et charger la batterie (1,5h de charge procure environ 30h d’autonomie). Devant le câble on voit le dongle USB qui sert à relier par radio (2,4 GHz) le scanner au PC quand il fonctionne sans fil et tout à droite la carte au format carte de crédit qui porte quelques codes essentiels. Elle évite de trimballer partout la notice et de la perdre en la posant quelque part et en l’oubliant… Que celui à qui ça n’est jamais arrivé me jette la première bière 😉

douchette_entiereOn peut voir ici la gâchette qui déclenche le tir Laser. La tête du scanner est entourée d’une protection plutôt rigide mais qui permet de poser le scanner sans prendre trop de précautions, si on n’a pas de support. A l’avant la fenêtre par laquelle le faisceau laser va sortir. Il faut veiller à la garder bien propre et l’entretenir sans la rayer.

douchette_USBDans la poignée on trouve la prise USB. Elle est bien à l’abri et ne risque rien en utilisation normale. Elle va permettre de charger le scanner ou de transférer les données à l’ordinateur sur lequel elle est connectée.

douchette_etiquetteSous la tête de la douchette on voit mieux la gâchette sur cette photo ainsi que l’étiquette d’identification de l’appareil qui rappelle aussi les dangers du LASER.

douchette_entiere2

Une fois mise sous tension, la douchette le signale par une lumière bleue. Après une minute d’inutilisation, la LED s’éteint et la douchette passe en veille pour réduire la consommation.

douchetteLa prise en main est bonne et la forme ergonomique de la douchette devrait convenir à toutes les tailles de mains (non, je n’ai pas de grosses paluches). Sur cette photo le film de protection est toujours en place sur le dessus de la douchette.

douchette_laserLorsque la douchette est en veille, si on appuie sur la gâchette, la douchette se réveille et émet trois bips. Un nouvel appui provoque un balayage LASER qui dure 3 secondes si aucun code n’est lu. Sur la photo ci-dessus on voit un scan réalisé sur une feuille blanche.

laser_600pxComme tout produit utilisant un laser, cette scannette peut être dangereuse.

La lumière cohérente monochromatique du LASER est susceptible de créer des lésions au niveau de l’œil, même à faible puissance.

Évitez de diriger le faisceau vers vos yeux ou ceux d’une autre personne même à une certaine distance. Prenez garde aux réflexions du faisceau qui peuvent être aussi dangereuses que le faisceau d’origine.

L’œil touché par un faisceau LASER va cligner (c’est un réflexe) mais même une brève exposition peut endommager la rétine de manière irréversible.

Un scanner LASER n’est pas un jouet et il doit être utilisé par un adulte connaissant parfaitement les risques générés de cet appareil.

laser_on_01

Projection du LASER sur la fenêtre de sortie

laser_on_FB

L’objectif de l’appareil photo est dans le faisceau du LASER

Caractéristiques

douchette_01

dimensions_600px

Les dimensions réduites et un poids de 400 grammes assurent une bonne prise en main, sans fatigue excessive après une utilisation prolongée.

  • Vitesse de balayage : 200 scan/s.
  • Plusieurs modes de lecture (scan unique, scan multiple, avec ou sans trigger, scan continu, scan impulsion)
  • Choix du pays (USA, Allemagne, France, Universel, Italie)
  • Codes compatibles: Codabar, Code 93, MSI, Code 128, UCC/EAN-128, Code 39, EAN-8, EAN-13, UPC-A, UPC-E , ISBN, Industrial 25, Interleaved 25, Standard 25, 2/5 Matrix, etc.

Le scanner BS-W2 lit uniquement les codes linéaires, pas les codes 2D comme le QRcode. Il ne peut pas lire les codes sur écran d’après le constructeur. Lors des tests j’ai pu lire sans problème des codes sur mon smartphone (Samsung Galaxy S4).

J’ai testé le matériel sur Windows 10 et Raspbian Jessie, sous Excel et sous LibreOffice sans rencontrer de souci d’installation ou de fonctionnement. En fait le scanner remplace le clavier et lorsque vous scannez un code-barres, celui-ci apparait dans la cellule en cours et le curseur passe à la cellule suivante.

Cette douchette sans-fil vous permet la lecture de codes-barres sans câble encombrant. Elle est livrée avec un émetteur/récepteur sans fil (2,4 GHz) qui se connectera en USB à votre PC, Mac ou Raspberry Pi. vous pourrez scanner dans un rayon de 40 mètres environ autour de votre station de travail.

La programmation se fait très simplement en scannant des codes inclus dans le mode d’emploi. Aucune installation de logiciel n’est nécessaire et en quelques minutes le scanner est prêt à fonctionner.

Il est possible de fonctionner en mode « inventaire », c’est à dire que le scanner enregistre les codes pendant l’inventaire. Quand l’inventaire est terminé les codes sont transmis à l’ordinateur.

La distance maximale de lecture va d’une trentaine de centimètres (code barre de 2cm environ) à cinquante centimètre pour des codes plus grands (voir la vidéo)

Le constructeur indique dans les caractéristiques que le lecteur LASER ne lit pas les codes sur les écrans. Effectivement sur l’écran du PC (HP L2245wg) il ne lit pas les codes-barres, par contre sur l’écran de mon portable (Samsung Galaxy S4) pas de souci pour lire les codes de mes cartes de fidélité enregistrées dans une appli.

Comment ça marche ?

Principe de lecture d’un scanner LASER

principe_scannerDans la tête de la scanette un miroir mobile est animé horizontalement par un moteur ou un dispositif du genre galvanomètre.

Une diode LASER envoie un faisceau sur le miroir. Ce faisceau est dévié de droite à gauche très rapidement par le miroir (220 fois par seconde sur le modèle BS-W2) puis envoyé vers l’extérieur au travers d’une fenêtre qui filtre la longueur d’onde du laser.

La lumière réfléchie par les objets qui reçoivent le faisceau LASER revient vers la fenêtre qui sélectionne la couleur du laser et élimine donc les lumières parasites.

anim_codebarre

Cette lumière est captée par un récepteur photosensible et le signal est analysé par un microcontrôleur pour en extraire un éventuel code-barres, déterminer le type du code, traduire celui-ci pour l’envoyer à l’ordinateur.

Synoptique d’une scanette

principe_lecteur_600pxSchématiquement et de manière simplifiée, voici les éléments constituant la partie active du scanner.

La programmation du scanner LASER

220px-DIN_Keyboard_ConnectorAh là… ça m’a rappelé lorsque je programmais les premières douchette pour PC dans les années… 1985. On intercalait une boite entre le clavier du PC et le PC lui même. La douchette venait se connecter sur le côté de la boîte (c’étaient des prises DIN à l’époque 🙂 ) et envoyait des codes pour simuler le clavier…

la douchette était livrée avec un classeur plein de codes qu’on faisait lire à la douchette pour la programmer. Ici c’est la même technique.

carte2 carte1Avec la douchette LASER on trouve cette carte au format carte de crédit. Elle permet rapidement de lire les codes les plus utiles : Appairer la douchette avec la clé USB (Pair Code) ou basculer du mode Inventaire au mode Normal et inversement.

De l’autre côté c’est le passage en mode transfert des données ou l’effacement des données en mémoire.

Faites attention de ne pas l’égarer, elle est vraiment utile 🙂

Au début c’est le manuel utilisateur qui servira à la configuration.

livret3livret2Les nombreux codes disponibles permettent de paramétrer la lecture, le transfert, les codes reconnus, le comportement du scanner. On pourra aussi régler les informations envoyées à l’ordinateur (CR, LF, CR+LF…).

Les principaux paramètres étant réglés, on peut passer à l’exploitation et lire des codes-barres.

Connexion sur un Raspberry Pi

Après un premier test réussi sur une machine équipée de Windows 10 j’ai connecté le dongle 2,4 GHz sur un Raspberry Pi.

raspi_barcode2La LED bleue s’allume… c’est bon signe. Un petit dmesg pour voir …

[ 320.028849] usb 1-1.4: Product: WPM USB
[ 320.028861] usb 1-1.4: Manufacturer: BarCode
[ 320.042608] input: BarCode WPM USB as /devices/platform/soc/3f980000.usb/usb1/1-1/1-1.4/1-1.4:1.0/0003:0416:C141.0001/input/input0
[ 320.101452] hid-generic 0003:0416:C141.0001: input,hidraw0: USB HID v1.10 Keyboard [BarCode WPM USB] on usb-3f980000.usb-1.4/input0

ma foi tout a l’air de bien se passer, le lecteur a été détecté par Jessie. lsusb -v pour voir comment le scanner est reconnu en USB

bInterfaceClass 3 Human Interface Device
bInterfaceSubClass 1 Boot Interface Subclass
bInterfaceProtocol 1 Keyboard

Tiens, un clavier… Donc sur les ports USB le dongle AUKEY, le scanner se présente donc comme un clavier. C’est ce qui lui permet d’émuler un clavier lorsque vous scannez un code. Il envoie directement le code à l’appli à votre place.

raspi_barcode3

Lorsqu’un code-barres est lu et correctement identifié, le scanner bippe et la LED à l’arrière du lecteur clignote de bleu à rouge. Le niveau du bip est réglable, ainsi que sa tonalité (en lisant des codes-barres dans la notice 🙂 )

Vidéo

Pour la vidéo, j’ai saisi une liste de matériel (les codes-barres sont rentrés avec la douchette évidemment). A chaque code-barres j’ai associé la désignation correspondante (la vraie) et un prix (fantaisiste). Il suffit de classer la liste du matériel dans l’ordre croissant des codes-barres pour pouvoir utiliser la fonction recherchev() dans la facture. Si vous voulez voir comment ça marche le fichier est disponible en téléchargement :).

Conclusion

Plutôt destiné aux entreprises, ce scanner LASER sans fil qui coûte moins de 50€ permet aux commerçants, libraires, bibliothèques ayant à gérer un stock ou à facturer des produits de le faire pour un prix abordable.

Sa bonne tenue en main, un poids léger (400g) et une autonomie de 30 heures à pleine charge lui permettent de s’aligner en comparaison avec les autres modèles (plus chers) sans rougir. Pendant la durée des tests qui se sont étalés sur plusieurs semaines je n’ai constaté aucun défaut de fonctionnement, que ce soit sur PC (sous Win10) ou sur le Raspberry Pi sous Raspbian Jessie.

Si je devais faire un reproche, ce serait celui-ci : il manque un logement pour ranger la carte de programmation. Je ne sais pas si vous êtes comme moi, mais j’ai une fâcheuse tendance à égarer (non pardon à ranger – trop bien) ce genre de choses après utilisation. Un système permettant de garder les codes DANS le scanner me semblerait une bonne chose.

attention-laserL’exposition aux sources lumineuses des rayons LASER peut entraîner des brûlures et des lésions irréversibles de la rétine (laser visible ou IR proche), de la cornée (laser UV, IR…) voire une perte visuelle définitive, une atteinte du cristallin par expositions répétées ou prolongées (cataracte). Ne dirigez jamais un faisceau LASER vers les yeux. Méfiez vous des réflexions du faisceau. Même à faible puissance le LASER est dangereux pour les yeux !

Sources

 

 

 

Un générateur de boite à hologramme ajustable pour écrans

Vous disposez d’écrans LCD dont vous n’avez plus besoin ? Voici un projet qui va vous permettre de les recycler. J’ai réalisé ce projet autour du générateur de pyramide présenté dans mon article précédent.

La technologie d’hologrammes utilisée repose sur un effet d’optique appelé Pepper’s ghost : le reflet d’un écran dans une vitre créé l’illusion, en regardant la vitre, que l’objet se trouve derrière. Pour ce projet, je place un écran suspendu au dessus d’une pyramide transparente donnant un corps aux reflets d’un écran non visible du spectateur.

Boite à hologramme

Ce générateur de boite est prévu pour des écrans allant des plus petites tablettes aux moniteurs de PC les plus grands. La boite a été envisagée sur une base carrée, désignant les dalles au format 4/3 comme étant les plus adaptées, sans limitation pour les 16/9eme. Le générateur fournit un fichier vectoriel destiné à une découpeuse laser, qu’on trouve couramment dans un fablab.

Boite à hologramme Boite à hologramme

Choix des matériaux

La boite peut être réalisée en medium ou en contreplaqué de 8mm minimum. Les colonnes de support entre la caisse inférieure et la caisse de l’écran peuvent être faites d’acrylique transparent (plexiglas) pour ne pas gêner la vision.

Le choix du matériau transparent de la pyramide est crucial. La vitre ne doit par exemple pas être un miroir, car l’oeil a besoin de voir à travers pour positionner l’objet dans la pyramide. Seconde contrainte, le matériau doit être aussi fin que possible, afin d’éviter un dédoublement du reflet. Ainsi, l’usage d’un miroir sans teint imposerait d’éclairer l’intérieur de la pyramide.

Je n’ai à ce jour pas trouvé de référence de produit pour le matériau de la pyramide. Dans un premier temps, j’ai utilisé de l’acrylique recouvert de film solaire teinté pour vitre de voiture, sans résultat :

Boite à hologramme

J’ai ensuite utilisé une pyramide achetée dans un kit pour tablette, le résultat est sans appel (voir plus haut). Je ne parviens toujours pas à trouver de matériau équivalent pour découper une pyramide à l’aide du générateur, aux dimensions de mon écran. Toute aide dans les commentaires serait très appréciée !

Détail de conception du prisme

Les moniteurs ont des dimensions standardisées selon deux critères : la diagonale et le format. Les diagonales courantes de dalles se mesurent en pouces, telles que 15″, 17″ ou 19″. Le format est la plupart du temps plus étiré que haut.

En construisant une pyramide à base carrée dont le côté mesure la hauteur de l’écran, on perd des pixels car l’écran est rectangulaire. À l’inverse, en construisant une pyramide à base carrée dont le côté mesure la longueur de l’écran, on perd de la surface vitrée. En construisant une pyramide à base rectangulaire, on obtient des faces ayant des angles de pente différents : le point de vue des observateurs cherchant le reflet varierait selon les faces.

La solution consiste à fixer un angle de pente pour les quatre faces puis à « allonger » une pyramide à base carrée sur une base rectangulaire aux dimensions de l’écran. On obtient un genre de prisme :

2. Pyramide étirée

Ce n’est plus une pyramide, c’est un polyèdre dont le sommet est une arrête. On peut optionnellement couper horizontalement le sommet et on obtient ceci :

3. Polyèdre tronqué

Cette dernière étape fait perdre un peu de surface d’affichage, mise à profit pour éclairer l’intérieur de la pyramide dans le but de renforcer l’effet d’optique selon les matériaux. Je n’ai pas encore essayé, mais y afficher des pixels blancs pourrait être suffisant.

Le choix de l’angle des faces du prisme se fixe arbitrairement. À 45°, la forme est trop basse pour être bien visible au centre de la boite, j’ai tendance à lui préférer 54,7° car on obtient ainsi des faces équilatérales, esthétiques, plus hautes.

Téléchargement du script

Tout ceci a été implémenté dans un script OpenSCAD qui permet de tout ajuster dynamiquement selon les mensurations de votre moniteur ! Il ne reste qu’à créer des applications générant des images divisées en 4. Le fond noir des images augmente significativement le contraste.

Imaginons que vous soyez un développeur et que l’envie vous prend de réaliser ce projet : venez en parler en commentaire ! Je suis certain qu’il est possible de créer des applications compatibles sur n’importe quelle boite, à condition de laisser l’utilisateur définir la surface vide au sommet du prisme, par exemple en pourcentage de la largeur de l’écran. Il sera ainsi possible de faire des applications interchangeables !

Démonstration du prototype

Hackable Magazine N°13 Raspberry Pi à donf !

couverture_hackable_43_250pxAvec juillet arrive la saison de la disette pour les lecteurs compulsifs que sont souvent les passionnés. (vous remarquerez que j’ai évité soigneusement d’utiliser le mot « été » peu approprié à décrire les conditions météo pourries que nous subissons depuis quelques mois 🙂 )
Il fallait donc que je mette dans la pile des revues estivales ce numéro 13 de Hackable Magazine en attendant de la lire…
Mais la présence insistante de nombreux Raspberry Pi et Arduino sur la couverture m’a fait anticiper ce moment et c’est finalement dès le retour à la maison que j’ai feuilleté ce numéro.

.

Hackable Magazine N°13, le plein de Raspberry Pi

J’avais eu l’occasion sur la page facebook de framboise314 de vous parler de HOP, qui milite contre l’obsolescence programmée.

L’édito de Denis BODOR dans ce numéro de Hackable Magazine va dans le sens de cet appel et j’espère qu’il me pardonnera de vous le présenter dans son intégralité. C’est un plaidoyer pour la réparabilité des objets de tous les jours, contrecarrée par les choix techniques des constructeurs, soit disant pour faire baisser les prix, en réalité pour nous forcer à acheter un nouveau produit en rendant les précédents irréparables !

hackable_43_edito

Au sommaire de ce numéro

Raspberry Pi 3 : une nouvelle carte pleine de ressources

hackable_43_01

Un article de présentation de la dernière carte de la Fondation Raspberry.

Il va bien au delà de la simple présentation habituellement trouvée dans la presse informatique qui se contente de recopier un communiqué, sans amener plus d’infos.

Ici vous trouverez plus d’infos sur le CPU, mais aussi sur la façon d’utiliser la sortie série du Pi 3 qui du fait de la fréquence différente d’une fréquence du noyau réglée à 400 MHz au lieu de 250 MHz dans les versions précédentes.

Utiliser des modules radio APC220

hackable_43_02

J’avais eu l’occasion d’utiliser ces modules APC220 il y a plusieurs années (4, c’était en Août 2012) sur un projet de voiture RC à base d’Arduino : ArduiCar.

Ici c’est sur un Raspberry Pi que ces modules seront greffés.

L’article explique d’abord comment paramétrer les modules pour être en conformité avec la réglementation française (sauf si vous êtes radioamateur 🙂 ) et les raccorder d’abord sur un Arduino, ensuite sur un Raspberry Pi.

Utilisables sur plusieurs centaines de mètres, ces modules vous seront utilise si vous souhaitez transmettre des données (9600 b/s).

Installez et utilisez la caméra Pi V2

hackable_43_03 hackable_43_04

Ces deux articles vous révèlent les secrets de la nouvelle caméra V2 de la Fondation Raspberry Pi. Avec ses 8 Mpixels et une version infrarouge, le module V2 est une source de découverte d’un monde caché à nos yeux.

 

Utilisez une imprimante thermique avec votre Raspberry Pi

hackable_43_05

Dans cet article vous découvrirez comment relier une imprimante thermique à votre Raspberry Pi.

Il faudra commencer par adapter le 3,3 volts des ports GPIO au 5 volts des entrées de l’imprimante. Cette tâche sera confiée à un adaptateur de niveaux.

Vient ensuite le moment d’imprimer « des trucs » sur le papier thermique. Des images ? Du texte ? tout ça vous est expliqué dans le détail avec en bonus des solutions pour venir à bout des problèmes posés par les lettres accentuées.

Convertissez une réglette lumineuse en affichage multicolore

hackable_43_06

Denis s’est attaqué à une réglette équipée de LED blanches.

Ça lui a permis de remplacer les LED d’origine par un ruban de LED intelligentes WS2812b.

Du coup la banale réglette d’éclairage se transforme en un objet attractif et vraiment intéressant !

C’est à un Arduino que sera confié la redoutable tâche de piloter les LED et de produire de superbes variations de couleurs.

Pour une quarantaine d’euros voilà un vrai hack Hard comme je les aime 🙂 Je précise car des lecteurs m’avaient fait remarquer qu’il est aussi possible de hacker le noyau de Linux… etc… Que voulez vous, je suis un « hardeux ».

Je sais bien que la réglette est en vertical, mais pourquoi avoir filmé ça dans ce sens ?

Apprenez à déchiffrer une datasheet

hackable_43_07

Si vous vous lancez dans des réalisations à base de Raspberry Pi ou d’Arduino, vous aurez certainement à utiliser des composants électroniques.

A mon époque on empilait sur l’établi des livres entiers contenant les caractéristiques de composants utilisés. J’avais une collection de gros bouquins au papier ultra fin, écrits en tout petit, pour l’analogique, le numérique, les transis, les diodes, les ampli-op…

Aujourd’hui quelques secondes suffisent pour charger le PDF contenant la notice technique d’un produit (datasheet= feuille de caractéristiques). Encore faut-il savoir la lire 🙂

Cet article décortique une datasheet pour vous apprendre à l’utiliser. Après avoir lu ces pages, vous pourrez vous aussi pousser le cri de guerre du Technicien : RTFM !

Conclusion

Un superbe numéro pratiquement 100% parfumé à la framboise !

J’avais attribué au numéro 9 de Hackable Magazine une framboise d’honneur 🙂 mais cette fois Denis s’est surpassé et c’est avec une émotion non dissimulée que j’attribue au N°13 de Hackable Magazine un Raspberry Pi d’or !

hackable_FB

Image du Raspberry Pi en Or : http://fieldguide.gizmodo.com/the-beginners-guide-to-the-raspberry-pi-1782608097

Merci Denis pour ce numéro très intéressant. Je ne sais pas si tu prends des vacances (la rédaction d’une revue comme Hackable ce n’est pas rien !) mais si c’est le cas, tu les as bien méritées ! On se retrouve à la rentrée pour de nouvelles aventures 😉

Sources

Ne négligez pas la qualité de la carte SD de votre Raspberry Pi !

evo_250pxLa carte microSD, un élément de votre Raspberry Pi qu’il ne faut pas négliger ! L’idée de ce billet est née lors de tests.
J’avais besoin de plusieurs cartes SD une montée sur le RasPi, une autre pour préparer le prochain test. J’en récupère une sur le bureau qui était dans un adaptateur SD <=> microSD un peu poussiéreux… je la prépare avec Win32DiskImager ah oui …. la vitesse est autour de 4 Mo/s. Vérification faite à la fin de l’opération (à la loupe car c’est écrit trop petit pour mes vieux yeux) c’est une classe (4) sans marque. Enfin si… Made in Taiwan.

La carte SD au cœur du Raspberry Pi

Bon, je continue mes tests en mettant la carte dans le RasPi. Mise sous tension… les 4 framboises, le texte défile… ça me semble normal. Et là, soudain tout bascule 🙁 Un écran noir, quelques clignotements de la LED ACT et…. rien !
Au bout d’un long moment, je me dis que la carte n’est pas bonne. Qu’à cela ne tienne, je la remets dans le lecteur de carte SD et… réécriture. Retour au RasPi ! Même combat ! arghhh

Les cartes SD

30c3-controllerCe sont des cartes mémoire dont la plupart embarquent un microcontrôleur de type ARM ou 8051, modifié par le constructeur afin de permettre une accélération matérielle des algorithmes contenus dans le micrologiciel de la carte. Ce microcontrôleur ainsi que le micrologiciel qu’il contient permettent une gestion des cellules de mémoire flash et de leur usure ainsi que la communication avec le système.

Dans la majorité des cas, les cellules de mémoire flash et le microcontrôleur se trouvent sur la même puce, ce pour des raisons pratiques. L’usure est due uniquement aux phases d’écriture. Selon la technologie le nombre d’écriture avant panne peut varier de 10 000 à 100 000. Ceci peut causer des problèmes sur un système qui accède (très) fréquemment au système de fichier sur la carte microSD (Raspbian).

sd_600pxLe micrologiciel embarqué peut être réécrit grâce à une séquence précise de commandes non documentée, variant d’un constructeur à l’autre. Certaines cartes MicroSD embarquent ainsi un micrologiciel modifié afin de masquer leur capacité réelle, comme dans le cas de cartes de contrefaçon, qui annoncent une capacité supérieure au nombre de blocs réellement disponibles. Cette annonce de capacité erronée peut conduire à des pertes de données, par réécriture des blocs précédents lorsque la capacité physique maximale est atteinte, certains blocs étant dupliqués par le micrologiciel modifié. (source Wikipedia)

Le Raspberry Pi

 La vitesse d’accès à la carte Sd est exactement la même sur un Rasperry Pi 2 et un Raspberry Pi 3. La principale limitation est le fait que le bus du lecteur de carte est limité à 20 Mo/s. Sur le RasPi 3 il est possible (mais pas recommandé à cause des erreurs qui se produisent) d’overclocker le bus à 40 Mo/s (http://www.jeffgeerling.com/blog/2016/how-overclock-microsd-card-reader-on-raspberry-pi-3).

cartes-memoires-sd-micro-sd_600px

image (c) http://www.cnetfrance.fr/produits/les-5-raisons-d-acheter-une-carte-sd-haute-performance-39799131.htm

Le test de démarrage

pi3_prises_600pxJe me suis placé dans les mêmes conditions pour les deux tests c’est à dire un Raspberry Pi 3 avec un système (la dernière version de Jessie en mode graphique), entièrement à jour (update/upgrade/rpi-update) en fonctionnement et déclenchement du chrono lors du clic sur le bouton Reboot. Arrêt du chrono lorsque le bouton « Menu » s’affiche dans la barre de tâches du bureau.

  • Carte Samsung EVO 16 Go Classe (10) : 25 secondes
  • Carte sans marque 8 Go Classe (4) : 2 minutes 35 secondes

carte_SD_FB

Une anecdote pour finir

Un de mes collègues qui gère son poulailler avec un Raspberry (projet PoulaGeek) se plaignait de plantages, carte microSD corrompue… Après avoir refait la carte avec Win32DiskImager ça refonctionnait une quinzaine et… rebelote ! Je lui ai conseillé de tester une carte EVO 16 Go comme celles que j’utilise (ce n’est pas de la pub, ce sont les cartes que je trouve au supermarché d’à côté à 8€ environ). Depuis je n’ai plus entendu parler de soucis avec sa carte SD.

Conclusion

Ne lésinez pas sur la qualité des cartes microSD que vous utilisez. Les quelques euros que vous économiserez, vous les repaierez en temps perdu à attendre votre système ou à refaire une nouvelle carte. Il faut savoir aussi que les cartes microSD comme tous les composants électroniques ne sont pas strictement identiques. A la sortie de la chaîne de fabrication, chaque composant est testé et classé en fonction de sa vitesse, des cellules mémoire défectueuses… Sans pouvoir vous le garantir à 100%, les microSD de meilleure qualité sont vendues par les « grands noms » alors que les mémoires « déclassées » finissent avec des marques folkloriques ou… pas de marque du tout !

panneau_danger_80pxPour plus de sécurité : Une carte microSD n’est pas éternelle. Un jour ou l’autre elle va lâcher ! Prévoyez d’en faire une copie de secours (Win32DiskImager sous Windows ou dd sous Linux) sous forme d’un fichier .img que vous ne mettrez que quelques minutes à transférer sur une carte neuve. La dernière version de Jessie embarque aussi un utilitaire qui peut cloner votre carte microSD à chaud… Vous ne pourrez plus dire que vous n’étiez pas prévenu(e).

Sources

On Hacking MicroSD Cards

 

Un JukeBox à base de Raspberry Pi et Subsonic

jukebox_250pxA la une un projet présenté par Philippe qui a travaillé dessus plusieurs mois fin 2015. Et il a des argument pour justifier son choix !
« Quoi de mieux pour écouter de la musique que de mettre une pièce dans une fente et d’appuyer sur un gros bouton ? De hocher la tête au rythme du morceau en s’appuyant sur une machine et en sirotant son demi ? D’imposer à toute une assemblée votre morceau de merde préféré, car c’est vous, beau gosse, qui avez mis la pièce ?« 

Un JukeBox DIY

Pour toutes ces (bonnes ?) raisons, Philippe s’est lancé dans la construction de son JukeBox qu’il a bâti autour d’un Raspberry Pi…

Le cahier des charges

  • un truc encombrant et intransportable
  • un nombre de morceaux limité (on écoute pas ce qu’on veut, on écoute ce qui est proposé)
  • des gros boutons sur lesquels on peut appuyer avec conviction
    (pas d’écran tactile, c’est désuet)
  • une interface utilisateur hyper simple sans fioritures, utilisable dans toutes les conditions
    Note de framboise314 : Après plusieurs bières, il vaut mieux que l’interface soit simple, non ? 🙂
  • un monnayeur mécanique avec une pièce qui doit faire du bruit en tombant,
    genre TCHING SHLINK

La réalisation

Philippe est parti d’un Raspberry Pi 2 dont il disposait, surtout à cause du GPIO grâce auquel il pourra interagir avec la framboise.

int_circuit

Le Raspberry Pi 2 est surmonté d’une carte HAT perma-proto d’Adafruit. Cette carte assure la liaison avec les boutons poussoirs, monnayeur…

Pour lire la musique il a utilisé Subsonic. Il s’agit d’un serveur de streaming développé en java, et doté d’une API hyper claire et facile à mettre en œuvre et très compréhensible. Seul petit bémol l’utilisation de l’API au delà des 30 jours d’essai nécessite l’achat d’une licence à 12$.

screenshot

Toute la partie gestion du catalogue musical se fait via l’interface d’administration de Subsonic (upload des morceaux, recherche des pochettes, création de la playlist). Mais si on ne veut/peut pas raccorder le JukeBox au réseau on peut aussi copier directement des morceaux via une clé USB dans le bon répertoire.

La partie ampli

Philippe ne donne pas beaucoup de détails sur la partie audio de son JukeBox mais il cite ses sources : ce sont les vide-greniers qui lui ont permis de récupérer le matériel nécessaire à l’amplification du signal fourni par le Raspberry Pi.

Pour réaliser votre JukeBox

Vous disposez de toutes les informations nécessaires sur le blog de Philippe, les photos vous aideront pour la réalisation pratique.

La partie logicielle est quant à elle disponible sur GitHub.

Ce qu’il reste à faire (TODO list)

  • Un script pour tout lancer au démarrage (plus besoin de connecter un clavier et une souris)
  • Ajouter des « cheat codes » pour avoir des chansons gratos 🙂 (en appuyant sur les boutons selon une séquence)
  • Debugger l’arrêt du jukebox (en commentaire dans le script python : Si on appuie plus de 5 secondes, le Jukebox s’éteint)
  • Un client pour les API Spotify et Deezer
  • Trouver un nom sympa pour le projet  😀

Photos

jukebox_03

La pièce, dans sa chute, actionne le microswitch

jukebox_04

Pour moi ce sera ABBA ! bin oui, c’est de mon époque :)

jukebox_01

Un look superbe pour le JukeBox de Philippe

jukebox_05

A l’arrière une porte qui ferme à clé. Ici on voit bien la forme de la poignée… Notez également les coins protégés comme sur les flight cases

jukebox_02

Les pièces de 20 centimes tombent dans la boîte (c’est le côté chling-blinggg), les autres suivent la glissière en bois pour ressortir en façade

le_son

Le son provient d’un ensemble Logitech pour PC avec caisson de basses.

Avertissement

Vous devez bien entendu utiliser des morceaux dont vous avez les droits, et/ou possédez les originaux. N’utilisez que vos pièces de 20 centimes à vous. N’utilisez pas votre jukebox autrement que dans le cadre familial. Et surtout n’essayez jamais de le transporter seul 🙂

Vidéo

Conclusion

ext_troisquarts_hautUne belle réalisation, imposante par la taille et par la qualité de sa présentation.

Bravo Philippe pour la qualité de cette réalisation et aussi pour la volonté de la partager avec la communauté Raspberry Pi (sur un ton humoristique et agréable à lire 😀 )

Si vous pensez pouvoir aider Philippe à terminer son projet, prenez contact avec lui via son blog 🙂

Sources

Vos câbles sur mesure avec l’Atelier du Câble

cable_250pxVous avez besoin d’un câble ? Vous ne le trouvez pas sur Internet ? Ou alors vous n’êtes pas certain de la qualité de ce que vous allez recevoir ?
Une entreprise française      l’Atelier du Câble vous propose de composer votre propre câble, de choisir vos prises pour adapter votre câble à votre appareil : smartphones et tablettes Android, Samsung, HTC, Nokia, Sony et autres Apple Lightning.

Le câble sera fabriqué à la demande dans les ateliers de l’Atelier du Câble.

Un câble à la demande

fond_01_600pxLe câble utilisé est du type 21AWG, il permet de charger vos appareils jusqu’à 2 ampères. Il devrait permettre de recharger vos appareils rapidement.

Pour mémoire, je vous joins le tableau que m’a envoyé Dodutils sur les câbles et leur utilisation:

courant_maxLa résistance pour 30 cm est exprimées en milli-ohms. Comme on peut le deviner ou le calculer, plus le câble est long…. plus il est résistant …  La longueur d’un câble influe donc directement sur la vitesse de charge. Pour les appareils gourmands, il est conseillé de ne pas dépasser le double de la longueur du câble vendu avec votre appareil. Le câble est compatible Qualcomm Quick Charge, Samsung Adaptative Fast Charging.

fond_04_600pxCe câble existe en plusieurs couleurs, il est constitué d’un matériau qui dure dans le temps, tout en restant flexible (ø 3.6mm).

Vous pourrez également transférer vos données rapidement (USB 2.0 High Speed, jusqu’à 45 mo/s – Donnée théorique maximale, dépend de la configuration utilisée).

C’est quoi un bon câble USB ?

La vitesse de chargement et de transfert de vos fichiers est intimement liée à ces quatre fils.

Charger vite

Les deux règles à connaître sont :
– plus un fil est long, plus sa résistance est grande
– plus un fil est fin, plus sa résistance est grande

La résistance s’oppose au passage du courant électrique et dissipe l’énergie perdue … sous forme de chaleur (c’est ce qui fait que vos câbles chauffent parfois). Pour que le courant passe de façon optimale, elle ne doit donc pas être trop importante.

Transférer vite

Pour les fils qui servent au transfert des données, c’est une autre paire de manches. La norme USB dit que «deux appareils doivent pouvoir échanger en moins de 26 nanosecondes» (26.10-9s ou encore 0.000 000 026 seconde).

Sachant qu’un fil transporte vos fichiers à 5,2 nanosecondes par mètre en moyenne, quelle est la longueur maximale à ne pas dépasser ?

Note de framboise314 :
Dans un câble la vitesse du signal v est proche de 0,66.c avec c = 300 000 Km/s (la vitesse de la lumière dans le vide) donc  v = 200 000 Km/s  ce qui fait voyager le signal aux environs de 5 ns/m

Bon, à la louche, il faut éviter qu’un câble USB ne dépasse 5 mètres pour transférer des fichiers en respectant la norme

Protéger le câble des perturbations

Il y a plusieurs options :

  • Feuillard en aluminium : nom barbare qui veut tout simplement dire du papier d’alu qui entoure complètement les fils (presque le même que pour les trois parts de pizza qui reste d’hier).
  • Tresse de fils de cuivre : les fils y sont enfermés ce qui permet de bloquer les perturbations grâce aux propriétés du cuivre.

01_shields_v2_600px

iphone-cable-casse

Ce qui arrive avec un câble de mauvaise qualité

L’Atelier du câble combine ces deux techniques et utilise le blindage pour feuillard d’aluminium + tresse pour stopper les perturbations et éviter que le feuillard en aluminium se déchire.

tresse

Un câble solide

  • Connecteurs moulés : les connecteurs sont formés en enrobant la prise soudée dans du  plastique en fusion grâce à des moules ; quelques secondes de séchage plus tard, c’est prêt ! Du coup, plus de connecteurs qui explosent en morceaux, les soudures sont protégées et la partie flexible réduit le risque que le câble se déchire.
  • Plastique haut de gamme : il existe de nombreux types différents de matières plastiques. L’Atelier du Câble utilise un plastique qu’on appelle élastomère thermoplastique ou TPE (mélange de plastique qui fond à la chaleur et de caoutchouc).
    Avec cette matière les câbles sont flexibles, résistants et très doux.

Un assistant en ligne

selecteur de type de câbleAvec l’assistant en ligne vous pourrez choisir le type de prise à chaque extrémité, leur couleur, la longueur du câble entre 30cm et 3 mètres ainsi que sa couleur !

fond_02_600pxSmartphones et Tablettes Android, Windows Phone, Blackberry ou Lightning pour Apple mais aussi disques durs externes et manettes: PS4, Xbox One, PC, PS Vita… pourront être connectés avec un câble assorti à leur couleur.

fond_03_600pxPour un câble d’alimentation Raspberry Pi, comptez de 14 € à 19 € selon que votre câble mesure de 30 cm à 3 mètres.

Les possibilités

cable_animation

Quelques informations sur la fabrication

Les tests

Les câbles de présérie ont été soumis à des tests d’arrachement après brasure mais avant encapsulation/moulage sur micro USB (c’est la prise la plus fragile) afin de vérifier la bonne tenue des brasures.
Les résultats ont été satisfaisants puisque le câble c’est rompu à plus de 30kg de traction, et

  • Les 2 fils AWG21 (+5v et GND) ont arraché les pastilles du connecteur micro USB
  • L’âme des 2 fils AWG28 (data + et -) s’est rompue à quelques mm de la soudure
  • Les brasures sont restées intactes, ce qui prouve leur qualité

Pour tester la protection électromagnétique amenée par le blindage du câble (tresse de masse + feuillard alu) il a été testé dans diverses situations, et le débit de l’USB 2.0 (45Mo/sec) est bien atteint. Par exemple :

  • Câble de 5m enroulé autour d’un appareil en plein transfert WiFi puis 4G
  • Câble de 5m à proximité de cordons d’alimentation secteur 220v (PC/ecran)
pret_a_partir_600px

Câbles avant livraison

Aujourd’hui chaque câble est testé avant expédition :

  • Vérification de la charge avec un testeur USB (comme celui que je vous ai déjà présenté)  et une tablette Lenovo MIIX 3 à 20% de batterie pour s’assurer que le débit de courant en fonction de la longueur du câble répond bien aux spécifications annoncées.

Afin d’améliorer la productivité et la qualité des câbles produits, l’Atelier du Câble est en train de développer un banc de test automatique :

  • Vérification du câblage de tous les fils (la continuité ainsi que l’absence de court-circuits)
  • Vérification de la présence de l’option OTG ou non
  • Vérification, par rapport aux spécifications de la résistance du câble sur les lignes +5v et GND grâce à une mesure 4 points sous 1A.

Dans un second temps il est prévu de vérifier également le diélectrique (rigidité et isolement)

Coté fabrication

soudure_cable

L’Atelier du Câble a mis en place une procédure de fabrication stricte pour garantir la plus grande résistance physique :

  • Afin de préserver la solidité des connections (Câble/Connecteur), elles sont encapsulés avec une colle spéciale polymérisant aussi bien sous lampe UV (en quelques secondes) qu’à l’air ambiant.
  • Les connecteurs sont renforcés par des « housing » lesquels sont sertis sur le câble afin de solidariser l’ensemble.

Conclusion

logoSuite au message de Flavien qui m’a présenté l’Atelier du Câble, j’ai décidé de vous présenter cette entreprise et commandé un câble spécial Raspberry Pi, rose d’un bout à l’autre !

cable_Raspi

Il est pas beau mon câble spécial Raspberry Pi ?

L’idée c’est de soumettre ce câble à la torture, c’est à dire l’utiliser pour alimenter un Raspberry Pi 3 « bien chargé ». Ça permettra de juger de la tenue de cet accessoire dans le temps et de mesurer la chute de tension entre les deux extrémités.

Avec une dimension de 21AWG il ne devrait normalement pas y avoir de problème mais c’est à vérifier.

Il faut savoir que l’atelier du câble offre 30% de remise aux lecteurs de framboise314 avec le code promo
FRAMBOISE314_30WYJ
que j’ai pu tester avec succès lors de mon achat.

Pour le reste, le paiement se fait sur le site de la banque de l’Atelier du câble, et j’ai reçu un SMS de confirmation de ma propre banque pour valider l’achat 🙂

reduc_600pxUn regret cependant, celui de ne pas avoir trouvé de solution Paypal pour le paiement, mais pour une entreprise qui démarre on peut comprendre qu’il ne soit pas facile de cotiser à plusieurs systèmes de paiement en ligne…

micro_usb_600px

Oui le prix de ce câble est plus élevé que ceux qu’on trouve sur des sites de vente asiatiques, mais vous avez l’info sur la qualité de câble utilisé et vous pouvez commander la longueur dont vous avez besoin à 10 cm près. Pour des installations audio exposées à la vue, la couleur et une longueur adaptée sont un vrai plus !

fond_05_600px

J’ajouterai à la suite de cet article les infos sur la réception du produit, les photos et les tests…

======= Ajout du 4 juillet 2016 ====================================================

Ayé, j’ai reçu mon câble de L’Atelier du câble !

boite_fermee_600pxCommande passée le 28 juin, expédiée le 30 juin, reçue le 1er juillet! Bien entendu pour équiper un Raspberry Pi j’ai opté pour… la version Pink Only, rose de chez rose 🙂 un vrai câble de princesse.

boite_600pxj’ai intérêt à le planquer si je ne veux pas me le faire faucher par une de mes petites filles 😉

cable_600pxLe câble est de belle facture, « fabriqué selon une méthode secrète ancestrale qui se transmet de génération en génération »!

micro_USB_600px

Je vous joins quelques images en attendant les tests. Le câble est arrivé bien emballé dans une boîte qui contenait… la boîte qui est sur la première photo – je l’avais ouverte avant de faire les photos, l’impatience…- il est tenu enroulé par deux colliers Velcro qui resserviront lors du rangement.

USB_600px

Les prises sont moulées et comportent le logo de l’Atelier du câble. Je vous joins un scan des deux faces de la carte jointe qui certifie le câble (câble USB=>microUSB, fabriqué le 29 juin par Jean). Je vous conseille la lecture des petites lignes, un trésor d’humour 🙂

carte1

carte2

Source