ZigBee communication with Arduino

Now a days Arduino is very famous development Board , Using different places in electronics and projects and making of the different products.

About ZigBee:

ZigBee is a specification for a suite of high level communication protocols used to create personal area networks built from small, low-power digital radios. ZigBee is based on an IEEE 802.15 standard. Though low-powered, ZigBee devices can transmit data over long distances by passing data through intermediate devices to reach more distant ones, creating a mesh network; i.e., a network with no centralized control or high-power transmitter/receiver able to reach all of the networked devices. The decentralized nature of such wireless ad hoc networks make them suitable for applications where a central node can't be relied upon.

ZigBee is used in applications that require only a low data rate, long battery life, and secure networking. ZigBee has a defined rate of 250 kbit/s, best suited for periodic or intermittent data or a single signal transmission from a sensor or input device. Applications include wireless light switches, electrical meters with in-home-displays, traffic management systems, and other consumer and industrial equipment that requires short-range wireless transfer of data at relatively low rates. The technology defined by the ZigBee specification is intended to be simpler and less expensive than other WPANs, such as Bluetooth or Wi-Fi.

ZigBee networks are secured by 128 bit symmetric encryption keys. In home automation applications, transmission distances range from 10 to 100 meters line-of-sight, depending on power output and environmental characteristics.

ZigBee was conceived in 1998, standardized in 2003, and revised in 2006. The name refers to the waggle dance of honey bees after their return to the beehive. 

Device types and operating modes

ZigBee devices are of three types:

• ZigBee Coordinator (ZC): The most capable device, the Coordinator forms the root of the network tree and might bridge to other networks. There is exactly one ZigBee Coordinator in each network since it is the device that started the network originally (the ZigBee LightLink specification also allows operation without a ZigBee Coordinator, making it more usable for over-the-shelf home products). It stores information about the network, including acting as the Trust Center & repository for security keys.^[24][25]
• ZigBee Router (ZR): As well as running an application function, a Router can act as an intermediate router, passing on data from other devices.
• ZigBee End Device (ZED): Contains just enough functionality to talk to the parent node (either the Coordinator or a Router); it cannot relay data from other devices. This relationship allows the node to be asleep a significant amount of the time thereby giving long battery life. A ZED requires the least amount of memory, and therefore can be less expensive to manufacture than a ZR or ZC.

The current ZigBee protocols support beacon and non-beacon enabled networks. In non-beacon-enabled networks, an unslotted CSMA/CA channel access mechanism is used. In this type of network, ZigBee Routers typically have their receivers continuously active, requiring a more robust power supply. However, this allows for heterogeneous networks in which some devices receive continuously, while others only transmit when an external stimulus is detected. The typical example of a heterogeneous network is a wireless light switch: The ZigBee node at the lamp may receive constantly, since it is connected to the mains supply, while a battery-powered light switch would remain asleep until the switch is thrown. The switch then wakes up, sends a command to the lamp, receives an acknowledgment, and returns to sleep. In such a network the lamp node will be at least a ZigBee Router, if not the ZigBee Coordinator; the switch node is typically a ZigBee End Device.

In beacon-enabled networks, the special network nodes called ZigBee Routers transmit periodic beacons to confirm their presence to other network nodes. Nodes may sleep between beacons, thus lowering their duty cycle and extending their battery life. Beacon intervals depend on data rate; they may range from 15.36 milliseconds to 251.65824 seconds at 250 kbit/s, from 24 milliseconds to 393.216 seconds at 40 kbit/s and from 48 milliseconds to 786.432 seconds at 20 kbit/s. However, low duty cycle operation with long beacon intervals requires precise timing, which can conflict with the need for low product cost.

In general, the ZigBee protocols minimize the time the radio is on, so as to reduce power use. In beaconing networks, nodes only need to be active while a beacon is being transmitted. In non-beacon-enabled networks, power consumption is decidedly asymmetrical: some devices are always active, while others spend most of their time sleeping.

Except for the Smart Energy Profile 2.0, ZigBee devices are required to conform to the IEEE 802.15.4-2003 Low-Rate Wireless Personal Area Network (LR-WPAN) standard. The standard specifies the lower protocol layers—the physical layer (PHY), and the media access control portion of the data link layer (DLL). The basic channel access mode is "carrier sense, multiple access/collision avoidance" (CSMA/CA). That is, the nodes talk in the same way that humans converse; they briefly check to see that no one is talking before they start, with three notable exceptions. Beacons are sent on a fixed timing schedule and do not use CSMA. Message acknowledgments also do not use CSMA. Finally, devices in beacon-enabled networks that have low latency real-time requirements may also use Guaranteed Time Slots (GTS), which by definition do not use CSMA.

