Raspberry Pi temperatur logger med database og webgrensesnitt med grafer.

[SvenniX]

Kjære lesere på dette forum, jeg trenger deres hjelp!

 

Jeg ønsker å sette opp en raspberry pi med 4 tilhørende temperatursensorer som logger temperaturen fra hver enkelt sensor hvert x sekund/minutt inn til en database. De 4 sensorene skal kunne gjenkjennes i databasen med at de har fått et valgfritt id/navn. Sammen med dette skal det også loggføres med klokkeslett. Databasen vil se omtrent slik ut:

Klokke/dato        id     Temp
12:00 01.01.2017   Ute1   29,6
12:00 01.01.2017   Ute2   19,4
12:00 01.01.2017   Inne1  18,5
12.00 01.01.2017   inne2  17,9
12.01 01.01.2017   Ute1   29,5
12.01 01.01.2017   Ute2   19,3
12.01 01.01.2017   Inne1  18,4
12.01 01.01.2017   Inne2  17,8

Det er altså 3 felt jeg ønsker i min database. Klokkeslett og dato,  id som jeg selv kan definere pr sensor og selvfølgelig temperaturen. Jeg har veldig lite erfaring med databaser, så det kan godt hende dette er mye mer avansert å få til enn det jeg forestiller meg.  

 

Jeg skal kunne navngi de ulike sensorene som jeg selv ønsker og stille inn intervallet mellom hver gang data skal lagres. Dette regner jeg da med kan gjøres i koden og trenger ikke ha noe fancy knapp og grafisk program for dette. Jeg regner med at når jeg først finner et passende ID og tidsintervall skal ikke dette endres ofte.

 

Når dette er gjort er neste steg å få dette grafisk fremvist via en graf på en webside der det skal være mulig å trykke av for hvilke sensor man vil se, 1,2,3 eller alle samtidig i grafen med ulike farger for å skille sensorene. Og velge tidsintervallet grafen skal fremstille fra databasen. Feks: Siste 24 timer, Siste 4 timer, Siste 7 dager osv...

 

I utgangspunktet har jeg tenkt å bruke en Raspberry pi til dette. Men om dette er et dårlig valg og det finnes bedre/enklere løsninger er jeg veeeeldig åpen for idër. Sensoren jeg skal bruke er jeg også åpen for. Men jeg har en del DS18B20 sensorer jeg primært ønsker å bruke. Jeg har også flere fullverdige servere stående hjemme, så om databasen og/eller webserveren burde flyttet hit er det også en mulighet.

 

Jeg har søkt rundt flere dager på nettet og funnet en hel haug med guides, men ingen fyller helt de kravene jeg ønsker ,og de fleste bruker også betalte websider eksternt for å vise grafene. Men igjen, hvis noen sitter på noen linker som kan være hjelpende så tar jeg gjerne imot.

 

Jeg ser for meg 3 steg i dette prosjektet. Det første steget er å hente ut temperaturen fra sensorene. Her er jeg ganske nærme mål og har klart å lage et python script som henter ut fra en sensor. Steg 2 vil være å putte data fra sensorene inn i databasen. Her er jeg ganske blank. Og siste steg er å få fremvist dette på en graf gjennom en webside. 

 

Jeg forventer ikke at noen skal smøre isammen en hel kode til meg, ønsker heller ikke dette da jeg får ikke stort utbytte av lærdom av det. Men om noen kan sparke meg i riktig retning på alle de ulike feltene, og kanskje litt senere hjelpe meg å sy ting sammen ville det vært ekstremt bra. Til slutt når alt fungerer som det skal skal jeg sette sammen en fullverdig "dummies guide" og publisere her på forumet. Dette er noe jeg kan se for meg kan være aktuelt for flere. Bruksområde for dette prosjektet er et ølgjærings-kjøleskap jeg ønsker å ha full oversikt over temperaturene.

 

Håper på positive svar! :-) 

 

 

[Gavekort]

Jeg synes ikke at Raspberry Pi er helt verktøyet for denne oppgaven. Det jeg foreslår er at du setter opp en Raspberry Pi med en Mosquitto-server, og kjøper deg inn noen NodeMCU til hvert rom, og finner kode for MQTT. Da har du plutselig et lite fundament for et smarthjem også.

[tingo]

Har du vurdert "ferdige" løsninger som for eksempel Home Assistant? Kjører på en Raspberry Pi (eller annen SBC med Linux på), gir deg et web-basert grensesnitt, du får grafer på sensorer, og du kan også få til styring som Gavekort nevner.

