ESP32 BLE (Bluetooth Low Energy)

Hello readers, I hope you all are having fun in your lives. Welcome to the 2nd Chapter of Section-2 in the ESP32 Programming Series. In today's lesson, we'll go over another built-in feature of the esp32 module that helps it stand out from the competition: BLE or Bluetooth Low Energy.

In the previous tutorial, we discussed the Classic Bluetooth in ESP32, which is considered the predecessor of Bluetooth Low Energy(which we are going to discuss today). We will first look at, what is BLE? and why is it used?, and then will design some examples to utilize the ESP32 BLE in Arduino IDE.

Where To Buy?
No.ComponentsDistributorLink To Buy
1ESP32AmazonBuy Now

What is BLE?

  • There have been numerous adjustments and upgrades to Bluetooth's characteristics since its inception, where Bluetooth 4.0(also called BLE or Bluetooth Smart) is the most influential.
  • BLE or Bluetooth Smart is also known as Wibree. The Wibree protocol was designed by Nokia in 2006 and was later included in Bluetooth 4.0 as Bluetooth Low Energy in December 2009.
  • Bluetooth Low Energy is a slightly different protocol from Classic Bluetooth, which is used in phones, headphones, TVs etc. Rather than continuously streaming data, BLE "servers" can "notify" clients to send the data chunks on a regular basis(which makes it preferable over traditional Bluetooth). As a result, BLE is better suited to low-power IoT applications that don't require significant volumes of data.
  • Both the server and clients now utilize a "service UUID", to determine which server and client needs to be connected. There are various "characteristics" that can be found inside these services.
  • Bluetooth Low Energy was developed and promoted by the Bluetooth Special Interest Group (SIG) for use in healthcare, beacons, fitness, home entertainment etc. It does not work with standard Bluetooth and does not have any compatibility, although it can coexist with BR/EDR and LE.
  • The Bluetooth Special Interest Group (SIG) recognizes several industries for low-energy technology, including smart homes, health, sport, and fitness.

Difference b/w traditional Bluetooth and BLE

Bluetooth Technology was created with the intention of allowing data to be streamed indefinitely. That implies you can send and receive a large amount of data over a short distance with Bluetooth.

  • It's crucial to discuss power usage while discussing the differences between Bluetooth and Bluetooth Low Energy. Bluetooth Low Energy is intended to transfer data only when the client is available to receive the data from the server; otherwise, the BLE device will go into low energy or sleep mode. Thus, use significantly less power as compared to traditional Bluetooth, while retaining a similar communication range.
  • Bluetooth Low Energy uses the same 2.4 GHz radio frequencies as traditional Bluetooth, but a different FHSS (Frequency Hopping Spread Spectrum) technique.
  • Classic Bluetooth uses Scatter-net topology whereas BLE uses Star topology.

Although Bluetooth Low Energy differs from the previous Bluetooth Basic Rate/Enhanced Data Rate protocol, both can be supported by the same device: the Bluetooth 4.0 specification allows devices to implement any or both of the LE and BR/EDR systems.

Because both, Bluetooth Low Energy and traditional Bluetooth use the same 2.4 GHz radio frequencies, allowing dual-mode devices to use a single radio antenna.

How does BLE work?

BLE Client & Server

  • Any BLE device can operate as both a server and a client.
  • Server ESP32 will announce its presence to nearby clients so that clients can establish a connection with the BLE server for communication.
  • Broadcast mode and mesh networks both are also supported by BLE.
  • In broadcast mode, only the BLE server transmits data to all the connected clients.
  • In mesh mode, all the devices are connected to each other.  Therefore, all devices can communicate with all other available devices.

GATT

  • GATT is an acronym for Generic Attributes.

It defines a data structure that is visible to all BLE devices linked to it. GATT defines how BLE devices can communicate with each other. Understanding this structure is crucial to understand the working of BLE.

The GATT protocol includes a set of commands that allow the client to learn more about the server.

  • Read through all of the descriptors for a specific characteristic.
  • Find out everything there is to know about a specific service.
  • Find qualities that match a UUID.
  • Find UUIDs for all major services.
  • Find a service using a UUID.
  • For a particular principal service, locate subsidiary services.

BLE Service

A service is nothing more than a collection of data, such as data from a temperature sensor.

  • A profile, which is made up of multiple services, is at the top of the structure. Typically, a BLE-supported device will have multiple services.
  • The SIG  has preset services for a variety of data kinds, such as battery level, weight, blood pressure, heart rate, and so on.
  • Every service has at least a single feature and can also refer to different services.

BLE Characteristics

The characteristic attribute is always held by a particular service, and it is where the hierarchy's real data is stored.

The characteristic has two attributes:

  • Characteristic value.
  • The characteristic declaration contains the metadata.

It essentially consists of the operations that can be used like Indicate, read, write, notify, broadcast etc.

UUID or Universally Unique Identifier

  • In a Generic Attribute (GATT) profile, the UUID is a universally unique 128-bit or 16-byte integer that is used to identify profiles, services, and data kinds.
Note:
  • In the code description, we will provide a link where you can generate a new UUID.

BLE network topology

BLE uses Star and mesh topology for communication.

A Broadcast Type or a Connection Type communication between two BLE devices is possible. The 'broadcaster' BLE Device sends data to any 'observer' BLE Device in broadcasting. It's a data transfer that only goes one way.

A 'Connection' between the BLE Devices is required for two-way communication. A Central (Master) BLE Device continuously checks for advertising data packets sent by a Peripheral (Slave) BLE Device.

BLE Applications

  • BLE is ideal for applications that need to exchange modest amounts of data on a regular basis.
  • BLE is used extensively in healthcare, fitness, tracking, beacons, security, and home automation etc.
  • Bluetooth Low Energy is natively supported by mobile operating systems such as iOS, Android, and Windows Phone, as well as macOS, Linux, Windows 8 & 10.

ESP32 BLE

  • You can use ESP32 BLE either as a BLE server or a client.
  • Examples are available in the ESP32 BLE library(Arduino IDE) which you can use to implement BLE services.

Note:

  • The Arduino IDE must have the ESP32 board manager file and libraries installed. If you haven't previously prepared your Arduino IDE to operate with the ESP32, then read our previous tutorial, i.e., Introduction to ESP32 Programming Series.

BLE Server Code Description

  • For coding, we are using Arduino IDE’s inbuilt example and will make the required changes in that code only.
  • I will also explain the code in detail for beginners to understand.

In this code, ESP32, BLE will be used as a server.

  • Import the necessary/required libraries for the BLE application.
  • Define a UUID for the Service and Characteristic.

  • To generate UUIDs, go to the following link:

         https://www.uuidgenerator.net/

 
  • You can either use the default UUIDs if you wish to or go to the above link to generate random UUIDs as per your services and attributes.
  • Call back or acknowledge the server whether the client is connected or not

