Btech Thesis

1

Speech Transmission over ZigBee Network

THESIS

Submitted for the partial fulfilment of the

degree of

Bachelor of Technology

(Electronics and Communication Engineering)

By

Chandana Kandru (BT09ECE004)

Pragya Agrawal (BT09ECE011)

Under the guidance of

Dr. A.S. Gandhi

Professor

Department of Electronics and

Communication Engineering

DEPARTMENT OF ELECTRONICS AND COMMUNICATION ENGINEERING

VISVESVARAYA NATIONAL INSTITUTE OF TECHNOLOGY, NAGPUR

2012-13

2

DECLARATION

We the students of the Department of Electronics and Communication Engineering, VNIT

Nagpur state that the thesis entitled “Speech transmission over ZigBee Network” is our

original work and has not been submitted to any other institute or university for any other

degree. This work is being submitted for the partial fulfilment of the B.Tech degree for the

session 2012-13.

Chandana Kandru

Pragya Agrawal

3

CERTIFICATE

This is to certify that the project work embodied in the thesis entitled “Speech transmission

over ZigBee Network” is genuine and has not been submitted to any other institute or

university for any other degree. This bonafide work has been carried out by:

CHANDANA KANDRU BT09ECE004

PRAGYA AGRAWAL BT09ECE011

in partial fulfilment of the requirements for the award of the Degree of Bachelor of

Technology (Electronics and Communication Engineering) from Visvesvaraya National

Institute of Technology, Nagpur, during 2012-2013.

Dr. A.S. Gandhi

Professor,


Communication Engineering,

VNIT, Nagpur.

Dr. K.D. Kulat

Head of Department,


Communication Engineering,

VNIT, Nagpur.

4

ACKNOWLEDGEMENTS

We would like to express our heartfelt gratitude to our guides Dr. A. S. Gandhi for their

valuable advice and constant support. His insightful suggestions have aided us in the

successful completion of our project work.

We also thank Prof. K.D.Kulat, Head of the Department, Electronics and Communication

Engineering, VNIT Nagpur for extending the departmental facilities for our research.

We are extremely grateful to all the faculty and staff of the Department of Electronics and

Communication Engineering for providing us unwavering guidance and support for the entire

four years of our bachelors’ degree course. Finally we would like to express our deepest

gratitude to all our friends in VNIT Nagpur for the help and cooperation they have extended

over the past four years.

5

ABSTRACT

The ZigBee standard is designed to enable the deployment of low-cost, low-power wireless

sensor and control networks based on the IEEE 802.15.4 physical radio standard.

Transmission of voice with acceptable QoS requires high bandwidth channel. ZigBee

operates in 2.4 GHz ISM band with a maximum possible data rate of 250 kbps. Despite the

low data rates of ZigBee, its use for transmission of voice has been proven to be feasible.

However, the system should guarantee the QoS throughput on the channel with minimal

occupancy of the allowable channel bandwidth. So, voice must be compressed before being

transmitted. The compression algorithm should be implemented on a low power processor for

extending the lifetime of the system. The challenges include selection and implementation of

the most suitable voice codec for high-quality voice transmission over constrained networks,

using constrained devices.

In this project we transmit human speech over ZigBee by implementing Speex compression

algorithm on DSP hardware TMS320C5505. The RF module used for transmission is

CC2520.

6

TABLE OF CONTENTS

DECLARATION.........................................................................................................2

CERTIFICATE...........................................................................................................3

ACKNOWLEDGEMENTS.......................................................................................4

ABSTRACT…………………………………………………………….....................5

LIST OF FIGURES……………………….……………………………...................8

LIST OF TABLES......................................................................................................9

CHAPTERS

1. INTRODUCTION.........................................................................................10

1.1 NETWORK SELECTION.....................................................................10

1.2 CODEC SELECTION............................................................................12

1.3 PLATFORM SELECTION...................................................................12

2. BACKGROUND...........................................................................................13

2.1 SPEECH CODEC...................................................................................13

2.1.1 Speex Codec.................................................................................14

2.1.2 Analysis of node data rate..........................................................15

2.2 ZIGBEE NETWORK.............................................................................15

2.2.1 Nodes in ZigBee Network...........................................................15

2.2.2 ZigBee PANs................................................................................16

2.2.3 ZigBee Channels..........................................................................16

2.2.4 ZigBee PAN Ids...........................................................................17

2.2.5 Network Address.........................................................................17

2.2.6 MAC Address..............................................................................17

2.2.7 Sending and Receiving data in ZigBee network.......................18

2.2.8 Addressing within the node........................................................18

2.2.8.1 Endpoints...............................................................................19

2.2.8.2 Clusters..................................................................................19

2.2.9 ZigBee Application Support Sublayer (APS)...........................20

2.2.9.1 APS Acknowledgements.......................................................21

2.2.9.2 Application Profiles..............................................................21

2.2.9.3 Device Ids...............................................................................21

7

2.2.9.4 Simple Descriptor..................................................................22

2.2.10 ZigBee Network Services............................................................22

2.2.10.1 ZigBee device profile.................................................22

3. HARDWARE................................................................................................24

3.1 ezDSP STICK..........................................................................................25

3.2 ProFLEX01-R2 MODULE....................................................................27

4. SOFTWARE IMPLEMENTATION..........................................................28

4.1 TOOLS USED.........................................................................................28

4.2 SPEECH COMPRESSION....................................................................29

4.2.1 Speex Codec.................................................................................29

4.2.2 DMA.............................................................................................30

4.2.3 UART...........................................................................................31

4.3 TRANSMISSION OVER ZIGBEE......................................................35

4.3.1 LSRApp_Init( )............................................................................37

4.3.2 LSRApp_ProcessEvent()............................................................38

4.3.3 Sending Message.........................................................................39

4.3.4 Receiving Message......................................................................41

4.4 CONCLUSION.......................................................................................43

APPENDIX................................................................................................................44

Program code for Speex Compression on TMS320C5505.........................44

Program code for ZigBee transmission........................................................57

REFERENCES.........................................................................................................66

8

LIST OF FIGURES

Figure 1: ZigBee Stack Architecture.......................................................................................10

Figure 2: APS end-to-end acknowledgements........................................................................11

Figure 3: Block diagram of the overall system.......................................................................14

Figure 4: TMS320C5505 ezDSP STICK................................................................................15

Figure 5: Expansion connector for ezDSP STICK..................................................................16

Figure 6: Board with expansion connector indicating connections........................................16

Figure 7: PROFLEX01-R2 development board……………………………………………17

Figure 8: ProFLEX01-R2 Module Block Diagram…………………………………………18

Figure 9: Programming the ProFLEX Module using MSP FET430UIF JTAG Debugger.....18

Figure 10: Flowchart representing speech compression using Speex.....................................23

Figure 11: Screenshots indicating project build in Code Composer Studio...........................24

Figure 12: Flowchart representing sending of message over the air using ZigBee................30

Figure 13: Flowchart representing receiving of message over the air using ZigBee..............31

Figure 14: Screenshots indicating Coordinator and End device project build in IAR............32

9

LIST OF TABLES

Table 1: Comparison of ZigBee with contemporary technologies...........................................1

Table 2: Nodes in ZigBee Network..........................................................................................6

Table 3: List of source and header files of Speex that need to be included in the project.....20

10

1. INTRODUCTION

IEEE 802.15.4 ZigBee standard is a wireless technology operating over 2.4 GHz frequency.

The maximum data rate supported by this technology is 250 kbps.

ZigBee has following features:

Low power consumption

Network can have large number of devices (65535 per network) when it uses short

addressing

Leaving and joining network is rapid of the order of milliseconds (less than 30ms)

Protocol stack is simpler

Supports periodic, intermittent and repetitive data

1.1 NETWORK SELECTION:

1.1.1 Why ZigBee?

The main advantages of ZigBee over rival technologies like Bluetooth, Wi-Fi is low power

consumption and higher network range.

This is because of the mesh and tree networking being allowed in addition to the star

networking supported by Bluetooth and Wi-fi, which means when we are not in the range of

the node that we wish to communicate with, other nodes in between, can be asked to pass the

message along.

Thus by halving the range of radio reduces power consumption by 75%, leading to dramatic

power consumptions without compromising range.

ZigBee Wi-Fi Bluetooth

Range 10-100 m 50-100 m 10-100 m

Networking

Topology

Ad-hoc, peer to peer,

star, mesh

Point to hub Ad-hoc, very small

networks

Operating

Frequency

868 MHz (Europe)

915 MHz (USA)

2.4 GHz (worldwide)

2.4 GHz,

5 GHz.

2.4 GHz

Complexity Low High High

Power

Consumption

Very low High Medium

Table 1: Comparison of ZigBee with contemporary technologies

11

1.2 CODEC SELECTION:

Due to the limited available bandwidth for ZigBee, voice must be compressed before being

transmitted.

The maximum bit rate supported by ZigBee is 250kbps but due to packet

overheads while transmission the data rate is reduced to 38kbps. Hence for high

quality speech transmission over ZigBee only narrowband voice codecs can be

used.

Also the DSP processor used to implement codec eliminates the use of wideband

codecs due to performance limitations pertaining to the low power application.

The popular voice codecs are: G723.1, iLBC, Speex.

1.3 PLATFORM SELECTION:

To implement the voice codec the DSP hardware must support the following features:

High processing power (up to 30MIPS).

To be able to implement compression/decompression algorithms like Speex,

G723.1etc.

Support of serial interfaces like UART, SPI.

Low power consumption.

Popular DSP platforms: TMS320C5505, dsPIC 33Fxx, BelaSigna 300

12

2. BACKGROUND

2.1 SPEECH CODEC

The human voice acoustic sensor initially generates an analog signal. This signal is converted

into a bit stream by an Analog-to-Digital converter (ADC) and applied to a multiple

compression algorithms. There are various compression techniques available in the literature.

The most popular ones are standardized in the ITU-T G-series. The most commonly used

codecs are: G.711 PCM, G.726 ADPCM, G.728 LD-CELP and G. 729/G.729a CS-ACELP.

PCM and ADPCM belong to the family of so called waveform codecs. These codecs simply

