Christoffer's hus

[Christoffer]

Etter en liten post om hjemme/borte status osv tenkte jeg at jeg kunne presentere mine løsninger her og hvilken løsning jeg har valgt på de forskjellige temaene.

 

Som system har jeg valgt Homeseer da jeg følte det passet meg bra.

 

Teknologier/protokoller:

- Z-Wave

- Zigbee

- 433 Mhz - Brukt for brytere og termperatursensorer

- Ethernet - ting som er koblet sammen via det vanlige nettverket uten å gå noen mellomledd

 

Oppsett:

Generelt

Pga hvordan vi gjør ting på jobb så har jeg blitt litt farget av det i mitt oppsett så jeg har delt opp automatikken når det kommer til lys i moder for hvert rom slik at jeg aldri stiller en lampe fra en annen event enn de som hører til det rommet. Eller manuelt så gjør jeg det manuelt i HSTouch (sjeldent nødvendig)

 

Husmoduser:

Hjemme : Da er alarmen av

Borte : Da er alarmen på, når denne blir aktivert settes alle rommene i den respektive automodusen som en slags resett på alle lysene slik at de er klare til vi kommer hjem igjen

Ferie : Denne settes manuelt

 

Døgnmoduser:

Dag : Settes enten manuelt, eller ved at solen står oppp, eller ved at full alarm blir aktivert etter et satt klokkelsett om morgenen

Natt : Settes enten manuelt, eller ved at alarmen blir satt i skallsikring etter et satt klokkeslett. Da settes også alle soverom i "Nattmodus" etter 5 minutter

 

De faste rommodusene jeg har er:

- Av : Her er alt lyset av 

- På : Her er alt lyset på

- Auto Dag : Her går alt lys på ved bevegelse stort sett eller justert ut fra lys i rommet målt med Fibaro Motion sensorer, og blir automatisk aktivert når "Døgnmodus"

- Auto Natt : Her går lyset delvis på ved bevegelse. Denne blir aktivert ved at huset blir satt i nattmodus, eller vha bryter

 

Noen rom har også andre moder:

Soverom:

Natt : Denne modusen er lyset alltid av og vil ikke bli satt i "Auto" før man enten gjør det manuelt eller ved at "Full Alarm" blir aktivert

 

Stuer

Film : Her dimmes lyset helt ned ved start av film og dimmes litt opp igjen ved pause og tilbake til tidligere status når filmen stoppes.

TV : Her blir lamper som skaper refleksjoner i TVen slått av (et kompromiss....)

 

Bad:

Auto Kveld : Blir satt etter et gitt klokkeslett hvis vi ikke allerede ha lagt oss, her vil ikke lysene rundt speilene som lyser rett mot oss slå seg på ved bevegelse. Slik at man unngår å våkne rett før man skal legge seg.

 

Hardware:

Server: Intel NUC med vPro

Z-Wave: Aeon Labs Z-stick

Zigbee: Ikea og Raspbee

433MHz: RFXtrx433e

Dimmere: Fibaro dimmere

Smarte pærer: Ikea GU10 og IKEA E14 med fargejustering

Brytere: Nexa WTE-2

Media: Raspberry Pi3 og Chromecast

Modbus: RS485 to Ethernet

Og diverse Arduino og ESP32 for testing og temperaturmåling i dataskap

 

Strømmåling:

Her bruket jeg en Deif MTR3-415 som vi bruker mye av på jobb. Denne måler spenning, strøm, kW, kVAR, THD og den har innebygde effektmålere slik at jeg lagrer data xx:59 til en database slik at jeg kan lage grafer av det. Denne kommuniserer via modbus.

 

GUI:

HSTouch på telefoner og en iPad, sjeldent i bruk da modusene stortsett passer til det vi gjør

 

Garasjeport:

Her bruker jeg en Arduino med Arduinopluginen og et relekort og har koblet opp endebrytere slik at jeg vet om den er åpen eller lukket

 

Manuell styring

Når det kommer til styring vha brytere så har jeg et fast oppsett for alle rommene bortsett fra stuen.

Standardoppsettet er som følger:

Øverst nærmest døren = Lysmodus - PÅ

Neders nærmest døren = Lysmodus - AV

Øverst lengst fra døren = Lysmodus - Auto - Her blir rett automodus satt ut fra når på døgnet det er.

