Introduction to STM32 Family

In this guide, we will explain step by step to start programming on the STMicroelectronics (STM) platform, especially the STM32 family.

The term, "STM32" refers to a family of 32-bit microcontroller integrated circuits based on the ARM® Cortex®M processor. The architecture of these CPUs (Central Processing Unit) is ARM (Advanced Risk Machine) which is a particular family of Reduced Instruction Set Computing (RISC). RISC architecture differs from Complex Instruction Set Computing (CISC) for its simplicity that allows you to create processors capable of executing instruction sets with shorter times. Why use STM32? The advantages are many, and now we will list a part of them:

1. ST offers a wide portfolio of solutions depending on the developer's needs. We can find products that combine different advanced features while maintaining a high level of integration. In fact, we can choose products with high performance, real-time processing, digital signal processing, and low consumption.
2. Thanks to the availability of different development tools and available support material, the development of a simple or complex project is quite simple and fast, reducing the time to market if you want to develop a product.
3. Each microcontroller has an integrated processor core, static RAM, flash memory, debug interface, and various peripherals such as GPIO, ADC, DAC, Timer, SPI, UART-USART, I2C, etc.
4. For every MCU, ST provides the STM32 Nucleo Board that helps anyone who wants to fastly build and test prototypes for new projects with any STM32 MCU. STM32 Nucleo boards share the same connectors and can be easily expanded with many specialized application hardware add-ons (Nucleo-64 includes ST Morpho and Arduino Uno Rev3 connectors, while Nucleo-32 includes Arduino Nano connectors). Another and not insignificant advantage is the cheap cost of these development boards.

In the next paragraph, it will be illustrated how the STM32 is divided to easily identify the one used for your purposes.

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

STM32 Family

• To date, the STM32 family has 16 series of microcontrollers divided into four groups in order to cover all the needs of developers.
• The four groups are Mainstream, Ultra-Low-Power, High-Performance Wireless.

STM32 Mainstream

The STM32 Mainstream has been designed to offer solutions for a wide range of applications where costs, time to market, reliability, and availability are fundamental requirements. They are widely used in real-time control signal processing applications.

There are 5 series in this group:

1. STM32F1 are microcontrollers based on the ARM Cortex-M3 core. It was launched in 2007 and evolved over time in terms of maximum clock rate, memory depth, and peripherals. In fact, the maximum clock rate has gone from 24 MHz to 72 MHz, static RAM up to 96 kB, and Flash up to 1024 kB. It also supports Thumb-1 and Thumb-2 instruction sets.
2. STM32F0 are microcontrollers based on the ARM Cortex-M0 core. It was launched in 2012. The maximum clock rate is 48 MHz and includes the SysTick timer. Static RAM up to 32 kB, and Flash up to 256 kB. It also supports Thumb-1 and Thumb-2 instruction sets.
3. STM32F3 are microcontrollers based on the ARM Cortex-M0 core. It was launched in 2012. The maximum clock rate is 72 MHz and includes the SysTick timer. Static RAM up to 40 kB, and Flash up to 256 kB. It also supports Thumb-1, Thumb-2, Saturated, DSP, FPU instruction sets.
4. STM32G0 are microcontrollers based on the Cortex-M0/M0+ core. It was launched in 2018. The maximum clock rate is 64 MHz. Static RAM up to 128 kB, and Flash up to 512 kB. It also supports Thumb-1 and Thumb-2 instruction sets. Compared to the older F0 series, it presents improvements in terms of efficiency and performance.
5. STM32G4 are microcontrollers based on the Cortex-M4F core. It was launched in 2019. The maximum clock rate is 170 MHz. Static RAM up to 128 kB, and Flash up to 512 kB. Thumb-1, Thumb-2, Saturated, DSP, FPU instruction sets. Compared to the older F3/F4 series, it presents improvements in terms of efficiency and performance and higher performance compared to the L4 series.

STM32 Ultra-Low-Power

The STM32 Ultra-Low-Power has been designed to meet the need to develop devices with low energy consumption (such as portable and wearable devices) but maintaining a good compromise with performance.  There are 6 series in this group:

