© Copyright 2021 - All rights reserved.

This document is geared towards providing exact and reliable information in regards to the topic and issue covered. The publication is sold with the idea that the publisher is not required to render accounting, officially permitted or otherwise qualified services. If advice is necessary, legal or professional, a practiced individual in the profession should be ordered.

- From a Declaration of Principles which was accepted and approved equally by a Committee of the American Bar Association and a Committee of Publishers and Associations.

In no way is it legal to reproduce, duplicate, or transmit any part of this document in either electronic means or printed format. Recording of this publication is strictly prohibited, and any storage of this document is not allowed unless with written permission from the publisher. All rights reserved.

The information provided herein is stated to be truthful and consistent, in that any liability, in terms of inattention or otherwise, by any usage or abuse of any policies, processes, or directions contained within is the solitary and utter responsibility of the recipient reader. Under no circumstances will any legal responsibility or blame be held against the publisher for any reparation, damages, or monetary loss due to the information herein, either directly or indirectly.

Respective authors own all copyrights not held by the publisher.

The information herein is offered for informational purposes solely and is universal as so. The presentation of the information is without a contract or any type of guarantee assurance.

The trademarks that are used are without any consent, and the publication of the trademark is without permission or backing by the trademark owner. All trademarks and brands within this book are for clarifying purposes only and are owned by the owners themselves, not affiliated with this document.

Table of Contents

ARDUINO PROGRAMMING

A Comprehensive Beginner's Guide

to learn the Realms of Arduino from A-Z

Introduction

Where Do I Find a Microcontroller?

Arduino

Know the Hardware

Chapter 1 : Basic Concepts of Arduino

Physical Computing

Open Source Hardware

Free Software

Arduino

Processing

Fritzing

Chapter 2 : Electronics

Concept of Electronics

Voltage

Electric Current

Direct Current

Alternate Current

Resistance

Ohm's Law

Electronic Systems

Summary of Electronic Systems

Electronic Signals

Voltage Divider

Analog to Digital Converter

PWM Pulse Width Modulation

Serial Communication

Chapter 3 : Electronic Components

Microcontroller

Protoboard

Resistor

Thermistor

Diode

Transistor

Capacitor

LED

RGB LED

LCD

Button

Reed Switch

Potentiometer

Photocell

Piezoelectric Transducer

DC Motor

Relay

Chapter 4 : Arduino Programming

The Arduino Project

Arduino IDE for Windows

Arduino IDE for Linux

Programming

Programming Language

Algorithm

Arduino Software

Sketches

Serial Monitor

Arduino Library

Programming Arduino

Digital Functions

Analog Functions

Chapter 5 : Starter Kit with Arduino Uno R3

Lessons

Button

Serial Reading of a Digital Input

Serial Reading of an Analog Input

Command with Serial Communication

Fade

Loop

LDR Sensor

Thermistor

DC Motor

LCD

Typing into the LCD

Piezo as Analog Output

Scroll Bar with Processing

Arduino - Thermostat

Chapter 6 : If Statement with Arduino, Control the Execution of your Code

If with Arduino - Necessary Material

Syntax of the if Statement with Arduino

Comparison Operators in if Statements with Arduino

Example if Statement with Arduino

Boolean Operators if with Arduino

if-else with Arduino

Example if-else statement with Arduino

else if with Arduino

Example else if statement with Arduino

Chapter 7 : Battery and Battery Charge Meter with Arduino

The Objective of the Battery and Battery Charge Meter with the Arduino Board

Arduino Components that We Will Use

Riding the Circuit with Arduino

Programming the Battery and Battery Charge Meter with Arduino

Arduino Native Code

Chapter 8 : ADS1115 ADC Digital-Analog Converter for Arduino and ESP8266

What is a Digital-Analog Converter?

What is an ADS1115?

Install Library for ADS1115

Single-End Mode Programming

Differential Mode

Differential Mode Programming

Comparator Mode

Chapter 9 : Arduino Interruptions

Practical Example: Controlling the Speed of Fantastic Car Lights

Conclusion

References

ARDUINO PROGRAMMING

Tip and Tricks to Learn Arduino Programming Efficiently

Introduction

What is Arduino?

Advantages of Arduino

Arduino - Choosing a Hardware Platform

Equipment Arduino UNO R3

Clones, or Arduino (un) Original

Materials you need to program Arduino

Arduino IDE Installation

What happens when you install the wrong IDE?

If you already have Arduino

Chapter 1 : Basic Concepts of Programming

Conversions

Decimal <-> Binary

Binary <-> Hexadecimal

Decimal <-> Hexadecimal

QUICK Method

The Software

Installation

Downloading

Windows

Mac Os

Under Linux

Software Interface Software Launch

Correspondence

Approach and Use of the Software

The File Menu

Buttons

Equipment

Presentation of the Card

Constitution of the Card

Materials

Visualization

Connectivity

Installation

Windows

Test your Equipment

The Arduino Language (1/2)

Language syntax

The Minimum Code

Function

The Instructions

The Braces

Comments

Accents

The Variables

What is a Variable?

A Variable is a Number

The Name of a Variable

Define a Variable

Code: C

The Arduino Language (2/2)

What is a Loop?

The do... while loop

Concatenation

The Functions

What is a Function?

Make a Function

But what is "Void"?

Empty Functions

The "Typed" Functions

Functions with Parameters

What is going on?

The Tables

What's the Point?

The Maximum Score

Average Calculation

Chapter 2 : Input / Output Management

Our First Program

But how do you calculate this resistance?

Where do we start?

Create A New Project

What does "HIGH Value or LOW Value" Mean?

Use the Command

The Program

Millis () Function

Limits of the Delay () Function

Chapter 3 : Programming With Arduino

The Basic Structure of a Sketch

1. Variables to Name

2. Setup (essential in the program)

3. Loop (essential in the program)

Instructions

A Flashing LED

Circuit

The Change Indicators

Sketch:

An LED Pulsing Leave

Sketch:

Simultaneous Lighting and Sound

Sketch:

Activate a LED Touch of a Button

Sketch:

An RGB LED Drive

Sketch 1:

Sketch 2:

The Motion

Sketch:

Read Brightness Sensor

Read Voltages

The "Serial Monitor"

Sketch:

Knobs

Sketch:

Measure Temperatures

Sketch:

Measure Distance

Code:

Enhancements: Reversing Warning

Infrared Remote Control for Controlling Arduino Microcontrollers

Code:

Servo Drive

Code:

LCD Display

Code:

Relay Card

Code:

Stepper Motor

Cabling

Code

Code:

Drop Sensor

Code:

RFID Kit

Read an RFID tag with Arduino and Process the Data

Preparation - the first sketch with the RFID READER

RFID Sketch 2

Sketch 3

Chapter 4 : Accessories for Arduino

Keypad Shield

Code:

Instructions for LCD Display with I2C Port

Program

Sketch:

Example of use:

Two I²C Displays

Arduino RTC

Cabling:

Extension:

Keypad

The Sketch:

Keypad - Castle

Color Sensor

Cabling:

Generate Tones

Code:

Create Melodies

Arduino Tilt Sensor SW-520D

The Sketch:

Temperature Measured with the LM35

Expansion of the Program:

Code:

Measure the Voltage

Cabling:

We now come to the code:

Four-Digit 7-Segment Display

Programming

Code:

Conclusion

References

ARDUINO PROGRAMMING

Advanced Methods and Strategies

to Learn Arduino Programming

Introduction

Chapter 1 : Setting Up the Tools

The Arduino Software

Arduino Hardware

Setting Up The Arduino IDE

Working with Arduino

Chapter 2 : The Basics of Arduino Programming

Curly Bracket

Semicolons

Comments

Variables

Datatype

Boolean

Byte

Integer

Long

Double and Float

Character

Arrays

Character Arrays

Constants

Arithmetic Functions

Comparison Operators

Logical Operators

Casting

Decision Making

Looping

Functions

Chapter 3 : The Advanced Concepts of Arduino Programming

Setting Digital Pin Mode

Digital Write

Digital Read

Analog Read

Structures

Unions

Adding Tabs

Working with Tabs

Object-Oriented Programming

String Library

Arduino Motion Sensor Project

Arduino LCD Display Project

Chapter 4 : Structuring and Arduino Programming

Structuring and Arduino Program

Using Standard Variable Types

Floating- Point Numbers

Working with Groups of Values

Using Strings in Arduino

Using Strings of C Programming Language

Splitting Comma- Separated Text into Groups

Converting a Number to a String

Converting a String to a Number

Transforming the Lines of Code into Blocks

Returning More Than One Value from a Function

Chapter 5 : Coding and Memory Handling

Using the Libraries

Installing Additional Libraries

Modifying Libraries

Creating a Library

Creating Libraries from Other Libraries

Memory Handling

Saving and Fetching Numeric Values from Program Memory

Saving and Fetching Strings Using the Program Memory

Conclusion

References

ARDUINO

PROGRAMMING

A Comprehensive Beginner's Guide to learn the Realms of Arduino from A-Z

STUART NICHOLAS

Introduction

The Internet of Things concept is fashionable, which refers to the ability to interact with physical devices, obtaining information/metrics (e.g., temperature, humidity, etc.) and sending commands/actions (e.g., opening the door, turning on air conditioning, etc.).

The concept, which is not new, implies collaboration between electronics professionals, programmers, and even DBAs. This book is suitable for developers and DBAs who have little knowledge of electronics, giving them an introduction to using Arduino, one of the most well-known electronics platforms used in this area.

In this section, we will make a brief introduction to the Arduino, which is basically a board with a programmable microcontroller, cheap, and easy to use.

The first thing we have to be clear about is that it is a microcontroller and how it differs from the microprocessor. We have all ever come into contact with both concepts, that is, we all have a computer at home, whether desktop, portable, etc.

Well, the core of our computers is a microprocessor, a chip in charge of performing complex operations from some instructions (which we will call program) and some input data obtaining some output data. To process and store this data, we need to connect the microprocessor to RAM and other I / O devices (Input / Output), which are connected through the motherboard.

Defined the microprocessor in a concise way, and taking into account that we had said that the microprocessor needs to be connected to the memory through the motherboard, in the microcontroller, we have both the memory where we store the program, and the memory where it is stored — data, in the same assembly (on the same chip).

Sorry if I have taken licenses to define it, I know there are several more differences, such as the location of the data memory and program in reference to the microprocessor.

Where Do I Find a Microcontroller?

We find it in most electronic devices that we use every day, such as remote controls, watches, televisions, cars, and much more. The importance of knowing how they work and how they are programmed opens up many doors.

Arduino

A few years ago, a free project, called Arduino , appeared,   which facilitated access to this class of devices for students since it is an open hardware-based board (its design is free and can be reproduced by anyone).

Initially, the board was connected through a USB port to program it (it usually is done based on its IDE that can be found here ). Arduino programming was not done at a low level with assembler like many microcontrollers (from now on we will call them PICs), but it is done with a language more understandable by most of us, C / C ++ (the basic reference to the language we found here and examples on this route ).

With these elements, a programmer who does not know about PICs would be able to program the Arduino in a short time.

The UNO version board consisted of 14 digital I / O pins, of which 2 had a serial connection. These pins are useful for most basic sensors, or for relays, actuators, etc., which only have two states, on or off (or with the Arduino constants HIGH and LOW). It also has six analog pins, capable of reading up to 1024 voltage levels, called analog port resolution. These are used to read sensors that give us different voltage ranges depending on their state, such as heat resistance, variable resistance, etc.

Basically, with the structure of the Arduino UNO, anyone can enter the world of PIC programming. But, for larger projects, more power is needed, with which the Arduino boys were creating plates and improved versions of the Arduino UNO. I expose a few:

Arduino Leonardo

It is the first evolution of the Arduino Mega, in fact, it has the same ports, but the PIC is different, with greater capacity and higher working frequency. Another difference is the USB port, which at the same time of being used to upload the program, can use the USB as a host; that is, we can use it as a keyboard, etc ... Another inclusion is the SDA and SCL ports, used for devices that communicate through the I2C protocol.

Arduino Mega 2560

For those who fall short, the Leonardo designed the Arduino Mega 2560, with much more speed in the microcontroller and many more digital (54 pins) and analog (16 pins) ports. We have the pins for I2C like Leonardo (although they change position).

This design is also the Arduino Mega ADK, which is a modified board of the Mega 2560, but a USB host port is added. Google has designed several projects with this board and its flagship, Android, an example you have on this page .

Another evolution is the Arduino DUE, with the same design as the Mega 2560 but with a 32-bit microprocessor. It is much faster than the Mega 2560.

Arduino YUN

Basically, this board has the same pin and processor characteristics as the Arduino Leonardo, but a microcomputer has been incorporated where a small Unix resides, which allows us to mount fundamental web servers. This board is mostly used for projects in which the sensors have to report through an Ethernet network quickly and easily.

More developments will come in the future, merging the power of Arduino boards with computer motherboards and offering us the possibility of creating a multitude of projects, with unlimited power and scalability.

Know the Hardware

There are several models of Arduino. Here we will just work with the Uno and Mega models.

The biggest differences between them are the speed, the amount of memory, and the number and type of pins. Some are connected via USB via a Type B USB connection, and others via a Type B Micro-USB connection. The positions of the Reset button and LEDs also vary by model and version.

For the purposes of this workshop, we will use pins and features that are common to everyone.

Arduino Uno

1. USB for power and communication;

2. Alternative power (from 9V to 12V, center pin is + );

3. Power pins (outputs and inputs);

4. Analog input pins (can be used as digital);

5. Digital input / output pins ( ~ means PWM digital output)

6. Processor;

7. Reset button

8. LEDs: RX and TX indicate serial communication (USB port), L shows pin 13 value.

Breadboards

Hello World with Integrated LED

After installing the Arduino IDE (https://Arduino.CC/en/Main/Software) and connecting it via the USB cable, you need to configure it. We start by choosing the serial port where it is connected (usually there will only be one).

Next, you must choose the Arduino model.

In some cases (such as Arduino Mega), it is also necessary to choose the version.

The Arduino IDE comes with some examples. Let's start by using the Blink example for flashing the integrated LED on board (L), which is connected to pin 13.

The example shows two functions:

Setup()

In this function, we initialize the hardware we are using. This function runs once when Arduino is powered.

Loop()

In this function, we put the program that performs the desired function. At the end of this function, it is called again (repeats indefinitely).

After creating the program, we must validate it. For this, we use the first toolbar button (√).

To send the program to Arduino, we use the second button (→). During upload, we will see several messages at the bottom of the IDE as well as the flashing RX and TX LEDs on the board. Once the upload is complete, the program starts automatically. In this case, the LED L on the board will flash.

You can adjust the delay()to change the duration of each state (on or off) of the LED. The delay()uses milliseconds. We start by implementing the following scheme, with a button and a high resistance (e.g., 10 kΩ).

This scheme, which, while the button is not pressed, is sending 0V to the input, is called a pull-down. There is also a pull-up, but by default, the input gets + 5V (or + 3.3V, depending on the type of card).

Then we load the Button example. After upload, the button will work to activate the LED. Using the scheme from the previous lab, we will send the status of the button over the USB / serial connection to the computer. Let's open the DigitalReadSerial example.

After sending the program to Arduino, let's see what is sent to the USB / serial port using Serial Monitor.

Note: Before turning on the Serial Monitor, in some, the serial output buffer fills up quickly, then the LED starts flashing randomly, and the program hangs on the Serial.println().

We can also send custom to debug text. For example, we add the line (always respect case).

[...] Serial. println ( buttonState );

if ( buttonState ) Serial . println ( "ON" ); else Serial . println ( "OFF" );

delay ( 1 ); // delay in between reads for stability [...]

Building on the scheme of previous labs, let's add a relay (which acts as a switch that can control external equipment).

We add to the end of the function setup():

pinMode ( 13 , OUTPUT );

pinMode ( 12 , OUTPUT );

We add to the end of the function loop():

digitalWrite ( 13 , buttonState );

digitalWrite ( 12 , ! buttonState );

Why is the pin 12 (relay) value reversed? The relays we are going to use will be active if their signal pin receives 0V, and they are inactive if they receive 5V (or not turned on). Not all relays are like this, so try testing before using it.

Using the scheme of previous labs, we will add an analog temperature or light sensor to pin A0.

Next, we load the example AnalogReadSerial.

We open the Serial Monitor again to see the sensor values. Analog pin reading (A0, A1, etc.) returns values between 0 and 1023 (i.e., linearly between 0V and 5V). However, likely, the sensor chosen will only show values in part of this range. Record the minimum and maximum sensor values for use in the following laboratory.

Using the scheme of previous laboratories, we will define rules for activating the relay. For example, if we use a light sensor, when we no longer have light, we want to enable the relay to turn on a lamp.

We add to the end of the function setup():

pinMode ( 13 , OUTPUT );

pinMode ( 12 , OUTPUT );

pinMode ( 2 , INPUT );

We add to the end of the function loop():

if ( sensorValue > 500 || digitalRead ( 2 )) { // Relay on

digitalWrite ( 13 , HIGH );

digitalWrite ( 12 , LOW ); } else { // Rele off

digitalWrite ( 13 , LOW );

digitalWrite ( 12 , HIGH ); }

The exact value (here 500) and the operator ( >or <) may vary by sensor. Use the values obtained in the previous laboratory to calibrate.

Chapter 1

Basic Concepts of Arduino

Physical Computing

Physical computing means building interactive physical systems through the use of software and hardware that integrate, can feel and respond to the analog world. Although this definition is broad, in a more general sense, physical computing is a creative framework for understanding the relationship between humans and the digital world. In practice, this term often describes design drawings DIY or objects using sensors and microcontrollers for translate analog inputs to software-based systems or control electromechanical devices such as motors, servos, lighting, or other hardware.

Other physical computing implementations work with voice recognition, which captures and interpret sound waves through microphones or other devices, audio wave detection devices, also computer vision, which applies algorithms to videos detected by some type of camera. Tactile interfaces are also an example of physical computing.

Prototyping (creating quick assemblies with the help of a protoboard and basic electronics components) plays an important role in physical computing. Tools such as Arduino and Fritzing are useful for designers, artists, students, and hobbyists because they help to make prototypes quickly.

Open Source Hardware

Free hardware is called hardware devices whose specifications and schematic diagrams are publicly accessible, either under some kind of payment or free of charge. The philosophy of free software (ideas about freedom of knowledge) is applicable to that of free hardware. It must be remembered at all times that free is not synonymous with free. Free hardware is part of free culture.

Open Source Hardware consists of physical technology devices designed and offered by the open design movement. Both free software and open-source hardware are created under the open-source culture movement and apply this concept to a variety of components. The term usually means that the information on the hardware is easily recognized.

The design on the hardware (i.e., mechanical drawings, schematics, material list, PCB layout data, source code, and integrated circuit layout data), plus of the free software that drives the hardware, are all released with the free and open-source approach. Every year the Open Source Hardware Association organizes the Open-Hardware Summit conference, which is the world's first comprehensive conference on open hardware, a space to discuss and draw attention to this rapidly growing movement.

Since the hardware has direct variable costs associated with it, no definition of free software can be applied directly without modification. In contrast, the term free hardware has been used primarily to reflect the use of free software with hardware and the free release of information regarding hardware, often including the version of schematic diagrams, designs, and assemblies.

Free Software

Free software is software that is distributed along with its source code and is released under terms that guarantee users the freedom to study, adapt/modify, and distribute the software. Free software is often developed in collaboration between volunteer programmers as part of an open-source software development project.

The Free Software Foundation considers software as free when it meets the four types of freedom for users:

- Freedom 0: The freedom to run the program, for any purpose;

- Freedom 1: The freedom to study the software;

- Freedom 2: The freedom to redistribute copies of the program so that you can help your neighbor;

- Freedom 3: Freedom to modify the program and distribute these modifications so that the entire community benefits.

The users of this type of software are free because they do not need to ask permission and are not bound by restrictive proprietary licenses. The Open Source Initiative (OSI) is an organization dedicated to promoting open-source or free software. It was created to encourage a rapprochement of commercial entities with free software. Its main performance is to certify which licenses fit as free software licenses, software, and its technological and economic advantages.

Free software, although this name is also sometimes confused with "free" because of the ambiguity of the term "free," so "free software" and "logical free" are also used) It is the name of the software that respects the freedom of the users on their acquired product and, therefore, once obtained, it can be used, copied, studied, modified, and redistributed freely. According to the Free Software Foundation, free software refers to the freedom of users to execute, copy, distribute, study, modify the software, and distribute it modified.

OSI, like many community members, believes that software is first and foremost a tool and that the merit of this tool should be judged based on technical criteria. For them, free software, in the long run, is economically more efficient and of better quality and should, therefore, be encouraged. In addition, the participation of companies in the free software ecosystem is considered fundamental because they are the companies that enable the increase in the development, implementation, and use of free software.

Arduino

Arduino is an open electronics platform for prototyping based on free, flexible, and easy-to-use software and hardware. It was developed for artists, designers, hobbyists, and anyone interested in creating objects or interactive environments. The Arduino can acquire environmental information through its input pins, for which a complete range of sensors can be used. On the other hand, Arduino can act in the environment by controlling lights, motors, or other actuators.

The fields of action for the control of systems are immense, being able to have applications in the area of 3D printing, robotics, transport engineering, agronomic engineering, musical engineering, fashion, and many others. The microcontroller of the Arduino board is programmed using the Arduino programming language, based on Wiring, and the development environment (IDE) is based on Processing.

The projects developed with Arduino can be run even without the need to be connected to a computer, although they can also be done by communicating with different types of software (such as Flash, Processing, or MaxMSP). Plates can be handmade or purchased assembled from the factory.

You can download the software that can be done for free, and the board designs are available under an open license, so you are also free to adapt it to your needs.

Processing

Processing is an open-source programming language, and integrated development environment (IDE) built for the electronic arts and communities of visual projects to teach basic notions of computer programming in a visual context. The project was initiated in 2001 by Casey Reas and Ben Fry, both former members of the MIT Media Lab Computing Group. One of the objectives of Processing is to act as a tool for nonprogrammers initiated with programming, through immediate satisfaction with visual feedback.

Fritzing

Fritzing is an open-source electronic design automation program designed to help designers and artists move from prototypes (using, for example, test boards) to final products. Fritzing was created under the principles of Processing and Arduino and allows designers, artists, researchers, and amateurs to document your Arduino-based prototype and create printed circuit diagrams for later manufacturing. Besides.., it has a complementary website that helps share and discuss projects, experiences, and reduce manufacturing costs.

Chapter 2

Electronics

From the beginning of this chapter, you will find out about the technical terms that electronics have and that at the end of this one, you will most likely manage expertly.

Concept of Electronics

In a broader definition, we can say that electronics is the branch of science that studies the use of circuits formed by electrical and electronic components, with the main objective of representing, storing, transmitting, or processing information beyond the control of processes and servomechanisms.

From this point of view, it can also be said that the internal circuits of the computers, telecommunications systems, the various types of sensors and transducers are all within the area of interest of electronics. It is divided into analog and digital because its work coordinates choose to obey.

These two forms of presentation of the electrical signals to be treated. It is also considered to be a branch of electricity, which, in turn, is a branch of physics where the phenomena of the charges are studied - elementary electrical power, the properties, and the behavior of the electron, photons, elementary particles, electromagnetic waves, etc.

It studies and uses systems whose operation is based on the conduction and control of the flow of electrons or other electrically charged particles. The design and large construction of electronic circuits to solve practical problems are part of electronics and the fields of electronic, electromechanical, and computer engineering in the design of software for their control.

Electronics currently develops a wide variety of tasks. The main uses of electronic circuits are control, processing, distribution of information, conversion, and distribution of electrical energy. These two uses involve the creation or detection of electromagnetic fields and electric currents. Look around the radio, TV, PC, mobile phone, washing machine, all of them have electronics.

Voltage

Electric voltage, also known as the potential difference (DDP) or voltage, is the difference in electrical potential between two points or the difference in potential electrical energy per electric charge unit between two points. Its unit of measure is the volt or joules by coulomb. The potential difference is equal to the work that must be done per unit of load against an electric field to move any load.

It is a physical quantity that drives electrons along a conductor (for example, a cable) in a closed electrical circuit, causing the flow of an electric current. Its unit is Volt (V). The instrument used to measure the voltage is known as a voltmeter.

A voltmeter can be used to measure the potential difference between two points in a system, and usually, a common reference point is earth. Fields can cause electrical voltage by an electric current under the action of a magnetic field by a variant magnetic field or a combination of the three.

Electric Current

Electric current is the orderly flow of electrically charged particles, or also the displacement of loads within a conductor when there is an electrical potential difference between the ends. The standard unit in the International System of Units for measuring current intensity is ampere. To measure the current, you can use an ammeter. An electric current, since it is electric, this is a phenomenon that can be used as an electromagnet, being this the principle of operation of a motor.

The instrument used to measure the intensity of the electric current is the galvanometer, which, calibrated in amps, is called an ammeter placed in series with the conductor whose intensity you want to measure.

Direct Current

Direct current, direct current, galvanic current, or direct current (DC) is the orderly flow of electrons in one direction at a time. This type of current is generated by car or motorcycle batteries (6, 12 or 24V), small batteries (usually 9V), batteries (1.2V and 1.5V), dynamos, solar cells and power supplies of various technologies, which rectify the alternating current to produce direct current.

It is the continuous flow of electrons through a conductor between two points of different potential. In the direct current, the electric charges always circulate in the same direction. It is continuing the current still maintains the same polarity. In the systematic American standard, the color black corresponds to the negative and the red to the positive or is symbolized for the positive with VCC, +, VSS, and for the negative with 0V, -, GND.

It has usually used for powering electronic devices (between 1.2 V and 24V) and digital circuits of computer equipment (computers, modems, hubs, etc.). This type of circuit has a negative pole and a positive pole (is polarized), whose intensity is maintained. More correctly, the intensity increases at the beginning to a maximum point, remaining continuous, that is, without changing. When turned off, it decreases to zero and extinguishes.

Many devices need direct current to operate on all those that carry electronics (audiovisual equipment, computers, etc.). For this purpose, power supplies are used. You can find it in the batteries, batteries, output of the computer chargers.

Alternate Current

Alternating current (AC) is an electrical current whose direction varies in time, as opposed to the following of the direct current whose direction remains constant over time. The usual waveform in an AC power is sinusoidal for to be the most efficient form of energy transmission. However, in specific applications, different waveforms are used, such as triangular or square waves. While the direct current source consists of the positive and negative poles of an alternating current is composed of phases (and often neutral wire).

It is the electric current in which the magnitude and direction vary cyclically. The most commonly used alternating current waveform is that of a sine wave.

The AC voltage is what reaches the electrical outlets of homes and businesses, and it is very common to find it in the sockets where our appliances are connected. However, audio and radio signals transmitted by electric cables are also examples of alternating current. In these uses, the most important purpose is usually the transmission and retrieval of the information encoded (or modulated) on the AC signal.

Resistance

Electrical resistance is the capacity of a body to oppose the passage of electric current even when there is a difference of applied potential. It is measured in ohms (Ω).

Resistors are components whose purpose is to offer opposition to the passage of electric current through its material. We call this opposition electrical resistance. They cause a voltage drop in the power supply to a power supply unit may be limited to some part of an electrical circuit, but it will never cause an electric current drop, even though the current is limited.

This means that the electrical current entering one resistor terminal will be exactly the same as that of leaving the other terminal, but there is a voltage drop. Using this, it is possible to use the resistors to control the voltage on the desired components. You can find resistance in electric heaters, electronic cards, stoves are very useful to limit the passage of current.

Ohm's Law

Ohm's Law states that the current (I) circulating through a given circuit is directly proportional to the applied voltage (V) and inversely proportional to its resistance (R).

The pyramid on the side is very useful to know this formula. For example, cover with one finger the letter V (voltage), then the voltage will be equal to the current (I) times the resistance (R). Or, to calculate the resistance, divide the voltage (V) by the current (I).

Electronic Systems

An electronic system is a set of circuits that interact with each other to obtain a result. One way of understanding electronic systems is to divide them into inputs, outputs, and signal processing.

Inputs

Inputs are electronic or mechanical sensors that take signals (in the form of temperature, pressure, humidity, contact, light, motion, pH, etc.) from the physical world and convert them into current or voltage signals. Examples of inputs are gas sensors, temperature sensors, pulsators, photocells, potentiometers, motion sensors, and many more.

Outputs

Outputs are actuators or other devices that convert current or voltage signals into physically useful signals such as motion, light, sound, force, or rotation, among others. Examples of outputs are motors, LEDs, or light systems that switch on automatically when darkens or a buzzer that generates several tones.

Signal Processing

Signal processing is carried out using circuits known as microcontrollers. These are integrated circuits built to manipulate, interpret, and transform voltage and current signals coming from sensors (inputs) and to activate certain actions in the outputs.

Summary of Electronic Systems

As an example, we imagine a TV set. The input is a signal received by an antenna or a cable. The integrated circuits inside the device extract information about brightness, color, and sound from this signal. The devices of output are the LCD screen, which converts the electronic signals into visible images, and the speakers, which emit the sound.

Another example might be a circuit that controls the temperature of an environment. A temperature sensor and an integrated circuit are responsible for converting an input signal to an appropriate voltage level. If the registered ambient temperature is too high, this circuit will send the information to a motor to turn on a fan that will cool the room.

Electronic Signals

The inputs and outputs of an electronic system will be considered as variable signals. In electronics, we work with variables that are taken in the form of voltage or current, which can simply be called signals. The signals can be of two types: digital or analog.

Digital Variable

Also called discrete variables are characterized by having two different states and, therefore, can also be called binary (in logic would be True (V) and False (F) values, or could be 1 or 0 respectively). An example of a digital signal is the bell switch of your house because it has only two states, pulsed and pulseless.

Analog Variable

They are those that can take an infinite number of values comprised between two limits. Most real-life phenomena are signals of this type (sound, temperature, brightness, etc.).

An example of an analog electronic system is that of a speaker, who is concerned with amplifying the sound of his voice so that a large audience can hear it. The sound waves that are analog in their origin are captured by a microphone and converted into a small analog voltage variation, called an audio signal.

Voltage Divider

In electronics, the voltage divider rule is a design technique used to create a voltage (Volt) that is proportional to the other (Vin). In this way, the voltage of a source is distributed among one or more resistors connected in series. On a circuit like this, two resistors are connected in series as in the following diagram:

The output voltage, Volt, is given by the formula:

This way, we can obtain any fraction between 0 and 1 of the Vin voltage.

Analog to Digital Converter

An analog-to-digital (ADC) converter is an electronic device capable of generating a digital representation from an analog magnitude by converting an analog input at a binary value. It is used in electronic equipment such as computers, sound and video recorders, and telecommunications equipment.

These converters are very useful in the interface between digital devices and analog devices and are used in applications such as sensor reading, audio, video, etc. scanning.

PWM Pulse Width Modulation

Pulse Width Modulation (PWM) - better known by its acronym in English PWM (Pulse-Width Modulation) - of a signal or power supplies involves modulating its duty cycle to carry any information about a communication channel or to control the amount of energy being sent in a load.

For example, if we apply PWM to an LED, we can vary the brightness intensity, and if we use PWM to a DC motor, we can achieve its speed with the characteristic of keeping its strength constant.

Serial Communication

It is a digital data communication interface where information is sent one bit at a time, sequentially. It's different from parallel communication, where everyone the bits of each symbol are sent together. The serial interface is used in all long-range communication and most cases, in computer networks.

One of its uses is to monitor the state of a connected peripheral through the computer screen. For example, when pulsing the letter, A on the keyboard should light an LED that is remotely connected to the computer.

Chapter 3

Electronic Components

Various electronic components join forces to achieve fantastic applications such as your home TV or computer, inside you go and find cards with resistors, capacitors, integrated circuits, transistors, among others.

Microcontroller

A microcontroller is a programmable integrated circuit capable of to execute the orders recorded in his memory. A microcontroller has inside it three main functional units: central processing unit, memory, input, and output peripherals.

The microcontrollers are different from the processors because, besides the logical components and usual arithmetic of a general-purpose microprocessor, the microcontroller integrates additional elements into its internal structure, such as memory read and write for data storage, read-only memory for storage of programs, EEPROMs for permanent data storage, peripheral devices such as analog / digital converters (ADC), digital-to-analog (DAC) converters in some cases; and, data input and output interfaces.

They are generally used in automation and control of products and peripherals, such as automotive engine control systems, remote controls, office and residential machines, toys, supervisory systems, etc. By reducing the size, cost, and energy consumption, and when compared to the way of the use of conventional microprocessors, allied to the ease of application design, along with its low price, the microcontrollers are an efficient alternative for controlling many processes and applications.

Protoboard

It is a reusable board used to build prototypes of seamless electronic circuits. A protoboard is made of perforated plastic blocks and several thin sheets of copper, tin, and phosphorus alloy.

Resistor

It is a component formed by carbon and other resistant elements used to limit the electric current in a circuit. It opposes the passage of the current. The maximum current in a resistor is conditioned by the maximum power that can dissipate your body. This power can be visually identified from the diameter without another indication being necessary. The most common values are 0.25 W, 0.5 W, and 1 W.

Due to their very small size, it is not possible to print their respective resistors on the resistors. The color-coding was then chosen, which consists of colored stripes on the resistor body indicated as a, b, c, and % tolerance. The first three ranges are used to indicate the nominal value of its resistance and the last range, the percentage by which the resistance can vary its nominal value, according to the following equation:

R = (10a + b) x 10c ± % of tolerance

The value of the electrical resistance is obtained by reading the figures as a one, two, or three-digit number; it is multiplied by the multiplier, and the result is obtained in Ohms (Ω).

Thermistor

The NTC (Negative Temperature Coefficient) thermistor is a temperature-sensitive semiconductor electronic component used for control, measurement, or polarization of electronic circuits. It has a coefficient of resistance variation that varies negatively as the temperature increases, i.e., its electrical resistance decreases with increasing temperature.

Diode

It is the simplest type of semiconductor electronic component. It is a component that allows the chain to cross only in one direction.

Transistor

It is mainly used as an amplifier, an electrical signal switch, and an electric rectifier in a circuit. The term comes from the English transfer resistor (resistor/ transfer resistance), as its inventors knew it.

The process of resistance transfer in the case of an analog circuit, it means that the characteristic impedance of the component varies upwards or downwards from the pre-assigned polarization.

Thanks to this function, the electrical current passing between collector (C), base (B), and emitter (E) of the transistor varies within specific pre-set parameters and processes the signal amplification.

The term "amplify" means the procedure for making a weaker electrical signal on a stronger one. A low-intensity electrical signal, such as the signal generated by a microphone, is injected into an electronic circuit (transistorized, for example), whose main function is to transform this weak signal generated by the microphone into electrical signals with them.

This whole process is called signal gain. Nowadays, transistors are found in all appliances for household and everyday use: radios, televisions, recorders, stereos, microwaves, washing machines, cars, calculators, printers, mobile phones, etc.

Capacitor

The capacitor is an electrical device capable of storing electrical charges. In electronic circuits, some components require DC power, while the power supply is connected to AC power. Solving this problem is one example of the usefulness of a capacitor.

This element is capable of storing electrical potential energy during a time interval and is constructed using a uniform electrical field. A capacitor consists of two conductive parts, called armatures and insulating material with specific properties called the dielectric.

LED

The LED (Light Emitting Diode) is a diode that emits light when energized. LEDs have many advantages over incandescent light sources such as lower energy consumption, longer lifetime, smaller size, exceptional durability, and reliability. The LED has a polarity, an order of connection. Connecting it upside down will not work correctly. Check the drawings for a match between the negative and the positive.

They are mainly used in microelectronic products, such as a warning signal. It is also widely used in panels, curtains, and led tracks. They can be found in larger sizes, such as some models of traffic lights or displays.

RGB LED

An RGB LED is an LED that incorporates in a single package three LEDs, one red, one green, and one red, blue. In this way, it is possible to form thousands of colors by adjusting each color individually. The three LED's are joined by a negative or cathode.

LCD

A liquid crystal display, or LCD (liquid crystal display), is a thin panel used to display information by electronic means, such as text, images, and videos. An LCD consists of an electrically controlled light polarizing liquid that is compressed into cells between two transparent polarizing blades. Its main features are lightness and portability. Its low power consumption allows it to be used in portable equipment, powered by electronic battery.

An LCD can vary the number of lines and characters per line, the color of the characters, and the background color, as well as having or not backlighting. The models with backlight have better visualization.

Button

A button, or push button, is used to activate some function. The buttons are usually activated by pressing them. A button on an electronic device often functions as an electrical switch. There are two contacts inside, and if it is a normally closed or normally open device, pressing the button will activate the opposite function to the one currently being performed.

Reed Switch

It is an electrical switch activated by a magnetic field, for example, with a magnet. When the contacts are open, they close in the presence of a magnetic field. When they're closed, they open.

It is commonly used in the door and window sensors for anti-theft alarms. The magnet is attached to the door and the reed switch to the stop.

Potentiometer

A potentiometer is a resistance whose value is variable. In this way, indirectly, you can control the current intensity that flows through a circuit if it is connected in parallel, or control the voltage by connecting it in series. They are suitable for use as a control element in electronic devices. You can activate it to vary the normal operating parameters. An example is the volume button of a radio.

Photocell

The LDR (Light Dependent Resistor) is a resistance whose value in ohms varies according to the incident light. A photocell has a low resistance value in the presence of light and a high value in its absence.

It can be found in various consumer goods, such as cameras, light meters, radio clocks, security alarms, or public lighting systems.

Piezoelectric Transducer

A piezoelectric transducer is efficient for detecting vibrations or blows. It can be used as a sensor by reading the output voltage. This electroacoustic transducer can also be used as a small buzzer to produce a continuous or intermittent sound or buzz.

DC Motor

The direct current (DC) motor is a machine that converts electrical energy into mechanical energy, causing a rotary motion. This direct current machine is one of the most versatile. Its easy control of position, pause, and speed makes it one of the best options in process control and automation applications. For example, you can find yourself in the traction of battery-powered toy cars or on the wheels of a robot.

Relay

It is an electromechanical switch used to turn devices on or off. When a current circulates through the internal coil, it creates a magnetic field that attracts one or a series of contacts by the closing or opening circuits. When the coil current ceases, the magnetic field also ceases, causing the connections to return to their original position.

Chapter 4

Arduino Programming

The Arduino Project

The Arduino project began in 2005 to create a device for students that would offer integrated control of design and interaction projects, and that would be more cost-effective than the prototyping systems available to date.

What we now call Arduino (the microcontroller) was born in the Italian city of Ivrea. In this same city in the 10th and 11th centuries, there was another Arduino (a nobleman) who proclaimed himself king of all Italy; obviously, the thing didn't work and, as was usual at the time, he was killed by his rivals. The fact is that in his hometown he is still very remembered, the main avenue of the city is called "Via Arduino" as well as many local shops.

While they lived there, the members of the team that created Arduino (the microcontroller), after work, would have a beer. Where? At the Arduino Bar. So the name of Arduino (the microcontroller) is a tribute to Arduino (the bar), which in turn was a tribute to the other Arduino (the nobleman).

The Arduino project was developed by Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, and David Mellis. It is based on an open-source platform called Wiring, created by Colombian artist Hernando Barragan during a master's thesis at the Interaction Design Institute Ivrea . On the other hand, Wiring is based on Processing, and Casey Reas and Ben Fry created its integrated development environment.

"I don't believe that Arduino would exist without Wiring, and I don't believe that Wiring would exist without Processing. And Processing would definitely not exist without Design By Numbers and John Maeda".

- Interview with Casey Reas and Ben Fry , Shiffman Daniel (Sep/2009)

Arduino Uno R3

1. The USB connector for AB-type cable

2. Reset button

3. Digital input and output pins and PWM

4. Green LED board on

5. Orange LED connected to pin13

6. ATmega in charge of communication with the computer

7. LED TX (transmitter) and RX (receiver) of serial communication

8. ICSP port for serial programming

9. ATmega 328 Microcontroller, Arduino's brain

10. Crystal quartz 16Mhz

11. Voltage regulator

12. 2.1mm female connector with positive center

13. Voltage and ground pins

14. Analog inputs

Arduino Family

Over the years, the Arduino line has been growing more and more and bringing solutions to the most diverse projects.

Shields for Arduino

A shield is a board that allows you to expand the original features of Arduino. Some examples:

Arduino IDE for Windows

Arduino board and a USB AB cable

This lesson will help you install Arduino Uno, Arduino Duemilanove, Nano, Arduino Mega 2560, or Diecimila boards. For other boards of the Arduino line, you should look for the corresponding lesson. You will also need a USB AB cable.

Download Arduino Software

Download the latest version of the Arduino software. When finished, unzip the file and maintain the folder and subfolder structure. If you want to save this folder in the C: drive of your computer. Inside this folder, there is a file called arduino.exe, which is the entry point of the Arduino program, the IDE (Integrated Development Environment).

Connecting Arduino

The isolated Arduino Uno uses power from the computer via the USB connection; no external power is required. Connect the Arduino card to the computer using the USB AB cable. The green power LED (PWR) should light up.

Installing drivers

Drivers for Arduino Uno or Arduino Mega 2560 with Windows 7, Vista or XP:

- Connect the card to the computer and wait for Windows to start the driver installation process. After a few moments, the process will fail. Click finish and dismiss the wizard's help.

- Click on the Main Menu and open the Control Panel.

- Within the Control Panel, navigate to System and Security. Then click System, select Hardware, and then click Device Manager.

- Search for Ports (COM & LPT), where you should see an Arduino UNO option (COMxx).

- Right-click on Arduino UNO (COMxx) and choose the Update Driver option.

- Then choose the Install option from a specific list or location (Advanced) and click move forward.

- Finally, browse and choose the Arduino.inf driver located in the Drivers folder of the Arduino software you downloaded.

- Windows will finish installing the driver from this point.

Opening the Arduino Program

Double-click the Arduino application, the arduino.exe file. If the program loads with the language that is not your preference, you can change it in the preferences section of the program.

Example Blinking

Open the example Blink: File > Examples > 01.Basics > Blink

Select your Card

You must select your Arduino card: Tools > Card > Arduino Uno.

Select the Port

Now select the serial port that will connect Arduino: Tools > Serial Port. You must choose the same port you used to confirm the system in step 4.

Upload the Program

Now simply click the Load button in the program window. Wait a few seconds. You should see the RX and TX LEDs on the card blink. If the process has been executed, you will generally see a "Transfer complete" message.

After a few seconds, you will see the LED of pin 13 blink orange. In this case, congratulations! Your Arduino is ready and installed.

If you have installation problems, you can access the official Arduino page with some solutions.

Arduino IDE for Linux

It will be necessary to install some programs to use Arduino on Linux. The form of the procedure depends on the distribution.

First, download the latest version of Arduino for Linux from the official page.

For more details, select your distribution:

- ArchLinux

- Debian

- Fedora

- Gentoo

- MEPIS

- Mint

- openSUSE

- Puppy

- Pussy

- Slackware

- Ubuntu

- Xandros (Debian derivative) on Asus Eee PC

- CentOS 6

Programming

Programming is a great resource that allows us to create several sequences of logical steps to meet our needs and those of our systems. Programming is an art that requires excellent logical skill and concentration on the part of the programmer.

Programming Concept

It is the process of designing, writing, proving, debugging, and maintaining the source code of computer programs. The source code is written in a programming language. The purpose of programming is to create programs that perform the desired behavior.

The process of writing code often requires knowledge in several different areas, in addition to the domain of the language to be used, specialized algorithms, and formal logic. Scheduling encompasses areas such as application analysis and design.

To create a program that the computer interprets and executes the written instructions, a programming language must be used. In the beginning, computers interpreted only instructions in a specific language, a low-level programming language known as machine code, which was too complicated to program. It consists exclusively of number strings 1 and 0 (binary system).

To facilitate the programming work, the first scientists who worked in the area decided to replace the instructions, sequences of one and zero, by English words or letters, encoding and creating a higher level language known as Assembly. For example, to add up, you use the English letter A add. Actually, writing in assembly language is basically the same as with machine language, but letters and words are easier to remember and understand than sequences of binary numbers.

As the complexity of the tasks performed by computers increased, it was necessary to develop a simpler method of programming. Then the high-level languages were created. While a task as simple as multiplying two numbers requires a set of assembly language instructions, in a high-level language, one is sufficient.

Programming Language

A programming language is an artificial language developed to express operations that can be performed by machines such as computers. They can be used to create programs that control the physical and logical behavior of a device, to express algorithms accurately, or as a mode of communication between people.

It consists of a set of symbols and syntactic and semantic rules that define its structure and the meaning of its elements and expressions.

The process by which the source code of a computer program is written, tested, debugged, compiled, and maintained is called programming.

Machine Language

A code system directly interpretable by a micro programmable circuit, such as a computer microprocessor or a microcontroller. A machine code program consists of a sequence of numbers that mean a sequence of instructions to be executed.

The machine language works with two voltage levels. Such levels, by abstraction, are symbolized by zero (0) and one (1), so the machine language only uses these signs.

Computer programs are rarely created in machine language but must be translated (by compilers) to be run directly by the computer.

There is currently a fashionable option of not running them directly, but using an interpreter, this one running directly on machine code and previously compiled.

Assembly Language

It is a low-level programming language for computers, microcontrollers, and other programmable integrated circuits. Machine language, which is a mere bit pattern, becomes readable by replacing the raw values with symbols called mnemonics. These symbols are generally defined by the hardware manufacturer and are based on codes that symbolize the processing steps (the instructions).

An assembly language is therefore specific to each computer architecture and can only be used by a specific microprocessor. This contrasts with most high-level programming languages that are ideally portable, which means that a program can run on a variety of computers.

High-Level Language

The high-level programming language is what is called, in Computer Science of programming languages, a language with a relatively high level of abstraction.

Far from the machine code and closer to human language, high-level languages are not directly related to computer architecture.

The programmer of a high-level language does not need to know processor features such as instructions and registers. These characteristics are abstracted in a high-level language.

For these languages, a certain amount of programming knowledge is required to perform sequences of logical instructions. High-level languages were created so that the average user could solve a data processing problem more easily and quickly.

Algorithm

An algorithm is a finite sequence of well-defined and unambiguous instructions, each of which can be performed mechanically over a finite period and with a finite amount of effort.

The concept of algorithm is often illustrated by the example of a cooking recipe, although many algorithms are more complex. They may repeat steps (making iterations) or need decisions (such as comparisons or logic) until the task is completed. An algorithm does not necessarily represent a computer program, but the steps necessary to perform a task. Its implementation can be done by a computer, by another type of automaton, or even by a human being.

Arduino Software

To run the program, we enter the Arduino folder stored on the computer and look for the icon. Double-click to open the program.

The Arduino program is also known as the Arduino IDE (Integrated Development Environment) because besides the programming environment, it also consists of a code editor, a compiler, and a debugger.

Sketches

Software written using Arduino is called Sketches. These Sketches are written in the text editor of the Arduino IDE and are saved with the .ino file extension. This editor has cut/paste and fetch/replace text features. The message area gives feedback when saving and exporting files and also displays error information when compiling Sketches. The lower right corner of the window displays the current card and the serial port. The toolbar buttons let you check, load, create, open, and save Sketches or open the serial monitor.

Note: In IDE versions before 1.0 Sketches are saved with the .pde extension. It is possible to open these files with version 1.0, but you will be asked to save Sketch with the .ino extension.

Serial Monitor

Displays serial data being sent from the Arduino card to the computer. To send data to the card, enter the text and click the "send" button or press enter.

Communication between the Arduino board and your computer can take place at several predefined standard speeds. For this to happen, it is important to set the same speed in both Sketch and Serial Monitor.

In Sketch, this choice is made through the Serial. Begin function. And in the Serial Monitor via the drop-down menu in the lower right corner.

Note that on Mac or Linux, the Arduino card will reset (re-run your Sketch from the beginning) when you open the serial monitor.

Serial communication with the Arduino board can also be done through other programming languages such as Processing, Flash, Python, MaxMSP, and many others.

Arduino Library

The Arduino environment can be extended through the use of libraries, as can most programming platforms. Libraries provide extra functionality for use in sketches. For example, to work with hardware or data manipulation.

Some libraries are already installed with the Arduino IDE, but you can also download or create your own.

To use a library in a sketch, select in your Arduino IDE: Sketch>Import Library.

Included in the programming is the functionality of an existing library from the command:

#include < LiquidCrystal.h>

Programming Arduino

Arduino is programmed in a high-level language similar to C/C++ and usually has the following components to elaborate the algorithm:

- Structures

- Variables

- Boolean, comparison and arithmetic operators

- Control Structure

- Digital and analog functions

For more details, visit the see the extended reference to more advanced features of the Arduino language and the libraries page for interaction with specific types of hardware on the official Arduino website.

Structures

These are two main functions that every program in Arduino must-have.

The setup() function is called when a program starts running. Use this function to initialize your variables, pin modes, declare the use of bookstores, etc. This function will be performed once after the Arduino board is turned on or reset.

setup(){

}

After creating a setup() function that declares the initial values, the loop() function does exactly what its name suggests, goes into looping (it always executes the same block of code), allowing your program to make changes and respond. Use this function to control the Arduino board actively.

loop(){

}

Variables

Variables are expressions that you can use in programs to store values such as reading from a sensor on an analog pin. Here we highlight some:

- Boolean Variables

Boolean variables, so-called in honor of George Boole, can have only two values: true and false.

boolean running = false;

- Int

An integer is the main type of data for numeric storage capable of storing 2-byte numbers. This covers the range of -32,768 to 32,767 (minimum value of -2^15 and maximum value of (2^15) -1).

int ledPin = 13;

- Char

A data type that occupies 1 byte of memory and stores the value of an ASCII character. Literal characters are written in quotation marks.

char myChar = 'A';

Boolean Operators

These operators can be used within the condition in an if sentence.

- && ("and" logical)

True only if the two operands are true, that is, the first condition and the second condition are true. Example

if (digitalRead(2) == 1&&        digitalRead(3) == 1) { // read two switches

// ...

}

is only true if both switches are closed.

- || ("or" logical)

True if any of the operands is true, that is if the first or second condition is true. Example

if (x > 0 || y > 0) {

// ...

}

is true only if x or y is greater than 0.

- ! (denial)

True only if the operation is false. Example

if (!x) {

// ...

}

is true only if x is false (i.e., if x is equal to 0).2

Comparison Operators

if, which is used in conjunction with a comparison operator, checks when a condition is met, such as input above a certain value. The format for an if a check is:

if (algumVariavel > 50)

{

// do something

}

The program checks if any Variable (putting accents on variable names is not a good idea) is greater than 50. If it is, the program performs a specific action. Put another way, if the sentence inside the parentheses is true, the code inside the wheel keys; otherwise, the program skips this block of code.

Keys can be omitted after an if sentence if there is only a single line of code.

(defined by a semicolon) that will be executed conditionally:

if (x > 120)     digitalWrite(LEDpin, HIGH);

if (x > 120) digitalWrite(LEDpin, HIGH);

if (x > 120) {digitalWrite(LEDpin, HIGH);}//         all are correct

The sentence being verified requires the use of at least one of the following operators comparison:

x == y (x equals y)

x != y (x is not equal to y) x < y (x is less than y) x > y (x is greater than y)

x <= y (x is less than or equal to y) x >= y (x is greater than or equal to y)

Arithmetic Operators

They apply when using variables.

- = (equality)

- + (addition)

- - (subtraction)

- * (multiplication)

- / (business area)

- % (rest of the division)

Control Structures

These are instructions that allow you to decide and perform several repetitions according to certain parameters. Among the most important we can highlight:

Switch/Case

Like if sentences, switch/case-control the flow of programs. Switch/case allows the programmer to construct a list of "cases" within a key-delimited block. The program checks each case with the test variable and executes the code if it finds an identical value.

switch (var) { case 1:

//do something when var == 1 case 2:

//do something when var == 2 default:

// if no value is identical, make the default

// default is optional

}

While

While it will cause the code block between keys to repeat continuously and indefinitely until the expression between parentheses () becomes false. Something has to cause a change in the value of the variable being checked, or the code will always be turning around inside the while. This could be the increment of a variable or an external condition, such as testing a sensor.

var = 0;

while(var < 200){

// some code that repeats 200 times var++;

}

For

The sentence is used to repeat a key-delimited code block. An increment counter is normally used to control and finalize the loop. The for sentence is useful for any repetitive operation, and is often used with arrays to operate on data sets or pins.

// Increase the brightness of an LED using an int PWM pin PWMpin = 13; // an LED on              pin 13

void setup()

{

// no setup required

}

void loop()

{

for (int i=0; i <= 255; i++){ analogWrite(PWMpin, i); delay(10);

}

}

Digital Functions

Oriented to review the status and configuration of digital inputs and outputs.

pinMode()

Sets the specified pin to behave either as an input or output.

Syntax:

pinMode(pin, mode)

pinMode(9, OUTPUT);      // determines digital pin 9 as an output.

digitalRead()

Reads the value of a specified digital pin, HIGH or LOW. Syntax:

digitalRead(pin)

buttonState = digitalRead(9);    // Reading the status of a button on pin 9.

digitalWrite()

Write a HIGH or LOW value on a digital pin. Syntax:

digitalWrite(pin, value)

digitalWrite(9, HIGH);      // Puts pin 9 into HIGH state.

Analog Functions

Ideal for reading or writing analog values.

analogRead()

It reads the value of a specified analog pin. The Arduino board contains a 10-bit analog-to-digital converter with 6 channels. With this, it can map input voltages between 0 and 5 volts to integer values between 0 and 1023. This allows a resolution between readings of 5 volts / 1024 units or 0.0049 volts (4.9 mV) per unit.

Syntax:

analogRead(pin)

int a = analogRead (A0);   // Reads the value of analog pin A0 and stores

//this value in variable "a".

analogWrite()

Write an analog value (PWM wave) on a pin. It can be used to light an LED by varying the brightness or rotate a variable speed motor.

Syntax:

analogWrite(pin, value)

analogWrite (9.134);         // Sends the analog value 134 to pin 9.

Chapter 5

Starter Kit with Arduino Uno R3

In this beginner Kit with Arduino Uno R3, you will explore lots of lessons. It has everything you need to perform all the lessons in this chapter and to start developing your own projects with the Arduino platform, without the need for welding.

Lessons

Lessons developed as an example to use all the components of your Beginner Kit with Arduino Uno R3. In each lesson, you identify the materials needed for its execution, the previous knowledge needed, and what you will learn, the assembly diagram, the programming code, tips, and extra exercises.

Hello World - Blinking

This example shows the most uncomplicated experience you can do with an Arduino to check a physical output: blink an LED.

When you're learning how to program, in most programming languages, the first code you write says "Hello World" on your computer screen. Since the Arduino board does not have a display, we will replace this function by flashing an LED.

What Will I Learn?

- Activate a digital output

- Lighting an ON/OFF LED

- Timing an output signal

- Syntax of an Arduino program

Previous Knowledge

- Digital Signal

- DigitalWrite() function

- The polarity of an LED (page 39)

- Connecting the Arduino board to the computer

Required Materials

- 1 Arduino Uno1 LED

- 1 AB USB cable

This code already comes with the Arduino IDE. You can access in: Archive > Examples > 01. Basics > Blink

We only reproduce here with explanations and comments.

In the following program, the first command is to initialize pin 13 as an output through the line.

pinMode(13, OUTPUT);

In the main loop of the code, you turn on the LED with this command line:

digitalWrite(13, HIGH);

This command directs 5 volts to pin 13 and lights it up. You switch off the LED with the following command:

digitalWrite(13, LOW);

This command removes the 5 volts from pin 13, returning to 0 and turning off the LED. Between power off and on you need enough time for one person to see the difference, so the delay() command tells Arduino not to do anything for 1000 milliseconds, or one second. When you use the delay() command, nothing else happens in this period. Once you have understood the basic examples.

Source Code

/ *

Blinking

Illuminates an LED for one second, and then goes out for the same time repeatedly.

* /

// Sets a name for pin 13: int led = 13;

// It is executed each time Arduino starts: void setup () {

// Initializes the digital pin as output. pinMode (led, OUTPUT);

}

// The loop () function continues to perform while Arduino is powered,

// or until the reset button is pressed.

void loop () {

digitalWrite (led, HIGH); // Lights up the LED

delay (1000); // Wait one second (1s = 1000ms) digitalWrite (led, LOW); // Turn off the LED

delay (1000); // Wait one second (1s = 1000ms)

}

Tips

1. In the Arduino // language it is used to add comments to the line of code, being very useful to explain a syntax or leave a reminder. An example of its use:

digitalWrite(13,LOW);       //Deletes the LED

2. Digital signals (ON and OFF) are present in many sensors. Meet some of them:

- Infrared motion sensor

- Sharp GP2Y0A41SK0F distance sensor - 4 to 30cm

Exercise 1

From the source code presented in this lesson, make the necessary modifications to make the LED stay:

- 3 seconds on and 3 seconds off

- 200 milliseconds on and 500 milliseconds off

Exercise 2

From the same source code, make a new assembly of this lesson and make the necessary modifications to the source code so that the LED is placed on Pin 5 and is on for 2 seconds and off for 1 second.

Note that for any pin other than 13, it is necessary to place a resistor in series with O LED, In this case, a resistor from 330Ω is sufficient.

Button

The button is a component that connects two points of the circuit when it is pressed. In this example, when the button is pressed, the LED lights up.

What Will I Learn?

- Wiring a circuit

- Conditional if/else

- Status of a button

- Read a digital input and write a digital output

Previous Knowledge

- Digital Signal

- DigitalWrite() and digitalRead() function

- Voltage divider

- Conditional, Boolean and comparison operators

Required Materials

- 1 Arduino Uno

- 1 Button

- 1 LED

- 1 Resistor 10kΩ

- 1 AB USB cable Jumpers

- 1 Protoboard

Source Code

/ *

Button

Turns on and off an LED connected to digital pin 13 when a button connected to pin 2 is pressed.

The Circuit:

* LED connected to pin 13 and ground

* button connected to pin 2 from 5V

* 10K resistor connected to pin 2 from ground

* /

// constants are not changed.

// These are used here to define the pin numbers: const int buttonPin = 2; // the pin number of the const int ledPin button = 13; // the pin number of the LED pin

// variables that must change:

int buttonState = 0; // variable to read the state of the button

void setup () {

// initializes the LED pin as output: pinMode (ledPin, OUTPUT);

// initializes the button pin as input: pinMode (buttonPin, INPUT);

}

void loop () {

// reads the button value: buttonState = digitalRead (buttonPin);

// check if the button is pressed.

// if yes, buttonState and HIGH: if (buttonState == HIGH) {

// turn on the LED: digitalWrite (ledPin, HIGH);

}

else {

// turns off the LED: digitalWrite (ledPin, LOW);

}

}

Tips

1. When you are programming with the Arduino software, many of the words you write are reserved for the language. These words are placed in a different color, and it is a hint to check if they are written correctly. As in the example:

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

}

2. In a project with the use of several buttons with different functionalities, it can be useful to work with parts like these:

Colorful touch button set.

Exercise 1

To prevent accidents in the workplace, a safety rule in several industrial types of equipment is to require a user to press two buttons, one with each hand, to drive a machine. This is the case with the cutting machine used in paper mills.

With the following assembly, we can simulate this situation. The LED only illuminates if both circuit buttons are pressed:

Exercise 2

Make one more change to the source code of exercise 1 so that you can light the LED on pin 13 by pressing either button 1 or button 2. When you stop pressing, the LED goes out.

Serial Reading of a Digital Input

This example shows how to monitor the status of a switch by establishing serial communication between your Arduino and the computer via USB.

What will you learn?

- Controlling a digital input

- View data by computer

- Serial Monitor

- Read a digital input

Previous Knowledge

- Digital Signal

- DigitalRead() and Serial.print function

- DigitalWrite() function and comparison operators

Required Materials

- 1 Arduino Uno

- 1 Button

- 1 LED

- 1 Resistor 10kΩ

- 1 AB USB cable Jumpers

- 1 Protoboard

Source Code

In this program, the first thing you will do in the configuration function is to start the serial communication at 9600 data bits per second between Arduino and his computer: Serial.begin (9600);

Remember to place the value 9600 also in the Serial Monitor, as explained earlier.

Then initialize the digital pin 2, the pin that will scan the button as a digital input:

int pushButton = 2;

When the button is pressed, 5 volts will flow freely through its circuit, and when not pressed, the input pin will be grounded. This is a digital input, which means that the key can only have one state (seen by your Arduino as "1", or HIGH) or an off state (seen by your Arduino as a "0", or LOW), with nothing in between.

Now when you open your Serial Monitor in the Arduino environment you will see a stream of "0". if your key is open, or "1" if your key is closed.

/ *

DigitalReadSerial

Read the digital input on pin 2 and print the result on the serial monitor. This example is a public domain.

* /

int pushButton = 2; // pin 2 has a button connected to it. int ledPin = 13; // LED input on pin 13.

void setup () {

// Initialize serial communication at 9600 bits per second: Serial.begin (9600);

pinMode (pushButton, INPUT); // define the button as an input. pinMode (ledPin, OUTPUT); // set the LED as an output.

}

void loop () {

// reads the input pin:

int buttonState = digitalRead (pushButton); if (buttonState == 1) {

digitalWrite (ledPin, HIGH);

} else {digitalWrite (ledPin, LOW);

}

// prints the state of the button: Serial.println (buttonState);

delay (1); // Delay between readings (in milliseconds)

}

Tips

1. The binary system is a positional numbering system in which all quantities are represented based on two numbers, i.e., zero and one (0 and 1). Computers work internally with two voltage levels, so their natural numbering system is the binary system (on, off).

The binary system is the basis for Boolean algebra that allows logical and arithmetic operations using only two digits or two states (yes and no, false and true, all or nothing, 1 or 0, on and off). All digital electronics and computing are based on this binary system and Boole's logic, which allows representing by digital electronic circuits (logical gates) the numbers, characters, perform logical and arithmetic operations. Computer programs are encoded in binary form and stored in media (memories, disks, etc.) under this format.

2. To remember:

- To read a digital signal use: digitalRead(numeroPin).

- To write a digital signal use: digitalWrite(numeroPin, value).

- A digital output or input is always HIGH or LOW.

Exercise 1

Here we will do one more exercise using the same assembly of this Lesson.

Once you have the button working, you often want to do some action based on the number of times the button is pressed. To do this, you need to know when the button changes from off to on, and count how many times this change of state happens. This is called state change detection. Every 4 pulses, the LED will turn on.

/ *

Pulse counter (edge detection)

created on 9/27/2005, modified on 8/30/2011 by Tom Igoe. This example is from the public domain. http://arduino.cc/en/Lesson/ButtonStateChange

* /

// constants are not changed:

const int buttonPin = 2; // the pin number of the const int ledPin button = 13; // the number of the LED pin

// variables that must change:

int buttonPushCounter = 0; // counter for the number of prints of the int button buttonState = 0; // current status of the button

int lastButtonState = 0; // previous button state

void setup () {

pinMode (buttonPin, INPUT); // initialize the button pin as input pinMode (ledPin, OUTPUT); // initialize the digital pin as output Serial.begin (9600); // initialize the serial communication

}

void loop () {

// reads the button value: buttonState = digitalRead (buttonPin);

// compare the current state of the button with its previous state if (buttonState! = lastButtonState) {

// if the button status has been changed, increment the if counter (buttonState == HIGH) {

buttonPushCounter ++; Serial.print ("number of pulses:"); Serial.println (buttonPushCounter);

}

}

// saves the current state of the button as the last state to start the

// next loop

lastButtonState = buttonState;

// Turn on the LED every 4 pulses by checking the if button counter module (buttonPushCounter% 4 == 0) {

digitalWrite (ledPin, HIGH);

It is {digitalWrite (ledPin, LOW);

}

}

Serial Reading of an Analog Input

This example shows how to read a pin from an analog input, map the result to a range of 0 to 255, and use that result to set the PWM modulation of an output pin to turn an LED on and off as a dimmer.

What Will I Learn?

- Control an analog input

- View data by computer

- Multiple states of a potentiometer

- Read an analog input

Previous Knowledge

- Analog signal

- Function analogRead() and Serial.print

Required Materials

- 1 Arduino Uno

- 1 LED

- 1 Resistor 330Ω

- 1 Potentiometer

- 1 AB USB cable Jumpers

- 1 Protoboard

Source Code

/ *

Analog Input, Analog Output, Serial Output

Read the analog input pin, map the result to a range between 0 and 255, and use the result to establish the PWM pulse of the output pin.

It is also possible to follow the result through the Serial Monitor.

The circuit:

- The central pin of the potentiometer connected to the analog pin 0. The side pins of the Potentiometer connected to ground and 5V.

- LED connected to digital pin 9 and ground.

Created on 29/12/2008, Modified on 04/04/2012 by Tom Igoe

This example is a public domain.

* /

// constants are not changed:

const int analogInPin = A0; // Potentiometer analog input

const int analogOutPin = 9; // Analog output where the LED is connected

int sensorValue = 0; // potentiometer reading

int outputValue = 0; // PWM output reading (analog)

void setup () {

// Initialize serial communication: Serial.begin (9600);

}

void loop () {

// sensorValue = analogRead (analogInPin);

// maps the result of the analog input within the range of 0 to 255: outputValue = map (sensorValue, 0, 1023, 0, 255);

// changes the value of the analog output: analogWrite (analogOutPin, outputValue);

// prints the result on the serial monitor: Serial.print ("sensor ="); Serial.print (sensorValue); Serial.print ("\ t output ="); Serial.println (outputValue);

// Wait 2 milliseconds before the next loop: delay (2);

}

Tips

1. Note that the analog inputs of Arduino have a resolution of 10 bits (values from 0 to 1023), but the analog outputs by PWM have a resolution of 8 bits (values from 0 to 1023).

255). This is why you need the 'map' function to 'map' the values so that they remain proportional.

2. Other elements that are also potentiometers:

- Force-sensitive resistor 0.5".

- Square force sensitive resistor.

Command with Serial Communication

Through this lesson, you will control the activation of a relay and an LED from the Serial Monitor of your computer.

What Will I Learn?

- Execute command via Serial Communication

- Controlling the activation of a relay and LED via the computer

- Char variable

Previous Knowledge

- Boolean Variables

- Serial.print

Required Materials

- 1 Arduino Uno

- 2 LEDs

- 1 Resistor 330Ω

- 1 Relay

- 1 AB USB cable Jumpers

- 1 Protoboard

Source Code

// ************************************************ **************************

// * Code for testing Arduino Multilogic triggering relay kit,

// * connected to digital output 2 and GND, monitored by LED 13

// * this code has public domain

// ************************************************ **************************

// initialize a char type variable that uses 1 byte to store

// 1 character char input = 0; int rele = 2; int led = 13;

boolean y = true; // initializes a boolean type variable

void setup () {pinMode (relay, OUTPUT); pinMode (led, OUTPUT);

Serial.Begin (9600); Serial.println ();

Serial.print ("** Code to trigger relay connected to Arduino pin 2"); Serial.println ("via serial monitor **");

Serial.println ("");

Serial.println ("Press 1 and then ENTER to invert the relay state again");

Serial.println ("Awaiting command:");

}

void loop () {

if (Serial.available ()> 0) {input = Serial.read ();

if (input == '1') {

Serial.print ("The re-read is now");

if (y) {

digitalWrite (relay, HIGH); digitalWrite (led, HIGH); Serial.println ("on");

}

else {

digitalWrite (relay, LOW); digitalWrite (led, LOW); Serial.println ("off");

}

y =! y; // alters or value of y, le and e equal to not

}

else {

Serial.println ("Invalid command");

}

}

}

Fade

This example demonstrates the use of the analogWrite() function to turn off a fade LED. AnalogWrite uses a PWM pulse, switching the digital pin on and off quickly, creating a fade effect.

What Will You Learn?

- Switching a faded LED on and off

- Intensify the concept of PWM

Previous Knowledge

- PWM

- AnalogWrite() function

- The polarity of an LED

- Increase and manipulate variables

Required Materials

- 1 Arduino Uno

- 1 LED

- 1 Resistor 330Ω

- 1 AB USB cable Jumpers

- 1 Protoboard

Source Code

/*

Fade

This example shows how to perform a fade on an LED on pin 9 using the analogWrite() function.

This example is a public domain

* /

int led = 9; // LED pin

int brightness = 0; // LED brightness intensity

int fadeAmount = 5; // on how many points to apply the fade on the LED

void setup () {

// sets pin 9 as output:

pinMode (led, OUTPUT);

}

// the loop runs in sequence continuously: void loop () {

// sets the brightness of pin 9:

analogWrite (led, brightness);

// changes the brightness for the next loop: brightness = brightness + fadeAmount;

// reverses the direction of the fade at the end of the fade:

if (brightness == 0 || brightness == 255) {fadeAmount = -fadeAmount;

}

// wait 3

0 milliseconds to see the dimmer effect: delay (30);

}

Tips

Connect the most extended leg of the LED to the digital pin 9 of your Arduino via a

330Ω. Connect the shortest leg of the LED directly to the ground.

After defining that pin 9 will be your ledPin, nothing more should be done in the setup() function of the code.

The analogWrite() function that you will use in the main loop of the code requires two arguments: one telling the function which pin to trigger and the other indicating which PWM value to use.

To run the fade on the LED, gradually increase the PWM value from 0 (entirely off) to 255 (fully on) and then decrease again to 0 to complete the cycle. In the code below, the PWM value is set using a variable called brightness. Each time the loop rotates, it increases the value of the variable according to the fadeAmount.

If brightness is set between the extreme values (0 or 255), then fadeAmount changes to its negative. For example, if fadeAmount is 5, then it is set to -5. If it is -5, then it would be set to 5. The next time you rotate the loop, this change causes the brightness increment also to change direction.

analogWrite() can change the PWM value very quickly, so the delay at the end of the code controls the fade speed. Try to modify the delay value and see how this changes the program.

Loop

Many times you want to repeat an action on a series of pins and do something different for each one. In this case, the example flashes 6 LEDs using the for() loop function to circulate back and forth between pins 2 and 7. The LEDs turn on and off in sequence, using both the digitalWrite() and delay() functions.

We can call this example "Super Machine" by recalling the television series of the 80s in which the famous actor David Hasselhoff directed his Pontiac with artificial intelligence. The car was turbocharged with various LEDs of various possible sizes to reproduce bright effects.

We thought it would be interesting to use this metaphor of the "Super Machine" to learn more about sequential programming and good programming techniques for the I/O information on the board.

What Will You Learn?

- for() loop function

- digitalWrite()

- delay()

Required Materials

- 1 Arduino Uno6 LEDs

- 1 ABJumpers USB cable

- 6 Resistors 330Ω

Source Code

The code below starts using the for() loop function to designate digital pins 2 to 7 as outputs of the 6 LEDs used. In the main loop of the code, two for() loops are used to increase the loop by going through the LEDs, one by one, from pin 2 to pin 7. Once pin 7 is lit, the process reverses, going back through each LED.

For more information on the for() function, see page 82.

/ *

Loop

Demonstrates the use of the for () loop function.

It lights up several LEDs in sequence, and then the coating.

The circuit:

* LEDs between pins 2 to 7 and ground

Created in 2006 by David A. Mellis

Modified on August 30, 2011, by Tom Igoe

This code is a public domain. http://www.arduino.cc/en/Lesson/ForLoop

* /

int timer = 100; // The higher the value, the slower the sequence of LEDs. void setup () {

// Use for loop to initialize each pin as output: for (int thisPin = 2; thisPin <8; thisPin ++) {

pinMode (thisPin, OUTPUT);

}

}

void loop () {

// loop from lowest to highest pin: for (int thisPin = 2; thisPin <8; thisPin ++) {

// Connect this pin: digitalWrite (thisPin, HIGH); delay (timer);

// turns off this pin: digitalWrite (thisPin, LOW);

}

// loop from highest to lowest pin: for (int thisPin = 7; thisPin> = 2; thisPin--) {

// Connect this pin: digitalWrite (thisPin, HIGH); delay (timer);

// turns off this pin: digitalWrite (thisPin, LOW);

}

}

LDR Sensor

In this lesson, we will use an LDR (Light Dependent Resistor) to simulate a light compensation of 5 levels, that is, depending on whether there is more or less light focusing on the sensor, the system turns on or off a series of LEDs.

This program could be used in a lighting system with five lines of light that

they light up as the sun goes down, progressively compensating for the lack of light.

In addition, a potentiometer adjusts the minimum critical light level from which the circuit will activate.

What Will You Learn?

- Serial reading of an analog sensor

- Using an analog reading

- Arduino AREF pin

Previous Knowledge

- DigitalWrite() function

- Conditional if/else

Required Materials

- 1 Arduino Uno

- 1 LDR

- 5 LEDs

- 1 AB USB

- 5 Resistors 330Ω

Source Code

/ *

LDR sensor

Connect an LDR to an analog input to control five outputs depending on ambient light.

* /

// Save the data collected by the LDR sensor: intLDR value = 0;

// Set the input pins of the LEDs:

int Ledpin1 = 12; int Ledpin2 = 11; int Ledpin3 = 10; int Ledpin4 = 9; int Ledpin5 = 8;

// Set LDR sensor input pin

int pinLDR = 0;

void setup ()

{

Serial.Begin (9600);

// Set the LED output pins: pinMode (Ledpin1, OUTPUT); pinMode (Ledpin2, OUTPUT); pinMode (Ledpin3, OUTPUT);

pinMode (Ledpin4, OUTPUT); pinMode (Ledpin5, OUTPUT);

// Defined the use of an external reference:

analogReference (EXTERNAL);

}

void loop ()

{

// Save the reading value of a variable: LDR value = analogRead (pinLDR); Serial.println (LDR value);

// Definition of the control pattern of the LEDs:

if (LDR value> = 1023)

{

digitalWrite (Ledpin1, LOW); digitalWrite (Ledpin2, LOW); digitalWrite (Ledpin3, LOW); digitalWrite (Ledpin4, LOW); digitalWrite (Ledpin5, LOW);

}

else if ((LDR value> = 823) & (LDR value <1023)))

{

digitalWrite (Ledpin1, HIGH); digitalWrite (Ledpin2, LOW); digitalWrite (Ledpin3, LOW); digitalWrite (Ledpin4, LOW); digitalWrite (Ledpin5, LOW);

}

else if ((LDR value> = 623) & (LDR value <823)))

{

digitalWrite (Ledpin1, HIGH); digitalWrite (Ledpin2, HIGH); digitalWrite (Ledpin3, LOW);

digitalWrite (Ledpin4, LOW); digitalWrite (Ledpin5, LOW);

}

else if ((LDR value> = 423) & (LDR value <623)))

{

digitalWrite (Ledpin1, HIGH); digitalWrite (Ledpin2, HIGH); digitalWrite (Ledpin3, HIGH); digitalWrite (Ledpin4, LOW); digitalWrite (Ledpin5, LOW);

}

else if ((LDR value> = 223) & (LDR value <423)))

{

digitalWrite (Ledpin1, HIGH); digitalWrite (Ledpin2, HIGH); digitalWrite (Ledpin3, HIGH); digitalWrite (Ledpin4, HIGH); digitalWrite (Ledpin5, LOW);

}

else

{

digitalWrite (Ledpin1, HIGH); digitalWrite (Ledpin2, HIGH); digitalWrite (Ledpin3, HIGH); digitalWrite (Ledpin4, HIGH); digitalWrite (Ledpin5, HIGH);

}

}

Tips

When the Arduino receives an analog signal, it converts it to digital in 1024 parts. This operation is standard since Arduino thinks that the signal he will receive varies between 0v and 5v, which gives us a value for each part of approximately 4.88 mV.

But we can say no, that really the system will work between 0v and 3v, thus getting 1024 parts distributed between 0v and 3v, which gives us a value for each part of 2.9 mV, i.e., a much higher resolution. The distribution of these values we will divide equally in our program to make a progressive activation of the lighting lines.

If we set the reference too low, the LEDs start working with less ambient light than if we set a higher signal, remember:

More light = less resistance = more Volt less light = more resistance = less Volt less

This control will be done via a potentiometer, where we can calibrate the system through the ambient light.

pinMode(EXTERNAL);

With this instruction, we are telling our Arduino not to use the reference voltage (+5V) but to apply it through the AREF pin.

Thermistor

In this lesson, you have to use a Thermistor (Temperature Dependent Resistor) to do a temperature reading.

The result, in degrees Celsius, we will see through the Serial Monitor of Arduino's IDE.

What Will I Learn?

- Serial reading of an analog sensor (Thermistor)

- Using an analog reading

- Float variable

Previous Knowledge

- analogRead function

- Serial.print

Required Materials

- 1 Arduino Uno

- 1 Thermistor

- 1 Resistor 1KΩ

- 1 AB USB cable Jumpers

- 1 Protoboard

Source Code

Note that it is not an accurate thermometer, just an approximate example based on empirical data.

Connect 1k resistor from A0 to ground and + 5V thermistor to A0 * /

#define pin_termistor A0

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

}

void loop (void) {float reading; float reading1;

reading = analogRead (pin_termistor); Serial.print ("Read pin A0 ="); Serial.println (read);

reading1 = (reading * 0.2027) -82; Serial.print ("Temperature approx. Celsius ="); Serial.println (reading1);

Serial.println (""); delay (2500);

}

Tips

There are two types of thermistors:

- NTC (Negative Temperature Coefficient) - thermistors whose coefficient of resistance variation with temperature is negative: resistance decreases with temperature increase.

- PTC (Positive Temperature Coefficient) - thermistors whose coefficient of resistance varies with the temperature is positive: the resistance increases with the increase of the temperature according to the characteristic curve/table of the thermistor, its resistance value can decrease or increase in a greater or lesser degree in a certain temperature range.

Thus, some can serve as overheat protection by limiting the electrical current when a certain temperature is exceeded. Another application is the measurement of temperature (in motors, for example) because we can, with the thermistor, obtain a variation of electrical resistance in the function of the variation of temperature.

DC Motor

In this lesson, we will control a DC motor through Arduino. The push of the button will start our engine.

What Will I Learn?

- Digital one-button reading

- Controlling a DC motor with Arduino

Previous Knowledge

- DigitalWrite() function

- DigitalRead() function

- Conditional if/else

Required Materials

- 1 Arduino Uno

- 1 DC motor

- 1 Resistor 330Ω

- 1 Resistor 15Ω

- 1 AB USB cable

Source Code

// Connect motor on pin 2 in series with a 15 ohm resistor

// to limit the current to 40mA just not to overload the Arduino

const int motorPin = 2; const int buttonPin = 7; int buttonState = 0;

void setup () {pinMode (buttonPin, INPUT); pinMode (motorPin, OUTPUT);

}

void loop () {

buttonState = digitalRead (buttonPin); if (buttonState == HIGH) {

digitalWrite (motorPin, HIGH);

}

else {

digitalWrite (motorPin, LOW);

}

}

Tip

We can change the direction of rotation of a DC motor by simply reversing the direction of the current. With the same assembly of this lesson, the test reverses the connections of the motor and verify that it will start to rotate in the opposite direction.

LCD

The LCD is an important part of projects where you need to visualize the reading of a sensor or even to transmit information to the user.

In this exercise, you will learn how to connect the 2x16 LCD Display of your Kit, which already comes with the welded pins.

What Will You Learn?

- Connect your LCD to Arduino Uno

- Programming phrases to appear on the LCD

- Adjust the brightness of the display with a potentiometer

- Know the functions of the LiquidCrystal.h library

- Use the functions:

- LCD.print

- LCD.setCursor

- scrollDisplayLeft()

- scrollDisplayRight()

Required Materials

- 1 Arduino Uno

- 1 LCD display

- 1 Potentiometer

- 1 AB USB cable Jumpers

- 1 Protoboard

Source Code

/ *

LiquidCrystal Multilogic Code Library

This library works with all displays compatible with the

Hitachi HD44780 driver.

Circuit:

* LCD RS pin on digital pin 12

* LCD pin Enable on digital pin 11

* LCD pin D4 pin on digital pin 5

* LCD pin D5 pin on digital pin 4

* LCD pin D6 pin on digital pin 3

* LCD pin D7 pin on digital pin 2

* LCD pin R / W on ground

* 10K Trimpot:

+ 5V on + 5V

* Earth on earth

* wiper to LCD VO pin (pin 3)

Public domain code based on the original lesson: http://www.arduino.cc/en/Lesson/LiquidCrystal

* /

// Includes library code: #include <LiquidCrystal.h>

// Initialize the library and define the pins used

LiquidCrystal lcd (12, 11, 5, 4, 3, 2);

void setup () {

// define the number of columns and lines of the display:

lcd begin (16, 2);

// Send the message to the display. lcd print ("Multilogic");

lcd setCursor (0.1); // Positions the cursor on the first column (0) and on the second line (1) of the Display.

lcd print ("shop");

}

void loop () {

}

Tips

If your project needs more space to view information or a different LCD, get to know these other options:

- 2x40 LCD - white on blue

- 2x16 LCD display - RGB background

Exercise 1

The Arduino website offers several other projects with the LiquidCrystal.h Library. Here we will do one more exercise using the same assembly of this Lesson.

In this exercise, you can also modify the original text and control how long your text stays fixed and how long it scrolls to the right or left.

/ *

LiquidCrystal Library - scrollDisplayLeft () and scrollDisplayRight ()

LiquidCrystal Multilogic Code Library

This library works with all displays compatible with the

Hitachi HD44780 driver

This code writes "Multilogic Shop" on the LCD and uses scrollDisplayLeft () and scrollDisplayRight () to pass the text.

Circuit:

* LCD RS pin on digital pin 12

* LCD pin Enable on digital pin 11

* LCD pin D4 pin on digital pin 5

* LCD pin D5 pin on digital pin 4

* LCD pin D6 pin on digital pin 3

* LCD pin D7 pin on digital pin 2

* LCD pin R / W on ground

* 10K Trimpot:

+ 5V on + 5V

* Earth on earth

* wiper to LCD VO pin (pin 3)

Library originally added 18 Apr 2008 by David A. Mellis

library modified 5 Jul 2009 by Limor Fried (http://www.ladyada.net) example added 9 Jul 2009 by Tom Igoe

modified 22 Nov 2010 by Tom Igoe

Public domain code based on the original lesson: http://arduino.cc/en/Lesson/LiquidCrystalScroll

* /

// Includes library code:

#include <LiquidCrystal.h>

// Initialize the library and define the pins used

LiquidCrystal lcd (12, 11, 5, 4, 3, 2);

void setup () {

// define the number of columns and rows:

lcd begin (16, 2);

// Send the message to the display. lcd print ("Desired Text"); delay (2000);

}

void loop () {

// walks 16 positions for the text to exit the display on the left:

for (int positionCounter = 0; positionCounter <16; positionCounter ++) {

// walk a position to the left: lcd. scrollDisplayLeft ();

// Wait a moment: delay (250);

}

// walks 32 positions for the text to exit the display on the right:

for (int positionCounter = 0; positionCounter <32; positionCounter ++) {

// walk a position to the right: lcd. scrollDisplayRight ();

// Wait a moment: delay (250);

}

// walks 16 positions to the left to move back to the center: for (int positionCounter = 0; positionCounter <16; positionCounter ++) {

// walk a position to the left: lcd. scrollDisplayLeft ();

// Wait a moment: delay (250);

}

// delay at the end of the full loop:

delay (2000);

}

Typing into the LCD

Transmitting information or custom commands through the LCD can be useful and necessary in many projects or activities.

In this lesson, you will be able to control the text that appears on display through the Serial Monitor of the Arduino IDE in a fast and fun way.

What Will You Learn?

- Connect your LCD to Arduino Uno

- Customize phrases to appear in the LCD

- Using the Serial Monitor to enter texts

Required Materials

- 1 Arduino Uno

- 1 LCD display

- 1 Potentiometer

- 1 AB USB cable Jumpers

- 1 Protoboard

Source Code

/ *

This code sends a text entered via USB to the Circuit display:

* LCD RS pin on digital pin 12

* LCD pin R / W on pin 11

* LCD pin Enable on digital pin 10

* LCD pin D4 pin on digital pin 5

* LCD pin D5 pin on digital pin 4

* LCD pin D6 pin on digital pin 3

* LCD pin D7 pin on digital pin 2

* 10K Trimpot:

+ 5V on + 5V

* Earth on earth

* wiper to LCD VO pin (pin 3)

* /

#include <LiquidCrystal.h>

LiquidCrystal lcd (12, 11, 10, 5, 4, 3, 2); void setup ()

{

Serial. begin (9600); lcd begin (2, 20);

lcd clear (); lcd setCursor (0,0); lcd print ("Multilogic"); lcd setCursor (0.1); lcd print ("shop");

}

void loop ()

{

if (Serial.available ())

{

// f reads through the serial monitor // char cr = Serial. read ();

// determine a character to clear the screen /// if (cr == '%')

{

lcd clear ();

}

// determine a character to jump to the bottom // else line if (cr = '>')

{

lcd.setCursor (0.1);

}

else

{

// if the typed character doesn't clear or skip line goes to display ///

// does not accept accent // lcd. write (cr);

}

}

}

Piezo as Analog Output

In this lesson, we will use a piezo as analog output. We use the possibility of processors to produce PWM signals to play music or emit sounds.

What Will I Learn?

- Connect your electric piezo to Arduino Uno.

Required Materials

- 1 Arduino Uno

- 1 Electric piezo

- 1 AB USB cable Jumpers

- 1 Protoboard

Tip

Do you want to amplify the sound of the piezo?

Place the back of the piezo (the whole golden part) on the bottom of a can of soda or chocolate can, and you will hear the loudest sound.

Use your creativity and test that other elements can amplify the sound of the piezo.

Scroll Bar with Processing

In this lesson, we will use Arduino's serial communication to interact with a Processing program running on the computer.

What Will You Learn?

From a graphical interface in Processing running on the computer, perform interactions with Arduino.

Previous Knowledge

Have the latest version of Processing installed and running on your computer.

Required Materials

- 1 Arduino Uno R3

- 5 LEDs

- 5 330Ω Resistor

- 1 Protoboard

- 1 USB - AB Cable and premium Jumpers. Or you can use the Arduino Uno R3 Starter Kit components.

Source Code

/ *

Scroll Bar with Processing

* /

char val; // variable to save the value received by the serial interface

char val_old; // variable to store the previous value received by the

serial interface

// setup function runs only once when program execution starts void setup () {

// we initialize the pins from 2 to 6 as pinMode (2, OUTPUT) outputs;

pinMode (3, OUTPUT);

pinMode (4, OUTPUT); pinMode (5, OUTPUT); pinMode (6, OUTPUT);

// we initialize the serial communication with a speed of 115200 baud Serial. begin (115200);

}

// the loop function is executed indefinitely

void loop () {

if (Serial. available ()) {// checks if data is available for reading

val = Serial. read (); // read the data and store it in val

}

if (val! = val_old) {// acts only if there is a change in the value of val

alloff (); // perform the alloff function that erases all LEDs for (int i = 2; i <(int (val) +2); i ++) {

// causes the value of i to vary from 2 to val + 2

// note that val stores a character and we need

// of the int (val) function to convert to a digitalWrite (i, HIGH) numerical value; // turns on the LED on pin i

}

val_old = val; // saves the value of val in val_old

}

}

void alloff () {// function to turn off all LEDs

for (int i = 2; i <7; i ++) {// causes i to vary from 2 to 6 digitalWrite (i, LOW); // turns off the LED on pin i

}

}

Arduino - Thermostat

In this lesson, we will set up a simple experimental thermostat with Arduino. This mounting causes a relay and an LED to turn on when the temperature drops below a set minimum value or turn off when it exceeds a set maximum temperature.

Note that temperature measurement is empirical and should not be used as an accurate instrument.

What You Will learn?

- Use your Arduino to control devices from the ambient temperature reading.

- For this experiment, you can vary the temperature of the sensor just by holding it with your fingertips.

- Note that just as we are using a relay to light an LED, you could drive any other device (a motor, for example) within the relay's power range.

Necessary Materials

- 1 Arduino Uno R3

- 2 LEDs

- 1 Relay

- 1 Resistor 1kΩ

- 1 Resistor 300Ω

- 1 Thermistor

- 1 Protoboard

- 1 USB - AB Cable and Premium Jumpers. Or you can use the Arduino Uno R3 Starter Kit components.

Source Code

// Example of a simple experimental Arduino thermostat

// This setup makes the relay and a led

// turn on when the temperature drops below a minimum

// and turn off when it exceeds a maximum

// The temperature measurement is an empirical approximation

// Do not use an accurate instrument, but rather as a

didactic // thermostat model.

// relay connected to digital pin 2

// Led connected to digital pin 13

// resistive divider of thermistor connected to pin A0 analog

// declaration of variables:

#define pin_termistor A0

int rele = 2;

int led = 13;

float reading;

float read1;

// set acting mode:

void setup (void) {

pinMode (relay, OUTPUT);

pinMode (led, OUTPUT);

Serial.Begin (9600);

}

// infinite loop:

void loop (void) {

read = analogRead (pin_termistor);

Serial.print ("Read pin A0 =");

Serial.println (read);

read1 = (read * 0.2027) -85; // Calculate the temp. approximate

if (read1 <32) // set trigger temperature

{

digitalWrite (relay, HIGH); // relay

digitalWrite (led, HIGH); // turn on Led

}

if (read1> 35) // set cutoff point

{

digitalWrite (relay, LOW); // turn off

digitalWrite relay (led, LOW); // turn off Led

}

Serial.print ("Temperature approx. Celsius ="); // send and temp. for serial monitor

Serial.println (read1) ;

Serial.println ("");

delay (2500);

}

Chapter 6

If Statement with Arduino, Control the Execution of your Code

If conditional statements with Arduino are the most used in programming Maker projects. They serve to make your program do one thing or another, depending on each situation.

Imagine the loop () function of an Arduino code that is repeated indefinitely within our program. It is where things really happen. It repeats very fast, and the speed depends directly on the clock of the microcontroller CPU.

If we talk about Arduino UNO, its speed is 20 MHz, that is, 20,000,000 instructions per second. And on an ESP8266, the clock speed is 80 MHz (80,000,000 instructions per second).

Surely you are wondering if the same code that is inside the loop () function is repeated over and over again, why do we get different results?

Well, it is largely due to the conditional statements if with Arduino. In this lesson, you will learn the following concepts:

- Syntax of the if-else and else if statement

- Comparison operators (>,> =, <=, ==,! =)

- Boolean operators (||, &&,!)

And of course, you will learn how to use the if statement with Arduino through a case study.

Take the plate out of the box, and let's start with this chapter.

What will you learn in this chapter?

- if with Arduino necessary material

- Syntax of the if statement with Arduino

- Comparison operators in if statements with Arduino

- Example if statement with Arduino

- Boolean operators if with Arduino

- if-else with Arduino

- Example if-else statement with Arduino

- else if with Arduino

- Example else if statement with Arduino

If with Arduino - Necessary Material

Although we will see all this later, in this lesson with the if-else and Arduino statements, you will need the following material.

- An Arduino UNO or derivative. Any compatible board can be worth even an ESP8266.

- A protoboard to connect the components.

- A potentiometer does not matter the value of the resistance.

- And cables to connect everything.

The circuit we will use is very simple. It only requires a potentiometer connected to an analog pin of the Arduino board. The electrical scheme would be as follows.

Let's now see the syntax that is hidden behind the if-else statement with Arduino.

Syntax of the if Statement with Arduino

The syntax of the if statement with Arduino is very simple. We begin by writing the reserved word if (it is translated as conditional). Then in brackets, we put the condition and finally open and close the keys.

if (Condition) {

// Everything we put here will be executed

// only if the condition is met

}

The condition is what will cause the code between the keys to be executed. If it is true, the Arduino code flow will enter the keys and execute everything inside. But of course, what is a condition?

Imagine you tell your child, "If you pass all the subjects, I will give you a bicycle." That would be a condition. Within the parentheses will be the condition or conditional sentence. It is something that can be evaluated as true or false (in English, it is true or false).

If your child passes all subjects, it is true (true) and therefore has a bicycle. If your child does not pass all subjects is false (false) and therefore runs out of bicycle.

If you approve_all then

buy_bikes ()

End yes

These conditions are called Boolean due to the great English mathematician George Boole, creator of Boolean logic. With this logic, there are only two possible states 0 or 1 that are equivalent to false (false) and true (true).

Ok, we are clear that an if statement with Arduino allows us to execute code depending on a condition. Now let's see how we can make conditional with the comparison operators.

Comparison Operators in if Statements with Arduino

Really, for something to be true or false, we need to compare it with something. Typically, the conditional statement if with Arduino with numbers is used, but other data can be used.

We can compare temperature, atmospheric pressure, ultraviolet radiation, time, intensity, voltage, water level, and any magnitude that can be measured.

Something that I think we all understand is temperature. For example, we can write a code where, depending on the temperature, a servo motor that activates a fan moves.

if (temperature > 25) {

Servo.move (30);

}

In this case, we are saying that whenever the temperature is greater than 25, move a servomotor. But we could also have programmed if the temperature is less than 30 or if it is greater than or equal to 25.

More or less I think you're getting where I want to go

All of the above are comparisons. All we do is compare two values and evaluate whether it is true or false. To compare, comparison operators are used.

With the if statement with Arduino, you can use six comparison operators:

- Greater than

- <Less than

- = Greater than or equal to

- <= Less than or equal to

- == Equal to

- ! = Different from

I am sure that more than one comparison operator sounds to you. They are often used to express mathematical formulas.

The first 4 (greater than, less than, greater than or equal to or less than or equal to) are quite explicit. However, the last two (equal to and different from) require a little explanation.

Let's see some examples of each of them.

Comparison operator greater than (>)

As long as the number on the left is greater than the number on the right, the condition of the if statement with Arduino is true. Otherwise, it is false.

- 50> 10 -> true

- 15> 80 -> false

Comparison operator less than (<)

As long as the number on the left is less than the number on the right, the condition of the if statement with Arduino is true. Otherwise, it is false.

- 10 <50 -> true

- 80 <15 -> false

Comparison operator greater than or equal to (> =)

As long as the number on the left is greater than or equal to the number on the right, the condition of the if statement with Arduino is true. Otherwise, it is false.

- 50> = 50 -> true

- 50> = 49 -> true

- 15> = 90 -> false

Comparison operator less than or equal to (<=)

As long as the number on the left is less than or equal to the number on the right, the condition of the if statement with Arduino is true. Otherwise, it is false.

- 50 <= 50 -> true

- 49 <= 50 -> true

- 90 <= 15 -> false

Comparison operator equal to (==)

As long as the number on the left is the same as the number on the right, the condition of the if statement with Arduino is true. Otherwise, it is false.

- 20 == 20 -> true

- 15 == 20 -> false

Look at the operator symbol equal to (==), why do you use a double equal sign? Do you need to verify twice that they are equal? The answer is simpler than it seems.

The equal sign already has a function, that of the assignment. When we assign a value to a variable, for example. The double equal sign is used as an equality comparator so as not to confuse the compiler since otherwise, I would not know if we are comparing or assigning a value.

Comparison operator other than (! =)

As long as the number on the left is different than the number on the right, the condition of the if statement with Arduino is true. Otherwise, it is false.

- 20! = 10 -> true

- 10! = 10 -> false

This comparison operator is the opposite of equal to.

Although in the examples I am using numbers, in the conditions of the if statements with Arduino, you can also use variables as we will see in the examples that follow.

With this, we have everything we need to start using the if statement with Arduino. Let's see a very simple example.

Example if Statement with Arduino

In this example, we are going to use the if statement with Arduino using the electric scheme of the potentiometer that we have seen at the beginning of this chapter. The idea is to be able to show by the serial monitor when the analog value exceeds a value.

I remind you that the analog pin has a range of values that goes from 0 to 1023 in an Arduino UNO. When we have 0V at the input, analogRead returns 0. When we have 5V at the input, analogRead returns 1023.

The code must be able to display text on the serial monitor when it exceeds 300.

// Variable with analog pin

const byte Analogpin = A0;

void setup () {

// Start serial communication

Serial.begin (9600);

}

void loop () {

// Read analog pin

int value = analogRead (Analogpin);

// Show analog pin value

Serial.println (value);

// If statement with Arduino

if (value> 300) {

// Show text by serial monitor

Serial.println ("Value exceeded");

}

// 100 ms delay

delay (100);

}

The code begins by declaring a constant variable of the type byte called Analogicpin. This variable contains the analog pin where the potentiometer is connected.

In the setup () function, we initiate serial communication with Serial.begin ().

In the loop () function, the first thing to do is read the analog pin with the analogRead function. The result is stored in the value variable of type int. This value is shown by the serial monitor with the Serial.println () function.

Then begins the statement of the if statement with Arduino. As we have seen, you put the reserved word if and then open and close parentheses. Within the parentheses goes the condition.

If we want to know if the value of the analog pin is greater than 300, we use the comparison operator greater than (>). On the left, you have the value you want to evaluate, and on the right, the threshold value that determines the condition.

Then open and close keys and inside is the code that will be executed if the if condition with Arduino is true. In this case, use the  Serial.println () statement to display a text on the serial monitor (no matter what).

Finally, put a delay of 100 milliseconds so that we can appreciate it when you write on the serial monitor and when not.

Now, if you load the code to the board, you will see how the analog pin value appears, and whenever it is above 300, it will show the text Value exceeded on the serial monitor.

It has been simple, right? Try different comparison operators and see when the text appears on the serial monitor.

Now think about how you would do it if you want the code to run when it is between two values. For example, if the value is between 300 and 500, it shows text on the serial monitor.

With only the if statement with Arduino, you won't be able to do it. For this, you need Boolean operators.

Boolean Operators if with Arduino

A Boolean operator allows us to make combinations between conditions within an if in Arduino. This programming tool is very powerful and is used in many cases.

There are 3 Boolean operators

- || or (0)

- && and (y)

- ! not (no)

As I said, they serve to combine conditions. For example, you can know if the value obtained from analogRead is between 300 and 500.

It's something like when you press two keys on your keyboard. If you press the c key, write that letter in a document, for example. But if you press the control key (Ctrl) and the c key, what you do is copy what you have selected. More or less, it is something similar.

We are going to see each of these Boolean operators with examples so that you understand it better.

Boolean Operator or (||)

It can be translated as "or this or that." It is represented with two vertical lines (||) that you find on key 1 of the keyboard. To use it, you must first press Alt Gr and then the 1 key.

This operator makes the if condition with Arduino true if either of the two or more conditions are met. For example, if we have this code:

if (value> 300 II value <200) {

// Show text by serial monitor

Serial.println ("Value exceeded");

}

We are saying that whenever the value is greater than 300 or that the value is less than 200, display a text on the serial monitor. This means that whenever the value is between 201 and 299, it will not show any text.

In the rest of the cases, it will show the text on the serial monitor.

Boolean Operator and (&&)

It can be translated by "this and that." It is represented by two ampersands (&&) symbols found on key 6 of the keyboard. Pressing capital letters and 6, you can use it in your codes.

This operator makes the if condition with Arduino true only if both or several conditions are met. For example, if we have the code:

if (value> 300 && value <500) {

// Show text by serial monitor

Serial.println ("Value exceeded");

}

It means that it will only be true if the value is greater than 300, and the value is less than 500. This gives us a range of values between 301 and 499 (don't forget that the symbols> and <exclude the numbers on the right).

Therefore, only when you are in that range will you show the text on the serial monitor.

Boolean Operator not (!)

It translates as "no." It is represented by the final exclamation mark (!) Located on the 1 key. You can use it by pressing the uppercase key plus the 1 key.

What this operator does is something strange. If an expression is true, it returns false, and if it is false, it returns true.

To understand the following example, you also have to understand what is true and what is false. They are still two states, like the binary code of which I have spoken to you before. We can have a 0 (false) or a 1 (true).

But the reality is that there are more numbers. The question is, is 2 true or false? Boolean data types are always false as long as it is 0. Otherwise, it is true. Therefore 2 and any other numbers are true if evaluated in a condition. This is only a reminder.

In a digital pin, we also have two values, LOW and HIGH. If you enter the Arduino core code, you can verify that these two reserved words are actually two constants whose value is 0 for LOW and 1 for HIGH.

Therefore, if we have a digital pin connected to a button, and the input is 0V, the status will be LOW. If we store that value in a variable, we could evaluate its value if it is false or true in an if conditional statement with Arduino.

For example, it can help us to know if a button is not pressed. In normal use, when pressed, it will have a HIGH state that, as we have seen, is true. While when not pressed, it has a LOW status, false.

boolean button = digitalRead (Buttonpin),

// If the button is false (equal to 0) everything is true

if (! button1) {

// Turn on the LED

digitalWrite (led Warning, HIGH);

}

This would be the way we would detect if a button is not pressed. In this case, it will pass inside the if with Arduino and execute the code inside.

Other Considerations of Boolean Operators with an Arduino if

Finally, I want to add that you can join as many conditions as we want to an if with Arduino. It is convenient, as far as possible, not to add many conditionals as this would make our code unreadable.

Also, note the use of the not (!) Operator with other comparison operators. For example, the same expression can be expressed in different ways thanks to the not operator. If you want to know if a number is between 300 and 500, you can use these two conditions:

- (number> = 300 && number <= 500)

- ! (number <300 && number> 500)

These two expressions return the same value for the same number.

Now we will continue to see how you can execute different pieces of code depending on different conditions with if-else in Arduino.

if-else with Arduino

So far, what we have seen is that if it meets a condition, it executes the code inside an if with Arduino. But what if we have more than one condition? For example, if the temperature is greater than 25, it moves the servo motor 135º if it is less than 25, it moves the servo motor 45º.

With what we know so far, we could do two if with Arduino.

if (temperature> 25) {

Servo.move (135);

}

if (temperature <= 25) {

Servo.move (45);

}

It would not be bad, but there is a more optimal way to do it, using the else conditional statement with Arduino.

Else can be translated as "yes no." It is always linked to a conditional statement if Arduino can never go alone. Therefore if-else would be translated as if the condition is met, execute the code if you do not execute this other code.

It is logical to think that when we are evaluating the same variable, it cannot have two values. In this case, the temperature is either greater than 25 or less than or equal to 25, and there is no other.

The biggest advantage of using if-else with Arduino is that we will make our code more efficient. In the first case (with two if), the two conditions will always be evaluated even if one of them is true.

If, for example, the temperature is 27º when it reaches the first if, since the temperature is greater than 25, it will execute the code inside. When finished, it will exit the if and go to the next if. Check if the temperature is less than or equal to 25, something absurd if nothing has changed within the first if.

This is where, if-else, comes into play.

if (temperature> 25) {

Servo.move (135);

} else {

Servo.move (45);

}

The second if is replaced with the condition by an else. This conditional statement does not have any condition. That is, if the previous condition or conditions are not met, it will always enter through the else.

The advantage is that if the first condition is met, you will stop checking the rest of the conditions. This programming structure is called nested if.

Be very careful with these types of structures since they can lead us to what is known as the spaghetti code. It is such an obfuscated code that it looks like a plate of spaghetti.

Let's see it with an example.

Example if-else statement with Arduino

We will continue with the same electric scheme of the potentiometer. The idea with this practical exercise is to turn on the LED integrated with the Arduino board (it is connected to pin 13) when the analog value exceeds 500. Otherwise, turn off the LED.

The code would be as follows.

// Variable with analog pin

const byte Analogicpin = A0;

// Variable LED pin

const byte Ledpin = 13;

void setup () {

// Start serial communication

Serial.begin (9600);

// Pin mode

pinMode (Ledpin, OUTPUT);

}

void loop () {

// Read analog pin

int value = analogRead (Analogicpin);

// Show analog pin value

Serial.println (value);

// If statement with Arduino

if (value> 500) {

// Turn on LED

digitalWrite (Ledpin, HIGH);

} else {

// Turn off LED

digitalWrite (Ledpin, LOW);

}

// 100 ms delay

delay (100);

}

The first part of the code is the declaration of variables. We need two to store the number of pins. They are constants of the byte type.

The Analogicpin variable stores the analog pin where the potentiometer is connected, pin A0.

The Ledpin variable stores the digital pin where the LED is connected, pin 13.

In the setup () function, we started the serial communication with Serial.begin () and put the LED pin in OUTPUT mode.

Within the loop () function, we read the analog pin with analogRead () and store it in the variable of the int value type. Then we show it by the serial monitor.

On the next line begins the conditional statement if-else with Arduino. As always, we put the word if and in brackets of the condition. In this case, it is if value (it is the value obtained from the analog pin) is greater than 500, then it enters inside the if.

Between braces, we put the code that we want to be executed when the condition is met. In this case, the LED is lit with the digitalWrite () statement.

Then we put the else and between braces the code that we want to be executed. In this case, the LED goes out with the digitalWrite () statement.

Finally, a delay of 100 ms so that we can follow what is shown by the serial monitor.

If you load the code to the board and play with the potentiometer, you will see how it turns on and off when you go over 500 or lower than 500.

The last thing that remains to be seen is if we want to have three or more conditional sentences if-else nested. We can do that with else-if, another way of writing an if with Arduino.

else if with Arduino

The else if conditional statement with Arduino will allow us to have two or more conditions within a nested if block.

The else conditional statement is very useful in cases where we only have two possibilities, but what happens if, for example, you want the LED to flash when the value of the potentiometer is greater than 800. When it is between 501 and 800, it stays on, and when it is less than or equal to 500, it turns off.

We can choose to put everything full of if without nesting, i.e., separate if statements. We have already seen that this is not a good idea when we are working with the same variable.

The else statement falls short because it does not allow a condition to be set.

But there is the else if statement which, as with the else statement, is always linked to an if with Arduino. It could be translated as if you have not fulfilled the above, check if this other is fulfilled.

It really is as if it were another if, but by putting the reserved word else in front, we are joining all the if. The syntax is very similar.

Else if (condition) {

// code to execute

}

First, we put the else, then if and in brackets the condition. Between the keys, the code we want to be executed when the condition is met.

For example, this would be the code if we want to control 3 ranges on an analog pin.

// If statement with Arduino

if (value> 800) {

// Flashing LED

digitalWrite (Ledpin, HIGH);

delay (500);

digitalWrite (Ledpin, LOW);

} else if (value <= 800 && value> 500) {

// Turn on LED

digitalWrite (Ledpin, HIGH);

} else {

// Turn off LED

digitalWrite (Ledpin, LOW);

}

The first if checks if the value of the analog pin is greater than 800. Since it only has the symbol greater than, it will start at 801. From 801 to 1023 it will execute the code inside, that is, it will flash the LED.

The second condition begins with else if and then in brackets of the condition. Whenever the analog value is less than or equal to 800 or greater than 500 (will start at 501), it will turn on the LED and leave it fixed.

Finally, if the two previous conditions are not met, it will enter the else and turn off the LED.

I repeat that when several if they are nested if one of them meets the condition, the rest of the if will not be executed. This will make our code more efficient.

Example else if statement with Arduino

To finish, we go with an example. You just have to replace the if we have seen in the previous example with this series of nested if.

// If statement with Arduino

if (value> 800) {

// Flashing LED

digitalWrite (Ledpin, HIGH);

delay (500);

digitalWrite (Ledpin, LOW);

} else if (value <= 800 && value> 500) {

// Turn on LED

digitalWrite (Ledpin, HIGH);

} else {

// Turn off LED

digitalWrite (Ledpin, LOW);

}

The complete code would be as follows.

// Variable with analog pin

const byte Analogicpin = A0;

// Variable LED pin

const byte Ledpin = 13;

void setup () {

// Start serial communication

Serial.begin (9600);

// Pin mode

pinMode (Ledpin, OUTPUT);

}

void loop () {

// Read analog pin

int value = analogRead (Analogicpin);

// Motivate analog pin value

Serial.println (value);

// If statement with Arduino

if (value> 800) {

// Flashing LED

digitalWrite (Ledpin, HIGH);

delay (500);

digitalWrite (Ledpin, LOW) ;

} else if (value <= 800 && value> 500) {

// Turn on LED

digitalWrite (Ledpin, HIGH);

} else {

// Turn off LED

digitalWrite (Ledpin, LOW);

}

// 100 ms delay

delay (100);

}

Try charging and playing with the potentiometer. You will see how it goes from being off to on and finally flashing.

In this chapter, we have seen one of the most powerful tools that programming languages have, the else if-else statements with Arduino. You have been able to verify that, although the loop () function is repeated over and over again very quickly and indefinitely, we can change the result using the if-else conditional statements with Arduino.

It is another tool in programming, but it is not the only one. This can help you control the temperature or water level with Arduino. In addition, it works in the same way on either another Arduino board or on an ESP8266. Moreover, in all programming languages, there are the if, if-else, and else if statements. By mastering the conditional sentences in Arduino, you will master the execution of your program.

Chapter 7

Battery and Battery Charge

Meter with Arduino

In this chapter, I will explain how we can make a battery and battery charge meter. We will do it through the assembly of a circuit with Arduino.

It is usually very typical that we have at home different electrical devices that use batteries. Sometimes, we doubt whether the device is broken or the batteries have run out.

Thanks to this project, this will no longer be a problem. The battery and battery charge meter will give you the solution.

What will you learn in this chapter?

- The objective of the battery and battery charge meter with the Arduino board

- Arduino components that we will use

- Riding the circuit with Arduino

- Programming the battery and battery charge meter with Arduino

- Arduino native code

The Objective of the Battery and Battery Charge Meter with the Arduino Board

We will use Arduino to read the voltage supplied by a battery through an analog input. Depending on this voltage, we will light an LED of one color. If the battery is new, a green LED will light. If the battery is not new, but part of its energy has been consumed, we will light a yellow LED. Finally, if the battery is worn out or does not supply enough voltage, we will turn on a red LED.

We must be very careful with the type of battery and battery we are going to measure. It is very dangerous to supply more than 5V to the analog pins of Arduino. If what we want is to measure batteries, the most typical, we can only do it with AA, AAA, C, and D batteries. They are the ones used in television controls, toys, and even to feed Arduino.

Much eye with a 9V battery, the squares. As I said before, these batteries far exceed the 5V limit. We must also be careful with the batteries as it will depend on the voltage they supply. Check before connecting that it really is less than or equal to 5V.

Measuring more than 5V for some analog input can damage the board.

Arduino Components that We Will Use

Let's see what kind of components we need for this circuit.

- Arduino UNO or any Arduino board

- Protoboard where we will connect the components

- Cables for connection between components and board

- 3 220 Ω resistors

- 1 10 kΩ resistor

- 1 red 5mm LED

- 1 yellow 5 mm LED

- 1 5mm green LED

As you can see, it is a very simple circuit. With three LEDs and four resistors, it is enough to build a battery or battery charge meter with Arduino.

Riding the Circuit with Arduino

Once all the information is collected, we go to the assembly. In the following image, I show you how you should connect the different components. Pay attention, especially in the resistances.

Let's see how the components have been connected. The first is the LEDs. Each one is connected in series with a resistance of 220 Ω to extend their useful life. The green LED is connected to pin 2, the yellow LED is connected to pin 3, and the red LED is connected to pin 4. This is important to remember when we see the programming.

To measure the battery, have placed a resistance pull-down. What this type of resistance does is maintain a low logical state, that is, at 0V. It is important to use this type of resistor since, and when we do not have the battery or battery connected to measure, we have an undetermined state at the analog pin input, which causes it to oscillate and maybe until some LED is lit. You can try to remove this resistance, and you will see the result.

The positive pole of the battery is connected to the pull-down resistor and to the analog input A0. The other end of the earth's resistance. Finally, the negative pole of the battery must be connected to the Arduino earth.

Beware of reversing polarities that is, positive with negative or vice versa.

It is more than advisable that all components have the same reference to ground. All must be connected to the same Arduino GND pin.

Programming the Battery and Battery Charge Meter with Arduino

Now play the logic and programming part. The first thing to do is to raise the problem or algorithm we want to achieve. Once we are clear, we can start programming. As I always say, an algorithm is a sequence of ordered steps that we must follow to achieve an objective. In this case, our goal is to measure the charge of a battery or battery with Arduino.

Algorithm

In this section, I will detail the steps that we must follow without writing a line of code; we will do that later when we are clear about what we have to do.

1. Read the analog pin where the battery is connected

2. We calculate the voltage for the value you have given us

3. We evaluate the voltage

a)    If it is greater than or equal to the maximum threshold

1. We turn the green LED

b)    If it is less than the maximum threshold and greater than the average threshold

1. We light a yellow LED

c)     If it is less than the average threshold and greater than the minimum threshold

1. We turn on the red LED

d)     The rest of the cases

1. Does not light any LED

4. We turn off all LEDs

Analyzing the algorithm that we are going to implement, we conclude that we are going to use three thresholds:

- The maximum threshold: will indicate that the battery is fully charged.

- Average threshold: from this threshold to the maximum threshold, the battery has been used but still has power.

- Minimum threshold: from this threshold to the average threshold, the battery does not supply enough power. Below this threshold, we interpret that there is no battery connected.

Arduino Native Code

We are going to see the code of the battery charge meter with Arduino in parts.

Variables and Constants

We will use the constants to store the pins where we will connect the LEDs and the analog pin where we will connect the battery. The thresholds will be variable, although we could also use constants. Finally, we will declare three variables to store the value returned by the analog pin, the voltage on that pin, and the waiting time for the LEDs to flash.

We declare the constants with the pins where we connect the LEDs and the analog pin.

// Pins for the LEDs

#define LEDGREEN 2

#define LEDYELLOW 3

#define LEDRED 4

#define ANALOGBATTERY 0

The next thing is to declare the variables and thresholds. The latter will depend on the type of battery. In this case, I am going to do the tests with an AA battery

// Variables

int analogValue = 0;

float voltage = 0;

int ledDelay = 800;

// Thresholds

maximum float = 1.6;

medium float = 1.4;

minimum float = 0.3;

Setup Function

In the setup function, we initialize the serial monitor and put the LED pins in output mode.

void setup () {

// We start the serial monitor

Serial.begin (9600) ;

// LED pins in output mode

pinMode (GREENLED, OUTPUT);

pinMode (YELLOWLED, OUTPUT);

pinMode (REDLED, OUTPUT);

}

Loop Function

We begin the loop function that will be repeated continuously. The first thing is to read the analog pin and store it in the variable Analog Value.

void loop () {

// We read analog input value

analogValue = analogRead (ANALOGBATTERY);

We calculate the voltage. It is a simple rule of 3. If 5V is 1024, with five dividing by 1024 and multiplying it by the value given by the analog pin, we already have the voltage. As simple as that. To verify that everything is fine, we show it by the serial monitor.

// We get the voltage

voltage = 0.0048 * analogValue;

Serial.print ("Voltage:");

Serial.println (voltage);

In the next part we will decide which LEDs we should turn on. We do this through the conditional structures if.

// Depending on the voltage we show an LED or another

if (voltage> = maximum)

{

digitalWrite (GREENLED, HIGH);

delay (ledDelay);

digitalWrite (GREENLED, LOW);

}

else if (voltage <maximum && voltage> medium )

{

digitalWrite (YELLOWLED, HIGH);

delay (ledDelay);

digitalWrite (YELLOWLED, LOW);

}

else if (voltage <medium && voltage> minimum)

{

digitalWrite (REDLED, HIGH);

delay (ledDelay);

digitalWrite (REDLED, LOW);

}

Finally, we turn off all the LEDs. Thus we begin in the next iteration with the initial state all turned off. As we are talking about very little time, microseconds, this will not affect the operation.

// We turn off all LEDs

digitalWrite (GREENLED, LOW);

digitalWrite (YELLOWLED, LOW);

digitalWrite (REDLED, LOW);

}

Full Code

Then I leave the complete code, so you do not have to copy part by part. It is not very good practice to copy and paste without reading the above. If you really want to learn, follow all the steps, and try to write the code yourself. Only then will you learn to program with Arduino?

// Pins for the LEDs

#define LED GREEN 2

#define LED YELLOW 3

#define LED RED 4

#define ANALOGBATTERY 0

// Variables

int analogValue = 0;

float voltage = 0;

int ledDelay = 800;

// Thresholds

maximum float = 1.6;

medium float = 1.4;

minimum float = 0.3;

void setup () {

// We start the serial monitor

Serial.begin (9600);

// LED pins in output mode

pinMode (GREENLED, OUTPUT);

pinMode (YELLOWLED, OUTPUT);

pinMode (REDLED, OUTPUT);

}

void loop () {

// We read analog input value

analogValue = analogRead (ANALOGBATTERY);

// We get the voltage

voltage = 0.0048 * analogValue;

Serial.print ("Voltage:");

Serial.println (voltage);

// Depending on the voltage we show an LED or another

if (voltage> = maximum)

{

digitalWrite (GREEN LED, HIGH);

delay (ledDelay);

digitalWrite (GREEN LED, LOW) ;

}

else if (voltage <maximum && voltage> medium)

{

digitalWrite (YELLOWLED, HIGH);

delay (ledDelay);

digitalWrite (YELLOWLED, LOW);

}

else if (voltage <medium && voltage> minimum)

{

digitalWrite (REDLED, HIGH);

delay (ledDelay);

digitalWrite (REDLED, LOW);

}

// We turn off all LEDs

digitalWrite (GREENLED, LOW);

digitalWrite (YELLOWLED, LOW);

digitalWrite (REDLED, LOW);

}

Chapter 8

ADS1115 ADC Digital-Analog Converter for Arduino and ESP8266

The ADS1115 is a 16-bit ADC digital-analog converter that can be very useful for certain projects with Arduino and ESP8266. Although the Arduino boards usually have some built-in ADC digital-analog converter, the ADS1115 has more features and more resolution.

For example, the Arduino UNO incorporates six 10-bit ADCs; however, the ADS1115 has a 16-bit resolution. On the other hand, by using an external ADC digital-analog converter, you will be able to free the processor.

In the case of ESP8266, it only incorporates a 10-bit digital-analog converter that measures in the range of 0V and 1V. This makes the conversion depends on the resistances that are used to make the voltage divider.

Using the ADS1115, you will gain a lot in accuracy and conversion quality. Communication between the external digital-analog converter ADS1115 and Arduino or ESP8266 is through I2C.

All this is what you will see in this lesson, but first, let me show you what analog, digital, and the digital-analog converter is.

What will you learn in this chapter?

- What is a digital-analog converter?

- What is an ADS1115?

- Install library for ADS1115

- Single-end mode

- Differential mode

- Comparator mode

What is a Digital-Analog Converter?

The digital-analog converter allows you to convert from the analog world to the digital world. All the signals detected and processed by the human being are analog signals. The objective of converting an analog signal into a digital signal is that it can be treated and processed by a microcontroller for various purposes.

Machines only understand 1s and 0s. Televisions, computers, tablets, or mobiles, all have at least one digital-analog converter. There are different types of the digital-analog converter (ADC) that are used for different purposes. The three most common types are:

- Flash

- Successive approximations

- Sigma-delta

The most common and most economical digital-analog converter (ADC) is that of successive approximations. The two most important characteristics of a digital-analog converter (ADC) are the resolution and the sampling rate or frequency.

Resolution of a Digital-Analog Converter

The resolution of a digital-analog converter (ADC) is expressed in the number of bits. Sets the number of levels into which an analog input range can be divided. To calculate the resolution of an n-bit digital-analog converter (ADC), divide 1 by 2 raised to n.

For example, a 16-bit digital-analog converter (ADC) has a resolution of

If the input range is 5V,

What comes to say that we can measure variations of 0.0763mV in the analog input signal?

Variations below this voltage will not be detected.

In general, when a digital-analog converter has a higher resolution, it provides more details of the analog signal than a digital-analog converter with a lower resolution.

Is it better to have an ADC with a higher resolution?

It depends. If you are only interested in temperature variations from grade to grade at best with the Arduino digital-analog converter itself is more than enough.

Whenever possible, avoid adding layers that make the project more complex and expensive without any compelling reason.

Speed of a digital-analog converter

The other characters in which we must look at a digital-analog converter (ADC) is the speed or frequency of sampling. It is the number of times the digital-analog converter (ADC) samples the analog signal in 1 second. Its unit is expressed in hertz (Hz).

For example, sampling frequencies of 44 kHz, 22 kHz, and 11 kHz are mainly used for audio signals. If the first one is used, 44 kHz means that the digital-analog converter samples the signal 44000 times per second. The higher the sampling frequency, the better the conversion from analog to digital.

What is an ADS1115?

Now that we are clear about what a digital-analog converter is let's move on to see the ADS1115. The ADS1115 is an ideal external digital-analog converter when more resolution or more analog pins are required.

A typical case is when you want to measure different analog signals with an ESP8266. This SoC only incorporates an ADC. In these cases, it is essential to use an external digital-analog converter (ADC) such as the ADS1115.

As with many components of this type, the ADS1115 is the chip that names the electronic component. You will find it in different shapes and formats, according to the manufacturer.

One of the most famous is that of Adafruit, although you can find other similar ones from other brands. I am going to work with the GY-ADS1115 / ADS1015, whose price is about $ 5.

Everything you see in this lesson will also be useful for any other ADS1115, no matter the manufacturer. The most normal thing is to come with the solderless pins. So prepare the soldering iron and tin because you have to weld.

Next, we will see the main features of the ADS1115.

Main Features of the ADS1115

The first thing is to always go to the technical data sheet, where you will get the best and most reliable information on an electronic component.

On the website of the chip manufacturer, Texas Instruments, you will find it here.

Characteristic

Value

Operating voltage

from 2V to 5.5V

Current consumption

150 µA (continuous mode)

Programmable Sampling Rate

8 Hz to 860 Hz

Resolution

16-bit

Channels

4 input channels or 2 differentials

Communication interface

I2C (4 addresses)

We will be explaining all these features of the ADS1115 throughout this lesson.

Before we go to see the pins.

ADS1115 Pins

The number of pins depends a lot on the component, but, normally, we have access to 10 pins.

- The VDD and GND pins are the power pins.

- The SCL and SDA pins are the I2C clock and data pins.

- Pins A0, A1, A2, and A3 are the four analog input pins.

- The ADDR and ALERT pins are special, and we will see them in more detail.

ADDR Pin

The ADS1115 digital-analog converter can be configured with 4 I2C addresses. This means that you can connect up to 4 ADS1115 on the same I2C bus.

The ADDR pin is used to select an address from the four possible ones. Depending on where you connect, you will use one address or another.

The possible I2C addresses are 0x48, 0x49, 0x4A and 0x4B.

In the following table, I show the possible connections with their corresponding addresses.

ADDR connection

Direction

GND

0x48

5V

0x49

SDA

0x4A

SCL

0x4B

What this table means is that the ADDR pin has to be connected to the GND, 5V, SDA or SCL pin to get the corresponding address.

This type of addressing allows up to 4 ADS1115 modules to be connected to the same board.

ALERT Pin

The ADS1115 digital-analog converter is equipped with a customizable comparator that issues an alert on the ALERT / RDY pin. This feature is very useful since it can significantly reduce external circuits in many projects.

Imagine you have a sensor to detect floods. Thanks to a comparator like the ADS1115 you could do that when it exceeds the threshold, on the ALERT pin it emits a signal and wakes the microcontroller. This allows device consumption to be very low.

It can work in two ways.

In traditional comparator mode, the ALERT pin is activated when the signal exceeds a set high threshold (TH_H) and is deactivated when the threshold drops below the low threshold (TH_L).

In the window comparator mode, lets you know if the signal is between the limits of a window set by the high threshold (TH_H) and the low threshold (TH_L).

This means that it is activated when the high threshold is exceeded or when they fall below the low threshold.

These two modes can be configured at the software level.

ADS1115 Conversion Modes

The ADS1115 digital-analog converter can operate in two conversion modes: single-shot mode and continuous conversion mode.

In single-shot mode, the digital-analog converter (ADC) converts the input signal to demand and stores the result in an internal register.

By sending a signal to ADS1115, we can indicate when to convert.

Then the ADS1115 enters the energy-saving mode. This mode is used to save energy on systems that only require periodic conversions, or there are long periods of inactivity between conversions.

In continuous conversion mode, the digital-analog converter (ADC) automatically begins converting the input signal as soon as the previous conversion is complete. That is, convert a value from analog to digital and when it finishes, take another sample. At what velocity?

The conversion rate, as we have seen before, is programmable.

The data can be read at any time and always reflect the most recent conversion.

Resolution of the ADS1115 Digital-Analog Converter

Although I have already commented that the resolution of the ADS1115 is 16-bit, the reality is that not all 16-bit bits are used to express the voltage value. The output you get from the ADS1115 is known as a signed integer, that is, one of the bits of the 16-bit word is used to set the sign, positive or negative.

Therefore, only 15-bit of the 16-bit is used, which means that there are 32,768 possible values (2 15 ).

The first value would be 0, and the last would be 32,767.

Programmable Gain Amplifier or PGA

Another of the peculiarities that give the ADS1115 even greater precision and reliability is the programmable gain amplifier or PGA that is incorporated.

Ok, but what is a programmable gain amplifier?

Basically, it is an operational amplifier to which we can modify the gain through the code, programming. The programmable gain amplifier sets the full scale, that is, indicates the reference value.

In Arduino, this value is determined by the reference voltage, which in the case of Arduino UNO is 5V and in the Arduino MKR range, and the ESP8266 is 3V3.

In ADS1115, it is established by the PGA. By default, this reference value is ± 6,144 V. This means that the value of 32,677 (maximum value with 15-bit) corresponds to 6,144 V.

In Arduino UNO, with a 10-bit ADC (1024 possible values), the value 1023 corresponds to 5 V.

If you do the conversion, you have to for the ADS1115

And for an Arduino UNO

This means that with the ADS1115, a significant improvement is achieved with respect to the ADC of the Arduino UNO, around 26 times better.

But the best thing is that the gain amplifier is programmable, and we can change the reference value to smaller values. The value of 6.144 V is the worst case.

In the following table, you have a summary of all possible PGA values.

PGA

Reference (V)

Scale factor

2/3

6.144 V

0.1875 mV

1

4,096 V

0.1250 mV

two

2,048 V

0.0625 mV

4

1,024 V

0.0312 mV

8

0.512 V

0.0156 mV

16

0.256 V

0.0078 mV

Note that by setting the PGA with the value 16, a scale factor of 0.0078 mV is achieved, that is, very small voltage variations can be detected.

But be careful, the reference in volts of the previous table does not mean that we can measure signals in that range of values.

The Maximum Range of Analog Inputs of ADS1115

The above table can be very misleading as it can lead to error, although the largest reference is 6.1444 V. The ADS1115 can only measure the power value (VDD) plus 0.3 V for its analog pins.

What does this mean? VDD is the supply voltage, and as we have seen, it can be between 2V and 5.5V.

Therefore, if we supply the ADS1115 with 5V, we can only measure voltages on the analog pins up to 5V + 0.3V, that is, 5.3V.

The same will happen if we feed with 3.3V. In this case, the maximum would be 3.6V.

Applying a voltage greater than VDD + 0.3V to an ADS1115 may damage the chip. Never exceed this voltage on an analog pin.

I repeat that the PGA reference is not the same (it is the scale factor) and the maximum value that the analog inputs support.

The last thing we are going to see before seeing the examples are the operating modes: single-ended mode, differential mode, and comparator mode.

ADS1115 Operating Modes

The single-ended mode makes the four analog inputs of the ADS1115 work like those of an Arduino. The digital-analog converter (ADC) reads the difference between each input and ground.

The differential mode, however, measures the difference between two of the analog inputs of the ADS1115. That is, a measurement is made in which neither side is in GND.

In this mode, the pins are paired two by two, A0 with A1 and A2 with A3. This means that you will only have two channels.

In channel 1, returns the difference between pins A0 and A1, and channel 2 returns the difference between pins A2 and A3.

In the comparator mode, the ALERT pin that we have seen before is used to launch a signal every time a threshold set within the ADS1115 is exceeded.

To test each mode, we will make some examples. The first thing we will do is install the library to be able to program the ADS1115.

Install Library for ADS1115

The first thing is to install the library to control the ADS1115. The most famous and popular is the Adafruit.

In the lesson on how to install a library with Arduino, I show you not only to install it but also how to select the most suitable for your project.

Just look for the Adafruit ADS1X15 library in the library manager.

You need to install it and go. Now you can access both the library and the code of the examples.

This library allows you to control both the ADS1115-based board and the ADS1015-based board. In this lesson, I will only talk about ADS1115.

Single-End Mode

The first mode we are going to see is the single-ended mode. This mode causes the ADS1115 to behave like a normal ADC.

It has 4 numbered analog inputs such as A0, A1, A2, and A3.

The idea is to connect an analog sensor to one of those inputs and measure its value.

In this example, you will use a photoresistor or LDR connected to the ADS1115.

Then I leave the electrical scheme to connect the ADS1115 to an Arduino UNO and a NodeMCU board based on the ESP8266.

ADS1115 Connection with Arduino UNO

The connection of the ADS1115 with the Arduino UNO is very simple. Follow the following scheme.

The SDA pin of the ADS1115 goes to the A4 pin of the Arduino UNO and the SCL pin to the A5 pin.

The I2C address is configured by connecting the ADDR pin of the ADS1115 to the GND pin.

In addition, I added a photoresistor or LDR to test the ADS1115 digital-analog converter (ADC).

The resistance is connected through a voltage divider with another 10kΩ resistor.

The analog pin of the ADS1115 that I am going to use is the A0.

ADS1115 Connection with ESP8266

The connection with the ESP8266 is very similar to that of Arduino UNO. In this case, I will use a NodeMCU board.

The SDA pin of the ADS1115 is connected to pin D2 of the NodeMCU ESP8266 board and pin SCL to pin D1.

The I2C address is configured by connecting the ADDR pin of the ADS1115 to the GND pin.

As in the Arduino UNO scheme, I have connected a photoresistor or LDR through a voltage divider with a 10kΩ resistor.

The LDR is connected to pin A0 of ADS1115.

Single-End Mode Programming

Once we have everything connected between the board and the ADS1115, we will see the programming.

We start with libraries and variables.

Libraries and Variables

#include <Wire.h>

#include <Adafruit_ADS1015.h>

// Create class object

Adafruit_ADS1115 ads;

The first thing is to import the Wire.h and Adafruit_ADS1015.h libraries. Although this last library is called ADS1015, it also contains the code to control the ADS1115.

Then create an object of the Adafruit_ADS1115 class that we call ads.

Setup () Function

void setup (void)

{

Serial.begin (9600);

delay (200);

// Start ADS1115

ads.begin ();

}

The setup () function begins by initiating serial communication to display messages through the serial monitor.

Then start the ADS1115 by calling the ads.begin () function that does not support any parameters.

Loop () Function

void loop (void)

{

// Get data from A0 of ADS1115

short adc0 = ads.readADC_SingleEnded (0);

Serial.print ("A0:");

Serial.println (adc0);

delay (1000);

}

The loop () function is where you really have to read the analog pin.

The first thing is to declare a variable of type short called adc0. This variable will store the value of the digital pin A0.

It is of the short type because this type of stores signed 16-bit integers. Enough to store the value returned by an analog pin, a 15-bit number as we have seen before (from 0 to 32767).

The ads.readADC_SingleEnded (0) function is used to obtain the ADS1115 analog pin value. The parameter that is passed to this function is the analog pin number.

0 will return the value of analog pin A0, 1 that of pin A1, and so on.

Finally, the information obtained by the serial monitor is shown in the loop () function.

Now there is only one thing left, upload the code to the board and open the serial monitor.

Full Code

#include <Wire.h>

#include <Adafruit_ADS1015.h>

// Create class object

Adafruit_ADS1115 ads;

void setup (void)

{

Serial.begin (9600);

delay (200);

// Start ADS1115

ads.begin ();

}

void loop (void)

{

// Get data from A0 of ADS1115

short adc0 = ads.readADC_SingleEnded (0);

Serial.print ("A0:");

Serial.println (adc0);

delay (1000);

}

You will get something similar to this.

If you put your hand on top of the photo resistance, the value will decrease, and if you put your hand on it, the value will increase.

But what would happen if I want more precision? As we have seen, the ADS1115 includes a programmable gain amplifier or PGA that allows us to have more precision with the same number of bits.

As it does? Changing the reference value.

By default, the ADS1115 uses the reference voltage of 6.1444V, which implies a scale factor of 0.1875mV.

If we change the reference voltage, for example, to 4,096V, a scale factor of 0.125mV is obtained.

To change the scale factor, you just have to add the call to the ads.setGain (GAIN_ONE) function just before starting the ADS1115 with the ads.begin () function on line 13.

The code would be as follows.

#include <Wire.h>

#include <Adafruit_ADS1015.h>

// Create class object

Adafruit_ADS1115 ads;

void setup (void)

{

Serial.begin (9600);

delay (200);

// Change scale factor

ads.setGain (GAIN_ONE);

// Start ADS1115

ads.begin ();

}

void loop (void)

{

// Get data from A0 of ADS1115

short adc0 = ads.readADC_SingleEnded (0);

Serial.print ("A0:");

Serial.println (adc0);

delay (1000);

}

What happens when you change the voltage reference? Since the range is reduced, and therefore the scale factor decreases.

Thanks to this, smaller variations in brightness can now be measured.

In the following table, I show the different values that this function can take, the reference voltage, and the corresponding scale factor.

Parameter

Reference

Scale factor

GAIN_TWOTHIRDS

6.144V

0.1875mV

GAIN_ONE

4.096V

0.125mV

GAIN_TWO

2,048V

0.0625mV

GAIN_FOUR

1,024V

0.03125mV

GAIN_EIGHT

0.512V

0.015625mV

GAIN_SIXTEEN

0.256V

0.0078125mV

And that's how the ADS1115 works normally, like any other digital-analog converter (ADC).

Now let's see another mode of operation, the differential mode.

Differential Mode

As I said, the differential mode of the ADS1115 allows us to measure the difference between two analog pins of this module.

You can measure the voltage difference between A0 and A1 or between A2 and A3. That is why it is called differential.

But why can this type of measure be useful?

If you usually do projects with Arduino at some point, you will need to power your project with batteries.

The differential mode will allow you to make a measurement in which none of the sides of the measurement is connected to GND, as is the case when measuring a battery or battery with Arduino.

In addition, another benefit of this mode is that you can perform negative voltage measurements.

In the following example, I will show you how you can do it.

ADS1115 Connection with Arduino UNO

Assemble the circuit starting from the following scheme.

I have used a battery holder with two AA batteries, but you can use another class of batteries, such as AAA or even a single 1.5V battery.

The positive end of the battery holder is connected to the A1, and the negative end is connected to the A0 of the ADS1115.

When the two batteries are connected in series, the voltages are added. Therefore 1.5 + 1.5 = 3V. This will be at best.

The programming will be the same: what will change will be the value obtained from the difference.

ADS1115 Connection with ESP8266

In the following scheme, I show you how to connect the ADS1115 with a NodeMCU ESP8266 board to make a differential measurement.

As in the scheme with the Arduino UNO, I used an AA battery holder.

The positive end of the battery holder to A1 and the negative end to A0.

Be very careful if you are going to measure a voltage higher than 3.3V with which the ADS1115 is powered. Remember that you cannot beat VDD + 0.3V, that is 3.3 + 0.3 = 3.6V

Differential Mode Programming

The ADS1115 differential mode programming is very simple and very similar to what we have seen in the single-ended mode.

Then I leave the code

#include <Wire.h>

#include <Adafruit_ADS1015.h>

// Create class object

Adafruit_ADS1115 ads;

// Scale factor. By default the reference value is 6.144V

// The scale factor of this reference is 0.1875mV

float scale factor = 0.1875F;

void setup (void)

{

Serial.begin (9600);

// Scale factor

ads.setGain (GAIN_TWOTHIRDS);

// Start ADS1115

ads.begin ();

}

void loop (void)

{

// Get the differential

short difference_0_1 = ads.readADC_Differential_0_1 ();

// Convert to volts

float volts = (difference_0_1 * scale factor) /1000.0;

Serial.print ("Difference 0-1 =");

Serial.println (difference_0_1);

Serial.print ("Voltage =");

Serial.println (volts, 4);

Serial.println ();

delay (2000);

}

The first thing the code does is import the libraries and create an instance of the Adafruit_ADS1115 class called ads.

Then I declare a float type variable to store the scale factor called the Scale factor.

The scale factor depends on the voltage reference that has been selected. By default, it is 6.144V, which corresponds to a scale factor of 0.1875mV.

If the voltage reference is modified, you will have to modify the scale factor and put the corresponding one according to the table we have seen in the previous section.

In the setup () function, serial communication is initiated, the scale factor is set with the ads.setGain function (GAIN_TWOTHIRDS), and the ADS1115 sensor is started with the ads.begin () function .

As I said, if you modify the scale factor with the function ads.setGain (...) will have to change the initial value of the variable scalefactor to the match.

In the loop () function, the first thing is to obtain the difference between pin A0 and A1 using the ads.readADC_Differential_0_1 () function.

This function returns the difference between A0 and A1; that is, the value in A0 subtracts the value from A1.

If you need to use the other two pins you can use the ads.readADC_Differential_2_3 () a function that will return the difference between A2 and A3.

This difference is expressed as a signed 16-bit number that is between 32,768 and 32,767. This value must be converted to volts.

To do this, multiply by a Scalefactor and get millivolts. To get volts, you have to divide by 1,000. The same is what is done on line 27 of the code.

Finally, the information is shown by the serial monitor.

Now you just have to load the code to the board and open the serial monitor. You will get something similar to this.

As you can see, negative numbers come out. This is because we are subtracting the voltage we have on pin A0 minus pin A1.

As we have connected the positive of the battery holder to A1, the result is negative.

You can try changing the cables (positive at A0 and negative at A1) and see how the positive voltage appears.

Finally, we will see how to make the ADS1115 launch an alert when it is running in comparator mode.

Comparator Mode

The comparator mode allows a comparison of the value obtained by one of the analog pins with a preset threshold.

As we have seen before, two types of comparisons can be configured: the traditional one or by a window.

If the traditional one is used, as long as the value exceeds the maximum threshold, the ALERT pin will be set to LOW. By default, it is always in the HIGH state.

If you use the type per window, it will change state whenever the high threshold is exceeded and whenever it falls below the low threshold.

With the Adafruit library, you can only work with a threshold, high threshold, and traditional mode. It has not implemented the other mode.

This is precisely what we will see next.

ADS1115 and Arduino UNO Connection

The circuit we are going to use is the same as the one we have seen in a previous section.

Follow the following scheme to connect the components.

The photoresistor or LDR is connected to pin A0, and we also connect an LED to the ALERT pin.

The idea is to set a threshold in the ADS1115, and every time you lower the brightness of that threshold, turn on the LED.

ADS1115 and NodeMCU ESP8266 Connection

The connection with the NodeMCU ESP8266 board is practically the same. Follow the following scheme.

As with the Arduino board, the photoresistor or LDR is connected to pin A0, and the LED to pin ALERT.

Now only programming remains.

Programming in Comparator Mode

Below is the complete code with the comparator example.

#include <Wire.h>

#include <Adafruit_ADS1015.h>

// Create class object

Adafruit_ADS1115 ads;

void setup (void)

{

Serial.begin (9600);

delay (200);

// Scale facto r

ads.setGain (GAIN_TWOTHIRDS);

// Start ADS1115

ads.begin ();

// Scale factor. By default the reference value is 6.144V

// The scale factor of this reference is 0.1875mV

float scale factor = 0.1875F;

// Comparator threshold at 2.5V

// To calculate, divide the (voltage / scale factor) * 1,000

float threshold = (2.5 / Scale factor) * 1000.0F;

Serial.print ("Threshold =");

Serial.println (threshold);

// Assign the threshold to analog pin A0

ads.startComparator_SingleEnded (0, threshold);

}

void loop (void)

{

// Only the comparison will be made after reading

short readADC0 = ads.getLastConversionResults ();

Serial.print ("ADC0:");

Serial.println (read ADC0);

delay (100);

}

The first part of the code is the same as the codes we have seen so far in this lesson, importing libraries and instance to the Adafruit_ADS1115 class.

In the setup () function, the serial communication starts, the scale factor is set, and the ADS1115 starts.

In the next part of the code, the high threshold of the comparator mode is set from line 20 to line 29.

The first thing is to declare a variable with the scale factor. Remember that by default, the scale factor is 0.1875mV, corresponding to 6.144V voltage reference.

The variable that stores this value is a scale factor of the float type.

The threshold must be set to a number that ranges from 0 to 32,767 (they are 15-bit resolution). The logical thing is to set a threshold voltage and then pass it to the number.

To do that conversion you have to apply the following formula:

The threshold voltage must be divided by the scale factor. It must be multiplied by 1,000 since the scaling factor is in millivolts, in case it is in Volts it would not be necessary

To assign the threshold in the ADS1115, you must use the ads.startComparator_SingleEnded (ADC, threshold) function.

The first parameter of the function indicates the analog pin to be used, and the second parameter indicates the threshold to be set.

It's that simple.

If, for example, you want to set a threshold of 2.5V, the number to use is the following.

In the loop () function, you must constantly check the value on the analog pin with the ads.getLastConversionResults () function so that the ADS1115 internally makes the comparison.

If the voltage on the A0 is greater than 2.5V, the ALERT pin of the ADS1115 will be in the LOW state, that is, the pin will be activated.

If the voltage at A0 is less than 2.5V, the ALERT pin will be in the HIGH state, that is, the pin will be deactivated.

By default, the ALERT pin works inverted.

Now there is only one thing left, upload the code to the board and try zooming in and out of light to the photoresistor or LDR.

You will see how, when the light hits the LED, the LED goes out, and when the light doesn't hit, the LED goes off.

With this, I conclude this lesson on the digital-analog converter.

The ADS1115 digital-analog converter can be a great ally when we need more analog pins or more precision in our projects.

It is very simple to use with an Arduino or an ESP8266 thanks to its I2C interface.

It allows working in different operating modes: single-ended mode, differential mode, or comparator mode.

Using one or the other will depend on the requirements of our project.

Thanks to the Adafruit library, its use with any of these two plates is very simple, and also the code is 100% compatible between them.

Chapter 9

Arduino Interruptions

Atmel microcontrollers incorporate a mechanism that is often unknown to all of us. The interruptions with Arduino allow us to react to external events to the plate in a quick way. When a signal is detected, an interruption interrupts the process that is running. This will allow us two things. On the one hand, quickly execute a piece of code, and on the other hand, stop the execution of the code that was being executed.

For example, imagine that you want to cook a pizza in the oven. Typically, heat the oven to a certain temperature, put the pizza in, and set the clock for 25 minutes. Meanwhile, you are going to watch TV.

When the clock ends the countdown, a bell rings, and you interrupt watching television to attend the oven. You take the pizza out of the oven, take it to the living room, and keep watching TV. This would be a real-life example of how interruptions work.

Interruptions are not simply to change and do something different. For example, we are riding a bicycle, we get home and keep the bike in the garage, or a button is pressed by the user and allows you to stop the DFRobot.

In these two cases, we do not interrupt an action; we go on to do something different. We finish doing one thing and do another. In the case of the button, the most we can do is remember the state of the pressed button. We must use the interruptions for what they are, interrupt what is being executed, and perform another task, then return to the same place where we had left.

Within the range of interruptions with Arduino are scheduled interruptions and external interruptions. The philosophy is the same, to be able to execute a code when a specific event happens. In the case of scheduled interruptions, the event will trigger every certain interval of time that we must configure.

This type of interruptions is not the object of this article. If you want to know more, you can see the reference of the TimerOne library that is responsible for configuring and managing this type of interruptions.

The other type of interruptions, the external ones, allows us to react to external events. An event may be that a button is pressed, or that a sensor captures certain information.

What will you learn in this chapter?

- Why use interrupts with Arduino

- How to use interrupts with Arduino

- Practical example: controlling the speed of fantastic car lights

Why Use Interrupts with Arduino?

Using interruptions will allow us to forget about controlling certain pins. This is very important because, within an application or program, we will not do a single thing. For example, we want an LED to turn on or off when we press a button. This is really simple, but when we also want another LED to flash, things get complicated.

The probability of capturing the event when the button is pressed decreases with the increase in flashing time. In these cases, and many others, we are interested in releasing the Arduino processor so that only when the button is pressed, it takes a specific action. So we will not have to be constantly checking the X pin if you have pressed the button.

Precisely this is the sense of interruptions, to be able to do other things as long as the event does not happen, but when that external event is present, to quickly execute the associated code.

Internally, Arduino (or rather the AtMega microcontroller) has certain configured interrupts that it throws according to the situation. For the transmission of data through the serial port, to reset the board before loading a program, I2C communication, etc ...

In this case, we will create our own interruptions associated with certain pins according to the type of board.

How to Use Interrupts with Arduino

Inside the Arduino board, we find different pins that allow us to have interruptions. It will depend on the type of plate.

LICENSE PLATE

PINS INTERRUPTIONS

One, Nano, Mini

2. 3

Mega, Mega2560, MegaADK

2, 3, 18, 19, 20, 21

Micro, Leonardo

0, 1, 2, 3, 7

Zero

All digital pins except 4

MKR1000

0, 1, 4, 5, 6, 7, 8, 9, A1, A2

Due, 101

All digital pins

In order to use interruptions with Arduino, we do not need to incorporate any type of library into our program. We only need to make references to certain functions or methods. Now we will see what they are.

attachInterrupt (pin, ISR, mode)

This function will allow us to define or configure one of the pins as an interrupt port. The three parameters it supports are:

- Pin: we must take special care with this parameter. Indicates which pin we will use as an interruption. We must not pass the pin number, and we must pass the ordinal. That is, if we work with Arduino UNO, we have two pins for interruptions 2 and 3. If we want to use the 2, we must put a 0 and if we want to use the 3, we must put a 1. This is very easily solved using another function, digitalPinToInterrupt (pin), which returns the ordinal of the pin we want to use. In this case, we must pass your number. For example, in the previous case, if we want to use pin 2, we would call the digital function PinToInterrupt (2). This will return a 0 and is the method recommended by Arduino to pass this parameter.

- ISR: is an abbreviation for Interrupt Service Routine and is nothing more than the function or method that is called when the interruption occurs. It is of a particular type since it does not support parameters and does not return any value either.

- mode: defines when the interruption should be triggered. It can take four constant values depending on what we want to do:

- LOW: the interrupt will be launched when the pin is in the low state.

- CHANGE: The interrupt will be launched when the pin changes the value from high to low, or from low to high.

- RISING: the interrupt will be launched when the pin changes state from low to high.

- FALLING: the interrupt will be launched when the pin changes state from high to low.

There is the fifth state that only the Arduino Due, Zero and MKR1000 allow:

- HIGH: the interrupt will be launched when the pin is in a high state.

detachInterrupt (pin)

If attachInterrupt () allows us to configure a pin as an interrupt, the detachInterrupt () method overrides that setting. As a parameter, we pass the pin, and we can do it with the digital function  PinToInterrupt (pin number)  that will return the ordinal of the pin from which we want to cancel the configuration.

Practical Example: Controlling the Speed of Fantastic Car Lights

The best way to learn is to put into practice what is learned in theory. For this, what we are going to do is the typical sketch with the fantastic car lights. In this case, we will control the speed with which it moves through two buttons .

Electrical Circuit

We will need the following material:

- 2 green LEDs

- 3 red LEDs

- 5 470 Ω resistors

- 2 push buttons

- 1 1 kΩ resistor

- Arduino UNO

- Protoboard

- Male / male cables

Each button will be connected to a pin and will have a pull-down resistor. This will make in a normal state, without pressing, the pin will have a low state. When the button is activated, we will have a high state. Therefore we must detect a change of state from low to high (RISING).

On the other hand, the LEDs will do a sequence of turning on and off from left to right and from right to left. Simulate the fantastic car lights. We will start with speed, and as we press the buttons, the speed will increase or decrease.

The electrical scheme is as follows.

Programming the Interruption Sketch with Arduino

The first part is the declaration of counters and variables. At this point, it is necessary to make a clarification. When we work with interruptions with Arduino, we must take special care with the ISR methods that will be executed when the event occurs.

In general, we must make ISR methods or functions as short and as fast as possible. A blockage between the different ISRs can occur. What happens in these cases is that only one is executed at a time, the rest of the interruptions being queued.

Within the interruptions, the delay () (delay) does not work; therefore, do not use it. Remember that it is about executing code as quickly as possible. If you want to make the process stop within an ISR, use the delayMicrosends () function since it works normally.

The variables that we will use both within the ISR methods and outside, either in the loop () or in any other function, we must declare them as volatile. This reserved word tells the compiler that these variables can change their value at any time and, therefore, the compiler must reload the variable every time reference is made to it. In contrast, other variables require the compiler to rely on a copy that it may have in a processor register.

Sketch Fantastic Car Lights with Interruptions

* /

// Global speed variable

volatile int speed = 20;

// Constants of maximum, minimum speed and how much increases

maximum int const = 1000;

minimum int const = 20;

const int increases = 20;

// Array with the pin numbers where they are connected

// the LEDs of the fantastic car lights

int leds [5] = {8, 9, 10, 11, 12};

void setup () {

// Initialize the LED pins as output and at low state

for (int i = 0; i <5; i ++)

{

pinMode (leds [i], OUTPUT);

digitalWrite (leds [i], LOW);

}

// We assign the minimum speed

speed = minimum;

// Configure the interrupt pins so that

// detect a change from low to high

attachInterrupt (digitalPinToInterrupt (2), speedLess, RISING) ;

attachInterrupt (digitalPinToInterrupt (3), speedMas, RISING);

}

void loop () {

// This first loop travels the array from left to right

for (int i = 0; i <5; i ++)

{

// Only for the second and consecutive pin, we turn off the previous pin

// In the case of 0, it is not necessary since by default it is off

// Be careful that we go out of the range of the array 0-1 = -1 this element does not exist

if (i> 0)

{

// Turn off the LED on the left

digitalWrite (leds [i - 1], LOW);

}

// We turn on the LED in which we are

digitalWrite (leds [i], HIGH);

// We wait for the time marked by speed

delay (speed);

}

// Turn off the last LED on, element 5 of the array

digitalWrite (leds [4], LOW);

// We traverse the array in the reverse direction from right to left

for (int i = 4; i> = 0; i--)

{

// In the first case as the LED is off, we do nothin g

// Be careful that we go out of the range of the 4 + 1 = 5 array this element does not exist

if (i <4)

{

// Turn off the LED on the right

digitalWrite (leds [i + 1], LOW);

}

// We turn on the LED in which we are

digitalWrite (leds [i], HIGH);

// We wait for the time marked by speed

delay (speed);

}

// Turn off the last LED on, element 0 of the array

digitalWrite (leds [0], LOW);

}

// ISR pin 2, slow down

void speed Less ()

{

// Decrease the set value

speed = speed - increases;

// If we have reached the minimum speed we do not decrease more

if (speed <minimum)

{

speed = minimum;

}

}

// ISR pin 3, increase the speed

void speedMore ()

{

// Increase the set value

speed = speed + increases;

// If we have reached the maximum speed we do not increase more

if (speed> maximum)

{

speed = maximum;

}

}

And finally, here in this chapter, we have seen the interruptions with Arduino. It is very important to know this technique very well since it will save us a lot of work on certain occasions.

Conclusion

Now that you have a little more skills and intimacy with electronics and programming, do you feel safe to create something? If you need more knowledge on Arduino, our Arduino series has several books ranging from super basic to advanced. Here are some projects that may be interesting for those like you who just had their first contact with Arduino.

Some components that we didn't work so hard on were the sensors, we saw only vibration and light, but there is a sensor for almost everything you can imagine! With them, you can carry out various projects, such as those listed below:

1. Temperature sensor

2. Proximity sensor, which measures distance using ultrasound

3. Touch sensor to play songs

4. Soil moisture sensor to know when your plant needs water

5. Flame sensor, be careful with this sensor testing

In addition to sensors, other cool components to learn to move are motors. In the book, we have seen how the servo motor works, but it is also interesting to know the simplest direct current motor or even the stepper motor.

To interact with Arduino, it is interesting to put a display on some projects. We saw the multi-segment display, which is quite simple. There are other models with more room to write, such as the LCD Display and OLED Display.

With Arduino, we can control things in the house too! We can go beyond the small electronic components using a component called relay, and we saw in this book how it works to light a lamp with a button. Remember that in a Project, we lit an LED according to the light? We also lit a lamp. Just be careful when working with the mains, turn everything off when mounting, and turn on only after mounting everything. The damage can be huge, so if possible, do it with some follow-up.

Of course, from a sample project, you can add other sensors and apply different logic to the proposal, so your project will better meet your needs. If you want to learn more about Arduino programming, the rest of the books of this series will teach you how to work with programming logic fluently.

Did you know there are other development boards besides Arduino? Some have easy access to the internet, some have a lot of processing, while others are practically a computer, with the operating system and all.

We on other boards can say, for example, are Raspberry and Internet of things with electronics. With them, you can start learning about a new range of options in the world of electronics and programming like Arduino.

No doubt, Arduino is an amazing platform, and the amount of projects that can be done is virtually endless. We hope that throughout the development of the 15 kit projects, you have understood the first steps with Arduino, and the guide has been enlightening. The main goal is actually to pique your curiosity and make you create your own designs.

References

https://classroom.littlebits.com/projects/pokelight

https://fabacademy.org/archives/2012/students/di_vozzo.romain/week_7_fab_academy_electronics_design_feb_29.html

https://www.littlebits.com/projects/croq-cat

https://digitalmedia.risd.edu/pbadger/PhysComp/index.php?n=Devices.MomentaryCode

https://www.arduino.cc/en/Tutorial/ForLoopIteration

https://sites.google.com/site/hwcontwerpen/sketches-les-0-t-m-9/les1d-looplicht

http://fritzing.org/projects/brightness-indicator-photocell-with-tweak

https://www.arduino.cc/en/tutorial/loop

https://stackoverflow.com/questions/50251876/how-can-i-blink-a-led-differently-when-i-press-a-toggle-button/50259528

https://stackoverflow.com/questions/50251876/how-can-i-blink-a-led-differently-when-i-press-a-toggle-button/50259528

https://www.arduino.cc/en/Tutorial/AnalogInOutSerial

https://www.arduino.cc/reference/en/#structure

ARDUINO

PROGRAMMING

Tip and Tricks to Learn Arduino Programming Efficiently

STUART NICHOLAS

Introduction

Have you ever wondered how to start the adventure with microcontrollers? Check Arduino. This open platform has been prepared for all DIY enthusiasts, including robot builders. The first part of the book discusses the basics required for further lessons.

If you are interested in electronics at least to a small degree and would like to start programming your own systems, then Arduino will be the perfect solution to start with. You won't have to waste time designing your own tiles, choosing the right programmer, and tedious environment configurations. Everything will work almost immediately.

This book has been planned for 11 parts (with possible continuation). Of book, he does not discuss the whole Arduino, and the subject is so extensive that you can write about it (several) books. The purpose of this book is to explain the basics in practice and to interest the reader in further exploring this platform.

What is Arduino?

For a beginner, Arduino is a ready "development kit" with the popular AVR microcontroller. Created according to the relevant assumptions, thanks to which:

1. Does not require an external programmer

2. Works well with a dedicated compiler

3. You can buy an "infinite" number of expansion boards (e.g., motor controllers, displays, executive modules)

However, the true power of Arduino lies in a dedicated programming language based on C / C ++. Starting the adventure with microcontrollers, it's worth learning at least the basics about their construction and how they work.

Fortunately, in the case of Arduino, to program your system, you do not need to know the microcontroller registers. Everything is based on friendly libraries, thanks to which the creation of even a complicated program is within reach of a novice programmer.

In short, Arduino is modules with microcontrollers that can be easily programmed using generally available libraries in a language similar to C / C ++.

Advantages of Arduino

The project began to be developed in 2005 in Italy. Since then, he has gathered a mass of supporters and fanatical users. From the very beginning, Arduino was prepared for people who did not have much in common with programming microcontrollers.

Excellent environment, friendly syntax, and low prices have made Ardunio extremely popular. The community built around this project is huge. This brings many benefits. From a beginner's point of view, three are most important:

- A huge number of ready-made solutions. Various projects are created on Arduino. If you came up with something "new" and interesting, then 90% someone has already done it on Arduino earlier and posted a description of the project on the Internet.

- The popularity of the platform has meant that manufacturers have prepared countless tile varieties and extensions - you will find more about this later in the book.

- A large number of users make it easier to find help when they get stuck in an important point of the project.

Arduino - Choosing a Hardware Platform

Arduino is an Open Hardware platform. This means that all materials needed to create your own development kit operating in this standard are available. For this reason, you can find many different tiles compatible with Arduino.

At the moment, Arduino officially talks about 20 available models on its websites. In every good store, you will find at least a few different sets. For the needs of the book, I decided to choose the most popular tile - Arduino UNO R3.

Arduino is a project that is constantly growing - both in programming and hardware. The UNO version 3 board is currently prompted by Arudino, like the one on which the latest libraries and expansion boards can be used for a long time.

Equipment Arduino UNO R3

The heart of the system is the popular 8-bit microcontroller from Atmel, AVR ATmega328, operating at a frequency of 16 MHz.

Working at such a frequency in a simplified way means that the microcontroller can perform 16 million operations per second. It's a lot.

Special connectors, placed characteristically on the sides of the board, are the outputs of the most important signals. There we will find 14 programmable digital inputs/outputs. Six of them can be used as PWM outputs (e.g., for motor control), and another six as analog inputs. We will also find there a reset signal and power supply.

Arduino can be powered in several ways. The most popular methods are:

1. Power supply via USB cable

2. Powered by a plug-in power supply (optimally 7V - 12V) or batteries

The most important elements are marked on the graphic below:

1. USB connector - used for power supply, programming, and communication with a computer

2. Power connector  (optimally 7V - 12V)

3. Voltage stabilizer - the input voltage from connector 2 is reduced to 5V thanks to this system

4. Reset button - resets the Arduino board

5. Microcontroller responsible for communication with the computer via USB

6. Programming connector for the microcontroller from step 5.

7. Signal connector *

8. Signal connector *

9. LED diode signaling connection of voltage to Arduino

10. Programmer output for the microcontroller from point 13.

11. Signal connector *

12. Power connector *

13. Arduino heart, AVR ATmega328 main microcontroller

14. LEDs signaling transmission to/from the computer

15. LED at the user's disposal

16. Ceramic resonator  clocking the microcontroller (point 13) with a frequency of 16MHz

17. A jumper that when cut off disables Arduino's automatic reset.

18. Solder pads with derived microcontroller signals from point 5, used extremely rarely in very specific and non-standard situations.

Clones, or Arduino (un) Original

As I mentioned, Arduino is an open-hardware platform. This means that anyone can make their own Arduino or design a tile per this standard. Sets from other companies operating, such as Arduino, are commonly called clones.

Clones can be divided into two types:

- Total fakes, imitating originals

- The tiles comply with the Arduino standard

For example, if you are looking for the Arduino UNO mentioned above and you find a plate identical to my photos at a price of less than $120, it will be 100% fake. You can take a chance and buy one. The choice is yours, whether you want to support companies that earn dishonestly or choose those that have put a little more effort into the production of their version.

Warning.   The cheap imitation ones are often made of inferior quality elements that can damage the entire system.

Materials you need to program Arduino

In addition to the Arduino UNO mentioned above, a handful of additional elements will be used in the first seven parts of the book. A USB cable and connection cables will definitely be useful. Plus colored LEDs and buttons. We will present more complicated items on a 2x16 character text display.

In the further chapters of the book, we will also discuss controlling actuators such as servos and motors. Sensors will also be useful. We will use light sensors ( photoresistors ) and an ultrasonic distance sensor.

The set of necessary elements is visible in the photo below:

Now we will deal with the installation of the environment. I assume you don't have the equipment you need yet. However, Arduino will be necessary for further learning.

Arduino IDE Installation

The appropriate environment must be installed before programming. The latest Arduino IDE can be downloaded from the project's official website . The installer takes about 53 MB.

Warning. Update (14.04.2015)

Due to the conflict, two versions of the environment appeared within the Arduino team. Fortunately, this doesn't matter much to the end-user. However, if you purchased the original board, check the address on its back before installing the environment.

There you will find a reference to one of the following pages:

- http://arduino.org/

- http://arduino.cc/

If the first address occurs, download the environment from here . However, if you find a second address on the back of the tile, get it from here .

What happens when you install the wrong IDE?

Note - You will only be notified that the tile you have does not come from an authorized source. You can turn off this message with one click. Everything will work without problems.

Download the latest version.

Installation is standard. In the beginning, we accept the product license:

Then click a few times Next, and we become happy users of the Arduino IDE. Along the way, pay attention to the components installed:

If we choose to install the USB driver (which is recommended), we will see a system warning at the end of the installation.

Click " Install this driver software anyway, " you don't have to worry about anything. After the installation is complete, a new icon should appear on your desktop:

If the software has been installed correctly, we will see the welcome screen after starting it:

And after a while the editor:

If you already have Arduino

I wrote earlier that we would not program in this part. However, if you already have Arduino, you can do something very simple to check if everything works. First, start the Arduino IDE editor. Then from the menu select:

File -> Examples -> 01. Basics -> Blink

A separate window will open with the program code (do not temporarily penetrate its structure). It should look similar to the following:

Now connect your Arduino to the computer. Use a USB cable for this, and you do not need to connect battery power. You only need this one cable. Now the computer will detect new hardware and install drivers.

When the equipment is ready for use, check which COM port has been assigned to your board. You can do this by going to the device manager:

Computer -> Properties -> Device Manager

Now we can go back to the Arduino IDE settings. Here we have to choose two options. First of all, we tell the compiler which board we use. Then indicate the previously checked COM port number.

The Arduino IDE only shows the available COM ports. For me it was COM1 and COM21, you can have many more. The main thing is to choose the right one.

Board connected and set up. Now we can proceed to upload the program. To do this, we need to choose two options:

- Verify

- Load

The first one is the equivalent of "Compiles" found in other environments. This process is responsible for checking the correctness of the code and its compilation, or conversion into a language understandable for programmed electronic devices.

The second command is responsible for sending the program to the Arduino UNO board. After clicking the Load button, the LEDs labeled TX and RX should flash on the board. This means that the data is transferred from/to the computer.

When the process is done correctly, you'll find the appropriate message at the bottom of the Arduino IDE. There will be information that the program has been sent and how much space has taken up in the memory of our microcontroller - in this case, it was 1 084 bytes.

The fact that the program has been sent correctly can also be seen on Arduino. As I mentioned earlier, we have 1 LED on the board. After uploading the program, it should flash.

The effect is not thrilling, but we know that everything works. Next, we'll start writing programs ourselves. In the meantime, you can try to edit the code we have downloaded and test how the system will behave.

Now here it’s enough "long introduction" to the book. I hope that it explains the basic issues and encourages you to follow the next chapter.

Chapter 1

Basic Concepts of Programming

Conversions

Often, we need to convert the numbers to different bases. We will find two methods and it’s good to know both. The first will teach you how to do the conversions "by hand,” allowing you to understand things well. The second that of the calculator will allow you to make conversions without getting tired.

Decimal <-> Binary

To convert a decimal number (in base 10) to a binary number (in base 2, you follow that's good.), You  need to know how to divide by 2. Will it be okay? Take your number, then divide it by 2. Then divide the quotient obtained by 2, then so on until you have a zero quotient. Then you have to read the remains from bottom to top to get your binary number.

Binary <-> Hexadecimal

Converting from binary to hexadecimal is the easiest to do.

First, start grouping the bits in blocks of four starting at the right. If there are not enough bits left to make the last group of four, we add zeros.

Take the number 42, which is written in binary, as we have seen, 101010, and we will get two groups of 4 bits, which will be 0010 1010. Then, calculate block by block to obtain a hexadecimal digit taking into account the value of each bit. The first bit of low weight (far right) will be worth, for example, A (: A in hexadecimal). Then the other block will simply be worth 2 (). So 42 in the decimal base is worth 2A in the hexadecimal base, which is also written to pass from hexadecimal to binary, it suffices to do the reverse operation with the help of the decimal base from time to time. The procedure to follow is as follows:

-        I separate the numbers one by one (we get 2 and A)

-        I "convert" their values to decimal (which makes us 2 and 10)

-        I put these values in binary (and we, therefore, have 0010 1010)

Decimal <-> Hexadecimal

This case is more delicate to treat because it requires to know the multiplication table by 16. As you have followed the previous explanations, you understand how to do it here. As I am bad at math, I would advise you to go through the binary base to do the conversions.

QUICK Method

For this, go to Start / All programs / Accessories / Calculator. Who Said I Was Lazy?

You see at the top, that there are options to check to display the number entered in the base that we want. Currently, I am in base 10 (decimal - Dec button). If I click on Hex:

I see that my number 42 has been converted to 2A. And now if I click on Bin:

Yes, that's right. Why didn't we start by explaining that? Who knows.

Now that you have acquired the essential basics to continue the book, we will see how the material you  bought looks and which we will need to follow this book.

The Software

To give you a little extra time to get your Arduino board, I will briefly show you how the Arduino software looks.

Installation

There is no need to install the Arduino software on your computer since it is a portable version. Let's look at the steps together to prepare your computer for using the Arduino board.

Downloading

To download the software, go to the download page of the Arduino.cc website. You have two categories:

Download: In this category, you can download the latest version of the software. Windows platforms,

The software supports Linux and Mac. This is where you will download the software.

Previous IDE Versions: In this category, you have all the versions of the software, under the platforms previously mentioned, since the beginning of its creation.

Windows

For me, it will be under Windows. I click on the Windows link, and the file appears:

Once the download is complete, you  have to decompress the file with a decompression utility (7-zip, WinRar, etc.). Inside the folder are a few files and the software executable:

Mac Os

Click on the Mac OS link. A.dmg file appears. Save it.

Double-click on the.dmg file: There is the Arduino application (.app), but also the driver to install (.mpkg). Proceed with the driver installation then install the application by dragging it into the shortcut of the "Applications" folder, which is normally present on your computer.

Under Linux

Nothing could be simpler, by going to the software library, look for the "Arduino" software. Several outbuildings will be installed at the same time.

Software Interface Software Launch

Launch the software by double-clicking on the icon with the "infinite" symbol in green. It is the executable of the software. What jumps out at first is the clarity of the presentation of the software. We immediately see its intuitive interface.

Correspondence

Frame number 1: these are the software configuration options

Frame number 2: it contains the buttons that will serve us when we are going to program our cards Frame number 3: this block will contain the program that we are going to create

Frame number 4: This is important because it will help us to correct the faults in our program. It's a debugger.

Approach and Use of the Software

Let's take a more serious look at the use of the software. The menu bar is surrounded in red and numbered by number 1.

The File Menu

It is mainly this menu that we will use the most. He has several things that are going to be very useful to us:

New: will allow you to create a new program. When this button is pressed, a new window, identical to this one, appears on the screen.

Open: with this command, we will be able to open an existing program

Save / Save as: save the current document/request where to save the current document

Examples: this is important; a whole list is scrolled to display the names of examples of existing programs; here, you can help you create your own programs.

The rest of the menus are not interesting for the moment, we will come back to this later, before starting to program.

Buttons

Now let's see what the buttons are for, framed in red and numbered by the number 2.

Button 1: This button allows you to check the program, it activates a module that searches for errors in your program

Button 2: Create a new file

Button 3: Save the current program Button 4: We do not touch it for the moment Button 5: Stop the verification

Button 6: Load an existing program

Button 7: Compile and send the program to the card

Finally, we will be able to take care of the equipment that you should all have right now: the Arduino board.

Equipment

I hope that you now have the equipment required to continue the book because, in this chapter, I will show you how your card looks, then how to test it to verify that it works.

Presentation of the Card

To start our discovery of the Arduino board, I will present the board itself. We will see how to use it and with what. I have represented in red on this photo the important points of the map.

Constitution of the Card

Let's see what these important points are and what they are used for.

The micro-controller - This is the brain of our map (in 1). It will receive the program you have created and store it in the memory and then execute it. Thanks to this program, it will know how to do things suchs as: flashing an LED, displaying characters on a screen, sending data to a computer, etc.

Materials

To operate, the card needs a power supply. The microcontroller operating under 5V, the card can be supplied with 5V by the USB port (in 2) or by an external power supply (in 3), which is between 7V and 12V. This voltage must be continuous and can, for example, be supplied by a 9V battery. A regulator then takes care of reducing the voltage to 5V for the proper functioning of the card. No danger of toasting everything. Please only respect the interval of 7V to 15V (even if the regulator can support more, do not bother to subtract it within its limits)

Visualization

The three "white dots" circled in red (4) are, in fact, LEDs whose size is of the order of a millimeter. These LEDs are used for two things:

The one at the top of the frame: it is connected to a pin of the microcontroller and will be used to test the hardware.

Note: When you connect the card to the PC, it flashes for a few seconds.

The two LEDs at the bottom of the frame: are used to display activity on the serial channel (one for transmission and the other for reception). The downloading of the program in the microcontroller being done in this way, one can see them flashing during the loading.

Connectivity

The Arduino board does not have any components that can be used for a program, put by the LED connected to pin 13 of the microcontroller, and it is necessary to add them. But to do this, you must connect them to the card.

For example, we want to connect an LED to an output of the microcontroller.  connect it, with a resistor in series, to the card, on the card's connection plugs.

This connection is important and has a pinout that must be respected. We will see it when we learn to do our first program. It is with this connection that the card is "expandable,” because you can connect all types of assemblies and modules. For example, the Arduino Uno board can be extended with shields, such as the "Ethernet Shield," which allows the latter to be connected to the internet.

Installation

To use the card, it must be installed. Normally, the drivers are already installed under GNU / Linux. Under Mac,  double click on the.mkpg file included in the download of the Arduino application, and the installation of the drivers is executed automatically.

Windows

When you connect the card to your computer on the USB port, a small message appears at the bottom of the screen. Theoretically, the card you use should install itself. However, if you are on Win 7 like me, it may not work the first time. In this case, leave the card connected and then go to the control panel. Once there, click on "system," then in the left panel, select "device manager." Once this menu is open, you should see a component with a yellow "caution" sign. Right-click on the component and click "Update Drivers." In the new menu, select the option "Search for the driver myself." Finally, you have to select the right folder containing the driver. It is in the Arduino folder that you had to unzip a little earlier and is called "drivers" (be careful, don't go down to the "FTDI" folder). For example, for me, the path will be:

[The way-to-folder] \ Arduino-0022 \ Arduino-0022 \ drivers

It seems that there are problems using the French version of Arduino (the drivers are missing from the file). If this is the case, you will need to download the original version (English) to install the drivers. After installation and a sequence of flashing on the micro-LEDs of the card, it should be functional; a small green LED indicates that the card is properly powered.

Test your Equipment

Before starting to program the head down, it is first of all necessary to test the correct functioning of the card. Because it would be silly to program the card and look for errors in the program when the problem comes from the card. > <We will test our hardware by loading a program that works on the card. But we haven't made any programs yet?

Barely. But the Arduino software contains sample programs. Well, these are the examples that we will use to test the card.

1st step: Open a Program

We are going to choose a very simple example that consists of making a LED flash. His name is Blink, and you will find him in the Basics category.

Last Step

Now, we will have to send the program to the card. To do this,  click on the Upload button.

At the bottom of the image, you see the text: "Uploading to I / O Board...,” this means that the software is sending the program to the card.

The message display: "Done uploading" indicates that the program has been loaded onto the card. If your hardware is working, you should have a flashing LED on the board:

If you do not get this message but rather something in red, do not worry, the equipment is not necessarily defective.

Indeed, several errors are possible:

- IDE recompiles before sending code, check for error

- The serial channel may be badly chosen, check the connections and the choice of the serial channel

- the IDE is coded in JAVA, it can be capricious and bug from time to time (especially with the serial channel...): try the sending again.

The Arduino Language (1/2)

To be able to program our card, we need three things:

- A computer

- Arduino board

- And know the Arduino language

It is this last point that we must acquire. The purpose of this chapter is to teach you how to program with the Arduino language. However, this is only a book material that you can browse when you have to program your card by yourself. Indeed, it is by manipulating that you learn, which implies that your programming learning will be more consistent in the next chapters than in this book itself.

I specify a small hazard: the Arduino language not having the coloring of its syntax in the zCode. I will put it as C code because their syntax is very close:

Code: C

// here is colored Arduino code thanks to the "code: C" tag in zCode

void setup ()

{

//...

}

The Arduino language is very close to C and C ++. For those whose knowledge of these languages is based, do not feel obliged to read the two chapters on the Arduino language. Although there are some somewhat important points.

Language syntax

The syntax of a programming language is the set of writing rules linked to this language. We will, therefore, see in this section the rules which govern the writing of the Arduino language.

The Minimum Code

With Arduino, we have to use minimal code when creating a program. This code allows dividing the program that we are going to create into two big parts.

Code: C

void setup ()

{

// card initialization function

// content of initialization

}

void loop () // main function, it repeats (runs) endlessly

{

// content of your program

}

So you have before you the minimum code to insert into your program. But what can it mean for someone who has never programmed?

Function

In this code, there are two functions. Functions are  portions of code.

Code: C

void setup ()

// card initialization function

{

// content of initialization

// we write the code inside

}

This setup () function is called only once when the program starts. This is why it is in this function that we will write the code which only needs to be executed once. This function is called: "initialization function." We will find the implementation of different outputs and some other settings. It's a bit like the start-up check-up. Imagine an airplane pilot in his cabin doing the inventory:

- leg 2 at the exit, high state?

-              OKAY

- timer 3 to 15 milliseconds?

-              OKAY

Once you have initialized the program, you must then create your "heart,” in other words, the program itself.

Code: C

void loop () // main function, it repeats (runs) endlessly

{

// content of your program

}

It is, therefore, in this loop () function where we will write the content of the program. It should be known that this function is called permanently, that is to say, that it is executed once, then when its execution is finished, it is re-executed and again and again. We are talking about an infinite loop.

For your information, you don't have to write anything on these two functions. However, it is mandatory to write them, even if they do not contain any code.

The Instructions

In these functions, what do we write? This is precisely the purpose of this paragraph.

In your list for dinner tonight, you write down the important tasks that await you. These are instructions. The instructions are lines of code that say to the program: "do this, do that." It is very simple but very powerful because it is what will orchestrate our program.

The semicolons end the instructions. If, for example, I say in my program: "call the function cutFromSausage" I must put a semicolon after calling this function.

Semicolons (;) are synonymous with errors because they are very often forgotten at the end of the instructions. Therefore, the code does not work, and the search for the error can take us considerable time. So be careful.

The Braces

The braces are the "containers" of the program code. They are specific to functions, conditions, and loops. The program instructions are written inside these braces. Sometimes they are not mandatory in the conditions (we will see below what it is), but I recommend to put them all the time. This will make your program more readable.

Comments

Finally, we will see what a comment is. I already put some in the example codes. These are lines of code that will be ignored by the program. They are useless during the execution of the program. But then is it useless?

No, because this will allow the programmers who will read your code and us (if there are any) to know what the line of code you wrote means. It is very important to put comments, and it also makes it possible to resume a forgotten program more easily.

If, for example, you are unfamiliar with an instruction that you have written in your program, you put a comment line to remind you the next time you read your program what the line means.

Single comment line:

Code: C

// this line is a comment on ONLY ONE line

Line or paragraph on several lines:

Code: C

/ * this line is a comment, on SEVERAL lines

which will be ignored by the program, but not by anyone who reads the code

;) * /

Accents

It is strictly forbidden to put accents in programming, except in the comments.

The Variables

As we have seen, in a microcontroller, there are several types of memory. We will only deal with "live" memory (RAM) and "read-only" memory (EEPROM).

I'm going to ask you about a problem. Let’s say you’ve connected a push button to a pin on your Arduino board. How will you store the state of the button (pressed or off)?

What is a Variable?

A variable is a number. This number is stored in a memory space (RAM) of the microcontroller. The way to store them is similar to that used to store shoes: in a numbered locker.

Shoes stored in numbered boxes

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

A Variable is a Number

This number has the distinction of changing its value. Strange, isn't it? Well, not that much, because a variable is  the container of the number in question. And this container will be stored in a memory box. If we materialize this explanation by a diagram, it will give:

number => variable => memory

the symbol "=>" meaning: "is contained in..."

The Name of a Variable

The variable name accepts almost all characters except:

. (point)

, (the comma)

é, à, ç, è (the accents)

Well I will not give them all, it only accepts the alphanumeric alphabet ([a-z], [A-Z], [0-9]) and _ (underscore)

Define a Variable

If we give a number to our program, it doesn't know if it's a variable or not. You have to tell it. For that, we give a type to variables. Yes, because there are several types of variables. For example, the variable "x" has a value of 4, so it is an int type.

Code: C

Well, this code would not work because it is not enough. Indeed, there is a multitude of numbers: whole numbers, decimal numbers, etc. This is why we must assign a variable to a type.

These are the most common types of variables:

int integer -32,768 to +32,767 16 bit 2 byte

long integer -2 147 483 648 to +2 147 483 647 32 bits 4 bytes

whole char -128 to +127 8 bits 1 byte

decimal float -3.4 x to +3.4 x 32 bit 4 byte

double decimal -3.4 x to +3.4 x 32 bit 4 byte

For example, if our variable "x" only takes decimal values, we will use the types int, long, or char. If now the variable "x" does not exceed the value 64 or 87, then we will use the char type.

If, on the other hand, x = 260, then we will use the higher type (which accepts a greater quantity of number) than char, in other words, int or long. But you're not smart; to avoid overspending, we put everything in double or long.

Yes, but no. A microcontroller is not a 2GHz multicore computer, 4GB of RAM. Here we are talking about a system that works with a CPU at 16MHz (0.016 GHz) and 2 KB of SRAM for the RAM. So there are two reasons why you should choose your variables wisely:

- RAM is not extensible when there is more, and there is more.

- The processor is of the 8-bit type (on Arduino UNO), so it is optimized for processing on variables of 8-bit size, processing on a 32-bit variable will, therefore (much) take longer.

If our variable "x" never takes a negative value (-20, -78,...), then we will use an unsigned type. That is, in our case, a char whose value is no longer from -128 to +127, but from 0 to 255.

Here is the table of unsigned types, we identify these types by the word unsigned which precedes them:

Type what number does it store? Maximum values of the stored number, Number of bits and Number of bytes like below:

- unsigned non-negative integer char 0 to 255  - 8 bits, 1 byte

- unsigned int non-negative integer 0 to 65,535 -  16 bits, 2 bytes

- unsigned long non-negative integer 0 to 4,294,967,295  - 32 bits, 4 bytes

One of the peculiarities of the Arduino language is that it accepts a larger number of types of variables.

Type what number does it store? Maximum values of the stored number, Number on X bits Number of bytes like below:

- byte non-negative integer 0 to 255 8 bits 1 byte

- non-negative integer word 0 to 65535 16 bit 2 byte

- non-negative integer boolean 0 to 1 1 bit 1 byte

The Arduino Language (2/2)

I have a question. If I want to make the code I wrote repeat itself, do I have to copy it as many times as I want? Or is there a solution?

This is an excellent question because it is precisely the object of this chapter. We will see how to make a piece of code repeat itself. Then we will see, next, how to organize our code so that it becomes more readable and easy to debug. Finally, we will learn to use the tables that will be very useful.

Here is the program waiting for you.

import processing.video.*;

Movie movie;

void setup()

{

size(640,360);

background(0);

//load and play the video in a loop

movie = new Movie(this,"transit.mov");

movie.loop();

}

void movieEvent(Movie m)

{

m.read();

}

void draw()

{

//if (movie.available() == true)

//{

// movie.read();

//}

image(movie,0,0,width,height);

}

What is a Loop?

In programming, a loop is an instruction that makes it possible to repeat a piece of code. This will allow us to repeat an end of program or an entire program.

There are two main types of loops:

The conditional loop tests a condition and executes the instructions it contains as long as the condition tested is true.

The repeat loop executes the instructions it contains a predetermined number of times.

The while loop

Problem: I want the electric shutter of my window to close automatically when night falls. We will not take care of making the system that closes the shutter at the arrival of the night. The Arduino board has a sensor which indicates the position of the flap (open or closed). What we are trying to do is create a piece of code that brings the shutter down until it is closed.

To solve the problem, we will have to use a loop.

/ * HERE, a bit of program allows you to do the following things:

_ a sensor detects nightfall and daybreak o If it is night, then we must close the shutter

o Otherwise, if it is the day, we must open the shutter

_ the program reads the state of the sensor which indicates whether the shutter is open or closed

_ recording of this state in the String variable: position_volet

o If the shutter is open, then: position_volet = "open";

o Otherwise, if the shutter is closed: position_volet = "closed";

* /

while (position_volet == "open")

{

// instructions that lower the shutter

}

The do... while loop

This loop is similar to the previous one. But there is a difference that matters. In fact, if we pay attention to the condition in the while loop, we will notice that it is tested before entering the loop. While loop, the condition is tested only when the program has entered the loop:

Code: C

do

{

the instructions between these braces are repeated as long as the condition is false } while (/ * condition to test * /);

The word does come from English and translates as do. So the do while loop means "do the instructions, as long as the condition tested is false." While in a while loop, you could say, "as long as the condition is false, do the following."

What Does it Change?

Well, in a while loop, if the condition is true from the start, we will never enter this loop. Conversely, with a loop do while we enter the loop, then we test the condition. Let's take our counter:

let i = 5;

do {

alert( i );

i++;

} while (i > 5);

In this code, the counter value is defined from the start at 5. However, the program will enter the loop when the condition is false. So the loop is executed at least once. And whatever the veracity of the condition. In the test it gives:

Concatenation

A loop is an instruction that has been spread over several lines. But we can write it on one line:

while(…) {…}

This is why you should not forget the semicolon at the end (after the while). While in a simple while loop, the semicolon should not be put.

The for loop

This is a very special loop. What it will allow us to do is quite simple. This loop is executed X times. Unlike the two previous loops, we must give it three parameters.

First, we create the loop with the term for (means "for that"). Then, between the parentheses, we must give three parameters which are creation and assignment of the variable to a starting value followed by the definition of the condition to be tested followed by the instruction to execute

The Arduino language does not accept the absence of the following line:

We are forced to declare the variable we are going to use (with its type) in the for a loop.

So, if we link this line: "FOR counter = 0 and counter less than 5, we increment counter". More concisely, the loop is executed as many times as it takes counter to get to 5. So here, the code inside the loop will be executed five times.

The infinite loop

The infinite loop is very simple to achieve, especially since it is sometimes very useful. You need to use a while and assign it a value that never changes. In this case, we often put the number

We can read: "As long as the condition is equal to 1, we execute the loop". And this condition will always be met since "1" is not a variable but a number. Also, it is possible to put any other whole number, or the boolean "TRUE":

do {

Block of statements;

}

while(1);

This will not work with the value 0. Indeed, 0 means "false condition," so the loop will stop immediately... The loop () function behaves like an infinite loop since it repeats itself after it has finished executing its tasks.

The Functions

In a program, the lines are often numerous. It then becomes imperative to separate the program into small pieces to improve the readability of it, in addition to improving the operation and facilitating debugging. We will see together what a function is, and then we will learn how to create and call them.

What is a Function?

A function is a "container" but different from the variables. Indeed, a variable can only contain a number, while a function can contain an entire program.

In fact, when we program our Arduino board, we will write our program in functions. For the moment, we only know 2: setup () and loop ().

In the previous example, instead of the comment, we can put instructions (conditions, loops, variables, etc.). This is these instructions that will make up the program in itself.

To be more concrete, a function is a piece of program that allows you to perform a specific task. For example, to format a text, you can color a word in blue, put the word in bold or even enlarge this word.

Bold - to put the word in bold color, to put the word in blue enlarge, to increase the size of the word in programming, we will use functions. So these functions are "divided into two large families." What I mean by that is that there are ready-made functions in the Arduino language and others that we will have to create ourselves.

You cannot write a program without putting functions inside. We are forced to use the setup () and loop () function (even if we don't put anything in it). If you write instructions outside of a function, the Arduino software will systematically refuse to compile your program. There are only global variables that you can declare outside of the functions.

I did not really understand what it is for

The usefulness of a function lies in its ability to simplify the code and separate it into "little bits" that we will assemble to create the final program. If you want, it's a bit like plastic building sets: each piece has its own mechanism and performs a function.

For example, a wheel makes it possible to roll; a block makes it possible to join several other blocks together; a motor will move the created object forward. Well, all these elements will be assembled to form an object (car, house, etc.).  like, the functions will be joined together to form a program. For example, we will have the function: "squaring a number"; the function: "add a + b"; etc. Which, in the end, will give the desired result.

Make a Function

To make a function, we need to know three things:

- What type of function do I want to create?

- What will his name be?

- What parameter (s) will it take?

Function Name

To start, we will, first, choose the name of the function. For example, if your function has to retrieve the temperature of a room supplied by a temperature sensor: you will call the function RoomTemperaturePiece, or room_temperature_piece, or lecture_temp_piece.

Well, names can be given full, but be logical about the choice of the latter. It will be easier to understand the code than if you call it tmp (for temperature). An explicit function name guarantees quick reading and easy understanding of the code. A reader should know what the function is doing by name, without reading the content.

Types and Parameters

The purpose of the functions is to split your program into different logical units. Ideally, the main program should only use function calls, with minimal processing. To be able to function, they mostly use "things" as inputs and return "something" as outputs. The inputs will be called function parameters, and the output will be called the return value.

The Settings

The parameters are used to feed your function; they are used to give information to the process it must carry out. Let’s take a concrete example.

To change the state of an output of the microcontroller, Arduino offers the following function: digitalWrite (pin, value). Thus, the reference explains to us that the function has the following characteristics:

- pin parameter: the number of the pin to be changed

- value parameter: the state in which to put the spindle (HIGH, (high, + 5V) or LOW (low, ground))

- return: no return of result

As you can see, the example is self-explanatory without reading the function code. Its name, digitalWrite ("digital writing" for anglophobes), means that we will change the state of a digital pin (therefore not analog). Its parameters also have explicit names, pin for the pin to change, and value for the state to give it.

When you go to create functions, it is up to you to see if they need parameters or not. For example, you want to do a function that pauses your program, and you can do a Pause () function that takes a parameter of type char or int, etc. (this will depend on the size of the variable). This variable will, therefore, be the parameter of our Pause () function and will determine the duration during which the program will be paused.

We will, therefore, obtain, for example, the following syntax: void Pause (char duration).

To sum up a bit, we have the choice of creating empty functions, therefore without parameters, or else "typed" functions that accept one or more parameters.

But what is "Void"?

I arrive there. Remember, a little above, I explained to you that a function could return a value, the famous output value, I will now explain how it works.

Empty Functions

We have  seen that a function could accept parameters. But it is not compulsory. A function that does not accept parameters is empty.

We, therefore, use the void type to say that the function will have no parameters. A void type function cannot return a value. For example:

void Arrange(int left,int right){

int i,j,x,w;

i=left,j=right;

x=(left+right)/2;

do{

while(struct[i].number < struct[x].number)i++;

while(struct[j].number > struct[x].number)j--;

if(i<=j){

w=struct[i].number;

struct[i].number=struct[j].number;

struct[j].number=w;

i++;j--;

}}while(i<=j);

if(left<j)

return Arrange(left,j); //1st recursive call. It doesn't work.

if(right>i)

return Arrange(i,right); //2nd recursive call.It doesn't work either.

};

This code will not work because the function () is of type void. However, it must return a variable that is of type int. Which is impossible.

The "Typed" Functions

Indeed, if we want to create a function that calculates the result of an addition of two numbers (or a more complex calculation), it would be good to be able to return the result directly rather than to store it in a variable which has a global scope and access that variable in another function.

Clearly, calling the function gives us the result directly. We can then do "what we want" with this result (store it in a variable, use it in a function, make it undergo an operation,...)

How to Create a Typed Function

In itself, this is not complicated, and you have to replace the void with the chosen type (int, long, etc.) Here is an example:

void setup(){

Serial.begin(9600);

}

void loop() {

int i = 10;

int j = 44;

int k;

k = myMultiplyFunction(i, j); // k now contains 440

Serial.println(k);

delay(500);

}

int myMultiplyFunction(int x, int y){

int result;

result = x * y;

return result;

}

Note that I have not put the two main functions, namely setup () and loop (), but they are mandatory.

In the loop () function, we do a calculation with the value returned by the function myFunction (). In other words, the calculation is: calculation = 10 * 44; Which gives us: calculation = 440.

Well, this is a very simple example to show you how it works. Later, when you are ready, you will certainly use this combination in a more complex way.

As this example is very simple, I did not write the value returned by the function myFunction () in a variable, but it is better to do so. At least, when it is useful, which is not the case here?

Functions with Parameters

It's all very nice, but now you're going to see something much more interesting. Here is a code; we will see what it does after:

void loop(){

int i = 2;

int j = 3;

int k;

k = myMultiplyFunction(i, j); // k now contains 6

}

What is going on?

I defined three variables: sum, x, and y. The function of my Function () is "typed" and accepts parameters. Let's read the code at the beginning:

void setup(){

Serial.begin(9600);

}

void loop() {

int i = 2;

int j = 3;

int k ;

k = myMultiplyFunction(i, j); // k now contains 6

Serial.println(k);

delay(500);

}

int myMultiplyFunction(int x, int y){

int result;

result = x * y;

return result;

}

We Declare our Variables

The loop () function calls the myFunction () function that we created

It is on this last point that we will look. We gave the parameters function. We use these parameters to "feed" the function. To put it simply, we say to the function: "These are two parameters, I want you to use them to do the calculation I want."

Then comes the signing of the function

The signature... what are you talking about?

The signature is the "full title" of the function. Thanks to it, we know the name of the function, the type of the returned value, and the type of the different parameters.

The function retrieves the variables sent to it from variables. In other words, in the variable param1, we find the variable x. In the variable param2, we find the variable y.

Either: param1 = x = 64 and param2 = y = 192.

Finally, we use these two variables created "on the fly" in the function's signature to perform the desired calculation (a sum in our case).

What's the point of doing all this? Why don't we use the variables x and y in the function?

This will help us to simplify our code. For example, you want to do several operations (addition, subtraction, etc.), and instead of creating several functions, we will only create one that does them all. But, to tell it which operation to do, you will give it a parameter telling it: "Multiply these two numbers" or else "add these two numbers."

What it would do:

So if the operation variable is 0, we add the variables x and y; otherwise, if the operation is 1, we subtract y from x. Simple to understand, isn't it?

The Tables

As the name suggests, this part will talk about tables.

What is the point of talking about this? Well, think again, on the computer a table has nothing to do. If we had a lot to summarize, an array is a big variable. Its purpose is to store elements of the same types by putting them in boxes. For example, a teacher who stores the grades of his students will use a floating table (a floating-point number) with one box per student.

We will use this example throughout this section. Here are some details to understand everything: each pupil will be identified by a number going from 0 (the first pupil) to 19 (the twentieth pupil of the class) one starts from 0 because in data processing the first value in a table is 0.

A Table in Programming

A table,  like in Excel, is a set made up of boxes, which will contain information. In programming, this information will be numbered. Each box in an array will contain a value.

What's the Point?

We will mainly use arrays when we need to store information without creating a variable for each information.

The Maximum Score

As the title indicates, we will look for the maximum grade (the best student in the class). The function will receive in parameter the array of float, the number of elements in this array, and will return the best note.

Code: C

float bestNote (float array [], int highNumber)

{

int i = 0;

int max = 0; // variables containing the highest grade

for (i = 0; i <highNumber, i ++)

{

if (table [i]> max) // if the grade read is better than the best current

{

max = array [i]; // then we save it

}

}

return max; // we return the best grade

}

What you do to read an array is exactly the same as when you initialize it with a loop.

It is quite possible to put the value of the searched box in a variable:

Code: C

int value = array [5]; // we save the value of the box

6 of the array in a variable

Well, it was not that hard; you can do the same to find the minimum value To practice.

Average Calculation

Here, we will look for the average of the grades. The signature of the function will be exactly the same as that of the previous function, unlike the name. Let you think, here is the signature of the function, the code is lower but try to find it yourself before:

Code: C

float mediumNote (float array [], int numberHigh)

A solution:

Secret (click to display)

Code: C

float mediumNote (float array [], int numberHigh)

{

int i = 0;

double total = 0; // add all the grades

average float = 0; // average of grades

for (i = 0; i <highNumber; i ++)

{

total = total + table [i];

}

mean = total / number High;

average return;

}

We finish with the tables, we may see more things in practice.

Now you are joyful because you have finished the first part.

You are ready to start using your card. So go to the next part of the book.

Chapter 2

Input / Output Management

Now that you have gained enough programming knowledge and some notions of electronics from the previous chapter and in this chapter, we will look at the use of the Arduino board. I will tell you about the inputs and outputs of the card. We are going to start simply, so do not be surprised if you go quickly to reading the chapters.

Do not neglect the basics; otherwise, you may not be able to follow the more complex chapters. A piece of advice – make sure you understand everything before you move on – there is no rush; everyone should work at their own pace.

Our First Program

You have finally arrived at the fateful moment when you will have to program. But before that, I will show you what will serve us for this chapter. In this case, learn to use an LED and the reference, present on the Arduino.cc site, which will be very useful when you need to make a program using a concept that is not covered in this book.

The LED / LED Light-Emitting Diode

The question is not to know which abbreviation to choose, but to know what it is.

A LED / LED: Light-Emitting Diode, or "Light Emitting Diode”. It is an electronic component that creates light when an electric current flows through it. I made you buy different colors. You can, for this chapter, use whatever you want. You see, a photo of a red LED. The size is not real, its "head" (in red) is only 5mm in diameter. It is this component that we will try to light with our Arduino board. But before, let's see how it works.

I will call the light-emitting diode, throughout the book, an LED. An LED is a diode that emits light. So I will talk to you about how LEDs work at the same time as LEDs. There is very little difference between the two. The LED is simply a diode that emits light, hence the arrows on its symbol.

Direct Polarization

We speak of polarization when an electronic component is used in an electronic circuit in the "right way." In fact, when it is polarized, it is because we use it in the desired way.

To polarize the diode, we ensure that the current must flow from the anode to the cathode. In other words, the voltage must be higher at the anode than at the cathode.

Reverse Polarization

The reverse bias of a diode is the opposite of forwarding bias. To create this type of assembly, it is simply enough, in our case, to "turn over" the diode finally to connect it "upside down." In this case, the current does not pass.

Note: a reverse-biased diode will not burn out if used in the right conditions. In fact, it works "the same way" for the positive and negative current.

If you do not want to make your first diode go up in smoke, I advise you to read the next lines carefully. In electronics, we must take two parameters into account: current and voltage. For a diode, two voltages are important. These are the maximum voltage in forwarding polarization, and the maximum voltage in reverse polarization. Then, for the LEDs to work properly, the current is also important.

Maximum Direct Voltage

When using a component, we must get into the habit of using the "datasheet" ("technical documentation”), which gives us all the characteristics of the component. In this datasheet, we will find something called "Forward Voltage” for the diode. This indicator represents the voltage drop across the diode when current flows directly through it. For a conventional diode (type 1N4148), this voltage will be around 1V. For a led, we will rather consider a voltage of 1.2 to 1.6V.

Well, to make our small assemblies, we will not quibble, but it is the approach to do when we design an electrical diagram and that we dimension its components.

Maximum Reverse Voltage

This voltage represents the maximum admissible difference between the anode and the cathode when the latter is connected "upside-down." In fact, if you put too much voltage on these terminals, the junction will not be able to support it and will go up in smoke. We find this voltage under the name of "Reverse Voltage" (or even "Breakdown Voltage"). If we take the diode 1N4148, it will be between 75 and 100V. Beyond this voltage, the junction breaks, and the diode becomes unusable. In this case, the diode becomes either a short circuit or an open circuit. Sometimes this can cause significant damage to our electronic appliances. Anyway, we will never handle 75V.

The Flowing Current

For an LED, the current flowing through it is important. If you connect the led directly to a battery, it will light up, then sooner or later, will eventually go out.

If we do not limit the current flowing through the LED, it will take the maximum current, and that is not good because it is not the maximum current that it can support. To limit the current, a resistor is placed before (or after) the LED. This resistance, expertly calculated, will allow it to ensure optimal operation.

But how do you calculate this resistance?

Simply with the basic formula, ohm's law. Little reminder:

Then, we will take for the example a supply voltage of 5V (at the output of the Arduino, for example) and a voltage at the terminals of the LED of 1.2V in normal operation. We can, therefore, calculate the voltage which will be at the terminals of the resistor:

Finally, we can calculate the resistance value to use:

And voila, you know the value of the resistance to use to be sure not to burn LEDs out of the arm. Is it better to use a higher value or lower value resistor?

Where do we start?

The Goal

The aim of this first program is to light an LED, however, it may feel somewhat tricky here but everything will be in control over time. The plan is to show you two or three things that can help you when you want to leave the nest and take the flight to new skies.

Equipment

To be able to program, you obviously need an Arduino board and an USB cable to connect the board to the PC. But to see the outcome of your program, you will need additional items. In particular, an LED and a resistor.

Production

With the pinout of the Arduino board, you will need to connect the larger tab to the + 5V (5V pin). The smallest tab being connected to the resistor, itself connected to pin number 2 on the card. We could do the opposite, connect the LED to the ground and turn it on by supplying 5V from the signal pin. However, components like microcontrollers do not like to deliver current too much, and they prefer to absorb it. For this, we will, therefore, prefer to power the LED by placing it at + 5V and putting the Arduino pin to ground to pass the current. If we put the pin at 5V, in this case, the potential is the same on each side of the LED, and it does not light up.

Create A New Project

To be able to program our card, we must create a new program. Open your Arduino software. Go to the File menu and choose the Save as... option:

What is it?

Arduino is a project in which the community is very active, offers us on its website a reference. But what is it? Well, it is simply the "user manual" of the Arduino language.

More precisely, an internet page on their site is dedicated to referencing each code that can be used to make a program.

How to use it?

To use it go to the page of their site. What we see when we get to the page is three columns, each with an element that makes up the Arduino languages.

Structure: this column references the elements of the Arduino language structure. It contains conditions, operations, etc.

Variables: As its name suggests, it brings together the different variables that can be used, and certain specified operations

Functions: Here it is everything else, but especially the read / write functions of the pins of the microcontroller (and other very useful functions)

It is very important to know how to use the documentation that Arduino offers us. Because knowing this, you can make programs without having previously learned to use one function or another.

Turn on our LED

1st Step

First of all, we must define the pins of the microcontroller. This step itself makes up two sub-steps. The first being to create a variable defining the pin used, then define if the pin used should be an input of the microcontroller or an output.

The term const means that we define the variable as being constant. We change the nature of the variable which then becomes constant.

The term int corresponds to a type of variable. By defining a variable of this type, it can store a number ranging from - 2149531648 to +2197438647. That is enough for us.

We are, therefore, in the presence of a variable named led_red, which is  a constant which can take a value ranging from -2147483648 to +2147483647. In our case, we assign this variable to 2.

When your code is compiled, the microcontroller will know that on its pin number 2, there is a connecting element.

Well, that is not enough to define the pin used. We must now say whether this pin is an input or an output. Yes, because the microcontroller can use some of its pins for input or output. It is fabulous. It suffices simply to interchange ONE line of code to say that it is necessary to use a pin as input (retrieval of data) or as output (sending of data).

This line of code precisely, let’s talk about it. It must be in the setup () function. In the reference, what we need is in the Functions category, then in Digital I/o. I/o for Input / Output, which means: Input / Output.

The function is pinMode (). To use this function, you must send it two parameters: The name of the variable that you defined on the pin.

2nd Step

This second step is to create the content for our program. Whoever is going to replace the comment in the loop () function, achieving our aim: turn on the LED.

Again, we do not snap our fingers to have the program ready. You have to go back to the Arduino reference to find what you need.

Yes, but now we don't know what we want?

We are looking for a function that will allow us to light this LED, so we have to find it. Let's be a bit logical if you don't mind. We know it's a function we need (I said it a moment ago), so we look in the Functions category of the reference.

If we keep our logical mind, we will take care of lighting an LED, so to say what is the output state of pin number 2 where which is connected to our LED. So it's a safe bet that it's in Digital I/o. Well, there is a suspicious function called digitalWrite (). In French, this means "digital writing." It is, therefore, the writing of a logical state (0 or 1).

What is the first sentence in the description of this function? This one: "Write a HIGH or a LOW value to a digital pin." According to our bilingual level, we can translate by Writing a HIGH value or a LOW value on a digital output. Bingo. This is what we were looking for.

What does "HIGH Value or LOW Value" Mean?

In digital electronics, a high level will correspond to a voltage of + 5V, and a so-called low level will be a voltage of 0V (generally ground). Except that we have connected the LED to the positive pole of the power supply so that it lights up, we must connect it to 0V. Therefore, a low state must be set on the pin of the microcontroller. Thus, the potential difference across the LEDs will allow it to light up.

Let's take a look at how digitalWrite () works by looking at its syntax. It requires two parameters. The name of the spindle that we want to put in a logical state and the value of this logical state.

We will therefore write the following code, using this syntax:

Code: C

digitalWrite (led_red, LOW); // write output (pin 2) of a LOW state

If we test the whole code:

Code: C

const int led_red = 2; // definition of pin 2 of the card as a variable

void setup ()

// card initialization function

{

pinMode (led_red, OUTPUT); // initialization of pin 2 as an output

}

void loop () // main function, it repeats (runs) endlessly

{

digitalWrite (led_red, LOW); // write output (pin 2) of a LOW state

}

We see the LED light up... It's fantastic.

Now you know how to use the outputs of the microcontroller, so we can get down to business and make our LED flash.

Enter time

It is fine to light an LED, but if it does nothing else, it is not very useful. You might as well plug it directly into a battery (with resistance all the same.). So let's see how to make this LED interesting by making it flash.

For this, we will have to introduce the concept of time. Well, guess what? There is a ready-made function there again. Let's go to practice.

How to do this?

Have a look for yourself; it will help you learn

I let you search a little by yourself, and it will train you.

For those who have attempted to search and have not found the function, here it is: delay ()

A short description of the function will be used to pause the program for a predetermined time.

Use the Command

The function accepts a parameter, which is the time during which we want to pause the program. We must give this time in milliseconds. If you want to stop the program for 1 second, you will have to give the function at the same time, written in milliseconds, or 1000ms.

Practice: Flash an LED

So, if we want to make our LED flash, we will have to use this function.

The LED lights up. Then, we use the delay () function, which will pause the program for a certain time. Then we turn off the LED. We pause the program. Then we return to the start of the program. We start again, and so on. It is this command sum, which forms the process that causes the LED to flash.

Henceforth, get into the habit of making this kind of diagram when you make a program.

Now we need to translate this diagram, bearing the name of the organization chart, into code. You have to replace the sentences in each frame with a line of code.

The Program

Normally, its design should not cause you any problems. It suffices to retrieve the code of the previous program ("light a group of LEDs") and modify it according to our needs.

This code, I give it to you, with the comments that go well:

Code: C

// we keep the same start as the previous program

const int L1 = 2; // pin 2 of the microcontroller is now called: L1

const int L2 = 3; // pin 3 of the microcontroller is now called: L2

const int L3 = 4; //...

const int L4 = 5; const int L5 = 6; const int L6 = 7;

void setup ()

{

pinMode (L1, OUTPUT); // L1 is a pinMode output pin (L2, OUTPUT); // L2 is a pinMode output pin (L3, OUTPUT); //...

pinMode (L4, OUTPUT); pinMode (L5, OUTPUT); pinMode (L6, OUTPUT);

}

// we  change the inside of the loop to reach our goal

void loop () // the loop () function executes the following code by repeating it in a loop

{

digitalWrite (L1, LOW); // switch on L1 delay (1000); // wait 1 second digitalWrite (L1, HIGH); // we extinguish L1

digitalWrite (L2, LOW); // we switch on L2 at the same time as we switch off L1

delay (1000); // we wait 1 second digitalWrite (L2, HIGH); // we turn off L2 and digitalWrite (L3, LOW); // we immediately turn on L3 delay (1000); //...

digitalWrite (L3, HIGH); digitalWrite (L4, LOW); delay (1000); digitalWrite (L4, HIGH); digitalWrite (L5, LOW); delay (1000); digitalWrite (L5, HIGH); digitalWrite (L6, LOW); delay (1000); digitalWrite (L6, HIGH);

}

As you can see, this code is very heavy and not practical. We will see later how to make it lighter. But before that, a TP arrives...

Millis () Function

We will end this chapter with a point that can be useful, especially in certain situations where we do not want to stop the program. If you want to flash an LED without stopping the execution of the program, you cannot use the delay () function, which pauses the program for the defined time.

Limits of the Delay () Function

You have probably noticed that when you use the "delay ()" function, our whole program stops waiting for you to wait. Sometimes, this is not a problem, but in some cases, it can be more troublesome.

Imagine, you are moving a robot forward. You put your motors at medium speed, quiet, until a small button on the front is pressed (it clicks when you touch a wall, for example). During this time, you decide to make signals by flashing your LEDs. To make a nice flash, you turn on a red LED for one second and then turned it off for another second. This is, for example, what we could do as code:

Code: C

void setup ()

{

pinMode (motor, OUTPUT); pinMode (led, OUTPUT); pinMode (button, INPUT);

digitalWrite (motor, HIGH); // we start the engine

digitalWrite (led, LOW); // we turn off the LED

}

void loop ()

{

if (digitalRead (button) == HIGH) // if the button is clicked (we enter a wall)

{

digitalWrite (engine, LOW); // we stop the engine

}

else // otherwise we blink

{

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

}

Please note this code is not at all rigorous or even false in its writing; it  serves to understand the principle.

Now imagine you drive, test the button that is not pressed, so blink the LEDs (case of else). The time you do, the entire display runs out two long seconds. The robot has been able to take the wall in the middle of this pearl for eternity, and the motors continue to advance head down until smoking. It is not good at all.

Chapter 3

Programming With Arduino

This chapter starts much theory, we begin directly with programming. "Learning by doing" is the magic word here. While the left side of the so-called "sketches" are printed and are located in the right pane Reviewing the code.

Anyone who works through the programs under this system will be able to see through the program code in a short time and apply yourself. Later even become familiar with other functions you then. This guide is only an introduction to the Arduino platform. All possible program functions or

Program code is on the website "www.arduino.cc " under the point called "reference."

Before we start a piece of brief information on possible errors that might arise while working with the Arduino software. The most common are the following two:

1. The board is not installed properly or selected the wrong board. When Upload, it displays the sketch an error message at the bottom of the software that roughly looks like as shown at right. In error, the text is then a Noted "not in sync."

2. There is an error in the sketch. For example, a word is misspelled, or it lacks only a clamp or a semicolon. In the example, the left brace that introduces the loop part is missing. The error message then begins often with "expected...” This means that the program expects something that does not yet exist.

The Basic Structure of a Sketch

We may divide a sketch into three areas.

1. Variables to Name

In the first area, elements have named the program (What that means, we learn in the program No. 3). This part is not mandatory.

2. Setup (essential in the program)

The setup is performed by the Board only once. Here, dividing the program with, for example, which pin is (slot for cable) on the microcontroller board, an output or an input.

Here, a voltage at the output Board shall: defined as the output. Example: This pin an LED to be illuminated.

Defined as input: Here, a voltage to be read by the Board. Example: a switch is pressed, and the Board noted the fact that he recognizes this input pin voltage.

3. Loop (essential in the program)

The loop portion is repeated continuously by Board. It processes the sketch once completely to the end and then starts again at the beginning of the loop part.

Instructions

A Flashing LED

Task: A light-emitting diode to blink.

Material: Only the microcontroller board with the USB cable.

On the Arduino, an LED is connected to pin 13 is already installed (for test purposes). Often this light blinks on when you connect a new Arduino board, as the flashing program is already pre-installed for testing the board depending on the manufacturer. We will program this flashing now itself.

Circuit

The existing on the board

LED is circled in red in the diagram.

You have to connect to the computer, only the board via an USB cable.

1.1     Program Section 1: variable name

- Here we go, first nothing.

1.2     Program Section 2: Setup

We have only one exit - to pin 13 to a voltage output (the LED will light up eventually.).

We write in the middle of the white box the Arduino software:

void set up()   // Here the setup starts

{   // brace on - Here begins a program section.

}   // curly bracket - Here ends a program section.

In part between the braces, we now introduce the setup information. In this case, "an output pin 13 is supposed to be."

void set up() // Here the setup starts

{   // Here a program section starts.

pinMode(13, OUTPUT); //          Pin 13 is what the output should be.

}   // Here, a program segment ends.

1.3     Program section 3: Loop (main body)

void set up()   // Here the setup starts

{   // Here a program section starts. pinMode(13, OUTPUT);              // pin 13 is to be a starting

}   // Here a program segment ends. void loop()     // Here the main program begins

{   // Here a program section starts.

}   // Here a program segment ends.

Now the contents of the loop part, ie, the main program is introduced: THIS IS THE COMPLETE SKETCH:

void set up()   // Here the setup starts

{   // Here a program section starts.

pinMode(13, OUTPUT);    // pin 13 to be an output.

}   // Here a program segment ends. void loop()     // Here the main program begins

{   // Program section begins.

digitalWrite(13, HIGH);    // Turn the the voltage at pin 13 a (LED on). delay(1000);              // wait 1000 milliseconds (one second)

digitalWrite(13, LOW);      // Turn the the voltage at pin 13 from (LED off). delay(1000);              // wait 1000 milliseconds (one second).

} // Program section         completed.

Finished. The sketch should now look exactly as it appears on the screen is shown on the right. It has to be now  uploaded to the board. This works with the red circled button (top left of the software).

1.4     Now we can create variation to the program. For example, the LED will blink rapidly. To do this, we reduce waiting times (from 1000ms to 200ms)

void set up()   // Here the setup starts

{   // Here a program section starts.

pinMode(13, OUTPUT);    // pin 13 to be an output.

}   // Here, a program segment ends. void loop()    // Here the main program begins

{   // Program section begins.

digitalWrite(13, HIGH);    // Turn the the voltage at pin 13 a (LED on). delay(200);              // Wait 200 milliseconds

digitalWrite(13, LOW);      // Turn the the voltage at pin 13 from (LED off). delay(200);              // Wait 200 milliseconds

} // Program section         completed.

The new Sketch must now again be uploaded to the board. If all goes well, the LED is now flashing faster.

The Change Indicators

Material: Arduino / two light-emitting diodes (blue) / two resistors 100 ohms / Breadboard / cable

Sketch:

void set up()

{   // // We start with the Setup

pinMode(7, OUTPUT);      // pin 7 is an output. pinMode(8th, OUTPUT);              // pin 8 is an output.

}

void loop()

{   // The main program starts.

digitalWrite(7, HIGH);                     to Pin7 // Turn on the LED. delay(1000);              // wait 1000 milliseconds. digitalWrite(7, LOW);              // Turn the LED off at Pin7. digitalWrite(8th, HIGH);                            // Turn the LED on a Pin8. delay(1000);              // wait 1000 milliseconds. digitalWrite(8th, LOW);              // Turn the LED off at Pin8.

} // Here at the end of the program jumps to the start of the loop part. So…

//... turn the LED on pin 7.

//... etc... etc... etc...

An LED Pulsing Leave

Task: An LED to be pulsed light and dark. (Also referred to as English. "Thread")

Material: Arduino / an LED (blue) / A resistor 100 Ohm / Breadboard / cable assembly:

The Arduino is a digital microcontroller. We know it outputs only "5 volts" or "5V off". To vary the brightness of an LED, you would need, but the voltage may vary. For example, 5V when the LED light illuminates. 4 volts when darker lit something so GOING TO DIGITAL PINS BUT NOT. There is an alternative, however. It is called pulse width modulation (PWM called).

The PWM pulsates the 5V voltage. The voltage is thus a millisecond on and off. At a high PWM, the 5V signal is almost continuously on the respective pin. At a low PWM, the 5V signal is virtually non-existent (since this is a very compact summary, you should look on the Internet for further explanation).

This PWM, you can achieve a similar effect with LEDs as if you were the voltage varies. Not all digital pins on the board have the PWM function. The pins on which the PWM works are specially marked, e.g. through a small wave of the number with the pin number. Here we go.

Sketch:

int LED = 9; // The word "LED" is now available for the value. 9

int Brightness = 0;   // The word "brightness" is now available for the value in the

// PWM output. The number 0 is only an arbitrary starting value.

int fade steps = 5;    // fade steps: determines the speed of the "thread" void set up()

{   // Here the setup starts.

pinMode(LED, OUTPUT);  //// The pin with the LED (Pin9) is an output

}

void loop()

{

analog write(LED, brightness);  // The function analog write is here at the

// Pin activated with the LED (Pin9) the PWM output. The PWM value is the value

// stored under the name of "brightness". In this case, "0" (See

// first program section)

brightness + = brightness fade steps; // Now, the value of the PWM output

// changed. Under the value "brightness" is now the previous brightness

// the value for the fade steps added. In this case: brightness = 0 + 5. The

// new value for "brightness" is therefore no longer 0 but 5. Once the loop

// part is once gone through, he repeats. Then the value is for

// the brightness of 10. In the next cycle 15, etc., etc...

delay(25); // The LED should for 25ms (milliseconds), so only very briefly

// maintained brightness. Decreasing this value, the pulsation

// also faster.

if(Brightness == 0 || brightness == 255) { // Command explanation: When the

// brightness has reached the value 0 ORDER 255, the value for the change

// "fade steps" from positive to negative or vice versa. Reason: The LED is

always a bit brighter // first with each pass of the loop part.

// However, at some point the maximum value for the PWM output with the value 255

//reached. The LED will then gradually become darker. So

// the value for the "fade steps" is at this point Negating (A

// minus sign is placed in front of it)

fade steps = -fadeschritte; // That means for the next pass that in

// the line "brightness = brightness + fade steps," the brightness decreases.

// Example: "brightness = 255 + (- 5)". The value of brightness is from then 250. In

// next pass 245, etc., etc... Once the value for brightness at 0

// has arrived, returns the sign. (Consider the old

// mathematical rule: "minus and minus gives plus").

}

} // This last clip of the loop portion is closed.

Simultaneous Lighting and Sound

Task: An LED and a piezo speaker will continuously flash or beep. Material: Arduino / a LED / A resistor 200 Ohm / A piezo speaker / Breadboard / cable

Sketch:

// This time, we also use the first program section. We enter

// variables. This means that behind a letter or

// one word hides a number. For us, the LED on pin 4 is connected and

// the piezo speaker to pin 5. This is the two pins later not

// confused, we call Pin4 and Pin5 simply.

int LED = 4; // The word "LED" is now available for the number "4".

int pieps = 5;  // The word "beep" is now available for the number "5". void set up()

{   // We start with the setup.

pinMode(LED, OUTPUT);  // pin 4 (pin "LED") is an output. pinMode(Beeping, OUTPUT);                            // Pin 5 (Pin "beep") is an output.

}

void loop()

{   // The main program starts. digitalWrite(LED, HIGH);              // Turn the light on

digitalWrite(Beeping, HIGH);                    // Switch to the piezo speaker. delay(1000);              // wait 1000 milliseconds. (It beeps and lights up.)digitalWrite(LED, LOW);              // Switch from LED. digitalWrite(Beeping, LOW);                            // Turn on the piezo out.

delay(1000);   // wait 1000 milliseconds. (No noise, no light)

} // Here at the end of the program jumps to the start of the loop part. so becomes

// it beeps again and lights. If one reduces the pause (delay)

// or enlarged beeps and lights it faster or slower.

Activate a LED Touch of a Button

Task: An LED to be lit for 5 seconds when a button has been operated.

Material: Arduino / an LED (blue) / A resistor 100 Ohm / A resistor 1K ohms (1000 ohms) / Breadboard / cable / probe

The microcontroller can output to its digital pins, not only tensions but also read out. We want to try this program. In the structure, however, there is a special feature. If you simply connect the switch only to the microcontroller, then up to the pin of the microcontroller to a voltage as soon as the button is pressed.

You can think of it that way as if many electrons are floating around the said pin. If we then release the button, no new electrons are more being added to the pin on the microcontroller. Now the rub comes. The electrons that have made it before relaxing on the pin, then still there and escape only very slowly over small leakage currents.

The microcontroller then so thinks that the button is not pressed only briefly, but that it is pressed very long. Namely, until no electrons spend more on the pin, this problem can be correct in that one grounding pin via a resistor to about 1000 ohms (1K ohms). The electrons can thus very quickly drain away from the pin, and the microcontroller detects that the button has been "touched" only briefly.

Since the resistance, the voltage at the input pin to 0V always "pulling down,” it is also referred to as a "pull-down" resistor. NOTE: If you use it too small, resistance can cause a short circuit to the microcontroller when the button is pressed that one grounding pin via a resistor to about 1000 ohms (1K ohms).

The electrons can thus very quickly drain away from the pin, and the microcontroller detects that the button has been "touched" only briefly. Since the resistance, the voltage at the input pin to 0V always "pulling down,” it is also referred to as a "pull-down" resistor. NOTE: If you use it too small, resistance can cause a short circuit to the microcontroller when the button is pressed that one grounding pin via a resistor to about 1000 ohms (1K ohms).

The electrons can thus very quickly drain away from the pin, and the microcontroller detects that the button has been "touched" only briefly. Since the resistance, the voltage at the input pin to 0V always "pulling down,” it is also referred to as a "pull-down" resistor. NOTE: If you use it too small, resistance can cause a short circuit to the microcontroller when the button is pressed.

Sketch:

int LEDblue = 6;      // The word "LEDblue" is now available for the value. 6

int taster = 7; // The word "taster" is now available for the value. 7

int button status = 0;        // The word "taster status" is now available for the first

// value 0 is later stored under this variable, if the button is pressed

// or not. void set up()

{   // Here the setup starts.

pinMode(LEDblue, OUTPUT);    // The pin with the LED (pin 6) is now an output. pinMode(Push buttons, INPUT); // The pin with the button (pin 7) is now an entrance.

}

void loop()

{   // This clip the loop portion is opened taster status =digital read(Button);              // Here the Pin7 is read

// (Command: digital read). The result is below the variable "taster status" with

// the value "HIGH" for 5V or "LOW" saved for 0Volt.

if (Taster status == HIGH)        // Processing: When the pushbutton is pressed (The

// voltage signal is high)..

{   Open // Program section of the IF command. digitalWrite(LEDblue, HIGH);              //..dann should light up the LED..

delay(5000);   Although for //..und for 5 seconds (5000 milliseconds). digitalWrite(LEDblue, LOW);              // then the LED off should be.

}   // close the program section of the IF command. else              //... otherwise...

{   Open // Program section of the else command digitalWrite(LEDblue, LOW);              //... to be the LED off.

}   // close the program section of the else command

} // This last clip of the loop part         closed.

An RGB LED Drive

Task: An RGB LED should light up in different colors

Material: Arduino board / RGB-LED / three resistors with 200 Ohm / Breadboard / Cable

What is an RGB LED?

An RGB LED is an LED that can light up in different colors. After the name of the RGB Color Bet "Red,” "Green" and hide

"Blue." The LED is in the interior of three individually addressable LEDs, which shine in the three colors. Therefore, an RGB LED also has so many legs, for example, 4/6/8 legs . The longest of the four legs depending on the version of the common anode (+) or

Cathode (-). With the three shorter legs of the RGB LED, we can control each color.

Version a "common cathode" - the longest leg of the LED is "-,," and the three shorter legs are controlled by "+" (voltage).

Version b) "common anode" - the longest leg of the LED is "+," and the three shorter legs are - controlled (GND). ""

Through a blend of colors, many other colors can be produced very. For example, results from the control of the color "blue" and "green" color

"Turquoise."

Which version you own, you can find by simply repositioning of "+" and "-" on the LED out (Info: An LED lights up only when properly mated)

The Arduino is a digital microcontroller. He knows his digital outputs only "5 volts" or "5V off". So you can generate many different colors with an RGB LED each color of the LED but must be controlled more accurately. This can be done with pulse width modulation and the PWM (pulse width modulation) can be used to the digital pins on the board at which it prints a small shaft.

The PWM allows the voltage between + 5V and 0V pulsate. The voltage is thus a millisecond on and off. At a high PWM, the 5V signal is almost continuously on the respective pin. At a low PWM signal is the 5V virtually non-existent (Since this is a very compact summary, you should look on the Internet for further explanation).

This PWM can achieve a similar effect in LEDs, as would be the voltage varies. The following codes work for both RGB versions alike. It needs only one thing to be observed: In the LED version b (Common anode) should be the value of the "Dark" is set to the 255th. This has the consequence that then, not only a positive voltage at the common positive terminal of the LED but also to the corresponding color. Then, the LED can be no current flowing, and the respective color of the LED remains off between the two contacts.

For this reason, that in this version of the LED, the color is brighter when the value is smaller is also noted for the color mixture. Thus the color lights blue to pin 3 in the sketch bright, if we choose the code for the blue color like this:

int brightness1a = 0;

Sketch 1:

In this code, the three individual colors are sequentially switched on and off.

int LEDblue = 3; // color blue to pin 3 int LEDrot = 5; // color red on pin 5 int LEDgreen = 6; // color green to pin 6

int p = 1000; // p is a break with 1000ms So one second

int brightness1a = 150; // numerical value between 0 and 255 - are

// the luminance of each color at

int brightness1b = 150; // numerical value between 0 and 255 - are

// the luminance of each color at

int brightness1c = 150; // numerical value between 0 and 255 - are

// the luminance of each color at

int dark = 0; // Neumericalvalue 0 means 0V - so LED off void set up()

{

pinMode(LEDblue, OUTPUT); pinMode(LEDgreen, OUTPUT); pinMode(LEDrot, OUTPUT);

}

void loop()

{

analog write(LEDblue, brightness1a); // turn blue delay(P); // Break

analog write(LEDblue, dark); off // blue analog write(LEDrot, brightness1b); // turn on red delay(P); // Break

analog write(LEDrot, dark); rotausschalten //

analog write(LEDgreen, brightness1c); turn green // delay(P); // Break

analog write(LEDgreen, dark); // greenausschalten

}

Sketch 2:

In this code, the three individual colors are in pairs on and off in sequence. Thereby, the color mixing yellow, turquoise, and purple arise.

int LEDblue = 3; // color blue to pin 3 int LEDrot = 5; // color red on pin 5 int LEDgreen = 6; // color green to pin 6

int p = 1000; // p is a break with 1000ms So one second

int brightness1a = 150; // numerical value between 0 and 255 - are

// the luminance of each color at

int brightness1b = 150; // numerical value between 0 and 255 - are

// the luminance of each color at

int brightness1c = 150; // numerical value between 0 and 255 - are

// the luminance of each color at

int dark = 0; // value 0 means 0V - so LED

//out

void set up()

{

pinMode(LEDblue, OUTPUT); pinMode(LEDgreen, OUTPUT); pinMode(LEDrot, OUTPUT);

}

void loop()

{

analog write(LEDgreen, brightness1c); // green and red on yellow = analog write(LEDrot, brightness1b);

delay(P);

analog write(LEDgreen, dark); // green and red from yellow = from analog write(LEDrot, dark);

analog write(LEDgreen, brightness1c); // green, and blue =

//turquoise

analog write(LEDblue, brightness1b); delay(P);

analog write(LEDgreen, dark); // green and blue from turquoise from = analog write(LEDblue, dark);

analog write(LEDrot, brightness1b); // red and blue = purple analog write(LEDblue, brightness1b);

delay(P);

analog write(LEDrot, dark); // red and blue from purple from = analog write(LEDblue, dark)

}

The Motion

Task: A piezo speaker to beep when motion is detected. Material: Arduino / Motion / Breadboard / cable / piezo speaker

Course content: voltage of a motion to read and use for output.

The motion, also called the PIR sensor, is very simple in construction.

Once it detects motion, it is on a pin a voltage

of 5 volts. This only needs to be read and processed by the microcontroller.

Two knobs can ad the duration of the output signal and sensitivity (range).

The plastic lens is lightly connected. If one sets them apart can be seen the infrared detector and can be seen from the label under the lens, as the sensor has to be wired: GND (-), OUT (output of the signal), VCC (+).

There is also a jumper which allows you to switch between two modes at the bottom of the movement.

1. A jumper is quite outside: it detects The output signal after it maintained a motion for a certain time and then deactivated definitely be back, even if there is a movement that could be detected in the action area of the motion. After a certain time, the output signal is generated again.

2. The jumper is like a right slightly offset on the image inside. The output signal remains constantly active as long as the motion is detected a movement and this mode is recommended for Arduino projects.

Sketch:

int piezo = 5; // The word "piezo" is now available for the value. 5

int motion = 7; // The word "movement" is now available for the value. 7

int motion status = 0; // The word "movement status" first, is now available for the

// value 0 is later stored under this variable, whether a movement

// is recognized or not.

void set up() // Here the setup starts.

{

pinMode(Piezo, OUTPUT); // The pin with the piezo (pin 5) is now an output. pinMode(Move, INPUT); // The pin with the motion detector (pin 7) is now

//an entrance.

}

void loop() // The loop part begins

{ // This brace is the Loop section opened. motion status =digital read(Move); // ier of Pin7 is read. The

// result is under the variable "moving status" with the value "HIGH" for

// 5V or "LOW" saved for 0Volt.

if (Movement status == HIGH) // processing: When motion is detected

// (The voltage signal is high)

{ Open // Program section of the IF command. digitalWrite(Piezo, HIGH); // then the piezo will beep. delay(5000); Although //...and for 5 seconds. digitalWrite(Piezo, LOW); //...then it should be quiet.

} // close the program section of the IF command. else //otherwise...

{ Open // Program section of the else command.

digitalWrite(Piezo, LOW); //...should the piezo speaker to be.

} // close the program section of the else command.

} // This last clip of the loop portion is closed.

Read Brightness Sensor

Now it's getting more complicated.

Task: An LED should light when it gets dark or when a photoresist is covered.

Material: Arduino / a LED / resistor with a 200 Ohm / a resistor of 10K ohms / Breadboard / cable / photoresistor

Read Voltages

The microcontroller is to read about a photoresistor how bright it is. For this, one uses a simple physical principle. If in a circuit two consumers are connected one behind the other (in series), then "shared" it is also commonly applied voltage. An example: two identical lamps connected in series, and there is applied a voltage of 6 volts.

Then you can determine with a voltmeter that each abut the lamps only 3 volts. If we connect two unequal lamps (One has a lower resistance), then one can use two different voltages to the two lamps measure, for example. 1.5 volts and 4.5 volts. A photoresistor changes its resistance as a function of light intensity. This effect is exploited so one can generate a voltage division here at all, and it closes the photoresistor and a resistor (1 - 10 K ohms, depending on the photoresistor. The resistor should have a similar resistance value as that of the photoresistor have.) in series and connects it to 5 volts and the "grounding" (ground / GND) - see construction. The microcontroller board is to measure capability of analog signals (voltage) and to process these.

We can do this with the analog inputs on the board and this converts the measured voltage value into a number that can then be further processed. 0 volt corresponds to the number 0, and the highest measured value 5 volts corresponds to the number 1023 (0 to 1023 equals 1024 digits = 10 bits). Example: A voltage of 2.5 volts is measured, then the microcontroller returns the value 512 (1024: 2).

The "Serial Monitor"

The "serial monitor" is an important part of the Arduino software. This "serial monitor" you can display data on the PC, which the microcontroller board to the PC sends (numbers or text). This is very useful because you do not an LCD display that is always connected to the microcontroller, on which one could read certain values.

In the sketch, the "serial monitor” is used to display the values that read the board of the photoresistor. Why is this useful? Suppose the LED to begin only at the onset of darkness to light. Then it must be in an area Sketch gives, which has the function: "If the value of the photo resistance below the value x, then the LED lights will." It would have to know how big the value of x at the onset of twilight.

Solution: (. Eg dusk) I send the read value "x" of the voltage across the photoresistor with appropriate brightness at the "serial monitor" and let him see me there. With this knowledge, I can later modify the program in the following form. "If the voltage output of the photoresistor has a value of" x "below, then turn on the LED."

Sketch:

int input = A0;         // The word "input" is now available for the value "A0" (name

// the analog port 0)

int LED = 10;  // The word "LED" is now available for the value 10

int Sensor value = 0;        // variable for the sensor value with 0 as the start value

void set up()   // Here the setup starts.

{

Serial.begin(9600);  // Communication with the serial port

// started. This one needs to be the actual value read later

let // Display serial monitor in.

pinMode (LED,OUTPUT);  // The pin with the LED (pin 10) is now an output

}

void loop()

{   // This brace is the Loop section opened. Sensor value =analog read(entrance);              // Read the voltage on the photoresistor

// store and under the variable "sensor value". Serial.print("Sensor value =");// Output on Serial Monitor: The word "sensor value"

Serial.print(Sensor value);         // Output on Serial Monitor. The command

the sensor value of the photoresistor is in the form of a number //Serial.print

// sent 0-1023 to the serial monitor.

if(Sensor value> 512)       // If the sensor value is over 512....

{

digitalWrite(LED,HIGH);   //... is to light the LED...

}

else

{

digitalWrite(LED,LOW);    //... otherwise, they will not shine

}

delay(50);       // A short break, during which the LED is on or off

}   // This last clip of the loop portion is closed.

// Now, if the sensor value, for example, at normal brightness. Only the value of 100 has

// (The value depends on the used resistors of the brightness

// and of the current direction), then take the place of the value 512

// much smaller value at which the LED will begin to glow. For example.

// then you take the value of 90. The current sensor value you can now use

// using the "Serial monitor" display. Click at the top "Tools."

// and then click "serial monitor."

Knobs

Task: An LED should blink. The blink rate is to be added with a knob.

Material: Arduino / a knob (potentiometer) / Breadboard/cable read voltage of a rotary control, processing sensor values, and mathematically to use for output (in this case, for the duration of a pause): learning content.

A knob has three terminals. Outside is + and - connected. From the middle, pin cable goes to an analog input pin on the microcontroller board. By turning the knob, the middle pin outputs a voltage between 0 and 5 volts. Knobs far left: 0 V and knobs on the far right: 5V, or mirror-inverted depending on the wiring.

As LED should blink, we use as the first sketch the LED, which is secured by pin 13 on the microcontroller. In addition, it still connects further LEDs.

Sketch:

int input = A0;         // The word "input" is now available for the value "A0" (name

// the analog port 0)

int LED = 13;  // The word "LED" is now available for the value 13

int Sensor value = 0;        // variable for the sensor value with 0 as the start value void set up()

{   // Here the setup starts.

pinMode (LED,OUTPUT); // The pin with the LED (pin 13) is now an output.

}

void loop()

{   // This brace is the Loop section opened.

Sensor value = analog read(entrance);        // The voltage on the control dial will read

// and in the previous sketch as a number from 0 to 1023 under the variable

// "sensor value" stored.

digitalWrite (LED,HIGH);  // The LED is turned on

delay(Sensor value);         // The LED remains on for so many milliseconds,

// as the value of "sensor value" it has stored. digitalWrite(LED, LOW);              // The LED is turned off.

delay(Sensor value);         // The LED remains off for so many milliseconds,

// as the value of "sensor value" it has stored.

}   // This clip the loop portion is closed

// The loop part is now restarted. If the value of the read

// knob changes, then the time between the input and output changes

// phases of the LED. The flashing is faster and slower. The longest

In this skit // delay is 1023ms (milliseconds). If you long delays

// required then builds to a small mathematical line in the code.

// For example, to change the line "sensor value = analog read (input)," in

// "sensor value = analog read (input) * 2;" This is the stored sensor value

// magnified by a factor 2nd Since longest delay would be 2046ms etc.

Measure Temperatures

Task: With the temperature sensor TMP36, the temperature should read and display monitor serial-by.

Material: Arduino / Breadboard / cable / Temperature Sensor TMP36 / External Power Supply

The sensor has three connections. When looking at the flat side of the sensor: left 5V, GND, and right in the middle of the pin for the temperature signal. On this pin, the sensor outputs a voltage between 0 and 2.0 volts. Wherein 0V -50 ° C and the corresponding value of 2.0V corresponds to 150 ° C.

According to the manufacturer, the sensor is between -40 ° C and + 125 ° C with reasonable accuracy (± 2 ° C). The voltage of this pin has to read from the microcontroller board and converted into a temperature value.

NOTE:

- If the sensor is connected incorrectly, it will burn out.

- In the structure of an external power supply should be used if possible, as it improves considerably the sensor accuracy (9V AC adapter or 9V battery).

Sketch:

int TMP36 = A0;      // The sensor A0 is to be connected to the analog pin. We

// call the pin from now "TMP36"

int temperature = 0; // Under the variable "temperature" is later

// temperature value stored

int temp [10];  // This yields good values, you first read multiple values

// and then averages the results. The square bracket "[10]" generated here

// equal to ten variables named "temp [0],” "temp [2],” "temp [3]"... to...

//"temp[9]".Mit the notation [10] So you can save only a little              Place.

int time= 20;  // The value for "time" is in the code, the time intervals

// ago between the individual measurements. void set up() {

Serial.begin(9600);  // In the setup we start serial communication so

// we can show us the temperature later. About the serial

// communication the board, sending measurements to the computer. In the Arduino

// software can be under "Tools" the "Serial Monitor" start the readings

// to see.

}

void loop() {

temp [0] = map(analog read(TMP36), 0        410    -50,              150);

delay(time);

temp [1] = map(analog read(TMP36), 0        410    -50,              150);

delay(time);

temp [2] = map(analog read(TMP36), 0        410    -50,              150);

delay(time);

temp [3] = map(analog read(TMP36), 0        410    -50,              150);

delay(time);

temp [4] = map(analog read(TMP36), 0        410    -50,              150);

delay(time);

temp [5] = map(analog read(TMP36), 0        410    - 50,              150);

delay(time);

temp [6] = map(analog read(TMP36), 0        410    -50,              150);

delay(time);

temp [7] = map(analog read(TMP36), 0        410    -50,              150);

delay(time);

temp [8] = map(analog read(TMP36), 0, 410, -50, 150); delay(time);

temp [9] = map(analog read(TMP36), 0, 410, -50, 150);              // From here is ten times the

read // temperature. In between is ever a break with the duration

// "time" in milliseconds. But what happens here, exactly? Let's look at the

// command once more closely.

// temp [1] = map (analog read (TMP36), 0, 410, -50, 150);

//Sequentially:

// temp [1] - is the name of the first variable.

// "map (a, b, c, d, e)" - This is the so-called "Map command". Allows

// to a read-in value (a) in which the values between (b) and (c) lie,

// convert it into a different speed range, and that (d) in the area between

// and (e).

// following our command happens:

// the value of the sensor is read out directly in the "Map" command with

// "analog read (TMP36)". The measured values should be between 0 and 410th The

// corresponds to the analog port of the values between 0V and 2V. is the voltage

// the sensor out at temperatures between -50 ° C and + 150 ° C. These values on

// analog port will now be through the "Map command" directly to the Celsius values

// -50 to 150 converted.

temperature = (temp [0] + temp [1] + temp [2] + temp [3] + temp [4] + temp [5] + temp [6] + temp [7] + temp temp [8] + [ 9]) / 10; // All in a row. Here every ten are found

// temperature values added together and divided by ten. The

// average value is stored under the variable "temperature"

Serial.print(temperature);          // Now, the value of "temperature" over the serial

// sent communications to the PC. Now you have the serial monitor in the

// Open Arduino software to the temperature at the sensor to read. Serial.println("Degree");

}

Expansion of the Program:

Once the temperature has reached 30 ° C, to a warning sound (beep of a piezo speaker).

int TMP36 = A0;

int temperature = 0; int temp [10];

int time= 20;

int piezo = 5;        // The word "piezo" is now the number 5, that is to port 5 of the

// Piezo connected. void set up() { Serial.begin(9600);

pinMode (Piezo, OUTPUT);     // The piezo speaker to pin 5 should be a starting

// (logical because of the yes from the microcontroller board yes a voltage required to

// beeping.

}

void loop() {

temp [0] = map(analog           0        410    -50,    150);

read(TMP36),

delay(time);                                  0        410    -50,    150);

temp [1] = map(analog read(TMP36),

temp [9] = map(analog           0        410    -50,    150);

read(TMP36),

Measure Distance

Task: the ultrasonic sensor HC-SR04 and a microcontroller Arduino a distance to be measured and displayed with the "serial-monitor".

How does the ultrasonic sensor? The sensor has four terminals.

a) 5V (+) b) GND (-) c) echo d) trigger

The connections 5V and GND are self-evident; they supply the sensor with power.

The "trigger" of the contacts inserts a short signal (5 V) into the microcontroller board, causing an acoustic wave through the ultrasonic sensor. Once the sound wave hits a wall or other object, it is reflected and at some point reaches the ultrasonic transducer again.

Once the transducer detects these reflected sound waves, it sends a 5V signal to the "echo" contact on the microcontroller board. The microcontroller only measures the time between the radiation and the return of the sound wave and converts this time into distance. Here we go.

Material: microcontroller board / cable / Breadboard / Hc-SR04 ultrasonic sensor

Code:

int trigger = 7;        trigger // The word is now the number. 7 int echo = 6;              // The word echo is now the number sixth

long time = 0;          life // The word is now a variable under which the time

// is stored, to the reflection and requires a sound wave back.

// Start value here 0th

long distance = 0;    // The word "distance" is now variable, under the

is stored // the calculated distance.

// Info: Instead of "int" is faced with the two variables "long." That has

// the advantage that a larger number can be saved. Disadvantage:

// variable takes up more space in memory. void set up()

{

Serial.begin (9600); // start communication Serial, so you later

can view the serial monitor // values.

pinMode(Trigger, OUTPUT);      // "trigger" (pin 7) is an output. pinMode(echo, INPUT);              // "echo" (pin 6) is an input.

}

void loop()

{

digitalWrite(Trigger, LOW);       // Here, take the voltage for a short period

// trigger pin, so that one later sending the trigger signal a noise-free

// Signal.

delay(5);         // Duration: 5 milliseconds

digitalWrite(Trigger, HIGH);                     // Now you send off an ultrasonic wave delay(10);              // This "tone" is heard for 10 milliseconds. digitalWrite(Trigger, LOW);              // Then the "tone" is turned off.

duration = pulseIn(echo, HIGH);         // The command "pulseIn" is one of the

// microcontroller the time in milliseconds until the sound to

// ultrasonic sensor returns.

Distance = (time / 2) / 29.1;       // Now we calculate the distance in

// centimeters. First, you divide the time by two (because only one

// Section wants to calculate and not back the track and back). The value

// can still be divided by 1.29 and then receives the value in centimeters because of the

// sound in the air at a speed of one centimeter per 29.1

// microseconds.

// Example: The sensor measures time from 2000 microseconds. These are then

// 1000 microseconds each way. Now one in 1000 because of the sound divided by 1.29 (

// yes 1cm travels per 29.1 microseconds) and receives the value 34,3cm

if (Distance> = 500 || distance <= 0)  // If the measured distance over

// is 500cm or 0cm...

{

Serial.println("No reading");      // then is to spend the serial monitor "No

// reading "because readings are wrong or inaccurate in these areas.

}

else       //otherwise..

{

Serial.print(distance);       //... should the value of the distance to the serial monitor

// output here.

Serial.println("cm");

}

delay(1000);   // The delay of one second provides in about every new second for

// a new measurement.

}

Expansion of the Program:

When a distance is measured 80cm, a piezo speaker to beep.

int trigger = 12; int echo = 13; long time = 0;

long distance = 0;

int piezo = 5;  // The word piezo is now the number 5 void set up()

{

Serial.begin (9600); pinMode(Trigger, OUTPUT); pinMode(echo, INPUT);

pinMode(Piezo, OUTPUT);         // The piezo speaker to pin 5 should be a starting

// (logical because the yes from the microcontroller board yes a voltage required to

beeping //

}

void loop()

{

digitalWrite(Trigger, LOW);

delay(5); digitalWrite(Trigger, HIGH); delay(10); digitalWrite(Trigger, LOW); duration =pulseIn(echo, HIGH); Distance = (time / 2) / 29.1;

if (Distance> = 500 || distance <= 0)

{

Serial.println("No reading");

}

else

{

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

}

if (Distance <= 80)  // If the value for the distance below or equal to 80

//, then...

{

digitalWrite(Piezo,HIGH);          //... start beeping.

}

else       // And if that is not so...

{

digitalWrite(Piezo,LOW);  //... then be quiet.

}

delay(1000);

}

Enhancements: Reversing Warning

With this code, we can construct a reverse warning system, on pin 12 besides "measure distance" to the already connected ultrasonic sensor from the Sketch 10 (connects an LED.

... you can wrap an image already follows construct the reverse warning anyway?

int trigger = 7; int echo = 6; long time = 0; int LED = 12;

long distance = 0;

void set up()

{

Serial.begin (9600); pinMode(Trigger, OUTPUT); pinMode(echo, INPUT); pinMode(12, OUTPUT);

}

void loop()

{

digitalWrite(Trigger, LOW); delay(5); digitalWrite(Trigger, HIGH); delay(10); digitalWrite(Trigger, LOW); duration =pulseIn(echo, HIGH); Distance = (time / 2) / 29.1;

if (Distance> = 500 || distance <= 0)

{

Serial.println("No reading");

}

else

{

Serial.print(distance); Serial.println("Cm");

}

if (Distance <= 40)

{

digitalWrite(LED, HIGH); delay(Distance * 3); digitalWrite(LED, LOW); delay(Distance * 3);

}

}

Infrared Remote Control for Controlling Arduino Microcontrollers

Material: Arduino / Breadboard / cable / infrared sensor / infrared remote control

With an infrared receiver that an Arduino board evaluates the commands of an infrared remote control. The data is sent in the form of infrared light from the remote control to the receiver. Since our eyes can not perceive this light, we can’t see it.

With a little trick, however, you can test whether a remote control, for example, sends an infrared signal. This involves taking a digital camera (for example, by phone) and viewed via the display, the infrared diode. Now, if we press the remote control, you can see the lights infrared diode because the sensors of digital cameras perceive infrared light and can represent. The light flickers easily, since the infrared diode toggle very quickly and outgoing. Underlying this is a very specific rhythm that can test the basis of which the infrared receiver later, which key was pressed on the remote control.

This sketch is a slight modification of Sketches "IRrecvDemo," default in the Arduino main program can not find which under the examples.

This sketch is very short and therefore lends itself very well for the first experiments.

Code:

/ *

*   IrRemote: IRrecvDemo - Demonstrates receiving IR codes with IRrecv

*   An IR detector/demodulator must be connected to the input RECV_PIN.

*   Version 0.1 July 2009

*   Copyright 2009 Ken Shirriff

*   http://arcfn.com

* /// Information over the original program "IrrecvDemo".               #include <Irremote.h>              // The program encroaches on a

// "Library" back. This does a lot of work. Because of the infrared light

// will be encrypted with a code. To read this code itself

// convert and appropriate values, a lot of lines of code would be required.

int RECV_PIN = 11;          // outputs The contact of the infrared sensor data,

// is connected to pin 11 of the Arduinoboards.

IRrecv irrecv (RECV_PIN);         // At this point, an object is defined that

// reads the infrared sensor to pin. 11

decode_results results;     // This command ensures that the data              by

// infrared is read stored under "results."

void set up()

{

Serial.begin(9600);  // In the setup the serial connection is started, so

// you look at the data to receive the remote control via the serial monitor

// can.

pinMode (13, OUTPUT);

irrecv.enableIRIn(); // This command initializes the infrared receiver.

}

void loop()

{   // The loop portion turns out very shortly by resorting to the "library". if (irrecv.decode(Results)) {              // If data has been received, Serial.println (results.value, DEC); // they are as a decimal (DEC) to the

// Serial Monitor output.

irrecv.resume();       // The next value to be read from the IR receiver

}

One press on the button "1" of the infrared remote control unit causes the number "16724175" is output at the Serial Monitor. This is the decoded numerical code behind this button.

If you hold the button down permanently, the number "4294967295" is displayed permanently. This indicates the code that a key is pressed permanently. This number is regardless of which button is pressed, but it can also appear other numbers if a button is pushed only very short or pulsed. In this case, the sensor can read no unique value.

Expansion of the Program:

When pressing the "1" LED will go on and on pressing the button "2,” the LED will go out.

#include <Irremote.h> int RECV_PIN = 11;

IRrecv irrecv (RECV_PIN);

decode_results results; void set up()

{

Serial.begin(9600);

pinMode (13, OUTPUT);   // To pin 13 an LED is connected. digitalWrite(13, LOW);                            // This should first of all be irrecv.enableIRIn();

}

void loop() {

if (irrecv.decode(Results)) { Serial.println(Results.value, DEC);

if (Results.value == 16724175)  // If the infrared receiver, the number

// read "16724175" (the key According to "1" on the remote control) has

{digitalWrite (13, HIGH)}          // the LED should go on.

if (Results.value == 16718055)  // If the infrared receiver, the number

// read has "16718055" (corresponding to "2" of the remote control button)

{digitalWrite (13, LOW)}  // the LED should go out. irrecv.resume();

}

}

Servo Drive

Task: A servo is to be controlled by an Arduino microcontroller. The servo should drive to three different positions in this example and wait a short time between positions.

Material: A microcontroller board, a servo, three plug-in cable

Code:

#include <Power.h>        // The servo library is called.

Power servo-blue;    // Create the program a servo with the name

// "servo blue"

void set up()

{

servo blue.attach(8th);      // servo is connected to Pin8

}

void loop()

{

servo blue.write(0);                // Position 1 controlled with the angle 0 ° delay(3000);                            // The program stops for 3 seconds servo blue.write(90);                            // position 2 controlled with the angle 90 ° delay(3000);              // The program stops for 3 seconds servo blue.write(180);                                          // position 3 controlled with the angle 180 ° delay(3000);              // The program stops for 3 seconds servo blue.write(20);              // position 4 controlled with the angle 20 ° delay(3000);              // The program stops for 3 seconds

}

LCD Display

Task: An LCD display is to be controlled with an Arduino microcontroller. After that, a predetermined text should appear as in the following example photo on display.

Material: Microcontroller Board (In this example, UN R3), a wheel (or potentiometer), jumper cables 14, Breadboard

Based on the material and the sketch, you quickly realize that the wiring is not so easy. This is because the LCD display must be connected to a large number of cables. Another difficulty is with which one could connect the cables missing sockets.

Therefore, it is advisable to solder a terminal strip or to solder the cable directly to the LCD. In the second case, it is advisable to use a ribbon cable (for example, from old IDE drives like hard disks, CD or DVD drives). Without a soldered connection, it is almost impossible to achieve good results.

The knob is there to ad the contrast of the LCD. The LED backlight, as shown in the sketch supplied with 5V. Since it would not recognize the label on the LCD in the sketch, it is not shown. You have, therefore, the position of the cable to the LCD counting (Example: The LCD is the first cable from the right GND.

The second cable from the right is connected to 5V, etc.). Info: For quick tinkering, many hobbyists prefer to use an LCD Keypad Shield or I2C LCD because you do not have to worry about the two alternatives to the wiring of the LCD must. However, the two alternatives mentioned above are also more expensive.

If you have successfully made the wiring, you can take the software with many other components, and use is made here to a "Library." The Library for the LCD display is part of the Arduino software and must not be installed separately.

Code:

#include <Liquid Crystal.h>     // Load LCD library

Liquid Crystal LCD (12, 11, 5, 4, 3, 2);         // This line is set,

// which pins is the microcontroller boards used for the LCD (Best

// first do not change). void set up() {

lcd.begin(16, 2);      // In the Setup specifies how many characters and lines are applied. Here: 16 characters in 2 lines

}

void loop() {

lcd.setCursor(0, 0);  Set the LCD // start position of the display.

// Means: The first character in the primal line.

lcd.print("Www.xyz.com");         // There should text "Www.xyz.com"

//appear.

lcd.setCursor(0, 1);  // lcd.setCursor (0.1) means: First character in the

// second line.

lcd.print("I wish you success...");        // There will be the text "Good luck ..."

//Pop up.

}

A variation: to alternately first up and then down a text message display. In this example, the text "up" and "down".

#include <Liquid Crystal.h> Liquid Crystal LCD (12, 11, 5, 4, 3, 2); void set up() {

lcd.begin(16, 2);

}

void loop() {

lcd.setCursor(0, 0);  // start at the first character in the first line with the

// text "Up." lcd.print("Above");

delay (2000);                 Wait // Two seconds. lcd.clear();              // Clear display.

lcd.setCursor(5, 1);  // Renewed beginning at the fifth character in the second

// line with the text "Down". lcd.print("Below");

delay (2000);                 Wait // Two seconds. lcd.clear();              // Clear display.

}

An LCD is particularly well suited to sensor values or other issues of microcontroller boards display. For more help, you get, for example, in the Arduino software. Among the sample Sketches, one finds a number of different examples under the menu item "Liquid Crystal."

Relay Card

When tinkering with Arduino relay is very important. Relays are switches that can flow a larger current than would be possible by the microcontroller. With the Arduino, so you now enabled only a very small current relay, which can then also run large electrical items.

The relay card is connected to the Arduino to the contacts (in the photo on the right edge, between the red and green LED). The card is in operation permanently + 5V and GND - connected (). The pin labeled "IN" is connected to a pin of the digital Arduino boards. As long as at pin "IN" no signal (output from the digital pin of Arduino), the screw terminals A and B are connected together. As soon as a signal is present, contacts B and C are connected to each other.

Warning: relay cards that switch when applied to the pin "IN" GND, and there are relay cards that switch when applied to the pin "IN,” a voltage of 5V +. Which version you can easily tell by combining the "signal" Pin once with GND and once with 5V + Arduino boards. A loud crack can clearly see the switching of the relay card.We can connect an electric device, at which a higher electric current flows as if it could provide the Arduino to the bottom contacts (A, B, C). For example, a large electric motor, a large lamp, etc.

As an example code, in this case, the simple "blink" code can be used. In place of the LED, you to close the output pin of the Arduino boards to the "signal" Pin the relay card. The relay will then switch every second.

Code:

void set up()

{

pinMode(6, OUTPUT);

}

void loop()

{

digitalWrite(6, HIGH);      // At this point, would one turn on the relay delay(1000);              //... wait a second

digitalWrite(6, LOW);        And off again //

delay(1000);   //... and wait a second.

}

Stepper Motor

In this step, the motor is a stepper motor suitable for small applications with the Arduino board. The special feature is that we can operate it without an external power supply. The motor develops a relatively high torque. This is realized by a transmission, which has been installed within the metal casing before the actual step motor.

This makes it possible at all in this compact design, is that a complete revolution of the driveshaft to 2048 individual steps can be divided. A small resultant disadvantage is the slow maximum rotational speed.

We connect the stepper motor to a motor control board. This supplies the engine with sufficient electrical power so that the power need not apply to the digital pins on the Arduino board. The control board is available in two versions, in which the side-mounted pins are protruding either upward or downward out of the board. However, the pin assignment is the same.

Cabling

PIN2 the Arduino board to IN4 of the motor control board - 2 to 4

PIN 3 on the Arduino board to IN2, the motor control board - 3 to 2

PIN4 the Arduino board to IN3 of the motor control board - 4 to 3

PIN 5 on the Arduino board to IN1 of the motor control board - 5 to 1

PIN "GND" on the Arduino board to GND, the motor control board

PIN "5V" on the Arduino board to VCC, the motor control board

This is an example code that the motor turns by 2048 steps (corresponding to a full revolution) above and can turn back.

Code

#include <stepper.h> int SPMU = 32;

stepper myStepper (SPMU, 2,3,4,5); void set up()

{

myStepper.setSpeed(500);

}

void loop() {MyStepper.step(2048); delay(500); myStepper.step(-2048); delay(500);

}

Instructions for a Humidity Sensor

With a moisture sensor (Moisture sensor), you can, as the name suggests measuring the moisture. However, this refers to the directly adjacent moisture, such as skin moisture or soil moisture, but not from humidity. You can use it, for example, to measure the moisture in the soil of plants. In the case of dryness, then an alarm signal may be heard, or an electric water pump could automatically the plant with water supply.

The sensor is also suitable to measure the water level in the sensor's range. The operation is simple. a voltage is applied to the two contacts of the sensor. The higher the moisture between the two contacts, the better the current to flow to the other from a contact.

This value is processed electronically in the sensor and transmitted to an analog signal on the molded card. Since the card, as described in previous manuals, cannot measure voltage per se, it converts the voltage present on the analog contact to a digital value. From 0 to 12 V corresponds to a digital value of 0 to 1023 (the digits 1024, since zero, is considered first).

In the humidity sensor, however, the upper limit is about at the numerical value of 800 when the sensor is completely immersed in the water. The exact calibration is, however, dependent on the sensor and of the kind that is measured of the liquid/moisture (e.g., saltwater has better conductivity, and the value would be correspondingly higher).

The programming is very simple and very similar to the very reading of potentiometers, as an analog value is read.

int reading = 0;       // Under the variable "reading" is later, the measured value of the

// sensor stored.

void set up()

{   // Here the setup starts.

Serial.begin(9600);  // Communication with the serial port is started.

// This is required to display the value read in the serial monitor to

//to let.

}

void loop()

{   // This brace is the Loop section opened.

reading =analog read(A0);         // The voltage on the sensor is read out and

// under the variable "reading" saved.

Serial.print("Humidity Reading");       // Output on Serial Monitor: The word

// "Humidity Reading"

Serial.println(Measured value); // and following the actual measured value delay(500);              // Finally, a little break, so not too many

// rushing numbers on the Serial Monitor.

}

Expansion of the Program:

Now, an alarm signal with the aid of piezo speakers to sound as soon as the measured humidity falls below a certain limit.

As the limit of the value "200" is set in this case.

Code:

int reading = 0;

int Beep = 6;  // The name "PIEPS" the Pin6 is now referred to which a piezo speaker is connected.

void set up()

{

Serial.begin(9600);

pinMode (6,OUTPUT);      // In the setup of the pin 6 is set as output

}

void loop()

{

reading =analog read(A0); Serial.print("Humidity Reading"); Serial.println(Measured value);

delay(500);

if (Reading <200)    // Here the query begins: When the sensor value is less

// is called "200,” then...

{

digitalWrite(PIEPS, HIGH);        //... to beep the piezo speaker

}

else       //…otherwise…

{

digitalWrite(PIEPS, LOW);         //... he should be quiet.

}

}

Drop Sensor

A drop sensor or liquid sensor, as the name suggests, can detect a liquid. For this purpose, the liquid must be located directly on the sensor. It is enough, a small drop, to get a clear reading.

You can use the sensor, for example, as a rain sensor. Once a drop strikes the sensor, the Arduino board can perform an action such as roll-up an awning, blinds close, trigger an alarm, or actuate a wiper.

The operation is simple. Traverse the sensor at the long contact point is a voltage (either + or -). As soon as a liquid, for example. Connects through a tropical two contacts, a small current flows from one contact to another. This value is processed electronically in the sensor and transmitted as an analog signal to the analog input of the card in a form.

Since the card cannot measure the voltage per se as described in previous instructions, it converts the voltage applied to the analog pin into a digital value. From 0 to 12 volts corresponds to a digital value of 0 to 1023 (the number 1024 because zero is considered the first value).

In the liquid sensor, the value in the dry is zero "0". When a drop of water hits the contacts of the sensor, the Who at about "480" is located. The more drops are on the sensor, the higher the value.

The first code it's all about, read the Sensorvalue with the Arduino board and display with the "serial monitor."

The programming is very simple and very similar to the very reading of potentiometers or the reading of the humidity sensor, as an analog value is read.

int reading = 0;       // Under the variable "reading" is later, the measured value of the

// sensor stored.

void set up()

{   // Here the setup starts.

Serial.begin(9600);  // Communication with the serial port is started.

// This is required to display the value read in the serial monitor to

//to let.

}

void loop()

{   // This brace is the Loop section opened.

reading =analog read(A0);         // The voltage on the sensor is read out and

// under the variable "reading" saved.

Serial.print("Humidity Reading");       // Output on Serial Monitor: The word

// "Humidity Reading"

Serial.println(Measured value); // and following the actual measured value delay(500);              // Finally, a little break, so not too many

// rushing numbers on the Serial Monitor.

}

Expansion of the Program:

Now an alarm signal using piezo speakers to alert you when a raindrop hits the sensor. As the limit, in this case, the measured value is determined 400, as expected with a drop on the sensor, a measured value of about 480 for sale.

Code:

int reading = 0;

int Beep = 6;  // The name "PIEPS" the Pin6 is now referred to which a piezo speaker is connected.

void set up()

{

Serial.begin(9600);

pinMode (6,OUTPUT);      // In the setup of the pin 6 is set as output

}

void loop()

{

reading =analog read(A0); Serial.print("Humidity Reading"); Serial.println(Measured value);

delay(500);

if (Reading > 400)   // Here the query begins: When the sensor value is less

// is called "400,” then...

{

digitalWrite(PIEPS, HIGH);        //... to beep the piezo speaker

}

else       //…otherwise…

{

digitalWrite(PIEPS, LOW);         //... he should be quiet.

}

}

RFID Kit

The RFID ( "radio frequency identification") reader is used (also called "RFID tags") of RFID transmitters read a particular code by radio. Each transmitter has a unique case, only own individual code. Thus can be realized with the Arduino locking systems or similar projects where a person to identify with a transmitter.

RFID tags can have different forms, such as key fobs or cards in credit card format.

How does it work? An RFID receiver contains a small copper coil that generates a magnetic field. An RFID transmitter also includes a copper coil that picks up the magnetic field and generates an electric voltage in the transmitter. This voltage is then used to bring a small electronic chip to emit an electrical code by radio. This code is then received directly from the transmitter and processed so that the Arduino microcontroller may further process the received code.

You can also describe RFID tags with a code. This is not taken into account because of the complexity of this manual. Other guides are available online.

Read an RFID tag with Arduino and Process the Data

Material: UN or MEGA Arduino, RFID reader, at least one RFID tag, display plate, display plate cable, LED, 200-ohm resistor.

Task: Using an Arduino microcontroller, an RFID tag to be read. Unless it is the correct TAG, it is to light an LED for 5 seconds.

Wiring the Arduino board with the RFD-receiver:

Board:

Arduino Uno

Arduino Mega

MFRC522 READER

Pin code:

10

53

SDA

Pin code:

13

52

SCK

Pin code:

11

51

MOSI

Pin code:

12

50

MISO

Pin code:

unassigned

unassigned

IRQ

Pin code:

GND

GND

GND

Pin code:

9

5

RST

Pin code:

3.3V

3.3V

3.3V

In this example, the 90° curved contact pins are soldered to the RFID receiver so that the receiver can be placed vertically in a breadboard.

Preparation - the first sketch with the RFID READER

First, we will read the UID ( "Unique Identification Number"), i.e., the individual name of an RFID tag. We use the following program (Attention, the program only works if we added the library to the Arduino software). The program is provided an R3 microcontroller for the UN. In MEGA2560 and other controllers, the pins have to be added accordingly.

#include <SPI.h> // SPI Bibliotheque Add #include <MFRC522.h> // add RFID Bibliotheque #define SS_PIN 10 // SDA to pin 10 (MEGA otherwise) #define RST_PIN 9 // RST to pin 9 (MEGA otherwise)

MFRC522 mfrc522 (SS_PIN, RST_PIN); // RFID receiver name

void set up() // start the setup:

{

Serial,begin(9600); // start serial connection (Monitor)

SPI,begin(); // build SPI connection mfrc522.PCD_Init (); // initialization of the RFID receiver

}

void loop() // Here, the loop part begins

{

if (. Mfrc522.PICC_IsNewCardPresent ()) // If a card within reach

// is...

{

return; // go on...

}

if (. Mfrc522.PICC_ReadCardSerial ()) // When an RFID transmitter was selected

{

return; // go on...

}

Serial,print("The ID of the RFID TAGS is:"); // "The ID of the RFID TAGS

// reads: "is written to the Serial Monitor for (byte i = 0; i <mfrc522.uid.size; i ++)

{

Serial,print(Mfrc522.uid.uidByte [i], HEX); // Then the UID is read,

// each of four blocks is and sequentially to the serial

// Monitor sent. The ending Hex means that the four blocks of the UID

// is (including letters) output as a HEX number

Serial,print(""); // The "Serial.print (" ") command;" ensures that

// stands between the individual blocks read a space.

}

Serial,println(); // This line is on the Serial Monitor only

// line break made.

}

If all is well, the result of the Serial Monitor looks (Apart from the own UID) like this:

HEX number with this written succession does not work well. So we change the line "Serial.print (mfrc522.uid.uidByte [i], HEX)," To

Then one gets as the result of the individual blocks of the UID code is output as a decimal number; "Serial.print (mfrc522.uid.uidByte [i], DEC".

RFID Sketch 2

Now the UID code is being issued as a decimal number, but it is still divided into four blocks. We change the code now with a little math to the effect that we obtain a single contiguous normal number for the UID (decimal).

Why do we do that? If we want to use the sketch later to trigger a correctly read RFID tags (e.g., an LED should light, or a servomotor is to be rotated 90 degrees...), we can better use an IF command with an associated number. For example:

"If the RFID code = is 1031720, then an LED for 5 seconds to light up."

Harder would contrast with the command "If the first block is 195 and the second block 765 reads and the third block 770 blocks 233 and the fourth is... Then turn the LEDs for 5 seconds.

However, a disadvantage is that the sketch is thus somewhat uncertain because all the numbers of the four blocks (max. 12 digits) can not be represented in a continuous number. If there is to be more secure, you would have every single block a query.

#include <SPI.h> #include <MFRC522.h> #define SS_PIN 10

#define RST_PIN 9

MFRC522 mfrc522 (SS_PIN, RST_PIN);

void set up()

{

Serial.begin(9600); SPI.begin(); mfrc522.PCD_Init ();

}

void loop()

{

if (. Mfrc522.PICC_IsNewCardPresent ())

{

return;

}

if (. Mfrc522.PICC_ReadCardSerial ())

{

return;

}

long code = 0; // As a new variable we add "code" under which the UID later is output as a continuous number. Instead of int, we now use the number range "long" because they can store a larger number.

for (byte i = 0; i <mfrc522.uid.size; i ++)

{

code = ((code + mfrc522.uid.uidByte [i]) * 10); // Now, as also previously read out the four blocks, and in each pass of the code is "stretched" by a factor of 10 degrees. (, here you would use the value in 1000, but the number would become too large.

}

Serial.print("The card number is ::"); // Finally, the number code (you can not call him as a UID more) output.

Serial.println(code);

}

Great, now we can read a unique identification number of an RFID tag (it displays The number on the Serial Monitor). In this case, the identification number of that individual RFID tags 1031720 is.

And how does it continue? Now we want to turn on an LED for 5 seconds if it holds the desired RFID tag in front of the RFID READER.

Sketch 3

#include <SPI.h> #include <MFRC522.h> #define SS_PIN 10

#define RST_PIN 9

MFRC522 mfrc522 (SS_PIN, RST_PIN);

void set up()

{

Serial.begin(9600); SPI.begin(); mfrc522.PCD_Init ();

pinMode (2, OUTPUT); // The pin 2 is now an output (Connects a LED)

}

void loop()

{

if (. Mfrc522.PICC_IsNewCardPresent ())

{

return;

}

if (. Mfrc522.PICC_ReadCardSerial ())

{

return;

}

long code = 0;

for (byte i = 0; i <mfrc522.uid.size; i ++)

{

code = ((code + mfrc522.uid.uidByte [i]) * 10);

}

Serial.print("The card number is"); Serial.println(code);

// From here takes place the expansion of the program.

if (Code == 1031720) // If the number code is 1031720...

{ // Open Programmabschniss

digitalWrite (2, HIGH); should //...dann the LED on pin 2 light... delay (5000); // for 5 seconds

digitalWrite (2, LOW); //... and then go out again

} // close the program section

} Completing // Sketch

Chapter 4

Accessories for Arduino

Keypad Shield

A Keypadshield has that one, the LCD display need not wire up in a complicated way, and that six additional buttons has that you can use to advantage. The special lies with the keys are that we can read them using an analog pin in the program code. Because it connects the keys via different resistances, all with an analog pin (A0). Pin A0 can, therefore, be restricted only used for other things. The reason is on the Shield no slot for the A0 pin.

The Keypadshield is placed such a way so that the pins for the power right into the pins of the power supply on the Arduino board fits (see in the image below in the middle of the pins for the power supply. A clue can be the pin that says "VIN" ). The upper slots of the Arduino boards also are covered by the shield (Pin 0-13). Some may anyway not be used because the LCD display uses. The unneeded pins were summarized in a series of slots (see photo above).

If you want to use these slots, you should solder the cable sockets there. As an example, we can use the following code:

Code:

// Sample using Liquid Crystal library #include <Liquid Crystal.h>

/ ************************************************* ****** This program will test the LCD panel and the buttons Mark Bramwell, July 2010

************************************************** ****** /

// select the pins used on the LCD panel Liquid Crystal lcd (8, 9, 4, 5, 6, 7);

// define some values used by the panel and buttons int lcd_key = 0;

int adc_key_in = 0; #define btnRIGHT 0

#define btnUP 1

#define btnDOWN 2

#define btnLEFT 3

#define btnSELECT 4

#define btnNONE 5

// read the buttons int read_LCD_buttons ()

{

adc_key_in = analog read(0); // read the value from the sensor

// my buttons When read are centered at Valie thesis: 0, 144, 329, 504, 741

// we add approx 50 tons Those values and check to see if we are close

if (Adc_key_in> 1000) return btnNONE; // We make this the 1st option for speed reasons since it will be the most likely result

if (Adc_key_in <50) return btnRIGHT; if (Adc_key_in <195) return btnUP; if (Adc_key_in <380) return btnDOWN; if (Adc_key_in <555) return btnLEFT;

if (Adc_key_in <790) return btnSELECT;

return btnNONE; // When all others fail, return this...

}

void set up()

{

lcd.begin(16, 2); // start the library lcd.setCursor(0,0);

lcd.print("Message"); // print a simple messagepinMode (2, OUTPUT);

}

void loop()

{

digitalWrite (2, HIGH);

lcd.setCursor(9,1); // move cursor to second line "1" and nine spaces over LCD.print(millis() / 1000); // display seconds elapsed since power-up

lcd.setCursor(0.1); // move to the begining of the second line lcd_key = read_LCD_buttons (); // read the buttons

switch (Lcd_key) // DEPENDING ON whichButton was pushed, we perform in action

{

case btnRIGHT:

{

lcd.print("RIGHT"); digitalWrite (2, LOW); break;

}

case btnLEFT:

{

lcd.print("LEFT"); break;

}

case btnUP:

{

lcd.print("UP"); break;

}

case btnDOWN:

{

lcd.print("DOWN"); break;

}

case btnSELECT:

{

lcd.print("SELECT"); break;

}

case btnNONE:

{

lcd.print("NONE"); break;

}

}

}

Instructions for LCD Display with I2C Port

The LCD module with a soldered I2C bus allows the use of an LCD module with simple wiring. This is particularly advantageous in more complex projects. Another difference from the normal LCD display is that a knob is located on the back of the display, with the brightness of the LCD can be added.

Note:

These instructions will only work with an I²C module on the back of the display without three solder points labeled A0, A1, and A2.

Material: microcontroller (in this example, UN R3), LCD with I2C module, cable

Wiring: The wiring is very simple. On the I2C LCD module, only four contacts are available. GND is connected to the GND contact on the microcontroller. VCC 5V with the contact on the microcontroller, SDA to the analog input A4 and SCL with the analog input A5.

Attention: In the MEGA2560 R3, microcontrollers are available for the SDA - and SCL contacts separate entrances on the board under 20 and 21.

Program

To work with the I2C LCD module needs a library that is not pre- installed in the Arduino program. This can be downloaded, for example, https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library as a.ZIP file. After that, the library must be added to the program in Arduino.

This can be done under the "Sketch" then "Include Library" and "add.ZIP Library..". Now it can be accessed in the code to the library.

Sketch:

#include <Wire.h> // Wire Library Upload

#include <LiquidCrystal_I2C.h>// Previously added LiquidCrystal_I2C

// Library Upload

LiquidCrystal_I2C lcd (0x27, 16, 2);    // This determines what kind

// a display it is. In this case, a 16-character 2

// lines.

void set up()

{

lcd.begin(); // In the setup, the LCD is started (unlike the simple LCD module without 16.2 in brackets for the previously specified

}

void loop()

{

lcd.setCursor (0,0); // From here the I2C LCD module as the simple LCD module can be programmed exactly.

lcd.print("XYZ GmbH");

lcd.setCursor (0.1); // lcd.setCursor to characters and line indicate

lcd.print("I wish you success.");//lcd.print something on the screen to show

//to let.

}

Example of use:

With the I2C LCD module can as with the simple LCD module, it displays also  measured values.

Here is an example code in which a moisture sensor to pin A0 is connected:

#include <Wire.h>

#include <LiquidCrystal_I2C.h> LiquidCrystal_I2C lcd (0x27, 16, 2); int reading = 0;

void set up()

{

lcd.begin();

}

void loop()

{

reading =analog read(A0); // The value from analog input A0 to

// read, and the variable "reading" are stored.

lcd.setCursor(0,0); // The first line of the text is "reading"

//are displayed.

lcd.print("Reading");

lcd.setCursor(0.1);   // In the second line to the measured value from

// moisture sensor has been determined to be displayed. lcd.print(Measured value);

delay(500);

}

Two I²C Displays

Use two I²C displays at the same time, Arduino.

Caution:

This structure and the associated change in the I²C address is only possible with displays that have a jumper function. We can see this in the following image to the red area. On the points A0, A1, and A2, we can solder a contact bridge.

In addition, the NewliquidCrystal_1.3.4 Library is required for these instructions which can be downloaded here: https://bitbucket.org/fmalpartida/new- liquid crystal/downloads

The library needs to be added to the Arduino software (see previous instructions I²C display).

Material: Arduino / 2 displays with I²C module / Breadboard / cable

Task: Two LCDs with I²C module to be driven simultaneously by an Arduino microcontroller and display two different texts. For this, the I²C addresses are the displays that are found earlier, and we can change the address of display.

First, a Brief Explanation of the I²C Address

Each I²C module has a so-called "HEX address." Using this address, the I²C module reacts to the data being sent from the Arduino on the data bus at exactly that address. Many I²C LCDs also have the same HEX address. That means it would react with the use of two displays, both displays to the transmitted data from the Arduino board. One might, therefore, represent two displays with no different data.

The HEX address can at the screen using the A0, A1, and A2 solder joints. However, it changed. As established, all three solder joints are not connected depending on the combination, which one of the bridged areas with a solder joint, so eight different addresses are possible. Depending on display type, this address may initially be 0x27 or 0x3F (we can find it with the address "scanner,” more on that later).

Tables HEX addresses depending on the soldered points (I = connected: = not connected):

A0

A1

A2

HEX address

HEX address

:

:

:

0x27

0x3F

I

:

:

0x26

0x3E

:

I

:

0x25

0x3D

I

I

:

0x24

0x3C

:

:

I

0x23

0x3B

I

:

I

0x22

0x3A

:

I

I

0x21

0x39

I

I

I

0x20

0x38

We come to the I²C addresses "Scanner":

The "Scanner" is basically where the LCD module is connected; only one code is uploaded to the Arduino and then displays the HEX address to the serial monitor.

Step Guide to I²C addresses "Scanner":

1. The same LCD module with the Arduino connected:

- I²C LCD module >> Arduino 5V VCC >>

- GND GND SDA >> >> >> A4 SCL A5

2. Load following sketch to the microcontroller:

// I2C scanner

// Written by Nick Gammon

// Date: 20th April 2011 #include <Wire.h>

void setup () {

Serial.begin (115200); // Leonardo: wait for serial port to connect while (.

// Serial)

{

}

Serial.println ();

Serial.println ( "I2C scanner scanning...."); byte count = 0;

Wire.begin ();

for (i byte = 8; i <120; i ++)

{

Wire.beginTransmission (i);

if (Wire.endTransmission () == 0)

{

Serial.print ( "Found address"); Serial.print (i, DEC); Serial.print ( "(0x"); Serial.print (i, HEX); Serial.println ( ")");

count ++;

delay (1); // maybe unneeded?

} // end of good response

} // end of for loop Serial.println ( "Done."); Serial.print ( "Found"); Serial.print (count, DEC); Serial.println ( "device (s).");

}

void loop () {}

3. Open Serial Monitor in the Arduino software

4. Change baud rate to 115200

5. Possibly. Press the Reset button on the Arduino

In the serial monitor, the following should be shown (HEX address is highlighted in red):

Again, the actual instructions:

To be able to display on two I²C displays simultaneously two different texts, the displays must have different HEX addresses. So we solder in our example, at one of the displays the A1 contact, so that it now has the address 0x3D (can be checked with the addresses scanner again). We call this display from now on display 2 and the other display. 1

Code:

#include <Wire.h> integrate //Wire.h Library

#include <LiquidCrystal_I2C.h> integrate //LiquidCrystal_I2C.h Bibliothel LiquidCrystal_I2C LCD1 (0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Here is

// display one named as LCD1, given the address "0x3F" and the

// Pinassignment through the I²C module specified

LiquidCrystal_I2C LCD2 (0x3D, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);// Here is

// Display 2 named as LCD2, the address specified "0x3D" and the

// Pinassignment through the I²C module specified void set up()

{

LCD1.begin(16.2); // Display 1 is started and the size of the display

// is specified (16 characters, two lines) LCD1.backlight(); Switch // Lighting Display 1

LCD2.begin(16.2); // Display 2 is started and the size of the display

// is specified (16 characters, two lines) LCD2.backlight(); Switch // Lighting Display 2

}

void loop()

{

LCD1.setCursor(0,0); // text is the first character in the front row

// start at Display 1.. LCD2.setCursor(0,0); // display at 2 also..

LCD1.print("Display 1"); // Display 1 to the top "Display 1" Show

LCD2.print("Display 2"); // Display 2 should show up "display 2" delay(1000); // wait a second

LCD1.setCursor(0.1); // text is the first character in the second row

// start at Display 1.. LCD2.setCursor(0.1); // display at 2 also..

LCD1.print("XYZ GmbH"); // Display 1 to bottom "XYZ GmbH"

LCD2.print("Www.xyz.com");// Display 2 "Www.xyz.com"

}

Arduino RTC

Time Module for Arduino: Real-Time Clock - RTC compatible with Arduino Real Time Clock DS1307 I2C can display time and date in near real time.

Material: Microcontroller Board (In this example, UN R3). Navigation wheel (or potentiometer), dashboard, LCD display, DS1307 I2C Real-Time Clock, connection cable.

Cabling:

We wire the LCD display in principle as in the instruction no. 13. These then must be added to the RTC, which is again connected to 5V and GND, the SDA contact to the analog input A4, and the SCL contact to the analog input A5.

Caution.: In the MEGA2560 R3, microcontrollers are available for the SDA - separate entrances on the board at 20 and 21 and SCL contacts.

If everything is wired, you can also be able to start correctly with programming, almost. Before must need for programming, download libraries and added to the Arduino software.

If you have downloaded both libraries, you have to add them to the Arduino software to the existing libraries. For this, open the Arduino software and selects the Punk "sketch" the "Include Library" box. Then you can select "Add.ZIP Library" and add the previously downloaded Time and DS1307RTC Library.

We can now draw this in code.

Next, you have to the so-called "Set Time" Sketch Upload the time and date from the device (computer, laptop, etc.), on which the microcontroller is connected to add to the real-time clock.

This is done by then "DS1307RTC" select "File" to "examples" to select "Set Time." This opens the appropriate Sketch which we now upload on the UN R3.

If you have done all, you can get to the actual code.

Code:

#include <Time.h> Libraries invite #include <Wire.h>

#include <DS1307RTC.h> #include <Liquid Crystal.h>

Liquid Crystal LCD (12, 11, 5, 4, 3, 2); which pins is the microcontroller boards used for the LCD // This line is set,

void set up()

{

lcd.begin(16, 2); // In the Setup specifies how many characters and lines are applied.

Serial,begin(9600); // Opens the serial port and sets the baud rate (9600) determined for the serial transmission. setSyncProvider (RTC.get); // This is to get the function to the time and date of the RTC

}

void loop()

{

Serial,print(Hour ()); //Serial.print is the command show something in the serial monitor (hour, minute, second, space, day, spaces, etc.)

print digits (minute ()); // in minutes and seconds, the command is

print digits (second ()); // print digits specified which will be determined at the end of the code.

Serial,print(""); Serial,print(Day ()); Serial,print(""); Serial,print(Month ()); Serial,print( " "); Serial,print(Year ()); Serial,println();

delay(1000); //wait a second

lcd.setCursor(2, 0); // setCursor indicates where the text should begin. In this case, the third character in the front row.lcd.print(Hour ()); // Here is the time to be displayed now, so "hour" "" "minute,” etc..

lcd.print ( ":"); lcd.print (minute()); lcd.print(":"); lcd.print(Second ()); lcd.print("");

lcd.print("Clock"); // Here the word "clock" is after the time are displayed to have to follow NOCH 3 spaces, otherwise in numbers <10 would always another "r" are displayed behind PM. This is because the LCD Library command a view 0 before numbers <10 does not exist.

lcd.print("");

lcd.print("");

lcd.print("");

lcd.setCursor(1, 1); // The next "text" will now start at the second character in the second row.

lcd.print(Day ()); // The date is now as

lcd.print("."); // "day,” ".,” "Month,” etc. are given. lcd.print(Month ());

lcd.print(".");

lcd.print(Year ());

}

void print digits (int digits) // This section fixed that automatically becomes 0 before the digits for numbers <10 in the serial monitor. This only applies to the serial monitor instead of the LCD display.

{

Serial,print(":"); if(Digits <10) Serial,print('0'); Serial,print(Digits);

}

Note: The DS1307 Real Time Clock is not accurate to the second. The reason is that between uploading the Set Time Sketch and uploading the final sketch, a certain period of about 15 seconds can not compensate for the RTC.

In addition, you can still display the week before the date.

For this purpose just before the date in lcd.print section of printDay () command; are added and are inserted after the loop following code:

void printDay () is // This sets a meaning for those already used in the code before command printDay

{

int day;

day = weekday (); // The weekdays are to be displayed depending on the date.

if(Day == 1) {lcd.print("So,")} // If this is Day 1 to display "Sun" and so on.

if(Day == 2) {lcd.print("Mo,")}

if(Day == 3) {lcd.print("Di")}

if(Day == 4) {lcd.print("Mi")}

if(Day == 5) {lcd.print("Do,")}

if(Day == 6) {lcd.print("Fri")}

if(Day == 7) {lcd.print("Sa")}

}

Extension:

Two I²C Activate components simultaneously: the time and date with a Real Time Clock with I²C bus, LCD display on a I²C.

To accommodate the two I²C components actuate the same time, one of the components must be another I²C address than the other. In our case, we can only change the address of the LCDs. Provided that the three soldering points A0, A1, and A2 on the rear of the module has I²C.

The I²C address of the Real-Time Clock is set and can not be changed.

To change the address of LCDs, the solder joints need to be connected differently (separated all three solder joints) at the beginning. Thus, the HEX address changes of LCDs (s.

Table) (I = connected,: = not connected):

"simultaneously control two displays with I²C module" are checked with the "Scanner" from the manual.

If the address of LCDs has been changed, we can now proceed to the wiring:

For programming as already mentioned above, the time and the DS1307RTC Library needed. In addition, the NewliquidCrystal_1.3.4 Library is required for the I²C LCD.

All libraries have the Arduino software is added:

Select Sketch> Include Library> Add ZIP library> previously downloaded file Next, you have to the so-called "Set Time" Sketch Upload the time and date from the device (computer, laptop, etc.) On which it connects the microcontroller, on the set of real-time clock.

This is done by "File" to "examples" then "DS1307RTC" the point

"Set Time" selects. This opens the appropriate Sketch which we now upload on the UN R3.

If you have done all you can get to the actual code.

#include <Time.h>

#include <Wire.h> #include <DS1307RTC.h>

#include <LiquidCrystal_I2C.h> // Load Libraries

LiquidCrystal_I2C lcd (0x3D, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // The I²C Display rename and the HEX address // Insert (for us 0x3D)

void set up() {

lcd.begin(16, 2); // Start the display, specify that it is a display with 16 characters in 2 lines are //

lcd.backlight(); Switch // lighting of the display Serial,begin(9600); // start serial connection with baud rate 9600 setSyncProvider(RTC.get); // Retrieve data from the RTC

}

void loop() {

Serial.print(hour()); //Serial.print is the little display in the serial monitor (hour, minute, second //, space, day, spaces, etc.) Command print digits (minute()); // in minutes and seconds, the command is print digits (second()); // print digits used, which is still set at the end of the code

Serial.print(""); Serial.print(day()); Serial.print (""); Serial.print(month()); Serial.print(""); Serial.print (year ()); Serial,println();

delay(1000); // wait one second

lcd.setCursor(2, 0); // setCursor indicates where the text should begin. In this case, the third character in // the front row.

lcd.print(hour()); // The time is to be displayed in the format: lcd.print(":"); //Hours minutes seconds

lcd.print (minute()); lcd.print(":"); lcd.print(second()); lcd.print("");

lcd.print("Clock"); // Behind, the word "clock" display lcd.print("");

lcd.print("");

lcd.print("");

lcd.setCursor(1, 1); // The second line will display the date // be lcd.print(day());

lcd.print(".");

lcd.print(month());

lcd.print(".");

lcd.print(year());

}

void print digits (int digits) { // The print command digits for the serial monitor Serial,print(":");

if(Digits <10) Serial,print('0'); Serial.print(Digits);

}

Keypad

A keypad on the Arduino.

Task: With the Arduino, a keypad (keyboard) to read out, and the pressed key are displayed on the Serial Monitor.

These instructions a 3 x 4 keypad used. Alternatively, a4 x 4 keypad is used here pins, and defined keys (COLS / HEXAKeys) need to be added (see below).

Material: Arduino / cable (7x) / keyboard / power supply

To use the keypad, you need the keypad Library. The Library of the Arduino IDE to add:

- Open the Arduino IDE

- Menu item: - embed> Library - Sketch> Library Management

Search -with the search line to "Keypad,” find and install (the version of Mark Stanly)

The keypad comprises a 3 x 4 array of 12 keys.

To understand the functioning of the keypad you have to imagine how a coordinate system. Each key is associated with two pins; a pin for the columns (COLS) and one for the rows (ROWS). If a key is pressed, the corresponding pins are connected. These pins can read the Arduino with the digital read () function. (The keyboard requires no external power supply.)

The Sketch:

#include <keypad.h>

// Here, we define the size of the keypad const byte COLS = 3; // 3 columns

const byte ROWS = 4; // 4 lines

// The digits / characters:

char HEXAKeys [ROWS] [COLS] = {

{.# '..0 '..* '},

{.9 '..8th'..7 '},

{.6 '..5 '..4 '},

{.3 '..2 '..1'}

};

byte colPins [COLS] = {8, 7, 6}; // definition of the pins for the 3 columns byte rowPins [ROWS] = {5, 4, 3, 2};// definition of the pins for the 4 lines char pressedKey; // pressedKey corresponds in the future, the keys pressed keypad myKeypad = keypad(makeKeymap(HEXAKeys) rowPins, colPins, ROWS,

COLS); // The keypad can be addressed from now on // with myKeypad void set up() {

Serial.begin(9600);

}

void loop() {

pressedKey = myKeypad.getKey(); // pressedKey corresponds to the pressed key if (PressedKey) { // If a key is pressed

Serial,print("The key "); Serial,print(PressedKey); Serial,print(" was pressed");

Serial,println(); // Tell us the Serial Monitor the pressed key with

}}

Using a 4 x 4 keypad (the sections are changed):

>  const byte COLS = 4; // 4 columns

>  byte colPins [COLS] = {9, 8, 7, 6}; // definition of the pins for the 4 columns

>  char HEXAKeys [ROWS] [COLS] = {

{, D '. , #.. , 0.. *.},

{, C '..9 '..8th'. , 7 '},

{, B '. , 6.. , 5...4 '},

{, A '..3 '. 2...1'}

};

Keypad - Castle

With the number keypad code lock programming Task: With the entry of a code 3 digit on the keypad to an LED light up and a servo occupy a certain position. The servo example could be a bolt are attached that unlocks a door.

Material: Arduino / Breadboard / keypad (in this example, 4 × 4) / cable / a red LED / green LED / two 100 Ohm resistors / Servo

We want to leave a green LED light up, typing a 3-digit password on the keypad and can occupy a certain position a servo. If the "lock" is closed to light up and the servo taking another position, a red LED. This tutorial serves as inspiration and an example of how a "safe" can be built from these simple components, for example.

We now come to the construction. This is quite simple and goes from the following Fritzing sketch out.

For Better Orientation in Wiring the Keypad:

At the extreme contacts of the keypad to enter the numbers, you can see one and seventh it connects The contact 1 at the keypad to pin 2 on the Arduino. Ascending, it then proceeds to contact 7 which is connected to the pin 8 at the Arduino, the keypad.

For the code, we need the keypad library, what the Arduino software has to be added.

Open Arduino Software> "Sketch"> Select "Include Library"> choose "Manage Libraries.." select> In the search bar of the new window "Keypad"> enter the top library Select by Mark Stanley and install.

From now on, we can use the keypad Library in the code.

Code:

#include <keypad.h> // keypad and servo Library is integrated #include <Power.h>

Power servo-blue; // servo is now addressed with "servo blue"

char* Password = "123"; // The password is set. In this example

// "123"

int position = 0;

const byte ROWS = 4; // This indicates how many rows and columns the const byte COLS = 3; // keypad has

char keys [ROWS] [COLS] = { be // The numbers and characters on the keypad

{# ". '0'. * '}, // specified

{9 '. ,8th'. , 7 '},

{6 '. , 5 '. , 4 '},

{, 3 '. , 2 '. ,1'}

};

byte rowPins [ROWS] = {5, 6, 7, 8}; // The connection with the Arduino is

byte colPins [COLS] = {2, 3, 4}; // set

keypad = keypad( makeKeymap(Keys), rowPins, colPins, ROWS, COLS); int RedLED = 12; // The red LED is connected to pin 12

int GreenLED = 13; // The green LED is connected to pin 13 void set up()

{

pinMode(RedLED, OUTPUT); // The LEDs are set as output pinMode(GreenLED, OUTPUT);

servo blue.attach(11); // The servo is connected to pin 11

setLocked (true);

}

void loop()

{

char key = keypad.getKey();

if (Key == * ' || key ==# ") // when the lock is unlocked it can with the

// key or "#" are blocked again "*"

{

position = 0;

setLocked (true); Lock // castle once was * or press #

}

if (Key == password [position])

{

position ++;

}

if (position == 3) // This line length indicates the password. In our

// Case 3 points.

{

setLocked (false);

}

delay(100);

}

void setLocked (int locked)

{

if (Locked) // If the lock is locked to..

{

digitalWrite(RedLED, HIGH); //..die red LED lights.. digitalWrite(GreenLED, LOW); //..die green LED does not light.. servo blue.write(90); // and the servo is to control 0 degrees.

}

else // when the lock is unlocked to..

{

digitalWrite(RedLED, LOW); //..die red LED does not light.. digitalWrite(GreenLED, HIGH); //..die green LED lights.. servo blue.write(0); //..und the servo drive 90 degrees.

}

}

This guide serves as an example and foundation of how a simple "castle" using fewer components and can construct the Arduino.

Color Sensor

Task: Using a color sensor, the colors are red, green, and blue are detected, and a corresponding LED light up.

Material: Arduino / cable / color sensor / Red LED / Green LED / Blue LED / resistors for LEDs are to obtain more accurate values 4 white LEDs on the color sensor. In the center of the LEDs is a small square of photodiodes, which may filter the intensity of a color. There are photodiodes for the green, red and blue color, and photodiodes without color filters present. This "filter" out what color is held  before the color sensor and convert them to values around that can handle the microcontroller.

We can use the color sensor, for example, in the construction of a sorting machine.

For our test setup, we made the following structure with appropriate wiring

Cabling:

Color sensor >>>    Arduino VCC 5V >>>

GND GND >>>

S0 >>>          8th

S1 >>>          9

S2 >>>          12

S3 >>>          11

OUT >>>       10

OE >>> GND

LEDs >>>      Arduino Red LED >>>  2

green LED >>>       3 Blueness LED >>>    4

This is a sample code with the three colors of red, green and blue are read by Arduino. At the same time indicate three correspondingly colored LEDs which color has been recognized by the sensor.

const int s0 = 8; // Set the connection of the color sensor contacts with the Arduino const int s1 = 9;

const int s2 = 12; const int s3 = 11; const int out = 10;

int RedLED = 2; // Set the connection of the LEDs with Arduino int GreenLED = 3;

int BlueLED = 4;

int red = 0; call // variables for LEDs int green = 0;

int blue = 0; void set up()

{

Serial.begin(9600); // Start Serial Communications

pinMode(S0, OUTPUT); // The contacts of the color sensor are used as output or pinMode(S1, OUTPUT); // Input festgelgt

pinMode(S2, OUTPUT); pinMode(S3, OUTPUT); pinMode(out, INPUT);

pinMode(RedLED, OUTPUT); // The LEDs are defined as output pinMode(GreenLED, OUTPUT);

pinMode(BlueLED, OUTPUT);

digitalWrite(S0, HIGH); // The four white LEDs at the color sensor will light up digitalWrite(S1, HIGH);

}

void loop()

color ();// This function is determined at the end of the code (s. "Void color ();") Serial.print("Value Red"); // On the serial monitor is to "value" each Serial.print(red, DEC); // with the appropriate color display Serial.print("Value Green");// be behind it and the value obtained in the Serial.print(green, DEC); // void color (); Function was read out.

Serial.print("Value Blue"); Serial.print(blue, DEC);

// Here are the commands for the LEDs

if (Red <blue && red <green && red <20) // If the filter value for red

// is smaller than all other values..

{

Serial.println(" - (Red color)"); are displayed on the serial monitor // //..should "red color" and..

digitalWrite(RedLED, HIGH); //... ie red LED lights up, the others digitalWrite(GreenLED, LOW); // stay out

digitalWrite(BlueLED, LOW);

}

else if (blue <red && blue <green) // The same in blue and green

{

Serial.println (" - (Blue colour)"); digitalWrite(RedLED, LOW); digitalWrite(GreenLED, LOW); digitalWrite(BlueLED, HIGH);

}

else if (Green <red && green <blue)

{

Serial.println(" - (Green colour)"); digitalWrite(RedLED, LOW); digitalWrite(GreenLED, HIGH); digitalWrite(BlueLED, LOW);

}

else{ // If there are no values..

Serial.println(); Show //..nichts on the serial monitor and..

}

delay(300);

digitalWrite(RedLED, LOW); //... turn off all LEDs digitalWrite(GreenLED, LOW); digitalWrite(BlueLED, LOW);

}

void color () // This is where the values are read by the color sensor and under the

// corresponding variables stored

{

digitalWrite(S2, LOW); digitalWrite(S3, LOW);

red = pulseIn(out, digital read(Out) == HIGH ? LOW : HIGH); digitalWrite(S3, HIGH);

blue = pulseIn(out, digital read(Out) == HIGH ? LOW : HIGH); digitalWrite(S2, HIGH);

green = pulseIn(out, digital read(Out) == HIGH ? LOW : HIGH);

}

To check our building, we have printed us a table with a red, green and blue surface.

Depending on what color you hold the color sensor, the corresponding LED should now light up.

Generate Tones

Produce with the Arduino and a speaker sounds.

With the Arduino can produce sounds in different ways. The simplest way is the tone generation with an active loudspeaker (active buzzer), which is connected to only the voltage of 5V. The sounds produced by a built inside electronics. The disadvantage is that a

"Active buzzer" can only produce a single tone - tunes or siren sounds are not possible.

With a passive Loudspeaker (passive buzzer), you have the option using the Arduino microcontroller different sounds, tunes, or siren signals to generate, since buzzer in passive no electronics is present, sets a tone.

Task: Passive speakers are different tones and a melody to be generated.

Material: Arduino microcontroller / A passive speaker (passive buzzer) / Breadboard / cable

The generation of sound is largely based on the command "tone (x, y),” where the x value indicative of the pin on which it connects the speaker to the positive side and the Y value that indicates the pitch.

An example:

tone (8, 100); // The speakers on pin 8 is activated with the pitch "100."

delay (1000); // break with 1000 milliseconds, or 1 second - The speaker remains active for this time.

noTone (8); // The speakers on pin 8 is disabled

Code 1: Simple Tone

void set up() // The Setup information is not required.

// The voltage output for the piezo speaker no command "tone" is automatically set in the sketch by the Arduino,

{

}

void loop()

{

tone(8, 100); // The main part will be given the command "tone (x, y)" a sound.

delay(1000); // with a duration of 1 second noTone(8th); // The sound is turned off

delay(1000); // The speaker one second remains off

}

Code 2: Alternating Pitches

In the second example, only a few lines are complemented in the main part (loop). Characterized sounding two tones alternately with the pitch "100" or "200,” as in a siren. A break between the tones does not exist.

void set up()

{

}

void loop()

{

tone(8, 100); delay(1000);

noTone(8th); // At this point, the first sound goes out.

tone(8, 200); sounds // The second tone with the new pitch "200". delay(1000); //... and that for a second...

noTone(8th); // At this point, the second sound goes off, and the loop part of the sketch begins again.

}

Code 3: Tone Generate by Keystroke

In the third example, a button on pin 6 is added to the construction. In the main part of the button is read by an "IF query." If the button is pressed, you will hear a tone for one second with the pitch "300".

int Taster1 = 6;

int Button status = 0; void set up()

{

pinMode(Taster1, INPUT);

}

void loop()

{

Probe status = digital read(Button); if (Button == Status HIGH)

{

tone(8, 300); noTone(8th);

}}

Code 4: Sounds Depending on Different Keys

In the fourth example, different keys should be decided depending on the actuation of which sound is emitted from the speaker. For this purpose, it connects a probe connected to pins 6 and 7 in each case. The main part is decided by two "IF statements," in which sound is emitted.

Code:

int Taster1 = 6; // Taster1 connected to pin 6 int Button2 = 7; // button2 connected to Pin7

int Tasterstatus1 = 0; save // variable to indicate the status of the probe. 1 int Tasterstatus2 = 0; save // variable to indicate the status of the probe. 2

void set up()

{

pinMode(Taster1, INPUT); // Set Taster1 as input pinMode(Button2, INPUT); // Set button2 as input

}

void loop()

{

Tasterstatus1 = digital read(Taster1);// Status of Taster1 read (HIGH or LOW)

Tasterstatus2 = digital read(Button2); // Status of button2 read (HIGH or LOW)

if (Tasterstatus1 == HIGH) // If the Taster1 is pressed, then...

{

tone(8, 100); // outputting a sound with the pitch 100th delay (1000); // with the duration of one second noTone(8th); // off the sound.

}

if (Tasterstatus2 == HIGH)

{

tone(8, 200);

delay (1000); // with the duration of one second noTone(8th); // off the sound.

}

}

Create Melodies

In the Arduino software is a file containing specially designed to generate sounds using a speaker (passive buzzer). Instead of the pitch in the form of numbers such as. "Tone (8, 200),” and sounds from the Sounds can now be selected.

As an example, there is for it in the Arduino software to sketch "toneMelody."

To see "examples" -> "02.Digital" -> "toneMelody"

In the example, the file is already stored, the association is in the pitch and numerical value. She has the name "pitches.h." The content you can see if you click in the opened sample program on the second tab in the sketch.

To have access to the file must be in the sketch only the command #include

"Pitches.h" be installed and must be opened as a tab file. This is best done by opening the sketch "toneMelody" from the examples in the Arduino software and then edited. Thus, the "pitches.h" file is automatically invoked as a tab. This is clear in the following example.

This is a very small sketch of the alternating plays, two tones from the file "pitches.h".

#include "Pitches.h" void set up()

{

pinMode (8th,OUTPUT); // speaker Pin8

}

void loop()

{

tone(8, NOTE_C4, 1000); // At Pin8 played the note C4 for 1000ms delay(3000); // After the note sounds, the Sketch for 3 seconds pause. This means that after it plays the sound to the end, the remaining two-second pause with no sound.

tone(8, NOTE_G3, 1000); // At Pin8 played the note G3 for 1000ms delay(3000); // After the note sounds, the Sketch for 3 seconds pause. This means that after it plays the sound to the end, the remaining two-second pause with no sound.

}

In this sketch, the "Tone" command is no longer needed to end the sound through the extension.

Command:

"tone (x, y, z)" x = Pin of the speaker, y = pitch = z duration of tone in milliseconds.

Arduino Tilt Sensor SW-520D

Sketch: Reading With the Arduino a tilt sensor SW-520D

The Arduino can be in different inclinations measures. Very accurate measurements you get, for example, with an acceleration sensor in which one can almost measure any angle exactly. It is, however, also easy with the tilt sensor (SensorTilt or Tiltswitch).

However, this sensor detects only two stages, namely "inclined" or "not inclined." For this purpose, the sensor roll inside around two free-moving metal balls. Once the sensor is tilted so that one of the balls inside against the two contacts about these two contacts are interconnected. This is then as if a button is pressed, and the electric current can flow from one contact to another contact.

Therefore, the sketch and the structure is very similar to how the Stretch with the button.

When the sensor is used as in the picture vertically, for example, if it is simply plugged into the breadboard, the circuit between the two contacts is closed, and the current can flow from one contact to another.

Once the sensor is inclined by more than 45 °, the balls of the two contacts away and the connection is broken.

Task:

With a Tilt sensor to be turned on, an LED, when an inclination of more than 45 ° is present

Material: Arduino / a LED / A resistor 100 Ohm / A resistor 1K ohms (1000 ohms) / Breadboard / cable / inclination sensor

The Sketch:

int LED = 6; // The word "LED" is now available for the value. 6

int TILT = 7; // The word "TILT" is now available for the value 7 - The inclinometer is thus connected to Pin7

int TILT = 0; // The word "TILT" is now first for the value 0. Later will be saved under this variable, whether a slope of more than 45 degrees or not.

void set up() // Here the setup starts.

{

pinMode(LED, OUTPUT); // The pin with the LED (pin 6) is now an output. pinMode(TILT, INPUT); // The pin with the tilt sensor (pin 7) is now an entrance.

}

void loop()

{ // This brace is the Loop section opened.

TILT =digital read(TILT); // Here the Pin7, so the inclination sensor is read (: digital read command) is. It stores the result under the variable "TILT" with the value "HIGH" for 5V or "LOW" for 0Volt. When the sensor is even, the current can flow between the two contacts of the sensor. It is then up to Pin7 to a voltage. The status would be so "HIGH." When the sensor 45 or more degrees is inclined, no current can flow, and the status would be "LOW."

if (TILT == HIGH) // processing: If the sensor is inclined less than 45 degrees

{ Open // Program section of the IF command. digitalWrite(LED, LOW); // then the LED will not light

} // close the program section of the IF command. else //...otherwise...

{ Open // Program section of the else command. digitalWrite(LED, HIGH); //...should the LED lights.

} // close the program section of the else command.

} // This last clip of the loop portion is closed.

Temperature Measured with the LM35

Task:

With the temperature sensor, LM35 temperature is to be read and displayed monitor serial-by.

Material:

Arduino / cable / LM35 temperature sensor/screw Shield or cable for soldering to the sensor

The sensor has three connections. The red Contact 5V, the black GND, and the yellow is the contact for the temperature signal. At this contact, the sensor outputs a voltage between 0 and 1.5 volts. Wherein 0V 0 ° C and the corresponding value of 1.5V corresponds to 150 ° C. The voltage of this pin has to read from the microcontroller board and converted into a temperature value.

- The special at this temperature sensor is its waterproof feature. Thus, the temperature can be measured by liquids with the LM35.

- NOTE : If the sensor is connected incorrectly, it will burn out.

- In the structure of an external power supply should be used if possible, as this is it improves considerably the sensor accuracy (9V AC adapter or 9V battery).

Code:

int LM35 = A0; // The sensor A0 is to be connected to the analog pin. We call the pin from now "LM35."

int temperature = 0;// Under the variable "temperature" the temperature value is saved later.

int temp [10]; // This yields good values, one first read several values and then averages the results. The square bracket "[10]" produced here equal to ten variables named

"Temp [0],” "temp [2],” "temp [3],” … to … "Temp [9]." With the notation [10], So it saves only a little              Place.

int time = 20; // The value for "time" specifies the time intervals between the individual measurements in the code.

void set up()

{

Serial.begin(9600); // In the setup we start serial communication

}

void loop()

{

// more detailed explanation under the code * 1

temp [0] = map(analog read(LM35),

delay(Time);   0        410    -50,    150);

temp [1] = map(analog read(LM35),   0        410    -50,              150);

delay(Time);

temp [2] = map(analog read(LM35),   0        410    -50,              150);

delay(Time);

temp [3] = map(analog read(LM35),   0        410    -50,              150);

delay(Time);

temp [4] = map(analog read(LM35),   0        410    -50,              150);

delay(Time);

temp [5] = map(analog read(LM35),   0        410    -50,              150);

delay(Time);

temp [6] = map(analog read(LM35),   0        410    -50,              150);

delay(Time);

temp [7] = map(analog read(LM35),   0        410    -50,              150);

delay(Time);

temp [8] = map(analog read(LM35), 0, 410, -50, 150); delay(Time);

temp [9] = map(analog read(LM35), 0, 410, -50, 150);

temperature = (temp [0] + temp [1] + temp [2] + temp [3] + temp [4] + temp [5] + temp [6] + temp [7] + temp temp [8] + [ 9]) / 10;

Serial.print(temperature); Serial.println(" Centigrade");

}

Detailed Explanation for Loop * 1:

Here the temperature is ten times read in between is ever a break with the duration

"Time" in milliseconds. But what happens here, exactly? Let's look at the command once more closely.

temp [1] = map (analog read (LM35), 0, 307, 0, 150); Sequentially:

temp [1] - is the name of the first variable.

"Map (a, b, c, d, e)" - This is the so-called "Map" command. This may be a read-in value (a) in which the values between (b) and (c) are, convert them into a different speed range, in the range between (d) and (e).

In our command, the following happens:

The value of the sensor is directly read out in the "Map" command with "analog read (LM35)". The measured values should be between 0 and 307th. This corresponds to the analog port of the values between 0 V and 1.5V. The voltage is the sensor at temperatures between 0 ° C and

+ 150 ° C from. These values on the analog port will now be through the "Map command" directly into the

° C values between 0 and 150 are converted.

Then every ten ascertained temperature values are added together and divided by ten. The average value is stored under the variable "temperature."

Finally, the value of "temperature" on the serial communication to the PC is sent. Now the serial monitor you have to open the Arduino software to read the temperature on the sensor.

Expansion of the Program:

Once the temperature has reached 30 ° C, to a warning sound (beep of a piezo speaker).

Code:

int LM35 = A0;

int temperature = 0; int temp [10];

int time = 20;

int piezo = 5; // The word "piezo" is now the number five, so five of the piezo is connected to the port.

void set up()

{

Serial.begin(9600);

pinMode (Piezo, OUTPUT); // The piezo speaker to pin 5 should be (logic one output, because the yes from the microcontroller board yes a voltage needed to beep.

}

void loop() {

temp [0] = map(analog read(LM35),   0        307    0              150);

delay(Time);

temp [1] = map(analog read(LM35),   0        307    0              150);

delay(Time);

temp [2] = map(analog read(LM35),   0        307    0              150);

delay(Time);

temp [3] = map(analog read(LM35),   0        307    0              150);

delay(Time);

temp [4] = map(analog read(LM35),   0        307    0              150);

delay(Time);

temp [5] = map(analog read(LM35),   0        307    0              150);

delay(Time);

temp [6] = map(analog read(LM35),   0        307    0              150);

delay(Time);

temp [7] = map(analog read(LM35),   0        307    0              150);

delay(Time);

temp [8] = map(analog read(LM35),   0        307    0              150);

delay(Time);

temp [9] = map(analog read(LM35),   0        307    0              150);

temperature = (temp [0] + temp [1] + temp [2] + temp [3] + temp [4] + temp [5]

+ Temp [6] + temp [7] + temp [8] + temp [9]) / 10; // All in a row.Serial.print(temperature);

Serial.println(" Centigrade");

if (Temperature> = 30) // Creates a IF condition: If the value for the

temperature above or equal to 30, then...

{

digitalWrite(Piezo,HIGH); //... start beeping.

}

else // And if that is not so...

{

digitalWrite(Piezo,LOW); //... then be quiet.

}

}

Measure the Voltage

With the Arduino microcontroller board and a voltage sensor, one can measure the electrical voltage. We use a sensor that can lie to Measuring voltage in a range between 0 and 25V DC (direct current).

Task: A voltage with a voltage sensor (voltage sensor) measure and display on the serial monitor.

Material: Arduino / cable / voltage sensor

We want to measure a voltage of a voltage sensor and display them on the serial monitor. For example, a voltage sensor makes sense if you want to measure a voltage exceeding the maximum measurable voltage (5V) from the Arduino.

For example, a voltage sensor can measure in the range of 0-25V voltages. The module measures the voltage and converts them into measurable for the Arduino values.

By mathematical formulas in the code, it is possible to specify a voltage indicated on the serial monitor.

Cabling:

This is simply because the sensor has only three contacts, which must be connected to the Arduino.

Voltage sensor >>> >>> Arduino S A1

+ 5V >>>

–   >>> GND

On the other side, there are labeled GND and VCC contacts to which is connected to the voltage to be measured.

We now come to the code:

int value1;

float value2;

void set up()

{

Serial,begin(9600); // start serial connection

}

void loop()

{

float temp;

value1 =analog read(1); // read voltage value at analog input 1 temp = value1 / 4,092; // value mathematically convert to the voltage value to obtain in volts

value1 = (int) Temp; value2 = ((% value1 100) /10.0);

Serial,println(Value2); Show // Final voltage value in the serial monitor

delay(1000); // wait a second

}

If you now open after successful upload of the code the serial monitor, you can now see a voltage value every second. Since it still connects no power source, this should be at 0.00.

To see if everything is working, you can test as to connect GND contact from the sensor to the GND contact from the Arduino and the VCC contact from the sensor to the 3.3V contact from the Arduino. Now a value should show up to 3.3V on the serial monitor. The sensor is not quite exact. So it was with us 3.2V.

Four-Digit 7-Segment Display

Task: We want to display any number on the four-digit seven-segment display.

Material: Arduino / cable / 4 digit 7-segment display / 1K ohm resistors

The 7-segment display has 12 pins at the back, six at the top, and six at the bottom. Four of these pins correspond to each number. They can be "common anode," "common cathode," or. On which screen you can try the code, but we'll talk about that later. The other eight pins belong to each segment and the dot next to the number.

On a 7-segment display with only one or two digits, the segments are controlled by each digit separately. However, since this even greater confusion on the cable will be four digits than it already is, these displays work with "multiplexing." This means that if, for example, the four digits have to be checked at the same time, they will be checked very quickly. This happens so quickly that it seems to the human eye as if all four digits are displayed at the same time.

Explanation of Contacts:

Programming

A 7-segment display to program without endless code, you need a library that is not installed in the Arduino software. This "SevenSeg" Library of Dean Reading can be downloaded here: https://github.com/DeanIsMe/SevSeg, and The library must then be known as already from the previous instructions, added to Arduino software.

This goes on easiest in the Arduino software at Sketch> Include Library> Add.ZIP Library.

Code:

#include "SevSeg.h" // Load The previously added Library SevSeg sevseg; // initialize a seven segment object

void set up() {

byte numDigits = 4; // Here the number of digits is specified

byte digitPins [] = {2, 3, 4, 5}; // The pins on points are set

byte segmentPins [] = {6, 7, 8, 9, 10, 11, 12, 13}; // The pins on the

// segments are defined

sevseg.begin(COMMON_CATHODE, NumDigits, digitPins, segmentPins); //In this

// section you can either test what kind of display you own or

// you can specify it. Try both as the display works only when the correct //type is entered - COMMON_CATHODE or

// COMMON_ANODE display. The wrong type will make all digits, and //segments light up simultaneously.

}

void loop() {

sevseg.SetNumber(1234.3); // Here we can now enter the desired number.

// 1234 is the example we used. The number after the comma represents

// the lit-up dot, i.e., 3 indicates the dot beside the first digit and 0 //indicates the dot beside digit 4.  If you do not want a dot showing,

// input 4.

sevseg.refresh display(); // This is where the numbers are started on the displays

sevseg.SETBRIGHTNESS(90); // Here the brightness of the display can be

//added in a range of 0-100 where 100 is the brightest.

//0 doesn’t indicate a completely dark display. Only using

// ,,sevseg.refreshDisplay ();controls what is on the display

}

In the sevseg library, there are some interesting sample codes available. These can be in File> Samples> SevSeg-master.

Conclusion

Well, here in the closing of this book, we want to detail the reasons why we think Arduino should be in your life, both professional and private.

Arduino boards are interesting, especially for students and teachers because of  their low cost. For less than 100 dollars you can buy the official Arduino Starter Kit that comes with all the necessary components to get started in this world, and if it seems expensive, there are always Arduino starter kits composed of fully functional Arduino board clones (advantages of free hardware on which Arduino is based), and for less than 50 dollars you can get more than enough to start. Even if you're not a student and you're only interested in finding a hobby to spend time with, Arduino is going to be cheaper than photography, painting, or gardening.

With Arduino, you can work on almost all computer platforms, from Mac OS X to Linux through Windows. Thanks to the fact that it is open-source, multiple tools have appeared that make it easy to use, for example, Scratch or its equivalent for Arduino Scratch for Arduino. Apart from the software, it is also flexible when using different accessories available in different kits, so you have the freedom to choose the components to use in your project. There is also flexibility regarding the Arduino itself since depending on the project you have in mind there is an Arduino for each project, from the smallest to make wearables such as the Arduino Gemma to other more powerful ones such as the Arduino Mega or the Arduino Yun in which you can install a network server.

The limit is your imagination. If you have been reading about Arduino for a while, you will have realized that many projects can be done with Arduino, from the simple ones that come in the starter kits to 3D printers or robots such as those from Star Wars, R2D2 or new BB8.

Or how about making a surveillance system for your home or building your own drone. All these things you can do with Arduino. Now is the time to get started!

References

https://stackoverflow.com/questions/15113128/ir-hex-comparison

https://www.copyscape.com/prosearch.php

https://arduino.stackexchange.com/questions/18503/ script-stops-functioning-after-calling-irsend-function-in-irlibrary

http://archive.fabacademy.org/fabacademy2017/fablabbottrophrw/students/64/ week13.html

https://forum.sparkfun.com/viewtopic.php?t=46505

https://github.com/miguelbalboa/rfid/issues/496

https://community.particle.io/t/rfid-code-explanation-needed/53961

https://forum.arduino.cc/index.php?topic=424620.0

https://community.platformio.org/t/wire-h-is-missing-and-cause-a-simple-program-to-not-compile/550

https://forum.arduino.cc/index.php?topic=424620.0

https://media.digikey.com/pdf/Data%20Sheets/DFRobot%20PDFs/DFR0009_Web.pdf

https://community.platformio.org/t/wire-h-is-missing-and-cause-a-simple-program-to-not-compile/550

https://www.geeetech.com/wiki/index.php/Arduino_1602_LCD_KeyPad_Shield

https://protosupplies.com/determining-unknown-i2c-addresses/

https://forum.arduino.cc/index.php?topic=315058.15

https://www.instesre.org/ArduinoWeatherStationCode.txt

http://arduino-tutorials.eu/real-time-clock-tutorial

http://arduino-tutorials.eu/arduino-keypad-lock-tutorial

https://www.instructables.com/id/EAL-MM-Sorting-Machine/

http://tinkbox.ph/sites/mytinkbox.com/files/downloads/ TCS230_COLOR_SENSOR.pdf

https://github.com/Nikaoto/Shamen/blob/master/lib/deep.lua

http://arduino-tutorials.eu/arduino-four-digit-seven-segment-display

ARDUINO

PROGRAMMING

Advanced Methods and Strategies to Learn Arduino Programming

STUART NICHOLAS

Introduction

The versatility, capability, and scope of Arduino are incredibly amazing. With hardware that is easily available in the market and its wide connectivity support, the possibilities of what users can do with this small computer are nearly endless. This is one of the major reasons why Arduino is being given more emphasis in the modern world. People are steadily discovering its hidden potential and realizing its true worth.

In this book, we will try to explore Arduino's capabilities to the furthest end and try to implement the knowledge we have learned into practicing building Arduino projects. Only talking about the theoretical possibilities of the techniques and methods is just not enough. Putting them into practice and seeing the results of your hard work provides a level of satisfaction that simply cannot be matched by anything else. The book will start by taking the readers through a brief tour exploring the Arduino environment's software and hardware aspects and then gradually proceeding towards learning how to use the Arduino’s integrated development environment. From here, we will move on to discussing advanced manipulation of elements in coding, such as variables, integers, strings, floating-points, loops, conditionals, and nests, etc. Once we have gone through initial important stuff, we will explore the higher levels of Arduino programming, where we will learn how to execute digital read and write operations, analog read and write operations, and manipulate both the board’s digital and analog pins through software and much more. Since we are focusing too much on coding anyway, we will also briefly explore some useful tips on making our Arduino programs work more efficiently without hogging too many resources by learning memory handling techniques. Finally, we will discuss a few Arduino projects which will involve circuitry, displays, and many more electronic components and hardware.

It is suggested to keep in mind that every chapter we go through has an important core concept that the reader has to learn to understand the later concepts. Even if the chapters' pace seems slow, be assured that after the initial half, the chapters will feel more concentrated and packed with advanced methods and techniques that you can employ and practice to polish your Arduino skills.

Chapter 1

Setting Up the Tools

Unlike other programming languages and their environments, Arduino is focused on allowing users who are not experienced in software and electronics programming to work on highly technical projects. Usually, such projects involve creating digital music instruments, working in robotics, games, and much more. The reason why the Arduino environment is preferred for fields such as mechatronics, robotics, electrical engineering, and even for those who are just tech enthusiasts is that users don’t need to be above-average regarding the software of their project and the electronic design as well. This makes even beginners exploring the world of technology and computing highly motivated when they find that Arduino allows them to transform their creative ideas into a tangible reality.

Due to the incredible functionality and usability of the Arduino environment, educational institutions worldwide use it for professionally training their students in their respective majors. For instance, people who are committed to creating designs and sketches of a product’s prototype will absolutely need to be aware of the product's technicalities before they can even proceed. However, with Arduino, this extra layer of complexity is shaved off from their work. They can easily focus on the design without having to worry about the sophistication under the hood of the product. In other words, Arduino itself is designed by people who are not specialists in robotics, electronics, or even engineering; this is why they have kept the end-user as their primary focus and have given the best user-friendly experience to help facilitate the user.

Although Arduino's hardware capabilities are what makes it stand out, the reality is that without the proper software, the hardware is just a useless chunk of metal. Hence, Arduino collectively refers to both the software and hardware aspects of the environment.

The Arduino Software

Like any computer hardware, unless there’s software that is controlling it, it's nothing more than a useless pile of metal. The software allows a user to directly interact with a system’s embedded hardware, in turn utilizing its functionalities for specific purposes. This also applies to Arduino hardware as well. Since Arduino is used for specialized projects, the software needs to be tailored accordingly as well. These programs designed and developed specifically for Arduino hardware are known as ‘sketches .’ Just as an application is developed using the IDE of a particular programming language, sketches are also created using the Arduino IDE.

Arduino Hardware

The piece of hardware that the user will end up interacting with is the ‘Arduino board .’ The software that we created using the Arduino IDE directly interacts with this board, executing any instructions embedded within the program. Generally, people do not use just the Arduino board itself; on the contrary, there are extra components available that pop onto the Arduino board extending its usability. For instance, we can attach things like switches, thermal-sensors, gyroscopes, pressure sensors, LEDs, output displays, and even motors to the Arduino board, all depending on what the project requires.

When using the Arduino environment for a project, users can choose from a variety of Arduino hardware boards according to the needs of the project and the Arduino software. There are a variety of Arduino boards available in the community for users to pick up. There are official Arduino boards released by the Arduino team, as well as Arduino boards that are released by the members of the community. Suppose you are picking up a project from the community and modifying it according to your needs. In that case, it's recommended to use the tools as specified by the original project designer or swap a few things in and out as you see fit. Arduino boards come in a variety of form-factors. You can find boards that are as small as credit cards and boards that are just large enough to design a project that features applications such as wearables. However, one thing to note is that different sized boards do not have the same specifications. Generally, smaller Arduino boards have fewer connection points for external peripherals and an underwhelming processor. In contrast, bigger boards feature a more robust processor and an increased number of connections (since the size is bigger, it can easily accommodate more ports). A quick run-through of the popular Arduino boards has been given below;

- Arduino Nano

- Arduino Bare Bones

- Boarduino

- Seeduino

- Arduino Teensy and Arduino Teensy plus

Setting Up The Arduino IDE

The Integrated Development Environment software for Arduino is available for the three most popular Operating Systems, i.e., Windows, macOS, and Linux. To download the IDE, you will have to visit Arduino’s official website to do so, which has also been linked below;

http://arduino.cc/en/Main/Software

When you visit the website, select the Operating System for which you want to download the IDE application, and then follow the instructions. Once the Arduino IDE is installed, we can launch it by simply clicking on the ‘Arduino.exe ’ file. However, installing the IDE is not enough because, at this point, the software (the IDE) and the hardware (the Arduino board) are not able to interact with each other. This is because we have not installed the necessary drivers for the Arduino board we are using. Luckily, this step is nothing complicated as well.

If you are using a PC running on Windows, connect the Arduino board to the computer using a USB cable. Once the board is connected, Windows will automatically find and install the necessary drivers. If the PC is unable to install the drivers properly for some reason, we can manually do this in the device manager. The IDE installation folder also has a separate sub-folder for drivers of Arduino boards. There’s a good chance that the driver for the board you are using will be in this folder as well. So open the device manager, look for the ‘unrecognized’ drivers, and then right-click them to open their properties. After this, all you need to do is simply click ‘update driver’ and choose the manual option and then specify the file directory which contains the drivers. In this way, you manually install your Arduino board’s drivers.

On a Mac, the IDE application installer file will be a disk image, and inside this disk image, there is also an installation wizard for the drivers as well. This file is generally named ‘FTDIUSBSerialDriver.’ Once you install the IDE, then simply run this file to install the drivers as well.

The Arduino Board

In this section, we will talk about the proper way in which we can set up an Arduino board and see if it works correctly. Most of the available boards feature a small LED that lights up when connected to a power source. Check for the USB port on your Arduino board and then connect it to your PC via a USB cable. If the LED on the board lights up, it indicates that the board is working properly (powering up at least). There is another LED indicator on the board as well that can be found in the middle area. This LED lights up with an orange color and flickers to show there is no issue with the components.

Upon connecting the board to your PC, if the green LED does not light up, it means that the board has a power issue. There’s a possibility that the USB port is faulty or the cable itself; however, if the peripherals are working, you should plug in the power adapter. If the LED still does not light up, then the problem is in the board’s power supply. It’s better to get a new one or a replacement in such cases.

The flashing orange LED light is controlled by a simple program loaded onto the board by the manufacturers themselves. If the orange LED light does not flicker, it means that either the sketch program has not been loaded on to the board’s chip or is faulty. In such cases, you should manually flash the sketch program on the board. If it still doesn’t work after doing that, then there’s a problem with the Arduino board.

Using the Arduino’s Integrated Development Environment

This section will be going over creating an Arduino sketch and then using it on the board.

Once we launch the IDE we downloaded on to our PC, we now can generate sketches, launch existing sketches, and even modify the sketches we have access to. These actions can be performed using the buttons present in the IDE’s toolbar or by using assigned short-cut keys. However, we will not go into any further details of how to use the IDE’s interface.

In the Arduino IDE, examples are also available to show the code for performing basic tasks on the Arduino board. To access these demonstrative sketches, you will have to go to the IDE toolbar and find the ‘Files’ option. In the ‘Files’ drop-down menu, go to ‘Examples,’ and  you will find the examples section with a range of basic sketches for the Arduino board. For instance, the code for controlling the board’s LED blinking can be found within this section as the ‘Blink ’ sketch. It is easier for someone who does not have much experience with programming and coding to use sketch perfectly well because of these example codes. Apart from the basic codes, 17 example codes cover all the board's functionalities that can be controlled through sketch programs. Users can simply import the example code for the task they wish the board to execute and easily complete their projects. This convenience is very appreciated within the programming and professional community like mechatronics as well.

Once we have created a sketch we want to use on the Arduino board, we must compile it first. The board cannot use the sketch program unless it has been compiled before-hand. Once the sketch program has finished compiling, the user will see the ‘Done Compiling ’ message in the IDE’s console. However, one should always be wary of the sketch’s size before using it with the board. This is because Arduino has limited storage support for the sketches being imported. If the sketch program exceeds the board’s size limit, then the board's code execution will simply fail. Once you compile the sketch program, the sketch's size will be displayed in the IDE’s console along with the size limit supported by the board itself. Different boards have different size limits, so check the maximum limit of the Arduino board you are using. An example of such a message has been shown below;

Binary sketch size: 1008 bytes (of a 32256 byte maximum)

If the instructions detailed in the sketch program exceeds the size that is supported by the Arduino board you are using, then the IDE will display the following error message;

Sketch too big; see http://www.arduino.cc/en/Guide/Troubleshooting#size

for tips on reducing it.

If you encounter this error, you will have to shave down the sketch program to decrease its size until it can be accommodated within the board’s memory. If making changes to the sketch program is not an option, then the only alternative is to simply get an Arduino board with larger memory space.

Like the Python and C programming language IDEs, the Arduino IDE compiler can also display errors made in the code of the sketch program. All the errors can be seen in the console after the compilation. However, once users import an example code and modify it by themselves, the IDE does not allow them to save these changes to the example file itself. This is to ensure that the integrity of the example codes remains intact. Once you use an example code and modify it, you will have to save it using the ‘Save As ’ option, which can be found in the toolbar's ‘Files’ menu. Suppose you know that you’ll frequently be making modifications and tweaking the source code. In that case, it is recommended to specify the sketch program's iteration to keep track of which changes were made to which iteration of the same sketch.  Another important thing to be mindful of is that once a sketch program is uploaded to the Arduino board, then it cannot be downloaded back to the system from where it was originally exported. That’s why you should always save your sketch programs on the system before uploading it to the board.

Exporting the Sketch Program and Executing it on an Arduino Board

This section will discuss how to export the sketch program we created and saved on our system to the Arduino board and see the code work its magic.

First and foremost, to copy the sketch from our system to the Arduino board, both need to be connected. So, we need a USB cable that has A-type connection points on both ends. We then connect one end to the Arduino board and the second end to our system. Once the connection has been established, we are ready to export the sketch file to the board.  Before we can do that, we must run the Arduino IDE and load a sketch program on to it. To keep things simple, we will export the blink sketch, which is available in the examples section in the IDE, to the connected Arduino board.

Once the IDE has loaded the sketch program we want to export, the next thing to do is to go to the IDE’s toolbar and click the ‘Tools ’ menu. From the drop-down list, look for the ‘Boards ’ option. The Arduino board that is connected to your system will show up here; at this point, all you have to do is look for the name of the board you are using and select it. Once this is done, go to the ‘Tools ’ menu again and this time, look for the ‘Serial Port ’ option. Over here, you will find all the serial ports that are present on the system you are using. If your system is running the Windows OS, then you will either find a single entry or multiple entries in this section. In case you see only a single entry, then that’s the port on which your board is connected to your system. If there are multiple entries, then the board will most likely be the last entry. In case you are using a Mac, then each entry shown in the ‘Serial Port ’ option will have two iterations, and each iteration will have different ending values. Selecting either entry is fine.

Once you have selected the board and the corresponding serial port, all that’s left to do is select the upload button on the main IDE interface or go to the ‘Files ’ menu in the toolbar and select the ‘Upload to I/O board ’ option from there.

Once these steps have been performed, the IDE will automatically compile the code in the sketch program. When the compilation is done, the program will be exported to the Arduino board. Once the export process is completed, the board will immediately start executing the instructions detailed in the sketch program exported to it. In this case, two LEDs will start blinking on the Arduino board as specified by the program. Once the sketch program's instruction set is completely executed, the LED's blinking will stop and the LED will be reset to its original state.

This is necessary because the PC needs to know which board the code needs to be sent to and which port connects it to the PC. Once the export process begins, the sketch currently being executed on the Arduino board is suspended and until the new sketch program is loaded on to it. Once the process is completed, the execution of the new sketch begins. However, a thing to keep in mind is that whenever a sketch program is exported to an Arduino board, the sketch program running currently on the board is overwritten and lost. So, it is recommended to save all the sketches that you create because you might need it in the future.

There are some cases where the upload process might not be successful. Usually, the reason for this is that some old Arduino boards and some new versions have compatibility issues. In such scenarios, the IDE will display an error message to the user when the sketch program's export is unsuccessful. Most of the time, if you encounter this error, the issue is caused by an incorrect selection of the Arduino board or the serial port. Another case could be that the board is simply just not connected properly to the system. Selecting the wrong port is one of the most common causes of this issue. An easy workaround to this is to disconnect the Arduino board connected to the system and then check the ports being shown in the IDE's serial ports menu. Once you have taken a look at the available serial ports, connect the board back to the system and then check one which was not shown previously. The new port being displayed is the one through which your board is connected to the system.

Building a Sketch Program and Saving it

In this section, we will discuss the process of using the Arduino IDE to create a sketch program and then save it onto your system.

Just as how we can open Microsoft Word and choose the ‘New ’ option to create an empty file and then fill it with content, in the same way, we can create a new sketch program by simply opening the IDE and choosing the ‘New ’ option under the ‘Files ’ menu. Once this is done, a new tab will be opened within the IDE to isolate the program you are working on from other sketches. In this tab, you can write as many code lines as necessary for your project (keeping in mind the size limit, obviously). Here’s an example of a modified ‘blink ’ code available in the IDE. The difference over here is that the duration in which the light stays illuminated before blinking is doubled.

const int ledPin = 13; // LED connected to digital pin 13

void setup()

{

pinMode(ledPin, OUTPUT);

}

void loop()

{

digitalWrite(ledPin, HIGH); // set the LED on

delay(2000); // wait for two seconds

digitalWrite(ledPin, LOW); // set the LED off

delay(2000); // wait for two seconds

}

If we are using this code as a sketch program, we will have to compile it. So let’s go over the process of exporting code on to Arduino boards. First, we will write this code (or copy it if you want to) in the IDE, and then we will compile it using the ‘Compile ’ option in the IDE interface and export it to the board using the ‘Upload ’ option either through the ‘Files ’ menu or through the interface button. Once the file is uploaded, we then save it on our system as we might need it in the future. To do this, we use the ‘Save ’ or ‘Save As ’ option in the ‘Files ’ menu.

When you save a sketch program, by default, the IDE software will set the location to a directory named ‘Arduino ’ in the user’s ‘My Documents .’ This happens when we are using a Windows system; if it’s a Mac, then the default file directory will be inside the ‘Documents ’ folder. It is recommended to name your sketch programs such that they reflect their usage or the instructions; however, the name of the sketch cannot be the same as the example sketch files. This makes it easier when you are dealing with a lot of sketch programs and saves you from the trouble of having to look through each program and see what it does before you find the sketch you’re looking for. Using the default save location of the IDE has its perks as well. Sketch program files stored in this directory are automatically displayed within the ‘Sketchbook menu ’ of the IDE, making it quicker and easier for the user to access.

One of the weaknesses of the Arduino IDE is its absence of sketch version management. This means that the IDE application does not have the functionality to revert the modifications made to a sketch over different iterations. So, if you find yourself frequently modifying your sketch files, then it is recommended that you keep each modified version of the program saved on your system. In this way, if you wish to use an older version of the same sketch program, you can do so.

If you are creating an Arduino IDE program from scratch or extending the example sketches, then it’s a good idea to compile the program frequently. In this way, you can easily fix any errors that pop up as you finalize the code without having to deal with a whole bunch of errors at the end and getting overwhelmed with the necessary changes.

Before we move on, there’s one final thing that needs to be discussed and it is the folder that contains the sketch file itself. In the Arduino IDE, the sketch programs must be stored within a folder that has a name matching the program's name.

Working with Arduino

Before we conclude this chapter, we will briefly demonstrate building a simple Arduino project using an Arduino board, some electrical components, and the Arduino IDE. This section will be brief and concise as practical projects have been discussed in detail in this book's upcoming chapters.

In this demonstration, we will be looking at a project which involves an LDR sensor connected to the Arduino board. This sensor will be responsible for controlling the frequency at which the LED on the board blinks and the duration as well. Since the core functionality is still the blinking of LED, we will be using the ‘blink’ sketch example and modify it according to the project's needs.

The idea here is that the LDR sensor will react to the board’s LED illumination intensity. The LDR sensor will be connected to ‘Pin 0’ on the analog circuit and the board LED is accessed through ‘pin 13’ on the digital section. Now that the project has been set up, all that’s left to do is create a sketch program and then export it to the Arduino board connected to our system. The sketch which will be used is as follows;

const int ledPin = 13; // LED connected to digital pin 13

const int sensorPin = 0; // connect sensor to analog input 0

void setup()

{

pinMode(ledPin, OUTPUT); // enable output on the led pin

}

void loop()

{

int rate = analogRead(sensorPin); // read the analog input

Serial.println(rate);

rate = map(rate, 200,800,minDuration, maxDuration); // convert to blink rate

digitalWrite(ledPin, HIGH); // set the LED on

delay(rate); // wait duration dependent on light level

digitalWrite(ledPin, LOW); // set the LED off

delay(rate);

}

Before we can even leverage the sensor's functionality, it needs to be connected to the board so the two components can communicate with each other. To do this, we will have to create a simple circuit that will consist of the LDR sensor itself and a suitable resistor. A resistor with a rating between 1000 to 10,000 ohm will be work just fine. Now that we know how the components need to be connected, let’s discuss the program demonstrated above. The core concept around which this program is designed is to define a certain value which corresponds to the intensity of the LED light. The brightness of the light emitted by the LED at pin ‘0’ will be interpreted by the LDR sensor connected to the board and its value will change accordingly. Based on this changing value, the sensor will increase or decrease the corresponding LED's voltage level accordingly. To read the value being pushed out by the sensor, we use a function known as ‘analogRead() .’ So, if the sensor detects that the light’s brightness is high, then the value will also be read as high by the function (in this case, the value will be ‘800’). Similarly, if the light's brightness is low, then the value given will be low as well (in this case, ‘200’). The voltage of the LED will be controlled by the LDR sensor accordingly.

We can specify the flickering rate of the LED by using the ‘map()’ function as well. The following code shown below demonstrates this;

const int ledPin = 13; // LED connected to digital pin 13

const int sensorPin = 0; // connect sensor to analog input 0

// the next two lines set the min and max delay between blinks

const int minDuration = 100; // minimum wait between blinks

const int maxDuration = 1000; // maximum wait between blinks

void setup()

{

pinMode(ledPin, OUTPUT); // enable output on the led pin

}

void loop()

{

int rate = analogRead(sensorPin); // read the analog input

// the next line scales the blink rate between the min and max values

rate = map(rate, 200,800,minDuration, maxDuration); // convert to blink rate

digitalWrite(ledPin, HIGH); // set the LED on

delay(rate); // wait duration dependent on light level

digitalWrite(ledPin, LOW); // set the LED off

delay(rate);

}

We can also use the Serial Monitor available in Arduino to take a look at various stuff to fine-tune the sketch program. For instance, we can observe the frequency at which the LED blinks at certain variable values. So, we can precisely know the blinking rate at a specific value and then set the value at which we want it to blink. This frequency is displayed in the IDE’s Serial Monitor. The following lines of code demonstrate the usage of Serial Monitors;

const int ledPin = 13; // LED connected to digital pin 13

const int sensorPin = 0; // connect sensor to analog input 0

// the next two lines set the min and max delay between blinks

const int minDuration = 100; // minimum wait between blinks

const int maxDuration = 1000; // maximum wait between blinks

void setup()

{

pinMode(ledPin, OUTPUT); // enable output on the led pin

Serial.begin(9600); // initialize Serial

}

void loop()

{

int rate = analogRead(sensorPin); // read the analog input

// the next line scales the blink rate between the min and max values

rate = map(rate, 200,800,minDuration, maxDuration); // convert to blink rate

Serial.println(rate); // print rate to serial monitor

digitalWrite(ledPin, HIGH); // set the LED on

delay(rate); // wait duration dependent on light level

digitalWrite(ledPin, LOW); // set the LED off

delay(rate);

}

The LDR can also be used for purposes other than simply controlling the LED blink rate. For instance, we can wire a small speaker to ‘pin 9’ and its resistor to ground on the digital connection pins to manipulate the resulting sound’s volume.

Since we are working with sound this time, we will have to adjust the frequency at which the pin turns on and off such that it matches with a frequency in the sound spectrum. To do this, we can simply define a variable as ‘rate ’ and then divide it by a factor of 100. The following lines of code demonstrate this:

const int ledPin = 13; // LED connected to digital pin 13

const int sensorPin = 0; // connect sensor to analog input 0

const int minDuration = 100; // minimum wait between blinks

const int maxDuration = 1000; // maximum wait between blinks

void setup()

{

pinMode(ledPin, OUTPUT); // enable output on the led pin

}

void loop()

{

int sensorReading = analogRead(sensorPin); // read the analog input

int rate = map(sensorReading, 200,800,minDuration, maxDuration);

rate = rate / 100; // add this line for audio frequency

digitalWrite(ledPin, HIGH); // set the LED on

delay(rate); // wait duration dependent on light level

digitalWrite(ledPin, LOW); // set the LED off

delay(rate);

}

Chapter 2

The Basics of Arduino Programming

So far, we’ve studied what an Arduino micro-controller is, and how the native coding environment that is provided alongside works. Let’s now step up into learning about how actually to use all of this. This chapter will serve to create a basis for understanding and writing Arduino code, that we can interface into micro-controllers and create wonderful things as we so desire.

To be specific, this chapter will teach you about:

- Variables, constants, and their usage.

- The versatility of included math functions.

- Code comments.

- Coding in “Decisions” and reasoning behind it.

- Looping and reusing bits of code.

We’ve had some experience with Arduino IDE Client and its Web Editor and learned how to use setup() and loop(). This chapter, along with the next one, will deal with syntax, programming practices, and general how-to's related to Arduino’s programming language. We’ll start by introducing the most fundamental components of basic code syntax.

Curly Bracket

The pair of curly brackets are used to tell the IDE where a block of code will start and where it will end; the left ( { ) for the former and the right ( } ) for the latter. You might have seen examples of this in prior sections, though we would like to mention these are used to make code blocks other than those of functions as well; this will be elaborated on further into this chapter.

Do note that full pairs of brackets must exist (an equal number of left and right brackets means that they’re “balanced”); otherwise, errors such as crypt compiler errors will occur, in which case counting these pairs is a good idea.

Semicolons

A semicolon is used to close off and end a statement of code (i.e., put at the end, like a period for normal sentences) to distinguish it from other lines. Not doing so will result in a fairly easy-to-debug error during compilation, as the IDE will mention where this has occurred.

Another use for semicolons is separating elements in for loops, which will also be discussed later.

Comments

Comments are bits of written text tagged with a syntax (in our case, a mix of forwarding slashes and asterisks) so that the compiler doesn’t read them and add them to the functionality of the program, allowing us to write whatever we want as comments to the actual code. There are two kinds of comments that the IDE has: Block comments and Line comments. Block comments are usually big blocks of text that describe the code around it, whereas line comments usually serve as a heading or a nametag for the code near it, telling the reader what it does.

A block comment uses ‘ /* ’ and ‘ */ ‘ to define where it starts and ends, respectively:

/* This is a block comment

This comment can span multiple lines

This type of comment is usually found outside function calls

*/

In contrast, a line comment begins with ‘ // ‘ and continues till the line ends. This can be put at the start of a line or somewhere in between; both of these work:

// This is a single line comment

Serial.println("Hello World"); // comment after statement

Using comments to describe your work is a very good habit for readers to be able to discern what you want to do.

Variables

Variables are the meat and potatoes of coding. These are objects that store information for further application by the functionality of the code. Every variable has a unique name used to identify it and thus the information it stores. A good habit for naming variables is using Camel Case (i.e., writing the first word in lowercase, and then the first letter of the second word in uppercase, like a camel’s humps, e.g., oldGreyDog, warmApplePie)

Another good habit is to initialize the variable by assigning it a value, which helps in errors where the variable is called without a value. To do so, we tell it what data type it will be, give it a name, use an equal sign, and then give it an initial value (usually zero).

int myInt = 0;

Datatype

What is ‘int’? It is a datatype , a kind of badge that says what set of values the variable can hold. Let’s examine some more built-in datatypes commonly used in coding with the Arduino language.

Boolean

This datatype is used for basic logical decisions at least as old as Shakespeare: true or false. This datatype‘s size is one bit. These are the only values this set has.

boolean myBool = true;

This code declares the variable myBool as being a boolean, with an initial value ‘true.’ As you might expect, this datatype is extremely common in Arduino, and all comparison operations produce (or ‘return’) a Boolean value.

Byte

A byte is eight bits, i.e., it is eight binary digits long, capable of referring to integer values from zero or 255. The keyword for this datatype is ‘byte.’

byte myByte = 128;

Integer

By far the most used data type, we use this to store integer values; the total number of unique values allowed is 2^16 or two bytes (sixteen binary digits long): from –32768 to 32767. We can also have it be unsigned, via adding the keyword ‘unsigned,’ to have this range go from 0 to 65,535. The keyword for this datatype is ‘int.’

int mySignedInt = 25;

unsigned int myUnsignedInt = 15;

Long

Similar to the previous datatypes, the long datatype can store four bytes (thirty-two binary digits) worth of integer numbers, from –2,147,483,648 to 2,147,483,647. ‘unsigned’ can be used as well for the same effect, going from 0 to 4,294,967,295. The keyword for this datatype is ‘long.’

long myLong = 123,456,789;

Do note that this consumes more memory (double that of integer), so take care to not use it unless it is necessary to store numbers that large.

Double and Float

These datatypes are ‘floating-point’ numbers, i.e., they allow us to go between integers and into decimal points. Both of these datatypes can store values ranging from -3.4028235x10^38 to 3.4028235x10^38.

Often (depending on what programming environment we’re using) these datatypes differ in the amount of decimal point accuracy, with float having an accuracy of six to seven decimal places as compared to double’s fifteen. However, for the Arduino platform, they both have the same accuracy of six to seven decimal places.

A few things to note: one, the precision inaccuracy may result in some weird values being returned to you, such as 6.0 divided by 3.0 giving a result of 1.9999999. two: floating-point/decimal computation is much more resource-intensive than the comparatively simpler integer math operations. For these reasons, do take to use these datatypes only when necessary.

The double datatype’s keyword is ‘double,’ while the keyword for the float datatype is ‘float.’

double myDouble = 1.25;

float myFloat = 1.5;

Character

Characters are generally referred to as the glyphs of alphabets and various other symbols, i.e., characters. However, on the back end, these characters are a numerical value that refers to the ASCII chart; we can store a character as either of these. The keyword for this datatype is ‘char’

char myChar = 'A';

char myChar = 65;

Both lines of the above code declare a character ‘myChar’ storing capital A. We can store a group of these characters using a method that will be discussed later, which will let us store words and sentences.

Arrays

An array is a storage structure that assigns an index value to some data and allows us to store multiple data entries into one structure, with the caveat that it must be of one datatype that is declared alongside the array during initialization. A few ways to define arrays are as follows:

int myInts[10];

int myInts[] = {1, 2, 3, 4};

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

Notice that the name has a pair of square brackets, which is how we tell the environment that we’re creating an array.

- The first line defines an uninitialized array that can store ten values in a row but doesn’t store any at the moment. Be careful of declaring uninitialized arrays, as its interactions with memory spaces can be quite weird.

- The second line initializes an array with an undefined size but with a defined number of values. In this case, the array matches the size of the row of values that we defined.

- The third line initializes an array with both a defined size and values. In this case, the defined values are assigned to the first spaces in the array, but the last three are not. Care must be taken in this case for the same reason as the first declaration, which will be demonstrated shortly.

Let’s look at how actually to use arrays:

We access a value in an array by writing the array name, the square brackets, and the value’s index inside the bracket, such as follows:

int myInts[] = {1, 2, 3, 4};

int myInt = myInts[1]; //counting from 0, myInts contains the second value in the array, ‘2.’

The above code notes that for most programming languages, we count indexes starting from zero. The following should serve as further clarification:

int myInts[] = {1, 2, 3, 4};

int myInt0 = myInts[0]; // contains 1

int myInt1 = myInts[1]; // contains 2

int myInt2 = myInts[2]; // contains 3

int myInt3 = myInts[3]; // contains 4

Now let’s look at what happens when arrays aren’t initialized. Run the following in the Arduino IDE, and you’ll notice that the Serial Monitor displays a jumbled mess that is definitely not integers since they were never initialized.

int myInts[5];

Serial.println(myInts[0]);

Serial.println(myInts[1]);

Serial.println(myInts[2]);

Serial.println(myInts[3]);

Serial.println(myInts[4]);

Fortunately, providing values to uninitialized indexed array space is the same as providing a value to any variable, as follows:

int myInts[2];

myInts[0] = 0;

myInts[1] = 1;

Another possibility is multi-dimensional arrays, which are technically arrays stored within arrays. Two ways describing how we’d define one are as follows:

int myInts[3][4];

int myInts[][] = { {0,1,2,3}, {4,5,6,7}, {8,9,10,11} };

They’re accessed in the same way as you’d expect:

int myInts[3][4];

int myInts[][] = { {0,1,2,3}, {4,5,6,7}, {8,9,10,11} };

Now let’s use what we’ve learned about arrays and characters, and combine them into something that will let us write sentences:

Character Arrays

Character arrays are arrays that store characters. They’re initialized the same way as regular arrays:

char myStr[10];

char myStr[8] = {'A,’ 'r,’ 'd,’ 'u,’ 'i,’ 'n,’ 'o,’ '\0'};

Character arrays are often referred to as Strings of characters. The previous code describes how we’d make a string that says ‘Arduino.’ The ‘\0’ character represents a null which terminates the string by being at the end of it. This is referred to as Null Termination , and it helps the IDE and its functions determine where the string, stored in memory space, ends; otherwise, these functions would continue until some other null character is encountered and produce a bunch of garbage data meanwhile.

Simpler ways to declare strings are as follows:

char myStr[] = "Arduino";

char myStr[10] = "Arduino";

The first line makes an array that resizes to contain 9 characters - the word ‘Arduino’ and the null terminator, whereas the second line’s array leaves space for them to be put in their respective positions.

Note that a string object exists, which will be discussed outside of this chapter, but we’ll be using character arrays more often than not.

Let’s now look at something that allows us to lock a value in stone, providing some sort of bedrock for functions to refer to and work.

Constants

A constant remains constant, i.e., any value that it is initialized with does not change during runtime. There are two ways to declare constants; by either using the keyword ‘const’ for it or using ‘#define.’

The first method, using the keyword ‘const,’ changes the variable's behavior, similar to how ‘unsigned’ works. The ‘const’ keyword serves to make the variable read-only and cause an error if there is code that tries to change the variable during compilation. An example is as follows:

const float pi = 3.14;

We often use ‘const’ to declare constants, though we might prefer to use the other method if memory is a concern.

The second method, using ‘#define,’ allows the user to name the constant for use before the code is fully compiled, allowing you to reduce the amount of memory (by skipping allocation of the name) that is required. This trick proves useful in micro-controller models with smaller memory sizes, such as Arduino Nano.

An important thing to keep in mind while using the latter method to declare a constant is if the name we’re using for it is used elsewhere. For example, some other array or variable or even another constant, the original constant’s name will be replaced by its value instead. A good idea to counteract this is to have completely uppercase names for constants and regular Camel Case for other names.

‘#define’ also does not need to use a semicolon to terminate its line, as follows:

#define LED_PIN 8

We’ve defined objects and initialized them with values. Let’s now look at how we can use these values and work with them, using basic arithmetic.

Arithmetic Functions

The four basic arithmetic processes, summation, subtraction, multiplication, and division, are allowed for by most if not all programming languages. Arduino provides operators - characters that when used in code refer to these arithmetic operations. These processes only work between operands of the same datatype; however, an int will not add to a float. We can create an exception to this rule using casting, which will be discussed in a short while. For now, let’s look at how to implement these basic functions:

z = x + y; // calculates the sum of x and y

z = x - y; // calculates the difference of x and y

z = x * y; // calculates the product of x and y

z = x / y; // calculates the quotient of x and y

Sometimes, we might only need the remainder of the division (in the case of integer operations), and we’ll use another tool for this, called the modulo operator ( ‘%’ ). An example of how this would work is as follows: when 5 is divided by 2, the result is 2.5. If we do not go into decimal places, this would instead return a remainder of 1. This value is the result of the modulo operation between these two numbers.

Another nifty syntax tool we can use is compound assignment operators, which combine the arithmetic operation with the assignment (or reassignment) operation of the variable. Here’s a list of these operators:

x++; // increments x by 1 and assigns the result to x

x--; // decrements x by 1 and assigns the result to x

x += y; //increments x by y and assigns the result to x

x -= y; //decrement x by y and assigns the result to x

x *= y; //multiplies x and y and assigns the result to x

x /= y; //divides x and y and assigns the result to x

Alongside both of these, full-fledged functions exist to help with performing common math operations and calculations. Here’s a list of those functions:

abs(x) // returns the absolute value of x

max(x,y) // returns the larger of the two values

min(x,y) //returns the smaller of the two values

pow(x,y) // returns the value of x raised to the power of y

sq(x) // returns the value of x squared

sqrt(x) // returns the square root of the value

Of particular note and usefulness, however, is the ability to compare values. Let’s continue and learn about operators that allow us to do so:

Comparison Operators

The Arduino language contains operator characters that allow us to make comparisons between two objects and return a Boolean value of either one or zero to confirm true or false, respectively. Here’s a list of those operators in use:

x == y // returns true if x is equal to y

x != y // returns true if x is not equal to y

x > y // returns true if x is greater than y

x < y // returns true if x is less than y

x >= y // returns true if x is greater or equal to y

x <= y // returns true if x is less than or equal to y

Let’s now look at logical operators, i.e., the operators for AND, OR, and NOT logical functions:

Logical Operators

‘AND,’ ‘OR,’ and ‘NOT’ are three operators that refer to their respective logical operations.  ‘AND’ checks whether both values (or the Boolean results of some comparison statement) is true and returns true,  ‘OR’ checks for either value of the previous case and returns true, and ‘NOT’ returns the opposite Boolean state of the value provided. Examples of these in action are provided below:

(x > 5 && x < 10) // true if x is greater than 5 and less than 10

(x > 5 || x < 1) // true if x is greater than 5 or less than 1

!(x == y) // returns true if x is not equal to y

Let’s now look at what we referred to previously as casting.

Casting

The cast operator changes the datatype of a variable to a different one, allowing it to be used where there’s a restriction of datatypes, like for arrays and arithmetic operations. Values converted via this operation are truncated to the relative decimal instead of being properly rounded up or down. For example, 8.7 being truncated to 8 instead of being rounded to 9. Thus, it is good to cast integers to float values instead of the other way around.

Casting is done by adding parentheses before the variable to be casted and writing the required datatype in it. An example:

int x = 5;

float y = 3.14;

float z = (float)x + y;

We need our program to make logical decisions as there’s not a lot one can do without some sort of logic behind it. Since we’ve learned how to compare values and draw some logical conclusion, let’s move on to using these tools and code in decision-making capabilities.

Decision Making

Decisions are often a matter of whether something will happen or not. Most programming languages, Arduino included, include an ‘if’ statement to that end. This function will check a statement inside a pair of parentheses, and if it is true(i.e., the Boolean statement returns a ‘TRUE’ Boolean value), it will run code placed inside curly brackets, as follows:

if (condition) {

// Code to execute

}

We can also use an ‘else’ statement when the conditional statement being checked returns false. The syntax is as follows:

if (condition) {

// Code to execute if condition is true

} else {

// Code to execute if condition is false

}

The else statement can also check a new statement and run if it returns a ‘TRUE’ Boolean value. Note that only the first block of code for which the respective statement returns true will execute, and the rest of the else statements will be ignored. The following code compares two variables, and the results of that comparison allows the ’if-else’ statements to function:

if (varA == varB) {

Serial.println("varA is equal to varB");

} else if (varA > varB) {

Serial.println("varA is greater than varB");

} else {

Serial.println("varB is greater than varA");

}

‘If-else' statements can get messy and expansive fairly fast, relative to how many statements we’d need to check. We use ‘switch/case' statements when we have multiple conditions (more than two or three).

‘switch/case’ statements take in a value inside parentheses (here ‘var’) and go down the list of cases, comparing the cases' value. If it finds a match, the statement inside the case runs. After its execution, we use ‘break’ to break the switch loop. If there is no match, a default case runs and then uses ‘break’ to end execution. The syntax for it is as follows:

switch (var) {

case match1:

// Code to execute if condition matches case

break;

case match2:

// Code to execute if condition matches case

break;

case match3:

// Code to execute if condition matches case

break;

default:

// Code to execute if condition matches case

}

We often need to have code repeating during runtime so that it functions continuously. We use loop structures for this. Let’s look at how to make loops now:

Looping

There are three kinds of loops: ‘for,’ ‘while’ and ‘do/while.’ These work in slightly different ways. Let’s start by looking at ‘for’ loops.

The ‘for’ loop continuously repeats a block of code a specific number of times. This number is assigned to a variable that continuously changes per iteration of the loop which can also be used to access particular indexes of matrices.

There are three parts of a ‘for‘ loop’s statement: initialization, condition, and increment.

for (initialization; condition; change) { }

- The initialization creates a variable that the loop uses and increments (or decrements). We can initialize other variables here too, but we’d advise you to keep your code lean and only initialize variables that the loop uses.

- The condition checks the current state of the loop variable against some conditions. As long as it returns true, the code continues.

- The increment changes and updates the current state of the loop variable.

An example of a ‘for’ loop in action is as follows. The statement is set up such that the loop increments a newly initialized variable i, causing the loop to re-execute ten times:

for (int i = 0; i < 10; i++) {

// Code to execute

}

The ‘while’ loop checks whether a statement is true or not and continues running while it returns a Boolean true. Care must be taken with this statement that the condition doesn’t infinitely return true, implying an infinitely repeating loop. The syntax for this loop is as follows:

while (condition) {

// code to execute

}

An example of this loop in action would be as follows. Good practices implore you to have the conditional be a comparison statement:

int x = 0;

while (x < 200) {

// code to execute

x++;

}

The ‘while’ loop checks the condition before execution. If we want it to be executed at least once, we’ll use a ‘do/while’ loop . This means that in the loop the condition is checked after the block of code is run. The syntax to follow is like so:

do {

// code to execute

} while (condition);

Similar to the previous, it would be a good idea to use a comparison statement as a condition. An example of this loop is as follows:

int x = 0;

do {

// code to execute

x++;

} while (x < 200);

Functions

Functions are blocks of code that perform a specific task. They are given unique names to identify them and called when needed. Programming libraries often have hundreds if not thousands of pre-defined functions, and we can create our own if we need to, as follows:

type name (parameters) { }

The declaration of a function requires us to start with defining what datatype it will return. If it will not return a value, this function has a ‘void’ datatype. Moving on to naming it, use a name that describes what it does or when it activates, such as ‘ledRedOn’ or ‘onRedCall,’ following Camel Case.

Next, a pair of parentheses encase the parameters that we need the function to require and use, to control its functionality. These parameters are passed to and used by the function within its logic to return an answer respective to the parameters. Multiple parameters can be added by separating them using commas.

A pair of curly brackets come next, and within them, we write the code block for the function to define its behavior.

A few examples of function syntaxes are as follows:

void myFunction() {

// Function code

}

void myFunction(int param) {

// Function code

}

int myFunction() {

// Function code

}

int myFunction(int param) {

// Function Code

}

- The first function does not return anything, and therefore of a void datatype, nor does it require. We use this kind of function when we do not need it to return a value or pass a parameter to it; it is entirely self-sufficient.

- The second function takes in an integer datatype parameter for its code block to use.

- The third function can return an integer datatype value but does not require a parameter to be inserted.

- The fourth combines the second and third kinds of functions and their respective functionalities.

To return a value from a function, we use the keyword ‘return.’ Let’s look at a simple example of a function:

int myFunction() {

var x = 1;

var y = 2;

return x + y;

}

Any variables that are initialized in the function are only usable in that domain, and cannot be called by anything outside of it (this also means that variables with the same names can exist uniquely inside different functions, outside of each other’s reach). The following code block demonstrates this:

int g = 1;

void function myFunction1() {

int x1 = 2;

}

void function myFunction2() {

int x2 = 3;

}

The variable ‘g’ is accessible globally, i.e., by both functions, but ‘x1’ and ‘x2’ can only be accessed by their respective functions, not outside of these domains.

Chapter 3

The Advanced Concepts of

Arduino Programming

Let’s now take the fundamental structures and syntaxes we’ve learned in the previous chapter and apply them to make some more complex Arduino-specific code structures. Do not be disheartened if coding doesn’t come to you immediately; practice does make perfect, and you still have plenty of chapters to go through still.

This chapter will go through the following topics:

- Setting the pin mode of an Arduino digital pin.

- Sending and receiving values to and from an Arduino digital pin.

- Sending and receiving values to and from an Arduino digital pin.

- Structures , unions , and how to use them.

- Adding tabs to the IDE Client/Web Editor

- Classes , objects , and how to use those structures.

Setting Digital Pin Mode

In previous sections, we learned that an Arduino micro-controller board has a set of digital pins, that receive or send digital data (i.e., zeros and ones). These can only work when they’re assigned the ability to either send or receive data. This is done by using the ‘pinMode()’ function. For basic examples like ours and smaller sketches, this function is called during ‘setup()’ execution, though do keep in mind that this is a function that can be called anywhere you wish.

The syntax for this function defines two parameters: ‘pin’ is the number of the pin being set and ‘mode’ being the setting of this pin, which can be given the argument ‘INPUT’ or ‘OUTPUT’ to read or send values from that pin.

pinMode(pin, mode);

pinMode( 11 , INPUT);

pinMode( 12 , OUTPUT);

A good habit is to never use a number directly as an argument to the ‘pin’ parameter and instead assign the value to a variable to be called for that parameter. This helps in keeping a value constant and stopping accidental errors. You may also use ‘#define’ to the same end.

An example of this function in action is as follows:

#define BUTTON_ONE 12

#define LED_ONE 11

void setup() {

pinMode(BUTTON_ONE, INPUT);

pinMode(LED_ONE, OUTPUT);

}

This code assigns ‘#define’constants BUTTON_ONE and LED_ONE to digital pins 12 and 11, respectively, and then sets the pins so that BUTTON_ONE receives an input and LED_ONE produces an output.

We can also use ‘pinMode()’ to change the pin’s pull-up resistor's functionality by passing the argument ‘INPUT_PULLUP’ to the mode parameter. This inverts whatever input it receives.

Let’s look at how to use these pins and their settings:

Digital Write

The function ‘digitalWrite()’ allows us to send a digital value onto the micro-controller’s digital pin, which then can be read by some other LED or sensor or electrical device. The syntax for it is as follows:

digitalWrite(pin, value);

The ‘pin’ parameter defines the pin to be used, while the ‘value’ parameter is used to assign what value the pin should put out. This can be either HIGH or LOW (or Boolean and binary equivalents), such as follows:

digitalWrite(LED_ONE, HIGH);

delay(500);

digitalWrite(LED_ONE, LOW);

delay(500);

This code makes the pin (defined by the variable LED_ONE) put out a high voltage, wait a period of 500 milliseconds, change the pin so that it produces a low voltage, and waits a period of 500 milliseconds again (using the ‘delay()’ function). Let’s look at a fuller version of this code block:

#define LED_ONE 11

void setup() {

pinMode(LED_ONE, OUTPUT);

}

void loop() {

digitalWrite(LED_ONE, HIGH);

delay(500);

digitalWrite(LED_ONE, LOW);

delay(500);

}

This sets up pin 11 to send voltage from the board’s pin, as defined by the constant’s value and then continues looping the rest of the functionality discussed above.

Digital Read

The function ‘digitalRead()’ allows us to read what binary value is being provided to a particular digital pin. This function's syntax consists of only one parameter - the ‘pin,’ to define what pin to look at. Take heed of the fact that this function returns an integer value, instead of a Boolean one, though these values (0 and 1) are mutually interchangeable:

digitalRead(pin);

//a fuller example:

int val = digitalRead(BUTTON_ONE);

Let’s again look at a more practical example of this function in use, that reads the status of a button:

#define BUTTON_ONE 12

void setup() {

Serial.begin(9600);

pinMode(BUTTON_ONE, INPUT);

}

void loop() {

int val = digitalRead(BUTTON_ONE);

if (val == HIGH) {

Serial.println("Button HIGH");

} else {

Serial.println("Button LOW");

}

}

This code sets a ‘#define’ constant BUTTON_ONE to 12, which is used to point out the pin that is set to receive inputs via ‘pinMode().’ The loop reads the current value being sent to that pin via the button’s state and tells it to print out the respective statements for the respective conditions onto the Serial Monitor.

So far we’ve seen how to use digital pins to communicate digital data. This can easily prove to limit, so we can also use analog pins to communicate analog-form, continuous data. These pins work using Pulse Width Modulation (PWM), and the pins for these, for most Arduino boards, are pins 3, 5, 6, 9, 10, and 11. Let’s look at the functions for these analogous (no pun intended) to the digital read and write functions:

Analog Write

The function ‘analogWrite()’ allows us to write an analog value that is sent to a pin using Pulse Width Modulation, which, in short, produces a percentage of the maximum value that is given at digital 1. The syntax for this function is:

analogWrite(pin, value);

‘pin’ specifies what pin the analog value should be written on, and ‘value’ tells it the value that it is supposed to write. This value ranges from 0 to 255 (dividing the maximum value into 255 steps between the low and high states)

The following code describes how we’d use analogWrite() to make an LED glow gradually from being off to being brightly lit:

#define LED_ONE 11

int val = 0;

int change = 5;

void setup()

{

pinMode(LED_ONE, OUTPUT);

}

void loop()

{

val += change;

if (val > 250 || val < 5) {

change *= -1;

}

analogWrite(LED_ONE, val);

delay(100);

}

The ‘#define’ constant specifies the number 11, which is used to identify what pin is to be written on (and whether it’s to be written on) in ‘pinMode().’ Two variables are also declared globally, which are ‘val’ and ‘change.’ This stores the current value being sent to the pin and whether it should be changed to increment in the opposite direction according to the conditional in the sketch’s loop. A short delay is added before the loop is to repeat.

Analog Read

The function ‘analogRead()’ allows us to read a voltage in an analog way, such that every step between zero and five volts is accounted for in some manner. The value that this function returns is an integer between 0 and 1023, meaning 1023 steps divide 5V into increments of 0.0049V. Similar to the syntax of digitalRead(),’ ‘analogRead()’ only needs to be provided the number of the pin it’s supposed to read. The syntax for this function is as follows:

analogRead(pin);

Let’s look at an example of this being used to determine the temperature reported by a TMP36 temperature sensor:

#define TEMP_PIN 5

void setup() {

Serial.begin(9600);

}

void loop() {

int pinValue = analogRead(TEMP_PIN);

double voltage = pinValue * 0.0049;

double tempC = (voltage - .5) * 100.0;

double tempF = (tempC * 1.8) + 32;

Serial.print(tempC);

Serial.print(" - ");

Serial.println(tempF);

delay(2000);

}

After pin 5 is defined as the pin to be used and read, the loop reads the current value the pin is receiving. It converts it to the temperature being measured via arithmetic operations (in both Celsius and Fahrenheit), and prints this to the Serial Monitor. A two-second delay is added between loop iterations.

These functions will be mainstays in our coding examples and practice. Let’s now look at code constructs to store multiple objects in a defined way. We call these constructs Structures .

Structures

A structure is a composite, user-defined datatype that can store multiple variables of varying datatypes. The syntax for defining this construction is as follows:

struct name {

variable list

.

.

};

The ‘struct’ keyword precedes the name of the structure. A pair of curly brackets stores the list of variables that we’ll keep in the structure.

In the previous section’s sketch, we used three different variables (of the same datatype ‘double’) to define different things. Let’s try grouping them together using a structure, and name it ‘temp_reading.’ Note again that these datatypes do not need to be the same:

struct temp_reading {

double voltage;

double tempC;

double tempF;

};

Creating and using a structure object is simple, though it is a step up from defining integer values to variables. We need to use the ‘struct’ keyword and the structure's name as the datatype for initializing the value. The syntax for our particular example is as follows:

struct tmp36_reading temp;

Assigning or reading values stored in the structure’s list of variables is done as follows:

temp.voltage = pinValue * 0.0049;

temp.tempC = (temp.voltage - .5) * 100.0;

temp.tempF = (temp.tempC * 1.8) + 32;

Let’s now modify our original code so that it uses a structure and define a function that takes this function as an argument parameter:

#define TEMP_PIN 5

struct tmp36_reading {

double voltage;

double tempC;

double tempF;

};

void setup() {

Serial.begin(9600);

}

void loop() {

struct tmp36_reading temp;

int pinValue = analogRead(TEMP_PIN);

temp.voltage = pinValue * 0.0049;

temp.tempC = (temp.voltage - .5) * 100.0;

temp.tempF = (temp.tempC * 1.8) + 32;

showTemp(temp);

delay(2000);

}

void showTemp(struct tmp36_reading temp) {

Serial.print(temp.tempC);

Serial.print(" - ");

Serial.println(temp.tempF);

}

Note the inclusion of the structure globally and a function at the end that prints the variables inside the structure passed to it.

A structure is a good way to cut down clutter and group data, and it is a good idea to use them to store a group of variables that contribute to closely related actions. Another example of these groupings is as follows: the difference between these being that only one of its variables can store a value at any given time. These are called Unions .

Unions

This datatype allows us to store different variables of different datatypes, similar to how structures function. However, where they diverge is in the fact that only one of these variables is allowed to store data at a given instance. The syntax for this construction is as follows. The only difference between the structure’s syntax and union is the keyword:

union name {

variable list

.

.

};

Let’s look at an example of a union. We’ll create a new union (with the name ‘some_data’) with a list of variables it can store:

union some_data {

int i;

double d;

char s[20];

};

Now, we’ll have a look at how its unique functionality works:

union some_data {

int i;

double d;

char s[20];

};

void setup() {

Serial.begin(9600);

union some_data myData;

myData.i = 42;

myData.d = 3.14;

strcpy( myData.s, "Arduino");

Serial.println(myData.s);

Serial.println(myData.d);

Serial.println(myData.i);

}

This code creates a union (the same as before) and initializes an object, named myData. It passes data into its variables, though printing these out onto the Serial Monitor yields the realization that only the last variable in the union declared is allowed to show its actual value.

‘some_data’ will only store one value at a time, shifting from the 20 of int ‘i,’ to the 3.14 of the double ‘d,’ to finally the character array storing the value ‘Arduino’ (and its null terminator).

Before we proceed, it would be prudent to familiarize ourselves with a useful feature of the IDE Client/Web Editor; tabs.

Adding Tabs

Tabs allow you to structure your workplace into different sections, allowing you to divide and conquer the task at hand and also reducing your frame of focus. Let's look at how we might add tabs:

Click on the button at the IDE's top-right, with an upside-down triangle icon, like so:

In the drop-down menu that appears, press the New Tab option, and an orange bar will show up allowing you to name this new tab. Press the OK key to continue with this name and creating the tab.

After you press OK , the new tab appears:

Adding new tabs in the Web Editor is pretty much the same procedure. Click the upside-down triangle to get a drop-down menu, click New Tab , put your preferred name for the tab into the space in the yellow bar, press OK , and Voila! Your tab has been created.

A short note about how one might actually divide the code to distribute them into tabs. For large programs, keep the main ‘setup()’ and ‘loop()’ functions in one tab, and have related functions and objects grouped into one tab’s worth of functional table-space. Add constants globally, allowing them to be used by multiple tabs at the same time, by including them in a header file, which contains declarations and definitions to be used outside it. Let’s continue.

Working with Tabs

When we make a new tab to work with (or want to do so), the first decision is to figure out what to do with it. Let’s continue our example code and create new tabs - ‘led’ to store functionality and ‘led.h’ to store constants.

Put the following block of code into the ‘led.h’ tab:

#ifndef LED_H

#define LED_H

#define LED_ONE 3

#define LED_TWO 11

#endif

This code defines ‘LED_ONE’ and ‘LED_TWO,’ and ensures this data is transferred to each tab only once. This is done via ‘#ifndef’ and ‘#endif’. The former looks at whether ‘LED_H’ is defined and allows the rest of the code (before ‘#endif’) to run if it is not.

Once we are done dealing with the preprocessors, we can now proceed to insert actual instructions to be executed by the compiler. These lines of code are to be inserted in the tab named ‘led .’

void blink_led(int led) {

digitalWrite(led, HIGH);

delay(500);

digitalWrite(led, LOW);

delay(500);

}

If we analyze this small portion of code, we will see that the ‘void ’ function includes a series of parameters that control the LED’s blinking by defining the intervals (each interval has a 500ms delay).

In the main tab, write the following to include the header file that we defined into the sketch, using ‘#include’. Trying to refer to our constants without using this line produces an error: “the constant was not declared in this scope”, meaning that the compiler could not found the constant.

#include "led.h"

Header files that we write from the sketch are surrounded by double-quotes, while header files from some other library are surrounded by less-than and greater-than signs. This will become useful later.

Finally, we use the function that we defined in the ‘led ’ tab previously and use it in our program’s loop. Also, you will see that in this demonstration, we did not use the ‘#include’ preprocessor, this is because the tab we are using does not have any header in the first place.

#include "led.h"

void setup() {

// put your setup code here, to run once:

pinMode(LED_ONE, OUTPUT);

pinMode(LED_TWO, OUTPUT);

}

void loop() {

// put your main code here, to run repeatedly:

blink_led(LED_ONE);

delay(1000);

blink_led(LED_TWO);

}

At this point, we are now ready to take this program and execute it on our Arduino project and see the results.

Object-Oriented Programming

Object-Oriented Programming, or OOP for short, is a methodology of coding practices that aims to break down a program into modular component objects that interact with one another to create its functionality. An example would be an LED object, containing variables and such to define how we want it to work. But we need a structure or blueprint of sorts to add these variables to, which is where classes come in.

Create two tabs and name them ‘led.cpp’ and ‘led.h.’ The former will contain the main body of code, while the latter will contain definitions and initializations, but also importantly the definition of our class. Add the following to ‘led.h’:

#ifndef LED_H

#define LED_H

#define LED_ONE 3

#define LED_TWO 11

class Led{

int ledPin;

long onTime;

long offTime;

public:

Led(int pin, long on, long off);

void blinkLed();

void turnOn();

void turnOff();

};

#endif

This code is similar to what we used in the previous section’s header file. The key difference is the addition of a class definition, containing three variables (or ‘properties’) inside it. In order of appearance, these variables define what pin to send data to, how long to keep the LED on, and how long it should stay off.

Next, we use a constructor to make a class instance, and after that three functions (or methods) are initialized.

Now, add the following block of code to ‘led.cpp,’ to give it functionality:

#include "led.h"

#include "Arduino.h"

Led::Led(int pin, long on, long off) {

ledPin = pin;

pinMode(ledPin, OUTPUT);

onTime = on;

offTime = off;

}

void Led::turnOn() {

digitalWrite(ledPin, HIGH);

}

void Led::turnOff(){

digitalWrite(ledPin, LOW);

}

void Led::blinkLed() {

this->turnOn();

delay(onTime);

this->turnOff();

delay(offTime);

}

We import two header files: ‘Arduino.h’ and our own ‘led.h’ into the code's main body. ‘Arduino.h’ contains all the libraries and their functions that Arduino has. It is usually automatically called, but this is not the case for different tabs, and we need to re-initialize this header file for our new environment.

Next up is the class constructor which is required to create a method for initializing a class. The syntax for it is to, one, name the constructor the same as the class, and two, separate these names via a pair of colons ( :: ). This class contains the pin and a call to the pinMode function.

Led::turnOn() and Led::turnOff() turn the LED on or off using digitalWrite(), and we’ll use these to define how blink_Led() works. Note that we call functions and methods of a class using ‘->’ operators, and use the keyword ‘this’ to specify the current instance.

Let’s now go back to the main tab and put all of this together:

Add the ‘#include’ line to include our header’s functionality, after which you should create a globally accessible ‘Led’ class object, whose variables we’re passing into the class constructor:

#include "led.h"

Led led(LED_ONE, 1000, 500);

Use the class method to blink the LED (syntaxed as ‘Led.blinkLed()’ ) in the main tab as follows:

#include "led.h"

Led led(LED_ONE, 1000, 500);

void setup() {

}

void loop() {

led.blinkLed();

}

Uploading this code onto our previous prototype will make our LED blink.

Let’s now discuss strings, objects made of character arrays, and Arduino’s libraries for using them:

String Library

One of Arduino’s basic libraries, this library allows us to work with character arrays in an extremely user-friendly manner. Strings are more flexible than these arrays, and allow us to work with text in a much easier and more intuitive fashion, though it does take more memory than them.

We can create a string object in a variety of ways:

String str1 = "Arduino";

String str2 = String("Arduino");

String str3 = String('B');

String str4 = String(str2 + " is Cool");

The first and second lines simply create strings that contain the word ‘Arduino.’ The third line creates a string with one character ‘B,’ and uses a pair of single colons to do so. The fourth line concatenates two strings, combining them at their ends into one new string.

We can also create strings from numbers, which is allowed for by pre-built constructors. A few examples of this are as follows:

String strNum1 = String(42); \\ returns a string ‘42’

String strNum2 = String(42, HEX); \\ returns a string ‘2a’

String strNum3 = String(42, BIN); \\ returns a string ‘101010’

Other functionalities in the string library include:

- concat(string), concatenates one string to the prior string’s end

- endsWith(string):  A Boolean conditional that returns true if the first string's end is the same as the argument string.

- equals(): returns true if both strings are the same.

- equalsIgnoreCase(): returns true if both strings are the same, ignoring lower- or upper-case differences

- length(): provides an integer value of the number of characters inside the string (without the null character).

- replace(substring1, substring2): replaces all instances of the first argument with the second argument.

- startsWith(string): A Boolean conditional that returns true if the first string's beginning is the same as the argument string.

- toUpperCase(): converts a string fully to uppercase, where possible.

- toLowerCase(): converts a string fully to lowercase, where possible.

Strings can be used in place of character arrays when needed, but be mindful of the fact that it requires more memory and time to execute. More often than not, this constraint is the only reason why character arrays are used for storing text instead of strings.

Arduino Motion Sensor Project

We shall learn, in this section, the process, and techniques for integrating a motion sensor with Arduino hardware. To do so, we shall use a pre-built motion sensor named HC-SR501. Owing to its simplicity of use, reasonable price range, and practical, flexible purpose, it is often one of the first tools that people use with Arduino (and the program) to test and develop an understanding of micro-controllers. It is often included in Arduino starter packages. We will learn how to:

- Attach the sensor to the Arduino.

- Read the output of the sensor.

- Create and read a Fritzing diagram of a completed build.

Introduction

Most common motion sensors will use infrared light to track whether something’s passed in their vicinity. These sensors, termed Passive Infrared Sensors (PIR Sensors), detect motion in a small range around them (usually up to two meters for simpler sensors, but industrial and military models with a larger range and higher accuracy exist). These are made of pyroelectric sensors which can read radiation (emitted by every object with a temperature higher than absolute zero) in the infrared range passively. This means that it can only read this information and not generate anything that other devices can work off of.

The pyroelectric sensor is divided into two halves. If there is no motion, both halves report the same amount of radiation and nothing happens, but if there is motion (within the sensor’s range) the halves detect different amounts of radiation, and this dissonance causes the sensor to go off.

These sensors are available in a wide variety of constructions, shapes, sizes, and purpose-built configurations, due to their small size and power draw, and inexpensive nature. A few examples of products that use PIR sensors include automatic lights, holiday decorations, pest control setups, burglar alarms, and tripwires.

As we previously mentioned, we shall be using a motion sensor IC called HC-SR501. The following image shows the various adjustment screws and connectors on the body of the IC.

We’ll explain what these screws and pins do, briefly. Screws act as analog switches, able to change values in a continuous range manually from the IC body itself, and different screws change different function variables. Pins allow current to flow to and from the IC, allowing communication with the Arduino motherboard. Let’s elaborate on the labeled screws and pins and what they do.

- Sensitivity: Changes the range at which the sensor is effective, from 3 meters to 7 meters. This value goes down with the clockwise rotation of the screw.

- Output Timing: Changes the delay or period wherein the sensor puts out a Boolean true state (a ‘high’ or ‘1’ state), from 5 seconds to 300 seconds (5 minutes). This value goes up from the lower end with the clockwise rotation of the screw.

- Ground: Connect to the Ground of your connection (breadboard ground rail, Arduino Ground pin, source ground, etc.)

- 5V: Connect to the Live of your power source, preferably a 5V voltage (breadboard power rail, Arduino 5V pin, source power, etc.)

- Output: Connect this to the relevant Arduino pin of your choosing. This sends out the IC output to the other ends of the wire (i.e., the micro-controller) for the period specified via the Output Timing screw.

Let’s continue onwards and build a circuit using this sensor.

Components

For our circuit we shall require the components listed:

- Arduino Uno (or similar)

- HC-SR501 Motion Sensor

- Jumper Wires

- Optional: LED

- Optional: Breadboard

Circuit Diagram

The Fritzing diagram for our build-to-be is as follows:

Notice the connections with the HC-SR501 IC’s power pins. The Ground pin is connected to the breadboard’s ground rail, the 5V ping is connected to the power rail, and the output pin is connected to a digital input pin on the Arduino, whose respective Ground and 5V pins are also connected to the breadboard as described. The circuit schematic for this setup is as follows:

Code

Using the HC-SR501 sensor with Arduino is fairly simple; we only need to read its digital state. A HIGH state indicates the sensor has ‘seen’ something (this signal, again, lasts for however long we specified via the analog screw, which we’ll usually keep within the range of a few seconds), and a LOW state indicates that it hasn’t seen anything yet. We’ll send forth this status to the serial console, as follows:

#define MOTION_SENSOR 3

void setup() {

pinMode(MOTION_SENSOR, INPUT);

Serial.begin(9600);

}

void loop() {

int sensorValue = digitalRead(MOTION_SENSOR);

if (sensorValue == HIGH) {

Serial.println("Motion Detected");

}

delay(500);

}

We use #define to create a MOTION_SENSOR variable that will read the state of pin 3 (set via pinmode()). We’ll also set up the serial console via setup().

The main loop (i.e., loop() ) operates as follows: digitalRead() is called to read the sensor output on pin 3, and sensorValue takes up this value. When it is HIGH, a message (‘Motion Detected’) is printed in the serial console. When it is LOW, nothing happens. A 0.5 second delay later, the loop restarts.

Running the Project

Have the console open while the code runs to see the output, and wave something in front of the sensor which would then make the Serial Console print out the message.

Challenge

Try adding an LED that lights up when the sensor goes HIGH. Remember to add a resistor to the circuit. The following code lights up an LED connected to pin 5 when the condition is met:

#define MOTION_SENSOR 3

#define LED 5

void setup() {

pinMode(MOTION_SENSOR, INPUT);

pinMode(LED, OUTPUT);

digitalWrite(LED, LOW);

Serial.begin(9600);

}

void loop() {

int sensorValue = digitalRead(MOTION_SENSOR);

if (sensorValue == HIGH) {

Serial.println("Motion Detected");

}

digitalWrite(LED, sensorValue);

delay(500);

}

Arduino LCD Display Project

Components required

- 1 Arduino Uno or compatible board One Nokia 5110 LCD

- 1 K Ω resistor (one)

- 10 K Ω resistors (four)

- One breadboard

- Jumper wires

Circuit Diagrams

The diagram shown below demonstrates the circuit diagram needed for this topic’s project:

Instead of the 5V that we have used in the prior projects, the Nokia 5110 LCD should utilize the Arduino's 3.3V power. The 3.3V input lines on the LCD are protected by utilizing the inline resistors. A 1K Ω (ohm) resistor is utilized by the CE lines and the 10K Ω resistor by the rest.

The table below tells that what pins on the Nokia 5110 LCD module are joined to what pins on Arduino:

Arduino

5110 LCD

3

RST

4

CE

5

DC

11

DIN

13

CLK

3.3V out

VCC

GND

BL

GND

GND

To turn it off, the back-light is set to the ground. The 3.3V power out that was utilized for the VCC pin, you can join the pin to it if you want to utilize the back-light.

Now let’s have a look at how we can show things on the LCD:

Code

We should install two Adafruit libraries, to begin with. The two libraries are as follows:

- The Adafruit GFX Library

- The Adafruit PCD8544 Nokia 5110 LCD Library.

The Above mentioned libraries are installed because we need them and the SPI library. To do this, the below-written include statements are added at the start of the sketch:

#include <SPI.h>

#include < Adafruit_GFX.h>

#include < Adafruit_PCD8544.h>

We won’t wish to begin an instance of the type i.e., the Adafruit_PCD8544 by utilizing the code written below:

Adafruit_PCD8544 display = Adafruit_PCD8544(13, 11, 5, 4, 3);

The CLK, DIN, DC, CE, and RST pins respectively are connected to the Arduino pin numbers that are basically the parameters.

To set up the Adafruit_PCD8544 instance, we should add the below-written code in the setup ( ) function:

Serial.begin(9600);

display.begin();

display.setContrast(40);

Now the remaining piece of code can be written in the setup ( ) function or in the loop ( ) for the test purposes. Let us begin with lighting up only one pixel on the display. We can do this by using the function drawPixel ( ) as shown in the piece of code below:

display.clearDisplay();

display.drawPixel(10, 10, BLACK);

display.display();

We need to clear the buffer and the display before we draw something on the screen. This is done by using the function clearDisplay ( ). After this, to light up only one pixel that is located at X coordinate 10 and Y coordinate 10, we use the function drawPixel ( ). As mentioned in the previous code we should run the display ( ) function before anything is shown on the LCD. This is very important to keep in mind to run the function clearDisplay ( ) prior to drawing anything on the LCD, and once we are done drawing everything on the LCD screen to display it, we should run the display ( ) function.

Drawing a line

Instead of calling the drawPixel ( ) function several times to draw a line, it would be much simpler to call the function drawLine ( ) as shown in the code below:

// draw a line

display.drawLine(3,3,30,30, BLACK);

display.display();

The function drawLine ( ) accepts 5 parameters. The first and second parameters are the X and Y coordinates for the beginning point of the line. The third and fourth parameters are the X and Y coordinates for the ending point of the line. The last and fifth parameter shows the color with which the line will be drawn. In this case, only two colors i.e., Black and White are available as the display of Nokia 5110 LCD is monochromatic.

Displaying Text

The Adafruit library additionally makes it a lot simpler to show the text on Nokia 5110 LCD. We can display the text by using the following code:

// Display text

display.setTextSize(1);

display.setTextColor(BLACK);

display.setCursor(0,0);

display.println("Hello, world!");

// Display Reverse Text

display.setTextColor(WHITE, BLACK);

display.println(3.14);

// Display Larger Text

display.setTextSize(2);

display.setTextColor(BLACK);

display.print("This is larger text");

display.display();

To set the size of the text, the function setTextSize ( ) is used. We can see in the first example that the size of the text is set to ‘1.’ The color of the text is set by using the setTextColor ( ) function. As we know that the display of Nokia 5110 LCD has a monochromatic so only two colors i.e., Black and White are available. To write the text on the screen, the position of the cursor is set to the position on the screen by using the setCursor ( ) function. For this example, the position of the cursor is set to the upper left corner of the screen. At last, the message i.e., Hello World! is displayed on the screen by using the function println ( ).

In the next example of the above code, the foreground color is set to WHITE and the background color is set to BLACK to reverse the text by using the setTextColor ( ) function. Afterward, to display the value of PI on the screen the println ( ) function is used. As the setTextSize ( ) function is not called so the text size stays the same i.e., ‘1.’

In the third example of the code above, the text's size is set to ‘2’ and the color is set to ‘BLACK.’

Rotating Text

The text can also be rotated. This can be done by the following code:

display.setRotation(1);

display.setTextSize(1);

display.setTextColor(BLACK);

display.setCursor(0,0);

display.println("Hello, world!");

display.display();

The text can be rotated counterclockwise using the function setRotation ( ). To rotate the text 90 degrees counterclockwise we can use the value ‘1.’ Similarly, to rotate the text to 180 and 270 degrees counterclockwise we can use the values ‘2’ and ‘3,’ respectively. The following image display the text when the code written above is run:

Note that if the text's length is longer than the limit of what can be displayed on a single line of the screen, the text will move to the next line.

Basic Shapes

The Adafruit library additionally makes it possible for us to make basic shapes on the LCD. These shapes are rectangles, rounded rectangles, and circles. There also exist different functions that allow us to make and fill these shapes. The below-written code and images tell us the best way to utilize the functions of a circle:

display.drawCircle(display.width()/2, display.height()/2, 6, BLACK);

Filled Shape

display.fillCircle(display.width()/2, display.height()/2, 6, BLACK);

Four parameters are required in the circle function. The first and second parameters, the X and Y coordinates, are for the circle's center. In the above-written codes, the center of the screen is considered as the center of the circle. The radius of the circle is the third parameter. And the last and the fourth parameter of the circle function is the color of the circle. This parameter is also considered as the color to fill the circle for the function fillCircle ( ).

Rectangle

In this section, we will look at codes that correspond to displaying different types of rectangles. For instance, we will see how to display a rectangle that is internally filled with pixels, a rectangle whose corners are smoothly rounded off instead of being sharp and pointed, and finally, a rounded corner rectangle that is internally filled with pixels.

To display a standard rectangle, we use the following code

display.drawRect(15,15,30,15,BLACK);

Filled Rectangle

To display a rectangle that is filled on the inside, we use the following code.

display.fillRect(15,15,30,15,BLACK);

Rounded Rectangle

We use the ‘drawRoundRect()’ function from the ‘display’ class and pass it a total of five parameters for drawing a rounded rectangle. The first and second parameters are the X and Y coordinates of the rectangle's upper left corner. The third and fourth parameters are the X and Y coordinates of the rectangle's lower right corner. The fifth parameter shows the color to draw the rectangle. This last parameter is also used to fill the rectangle with the respective color by using the fillRect ( ) function.

To display a rectangle that has rounded corners, we use the following code.

display.drawRoundRect(15,15,30,15,4,BLACK);

Filled Rounded Rectangles

display.fillRoundRect(15,15,30,15,8,BLACK);

In this +case, there are a few minor changes, we just need to include an extra parameter to tell the code to fill in the internals of the rounded rectangle and use the ‘fillRoundRect() ’ function instead of the ‘drawRoundRect() ’ function. The initial four parameters are similar to those of the normal rectangle functions, the two of which are the upper left corner coordinates. The other two are the coordinates of the lower right corners of the rectangle. The fifth parameter tells how much to round the rectangle’s corners and the last and sixth parameter shows the color to draw and fill the rounded rectangle.

The examples of this chapter show that with the Nokia 5110 LCD we can do much more than text. And the Arduino library makes it simple to utilize.

Chapter 4

Structuring and Arduino Programming

This chapter will focus a bit more on Arduino programming and structuring the sketches we build.

Structuring and Arduino Program

Arduino programs are normally alluded to as sketches, to underline the agile nature of advancement. The words program and sketch are compatible. Sketches have code – the guidelines the board will complete. Code required to run just a single time (for example, to set up the board for your application) should be kept in the setup function. While the code which has to be run consistently after the first step has completed goes into the loop function. Below shown is a regular sketch:

const int ledPin = 13; // LED connected to digital pin 13

// The setup() method runs once when the sketch starts

void setup()

{ pinMode(ledPin, OUTPUT); // initialize the digital pin as an output

}

// the loop() method runs over and over again,

void loop()

{

digitalWrite(ledPin, HIGH); // turn the LED on

delay(1000); // wait a second

digitalWrite(ledPin, LOW); // turn the LED off

delay(1000); // wait a second

}

Once the sketch program's transfer from the PC to the Arduino board is completed, the board begins from the start of the sketch and completes the directions consecutively. It also does the same when the board has the code and is turned on. It executes the code once in the setup function and afterward executes it in a loop. When it gets to the end limit of the loop (set apart by the closing bracket,}) it returns to the start of the loop.

This example persistently flashes a LED by composing HIGH and LOW yields to a pin. Refer to Chapter 5 to become familiar with utilizing Arduino pins. When the sketch starts, the code in setup sets the pin mode (so it’s equipped for lighting a LED). When the code's execution in setup is finished, the code in the loop is consistently executed to flash the LED until the Arduino board is switched on.

You don’t have to realize this to compose Arduino sketches, yet expert C and C++ developers may ponder where the expected main ( ) function (which is the entry point) has gone. Actually, it's present there, yet it's covered under the covers by the Arduino build environment. A halfway document is made by the build process that has the sketch code along with some other explanations:

int main(void)

{

init();

setup();

for (;;)

loop();

return 0;

}

In the above sketch we see that the Arduino Hardware is initialized as at the start of the code the function init ( ) is called. After the init ( ) function the next function called is the setup ( ). After both these functions the last and final function is called, that is the loop ( ). It is called repeatedly. And at last we see that the statement ‘return’ does not run. The reason behind this is that the for loop does not end.

Using Standard Variable Types

Arduino has various kinds of variables to represent the values more efficiently. You need to understand how to choose and utilize these data types of Arduino.

In the Arduino applications we see that the most basic data type used is int. int is an abbreviation for integer and is a 16- bit value. The following table highlights the numerous data types used in Arduino and their explanations, originally given by Michael Margolis in his book ‘Arduino Cookbook ’ which is a very good read.

Numeric types

Bytes

Range

Use

int

2

-32768 to 32767

Represents positive and negative integer values.

unsigned int

2

0 to 65535

Represents only positive values; otherwise, similar to int

Long

4

-2147483648 to 2147483647

Represents a very large range of positive and negative values.

unsigned long

4

4294967295

Represents a very large range of positive values.

Float

4

3.4028235E+38 to -3.4028235E+38

Represents numbers with fractions; use to approximate real world measurements.

double

4

Same as float

In Arduino, double is just another name for float.

boolean

1

false (0) or true (1)

Represents true and false values.

char

1

-128 to 127

Represents a single character. Can also represent a signed value between -128 and 127.

byte

1

0 to 255

Similar to char, but for unsigned values.

Other types

string

Represents arrays of chars (characters) typically used to contain text.

void

Used only in function declarations where no value is returned.

(Reference: Arduino Cookbook by Michael Margolis)

If the values do not surpass the range and you do not have to deal with fractional numbers, then the variables proclaimed utilizing int will be appropriate. This is only possible for circumstances in which efficient memory or most of execution is not required. In the official example codes of Arduino, we can see that int data type is preferred for numeric values. But in some cases, you are required to select a different data type.

One might encounter different scenarios where they might either require a positive value or a negative value. So, signed and unsigned are the two numeric types that can be used to represent both positive and negative values respectively, variables are used without the keyword ‘unsigned’ in front of them. Positive values are always considered as unsigned. A signed variable has half the range of an unsigned variable so one main cause to utilize unsigned variables is the point at which the range of signed values won’t be in the limit of the variable. One other cause is that the developers prefer unsigned values because they want to show the individuals that they will not get a negative value.

True or false are the two potential outcomes of a Boolean data type. These kinds of data types are normally utilized to see the switch’s condition. Instead of using the words true or false, you can also utilize the words HIGH or LOW, respectively. For example, instead of using digitalWrite (pin, true) or digitalWrite (pin, 1), you can write digitalWrite (pin, HIGH) as it feels like a more suitable approach to turn on a LED. However, these all are considered identical when the code really performs the execution.

Floating- Point Numbers

The numbers having decimal points are represented with the help of Floating-point values. Fractional numbers can also be expressed using this approach. Now you are required to write a code that will help you to compute and analyze these numbers.

The code shown below tells you how to express floating-point variables, demonstrates issues you can come across while the comparison floating-point values, and also explains how to solve these issues:

/*

* Floating-point example

* This sketch initialized a float value to 1.1

* It repeatedly reduces the value by 0.1 until the value is 0

*/

float value = 1.1;

void setup()

{

Serial.begin(9600);

}

void loop()

{

value = value - 0.1; // reduce value by 0.1 each time through the loop

if( value == 0)

Serial.println("The value is exactly zero");

else if(fabs(value) < .0001) // function to take the absolute value of a float

Serial.println("The value is close enough to zero");

else

Serial.println(value);

delay(100);

}

The calculation performed by the Floating-point numbers isn’t precise. We can face some errors in these calculations. As we know that the numbers expressed internally just hold estimation so these mistakes happen in the light of the fact that a vast range of numbers falls in the category of floating-point numbers. These mistakes bound you to check whether the values are in a ‘range of resilience’ or not.

The following is the output from this sketch:

1.00

0.90

0.80

0.70

0.60

0.50

0.40

0.30

0.20

0.10

The value is close enough to zero

-0.10

-0.20

The output keeps on giving negative numbers.

This might be possible that you assume the loop to terminate as its value becomes equal to ‘0.1.’ Afterward, from this value ‘0.1’ is deducted. In any case, this value never becomes sufficient enough to hold true for the if statement i.e., value == 0. This is because the only approach is that floating-point numbers can accommodate the vast range by saving an estimation of that respective value.

This problem can be solved by checking if a variable is near to the ideal value, as appeared in the code in the current solution

else if(fabs(value) < .0001) // function to take the absolute value of a float

Serial.println("The value is close enough to zero");

This code checks if the variable's value is within 0.0001 of the ideal value and if the case is true, it prints a message. The function known as ‘fabs,’ an abbreviation for floating-point absolute value, gives the absolute value of a floating-point variable. The magnitude of the value is returned through this function, if the value is within 0.0001 of 0, then the code will print a message that ‘the value is close enough to zero.’

Working with Groups of Values

Arrays are called the group of values. Basically, you are required to understand their creation and utilization. These arrays can have more than one dimension. Learn to access the array’s elements and find its size..

The following piece of codes shows the creation of 2 arrays. The first array in the following code consists of integers that denote the pins joined to switches. Similarly, the second array consists of integers that denote the pins joined to LEDs.

/*

array sketch

an array of switches controls an array of LEDs

*/

int inputPins[] = {2,3,4,5}; // create an array of pins for switch inputs

int ledPins[] = {10,11,12,13}; // create array of output pins for LEDs

void setup()

{

for(int index = 0; index < 4; index++)

{

pinMode(ledPins[index], OUTPUT); // declare LED as output

pinMode(inputPins[index], INPUT); // declare pushbutton as input

digitalWrite(inputPins[index],HIGH); // enable pull-up resistors

//(see Recipe 5.2)

}

}

void loop(){

for(int index = 0; index < 4; index++)

{

int val = digitalRead(inputPins[i]); // read input value

if (val == LOW) // check if the switch is pressed

{

digitalWrite(ledPins[index], HIGH); // turn LED on if switch is pressed

}

else

{

digitalWrite(ledPins[i], LOW); // turn LED off

}

}

}

The assortments of successive variables having the similar data types are called arrays. An independent variable in that assortment is called an element and the quantity of these independent variables determines the array’s dimension.

In the example mentioned above we see how to store an assortment of pins. This is a basic utilization of array in the Arduino code. It shows that the pins are joined to LEDs and switches. The most significant things we learn here are that how an array is created and how its elements are accessed.

Below given is a code that creates an array of data type integer. It has four elements and the values are initialized. The value of the first element is 2, the next element has value 3, etc:

int inputPins[] = {2,3,4,5};

You can create an array as shown below if you do not want the arrays' values to be initialized. Maybe these values will be accessible only when the code is being executed.

int array[4];

This declares an array having 4 elements and the value of each element is initially set to 0 (zero). The number written inside the square [] bracket shows the array's dimension and sets that number of elements of an array. The above array cannot have more than four integer values as its dimension is four. If the array declaration has initializers, then the array's dimension can be excluded as shown in the primary example.  This is because the compiler sorts out how huge to make the array by getting the total number of initializers.

element [0] is the first element of the array:

int firstElement = inputPin[0]; // this is the first element

If we look at the previous demonstration, we can find that the array's concluding component is 3 although we are working with a four-dimensional array. This is because it is a common trend that whatever the array's dimension is, the value of its last component will always be ‘n-1’ where ‘n’ is the total dimensions of the array.

int lastElement = inputPin[3]; // this is the last element

It might appear to be odd that the last element of an array having dimension four is accessed through array [3], but since the first element of the array is array [0], the four elements will be:

array[0],array[1],array[2],array[3]

In the preceding sketch, for is used to access the four elements of the array:

for(int index = 0; index < 4; index++)

{

//get the pin number by accessing each element in the pin arrays

pinMode(ledPins[index], OUTPUT); // declare LED as output

pinMode(inputPins[index], INPUT); // declare pushbutton as input

}

With values beginning at ‘0’ and finishing at ‘3,’ the loop will journey over the index variable. This is arguably one of the most common mistakes where sometimes an element that does not lie in the array’s dimension is sent an access request by the user. This is an error that can have various side effects. An approach to avoid such errors is to use a constant to set the array’s dimension. Consider the code written below:

const int PIN_COUNT = 4; // define a constant for the number of elements

int inputPins[PIN_COUNT] = {2,3,4,5};

for(int index = 0; index < PIN_COUNT; index++)

pinMode(inputPins[index], INPUT);

Arrays are also utilized to store text characters that are basically known as strings. These are known as strings or character strings in the Arduino code. At least one character is required to make character string. This is then followed by the null character i.e., 0, to demonstrate that the string ends here.

Using Strings in Arduino

You need to manage text. You have to copy the text, add bits together, and find the number of characters.

Character arrays are used to store text. They are normally known as strings. Arduino has an additional ability for utilizing a character array known as String that can store and manage text strings.

This topic explains how to use Arduino strings.

First load the sketch was written below and then to view the results open your Serial Monitor:

/*

Basic_Strings sketch

*/

String text1 = "This string";

String text2 = " has more text";

String text3; // to be assigned within the sketch

void setup()

{

Serial.begin(9600);

Serial.print( text1);

Serial.print(" is ");

Serial.print(text1.length());

Serial.println(" characters long.");

Serial.print("text2 is ");

Serial.print(text2.length());

Serial.println(" characters long.");

text1.concat(text2);

Serial.println("text1 now contains: ");

Serial.println(text1); }

void loop()

{

}

The above sketch makes two variables of type String. One is called message and the other is called ‘anotherMessage.’ Type String variables have built-in abilities that allow them to manipulate text. Message.length ( ) provides (returns) the value of the number of characters (length) in the string message.

To combine the contents of a string message.concat (anotherMessage) will be used; in this situation, it will combine the contents of anotherMessage to the end of the message. Here, concat is an abbreviation for concatenation.

The following will be shown on the Serial Monitor:

This string is 11 characters long.

text2 is 14 characters long.

text1 now contains:

This string has more text

There is another way to combine the strings i.e., by using the string addition operator. Write the following two lines of code at the end of setup code:

text3 = text1 + " and more";

Serial.println(text3);

The new code will bring about the Serial Monitor adding the line shown below to the end of the display:

This is a string with more text and more

To find the instance of a specific character in a string, the two functions indexOf and lastIndexOf can be used.

On the off chance that you see a line as shown below:

char oldString[] = "this is a character array";

C-style character arrays are used in the code. And if you see a line of code like the following:

String newString = "this is a string object";

then Arduino Strings are used in the code. If you want a C-style character array to be converted into Arduino String, then assign its contents to the String object:

char oldString[] = "I want this character array in a String object";

String newsString = oldString;

The Arduino distribution provides string example sketches.

Using Strings of C Programming Language

You need to learn that how you can use raw character strings: you need to understand how to declare or create a string, how to find its length, and how to copy, compare, or append strings. The C language does not support the Arduino style String ability, that’s why you need to get code written to work with primitive character arrays.

Character arrays are at times known as character strings or basically strings for short. This topic explains the functions that work on character strings.

String declaration is done as follows:

char StringA[8]; // declare a string of up to 7 chars plus terminating null

char StringB[8] = "Arduino"; // as above and init(ialize) the string to "Arduino";

char StringC[16] = "Arduino"; // as above, but string has room to grow

char StringD[ ] = "Arduino"; // the compiler inits the string and calculates size

To find the number of characters in an array before the null, use strlen i.e., abbreviation for sting length.

int length = strlen(string); // return the number of characters in the string

StringA will have length ‘0’ and other strings shown in the above code will have length 7. Strlen does not count the null that shows the end of the string.

Now, to copy one string to another string strcpy i.e., abbreviation for string copy is used.

strcpy(destination, source); // copy string source to destination

To restrict the number of characters to copy use strncpy. This is useful as it prevents copying more characters than the destination strings range.

strncpy(destination, source, 6); // copy up to 6 characters from source to destination

To append one string to the end of another string use strcat i.e., abbreviation for string concatenation:

strcat(destination, source); // append source string to the end of the destination string

To compare two strings use strcmp i.e., abbreviation for string compare.

if(strcmp(str, "Arduino") == 0)

// do something if the variable str is equal to "Arduino"

An array of characters is used to display the text in the Arduino environment. A string comprises of various characters followed by a null (it has a value equal to ‘0’). The null isn’t shown, however it is expected to show the end of a string.

Splitting Comma- Separated Text into Groups

You are given a string with at least two bits of data separated by commas or any other separator. You have to divide (split) the string so you can utilize each part of the string individually.

The following sketch displays the text present between ever comma:

/*

* SplitSplit sketch

* split a comma-separated string

*/

String message= "Peter,Paul,Mary"; // an example string

int commaPosition; // the position of the next comma in the string

void setup()

{

Serial.begin(9600);

}

void loop()

{

Serial.println(message); // show the source string

do

{

commaPosition = message.indexOf(,’');

if(commaPosition != -1)

{

Serial.println( message.substring(0,commaPosition));

message = message.substring(commaPosition+1, message.length());

}

else

{ // here after the last comma is found

if(message.length() > 0)

Serial.println(message); // if there is text after the last comma, print it

}

}

while(commaPosition >=0);

delay(5000);

}

The Serial Monitor will display the following text:

Peter,Paul,Mary

Peter

Paul

This above sketch utilizes String functions to get the text from between the commas. The line of code written below:

commaPosition = message.indexOf(,’');

finds the position (index) of the first comma used in the String named  message and sets the value of the variable commaPosition equivalent to it. If there is no comma found in the string, the value of commaPosition will be set to -1. If a comma is found in the string then to display the text from the start of the string to the comma's position, the substring function is used. The text that was displayed is taken out from the string message with the following code:

message = message.substring(commaPosition+1, message.length());

substring results in a string having text beginning from commaPosition + 1 i.e., the next position after the comma up to the end of the string message. This outcomes in that message having only the text after the first comma. This is done repeatedly until no more commas are left in the string i.e., commaIndex will become – 1.

The low-level functions that belong to the standard C library can also be used if you are an expert programmer. The sketch  written below has the same functionality as the previous one using Arduino strings:

/*

* SplitSplit sketch

* split a comma-separated string

*/

const int MAX_STRING_LEN = 20; // set this to the largest string you'll process

char stringList[] = "Peter,Paul,Mary"; // an example string

char stringBuffer[MAX_STRING_LEN+1]; // a static buffer for computation and output

void setup()

{

Serial.begin(9600);

}

void loop()

{

char *str;

char *p;

strncpy(stringBuffer, stringList, MAX_STRING_LEN); // copy source string

Serial.println(stringBuffer); // show the source string

for( str = strtok_r(stringBuffer, ",", &p); // split using comma

str; // loop while str is not null

str = strtok_r(NULL, ",", &p) // get subsequent tokens

)

{

Serial.println(str);

if(strcmp(str, "Paul") == 0)

Serial.println("found Paul");

}

delay(5000);

}

The fundamental functionality originates from the function known as strtok_r i.e., the version’s name of strtok that accompanies the Arduino compiler. You pass the string you need to tokenize i.e., separate into individual pieces, to the function strtok_r when you call it for the first time. However, whenever the function strtok_r finds a new token it overwrites the characters in this string, so as shown in the example above it's ideal to pass a copy of the string. Every call that follows utilizes a NULL to inform the function that it should go to the following token. In the above example, every token is compared to a target string i.e., (“Paul”), and is printed to the serial port.

Converting a Number to a String

You have to convert a given number to a string, possibly to represent the number on an LCD or some other display.

The variable String will change numbers to character strings spontaneously. You can utilize the contents of the variable or literal values. For instance, the code written below will work:

String myNumber = 1234;

So will this code:

int value = 127

String myReadout = "The reading was ";

myReadout.concat(value);

Or the following code:

int value = 127;

String myReadout = "The reading was ";

myReadout += value;

If and only if you are changing a number to show on a serial device or an LCD as a text, the easiest approach is to utilize Serial libraries and LCD's built-in conversion ability. However, maybe you are utilizing a device that does not have built-in assistance or want to change the number to a string.

When the numerical values are assigned to a String variable they are automatically converted by the class called Arduino String class. You can use the addition (+) operator or the concat function if you want to join the numeric values at the end of some string.

The piece of code written below gives a number having a value equal to 13:

int number = 12;

number += 1;

When we use the data type String, we get the following result:

String textNumber = 12

textNumber += 1;

In the above code textNumber is a string having text “121”.

When the String class was not introduced, the function itoa or ltoa was usually used to determine the Arduino code. The name ‘itoa’ originates from “integer to ASCII” and the name ‘ltoa’ originates from “long to ASCII”. The String version explained before is simpler to use, however, if you need to know the code that uses ltoa or itoa, the following will help you understand it:

The following functions require three parameters. First, the value to be converted. Second, the buffer that will store the resultant string. And third, the number base i.e., 2 for binary, 10 for decimal, and 16 for hex.

The conversion of numeric values using ltoa is explained in the code written below:

/*

* NumberToString

* Creates a string from a given number

*/

void setup()

{

Serial.begin(9600);

}

char buffer[12]; // long data type has 11 characters (including the

// minus sign) and a terminating null

void loop()

{

long value = 12345;

ltoa(value, buffer, 10);

Serial.print( value);

Serial.print(" has ");

Serial.print(strlen(buffer));

Serial.println(" digits");

value = 123456789;

ltoa(value, buffer, 10);

Serial.print( value);

Serial.print(" has ");

Serial.print(strlen(buffer));

Serial.println(" digits");

delay(1000);

}

It is very important for the buffer being used in the sketch program to be big enough such that it’s capable of handling every character which is being used in the string. Seven character buffer i.e., five digits, a ‘-’ sign, and an ending zero, for a 16 – bit integer. Twelve character buffer i.e., ten digits, a ‘-’ sign, and an ending zero, for a 32 – bit long integer. If you exceed the limit of buffer no warning is given; and this is such a bug that can cause a wide range of abnormal indications, as the overflow will manipulate some other pieces of memory that might be utilized by your program. So the least demanding approach to deal with this is to use a twelve character buffer and always prefer to in light of the fact that it can handle both 16 – bit and 32 – bit values.

Converting a String to a Number

You have to change a string to a number. Maybe you have got a value in the form of a string over a communication connection and you have to utilize this as a floating-point or integer value.

There are various approaches to understand and solve this. As each character is received it can be converted on the fly if the string is received as serial data. Refer to the preceding topics for an example of the most effective method to do this utilizing the serial port.

One more way to convert the text strings that represent numbers is to utilize C language's conversion functions. For int variable use the function atoi and for long variable use the function atol.

The following piece of code ends the approaching digits on any character that isn’t a digit or if there is no space left in the buffer:

int blinkRate; // blink rate stored in this variable

char strValue[6]; // must be big enough to hold all the digits and the

// 0 that terminates the string

int index = 0; // the index into the array storing the received digits

void loop()

{

if( Serial.available())

{

char ch = Serial.read();

if(index < 5 && ch >= '0' && ch <= '9'){

strValue[index++] = ch; // add the ASCII character to the string;

}

else

{

// here when buffer full or on the first non-digit

strValue[index] = 0; // terminate the string with a 0

blinkRate = atoi(strValue); // use atoi to convert the string to an int

index = 0;

}

}

blink();

}

The indistinctly named functions atoi i.e., for ASCII to int and atoll i.e., for ASCII to long are used to change a string into integer or long. If you want to use them then before calling the conversion function, you have to get and then store the whole string in a character array. The above code will make a character array i.e., strValue that can store five digits. As there must be space to store the terminating NULL, so it is declared as char strValue [6]. Digits are stored in the array from Serial.read till it receives a character that is an invalid digit. The array is ended with a NULL and the character array is converted into the variable blinkRate by calling the atoi function.

The value stored in blinkRate is used by a function named blink. The previous sections show the function of ‘blink.’

This example creates a character array, as opposed to utilizing the class String. At the time of this composition, the Arduino String library didn’t serve the purpose of converting strings into numbers.

Transforming the Lines of Code into Blocks

You should understand how you will be able to write more functions in your code. And also understand the right measure of functionality that you need to go into your functions. Additionally, you should be aware of designing the general structure of a code.

The activities performed by your sketch are sort out by functions into the functional blocks. Functions pack features into clearly described inputs i.e., data provided to a function and outputs i.e., data given as a result by a function that keeps it simpler to maintain, structure, and reuse the code. setup and loop are two functions in every Arduino sketch that are already well known by you. To create a function you declare its return type i.e., the data it gives as a result, the name of the function, and any parameters i.e., values that will be passed in the function when it is called. However, parameters are optional. Below given is a basic function that causes the LED to blink. The following code has no parameters and it returns nothing. The keyword void, which was written before the function, shows that it will not return anything.

// blink an LED once

void blink1()

{

digitalWrite(13,HIGH); // turn the LED on

delay(500); // wait 500 milliseconds

digitalWrite(13,LOW); // turn the LED off

delay(500); // wait 500 milliseconds

}

The piece of code written below has a parameter i.e., int count that shows how frequently the LED will blink:

// blink an LED the number of times given in the count parameter

void blink2(int count)

{

while(count > 0 ) // repeat until count is no longer greater than zero

{

digitalWrite(13,HIGH);

delay(500);

digitalWrite(13,LOW);

delay(500);

count = count -1; // decrement count

}

}

This block of code's main function is to double-check the counter’s value to see if it’s ‘0’ or some other value and take appropriate actions. For instance, in the scenario where the value is something other than ‘0,’ the program blinks the LED on the Arduino board and, consequently, reduces the value on the counter by ‘1.’ This process is repeated until the counter’s value is brought to ‘0.’

The following is a code that accepts a parameter. It also gives some value as a result. How many times the LED blinks i.e., it is turned on and off is determined by this parameter. The LED keeps on blinking till we press a button. This value is then returned:

/*

As soon as the program starts executing, the LED begins blinking.

When a ‘switch’ is paired with ‘pin 2,’ the blinking will immediately stop after this switch is triggered.

The final result is that the program prints out the total number of blinks the LED went through until the switch was pressed.

*/

const int ledPin = 13;       // This is the LED’s output pin

const int inputPin = 2;      // This is the Input pin which is connected to the switch

void setup()

{

pinMode(ledPin, OUTPUT);

pinMode(inputPin, INPUT);

digitalWrite(inputPin,HIGH); // use internal pull-up resistor (Recipe 5.2)

Serial.begin(9600);

}

void loop()

{

Serial.println("Press and hold the switch to stop blinking");

int count = blink3(250); // blink the LED 250ms on and 250ms off

Serial.print("The number of times the switch blinked was ");

Serial.println(count);

}

// blink an LED using the given delay period

// return the number of times the LED flashed

int blink3(int period)

{

int result = 0;

int switchVal = HIGH; //with pull-ups, this will be high when switch is up

while(switchVal == HIGH) // repeat this loop until switch is pressed

// (it will go low when pressed)

{

digitalWrite(13,HIGH);

delay(period);

digitalWrite(13,LOW);

delay(period);

result = result + 1; // increment the count

switchVal = digitalRead(inputPin); // read input value

}

// here when switchVal is no longer HIGH because the switch is pressed

return result; // this value will be returned

}

Discussion:

The code in this problem’s solution shows the three types of a function call that you’ll encounter.

The following function blink1 does not have any parameter or return value.

void blink1()

{

// implementation code goes here...

}

The next function blink2 has one parameter yet does not have any return value:

void blink2(int count)

{

// implementation code goes here...

}

The third function blink3 has both i.e., a parameter and a return value as shown below:

int blink3(int period)

{

// implementation code goes here...

}

If void is written before the name of a function it shows that the respective function has no return type. Other than this all the functions have some return types that they mentioned before their name. When you declare a function a semicolon is not required at the end of the parenthesis. However, the semicolon plays an important role when you call a specific function.

Most of the functions that we demonstrate are of similar datatypes. For instance, consider the following example;

int sensorPercent(int pin)

{

int percent;

val = analogRead(pin); // read the sensor (ranges from 0 to 1023)

percent = map(val,0,1023,0,100); // percent will range from 0 to 100.

return percent;

}

The name of the function is sensorPercent. A pin number is passed as a parameter in this function and then returns a value i.e., percent. The int written before the name of the function indicates that the function will return an integer. While declaring functions keep in mind to select the proper return type according to what action the function has to perform. For the above-mentioned function, int data type is appropriate as it returns a number between 0 and 100.

The pin is a parameter of sensorPercent. The value that is passed to the function is assigned to the pin when the function is called.

The code that is written inside the parenthesis (the body of the function) executes the task you need, it reads the value from an analog input pin and afterward depicts the value to a percentage. In the previous example, the variable named percent temporarily holds the percentage. The value stored in the temporary variable i.e., percent is returned to the calling function using the following statement:

return percent;

We can also get similar functionality without the utilization of a temporary variable:

int sensorPercent(int pin)

{

val = analogRead(pin); // read the sensor (ranges from 0 to 1023)

return map(val,0,1023,0,100); // percent will ranges from 0 to 100.

}

The following code shows that how to call a function:

// print the percent value of 6 analog pins

for(int sensorPin = 0; sensorPin < 6; sensorPin++)

{

Serial.print("Percent of sensor on pin ");

Serial.print(sensorPin);

Serial.print(" is ");

int val = sensorPercent(sensorPin);

Serial.print(val);

}

Returning More Than One Value from a Function

You have to return at least two values from a given function. One of these forms of the function returns just one value or no value at all. However, at times you are required to alter or return more values.

There are different approaches to solve this problem. The simplest to comprehend is to have the function alter some global variables and to not really return any value from the function:

/*

swap sketch

demonstrates changing two values using global variables

*/

int x; // x and y are global variables

int y;

void setup()

{

Serial.begin(9600);

}

void loop()

{

x = random(10); // pick some random numbers

y = random(10);

Serial.print("The value of x and y before swapping are: ");

Serial.print(x); Serial.print(","); Serial.println(y);

swap();

Serial.print("The value of x and y after swapping are: ");

Serial.print(x); Serial.print(","); Serial.println(y);Serial.println();

delay(1000);

}

// swap the two global values

void swap()

{

int temp;

temp = x;

x = y;

y = temp;

}

By utilizing the global variables, the swap function changes the two values. Global variables are available throughout the program and can be changed by anything. Moreover, they are very easy to understand. However, they are not used by expert programmers since it's very easy to modify the value of these variables or have a function quit working because you altered the type or name of this variable somewhere else in the sketch.

A more secure and more exquisite approach is to pass a reference to those values that you want to change and let the function modify the values by using the references. As shown below:

/*

functionReferences sketch

demonstrates returning more than one value by passing references

*/

void swap(int &value1, int &value2); // functions with references must be

declared before use

void setup() {

Serial.begin(9600);

}

void loop(){

int x = random(10); // pick some random numbers

int y = random(10);

Serial.print("The value of x and y before swapping are: ");

Serial.print(x); Serial.print(","); Serial.println(y);

swap(x,y);

Serial.print("The value of x and y after swapping are: ");

Serial.print(x); Serial.print(","); Serial.println(y);Serial.println();

delay(1000);

}

// swap the two given values

void swap(int &value1, int &value2)

{

int temp;

temp = value1;

value1 = value2;

value2 = temp;

}

The functions having parameters that are described in the preceding sections and the swap function both are similar. However, the symbol ‘&’ (ampersand) shows that the parameters are references. This means that the value of the variable that is given when the function is called is changed when the values inside the function change. This happens by first executing the code given in the above Solution and then checking that the parameters are swapped. Afterward, the code is modified by eliminating all the four ampersands. Two of them are present at the top of the declaration and the other two at the end.

The two lines that are changed should be as follows:

void swap(int value1, int value2); // functions with references must be declared

before use

...

void swap(int value1, int value2)

By running the code, we see that the values are not swapped. The modifications that are done inside the function are local and when the function returns, these changes are lost.

Problem

You need to execute a piece of code if and only if a specific condition is valid. For instance, if a switch is pressed you might need to turn on a LED or if the value of analog is larger than the threshold.

Solution

The piece of code written below utilizes the wiring shown in the preceding sections:

/*

Pushbutton sketch

a switch connected to pin 2 lights the LED on pin 13

*/

const int ledPin = 13; // choose the pin for the LED

const int inputPin = 2; // choose the input pin (for a pushbutton)

void setup() {

pinMode(ledPin, OUTPUT); // declare LED pin as output

pinMode(inputPin, INPUT); // declare pushbutton pin as input

}

void loop(){

int val = digitalRead(inputPin); // read input value

if (val == HIGH) // check if the input is HIGH

{

digitalWrite(ledPin, HIGH); // turn LED on if switch is pressed

}

}

Discussion

To test the value of digitalRead, the if statement is used. The if statement should have a test written between the parenthesis that must be true or false. In this given problem’s Solution, its val == High, and if the expression is true only then the if statement is executed. A block of code comprises of all the code written inside the parenthesis and if the parenthesis is not used, then the block comprises of the following executable statement ended by a semicolon.

Use the if… else statement, if you have to do a certain thing if the statement is true and another if the statement is false:

/*

Pushbutton sketch

a switch connected to pin 2 lights the LED on pin 13

*/

const int ledPin = 13; // choose the pin for the LED

const int inputPin = 2; // choose the input pin (for a pushbutton)

void setup() {

pinMode(ledPin, OUTPUT); // declare LED pin as output

pinMode(inputPin, INPUT); // declare pushbutton pin as input

}

void loop(){

int val = digitalRead(inputPin); // read input value

if (val == HIGH) // check if the input is HIGH

{

// do this if val is HIGH

digitalWrite(ledPin, HIGH); // turn LED on if switch is pressed

}

else

{

// else do this if val is not HIGH

digitalWrite(ledPin, LOW); // turn LED off

}

}

Problem

You want a piece of code to run until a given condition is true.

Solution

Until a condition is true, a while loops execute the code repeatedly.

while(analogRead(sensorPin) > 100)

{

flashLED(); // call a function to turn an LED on and off

}

The above code is written within the parenthesis of while the loop will execute until the given condition is true i.e., value of analogRead is greater than 100. When a value surpasses a threshold, it could blink a LED as an obvious warning. When the analogRead is greater than 100, the led blinks continuously. Otherwise, the LED is off if the value is less or equal to 100.

Parentheses fix the limit of a code block that is to be executed within a loop. Only the first line of the code in executed repeatedly if the parenthesis are not used.

while(analogRead(sensorPin) > 100)

flashLED(); // line immediately following the loop expression is executed Serial.print(analogRead(sensorPin)); // this is not executed until after

// the while loop finishes!!!

The ‘do… while’ loop is just like the while loop, however, the statements of the code are run once before checking the condition. You can use do… while loop when you want at least a single execution of the code, regardless of whether the condition is false:

do

{

flashLED(); // call a function to turn an LED on and off

}

while (analogRead(sensorPin) > 100);

The above code will cause the LED to blink at least a single time even if the condition is false. And the LED will keep blinking until the value from analogRead is greater than 100. The LED will blink only once if the value is not greater than 100. A battery – circuit could be made using this code. The LED's persistent blinking will show that the battery is fully charged and if it blinks every other second, this will show that the circuit is active.

You need to execute at least one statement a specific number of times. The ‘while’ loop and ‘for’ loop are almost the same. However, in the ‘for’ loop, you have more command over the beginning and terminating conditions.

In the code lines demonstrated below, the program tells the user the ‘i’ variable’s value as it went through the ‘for’ loop.

/*

ForLoop sketch

demonstrates for loop

*/

void setup() {

Serial.begin(9600);}

void loop(){

Serial.println("for(int i=0; i < 4; i++)");

for(int i=0; i < 4; i++)

{

Serial.println(i);

}

}

We get the following result from the above sketch:

for(int i=0; i < 4; i++)

0

1

2

3

Discussion

Generally, the ‘for’ loop consists of three portions. First is the initialization, second is the conditional test and third is iteration i.e., an expression that is executed toward the finish of each pass through the loop. A semicolon distinguishes all these three parts. In the above solution's code, variable i is initialized to ‘0’ i.e., int i = 0. The condition i.e., i < 4 checks if the variable i is less than 4. And the iteration i.e., i ++ increments the value of the variable i by 1 after a single iteration.

A for loop can either create a new variable that is restricted within the for loop or it can use an existing variable. The following sketch shows the use of an already created variable:

int j;

Serial.println("for(j=0; j < 4; j++ )");

for(j=0; j < 4; j++ )

{

Serial.println(j);

}

This code is nearly similar to the previous code. However, the only difference is in the initialization part i.e., the variable j does not have int keyword written before it, because it is already defined outside the loop. Bothe these codes get the same outputs as shown below:

for(j=0; i < 4; i++)

0

1

2

3

If you want to eliminate the initialization part totally you can just utilize a variable defined before. The following code begins the loop where j has a value equal to 1.

int j = 1;

Serial.println("for( ; j < 4; j++ )");

for( ; j < 4; j++ )

{

Serial.println(j);

}

The above code displays the following output:

for( ; j < 4; j++)

1

2

3

You control the loop termination in the conditional test. In the preceding example, when the variable's value exceeds 4 the loop ends because the condition is no longer true.

The code written below checks the value of the variable whether it is equal to 4 or less than 4. It displays the numbers from 0 to 4:

Serial.println("for(int i=0; i <= 4; i++)");

for(int i=0; i <= 4; i++)

{

Serial.println(i);

}

The iteration statement that is the third part of the for loop gets executed toward the finish of each pass through the loop. This can be any legitimate statement of C or C++. The below given code increments the value of variable i by 2 after each iteration:

Serial.println("for(int i=0; i < 4; i+= 2)");

for(int i=0; i < 4; i+=2)

{

Serial.println(i);

}

This code prints only two values i.e., 0 and 2.

The iteration statement can be utilized to get the values from high to low, for example in the following code, from 3 to 0:

Serial.println("for(int i=3; i > = 0 ; i--)");

for(int i=3; i > = 0 ; i--)

{

Serial.println(i);

}

Just like the other parts, the iteration statement can also be left empty. But in mind to put the semicolons in between to separate the three parts of a ‘for’ loop.

The following piece of code shows that the for loop does not increment or decrement the value of variable i until an input pin is high and this is dine in the if statement after Serial.print:

Serial.println("for(int i=0; i < 4; )");

for(int i=0; i < 4; )

{

Serial.println(i);

if(digitalRead(inPin) == HIGH);

i++; // only increment the value if the input is high

}

Problem

Based on some conditions that you are testing you need to end a loop early.

You will use the code written below:

while(analogRead(sensorPin) > 100)

{

if(digitalRead(switchPin) == HIGH)

{

break; //exit the loop if the switch is pressed

}

flashLED(); // call a function to turn an LED on and off

}

Discussion

This code is like the one that uses while loops, however, this code uses a break statement if the loop needs to be terminated if the digital pin is high. For instance, the LED will stop blinking and the loop will terminate regardless of whether the condition in the while loop is true, if the switch is connected to the pins.

Chapter 5

Coding and Memory Handling

Whenever we talk about programming, an essential part is to understand the tools available for us to use within the language we are working with. Every language features their own set of tools which make the preferable for a certain niche of programming. For instance, for statistical and data analysis, people prefer the ‘R programming language.’ For machine learning and working with neural networks, people prefer ‘Python,’ and in some cases, both Python and C++ can be used to create the same instruction set. However, it all boils down to which language the programmer is comfortable using. The reason why programmers have a preference when it comes to programming languages is because of the tools they are packing. These tools are essentially the libraries that feature classes, objects, and functions that enable the programmer to create a useful application. In short, libraries extend the usefulness of a programming language as a whole and Arduino is no exception (since it uses C++ as the base programming language).

In addition, coding requires that the user also accounts for any complications and other aspects which arise when software interacts with hardware. One of the most important aspects to be wary of when writing any program is its memory and error handling capabilities. In Arduino, error handling isn’t emphasized as much as memory handling because the programs have fewer chances of encountering an error as compared to applications designed for PCs. A good memory handling program can execute more efficiently, consuming less RAM all whilst running smoothly and fast. This becomes even more important when we are working on a resource-intensive project and is required to deliver a level of performance that is well over the capabilities of the Arduino’s chipset itself. On the Arduino board, there a total of three memory types which have been listed below;

- Random Access Memory

- Program Memory

- EEPROM

This chapter will discuss how to use libraries, create our own, and even modify existing libraries. In the latter half, we will cover different memory handling techniques to make sketch programs more efficient without relying heavily on RAM.

Using the Libraries

The Arduino distribution comes with a collection of libraries for users to implement in their sketch programs from the get-go. Using a library that is by default included in the IDE is very simple. All we have to do is go to the ‘Sketch ’ menu and in the ‘Import Library ’ section, we will find all of the libraries currently available in the Arduino IDE. Apart from the ones that come with the distribution, we can install additional libraries as well. These libraries will show up on the same menu and will be separated from the default ones by a line.

To use a library, we simply go to the ‘Import Library ’ option and choose the one we want to use for the current sketch program. If we know the name of the library, we can also directly add it to our sketch program by using the ‘include’ header as shown below;

#include <nameOfTheLibrarySelected.h>

In this way, all of the functions, methods, classes, objects, and commands specified within this library become available for use in the current coding session. Here’s a list of the libraries that you’ll find come with the Arduino distribution.

- EEPROM ; this library contains functions and classes that allow the user to save data within the EEPROM memory of the board and read it. The data stored within this memory is not lost even when the power is turned off.

- Ethernet ; this library features elements that allow the user to code a sketch program capable of interacting with the Arduino board's Ethernet shield.

- Firmata ; this library contains protocols to facilitate serial communication. It also includes protocols that help the program to control the functioning of the board as well.

- LiquidCrystal ; this library allows the sketch program to be able to control the LCD display connected to the Arduino board.

- Matrix ; this library is primarily used to manipulate LED displays being used with the Arduino board.

- SD ; this library features functions that allow the program to perform read and write operations on an SD card.

- Servo ; this library is used when the Arduino board is connected to a ‘Servo motor’ so that it can control its functioning.

- SoftwareSerial ; this library is used to enable additional serial ports on the Arduino board.

- SPI ; this library is primarily used for controlling the Ethernet as well as any SPI hardware connected to the board.

- Sprite ; this library allows the program to use ‘sprites’ on a matrix LED connected to the Arduino board.

Many more libraries are available with the Arduino distribution which unlock its full potential when used, making the hardware more versatile and compatible with many projects.

Installing Additional Libraries

As we discussed before, we are not limited to only using the libraries that come with the Arduino distribution, we can install additional libraries as well. To install a library in the IDE software, we first need to download it. Suppose the downloaded file is in the form of a .’zip’ file. In that case, we will first need to unzip and then relocate the folder containing the library files to the ‘libraries ’ directory found within the ‘Arduino Documents ’ folder.              If you don’t know where this root folder is, you can simply go to the Arduino IDE and under the ‘Sketch ’ menu, go to the ‘Show Sketch Folder ’ menu. This will bring us to Arduino’s sketch folder and from here, we simply go to the root directory and this will lead us to the ‘Arduino Documents ’ folder. There’s a good chance that this will be the first time you are adding a library to the IDE, if that’s the case, then a ‘libraries ’ folder might not even exist. In this scenario, just create a folder named ‘libraries ’ by yourself and then put all of the libraries you want to add to this folder.

Once you add a library, it will show up when the IDE is booted. This is because the Arduino IDE scans its directory and checks if anything was added when it is being booted. However, if the IDE is running and the libraries are added, then they will not show up unless the IDE is closed and launched again.

Modifying Libraries

Users have the option to make changes to libraries as well if they want to add certain functionalities needed for their projects. For instance, if we download a library named ‘TimeAlarms ,’ we can use its methods and classes to program an alarm on the Arduino board.  However, this library has a limitation: it only allows a total of 6 alarms to be set at any time. Let’s say that we need more than six alarms for our project. In such a scenario, it is much better and easier to modify the library itself rather than looking for one that supports more than 6 alarms.

The following sketch program is using the ‘TimeAlarms ’ library. In this demonstration, we are specifying 7 alarms instead of 6 to show the error it will trigger.

/*

multiple_alarms sketch

has more timer repeats than the library supports out of the box -

you will need to edit the header file to enable more than 6 alarms

*/

#include <Time.h>

#include <TimeAlarms.h>

int currentSeconds = 0;

void setup()

{

Serial.begin(9600);

// create 7 alarm tasks

Alarm.timerRepeat(1, repeatTask1);

Alarm.timerRepeat(2, repeatTask2);

Alarm.timerRepeat(3, repeatTask3);

Alarm.timerRepeat(4, repeatTask4);

Alarm.timerRepeat(5, repeatTask5);

Alarm.timerRepeat(6, repeatTask6);

Alarm.timerRepeat(7, repeatTask7); //7th timer repeat

}

void repeatTask1()

{

Serial.print("task 1 ");

}

void repeatTask2()

{

Serial.print("task 2 ");

}

void repeatTask3()

{

Serial.print("task 3 ");

}

void repeatTask4()

{

Serial.print("task 4 ");

}

void repeatTask5()

{

Serial.print("task 5 ");

}

void repeatTask6()

{

Serial.print("task 6 ");

}

void repeatTask7()

{

Serial.print("task 7 ");

}

void loop()

{

if(second() != currentSeconds)

{

// print the time for each new second

// the task numbers will be printed when the alarm for that task is triggered

Serial.println();

Serial.print(second());

Serial.print("->");

currentSeconds = second();

Alarm.delay(1); //Alarm.delay must be called to service the alarms

}

}

Once this sketch program is uploaded to the Arduino board, it will start executing. But we won’t do that just yet because we know it will not work. Upon compiling and running the sketch program, the Serial Monitor will display each task's output for a total of 9 seconds. Each second, different tasks will be performed. The result is as shown below;

1->task 1

2->task 1        task 2

3->task 1        task 3

4->task 1        task 2 task 4

5->task 1        task 5

6->task 1        task 2 task 3 task 6

7->task 1

8->task 1        task 2 task 4

9->task 1        task 3

If we carefully analyze this result, then we can see that the task scheduled at the 7th second did not execute. This is because we used a 7th timer object even though the library only has 6 timer objects. To make this sketch work, we will have to open the library to modify it. To do this, we simply open the library we want to modify using a text editor. There’s no specific text editor application which is mandatory to install, even the default text editors that come with the Operating System are more than enough. Find the library you want to modify in the ‘libraries ’ folder and then open it with the text editor. If you are running Windows, you can use ‘Notepad’ and if you are using Mac, you can use the ‘TextEdit’ application. Once in the libraries folder, we need to find the ‘TimeAlarms.h ’ file and open it using the desired text editor.

Once we open the header file using the text editor, the very first lines will be like this;

#ifndef TimeAlarms_h

#define TimeAlarms_h

#include <inttypes.h>

#include "Time.h"

#define dtNBR_ALARMS 6

If we look at the very last line, we will see the number of timer objects defined. To add support for 7 alarms instead of 6, we simply need to change the value assigned to ‘dtNBR_ALARMS’ accordingly. Since we only want 7 alarms, we will assign it a value of ‘7.’

#define dtNMBR_ALARMS 7

Once the modifications are done, we need to save the file to make the changes permanent and close it. Now, we run the lines of code in the Arduino IDE again and this time, instead of the 7th -second task being missed, it will be properly executed this time.

1->task 1

2->task 1 task 2

3->task 1 task 3

4->task 1 task 2 task 4

5->task 1 task 5

6->task 1 task 2 task 3 task 6

7->task 1 task 7

8->task 1 task 2 task 4

9->task 1 task 3

The result displayed by the Serial Output Monitor this time clearly shows us that the task scheduled at the 7th second succeeded this time whereas it failed when we used the original library.

However, modifications made to the library are not for free, on the contrary, they come at a cost that can be sometimes quite hefty to pay for the board’s resources. For instance, the type of change we made to this library will ultimately consume more system resources and this consumption will affect the resources available for the rest of the program. But not everything is doom and gloom. In fact, we can use this to our advantage as well. By carefully structuring the sketch program, we can identify the portion that needs more system memory (RAM) and the portion that does not need it. Since the requirement is imbalanced, we can modify certain elements of the sketch program accordingly. For instance, we can selectively decrease the memory allocated to the ‘serial library’ being used in the program, this will increase the memory resource available to the rest of the program. Similarly, we can increase the memory resource available to a library being used in the program if the other code lines don’t require as much RAM. Hence, when creating a sketch program, one should always be wary of system requirements to take appropriate measures. Otherwise, the code execution will have problems.

Creating a Library

Generally, the reason why users would want even to create libraries is not to invent new functions and capabilities within the programming language, instead, this method is a pretty convenient way of sharing a block of code or reusing it in other programs.

This section will create a library from a sketch program example, which will be done without using any classes.

The sketch we will be using for this demonstration is given below;

/*

* blinkLibTest

*/

const int firstLedPin = 3; // choose the pin for each of the LEDs

const int secondLedPin = 5;

const int thirdLedPin = 6;

void setup()

{

pinMode(firstLedPin, OUTPUT); // declare LED pins as output

pinMode(secondLedPin, OUTPUT); // declare LED pins as output

pinMode(thirdLedPin, OUTPUT); // declare LED pins as output

}

void loop()

{

// flash each of the LEDs for 1000 milliseconds (1 second)

blinkLED(firstLedPin, 1000);

blinkLED(secondLedPin, 1000);

blinkLED(thirdLedPin, 1000);

}

We will now take out the ‘blinkLED() ’ function from the sketch program and copy it over to a different file and name it ‘blinkLED.cpp .’

/* blinkLED.cpp

* simple library to light an LED for a duration given in milliseconds

*/

#include <WProgram.h> // Arduino includes

#include "blinkLED.h"

// blink the LED on the given pin for the duration in milliseconds

void blinkLED(int pin, int duration)

{

digitalWrite(pin, HIGH); // turn LED on

delay(duration);

digitalWrite(pin, LOW); // turn LED off

delay(duration);

}

All that’s left to do is create a header file with the same name as the .’cpp’ file, in this case, the name of the header file would be ‘blinkLED.h .’ The contents of this header file are shown below;

/*

* blinkLED.h

* Library header file for BlinkLED library

*/

void blinkLED(int pin, int duration); // function prototype

Once done, we put the ‘blinkLED.ccp’ file and the ‘blinkLED.h’ into a folder of the same name and place it in the ‘libraries ’ folder. Now we are ready to use the functions defined within this code for any sketch programs.

We can even modify a library that we create to extend its functionalities further as well. In this case, as soon as we use the library in a blank sketch program, all three of the LEDs on the Arduino board will start flickering. But by adding in a few things, we can change how the library works as well. For instance, we can add a quality of life improvement in this library by including constants that define each blink's delays. This will allow users to refer to the constant value when changing the delay between each blink of the LED light instead of having to work with values in milliseconds. The first option is more convenient and easy to deal with. To make this modification, we first need to open the header file and inside the header file, we need to add the following lines;

/*

* blinkLED.h

* Library header file for BlinkLED library

*/

void blinkLED(int pin, int duration); // function prototype

After that, we open the ‘blinkLED.ccp’ file and change the lines of code present in the ‘void loop() ’ section as shown below;

void loop()

{

blinkLED(firstLedPin, BLINK_SHORT);

blinkLED(secondLedPin, BLINK_MEDIUM);

blinkLED(thirdLedPin, BLINK_LONG);

}

In this way, we assigned the constant values a variable that effectively describes the effect of the value upon the delay in the LED's blinking lights. When we export the sketch file to the Arduino board, we will see that the light will blink really fast at the start, then the intervals between each blink will be longer than before and in the final blink, the delay between the on and off intervals will be the longest.

We can also add different functions to this library as well which were not previously present. For instance, we can specify the number of times an LED should blink when the code is executed. This has been demonstrated in the following lines of code;

void loop()

{

blinkLED(firstLedPin,BLINK_SHORT,5 ); // blink 5 times

blinkLED(secondLedPin,BLINK_MEDIUM,3 ); // blink 3 times

blinkLED(thirdLedPin, BLINK_LONG); // blink once

}

If we want the library to include such functionality, we will have to make changes to both the ‘blinkLED.h’ and ‘blinkLED.cpp’ files. First things first, we open the header file using a text editor and include the function prototype in it;

/*

* BlinkLED.h

* Header file for BlinkLED library

*/

const int BLINK_SHORT = 250;

const int BLINK_MEDIUM = 500;

const int BLINK_LONG = 1000;

void blinkLED(int pin, int duration);

// new function for repeat count

void blinkLED(int pin, int duration, int repeats);

Next, we open the ‘blinkLED.ccp’ file and include the function corresponding to the prototype added in the header file.

/*

* BlinkLED.cpp

*/

#include <WProgram.h> // Arduino includes

#include "BlinkLED.h"

// blink the LED on the given pin for the duration in milliseconds

void blinkLED(int pin, int duration)

{

digitalWrite(pin, HIGH); // turn LED on

delay(duration);

digitalWrite(pin, LOW); // turn LED off

delay(duration);

}

/* function to repeat blinking

void blinkLED(int pin, int duration, int repeats)

{

while(repeats)

{

blinkLED(pin, duration);

repeats = repeats -1;

}

}

Creating Libraries from Other Libraries

While this may sound confusing when read out loud, but it’s not that complicated at all. Just as we used a chunk of code to create a library, we can also use existing libraries as a part of another library. In other words, we can take an entire library, or one portion of it and then extend it to create a different yet similar library. This can be done with multiple libraries as well, just as how you would make a cocktail. One possible use of this technique would be to build a library to help us in debugging. We will be using this library to dispatch a print command and the result would be displayed on another Arduino board. This is possible through a library known as ‘Wire Library .’

The sketch program we will be using to demonstrate this task will be using two main components;

- The wire library

- The Arduino print commands

However, for this demonstration to work, we need two Arduino boards and these boards must be connected to each other through an ‘I2C ’ connection. We will discuss I2C serial port connections some other time, for now, let’s focus on the main concept, which is to use the wire library to create another library (which will have a bit of salvaged code as well). We will be using appropriate code lines for handling the I2C connection and include it in the new library we will be creating.

Let’s name the folder where we will be placing the library as ‘i2cDebug ’ (reminder, every library folder which has a header and .ccp files need to be placed within the root directory of ‘libraries ’). First, let’s build a header file for the corresponding library;

/*

* i2cDebug.h

*/

#include <WProgram.h>

#include <Print.h> // the Arduino print class

class I2CDebugClass : public Print

{

private:

int I2CAddress;

byte count;

void write(byte c);

public:

I2CDebugClass();

boolean begin(int id);

};

extern I2CDebugClass i2cDebug; // the i2c debug object

Now that we have a header file, we now need a .’ccp ’ file to place it alongside the header file in the ‘libraries ’ directory inside the ‘i2cDebug ’ folder. The contents of the .’ccp ’ file will be as follows;

/*

* i2cDebug.cpp

*/

#include <i2cDebug.h>

#include <Wire.h> // the Arduino I2C library

I2CDebugClass::I2CDebugClass()

{

}

boolean I2CDebugClass::begin(int id)

{

I2CAddress = id; // save the slave's address

Wire.begin(); // join I2C bus (address optional for master)

return true;

}

void I2CDebugClass::write(byte c)

{

if( count == 0)

{

// here if the first char in the transmission

Wire.beginTransmission(I2CAddress); // transmit to device

}

Wire.send(c);

// if the I2C buffer is full or an end of line is reached, send the data

// BUFFER_LENGTH is defined in the Wire library

if(++count >= BUFFER_LENGTH || c == '\n')

{

// send data if buffer full or newline character

Wire.endTransmission();

count = 0;

}

}

I2CDebugClass i2cDebug; // Create an I2C debug object

Once we have created both the .’h’ and .’ccp’ files, we simply place them in their appropriate folder inside the ‘libraries ’ directory. We now have created an entirely new library from the ‘Wire library ’ and some lines of code (to handle I2C connections). Let’s now load the following sketch program which will be using the ‘i2cDebug library ’ to perform its core functions.

/*

* i2cDebug

* example sketch for i2cDebug library

*/

#include <Wire.h> // the Arduino I2C library

#include <i2cDebug.h>

const int address = 4; //the address to be used by the communicating devices

const int sensorPin = 0; // select the analog input pin for the sensor

int val; // variable to store the sensor value

void setup()

{

Serial.begin(9600);

i2cDebug.begin(address);

}

void loop()

{

// read the voltage on the pot(val ranges from 0 to 1023)

val = analogRead(sensorPin);

Serial.println(val);

i2cDebug.println(val);

}

Memory Handling

This section will discuss how to implement memory handling techniques to ensure that our sketch program will never have to work with insufficient RAM and sacrifice performance. Before we can even determine how much memory we have to handle carefully, we first need to know how much memory is even allocated to the sketch program in the first place. This can be done by using the ‘memoryFree() ’ function as shown in the following demonstration;

void setup()

{

Serial.begin(9600);

}

void loop()

{

Serial.print(memoryFree()); // print the free memory

Serial.print(' '); // print a space

delay(1000);

}

// variables created by the build process when compiling the sketch

extern int __bss_end;

extern void *__brkval;

// function to return the amount of free RAM

int memoryFree()

{

int freeValue;

if((int)__brkval == 0)

freeValue = ((int)&freeValue) - ((int)&__bss_end);

else

freeValue = ((int)&freeValue) - ((int)__brkval);

return freeValue;

}

This program uses the function ‘memoryFree()’ to validate the total system memory available for use. In turn, the function performs this task by utilizing a special type of variable known as ‘system variables .’ System variables are not generally used in programs because the purpose of these variables is to facilitate the IDE’s compiler in managing the internal resources. As the program is undergoing the execution process, the number of bytes it stores in the system memory constantly changes. Thus, it is important to make sure that the program only uses as much memory as is available and not more than that.

The most common elements that drain memory have been listed below;

- During the initialization of constants. For example;

#define ERROR_MESSAGE "an error has occurred"

- During the declaration of global variables. For example;

char myMessage[] = "Hello World";

- When a function is called. For example;

void myFunction(int value)

{

int result;

result = value * 2;

return result;

}

- During memory allocation. For example;

String stringOne = "Arduino String";

Using lines of code that increasingly incorporate more of the elements listed above will steadily and surely drain the system memory to its last drop. In addition, it is also recommended to be wary of the global variables because these are declared most commonly in libraries. Setting a parameter on which we base the declaration of variables can also backfire because the number of variables might increase to the point where the majority of the system memory is used up during code execution.

Saving and Fetching Numeric Values from Program Memory

It is not possible to save everything in the system memory of the Arduino board. Moreover, we want to have the maximum amount of free RAM available whenever possible. In such cases, we can use the board’s flash memory (also known as the program memory) to do this. This section will discuss how we can store numeric values in the system’s program memory.

In the sketch, we will demonstrate functions in a way such that it makes adjustments to the fading away of the LED light according to our non-linear sensitivity perception. The sketch program will be using a total of 256 values and these values are in the form of a table. Moreover, this entire bundle of data is stored within the system’s program memory instead of the RAM.

When we execute this sketch, the light transitioning from bright to completely fading away is extremely smooth. This sketch works on the LED connected to the pin 5 terminal and this animation can be compared to the LED connected to the pin 3 terminal where the latter has abrupt and hasty fade animations.

The sketch for storing 256 constant numeric values in the system’s program has been shown below;

/* ProgmemCurve sketch

* uses table in Progmem to convert linear to exponential output

*/

#include <avr/pgmspace.h> // needed for PROGMEM

// table of exponential values

// generated for values of i from 0 to 255 -> x=round( pow( 2.0, i/32.0) - 1);

const byte table[]PROGMEM = {

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,

3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5,

5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7,

7, 7, 7, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 10, 10,

10, 11, 11, 11, 11, 12, 12, 12, 12, 13, 13, 13, 14, 14, 14, 15,

15, 15, 16, 16, 16, 17, 17, 18, 18, 18, 19, 19, 20, 20, 21, 21,

22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 28, 28, 29, 30, 30,

31, 32, 32, 33, 34, 35, 35, 36, 37, 38, 39, 40, 40, 41, 42, 43,

44, 45, 46, 47, 48, 49, 51, 52, 53, 54, 55, 56, 58, 59, 60, 62,

63, 64, 66, 67, 69, 70, 72, 73, 75, 77, 78, 80, 82, 84, 86, 88,

90, 91, 94, 96, 98, 100, 102, 104, 107, 109, 111, 114, 116, 119, 122, 124,

127, 130, 133, 136, 139, 142, 145, 148, 151, 155, 158, 161, 165, 169, 172, 176,

180, 184, 188, 192, 196, 201, 205, 210, 214, 219, 224, 229, 234, 239, 244, 250

};

const int rawLedPin = 3; // this LED is fed with raw values

const int adjustedLedPin = 5; // this LED is driven from table

int brightness = 0;

int increment = 1;

void setup()

{

// pins driven by analogWrite do not need to be declared as outputs

}

void loop()

{

if(brightness > 255)

{

increment = -1; // count down after reaching 255

}

else if(brightness < 1)

{

increment = 1; // count up after dropping back down to 0

}

brightness = brightness + increment; // increment (or decrement sign is minus)

// write the brightness value to the LEDs

analogWrite(rawLedPin, brightness); // this is the raw value

int adjustedBrightness = pgm_read_byte(&table[brightness]); // adjusted value

analogWrite(adjustedLedPin, adjustedBrightness);

delay(10); // 10ms for each step change means 2.55 secs to fade up or down

}

When working with a large expression of values that iterate over a regular interval, it is better to simply calculate these values before-hand and store them in the form of an array. In this way, when the code is executed, it doesn’t have to calculate each value repeatedly. This is not only time-efficient, making the program to run faster, but also memory efficient as well because if the values were to be calculated multiple times, then the result would be stored in the system’s RAM. Instead of doing that, we calculated the values before-hand and stored the resulting array in the program memory, hence saving Arduino’s RAM resource from being completely drained by this program. At the beginning of the sketch program, we first and foremost define the table used to store the values. This table is created through the following line;

const byte table[ ]PROGMEM = {

0, . . .

The ‘PROGMEM ’ expression is used to inform the compiler that the values written henceforth are to be saved in the board’s program memory rather than the board’s system memory.  The values are then defined in the form of an array. To use the ‘PROGMEM’ argument, the sketch program needs the corresponding definitions as well, otherwise, the compiler won’t be able to understand this instruction. For this purpose, we include a header file with the name of ‘pgmspace.h ’ in the libraries folder and then import it into the program using the ‘#include ’ argument.

The overall brightness of the LED light is controlled using the following lines of code in the sketch program shown above to ensure a smooth fading transition;

int adjustedBrightness = pgm_read_byte(&table[brightness]);

analogWrite(adjustedLedPin, adjustedBrightness);

This entire expression can also be written in the following way as well;

pgm_read_byte(table + brightness);

Let’s see another demonstration as well.

/* ir-distance_Progmem sketch

* prints distance & changes LED flash rate depending on distance from IR sensor

* uses progmem for table

*/

#include <avr/pgmspace.h> // needed when using Progmem

// table entries are distances in steps of 250 millivolts

const int TABLE_ENTRIES = 12;

const int firstElement = 250; // first entry is 250 mV

const int interval = 250; // millivolts between each element

// the following is the definition of the table in Program Memory

const int distanceP[TABLE_ENTRIES] PROGMEM = { 150,140,130,100,60,50,

40,35,30,25,20,15 };

// This function reads from Program Memory at the given index

int getTableEntry(int index)

{

int value = pgm_read_word(&distanceP[index]);

return value;

}

If you recall the beginning of this book, you’ll find that we discussed a similar experiment by using the LDR sensor instead of an Infrared Sensor. However, the difference is that instead of measuring the light intensity being emitted by the LED, we measure the distance of the light coming from the LED and reaching the Infrared sensor. In the case of the LDR experiment, we assigned different values that correspond to the different intensities of the LED light. Similarly, we will assign values in this program as well but these values will be stored in the board’s flash memory instead of RAM because all of these values are constant (meaning, the values themselves won’t change). To do this, we use the function ‘PROGMEM .’

The distance is measured and interpreted by using the function ‘getDistance() ’ and the ‘getTableEntry() function is used by the program to fetch the corresponding values from the program memory and not from the RAM.

int getDistance(int mV)

{

if( mV > interval * TABLE_ENTRIES )

return getTableEntry(TABLE_ENTRIES-1); // the minimum distance

else

{

int index = mV / interval;

float frac = (mV % 250) / (float)interval;

return getTableEntry(index) - ((getTableEntry(index) -

getTableEntry(index+1)) * frac);

}

}

Saving and Fetching Strings Using the Program Memory

Another element in coding that eats up RAM greedily is strings. To conserve memory space, we will move the string constants being used in the sketch program to be stored in the system’s program memory.

The sketch shown below generates a string directly in the flash memory (program memory) of the Arduino board. When the code is executed, the strings are fetched from the program memory and the resulting text is displayed in the IDE’s serial monitor. In addition, the sketch also has code that tells the free RAM available in the system for use;

#include <avr/pgmspace.h> // for progmem

//create a string of 20 characters in progmem

const prog_uchar myText[] = "arduino duemilanove ";

void setup()

{

Serial.begin(9600);

}

void loop()

{

Serial.print(memoryFree()); // print the free memory

Serial.print(' '); // print a space

printP(myText); // print the string

delay(1000);

}

// function to print a PROGMEM string

void printP(const prog_uchar *str)

{

char c;

while((c = pgm_read_byte(str++)))

Serial.print(c,BYTE);

}

// variables created by the build process when compiling the sketch

extern int __bss_end;

extern void *__brkval;

// function to return the amount of free RAM

int memoryFree()

{

int freeValue;

if((int)__brkval == 0)

freeValue = ((int)&freeValue) - ((int)&__bss_end);

else

freeValue = ((int)&freeValue) - ((int)__brkval);

return freeValue;

}

Each character in a string takes up about one byte of memory space and thus, a large number of strings can easily gobble up a system’s RAM very easily. We used the same ‘PROGMEM ’ expression to move the string constants to the system’s program memory just as how we used it to move numeric constants in the previous section. To use this function, we need to include the header file which includes the corresponding definitions.

#include <avr/pgmspace.h> // for progmem

Strings that are being declared in the system’s program memory have a slightly different syntax which is as follows;

const prog_uchar myText[] = "arduino duemilanove "; //a string of 20 characters

in progmem

We can also leverage the functionality of preprocessors when declaring the strings. This not only creates all of the strings before the code in the program even starts executing. Moreover, the syntax used for declaring strings by using preprocessors is easier and simpler as shown below;

#define P(name) const prog_uchar name[] PROGMEM // declare a PROGMEM string

Once the declaration has been done using the syntax shown above, all we have to do is use a short-expression ‘P(name) ’ and it will be automatically be replaced by the entire string it is linked to.

P(myTextP) = "arduino duemilanove "; //a string of 20 characters in progmem

Now let’s compare this approach to using the standard way of declaring and storing strings in the system RAM.

char myText[] = "arduino duemilanove "; //a string of 20 characters

void setup()

{

Serial.begin(9600);

}

void loop()

{

Serial.print(memoryFree()); // print the free memory

Serial.print(' '); // print a space

Serial.print(myText); // print the string

delay(1000);

}

Upon executing this block of code, the ‘memoryFree()’ function will tell us that we only have a total of 20 bytes of free RAM space.

Optimizing Constant Values

This section will discuss an optimization technique that will help reduce the memory usage of integer values. This is done by utilizing the ‘#define ’ and ‘const ’ expressions to tell the compiler the values are to be interpreted as constants. Once the values are interpreted as constants, they can be declared in multiple ways choosing the one that fits the situation the best.

Here's an example showing how to declare integer values as constant by using the ‘const ’ argument.

const int ledPin=13;

If we were to declare the value traditionally, it would be like this;

int ledPin=13;

Generally, it is recommended to use constant values wherever possible instead of just using standard integer values. Moreover, using references is also a really good practice because you might need to change the value of the integer at some point in program development. Then you will have to arduously look through the entire source code and figure out the values that also need to be adjusted when making such a change.

Three distinct approaches can define a constant integer value and each approach has been demonstrated below;

int ledPin = 13; // a variable, but this wastes RAM

const int ledPin = 13; // a const does not use RAM

#define ledPin 13 // using a #define

// the preprocessor replaces ledPin with 13

pinMode(ledPin, OUTPUT);

By looking at this block, you will notice that the first two approaches are quite similar at first glance but that’s not the case at all. In the first method, we are declaring the integer as a standard variable. Since this variable can be changed at any point in the code execution, a piece of memory is reserved in the RAM for it. In the second method, we are using the ‘const ’ argument to declare the integer as a constant variable. In this case, since the variable’s value is constant, this means that the value will not change during code execution, thus the compiler doesn’t need to reserve space for this variable in the system RAM.

Memory Handling through Conditional Compilation

There are cases when programmers keep multiple versions of the same source code for different purposes. For instance, the source code used for debugging will be a different version as compared to the source code being executed as a program on the Arduino board. Similarly, some programmers even create different versions of the same sketch program to ensure that their program is compatible with different Arduino boards (since each Arduino board has slightly different specifications, like system memory, processor speed, etc.). This is an advanced practice that helps developers a lot throughout their program’s developmental stages and debugging stages as well.

To make this possible, we use conditionals during the compilation process. These conditionals mainly act on the compiler’s preprocessor and directly interfere with how the compiler builds the sketch program. Thus, we can manipulate the way the program is built.

Let’s take a look at a sketch example. The example you are about to see is strictly compatible with only Arduino boards that have been released after version ‘0018.’ In other words, boards of versions ‘0018’ and older will not support this sketch.

#if ARDUINO > 18

#include <SPI.h> // needed for Arduino versions later than 0018

#endif

Let’s now look at the sketch example which will use the ‘if’ conditional statement to determine if we want to use the program for debugging purposes. If the conditional is true, then the ‘DEBUG ’ function defined in the header file will be executed.

/*

Pot_Debug sketch

blink an LED at a rate set by the position of a potentiometer

Uses Serial port for debug if DEBUG is defined

*/

const int potPin = 0; // select the input pin for the potentiometer

const int ledPin = 13; // select the pin for the LED

int val = 0; // variable to store the value coming from the sensor

#define DEBUG

void setup()

{

Serial.begin(9600);

pinMode(ledPin, OUTPUT); // declare the ledPin as an OUTPUT

}

void loop() {

val = analogRead(potPin); // read the voltage on the pot

digitalWrite(ledPin, HIGH); // turn the ledPin on

delay(val); // blink rate set by pot value

digitalWrite(ledPin, LOW); // turn the ledPin off

delay(val); // turn LED off for same period as it was turned on

#if defined DEBUG

Serial.println(val);

#endif

}

Conclusion

We have now finally concluded our journey of exploring the world of Arduino. Along the way, we have discovered many important methods and techniques that advanced programmers use as their daily practice. It is very important to polish your skills and use what you learned to understand the concepts even more intricately. Just reading alone is not enough. Just as how we demonstrated a practical example in every important chapter, similarly, the reader is encouraged to practice whatever technique they have learned along the way. The book is designed so that each chapter builds upon the concepts explained in the preceding chapters. Hence, if the reader does not properly pick up the crucial concepts in the beginning chapters, the upcoming chapters will be very hard to grasp, especially the practical portions.

We have gone through many coding techniques, methods, and practices that are both advance and easy to use. We have learned how to effectively manipulate strings in Arduino, use LCDs and Motion sensors, use components like Infrared Sensors to detect the intensity of the light, and control the blinking accordingly and this is just the tip of the iceberg. This book is jam-packed with coding concepts and practical illustrations. We hope that the reader found this book useful and learned a lot from it.

References

1). Mastering Arduino by author Jon Hoffman

2). Arduino Cookbook by author Michael Margolis; ISBN: 978-0-596-80247-9

Table of Contents

ARDUINO PROGRAMMINGA Comprehensive Beginner's Guide to learn the Realms of Arduino from A-Z

ARDUINO PROGRAMMINGA Comprehensive Beginner's Guide to learn the Realms of Arduino from A-Z

Introduction

Where Do I Find a Microcontroller?

Arduino

Know the Hardware

Chapter 1: Basic Concepts of Arduino

Chapter 1: Basic Concepts of Arduino

Physical Computing

Open Source Hardware

Free Software

Arduino

Processing

Fritzing

Chapter 2: Electronics

Chapter 2: Electronics

Concept of Electronics

Voltage

Electric Current

Direct Current

Alternate Current

Resistance

Ohm's Law

Electronic Systems

Summary of Electronic Systems

Electronic Signals

Voltage Divider

Analog to Digital Converter

PWM Pulse Width Modulation

Serial Communication

Chapter 3: Electronic Components

Chapter 3: Electronic Components

Microcontroller

Protoboard

Resistor

Thermistor

Diode

Transistor

Capacitor

LED

RGB LED

LCD

Button

Reed Switch

Potentiometer

Photocell

Piezoelectric Transducer

DC Motor

Relay

Chapter 4: Arduino Programming

Chapter 4: Arduino Programming

The Arduino Project

Arduino IDE for Windows

Arduino IDE for Linux

Programming

Programming Language

Algorithm

Arduino Software

Sketches

Serial Monitor

Arduino Library

Programming Arduino

Digital Functions

Analog Functions

Chapter 5: Starter Kit with Arduino Uno R3

Chapter 5: Starter Kit with Arduino Uno R3

Lessons

Button

Serial Reading of a Digital Input

Serial Reading of an Analog Input

Command with Serial Communication

Fade

Loop

LDR Sensor

Thermistor

DC Motor

LCD

Typing into the LCD

Piezo as Analog Output

Scroll Bar with Processing

Arduino - Thermostat

Chapter 6: If Statement with Arduino, Control the Execution of your Code

Chapter 6: If Statement with Arduino, Control the Execution of your Code

If with Arduino - Necessary Material

Syntax of the if Statement with Arduino

Comparison Operators in if Statements with Arduino

Example if Statement with Arduino

Boolean Operators if with Arduino

if-else with Arduino

Example if-else statement with Arduino

else if with Arduino

Example else if statement with Arduino

Chapter 7: Battery and Battery Charge Meter with Arduino

Chapter 7: Battery and Battery Charge Meter with Arduino

The Objective of the Battery and Battery Charge Meter with the Arduino Board

Arduino Components that We Will Use

Riding the Circuit with Arduino

Programming the Battery and Battery Charge Meter with Arduino

Arduino Native Code

Chapter 8: ADS1115 ADC Digital-Analog Converter for Arduino and ESP8266

Chapter 8: ADS1115 ADC Digital-Analog Converter for Arduino and ESP8266

What is a Digital-Analog Converter?

What is an ADS1115?

Install Library for ADS1115

Single-End Mode Programming

Differential Mode

Differential Mode Programming

Comparator Mode

Chapter 9: Arduino Interruptions

Chapter 9: Arduino Interruptions

Practical Example: Controlling the Speed of Fantastic Car Lights

Conclusion

References

ARDUINO PROGRAMMINGTip and Tricks to Learn Arduino Programming Efficiently

ARDUINO PROGRAMMINGTip and Tricks to Learn Arduino Programming Efficiently

Introduction

What is Arduino?

Advantages of Arduino

Arduino - Choosing a Hardware Platform

Equipment Arduino UNO R3

Clones, or Arduino (un) Original

Materials you need to program Arduino

Arduino IDE Installation

What happens when you install the wrong IDE?

If you already have Arduino

Chapter 1: Basic Concepts of Programming

Chapter 1: Basic Concepts of Programming

Conversions

Decimal <-> Binary

Binary <-> Hexadecimal

Decimal <-> Hexadecimal

QUICK Method

The Software

Installation

Downloading

Windows

Mac Os

Under Linux

Software Interface Software Launch

Correspondence

Approach and Use of the Software

The File Menu

Buttons

Equipment

Presentation of the Card

Constitution of the Card

Materials

Visualization

Connectivity

Installation

Windows

Test your Equipment

The Arduino Language (1/2)

Language syntax

The Minimum Code

Function

The Instructions

The Braces

Comments

Accents

The Variables

What is a Variable?

A Variable is a Number

The Name of a Variable

Define a Variable

Code: C

The Arduino Language (2/2)

What is a Loop?

The do... while loop

Concatenation

The Functions

What is a Function?

Make a Function

But what is "Void"?

Empty Functions

The "Typed" Functions

Functions with Parameters

What is going on?

The Tables

What's the Point?

The Maximum Score

Average Calculation

Chapter 2: Input / Output Management

Chapter 2: Input / Output Management

Our First Program

But how do you calculate this resistance?

Where do we start?

Create A New Project

What does "HIGH Value or LOW Value" Mean?

Use the Command

The Program

Millis () Function

Limits of the Delay () Function

Chapter 3: Programming With Arduino

Chapter 3: Programming With Arduino

The Basic Structure of a Sketch

1. Variables to Name

2. Setup (essential in the program)

3. Loop (essential in the program)

Instructions

A Flashing LED

Circuit

The Change Indicators

Sketch:

An LED Pulsing Leave

Sketch:

Simultaneous Lighting and Sound

Sketch:

Activate a LED Touch of a Button

Sketch:

An RGB LED Drive

Sketch 1:

Sketch 2:

The Motion

Sketch:

Read Brightness Sensor

Read Voltages

The "Serial Monitor"

Sketch:

Knobs

Sketch:

Measure Temperatures

Sketch:

Measure Distance

Code:

Enhancements: Reversing Warning

Infrared Remote Control for Controlling Arduino Microcontrollers

Code:

Servo Drive

Code:

LCD Display

Code:

Relay Card

Code:

Stepper Motor

Cabling

Code

Code:

Drop Sensor

Code:

RFID Kit

Read an RFID tag with Arduino and Process the Data

Preparation - the first sketch with the RFID READER

RFID Sketch 2

Sketch 3

Chapter 4: Accessories for Arduino

Chapter 4: Accessories for Arduino

Keypad Shield

Code:

Instructions for LCD Display with I2C Port

Program

Sketch:

Example of use:

Two I²C Displays

Arduino RTC

Cabling:

Extension:

Keypad

The Sketch:

Keypad - Castle

Color Sensor

Cabling:

Generate Tones

Code:

Create Melodies

Arduino Tilt Sensor SW-520D

The Sketch:

Temperature Measured with the LM35

Expansion of the Program:

Code:

Measure the Voltage

Cabling:

We now come to the code:

Four-Digit 7-Segment Display

Programming

Code:

Conclusion

References

ARDUINO PROGRAMMINGAdvanced Methods and Strategies to Learn Arduino Programming

ARDUINO PROGRAMMINGAdvanced Methods and Strategies to Learn Arduino Programming

Introduction

Chapter 1: Setting Up the Tools

Chapter 1: Setting Up the Tools

The Arduino Software

Arduino Hardware

Setting Up The Arduino IDE

Working with Arduino

Chapter 2: The Basics of Arduino Programming

Chapter 2: The Basics of Arduino Programming

Curly Bracket

Semicolons

Comments

Variables

Datatype

Boolean

Byte

Integer

Long

Double and Float

Character

Arrays

Character Arrays

Constants

Arithmetic Functions

Comparison Operators

Logical Operators

Casting

Decision Making

Looping

Functions

Chapter 3: The Advanced Concepts of Arduino Programming

Chapter 3: The Advanced Concepts of Arduino Programming

Setting Digital Pin Mode

Digital Write

Digital Read

Analog Read

Structures

Unions

Adding Tabs

Working with Tabs

Object-Oriented Programming

String Library

Arduino Motion Sensor Project

Arduino LCD Display Project

Chapter 4: Structuring and Arduino Programming

Chapter 4: Structuring and Arduino Programming

Structuring and Arduino Program

Using Standard Variable Types

Floating- Point Numbers

Working with Groups of Values

Using Strings in Arduino

Using Strings of C Programming Language

Splitting Comma- Separated Text into Groups

Converting a Number to a String

Converting a String to a Number

Transforming the Lines of Code into Blocks

Returning More Than One Value from a Function

Chapter 5: Coding and Memory Handling

Chapter 5: Coding and Memory Handling

Using the Libraries

Installing Additional Libraries

Modifying Libraries

Creating a Library

Creating Libraries from Other Libraries

Memory Handling

Saving and Fetching Numeric Values from Program Memory

Saving and Fetching Strings Using the Program Memory

Conclusion

References