🌐 You can read this article in: Português | Español

Arduino was born at the Interaction Design Institute in Ivrea with a simple goal: to allow students without experience in electronics and programming to create interactive projects. What started as an educational tool evolved to become one of the most versatile platforms in the maker world, adapting to new requirements and technological challenges.

Today, Arduino boards range from simple 8-bit versions to advanced products for Internet of Things (IoT) applications, 3D printing, wearables, and embedded environments. This diversity allows both beginners and professionals to find the perfect board for their projects.

One of the greatest virtues of the Arduino ecosystem is that all boards are fully open-source, allowing users to create them independently and adapt them to their specific needs. This open philosophy has driven a global community of creators who share knowledge and continuously expand the possibilities of these boards.

💡 Curiosity: Over the years, Arduino boards have been used to build thousands of projects, from everyday objects to complex scientific instruments. An international community of designers, artists, students, programmers, and enthusiasts has formed around this platform, contributing an impressive amount of knowledge accessible to all.

What is Arduino?

The Arduino board is an open-source platform used to develop electronic projects. It consists of two main components:

🔧 Hardware

A physical board with a microcontroller that can be programmed to interact with sensors, motors, LEDs, and other electronic components.

💻 Software

The Integrated Development Environment (IDE) that runs on your computer, allowing you to write and upload code to the physical board.

👉 To better understand what Arduino is: Arduino: What It Is, How It Works, and Why You Should Start Using It!

Why choose Arduino boards?

Arduino boards have become popular for various reasons, especially for their accessibility and versatility. The Arduino software is extremely beginner-friendly, yet flexible enough for advanced users.

The IDE is available for free on Windows, Linux, and Mac, facilitating its use in educational environments. Teachers and students can use it to create low-cost scientific instruments and demonstrate physics and chemistry principles practically.

Although there are other microcontroller platforms like Netmedia's BX-24, the Parallax Basic Stamp, MIT's Handyboard, and Phidget, Arduino offers distinctive advantages:

• ✅ Affordable: Accessible boards for all budgets
• ✅ Cross-platform: Works on Windows, Mac, and Linux
• ✅ Simple programming environment: Clean and intuitive interface
• ✅ Open-Source Software: Fully customizable and extensible
• ✅ Open hardware: Schematics and designs available for modification

Types of Arduino Boards

Every day, new types of embedded boards emerge worldwide, with differentiated functionalities and improved designs that make usability increasingly better. There are numerous varieties of Arduino boards, but we will focus on the most popular and easiest to find in the Brazilian market.

📌 Note: This guide covers the most popular boards in Brazil. If you are looking for newer models like the Arduino Portenta or the Nano 33 BLE, leave a comment at the end of the article and we can address them in future publications!

The most commonly used Arduino board:

Arduino UNO

• The most popular board for beginners

Arduino Mega

• For complex projects with many components

Arduino Nano

• Compact and perfect for small prototypes

Arduino Pro Mini

• Ultra compact for final projects

Arduino Leonardo

• With native USB communication

Arduino LilyPad

• Designed for wearables and smart clothing

Detailed Analysis of Main Arduino Boards

1. Arduino Uno R3: The Classic for Beginners

🏆 Ideal for: Beginners, educational projects, and simple prototypes

Microcontroller: ATmega328P | Clock: 16 MHz

Advantages:

• ✔️ Integrated USB communication (plug-and-play)
• ✔️ Compatible with 90% of Shields (expansions)
• ✔️ Ideal for educational projects (e.g., traffic light, alarm)
• ✔️ Widely documented with thousands of tutorials
• ✔️ Large online support community

Disadvantages:

• ❌ Limited memory for systems with many sensors
• ❌ Fewer I/O pins compared to larger models

💰 Average price in the USA: $15 - $30

Arduino Uno R3 Specifications

Microcontroller: ATmega328

Input Voltage: 6V - 20V

Recommended Voltage: 7V - 12V

Digital I/O Pins: 14 (6 PWM)

Analog Inputs: 6

DC Current per I/O Pin: 40mA

Flash Memory: 32 KB (0.5KB for bootloader)

SRAM: 2 KB

EEPROM: 1 KB

Clock Speed: 16 MHz

💡 Ideal Project for Arduino Uno:

The Arduino Uno is perfect for creating an automated irrigation system for plants. With its 6 analog pins, you can monitor soil moisture in different pots and activate water pumps when necessary. It is an excellent educational project that teaches electronics, programming, and automation concepts!

2. Arduino Mega R3: Power for Complex Systems

🏆 Ideal for: Industrial automation, advanced robotics, and projects with multiple sensors

Microcontroller: ATmega2560 | Clock: 16 MHz

Highlight: 54 I/O pins and 256KB of memory.

Best For:

• ✔️ Industrial automation
• ✔️ Systems with multiple sensors (e.g., smart greenhouse)
• ✔️ Complex robotics projects
• ✔️ CNC controllers and 3D printers

Comparison:

• Mega vs. Uno: 4x more memory, but 2x more expensive
• Mega vs. Nano: Significantly larger, but with many more pins

💰 Average price in the USA: $15 - $45

⚠️ Caution: Requires a 12V power supply to function with all peripherals.

Arduino Mega (R3) Specifications

Microcontroller: ATmega2560

Input Voltage: 6V - 20V

Recommended Voltage: 7V - 12V

Digital I/O Pins: 54 (14 PWM)

Analog Inputs: 16

DC Current per I/O Pin: 40mA

Flash Memory: 256KB

Clock Speed: 16MHz

💡 Ideal Project for Arduino Mega:

With its 54 digital pins and 16 analog inputs, the Arduino Mega is perfect for building a complete smart greenhouse. You can monitor temperature, humidity, light, soil pH, control irrigation systems, lighting, ventilation, and still have pins left for future expansions!

3. Arduino Nano: Compact and Versatile

🏆 Ideal for: Compact projects, breadboard prototypes, and wearables

Microcontroller: ATmega328 | Clock: 16 MHz

Advantages:

• ✔️ 45% smaller than the Uno
• ✔️ USB-C in recent versions (Nano Every)
• ✔️ Perfect for breadboards (fits directly)
• ✔️ Low power consumption

Uses:

Drones, Wearables, battery-powered projects, compact prototypes.

Common Mistake:

• ❌ Do not use in projects with more than 8 sensors (lack of pins)

💰 Average price in the USA: $5 - $25

Arduino Nano 3.0 Specifications

Microcontroller: Atmel Atmega328

Input Voltage: 3.3V - 20V

Recommended Voltage: 7V - 12V

Digital I/O Pins: 14 (6 PWM)

Analog Inputs: 8 (10-bit resolution)

DC Current per I/O Pin: 40mA

Flash Memory: 16 Kb (2 Kb for bootloader)

SRAM: 2 Kb

EEPROM: 1Kb

Clock Speed: 16 MHz

💡 Ideal Project for Arduino Nano:

The Arduino Nano is perfect for creating a mini quadcopter drone. Its compact size and reduced weight are ideal for aerial applications, while its PWM pins allow precise control of the four motors. Add an MPU-6050 sensor for stabilization and you'll have a functional drone in a small space!

4. Arduino Pro Mini: Compact and Pure for Professional Projects

🏆 Ideal for: Final projects where space and economy are essential

Microcontroller: ATmega328P | Clock: 16 MHz

Advantages:

• ✔️ Dimensions: 18mm x 33mm (60% smaller than the Uno)
• ✔️ Extremely low cost
• ✔️ Energy efficiency, with minimal consumption
• ✔️ Perfect for projects that will be permanently assembled

Disadvantages:

• ❌ No Integrated USB: Requires FTDI adapter or USB-Serial converter for programming
• ❌ No Voltage Regulator: Power supply must be stable (e.g., exact 3.3V or 5V)

💰 Average price in the USA: $5 - $15

Arduino Pro Mini Specifications

Microcontroller: ATmega328p

Input Voltage: 3.3V or 5V (distinct models)

Digital I/O Pins: 14 (6 PWM)

Analog Inputs: 8

DC Current per I/O Pin: 40mA

Flash Memory: 32KB (2KB for bootloader)

SRAM: 1KB

EEPROM: 1KB

Clock Speed: 8 MHz (3.3V) or 16 MHz (5V)

💡 Ideal Project for Arduino Pro Mini:

The Pro Mini is excellent for creating a beehive monitoring system. Its reduced size allows for discreet installation inside the hive, and its low power consumption ensures long battery life. With temperature, humidity, and weight sensors, you can monitor the health of the hive remotely!

5. Arduino Leonardo: The Board with Integrated USB Communication

🏆 Ideal for: Projects that need to interact directly with the computer

Microcontroller: ATmega32u4 (with native USB) | Clock: 16 MHz

Advantages:

• ✔️ Native USB communication (Can emulate keyboards, mice, and controllers (HID))
• ✔️ Automation projects (e.g., custom macro keyboard)
• ✔️ Direct interaction with PC without extra components
• ✔️ More digital pins than the Uno (20 vs 14)

Disadvantages:

• ❌ ompatibility: Some Shields do not work due to the difference in the USB chip
• ❌ Learning Curve: Requires care when programming HID functions

Comparison:

• Leonardo vs. Uno: 6 extra digital pins and 6 additional analog inputs

💰 Average price in the USA: $10 - $25

Arduino Leonardo Specifications

Microcontroller: ATmega32u4 (with native USB)

Input Voltage: 6-20V

Recommended Voltage: 7V - 12V

Digital I/O Pins: 20 (7 PWM)

Analog Inputs: 12

DC Current per I/O Pin: 40mA

Flash Memory: 32 KB (4KB for bootloader)

Clock Speed: 16 MHz

💡 Ideal Project for Arduino Leonardo:

With its ability to emulate USB devices, the Leonardo is perfect for creating a custom controller for games or editing software. You can build a joystick with programmable buttons, a dial to control parameters in audio or video software, or even a custom shortcut keyboard for your workflow!

6. Arduino LilyPad: Wearable Technology

🏆 Ideal for: Smart clothing projects and wearables

Differential: Circular shape and washable.

Applications:

• ✔️ Smart clothing (e.g., LED jacket)
• ✔️ Accessories with motion sensors
• ✔️ Interactive wearable art
• ✔️ Monitoring of vital signs in sportswear

Limitation:

• ❌ Does not support traditional Shields

💰 Average price in the USA: $10 - $30

🔧 Pro Tip: Use conductive thread to sew circuits!

Arduino LilyPad Specifications

Microcontroller: ATmega168V

Input Voltage: 2.7 - 5.5V

Digital I/O Pins: 14 (6 PWM)

Analog Inputs: 6

DC Current per I/O Pin: 40mA

Flash Memory: 16 KB (2KB for bootloader)

Clock Speed: 8 MHz

This Arduino technology was designed and developed by Leah Buechley and each LilyPad was created with large connectors to allow them to be sewn into clothing. There are various input, output, and sensor boards available, and all are washable.

💡 Ideal Project for Arduino LilyPad:

Create a smart cyclist jacket with the LilyPad! Add LEDs on the back that blink when you brake, directional arrows activated by buttons on the handlebars, and a light sensor that automatically increases the LED brightness at night. It's a practical, safe, and impressive project that demonstrates the full potential of wearables!

📖 Arduino Boards Comparative Table

In this table, we compare the main characteristics of Arduino boards to help you choose the ideal one for your project:

Model	Microcontroller	Clock	Flash Memory	SRAM	EEPROM	Digital Pins	Analog Pins	Operating Voltage	Average Price (USD)
Arduino UNO	ATmega328P	16 MHz	32 KB	2 KB	1 KB	14 (6 PWM)	6	5V	$15 - $30
Arduino Mega	ATmega2560	16 MHz	256 KB	8 KB	4 KB	54 (14 PWM)	16	5V	$15 - $45
Arduino Nano	ATmega328	16 MHz	16 KB	2 KB	1 KB	14 (6 PWM)	8	5V	$5 - $25
Arduino Pro Mini	ATmega328P	8/16 MHz	32 KB	1 KB	1 KB	14 (6 PWM)	8	3.3V/5V	$5 - $15
Arduino Leonardo	ATmega32u4	16 MHz	32 KB	2.5 KB	1 KB	20 (7 PWM)	12	5V	$10 - $25
Arduino LilyPad	ATmega168V	8 MHz	16 KB	1 KB	512 B	14 (6 PWM)	6	2.7-5.5V	$10 - $30

💡 Tip: To quickly compare boards, note that the Arduino Mega offers 4x more flash memory than the UNO, while the Nano maintains the same specifications as the UNO in a 45% smaller format. The Pro Mini is ideal for final projects due to its reduced size and low consumption.

⚠️ Note on prices: The values presented are market averages in the USA and may vary according to the store and whether the product is an original board or a clone. Original Arduinos usually cost more but offer greater quality assurance and compatibility.

🎯 How to Choose the Ideal Arduino for Your Project?

For Beginners:

We recommend the Arduino Uno - it is the most documented board, with a vast support community and compatible with most available shields and tutorials.

For Compact Projects:

The Arduino Nano is ideal for breadboard prototypes or projects with limited space, maintaining the ease of programming of the Uno.

For Complex Projects:

If you need many pins or more memory, the Arduino Mega offers 54 digital pins and 256KB of flash memory.

For Final Projects:

The Arduino Pro Mini is perfect for projects that will be permanently assembled, due to its reduced size and low cost.

For Computer Interaction:

The Arduino Leonardo can emulate a keyboard and mouse, being ideal for custom controls and PC task automation.

For Wearables:

The Arduino LilyPad was specifically designed to be sewn into clothes and accessories, being washable and with a circular shape.

🤔 Frequently Asked Questions (FAQ)

