In this course, you’ll build two hands-on applications using MediaPipe and OpenCV. The first project shows you how to control an LCD display with your facial movements. The second project takes things further by using computer vision to control a robotic arm.

Along the way, you’ll learn how to:

• Set up serial communication between Python and Arduino

• Use MediaPipe’s face detection and landmarks module

• Work with LCD displays and servo motors

• Apply image processing techniques with OpenCV

The instructor, Yılmaz ALACA, walks you through the process step by step and explains the hardware and software in a clear way.

You can watch the full course on the freeCodeCamp.org YouTube channel (3-hour watch).

In this tutorial, you will learn how to interface a resistive soil moisture sensor with an Arduino UNO microcontroller. You will learn about the parts and components of the sensor, how to calibrate the sensor for your soil type, and how to read both analog and digital output data from the sensor.

You will implement two practical examples in this tutorial:

1. The first example illustrates how you can read the analog output data from the sensor and convert the analog reading to a percentage value.

2. The second example illustrates how you can use the digital output from the sensor to determine if the soil is wet or dry, and indicate the result using a red and green LED.

At the end of the tutorial, you will have a solid understanding of how a resistive soil moisture sensor works and how to integrate the sensor into your microcontroller-based projects.

Prerequisites

To effectively follow along with this tutorial, you should have the following components:

• Arduino UNO

• Resistive Soil Moisture Sensor

• Breadboard

• 5 LEDs (any color for the analog example)

• 1 red LED and 1 green LED (for the digital example)

• 220-ohm resistors (one per LED)

• Jumper wires

Table of Contents

• What is a Soil Moisture Sensor?

• Types of Soil Moisture Sensors

• Parts of a Resistive Soil Moisture Sensor

• How to Calibrate the Sensor for Your Soil

• Example 1: How to Determine Soil Moisture Level in Percentage from Analog Output

• Example 2: How to Determine Soil Moisture State from Digital Output

• Conclusion

What is a Soil Moisture Sensor?

A soil moisture sensor is a device that estimates the moisture content in the soil. Soil moisture sensors typically operate by measuring the soil's electrical properties, such as dielectric and resistance. Some soil moisture sensors also use time domain methods to determine the propagation speed of electromagnetic waves through the soil.

Soil moisture sensors have various applications in different fields. These applications include, but are not limited to:

• Climate and environmental research

• Automated/smart irrigation system

• Greenhouse monitoring systems

• Urban planning

Types of Soil Moisture Sensors

Soil moisture sensors are categorized based on the property of the soil that they measure as an indicator of the moisture content. The most common soil moisture sensors for small-scale projects are:

• Resistive soil moisture sensors

• Capacitive soil moisture sensors

Resistive Soil Moisture Sensor

A resistive soil moisture sensor estimates the moisture content based on the relationship between water content and soil resistivity. The electrical resistivity of the soil reduces exponentially as the water content increases.

The resistive soil moisture sensor has two probes inserted into the soil. It measures the electrical resistance of the soil between the two probes.

Capacitive Soil Moisture Sensor

A capacitive soil moisture sensor determines the moisture content of the soil based on the relationship between water content and the dielectric properties of the soil. The dielectric constant of a soil increases as the water content increases.

A capacitive soil moisture sensor typically has a positive plate and a negative plate with space between them. When inserted into the soil, the soil becomes the dielectric medium between both plates. The sensor measures the change in the soil's dielectric property.

How to Choose Between Resistive and Capacitive Sensors

The choice between a resistive and capacitive soil moisture sensor depends on a couple of factors:

• Cost: A resistive soil moisture sensor is typically less expensive than a capacitive sensor.

• Accuracy: Capacitive soil moisture sensors are more accurate than their resistive counterparts. Factors like soil type and application of fertilizers have a lesser effect on the sensitivity of the capacitive soil moisture sensor.

• Long-term use: Resistive soil moisture sensors are prone to corrosion with frequent use. This happens because the current flowing through the probes in contact with the soil causes electrolysis of the metal electrodes in the probes. On the other hand, capacitive soil moisture sensors are resistant to corrosion. This is because the contact plates are embedded in corrosion-resistant materials and don't need to be in direct contact with the soil.

Parts of a Resistive Soil Moisture Sensor

The resistor soil moisture sensor module is usually made of two parts: the sensor probes and the voltage comparator module.

The Sensor Probes

The probes are the part of the sensor that is placed in the soil. The probes are used to detect the electrical resistance across two points in the soil.

As shown in the diagram above, the sensor probes have the following components:

• Electrodes: The metal electrodes conduct current through the soil. When the sensor is powered, current flows from one electrode through the soil to the other electrode and back to the comparator module. The sensor then measures the soil's resistance to the electrical signal flowing through the soil across the electrodes to determine the moisture level.

• Non-polarized connector pins: The two connector pins are used to connect the probes to the voltage comparator module. The pins have no polarity and can be connected in any order to the respective connector pins on the voltage comparator module. The probe is connected to the comparator module using female-to-female jumper wires.

The Voltage Comparator Module

The voltage comparator module interprets the electrical signal from the probes, processes the signals, and provides both analog and digital outputs that can be read by the microcontroller.

The voltage comparator module has the following components:

• LM393 Comparator Chip: The LM393 comparator is a dual comparator that compares the electrical signal from the probes to a reference set by the potentiometer and produces a digital output. The reference signal corresponds to a certain soil moisture level (threshold) and is set using the potentiometer.

  • The comparator outputs a HIGH when the analog signal read from the probes is above the reference, this means the soil has less moisture than the threshold moisture level.

  • The comparator outputs a LOW when the analog signal read from the probes is less than the reference; this means the soil has more moisture than the threshold moisture level.

• Potentiometer: The potentiometer is used to set the reference electrical signal that is used by the LM393 comparator chip. The potentiometer raises or lowers the threshold moisture level. It consists of a knob that can be turned either clockwise or counterclockwise.

• Power Indicator (PWR-LED): The power indicator is an LED that turns on when the module is powered on.

• Digital Output Indicator (DO-LED): The digital output indicator is an LED that turns on when the sensor detects wet soil. That is, the current moisture level read from the sensor is above the threshold, and the comparator outputs a LOW.

• Power Supply Pin (VCC): This pin is used to supply power to the sensor. The sensor module can be powered by a 5V or 3.3V voltage source. You should note that changing the voltage source also changes the analog output from the sensor. In this tutorial, you will be using one of the digital pins to power the sensor. The digital pins of the Arduino output 5V. The sensor typically has an operating current of 15mA, and the Arduino digital output pin can provide a maximum current of 40mA, so it can safely power the sensor.

• Ground Pin (GND): This pin is used to provide a ground reference for the sensor. It is usually connected to any ground pin in your microcontroller.

• Digital Output Pin (DO): The digital output pin outputs a HIGH or a LOW based on the value obtained from the LM393 comparator. This pin is usually used by a microcontroller to read the digital output of the LM393 comparator.

• Analog Output Pin (AO): The analog output pin provides a 10-bit analog voltage value. The values range from 0 to 1023, and they indicate the moisture level of the soil. Typically, in most sensors, higher analog values indicate drier soil and lower analog values indicate wetter soil.

• Sensor Probe Connector Pins: These two pins are used to connect the sensor probes to the voltage comparator module.

How to Calibrate the Sensor for Your Soil

As explained earlier in the article, the resistive soil moisture sensor is sensitive to soil type. This means that it’s important that you calibrate the sensor to the soil type you intend to use it on. You do this to improve the accuracy of your readings on a particular soil.

One way of calibrating the sensor is to determine the possible range of values for the soil type. That means you measure the sensor's output when the soil is totally dry and when the soil is totally wet. You can then use this range of values to map the sensor's reading to a new scale, like a percentage. The following steps describe how you can calibrate the sensor:

Step 1: Connect the Sensor to the Arduino

Using the image above as a reference, connect the sensor to the Arduino microcontroller as follows:

1. Connect the VCC or Power pin of the sensor's module to digital pin 7 of the Arduino. This allows you to control the supply voltage to the sensor in the Arduino sketch, ensuring that the sensor is only powered when you want to take a reading. Doing this can help improve the durability of the sensor.

2. Connect the GND pin of the sensor's module to a ground pin in the microcontroller.

3. Connect the analog output pin AO of the sensor's module to the analog pin A0 of the Arduino. This is the pin where you will read the analog data from the sensor.

4. Connect the two pins on the probes to the two connector pins on the sensor's module. The connector pins have no polarity.

Step 2: Upload Calibration Sketch to Microcontroller

Upload the following sketch into the Arduino:

const int sensorPin = A0; // Analog input pin for sensor
const int powerPin = 7; // Digital pin to power the sensor

int getAverageReading(int analogPin, int powerPin, int samples = 10) {
  long total = 0;

  digitalWrite(powerPin, HIGH); // Power ON sensor
  delay(500); // Wait for sensor to stabilize

  for (int i = 0; i < samples; i++) {                    
 total += analogRead(analogPin);
    delay(10); // Short gap between cycles
 }

  digitalWrite(powerPin, LOW); // Power OFF sensor
  return total / samples;
}

void setup() {
  Serial.begin(9600);

  pinMode(powerPin, OUTPUT);
  digitalWrite(powerPin, LOW); // Ensure sensor is off at start

  Serial.println("Calibration mode: Insert into DRY or WET soil and observe values.");
}

void loop() {
  int avgReading = getAverageReading(sensorPin, powerPin, 20); // Take 20 averaged samples
  Serial.print("Average analog reading: ");
  Serial.println(avgReading);
  delay(2000); // Update every 2 seconds
}

In the sketch, you begin by defining the pins for powering the sensor and reading the analog data from the sensor. The digital pin 7 powers the sensor, and the analog pin A0 reads data from the sensor.

The getAverageReading function powers on the sensor, takes multiple readings from the sensor, powers off the sensor, and returns the average of the readings taken. The function has three parameters:

• analogPin – The analog input pin, which reads data from the sensor to the microcontroller.

• powerPin – The pin used to power the sensor. The sensor is powered only when you want to take a reading.

• samples – The number of readings taken from the sensor. This defaults to 10. You take multiple readings as a way of filtering out noise in the sensor data.

In the setup function, you begin by setting the baud rate, which is 9600 for Arduino UNO and differs across different microcontrollers. Then you set the digital pin 7 used to power the sensor as an output pin, and write a LOW to the sensor to ensure it is off at the start.

Lastly, in the loop function, you get the average analog reading from the getAverageReading function and print it to the Serial Monitor. You should note that in the sketch, the readings are taken every 2 seconds – this delay should be longer in a practical application in order to improve the durability of the sensor.

Step 3: Record the Value for Dry Soil

Insert the sensor's probe into a completely dry soil sample, and record the average analog reading. You can dry the soil by baking it in an oven to remove moisture. Note that you must allow the soil to cool before inserting the sensor's probe. Hot soil may damage the sensor. The analog readings from the sensor differ according to soil type but are typically very high for dry soil. This is what I obtained for a dry soil sample:

Step 4: Record the Value for Wet Soil

Insert the sensor's probe into a completely wet soil sample, and record the average analog reading. The value is typically low when the soil is saturated. This is what I obtained for a wet soil sample:

You will use these recorded analog values for wet and dry soil in the subsequent section as reference points to map future readings onto a percent scale. In the example provided later in this tutorial, the moisture level is expressed as a percentage, between 0%(dry) and 100%(wet). Using the calibration values ensures that the percentage output accurately reflects the conditions of your soil type.

Example 1 – How to Determine Soil Moisture Level in Percentage from Analog Output

In this example, you will learn how to read the analog data from the soil moisture sensor, convert the analog reading to a percentage value, and visually represent the moisture level using five LEDs.

The analog reading from the sensor is inversely proportional to the soil moisture level. This means that higher analog readings indicate drier soil and lower readings indicate wetter soil.

The LEDs act as a visual indicator of the moisture percentage. The LEDs are lit based on a range of soil moisture levels:

• 1 LED: 0-20% (very dry)

• 2 LEDs: 20-40%

• 3 LEDs: 40-60%

• 4 LEDs: 60-80%

• 5 LEDs: 80-100% (very wet)

Circuit Diagram

Using the schematic above as a reference, design the circuit as follows:

1. Connect the sensor to the Arduino in the same way as described in the calibration section. That is, connect the sensor's power pin (VCC) to digital pin 7, analog output pin AO to analog pin A0, and ground pin to any ground pin of the microcontroller.

2. Connect each of the LEDs in series with a 220-ohm resistor.

3. Connect the anode of the five LEDs to digital pins 3, 4, 5, 6, and 8 of the microcontroller.

This is how my setup looked:

Arduino Code

Upload the following sketch to your Arduino:

const int sensorPin = A0; // Analog input from soil moisture sensor
const int powerPin = 7; // Digital pin to power the sensor

// LED bar pins (from lowest to highest)
const int ledPins[5] = {3, 4, 5, 6, 8};

// Calibrated analog values - replace with your values
const int dryValue = 1005;
const int wetValue = 254;

// Global to hold the last analog value
int lastAnalogReading = 0;

// Read and calculate soil moisture percentage
int getMoisturePercent(int analogPin, int powerPin, int samples = 10) {
  unsigned long total = 0;

  digitalWrite(powerPin, HIGH);
  delay(10); // Allow sensor to stabilize

  for (int i = 0; i < samples; i++) {
 total += analogRead(analogPin);
    delay(10);
 }

  digitalWrite(powerPin, LOW);

  int avgReading = total / samples;
 lastAnalogReading = avgReading;

  int percent = map(avgReading, dryValue, wetValue, 0, 100);
  return constrain(percent, 0, 100);
}

// Update LED states using boolean array
void updateLEDBar(int percent) {
  bool ledStates[5] = {0, 0, 0, 0, 0}; // Default all OFF

  if (percent <= 20) {
    ledStates[0] = true;
 } else if (percent <= 40) {
    ledStates[0] = ledStates[1] = true;
 } else if (percent <= 60) {
    ledStates[0] = ledStates[1] = ledStates[2] = true;
 } else if (percent <= 80) {
    ledStates[0] = ledStates[1] = ledStates[2] = ledStates[3] = true;
 } else {
    for (int i = 0; i < 5; i++) ledStates[i] = true;
 }

 // Write LED states to pins
  for (int i = 0; i < 5; i++) {
    digitalWrite(ledPins[i], ledStates[i] ? HIGH : LOW);
 }
}

void setup() {
  Serial.begin(9600);
  pinMode(sensorPin, INPUT);
  pinMode(powerPin, OUTPUT);
  digitalWrite(powerPin, LOW); // Start with sensor powered off

  for (int i = 0; i < 5; i++) {
    pinMode(ledPins[i], OUTPUT);
    digitalWrite(ledPins[i], LOW); // Ensure all LEDs start OFF
 }

  Serial.println("Soil Moisture Monitor with 5-LED Bar (Boolean Array)");
}

void loop() {
  int moisturePercent = getMoisturePercent(sensorPin, powerPin, 20);

 // Print both analog reading and percent
  Serial.print("Analog Reading: ");
  Serial.print(lastAnalogReading);
  Serial.print("  |  Moisture: ");
  Serial.print(moisturePercent);
  Serial.println(" %");

  updateLEDBar(moisturePercent);

  delay(2000); // Update every 2 seconds
}

In the sketch, you start by defining the analog pin for reading data from the sensor and the digital pin for powering the sensor. You also define the following variables, which will be used in the code:

• ledPins[5] – An array that stores the digital pins used to power each LED. The pins are arranged from the first LED to the last one. That is the visual display order from left to right.

• dryValue – This variable stores the analog value recorded for dry soil during the calibration section.

• wetValue – This variable stores the analog value recorded for wet soil during the calibration section.

• lastAnalogReading – This variable stores the last reading taken by the sensor. You use this variable to log the actual analog reading to the Serial Monitor.

The getMoisturePercent function powers on the sensor, takes multiple readings, powers off the sensor, calculates the average analog reading, represents the analog reading in percent, and returns the percent value. The function also saves the average analog reading to the lastAnalogReading variable. You can print it directly here, but this sketch saves it in a separate variable so that you can print it later in the loop function for readability.

You can express the average analog reading in percentage with the map(avgReading, dryValue, wetValue, 0, 100) function. The function remaps the average reading stored in avgReading from the range of your calibration values dryValue and wetValue to a new range between 0 and 100 (where 0 is the driest and 100 is the wettest). You then use the constrain function to keep values within the 0 and 100 range.

The updateLEDBar function displays the percent value using the LEDs. The ledStates array in the function stores the logic state of each LED. You begin by setting all LEDs off – that is, having a state 0. The next bit of logic is a simple if statement where you turn on the required LEDs corresponding to a particular percent range by setting the elements in the array to true (equivalent to 1). You end the function by writing the states in the ledStates to the pins in ledPins.

The setup function is pretty routine: you set the baud rate for serial communication, define input and output digital pins, and write a LOW to the digital output pins to ensure they are all turned off at the start.

In the loop function, you call the getMoisturePercent function to get the percent moisture value. You then print the percent value and the average analog reading to the Serial Monitor for clarity. Lastly, you call the updateLEDBar function with the percent value as a parameter to turn on the respective LEDs to indicate the moisture level.

Test the System

You can proceed to test the example with different moisture levels. For example:

• At around a 37% moisture level, two LEDs are lit.

• At about a 76% moisture level, four LEDs are lit.

You can also simulate the example on Tinkercad here: https://www.tinkercad.com/embed/6s47ZvIrNOP.

Example 2 – How to Determine Soil Moisture State from Digital Output

In the previous project, you learned how to read the analog data from the sensor and convert the value into a percentage. If your application requires a binary output, you can use the digital output pin. In this section, you'll learn how to use the digital output pin of the sensor.

The digital output pin has only two states:

• LOW – This state corresponds to 0V and is the output when the soil is wet, that is, the moisture level is above the set threshold.

• HIGH – This state corresponds to 5V and is the output when the soil is dry, that is, the moisture level is below the threshold moisture level.

Circuit Diagram

The example built in this section is very simple. It consists of a red and green LED. When the sensor outputs a LOW from the digital output pin, which means the soil is wet, the green LED turns on. When the sensor outputs a HIGH from the digital output pin, which means the soil is dry, the red LED turns on.

Using the circuit diagram above as a reference, design the circuit as follows:

1. Place the sensor module on the breadboard.

2. As in the previous project, connect the power (VCC) pin of the sensor module to digital pin 7 of the microcontroller, and the ground (GND) pin to a ground pin on the microcontroller.

3. Connect the digital output (DO) pin of the sensor to digital pin 2 of the microcontroller. This pin is where you will read the data from the sensor.

4. Connect the red and green LEDs each to a 220-ohm resistor in series.

5. Connect the anode of the red and green LEDs to digital pins 12 and 13 of the microcontroller, respectively.

This is how my physical connection looked:

How to Set the Threshold Moisture Level

Before using the digital output pin of the soil sensor module, you first have to set a threshold moisture level.

The sensor's module has a built-in potentiometer that allows you to adjust the moisture level, which will be used as a threshold. The sensor also has a built-in LM393 comparator, which continuously compares the actual reading from the sensor to the threshold set by the potentiometer and outputs the appropriate state.

You can set the threshold moisture level by rotating the knob on the potentiometer. Rotating the potentiometer clockwise lowers the threshold. Rotating the potentiometer counterclockwise raises the threshold. The sensor module also has a built-in LED labeled DO-LED that turns on when the sensor output is LOW. Set the threshold as follows:

1. Place the sensor's probe in soil just dry enough that it requires irrigation. That is the soil whose moisture level you want to use as a threshold. Note that the DO-LED should be off.

2. Use a small screwdriver to rotate the potentiometer clockwise until the DO-LED comes on. Turning clockwise reduces the threshold level until it is slightly lower than the current moisture level, thereby triggering the digital output indicator (DO-LED) to turn on.

3. Turn the screw slightly counterclockwise just enough to turn the built-in digital LED off. Given that the current moisture level of the soil is dry enough that it needs to be watered, you still want the sensor to read this level as dry. So turning counterclockwise reduces the threshold to a level just above the current moisture level of the soil, which triggers the DO-LED to turn off.