Nederst lengst fra døren:

Bad = Start vifte i 30 minutter eller til fuktighetsnivå har vært over og så under satt grense

Stuer = TV

Soverom = Natt

 

 

Planer:

Koble meg på vaskemaskin for å få varsel når den er ferdig

Koble meg til tørketrommel for å få varsel når den er ferdig

Lage ferdig Arduino for tilkobling til TVer slik at de kan styres/lese status via WiFi og Arduino plugin

Lage plugin til Tibber for å lese ut timespris og dyre og billige perioder

Z-Wave termostater på varmekabler

Modbusstyring av varmepumpe (vet hvilken hardware som trengs men sliter med leverandør)

Vektsensorer under sengene for å styre lysmoduser nevnt over

Id Lock når de har lansert både lås og ny Z-Wave modul

Lekasjesensorer på utsatte steder på rør med bomullsbånd sammen med Arduino

Styring av hovedstoppekran

Styring av avtrekksvifte over komfyr vha Arduino

Komfyrvakt med Z-Wave når den en gang blir lansert

 

 

[Hr Kotelett]

Mulig å sett arduinokoden du har til garasjen? Har en nodemcu og et "arduino" rele liggende som jeg ikke har fått kommet meg igang med.

[Christoffer]

15 hours ago, Hr Kotelett said:

Mulig å sett arduinokoden du har til garasjen? Har en nodemcu og et "arduino" rele liggende som jeg ikke har fått kommet meg igang med.

Har bare brukt den vanlig sketch modusen til Arduino Pluginen og logikk i HS.

[Christoffer]

Har laget litt scripts og oppdatert "Energisiden" i HsTouch for å få oversikt over forbruket.

 

 

[Hr Kotelett]

1 time siden, Christoffer skrev:

Har bare brukt den vanlig sketch modusen til Arduino Pluginen og logikk i HS.

Tenkte mer på selve koden,  som du har lastet opp til arduinoen.

[Christoffer]

3 minutes ago, Hr Kotelett said:

Tenkte mer på selve koden,  som du har lastet opp til arduinoen.

#include <EEPROM.h>
//#include <avr/eeprom.h>


/********************************************************
  Arduino to Homeseer 3 Plugin written by Enigma Theatre.
   V1.0.0.127
 *                                                       *
 *******Do not Change any values below*******************
*/


//Global Variables
#define ISIP 1
#define BoardType 0
const byte BoardAdd = 1;
byte Byte1, Byte2, Byte3;
unsigned int Byte4, Byte5;
char* Version = "1.0.0.127";
bool IsConnected = false;
byte EEpromVersion = EEPROM.read(250);
byte AlivePin = -1;
unsigned long LastAlive = 0;
bool WaitForAck = false;
int Available = 0;
int pinread;
byte count = 0;


#if BoardType == 2
void resetFunc() {
  ESP.restart();
}
#else
void(* resetFunc) (void) = 0;
#endif

//******************************Ethernet Setup*****************************
#if ISIP == 1

#if BoardType == 2
#include <ESP8266WiFi.h>
#include <WiFiUdp.h>
char ssid[] = "TALKTALK-C94ECC";
char pass[] = "YNH9EXWA";
#else
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetUdp.h>
#endif


char packetBuffer[UDP_TX_PACKET_MAX_SIZE]; //buffer to hold incoming packet,
const unsigned int ServerPort = 8888;     // port to Send To
byte mac[] = {0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x01};
IPAddress ip(192,168,40,85);     //IP entered In HS config.
const unsigned int localPort = 8900;      //port entered In HS config.
IPAddress HomeseerIP(192,168,40,51); //Homeseer IP address
IPAddress ServerIP(EEPROM.read(2), EEPROM.read(3), EEPROM.read(4), EEPROM.read(5));
IPAddress gateway(192,168,40,1);
IPAddress subnet(255,255,255,0);
IPAddress LastRcvIP(0, 0, 0, 0);

#if BoardType == 2
WiFiUDP Udp;
#else
EthernetUDP Udp;
#endif

