A brief introduction to ESP32 and OTA Lab 5

A brief introduction to ESP32 and Over the Air Programming

(OTA)
Objectives:

⮚ To familiarize participants with the ESP32 hardware and software setup, including board components and
software installation.
⮚ To teach basic ESP32 programming and GPIO control, enabling participants to blink LEDs and read digital
inputs.
Learn about Arduino and the Arduino UNO and how you can integrate this board into your makerspace and coding program. Make interactive makerspace projects while learning to code and problem solve.

1
 A brief introduction to ESP32 and OTA Lab 5

ESP 32:
The ESP32 is a series of low-cost and low-power System on a Chip (SoC) microcontrollers developed by
Espressif that include Wi-Fi and Bluetooth wireless capabilities and dual-core processor. If you’re familiar
with the ESP8266, the ESP32 is its successor, loaded with lots of new features.

Mainly because of the following features:

● Low-cost: you can get an ESP32 starting at $6, which makes it easily accessible to the general
public;
● Low-power: the ESP32 consumes very little power compared with other microcontrollers, and it
supports low-power mode states like deep sleep to save power;
● Wi-Fi capabilities: the ESP32 can easily connect to a Wi-Fi network to connect to the internet
(station mode), or create its own Wi-Fi wireless network (access point mode) so other devices can
connect to it—this is essential for IoT and Home Automation projects—you can have multiple
devices communicating with each other using their Wi-Fi capabilities;
● Bluetooth: the ESP32 supports Bluetooth classic and Bluetooth Low Energy (BLE)—which is useful
for a wide variety of IoT applications;
● Dual-core: most ESP32 are dual-core— they come with 2 Xtensa 32-bit LX6 microprocessors: core
0 and core 1.
● Rich peripheral input/output interface—the ESP32 supports a wide variety of input (read data
from the outside world) and output (to send commands/signals to the outside world) peripherals
like capacitive touch, ADCs, DACs, UART, SPI, I2C, PWM, and much more.
● Compatible with the Arduino “programming language”: those that are already familiar with
programming the Arduino board, you’ll be happy to know that they can program the ESP32 in the
Arduino style.
● Compatible with MicroPython: you can program the ESP32 with MicroPython firmware, which is
a re-implementation of Python 3 targeted for microcontrollers and embedded systems.

