Wednesday, 18 January 2017

Induino R5 Arduino R3 USB Clone Board - Latest Revision of the Induino Board

The Induino R5 is the latest design revision in the Induino Series of Boards.

http://www.simplelabs.co.in/821-thickbox_leometr/induino-r5-arduino-r3-usb-clone-board.jpg

The Induino R5 is a Arduino Rev3 Clone with a ATmega328 microcontroller loaded with Arduino UNO bootloader. Rev3 compatibility ensures that the board works with the newer versions of the arduino shields.

The Induino R5 comes with 3 major changes - The FTDI ic has been replaced by CH340 IC, the RTC Pinout changes to match the improved RTC DS3231 Breakout Board and the addition of a 3.3V regulator for better 3.3V output
It has 14 digital input/output pins (of which 6 can be used as PWM outputs), 6 analog inputs, a 16 MHz crystal oscillator, a USB connection, an ICSP header, and a reset button. Like the Duemilanove, 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. It is completely compatible with all arduino shields mechanically.
On top of the regular features of an Arduino Board, The Induino R5 comes with a number of on-board peripherals and interfaces.
The Following is the list of On-Board Peripherals
  • 3 LEDS on digital pins 11,12 & 13 [for experimentation with digital outputs]
  • 3 Push Buttons on digital pins 7,8 & 9 [for experimentation with digital inputs]
  • 1 IR LED on digital pin 14 a.k.a anlog input pin 0 [experimentation with pulse generation & wireless communication]
  • 1 TSOP IR Receiver on digital pin 15 a.k.a analog input pin 1 [experimentation with pulse decoding & wireless communication]
  • 1 LDR (with potential divider) on analog input pin 3 [experimentation with analog sensors]
  • 1 RGB Led [experimentation with analog outputs / PWM]


The Following is the list of On-Board Interfaces
  • R3 Shield Compatible Pinouts – Makes the board compatible with all the latest R3 Arduino Shields
  • Analog Sensor Interface – Plug & Program Interface compatible with a number of sensors – HC-SR04 Ultrasonic Distance Sensor, RHT03 – Humidity & Temperature Sensor, Force Sensitive Resistors & Other Variable Resistor type sensors
  • Servo Interface – Plug & Program upto 2 / 3 Servo Motors (3rd one using the Analog Sensor Interface)
  • RTC Interface – Plug & Program interface for DS18B
  • I2C OLED Display Interface - Plug in I2C OLED Displays Directly onto the Board
  • FTDI Bit Bang Programming Interface

Monday, 15 June 2015

List of Contents


This is the User Guide for the Induino R3 / R4 / R5 from Simple Labs. The Induino R5 is the latest in the Induino Series of Low Cost Arduino clone boards from Simple Labs. The user guide focuses on making use of the Induino R5 board effectively & Interfacing different components. This is a constant work in progress so if something looks incomplete, it means we are working on it and will update it soon. If you are in a hurry, drop us an email. Enjoy!

http://www.simplelabs.co.in/821-thickbox_leometr/induino-r5-arduino-r3-usb-clone-board.jpg


Induino R3 Blog Overview - List of Contents (For Easy Navigation!!!)
  1. What is Arduino? What is Induino? Lets get Some Clarity
  2. Induino R3 / R4 / R5 - An Overview
  3. Simple Labs' Induino R3 / Induino R4 / Induino R5 and Arduino Uno Comparison
  4. Driver Installation
  5. The Basics of Working with Induino R3 / Arduino
  6. Digital Outputs - What, Where & How? - Working with the 3 on-board LEDs
  7. Digital Inputs - What, Where & How? - Working with the 3 on-board Push Buttons
  8. Serial Communication - What, Where & How?
  9. Analog Outputs - What, Where & How? - Working with the RGB LED
  10. Analog Inputs - What, Where & How? - Working with the on-board LDR
  11. Sensor Interface & Interfacing External Sensors - Variable Resistors, LM35 & HC-SR04
  12. Interfacing a TV Remote with the on-board TSOP Remote Control Receiver
  13. Generating Remote Control Signals using the on-board IR LED
  14. Servo Interfacing -  Working with the on-board Servo Interface
  15. LCD Interfacing - Working with the Simple Labs LCD Shield
  16. I2C Communication - What, Where & How? - Interfacing with the Simple Labs RTC Module
  17. I2C Communication - Interfacing Sensors -  MPU6050, BMP085 & HMC5883L 
  18. Interfacing with the Real World - Working with the Simple Labs Relay Control Board
  19. Interrupts - What, Where & How? - Working with the Simple Labs DTMF Control Board
  20. Interfacing Serial Devices - Part 1 - Working with the BTBee PRO / Xbee
  21. Interfacing Serial Devices - Part 2 - Working with a Serial RFID Reader
  22. Interfacing Serial Devices - Part 3 - Working with a Serial GSM Modem
  23. SPI Communication - What, Where & How? - Working with the W5100 Ethernet Shield
  24. Interfacing Sensors - Microphone Sound Detection Sensor
  25. LCD Interfacing - Creating Custom Characters and a Bar Graph
  26. PORT Manipulation & 7 Segment LED Interfacing - Working with the Simple Labs Seven Segment cum DTMF Shield
  27. Interfacing the 0.96" I2C OLED Display

15-June-2015 - Induino R4 replacing the Induino R3

Induino R4 is the latest revision to our Induino series of Boards. The Induino R4 will replace the Induino R3.