analyze the input signal without any knowledge of the human source. Most of these codecs

work in time domain, like PCM. These codecs offer high quality speech at a low

computational complexity. But if we try to get the bit rate below 8 kbps the quality decreases

tremendously. To get the low bit rate with better voice quality another approach is necessary.

Human source codecs need to know the characteristics of the human voice. When a human

voice is encoded, the source codec tries to extract the voice parameters from the voice signal.

Then these parameters along with two states of excitation are transmitted. These types of

codecs can simply transport the pure informational content of the speech samples and not the

voice signal samples itself. The big advantage is that they operate with bit rates as low as 2.4

kbps of course with poor voice quality.

Hybrid codecs try to combine the advantages of both waveform codecs and source codecs to

obtain good voice quality. To get the best voice parameters all possible waveforms are tested

and then one with the least error is chosen. This involves a very high computational

complexity to analyze every voice frame. The low bit rate codecs usually involve a high

computational complexity and a delay while the waveform codecs have the advantage of low

delay and excellent voice quality. One example of this is Speex codec.

13

2.1.1 Speex:

Unlike many other speech codecs, Speex has the advantage of being capable to be used for

packet networks and voice over IP (VoIP) applications also. It uses CELP (code excited

linear prediction) coding techniques. Speex is mainly designed for three different sampling

rates: 8 kHz, 16 kHz and 32 kHz referred as narrowband, wideband and ultra-wideband

respectively.

It can be configured either for variable bit rate or fixed bit rate. The variable bit-rate (VBR)

allows a codec to change its bit-rate dynamically to adapt to the "difficulty" of the audio

being encoded. Sounds like vowels and high energy transients require a large number of bits

to achieve good quality, while fricatives (s, f sounds) can be coded adequately with less

number of bits. With this VBR we can achieve lower bit-rate for the same quality, or a better

quality for a certain bit-rate.

Despite its advantages VBR has two main drawbacks: first, by only specifying quality, there's

no guaranty about the final average bit-rate, second, for some real-time applications like

voice over IP (VoIP), the maximum bit-rate must be low enough for the communication

channel.

Speex has VAD (Voice activity detection) feature. When enabled the VAD detects whether

the audio being encoded is speech or silence/background noise. VAD is always implicitly

activated when encoded in VBR, so the option is only useful in non-VBR operation. In this

case, Speex detects non-speech periods and encode them with just enough bits to reproduce

the background noise. This is called "Comfort noise generation" (CNG).

Thus, Speex compression algorithm is used for the proposed model which compresses 20ms

voice data at a time, sampled at 8khz and results in compressed data size of 20 byte in case of

5.3kbps rate and 24 byte in case of 6.3kbps rate.

Now the compressed voice data is integrated into a voice packet. This voice packet is

basically a ZigBee network packet which contain voice packet as data payload to send to the

receiver. The packet is sent to the ZigBee module over UART. The ZigBee network layer

utilizes the coordinators, routers and end devices. When the receiver receives the packet, the

packet goes through the reverse process for playback of voice.

14

2.1.2 Analysis of node data rate:

When UART as interface between Sensor Board (DSP) and RF board(ZigBee)

Baud Rate: 115200 bps

Data Rate of Transceiver: 250kbps

UART transmit (Sensor to RF Board) time (160 bytes): 32ms (approx.)

Over the air Transmit time/bit: 4us (approx.)

For a single packet: 6.4 ms approx.

So, ideal time for transmission of a single packet is ~40ms.

Considering the total packet size including overhead to be 200 bytes

Data Transmission Rate = Total packets size (in bits) / Total Time taken

Thus achieving a data transmission rate of ~40kbps, which is the actual available data rate

excluding headers in ZigBee network.

2.2 ZIGBEE NETWORK

ZigBee is a WPAN (Wireless Personal Area Network) protocol which defines the higher

layers of the protocol stack. It is built over the IEEE 802.15.4 WPAN standard. IEEE

802.15.4 defines only lower layers (PHY and MAC) of the protocol stack.

2.2.1 Nodes in ZigBee Network:

Two types of devices can participate in an IEEE 802.15.4 network:

Full-function device (FFD)

Reduced-function device (RFD).

The FFD can operate in three modes serving as a PAN coordinator, a coordinator, or an end

device. An FFD can talk to RFDs or other FFDs, while an RFD can talk only to an FFD.

An RFD is intended for applications that are extremely simple, such as a light switch or a

passive infrared sensor as an end device; they do not have the need to send large amounts of

data and may only associate with a single FFD at a time. Consequently, the RFD can be

implemented using minimal resources and memory capacity.

Every node in a ZigBee network is one of three types: a ZigBee Coordinator (ZC), a

ZigBee Router (ZR), or a ZigBee End-Device (ZED). In IEEE 802.15.4-speak, both ZCs

and ZRs are full-function devices, and a ZED is a reduced-function device:

15

Device Name Description

Coordinator Create the Network

Accept new element into the network

Participate the message routing

Participate self-healing when link broke

Mains powered

Router Accept new element into the network

Participate the message routing

Participate self-healing when kink broke

Mains Powered

End device Only communicate with direct parent

Does not participate with message routing

Cannot adopt new element into the network

Can be battery powered and go to sleep mode

periodically

Table 2: Nodes in ZigBee Network

2.2.2 ZigBee PANs:

ZigBee nodes can only send data requests to other nodes on the same network. A single

ZigBee network is called a Personal Area Network (PAN).

ZigBee PANs are formed by ZigBee Coordinators. Only ZigBee Coordinators (ZCs) may

form a PAN. The other ZigBee node types, ZigBee Routers (ZRs) and ZigBee End-Devices

(ZEDs) may join a network, but cannot form a PAN alone.

2.2.3 ZigBee Channels:

The 2.4 GHz band is a worldwide unlicensed portion of the RF spectrum for use by many

radio products like Bluetooth, WiFi™, Microwaves and others. This band is also known as

the ISM (Industrial, Scientific, and Medical) band. ZigBee uses the same channel set as

specified in 802.15.4.

In the 2.4 GHz band, these channels are numbered 11 through 26. Channel numbers 0

through 10 are defined by the sub-1 GHz 802.15.4 radios, but ZigBee does not run on the

sub-1 GHz radios. Channels are just a portion of the RF spectrum. In the case of 802.15.4,

each of these channels is separated by 5 MHz in the 2.4 GHz band.

16

802.15.4 uses Direct Sequence Spread Spectrum (DSSS) to spread the packets into symbols

and reassemble them on the other end, verifying that the data was decoded correctly through

use of a 16-bit CRC. Due to the robust nature of O-QPSK and DSSS, 802.15.4 radios are

very robust, even in a noisy RF environment.

2.2.4 ZigBee PAN IDs:

ZigBee Personal Area Network identifiers (or PAN IDs) are used to logically separate a

collection of ZigBee nodes from other ZigBee nodes in the same vicinity or on the same

physical channel. This allows network A and network B to exist in close proximity without

interfering with each other, other than consuming over-the-air bandwidth that they both share.

ZigBee PAN IDs are 16-bit numbers that range from 0x0000 to 0x3fff. Note this is different

than the 802.15.4 specification, which allows PAN IDs from 0x0000 to 0xfffe.

A device is only allowed to join one PAN at a time. When PAN is configured as 0xffff, the

device will join/create random PAN.

2.2.5 The Network Address:

The network address, also called NwkAddr, short address, or node address, is a 16-bit

number used to uniquely identify a particular node on a ZigBee network.

The ZigBee Coordinator is always NwkAddr 0x0000. Two ZigBee coordinators can exist on

the same channel with NwkAddr 0x0000 because of their different PAN IDs.

2.2.6 MAC Addresses:

The MAC address, also called IEEE address, long address, or extended address, is a 64bit

number that uniquely identifies a board from all other ZigBee boards in the world.

The 64-bit MAC addresses have no direct relationship to the 16-bit NwkAddr. If a node

leaves one ZigBee network and joins another, its MAC address will remain the same, but the

NwkAddr will likely change.

17

2.2.7 Sending and Receiving Data in a Zigbee network:

Different message sending methods in ZigBee are:

Unicast with end-to-end acknowledgment

Unicast without end-to-end acknowledgment

Broadcast

Groupcast/Multicast

Unicasts are transmitted from one node to exactly one other node. Unless the nodes are

neighbours (within radio range of each other), route discovery takes place the first time these

nodes speak together. If end-to-end is acknowledged, the unicast will be retried up to three

times, perhaps even initiating a new route discovery if the old route is broken.

A broadcast is used to send a data request from one node to the entire ZigBee network, at

least within a given radius.

Broadcasts are used by some underlying ZigBee management functions, such as route

discovery or NWK_addr_req, and may be also used by applications.

Unlike unicasts, broadcasts have no acknowledgment mechanism.

Broadcasts don't need specific commissioning. There is no "binding" to a

broadcast destination address. A node simply broadcasts to a specified radius. The

default radius for a broadcast spans the entire network.

2.2.8 Addressing Within the Node:

ZigBee goes beyond a networking protocol and also offers application-level compatibility.

To achieve this, ZigBee contains a variety of concepts: endpoints, clusters, command,

attributes, and profiles.

Addressing within ZigBee includes all of the following components:

PAN ID (MAC)

NwkAddr (NWK)

Endpoint (APS)

Profile ID (APS)

Cluster (APS)

Command and/or attribute (ZCL)

18

2.2.8.1 Endpoints:

Endpoints are defined within each node. Endpoints serve three purposes in ZigBee:

Endpoints allow for different application profiles to exist within each node

Endpoints allow for separate control points to exist within each node

Endpoints allow for separate devices to exist within each node

Endpoints, identified by a number between 1 and 240, define each application running in a

ZigBee node (where, a single ZigBee node can run multiple applications).

A node may contain any number of endpoints (up to 240), with any set of endpoint

identifiers. For example, a single node might contain just one endpoint, numbered 55. Or a

node might contain 20 endpoints, numbered 1 through 10 and 201 through 210.

Hence endpoints can be viewed as virtual wires connecting applications. Endpoints allow for