for the more information please visit  the below links

http://potentiallabs.com/cart/automatic-station-name-display-in-train-using-zigbee?search=zigbee

detailed video please visit the youtube link ....
https://www.youtube.com/watch?v=SBjvDa1uC3E
 

Raspberry Pi with LED ON/OFF

We did a very simple experiment on interfacing a single LED to the GPIO of Raspberry Pi.

The basic circuit diagram is shown below:

Here, we used GPIO8 of the Raspberry Pi and connected it to the LED through a current limiting resistor of 200E.

The python code to blink the LED ON/OFF continuously is shown below:

import RPi.GPIO as GPIO

import time

pinNum = 8

GPIO.setmode(GPIO.BCM) #numbering scheme that corresponds to breakout board and pin layout

GPIO.setup(pinNum,GPIO.OUT) #replace pinNum with whatever pin you used, this sets up that pin as an output

#set LED to flash forever

while True:

  GPIO.output(pinNum,GPIO.HIGH)

  time.sleep(0.5)

  GPIO.output(pinNum,GPIO.LOW) 

  time.sleep(0.5)

To run the above code, save it in any file, say led.py using any text editor. Once saved, run this command to see the LED in action:




sudo python led.py


 

Change with the different GPIO pins and have a fun...................

Raspberry pi with 16x2 lcd display

There are so many example libraries are available...
m also taken from  those examples only..but i modified something and tested lot...

thanks for developers of raspberry pi....

for the connection withe raspberry pi and 16x2 lcd....

pin configuration of the raspberry pi

pin configuration of the16x2 lcd

how to connect the 16x2 display with the raspberry pi

check the code of the python...dump on the raspberry pi

Usually the device requires 8 data lines to provide data to Bits 0-7. However the device can be set to a “4 bit” mode which allows you to send data in two chunks (or nibbles) of 4 bits. This is great as it reduces the number of GPIO connections you require when interfacing with your Pi.

Here is how I wired up my LCD :

LCD Pin	Function	Pi Function	Pi Pin
01	GND	GND	P1-06
02	+5V	+5V	P1-02
03	Contrast	GND	P1-06
04	RS	GPIO7	P1-26
05	RW	GND	P1-06
06	E	GPIO8	P1-24
07	Data 0
08	Data 1
09	Data 2
10	Data 3
11	Data 4	GPIO25	P1-22
12	Data 5	GPIO24	P1-18
13	Data 6	GPIO23	P1-16
14	Data 7	GPIO18	P1-12
15	+5V via 560ohm
16	GND		P1-06

NOTE : The RW pin allows the device to be be put into read or write mode. I wanted to send data to the device but did not want it to send data to the Pi so I tied this pin to ground. The Pi can not tolerate 5V inputs on its GPIO header. Tying RW to ground makes sure the device does not attempt to pull the data lines to 5V which would damage the Pi.

In order to control the contrast you can adjust the voltage presented to Pin 3. This must be between 0 and 5V. I tied this pin to ground.

Pin 15 provides 5V to the backlight LED. It wasn’t clear on my device if this could be connected direct to 5V so I played safe and placed a 560ohm resistor in line with this pin.

Python

You can control a HD44780 style display using any programmming environment you like but my weapon of choice is Python. I use the RPi.GPIO library to provide access to the GPIO.

Here is my code :

#!/usr/bin/python

#

# HD44780 LCD Test Script for

# Raspberry Pi

#

# Author : Durgam anil

# Site   : http://potentialabs.com

# Online Store :http://potentiallabs.com/cart

#more info :anildurgam.blogspot.com

# 

# Date   : 17/12/2013

#

# The wiring for the LCD is as follows:

# 1 : GND

# 2 : 5V

# 3 : Contrast (0-5V)*

# 4 : RS (Register Select)

# 5 : R/W (Read Write)       - GROUND THIS PIN

# 6 : Enable or Strobe

# 7 : Data Bit 0             - NOT USED

# 8 : Data Bit 1             - NOT USED

# 9 : Data Bit 2             - NOT USED

