Mnr. Henry Foulds
Mnr. Henry Foulds Pi car
Project 3 | AbstractThe purpose of this report is to give background information regarding IoT, Raspberry Pi, and Python as well as how these components were used to develop a system that would enable a user to control a RC car over a locally hosted website on any device with WiFi capability. The locally hosted website was created using HTML5 and CSS to format the layout of the website along with Javascript code to create and program buttons on the website. WebIOPi was used to convert the Javascript code to Python code to activate/deactivate the GPIO pins on the Raspberry Pi.
Ruaan Klem 23653000
ITRW 324 |

Pi car
Project 3 | AbstractThe purpose of this report is to give background information regarding IoT, Raspberry Pi, and Python as well as how these components were used to develop a system that would enable a user to control a RC car over a locally hosted website on any device with WiFi capability. The locally hosted website was created using HTML5 and CSS to format the layout of the website along with Javascript code to create and program buttons on the website. WebIOPi was used to convert the Javascript code to Python code to activate/deactivate the GPIO pins on the Raspberry Pi.
Ruaan Klem 23653000
ITRW 324 |

Table of Contents 1. Introduction 2 2. The Internet of Things (IoT) 2 3. Raspberry Pi (RPi) 3 4. Python 4 5. System Development Methodology (SDM) 5 6. Development 6 7. Testing 11 8. Implementation 12 9. Experimentation 14 10. Results and Discussion 14 11. Conclusion 16 Bibliography Appendix A 18 Appendix B 19

Table of Figures Figure 1: Raspberry Pi 2 Model B 3 Figure 2: Python example code 5 Figure 3: Prototyping SDM graphical representation 5 Figure 4: RC car used for Pi Car 6 Figure 5: L293D motor driver IC 7 Figure 6: "Bare bones" RC car 8 Figure 7: L293D Wiring diagram 9 Figure 8: Screenshot of website 10 Figure 9: Finished Pi Car 10 Figure 10: Testing GPIO pins setup 11 Figure 11: WiFi router used in system development 12 Figure 12: Device used for system testing and development 13 Figure 13: Non-external power supply wiring 15 Figure 14: Original wireless dongle 15

1. Introduction
The Internet of Things is a relatively new field in IT and has very many applications and in the system that was developed one of these applications was used to connect an RC car to the internet, using a Raspberry Pi with Python code on it, and control it using a WiFi capable device such as a smart phone or a laptop, The Internet of Things has functional uses to make a user’s life easier, but it has recreational uses as well and it was in this last field that this system fell. In the following paragraphs each component used in the development of the system will be discussed in detail, starting with The Internet of Things.
2. The Internet of Things (IoT)
The Internet of Things is defined as the network of physical objects or “things” embedded with electronics, software, sensors, and network connectivity, which enables these objects to collect and exchange data (Anon., 2012). The Internet of Things is in simplistic terms the connecting of a device that does not have network access to the internet. This could include, but is not limited to, a refrigerator or television, and through doing this a person could use the device that is now connected to the internet for other purposes that what it was used for before. For instance, a television could be connected to the internet so that it could be a smart TV whereas before it was only a normal TV that was used for normal everyday applications such as DSTV. The Internet of Things is a very hot topic in today’s IT environment, because it feels like the IT dream being able to link everything a person owns online so that you can use it anywhere, anytime.
The only problem with IoT is that, usually, it is not as simple as plugging the device to the internet and it works, you need an external device that gives the device the capability to connect to the internet. There is a couple of options for this goal for instance, Arduino, Intel Galileo, Beaglebone, and Raspberry Pi. The last one will be discussed in detail in the next paragraph.
3. Raspberry Pi (RPi)
Figure [ 1 ]: Raspberry Pi 2 Model B
Figure [ 1 ]: Raspberry Pi 2 Model B
The Raspberry Pi, as seen in figure 1, is a low cost, credit-card sized computer that plugs into a computer monitor or TV, and uses a standard keyboard and mouse (Anon., 2013a).
The Raspberry Pi is a multi-purpose, light-weight, powerful microcomputer that has the ability to perform any task that a user requires, permitted the user can program the solution to the problem. The RPi was developed by a United Kingdom based company, Raspberry Pi Foundation in 2006. The main idea for an affordable and tiny computer was thought up by four individuals, Eben Upton, Rob Mullins, Jack Lang and Alan Mycroft, who all worked at the University of Cambridge (Anon., 2013b). Their main motivation was the lack of skill that they saw in students applying for Computer Science degrees and they then thought that an affordable, tiny computer would make a difference (Anon., 2013b). By 2008, processors that were being used for mobile devices were becoming increasingly more affordable, as well as becoming much more powerful than previous years’ (Anon., 2013b). This all paved the way for a small affordable computer, but unknowingly also created the new and exciting field of IoT.
The RPi uses languages such as Python and Scratch which are powerful, but at the same time simple so as to make it possible for a beginner or novice to become proficient in these languages very quickly. Python specifically is what is most commonly used on RPi’s around the world, because of various reason which will be discussed in the next paragraph.
4. Python
Python was developed in the late 1980s by a Dutch Computer Scientist named Guido van Rossum (Klein, 2011). To discuss the idea behind the development of Python one first has to discuss the programming language ABC and the Amoeba project developed at CWI. The ABC language is an interactive programming language and environment for personal computing, originally intended as a good replacement for BASIC (Pemberton, 2012). The Amoeba Project is a distributed project on distributed operating systems (Mullender, 1986). The idea behind the development for Python was to create a scripting language with syntax like the ABC language, but with the capability to to access the Amoeba system calls (Lutz, 1996:23). Van Rossum’s idea behind Python was to make his, and by extension the other developers, life easy when it came to developing the Amoeba project and this later on had much more of an impact to the rest of the programming community than he had originally suspected (Venners, 2003).
Now as to why Python is used on RPi. Python is a powerful programming language that’s easy to use ,as seen in figure 2, (easy to read and write) and with the RPi lets you connect your project to the real world (Anon., 2013c). Python makes it easy for the user to access all the features that are provided with the RPi without having to have extensive knowledge in programming. Python makes it possible for a user to, for instance, create a website that can be hosted by the RPi or to use the GPIO (General-purpose input/output) that are present on the RPi.

