The Engineering Projects

Introduction to Ceramic Printed Circuit Board

Hello friends and welcome to this article. Today we are going to have a look at the introduction to the ceramic printed circuit boards. we have previously introduced what a printed circuit board is and we noticed that it is a very important part that makes electronic circuits complete and well organized. Having that in mind, we had also discussed several materials that build up these PCBs and today our focus is on the ceramic types of PCBs.

Introduction to Ceramic Printed Circuit Board

• This printed circuit board is referred to as ceramic PCB because of the substrate used in the construction of this board is made up of ceramic and it finds applications in special areas.
• The process of making this board is that copper is pasted on the surface that is made up of alumina ceramic which is the substrate material at a very high amount of temperature.
• Its substrate material offers a very high value of conductivity features, very great insulation factors and provides easy soldering surfaces.
• The most preferred manufacturing process is the laser rapid metalization technique which is a very important process.
• The structure of ceramic borders is very simple when compared to other types of these boards and it offers high-level operations than what is offered by the other type of boards.
• The size of the conductive layer used in this type of board is between one micrometer and 1-millimeter thickness.

How to order Ceramic PCB

There are many online PCB companies, where we can place our PCB orders and the best of them all is JLCPCB. JLCPCB is a China-based PCB Fabrication house and offers the cheapest PCB rates. It's quite simple to place your PCB order on the JLCPCB official site. Here are the steps:

• First of all, create an account on the JLCPCB site.
• They have an online PCB calculator, where you can calculate the final price of your order by adding all your requirements.
• Next, you need to upload the Gerber file of your PCB design.
• Finally, made the payments through an online secure payment gateway, they have multiple options i.e. Visa, MasterCard, PayPal.
• That's it, once your order got ready, you will get it through DHL express delivery service.

[video width="1920" height="1080" mp4="https://www.theengineeringprojects.com/wp-content/uploads/2021/12/homeOrderVideo.mp4"][/video]

Structure of the ceramic PCB

In this discussion, we shall have a look at a single-layer ceramic PCB. It consists of; the ceramic substrate layer, the copper layer and the solder mask layer. Let us have a look at the image below which is a double-sided layer ceramic PCB constructed through the normal method of lamination.

Ceramic substrate

• Compared to the FR-4, ceramic has good thermal conductivity and thermal insulation features and there in these boards, ceramic plays two very important roles one is about thermal dissipation and the other is about providing insulation between the board’s circuit layers.
• When double or multilayer ceramic PCB is required, vias are necessary for providing connection between the layers. To achieve this, vias are drilled through the ceramic substrate by the use of laser technology.
• The drilled vias are then filled with the copper core through plating.

Copper layer

• This is in form of a thin copper foil that is bonded to the substrate by the method of magnetic sputtering.
• After bonding the copper foil on the ceramic substrate, the circuit is etched on the copper by the use of the photoresist coating of the yellow light way.

Dielectric layer

• Made up of various materials such as epoxy resins, phenolic, etc.
• It is used to bond the structures of two adjacent ceramic substrate layers.
• This substrate has poor thermal conductivity properties compared to the ceramic material hence it ends up affecting the overall thermal conductivity of this board.
• it is important to note that ceramic boards can only be used in applications that have lower heat dissipation.

Solder mask

• this has the importance of protecting the exposed copper wires from solder, metals and damages from the environmental conditions.
• The solder mask is applied on the top layer of every PCB after completion of lamination. It might be white, green, beige, red, etc in color.

Single-sided layer ceramic PCB is shown below;

We can notice that it has a copper layer, the substrate layer and the copper shield but the dielectric is missing. This is because the two ceramic layers are bonded by the PP.

Types of Ceramic PCB

Ceramic PCBs are classified according to ceramic substrate material used and also according to the manufacturing method that was used. Let us have a deeper look into these classifications below;

Classification according to the type of ceramic substrate used

Alumina PCBs

They are the most used types of ceramic PCBs and aluminum oxide is the most readily available substrate.

Aluminum nitride PCBs

They are also commonly used PCBs but they are a bit expensive when a comparison is done with the alumina PCBs.

They gave high thermal conductivity and smartly higher frequency performance again when compared to the Alumina ones.

Silicon nitride PCBs

More costly when compared with the aluminum nitride PCBs. They have higher mechanical strength and toughness hence finding greater use in the power modules such as IGBT and military modules.

Silicon carbide PCBs

This is diamond and has high thermal conductivity and electrical conductivity. They find applications in the areas of laser technology.

Boron oxide PCBs

Has dozen times boron activities than the alumina ceramics but this type of ceramic is very poisonous. They find use in high power and frequency applications

Classification according to manufacturing.

High temperature co-fired ceramic – HTCC

This is the earliest method known for PCB manufacturing. The method is suitable for high power and not for high speed or high-frequency PCB manufacturing.

Direct bonding copper method – DBC

This one requires lower temperature compared to the HTCC. They have no PTH vias and they are mainly preserved for power electronic module packaging.

Thick film ceramic PCBs

This has a requirement that the circuit line space should be at 60 micrometers. They find their use in applications that require lower power utilization.

Low temperature co-fired ceramics PCBs – LTCC

They are usually multilayer and normally three-dimensional. They are best suited for communication devices with high frequency.

Thin-film ceramic PCBs.

Has very high precision circuits but the copper layer has a limited thickness. These types of PCBs find their use in high precision devices and also in very small devices development.

Direct platting copper PCBs

They are developed from thin-film technology and can be in 3D and has very high circuit precision. They find their use in high-frequency and high-power circuits.

Characteristics of the ceramic PCBs.

Ceramic boards have very distinct characteristics that always give them an advantage over the other type of boards. below is the list of these special characteristics;

• They are excellent heat conductors.
• Offers excellent CTA component compliance.
• With ceramic PCBs expect a high level of mechanical compatibility.
• They are not easily corroded by chemicals.
• It is very simple to do a high-density outline in these types of PCB boards.

Benefits/advantages of the ceramic PCBs

The ceramic PCB boards are given high priority due to a number of material features and characteristics that they offer which proves to be beneficial in the process of PCB manufacturing. The character of heat dissipation gives this board an advantage over the traditional types of PCB boards. components of the board are placed on the boards directly without the involvement of the isolation layer and this makes the flow of heat throughout the board better compared to the other types of boards. The following are some of the benefits that make this board the most preferred;

High thermal expansion

They are the most popular in the field of electronics due to their features that are unique. One of these features is that it provides a very high thermal coefficient expansion. These boards will still offer very high thermal conductivity even when operated at high temperatures.

Adaptability

These types of boards use a metal core. The metal core is used when the board is undergoing the engineering process. The board can be changed to a rigid carrier which will offer a stiff mechanical strength. This stiffness is very crucial as it allows the board to be used in both fluids and solids.

Durability

The ceramic material offers a lasting-results to the PCBs being manufactured. The toughness of the material used in the making of the board will protect it against routine wear and tear. In addition, these boards offer high thermal resistance which will slow down the decomposition of these types of boards and therefore increase their durability.

Stability

They offer very high stability which is a result of a stable dielectric property that originates from the dielectric materials. Due to the toughness of the ceramic materials, it has a natural resistance to many chemicals.

Versatility

It has a very high melting point hence it can be used in many applications for both low and high temperatures. The best thing about these ceramic boards is that they will offer good thermal conductivity while distributing heat evenly throughout the board and different positions of the devices.

Ceramic boards disadvantage

• It is very hard to find ceramic PCB boards because they are hardly available.
• When compared to the standard boards, the ceramic boards are very expensive.
• These types of boards are highly fragile and therefore they require handling with great care.

Ceramic PCBs applications

Memory module applications

It was done in Japan when a company crested an SRAM memory module by the use of the multilayer ceramic PCB. The ceramic PCB is appreciated for both high-density PCB and low-density PCB. Another example is about the USA company that had developed the telecommunication, aerospace and missile products using this type of board.

Transmission module

This is being done by an American company that is determined is building a transmission module for radar communication using the ceramic PCB boards.

Digital PCBs

Japanese have used low-temperature PCBs in the manufacture of digital PCBs. This is used because it reduces the weight of the circuit greatly. It also reduces the volume of the circuit.

Interconnect boards;

The ceramic boards are mostly used in printed circuit boards because they support the miniaturization of the devices. It has a very high probability in the application of the boards in multilayer interconnects.

Solar panels

HTCCs and LTCCs are both applied in the process of making photovoltaic panels. In this device, we shall use multilayer ceramic PCBs to make them tough and durable.

Electrical power transmitter

There has been an increase in the use of wireless power transmission systems and this implies that most power transmission system has to use ceramic boards to achieve that ability.

Semiconductor coolers

With the introduction of very small pocket gadgets, many electronic circuits are getting miniatured. To achieve miniaturization, it starts with the use of semiconductors that have a highly reduced size. The normal boards cannot give the support needed in order to make sure that the miniaturization process is fully achieved. In order to make this possible, ceramic semiconductors have been introduced and this is accompanied by the use of ceramic PCBs.

How to choose the right ceramic PCB manufacturer

When you are choosing the person or the manufacturer who can produce your board, you have to consider the manufacturer who has the superior tooling that is required to make the process successful. The manufacturer should be able to control the oxidation process so that the board can have superior thermal conductivity and higher temperature resistance.

Ensure that the manufacturer uses the automated process to do the manufacturing and this will make sure that your board is in perfect condition and of very high quality and the process will be less time-consuming.

Introduction to the MATLAB Datatypes

Hello friends. In this lecture, we are going to have a look at the different kinds of MATLAB data types.

As we have already seen in previous lectures, MATLAB stands for MATrix LABoratory and allows us to store numbers in the form of matrices.

Elements of a matrix are entered row-wise, and consecutive row elements can be separated by a space or a comma, while the rows themselves are separated by semicolons. The entire matrix is supposed to be inside square brackets.

Note: round brackets are used for input of an argument to a function.

A = [1,2,3; 4,5,6; 7,8,9];

An individual element of a matrix can also be called using ‘indexing’ or ‘subscripting’. For example, A(1,2) refers to the element in the first row and second column.

A larger matrix can also be cropped into a smaller matrix, as we can see in the example below.

A scalar is just a special case of a matrix and its element size is 1x1. Square brackets are not needed to create a scalar variable. Also, a vector is a special case of a matrix with a single row or column. Square brackets without an element inside them create a null vector. We see examples of this in the code below:

• u = [1 2 3]; %Produces a row vector
• v = [1;2;3]; %Produces a column vector
• X = []; %Produces a null vector

Elements of a matrix can be all kinds of numeric datatypes, whether they are floating-point, integers, or imaginary numbers, as we will see in the next section. They can even be symbolic.

DataTypes of MATLAB

Every variable that is stored in the workspace of MATLAB has a datatype. It can be an in-built or default datatype or users can build their own datatypes depending on the purpose of the code.

