Practical IoT using Arduino and ESP32

Practical IoT using Arduino and ESP32

Interactive experiments covering sensor reads, Wi-Fi, Bluetooth, and AWS IoT Core connectivity

Pravin Dhandre

Disclaimer

This book, including all its text, diagrams, and illustrations, is an original work developed for educational and informational purposes. The content is not affiliated with, endorsed by, or sponsored by Arduino, Espressif (ESP32), Amazon Web Services (AWS), or any other company, brand, or entity referenced within. All brand names, product names, and trademarks mentioned are the property of their respective owners and are used in a descriptive, educational context only. Every effort has been made to ensure that no copyrighted or trademarked material has been copied or misused in this book. All diagrams and illustrations that are not original have been used with proper attribution and credit to their respective sources.

If you believe that any content in this book infringes upon your copyright or trademark, please contact us immediately at support@gitforgits.com. Upon notification, corrective action will be taken promptly.

Preface

This handy book will get you up and running with Arduino and ESP32 in no time, teaching you how to think, design, and build real-world IoT applications. You'll start by exploring the Uno and ESP32 boards, identifying pins, and powering sensors and LEDs. Then, you get the Arduino IDE up and running, handle libraries and flags, and learn how to write, upload, and debug sketches.

You'll be working on building some key C++ skills, like handling data types, loops, functions, and classes, and you'll be doing all of this without getting stuck. Then you move on to sensors, where you're reading digital and analog signals, calibrating measurements, scaling values, and filtering noise. You'll be driving I2C and SPI displays for clear visual feedback. Next, we'll dive into camera modules, where you'll learn how to wire an OV7670 or ESP32-CAM, capture and compress images, save them to SPIFFS or SD, and run basic image analysis. There are wireless chapters that teach Wi-Fi, HTTPS with JSON, MQTT messaging, Bluetooth LE vs Classic, and token-based security.

Later on, you'll find chapters about Cloud and low-power stuff, like JSON building, AWS IoT Core connections, live dashboards with WebSockets and Node-RED, Google Sheets logging, and deep sleep with batched updates. And the final projects really tie it all together: a temperature monitor that notifies the cloud, an OLED QR-code generator, an ethical Wi-Fi jamming demo, and an RTC alarm clock with mobile notifications. All of our projects combine wiring, code, networking, and power management, so you'll gain real-world IoT skills without claiming total mastery.

In this book you will learn how to:

Use Uno and ESP32 pins for sensors, power, and communication.

Set up Arduino IDE, boards, libraries, and compile flags effectively.

Use C++ to create efficient programs with loops, functions, and classes. Also use non-blocking timing.

Read, calibrate, and filter the sensor data to get accurate measurements.

Get clear visual feedback by driving I2C/SPI displays with Adafruit GFX.

Capture and process images using OV7670 or ESP32-CAM modules.

Enable Wi-Fi, HTTPS, MQTT, and Bluetooth for secure IoT communication.

Combine AWS IoT and Node-RED to create real-time data dashboards.

Log to Google Sheets and extend your battery life with deep sleep.

Build projects like cloud alerts, QR codes, Wi-Fi jamming, and RTC alarms.

GitforGits

Prerequisites

If you don’t know Arduino, what a microcontroller does, or how does really IoT project is developed, this is the perfect handy book to get to know the foundations of IoT and dive into building the smart IoT applications with just knowing the basics of programming.

Codes Usage

Are you in need of some helpful code examples to assist you in our programming and documentation? Look no further! Our book offers a wealth of supplemental material, including code examples and exercises.

Not only is this book here to aid you in getting our job done, but you have our permission to use the example code in our programs and documentation. However, please note that if you are reproducing a significant portion of the code, we do require you to contact us for permission.

But don't worry, using several chunks of code from this book in our program or answering a question by citing our book and quoting example code does not require permission. But if you do choose to give credit, an attribution typically includes the title, author, publisher, and ISBN. For example, Practical IoT using Arduino and ESP32 by Pravin Dhandre.