Arduino Setup() Function

  • Serial Communication at a baud rate of 115200.
  • Create a name for your BLE device for identification, we named it Wibree.
  • Set the BLE device as a server.
  • Create a service for the BLE server with the UUID defined earlier.
  • The characteristic for that service is then set. As you can see, you're still using the UUID you created previously, and you'll need to supply the properties of the characters as arguments. It's read and write in this scenario.
  • You can also add other services like battery, indicate, notify etc.
  • The setValue() method can be used to set the value of a characteristic.
  • The above value can be changed to whatever you like. This could be a sensor reading.
  • Finally, activate the service and advertising so that other BLE devices can scan and locate this BLE device.

Arduino Loop() Function

  1. Here we can check if the device is connected to the client or not
  2. If connected then do some tasks like transmitting data or receiving input from the client.

Data Size Per Packet

20 bytes per packet.

Unfortunately, BLE isn't built to handle large amounts of data. The maximum data size per packet in the BLE specification is 20 bytes, so if you wish to communicate more, you'll have to divide it up into many packets. Fortunately, this isn't a challenging task. Simply put, use a delimiter like "!" or "*" or something unique at the end of your whole message to signal the app that the message is done and to start listening for future communications. If you want to send + > 20 bytes cumulatively, for example, you can send and then proceed with the next message if needed.

Testing ESP32 BLE Server

After creating a BLE server using ESP32, we can use a BLE application available on the Play store for testing purposes.

Demonstration with BLE scanner app:

  1. Go to the play store
  2. Search for the BLE scanner and download the app
  3. After installing the app turn on the Bluetooth.
  4. Open the app and search for nearby devices.

  • Now connect to ESP32 BLE  by clicking on the ESP32 device.
  • In our case, we named the device ‘Wibree’.
  • Now you can use the various services provided by BLE like writing and reading data packets, checking battery levels etc. and a lot more.

This concludes the tutorial. I hope you find it helpful.

Create a Web Server with ESP32

Hello readers, I hope you all are doing great. Today, we are going to start the second section of the ESP32 tutorial series and today's our first tutorial, where we will have a look at How to Create a Web Server with ESP32. In our previous tutorial, we introduced you to the basics of the ESP32 microcontroller. where we discuss How to set up Arduino IDE to program ESP32. In this tutorial, we will discuss creating a web server using the ESP32 module.

One of the most interesting features of the ESP microcontroller series is its wireless connectivity via WiFi & Bluetooth. Wireless connectivity protocols supported by ESP32 are:

  • Wi-fi: 802.11b/g/n/e/i
  • Bluetooth : BLE(Bluetooth low energy) and V4.2
Where To Buy?
No.ComponentsDistributorLink To Buy
1ESP32AmazonBuy Now

What is a Web server?

A web server is software or hardware that stores, processes, and delivers web pages to users on request. In other words, it serves users all over the World Wide Web (www). The web server uses the hypertext transfer protocol (HTTP or HTTPS) for communication with the clients(normally, web browsers). We know that HTTP is a set of rules to format and exchange messages.

The following are some important features of a web server:

Features of a Web Server

  • A web server, either physical or virtual, is a computer that hosts one or more websites.
  • The HTTP protocol is the foundation of any data exchange within the network when using the server. So a web server uses it to communicate with the client.
  • The web server uses static content and the files do not change dynamically. Some such files used in a web service are:
    • HTML files
    • Images
    • Stylesheets
    • JavaScript files
  • The web server has multiple settings to avoid unnecessary attacks. This helps to maintain the health and integrity of a website. There are multiple types of web security attacks, such as:
    • DDoS attacks
    • SQL injection
    • Cross-site scripting (XSS)

Hence, a web server has multiple features to serve the users on the web.

Web Server & Client Communication

A client is an entity that initiates communication with the web server and then the server provides the information required. In simple words, the client is a program, device, or user that requests services or resources from the devices, such as the web server. The communication and relationship between these two is called the server-client model. The following are the general server-client model steps that will help to understand the whole scenario:

The client sends an HTTP request to the server. The request includes the URL of the web page that the client wants to retrieve.

  • The client (when the user requires data) sends an HTTP request to the server. This request may include the URL of the web page from which the client wants to retrieve the information.
  • The server receives the request instantly and processes it. It does it when it looks up the URL saved in its database to find the corresponding web page file a client requires.
  • If the web page file is found, the server sends it back to the client in the form of an HTTP response. This response also includes other important types of information, such as the page's content type and expiration date, etc.
  • The client then receives the response and renders the web page on the user's screen. The client uses the content type information to determine how to display the web page.
  • If the page is not found in the URL database, the server shows the error.

Web browsers like Chrome, Firefox, and Safari are examples of clients. 

ESP32 as a Web Server

The ESP32 is a microcontroller famous for its wireless capabilities, which makes it ideal for a large number of fields, especially IoT. We are talking about WiFi connectivity as a web server and here are the key features of this module related to it:

  • The ESP32 is made under the IEEE 802.11b/g/n standards; therefore it has a 2.4 GHz frequency band. Therefore, it can be used as:
    • Common WiFi routers
    • Access point
  • The built-in WiFi capabilities of the ESP32 allow it to be used as a server and carry out the easiest and most effective communication at a distance without any physical connection.
  • It has three operating modes:
    • In station mode, the ESP32 is operated as a WiFi client. It means it can be connected to the existing Wi-Fi network. (We are covering today)
    • In access point mode, it is operated as a WiFi access point; therefore it allows other devices to create a connection with it. (will be covered in the next lecture)
    • In dual mode, it can act as a server and as a client and allow the features of both at the same time. (will be covered in the 3rd lecture of section 2)
  • It has a dual processor that helps in handling multiple tasks at the same time. Therefore, ESP32 is more capable of managing a large network of devices and making it responsive for concurrent connections.
  • It has asynchronous web server libraries, such as “ESPAsyncWebServe” to handle the HTTP requests asynchronously. These are useful because they allow it to effectively manage the connections without blocking the execution of other tasks.
  • ESP32 has multiple security protocols that are used when creating the web server. As a result, it provides secure and protective communication between the devices.
  • It has over-the-air updates, which means it can update the device's firmware without physically accessing it. It helps with remote updates and maintenance.
  • The ESP32 is suitable for use as a server because of its multiple features, including:
    • It can serve static files
    • It can handle different HTTP methods (GET, POST, etc.)
    • It supports features like server-side scripting
  • The WebSockets feature of ESP32 allows it to carry out bi-directional communication between servers and clients. You will learn about both of these in just a bit.
  • The ESP32 supports WiFi Direct, which is also referred to as the Peer to Peer (P2P); therefore, it can form a direct connection with other devices with no need for an external WiFi network.

