AVR Sketch

#include <dht.h>
#include <IRremote.h>
#include <SPI.h>
#include <Ethernet.h>
#include <PubSubClient.h>

#define CaFan 22 //AV Rack fan
#define RmFan 23 //Room fan
#define Sub 24 //subwoofer
#define Motion 26 //motion detector
#define RMTemp 27 //Room temp/humidity sensor
#define IRIn 28  //IR receiver
#define AVTemp 29 //AV Rack Temp/humidity sensor
#define doorbell 30  //door bell relay

//define global variables
unsigned long TempMillis = millis(); //holds millis count for temp sensing
unsigned long mMillis = 0; //holds millis count for motion sensor
unsigned long UpdateMillis = millis() - 1800000; //holds millis count for sending MQTT status updates
unsigned long dbMillis = 0; //holds millis count for doorbell delay
int motionstatus = 0;
int motionlast = 0;
int dbStatus = 1;
int dbLast = 1;
float AVt = 0;//av and room temp/humidity variables
float AVh = 0;
float RMt = 0;
float RMh = 0;
float AVtL = 0;//av and room temp/humidity last state variables
float AVhL = 0;
float RMtL = 0;
float RMhL = 0;
char message_buff[100];

dht DHT;

IRrecv irrecv(IRIn);
decode_results results;

// Ethernet shield
byte mac[]    = {  0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xED };
//IPAddress ip(10, 0, 0, 10);
IPAddress server(10, 0, 0, 20);
EthernetClient ethClient;
PubSubClient client(ethClient);


//MQTT CALLBACK FUNCTION----------------------------------------------------------------------------
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i=0;i<length;i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();

  if (strcmp(topic,"/theater/AVR/CaFan")==0) //evaluate payload
  {
    if (payload[0] == '0') //turn off
    {
      digitalWrite(CaFan, HIGH);
      delay(100);
      client.publish("/theater/AVR/CaFan/state","OFF");
      Serial.println("Case Fan OFF");
    }
    else if (payload[0] == '1') //turn on
    {
      digitalWrite(CaFan, LOW);
      delay(100);
      client.publish("/theater/AVR/CaFan/state","ON");
      Serial.println("Case Fan ON");
    }
    else if (payload[0] == '2') //status update
    {
      if (digitalRead(CaFan)==0) client.publish("/theater/AVR/CaFan/state","ON");
      else client.publish("/theater/AVR/CaFan/state","OFF");
    }
 }
if (strcmp(topic,"/theater/AVR/RmFan")==0) //evaluate payload
  {
    if (payload[0] == '0') //turn off
    {
      digitalWrite(RmFan, HIGH);
      delay(100);
      client.publish("/theater/AVR/RmFan/state","OFF");
      Serial.println("Room Fan OFF");
    }
    else if (payload[0] == '1') //turn on
    {
      digitalWrite(RmFan, LOW);
      delay(100);
      client.publish("/theater/AVR/RmFan/state","ON");
      Serial.println("Room Fan ON");
    }
    else if (payload[0] == '2') //status update
    {
      if (digitalRead(RmFan)==0) client.publish("/theater/AVR/RmFan/state","ON");
      else client.publish("/theater/AVR/RmFan/state","OFF");
    }
 }

   if (strcmp(topic,"/theater/AVR/Sub")==0) //evaluate payload
  {
    if (payload[0] == '0') //turn off
    {
      digitalWrite(Sub, HIGH);
      delay(100);
      client.publish("/theater/AVR/Sub/state","OFF");
      Serial.println("Sub OFF");
    }
    else if (payload[0] == '1') //turn on
    {
      digitalWrite(Sub, LOW);
      delay(100);
      client.publish("/theater/AVR/Sub/state","ON");
      Serial.println("Sub ON");
    }
    else if (payload[0] == '2') //status update
    {
      if (digitalRead(Sub)==0) client.publish("/theater/AVR/Sub/state","ON");
      else client.publish("/theater/AVR/Sub/state","OFF");
    }
 }
}
//END MQTT CALLBACK FUNCTION----------------------------------------------------------------------------