separate profiles, devices, and control points to exist within a single node.

2.2.8.2 Clusters:

Clusters, defined by a 16-bit identifier, are application objects. While the NwkAddr and

endpoint are addressing concepts, the cluster defines application meaning.

Clusters encapsulate both commands and data.

Clusters have direction. In the Simple Descriptor which describes an endpoint, a

cluster is listed as either input or output. This is used only for the purposes of

service discovery.

Clusters contain both code (commands) and data (attributes). Commands cause action on a

cluster while attributes keep track of the current state of that cluster.

Commands: Commands are identified by an 8-bit number, and are either cluster-

specific, or cross-cluster. Cluster-specific commands depend on the cluster number,

and generally start at 0x00.

Attributes: Attributes store the current "state" of a given cluster. Collectively, a set of

attributes on all clusters supported by a device define the state of that device. There

are generic ZCL commands to read and write attributes on any given cluster.

19

ZIGBEE STACK ARCHITECTURE

Figure 1: ZigBee Stack Architecture

2.2.9 ZigBee Application Support Sublayer (APS):

The Application Support Sublayer, or APS, sits above the NWK layer, and is the layer in

ZigBee which understands applications. The APS frame over-the-air includes endpoints,

clusters, profile IDs, and even groups.

APS is responsible for the following activities:

Filtering out packets for non-registered endpoints, or profiles that don't match

Generating end-to-end acknowledgment with retries to maximise the chance of

successful transmission and to inform the sender whether or not the packet was

delivered.

Maintaining the local binding table

Maintaining the local groups table

Maintaining the local address map of a 64-bit MAC address with a ZigBee 16-bit

NwkAddr.

20

2.2.9.1 APS Acknowledgements::

While the MAC layer provides per-hop acknowledgments, the APS layer is what provides

end-to-end acknowledgments, also called ACKs

Figure 2: APS end-to-end acknowledgements

2.2.9.2 Application Profiles:

Every data request in ZigBee is sent (and received) on an Application Profile. Application

Profile IDs are 16-bit numbers and range from 0x0000 to 0x7fff for public profiles and

0xbf00 to 0xffff for manufacturer-specific profiles.

A profile is a domain space of related applications and devices. Public profiles are those

specified by the ZigBee Alliance (as opposed to private profiles specified by individual

OEMs).

Any number of Application Profiles, both public and manufacturer-specific, may exist in a

single ZigBee network. In fact, any number of profiles may exist in a single node on the

network, separated on different endpoints.

2.2.9.3 Device Ids:

Every endpoint includes a profile identifier and a device identifier. A device is a physical

thing like a light, temperature sensor, thermostat etc. ZigBee Device IDs range from 0x0000

to 0xffff.

Device IDs serve two purposes:

To allow human-readable displays (your PC, the TV, etc.) to show a proper

icon for the device in question.

To allow ZigBee commissioning tools to be more intelligent.

http://www.eetimes.com/ContentEETimes/zigbee_applications_fig27.jpg

21

2.2.9.3 The Simple Descriptor:

The simple descriptor ties all the endpoint information, which defines an application, together

in one place. The simple descriptor defines the fields: an endpoint ID, a profile ID, cluster

IDs, and a device ID.

The simple descriptor of any endpoint can be retrieved over-the-air when performing service

discovery.

The simple descriptor does not list the commands and/or attributes available on any given

cluster. By asking for the simple descriptor, any device in the network can determine which

clusters are supported by any other device, and can then make an informed decision about

optional functionality.

There are both input and output cluster lists in the simple descriptor. This is how ZigBee

determines which devices match. If one side has an output cluster (say a dimmer switch) and

the other side has the same cluster as an input cluster (say, a dimming light), then they match.

Any overlap indicates a match, so if an application is looking for a particular cluster, it can

send a "simplified" simple descriptor to match just that one cluster.

2.2.10 Zigbee network services:

ZigBee contains two sets of services for network commissioning and maintenance:

The ZigBee Device Object (together with the ZigBee Device Profile)

The ZigBee Cluster Library

ZigBee Device Object is a specialized form of application object (with profile ID 0x0000)

which each node must have.

2.2.10.1 ZigBee Device Profile services include the following categories:

Device discovery services

Service discovery services

Binding services

Management services

22

Device Discovery involves interrogating a remote node for address information. The retrieved

information can be either:

the MAC (IEEE) address of the node with a given network address

the network address of the node with a given MAC address.

Service discovery involves interrogating a remote node for information about its capabilities.

This information is stored in a number of descriptors on the remote node, and includes:

The device type and capabilities of the node (Node Descriptor)

The power characteristics of the node (Node Power Descriptor)

Information about each application running on the node (Simple Descriptor)

Requests for these descriptors are made by a device during its configuration and integration

into a ZigBee network. ZigBee performs service discovery based on profile IDs and cluster

IDs, not device IDs.

Binding provides a mechanism for attaching an endpoint on one node to one or more

endpoints on another node. Binding can even be destined for groups of nodes. Each binding

table entry stores the following information:

Source endpoint

the short (16-bit NwkAddr) and long (IEEE) address of a node

Cluster ID

Binding, coupled with the over-the-air ZDP binding commands, allows any endpoint on any

node to be connected easily with any endpoint on any other node.

Management services provide the ability to retrieve management information from the

devices, including network discovery results, routing table contents, link quality to neighbour

nodes, and binding table contents.

23

3. HARDWARE

Figure 3: Block diagram of the overall system

The stereo codec, AIC3204 is used for capturing, sampling the speech signal and converting

the samples back into analog signal. The sampled speech signal is compressed using Speex

compressing algorithm which is ported to DSP platform TMS320C5505. This compressed

data is further packetized using the ZigBee stack implemented on micro-controller

MSP430F5437. The ZigBee packets are transmitted using RF transceiver CC2520. While

reception the received signal is depacketized, decompressed and fed into speaker.

24

3.1 ezDSP STICK:

Figure 4: TMS320C5505 ezDSP STICK

The end device consists of sensor board using TI DSP (TMS320C5505) processor of C55x

series and AIC3204 stereo codec. TMS320C5505 16-bit DSP is a low power, Fixed point

DSP working at 100 MHz processing speed and is capable of executing some DSP algorithms

as well as some of the voice compression or decompression algorithms. The DSP is also rich

in peripherals like DMA controller and serial interfaces like SPI, UART, I2S, I2C. It is

therefore, possible to implement several interfaces in order to connect various ZigBee

devices. This makes it possible to evaluate different components.

The stereo codec (AIC3204), a low power Codec from TI is used for capturing, sampling the

audio signal and converting the samples back into analog audio. It connects to the TI C5505

DSP using I2C for configuration & I2S for data communication.

The UART connections required for interaction with ZigBee board is obtained using an

expansion connector connected to the end of the board.

25

Figure 5: Expansion connector for eZDSP Stick

Figure 6: Board with expansion connector indicating connections

26

3.2 ProFLEX01-R2 MODULE:

The ZigBee modules used for RF transmission and reception are PROFLEX01- R2 module

by LS Research.

Figure 7: PROFLEX01-R2 development board

The ProFLEX01-R2 module is a high performance 2.4GHz IEEE 802.15.4 radio (CC2520 &

CC2591) and microcontroller (MSP430F5437A) in a cost effective, pre-certified footprint.

The microcontroller is connected to CC2520 via serial interface. The board comes preloaded

with TI MAC stack and we have implemented TI Z-Stack 2.5.1 to develop our application.

The board can be connected to an external PC/Microcontroller for communication via the

UART interface of MSP430F5437A. The programming software used is IAR Embedded

Workbench compatible with TI Z-Stack 2.5.1.

27

Figure 8: ProFLEX01-R2 Module Block Diagram

The important features of the board are:

100mW output power

Long range: 4000 feet

Integrated PCB F antenna or U.FL connector for external antenna

Worldwide acceptance: FCC, IC and CE

Powerful Texas Instruments 256k MSP430 with 802.15.4 MAC or ZigBee Stack

LSR serial interface based on 802.15.4 MAC

Low power operation

RoHS compliant

Figure 9: Programming the ProFLEX Module using MSP FET430UIF JTAG Debugger

28

SOFTWARE IMPLEMENTATION

4.1 TOOLS USED:

IAR Embedded Work bench - This tool is a complete IDE for compiling, debugging and

programming a RF board which has MSP430 controller. We customize & build z-stack as per

our RF board and develop a user application.

Code Composer Studio (CCS) - This tool is a complete IDE for compiling, debugging and

programming Sensor board which has TI C5505 DSP controller. We develop a user

application to capture voice, compress it and transfer to RF board.

Z-Stack - Z-Stack is a ZigBee compliant protocol stack for IEEE 802.15.4 products. The

Stack is developed for TI ultra low power microcontrollers and RF transceivers. The ZigBee-

stack architecture shown in Fig.6 includes a number of layered components including the

IEEE 802.15.4 Physical (PHY) layer, Medium Access Control (MAC) layer, and the ZigBee

Network (NWK) layer and Application layer. Each component provides an application with

its own set of services and capabilities.

ZigBee Sniffer tool (WiSens) is used for observing the packet being transmitted and

received by the devices.

MSP FET430 UIF JTAG Debugger is used for programming and debugging ProFLEX01-

R2 Modules through 14pin JTAG interface.

The implementation of the project broadly comprises of 2 parts:

Capturing voice and compressing it on DSP.

Transmitting the compressed data over ZigBee,

This is followed by reception and decompression on the receiver side.

29

4.2 SPEECH COMPRESSION:

4.2.1 SPEEX:

Speex is open-source software and is available for download on www.xiph.org.The

list of files to be included in the CCS project is

Source files Header files

bits.c arch.h

cb_search.c cb_search.h

exc_10_16.c config.h

exc_10_32.c filters.h

exc_20_32.c fixed_generic.h

exc_5_256.c lpc.h

exc_5_64.c lsp.h

exc_8_128.c ltp.h

filters.c modes.h

gain_table.c nb_celp.h

gain_table_lbr.c os_support.h

lpc.c os_support_custom.h

lsp.c quant_lsp.h

lsp_tables_nb.c sb_celp.h

