Internet of Things Projects with ESP32

4.8 (5 reviews total)
By Agus Kurniawan
  • Instant online access to over 7,500+ books and videos
  • Constantly updated with 100+ new titles each month
  • Breadth and depth in over 1,000+ technologies
  1. Getting Started with ESP32

About 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.

Publication date:
March 2019
Publisher
Packt
Pages
252
ISBN
9781789956870

 

Chapter 1. Getting Started with ESP32

ESP32 is a low-cost chip that consists of MCU with Wi-Fi and a Bluetooth network stack that makes it possible to build an Internet of Things (IoT) application. In this chapter, we will review ESP32 boards and learn ESP32 basic development.

We will also cover the following topics:

  • Introduction to ESP32
  • Reviewing development boards-based ESP32
  • Setting up a development environment
  • Building ESP32 programs with Espressif SDK
  • Developing Sketch programs on ESP32 development boards
 

Technical requirements


Before we begin, make sure you have the following things ready:

  • A computer with an OS installed such as Windows, Linux, or macOS.
  • An ESP32 development board. Recommended is the ESP-WROVER-KIT v4 board from Espressif.
 

Introduction to ESP32


ESP32 is a low-cost Wi-Fi and Bluetooth chip from Espressif Systems. ESP32 integrates Wi-Fi (2.4 GHz band) and Bluetooth 4.2 solutions on a single chip. It also supports classic Bluetooth for legacy connections such as L2CAP, SDP, GAP, SMP, AVDTP, AVCTP, A2DP (SNK), and AVRCP (CT). ESP32 also supports Bluetooth Low Energy (BLE), which covers L2CAP, GAP, GATT, SMP, and GATT-based profiles. A detailed product review of the ESP32 chip/module can be found at the following link: https://www.espressif.com/en/products/hardware/esp32/.

There are two forms for ESP32: chip form and module form. ESP32 chip and module forms have different sizes and numbers of pins. Choosing ESP32 form is dependent on your design and purposes. The size factor of ESP32 form can also be one of your preferences when you make and design an IoT solution-included PCB scheme. A list of ESP32 chips and modules can be read on the following website: https://www.espressif.com/en/products/hardware/modules.

Next, we will review some development boards that use the ESP32 chip or ESP32 module.

 

Reviewing development boards-based ESP32


Since ESP32 has two forms, in chip and module, there are some development boards with an ESP32 chip or ESP32 module.In this book, we will not learn how to make a board-based ESP32. Instead, we will use pre-existing, ready development boards available on the market.

We can categorize boards-based ESP32 into two models. The first board models are the development boards officially manufactured by Espressif.  The second models are from their partners or personal makers.

Let's review some available ESP32 development boards on the market.

The official ESP32 development kit

In general, Espressif provides an ESP32 development kit board that we can use directly. We don't need to take any effort to make a PCB board and do soldering of the ESP32 chip. A list of ESP32 boards from Espressif can be found at this link: https://www.espressif.com/en/products/hardware/development-boards. We will review the two ESP32 boards: ESP32-PICO-KIT and ESP-WROVER-KIT boards.

ESP32-PICO-KIT is a basic development board that is small in size. This board fits on breadboard PCB, so you can do wiring on it. The board consists of EPS32 chips such as serial USB CP2102 (version 4.0)/CP2102N (version 4.1). You can connect this board to a computer through USB. 

ESP-WROVER-KIT is a complete development board. This consists of various sensors and modules. The board uses ESP32-WROVER for ESP32 board implementation. The following are the main features from ESP-WROVER-KIT:

  • JTAG interface on FT2232HL
  • Camera connector
  • I/O connector
  • RGB LED
  • Micro SD card slot
  • LCD

A form of ESP-WROVER-KIT can be seen in this photo:

ESP-WROVER-KIT

Third-party boards-based ESP32

We can buy ESP32 chips and modules from Espressif and their distributors. Then, we can make our own development board for ESP32. Sometimes, these boards-based ESP32 boards are sold to the public. In this section, we will review two ESP32 development boards.