If you are unsure whether our intended use of the code examples falls under fair use or the permissions outlined above, please do not hesitate to reach out to us at support@gitforgits.com. 

We are happy to assist and clarify any concerns.

Prologue

When researchers asked for clear explanations of complex circuits, I found myself translating dense theory into straightforward steps. I've worked with professors, consultants, and academic teams over the years, helping them deliver technical workshops to engineers and students worldwide. While talking about data science, web development, and cloud computing, I noticed that someone was curious about microcontrollers and connected devices.

It was a real mix of topics, from amplifier biasing to how a tiny board could read a sensor and report data over the internet. Every time I asked myself, How do we make that? I got closer to Arduino and ESP32. I ordered my first development board, wired a temperature sensor, and hesitated at the blank setup() and loop() functions. Writing code felt a bit weird, but the idea of a sensor that could tweet its readings was too good to pass up.

I spent my evenings getting the hang of C++ basics—variables, loops, functions—and figured out how those constructs turn raw voltage into meaningful numbers. When a simple sketch made an LED blink, a new door opened: I could combine hardware wiring with software logic. I was soon polling analog pins, driving OLED graphics, capturing camera frames, and securing data over Wi-Fi. Each experiment built on the last, and they all had to do with the lessons I learned from my work with academics. Those lessons were clear communication, step-by-step reasoning, and practical examples.

This book came from a mix of teaching and tinkering. It's a collection of the projects I've built to connect the theoretical side with real-world IoT solutions. You'll start by getting the lowdown on hardware basics—the pins and power rails that connect sensors and actuators. You'll learn how to set up modern development tools, write efficient code without blocking, and structure your sketches for maintainability. You'll dive into digital and analog sensors, displays, camera modules, and wireless protocols, all with the same simple approach I used when helping researchers.

Later on, we'll dive into cloud services, like publishing data to AWS IoT, streaming live dashboards with Node-RED, and logging to Google Sheets. You'll learn how to stretch your battery life with deep sleep and batch transmissions. Finally, practical projects tie everything together: environmental monitors that alert in real time, QR-code generators on tiny screens, ethical jamming demonstrations for protocol study, and alarm clocks that buzz and send notifications at the right moment.

My goal isn't to make you an overnight expert in every niche of IoT and robotics.  If you've ever wanted to bring sensors, displays, and cloud services into a single project, you'll find a clear path forward here. My name is Pravin Dhandre, and I'm thrilled to share this hands-on journey. It's a collection of experiments and insights that came from helping others learn and my own exploration of Arduino and ESP32.

Copyright © 2025 by GitforGits

All rights reserved. This book is protected under copyright laws and no part of it may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage and retrieval system, without the prior written permission of the publisher. Any unauthorized reproduction, distribution, or transmission of this work may result in civil and criminal penalties and will be dealt with in the respective jurisdiction at anywhere in India, in accordance with the applicable copyright laws.

Published by: GitforGits

Publisher: Sonal Dhandre

www.gitforgits.com

support@gitforgits.com

Printed in India

First Printing: February 2025

Cover Design by: Kitten Publishing

For permission to use material from this book, please contact GitforGits at support@gitforgits.com.

Content

Preface

GitforGits

Acknowledgement

Chapter 1: UNO & ESP32 Overview

Overview

UNO Pinout & Functions

Microcontroller Overview

Why UNO Pinout?

Identifying Digital Pins

Pin Layout

Basic Operations

Built-in LED Indicator (Pin 13)

Pins with PWM Capability

Communication Pins D0 & D1

Pins 2 & 3 for Interrupts

Recognizing Analog Input Pins

Location of Analog Pins

Voltage Reference

Reading Sensors

I²C Communication on A4 & A5

Unused Analog Pin for Extra Digital I/O

Locating Power Pins