ESP32 WebServer Working Principle

We know that the ESP32 has a built-in WiFi feature. This makes it suitable to use as a server. The example of the server-client relationship we have just discussed shows the internet connection of the whole world. The ESP32 can be used for the intranet connection, which is defined as:

"An intranet is a private network that has limited functionalities and is only accessible to users within a specific organization/location."

Usually, this network may consist of different devices, such as mobile phones, computers, laptops and tablets. The Arduino IDE is for the programming of the ESP32, just like we have done in the previous session. If your Arduino IDE is ready with the boards and ports, then let us try the built-in example of the ESP32 to use as a server. 

What is an SSID?

  • An SSID is a service set identifier that is the unique name of a wireless local area network (WLAN).
  • It can be 32 characters long.
  • It may include numbers, letters, and signs.
  • The SSID can be set by the user as well.
  • In simple words, the SSID is the name of the WiFi connection people use for their connection.

In the experiment we are just performing, the user has to replace the SSID with their own SSID to connect with the ESP32.

Using the ESP32 Server Built-in Example

Using the ESP32 as a server is easy with the web server example. It has the basics, and here are the steps to follow:

  • Open the Arduino IDE.
  • Connect the esp32 to your system through the cable. Make sure the ESP32 is connected accurately.
  • Click on tools>boards>ESP32>Node32s. This is my board and you can choose according to the model of ESP32.
  • Go to the files> examples>examples of Nose32s>WiFi and from the side menu, choose “SimpleWifiServer".
  • It will create a new project with the code in it to run the ESP32 (connected to your system) as a server.
  • Press the encoder (EN) button of the ESP32.
  • Change the SSID and password according to your choice. In my case, it is PTCL-BB.
  • Go to lines 38, 103, and 106 by one and replace the pin “5” digit with pin “2” because the built-in light is at pin 2.
  • Replace lines 70 and 71 with the following:

client.print("Click <a href=\"/H\">here</a> to turn the LED on pin 2 on.<br>");

client.print("Click <a href=\"/L\">here</a> to turn turn the LED on pin 2 off.<br>");

  • All the instructions are given in the code. Go to line 30 and place your SSID there.
  • Go to line 31 and enter the password of your choice.
  • Read the code carefully and hit the “verify” button.
  • Once the code is compiled, press "Boot" on the ESP32 when the uploading process is carried out.
  • Wait for the loading to complete.
  • Click on the “Serial Monitor” button at the upper right corner of the screen to open the monitor. You can go to Tool>Serial Monitor for the same task.
  • Choose the baud rate of 115200 from the drop-down menu at the right corner of the monitor.
  • Right now, the monitor is blank:
  • Click the EN button on the EPS32 to see the information.
  • Now that the monitor has data and is loading, it starts to connect with the WiFi connection of the system.
  • Once the loading is complete, it will provide the IP address. Copy this address.
  • Go to the new tab in the browser and paste the address there.
  • You will see that merely placing the “H” or “L” just after the IP address (as given in the code comment) will turn on and off the LED on ESP32 according to the URL.

Note: Make sure you have installed the port and board before you try this code and have selected all the right options; otherwise, you can face errors. 

ESP32 Server as Messenger

  • The ESP32 can be used to send the message through the browser.
  • The microcontroller connects to the internet connection of the system.
  • The serial monitor shows the IP address.
  • The ESP32 acts as a server and through the URL of the browser, the user will send the message to the Arduino IDE.
  • This message will be shown on the serial monitor.
  • The user can change the message through the URL pasted in the web browser.

Material Required

  • Internet connection
  • System (e,g, laptop)
  • ESP32 microcontroller
  • Connecting cable

Code for ESP32 as Server

#include <WiFi.h>

const char *ssid = "My-SSID";

const char *password = "My-Password";

WiFiServer server(80);

void setup() {

  Serial.begin(115200);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {

    delay(1000);

    Serial.println("Connecting to WiFi...");

  }

  Serial.println("Connected to WiFi");

  Serial.println("IP address: ");

  Serial.println(WiFi.localIP());

  server.begin();

}

void loop() {

  WiFiClient client = server.available();

  if (client) {

    Serial.println("New Client.");

    while (client.connected()) {

      if (client.available()) {

        String request = client.readStringUntil('\r');

        client.flush();

        // Check if the request contains a specific message

        if (request.indexOf("GET /message") != -1) {

          int startPos = request.indexOf("message=") + 8;

          int endPos = request.indexOf("HTTP/1.1") - 1;

          String message = request.substring(startPos, endPos);

          Serial.println("Received message: " + message);

          // Send a proper HTTP response

          client.println("HTTP/1.1 200 OK");

          client.println("Content-type: text/plain");

          client.println("Connection: close");

          client.println();

          client.print("Message received!");

          // Close the connection

          client.stop();

          Serial.println("Client disconnected.");

          break;

        }

      }

    }

  }

}

Procedure

  • Connect the ESP32 to the system using the cable.
  • Open the Arduino IDE.
  • Create a new project and remove the current code.
  • Make sure you have the respective port and board installed successfully.
  • Connect the right port and board.
  • Paste the code given above into the new project.
  • "Verify" the code by using the button.
  • Once verified, compile and upload the code.
  • Once the code is compiled, press the Boot button.
  • Once the installation is completed, go to the serial monitor.
  • Press the EN button.
  • The serial monitor will show the information. Copy the IP address shown on the end of loading.
  • The general ULR for sending the message through the server is given as: http://esp32-ip-address/message?message=Hello
  • To send the “Hello” message to the ESP32 through the browser, use your IP address and the message. In my case, I am pasting the following URL in the browser: http://192.168.43.251/message?message=Hello
  • Once reloaded, go to the serial monitor and check for the message:
  • You can change the message through the URL.

http://192.168.43.251/message?message=I_am_using_The_Engineering_Projects

  • This will create the following output:

How ESP32 WebServer works with hardware?

  • For the demonstration purpose, we will create a webpage and will launch it through our ESP32 module, so ESP32 will be acting as a web server, serving the page.
  • This webpage will have 3 Buttons on it, which will be controlling three LEDs, we will turn ON or OFF respective LEDs using these buttons.
  • WebServer Page is shown in the below figure:
  • Now the question arises, how will ESP32 understand which Button has been pressed?
  • For that, we have created multiple links i.e. the HomePage Url will look like:

http://192.168.43.188/

  • When a user will click on LED 26 ON Button, we will redirect the user to:

http://192.168.43.188/26/on

  • Now, when the client wants to turn OFF the LED, we will redirect to:

http://192.168.43.188/26/off

  • So, actually, we are checking the request from the client and based on that request we are turning ON or OFF the respective LED.
  • Moreover, we are providing the same webpage to all the links but with the change in the state of each button i.e. if it's ON then Blue, otherwise Green.

