296 lines
9.3 KiB
C++
296 lines
9.3 KiB
C++
/**
|
|
* Loading classes
|
|
*/
|
|
#include <Arduino.h>
|
|
#include <IRremoteESP8266.h>
|
|
#include <IRrecv.h>
|
|
#include <IRsend.h>
|
|
#include <IRutils.h>
|
|
#include <ESP8266WiFi.h>
|
|
#include <WiFiClient.h>
|
|
#include <ESP8266WebServer.h>
|
|
#include <ESP8266mDNS.h>
|
|
#include <NewRemoteTransmitter.h>
|
|
#include <NewRemoteReceiver.h>
|
|
#include <DHT.h>
|
|
#include "config.h"
|
|
|
|
/**
|
|
* Define constants
|
|
*/
|
|
const uint16_t NONE = 65535; // Used to define not activated pins.
|
|
|
|
const char* PARAMETER_PLUG_ADDRESS="plug_address";
|
|
const char* PARAMETER_PLUG_ID="plug_id";
|
|
const char* PARAMETER_PLUG_STATUS="plug_enabled";
|
|
const char* PARAMETER_IR_TYPE="ir_type";
|
|
const char* PARAMETER_IR_CODE="ir_code";
|
|
const char* PARAMETER_IR_BITS="ir_bits";
|
|
const char* PARAMETER_PRE_DELAY_TIME_IN_MS="pre_delay_time_in_ms";
|
|
const char* PARAMETER_SIGNAL="signal";
|
|
const char* PARAMETER_LIST[]={PARAMETER_PLUG_ADDRESS,PARAMETER_PLUG_ID,PARAMETER_PLUG_STATUS,PARAMETER_IR_TYPE,PARAMETER_IR_CODE,PARAMETER_IR_BITS,PARAMETER_PRE_DELAY_TIME_IN_MS,PARAMETER_SIGNAL};
|
|
|
|
/**
|
|
* Define variables
|
|
*/
|
|
decode_results results;
|
|
decode_type_t last_recieved_ir_type;
|
|
int last_recieved_ir_code;
|
|
int last_recieved_ir_bits;
|
|
unsigned int last_recieved_radio_period;
|
|
unsigned long last_recieved_radio_address;
|
|
unsigned long last_recieved_radio_groupBit;
|
|
unsigned long last_recieved_radio_unit;
|
|
unsigned long last_recieved_radio_switchType;
|
|
|
|
/**
|
|
* Setup classes
|
|
*/
|
|
MDNSResponder mdns;
|
|
ESP8266WebServer server ( 80 );
|
|
IRrecv irrecv(PIN_IR_RECIEVER);
|
|
|
|
/**
|
|
* Setter functions
|
|
*/
|
|
void setRecievedIr(decode_results *results) {
|
|
last_recieved_ir_type = results->decode_type;
|
|
last_recieved_ir_code = results->value;
|
|
last_recieved_ir_bits = results->bits;
|
|
Serial.println("The code \"" + String(last_recieved_ir_code) + "\" was send for type \"" + String(results->decode_type,DEC) + "\" with \"" + String(results->bits,DEC) + "\" bits.");
|
|
}
|
|
|
|
void setLastRecievedRadio(unsigned int period, unsigned long address, unsigned long groupBit, unsigned long unit, unsigned long switchType){
|
|
last_recieved_radio_period=period;
|
|
last_recieved_radio_address=address;
|
|
last_recieved_radio_groupBit=groupBit;
|
|
last_recieved_radio_unit=unit;
|
|
last_recieved_radio_switchType=switchType;
|
|
Serial.println("Recieved radio code with the following values: address \"" + String(address) + "\", period \"" + String(period) + "\", unit \"" + String(unit) + "\", group bit \"" + String(groupBit) + "\" and switch type \"" + String(switchType) + "\".");
|
|
}
|
|
|
|
/**
|
|
* Transmitter functions
|
|
*/
|
|
void sendRemoteGroupSignal(boolean state, NewRemoteTransmitter transmitter)
|
|
{
|
|
transmitter.sendGroup(state);
|
|
Serial.println("The state \"" + String(state,BIN) + "\" was send to the group.");
|
|
}
|
|
|
|
void sendRemoteUnitSignal(int unit, boolean state, NewRemoteTransmitter transmitter)
|
|
{
|
|
transmitter.sendUnit(unit, state);
|
|
Serial.println("The state \"" + String(state,BIN) + "\" was send to the switch \"" + String(unit,DEC) + "\".");
|
|
}
|
|
|
|
void sendIrCode(decode_type_t type,uint32_t code, uint16_t bits) {
|
|
Serial.println("Enable IR-sender.");
|
|
IRsend irsend(PIN_IR_SEND);
|
|
irsend.begin();
|
|
irsend.send(type, code, bits);
|
|
Serial.println("The code \"" + String(code) + "\" with \"" + String(bits) + "\" bits was send in format \"" + String(type) + "\".");
|
|
}
|
|
|
|
/**
|
|
* Actors
|
|
*/
|
|
void switchSignal(boolean status){
|
|
Serial.println("Switching signal\"" + String((status)?("on"):("off")) + ".");
|
|
if(status){
|
|
pinMode(PIN_SIGNAL,OUTPUT);
|
|
digitalWrite(PIN_SIGNAL,LOW);
|
|
}else{
|
|
digitalWrite(PIN_SIGNAL,HIGH);
|
|
pinMode(PIN_SIGNAL,INPUT);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper functions
|
|
*/
|
|
bool isParameterDefined(String parameter_name){
|
|
for (uint8_t parameter_index = 0; parameter_index < server.args(); parameter_index++) {
|
|
if(server.argName(parameter_index)==parameter_name){
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
String getParameterType(const char* parameter){
|
|
if(
|
|
parameter==PARAMETER_PLUG_ID ||
|
|
parameter==PARAMETER_IR_TYPE ||
|
|
parameter==PARAMETER_IR_CODE ||
|
|
parameter==PARAMETER_PRE_DELAY_TIME_IN_MS ||
|
|
parameter==PARAMETER_IR_BITS ||
|
|
parameter==PARAMETER_PLUG_ID
|
|
){
|
|
return "integer";
|
|
}
|
|
|
|
if(parameter==PARAMETER_PLUG_ADDRESS){
|
|
return "long";
|
|
}
|
|
|
|
if(
|
|
parameter==PARAMETER_SIGNAL ||
|
|
parameter==PARAMETER_PLUG_STATUS
|
|
){
|
|
return "boolean";
|
|
}
|
|
return "text";
|
|
}
|
|
|
|
void controller(void){
|
|
if(isParameterDefined(PARAMETER_SIGNAL)){
|
|
switchSignal(server.arg(PARAMETER_SIGNAL).equals("on"));
|
|
}
|
|
if(isParameterDefined(PARAMETER_IR_TYPE) && isParameterDefined(PARAMETER_IR_CODE) && isParameterDefined(PARAMETER_IR_BITS)){
|
|
sendIrCode(static_cast<decode_type_t>(server.arg(PARAMETER_IR_TYPE).toInt()),server.arg(PARAMETER_IR_CODE).toInt(),server.arg(PARAMETER_IR_BITS).toInt());
|
|
}
|
|
if(isParameterDefined(PARAMETER_PLUG_ID)){
|
|
NewRemoteTransmitter transmitter(server.arg(PARAMETER_PLUG_ADDRESS).toInt(), PIN_RADIO_TRANSMITTER);
|
|
if(server.arg(PARAMETER_PLUG_ID).equals("0")){
|
|
sendRemoteGroupSignal(server.arg(PARAMETER_PLUG_STATUS).equals("on"),transmitter);
|
|
}else if(server.arg(PARAMETER_PLUG_ID).toInt()>0){
|
|
sendRemoteUnitSignal(server.arg(PARAMETER_PLUG_ID).toInt(),server.arg(PARAMETER_PLUG_STATUS).equals("on"),transmitter);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Getter functions
|
|
*/
|
|
String getJsonDht(void){
|
|
Serial.println("Reading DHT...");
|
|
DHT dht(PIN_DHT, DHT11);
|
|
delay(800); // Somehow this delay is needed to don't get "nan" values
|
|
String temperature = String(dht.readTemperature());
|
|
delay(800); // Somehow this delay is needed to don't get "nan" values
|
|
String humidity = String(dht.readHumidity());
|
|
return "{\"temperature_celcius\":\""+ temperature +"\",\"relative_humidity\":\""+humidity+"\"}";
|
|
}
|
|
|
|
String getJsonRadio(void){
|
|
Serial.println("Reading radio signal...");
|
|
return "{\"last_recieved\":{\"period\":\""+String(last_recieved_radio_period)+"\",\"address\":\""+String(last_recieved_radio_address)+"\",\"group_bit\":\""+String(last_recieved_radio_groupBit)+"\",\"unit\":\""+String(last_recieved_radio_unit)+"\",\"switch_type\":\""+String(last_recieved_radio_switchType)+"\"}}";
|
|
}
|
|
|
|
String getJsonPir(void){
|
|
Serial.println("Reading PIR...");
|
|
pinMode(PIN_PIR, INPUT);
|
|
return "{\"motion\":\""+String((digitalRead(PIN_PIR)==HIGH)?"true":"false")+"\"}";
|
|
}
|
|
|
|
String getJsonSoilMoisture(void){
|
|
Serial.println("Reading soil moisture from PIN ...");
|
|
String moistures = "[";
|
|
int array_elements=(sizeof(PINS_SOIL_MOISTURE) / sizeof(uint16_t));
|
|
for (int index=0; index<array_elements; index++)
|
|
{
|
|
pinMode(PINS_SOIL_MOISTURE[index], INPUT);
|
|
moistures = moistures + "{"
|
|
"\"pin\":\"" + String(PINS_SOIL_MOISTURE[index]) + "\","
|
|
"\"is_moist\":\""+String((digitalRead(PINS_SOIL_MOISTURE[index])==LOW)?"true":"false")+"\""
|
|
"}";
|
|
if(index<(array_elements-1)){
|
|
moistures = moistures + ",";
|
|
}
|
|
}
|
|
return moistures + "]";
|
|
}
|
|
|
|
String getJsonLdr(void){
|
|
Serial.println("Reading LDR...");
|
|
return "{\"actual\":\""+String(analogRead (PIN_LDR))+"\",\"minimum\":\"0\",\"maximum\":\"1023\"}";
|
|
}
|
|
|
|
String getJsonIr(void){
|
|
Serial.println("Reading infared signal...");
|
|
return "{\"last_recieved\":{\"bits\":\""+String(last_recieved_ir_bits)+"\",\"type\":\""+String(last_recieved_ir_type)+"\",\"data\":\""+String(last_recieved_ir_code)+"\"}}";
|
|
}
|
|
|
|
String getJson(void){
|
|
Serial.println("Generating json...");
|
|
return "{"
|
|
"\"LDR\":"+String(getJsonLdr())+","
|
|
"\"DHT\":"+String(getJsonDht())+ ","
|
|
"\"soil_moisture\":"+String(getJsonSoilMoisture())+","
|
|
"\"PIR\":"+String(getJsonPir())+","
|
|
"\"IR\":"+String(getJsonIr())+","
|
|
"\"radio\":"+String(getJsonRadio())+
|
|
"}";
|
|
}
|
|
|
|
#include "homepage_template.h"
|
|
|
|
void view(void){
|
|
if(server.arg("format")=="json"){
|
|
Serial.println("Json was called.");
|
|
server.send ( 200, "application/json", getJson());
|
|
}else{
|
|
Serial.println("Html was called.");
|
|
server.send ( 200, "text/html ", homepage_template());
|
|
}
|
|
}
|
|
|
|
int getDelayTime(void){
|
|
if(isParameterDefined(PARAMETER_PRE_DELAY_TIME_IN_MS)){
|
|
int delay_time_in_ms = server.arg(PARAMETER_PRE_DELAY_TIME_IN_MS).toInt();
|
|
if(delay_time_in_ms>0){
|
|
Serial.println("Applying delay time: " + server.arg(PARAMETER_PRE_DELAY_TIME_IN_MS) + "ms");
|
|
return delay_time_in_ms;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void handleRequest(void){
|
|
Serial.println("Website was called.");
|
|
delay(getDelayTime());
|
|
controller();
|
|
view();
|
|
}
|
|
|
|
//Arduino-Setup
|
|
void setup(void)
|
|
{
|
|
Serial.begin(9600);
|
|
Serial.println("Enable remote transmitter.");
|
|
NewRemoteReceiver::init(PIN_RADIO_RECIEVER, 1, setLastRecievedRadio);
|
|
Serial.println("Enable IR-reciever.");
|
|
irrecv.enableIRIn();
|
|
Serial.println("Started program.");
|
|
//WiFi.softAPdisconnect(true);
|
|
WiFi.begin(ssid, password);
|
|
while (WiFi.status() != WL_CONNECTED) {
|
|
Serial.print(".");
|
|
delay(500);
|
|
}
|
|
Serial.println("Connected to :" + String(ssid));
|
|
Serial.print("IP address: ");
|
|
Serial.println(WiFi.localIP());
|
|
if (mdns.begin(hostname, WiFi.localIP())) {
|
|
Serial.println("MDNS responder started.");
|
|
Serial.println("Using \"" + String(hostname) + "\" as hostname.");
|
|
}
|
|
server.onNotFound(handleRequest);
|
|
server.begin();
|
|
Serial.println("HTTP server started.");
|
|
Serial.println("Generate test signal.");
|
|
switchSignal(true);
|
|
delay(200);
|
|
switchSignal(false);
|
|
}
|
|
|
|
void loop()
|
|
{
|
|
server.handleClient();
|
|
if (irrecv.decode(&results)) {
|
|
setRecievedIr(&results);
|
|
irrecv.resume();
|
|
}
|
|
}
|