5 V Pin (Regulated Output)

3.3 V Pin (Regulated Output)

VIN Pin (Unregulated Input)

Ground Pins (GND)

IOREF Pin

Finding Ground Pins

Why Multiple GND Pins?

Importance of Common Ground

Breadboard Ground Bus Connections

Pin Functions in Sketches

Digital Pins

Analog Pins

Power and Ground

PWM-Capable Pins

I²C Pins

Serial Pins

Interrupt Pins

Sketch Walkthrough

ESP32 Key Features

ESP32 Architecture Highlights

WiFi Capabilities

Bluetooth Flexibility

GPIO Layout

PWM on ESP32

Analog-to-Digital and Digital-to-Analog Converter

I²C, SPI & UART Peripherals

I²C Bus

SPI Bus

UART Ports

Built-In Sensors and Co-Processors

Hall Effect Sensor

Touch Sensors

Temperature Sensor (On-Chip)

Memory and Storage

Flash Memory (4 MB or Larger)

SRAM (520 KB)

PSRAM (Optional)

Power Management and Sleep Modes

Light Sleep

Deep Sleep

ULP Co-Processor

GPIO and Peripheral Summary

Board Capabilities Comparison

CPU Speed and Architecture

UNO’s ATmega328P

ESP32’s Dual-Core LX6

Memory Resources

Uno’s Constraints

ESP32’s Generous Space

I/O Count and Peripherals

UNO’s Pin Count

ESP32’s Flexible GPIO

Power Profiles

Uno’s Power Consumption

ESP32’s Versatile Sleep States

Comparison Summary

Power & Voltage Basics

Acceptable Input Voltages

Onboard Regulators and Power Rails

5 V Regulator

3.3 V Regulator

Current Limits and Safe Design

Onboard 5 V Regulator

USB 5 V Source

Digital Pin Current

3.3 V Pin Current

Using External Regulators

Designing Stable Power Architectures

Estimate Total Current Draw

Choose Input Source

Voltage Regulation

Grounding and Noise Reduction

Testing under Load

Sample Sketch: Practical Wiring on Uno Board

External 9 V Adapter to VIN

Adding a 3.3 V Sensor

Ground Wiring

Driver Setup & Blink Test

Setting up USB Drivers

Selecting Board and Port in Arduino IDE

Writing and Uploading the Blink Sketch

Troubleshooting Common Issues

Summary

Chapter 2: Arduino IDE & Toolchain

Overview

IDE 2.0 Installation & Setup

Introducing Arduino IDE 2.0

Arduino IDE 2.0 on Windows

Configuring Board URLs for Uno and ESP32

Installing ESP32 Core

Exploring Editor & Serial Monitor

Exploring Code Editor

Writing and Verifying Code

Opening Serial Monitor

Using Serial Plotter

Interactive Debugging Workflow

Library Manager & PlatformIO

Using Library Manager

Opening Library Manager

Searching for Library

Installing Library

PlatformIO for Dependency Management

Installing PlatformIO IDE

Creating PlatformIO Project

Adding Library Dependency

Using Library in Code

Updating/Locking Library Versions

Compiler Flags & Verbose Output

Adjusting Compiler Optimization Settings

Changing Optimization in Arduino IDE 2.0

Changing Optimization in PlatformIO

Enabling Verbose Build Logs

Enabling Verbose Output in Arduino IDE 2.0

Enabling Verbose Output in PlatformIO

Interpreting Compiler Messages

Include Paths and Header Errors

Type Mismatch or Undefined References

Linker Errors (Undefined References)

Warning: Deprecation or Compatibility

Debugging with LEDs & Serial

Preparing Blink-and-Print Sketch

Uploading and Observing Serial Output

Adding Variable Inspection

Tracing Complex Program Flow

Observing LED Behavior for Debugging

Combining Serial and LED Techniques

Summary

Chapter 3: C++ Fundamentals for Sketches