If it looks too complicated, don't worry. These things will get more clear when we will cover the Arduino coding.

Note:

ESP32 server Modes:

ESP32 Wi-Fi module includes a number of useful characteristics, including the ability to use a soft access point mode, a station mode, or both modes at the same time. Only station mode will be discussed in this session. I'll also cover how to use this board in soft access mode in future tutorials.

  1. Station Mode: The ESP32 board connects to your Wi-Fi network via a router in Station mode. The router serves as the communication channel between the web client and the ESP32. The IP address is obtained from the Wi-Fi router. Web clients can connect to the Web server using this IP address across a local network.
  2. Access Point Mode: In this mode, the ESP32 creates its own wireless Wi-Fi network, similar to the one provided by your existing router. We don't need to connect the ESP2 to a Wi-Fi network in this mode. This Wi-Fi board can link up to 5 devices to the Wifi network it creates.
Controlling peripherals Using ESP32 Web Server

Connect the peripherals to the ESP32 board which you want to control through the ESP32 Web Server.

Here, we are going to control two external LEDs connected to LED1 (GPIO 26), LED2 (GPIO 27), and an inbuilt LED.

The following are the requirements for creating an ESP32 webserver to control peripherals:
  • ESP32 module
  • Internet connection
  • LEDs
  • Resistors
  • Connecting Wires

Arduino IDE Code

  • Using the Arduino IDE, upload the following code to the ESP32 module:
#include // Replace with your network credentials char* ssid = "ESP32"; //enter SSID char* passphrase = "asdfgf@123"; // enter the password // Set web server port number to 80 WiFiServer server(80); // Variable to store the HTTP request String header; // Auxiliar variables to store the current output state String output26State = "off"; String output27State = "off"; String builtin_led_state = "off"; // Assign output variables to GPIO pins const int output26 = 26; const int output27 = 27; // Current time unsigned long currentTime = millis(); // Previous time unsigned long previousTime = 0; // Define timeout time in milliseconds (example: 2000ms = 2s) const long timeoutTime = 2000; void setup() { Serial.begin(115200); // Initialize the output variables as outputs pinMode(output26, OUTPUT); pinMode(output27, OUTPUT); pinMode(LED_BUILTIN, OUTPUT); // Set outputs to LOW digitalWrite(output26, LOW); digitalWrite(output27, LOW); digitalWrite(LED_BUILTIN, LOW); // Connect to Wi-Fi network with SSID and password Serial.print("Connecting to "); Serial.println(ssid); WiFi.begin(ssid, passphrase); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } // Print local IP address and start web server Serial.println(""); Serial.println("WiFi connected."); Serial.println("IP address: "); Serial.println(WiFi.localIP()); server.begin(); } void loop(){ WiFiClient client = server.available(); // Listen for incoming clients if (client) { // If a new client connects, currentTime = millis(); previousTime = currentTime; Serial.println("New Client."); // print a message out in the serial port String currentLine = ""; // make a String to hold incoming data from the client while (client.connected() && currentTime - previousTime <= timeoutTime) { // loop while the client's connected currentTime = millis(); if (client.available()) { // if there's bytes to read from the client, char c = client.read(); // read a byte, then Serial.write(c); // print it out the serial monitor header += c; if (c == '\n') { // if the byte is a newline character // if the current line is blank, you got two newline characters in a row. // that's the end of the client HTTP request, so send a response: if (currentLine.length() == 0) { // HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK) // and a content-type so the client knows what's coming, then a blank line: client.println("HTTP/1.1 200 OK"); client.println("Content-type:text/html"); client.println("Connection: close"); client.println(); // turns the GPIOs on and off if (header.indexOf("GET /26/on") >= 0) { Serial.println("GPIO 26 on"); output26State = "on"; digitalWrite(output26, HIGH); } else if (header.indexOf("GET /26/off") >= 0) { Serial.println("GPIO 26 off"); output26State = "off"; digitalWrite(output26, LOW); } else if (header.indexOf("GET /27/on") >= 0) { Serial.println("GPIO 27 on"); output27State = "on"; digitalWrite(output27, HIGH); } else if (header.indexOf("GET /27/off") >= 0) { Serial.println("GPIO 27 off"); output27State = "off"; digitalWrite(output27, LOW); } else if (header.indexOf("GET /LED_BUILTIN/on") >= 0) { Serial.println("BUILTIN LED on"); builtin_led_state = "on"; digitalWrite(LED_BUILTIN, HIGH); } else if (header.indexOf("GET /LED_BUILTIN/off") >= 0) { Serial.println("BUILTIN_LED off"); builtin_led_state = "off"; digitalWrite(LED_BUILTIN, LOW); } // Display the HTML web page client.println(""); client.println(""); client.println(""); // CSS to style the on/off buttons // Feel free to change the background-color and font-size attributes to fit your preferences client.println(""); // Web Page Heading client.println("

ESP32 Web Server

"); // Display current state, and ON/OFF buttons for builtin led client.println("

LED_BUILTIN - State " + builtin_led_state + "

"); // If the LED is off, it displays the ON button if (builtin_led_state=="off") { client.println("

"); } else { client.println("

"); } // Display current state, and ON/OFF buttons for GPIO 26 client.println("

LED_1 - State " + output26State + "

"); // If the output26State is off, it displays the ON button if (output26State=="off") { client.println("

"); } else { client.println("

"); } // Display current state, and ON/OFF buttons for GPIO 27 client.println("

LED_2 - State " + output27State + "

"); // If the output27State is off, it displays the ON button if (output27State=="off") { client.println("

"); } else { client.println("

"); } client.println(""); // The HTTP response ends with another blank line client.println(); // Break out of the while loop break; } else { // if you got a newline, then clear currentLine currentLine = ""; } } else if (c != '\r') { // if you got anything else but a carriage return character, currentLine += c; // add it to the end of the currentLine } } } // Clear the header variable header = ""; // Close the connection client.stop(); Serial.println("Client disconnected."); Serial.println(""); } }
Note:
  • You need to modify the SSID and password with your network credentials.

Code Description:

Here, we'll take a closer look at the code to see how it works.

  • The first task is to add a Wi-Fi library.
  • As mentioned previously, you must type your SSID and password inside the double quotes in the following lines.
  • As we are creating a web server, so we need to assign a port to it and normally we use port 80 for a local webserver.
  • So, in the below code, Port 80 is assigned to the webserver and then initialized a few variables:
  1. String header: variable to store the header of the HTTP request.
  2. Below the header variable, we have variables to store the current state of connected peripheral LEDs and built-in LED. If you wish to add more peripherals and save their states, you need to create more variables. By default, all LEDs are in the OFF state.
  3. Next, assigned GPIOs to each peripheral device or component. Here we are using GPIO 26(LED1) and GPIO 27(LED2). You can use any other suitable GPIOs.
  4. Lastly, we have initialized a few variables to check the connection timeout, we will check their working soon.