You can always find a datatype in MATLAB by using the 'class’ function.

Numeric datatypes:

Double:

• This datatype takes 64 bits to store a number. This essentially represents a floating-point number, i.e., a decimal number with double precision, and can be positive or negative. You can use the function ‘double’ to declare the datatype when creating a variable, but double is the default datatype in MATLAB and whenever you call a command such as the one shown below, the number is stored as a double.

• These variables can store values varying from between -1.79769 x 10³⁰⁸ and -2.22507 x 10^-308 for the negative numbers and the range for positive numbers is between 2.22507 x 10^-308 and 1.79769 x 10³⁰⁸ In situations where such large values of numbers are not needed, single-precision floating-point variable can be used.

Single:

1. When storing smaller numbers, it is better to use the single-precision floating-point numbers which vary between-3.4x10^38 and 3.4x10^38. This stores a variable in only 32 bits and helps to speed up the code. We use the function single in order to create this kind of variable.

Integers:

• MATLAB supports four types of signed integers and four types of unsigned integer datatypes, given by, int8, int16, int32, and in64 for the signed integers, and uint8, uint16, uint32 and uint64 for the unsigned integers. The number refers to the number of bits required to stored these integers and the range of allowed numbers is decided accordingly.

Complex numbers:

• You can create a complex number by using the ‘complex’ function or using the default symbol ‘i’ for the imaginary part of the complex variable. We can also extract the real and imaginary parts of the complex number using the ‘real’ and ‘imag’ functions on the complex number.

Infinity and Nan:

• Any number larger than the range given above is represented in MATLAB by the value ‘Inf’. Such a number can result when we divide by zero, which leads to results too large to represent as floating-point values and they end up being outside of the ranges discussed above. We can check if a variable is an infinity or not by using the function ‘isinf’ on it. Some numbers that can’t be represented by a real number such as the result of calculating ‘0/0’ or ‘inf/inf’ are called NaN, i.e., “Not a Number”. We can check if a variable is NaN or not by using the function ‘isnan’ on it.

Logical:

• These are variables that only have values of 0 and 1, and are the result of a comparison operation. An example of a result of comparing two matrices that gives a logical matrix as an output is shown below:

Representation

We can represent the output of a double in a shorter format which is easy to read or in a longer format which will help with learning about the accuracy of those double variables, using the commands below:

• format short
• format long

Conversion of numeric datatypes:

We can convert between double or single-precision numbers, as well as from floating-point to integers or vice versa using the functions described above which we use while declaring the numeric data type.

Operations on numeric datatypes:

Following is a list of operations on the numeric datatypes.

• abs: to determine absolute and positive value of a signed or complex number.
• Fix: round-off a floating point number towards 0. For example, fix([-2.1, 2.9]) = [-2, 2]
• floor: round-off a floating point number towards –Inf. For example, floor([-2.1, 2.9]) = [-3, 2]
• ceil: round-off a floating-point number towards +Inf. For example, ceil([-2.1, 2.9]) = [-2, 3] round: round-off a floating-point number towards the nearest integer. For example, round([-2.1, 2.9]) = [-2, 3]
• Rem: Remainder after division of first argument by second argument. For example, rem(10,3)=1
• Sign: signum function returns the sign of a number.

Other datatypes:

Characters/strings:

• The character or string array is used to store text data in MATLAB.

Single quotes are used to declare a character array. For example,

A = ‘Hello World’ is a character vector.

However, double quotes are used to declare a string. String is different from a character because individual parts of a character array can be accessed using indexing but the same is not true for strings.

You can carry out the exercise shown below to understand this subtle difference.

The various operations that can be performed on character array include:

Cell matrix:

• Just like matrices, a cell array is an indexed data container with each element known as a cell and can contain any type of data, including other cells and arrays which can be numeric or non-numeric types. Cells can be declared with curly braces, { } to let MATLAB know the input is a cell array. Individual cells inside a cell array can be called using round parentheses whereas contents at a location can be accessed by curly braces again, as shown in the example below:

The function ‘cell2mat’ takes a cell as an argument and outputs a matrix. However, for this, all the elements of a cell array must be the same data type. This is what distinguishes Cell arrays from Matrices.

Tables:

• A table is a convenient data structure to write column-based or tabular datasets that can be stored in a text or spreadsheet file, or plotted easily as well. Tables let you access individual columns with variable names. Each variable can be a different datatype. The only restriction for different columns is for them to have the same number of rows. You can load the inbuilt tabular dataset inside MATLAB as shown below.

Structures:

• Structures are the most generic datatype in MATLAB which consist of indexed elements and each index can store a different datatype or in fact, a structure itself. Such structures are known as nested structures and the various branches of a nested structure can be accessed using the dot notation.

Non-numeric datatypes also include function handles, symbolic variables and anonymous functions but they are a topic worth a separate lecture for discussion and will come up in the upcoming lectures.

In further chapters, we will look at some of the applications of MATLAB in Linear algebra, look at different kinds of matrices inside MATLAB that are commonly used in a linear algebra class, and also work with input and output of data and functions using ‘m’ files as well as ‘mat’ files. We will also read about saving and loading operations, for input and output of data from MATLAB, and we will look further at making GUI in MATLAB, plotting linear, polar, 2D and 3D graphs with data sets.

Regulated Power Supply Using LM317

Hello geeks, welcome to our new project. We are going to make an important project which will be very useful for us in our daily life which is a variable DC power supply. As engineers who work with electronics need different voltage ranges of DC power supply for different electronic projects and components. It becomes very clumsy and hard to manage different power supplies because of wires which are connected to it and each power supply consumes an extra power socket as well.

So in this project, we will overcome this issue and learn to make an adjustable DC power supply, in which we will get a wide range of voltages.

Software to install

We will make this project in the simulation, as it is a good practice to make any project in the simulation first so that if we do any mistakes or errors in the circuit, which can be corrected without making any physical damage to actual components.

To make this project we will be using the Proteus simulation tool. A brief about the Proteus, it is a simulation software for electronics, here we can make different types of electronic circuits and run the simulation and it will give us the real-time working model of our circuit. Also, we can easily debug in case of a wrong connection.

It has a very large database of pre-installed components which has basically all types of different electronic components and in case, if it is not pre-installed, then we can install a library for those.

Components Required

• One Step down transformer
• Five 1N4007 Diodes
• One 4700 microFarad Polarised capacitor
• One 100 microFarad Polarised capacitor
• Three 0.1 microFarad non-polar capacitors
• One 5 kOhms potentiometer
• One 220 Ohms resistor
• One LM317 IC

Components details

1. LM317

• It is a voltage regulator IC which has a wide range of applications in various voltage limiting circuits.
• It has three terminals as Vin, Vout, Adjust.
• Using these three pins only we can regulate the output voltage.
• As the name suggests, the Vin pin is used for the input power supply, the Vout pin is used to take the output voltage, and Adjust pin is used to control the output voltage.
• It is a very easy-to-use IC, it requires only two resistors for the circuit and it will be ready to use.
• It uses one resistor for the RC filter and one as a potentiometer to adjust the output voltage.
• As per the datasheet, it has a formula for calculating output voltage, and using that we can adjust our resistor value as per our requirement of output voltage.

 

• For more details about this IC prefer the following datasheet:

2. Step down Transformer

• Step down transformer is used to convert the high input voltage to low voltage.
• It takes high voltage and low current as an input and it will give low voltage and high current as an output.
• Here we will not go in-depth about the working of transformers but in brief, it has two windings as primary and secondary.
• It is the exact opposite of the Step-up transformer as per the use case and windings.
• In this type of transformer, there are more turns on the primary side winding and lesser turns on the secondary side winding.
• It is mostly used in power supplies.

3. Diodes

• Diodes are two-terminal simple electronics components.
• It works as a valve which allows the flow of current in only one direction and limits the flow of current in another direction.
• They are used mostly in every electronic device such as in power supply or as regulators or used in construction ICs for logic gates.
• It has two terminals as Anode and Cathode and current is allowed to flow from Anode to Cathode side only.
• As per the construction, it has two sides P side and N side.
• The P side terminal is also known as Anode and the N side terminal is known as Cathode.
• A simple PN type diode is made using the P-type and N-type semiconductors.
• In N-type semiconductors, free electrons are in majority, and in P-type semiconductors, holes are in majority.
• There are various types of diodes available but as per our use case, we will use a simple PN junction type diode.
• We are using the diodes as rectifiers in this project.

4. Capacitors

• Capacitors are electronic components that have the ability to store energy.
• It has two terminals that are connected with two parallel conductor plates and they are separated from each other with an insulating material called dielectric material.
• When we apply voltages across the terminals then due to generated electric field, it stores energy in the form of electric charges.
• We have used capacitors in this project for filtering purposes.
• There are various types of capacitors as per the use case in this project we have used the non-polarized and polarized capacitors.

5. Potentiometer

• It is a passive electronic component using which we can vary the output voltage by changing the resistance.
• Basically, it is a variable resistor in which we change the resistance by moving a nob.
• It has three terminals as Vcc, Ground, and Vout.
• There are two types of potentiometers. First is the Rotary potentiometer and the second is the Linear potentiometer.
• In this project, we have used a rotary potentiometer.
• The main application of a potentiometer is a voltage divider. And using this characteristic, it is used in various types of applications such as speed controlling of motors, volume control in audio systems, etc.

Project Overview

In this project, we will use the following components-

• LM317 - We will be using this IC as the main controller of our project, using this we will regulate the voltage of the power supply.
• Diodes - These are very important components for any DC power supply as they will change the AC supply to DC supply.
• Step down Transformer - This will be used as an isolator and it will lower the input voltage.
• Capacitors - These are used for smoothening the pulses and making the noise-free power supply.
• Potentiometer - It is used as a regulator to set the output DC voltage.

Now we know the basic role of each component, so let's talk about how actually our power supply will work. In brief, the flow of our power supply will be as mentioned further.

We connect it with AC power then we will lower down the AC supply to 12-24 AC because most of the electronic component has this working voltage range, thereafter we will change the AC to DC and do the smoothening of that DC supply, and then we will regulate that using a potentiometer and LM317 IC.

• To step down the AC voltage we have used the Step-down transformer and it will also isolate the AC circuit with the DC circuit although there are ways to step down the power without using the transformer also.
• After that, using the diodes we will make a full-wave bridge rectifier. It will change the AC power to DC but still, it will have some ripple from the AC supply.
• To smoothen the ripples from the AC supply we will use the RC filters, where we will connect some capacitors.
• Now we will have the smooth DC supply that we will use as input power for LM317 IC and a potentiometer will be connected to it.
• Using that potentiometer, we will change the output voltage.

Circuit Diagram and Working

Now we know all the components which we will use in this project and their use cases also. Let's start connecting them.

• Start the new project in the Proteus software and import all the required components to the workplace.