1. STM32L0 are microcontrollers based on the ARM Cortex-M0+ core. It was launched in 2014. The maximum clock is 32 MHz, static RAM is of 8 kB, and Flash is up to 64 kB. It also supports Thumb-1 and Thumb-2 instruction sets.
2. STM32L1 are microcontrollers based on the ARM Cortex-M3 core. It was launched in 2010. The maximum clock rate is 32 MHz, static RAM up to 80 kB, and Flash up to 512 kB. It also supports Thumb-1 and Thumb-2 instruction sets.
3. STM32L4 are microcontrollers based on the ARM Cortex-M4 core. It was launched in 2015. The maximum clock rate is 80 MHz, static RAM is of 64 kB, and Flash is of 1024 kB. It also supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.
4. STM32L4+ are microcontrollers based on the ARM Cortex-M4 core. It was launched in 2016. The maximum clock rate is 120 MHz, static SRAM up to 640 kB, and Flash up to 2048 kB. It also supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets. It has been enriched with advanced peripherals such as a TFT-LCD controller, Camera interface, etc.
5. STM32L5 are microcontrollers based on the ARM Cortex-M33F core. It was launched in 2018. The maximum clock rate is 110 MHz, static SRAM up to 640 kB, and Flash up to 2048 kB. It also supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.
6. STM32U5 is the last ultra-low-power series launched (in 2021). It is an evolution of the L series and is based on the ARM Cortex-M33F core. the new 40 nm silicon technology allows to further reduce energy consumption, it also includes advanced cyber security features and graphics accelerators. The maximum clock rate is 160 MHz, static SRAM up to 640 kB, and Flash up to 2048 kB. It also supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.

STM32 High-Performance

The STM32 High-Performance has been designed for data processing and data transfer. It also has a high level of memory integration. There are 5 series in this group:

1. STM32H7 are microcontrollers based on the ARM Cortex-M7F core. It was launched in 2017. The maximum clock is 480 MHz, static RAM is up to 1.4 MB, and Flash is up to 128 kB. It includes Ethernet and some advanced features such as dual Octo-SPI, JPEG codec, etc. It supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.
2. STM32F7 are microcontrollers based on the ARM Cortex-M7F core. It was launched in 2014. The maximum clock is 216 MHz, static RAM is up to 1.4 MB, and Flash is up to 128 kB. It is fully pin-compatible with F4-series. It supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.
3. STM32F4 was the first series of microcontrollers based on the ARM Cortex-M4F core. It was launched in 2011. The maximum clock is up to 180 MHz. It is the first series to have DSP and FPU. It also has faster ADCs, full-duplex I2S and an improved real-time clock. It supports Thumb-1 and Thumb-2, Saturated, DSP, FPU instruction sets.
4. STM32F2 are microcontrollers based on the ARM Cortex-M3 core. It was launched in 2010. The maximum clock is 120 MHz, static RAM is up to 128 kB, and Flash is up to 1024 kB. It is fully pin-compatible with the F2 series. It supports Thumb-1, Thumb-2 and Saturated instruction sets.

STM32 Wireless

With STM32 Wireless ST adds in the portfolio a platform for wireless connectivity to the portfolio. It has a broad spectrum of frequencies and is used in various industrial and consumer applications.

It has features compatible with multiple protocols which allows it to communicate with different devices in real-time. Now, only two series belong to this group:

• STM32WB provides Bluetooth®LE 5.2 and IEEE 802.15.4 communication protocols, Zigbee® and Thread, which can work simultaneously or individually.

 

• STM32WL is the first series that support LoRa® communication.

So, that was all for today. I hope you have enjoyed today's lecture. In the next lecture, I am going to focus on the Nucleo Development board, as we are going to use that in our upcoming tutorials. Thanks for reading. Take care !!! :)

Quick-Turn PCB Prototyping Service

Hi friends, I hope you are enjoying yourself a lot and having a great deal of fun. Our mission is to help you by providing quality content that meets your expectations so now today we will discuss all quick turn PCB prototyping services. We will discuss what is quick-turn PCB? What is a PCB prototype? What is a quick-turn PCB prototyping service? Quick turn PCB general Capabilities provided by companies. Benefits, applications and importance of quick turn prototyping service. Online Quick-turn PCB service providers and time measurements. So, let's get started:

Overview