ESP32 Specifications
If you want to get a bit more technical and specific, you can take a look at the following detailed specifications of the
ESP32 (source: http://esp32.net/)

2
A brief introduction to ESP32 and OTA Lab 5

3
 A brief introduction to ESP32 and OTA Lab 5

● Wireless connectivityWiFi: 150.0 Mbps data rate with HT40

● Bluetooth: BLE (Bluetooth Low Energy) and Bluetooth Classic

● Processor: Tensilica Xtensa Dual-Core 32-bit LX6 microprocessor, running at 160 or 240 MHz

● Memory:

● ROM: 448 KB (for booting and core functions)

● SRAM: 520 KB (for data and instructions)

● RTC fast SRAM: 8 KB (for data storage and main CPU during RTC Boot from the deep-sleep
mode)
● RTC slow SRAM: 8KB (for co-processor accessing during deep-sleep mode)

● eFuse: 1 Kbit (of which 256 bits are used for the system (MAC address and chip configuration)
and the remaining 768 bits are reserved for customer applications, including Flash-Encryption
and Chip-ID)
● Embedded flash: flash connected internally via IO16, IO17, SD_CMD, SD_CLK, SD_DATA_0
and SD_DATA_1 on ESP32-D2WD and ESP32-PICO-D4.
● 0 MiB (ESP32-D0WDQ6, ESP32-D0WD, and ESP32-S0WD chips)

● 2 MiB (ESP32-D2WD chip)

● 4 MiB (ESP32-PICO-D4 SiP module)

● Low Power: ensures that you can still use ADC conversions, for example, during deep sleep.

● Peripheral Input/Output:

● peripheral interface with DMA that includes capacitive touch

● ADCs (Analog-to-Digital Converter)

● DACs (Digital-to-Analog Converter)

● I²C (Inter-Integrated Circuit)

● UART (Universal Asynchronous Receiver/Transmitter)

● SPI (Serial Peripheral Interface)

● I²S (Integrated Interchip Sound)

4
 A brief introduction to ESP32 and OTA Lab 5

● RMII (Reduced Media-Independent Interface)

● PWM (Pulse-Width Modulation)

● Security: hardware accelerators for AES and SSL/TLS

Main Differences Between ESP32 and ESP8266

What are the main differences between ESP32 and ESP8266 boards?

The ESP32 adds an extra CPU core, faster Wi-Fi, more GPIOs, and supports Bluetooth 4.2 and Bluetooth low energy.
Additionally, the ESP32 comes with touch-sensitive pins that can be used to wake up the ESP32 from deep sleep, and
built-in hall effect sensor.

In summary:

● The ESP32 is faster than the ESP8266;

● The ESP32 comes with more GPIOs with multiple functions;

● The ESP32 supports analog measurements on 18 channels (analog-enabled pins) versus just one 10-bit ADC
pin on the ESP8266;
● The ESP32 supports Bluetooth while the ESP8266 doesn’t;

5
 A brief introduction to ESP32 and OTA Lab 5

● The ESP32 is dual-core (most models), and the ESP8266 is single core;

● The ESP32 is a bit more expensive than the ESP8266.

ESP32 Development Boards

ESP32 refers to the bare ESP32 chip. However, the “ESP32” term is also used to refer to ESP32 development boards.
Using ESP32 bare chips is not easy or practical, especially when learning, testing, and prototyping. Most of the time,
you’ll want to use an ESP32 development board.

These development boards come with all the needed circuitry to power and program the chip, connect it to your
computer, pins to connect peripherals, built-in power and control LEDs, an antenna for wi-fi signal, and other useful
features. Others even come with extra hardware like specific sensors or modules, displays, or a camera in the case of
the ESP32-CAM.

How to Choose an ESP32 Development Board?

Once you start searching for ESP32 boards online, you’ll find there is a wide variety of boards from different vendors.
While they all work in a similar way, some boards may be more suitable for some projects than others. When looking
for an ESP32 development board there are several aspects you need to take into account:

6
 A brief introduction to ESP32 and OTA Lab 5

● USB-to-UART interface and voltage regulator circuit. Most full-featured development boards have
these two features. This is important to easily connect the ESP32 to your computer to upload code
and apply power.
● BOOT and RESET/EN buttons to put the board in flashing mode or reset (restart) the board. Some
boards don’t have the BOOT button. Usually, these boards go into flashing mode automatically.
● Pin configuration and the number of pins. To properly use the ESP32 in your projects, you need to
have access to the board pinout (like a map that shows which pin corresponds to which GPIO and its
features). So make sure you have access to the pinout of the board you’re getting. Otherwise, you
may end up using the ESP32 incorrectly.
● Antenna connector. Most boards come with an onboard antenna for Wi-Fi signal. Some boards come
with an antenna connector to optionally connect an external antenna. Adding an external antenna
increases your Wi-Fi range.
● Battery connector. If you want to power your ESP32 using batteries, there are development boards
that come with connectors for LiPo batteries—this can be handier. You can also power a “regular”
ESP32 with batteries through the power pins.
● Extra hardware features. There are ESP32 development boards with extra hardware features. For
example, some may come with a built-in OLED display, a LoRa module, a SIM800 module (for
GSM and GPRS), a battery holder, a camera, or others.

What is the best ESP32 development board for beginners?

For beginners, we recommend an ESP32 board with a vast selection of available GPIOs, and without any extra
hardware features. It’s also important that it comes with voltage regular and USB input for power and upload code.

In most of our ESP32 projects, we use the ESP32 DEVKIT DOIT board, and that’s the one we recommend for
beginners. There are different versions of this board with a different number of available pins (30, 36, and 38)—all
boards work in a similar way.

7
 A brief introduction to ESP32 and OTA Lab 5

ESP32 DEVKIT DOIT

The picture below shows the ESP32 DEVKIT DOIT V1 board, version with 36 GPIO pins.

8
 A brief introduction to ESP32 and OTA Lab 5

It comes with a microUSB interface that you can use to connect the board to your computer to upload code or apply
power.

It uses the CP2102 chip (USB to UART) to communicate with your computer via a COM port using a serial interface.
Another popular chip is the CH340. Check what’s the USB to UART chip converter on your board because you’ll
need to install the required drivers so that your computer can communicate with the board (more information about
this later in this guide).

This board also comes with a RESET button (may be labeled EN) to restart the board and a BOOT button to put the
board in flashing mode (available to receive code). Note that some boards may not have a BOOT button.

It also comes with a built-in blue LED that is internally connected to GPIO 2. This LED is useful for debugging to
give some sort of visual physical output. There’s also a red LED that lights up when you provide power to the board.

9
 A brief introduction to ESP32 and OTA Lab 5

ESP32 GPIOs Pinout Guide

The ESP32 chip comes with 48 pins with multiple functions. Not all pins are exposed in all ESP32 development
boards, and some pins should not be used. The ESP32 DEVKIT V1 DOIT board usually comes with 36 exposed
GPIOs that you can use to connect peripherals.

Power Pins
Usually, all boards come with power pins: 3V3, GND, and VIN. You can use these pins to power the board (if you’re
not providing power through the USB port), or to get power for other peripherals (if you’re powering the board using
the USB port).

General Purpose Input Output Pins (GPIOS)

Almost all GPIOs have a number assigned and that’s how you should refer to them—by their number.

With the ESP32 you can decide which pins are UART, I2C, or SPI – you just need to set that on the code. This is
possible due to the ESP32 chip’s multiplexing feature that allows to assign multiple functions to the same pin.

If you don’t set them on the code, the pins will be configured by default as shown in the figure below (the pin location
can change depending on the manufacturer). Additionally, there are pins with specific features that make them suitable
or not for a particular project.

10
 A brief introduction to ESP32 and OTA Lab 5

We have a detailed guide dedicated to the ESP32 GPIOs that we recommend you read: ESP32 Pinout Reference
Guide. It shows how to use the ESP32 GPIOs and explains what are the best GPIOs to use depending on your project.

The placement of the GPIOs might be different depending on your board model. However, usually, each specific
GPIO works in the same way regardless of the development board you’re using (with some exceptions). For example,
regardless of the board, usually GPIO5 is always the VSPI CS0 pin, GPIO 23 always corresponds to VSPI MOSI for
SPI communication, etc.

How to Program the ESP32?

The ESP32 can be programmed using different firmware and programming languages.

Our preferred method to program the ESP32 is with C/C++ “Arduino programming language”. We also have some
guides and tutorials using MicroPython firmware.

Programming ESP32 with Arduino IDE

To program your boards, you need an IDE to write your code. For beginners, we recommend using Arduino IDE.
While it’s not the best IDE, it works well and is simple and intuitive to use for beginners. After getting familiar with
Arduino IDE and you start creating more complex projects, you may find it useful to use VS Code with the Platformio
extension instead.

11
 A brief introduction to ESP32 and OTA Lab 5

If you’re just getting started with the ESP32, start with Arduino IDE. At the time of writing this tutorial, we
recommend using the legacy version (1.8.19) with the ESP32. While version 2 works well with Arduino, there are
still some bugs and some features that are not supported yet for the ESP32.

Installing the ESP32 in Arduino IDE

To be able to program the ESP32 using Arduino IDE, you need to add support for the ESP32 boards. Follow the next
steps:

Go to File > Preferences.

Enter the following into the “Additional Board Manager URLs” field. This will add support for ESP32 and ESP8266
boards as well.

https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json,
http://arduino.esp8266.com/stable/package_esp8266com_index.json

See the figure below. Then, click the “OK” button.

12
 A brief introduction to ESP32 and OTA Lab 5

Open the Boards Manager. Go to Tools > Board >Boards Manager…

Search for ESP32 and install the “ESP32 by Espressif Systems“:

That’s it. It will be installed after a few seconds.

13
 A brief introduction to ESP32 and OTA Lab 5

After this, restart your Arduino IDE.

Then, go to Tools > Board and check that you have ESP32 boards available.

14
 A brief introduction to ESP32 and OTA Lab 5

Now, you’re ready to start programming your ESP32 using Arduino IDE.

ESP32 Examples
In your Arduino IDE, you can find multiple examples for the ESP32. First, make sure you have an ESP32 board
selected in Tools > Board. Then, simply go to File > Examples and check out the examples under the ESP32 section.

15
 A brief introduction to ESP32 and OTA Lab 5

Update the ESP32 Core in Arduino IDE

Once in a while, it’s a good idea to check if you have the latest version of the ESP32 boards add-on installed.

16
 A brief introduction to ESP32 and OTA Lab 5

You just need to go to Tools > Board > Boards Manager, search for ESP32, and check the version that you have
installed. If there is a more recent version available, select that version to install it.

Upload Code to the ESP32 using Arduino IDE

To show you how to upload code to your ESP32 board, we’ll try a simple example available in the Arduino IDE
examples for the ESP32.

First, make sure you have an ESP32 selected in Tools > Board. Then, go to File > Examples > WiFi > WiFiScan.

This will load a sketch that scans Wi-Fi networks within the range of your ESP32 board.

Connect your ESP32 development board to your computer using a USB cable. If you have an ESP32 DEVKIT DOIT
board, the built-in red LED will turn on. This indicates the board is receiving power.

17
 A brief introduction to ESP32 and OTA Lab 5

Important: you must use a USB cable with data wires. Some USB cables from
chargers or power banks are power only and they don’t transfer data—these won’t
work.
Now, follow the next steps to upload the code.

1) Go to Tools > Board, scroll down to the ESP32 section and select the name of your ESP32 board. In my case, it’s
the DOIT ESP32 DEVKIT V1 board.

