ALCOHOL SENSOR

MQ3 is one of the most commonly used sensors in the MQ sensor series. It is a
Metal Oxide Semiconductor (MOS) type of sensor. Metal oxide sensors are
also known as Chemiresistors, because sensing is based on the change of
resistance of the sensing material when exposed to alcohol. So by placing it in
a simple voltage divider network, alcohol concentrations can be detected.

MQ3 alcohol sensor works on 5V DC and draws around 800mW. It can detect
Alcohol concentrations anywhere from 25 to 500 ppm.

When measuring gases, the term concentration is used to describe the amount
of gas by volume in the air. The two most common units of measurement are
parts-per-million, and percent concentration.

Parts-per-million (abbreviated ppm) is the ratio of one gas to another. For

example, 500ppm of alcohol means that if you could count a million gas
molecules, 500 of them would be of alcohol and 999500 molecules would be
some other gases.
MQ3 is a heater-driven sensor. That’s why it is enclosed in two layers of fine
stainless steel mesh called an Anti-explosion network. It ensures that heater
element inside the sensor will not cause an explosion, as we are sensing
flammable gas (alcohol). It also provides protection for the sensor and filters
out suspended particles so that only gaseous elements are able to pass inside
the chamber.

This is what the sensor looks like when outer mesh is removed.
The star-shaped structure is formed by the sensing element and six connecting
legs that extend beyond the Bakelite base. Out of six, two leads (H) are
responsible for heating the sensing element and are connected via a Nickel-
Chromium coil ( a well known conductive alloy).

The remaining four leads (A & B) responsible for output signals are connected
using Platinum Wires. These wires are connected to the body of the sensing
element and convey small changes in the current that passes through the
sensing element

The tubular sensing element is made up of Aluminum Oxide (AL2O3) based

ceramic and has a coating of Tin Dioxide (SnO2). The Tin Dioxide is the most
important material being sensitive towards alcohol. However, the ceramic
substrate only increases the heating efficiency and ensures that the sensor
area is continuously heated to the working temperature.
So, to summarize, the Nickel-Chromium coil and Aluminum Oxide based
ceramic forms a Heating System; while Platinum wires and coating of Tin
Dioxide forms a Sensing System.

How MQ3 Alcohol Sensor Works?

When SnO2 semiconductor layer is heated at high temperature, oxygen is

adsorbed on the surface. In clean air, electrons from the conduction band in tin
dioxide are attracted to oxygen molecules. This form an electron depletion
layer just below the surface of SnO2 particles and forms a potential barrier. As
a result, the SnO2 film becomes highly resistive and prevents electric current
flow.

In the presence of alcohol, however, the surface density of adsorbed oxygen

decreases as it reacts with the alcohols; which lowers the potential barrier.
Electrons are then released into the tin dioxide, allowing current to flow freely
through the sensor.
MQ3 Alcohol Sensor Module Hardware Overview

Since the MQ3 alcohol sensor is not breadboard compatible, we recommend

this handy little breakout board. It’s very easy to use and comes with two
different outputs. It not only provides a binary indication of the presence of
alcohol but also an analog representation of its concentration in air.

The analog output voltage provided by the sensor (at AO pin) varies in
proportion to the alcohol concentration. The higher the alcohol concentration
in the air, the higher the output voltage; Whereas lower concentration gives
lower output voltage. The following animation shows the relationship between
alcohol concentration and output voltage.

The same analog signal is fed to a LM393 High Precision Comparator to digitize
it and is made available at the Digital Output (DO) pin.
The module has a built-in potentiometer for adjusting the sensitivity of the
digital output (DO). You can use it to set a threshold; so that when the alcohol
concentration exceeds the threshold value, the module will output LOW
otherwise HIGH.

This setup is very useful when you want to trigger an action when certain
threshold is reached. For example, when the alcohol concentration in the
breath exceed a threshold, you can tell if someone is drunk.

Apart from this, the module has two LEDs. The Power LED will light up when
the module is powered. The Status LED will light up when the digital output
goes LOW.
MQ3 Alcohol Sensor Module Pinout

