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.

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.

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.

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:

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 ESP32 Thing has 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:

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 visit https://www.adafruit.com/product/3405 to purchase this 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.

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.

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:

Next, we create 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:

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.

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

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

3. 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"

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

5. 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);
    }

6. 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;
    }
}

7. 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;
    }
}

8. Now, save all programs.

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

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:

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:

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:

Now, your program is ready for 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:

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

Next, we develop the ESP32 program using Arduino Sketch.

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:

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:

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:

Now, your Arduino is ready for ESP32 boards.

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

2. 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;

3. 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);

}

4. 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;
 }
}

5. 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;
}

6. Save the program.

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

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:

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

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.

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