ltp.c speex/speex_bits.h

modes.c speex/speex_buffer.h

nb_celp.c speex/speex_callbacks.h

quant_lsp.c speex/speex_echo.h

sb_celp.c speex/speex_header.h

speex.c speex/speex_jitter.h

speex_callbacks.c speex/speex_preprocess.h

vbr.c speex/speex_resampler.h

vq.c speex/speex_stereo.h

window.c speex/speex_types.h

testenc_TI_c5x.c speex/speex.h

Table 3: List of source and header files of Speex that need to be included in the project

http://www.xiph.org/

30

The example project “testencTIc55x.c” available for TI-C5xx for encoding speech in the wav

format is modified to work in real-time conditions.

For this, speech from the mic is recorded every 20 ms and is provided for processing.20 ms

of speech sampled at 8 kHz accounts to 160 bytes of data, described as 1 frame. Each frame

is encoded using encoder state “st”. The compressed data accounts to 20 bytes per frame.

Before recording speech from mic, initialisation of the codec (AIC3204) is to be done. It is

done using aic3204.c. The corresponding header file aic3204.h is also to be included.

Parameters set during Speex compression include Speex_quality set to 4, complexity set to 1.

In loopback mode, the compressed data is decompressed using the decoder state “dec” on the

same device. The decoded data is sent to HP_OUT and is heard through the headphones

connected to this port.

4.2.2 DMA

The quality of the decoded speech was found to be below par from expected.This is due to

the delay in the processing during compression. This is countered by using DMA to transfer

the data to and from the peripherals while the processor is entirely dedicated for processing

the data.

The TMS320C55x™ DSP Chip Support Library (CSL) which provides C-program functions

to configure and control on-chip peripherals, is used to configure DMA.DMA is used in

Interrupt mode i.e. DMA module generates an interrupt at the completion of specified

transfer.

The test code of csl_dma_IntcExample.c, which tests the basic working of the DMA module

in interrupt mode, is modified to suit the present application. The transfer type is modified to

CSL_DMA_TRANSFER_IO_MEMORY since I/O peripherals are being read from or

written to. Auto reload mode is enabled which continuously reads the peripherals so that

DMA need not be configured each time. The source address for the dma_receive function is

set to 2828h, which is the address of the I2S register, I2SRXLT0.This register stores the data

received from AIC3204 codec i.e. digital version of speech from mic. The destination address

would be a buffer in memory which would be further processed using speex.

31

Similarly, dma_transmit function has its source address as a buffer in memory with the

destination address being 2808h, I2STXLT0. These two functions are included in the

“testencTIc55x.c” where encoding and decoding of the data is done.

In loopback mode, both dma_transmit and dma_receive are implemented on the same device.

4.2.3 UART

In the transmission mode, the compressed data is transmitted further through UART.UART is

again configured in DMA mode using CSL. csl_uartDmaExample.c is modified and is

included in “testencTIc55x.c”, where DMA transfer and encoding has been done so far.

The baud rate of UART is set at 115200 bps and word length of 8 is used with no start and

stop bits. The source address of UART_transmit function is cbits, which temporarily stores

the encoded data and the destination address is (hUart->uartregs->THR), which is transmit

buffer of UART. Similarly,the source address of UART_Receive is (hUart->uartregs->RBR),

which is receive buffer of UART and the destination address is a buffer in memory of the

received device. The encoded data is present in this buffer which is further decoded and sent

to HP_OUT and played through headphones.

The program “testencTIc55x.c” with all the above mentioned modifications is included in

Appendix A.

NOTE :

While using aic3204.c(present in usbstk5505_v2 files) and codes of CSL(present in

c55xx_csl/ccs_v4.0_examples), usbstk5505bsl.lib and cslVC5505.lib are to be built

in the workspace and then included in the File Search Path of the main project

properties (Properties / C/C++ Build / File Search Path), since all the macros and

functions are defined there.

Since in this program several codes from Speex, usbstk5505, csl are combined, care is

to be taken that all are built using the same memory model.

During the implementation of Speex, certain symbols need to be predefined. They are

_DEBUG, CONFIG_TI_C55X, HAVE_CONFIG_H.

32

Initialize AIC3204 codec to

capture speech from mic

Transfer this data over

UART in DMA mode

Invoke DMA to transfer the

decoded data to speaker Store the data in a buffer

Receive the data at the other

end through UART

Store the encoded data in a

buffer (memory)

Encoding one frame of data

using Speex

Invoke DMA of DSP to read

data from I2S peripheral

Read the data from memory

Decode the compressed data

Loopback

Transmission

Figure 9: Flowchart representing speech compression using Speex

33

Figure 10: Screenshots indicating project build in Code Composer Studio

34

4.3 TRANSMISSION OVER ZIGBEE:

The application is developed using TI Z-Stack version 2.5.1 and implemented over

PROFLEX01-R2 module. A network is formed using two Proflex01 R2 modules, one

configured as the Coordinator and the other configured as End Device. Our application

allows transfer of messages from the Coordinator to the End device and vice versa.

The data of 20ms frame size, sent over the UART interface by TMS320C5505 is received in

the UART receive buffer of MSP430F5437A of Coordinator. In our application we have used

USCI_A0 module for UART communication. The data in receive buffer (UCA0RXBUF) is

transferred to an array RxString which is further transmitted over the air using CC2520.

These message packets are received at the receiver CC2520 (End Device) and transferred to

the UART transmit buffer of MSP430F5437A. The data in UART transmit buffer

(UCA0TXBUF) is finally sent over UART interface to TMS320C5505 for decoding.

The various parameters set for setting up of Zigbee Network are:

PAN ID: 0xFF00 Channel of operation: Channel 11

The parameters required for setup of network are defined in the file f8wConfig.cfg in the

project.

We have built an application specific project “LSRApp.ewp” in IAR Embedded Workbench

using the TI Z- Stack which consists of following source files:

1. LSRApp.c (LSRApp.h)

2. OSAL_LSRApp.c

35

The application instantiates a single Application Object for each ZDO with a unique endpoint

defined using the following Simple Descriptor:

const SimpleDescriptionFormat_t LSRApp_SimpleDesc =

{

LSRAPP_ENDPOINT, // int Endpoint;

LSRAPP_PROFID, // uint16 AppProfId[2];

LSRAPP_DEVICEID, // uint16 AppDeviceId[2];

LSRAPP_DEVICE_VERSION, // int AppDevVer:4;

LSRAPP_FLAGS, // int AppFlags:4;

LSRAPP_MAX_CLUSTERS, // byte AppNumInClusters;

(cId_t *) NULL, // byte *pAppInClusterList;


(cId_t *)LSRApp_ClusterList // byte *pAppInClusterList;

};

const cId_t LSRApp_ClusterList[LSRAPP_MAX_CLUSTERS] =

{

LSRAPP_CLUSTERID

};

We have used a single cluster id: LSRAPP_CLUSTERID for both sending and receiving the

messages from a ZDO.

The two major functions to be implemented for a task defined for an application object

are:

Task initialization function: LSRApp_Init()

Function to handle task events: LSRApp_ProcessEvent()

36

4.3.1 LSRApp_Init():

The initialization function deals with initialization of variables local to or specific for the

corresponding Application Object.

Here we define the following:

task id: LSRApp_TaskId which is set to the task id value assigned by OSAL.

Network state: LSRApp_NwkState = DEV_INIT , this indicates that the network

state at power-up is “not connected”.

Message transaction counter: LSRApp_TransID = 0, keeps track of the no of

times message is sent.

Here we also define the endpoint description of the application object and

register it with the application framework using afRegister( &LSRApp_epDesc ).

This allows the AF layer to know how to route incoming packets destined for the

profile/endpoint.

The application is also registered for the exclusive system service of key press

notification.

RegisterForKeys( LSRApp_TaskID )

A default destination address is initialized so that messages will be sent as bound

messages

GenericApp_DstAddr.addrMode = (afAddrMode_t)AddrNotPresent;

GenericApp_DstAddr.endPoint = 0;

GenericApp_DstAddr.addr.shortAddr = 0;

The UART module is configured and the state machine is released. Interrupts to

be used in the application are enabled.

SFRIE1 |= WDTIE; // Enable WDT interrupt

P3SEL |= 0x3C; // P3.4,5 = USCI_A0 TXD/RXD

P3DIR |= 0x01;

UCA0CTL1 |= UCSWRST; // 8-bit characters

UCA0CTL1 = UCSSEL_1; // CLK = ACLK

UCA0BR0 = 0x03; // 32k/9600=3.41

37

UCA0BR1 = 0x00;

UCA0MCTL = UCBRS_3+UCBRF_0; // Modulation

UCA0CTL1 &= ~UCSWRST; // Release USCI state machine

4.3.2 LSRApp_ProcessEvent():

This is a callback function to handle task events.

SYS_EVENT_MSG (0x8000): This is a mandatory event and all the global system

messages are sent via the SYS_EVENT_MSG. The task event handler processes the

following minimal subset of these global system messages.

AF_DATA_CONFIRM_CMD: This is an indication of the over-the-air result for

each data request that is successfully initiated by invoking AF_DataRequest().

Since the data request is made with the AF_ACK_REQUEST flag set hence the

ZSuccess confirms that the message was successfully received at the final

destination.

AF_INCOMING_MSG_CMD: This is an indication of an incoming AF

message.

KEY_CHANGE: This is an indication of a key press action.

ZDO_STATE_CHANGE: With the device power up, initially its network state is

not connected. The device immediately tries to either join or form the network.

The change in network state generates ZDO_STATE_CHANGE sytem event and

the device receives notification of the status of the network formation or join.

ZDO_CB_MSG: This message is sent to the application for every registered

ZDO response message [ZDO_RegisterForZDOMsg()].

38

4.3.3 Sending Message:

The program flow for sending a Message over the air is as follows:

Address Initialization

Register “Service discovery” call back

Issue the service discovery operation i.e Match description request

Handle the message call back

Send the device bind request

Send the message via the Af_DataRequest

If the return value of AF_DataRequest() = ZSuccess, this signifies that the

message has been accepted by the Network Layer which will attempt to send it to