VCC supplies power for the module. You can connect it to 5V output from your
Arduino.

GND is the Ground Pin and needs to be connected to GND pin on the Arduino.

D0 provides a digital representation of the presence of alcohol.

A0 provides analog output voltage in proportional to the concentration of

alcohol.
BUZZER

A buzzer is a small yet efficient component to add sound features to our

project/system. It is very small and compact 2-pin structure hence can be
easily used on breadboard, and even on PCBs which makes this a widely used
component in most electronic applications.

There are two types are buzzers that are commonly available. The one shown
here is a simple buzzer which when powered will make a Continuous
Beeeeeeppp.... sound, the other type is called a readymade buzzer which will
look bulkier than this and will produce a Beep. Beep. Beep. Sound due to the
internal oscillating circuit present inside it. But, the one shown here is most
widely used because it can be customized with help of other circuits to fit
easily in our application.

This buzzer can be used by simply powering it using a DC power supply ranging
from 4V to 9V. A simple 9V battery can also be used, but it is recommended to
use a regulated +5V or +6V DC supply. The buzzer is normally associated with a
switching circuit to turn ON or turn OFF the buzzer at required time and
require interval.
 ARDUINO

Arduino is a tool for making computers that can sense and control more of the physical world

than your desktop computer. It's an open-source physical computing platform based on a

simple microcontroller board, and a development environment for writing software for the

board.

Arduino can be used to develop interactive objects, taking inputs from a variety of switches

or sensors, and controlling a variety of lights, motors, and other physical outputs. Arduino

projects can be stand-alone, or they can be communicate with software running on your

computer (e.g. Flash, Processing, MaxMSP.) The boards can be assembled by hand or

purchased preassembled; the open-source IDE can be downloaded for free.

The Arduino programming language is an implementation of Wiring, a similar physical

computing platform, which is based on the Processing multimedia programming

environment.

Why Arduino?

Arduino simplifies the process of working with microcontrollers, but it offers some

advantage for teachers, students, and interested amateurs over other systems:

 Inexpensive - Arduino boards are relatively inexpensive compared to other

microcontroller platforms. The least expensive version of the Arduino module can be

assembled by hand, and even the pre-assembled Arduino modules cost less than $80

 Cross-platform - The Arduino software runs on Windows, Macintosh OSX, and Linux

operating systems. Most microcontroller systems are limited to Windows.

  Simple, clear programming environment - The Arduino programming environment is

easy-to-use for beginners, yet flexible enough for advanced users to take advantage of

as well. For teachers, it's conveniently based on the Processing programming

environment, so students learning to program in that environment will be familiar

with the look and feel of Arduino

 Open source and extensible software- The Arduino software is published as open

source tools, available for extension by experienced programmers. The language can

be expanded through C++ libraries, and people wanting to understand the technical

details can make the leap from Arduino to the AVR C programming language on

which it's based. SImilarly, you can add AVR-C code directly into your Arduino

programs if you want to.

 Open source and extensible hardware - The Arduino is based on Atmel's ATMEGA8

and ATMEGA168 microcontrollers. The plans for the modules are published under a

Creative Commons license, so experienced circuit designers can make their own

version of the module, extending it and improving it. Even relatively inexperienced

users can build the breadboard version of the module in order to understand how it

works and save money.

Some people think of the entire Arduino board as a microcontroller, but this is inaccurate.

The Arduino board actually is a specially designed circuit board for programming and

prototyping with Atmel microcontrollers.

The nice thing about the Arduino board is that it is relatively cheap, plugs straight into a

computer's USB port, and it is dead-simple to setup and use (compared to other development

boards).
The Arduino board exposes most of the microcontroller's I/O pins for use by other circuits.

The Diecimila, Duemilanove, and current Uno provide 14 digital I/O pins, six of which can

produce pulse-width modulated signals, and six analog inputs. These pins are on the top of

the board, via female 0.10-inch (2.5 mm) headers. Several plug-in application shields are also

commercially available.

The Arduino Nano, and Arduino-compatible Bare Bones Board and Boarduino boards may

provide male header pins on the underside of the board to be plugged into solderless

