WiFi Temperature Monitor with ESP8266 and DS18B20

Hello friends, I hope you all are doing great. Today, we will create a wifi temperature monitoring system. For reading, we will use the DS18B20 sensor. For data processing and webpage creation, we will use our already known ESP8266.

The project will be built as follows:

1. Circuit assembly
2. Code for reading the DS18B20 sensor (we will use Serial for tests).
3. Creation of the webpage (we will use SPIFFS to store in FLASH).

But first, let's know a little about the sensor and the communication model it uses.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	ESP8266	Amazon	Buy Now

Materials

For this project, we will need the following items: For this project, we will need the following items:

• 1 x ESP8266
• 1x DS18B20 Sensor
• 1x Breadboard
• 1x 4k7 Ohms resistor

DS18B20

• DS18B20 is a digital temperature sensor with good precision, good customization, practical use, reliable and low cost. Good combination?
• The sensor monitors temperatures in the range: -55°C to +125°C (-67°F to + 257°F), with an accuracy of +-0.5°C in the range -10°C to +85°C (outside that range, this inaccuracy increases, but nothing absurd).

It uses three pins for operation:

• VDD (Power Supply)
• GND (Ground)
• DQ (Digital Communication)

VDD operates with values from 3V to 5.5V and can even be omitted. The sensor has a Parasite Mode, using only the DQ and GND pins, and its power comes from the communication pin. This mode works well but is more susceptible to noise.

Data communication takes place over the 1-Wire (OneWire) protocol, using the DQ pin. We'll discuss the protocol later, but now it's important to know that, despite having only one wire, it allows two-way communication.

The reading is performed actively, the microcontroller sends a command and receives back a packet with the information.

In addition to the reading request, the sensor can also receive alarm configuration and data format commands. The DallasTemperature library already handles most of this for us. Including offering us some additional features, such as receiving reading in Faraday.

The most common models on the market are found in the TO-92 package (looks like a transistor) and the waterproof package. This second is more common due to its practical application, 1m long cable with stainless steel tip. It can be used to control water temperature, for example. The reading is performed actively, the microcontroller sends a command and receives back a packet with the information.

In addition to the reading request, the sensor can also receive alarm configuration and data format commands. The DallasTemperature library already handles most of this for us. Including offering us some additional features, such as receiving reading in Faraday.

The most common models on the market are the TO-92 package (looks like a transistor) and the waterproof package. This second is more common due to its practical application, 1m long cable with stainless steel tip. It can be used to control water temperature, for example.

OneWire

OneWire (or 1-Wire) is a communication method designed by Dallas Semiconductor that transmits data using just one line, with a system of signaling who sends and when.

The method is very similar to i2C, but it has a much more limited data transfer speed. Another difference is that in the 1-wire case, it is possible to omit the power pin, using the data pin in parasite mode (by now, you may have noticed that despite the name, the method needs at least two wires: Data and GND).

Communication is done in master-slave mode, in which the microcontroller sends all requests, and the other devices only send data when nominally requested.

Each device has a unique address/name. This allows us to connect multiple devices on the same data line. The requests are sent in broadcast, the device that recognizes itself in it responds.

Circuit

The circuit for our application is simple. We will connect the VDD pin of the sensor to the 3V3 of the NodeMCU, GND with GND, and we will use the D4 pin for the sensor data. It could be any other digital pin.

Additionally, a 4k7 ohm resistor must be placed between the data pin and the 3V3 to increase stability.

Finding the DS18B20 address

As we saw earlier, each sensor has a unique address and, this address is essential for communication. We can understand this as a manufacturing serial number. But how to identify this number? We will create a helper code to find this address. In this case, the code scans any devices connected to pin D4. We will use the Serial Monitor to visualize the result.

We started with importing the OneWire and DallasTemperature libraries (do not forget to maintain order). If any import error occurs, you can add them to Arduino IDE's library manager.

Next, we start a OneWire object on pin D4 and create a sensor using that object. From that moment on, the “sensors” object has all the properties and functions offered by the DallasTemperature library.

And we will make use of two functions Search(), which performs a search for devices in OneWire, and reset_search() which restarts this search.

What our code does is start a search, save the result in the addr variable and, if the variable is not empty, write it in the serial.

We found the result on the Serial Monitor. If there are other devices, they will appear here too. Keep the address, we'll need it.

 

Sensor reading by Serial Monitor

Now that we know the sensor's address. Let's start our main code for reading the temperature. The objective here is to start the sensor and take a reading every 10s.

We started in the same way, but this time we created the sensor1 variable with the collected address.

In the readDs18b20() function we will use two functions:

• requestTemperatures() - This function does not specifically communicate with any sensors, but with all. It's like it says: If you're a ds18b20, run a new read now and wait for my ” And what the sensor does.
• getTempC(address) - Here we send information directed to each sensor of interest, which responds to us with the last reading

Inside the Setup() function we started the sensor with the begin() function, it performs a reading automatically, if you didn't make new requests, the sensor would still respond to the getTemp() function, but with an outdated value.

In the loop, we have a timer with the millis() function so that the reading takes place every 10s.

On the serial monitor, we should get the following result:

Note that on line 15, we added one more parameter to the Serial.println() function. With that, we define the number of decimal places.

Creating the monitoring page

With our reading ready, let's create a web page to view this information in the browser. Remember that later we will put these files in FLASH ESP8266 with SPIFFS.

We will build the following screen:

    And for this, we will use two files:

• index.html

• style.css

The page structure is not the focus of this article, but basically, we have the index.html file creating the page itself and triggering a javascript function to update the reading.

The style.css file improves the appearance of the page but does not interfere with its functioning.

Both files must be in the data folder within the project folder and be transferred using the ESP8266 Sketch Data Upload.

Complete Code

With the page saved to FLASH, we need to create the structure to serve the page.