Overview

Data Types & Memory Use

Microcontroller Memory Layout

Integer Types and their Memory Impact

Sample Program: Measuring Sizes

Floating-Point Types

Booleans and Memory

Constants and ‘const’

Storing Data in PROGMEM (Flash)

Storing Constant Strings in PROGMEM

PROGMEM on ESP32

Inspecting Free SRAM at Runtime

Diagram Summary

Loops, Conditionals & Switches

For Loops

Inspecting Loop Progress via Serial

While Loops

Wiring Pushbutton

Streaming Blinks until Button Press

If/Else Logic

Wiring Potentiometer

Upload and Rotate Knob

Switch Statements

Listening for Serial Commands

Combining Loops and Conditionals

Functions & Parameter Passing

Refactoring with Value Parameters

Passing Parameters by Reference

Define Function Signature

Modify loop() to Use checkSensors

Upload and Observe

Returning Complex Data Structures

Upload and Confirm

Simple Classes & Abstraction

Defining TemperatureSensor Class

Instantiating Sensor Objects

Refactoring ‘setup()’ and ‘loop()’

Constructor Demonstration

Non-blocking Timing with ‘millis()’

Why to Avoid ‘delay()’?

How ‘millis()’ Works?

Adding Concurrent Task

Extending Additional Tasks

Sample Program: State Machine without Blocking

Summary

Chapter 4: Digital & Analog Sensors

Overview

Digital Input & Debounce Logic

Polling Digital Pins

Wiring Pushbutton

Why Mechanical Switches Bounce?

Implementing Software Debounce

Debounce Sketch without Blocking

Testing Debounce Reliability

Sample Program: Mode Selection with Debounced Buttons

Reading Analog with analogRead()

Wiring and Sampling Potentiometer

Choosing and Changing Voltage References

Reading Photodiode as Analog Sensor

Interpreting Raw Values

Sensor Calibration Techniques

Deriving Calibration Curve

Applying Linear Scaling to Other Sensors

Compensating Sensor Drift over Time

Design Zero-Point Routine

Implement Periodic Re-Zero

Handling Non-Linear Sensor Responses

Scaling Values to Units

‘map()’ for Simple Integer Scaling

Writing Float-Based Scaling Function

Mapping Humidity from Analog Humidity Sensor

Combining ‘map()’ and float Scaling

Building Reusable Scaling Function

Noise Filtering & Pull Resistors

Pull-Up and Pull-Down Resistors for Digital Inputs

Wiring a Pull-Down Resistor

Using Built-In Pull-Up

Moving Average Filter for Analog Noise

Exponential (Low-Pass) Filter for Analog Inputs

Applying Digital Input Filtering

Combining Analog and Digital Filters

Summary

Chapter 5: Displays & User Interfaces

Overview

I²C Character LCDs

Popular Display Types for Arduino and ESP32

Character LCDs (HD44780-based)

Graphical OLED Displays (e.g., SSD1306)

TFT LCDs (e.g., ST7735, ILI9341)

E-Ink Displays

LED Matrices (e.g., MAX7219-based 8×8 modules)

Wiring 16×2 or 20×4 LCD via I²C Backpack

Using ‘LiquidCrystal_I2C’ Library

Determine LCD’s I²C Address

Initializing and Printing to LCD

Customizing Contrast, Backlight, and Cursor

SPI OLED & TFT Graphics

Popular SPI-Driven Graphic Displays

SSD1306 OLED (128×64 pixels)

ST7735/ST7789 TFT (128×160 or 160×128 pixels)

Wiring SSD1306 OLED over SPI

Pin Mapping

Physical Connections

Wiring ST7735/ST7789 TFT over SPI

Pin Mapping

Physical Connections

Installing Required Libraries

Adafruit GFX Core

Adafruit SSD1306 OLED Library

Adafruit ST7735/ST7789 TFT Library