To ensure your project is a success, we have compiled some of the most common questions about this charger. Check it out!

What is the difference between Original Arduino and Clones? 🔽

Original Arduinos are manufactured by the official company and guarantee quality and support. Clones are cheaper versions produced by third parties, generally in China. Although they work similarly, they may have differences in component quality and reliability.

Can I use the same code on different Arduino boards? 🔽

In most cases, yes! Code written for an Arduino Uno will generally work on a Nano or Mega without modifications. However, if you are using specific pins or special features of a board, you may need to adjust the code.

Which is the best Arduino for beginners? 🔽

The Arduino Uno is generally recommended for beginners due to its simplicity, extensive documentation, and compatibility with most projects and tutorials available online.

Is Arduino difficult to learn? 🔽

No! Arduino was specifically designed to be accessible to beginners. The programming language is based on C/C++, but simplified, and there are thousands of tutorials, examples, and an active community to help you get started.

Can I power my Arduino directly through the USB port? 🔽

Yes! Most Arduino boards can be powered through the USB port, which provides 5V. However, for projects that consume more energy (like motors or many LEDs), it is recommended to use an external power supply.

💬 Share Your Experience!

Which Arduino do you use or intend to use?

Leave a comment below sharing your projects, questions, or experiences with different Arduino boards!

👋 Conclusion

We hope this complete guide on types of Arduino has helped you understand the differences between the main boards and choose the ideal one for your project. Remember that the Arduino ecosystem is vast and constantly evolving, so keep exploring and learning!

Thank you for visiting our blog, and we hope to see you again soon. Don't forget to check out our other content on technology and various topics.

✨ Our Gratitude and Next Steps

We sincerely hope this guide has been useful and enriching for your projects! Thank you for dedicating your time to this content.

Your Feedback is Invaluable:

Have any questions, suggestions, or corrections? Feel free to share them in the comments below! Your contribution helps us refine this content for the entire ElCircuits community.

If you found this guide helpful, share the knowledge!

🔗 Share This Guide

Best regards,

The ElCircuits Team ⚡

O post Types of Arduino: The Ultimate Guide to Choosing the Right Board apareceu primeiro em Electronic Circuits.

🌐 You can read this article in: Português | Español

Hello Tech Enthusiasts!

If you're starting an Internet of Things (IoT) project, you've probably faced the question: ESP8266, ESP32, or Arduino? All are excellent microcontrollers, but each has its own characteristics that can directly influence the success of your project. In this article, we'll compare the three in a clear and practical way, analyzing performance, connectivity, power consumption, and cost-effectiveness.

🔷 Understanding What Microcontrollers Are

The role of microcontrollers in IoT

Microcontrollers are the heart of smart devices. They collect data from sensors, process information, and send commands to other components, all in an automated way. Think of them as small brains that bring life to your electronic projects!

💡 Expert tip: For IoT projects, the ideal microcontroller should have integrated connectivity, low power consumption, and sufficient processing capacity to handle sensor data and network communication.

The Difference Between Microcontroller and Microprocessor

While microcontrollers have integrated memory and peripherals (like ADCs and GPIOs), microprocessors depend on external components. This is why microcontrollers are ideal for embedded and IoT projects.

🔅 Overview of Main Models

The Classic Arduino

Arduino is an open-source platform based on AVR microcontrollers (like the ATmega328P). It's widely used by beginners due to its simplicity and extensive support community. It's like the "popular car" of microcontrollers: reliable, easy to use, and with many "workshops" available to learn!

The Revolutionary ESP8266

Created by Espressif, the ESP8266 gained popularity for bringing integrated Wi-Fi at a very low cost, making it feasible to create connected devices without external modules. It was responsible for democratizing home IoT!

The Powerful ESP32

The ESP32 is a direct evolution of the ESP8266, bringing Wi-Fi, Bluetooth, greater processing, more pins, and low-power features, ideal for professional and industrial applications. Think of it as the "sports car" of microcontrollers: power, features, and versatility!

📊 Technical Comparison: ESP8266 vs ESP32 vs Arduino

Feature	ESP8266	ESP32	Arduino Uno
Processor	1 core (80–160 MHz)	Dual-core (240 MHz)	1 core (16 MHz)
Connectivity	Wi-Fi	Wi-Fi + Bluetooth	None
RAM Memory	160 KB	520 KB	2 KB
GPIOs	17	36	14
ADC	10 bits	12 bits	10 bits
IoT Support	High	Very high	Low
Average Cost	R$ 25–35	R$ 40–60	R$ 60–90

📈 Quick Analysis: The ESP32 offers the best set of features for IoT, with dual connectivity, more memory, and superior processing. The ESP8266 remains an economical option for simpler projects, while Arduino is ideal for beginners and local projects.

🧑‍💻 Programming Ease

Development environment

All can be programmed using the Arduino IDE, which simplifies the learning curve. The ESP32 and ESP8266 can also be programmed with MicroPython and PlatformIO, ideal for more advanced projects.

Supported languages

• Arduino: C/C++
• ESP8266/ESP32: C/C++, MicroPython, Lua, and even JavaScript (with specific firmware)

✅ Recommendation: If you already know the Arduino language, starting with ESP8266 or ESP32 using the same IDE will be a natural transition. For those who prefer Python, MicroPython on ESP32 is an excellent option!

🛜 Connectivity and Communication

Integrated Wi-Fi

This is the great advantage of the ESPs. While Arduino needs external modules (like the ESP-01 or Ethernet Shield), the ESP8266 and ESP32 come ready to connect to the internet.

Bluetooth on ESP32

The ESP32 stands out with Bluetooth Classic and BLE (Bluetooth Low Energy), allowing integration with smartphones, sensors, and wearable devices.

⚡ Power Consumption

Battery-powered projects

The ESP32 has more advanced power-saving modes (like Deep Sleep), consuming only a few microamps. The ESP8266 also has this mode, but with less efficiency. The Arduino consumes more, making it less ideal for battery-powered devices.

🔋 Practical example: A temperature sensor with ESP32 in Deep Sleep mode can work for months on a single 3.7V battery, while a similar Arduino would need frequent replacements or a continuous power supply.

📎 Additional Features

ADC, PWM, and sensors

The ESP32 offers better ADC resolution (12 bits), more PWM channels, and native support for touch sensors and CAN communication.

Security and encryption

IoT projects require security. The ESP32 has AES, SHA, and RSA encryption embedded, something absent in Arduino and limited in ESP8266.

⚠️ Security alert: For IoT projects that handle sensitive data, the ESP32 offers much more robust security features, essential to protect against common vulnerabilities in connected devices.

💰 Cost-Effectiveness

The ESP8266 still reigns in terms of low cost with good performance. The ESP32 is slightly more expensive, but delivers many more features. Arduino, on the other hand, is great for learning, but costs more and offers less for connected IoT.

👀 When to Choose Arduino

Ideal for beginners