void UDPCheck() {
  byte packetSize = Udp.parsePacket();
  Available  = packetSize;
  if (packetSize)
  {

#if BoardType == 2
    IPAddress remote = Udp.remoteIP();
    Byte1 = Udp.parseInt();
    Udp.read();
    Byte2 = Udp.read();
    Udp.read();
    Byte3 = Udp.parseInt();
    Udp.read();
    Byte4 = Udp.parseInt();
    Udp.read();
    Byte5 = Udp.parseInt();
    DataEvent();
#else

    LastRcvIP = Udp.remoteIP();
    Byte1 = Udp.parseInt();
    Udp.read();
    Byte2 = Udp.read();
    Byte3 = Udp.parseInt();;
    Byte4 = Udp.parseInt();
    Byte5 = Udp.parseInt();;

    DataEvent();
#endif
  }
}

#endif



//********************************Input Setup*******************************
byte InPinArray[40] = { 0 };
unsigned int Debounce = 30;
byte NoOfInPins = 0;
byte InStateArray  [(sizeof(InPinArray) / sizeof(InPinArray[0]))];
static long InTime = 0;

void InputCheck() {

  if (millis() < InTime) { // we wrapped around, lets just try again
    InTime = millis();
  }

  if ((InTime + Debounce) > millis()) {
    // not enough time has passed to debounce
    return;
  }

  InTime = millis();

  for (count = 0; count < NoOfInPins; count++) {
    pinread = (digitalRead (InPinArray[count]));

    if (pinread != InStateArray[count] && WaitForAck == false) {
      InStateArray[count] = pinread;
      Send(BoardAdd);
      Send(" I ");
      Send(count + 1);
      Send(" ");
      Send(pinread);
      Send();
      WaitForAck == true;
    }
  }
  return;
}

//*******************************Output toggle/flash****************************

byte OutputToggle = 0;
byte OutputState = 0;
byte OutPinArray[40] = { -1 };
word OutputMillis[40];
byte OutputCount = 0;
unsigned long previousOutMillis[40] = { -1};


void OutputCheck() {

  if (millis() - previousOutMillis[OutputCount] >= OutputMillis[OutputCount]) {
    previousOutMillis[OutputCount] = millis();

    if (OutPinArray[OutputCount] > 0 ) {
      // if the Output is off turn it on and vice-versa
      if (bitRead(OutputState, OutputCount) == 0) {
        digitalWrite(OutPinArray[OutputCount], HIGH);
        bitWrite(OutputState, OutputCount, 1);

      }
      else {
        digitalWrite(OutPinArray[OutputCount], LOW);
        bitWrite(OutputState, OutputCount, 0);
        if (bitRead(OutputToggle, OutputCount) == 1) {
          bitWrite(OutputToggle, OutputCount, 0);
          OutPinArray[OutputCount] = -1;
        }

      }
    }
  }

  OutputCount++;
  if (OutputCount == 40 ) {
    OutputCount = 0;
  }

 return;
}





//*******************************Analogue Setup****************************
byte  AnalogPinArray[10] = {0};
unsigned int AnalogueDelay[(sizeof(AnalogPinArray) / sizeof(AnalogPinArray[0]))] = {0};
word AnalogueInvert = 0;
byte NoOfAnalogPins = 0;
int AnalogStateArray[(sizeof(AnalogPinArray) / sizeof(AnalogPinArray[0]))];
unsigned long PrevAnalogeMillis[sizeof(AnalogPinArray) / sizeof(AnalogPinArray[0])];


void  AnalogueCheck() {
  for (count = 0; count < NoOfAnalogPins; count++) {
    if (millis() - AnalogueDelay[count] > PrevAnalogeMillis[count]) {
      analogRead(AnalogPinArray[count]);
      pinread = analogRead(AnalogPinArray[count]);

      if (AnalogStateArray[count] != pinread && WaitForAck == false) {
        PrevAnalogeMillis[count] = millis();
        AnalogStateArray[count] = pinread;
        Send(BoardAdd);
        Send(" A ");
        Send(count + 1);
        Send(" ");
        if (bitRead(AnalogueInvert, count) == 1) {
          Send(map(AnalogStateArray[count], 0, 1023, 1023, 0));
          Send();
          WaitForAck == true;
        }
        else {
          Send(AnalogStateArray[count]);
          Send();
          WaitForAck == true;
        }
      }
    }
  }
}


//*****************************PWM Setup****************************
#if BoardType == 0
#include <SoftPWM.h>
#endif
byte PwmPinArray[15] = {0};