# 10: Data Bit 3             - NOT USED

# 11: Data Bit 4

# 12: Data Bit 5

# 13: Data Bit 6

# 14: Data Bit 7

# 15: LCD Backlight +5V**

# 16: LCD Backlight GND

#import

import RPi.GPIO as GPIO

import time

# Define GPIO to LCD mapping

LCD_RS = 7

LCD_E  = 8

LCD_D4 = 25 

LCD_D5 = 24

LCD_D6 = 23

LCD_D7 = 18

# Define some device constants

LCD_WIDTH = 16    # Maximum characters per line

LCD_CHR = True

LCD_CMD = False

LCD_LINE_1 = 0x80 # LCD RAM address for the 1st line

LCD_LINE_2 = 0xC0 # LCD RAM address for the 2nd line 

# Timing constants

E_PULSE = 0.00005

E_DELAY = 0.00005

def main():

  # Main program block

  GPIO.setmode(GPIO.BCM)       # Use BCM GPIO numbers

  GPIO.setup(LCD_E, GPIO.OUT)  # E

  GPIO.setup(LCD_RS, GPIO.OUT) # RS

  GPIO.setup(LCD_D4, GPIO.OUT) # DB4

  GPIO.setup(LCD_D5, GPIO.OUT) # DB5

  GPIO.setup(LCD_D6, GPIO.OUT) # DB6

  GPIO.setup(LCD_D7, GPIO.OUT) # DB7

  # Initialise display

  lcd_init()

  # Send some test

  lcd_byte(LCD_LINE_1, LCD_CMD)

  lcd_string("Rasbperry Pi")

  lcd_byte(LCD_LINE_2, LCD_CMD)

  lcd_string("Model B")

  time.sleep(3) # 3 second delay

  # Send some text

  lcd_byte(LCD_LINE_1, LCD_CMD)

  lcd_string("Potentiallabs")

  lcd_byte(LCD_LINE_2, LCD_CMD)

  lcd_string(".HYDERBAD,INDIA")

  time.sleep(20)

def lcd_init():

  # Initialise display

  lcd_byte(0x33,LCD_CMD)

  lcd_byte(0x32,LCD_CMD)

  lcd_byte(0x28,LCD_CMD)

  lcd_byte(0x0C,LCD_CMD)  

  lcd_byte(0x06,LCD_CMD)

  lcd_byte(0x01,LCD_CMD)  

def lcd_string(message):

  # Send string to display

  message = message.ljust(LCD_WIDTH," ")  

  for i in range(LCD_WIDTH):

    lcd_byte(ord(message[i]),LCD_CHR)

def lcd_byte(bits, mode):

  # Send byte to data pins

  # bits = data

  # mode = True  for character

  #        False for command

  GPIO.output(LCD_RS, mode) # RS

  # High bits

  GPIO.output(LCD_D4, False)

  GPIO.output(LCD_D5, False)

  GPIO.output(LCD_D6, False)

  GPIO.output(LCD_D7, False)

  if bits&0x10==0x10:

    GPIO.output(LCD_D4, True)

  if bits&0x20==0x20:

    GPIO.output(LCD_D5, True)

  if bits&0x40==0x40:

    GPIO.output(LCD_D6, True)

  if bits&0x80==0x80:

    GPIO.output(LCD_D7, True)

  # Toggle 'Enable' pin

  time.sleep(E_DELAY)    

  GPIO.output(LCD_E, True)  

  time.sleep(E_PULSE)

  GPIO.output(LCD_E, False)  

  time.sleep(E_DELAY)      

  # Low bits

  GPIO.output(LCD_D4, False)

  GPIO.output(LCD_D5, False)

  GPIO.output(LCD_D6, False)

  GPIO.output(LCD_D7, False)

  if bits&0x01==0x01:

    GPIO.output(LCD_D4, True)

  if bits&0x02==0x02:

    GPIO.output(LCD_D5, True)

  if bits&0x04==0x04:

    GPIO.output(LCD_D6, True)

  if bits&0x08==0x08:

    GPIO.output(LCD_D7, True)

  # Toggle 'Enable' pin

  time.sleep(E_DELAY)    

  GPIO.output(LCD_E, True)  

  time.sleep(E_PULSE)

  GPIO.output(LCD_E, False)  

  time.sleep(E_DELAY)   

if __name__ == '__main__':

  main()

the output look like this