Induino R4 is the same as the R3 excepting the following 2 changes

1) Removal of the General Purpose Prototyping Area

2) Addition of a 4 Pin I2C Header in that Area to Allow Direct Plugging in of 0.96" I2C OLED Displays.

All existing code / tutorials / examples for the Induino R3 will work on the Induino R4 as it is. The OLED interface is the only addition. Soon we will publish an OLED version of all example codes using LCD currently.

Here are pictures of the Induino R4. The oled display is just for illustrative purposes and does not come with the Board. However the display is included as part of various kits for the Induino.





Friday, 12 June 2015

Interfacing the 0.96" I2C OLED Display

I2C OLED Display

The 0.96" I2C OLED Display is a simple display with plenty of options for displaying text and graphics in monochrome. The display hooks up to the I2C bus and can be accessed using the Address 0x3C. The display is a 128 x 64 Display where it has 128 pixels for every row with a total of 64 rows.

Hooking it up

All it needs to work is 4 lines of connection (SDA, SCL, Vcc, Gnd). You don't need any pullups. Should you have the latest version of the Induino, The Induino R4, you don't even have to use physical wires! the board comes with a Direct Plug in Header for the 0.96" I2C OLED display. Just plug it in and you are good to go!

For Induino R3 or Arduino

For Induino R3 or Arduino

For Induino R3 or Arduino

Plug in Directly on the Induino R4
One you are done with the connections, download this excellent library from DigiSpark. If You are wondering how to install this library? check this -> http://arduino.cc/en/Guide/Libraries

The Digispark OLED library offers a number of functions that we can use. The library creates a default object called oled and functions can be called through this object.

The Functions
  • oled.begin() - > This function intialises communication with the oled and does the basic oled setup required.
  • oled.fill(fill color) -> This function fills the display with the chosen fill color. In our case since we are working with a monochrome oled. its only possible to fill it with black or blue(white). use oled.fill(0xFF) to fill the screen with white color and oled.fill(0x00) to fill the screen with black color.
  • oled.clear() -> This function clears the display.
  • oled.setCursor(x,y) -> This function sets the cursor in the given x,y position. X is the coloumn value in pixels and Y is the row value. X can have any value starting 0 - 127. Y can have any value from 0-7. Take font sizes into consideration when deiciding on X & Y values
  • oled.setFont(font size) -> This function sets the font size to be used. There are 2 font sizes available. oled.setFont(FONT6X8) sets the font to be used as a smaller font with each font taking up 6 x 8 pixels. So you can have a total of 168 characters.  oled.setFont(FONT8X16) sets the font to be used as a larger font with each font taking up 8 x 16 pixels. So you can have a total of 64 characters. 
  • oled.print(text/value) -> This function prints the text / value given. oled.print("hello world")
  • oled.println(text/value) -> This functions prints the text / value given and then positions the cursor at the beginning of the next line
  • oled.off()-> Turns the display off
  • oled.on() -> Turns the display on if it has been turned off
  • oled.invert(parameter) -> Inverts the display when the parameter passed is 1 and restores the display when the parameter passed is 0. oled.invert(1) or oled.invert(0)

The Code

Here's a simple code to display hello world and explore the various functions



/*  Induino R3 User Guide - Program 22.0 - 0.96"I2C OLED Usage Example using the Induino R3 */

/* This program explore various functions of the DigisparkOLED library using the Induino R4*/

#include <DigisparkOLED.h> // Header for the OLED library
#include <Wire.h>

void setup()
{
  // Initialise Communication with the OLED
  oled.begin();

  // First lets print the line numbers
  // Lets Set the Font to small size. This font takes up one row per character (for the height!)
  oled.setFont(FONT6X8);
  oled.setCursor(0, 0);
  //Print the first number using a println so that the cursor is automatically positioned at the start of the next line. Then repeat this till the last number
  oled.println("1");
  oled.println("2");
  oled.println("3");
  oled.println("4");
  oled.println("5");
  oled.println("6");
  oled.println("7");
  oled.println("8");

  // Set the Font to large size. This font takes up two rows per character (for the height!) as agains the small font that takes up one row per character
  oled.setFont(FONT8X16);

  // Position the Cursor to print Hello in the middle of the Screen. Given the font size and that we have 8 rows in total, printing on the 4th row will take up the 4th and 5th rows
  // leaving the first and last 3 rows empty
  // given that the 5 characters hello take up 40 pixels, we can print from the 45th pixel to keep it at the center
  oled.setCursor(45, 3);
  oled.print("HELLO");
  delay(5000);
  // Lets turn off the display
  oled.off();
  delay(5000);

  // Lets turn on the display
  oled.on();
  delay(5000);

  // Lets invert display
  oled.invert(1);
  delay(5000);

  // Lets restore the inverted display
  oled.invert(0);
  delay(5000);

  // lets wait for some time
  delay(10000);

  // finally clear the screen
  oled.clear();


}

void loop()
{


}


Thats It For This Part! Enjoy... and feel free to drop us an email with questions you might have -> info@simplelabs.co.in

Visit www.simplelabs.co.in for more interesting products

Back to List of Contents

Tuesday, 3 June 2014

PORT Manipulation & 7 Segment LED Interfacing - Working with the Simple Labs Seven Segment cum DTMF Shield

What is Port Manipulation?