• Connect on wifi
• Create a web server
• Create call-backs for requests to this

This step is nothing new for us, but it is worth noting a few points.

Now the readDs18b20() function also updates a variable of type String. We do this because server call-back functions do not accept integer or float variables.

For the server, we have three routes:

• “/” will send the html file with the latest sensor reading.
• “/styled.css” will send the css file
• “/state” will return the temperature variable to be updated.

• And now in Serial Monitor, we have the IP to access at http://yourIP.

Conclusion

The DS18B20 is an extremely efficient and easy-to-use sensor. The application we developed today could be used to monitor the ambient temperature, or perhaps the temperature of a water reservoir. And the ESP8266 extends the range of that monitoring as far as we want.

ESP8266 – Serial Communication

Today we will talk about an extremely powerful tool in the use of microcontrollers. The Serial communication, specifically the USART (Universal Synchronous Asynchronous Receiver Transmitter) standard. The system works using two wires. RX (Receiver) and TX (Transmitter), connecting two devices. The RX of one is connected to the TX of the other. If the choice is for a synchronous connection, it may be necessary to add one or two more pins to operate as a “traffic light”. But most current microcontrollers can operate asynchronously, which saves us the expense of pins. Data is sent, as the name implies, in a series of bits. ESP8266 provides us with two ports, one of them converted to USB in the NodeMCU module.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	ESP8266	Amazon	Buy Now

Applications

The range of uses of serial communication is limited only by creativity. Here I will mention three more general scenarios and detail some applications within them.

1. Communicating with computers

With a USB cable, we were able to connect the NodeMCU with a computer via Serial. Arduino IDE already gives us the first use. With Serial Monitor, we can send commands or debug the functioning of our code. But the integration with other software is pretty powerful. Imagine, for example, access control in which a circuit with ESP8266 reads an RFID card and sends it via Serial to a Permission Validation System. Or even an LED panel that receives a software display text.

2. Communicating with microcontrollers

Probably the most common application. Whether to integrate into a preexisting circuit or to distribute functionality between microcontrollers. This integration can be done between different microcontrollers. As long as they operate with the same voltage (3.3V) or use a level converter. An application example is to integrate the ESP8266 wifi with the analog ports of an ATMEGA328 to build an IoT toxic gas sensor. We already know that the ESP8266's analog port is quite inefficient. Then it is possible to perform the analog reading on the ATMEGA328 and send the information to ESP8266 by Serial.

3. Communicating with industrial machines

This, without a doubt, is the most interesting way to integrate industrial machinery with WEB systems. The older industrial equipment that allows some automation, provides RS232 or RS485 ports for integration with PLCs. In these cases, the commands are pretty plastered, but hopefully, well documented. The voltage level is 12V or 24V, but there are converters and logic levels to solve this. The industry 4.0 paradigm has been operating to make this kind of integration. Some PLCs are already developed with wifi modules. And on that account, circuits with the ESP8266 have the immense advantage of low cost. The vision behind this is to be able to remotely monitor or control an entire industrial plant. Tracking KPIs for predictive maintenance, doing recalibrations, and managing production.

Main Functions

The Serial library has a good variety of functions for Serial communication, but most are for very specific uses. We will discuss the most common ones and may return to others in the future as needed by the projects.

Serial.begin()

The first function to be used. It initializes Serial communication informing the data transfer speed (in bits per second) and, optionally, a configuration parameter. By default, Serial is configured to send data in 8-bit packets plus a terminator, not including parity. The best way to imagine this communication is to imagine a train, where each byte (8 bits) sent is a car, and the terminator is the connection between them. This standard is used in most devices, but if you need to integrate a device with another standard, the config parameter allows you to change the number of bits in the packet (from 5 to 8), the number of stop bits (1 or 2 ) and enable or disable parity (a packet integrity check). The speed uses some preset values. The fastest that remains stable for the ESP8266 is 115200 changes per second. So we could start with: Serial.begin(155200) The function below presents the same result, making the config parameter explicit. Serial.begin(115200, SERIAL_8N1)

Serial.available()

The function returns an integer with the number of bytes available in the read buffer. The maximum of bytes in the buffer is 64. This function is very useful for monitoring incoming information. Value = Serial.available()

Serial.read()

The function returns the most recent byte in the input buffer and removes it from the buffer. It is ideal if your communication is byte-to-byte. For example, if you are receiving input from a keyboard, the function would return the key you typed. It returns an integer with byte or -1 if no data is available.

Serail.readString()

This function is best suited for reading strings. Like words. It is the equivalent of calling the read() function continuously until it reads all the information from the buffer. The function returns a string with the data.

Serial.print() and Serial.println()

The two functions are very similar. It takes a value and sends it serially in ASCII format. It is also possible to define the numerical base before sending (binary, decimal...) and the number of decimal places. The function can be used either in the format: Serial.print(value) And the format: Serial.print(value, format) The table below presents some usage examples. The println function works pretty much the same, but it adds the return character ‘\r’ and newline ‘n’ at the end of the packet. It's the equivalent of typing in a text editor and pressing the "Enter" key.

Serial Monitor

The Arduino IDE provides a very powerful tool for debugging and testing Serial communication. The Serial Monitor. The tool is pretty intuitive, but let's take a look at its fields.

• Sending data: This allows us to send commands directly to the microcontroller
• Autoscroll: Very useful when we've already received enough information to fill the screen

and don't want to move it down manually.

• Terminator: Choose whether or not to include the new line and carry return characters at the end of the message before
• BaudRate: Defines the communication It must be the same as the microcontroller, or

packet loss or character misreading problems will occur.

Controlling and monitoring an LED

Let's make a simple code to control and monitor the NodeMCU LED from the Serial monitor. The code will monitor the Serial, and each time it receives the command “ON”, it will turn on the LED, when it receives “OFF”, it will turn off the LED when it receives “STATUS”, it will return the status of the LED in the Serial. We will create three functions to perform the actions.