• First of all, before starting the discussion we have to know about the meanings of the words used in our topic heading.
• We have to make grip on the meanings of quick turn, PCB, prototype, and service. After understanding the heading of the topic we will be able to understand core concepts.
• Quick turn: quick turn means something or someone that does things with great speed. Day traders use the quick turn technique to make a great deal of profit.
• PCB: PCB stands for the printed circuit board. It is a combination of conductive and insulating layers to perform specific functions that meet the demands of customers.

• The prototype is defined as an original model on which something is patterned. It is an early sample product built to test a process or concept.
• Now prototyping is a fundamental process for designing a new product on which electrical components will be patterned.

• Service: service is a system that is used to provide utilities like providing PCBs to the provided/desired location.

What is a quick turn PCB?

• Now after understanding the meaning of each term used in the heading we have to understand what is quick turn PCB? What is PCB prototyping and then we will discuss what is quick turn PCB prototyping service?

• A quick turn PCB means that a customer has their PCB faster than ever before.
• A quick turn ensures that a customer doesn’t have to wait for their product so it reduces delays.
• A quick turn also ensures that the manufacturing time for the PCB is reduced.

What is PCB prototyping?

• A PCB prototyping is to help designers to determine if there are any faults in the original PCB.

• It helps to improve performance and enhance efficiency.
• As prototypes are crucial so it is very difficult to make changes in the PCB which is manufactured.
• Quick turn PCB prototyping service means that providing PCB prototypes to the customers at a very fast speed, without delay.

Online Quick turn PCB prototyping service providers:

There are some online quick turn PCB prototyping service providers available. The one I am going to recommend is JLCPCB Fabrication House. JLCPCB provides this service of Quick-Turn PCB Prototyping for researchers so that they could test their projects in no time. Here are a few of the key points of this service provided by JLCPCB:

• They provide 1-50 layer PCBs with PCB Order Quality < 1m2 within 24 hours, while normally it takes 2-3 days for accomplishing such tasks.
• For PCBs with order quality between 1m2-5m2, JLCPCB takes around 3-4 days, while the normal time range is 5-7 days.

Few other Quick-Turn PCB suppliers are:

1. pcb4u.com

Location: Santa Clara

2. pcbway

Location: china Capabilities: preferred for minimum trace and hole size...etc.

3. aipcba

Capabilities: PCB fabrication, SMT services, PCB assembly services.

4. pcbunlimited

Location: US-based Capabilities: US prototype PCBs, PCBs panel share, offshore PCBs, PCB   design and layout services, PCB assembly services.

5. pcbgogo

Capabilities: FIXME(minimum trace and hole size...etc) 6. Other Quick turn PCB prototyping service providers are:

• Homebrew fabrication
• Breadboard killer
• Foundation technology
• Linksprite
• Kingfield electronics- CEM services
• Apex
• Cadsoft Eagle
• Exception group
• Bittele electronics
• Technotronic
• 4pcbassembly
• Sinomicro PCB
• Asian circuits
• Standard printed circuit board limited
• PCB train
• Euro circuit.....etc

PCB Capabilities - Quick-turn PCB

• Providing PCB prototypes within 24-72 hours is the quick turn PCB prototyping service.
• Companies do not have to look eye only at providing PCB at a fast rate but they don’t have to compromise on the quality of the product.