2) Go to Tools > Port and select a COM port available. If the COM port is grayed out, this means you don’t have the
required USB drivers. Check the section Installing USB Drivers before proceeding.

3) Press the upload button.

18
 A brief introduction to ESP32 and OTA Lab 5

Some boards will automatically go into flashing mode and the code will be successfully uploaded straight away.

Other boards don’t go into flashing mode automatically, so you may end up getting the following error.

Failed to connect to ESP32: Timed out... Connecting...

Or something like:

A fatal error occurred: Failed to connect to ESP32: Wrong boot mode

detected (0x13)! The chip needs to be in download mode.

This means the ESP32 was not in flashing mode when you tried to upload the code. In this situation, you should long
press the board BOOT button, when you start seeing the “Connecting….” message on the debugging window.

Note: in some boards, a simple trick can make the ESP32 go into flashing mode automatically. Check it out on the
following tutorial: [SOLVED] Failed to connect to ESP32: Timed out waiting for packet header.

Now, the code should be successfully uploaded to the board. You should get a “Done uploading “message”.

Demonstration
To see if the code is working as expected, open the Serial Monitor at a baud rate of 115200.

Press the ESP32 RST or EN button to restart the board and start running the newly uploaded code.

You should get a list of nearby wi-fi networks.

19
 A brief introduction to ESP32 and OTA Lab 5