• Now, we have all the listed components in the workplace.
• First, connect the AC power supply with the Step-down transformer primary winding.
• On the secondary winding of the transformer, we will connect the full-wave bridge rectifier which we will make using the diodes. They are simple 1N4007 diodes.
• First, we will make two pairs of diodes by connecting two with each other.
• In the first pair, we will connect the Anode of two diodes with each other and leave the other two terminals free.
• Then in the second pair, we will connect the Cathode of two diodes with each other and leave the other two terminals.
• Now we have two free terminals in each pair, and we will connect them with each pair.
• If you are working with real components, just remember there will be a grey color stripe on the diode so that side will be Cathode and another side will be Anode.
• In simple words just take two diodes, connect the grey strip side of them with each other, then take another two diodes and connect the black side with each other, and after that connect them with each other.

• It is very important to connect the diodes very carefully otherwise our power supply will not work.
• And in case of wrong connections, it will flow the AC current in our circuit and that would be very dangerous.
• Now we have completed our full-wave bridge rectifier so now connect the input side of that with the secondary side of the step-down transformer.
• And connect two capacitors parallel to the output side of the rectifier. That is used for smoothening the output power.
• One 4700 microFarad capacitor and a 0.1 microFarad capacitor.
• While connecting the polar capacitor keep the terminals in mind.
• Connect the positive terminal of the capacitor with the positive side of the rectifier and the negative side with the negative side of the rectifier.
• In the polar capacitor, the longer terminal is positive and the shorter side is negative.
• Now let's connect the LM317 IC with the circuit.
• As we know LM317 has three pins so connect the Vin pin of IC with the positive terminal output of the rectifier.
• Now connect the Adj pin of IC with the potentiometer and Vout of IC will be the output of the power supply.
• We will use some more resistors and capacitors for filtering purposes.
• Connect two capacitors parallel with the output of LM317 and one RC filter also with it.
• At last, connect a diode from the output of LM317 with the input side of LM317 that will prevent the flow of reverse voltage. It is for simple protection.
• Now we have completed the connection of our circuit. For debug purposes, connect a voltmeter at the end so that it will be easy to check the working of the power supply and we can monitor the change in the output voltage by changing the value using the potentiometer.

Results and Working

• Now run this project.
• At first, AC high voltage will be converted to low voltage AC.
• As we know AC power is a sine wave and DC power is a straight line. It does not travel as a sine wave.
• That will be converted by the full-wave bridge rectifier. We know that diodes allow the flow of current only in the forward bias. This means only half of the cycle of the sine wave will pass through it, that is when the sine wave is in a positive direction.
• So to overcome this problem, we have used the diodes as full-wave bridge rectifiers.
• When the AC sine wave will be in the positive half cycle, the diodes D2 and D3 will be in forward bias, thus they will let the current flow. But D4 and D5 will be in reversed bias so they will not allow the current to flow.
• And when the AC sine wave will be in the negative half cycle, the diodes D2 and D3 will be in reversed bias, and diodes D4 and D5 will be in forward bias and that is how current will flow here. Thus, we will get the current in a full sine wave.
• So the output of the full-wave bridge rectifier will be like the following image:

• But still, this wave is not a DC current, so to make it a smooth DC current we have used the capacitors.
• When the wave goes upward, at that time, the capacitors store the charge but when the wave goes downward, then the capacitors start discharging, and while discharging they maintain the output voltage and let the current flow.
• But this will make some ripples and to neutralize that, we have used another capacitor that will do the same charging-discharging process and after that, we will have a straight line of pure DC power.
• Now DC power will go into the LM317 regulator IC. Thereafter when we change the value from the potentiometer, we can see the output voltage will change on the voltmeter which is connected to the output side.
• We can see in the following image when the value of the potentiometer is 4% then the output voltage is 2.40 volts

• Let’s change the value of the potentiometer.
• After changing the value of the potentiometer to 52%, we can see that output voltage is also changed to 14 volts.

• As we can see that output voltage changes by changing the value of the potentiometer which means our regulated power supply is working well.

Conclusion

I hope we have explained all the points related to this project. And I hope this will be a very useful project for your daily use as a power supply.

Please let us know if you face any issues while making this project in the comment section below.

We will be happy to know if you will make this project and how you are going to use it in your daily life.

Thanks for reading this article and All the best for this project, see you in the next one.

Motion Detection with ESP32 & PIR Sensor

Hello readers, we hope you all are doing great. Welcome to the 4th lecture of Section 5(ESP32 Sensor) in the ESP32 Programming Series. So far, we have discussed the ESP32 built-in sensors in this section. Today, we are going to interface an external embedded sensor(i.e. PIR Sensor) with the ESP32 Microcontroller board. At the start, we will discuss the basics of a PIR Sensor(HC-SR501) i.e. its pinout and working. After that, we will design a simple project to detect the motion with a PIR sensor and ESP32. Finally, we will display the motion detection results on the ESP32 WebServer.

We will use ESP32 interrupts to detect the motion. Interrupts are used when a microcontroller needs to continuously monitor an event while executing other tasks at the same time. We have already posted a tutorial on ESP32 Interrupts, which includes both software and hardware interrupts. In this tutorial, we are implementing the hardware interrupt(Hardware interrupts are the external interrupts that are caused by an external event). In our project, the hardware interrupt will be generated by the PIR sensor.

PIR motion sensor is mostly used in home automation & security projects, used to enable the system to respond automatically over human presence. Appliances connected to ESP32 will respond automatically(as per the instructions provided) whenever an interrupt is triggered by the PIR motion sensor. Let's first have a look at the working of PIR Sensor:

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

What is a PIR Motion Sensor?

In today's project, we will use the HC-SR501 PIR Sensor to detect the motion. PIR stands for Passive Infrared sensors. It uses a pair of pyroelectric sensors to detect heat energy in the surrounding environment. Both the sensors sit beside each other, and when a motion is detected or the signal differential between the two sensors changes the PIR motion sensor will return a LOW result (logic zero volts). It means that you must wait for the pin to go low in the code. When the pin goes low, the desired function can be called.

PIR Sensor Calibration

PIR Sensor has two variable resistors on its back side, used to adjust the Sensitivity and Detection Range, explained below:

• Low sensitivity ignores the small motions i.e. a moving leaf or a small mouse. The sensitivity can be adjusted based on the installation location and project requirements.
• The second resistor is used to specify how long the detection output should be active. It can be set to turn on for as little as a few seconds or as long as a few minutes.

PIR Sensor Applications

Thermal sensing applications, such as security and motion detection, make use of PIR sensors. They're frequently used in security alarms, motion detection alarms, and automatic lighting applications.

Now let's interface the PIR Sensor with ESP32:

Interfacing PIR Sensor with ESP32

As I mentioned earlier, in today's project, we will design a motion detection project with ESP32 and PIR Sensor. In the first example, we will turn "ON" the LED on motion detection, while in the second project, we will display the results in the ESP32 WebServer.

Here's the list of the components for today's project:

Components Required

• ESP32 Development Board
• PIR motion sensor (HC-SR501)
• LED
• 1k Ohm resistor
• Jumper Wires
• Breadboard

Circuit Diagram

Here's the circuit diagram for motion detection with ESP32 and PIR Sensor:

Now let's design the programming code for motion detection:

ESP32 Motion Detection Code

We are using Arduino IDE to compile and upload code into the ESP32 module. You need to first Install ESP32 in Arduino IDE to get started. Here's the code for motion detection:

//----Set GPIOs for LED and PIR Motion Sensor
const int led = 23;
const int PIRSensor = 4;

// -----Timer: Auxiliary variables
#define timeSeconds 10
unsigned long now = millis();
unsigned long lastTrigger = 0;
boolean startTimer = false;

//---Checks if motion was detected, sets LED HIGH and starts a timer
void IRAM_ATTR detectsMovement()
{
    Serial.println( " MOTION DETECTED " );
    Serial.println("Turning ON the LED");
    digitalWrite(led, HIGH);
    startTimer = true;
    lastTrigger = millis();
}

void setup()
{
    Serial.begin( 115200 ); // Serial port for debugging purposes
    pinMode( PIRSensor, INPUT_PULLUP ); // PIR Motion Sensor mode INPUT_PULLUP
    pinMode( led, OUTPUT );
    digitalWrite( led, LOW );
    attachInterrupt( digitalPinToInterrupt( PIRSensor ), detectsMovement, FALLING ); // Set PIRSensor pin as interrupt, assign interrupt function and set RISING mode
}

void loop()
{
    now = millis();
    if( startTimer && (now - lastTrigger > ( timeSeconds*500)))
    {
        Serial.println(" Turning OFF the LED " );
        digitalWrite( led, LOW );
        startTimer = false;
    }
}

Variables Declaration

• The first step is to set up the GPIO pins for the LED and motion sensor(PIR).
• LED is connected to GPIO23 and PIR sensor to GPIO4, as shown in the below code:
  

//----Set GPIOs for LED and PIR Motion Sensor
const int led = 23;
const int PIRSensor = 4;

• Next, we need variables to set the timer to count the time, after the interrupt is detected.
• The variable "now" defines the current time
• The variable "lastTrigger" defines the time when the interrupt is detected.
• The variable "startTimer" is used to start the time when an interrupt is detected.

//-----Timer: Auxiliary variables
#define timeSeconds 10
unsigned long now = millis();
unsigned long lastTrigger = 0;
boolean startTimer = false;

ESP32 Interrupt Function "IRAM_ATTR"

• The Function with the attribute "IRAM_ATTR" is executed inside the internal RAM.
• We are assigning this attribute to our interrupt function because RAM (random access memory) operates faster than flash memory.
• After the execution of the interrupt code or ISR, the normal code will be executed inside the flash memory.
• It is recommended that the interrupt service routine should have the minimum possible execution time because it halts or blocks the normal program execution.

//---Checks if motion was detected, sets LED HIGH and starts a timer
void IRAM_ATTR detectsMovement()
{
    Serial.println( " MOTION DETECTED " );
    Serial.println("Turning ON the LED");
    digitalWrite(led, HIGH);
    startTimer = true;
    lastTrigger = millis();
}

Setup() Function

• Inside the setup() function we are initializing the serial communication with a baud rate of 115200.
• Set the mode of pin GPIO23 (LED) as output.
• Set the initial state of the LED as LOW.
• Assigned the digital pin(connected to the PIR Sensor) to hardware interrupt using the attachInterrupt function.
• The detectMovement function is passed as an argument inside this function.

void setup()
{
    Serial.begin( 115200 ); // Serial port for debugging purposes
    pinMode( PIRSensor, INPUT_PULLUP ); // PIR Motion Sensor mode INPUT_PULLUP
    pinMode( led, OUTPUT );
    digitalWrite( led, LOW );
    attachInterrupt( digitalPinToInterrupt( PIRSensor ), detectsMovement, FALLING ); // Set PIRSensor pin as interrupt, assign interrupt function and set RISING mode
}