Items	General Manufacturing Capabilities	Companies general Remarks
How many layers	1-10 layers	For orders above 10 layers, contact to company.
Material	Aluminium or RF-4	For Flex, Rigid-flex, Metal-based (Aluminium etc.,), HDI, Halogen-free, High Tg, etc.
Maximum dimensions of PCB	500*1100mm (min 5*6mm)	For any size Greater than these Standard dimensions customers have to contact to the company
Tolerance in board size	±0.2mm/±0.5mm	±0.2mm for CNC routing, and ±0.5mm for V-scoring.
Thickness of the board	0.2-2.4mm	0.2,0.4, 0.6, 0.8, 1.0, 1.2, 1.6, 2.0, 2.4mm. For other thicknesses, customers have to contact to company.
Tolerance in the thickness of board	±10%	Normally “+ Tolerance” will occur due to PCB processing steps such as solder mask, electroless copper and other types of finish on the surface.
Board Thickness Tolerance(t<1.0mm)	±0.1mm
Minimum manufactural Trace	0.1mm	Min manufactural trace is (0.1mm), To save cost design trace should be above 6mil(0.15mm)
Min Spacing		Min manufactural spacing is 0.1 mm. To save cost it should be 6mil(0.15mm)
Thickness of outer copper layer	1oz/2oz/3oz(35µm/70µm/105µm)	Also known as copper weight. 35µm=1oz, 70µm=2oz, 105µm=3oz. For copper weight greater than 3oz customers have to contact the company.
Thickness of inner copper layer	1oz/1.5oz(35µm/50µm)	Inner copper weight as per customer’s request for 4 and 6 layers is 1-1.5 oz.
Drill Sizes	0.2-6.3mm	Min hole size is 0.2mm, max drill size is 6.3mm. Any holes greater than 6.3mm or smaller than 0.3mm customer will have to pay extra charges.
Annular Ring’s minimum width	0.15mm(6mil)	Min width for Annular Ring is 0.15mm(6mil), for pads with vias in the middle
Diameter of finished hole	0.2mm-6.2mm	The final hole diameter will be smaller than the size of the drill because of copper plating in the holes.
Tolerance of finished hole size	±0.08mm	For example, if the drill size is 0.8mm, the finished hole diameter ranges from 0.72mm to 0.88mm will be considered acceptable.
Solder Mask	LPI	Liquid Photo-Image able is the most adopted. Thermosetting Ink is used in the inexpensive PCBs
Width of minimum character	0.15mm	Characters of less than 0.15mm wide will not be Identify easily.
Height of minimum character	0.8mm	Characters of less than 0.8mm high will be too small to be identified.
Width to Height Ratio of character	1:5	In PCB silkscreen legends processing, 1:5 is the most suitable ratio for character width to height.
minimum diameter of PHH( plated half holes)	0.6mm	Design Half-Holes greater than 0.6mm for better connections.
Surface Finishing	HASL with lead HASL lead free Immersion gold	These are the tree most popular types of surface finish.
Solder Mask	Black, yellow, white, blue, green, red	No extra charge (Green, Red, Yellow, Blue)
Silkscreen	White, Black and None	No extra charge.
Panelization	Tab-routing with Perforation (Stamp Holes)V- scoring Tab-routing	For break-routing min clearance between boards should be 1.6mm and for V- scoring it should be zero.
Others	UL certificate, Fly Probe and A.O.I. testing, ISO 9001:2008	No extra charge.

Quick turn PCB service types:

PCB manufacturing service providers provide PCB quick turn services as

• 1-day quick turn PCB prototype
• 2 days quick turn PCB prototype
• 3 days quick turn PCB prototype
• 5 days quick turn PCB prototype
• 10 days PCB standard PCB prototype
• > 10 days PCB prototype.

Benefits of quick turn PCB prototyping service:

• Why do designers rely on prototypes instead of making a standard product? The answer to this question is that the prototype allows designers to test the functionality of the product in the design process at several stages and allow them to make adjustments according to their needs.
• Prototyping creates several advantages for customers and manufacturers as

1. Reduced timeline:

PCB prototypes help designers to complete their final product in these ways by saving their time.

• PCB prototypes complete the testing process at a fast rate. Without prototypes, flaws will waste a lot of time, lost revenue, and make a customer unhappy.
• PCB prototypes also save time by providing visual assistance to clients during the production process.
• At several stages, Prototypes help in testing before a full production run and save not only time but also minimized rework.

2. Reduced costs:

Prototypes help in reducing cost by avoiding the following issues:

• Catching design flaws
• Pinpointing cost-saving adjustments.
• Determining product adjustments.

3. Test components individually:

Designers use PCB prototypes for testing purposes. Most beneficial testing is achieved by testing simple PCBs. This type of testing is used to achieve the purposes listed below

• Testing design theories
• Breaking down complex designs.

4. Accurate reliable prototype:

Accurately designed reliable prototypes help throughout the designing and manufacturing process. Quality PCB prototypes allow designers to test the following aspects:

• PCB design
• Functional testing
• Conditional testing
• Final product design

5. Manufacturing review and assistance:

Using third party PCB prototyping services companies gain benefits but several things can go wrong in the design process that results in mistakes listed below:

• Excessive input
• Design blind spots
• Design rule check

Applications of quick turn PCB prototype:

Quick turn PCB has several applications in different industries. The applications in different scenarios are listed below:

1. Electronic designers who require high-quality boards use quick-turn PCB prototypes.