SparkFun ESP32 Thing is one of the ESP32 development boards from SparkFun. This board uses the ESP32 chip. The board provides TTL USB to make it possible to communicate with the ESP32 chip. In addition, SparkFun ESP32Thinghas an LiPo connector so we can run the board with a battery. For further information about SparkFun ESP32 Thing, you can visit on this site: https://www.sparkfun.com/products/13907. A form of the SparkFun ESP32 Thing board is shown in the following photo:

SparkFun ESP32 Thing

Adafruit is an electronic manufacturer and electronic product online store. They make a development board-based ESP32 called Adafruit HUZZAH32 – ESP32 Feather Board. This board uses the ESP32 module. Adafruit HUZZAH32 has a TTL USB and LiPo connector like the SparkFun ESP32 Thing board. You can visithttps://www.adafruit.com/product/3405 to purchase this board:

Adafruit HUZZAH32 – ESP32 Feather Board

Other board-based ESP32 boards can be found on Alibaba and AliExpress. You can search for ESP32 board as keywords. There are many custom development boards with ESP32 chips or modules.

In this book, I use ESP-WROVER-KIT for testing.

 

 

Setting up the development environment


Espressif provides SDK development for ESP32. Technically, there is a guideline document from Espressif on how to set up the ESP32 toolchain. You can follow this guideline for Windows, Linux, and macOS: https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html#setup-toolchain.

After completed, you can continue to get ESP-IDF to enable you to develop the ESP32 program. You also need all required libraries for Python. A detailed guideline can be read on this site: https://docs.espressif.com/projects/esp-idf/en/latest/get-started/index.html#get-started-get-esp-idf.

If done, we can develop programs for the ESP32 board. The ESP32 program is written in C programming language, which you should be familiar with. However, we can write ESP32 programs using any text editor. In this book, I use Visual Studio code: https://code.visualstudio.com. This IDE tool is available for Windows, Linux, and macOS.

Next, we develop a simple program with the ESP32 board.

 

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.

Wiring

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)
  • component.mk 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 component.mk files.

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

Writing the program

Now, we write scripts and codes on the Makefile, component.mk, 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/project.mk

 

 

  1. component.mk is required for compiling purposes. You should create a component file with this exact name. The content of the component.mk 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",  
    configMINIMAL_STACK_SIZE, NULL, 5, NULL);
    }
  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_pad_select_gpio(LED1); 
    gpio_set_direction(LED1, GPIO_MODE_OUTPUT);
    gpio_pad_select_gpio(LED2); 
    gpio_set_direction(LED2, GPIO_MODE_OUTPUT);
    gpio_pad_select_gpio(LED3); 
    gpio_set_direction(LED3, GPIO_MODE_OUTPUT);

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

        current_led++;
        if(current_led>3)
            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);

    switch(led)
    {
        case 1:
            gpio_set_level(LED1, 1);
            break;
        case 2:
            gpio_set_level(LED2, 1);
            break;
        case 3:
            gpio_set_level(LED3, 1);
            break;
    }
}
  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.

 

Arduino programming for ESP32


Arduino is the biggest community for open source hardware. It has various Arduino boards to fit your needs. Arduino also provides software to develop the Arduino program, Sketch. Arduino Sketch can be downloaded at https://www.arduino.cc/en/Main/Software.

Now, ESP32 boards support Arduino development. Technically, ESP32 development with Arduino still uses Espressif SDK. You should set Arduino Sketch software to enable you to work with ESP32 boards. You can configure this based on your platform. Please follow this guideline on the following website: https://github.com/espressif/arduino-esp32.

It is recommended to install ESP32 boards into Arduino software via Board Manager. Open the Preferences dialog from Arduino, then put this URL into the board manager URL: https://dl.espressif.com/dl/package_esp32_index.json:

Adding ESP32 boards into Arduino software

 

 

When this is done, click OK.

Now, you can install ESP32 boards. To do this, open Boards Manager from the Tools menu. Type esp32 on this form so you can see the esp32 package, as shown in the following screenshot:

Installing ESP32 boards

