FINAL INDIVIDUAL

The Design of a Raspberry Pi
Based Temperature Sensor
By
William Duncan
This project is submitted as partial fulfilment for the Honours degree of
Bachelor of Engineering in
Product Design and Development
At the University of the West of Scotland
School of Engineering,
University of the West of Scotland, ___________________
High Street, William Duncan
Paisley, B00207244
PA1 2BE 27th
April 2015

i
Acknowledgements
I would firstly like to thank Dr James Thompson for his help and for supplying me with the
materials required for this project despite his busy schedule.
Secondly, I’d like to thank Robert Boyce and the technicians of the School of Engineering for
their unparalleled help and assistance throughout the year with this and my group project.
Thirdly, thanks to Tom Caddell for his knowledge and guidance in all things technical
whenever I was stuck.
Next, to the online community who have supported – not only my project – but projects on a
global scale on a daily basis; with expert knowledge and critical feedback.
Lastly, to my wee maw, family, and the troops who have supported me throughout the past five
years despite by bumpy journey.

ii
Abstract
Product Design is a significant part of technology; it is one of the key steps in many to create
a brand new product. In its purest form; product design can be the answer to a flaw which
requires redesigning, or it could just be an advanced idea that has the potential to either succeed
or supersede its predecessor.
Technology in general is innovating and expanding at an exponential rate. Our pockets are
emptier, but the few items inside them can now do more than ever. Storage devices are
significantly smaller, but they hold massive amounts of data. Current mobile phones on the
market are no longer just phones anymore; they are portable computers which integrate media
players, web browsers and instant messengers. Personal computers have evolved to laptops,
which themselves have been innovated and developed into touch screen tablets, all within the
past 15 years.
This paper focuses on the design process of a new iteration of a product, a temperature sensor,
with the incorporation of a 21st
century innovation in technology – the Raspberry Pi. Detailed
accounts of the steps taken to configure the software, testing, hardware creation, and possible
next steps will be identified and discussed throughout. The outcome of this dissertation is to
construct a circuit, a suitable casing for the packaging of the device and screen, and then to
prototype the design.

iii
Copyright
“The copyright of this dissertation rests with the author. No quotation from it should be
published without his prior written consent and information derived from it should be
acknowledged.”

iv
Table of Contents
Acknowledgements.....................................................................................................................i
Abstract......................................................................................................................................ii
Copyright ................................................................................................................................. iii
Table of Contents......................................................................................................................iv
Nomenclature......................................................................................................................... viii
List of Figures...........................................................................................................................ix
List of Tables ............................................................................................................................xi
1. Introduction............................................................................................................................1
1.1 Background and Context..................................................................................................2
1.2 Scope and Objectives.......................................................................................................3
1.3 Achievements...................................................................................................................4
1.4 Overview of Dissertation.................................................................................................4
2. Literature Review and Similar Projects .................................................................................6
2.1 What is the Raspberry Pi?................................................................................................6
2.1.1 History of the Raspberry Pi.......................................................................................6
2.1.2 Hardware and Specifications ....................................................................................6
2.1.2.1 GPIO ..................................................................................................................7
2.1.2.2 RAM, CPU and GPU.........................................................................................7
2.1.2.3 Video Outputs....................................................................................................8
2.1.2.4 Power .................................................................................................................8
2.1.2.5 LEDs ..................................................................................................................8
2.1.2.6 USB and LAN....................................................................................................8
2.1.2.7 SD Card..............................................................................................................9
2.1.3 Operating System......................................................................................................9
2.2 Similar Projects..............................................................................................................10
2.2.1 A Simple Temperature Sensor................................................................................10

v
2.2.2 Adafruit DHT Humidity Sensing............................................................................11
2.2.3 Raspberry Pi Temperature Sensor with LCD Display, Temperature Sensor and
Receiver ...........................................................................................................................12
3. Methodology........................................................................................................................14
3.1 Planning .........................................................................................................................14
3.2 Setting up the Raspberry Pi............................................................................................15
3.2.1 Installation...............................................................................................................15
3.2.2 WiFi and VNC........................................................................................................15
3.3 Obtaining First Temperature Readings..........................................................................17
3.3.1 DHT11 Sensor ........................................................................................................17
3.3.2 Understanding the GPIO.........................................................................................18
3.3.3 Code for First Temperature Reading ......................................................................19
3.3.3.1 Relative Humidity............................................................................................21
3.3.3.2 Relative Temperature.......................................................................................22
3.4 Display...........................................................................................................................22
3.4.1 Display Size ............................................................................................................22
3.4.2 MyPiFi LCD Add-on Board ...................................................................................22
3.4.3 Soldering.................................................................................................................23
3.5 Temperature Sensor and Display Software....................................................................26
3.5.1 DHT11 Temperature Sensor and Data Logging .....................................................26
3.5.2 Display....................................................................................................................27
3.5.3 Start-up Script.........................................................................................................28
3.6 Online Data Logging......................................................................................................29
3.6.1 PrivateEyePi............................................................................................................29
3.6.2 Twitter.....................................................................................................................32
4. Testing..................................................................................................................................36
4.1 Cooling Test...................................................................................................................36

vi
4.2 Heating Test...................................................................................................................37
5. Case Design .........................................................................................................................39
5.1 Concept and Influence ...................................................................................................39
5.2 3D Modelling.................................................................................................................41
5.3 Part Drawings.................................................................................................................44
5.4 Rapid Prototyping..........................................................................................................44
5.4.1 Advantages of Rapid Prototyping...........................................................................44
5.4.2 3D Printing..............................................................................................................45
5.5 Case Revision 2.0...........................................................................................................47
5.6 Cost ................................................................................................................................48
5.7 Manufacture...................................................................................................................49
5. Reflection.............................................................................................................................51
5.1 Programming and Testing..............................................................................................51
5.2 Case Design ...................................................................................................................53
6. Conclusion ...........................................................................................................................54
6.1 Recommendations for Future Work...............................................................................54
6.1.1 Battery Power Source .............................................................................................54
6.1.2 3G/4G WiFi Connection.........................................................................................55
6.1.3 Possible Manufacture for Sale ................................................................................55
6.1.4 Improving the Sensor Design..................................................................................55
Bibliography ............................................................................................................................56
Appendix 1 – Code ..................................................................................................................65
dht11.c..................................................................................................................................65
gpio_oi.c...............................................................................................................................72
Makefile...............................................................................................................................77
minmax.awk.........................................................................................................................78
savetemp.c............................................................................................................................79

vii
timed_wait.c.........................................................................................................................80
tempsense.............................................................................................................................82
displaytempsense.py ............................................................................................................83
tweettempsense.py ...............................................................................................................85
Appendix 2 – Test Data ...........................................................................................................87
Cooling Test.........................................................................................................................87
Heating Test.........................................................................................................................88
Appendix 3 – Drawings ...........................................................................................................89

viii
Nomenclature
GPIO = General Purpose Input / Output LAN = Ethernet
LCD = Liquid Crystal Display OS = Operating System
UK = United Kingdom PCB = Printed Circuit Board
PHD = Doctorate of Philosophy TFT = Thin-film-transistor
Pi = Raspberry Pi RF = Radio Frequency
TV = Television MB/sec = Megabytes per second
HD = High Definition GUI = Graphical User Interface
£ = Pounds Sterling IP = Internet Protocol
3D = Three-dimensional V = Volts
USB = Universal Serial Bus % = Percentage
Python =
Python Programming
Language
mA = Milliamps
C = C Programming Language Hz = Herts
SD = Secure Digital Mm = Millimetre
VNC = Virtual Network Computing K = Kilo
Creo = PTC Creo GND = Ground
CPU = Central Processing Unit VCC = Power Supply
RAM = Random Access Memory °C = Degrees Celsius
SoC = System-on-chip UWS =
The University of the West of
Scotland
MB = Megabyte Dr = Doctor
GB = Gigabyte STL = Stereolithography
RCA = Radio Corporation of America CAD = Computer Aided Design
HDMI =
High Definition Multimedia
Interface
CAM = Computer Aided Manufacture
LED = Light Emitting Diode 3G/4G = 3rd
/4th
Generation
API =
Application Programming
interface

ix
List of Figures
Figure 1 – The BeetBox (Scott Garner, 2013)...........................................................................2
Figure 2 – Media Centre (Adam Shepherd, 2015).....................................................................3
Figure 3 – Model B (vividvilla, 2013).......................................................................................7
Figure 4 – Simple Temperature Sensor (Horan, 2013, p. 49 & 53).........................................10
Figure 5 – Adafruit DHT Humidity Sensing (Ada, 2015, p. 5 & 6)........................................11
Figure 6 – Pi, TFT, RF and Temperature Sensor (Williams, 2013) ........................................13
Figure 7 – Gantt Chart .............................................................................................................14
Figure 8 – 8GB Micro-SD .......................................................................................................15
Figure 9 – Edimax WiFi Adapter.............................................................................................16
Figure 10 – VNC in Action......................................................................................................16
Figure 11 – DHT11 Sensor......................................................................................................17
Figure 12 – GPIO Pin Layout (Ziegelwanger, 2013) ..............................................................18
Figure 13 – DHT11 in GPIO ...................................................................................................19
Figure 14 – DHTlib Example ..................................................................................................21
Figure 15 – LCD Sizes.............................................................................................................22
Figure 16 – MyPiFi Board Kit (MyPiFi, 2014) .......................................................................23
Figure 17 – Soldering Kit (Google, 2015)...............................................................................24
Figure 18 – Soldering Snapshot...............................................................................................24
Figure 19 – Completed Soldering............................................................................................25
Figure 20 – Soldering Check ...................................................................................................25
Figure 21 – Working Display ..................................................................................................29
Figure 22 – DHT22 Sensor......................................................................................................29
Figure 23 – DHT22 Snapshot ..................................................................................................31
Figure 24 - PrivateEyePi..........................................................................................................32
Figure 25 - @UWS_Pi Twitter................................................................................................33
Figure 26 – Tweet Test ............................................................................................................34
Figure 27 – Twitter Temperature Tweets ................................................................................34
Figure 28 – Cooling Test .........................................................................................................36
Figure 29 – Cooling Graph ......................................................................................................37
Figure 30 – Heating Test..........................................................................................................37
Figure 31 – Heating Graph ......................................................................................................38
Figure 32 – Adafruit Case (Humpries, 2012) ..........................................................................39