//*****************************Servo Setup***************************
#include <Servo.h>
byte ServoPinArray[6] = {0};
byte NoOfServos = 0;
Servo myservo[(sizeof(ServoPinArray) / sizeof(ServoPinArray[0]) )];
byte ServoPosArray[(sizeof(ServoPinArray) / sizeof(ServoPinArray[0]))];
byte ServoOldPosArray[(sizeof(ServoPinArray) / sizeof(ServoPinArray[0]))];

void ServoCheck() {
  for (count = 0; count < NoOfServos; count++) {
    if (ServoPosArray[count] != ServoOldPosArray[count]) {
      myservo[count].write(ServoPosArray[count]);
      ServoOldPosArray[count] = ServoPosArray[count];
    }
  }
}


//***************************One Wire Setup**************************
#include <OneWire.h>
#include <DallasTemperature.h>
byte OneWirePin = EEPROM.read(1);
byte TEMPERATURE_PRECISION = EEPROM.read(6);
OneWire oneWire(OneWirePin);
DallasTemperature sensors(&oneWire);
DeviceAddress tempDeviceAddress;
unsigned long lastTempRequest = 0;
int conversionDelay = 900;
bool  waitingForTempsGlobal = false;
bool needReboot = false;
float Temps[15] = {0};
unsigned long lastUpdated[15] = {0};


void OneWireCheck() {
  if (waitingForTempsGlobal && millis() - lastTempRequest >=  conversionDelay ) {
    for (int i = 0; i < sensors.getDeviceCount(); i++)  {
      sensors.getAddress(tempDeviceAddress, i);
      float Temp = sensors.getTempC(tempDeviceAddress);
      if ((Temps[i] != Temp || millis() - lastUpdated[i] >= 60000) && sensors.validAddress(tempDeviceAddress) && WaitForAck == false) {
        Temps[i] = Temp;
        Send(BoardAdd);
        Send(" Rom ");
        for (uint8_t i = 0; i < 8; i++)
        {
          if (tempDeviceAddress[i] < 16) Send("0");
          Send(tempDeviceAddress[i]);
        }
        Send(" ");
        Send(Temp);
        Send();
        lastUpdated[i] = millis();
        WaitForAck == true;
      }
    }
    waitingForTempsGlobal = false;
  }
  if (!waitingForTempsGlobal && millis() - lastTempRequest > 1500) {
    lastTempRequest = millis();
    waitingForTempsGlobal = true;
    sensors.requestTemperatures();
  }
}
//******************************************************************************



//#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 4, 20);  // Set the LCD I2C address
bool LCDInit = false;



//**********************************Alive Check***********************************

void AliveCheck() {

  if (AlivePin > -1 ) {
    if (millis() - LastAlive < 40000 && IsConnected == true) { //if connected and data recieved within 40sec set Alive pin High.
      digitalWrite(AlivePin, HIGH);
    }
    else if (millis() - LastAlive > 40000 && millis() - LastAlive < 81000 && IsConnected == true) { //if connected but no data recieved for 81sec reset the board.
      WaitForAck == false;
    }

    else {
      digitalWrite(AlivePin, LOW);
    }

    if (millis() - LastAlive > 81000 && IsConnected == true) { //if connected but no data recieved for 81sec reset the board.
      resetFunc();
    }
  }

}


//******************************************************************************

//**********************************Send Data***********************************

bool UdpSend = false;
//WiFiUDP port2;
void SendConnect()
{
#if ISIP == 0
  Serial.print("Connect ");
  Serial.println(BoardAdd);
#else
  if (UdpSend == false) {
    UdpSend = true;
    Udp.beginPacket(ServerIP, ServerPort); //First send a connect packet to the dynamic IP stored in eeprom
    Udp.print("Connect ");
    Udp.print(BoardAdd);
    Udp.endPacket();
    if (ServerIP != HomeseerIP) {
      Udp.beginPacket(HomeseerIP, ServerPort); //Then if the stored value doesn't match the pre-specified one, send a connect packet there also
      Udp.print("Connect ");
      Udp.print(BoardAdd);
      Udp.endPacket();
    }

    UdpSend = false;
  }
#endif
}