This means everything went as expected.

Installing ESP32 USB Drivers

After connecting the ESP32 board to your computer, if the COM port in Arduino IDE is grayed out, it means you
don’t have the necessary USB drivers installed on your computer.

Most ESP32 boards either use the CP2101 or CH340 drivers. Check the USB to UART converter on your board, and
install the corresponding drivers.

You’ll easily find instructions with a quick google search. For example “install CP2101 drivers Windows”.

ESP32 Over the Air Programming (OTA)

One of the best things about ESP32 is that its firmware can be updated wirelessly. This kind of programming is called
“Over-The-Air” (OTA).

20
 A brief introduction to ESP32 and OTA Lab 5

What is OTA programming in ESP32?

OTA programming lets you update/upload a new program to the ESP32 over Wi-Fi without having to connect the
ESP32 to the computer via USB.

The OTA functionality comes in handy when there is no physical access to the ESP module. In addition, it reduces the
time required to update each ESP module during maintenance.

One key advantage of OTA is that a single central location can send an update to multiple ESPs on the same network.

The only disadvantage is that you must include an OTA code with each sketch you upload in order to use OTA in the
next update.

Ways To Implement OTA In ESP32

There are two ways to implement OTA functionality in the ESP32.

Basic OTA – updates are delivered using the Arduino IDE.

Web Updater OTA – updates are delivered via a web browser.

Each one has its own benefits, so you can use whichever one works best for your project.

This tutorial will walk you through the process of implementing Basic OTA.

Upload Basic OTA Firmware Serially

Because the ESP32’s factory image lacks OTA Upgrade capability, you must first load the OTA firmware on the
ESP32 via serial interface.

It is required to first update the firmware to perform subsequent updates over-the-air.

The ESP32 add-on for the Arduino IDE includes an OTA library as well as a BasicOTA example. Simply navigate to
File > Examples > ArduinoOTA > BasicOTA.

21
 A brief introduction to ESP32 and OTA Lab 5

Before you begin

uploading the sketch, you must modify the following two variables with your network credentials so that the ESP32
can connect to an existing network.

#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>

const char* ssid = "..........";

const char* password = "..........";

void setup() {
Serial.begin(115200);
Serial.println("Booting");
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.waitForConnectResult() != WL_CONNECTED) {
22
 A brief introduction to ESP32 and OTA Lab 5

Serial.println("Connection Failed! Rebooting...");

delay(5000);
ESP.restart();
}

// Port defaults to 3232

// ArduinoOTA.setPort(3232);