Arduino Code

Upload the following sketch to the Arduino:

const int sensorPower = 7; // Digital pin to power the sensor
const int sensorPin = 2; // Digital input from the sensor
const int greenLED = 13; // Green LED pin
const int redLED = 12; // Red LED pin

int getSensorReading(int digitalPin, int powerPin) {  
  digitalWrite(powerPin, HIGH); // Power ON sensor
  delay(500); // Wait for sensor to stabilize

  int reading = digitalRead(digitalPin);

  digitalWrite(powerPin, LOW); // Power OFF sensor
  return reading;
}

void setup() {
  Serial.begin(9600);

  pinMode(sensorPower, OUTPUT);
  pinMode(sensorPin, INPUT);
  pinMode(greenLED, OUTPUT);
  pinMode(redLED, OUTPUT);

 // Ensure everything starts OFF
  digitalWrite(sensorPower, LOW);
  digitalWrite(greenLED, LOW);
  digitalWrite(redLED, LOW);
}

void loop() {
  int sensorReading = getSensorReading(sensorPin, sensorPower);

  Serial.println("===================================");
  Serial.print("Digital Reading: ");
  Serial.println(sensorReading);

  if (sensorReading == HIGH) {
    Serial.println("Status: Soil moisture is LOW (dry)");
    Serial.println("Action: Water the soil");
    digitalWrite(redLED, HIGH);
    digitalWrite(greenLED, LOW);
 } else {
    Serial.println("Status: Soil moisture is GOOD (wet)");
    Serial.println("Action: No watering needed");
    digitalWrite(greenLED, HIGH);
    digitalWrite(redLED, LOW);
 }

  Serial.println("===================================");
  Serial.println(); 
  delay(2000); // Update every 2 seconds
}

In the sketch, you define the digital pin used to read data from the sensor, the digital pins to power the sensor, and the green and red LEDs.

The getSensorReading function powers on the sensor, takes the digital reading from the sensor, powers off the sensor, and returns the digital reading taken from the sensor.

The setup function is routine: you set the baud rate, define the digital pins as input or output, and write a LOW to the output pins to ensure they are off at the start.

In the loop function, you call the getSensorReading to get the digital reading from the sensor. If the sensor outputs a HIGH, you turn on the red LED and print a message that the soil is dry. If the sensor outputs a LOW, you turn on the green LED and print a message that the soil is wet.

Test the System

You can proceed to test the project using different moisture levels. For example:

• For wet soil, that is, if the moisture level is above the threshold, you should have the following output:

• For dry soil, that is, if the moisture level is below the threshold, you should have the following output:

You can also simulate the example on Tinkercad here: https://www.tinkercad.com/embed/2wHwfKherNz.

Conclusion

In this tutorial, you learned what a resistive soil moisture sensor is, how to calibrate the sensor for your soil type, and how to use the sensor's analog and digital data to determine the moisture level of the soil.

The examples provided a solid foundation for working with the sensor. You can extend these examples into more complex projects, such as an automated irrigation system or remote monitoring of soil moisture.

For projects that require greater accuracy and frequent or sustained sensor operation, you should explore the capacitive sensor.

You can access all the code on GitHub.

We just published a course on the freeCodeCamp.org Spanish YouTube channel that will teach you the fundamentals of Arduino step by step. You'll learn key programming concepts, like data types, variables, functions, operators, conditionals, and loops, alongside concepts related to electronics, such as digital input and output, time, buttons, temperature and humidity, movement sensors, and more.

If you have Spanish-speaking friends, you are welcome to share the Spanish version of this article with them.

The course was created by Carlos Leon. Carlos is a developer who is passionate about Arduino and who loves sharing his knowledge of programming and electronics with everyone who is interested in learning these technologies.

What is Arduino?

Arduino is an open-source electronics platform that connects the digital and physical worlds. It consists of a microcontroller board and a user-friendly development environment. By connecting various sensors, actuators, and other electronic components to the Arduino board, you can create interactive projects that respond to the real world.

With Arduino, you can build a wide range of projects, from simple circuits to complex robotics systems. You can also practice your problem-solving skills and gain a deeper understanding of programming fundamentals and electronics.

This course is great for anyone who is interested in learning more about Arduino. It’s a stepping stone into the world of robotics, automation, Internet of Things, and wearable technology.

💡 Tip: During the course, you’ll use an Arduino simulator, so you can take the course even if you don’t have an Arduino board available.

Arduino Course

Great! Now that you know more about Arduino, let’s check out some of the topics that you’ll learn during the course:

• Introduction

• Arduino Uno

• Pins

• Electricity concepts

• Calculating resistance

• Breadboard

• Programming fundamentals

• About Wokwi

• Data types

• Variables

• Functions

• Operators

• Conditionals

• Loops

• Serial console

• Hello World with Arduino

• Pin declarations

• Digital input-output

• Analog input-output

• Time

• Buttons

• Libraries

• Sensors

• Temperature and Humidity

• Ultrasonic

• Movement sensor

• Interesting components

• LCD screen

• Servomotors

• And more…

Check out these course screenshots:

💡 Tip: The course is beginner-friendly. It’s great for you if you’re just getting started in the world of programming and electronics. You’ll even write your first “Hello, world!” program in Arduino.

If you’re ready to start learning, check out the course in Spanish on the freeCodeCamp.org Spanish YouTube channel:

✍️ Course created by Carlos Leon.

• LinkedIn: Carlos Leon

In this article, you'll learn how to control LEDs using a switch case statement in Arduino. You can also find the switch case statement in other programming languages, so this can serve as a practical example of how they work.

Here’s a demo of what you’ll be building:

You can watch the video version of this article here:

Hardware Components

Here are the components you'll need to follow along:

• Arduino board (Uno).

• Potentiometer.

• Breadboard.

• Three LEDs.

• Resistors for the LEDs.

• Jumper wires.

How to Use a Switch Case Statement in Arduino

Here's the syntax/structure of a switch statement:

switch (variable) {
  case value1:
    // code to be executed if variable == value1
    break;
  case value2:
    // code to be executed if variable == value2
    break;
  default:
    // code to be executed if variable doesn't match any case
    break;
}

Let's break it down:

• variable: This denotes the variable being evaluated. The value of the variable determines how the code blocks will be executed.

• case: Each case represents a value that may match the variable being evaluated. If the variable and a case have the same value, the code for that case will be executed. You can have as many cases as you want.

• break: After a code block in a case has been executed, the break keyword terminates the code. That is, it stops the code from moving on to other cases because a match has already been found.

• default: In a situation where none of the cases match the variable, the code in the default block will be executed.

Next, let's use a switch statement to control LEDs.

Switch Case in Arduino Example

Circuit Diagram

Here’s how to connect your components:

The goal here is to decide which LED (or a combination of LEDs) comes on based on the value of a variable.

Potentiometer Connection

• Connect the left terminal of the potentiometer to 5V.

• Connect the right terminal to GND.

• Connect the middle terminal to A0.

LED Connection

• For each LED, connect the shorter leg to GND.

• Connect each longer leg to a digital pin. I recommend using pin 8 (for the green LED), 9 (for the yellow LED), and 10 (for the red LED) to match what we have in the circuit diagram. We'll also use these values in the code.

Here's the full project code:

int greenLED = 8;
int yellowLED = 9;
int redLED = 10;
int potPin = A0; 
int potValue;
int mappedPotValue;
​
void setup() {
  pinMode(greenLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
  pinMode(redLED, OUTPUT);
  Serial.begin(9600);
}
​
void loop() {
  potValue = analogRead(potPin);
  mappedPotValue = map(potValue, 0, 1023, 0, 5);
​
  switch (mappedPotValue) {
    case 0:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 1:
      digitalWrite(greenLED, HIGH);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 2:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, HIGH);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 3:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, HIGH);
      Serial.println(mappedPotValue);
      break;
    case 4:
      digitalWrite(greenLED, HIGH);
      digitalWrite(yellowLED, HIGH);
      digitalWrite(redLED, HIGH);
      Serial.println(mappedPotValue);
      delay(500);
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      delay(500);
      break;
  }
}

Let's break down the code.

Variable Initialization

int greenLED = 8;
int yellowLED = 9;
int redLED = 10;
int potPin = A0; 
int potValue;
int mappedPotValue;

We started by initializing variables to correspond with the hardware connections.

greenLED, yellowLED, and redLED have values of 8, 9, and 10, respectively. This matches the pins they were connected to on the Arduino board. Similarly, potPin, which is the variable for the potentiometer, has a value of A0.

You'll use the potValue variable to store the current value of the potentiometer. We also created a mappedPotValue variable to store the range of values needed for the LEDs in a minute.

pinMode and Serial Monitor

void setup() {
  pinMode(greenLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
  pinMode(redLED, OUTPUT);
  Serial.begin(9600);
}

In the setup() function, we set the LEDs as output pins and initialized the serial monitor.

Logic for switch case Statement

First, we read the value of the potentiometer using the analogRead() function and stored it in the potValue variable:

potValue = analogRead(potPin);

We then converted the values from the potentiometer to a range of 0 to 4 using the map function and stored them in the mappedPotValue variable:

mappedPotValue = map(potValue, 0, 1023, 0, 5);

Next, we created a switch statement—the value being evaluated is mappedPotValue. Recall that this is the variable where we stored the potentiometer values. So whenever you turn the potentiometer, the value changes and potentially matches a case:

  switch (mappedPotValue) {
    case 0:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 1:
      digitalWrite(greenLED, HIGH);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 2:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, HIGH);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      break;
    case 3:
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, HIGH);
      Serial.println(mappedPotValue);
      break;
    case 4:
      digitalWrite(greenLED, HIGH);
      digitalWrite(yellowLED, HIGH);
      digitalWrite(redLED, HIGH);
      Serial.println(mappedPotValue);
      delay(500);
      digitalWrite(greenLED, LOW);
      digitalWrite(yellowLED, LOW);
      digitalWrite(redLED, LOW);
      Serial.println(mappedPotValue);
      delay(500);
      break;
  }

We passed mappedPotValue as a parameter to switch since it's the variable being compared to different cases: switch (mappedPotValue).

• For case 0, all the LEDs will be off.

• For case 1, only the green LED comes on.

• For case 2, only the yellow LED comes on.

• For case 3, only the red LED comes on.

• For case 4, all three LEDs will blink continuously.

Using a switch statement, you've successfully controlled the behavior of LEDs based on the value of a potentiometer!

Conclusion

In this article, you learned how to use a switch case statement in Arduino using a practical example.

You learned how to control different LEDs based on the value of a potentiometer. You achieved this by using different cases in a switch statement to match the potentiometer's current value and execute the corresponding code.

switch statements can be used in different ways to make a project more dynamic. Some use cases in Arduino include:

• Managing and interpreting the different values, modes, and states of a component or sensor.

• Performing actions based on specific commands. For example, rotating a robotic arm to a specific angle/direction.

• Mapping button presses to user input, and so on.

You can watch the video version of this project here. The full project code is available on GitHub.

Check out my blog for articles about embedded systems, IoT, and web development.

Happy coding!

You've most likely used a potentiometer before with appliances like radios, microwaves, blenders, electric fans, game controllers, and others.

They are generally used to provide or control different ranges of variable resistance in electronic circuits.

In this article, you'll learn the following:

• How to connect a potentiometer to an Arduino board.
• How to get the values of a potentiometer.
• How to control the brightness of an LED using a potentiometer.

You can also watch the video version of this article here:

Hardware Components

Here are the hardware components you'll need to follow along:

• Arduino board.
• Potentiometer.
• Breadboard.
• LED.
• 1K Ohm resistor.
• Jumper wires.

How to Connect a Potentiometer to an Arduino Board

The potentiometer is made up of three terminals: two outer terminals and the middle terminal. Either of the outer terminals can be connected to either 5V or GND (ground). That is:

• If you connect the left outer terminal to 5V, you have to connect the right outer terminal to GND.
• If you connect the left outer terminal to GND, you have to connect the right outer terminal to 5V.

The middle terminal serves as the output terminal. We'll connect it to an analog pin. You can read the varying values of the potentiometer from the output terminal.

Here's the circuit diagram:

circuit diagram

Here's how the potentiometer was connected in the diagram above:

• The left outer terminal of the potentiometer was connected to GND.
• The right outer terminal was connected to 5V.
• The middle terminal (output terminal) was connected to analog pin A0 on the Uno board.

Here's how the LED was connected:

• The shorter leg of the LED was connected to GND.
• The longer leg was connected to digital pin 6 through a 1K Ohm resistor.

Make sure to connect the LED to a digital pin with the ~ symbol. Such pins support pulse width modulation, which lets you send analog signals to digital pins.

int potPin = A0;
int potValue = 0;
int brightness = 0;
int ledPin = 6;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  potValue = analogRead(potPin);
  brightness = (255.0/1023.0)*potValue;
  analogWrite(ledPin, brightness);
}

Let's break down the code.

Initialize Variables

We started by initializing our variables:

int potPin = A0;
int potValue = 0;
int brightness = 0;
int ledPin = 6;

The potPin variable has a value of A0. This represents the A0 pin connected to the output pin of the potentiometer.

We then declared a potValue variable, which will be used to store the values from potPin.

The brightness variable will be used to control the brightness of the LED.

The LED pin was connected to digital pin 6 on the Uno board, so we initialized a ledPin variable with a value of 6: int ledPin = 6;.

Serial Monitor and pinMode

Next, in the loop() function, we initialized the serial monitor and set the LED pin to serve as an output pin:

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
}

Create Logic to Control LED Brightness

In the loop() function, we have three lines of code:

void loop() {
  potValue = analogRead(potPin);
  brightness = (255.0/1023.0)*potValue;
  analogWrite(ledPin, brightness);
}

In the first line, we used the analogRead() function to read the value of potPin. The read values were assigned to the potValue variable.

At this point, if you print potValue to the serial monitor using Serial.println(potValue);, you'll get a range of values from 0 to 1023 when you tune the knob of the potentiometer.

For the brightness variable, we converted the values from the potentiometer to fall with the range of 0 to 255: brightness = (255.0/1023.0)*potValue;. This is because the analogWrite() function only accepts values within that range, and not the default 0 to 1023 that the potentiometer produces.

Lastly, we used the analogWrite() function to send values to the LED: analogWrite(ledPin, brightness);.

The analogWrite() function's first parameter is the ledPin, which denotes the pin where the values should be sent. The second parameter is brightness, which denotes a range of values to be sent to the LED (ledPin).

When you upload the code to your board, the LED should have varying levels of brightness as you tune the potentiometer.

Conclusion

In this article, you learned how to control the brightness on an LED using a potentiometer. You also saw how to connect the components to digital and analog pins on an Arduino board.

Finally, you learned about how to make the components work together using code.

You can find the code for this project here. You can watch the video version here.

Check out my blog for articles about embedded systems, IoT, and web development.

Happy coding!

We just published a comprehensive Arduino course on the freeCodeCamp.org YouTube channel. The course covers the basics of Arduino, from hardware components to software programming. It also includes a series of hands-on projects that you can build to apply your knowledge.

Arduino is easy to use even for hobbyists and beginners with little to no experience in electronics. Mathewos Wondwosen created this course. He has a lot of experience creating with Arduino and he is a great person to teach this course.

Here are a few types of projects that people sometimes use Arduino for.

• Controlling LEDs: Arduino can be used to control LEDs to create different patterns and animations.
• Creating interactive projects: Arduino can be used to create interactive projects, such as game controllers, robots, and home automation devices.
• Measuring and collecting data: Arduino can be used to measure and collect data from sensors, such as temperature, humidity, and light.
• Controlling motors: Arduino can be used to control motors, such as servo motors and stepper motors.

Throughout the course, you will build 14 hands-on Arduino projects while learning:

• How to set up the Arduino IDE
• Basic electronics components like resistors, LEDs, and buttons
• Essential coding concepts like variables and loops
• How to connect sensors, displays, and more

By the end of the course, you will have the skills to create your own interactive Arduino prototypes using lights, buzzers, displays, sensors, and more.

Here are all the sections in this course:

• Introduction to Arduino
• Buying the right Arduino Kit
• Using a Digital Simulator
• Project #1 Overview: Basic LED Circuit
• Breadboards
• Resistors
• LEDs
• Assembly
• Project Recap
• Arduino Installation
• Project #2: LED Blink Project
• Homework #1
• Project #3: LED Traffic Light
• Variables
• Project Recap
• Project #4: Analog Pins
• Project #5: Volt Reader
• Project #6: Dimmable LED with Potentiometer
• Project # 7: Simple Buzz Modulator
• Project #8: Melody Buzzer
• Photoresistor
• Thermistor
• Temperature Sensor
• Project #9: LM Temperature Sensor
• Project #9: DHT Sensor
• Project #10: Pushbuttons & Switches
• RGB LED
• Project #11: Color Picker RGB LED
• One Digit 7-Segment LED Display
• Project #12: Countdown timer
• Four Digit 7-Segment LED Display
• Project #13: Alarm Timer
• X 8 LED Matrix
• Project #14: Input Display

Watch the full course on the freeCodeCamp.org YouTube channel (10-hour watch).

Arduino can be applied in a variety of projects like:

• Home automation.
• Internet of Things (IoT).
• Audio and music.
• Automated and remote controlled systems.
• Automation in agriculture.
• Electronic prototyping.
• Wearable devices, and so much more.

The hardware part of Arduino comprises Arduino boards, input and output devices (including digital and analog pins, and sensors and actuators), shields, breadboards, jumper wires, and so on. These components can be combined together to create dynamic and interactive projects.

The software is made up of the development tools used to write, debug, compile, and upload code to Arduino boards. Most 0f the software tools can be found in the Arduino IDE (Integrated Development Environment).

This handbook will help you understand how Arduino works. You'll learn about the Arduino boards, the components that make up a board, and how to connect devices to them.

We'll talk about input and output peripherals which help the microcontroller (the brain of the Arduino board) process information coming from the physical environment, and send output based on programmed logic.

You'll learn about the Arduino IDE, how to code using the Arduino programming language, and how to use sensors, actuators, and other components to build projects as you learn.

You'll also learn about serial communication, which helps Arduino boards communicate with other computers.

This handbook is written for makers (students, artists, hobbyists, programmers) who are beginners.

Prerequisites

Although it would be helpful, you don't need prior programming knowledge to use this handbook. You will learn the basics of Arduino programming from scratch. This can also serve as your introduction to programming.

To make it beginner friendly, we won't talk about some aspects of electronics like current and voltage, resistance, circuits (series and parallel), and most basic electronic/electrical laws and requirements for students in STEM (Science, Technology, Engineering, Mathematics) fields.

Whether you have knowledge of these concepts or not, you can learn about Arduino using this handbook.

If you know how to use a breadboard and a resistor, then that's all the knowledge on electronics you'll need to follow along.

In summary, this handbook is for everyone. You don't need an engineering degree to become an Arduino maker!

Table of Contents:

• Prerequisites
• Chapter 1: Getting Started with Arduino
• Chapter 2: Basics of Arduino Programming
• Chapter 3: How to use Digital Pins in Arduino
• Chapter 4: How to use Analog Pins in Arduino
• Chapter 5: How to use Sensors and Actuators in Arduino
• Chapter 6: How to use the Serial Monitor in Arduino
• Chapter 7: How to use Displays in Arduino

Chapter 1: Getting Started with Arduino

The Arduino development and design process comprises both hardware and software. So knowing how they work together is important for building the right foundation for your journey.

In this chapter, you’ll learn about the different components that make up the Arduino Uno board. You'll also learn how to install the Arduino IDE and set up your development environment.

At the time of writing, a new Uno board was released — the Arduino Uno R4. This handbook will make use of the Uno R3 board, but you can follow along with either of them. The R4 board comes in two variants — Arduino Uno R4 WiFi and Arduino Uno R4 Minima — with cool additional features that you can read about here.

Components of the Arduino Uno R3 Board

There are many types of Arduino boards like Arduino Nano, Arduino Uno, Arduino Mega, Arduino Leonardo, and so on.