So far we have been working on controlling individual pins on the Induino R3. Now we will explore as to how we can use groups of pins together. Pins of a microcontroller are normally grouped together as PORTS. Each PORT can have 6 - 8 Pins (Though 8 Pins is pretty much the standard!). We can control each of these Ports using associated registers and this process of controlling a whole port instead of individual pins is called Port Manipulation.  

Lets take a look at how Pins are mapped on the Atmega 328 Microcontroller on the Induino R3 / Arduino. Take a look at the image here


From the image, we can see that digital pins 0 to 7 are numbered as PD0 to PD7, This denotes they are Part of PORT D. So PORT D consists of pins 0 - 7. Here is how the pins are grouped to ports
  • PORT B => digital pins 8 to 13
  • PORT C => analog input pins A0 - A5
  • PORT D => digital pins 0 to 7

Every PORT has 3 Registers Associated with it
  1. DDR => Data Direction Register - This Register Stores Information as to if a pin is Input or Output
  2. PORT => This Register is a Output Register and all Output states of a pin are written to this register.
  3. PIN => This is a Input Register and Read Only. This register contains the current state of pin configured for Input.

The following are the registers associated with the 3 PORTS of the ATmega328.
  • PORT B => DDRB, PORTB, PINB
  • PORT C => DDRC, PORTC, PINC
  • PORT D => DDRD, PORTD, PIND
Note: Incase of a Board like the Arduino Mega 2560 there are more Ports however the naming convention for the registers will be the same as the above. 

Now Lets look at how these Registers work. Lets take PORT D. All the 3 registers associated with 

Digital Pin 7Digital Pin 6Digital Pin 5Digital Pin 4Digital Pin 3Digital Pin 2Digital Pin 1Digital Pin 0
DDRD1 (OUTPUT) 0  (INPUT)  0  (INPUT)  0  (INPUT)  0  (INPUT)  0  (INPUT)  0  (INPUT)  0  (INPUT) 
PORTD1 (HIGH)1 (Internal Pull up Enabled)0 (Default)0 (Default)0 (Default)0 (Default)0 (Default)0 (Default)
PIND1 (HIGH)1 (HIGH)0 (LOW)0 (LOW)0 (LOW)0 (LOW)0 (LOW)0 (LOW)

In the table above, in the Register DDRD is a 8 bit register with the least significant bit representing pin 0 and the most significant bit representing pin 7. Now in this register the 7th pin is configured as OUTPUT and the remaining pins are configured as INPUTs. When you use the pinMode function, this is the register that gets modified based on the pin number you specify.

The PORTD register has the 7th pin set as a HIGH. This is the register that gets modified when you use the digitalWrite function. Note, The 6th Pin is a Input pin and setting this as HIGH enables the Internal Pullup resistor. The remaining pins are in their default state - LOW.

The PIND register has the value pertaining to the current state of the PIN. In this case it would have HIGH for the 6th & 7th pins,  as they've both been set to HIGH in the PORTD register. However if there is a button connected to PIN 6 (which is configured as INPUT), the value of the 6th pin would vary everytime the button is pressed.

Port Manipulation Example

Lets try a blink program example that uses Port Manipulation. Lets try to Blink all the 3 LEDs on pins 11, 12 & 13 at the same time.


/*  Induino R3 User Guide - Program 21.0 - Port Manipulation Example using the Induino R3 */

/* This program Controls the LEDs 11, 12 & 13 on the Induino R3 using PORT Manipulation*/

void setup()
{
  // Set the 3 Most significant bits corresponding to Pins 11, 12 & 13 as Output in the Data Direction Register
  // You can use binary data directly by preceeding with B
  DDRB = B111000; // This is the same as saying DDRB = 56;
  // Try commenting the above line and uncommenting the below line
  //DDRB = 56;
  // Initialise Serial Communication to see Register Values
  Serial.begin(9600);
}

void loop()
{
  // Set the 3 Most significant bits corresponding to Pins 11, 12 & 13 as HIGH in the PORT Register
  PORTB = B111000;
  // Store the current value of the PIN Register in the variable VAL just to see how the PIN register works
  int val = PINB ;
  Serial.println(val); // Print the value of the variable VAL
  delay(1000); // a delay as in a blink program ;)
  
  // Set the 3 Most significant bits corresponding to Pins 11, 12 & 13 as LOW in the PORT Register
  PORTB = B000000;
  // Store the current value of the PIN Register in the variable VAL
  val = PINB ;
  Serial.println(val); // Print the value of the variable VAL
  delay(1000); // a delay as in a blink program ;) 
  
}


The 7-Segment Display

7-Segment displays are another common component in the world of electronics. These displays have 8 LEDs split into different segments designed to be able to display numerals from 0-9 and a dot.  All The LEDs have a common ground / supply line. There are 5 pins at the top and 5 pins at the bottom. The middle pins in the top and bottom are connected to each other internally and have to be connected to Ground / Supply depending upon the type of the 7-segment Display. You can control each segment like an individual LED. We shall use Port Manipulation to Control these as a set.


The Simple Labs' DTMF / 7-Segment Shield

This shield lets you experiment with DTMF or 7-Segment Displays (You can use only one of these at any given time).  Check here for how to work with the DTMF part.


The shield lets you control up to two Common Cathode type 7-Segment Displays. The shield provides you with options to control the COM pin of the 7-Segment Displays using either an IO or by connecting the COM pin Directly to Ground through a set of jumpers. COM pin of the Digit 1 can be set to be controlled by Digital Pin 10 and COM pin of the Digit 1 can be set to be controlled by Digital Pin 11. See the image below.