If you've never programmed a microcontroller, Arduino is the perfect starting point. Its vast community and simplicity dramatically reduce entry barriers.

Simple and educational projects

For local automations or prototypes that don't require internet, Arduino is still an excellent choice.

🎓 Ideal educational projects for Arduino:

• Basic robotics
• LED and motor control
• Proximity and temperature sensors
• Small games and displays

🤷‍♂️ When to Choose ESP8266

For those seeking cheap Wi-Fi

The ESP8266 is the perfect choice if you want to connect sensors or devices to the cloud without spending much.

Typical applications

• Wi-Fi thermometers
• Smart plugs
• Remote monitoring via MQTT

💡 Success case: A smart irrigation system that monitors soil moisture and controls valves remotely can be implemented with ESP8266 at a very low cost, sending data to an application via Wi-Fi.

🤔 When to Choose ESP32

More robust projects

If you need performance, Bluetooth connectivity, and multiple peripherals, the ESP32 is unbeatable.

Typical applications

• Home automation
• Smart robots
• Wearable devices
• IoT gateways

🚀 Advanced project: A personal voice assistant with touchscreen display, Wi-Fi and Bluetooth connectivity, and device control by voice commands is perfectly feasible with a single ESP32, thanks to its dual-core processing power and multiple interfaces.

🧩 Compatibility with Sensors and Modules

Both ESP8266 and ESP32 are compatible with most sensors used in Arduino (DHT11, BMP280, HC-SR04, etc.), making migration simple.

🎯 Which Is Best to Start in IoT?

If the focus is on learning the basics, start with Arduino Uno. But if the goal is to create real connected devices, the ESP8266 or ESP32 are clearly superior.

🧾 Conclusion: The Right Choice Depends on Your Project

There is no single answer.

• Want something simple and educational? Go with Arduino.
• Need cheap Wi-Fi? Choose the ESP8266.
• Looking for power and flexibility? The ESP32 is the ideal path.

In summary: the ESP8266 popularized home IoT, the ESP32 professionalized it, and Arduino continues to be the gateway for all who want to learn electronics in a fun way.

---

🤔 Frequently Asked Questions (FAQ)

To ensure your project is a success, we've compiled some of the most common questions about this charger. Check it out!

Can I use Arduino sensors on ESP8266 or ESP32? 🔽

Yes! Most sensors compatible with Arduino (like DHT11, BMP280, HC-SR04, etc.) work perfectly on ESPs. You may need to adjust libraries or pins, but the hardware is compatible.

Which consumes less battery? 🔽

The ESP32 has the most efficient power-saving modes, especially Deep Sleep mode. For battery-powered projects, the ESP32 is generally the best choice.

Is it difficult to migrate from Arduino to ESP? 🔽

No! You can program the ESPs using the same Arduino IDE and C/C++ language. The transition is quite natural, especially if you're already familiar with Arduino programming.

Can I use Arduino and ESP together in the same project? 🔽

Yes! Many projects use Arduino for local control and an ESP8266 as a Wi-Fi module. The ESP32 can also be used as a main processor or co-processor in more complex projects.

Which is best for an IoT beginner? 🔽

If you already have experience with Arduino, the ESP8266 is an excellent next step to add Wi-Fi connectivity to your projects. If you're starting from scratch, it might be better to learn the basics with Arduino first.

🎯 Did You Like This Article?

Leave your comment below with your questions or experiences with these microcontrollers!

✨ Our Gratitude and Next Steps

We sincerely hope this guide has been useful and enriching for your projects! Thank you for dedicating your time to this content.

Your Feedback is Invaluable:

Have any questions, suggestions, or corrections? Feel free to share them in the comments below! Your contribution helps us refine this content for the entire ElCircuits community.

If you found this guide helpful, spread the knowledge!

🔗 Share This Guide

Best regards,

The ElCircuits Team ⚡

O post ESP8266 vs ESP32 vs Arduino: Which One to Choose for Your IoT Project? apareceu primeiro em Electronic Circuits.

🌐 You can read this article in: Português | Español

The Arduino Pro Mini is a compact development board based on the ATmega328P microcontroller, designed for applications where space is limited. Its popularity is due to its small size and low power consumption, making it ideal for embedded projects and wearables. Despite its compact size, it maintains the same functionality as other Arduino boards, such as the Uno, but without the edge connectors and without the integrated USB interface.

In this complete guide, we will explore in detail the pinout of the Arduino Pro Mini, analyzing each pin, its functions and limitations. We will cover from the power pins to the communication pins and digital I/O, providing essential information so you can make the most of this board in your projects. We will also discuss the schematic diagram, electrical characteristics and answer the most frequently asked questions about the pinout of this board.

I/O Pin Table (Input/Output)

Pin on Board	GPIO (Chip)	Main Functions	Critical Notes / Default State
D0 (RX)	PD0	UART RX	Serial receiver. Used for communication with the computer via USB-Serial converter.
D1 (TX)	PD1	UART TX	Serial transmitter. Used for communication with the computer via USB-Serial converter.
D2	PD2	Digital, External Interrupt 0	Can be used as external interrupt. Supports PWM in some configurations.
D3	PD3	Digital, PWM, External Interrupt 1	Supports PWM (~) and can be used as external interrupt.
D4	PD4	Digital	Standard digital pin. Default state: input (high impedance).
D5	PD5	Digital, PWM	Supports PWM (~). Default frequency: ~490Hz.
D6	PD6	Digital, PWM	Supports PWM (~). Default frequency: ~490Hz.
D7	PD7	Digital	Standard digital pin. Default state: input (high impedance).
D8	PB0	Digital	Standard digital pin. Default state: input (high impedance).
D9	PB1	Digital, PWM	Supports PWM (~). Default frequency: ~490Hz.
D10	PB2	Digital, PWM, SS	Supports PWM (~) and is the Slave Select pin for SPI communication.
D11	PB3	Digital, PWM, MOSI	Supports PWM (~) and is the MOSI pin for SPI communication.
D12	PB4	Digital, MISO	Is the MISO pin for SPI communication.
D13	PB5	Digital, SCK, LED	Is the SCK pin for SPI communication and controls the onboard LED.
A0	PC0	Analog, Digital	Analog input (10-bit). Can be used as digital pin. Resolution: 1024 levels (0-1023).
A1	PC1	Analog, Digital	Analog input (10-bit). Can be used as digital pin. Resolution: 1024 levels (0-1023).
A2	PC2	Analog, Digital	Analog input (10-bit). Can be used as digital pin. Resolution: 1024 levels (0-1023).
A3	PC3	Analog, Digital	Analog input (10-bit). Can be used as digital pin. Resolution: 1024 levels (0-1023).
A4	PC4	Analog, Digital, SDA	Analog input (10-bit). Can be used as digital pin and SDA for I2C communication.
A5	PC5	Analog, Digital, SCL	Analog input (10-bit). Can be used as digital pin and SCL for I2C communication.
A6	ADC6	Analog only	Analog input (10-bit). Cannot be used as digital pin. Resolution: 1024 levels (0-1023).
A7	ADC7	Analog only	Analog input (10-bit). Cannot be used as digital pin. Resolution: 1024 levels (0-1023).