the MAC layer which will attempt to send it over-the-air . This results in a

“callback” by way of the AF_DATA_CONFIRM_CMD system event message.

The AF_DATA_CONFIRM_CMD ultimately generates the "sentStatus =

Zsuccess" to indicate message is delivered to the destination address.

39

With power up, device network state is not

connected

Match description request is made

Call AF_DataRequest() to send the

message received over UART

ZDO_STATE_CHANGE

E

System Events generated

KEY_CHANGE User 1 Key is pressed

ZDO_CB_MSG

Match description request response

indicates status of request

KEY_CHANGE User 2 Key is pressed

End device Binding request is made

ZDO_CB_MSG

Device binding request response

indicates status of request

LSRAPP_SEND_MSG_EVT

If AF_ACK_REQUEST= Zsuccess

AF_DATA_CONFIRM_CMD

If SentStatus = Zsuccess

Message successfully sent over the air

TRUE

FALSE

Figure 11: Flowchart representing sending of message over the air using ZigBee

40

4.3.4 Receiving Message:

The program flow for receiving the message is as follows:

Address Initialization

Register “Service discovery” call back

Issue the service discovery operation

Handle the message call back

Send the bind request

Process the incoming message

The above flow is similar to the program flow for sending message except for the last stage to

process the incoming message.

The receiving Application Object is notified about the incoming message by the SYS_EVENT_MSG

message AF_INCOMING_MSG_CMD. This event generates a call to the function

LSRApp_MessageMSGCB(MSGpkt).

Message successfully received over the air

AF_INCOMING_MSG_CMD

System Events generated

Put the data in UART transmit buffer

Data is sent to the DSP processor for

decoding and further processing

Figure 12: Flowchart representing receiving of message over the air using ZigBee

41

Figure 13: Screenshots indicating Coordinator and End device project build in IAR

42

4.4 CONCLUSION:

We have successfully implemented the speech compression and decompression using Speex

Codec in the loop back mode with high voice quality.

43

APPENDIX

Program code for Speex Compression on TMS320C5505:

/* Modified from speexlib/testenc.c for Code Composer simulator */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <speex/speex.h>

#include <speex/speex_callbacks.h>

#include "arch.h"

#include "usbstk5505.h"

#include "usbstk5505_i2s.h"

#include "csl_i2s.h"

#include "csl_intc.h"

#include "csl_dma.h"

#include "csl_uart.h"

#include "csl_uartAux.h"

#undef DECODE_ONLY

#define CHECK_RESULT /* Compares original file with encoded/decoder file */

#define TESTENC_BYTES_PER_FRAME 20 /* 8kbps */

#define TESTENC_QUALITY 4 /* 8kbps */

//#define TESTENC_BYTES_PER_FRAME 28 /* 11kbps */

//#define TESTENC_QUALITY 5 /* 11 kbps */

/* For narrowband, QUALITY maps to these bit rates (see modes.c, manual.pdf)

* {1, 8, 2, 3, 3, 4, 4, 5, 5, 6, 7}

* 0 -> 2150

* 1 -> 3950

* 2 -> 5950

* 3 -> 8000

* 4 -> 8000

* 5 -> 11000

* 6 -> 11000

* 7 -> 15000

44

* 8 -> 15000

* 9 -> 18200

*10 -> 26400 */

#define FRAME_SIZE 160

#define CSL_DMA_BUFFER_SIZE 160

extern void AIC3204_init( );

short out_short[FRAME_SIZE];

char cbits[TESTENC_BYTES_PER_FRAME/2 + 2]; // temp store for encoded data

//int busyEncoding;

int i_loop,j_loop;

static int count ;

#ifdef FIXED_DEBUG

extern long long spx_mips;

#endif

//#include <math.h>

#ifdef MANUAL_ALLOC

/* Take all Speex space from this private heap */

/* This is useful for multichannel applications */

#pragma DATA_SECTION(spxHeap, ".myheap");

static char spxHeap[SPEEX_PERSIST_STACK_SIZE];

#pragma DATA_SECTION(spxScratch, ".myheap");

static char spxScratch[SPEEX_SCRATCH_STACK_SIZE];

char *spxGlobalHeapPtr, *spxGlobalHeapEnd;

char *spxGlobalScratchPtr, *spxGlobalScratchEnd;

#endif

//from try_i2sdma_regs.c

#define CSL_TEST_FAILED (1)

#define CSL_TEST_PASSED (0)

#define CSL_DMA0_CH0 (0)

//Int16 count=0;

volatile Int16 PaSs_StAtE = 0x0001; // Init to 1. Reset to 0 at any monitored execution error.

volatile Int16 PaSs = 0x0000;

Int16 ReadyToEncode=0;

Int16 tx_done=0;

short RcvL1[FRAME_SIZE];

//from uart.c

#define CSL_TEST_FAILED (-1)

#define NO_OF_CHAR_TO_READ TESTENC_BYTES_PER_FRAME

#define NO_OF_CHAR_TO_WRITE TESTENC_BYTES_PER_FRAME

#define CSL_UART_WRBUF_SIZE (NO_OF_CHAR_TO_WRITE*4)

#define CSL_UART_RDBUF_SIZE (NO_OF_CHAR_TO_READ*4)

45

#define CSL_PLL_DIV_000 (0)

#define CSL_PLL_DIV_001 (1u)







#define CSL_PLL_CLOCKIN (32768u)

/* Global data definition */

/* UART setup structure */

CSL_UartSetup mySetup =

{

100000000, /* Input clock freq in MHz */

115200, /* baud rate */

/* word length of 8 */

CSL_UART_WORD8,

/* To generate 1 stop bit */

0,

/* Disable the parity */

CSL_UART_DISABLE_PARITY,

/* enable trigger 14 fifo */

CSL_UART_FIFO_DMA1_ENABLE_TRIG14,

/* Loop Back enable */

CSL_UART_NO_LOOPBACK,

/* No auto flow control*/

CSL_UART_NO_AFE ,

/* No RTS */

CSL_UART_NO_RTS ,

};

/**

* \brief Function to calculate the system clock

* \param none

* \return System clock value in Hz

*/

Uint32 getSysClk(void);

/* CSL UART object */

CSL_UartObj uartObj;

/* CSL DMA data structures used for UART data transfers */

CSL_DMA_Handle dmaWrHandle;

CSL_DMA_Handle dmaRdHandle;

CSL_DMA_Config dmaConfig_uart;

CSL_DMA_Config dmaConfig_uart2;

46

CSL_DMAChanNum chanNum3;

CSL_DMAChanNum chanNum4;

CSL_DMA_ChannelObj dmaWrChanObj;

CSL_DMA_ChannelObj dmaRdChanObj;

char guartDmaReadBuf[CSL_UART_RDBUF_SIZE];

/* Reference the start of the interrupt vector table */

extern void VECSTART(void);

/* Protype declaration for ISR function */

interrupt void dma_isr(void);

CSL_DMA_Handle dmaHandle;

CSL_DMA_Config dmaConfig;

CSL_DMA_Config getdmaConfig;

CSL_DMA_ChannelObj dmaObj;

CSL_DMA_Handle dmaHandle2;

CSL_DMA_Config dmaConfig2;

CSL_DMA_Config getdmaConfig2;

CSL_DMA_ChannelObj dmaObj2;

CSL_DMA_Handle dmaLeftRxHandle;

CSL_DMA_Handle dmaLeftTxHandle;

Uint16 dmaSRCBuff[CSL_DMA_BUFFER_SIZE];

Uint16 dmaDESTBuff[CSL_DMA_BUFFER_SIZE];

void dma_func()

{

CSL_Status status;

Uint16 i;

Uint16 chanNumber;

Uint16 chanNumber2;

#if (defined(CHIP_C5505_C5515) || defined(CHIP_C5504_C5514))

dmaConfig.pingPongMode = CSL_DMA_PING_PONG_DISABLE;

#endif

dmaConfig.autoMode = CSL_DMA_AUTORELOAD_ENABLE;

dmaConfig.burstLen = CSL_DMA_TXBURST_1WORD;

dmaConfig.trigger = CSL_DMA_SOFTWARE_TRIGGER;

dmaConfig.dmaEvt = CSL_DMA_EVT_NONE;

dmaConfig.dmaInt = CSL_DMA_INTERRUPT_ENABLE;

dmaConfig.chanDir = CSL_DMA_READ;

dmaConfig.trfType = CSL_DMA_TRANSFER_IO_MEMORY;

dmaConfig.dataLen = CSL_DMA_BUFFER_SIZE * 2;

dmaConfig.srcAddr = (Uint32)(0x00002828);

dmaConfig.destAddr = (Uint32)RcvL1;

47

IRQ_globalDisable();

IRQ_clearAll();

IRQ_disableAll();

IRQ_setVecs((Uint32)&VECSTART);

IRQ_clear(DMA_EVENT);

IRQ_plug (DMA_EVENT, &dma_isr);

IRQ_enable(DMA_EVENT);

IRQ_globalEnable();

status = DMA_init();

if (status != CSL_SOK)

{

printf("DMA_init() Failed \n");

/////INSTRUMENTATION FOR BATCH TESTING -- Part 2 --

///// Reseting PaSs_StAtE to 0 if error detected here.

PaSs_StAtE = 0x0000; // Was intialized to 1 at declaration.

/////

}

chanNumber=0;

count = 0;

// printf("\n Test for DMA Channel No : %d \t", chanNumber);

dmaHandle = DMA_open((CSL_DMAChanNum)chanNumber,&dmaObj,

&status);

if (dmaHandle == NULL)

{

printf("DMA_open() Failed \n");

//break;

}

status = DMA_config(dmaHandle, &dmaConfig);


{

printf("DMA_config() Failed \n");

//break;

}

status = DMA_start(dmaHandle);


{

printf("DMA_start() Failed \n");

//break;

}

while(count != 1);

48

while(count == 0);

}

void dma_func2()

