Book Image

Internet of Things Projects with ESP32

By : Agus Kurniawan
Book Image

Internet of Things Projects with ESP32

By: Agus Kurniawan

Overview of this book

ESP32 is a low-cost MCU with integrated Wi-Fi and BLE. Various modules and development boards-based on ESP32 are available for building IoT applications easily. Wi-Fi and BLE are a common network stack in the Internet of Things application. These network modules can leverage your business and projects needs for cost-effective benefits. This book will serve as a fundamental guide for developing an ESP32 program. We will start with GPIO programming involving some sensor devices. Then we will study ESP32 development by building a number of IoT projects, such as weather stations, sensor loggers, smart homes, Wi-Fi cams and Wi-Fi wardriving. Lastly, we will enable ESP32 boards to execute interactions with mobile applications and cloud servers such as AWS. By the end of this book, you will be up and running with various IoT project-based ESP32 chip.
Table of Contents (12 chapters)

Demo 1 – building your first ESP32 program

In this section, we will write a simple program for the ESP32 board. We need three LEDs including cable jumpers for this. We will turn on one LED from LED 1 to LED 3. For implementation, I use the ESP-WROVER-KIT board.

Let's begin.


We connect three LEDs on the ESP32 board GPIO. We then do the following wiring:

  • LED 1 is connected to IO12
  • LED 1 is connected to IO14
  • LED 1 is connected to IO26
  • All LED GND pins are connected to the ESP32 board GND

You can see a wiring scheme in the following diagram:

Wiring on LED demo

Next, we create a project.

Creating a project

In general, there is no project template for the ESP32 program with SDK. However, we can create a project with the project structure as shown in this screenshot:

A project structure

Each project has the following files:

  • Makefile on your project root
  • main folder
  • Program file (*.c)
  • file inside the main folder

In this demo, we create a project by creating a folder called blinking. Then, we create a Makefile file. We also create a main folder. Inside the main folder, we create the blinking.c and files.

We will write code for those files in the next section.

Writing the program

Now, we write scripts and codes on the Makefile,, and blinking.c files:

  1. In the Makefile file, we declare our project name. This should be the same name as the project folder. The following are Makefile scripts:
   PROJECT_NAME := blinking

include $(IDF_PATH)/make/

  1. is required for compiling purposes. You should create a component file with this exact name. The content of the file is empty:
# "main" pseudo-component makefile.
# (Uses default behavior of compiling all source files in
directory, adding 'include' to include path.)
  1. Now, we write code for our main program, blinking.c. Firstly, we declare our required library headers as follows:
    #include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "sdkconfig.h"
  1. We define our three LEDs on ESP32 GPIO. We use IO12, IO14, and IO26 pins from ESP32 GPIO:
    #define LED1 12
#define LED2 14
#define LED3 26
  1. A main entry of the program is app_main(). For this, we create a task and pass a function, called blinking_task:
    void app_main()
xTaskCreate(&blinking_task, "blinking_task",
  1. The blinking_task() function performs GPIO initialization by calling gpio_pad_select_gpio(). Then, we set the GPIO pin as output using the gpio_set_direction() function. In the main loop, we turn on the LEDs one by one. We call the turn_on_led() function to perform this task:
void blinking_task(void *pvParameter)
// set gpio and its direction
gpio_set_direction(LED1, GPIO_MODE_OUTPUT);
gpio_set_direction(LED2, GPIO_MODE_OUTPUT);
gpio_set_direction(LED3, GPIO_MODE_OUTPUT);

int current_led = 1;
while(1) {
vTaskDelay(1000 / portTICK_PERIOD_MS);

current_led = 1;
  1. To turn on/off LEDs, we call gpio_set_level() with 1 or 0 parameters. If we pass 1 on gpio_set_level(), it means we set a power voltage on that GPIO:
void turn_on_led(int led)
// turn off all leds
gpio_set_level(LED1, 0);
gpio_set_level(LED2, 0);
gpio_set_level(LED3, 0);

case 1:
gpio_set_level(LED1, 1);
case 2:
gpio_set_level(LED2, 1);
case 3:
gpio_set_level(LED3, 1);
  1. Now, save all programs.

Next, we configure the project before flashing on the ESP32 board.

Configuring the project

Now, we should configure our project using menuconfig. This tool is a part of the ESP32 toolchain that you have configured previously on your platform.

Open Terminal and navigate to your project directory. Then, you can type this command:

$ make menuconfig

You should get the dialog shown in the following screenshot:

Espressif project config

We configure our ESP32 serial port and then select the Serial flasher config menu. From here, fill your serial port of the ESP32 board. You can see my ESP32 serial port from the ESP-WROVER-KIT board here:

Setting a serial port for the ESP32 board

If complete, click the Save button. The menuconfig program will save your project configuration. The program output can be seen in the following screenshot. You should see that this tool generates the sdkconfig file into your current project directory:

A result of configuring a project

Now, your program is ready for compiling and flashing.

Compiling and flashing

After we configured our project, we can flash our program into the ESP32 board. We can type this command on the current project directory from the following terminal:

$ make flash

This command performs compiling and flashing. If the make command is not found, you should install make for your platform.

If you have configured a serial port of the ESP32 board, the program will be flashed. Otherwise, you will get a timeout because the tool cannot find the ESP32 serial port. You can see my program output on the flashing process in the following screenshot:

Flashing a program into the ESP32 board

If this succeeds, you should see lighting on LED 1, LED2, and LED 3.

Next, we develop the ESP32 program using Arduino Sketch.