Sample Program: Drawing on SSD1306 OLED (SPI Mode)

Sample Program: Drawing on ST7735 TFT (SPI Mode)

Capacitive Touch Inputs

Capacitive Touch Sensing

Wiring Capacitive Touch Sensor

Configuring Sensor Sensitivity

Handling Capacitive Touch Events in Sketch

Replacing Mechanical Buttons with Sleek Touch Controls

Menu Structure & Navigation

Building Menu Data Structures

Initializing Buttons for Navigation

Displaying Menu Items on Small Screen

Handling Button Presses for Navigation

Updating Display

Efficient Display Refresh

Character LCD

OLED Displays

TFT Displays

Sample Program: Partial Bar Graph Redraw on SSD1306

Integrating Efficient Refresh into User Interface

Summary

Chapter 6: Camera & Image Handling

Overview

Wiring OV7670 & ESP32-CAM

Wiring OV7670 (with FIFO)

Power and Ground

I²C (SCCB) Interface

SPI-FIFO Interface

Wiring ESP32-CAM Board

Capturing & Encoding JPEG

Raw Frame Capture with ArduCAM

Library and Module Requirements

Initializing Camera for JPEG Capture

Triggering JPEG Snapshot

Reading JPEG Data and Managing Buffers

Capturing and Encoding JPEG on ESP32-CAM

Include ESP32 Camera Library

Initialize Camera and Wi-Fi

Grab Frame and Access JPEG Buffer

Streaming JPEG over HTTP

Saving JPEG to SD Card

Sample Program: Streaming JPEG over Serial

Sample Program: Saving JPEG to SD Card on ESP32-CAM

Managing JPEG Buffer Lifetimes and Error Handling

Always Return Frame Buffers

Check for Null Pointers and Length Zero

Watch for SD Card Errors

Avoid Blocking Calls

Saving to SPIFFS/SD Card

Mounting File System

Mounting SPIFFS on ESP32

Mounting SD Card on ESP32

Mounting SD Card on Arduino Uno

Writing JPEG Files to SPIFFS or SD Card

Writing to SPIFFS on ESP32

Writing to SD Card on ESP32

Writing to SD Card on Arduino Uno

Basic Thresholding & Edges

Capturing Grayscale Frame

Adjust Camera Configuration

Capture Frame

Layout of Buffer

Applying Simple Binary Threshold

Choose Threshold Value

Allocate Binary Output Buffer

Iterate over each Pixel

Visualize Result

Implementing Simple Edge Detection (Sobel Operator)

Define Sobel Kernels

Allocate Edge Buffer

Compute Gradient at each Pixel

Display Edge Map

RAM & Buffer Optimization

Reducing Resolution

Reusing Buffers

Leveraging DMA

Summary

Chapter 7: WiFi & Bluetooth Networking

Overview

ESP32 WiFi Connection Logic

Scanning Nearby Wi-Fi

Securely storing Wi-Fi Credentials

Implementing Wi-Fi Connection and Reconnection Logic

Verifying Connection Status and Signal Strength

Storing Multiple Network Profiles

HTTP Requests & JSON Parsing

Sending HTTP GET Requests

Parsing JSON Responses

Sending HTTP POST Requests

Handling HTTPS and Certificates

MQTT Publish/Subscribe

Installing ‘PubSubClient’

MQTT on Arduino Uno with ESP8266

Quality of Service (QoS) Levels

Retained Messages and Last Will

BLE vs. Classic Bluetooth

Pairing Processes and Security Considerations

Data Rates and Power Consumption

Choosing Right Bluetooth Mode

TLS Security & Tokens

Enabling TLS for HTTP on ESP32

Securing MQTT with TLS

Managing Certificates on ESP32

Upload Certificate to SPIFFS

Code to Read PEM from SPIFFS

Implementing Token-Based Authentication

Bearer Token in Authorization Header

Token as Username