void Send(byte Data)
{
#if ISIP == 0
  Serial.print(Data);
#else
  if (UdpSend == false) {
    UdpSend = true;
    Udp.beginPacket(Udp.remoteIP(), ServerPort);
    Udp.print(Data);
  }
  else {
    Udp.print(Data);
  }
#endif
}
void Send(long Data)
{
#if ISIP == 0
  Serial.print(Data);
#else
  if (UdpSend == false) {
    UdpSend = true;
    Udp.beginPacket(Udp.remoteIP(), ServerPort);
    Udp.print(Data);
  }
  else {
    Udp.print(Data);
  }
#endif
}

void Send(int Data)
{
#if ISIP == 0
  Serial.print(Data);
#else
  if (UdpSend == false) {
    UdpSend = true;
    Udp.beginPacket(Udp.remoteIP(), ServerPort);
    Udp.print(Data);
  }
  else {
    Udp.print(Data);
  }
#endif
}

void Send(char* Data)
{
#if ISIP == 0
  Serial.print(Data);
#else
  if (UdpSend == false) {
    UdpSend = true;
    Udp.beginPacket(Udp.remoteIP(), ServerPort);
    Udp.print(Data);
  }
  else {
    Udp.print(Data);
  }
#endif
}


void Send(float Data)
{
#if ISIP == 0
  Serial.print(Data);
#else
  if (UdpSend == false) {
    UdpSend = true;
    Udp.beginPacket(Udp.remoteIP(), ServerPort);
    Udp.print(Data);
  }
  else {
    Udp.print(Data);
  }
#endif
}

void Send()
{
#if ISIP == 0
  Serial.println();
#else
  Udp.endPacket();
  UdpSend = false;
#endif

}



//*****************************Data Input********************************
/*

  Used Data Input Cases
  D Disconnect
  r reset
  F PWM Fade Time Set
  P PWM State Set
  K Keepalive
  W OneWire Pin Set
  p PinMode set PWM
  a PinMode AnalogInverted Set
  A PinMode Analog Input Set
  H PinMode Alive
  h acknowledge Data
  I PinMode Digital Input Set
  L Lcd Display Data
  l Lcd Backlight control
  O PinMode Output Set
  d Input debounce time set
  S Servo set Pos
  s PinMode Servo set
  C Connect request
  c Connection established - reUdp current status
  X Board PinMode Reset
*/