Arduino Setup() Function

  • Now let's first have a look at the Arduino setup loop.
  • First, we have initialized our Serial Port at a baud rate of 115200, so that we could monitor the results at the serial terminal.
  • Define the GPIOs as OUTPUTs and set them to LOW, as by default LEDs will be off.
  • To set up a wifi connection, we called the WiFI.begin() and here we have provided our SSID and passphrase as variables.
  • Now our ESP32 will try to connect to the provided WiFi connection.
  • As you can see, we have a while loop, where we are checking the WiFi Status.
  • If ESP32 gets connected with WiFi, the while loop will break and a message will get printed on the Serial Monitor "WiFi Connected".
  • Now our ESP32 is connected to the WiFi, so the router must have assigned an IP address to ESP32 and we are printing it on Serial using WiFi local IP Function.
  • Finally, we begin our server, to which we have assigned Port 80 at the start.

Arduino Loop() Function

Now, we are done with all the basic settings in the setup function. Let's have a look at the code in the Loop function:

  • At the last line of the Setup function, we have started our webserver, so now ESP32 is acting as a webserver and is waiting for incoming clients.
  • But what will happen, when someone will hit the IP Address of this webserver?
  • So, in the loop function, first of all, we are listening to the incoming client using the server.available() function.
  • If any client is available i.e. someone has entered our IP Address in the browser then we will print the HTML page.
  • So, we are going to write the rest of our code in this IF loop.
  • AS you can see in the below code, if the client is available, we have printed "New Client" on Serial Monitor.
  • After that, we have a while loop checking for client connection, so as long as we have a connection with the client, we will remain in this loop.
  • Inside this while loop, we have an If loop, checking if the client is available.
  • Now, if we are connected to the client, we need to read for the incoming request.
  • So, If there are any bytes to read from the client, read those bytes:
  • The client request ends at New Line Character \n, so we are checking for that.
  • Once we received the New Line Character, we are sending the response back to the Client.
  • In response, we have first sent the HTTP header, which is the default for webpages so that browsers should understand the response type.

Checking Request Type

  • As we discussed earlier, on each button press, we are redirecting our client to its respective link.
  • Depending on which button is pushed, we make requests to different URLs to turn the LEDs on and off using if else statements, as shown below:
   
  • As you can see in the above code, we are repeating the same code three times for 3 LEDs.
  • In the first block, we are simply checking the header response and if it's a GET request and from "/26/on", we have turned that Pin HIGH, changed the LED state variable to "on" and sent a message on the serial monitor.
  • So, if a client clicks on the LED 26 ON button, ESP32 will understand the GET request and glow the LED.
  • The other buttons work in the same way. If you wish to add more outputs, you'll need to change this section of the code.

 HTML to display a web page

  • We have designed the output part i.e. what we are going to do when a user clicks any button.
  • And now we are going to design those buttons themselves i.e. we are designing the webpage.
  • As you can see in the below figure, we have standard HTML tags at the start.
  • After that, we have some CSS text to design the buttons and the appearance of the web page. We use the Helvetica font and set the information to be shown as a block with the center aligned.
  • Next, displaying Web page heading i.e. "ESP32 Web Server".
  • Next, comes the If Loop for the first Button, we are checking the LED state variable and based on LED state, we are displaying our Button.
  • So, if the LED state is OFF, we are redirecting the user to /LED_BUILTIN/on and vice versa.
  • That's how we are changing the Buttons on the webpage, as you can see buttons are using different CSS classes for on and off states.
  • Similar loops are used to display the states on other connected LEDs.
  • Finally, we are closing the web connection and clearing the header that was used to store the HTTP request header using client.stop() function.
  • Printing information about the closed web connection on the serial monitor.

Uploading Web Server Code to ESP32

  • Please reread the previous instruction, "Introduction to ESP32 programming series," if you are unfamiliar with the procedure of uploading code in the Arduino IDE.
  • After uploading the code, open the Serial Monitor with a baud rate of 115200.
  • Enable the ESP32 by pressing the EN (enable) button. The ESP32 establishes a Wi-Fi connection and the Serial Monitor displays the ESP32 IP address. To connect to the ESP32 web server, you'll need that IP address.
Note:
  • Make sure you have selected the right board and COM port.

Getting IP address and Access ESP32 web Server

  • After successfully uploading the code in esp32 module.
  • Open Serial Monitor from the top right corner of Arduino IDE screen as shown in figure below:
  • The IP address required to connect to the ESP32 point will be displayed on the Serial Monitor. It's 192.168.43.223 in this scenario.
 
  • To access the webserver, type the IP Address of the ESP32 into a Web Browser on a laptop or a mobile phone. It's 192.168.43.223 in our case.
  • You should be able to see a simple web page served by the ESP32's Web Server if everything goes well.

A screenshot of a Web Browser on a laptop accessing the ESP32 Web Server is shown below.

  • The image below is displaying the ON state of the inbuilt LED.
  • The inbuilt LED is Blue in color.
  • The below image is displaying the OFF State of the inbuilt LED

Hence, We have done a lot of work on the ESP32 by using it as a server. In the beginning, we saw what is a web server and studied its features in detail. After that, we saw that ESP32 can be used as a server and we saw the feature that makes it ideal for this task. Then we experimented to learn the concept, in which we saw the built-in example of ESP32 as a server in Arduino IDE. We saw the step-by-step procedure to experiment and once it was completed, we moved on to a more complex example. I hope you find this tutorial useful and have performed it by yourself but if you are stuck at any point, you can ask in the comment section.

Using the ESP32 web server and the preceding process, you can control the peripherals linked to the ESP32 module from any mobile, tablet, or computer. The only need is that all of the devices to be linked to the same network.

This concludes the lesson. I hope it becomes useful to you. In the next tutorial, we will have a look at How to work the ESP32 BLE, so stay tuned. Have a good day. :)

ESP32 Programming Series: Install ESP32 in Arduino IDE

Hello everyone, I hope you're all doing well. In the previous lecture(Chapter 0: ESP32 Pinout), we discussed the ESP32 features & specs in detail. Today, we are officially starting this ESP32 Programming Series. In this ESP32 Programming Series, we will start with basic concepts and will gradually move towards complex topics. I will try to keep this ESP32 series as simple as I can. But still, if you encounter any issues, please ask in the comments, will try to resolve the issues as soon as possible.

As ESP32 has numerous features & applications, so I have divided this series into different sections. I have named the 1st section "ESP32 IDEs". In this section, we will discuss different IDEs used to program ESP32 boards. In each Chapter of this section, we will install one of these ESP32 IDEs and will test a simple LED Blinking Code in it. We will set up the ESP32 Development Environment for Windows, Mac, and Linux users.

