Thesis v06-13th jan

Communication Bottlenecks in ARM-ATMEL Controller Boards
for Robotic Applications
Submitted as partial fulfillment of the requirements for the award of the degree of
Master of Science in Embedded Systems
By
Selvaraju Venkatesh (G1200959C)
Supervisor:
Mr. Yong Chuen-Tze, Mark
Submitted to the School of Computer Engineering
2013

i
Table of Contents
Acknowledgement .........................................................................................................................iii
Abstract.......................................................................................................................................... iv
Acronyms........................................................................................................................................ v
List of Figures................................................................................................................................ vi
List of Tables ................................................................................................................................ vii
Chapter 1 Introduction .................................................................................................................... 1
1.1 Background and motivation .................................................................................................. 1
1.2 Objectives.............................................................................................................................. 1
1.3 Challenges............................................................................................................................. 3
1.4 Organization of thesis............................................................................................................ 4
Chapter 2 Communication Protocol................................................................................................ 5
2.1 Communication Protocol: ..................................................................................................... 5
2.2 SPI Communication: ............................................................................................................. 7
Chapter 3: Implementation Platform ............................................................................................ 15
3.1 Raspberry Pi board.............................................................................................................. 15
3.1.1 Communication in Raspberry Pi .................................................................................. 16
3.1.2 Support for SPI Implementation................................................................................... 16
3.1.3 Enabling SPI Communication...................................................................................... 16
3.2 Arduino Uno........................................................................................................................ 17
3.2.1 Arduino IDE................................................................................................................. 19
3.3 Arduino Due....................................................................................................................... 21
3.3.1 Arduino IDE:................................................................................................................ 23
Chapter 4: Experimental Analysis & Implementation Issues....................................................... 25
4.1 Interface between Arduino UNO and Raspberry pi:........................................................... 25

ii
4.1.1 Communication Bottlenecks: ....................................................................................... 26
4.1.2 Increasing clock Speed:................................................................................................ 26
4.1.3 Operating Voltage: ....................................................................................................... 27
4.2 Communication analysis for Arduino Uno ......................................................................... 27
4.3 Components for communication platform .......................................................................... 28
4.4 Communication platform with multiple slaves or nodes .................................................... 31
4.5 Interface between Arduino DUE and Raspberry pi: ........................................................... 30
4.5.1 Communication Bottlenecks: ....................................................................................... 30
4.5.2 Increasing clock Speed:................................................................................................ 31
4.5.3 Operating Voltage: ....................................................................................................... 31
Chapter 5....................................................................................................................................... 32
5.1 Experimental Results and Limitations of Hardware: .......................................................... 32
5.2 Implementation of Error Detection and Correction: ........................................................... 39
5.3 Implementation of Compression:........................................................................................ 40
5.4 Theoretical Result: .............................................................................................................. 49
5.5 Optimizing Boot time of Raspian Wheezy OS: .................................................................. 50
Chapter 6 Summary ...................................................................................................................... 51
Conclusion:................................................................................................................................ 51
Future works:............................................................................................................................. 52
References:.................................................................................................................................... 52

iii
Acknowledgement
I like to begin my thanks to my parents for supporting me to do a Master degree in their
retired life.
I am grateful to thank my project supervisor Mr. Yong Chuen-Tze, Mark School of
Computer Engineering for guiding me throughout the project to complete my dissertation for
Master's degree. My deepest thanks to his patience for my mistakes in between deadlines. With
your valuable and timing suggestions you made me ease to complete my dissertation. By your
teaching I learned many things technically to find a solution for a problem in a different way of
thinking.
I would like to extend my sincere thanks to Tan Piah Chye, Hardware projects lab for
contributing his support to available resources while working in lab.
I also extend my thanks to each professor during my coursework for clearing my practical
doubts.
At last I extend my sincere thanks to my friend's who supported me to complete my
dissertation.

iv
Abstract
The main scope of the project is to build a high speed communication system for robotic
applications using hybrid controller board for large volume of data. Due to larger number of data
from sensor and actuators, modern applications meets communication bottlenecks to process data
in real time. More number of I/O pins for sensors and actuators requires more power and
memory to handle high volume of data and have latency to handle data. Latency in process can
be avoided by using higher efficient powerful processor and micro-controller with less power
consumption. To avoid overload of a single board to read data from sensor and handle data for
process can be modified to read sensor data in a board and for processing data is passed to a
multi core ARM processor for further communications.
In this project Arduino microcontroller has been used at lower end by interfacing I/O pins
of sensors and Raspberry pi ARM processor board at higher end to handle data for further
communication. By default all low-power communication boards uses serial communication for
reason of ease of implementation and for efficient result. When coming to high bandwidth
communication the speed was limited. The choice of high bandwidth communication protocol
and interface issues has been discussed in further chapters. By implementing high bandwidth
protocol and rectifying issues faced by current robotic controller it is possible to build a better
efficient robot for future enhancement.

v
Acronyms
CAN - Controller Area Network
CPU - Central Processing Unit
DAC - Digital to Analog converter
EEPROM - Electrically Erasable Programmable Memory
EOT - End of Text
IDE - Integrated Development Environment
I2C - Inter Integrated Circuit
KB - Kilo Byte
JTAG - Joint Test Action Group
LAN - Local Area Network
LZW - Lempel-Ziv-Welch
MB - Mega Byte
MISO - Master-In Slave-Out
MOSI - Master-Out Slave-In
RISC - Reduced Instruction Set Computing
SCK - Clock
SOT - Start of Text
SPI - Serial Peripheral Interface
SRAM - Static Random Access Memory
SS - Slave Select
UART - Universal Asynchronous Receiver Transmitter
USB - Universal Serial Bus.

vi
List of Figures
Figure 1.1 Objective of application design .................................................................................... 3
Figure 2.1 SPI Block Diagram...................................................................................................... 7
Figure 2.2 Modes of SPI communication ...................................................................................... 8
Figure 2.3 SPI timing diagram....................................................................................................... 9
Figure 2.4 Schematic of SPI data transfer.................................................................................... 10
Figure 2.5 Interrupt Based communication between Master and Slave ...................................... 12
Figure 2.6 Sequence Flow diagram of different booting time processor..................................... 13
Figure 2.7 Problem with existing boot time asynchronization .................................................... 14
Figure 2.8 Solution for existing boot time asynchronization....................................................... 14
Figure 3.1 Raspberry pi board...................................................................................................... 15
Figure 3.3 Arduino UNO board specifications ............................................................................ 17
Figure 3.4 Arduino UNO Schematic diagram ............................................................................. 18
Figure 3.6 Arduino Due board specifications .............................................................................. 21
Figure 3.7 Arduino Due Schematic diagram ............................................................................... 22
Figure 3.8 Arduino IDE v1.5.3 for Arduino Due......................................................................... 23
Figure 4.1 Interface between Raspberry pi and Arduino Uno via SPI ........................................ 25
Figure 4.2 Level Shifter for 3.3v to 5v ........................................................................................ 27
Figure 4.3 Interface between Raspberry pi and Arduino Uno via SPI ........................................ 30
Figure 5.1 Graph for receiving data in Raspberry Pi................................................................... 33
Figure 5.2 Receiving speed of data in Raspberry pi .................................................................... 34
Figure 5.3 Graph for receiving data in Raspberry Pi ................................................................... 36
Figure 5.4 CPU usage while IDLE .............................................................................................. 38
Figure 5.5 CPU usage while running........................................................................................... 39
Figure 5.6 Flowchart for LZW compression algorithm............................................................... 42
Figure 5.7 Running compression for random integer and large text. .......................................... 43
Figure 5.8 Slave Mode Functional Block Diagram ..................................................................... 44

vii
List of Tables
Table 3.1 Key specification of Arduino Uno................................................................................ 17
Table 3.2 Key Specification of Arduino Due ............................................................................... 21
Table 3.3 Cost of Resource........................................................................................................... 24
Table 5.1 Receiving data speed in Raspberry pi........................................................................... 33
Table 5.2 Format for Error detection with checksum................................................................... 40
Table 5.3 Dictionary table for LZW algorithm............................................................................. 41
Table 5.4 Compression results for various files............................................................................ 43
Table 5.5 Table for configuring BITS in SPI_CSR Register........................................................ 46