//MQTT RECONNECT FUNCTION
void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
    if (client.connect("arduinoClient")) {
      Serial.println("connected");
      client.subscribe("/theater/AVR/#"); //subscribe to all messages aimed for this device
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}
//END MQTT RECONNECT FUNCTION----------------------------------------------------------------------------

//SETUP----------------------------------------------------------------------------
void setup() {
  //setup pins
  pinMode(CaFan, OUTPUT);
  pinMode(RmFan, OUTPUT);
  pinMode(Sub, OUTPUT);
  pinMode(Motion, INPUT);
  pinMode(doorbell, INPUT);
  //set outputs to HIGH
  digitalWrite(CaFan, HIGH);
  digitalWrite(RmFan, HIGH);
  digitalWrite(Sub, HIGH);
  digitalWrite(doorbell, HIGH);
  //setup serial and print header
  Serial.begin(9600);
  Serial.println("MoxieSoft 'TM'");
  Serial.println("Theater Control Module");
  Serial.println("Version 1.3\n\n");
  irrecv.enableIRIn(); // Start the IR receiver
  client.setServer(server, 1883);  //MQTT setup
  client.setCallback(callback);
  if (Ethernet.begin(mac) == 0) {
    Serial.println("Failed to configure Ethernet using DHCP");
    // no point in carrying on, so do nothing forevermore:
    for (;;)
      ;
  }
  // print your local IP address:
  Serial.print("My IP address: ");
  for (byte thisByte = 0; thisByte < 4; thisByte++) {
    // print the value of each byte of the IP address:
    Serial.print(Ethernet.localIP()[thisByte], DEC);
    Serial.print(".");
  }
  Serial.println();
}
//END SETUP----------------------------------------------------------------------------

