Normally, when buying a home light that you want to control electronically, you need to install custom software. But with the ZigBee protocol and the RaspBee II gateway, you can use compatible devices and open source software. In this article I will show you how to add a custom Go API service to the stack.

In the following diagram, you can see the software stack that I use for the project:

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

## ZigBee

ZigBee is an IEEE 802.15.4-based specification for a suite of high-level communication protocols used to create personal area networks with small, low-power digital radios. It is often used in home automation, but also in other contexts like industrial production or medical devices.
Its key feature is that it does not use much power. Therefore, it can often run on battery for a long time. The flip-side of this coin is that its data rate is also low. But for turning on and off lights this is enough.

When you buy a ZigBee enables device, like a LED light strip, you need a gateway to control the device.

## RaspBee II Gateway

One such ZigBee gateway is the [Raspbee II gateway](https://phoscon.de/en/raspbee2) that I use for this article. RaspBee II is developed by Dresden Elektronik in Germany and is an extension card that fits on a standard Raspberry Pi. RaspBee II comes with a software application called "deCONZ" that interfaces with the hardware. 

The great thing about deCONZ is that you can integrate it easily with Home Assistant, thereby allowing you to control the ZigBee gateway directly within Home Assistant.

## Home Assistant

[Home Assistant](https://www.home-assistant.io) is a widely used open source home automation application. It was originally developed by Paulus Schoutsen and initially released in 2013. It is written in Python and has a web interface but also releases mobile apps.

In Home Assistant you can add deCONZ as an integration. Thereby, your ZigBee devices that are recognized by deCONZ are also available in Home Assistant. Then, you can configure simple automation routines. For example, if you have a motion detector device, you could add an automation routine that whenever a movement is detected, the lights turn on.

But for our purpose, we want to integrate MQTT and control the lights via MQTT.

## Mosquitto

MQTT is a light-weight publish-subscribe protocol that is often used in home automation scenarios. Applications can communicate with each other with a publish-subscribe messaging mechanism.
In our case I use it to control the state of the LED lights. 

But first, we need to install a MQTT broker. One popular open source MQTT broker is Eclipse Mosquitto. It is easy to install and configure.
In my case I installed it together on the same machine where Home Assistant runs.

Then, you configure an automation in Home Assistant that reacts to messages received on a MQTT channel and turns the LED lights on or off.

You can see my configuration in the follwing screenshot:

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

As MQTT topic I chose "/homeassistant/sleep-light", but the naming is up to you. It just needs to be consistent with the Go web application we program later that publishes a MQTT message.

Once Home Assistant is configured, it listens for incoming MQTT messages on the topic "/homeassistant/sleep-light" and toggles the LED light accordingly.

Now we need to create a REST API and a simple web application to control the lights.

## Go App

For writing the REST API and the simple web application, I chose Go as the programming language. With Go it is easy to compile to ARM architecture processors. Also, deployment is straightforward on the Raspberry Pi.

This is the source code of the Go application:

```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")
}
```

As a REST API framework I use [Fiber](https://gofiber.io). The MQTT library is Paho MQTT. Before you run this Go app, you need to adapt the "broker" endpoint to your server.
This application listens on the GET "/v1/lights" endpoint and sends out a MQTT message to the Mosquitto MQTT broker. Since Home Assistant listens for these kind of MQTT messages, once you invoke the REST endpoint, the LED lights toggle.

One missing piece is the web application. It is a simple button that invokes the "/v1/lights" GET endpoint. Thus, the lights are toggled when the button is pressed.

Here is the web application:

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>
```

This web page gets delivered to the browser via the "/" endpoint as configured in the Go Fiber application.

In the web page I used XMLHttpRequest() instead of the now standard fetch() because the website has to work on legacy browsers for me. If this is not the case for you, then you can substitute these lines with fetch().

Now you can control the ZigBee lights with a web application and an API.

This brings to an end our story of how to control ZigBee LED lights with a web application. I hope you enjoyed the ride.

## Conclusion

As you could see from this article, integrating a LED ZigBee light into the word of web standard like HTTP and web applications requires quite some pieces. But luckily, many parts are open source and freely available. I am sure there are other ways to reach the same goal, and I would love the hear your story. You can contact me by pressing the contact button below.

## References

- 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)

Cover photo by <a href="https://unsplash.com/@9thvenom?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Dejan Nasteski</a> on <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

Normally, when buying a home light that you want to control electronically, you need to install custom software. But with the ZigBee protocol and the RaspBee II gateway, you can use compatible devices and open source software. In this article I will show you how to add a custom Go API service to the stack.

Control ZigBee LED Lights with Go Web App

In many circumstances it is convenient to work remotely using Visual Studio Code. There is a fine VS Code extension that allows you to work on a remote machine as if it was your local machine. This is great for things like embedded programming or developing in the cloud. Read here how to do this.

## Why Working Remotely

Often when working on embedded projects like IoT devices you have two possibilities. One is to use a development machine that is separated from the embedded device and work there. Depending on the programming language, you will possibly need to use a cross-compiler to generate the version suitable for the embedded device. The other possibility is to directly work on the embedded device and develop there. This has the advantage of finding errors earlier, but may not always be possible due to device constraints. 

But now with the "Remote SSH" extension for Visual Studio Code you can comfortably develop within Visual Studio Code on your development machine and execute directly on the embedded device. This makes development on remote machines more convenient. 
The source code and the execution environment are directly located on the remote machine. You can access the remote machine comfortably via your development machine.

The next step is how to install the extension.

## Installing the Remote - SSH Extension

The pre-requisite for using the Remote SSH Extension is that the remote (e.g. embedded) machine has a running SSH server and a minimum of 1GB of RAM. This includes most versions of the Raspberry Pi as well as many server instances of cloud providers.

In Visual Studio Code you can install the Remote SSH Extension via the extension tab like so:

![Screenshot Remote SSH Extension](https://res.cloudinary.com/dxxtt2clx/image/upload/v1702380058/Screenshot_2023_12_12_at_12_19_59_86c30b7e00.png)

## Connect to Remote Machine

Once you have installed the extension, you can connect to your remote device via the command palette and search for "Remote-SSH: Connect to Host...". Now enter the IP address and then the user name and password of you remote machine.

![Connect to remote machine](https://res.cloudinary.com/dxxtt2clx/image/upload/v1702380726/Screenshot_2023_12_12_at_12_25_44_c42e8e147d.png)

Upon a successful connect, you wil see a new Visual Studio Code window where you can directly edit source files and execute scripts in the terminal.
The great thing is that you can open source files that are located directly on your remote machine but edit them seamlessly on your development machine. In case you need other language specific VS Code extensions like for example for editing Python you can install them there.

Once you have developed your first project with the help of the extension, you will notice that it is faster and esier than installing everything from scratch on the remote machine. Often it is even not possible to work with Visual Studio Code directly on the remote or embedded device.

## Conclusion

I hope in this article you could learn something new about the useful Visual Studio Code extension "Remote SSH". I am sure you can find other use cases like working remotely on cloud machines. If you like the extension do not hesitate to write me, I would love to hear from you.

## References

- Remote SSH Extension: [https://code.visualstudio.com/docs/remote/ssh](https://code.visualstudio.com/docs/remote/ssh)

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

Cover photo: <a href="https://unsplash.com/@heroye2?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Chung Yee Tsang</a> on <a href="https://unsplash.com/photos/house-surrounded-by-trees-during-nighttime-wqxCKM0R6R8?utm_content=creditCopyText&utm_medium=referral&utm_source=unsplash">Unsplash</a>
  

large_chung-yee-tsang-wqxCKM0R6R8-unsplash.jpg

medium_chung-yee-tsang-wqxCKM0R6R8-unsplash.jpg

small_chung-yee-tsang-wqxCKM0R6R8-unsplash.jpg

thumbnail_chung-yee-tsang-wqxCKM0R6R8-unsplash.jpg

In many circumstances it is convenient to work remotely using Visual Studio Code. There is a fine VS Code extension that allows you to work on a remote machine as if it was your local machine. This is great for things like embedded programming or developing in the cloud. Read here how to do this.

Working Remotely Using Visual Studio Code

<YouTube id="IP4Ikw3KtAU" />

The Arduino IDE contains a simplified language for developing for the Arduino platform. This language is called
Wiring and is a simplified dialect version of C and C++. Common input and output operations are simplified, making the environment ideal for prototyping for designers and makers.

But sometimes you want to program in "real" C and use the AVR tool chain directly. For example, you might
want to look behind the scenes or need to program a library. Then it becomes necessary to use
the AVR tool chain.

How to program a simple blinking LED in pure C, I want to show in this article.

## Installation

In order to be able to compile and run the C program to AVR machine code, you need to install
a cross-compiler, a linker and an uploader for the AVR microcontroller.

Under Ubuntu Linux, this done by running the following command:

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

This installs all the required tool chain for AVR C development on your machine.

## Arduino Hardware Setup

The C program assumes you have an Arduino Uno with one LED connected to port 13.

This Fritzing image shows the setup:
![Blinking LED](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)
{
  // Arduino digital pin 13 (pin 5 of PORTB) for output
  DDRB |= 0B100000; // PORTB5

  while(1) {
    // turn LED on
    PORTB |= 0B100000; // PORTB5
    _delay_ms(BLINK_DELAY_MS);

    // turn LED off
    PORTB &= ~ 0B100000; // PORTB5
    _delay_ms(BLINK_DELAY_MS);
  }
}
```

In this C example, the LED is turned on for 5000 ms (5 sec) and is then turned off again.
You need to import two header files, one for the IO ports definition and the other for
the delay function.

It is important that under pure C you need to calculate the exact
pin where you want to write to. In our case, the LED pin 13 is on Port B5 (or in binary: 0B100000).
You can find out about the raw port and pins in the [Arduino schematics](https://www.arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf)
that can be accessed from the Arduino website.

## Compiling and Uploading

With the attached Makefile, it becomes easy to compile the C file.

Just run:

```bash
make
```

Behind the scenes, the Makefile calls the AVR C compiler (avr-gcc) and converts
the file to the correct hex format that the uploader can use.
Before you can upload, you need to find out where on your machine the Arduino Uno
is connected to. The path is then written in the Makefile as variable ARDUINO_USB.

Once that is done, upload the file to your Arduino Uno with:

```bash
make deploy
```

The uploader we use in the Makefile is called Avrdude.

## Conclusion

The Arduino family is a great hardware prototyping playing field.
But you can dive deeper and program the Arduino Uno without the
Arduino IDE directly by using AVR C. I hope I could take away the first hurdles in this adventure.

## References

- Led in pure C project source: https://github.com/tderflinger/arduino-blink-purec
- Arduino Uno schematics: https://www.arduino.cc/en/uploads/Main/arduino-uno-schematic.pdf
- AVR Toolchain: http://nongnu.org/avr-libc/
- Thanks to Sagar: https://github.com/sagarsp/arduino-blink-c

For best quality, watch it via this link here: https://www.youtube.com/watch?v=IP4Ikw3KtAU

Cover image by <a href="https://unsplash.com/de/@brianwangenheim?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Brian Wangenheim</a> on <a href="https://unsplash.com/de/fotos/OKWgnUqwBl0?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
  



large_brian-wangenheim-OKWgnUqwBl0-unsplash.jpg

medium_brian-wangenheim-OKWgnUqwBl0-unsplash.jpg

small_brian-wangenheim-OKWgnUqwBl0-unsplash.jpg

thumbnail_brian-wangenheim-OKWgnUqwBl0-unsplash.jpg

The Arduino IDE contains a simplified language for developing for the Arduino platform. Common input and output operations are simplified, making the environment ideal for prototyping for designers and makers. But sometimes you want to program in "real" C and use the AVR tool chain directly.

Arduino Blinking LED in Pure C

Happy to answer any questions you might have. Or simply say hello!

Thoughts by Thomas Derflinger

Iot Category

Control ZigBee LED Lights with Go Web App

Working Remotely Using Visual Studio Code

Arduino Blinking LED in Pure C