Loop() Function

We have activated the interrupt in the Setup Function, so when the PIR Sensor detects the motion, it will automatically execute the interrupt function, which will turn the LED ON and start the timer.

• In the loop function, we are comparing the current time with the last triggered time.
  
• LED will turn off after a delay of 5sec (once an interrupt is detected).
  
• The variable “now” will be updated with the current time in each iteration.

void loop()
{
    now = millis();
    if( startTimer && (now - lastTrigger > ( timeSeconds*500)))
    {
        Serial.println(" Turning OFF the LED " );
        digitalWrite( led, LOW );
        startTimer = false;
    }
}

Motion Detection Results/Testing

• Select the right development board from Tools >> Boards >> DOIT ESP32 DevKit V1 in Arduino IDE.
• Compile and upload the code into ESP32 using Arduino IDE.
• Open the serial monitor with a 115200 baud rate as defined in the Arduino code.
• Press the EN button on the ESP32 development board.

This concludes the tutorial. I hope you find this tutorial helpful. Thanks for reading. See you soon with a new tutorial on ESP32. Take care !!!

Christmas Tree using Arduino

Hello Geeks, I hope you all are doing great and enjoying your festive seasons. This time, we have come up with a new project which will make your festival a bit brighter so here comes a Christmas tree.

It is said that Christmas is the center of all the celebrations. Did you guys know the scientist who discovered the light bulb, Thomas Edison and his friends were the first to put up the light bulbs on the Christmas tree, and here we are going to keep that tradition forward? Well, it’s time to gear up for the next season of Christmas being tech-savvy. Hence we have decided to brighten up a Christmas tree with the usage of Arduino Uno and LEDs in real life.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	LEDs	Amazon	Buy Now
2	Arduino Uno	Amazon	Buy Now

Software to Install:

To make our festival a little safer, we will first make our Christmas tree in the simulation and for that, we will use the Proteus simulation software. Making it in the simulation will give us a good understanding of how it is going to work, and how we are about to design the Christmas tree such as the placements of lights and lighting patterns.

Proteus is a simulation tool for electronic projects. In this software, we can make approximately every type of electronic circuit and run the working simulation. It will show the real-time working simulation of the circuit and errors as well if any occurs.

It has a large database of mostly all types of electronic components but still, for some, we have to install libraries. In this project, we are using Arduino UNO and it is not pre-installed so we have to download it first.

Project Overview:

Following components will be required to design our Christmas Tree

• Arduino UNO - It works as the main controller in the project. We have used this to make different types of lighting patterns and using this, we will have a scope to make interesting lighting effects.
• LEDs - We will need LEDs for our Christmas tree. We have used different colors of LEDs to make the matrix shape circuit for the Christmas tree.

Components required:

• Arduino UNO
• Different colors of LEDs

Components Details:

Arduino UNO

• Arduino UNO is an open-source development board that we will use in this project.
• There are many types of Arduino development boards available but as per our requirement, we will be using Arduino UNO.
• It uses the ATMega328P processor.
• This microcontroller has a RISC-based architecture.
• It has 32KB flash memory, 2KB of SRAM and 1 KB of EEPROM.
• Talking about the communication peripherals, it has 1 SPI, 1 I2C and 1 UART on board.
• It comes with 6 individual PWM channels and 6 channels of ADC.
• There are 14 digital pins starting from D0-D13 and 6 analog pins starting from A0-A5 in this.
• D10-D13 can be used for digital I/O and SPI communication pinouts.
• A4 and A5 can be used for analog I/O and I2C communication pins.
• To power the Arduino, we can use the USB or Vin pin of the Arduino UNO board.

Note - It is recommended to disconnect any connection which is connected with the D0 and D1 pin of Arduino UNO before uploading the code otherwise it will cause issues in communication with the Arduino UNO and there can be an error for the same.

LEDs

• In this project, we have used different colors of LEDs for our Christmas tree.
• LED stands for light-emitting diode.
• It is one of the most efficient light sources compared to all other types of lights or bulbs.
• They are used mostly in all types of electronics projects such as display, indicators or works as a light source.
• Due to the long range of applications, LEDs come in a variety of shapes and colors.
• There are two poles for connecting it, one is short and the other one is longer.
• Talking about the connection, the longer side pole will be connected to positive voltage and the shorter side will be connected to the ground.
• As LED is a type of diode, the current will flow in only one direction. In case, if we connect the wiring incorrectly, it will not work.
• But still, if we have connected the LED wrong, no need to worry, just flip it over.

Mostly it has not been damaged yet.

• LEDs come in different voltage working ranges but here we have used 5v operating

Circuit Diagram and Working:

Now let's start with the circuit diagram of our project. The first step would be to import all the components to the workspace of Proteus software.

We will be using one Arduino UNO for controlling the LEDs and six different colors of LEDs. Here we will make 6 rows and 6 columns of LEDs for our Christmas tree, so we will be using 6 Aqua color LEDs, 6 Green color LEDs, 6 Orange color LEDs, 6 White color LEDs, and 6 Yellow color LEDs.

• After importing all the components to the workplace, it’s time to start connecting them.
• We will use 6 pins of Arduino UNO for rows and 6 pins for columns. As we know, Arduino UNO has 14 digital pins but as suggested we should not connect any connections with D0 and D1 pins.
• We will connect from D2 to D7 with the rows and D8 to D13 for columns.
• While connecting the LEDs, we must be very careful in case, if we connect any wrong terminal or any wrong connection, our whole tree will not work because all of them are connected in series with each other and that is the drawback of series connection.
• In case any connection is loose or wrong then all of the connected components will not work.
• Keeping this in mind, when we will use the real components, make sure all the LEDs are working fine otherwise we will not get the desired output.
• Don’t leave any loose connections or hanging wires.
• It would be easy if we would connect it in steps therefore we will divide it into three steps.
• First, connect all LEDs and make a 6x6 matrix. For connecting those we can use the simple twisted copper wires.

• While connecting the LEDs, mind the terminals.
• Now we will connect the column pins.

• After connecting the pins, we will connect the row pins.

• We have divided the connections in different pictures so that it would be easy to understand.
• After completing all the connections, our circuit will look like as shown in the picture below.
• Here, we have adjusted the wires, so that it will be in shape as the Christmas tree.

• After completing the connections, there may be a doubt about the working of this circuit.
• It is a little tricky, we have to make sure from the coding side that whenever we want to glow any LED, its ground terminal should be logic LOW and the positive terminal should be logic HIGH.

Arduino Coding:

After the connection of the circuit, let's start to code our Christmas tree:

• For writing the code, we will be using the Arduino IDE.
• In this application, we will not require any external library.
• So our code will be divided into three parts: first declaration of variables, pin definition and setup and the last main application logic.

Code declaration

• First, declare two arrays for rows and columns.
• In those arrays, we will store assigned pins for each row and column.
• As we are using D8 to D13 for columns, that will be stored in the “column” array and D2 to D7 for rows, similarly, that will be stored in the “row” array.

Void setup function

• This is one of the most important functions as per the structure of the Arduino sketch.
• As we are using the GPIO pins to control the LEDs, we will set the pin modes of LEDs to be in output mode.

? We have declared all the row and column pins in the output modes.

Void loop function

• In this function, we will write our main application code for our Christmas tree.
• Here we will write the interesting patterns to glow the LEDs of the tree.
• While making patterns, we only need to focus on two points, first, if we want to glow LEDs sequentially from rows, in this case, set all the pins of the column to logic HIGH state and if we want to glow the LEDs sequentially from columns then we need to set all the row to logic LOW state.
• Keeping the above-mentioned points, we can glow any pattern on our tree.
• For blinking the LEDs in a row-wise direction. We have to set all the column pins to HIGH state and then toggle the rows pin to HIGH-LOW.

• For blinking the LEDs in a column-wise direction. We have to set all the row pins to LOW state and then toggle the column pins to HIGH-LOW.

• To turn off all the LEDs, either set all the pins of columns and rows to logic HIGH or set all the pins of columns and rows to logic LOW.
• To turn off the LEDs by setting all column and row pins to a HIGH state.

• To turn off the LEDs by setting all column and row pins to LOW state.

• We can use either of the above-mentioned logic depending upon the next pattern.
• Using these simple logics, we can write various patterns.
• Here in this code, we have written some interesting patterns that would be easy to understand while running the code.

After completing the development side of the Christmas tree, it is time to test it.

Results and Working:

• As we have successfully completed the coding and the wiring part of our project, let's start the real fun of running it.
• In the Proteus, to run any application code, it requires a hex file of the application code.
• First of all, we need to generate the binary or hex file of our application code using the Arduino IDE.
• To generate the hex file, we need to go to the toolbar and then click on the “Sketch” option. Thereafter click on the “Export compiled binary”.
• After that, it will compile the code and a hex file will be generated.
• Now add this hex file to the Proteus project.
• To do so, click on the Arduino UNO module and go to the “Program File” option, then browse to the folder containing the hex file.

• Now we are all ready to test our project.
• Click on the “Play” button in the Proteus software.
• As per our code, first, all the LEDs will blink column-wise, after every 100 milliseconds of delay.
• Then all the LEDs will blink row-wise similarly after every 100 milliseconds of delay.
• After that, all the LEDs will be off and it will start glowing in the column-wise pattern from both sides towards the center.
• Thereafter, it will start glowing from the center towards the sides.
• Each row will glow and after that, all the LEDs will be off, thereafter each will blink sequentially.
• The working logic of this circuit is pretty simple. We just have to maintain the appropriate switching of the pins.
• Using the same we can have different types of interesting patterns.

Here is the working demo of our Christmas Tree

I hope we have covered all the points related to this project and you have enjoyed reading it. We can use this with the real component and decorate the Christmas tree or we can use some cardboard and insert the LEDs on them in the same way.

If you have any doubts regarding the project. And we will be glad to read about how you made your Christmas tree using this project and if you try any interesting new patterns with it, please let us know in the comment section.

Merry Christmas.

Servo Motor Control with ESP32 WebServer

Hello readers, we hope you all are doing great. In this tutorial, we are going to demonstrate how to interface and control a servo motor using an ESP32 board. After that, we will demonstrate how to create a webserver to control the servo motor’s shaft position with the ESP32 board.

Servo Motors are among the most important actuators in robotics, with applications ranging from RC planes to automated door locks.

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

Hardware components required

• A servo motor
• ESP32 development board
• Connecting wires
• Breadboard

Servo Motor

There are several specific types of electric motor applications in which the motor must rotate only at a specific angle. For such applications, we need a special type of motor with such a special arrangement that causes the motor to rotate at a specific angle for a given electric signal (input). The servo motor comes into effect for this purpose.