//MAIN LOOP----------------------------------------------------------------------------
void loop() {
//MOTION SENSOR----------------------------------------------------------------------------
  if (millis() > mMillis+500) //monitor motion every 500ms
  {
    motionstatus = digitalRead(Motion);
    mMillis = millis();
    if (motionlast != motionstatus) { //avoid resending state
      motionlast = motionstatus;  //reset state
      Serial.print("Motion is: ");
      Serial.println(motionstatus);
      if (motionstatus==1) client.publish("/theater/AVR/Motion/state","OPEN"); //send MQTT update to openhab
      else client.publish("/theater/AVR/Motion/state","CLOSED");
      mMillis = millis() + 4000; //delay keeps from a bounce & flooding openhab

    }
  }
//END MOTION SENSOR----------------------------------------------------------------------------
//STATUS UPDATES----------------------------------------------------------------------------
  if (millis() > UpdateMillis+1800000) //send status updates once every 30 minutes
  {
    if (motionstatus==1) client.publish("/theater/AVR/Motion/state","OPEN");
    else client.publish("/theater/AVR/Motion/state","CLOSED");
    if (digitalRead(Sub)==0) client.publish("/theater/AVR/Sub/state","ON");
    else client.publish("/theater/AVR/Sub/state","OFF");
    if (digitalRead(RmFan)==0) client.publish("/theater/AVR/RmFan/state","ON");
    else client.publish("/theater/AVR/RmFan/state","OFF");
    if (digitalRead(CaFan)==0) client.publish("/theater/AVR/CaFan/state","ON");
    else client.publish("/theater/AVR/CaFan/state","OFF");
    UpdateMillis = millis();
  }
//END STATUS UPDATES----------------------------------------------------------------------------
//IR RECEIVER----------------------------------------------------------------------------
  if (irrecv.decode(&results)) {
    switch(results.value)
      {
      case 0x3A2A: Serial.println("Projector ON"); break;
      case 0x7A2A: Serial.println("Projector OFF");    break;
      case 0x542A: Serial.println("Projector Toggle");    break;
      case 0x4BB620DF: Serial.println("Receiver ON");   break;
      case 0x4B36E21D: Serial.println("Receiver OFF"); break;
      case 0x4B36D32C: Serial.println("Receiver Toggle");    break;
      case 0x4BB640BF: Serial.println("Receiver Volume Up");    break;
      case 0x4BB6C03F: Serial.println("Receiver Volume Down");    break;
      case 0x4BB6A05F: Serial.println("Receiver Mute");    break;
      case 0x11B6897: Serial.println("Xbox One Play");    break;
      case 0x11B18E7: Serial.println("Xbox One Pause");    break;
      case 0x11B9867: Serial.println("Xbox One Stop");    break;
      case 0xA25D807F: Serial.println("Sub ON");    //turn on sub relay and update openhab via MQTT,  this is numeric '1' on toshiba se-r0121 remote
        digitalWrite(Sub, LOW); //turn on sub
        client.publish("/theater/AVR/Sub/state","ON");
        break;
      case 0xA25D40BF: Serial.println("Sub OFF");   //turn off sub relay and update openhab via MQTT, this is numeric '2' on toshiba se-r0121 remote
        digitalWrite(Sub, HIGH); //turn off sub
        client.publish("/theater/AVR/Sub/state","OFF");
        break;
      case 0xA25DC03F: Serial.println("Sub Toggle");   //toggle the state of the sub relay and update openhab via MQTT
        if (digitalRead(Sub) == LOW)
          {
            digitalWrite(Sub, HIGH);
            client.publish("/theater/AVR/Sub/state","OFF");
          }
        else
          {
            digitalWrite(Sub, LOW);
            client.publish("/theater/AVR/Sub/state","ON");
          }
        break;
      case 0xA25D20DF: Serial.println("room Light on"); //turn room light on, 4 on remote
        client.publish("/theater/AVR/OHL/state","1");
        break;
      case 0xA25DA05F: Serial.println("room Light off"); //turn room light off, 5 on remote
        client.publish("/theater/AVR/OHL/state","0");
        break;
      case 0xA25D609F: Serial.println("room Light up"); //turn room light up, 6 on remote
        client.publish("/theater/AVR/OHL/state","2");
        break;
      case 0xA25DE01F: Serial.println("room Light down"); //turn room light down, 7 on remote
        client.publish("/theater/AVR/OHL/state","3");
        break;
      case 0xFFFFFFFF: break;
      default:  //outputs remote code to serial if unrecognized
        Serial.print("Unknown IR Value: 0x");
        Serial.println(results.value, HEX);
      break;
  }// End Case
    irrecv.resume(); // Receive the next value
  }
//END IR RECEIVER----------------------------------------------------------------------------
//DOORBELL----------------------------------------------------------------------------
if (millis() > dbMillis) //check every loop but reset millis one button is pushed to delay 1 minute
{
  dbStatus = digitalRead(doorbell);
  if (dbStatus != dbLast)  //state changed
  {
    if (dbStatus == 0) //button is pressed
    {
      //doorbell rang, do something
      client.publish("/theater/AVR/DB/state","ON");//send MQTT doorbell pushed
      Serial.println("Doorbell Pressed");
      dbLast = dbStatus;
      dbMillis = millis() + 2000;  //wait 1 second to look for button release
    }
    else //button was released
    {
      client.publish("/theater/AVR/DB/state","OFF");//send MQTT doorbell released
      dbMillis = millis() + 60000; //wait 1 minute to keep from receiving several doorbell notifications in a row
      Serial.println("Doorbell Released");
      dbLast = dbStatus;
    }
  } else
  {
    dbMillis = millis() + 100; //check every 10ms (reduce load on proc but still catch super short presses)
  }
}
//END DOORBELL----------------------------------------------------------------------------
//ETHERNET RECONNECT----------------------------------------------------------------------------
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
//END ETHERNET RECONNECT----------------------------------------------------------------------------
//TEMP SENSORS----------------------------------------------------------------------------
  if (millis() > TempMillis+30000) //read temp sensors once every 30 seconds
  {
    int chk = NULL;
    //AV Sensor handling------
    chk = DHT.read22(AVTemp); //read from av sensor
    AVt = Fahrenheit(DHT.temperature);
    AVh = DHT.humidity;
    switch (chk)
    {
      case 0:
      {
        if (AVtL <= (AVt-1) || AVtL >= (AVt+1)) //evaluate temperature
        {
          Serial.print("AV Temperature = ");
          Serial.print(AVt);
          Serial.print(", Rounded: ");
          Serial.println(AVt, 0);
          AVtL = AVt;
          String pubString = String(AVt,0);
          pubString.toCharArray(message_buff, pubString.length()+1);
          client.publish("/theater/AVR/AVT/state", message_buff);
        }
        if (AVhL <= (AVh-1) || AVhL >= (AVh+1)) //evaluate humidity
        {
          Serial.print("AV Humidity = ");
          Serial.print(AVh);
          Serial.print(", Rounded: ");
          Serial.println(AVh, 0);
          AVhL = AVh;
          String pubString = String(AVh, 0);
          pubString.toCharArray(message_buff, pubString.length()+1);
          client.publish("/theater/AVR/AVH/state", message_buff);
        }
        break;
      }
      case -1:
      {
        Serial.println("AVR DHT Checksum error");
        break;
      }
      case -2:
      {
        Serial.println("AVR DHT Time out error");
        break;
      }
      default: Serial.println("Unknown AVR DHT Read error"); break;
    }
    //ROOM Sensor handling------
    chk = NULL;
    chk = DHT.read22(RMTemp); //read from av sensor
    RMt = Fahrenheit(DHT.temperature);
    RMh = DHT.humidity;
    switch (chk)
    {
      case 0:
      {
        if (RMtL <= (RMt-1) || RMtL >= (RMt+1)) //evaluate temperature
        {
          Serial.print("Room Temperature = ");
          Serial.print(RMt);
          Serial.print(", Rounded: ");
          Serial.println(RMt, 0);
          RMtL = RMt;
          String pubString = String(RMt, 0);
          pubString.toCharArray(message_buff, pubString.length()+1);
          client.publish("/theater/AVR/RMT/state", message_buff);
        }
        if (RMhL <= (RMh-1) || RMhL >= (RMh+1)) //evaluate humidity
        {
          Serial.print("Room Humidity = ");
          Serial.print(RMh);
          Serial.print(", Rounded: ");
          Serial.println(RMh, 0);
          RMhL = RMh;
          String pubString = String(RMh, 0);
          pubString.toCharArray(message_buff, pubString.length()+1);
          client.publish("/theater/AVR/RMH/state", message_buff);
        }
        break;
      }
      case -1:
      {
        Serial.println("Room DHT Checksum error");
        break;
      }
      case -2:
      {
        Serial.println("Room DHT Time out error");
        break;
      }
      default: Serial.println("Unknown Room DHT Read error"); break;
    }

    TempMillis = millis();  //set TempMillis to current millis to restart "timer"
  }
//END TEMP SENSORS----------------------------------------------------------------------------
//START ETHERNET IP MAINTAIN-------------------------------------------------------------------
switch (Ethernet.maintain())
  {
    case 1:
      //renewed fail
      Serial.println("Error: renewed fail");
      break;
    case 2:
      //renewed success
      Serial.println("Renewed success");
      //print your local IP address:
      printIPAddress();
      break;
    case 3:
      //rebind fail
      Serial.println("Error: rebind fail");
      break;
    case 4:
      //rebind success
      Serial.println("Rebind success");
      //print your local IP address:
      printIPAddress();
      break;
    default:
      //nothing happened
      break;
  }
//END ETHERNET IP MAINTAIN-------------------------------------------------------------------

}
//END MAIN LOOP----------------------------------------------------------------------------


//CELSIUS TO FAHRENHEIT CONVERSION----------------------------------------------------------------------------
double Fahrenheit(double celsius)
{
        return 1.8 * celsius + 32;
}
//END CELSIUS TO FAHRENHEIT CONVERSION----------------------------------------------------------------------------

void printIPAddress()
{
  Serial.print("My IP address: ");
  for (byte thisByte = 0; thisByte < 4; thisByte++) {
    // print the value of each byte of the IP address:
    Serial.print(Ethernet.localIP()[thisByte], DEC);
    Serial.print(".");
  }

  Serial.println();
}