Drive an SSD relay module using RIOT OS

The project shows how to control an 220V Lighbulb by driving an SSD relay module using an STM32 Nucleo-64 F401RE development board and GPIO device peripheral of the RIOT operating system.

Controlling a low-power external device, like a LED, can be achieved using the MCU's GPIO (General Purpose Input/Output) pins, like in the project with the blinking LED. Large power devices that require 110-240V cannot be controlled in this way. What is needed is an external circuit based on a relay switch that allows to controls the high voltage using the low voltage of the MCU. The external circuit also helps isolate the high voltage components from the low voltage ones.

Wiring the hardware components

The relay used here is the OMRON G3MB-202P that switches up to 2A loads. The DC+ pin of the relay module is connected to the 5V pin of the STM32 Nucleo board. The DC- pin of the relay module is connected to the GND pin of the STM32 Nucleo board. The CH1 pin of the relay module is connected to the D4 pin of the STM32 Nucleo board.

The switching contacts of the relay marked with as AC are used to interrupt the electrical supply of the Lightbulb socket.

Note that the SSD relay module used in this example drives AC devices. Connecting a DC component, for example a LED, will not work as it should.

Setting-up a RIOT application

To create a new application you need to create a directory containing two files: (1) the Makefile and (2) the main.c file.

At minimum the Makefile should define the following basic aspects of the application:

• The name of the application (APPLICATION)
• The location of the RIOT base directory (RIOTBASE)
• Additionally, it is required to include the Makefile.include from the RIOTBASE

# A simple name of the application  
APPLICATION = relay    

# This has to be the absolute path to the RIOT base directory:  
RIOTBASE ?= $(CURDIR)/../../RIOT    

include $(RIOTBASE)/Makefile.include

Within the Makefile we also define that the application will use the RIOT low-level GPIO peripheral:

USEMODULE += periph_gpio

We wish to switch on and off the Lightbulb periodically. For this reason we will use the RIOT xtimer module that provides a high-level API to multiplex the available timers.

USEMODULE += xtimer 

The above are enough to setup a new application. More details can be found on the RIOT documentation.

The next step is to create the main.c file where the main code of the application is defined.

First we include the headers of the GPIO peripheral and the XTIMER module. We also include stdio.h for printing debug messages.

#include <stdio.h>  

#include "periph/gpio.h" 
#include "xtimer.h"

The GPIO interface is intentionally designed to be as simple as possible, to allow for easy implementation and maximum portability. All modern micro controllers organize their GPIOs in some form of ports, often named 'PA', 'PB', 'PC'..., or 'P0', 'P1', 'P2'..., or similar. Each of these ports is then assigned a number of pins, often 8, 16, or 32. To access a pin, the _GPIO_PIN(port, pin) macro_ should be used.

For the case of the STM32 Nucleo board used here, the mapping of the ARDUINO® Uno V3 connectivity headers with the MCU's internal pins can be found in the user manual UM1724 of the STM32 Nucleo F401RE board.

The figure below indicates that the D4 pin is connected to the PB port of the F401RE MCU at pin number 5.

The GPIO interface provides capabilities to initialize a pin as output-, input- and interrupt pin. Within the main.c file we need to use the gpio_init method to signal that pin PB5 should be initialized for output (GPIO_OUT) as follows:

gpio_t pin_out = GPIO_PIN(PORT_B, 5);
if (gpio_init(pin_out, GPIO_OUT)) {
    printf("Error to initialize GPIO_PIN(%d %d)\n", PORT_B, 5);
    return -1;
}

Now we can switch on and off the Lightbulb periodically as follows:

while(1)
{
  printf("Set pin to HIGH and signal SSD to switch on lightbulb\n");
  gpio_set(pin_out);

  xtimer_sleep(5);

  printf("Set pin to LOW and signal SSD to switch off lightbulb\n");
  gpio_clear(pin_out);

  xtimer_sleep(5);
}

Compiling the code and flushing the device

To compile the application, program the STM32 board and connect through the USB to receive debug information, we execute the following command:

make BOARD=nucleo-f401re flash term

Here is what we should expected as output:

main(): This is RIOT! (Version: 2021.04-devel-200-g67e5a)
RIOT relay application
Control an external LED using RIOT GPIO module.
Set pin to HIGH and signal SSD to switch on lightbulb
Set pin to LOW and signal SSD to switch off lightbulb 

More details on the code and insights on how the different modules of RIOT are used in this application can be found on the GITHUB repository.