2. PCB assembly manufacturers designs products for the mass market use quick turn PCB prototypes to fulfil the needs of the market. 3. Designers also need to work on new ideas so they use quick turn PCB prototypes. 4. To provide the investors and clients the samples of their products designers need to show quick turn PCB prototypes.

Importance of quick turn PCB prototyping service:

• The role of PCBs in the best performance of electronic devices can not be denied.
• Electronic devises based companies heavily depend upon PCB prototyping firms and their efficiency of fabrication.
• However, to meet challenging deadlines, pressing schedules, and excellent quality PCB manufacturing, quick turn PCB prototyping service plays a crucial role.
• Let’s know-how companies benefit from their quick services and attain their business goals.

1. By providing quick turn services, companies increase their number of customers.
2. For the projects that need to be completed in a very short time, companies charge extra amounts. To attain the goals of extra profit, and everything related to PCB manufacturing should be perfect.
3. By providing reference prototyping services, companies built a trust relationship with their customers.

• Listed above are the benefits/ importance for companies providing quick turn PCB prototyping service. Quick turn PCB prototyping service is not only beneficial for companies but also for clients. Here is the importance of quick turn PCB service for customers.

1. By obtaining their prototype according to their demands, customers can complete their projects on time.
2. Customers do not have to waste their time in transportation and searching for PCB, they just have to order PCB and mention their requirements. Their desired PCB will be at their door.
3. There are also some cost benefits to customers in this service.

Quick turn PCB prototyping service time measurement:

• When an order is placed in the morning like at 9:00 am then at next business day noon, 1 day is completed and from noon after 24 hours, 2nd day is completed from your order.
• If an order is placed at 12:00 am then after 24 hours, 1 day will be completed. And next days will be counted similarly.
• For orders placed after 4:00 pm lost much of their time so placing late time orders is not suitable.

Conclusion:

When we think about PCB prototyping, it seems an additional step that will enhance the PCB cost and we consider it one that never is overlooked. But the reality is that it is best to weed out errors, flaws, and faults before proceeding to the final product. Prototyping helps in reducing cost, provides us with quicker turnaround time, and provides you with more efficient design. Now designers always prefer prototypes before developing new innovative ideas as well. They know about the value of time, cost and quality so suggest to students, engineers, and innovators to use prototypes. In the end, we can say that the value of PCB prototypes can not be neglected, they are as fruitful and helpful as standard PCBs.

That’s all for today’s article. I hope you have enjoyed the article and make grip on the understanding points. However, if you still face any skepticism regarding single-layer PCB then please feel free to leave your questions in the comment section. I will provide an answer to these questions to the best of my knowledge and researching skills. Also, provide us with your innovative feedbacks and suggestions you improve the quality of our work and provide you content according to your needs and expectations. Stay tuned! Thank you for reading this article.

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.

Setup Arduino Environment for NodeMCU Programming

In the previous tutorial, we have discussed the basics of ESP8266 modules and have also had a look at the different WiFi modules based on ESP8266. In today's tutorial, we are going to set up Arduino Environment for NodeMCU Programming. Today we will prepare the development environment and build code to blink an LED and report status on the Serial Port (to validate the configuration). We will use the Arduino IDE for coding and the NodeMCU board (a module that works with an ESP8266). Simple integration. Zero hardware complexity.

The ESP8266 is an extremely robust and versatile microcontroller, which has proven to be a powerful tool in building Internet of Things solutions. What makes the ESP8266 such a popular tool is the perfect integration between a robust 32-bit processor and a fully functional WIFI module that already includes Internet Protocols.

A simple target, but the goal here is to prepare and test the development environment and introduce the programming mode.

Material

• 1x Computer/notebook with the minimum requirements to install Arduino IDE;
• 1x Mini-USB cable;
• 1x NodeMCU

Arduino IDE Install