As I am sharing the 1st Chapter today, so first we will unbox the ESP32 board, set up the most commonly used ESP32 IDE i.e. Arduino IDE, and test a simple WiFi Scan Code on the ESP32.

Here's a video lecture for better understanding:

Where To Buy?
No.ComponentsDistributorLink To Buy
1ESP32AmazonBuy Now

ESP32 IDEs

IDE is an abbreviation of Integrated Development Environment. IDE is a software package used to write & compile the code. As ESP32 is one of the most popular microcontroller boards, there are numerous third-party IDEs available to program it, and each IDE supports its own programming language. So, if you are a C# developer or an Arduino expert, you can quickly and easily get your hands dirty with ESP32. The below table shows the most commonly used ESP32 IDEs along with their supported programming language:

ESP32 IDEs
No.
ESP32 IDEs
Programming Language
1
Arduino IDE
Arduino C
2
Thonny IDE
MicroPython
3
Visual Studio Code
Arduino C
4
PlatformIO IDE
C++
5
ESP-IDF(official IDE by EspressIF)
C
6
nanoFramework
C#

In today's lecture, we will install the Arduino IDE and configure it for ESP32 Programming. So, let's get started:

Install ESP32 in Arduino IDE

First of all, we need to install the Arduino IDE itself. To program ESP32 with Arduino IDE, we need to install the ESP32 Boards in Arduino IDE. Before installing the ESP32 Boards, we first need to add a JSON File containing information about ESP32 Boards. JSON format is used to share information between two computers. So, this JSON file will add the information of ESP32 boards in the Arduino IDE. So, let me summarize these 3 steps in proper order:

  1. Installing Arduino IDE
  2. Adding ESP32 JSON File
  3. Installing ESP32 Boards
  4. Installing COM Port Driver for ESP32(if COM Port not detected automatically)

Installing Arduino IDE

We need to first download & install the Arduino IDE.

After installing the Arduino IDE, we need to add the ESP32 JSON File in it. So, follow the below steps:

Adding ESP32 JSON File in Arduino IDE

Steps to install ESP32 JSON File in Arduino IDE:

  • In the Arduino Preferences Window, you will find a textbox named "Additional boards Manager URL".
  • Add the ESP32 JSON File link(provided above) in it, as shown in the below figure:

  • If you have already added any third-party board URLs, then add a comma (,) between the JSON links OR click on the button and it will open up a new window, add URL in the new row, as shown below:

  • Click "OK" to close the Preference Window.
  • Once you close the Preference Window, Arduino IDE will extract the information of all ESP32 boards by downloading the ESP32 JSON file.

Now, we are ready to install the ESP32 Boards in Arduino IDE:

Installing ESP32 Boards in Arduino IDE

  • In the Arduino IDE, click on "Tools > Board > Board Manager", as shown in the below figure:

  • It will open up a Board Manager Window in Arduino IDE.
  • From this Board Manager, we can install the packages for third-party modules.
  • In the Board Manager, make a search for "ESP32" and you will get many third-party ESP32 packages.
  • Here, we need to install the "ESP32 by Espressif Systems" as it's the official package, I have highlighted it in the below image:

  • So, click on the Install button to install ESP32 boards in Arduino IDE.
  • Arduino IDE will take some time to install the ESP32 package.

  • Once installed, click on "Tools > Boards > esp32" and you will find a list of newly added ESP32 boards, as shown in the below figure:

  • From this list, we will select "ESP32 DEV KIT V1", it's the most commonly used ESP32 board.

  • In the COM Port, select the available COM Port, in our case, it's COM5:

In some cases, the Arduino IDE won't automatically detect the ESP32 COM Port, so here we need to install the COM Port driver for ESP32. Let's do it:

Installing ESP32 COM Port in Arduino IDE

If you don't find the ESP32 COM Port in the Port Section of Arduino IDE, then you need to install the COM Port Driver manually. So, follow the below steps:

  • Download the Windows COM Port Driver by clicking the below button and install it on your computer:

CP210x_Windows_Drivers

  • If you are using 32-bit Windows, then install the x86 version and if working on 64-bit Windows, then install the x64 version.

After installing this COM Port Driver, restart your Arduino IDE and it's recommended to restart your computer as well.

So, we have successfully installed the ESP32 Boards in the Arduino IDE. Now, let's upload a simple LED Blinking Code in the ESP32:

Code Upload to ESP32 from Arduino IDE

Now that the Arduino IDE is ready to handle the ESP32 Dev Kit module, you can write the code for the ESP32 module. We will just upload a simple WiFi Scan Code to verify that our ESP32 installation is correct.

  • Open Arduino IDE and navigate to "File > Examples > WiFi > WiFiScan".

  • Click on the Tools and verify that you have selected the correct ESP32 board and the COM Port.
  • Now, click the "Upload " button to upload the code to the ESP32 board.
  • If the code is uploaded successfully in the ESP32 board, you will get the confirmation message in the Output pane, as shown in the below figure:

Now open the Serial Terminal and you will start receiving the List of all available WiFi connections, as shown in the below figure:

That concludes today's discussion. We hope you found this post informative. In the next tutorial, we will install the ESP32 Boards in the Visual Studio Code. If you have any questions, please ask in the comments. Take care. Have a good day.

ESP32 Pinout, Datasheet, Features & Applications

Hi Guys! I hope you’re doing great. Today, I am going to share Chapter Zero of the ESP32 Programming Course. I have called it Chapter 0 because today, we won't practically work on the ESP32. Instead, I’ll walk you through the detailed theoretical Introduction to the ESP32 Module, where we will discuss the ESP32 Pinout, Datasheet, Specifications, Features, Applications etc. in detail.

ESP32 is an embedded module that supports both WiFi and BT(dual-mode) connectivity and is thus used in Cloud-based IoT projects. ESP32 is the upgraded model of the ESP8266 module and is designed by Espressif Systems in China.

The following tables show the main features and technical specifications of the ESP32 module.

ESP32 Technical Specifications
No. Parameter Name Parameter Value
1
Microprocessor Tensilica Xtensa single-/dual-core 32-bit LX6 microprocessor(s)
2
CoreMark® score 1 core at 240 MHz: 504.85 CoreMark; 2.10 CoreMark/MHz
2 cores at 240 MHz: 994.26 CoreMark; 4.14 CoreMark/MHz
3 Operating Voltage 3.3V
4
DC Current on 3.3V Pin 50 mA
5
DC Current on I/O Pins 40 mA
6
Maximum Operating Frequency 240MHz
7
Frequency Oscillators 8MHz (Internal Oscillator)
Internal RC Oscillatoror
2MHz ~ 60MHz External Crystal Oscillator(40MHz required for WiFi/BT)
32kHz External Crystal Oscillator(For RTC)
8
Timers 2 x 64-bit Timers, 1 RTC Timer,