After you have clicked Install, Arduino will download all required libraries for ESP32. If done, we will see a list of ESP32 boards on the Arduino software. You can see this in the following screenshot:

A list of ESP32 boards in Arduino

Now, your Arduino is ready for ESP32 boards.

 

Demo 2 - making an Arduino Sketch program with ESP32


In this section, we develop an Arduino program for ESP32 boards. We will use the previous demo, but we still use Arduino software. If you don't have experience with Arduino Sketch, I recommend learning Sketch programming on this site: https://www.arduino.cc/reference/en/. Since ESP32 has two cores (core 0 and core 1), our Arduino program runs one core. You don't need to worry which about core will be used by Arduino. You can verify which core is used with the xPortGetCoreID() function.

  1. We use the pinMode() function to set ESP32 GPIO pins as input or output. Then, we can write digital values using the digitalWrite() function. Using the previous demo, we can implement the demo using Sketch, as follows:
#define LED1 12
#define LED2 14
#define LED3 26
  1. Let's set the current_let to 1. That meant that later will start turning the LEDs with LED number 1.
int current_led = 1;
  1. Every program developed with the help of Arduino IDE will contain the setup() function. Code in setup function will run only on time at the beginning. For now let’s setup the pins that will drives our LEDS as output pins.
void setup() {
 pinMode(LED1, OUTPUT);
 pinMode(LED2, OUTPUT);
 pinMode(LED3, OUTPUT);

}
  1. This is a helper function that will get a led number as parameter and will turn off all the LEDS and based on the value of the input parameter will turn on that LED by using the digitalWrite() function.
void turn_on_led(int led)
{
 // turn off all leds
 digitalWrite(LED1, LOW);
 digitalWrite(LED2, LOW);
 digitalWrite(LED3, LOW);

 switch(led)
 {
 case 1:
 digitalWrite(LED1, HIGH);
 break;
 case 2:
 digitalWrite(LED2, HIGH);
 break;
 case 3:
 digitalWrite(LED3, HIGH);
 break;
 }
}
  1. The code in the loop() function will run continuously like in a while(1). For now the code will turn on one LED every second. When the code reach the last LED then will go back to the first one and the process will run forever.
void loop() {
 turn_on_led(current_led);
 delay(1000); 
 current_led++;
 if(current_led>3)
 current_led = 1;
}
  1. Save the program.

Now, you can set the ESP32 board target and its port, as shown in the following screenshot:

Configuring the ESP32 Wrover module

Now, you can compile and upload the Sketch program via Arduino software. If you succeed, you can see the program output as shown in the following screenshot:

Uploading the Sketch program to the ESP32 board

If you still get errors, please verify your ESP32 board type and its serial port.

 

 

 

Summary


In this chapter, we have learned about and reviewed the ESP32 board. We have also set up a development environment for ESP32 boards. At the end of the chapter, we developed a blinking program for three LEDs using Espressif SDK. Lastly, we implemented the same scenario using Arduino software.

In the next chapter, we will learn how to work with LCDs on the ESP32 board.

 

Further reading


For more information on ESP-IDF programming, I recommend reading: the ESP-IDF Programming Guide, athttps://docs.espressif.com/projects/esp-idf/en/latest/.

About the Author

  • Agus Kurniawan

    Agus Kurniawan is an independent technology consultant, author, and lecturer. He has over 18 years' experience working on various software development projects, including delivering training courses and workshops, and delivering technical writing. He has done a few research activities related to wireless networking, software, and security in multiple universities. Currently, he is pursuing a Ph.D. program in Computer Science in Germany.

    He has previously written five books for Packt.

    Browse publications by this author

Latest Reviews

(5 reviews total)
fit my expectations, no issues
Idem ao comentário dado acima
The content of this book is rare on the Internet. There is not much book about esp-idf. But there are some things that need to be fixed. I've only seen part of the book yet, For example, the makefile gets an error when importing the dht11 driver code. The builds should be done in the cmake format of the git source linked in this book.

Recommended For You

Book Title
Unlock this full book FREE 10 day trial
Start Free Trial