breadboards.

Official boards

The original Arduino hardware is manufactured by the Italian company Smart Projects. Some

Arduino-branded boards have been designed by the American company SparkFun

Electronics. Sixteen versions of the Arduino hardware have been commercially produced to

date.

Example of different Arduino boards

 Arduino Diecimila

 Arduino Duemilanove

 Arduino UNO

 Arduino Leonardo

 Arduino Mega

 Arduino Mega ADK

 Arduino Nano

 Arduino Pro-Mini
 ARDUINO UNO

The Arduino Uno is a AVR microcontroller board based on the ATmega328 . It

has 14 digital input/output pins (of which 6 can be used as PWM outputs), 6

analog inputs, a 16 MHz ceramic resonator, a USB connection, a power jack, an

ICSP header, and a reset button. It contains everything needed to support the

microcontroller; simply connect it to a computer with a USB cable or power it

with a AC-to-DC adapter or battery to get started. The Uno differs from all

preceding boards in that it does not use the FTDI USB-to-serial driver chip.

Instead, it features the Atmega16U2 (Atmega8U2 up to version R2)

programmed as a USB-to-serial converter.

Version 3 Uno board has the following new features:

 1.0 pinout: added SDA and SCL pins that are near to the AREF pin and

two other new pins placed near to the RESET pin, the IOREF that allow

the shields to adapt to the voltage provided from the board. In future,

shields will be compatible with both the board that uses the AVR, which

operates with 5V and with the Arduino Due that operates with 3.3V. The

second one is a not connected pin, that is reserved for future purposes.

 Stronger RESET circuit.

 Atmega 16U2 replace the 8U2.

"Uno" means one in Italian and is named to mark the upcoming release of

Arduino 1.0. The Uno and version 1.0 will be the reference versions of Arduino,

moving forward. The Uno is the latest in a series of USB Arduino boards, and

the reference model for the Arduino platform; for a comparison with previous

versions, see the index of Arduino boards.

Microcontroller ATmega328

Operating Voltage 5V

Input Voltage (recommended) 7-12V

Input Voltage (limits) 6-20V

Digital I/O Pins 14 (of which 6 provide PWM output)

Analog Input Pins 6

DC Current per I/O Pin 40 mA

DC Current for 3.3V Pin 50 mA

32 KB (ATmega328) of which 0.5 KB

Flash Memory
used by bootloader

SRAM 2 KB (ATmega328)

EEPROM 1 KB (ATmega328)

Clock Speed 16 MHz

Power

The Arduino Uno can be powered via the USB connection or with an external

power supply. The power source is selected automatically.

External (non-USB) power can come either from an AC-to-DC adapter (wall-

wart) or battery. The adapter can be connected by plugging a 2.1mm center-

positive plug into the board's power jack. Leads from a battery can be inserted

in the Gnd and Vin pin headers of the POWER connector.

The board can operate on an external supply of 6 to 20 volts. If supplied with

less than 7V, however, the 5V pin may supply less than five volts and the board

may be unstable. If using more than 12V, the voltage regulator may overheat

and damage the board. The recommended range is 7 to 12 volts.

The power pins are as follows:

 VIN. The input voltage to the Arduino board when it's using an external

power source (as opposed to 5 volts from the USB connection or other

regulated power source). You can supply voltage through this pin, or, if

supplying voltage via the power jack, access it through this pin.

 5V.This pin outputs a regulated 5V from the regulator on the board. The

board can be supplied with power either from the DC power jack (7 -

12V), the USB connector (5V), or the VIN pin of the board (7-12V).

Supplying voltage via the 5V or 3.3V pins bypasses the regulator, and can

damage your board. We don't advise it.

 3V3. A 3.3 volt supply generated by the on-board regulator. Maximum

current draw is 50 mA.

 GND. Ground pins.

 IOREF. This pin on the Arduino board provides the voltage reference

with which the microcontroller operates. A properly configured shield

can read the IOREF pin voltage and select the appropriate power source
 or enable voltage translators on the outputs for working with the 5V or

3.3V.

Memory