A servo motor is a linear or rotary actuator that enables accurate control of linear or angular position, acceleration, and velocity. It is made up of a motor and a sensor for position feedback. It also necessitates a fairly sophisticated controller, which is frequently a dedicated module designed specifically for use with servo motors.

Fig. Servo Motor

The primary reason to use a servo motor is that it offers angular precision, which means that it will only rotate as far as we want it to before stopping and waiting for the next signal to take action. The servo motor, unlike a standard electric motor, begins to turn as soon as we apply input power to it and continues to rotate until we turn off the power. We cannot restrict the rotational progress of an electric motor, but we can control its speed and turn it on and off. Small servo motors are included in numerous beginner Arduino launcher kits since they are simple to use in small electronic projects and applications.

Interfacing Servo Motor with ESP32

 

Fig. Interfacing Servo motor with ESP32

When compared to an Arduino, interfacing a servo motor to the ESP32 is extremely difficult because it does not support analogWrite(). However, it employs a variety of frequencies and timers, allowing all digital pins to be used as PWM pins and to send signals much faster than any Arduino.

Connections:

Servo motor consists of three wires;

Table 1 ESP32 and servo motor interfacing

Controlling servo motor

A servo motor is controlled by sending a PWM or pulse width modulated signal. A servo motor can only turn for a total of 180-degree movement (90 degrees in either direction).

The PWM signal sent to the motor specifies the position of the shaft, and the rotor will turn to the desired position depending on the duration of the pulse sent through the control wire.

Arduino IDE programming

We are using Arduino IDE to compile and upload code into the ESP32 module. To know more about Arduino IDE and how to use it, follow our previous tutorial i.e., on the ESP32 programming series.

• Installing Required Libraries
• Download the library from the given link:

https://github.com/RoboticsBrno/ServoESP32

• Open the Arduino IDE.
• Go to Sketch >> Include Library >> Add .ZIP library.
• Select the zip file you have downloaded from the above link.

Fig. Adding Library file

Arduino IDE Code

• We are using the example code that comes with the library file we have downloaded for the above link.
• To access the example code, go to Files >> Examples >> Servo ESP32 and select the required example code.
• In this tutorial, we are using a simple servo example code.

#include <Servo.h>

static const int servoPin = 4;

Servo servo1;

void setup()

{

Serial.begin( 115200 );

servo1.attach( servoPin);

}

void loop() {

for(int posDegrees = 0;

posDegrees <= 180;

posDegrees++)

{

servo1.write( posDegrees );

Serial.println( posDegrees );

delay( 20);

}

for(int posDegrees = 180;

posDegrees >= 0;

posDegrees--)

{

servo1.write( posDegrees);

Serial.println( posDegrees);

delay(20);

}

}

Code Description

• • The first task is adding the required library files or header files.

Fig. header file

• Define the GPIO pin which you are going to use for controlling the servo motor.

Fig. Defining Variables

• Create an object Servo, which is called

Setup()

• Inside the setup() function, the first task is to initialize the serial monitor with a 115200 baud rate for debugging purposes.
• Attach the GPIO pin you have assigned to the variable servoPin (in the global declaration) to the servo object.

Fig. setup function

Loop()

• As we mentioned earlier, a servo motor can only rotate between 0 to 180 degrees. So in this code, we are changing the position of the servo motor from 0 degree to 180 degrees and then back to 0 degree from 180 degrees.
• We have defined a variable postDegree to store the position or angle of the servo motor.
• We are using the for() loop, which will change the position of servo motor from 0 to 180 degrees.

Fig.

• Another for() loop is used to change the position back to 0 degrees from 180 degrees.

Testing

• Select the right development board from Tools >> Boards >> DOIT ESP32 DevKit V1 in Arduino IDE.
• Compile and upload the code into ESP32 using Arduino IDE.
• Open the serial monitor with a 115200 baud rate as defined in the Arduino code.
• Press the EN button from the ESP32 development board.
• Now you should see the servo motor’s shaft rotating as per the instructions provided.
• You can observe the variation on shaft’s angle on the serial monitor as well, as shown below:

Fig. Serial monitor output

Fig. ESP32 and servo motor

Creating a web server to control servo motor with ESP32

Let’s create a web server to control the position of the servo motor. We will create a web page containing a slider to control the angle/position of the servo motor’s shaft.

We have also created a tutorial on creating a simple web server with ESP32.

Arduino IDE Code

#include <WiFi.h>

#include <Servo.h>

Servo servo1; // create servo object to control a servo

// twelve servo objects can be created on most boards

// GPIO the servo is attached to

static const int servoPin = 13;

// Replace with your network credentials

const char* ssid = "SSID";

const char* password = "PASSWORD";

// Set web server port number to 80

WiFiServer server(80);

// Variable to store the HTTP request

String header;

String valueString = String(5);

int angle_x = 0;

int angle_y = 0;

// Current time

unsigned long currentTime = millis();

// Previous time

unsigned long previousTime = 0;

// Define timeout time in milliseconds (example: 2000ms = 2s)

const long timeoutTime = 2000;

void setup() {

Serial.begin(115200);

servo1.attach(servoPin); // attaches the servo on the servoPin to the servo object

// Connect to Wi-Fi network with SSID and password

Serial.print("Connecting to ");

Serial.println(ssid);

WiFi.begin(ssid, password);

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

delay(500);

Serial.print(".");

}

// Print local IP address and start web server

Serial.println("");

Serial.println("WiFi connected.");

Serial.println("IP address: ");

Serial.println(WiFi.localIP());

server.begin();

}

 