1
Chapter 1 Introduction
1.1 Background and motivation
In the modern world all embedded applications are handling large amount of data.
Especially for robotic applications it's a new era for modern sensor's. Earlier we used only sound
and light sensor, nowadays various kind of sensor's are used. At present robot applications use
modern sensor which have large amount of data for system. when coming to processing, system
become slow to perform all actions before next command. In high speed data interface systems,
the speed of transmission and data acquisition are creating new challenges for portable systems.
A new trend of ARM+Arduino combinational controller become so popular for robot
applications. In this project we will briefly discuss about implementation high speed
communication between ARM and ATMEL boards.[1]
1.2 Objectives
The objective of the project is to build high speed compact system for robotic
applications with ARM and ATMEL hybrid controller. The task of the robot application to
handle large amount of data between processor and controller. Existing system uses serial
communication protocol for communication between board and sensor's. It is quite slow when
system needs to transfer large amount of data for processing. When using serial communication
we can able to achieve maximum transfer of 14.0625 KB/s.
In my project, I'm building a system which can have large number of sensors Eg. speech
sensor, distance sensor, temperature sensor etc. Speech sensor collect text data, temperature
sensor collect float value, distance sensor collect either integer or byte value. So amount of data
will be in larger value of KB's or even in MB's. With the serial communication we supposed to
loss data bytes. So the communication bandwidth should be higher than serial communication.
Here an example for single sensor. Infrared thermometer-MLX90614 which represents
temperature in float values. It has 11 bit resolution with response time of 1.024ms. For a second
it produces 977 responses, to represent a value in terms of bytes we consider it as 16bit value
which mean it will be calculated as 977*16 bits/sec=15632bits/sec =1954 bytes/sec = 1.91KB/s.

2
If we use 8 similar sensors it exceeds serial communication bandwidth and creates
communication bottleneck for large number of sensors. To avoid communication bottleneck in
between commands we should design system with higher bandwidth communication.
For Example, Arduino Due has 12 analog pins. If we have similar sensors which have
data value for above mentioned sensor. Then we will have 22.92KB of data. If we transfer data
for every second then our required data transfer is exceeds maximum transfer data throughput of
serial communication.
Here Arduino is going to be a data collection node which will transfer collected data at
specific intervals. Two system design are considered as shown in Figure 1.1. In first case
Raspberry Pi and Arduino Uno has been chosen and in second case Arduino Uno is replaced by
Arduino Due. These two cases are used to prove high bandwidth transmission between boards
and communication bottlenecks are clarified to build perfect high-speed hybrid controller[2].
Arduino Uno is chosen here because it is the low-cost arduino ATMEL microcontroller,
as it is the first microcontroller from arduino it has well built libraries for implementation. On the
other hand arduino Due has been chosen, since it has more IO pins and more SRAM memory
compare to other arduino microcontroller. It the latest microcontroller from arduino with
ATMEL SAM3X8E. My final system able to communicate data at higher speed than serial
communication.

3
Figure 1.1 Objective of application design
1.3 Challenges
Basically Arduino micro-controller configured as master node for controlling sensor and
every data has handled in same board. Challenge here is to make Arduino as a sensor node to
collect data and transfer collected data to another board for further communication. When taking
two board its unstable to configure together due to issues of hardware pins and support for one
board to other.
SPI communication doesn't have the support for error correction and detection because
SPI specifies the signaling protocol. The meaning of the bit is not defined by the protocol. We
can write our software to do error correction but it will take additional CPU usage for working it
and may produce delay between incoming bytes.
Compression algorithm implementation where memory source on-board has been limited.
Because when more number of sensor's data are read by microcontroller, if transmission speed is
slow it have to hold the data until all collected data are transmitted. It will skip data to send when
size of data exceeds on-chip memory. So compression can be implemented to avoid memory

4
shortage. Compression quite easier for repeated number of bytes and for worst case it is very
difficult for non-repeated bytes.
1.4 Organization of thesis
The remaining chapters are organized as follows:
Chapter 2-Communication Protocol
The chapter discuss about various communication protocol for board to board
communication. Reason for choosing protocol and discussed about problem in interrupt based
communication.
Chapter 3-Implementation Platform
This chapter describe about each platform of Raspberry pi and Arduino microcontroller.
Elaborated hardware description will give an idea about I/O pins to configure for
communication.
Chapter 4-Experiental analysis & Implementation Issues
This chapter illustrates how to physically design system with wires for communication
pins. And also limitations of hardware platform for certain cases for which communication is
limited. And addressed about latency of hardware and data bandwidth problem.
Chapter 5-Experimental Results
This chapter shows the results of build systems of raspberry pi and Arduino Uno,
Raspberry pi and Arduino Due. Implementation Error correction and detection for SPI protocol
has been discussed. Compression for data where memory resources has limited.
Chapter 6-Conclusion and Future works
This chapter provides summary of high speed communication between ARM and
ATMEL microcontroller and suggestions for future work.

5
Chapter 2 Communication Protocol
2.1 Communication Protocol:
The UART (Universal Asynchronous Receiver Transmitter) a two way communication
protocol Tx and Rx pins since its very basic and popular communication protocol for low level
peripherals. It supports up to 115Kbits per second.
CAN (Controller Area Network) is a multi-master communication. Each master will be
able to send/receive data at a time. It supports up to 1Mbits per second.
I2
C (Intel-Integrated Circuit) is a half-duplex, master-slave communication. One master
and maximum of 127 slave devices connection can be possible. There are two pins; one is SDA
(data) and SCL (clock). It can transfer data between two processors but one way transmission
can be possible at a time. Slave select is done by device addressing by software. To be able to
support multiple devices on a same bus, utilizes pull up resistor on the wires. The peripheral can
be pulled low by the device „logic 0‟. And to release the device pulled high by the device „logic
1‟. Latest hardware control capable of transmitting 3.4Mbits per second.
USB2.0 and USB 3.0 can transfer data at 480Mbit/s and 5Gbits/s respectively. For USB
protocol the complexity was high in terms of latency, packet framing, routing issues. Since SPI
and I2C had well support for Atmel controller. Moreover arduino microcontroller doesn't have
physical availability of USB port and driver support for it. Arduino Uno has Type B USB port
which is designed for USB-Serial communication and data speed is limited to 115200bps. Even
if we design USB port, it's very difficult to write our own USB driver support and implement it
in ATMEL controller. With the less amount of SRAM memory we can't frame data to send at all
time. With SPI and I2C protocols it is easier to add additional slave devices without any complex
structure and it needs a single additional wire to add it. Compare to I2C, SPI has higher transfer
bit rate. I observed 60% improve in data transfer rate by using SPI protocol instead of serial
communication in later section.
SPI (Serial Peripheral Interface) is a full-duplex, master-slave communication, basically
3or4 wires protocol. MOSI (Master Out, Slave In), MISO (Master In, Slave Out) and SCLK
(clock from master)[3]. In certain cases multiple slaves are used, at this case 4th
wire SS (Slave
Select) is kept low to use a particular peripheral. Other time it kept high. It‟s a kind of ring

6
communication between two processors. Master shares the clock with slave. Data bit is available
at rising edge of the clock. The data rate often goes 10Mb/s [4].
Whenever one of the devices wants to transmit data to other then it is half duplex. Master
will be identified by the SS pin if it set as low. After the transmission master will set SS pin as
high. It has two libraries namely a circular FIFO and an UART communication library. A
circular FIFO library offers dynamically allocation of circular FIFO, commonly used in
communication applications. The UART communication library supports interrupt based
reception into a circular FIFO; interrupt based transmission from a circular FIFO as well polled
mode byte transmission[5].
Here we are going to briefly discuss about the SPI interface, the reason of choosing this
interface in a system because it‟s a two way communication protocol where the speed was in
Mbps.