The ATmega328 has 32 KB (with 0.5 KB used for the bootloader). It also has 2

KB of SRAM and 1 KB of EEPROM (which can be read and written with the

EEPROM library).

Input and Output

Each of the 14 digital pins on the Uno can be used as an input or output, using

pinMode(), digitalWrite(), and digitalRead() functions. They operate at 5 volts.

Each pin can provide or receive a maximum of 40 mA and has an internal pull-

up resistor (disconnected by default) of 20-50 kOhms. In addition, some pins

have specialized functions:

 Serial: 0 (RX) and 1 (TX). Used to receive (RX) and transmit (TX) TTL

serial data. These pins are connected to the corresponding pins of the

ATmega8U2 USB-to-TTL Serial chip.

 External Interrupts: 2 and 3. These pins can be configured to trigger an

interrupt on a low value, a rising or falling edge, or a change in value. See

the attachInterrupt() function for details.

 PWM: 3, 5, 6, 9, 10, and 11. Provide 8-bit PWM output with the

analogWrite() function.
  SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). These pins support SPI

communication using the SPI library.

 LED: 13. There is a built-in LED connected to digital pin 13. When the

pin is HIGH value, the LED is on, when the pin is LOW, it's off.

The Uno has 6 analog inputs, labeled A0 through A5, each of which provide 10

bits of resolution (i.e. 1024 different values). By default they measure from

ground to 5 volts, though is it possible to change the upper end of their range

using the AREF pin and the analogReference() function. Additionally, some

pins have specialized functionality:

 TWI: A4 or SDA pin and A5 or SCL pin. Support TWI communication

using the Wire library.

There are a couple of other pins on the board:

 AREF. Reference voltage for the analog inputs. Used with

analogReference().

 Reset. Bring this line LOW to reset the microcontroller. Typically used to

add a reset button to shields which block the one on the board.

See also the mapping between Arduino pins and ATmega328 ports. The

mapping for the Atmega8, 168, and 328 is identical.

Communication
The Arduino Uno has a number of facilities for communicating with a

computer, another Arduino, or other microcontrollers. The ATmega328

provides UART TTL (5V) serial communication, which is available on digital

pins 0 (RX) and 1 (TX). An ATmega16U2 on the board channels this serial

communication over USB and appears as a virtual com port to software on the

computer. The '16U2 firmware uses the standard USB COM drivers, and no

external driver is needed. However, on Windows, a .inf file is required. The

Arduino software includes a serial monitor which allows simple textual data to

be sent to and from the Arduino board. The RX and TX LEDs on the board will

flash when data is being transmitted via the USB-to-serial chip and USB

connection to the computer (but not for serial communication on pins 0 and 1).

A Software Serial library allows for serial communication on any of the Uno's

digital pins. The ATmega328 also supports I2C (TWI) and SPI communication.

The Arduino software includes a Wire library to simplify use of the I2C bus; see

the documentation for details. For SPI communication, use the SPI library.

Programming

The Arduino Uno can be programmed with the Arduino software (download).

Select "Arduino Uno from the Tools > Board menu (according to the

microcontroller on your board). For details, see the reference and tutorials.
The ATmega328 on the Arduino Uno comes preburned with a bootloader that

allows you to upload new code to it without the use of an external hardware

programmer. It communicates using the original STK500 protocol (reference, C

header files).

You can also bypass the bootloader and program the microcontroller through

the ICSP (In-Circuit Serial Programming) header; see these instructions for

details.

The ATmega16U2 (or 8U2 in the rev1 and rev2 boards) firmware source code

is available . The ATmega16U2/8U2 is loaded with a DFU bootloader, which

can be activated by:

USB Over current Protection

The Arduino Uno has a resettable polyfuse that protects your computer's USB

ports from shorts and overcurrent. Although most computers provide their own

internal protection, the fuse provides an extra layer of protection. If more than

500 mA is applied to the USB port, the fuse will automatically break the

connection until the short or overload is removed.

ATmega328 Microcontroller

ATmega328 is a low-power CMOS 8-bit microcontroller based on the AVR

enhanced RISC architecture. By executing powerful instructions in a single