Pin Mappings for 7-Segment Displays on the Shield are as per the following image


First Lets try to Control one of 7-Segment Displays. Set the jumper to connect the COM pin of display 1 to ground. (Refer to Jumper Settings image above). You can either remove the other display or set the jumper for it to connect its COM pin to the IO.

Now that we are all set, lets understand what we are about to do.
  • If you noticed, we have used all pins on PORT D to connect to the segments of the 7-Segment Display. This will help us control all the segments at once.
  • To display the number '1' on the 7-segment display, we need to make the segment 'b' (digital Pin 0) & 'c' (digital Pin 4) high and keep all other segments low.

Here's a table with values to display the different numbers

2^7 = 1282^6 = 642^5 = 322^4 = 162^3 = 82^2 = 42^1 = 22^0 = 1
Digital Pin 7Digital Pin 6Digital Pin 5Digital Pin 4Digital Pin 3Digital Pin 2Digital Pin 1Digital Pin 0
DigitDecimal ValueBinary ValueSegment D Segment DP Segment E Segment C  Segment F  Segment G  Segment A  Segment B 
0187101110111 (HIGH)0 (LOW)1 (HIGH)1 (HIGH)1 (HIGH)0 (LOW)1 (HIGH)1 (HIGH)
117000100010 (LOW)0 (LOW)0 (LOW)1 (HIGH)0 (LOW)0 (LOW)0 (LOW)1 (HIGH)
2167101001111 (HIGH)0 (LOW)1 (HIGH)0 (LOW)0 (LOW)1 (HIGH)1 (HIGH)1 (HIGH)
3151100101111 (HIGH)0 (LOW)0 (LOW)1 (HIGH)0 (LOW)1 (HIGH)1 (HIGH)1 (HIGH)
429000111010 (LOW)0 (LOW)0 (LOW)1 (HIGH)1 (HIGH)1 (HIGH)0 (LOW)1 (HIGH)
5158100111101 (HIGH)0 (LOW)0 (LOW)1 (HIGH)1 (HIGH)1 (HIGH)1 (HIGH)0 (LOW)
6190101111101 (HIGH)0 (LOW)1 (HIGH)1 (HIGH)1 (HIGH)1 (HIGH)1 (HIGH)0 (LOW)
719000100110 (LOW)0 (LOW)0 (LOW)1 (HIGH)0 (LOW)0 (LOW)1 (HIGH)1 (HIGH)
8191101111111 (HIGH)0 (LOW)1 (HIGH)1 (HIGH)1 (HIGH)1 (HIGH)1 (HIGH)1 (HIGH)
9159100111111 (HIGH)0 (LOW)0 (LOW)1 (HIGH)1 (HIGH)1 (HIGH)1 (HIGH)1 (HIGH)


We are going to store the above decimal values in an array such that the 0th element of the array will hold the value '187' which is the value to be written to the output register to produce a '0' on the 7 segment display. So anytime we want to display a numeric value, we simply call the array variable with the value of the digit we want to display.

Try the following program. You should see numbers from 0 to 9 being displayed. Ensure you set the jumpers of the Displays to have the common pin connected to GND.


/*  Induino R3 User Guide - Program 21.1 - Controlling a single 7-Segment LED on the Simple Labs 7-Segment / DTMF Shield using the Induino R3 */

/* This program displays the numbers 0 to 9 on the 7 Segment display*/

// An array variable to store the decimal values to be written to the PORT register to produce various digits on the 7 segment.
// The 0th array index holds the value to display '0'. the 1st array index holds the value to display '1' and so on

int seven_seg_val[]={187,17,167,151,29,158,190,19,191,159};

void setup()
{
  // Set all the pins from 0 to 7 as output.
  // You can use binary data directly by preceeding with B
  DDRD = B11111111; // This is the same as saying DDRD = 255;

}

void loop()
{
  // A for loop to iterate through values 0 to 9 that have to be displayed on the 7 segment
  for(int i=0; i< 10; i++)
  {
    // Write the set of values for the current digit to the PORT register
    PORTD = seven_seg_val[i];
    delay(1000);
  }
}

Displaying Multiple Digits

Next lets see how we can produce multiple digits using multiple 7 segments (we will be working with two 7 segment displays however the process will be the same for n number of 7 segment displays!)

To produce multiple digits, we are going to control the common pin and change the values displayed on each of the digits at very high speed so that it appears to the viewer as if a multi digit number is being displayed constantly.

Lets see how to display the number 23.

  1. First control the common pin of the display 1 to turn it ON and control the common pin of the display 2 to turn it OFF
  2. Then Display the number 2 on the display 1 for a short amount of time (very short!). You do this by writing the corresponding value for 2 to the PORT register and adding a delay
  3. At the end of the delay write '0' to the PORT register to clear it
  4. Now control the common pin of the display 1 to turn it OFF and control the common pin of the display 2 to turn it ON
  5. Now Display the number 3 on the display 2 for a short amount of time (very short!). You do this by writing the corresponding value for 3 to the PORT register and adding a delay
  6. At the end of the delay write '0' to the PORT register to clear it
  7. go back and keep repeating from step 1 to 6 
Here's the program to display the number '23'
/*  Induino R3 User Guide - Program 21.2 - Displaying the number 23 using the two 7-Segment LEDs on the Simple Labs 7-Segment / DTMF Shield using the Induino R3 */