[Hårek]

Det er ikke behov for en database, det blir unødig komplisert. Det eneste du trenger er en loggfil hvor du lagrer på en strukturert måte. 

Jeg bruker en Arduino for å lese 16 stk DS1820 sensorer, den sender data til en PC over en UDP socket.

På PC kjører jeg et C# program som lagrer data. Her lager jeg en folder for hvert årstall, som inneholder en folder for hver måned, som inneholder en tekstfil for hver dag.

Tekstfilen har en linje for hver avlesning, med klokkeslett, sensor ID, og temperatur. 

Visningsprogrammet leser så disse filene og tegner grafer.

[SvenniX]

Jeg synes ikke at Raspberry Pi er helt verktøyet for denne oppgaven. Det jeg foreslår er at du setter opp en Raspberry Pi med en Mosquitto-server, og kjøper deg inn noen NodeMCU til hvert rom, og finner kode for MQTT. Da har du plutselig et lite fundament for et smarthjem også.

Jeg glemte kanskje å nevne det, men samtlige sensorer skal være koblet til 1 Raspberry Pi og alle sensorene skal være i samme rom, så trenger ikke flere noder. Men ingen dum idè uansett! Selvlaget smarthus løsninger er neste prosjekt, så jeg skal notere meg NodeMCU  

 

Har du vurdert "ferdige" løsninger som for eksempel Home Assistant? Kjører på en Raspberry Pi (eller annen SBC med Linux på), gir deg et web-basert grensesnitt, du får grafer på sensorer, og du kan også få til styring som Gavekort nevner.

Dette er absolutt noe som kan være aktuelt! Jeg har sett flere "ferdig" løsninger, men litt av poenget her var å lære noe ut av dette. Mer enn bare installere et software også vips fungerer alt. Men denne løsningen er veldig fristende til å teste ut litt.  En annen grunn til at jeg har vært fravikende fra ferdigløsninger er at de skal ha penger for alt. Men her ser jeg at det er open-source, så det er pluss i boka! Takk for linken, dette skal jeg se nærmere på! Men er ikke løsningen på det originale prosjektet her (Med mindre det blir super avansert og vanskelig)

 

Det er ikke behov for en database, det blir unødig komplisert. Det eneste du trenger er en loggfil hvor du lagrer på en strukturert måte. 

Jeg bruker en Arduino for å lese 16 stk DS1820 sensorer, den sender data til en PC over en UDP socket.

På PC kjører jeg et C# program som lagrer data. Her lager jeg en folder for hvert årstall, som inneholder en folder for hver måned, som inneholder en tekstfil for hver dag.

Tekstfilen har en linje for hver avlesning, med klokkeslett, sensor ID, og temperatur. 

Visningsprogrammet leser så disse filene og tegner grafer.

Jeg var veldig usikker på om database var nødvendig eller ikke, men om du klarer deg uten med 16 sensorer bør jeg overleve med mine 4 Har du lyst til å sparke meg litt i riktig retning med tanke på Arduino (som jeg har brukt vesentlig mindre enn Raspberry PI) og avlesning fra sensorene. Og ikke mist sende disse til en pc/server? Det hadde vært til stor hjelp!  

[Hårek]

Jeg bruker en Arduino Uno og Ethernet shield. Det får du for en hundrelapp fra Kina.

Her er en god innføring: https://create.arduino.cc/projecthub/TheGadgetBoy/ds18b20-digital-temperature-sensor-and-arduino-9cc806

Kode:

 

/********************************************************************
  Using Arduino-Temperature-Control-Library-master

  Arduino is a TCP server. It has a fixed IP
********************************************************************/

// First we include the libraries
#include <OneWire.h> 
#include <DallasTemperature.h>
#include <SPI.h>
#include <Ethernet.h>

#define TEMP_HUB_NO       2             // Two devices in use, one for development

#define ONE_WIRE_BUS1     2             // Data wire is plugged into pin 2 on the Arduino
#define ONE_WIRE_BUS2     3             // Data wire is plugged into pin 3 on the Arduino
#define ONE_WIRE_BUS3     5             // Data wire is plugged into pin 5 on the Arduino
#define ONE_WIRE_BUS4     6             // Data wire is plugged into pin 6 on the Arduino
#define ONE_WIRE_BUS5     7             // Data wire is plugged into pin 7 on the Arduino
#define ONE_WIRE_BUS6     8             // Data wire is plugged into pin 8 on the Arduino