These boards have some common features — they all have digital and output pins, they’re programmable, and they all have a microcontroller.

But there are also some differences. Each board varies in size and shape, and usually has more or fewer components when compared to other boards.

The common boards you’ll come across as a beginner are the Nano, Uno, and Mega boards. The most commonly used is the Uno board, which we’ll use for this handbook.

Here are some of the components you'll find on the Uno R3 board:

• A power port.
• USB connector.
• Microcontroller (ATmega328).
• Analog pins.
• Digital pins.
• Reset button.
• TX and RX indicators.

Arduino Uno R3 board (https://store.arduino.cc/products/arduino-uno-rev3)

You’ll make use of most of the components listed above as you progress through this handbook.

How to Install and Set Up the Arduino IDE

You can use the Arduino IDE to program Arduino boards. That is, you write the code in the IDE, then upload it to the board.

In this section, you’ll learn how to set up the IDE, and create your first Arduino program (also called an Arduino sketch).

You can download the latest version of the Arduino IDE on the Arduino software download page. You can download the IDE for different operating systems — Windows, MacOS, and Linux.

The installation process is similar for the operating systems listed above. Here’s how to install it on a Windows machine:

Step #1 – Download the Arduino IDE

The first step is to download the IDE from the Arduino software download page. You should see a section of the page similar to the image below:

On the right side of the image above are different download options for specific operating systems. Make sure you download the option that suits your operating system.

I'll use the ZIP file option for Windows. If you decide to download an installer instead, then you can follow the installation steps after clicking the installation file.

Step #2 – Unzip the Downloaded File

Go on and unzip the downloaded file. This gives you access to all the resources needed to run the Arduino IDE.

After unzipping the file, you should see files like these:

Image showing the files you should see

To launch the Arduino IDE, click on the file that says “Arduino IDE”.

Step #3 – Overview of the Arduino IDE

Now that you’ve downloaded and installed the Arduino IDE, the next part is to get familiar with the development environment. In the next section, you’ll learn how to upload code to an Arduino Uno board using the IDE.

Before that, let’s have a look at some options you’ll find in the Arduino IDE. At the top left corner of the IDE are five options — File, Edit, Sketch, Tools, Help:

Screenshot showing these options (File, Edit, Sketch, Tools, Help)

The “File” option lets you do different things like creating a new sketch (we’ll talk about sketches in the next section), opening an existing sketch, Arduino practice examples for beginners, keyboard shortcuts, save options, and so on.

The “Edit” option gives you access to text formatting options like copy, paste, cut, comment/uncomment code, font size options, text search options, and so on.

You can use the “Sketch” option to verify and compile code, upload code to Arduino boards, optimize code, and add libraries.

You can use the “Tools” option to manage libraries, format code, access the serial monitor and plotter, select an Arduino board and port to upload code to, choose a processor, and so on.

The “Help” option provides resources for troubleshooting, information on IDE updates, guides on “getting started”, and so on.

Next, let’s look at some other parts and functionalities in the IDE that you’ll find useful. The image below, from the Arduino documentation, highlights them perfectly:

https://docs.arduino.cc/software/ide-v2/tutorials/getting-started-ide-v2

• Verify/Upload: You can use these options to compile and upload code to Arduino boards. You’ll get error messages if the code doesn't compile as expected.
• Select Board & Port: You can use this option to select a port and port number to upload your code too. The current version of the Arduino IDE automatically detects both boards and ports.
• Sketchbook: This gives you access to all the sketches created in your computer. You can also access sketches saved on Arduino Cloud (mostly used for creating IoT projects).
• Boards Manager: The Arduino IDE comes with support for different boards. As you progress through your journey, you’ll make use of different boards and some of them may not be supported by the IDE. The board manager tab lets you install and manage packages required to use these boards.
• Library Manager: You can use libraries to extend certain functionalities in code. Through the library manager, you can install numerous libraries that’ll help simplify the development process for you.
• Debugger: This is used for real time testing and debugging of Arduino programs.
• Search: You can use the search tool to find specific keywords in your code.
• Open Serial Monitor: You can use the serial monitor to communicate with Arduino boards, debug and test code, visualize data from your boards, interact with user input, and so on. We’ll look at the serial monitor in depth in a different chapter.
• Open Serial Plotter: The serial plotter is mostly used for real-time visualization of numerical data.

What Is an Arduino Sketch?

We mentioned the term “sketch” a couple of times in the last section, but what is it? A sketch is a program written with the Arduino programming language. It’s another way of referring to a code file written for Arduino projects.

The Arduino programming language is built upon the C/C++ language so they both share similar syntax and structure. You may come across resources that refer to Arduino code as “embedded C” or “embedded C++”.

How to Upload Code to an Arduino Board

To upload code to an Arduino board, you'll need both hardware and software. The hardware is the board which is the Uno board in our case, and the software is the Arduino sketch in the IDE.

Here are the steps:

Step #1 – Connect the Arduino Board

Connect the Arduino board to your computer using the USB cable. Without this step, you can't go further.

Step #2 – Create a Sketch

Now it's time to launch the IDE and write some code.

Here's a code example that makes an LED blink:

int ledPin = 13;

void setup() {
  pinMode(ledPin, OUTPUT);
}

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

Don't worry if you don't understand the code — we'll cover everything as we go further.

Step #3 – Select the Board and Port

You can select the board to upload your code to from the IDE. Here's an image showing what that looks like:

Step #4 – Verify the Code

You can use the verify button to compile the code and check for errors. If errors exist, you'll get an error message to show you the possible cause.

Image showing the verify button

Step #5 – Upload the Code

You can upload the code using the upload button (the button after the verify button).

If there are no errors in your code, these steps will help upload code to your board. If you've uploaded the code above, you should have the built-in LED (it is connected to pin 13 by design) on the Uno board blinking.

In the next chapter, you'll learn the basics of the Arduino programming language.

Chapter 2: Basics of Arduino Programming

Before we dive into creating our own sketches and tinkering, you have to understand the logic that make these boards work as expected. To do that, you’ll have to know how to code using the Arduino programming language.

As discussed in the last chapter, the Arduino language is built upon C/C++. You’ll begin this chapter by learning the basics of programming. This will prepare you for every other chapter that involves writing code.

I’ve created this chapter with beginners in mind. If you’ve never written code before then this can serve as a starting point for you. This doesn’t mean you’ll learn how to code in C or C++. You’ll be learning how to write Arduino code which shares similar syntax with those languages.

At the end of this chapter, you should be able to understand and write Arduino code.

Variables and Data Types in Arduino

Variables and data types are used in most programming languages to store and manipulate data. You can think of variables as containers or storage units. Data types, like the name implies, are the type of data stored in variables.

In Arduino programming, you must specify the data type of a variable before using it. That is:

dataType variableName = variableValue

There are different types of data types in Arduino, and we’ll discuss each one along with code examples.

int Data Type in Arduino

The int data type is used to store integer values. The Uno board has a 16-bit integer capacity so it can store values that fall within the range of -32,768 to 32,767.

int redLED = 6;

In the code above, we created an integer variable called redLED with a value of 6.

The int data type can also store negative integers:

int redLED = -6;

long Data Type in Arduino

The long data type is similar to int but has a wider range of integer values. It has a 32-bit integer limit which falls within the range of -2,147,483,648 to 2,147,483,647.

long largeNumber = 6000;

float Data Type in Arduino

The float data type can be used to store numbers with decimals. Float variables can store values up to 3.4028235E+38 and values as low as -3.4028235E+38.

float num = 10.5;

Although the float data type is mainly used for decimal numbers, it can also accept whole numbers (integers without decimals). But it'll always return a float value. So if you store 10 in a float, it'll return 10.00.

String Data Type in Arduino

You can use the String data type to store and manipulate text. You'll work with strings occasionally to display information in the form of text when building projects.

Here's a code example:

String greeting = "Hello World!";

The value of strings are nested within double quotation marks as can be seen in the code above.

Note that when declaring a string, the "S" should always be in uppercase.

char Data Type in Arduino

The char data type stores single characters.

Here's an example:

char alphabet = 'A';

This is different from the String data type that can store multiple characters.

There are two main differences between char and String:

• char uses single quotes ('A') while string uses double quotes ("Arduino").
• char stores single characters while string stores multiple characters.

char can also accept integer values equivalent to the ASCII value of letters:

char charValue = 65;

In the code above, we initialized a char variable with the value of 65. When printed to the serial monitor (we'll talk about the serial monitor in Chapter 6: How to use the Serial Monitor in Arduino), A will be returned.

A is returned because 65 has an ASCII character of A.

bool and boolean Data Types in Arduino

You can use both bool and boolean to store/denote boolean values of either true or false.

bool roomIsCold = false;

Boolean values are mostly used with logical and comparison operators, and conditional statements (you'll learn about these later in this chapter) to manipulate and control different outcomes in an Arduino program.

byte Data Type in Arduino

The byte data type has an 8-bit unsigned integer limit that ranges from 0 to 255. Unsigned means that it can't store negative values.

byte sensorValue = 200;

The byte data type isn't the only data type that can be unsigned. You can also use the unsigned int, unsigned long, and unsigned char data types which all have their respective positive integer ranges.

Operators in Arduino

Operators are symbols or characters that can be used to perform certain operations on operands. An operand is simply any value(s) an operator acts on.

There are different categories of operators in Arduino like:

Arithmetic Operators

Arithmetic operators are used to perform mathematical operations like addition, subtraction, division, multiplication, and so on. Here are some arithmetic operators you should know:

Addition(+) Operator

The addition operator, denoted by the + symbol, adds two operands together:

int a = 5;
int b = 10;

// we use addition operator to add a and b below
int c = a + b;

Serial.print(c);
// 15

Subtraction(-) Operator

The subtraction operator subtracts the value of one operand from another operand. It is denoted by the - symbol:

int a = 5;
int b = 10;

// we use subtraction operator to subtract b from a below
int c = b - a;

Serial.print(c);
// 5

Multiplication (*) Operator

You can use the multiplication operator (*) to multiply two operands:

int a = 5;
int b = 10;

// we use multiplication operator to multiply a by b below
int c = a * b;

Serial.print(c);
// 50

Division(/) Operator

The division operator divides one operand by another:

int a = 5;
int b = 10;

// we use division operator to divide b by a below
int c = b / a;

Serial.print(c);
// 2

Modulus (%) Operator

The modulus operator returns the remainder of a division between two operands:

int a = 5;
int b = 10;

// we use division operator to divide b by a below
int c = b % a;

Serial.print(c);
// 0

Increment (++) Operator

The increment operator increases the value of a variable by 1:

int num = 5;
num++;

Serial.print(num);
// 6

Decrement (--) Operator

The decrement operator decreases the value of a variable by 1:

int num = 5;
num--;

Serial.print(num);
// 4

Assignment Operators

Assignment operators are mainly used to assign values to variables. You can also use them to update the value of variables.

The assignment (=) operator is used for assigning and updating variables. The = operator should not be confused for "equal to" — they aren't the same. We'll talk about the equal to (==) operator in the Comparison Operators section.

Here's an example that shows how to use the assignment operator:

int age = 1;

In the code above, we created a variable called age, and then assigned a value of 1 to it using the = operator.

But this isn't the only way to assign or update the value of variables when using the = operator. You can also use compound assignment operators.

Compound Assignment Operators

Compound assignment operators let you combine arithmetic operators and the = operator. This method provides a shorter way of writing code. Here is an example:

int x = 5;
x += 5;

Serial.print(x)
// 10

In the code above, we created an x variable and assigned a value of 5 to it. But on the second line, you'd see that we combined the arithmetic addition (+) operator and the = operator to assign a new value to x:

x += 5;

The line of code above is the same as this:

x = x + 5;

So compound operators combine two operators and let you do the same thing in a shorter way. There's nothing wrong with either method.

Here are other compound operator examples:

int a = 10;
a -= 5; // Equivalent to a = a - 5 (a becomes 5)

int b = 10;
b *= 5; // Equivalent to b = b * 5 (b becomes 50)

int c = 10;
c /= 5; // Equivalent to c = c / 5 (c becomes 2)

int d = 10;
d %= 5; // Equivalent to d = d % 3 (d becomes 0)

Comparison Operators

You can use comparison operators to compare two values/operands. Comparison operators return either true (1) or false (0) depending on the relationship between operands.

Comparison operators can help you make decisions based on their return values. You'll see them a lot when we start building projects.

Here are the comparison operators you'll come across occasionally:

Equal To (==) Operator

This operator compares the values of two variables. If the values are the same, it returns true. If the values are not the same, it returns false. Here's an example:

int x = 10;
int y = 5; 

Serial.print(x == y)
// returns 0

The return value of x == y in the code above is 0 (false) because the two variables are not the same. Remember that the == operator returns 1 (true) only when both variables have the same value.

Not Equal (!=) Operator

The not equal operator checks whether two values have different values. It's does the opposite of the == operator. That means it'll return 1 (true) if both values are not of the same value and 0 (false) if both values are the same.

Here's an example:

int x = 10;
int y = 5; 

Serial.print(x != y)
// returns 1

Greater Than (>) Operator

The greater than (>) operator checks if the operand on the left is greater than the operand on the right. If the left operand is greater, it returns 1. If the left operand is smaller, it returns 0.

int x = 10;
int y = 5; 

Serial.print(x > y)
// returns 1

Less Than (<) Operator

The less than (<) operator checks if the operand on the left is less than the operand on the left. If the left operand is smaller, it returns 1. If the left operand is greater, it returns 0.

int x = 10;
int y = 5; 

Serial.print(x < y)
// returns 0

Greater Than or Equal To (>=) Operator

Just like the name, the >= operator checks if the operand on the left is either greater than or equal to the operand on the right. It returns 1 if the left operand is greater than or equal to the right operand, and 0 if it isn't.

"Or" implies that either of the conditions can be used. If the left operand is not greater than the right operand but is equal to the right operand, you'll still get a value of 1.

int x = 10;
int y = 5; 

Serial.print(x >= y)
// returns 1

Less Than or Equal To (<=) Operator

The <= operator checks if the left operand is either less than or equal to the right operand. If the left operand is less than or equal to the right operand, it returns 1, and returns 0 if the left operand is neither less than nor equal to the right operand.

int x = 10;
int y = 5; 

Serial.print(x <= y)
// returns 0

Logical Operators

Logical operators are used in most programming languages to evaluate and determine the relationship between variables.

Here are the three logical operators you should know for Arduino programming:

Logical AND (&&) Operator

The logical AND (&&) operator returns 1 if both statements are true.

int x = 10;

Serial.print((x > 5) && (x > 3));
// returns 1

The expression above — (x > 5) && (x > 3) — returns 1 because both statements are true. That is, x > 3 and x > 3. If either or both of those statements were false, then we'd have a return value of 0.

Logical OR (||) Operator

The logical OR (||) operator returns 1 if one of both statements is true.

int x = 10;

Serial.print((x > 5) && (x > 15));
// returns 1

The code above returns 1 although one of the statements is false. This is because the || operator returns 1 if either or both statements are true.

Logical NOT (!) Operator

The NOT (!) operator negates or reverses the value of its operand. If the operand statement is true, it returns false, and returns false if the operand is true.

Here's an example:

int x = 10;

Serial.print(!(x > 5));
// returns 0

The code above returns 0, but why? x > 5 is true so the expected result is 1.

We got 0 because the ! operator reversed the return value of the operand from 0 to 1.

Conditional Statements in Arduino

You can use conditional statements to make decisions or execute code based on specific conditions. You can combine conditional statements and logic (like operators in the last section) to control how code is executed.

Let's take a look at some conditional statements and how to use them:

if Statement

The if statement is used to execute code if a condition is true. Here's what the syntax looks like:

if (condition) {
    // code to be executed if condition is true
}

In the syntax above, condition denotes a specified logic. If the condition is true then the code in the curly brackets will be executed. Here's an example:

int x = 5;
if (x < 10) {
  Serial.print("x is less than 10");
}

// x is less than 10

In the code above, we gave a condition— x < 10 — and a block of code within curly brackets that prints "x is less than 10". The code in the curly brackets will only run if the condition is true.

This is the same as saying "if x is less than 10 then print 'x is less than 10' to the serial monitor". Since x is less than 10, the condition evaluates as true and we get the message printed out.

But what if the condition is false? The code in the curly brackets won't run, so we'll need a different type of logic to handle situations like that. We can do this using the else statement.

else Statement

The else statement is used to execute code if a condition is false.

int score = 20;
if (score > 50 ) {
  Serial.print("You passed the exam!");
} else {
  Serial.print("You have to rewrite the exam!");
}

// You have to rewrite the exam

In the code above, the condition given is false. So the code for the else statement will be executed because the score variable is not greater than 50.

Remember: the code for the else statement only runs when the condition is false. If the condition is true then the code for the if statement will be executed.

else if Statement

You can use the else if statement to define multiple conditions to be checked. Here's the syntax:

if (condition1) {
    // code to be executed if condition1 is true
} else if (condition2){
    // code to be executed if condition2 is true
} else {
    // code to be executed if condition1 and condition2 are false
}

In the syntax above, there are two conditions (you can create more than two conditions). If condition1 is true, then code in the curly bracket for condition1 will be executed.

If condition1 is false, then condition2 will be evaluated. If condition2 is true, its block of code will be executed.

If both condition1 and condition2 are false, the else statement's code will be executed.

int score = 80;
if (score > 50 ) {
  Serial.print("You passed the exam!");
} else if (score < 50) {
  Serial.print("You have to rewrite the exam!");
} else {
  Serial.print("No records for your exam score found!");
}

// You passed the exam!

switch-case Statement

In the last section, we saw how to create multiple conditions using else if statements. Your code might become hard to read if you have many conditions. We can clean it up and make the code more readable using switch statements.

Here's what the syntax looks like:

switch (expression) {
    case 1:
        // Code to be executed if expression equals case 1
        break;
    case 2:
        // Code to be executed if expression equals case 2
        break;
     case 3:
        // Code to be executed if expression equals case 3
        break;
    default:
        // Code to be executed if expression doesn't match any case
        break;
}

Let's break the syntax down:

• The expression is compared to the value of each case.
• When a case matches the expression, the code for that case is executed.
• The break keyword stops the switch statement's iteration once a match for the expression has been found.
• The code for the default keyword is executed if none of the cases match the expression.

Here's an example:

int day = 2;

switch (day) {
  case 1:
    Serial.print("Monday");
    break;
  case 2:
    Serial.print("Tuesday");
    break;
  case 3:
    Serial.print("Wednesday");
    break;
  case 4:
    Serial.print("Thursday");
    break;
  case 5:
    Serial.print("Friday");
    break;
  case 6:
    Serial.print("Saturday");
    break;
  case 7:
    Serial.print("Sunday");
    break;
  default:
    Serial.print("Number out of range");
  }

//  Tuesday

The code above prints "Tuesday" because the expression which has a value of 2 matches case 2.

Loops in Arduino

You can use loops to execute code repeatedly until a certain condition is met. You can also use loops to iterate over a collection of data and execute code on all elements of the collection.

There are different type of loops you can use in Arduino like the for loop, while loop, and do-while loop. Let's take a look at their syntax along with some practical examples:

for loop

You can use the for loop to iterate through a collection or execute code until a certain condition is met. It is commonly used when you know the number of times the loop is supposed to run.

Here's the syntax:

for (initialization; condition; increment/decrement) {
   // code to be executed
}

There are three important keywords in the syntax above:

• initialization denotes an initial variable (usually an integer) which specifies the starting point of the loop.
• condition is used to control the number of times the loop is expected to run for. The loop stops when the condition is false.
• increment/decrement increases/decreases the value of the initial variable after every iteration.

Here's an example to help you understand the keywords:

for (int i = 0; i < 11; i++){
  Serial.println(i);
}

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

In the loop above, we created an initial variable called 1 with a value of 0.

The condition stated i < 11 which implies that the loop will continue to run as long as i is less than 11.

Using the increment operator i++, we increased the value of i by 1 every time the loop ran.

Lastly, we printed the value of i at every iteration. In the serial monitor, you'll notice the numbers from 0 to 10 printed out. This is because after the number 10, i is no longer less than 11 (the condition given), so the loop terminates.

while loop

The while loop works just like the for loop — it executes code as long as the given condition is true. But its often used when the number of times the loop is supposed to run is unknown.

Here's the syntax:

while (condition) {
    // Code to be executed
}

In the syntax above, the code will continue to run until the condition becomes false.

while (i < 11) {
  Serial.println(i);
  i++;
}

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

do-while Loop

The do-while loop is just like the while loop, but it executes its code block first before checking the validity of the condition given. That is, at the beginning of the loop, the code in curly brackets will run first even if the condition is false. After that, it starts checking if the condition is true or false, just like a normal loop.

In summary, the code for a do-while loop will run at least once, irrespective of the condition given. Here's an example:

do {
  // code block to be executed
}
while (condition);

Here's the code example:

int i = 0;

do {
  Serial.println(i);
  i++;
} while ( i < 11);

// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 10

Arrays in Arduino

You can use arrays in Arduino to store multiple variables of the same data type in a single variable. Each element stored in an array can be accessed using its index number.

Array Declaration

Declaring an array simply means to create one. You can do that in Arduino using the syntax below:

dataType arrayName[arraySize]

In the syntax above:

• dataType represents the data types that'll be stored in the array. For instance, if the data type is int, then only integers can be stored in the array.
• arrayName denotes the name of the array.
• arraySize denotes the number of elements that can be stored in the array.

Here's an array declaration code example:

int ages[4];

In the code above, we created an array called ages. The array can only store four elements with an int data type.

Array Initialization

To initialize an array means to assign values to the array. In the last section, we created an array called ages. Now, let's assign some elements to it:

int ages[4] = {2, 4, 6, 8};

You can see from the example above that there are only four elements in the array — 2, 4, 6, 8. Assigning a fifth element would throw an error because we specified that the array can only have for integer elements: int ages[4];.

You can access the elements of the array using their index number. Indexes start at zero (0) – so the first element has an index of 0, the second element has an index of 1, the third element has an index of 2, and so on.

int ages[4] = {2, 4, 6, 8};

Serial.print(ages[0]);
// 2

As can be seen above, we accessed the first element using the array name and the index of the element in square brackets: ages[0].

You can also assign and reassign values to a particular element using its index:

ages[0] = 10;

Note that you can declare and initialize an array at the same time. I only divided them into separate sections to help you understand what each term means.

Functions in Arduino

In the last chapter, we discussed some built-in functions in Arduino that can be used to carry out a variety of tasks related to Arduino hardware and software components. All we did was write the function name and pass in parameters where necessary and we got the desired outcome.

For instance, the digitalWrite() function writes values to digital pins using two parameters (the pin number and the value to be sent to the pin). Under the hood, some code logic handles that operation.

Let's assume that the logic required to send values to digital pins was up to a hundred lines of code. Without functions, you'll have to write those hundred lines every time you wanted to send values to digital pins.

Functions prevent you from having to reinvent the wheel. They also help you break your code down into smaller, more readable and manageable parts.

Just like how built-in functions can be reused to perform a particular task repeatedly, you can also create your own functions for specific functionalities, and that's exactly what you'll learn in this chapter.

How to Declare Functions in Arduino

There are four main parts of a function in Arduino:

• The type of data the function returns.
• The name of the function.
• The function parameter(s) which is optional.
• The body of the function.

Here's what that looks like:

dataType functionName(optionalParameters) {
    // body of the function
}

So from the syntax above, dataType is the data type the function returns. It can be int, String, and so on. A function that has no return statement uses the void type as its data type.

The functionName is the name given to the function. The name is used to call the function to execute the logic defined in the body of the function. You'd see words like "call", "fire", and "invoke" associated with functions. They all mean the same thing — to execute the function's logic.

optionalParameters are variables that you define when creating a function. They enable functions to accept external data which can be used within the function body. Function parameters are defined along with their data types. You'll understand this when we look at some examples.

The body of the function is where all the logic goes to. What the function does when it is invoked is written in the body.

Now that we've seen the different parts of a function, let's create some functions!

How to Declare a Function with the void Type

In the last chapter, we discussed the void Setup() and void loop() functions. They are two built-in functions that you'll use in every Arduino sketch. These functions are defined using the void keyword because they return nothing

Here's what the syntax looks like for functions that use the void type:

void functionName(optionalParameters) {
    // code logic
}

In the syntax above, functionName denotes the name of the function. We can use that name to call the function in order to execute the code defined in the function.

optionalParameters are used to pass external data to the function while the code logic that runs when the function is called is written between the curly brackets.

Here's an example:

// function declaration
void printName(String userName) {
  Serial.println("Hello " + userName);
}

void setup() {
  Serial.begin(9600);
}

void loop() {
  printName("Ihechikara"); // function call
  delay(1000);
}

In the code above, we created a function called printName which accepts a string parameter called userName. The function's task is to print "Hello " along with whatever the parameter value is.

In the void loop(), we called the function and passed a parameter to it: printName("Ihechikara"). In the serial monitor, you'll see "Hello Ihechikara" printed.

To call a function, all you have to do is write the name of the function with parenthesis: printName(). Remember to pass in parameters when required: printName("Ihechikara").

Using a parameter that has the wrong data type will result in an error. For instance, we defined a string parameter in our example. Using an integer will raise an error because the function expects a string.

How to Declare a Function with a Return Data Type

In this section, I'll use the int data type to show you how functions declared without the void type are used. The logic here is the same with other functions that use the return statement.

// function declaration
int addNums(int a, int b) {

  int result = a + b;
  return result;
}

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println(addNums(2, 10)); // function call
  delay(1000);
}

In the code above, we declared a function with the int type: int addNums(int a, int b) {...}. This implies that the function is expected to return an integer value.

The function's logic adds the value of the two parameters (a and b) and returns their sum. We used the return statement to return the sum of the parameters.

We can now say that the task of the addNums function is to return the sum of two given parameters. This can be seen when we used the function in the void loop():

Serial.println(addNums(2, 10));

We called the function with two parameters and got their sum printed out in the serial monitor.

What You Should Know About the return Statement

In the last two sections, we saw how to use functions in two different ways — functions that use the return statement and functions that don't use it.

But what if you used the return statement in a void function? Would that break the code? The answer is no. I'll explain why.

The main use of the return keyword is to return a value from the function, and then terminate the function. Consider the example below:

int addNums(int a, int b) {

  int result = a + b;
  Serial.println(result);
  return result;

  // This part will be ignored
  Serial.println("Hello World");
}

The function above takes in two parameters — a and b — and returns their sum. You'll notice that we printed "Hello World" after the return statement. The part of the code that comes after the return statement will not be executed because the function terminates/stops its operation once it sees a return statement.

So you should always remember that anything that comes after the return statement will be ignored.

You can use the return statement in void functions but it is a convention not to. We simply use the void keyword to define functions that have no use for the return statement.

Commonly Used Built-in Functions in Arduino Sketch

In this section, we’ll discuss some of the commonly used built-in functions you’ll come across when writing or reading Arduino code. We'll make use of them in most of the upcoming chapters of this handbook.

We'll begin with the two main parts of an Arduino sketch — the setup() and loop() functions.

setup() and loop() Functions in Arduino

You can use the setup() function to configure analog and digital pins, initialize variables, and do other setup functionalities. The setup() function is executed once — when the board is powered on or reset.

The loop() function runs continuously. This part of the sketch is where you write all the code logic. You can use the loop() function to give the Arduino board instructions on different components and sensors.

void setup() {
  // put your setup code here, to run once:

}

void loop() {
  // put your main code here, to run repeatedly:

}

pinMode() Function in Arduino

The pinMode() function is used to configure pins as input or output pins. It can also be used to configure a resistor to act as either a pull-up or pull-down resistor. You'll understand more about this function in the Sensors and Actuators chapter.

Syntax

pinMode(pin, mode)

• pin denotes the pin number on an Arduino board.
• mode denotes the configuration of the pin which can be INPUT, OUTPUT, or INPUT_PULLUP.

digitalRead() Function in Arduino

You can use the digitalRead() function to read the state of digital pins. It returns either 0 (LOW) or 1 (HIGH).

Syntax

digitalRead(pin)

In the code above, pin denotes the pin number on an Arduino board.

digitalWrite() Function in Arduino

The digitalWrite() function assigns or writes values (either HIGH or LOW) to digital pins.

Syntax

digitalWrite(pin, value)

• pin denotes the pin number on an Arduino board.
• value denotes the value to be assigned to pin. Can be HIGH or LOW.

analogRead() Function in Arduino

The analogRead() function reads values from analog pins and returns values that fall within the range of 0 and 1023.

Syntax

analogRead(pin)

In the code above, pin denotes the pin number on an Arduino board.

analogWrite() Function in Arduino

This function writes or assigns an analog value to a pin.

Syntax

analogWrite(pin, value)

• pin denotes the pin number on an Arduino board.
• value denotes the value to be assigned to pin. Range from 0 to 255.

Serial Functions in Arduino

Serial communication enables an Arduino board to communicate with the computer and other devices using the built-in serial monitor. Here are some of the commonly used functions:

Serial.begin()

The Serial.begin() function initializes serial communication. It is the first function you use when working with the serial monitor. The function takes in a baud rate as its parameter.

In this case, baud rate represents the rate or speed of data transfer in serial communication.

Here's the syntax:

Serial.begin(baudRate)

Serial.print() and Serial.println()

You can use the print() and println() functions to print data to the serial monitor.

print(val)
println(val)

In the code above, val denotes the value to be printed.

We'll talk more about serial communication in Chapter 6: How to use the Serial Monitor in Arduino.

delay() Function in Arduino

You can use the delay() function to pause the Arduino program for a specified amount of time. Here's what the syntax looks like:

delay(ms)

In the code above, ms denotes the specified time in milliseconds.

Chapter 3: How to Use Digital Pins in Arduino

Digital pins are used to send and receive digital signals in two states — HIGH and LOW. The digital pins on a Arduino board can be configured as either input or output pins.

These states can also be represented using numbers (1 for HIGH and 0 for LOW), or in volts (V) (5V for HIGH and 0V for LOW).

The number and arrangement of pins differ in various Arduino boards, but they serve the same purpose. So if you understand how to use them in this chapter, you won't have a problem working with them in other boards.

The Uno board has 14 digital pins numbered from 0 to 13. Although each pin can be configured to serve as either a digital input or output pin, some of them come with extra functionalities like:

• Pins 0 (RX) and 1 (TX) enable the Arduino board to communicate serially. RX receives while TX sends.
• Pins that have the tilde (~) symbol beside them support PWM (Pulse Width Modulation) signals. This means that you can use these pins like analog pins (to receive analog values).
• Pins 2 and 3 can be used for interrupt-based functionalities.

How to Configure Digital Pins as Input or Output Pins

When a digital pin is configured as an INPUT pin, it serves as a point for receiving information from components. This way you get data from sensors, electronic components, and so on.

You can use the pinMode() function to configure a pin to serve as either an INPUT or OUTPUT pin. Note that the pins on an Uno board are set to INPUT by default so if you don't specify prior to using them, they'll serve as input pins.

In this section, you'll learn how to use digital pins as both input and output pins. You'll start by learning about them individually, and then see how to combine input and output signals to build a mini project.

We'll start with INPUT.

Digital Pins as INPUT

The information or signal sent to input pins can be read using the digitalRead() function. In this section, you'll learn how to configure and read signals from a digital input pin using different built-in functions.

We'll use the following hardware components:

• Arduino Uno.
• Breadboard.
• Pushbutton.
• Jumper wires.

Here's the diagram for the connection:

Configuration diagram – INPUT

Here's the code:

int pushBtn = 7;
int push_btn_state;

void setup(){
  pinMode(pushBtn, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop(){
  push_btn_state = digitalRead(pushBtn);
  Serial.println(push_btn_state);
  delay(1000);
}

Let's break the code down.

We started by creating two integer variables — pushBtn and push_btn_state:

int pushBtn = 7;
int push_btn_state;

pushBtn was assigned a value of 7. We used this value to denote pin 7 on the Arduino board. We declared the push_btn_state variable but didn't assign any value to it because we'll use it to store the value of the push button later.

In our setup() function, we configured the push button to act as an input pin using the pinMode() function:

pinMode(pushBtn, INPUT_PULLUP);

The function took in two parameters — the pushBtn variable which denoted pin 7, and INPUT_PULLUP which sets the pin as an input with a pull-up resistor.

We also initialized the serial monitor using Serial.begin(9600).

At this point, we've configured the Arduino software and hardware to recognize pin 7 as an input pin.

Next, we used the digitalRead() function to read signals coming from pin 7. Remember the push_btn_state variable we created? That's where we stored the signal:

push_btn_state = digitalRead(pushBtn);

After that, we printed the value being read from pin 7 to the serial monitor using Serial.println(push_btn_state);.

When you open the serial monitor, you'll see 1 being printed out repeatedly. This is the initial state of the pushbutton using a pull-up resistor. When you press down the pushbutton, the value will become 0. When you release the button, the value will become 1.

0 denotes LOW while 1 denotes HIGH. With this example, you should understand how to configure, read, and display signals from an input pin.

Digital Pins as OUTPUT

The main use of an output pin is to send out signals. Since we're working with digital output, we can send either HIGH (5V) or LOW (0V) signals. We can do this for digital pins using the digitalWrite() function.

In this section, we'll use a LED (Light Emitting Diode) to demonstrate how to configure and send signals to components.

Here are the components we'll use:

• Arduino Uno.
• Red LED.
• 1k Ohm resistor.
• Jumper wires.
• Breadboard.

Here's the circuit diagram:

Configuration diagram – OUTPUT

int RedLED = 8;

void setup(){
  pinMode(RedLED, OUTPUT);
}

void loop(){
  digitalWrite(RedLED, HIGH);
  delay(1000);
  digitalWrite(RedLED, LOW);
  delay(1000);
}

In the code above, we configured the red LED, which is connected to pin 8 on the Uno board, as an output pin using the pinMode() function.

We then used the digitalWrite() function to send signals to the pin:

  digitalWrite(RedLED, HIGH);
  delay(1000);
  digitalWrite(RedLED, LOW);
  delay(1000);

With the HIGH parameter, we send 5V to the pin which makes the LED come on. With LOW, we send 0V which turns the LED off. So the LED comes on and off continuously with a delay of 1000 milliseconds. This example is commonly known as the "BLINK" example.

Digital I/O Project

Now that we've understood how to send and receive digital signals using Arduino, let's combine both of them to build an interactive project.

The idea is to control an LED using a pushbutton. When you press the button, the LED goes off, and comes back on when you release the button.

We'll combine the components used in the previous examples:

• Arduino Uno.
• Red LED.
• 1k Ohm resistor.
• Pushbutton.
• Jumper wires.
• Breadboard.

Configuration diagram - INPUT and OUTPUT project

Here's the code:

int pushBtn = 7;
int push_btn_state;
int RedLED = 8;

void setup(){
  pinMode(pushBtn, INPUT_PULLUP);
  pinMode(RedLED, OUTPUT);
}

void loop(){
  push_btn_state = digitalRead(pushBtn);

  if (push_btn_state == 1) {
    digitalWrite(RedLED, HIGH);
  } else {
    digitalWrite(RedLED, LOW);
  }
}

Here's a breakdown of the code above:

First, we connected the pushbutton to pin 7 and the red LED to pin 8.

Then we configured both pins — pin 7 as input, and pin 8 as output.

Next, we read the value of the pushbutton using the digitalRead() function and stored the value in a variable called push_btn_state.

Using an if statement, we checked for the state of the pushbutton. When push_btn_state is not being pushed down, it has a value of 1 (HIGH). We send 5V to the LED using digitalWrite().

When push_btn_state is pushed down, it has a value of 0, and we send 0V to the LED which turns it off.

Chapter 4: How to Use Analog Pins in Arduino

Analog pins can be used to receive and send voltage values from/to different sensors and components. Unlike digital signals that fall within two states of 0 (LOW) and 1 (HIGH), analog values have a wider range of values from 0 to 1023.

The Uno board has six analog pins — A0, A1, A2, A3, A4, and A5. These pins are INPUT pins by default.

Similar to digital pins, there are in-built functions for receiving and sending analog voltage signals. You can use the analogRead() function to read/receive analog values from pins while the analogWrite() function can be used to write to specific pins.

Note that the analogWrite() function doesn't write or send analog values to analog pins. It sends analog voltage values (that get converted to digital signals) to digital pins that support PWM (Pulse Width Modulation).

You can find PWM digital pins on the Arduino board by the (~) symbol beside them. On the Uno board, there are pins 3, 5, 6, 9, 10, and 11.

In the project for this section, you'll learn how to adjust the brightness of an LED using a potentiometer. We'll use the potentiometer as an input component, and send its voltage to an LED to increase/decrease the LED's brightness.

Here are the components we'll use:

• Arduino Uno.
• Yellow LED.
• Potentiometer.
• 1k Ohm resistor.
• Jumper wires.
• Breadboard.

Here's the circuit diagram:

Configuration diagram

Here's the code for the circuit:

int potentiometer = A0;
int pot_value = 0;
float pot_in_PWM;
int yelowLED = 6;

void setup(){
  pinMode(potentiometer, INPUT);
  pinMode(yelowLED, OUTPUT);
}

void loop(){
  pot_value = analogRead(potentiometer);
  pot_in_PWM = pot_value * (255.0 / 1023.0);

  analogWrite(yelowLED, pot_in_PWM);
}

In the code above, we set the potentiometer (connected to analog pin A0) as an input component. The yellow LED (connected to digital pin 6) was set as an output component. The LED is connected to a PWM pin because we'll be sending analog values to it.

Using the analogRead() function, we got the value of the potentiometer and stored it in a variable called pot_value. The potentiometer returns values from 0 to 1023.

We then converted the values returned by the potentiometer to a range of 0 to 255 which corresponds with PWM values. This is because the analogWrite() function sends PWM values that fall within that range (0 to 255). The new range of values was stored in a variable called pot_in_PWM.

Lastly, we used the analogRead() function to send PWM values to the LED: analogWrite(yelowLED, pot_in_PWM).

When you verify and upload the code to your Arduino board, you'll be able to control the brightness of the LED by turning the potentiometer's knob.

Chapter 5: How to Use Sensors and Actuators in Arduino

Sensors and actuators play a crucial role in developing projects using Arduino. They help microcontrollers get information about changes in the physical environment, and make decisions based on that information.

The goal of this chapter is to help you understand the difference between sensors and actuators, and how to use them. Of course, there are numerous sensors and actuators, but we'll focus on just a few. You should be able to explore other sensors on your own at the end of this chapter.

We'll first talk about what sensors are, types of sensors, and how to work with them using code. We'll then do the same for actuators, and conclude by looking at an example that uses both sensors and actuators in a project.

Let's get started!

What are Sensors in Arduino?

A sensor is a device that listens for or detects changes in the environment. Sensors convert the information they detect in the physical environment to electrical signals which are then sent to the microcontroller (the brain of the board).

You can look at sensors like the human sense organs — we use them to gather information about our environment. Each sense organ (like eyes and ears) in the human body has a specific function and mode of operation that's different from other organs.

In the same manner, sensors in Arduino have their specific functions and use cases. For example, we have sensors that can measure and detect temperature, motion, moisture, and so on.

Types of Sensors in Arduino

Here are some commonly used sensors you'll come across when working with Arduino:

• Temperature sensor: Measures the temperature and humidity of the environment.
• Light-Dependent Resistor (LDR): Measures/senses the intensity of light.
• Ultrasonic sensor: Measures the distance of an object from the sensor.
• Motion sensor: Generally detects motion by sensing changes in infrared energy/radiation.
• Soil moisture sensor: Measures the moisture level of the soil.
• Water sensor: Measures water level/detects water, and so on.

There are other types of sensors that you can use with Arduino, but we'll just focus on two: the LDR (light-dependent resistor) and ultrasonic sensor.

With the examples in this section, you'll be able to explore how other sensors work on your own.

How to use the Light-Dependent Resistor (LDR) in Arduino

The light-dependent resistor (LDR), also known as a photoresistor, is an electronic component that has varying levels of resistance depending on the intensity of light.

Basically, you can use this sensor to sense light. You can do cool things with it like creating an automated lighting system that turns on electric lights in your house when it's dark, or a weather station that tracks and monitors sunlight, and so on.

A LDR usually looks like this:

Diagram of an LDR

Here's what the circuit connection looks like:

Configuration diagram

In the circuit above, one leg of the LDR is connected to 5V (volts). The other leg is connected to a 1K Ohm resistor — one end of the resistor is connected to ground (GND) while the other end is connected to an analog pin (A1 in our circuit).

Here's the code:

int ldrPin = A1;
int ldrValue;

void setup() {
  pinMode(ldrPin, INPUT);
  Serial.begin(9600); 
}

void loop() {
  ldrValue = analogRead(ldrPin);
  Serial.println(ldrValue);
  delay(1000); 
}

In the code above, we created a variable called ldrpin with a value of A1. This denotes the connection made in the circuit where one leg of the LDR is connected to the analog pin. This pin will help us know the value of the sensor.

We then created an ldrValue variable which will be used to store the value of the sensor.

In the setup() function, we set the LDR as an INPUT pin. We also initialized the serial monitor.

Next, we read the value of the LDR using the analogRead function, and stored the value in the ldrValue variable:

ldrValue = analogRead(ldrPin);

Lastly, we printed the read value to the serial monitor with a delay of 1000 milliseconds (one second).

At this point, if you increase the exposure of light on the LDR, the value increases. If you decrease the light intensity or cover the sensor to block off light, the value will decrease or become zero, respectively.

How to Use the Ultrasonic Sensor in Arduino

The ultrasonic sensor is generally used to measure the distance of objects. You can use this sensor in a lot of applications like:

• Home automation (you can perform certain actions when the presence of an object/human is sensed, like turning on lights in a dark room).
• Automated doors.
• Security systems.
• Measurement of distance, and so on.

Just like other sensors, there are various types. In this example, we'll use the HC-SR04 ultrasonic sensor. Don't worry, the working principle is the same. So if you understand how to use this one, you can configure and use other types of ultrasonic sensors you come across.

Here's what the circuit diagram looks like:

Configuration diagram (from https://howtomechatronics.com/tutorials/arduino/ultrasonic-sensor-hc-sr04/)

The sensor has four pins — VCC, Trig, Echo, and GND.

• The VCC pin is connected to 5V on the Uno board
• The Trig pin is connected to digital pin 9.
• The Echo pin is connected to digital pin 10.
• The GND pin is connected to GND on the Uno board.

The trig pin is used to "trigger" the ultrasonic sensor while the echo pin is used to distance of objects based on the amount of time it takes for ultrasonic waves/signals to bounce back from an object.

Here's a code example:

int trigPin = 9; 
int echoPin = 10;  

long duration, distance;

void setup() {
  Serial.begin(9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  duration = pulseIn(echoPin, HIGH);

  distance = (duration / 2) * 0.0343;

  Serial.print("Distance: ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(1000);
}

In the code above, the trig pin denotes digital pin 9, and the echo pin denotes digital pin 10.

We declared two variables — duration and distance — to be used to store their respective values.

We triggered the sensor by sending the HIGH signal to the trigger pin for 10 microseconds. Without this, the sensor might not work:

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

We measured and stored the duration of the ultrasonic pulse/signals using the pulseIn(echoPin, HIGH) function and stored it in the duration variable.

We then calculated the duration in centimeters and stored it in the distance variable.

Lastly, we printed the distance to the serial monitor with a delay of 1000 milliseconds.

At this point, you can place an object closer to or farther away from the sensor and see the value of the distance of the object change in the serial monitor.

What are Actuators in Arduino?

Actuators in Arduino are components that convert electrical signals into physical/mechanical motion.

Here are some actuators:

• LED (Light Emitting Diode): Used as light/visual indicators.
• Buzzer: Used to produce sound.
• Relay modules: Used to control high voltage devices.
• LCD (Liquid Crystal Display): Used as visual display for text, images, sensor data, and so on. We'll dedicate a separate chapter to displays.
• Servo motors: Used to control angular or rotational motion (an example is the movement of a robotic arm).

We'll focus on the buzzer and LED in this section.

How to use LEDs in Arduino

LEDs are usually the first components you learn about in Arduino. There are easy to connect and use.

Here's what an LED looks like:

Here's the circuit connection:

In the circuit above, the longer leg of the LED (the anode or positive leg) is connected to digital pin 7.

The shorter leg (cathode) is connected to ground.

Here's the code:

int redLED = 7;

void setup() {
  pinMode(redLED, OUTPUT);
}

void loop() {
  digitalWrite(redLED, HIGH);
  delay(1000);
  digitalWrite(redLED, LOW);
  delay(1000);
}

The code above will make the LED blink once the code has been uploaded.

How to use a Buzzer in Arduino

You can use buzzers to produce sound. There are generally two types of buzzers: active and passive buzzers.

Active buzzers usually have a predefined type of sound that they produce when voltage is supplied to them. The sound cannot be modified. Active buzzers have an internal circuit that triggers the sound production.

Passive buzzers are a bit more flexible when it comes to producing sound because they rely on external signals. This means that you can determine the frequency (or frequencies) of the sound produced by the buzzer.

Buzzers can be used in different applications like:

• Alarm systems.
• Sound indictor for home appliances.
• Doorbells.
• Communication devices to denote the start/end of a signal communication, and so on.

We'll work with the passive buzzer because of its flexibility. This is what it looks like:

The buzzer has a positive and negative terminal. The positive is connected to a digital pin while the negative is connected to ground.

Here's the circuit diagram:

In this example, we'll use the buzzer to produce the DO, RE, MI, FA, SOL, LA, TI music notes sound.

Here's the code:

int buzzerPin = 7;

int notes[] = {262, 294, 330, 349, 392, 440, 494};

int noteDurations[] = {400, 400, 400, 400, 400, 400, 400};

void setup() {
  pinMode(buzzerPin, OUTPUT);
}

void loop() {
  for (int i = 0; i < 8; i++) {
    tone(buzzerPin, notes[i], noteDurations[i]);
    delay(noteDurations[i] + 50);
    noTone(buzzerPin);
  }

  delay(1000);
}

In the code above, we used the buzzerPin variable to denote pin 7 on the Uno board.

We then created an array called notes[] which stores the respective frequency of each note, and another array called noteDurations which stores the duration of each note as they're being produced by the buzzer.

In the void loop() function, we looped through each note a played them using the tone() function. The function takes in three parameters — the pin connected to the buzzer, the frequency, and the duration.

We used the noTone() function to stop the generation of sound. Lastly, we added a delay of 1000 milliseconds which is the amount of time it'll take to play the notes from the start after the last note has been played.

If you've followed along up to this point, then you should have the DO, RE, MI, FA, SOL, LA, TI music notes playing through the buzzer.

Arduino Sensor and Actuator Example

Now that you understand what sensors and actuators are and how to use them, let's use them together in one project.

In many embedded systems, sensors and actuators work together to get a specific task/functionality done. Here's how that works:

• A sensor detects/senses changes in the environment, and sends signals to the microcontroller to notify it of the detected changes.
• The microcontroller processes the signals from the sensor. Depending on the existing logic (defined in the code), it sends signals to the actuator.
• The actuator converts the signal from the microcontroller to physical/mechanical motion.

Let's demonstrate these using an example. The idea here is to turn on an LED in a dark environment and turn it off when there's enough light.

The sensor will be the LDR sensor, the microcontroller will be the Arduino Uno board/software, and the actuator will be the LED.

Here's the circuit diagram:

Here's the code:

int redLED = 7;

int ldrPin = A1;
int ldrValue;

void setup() {
  pinMode(ldrPin, INPUT);
  pinMode(redLED, OUTPUT);
  Serial.begin(9600); 
}

void loop() {
  ldrValue = analogRead(ldrPin);

  if (ldrValue > 200) {
    digitalWrite(redLED, LOW);
  } else if (ldrValue < 200) {
    digitalWrite(redLED, HIGH);
  }

  Serial.println(ldrValue);
  delay(1000); 
}

As usual, we created variables to represent the Arduino pins connected to the LED and LDR. We then set the LDR as INPUT and the LED as output in the setup() function.

We read the value of the LDR using the analogRead() function and stored it in the ldrValue variable.

Next, we used the an if statement to check the value of the LDR.

If the value is greater than 200, we turn off the LED. If the value is less than 200, we turn on the LED.

Chapter 6: How to Use the Serial Monitor in Arduino

The serial monitor is a useful tool for every Arduino builder. You can use it for a variety of tasks like:

• Debugging and testing code/components.
• Serial communication between the Arduino board and the computer.
• Display sensor and component data and readings.

In this chapter, you'll learn how to initialize and use the serial monitor using the Arduino IDE. You'll learn about different built-in functions that can be used to send and receive data between the Arduino board and the computer.

Lastly, you'll build a project that uses values sent from the serial monitor to power specific LEDs connected to the Arduino board.

How to Initialize the Serial Monitor With Serial.begin()

You can use the Serial.begin() function to initialize the serial monitor. It takes in the baud rate as its parameter. Here's what the syntax looks like:

Serial.begin(baudRate)

The baud rate is the speed of data transfer between the Arduino board and the computer or any other device communicating with the Arduino board through the serial monitor.

The most commonly used baud rate is 9600, but you'll also come across resources that make use of 115200, 57600, and 38400, and so on. Whichever baud rate you specify in the Serial.begin() function should always match the baud rate seen in the serial monitor window.

For example, we can initialize the serial monitor in the IDE using the Serial.begin() function like this:

void setup() {
  Serial.begin(9600);

}

void loop() {
  // put your main code here, to run repeatedly:

}

In the code above, using the Serial.begin() function, we initialized the serial monitor in the setup() function with a baud rate of 9600.

At this point, nothing is happening. You can verify that the baud rates match by opening the serial monitor window. Once you have it open, you should have the serial monitor appear at the base of the IDE. You'll see the baud rate of the serial monitor within the window, usually written like "9600 baud".

Image showing baud rate

If you're using an older version of the IDE, the serial monitor may pop up as a separate window. The functionality is still the same.

Now that we've initialized the serial monitor, let's see how to send and receive data with it.

How to Send Data with Serial Monitor

You can use different built-in functions reserved for serial communication in Arduino. We won't discuss all the built-in serial functions in Arduino – we'll just look at some you'll use/come across regularly. You can see more functions here.

print() and println() Functions

The print() and println() functions both print data to the serial monitor. The difference between the two is that print() prints data on the same line while println() prints each data on a new line.

Here are some examples:

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.print("Hello"); 
  delay(1000);
}

In the code above, we used the print() function to print "Hello" to the serial monitor repeatedly with a delay of 1000 milliseconds. Here's what the output looks like in the serial monitor:

Here's another example using the println() function:

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.println("Hi");
  delay(1000);
}

Here's the output in the serial monitor:

How to Receive Data with Serial Monitor

We'll discuss four functions in this section — available(), readString(), parseInt(), and parseFloat(). You can read up on other serial functions here.

available() Function

The Serial.available() function checks the number of characters in the serial port. It is mostly use to run code only when data is available in the serial monitor.

Here's a code example:

int userInput;

void setup(){
  Serial.begin(9600);
}

void loop(){
  if (Serial.available() > 0) {
    userInput = Serial.parseInt();

    Serial.println(userInput);
  }

}

In the code above, the code block in the if statement will not run until the number of characters in the serial monitor is greater than 0.

When you initialize the serial monitor, the number of readable characters will be zero because there is no data available yet. The Serial.available() function checks and returns the number of characters available in the serial monitor. So it is used to create logic that only lets code be executed when data is available.

readString() Function

You can use the readString() function to read characters from the serial monitor. It returns a string object so whatever values/characters you input in the serial monitor will be seen as string values when using the readString() function.

String userInput;

void setup(){
  Serial.begin(9600);
}

void loop(){
  if (Serial.available() > 0) {
    userInput = Serial.readString();

    Serial.println(userInput);
  }

}

parseInt() Function

The parseInt() function returns valid integer values from incoming serial data. Non integer values will be returned as 0.

int userInput;

void setup(){
  Serial.begin(9600);
}

void loop(){
  if (Serial.available() > 0) {
    userInput = Serial.parseInt();

    Serial.println(userInput);
  }

}

parseFloat() Function

The parseFloat() function returns valid floating point numbers from incoming serial data.

float userInput;

void setup(){
  Serial.begin(9600);
}

void loop(){
  if (Serial.available() > 0) {
    userInput = Serial.parseFloat();

    Serial.println(userInput);
  }

}

Serial Monitor Project

In this section, you'll build a project that uses string values from the serial monitor to turn on LEDs. We'll make use of some of the serial functions discussed in previous sections.

Here's the circuit diagram:

In the circuit diagram above, we have three LEDs. The red LED is connected to pin 6, the blue LED to pin 5, and the yellow LED to pin 4.

Here's the code:

int redLED = 6;
int blueLED = 5;
int yellowLED = 4;

String userInput;

void setup(){
  pinMode(redLED, OUTPUT);
  pinMode(blueLED, OUTPUT);
  pinMode(yellowLED, OUTPUT);
  Serial.begin(9600);

  Serial.println("Choose an LED to turn on from the list below:");
  Serial.println("red");
  Serial.println("blue");
  Serial.println("yellow");
}

void loop(){

  if (Serial.available() > 0) {

    userInput = Serial.readString();

    if (userInput == "red") {
      digitalWrite(redLED, HIGH);
      digitalWrite(blueLED, LOW);
      digitalWrite(yellowLED, LOW);
    } 

    if (userInput == "blue") {
      digitalWrite(redLED, LOW);
      digitalWrite(blueLED, HIGH);
      digitalWrite(yellowLED, LOW);
    }

    if (userInput == "yellow") {
      digitalWrite(redLED, LOW);
      digitalWrite(blueLED, LOW);
      digitalWrite(yellowLED, HIGH);
    }

  }

}

Let's break down the code above.

Just like the connection in the circuit diagram, we initialized the three LEDs with their respective pin numbers. We also created a string variable called userInput that will be used to store the data from the serial monitor:

int redLED = 6;
int blueLED = 5;
int yellowLED = 4;

We then configured the three LEDs as output pins using the pinMode() function:

pinMode(redLED, OUTPUT);
pinMode(blueLED, OUTPUT);
pinMode(yellowLED, OUTPUT);

We initialized the serial monitor with a baud rate of 9600, and printed some strings to give users a hint at the expected values to be used in the serial monitor:

Serial.begin(9600);

Serial.println("Choose an LED to turn on from the list below:");
Serial.println("red");
Serial.println("blue");
Serial.println("yellow");

At this point, you'll have an output like this in the serial monitor:

Using the Serial.available() function, we check for availability of serial data before running the code in the if statement:

if (Serial.available() > 0) {
    ...
}

The next thing we did was to read and return the incoming data as string values, and store the data in the userInput variable. We did that using the readString() function:

userInput = Serial.readString();

Lastly, we used if statements to check which LED color value the user has typed in/sent through the serial monitor, then turn on/off the respective LEDs:

if (userInput == "red") {
  digitalWrite(redLED, HIGH);
  digitalWrite(blueLED, LOW);
  digitalWrite(yellowLED, LOW);
} 

if (userInput == "blue") {
  digitalWrite(redLED, LOW);
  digitalWrite(blueLED, HIGH);
  digitalWrite(yellowLED, LOW);
}

if (userInput == "yellow") {
  digitalWrite(redLED, LOW);
  digitalWrite(blueLED, LOW);
  digitalWrite(yellowLED, HIGH);
}

If you type and send red through the serial monitor, the red LED comes on while the others goes off. The same logic applies to sending blue or yellow through the serial monitor.

Chapter 7: How to Use Displays in Arduino

You can use display components in Arduino to represent data visually in different formats like text, images, and so on.

Displays provide an alternative to showing data other than the serial monitor. You can use them to display sensor values, instructions to users, user input, and so on.

There are various types of display components when it comes to building with Arduino but we'll focus on the LCD (Liquid Crystal Display).

To be more specific, we'll use the 16 x 2 LCD (HD44780). This is what it looks like:

From the image above, there are sixteen pins with different values. We'll use most of these pins to make connections to the Uno board which will enable us use and control the component.

There are generally two ways of connecting the LCD — using the built-in library or using a third-party library.

With the built-in LiquidCrystal library, you'll make use of about 12 pins on the LCD component. When it comes to using a third-party library like LiquidCrystal_I2C, you'll make use of just 2 pins.

We'll be using the first method — this will help you understand how the pins work. Now let's talk about those pins.

What are the pins in an LCD used for?

The pins control functionalities like memory management, data transfer, and power on an LCD. Let's talk about them in detail:

• The first pin from the left is the GND pin, which is the LCD's ground pin. It is connected to GND on the Arduino board. In some LCD modules, it may be written as VSS.
• The VCC is the power pin which is connected to 5V on the Arduino board. In some LCD modules, it may be written as VDD.
• The V0 pin is used to adjust the contrast of the LCD. It is connected to a potentiometer. Tuning the potentiometer changes the contrast of the data being displayed.
• The RS (Register Select) pin can be used to control the LCD's memory. It is usually connected to a digital pin.
• The RW (Read/Write) pin controls whether data is written or read to the LCD. It is usually connected to ground (GND) which sets the LCD to write mode — this enables you to send and display data with the LCD.
• The E (Enable) pin "enables" data transfer between the microcontroller (in our case, the Uno board) and the LCD. It is usually connected to a digital pin.
• The D0 to D7 (can also be written as DB0 to DB7) are the data pins. There are used to send data to the LCD in bits. In most cases, the D4 to D7 pins are used. The main difference is that data is sent in 4-bits with the D0 to D3 pins, while data is sent in 8-bits with the D4 to D7 pins. There are usually connected to digital pins.
• The LED pins are used to control the backlight of the LCD. In some LCD modules, they may be written as BLA and BLK, or A and K. The first LED pin is connected to 5V using a resistor while the second LED pin is connected to ground (GND).

Example #1 – How to Connect and Use an LCD with Arduino

In the last section, we talked about the meaning of the pins on an LCD. In this section, you'll see a practical example on how to connect them in a circuit, and write code to display data on the LCD.

We'll use the following components:

• Arduino Uno.
• 16 x 2 LCD.
• Potentiometer.
• Jumper wires.
• Resistors.
• Breadboard.

Here's what the circuit diagram looks like:

In the circuit above, we made the following connections from the LCD to the Uno board:

• The LCD's GND pin was connected to GND on the Uno board.
• The LCD's VCC pin was connected to 5V on the Uno board.
• The V0 pin was connected to the potentiometer.
• The RS pin was connected to digital pin 4 on the Uno board.
• The RW pin was connected to GND on the Uno board.
• The LCD's D4 was connected to digital pin 6 on the Uno board.
• The LCD's D5 was connected to digital pin 7 on the Uno board.
• The LCD's D6 was connected to digital pin 8 on the Uno board.
• The LCD's D7 was connected to digital pin 9 on the Uno board.
• The first LED pin was connected to 5V.
• The second LED pin was connected to GND.

For the potentiometer, one of the outer legs (either the left or right) was connected to 5V, the other outer leg was connected to GND. Then the middle leg of the potentiometer was connected to the V0 pin on the LCD. This will enable you to control the contrast of the LCD.

Next, we'll write some code!

#include <LiquidCrystal.h>

LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

void setup() {
  lcd.begin(16, 2);
  lcd.print("freeCodeCamp!");
}

void loop() {

}

In the code above, we first included/imported the built-in LiquidCrystal library which can be used to interact with an LCD using Arduino code: #include <LiquidCrystal.h>.

We then initialized the lcd object with the required pin numbers: LiquidCrystal lcd(4, 5, 6, 7, 8, 9). The first number denotes the RS pin. The second number denotes the E pin. The last four numbers denote the data pins (D4 to D7).

Next, we initialized the number of columns and rows using the lcd.begin() function: lcd.begin(16, 2). We have 16 columns and 2 rows.

The lcd.print function prints data to the LCD. If you've made all the connections right, you should see "freeCodeCamp" displayed on the LCD.

In the next examples, we'll work with user input and sensor data, and also see other lcd functions.

Example #2 – How to Display User Input with LCD in Arduino

In this example, we'll accept input from the user using the serial monitor, and display the input along with a welcome message on the LCD screen.

We'll make use of the same circuit in the previous example. Here's the code:

#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

String userInput;

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);

  lcd.print("Input name");

  lcd.setCursor(0, 1);
}

void loop() {
  if (Serial.available() > 0) {

    userInput = Serial.readString();
    lcd.print("Welcome " + userInput);
  }
}

In the code above, we created a string variable called userInput which will be used to store the value of the user's input.

We then initialized the serial monitor — Serial.begin(9600);

Next, we set the rows and columns of the LCD using the lcd.begin function.

Using the lcd.print function, we printed "Input name" on the LCD screen.

This was followed by the lcd.setCursor(0, 1) function which has two parameters — 0 and 1. 0 represents first column on the left while 1 represents the second row. So the cursor will be set to the second line of the LCD.

We set the cursor to be on the second line because we already have some text ("input name") on the first line so it would be more ideal in this case to print the message to the user on the next line. I'll show you an alternative way to do this after this example.

In the void loop() function, we used the Serial.readString() function to read the value of user's input and stored it in the userInput variable.

Lastly, we printed a welcome message and the user's name in the LCD. This will be printed on the second line because that's where we set the cursor to be.

Play around with the code and see what happens as you adjust the parameters of the lcd.setCursor() function. This will help you understand it better.

Example #2 Alternative

An alternative way to print the message to the user is by using the same line where the initial message was displayed. We can clear whatever is written on the first row of the LCD and display a different value.

Here's how:

#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

String userInput;

void setup() {
  Serial.begin(9600);
  lcd.begin(16, 2);

  lcd.print("Input name");
}

void loop() {
  if (Serial.available() > 0) {
    lcd.clear();
    userInput = Serial.readString();
    lcd.print("Welcome " + userInput);
  }
}

In this example, we used the lcd.clear() function to clear the initial request message and display/print the welcome message to the user. The rest of the logic is the same.

So when you type in a name in the serial monitor an hit enter, the request message ("Input name") will be cleared while the welcome message will be displayed with the name you inputted.

Example #3 – How to Display Sensor Data with LCD in Arduino

In this example, we'll display data from a sensor on the LCD. We'll use the temperature sensor. The logic here is to sense the temperature of a room and display the varying values on the LCD.

Here are the components we'll use:

• Arduino Uno.
• 16 x 2 LCD.
• Light-Dependent Resistor (LDR).
• Potentiometer.
• Jumper wires.
• Resistors.
• Breadboard.

Here's the circuit diagram:

The circuit diagram is almost the same as the ones in the previous examples, except that we added an LDR to measure the intensity of light. Using the LDR, we'll read, store, and display the value of light intensity on the LCD.

Here's the code:

#include <LiquidCrystal.h>
LiquidCrystal lcd(4, 5, 6, 7, 8, 9);

int ldrPin = A1;
int ldrValue;

void setup() {
  pinMode(ldrPin, INPUT);
  lcd.begin(16, 2);
}

void loop() {
  ldrValue = analogRead(ldrPin);

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("LDR value:");

  lcd.setCursor(0, 1);
  lcd.print(ldrValue);

  delay(1000);
}

Let's break down the code.

We started by including the built-in LiquidCrystal library and initialized the respective pins for working with the LCD (refer to the first example if you do not understand how the connection and initialization works).

We then created two variables: ldrPin which denoted the analog pin connected to the LDR, and ldrValue to store the readings from the LDR.

In void setup(), we configured the LDR as an input pin and set the columns and rows of the LCD.

Next, we read the value of the LDR using the analogRead function and stored that value in the ldrValue variable.

Using the lcd.clear() function, we clear the display after each reading. This helps in making the reading appear more accurately. If you remove the function, then some values will still be on display and make your results appear inaccurately (I spent about thirty minutes figuring this out 😂).

After that, we set the cursor on the first row and column of the LCD: lcd.setCursor(0, 0), and displayed a message ("LDR value:").

Using the lcd.setCursor(0, 1) function, we moved the cursor down to the second row, and used lcd.print(ldrValue) to print/display the value of the LDR on the LCD.

Lastly, we added a delay of 1000 milliseconds.

Now you can see the value of light intensity in your environment displayed on the LCD.

You can use a flashlight to increase and decrease the exposure of light on the LDR, and then observe the values change on the LCD. Pretty cool!

Conclusion

Congratulations! We've come to the end of this handbook. You now have enough knowledge to take on bigger projects.

And that should be your next goal — applying these concepts to projects that aid you and the people around you. There is no limit to what you can create. You can start by watching a couple of videos to see the type of projects people build, then you can come up with yours.

This handbook covered the necessary parts of Arduino (both hardware and software) that you'll need as a beginner to kickstart your journey.

The best way to improve and retain what you've learned is by practicing and building.

Happy tinkering!

Arduino boards are able to read inputs - light on a sensor, a finger on a button, or a Twitter message - and turn it into an output - activating a motor, turning on an LED, publishing something online. You can tell your board what to do by sending a set of instructions to the microcontroller on the board.

We just released a full course on the freeCodeCamp.org YouTube channel that will teach you how to use Arduino hardware and software.

Ashish Bansal developed this course. He will teach you everything you need to know to start creating your own electronics with Arduino. And you don't even have to have any hardware to follow along.

Here are all the topics covered in this comprehensive course:

Section 1: Objective of the course

• Course Introduction

Section 2: Foundation of Electronics

• Electricity
• Static Electricity
• Current Electricity
• Voltage
• Current
• Resistance
• Ohm’s Law
• Ohm’s Law Example
• Resistances in Series and Parallel
• Resistance Color Coding

Section 3: Intro to Arduino Board

• What is Microcontroller and Microprocessor
• What category Arduino falls into?
• Different Types of Arduino Boards
• About Arduino
• Parts of Arduino Uno
• Technical Specifications of Arduino Uno

Section 4: Intro to Arduino IDE

• What is IDE?
• Downloading and Installing the official IDE
• Preparing your computer
• Testing the Arduino.
• What if you don’t have an Arduino board?

Section 5: Before we move ahead

• What is breadboard?
• How to make connections in breadboard?
• Some safety instructions and Do’s and Don’ts
• Input & Output
• Analog & Digital
• Bit & Byte

Section 6: Arduino Programming

• Introduction
• The First Step into Programming
• Bare minimum structure of an Arduino Program
• Comments
• White Spaces and Case Sensitivity
• pinMode
• digitalWrite and delay
• Camel casing

Section 6.1 Introduction to Variables and Data Types

• What are variables and data types
• Int data type
• Arithmetic operators
• Incrementing and Decrementing our variables
• Float data type
• Bool/Boolean data type
• Byte data type
• Char data type
• Conclusion

Section 6.2 Variable Scope and Qualifiers

• What is Scope? Global and Local Variables
• What are Qualifiers, starting with const qualifier
• Alternative to const qualifier: #define
• Static Qualifier

Section 6.2 Comparison and Logical Operators

• What are comparison operators?
• What are Logical Operators?

Section 6.3 Control Structures

• if statement
• else statement
• A joke :P
• if - else Simulation
• Introduction to loop control structures
• For loop
• While loop
• do…while loop
• break
• continue
• return
• switch..case

Section 6.4 Remaining data types

• Arrays
• Strings

Section 6.5 Functions

• What are functions?
• Create your own functions

Section 6.6 Arduino Built-in Functions and related concepts

• digitalRead & digitalWrite
• analogRead and Analog to Digital Converter (ADC)
• analogWrite and Pulse Width Modulation (PWM)

Section 6.7 Libraries

• What are Libraries?
• How to add Libraries in Arduino IDE
• What's next?

Watch the full course below or on the freeCodeCamp.org YouTube channel (4-hour watch).

The world as we know it was recently taken by storm. That storm was the outbreak of the COVID-19 pandemic. This has in turn created a shortage of ventilators world wide which has led many people to foray into the world of ventilator design.

There is just one problem: many people are basing their designs around the Arduino platform. While this may be good for a proof of concept, you do not want to use it for actual life support unless absolutely necessary.

This is because platforms like the Arduino were designed as a platform to be used in a learning environment. They were not designed for the real time, safety-critical design that is required to build ventilators.

However, there are some workarounds you can employ to adapt the platform for use in a makeshift emergency ventilator if one isn't available.

In this post we will discuss real time systems and safety-critical systems. Hopefully you can use some of these principles in your own ventilator control system designs to improve their safety and reliability.

Since the target audience is mainly web developers trying their hand at embedded design, I will try to make this post as self contained as possible. Join me as we dive from the browser into the realm of embedded systems design and move closer to the hardware to design our ventilators.

Embedded Systems

For all its usefulness a ventilator is simply an embedded system. An embedded system is a system that is designed to carry out one function and to perform it well, with high reliability and minimal user intervention.

To accomplish this an embedded system consists of two components: a hardware system as well as a software component to run the hardware configuration.

A classical embedded system is typically powered by a control device which generally integrates RAM, ROM, as well as a host of embedded peripherals on board to allow the system to accomplish its task.

Modern embedded systems can sometimes be based around an applications processor, which may integrate a GPU, multiple CPU cores, multimedia codecs and other devices. Though applications processors can be used in embedded systems, they are mainly used in general purpose computing systems such as a smartphone.

The software that runs on an embedded system is called firmware. It is called firmware because once written into ROM, it is not expected to change frequently.

Components of An Embedded System

Think of a ventilator. Its main purpose is to provide mechanical ventilation to keep patients alive. It performs one function and does it with a high degree of reliability, to such an extent that it can be used as a life support system. Very rarely do you find someone changing the firmware in such a device once deployed.

The Hardware Component

As stated previously, the embedded system has a hardware component which integrates RAM, ROM and other devices in one package. This device is called a microcontroller.

There are several popular microcontrollers today. The PIC and AVR from Microchip Technology and the STM32 from STMicroelectronics are the most popular. The classic Arduino uses an AVR microcontroller at its core.

Regardless of the manufacturer, the microcontroller will consist of a processor core, memory and a means to provide input and output also known as I/O.

Microcontrollers also consist of memory which are divided into two categories: data memory and program memory.

Data memory is memory that is used to store data that will be used by the microcontroller during run time. It is typically a few tens to a few hundred kilobytes of SRAM. Data memory is volatile and is lost when power is removed from the device.

Program memory on the other hand, actually stores the memory that will be used by the microcontroller. It consists of Flash (think the memory in your USB flash drive) or FRAM (Ferroelectric RAM) and is not volatile. The size of program memory typically ranges from a few bytes to a couple of megabytes on modern systems.

The Input and Output (I/O) pins on the microcontroller are what allow the device to communicate with external devices such as sensors and other chips that perform various functions such as memory expansion and even adding additional I/O to the device.

A microcontroller will also integrate peripherals for performing analog to digital (A to D) and digital to analog (D to A) functionality.

This is because our world is analog in nature and Analog to Digital Conversion (ADC) will convert real world data into a format our microcontroller can process. If you have a voice recorder, a microphone sensor together with a microcontroller will convert your voice into a digital format and store it.

The microcontroller may also have means to perform Digital to Analog Conversion (DAC) whereby digital data can be converted into an analog format that we can utilize in the real world.

In our voice recorder example, this would be applicable when you must play back your recorded voice. The stored digital information is converted to sound we can detect in our analog world.

When we combine all this we get a block diagram of typical microcontroller hardware.

Crude Microcontroller Block Diagram

Now that we have a basic understanding of the hardware, let's look at the software component.

The Software Component

As great as your hardware is, without the software to control it, it's as useful as a paper weight. Software in embedded systems typically fall into three basic categories:

• cyclic execution systems,
• finite state machine based systems, and
• systems build using a real time operating system.

The difference between these three types of software systems is based on the way they handle tasks. When we speak about tasks, what we are talking about is the smallest unit of execution within your firmware.

Cyclic Execution Systems

A cyclic execution system works by having all the program tasks contained in an infinite loop. These systems have one main program entry point, and then the system cycles through a list of tasks. This is the simplest type of firmware design and is used for basic systems.

Cyclic Execution System

This system will have a program entry point which would typically configure hardware and set up systems clocks and basic bring up tasks. Once the program enters into the infinite loop, it will perform Task one, then Task two and finally Task three.

Finite State Machine

While the cyclic based execution system is simple and effective for most tasks, sometimes you need a little more control over program flow. When this occurs a designer may use what is known as a Finite State Machine (FSM) system.

In a FSM, we can think of each task as a state the machine can be in. The FSM will have an initial state and after that each state will execute based on some conditional statement. The coin acceptor turnstile is usually used (like the hello world of state machines) to explain the concept of a state machine.

"Coin Acceptor Turnstile FSM". (Source Codeless Data Structures and Algorithms by Armstrong Subero).

We have a black dot which represents the initial state along with two states, locked and unlocked. The turnstile in a locked state will become unlocked once you insert a coin. Even if you push on the machine it will not unlock until you insert a coin. Once you insert a coin the machine enters into the unlocked state and will remain in that state as long as a coin a present.

If you push on the turnstile while in the unlocked state, that condition will cause the machine to transition into a locked state which it will remain in until a coin is entered again.

As simple as it seems, this method of modeling program tasks as states which transition based on conditions is a powerful method of embedded system firmware design. It is the method I use most often when designing my own systems.

Ventilators are Real Time Systems

Real Time Systems or RTS are systems which must meet strict requirements in terms of response times. In a real time system there is no room for compromise.

Such systems must guarantee that they will perform an action within a given time period. Failure to perform action within a certain time may lead to loss of life or serious damage to property.

This is the category of systems a ventilator falls into.

When a patient requires a ventilator, it is because they cannot breathe properly and need mechanical assistance to breathe required by a ventilator. A ventilator can perform Continuous Mandatory Ventilation (CMV) which means that the patient will be required to get a minimum number of breaths from the machine guaranteed.

Failure to provide the minimum number of breaths required will result in death of the patient. That means that the control electronics must be able to perform without failure.

To accomplish this most real time systems will utilize what is known as a real time operating system (RTOS) to ensure that the many tasks to be performed by the device can all be performed without fail.

RTOSs use a scheduler to manage tasks and limit how each task utilizes resources. The kernel would manage how each task can utilize the hardware resources based on their priority.

Think of the current makeshift ventilator designs that exist. The most promising ones are built using a bag-valve resuscitator that uses motors to actuate mechanical arms that press on the bag-value resuscitator and perform the ventilator functions.

However what will happen if the motor fails? Maybe we can add an infrared or ultrasonic sensor that will measure distance of the the mechanical arm from a certain point and ensure it reaches a particular distance. These sensors can also ensure that it returns to the starting point.

However the main microcontroller reading those sensors needs time to process the information. What if a sensor fails? Must the microcontroller lock up waiting for sensor data? Will a failure in sensor prevent the motor from being actuated on time?

To ensure each task takes place at a certain time, the scheduler will only allocate processing time to the task as designated by the system designer.

That way if a sensor fails, once the time allocated to reading that sensor has passed, the microcontroller will move on to the other task of actuating the motor which will keep the system running.

Using a Real Time Operating System in your design will guarantee that your device will be able to perform its function within the specified time.

Ventilators are Safety Critical Systems

In the previous section we discussed real time operating systems. I think we should expand our discussion a little and talk about hard real time vs soft real time systems.

In hard real time systems, the requirement of operation is that it MUST happen within the specified time at all costs, and failure to meet deadlines is not acceptable. Air traffic control systems and ventilator systems fall into this category.

Hard real time systems are not allowed to miss deadlines.

In soft real time systems, it is preferred that deadlines are met. But if deadlines are not always met it means that it may upset the end user but may be acceptable. Think of an online gaming platform. We would like to have real time response of our games, but if you miss a few frames it will not result in loss of life.

Soft real time systems are allowed to miss deadlines.

Now, a lot of people mistake a real time system with a safety critical system. Not all real time systems are safety critical systems. Think of the example above with online gaming or video conferencing – such systems require real time performance but they are not safety critical in nature.

What makes a safety critical system (SCS) different from a regular real time system is that failure to meet a deadline within a safety critical system will result in death or serious property loss.

In a safety critical system, stoppage of the system is NOT an option.

For example a high availability system real time system may be specified as having an up time of around 99% in a 24 hour period.

Think about a ventilator system.

Which 1% of the day is it acceptable to have the ventilator not operational? Since we have 1440 minutes in a day, which 14.4 minutes of the day should the patient not be allowed to breathe?

The Arduino Platform

At this stage in our discussion, I think it's best we talk about the Arduino platform for use in safety critical systems.

In our discussion of embedded systems, we talked about hardware and software, however did you know that there is also the development tools component of the design process?

You see, in order to put the software you have written into the microcontroller device running the hardware, you need to use development tools such as an IDE and toolchain to program the device.

Setting up and using a toolchain was a painful process depending on the device you were using. Many microcontroller vendors used to provide clunky IDEs that you had to be a seasoned embedded designer to use (though this has changed in recent years).

Additionally you also needed knowledge of the underlying hardware, and configuring registers and clocks can be daunting even for experienced designers.

Even if you overcame these hurdles on the software side, you needed to have a Printed Circuit Board (PCB) or have experience using a breadboard to get your microcontroller running.

It you did not know how to properly connect your hardware, even if your program was correct, the device would not run and troubleshooting the hardware also required some experience.

In order to address the problem, the Arduino platform was introduced as a way to provide synergy between hardware, software, and development tools to allow students control hardware with ease.

The Components of the Arduino Platform

The Arduino provides a physical board with the chip that is in a configuration known to work along with a simple IDE with tons of libraries. This seamless integration makes a less intimidating foray for beginners looking to get into the realm of hardware design.

The Problem with Using Arduino in Safety Critical Systems

There is one problem: since the Arduino is so easy to use, this has led many people to use the Arduino far beyond what the platform was originally intended for, including use in real time systems.

It's not recommended to use the Arduino for real time systems. Why? Some people may argue that you can use an operating system such as Amazon FreeRTOS on the Arduino and make it real time. That is true. But while the platform does become real time and it will make it highly reliable, it will not make it a safety critical one.

What makes the Arduino not suitable for use in safety critical systems? The answer lies in abstraction and its relation to the testing and debugging capability of the platform.

The Arduino is a good platform for learning, and as such it adds a lot of software abstraction to make things easy.

Abstraction in itself is not necessarily a bad thing. Abstraction allows for code reuse and can help eliminate bugs if used correctly. Properly tested code that abstracts away a lot of the hardware can be a powerful tool in the right hands.

However abstraction does NOT eliminate bugs and there is the problem. Even if code is abstract, if it had faulty logic to begin with then abstraction will not save you.

If you find a bug, usually you would rely on a debugger and software tests to help you figure out the source and improve the system reliability.

Therein lies the problem. The Arduino platform has no debugging capability.

Having no debugging makes bugs difficult to track. Having software that a bug free is crucial in a safety critical design. Additionally running tests on your code is not easy as the IDE is too simple for the powerful debugging and testing that is required for safety critical system design.

If you have no choice you can use the Arduino for design of a ventilator system. But the lack of debugging makes it difficult to do so and increases the likelihood of bugs in your firmware, and increases the risk of failure within the system.

How Can I Design a Good Makeshift System?

If you must design a ventilator system, there are two specific things you can do to improve your design based on the Arduino: You can improve the software design and improve the hardware design.

Improving Design on the Software Side

All hope is not lost. To make sure your system has reliable software consider doing the following:

1. Consider using Another IDE - Atmel Studio is a great IDE that provides the option for debugging if you use an external debugger such as the Atmel ICE or ICD 4 debugger. Additionally MPLAB X can be used. These IDE's will assist with debugging.
2. Adhere to a C/C++ coding standard - Using a code standard can improve your system reliability and make your system design more efficient. Consider rewriting the libraries you are using to adhere to MISRA, JSF++ or even the Barr Group's embedded C coding standard
3. Use an RTOS - Many of the ventilator designs based on the Arduino utilize the platform as is with a cyclic execution system in place. Consider using the Amazon FreeRTOS to make your system real time. This would avoid system lockup and make your system more reliable.
4. Consider using a Platform with Libraries that meet Safety Requirements – While not ideal for inexperienced designers, using a device that has libraries that already have existing safety requirements will help make your design more robust.
   For example even though our device is a makeshift medical device, using IEC 60730 requirements for Class B safety can help make your design more robust. Microchip Technology (company that makes the chip that powers the Arduino) has other devices that has libraries that meet Class B safety requirements and would aid in improving device safety.
5. Implement Sensor Data Analytic Redundancy - When designing your device consider using sensors to ensure the device is still operational and when you do, consider using analytic redundancy methods to aid with more accurate sensor data.
6. Consider using SAFERTOS - While it may require you to change systems SAFERTOS is pre-certified for use in medical systems and will provide a higher level of safety that the software of the Arduino platform.

Improving Design on the Hardware Side

To improve your design on the hardware side:

1. Consider using a Watch Dog Timer - If you don't have time to use an RTOS, a simple way to ensure your device keeps operating is to use a watchdog timer in your design. The watchdog timer ensures the device resets if a problem occurs in the execution of your code.
2. Use a Hardware Device with Pre-existing Safety Certifications and Libraries - Some devices are better suited for the task of a ventilator design. Rather than entrust a safety critical design to an Arduino, consider using a control device that can use software that is already certified for medical device use or provides safety libraries.
   The SAFERTOS supported platforms is a good place to start. The Microchip Technology web page on Class B safety software is also a good place to start.
3. Add Feedback Systems - It is not enough to have your device up and running. You also need feedback systems to ensure devices are operating as they should. Integrate sensors to provide feedback on mechanical parts that are subject to failure.
4. Consider Distributed Hardware Control- Though many persons base their designs on a single chip consider using multiple microcontrollers in your design. Consider having one device for control and another for notifying the end user if a component is failing.
5. Implement System Redundancy - Having a proper shutdown system with a proper transfer system is crucial for such designs. Implement a proper shutdown procedure in case the system fails as well as have a proper switch over mechanism to ensure you have a 100% up time on your system.

Wrapping Up

In this post we looked at embedded systems, briefly talked about their hardware and software components, and touched on firmware design paradigms. We also talked about real time systems and safety critical systems as it relates to ventilator design.

Finally, we talked about how to improve the safety and reliably of your Arduino-based ventilator designs by improving the hardware and software design.

By the end of this post you should have some understanding of how to enhance your makeshift Arduino ventilator system.

If you wish to learn more about microcontrollers, pick up my book "Programming PIC Microcontrollers with XC8" where you will learn about the PIC microcontroller and how to program it. This microcontroller can also be used to design your ventilators and will give you a greater degree of control and debugging capability than the Arduino platform.

Read the book here:

https://www.apress.com/gp/book/9781484232729

IoT is all about connecting devices, or “things” as you may call them, to the internet and then analyzing data collected from these devices in order to extract an added value. In this article you’ll discover how to benefit from Firebase when working on an IoT project and how it can help you develop IoT prototypes much faster and easier than traditional methods. You will also develop your own IoT project and host it in Firebase.

Before Firebase Realtime Database

Most of my IoT projects require some way of communication between the different endpoints. These endpoints can be anything from devices and services to applications, and eventually data needs to be stored somewhere for further processing and analyzing.

So let’s say you want to build an IoT system where a device will measure temperature and humidity values from sensors and send them to a database service to store them. Then you want to have a web application that will fetch these values and display them in a dashboard. Quite simple, right…?

The easy and lightweight way to go about this is to setup an MQTT broker that will act as a hub and reroute all incoming messages published from the device to all subscribed clients like the web application in this case.

Now the question here is how can the web application display the data? Meaning will it be displaying messages coming from the broker directly or will it be fetching data from a database service?

Let’s say that you want the app to do both things: display data coming from the broker in realtime and fetch data from the database. In this case you can think of 2 ways (actually there are many different ways) to achieve this:

First solution:

Using this architecture the device will first publish its data to the broker then it will send an HTTP request to the database web-service to save the data. For this solution the device needs to implement 2 clients: an MQTT and an HTTP client.

Second solution:

The other way to go about this is that the device will send or publish its data to the broker, then the broker (as expected) will reroute this message to all connected subscribers like the web app. But this time there’s another subscriber connected which represents an API Engine that will accept this data and send it to the database web-service to be stored.

As you may have noticed in this solution, the HTTP client is decoupled from the device and implemented as a backend service. This way you make the device program much lighter. This is an important thing to keep in mind when developing on constrained IoT devices where resources like CPU and memory are limited.

Still, this solution required some additional work in developing the back-end service that will act as a persistence layer.

So is there much easier way of doing this?

Firebase to the rescue

As you may have seen above, things can get quite complex quite easily. For someone like me who wants to get up and running quickly when working on a prototype, that can take some extra time. That’s why, in this part of the article, you’ll see how Firebase can make your life easier and save you a lot of time when developing an IoT prototype.

Firebase offers many cloud services that ranges from authentication, storage, and cloud functions to hosting your web application. In this article you’ll use 2 services: Realtime Database and Hosting.

Let’s start with Firebase Realtime Database. The first thing that comes to mind when reading this service name is: okay so I know what a database is but what does it mean to be realtime here?

Well according to Wikipedia:

A real-time database is a database system which uses real-time processing to handle workloads whose state is constantly changing. This differs from traditional databases containing persistent data, mostly unaffected by time

In the case of Firebase Realtime Database, clients will be connected to the database and will maintain an open bidirectional connection via websockets. Then if any client pushes data to the database it will be triggered and (in this case) inform all connected clients that it has been changed by sending them the newly saved data.

This way of working may remind you of the MQTT broker and how it reacts when it receives a message from a publisher and sends it to all subscribers. The difference this time is the addition of the data persistent part, which is the database. So as you can see here, you don’t need to route messages yourself using other protocols — Firebase Realtime Database will take care of that plus performing its normal database function. Amazing isn’t it?

Returning to the IoT system mentioned earlier, you can now connect the device to the Firebase Realtime Database and make it push data periodically to the database. On the other part of the system you have a web application which will be connected to the same service as the device and will receive new data whenever there is a change in the database.

But what about hosting the web application?

Firebase offers a hosting service that you can use to host your app rather than managing your own web server and dealing with deployment and networking configurations. The good thing is that it is free (yet limited) and pretty easy to use.

Now for the part you all have been waiting for. In this demo you’ll use the example discussed throughout this article and bring it to life.

If you remember, the IoT system is made of 2 endpoints: the first one is the IoT device which is responsible for sending temperature and humidity data to the Firebase Realtime Database. This in turn will communicate with the second endpoint — the web application — that will read the data and display it on a nice dashboard.

I’ll break this project into 3 steps so it becomes easier to follow.

1. Setting up Firebase Realtime Database

There is nothing special about this step. You just need to go to your firebase console and create a new project. After your project is ready, go to the database section and make sure to create a Realtime Database not a cloud Firestore Database. Select start in test mode and proceed as you’ll be using this database only for testing and prototyping and not for production solutions (so you can ignore the red warning). Now the database should be ready for use.

2. Developing the IoT device application

When talking about embedded systems development, you often hear terms like low level programming, assembly, registers, memory management and so on. These terms and concepts are related to the hardware specifics you’re working with and can change from one to another.

That’s why, when prototyping ideas, you don’t have time to dig deep into these specifics and study them in details because you’ll be dealing at the same time with other high level languages and thus other ways of thinking about code. So instead you should have a clear overall idea about the architecture and characteristics of the device and how to use them.

Luckily for you there is a platform that was made specially for prototyping and abstracting all the low level functionalities of hardware. Yes I’m talking about the famous Arduino.

Arduino - Home
_Open-source electronic prototyping platform enabling users to create interactive electronic objects._www.arduino.cc

Note here that when I’m talking about Arduino, I’m referring to the Arduino Framework with its IDE, compilers, and libraries — not the board.

So you will be using Arduino to program the board, but what board you ask? Well, you need a board that is able to interface with sensors and measure physical values like temperature. It should also be able to connect to the internet in order to send this data to the database. Finally, it should be able to be programmed using the Arduino framework.

There are a variety of boards on the market that can achieve these tasks. Some of them are Arduino boards and others are Arduino-compatible boards.

In this demo you will use the famous NodeMCU, an Arduino compatible board. It’s based on the ESP8266 SoC, a chipset produced by the Shanghai-based Chinese manufacturer, Espressif Systems. This board is attractive for developers, as single units can be bought for as little as $3.

Our Gear

Although the Arduino platform offers an IDE for programming and uploading code to boards, it’s not very friendly to developers as it does not provide any intelliSense features or debugging functionalities. That’s why, for most my IoT projects, I use an environment called PlatformIO.

PlatformIO: An open source ecosystem for IoT development
_Cross-platform build system and library manager. Cross-platform IDE and unified debugger. Remote unit testing and…_platformio.org

It’s an open source ecosystem for IoT development, and guess what? It supports the Arduino Framework. So you can use it to write Arduino code, compile it, and upload it to the board. Finally the cool thing about PlatformIO is that it comes as an extension that you can use inside Atom or VScode so you can use it alongside the other functionalities of your IDE (Atom or VScode). I highly recommend watching these 2 YouTube video tutorials to setup and get familiar with the environment.

Enough talk — let’s get started:

Developing Firmware for NodeMCU

kaizoku-619/firebase_nodemcu
_Arduino Firebase Nodemcu client developed sending DHT11 data to Firebase Realtime Database …_github.com

Before diving into developing the firmware, let’s talk about the electronics setup.

If you remember from the example earlier, the IoT device will measure temperature and humidity values from a sensor and send them to the cloud. In this case that means the NodeMCU will read temperature and humidity values from DHT11 sensor module and send them to Firebase. The DHT11 module will be used here because it’s cheap and doesn’t require any additional electronic components to function.

Wiring Diagram

As you can see from the wiring diagram above, DHT11 is connected to the board with 3 wires GND, 3.3V and Data signal in the middle. Connect the data pin to one of the Dx pins on the board and you’re done with wiring.

Now that the wiring is done you can start coding the firmware using PlatformIO.

We’re not writing Go but I like the GIF

But before you dig into writing code directly, let’s stop for a moment and think about what the program should do.

So the first thing the device needs to do is to connect to the internet. To do that it needs to connect to the WiFi access point. Once online, it needs to open a connection with Firebase. After that the device will read temperature and humidity values from the sensor and finally publish the data.

Here is an ordered list of tasks:

(Note that the world task is used here to refer to a functionality of a bloc of code and not a task in realtime OS like FreeRTOS tasks.)

1. Connect to WiFi
2. Open connection with Firebase
3. Read sensor values
3. Publish values to Firebase

Let’s start with the first task:

• Connect to WiFi:

This function begins with printing the SSID (AP name) and setting the NodeMCU into station mode rather than AP mode. Then it keeps loading until it connects to the AP. SSID and PASSWORD are 2 constants defined in another file as you’ll see later.

• Open connection with Firebase:

This function is very straightforward: it takes 2 parameters FIREBASE_HOST and FIREBASE_AUTH. These are also 2 constants defined in another file.

• Read sensor values:

You start by defining 2 constants for the DHT sensor type and pin. After that you create a DHT object by passing these 2 constants to the DHT constructor. Finally you use the object methods readHumidity() and readTemperature() to read humidity and temperature respectively.

• Publish values to Firebase:

Here, the pushInt() method of Firebase class is used to push an integer to Firebase and in case of an error, print it.

And now you’re done with the tasks! All that’s left is to put these tasks together in a clean arduino sketch.

Start by creating a new project in PlatformIO as shown here:

Next you need to install the libraries needed for the project. Note that in this case you will install the libraries locally, meaning they’re only available for this project. This is a best practice if you decided one day to use another version of the library in another project.

Go to the PlatformIO home page → Libraries and search for firebase. FirebaseArduino will show up, so click on it. But don’t click install button, instead click on the … next to install and choose the project to install the library into. Then finally click install. Repeat this process for the DHT library.

Copy this code in the main.cpp file:

Remember the file containing the credentials for the WiFi and Firebase? Go to the include folder and create a new file Creds.h and copy this code to it. Don’t forget to change the code according to your credentials.

And there you go! Upload the firmware to NodeMCU and your device should be able to send data to Firebase Realtime Database.

3. Developing and hosting the web application

kaizoku-619/firebase_iot_web
_Firebase web application client connected to Firebase Realtime database fetching sensor values …_github.com

Now that the IoT device is ready and pushing data to the Realtime Database, you can move to the other endpoint in the system, the web application. It will receive data from Firebase and display it on a dashboard.

You will start by developing the app locally and eventually deploying it.

Start by setting up the project.

Installing Firebase CLI:

The Firebase CLI (command line interface) requires Node.js and npm (the Node Package Manager). Once they are installed you proceed to install the Firebase CLI using npm by running:

npm install -g firebase-tools

You can follow the video to complete the project setup.

Once project setup is done your directory should look something like this:

├── database.rules.json├── firebase.json└── public   ├── 404.html   └── index.html

Start by building the dashboard UI. This will be the index.html file. Open the file and change it to look like this:

This is a simple HTML page designed using Bootstrap Material Design. It consists of 2 Card elements, one for displaying Humidity and the other for displaying Temperature.

As for the Firebase part here, first you import the firebase dependency in the script tag inside the head tag. Finally when the page finishes loading, it calls app.js.

Now that the Dashboard UI is ready you can move on to app.js where you implement the firebase connection and your business logic. In the same directory create a new file called app.js and copy this code:

The script starts by creating a configuration object. The best way is to copy it directly from the firebase project in the firebase console. To do that, navigate to your firebase console and go to the firebase project settings. Then scroll down and click on the <;/> icon as shown here:

I guess the rest of the code is self explanatory with the comments.

Now your app should be ready and you can test it locally with the following command:

firebase serve

Note that on startup the app will fetch the last temperature and humidity values from the database. Great! The app is working locally, but up until now it’s working only inside your localhost and can’t be accessed from the outside world. This means that it’s time to host it on the web using Firebase Hosting.

But before you deploy it there is just one last thing you need to do. Go to the database.rules.json file and change the read and write rules to “true”. This method is not advised for production, as it is not secure, but it’s fine for demonstration purposes here.

With that done you are ready for deployment:

firebase deploy

There you go! If you’ve made it this far, by now you should have a live web application deployed and up and running.

Putting it all together

It’s time to put everything together and test the system. Plug in the NodeMCU to your PC and upload the sketch if you haven’t already:

Open up the web app and the firebase database and watch it change in realtime with the values sent by the device.

Now open up the serial monitor and watch the data pushed from the device to the web app. Note that you can open the console in the browser to watch the received values. Here I use Gtk Serial port terminal with a baud-rate of 115200 bps, but you can use the integrated PlatformIO Serial Monitor or any other tool of your choice.

Troubleshooting

I faced a problem while developing the application on the ESP8266 (and it took me sometime to figure out). Even when everything was configured correctly (WiFi Connection, Firebase Host, Secret Key), the ESP8266 couldn’t connect to Firebase. This was caused by the wrong Fingerprint inside FirebaseHttpClient.h file in the Firebase library. You need to replace it with your own fingerprint. If you installed the library locally using PlatformIO then you can find the file in this path:

your_project_folder/.piolibdeps/FirebaseArduino_ID1259/src/

To generate a fingerprint, go to this website and copy your Firebase host link without the https part and click on Fingerprint Site (mine is:
medium-iot-project.firebaseio.com):

GRC | SSL TLS HTTPS Web Server Certificate Fingerprints
_GRC's HTTPS Web Server Certificate Fingerprint Service_www.grc.com

This will generate a fingerprint for your site, so go ahead and copy it in place of the old kFirebaseFingerprint[] value inside the FirebaseHttpClient.h file. That should fix the problem.

Conclusion

Congratulations if you’ve made it this far!

We’ve only scratched the surface here. The Internet of Things is all about experimenting and exploring, so I encourage you to not stop here and keep learning by making mistakes and finding bugs in your code. But above all don’t forget to have fun along your learning journey.

References

Firebase Realtime Database | Firebase Realtime Database | Firebase
_Store and sync data with our NoSQL cloud database. Data is synced across all clients in realtime, and remains available…_firebase.google.comPlatformIO: An open source ecosystem for IoT development
_Cross-platform build system and library manager. Cross-platform IDE and unified debugger. Remote unit testing and…_platformio.orgArduino - Home
_Open-source electronic prototyping platform enabling users to create interactive electronic objects._www.arduino.ccBootstrap Material Design
_The most popular HTML, CSS, and JS Material Design library in the world._fezvrasta.github.ioesp8266/Arduino
_ESP8266 core for Arduino. Contribute to esp8266/Arduino development by creating an account on GitHub._github.comFirebaseExtended/firebase-arduino
_Arduino samples for Firebase. Contribute to FirebaseExtended/firebase-arduino development by creating an account on…_github.comGRC | SSL TLS HTTPS Web Server Certificate Fingerprints
_GRC's HTTPS Web Server Certificate Fingerprint Service_www.grc.com

I am a big fan of science toys. I have been looking for one that combines the elegance of math and programming for a while. However, there was not much success in the search. So, I decided to make one myself.

Here is a demo. The flashing LEDs are used to illustrate a mathematical identity visually.

Math

The mathematical identity is the following. The left side of the equation is an arithmetic sum from 1 to n-1 and the right side of the equation is “n choose 2”, the number of unique ways to choose 2 items from n items.

Mathematical identity

It is not the identity itself that is elegant, but the visual proof itself. Let’s look at the diagram below. There are n=4 green dots in the illustration.

LED illustration

For every two green dots on the bottom row, there is always a unique red dot in the triangle above that corresponds to them. That red dot is the tip of an equilateral triangle with the base specified by the green dots.

Therefore, the number of ways to choose 2 green dots out of n green dots is equal to the sum of the red dots, 1 +2 + 3 + … + (n-1).

In this case, it is 1 + 2 + (4 –1) = 6.

This observation was originally made by Loren C. Larson in this article.

Programming

While it is easy to trace the red dot from the green dots visually, it is more fun and challenging to specify the relationship in code.

Let us assume that we know the indices of the green dots (say, i and j). The programming challenge is to specify the corresponding index of the red dot that forms the equilateral triangle with the green dots.

It looks difficult at first glance.

But the problem can be simplified a lot when we tweak the way that we label the red dots. We can label the red dots from bottom-up instead of top-down.

With that indexing scheme, we can then specify the index of the red dots by the following formula.

An illustration of how to index the red dots using the indices of the green dots.

Here is the complete code used to flash the LEDs using Arduino.

Electronics

I solder the LEDs on a board and connect the LEDs to Arduino output pins through 1k resistors. It is very important to use the resistors because they protect the LEDs.

The connection is as follows.

Schematics

And when you put them together and load the software to Arduino, it will start flashing like below.

Final result

Hope you enjoy this gadget!

Last year, I created Crypto Price Tracker (an app which was acquired by Redwood City Ventures this year). A back end member of my team had been using an Arduino setup to check web server response statuses continuously to get updates all the time. I found that setup to be pretty useful and interesting.

I researched about it and recreated the setup for myself. In this article, I’ll show you how you can build it yourself, too.

Things that you need:

1. Arduino Uno
2. Ethernet Shield for Arduino (to connect the Arduino to the Internet)
3. Ethernet Cable
4. A/B Type USB 2.0 Cable (Power cable for Arduino)
5. Male-to-Male Jumper Cables (x2)
6. Breadboard
7. LED (x1, any color)
8. Resistor (x1, >100 ohms works)

Setting It Up

1. Mount/Insert the Ethernet shield on the Arduino.
2. Insert the positive (longer) end of the LED into the breadboard slot 6a and the negative (shorter) end into slot 5a.
3. Insert one end of the resistor into the breadboard slot 1b and the other into slot 5b.
4. Insert one end of the first jumper cable into the breadboard slot 1e. Insert the other end into the GND slot of the Ethernet shield.
5. Insert one end of the second jumper cable into the breadboard slot 6e. Insert the other end into pin slot 2 of the Ethernet shield.
6. Connect the Ethernet cable from your router to your Ethernet shield.

This is what my setup looks like:

7. Open a command line interface on your machine and check and note your default gateway. This can be done using ipconfig command on Windows or the netstat -nr | grep default command on Linux/Mac.

8. Download and install the Arduino IDE if you haven’t already.

9. Open the IDE and go to Files -&gt; Examples -> Ethernet -> WebClientRepeating. You should see the following code:

10. Edit the line 37 to be an IP address in the range (1–254) of your default gateway IP. So for example, if my default gateway is 10.0.0.1, then I can use an IP address from 10.0.0.2 to 10.0.0.254. It is, however, important to make sure that the IP that you’re using doesn’t conflict with any other IP addresses on your network.

For this example, I changed the line of code to be:

**IPAddress ip(10, 0, 0, 2);**

11. Change the DNS in line 40 to be 8.8.8.8 (this is the Google Public DNS and is just something I prefer, you may use a DNS that you prefer).

For this example, I changed the line of code to be:

**IPAddress myDns(8, 8, 8, 8);**

12. Change the URL in line 45 to a URL matching your web server. If you would like to use an IP address instead, then comment line 45 and uncomment line 46. Since I am using a web server that I’m hosting locally, for this example, I will use an IP address.

For this example, I changed the line of code to be:

//char server[] = “[www.arduino.cc](http://www.arduino.cc)";
IPAddress server(127,0,0,1);

Note that the port or the path here is not important yet. Just the IP Address
is needed. If you would like to change the port that is used for the GET
request, you may change it on line 94.

For this example, I have hosted my local webserver on port 3000. Thus, I will change the code in line 94 to something like this:

if (client.connect(server, 3000)) {

13. Edit the GET request that is pre-written in lines 97 - 100 to follow this pattern:

client.println(“GET /path_to_url HTTP/1.1”);
client.println(“Host: 127.0.0.1”);
client.println(“Connection: close”);
client.println();

14. We can now start programming the behaviour of the LED depending on the web server status and response. To do this, we must first declare the pin we’re using for the LED on our Ethernet shield.

Add the following line of code after the first two include statements of the program:

int LED = 2;

15. Add the following lines of code at the beginning of the setup() function.

pinMode(LED, OUTPUT);

digitalWrite(LED, LOW); //program starts with the LED turned off

16. Add the following line of code after the GET request line that we previously edited:

digitalWrite(LED, LOW);

17. Finally, add this line of code at the beginning of the else statement of the same conditional:

digitalWrite(LED, HIGH);

And voilà, you’re done!

Upload the program to your Arduino. Open the serial monitor from the top right part of the IDE and watch the response. If your server doesn’t respond, the LED glows, if it does, the LED stays off :)

You can check out my final code here.

Checking Response

If you would also like to validate the response that you receive from your
web server, then you may add them inside the following conditional of the
program.

if (client.available()) {
char c = client.read();
Serial.write(c);
}

The variable c is where the response is stored.
You could check it like this:

if (client.available()) {

char c = client.read();
if(c == “arduino is great”){
digitalWrite(LED, LOW); //correct response
}
else{
digitalWrite(LED, HIGH); //wrong response
}
Serial.write(c);
}

Do note that, if you’re trying to do this, then it’s best to get rid of the
digitalWrite statement after the GET request. Depending on your response,
you may also have to parse JSON values. There are several ways to do this
and plenty of tutorials/articles around for it too! Make sure to check them
out!

Have fun! Feel free to email me at harshita (at) harshitaapps.com for any questions, feedback, or ideas!

Make sure to check out Crypto Price Tracker app if you’re interested/invested in cryptocurrencies! :)

The Internet of Things (IoT) is changing the way we live, from wearable tech to smart home devices. IoT may sound complex, but in actuality it’s a fairly simple concept to understand. Everyday objects are constantly being transformed into smart devices using sensors and actuators.

In this article, we will build a realtime Arduino ambient light monitor which sends its sensor readings to a web application. We will cover the basics of connecting an Arduino board to the web and sending data as realtime notifications to a web app using Pusher.

This article will act as an introduction to what can be achieved with Arduino and Pusher. It is for those curious about the hardware industry who want to delve into the fun IoT world.

Requirements for building our Arduino and Pusher integration

In this process, I used:
— An Arduino board. MKR1000 board.
— The Arduino IDE.
— Photocell (available here).
— 10k Ohm resistor (available here).
— Breadboard and Jumper Wires.
— A Pusher application — Create one here.
— Composer (available for download at https://getcomposer.org)..)
— Knowledge of PHP.

A breadboard is a board for temporarily prototyping hardware projects. It has nodes that conduct current throughout it.

The jumper wires are used for ensuring continuity between various points on the breadboard that aren’t connected by default.

Getting Started with Arduino

In this section, will set up the Arduino IDE and add internet connectivity to our board. We will find out about choosing the right board and adding internet connectivity to it.

Many of the boards don’t come with internet connectivity, which is something you need to make IoT devices. To add internet connectivity to our board, we have a variety of options to choose from: a shield, micro-chip, or an Arduino board with built-in wireless capabilities.

Note: a shield is basically an extension board that can be placed (mounted) on top of the Arduino board.

There are many types of shields:

1. Ethernet Shield.

_[Ethernet shield](https://www.digikey.com/en/articles/techzone/2012/jan/networking-options-for-arduino-based-systems" rel="noopener" target="blank" title=")

2. WiFi Shield.

_[WiFi shield](https://store.arduino.cc/usa/arduino-wifi-shield" rel="noopener" target="blank" title=")

3. 3G or LTE Shields.

_[Arduino GSM Shield](https://store.arduino.cc/usa/arduino-gsm-shield" rel="noopener" target="blank" title=")

We are going to use the Arduino MKR1000 which comes with an in-built WiFi Chip. This board is available at the Arduino Store.

_[Arduino MKR1000 WIFI](https://store.arduino.cc/usa/arduino-mkr1000" rel="noopener" target="blank" title=")

Next, download the Arduino IDE from here and install it on your computer.

Once the installation is finished, go ahead to install the Board Definition by launching the IDE. Then go to Tools > Boards > Board Manager where we search for and install the definitions for the MKR1000.

Board Manager

Once the Board Definition is completely installed, go to Tools | Boards and select the newly installed board definition.

To connect our Arduino Board to the internet, we have to install a library called wifi101. In order to install the library, go to Sketch &gt; Include Library > Manage Libraries, then search for and install wifi101.

Install WiFi101 library

We can test that it works by going to Files > Examples > WiFi > ConnectWithWpa. This should generate some code in our sketch. Next, edit the ssid and pass to our router’s SSID and Password:

char ssid[] = "yourNetwork";     //  your network SSID (name)    char pass[] = "secretPassword";  // your network password    int status = WL_IDLE_STATUS;     // the Wifi radio's status

Building the Light Monitor in Arduino

In this section, we are going to see how to set up the circuit and measure data coming from the sensors on the MKR1000 board. In addition to the Arduino MKR1000 and the usual breadboard and jumper wires, we are going to need a few extra components.

• Photocell
• 10k Ohm resistor

The photocell is a sensor that allows us to detect light. They are often regarded as Light-Dependent Resistors (LDR), Photoresistors, or CdS cells.

A Photocell is basically a resistor that changes its resistive value (in ohms) depending on how much light is shining onto the squiggly face.

Assembling the components

First, place the resistor in series with the photocell on the breadboard, next to the Arduino board.

Now, connect the other end of the resistor to GND on the Arduino board, and the other end of the photocell to the VCC pin of the Arduino board.

Finally, connect the middle pin between the resistor and the photocell to analog pin A0 of the Arduino board. The final result should look like this:

Once this is done, we can go ahead and configure the board to read data coming from the photocell. We will take the readings from analog pin A0 and print them on the serial port for now. The sketch for this part is really easy and should look like this:

We will copy and paste this sketch into our Arduino IDE, then upload it to the board.

Make sure the right board and serial ports are selected.

// Pins    int sensorPin = A0;    void setup() {      // Serial      Serial.begin(115200);    }

    void loop() {      // Reading      int sensorValue = analogRead(sensorPin);      // Display      Serial.print("Sensor reading: ");      Serial.println(sensorValue);      // Wait      delay(500);    }

You can save the Arduino sketch files to your machine, so you can reference them later. They can be named whatever you like as long as they are uploaded to the Arduino board.

After this is run, we open the serial monitor and immediately observe the readings from the sensor:

If we put our hands over the sensor, we will see a decrease in the values measured by it. Now let’s focus on creating the web application.

Setting up the web application

In this section, we are going to create a basic web application that collects the data as a GET request and displays it to the users subscribed to that channel in realtime. For realtime display we’ll be using Pusher.

Pusher is a simple hosted API for quickly, easily, and securely integrating realtime bi-directional functionality via WebSockets to web and mobile apps, or any other Internet-connected device.

The first step will be to create a free Pusher account. If you don’t have one, then create your application on the dashboard.

Creating a Pusher application

Create a Pusher account and go to Your apps > Create new app. Fill in your application name, select a cluster, choose JavaScript and PHP, and then we are good to go.

The application set up screen should look something like this:

Once done, you will be provided with your App keys.

Setting up our project

We’ll create a folder called arduino-light-monitor in our localhost root directory.

Then, open your terminal and type composer require pusher/pusher-php-server. This will generate a couple of files in our directory.

Create a file called notification.html. Then add the HTML and JavaScript below:

<!DOCTYPE html>    <html>    <head>      <title>Notifications From Light monitor</title>      <script src="https://js.pusher.com/4.1/pusher.min.js"></script>      <script>        //Enable Pusher Logging - don't include this in production        Pusher.logToConsole = true;

        //Create a new instance of pusher with your credentials        var pusher = new Pusher('APP_KEY', {            cluster: 'PUSHER_CLUSTER',//if you chose a different cluster replace it here            encrypted: true          });

        //subscribe to a channel you will listen on        var channel = pusher.subscribe('light-monitor-channel');

        //What happens when light-readings-sent is fired        channel.bind('light-readings-sent', function(data){          //gets the ul in the dom          var ul = document.querySelector('ul');          //creates a li          var li = document.createElement('li');          //Attaches the data received to the text node          var itemText = document.createTextNode(data.value);          //Append the data to the li          li.appendChild(itemText);          //Append the li to the ul          ul.appendChild(li);        });      </script>    </head>    <body>      <ul></ul>    </body>    </html>

What happens here is we subscribe to a channel called light-monitor-channel then wait until we receive an event called light-readings-sent. Whenever the event is triggered, we append the data received to our list.

We will also create another file called index.php. This is the file that will send the events to the notifications channel. We will add the PHP code below to the file:

<?php      require __DIR__ . '/vendor/autoload.php';

      $options = array(        'cluster' => 'PUSHER_APP_CLUSTER',        'encrypted' => true      );      $pusher = new Pusher\Pusher(        'PUSHER_APP_KEY',// replace with yours        'PUSHER_APP_SECRET',//replace with yours        'PUSHER_APP_ID', //replace with yours        $options      );

      //checks if there is any data sent      if(isset($_GET['value'])){        $data['value'] = $_GET['value'];        //triggers the event on the channel        $pusher->trigger('light-monitor-channel', 'light-readings-sent', $data);      } else {        echo "Nothing to do";      }    ?>

If you need somewhere to host your content, you can go to 000webhost.com and create a free subdomain where you can upload the contents of your arduino-light folder.

We will test it out by opening notification.html and index.php in two different browsers. When we reload index.php, we should get a new list item added with a value of “Empty request”. If we try index.php?value=123, we should get value 123 added to our notifications list in realtime.

Isn’t that just awesome?

Sending the sensor readings to the web app

Finally, we will look at how to send the data from the Arduino board to the server.

Continuing from the sketch we had before, we just replace this by taking note of the important parts:

// Pins    int sensorPin = A0;

    char ssid[] = "wifi_name"; //your wifi name    char pass[] = "wifi_pass"; // your wifi password    int status = WL_IDLE_STATUS;

    char server[] = "yourexampleserver.com"; //replace with your localhost or domain

    // Create an instance of WiFiClient    WiFiClient client;

    // We define the interval on which we want to send the data    unsigned long lastConnectionTime = 0;    const unsigned long postingInterval = 60L * 1000L; //this implies 60,000L the L represents the long datatype

    void setup() {      // Serial      Serial.begin(115200);

      // Attempt to connect to Wifi network:      while ( status != WL_CONNECTED) {

        Serial.print("Attempting to connect to WPA SSID: ");        Serial.println(ssid);

        // Connect to WPA/WPA2 network:        status = WiFi.begin(ssid, pass);

        // Wait 10 seconds for connection:        delay(10000);      }

      // you're connected now      Serial.print("You're connected to the network");    }

    void loop() {      if(millis() - lastConnectionTime > postingInterval) {        //Measure the light level        int sensorValue = analogRead(sensorPin);

        //Send the value to the server        sendHTTPRequest(sensorValue);      }    }

    void sendHTTPRequest(int sensorValue){      // Close existing connection      client.stop();

      // Connect & send request      if (client.connect(server, 80)) {

        Serial.println("connecting...");

        // Send the HTTP GET request:        client.println("GET /light/?value=" + String(sensorValue) + " HTTP/1.1");        client.println("Host: yourexampleserver.com");        client.println("User-Agent: ArduinoWiFi/1.1");        client.println("Connection: close");        client.println();

        // Note the time that the connection was made:        lastConnectionTime = millis();      }      else {        // if you couldn't make a connection:        Serial.println("connection failed");      }    }

In the code above, we create a connection to the specified WiFi ssid using an instance of WiFiClient. We will use this connection to interact with our remote server.

In the setup``() function, we deal with the initialization of the Serial and connection to the WiFi network specified by the ssid and pass variables above.

In the loop``() function we check if we are in the posting interval. Then, if we are, we take the reading and make a call to the sendHTTPRequest function defined below it.

In the sendHTTPRequest``() function, we accept a parameter called sensorValue. Because Arduino runs the code in a loop, the first thing to do is to stop any previous opening of the client connection with the statement client.stop(). This will stop connections from being created and will keep them from being discarded after they have been used.

Next, we try to connect to the server defined in the variable server[]. We check if the connection can be established, and if not we print to the Serial “connection failed”. Once the client is connected, we send the sensor pin value through the URL to our web application.

If we test this out now, we will have the light sensor reading every minute.

Conclusion

We have successfully built a light monitor using Arduino and Pusher. If you enjoyed this tutorial and would like to go from zero to hero in the IoT world, you should check out the book “Internet of Things with Arduino Cookbook” by Marco Schwartz. It contains over 60 recipes which will help you build smart IoT solutions and will surprise you with captivating IoT projects you thought only existed in James Bond movies.

If you have any questions or other ideas on integrating IoT with Pusher, please leave a comment below!

This was originally published on our blog.

Last Sunday, while I was explaining the basics of electronics and Arduino to my roommate, she challenged me to understand how a voltmeter works and build one from scratch just using the stuff I own already. I accepted the challenge, started hacking, coding, testing, re-coding, and re-testing, and finally I had my voltmeter ready and working by dinner time!

I used Arduino Uno (to collect voltage in analog and to power the LCD), a small LCD screen that I got in my Arduino starter kit (to display the voltage), a breadboard (to connect everything), and jumper wires.

If you’re looking for an easy project to learn electronics, then making a digital voltmeter will be fun. Let’s get started!

The Electric Circuit

Step 1

Take a breadboard (I used a small one with 30 rows) and connect an LCD screen to it. Then using a wire, connect one wire from the GND pin (ground state) on the Arduino to the negative charge on breadboard, and one wire from the 5V pin to the positive charge. This provides electric current to the columns on the breadboard, which we can now connect to the LCD.

This is the basic setup after Step 1.

Step 2

Now we’ll connect the pins on the LCD to the breadboard so we can get current to it. Connect Pin 1 of the LCD to a negative charge, Pin 2 to a positive charge, Pin 3 to a negative charge, Pin 5 to a negative charge, Pin 15 to a positive charge, and Pin 16 to a negative charge. Plug in your Arduino to test and see if the LCD turns on!

The LCD lights up!

Step 3

Let’s connect the LCD to the Arduino so that we can display the voltage (which we will collect from an analog pin) on the LCD. Connect Pins 4, 6, 11, 12, 13, and 14 of the LCD to any digital pin on Arduino (for example, Pin 2). Then put a wire in the GND and another in an analog pin, like A5. The two wires are now your probe leads.

Finished electric circuit!

We’re now done with the electronics/hardware. Let’s move on to the code.

The Code

The code is pretty simple. We just want to collect the analog signal that the Arduino receives at Pin A5 (or any other analog pin) and convert it to digital. We then want to display the results on the LCD screen.

This is the code that you can copy-paste.

#include <LiquidCrystal.h> int Vpin=A5;float voltage;float volts;LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup() {Serial.begin(9600);lcd.begin(16,2);}

void loop() {

voltage = analogRead(Vpin); volts = voltage/1023*5.0; Serial.println(volts);lcd.print(“voltage = “);lcd.print(volts);delay(200);lcd.clear();}

What’s going on here?

So we’re first importing the LCD library, then creating a variable named Vpin (which will be the voltage collected from A5). Next, we create two more variables for the voltage, and then a variable of type LiquidCrystal. Finally, we do setup with the Serial monitor (which is a really useful tool in Arduino! Sort of like debug console), convert the analog voltage to digital voltage, and print (display) that value to the LCD screen.

And that’s it! Go and test out various batteries and points! Here are photos from some tests I did:

Neutral wires.

Testing a 1.5V AA battery.

Also, if you want to make the reading on the LCD more legible, put a 1k ohm resistor in the path to Pin 3 (which is for contrast adjustments). By limiting the electric current flowing to that pin, you’ll improve the contrast of the screen.

Also important note: In this voltmeter, whatever voltage you test will go as a direct input to the Arduino, so you should only test stuff that is in the range of volts that Arduino can safely handle (0–5V). Testing with a 9V battery will fry your Arduino.

Thanks to this video tutorial for helping me figure out the electric circuit. Special thanks to my friends Nick Arner and Johnny Wang for helping me fix stuff. And thanks to Laura Deming for the challenge! :)

More articles and tutorials on electronics/hardware and brain-computer interfaces on the way! :D

If you have feedback to share, feel free to email me at harshita@harshitaapps.com. I look forward to hearing from you!

Hi, I’m 16 years old and during the holidays I like to work on little projects. I grew up in a very artistic environment - my father is a painter my brothers and sisters draw, play music, compose … And me, with my best friend we wanted to have fun with our new Arduino and Unity3D, so we started working on interactive artistic experiences. But we got stuck on one big thing. If you’ve ever wanted to transmit data from Arduino to Unity3D, you know the main issue is INSANE LATENCY.

Don’t worry about Latency, wrmhl is here ⚡️

Without wrmhl (using a simple ReadLine () )

We didn't find any free, optimized, and customizable solutions to tackle this problem. So I built wmrhl. You can now connect any Arduino interface to Unity3D, and it’s completly Open Source.

• Just write your Arduino code, how about A Touchless 3D Tracking Interface or a Brain-Computer Arduino Interface ?
• Add a Serial print to send data from your interface to Unity3D (see examples)
• Import wrmhl to Unity, and voilà!

You can use the default wrmhl protocol, or implement your own in a minute just by changing: wrmhl/Assets/WRMHL/Scripts/Thread/wrmhlThread_Lines.cs.

How to get started ?

just follow the guide by clicking here. Star the repo if you liked it ⭐️

Hope this is helpful! If you’re using it, would love to hear about what you’re building. Ping me at maxime@relativty.com or @maximecoutte.