---
# System prepended metadata

title: '***Tutorial till hur man bygger en temperatursensor***'

---

# ***Tutorial till hur man bygger en temperatursensor***

Gisela Dahlberg - gd222ec

**Översikt**

Projektet avser att mäta rumstemperaturen och att sedan skicka denna data till cloudplattformen Pybytes. På Pybytes har en dashboard skapats för att ge en visuell bild av temperaturen. Förutom detta ändras LED-lampans färg på Pycomenheten beroende på temperaturen. 
Målet med projektet är att skapa en förståelse för IoT, sensorer, Micropython, Pycomenheterna samt sändning av data och inte att skapa en avancerad lösning. Därför valdes en enkel sensor och en enkel plattform som kunde visualisera data på ett smidigt sätt. Datan ska egentligen inte användas till något i nuläget, annat än att visa att det fungerar och att värden sänds. Initialt fanns en tanke om att styra en minifläkt som ansluts via USB-kabel till Pycomenheten men det är inget som projektet uppnår i nuläget. Dock finns grunden till att med hjälp av temperatursensorn kunna styra fläkten beroende på temperaturen om man skulle önska att vidareutveckla projektet. 

Uppskattad tid för att sätta upp hårdvara och mjukvara och skriva kod beror på användarens erfarenheter men utan förkunskaper inom IoT och hårdara är det en del att sätta sig in i gällande det. Tid sätts därför till 30-40 timmar och då inkluderas tid för att inhämta növändig information som krävs. 

**Mål**

Själva enheten skapades för att ge en förståelse för IoT och hur IoT fungerar tekniskt. Projeket är gjort av en novis inom området och är enkelt att genomföra för någon utan erfarenhet. Det ger en grund inför fortsatta projekt och kan utvecklas vidare med andra sensorer eller annan apparatur. Tanken är också att ge grundläggande kunskaper för att kunna använda andra plattformar och protokoll som är mer avancerade. 

**Material**

Samtliga produkter köptes via Elektrokit. Startpaketet för kursen köptes men det var bara vissa delar som användes i projektet. Vilka delar som ingår går att se i Tabell 1 nedan. Totala kostnaden för paketet var 1024:-, inklusive frakt. Enligt specifikationen kostade inte produkterna från Pycom något. 

*Tabell 1. Förteckning över använda delar i projektet*
| Enhet                                                | Pris    |
| ---------------------------------------------------- | ------- |
| Kopplingsdäck 400 anslutningar                       | 47,20:- |
| Pycom - Antennae                                     | 0:-     |
| Pycom - Expansion board                              | 0:-     |
| Pycom - Lopy4 with headers                           | 0:-     |
| MCP9700 TO-92 Temperaturgivare                       | 6,40:-  |
| Kopplingstråd byglar för kopplingsdäck - mjuka 65 st | 28,80:- |
| USB-kabel A-hane - micro B 5p hane 1.8 m             | 31,20   |