#define NOOFBUSES         6             // Number of buses
#define MAX_SENSORS       5             // Max expected on one bus
#define ROM_ID_LENGTH     8             // ROM = 8 bytes

#define BINPROC_HEADER    6             // Length of header

#if TEMP_HUB_NO == 1
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x10 };
IPAddress ip(192, 168, 0, 222);                 // My fixed IP address
#else
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0x11 };
IPAddress ip(192, 168, 0, 223);                 // My fixed IP address
#endif
EthernetServer server = EthernetServer(33666);  // Setup as server on this port
EthernetClient client;
boolean isConnected = false;

OneWire oneWire1(ONE_WIRE_BUS1);        // Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire2(ONE_WIRE_BUS2);        // Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire3(ONE_WIRE_BUS3);        // Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire4(ONE_WIRE_BUS4);        // Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire5(ONE_WIRE_BUS5);        // Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire6(ONE_WIRE_BUS6);        // Setup a oneWire instance to communicate with any OneWire devices
DallasTemperature sensors[NOOFBUSES];

int devCount[NOOFBUSES];                    // Number of sensors found on each bus
uint8_t romBuf[NOOFBUSES][MAX_SENSORS][ROM_ID_LENGTH];
float temperature[NOOFBUSES][MAX_SENSORS];
char msg[100];
byte receiveMsg[100];
int receiveIndex;

/********************************************************************/ 
void setup(void) 
{ 
    Serial.begin(9600); 
    Serial.println("DS1820 Hub v1");
    setupEthernet();
    DallasSetup();

    for (int bus = 0; bus < NOOFBUSES; bus++) {
        showRom(bus, sensors[bus]);
    }
    sprintf(msg, "int %d, long %d", sizeof(int), sizeof(long));
    Serial.println(msg);
} 

void loop(void) 
{ 
    client = server.available();
    if (client && !isConnected) {
        Serial.println("Client connected");
        isConnected = true;
    }

    if (client.connected() && client.available()) {
        receiveCharacter();
    } 

/*    if (isConnected && !client.connected()) {     dette fungerer ikke, 
        Serial.println("Client not connected");
        isConnected = false;      
    }*/   
} 

void showRom(int bus, DallasTemperature sensors) {
    sprintf(msg, "Device count %d = %d", (bus + 1), devCount[bus]);
    Serial.println(msg);
/*    if (devCount[bus] > 0)
    {
        for (int n = 0; n < devCount[bus]; n++)
        {
            sprintf(msg, "ID %d:   %02x %02x %02x %02x %02x %02x %02x %02x", n + 1,
                  romBuf[bus][n][0], romBuf[bus][n][1], romBuf[bus][n][2], romBuf[bus][n][3], 
                  romBuf[bus][n][4], romBuf[bus][n][5], romBuf[bus][n][6], romBuf[bus][n][7]);
            Serial.println(msg);
            delay(100);
        }
    } 
    Serial.println();*/ 
}

/*************************************************************************************
 *  Dallas library commands
 *  validAddress()
 *  requestTemperatures()
 *  getTempC()
 *************************************************************************************/
 bool DallasValidAddress(int busIndex, int sensorIndex) {
    return sensors[busIndex].validAddress(&romBuf[busIndex][sensorIndex][0]);   // Check CRC
 }             

 void DallasRequestTemperatures(int busIndex) {
    unsigned long time1, time2;  
    time1 = millis();
    sensors[busIndex].requestTemperatures();        // Send the command to get temperature readings
    time2 = millis();
    sprintf(msg, "Time %d", (time2 - time1));
    Serial.println(msg);
}             

float DallasGetTempC(int busIndex, int sensorIndex) {
    return sensors[busIndex].getTempC(&romBuf[busIndex][sensorIndex][0]);            
}

/*************************************************************************************
 *  Setup for Ethernet
 *  subnet defaults to 255.255.255.0 
 *************************************************************************************/
void setupEthernet() {
    Ethernet.begin(mac, ip);          // start the Ethernet, fixed IP
    server.begin();                   // start listening for clients
}

/*************************************************************************************
 *  Initialize OneWire buses
 *  begin()
 *  getDeviceCount()
 *  getAddress()
 *************************************************************************************/