{

CSL_Status status;

Uint16 i;

Uint16 chanNumber2;

tx_done=0;


dmaConfig2.pingPongMode = CSL_DMA_PING_PONG_DISABLE;

#endif

dmaConfig2.autoMode = CSL_DMA_AUTORELOAD_ENABLE;

dmaConfig2.burstLen = CSL_DMA_TXBURST_1WORD;

dmaConfig2.trigger = CSL_DMA_SOFTWARE_TRIGGER;

dmaConfig2.dmaEvt = CSL_DMA_EVT_NONE;

dmaConfig2.dmaInt = CSL_DMA_INTERRUPT_ENABLE;

dmaConfig2.chanDir = CSL_DMA_WRITE;

dmaConfig2.trfType = CSL_DMA_TRANSFER_IO_MEMORY;

dmaConfig2.dataLen = CSL_DMA_BUFFER_SIZE * 2;

dmaConfig2.srcAddr = (Uint32) out_short;

dmaConfig2.destAddr = (Uint32)(0x00002808);

IRQ_globalDisable();

IRQ_clearAll();

IRQ_disableAll();

IRQ_setVecs((Uint32)&VECSTART);

IRQ_clear(DMA_EVENT);

IRQ_plug (DMA_EVENT, &dma_isr);

IRQ_enable(DMA_EVENT);

IRQ_globalEnable();

chanNumber2=1;

count = 0;

// printf("\n Test for DMA Channel No : %d \t", chanNumber);

dmaHandle2 = DMA_open((CSL_DMAChanNum)chanNumber2,&dmaObj2,

&status);

if (dmaHandle2 == NULL)

{

printf("DMA_open() Failed \n");

//break;

}

49

status = DMA_config(dmaHandle2, &dmaConfig2);


{

printf("DMA_config() Failed \n");

//break;

}

status = DMA_start(dmaHandle2);


{

printf("DMA_start() Failed \n");

//break;

}

while(count == 0);

} //end of dma_func2


Uint32 getSysClk(void)

{

Bool pllRDBypass;

Bool pllOutDiv;

Uint32 sysClk;

Uint16 pllVP;

Uint16 pllVS;

Uint16 pllRD;

Uint16 pllVO;

pllVP = CSL_FEXT(CSL_SYSCTRL_REGS->CGCR1, SYS_CGCR1_VP);

pllVS = CSL_FEXT(CSL_SYSCTRL_REGS->CGCR1, SYS_CGCR1_VS);

pllRD = CSL_FEXT(CSL_SYSCTRL_REGS->CGICR, SYS_CGICR_RDRATIO);

pllVO = CSL_FEXT(CSL_SYSCTRL_REGS->CGOCR, SYS_CGOCR_OD);

pllRDBypass = CSL_FEXT(CSL_SYSCTRL_REGS->CGICR,

SYS_CGICR_RDBYPASS);

pllOutDiv = CSL_FEXT(CSL_SYSCTRL_REGS->CGOCR,

SYS_CGOCR_OUTDIVEN);

sysClk = CSL_PLL_CLOCKIN;

if (0 == pllRDBypass)

{

sysClk = sysClk/(pllRD + 4);

}

50

sysClk = (sysClk * ((pllVP << 2) + pllVS + 4));

if (1 == pllOutDiv)

{

sysClk = sysClk/(pllVO + 1);

}

/* Return the value of system clock in KHz */

return(sysClk);

}

#else

Uint32 getSysClk(void)

{

Bool pllRDBypass;

Bool pllOutDiv;

Bool pllOutDiv2;

Uint32 sysClk;

Uint16 pllVP;

Uint16 pllVS;

Uint16 pllRD;

Uint16 pllVO;

Uint16 pllDivider;

Uint32 pllMultiplier;

pllVP = CSL_FEXT(CSL_SYSCTRL_REGS->CGCR1, SYS_CGCR1_MH);

pllVS = CSL_FEXT(CSL_SYSCTRL_REGS->CGICR, SYS_CGICR_ML);

pllRD = CSL_FEXT(CSL_SYSCTRL_REGS->CGICR, SYS_CGICR_RDRATIO);

pllVO = CSL_FEXT(CSL_SYSCTRL_REGS->CGOCR,

SYS_CGOCR_ODRATIO);

pllRDBypass = CSL_FEXT(CSL_SYSCTRL_REGS->CGICR,

SYS_CGICR_RDBYPASS);

pllOutDiv = CSL_FEXT(CSL_SYSCTRL_REGS->CGOCR,

SYS_CGOCR_OUTDIVEN);

pllOutDiv2 = CSL_FEXT(CSL_SYSCTRL_REGS->CGOCR,

SYS_CGOCR_OUTDIV2BYPASS);

pllDivider = ((pllOutDiv2) | (pllOutDiv << 1) | (pllRDBypass << 2));

pllMultiplier = ((Uint32)CSL_PLL_CLOCKIN * ((pllVP << 2) + pllVS + 4));

switch(pllDivider)

{

case CSL_PLL_DIV_000:


sysClk = pllMultiplier / (pllRD + 4);

break;

51


sysClk = pllMultiplier / ((pllRD + 4) * (pllVO + 4) * 2);

break;


sysClk = pllMultiplier / ((pllRD + 4) * 2);

break;



sysClk = pllMultiplier;

break;


sysClk = pllMultiplier / ((pllVO + 4) * 2);

break;


sysClk = pllMultiplier / 2;

break;

}

/* Return the value of system clock in KHz */

return(sysClk);

}

#endif

CSL_DMA_Handle CSL_configDmaForUart(CSL_DMA_ChannelObj *dmaChanObj,

CSL_DMAChanNum chanNum)

{

CSL_DMA_Handle dmaHandle;

CSL_Status status;

dmaHandle = NULL;

/* Open A Dma channel */

dmaHandle = DMA_open(chanNum, dmaChanObj, &status);

if(dmaHandle == NULL)

{

printf("DMA_open Failed!\n");

}

/* Configure a Dma channel */

status = DMA_config(dmaHandle, &dmaConfig_uart);

if(status != CSL_SOK)

{

printf("DMA_config Failed!\n");

52

dmaHandle = NULL;

}

return(dmaHandle);

}

CSL_Status uart_tx_rx(void)

{

CSL_UartHandle hUart;

CSL_Status status;

int looper;

Uint32 sysClk;

sysClk = getSysClk();

mySetup.clkInput = sysClk;

/* Initialize CSL UART module */

status = UART_init(&uartObj,CSL_UART_INST_0,UART_POLLED);

if(CSL_SOK != status)

{

printf("UART_init failed error code %d\n",status);

return(status);

}

else

{

printf("UART_init Successful\n");

}

/* Handle created*/

hUart = (CSL_UartHandle)(&uartObj);

/* Configure the DMA channel for UART transmit */


dmaConfig_uart.pingPongMode = CSL_DMA_PING_PONG_DISABLE;

#endif

dmaConfig_uart.autoMode = CSL_DMA_AUTORELOAD_DISABLE;

dmaConfig_uart.burstLen = CSL_DMA_TXBURST_1WORD;

dmaConfig_uart.trigger = CSL_DMA_EVENT_TRIGGER;

dmaConfig_uart.dmaEvt = CSL_DMA_EVT_UART_TX;

dmaConfig_uart.dmaInt = CSL_DMA_INTERRUPT_DISABLE;

dmaConfig_uart.chanDir = CSL_DMA_WRITE;

dmaConfig_uart.trfType = CSL_DMA_TRANSFER_IO_MEMORY;

dmaConfig_uart.dataLen = CSL_UART_WRBUF_SIZE;

dmaConfig_uart.srcAddr = (Uint32) cbits;

dmaConfig_uart.destAddr = (Uint32)&(hUart->uartRegs->THR);

dmaWrHandle = CSL_configDmaForUart(&dmaWrChanObj, CSL_DMA_CHAN4);

53

/* Start Dma transfer */

status = DMA_start(dmaWrHandle);


{

printf("Uart Dma Write Failed!!\n");

return(status);

}

/* Configure UART registers using setup structure */

status = UART_setup(hUart,&mySetup);

if(CSL_SOK != status)

{

printf("UART_setup failed error code %d\n",status);

return status;

}

else

{

printf("UART_setup Successful\n");

}

/* Check transfer complete status */

while(DMA_getStatus(dmaWrHandle));

/* Configure the DMA channel for UART receive */


dmaConfig_uart.pingPongMode = CSL_DMA_PING_PONG_DISABLE;

#endif

dmaConfig_uart.autoMode = CSL_DMA_AUTORELOAD_DISABLE;

dmaConfig_uart.burstLen = CSL_DMA_TXBURST_1WORD;

dmaConfig_uart.trigger = CSL_DMA_SOFTWARE_TRIGGER;

dmaConfig_uart.dmaEvt = CSL_DMA_EVT_NONE;

dmaConfig_uart.dmaInt = CSL_DMA_INTERRUPT_DISABLE;

dmaConfig_uart.chanDir = CSL_DMA_READ;

dmaConfig_uart.trfType = CSL_DMA_TRANSFER_IO_MEMORY;

dmaConfig_uart.dataLen = CSL_UART_RDBUF_SIZE;

dmaConfig_uart.srcAddr = (Uint32)&(hUart->uartRegs->THR);

dmaConfig_uart.destAddr = (Uint32)guartDmaReadBuf;

dmaRdHandle = CSL_configDmaForUart(&dmaRdChanObj,CSL_DMA_CHAN4);

/* Open A Dma channel */

chanNum4=CSL_DMA_CHAN5;

dmaRdHandle = DMA_open(chanNum4, &dmaRdChanObj, &status);

if(dmaRdHandle == NULL)

{

printf("DMA_open Failed!\n");

}

/* Configure a Dma channel */

status = DMA_config(dmaRdHandle, &dmaConfig_uart2);

54


{

printf("DMA_config Failed!\n");

dmaRdHandle = NULL;

}

if(dmaRdHandle == NULL)

{

printf("DMA Config for DMA Read Failed!\n!");

//return(CSL_TEST_FAILED);

}

/* Start Dma transfer */

status = DMA_start(dmaRdHandle);


{

printf("Uart Dma Write Failed!!\n");

return(status);

}

/* Check transfer complete status */

while(DMA_getStatus(dmaRdHandle));

}

void main()