Power and Control Pin Table

Pin on Board	Name	Function	Technical Description
RAW	VIN	Unregulated power input	Accepts voltage from 6V to 12V (5V version) or 6V to 9V (3.3V version). Passes through the voltage regulator.
VCC	VCC	Regulated power output	Provides 5V (5V version) or 3.3V (3.3V version) regulated. Can be used to power external components.
GND	GND	Ground	Ground reference pin (0V). There are multiple GND pins on the board.
RST	RESET	Reset	When set to low level, resets the microcontroller. Has a 10kΩ pull-up resistor.
TXO	TX	Serial Transmitter	Connected to pin D1. Used for programming and serial communication via USB-Serial adapter.
RXI	RX	Serial Receiver	Connected to pin D0. Used for programming and serial communication via USB-Serial adapter.
DTR	DTR	Data Terminal Ready	Used by the USB-Serial adapter to automatically reset the board during programming.
GND	GND	Ground	Ground reference pin (0V) for the USB-Serial adapter.
AREF	AREF	Analog Reference	Reference voltage for analog inputs (0-5V by default). Can be connected to an external voltage for greater precision.

Schematic Diagram

The Arduino Pro Mini schematic diagram shows how the components are connected internally, including the ATmega328P microcontroller, the voltage regulator and the support circuits. This diagram is essential to understand the internal operation of the board and to perform modifications or diagnostics more advanced.

🔗 Related Content

If you liked this project, you might also be interested in these other articles:

• Arduino UNO R3: Pinout and Key Features
• Arduino Mega 2560 R3: Complete Pinout and Key Features
• What is Arduino?
• How to Install Arduino Software (IDE) on Windows - Step by Step!

To view the Arduino Pro Mini schematic, you can access the official Arduino documentation. The document contains complete and up-to-date technical information about the module's hardware. Click here to access the PDF schematic on the official Arduino website.

Summary of Electrical Characteristics and Limitations

• Microcontroller: ATmega328P operating at 16MHz (5V version) or 8MHz (3.3V version).
• Operating Voltage: Available in two versions - 5V (accepts 6-12V on RAW pin) and 3.3V (accepts 6-9V on RAW pin).
• Current per I/O Pin: Each digital pin can provide up to 40mA, but the total for all pins should not exceed 200mA.
• Flash Memory: 32KB (of which 0.5KB are used by the bootloader).
• SRAM Memory: 2KB for variables during program execution.
• EEPROM Memory: 1KB for permanent data storage.
• USB-Serial Converter: Does not have an integrated converter. An external adapter (such as FTDI FT232RL, CH340G or CP2102) is required for programming and serial communication.
• Boot Pins: The bootloader is configured to use the pins RX (D0) and TX (D1) for serial programming.

This Arduino Pro Mini pinout guide was developed to provide a complete and detailed reference for developers and enthusiasts who work with this compact board. Understanding the function of each pin and its limitations is essential to make the most of the Arduino Pro Mini's potential in your projects. Remember that, despite its reduced size, this board offers the same processing capability as other larger Arduino boards, making it ideal for applications where space is a critical factor.

🤔 Frequently Asked Questions (FAQ)

To ensure your project is a success, we've compiled some of the most common questions about this charger. Check it out!

1. How to program the Arduino Pro Mini if it doesn't have a USB port? 🔽

To program the Arduino Pro Mini, you need an external USB-Serial adapter, such as FTDI FT232RL, CH340G or CP2102. Connect the adapter's TXO pin to the Pro Mini's RXI, the adapter's RXI to the Pro Mini's TXO, GND to GND, and the adapter's DTR to the Pro Mini's DTR pin. The DTR pin is important as it allows automatic reset of the board during code upload.

2. What is the difference between the 5V and 3.3V versions of the Arduino Pro Mini? 🔽

The main difference is in the operating voltage and clock frequency. The 5V version operates with a 16MHz clock and accepts power from 6V to 12V on the RAW pin. The 3.3V version operates with an 8MHz clock and accepts power from 6V to 9V on the RAW pin. The choice depends on the components you intend to use in your project, especially sensors and modules that may be voltage-sensitive.

3. Can I power the Arduino Pro Mini directly through the VCC pin? 🔽

Yes, you can power the Arduino Pro Mini directly through the VCC pin, but only with the correct regulated voltage (5V for the 5V version or 3.3V for the 3.3V version). Do not power the VCC pin with unregulated voltage or with voltage higher than specified, as this can damage the microcontroller. The RAW pin should be used when you need to power the board with a higher voltage that will be regulated internally.

4. How many PWM pins are available on the Arduino Pro Mini? 🔽

The Arduino Pro Mini has 6 PWM pins: D3, D5, D6, D9, D10 and D11. These pins can be used to generate pulse width modulation signals, which are useful for controlling LED brightness, DC motor speed, or for other applications that require simulated analog outputs.

5. How to use the A6 and A7 pins that are analog only? 🔽

The A6 and A7 pins are exclusive analog inputs, which means they cannot be used as digital pins. To use them, you must read their values using the analogRead() function with the parameters A6 or A7. They provide readings from 0 to 1023, corresponding to 0V to 5V (or 0V to 3.3V on the 3.3V version). They are useful when you need more analog inputs than those available on pins A0 to A5.

6. Is it possible to use I2C and SPI communication simultaneously on the Arduino Pro Mini? 🔽

Yes, it is possible to use I2C and SPI communication simultaneously on the Arduino Pro Mini, as they use different pins. I2C communication uses pins A4 (SDA) and A5 (SCL), while SPI communication uses pins D10 (SS), D11 (MOSI), D12 (MISO) and D13 (SCK). However, you must be careful not to use these pins for other purposes at the same time, and ensure there are no address or resource conflicts when using multiple I2C or SPI devices.

✨ Our Gratitude and Next Steps

We sincerely hope this guide has been useful and enriching for your projects! Thank you for dedicating your time to this content.

Your Feedback is Invaluable:

Have any questions, suggestions, or corrections? Feel free to share them in the comments below! Your contribution helps us refine this content for the entire ElCircuits community.

If you found this guide helpful, spread the knowledge!

🔗 Share This Guide

Best regards,

The ElCircuits Team ⚡

O post Arduino Pro Mini: Complete Pinout and Key Features apareceu primeiro em Electronic Circuits.

Arduino: Lesson 9 – LED Sequencing using Array Data Structure

Welcome to Lesson 9 – Basic Arduino Course

In today’s lesson, we will learn how to use 5 LEDs connected to 5 Arduino ports, which will light up in sequence and right after the cycle ends, will go out in sequence. With that, we will learn a new instruction, the Array data structure.

What is Array?