void loop(){

WiFiClient client = server.available(); // Listen for incoming clients

if (client) { // If a new client connects,

currentTime = millis();

previousTime = currentTime;

Serial.println("New Client."); // print a message out in the serial port

String currentLine = ""; // make a String to hold incoming data from the client

while (client.connected() && currentTime - previousTime <= timeoutTime) { // loop while the client's connected

currentTime = millis();

if (client.available()) { // if there's bytes to read from the client,

char c = client.read(); // read a byte, then

Serial.write(c); // print it out the serial monitor

header += c;

if (c == '\n') { // if the byte is a newline character

// if the current line is blank, you got two newline characters in a row.

// that's the end of the client HTTP request, so send a response:

if (currentLine.length() == 0) {

// HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)

// and a content-type so the client knows what's coming, then a blank line:

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

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

client.println("Connection: close");

client.println();

// Display the HTML web page

 

client.println("<!DOCTYPE html><html>");

client.println("<head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">");

client.println("<link rel=\"icon\" href=\"data:,\">");

// CSS to style the slider

// Feel free to change the background-color and font-size attributes to fit your preferences

client.println("<style>body { text-align: justify; font-family: \"Trebuchet MS\", Arial; margin-left:auto; margin-right:auto;}");

client.println(".slider { width: 600px; }</style>");

client.println("<script src=\"https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js\"></script>");

// Styling Web Page

client.println("</head><body><h1>Control Servo via ESP32</h1>");

client.println("<p>Angle: <span id=\"servoPos\"></span></p>");

client.println("<input type=\"range\" min=\"0\" max=\"180\" class=\"slider\" id=\"servoSlider\" onchange=\"servo(this.value)\" value=\""+valueString+"\"/>");

client.println("<script>var slider = document.getElementById(\"servoSlider\");");

client.println("var servoP = document.getElementById(\"servoPos\"); servoP.innerHTML = slider.value;");

client.println("slider.oninput = function() { slider.value = this.value; servoP.innerHTML = this.value; }");

client.println("$.ajaxSetup({timeout:2000}); function servo(pos) { ");

client.println("$.get(\"/?value=\" + pos + \"&\"); {Connection: close};}</script>");

client.println("</body></html>");

//GET /?value=180& HTTP/1.1

if(header.indexOf("GET /?value=")>=0) {

angle_x = header.indexOf('=');

angle_y = header.indexOf('&');

valueString = header.substring(angle_x+1, angle_y);

//Rotate the servo

servo1.write(valueString.toInt());

Serial.println(valueString);

}

// The HTTP response ends with another blank line

client.println();

// Break out of the while loop

break;

} else { // if you got a newline, then clear currentLine

currentLine = "";

}

} else if ( c != '\r' ) { // if you got anything else but a carriage return character,

currentLine += c; // add it to the end of the currentLine

}

}

}

// Clear the header variable

header = "";

// Close the connection

client.stop();

Serial.println("Client disconnected.");

Serial.println(" ");

}

}

Code Description

• Replace SSID and PASSWORD with your network credentials.

Fig. Variables to store Network credentials

• As we are creating a web server, we need to assign a port to it and normally we use port 80 for a local webserver.
• So, in the below code, we have assigned port 80 to the web server and then initialized a few variables:

Fig.

• header variable is used to store the HTTP requests.
• Variables angle_x and angle_y are used to store the position/angle of servo motor’s shaft.

Fig.

• Variables to store timer values for a delay of 2sec or 2000ms.

Fig.

Setup()

• Inside the setup() function, servoPin is being attached to the servo1 object.

Fig.

• Wi-Fi.begin() is used to initialize the ESP32’s wi-fi module.
• IP address of the device will be fetched once ESP32 is successfully connected to the wi-fi network.
• begin() function is used to initialize the webserver mode in ESP32.

Loop()

• After the webserver has been initialized successfully, the ESP32 server will be continuously waiting for the client connection.

Fig

• Once the connection is established between the access point and the client device, the access point will wait for the data input.
• A string type variable called currentLine has been defined to hold the incoming data from the client.
• If there is a byte to be read from the client, then it will be stored inside the char type variable

HTML to display a web page

• The ESP32 will respond to your browser with HTML (hypertext markup language) code that will be used to construct the web page.
• HTTP header always starts with a response code e.g.: HTTP/1.1 200 ok
• An HTML page will be created on the client’s browser, from where the client device can control the position of the servo motor.

Fig.

• The next line, which signals that we are transmitting HTML, should always be the first thing we send.
• Make the web page responsive in any web browser.

 

Fig.

• The next task is styling the webpage and the slider.
• The maximum and minimum angles are 180 and 0 degrees respectively.
• valueString variable is containing the current angle/position of the slider, fetched from the HTTP request.

Fig.

• Close the web connection and clear the header that was used to store the HTTP request header.
• Print information about the closed web connection on the serial monitor.

Fig. Close the connection

Testing

• Enter the Wi-Fi or network credentials in the code.
• Compile and upload the code into ESP32 using Arduino IDE.
• Make sure you have selected the right development board and com port before uploading the code.
• Open the serial monitor with a 115200 baud rate as defined in the Arduino code.
• Press the EN button from the ESP32 development board.

Fig. Serial Monitor

• Copy the IP address from the serial monitor.
• Open the web browser.
• Paste the IP address. A webpage to control the position/angle of servo motor will be displayed, as shown below:

Fig. Web Page

This concludes the tutorial. I hope you found this of some help and also to see you soon with a new tutorial on ESP32.

Capacitance Measurement using Arduino

Hello geeks, welcome to our new project. In this project, we are going to make a very useful and interesting electronics tool that we as engineers or tinkers need in everyday life. We use the capacitor in most of our projects for various purposes such as filters or power supplies. Most of the time, we do not have a provision to measure the capacitor value in our digital multimeter. So, this time we came up with the solution. Hence, we will make our own capacitance measurement tool using Arduino.

Rather than investing in new electronic equipment, we will use an Arduino board and some basic components to measure the capacitance. To make this project, we should have some working knowledge about the capacitor. Here, we will not discuss the in-depth working of capacitors, but we will talk briefly so that it would be easy to understand the working principle of our project.

The capacitor is an electronic component that basically stores the energy when applied to an electric field. It has two parallel terminals connected by two parallel conducting plates separated by a dielectric material. Dielectric materials are electrical insulators(resist to pass the current) that can be polarised by applying an electric field. When we connect a battery with the capacitor then due to potential difference, the electric field is created between two oppositely charged plates of the capacitor and this way the capacitor stores the energy.

Where To Buy?
No.	Components	Distributor	Link To Buy
1	Capacitor	Amazon	Buy Now
2	Resistor	Amazon	Buy Now
3	LCD 16x2	Amazon	Buy Now
4	Arduino Uno	Amazon	Buy Now

Software to install

To make this project, we will need some software to install. As we will make our project in the simulation, so for that we will install Proteus simulation software and for coding, we will use the Arduino IDE.

A brief about Proteus, it is a tool used for simulation and design of electronic circuits. Here we can design different types of electronic circuits and run the simulation. Although Proteus has a very big database for electronic components, still we need to install some libraries which we will use in this project.

• Arduino UNO - We have to install the library for Arduino UNO.
• LCD module - We have to install a library for the LCD module.

You can download this whole project for example Proteus Simulation and Arduino Code, by tapping the below button:

Capacitance Measurement using Arduino

Project overview

In this project, we will use the following components-

• Arduino UNO - We will use this as the main controller for this project. It will calculate the capacitance of the capacitor.
• 16x2 LCD Module - We will use this to show the result of measured capacitance and some user-related messages.
• Resistors and Capacitors - We will be using some resistors to make the RC circuit which is required for measuring the capacitance.

Now let's talk about the working of this project. The capacitance of any capacitor is the amount of charge that is stored in that capacitor and its unit is Faraday (F). To measure the capacitance, we will use some basic properties of the capacitor.

So when we connect a power supply with a resistor across the terminals of a capacitor, it will take a certain amount of time to fully charge. And when we connect any discharging resistor as a load across it, then it will take a certain amount of time to fully discharge. And this charging and discharging time will be proportional to the capacitance of the capacitor and the charging resistor in the RC circuit.

We will use the time constant formula for the calculation of capacitance. The time constant of any capacitor is known as the time taken by the capacitor to charge 63 percent of applied voltage or the time taken by the capacitor to discharge to 33 percent of stored voltage.

Here,

T (Tau) = Time constant(Seconds)

R = Resistance (Ohms)

C= Capacitance (Farads)

Using the above principle, we will charge the capacitor using a resistor to reach the charge of the capacitor to 63 percent of applied voltage and we will measure the time taken by the capacitor to reach that point. As we know the resistor’s value and time constant, using these two, we can calculate the capacitance:

Components required

• Arduino UNO
• 16x2 LCD module
• 10 kOhms Resistor
• 220 Ohms Resistor
• An unknown capacitor(Enter range here )

Components details

1. Arduino UNO

• Arduino UNO is an open-source development board that will be used to measure capacitance.
• It comes with 14 digital I/O pins and 6 analog I/O pins.
• It has 1 UART, 1 SPI, and 1 I2C hardware which are multiplexed with GPIO pins.
• Digital pins can be used for input and output for digital data. In this project, we have used digital pins for charging the capacitor.
• Analog pins have 10 bits of ADC (Analog to Digital convertor) resolution ranging values from 0 - 1023.
• Analog pins can be used for input and output purposes. In this project, we have used analog pins as input for measuring the discharge and charge voltage.

Note-Whenever uploading the code on the Arduino UNO, disconnect any wire which is connected to Rx(D0) and Tx(D1) pins, otherwise, it will give an error while uploading the code.

2. LCD Module

• LCD stands for Liquid Crystal Display, and its display is made using liquid crystal technology.
• For more knowledge of how LCD works, prefer this link Working of LCD display.
• We have used a 16x2 LCD display in this project.
• The LCD module works in two different data modes: 8-bit or 4-bit mode.
• We have used 4-bit mode which means we can send 4-bit data in a single cycle to the LCD module.
• We have used an LCD module to display the user-related information such as capacitance value and the welcome message.

3. Resistors and Capacitors

• Resistors, as the name suggests, is an electronic component that controls the flow of current in a circuit.
• Current flowing in any circuit is inversely proportional to resistance.
• They are used mostly in every type of electronic circuit for current limiting, voltage divider, and in some noise filters.
• There are various types of resistors available depending upon the current rating, manufacturing materials, and use case.
• Although we are making this project in simulation, if you want to make this project using the real components for that we will use the carbon composition through-hole resistors.
• Capacitors are electronic components that have the ability to store energy.
• When we connect any battery across the terminals of capacitors then it will start charging.
• We can store a large amount of charge for a very short period of time in capacitors.

Circuit diagram and Working

Now, we have a list of all the required components. Let's start connecting them.

• Make sure, we have the correct version of Proteus and have installed all the required libraries which we will be using in this project.
• Now let’s start creating the new project in the Proteus.
• Import the listed components to the workspace of Proteus.

• Now we have imported all the components to the workspace.

• First, connect the charging resistor of 10K ohms with the digital pin 8 of Arduino UNO and then connect the discharging resistor of 220 ohms with the digital pin 9 of the Arduino UNO.
• We will use the D8 pin for charging the capacitor and the D9 pin for discharging the capacitor.
• Now connect the capacitor which we want to measure in between these two resistors and connect another terminal of the capacitor with the ground.
• Connect an analog pin of Arduino UNO with the discharging resistor terminal and that analog pin will be A0 on Arduino UNO.
• After that, we are finished with our RC circuit.
• Let’s connect the LCD module with the Arduino UNO, as we are using the LCD module in 4 bits mode so we need to connect only four data pins with Arduino UNO.
• Connect D4 pin to D7 pins of the LCD module with D2 to D5 pins of the Arduino UNO.
• While connecting them, keep in mind that they must be connected in the same order.
• Connect the RS pin with the D6 and Enable pin with the D7 pin of Arduino UNO.
• Connect the RW pin with the ground which enables the write mode in the LCD module.
• Connect the 5v power supply with Vdd and Gnd pins of the LCD module.
• Now we have connected all the components.
• Before moving to the coding part, reverify your connections once.

While working on the real components, make sure you have connected the backlight of the LCD module and set the contrast properly otherwise nothing will be visible on the LCD module.

Arduino code of Capacitance measurement-

Downloading and including libraries

• This project will need the library for the LCD module.
• Before going to write, we must download and include all the required libraries.
• We can download the library for the LCD module using this link LCD module library.
• To include the library, go to the Sketch >> Include Library >> Manage Libraries… Using this, we can add libraries directly by searching the window.
• Or if you have downloaded the library using the link then you will have a zip file for the library. In this case, follow this path: Sketch >> Include Library >> Add .Zip Library…

• After downloading the library, we are all set to start our code.
• First, include the LCD library header at the start, make an object for the same, and declare all the pins which are used for the LCD module.

Variable declaration

• Now we will declare all the variables and pins which we are going to use in this project.
• Declare the charging pin, discharging pin, and an analog pin for measuring the charging voltage as 8,9 and A0 respectively.
• Declare variables to store the start time, stop time, and a variable to store the duration.
• Declare a function “measure()” which will read the analog values.

• After the declaration, we will define a function “measure()”.
• We have defined this at the end of the code.

• This function will read the analog values from the pin and return the values for the same.

• Here, we have declared and defined the function separately but we can define the function without declaring it, but it is not a good practice to do so and sometimes that will cause errors in the code also.

Void setup()

• After declaring all the required variables, we will start writing the “void setup()” function.
• This is a built-in function in the structure of the Arduino sketch.
• We can write any code without this function. As per the structure of the Arduino sketch, this function must be in the code.
• In this function, we will write the pin mode and initialization of other peripherals which will be required in the code.
• This function will only run once when the code starts.
• So in this function, we will first begin the LCD module and print the instructions to use.
• Then set the pin mode of pins and the initial state of the pins.

Void loop()

• This is also a built function of Arduino sketch.
• As per the structure of the Arduino sketch, we can not delete this function from the code even though we don’t have anything to write in this.
• This function executes after the “void setup()” function.
• In this function, we will write our main code which we want to run continuously.
• As the name suggests this will run in a loop.
• Initially, when there is no capacitor connected then the analog value will be in the maximum range and that is 1010 to 1030.
• So now, we will display the message that ‘place a capacitor’ and code will be in a while loop until we connect any capacitor to the circuit.

• Now when we connect any capacitor, the above condition will be unsatisfied, then code will enter in a next infinite while and there we will write the process of charging and discharging of capacitor and time constant.
• First, we will discharge the whole capacitor, for that we will run a while loop, and using the measure() function, we will measure the currently stored voltage in the capacitor.

• And when the stored voltage reaches below or equal to the threshold, we will change the pin mode of pins to start charging the capacitor again and store the start time of charging.
• Using the measure() function, monitor the charging voltage in the capacitor and when the stored charge reaches 63 percent which is 648 of 1023 then we will stop the charging and store the stop charging time also.
• And display the charging percent on the LCD module.

• Now calculate the total time taken by the capacitor to reach the 63 percent of charge and that will be the time constant of the capacitor.
• Using the time constant formula, we can calculate the capacitance of the capacitor as we know the charging resistor connected to the capacitor.

• As we know the charging resistor value is 10k ohms, using that when we divide the time taken by the resistor value, then we will get the capacitance.
• And the calculated result will be displayed on the LCD module for 3 seconds, after that code will enter in an infinite while loop.
• Now we have to reset the device to measure any new capacitor value.

• Here, our coding part will be completed, it is time to test our code with the circuit and now we will move to the next section.

Results and Working

• As we are going to test our project in the Proteus simulation, we have to include the hex file of our code in the Arduino UNO module.
• The first step is to generate the hex file of the code.
• Click on the Arduino UNO module in the Proteus then browse to the location of the generated hex file.

• After adding the code, we are ready to run the simulation and click on the Play button to start the simulation.
• First of all when the code starts, on the LCD module, we will show the range of capacitance that can be measured using this device and the message to place the capacitor if it is not placed already.

• When the capacitor is placed, then the discharging process will start to eliminate any pre-stored charge in the capacitor, thus we will get the more accurate value.

• After 100 percent discharge, the charging process will start and it will go to 63 percent of the stored charge.

• Thereafter, the code will calculate the capacitance using the time constant formula, and the result will be displayed on the LCD module with the message to reset the device to measure again.

• After the compilation of the simulation, click on the stop button to stop the running code.

I hope we have covered all the points related to this project such as circuit diagrams, codes, and working simulation. And I think this will be a very useful project for your daily tinker life. Please let us know if you face any difficulties while making this project in the comment section below.

We will be happy to hear if you will make this project used in your projects.

Thanks for reading this article. All the best and see you in the next project.

Accessing ESP32 Dual Core

We are familiar with multiple features of the ESP32 module. Like Wi-Fi capabilities, classic Bluetooth, Bluetooth low energy (BLE), inbuilt sensors etc.

Hello readers, I hope you all are doing great. We have already mentioned in our previous tutorials that, ESP32 is also featured with a Dual-Core Processor. Which provides better performance and efficiency.

In this tutorial, we will learn how to use ESP32’s dual cores. ESP32 has two (32-bit each) Tensilica Xtensa LX6 microprocessors namely, core0 and core1 which makes it a powerful dual-core microcontroller and hence stands apart from its predecessors.

When we compile and upload a code using Arduino IDE, we do not have to worry about which core executes the code. It just runs.

Fig. 1 ESP32 dual-core processor

Features of Dual-Core processor

• Power Efficiency: A single-core processor can rapidly hit 100% of its workload. On the other hand, a dual-core processor allows the efficient allocation of resources with a multitasking environment.
• Increased Performance to Multithread Programs: Aside from being able to run multiple programs at the same time, dual-core processors can also collaborate to make a single program faster and more efficient. Multithreading allows programmers to send different instructions from the same program into two processing paths. On a single processor with hyper-threading, the program is still limited to the single core's maximum processing speed. However, on a dual-core, this effectively doubles the speed available to that program.
• Two programs running simultaneously: Two cores allow two programs to run at the same time. The many complex calculations that a computer must perform to create the average browsing experience are difficult to quantify; however, single-core processors only create the illusion of multitasking through technologies such as hyper-threading.

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

FreeRTOS in ESP32

A FreeRTOS (real-time operating system) firmware is already available in the ESP32 module. FreeRTOS is helpful in improving the system performance and managing the resources of the module. FreeRTOS allows users to handle several tasks like measuring sensor readings, making a network request, controlling motor speed etc. all of them run simultaneously and independently.

FreeRTOS offers multiple APIs for different applications. Those APIs can be used to create tasks and make them run on different cores. You need to create tasks to assign a particular part of code to a specific core. You can also prioritize that on which core the code will run. Priority value starts with level_0.

Accessing ESP32’s both cores using Ardui1no IDE

Whenever we run a code on Arduino IDE, it runs on core_1 by default.

• How to check on which core the code is running?

There is a function you can use to check on which core the code is running on.

xPortGetCoreID()

Run the following code in Arduino IDE:

void setup()

{

Serial.begin(115200);

Serial.print( " setup() is running on: Core_" );

Serial.println( xPortGetCoreID() );

delay(1000);

}

void loop()

{

Serial.print( " loop() is running on: Core_" );

Serial.println( xPortGetCoreID() );

delay(1000);

}

• Open the serial monitor with a 115200 baud rate.
• Press the EN button from the ESP32 development board.

Fig. 2 Serial Monitor

From the results on the serial monitor, you can see that both setup() function and loop() function are running on core_1.

Steps to be followed to create a task are:

• Create a task handle to keep a track of the task created. For example, a task handle named task is created below:

Fig. 3

• Inside setup() function, create a task assigned to a specific core. xTaskCreatedPinnedToCore() function is used to create a task assigned to a specific core.

This function takes seven arguments:

1. Name of the function to implement the task
2. Name of the task
3. Stack size assigned to the task in words (where 1 word = 2 Bytes)
4. Task Input parameter
5. Priority of the task
6. Task handler
7. Core where the task should run

Fig. 4

• Create a function that contains the code for the task you have been created.

For example, we have created a function named task_code(). Inside the task_code() function a for(;;) loop is used which will create an infinite loop. All the instructions to be given for a particular core to perform a particular task like led blinking, sensor readings etc. will be written inside this for(;;) loop.

Fig. 5

• How to delete the created task, during the code execution?

You can use the function vTaskDelete() during the code execution to delete a task. This function takes the task handle (task) as an argument.

• Code for creating and assigning the separate task to each core

In this code we will use two LEDs to be processed by different core.

TaskHandle_t task1;

TaskHandle_t task2;

// Assign GPIOs pins to LEDs

const int led1 = LED_BUILTIN;

const int led2 = 25;

void setup() {

Serial.begin(115200 );

pinMode( led1, OUTPUT );

pinMode( led2, OUTPUT );

//create a task that will be executed in the Task1code() function, with priority 1 and executed on core 0

xTaskCreatePinnedToCore(task_1code, // Task function.

"Task1", // name of task.

10000, // Stack size of task

NULL, // parameter of the task

1, // priority of the task

&task1, // Task handle to keep track of created task

1); // pin task to core 1

delay(1000);

//create a task that will be executed in the Task2code() function, with priority 1 and executed on core 1

xTaskCreatePinnedToCore(task_2code, //Task function.

"task2", //name of task.

10000, //Stack size of task

NULL, //parameter of the task

1, //priority of the task

&task2, //Task handle to keep track of created task

0); //pin task to core 0

delay(1000);

}

//task_1code: blinks an LED every 1000 ms

void task_1code( void * pvParameters ){

Serial.print( "task1 running on: core " );

Serial.println( xPortGetCoreID() );

for(;;)

{

digitalWrite( led1, HIGH);

delay(1000);

digitalWrite(led1, LOW);

delay(1000);

}

}

//task_2code: blinks an LED every 500 ms

void task_2code( void * pvParameters )

{

Serial.print( "task2 running on: core " );

Serial.println(xPortGetCoreID() );

for(;;){

digitalWrite(led2, HIGH );

delay(500);

digitalWrite(led2, LOW );

delay(500);

}

}

void loop()

{

Serial.print( " loop() is running on: Core " );

Serial.println( xPortGetCoreID() );

delay(1000);

}

Code Description

• We have created two task handle to keep track of two different tasks created for each core. Task1 is for core_1 and task2 is for core_0.
• Although we do not need to create a new task and a task handle for core_1 because the void loop() function be default run on core_1 but for better understanding we are creating a different task for each core.

Fig. 6

• Allocate GPIOs to the LEDs. Led1 is the inbuilt one that is connected with GPIO2 (internally) and another one is led2 to be connected with GPIO 25.

Fig. 7

Setup()

• Initialize the serial monitor with a 115200 baud rate for debugging purposes.
• Set the mode of LEDs as OUTPUT.

Fig. 8 setup() function

• Create a task (task1) using xTaskCreatePinnedToCore() This task will take seven parameters which include; the task function namely task_1code(), name of the task, stack size of the task, priority level, task handle (if created), core to which you want to assign the task.

Fig. 9

• Create a similar task for another core. We will create a different function for this task namely task_2code() and will pass task_2 as a task handle and the core selected is

Fig. 10

• The next step is to create functions to execute the above task for each core.
• task_1code() function is passed as a parameter in
• xPortGetCoreID() function is used to fetch the core number on which the current function is running on.
• This function will make the inbuilt LED (GPIO2) or led1 blink with a delay of 1 second or 1000msec.
• This for(;;) loop will make led1 blink continuously which is similar to the instructions executed inside loop() function.
• print() function is used to print the results on the serial monitor for debugging purposes.

Fig. 11

• task_2code() function is called for task2.
• This code will be executed in core0.
• Led2 (GPIO25) will blink continuously with a delay of 0.5sec.

Fig. 12

• Inside the loop function we called the xPortGetCoreID() function to get the core number which is responsible to execute the instructions written inside loop() function

Fig. 13 loop function

Testing

Components required:

• ESP32 development board
• Breadboard
• 2*Jumper wires
• 1*LED
• 1*resistor(330 ohms)

Steps for testing:

• Connect the LED with ESP32 as shown below:

Fig. 14 connecting LED with ESP32

• Upload the code into the ESP32 development board.
• Open the serial monitor with a 115200 baud rate.
• Press the EN from the ESP32 development board.
• Results observed from the serial monitor are shown below:

Fig. 15 Results on the serial monitor

• On the serial monitor, we can see that task1 functions are processed by core 1 and task2 is processed by core 0.
• We have already mentioned that core1 is the default processing core so instructions inside the loop() function are processed by core1.

This concludes the tutorial. We hope you found this helpful and also hope to see you soon with a new tutorial on ESP32.

Sending Sensor Readings to Google Sheet Through IFTTT using ESP32

Hello readers, I hope you all are doing great. In our previous tutorial, we learnt how to make HTTP POST from ESP32 to the IFTTT server.

In this tutorial, we will learn about another application of the ESP32 module in the field of IoT (Internet of Things). We can publish multiple sensor readings from ESP32 to Google sheets via the IFTTT web service.

IFTTT is used as a third-party web service to integrate Google sheets with ESP32.

Fig. 1

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

Creating an IFTTT Account for Integrating ESP32 with Google Sheets

We are going to create an applet (on the IFTTT server) that is responsible to integrate the Webhooks and Google Sheets services.

While operating with the IFTTT server there are some services/utilities that we are going to deal with like Applets and Webhooks. Before getting started with the project, let’s first introduce you to those terms:

Applet

An Applet is a small application or a utility program, which is used for one or a few simple functions. It connects two or more devices or apps together. An applet provides integration between two devices or services to enable some functionality that those devices or services cannot do alone or on their own. An applet consists of actions and triggers.

Fig. 2

Webhooks

• Webhooks are hypertext transfer protocol (HTTP) callbacks that are defined by the user. They are data and executable commands sent from one app to another over HTTP rather than through the computer's command line. Essentially, it is a method for apps to send automated messages or information to other apps.
• When an event occurs on the "trigger" application, the app serializes the data and sends it to a webhook URL from the "action" application (the app that processes the data from the "trigger" application). After that, the active application can send a callback message.

Getting Started with IFTTT:

1. Enter the following link in the web browser: https://ifttt.com
2. Login with your Gmail or Facebook accounts for free.
3. Click on Create icon (top left menu) to create an

Fig. 3: Creating an Applet

4. Click on the ”if This” icon.

Fig. 4: “If This”

5. Select a service. Search for the Webhooks service and select the respective icon.

Fig. 5: Search and Select Webhooks

6. Click on the Receive a web request option to select a trigger option. The trigger will fire every time the maker service receives a web request to notify it of an event.

Fig. 6: Receive a Web Request

7. Assign a name to the trigger event and click on Create trigger We have assigned ESP32_GoogleSheets.

Fig. 7: Create Trigger

8. Next, click on the “Then That”

Fig. 8:  Then That

9. To select the service, search for the Google Sheets service and click on the respective icon.

Fig. 9:  Google Sheets

 

10. The next step is selecting an action, click on Add row to the spreadsheet

Fig. 10: Select an Action

11. Click on the connect button to connect with the Google Sheet service, if you haven’t connected to it yet.

Fig. 11: Connect to Google Sheets Service

12. A new window will pop up, where you need to log in with your Gmail account.
13. Enter your Gmail account address and password.
14. Click on Allow icon, (as shown below) to allow the IFTTT web service to access files from your Google drive. So that IFTTT can create new folders or update details in the existing Google drive folders with new sensor readings.

Fig. 12: Allow IFTTT Service to Access Files of your Google Drive

15. Finally, complete the action field by assigning the name to the spreadsheet and path the folder in Google drive. Leave the Formatted row as it is (default).
16. A folder named IFTTT will be created by default if you leave the above fields empty.

Fig. 13: Complete Action Fields

17. Click on the finish

Fig. 14: Applet Successfully Created

Testing the Applet

Before interfacing the IFTTT service (applet) with ESP32, let us test the applet whether it is created successfully or not.

1. Open the following link: https://ifttt.com/maker_webhooks
2. Click on the Documentation

Fig. 15

• A new window will open containing your key (API).
• Enter the details in To trigger an Event and click on Test it.

Fig. 16: Test your Applet

• Open your Google drive.
• You should see a folder (named IFTTT ) in your Google drive.
• Open the folder to see the values received from the IFTTT server.

Fig. 17:  IFTTT Folder in Google Drive

 

Components Required:

• ESP32 development board.
• USB cable to connect to ESP32 development board with the computer.

No external components are required as we are using the ESP32’s inbuilt sensors to take the readings.

 

Arduino IDE code

Let’s have an overview of the project before writing the Arduino code:

• To access the internet, the ESP connects to the local Wi-Fi network.
• Then, the Hall sensor will take the readings;
• Your ESP32 will communicate with the IFTTT Webhooks service that publishes the readings to a spreadsheet on Google Sheets that is saved in your Google Drive’s folder.
• After publishing the readings, the ESP goes into deep sleep mode for 15 minutes;
• After 15 minutes the ESP wakes up;
• After waking up, the ESP connects to Wi-Fi, and the process repeats.

• We are using Arduino IDE to compile and upload into the ESP32 module. To know more about Arduino IDE and how to use it, follow our previous tutorial i.e., on ESP32 programming series.

#include <WiFi.h>

// Replace with your SSID and Password

const char* ssid = "SSID";

const char* password = "Password";

// Replace with your unique IFTTT URL resource

const char* serverName = "https://maker.ifttt.com/trigger/replace_this_with_eventName/with/key/replace_this_with_your_unique_key ";

// Maker Webhooks IFTTT

const char* server="maker.ifttt.com";

//----Timer for sleep

uint64_t uS_TO_S_FACTOR = 1000000; // Conversion factor for micro seconds to seconds

uint64_t TIME_TO_SLEEP = 900; //sleep for 15 minutes

 

void setup()

{

Serial.begin(115200);

delay(100);

Serial.print("Connecting to: ");

Serial.print(ssid);

WiFi.begin(ssid, password);

int timeout = 10 * 4; // 10 seconds

while( WiFi.status() != WL_CONNECTED && ( timeout-- > 0) )

{

delay(200);

Serial.print(".");

}

Serial.println(" ");

if(WiFi.status() != WL_CONNECTED )

{

Serial.println(" Failed to connect, going back to sleep ");

}

Serial.print("WiFi connected in: ");

Serial.print(millis());

Serial.print(", IP address: ");

Serial.println(WiFi.localIP());

makeIFTTTRequest();

// enable timer deep sleep

esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);

Serial.println("Going to sleep now");

esp_deep_sleep_start(); // start deep sleep for 900 seconds (15 minutes)

}

 