ESP32 Pinout
1
DAC
2 Channels (8-bit, digital to analog converter)
2
ADC 18 Channels (12-bit, analog to digital converter)
3
Capacitive Touch Sensors
10
4
LED PWM
16 Channels

ESP32 Communication Protocols
1
Wi-Fi 802.11 b/g/n (Speed upto 150Mbps)
2
Bluetooth Supports Classic Bluetooth v4.2 BR/EDR & Bluetooth Low Energy(BLE)
3
Bluetooth Low Energy Supports BLE
4
UART Protocol 3 Channels
5
SPI Protocol 4 Channels
6
I2C Protocol 2 Channels
7
I2S Protocol 2 Channels (for digital audio)
8 CAN Protocol 1 Channels

ESP32 Builtin Memory
No. Parameter Name Parameter Value
1 SRAM 520kb
2 ROM(Flash Memory) 448kb
3 RTC SRAM
16kb

So, let's get started with the Introduction to ESP32:

Where To Buy?
No.ComponentsDistributorLink To Buy
1ESP32AmazonBuy Now

Introduction to ESP32 Module

  • ESP32 (designed by Espressif Systems, a Shanghai-based Chinese Company) is a 48 Pin microprocessor-based embedded IC(available in QFN package), that supports both WiFi & BT(dual-mode) connectivity and is used majorly in wearable devices, mobile & cloud-based IoT applications.
  • The microprocessor used in the ESP32 chip is the Tensilica Xtensa LX6 microprocessor (single-core and dual-core).
  • A few LX6 based ESP32 ICs are:
    • ESP32-D0WDQ6 (and ESP32-D0WD)
    • ESP32-D2WD
    • ESP32-S0WD
    • ESP32-PICO-D4

ESP32 vs ESP8266

  • Both the ESP32 and ESP8266 are inexpensive WiFi modules with low power consumption.
  • Both modules are desirable for DIY projects in the areas of IoT (Internet of Things) and automation.
  • The ESP32 is a dual-core 160Mhz 240Mhz CPU, while the ESP8266 has an 80Mhz single-core processor. Therefore, if your primary concern is processor speed, you should prioritize the ESP32 over the ESP8266.
  • The ESP32 offers more GPIO than the ESP8266.
  • ESP32 supports Bluetooth 4.2 and BLE(Bluetooth Low Energy).
  • The ESP32 offers a 12-bit ADC, while the ESP8266 offers only a 10-bit ADC.

ESP32-WROOM-32

  • ESP32-WROOM-32 is a 38-pin breakout board of ESP32, which is most commonly used in third-party ESP32 modules.
  • As ESP32 IC is available in the QFN(Quad Flat No Leads) package, so it's quite difficult to solder the IC in embedded projects.
  • So, to ease the process of using ESP32 IC, Espressif Systems designed numerous small modules(using ESP32 chip) that have a built-in antenna and easily usable pinout.
  • Other ESP32 modules are ESP32-SOLO and ESP32-WROVER.
  • One of the most commonly used breakout boards of ESP32 is ESP32-WROOM-32, shown in the below figure:

Third-Party ESP32 Development Modules

  • Many embedded companies have used ESP32-WROOM-32 and designed different ESP32 development boards, which are plug-and-play modules and are thus normally used for learning and prototyping purposes.
  • One of the most commonly used ESP32 development boards is called ESP32-DevkitC.
  • ESP32-DevKitC is a 30-pin ESP32-based development board, designed by Espressif Systems and is used in embedded and IoT projects.

  • All you need to do is plug this device using a USB cable and play with it on the fly.
  • Boot mode and Reset buttons are incorporated on the board.
  • USB micro connector and USB-UART Bridge, and LDO regulator are also included in the device.

Types of ESP32 Development Boards

  • The following are the five different versions of ESP32-DevKitC.
    1. ESP32-DevKitC-32E
    2. ESP32-DevKitC-32UE
    3. ESP32-DevKitCVE
    4. ESP32-DevKitCVIE
    5. ESP32-DevKitCS1

So, that was the evolution of ESP32 from a simple IC to plug & play board. Now let's have a look at the Pinout of the ESP32 microcontroller and modules:

ESP32 Pinout

We have seen above that ESP32 has evolved first into ESP32-WROOM-32 and is further upgraded into ESP32-DevKitC. So, let's have a look at the pinout of all these boards, one by one:

Pinout of ESP32 IC

  • ESP32 IC in its pure form consists of 48 pins in total.
  • The following figure shows the labeled ESP32 Pinout diagram:

Pinout of ESP32-WROOM-32

  • ESP32-WROOM-32 is a breakout board of ESP32 and consists of 38 pins in total.
  • Here's the pinout of the ESP-WROOM-32 board:

Pinout of ESP32-DevkitC

  • ESP32-DevKitC is a development board based on the ESP32 microcontroller and it has 36 pins in total.
  • Here's the pinout diagram of ESP32 DevKitC:

ESP32 Pin Description

Now, let's have a look at the functions of ESP32 Pinout:

Power Pins in ESP32

  • Power: Power is applied through Micro-USB, 3.3V pin, 5V pin, and GND. Regulated 5V is supplied to this pin which is further regulated to 3.3V to power up the board. And 3.3V pin directly supplies the 3.3V regulated to the board. And the ground is connected to GND.
  • Enable: The enable pin is represented by ‘En’ on the board and is used to reset the microcontroller.
  • AREF: It is marked as AREF which is used to provide a reference voltage for input voltage.

GPIO Pins in ESP32

ESP32 has 36 GPIO(general purpose input/output) pins to perform numerous operations(normally one at a time). Third-party ESP32 modules have different numbers of GPIO pins i.e. ESP32 Dev Kit V1 includes 30 GPIO pins. Let's have a look at the functionality of ESP32 GPIO Pins:

ADC Pins in ESP32

  • ADC Pins: ESP32 has a total of 18 ADC channels(12-bit each) used to measure the analog voltage within the range of 0-3.3V.

ESP32 is equipped with two SAR analog-to-digital converter modules named ADC1 and ADC2. ADC1 has 10 Channels labeled from ADC2_1 to ADC2_7, while ADC2 has 10 Channels labeled from ADC2_0 to ADC2_9. The ADC output value ranges from 0 to 4093 at 12-bit resolution.

DAC Pins in ESP32

  • DAC Pins: ESP32 features 2 distinct 8-bit digital-to-analog converters(DAC1 and DAC2) for translating digital values to analog signals. The DAC function is attached to below two GPIO pins:
  1. DAC1-GPIO25
  2. DAC2-GPIO26