void DataEvent() {

  if (Byte1 == BoardAdd) {
    LastAlive = millis();//Reset the Alive timer if board  Data

    switch (Byte2) {

      case 'X':
        NoOfInPins = 0;
        NoOfServos = 0;
        NoOfAnalogPins = 0;
        //      NoOfPwmPins=0;
        break;

      case 'c':
        IsConnected = true;
#if ISIP == 1
        if (Udp.remoteIP() != ServerIP) {
          ServerIP = Udp.remoteIP();
          EEPROM.write(2, ServerIP[0]);
          EEPROM.write(3, ServerIP[1]);
          EEPROM.write(4, ServerIP[2]);
          EEPROM.write(5, ServerIP[3]);
        }
#endif
        for (count = 0; count < NoOfInPins; count++) {
          pinread = digitalRead(InPinArray[count]);
          Send(BoardAdd);
          Send(" I ");
          Send(count + 1);
          Send(" ");
          Send(pinread);
          Send();
          InStateArray[count] = pinread;
          delay(100);
        }
        break;

      case 'C':
        Send("Version ");
        Send(BoardAdd);
        Send(" ");
        Send(Version);
        Send(" HS3");
        Send();
        delay(100);
        Send("Connected ");
        Send(BoardAdd);
        Send();
        delay(100);
        IsConnected = false;
        break;


      case 's':
        ServoPinArray[Byte3 - 1] = Byte4;
        myservo[Byte3 - 1].attach(Byte4);
        //ServoPosArray[count] = 90;
        if (Byte3 > NoOfServos) {
          NoOfServos = Byte3;
        }
        break;

      case 'S':
        ServoPosArray[Byte3 - 1] = Byte4;
        break;

      case 'd':
        Debounce = Byte4;

        break;

      case 'l':

        if (LCDInit == false) {
          lcd.init();                      // initialize the lcd
          lcd.init();
          LCDInit = true;
        }
        if (Byte3 == 0) {
          lcd.noBacklight();
        }
        if (Byte3 == 1) {
          lcd.backlight();
        }
        if (Byte3 == 2) {
          lcd.clear();
        }
        break;

      case 'L':
        if (LCDInit == false) {
          lcd.init();                      // initialize the lcd
          lcd.init();
          LCDInit = true;
        }
        lcd.setCursor(0, Byte3 - 1);

#if ISIP == 1
        Udp.read();
        Available  = (Available - 9);
        for  (count = 1; count < Available  ; count++) {
          lcd.write(Udp.read());
        }
#else

        Serial.read();
        Available  = (Available - 11);
        for  (count = 1; count < Available  ; count++) {
          lcd.write(Serial.read());
        }
#endif

        break;


      case 'o':
        pinMode(Byte3, OUTPUT);
        OutPinArray[Byte5 - 1] = Byte3;
        OutputMillis[Byte5 - 1] = Byte4;
        bitWrite(OutputToggle, Byte5 - 1, 1);
        bitWrite(OutputState, OutputCount, 0);
        previousOutMillis[Byte5 - 1] = 0;

        break;

      case 'O':

        pinMode(Byte3, OUTPUT);
        if (Byte4 > 1) {
          OutPinArray[Byte5 - 1] = Byte3;
          OutputMillis[Byte5 - 1] = Byte4;
          bitWrite(OutputToggle, Byte3, 0);
          previousOutMillis[Byte5 - 1] = 0;
        }
        else
        {
          OutPinArray[Byte5 - 1] = -1;
          bitWrite(OutputToggle, Byte3, 0);
          digitalWrite(Byte3, Byte4);
          previousOutMillis[Byte5 - 1] = 0;
        }
        break;

      case 'H':
        pinMode(Byte3, OUTPUT);
        AlivePin = Byte3;
        break;

      case 'h':
        WaitForAck = false;
        break;

      case 'I':
        pinMode(Byte4, INPUT_PULLUP);

        if (Byte3 > NoOfInPins) {
          NoOfInPins = Byte3;
        }
        InPinArray[Byte3 - 1] = Byte4;
        break;

      case 'A':
        pinMode(Byte4, INPUT);
        if (Byte3 > NoOfAnalogPins) {
          NoOfAnalogPins = Byte3;
        }
        AnalogueDelay[Byte3 - 1] = Byte5;
        AnalogPinArray[Byte3 - 1] = Byte4;
        PrevAnalogeMillis[Byte3 - 1] = 0;
        break;

      case 'a':
        bitWrite(AnalogueInvert, Byte3 - 1, Byte4);
        break;


      case 'W':
        if (OneWirePin != Byte3) {
          OneWirePin = Byte3;
          EEPROM.write(1, OneWirePin);
          needReboot = true;
        }
        if (TEMPERATURE_PRECISION != Byte4) {
          TEMPERATURE_PRECISION = Byte4;
          EEPROM.write(6, TEMPERATURE_PRECISION);
          needReboot  = true;
        }
        if (needReboot) {
          resetFunc();
        }
        sensors.begin();
        sensors.setResolution(TEMPERATURE_PRECISION);
        sensors.setWaitForConversion(false);
        if (sensors.isParasitePowerMode()) {
          sensors.setCheckForConversion(false);
        }

        break;

      case 'K':
        delay(200);
        Send("Alive ");
        Send(BoardAdd);
        Send();
#if ISIP == 1
        if (Udp.remoteIP() != ServerIP) {
          ServerIP = Udp.remoteIP();
          EEPROM.write(2, ServerIP[0]);
          EEPROM.write(3, ServerIP[1]);
          EEPROM.write(4, ServerIP[2]);
          EEPROM.write(5, ServerIP[3]);
        }
#endif
        break;
#if BoardType == 0
      case 'p':
        PwmPinArray[Byte3 - 1] = Byte4;

      case 'P':
        SoftPWMSet(PwmPinArray[Byte3 - 1], Byte4);
        break;

      case 'F':
        SoftPWMSetFadeTime(PwmPinArray[Byte3 - 1], Byte4, Byte4);
        break;
#endif
      case 'r':
        Send("Reseting ");
        Send();
        delay(200);
        resetFunc();
        break;

      case 'D':
        IsConnected = false;
        break;

    }
  }
}