void DallasSetup() {
    sensors[0] = DallasTemperature(&oneWire1);
    sensors[1] = DallasTemperature(&oneWire2);
    sensors[2] = DallasTemperature(&oneWire3);
    sensors[3] = DallasTemperature(&oneWire4);
    sensors[4] = DallasTemperature(&oneWire5);
    sensors[5] = DallasTemperature(&oneWire6);

    resetRomIdData();                                       // Clear old data
    for (int bus = 0; bus < NOOFBUSES; bus++) {
        sensors[bus].begin();                               // initialise bus
        devCount[bus] = sensors[bus].getDeviceCount();      // find number of devices on bus
        for (int n = 0; n < devCount[bus]; n++) {
            sensors[bus].getAddress(&romBuf[bus][n][0], n); // Collect array of ROM data from device
        }  
    }  
}

void resetRomIdData() {
    for (int bus = 0; bus < NOOFBUSES; bus++) {
        devCount[bus] = 0;
        for (int s = 0; s < MAX_SENSORS; s++) {
            for (int k = 0; k < ROM_ID_LENGTH; k++) {
                romBuf[bus][s][k] = 0;                  // Clear old data                                  
            }
        }
    }  
}

    typedef struct {
        uint8_t  sof;           // Start of message (SOM), 0xAA.
        uint8_t  cmd;           // Command
        uint8_t  busIndex;
        uint8_t  sensorIndex;
        uint16_t length;        // Length of message
    } messageB_t;

    typedef enum {
        CMD_PING = 1,
        CMD_INITIALIZE,
        CMD_GETSENSORCOUNT,
        CMD_GET_ROMID,
        CMD_CHECK_ADDRESS,        
        CMD_COLLECT_TEMPERATURE,
        CMD_GET_TEMPERATURE,
        CMD_TEST
    } commands_e;

  static const uint8_t SOF    = 0xAA;
  static bool rxHeader = true;
  static messageB_t rxMessage;



int receiveCharacter() {
    char c = client.read();
    receiveMsg[receiveIndex++] = c;
    //sprintf(msg, "%02x", c);    Serial.print(msg);
    
    int dataLen = 0;  
    if (rxHeader && receiveIndex >= BINPROC_HEADER) {
        dataLen = decodeCommand(receiveMsg);
        if (dataLen > 0) {
            rxHeader = false;
        }
        receiveIndex = 0;
    } else if (!rxHeader && receiveIndex >= rxMessage.length) {
        Serial.println("Data received OK");
        rxHeader = true;
        receiveIndex = 0;        
    }
}

// Decode message, return data langth
int decodeCommand(byte *message) {   
    float tempF;
    byte reply1[1];
    byte reply2[ROM_ID_LENGTH];
    byte reply3[2];                           // sizeof(int)
    int tempI;
    bool tf;
    
    //sprintf(msg, "Msg: %02x %02x %02x %02x ", message[0], message[1], message[2], message[3]);     Serial.println(msg);
    rxMessage.sof         = message[0];
    rxMessage.cmd         = message[1];
    rxMessage.busIndex    = message[2];
    rxMessage.sensorIndex = message[3];
    rxMessage.length      = (message[4] << 8) + message[5];
    
    if (rxMessage.sof != SOF) {
        Serial.println("Wrong command format");
        return 0;
    }

    //sprintf(msg, "Command %d. Length %d", rxMessage.cmd, rxMessage.length);  Serial.println(msg);
    switch (rxMessage.cmd) {
        case CMD_PING: 
            sendReplyHeader(CMD_PING, 0);
            break;

        case CMD_INITIALIZE: 
            sendReplyHeader(CMD_INITIALIZE, 0);
            DallasSetup();                                  // Full initialisation
            break;

        case CMD_GETSENSORCOUNT:                            // Get number of sensors on specified bus
            sendReplyHeader(CMD_GETSENSORCOUNT, 1);         // Send header
            reply1[0] = (byte)devCount[rxMessage.busIndex]; // Data comes from DallasSetup()
            server.write(reply1, 1);                        // Send reply       
            break;
                
        case CMD_GET_ROMID:                                 // Get ROM ID for specified sensor/bus
            sendReplyHeader(CMD_GET_ROMID, ROM_ID_LENGTH);  // Send header
            for (int n = 0; n < ROM_ID_LENGTH; n++) {       // Data comes from DallasSetup()
                reply2[n] = (byte)romBuf[rxMessage.busIndex][rxMessage.sensorIndex][n];
            }
            server.write(reply2, ROM_ID_LENGTH);            // Send reply       
            break;

        case CMD_CHECK_ADDRESS: 
            sendReplyHeader(CMD_CHECK_ADDRESS, 1);
            reply1[0] = (byte)DallasValidAddress(rxMessage.busIndex, rxMessage.sensorIndex);
            server.write(reply1, 1);                        // Send reply       
            break;

        case CMD_COLLECT_TEMPERATURE: 
            sendReplyHeader(CMD_COLLECT_TEMPERATURE, 0);
            DallasRequestTemperatures(rxMessage.busIndex);    // Send the command to get temperature readings
            break;

        case CMD_GET_TEMPERATURE: 
            sendReplyHeader(CMD_GET_TEMPERATURE, 2);
            tempF = DallasGetTempC(rxMessage.busIndex, rxMessage.sensorIndex);         
            tempI = (int)(tempF * 10);
            reply3[0] = (byte)(tempI >> 8);
            reply3[1] = (byte)(tempI & 0xff);
            server.write(reply3, 2);                          // Send reply       
            break;

        case CMD_TEST: 
            sendReplyHeader(CMD_TEST, 0);
            //tf = sensors[rxMessage.busIndex].readPowerSupply(&romBuf[rxMessage.busIndex][rxMessage.sensorIndex][0]);    needParasite = 0
            sprintf(msg, "CMD_TEST %d  %d = %d", rxMessage.busIndex, rxMessage.sensorIndex, sensors[rxMessage.busIndex].getResolution());
            Serial.println(msg);
            break;

        default: 
            Serial.print("Undefined command ");
            Serial.println(rxMessage.cmd);
            break;
    }
    //Serial.println("-----------");
    return rxMessage.length;
}

            //sprintf(msg, "CMD_COLLECT_TEMPERATURE %d", rxMessage.busIndex);
            //Serial.println(msg);