7
2.2 SPI Communication:
To begin communication, SPCR (SPI Control Register) register in master and slave
should be configured; master should have clock speed at which going to be run[6]. It should be
less than or equal to slave can able run at the speed. Master generate clock for the whole system.
7 bit 6 bit 5 bit 4 bit 3 bit 2 bit 1 bit 0 bit
SPCR SPIE SPE DORD MSTR CPOL CPHA SPR1 SPR0
Figure 2.1 SPI Block Diagram
SPR0 and SPR1 the two bits to configure the clock speed of processor.
DORD bit controls the direction of the transmission if it set as low it will transmit MSB
bit first and LSB last in SPDR register else LSB bit first and MSB last. Clock polarity decides
when to send/receive data whether at falling edge or rising edge. If CPOL bit is set as low the
data going to be send/receive at the rising edge of the clock else in falling edge of the clock.
Clock phase decides when to read data whether at falling edge or rising edge. If CPHA bit is set
as low the data going to be read at the rising edge else high for falling edge of the clock.

8
MODE 0
MODE 1
MODE 2
MODE 3
Figure 2.2 Modes of SPI communication

9
Figure 2.3 SPI timing diagram

10
SPE bit enables the SPI interface between master and slave. SPIE bit enables the SPI
interrupt service routine. MSTR bit in the SPCR register tells about whether the processor is
master or slave. If set HIGH act as master else act as slave. SPDR (SPI Data Register) is an 8-bit
register the 7th
bit is the MSB and 0th
bit is LSB of the data.
Master initiates communication by setting CS pin low which indicates the data going to
transfer. After clock is set the MSB bit is first transfer in the 8 bit shift register via MOSI pin. At
the transfer of a bit master can able to read a bit from MISO pin. After the completion of transmit
bytes the CS will be high.
Figure 2.4 Schematic of SPI data transfer
Issues faced by processor for SPI:
 Clock speed:
The major issue face by the embedded processor is the clock speed between the processor
going to run. SPI interface communication based on the clock of the master. Slave clock will be
less when compared to master. So we have to run the master at equal to or less than the slave
clock speed. By running master at slave clock speed the synchronization of data between
processors will be correct. What can we do if data‟s are incorrect even running at the same clock
speed. Error detection and error correction technique can be used to resolve the problem. But SPI
doesn‟t have the support of error detection and error correction. Then how to implement it? In
that case the user program can able to resolve this problem. Supported clock speed is based on
clock divider, speed ranges from 500KHz to 4MHz for Arduino Uno.

11
 Solution for Clock speed issue-ERROR CORRECTION AND ERROR
DETECTION:
The error correction code is in the form of adding additional bytes of checksum,
length, start byte and end byte along with the data bytes from the transmitter before transmission.
The error detection code is in the form validating bytes received in the receiver side with the
additional bytes. If the bytes received correctly it acknowledges the transmission[7]. Software
written in the transmitter automatically retransmits data until data received correctly by the
receiver which leads to continuously in transmit loop even if receiver is not working. If transmit
was successful transmitter will ready for next transfer but it may leads to continuously consume
power. If transmitter needs acknowledgement for retransmission, then transmitter waits for
acknowledgement from the receiver even receiver fails to work. It will affect the communication
between other slaves. To reduce that wastage of power we can use interrupt-based
communication method.
 INTERRUPT-BASED COMMUNICATION METHOD:
In multiple processor communication system, we can implement interrupt based
communication to prevent transmitter to wait for a receiver acknowledgement whether the
receiver is working or not. Also it improves ability of transmitter to communicate to other slave
instead of lock for a slave. ARQ (Automatic Repeat Request) is an acknowledgement from
receiver to transmitter, if it unsuccessful in last transmission of data then negative
acknowledgement otherwise positive acknowledgement[8]. To inform receiver that transmitter
wants to transmit data by sending IQR (Inquire). If receiver ready to receive data then it
acknowledge interrupt to the transmitter, after that transmitter sends data bytes to receiver.
Whether the receiver in processing state of previously data it will send a busy acknowledge or
not working it won‟t acknowledge for IQR from transmitter. Once it completes the receiving of
bytes it will wait for IQR. This way helps the transmitter to avoid unnecessary wait state for
acknowledgement.
In SPI interface, processor which is connected to sensor is continuously reads the
value from it. When the other master sends the IQR (may be command byte) to slave it will
consider as interrupt, after receiving byte it will check whether it is command byte if it so will

12
send data bytes which read from sensor. After sent of data bytes it needs some delay to read next
data from sensor until that it will disable the next interrupt.
Figure 2.5 Interrupt Based communication between Master and Slave
Another issue face by the embedded system is booting time of the processor. Most of the
embedded processor has the different operating clocks. If similar processor used to form a
system then there will be no delay of booting time between them. Else two different processors
in a system, most master takes more time to boot than the slave. If processor finishes the
processing before the boot of other processor have to wait for the other processor to send status
of the processor.
Faster processor has to run time delay in the program after completing processing of data
and before transmit of data to get response from slower processor.
MASTER SLAVE
Booting Time
Booting Time
IQR wait
Read data from sensorACK Wait
Data Processing 1
POWER ON
IQR
ACK IQR
Command
DATA
IQR
IQR wait

13
Figure 2.6 Sequence Flow diagram of different booting time processor
Suppose master processor connected to multiple slave devices which have different clock
speed then it will be a complex logic to implement time in software to configure the slaves in the
system to communicate with the master[9]. For different processor different delay time by
coding will make the software worse. Instead of that, we can set unique clock speed at which all
slave can operate, in this case it can work but it may lead to slower in terms of speed of
communication.
 Solution for Interrupt based communication- RESET Signal
If Master board has operating system its booting time is longer than microcontroller
slave. Slave may wait for an interrupt will help the system instead of waiting for a command
byte. In another side, slave can take more time to boot the system. At that time interrupt sent by
the master cannot be received by slave. And it won‟t receive any data from slave. But master will
keep on transmitting interrupt. We can use a reset signal after the boot of slave. Once master got
the reset signal from slave, master initiates the communication by sending command byte as
interrupt. Slave will consider command byte as interrupt. At the interrupt function it will check
whether the received byte is command byte for data transfer or some junk data. If the command
byte is received then slave will transmit data to master. Master boot time is greater than slave
then there will be no delay in process because slave communication will establish when master
clock generates signal otherwise it wait for the master clock. Let see how the reset signal is set.
MASTER SLAVE
Booting Time
Booting Time
Time delay (master boot)
Time delay (master process)
Time delay (master process)
Command receive & Data Transfer 1Command send & Data Receive 1
Data Processing 1
Command receive & Data Transfer 2Command send & Data Receive 2
Data Processing 2
POWER ON

14
Figure 2.7 Problem with existing boot time asynchronization
Figure 2.8 Solution for existing boot time asynchronization
In the meanwhile, we have to check the capability of processor whether it can act both
master and slave. Especially ARM based system can only act as master. So there should another
microcontroller used in the system to act as slave. The reason behind the issue is by default the
kernel space modules are designed to only act as master.
MASTER SLAVE
Booting Time
Booting
Time
Processing Time
POWER ON
IQR
Reset waiting
MASTER SLAVE
Booting Time
Booting
Time
POWER ON
Reset
IQR waiting
IQR

15
Chapter 3: Implementation Platform
3.1 Raspberry Pi board
Raspberry Pi is a palm size computer with an ARM1176JZF-S ARM processor. Raspian
Wheezy is a Linux based Operating system that can be loaded in a 4GB SD memory card and
booted from it. It is a powerful ARM processor with 512MB of RAM and runs at 700MHz[10].
It can be over-clocked to speed of 1GHz. Nowadays it used widely low-cost, low-power robotic
applications. For developing applications HDMI port is available to connect with HDMI monitor
and writing code can be done with wireless keyboard and mouse.
Figure 3.1 Raspberry pi board
As it runs Linux OS, a developer can able to write code in various programming
languages like C,C++ and python are most popular and execute it. We can write code with or
without GUI. GUI software for coding Geany and Gedit. Geany is integrated IDE with
terminal[11]. For specific applications we can directly hook up sensors with raspberry pi and run.
Operating voltage at 3.3v consumes less power even for continuous run.