{

Uint16 i;

//Uint16 i_loop;

int nbChars;

char cbits[TESTENC_BYTES_PER_FRAME/2 + 2]; // temp store for encoded data

void *st;

void *dec;

SpeexBits bits;

spx_int32_t tmp;

unsigned long bitCount=0;

spx_int32_t skip_group_delay;

SpeexCallback callback;

// C54xx defaults to max wait states, even for parts like C5416 with

// larger internal memory. Need to force the wait state register to zero

#ifdef CONFIG_TI_C54X

asm(" STM #0,SWWSR");

#endif

/*

#ifdef CHECK_RESULT

sigpow = 0;

errpow = 0;

#endif

*/

55

#ifdef MANUAL_ALLOC

spxGlobalHeapPtr = spxHeap;

spxGlobalHeapEnd = spxHeap + sizeof(spxHeap);

spxGlobalScratchPtr = spxScratch;

spxGlobalScratchEnd = spxScratch + sizeof(spxScratch);

#endif

st = speex_encoder_init(&speex_nb_mode);

#ifdef MANUAL_ALLOC

spxGlobalScratchPtr = spxScratch; // Reuse scratch for decoder

#endif

dec = speex_decoder_init(&speex_nb_mode);

callback.callback_id = SPEEX_INBAND_CHAR;

callback.func = speex_std_char_handler;

callback.data = stderr;

speex_decoder_ctl(dec, SPEEX_SET_HANDLER, &callback);

callback.callback_id = SPEEX_INBAND_MODE_REQUEST;

callback.func = speex_std_mode_request_handler;

callback.data = st;

speex_decoder_ctl(dec, SPEEX_SET_HANDLER, &callback);

tmp=0;

speex_decoder_ctl(dec, SPEEX_SET_ENH, &tmp);

tmp=0;

speex_encoder_ctl(st, SPEEX_SET_VBR, &tmp);

tmp=TESTENC_QUALITY;

speex_encoder_ctl(st, SPEEX_SET_QUALITY, &tmp);

tmp=1; // Lowest

speex_encoder_ctl(st, SPEEX_SET_COMPLEXITY, &tmp);

#ifdef DISABLE_HIGHPASS

// Turn this off if you want to measure SNR (on by default)

tmp=0;

speex_encoder_ctl(st, SPEEX_SET_HIGHPASS, &tmp);

speex_decoder_ctl(dec, SPEEX_SET_HIGHPASS, &tmp);

#endif

speex_encoder_ctl(st, SPEEX_GET_LOOKAHEAD, &skip_group_delay);

speex_decoder_ctl(dec, SPEEX_GET_LOOKAHEAD, &tmp);

skip_group_delay += tmp;

fprintf (stderr, "decoder lookahead = %ld\n", skip_group_delay);

AIC3204_init( );

speex_bits_init(&bits);

for(i = 0; i < CSL_DMA_BUFFER_SIZE; i++)

{

56

out_short[i]=0;

}

while(1)

{

dma_func();

//refer speex.h for these functions

speex_bits_reset(&bits);

speex_encode_int(st, RcvL1, &bits);

nbChars = speex_bits_write(&bits, cbits,sizeof(cbits)*BYTES_PER_CHAR)

/BYTES_PER_CHAR;

speex_bits_reset(&bits);

uart_tx_rx();

speex_bits_rewind(&bits);

//speex_bits_read_from(&bits, cbits,TESTENC_BYTES_PER_FRAME);

speex_bits_read_from(&bits,

guartDmaReadBuf,TESTENC_BYTES_PER_FRAME);

//printf("%d\n",counterDecode++);

// counterDecode++;

speex_decode_int(dec, &bits, out_short);

skip_group_delay = 0;

count=0;

dma_func2();

}//end of while

}//end of main

interrupt void dma_isr(void)

{

int ifrValue;

ifrValue = CSL_SYSCTRL_REGS->DMAIFR;

CSL_SYSCTRL_REGS->DMAIFR |= ifrValue;

//printf("entered dma_isr\n");

++count;

}

57

Program code for transmission and receiving message over ZigBee:

#include "OSAL.h"

#include "AF.h"

#include "ZDApp.h"

#include "ZDObject.h"

#include "ZDProfile.h"

#include "LSRApp.h"

#include "DebugTrace.h"

#if !defined( WIN32 )

#include "OnBoard.h"

#endif

/* HAL */

#include "hal_lcd.h"

#include "hal_led.h"

#include "hal_key.h"

#include "hal_uart.h"

/* RTOS */

#if defined( IAR_ARMCM3_LM )

#include "RTOS_App.h"

#endif

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

* GLOBAL VARIABLES

*/

// This list should be filled with Application specific Cluster IDs.

const cId_t LSRApp_ClusterList[LSRAPP_MAX_CLUSTERS] =

{

LSRAPP_CLUSTERID

};

const SimpleDescriptionFormat_t LSRApp_SimpleDesc =

{

LSRAPP_ENDPOINT, // int Endpoint;

LSRAPP_PROFID, // uint16 AppProfId[2];

LSRAPP_DEVICEID, // uint16 AppDeviceId[2];

LSRAPP_DEVICE_VERSION, // int AppDevVer:4;

LSRAPP_FLAGS, // int AppFlags:4;


(cId_t *)LSRApp_ClusterList, // byte *pAppInClusterList;


(cId_t *)LSRApp_ClusterList // byte *pAppInClusterList;

};

// This is the Endpoint/Interface description. It is defined here, but

// filled-in in LSRApp_Init(). Another way to go would be to fill

58

// in the structure here and make it a "const" (in code space). The

// way it's defined in this sample app it is define in RAM.

endPointDesc_t LSRApp_epDesc;

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

* LOCAL VARIABLES

*/

byte LSRApp_TaskID; // Task ID for internal task/event processing

// This variable will be received when

// LSRApp_Init() is called.

devStates_t LSRApp_NwkState;

byte LSRApp_TransID; // This is the unique message ID (counter)

afAddrType_t LSRApp_DstAddr;

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

* LOCAL FUNCTIONS

*/

static void LSRApp_ProcessZDOMsgs( zdoIncomingMsg_t *inMsg );

static void LSRApp_HandleKeys( /*byte shift,*/ byte keys );

static void LSRApp_MessageMSGCB( afIncomingMSGPacket_t *pckt );

static void LSRApp_SendTheMessage( void );


static void LSRApp_ProcessRtosMessage( void );

#endif

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

* PUBLIC FUNCTIONS

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

* @fn LSRApp_Init

* @brief Initialization function for the Generic App Task.

* This is called during initialization and should contain

* any application specific initialization (ie. hardware

* initialization/setup, table initialization, power up

* notificaiton ... ).

* @param task_id - the ID assigned by OSAL. This ID should be

* used to send messages and set timers.

* @return none */

void LSRApp_Init( uint8 task_id )

{

LSRApp_TaskID = task_id;

LSRApp_NwkState = DEV_INIT;

LSRApp_TransID = 0;

// Device hardware initialization can be added here or in main() (Zmain.c).

// If the hardware is application specific - add it here.

// If the hardware is other parts of the device add it in main().

LSRApp_DstAddr.addrMode = (afAddrMode_t)AddrNotPresent;

LSRApp_DstAddr.endPoint = 0;

59

LSRApp_DstAddr.addr.shortAddr = 0;

SFRIE1 |= WDTIE; // Enable WDT interrupt

P3SEL |= 0x3C; // P3.4,5 = USCI_A0 TXD/RXD

P3DIR |= 0x01; // P3.0 = CSn OUTPUT DIRECTION

UCA0CTL1 |= UCSWRST; // 8-bit characters

UCA0CTL1 = UCSSEL_1; // CLK = ACLK

UCA0BR0 = 0x03; // 32k/9600=3.41

UCA0BR1 = 0x00;

UCA0MCTL = UCBRS_3+UCBRF_0; // Modulation

UCA0CTL1 &= ~UCSWRST; // Release USCI state machine

HalLedSet( HAL_LED_1, HAL_LED_MODE_ON );



// Fill out the endpoint description.

LSRApp_epDesc.endPoint = LSRAPP_ENDPOINT;

LSRApp_epDesc.task_id = &LSRApp_TaskID;

LSRApp_epDesc.simpleDesc

= (SimpleDescriptionFormat_t *)&LSRApp_SimpleDesc;

LSRApp_epDesc.latencyReq = noLatencyReqs;

// Register the endpoint description with the AF

afRegister( &LSRApp_epDesc );

// Register for all key events - This app will handle all key events

RegisterForKeys( LSRApp_TaskID );

// Update the display

#if defined ( LCD_SUPPORTED )

HalLcdWriteString( "LSRApp", HAL_LCD_LINE_1 );

#endif

ZDO_RegisterForZDOMsg( LSRApp_TaskID, End_Device_Bind_rsp );

ZDO_RegisterForZDOMsg( LSRApp_TaskID, Match_Desc_rsp );


// Register this task with RTOS task initiator

RTOS_RegisterApp( task_id, LSRAPP_RTOS_MSG_EVT );

#endif

}

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

* @fn LSRApp_ProcessEvent

* @brief Generic Application Task event processor. This function

* is called to process all events for the task. Events

* include timers, messages and any other user defined events.

* @param task_id - The OSAL assigned task ID.

* @param events - events to process. This is a bit map and can

* contain more than one event.

* @return none */

60

uint16 LSRApp_ProcessEvent( uint8 task_id, uint16 events )