Figure [ 2 ]: Python example code
Figure [ 2 ]: Python example code

In the following paragraph the system development methodology that was used to develop the system will be discussed.
5. System Development Methodology (SDM)
A system development methodology refers to the framework that is used to structure, plan, and control the process of developing an information system (Anon., 2008). The system development methodology that was used in the development of this system is RAD (Rapid Application Development), but Prototyping as seen in figure 3 was used to develop individual portions of the system.

Figure [ 3 ]: Prototyping SDM graphical representation
Figure [ 3 ]: Prototyping SDM graphical representation

This SDM was chosen because of its’ ability to create a quick implementation even though this implementation is incomplete. This made it possible for the developer to see what progress had been made without having to try and create a fully functioning application every time, this made it possible to find problems and address them individually without having to waste time on trying to solve all of the complications at once.
In the next paragraph the development of the system will be discussed.
6. Development
The system was developed using the aforementioned SDM, but the actual development of the system was done using different sources to create a system that solves the specific problem that was posed that is discussed in the introduction. The idea of the system was to create a remote control (RC) car that could be remotely controlled over the internet using a WiFi capable device such as a smart phone or laptop. This is in essence exactly the point of the IoT movement, but this specific application was more for entertainment than actually a real world function to make a user’s life easier.
Figure [ 4 ]: RC car used for Pi Car
Figure [ 4 ]: RC car used for Pi Car
This system was developed using a number of different components to solve the unique problems that arose during the development of the system. The first, and probably most important component was the Raspberry Pi. The Raspberry Pi 2 Model B was chosen as the microcontroller that would give the RC car access to the network/internet. The second important component was the RC car as seen in figure 4, there were a couple of complications when it came to this component as different RC cars work using different technologies as well as different DC motors, but this will be discussed in detail later on in this report.
The third component was a L293D, as seen in figure 5, motor driver IC (Integrated Circuit). This was used, with an external power supply to supply the DC motors with power as well as to dictate in which direction they would move. The other components used in the development of the system will be discussed as they were used in the development process.
Figure [ 5 ]: L293D motor driver IC
Figure [ 5 ]: L293D motor driver IC