16
3.1.1 Communication in Raspberry Pi
Raspberry pi with an ARM11 processor can capable of transfer data via serial,I2
C and
SPI protocols with limited wires to other boards. If we are looking for high speed protocols we
can implement Ethernet protocol between boards, but we must ensure that both boards have
physical available of LAN adapter for connection. In our platform we going communicate
between arduino Uno and raspberry pi. Arduino Uno doesn't have a LAN adapter with it. It's
quite expensive to add LAN adapter in arduino. so we try to communicate with SPI. Since SPI
can able to transfer bit rate at a very high range of Mbps. Benefit of SPI over other protocols is
that can capable of Bidirectional communication at a time. Maximum clock speed of SPI in
raspberry is 16MHz. Minimum clock speed supported by SPI is 500KHz.
3.1.2 Support for SPI Implementation
As we know in SPI communication between two boards one should be act as master and
other as slave. Master runs clock for communication with slave. Slave respond back with
synchronization of master clock. Raspberry pi designed as can only work as master so raspberry
pi cannot be slave at any time. Because Raspberry pi cannot work without running clock, as
slave is not possible to configure by muting clock. And also it's not possible to do SPI
communication between two raspberry pi boards[12].
3.1.3 Enabling SPI Communication
By default Broadcom BCM2835 pins for SPI communication has been disabled to avoid
damage of pins. To enable it include "#" at start of lines in the file.
Figure 3.2 Enabling SPI communication[13]

17
3.2 Arduino Uno
An Arduino Uno is an Atmel 328P 8-bit AVR microcontroller with RISC
architecture[14][15]. It has 14 digital IO pins to hook up multiple sensors. It able to handle 6
analog inputs. It supports communication via RS232,I2
C,SPI with other boards. Operating
voltage at 5v is common among microcontroller. With compact size of length and width of 2.7
and 2.1 inches acquires less space in a compact system. It is a low cost microcontroller in
arduino family.
Table 3.1 Key specification of Arduino Uno
Input
Voltage
Flash
Memory
SRAM EEPROM Clock Speed SPI Clock
Speed
Software
6-12 V 32 KB
(0.5KB for
boot loader)
2KB 1KB 16MHz 4MHz Arduino
IDE
v1.0.5
Figure 3.3 Arduino UNO board specifications

18
Figure 3.4 Arduino UNO Schematic diagram
With Arduino we can read sensor data, control motor, lights, read switches and control small DC
motor. A beginner can easily able to do code in c program to perform small task. In c program it
can able to compile 300,000 lines of code in a single program. With some extensions we can
access hardware in code.
 Flash Memory for source code:
With the 32KB of flash memory we can flash our code. Feature of arduino is no
need to compile code in board. In host pc we can do compiling process and flash the code in the
board memory.

19
 Clock Frequency:
The Arduino uno has 16MHz clock speed for operating. For SPI specific it limited
to 4MHz, PIN 13 drives the clock for SPI.
3.2.1 Arduino IDE
To develop code, arduino is provided with IDE which run on host pc to compile code and
is very simple to use. It doesn't have all libraries which normal c compiler has. Latest version of
arduino IDE can be downloaded freely from arduino website. It build with standard
programming language compiler so there is no need to separately install compiler in the host pc.
Arduino IDE can communicate with board through USB cable. And we easily choose to which
arduino board we going to compile. It also support user defined library files to include in our
program to compile.
Figure 3.5 Arduino IDE v1.0.5 for Arduino Uno
 Code Downloader:
As all the compiling process done in the host pc, then we have to download code
to board via type B USB cable. Arduino UNO has on board type B USB connector. A single
click of "LOAD" in arduino IDE will download code to arduino Uno board.

20
 Power Supply:
As mentioned above it operating voltage at 5v, it can be powered by different forms.
1st by (External power supply pin),
2nd by (type B USB port draws current host pc) and
3rd by (On board pin for power supply from other board).

21
3.3 Arduino Due
An Arduino Due is a Atmel SAM3X8E ARM Cortex-M3 microcontroller[16]. It is a
Thumb-2 Instruction set. It has 54 IO pins to connect digital sensors. It able to handle 12 analog
inputs and additionally it has 4UART for serial communication and 2 DAC(Digital to Analog
Converter). It supports board to board communication like Arduino UNO additionally with CAN
BUS protocol. This board operating at 3.3v it will not tolerate higher voltage like 5v. With
compact size of length and width of 4 and 2.1 inches. Cost is quite high among arduino
microcontroller's.
Table 3.2 Key Specification of Arduino Due
Input
Voltage
Flash
Memory
SRAM DAC Clock Speed SPI Clock
Speed
Software
7-12 V 512 KB 96KB 2 84MHz 4MHz
(default)
Arduino
IDE
v1.5.3
Figure 3.6 Arduino Due board specifications

22
Figure 3.7 Arduino Due Schematic diagram
 Flash Memory for source code:
With the 512 KB of flash memory we can flash large user application of our code to the
memory. It has dedicated memory for boot loader.

23
 Clock Frequency:
The Arduino due has 84MHz clock speed for operating. For SPI specific it limited to
42MHz, PIN 110 drives the clock for SPI.
3.3.1 Arduino IDE:
As mentioned in 3.2.1 we can understand about arduino IDE. There is a separate version
IDE for Arduino Due. To change type of board we have to select in the board option under tools.
Figure 3.8 Arduino IDE v1.5.3 for Arduino Due

24
 Code Downloader:
As all the compiling process done in the host pc, then we have to download code
to board via programming port (micro USB) near to external power supply. A single click of
"LOAD" in arduino IDE will download code to Arduino Due board.
 Power Supply:
As mentioned above it operating voltage at 5v, it can be powered by different forms.
1st by (External power supply pin),
2nd by Native usb port (micro USB)and
3rd by (On board pin for power supply).
Resource List:
Table 3.3 Cost of Resource
S.No Items COST in S$
1 Raspberry Pi - Model B 49.9
2 Arduino Uno R3 32.7
3 Arduino Due 71.0
4 Level Shifter 1.9
Source: www.sgbotic.com

25
Chapter 4: Experimental Analysis & Implementation Issues
4.1 Interface between Arduino UNO and Raspberry pi:
Arduino is a very good microcontroller to connect sensors and read values of it. With
availability digital IO pins easy to hook up peripherals. Arduino purpose to read only sensor
values and processing values are done in Raspberry pi[17][18][19] since it has enough RAM. As
mentioned above, SPI protocol is the high speed way of communication between boards. To
communicate arduino and raspberry pi things like clock speed, voltage on pins and available
memory are to be considered.
Figure 4.1 Interface between Raspberry pi and Arduino Uno via SPI

26
In raspberry pi pins 19-MOSI,21-MISO,23-SCLK,6-GND[20] has been connected to
Arduino pins 11-MOSI,12-MISO,13-SCK,GND[21] together for SPI implementation. Wires of
MOSI, MISO, SCK are connected together with level shifter.
4.1.1 Communication Bottlenecks:
To get data byte from arduino uno we should send a byte from raspberry pi(master).
Since arduino uno is 8-bit microcontroller. Only one byte at a time is quite slow process of
communication in one transfer. By doing one byte transfer we will not achieve maximum data
transfer rate of SPI protocol standard. So we going to come up with a solution to eliminate less
data throughput between boards.
4.1.2 Increasing clock Speed:
Clock speed is the major factor to use SPI for high speed data transfer. Master initiates
communication by sending command byte to slave. First bit of command byte transferred when
clock is high. And receives first bit of data byte on low. By default arduino SPI clock speed is
4MHz whereas in Raspberry pi is 16MHz. To synchronize communication with two boards we
must run both boards at same clock speed. Obviously we have to run at 4MHz in both boards to
achieve maximum speed communication. For initial communication and analyze data
throughput, clock speed in raspberry pi is gradually increased from 500KHz to maximum speed.
Results of data received shows that the data transfer rate increased when speed is doubled with
the previous speed it was ran.
Clock speed in Raspberry pi can be increased to its maximum speed but after 4MHz there
is no improvement in the data throughput. At this position increasing speed still works with data
transfer but missing of bytes in a packet is started. This problem is arrives due to improper
synchronization with the arduino packet message. Since arduino uno supports maximum SPI
clock speed of 4MHz. Before it complete full packet transfer next command byte is received in
arduino to send next packet. Because of limited size of RAM it not able to hold data which have
to be send.
By increasing clock speed the percentage of delay between each byte is reduced. As the
percentage of delay is reduced which results increase in data transfer rate. Since raspberry pi has
enough RAM is doesn't disturb data transfer and data processing. SPI master it doesn't know

