Introduction
This week, I learned about different interfaces and applications used in embedded systems and IoT. I worked with different interfaces such as Web Server, PictoBlox, p5.js, Blockly, and Processing. These interfaces helped me understand how we can control and communicate with hardware using different software platforms.
I also explored applications such as MIT App Inventor and Blynk. I used these applications to create simple control systems and connect hardware with mobile or web-based interfaces.
By working with these tools, I learned how hardware and software can work together. I also understood how different interfaces can be used to control devices, display data, and build interactive IoT applications.
What is an Interface?
An interface is a way that allows two different systems, devices, or software to communicate and exchange information with each other. In embedded systems and IoT, an interface helps us connect and control hardware using software or communication methods. For example, a web server can be used to control hardware through a web browser, while p5.js and Processing can be used to create interactive interfaces. Blockly and PictoBlox allow users to control hardware using visual blocks. In simple words, an interface acts as a medium between the user, software, and hardware, helping them communicate and work together.
What is an Application?
An application is a software program designed to perform a specific task or help users interact with a system or device. In embedded systems and IoT, applications are used to control hardware, monitor sensors, display data, and communicate with devices. For example, MIT App Inventor can be used to create mobile applications for controlling IoT devices, while Blynk can be used to control and monitor hardware through a mobile or web application. In simple words, an application is a software tool that helps users perform tasks and interact with hardware or other systems.
Indiviual Asignment
Task
The task was to build an application that interfaces with a microcontroller board and compare different tools for application and interface development. I used Web Server, PictoBlox, p5.js, Blockly, Processing, MIT App Inventor, and Blynk to understand how they can be used to communicate with and control microcontroller boards.
PICTOBLOX
What is PictoBlox?
PictoBlox is a block-based programming platform used to learn programming and create interactive projects. It allows users to program microcontrollers and electronic components using drag-and-drop blocks, which makes programming easier for beginners. PictoBlox can be used with Arduino, sensors, LEDs, motors, robotics, IoT, and AI projects. It helps users understand how software can communicate with and control hardware.
how i install Pictoblox
I searched for PictoBlox for Windows on Google.
opened the official PictoBlox download page and selected Windows.
clicked the Windows Installer 64-bit option to download PictoBlox
entered the required details and started the PictoBlox download.
The PictoBlox installer was downloaded successfully.
I opened the downloaded PictoBlox setup file to start the installation.
selected the installation folder and clicked the Install button.
PictoBlox was being installed on the computer.
The installation was completed, and I clicked Finish to launch PictoBlox.
Bounce Ball Game Using PictoBlox
I opened PictoBlox
selected the Blocks option to create the game.
I added the ball and paddle sprites and set up the game background.
created the ball movement and bouncing logic using blocks.
programmed the paddle to move left and right using the arrow keys.
tested the game and checked whether the ball bounced correctly on the paddle.
Experience
Creating the Bounce Ball Game in PictoBlox was a good learning experience for me. I learned how to use different blocks to control the movement of the ball and paddle and make the ball bounce properly. While making the game, I understood how conditions and loops are used to create game logic. I also faced some small problems while testing the game, but solving them helped me improve my debugging and problem-solving skills.
Processing IDE
Processing is an open-source programming language and development environment used to create interactive graphics, animations, visualizations, and applications. It has a simple and user-friendly interface, which makes it suitable for learning programming and developing interactive projects. Processing can also communicate with external hardware such as microcontrollers using serial communication. In this project, Processing was used as an interface to communicate with the XIAO ESP32-C3 and control five LEDs.
how i install processing
search processing ide on google
click to download
downloading
click next
installing
click on new sketch
Processing with XIAO ESP32-C3 and RGB LED
After creating the Bounce Ball Game, I worked with the Processing IDE and XIAO ESP32-C3 to control an RGB LED. I created a simple graphical interface in Processing IDE with buttons to control the LED colors. The interface sent commands to the ESP32-C3 through serial communication, and the ESP32-C3 changed the RGB LED color according to the received command. I tested different colors such as red, green, blue, and other combinations. This activity helped me understand serial communication, graphical interfaces, and microcontroller control. It also gave me practical experience in connecting software with hardware and controlling an electronic component through a computer interface.
CODE for Arduino IDE
#define RED_PIN 3
#define GREEN_PIN 4
#define BLUE_PIN 5
void setup() {
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
// LED OFF
digitalWrite(RED_PIN, LOW);
digitalWrite(GREEN_PIN, LOW);
digitalWrite(BLUE_PIN, LOW);
Serial.begin(115200);
}
void setColor(bool red, bool green, bool blue) {
digitalWrite(RED_PIN, red ? HIGH : LOW);
digitalWrite(GREEN_PIN, green ? HIGH : LOW);
digitalWrite(BLUE_PIN, blue ? HIGH : LOW);
}
void loop() {
if (Serial.available() > 0) {
char command = Serial.read();
switch (command) {
case 'R': // Red
setColor(1, 0, 0);
break;
case 'G': // Green
setColor(0, 1, 0);
break;
case 'B': // Blue
setColor(0, 0, 1);
break;
case 'Y': // Yellow
setColor(1, 1, 0);
break;
case 'P': // Purple
setColor(1, 0, 1);
break;
case 'C': // Cyan
setColor(0, 1, 1);
break;
case 'W': // White
setColor(1, 1, 1);
break;
case 'O': // OFF
setColor(0, 0, 0);
break;
}
}
}
CODE for Processing
import processing.serial.*;
Serial myPort;
void setup() {
size(800, 500);
println(Serial.list());
// ESP32-C3 COM PORT
myPort = new Serial(this, "COM14", 115200);
}
void draw() {
background(240);
textAlign(CENTER, CENTER);
textSize(28);
fill(0);
text("ESP32-C3 RGB LED CONTROL", width/2, 45);
// RED
fill(255, 0, 0);
rect(50, 100, 150, 100);
fill(255);
text("RED", 125, 150);
// GREEN
fill(0, 200, 0);
rect(225, 100, 150, 100);
fill(255);
text("GREEN", 300, 150);
// BLUE
fill(0, 100, 255);
rect(400, 100, 150, 100);
fill(255);
text("BLUE", 475, 150);
// YELLOW
fill(255, 220, 0);
rect(575, 100, 150, 100);
fill(0);
text("YELLOW", 650, 150);
// PURPLE
fill(180, 0, 255);
rect(150, 250, 150, 100);
fill(255);
text("PURPLE", 225, 300);
// CYAN
fill(0, 220, 220);
rect(325, 250, 150, 100);
fill(0);
text("CYAN", 400, 300);
// WHITE
fill(255);
rect(500, 250, 150, 100);
fill(0);
text("WHITE", 575, 300);
// OFF
fill(80);
rect(325, 380, 150, 70);
fill(255);
text("OFF", 400, 415);
}
void mousePressed() {
// RED
if (mouseX > 50 && mouseX < 200 &&
mouseY > 100 && mouseY < 200) {
myPort.write('R');
}
// GREEN
else if (mouseX > 225 && mouseX < 375 &&
mouseY > 100 && mouseY < 200) {
myPort.write('G');
}
// BLUE
else if (mouseX > 400 && mouseX < 550 &&
mouseY > 100 && mouseY < 200) {
myPort.write('B');
}
// YELLOW
else if (mouseX > 575 && mouseX < 725 &&
mouseY > 100 && mouseY < 200) {
myPort.write('Y');
}
// PURPLE
else if (mouseX > 150 && mouseX < 300 &&
mouseY > 250 && mouseY < 350) {
myPort.write('P');
}
// CYAN
else if (mouseX > 325 && mouseX < 475 &&
mouseY > 250 && mouseY < 350) {
myPort.write('C');
}
// WHITE
else if (mouseX > 500 && mouseX < 650 &&
mouseY > 250 && mouseY < 350) {
myPort.write('W');
}
// OFF
else if (mouseX > 325 && mouseX < 475 &&
mouseY > 380 && mouseY < 450) {
myPort.write('O');
}
}Experience with Processing
Working with Processing IDE and XIAO ESP32-C3 was a good practical experience for me. I learned how to create a simple graphical interface and use it to control an RGB LED. I understood how serial communication works between the computer and the microcontroller. While testing the project, I faced some small issues with the COM port and communication, but solving them helped me improve my debugging skills. This activity gave me a better understanding of how software interfaces can be connected with hardware and used for real-time control.
Web Server
A Web Server is a software system that allows a user to access and control a device through a web browser. In embedded systems and IoT, a microcontroller such as the ESP32 can work as a web server by creating a simple webpage. The webpage can contain buttons, switches, or information that can be used to control hardware such as LEDs, relays, and motors. The user can access this webpage using a mobile phone or computer connected to the same network. Web servers are useful in IoT applications because they provide a simple way to monitor and control devices without installing a separate application.
16×2 LCD Control Using Web Server
I used a Web Server with a 16×2 LCD display to create a simple control interface. I created a webpage with input and control options to send text to the LCD display. The ESP32 received the data from the web page and displayed the message on the 16×2 LCD. Through this activity, I learned how a web-based interface can communicate with a microcontroller and control an LCD display. It also helped me understand the practical use of web servers in IoT projects.
CODE
#include <WiFi.h>
#include <WebServer.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
// ---------------- WiFi ----------------
const char* ssid = "karan";
const char* password = "12345678";
// ---------------- LCD ----------------
#define SDA_PIN 8
#define SCL_PIN 9
LiquidCrystal_I2C lcd(0x27, 16, 2);
// ---------------- Web Server ----------------
WebServer server(80);
// LCD text
String line1 = "Hello";
String line2 = "ESP32-C3";
// ---------------- LCD Function ----------------
void showLCD() {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(line1);
lcd.setCursor(0, 1);
lcd.print(line2);
}
// ---------------- Web Page ----------------
void handleRoot() {
String page = "<!DOCTYPE html>";
page += "<html>";
page += "<head>";
page += "<meta name='viewport' content='width=device-width, initial-scale=1'>";
page += "<title>ESP32-C3 Web Server</title>";
page += "<style>";
page += "body{font-family:Arial;text-align:center;margin-top:50px;}";
page += "input{padding:10px;margin:5px;width:250px;}";
page += "button{padding:10px 25px;font-size:18px;}";
page += "</style>";
page += "</head>";
page += "<body>";
page += "<h1>ESP32-C3 Web Server</h1>";
page += "<h2>LCD Control</h2>";
page += "<form action='/set' method='GET'>";
page += "<input type='text' name='line1' maxlength='16' value='" + line1 + "'>";
page += "<br>";
page += "<input type='text' name='line2' maxlength='16' value='" + line2 + "'>";
page += "<br><br>";
page += "<button type='submit'>Update LCD</button>";
page += "</form>";
page += "<h3>Current LCD Data</h3>";
page += "<p>Line 1: " + line1 + "</p>";
page += "<p>Line 2: " + line2 + "</p>";
page += "</body>";
page += "</html>";
server.send(200, "text/html", page);
}
// ---------------- Set LCD Data ----------------
void handleSet() {
if (server.hasArg("line1")) {
line1 = server.arg("line1");
}
if (server.hasArg("line2")) {
line2 = server.arg("line2");
}
showLCD();
server.sendHeader("Location", "/");
server.send(303);
}
// ---------------- Setup ----------------
void setup() {
Serial.begin(115200);
// LCD Start
Wire.begin(SDA_PIN, SCL_PIN);
lcd.init();
lcd.backlight();
showLCD();
// WiFi Start
Serial.println("Connecting to WiFi...");
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("WiFi Connected!");
Serial.print("IP Address: ");
Serial.println(WiFi.localIP());
// Web Server
server.on("/", handleRoot);
server.on("/set", handleSet);
server.begin();
Serial.println("Web Server Started!");
}
// ---------------- Loop ----------------
void loop() {
server.handleClient();
}What i get on web server
ESP32-C3 Web Server
LCD Control
[ Hello ]
[ ESP32-C3 ]
[ Update LCD ]
Current LCD Data
Line 1: Hello
Line 2: ESP32-C3Web Server Experience
I worked with the ESP32-C3 Web Server using Arduino IDE. I connected the ESP32-C3 to Wi-Fi and created a simple web server. I learned how to get the ESP32-C3 IP address and open the web page using a browser. I also controlled a 16×2 I2C LCD through the web server by sending text from the browser and displaying it on the LCD. This practical helped me understand Wi-Fi communication, IP addresses, web server basics, and communication between a web browser and an embedded device. It also improved my skills in testing, debugging, and working with ESP32-C3.
4.p5.js
What is p5.js?
p5.js is a JavaScript library used to create interactive graphics, animations, and web-based applications. It provides simple functions that make it easy to draw shapes, create animations, handle mouse and keyboard input, and build interactive user interfaces. In embedded systems and IoT projects, p5.js can also be used to create a web interface that communicates with a microcontroller and displays or controls data. It is beginner-friendly and useful for learning creative coding and interactive applications.
search p5.js on google
p5.js Web Editor Interface.
p5.js
As part of my individual assignment, I learned about p5.js and explored its Web Editor, coding structure, and basic functions. I used p5.js to create different games, pictures, animations, and interactive graphics by writing my own code with the help of ChatGPT AI for learning, understanding, and developing the programs. This activity helped me understand how code can be used to create visual and interactive applications. I learned about functions, shapes, colors, animations, user interaction, and game logic while experimenting with different projects. This assignment improved my programming skills and gave me practical experience in creative coding and interactive web development.
code
function setup() {
createCanvas(600, 400);
}
function draw() {
// Sky
background(135, 206, 235);
// Sun
fill(255, 200, 0);
noStroke();
circle(450, 100, 100);
// Mountains
fill(80, 100, 120);
triangle(0, 300, 180, 100, 360, 300);
triangle(250, 300, 430, 120, 600, 300);
// Snow on mountains
fill(255);
triangle(180, 100, 145, 140, 165, 130);
triangle(430, 120, 395, 160, 420, 150);
// Ground
fill(60, 150, 80);
rect(0, 300, 600, 100);
// River
fill(70, 170, 220);
beginShape();
vertex(250, 300);
vertex(350, 300);
vertex(500, 400);
vertex(100, 400);
endShape(CLOSE);
// Tree trunk
fill(100, 60, 30);
rect(80, 220, 25, 100);
// Tree leaves
fill(30, 120, 50);
circle(90, 200, 90);
circle(55, 225, 70);
circle(125, 225, 70);
// Birds
noFill();
stroke(0);
strokeWeight(2);
arc(150, 100, 25, 15, PI, TWO_PI);
arc(180, 100, 25, 15, PI, TWO_PI);
// Title
noStroke();
fill(0);
textSize(20);
text("p5.js Sunset Landscape", 20, 30);
}Game on p5.js
CODE
let playerX;
let ballX;
let ballY;
let ballSpeed = 4;
let score = 0;
let gameOver = false;
function setup() {
createCanvas(800, 600);
playerX = width / 2;
ballX = random(30, width - 30);
ballY = 0;
}
function draw() {
background(135, 206, 235);
// Title
fill(0);
textAlign(CENTER);
textSize(28);
text("Catch the Ball Game", width / 2, 40);
// Score
textSize(22);
text("Score: " + score, width / 2, 75);
if (!gameOver) {
// Player movement
if (keyIsDown(LEFT_ARROW)) {
playerX -= 6;
}
if (keyIsDown(RIGHT_ARROW)) {
playerX += 6;
}
// Keep player inside screen
playerX = constrain(playerX, 60, width - 60);
// Player
fill(0, 120, 255);
rect(playerX - 60, height - 70, 120, 25, 10);
// Ball
fill(255, 50, 50);
ellipse(ballX, ballY, 30, 30);
// Ball movement
ballY += ballSpeed;
// Catching the ball
if (
ballY > height - 90 &&
ballY < height - 50 &&
ballX > playerX - 70 &&
ballX < playerX + 70
) {
score++;
ballX = random(30, width - 30);
ballY = 0;
ballSpeed += 0.3;
}
// Ball missed
if (ballY > height) {
gameOver = true;
}
} else {
fill(0);
textSize(40);
text("GAME OVER", width / 2, 280);
textSize(25);
text("Final Score: " + score, width / 2, 330);
textSize(20);
text("Press SPACE to restart", width / 2, 380);
}
}
function keyPressed() {
if (key === ' ' && gameOver) {
score = 0;
ballSpeed = 4;
ballX = random(30, width - 30);
ballY = 0;
gameOver = false;
}
}5.Blockly Games
A Blockly game is a game created using the Blockly visual programming environment, where programming is done by connecting drag-and-drop blocks instead of writing traditional code. These blocks can be used to control the player, movement, conditions, scoring, and game logic. Blockly games are useful for beginners because they make programming easier and more interactive. By creating a game in Blockly, we can understand important programming concepts such as loops, conditions, variables, events, and logic in a simple way.
search blockly on google
blockly games interface
Blockly Games
As part of my individual assignment, I explored Blockly Games, a collection of educational games designed to teach programming concepts using block-based coding. Instead of writing code using traditional programming languages, I arranged and connected different blocks to create instructions and solve challenges. Through these games, I learned basic programming concepts such as sequence, loops, conditions, logic, and problem-solving. This activity made programming easier to understand and helped me develop logical thinking and coding skills in an interactive way.
Blockly Games: Maze
In this assignment, I worked with Blockly Games – Maze, where I used block-based coding to guide a character through a maze and reach the destination. I used programming blocks such as move forward, turn left, turn right, repeat until, and if path to create the required sequence of instructions. The assignment required me to understand the maze structure and arrange the blocks in the correct logical order so that the character could reach the target without getting stuck. This activity helped me understand loops, conditional statements, sequencing, and logical problem-solving through visual programming. It also improved my ability to develop programming logic without writing traditional text-based code.
1. MIT App Inventor
LED Control Using MIT App Inventor
After completing the Bluetooth Terminal project, I created a mobile application using MIT App Inventor to control an LED. I designed a simple user interface with ON and OFF buttons and connected the app to the HC-06 Bluetooth module. By pressing the buttons in the app, I was able to turn the LED ON and OFF wirelessly through Bluetooth. This assignment helped me understand mobile app development, Bluetooth communication, and the integration of Android applications with embedded systems.
What is MIT App Inventor?
MIT App Inventor is a free, web-based platform used to create Android applications without writing complex code. It uses a simple drag-and-drop interface and block-based programming, making it easy for beginners to build mobile apps. MIT App Inventor is widely used for learning app development and creating applications that interact with embedded systems and IoT devices such as Arduino and ESP32 through Bluetooth or Wi-Fi.
Steps a follow to create app on MIT app inventor
first searched for MIT App Inventor on Google Chrome and opened the official website
After opening the website, I clicked on the Create Apps button to start developing my application.
clicked on New Project
entered a project name to create a new application
designed the application interface by adding the required buttons, labels, and other components according to the project requirements
After designing the interface, I opened the Blocks section and created the block-based programming
After completing the block programming, I went to the Build menu and clicked on Android App (.apk) to generate the APK file for the application.
After the APK generation process was completed, the application was ready to download and install on my Android device.
scanned the QR code using my mobile phone and downloaded the application
CODE
#include <WiFi.h>
const char* ssid = "YOUR_WIFI_NAME";
const char* password = "YOUR_WIFI_PASSWORD";
WiFiServer server(80);
const int ledPin = 2; // Built-in LED
void setup() {
Serial.begin(115200);
pinMode(ledPin, OUTPUT);
digitalWrite(ledPin, LOW);
WiFi.begin(ssid, password);
Serial.print("Connecting");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.print("ESP32 IP Address: ");
Serial.println(WiFi.localIP());
server.begin();
}
void loop() {
WiFiClient client = server.available();
if (!client) return;
String request = client.readStringUntil('\r');
client.flush();
if (request.indexOf("/ON") != -1) {
digitalWrite(ledPin, HIGH);
}
if (request.indexOf("/OFF") != -1) {
digitalWrite(ledPin, LOW);
}
client.println("HTTP/1.1 200 OK");
client.println("Content-type:text/html");
client.println();
client.println("OK");
client.stop();
}ESP32 Configuration
To connect the ESP32 with the MIT App Inventor application, the Wi-Fi network name and password were entered in the ESP32 program. The ESP32 was then connected to the same Wi-Fi network as the mobile phone. After successful connection, the ESP32 automatically displayed its IP address in the Serial Monitor. This IP address was used in the MIT App Inventor application to communicate with the ESP32 and control the LED. No IP address was required to be added manually to the ESP32 code.
| Component | ESP32 Pin |
|---|---|
| LED Anode (+) | GPIO 2 |
| LED Cathode (-) | GND |
Experience
This project helped me understand the basic programming and GPIO functionality of the ESP32. I learned how to connect an external LED, upload code using the Arduino IDE, and control the LED by generating HIGH and LOW signals. It also improved my understanding of circuit connections, program execution, and debugging. This hands-on activity increased my confidence in working with ESP32-based embedded projects.
2. Blynk IoT
What is Blynk IoT?
Blynk IoT is an IoT platform that allows users to connect, monitor, and control hardware devices using a mobile or web application. It can be used with microcontrollers such as ESP32 and Arduino. With Blynk, we can create dashboards using buttons, switches, displays, and other widgets to control devices and view sensor data. It is commonly used for projects such as LED control, home automation, sensor monitoring, and smart IoT devices.
Log in and interface of blynk
LED Control Using Blynk
As part of my individual assignment, I used Blynk to create a mobile interface for controlling one LED connected to the XIAO ESP32-C3. I installed the Blynk application, created a project interface, and added a button to control the LED. The XIAO ESP32-C3 was connected to Wi-Fi and linked with the Blynk application. When I pressed the button on the mobile app, a command was sent to the XIAO ESP32-C3, which turned the LED ON or OFF. This assignment helped me understand how a mobile application can be used as an IoT interface to control physical devices remotely.
Create a Template by selecting new template
Create a Datastream and dashboard
edit template ID , template name , token number and wifi name password in the code and upload it in arduinoIDE
#define BLYNK_TEMPLATE_ID "YOUR_TEMPLATE_ID"
#define BLYNK_TEMPLATE_NAME "LED Control"
#define BLYNK_AUTH_TOKEN "YOUR_AUTH_TOKEN"
#include <WiFi.h>
#include <BlynkSimpleEsp32.h>
char ssid[] = "YOUR_WIFI_NAME";
char pass[] = "YOUR_WIFI_PASSWORD";
#define LED_PIN 8
BLYNK_WRITE(V0)
{
int value = param.asInt();
if (value == 1) {
digitalWrite(LED_PIN, HIGH);
}
else {
digitalWrite(LED_PIN, LOW);
}
}
void setup()
{
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
Serial.begin(115200);
Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
}
void loop()
{
Blynk.run();
}Temperature and Humidity Monitoring Using Blynk
As part of my individual assignment, I used the DHT22 sensor, XIAO ESP32-C3, and Blynk to monitor temperature and humidity. The DHT22 sensor was connected to the XIAO ESP32-C3 to measure the surrounding temperature and humidity. The XIAO ESP32-C3 read the sensor values and sent the data through Wi-Fi to the Blynk platform. I created a mobile interface in Blynk to display the temperature and humidity readings using suitable widgets. This assignment helped me understand how sensor data can be collected by a microcontroller and displayed remotely on a mobile application using IoT technology.
create a new template for monitoring temperature and humidity
then create a datastream
then create a dashboard and upload a code in arduino IDE with template ID , template name , token number and wifi name password
CODE
#define BLYNK_TEMPLATE_ID "तुझा_TEMPLATE_ID"
#define BLYNK_TEMPLATE_NAME "DHT22 Monitor"
#define BLYNK_AUTH_TOKEN "तुझा_AUTH_TOKEN"
#include <WiFi.h>
#include <BlynkSimpleEsp32.h>
#include <DHT.h>
char ssid[] = "तुझ्या_MOBILE_HOTSPOT_NAME";
char pass[] = "तुझ्या_MOBILE_HOTSPOT_PASSWORD";
// DHT22 DATA = XIAO ESP32-C3 D2 = GPIO4
#define DHTPIN 4
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);
BlynkTimer timer;
void sendSensorData()
{
float temperature = dht.readTemperature();
float humidity = dht.readHumidity();
// Sensor reading check
if (isnan(temperature) || isnan(humidity))
{
Serial.println("DHT22 reading failed!");
return;
}
// Blynk मध्ये data पाठवणे
Blynk.virtualWrite(V0, temperature);
Blynk.virtualWrite(V1, humidity);
// Serial Monitor
Serial.print("Temperature: ");
Serial.print(temperature);
Serial.println(" °C");
Serial.print("Humidity: ");
Serial.print(humidity);
Serial.println(" %");
Serial.println("----------------------");
}
void setup()
{
Serial.begin(115200);
dht.begin();
Blynk.begin(BLYNK_AUTH_TOKEN, ssid, pass);
// प्रत्येक 2 सेकंदांनी sensor data पाठवणे
timer.setInterval(2000L, sendSensorData);
}
void loop()
{
Blynk.run();
timer.run();
}Overall Experience
Overall, learning about interfaces and applications was a very useful and practical experience for me. I worked with different tools such as PictoBlox, p5.js, Blockly, Processing, and Web Server, and also explored applications like MIT App Inventor and Blynk IoT. I created projects such as a Bounce Ball Game, RGB LED control using Processing, 16×2 LCD control using a Web Server, and Bluetooth LED control using the HC-06 module. Through these activities, I learned how software interfaces and applications can communicate with microcontrollers and control hardware. I also improved my understanding of serial communication, IoT, programming logic, debugging, and hardware-software integration. This practical work increased my confidence in developing simple embedded and IoT applications.
