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

[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

<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

Iot catégorie

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

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

Tableau de bord avec Magic Mirror² sur Raspberry Pi

Arduino DEL clignotante en pure C