The first step in the development process was to program the RPi so that it would be able to host a website that different devices would be able to connect to. This was done using Raspbian as the operating system on the RPi, and WebIOPi, which is software that translates Javascript running on buttons on a HTML website to Python code, that activates and deactivates the GPIO pins on the RPi so that the GPIO pins would power the L293D through its’ input pins and allow the it to send power, from the external power supply, to the DC motors, to allow the RC car to move. The programming of this was made difficult as WebIOPi was originally intended to be used on the Raspberry Pi 1 Model A, which only has 26 GPIO pins, and could not just be installed on the Raspberry Pi 2 Model B, which has 40 GPIO pins, so the developer had to modify certain aspects of WebIOPi to allow it to use all the GPIO pins on this specific RPi model (See appendix A).
The second step in the development process was to remove all the unnecessary parts from the RC car to be able to get to the DC motors and be able to connect them to the RPi, using the L293D as the controller. The outside body and any other esthetical parts were removed using screw drivers until all that was left was the “bare bones” of the RC car, as seen in figure 6. The wires of the external power supply as well as the DC motors were then extended using a soldering iron and some spare CAT5 network cable to be able to connect these components to the breadboard and L293D.
Figure [ 6 ]: "Bare bones" RC car
Figure [ 6 ]: "Bare bones" RC car

The third step was to connect everything to the breadboard and to the RPi. This was not difficult at all as the L293D came with a datasheet that explained in detail what each pin on the IC does and how to connect it to a microcontroller, as seen in figure 7, and to a DC motor. WebIOPi came with detailed instructions on how to connect LED lights to GPIO pins on the RPi, and this was just adapted to be used with the L293D and DC motors.
Figure [ 7 ]: L293D Wiring diagram
Figure [ 7 ]: L293D Wiring diagram

The fourth step was to create an HTML website (See Appendix B) that would be hosted by the RPi and would be used to control the DC motors. This was done using Notepad++ and testing it on the RPi, because WebIOPi cannot host a website on a Windows machine and this made it difficult for the developer to test it on anything else than the RPi. The website was supposed to be esthetically pleasing but functional at the same time, as seen in figure 8, so the developer used CSS code to make the website look a certain way (See Appendix B). After the website was developed and deployed on the RPi the developer had to create the Javascript (See Appendix B) that would be used to press buttons on the website hosted by the RPi. This was done in Notepad++ as well because it was the simplest option to pursue.

Figure [ 8 ]: Screenshot of website
Figure [ 8 ]: Screenshot of website

The final assembly of the RPi (hereafter the Pi Car) can be seen in figure 9, the only component that was used in the development process that was not mentioned is the power bank that was used to power the Pi Car without it having to be plugged into a wall socket, which would limit its’ mobility greatly.

Figure [ 9 ]: Finished Pi Car
Figure [ 9 ]: Finished Pi Car

In the next paragraph the testing of the system will be discussed.
7. Testing
The system was tested using a wide range of devices as well as using multiple WiFi routers or Ethernet cables. This was done so that the developer could make sure that the Pi Car would work on most devices as well as being able to connect to any WiFi that the user would want to use.
The GPIO pins were first tested using Python code that was written on the Pi Car to ensure that the GPIO pins were working and that if something were wrong the developer would be able to pin point the problem to whether or not it was a software or hardware related problem.
Figure [ 10 ]: Testing GPIO pins setup
Figure [ 10 ]: Testing GPIO pins setup
The GPIO pin activation/deactivation using the website buttons and Javascript were tested using LED lights connected to the breadboard and the Pi Car with a 1kΩ resistor, as seen in figure 10, to protect the Pi Car’s GPIO pins.
All of the testing was done with the Raspberry Pi and power bank that would be used for the system as well as a black rubber mat to ensure the Raspberry Pi would not be directly grounded in possibly short-out.
Once all the testing was done the entire system was assembled and readied for the implementation phase of the system development.
8. Implementation
The system was implemented using all of the components developed in the development process, all of these components were connected, as seen in figure 9, to the Pi Car and the Pi Car was powered up. When the Pi Car was powered up it was connected to a WiFi router, as seen in figure 11, using a WiFI dongle plugged into the Pi Car.
Figure [ 11 ]: WiFi router used in system development
Figure [ 11 ]: WiFi router used in system development

When the Pi Car was connected to the WiFi, WebIOPi was started which would host the website locally using the Pi Car’s IP address on the WiFi router as the websites’ URL. After all of this was done a device, as seen in figure 12, was also connected to the WiFi router and using a web browser, such as Google Chrome, the device was used to navigate to the website that was currently being hosted by the Pi Car.
Figure [ 12 ]: Device used for system testing and development
Figure [ 12 ]: Device used for system testing and development

