---
# System prepended metadata

title: Tutorial till temperaturmätning

---

# Tutorial till temperaturmätning

Adam Eriksson 
Ae224ae

# Intro
Jag och en vän gjorde detta projekt tillsammans och hjälptes åt att sätta upp enheten. I den här tutorialen kommer jag gå över hur man på ett simpelt sätt sätter upp en Pycom enhet med en temperatursensor och hur man skickar över relevant data till Pybytes.

För någon som är helt ny till detta så tar det självklart längre tid. För en  nybörjare skulle jag uppskatta att det tar ungefär 30-40 timmar och om du har lite erfarenhet skulle det ta betydligt mindre tid.

# Mål
Vi ville sätta upp enheten på ett sätt som låter den skicka över temperaturvärden till en databas och sedan lagra dessa värden för att visas i exempelvis grafer och tabeller.

Vi valde detta projekt eftersom det kändes som ett enkelt och relevant sätt att sätta in sin fot i IoT.
Detta kommer fungera som ett projekt som hjälper en person att enkelt förstå hur IoT fungerar och hjälper en att gå över till mer komplicerade projekt i framtiden.

# Material
Produkterna nedan köptes via Elektrokit. Vi köpte startpaketen som rekommenderades, dock så används inte allt. Det som används är listat i tabellen nedan. 
Totala kostnaden blev 1024:-

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   |

Kopplingsdäcket med 400 anslutningar är ett breadboard som används för lödfria uppkopplingar.

Lopy4 är enheten som kopplas till datorn. 
Expansionboarden används för att koppla Lopy4 till datorn.
För att koppla in dem i datorn så används microusb.
Antennen används för att ansluta till LoRa vilket vi inte gör i detta projekt.

Temperaturgivaren är en analog sensor som omvandlar temperatur till analog spänning.

# Datorsetup och kod
Vi började med att lyssna på föreläsningen och kolla på instruktionsvideorna för att få en insikt i hur vi ska börja. Efteråt så laddade vi ner Visual Studio Code. Vi valde Visual Studio Code eftersom vi båda har lite erfarenhet inom det. Därefter tog vi hjälp av pycoms hemsida för att kunna få igång enheten. När vi väl fått igång enheten och kopplad ihop den med datorn så var det bara att börja koda. Koden är uppladdad på github.

# Enhetsuppsättning
Nedan är ett kretsdiagram som förklarar hur vår enhet är kopplad.

Här är ett kretsdiagram på vår enhet:
![](https://i.imgur.com/qkNFqEc.png)

# Platform
Vi valde oss att använda oss av Pybytes. Vi såg att Fredrik använde sig av det när han visade hur man överför data och vi kände att det kändes som en relevant sida att använda sig av. Vi har inte provat olika och kan därför inte jämföra dem.

Pybytes är en cloudbaserad gratistjänst som fungerade perfekt för ett litet projekt som detta. Som tidigare nämnt har vi inte provat några olika och kan därför inte ge en översikt över de för- och nackdelar en betald och gratistjänst har.

Pybytes fungerar felfritt för vårt projekt. Det går enkelt att skicka data till Pybytes där man enkelt kan visa datan visuellt med hjälp av exempelvis grafer.

# Vår kod

Här under är ligger vår kod. Vi har även kommenterat i koden.
Det här är vår main
```*.py=1
# Import the libraries that are recuired
import time
import machine
import pycom
#from mcp9700 import MCP9700, MCP9700Result
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)    
```

Det här är vår MCP9700
```*.py=1

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 <=26.0:
            pycom.rgbled(0xe60099)
        elif degree_celsius >=26.1 :
            pycom.rgbled(0x32a8a2)
        elif degree_celsius >=26.8:
            pycom.rgbled(0xa89c32)
```

# Hur allting fungerar
Som tidigare nämnt använder vi oss av pybytes. Datan skickas till pybytes via WiFi. Transportprotokollen som pybytes använder sig av är MQTT.
Datan skickas var trettionde sekund och sparas varje gång. Tyvärr så vet vi inte hur länge datan sparas i Pybytes.

Dashboarden visas de senaste värdena i en tabell, tre diagram och även en platskarta.

Här är en bild på vår dashboard:
![](https://i.imgur.com/B8XnvkY.png)

# Avslut
Vi tyckte att projektet gick väldigt bra. Det var en väldigt trög start eftersom det är ett helt nytt område man hoppar in i. Hur kopplar man ihop enheten? Vad betyder allting? Men när man väl fick svar på dessa frågor så gick det snabbt framåt. Eftersom både jag och Gisela har erfarenhet inom kodning så var den delen enkel. Nu i efterhand så ser man självklart vad det är som skulle kunnat förbättrats. Det skulle kunna vara att få in fler varierande värden och en klarare dashboard.

Här har vi en bild på hur enheten ser ut helt färdig!
![](https://i.imgur.com/KzCEe9z.png)