27
anything about the slave which is connected to it, it's just send and receive byte with the clock
for every transfer. As a serial transfer it send and receive byte by byte between master and slave.
4.1.3 Operating Voltage:
The operating voltage for Raspberry pi GPIO pins is 3.3v and Arduino GPIO is 5v. For
serial communication there will be no issue with voltage whereas incase for doing SPI
communication it should be at same operating voltage because master running clock otherwise it
will affect communication protocol. And also it creates latency issue with transfer of bytes to and
fro. So there is a need of level shifter between these two boards. Level shifter will shift 3.3v pins
from raspberry pi to 5v pins in arduino. MISO,MOSI and CLK are the three pins and one more
pin for GND, the need of common ground connection between two board is protect higher
voltage pins will not affect lower voltage pins.
Figure 4.2 Level Shifter for 3.3v to 5v
4.2 Communication analysis for Arduino Uno
When doing communication with arduino Uno if we send one byte at a time it response
with a byte and if we send two byte at a time it will response for first byte and for second byte it
will not give response. This is due to SPDR register RESET signal is goes high after a transfer of
a byte is completed since it is a 8-bit microcontroller. The second byte will be revert back to
sender. Eg. if we send 100 bytes in a single transfer, the first byte will be responded and
remaining bytes will be revert back to sender.

28
4.3 Components for communication platform
Required system components are listed below. Each component is described briefly for
what purpose it has been used.
 Sensor
 Level Shifter
 Monitor with HDMI port.
 Cabling
 Power Supply.
Sensor:
Various sensor available for robotic applications like camera, temperature, switch read,
joystick, light, sound, accelerometer, etc. These kind of sensors are available in the market to
hook up with arduino.
Level Shifter:
Since both board operating voltage are different, there is a need of level shifter which has
discussed in section 4.1.3 for arduino Uno. And no need for arduino Due.
Cabling:
As known SPI is a 3 wire communication protocol(MOSI,MISO,SCK) pins to be
connected together in each board (Master & Slave). Additional cable is required if adding
multiple slave to the master. Since both board has different operating voltage, here a level shifter
is used to convert voltage level between them for IO pins. So each pin has been connected from
raspberry pi to level shifter and then to arduino Uno pins of (MOSI - pin 11, MISO - pin 12,
SCK - pin 13 and pin 10 for SS). Without a bread board it's not possible to interconnect board
together.
Monitor with HDMI port:
For evaluating the communication process between arduino and raspberry pi, a monitor
with HDMI port is used to display data received by raspberry pi via HDMI port available in
Raspberry pi.

29
Power Supply:
It has been discussed in section 3.2.1. External power supply require separate wire to the
board. As a compact system it should not require external power supply for each board. so power
is drawn from another board.
Benefits of Arduino DUE over Arduino UNO
 More number of digital IO pins and analog pins.
 Increased clock speed of microcontroller.
 SPI supported clock speed is higher.
 Number of SPI channels is more.
 Available of 2 DAC.
 32bit ARM cortex processor.
 4 High speed serial communication ports.
 High speed CAN BUS protocol.
 More Flash memory for user application.
 More SRAM to handle data.
 Same operating voltage 3.3v as Raspberry pi.
 8-16 bits data length of SPI transfer.

30
4.4 Interface between Arduino DUE and Raspberry pi:
Arduino Due can be best replacement in terms of SRAM, clock speed and number of bits
transfer for arduino Uno.
Figure 4.3 Interface between Raspberry pi and Arduino Uno via SPI
In raspberry pi pins 19-MOSI,21-MISO,23-SCLK,6-GND has been connected to Arduino
Due pins 109-MOSI,108-MISO,110-SCK,GND together for SPI implementation.
4.4.1 Communication Bottlenecks:
In SPI communication 8 bit transfer is a default, here arduino due can be configured to
8-16 bits transfer. To get 16bit data from arduino Due we must transfer 16 bit data transfer from
raspberry pi. By making CS(chip select) low until two byte transfer we can achieve this.

31
4.4.2 Increasing clock Speed:
By default arduino due has SPI clock speed of 4MHz and it can be configured up to
84MHz[22]. Here arduino due is configured as slave so there is no need of setting clock speed.
Compare to Uno it supports higher speed for SPI communication with raspberry pi. It results
increased data transfer rate.
4.4.3 Operating Voltage:
Since both arduino due and raspberry pi has same operating voltage there is no need of
level shifter between them.
4.5 Communication platform with multiple slaves or nodes
Reasons for not testing with multiple slaves or nodes are first when replacing serial
communication with SPI protocol how data throughput is increased?, after analyzing it secondly
our aim is set to test with single node with multiple slaves and with large amount of data to
check how our system able to handle bottleneck, third the current budget was limited with the
available resource, it takes additional time to test analysis part if we have multiple nodes, and the
result of the current analysis is not considered for future work.
What happen if we have two or more data collection node? In near future we may add
multiple data collection nodes to add additional sensors. If we use either SPI or I2C data
throughput depends on clock speed and length of bits for a packet going to be transfer. Once both
terms is set to maximum it will not make change in data throughput when we add multiple slaves
or multiple data collection node into bus protocol. Because data collection node or slave to
collect data is decided by master by selecting slave select line. If slave select is set to HIGH it
will not be active for data collection. Once it is set to LOW master starts to read data from it and
rest of the slave set to HIGH. By coding mistake if we set LOW for two slave at a time data will
collide with each other. Even though we add multiple number of nodes the resultant data
throughput will not increase. Since data throughput increase is based on only clock speed and
length of bits per transfer.

32
Chapter 5 Experimental Results
5.1 Experimental Results and Limitations of Hardware:
Here SPI protocol is chosen, it is the high speed protocol for board to board
communication with limitation of standard up to 4Mbytes/sec and without limitation it can go up
to 10Mbytes/sec. Drawback of SPI protocol is doesn't have ECC for incoming data. In my work,
I have done Error detection and Correction for incoming data, compression of data with offline
and online stream of data added for SPI protocol. I have configured Arduino UNO and Arduino
DUE as slave in two different cases. Since arduino going to be data collection node connected
with sensors and read data from it and pass data to raspberry pi for further data processing. Here
I configured Raspberry pi Type B as Master. Due to limitations with hardware for
communication in Arduino Uno I have extended my work with Arduino Due.
Two cases:
i. Raspberry pi(Master) and Arduino Uno(Slave)
ii. Raspberry pi(Master) and Arduino Due(Slave)
In further section i have explained briefly about using Arduino UNO and Arduino DUE as SPI
slave.
 Raspberry pi(Master) and Arduino Uno(Slave)
To begin communication between arduino uno and raspberry pi i have used UART to
transfer data from arduino to raspberry pi via USB cable since raspberry pi configures USB port
as UART. Without any lag i can able to receive data which has been sent from arduino UNO.
Next SPI protocol has been implemented. In arduino Uno i kept array of bytes to test the
communication. As the SPI communication data throughput is based on clock speed, it can be
changed to various speeds up to the maximum supported speed. Here raspberry pi is activated
with various clock speed minimum of 500KHz and i designed my software to measure incoming
byte speed. Then i increased clock speed in raspberry pi gradually in frequencies of 1MHz,
1.5Mhz, 2MHZ, 2.5MHz, 3Mhz, 3.5MHZ, 4MHz. 4MHz is the maximum clock speed supported
by arduino Uno.

33
In below Figure 5.1 Green line indicates the data transfer rate without any missing of
data, after 4MHz the red line indicates data throughput with missing of bytes while transfer.
Table 5.1 Receiving data speed in Raspberry pi
Clock speed in KHz Data Receive speed in Bytes/Sec
500 11.16
1000 14.71
1500 14.99
2000 18.7
2500 18.84
3000 18.68
3500 18.51
4000 24.42
4500 24.4
5000 23.95
5500 25.02
At 4MHz system able to transfer around maximum of ~25.47KBytes/sec.
Figure 5.1 Graph for receiving data in Raspberry Pi
0
5
10
15
20
25
30
500 1000 1500 2000 2500 3000 3500 4000 4500 5000 5500
DataTransferRateinKBytes/s
Clock Speed in KHz
Data with valid bytes
Data with corrupted bytes

34
Figure 5.2 Receiving speed of data in Raspberry pi
When using SPI communication we can improve data transfer rate by 60% to
25.42KB/s instead of using serial communication.