/* This program displays the number 23 on the 7 Segment LEDs */

// An array variable to store the decimal values to be written to the PORT register to produce various digits on the 7 segment.
// The 0th array index holds the value to display '0'. the 1st array index holds the value to display '1' and so on

int seven_seg_val[]={187,17,167,151,29,158,190,19,191,159};

void setup()
{
  // Set all the pins from 0 to 7 as output.
  // You can use binary data directly by preceeding with B
  DDRD = B11111111; // This is the same as saying DDRD = 255;
  // set the control pins for the common lines of both the 7 segment displays as OUTPUT
  pinMode(10,OUTPUT);
  pinMode(11,OUTPUT);
  // write a LOW signal to the control pins for the common lines to keep them both disabled
  digitalWrite(10,LOW);
  digitalWrite(11,LOW);
}

void loop()
{
  // A for loop to iterate through values 0 to 9 that have to be displayed on the 7 segment
  for(int i=0; i< 100; i++)
  {
    // Turn ON Display 1 using the control Pin
    digitalWrite(10,HIGH);
    // Turn OFF Display 2 using the control Pin
    digitalWrite(11,LOW);
    // Write the set of values for the digit '2' to the PORT register
    PORTD = seven_seg_val[2];
    // A Short Delay
    delay(1);
    // Reset the PORT Register to 0
    PORTD = 0;
    
    // Turn OFF Display 1 using the control Pin
    digitalWrite(10,LOW);
    // Turn ON Display 2 using the control Pin
    digitalWrite(11,HIGH);
    // Write the set of values for the digit '3' to the PORT register
    PORTD = seven_seg_val[3];
    // A Short Delay
    delay(1);
    // Reset the PORT Register to 0
    PORTD = 0;
  }
}

Displaying Multiple Digits - 0 to 99

Here's an extension of the above program to display the numbers from 0 to 99
/*  Induino R3 User Guide - Program 21.3 - Displaying the numbers 0 to 99 using the two 7-Segment LEDs on the Simple Labs 7-Segment / DTMF Shield using the Induino R3 */

/* This program displays the numbers 0 to 99 on the 7 Segment LEDs */

// An array variable to store the decimal values to be written to the PORT register to produce various digits on the 7 segment.
// The 0th array index holds the value to display '0'. the 1st array index holds the value to display '1' and so on

int seven_seg_val[]={ 187,17,167,151,29,158,190,19,191,159};

void setup()
{
  // Set all the pins from 0 to 7 as output.
  // You can use binary data directly by preceeding with B
  DDRD = B11111111; // This is the same as saying DDRD = 255;
  // set the control pins for the common lines of both the 7 segment displays as OUTPUT
  pinMode(10,OUTPUT);
  pinMode(11,OUTPUT);
  // write a LOW signal to the control pins for the common lines to keep them both disabled
  digitalWrite(10,HIGH);
  digitalWrite(11,HIGH);
}

void loop()
{
  // A for loop to iterate through values 0 to 9 that have to be displayed on tens position of the 7 segment display
  for(int i=0; i<10;i++)
  {
    // A for loop to iterate through values 0 to 9 that have to be displayed on ones position of the 7 segment display
    for(int j=0; j<10;j++)
    {
      // A for loop to add stability to the display - the display looks more stable if the same value is displayed for more number of times at a higher speed.
      for(int k=0; k< 100; k++)
      {
        // Turn ON Display 1 using the control Pin
        digitalWrite(10,HIGH);
        // Turn OFF Display 2 using the control Pin
        digitalWrite(11,LOW);
        // Write the set of values for the digit '2' to the PORT register
        PORTD = seven_seg_val[i];
        // A Short Delay
        delay(1);
        // Reset the PORT Register to 0
        PORTD = 0;

        // Turn OFF Display 1 using the control Pin
        digitalWrite(10,LOW);
        // Turn ON Display 2 using the control Pin
        digitalWrite(11,HIGH);
        // Write the set of values for the digit '3' to the PORT register
        PORTD = seven_seg_val[j];
        // A Short Delay
        delay(1);
        // Reset the PORT Register to 0
        PORTD = 0;
      }
    }
  }
}

Displaying a sensor value