void loop()

{

// sleeping so wont get here

}

void makeIFTTTRequest()

{

Serial.print("Connecting to ");

Serial.print(server);

WiFiClient client;

int retries = 5;

while(!!!client.connect(server, 80) && (retries-- > 0))

{

Serial.print(".");

}

Serial.println();

if(!!!client.connected())

{

Serial.println(" Failed to connect... ");

}

Serial.print(" Request server: ");

Serial.println( serverName );

// Hall sensor values

String jsonObject = String("{\"value1\":\"") +

hallRead() +

"\",\"value2\":\"" + hallRead()

+ "\",\"value3\":\"" +

hallRead() + "\"}";

client.println(String("POST ") + serverName + " HTTP/1.1");

client.println(String("Host: ") + server);

client.println("Connection: close\r\nContent-Type: application/json");

client.print("Content-Length: ");

client.println(jsonObject.length());

client.println();

client.println(jsonObject);

int timeout = 5 * 10; // 5 seconds

while(!!!client.available() && (timeout-- > 0)){

delay(100);

}

if(!!!client.available()) {

Serial.println("No response...");

}

while(client.available()){

Serial.write(client.read());

}

Serial.println("\nclosing connection");

client.stop();

}

Code Description

• Add the required header files.
• WiFi.h header file is used to enable the Wi-Fi module and its respective functions.