x
Figure 33 – Bramble LCD Case (bitcrafts, 2015)....................................................................40
Figure 34 – Conceptual Sketch................................................................................................40
Figure 35 – Raspberry Pi Creo Model .....................................................................................41
Figure 36 – Component Modelling..........................................................................................42
Figure 37 – Component Assembly ..........................................................................................42
Figure 38 – Reference Modelling ............................................................................................43
Figure 39 – Case Modelling.....................................................................................................43
Figure 40 – Case Component Assembly..................................................................................44
Figure 41 – SLT Part................................................................................................................45
Figure 42 – 3D Printer .............................................................................................................46
Figure 43 – Printing Configuration..........................................................................................46
Figure 44 – Full Working Assembly .......................................................................................47
Figure 45 – Corrupt Display ....................................................................................................51
Figure 46 – Case Bottom Drawing ..........................................................................................89
Figure 47 – Case Top Drawing................................................................................................90
Figure 48 – Case Side 1 Drawing ............................................................................................91
Figure 52 – Component Assembly Drawing ...........................................................................95
Figure 53 – Case Assembly Drawing ......................................................................................96
Figure 54 – Complete Assembly Drawing...............................................................................97
Figure 55 – Case Bottom (Revision 2.0) Drawing ..................................................................98
Figure 56 – Exploded Assembly..............................................................................................99

xi
List of Tables
Table 1 – Cost of Prototype .....................................................................................................48
Table 2 – Cooling Test Data ....................................................................................................87
Table 3 – Heating Test Data ....................................................................................................88

1
1. Introduction
The introduction provides the outline of scope and context of the project titled “Raspberry Pi
Based Temperature Sensor Design”.
Dr James Thompson, a senior lecturer within the School of Engineering, proposed this project.
The successful development of this venture will enable a Raspberry Pi to control a temperature
sensor with the inclusion of a screen display to highlight the surrounding temperature. The
Raspberry Pi required various software packages and Python modules to be installed for the
Raspbian Wheezy operating system to allow interactions with the GPIO utilised devices.
Through a simplistic design, the project aims to develop the Raspberry Pi to a state which
allows anyone to power up the Raspberry Pi with no commands or input required to generate
a temperature reading. Ideally the final device will allow the user to record the temperature
readings obtained either through an internal text log or transmission to an online source (if
connected wirelessly to a network connection).
Initially intended to be a group assignment, the project undertaken is to develop a temperature
sensor using a new 21st
century computing innovation, the Raspberry Pi microcomputer. With
the model utilised in this project (Model B) having been released on the 5th
September 2012
(Raspberry Pi Foundation, 2012), research was conducted on: the device, supplied and required
hardware (to ensure there were no compatibility issues), the operating system, the software
available which would allow the device to interact with the sensor(s), and interaction with the
GPIO (General Purpose Input / Output) pins.
The GPIO on the Raspberry Pi is a collection of small pins which allows instruments and tools
to be attached and controlled. The operating system can detect and be configured for either
input or output; with this assignment making use of this to allow DHT temperature sensor(s)
to provide data to the Pi whilst also employing a LCD display to present updated figures using
the GPIO pins – however there are many more devices and tools that exist.