Lets see how to display a Sensor value. We shall display temperature value using a LM35 temperature sensor. Read this tutorial before proceeding (if you already haven't!)
http://www.induino.com/2013/07/the-on-board-sensor-interface.html

Heres how we are going to do it.
  1. Get the temperature value from the analog value
  2. Split the temperature value into 2 digits -> ones and tens values
  3. First control the common pin of the display 1 to turn it ON and control the common pin of the display 2 to turn it OFF
  4. Then Display the number of the ones value on the display 1 for a short amount of time (very short!). 
  5. At the end of the delay write '0' to the PORT register to clear it
  6. Now control the common pin of the display 1 to turn it OFF and control the common pin of the display 2 to turn it ON
  7. Now Display the number of the tens value on the display 2 for a short amount of time (very short!). 
  8. At the end of the delay write '0' to the PORT register to clear it
  9. go back and keep repeating from step 1 to 6 
Here's the program to do it

/*  Induino R3 User Guide - Program 21.4 - Displaying temperature value from a  lm35 sensor using the two 7-Segment LEDs on the Simple Labs 7-Segment / DTMF Shield using the Induino R3 */

/* This program displays the temperature value from a lm35 sensor on the 7 Segment LEDs */

// An array variable to store the decimal values to be written to the PORT register to produce various digits on the 7 segment.
// The 0th array index holds the value to display '0'. the 1st array index holds the value to display '1' and so on

int seven_seg_val[]={ 187,17,167,151,29,158,190,19,191,159};


void setup()
{
  // Set all the pins from 0 to 7 as output.
  // You can use binary data directly by preceeding with B
  DDRD = B11111111; // This is the same as saying DDRD = 255;
  // set the control pins for the common lines of both the 7 segment displays as OUTPUT
  pinMode(10,OUTPUT);
  pinMode(11,OUTPUT);
  // write a LOW signal to the control pins for the common lines to keep them both disabled
  digitalWrite(10,HIGH);
  digitalWrite(11,HIGH);
}

void loop()
{
  // Read the raw sensor value and store it in the variable
  int sensor_val = analogRead(2)/2; 
  int ones = sensor_val%10;
  int tens = sensor_val/10;
      // A for loop to add stability to the display - the display looks more stable if the same value is displayed for more number of times at a higher speed.
      for(int k=0; k< 100; k++)
      {
        // Turn ON Display 1 using the control Pin
        digitalWrite(10,HIGH);
        // Turn OFF Display 2 using the control Pin
        digitalWrite(11,LOW);
        // Write the set of values for the digit '2' to the PORT register
        PORTD = seven_seg_val[ones];
        // A Short Delay
        delay(1);
        // Reset the PORT Register to 0
        PORTD = 0;

        // Turn OFF Display 1 using the control Pin
        digitalWrite(10,LOW);
        // Turn ON Display 2 using the control Pin
        digitalWrite(11,HIGH);
        // Write the set of values for the digit '3' to the PORT register
        PORTD = seven_seg_val[tens];
        // A Short Delay
        delay(1);
        // Reset the PORT Register to 0
        PORTD = 0;
      }
}

Thats It For This Part! Enjoy... and feel free to drop us an email with questions you might have -> info@simplelabs.co.in

Visit www.simplelabs.co.in for more interesting products

Back to List of Contents

Monday, 24 February 2014

LCD Interfacing - Creating Custom Characters

So you have been using an LCD for sometime and now have the need to create a custom character / symbol... How do you do it?
(Please check this before proceeding -   LCD Interfacing - Working with the Simple Labs' LCD Shield)

Before getting onto it, lets understand how an LCD displays characters. If you notice, each character on a LCD display typically is inside a small 5 Rows x 8 Columns array of dots. Depending upon the character to be displayed, the required dots are turned On / Off. Most LCD's come pre-configured to display standard characters. Each character has a definition matrix, which defines which dots are to be On and which dots are to be Off.

Here's an image that will help you understand better. Here's a Custom Smiley and its corresponding Binary definition

Here's how we will define a BYTE variable to hold the definition for the above Character. If you look at it the first row above is stored in the 0th index of the array mySmiley.

byte mySmiley[8] = {
0b00000, 
0b01010, 
0b01010, 
0b01010, 
0b00000, 
0b10001, 
0b01110,
0b00000
};

if Binary is not your game, you can use the below image, to find the decimal equivalent. (both images are using different characters - so use your common sense ;) )


So we can rewrite the definition in decimal as follows
byte mySmiley[8] = { 0, 10,10,10,0,17,14,0};

Here's a simple program to display the Smiley on your LCD

Here's the Program
/*  Induino R3 User Guide - Program 20.0 - LCD Interfacing - Creating Custom Characters on a 16x2 LCD using the Induino R3 */

/* This program uses the Simple Labs LCD Shield, 16x2 LCD from Simple Labs and the Induino R3 Board. Change the pin numbers according your own hardware */

#include <LiquidCrystal.h> //Include the LCD Header

// initialize the lcd
LiquidCrystal lcd(8, 9,10, 11, 12,13);

byte mySmiley[8] = {0,10,10,10,0,17,14,0}; // Define the Smiley Character


void setup()
{
  // add the mySmiley Character to the 0th Location of the LCD's CGRAM 
  // 0-7 are possible values here
  lcd.createChar(0, mySmiley);
  
  // set up number of columns and rows
  lcd.begin(16, 2); 
  
  // Write out Smiley Character.
 // Type casting is required as we are directly mentioning a value
  lcd.write((uint8_t)0); 
}

void loop()
{

}


Now lets play around by creating a set of 8 Characters, each representing a line at a different height (see the output to get a clear understanding)

byte line_0[8] = { 0,0,0,0,0,0,0,31};
byte line_1[8] = { 0,0,0,0,0,0,31,0};
byte line_2[8] = { 0,0,0,0,0,31,0,0};
byte line_3[8] = { 0,0,0,0,31,0,0,0};
byte line_4[8] = { 0,0,0,31,0,0,0,0};
byte line_5[8] = { 0,0,31,0,0,0,0,0};
byte line_6[8] = { 0,31,0,0,0,0,0,0};
byte line_7[8] = { 31,0,0,0,0,0,0,0};

Now the above definition can be optimized by making it an array, so we can redefine it as 

byte line[8][8]={
{ 0,0,0,0,0,0,0,31},
{ 0,0,0,0,0,0,31,0},
{ 0,0,0,0,0,31,0,0},
{ 0,0,0,0,31,0,0,0},
{ 0,0,0,31,0,0,0,0},
{ 0,0,31,0,0,0,0,0},
{ 0,31,0,0,0,0,0,0},
31,0,0,0,0,0,0,0}
};