Lopy4 går att ansluta till WiFi/LoRa/SigFox eller Bluetooth, har en kraftfull CPU och är energisnål vilket gör den till en väldigt användbar enhet inom IoT. Den programmeras med Micropython och har analoga samt digitala pins (https://docs.pycom.io/gitbook/assets/specsheets/Pycom_002_Specsheets_LoPy4_v2.pdf). Till denna används Pycoms Expensionboard för att koppla samman Lopy4 till datorn vilket görs med micro-USB. Det finns även möjlighet att ge ström via batterier som kan laddas om enheten är ansluten med USB-kabeln.  (https://docs.pycom.io/gitbook/assets/expansion3-specsheet-1.pdf). 
Kopplingsdäck 400 anslutningar är en så kallad "breadboard" och denna används till lödfria uppkopplingar. Hålen är förbunda fem och fem, det vill säga samtliga hål på en rad (a-e eller f-j) (https://www.electrokit.com/produkt/kopplingsdack-400-anslutningar/) vilket eventuellt tydligare kan förstås genom att se i Figur 4 längst ned i dokumentet där jag satt sensorn så att varje pin enbart sitter på a-raden. 
Antennen används för att ansluta till LoRa och är egentligen inte nödvändig för just detta projekt då enbart WiFi används men den måste vara ikopplad om LoRa är tänkt att användas då PyCom menar att Lopy4 annars riskeras att skadas. 

Temperaturgivaren är en analog sensor som omvandlar temperatur till analog spänning. Voltage Output Pin (VDCout) kan kopplas direkt till ADC-pin på Pycomenheten. Vid 0 grader fås en spänning på 500 milliVolt vilket gör det enkelt att räkna ut grader utifrån antal milliVolt (https://www.mouser.com/datasheet/2/268/20001942F-461622.pdf).
Kopplingtrådarna används till att koppla samman sensorn med Pycomenheten. Dessa som ingick i projektet var av samma längd men det finns även färdiga i olika längder eller möjlighet att klippa egna trådar av olika längder om det föredras. 
USB-kabeln används för att ansluta Pycomhenheterna till datorn. I detta projekt krävs sladden då inget batteri införskaffats och tanken är inte att enheten ska vara på någon annan plats än vid datorn. 

**Datorinställningar**

För att starta upp projektet följdes stegen på Pycoms hemsida. Hjälp togs även av kursens instruktionsvideor. Initialt kopplades antennen, Lopy4-enheten samt expansionsboarden ihop. Enligt instruktionerna skulle firmware på expansionboarden uppdateras som första steg vilket inte lyckades att genomföra. Detta berodde tydligen på en bugg vid användandet av Mac OS. I och med att Pycom menade att firmware sannolikt skulle vara uppdaterat hoppades detta steg över. 

Som IDE användes Visual Studio Code (VS Code), vilket redan fanns installerat på datorn då jag brukar använda den som IDE. PyMakr-pluginet installerades enligt instruktioner på Pycoms hemsida. 

En mapp skapades sedan för projektet och den öppnades i VS Code där filer skapades enligt den struktur som Pycom anger. En boot-fil skapades men ingen kod finns i den då det inte rekommenderas att den används av nybörjare men om projektet ska utvecklas med tiden finns möjlighet att lägga kod i den filen. 

Sedan startades ett konto på Pybytes och ett projekt skapades. Enheten kopplades sedan till detta projekt och inställningar för WiFi och LoRa skapades. En kanal för att spara data skapades också. Via Pybytes uppdaterades firmware för Lopy4. 

**Vald IDE**

Programmering av Lopy4 gjordes via VS Code. Node.js fanns redan installerat på datorn och inga andra installationer var nödvändiga. Genom att trycka på "upload" i VS Code fördes koden över till Lopy4 vilket var nödvändigt för att uppdateringar i koden skulle köras. 

**Koppla ihop hårdvara**

I Figur 1 nedan visas hur enheten kopplats ihop. Genom att läsa datasheet för Lopy4 valdes en Pin som var lämplig för en analog sensor. Den svarta rektangel längst upp ska demonstrera sensorn. Den lila kabeln går från Pin 20 till VOUT, den röda från 3V3 till VDD och den lila från GND till GND. Antennen är kopplad till porten för LoRa samt SigFox (868MHz/915MHz) då tanken initialt var att använda LoRa. Då projektet bygger på WiFi är antennen inte nödvändig men den har fått vara kvar ändå. För att underlätta kopplingen användes en breadboard. Enheten ansluts till datorn via micro-USB. Enligt datasheet för sensorn ska volt ligga mellan 3,3-6 volt och därför behövs ingen resistor. Tanken är inte att enheten ska användas komersiellt utan som ett hemmaprojekt för att få praktisk grundkunskap om IoT.

*Figur 1*. Kretsdiagram
![](https://i.imgur.com/E5SWz33.png)

**Plattform**

Data skickas till plattformen Pybytes. Plattformen är kostnadsfri och cloudbaserad. En dashboard kan enkelt skapas som visar data grafiskt med hjälp av valda widgets. Det går även att uppdatera Lopy4 och att skicka notiser. Om projektet ska utvecklas och om man önskar öka sin kunskap inom databashantering och dataöverföring skulle exempelvis Ubidots och Grafana kunna användas. 

**Kod**

Nedan ses koden skriven i Micropython. Den går även att hitta på https://github.com/snurrbo/iot-temperature-sensor.
Förklaring till koden kan ses i kommentarerna men i stort sett sker inläsning av temperatur, sändning av temperaturvärde till pybytes, utskrift till terminalen samt ändring av färgen på LED beroende på temperaturen. 

```*.py=1

import time
import machine
import pycom
import lib.mcp9700

#Create instance of class MCP9700
temp_sensor = MCP9700()

#Reading the temperatur and sending data is placed in a while loop
#since we want to do this repeaditly. First we create a variable which 
#holds the temperature from the sensor. Then there's a inner while loop
#that only executes if the sensor hasn't a valid value, otherwise the outer 
#while loop continues and the data are send to Pybytes, the LED switches color 
#and last the unit wait for 30 seconds until the loop continues. 
while True:
    temp_value = temp_sensor.read_print()
    while not temp_value.input_is_valid():
        time.sleep(1)
        temp_value = temp_sensor.read_print()
    pybytes.send_signal(2, temp_value.degree_celsius)
    temp_sensor.color_switcher(temp_value.degree_celsius)
    time.sleep(2)
    pycom.heartbeat(False)
    time.sleep(30)


import machine
import pycom

class MCP9700Result:

    NO_INPUT = 0
    VALID_INPUT = 1

    error = VALID_INPUT
    degree_celsius = 0

    #Constructor for the class that is created when a temperature is read 
    def __init__(self, error, degree_celsius):
        self.error = error
        self.degree_celsius = degree_celsius

    #Method that confirmes a valid temperature value
    def input_is_valid (self):
        return self.error == MCP9700Result.VALID_INPUT

  
class MCP9700:

#Constructor that's called in main when a object of MCP9700 is created
#machine.ADC() is called since the sensor is a analog sensor. 
def __init__(self):
    adc = machine.ADC()
    self.analogTempPin = adc.channel(pin='P20')
    pycom.heartbeat(False)

#Method that reads value and print value to the terminal. If the sensor
#doesn't detect anything a object with error NO_INPUT is returned to main
#and the inner loop in main continues until the sensor detects a valid value. 
#If the sensor detects voltage it is converted to celsius, prints the voltage 
#and the degrees in celsius to the terminal and returns a object with the result 
#to main. 
def read_print(self):

    milli_volts = self.analogTempPin.voltage()

    if milli_volts == 0:
        return MCP9700Result(self.NO_INPUT, 0)
    else:
        degree_celsius = (milli_volts - 500.0) / 10.0
        print(milli_volts)
        print(degree_celsius)
        return MCP9700Result(MCP9700Result.VALID_INPUT, degree_celsius)

# Method that switches the color of the LED on the Lopy4 depending
# of the temperature.      
def color_switcher(self, degree_celsius):

if degree_celsius <=23.0:
    pycom.rgbled(0xe60099)
elif degree_celsius >=23.1 and degree_celsius <23.8:
    pycom.rgbled(0x32a8a2)
elif degree_celsius >=23.8:
    pycom.rgbled(0xa89c32)

```

**Överföring av data / anslutning**

Data överförs via WiFi till plattformen Pybytes. Värdet sparas som en float och skickas som enskilda värden var 30:e sekund. Intervallet för hur ofta data sänds går enkelt att ändra i koden och det skulle kunna gå att skapa en array med värden som skickas istället för att skicka ett värde i taget men för syftet med projektet räcker det med enskilda värden. Pybytes använder transportprotokollet MQTT. För att föra över data behöver nätverket som används anges på plattformen. Där behöver man även definiera en signal för att koppla den till data som överförs. Detta kan göras innan eller efter att kod för överföring skapats. Genom att dessa steg kan göras via plattformen är det väldigt enkelt och lätt att förstå hur man ska göra även om man är nybörjare inom området. Man måste även lägga till enheten som används vilket kan göras via micro-USB eller via Pybytes app. 


**Presentation av data**

Temperaturvärdena visas genom en dashboard på Pybytes. Pybytes valdes då den var enkel att förstå och var tillräcklig för syftet med projektet. Dashboarden visar temperaturen numeriskt i tabellform samt grafiskt i ett linjärt diagram. Den visar även var enheten befinner sig samt när data mottagits den senaste timmen samt det senaste dygnet. Figur 2 nedan visar hur dashboarden ser ut. Data skickas var 30:e sekund och sparas därför var 30:e sekund. Eftersom ingen egen databas används utan Pybytes egen databas är det deras principer för lagring av data som avgör hur länge data sparas. I Pybytes går det att välja på olika tabellformat för att presentera data. För detta projekt som ska visa temperaturer anses ett linjärt diagram ge tydligast bild över förändringar i temperaturen. I Figur 3 visas hur dashboarden ser ut. 

*Figur 2*. Dashboard på Pybytes
![](https://i.imgur.com/1PZRIy8.png)

**Finalizing the design**

I Figur 3 visas en bild av enheten och hur den kopplat ihop. De praktiska delarna med programmering och sammansättning av hårdvara gjordes gemensamt med en vän som läser samma kurs. Vi har båda kunskaper inom programmering sedan tidigare men ingen kunskap inom hårdvara. Det var mycket att sätta sig in i och då stor del av tiden gick åt till att skapa förståelse och läsa på om alla nya begrepp och tekniker blev valet av projekt ett enkelt sådant. Vi hade velat skapa notiser som skickades till mobilen för att få lite mer nytta av datan men vi hade inte riktigt tid till det. Vår tanke med att läsa kursen var dock att få basala kunskaper om vad IoT är och inte att göra ett avancerat projekt och jag tycker att det har uppnåtts. Som det går att se på den widget som visar temperaturen i tabellform (Figur 2) anges den med väldigt många decimaler vilket ger ett rörigt intryck. Att bara ha med en eller två decimaler skulle varit tydligare vilket är något vi hade kunnat göra annorlunda. Det hade också varit roligare om vi hade skickat notiser eller meddelanden om temperaturen för att göra projektet lite mer intressant och användbart. 

*Figur 3*. Samtliga använda delar - slutresultat
![](https://i.imgur.com/e2Om9Xo.jpg)