// Hostname defaults to esp3232-[MAC]

// ArduinoOTA.setHostname("myesp32");

// No authentication by default
// ArduinoOTA.setPassword("admin");

// Password can be set with it's md5 value as well

// MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
// ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");

ArduinoOTA
.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else // U_SPIFFS
type = "filesystem";

// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using
SPIFFS.end()
Serial.println("Start updating " + type);
})
.onEnd([]() {
Serial.println("\nEnd");
})
.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
})
.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
else if (error == OTA_END_ERROR) Serial.println("End Failed");
});

ArduinoOTA.begin();

Serial.println("Ready");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}

23
 A brief introduction to ESP32 and OTA Lab 5

void loop() {
ArduinoOTA.handle();
}

Now, open the Serial Monitor at 115200 baud rate and press the EN button on the ESP32. If everything is fine, you
should see the dynamic IP address assigned by your router. Make a note of it.

Upload New Sketch

Over-The-Air
Now, let’s upload a new sketch over-the-air.

Remember that you must include the OTA code in every sketch you upload. Otherwise, you will lose OTA capability
and will be unable to perform the next over-the-air upload. Therefore, it is recommended that you modify the
preceding code to include your new code.

As an example, we will include a simple Blink sketch in the Basic OTA code. Remember to modify the SSID and
password variables with your network credentials.

#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>

const char* ssid = "..........";

24
 A brief introduction to ESP32 and OTA Lab 5

const char* password = "..........";

//variabls for blinking an LED with Millis

const int led = 2; // ESP32 Pin to which onboard LED is connected
unsigned long previousMillis = 0; // will store last time LED was updated
const long interval = 1000; // interval at which to blink (milliseconds)
int ledState = LOW; // ledState used to set the LED
void setup() {

pinMode(led, OUTPUT);
Serial.begin(115200);
Serial.println("Booting");
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.waitForConnectResult() != WL_CONNECTED) {
Serial.println("Connection Failed! Rebooting...");
delay(5000);
ESP.restart();
}

// Port defaults to 3232

// ArduinoOTA.setPort(3232);

// Hostname defaults to esp3232-[MAC]

// ArduinoOTA.setHostname("myesp32");

// No authentication by default
// ArduinoOTA.setPassword("admin");

// Password can be set with it's md5 value as well

// MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
// ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");

ArduinoOTA
.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else // U_SPIFFS
type = "filesystem";

// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using
SPIFFS.end()
Serial.println("Start updating " + type);
})
.onEnd([]() {
Serial.println("\nEnd");
})
.onProgress([](unsigned int progress, unsigned int total) {
Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
})

25
 A brief introduction to ESP32 and OTA Lab 5

.onError([](ota_error_t error) {
Serial.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) Serial.println("Auth Failed");
else if (error == OTA_BEGIN_ERROR) Serial.println("Begin Failed");
else if (error == OTA_CONNECT_ERROR) Serial.println("Connect Failed");
else if (error == OTA_RECEIVE_ERROR) Serial.println("Receive Failed");
else if (error == OTA_END_ERROR) Serial.println("End Failed");
});

ArduinoOTA.begin();

Serial.println("Ready");
Serial.print("IP address: ");
Serial.println(WiFi.localIP());
}

void loop() {
ArduinoOTA.handle();
//loop to blink without delay
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
ledState = not(ledState);
// set the LED with the ledState of the variable:
digitalWrite(led, ledState);
}
}

After copying the above sketch to your Arduino IDE, navigate to Tools > Port option. Look for something like: esp32-
xxxxxx at your_esp_ip_address. If you are unable to locate it, you may need to restart your IDE.

26
 A brief introduction to ESP32 and OTA Lab 5

Choose the port and press the Upload button. The new sketch will be uploaded in a matter of seconds. The on-board
LED should start blinking.

27
 A brief introduction to ESP32 and OTA Lab 5

Lab Tasks
1. Connect 3 leds when you type FIRSTON so 1st led should be turn on and when you type
SECONDON second led should be on and so on. Similarly turn off the 1st led with FIRSTOFF
command and so on.
2. Connect a Serial monitor with PIR sensor whenever a motion is detected the serial monitor display
“Motion Detected” and when no motion detected serial monitor display “No Motion”
3. Make a spy robot if the distance of ultrasonic sensor is less than 20cm the LED will turn on.
4. By performing OTA, make a smart security system if the distance of ultrasonic sensor is less than 3
foot then BUZZ the alarm.

28