Here's the Program
/*  Induino R3 User Guide - Program 20.1 - LCD Interfacing - Creating Custom Characters on a 16x2 LCD using the Induino R3 */

/* This program uses the Simple Labs LCD Shield, 16x2 LCD from Simple Labs and the Induino R3 Board. Change the pin numbers according your own hardware */

#include <LiquidCrystal.h> //Include the LCD Header

// initialize the lcd
LiquidCrystal lcd(8, 9,10, 11, 12,13);

byte mySmiley[8] = {0,10,10,10,0,17,14,0}; // Define the Smiley Character


void setup()
{
  // add the custom characters to the LCD's CGRAM 
  lcd.createChar(0, mySmiley);
  
  // set up number of columns and rows
  lcd.begin(16, 2); 
  
  // Write out the custom Characters
  // Type casting is required as we are directly mentioning a value
  lcd.write((uint8_t)0); 
}

void loop()
{

}

Now Lets to try to modify the above program to create a set of characters that can produce a BAR Graph with 8 different levels.

First we redefine the Character Array

byte line[8][8]={
{ 0,0,0,0,0,0,0,31}, // Level 1
{ 0,0,0,0,0,0,31,31}// Level 2
{ 0,0,0,0,0,31,31,31}// Level 3
{ 0,0,0,0,31,31,31,31}// Level 4
{ 0,0,0,31,31,31,31,31}// Level 5
{ 0,0,31,31,31,31,31,31}// Level 6
{ 0,31,31,31,31,31,31,31}// Level 7
31,31,31,31,31,31,31,31// Level 8
};

Here's the Program
/*  Induino R3 User Guide - Program 20.2 - LCD Interfacing - Creating Custom Characters on a 16x2 LCD using the Induino R3 */

/* This program creates a series of Bar Graph Characters- an experimentation with custom characters */

#include <LiquidCrystal.h> //Include the LCD Header

// initialize the lcd
LiquidCrystal lcd(8, 9,10, 11, 12,13);

// Define the Characters for creating a Bar Graph with Various Levels
byte line[8][8]={
{ 0,0,0,0,0,0,0,31}, // Level 1
{ 0,0,0,0,0,0,31,31}, // Level 2
{ 0,0,0,0,0,31,31,31}, // Level 3
{ 0,0,0,0,31,31,31,31}, // Level 4
{ 0,0,0,31,31,31,31,31}, // Level 5
{ 0,0,31,31,31,31,31,31}, // Level 6
{ 0,31,31,31,31,31,31,31}, // Level 7
{ 31,31,31,31,31,31,31,31} // Level 8
};

void setup()
{
  // add the custom characters to the LCD's CGRAM 
  for(int i =0; i <8; i++)
  {
    lcd.createChar(i, line[i]);
  }
  // set up number of columns and rows
  lcd.begin(16, 2); 
}

void loop()
{
  // Show the Bar Graph Characters as increasing
  for(int i =0; i <8; i++)
  {
   // Print the Bar Graph Character on the First Line
   lcd.setCursor(i,0);   
   lcd.write(i);
   
   // Print the Corresponding value on the Second Line
   lcd.setCursor(i,1);   
   lcd.print(i);
   delay(1000); 
  }
  delay(1000); 
  // Clear the display
  lcd.clear();
}

Now lets use the bar graph characters to indicate sensor value. We shall use the value of the LDR on the Induino R3 board and try to represent it using the Bar Graph.

Here's the Program
/*  Induino R3 User Guide - Program 20.3 - LCD Interfacing Custom Characters- Displaying the LDR Value as a Single Bar Graph Character Induino R3 */

/* This program creates a series of Bar Graph Characters- an experimentation with custom characters */

#include <LiquidCrystal.h> //Include the LCD Header

// initialize the lcd
LiquidCrystal lcd(8, 9,10, 11, 12,13);

// Define the Characters for creating a Bar Graph with Various Levels
byte line[8][8]={
{ 0,0,0,0,0,0,0,31}, // Level 1
{ 0,0,0,0,0,0,31,31}, // Level 2
{ 0,0,0,0,0,31,31,31}, // Level 3
{ 0,0,0,0,31,31,31,31}, // Level 4
{ 0,0,0,31,31,31,31,31}, // Level 5
{ 0,0,31,31,31,31,31,31}, // Level 6
{ 0,31,31,31,31,31,31,31}, // Level 7
{ 31,31,31,31,31,31,31,31} // Level 8
};

void setup()
{
  // add the custom characters to the LCD's CGRAM 
  for(int i =0; i <8; i++)
  {
    lcd.createChar(i, line[i]);
  }
  // set up number of columns and rows
  lcd.begin(16, 2); 
}

void loop()
{
 // Read the LDR Value and store it in a variable
 int val = analogRead(3);
 // Map the analog value from the sensor to a scale of 0 to 7 (8 Levels)
 val = map(val, 0, 1023, 0, 7);
 
 // Print the numerical value to the LCD
 lcd.setCursor(0,1);
 lcd.print(val);
 
 //set the cursor
 lcd.setCursor(0,0);
 
  // Write the Bar Graph Level Value corresponding to the Value of the LDR

 lcd.write(val);
 
 delay(100);  
 lcd.clear(); 
}

Now Having a static Bar is not much fun, lets convert this into a realtime BAR graph. A Running Bar Graph based on the last 16 values of the sensor. 16 Values as we can display only 16 characters per line.