Fig. 18:  Library Files

• Enter the network credentials, SSID and Password.

Fig. 19:  Network Credentials

• Add the IFTT domain name, the event name (you have created) and the API key. The event name we have created is ESP32_test.

Fig. 20

• IFTTT Server URL.

Fig. 21

• Time_To_Sleep variable is used to set a timer (sleep time) of 15 minutes (900 sec). ESP32 processor will wake up from sleep mode after every 15 minutes to take the sensor readings and publish them to Google Sheets.
• uS_To_S_Factor is used to store the conversion value for converting the timer unit from microseconds to seconds.

Note: The ESP32 sleep time should not be very short. A very short sleep time can result in the exceeded limit of requests imposed by the IFTTT service.

Fig. 22: Timer

 

Setup()

• • Initialize the Serial monitor with a 115200 baud rate for debugging purposes.

Fig. 23:  Serial Monitor

• Enable ESP32’s Wi-Fi module using begin() function which is using SSID and password as arguments.
• Wait until the ESP32 is not connected to the Wi-Fi network.
• Fetch the IP address using WiFi.localIP() function.

Fig. 24:  Wi-Fi

• makeIFTTTRequest() function is used to connect ESP32 with the client server.

Fig. 25

• esp_sleep_enable_timer_wakeup() function is used to enable the timer for sleep mode.
• The duration of sleep mode is passed as an argument inside the timer function.
• Esp_deep_sleep_start() function is used to start the sleep mode.

Fig. 26

• The below code represents the process happening inside the makeIFTTTRequest()

Fig. 27

• ESP32 connects to IFTTT serve and then communicates with the server (IFTTT) through port 80.
• ESP32 tries 5 times to connect to the server and if it couldn’t then it will enter the sleep mode.

Fig. 28

• jsonObject variable is used to store the sensor data to be shared to the Google Sheets via the IFTTT server.
• We are using ESP32’s inbuilt Hall sensor to take the readings.
• This variable will take three sensor values and ESP32 will communicate the readings to Google Sheets.

Fig. 29

• Connection with the server will be closed once the data is shared successfully and ESP32 will enter to sleep mode form next 15 minutes.

Fig. 30

Testing

• Select the right development board in Tools >> Boards >> DOIT ESP32 DevKit V1 in Arduino IDE.
• Compile and upload the code into ESP32 using Arduino IDE.
• Make sure that you have entered the right Wi-Fi credentials, API key and event name before uploading the code.
• Open the serial monitor with a 115200 baud rate as defined in the Arduino code.
• Press the EN button from the ESP32 development board.
• Go to your Google drive.
• You should see a folder (named IFTTT ) in your Google drive.
• Another folder will be there inside the IFTTT folder (named as ESP32_hall sensor readings, in our case)
• Open the folder to see the values received from the IFTTT server.
• The spreadsheet will be updated after every 15 minutes. If you press the EN button before completing the sleep duration(15 minutes), the spreadsheet will be updated automatically with new sensor data, as shown below:

Fig. 31: Hall Sensor Readings on Google Sheets

Fig. 32: Serial Monitor

This concludes the tutorial. I hope you found this of some help and also to see you soon with the new tutorial on ESP32.

Key Steps To Improve Health And Safety In Industrial Workplaces

Industrial workplace health and safety are essential for avoiding work-related accidents, injuries, and fatalities. In fact, as many as 13,455,000 workers across manufacturing industries in the US are at risk for fatal and nonfatal injuries, the CDC reveals. Not only does improving workplace health and safety protect workers, but it also prevents lost work days and lost revenue. The National Safety Council found work injuries cost businesses a total of $161.5 billion annually, equating to $1,100 per worker.

Improve employee training

New workers are three times more likely to sustain an injury in their first month than workers with a year's experience on the job. By improving employee training and tailoring programs to the demands of each individual role, you can better minimize the risk of accident and injury (a lab employee, for instance, requires vastly different training to an industrial line worker). In fact, OSHA advises implementing different plans for five key areas in order to form a comprehensive health and safety approach: hazard assessment; hazard mitigation; hazard prevention; electrical safety; and safety training. Additionally, it’s important to provide refresher training sessions on a regular basis. Never make health and safety training a one-time occurrence. By reiterating health and safety information and advice throughout the year, you can ensure workers maintain awareness of best practices.

Implement a health and safety management system

A health and safety management system is essential for identifying and resolving workplace hazards and protecting workers, as well as improving overall operational performance. In fact, it can reduce total costs arising from occupational injuries by at least 20-40%. To devise your system, OSHA recommends first identifying any health and safety issues, including, risks and hazards, management system deficiencies, and opportunities for improvement, and then prioritizing those issues. You can then determine the goals of your health and safety management system in order to maximize workplace safety and minimize risks. If an employee does sustain an injury while on the job, it’s important they inform themselves of their legal rights. Filing a lawsuit for personal injury damages can help injured employees secure financial compensation to cover the cost of medical bills and lose income, Aaron Allison Law explains.

Incentivize compliance

By incentivizing compliance, you have a better chance of ensuring your employees adhere to health and safety standards. Industrial workplaces often involve high-risk activities dealing with heavy machinery, electrical tools, and toxic chemicals on a daily basis. As such, employees can easily become too comfortable and lax, which results in potential injury or death. Incentivizing compliance could, for example, involve rewarding employees or managers when they achieve pre-set health and safety goals. Similarly, examples of non-compliance with rules and guidelines should also be corrected.

Health and safety should be a priority in all industrial workplaces. By improving employee training, implementing a health and safety management system, and incentivizing compliance, you can keep your workplace as safe as possible for employees.