The DAC employs a power supply as an input reference voltage and features an internal resistance network.

PWM Pins in ESP32

  • PWM Pins: ESP32's PWM controller has 16 independent PWM channels with configurable frequency and duty cycles. Any GPIO pin can be used as a PWM pin.

PWM pulses are used to control the speed of motors or the brightness of LEDs. You can configure the frequency, channel, GPIO pin, and duty cycle of the PWM signal.

SPI Pins in ESP32

  • SPI Pins: ESP32 has three SPI blocks that operate in both master and slave modes, named SPI, HSPI, and VSPI.

Among these 3 blocks, SPI is used as an interface to flash memory. So, we are left with HSPI and VSPI for normal use:

  1. VSPI: ESP32 VSPI Pins are GPIO23 (MOSI), GPIO19 (MISO), GPIO18 (CLK) and GPIO5 (CS) used for SPI-1 communication.
  2. HSPI: ESP32 HSPI Pins are GPIO13 (MOSI), GPIO12 (MISO), GPIO14 (CLK) and GPIO15 (CS) used for SPI-2 communication.

I2C Pins in ESP32

The ESP32 has two I2C interfaces. The SCL and SDA pins of both I2C interfaces can be assigned by a user in the program. The default I2C pins are:

  • SDA-GPIO21
  • SCL-GPIO22

ESP32 Capacitive Touch Sensors

  • ESP32 has 10 capacitive touch-sensing GPIO Pins(T0 to T9), which get electrostatically charged when a finger touches the respective GPIO pin.

Without any additional hardware, these touch GPIOs can be utilized to make capacitive touchpads. Variations in capacitance are evident.

RTC GPIO

  • ESP32 has 18 Low-Power RTC GPIO Pins(RTCIO0 to RTCIO17) used to wake up the ESP32 board from deep sleep mode.

  • Serial: Two serial pins are represented on boards as Tx and Rx. The Tx is used to transmit serial data while Rx is used to receive serial data.

  • External Interrupts: All GPIO pins can be used as external interrupts.

ESP32 Datasheet

Before you incorporate this device into your electrical project, it’s wise to go through the datasheet of the component that features the main characteristics of the device. You can click the link given below to download the ESP32 datasheet.

Now, let's have a look at the features of ESP32:

ESP32 Features

Here are the main features of ESP32 IC:

  • ESP32 has built-in integration of both WiFi and Bluetooth dual-mode.
  • ESP32 has 34 programmable GPIOs present on the chip.
  • ADC is of 12-bit SAR and can support up to 18 channels.
  • DAC is 8-bit and it has 2 DAC channels.
  • ESP32 also has 10 touch sensors embedded in it.
  • ESP32 also has a Hall sensor in it.
  • It supports 4 SPI channels.
  • It also has 2 I²S channels.
  • ESP32 has 2 I²C ports in it.
  • It supports 3 UART channels.
  • It also has 1 host(SD/MMC/SDIO) and 1 slave(SDIO/SPI).
  • ESP32 also supports the Ethernet MAC interface with dedicated DMA and IEEE 1588 support.
  • It supports Two-Wire Automotive Interface (TWAI®, compatible with ISO11898-1)
  • LED PWM up to 16 channels

A few of ESP32's key features are discussed below in detail:

ESP32 WiFi Key Features

  • Wireless Networking Standard: 802.11 b/g/n
  • Wireless Standard: 802.11 n (2.4 GHz), up to 150 Mbps
  • WiFi Multimedia(WMM)
  • WiFi Aggregation: TX/RX A-MPDU, RX A-MSDU
  • Immediate Block ACK: suitable for high bandwidth & low latency traffic.
  • Automatic Beacon monitoring (hardware TSF)
  • Simultaneous support for SoftAP, Infrastructure Station and Promiscuous modes.
  • Diverse Antenna
  • Defragmentation to smoothen the data.
  • Supports 4 virtual WiFi Interfaces.

ESP32 Bluetooth Key Features

  • Compliant with Bluetooth v4.2 BR/EDR
  • Class-1, Class-2 and Class-3 transmitters without external power amplifier
  • Increased Power Control
  • Transmission Power: +12 dBm
  • BLE sensitivity: –94 dBm (NZIF receiver)
  • Adaptive Frequency Hopping (AFH)
  • Standard HCI supports SDIO/SPI/UART
  • High-speed UART HCI, up to 4 Mbps
  • Bluetooth 4.2 BR/EDR BLE dual-mode controller
  • CVSD and SBC for audio codec
  • Classic BT and BLE support Multiple connections.
  • It can advertise and scan simultaneously.
  • Bluetooth Piconet and Scatternet

ESP32 Microcontroller Key Features

  • ESP32 uses an Xtensa® single-/dual-core 32-bit LX6 microprocessor(s) .
  • It supports data rates up to 600 MIPS (200 MIPS for ESP32-S0WD/ESP32-U4WDH)
  • It has a Flash Memory of 448 KB.
  • It has an SRAM memory of 520 KB.
  • 16 KB SRAM in RTC
  • QSPI supports multiple flash/SRAM chips.

ESP32 Clocks & Timers Key Features

  • ESP32 has a calibrated 8MHz crystal oscillator (internal)
  • Calibrated RC oscillator (internal)
  • External 2 MHz ~ 60 MHz crystal oscillator (40 MHz only for Wi-Fi/BT functionality)
  • External 32 kHz crystal oscillator for RTC with calibration
  • Two timer groups, including 2 × 64-bit timers and 1 × main watchdog in each group
  • ESP32 also has one RTC timer.
  • RTC watchdog is also present in ESP32.

ESP32 Projects & Applications

ESP32 modules have brought a revolution in embedded and especially IoT projects. As these boards are small-sized, low-powered and support both WiFi & BT, thus are gaining popularity in IoT-based handheld devices. A few applications of the ESP32 module are as follows:

  • Used in Network projects.
  • Employed for beginner-level DIY projects.
  • Employed in the prototyping of IoT devices.
  • Used in cloud-based smart security projects.
  • Used in low-power battery-operated applications.

That was all about the Introduction to ESP32 module. If you have any questions, you can approach me in the comment section below. I’ll help you according to the best of my expertise. You’re most welcome to share your valuable feedback and suggestions around the content we share so we keep coming up with quality content customized to your exact needs and requirements. Thank you for reading the article.

Syed Zain Nasir

I am Syed Zain Nasir, the founder of <a href=https://www.TheEngineeringProjects.com/>The Engineering Projects</a> (TEP). I am a programmer since 2009 before that I just search things, make small projects and now I am sharing my knowledge through this platform.I also work as a freelancer and did many projects related to programming and electrical circuitry. <a href=https://plus.google.com/+SyedZainNasir/>My Google Profile+</a>

Share
Published by
Syed Zain Nasir