35
From the Figure 5.1 i have observed two things. First the data transfer rate is not a
straight line and second scale factor is not 1:1.
For the first, the data throughput doesn't increase linearly with clock speed. Raspberry Pi
only works with the certain clock speeds of 500KHz,1MHz,2MHz,4MHz,8MHz and 16MHz. If
we set clock speed in between these values it will not make effect in change of clock speed.
Secondly the data transfer doesn't have scale factor of 1:1. For every transfer the system
will configure the SPI protocol of clock speed and allocate memory size. In Linux based system
each process has been written to a file and handled by the kernel. i.e. to access hardware SPI
pins. So if we transfer just 1 or 2 bytes per transfer the percentage of latency is high in between
transfer. It means the percentage of configuration time is large compare to less number of data
bytes. So data transfer rate doesn't linearly increase with the clock speed. Here latency is about
the percentage of configuration time. To increase efficiency we should transfer large block of
bytes at a time. If we increase data block size, it will improve the percentage of efficiency of the
data transfer. It means the percentage of configuration time is less compare to large block of
data. So we can able to receive data at higher rate.
To analyze efficiency with large block of data, I started to test with large block of data.
Since Arduino Uno cannot send more than one byte at a time. Because all arduino controller are
designed to transfer 8bit or 16bit at a time. So we cannot send more than two bytes at a time. To
analyze efficiency with large block of data I used Raspberry Pi by simply loopback data to it. To
test it, I connected MOSI to MISO together to receive and measure the data which sent through
MOSI and it is received by MISO in Raspberry pi.
If i sent one byte at a time i can get back data at 11.16KB/s. What happen if we increase
data bytes for each transfer? Then i sent two bytes at a time the data transfer rate is increased to
37.63KB/s at 4MHz. Here I had noticed if we increase data block size the data throughput is
increased but still the data rate doesn't linearly increase with the clock speed. To find a better
efficiency i then increased data bytes to 100bytes in a single transfer which gives higher transfer
of 295.67KB/s. From this analysis i had noticed, if we are trying to send one byte or two
bytes(less number of bytes) at a time the delay between each transfer of byte is high so the data
throughput is slowing down and if we try to send large number of bytes the percentage of
efficiency is increased.

36
Below graph shows data transfer rate for 100bytes transfer at a time.
.
Figure 5.3 Graph for receiving data in Raspberry Pi
From the above graph you can see the data rate is double when double the clock speed.
While going to higher speed the data rate is reduced since the cpu usage at that speed is almost
full so my software can't able to measure accurately. So it is clear here if we try to send large
number of bytes per transfer the data throughput increase linearly with the clock speed.
And also I have measured the data throughput by scope,
bytes
Speed
1 byte 2 byte 100 bytes
(Time taken to transfer byte + delay between transfer)
500KHz 0.016+0.071 0.035+0.066 1.686+0.203
1MHz 0.009+0.065 0.017+0.065 0.850+0.103
2MHz 0.004+0.056 0.009+0.047 0.429+0.092
4MHz 0.002+0.052 0.004+0.042 0.269+0.084
8MHz -- 0.002+0.039 --
16Mhz -- 0.001+0.032 --
0
100
200
300
400
500
600
700
500 1000 2000 4000 8000 16000
DataTransferRateinKBytes/s
Clock Speed in KHz

37
For 500KHz time taken to transfer a byte is .016ms and time delay between each transfer is
0.071ms for a transfer it takes 0.87ms.
1second= 1000/0.87
= 11494.25x1(1byte per transfer)
= 11494.25bytes/s
= 11.22KB/s
At same 500KHz clock speed transferred 2bytes at a time it takes 0.035ms and time delay
between each transfer is 0.066ms for a transfer it takes 0.101ms.
1second = 1000/0.101
= 9900.99x2(2bytes per transfer)
= 19801.98bytes/s
= 19.22KB/s
Similarly for 100 bytes per transfer,
1second = 1000/1.889
= 529.38x100(100bytes per transfer)
= 52938.06bytes/s
= 51.69KB/s
Here with the kernel latency we had scale factor of 1:0.66(clock speed : data transfer rate)
when we transferring one byte at a time and for two bytes transfer scale factor is more or less
same around 0.6 continued here. If we transfer data without latency we can achieve scale factor
of 1:1.
What will happen if increase in clock speed? Will communication work? Yes raspberry
pi can able to receive data even up to 16MHz of SPI clock speed. The thing i observed is the data

38
which has been sent over 4MHz clock speed, arduino begins to skip bytes to send in a packet
which i stored in array of bytes. This kind of data missing is not tolerated in an embedded
system.
I also observed that missing of bytes in an array is not frequent, it skips bytes to send
randomly from the array. This is due to un-synchronization of clock speed with what arduino uno
can support. Here communication based on send and receive a byte at a time. There is no
acknowledgement of data and there is no way for request to resend the packet which fails to
receive packet with all bytes. At this stage i thought to retrieve the data which has been lost. By
means retrieving system can able to build the packet message of its own with the missing bytes.
Then i implemented Error detection and correction for incoming bytes. It also named as
ECC(Error Correcting Codes).
CPU Usage:
It is a important factor to measure to describe the capability of system to handle
communication between boards. It has been measured for both idle and working status of system.
Figure 5.4 CPU usage while IDLE

39
Figure 5.5 CPU usage while running
5.2 Implementation of Error Detection and Correction:
Reason to going for error detection and correction is, there is no acknowledgement for
incoming bytes communication in our system. So it is to ensure that we are receiving correct
bytes which has been sent by sender. One of the disadvantage of SPI protocol is, there is no
support for validation of incoming bytes. So we must write our software to include validate of
incoming bytes. Checksum calculation is a good idea for validate received bytes whether it have
any error in it. But it doesn't do error correction for error bytes. CRC32 is a technique to do error
detection and correction of incoming bytes[23][24].
This technique can be resolve from 1bit to burst bits in a packet. As mentioned above
raspberry pi can able to receive and process data at a time as it has enough RAM, so there will be
no slow in transmission. The disadvantage is from arduino, since arduino is a 8 bit
microcontroller it can able to send one byte at a time, so it's not possible to form a packet of 32
bits with 24bits of data and 8 bits of remainder. Otherwise we can do receive 4bytes one by one
and group to 32bits to do CRC32. But incase if a byte miss happens in between transfer it will
take a byte from next packet. This will go wrong frame of packet hence it very complex to
implement CRC32 in raspberry pi. For reconstructing entire packet it will take additional CPU
usage and may hang system for further communication.
I also noticed that CPU usage in raspberry pi is increasing if implementing CRC32
algorithm. To overcome drawback of CRC32 I implemented an efficient algorithm to detect error
in incoming packet.

40
Table 5.2 Format for Error detection with checksum
SOT COMMAND LENGTH DATA BYTES CHECKSUM EOT
In the above packet SOT is defined as value of a byte which is first byte in the packet,
secondly command byte describes what sensor value it is sending, thirdly length of the data bytes
and next byte is checksum XOR of (Command byte, Length, Data bytes) and finally EOT
describes last byte of packet frame. These process done in arduino before transmitting data bytes
from sensor it is framed as describe above. Reversely it is validated in raspberry pi. Hence this
logic overhead with frame bytes.
5.3 Implementation of Compression:
Limited size of RAM in arduino UNO will can only hold less amount of data before it
transferred to other board via SPI . It's better to build a library for arduino to compress data
before it transferred to raspberry pi. By compressing data we can get some memory space in
SRAM memory for additional data to hold. RLE(Run Length Encoding), Huffman code, gzlib
and Lempel-Ziv-Welch are considerable compression algorithms for byte compression. RLE
works if bytes are repeated in a packet message[25]. Huffman code each value is considered as
symbol and then transferred[26]. SPDR data register of SPI is 8 bits it's possible to send only a
byte at a time via SPI. Instead of sending byte by byte we look to build a library for byte
compression to reduce byte transfer in a packet.
Before going to implement compression library in arduino we must look at pre requisite
of header files. Header file for library function should be accepted by compiler in arduino IDE.
RLE doesn't need any pre defined function so it will be helpful only if bytes are repeated in a
packet. Complex issues will be resolved by implementing supportable header file for library
function.
For worst case complexity non repeated bytes will not give efficiency by using RLE
instead of that here i consider LZW which identifies repeated pattern of bytes[27] Eg: "36045792
and 20579214" underlined tells certain numbers are repeated in a way. Similarly it perform for
text also Eg: "Helloworld is simple word most used by beginner programmer. It may be lowor
high"