An array is a collection of variables that are accessed with an index number. However, the “array” data structure is not exactly an existing data type.

There are arrays of variables like “char“, “int“, “boolean“, “float” and so on. This means that an array can be variables of any type mentioned above.

An array, orvector, for example, is a collection of variables of a specific type, which may even use the same nomenclature, but which will be distinguished by an indexed number.

For example: We can use a variable type “float” with a single name indexed by number, instead of different variables (VarFloat_1, VarFloat_2, VarFloat_3…) we can use a single grouped array with the same nomenclature that will allow each variable be manipulated separately by a numerical index, (VarFloat [0], VarFloat [1], VarFloat [2] …).

Hardware Required

• Arduino Board
• 5 – LEDs
• 5 – 250 ohms resistor – (brown, green, brown, gold)
• Jumper Wires
• Protoboard (optional)

The Circuit Connections

The circuit is a bit simple, we connect the longer “Anode” legs of the 5 LEDs to the positive 5V of the Arduino, and the other shorter leg “Cathode“, we connect to the 150 ohm resistor and in series with GND, negative of the Arduino, as shown in Figure 2 below.

Fig. 2 – LED Sequencing using Array Data Structure – tinkercad.com

We use a protoboard to facilitate the connections, but you can also connect the wires directly to the Arduino.

The Code

The code can be implemented in the normal way in programming, as shown in the code below. But the code is quite large, we use 42 lines of code to create this kind of sequential LED circuit. To write less lines of code, an “optimizer” is required.

// Arduino: Lesson 9 - LED Sequencing using Array Data Structure
const int Led1 =  2;     // Select the output LED1 PIN
const int Led2 =  3;     // Select the output LED2 PIN
const int Led3 =  4;     // Select the output LED3 PIN
const int Led4 =  5;     // Select the output LED4 PIN
const int Led5 =  6;     // Select the output LED5 PIN
void setup() {            // This function is called once when the program starts
  pinMode(Led1, OUTPUT);  // Initialize digital pin LED1 as an output.
  pinMode(Led2, OUTPUT);  // Initialize digital pin LED2 as an output.
  pinMode(Led3, OUTPUT);  // Initialize digital pin LED3 as an output.
  pinMode(Led4, OUTPUT);  // Initialize digital pin LED4 as an output.
  pinMode(Led5, OUTPUT);  // Initialize digital pin LED5 as an output.
}
void loop() {                           // The loop function runs over and over again as long as the Arduino has power.
  // Turn ON each LED sequence in order
  digitalWrite(Led1, HIGH);
  delay(150);               // Wait for 150 millisecond(s)
  digitalWrite(Led2, HIGH);
  delay(150);               // Wait for 150 millisecond(s)
  digitalWrite(Led3, HIGH);
  delay(150);               // Wait for 150 millisecond(s)
  digitalWrite(Led4, HIGH);
  delay(150);               // Wait for 150 millisecond(s)
  digitalWrite(Led5, HIGH);
  delay(150);               // Wait for 150 millisecond(s)
  // Turn OFF each LED sequence in order
  digitalWrite(Led1, LOW);
  delay(150);               // Wait for 150 millisecond(s)
  digitalWrite(Led2, LOW);
  delay(150);               // Wait for 150 millisecond(s)
  digitalWrite(Led3, LOW);
  delay(150);               // Wait for 150 millisecond(s)
  digitalWrite(Led4, LOW);
  delay(150);               // Wait for 150 millisecond(s)
  digitalWrite(Led5, LOW);
  delay(150);               // Wait for 150 millisecond(s)
}
//------------------------------------- www.elcircuits.com --------------------------------------------

This is where the Array data structure comes into play, we can use it to drastically reduce the number of lines of code, as shown in the code example below.

// Arduino: Lesson 9 - LED Sequencing using Array Data Structure
const int Leds = 5;                          //Number of LEDs in the circuit
const int PinLeds[Leds] = {2, 3, 4, 5, 6};   //LEDs connected to pins 2 to 6
void setup() {            // This function is called once when the program starts
  for (int i = 0; i < Leds; i++) {    // Go through each of the elements in our array
    pinMode(PinLeds[i], OUTPUT);  // And set them as OUTPUT
  }
}
void loop() {                                        // The loop function runs over and over again as long as the Arduino has power.
  for(int i = 0; i < Leds; i++) {    // Go through each of the Leds elements in our array
    digitalWrite(PinLeds[i], HIGH);   // And set each of the PinLeds in HIGH level
    delay(150);   // Wait 150 millis seconds, and back to structure For
  }
  for(int i = 0; i < Leds; i++) {    // Go through each of the Leds elements in our array
    digitalWrite(PinLeds[i], LOW);   // And set each of the PinLeds in LOW level
    delay(150);   // Wait 150 millis seconds, and back to structure For
  }
}
//------------------------------------- www.elcircuits.com --------------------------------------------

Using the Array Data Structure technique, we could practically save half a line of the previous code, that's really cool, right?

After building the circuit, connect your Arduino board to your computer, run the Arduino software (IDE), copy the code below and paste it into your Arduino IDE. But first let us understand the code line by line.

• In Line 3, we declared the number of LEDs in the circuit.
• In Line 4, We are using an Array to index each pin of the LEDs in the corresponding Arduino Ports.
• In Line 6, we enter the void setup() function. This function is read only once when the Arduino is started.
• In Line 7, we enter in the FOR structure control, to access each Leds element.
• in Line 8, we set each PinLeds as OUTPUT, through each elements in ou array.
• In Line 11, we enter in the loop() function does precisely what its name suggests, and loops consecutively.
• In Line 12, we enter in the For structure control, to go through each of the Leds elements in our array.
• In Line 13, we continue in the For structure control, and set each of the PinLeds in HIGH level, turn on Led by Led.
• In Line 14, we enter in the delay function, to wait 150 millis seconds, and back to structure For while it is true.
• In Line 16, we enter in the For structure control, to go through each of the Leds elements in our array.
• In Line 17, we continue in the For structure control, and set each of the PinLeds in LOW level, turn off Led by Led.
• In Line 18, we enter in the delay function, to wait 150 millis seconds, and back to structure For while it is true.

All ready! After you have assembled the entire circuit, and uploaded this code, what you should see is the sequence of LEDs turning on and off, giving the impression that the LEDs are moving forward.

Next Lesson

• Arduino: Lesson 10 - How to Read Temperature and Humidity with Arduino, Using the DHT11 Sensor

Previous Lesson

• Arduino: Lesson 6 - How to use Analog Output to fade an LED
• Arduino: Lesson 7 - Controlling LED Through Serial Monitor with Arduino
• Arduino: Lesson 8 - Using LDR Sensor and reading values on Serial Monitor

✨ Our Gratitude and Next Steps

We sincerely hope this guide has been useful and enriching for your
projects! Thank you for dedicating your time to this content.

Your Feedback is Invaluable:

Have any questions, suggestions, or corrections? Feel free to share them
in the comments below! Your contribution helps us refine this
content for the entire ElCircuits community.

If you found this guide helpful, spread the knowledge!

🔗 Share This
Guide

Best regards,

The ElCircuits Team ⚡

O post Arduino Lesson 9 – LED Sequencing with Arrays (Practical Guide) apareceu primeiro em Electronic Circuits.

Using LDR Sensor and reading values on Serial Monitor

Welcome to Lesson 8 – Basic Arduino Course

In today’s lesson, we will learn how to use an LDR sensor and read values on a Serial Monitor with Arduino.

To measure light intensity, we will use the famous and widely used low-cost LDR (Light Dependent Resistor) sensor, to detect the intensity of light or darkness easily and cheaply.

LDR (Light Dependent Resistor) Sensor

LDR is a special type of resistor that passes higher voltage (low resistance) when light intensity is high and low voltage (high resistance) when darkness is low.

With this method, we can use it for example in projects such as:

• Lack of Light Alarm – Triggers an alarm when power is cut.
• Brightness Control – Used to control the brightness of a recording or filming environment for example.
• Contrast Control Screen – Often used on mobile phones to automatically lower or increase the brightness of the Display.
• Emergency Light – Automatically turns on when Light is cut.
• Ticket Counter – Also used to count people at the entrance of an establishment.
• Invasion Alarm – Used to trigger an alarm when there is an invasion of a monitored establishment.

In today’s example, we will use this sensor to measure numerical resistance and read these values from the serial monitor.

To do this, we will use Arduino analog port A0. We can use any analog port, in the case of Arduino Uno there are 6 ports; A0 to A5.

Hardware Required

• Arduino Board
• LDR – Sensor Dependent Light
• 100K ohms resistor – (Brown, black, yellow, gold)
• Jumper Wires
• Protoboard (optional)

The Circuit Connections

The circuit is very simple, we connect one leg of the LDR to positive 5V, and another leg to a 100K resistor in series with negative GND, and the same leg that takes the resistor and LDR, we connect to port A0, as shown in Figure 2 below.

Fig. 2 – Using LDR Sensor and reading values on Serial Monitor – tinkercad.com

We use a protoboard to facilitate the connections, but you can also connect the wires directly to the Arduino.

The Code

The analogRead() function reads the value from the specified analog pin. Arduino boards contain a multichannel, 10-bit analog to digital converter. This means that it will map input voltages between 0 and the operating voltage (5V or 3.3V) into integer values between 0 and 1023.

On an Arduino UNO, for example, this yields a resolution between readings of: 5 volts / 1024 units or, 0.0049 volts (4.9 mV) per unit.

After building the circuit, connect your Arduino board to your computer, launch Arduino Software (IDE), copy the code below and paste it into your Arduino IDE. But first let us understand the code line by line.

• In Line 3, we declared sensorPin to select the analog input Pin A0 to connect the LDR.
• In Line 4, we declared sensorValue as a variable to store the value coming from the LDR sensor.
• In Line 6, we enter the void setup() function. This function is read only once when the Arduino is started.
• In Line 7, we set the serial port for communication, we will read the numeric value from the LDR sensor.

// Arduino Lesson 8 - Using LDR Sensor and reading values on Serial Monitor with Arduino

int sensorPin = A0;      // Select the Analog input pin for LDR
int sensorValue = 0;       // Variable to store the value coming from the sensor

void setup() {            // This function is called once when the program starts
  Serial.begin(9600);   // Sets Serial Port for communication with bounce rate in 9600
}

void loop() {                                           // The loop function runs over and over again as long as the Arduino has power.
  sensorValue = analogRead(sensorPin);   // Read the value from the sensor
  Serial.println(sensorValue);             // Prints the values coming from the sensor on the Serial Monitor
}
//------------------------------------- www.elcircuits.com --------------------------------------------

• In Line 10, we enter in the loop() function does precisely what its name suggests, and loops consecutively.
• In Line 11, the sensorValue variable receives the value read from the sensorPin, which is the analog input Pin, and stores the read values.
• In Line 12, the Serial.println() function prints the values from the variable sensorValue on the serial monitor screen.

Below you can see the full code, which we can be copying and pasting into your Arduino IDE, and uploading to the Arduino.

// Arduino Lesson 8 - Using LDR Sensor and reading values on Serial Monitor with Arduino

int sensorPin = A0;      // Select the Analog input pin for LDR
int sensorValue = 0;       // Variable to store the value coming from the sensor

void setup() {            // This function is called once when the program starts
  Serial.begin(9600);   // Sets Serial Port for communication with bounce rate in 9600
}

void loop() {                                           // The loop function runs over and over again as long as the Arduino has power.
  sensorValue = analogRead(sensorPin);   // Read the value from the sensor
  Serial.println(sensorValue);             // Prints the values coming from the sensor on the Serial Monitor
}
//------------------------------------- www.elcircuits.com --------------------------------------------

All ready! After you have assembled the entire circuit, and uploaded this code, open the Serial Monitor and what you will see is the numerical value of the LDR.

When you approach your hands to the LDR, inhibiting the light, the number will drop to the minimum possible, it will depend on the LDR, and when you shine a light on the sensor, the number will go to the maximum of the sensor.

With that, the possibilities are immense to work with this sensor.

Next Lesson

• Arduino: Lesson 9 – LED Sequencing using Array Data Structure

Previous Lesson

• Arduino: Lesson 5 – Reading Potentiometer and Showing Values On Serial Monitor
• Arduino: Lesson 6 – How to use Analog Output to fade an LED
• Arduino: Lesson 7 – Controlling LED Through Serial Monitor with Arduino

✨ Our Gratitude and Next Steps

We sincerely hope this guide has been useful and enriching for your projects! Thank you for dedicating your time to this content.

Your Feedback is Invaluable:

Have any questions, suggestions, or corrections? Feel free to share them in the comments below! Your contribution helps us refine this content for the entire ElCircuits community.

If you found this guide helpful, spread the knowledge!

🔗 Share This Guide

Best regards,
The ElCircuits Team ⚡

O post Arduino Lesson 8 – Using LDR Sensor and Serial Monitor Readings apareceu primeiro em Electronic Circuits.

Arduino: Lesson 7 – Controlling LED Through Serial Monitor with Arduino

Welcome to Lesson 7 – Basic Arduino Course

In today’s lesson, we will learn how to control the state of a LED via the Serial Monitor using the Arduino IDE.

We will use the Serial.readString() function which will cause the Arduino to interpret the sentence you have entered into the serial monitor, e.g. “Turn on the led“. If you press ENTER Key in your computer, the LED will be turned on, if you want to turn off the LED just write the message “Turn off the LED“.

With this method we can use it in different projects such as:

• Load activation – Turns one or more loads on or off using commands.
• Motor Speed Control – Use Serial Monitor to send the speed at which a PWM motor should run.
• Calibrate a sensor’s constant – We can create software to change a sensor’s constant to a specified value if needed.