2
1.1 Background and Context
Since it was first announced; the Raspberry Pi has received a lot of attention, becoming
“the fastest-selling British computer” (Raspberry Pi Foundation, 2015) with 5 million
units sold worldwide as of February 2015.
The concept of the Raspberry Pi was a brainchild of a UK based team – from the
University of Cambridge’s Computer Laboratory – concerned with the decline in the
number and skills of students applying for Computer Science degrees, during the course
of their PHD (Eben Upton, 2014, pp. 1 - 3).
Figure 1 – The BeetBox (Scott Garner, 2013)
Since its inception, a vast amount of people – ranging from complete novices to
technology enthusiasts – have obtained Pi’s to program, control, and create various
projects.
These inventions span from wacky designs such as “The BeetBox” (an interactive drum
kit made of vegetables via a capacitive touch sensor that connects to a Raspberry Pi,
which sends signals to an amp inside a handmade wooden case – as seen in Figure 1 –
The BeetBox to practical ideas such as a Media Centre for a TV (which plays HD video
content and streams online services such as Netflix – highlighted in Figure 2 – Media
Centre .

3
Figure 2 – Media Centre (Adam Shepherd, 2015)
Basic temperature sensors with displays on the current market can cost between £10 to
upwards of £100 (Ebay, 2015), with the inclusion of a data log increasing the cost of
the unit to between £30 to £300 (LS Technology, 2015).
This project makes use of the Raspberry Pi Model B – retailing at £25 as of January
2015 (Allied Electronics, 2015) – and a small number of accessories which includes:
temperature sensor(s), an LCD display (including a MyPiFi LCD board kit) and a USB
Wi-Fi connection, all of which can be purchased for under £25 to turn the Raspberry Pi
into a temperature sensor capable of reading and displaying the current temperature and
recording the data obtained in real time. This design will be encased in a 3D printed
rapidly prototyped suitable casing.
In comparison to a typical digital temperature sensor; the Raspberry Pi has the option
of using different types of sensors and connection methods. The Raspberry Pi also
contains functionality to log data for future reference and performance of actions based
on data readings. This could be useful for monitoring the temperature of a space, for
example, a room filled with computers servers that may have to be observed for rises
in temperature to prevent overheating and potential damage.
1.2 Scope and Objectives
Using the Raspberry Pi credit card sized microcomputer; the overall goal of this project
was to develop a temperature sensor. The project included the research and
development of software for the Raspberry Pi by employing the Python programming
language and a variety of downloadable modules readily available for the Python
program to allow interaction with the GPIO sensor(s) – such as the temperature
sensor(s) – and the GPIO outputs (the LCD display).

4
This would allow the Raspberry Pi to detect and display the temperature within the
location it was stored in whilst potentially recording the data obtained for reference.
The planned program would automatically initiate from powering up the Raspberry Pi
without the requirement of user input.
The final planned project includes a working temperature sensor, consisting of a
Raspberry Pi connected to a LCD display, with a 3D printed casing for the unit, sensor
and display. The Raspberry Pi contains an SD card slot which holds an SD card
containing the Raspbian Wheezy operating system and the project software. By
powering up the unit, the required commands will be executed to run the developed
software.
1.3 Achievements
Developments which have occurred throughout the duration of this project include:
 Appreciation for the importance of time management
 Learning about the Raspbian operating system, LXTerminal, and how to use it
 Knowledge of how to connect to the Raspberry Pi Remotely (using VCN)
 Understanding basic circuitry and learning how to solder at a fundamental level
 Interpretation of the Python and C programming language modules and
packages – required to interact with the GPIO pins and to obtain readings from
the sensor(s), display the output, and connect to online sources
 Utilizing advanced functions in Creo to develop a practical case for the
temperature sensor and generating a rapid prototype of the design
The overall achievement from this project is a Raspberry Pi configured with suitable
software and hardware to allow the recording and display of data using a temperature
sensor encased within a rapidly prototyped container.
1.4 Overview of Dissertation
The paper contains seven different chapters which provide an explanation of the project,
discussion of the development, testing of the product, rapid prototype development, and
the potential future improvements.
Chapter 1 acts as an introduction to the project, the background and what the project
has provided, the goals and scope, and the overall achievements of the assignment.

5
Chapter 2 contains a description of the Raspberry Pi, review of projects in the same
area and how they differ from this project, including a brief description of some of the
hardware used by this and similar projects.
Chapter 3 provides a description of: the planning of the project, software and hardware
utilised to achieve the goal of creating a temperature sensor using the Raspberry Pi, and
what each software package is used for.
Chapter 4 includes the testing of the project software and analyses results obtained.
Chapter 5 discusses the use of Creo and rapid prototyping to design the case.
Chapter 6 reflects on the overall project and issues which occurred throughout.
Chapter 7 supplies the conclusion and discusses potential future work for the project.

6
2. Literature Review and Similar Projects
This chapter describes the Raspberry Pi, reviews similar projects which have implemented
temperature sensors, how they differ, and the hardware used both within those and this
enterprise.
2.1 What is the Raspberry Pi?
The Raspberry Pi series is a succession of small, credit-card sized microcomputers
initially developed and released by the registered charity The Raspberry Pi Foundation
in 2012. The single boarded computer was developed with the aim of teaching the
basics of computer science and programming to school students worldwide (The
Raspberry Pi Foundation, 2015).
Although a microcontroller similar to that of the Arduino (Arduino, 2015) – which is
popular for prototyping projects – the Raspberry Pi differs in that it acts more of a
computer rather than just a microcontroller.
2.1.1 History of the Raspberry Pi
The development of the Raspberry Pi dates back to 2006. With a realization in
the decline in both the skill and number of students applying for computer
sciences; a team of university students from the University of Cambridge
studying for their PHD (consisting primarily of Jack Lang, Eben Upton and
Alan Mycroft) within the Computer Laboratory decided to develop and create a
cheap, small, effective system. The planned system would allow for easy access
for school students into the world of computing; leading to the aim of improved
education in their field for students worldwide.
With the initial concepts for the unit being prototyped between 2006 – 2008, the
first low priced, credit-card sized microcomputer was released early 2012 – the
Raspberry Pi Model A (Eben Upton, 2014, pp. 3 - 8).
2.1.2 Hardware and Specifications
At the commencing of this project there were three revisions of the Raspberry
Pi; Model A, Model B (released late 2012) and Model B+ (released early 2014).
In February 2015, the Raspberry Pi 2 was announced (Lester Haines, 2015).

7
Each Raspberry Pi is similar in design, however, with each new revision comes
various changes such as increased; CPU power, RAM size, GPIO pins, Ethernet
ports, USB slots, and price.
Figure 3 – Model B (vividvilla, 2013)
The Raspberry Pi supplied by Dr James Thompson and focused on in this
enterprise is Model B. This revision of the Raspberry Pi is represented in Figure
3 – Model B . The features of this version are discussed in the following
segments (Eben Upton, 2014, pp. 14 - 18).
2.1.2.1 GPIO
Located at the top left of the Pi are a series of pins which compose the
general-purpose input-output (GPIO) header, which can be used to
connect other hardware to the Raspberry Pi. Different devices and add-
on boards can be connected to these pins.
Great care must be taken when handling the Pi as to not damage the pins
as the GPIO port is extremely powerful and, without these pins, certain
elements of the Pi are redundant. The GPIO pins will be discussed
further in later chapters.
2.1.2.2 RAM, CPU and GPU
In the centre of all Raspberry Pi boards lie integrated semiconductors
(circuits or chips). This is the processor, a Broadcom BCM2835 SoC
(system-on-chip) which embodies an ARM1176JZF-S CPU core.

8
This provides the Pi with its general purpose processing, graphical
rendering and input / output capabilities. On top of the chip is another
semiconductor which provides memory (512MB) for temporary storage
of data while running programs – this is also known as random access
memory (RAM).
2.1.2.3 Video Outputs
Below and above the SoC are the video outputs. The RCA (Radio
Corporation of America) video connector is a video port which is
primarily used to connect to older generation televisions which may not
have HDMI sockets. This provides low quality video and does not
provide audio; hence why a 3.5mm audio jack is provided to the right of
the RCA video output.
The HDMI (High Definition Multimedia Interface) port is most
commonly utilised, given that many of today’s media sources employ
this type of connection. When connected to a monitor or modern TV,
the HDMI port allows for high-resolution video and digital audio.
2.1.2.4 Power
Unlike a laptop or desktop computer, the Pi does not have a power
switch. At the bottom left of the unit is the Pi’s power supply – a micro
USB socket. This type of connection is typically found in the majority
of modern tablets and smartphones. Upon connecting a micro USB cable
with a suitable power adapter, the Raspberry Pi will start instantly when
power is connected.
2.1.2.5 LEDs
In the top right hand corner of the Pi are a series of Light Emitting
Diodes (LEDs), which are marked with different labels which provide
activity (ACT) and power (PWR) notifications.
2.1.2.6 USB and LAN
On the right hand edge of the board are two USB (Universal Serial Bus)
ports, which provide space for two hardware interfaces. This is the same
type of port found on desktop and laptop computers and allows the Pi to
be connected to any USB-compatible peripherals.

9
An Ethernet (LAN) port for connecting the Pi to a wired network is also
present – allowing the unit to access the internet and other devices on
the same network to access the Pi. This can also be done wirelessly and
will be discussed later.
2.1.2.7 SD Card
The underside of the board (left hand side) holds an SD (Secure Digital)
card slot. This allows the insertion on an SD card which acts as the
storage for the operating system, data, programs, and other files.
2.1.3 Operating System
The Raspberry Pi primarily uses Linux-kernel-based operating systems (OS).
Unlike Windows and MAC OS; Linux based systems are assembled under the
model of free and open-source software development and distribution (Linux,
2009).
The install manager for the Pi is NOOBS and can be obtained from The
Raspberry Pi Foundations website (The Raspberry Pi Foundation, 2015).
NOOBS contains different operating system packages (images) which can be
installed to the Raspberry Pi.
The OS installed in this project was Raspbian (Debian Wheezy) which supports
both Pi versions 1 and 2. Raspbian is heavily based on Debian; Debian is a “free
operating system for your computer and includes the basic set of programs and
utilities that make your computer run along with many thousands of other
packages” (Raspbian, 2015).
Raspbian is the most common operating system used in conjunction with the
Raspberry Pi due to being regarded as stable, high-quality, and scalable with an
extensive online community for help and support.

10
2.2 Similar Projects
The online community continuously share and modify different Raspberry Pi ventures
every day; this section explores similar temperature sensor schemes, as well as the
hardware and software developed within them.
2.2.1 A Simple Temperature Sensor
Projects similar to the work presented in this project include Brendan Horan’s
“A Simple Temperature Sensor” (Horan, 2013, pp. 37 - 60). In this development
the author connects the Raspberry Pi Model B to two different temperature
sensors – the DS18B20 and the DHT11 – using the GPIO pins through a
breadboard. Both configurations can be seen in Figure 4 – Simple Temperature
Sensor.
Breadboards are solderless construction bases used for prototyping in
electronics. This means that the GPIO pins of the Pi are plugged into the
breadboard as opposed to connections being directly soldered to the pins. This
allows for trial and error based scenarios and software or hardware testing.
Figure 4 – Simple Temperature Sensor (Horan, 2013, p. 49 & 53)
Given that two temperature sensors can be used interchangeably by the
Raspberry Pi highlights the flexibility in its design. As breadboards were used,
other parts such as different resistors, jumper wires and hook-up wires were
required. The DS18B20 temperature sensor circuit was setup using both a
“standard” mode and a “parasitic” mode. The author makes use of various
modules to obtain temperature values and sets up the program in order for the
DS18B20 to be detected and operate from the start-up of the Raspberry Pi.

11
Horan does note that, despite not including it within his program at this point of
testing, a “simple script to monitor the sensor or log the values to a file” could
be implemented. A script such as the one described would allow for records or
logs of recorded temperature values.
Horan then goes on to implement the DHT11 temperature sensor. Unlike the
DS18B20, the DHT11 sensor is also capable of recording the relative humidity.
Software from the Adafruit website is used in this example and the source code
from it is configured to suit the author’s requirements. The author notes that,
due to data time constraints in the DHT11, problems arise if requests for data
from the DHT11 arrive between 0 and 2 seconds; meaning the DHT11 is time
critical. The DHT11 temperature sensor was supplied by Dr James Thompson
with the intention of being included in the project design and this will be
discussed later.
2.2.2 Adafruit DHT Humidity Sensing
In the previous section it was highlighted that the Horan extracted software from
a website named Adafruit. Adafruit was founded in 2005 by Limor “Ladyada”
Fried; with the goal of creating “the best place online for learning electronics
and best designed products for makers of all ages and skill levels” (Adafruit,
2015). Adafruit have different experiments and developments for Arduino
microcontrollers and Raspberry Pis. One development on the website focuses
on the use of DHT temperature sensors realised on either a Raspberry Pi or a
Beaglebone black – a low-power, open-source hardware single-board computer
similar to the Raspberry Pi (BeagleBoard, 2015).
Figure 5 – Adafruit DHT Humidity Sensing (Ada, 2015, p. 5 & 6)

12
In this example, titled “DHT Humidity Sensing on Raspberry Pi or Beaglebone
Black with GDocs Logging” (Ada, 2015), the DHT11 and DHT22 temperature
and humidity sensors are implemented using a breadboard coupled with an
Adafruit Pi Cobbler (as can be viewed in Figure 5 – Adafruit DHT Humidity
Sensing ). The Adafruit Pi Cobbler is a breakout kit for the Raspberry Pi which
allows the user to make use of a ribbon-type cable to connect the GPIO pins to
the custom Adafruit PCB (Printed Circuit Board). This is used in conjunction
with a breadboard allowing connection to specific GPIO pins and again is an
alternative to soldering directly to the Pis pins. The software used allows for
both temperature and humidity values to be displayed. Ada does note that –
similar to Horan’s results – due to limitations in the sensors used and delays in
data transmission, potential errors can occur, resulting in the program having to
be ran until values are obtained.
Differing from the “Simple Temperature Sensor”, Ada then proceeds to develop
code which allows for the data attained from the DHT sensors to be transmitted
to Google Docs. Google Docs is “an online word processor that lets you create
and format text documents and collaborate with other people in real time”
(Google, 2015). Using a Google email address and password, Ada produces a
spreadsheet which is updated every 30 seconds directly online to Google Docs
with measurements added in real-time.
This type of data recording would be potentially useful if the user requirement
was to monitor the temperature from a different location, such as monitoring
the temperature in a computer server room out with working office hours from
home. The DHT22 and data logging are features which are later explored by the
author.
2.2.3 Raspberry Pi Temperature Sensor with LCD Display,
Temperature Sensor and Receiver
The previously reviewed projects demonstrate using different temperature
sensors with the Raspberry Pi, however, data output is either displayed on the
monitor used to access the Pi or online – not on an independent display.

13
The project self-titled “Raspberry Pi 1.8″ TFT, RF Receiver and Temperature
Sensor” provides an example of the temperature sensor coupled with an LCD
(liquid-crystal-display) (Williams, 2013). Williams equips the Raspberry Pi
with a small TMP102 digital temperature sensor and a TFT (Thin-Film-
Transistor) LCD display using software adopted and altered from the Adafruit
website. This can be observed in Figure 6 – Pi, TFT, RF and Temperature
Sensor .
Figure 6 – Pi, TFT, RF and Temperature Sensor (Williams, 2013)
The software used allows the user to record and store a data log of up to 7 days’
worth of data, after which the user is prompted to delete records to prevent the
memory of the SD card filling. The display indicates:
 The current date and time
 The last recorded temperature (polled every 5 minutes)
 Graphs of recorded temperature for the last 12 hours, 24 hours, and 7
days
Williams also applies an RF (Radio Frequency) receiver to the build which,
upon pressing either buttons A, B, C or D, controls the display and the type of
graphed data shown. Graphed recorded data is not a requirement for this
enterprise, however, the inclusion of the data and time could be implemented.
The use on an LCD display and the information shown will be discussed later.

14
3. Methodology
This chapter provides insight into the planning of the project and a description of the process
of utilising the software and hardware to create the temperature sensor using the Raspberry Pi.
All python and C script coding used in this project can be found in Appendix 1 – Code.
3.1 Planning
In order to complete a project successfully, a number of activities must be controlled to
ensure they are completed on schedule. If deadlines are missed or tasks remain
unfinished, there could potentially be knock-on effects on the rest of the project. In a
working environment; this could result in late deliverables which may have
consequential negative costs. As a result of being the leader of a group project, an
individual dissertation, and having modules coursework and exams; the author opted at
the beginning of this enterprise to implement a project Gantt chart. Gantt charts “outline
all of the tasks involved in a project, and their order, shown against a timescale” (Mind
Tools Ltd., 2015). An example of the Microsoft Excel Gantt chart used in this project
can be viewed in Figure 7 – Gantt .
Figure 7 – Gantt Chart
The Gantt Chart allowed the segregation of class, group and individual dissertation
work which allowed the author to plan objectives and monitor progress throughout the
year. If at any point work was behind schedule, the Gantt chart was reworked to
incorporate these changes to ensure that the overall workload remained constant as well
as bringing any lagging tasks back on course.
For this project in particular; the focus was firstly on obtaining temperature readings,
second the display, third data logging, and lastly the case design.

15
3.2 Setting up the Raspberry Pi
This section describes the steps taken to initially set up the Raspberry Pi.
3.2.1 Installation
The equipment supplied by Dr James Thompson included an 8GB SD card with
an outdated version of the Raspbian Wheezy OS pre-installed. The author opted
to remove this in place for an updated version of the Raspbian OS on a smaller
8GB Micro-SD card (evident in Figure 8 – 8GB Micro-SD). This was achieved
by formatting the SD card to remove all files associated with the old OS in place
for a new installation. An updated image of the OS was obtained from the
Raspberry Pi website (The Raspberry Pi Foundation, 2015) and copied to the
SD card on a laptop.
Figure 8 – 8GB Micro-SD
The SD card was then inserted into the Pi. With a powered USB hub, keyboard,
mouse, and TV screen connected through an HDMI cable in place; the
installation of the OS began. At a rate on 0.5 MB/sec and a file size of 2349
MB; the installation lasted for approximately an hour. Once installed, the
system prompted for the insertion of a default username and password –
configured to ‘pi’ and ‘raspberry’ respectively. The author also changed the
configuration of the Raspberry Pi start up to allow the GUI (Graphical User
Interface) to automatically boot up.
3.2.2 WiFi and VNC
Using an Edimax WiFi Nano adapter (Figure 9 – Edimax WiFi Adapter), a WiFi
connection was formed to allow internet access to the Pi. This connection
permits the Pi to download appropriate software and keep up to date.

16
Figure 9 – Edimax WiFi Adapter
Despite having a USB hub, keyboard, mouse and TV; to allow the author to
work on the Pi through a laptop, a VNC (Virtual Network Computing)
connection was programmed into the Pi. This permits any devices connected
over the same network to link together. Following a tutorial through eLinix.org
(eLinux.org, 2014) – an online resource for developers using Linux embedded
systems – a VNC server was added to the Raspberry Pi. When prompted for an
eight character password to secure the network connection, the author entered
‘raspberr’.
On the author’s laptop, software capable of connecting to the Raspberry Pi –
Real VNC Viewer (Real VNC, 2015) – was then downloaded. By inserting the
corresponding IP (Internet Protocol) address of the Pi into Real VNC Viewer; a
connection between the author’s laptop and the Pi was established. This
provides the laptop full control of the Pi and also acted as a means for the author
to screenshot work done on the Pi. The Pi GUI displayed on the laptop can be
viewed in Figure 10 – VNC in Action.
Figure 10 – VNC in Action

17
3.3 Obtaining First Temperature Readings
The following explains the process of obtaining temperature readings using the DHT11
sensor connected to the Raspberry Pi.
3.3.1 DHT11 Sensor
The DHT11 is a low cost temperature and humidity sensor consisting of a
capacitive humidity sensor and a thermistor – along with a basic chip which
supplies an analog to digital signal output with the temperature and humidity.
The specifications of the sensor are as follows (D-Robotics UK, 2010):
 Ultra low cost – £1.79 from eBay (eBay.co.uk, 2014)
 3 to 5.5V power and O/I
 2.5mA max current use during conversion (while requesting data)
 Good for 20% - 90% humidity readings with ±5% accuracy
 Good for 0 – 50°C temperature readings ±2°C accuracy
 No more than 1Hz sampling rate (once every second)
 Body size 15.5mm x 12mm x 5.5mm
 4 pins with 0.1” spacing
Typically, DHT11 sensors are connected to the Pi through the use of
aforementioned breadboards, Adafruit Pi Cobblers, resistors, and jumper wires;
however, the DHT11 sensor supplied by Dr James Thompson came on a PCB
inclusive of a 10K resistor and three pins (as seen in Figure 11 – DHT11
Sensor).
Figure 11 – DHT11 Sensor

18
The first pin (GND) is the ground pin, second is the data pin, and third pin
(VCC) is the power supply pin. This allowed the author to connect the DHT11
sensor directly to the corresponding Pi GPIO pins using only female-to-male
jumper wires.
3.3.2 Understanding the GPIO
As previously mentioned; the GPIO is used to connect hardware to the Pi – in
this case the DHT11 – with each GPIO pin offering different input and outputs.
Figure 12 – GPIO Pin Layout (Ziegelwanger, 2013)
The revision of the GPIO pins is dependent on the revision of the Raspberry Pi
– the layout for model B being revision 2.0. Figure 12 – GPIO Pin Layout
represents GPIO revision 2.0 and highlights each pin with a corresponding pin
number and name. For the purposes of this section, the pins used are 1 (3V3), 7
(GPIO 4), and 9 (GND) – although other pins can be used.

19
Figure 13 – DHT11 in GPIO
GPIO pin 1 (3V3) provides a constant output voltage of 3.3V which is a
sufficient minimum voltage for the operation of the DHT11 sensor using the
VCC pin. Pin 7 (GPIO 4) is a general purpose input and output pin suitable for
systems which are time sensitive (such as the DHT11) acting as an input as a
result of data incoming from the DHT11 data pin. Pin 9 (GND) connects to the
corresponding ground pin of the DHT11. This setup is represented in Figure 13
– DHT11 in GPIO.
3.3.3 Code for First Temperature Reading
Github.com is a web-based Git repository hosting service. Git is “a free and
open source distributed version control system designed to handle everything
from small to very large projects with speed and efficiency” (Github, 2014). Git
is used by companies such as Google, Facebook, Microsoft and Twitter. Git
allows users to acquire code for projects from online libraries. After searching
Github, in order to obtain temperature readings, a suitable C library was
obtained named ‘DHTlib’. C is a “high-level and general purpose programming
language that is ideal for developing firmware or portable applications”
(Janssen, 2015).
‘DHTlib’ is a “C library that can be used to read the DHT temperature and
humidity sensors an Single Board Computers running Linux” (Wisniewski,
2014). ‘DHTlib’ supports the DHT11 sensor – as well as the DHT22, AM2302,
and RHT03 – and can automatically detect the sensor through the GPIO pins.

20
The ‘DHTlib’ library was obtained by executing commands in the LXTerminal.
LXTerminal is a terminal emulator for the Raspberry Pi GUI used for operations
and commands. The commands used to install ‘DHTlib’ and a description of
their actions are as follows:
 git clone https://github.com/ondrej1024/foxg20 – the ‘git clone’
command copies the source code from Github within a specified
repository
 cd dhtlib – ‘cd’ is used to change the current working directory to the
one specified
 make – ‘make’ is used to determine automatically which pieces of a
program need to be recompiled, issues commands to recompile them and
builds the library
 sudo make install – ‘sudo’ allows a permitted user to execute a command
as the superuser. A superuser has special privileges needed to administer
and maintain a system. ‘make install’ installs the library, executable
commands and other required files created during the ‘make’ step
Once installed, the author again executed commands to build the appropriate
program:
 cd dhtlib/example – as previously mentioned
 make – as previously mentioned
Lastly, the program was run using:
 sudo ./dhtsensor DHT11 4 – ‘./dhtsensor’ runs the desired program of
the same name located within the working directory. ‘DHT11’ is used
by the program to help and automatically identify the sensor using the
GPIO pins and ‘4’ tells the program which GPIO pin the data pin of the
DHT11 is connected to – in this case GPIO 4 (or pin 7)
Figure 14 – DHTlib Example highlights the aforementioned commands being
entered to the LXTerminal and the results obtained.

21
Figure 14 – DHTlib Example
The first two readings generate the output ‘Error reading sensor: TIMEOUT’.
This was a result of the author accidently connecting the data pin of the DHT11
to the GND GPIO header and the ground pin to GPIO 4 header.
This error was corrected and the program run again – which yielded a result of
‘Rel. Humidity: 38.0% - Temperature: 21.0 °C’. This result was expected
considering the room temperature environment. The DHT sensor series records
both relative humidity and relative temperature.
3.3.3.1 Relative Humidity
Relative humidity is “the ratio of the amount of water vapour in the air
at a specific temperature to the maximum amount that the air could hold
at that temperature, expressed as a percentage” ( The Free Dictionary,
2011).
Humans are sensitive to humidity as the skin relies on air to get rid of
moisture. If the relative humidity is 100%, sweat from human skin will
not evaporate – resulting in people feeling hotter than the actual
temperature. On the contrary; if the relative humidity is low, people will
feel cooler than the actual temperature.

22
3.3.3.2 Relative Temperature
Relative temperature is a temperature scale consisting of both positive
and negative values – such as the Celsius and Fahrenheit scales. This
project uses degrees Celsius.
3.4 Display
The section to follow discusses the actions taken to build and configure a working
visual display for the Raspberry Pi based temperature sensor.
3.4.1 Display Size
As part of the kit provided with the Raspberry Pi at the beginning of this project;
the author was initially supplied with a HD44780 20 x 4 character LCD display
to use as part of the project. As can be seen in Figure 15 – LCD Sizes, the 20 x
4 LCD display (centre) is larger than the Raspberry Pi in dimensional size.
Figure 15 – LCD Sizes
Given that the minimum the display would be showing would be the
temperature and humidity values, and the maximum an inclusion of the date and
time; the author opted to purchase a HD44780 16 x 2 LCD to keep the design
as compact as possible. The 16 x 2 LCD is significantly smaller than the 20 x 4
– evident at the right of Figure 15 – LCD Sizes.
3.4.2 MyPiFi LCD Add-on Board
While researching methods to connect the HD44780 16 x 2 LCD display to the
Pi, a related Kickstarter project was noticed. Kickstarter is “the world’s largest
funding platform for creative projects” (Kickstarter.com, 2015) and includes
millions of projects covering art, gaming, hobbies, and technology.

23
The MyPifi LCD add-on board, as seen in Figure 16 – MyPiFi Board Kit
created by Paul Brown (Paul Brown, 2014), is an add-on board for the
Raspberry Pi which supports both 20 x 4 and 16 x 2 HD44780 LCD displays.
The idea was conceived by Brown as a result of “using a fiddly breadboard
where wires kept coming out on their own accord” (MyPiFi, 2014).
Figure 16 – MyPiFi Board Kit (MyPiFi, 2014)
The kit comes unassembled, requires soldering, and includes: the MyPiFi PCB,
a GPIO pin header extension, 16 pin insert strip, and a variable resistor. The
GPIO pin header extension allows access to the GPIO pins which are not in use
for the LCD display to operate – leaving adequate pins available for the
operation of the DHT11 sensor. The variable resistor controls the brightness of
the LCD display.
3.4.3 Soldering
With the purchase of the MyPiFi board, work began on soldering the
components together. Following recommendations from the ‘Adafruit Guide to
Excellent Soldering’ (Bill Earl, 2014); the author purchased a soldering kit
(Figure 17 – Soldering Kit ) from eBay (eBay.com, 2014) which included:
 25W soldering iron with 1mm conical pointed tip
 Helping hands with magnifier
 Soldering iron stand with tip cleaning sponge
 De-soldering pump tool and de-solder braid
 Solder (tin 60% / lead 40%)

24
Figure 17 – Soldering Kit (Google, 2015)
Having never soldered before, the author used the ‘Adafruit Guide to Excellent
Soldering’ as a reference. No formal risk assessment was completed as all
soldering work was completed at the author’s residence, however, the author
ensured that the area had sufficient ventilation and that a dust mask was worn.
This was to prevent inhalation of any poisonous lead fumes from the solder
during and after soldering.
Figure 18 – Soldering Snapshot
Figure 18 – Soldering Snapshot highlights the in-progress soldering of the
MyPifi board clamped in to the Helping hands. Care was taken to ensure each
solder met the standards outlined in the guide and that after each solder, the tip
of the soldering iron was cleaned using a damn sponge to remove excess solder.

25
Given that this was a first attempt, mistakes occurred. Any mistakes were
resolved by utilising the de-soldering pump which, when used, removed any
excess solder from the soldering joint.
Once the MyPifi add-on board was completed, a 16 pin header strip was
soldered to the 16 x 2 LCD display. This allows the quick addition and removal
of the display to the MyPiFi board without making it a permanent attachment.
The total soldering process lasted approximately three and a half hours.
Figure 19 – Completed Soldering
The fully soldered and assembled MyPiFi board with the LCD attached can be
seen in Figure 19 – Completed Soldering. The assembly was then plugged into
the Pi GPIO pins and powered on. As a result of successful soldering work, the
display worked – evident in Figure 20 – Soldering Check.
Figure 20 – Soldering Check

26
3.5 Temperature Sensor and Display Software
This segment discusses the software modules used and developed for the DHT11 sensor
and LCD display.
3.5.1 DHT11 Temperature Sensor and Data Logging
By searching Github.com for alternative DHT11 sensor programs; the author
found another Git repository for the DHT11 sensor being used with the
Raspberry Pi (Warren Gay, 2014). This source code is linked to the section
‘DHT11 Sensor’ of the book ‘Mastering the Raspberry Pi’ by Warren Gay (Gay,
2014, pp. 263 - 273). This was obtained by entering the following commands
into the LXTerminal:
 git clone https://github.com:ve3wwg/raspberry_pi/dht11.git
 make
The source code consists of:
 dht11.c – a C script providing direct GPIO access to read the DHT11
humidity and temperature sensor
 gpio_oi.c – a C script which configures the GPIO pins and is used within
the dht11.c script
 makefile – a C script which organises and provides superuser privileges
to the scripts in the same directory to allow them to operate with the Pi
 timed_wait.c – a C script which implements a precision “timed wait”
allowing the time sensitive DHT11 sensor to operate properly
Similar to the software utilised earlier, this library allows the user to obtain
readings for the relative humidity and temperature. The difference is that the
new library is built solely for use with the DHT11 sensor and does not require
the sensor or pin number to be specified when executing the software to obtain
readings. Readings are taken every 1 – 2 minutes.
Next, attention turned to the logging of data readings obtained from the DHT11
sensor. Stackoverflow.com is “a question and answer site for professional and
enthusiast programmers” (Stack Exchange Inc., 2015) and questions previously
asked and answered were used to help create and validate the appropriate C
script.

27
The script logs the temperature and humidity to a current and local log file each
time a value is recorded by the DHT11 (Stack Overflow, 2015) – this was saved
in the DHT11 directory and named ‘savetemp.c’.
The C scripts in the DHT11 directory where then compiled into one executable
file (Tips for Linux, 2015). This was achieved by executing the following
commands in the LXTerminal:
 cd /home/pi/DHT11
 gcc –o dht11 dht11.c gpio_oi.c timed_wait.c savetemp.c – ‘gcc’ merges
and compiles all declared scripts into one executable object. ‘dht11’ was
the name given to the executable object. ‘dht11.c gpio_oi.c timed_wait.c
savetemp.c’ are the declared C scripts the user wants to compile
3.5.2 Display
Software for the HD44780 16 x 2 LCD was then researched. PenguinTutor.com,
a website of “open source software tutorials” (Watkiss, 2014), provides
information on programming an LCD character display on the Raspberry Pi
(Watkiss, 2014). The python script requires an additional module to be installed
to the Pi, completed by entering into the LXTerminal:
 sudo pip install RPLCD – ‘pip’ is a tool for installing and managing
Python packages – in this case the installation of ‘RPLCD’
The python script was created using the PenguinTutor.com tutorial. The LCD
display first reads ‘Visit @UWS_Pi’ on the first line and ‘TEMP & HUMID’
on the second line for five seconds. ‘@UWS_Pi’ was the intended twitter handle
for a twitter account which was potentially going to be used to display updated
temperature and humidity values through a series of tweets and is something
which will be discussed later.
Following this, the script shows the current date and time on the first line, and
then pulls information from the updated log file and displays it on the LCD
display on the second line – temperature first and humidity second. The readings
update in accordance with the current log file (1 – 2 minutes). This Python script
was saved as ‘displaytempsense.py’ and saved in the same directory as the
‘dht11’ executable file.

28
3.5.3 Start-up Script
The author opted to start the DHT11, data logging, and display software in the
background as a service and from the initial boot up of the Raspberry Pi. This
was achieved by developing a shell script. A shell script is “a text file that
contains a sequence of commands for UNIX-based operating system(s)”
(Allsup, 2006). Shell scripts combine a sequence of commands into one file to
prevent the user from having to repetitively execute individual commands in the
LXTerminal.
Using logic obtained from an online blog post (Philips, 2013); the author
generated a shell script which calls for the ‘dht11’ executable file and
‘displaytempsense.py’ Python script upon start-up of the Raspberry Pi – this
was saved as ‘tempsense’ (temperature sensor). For the script to work, the
permissions of ‘dht11’ and ‘displaytempsense.py’ had to be changed to granted
as executable by the LXTerminal. This was achieved by typing the commands:
 sudo chmod 755 dht11
 sudo chmod 755 displaytempsense.py
Where ‘chmod’ allows the permissions to be changed and ‘755’ are the read,
write, and execute permissions for the user, group and work.
Once the appropriate permissions were in place; the shell script ‘tempsense’ was
then moved to the directory ‘etc/init.d/’ which is the directory in the Raspberry
Pi for any start-up scripts by commanding:
 sudo cp tempsense.sh /etc/init.d – ‘cp’ being the command to copy to
the specified directory and ‘/etc/init.d’ being the intended directory
To check the working script and activate it, the following command was entered
into the LXTerminal:
 sudo /etc/init.d/tempsense.sh start – ‘start’ initiating the DHT11
software and display Python script
The successful result is highlighted in Figure 21 – Working Display.

29
Figure 21 – Working Display
To get the shell script to start when the Raspberry Pi is powered up, a final
command was entered:
 sudo update-rc.d tempsense.sh defaults – ‘update-rc.d’ links the shell
script to the directory ‘/etc/rc.x’ so that the script can run at the ‘default’
times such as the boot up of the Pi.
3.6 Online Data Logging
Another means of recording and monitoring the temperature and humidity is online.
With working hardware and software in place for the DHT11 sensor and LCD display;
the author began researching methods of transmitting this data online.
3.6.1 PrivateEyePi
PrivateEyePi is a “projects website aimed at the Raspberry enthusiast wanting
to build home security/automation systems and at the same time learn
programming and electronics” (PrivateEyePi, 2015). PrivateEyePi provides
downloadable source code and an online dashboard which allows the user the
control, monitor, and trigger alerts for their Raspberry Pi based projects.
Figure 22 – DHT22 Sensor

30
Based on an online tutorial (PrivateEyePi, 2015); the author registered an email
address and password at www.privateeyepi.com. This project makes use of the
DHT22 temperature and humidity sensor. The DHT22 (visible in Figure 22 –
DHT22 Sensor) has the same specifications at the DHT11, except for the
following:
 Good for 0 – 100% humidity readings with ±2 – 5% accuracy
 Good for -40 to 125°C temperature readings ±0.5°C accuracy
 No more than 0.5Hz sampling rate (once every 2 seconds)
 Body size 15.1mm x 25mm x 7.7mm
The DHT22 sensor was purchased by the author for £8.85 from eBay
(eBay.com, 2015) which is a higher cost that the DHT11; however, the DHT22
sensor is more accurate and has a larger temperature and humidity range
compared to the DHT11. The DHT22 also came on a PCB with a resistor and
was connected to the same pins that the DHT11 was connected to previously.
The software for the DHT11, data logging and display at this point were stopped
to allow the use of the GPIO pins using:
 sudo /etc/init.d/tempsense.sh stop
…and the MyPiFi add-on board, LCD display, and DHT11 removed to make
way for the DHT22.
The PrivateEyePi dashboard prompted the author to configure a GPIO pin
number and choose which type of sensor was being set up – in this case a
temperature gauge was selected using GPIO 4 (pin 7). Next, the PrivateEyePi
software was installed to the Raspberry Pi by commanding in the LXTerminal:
 cd /home
 sudo wget –N www.privateeyepi.com/downloads/install.sh – ‘wget’
downloads internet files from the requested website
 sudo sh install.sh – ‘sh’ runs the shell script install specified

31
Once installed, the username and password created on the PrivateEyePi
dashboard was linked to the Raspberry Pi by commanding:
 cd /home
 sudo nano globals.py – ‘nano’ allows the user to enter a text editor
within the LXTerminal to edit the specified script
This information was then saved. Following this, software for the DHT22 was
downloaded from an Adafruit Git repository to the same directory:
 cd /home
 sudo git clone git://github.com/Adafruit/Adafruit-Raspberry-Pi-Python-
Code.git
Last, the PrivateEyePi and DHT22 software was started by commanding:
 sudo python dht22.py
A snapshot of the software running in the LXTerminal providing temperature
and humidity readings (every 1 – 2 minutes) can be seen in Figure 23 – DHT22
Snapshot.
Figure 23 – DHT22 Snapshot

32
The author started the software at 5.29pm and left the programming running
overnight. Figure 24 - PrivateEyePi highlights the PrivateEyePi online
dashboard which advises if the Raspberry Pi on online, what the current relative
humidity, temperature, date and time is; as well as providing graphed data of
the temperature vs time.
Figure 24 - PrivateEyePi
As can be seen in the graphed data, the curve takes a decline from midnight
onwards. This is when the author turned the area’s central heating off as a result
of retiring to bed. This trend lasts up until 5.42am the following day when the
author’s internet connection unintentionally disconnected the Raspberry Pi from
the internet. Excluding the internet disconnection; this was a successful method
of monitoring the temperature online.
3.6.2 Twitter
Twitter is an “information network made up of 140-character messages called
Tweets” (Twitter Inc., 2014) and is one of the main social media platforms used
to date with 288 million monthly active users and 500 million tweets sent
everyday (Twitter Inc., 2015).

33
Based on a YouTube tutorial by SparkFun Electronics (SparkFun Electronics,
2014); the author created a Twitter account under the Twitter handle
‘@UWS_Pi’ (Twitter Inc., 2015) as can be seen in Figure 25 - @UWS_Pi.
Twitter allows programmers and developers to interact with its API
(Application Programming Interface). API is a “set of programming instructions
and standards for accessing a Web-based software application(s)” (Ross, 2015).
Figure 25 - @UWS_Pi Twitter
On Twitters Application Manager; new applications can be created which grant
the user API keys and access tokens to allow any authorised, developed
applications to interact with the Twitter account created. The author created an
application named ’UWS_Pi’ to obtain the relative codes to link a Python script
to the Twitter account ‘@UWS_Pi’.
The SparkFun Electronics tutorial uses a HIH6130 SparkFun Humidity and
Temperature Sensor Breakout board to generate temperature and relative
humidity values. The author opted to remove the DHT22 sensor, stop the
PrivateEyePi software, and reinsert the DHT11 with the MyPiFi add-on and
LCD display. The Pi was rebooted to automatically start-up the appropriate
scripts.
Using a similar Python script to the tutorial, a Python script named
‘tweettempsense.py’ was created by the author which – instead of the HIH6130
sensor values – uses the same temperature and humidity data that the
‘displaytempsense.py’ Python script uses.

34
To test the connection to the Twitter account, the author entered the message
‘Testing, testing, 1, 2, 3.’ into the Python script and executed the command in
LXTerminal using:
 sudo python tweetpython.py
Figure 26 – Tweet Test highlights the successful tweet being posted to Twitter.
Figure 26 – Tweet Test
From here, the author changed the Python Script to accommodate the date, time,
temperature and humidity and ran the script again using the same LXTerminal
command. One of the first readings to the Twitter account can be viewed in
Figure 27 – Twitter Temperature Tweets. Twitter has a daily limit of 1,000
tweets per day (Twitter Inc., 2014). The author configured the Python script to
send an updated tweet every two minutes to the Twitter account; meaning that
daily the script would send out only 720 tweets per day.
Figure 27 – Twitter Temperature Tweets
Similar to PrivateEyePi, the Twitter account can be accessed to obtain
temperature and humidity readings on any device – such as a laptop of mobile
phone. By the author adding the Twitter handle ‘@wullbertduncan’ – the
author’s own Twitter account – notifications are received every time the script
sends a tweet to Twitter.

35
The incorporation of Twitter to the project also allowed for updated online data
transmission. One key difference is that PrivateEyePi is only accessible to the
owner of the configured dashboard; whereas information posted to Twitter is
accessible to anyone.
For example; this would prove useful for a technical department with multiple
employees looking to monitor the temperature and humidity of a server room to
ensure the temperature was suitable for computing operations

36
4. Testing
This chapter analyses the performance of the temperature sensor against changes in
temperature and humidity and analyses results obtained. All data can be viewed in Appendix 2
– Test Data.
4.1 Cooling Test
The purpose of this test was to analyse how the temperature and humidity sensor reacted
to extreme reductions in temperature. The temperature and humidity were analysed
over a period of time. The expectation was that the temperature would decrease with
time and the humidity would potentially rise over time.
Figure 28 – Cooling Test
The temperature and humidity were altered by using a bag of frozen ice – wrapped in a
towel – placed over the DHT11 sensor; this is shown in Figure 28 – Cooling Test. The
frozen ice remained on the sensor for approximately ten minutes and then removed
again. The log file on the Pi was then transferred to Microsoft Excel and the temperature
and humidity values were plotted against time.
Figure 29 – Cooling Graph displays the trend for the temperature and humidity during
the testing period. The graph provided highlights the temperature (blue curve)
decreasing from room temperature (25°C) to 1°C over the course of the ten minute
period.
The humidity (red curve) during this time also changes at approximately the same rate
but increases with time. As the bag of ice is removed, the temperature increases at the
same rate until it reaches room temperature again; the humidity dropping at a similar
but opposite rate also. This was the intended outcome of the test.

37
Figure 29 – Cooling Graph
4.2 Heating Test
The purpose of this test was to analyse how the temperature and humidity sensor reacted
to an extreme increase in temperature. The temperature and humidity was analysed over
a period of time. The expectation was that the temperature would increase with time
and the humidity would potentially decrease over time.
Figure 30 – Heating Test
The temperature and humidity were altered by using a hairdryer – set to the highest
temperature setting – blown directly to the DHT11 sensor; this is shown in Figure 30 –
Heating Test. The hairdryer remained on the sensor for approximately five minutes and
then removed again.

38
The log file on the Pi was then transferred to Excel and the temperature and humidity
values were plotted against time. Figure 31 – Heating Graph displays the trend for the
temperature and humidity during the testing period.
Figure 31 – Heating Graph
The graph provided highlights the temperature (blue curve) increases from room
temperature (25°C) to 60°C over the course of the five minute period. Despite the range
of the DHT11 being 0 – 50°C it still detected temperatures above this range.
The humidity (red curve) during this time also changes at approximately the same rate
but decreases with time. As the hairdryer is removed, the temperature decreases at the
same rate until it reaches room temperature again; the humidity increasing at a similar
but opposite rate also. Excluding the reading above 50°C; this was the intended
outcome of the test.

39
5. Case Design
The following chapter discusses the process of creating and rapid prototyping the case. The
case was designed using Creo and then rapid prototyped using a 3D printer.
5.1 Concept and Influence
Research was conducted on existing cases for Raspberry Pis to generate ideas and
concepts for a suitable case for the temperature sensor. Many cases come as part of a
kit which are then assembled by the user. Cases such as the Adafruit transparent case
(Figure 32 – Adafruit Case ) and the Bramble case (Figure 33 – Bramble LCD Case )
proved preferable due to multiple parts with ease of assembly.
These cases are advantageous for a device such as the Raspberry Pi as it provides quick
and easy access into the GPIO pins and ports.
Individual parts of the case could also potentially be changed and modified to
incorporate new projects without having to design a completely new case.
Figure 32 – Adafruit Case (Humpries, 2012)

40
Figure 33 – Bramble LCD Case (bitcrafts, 2015)
Figure 34 – Conceptual Sketch highlights a conceptual sketch of the intended case. The
conceptual case features holes for the HDMI, audio and visual, Ethernet, and USB ports
as well as a slot for the DHT11 sensor and LCD display. Each side of the case features
both slots and protrusions which allow the case to merge and lock into place, similar to
the Bramble case. The base of the conceptual unit also features holes for either screws,
hooks, or suction cups to allow the case to be placed vertically on a wall or surface.
Figure 34 – Conceptual Sketch

41
5.2 3D Modelling
Creo is a commercial CAD (Computer Aided Design) software package used
extensively throughout the manufacturing and design industry. Product designers and
manufacturers use CAD software for designing and rapid prototyping (such as 3D
printing) to create physical scale models of products which can be used for analysis and
production tooling.
Figure 35 – Raspberry Pi Creo Model
Creo was used to realise a 3D model of the conceptual design. To create an accurate
case design; the author obtained official 3D part modelling files online
(Stackexchange.com, 2013) for the Raspberry Pi model B and uploaded them to Creo.
The part files came preassembled on Creo but were unreferenced (Figure 35 –
Raspberry Pi Creo Model).
Next, the author measured each main component being added to the Raspberry Pi.
These parts were:
 DHT11 temperature and humidity sensor
 GPIO pin extension
 MyPiFi add-on board
 16-pin header strip
 HD44780 16 x 2 LCD display

42
Figure 36 – Component Modelling
In the assembly mode of Creo; each measured component was then 3D modelled using
the obtained Raspberry Pi model as a reference (an in progress snapshot evident in
Figure 36 – Component Modelling)).
Figure 37 – Component Assembly
The complete assembly of all modelled components can be viewed in Figure 37 –
Component Assembly. With all required electrical components in place, work began
on the case design. Again, using reference modelling (an example of which visible in
Figure 38 – Reference Modelling) each part was constructed in relation to pre-existing
geometry.

43
Figure 38 – Reference Modelling
Reference modelling allowed the author to construct the case while creating offset
sketches of features – such as the HDMI and USB ports – allowing adequate space in
the case design for the insertion of plugs and cables. An in-progress snapshot of the
construction of the case can be seen in Figure 39 – Case Modelling.
Figure 39 – Case Modelling
The author opted to include holes at the base of the unit for four 20mm suction cups in
the design which would allow the case to be stuck to non-porous surfaces. The ‘UWS
– University of the West of Scotland’ logo was also extruded on the case using a palette
sketch. Shelves were included in the design to support the MyPiFi add-on board and
LCD display.
The complete, assembled 3D model of the case, including the main electrical
components, can be viewed in Figure 40 – Case Component Assembly.

44
Figure 40 – Case Component Assembly
5.3 Part Drawings
Dimensional, assembly, and exploded drawings of each part and can be viewed in
Appendix 3 – Drawings. All drawings were produced using key functions within Creo.
5.4 Rapid Prototyping
Additive Layer manufacturing (3D printing) works by “laying down thin layers of
heated material onto a platform. Either the (printing) head or platform will continuously
be moving to deposit more material on top of each other to form the 3D object”
(University of Exeter, 2015). 3D printing is a modelling technique which can improve
and speed up new product development.
5.4.1 Advantages of Rapid Prototyping
Conventional prototyping typically requires production of prototype tooling and
physical components of exact tolerances; whereas rapid prototyping eliminates
this and allows for the incorporation of complex shapes and surfaces – typically
proving either difficult or impossible to recreate by conventional prototyping.
Conventional prototyping tends to involve subtractive processes such as
milling, turning, and drilling. This means that waste occurs through cut-off
materials or chippings as the tools used create the finished model – resulting in
higher costs due to tooling and material waste. 3D printing helps reduce costs
of product development as it is an additive technique.
The only machine used each time is a 3D printer and CAD software such as
Creo – there is no need to develop special tools for each new product.

45
5.4.2 3D Printing
3D printing uses SLT (stereolithography) files constructed from 3D CAD
software such as Creo. The 3D modelled part files for the case were individually
exported as SLT files. STL files change the 3D modelled files and break the
reference shape into thousands of triangles which replicate the reference model.
The parts submitted were named:
 Top – Top of the case featuring the UWS logo and space for the LCD
display
 Bottom – Bottom of the case featuring holes for suction cups
 Side 1 – Featuring a hole for the HDMI port
 Side 2 – Featuring holes for the USB, Ethernet ports and a shelf for the
LCD Display
 Side 3 – Featuring a hole for the micro-use power cable and shelves for
the MyPiFi board and LCD display
 Side 4 – Featuring holes for the audio and visual ports and the DHT11
sensor
Upon exporting; the author was prompted to choose the ‘Chord Height’ and
‘Angle Control’ which determines the shape of the triangles.
On the recommendation from the Chief Technician Robert Boyce; there were
set and saved as zero. An example of an SLT file created from an exported case
component can be seen in Figure 41 – SLT Part.
Figure 41 – SLT Part

46
The SLT files were submitted to the Robert Boyce for printing on the Stratasys
Dimension Elite ABS Printer (Figure 42 – 3D Printer) located in the Product
Design facility at UWS.
Figure 42 – 3D Printer
The printing envelope of the printer is 203x203x305mm and the printer uses
ABS thermoplastic and a support material (Stratasys FDM soluble support) to
print 3D models.
The Dimensions printer has software which allows the user to insert and
position SLT files to the printing envelope – this was configured by the Chief
Technician as seen in Figure 43 – Printing Configuration.
Figure 43 – Printing Configuration
Given that the case parts were small and flat; the components were arranged in
the printing space to optimise printing time. The Stratasys Dimension Elite ABS
Printer has a dimension resolution range of 0.178 – 0.254mm layer thickness.

47
The smallest layer thickness would create a more accurate component due to
having more layers but overall takes more time to print. This was also
configured appropriately by the Chief Technician.
The first batch of printed parts – five out of six components – were submitted
to the printer, returning a printing time of 4.25 hours. The remaining component
was later submitted with a total print time of 1.2 hours.
After printing; the parts were transferred to a bath which contained a solution
(Stratasys Water works soluble concentrate P400SC) used to remove any
support material. The total process time, including bathing parts, took
approximately eight hours. The printer parts where then assembled with the
Raspberry Pi, electrical components, and suction cups. Figure 44 – Full
Working Assembly shows the fully assembled temperature sensor and
prototyped cased suctioned to a wall.
Figure 44 – Full Working Assembly
5.5 Case Revision 2.0
As previously mentioned; the Raspberry Pi features a Broadcom BCM2835 SoC which
– with general use of the Pi – can overheat if poorly ventilated. The author opted to
revise the design of one component of the case – ‘Bottom’ (Figure 46 – Case Bottom
Drawing in Appendix 3 – Drawings). This was a result of the author observing the
bottom of the case heating up.

48
Figure 55 – Case Bottom (Revision 2.0) Drawing in Appendix 3 – Drawings highlights
the patterned extrusion design added to revision 2.0. Similar to previous parts; this was
submitted for printing with a print time of 1.1 hours and bathed in the soluble support
solution for approximately 2 hours. This proved the flexibility in the cases design and
the effectiveness that rapid prototyping has on altering new products.
5.6 Cost
The overall costs associated with the production of the prototype were assessed. This
takes into consideration the main electrical components used in the final design and
rapid prototyped components. The total cost for electrical components is inclusive of
VAT and delivery charges to Paisley, UK. Table 1 – Cost of Prototype represents these
charges.
Table 1 – Cost of Prototype
The cost of the 3D printed parts is based on the cost associated with printing time. 48
hours of printing uses a full cartridge of either ABS thermoplastic or support material
– with a cost of £275 per cartridge.
This cost excludes labour fees associated with the production of the parts and computer
components – such as monitor, keyboard and mouse.
Part Name Supplier Total Cost
Raspberry Pi (Model B) RS Components 29.22£
Edimax Wireless Nano
USB Adapter
RS Components
12.30£
My PiFi Add-on Board Amazon 9.07£
10 x 20 mm Suction Cups eBay 2.10£
HD44780 LCD Display eBay 2.78£
DHT11 Humidity &
Temperature Sensor
with cables
eBay 2.49£
Rapid Prototypes UWS, Paisley 37.52£
Total Cost = 95.48£

49
5.7 Manufacture
As prototypes are created to prove the concept of a given design; the author was not
focused of perfecting a finalised design, but a representation of a product which could
then potentially be manufactured for a target market.
The majority of products in today’s modern society involve plastics to some extent;
from the clothes people wear to the cars that they drive. These commodities are
typically mass produced on a grand scale, some of which are created using injection
moulding techniques by manufacturing companies.
Molten plastic is injected at high pressure into a mould core and cavity, which contains
a hollow space representing the part shape. In order for companies to use injection
moulds, the moulds themselves have to be firstly designed; this job typically would be
assigned to a product designer.
CAM (Computer Aided Manufacturing) software, such as Creo, can allow design and
manufacturing companies to assess potential products for manufacturing. If the parts of
the case were to be produced in plastic and moulds were required for production; Creo
could analyse factors such as, but not limited to:
 Drafts check – the determination of areas within a reference model which do
not satisfy minimum draft angles
 Thickness check – the analysis of the thickness throughout a reference model to
satisfy minimum material or mould requirements
 Undercut check – the determination of areas where mould sliders may be
required to achieve undercuts
 Gate Location – the examination of the best location to inject molten plastic
Much similar to the creation of the component parts; moulds could then be created on
Creo to produce 3D models of mould core and cavities for each part.
Next, using the newly created mould models; the user could then recreate a
manufacturing environment – again by utilising key functions in CAM software such
as Creo. Creo would allow the user to replicate the working space used to create moulds.
With a vast catalogue of tools, VMCs (Vertical Machining Centres), and techniques
available; the user would be able to simulate the production of the moulds by
configuring NC (Numerical Controlled) tool paths.

50
These tool paths could then be analysed to ensure the products being produced are done
with:
 Minimum cost
 Minimum time resource
 Reduced material waste
 Minimum machine time
…all whilst maintaining a quality end product.
The aforementioned steps avoid the use of any raw materials, tools or labour as they
are virtual simulations. This is advantageous as there comes low risk due to the low
cost associated with CAM simulations.
3D rapid prototypes of the moulds could also be constructed; allowing product
designers to identify design flaws or usability issues and make the appropriate changes
quickly.
The rapid prototyping process provides an accurate model which can then be used to
create production tooling, decreasing the risk of issues in the manufacturing phases.
The moulds produced from the reference model (case design) could then be used to
manufacture the plastic components required.

51
5. Reflection
The chapter discusses the key aspects of the work conducted and highlights issues encountered
during the project.
5.1 Programming and Testing
Programming and configuring the appropriate software for the hardware used in the
Raspberry Pi proved to be the most time-consuming and problematic area of work
during this enterprise. As a newcomer to the Python and C programming languages; the
author tried different software to operate the DHT11 sensor and display.
Initially, the author followed the online Adafruit tutorial (Ada, 2015) mentioned
previously in the literature review. This was done using a breadboard and Adafruit Pi
Cobbler but this tutorial did not return any sensor values. Ada does point out, however,
that the tutorial is purely experimental and in some cases may not work.
The programming of the display also proved difficult. Upon soldering the MyPiFi Add-
on board and LCD display; the author used recommended steps from a Raspberry Pi
blog (BOEEERB, 2013) to configure the GPIO pins with the LCD display. This tutorial
worked, however, it configured a client server on the LCD display which, when coupled
with the intended DHT11 software, corrupted the on screen values displayed (evident
in Figure 45 – Corrupt Display).
Figure 45 – Corrupt Display
The Raspberry Pi and Raspbian OS proved temperamental on different occasions. On
one instance – upon rebooting the Pi after configuring the shell start up scripts – the Pi
locked the author out of the Raspberry Pi. This prevented the author from being able to
access the Raspbian GUI.

52
As a result, the author had to completely format the micro-SD card and reinstall the
Raspbian OS again. Luckily, the author had backed up all scripts used for the project
on a USB stick – highlighting the importance of backing up files on a regular basis.
Without backups, the author would have had to start from the beginning.
Stackoverflow.com proved to be a useful resource during the project as it allowed the
author to question and validate any configured Python and C scripts if problems arose.
Responses and feedback from members of Stackoverflow.com proved to be quick and
effective.
The output of the logged temperature and humidity provides the date, time, temperature
and humidity for each recording. The log file produces the following values:
“1428847287 25 36
1428847403 25 36
1428847465 25 36
1428847541 23 37”
The string of numbers at each instance is an UNIX timestamp. UNIX timestamps (or
epoch times) are “the number of seconds that have elapsed since January 1, 1970
00:00 UTC” (convert-unix-time.com, 2015).
The author could was unsuccessful in correcting this to a readable time, however; when
transferring the data to a Microsoft Excel spreadsheet – an example of which was used
for the testing graphs – the timestamp was converted to a readable time using an Excel
formula (J-Walk & Associates, Inc., 2015).
Between the DHT11 and DHT22 sensors used, due to its specification, the DHT22
proved to be the more accurate temperature and humidity sensor. Unfortunately; the
author was unable to operate the DHT22 with the final software used. Integrating the
system with online sources such as PrivateEyePi and Twitter proved effective in
providing online resource for observing and monitoring the temperature and humidity.
The open-source nature of the Raspberry Pi allows programmes and hobbyists of all
levels – from initial beginners such as the author to experts – to try, test, and alter free,
readily available modules and software for any purpose.

53
The possibilities of the use of the Raspberry Pi are endless, and this project hones in on
only a couple of elements in particular.
5.2 Case Design
Having used Creo extensively throughout previous university coursework; the design
of the case came naturally to the author. CAD software logic such as using unreferenced
part files, the incorporation of palette logos, reference assembly modelling, and patterns
were utilised throughout the design process on Creo. These skills apply not only to
Creo, but CAD software programs in general.
Rapid prototyping the components proved straightforward and successful overall with
a second revision in the design. Given that prototypes are not perfect representations of
a finalised design; the author used blue tack to secure the case components for proof of
the concept. The cost of producing the prototypes was also inexpensive overall.

54
6. Conclusion
The overall objective of this project was to produce a Raspberry Pi configured with suitable
software and hardware to allow the display and recording of data using a temperature sensor
encased within a rapidly prototyped container.
Through employing careful time management, research into the Raspberry Pi microcomputer,
software and hardware, utilisation of CAD software, and the exploration of rapid prototyping;
the author logically applied new and existing knowledge gained during his tenure at UWS to
satisfy the requirements of the project outlined.
The final outcome of this project was a Raspberry Pi based temperature and humidity sensor,
capable of displaying updated values on an LCD display with local and online data logging.
The tested sensor uses Python and C programming language software to operate coupled with
the following hardware:
 Raspberry Pi (Model B)
 DHT11 Temperature and Humidity Sensor
 MyPiFi LCD Add-on Board
 HD44780 16 x 2 LCD Display
The Raspberry Pi based temperature and humidity sensor with case created has the prospective
to be manufactured for sale and, given more time and resource, this is an idea which could
potentially be realised.
6.1 Recommendations for Future Work
There are some aspects of the project which could have been further investigated; this
section briefly discusses them. Due to limitations in either time or resource, these ideas
were not realised at time of writing.
6.1.1 Battery Power Source
The final project outcome is powered using a micro-USB powered using mains
voltage. One future development for this project could focus on powering the
Raspberry Pi with an internal battery power supply.

55
6.1.2 3G/4G WiFi Connection
The temperature sensor developed uses a home broadband WiFi connection. A
potential future development could focus on using the Raspberry Pi with a
3G/4G USB WiFi device for online connectivity out-with a household.
6.1.3 Possible Manufacture for Sale
This topic was discussed at a high level but was not realised. A potential next
step for this project could concentrate on the manufacture of a Raspberry Pi
based temperature sensor. This could involve research into electrical part and
component supply, creating moulds for the Raspberry Pi case, and preparing it
for sale to a target market.
6.1.4 Improving the Sensor Design
The design of the sensor could also be greatly improved. The final outcome of
this project satisfied the project requirement, but with more time and resource,
better sensors and displays could be included.
Due to the open-source nature of the Raspberry Pi, components such as a
camera, audio recording, movement sensors, and controllers could develop the
sensor into a home automation device.

56
Bibliography
The Free Dictionary, 2011. Relative Humidity. [Online]
Available at: http://www.thefreedictionary.com/relative+humidity
[Accessed 20 October 2014].
Adafruit, 2015. About Adafruit. [Online]
Available at: http://www.adafruit.com/about
[Accessed 15 January 2015].
Ada, L., 2014. Overview | DHTxx Sensors | Adafruit Learning System. [Online]
Available at: https://learn.adafruit.com/dht/overview
Ada, L., 2015. DHT Humidity Sensing on Raspberry Pi or Beaglebone Black with GDocs
Logging. [Online]
Available at: https://learn.adafruit.com/downloads/pdf/dht-humidity-sensing-on-raspberry-pi-
with-gdocs-logging.pdf
[Accessed 10 November 2014].
Adam Shepherd, D. C., 2015. The 9 best Raspberry Pi projects and uses: cool things you can
do with a £22 microcomputer | PC Pro. [Online]
Available at: http://www.pcpro.co.uk/computing/1000043/the-9-best-raspberry-pi-projects-
and-uses-cool-things-you-can-do-with-a-22
[Accessed 12 Febuary 2015].
Allied Electronics, 2015. Raspberry Pi - Raspberry Pi Model B. [Online]
Available at: http://ex-en.alliedelec.com/raspberry-pi-raspberry-pi-model-b/70229569/
Allsup, C., 2006. What is a Shell Script? - Definition from WhatIs.com. [Online]
Available at: http://searchenterpriselinux.techtarget.com/definition/shell-script
Arduino, 2015. Arduino - ArduinoUnoBoard. [Online]
Available at: http://arduino.cc/en/Main/ArduinoBoardUno
[Accessed 01 Febuary 2015].

57
BeagleBoard, 2015. Black. [Online]
Available at: http://beagleboard.org/black
Bill Earl, 2014. Tools | Adafruit Guide To Excellent Soldering | Adafruit Learning System.
[Online]
Available at: https://learn.adafruit.com/adafruit-guide-excellent-soldering/tools
bitcrafts, 2015. Bramble LCD Raspberry Pi case for use with 1.8" TFT by bitcrafts. [Online]
Available at: https://www.etsy.com/listing/155640789/bramble-lcd-raspberry-pi-case-for-use
[Accessed 7 March 2015].
BOEEERB, 2013. Pi & GPIO powered HD44780 LCD. [Online]
Available at: http://www.boeeerb.co.uk/pi-lcd/
convert-unix-time.com, 2015. Convert Unix Time - convert and create your unix timestamp.
[Online]
Available at: http://convert-unix-time.com/
[Accessed 3 March 2015].
D-Robotics UK, 2010. DHT11 Humidity & Temperature Sensor. [Online]
Available at: http://www.micropik.com/PDF/dht11.pdf
eBay.co.uk, 2014. New DHT11 Temperature and Relative Humidity Sensor Module for
arduino WT. [Online]
Available at:
http://www.ebay.co.uk/itm/like/161341859868?limghlpsr=true&hlpv=2&ops=true&viphx=1
&hlpht=true&lpid=108&chn=ps&device=c&adtype=pla&crdt=0&ff3=1&ff11=ICEP3.0.0-
L&ff12=67&ff13=80&ff14=108
eBay.com, 2014. 25 Watt Electronics Soldering Iron Kit Stand, Solder, Desolder & Accessories
25w. [Online]
Available at: http://www.ebay.co.uk/itm/141609851593

FINAL INDIVIDUAL

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (11)

Similar to FINAL INDIVIDUAL

Similar to FINAL INDIVIDUAL (20)

FINAL INDIVIDUAL