41
For number's it ranges 0-9, 100 combinations for two digit number
For Text A-Z, 676 combinations for two characters.
Total possible combinations will be kept in an array of table. Predefined combinations needs
more memory to save. But the advantage is very high, because it will take less time to compress
data. But in my system compression takes part in microcontroller. In my software design i kept
512bytes for combination array which means it will have combination only after read each
character until it fills my array table.
Eg: "LEFT EFFECT".
Table 5.3 Dictionary table for LZW algorithm
A-Z 0-25
LE 26
EF 27
FT 28
(EF-27)F 29
In my software maximum range of bits is 16, even for data between 0-15 bits. It will
utilize more number of bits for less digit value, when come to long range values it simplifies into
less number of digits to specify. I have also tested with various size of bits for my array table.
For 16 bit data range gave more compression ratio. Here results were tested in raspberry pi.
Since there is no option to check the compression output in arduino. As the data's are transferred
in bytes for communication here test is done for byte values. The input of speech recognizer
sensor will be taken as text. In testing for compression, the input of text also has been tested
here. For distance sensor the values are in co-ordinates values which has been measured from its
origin. For each position it will give numerical values which changes frequently so a random
number of integers are tested here.
"EF" is already in table so it will
read next character. EFF mapped
as 29

42
Figure 5.6 Flowchart for LZW compression algorithm
YES
NO
YES
NO
YESNO Is
STRING+CHAR
in table?
Input next byte store in CHAR
START
Input first byte store in STRING
Is table size >512?
more bytes to input?
output the code for
STRING
STRING = STRING + CHAR
add entry in table for
STRING+CHAR
STRING=CHAR
output the code for
STRING
END

43
Figure 5.7 Running compression for random integer and large text.
File
Content
Factors
Numbers Text Bytes(16bits) Float values
File size 22.07KB 50.82KB 48.29KB 49.02KB
Compressed File size 12.26KB 39.5KB 33.85KB 20.88KB
% compressed file size 55.55% 77.72% 70.09% 42.6%
Table 5.4 Compression results for various files.
In Arduino Uno it has 2KB of SRAM, algorithm array table acquires 512bytes and rest
will be for reading data's. If we are compressing a text file, it fetches around only 1500bytes of
data from the file. It will be very less for better compression ratio, this is a drawback i have faced
in testing. Even without compression system support to transfer of around 24KBytes per second.

44
 Raspberry pi(Master) and Arduino Due(Slave)
As mentioned above arduino Due has more advantage in terms of hardware than arduino
Uno. SPI clock speed and Transmit data register range was high and advantage to communicate
with raspberry pi. In this section i will discuss about configuring arduino Due as slave and
implementing SPI protocol. Both arduino Uno and Due has different microcontroller registers
and configuration are entirely different. Most of the library functions will not support on arduino
Due which was supported by arduino Uno.
Figure 5.8 Slave Mode Functional Block Diagram
To configure arduino Due as slave the following register's have to be coded.
 SPI_CR (SPI Control Register).
 SPI_MR (SPI Mode Register).
 SPI_RDR (SPI Read Data Register).
 SPI_TDR (SPI Transfer Data Register).
 SPI_SR (SPI Status Register).
 SPI_IER (SPI Interrupt Enable Register).
 SPI_CSR (SPI Control Status Register).
 SPI_WPMR (SPI Write Protection Mode Register).

45
To enable SPI interface in arduino Due SPIEN pin SPI_CR register should be set to 1.
31-25 24 23-8 7 6-2 1 0
- LASTXFER - SWRST - SPIDIS SPIEN
Source code:
REG_SPI0_CR=0x1;
To configure as slave MSTR bit in SPI_MR must set to '0'.
31-24 23-
20
19-
16
15-
8
7 6 5 4 3 2 1 0
DLYBCS - PCS - LLB - WDRBT MODFDIS - PCSDEC PS MSTR
Here data register to transmit and receive is different from Uno. For transmit SPI_TDR,
we should pass data to this register to send bytes and the offset should be 0x0C. For receive
SPI_RDR, this register will receive the incoming bytes and the offset should be 0x08.
SPI_TDR Register:
TD-Transfer Data will be transfer depends upon bits going to be received.
SPI_RDR Register:
31-20 19-16 15-0
- PCS RD
RD-Receive Data will be read depends upon bits transferred.
31-25 24 23-20 19-16 15-0
- LASTXFER - PCS TD

46
To configure how many bits will be transferred is set in SPI_CSR register. LSB 0&1 of
this 32bit register will tell about CPOL(Clock polarity) and NCPHA(Clock Phase) respectively.
SPI_CSR Register:
31-24 23-16 15-8 7-4 3 2 1 0
DLYBCT DLYBS SCBR BITS CSAAT CSNAAT NCPHA CPOL
From bit 4-7 is for transmit data bit range.
Table 5.5 Table for configuring BITS in SPI_CSR Register.
BITS 7-4 Name Description
0000 8_BIT 8 bits for transfer
0110 14BIT 14 bits for transfer
To enable WRITE mode for this register WPEN bit in the SPI_WPMR register should be
cleared. Even if we want run in default mode SPI_CSR register must be written. SPI_WPMR
register will tell about WRITE mode for pins. Status of SPI_WPMR can be checked in
SPI_WPSR(Write Protected Status Register).
SPI_WPMR register:
Above register are configured to act as slave and configuring 16bit transfer per
message[28]. As in general bye transfer is possible in SPI with SPDR register. In arduino Due
31-8 7-1 0
WPKEY - WPEN

47
has extended feature to send 16bits at a time by using parameter SPI_CONTINUE, it indicates
next bytes to be send in the packet. SPI_LAST tells which byte is last to be transfer. If we doesn't
specify SPI_LAST for a transfer, then it will consider as last byte in a packet. This logic helps to
frame 32bit transfer of 24bit data and 8bit remainder for implementing ECC code.
Source code:
short value[] = {0x8308, 0x0233};
SPI.transfer(MISO,value[i],SPI_CONTINUE);
SPI.transfer(MISO,value[i++],SPI_LAST);
Here it will transfer 16 bit data, because its configured to sent 16 bit transfer.
SPI_CONTINUE will transfer 16bit data from value array and SPI_LAST will send next byte. It
will shift MSB first in the data transmit register. So array of value first indicates 16bits of MSB
and in next transfer it will shift remaining 8bit with remainder 8bits. By doing this, clock cycle
between each packet will set Slave Select(SS) pin low up to transfer ends. So it resolve problem
for implementing CRC32 in communication which has been faced in arduino Uno.
To receive a 16bit data we need to configure SPI in raspberry pi to send 2 bytes at a time.
Below code will tells us how to configure 16bit transfer from raspberry pi.
Source code:
uin16_t tx = 0x7689;
transfer(fd,(tx>>8),tx,2);
CS(Chip select) have to be set active low until 16bits are transferred.
Before going to transmit next data we have to ensure that last written data in SPI_TDR
has been transferred. To ensure that we should check SPI_SR status register before each
transmit.
31-
17
16 15-
11
10 9 8 7-
4
3 2 1 0
- SPIENS - UNDES TXEMPTY NSSR - OVRES MODF TDRE RDRF

48
Source code:
int SR_8LSB = (int) ((REG_SPI0_SR & 0x00000002)>>1);
if(SR_8LSB)
{
REG_SPI0_TDR = data[i]; // Put data into data transmit register
}
And also we have to check for interrupt based communication in SPI_IER(Interrupt enable
Register). A bit set in TDRE pin defines whether to enable interrupt or not.
31-11 10 9 8 7-4 3 2 1 0
- UNDES TXEMPTY NSSR - OVESR MODF TDRE RDRF