void sendReplyHeader(byte cmd, int length) {
    byte txbuff[BINPROC_HEADER];
     
    txbuff[0] = SOF;
    txbuff[1] = cmd;
    txbuff[2] = 0;
    txbuff[3] = 0;
    txbuff[4] = (length >> 8);
    txbuff[5] = (length & 0xff);
    server.write(txbuff, BINPROC_HEADER);
}

 

[SvenniX]

Nå er det lenge siden jeg har oppdatert denne posten, beklager det!

 

Men nå har jeg lest meg opp en del på Arduino og har satt sammen 2 ulike koder som jeg kan bruke for å overføre temperaturdata fra sensor til server. Jeg har konkludert med å overføre data over seriell kommunikasjon, dvs gjennom USB-kabelen tilkoblet Arduino. Så oppsettet mitt vil være å ha en liten datamaskin (Fysisk størrelse liten) som driver en database og en webserver. Denne datamaskinen har tilkoblet en Arduino som igjen har tilkoblet alle temperatursensorene. Arduinoen vil da pushe temp-data over USB til datamaskinene. På denne datamaskinen skal jeg lage et program som henter data fra seriellporten og legge disse inn i databasen.

 

Der jeg er nå: Jeg har fått temp-data inn på pcen fra Arduino. Så steg 1 er ferdig.

 

Hva neste steg er: Steg 2 er å få temp-data inni databasen. Der har jeg lest litt rundt på nettet og hørt rundt med bekjente. Konklusjonen der er at jeg vil lage et program i Visual Studio som skal være gateway'en mellom seriell porten og databasen. Dette programmet skal også kunne sende kommandoer over seriell porten til Arduinoen for å kunne gjøre enkle kommandoer til den.

 

Er det noen her som har erfaring med Visual Studio og kan sparke meg i riktig retning? Jeg har liten erfaring på område, så om noen har en nettside eller guide som kan være verdt å lese, gi meg en link!

 

Så, kodene jeg har laget. Der har jeg laget to som en nesten like, og hvilke av de jeg skal bruke vet jeg ikke enda. Forskjellen på de er at den første koden sender kun over temp og id (Les: Løpenummer fra 1 til x=siste sensor). Kode nummer to legger ikke ved id-tallet med bruker plasseringen isteden. Poenget er at i databasen vil jeg har plassering beskrevet meg ord, som i eksemplet i første post (Ute1, Ute2, Inne1 osv...). Så med første koden må jeg bruke programmet som kjører på pcen til å oversette ID til plassering. Når det kommer temp-data på ID"X" må programmet har en matrise som inneholder alle ID'ene og hvilke plassering hver av de har. Så feks ID1 er Ute1. Slik at når programmet sender data til databasen vil den oversette ID1 til Ute1. Hvor det er enklest å legge til plassering ser jeg nok når jeg oppretter programmet som skal kjøre på datamaskinen.

 