#if ISIP == 0
//*****************************Serial Event*********************************
void serialEvent() {
  while (Serial.available() > 0) {
    delay(17);
    Available  = Serial.available();
    Byte1 = Serial.parseInt();
    Serial.read();
    Byte2 = Serial.read();
    Byte3 = Serial.parseInt();
    Byte4 = Serial.parseInt();
    Byte5 = Serial.parseInt();
    DataEvent();
  }
}
#endif


//*****************************Setup Void*********************************
void setup() {



  //*****************************EEPROM Setup******************************
#if BoardType == 2
 // WiFi.persistent(false);
  EEPROM.begin(256);
  EEpromVersion = EEPROM.read(250);
  TEMPERATURE_PRECISION = EEPROM.read(6);
#else
  SoftPWMBegin();
#endif



  //***************************End EEPROM Setup
  switch (TEMPERATURE_PRECISION)
  {
    case 9:
      conversionDelay = 94;
    case 10:
      conversionDelay = 188;
    case 11:
      conversionDelay = 375;
    case 12:
      conversionDelay = 750;
  }


#if ISIP == 1
  if (EEpromVersion != 22 && EEpromVersion != 37) {
    ServerIP = HomeseerIP;
    EEPROM.write(2, ServerIP[0]);
    EEPROM.write(3, ServerIP[1]);
    EEPROM.write(4, ServerIP[2]);
    EEPROM.write(5, ServerIP[3]);
    EEpromVersion = 22;
  }
  if (EEpromVersion == 22) {
    EEPROM.write(6, 9);
    EEpromVersion = 37;
    #if BoardType == 2
    EEPROM.commit();
    #endif
  }

#if BoardType == 2
  Serial.begin(115200);
  WiFi.begin(ssid, pass);
  WiFi.config(ip, gateway, subnet);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
#else
  Ethernet.begin(mac, ip, gateway, gateway, subnet);
#endif

  Udp.begin(localPort);
  Udp.setTimeout(0);
#else
  if (EEpromVersion != 37) {
    EEPROM.write(6, 9);
    EEpromVersion = 37;
  }
  Serial.begin(115200);
  Serial.flush();
  Serial.setTimeout(0);
#endif

  EEPROM.write(250, EEpromVersion); //Store the version where the eeprom data layout was last changed
#if BoardType == 2
  EEPROM.commit();
 #endif 
  delay(1000);
  IsConnected = false;
  SendConnect();
}



//*****************************Loop Void*********************************
void loop() {
#if ISIP == 1
  UDPCheck();
#endif
  AliveCheck();
  if (IsConnected == true)
  {

    InputCheck();
    OutputCheck();
   
    #if BoardType == 0
    AnalogueCheck();
    ServoCheck();
    if (OneWirePin > 0) {
      OneWireCheck();
    }
    #endif
  }
  yield();
}

//****************************************End**************************************************

Jeg har bare lastet opp denne koden

[Moskus]

28 minutter siden, Hr Kotelett skrev:

Tenkte mer på selve koden,  som du har lastet opp til arduinoen.

Sketchen laster du ned fra HS-plugin'en. Den ordner kommunikasjonen mot HomeSeer.

Resten settes opp i HomeSeer, og der velger du bl.a. hvilke pinner du vil skal være utganger, digitale innganger og analoge innganger.

 

Sketchen er i denne sammenheng fullstendig uinteressant.  

[Hr Kotelett]

Aaaah, kanskje jeg skal begynne med å laste ned plugin'n og se kossn den fungerer ja, trodde en måtte gjøre kodingen på forhånd

[Christoffer]

3 hours ago, Hr Kotelett said:

Aaaah, kanskje jeg skal begynne med å laste ned plugin'n og se kossn den fungerer ja, trodde en måtte gjøre kodingen på forhånd

Neida, eneste man trenger er Arduino IDE og en Arduino/NodeMCU

[Moskus]

Merk at for å gjøre det praktisk med en Arduino trenger man et Wifi-Shield eller Ethernet-shield. NodeMCU har jo wifi innebygget, så det blir enklere.  

[Christoffer]

Har laget til en temperaturside for hvert rom. Har en med oversikt over de forskjelliger rommene og så klikker man seg videre derfra for å detaljstyre de forskjellige rommene. Foreløpig er det kun rommene med panelovner jeg styrer fra HS3. Venter på at heatit skal få fingen ut slik at jeg får med varmekablene også.

 

Endret 8. februar 2018 av Christoffer