The evolution of technology over the decades has helped almost all sectors to grow and flourish. And, the medical sector is no different. The way medicine was practiced a couple of decades ago has been completely changed today. This has obviously brought in multiple benefits to the patients. The treatment time has lowered and so has the accuracy increased. People now trust technology to get their treatments done.
This article highlights certain technologies that have transformed modern medicine.
Electronic health records
This is the prime example of how technology has transformed the way of conducting treatments and keeping records. The paper filing system of patients is now long gone. It is now replaced with electronic record-keeping. This has made collaboration easier and smoother and facilities can focus better on patient care now. The entire medical history of patients is available in just a click and doctors can make better and detailed decisions about their treatment plan.
Personalized treatment
This is yet another great way by which technology is driving healthcare. With the evolution of wearable technology, patient engagement has increased more than ever. And, more healthcare facilities are trying to connect with their patients through these hyper-targeted and extremely personalized health and fitness plans. The data that is driving the results is extremely accurate and the recommendations are loved by the patients. The technology tries to understand every individual motivation and design solutions that reflect well with their lifestyles and that are manageable on both ends.
Telehealth
Virtual healthcare or telehealth was there initially also but it gained popularity pretty recently after the outbreak of the global COVID-19 pandemic. It has increased the communication efficiency between the clinics, healthcare providers, and the patients who are seeking help. The information exchange has become simpler and one can easily track and monitor the changes that are visible after every telehealth interaction. The data is optimized and your treatment is curated across a stable plan of action.
Surgical technology
Surgeries are equally benefited through this progressive technology. It is now possible to draw virtual 3D reconstructions before any major surgery on trauma patients. It helps the surgeons to make the most accurate incisions on the skin and have bony reconstruction with plates. This is a great way to plan the surgeries and monitor the flow of blood in those regions. We are hopeful the future will see more advanced improvements in this field to help the surgeons.
AI and augmented reality
When both of these are combined, many new opportunities arise. There are handheld devices that use both of these technologies to make veins in a patient's body visible. They also help the doctors to sense heat by just using a single device. The combination of both these technologies improves the activities like drawing blood or IV insertions.
Besides these, there are many other innovations in health care devices that have streamlined the treatments to a great extent while helping the industry move forward. The patients can now confidently rely on the system for their treatments.
If you want to monitor the utility usage in real-time and if you want to optimize the business utilities, you should make use of the energy monitoring system. It is the software that monitors the utility consumption online like the energy, fluids, gas, and so on. This system helps to calculate the consumption per area like the departments and production lines. It also helps in calculating the consumption per the production like the orders and the items that further helps in calculating the real production cost. With the help of the best type of energy monitoring tool, you can forecast the energy usage in several sectors and then create the alarm if it finds that the site has reached the contractual capacity.
The energy management system will further help detect the failures in the process, leaks or anomalies, and provide information on how much the utilities are used during the non-production time. After assessing the data offered by this tool, you can decide to depend upon the real data and then collate the production data with the utility usage. You can get the best energy monitoring software online, one of the best places to get tools for energy management and monitoring for businesses.
Benefits of using the Energy Monitoring System
There Are Various Benefits Of Using This Tool, And They Are-
Lower the utility usage
Detecting the utility waste
Précising the forecast on the utility usage
CO2 footprint awareness
Reduce the downtime
Improve the OEE of the functioning
Make decisions depending upon the real-time data from the machines
Features Of Energy Monitoring System
As said before, Energy checking frameworks give clients information about their utilization designs so they can settle on informed energy the board choices and expand investment funds. It is completed utilizing energy observing programming that accumulates energy utilization information, dissects it. Afterward, gives valuable data straightforwardly to the customer's gadget.
The product utilizes counters or sub-counters situated nearby or in the structure to accumulate information for every item (power, heat, water, gas) to give a total image of energy utilization. Because of these energy observing methods, clients can monitor the amount they are devouring. They can also monitor how the item is utilized at some random season of day or night.
Keeping all the utilities under control
EMS framework focuses on unlimited authority over the Utilization and cost of utilities in the processing plant. Counters cautions and controlling dashboards give the client the likelihood of dealing with the utilities. They are also expected in all pieces of the processing plant – from the creation floor to workplaces. Relationship with creation information takes into consideration full examination and straightforwardness of the actual production costs. Dynamic checking upholds the identification of holes and misuse of utilities that can be not entirely obvious and fixed.
Determining the Utilization per area
It helps to analyze all utilities in the current location with detailed information on planned and actual usage. It also helps in displaying trends and forecasts.
Compare the utilities and consumers
Information on utility utilization can get a connection with creation information, showing a precise image of complete creation and non-creation costs.
Make use of Power Guard
It is a tool for controlling the total amount of electrical power used to avoid the expensive penalties for breaching or crossing the limits. With the help of tracking the system, it issues warnings on the incoming faults with the proper advance.
Choose the EMS or the energy monitoring system, an advanced solution for monitoring energy consumption. In addition, it allows for the implementation of additional software like the contracted capacity guard. Choose EMS for the higher energy management at the workplace.
Choosing a prototyping firm to manufacture your things is a crucial decision. Identifying the right match is a difficult task for any firm. Cost, effectiveness, dependability, and operational processes must all be considered before assigning any production assets.
Dealing with a prototyping firm should be straightforward once you learn what to look for. The following are important considerations to consider while looking for a producer to help you bring your prototype idea to life.
Familiarity with the Business
You can look through the portfolios of the best prototyping businesses to see their previous work. This data is crucial in determining whether they have experience with similar initiatives and specialize in your required prototypes.
You'll need a corporation with experience in your sector throughout this early stage of product development. They are more knowledgeable about the resources to utilize, the equipment that can be employed to make the finished output, and they are conversant in industry jargon.
Working with organizations that specialize in modeling will make the production process much smoother.
The Available Services
You might need a simple 3D printing concept part right now, but you could require a perfectly functioning prototype for a trade show or business meeting tomorrow. It's vital to know whether your prototyping partner can handle many tasks.
Enquire about the many sorts of 3D printing services offered and just about every other service that may be accessible. Determine what kind of finishing services they provide, such as smoothing, polishing, and laser engraving.
A reputable specialist will have both current and 'traditional' talents, such as SLA and Vacuum Casting solutions, and other 3D printing services and a CNC suite if you select them.
Full-cycle prototyping competences
If you're working with complex or advanced prototypes that involve several production processes such as CNC machining and plastic injection molding, a prototyping company should ideally have all of the design development they'll use to manufacture your prototypes under one roof.
Why? You don't have to squander weeks or months working with a modeling company that collects all of your model's components from numerous vendors and then assembles them before delivering them to you. This is a worthless exercise that you almost certainly do not have.
Manufacturing your product by a unified prototyping company addresses both of these potential difficulties by providing for quick alterations and hiring integrated and comprehensive specialists who can supervise all areas of the design process.
Another benefit of engaging with a consistent, reputable prototyping company that can provide all of the prototyping solutions you need under one roof is IP protection.
Your ideas are more likely to get robbed if a lot of people see them. Collaboration with a lone prototyping company means fewer eyes on your concepts and a lower risk of a vital file ending in the wrong hands.
Speed
To maintain a competitive advantage, prototypes must be released into the market considerably more quickly. As a result, you must only hire a firm with a trained workforce of design professionals who can work rapidly and get concepts to market.
If you wish to obtain a competitive advantage, you must meet this criterion. To produce models in a matter of days, the leading rapid prototyping businesses rely on their innovative technologies. As a result, if your prototyping firm fails to fulfill timelines, you should hunt for a new supplier.
Inquire about the company's ability to act quickly to orders throughout product innovation, market launch, or implementation stage. Few companies also offer rapid prototyping.
Cost
Consider cost in mind while choosing a prototype manufacturer. Prototyping prices vary from one prototyping company to another, as you may be familiar with. Some companies charge per hour, while others charge per order.
It's vital to remember that the manufacturing process and materials used also influence the pricing. The complexity of the design may also have an impact on prototyping expenses.
Before engaging in prototyping solutions and services, make sure you understand the cost split. While at that, you can request a CNC instant quote as it will help you have a plan in place.
Help with Design
If you're an entrepreneur, or if this is your first time working with a prototyping firm, you may not have been an expert in most production procedures. Consequently, while choosing a production provider, please make certain that they provide continual information and coaching.
A reputable prototyping company should constantly provide you with advice, information, and choices for the greatest materials to use and the ideal technique to follow. Consequently, if you're unclear about which methods to employ, it's not a bad idea to seek advice from the company.
Conclusion
Selecting the right company may impact how much money and work you put into the entire production cycle. Please do your research to confirm that they meet the required standards.
Hello readers, I hope you all are having fun in your lives. Welcome to the 2nd Chapter of Section-2 in the ESP32 Programming Series. In today's lesson, we'll go over another built-in feature of the esp32 module that helps it stand out from the competition: BLE or Bluetooth Low Energy.
In the previous tutorial, we discussed the Classic Bluetooth in ESP32, which is considered the predecessor of Bluetooth Low Energy(which we are going to discuss today). We will first look at, what is BLE? and why is it used?, and then will design some examples to utilize the ESP32 BLE in Arduino IDE.
There have been numerous adjustments and upgrades to Bluetooth's characteristics since its inception, where Bluetooth 4.0(also called BLE or Bluetooth Smart) is the most influential.
BLE or Bluetooth Smart is also known as Wibree. The Wibree protocol was designed by Nokia in 2006 and was later included in Bluetooth 4.0 as Bluetooth Low Energy in December 2009.
Bluetooth Low Energy is a slightly different protocol from Classic Bluetooth, which is used in phones, headphones, TVs etc. Rather than continuously streaming data, BLE "servers" can "notify" clients to send the data chunks on a regular basis(which makes it preferable over traditional Bluetooth). As a result, BLE is better suited to low-power IoT applications that don't require significant volumes of data.
Both the server and clients now utilize a "service UUID", to determine which server and client needs to be connected. There are various "characteristics" that can be found inside these services.
Bluetooth Low Energy was developed and promoted by the Bluetooth Special Interest Group (SIG) for use in healthcare, beacons, fitness, home entertainment etc. It does not work with standard Bluetooth and does not have any compatibility, although it can coexist with BR/EDR and LE.
The Bluetooth Special Interest Group (SIG) recognizes several industries for low-energy technology, including smart homes, health, sport, and fitness.
Difference b/w traditional Bluetooth and BLE
Bluetooth Technology was created with the intention of allowing data to be streamed indefinitely. That implies you can send and receive a large amount of data over a short distance with Bluetooth.
It's crucial to discuss power usage while discussing the differences between Bluetooth and Bluetooth Low Energy. Bluetooth Low Energy is intended to transfer data only when the client is available to receive the data from the server; otherwise, the BLE device will go into low energy or sleep mode. Thus, use significantly less power as compared to traditional Bluetooth, while retaining a similar communication range.
Bluetooth Low Energy uses the same 2.4 GHz radio frequencies as traditional Bluetooth, but a different FHSS (Frequency Hopping Spread Spectrum) technique.
Classic Bluetooth uses Scatter-net topology whereas BLE uses Star topology.
Although Bluetooth Low Energy differs from the previous Bluetooth Basic Rate/Enhanced Data Rate protocol, both can be supported by the same device: the Bluetooth 4.0 specification allows devices to implement any or both of the LE and BR/EDR systems.
Because both, Bluetooth Low Energy and traditional Bluetooth use the same 2.4 GHz radio frequencies, allowing dual-mode devices to use a single radio antenna.
How does BLE work?
BLE Client & Server
Any BLE device can operate as both a server and a client.
Server ESP32 will announce its presence to nearby clients so that clients can establish a connection with the BLE server for communication.
Broadcast mode and mesh networks both are also supported by BLE.
In broadcast mode, only the BLE server transmits data to all the connected clients.
In mesh mode, all the devices are connected to each other. Therefore, all devices can communicate with all other available devices.
GATT
GATT is an acronym for Generic Attributes.
It defines a data structure that is visible to all BLE devices linked to it. GATT defines how BLE devices can communicate with each other. Understanding this structure is crucial to understand the working of BLE.
The GATT protocol includes a set of commands that allow the client to learn more about the server.
Read through all of the descriptors for a specific characteristic.
Find out everything there is to know about a specific service.
Find qualities that match a UUID.
Find UUIDs for all major services.
Find a service using a UUID.
For a particular principal service, locate subsidiary services.
BLE Service
A service is nothing more than a collection of data, such as data from a temperature sensor.
A profile, which is made up of multiple services, is at the top of the structure. Typically, a BLE-supported device will have multiple services.
The SIG has preset services for a variety of data kinds, such as battery level, weight, blood pressure, heart rate, and so on.
Every service has at least a single feature and can also refer to different services.
BLE Characteristics
The characteristic attribute is always held by a particular service, and it is where the hierarchy's real data is stored.
The characteristic has two attributes:
Characteristic value.
The characteristic declaration contains the metadata.
It essentially consists of the operations that can be used like Indicate, read, write, notify, broadcast etc.
UUID or Universally Unique Identifier
In a Generic Attribute (GATT) profile, the UUID is a universally unique 128-bit or 16-byte integer that is used to identify profiles, services, and data kinds.
Note:
In the code description, we will provide a link where you can generate a new UUID.
BLE network topology
BLE uses Star and mesh topology for communication.
A Broadcast Type or a Connection Type communication between two BLE devices is possible. The 'broadcaster' BLE Device sends data to any 'observer' BLE Device in broadcasting. It's a data transfer that only goes one way.
A 'Connection' between the BLE Devices is required for two-way communication. A Central (Master) BLE Device continuously checks for advertising data packets sent by a Peripheral (Slave) BLE Device.
BLE Applications
BLE is ideal for applications that need to exchange modest amounts of data on a regular basis.
BLE is used extensively in healthcare, fitness, tracking, beacons, security, and home automation etc.
Bluetooth Low Energy is natively supported by mobile operating systems such as iOS, Android, and Windows Phone, as well as macOS, Linux, Windows 8 & 10.
ESP32 BLE
You can use ESP32 BLE either as a BLE server or a client.
Examples are available in the ESP32 BLE library(Arduino IDE) which you can use to implement BLE services.
Note:
The Arduino IDE must have the ESP32 board manager file and libraries installed. If you haven't previously prepared your Arduino IDE to operate with the ESP32, then read our previous tutorial, i.e., Introduction to ESP32 Programming Series.
BLE Server Code Description
For coding, we are using Arduino IDE’s inbuilt example and will make the required changes in that code only.
I will also explain the code in detail for beginners to understand.
In this code, ESP32, BLE will be used as a server.
Import the necessary/required libraries for the BLE application.
Define a UUID for the Service and Characteristic.
To generate UUIDs, go to the following link:
https://www.uuidgenerator.net/
You can either use the default UUIDs if you wish to or go to the above link to generate random UUIDs as per your services and attributes.
Call back or acknowledge the server whether the client is connected or not
Arduino Setup() Function
Serial Communication at a baud rate of 115200.
Create a name for your BLE device for identification, we named it Wibree.
Set the BLE device as a server.
Create a service for the BLE server with the UUID defined earlier.
The characteristic for that service is then set. As you can see, you're still using the UUID you created previously, and you'll need to supply the properties of the characters as arguments. It's read and write in this scenario.
You can also add other services like battery, indicate, notify etc.
The setValue() method can be used to set the value of a characteristic.
The above value can be changed to whatever you like. This could be a sensor reading.
Finally, activate the service and advertising so that other BLE devices can scan and locate this BLE device.
Arduino Loop() Function
Here we can check if the device is connected to the client or not
If connected then do some tasks like transmitting data or receiving input from the client.
Data Size Per Packet
20 bytes per packet.
Unfortunately, BLE isn't built to handle large amounts of data. The maximum data size per packet in the BLE specification is 20 bytes, so if you wish to communicate more, you'll have to divide it up into many packets. Fortunately, this isn't a challenging task. Simply put, use a delimiter like "!" or "*" or something unique at the end of your whole message to signal the app that the message is done and to start listening for future communications. If you want to send + > 20 bytes cumulatively, for example, you can send and then proceed with the next message if needed.
Testing ESP32 BLE Server
After creating a BLE server using ESP32, we can use a BLE application available on the Play store for testing purposes.
Demonstration with BLE scanner app:
Go to the play store
Search for the BLE scanner and download the app
After installing the app turn on the Bluetooth.
Open the app and search for nearby devices.
Now connect to ESP32 BLE by clicking on the ESP32 device.
In our case, we named the device ‘Wibree’.
Now you can use the various services provided by BLE like writing and reading data packets, checking battery levels etc. and a lot more.
This concludes the tutorial. I hope you find it helpful.
Hello readers, I hope you all are doing great. Today, we are going to start the second section of the ESP32 tutorial series and today's our first tutorial, where we will have a look at How to Create a Web Server with ESP32. In our previous tutorial, we introduced you to the basics of the ESP32 microcontroller. where we discuss How to set up Arduino IDE to program ESP32. In this tutorial, we will discuss creating a web server using the ESP32 module.
One of the most interesting features of the ESP microcontroller series is its wireless connectivity via WiFi & Bluetooth. Wireless connectivity protocols supported by ESP32 are:
A web server is software or hardware that stores, processes, and delivers web pages to users on request. In other words, it serves users all over the World Wide Web (www). The web server uses the hypertext transfer protocol (HTTP or HTTPS) for communication with the clients(normally, web browsers). We know that HTTP is a set of rules to format and exchange messages.
The following are some important features of a web server:
Features of a Web Server
A web server, either physical or virtual, is a computer that hosts one or more websites.
The HTTP protocol is the foundation of any data exchange within the network when using the server. So a web server uses it to communicate with the client.
The web server uses static content and the files do not change dynamically. Some such files used in a web service are:
HTML files
Images
Stylesheets
JavaScript files
The web server has multiple settings to avoid unnecessary attacks. This helps to maintain the health and integrity of a website. There are multiple types of web security attacks, such as:
DDoS attacks
SQL injection
Cross-site scripting (XSS)
Hence, a web server has multiple features to serve the users on the web.
Web Server & Client Communication
A client is an entity that initiates communication with the web
server and then the server provides the information required. In simple
words, the client is a program, device, or user that requests services
or resources from the devices, such as the web server. The communication
and relationship between these two is called the server-client model.
The following are the general server-client model steps that will help
to understand the whole scenario:
The client sends an HTTP request to the server. The request includes the URL of the web page that the client wants to retrieve.
The
client (when the user requires data) sends an HTTP request to the
server. This request may include the URL of the web page from which the
client wants to retrieve the information.
The server receives
the request instantly and processes it. It does it when it looks up the
URL saved in its database to find the corresponding web page file a
client requires.
If the web page file is found, the server sends
it back to the client in the form of an HTTP response. This response
also includes other important types of information, such as the page's
content type and expiration date, etc.
The client then receives
the response and renders the web page on the user's screen. The client
uses the content type information to determine how to display the web
page.
If the page is not found in the URL database, the server shows the error.
Web browsers like Chrome, Firefox, and Safari are examples of clients.
ESP32 as a Web Server
The ESP32 is a microcontroller famous for its wireless capabilities, which makes it ideal for a large number of fields, especially IoT. We are talking about WiFi connectivity as a web server and here are the key features of this module related to it:
The ESP32 is made under the IEEE 802.11b/g/n standards; therefore it has a 2.4 GHz frequency band. Therefore, it can be used as:
Common WiFi routers
Access point
The built-in WiFi capabilities of the ESP32 allow it to be used as a server and carry out the easiest and most effective communication at a distance without any physical connection.
It has three operating modes:
In station mode, the ESP32 is operated as a WiFi client. It means it can be connected to the existing Wi-Fi network. (We are covering today)
In access point mode, it is operated as a WiFi access point; therefore it allows other devices to create a connection with it. (will be covered in the next lecture)
In dual mode, it can act as a server and as a client and allow the features of both at the same time. (will be covered in the 3rd lecture of section 2)
It has a dual processor that helps in handling multiple tasks at the same time. Therefore, ESP32 is more capable of managing a large network of devices and making it responsive for concurrent connections.
It has asynchronous web server libraries, such as “ESPAsyncWebServe” to handle the HTTP requests asynchronously. These are useful because they allow it to effectively manage the connections without blocking the execution of other tasks.
ESP32 has multiple security protocols that are used when creating the web server. As a result, it provides secure and protective communication between the devices.
It has over-the-air updates, which means it can update the device's firmware without physically accessing it. It helps with remote updates and maintenance.
The ESP32 is suitable for use as a server because of its multiple features, including:
It can serve static files
It can handle different HTTP methods (GET, POST, etc.)
It supports features like server-side scripting
The WebSockets feature of ESP32 allows it to carry out bi-directional communication between servers and clients. You will learn about both of these in just a bit.
The ESP32 supports WiFi Direct, which is also referred to as the Peer to Peer (P2P); therefore, it can form a direct connection with other devices with no need for an external WiFi network.
ESP32 WebServer Working Principle
We know that the ESP32 has a built-in WiFi feature. This makes it suitable to use as a server. The example of the server-client relationship we have just discussed shows the internet connection of the whole world. The ESP32 can be used for the intranet connection, which is defined as:
"An intranet is a private network that has limited functionalities and is only accessible to users within a specific organization/location."
Usually, this network may consist of different devices, such as mobile phones, computers, laptops and tablets. The Arduino IDE is for the programming of the ESP32, just like we have done in the previous session. If your Arduino IDE is ready with the boards and ports, then let us try the built-in example of the ESP32 to use as a server.
What is an SSID?
An SSID is a service set identifier that is the unique name of a wireless local area network (WLAN).
It can be 32 characters long.
It may include numbers, letters, and signs.
The SSID can be set by the user as well.
In simple words, the SSID is the name of the WiFi connection people use for their connection.
In the experiment we are just performing, the user has to replace the SSID with their own SSID to connect with the ESP32.
Using the ESP32 Server Built-in Example
Using the ESP32 as a server is easy with the web server example. It has the basics, and here are the steps to follow:
Open the Arduino IDE.
Connect the esp32 to your system through the cable. Make sure the ESP32 is connected accurately.
Click on tools>boards>ESP32>Node32s. This is my board and you can choose according to the model of ESP32.
Go to the files> examples>examples of Nose32s>WiFi and from the side menu, choose “SimpleWifiServer".
It will create a new project with the code in it to run the ESP32 (connected to your system) as a server.
Press the encoder (EN) button of the ESP32.
Change the SSID and password according to your choice. In my case, it is PTCL-BB.
Go to lines 38, 103, and 106 by one and replace the pin “5” digit with pin “2” because the built-in light is at pin 2.
Replace lines 70 and 71 with the following:
client.print("Click <a href=\"/H\">here</a> to turn the LED on pin 2 on.<br>");
client.print("Click <a href=\"/L\">here</a> to turn turn the LED on pin 2 off.<br>");
All the instructions are given in the code. Go to line 30 and place your SSID there.
Go to line 31 and enter the password of your choice.
Read the code carefully and hit the “verify” button.
Once the code is compiled, press "Boot" on the ESP32 when the uploading process is carried out.
Wait for the loading to complete.
Click on the “Serial Monitor” button at the upper right corner of the screen to open the monitor. You can go to Tool>Serial Monitor for the same task.
Choose the baud rate of 115200 from the drop-down menu at the right corner of the monitor.
Right now, the monitor is blank:
Click the EN button on the EPS32 to see the information.
Now that the monitor has data and is loading, it starts to connect with the WiFi connection of the system.
Once the loading is complete, it will provide the IP address. Copy this address.
Go to the new tab in the browser and paste the address there.
You will see that merely placing the “H” or “L” just after the IP address (as given in the code comment) will turn on and off the LED on ESP32 according to the URL.
Note: Make sure you have installed the port and board before you try this code and have selected all the right options; otherwise, you can face errors.
ESP32 Server as Messenger
The ESP32 can be used to send the message through the browser.
The microcontroller connects to the internet connection of the system.
The serial monitor shows the IP address.
The ESP32 acts as a server and through the URL of the browser, the user will send the message to the Arduino IDE.
This message will be shown on the serial monitor.
The user can change the message through the URL pasted in the web browser.
Material Required
Internet connection
System (e,g, laptop)
ESP32 microcontroller
Connecting cable
Code for ESP32 as Server
#include <WiFi.h>
const char *ssid = "My-SSID";
const char *password = "My-Password";
WiFiServer server(80);
void setup() {
Serial.begin(115200);
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.println("Connecting to WiFi...");
}
Serial.println("Connected to WiFi");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}
void loop() {
WiFiClient client = server.available();
if (client) {
Serial.println("New Client.");
while (client.connected()) {
if (client.available()) {
String request = client.readStringUntil('\r');
client.flush();
// Check if the request contains a specific message
Make sure you have the respective port and board installed successfully.
Connect the right port and board.
Paste the code given above into the new project.
"Verify" the code by using the button.
Once verified, compile and upload the code.
Once the code is compiled, press the Boot button.
Once the installation is completed, go to the serial monitor.
Press the EN button.
The serial monitor will show the information. Copy the IP address shown on the end of loading.
The general ULR for sending the message through the server is given as: http://esp32-ip-address/message?message=Hello
To send the “Hello” message to the ESP32 through the browser, use your IP address and the message. In my case, I am pasting the following URL in the browser: http://192.168.43.251/message?message=Hello
Once reloaded, go to the serial monitor and check for the message:
For the demonstration purpose, we will create a webpage and will launch it through our ESP32 module, so ESP32 will be acting as a web server, serving the page.
This webpage will have 3 Buttons on it, which will be controlling three LEDs, we will turn ON or OFF respective LEDs using these buttons.
WebServer Page is shown in the below figure:
Now the question arises, how will ESP32 understand which Button has been pressed?
For that, we have created multiple links i.e. the HomePage Url will look like:
http://192.168.43.188/
When a user will click on LED 26 ON Button, we will redirect the user to:
http://192.168.43.188/26/on
Now, when the client wants to turn OFF the LED, we will redirect to:
http://192.168.43.188/26/off
So, actually, we are checking the request from the client and based on that request we are turning ON or OFF the respective LED.
Moreover, we are providing the same webpage to all the links but with the change in the state of each button i.e. if it's ON then Blue, otherwise Green.
If it looks too complicated, don't worry. These things will get more clear when we will cover the Arduino coding.
ESP32 Wi-Fi module includes a number of useful characteristics, including the ability to use a soft access point mode, a station mode, or both modes at the same time. Only station mode will be discussed in this session. I'll also cover how to use this board in soft access mode in future tutorials.
Station Mode: The ESP32 board connects to your Wi-Fi network via a router in Station mode. The router serves as the communication channel between the web client and the ESP32. The IP address is obtained from the Wi-Fi router. Web clients can connect to the Web server using this IP address across a local network.
Access Point Mode: In this mode, the ESP32 creates its own wireless Wi-Fi network, similar to the one provided by your existing router. We don't need to connect the ESP2 to a Wi-Fi network in this mode. This Wi-Fi board can link up to 5 devices to the Wifi network it creates.
Controlling peripherals Using ESP32 Web Server
Connect the peripherals to the ESP32 board which you want to control through the ESP32 Web Server.
Here, we are going to control two external LEDs connected to LED1 (GPIO 26), LED2 (GPIO 27), and an inbuilt LED.
The following are the requirements for creating an ESP32 webserver to control peripherals:
ESP32 module
Internet connection
LEDs
Resistors
Connecting Wires
Arduino IDE Code
Using the Arduino IDE, upload the following code to the ESP32 module:
#include
// Replace with your network credentials
char* ssid = "ESP32"; //enter SSID
char* passphrase = "asdfgf@123"; // enter the password
// Set web server port number to 80
WiFiServer server(80);
// Variable to store the HTTP request
String header;
// Auxiliar variables to store the current output state
String output26State = "off";
String output27State = "off";
String builtin_led_state = "off";
// Assign output variables to GPIO pins
const int output26 = 26;
const int output27 = 27;
// Current time
unsigned long currentTime = millis();
// Previous time
unsigned long previousTime = 0;
// Define timeout time in milliseconds (example: 2000ms = 2s)
const long timeoutTime = 2000;
void setup() {
Serial.begin(115200);
// Initialize the output variables as outputs
pinMode(output26, OUTPUT);
pinMode(output27, OUTPUT);
pinMode(LED_BUILTIN, OUTPUT);
// Set outputs to LOW
digitalWrite(output26, LOW);
digitalWrite(output27, LOW);
digitalWrite(LED_BUILTIN, LOW);
// Connect to Wi-Fi network with SSID and password
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, passphrase);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
// Print local IP address and start web server
Serial.println("");
Serial.println("WiFi connected.");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
server.begin();
}
void loop(){
WiFiClient client = server.available(); // Listen for incoming clients
if (client) {
// If a new client connects,
currentTime = millis();
previousTime = currentTime;
Serial.println("New Client."); // print a message out in the serial port
String currentLine = ""; // make a String to hold incoming data from the client
while (client.connected() && currentTime - previousTime <= timeoutTime) { // loop while the client's connected
currentTime = millis();
if (client.available()) { // if there's bytes to read from the client,
char c = client.read(); // read a byte, then
Serial.write(c); // print it out the serial monitor
header += c;
if (c == '\n') { // if the byte is a newline character
// if the current line is blank, you got two newline characters in a row.
// that's the end of the client HTTP request, so send a response:
if (currentLine.length() == 0) {
// HTTP headers always start with a response code (e.g. HTTP/1.1 200 OK)
// and a content-type so the client knows what's coming, then a blank line:
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println("Connection: close");
client.println();
// turns the GPIOs on and off
if (header.indexOf("GET /26/on") >= 0)
{
Serial.println("GPIO 26 on");
output26State = "on";
digitalWrite(output26, HIGH);
}
else if (header.indexOf("GET /26/off") >= 0)
{
Serial.println("GPIO 26 off");
output26State = "off";
digitalWrite(output26, LOW);
}
else if (header.indexOf("GET /27/on") >= 0)
{
Serial.println("GPIO 27 on");
output27State = "on";
digitalWrite(output27, HIGH);
}
else if (header.indexOf("GET /27/off") >= 0)
{
Serial.println("GPIO 27 off");
output27State = "off";
digitalWrite(output27, LOW);
}
else if (header.indexOf("GET /LED_BUILTIN/on") >= 0)
{
Serial.println("BUILTIN LED on");
builtin_led_state = "on";
digitalWrite(LED_BUILTIN, HIGH);
}
else if (header.indexOf("GET /LED_BUILTIN/off") >= 0)
{
Serial.println("BUILTIN_LED off");
builtin_led_state = "off";
digitalWrite(LED_BUILTIN, LOW);
}
// Display the HTML web page
client.println("");
client.println("");
client.println("");
// CSS to style the on/off buttons
// Feel free to change the background-color and font-size attributes to fit your preferences
client.println("");
// Web Page Heading
client.println("
ESP32 Web Server
");
// Display current state, and ON/OFF buttons for builtin led
client.println("
LED_BUILTIN - State " + builtin_led_state + "
");
// If the LED is off, it displays the ON button
if (builtin_led_state=="off")
{
client.println("
");
}
else
{
client.println("
");
}
// Display current state, and ON/OFF buttons for GPIO 26
client.println("
LED_1 - State " + output26State + "
");
// If the output26State is off, it displays the ON button
if (output26State=="off")
{
client.println("
");
}
else
{
client.println("
");
}
// Display current state, and ON/OFF buttons for GPIO 27
client.println("
LED_2 - State " + output27State + "
");
// If the output27State is off, it displays the ON button
if (output27State=="off")
{
client.println("
");
}
else
{
client.println("
");
}
client.println("");
// The HTTP response ends with another blank line
client.println();
// Break out of the while loop
break;
} else { // if you got a newline, then clear currentLine
currentLine = "";
}
} else if (c != '\r') { // if you got anything else but a carriage return character,
currentLine += c; // add it to the end of the currentLine
}
}
}
// Clear the header variable
header = "";
// Close the connection
client.stop();
Serial.println("Client disconnected.");
Serial.println("");
}
}
Note:
You need to modify the SSID and password with your network credentials.
Code Description:
Here, we'll take a closer look at the code to see how it works.
The first task is to add a Wi-Fi library.
As mentioned previously, you must type your SSID and password inside the double quotes in the following lines.
As we are creating a web server, so we need to assign a port to it and normally we use port 80 for a local webserver.
So, in the below code, Port 80 is assigned to the webserver and then initialized a few variables:
String header: variable to store the header of the HTTP request.
Below the header variable, we have variables to store the current state of connected peripheral LEDs and built-in LED. If you wish to add more peripherals and save their states, you need to create more variables. By default, all LEDs are in the OFF state.
Next, assigned GPIOs to each peripheral device or component. Here we are using GPIO 26(LED1) and GPIO 27(LED2). You can use any other suitable GPIOs.
Lastly, we have initialized a few variables to check the connection timeout, we will check their working soon.
Arduino Setup() Function
Now let's first have a look at the Arduino setup loop.
First, we have initialized our Serial Port at a baud rate of 115200, so that we could monitor the results at the serial terminal.
Define the GPIOs as OUTPUTs and set them to LOW, as by default LEDs will be off.
To set up a wifi connection, we called the WiFI.begin() and here we have provided our SSID and passphrase as variables.
Now our ESP32 will try to connect to the provided WiFi connection.
As you can see, we have a while loop, where we are checking the WiFi Status.
If ESP32 gets connected with WiFi, the while loop will break and a message will get printed on the Serial Monitor "WiFi Connected".
Now our ESP32 is connected to the WiFi, so the router must have assigned an IP address to ESP32 and we are printing it on Serial using WiFi local IP Function.
Finally, we begin our server, to which we have assigned Port 80 at the start.
Arduino Loop() Function
Now, we are done with all the basic settings in the setup function. Let's have a look at the code in the Loop function:
At the last line of the Setup function, we have started our webserver, so now ESP32 is acting as a webserver and is waiting for incoming clients.
But what will happen, when someone will hit the IP Address of this webserver?
So, in the loop function, first of all, we are listening to the incoming client using the server.available() function.
If any client is available i.e. someone has entered our IP Address in the browser then we will print the HTML page.
So, we are going to write the rest of our code in this IF loop.
AS you can see in the below code, if the client is available, we have printed "New Client" on Serial Monitor.
After that, we have a while loop checking for client connection, so as long as we have a connection with the client, we will remain in this loop.
Inside this while loop, we have an If loop, checking if the client is available.
Now, if we are connected to the client, we need to read for the incoming request.
So, If there are any bytes to read from the client, read those bytes:
The client request ends at New Line Character \n, so we are checking for that.
Once we received the New Line Character, we are sending the response back to the Client.
In response, we have first sent the HTTP header, which is the default for webpages so that browsers should understand the response type.
Checking Request Type
As we discussed earlier, on each button press, we are redirecting our client to its respective link.
Depending on which button is pushed, we make requests to different URLs to turn the LEDs on and off using if else statements, as shown below:
As you can see in the above code, we are repeating the same code three times for 3 LEDs.
In the first block, we are simply checking the header response and if it's a GET request and from "/26/on", we have turned that Pin HIGH, changed the LED state variable to "on" and sent a message on the serial monitor.
So, if a client clicks on the LED 26 ON button, ESP32 will understand the GET request and glow the LED.
The other buttons work in the same way. If you wish to add more outputs, you'll need to change this section of the code.
HTML to display a web page
We have designed the output part i.e. what we are going to do when a user clicks any button.
And now we are going to design those buttons themselves i.e. we are designing the webpage.
As you can see in the below figure, we have standard HTML tags at the start.
After that, we have some CSS text to design the buttons and the appearance of the web page. We use the Helvetica font and set the information to be shown as a block with the center aligned.
Next, displaying Web page heading i.e. "ESP32 Web Server".
Next, comes the If Loop for the first Button, we are checking the LED state variable and based on LED state, we are displaying our Button.
So, if the LED state is OFF, we are redirecting the user to /LED_BUILTIN/on and vice versa.
That's how we are changing the Buttons on the webpage, as you can see buttons are using different CSS classes for on and off states.
Similar loops are used to display the states on other connected LEDs.
Finally, we are closing the web connection and clearing the header that was used to store the HTTP request header using client.stop() function.
Printing information about the closed web connection on the serial monitor.
Uploading Web Server Code to ESP32
Please reread the previous instruction, "Introduction to ESP32 programming series," if you are unfamiliar with the procedure of uploading code in the Arduino IDE.
After uploading the code, open the Serial Monitor with a baud rate of 115200.
Enable the ESP32 by pressing the EN (enable) button. The ESP32 establishes a Wi-Fi connection and the Serial Monitor displays the ESP32 IP address. To connect to the ESP32 web server, you'll need that IP address.
Note:
Make sure you have selected the right board and COM port.
Getting IP address and Access ESP32 web Server
After successfully uploading the code in esp32 module.
Open Serial Monitor from the top right corner of Arduino IDE screen as shown in figure below:
The IP address required to connect to the ESP32 point will be displayed on the Serial Monitor. It's 192.168.43.223 in this scenario.
To access the webserver, type the IP Address of the ESP32 into a Web Browser on a laptop or a mobile phone. It's 192.168.43.223 in our case.
You should be able to see a simple web page served by the ESP32's Web Server if everything goes well.
A screenshot of a Web Browser on a laptop accessing the ESP32 Web Server is shown below.
The image below is displaying the ONstate of the inbuilt LED.
The inbuilt LED is Blue in color.
The below image is displaying the OFF State of the inbuilt LED
Hence, We have done a lot of work on the ESP32 by using it as a server. In the beginning, we saw what is a web server and studied its features in detail. After that, we saw that ESP32 can be used as a server and we saw the feature that makes it ideal for this task. Then we experimented to learn the concept, in which we saw the built-in example of ESP32 as a server in Arduino IDE. We saw the step-by-step procedure to experiment and once it was completed, we moved on to a more complex example. I hope you find this tutorial useful and have performed it by yourself but if you are stuck at any point, you can ask in the comment section.
Using the ESP32 web server and the preceding process, you can control the peripherals linked to the ESP32 module from any mobile, tablet, or computer. The only need is that all of the devices to be linked to the same network.
This concludes the lesson. I hope it becomes useful to you. In the next tutorial, we will have a look at How to work the ESP32 BLE, so stay tuned. Have a good day. :)
Hello friends, I hope you all are doing great. In today's tutorial, we will discuss what is Selective Laser Sintering, why is it used for. Selective Laser Sintering is a popular 3D printing technology used to create durable prototypes and end-use parts from CAD files. Its one of the oldest and most popular forms of additive manufacturing techniques and thanks to further technological advances, its use is becoming widespread. In this guide, we will explore what SLS is and what it is used for.
How does Selective Laser Sintering work?
SLS uses a nylon or polyamide powder which is spread successively in thin layers with a high-powered laser that selectively sinters the powder according to data derived from digital models. This process is repeated layer after layer, binding the powdered material together to produce a final, firm structure. Excess powder is removed manually to reveal the final shape before bead blasting is applied to further remove powder residue.
What is SLS used for?
SLS is used for high productivity manufacturing tasks thanks to the laser’s high power and capability to scan quickly and accurately. It is a technology able to produce durable prototypes from a broad range of nylon-based materials, and it is also capable of printing independently moving parts in a single build. SLS is known as the go-to technology for producing complex shapes. It does not require a support structure and utilises unused powder to further add to its strength. In industries where lightweight material is imperative to a successful design (for example, aircraft building and automotive) SLS printed parts are invaluable.
What kind of products are made with SLS?
Being able to produce high strength products at a low volume, using different materials, like glass, plastic, metal and ceramics, means SLS printing is used to create many different tailored products. Medical and dentistry products such as prosthetics, hearing and dental aids are made using SLS. SLS is often utilised in industries where high-volume production is not required, for example, end-use parts for aeroplanes where only small quantities are needed on an infrequent basis.Businesses are able to store the digital files needed for SLS printing inexpensively and reproduce designs as and when required, instead of spending money on the expensive storage of moulds used in traditional manufacturing.
Benefits of Selective Laser Sintering
SLS has an impressive number of benefits. Primarily, it is a technology suitable for high productivity and quick turnaround times of less than 24 hours. The nylon powder used needs only a very brief exposure to the laser for sintering, making the process faster than other technologies. The associated cost of moulds is not required meaning it is ideal for rapid prototyping. Along with these benefits, SLS is a self-supporting technology, affording greater scope for more complex designs. This differs from the more widely adopted FDM (Fused deposition modelling) printing and stereolithography (SLA) which require structure support during printing. Laser adhesion is also stronger with SLS printing and the porous surfaces created to allow for a very effective dyeing process to final shapes and products.
How does SLS compare to other technologies?
Although SLS has a huge array of advantages there are some limitations to its use, warranting the need for other forms of 3D printing technology. One of its key drawbacks is cost. Compared to FDM and SLA printers which are obtainable for around $500 or less, a desktop SLS printer is a few thousand dollars, thus compromising its appeal for hobbyists.SLS prints are excellent for prototypes but for end-use functional parts, there are some disadvantages because of the porous quality of the final product. Although this porosity lends itself to excellent dyeing and colouring potential, this is not the case for the structural integrity of the final product. In addition, because SLS prints go through a cooling process following sintering, there is the propensity for shrinking and warping leading to the production of inaccurate shapes. Compared to SLA printing, where liquid resin is used instead of powder, SLS printing can generate more waste. This is because the resin in SLA printing can be reused whereas the quality of reused powder in SLS printing is compromised and needs to be disposed of. Coupled with this, the process of cleaning the powder from the finished product is messy. In an industrial setting, this does not cause a problem as cleaning chambers are often used, however, this necessary procedure can be off-putting for those using a small scale or desktop printers as the powder is difficult to control.
Conclusion
SLS is a proven and effective form of 3D printing and has been used in manufacturing for decades. Predominantly used in an industrial setting for rapid prototyping, it is difficult to envisage its use for smaller-scale activities as the inherent expense, poor recyclability of powder and complexity of use have so far formed a barrier for 3D printing novices.
Hello friends, I hope you all are doing great. In today's tutorial, we are going to design a Proteus Simulation for Automatic Plant Watering System using Arduino. We have designed this project for engineering students as it's a common semester project, especially in electrical, electronics and mechatronics engineering.
The two most significant hazards to the agriculture industry are the need for extensive labor and a scarcity of water. According to the World Wildlife Fund (WWF) organization, water shortages might affect two-thirds of the world's population by 2025, putting both the ecosystem and human health at risk. The use of automatic plant watering systems eliminates both of these problems by watering plants at specified times and amounts while monitoring their hydration levels through measuring moisture in the soil surrounding the plants. Automatic plant watering systems can be used in homemade gardens and can also be deployed in fields for large-scale use. Whenever designing an automatic watering system, it is important to keep in mind that the system should be expandable, allowing for the simple integration of new devices in order to broaden the applicability of the system.
We are not designing this project using real components, instead, we are going to design its Proteus simulation. So, first of all, you should Install Proteus Software itself. Proteus software has a big database of electronics components but it doesn't have modules in it. So, we need to install Proteus Libraries of a few components, so that we could simulate them. So, these are the PRoteus libraries which you should install first, before working on this project:
You can download this complete project i.e. Proteus Simulation & Arduino Code, by clicking the below button:
Download Complete ProjectNote:
You should also have a look at these other Proteus Libraries:
Three main components of an autonomous watering system are:
Water Level Sensor: monitors the water reservoir level.
Moisture Sensor: monitors the soil moisture level.
RTC module: responsible for supplying water to the plant at predetermined intervals or at a predetermined time.
Arduino UNO: serves as a hub for connecting and controlling all these components.
It is necessary to integrate the water level sensor with the microcontroller before it can be installed within the water reservoir. The location of the water level sensor within the reservoir is variable and is determined by the user and the application for which it is being utilized. The Arduino receives continuous data from the water level sensor and warns the user when the water goes below a certain level, either by an alarm or a buzzer, as appropriate.
The soil moisture sensor operates in a manner similar to that of the water level sensor. The tip of the sensor is inserted into the soil near the plant, and the sensor is activated. In the case of a moisture sensor, the closeness of the sensor to the plant is also variable, and the user may adjust it depending on the features of the plant for which it is being used. In vast agricultural fields, a single sensor may be used for numerous plants if they are closely spaced and their hydration levels can be determined by measuring the soil moisture at one location that overlaps with another spot on the soil surface.
The RTC module operates on the same concept of time monitoring in the background as other electronic devices such as computers and smartphones; even when these devices appear to be turned off, they continue to keep track of the current time. The RTC module, on the other hand, is capable of exchanging time information with the Arduino board. On a specific day of the week, at a specific time of day, the Arduino is pre-programmed to turn on the water pump and turn off the water pump after a specified length of time.
Components Needed:
Arduino UNO
Water Level Sensor
Moisture Sensor
RTC Module (DS1307)
LCD
4 LEDs
Buzzer
Relay
Water Pump
PCF8574
Component Details:
Arduino UNO:
Arduino UNO is a programmable microcontroller board.
It contains Atmel's ATMega328 as is based on that microcontroller.
The Arduino board also contains an in-built voltage regulator to protect it from burning out and supports serial communication to help programmers.
The Arduino board is culturally programmed through the Arduino App designed by the board's developers and the programming is done in C language.
The Arduino App compiles code and interfaces the firmware into the Arduino hardware.
Arduino UNO has 14 digital I/O pins out of which 6 are PWM pins as well.
Arduino also takes analog inputs and has 6 analog input pins.
Figure # 1: Arduino UNO
Soil Moisture Sensor:
The soil moisture sensor is a resistive sensor that consists of two electrodes with a small charge and the resistance in those electrodes is measured and then the resistance in between the soil is used to find the moisture levels.
A soil moisture sensor normally comes equipped with an amplifier such as LM393. It has a VCC, GND and analog output pin.
Figure # 2: Soil Moisture Sensor
Water Level Sensor:
The water level sensor is a module that helps calculate the amount of liquid in a container.
When a liquid is present in the tank, the Submersible level sensor detects the hydrostatic pressure generated by the liquid.
Since hydrostatic pressure is a measure of two variables, the first of which is the density of the fluid and the second of which is the height of the fluid, it is a useful tool.
Figure # 3: Water Level Sensor
RTC Module:
RTC stands for real Time Clock and as the name suggests the module keeps track of time even when the external power supply is cut off.
It has a battery cell installed within it for that purpose, moreover, it is capable of communication with other devices such as Arduino too.
Figure # 4: RTC Module
Relay:
Relays are basically electrical or electromechanical switches that operate on the principle of magnetic field controlling the switching within the relay.
A relay has two modes of operation, normally open and normally closed.
Figure # 5: 12V Relay
PCF8574:
The PCF8574 is a silicon-based CMOS integrated circuit.
Using the two-line bidirectional bus enables general-purpose remote I/O extension for the majority of microcontroller families (I2C).
It is used in our project for I2C communication of LCD.
Figure # 6: PCF 8574
Proteus Simulation of Plant Watering System
Now, let's design the Proteus Simulation of Plant Watering System first and then will work on the Arduino Code.
First of all, make sure that Proteus is installed on your computer and download all the necessary libraries for Proteus beforehand.
For this project, you will need libraries for Arduino, LCD, RTC Module, Water Level Sensor and Soil Moisture Sensor. Make sure that you read how to use each library in Proteus as well.
Open a new project on Proteus, import all the components required and place them within the working area or the blue line of Proteus.
Select below components from Proteus Components' library:
Circuit Diagram and Working:
Now, place these components in your Proteus workspace, as shown in the below figure:
For the water level and moisture sensor, place a variable POT(potentiometer) at the test pin and place an RC filter at the output pins. (This is only for simulation purposes)
Start with the input side of Arduino and connect the soil moisture, water level output pins to the A1 and A0 pins of Arduino respectively.
To use the LCD for I2C communication, Place PCF8574 and connect with LCD.
Connect the SDA and SCL pins of PCF8574 and the SDA and SCL pins of the RTC module with the SDA and SCL pins of Arduino.
For the output side of Arduino, Connect the D7 to the relay controlling the pump.
Connect the buzzer at D2 and the LEDs to their respective Arduino pins as well.
Make sure appropriate power and ground are provided to each component. With that the making of the circuit on Proteus is complete.
Figure 7 shows the circuit diagram of the system. Proteus was used to simulate the circuit and Arduino App was used for the simulation of the Arduino code. The circuit was designed in a way that is easy to understand and further integrated easily. We will now go through a step-by-step guide on how the circuit was built.
Figure # 7: Proteus Circuit diagram
Arduino Code for Plant Watering System
A normal Arduino code has two main segments:
void setup
void loop
We will look at both of them separately here.
Declaration Code
The first step in setting up our code is defining libraries, download if you don’t have any libraries already integrated in the Arduino App.
Figure # 12: Arduino Code
The next step in the code is tone definition for buzzer and pin definition of variables being used in the project.
Figure # 13: Arduino Code
After pin definition, the variables used must be defined so that Arduino knows where to find them and how to identify them.
Figure # 14: Arduino Code
The next step is defining the system messages that will appear on the LCD.
It is not necessary to define those messages in the setup, they can be easily defined within the main code but it is an easier way to define those beforehand and call them whenever needed.
This is especially useful when a system message is used multiple times in the code.
Figure # 15: Arduino Code
Now we define the objects being used in the project.
The two objects being defined are the RTC module and LCD. In the syntax below we used 20x0 in the argument for the LCD, that is because there are no libraries for I2C LCDs and we had to turn a simple LCD into an I2C LCD by the means of PCF8574.
Figure # 16: Arduino Code
Void setup:
Now we start the programming of void setup.
At first is the initialization of various components, such as initializing the RTC module and setting the time and date of RTC with respect to our computer.
Wire initialization and library are used for I2C communication.
Figure # 17: Arduino Code
The next step is defining the digital pins of Arduino being used as input or output pins and displaying the initial message on our LCD.
Figure # 18: Arduino Code
Void Loop:
The first step in the loop is to read the date and time from the computer through the RTC and read the values from the sensor.
Since this part of the program runs in the loop, Arduino will keep reading and refreshing the sensor inputs every time the loop starts.
Figure # 19: Arduino Code
In the next segment of the code, we will check various conditions of the sensor values and RTC and actuate our outputs on the basis of these conditions.
At first, we check the water level of the container, if it is below the set level, Arduino will actuate the buzzer to alarm the user of low tank on LCD.
Figure # 20: Arduino Code
In the next step, we check the values of the moisture sensor and place the conditions in three categories, namely, moist soil, soggy soil and dry soil.
The Arduino will light up the respective LED whenever its condition is true. Red LED for dry soil, yellow LED for soggy soil and green LED for moist soil.
The LCD will also display respective messages for each of those conditions.
The following code is for the condition of dry soil.
Figure # 21: Arduino Code
The following code is for the condition of moist soil.
Figure # 22: Arduino Code
And finally the code for the condition of soggy soil.
Figure # 23: Arduino Code
In the next step of the code, we check the condition of time, whether it is time to water the plants or not and the condition of the water reservoir to see its level as well.
Figure # 24: Arduino Code
If you see the code closely, you may see the function of the right hour, which is called various times in the main code. The function code in itself is written at the bottom of the main code. This function is used for displaying the time and date on the LCD and also for fixing the date and time.
Results/Working
Open Arduino and generate a hex file for that program.
Put the hex file in the Arduino UNO board placed in Proteus.
Run the simulation.
Figure # 8: Proteus circuit simulation when soil is soggy
Figure # 9: Proteus circuit simulation when soil is moist
Figure # 10: Proteus circuit simulation when soil is dry
Figure # 11: Proteus circuit simulation when soil is dry and it is time to water the plant
As you can see from figure 8 that our simulation is running according to the program set at Arduino. You can increase or decrease the values coming from the sensors through the Potentiometer.
So, that was all for today. I hope you have enjoyed today's lecture. If you have any questions, please ask in the comments. Thanks for reading.
Are you here to learn about Databases and CRUD operations in the C# programming language? If so, then you will be an expert in no time. Learning Databases and CRUD operations in C# is not a piece of cake. But, if you know all the terms and steps of CRUD operations and databases in C#, it will not be rocket science for you. This article contains all the information you should know regarding databases and CRUD operations. So, keep reading till the end!
C# Programming Language: An Overview
We know that you are already aware of the C# programming language. So, here is a quick overview of the C# programming language before we move to the actual topic:
C#, also known as C-Sharp, is an object-intended coding language that operates on the .NET Platform and is developed by Microsoft. ISO and ECMA have certified the C# programming language. C# is a broad programming language that can help accomplish hundreds of activities and purposes in different fields. It resembles Java, C++, and other programming languages but, it is truly one of a kind. The best thing is that it is object-oriented and is easy to use. It has an infinite list of advantages.
Some of the advantages of the C# are listed below:
C# programming language offers automated garbage pickup.
In C# programs, classes may be specified within domains.
No obligation to add the “.h” extension within header folders.
Because non-Boolean values are not utilized as conditionals, the scripts are less vulnerable to errors.
Multithreading is genuinely uncomplicated in C# as compared to other programming languages like C++ or Java.
All parameters in the C# are immediately set to their standard settings before being utilized.
C# offers reflection skills, which means it can look at and change its composition at execution.
With the help of the C# programming languages, many apps and programs have been built like KeePass, Banshee, Paint.NET, FlashDevelop, and many others. In fact, the application where I am writing this article is also an application of the C# programming language (Microsoft Word).
All the above advantages make the C# programming language stand out in other languages. It is undoubtedly the most contemporary and exceptional language out there!
What is a Database In C#?
Before we begin learning about CRUD operations in a database within the C# programming language, it is crucial to know what a Database is.
A database is basically a coordinated set of formatted data kept digitally within a computer network. A database administration tool is generally in charge of a dataset. The DBMS, the dataset, and the programs that interact with these are collectively called a database platform. Every database operation can access a single relational database. It is generated as an inclusion within the data catalog by the data proprietor (usually a database manager with authority for that collection), who gives it a title and a specification. Several databases utilize structured query language (SQL) when generating and accessing data.
What is CRUD?
Here is the most awaited section of the entire article: CRUD operations. Please grab a notebook to note every detail for your better understanding. And if you do not wish to write these, you can always read our article from the website. Let us begin:
The abbreviation CRUD refers to Create, Read, Update, and Delete in software coding. Permanent memory has these four primary functions. Additionally, every letter of the abbreviation may relate to every functionality within a relational network program that is linked to a standard HTTP service, SQL declaration, or DDS action.
It may also apply to consumer-interface standards that let users browse, explore, and alter data using computer-based documentation. Objects are viewed, produced, modified, and removed in this way. Furthermore, CRUD is data-driven, and HTTP operation verbs are regulated.
Standard CRUD Operations In C#
The CRUD feature is present in almost all programs. CRUD is something that every coder has to use at some stage. In the C# programming language, CRUD operations in the database are quite crucial to learn because they are a fundamental component of programming. CRUD is important because of its Create, Read, Update, and Delete features. A brief explanation of these features is listed below:
CREATE Operations: Inserts a fresh entry using the INSERT command. This operation is required when we wish to add new data to the database. It basically enables you to add extra rows to your table. When you use the INSERT INTO command, the system will show two possibilities. You can choose the one which is according to your requirement. The two possibilities are:
READ Operations: The READ operation retrieves table entries depending on the main key inside the given variable. It works in a similar way to the search feature.
UPDATE Operations: Performs an UPDATE assertion on the database depending on the main key provided for an entry in the WHERE statement. You must specify the destination table and attributes to be modified when using UPDATE. The corresponding variables and the rows are also required. Use the code below to make changes to a preexisting record:
DELETE Operations: Erases a specific order within the WHERE statement. Certain relational database systems may enable a final delete or a temporary delete, depending on the requirement. The DELETE code is:
Here's the table, showing all operations with their description:
Standard CRUD Operations In ASP.NET MVC Utilizing C#
In this section, we will discuss the steps required to operate the standard CRUD operations in ASP.NET MVC within the C# programming language. So, please pay extra attention to this section so that you do not have to face any difficulty while coding.
You must be thinking about the term MVC. Well, MVC abbreviates for Model View Controller. It is actually a development paradigm that isolates the business strategy from the display strategy and information. In a nutshell, it is a framework for designing online applications. According to MVC, the program can be divided into three layers:
Model Layer: The Model element relates to everyone's data-associated reasoning. It will reflect the content being transmitted among the Display and Controlling portions, as well as any additional business logic-associated data. A Client class, for example, will receive client details from a server, change them, or utilize the content.
View Layer: The View element is used for the UI functionality of the device. For example, the Client view will have all of the UI elements that the final user encounters, like input forms, dropdowns, and others.
Controller: Controllers serve as a link among the Framework and View elements to execute all administrative functions and incoming applications, manipulating information with the Framework element, and interacting with Viewpoints to display the final result. For example, the Client manager would manage all activities and entries from the Client Page and use the Client Model to refresh the database.
Now that you know about the MVC, we can begin the discussion of the steps of CRUD operations in C#:
Construct A Database Using The Columns Listed Below: It is merely a demonstration to ensure that you comprehend the script. You may construct your custom database based on your requirements. You can also understand it better by the illustrations in each step like the one below:
New Project: Build a new project in Visual Basic.
Create a Fresh Record: Next, within the freshly formed controller, enter the following script to generate a fresh record within your dataset.
Afterward, select the initial activity outcome and select AddView. Choose to Generate as your theme, model type as your developed model, and info context category as your EDMX developed prototype. After that, execute the project.
Read: Next, to view the latest values on your display, use the code provided below.
Then, insert the View. However, make sure the style is set to List. After that, launch the project.
Update: Now, use the following code to modify the present record.
Next, insert a view in the same way you did before, but ensure to set the theme to Edit. After that, launch the project.
Delete: To erase an entry from the system, use the following code.
Now, just set the theme to Delete and execute the program.
Please remember that you can always change the HTML according to your needs. We hope that you understood how CRUD operations work in databases of the C# programming language.
CRUD Operations in C# Connecting SQL Database
We want our readers to have crystal clear concepts regarding CRUD operations in the C#. That is why we also included this brief section of CRUD operations in C# connecting the SQL Database. Let us begin:
Add DLL: First, you must include Dynamic Link Library (DLL).
Namespace: To link to a SQL system, you can utilize the System.Data.SqlClient; namespace.
Declaration: Next, you should specify the relationship string beyond the class.
Insert the Data: Enter data into the system as shown below:
Update: Afterwards, you have to update the record like the code mentioned below:
Display: Then, display the information like the code below:
Delete: Then, follow the code below to erase the record.
Use Clear Technique: Lastly, utilize the Clearing technique to remove all the text fields, as shown below:
Please remember these steps. If you mess up in one step, your program will not execute the right way. So, it would be great for you if you note the steps down!
Benefits Of Using CRUD Operations
Now that you know about the launch of CRUD operations in databases within the C# programming language, it is time to know the benefits of using CRUD operations. You must have this question that why do programmers prefer CRUD? In simple words, developers use CRUD because of its exceptional productivity. Additionally, performing CRUD operations protects against SQL manipulation attacks. Because all SQL Entries utilize saved methods rather than string synthesis to generate flexible queries from client input info, everything entered into a variable is quoted.
It would not be wrong to say that CRUD is just too crucial to be overlooked. Mastering it initially can help you feel more confident when working with unknown stacks. CRUD Operations help in our daily desktop tasks. Some of these are:
Signing up for a webpage
Saving a hyperlink in your account
Modifying configurations
Deleting a Facebook status
These are just some of them. CRUD is a part of everyone’s life whether one is a programmer or not.
CRUD Restricts Casual Surfing and Changes
Program permissions are a SQL Administration feature that allows code to alter credentials without requiring the person's permission. Individuals should have the necessary rights on the relational records to execute ad hoc SQL queries. Clients can view and change data in apps like Microsoft Excel, PowerPoint, and others after authorization is allowed. Customers can even ignore the app's corporate rules.
However, it is an undesirable scenario that may be avoided by using the Application Authority. Such kind of flaws can be prevented by combining database access protection with an Application License. Because Application licenses are uploaded to the system via a recorded method, CRUD is required. It can also be done by providing authorization to run the CRUD saved methods and removing immediate table entry.
After an Application Account is established, authorization and passcode are granted. The passcode is also hard to change because it is programmed into the program. CRUD is indeed the procedure to utilize while modifying data. Thus, the world of programming would be incomplete without CRUD Operations.
Summing Up
In this article, we discussed the CRUD operations in databases within the C# programming language. We also discussed Standard CRUD Operations In ASP.NET MVC as well as in Connecting SQL Databases Utilizing C#, with some benefits of using CRUD. These might seem complicated to you. Once you become an expert, all the CRUD operations in the C# will not be rocket science for you. Just make sure to follow all the steps correctly to avoid any mistakes.
Hello everyone, I hope you're all doing well. In the previous lecture(Chapter 0: ESP32 Pinout), we discussed the ESP32 features & specs in detail. Today, we are officially starting this ESP32 Programming Series. In this ESP32 Programming Series, we will start with basic concepts and
will gradually move towards complex topics. I will try to keep this
ESP32 series as simple as I can. But still, if you encounter any issues,
please ask in the comments, will try to resolve the issues as soon as
possible.
As ESP32 has numerous features & applications, so I have divided this series into different sections. I have named the 1st section "ESP32 IDEs". In this section, we will discuss different IDEs used to program ESP32 boards. In each Chapter of this section, we will install one of these ESP32 IDEs and will test a simple LED Blinking Code in it. We will set up the ESP32 Development Environment for Windows, Mac, and Linux users.
As I am sharing the 1st Chapter today, so first we will unbox the ESP32 board, set up the most commonly used ESP32 IDE i.e. Arduino IDE, and test a simple WiFi Scan Code on the ESP32.
IDE is an abbreviation of Integrated Development Environment. IDE is a software package used to write & compile the code. As ESP32 is one of the most popular microcontroller boards, there are numerous third-party IDEs available to program it, and each IDE supports its own programming language. So, if you are a C# developer or an Arduino expert, you can quickly and easily get your hands dirty with ESP32. The below table shows the most commonly used ESP32 IDEs along with their supported programming language:
ESP32 IDEs
No.
ESP32 IDEs
Programming Language
1
Arduino IDE
Arduino C
2
Thonny IDE
MicroPython
3
Visual Studio Code
Arduino C
4
PlatformIO IDE
C++
5
ESP-IDF(official IDE by EspressIF)
C
6
nanoFramework
C#
In today's lecture, we will install the Arduino IDE and configure it for ESP32 Programming. So, let's get started:
Install ESP32 in Arduino IDE
First of all, we need to install the Arduino IDE itself. To program ESP32 with Arduino IDE, we need to install the ESP32 Boards
in Arduino IDE. Before installing the ESP32 Boards, we first need to add
a JSON File containing information about ESP32 Boards. JSON format is
used to share information between two computers. So, this JSON file will
add the information of ESP32 boards in the Arduino IDE. So, let me summarize these 3 steps in proper order:
Installing Arduino IDE
Adding ESP32 JSON File
Installing ESP32 Boards
Installing COM Port Driver for ESP32(if COM Port not detected automatically)
Installing Arduino IDE
We need to first download & install the Arduino IDE.
Download Arduino IDE from its official website, make sure to download the latest version.
Installing Arduino IDE is quite simple, but if you are having issues, have a look at this Arduino IDE Installation Guide.
After installing the Arduino IDE, we need to add the ESP32 JSON File in it. So, follow the below steps:
Open Arduino IDE and navigate to "File > Preferences", as shown in the below image:
In the Arduino Preferences Window, you will find a textbox named "Additional boards Manager URL".
Add the ESP32 JSON File link(provided above) in it, as shown in the below figure:
If you have already added any third-party board URLs, then add a comma (,) between the JSON links OR click on the button and it will open up a new window, add URL in the new row, as shown below:
Click "OK" to close the Preference Window.
Once you close the Preference Window, Arduino IDE will extract the information of all ESP32 boards by downloading the ESP32 JSON file.
Now, we are ready to install the ESP32 Boards in Arduino IDE:
Installing ESP32 Boards in Arduino IDE
In the Arduino IDE, click on "Tools > Board > Board Manager", as shown in the below figure:
It will open up a Board Manager Window in Arduino IDE.
From this Board Manager, we can install the packages for third-party modules.
In the Board Manager, make a search for "ESP32" and you will get many third-party ESP32 packages.
Here, we need to install the "ESP32 by Espressif Systems" as it's the official package, I have highlighted it in the below image:
So, click on the Install button to install ESP32 boards in Arduino IDE.
Arduino IDE will take some time to install the ESP32 package.
Once installed, click on "Tools > Boards > esp32" and you will find a list of newly added ESP32 boards, as shown in the below figure:
From this list, we will select "ESP32 DEV KIT V1", it's the most commonly used ESP32 board.
In the COM Port, select the available COM Port, in our case, it's COM5:
In some cases, the Arduino IDE won't automatically detect the ESP32 COM
Port, so here we need to install the COM Port driver for ESP32. Let's do it:
Installing ESP32 COM Port in Arduino IDE
If you don't find the ESP32 COM Port in the Port Section of Arduino IDE, then you need to install the COM Port Driver manually. So, follow the below steps:
Download the Windows COM Port Driver by clicking the below button and install it on your computer:
If you are using 32-bit Windows, then install the x86 version and if working on 64-bit Windows, then install the x64 version.
After installing this COM Port Driver, restart your Arduino IDE and it's recommended to restart your computer as well.
So, we have successfully installed the ESP32 Boards in the Arduino IDE. Now, let's upload a simple LED Blinking Code in the ESP32:
Code Upload to ESP32 from Arduino IDE
Now that the Arduino IDE is ready to handle the ESP32 Dev Kit module, you can write the code for the ESP32 module. We will just upload a simple WiFi Scan Code to verify that our ESP32 installation is correct.
Open Arduino IDE and navigate to "File > Examples > WiFi > WiFiScan".
Click on the Tools and verify that you have selected the correct ESP32 board and the COM Port.
Now, click the "Upload
" button to upload the code to the ESP32 board.
If the code is uploaded successfully in the ESP32 board, you will get the confirmation message in the Output pane, as shown in the below figure:
Now open the Serial Terminal and you will start receiving the List of all available WiFi connections, as shown in the below figure:
That concludes today's discussion. We hope you found this post informative. In the next tutorial, we will install the ESP32 Boards in the Visual Studio Code. If you have any questions, please ask in the comments. Take care. Have a good day.
Hello friends, I hope you all are doing great. In today's lecture, we will have a look at the I2C Communication with STM32 Microcontroller board. I am going to use the Nucleo board for today's lecture. In the previous lecture, we have discussed STM32 Serial communication both in Interrupt Mode and polling Mode. Today, we will study another way of communication(i.e. I2C) with STM32. So, let's first have a look at what is I2C Communication:
I²C (Inter-Integrated Circuit) is a two-wire serial communication system used between integrated circuits. Like any serial protocol, one of its advantages is that of using only two lines that transmit or receive a sequence of bits, the limit is the communication speed which has been improved over the years.
The bus was conceived and developed by Philips (now NXP) It was designed to overcome the difficulties inherent in the use of parallel buses for communication between a control unit and various peripherals.
Serial transmission is a mode of communication between digital devices in which bits are sent one at a time and sequentially to the receiver in the same order in which they were transmitted by the sender. Although the communication modules are more complex than the parallel transmission, the serial mode is one of the most widespread especially in communications between chips that must communicate with each other over great distances, because:
it requires fewer wires and pins available on the integrated circuit with a consequent reduction in costs and space on the board;
is more tolerant of interference and transmission errors;
up to 128 devices can be connected to each other
I2C Pinout
SDA (Serial Data) is the line where master and slave send or receive the information (sequence of bit);
SCL (Serial Clock) is the line dedicated to the clock to synchronize the data flow.
SDA and SCL lines need to be pulled up with resistors. The value of these resistors depends on the bus length ( ie the bus capacitance) and the transmission speed. The common value is 4.7kO. In any case, there are many guides to size them and we refer their reading to the more attentive reader.
The transmission mode is Half-duplex ie the transmission between devices is alternated.
As shown by the previous image, we can use this communication to put in communication different peripherals as Analog-Digital Converters (ADCs), Digital-Analog Converters (DACs), EEPROM memories, sensors, LCD screen, RF module, Real-Time Clock, etc.
I2C Communication in STM32
The Nucleo boards provide one or more I2C interfaces that can be quickly configured with STCube Tool.
There are four modes of operation:
Slave Transmitter
Slave Receiver
Master Transmitter
Master Receiver
The first two are used to operate in slave mode, while the last two are in master mode. By default, the interface is configurated in slave mode.
By default, the I2C interface operates in Slave mode, but it is possible to switch to Master mode to send a Start condition message. Furthermore, it needs to write in I2C_CR2 register the correct clock configuration to generate the expected timings. The Master sends a Stop condition when the last data byte is transferred, and the interface generates an interrupt.
I2C Packet Message
In general, the packet message is as follow:
Start condition: the master pulls SDA low and SCL is High to inform slave devices that a transmission is ready to start.
Address frame: the master sends the address of the slave, each device has an address of 7-10bit, then sends the Read (R) or Write (W) bit, which are respectively 1 and 0. Finally, the master waits that the slave sends the Acknowledge bit (ACK).
Data frame(s): Send (master) / Receive (slave) Data Byte (DATA) and then Waiting (master) / sending (slave) the Acknowledge bit (ACK)
Stop condition: the master sends the stop conditions pull SDA to High defined by a low while SCL remains high.
I2C Modes in STM32
Furthermore, there are three ways to exchange data, named:
Polling Mode
Interrupt Mode
STM32 I2C Polling Mode
In polling mode, also called blocking mode, the application waits for the data transmission and reception.
This is a simple way to communicate between devices when the bit rate is not very low, for example when we can debug the board and we want to display the result on screen console.
HAL library provides the following functions to transmit and receive in polling mode:
I2C Master Reciever
The function to receive data in master mode is as follows:
Slave transmits in master mode an amount of data in non-blocking mode with DMA.
In the STCube tool, the I2C can be configurated fastly and easily as follow.
In Pinout & Configuration, widow selects Connectivity and selects one of the available I2C (I2C1, I2C2, etc). In parameter settings, the master and slave features can be set. Master features are I2C speed mode (standard mode by default and fast mode) and the I2C clock speed (Hz). In standard mode, the device can send up to 400kbit/s while in fast mode up to 1Mbit/s. In general, like clock speed, the STM32 supports 100kHz, 400kHz and sometimes 1MHz.
The main feature of slaves is the primary address length that in general, as previously said, is 7-Bit. Furthermore, the slave can have a secondary address.
Then need to configure the GPIO, as follow:
Now the I2C configuration is terminated and can be possible to generate the code initialization and finally be ready to write our application.
Syed Zain Nasir
I am Syed Zain Nasir, the founder of <a href=https://www.TheEngineeringProjects.com/>The Engineering Projects</a> (TEP). I am a programmer since 2009 before that I just search things, make small projects and now I am sharing my knowledge through this platform.I also work as a freelancer and did many projects related to programming and electrical circuitry. <a href=https://plus.google.com/+SyedZainNasir/>My Google Profile+</a>