49
5.4 Theoretical Result:
As of now Arduino DUE SAM3x8E of ATMEL microcontroller Interrupt Service
Routine(ISR) to enable SPI as slave has yet not been coded from the developer side[29][30][31].
Here i did mathematical result which tells the expected data transfer rate. In Arduino UNO able
to receive ~25.42KB/s at 4MHz clock speed with 8 bits transfer at time. In Arduino DUE clock
speed is increased to 16MHz which is four times of Arduino UNO and transfer bit range(size of
data) is increased to 16bits per transfer which is double from Arduino UNO. So, expected result
will be
Arduino Uno Arduino Due
Clock Speed(MHz) 4 16
Number of transfer bit range 8 16
Expected Data rate = 25.42*4*2
= 203.36 KBytes/sec
From Figure 5.1, the data transfer can continue beyond 4MHz in Arduino Uno but with
missing of data while transfer. By that performance we can expect more data throughput with
higher clock speed in Arduino Due.

50
5.5 Optimizing Boot time of Raspian Wheezy OS:
In general, Raspian Wheezy OS takes approximately 2minutes to boot up with full
features of a Linux system[32]. In our application, most of the programs can be muted to reduce
boot time of raspberry pi. The following steps will make raspberry pi to run our application
within 30seconds.
Step 1: Overclock clock speed of system. It can be done by configuring the raspian os.
Command: sudo raspi-config
Step 2: Configure Kernel file of
/boot/cmdline.txt
Replace these lines with the existing
dwc_otg.lpm_enable=0 root=/dev/mmcblk0p2 rootfstype=ext4
rootflags=commit=120,data=writeback elevator=deadline noatime nodiratime data=writeback
rootwait quiet
Step 3: Configure System file of
/etc/sysctl.conf
Add these lines to end of file
vm.dirty_background_ratio = 20
vm.dirty_expire_centisecs = 0
vm.dirty_ratio = 80
vm.dirty_writeback_centisecs = 1200
vm.overcommit_ratio = 2
vm.laptop_mode = 5
vm.swappiness = 10
After applying above changes run command from terminal to made changes effective.
Command: sudo reboot

51
Chapter 6 Summary
Conclusion:
Scope of this project is to build a compact system for robotic application with high speed
data transfer between Atmel microcontroller and raspberry pi. For high speed bandwidth
communication SPI has been chosen. Usual SPI based communication systems try to transfer
data with the clock speed, when exceeds clock speed the data transfer drops from that point. In
my work I have made my software to transfer data by implementing strategies like compression
and error correction and detection. It enables the system to push more with the maximum clock
speed. Usual microcontroller will do SPI communication between sensor's and microcontroller,
here sensor's data are collected and transferred to raspberry pi. In first case Arduino Uno is
configured as SPI slave with master raspberry pi, SPI communication has been established
between them and able to transfer data at a rate of ~25.5KBytes/sec maximum. With compare to
serial communication of 115200 bits/sec (14.06KBytes/sec) nearly data rate is doubled. With the
less amount of clock speed compared with raspberry, Arduino Uno has only 4MHz with 8bit at a
time transfer, the communication result is not achieved as expected. And with 2KB of SRAM is
not a proposed sensor node for future with high end sensor.
In second case Arduino Due is replaced for Arduino Uno, SPI communication has been
established between them and can able to transfer data. With the option of 8-16bits transfer at a
time doubles the data transfer bits for every transfer and with the 16MHz clock speed the data
throughput rate has been multiplied by four times of what Arduino Uno can, theoretically we can
receive around ~203.36KB/s. From the results of arduino Uno, we can find system
communication doesn't drop data transfer when exceeding maximum clock speed but with
drawback of data loss while transfer.
Since SPI doesn't has the support of error correction and detection here CRC32 has been
implemented for validating incoming bytes. At certain cases compression is required for repeated
kind of data from sensors. Instead of transmitting same values of data it is suggested to
implement to compression algorithm for data's. The compression part takes place in arduino
microcontroller and decompression takes place in raspberry pi.

52
Future works:
In my current work, Error detection and correction working fine up to 1bit error. To get
more performance ability of ECC it can be extended to 2bit or burst bit error correction in data. It
helps to reconstruct data when data corruption happen with multiple bit error in data while using
maximum clock speed. In data compression 512bytes of data library with 16bit resolution can be
increased to get increase in percentage of compression for data and it reduces the compression
time. Arduino due has more SRAM than arduino uno so we create more than 2KB of data
library with 32 bit resolution. It will increase the compression ratio. If we increase compression
ratio we can able to send more amount of sensor data. This compression helps a lot when sensors
are replaced with high resolution data bit sensors in future.
References:
1. Daode Zhang, Yourong pan and Xinyu Hu, "Design of High-Speed Parallel Data Interface
Based on ARM & FPGA", Journal of Computers, Vol. 7,No.3, March 2012.
2. John D. Wason and John T. Wen, " Robot Raconteur: A Communication Architecture and
Library for Robotic and Automation Systems", IEEE International Conference on
Automation Science and Engineering Trieste, Italy - August 24-27, 2011.
3. Motorola Inc., “SPI Block Guide V4.01”, July 2004.
4. F. Leens, “An Introduction to I2C and SPI Protocols”, IEEE Instrumentation & Measurement
magazine, pp 12-13, February 2009.
5. Design Note by Zoltan Monar, Using the SPI as High Speed , Bidirectional Data Bus With
Automatic Master/Slave Switch, 2002.
6. SPI Interface http://www.eeherald.com/section/design-guide/esmod12.html
7. Mingji Ban and Sung Ho Cho, “An Efficient Communication Method between Processors in
an Embedded Communication System”, International Conference on New Trends in
Information and Service Science 2009.
8. A.K.Oudjida, M.L. Berrandjia, A.Liachia, R.Tiar, K.Tahraoui & Y.N.Alhoumays, “Design
and Test of General-Purpose SPI Master/Slave IPS on OPB Bus"
9. Dimitrios N Serpanos, “Speeding Up High-Speed Protocol Processors”.
10. Raspberry Pi official website: http://www.raspberrypi.org/quick-start-guide

53
11. Guide for Raspberry Pi beginners http://elinux.org/RPi_Beginners#Beginner_Projects
12. Enabling SPI Interface http://www.hobbytronics.co.uk/raspberry-pi-raspbian-distro
13. Function access for broadcom BCM2835
http://www.airspayce.com/mikem/bcm2835/group__spi.html
14. Arduino UNO official website: http://arduino.cc/en/Main/ArduinoBoardUno
15. ATMEL 328P document: http://www.atmel.com/Images/8161s.pdf
16. Arduino DUE official website: http://arduino.cc/en/main/ArduinoBoardDue
17. Library code for Raspberry Pi to configure as SPI Master
https://github.com/WiringPi/WiringPi/blob/master/wiringPi/wiringPiSPI.c
18. SPI driver file for Raspberry Pi https://github.com/WiringPi/WiringPi/tree/master/wiringPi
19. SPI for Arduino http://www.gammon.com.au/forum/?id=10892
20. Raspberry Pi Model B IO pins http://www.raspberry-projects.com/pi/pi-hardware/model-b-
io-pins
21. Setup and use of SPI in Arduino Uno: http://www.atmel.com/images/doc2585.pdf
22. Arduino Due SPI Clock Divider http://arduino.cc/en/Reference/SPISetClockDivider
23. Wikipedia- Error detection and correction
http://en.wikipedia.org/wiki/Error_detection_and_correction
24. Explanation of Cyclic Redundancy check by Dave Janecek
http://www.csm.ornl.gov/~dunigan/crc.html
25. Wikipedia- Run length encoding http://en.wikipedia.org/wiki/Run-length_encoding
26. Wikipedia-Huffman coding http://en.wikipedia.org/wiki/Huffman_coding
27. Wikipedia- Lempel–Ziv–Welch
http://en.wikipedia.org/wiki/Lempel%E2%80%93Ziv%E2%80%93Welch
28. Configure SPI for 16 bit data transfer
http://www.raspberrypi.org/phpBB3/viewtopic.php?f=44&t=38830
29. SPI driver implementation file for SAM3X8E
https://github.com/phyrwork/nspi_arm/blob/master/nspi_arm.cpp
30. Arduino issue for Slave mode support https://github.com/arduino/Arduino/issues/965
31. Arduino DUE forum http://forum.arduino.cc/index.php/board,87.0.html
32. Start program before login
http://www.raspberrypi.org/phpBB3/viewtopic.php?f=31&t=31567

Thesis v06-13th jan

More Related Content

What's hot

Viewers also liked

Similar to Thesis v06-13th jan

Thesis v06-13th jan