In our example today, we are using the serial monitor to trigger a LED, but you can also use a relay module to drive a motor, for example.

To do this, we will use the D9 digital port on Arduino. We can use any digital port we want. Just change the port you want to use in the declaration or the one that is available on your Arduino.

Required hardware

• Arduino board
• LED – Light Emitter Diode 220 Ohm Resistor – (red, red, brown, gold)
• Jumper wires
• Protoboard (optional)

The circuit

The circuit is quite simple. We connect a LED in series with a 220 ohm resistor to limit the current in the LED as we learned in previous lessons, and we connect the 9-pin of the Arduino UNO as shown in Figure 2 below.

Fig. 2 – Controlling LED Through Serial Monitor with Arduino – tinkercad.com

We use a protoboard to facilitate the connections, but you can also connect the wires directly to the Arduino.

The code

The Serial.readString() function reads characters from the serial buffer and moves them to a given string.

In our example, we want to do something very simple, which is to turn on and off a LED using the command from Serial Monitor.

After building the circuit, connect your Arduino board to your computer, run the Arduino software (IDE), copy the code below and paste it into your Arduino IDE. But first let us understand the code line by line.

// Arduino: Lesson 7 - Controlling LED Through Serial Monitor with Arduino

int ledPin = 9;      // LED connected to digital pin 9
String DataIn;       // String that will receive the Serial Monitor commands

void setup() {            // This function is read only once when the Arduino is started
  Serial.begin(115200);   // Begin Serial Monitor with bounce rate in 115200
  pinMode(ledPin, OUTPUT);  // Set the digital pin as output:
}

void loop() {                                           // The loop function runs over and over again as long as the Arduino has power.
  if (Serial.available()) {  // Check if there is any data on the serial monitor
    DataIn = Serial.readString();  // String DataIn receives the data typed in the Serial Monitor
  }
  if (DataIn == "turn led on") {  // Check if the received String is equal to "turn led on"
    digitalWrite(ledPin, HIGH);  // If yes, the function digitalWrite turns Led ON
  }
  if (DataIn == "turn led off") {  // Check if the received String is equal to "turn led off"
    digitalWrite(ledPin, LOW);   // If yes, the function digitalWrite turns Led OFF
  }
}
//------------------------------------- www.elcircuits.com --------------------------------------------

• In Line 11, we enter in the void loop() function does precisely what its name suggests, and loops consecutively.
• In Line 12, we enter in a if conditional, for to check if the Serial Monitor is available, if yes we call the next function.
• In Line 13, we call the Serial.readString() function to read the characters from the Serial Monitor and send them to the String DataIn.
• In Line 15, we enter in a if conditional, in this case to compare if the characters are the same as written in the Serial Monitor, in our example “turn led on“, if yes…
• In Line 16, we enter the digitalWrite function, command activates ledPin to HIGH level, it means that it goes from 0V to 5V, which turn the LED On.
• In Line 17, we enter in a if conditional, that compare if the characters are the same as written in the Serial Monitor, in our example “turn led off“, if yes…
• In Line 18, we enter the digitalWrite function, command disables ledPin to LOW level, it means that it goes from 5V to 0V, which turn the LED Off.

// Arduino: Lesson 7 - Controlling LED Through Serial Monitor with Arduino

int ledPin = 9;      // LED connected to digital pin 9
String DataIn;       // String that will receive the Serial Monitor commands

void setup() {            // This function is read only once when the Arduino is started
  Serial.begin(115200);   // Begin Serial Monitor with bounce rate in 115200
  pinMode(ledPin, OUTPUT);  // Set the digital pin as output:
}

void loop() {                                           // The loop function runs over and over again as long as the Arduino has power.
  if (Serial.available()) {  // Check if there is any data on the serial monitor
    DataIn = Serial.readString();  // String DataIn receives the data typed in the Serial Monitor
  }
  if (DataIn == "turn led on") {  // Check if the received String is equal to "turn led on"
    digitalWrite(ledPin, HIGH);  // If yes, the function digitalWrite turns Led ON
  }
  if (DataIn == "turn led off") {  // Check if the received String is equal to "turn led off"
    digitalWrite(ledPin, LOW);   // If yes, the function digitalWrite turns Led OFF
  }
}
//------------------------------------- www.elcircuits.com --------------------------------------------

Below you can see the full code, which we can be copying and pasting into your Arduino IDE, and uploading to Arduino.

The complete code is showed in the sketch below!

// Arduino: Lesson 7 - Controlling LED Through Serial Monitor with Arduino

int ledPin = 9;      // LED connected to digital pin 9
String DataIn;       // String that will receive the Serial Monitor commands

void setup() {            // This function is read only once when the Arduino is started
  Serial.begin(115200);   // Begin Serial Monitor with bounce rate in 115200
  pinMode(ledPin, OUTPUT);  // Set the digital pin as output:
}

void loop() {                                           // The loop function runs over and over again as long as the Arduino has power.
  if (Serial.available()) {  // Check if there is any data on the serial monitor
    DataIn = Serial.readString();  // String DataIn receives the data typed in the Serial Monitor
  }
  if (DataIn == "turn led on") {  // Check if the received String is equal to "turn led on"
    digitalWrite(ledPin, HIGH);  // If yes, the function digitalWrite turns Led ON
  }
  if (DataIn == "turn led off") {  // Check if the received String is equal to "turn led off"
    digitalWrite(ledPin, LOW);   // If yes, the function digitalWrite turns Led OFF
  }
}
//------------------------------------- www.elcircuits.com --------------------------------------------

All ready! After you have assembled the entire circuit, and uploaded this code, open the Serial Monitor and what you will see is the numerical value of the LDR.

When you approach your hands to the LDR, inhibiting the light, the number will drop to the minimum possible, it will depend on the LDR, and when you shine a light on the sensor, the number will go to the maximum of the sensor.

With that, the possibilities are immense to work with this sensor.

Next Lesson

• Arduino: Lesson 8 – Using LDR Sensor and reading values on Serial Monitor
• Arduino: Lesson 9 – LED Sequencing using Array Data Structure

Previous Lesson

• Arduino: Lesson 4 – Read Pushbutton with digitalRead() function
• Arduino: Lesson 5 – Reading Potentiometer and Showing Values On Serial Monitor
• Arduino: Lesson 6 – How to use Analog Output to fade an LED

✨ Our Gratitude and Next Steps

We sincerely hope this guide has been useful and enriching for your projects! Thank you for dedicating your time to this content.

Your Feedback is Invaluable:

Have any questions, suggestions, or corrections? Feel free to share them in the comments below! Your contribution helps us refine this content for the entire ElCircuits community.

If you found this guide helpful, spread the knowledge!

🔗 Share This Guide

Best regards,

The ElCircuits Team ⚡

O post Arduino Lesson 7 – Controlling LED via Serial Monitor apareceu primeiro em Electronic Circuits.