Kode 1:

 

#include <OneWire.h> 

#include <DallasTemperature.h>

 

const byte SensorPin = (10);     //Hvilken pinne er sensorene koblet til

const byte LoggTime = (10);      //Hvor ofte skal temperaturen logges i sekunder

 

OneWire oneWire(SensorPin); 

DallasTemperature sensors(&oneWire);

 

void setup(void) {  

 Serial.begin(9600); 

 sensors.begin();  }

 

void loop(void) {

  sensors.requestTemperatures(); 

  for (byte i=0; i<sensors.getDeviceCount(); i++) {

    Serial.print(sensors.getTempCByIndex((i))); 

    Serial.print(" ; ") ;

    Serial.println((i+1));

    delay(300); } 

delay(LoggTime*1000); }

 

Output på seriell med kode 1

17.37 : 1

17.75 : 2

17.81 : 3

17.50 : 4

17.37 : 5

17.37 : 1

17.69 : 2

17.81 : 3

17.44 : 4

17.37 : 5

17.37 : 1

17.69 : 2

17.81 : 3

17.44 : 4

17.37 : 5

 

 

Kode 2 med plassering

 

 

#include <OneWire.h> 

#include <DallasTemperature.h>

 

const byte SensorPin = (10);           //Hvilken pinne er sensorene koblet til

const byte LoggTime = (10);            //Hvor ofte skal temperaturen logges i sekunder

 

String Plassering[] = {                //Her skal det være 1 plassering pr sensor.

  "KjøleskapOppe",                     //Plassering av Sensor 1

  "KjøleskapNede",                     //Plassering av Sensor 2

  "KjøleskapUtsiden",                  //Plassering av Sensor 3

  "GjæringSpannNede",                  //Plassering av Sensor 4

  "GjæringSpannOppe",                  //Plassering av Sensor 5

  };

 

OneWire oneWire(SensorPin); 

DallasTemperature sensors(&oneWire);

 

void setup(void) {  

 Serial.begin(9600); 

 sensors.begin();  }

  

void loop(void) { 

  sensors.requestTemperatures();

  for (byte i=0; i<sensors.getDeviceCount(); i++) {

    Serial.print(sensors.getTempCByIndex(i)); 

    Serial.println(" : "+Plassering);

    delay(300); } 

delay(LoggTime*1000); }

 

Output på seriell med kode 2

17.12 : KjøleskapOppe

17.50 : KjøleskapNede

17.56 : KjøleskapUtsiden

17.19 : GjæringSpannNede

17.12 : GjæringSpannOppe

17.12 : KjøleskapOppe

17.50 : KjøleskapNede

17.56 : KjøleskapUtsiden

17.19 : GjæringSpannNede

17.12 : GjæringSpannOppe

17.12 : KjøleskapOppe

17.50 : KjøleskapNede

17.56 : KjøleskapUtsiden

17.19 : GjæringSpannNede

17.12 : GjæringSpannOppe

17.12 : KjøleskapOppe

17.50 : KjøleskapNede

17.62 : KjøleskapUtsiden

17.19 : GjæringSpannNede

17.12 : GjæringSpannOppe

17.12 : KjøleskapOppe

17.50 : KjøleskapNede

17.62 : KjøleskapUtsiden

17.19 : GjæringSpannNede

17.12 : GjæringSpannOppe

17.12 : KjøleskapOppe

17.50 : KjøleskapNede

17.62 : KjøleskapUtsiden

17.19 : GjæringSpannNede

17.12 : GjæringSpannOppe

 

Det er primært kode 1 jeg vil prøve å bruke da denne er hel automagisk. Det vil si at man kan putte i så mange sensorer man vil, starte den opp og den vil fungere. Den vil kun spørre det antallet sensorer som er tilkoblet. Kode 2 gjør mye av det samme, men der må man legge til plasseringer etterhvert som man legge til sensorer.

[Hårek]

For hvordan du bruker SerialPort, ta et Google søk på 'c# serialport example'

 

Jeg ville ikke legge inn konfigurasjonsavhengig kode i et embedded system (Arduino). Det bør håndteres på høyere nivå.