Normalement, lorsque vous achetez un éclairage domestique que vous souhaitez contrôler électroniquement, vous devez installer un logiciel personnalisé. Mais avec le protocole ZigBee et la passerelle RaspBee II, vous pouvez utiliser des appareils compatibles et des logiciels libres. Dans cet article, je vais vous montrer comment ajouter un service API en Go personnalisé à la pile. 

Dans le diagramme suivant, vous pouvez voir la pile logicielle que j'utilise pour le projet : 

![Pile logicielle](https://res.cloudinary.com/dxxtt2clx/image/upload/v1710517369/Screenshot_2024_03_15_at_16_42_22_8508b85b01.png) 

## ZigBee 

ZigBee est une spécification basée sur l'IEEE 802.15.4 pour une suite de protocoles de communication de haut niveau utilisés pour créer des réseaux personnels avec de petites radios numériques de faible puissance. Il est souvent utilisé dans la domotique, mais aussi dans d'autres contextes tels que la production industrielle ou les appareils médicaux. 

Sa principale caractéristique est qu'il ne consomme pas beaucoup d'énergie. Par conséquent, elle peut souvent fonctionner sur batterie pendant une longue période. Le revers de la médaille est que son débit de données est également faible. Mais pour allumer et éteindre des lumières, c'est suffisant. 

Lorsque vous achetez un appareil compatible ZigBee, comme une bande lumineuse LED, vous avez besoin d'une passerelle pour contrôler l'appareil. 

## RaspBee II Gateway 

L'une de ces passerelles ZigBee est la [Raspbee II gateway](https://phoscon.de/en/raspbee2) que j'utilise dans le cadre de cet article. RaspBee II est développé par Dresden Elektronik en Allemagne et est une carte d'extension qui s'adapte à un Raspberry Pi standard. RaspBee II est livré avec une application logicielle appelée "deCONZ" qui s'interface avec le matériel. 

L'avantage de deCONZ est que vous pouvez l'intégrer facilement à Home Assistant, ce qui vous permet de contrôler la passerelle ZigBee directement dans Home Assistant. 

## Home Assistant 

[Home Assistant](https://www.home-assistant.io) est une application de domotique open source très répandue. Elle a été développée à l'origine par Paulus Schoutsen et publiée en 2013. Elle est écrite en Python et dispose d'une interface web mais propose également des applications mobiles. 

Dans Home Assistant, vous pouvez ajouter deCONZ en tant qu'intégration. Ainsi, vos appareils ZigBee reconnus par deCONZ sont également disponibles dans Home Assistant. Vous pouvez alors configurer des routines d'automatisation simples. Par exemple, si vous avez un détecteur de mouvement, vous pouvez ajouter une routine d'automatisation qui allume les lumières dès qu'un mouvement est détecté. Mais pour notre objectif, nous voulons intégrer MQTT et contrôler les lumières via MQTT. 

## Mosquitto 

MQTT est un protocole léger de publication et d'abonnement qui est souvent utilisé dans les scénarios de domotique. Les applications peuvent communiquer entre elles à l'aide d'un mécanisme de messagerie de type publication-abonnement. Dans notre cas, je l'utilise pour contrôler l'état des lumières LED. 

Mais tout d'abord, nous devons installer un courtier MQTT. Un courtier MQTT open source populaire est Eclipse Mosquitto. Il est facile à installer et à configurer. Dans mon cas, je l'ai installé sur la même machine que Home Assistant. Ensuite, vous configurez une automatisation dans Home Assistant qui réagit aux messages reçus sur un canal MQTT et qui allume ou éteint les lumières LED. 

Vous pouvez voir ma configuration dans la capture d'écran suivante : 

![Home Assistant MQTT](https://res.cloudinary.com/dxxtt2clx/image/upload/v1710515892/Screenshot_2024_03_15_at_16_14_29_0a04ad1643.png) 

Comme sujet MQTT, j'ai choisi "/homeassistant/sleep-light", mais le nommage est à votre convenance. Il doit juste être cohérent avec l'application web Go que nous programmerons plus tard et qui publiera un message MQTT. Une fois que Home Assistant est configuré, il écoute les messages MQTT entrants sur le topic "/homeassistant/sleep-light" et allume la lumière LED en conséquence. Maintenant, nous devons créer une API REST et une simple application web pour contrôler les lumières. 

## Go App 

Pour écrire l'API et la simple application web, j'ai choisi Go comme langage de programmation. Avec Go, il est facile de compiler pour les processeurs d'architecture ARM. 

Voici le code source de l'application Go : 

```Go 
package main

import (
	"fmt"
	"os"

	mqtt "github.com/eclipse/paho.mqtt.golang"
	"github.com/gofiber/fiber/v2"
)

func main() {
	broker := "tcp://your-server:1883"
	clientID := "go-mqtt-publisher"
	topic := "/homeassistant/sleep-light"
	message := "TOGGLE"

	opts := mqtt.NewClientOptions().AddBroker(broker).SetClientID(clientID)
	client := mqtt.NewClient(opts)
	if token := client.Connect(); token.Wait() && token.Error() != nil {
		fmt.Println(token.Error())
		os.Exit(1)
	}

	app := fiber.New()

	app.Get("/", func(c *fiber.Ctx) error {
		return c.SendFile("./public/index.html")
	})

	app.Get("/v1/lights", func(c *fiber.Ctx) error {
		token := client.Publish(topic, 0, false, message)
		token.Wait()

		if token.Error() != nil {
			return c.SendString(token.Error().Error())
		} else {
			return c.SendString("Toggled lights!")
		}
	})

	app.Listen(":3005")
}
``` 

Comme framework API REST j'utilise [Fiber](https://gofiber.io). La bibliothèque MQTT est Paho MQTT. Avant de lancer cette application Go, vous devez adapter le point de terminaison "broker" à votre serveur. Cette application écoute le point de terminaison GET "/v1/lights" et envoie un message MQTT au broker MQTT Mosquitto. 

Comme Home Assistant est à l'écoute de ce type de messages MQTT, une fois que vous invoquez le point de terminaison GET, les lumières LED s'allument. La pièce manquante est l'application web. Il s'agit d'un simple bouton qui invoque le point de terminaison GET "/v1/lights". 

Voici l'application web : 

index.html
```html
<!DOCTYPE html>
<html>
  <head>
    <title>Lights Toggler</title>
  </head>
  <body>
    <button id="myButton" style="font-size: 60px; padding: 10px 20px;">Toggle Lights</button>

    <script>
      document
        .getElementById("myButton")
        .addEventListener("click", function () {
          var xhr = new XMLHttpRequest();
          xhr.open("GET", "http://your-server:3005/v1/lights", true);
          xhr.send();
        });
    </script>
  </body>
</html>
```

Cette page web est livrée au navigateur via le point d'arrivée "/" tel que configuré dans l'application Go Fiber. Dans la page web, j'ai utilisé XMLHttpRequest() au lieu de la méthode standard fetch() parce que le site web doit fonctionner sur des navigateurs anciens pour moi. Si ce n'est pas le cas pour vous, vous pouvez remplacer ces lignes par fetch(). 

Vous pouvez maintenant contrôler les lumières ZigBee avec une application web et une API. Ceci met fin à notre histoire sur la façon de contrôler les lumières LED ZigBee avec une application web. 

## Conclusion 

Comme vous avez pu le constater dans cet article, l'intégration d'une lampe LED ZigBee dans le monde des standards web tels que HTTP et les applications web nécessite un certain nombre d'éléments. Mais heureusement, de nombreux éléments sont open source et disponibles gratuitement. Je suis sûr qu'il existe d'autres moyens d'atteindre le même objectif, et j'aimerais entendre votre histoire. Vous pouvez me contacter en cliquant sur le bouton de contact ci-dessous. 

## Références 

- ZigBee : [https://csa-iot.org](https://csa-iot.org) 
- RaspBee II : [https://phoscon.de/en/raspbee2](https://phoscon.de/en/raspbee2) 
- Home Assistant : [https://www.home-assistant.io](https://www.home-assistant.io) 
- Mosquitto : [https://mosquitto.org](https://mosquitto.org) 
- Go : [https://go.dev](https://go.dev) 
- Fiber : [https://gofiber.io](https://gofiber.io) 

Photo de couverture par <a href="https://unsplash.com/@9thvenom?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Dejan Nasteski</a> sur <a href="https://unsplash.com/photos/blue-and-white-light-fixture-I3rvOvxvybE?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Unsplash</a>

large_dejan-nasteski-I3rvOvxvybE-unsplash.jpg

medium_dejan-nasteski-I3rvOvxvybE-unsplash.jpg

small_dejan-nasteski-I3rvOvxvybE-unsplash.jpg

thumbnail_dejan-nasteski-I3rvOvxvybE-unsplash.jpg

Normalement, lorsque vous achetez un éclairage domestique que vous souhaitez contrôler électroniquement, vous devez installer un logiciel personnalisé. Mais avec le protocole ZigBee et la passerelle RaspBee II, vous pouvez utiliser des appareils compatibles et des logiciels libres. Dans cet article, je vais vous montrer comment ajouter un service API en Go personnalisé à la pile. 


Contrôlez les lampes LED ZigBee avec l'application Web Go

Lorsque l'on programme des applications embarquées sur des Raspberry Pi, il est souvent pratique de travailler sur une machine plus puissante.
Dans cet article, je veux montrer comment éditer à distance depuis un Mac du code de programmation qui s'exécute directement sur les Raspberry Pi.
Comme IDE confortable, j'utilise Visual Studio Code.

## Partager un dossier sur des Raspberry Pi

Comme je veux accéder aux fichiers depuis mon Mac, je peux utiliser un outil appelé `Netatalk`.
Netatalk est une implémentation libre et gratuite du logiciel d'Apple, le [Apple Filing Protocol (AFP)](https://en.wikipedia.org/wiki/Apple_Filing_Protocol).
AFP est maintenant dépréciée, mais il fonctionne toujours sur les Mac avec MacOS Monterey.

Afin d'installer netatalk, vous devez entrer ce qui suit dans le shell de votre Raspberry Pi :

```bash
sudo apt update
sudo apt install netatalk
```

Vous devez configurer les dossiers que vous souhaitez partager avec votre Mac dans un fichier appelé `/etc/netatalk/afp.conf`.

C'est la configuration minimale que vous devez ajouter :

```
[Homes]
basedir regex = Full path to your base directory of the user you want to share folders in

[Name of your share]
path = Full path of your folder you want to share
```

Adaptez les valeurs du chemin à votre dossier et spécifiez le nom du partage dans le champ
fichier `afp.conf`.

Après avoir terminé l'édition, redémarrez netatalk avec :

```bash
sudo systemctl restart netatalk
```

## Ajouter un dossier à Mac

Sur votre Mac, vous pouvez maintenant ouvrir l'application Finder et rechercher dans votre réseau le Rasperry Pi portant le nom de partage que vous avez spécifié dans le fichier `afp.conf`.

Double-cliquez pour vous connecter et entrez les informations d'identification de votre utilisateur Raspberry Pi.
Vous devriez maintenant voir les fichiers de votre dossier partagé Raspberry Pi dans votre Finder.

## Ajouter un dossier à Visual Studio Code

Dans Visual Studio Code, vous pouvez maintenant accéder à l'onglet et sélectionnez dans le menu
l'élément de menu "Add Folder to Workspace". Vous pouvez maintenant sélectionner votre dossier partagé et l'ajouter à l'espace de travail de vos projets.

Enfin, vous pouvez modifier les fichiers directement dans Visual Studio Code sur votre Mac. Une fois enregistrés, ils sont transférés sur le Raspberry Pi et y sont stockés.

## Conclusion

La programmation embarquée sur des Raspberry Pi peut souvent sembler lente avec les IDE modernes. Mais j'espère avoir pu montrer qu'il n'est pas si difficile de mettre en place un partage de fichiers pour une édition à distance confortable avec Visual Studio Code sur votre Mac.

## Références

- Raspberry Pi : [https://www.raspberrypi.com](https://www.raspberrypi.com)

- Netatalk : [https://github.com/Netatalk/Netatalk](https://github.com/Netatalk/Netatalk)

- Apple Filing Protocol (AFP) : [https://developer.apple.com/library/archive/documentation/Networking/Conceptual/AFP/Introduction/Introduction.html](https://developer.apple.com/library/archive/documentation/Networking/Conceptual/AFP/Introduction/Introduction.html)

- Visual Studio Code : [https://code.visualstudio.com](https://code.visualstudio.com)

- Image de couverture : https://pixabay.com/photos/iceland-sky-clouds-beautiful-1995039


large_cover.png

medium_cover.png

small_cover.png

thumbnail_cover.png

Lorsque l'on programme des applications embarquées sur des Raspberry Pi, il est souvent pratique de travailler sur une machine plus puissante. Dans cet article, je veux montrer comment éditer à distance depuis un Mac du code de programmation qui s'exécute directement sur le Raspberry Pi. Comme IDE confortable, j'utilise Visual Studio Code.

Modification à distance des fichiers Raspberry Pi depuis un Mac avec Visual Studio Code

À la lumière de la pénurie actuelle de Raspberry Pis, je veux partager des informations sur
un ordinateur monocarte alternatif, l'Odroid N2+. L'Odroid N2+ peut être utilisé pour héberger un certain nombre 
d'applications en utilisant Docker. Portainer facilite l'administration des conteneurs Docker sur l'Odroid N2+.

## Odroid N2+

Le site [Odroid N2+](https://wiki.odroid.com/odroid-n2) est un ordinateur monocarte (SBC) de la société sud-coréenne
[Hardkernel](https://www.hardkernel.com) (하드커널). A la lumière des pénuries actuelles des SBCs Rasperry Pi, j'ai
voulu voir si l'Odroid N2+ est une alternative viable pour héberger des applications Docker.

L'Odroid N2+ combine un quad-core [ARM Cortex-A73 CPU](https://developer.arm.com/Processors/Cortex-A73) et un double cœur [Cortex-A53](https://developer.arm.com/Processors/Cortex-A53) avec un GPU Mali-G52. Il dispose de 4 Go de RAM DDR4 et de quatre ports USB 3.0. Pour la mise en réseau, l'Odroid N2+ a un port LAN GbE, mais malheureusement pas de wifi intégré.
Dans ma configuration, j'utilise donc un adaptateur wifi USB 2.0 séparé de la marque [Delock](https://www.delock.de/produkt/12462/merkmale.html?f=s).
L'adaptateur wifi de Delock possède un chipset Realtek RTL8811 qui est largement supporté par Linux.
Comme les Raspberry Pi, l'Odroid N2+ a aussi des ports GPIO.

Le dissipateur thermique est passif et ne fait aucun bruit, ce qui est idéal pour les environnements domestiques. Pour le stockage, vous avez le choix entre une carte SD et une carte eMMC. La carte eMMC est plus rapide, mais aussi plus chère.

## Installer Linux sur l'Odroid N2+

Hardkernel [offers several Linux images](https://wiki.odroid.com/odroid-n2/os_images/ubuntu/20200224) pour l'Odroid N2+. Pour mon usage, j'utilise l'image Ubuntu Mate Desktop.

Une fois que vous avez téléchargé le fichier image, vous pouvez le copier sur votre carte SD à l'aide d'une application comme l'application [Raspberry Pi Imager](https://www.raspberrypi.com/software/). D'autres logiciels de transfert pour différents systèmes d'exploitation existent également.

## Installation de Docker

[Docker](https://www.docker.com/) est une solution populaire de virtualisation au niveau du système d'exploitation qui fournit des logiciels dans des paquets appelés conteneurs.
Ainsi, Docker facilite le déploiement de logiciels qui contiennent souvent plusieurs parties. Il peut par ailleurs être utilisé pour déployer des logiciels sur des SBC comme l'Odroid.

Docker est livré avec un CLI pour gérer les conteneurs, mais il n'est pas facile à utiliser pour les utilisateurs non techniques. Une fois que vous avez inséré la carte SD dans votre Odroid N2+, vous pouvez installer Docker en suivant les étapes manuelles sur Docker.com :

https://docs.docker.com/engine/install/ubuntu/

## Installation de Portainer

Une solution comme [Portainer](https://www.portainer.io) peut être installé qui rend l'administration des conteneurs Docker simple sur l'Odroid N2+. Il est lui-même livré sous forme de conteneur et dispose d'une interface web commode à utiliser.

Portainer existe en deux versions, une édition CE open source et une édition commerciale. Une fois que vous avez une installation fonctionnelle de Docker sur votre Odroid N2+, vous pouvez suivre ces étapes d'installation pour installer Portainer :

[https://docs.portainer.io/start/install/server/docker/linux](https://docs.portainer.io/start/install/server/docker/linux)

Après l'installation réussie, vous pouvez vous connecter à l'application web de Portainer. Portainer dispose de nombreuses fonctionnalités pour gérer facilement les conteneurs Docker, les images, les réseaux et les volumes.

Une chose à laquelle il faut faire attention lors de l'installation des images Docker sur l'Odroid N2+ est que les images Docker doivent
être dans un format qui prend en charge l'architecture du CPU ARM (arm64). Les images Docker qui, par exemple, ne supportent que l'architecture Intel ne fonctionneront pas sur votre Odroid N2+.

## Conclusion

L'installation de votre périphérique local exécutant Docker sur votre Odroid N2+ est un excellent moyen de profiter des avantages d'un ordinateur monocarte. Portainer rend l'administration des conteneurs Docker facile sur l'Odroid N2+.

## Références

- Hardkernel : [https://www.hardkernel.com](https://www.hardkernel.com)

- Odroid N2+ Wiki : [https://wiki.odroid.com/odroid-n2/odroid-n2](https://wiki.odroid.com/odroid-n2/odroid-n2)

- Docker : [https://www.docker.com](https://www.docker.com)

- Portainer : [https://www.portainer.io](https://www.portainer.io)


large_cover.jpg

medium_cover.jpg

small_cover.jpg

thumbnail_cover.jpg

Compte tenu de la pénurie actuelle de Raspberry Pis, je souhaite partager des informations sur un autre ordinateur monocarte, le Odroid N2+. L'Odroid N2+ peut être utilisé pour héberger un certain nombre d'applications en utilisant Docker. Portainer facilite l'administration des conteneurs Docker sur l'Odroid N2+.

Comment installer Docker et Portainer sur Odroid N2+ ?

[Magic Mirror²](https://magicmirror.builders/) est une application open source permettant de créer des tableaux de bord pour un usage domestique ou professionnel. Elle dispose d'un vaste écosystème de plugins tiers permettant d'afficher des informations provenant de différentes sources de données. Dans cet article, je veux montrer comment configurer un tableau de bord avec Magic Mirror² sur des Raspberry Pi. 

## Tableaux de bord

Les tableaux de bord sont un type d'interface utilisateur graphique qui fournit une vue d'ensemble des informations utiles. Dans le cadre d'une utilisation professionnelle, ce type d'interface utilisateur inclut généralement des mesures telles que les indicateurs de performance clés (KPI). Le fait d'avoir cette vue d'ensemble des indicateurs importants permet à la direction d'agir plus facilement et plus rapidement en cas d'évolution de ces indicateurs. 

Mais les tableaux de bord peuvent également être utiles à des fins privées pour afficher des informations pertinentes à la maison. Pour moi, les informations utiles sont par exemple le temps qu'il fait dans ma ville, les actualités ou simplement un message important de mon ami sur Twitter. Avec le logiciel gratuit Magic Mirror², vous pouvez construire un tel système. 

## Magic Mirror² 

Le logiciel open source est appelé "Magic Mirror" parce qu'il a été conçu à l'origine pour un système de miroir intelligent qui affiche des informations utiles à la maison. Mais il peut aussi être utilisé sans miroir comme je vais le montrer dans cet article. 

Créé à l'origine par Michael Teeuw avec les premiers commits sur GitHub en 2014, ce projet compte maintenant plus de 200 contributeurs sur GitHub et 16,6k étoiles (mai 2022). Le logiciel est construit en utilisant JavaScript et [Electron](https://www.electronjs.org/). 

Electron est essentiellement un navigateur adapté à la création d'applications de bureau utilisant la technologie web. Magic Mirror² dispose d'un mécanisme simple permettant aux programmeurs d'étendre et d'adapter l'application avec des fonctionnalités personnalisées. Ces extensions tierces sont appelées "modules" et il en existe une grande variété prête à être installée. 

## Raspberry Pi

[Raspberry Pi](https://www.raspberrypi.com) est un ordinateur monocarte (SBC) populaire. Le projet Magic Mirror² a été spécifiquement développé pour fonctionner avec le système Raspberry Pi. En raison de la pénurie actuelle de Raspberry Pi, d'autres SBC fonctionnant sous Linux pourraient également fonctionner avec Magic Mirror². Pour les besoins de ce projet, j'utilise un Raspberry Pi 3B+.  

## Moniteur Samsung 

Pour l'affichage du tableau de bord, j'ai acheté un moniteur Samsung. Il s'agit du modèle 24" [S24A400VEU](https://news.samsung.com/global/samsungs-new-webcam-monitor-is-now-available) et je l'ai choisi parce que vous pouvez faire pivoter le moniteur en mode portrait et qu'il comprend par ailleurs un système audio et une webcam, ce qui pourrait s'avérer pratique à l'avenir mais n'est pas nécessaire pour le moment. 

## Installation de Magic Mirror² 

Tout d'abord, vous devez créer le Raspberry OS sur une carte SD. Raspberry OS est le système d'exploitation recommandé pour un Raspberry Pi. D'autres versions de Linux comme Ubuntu peuvent ainsi fonctionner. 

Vous pouvez utiliser l'application [Raspberry Pi Imager](https://www.raspberrypi.com/software/) pour écrire facilement Raspberry OS sur votre carte SD. Ensuite, vous insérez la carte SD dans votre Raspberry Pi et suivez les instructions à l'écran pour connecter votre Raspberry Pi au réseau et configurer votre clavier, entre autres. Une fois que vous avez une connexion Internet, vous pouvez installer le logiciel Magic Mirror². Vous pouvez suivre les instructions pour [l'installation manuelle](https://docs.magicmirror.builders/getting-started/installation.html#manual-installation) sur le site Web de Magic Mirror². 

Pour mes besoins, je veux utiliser le système d'exploitation en mode portrait pivoté. J'ai donc réglé la rotation de l'écran dans le Raspberry OS sous le menu principal "Preferences", "Screen Configuration" et ensuite "Configure", "Screens", "HDMI-1", "Orientation" sur "left". 

N'oubliez pas d'appliquer les réglages. Ils sont ensuite conservés et fonctionnent également après un redémarrage. 
 
## Installation de modules 

Magic Mirror² est livré avec un certain nombre de modules préinstallés qui affichent l'heure, les vacances et les nouvelles. Dans la plupart des cas, vous voudrez personnaliser Magic Mirror² et installer d'autres modules intéressants. 

Il existe une [longue liste de modules tiers prêts à l'emploi](https://github.com/MichMich/MagicMirror/wiki/3rd-Party-Modules) qui peuvent être installés sur votre système. Une fois que vous avez trouvé un module approprié, vous devez aller dans le répertoire d'installation racine de MagicMirror sur votre système (par exemple /home/pi/MagicMirror). Le répertoire `modules` se trouve là où vous devez aller. 

```bash 
cd modules
``` 
 
Sur le site web GitHub du module que vous voulez installer, il y a un bouton vert "Code" et quand vous cliquez dessus, vous pouvez copier le lien HTTPS pour le clonage. En collant le lien HTTPS dans votre terminal, vous pouvez cloner le code source du module dans votre dossier `modules`, comme ceci 
 
```bash 
 git clone https://github.com/mrVragec/MMM-mvgmunich.git
``` 

Dans mon cas ci-dessus, j'ai installé le module `MMM-mvgmunich` pour le système de transport public à Munich. Vous devez adapter l'URL à votre module sélectionné. Après le téléchargement réussi du code source, vous devez installer tous les paquets JavaScript possibles via : 

```bash 
npm i 
``` 

Ensuite, vous devez éditer le fichier `config/config.js` et ajouter les propriétés de votre module. Les informations que vous devez ajouter sont décrites dans la documentation de chaque module sur GitHub. Pour le module `MMM-mvgmunich`, les propriétés ressemblent à ceci : 

```js
  {
        module: "MMM-mvgmunich",
        position: "top_right",
		config: {
          haltestelle: "Karlsplatz",
          maxEntries: 15,             // 10 items on screen
          updateInterval: 60000,      // 60 s
          showIcons: true,            // Show transport type icon
          transportTypesToShow: {
              "ubahn": true,            // show ubahn route
              "sbahn": true,            // show sbahn route
              "bus": true,              // show bus route
              "regional_bus": false,     // show regional bus route
              "tram": true              // show tram route
          },
          ignoreStations: [],         // destination not to be shown
          timeToWalk: 0,             // 10 min walking time to station. Default is 0
          showWalkingTime: true,     // if the walking time should be included and the starting time is displayed
          showTrainDepartureTime: true,     // show tran departure time
          trainDepartureTimeFormat: "absolute",   // format of the train departure time
          walkingTimeFormat: "relative"    // format of the walking time
        }
  }
```

Là, vous pouvez adapter le module à vos besoins en changeant les valeurs, par exemple je pourrais
désactiver l'affichage des icônes en mettant `showIcons` à `false`.

Chaque module a des possibilités de personnalisation différentes, vous devez donc consulter la documentation.

Une fois que vous avez sauvegardé vos changements dans le fichier `config/config.js`, vous pouvez aller dans le dossier racine de votre installation du Magic Mirror² et exécuter:

```bash
npm run start
```

Une fois que vous voyez que tout va bien, vous pouvez configurer Magic Mirror² pour qu'il s'exécute automatiquement à chaque démarrage de votre Raspberry Pi.
 
## Démarrage automatique
 
Lorsque vous avez besoin de démarrer automatiquement Magic Mirror² à chaque démarrage de votre Raspberry Pi, vous pouvez suivre les [instructions sur le site web de Magic Mirror²](https://docs.magicmirror.builders/configuration/autostart.html).

L'important est de suivre la configuration à l'aide de [PM2](https://pm2.keymetrics.io/) que vous devez installer séparément. PM2 est un gestionnaire de processus de production pour Node qui peut démarrer automatiquement Magic Mirror². 

## Conclusion 

Les tableaux de bord peuvent être utiles non seulement pour les entreprises, mais aussi pour les particuliers. Ils facilitent l'affichage d'informations utiles qui permettent également aux particuliers de donner un sens au monde d'une manière simple.
Magic Mirror², combiné à un ordinateur monocarte comme le Raspberry Pi et un écran d'ordinateur, rend cette technologie disponible pour une adoption plus large. 

## Références 

- Magic Mirror² : [https://magicmirror.builders](https://magicmirror.builders)

- Code source GitHub Magic Mirror² : [https://github.com/MichMich/MagicMirror](https://github.com/MichMich/MagicMirror)

- Modules tiers : [https://github.com/MichMich/MagicMirror/wiki/3rd-Party-Modules](https://github.com/MichMich/MagicMirror/wiki/3rd-Party-Modules)

- Raspberry Pi : [https://www.raspberrypi.com](https://www.raspberrypi.com)

- PM2 : [https://pm2.keymetrics.io](https://www.raspberrypi.com)

Magic Mirror² est une application open source adaptée à la création de tableaux de bord pour un usage privé ou professionnel. Elle dispose d'un vaste écosystème de plugins tiers permettant d'afficher des informations provenant de différentes sources de données.  Dans cet article, je veux montrer comment configurer un tableau de bord avec Magic Mirror² sur des Raspberry Pi.

Tableau de bord avec Magic Mirror² sur Raspberry Pi

Vous avez souvent besoin d'une interface web pour vos projets Raspberry Pi.
Flask est un framework Python qui facilite la programmation d'API web.
Mais vous devez ensuite ajouter toutes les étapes de déploiement pour exécuter automatiquement l'application Flask. Dans cet article je veux montrer comment vous pouvez le faire avec Gunicorn, Nginx et une intégration une intégration systemd.

## Application Flask

[Flask](https://flask.palletsprojects.com/en/2.0.x/) est un framework écrit en Python qui facilite la programmation rapide d'API REST.
Il fonctionne sur des Raspberry Pi avec le système d'exploitation Raspberry Pi.
Par exemple, vous pouvez programmer une API qui allume une lampe LED en envoyant une requête POST.
POST est une méthode de requête du protocole HTTP.
Ainsi, vous pouvez connecter votre Raspberry Pi à votre réseau, par exemple pour la domotique.

Mais il y a quelques étapes supplémentaires nécessaires pour exécuter votre application Flask en douceur. En outre, vous devez exécuter automatiquement l'application Flask au démarrage de votre Raspberry Pi.

## Gunicorn

Les développeurs de Flask recommandent l'utilisation de [Gunicorn](https://gunicorn.org) comme serveur HTTP pour l'application Flask en mode de production.

Tout d'abord, vous devez installer Gunicorn. Je l'ajoute normalement au fichier requirements.txt, comme ceci :

requirements.txt
```txt
flask==1.1.4
gunicorn==20.1.0
```

Avec ```pip3 install -r requirements.txt`` vous pouvez
installer les dépendances.

Ensuite, vous devez créer un fichier de configuration pour
Gunicorn, par exemple:

gunicorn_config.py
```py
bind="0.0.0.0:8000"
workers=2
```

Ensuite, vous pouvez démarrer votre application Flask avec Gunicorn,
comme dans mon cas, l'application Flask est dans app.py :

``gunicorn app:app``

Cette commande lance notre application sur le port 8000, mais nous souhaitons
la rendre disponible sur le port 80 qui est le port standard pour les applications web.

Nous avons donc besoin d'un proxy web, pour lequel nous utilisons Nginx.

### Nginx

[Nginx](https://www.nginx.com/) est un serveur web et un proxy web open source populaire
 qui a été créé par Igor Sysoev. Nous l'utilisons ici
comme proxy pour notre serveur Gunicorn.

Vous pouvez installer Nginx sur votre Raspberry Pi avec
``sudo apt-get install nginx``

Ensuite, vous devez l'activer pour qu'il s'exécute automatiquement
à chaque démarrage de votre Raspberry Pi :

``sudo systemctl start nginx``

``sudo systemctl enable nginx``

La configuration recommandée de Nginx
en tant que proxy est la suivante :

/etc/nginx/sites-enabled/default
```
server {
    listen 80 ;
    nom_serveur exemple.org ;
    access_log /var/log/nginx/example.log ;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host ;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for ;
    }
  }
```

### Systemd

La dernière étape de notre voyage consiste à exécuter automatiquement le serveur
Gunicorn à chaque nouveau démarrage du Raspberry Pi.

Nous y parvenons en intégrant Gunicorn dans le service systemd de Linux.

Systemd est utilisé dans la plupart des systèmes Linux modernes pour gérer les
services. Chaque fois que vous démarrez votre système d'exploitation Raspberry Pi
la gestion de l'exécution correcte des services qui doivent être exécutés est faite par systemd.

Vous devez créer un nouveau service pour systemd dans le dossier

``/usr/lib/systemd/system``

Le fichier texte du service doit avoir un certain format et les informations requises :

votre-nom.service
```
[Unité]
Description=Votre service
After=multi-user.target

[Service]
WorkingDirectory=/home/pi/your/path
ExecStart=/home/pi/projets/votre-app/venv/bin/gunicorn app:app &

[Install]
WantedBy=multi-user.target
```

Vous devez nommer le fichier en fonction de votre service et ajouter
le chemin correct où se trouve votre projet.
J'utilise virtualenv, c'est pourquoi ```gunicorn`` est lancé depuis
le dossier ``/venv/bin``.

Gunicorn est démarré avec ``&`` afin qu'il fonctionne en arrière-plan.

Vous pouvez maintenant utiliser ``systemctl`` pour démarrer et arrêter votre service :

``sudo systemctl start votre-nom.service``

``sudo systemctl stop votre-nom.service``

Afin de démarrer automatiquement votre serveur à chaque fois que le Raspberry Pi
vous devez utiliser la commande suivante :

``sudo systemctl enable votre-nom.service``


### Conclusion

Ceci termine notre voyage dans le déploiement d'une application Flask.
Ces étapes peuvent être un modèle utile chaque fois que vous avez besoin de faire tourner votre application Flask automatiquement
sur votre Raspberry Pi.

## Références

- Flask : [https://flask.palletsprojects.com/en/2.0.x/](https://flask.palletsprojects.com/en/2.0.x/)

- Serveur HTTP WSGI Gunicorn : [https://gunicorn.org](https://gunicorn.org)

- Nginx : [https://www.nginx.com](https://www.nginx.com)

- Systemd : [https://www.freedesktop.org/wiki/Software/systemd](https://www.freedesktop.org/wiki/Software/systemd)



Vous avez souvent besoin d'une interface web pour vos projets Raspberry Pi.
Flask est un framework Python qui facilite la programmation d'API web. Ensuite, vous devez ajouter toutes les étapes de déploiement pour exécuter automatiquement l'application Flask. Voici, je veux montrer comment vous pouvez faire cela avec Gunicorn, Nginx et systemd.

Comment déployer des applications Flask sur Raspberry Pi

Systemd est excellent pour démarrer et arrêter des services sous Linux. Cet article explique comment créer un script systemd en utilisant l'exemple de l'application Python open source Timetagger. 

## Systemd 

Sur les systèmes Linux, [systemd](https://systemd.io) est un système init utilisé pour démarrer l'espace utilisateur et gérer les processus utilisateur. Au moment de son introduction, il était controversé, mais il est maintenant utilisé par la majorité des distributions Linux modernes. Ainsi, lorsque vous souhaitez exécuter automatiquement une application à chaque démarrage du système d'exploitation Linux, vous devez créer un fichier de configuration. Je vous montrerai plus tard comment le faire. 

## Virtualenv

Lors de l'installation d'applications Python qui ont des dépendances de bibliothèques, il est très utile d'utiliser le service de [virtualenv](https://virtualenv.pypa.io/en/latest/). Avec l'aide de virtualenv, vous pouvez isoler les applications Python afin que les dépendances de bibliothèque n'interfèrent pas entre elles. Ceci est nécessaire si vous avez plusieurs applications Python installées en même temps dans votre système. Depuis Python 3.3, un sous-ensemble de virtualenv est intégré au module `venv`. 

## Timetagger

[Timetagger](https://github.com/almarklein/timetagger) est une application open source Python de suivi du temps développée par Almar Klein. Je l'utilise comme exemple ici car je trouve Timetagger utile dans mon travail. Il dispose d'une interface web confortable pour suivre votre temps et possède également une API. Grâce à la CLI de Timetagger, vous pouvez lancer et arrêter le suivi du temps en ligne de commande. C'est particulièrement pratique pour les développeurs de logiciels. 

Lorsque vous hébergez vous-même l'application, vous souhaitez probablement l'exécuter automatiquement à chaque démarrage de votre système. C'est là que le script systemd entre en jeu. 

## Script systemd 

Vous devez installer Timetagger avec virtualenv afin d'utiliser le script systemd. Après avoir cloné [Timetagger](https://github.com/almarklein/timetagger) depuis GitHub, vous pouvez exécuter les commandes suivantes pour l'installer à l'aide de virtualenv : 

```bash 
cd timetagger 

python3 -m venv venv 

. venv/bin/activate 

pip3 install -r requirements.txt 
```

Maintenant que toutes les dépendances sont installées en utilisant virtualenv, vous devez créer le script de service systemd (timetagger.service) dans le répertoire système en utilisant un éditeur de texte : 

/etc/systemd/system/timetagger.service

```bash
[Unit]
Description=Service Timetagger 

[Service]
User=Votre nom d´utilisateur Linux 
WorkingDirectory=Votre dossier timetagger 
ExecStart=Votre dossier timetagger/venv/bin/python3 -m timetagger  

[Install]
WantedBy=multi-user.target 
``` 

Remplacez `Votre dossier timetagger` par le nom réel du répertoire Timetagger sur votre système.

La clé pour exécuter une application Python qui a été installée via virtualenv est d'exécuter Python via le dossier `venv/bin`. Notez que vous avez besoin de droits d'administrateur pour créer le fichier timetagger.service.

Vous pouvez maintenant démarrer timetagger avec: 

```bash
sudo systemctl start timetagger
```

Pour exécuter timetagger automatiquement à chaque démarrage du système, activez-le comme suit: 

```bash
sudo systemctl enable timetagger 
```

## Arrêter Timetagger 

Lorsque vous avez démarré Timetagger de la manière décrite ci-dessus, vous pouvez l'arrêter en lui envoyant un signal `SIGSTOP`: 

```bash 
kill -SIGSTOP pid 
```

Vous pouvez obtenir le pid (identifiant du processus) via la commande `ps ax`. Cherchez le nom du Timetagger. 

## Conclusion

Faire tourner des applications Python qui utilisent virtualenv automatiquement dans systemd n'est pas sorcier. J'espère qu'avec cet article je vous ai montré comment le faire. 

## Références 

- Systemd : [https://systemd.io](https://systemd.io) 

- Python : [https://www.python.org](https://www.python.org)

- Virtualenv : [https://virtualenv.pypa.io/en/latest](https://virtualenv.pypa.io/en/latest)

- Timetagger : [https://github.com/almarklein/timetagger](https://github.com/almarklein/timetagger)

Image de couverture par OpenAI Dall-E2 : "Yellow snake with a time tagger".


Systemd est idéal pour démarrer et arrêter des services sous Linux. Lorsque vous voulez démarrer une application Python qui utilise virtualenv, vous devez prendre des précautions particulières.
Cet article explique comment créer un script systemd à l'aide de l'exemple de l'application Python open source Timetagger.

Utiliser systemd pour démarrer une application Python avec virtualenv

<YouTube id="IP4Ikw3KtAU" />

L'IDE Arduino contient un langage simplifié pour développer pour la plateforme Arduino. Ce langage s'appelle
Wiring et est une version dialectale simplifiée de C et C++. Les opérations courantes d'entrée et de sortie sont simplifiées, ce qui rend l'environnement idéal pour le prototypage pour les concepteurs et les fabricants.

Mais parfois, vous souhaitez programmer en "vrai" C et utiliser directement la chaîne d'outils AVR. Par exemple, vous pouvez vouloir regarder derrière les scènes ou avoir besoin de programmer une bibliothèque. Il devient alors nécessaire d'utiliser la chaîne d'outils AVR.

Comment programmer une simple DEL clignotante en C pur, c'est ce que je veux montrer dans cet article.

## Installation

Afin de pouvoir compiler et exécuter le programme C en code machine AVR, vous devez installer un compilateur croisé, un linker et un uploader pour le microcontrôleur AVR.

Sous Ubuntu Linux, cela se fait en exécutant la commande suivante :

```bash
sudo apt-get install gcc-avr binutils-avr gdb-avr avr-libc avrdude make
```

Ceci installe tous les outils nécessaires au développement de l'AVR C sur votre machine.

## Configuration du matériel Arduino

Le programme C suppose que vous avez un Arduino Uno avec une DEL connectée au port 13.

Cette image Fritzing montre la configuration :
![LED clignotante](https://res.cloudinary.com/dxxtt2clx/image/upload/v1692378835/Blink_Led_7cdbbb379f.png)

## Led.c

```C
#include <avr/io.h>

#define F_CPU 16000000
#define BLINK_DELAY_MS 5000

#include <util/delay.h>

int main (void)
{
  // Broche numérique Arduino 13 (broche 5 de PORTB) pour la sortie
  DDRB |= 0B100000 ; // PORTB5

  while(1) {
    // Allumez la DEL
    PORTB |= 0B100000 ; // PORTB5
    _delay_ms(BLINK_DELAY_MS) ;

    // éteint la DEL
    PORTB &= ~ 0B100000 ; // PORTB5
    _delay_ms(BLINK_DELAY_MS) ;
  }
}
```

Dans cet exemple en C, la DEL s'allume pendant 5000 ms (5 secondes), puis s'éteint à nouveau.
Vous devez importer deux fichiers d'en-tête, l'un pour la définition des ports IO et l'autre pour la fonction de
la fonction de retard.

Il est important que sous C pur, vous devez calculer la broche exacte sur laquelle vous voulez écrire.
Dans notre cas, la broche 13 de la DEL est sur le port B5 (ou en binaire : 0B100000).
Vous pouvez trouver le port et les broches brutes dans les [schémas Arduino](https://www.arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf)
que vous pouvez consulter sur le site Web d'Arduino.

## Compilation et téléchargement

Avec le fichier Makefile ci-joint, il devient facile de compiler le fichier C.

Il suffit de l'exécuter :

```bash
make
```

Dans les coulisses, le Makefile appelle le compilateur C de l'AVR (avr-gcc) et convertit le
le fichier au format hexadécimal correct que l'uploader peut utiliser.
Avant de pouvoir télécharger, vous devez trouver à quel endroit de votre machine l'Arduino Uno
est connecté sur votre machine. Le chemin est alors écrit dans le Makefile comme variable ARDUINO_USB.

Une fois que c'est fait, téléchargez le fichier sur votre Arduino Uno avec :

```bash
make deploy
```

L'uploader que nous utilisons dans le Makefile est appelé Avrdude.

## Conclusion

La famille Arduino est un excellent terrain de jeu pour le prototypage matériel.
Mais vous pouvez plonger plus profondément et programmer l'Ardunio Uno sans l'IDE Arduino en utilisant le langage C d'AVR.
J'espère que j'ai pu lever les premiers obstacles dans cette aventure.

## Références

- Source du projet DEL en C pur : [https://github.com/tderflinger/arduino-blink-purec](https://github.com/tderflinger/arduino-blink-purec)
- Schémas de l'Arduino Uno : [https://www.arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf](https://www.arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf)
- Chaîne d'outils AVR : [http://nongnu.org/avr-libc](http://nongnu.org/avr-libc)
- Merci à Sagar : [https://github.com/sagarsp/arduino-blink-c](https://github.com/sagarsp/arduino-blink-c)

Pour une meilleure qualité, regardez-le via ce lien : [https://www.youtube.com/watch?v=IP4Ikw3KtAU](https://www.youtube.com/watch?v=IP4Ikw3KtAU)



medium_BlinkLed.png

small_BlinkLed.png

thumbnail_BlinkLed.png

L'IDE Arduino contient un langage simplifié pour développer pour la plateforme Arduino. Les opérations courantes d'entrée et de sortie sont simplifiées, ce qui rend l'environnement idéal pour le prototypage pour les concepteurs et les fabricants.
Mais parfois, vous souhaitez programmer en 'vrai' C et utiliser directement la chaîne d'outils AVR.

Arduino DEL clignotante en pure C

Veuillez entrer une adresse e-mail valide.

Je suis heureux de répondre à toutes les questions que vous pourriez avoir. Ou simplement dis bonjour !

Réflexions par Thomas Derflinger

IdO catégorie