/*  Induino R3 User Guide - Program 20.4 - LCD Interfacing Custom Characters- Displaying the LDR Value as a Running Bar Graph using the Induino R3 */

/* This program creates a series of Bar Graph Characters- an experimentation with custom characters */

#include <LiquidCrystal.h> //Include the LCD Header

// initialize the lcd
LiquidCrystal lcd(8, 9,10, 11, 12,13);

// Define the Characters for creating a Bar Graph with Various Levels
byte line[8][8]={
{ 0,0,0,0,0,0,0,31}, // Level 1
{ 0,0,0,0,0,0,31,31}, // Level 2
{ 0,0,0,0,0,31,31,31}, // Level 3
{ 0,0,0,0,31,31,31,31}, // Level 4
{ 0,0,0,31,31,31,31,31}, // Level 5
{ 0,0,31,31,31,31,31,31}, // Level 6
{ 0,31,31,31,31,31,31,31}, // Level 7
{ 31,31,31,31,31,31,31,31} // Level 8
};

// a variable array to store the last 16 values of the sensor
int hist_val[16];

// to count the first 16 values
int cnt = 0;

void setup()
{
  // add the custom characters to the LCD's CGRAM 
  for(int i =0; i <8; i++)
  {
    lcd.createChar(i, line[i]);
  }
  // set up number of columns and rows
  lcd.begin(16, 2); 
}

void loop()
{
 // Read the LDR Value and store it in a variable
 int val = analogRead(3);
 // Map the analog value from the sensor to a scale of 0 to 7 (8 Levels)
 val = map(val, 0, 1023, 0, 7);
 
 lcd.setCursor(0,0);
 lcd.print(val);
 
 // Check if cnt is less than 16, if it is less than 16, we need to increment it
// we also need to store the values of the sensor for the first 16 counts
 if(cnt<16)
 {
   hist_val[cnt] = val;
   // Increment cnt  
   cnt++;
 }
 else
 // if count is greater than 16, we need to push out the oldest of the values and add the latest value to the set of 16 values.
 // the oldest value will be stored in the 0th array index and the latest value in the 15th array index
 // in addition, we also need to move up all other historic values by one position
 {
   // do the moving up of the historic values
   for(int j=0; j<15;j++) 
     hist_val[j] = hist_val[j+1];
     
   // store the latest value in the last position
   hist_val[15] = val; 
 }
 // Displaying the Values as a Running Bar Graph
 for(int i=0; i<cnt; i++)
 {
    lcd.setCursor(i,0);
                  lcd.write(hist_val[i]);
                 /* lcd.setCursor(i,1);
                  lcd.print(hist_val[i]); */
                  delay(10);
 }

}

Thats It For This Part! Enjoy... and feel free to drop us an email with questions you might have -> info@simplelabs.co.in

Visit www.simplelabs.co.in for more interesting products

Monday, 17 February 2014

Interfacing Sensors - Microphone Sound Detection Sensor

Microphone Sound Detection Sensor

The Microphone Sound Detection Sensor is a simple sensor that detects sound using a Condenser Mike. It can give either a RAW analog output or a Comparator based Digital Output. The Analog Output is the Output from a Potential Divider constructed between the Microphone and the Trimpot. The Digital Output is that of a Comparator that takes in the potential divider as one Input and a fixed resistance as the other. 



Connections

If you are using the Induino R3 Board, You can plug the sensor directly onto the Sensor Interface on the Board. Like in the Image Below.



  1. Connect '+' pin of the Sensor module to +5V on the Induino R3 / Arduino Board
  2. Connect the 'G' pin of the Sensor module to the GND pin on the Induino R3 / Arduino Board
  3. Connect the 'DO' pin of the Sensor module to Digital Pin 16 (A2) on the Induino R3 / Arduino Board
Adjusting the Sound Sensor Sensitivity

The Trimpot on the Sensor, lets you adjust the Sound Sensor Sensitivity. The LED marked L2 (below the Trimpot) indicates the digital output of the sensor. To adjust the sensitivity, Adjust the Trimpot using a Screw Driver. Clock Wise Rotation, Decreases the Sensitivity and Anti-Clock Wise Rotation Increases it. Once the sensitivity is set,  Verify by making a sound and checking if the LED L2 Turns On when you make the desired sound. 


Programming for the Microphone Sound Detection Sensor

Here's a Simple Program that toggles On / Off the LED on the 13th Pin everytime a clap is detected.


Here's the Program
/*  Induino R3 User Guide - Program 19.0 - Interfacing Microphone Sound Detection Sensor with the Induino R3 */

#define mic 16 // The Microphone Sound Detection Sensor's Digital Output Pin is Connected to Pin 16 / A2 of Induino R3

boolean state = 0;

void setup()
{
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
  
  // Setup the 13the pin LED for OUTPUT
  pinMode(13, OUTPUT);
  
  // Setup the sensor input pin
  pinMode(mic, INPUT);
  
}

void loop()
{
  if(digitalRead(mic)) // Check if the Sensor Input is HIGH
  {
   state = !state; // Toggle the State Variable
   digitalWrite(13, state); // Set the Current State to the OUTPUT LED
   delay(1000); // Wait for the INPUT to become stable
  }
}

Thats It For This Part! Enjoy... and feel free to drop us an email with questions you might have -> info@simplelabs.co.in

Visit www.simplelabs.co.in for more interesting products