The connected device would then be able to control the Pi Car using the buttons on the website which would then call the Javascript on the webserver which would in turn make WebIOPi translate this to Python code to activate/deactivate the GPIO pins.
Once the implementation phase was completed and the Pi Car functioned as required the developer could then start experimenting with extra features of the Pi Car to make it better or rather perform extra functions.
9. Experimentation
Once the implementation was completed the developer tried to connect different devices to the Pi Car to create a more “likeable”, sadly none of these devices worked as expected and instead of adding to the system, they subtracted from it.
The first concept the developer tried was to add LED’s to the Pi Car to indicate whether it was going forward, backward, left or right. The LED’s, however, could not be protected from the effects of the magnetic field that was destroyed once the DC motors would stop, and this field burnt more than ten LED’s out before the developer abandoned the idea all together.
The other concept the developer tried was to add a small speaker to the Pi Car so that it would beep if was going backwards. The speaker could, however, also not work with the magnetic field that was being generated and destroyed by the DC motors, so this idea had to be abandoned as well.
In the next paragraph the results of the system will be discussed.
10. Results and Discussion
The results of the system were positive, in general. The Pi Car functioned very well under the circumstances. There were a few problems that, given current knowledge, could have been prevented or avoided all together.
One of the first problems was the RC car that was used as the base for the Pi Car. The RC car used 6.6V DC motors and the Pi Car could only provide 5V to the DC motors, which meant that an external power supply had to be used to power the DC motors. This meant, however, that the L293D motor driver IC had to be used, because the original idea used a different wiring configuration, as seen in figure 13, that did not allow for an external power supply to be connected. This meant that the L293D had to be purchased from a company that was not easily accessible to the developer which created complications towards the end of the system development.

Figure [ 13 ]: Non-external power supply wiring
Figure [ 13 ]: Non-external power supply wiring

Another problem was wireless access from the Pi Car to a router. The original WiFi adapter, as seen in figure 14, that was to be used is not compatible with Linux, and accordingly not compatible with Raspbian. This created difficulties as well, but could be circumvented by simply using an Ethernet cable connected to the Pi Car and the router.
Figure [ 14 ]: Original wireless dongle
Figure [ 14 ]: Original wireless dongle

The final result of the Pi Car is, in spite of the problems, still a success. The Pi Car functioned exactly as expected and required and therefor the result is good. In the next paragraph the conclusion will be discussed.
11. Conclusion
The final conclusion of the developed system is that it worked, however there is room for much improvement, as well as problem solving that could take place actually before it becomes a problem.
The main problem with the Pi Car is that the main objective was to create a system that makes use of a web service to complete a certain function, and unfortunately the Pi Car did not comply to this requirement fully. It was very close but did not completely perform this function even though it did work perfectly it should have been developed using different services.
In conclusion the Pi Car was a fun system to develop and the developer would gladly do it again.

Bibliography
Anon. 2008. Selecting a development approach. https://www.cms.gov/research-statistics-data-and-systems/cms-information-technology/xlc/downloads/selectingdevelopmentapproach.pdf Date of access: 20 October 2015
Anon. 2012. ITU-T Y: http://www.itu.int/en/ITU-T/gsi/iot/Pages/default.aspx Date of access: 19 October 2015.
Anon. 2013a. Raspberry Pi Foundation: What is a raspberry pi? https://www.raspberrypi.org/help/what-is-a-raspberry-pi/ Date of access: 20 October 2015
Anon. 2013b. Raspberry Pi Foundation: About. https://www.raspberrypi.org/about/ Date of access: 20 October 2015.
Anon. 2013c. Raspberry Pi Foundation: Python. https://www.raspberrypi.org/documentation/usage/python/ Date of access: 20 October 2015.
Klein, B. 2011. Python3 history and philosophy. http://www.python-course.eu/python3_history_and_philosophy.php Date of access: 20 October 2015
Lutz, M. 1996. Programming Python. Sebastopol, CA: O'Reilly.
Mullender, S.J. 1986. The Amoeba distributed operating system, Part 2. CWI Quarterly, 12(3):15-23.
Pemberton, S. 2012. The ABC programming language: a short introduction. http://homepages.cwi.nl/~steven/abc/ Date of access: 20 October 2015.
Venners, B. 2003. The making of Python. http://www.artima.com/intv/pythonP.html Date of access: 20 October 2015
Appendix A cpuinfo.c file to be edited
#include <stdio.h>
#include <string.h>
#include "cpuinfo.h"