Refreshing and Revoking Tokens

Summary

Chapter 8: IoT Protocols & Cloud

Overview

Building & Parsing JSON

Introduction to ArduinoJson

Constructing JSON Objects

Parsing JSON Data

Connecting to Cloud Services

EAWS IoT Core Overview

Connect and Publish Telemetry

Real-Time WebSocket Dashboards

Building WebSocket Server in Node-RED

Streaming ESP32 via WebSocket

Building Browser Dashboard

Logging Google Sheets & InfluxDB

Setting up Google Sheet for HTTP Logging

Writing Apps Script Function

Deploying as Web App

Preparing ESP32 to Send Data

Power-Saving Communication

Configuring Wake-Up Triggers

Batching Data and Transmissions

Sample Program: Implementing ESP32 Deep Sleep

Summary

Chapter 9: Smart IoT Projects

Overview

Cloud-Alert Temp Monitor

Reading and Converting Analog Temperature

Implementing Threshold Detection

Building JSON Payload with Reading/Status

Secure MQTT Connection to AWS IoT Core

Node-RED Flow for Alert Routing/Push Notification

Implementing Batched Transmissions and Deep Sleep

Testing and Verification

OLED QR-Code Generator

Generating QR Code from Text/Sensor Data

Rendering QR Code on OLED Display

Integrating Sensor Data Updates

Scanning QR Code with Mobile

Ethical WiFi Jamming

Scanning Wi-Fi Channels (Chapter 7 Refresher)

Switching to Promiscuous Mode

Crafting and Sending Deauthentication Frames

Discovering Target AP and Clients

RTC Alarm Clock & Alerts

Installing RTC Library and Initializing I²C

Setting and Storing Alarm Time

Checking RTC and Triggering Alarm

Activating Buzzer and Mobile Notification

Program Alarm via Serial

Displaying Time and Alarm Status

Implementing Snooze and Cancel

Summary

Index

Chapter 1: UNO & ESP32 Overview

Overview

In this chapter, we'll take a look at why the UNO and the ESP32 are such a big deal for all sorts of projects, both hobbyist and professional. Each board's processor, memory, and peripheral set shape its strengths. We'll teach you to identify every UNO pin—digital, analog, PWM, power, and ground—so you can wire sensors and actuators with confidence. We will learn about the ESP32's pin layout, including its GPIO, ADC, DAC, and touch-sensor capabilities. This will get us ready to use WiFi and Bluetooth in future lessons. We will compare CPU speed, flash and SRAM capacities, I/O counts, and built-in peripherals so you can choose the right board whenever a new robotics or embedded application comes up. We will learn about acceptable input voltages, onboard regulators, USB versus battery supplies, and current limits.

Then, you'll design stable power architectures that keep components running reliably. Finally, you'll install USB drivers on Windows, select the Arduino Uno board and port in the IDE, and upload a blink sketch. We can do a quick test to make sure that the drivers, hardware, and power arrangements are working together right. By the time you reach the end of the chapter, you'll be well-prepared to wire sensors and write sketches with ease, setting us up for more in-depth topics.

UNO Pinout & Functions

Microcontroller Overview

These days, working with microcontrollers like the Arduino Uno and ESP32 is the way to go if you want to create devices that blend hardware and software in seamless ways. We will learn how to create interactive gadgets, automate tasks, and build Internet-connected tools in our home or workshop. It's really cool to see the LEDs blink when you give them commands, to have sensors report live data, and to have wireless modules stream information to the cloud. When our code reliably drives motors, reads temperature, or publishes values to a dashboard, you're onto something. We'll work together to get the hang of microcontroller operation, hardware wiring, and the basics of C++ sketch design. This will help make custom robotics, smart home applications, and innovative prototypes much more achievable.

When you get the hang of this, you'll be doing more than just knowing pin numbers or writing loops. We will learn circuit design principles, how to debug hardware–software interactions, and how to apply