clock cycle, the ATmega328 achieves throughputs approaching 1 MIPS per

MHz allowing the system designed to optimize power consumption versus

processing speed.

16X2 LCD:

A Liquid Crystal Display (LCD) is a low cost, low-power device

capable of displaying text and images. LCDs are extremely common in

embedded systems, since such systems often do not have video monitors like
those that come standard with desktop systems. It can be found in numerous

common devices like watches, fax and copy, machines and calculators.

Pin configuration of LCD

LCD pin descriptions:

VDD (Pin2), VSS(Pin1):

VDD and VSS provide +5v and ground, respectively.

VO (Pin3):

VO is used for controlling LCD contrast.

Register Select (RS)(Pin4):

There are two very important registers inside the LCD. The RS pin is used for

their selection as follows. If RS=0, the instruction command code register is

selected, allowing the user to send a command such as clear display, cursor at

home, etc. If RS=1 the data register is selected, allowing the user to send data to

be displayed on the LCD.

Read/Write(R/#W)(Pin5):

R/#W input allows the user to write information to the LCD or reads

information from it. R/W=1 when reading; R/W=0 when writing.

Enable (E)(Pin6):

The Enable pin is used by the LCD to latch an information presented to its data

pins When data is supplied to data pins, a high –to-low pulse must be applied to

this pin in order for the LCD to latch in the data present at the data pins. This

pulse must be a minimum of 450ns wide.

DO-D7 (Pin 7 to 14):

The 8-bit Data pins, D0-D7, are used to send information to the LCD or to read

the contents of the LCD’s internal registers. To display letters and numbers,

send ASCII codes of the letters A-Z, a-z, and numbers 0-9 to these pins while

RS=1.

Back Light LED (Pin15, 16):

LCD has Light Emitting Diode (LED) in the backside to illuminate its panel.

Back Light LED

Table : Pin Description of LCD

Table : LCD Command Codes

The HD44780U dot-matrix Liquid Crystal Display controller and driver LSI

displays alphanumeric, and symbols. It can be configured to drive a dot-matrix

liquid crystal display under the control of a 4- or 8-bit microprocessor. Since all

the functions such as display RAM, character generator, and liquid crystal

driver, required for driving a dot-matrix liquid crystal display are internally

provided on one chip, a minimal system can be interfaced with this

controller/driver.

A single HD44780U can display up to one 8-character line or two 8-character

lines.The HD44780U has pin function compatibility with the HD44780S which

allows the user to easily replace an LCD-II with an HD44780U. The

HD44780U character generator ROM is extended to generate 208 5 × 8 dot

character fonts and 32 5 × 10 dot character fonts for a total of 240 different

character fonts.

The low power supply (2.7V to 5.5V) of the HD44780U is suitable for any

portable battery-driven product requiring low power dissipation.

ESP8266

The ESP8266 is a low-cost Wi-Fi microchip with full TCP/IP stack and

microcontroller capability produced by Shanghai-based Chinese manufacturer,

Espressif Systems. The chip first came to the attention of western makers in

August 2014 with the ESP-01 module, made by a third-party manufacturer, Ai-

Thinker. This small module allows microcontrollers to connect to a Wi-Fi

network and make simple TCP/IP connections.

ESP8266 delivers highly integrated Wi-Fi SoC solution to meet users’

continuous demands for efficient power usage, compact design and reliable

performance in the Internet of Things industry. With the complete and self-

contained Wi-Fi networking capabilities, ESP8266 can perform either as a

standalone application or as the slave to a host MCU. When ESP8266 hosts the

application, it promptly boots up from the flash. The integrated high-speed

cache helps to increase the system performance and optimize the system

memory.

Also, ESP8266 can be applied to any microcontroller design as a Wi-Fi adaptor

through SPI / SDIO or I2C / UART interfaces. ESP8266EX integrates antenna

switches, RF balun, power amplifier, low noise receive amplifier, filters and
power management modules. The compact design minimizes the PCB size and

requires minimal external circuitries

ESP8266EX implements TCP/IP, the full 802.11 b/g/n WLAN MAC protocol

and Wi-Fi Direct specification. It supports not only basic service set (BSS)

operations under the distributed control function (DCF) but also P2P group

operation compliant with the latest Wi-Fi P2P protocol. Low level protocol

functions are handled automatically by ESP8266EX.

Features

 Processor: L106 32-bit RISC microprocessor core based on the Tensilica

Xtensa Diamond Standard 106Micro running at 80 MHz

 Memory:

o 32 KB instruction RAM

o 32 KB instruction cache RAM

o 80 KB user data RAM

o 16 KB ETS system data RAM

 External QSPI flash: up to 16 MB is supported (512 KB to 4 MB

typically included)

 IEEE 802.11 b/g/n Wi-Fi

o Integrated TR switch, balun, LNA, power amplifier and matching

network
 o WEP or WPA/WPA2 authentication, or open networks

 16 GPIO pins

 SPI

 I²C (software implementation)

 I²S interfaces with DMA (sharing pins with GPIO)

 UART on dedicated pins, plus a transmit-only UART can be enabled on

GPIO2

 10-bit ADC
Applications
• Home appliances

• Home automation

• Smart plugs and lights

• Mesh network

• Industrial wireless control

• Baby monitors

• IP cameras

• Sensor networks

• Wearable electronics

• Wi-Fi location-aware devices

• Security ID tags

• Wi-Fi position system beacons

 Arduino Sketch IDE
The Sketch IDE (Integrated Development Environment) is a special program

running on your computer that allows you to write sketches for the Arduino

board in a simple language modelled after the Processing language. The magic

happens when you press the button that uploads the sketch to the board: the

code that you have written is translated into the C language, and is passed to the

AVR-GCC compiler, an important piece of open source software that makes the

final translation into the language understood by the microcontroller. This last

step is quite important, because it’s where Arduino makes your life simple by

hiding away as much as possible of the complexities of programming

microcontrollers.

The programming cycle on Arduino is basically as follows:

 Plug your board into a USB port on your computer.

 Write a sketch that will bring the board to life.

 Upload this sketch to the board through the USB connection and wait a

couple of seconds for the board to restart.

 The board executes the sketch that you wrote.

The idea of sketching in code is a way of thinking about writing code as a

simple intuitive process, just like drawing in a sketchbook. In this way, an

Arduino program is called a sketch and is saved in a folder called a sketchbook.

Sketching means we can get our hands dirty and quickly try out a new idea. It is

a skill available to all of us.

 Installing the Software

First things first, you need to download and install the Arduino software.

Because the Arduino Team is always making updates to the software, you

should head to the main download page on the Arduino web site

(https://www.arduino.cc/en/Main/Software), shown in Figure below

From here download and install the latest version of the software for your

particular operating system. Full installation instructions are available on the

Getting Started page at http://arduino.cc/en/ Guide/HomePage.

 Connecting the Arduino

With the software installed, you should be able to connect your Arduino to the

USB port on your computer using an A-B USB cable. The Arduino’s power

indicator LED will light up on the board, letting us know that it has power and

is ready to go. With a brand-new Arduino Uno, the first time that it powers up,

the pin 13 LED marked L will begin to blink rapidly, letting us know that the

board has been fully tested. On Windows-based PCs or older Arduino boards, it

is necessary to install a driver for the Arduino’s onboard USB to Serial

convertor, as shown in Figure below.

 Opening a Sketch

Now you can launch the Arduino development environment. This will bring up

an empty window if this is your first time out. Open an example sketch by
navigating to the File menu ➤Examples ➤1.Basics and select the sketch

named Blink, as shown in Figure1-10. You should now see a very simple

example sketch for blinking the onboard LED once every second.

Selecting the Board and Serial Port Before we can upload our sample sketch, we

need to select the correct board type and serial port that the board is attached to

on our computer. Setting the correct board can be done in the Tools ➤Board

menu

by selecting Arduino Uno or one of the other corresponding board names, as

shown in Figure below.

Next, we need to choose the correct serial port under the Tools ➤Serial Port

menu, as shown in Figure 1-12. This port should be named COM3, or

something similar, on a Windows PC; or something like

/dev/tty.usbmodemor /dev.tty.usbserialon the Mac.

  Uploading a Sketch

Once you have selected the proper board and serial port, it’s time for the fun

part. To upload a sketch onto the Arduino board, simply hit the Upload button

on the toolbar, as shown in Figure. The onboard LEDs marked RX and TX will

blink furiously and you will receive a message in the status bar that says, “Done

uploading.” That’s all there is to it!

 BLYNK APP

Blynk is designed for the Internet of Things. It can control hardware remotely, it

can display sensor data, it can store data, visualize it and do many other cool

things.

There are three major components in the platform:

 Blynk App - allows to you create amazing interfaces for your projects

using various widgets we provide.

 Blynk Server - responsible for all the communications between the

smartphone and hardware. You can use our Blynk Cloud or run your

private Blynk server locally. It’s open-source, could easily handle

thousands of devices and can even be launched on a Raspberry Pi.

 Blynk Libraries - for all the popular hardware platforms - enable

communication with the server and process all the incoming and

outcoming commands.

Now imagine: every time you press a Button in the Blynk app, the message

travels to space the Blynk Cloud, where it magically finds its way to your

hardware. It works the same in the opposite direction and everything happens in

a blynk of an eye.
Features

 Similar API & UI for all supported hardware & devices

 Connection to the cloud using:

o WiFi

o Bluetooth and BLE

o Ethernet

o USB (Serial)

o GSM
  Set of easy-to-use Widgets

 Direct pin manipulation with no code writing

 Easy to integrate and add new functionality using virtual pins

 History data monitoring via History Graph widget

 Device-to-Device communication using Bridge Widget

 Sending emails, tweets, push notifications, etc.

 … new features are constantly added!

You can find example sketches covering basic Blynk Features. They are

included in the library. All the sketches are designed to be easily combined with

each other.

What do I need to Blynk?

At this point you might be thinking: “Ok, I want it. What do I need to get

started?” – Just a couple of things, really:

1. Hardware.

An Arduino, Raspberry Pi, or a similar development kit.

Blynk works over the Internet. This means that the hardware you choose

should be able to connect to the internet. Some of the boards, like Arduino Uno

will need an Ethernet or Wi-Fi Shield to communicate, others are already

Internet-enabled: like the ESP8266, Raspberri Pi with WiFi dongle, Particle

Photon or SparkFun Blynk Board. But even if you don’t have a shield, you can

connect it over USB to your laptop or desktop (it’s a bit more complicated for

newbies, but we got you covered). What’s cool, is that the list of hardware that

works with Blynk is huge and will keep on growing.

2. A Smartphone.

The Blynk App is a well-designed interface builder. It works on both iOS and

Android, so no holywars here, ok?

Getting Started With The Blynk App

1. Create a Blynk Account

After you download the Blynk App, you’ll need to create a New Blynk account.
This account is separate from the accounts used for the Blynk Forums, in case
you already have one.

We recommend using a real email address because it will simplify things later.
Why do I need to create an account?

An account is needed to save your projects and have access to them from
multiple devices from anywhere. It’s also a security measure.

You can always set up your own Private Blynk Server and have full control.

2. Create a New Project

After you’ve successfully logged into your account, start by creating a new
project.
3. Choose Your Hardware

Select the hardware model you will use.

4. Auth Token

Auth Token is a unique identifier which is needed to connect your hardware to

your smartphone. Every new project you create will have its own Auth Token.
You’ll get Auth Token automatically on your email after project creation. You
can also copy it manually. Click on devices section :
5. Add a Widget

Your project canvas is empty, let’s add a button to control our LED.

Tap anywhere on the canvas to open the widget box. All the available widgets
are located here. Now pick a button.

Widget Box
6. Run The Project

When you are done with the Settings - press the PLAY button. This will switch
you from EDIT mode to PLAY mode where you can interact with the hardware.
While in PLAY mode, you won’t be able to drag or set up new widgets, press
STOP and get back to EDIT mode.
You will get a message saying “Arduino MEGA is offline”. We’ll deal with
that in the next section.