{

afIncomingMSGPacket_t *MSGpkt;

afDataConfirm_t *afDataConfirm;

// Data Confirmation message fields

byte sentEP;

ZStatus_t sentStatus;

byte sentTransID; // This should match the value sent

(void)task_id; // Intentionally unreferenced parameter

if ( events & SYS_EVENT_MSG )

{

MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( LSRApp_TaskID );

while ( MSGpkt )

{

switch ( MSGpkt->hdr.event )

{

case ZDO_CB_MSG:

LSRApp_ProcessZDOMsgs( (zdoIncomingMsg_t *)MSGpkt );

break;

case KEY_CHANGE:

LSRApp_HandleKeys( ((keyChange_t *)MSGpkt)->keys );

break;

case AF_DATA_CONFIRM_CMD:

// This message is received as a confirmation of a data packet sent.

// The status is of ZStatus_t type [defined in ZComDef.h]

// The message fields are defined in AF.h

afDataConfirm = (afDataConfirm_t *)MSGpkt;

sentEP = afDataConfirm->endpoint;

sentStatus = afDataConfirm->hdr.status;

sentTransID = afDataConfirm->transID;

(void)sentEP;

(void)sentTransID;

// Action taken when confirmation is received.

if ( sentStatus != ZSuccess )

{

// The data wasn't delivered -- Do something

HalLedSet(HAL_LED_2, HAL_LED_MODE_FLASH); //BLINK red led

}

break;

case AF_INCOMING_MSG_CMD:

//extern byte zclYour_TaskID;

//osal_msg_send( zclYour_TaskID, msgPtr );

//osal_msg_send( LSRAPP_CLUSTERID, msgPtr );

LSRApp_MessageMSGCB( MSGpkt );

61

break;

case ZDO_STATE_CHANGE:

LSRApp_NwkState = (devStates_t)(MSGpkt->hdr.status);

if ( (LSRApp_NwkState == DEV_ZB_COORD)

|| (LSRApp_NwkState == DEV_ROUTER)

|| (LSRApp_NwkState == DEV_END_DEVICE) )

{

// Start sending "the" message in a regular interval.

osal_start_timerEx( LSRApp_TaskID,

LSRAPP_SEND_MSG_EVT,

LSRAPP_SEND_MSG_TIMEOUT );

//osal_set_event(LSRApp_TransID, LSRAPP_SEND_MSG_EVT);

}

HalLedSet(HAL_LED_1, HAL_LED_MODE_ON); //flash red led

HalLedSet(HAL_LED_1, HAL_LED_MODE_FLASH); //flash green led*/

break;

}

osal_msg_deallocate( (uint8 *)MSGpkt ); // Release the memory

// Next

MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( LSRApp_TaskID );

}

return (events ^ SYS_EVENT_MSG); // return unprocessed events

}

// Send a message out - This event is generated by a timer

// (setup in LSRApp_Init()).

if ( events & LSRAPP_SEND_MSG_EVT )

{

// Send "the" message

LSRApp_SendTheMessage();

// Setup to send message again

osal_start_timerEx( LSRApp_TaskID, LSRAPP_SEND_MSG_EVT,

LSRAPP_SEND_MSG_TIMEOUT );

// return unprocessed events

return (events ^ LSRAPP_SEND_MSG_EVT);

}


// Receive a message from the RTOS queue

if ( events & LSRAPP_RTOS_MSG_EVT )

{

// Process message from RTOS queue

LSRApp_ProcessRtosMessage();

62

// return unprocessed events

return (events ^ LSRAPP_RTOS_MSG_EVT);

}

#endif

// Discard unknown events

return 0;

}

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

* Event Generation Functions

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

* @fn LSRApp_ProcessZDOMsgs() *

* @brief Process response messages

* @param none

* @return none */

static void LSRApp_ProcessZDOMsgs( zdoIncomingMsg_t *inMsg )

{

zAddrType_t dstAddr;

switch ( inMsg->clusterID )

{

case End_Device_Bind_rsp:

if ( ZDO_ParseBindRsp( inMsg ) == ZSuccess )

{

// Light LED

HalLedSet( HAL_LED_1, HAL_LED_MODE_OFF );// green led on

}

//#if defined( BLINK_LEDS )

else

{

dstAddr.addrMode = Addr16Bit;

dstAddr.addr.shortAddr = 0x0000; // Coordinator

ZDP_EndDeviceBindReq( &dstAddr, NLME_GetShortAddr(),

LSRApp_epDesc.endPoint,

LSRAPP_PROFID,

LSRAPP_MAX_CLUSTERS, (cId_t *)LSRApp_ClusterList,


FALSE );

// Flash LED to show failure

//HalLedSet ( HAL_LED_1, HAL_LED_MODE_FLASH );// green led blinking

}

//#endif

break;

case Match_Desc_rsp:

{

ZDO_ActiveEndpointRsp_t *pRsp = ZDO_ParseEPListRsp( inMsg );

if ( pRsp )

63

{

if ( pRsp->status == ZSuccess && pRsp->cnt )

{

LSRApp_DstAddr.addrMode = (afAddrMode_t)Addr16Bit;

LSRApp_DstAddr.addr.shortAddr = pRsp->nwkAddr;

// Take the first endpoint, Can be changed to search through endpoints

LSRApp_DstAddr.endPoint = pRsp->epList[0];

// Light LED

HalLedSet(HAL_LED_1, HAL_LED_MODE_FLASH); //blink green yellow led

//HalLedSet( HAL_LED_1, HAL_LED_MODE_OFF );// green led on

}

osal_mem_free( pRsp );

}

}

break;

}

}

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

* @fn LSRApp_HandleKeys

* @brief Handles all key events for this device.

* @param shift - true if in shift/alt.

* @param keys - bit field for key events. Valid entries:

* HAL_KEY_SW_4

* HAL_KEY_SW_3

* HAL_KEY_SW_2

* HAL_KEY_SW_1

* @return none */

static void LSRApp_HandleKeys( /*uint8 shift,*/ uint8 keys )

{

zAddrType_t dstAddr;

if ( keys & HAL_KEY_SW_1 )

{

// Initiate a Match Description Request (Service Discovery)

//HalLedSet ( HAL_LED_1, HAL_LED_MODE_ON ); // green led off initially

dstAddr.addrMode = AddrBroadcast;

dstAddr.addr.shortAddr = NWK_BROADCAST_SHORTADDR;

ZDP_MatchDescReq( &dstAddr, NWK_BROADCAST_SHORTADDR,

LSRAPP_PROFID,



FALSE );

}

if ( keys & HAL_KEY_SW_2 )

{

// Initiate an End Device Bind Request for the mandatory endpoint

64

dstAddr.addrMode = Addr16Bit;

dstAddr.addr.shortAddr = 0x0000; // Coordinator

ZDP_EndDeviceBindReq( &dstAddr, NLME_GetShortAddr(),

LSRApp_epDesc.endPoint,

LSRAPP_PROFID,



FALSE );

}

}

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

* LOCAL FUNCTIONS

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

* @fn LSRApp_MessageMSGCB

* @brief Data message processor callback. This function processes

* any incoming data - probably from other devices. So, based

* on cluster ID, perform the intended action.

* @param none

* @return none */

static void LSRApp_MessageMSGCB( afIncomingMSGPacket_t *pkt )

{

char *l1;

uint8 l2;

HalLedSet(HAL_LED_3, HAL_LED_MODE_FLASH);

l1 = (char*)pkt->cmd.Data;

l2 = *l1;

while (!(UCA0IFG&UCTXIFG));

UCA0TXBUF = l2;

}

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

* @fn LSRApp_SendTheMessage

* @brief Send "the" message.

* @param none

* @return none */

static void LSRApp_SendTheMessage( void )

{

for(int i=0;i<160;i++)

{

theMessageData[i] = UCA0RXBUF;

}

if ( AF_DataRequest( &LSRApp_DstAddr, &LSRApp_epDesc,

LSRAPP_CLUSTERID,

(byte) sizeof(theMessageData)*4,

(byte *)&theMessageData,

65

&LSRApp_TransID,

AF_ACK_REQUEST, AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )

{

// Successfully requested to be sent.

HalLedSet(HAL_LED_3, HAL_LED_MODE_OFF); //ON yellow led

}

else

{

// Error occurred in request to send.

HalLedSet( HAL_LED_2, HAL_LED_MODE_OFF );// Red Led on

}

}


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

* @fn LSRApp_ProcessRtosMessage

* @brief Receive message from RTOS queue, send response back.

* @param none

* @return none */

static void LSRApp_ProcessRtosMessage( void )

{

osalQueue_t inMsg;

if ( osal_queue_receive( OsalQueue, &inMsg, 0 ) == pdPASS )

{

uint8 cmndId = inMsg.cmnd;

uint32 counter = osal_build_uint32( inMsg.cbuf, 4 );

switch ( cmndId )

{

case CMD_INCR:

counter += 1; /* Increment the incoming counter */

/* Intentionally fall through next case */

case CMD_ECHO:

{

userQueue_t outMsg;

outMsg.resp = RSP_CODE | cmndId; /* Response ID */

osal_buffer_uint32( outMsg.rbuf, counter ); /* Increment counter */

osal_queue_send( UserQueue1, &outMsg, 0 ); /* Send back to UserTask */

break;

}

default:

break; /* Ignore unknown command */

}

}

}

#endif

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

66

REFERENCES

1. E. Touloupis et al., “Speech Codecs for High-Quality Voiceover ZigBee Applications:

Evaluation and Implementation Challenges,” IEEE Commun. Mag., vol. 50, no. 4, April

2012.

2. J.-M. Valin, “The Speex Codec Manual Version 1.2 Beta3,” Dec. 2007.

3. Human Voice streaming over ZigBee - Low Bandwidth Communication by Manish

Kumar Verma, Adarsh Pillai.

4. L. Y. Hua and F. F. Teng, “Delivering High Quality, Secure Speech Communication

through Low Data Rate 802.15.4 WPAN,” IEEE Int’l. Conf. Telecommunications and

Malaysia Int’l. Conf. Commun., 2007. ICT-MICC 2007.

5. TI TMS320C5505 Family Reference Manual.

6. eZDSP Stick User Guide.

7. LS Research ProFLEX01 R2 Module User Guide and datasheet.

8. http://www.iar.com/en/Service-Center/Downloads/

9. http://support.spectrumdigital.com/boards/usbstk5505/revc/

10. http://www.lsr.com/wireless-products/proflex01-r2

11. http://www.ti.com/tool/z-stack

http://www.iar.com/en/Service-Center/Downloads/

http://support.spectrumdigital.com/boards/usbstk5505/revc/

http://www.lsr.com/wireless-products/proflex01-r2

http://www.ti.com/tool/z-stack

Documents

Btech Thesis