• turnOn() : To turn on the
• turnOff() : To turn off the
• statusLED() : To read the pin status and return information in the serial.

We initialize the Serial in the Setup function. In the loop() function, we check if there is any data in the input buffer of the serial, if there is, it saves the buffer values in the variable “payload”. Finally, we check the payload value to decide the action. Here it is important to note that we use an equality comparison and that “ON” is different from “ON “. For this reason, when sending the information through the Serial Monitor, we choose the “No line ending” option. And so is our final code. Compiled, written to nodeMCU. Open the Serial Monitor, remember to put the correct baud rate and the "No Line ending" and send one of our 3 commands. This is simple code, but very powerful. So, that was all for today. I hope you have enjoyed today's tutorial. If you have any questions, please ask in the comments. Thanks for reading.

ESP8266 – Knowing the NodeMCU GPIOs or Pinout

Where To Buy?
No.	Components	Distributor	Link To Buy
1	ESP8266	Amazon	Buy Now

Introduction

When the subject is ESP8266, it is normal that our attention is on the Wifi module. We've already discussed some applications in previous articles, and there's still a lot of cool stuff to see in the future. We've looked at how the ESP8266 communicates with the world via wifi, and now we'll look at how it does it through its pins.

We will make a decision here. The ESP8266 is found in several modules. Each module with its pin provision. ESP-12 modules provide the most features. To make better use of these features and have a more protoboard-friendly module at hand, we will analyze the NodeMCU module with the ESP-12E.

Overview and Electrical Data

The NodeMCU pins are available in two rows with a spacing that allows them to fit on a breadboard (in particular, I find the pins a little thicker than they should be, and I think if they had more length and less width, it would be even more efficient).

• The NodeMCU interferes just a little with ESP-12 pins. It does an untreated exposure of each of them.

It is interesting to see what NodeMCU adds or changes to the ESP-12.

Power Source

ESP8266 operates on 3.3V, ESP-12 exposes the VDC pin for direct power. The NodeMCU incorporates a voltage regulator (usually the AMS1117) that can receive a 5V to 10V input and deliver a stable 3.3V supply to the ESP-12.

But what advantage does this give us? nodeMCU is a development module. Choosing pins that fit the breadboard shows us this. Being able to receive 5V greatly increases the practicality of the power supply. 5V is the standard used on USB, so even a cell phone charger can keep everything running.

The power can be supplied directly via the USB connector (standard USB = 5V) or the Vin pin (5V to 10V). The regulator provides a maximum of 500mA.

The pins involved in the power are:

• Vin: Positive voltage Operates with voltages from 5V to 10V.
• GND (G): Reference voltage for voltage input and
• 3V (3V): Output voltage with a value of 3.3V
• VU: On some models, this pin is not connected to But Lolin's V3 model provides a 5V output provided directly by USB.

Some important considerations to keep in mind:

• The 3V3 regulator provides a maximum of So be careful what you feed the 3V3 pins.
• The Module can be powered by either USB or Vin But it is not recommended that it occur for both at the same time.

Serial – USB Adapter

The ESP-12 provides us with two UARTs, with UART0 (pins RXD0 and TXD0) being used in programming. The NodeMCU Module integrates a Serial-USB converter that greatly facilitates our work.

The USB connector can be used for power and data communication via Serial. For this reason, it is a sufficient condition for recording the ESP8266.

A point of attention here: The RXD0 and TXD0 pins are available as GPIO pins (respectively GPIO3 and GPIO1). But they need to be used very carefully. Enabling these pins as GPIO disables USB.

Digital Pins (GPIO)

Digital pins or GPIO (General Purpose Input Output) are pins intended for binary control. It can have a HIGH or LOW state and can operate both, as an input (for reading digital states) and as a digital control (turning on LEDs, for example).

If you take a look at the nodeMCU image, you will notice that it talks about 13 GPIOs (From GPIO0 to GPIO15). So we have 13 pins for input and output control? Not exactly.

Most microcontroller pins have more than one function, this function is defined through registers. In the case of NodeMCU, some GPIOs are already in use. And if we configure it as a digital pin, we lose some functionality.

Let's look at it on a case-by-case basis:

• GPIO4 and GPIO5: Starting with the easiest. These two have only the GPIO function. It can operate as Input or Output.
• GPIO0 and GPIO2: These pins play a very specific role in the ESP8266 startup. For that reason, they can only operate as
• GPIO1 and GPIO3: As we have seen, these pins are used by USB so they are not recommended for use as GPIO in
• GPIO9 and GPIO10: ESP8266 uses an external FLASH memory chip and communicates with it with a 4-bit SDIO interface. These two pins are on the list. By default, both are used in this But it is possible to set it to 2-bit mode and release these two pins. You gain in the number of pins, but you lose in memory access speed.
• GPIO12, GPIO13, GPIO14, GPIO15: These pins can be used in other modes, but by default, they are free GPIOs for use as Input or

Ah, an important point to mention: ESP's GPIOs operate at 3.3V.

Analog Pinout

The Esp8266 only provides one analog input (ADC0 pin), and that's probably its biggest weakness.

Although the module operates with 3.3V, the analog input operates from 0 to 1V. Which significantly limits the resolution.

Main functions for GPIO in the Arduino IDE

To control the GPIOs, the Arduino IDE provides us with some functions. Among the main ones, times:

pinMode(pin, mode)

pinMode() defines the mode in which the pin will act. The possible modes are:

• INPUT: The pin will be configured as a digital input
• OUTPUT: The pin will be configured as digital output
• INPUT_PULLUP: The pin will be configured as a digital input with a pull-up Here I leave a study recommendation for pull-up and pull-down circuits but simply put. It forces a value when nothing is connected to the pin. If it's a pull-up, it's HIGH, and if it's pull-down, it's LOW.

