Arduino

LED BLINK

HOW IT WORKS?

The LED is on for the time we set using the delay command. After the time is reached the LED is turned on for the time we set in the second delay command.

PARTS REQUIRED:

ARDUINO MICROCONTROLLER(1)
LED(1)
BREAD BOARD(1)
WIRES(2)
220 Ω RESISTOR(1)

THE CIRCUIT:

THE CODE:

// Pin 13 has an LED connected on most Arduino boards.

// give it a name:

int led = 13;

// the setup routine runs once when you press reset:

void setup() {

  // initialize the digital pin as an output.

  pinMode(led, OUTPUT);

// the loop routine runs over and over again forever:

void loop() {

  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)

  delay(1000);               // wait for a second

  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW

  delay(1000);               // wait for a second

TACTILE BUTTON CONTROLLED LED

HOW IT WORKS?

When the button is pressed, the LED is turned on. When the button is released, the LED is turned off.

PARTS REQUIRED:

ARDUINO MICROCONTROLLER(1)
BREAD BOARD(1)
SMALL TACTILE BUTTON(1)
WIRES(5)
LED(1)
220 Ω RESISTOR(2)

THE CIRCUITS:

// constants won't change. They're used here to

// set pin numbers:

const int buttonPin = 2;     // the number of the pushbutton pin

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

// variables will change:

int buttonState = 0;         // variable for reading the pushbutton status

void setup() {

  // initialize the LED pin as an output:

  pinMode(ledPin, OUTPUT);

  // initialize the pushbutton pin as an input:

  pinMode(buttonPin, INPUT);

void loop() {

  // read the state of the pushbutton value:

  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed.

  // if it is, the buttonState is HIGH:

  if (buttonState == HIGH) {

    // turn LED on:

    digitalWrite(ledPin, HIGH);

  } else {

    // turn LED off:

    digitalWrite(ledPin, LOW);

WORKING WITH LCD

MATERIALS REQUIRED:

ARDUINO MICROCONTROLLER(1)
16*2 LCD(1)
BREAD BOARD(1)
WIRES(13)

There are 9 different projects that can be done with the same circuits.

THE CIRCUITS:

AUTOSCROLL:

/*

  LiquidCrystal Library - Autoscroll

*/

// include the library code:

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

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

void setup() {

  // set up the LCD's number of columns and rows:

  lcd.begin(16, 2);

void loop() {

  // set the cursor to (0,0):

  lcd.setCursor(0, 0);

  // print from 0 to 9:

  for (int thisChar = 0; thisChar < 10; thisChar++) {

    lcd.print(thisChar);

    delay(500);

  // set the cursor to (16,1):

  lcd.setCursor(16, 1);

  // set the display to automatically scroll:

  lcd.autoscroll();

  // print from 0 to 9:

  for (int thisChar = 0; thisChar < 10; thisChar++) {

    lcd.print(thisChar);

    delay(500);

  // turn off automatic scrolling

  lcd.noAutoscroll();

  // clear screen for the next loop:

  lcd.clear();

HOW IT WORKS?

The lcd prints numbers from 1-10 and the numbers move from left to right.

BLINK:

/*

  LiquidCrystal Library - Blink

*/

// include the library code:

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

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

void setup() {

  // set up the LCD's number of columns and rows:

  lcd.begin(16, 2);

  // Print a message to the LCD.

  lcd.print("hello, world!");

void loop() {

  // Turn off the blinking cursor:

  lcd.noBlink();

  delay(3000);

  // Turn on the blinking cursor:

  lcd.blink();

  delay(3000);

HOW IT WORKS?

This sketch prints "Hello World!" to the LCD and makes the cursor block blink.

CURSOR:

/*

  LiquidCrystal Library - Cursor

*/

// include the library code:

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

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

void setup() {

  // set up the LCD's number of columns and rows:

  lcd.begin(16, 2);

  // Print a message to the LCD.

  lcd.print("hello, world!");

void loop() {

  // Turn off the cursor:

  lcd.noCursor();

  delay(500);

  // Turn on the cursor:

  lcd.cursor();

  delay(500);

HOW IT WORKS?

This sketch prints "Hello World!" to the LCD and uses the cursor() and noCursor() methods to turn on and off the cursor.

DISPLAY:

/*

  LiquidCrystal Library - display() and noDisplay()

*/

// include the library code:

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

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

void setup() {

  // set up the LCD's number of columns and rows:

  lcd.begin(16, 2);

  // Print a message to the LCD.

  lcd.print("hello, world!");

void loop() {

  // Turn off the display:

  lcd.noDisplay();

  delay(500);

  // Turn on the display:

  lcd.display();

  delay(500);

HOW IT WORKS?

This sketch prints "Hello World!" to the LCD and uses the display() and noDisplay() functions to turn on and off the display.

HELLOWORLD:

/*

 This sketch prints "Hello World!" to the LCD

 and shows the time.

*/

// include the library code:

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

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

void setup() {

  // set up the LCD's number of columns and rows:

  lcd.begin(16, 2);

  // Print a message to the LCD.

  lcd.print("hello, world!");

void loop() {

  // set the cursor to column 0, line 1

  // (note: line 1 is the second row, since counting begins with 0):

  lcd.setCursor(0, 1);

  // print the number of seconds since reset:

  lcd.print(millis() / 1000);

HOW IT WORKS?

This sketch prints "Hello World!" in the first row to the LCD and shows the time in the second. After 1000 seconds, the time is reset to nil.

SCROLL:

/*

  LiquidCrystal Library - scrollDisplayLeft() and scrollDisplayRight()

*/

// include the library code:

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

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

void setup() {

  // set up the LCD's number of columns and rows:

  lcd.begin(16, 2);

  // Print a message to the LCD.

  lcd.print("hello, world!");

  delay(1000);

void loop() {

  // scroll 13 positions (string length) to the left

  // to move it offscreen left:

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

    // scroll one position left:

    lcd.scrollDisplayLeft();

    // wait a bit:

    delay(150);

  // scroll 29 positions (string length + display length) to the right

  // to move it offscreen right:

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

    // scroll one position right:

    lcd.scrollDisplayRight();

    // wait a bit:

    delay(150);

  // scroll 16 positions (display length + string length) to the left

  // to move it back to center:

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

    // scroll one position left:

    lcd.scrollDisplayLeft();

    // wait a bit:

    delay(150);

  // delay at the end of the full loop:

  delay(1000);

HOW IT WORKS?

This sketch prints "Hello World!" to the LCD and uses the scrollDisplayLeft() and scrollDisplayRight() methods to scroll the text left.

SERIAL DISPLAY:

/*

  LiquidCrystal Library - Serial Input

*/

// include the library code:

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

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

void setup() {

  // set up the LCD's number of columns and rows:

  lcd.begin(16, 2);

  // initialize the serial communications:

  Serial.begin(9600);

void loop() {

  // when characters arrive over the serial port...

  if (Serial.available()) {

    // wait a bit for the entire message to arrive

    delay(100);

    // clear the screen

    lcd.clear();

    // read all the available characters

    while (Serial.available() > 0) {

      // display each character to the LCD

      lcd.write(Serial.read());

HOW IT WORKS?

This sketch displays text sent over the serial port (e.g. from the Serial Monitor) on an attached LCD.

SETCURSOR:

/*

  LiquidCrystal Library - setCursor

*/

// include the library code:

#include <LiquidCrystal.h>

// these constants won't change.  But you can change the size of

// your LCD using them:

const int numRows = 2;

const int numCols = 16;

// initialize the library with the numbers of the interface pins

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

void setup() {

  // set up the LCD's number of columns and rows:

  lcd.begin(numCols, numRows);

void loop() {

  // loop from ASCII 'a' to ASCII 'z':

  for (int thisLetter = 'a'; thisLetter <= 'z'; thisLetter++) {

    // loop over the columns:

    for (int  thisRow = 0; thisRow < numRows; thisRow++) {

      // loop over the rows:

      for (int thisCol = 0; thisCol < numCols; thisCol++) {

        // set the cursor position:

        lcd.setCursor(thisCol, thisRow);

        // print the letter:

        lcd.write(thisLetter);

        delay(200);

HOW IT WORKS?

This sketch prints to all the positions of the LCD using the setCursor() method.

TEXT DIRECTION:

/*

LiquidCrystal Library - TextDirection

*/

// include the library code:

#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins

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

int thisChar = 'a';

void setup() {

  // set up the LCD's number of columns and rows:

  lcd.begin(16, 2);

  // turn on the cursor:

  lcd.cursor();

void loop() {

  // reverse directions at 'm':

  if (thisChar == 'm') {

    // go right for the next letter

    lcd.rightToLeft();

  // reverse again at 's':

  if (thisChar == 's') {

    // go left for the next letter

    lcd.leftToRight();

  // reset at 'z':

  if (thisChar > 'z') {

    // go to (0,0):

    lcd.home();

    // start again at 0

    thisChar = 'a';

  // print the character

  lcd.write(thisChar);

  // wait a second:

  delay(1000);

  // increment the letter:

  thisChar++;

HOW IT WORKS?

The cursor moves left to right and right to left.

LCD GAME

HOW IT WORKS?

The SPRITE keeps running. To score, you need to escape from obstacles. When you press the tactile button, the SPRITE or HERO jumps.

PARTS REQUIRED:

ARDUINO MICROCONTROLLER(1)
BREAD BOARD(1)
TACTILE BUTTON(1)
16*2 LCD WITH BUILT-IN RESISTORS(1)
WIRES(16)

THE CIRCUITS:

Arduino LCD Game | Autodesk Circuits

THE CODE:

#include <LiquidCrystal.h>

#define PIN_BUTTON 2

#define PIN_AUTOPLAY 1

#define PIN_READWRITE 10

#define PIN_CONTRAST 12

#define SPRITE_RUN1 1

#define SPRITE_RUN2 2

#define SPRITE_JUMP 3

#define SPRITE_JUMP_UPPER '.'         // Use the '.' character for the head

#define SPRITE_JUMP_LOWER 4

#define SPRITE_TERRAIN_EMPTY ' '      // User the ' ' character

#define SPRITE_TERRAIN_SOLID 5

#define SPRITE_TERRAIN_SOLID_RIGHT 6

#define SPRITE_TERRAIN_SOLID_LEFT 7

#define HERO_HORIZONTAL_POSITION 1    // Horizontal position of hero on screen

#define TERRAIN_WIDTH 16

#define TERRAIN_EMPTY 0

#define TERRAIN_LOWER_BLOCK 1

#define TERRAIN_UPPER_BLOCK 2

#define HERO_POSITION_OFF 0          // Hero is invisible

#define HERO_POSITION_RUN_LOWER_1 1  // Hero is running on lower row (pose 1)

#define HERO_POSITION_RUN_LOWER_2 2  //                              (pose 2)

#define HERO_POSITION_JUMP_1 3       // Starting a jump

#define HERO_POSITION_JUMP_2 4       // Half-way up

#define HERO_POSITION_JUMP_3 5       // Jump is on upper row

#define HERO_POSITION_JUMP_4 6       // Jump is on upper row

#define HERO_POSITION_JUMP_5 7       // Jump is on upper row

#define HERO_POSITION_JUMP_6 8       // Jump is on upper row

#define HERO_POSITION_JUMP_7 9       // Half-way down

#define HERO_POSITION_JUMP_8 10      // About to land

#define HERO_POSITION_RUN_UPPER_1 11 // Hero is running on upper row (pose 1)

#define HERO_POSITION_RUN_UPPER_2 12 //                              (pose 2)

LiquidCrystal lcd(11, 9, 6, 5, 4, 3);

static char terrainUpper[TERRAIN_WIDTH + 1];

static char terrainLower[TERRAIN_WIDTH + 1];

static bool buttonPushed = false;

void initializeGraphics(){

  static byte graphics[] = {

    // Run position 1

    B01100,

    B01100,

    B00000,

    B01110,

    B11100,

    B01100,

    B11010,

    B10011,

    // Run position 2

    B01100,

    B01100,

    B00000,

    B01100,

    B01100,

    B01100,

    B01100,

    B01110,

    // Jump

    B01100,

    B01100,

    B00000,

    B11110,

    B01101,

    B11111,

    B10000,

    B00000,

    // Jump lower

    B11110,

    B01101,

    B11111,

    B10000,

    B00000,

    B00000,

    B00000,

    B00000,

    // Ground

    B11111,

    B11111,

    B11111,

    B11111,

    B11111,

    B11111,

    B11111,

    B11111,

    // Ground right

    B00011,

    B00011,

    B00011,

    B00011,

    B00011,

    B00011,

    B00011,

    B00011,

    // Ground left

    B11000,

    B11000,

    B11000,

    B11000,

    B11000,

    B11000,

    B11000,

    B11000,

};

  int i;

  // Skip using character 0, this allows lcd.print() to be used to

  // quickly draw multiple characters

  for (i = 0; i < 7; ++i) {

    lcd.createChar(i + 1, &graphics[i * 8]);

  for (i = 0; i < TERRAIN_WIDTH; ++i) {

    terrainUpper[i] = SPRITE_TERRAIN_EMPTY;

    terrainLower[i] = SPRITE_TERRAIN_EMPTY;

// Slide the terrain to the left in half-character increments

//

void advanceTerrain(char* terrain, byte newTerrain){

  for (int i = 0; i < TERRAIN_WIDTH; ++i) {

    char current = terrain[i];

    char next = (i == TERRAIN_WIDTH-1) ? newTerrain : terrain[i+1];

    switch (current){

      case SPRITE_TERRAIN_EMPTY:

        terrain[i] = (next == SPRITE_TERRAIN_SOLID) ? SPRITE_TERRAIN_SOLID_RIGHT : SPRITE_TERRAIN_EMPTY;

        break;

      case SPRITE_TERRAIN_SOLID:

        terrain[i] = (next == SPRITE_TERRAIN_EMPTY) ? SPRITE_TERRAIN_SOLID_LEFT : SPRITE_TERRAIN_SOLID;

        break;

      case SPRITE_TERRAIN_SOLID_RIGHT:

        terrain[i] = SPRITE_TERRAIN_SOLID;

        break;

      case SPRITE_TERRAIN_SOLID_LEFT:

        terrain[i] = SPRITE_TERRAIN_EMPTY;

        break;

bool drawHero(byte position, char* terrainUpper, char* terrainLower, unsigned int score) {

  bool collide = false;

  char upperSave = terrainUpper[HERO_HORIZONTAL_POSITION];

  char lowerSave = terrainLower[HERO_HORIZONTAL_POSITION];

  byte upper, lower;

  switch (position) {

    case HERO_POSITION_OFF:

      upper = lower = SPRITE_TERRAIN_EMPTY;

      break;

    case HERO_POSITION_RUN_LOWER_1:

      upper = SPRITE_TERRAIN_EMPTY;

      lower = SPRITE_RUN1;

      break;

    case HERO_POSITION_RUN_LOWER_2:

      upper = SPRITE_TERRAIN_EMPTY;

      lower = SPRITE_RUN2;

      break;

    case HERO_POSITION_JUMP_1:

    case HERO_POSITION_JUMP_8:

      upper = SPRITE_TERRAIN_EMPTY;

      lower = SPRITE_JUMP;

      break;

    case HERO_POSITION_JUMP_2:

    case HERO_POSITION_JUMP_7:

      upper = SPRITE_JUMP_UPPER;

      lower = SPRITE_JUMP_LOWER;

      break;

    case HERO_POSITION_JUMP_3:

    case HERO_POSITION_JUMP_4:

    case HERO_POSITION_JUMP_5:

    case HERO_POSITION_JUMP_6:

      upper = SPRITE_JUMP;

      lower = SPRITE_TERRAIN_EMPTY;

      break;

    case HERO_POSITION_RUN_UPPER_1:

      upper = SPRITE_RUN1;

      lower = SPRITE_TERRAIN_EMPTY;

      break;

    case HERO_POSITION_RUN_UPPER_2:

      upper = SPRITE_RUN2;

      lower = SPRITE_TERRAIN_EMPTY;

      break;

  if (upper != ' ') {

    terrainUpper[HERO_HORIZONTAL_POSITION] = upper;

    collide = (upperSave == SPRITE_TERRAIN_EMPTY) ? false : true;

  if (lower != ' ') {

    terrainLower[HERO_HORIZONTAL_POSITION] = lower;

    collide |= (lowerSave == SPRITE_TERRAIN_EMPTY) ? false : true;

  byte digits = (score > 9999) ? 5 : (score > 999) ? 4 : (score > 99) ? 3 : (score > 9) ? 2 : 1;

  // Draw the scene

  terrainUpper[TERRAIN_WIDTH] = '\0';

  terrainLower[TERRAIN_WIDTH] = '\0';

  char temp = terrainUpper[16-digits];

  terrainUpper[16-digits] = '\0';

  lcd.setCursor(0,0);

  lcd.print(terrainUpper);

  terrainUpper[16-digits] = temp;

  lcd.setCursor(0,1);

  lcd.print(terrainLower);

  lcd.setCursor(16 - digits,0);

  lcd.print(score);

  terrainUpper[HERO_HORIZONTAL_POSITION] = upperSave;

  terrainLower[HERO_HORIZONTAL_POSITION] = lowerSave;

  return collide;

// Handle the button push as an interrupt

void buttonPush() {

  buttonPushed = true;

void setup(){

  pinMode(PIN_READWRITE, OUTPUT);

  digitalWrite(PIN_READWRITE, LOW);

  pinMode(PIN_CONTRAST, OUTPUT);

  digitalWrite(PIN_CONTRAST, LOW);

  pinMode(PIN_BUTTON, INPUT);

  digitalWrite(PIN_BUTTON, HIGH);

  pinMode(PIN_AUTOPLAY, OUTPUT);

  digitalWrite(PIN_AUTOPLAY, HIGH);

  // Digital pin 2 maps to interrupt 0

  attachInterrupt(0/*PIN_BUTTON*/, buttonPush, FALLING);

  initializeGraphics();

  lcd.begin(16, 2);

void loop(){

  static byte heroPos = HERO_POSITION_RUN_LOWER_1;

  static byte newTerrainType = TERRAIN_EMPTY;

  static byte newTerrainDuration = 1;

  static bool playing = false;

  static bool blink = false;

  static unsigned int distance = 0;

  if (!playing) {

    drawHero((blink) ? HERO_POSITION_OFF : heroPos, terrainUpper, terrainLower, distance >> 3);

    if (blink) {

      lcd.setCursor(0,0);

      lcd.print("Press Start");

    delay(250);

    blink = !blink;

    if (buttonPushed) {

      initializeGraphics();

      heroPos = HERO_POSITION_RUN_LOWER_1;

      playing = true;

      buttonPushed = false;

      distance = 0;

    return;

  // Shift the terrain to the left

  advanceTerrain(terrainLower, newTerrainType == TERRAIN_LOWER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);

  advanceTerrain(terrainUpper, newTerrainType == TERRAIN_UPPER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);

  // Make new terrain to enter on the right

  if (--newTerrainDuration == 0) {

    if (newTerrainType == TERRAIN_EMPTY) {

      newTerrainType = (random(3) == 0) ? TERRAIN_UPPER_BLOCK : TERRAIN_LOWER_BLOCK;

      newTerrainDuration = 2 + random(10);

    } else {

      newTerrainType = TERRAIN_EMPTY;

      newTerrainDuration = 10 + random(10);

  if (buttonPushed) {

    if (heroPos <= HERO_POSITION_RUN_LOWER_2) heroPos = HERO_POSITION_JUMP_1;

    buttonPushed = false;

  if (drawHero(heroPos, terrainUpper, terrainLower, distance >> 3)) {

    playing = false; // The hero collided with something. Too bad.

  } else {

    if (heroPos == HERO_POSITION_RUN_LOWER_2 || heroPos == HERO_POSITION_JUMP_8) {

      heroPos = HERO_POSITION_RUN_LOWER_1;

    } else if ((heroPos >= HERO_POSITION_JUMP_3 && heroPos <= HERO_POSITION_JUMP_5) && terrainLower[HERO_HORIZONTAL_POSITION] != SPRITE_TERRAIN_EMPTY) {

      heroPos = HERO_POSITION_RUN_UPPER_1;

    } else if (heroPos >= HERO_POSITION_RUN_UPPER_1 && terrainLower[HERO_HORIZONTAL_POSITION] == SPRITE_TERRAIN_EMPTY) {

      heroPos = HERO_POSITION_JUMP_5;

    } else if (heroPos == HERO_POSITION_RUN_UPPER_2) {

      heroPos = HERO_POSITION_RUN_UPPER_1;

    } else {

      ++heroPos;

    ++distance;

    digitalWrite(PIN_AUTOPLAY, terrainLower[HERO_HORIZONTAL_POSITION + 2] == SPRITE_TERRAIN_EMPTY ? HIGH : LOW);

  delay(50);

DISTANCE MEASURING DEVICE

HOW IT WORKS?

The Ultrasonic sensor has 2 main parts TX & RX. TX transmits ultrasonic waves and in case of an obstacle the waves are reflected and are received by RX. The sensor with the help of these 2 main components measures the distance.

MATERIALS REQUIRED:

ARDUINO MICROCONTROLLER(1)
16*2 LCD(1)
HC SR-04 ULTRASONIC SENSOR(1)
BREAD BOARD(1)
WIRES(17)

THE CIRCUIT:

THE CODE:

#include <LiquidCrystal.h>

#include <Ultrasonic.h>

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

Ultrasonic ultrasonic (A0, A1);

void setup(){

lcd.begin(16 ,2);

void loop(){

lcd.clear();

lcd.print(" DISTANCE FROM ");

lcd.setCursor(0, 1);

lcd.print("OBSTACLE: ");

lcd.print(ultrasonic.Ranging(CM)) ;

lcd.print("cm");

delay(500);

SERVO SWEEP

HOW IT WORKS?

The servo motor rotates from 0° to 180° and back from 180° to 0° .

MATERIALS REQUIRED?

ARDUINO MICROCONTROLLER(1)
MINI SERVO MOTOR(1)
WIRES(3)

THE CIRCUITS:

SERVO SWEEP | Autodesk Circuits

THE CODE:

#include <Servo.h>

Servo myservo;  // create servo object to control a servo

// twelve servo objects can be created on most boards

int pos = 0;    // variable to store the servo position

void setup() {

  myservo.attach(9);  // attaches the servo on pin 9 to the servo object

void loop() {

  for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees

    // in steps of 1 degree

    myservo.write(pos);              // tell servo to go to position in variable 'pos'

    delay(15);                       // waits 15ms for the servo to reach the position

  for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees

    myservo.write(pos);              // tell servo to go to position in variable 'pos'

    delay(15);                       // waits 15ms for the servo to reach the position

BURGLAR ALARM

HOW IT WORKS?

When an obstacle is spotted by the sensor within the range set, the LED, BUZZER and SERVO MOTOR are turned on.

MATERIALS REQUIRED?

ARDUINO MICROCONTROLLER(1)
HC SR-04 ULTRASONIC SENSOR(1)
MINI SERVO MOTOR(1)
LED(1)
PIEZO BUZZER(1)
BREAD BOARD(1)
WIRES(13)

THE CIRCUITS:

THE CODE:

#include <Servo.h>

// create servo object to control a servo

Servo myservo;

// variable to store the servo position

int pos = 0;

// Define pins for ultrasonic, buzzer, led and relay

int const trigPin = 10;

int const echoPin = 9;

int const buzzPin = 2;

int const ledPin = 13;

void setup()

  myservo.attach(11);

  // attach servo on pin 11

  pinMode(trigPin, OUTPUT);

  // trig pin will have pulses output

  pinMode(echoPin, INPUT);

  // echo pin should be input to get pulse width

  pinMode(buzzPin, OUTPUT);

  // buzz pin is output to control buzzering

  pinMode(ledPin, OUTPUT);

  // led pin is output to glow light

  // relay pin is output

void loop()

  // Duration will be the input pulse width and distance will be the distance to the obstacle in centimeters

  int duration, distance;

  // Output pulse with 1ms width on trigPin

  digitalWrite(trigPin, HIGH);

  delay(1);

  digitalWrite(trigPin, LOW);

  // Measure the pulse input in echo pin

  duration = pulseIn(echoPin, HIGH);

  // Distance is half the duration devided by 29.1 (from datasheet)

  distance = (duration / 2) / 29.1;

  // if distance less than 0.5 meter and more than 0 (0 or less means over range)

  if (distance <= 50 && distance >= 0)

    // Buzz

    digitalWrite(buzzPin, HIGH);

    // Led on

    digitalWrite(ledPin, HIGH);

    // Relay on

      myservo.write(0);// tell servo to go to position in variable 'pos'

      delay(15);// servo 15ms to reach that position

  else

    // Don't buzz

    digitalWrite(buzzPin, LOW);

    // Led off

    digitalWrite(ledPin, LOW);

    // Relay off

      myservo.write(90);// tell servo to go to position in variable 'pos'

      delay(15);// servo 15ms to reach that position

  // Waiting 60 ms won't hurt any one

  delay(60);

RAIN DETECTING DEVICE

HOW IT WORKS?

The minimum sensor reading is 0 and he maximum sensor reading is 1024. Based on this, there are 3 different cases:

682-1024 = case 0(Flood)
341-682 = case 1(Raining)
0-341 = case 2(Not Raining)

MATERIALS REQUIRED:

ARDUINO MICROCONTROLLER(1)
HL-83 RAIN SENSOR(1)
LM393 COMPARATOR(1)
16*2 LCD(1)
BREAD BOARD(1)
WIRES (18)

Sorry, we couldn't get pictures of the circuit.

THE CIRCUITS:

RAIN SENSOR → LM393 COMPARATOR:

+→ +
-→ -

LM393 COMPARATOR → ARDUINO MICROCONTROLLER

VCC→ VCC
GND→ GND
A0→ A0

LCD→ ARDUINO MICROCONTROLLER

VSS→ GND
VDD/VCC→ VCC
RS→ D-12
R/W→ GND
E→ D-10
DB-4→ D-5
DB-5→ D-4
DB-6→ D-3
DB-7→ D-2

THE CODE:

#include <LiquidCrystal.h>

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

// lowest and highest sensor readings:

const int sensorMin = 0;     // sensor minimum

const int sensorMax = 1024;  // sensor maximum

void setup() {

  // initialize serial communication @ 9600 baud:

  Serial.begin(9600);

  lcd.begin(16, 2);

void loop() {

  // read the sensor on analog A0:

  int sensorReading = analogRead(A0);

  // map the sensor range (four options):

  // ex: 'long int map(long int, long int, long int, long int, long int)'

 int range = map(sensorReading, sensorMin, sensorMax, 0, 3);

  // range value:

  switch (range) {

 case 0:    // Sensor getting wet

    Serial.println("Flood");

    lcd.clear();

    lcd.setCursor(0, 0);

    lcd.print("Flood");

    break;

 case 1:    // Sensor getting wet

    Serial.println("Raining");

    lcd.clear();

    lcd.setCursor(0, 0);

    lcd.print("Raining");

    break;

 case 2:    // Sensor dry - To shut this up delete the " Serial.println("Not Raining"); " below.

    Serial.println("Not Raining");

    lcd.clear();

    lcd.setCursor(0, 0);

    lcd.print("Not Raining");

    break;

  delay(100);  // delay between reads

IR SENSOR OBSTACLE DETECTOR

HOW IT WORKS?

To see how the IR sensor works, view the "HOW DO THEY WORK" page. When Infrared rays are received by the photo diode, the LED is turned on.

MATERIALS REQUIRED:

IR SENSOR MODULE(1)
ARDUINO MICROCONTROLLER(1)
LED(1)
330 Ω RESISTOR(1)
JUMPER WIRES(5)

THE CODE:

int LED = 13;

int isObstaclePin = 7;  // This is our input pin

int isObstacle = HIGH;  // HIGH MEANS NO OBSTACLE

void setup() {

  pinMode(LED, OUTPUT);

  pinMode(isObstaclePin, INPUT);

  Serial.begin(9600);

void loop() {

  isObstacle = digitalRead(isObstaclePin);

  if (isObstacle == LOW)

    Serial.println("OBSTACLE!!, OBSTACLE!!");

    digitalWrite(LED, HIGH);

  else

    Serial.println("clear");

    digitalWrite(LED, LOW);

  delay(200);

VOTING MACHINE

HOW IT WORKS?

When either of the voting buttons are pressed, the microcontroller adds 1 to the sum and displays the number on the LCD. When the result button is clicked, the microcontroller compares the number of votes and displays the name of the winner.

MATERIALS REQUIRED:

ARDUINO MICROCONTROLLER(1)
TACTILE BUTTONS(3)
BREADBOARD(1)
LCD(1)
WIRES(17)

THE CIRCUIT:

Google Sites

Report abuse