char *get_cpuinfo_revision(char *revision)
{
FILE *fp; char buffer[1024]; char hardware[1024]; int rpi_found = 0; if ((fp = fopen("/proc/cpuinfo", "r")) == NULL) return 0; while(!feof(fp)) { fgets(buffer, sizeof(buffer) , fp); sscanf(buffer, "Hardware : %s", hardware); if (strcmp(hardware, "BCM2709") == 0) rpi_found = 1; else if (strcmp(hardware, "BCM2709") == 0) rpi_found = 1; sscanf(buffer, "Revision : %s", revision); }
{…}

gpio.c file to be edited

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <time.h>
#include <pthread.h>
#include "gpio.h"
#include "cpuinfo.h"

#define BCM2708_PERI_BASE 0x3f000000
#define BCM2708_GPIO_BASE (BCM2708_PERI_BASE + 0x200000)
#define BCM2709_PERI_BASE 0x3F000000
#define BCM2709_GPIO_BASE (BCM2709_PERI_BASE + 0x200000)
#define PULLUPDNCLK_OFFSET 38 // 0x0098 / 4

{…} 1. python/native/cpuinfo.c,change "BCM2708" to "BCM2709"; 2. python/native/gpio.c, change "#define BCM2708_PERI_BASE 0x20000000" to "#define BCM2708_PERI_BASE 0x3f000000"; 3. run setup.sh again.
Appendix B
HTML Website:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <meta name="mobile-web-app-capable" content="yes"> <meta name="viewport" content = "height = device-height, width = device-width, user-scalable = no" /> <title>Pi Car</title> <script type="text/javascript" src="/webiopi.js"></script> <script type="text/javascript" src="/scripts/bacon.js"></script> <link rel="stylesheet" type="text/css" href="/styles/bacon.css"> <link rel="shortcut icon" sizes="196x196" href="/img/LED-icon.png" />
</head>
<body> </br> <div id="forward" align="center"></div> <div id="left" style="position: absolute; left: 0; top: 1"></div> <div id="right" style="position: absolute; right: 0; top: 1"></div> </br> <div id="back" align="center"></div> </br> <p align="center">Race to receive BACON!!!</p> </br>
</body>
</html>

CSS Code: body {background-color:#000000; background-image:url('/img/LED-icon.png'); background-repeat:no-repeat; background-position:center; background-size:cover; font: bold 18px/25px Arial, sans-serif; color:LightGray; } button {display: block; position: relative; margin: 10px; padding: 0 10px; text-align: center; text-decoration: none; width: 130px; height: 40px; font: bold 18px/25px Arial, sans-serif; color: black; text-shadow: 1px 1px 1px rgba(255,255,255, .22); -webkit-border-radius: 30px; -moz-border-radius: 30px; border-radius: 30px;
-webkit-box-shadow: 1px 1px 1px rgba(0,0,0, .29), inset 1px 1px 1px rgba(255,255,255, .44);
-moz-box-shadow: 1px 1px 1px rgba(0,0,0, .29), inset 1px 1px 1px rgba(255,255,255, .44); box-shadow: 1px 1px 1px rgba(0,0,0, .29), inset 1px 1px 1px rgba(255,255,255, .44);
-webkit-transition: all 0.15s ease;
-moz-transition: all 0.15s ease;
-o-transition: all 0.15s ease;
-ms-transition: all 0.15s ease; transition: all 0.15s ease;} input[type="range"] {display: block; width: 160px; height: 45px;} #gpio17.LOW {background-color: Gray; color: Black;} #gpio17.HIGH {background-color: Purple; color: LightGray;} #gpio18.LOW {background-color: Gray; color: Black;} #gpio18.HIGH {background-color: Blue; color: LightGray;} #gpio22.LOW {background-color: Gray; color: Black;} #gpio22.HIGH {background-color: Green; color: LightGray;} #gpio23.LOW {background-color: Gray; color: Black;} #gpio23.HIGH {background-color: Yellow; color: LightGray;} #gpio24.LOW {background-color: Gray; color: Black;} #gpio24.HIGH {background-color: Red; color: LightGray;}

Javascript code: webiopi().ready(function() { webiopi().setFunction(17,"out"); webiopi().setFunction(18,"out"); webiopi().setFunction(22,"out"); webiopi().setFunction(23,"out"); var Forward, button; var Backward, button; var Left, button; var Right, button; Forward = $("#forward"); Backward = $("#back"); Left = $("#left"); Right = $("#right"); button = webiopi().createGPIOButton(17,"Forward"); Forward.append(button); button = webiopi().createGPIOButton(18,"Backward"); Backward.append(button); button = webiopi().createGPIOButton(22,"Left"); Left.append(button); button = webiopi().createGPIOButton(23,"Right"); Right.append(button); });