As an example, if we want to use gpio4 as an output, we will have:

pinMode(4, OUTPUT)

digitalWrite(pin, value)

The digitalWrite() function changes the value of the informed pin. Possible values are: HIGH or LOW.

As an example, if we want to change the value of gpio4 to HIGH, we will have:

digitalWrite(4, HIGH);

One point we need to note is that there is an expected logical sequence to control the pin. First, we define it as OUTPUT and only then send a command to change the state. But what happens if we forget to use pinMode or set it to INPUT?

For these cases, the digitalWrite() command automatically enables the INPUT_PULLUP mode. This procedure protects the microcontroller from short circuits.

digitalRead(pin)

The function reads the digital value of the selected pin, returning the HIGH or LOW value. As an example, to read the status of gpio4, we will have:

value = digitalRead(4)

Of course, the value variable needs to be declared before it can be used. And if the pin is not connected to anything, the value will vary randomly (unless pullup is enabled).

analogRead(pin)

This function reads the analog pin. Or almost. The function returns a value between 0 and 1023, with 0 being the equivalent of the GND voltage and 1023 being the value referring to the VCC.

As an example, to read the status of adc0, we will have:

value = digitalRead(A0)

Constants

There are some predefined constants to refer to the pins more practically. When using either function, you can use either the gpio number or the related constant.

Differences in other modules

Here we look at the pin arrangement of the nodeMCU Lolin V3 board. There are slight differences on other cards. In Lolin itself there are versions with the ESP-12E module and others with ESP-12F. In this case of Lolin, the most significant difference is a change of position between GPIOs 4 and 5.

ESP8266 Operational WiFi Modes

In previous articles, we connected the ESP8266 to a pre-existing WIFI network. It is the commonly used method in projects, especially when there is interest in internet access.

For these cases, the ESP8266 operates as a “station” on the network. But we can find scenarios where there is no WIFI network to connect. Can we still use the ESP8266 in these cases? Yes, we can!

Where To Buy?
No.	Components	Distributor	Link To Buy
1	ESP8266	Amazon	Buy Now

ESP8266 Operational Modes

The ESP8266 WiFi module can operate in 2 different modes:

• STA (the module operates as a station and is available to connect to an Access Point).
• AP (the module creates a network with customizable SSID and Password. We will discuss how each mode works, its limitations, and how to use

STA Mode

We use the STA mode to connect the ESP8266 to a pre-existing Wi-Fi network. This connection is made from an Access Point, which will be responsible for managing information traffic.

For configuration and use on the Arduino platform, we use the ESP8266WiFi.h library. Simple to use and extremely powerful, this library offers us all the tools to configure the WiFi module, without overloading us with flags and registers.

For our configuration, there are two more relevant functions, begin() and config().

begin() function

The begin() function needs some parameters necessarily and others optionally. This is because this function is of type overload, which provides more flexibility when calling the function. For a better example, let's look at the begin() function in its full form and its minimal form:

• Complete form: begin(ssid, password, channel, bssid, connect)
• Minimum Form: begin(ssid, password)

Same function, two ways to call it. And both works. This is because it was built with more than one declaration format in the library.

Let's take a look at the parameters it accepts:

• SSID: The name of the network we want to connect to. Required field, and can contain up to 32
• password: password for the chosen Required field, must be between 8 and 64 characters.
• channel: Defines the bandwidth to be This parameter is optional and can be useful in areas with many different networks. Choosing a good channel can minimize interference and increase network range. If omitted, it will be selected automatically.
• bssid: One more optional parameter. If set to true, the function will return the MAC of the AP it was connected
• Connect: A Boolean parameter which, if set to false, will save the parameters defined in the function, but will not connect to the

This information will be saved in a reserved area of FLASH and in case of loss of connection, the attempt to reconnect will occur automatically.

Another important point is that, by default, the station is configured as a DHCP (Dynamic Host Configuration Protocol) client. This means that when connecting, the ESP8266 will ask the Access Point for an IP address. If the AP has DHCP enabled, we will receive a random IP within the network range configured there.

Config() function

The config() function is not mandatory for a connection such as a station. But you will need it if you want to connect to the network with a fixed IP address. The function has the following format:

• config(local_ip, gateway, subnet, dns1, dns2) Where the parameters represent:
• local_ip: IP address we want to assign to the
• gateway: Access Point IP address.
• Subnet: IP mask of the network where we will
• dns1 and dn2: optional fields for IP address of DNS servers (Domain Name Server).

When we call the config() function, the DHCP mode is automatically disabled. Then the station will force the use of the address we choose. This method is useful when connecting over a network that does not have a DHCP server, or when having a fixed address is an essential project requirement.

You need to be careful when choosing the IP address and the subnet, as if it's incompatible with the network configuration, we will connect, but we won't be able to interact with anything.

In the image, we have a code for configuration and connection as a station.

Access Point Mode (AP)

In AP mode, the ESP8266 creates its WiFi network, allowing stations to connect to it. The figure below should help you better understand how it works. The ESP8266 configured as AP, replaces the role of the router in the network (with some limitations, but the principle is the same).

Strictly speaking, the name of this mode is Soft Access Point, because the functionality as an AP does not use any hardware resources equivalent to that of a common AP. It's like a Virtual AP. This does not impact health, but it does severely impact performance.

The main limitation is the number of connections it can manage. Although the manufacturer suggests up to 8 stations connected, you will have serious problems if you go beyond 5. If your application has a heavy data flow, I recommend that you limit it to 4 connections.

Another limitation is that the created network is not connected to the internet. So keep in mind that this is a model for applications that work well on local networks and for a few devices.

An example application for this format is an access control system. Approach with your cell phone, connect to the ESP8266 network, and be authorized to open a door.

Setting up this mode is very similar to that of a station. We have an overload function for begin and another one for configuration.

softAP() function

It would be the equivalent of our station mode begin() function.

• softAP(ssid): to create an open network, without a password.
• softAP(ssid, password, channel, hidden, max_connection): to create a protected network.

Let's take one for each parameter:

• SSID: The name of our network, can contain a maximum of 63 This is the only mandatory field in the role and cannot be empty.
• password: This field contains the password that the station needs to enter to connect. If not informed, the network will be open and can be accessed without any security. If you include one, it must contain a minimum of 8 characters, following the WPA2-PSK network security standard.
• Channel: As we discussed for the station, this field defines the wifi operation It must receive a numeric value from 1 to 13. If not informed, it will receive 1 as the default value.
• Hidden: If set to true, the SSID will be invisible and cannot be detected by identifiers (in your mobile's WiFi network list, for example. The network can still be connected if the station writes
• Max_connection: Defines the maximum number of stations allowed. Receives values from 0 to 8, with 4 as the default.

softAPConfig() Function

This function sets some parameters referring to IP addresses. It has the format: WiFi.softAPConfig(local_ip, gateway, subnet)

Where the parameters represent:

• Local_ip: IP address of the access point
• Gateway: IP address of the gateway (this is what stations will use as a switch)
• Subnet: Defines the IP range to be

With the code, you will configure a simple access point visible to your cell phone or computer.

STA + AP Mode

As the name suggests, the esp8266 will operate both as a station (being able to connect to a network) and as an Access Point (allowing stations to connect to it) at the same time.

The purpose behind this method is to use esp8266 in mesh network configurations. The idea is interesting, but if the performance is not already excellent operating as AP, imagine as AP and STA.

The documentation for this format is very scarce and, in a way, abandoned by the manufacturer itself. Espressif, when launching the successor of ESP8266, ESP32, included a specific library for MESH.

Create Webserver with ESP8266 using SPIFFS

Hello friends, I hope you all are doing great. In today's tutorial, we will have a look at How to Create Web Server with ESP8266 using SPIFFS.

We've already seen how to create a web server and how to provide an HTML page on our ESP8266. We use the PROGMEM command to store an HTML code in FLASH memory. For a simple page, this works fine, but what if we have a more complex webpage? With a better style? What if we want to include images?

Today we will learn how to use SPIFFS with ESP8266 to store files (regardless of type) in FLASH memory.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	ESP8266	Amazon	Buy Now

What is SPIFFS?

• SPIFFS (SPI Flash File System) is a system designed for managing SPI flash memory in embedded devices. Its main goal is to use minimal RAM to access files. It's very useful when using pen drives, memory cards, and the ESP8266's flash memory.
• SPIFFS allows you to access files (create, read, write, delete) just like on a computer. But with a much simpler folder structure.
• To show how the tool works, we will create a web server with a styled page and an image. Then when accessing the webserver, the browser will receive the HTML file, the CSS file, and the images.

Create Webserver with ESP8266 using SPIFFS

• For that, we will need two things:
  • Library to manage SPIFFS.
  • Tool to load the files in FLASH.
• The upload tool is a plugin called ESP8266fs that integrates python into the Arduino IDE.
• Download the ESP8266FS-0,5.0.zip file from Github and unzip the files into Arduino's tools folder ( Possibly C:\program files x86\arduino \tools).
• Restart Arduino IDE and the tool should appear available as shown in the image.

• Now let's take a look at how it works.
• Your sketch will always be saved inside a folder. The Arduino IDE cannot open an .INO file if it is not inside a folder with the same name.
• Our upload tool will look inside that folder and look for another folder called “data”. Everything inside that folder will be transferred to the ESP8266's FLASH memory.

Our page will have 3 main objects:

• An image that will change depending on the status of the LED.
• A text with the status of the LED.
• A button to change the status of the LED.

Files on Webserver

And to build this page we will use 4 files:

• html, which will contain the page itself.
• css, containing the styling to make the page more beautiful.
• Image of the lamp
• Image of the lamp

• The two images were chosen from the pixabay repository. You can use another one. But I recommend not using very large files as it takes a little longer to load. I also recommend using some service to resize the image, such as tinypng.
• In our index.html file, we will have:

• In our style.css file, we will have:

Understanding ESP8266 Webserver Code

• Created and saved, we used ESP8266 Sketch Data Upload to load the file into FLASH memory.
• Before we look at the code, it's important to understand how the browser behaves when accessing a page.
• When accessing the web server address, the browser sends an HTTP GET command in the path “/” and waits for an index file in response.
• Inside index file it can be informed that it needs other files. What happens in our code.
• In line 7 of the index.html file, it is informed that the style.css file will also be needed and that it is of type text/css.
• Then the browser sends another HTTP GET command with the path “/style.css” and expects to receive a file with that name.
• In line 13, the <img> tag informs the path to an image, and the browser sends another HTTP GET command to the address “/bulb-off.png”, this time the browser expects an image file.
• The browser will send GET commands each time we click the Toggle button (“/toggle” path) and every 1 second to receive an updated status (“/state” path).
• Doing yet another GET to the lit lamp image (path: “/bulb-on.png”).

So we will need to handle it in our .INO code the GET requests in the paths:

• “/”
• “/style.css”
• “/bulb-off.png”
• “/bulb-on.png”
• “/toggle”
• “/state”

Our style.css file sets sizes, alignments, and colors for components. We start our .INO file by importing four libraries:

• h – That will take care of our WiFi connection.
• h and ESPAsyncWebServer.h – Which will manage the webserver (including HTTP GET commands).
• h – File System Library that will take care of our SPIFFS.

We define the pin for our LED. We create variables with SSID and password of the wifi network where we will connect. We created our server on port 80 and a variable to monitor the LED status.

• The wifiConnect() function will connect the ESP8266 to the chosen wifi network by printing the IP address on the serial monitor.
• Pay attention to this number. You will need to access the webserver from the browser.

• The processor() function is responsible for updating the variable with the status of the LED.
• We will use it in handling our GETs.

• The toggleLed() function toggles the LED state. We will use it in the GET “/toggle”.

• And finally, our setup() function. We start by setting our LED to OUTPUT (otherwise, our toggle won't work.
• Next, we start Serial with a baud rate of 115200 to view the IP address on the Serial Monitor.
• With SPIFFS.begin(), we initialize our filesystem in flash memory.
• If an error occurs, our code stops here and reports on Serial Monitor. In that case, upload the files again.
• And finally, we've included our GETs.

The “server.on” structure is an event manager provided by the ESPAsyncWebServer.h library. In short, we inform a route, a method (HTTP-GET, for our case), and action when receiving the request. But we need to take a closer look at some variations of the function.

• The server receives a request for the “/” route with the HTTP GET method.
• In request->send, we inform that the response is a SPIFFS file with the name index.html and that it will be sent in string format.
• The last two fields (“false” and “processor”) inform that the index.html file is a template that depends on more information. This information will be provided by the processor() function.

It is necessary to send the index file with the updated LED state value.

For style files and images, we use a similar principle, but these files are not being changed before they are uploaded. So we only inform the origin, name, and type (if you want to know a little more about file types in HTTP, I recommend a study on MIME TYPES. Any type of file can be sent, but MIME standardizes what browsers can understand).

Lastly, we have the “/state” returning the stateValue variable on each update and the “/toggle” which changes the state before sending the same variable. The response format has a small change. As we are sending only one variable, we inform the MIME TYPE “text/plain”, the response code 200 (default for success over HTTP), and the variable converted to a string.

Results

• With the code compiled and recorded, check the IP of the webserver in the Serial Monitor and access it in the browser.
• Example: for IP: 10.10.10.11 access: http://10.10.10.11.
• Attention: As we use port 80 on the web server, we use HTTP and not HTTPS. The result on the screen should look like the images below:

So that was all for today. I hope you have enjoyed today's lecture because it will improve the presentation of your project. If you got any queries, ask in the comments. Thanks for reading!!!

Create Web Server with ESP8266

Hello friends, I hope you all are doing great. Today, we will create a web server with ESP8266 microcontroller to control the activation of an LED. The goal is to understand how the ESP8266 connects to a WiFi network, how it sets up a web server, and how it is possible to exchange information between the browser and the esp8266.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	ESP8266	Amazon	Buy Now

Components Required

• 1x Computer/notebook with Arduino
• 1x Mini-USB cable.
• 1x NodeMCU (ESP8266 Breakout Board)
• Internet Browser (Chrome, Firefox, IE…)

ESP8266 Libraries for Arduino IDE

For this project, we will use two libraries:

• ESP8266WiFi: This library carries all the functions necessary for the ESP8266 to connect to a wifi network.
• ESPAsyncWebServer: This library carries the functions needed to create and manage an EB server.

Creating the code

• We can divide the code into three main functionalities:
  1. Control the LED.
  2. Connect to Wifi
  3. Create the webserver.

And we'll treat this building in blocks.

Importing Libraries

• The Libraries must be included at the beginning of the sketch so that their functions are already available elsewhere in the code.

LED Control with ESP8266

• Our first step is to define the pin to be used. For our example, we will use the LED of the NodeMCU module.

• And set this pin as output in the setup function.

• We will also create a variable to monitor LED status. This variable is not used to control the LED, but it will be important for the webserver so, we will include it here.

• So, we'll create a function that, whenever triggered, will change the state of the LED (and the variable).

• The toggleLed() function makes a function nesting in its first line:
• The digitalWrite() function receives as a value for writing, the inverse of the reading of the pin itself. So each time the function is called, it reads the current value of the pin and toggles its value.
• The following conditional is only used to update the stateValue variable. To test the function, you can include it in the loop as follows:
• With these inclusions, we will have this code:

• With this code, the NodeMCU module LED, we expect to change state every 3 seconds. Remember to remove the data inside the loop function when you finish the test. We will not use them in the next steps.

Connect ESP8266 to WIFI

• Now let's connect the ESP8266 to your WIFI network. We'll start by creating a variable to store the network name and another one for the password.

• The connection could be executed directly in the setup function, but we will create a standalone function to make the code more organized and so that it can be reused if you want to create a reconnect function.

The wifiConnect() function will send a connection request and wait for it to be approved.

With Wifi.begin(), ESP8266 will search the network informed in the ssid variable and send a connection request, informing the password (just like what a cell phone would do).

The WiFi.status() function can return the following values:

• WL_CONNECTED: assigned when connected to a WiFi network;
• WL_NO_SHIELD: assigned when no WiFi shield is present;
• WL_IDLE_STATUS: it is a temporary status assigned when WiFi.begin() is called and remains active until the number of attempts expires (resulting in WL_CONNECT_FAILED) or a connection is established (resulting in WL_CONNECTED);
• WL_NO_SSID_AVAIL: assigned when no SSID are available;
• WL_SCAN_COMPLETED: assigned when the scan networks is completed;
• WL_CONNECT_FAILED: assigned when the connection fails for all the attempts;
• WL_CONNECTION_LOST: assigned when the connection is lost;
• WL_DISCONNECTED: assigned when disconnected from a network;

In this project, we are not handling connection failures, so we are only interested in the WL_CONNECTED return. The function will wait while this is not the connection status and, when identifying it, it will look for the IP address it received on the network.

Here is a point of attention. The WIFI network must allow the connection and provide an IP by DHCP. If any device can connect to your network just by offering the password, don't worry. This configuration must already exist.

We've added some information to be viewed on the Serial monitor, so the serial needs to be initialized before we call the wifiConnect() function.

• This should be our code so far:

• The expected result on the Serial Monitor is as follows:

• From this point on, the ESP8266 can be found by network tools like the Advanced IP Scanner or a simple PING at the command prompt.

Creating the Webserver with ESP8266

• Spoiler Alert: At the end of this step, you can view our webserver at the address
• HTTP://”IP address”, for our case http://192.168.18.76.
• We will start by creating an instance of AsyncWebServer operating on port 80.

• In short, a webserver operates as a file manager that delivers on-demand. Then the browser makes a request, the web server responds and continues to wait for new requests.
• All this happens following communication protocols (HTTP, FTTP, or both), rigorous error handling, and high-security logic.
• The library takes care of preparing the backstage of the webserver, which saves us a lot of time and lines of code. But we still need to configure what happens on each request.

We will handle two requests:

• When the page starts or refreshes
• When we press the LED state change

The first will occur when we send a GET request to the root “/”. What the browser does automatically when we go to http://192.168.18.76.

• The server will respond with status 200 (default success response), the information on the type of file sent ("text/html"), the HTML file (which we will create next and save in the variable index_html), and the return of the processor( ) (which we will also create now).
• The processor function simply returns the value of the updated stateValue variable.

• The HTML file the browser expects tends to be large for a variable, and even with the good SRAM memory space the ESP8266 has, it could cause problems.
• That's why we'll use the PROGMEM utility so that the variable is written to FLASH memory.

 

• Don't worry if you don't know HTML or javascript. We won't go into details, but we'll explain the most important ones for now.
• On line 23, the page displays the value returned by the processor() function.
• In line 24, the button calls the “toggleLED()” function when activated.
• The toggleLED() function makes a GET request at address “/state” passing the toggle valceue.

• After 1 second it refreshes the page to receive the updated value. We need to handle this request:
• When the server receives the request at the address “/state” it calls the toggleLed() function
• and just replies to the server that everything went fine. And last but not least: We started the server:

• This will be our final code:

• In our browser:

Conclusion

In this project, we saw a very simple application of the power that the ESP8266 WiFi has. In the HTML file, page styling could also be included to make the page prettier.

And with that base, it's possible to expand into several cool projects. A temperature monitor via Wifi? Security systems? Home automation systems? These are just a few examples. The limit is up to your creativity.

ESP8266 based WiFi Modules for IoT Projects

The Internet of Things (IoT) and the Industry 4.0. Distinct technological revolutions but with a common goal: To integrate equipment (digital or analog) to a computer network.

And to be part of this revolution, the developer goes out of its way to include wired ethernet modules or WIFI modules in its circuits. Which increases complexity, circuit size and development cost.

What if I told you that already has a built-in WIFI microcontroller? And that it fits in the palm of your hand? For just 1 US dollar?

Today I’m going to introduce you to the ESP8266 microcontroller, from Espressif. And for those of you who already program in 8Bit microcontrollers like the Atmega328 (one of the most common on Arduino) and struggle to build your code in the modic SRAM’s 2KB and Flash memory’s 32KB… The ESP8266 offers 32KB to RAM and 512KB to Flash Memory … expandable up to 4MB.

 Did I get your attention? So, let’s go to a summary of the specs, provided by the manufacturer itself:

• 32-bit RISC architecture;
• 80MHz processor (can be expanded up to 160MHz);
• Operating Voltage of 3V;
• 32KB of RAM memory for instructions;
• 96KB of RAM memory for data;
• 64KB of ROM memory to boot;
• Flash memory preview by SPI (512KB to 4MB);
• Wireless 11 b/g/n standard;
• Operating modes: STA/AP/STA+AP;
• WEP, WPA, TKIP, AES security;
• Built-in TCP/IP protocol;
• QFN encapsulation with 32 pins;
• Main Peripherals: UART, GPIO, I2C, I2S, SDIO, PWM, ADC and SPI;
• Architecture with prediction of operation in energy saving

At this point you may have noticed that I stated that the ESP8266 has a 512KB Flash memory, extendable up to 4MB, but then I said that the module only provides this memory per SPI. Before explaining this, I want to draw your attention to another important point: The ESP8266 has a WIFI module inside a QFN package. WIFI is radio frequency! And how does it work without an antenna? The answer is: It doesn’t work!

The ESP8266Ex chip (this is its full name) needs an antenna to be connected to your antenna’s specific pins as well as a FLASH memory IC.

Started to get complicated? Don’t worry. With the idea of making the chip more accessible, several modules were developed that already include an antenna and a memory chip.

Understanding the need to include an antenna for the WIFI, a memory IC in the SPI and making pins more accessible, several manufacturers started working on ore “friendly” ESP8266’s versions. Among the best known are the ESP-01, ESP-03, ESP-05, ESP-07, ESP-12E, ESP-12F and NodeMCU. All of them have the esp8266 microcontroller in common, but they vary in size, antenna availability, memory size and pin availability. There are others, but today we’ll talk a little about them.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	ESP8266	Amazon	Buy Now

ESP-01

It is the most common module in the ESP8266 range. It is compact (24.8 x 14.3 mm), the WIFI antenna is built in the board itself and has two GPIO pins that can be controlled according to programming. There are two significant drawbacks to this card:

• The pins are not intended for connection to a breadboard. Although they fit well, they end up shorting So, they necessarily need wires to extend the pins.
• The two available GPIOs play an important role in the board So it is necessary to pay attention to the level (high/low) when the board is initialized, or the board may mistakenly enter in programming mode. So, pins are safer operating as Outputs than as Inputs.

ESP-03

 

This version comes with a ceramic antenna, 7 GPIOs (two are those of the ESP-01 that require attention), a pair for UART, in size 17.4 x 12.2 mm. Smaller than 01? Yes! But that comes at a price: The encapsulation is another.

ESP-05

• No GPIOs available, it actually doesn’t even have a built-in antenna.
• This version was thought to incorporate WIFI to some other microcontroller (with the smallest possible size: 14.2 x 14.2 mm), so it has an external connector and UART pins to be manipulated by AT commands.

ESP-07

• The ESP-07 has both a ceramic antenna and an external connector. Looks a lot like the ESP-03, but leaves the meager analog pin available.
• In addition to incorporating a metallic cover that protects the circuit against magnetic interference.

ESP-12E and ESP-12F

Built-in antenna, 11 GPIOs, UART available, SPI available (not exactly, it’s still being used by the flash memory CI, but now you get the option to disable the memory and associate a larger one), an ADC pin (pause here to explain because it’s not that useful, The board operates with 3.3V, but the ADC is 0 – 1V. Low resolution, plus the big risk of damaging everything.).

The ESP-12E would be icing on the cake for the ESP8266’s boards, but the ESP-12F version handled an improvement in the antenna design and a little more pin protection.

NodeMCU

The NodeMCU module is to the ESP-12s as the Arduino UNO is to ATMEGA328s. A board with a protoboard compatible pinbus, all ESP-12 pins available, a 3.3V regulator to power the module (the VIN pin can receive 5V) and a UART – USB interface that turn the nodeMCU into a plug an play module.

There are versions with the ESP-12E (increasingly rare) and with the ESP-12F.

Now that we know a little more about the hardware, let’s take a look at how to program it.

There are different ways to programming the ESP8266. Different methods, different languages, among the most common, we have the ESP-IDF (manufacturer’s official. C programming) and others recommended, also, by the manufacturer: NodeMCU (Lua Script), Arduino (C++), MicroPython (you get one candy if you guess the language). It is possible to work with it in PlatformIO as well.

ESP-IDF

The ESP-IDF is the official Espressif solution. The SDK has a number of precompiled libraries and works with the Xtensa GCC compiler.

For a long time, the company has released RTOS and NON-OS versions in parallel. But since 2020 no NON-OS versions have been released (except minor bug fixes). Other modules from Espressif were born exclusive to RTOS versions, probably this was already part of the decision to bury the NON-OS. IN 2019, the company released a note stating that it would keep the main version, but that it would only operate in the correction of critical bugs. It even released some new features after that, but it doesn’t compare in quantity to the RTOS version.

This is without any doubt the most specialized tool that allows for the greatest customization at a low level. Drivers and libraries are customized for company modules. And specialization directly reflects on performance.

But the ESP-IDF lacks in complexity and size of the active community. Which ends up making the solution’s development a little slower. How does this happen? The programming is done in C- ANSI, in some cases with the directly treatment of registers, creating a more verbose code. More verbose? More chances for bugs. Also, active community is something that needs to be looked at when using any technology. Whether for creating new libraries or for sharing issues and solutions. The ESP-IDF user community exists, but it is much smaller than the others that will be presented here.

NodeMCU

The NodeMCU is an ambiguous term, it can either be used to indicate the NodeMCU module (hardware) or the NodeMCU development environment (software), both can be used together. But not necessarily. Let’s go to the software one.

The NodeMCU is a Lua-based firmware specific to the ESP8266 and uses a SPIFF (SPI Flash File System) based file system. This firmware is installed directly in FLASH memory, which allows the code’s execution in real time, without the need for compilation.

It offers a library structure for native functionality and for sensor’s integration, such DS18B20 or BME280, which make programming more dynamic.

The NodeMCU has been popular for quite some time. But it has three serious problems that have started to reduce its use.

• The Firmware NodeMCU, installed in FLASH, takes up a lot of Especially if the full version is included.
• It was developed based on the NON-OS version, so, firmware bugs started to get more complex to
• The memory management is quite complex in some cases. Because it didn’t compile, some memory overflow issues could only be noticed at runtime. (This was the reason I stopped using this method).

Arduino

The Arduino platform, undoubtedly the best known in the world when it comes to microcontrollers, is also on the manufacturer’s list of nominees.

The Arduino was built as software-hardware relationship that makes microcontroller’s development more accessible to non-specialists. The hardware complexity was minimal (in some cases none) and the software started to be treated in a high-level language (C++), allowing even object orientation.

Because it is so accessible, some members of the software’s community have started to be collaborators in building libraries (Only to control LCD displays, I know four), some sensor’s manufacturers offer official versions as well. Constantly updated material. Etc. Etc.

The Arduino architecture started with the Arduino Uno board (which uses an ATMEGA328), expanded support to other boards and… for some time now, it has support for ESP8266 in different modalities. There is good compatibility with standard Arduino libraries and it has its own.

MicroPython

I Don’t know the MicroPython in practice (yet), but as the name advertises, it allows programming in Python. Like NodeMcu, it deploys a firmware to FLASH memory and has well- defined libraries for hardware usage.

The space occupied in Flash is well optimized (not even compared to NodeMCU chaos). It seams to have a very active community. As for programming complexity I don’t have much information. But if you program in Python, I think it’s worth the experience.

PlatformIO

The PlatformIO is not really a development platform, but it allows an integration with other platforms to simulate the board. If you don’t have an ESP8266 on dang yet, it might be a good choice for your first steps.

However, there is a natural limitation when simulating a module whose flagship is WIFI.

Don’t you know where to start?

Personally, I think that the Arduino environment is perfect for prototyping. It’s easy to get results pretty quickly to validate a proof of concept. But in some cases you can go beyond that. If your project doesn’t demand maximum performance from the ESP8266, even the production version can be built here.

For a project that requires a lot of hardware precision, I don’t recommend intermediaries. Nothing will perform better than IDF.

For educational purposes, our next articles will use the NodeMCU board programmed on the Arduino platform.