•  Our first step is to download the Arduino IDE installer. It is available at this URL (https://www.arduino.cc/en/software).
• Figure 2 shows the latest stable version 1.8.15.
• It is recommended that you always have the most current version.
• So, if there’s a newer version when you download it, it’s the right for you. The Arduino community provides constant improvements to the IDE.

• On the right side, you can find the correct version for each Operating System and download the correct installer.
• We will not go into details here about how to install from the file. The Arduino page itself features an excellent manual on Getting Started.

• If this is your first contact with Arduino, I recommend checking out the Learn Arduino section as well.

Arduino IDE Presentation

• So, IDE installed, let's get to know the interface before making some important settings.
• If everything is ok, you should get the following result when running Arduino.

 

Text Editor

• The first thing that should catch your attention is that the code has already started with two functions.
• The “void setup()” and the “void loop()”.
• Arduino maintains a bootloader in the microcontroller, which is an initiator program responsible for preparing the hardware for correct operation.
• When we turn the module on power or press the reset button, the bootloader is the first program to run.

One of the bootloader's main responsibilities is to receive the code we send and write it to the microcontroller's memory. And when the code plays, the bootloader asks two questions:

1– What do I do first?

Answer: What does the “setup()” function say to do.

2– What do I do after “setup()”?

Answer: Repeatedly execute whatever the “loop()” function tells you to do.

• By default, we use the “setup()” function to inform whether a pin will operate as input or output, set the initial state of each pin used, set serial port Baud Rate, initialize additional configuration functions.

Verify and Upload Buttons

• Once our code is done, we need to check if everything is right and write the code in the microcontroller.
• The check button does a code check to identify syntax or library integration errors. Attention: logic errors are not checked; these are up to the programmer.
• The Upload button also performs the verification and then sends the code to the microcontroller via the Serial port.

Feedback Interface

• Perhaps the most important snippet of the IDE, here it reports the status of testing and recording. This is where you see if everything is ok.

Serial Monitor

• The Arduino IDE has a tool called Serial Monitor that allows direct communication with the microcontroller from the Serial port.
• It is possible to follow what is being sent by the module and send commands directly to it.

Two points of attention

1. The Communication Port (in the example COM3) must be selected in the Tools
2. The Baud Rate (in this case, 115200) must be entered correctly, otherwise, the data may become illegible or simply not appear.
3. Baud Rate can be set in the “setup()” function when preparing the recording

Boards Manager

• Each Arduino module has its peculiarities. Amount of memory, available pins, etc.
• Just as important as making a well-built code is telling the IDE which card model will be used.
• IDE Arduino already brings in its basic installation, the installation of boards that use ATMEGA microcontrollers.
• If you are going to use another type of board, it needs to be installed in Boards Manager (tools -> Boards Manager...).

•  Once installed, the board will be available and must be selected from the Tools -> Board menu.

Attention point

• Until Arduino version 1.8.15, modules using the ESP8266 do not appear available in Boards Manager.
• This is because it is not yet included in the official Arduino repository.
• For it to appear, it is necessary to add the path of a new repository.
• Do this by going to the File -> preferences menu and add http://arduino.esp8266.com/stable/package_esp8266com_index.json in the Additional Boards Manager URLs field.
• Press OK, close Arduino, and open it again.
• In Boards Manager the ESP8266 option will be available. Click install.

Once this step is completed, the main modules using the ESP8266 will be available. For our application, we will use nodeMCU 1.0.

Coding NodeMCU with Arduino IDE

• After choosing the board, choosing the port (note, the port will only appear when you connect the board to the USB), it's time to make our first code.
• The nodeMCU Module has a built-in LED and we will make it blink every 1 second.

• For this sketch, we don't need to include any additional libraries.
• When we inform Arduino that we are using the NodeMCU board, it already knows who the LED_BUILTIN is and which pin it is connected to.
• We use #define LED LED_BUILTIN just to give a more practical name to our LED, it could be used to name an external pin, for example, #define LED 13, alternatively, the original name could be used in the code.
• pinMode(LED, OUTPUT) and pinMode(13, OUTPUT) would have the same effect.
• The pinMode(LED, OUTPUT), by the way, is used to inform that this pin will operate as output. Note that this configuration was done inside the setup() function, so the pin will be prepared before being used in another function.
• Serial.begin(115200) initializes communication with the serial port at baud rate 115200. In our Loop function we will follow the sequence:
• Turn off the LED, write the pin status to the serial, wait for 1 second, turn the LED on, write the pin reading to the serial, wait for 1 second and start all over again.
• Here's the video demonstration of LED Blinking with NodeMCU:

So, that was all for today. I hope you guys have enjoyed today's tutorial on LED Blinking with NodeMCU. In the next tutorial, we will have a look at How to connect NodeMCU with webserver. Stay Tunned. Thanks !!! :)

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.