├── .gitattributes └── All_in_one_home_automation_rainmaker └── All_in_one_home_automation_rainmaker.ino /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /All_in_one_home_automation_rainmaker/All_in_one_home_automation_rainmaker.ino: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | This is the code for the project, 4 | 5 | All in One Home Automation project using ESP RainMaker made using ESP32 6 | 7 | This code was written by Arun Suthar Modified by Sachin Soni for techiesms YouTube channel 8 | 9 | This code is provided free for project purpose and fair use only. 10 | Do mail us if you want to use it commercially 11 | 12 | techiesms@gmail.com 13 | Copyrighted © by techiesms 14 | 15 | 16 | Watch out it's complete tutorial on our YouTube channel 17 | https://www.YouTube.com/techiesms 18 | */ 19 | 20 | 21 | //This example demonstrates the ESP RainMaker with a standard Switch device. 22 | #include "RMaker.h" 23 | #include "WiFi.h" 24 | #include "WiFiProv.h" 25 | #include 26 | #include 27 | #include 28 | 29 | //for BLE 30 | const char *service_name = "PROV_techiesms"; //name of node in BLE 31 | const char *pop = "Techiesms123"; //password 32 | 33 | using namespace ace_button; 34 | 35 | #define DEBUG_SW 1 // for ON/OFF serial moniter 36 | #define DEFAULT_RELAY_STATE false 37 | 38 | // GPIO for push button 39 | static uint8_t gpio_reset = 0; 40 | 41 | // GPIO for switch 42 | static uint8_t switch1 = 32; 43 | static uint8_t switch2 = 35; 44 | static uint8_t switch3 = 34; 45 | static uint8_t switch4 = 39; 46 | 47 | // GPIO for Relay (Appliance Control) 48 | static uint8_t relay1 = 15; 49 | static uint8_t relay2 = 2; 50 | static uint8_t relay3 = 4; 51 | static uint8_t relay4 = 22; 52 | 53 | // GPIO for Relay (Fan Speed Control) 54 | static uint8_t Speed1 = 21; 55 | static uint8_t Speed2 = 19; 56 | static uint8_t Speed4 = 18; 57 | 58 | // GPIO for Fan Regulator Knob 59 | static uint8_t s1 = 27; 60 | static uint8_t s2 = 14; 61 | static uint8_t s3 = 12; 62 | static uint8_t s4 = 13; 63 | 64 | bool speed1_flag = 1; 65 | bool speed2_flag = 1; 66 | bool speed3_flag = 1; 67 | bool speed4_flag = 1; 68 | bool speed0_flag = 1; 69 | 70 | /* Variable for reading pin status*/ 71 | bool switch_state_ch1 = false; 72 | bool switch_state_ch2 = false; 73 | bool switch_state_ch3 = false; 74 | bool switch_state_ch4 = false; 75 | 76 | 77 | int Slider_Value = 0; 78 | int curr_speed = 1; 79 | bool fan_power = 0; 80 | 81 | 82 | 83 | static Switch my_switch1("light1", &relay1); 84 | static Switch my_switch2("light2", &relay2); 85 | static Switch my_switch3("light3", &relay3); 86 | static Switch my_switch4("light4", &relay4); 87 | static Fan my_fan("Fan"); 88 | 89 | ButtonConfig config1; 90 | AceButton button1(&config1); 91 | ButtonConfig config2; 92 | AceButton button2(&config2); 93 | ButtonConfig config3; 94 | AceButton button3(&config3); 95 | ButtonConfig config4; 96 | AceButton button4(&config4); 97 | 98 | 99 | void handleEvent1(AceButton*, uint8_t, uint8_t); 100 | void handleEvent2(AceButton*, uint8_t, uint8_t); 101 | void handleEvent3(AceButton*, uint8_t, uint8_t); 102 | void handleEvent4(AceButton*, uint8_t, uint8_t); 103 | 104 | void sysProvEvent(arduino_event_t *sys_event) 105 | { 106 | switch (sys_event->event_id) 107 | { 108 | case ARDUINO_EVENT_PROV_START: 109 | Serial.printf("\nProvisioning Started with name \"%s\" and PoP \"%s\" on BLE\n", service_name, pop); 110 | printQR(service_name, pop, "ble"); 111 | break; 112 | case ARDUINO_EVENT_WIFI_STA_GOT_IP: 113 | Serial.print("\nConnected IP address : "); 114 | Serial.println(IPAddress(sys_event->event_info.got_ip.ip_info.ip.addr)); 115 | break; 116 | case ARDUINO_EVENT_WIFI_STA_DISCONNECTED: 117 | Serial.println("\nDisconnected. Connecting to the AP again... "); 118 | break; 119 | case ARDUINO_EVENT_PROV_CRED_RECV: 120 | Serial.println("\nReceived Wi-Fi credentials"); 121 | Serial.print("\tSSID : "); 122 | Serial.println((const char *) sys_event->event_info.prov_cred_recv.ssid); 123 | Serial.print("\tPassword : "); 124 | Serial.println((char const *) sys_event->event_info.prov_cred_recv.password); 125 | break; 126 | case ARDUINO_EVENT_PROV_INIT: 127 | wifi_prov_mgr_disable_auto_stop(10000); 128 | break; 129 | case ARDUINO_EVENT_PROV_CRED_SUCCESS: 130 | Serial.println("Stopping Provisioning!!!"); 131 | wifi_prov_mgr_stop_provisioning(); 132 | break; 133 | } 134 | } 135 | 136 | void write_callback(Device *device, Param *param, const param_val_t val, void *priv_data, write_ctx_t *ctx) 137 | { 138 | const char *device_name = device->getDeviceName(); 139 | const char *param_name = param->getParamName(); 140 | 141 | if (strcmp(device_name, "Fan") == 0) 142 | { 143 | if (strcmp(param_name, "Power") == 0) { 144 | Serial.printf("Received Fan power = %s for %s - %s\n", val.val.b ? "true" : "false", device_name, param_name); 145 | fan_power = val.val.b; 146 | if (fan_power) { 147 | if (curr_speed == 0) 148 | { 149 | speed_0(); 150 | } 151 | if (curr_speed == 1) 152 | { 153 | speed_1(); 154 | } 155 | if (curr_speed == 2) 156 | { 157 | speed_2(); 158 | } 159 | if (curr_speed == 3) 160 | { 161 | speed_3(); 162 | } 163 | if (curr_speed == 4) 164 | { 165 | speed_4(); 166 | } 167 | } 168 | else 169 | speed_0(); 170 | param->updateAndReport(val); 171 | } 172 | 173 | 174 | if (strcmp(param_name, "My_Speed") == 0) 175 | { 176 | Serial.printf("\nReceived value = %d for %s - %s\n", val.val.i, device_name, param_name); 177 | int Slider_Value = val.val.i; 178 | if (Slider_Value == 1) 179 | { 180 | speed_1(); 181 | } 182 | if (Slider_Value == 2) 183 | { 184 | speed_2(); 185 | } 186 | if (Slider_Value == 3) 187 | { 188 | speed_3(); 189 | } 190 | if (Slider_Value == 4) 191 | { 192 | speed_4(); 193 | } 194 | if (Slider_Value == 0) 195 | { 196 | speed_0(); 197 | } 198 | param->updateAndReport(val); 199 | } 200 | 201 | } 202 | if (strcmp(device_name, "light1") == 0) 203 | { 204 | Serial.printf("Switch value_1 = %s\n", val.val.b ? "true" : "false"); 205 | 206 | if (strcmp(param_name, "Power") == 0) { 207 | Serial.printf("Received value = %s for %s - %s\n", val.val.b ? "true" : "false", device_name, param_name); 208 | switch_state_ch1 = val.val.b; 209 | (switch_state_ch1 == false) ? digitalWrite(relay1, LOW) : digitalWrite(relay1, HIGH); 210 | param->updateAndReport(val); 211 | } 212 | 213 | } 214 | if (strcmp(device_name, "light2") == 0) { 215 | 216 | Serial.printf("Switch value_2 = %s\n", val.val.b ? "true" : "false"); 217 | 218 | if (strcmp(param_name, "Power") == 0) { 219 | Serial.printf("Received value = %s for %s - %s\n", val.val.b ? "true" : "false", device_name, param_name); 220 | switch_state_ch2 = val.val.b; 221 | (switch_state_ch2 == false) ? digitalWrite(relay2, LOW) : digitalWrite(relay2, HIGH); 222 | param->updateAndReport(val); 223 | } 224 | } 225 | if (strcmp(device_name, "light3") == 0) { 226 | 227 | Serial.printf("Switch value_3 = %s\n", val.val.b ? "true" : "false"); 228 | 229 | if (strcmp(param_name, "Power") == 0) { 230 | Serial.printf("Received value = %s for %s - %s\n", val.val.b ? "true" : "false", device_name, param_name); 231 | switch_state_ch3 = val.val.b; 232 | (switch_state_ch3 == false) ? digitalWrite(relay3, LOW) : digitalWrite(relay3, HIGH); 233 | param->updateAndReport(val); 234 | } 235 | } 236 | if (strcmp(device_name, "light4") == 0) { 237 | 238 | Serial.printf("Switch value_4 = %s\n", val.val.b ? "true" : "false"); 239 | 240 | if (strcmp(param_name, "Power") == 0) { 241 | Serial.printf("Received value = %s for %s - %s\n", val.val.b ? "true" : "false", device_name, param_name); 242 | switch_state_ch4 = val.val.b; 243 | (switch_state_ch4 == false) ? digitalWrite(relay4, LOW) : digitalWrite(relay4, HIGH); 244 | param->updateAndReport(val); 245 | } 246 | } 247 | } 248 | 249 | 250 | void setup() 251 | { 252 | 253 | Serial.begin(115200); 254 | 255 | // Configure the input GPIOs 256 | pinMode(gpio_reset, INPUT); 257 | pinMode(relay1, OUTPUT); 258 | pinMode(relay2, OUTPUT); 259 | pinMode(relay3, OUTPUT); 260 | pinMode(relay4, OUTPUT); 261 | pinMode(Speed1, OUTPUT); 262 | pinMode(Speed2, OUTPUT); 263 | pinMode(Speed4, OUTPUT); 264 | 265 | pinMode(switch1, INPUT_PULLUP); 266 | pinMode(switch2, INPUT_PULLUP); 267 | pinMode(switch3, INPUT_PULLUP); 268 | pinMode(switch4, INPUT_PULLUP); 269 | 270 | 271 | pinMode(s1, INPUT_PULLUP); 272 | pinMode(s2, INPUT_PULLUP); 273 | pinMode(s3, INPUT_PULLUP); 274 | pinMode(s4, INPUT_PULLUP); 275 | 276 | // Write to the GPIOs the default state on booting 277 | digitalWrite(relay1, DEFAULT_RELAY_STATE); 278 | digitalWrite(relay2, DEFAULT_RELAY_STATE); 279 | digitalWrite(relay3, DEFAULT_RELAY_STATE); 280 | digitalWrite(relay4, DEFAULT_RELAY_STATE); 281 | 282 | config1.setEventHandler(button1Handler); 283 | config2.setEventHandler(button2Handler); 284 | config3.setEventHandler(button3Handler); 285 | config4.setEventHandler(button4Handler); 286 | 287 | button1.init(switch1); 288 | button2.init(switch2); 289 | button3.init(switch3); 290 | button4.init(switch4); 291 | 292 | 293 | Node my_node; 294 | my_node = RMaker.initNode("All In One"); 295 | 296 | //Standard switch device 297 | my_fan.addCb(write_callback); 298 | Param level_param("My_Speed", "custom.param.level", value(0), PROP_FLAG_READ | PROP_FLAG_WRITE); 299 | level_param.addBounds(value(0), value(4), value(1)); 300 | level_param.addUIType(ESP_RMAKER_UI_SLIDER); 301 | my_fan.addParam(level_param); 302 | my_node.addDevice(my_fan); 303 | my_fan.updateAndReportParam("My_Speed", 0); 304 | my_fan.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, fan_power); 305 | delay(500); 306 | 307 | my_switch1.addCb(write_callback); 308 | my_node.addDevice(my_switch1); 309 | my_switch1.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch1); 310 | delay(500); 311 | 312 | my_switch2.addCb(write_callback); 313 | my_node.addDevice(my_switch2); 314 | my_switch2.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch2); 315 | delay(500); 316 | 317 | my_switch3.addCb(write_callback); 318 | my_node.addDevice(my_switch3); 319 | my_switch3.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch3); 320 | delay(500); 321 | 322 | my_switch4.addCb(write_callback); 323 | my_node.addDevice(my_switch4); 324 | my_switch4.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch4); 325 | delay(500); 326 | 327 | //This is optional 328 | RMaker.enableOTA(OTA_USING_PARAMS); 329 | //If you want to enable scheduling, set time zone for your region using setTimeZone(). 330 | //The list of available values are provided here https://rainmaker.espressif.com/docs/time-service.html 331 | // RMaker.setTimeZone("Asia/Shanghai"); 332 | // Alternatively, enable the Timezone service and let the phone apps set the appropriate timezone 333 | RMaker.enableTZService(); 334 | RMaker.enableSchedule(); 335 | 336 | Serial.printf("\nStarting ESP-RainMaker\n"); 337 | RMaker.start(); 338 | delay(2000); 339 | 340 | WiFi.onEvent(sysProvEvent); 341 | WiFiProv.beginProvision(WIFI_PROV_SCHEME_BLE, WIFI_PROV_SCHEME_HANDLER_FREE_BTDM, WIFI_PROV_SECURITY_1, pop, service_name); 342 | 343 | 344 | } 345 | 346 | 347 | void loop() 348 | { 349 | 350 | button1.check(); 351 | button2.check(); 352 | button3.check(); 353 | button4.check(); 354 | fan(); 355 | 356 | 357 | // Read GPIO0 (external button to gpio_reset device 358 | if (digitalRead(gpio_reset) == LOW) { 359 | //Push button pressed 360 | Serial.printf("reset Button Pressed!\n"); 361 | // Key debounce handling 362 | delay(100); 363 | int startTime = millis(); 364 | while (digitalRead(gpio_reset) == LOW) delay(50); 365 | int endTime = millis(); 366 | 367 | if ((endTime - startTime) > 5000) { 368 | // If key pressed for more than 5secs, reset all 369 | Serial.printf("reset to factory.\n"); 370 | RMakerFactoryReset(2); 371 | } 372 | } 373 | delay(100); 374 | } 375 | 376 | 377 | //functions for defineing manual switch 378 | 379 | void button1Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) { 380 | Serial.println("EVENT1"); 381 | //EspalexaDevice* d1 = espalexa.getDevice(0); 382 | switch (eventType) { 383 | case AceButton::kEventPressed: 384 | Serial.println("kEventPressed"); 385 | switch_state_ch1 = true; 386 | my_switch1.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch1); 387 | digitalWrite(relay1, HIGH); 388 | break; 389 | case AceButton::kEventReleased: 390 | Serial.println("kEventReleased"); 391 | switch_state_ch1 = false; 392 | my_switch1.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch1); 393 | digitalWrite(relay1, LOW); 394 | break; 395 | } 396 | } 397 | void button2Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) { 398 | Serial.println("EVENT2"); 399 | //EspalexaDevice* d2 = espalexa.getDevice(1); 400 | switch (eventType) { 401 | case AceButton::kEventPressed: 402 | Serial.println("kEventPressed"); 403 | switch_state_ch2 = true; 404 | my_switch2.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch2); 405 | digitalWrite(relay2, HIGH); 406 | break; 407 | case AceButton::kEventReleased: 408 | Serial.println("kEventReleased"); 409 | switch_state_ch2 = false; 410 | my_switch2.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch2); 411 | digitalWrite(relay2, LOW); 412 | break; 413 | } 414 | } 415 | void button3Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) { 416 | Serial.println("EVENT3"); 417 | //EspalexaDevice* d3 = espalexa.getDevice(2); 418 | switch (eventType) { 419 | case AceButton::kEventPressed: 420 | Serial.println("kEventPressed"); 421 | switch_state_ch3 = true; 422 | my_switch3.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch3); 423 | digitalWrite(relay3, HIGH); 424 | break; 425 | case AceButton::kEventReleased: 426 | Serial.println("kEventReleased"); 427 | switch_state_ch3 = false; 428 | my_switch3.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch3); 429 | digitalWrite(relay3, LOW); 430 | break; 431 | } 432 | } 433 | void button4Handler(AceButton* button, uint8_t eventType, uint8_t buttonState) { 434 | Serial.println("EVENT4"); 435 | //EspalexaDevice* d4 = espalexa.getDevice(3); 436 | switch (eventType) { 437 | case AceButton::kEventPressed: 438 | Serial.println("kEventPressed"); 439 | switch_state_ch4 = true; 440 | my_switch4.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch4); 441 | digitalWrite(relay4, HIGH); 442 | break; 443 | case AceButton::kEventReleased: 444 | Serial.println("kEventReleased"); 445 | switch_state_ch4 = false; 446 | my_switch4.updateAndReportParam(ESP_RMAKER_DEF_POWER_NAME, switch_state_ch4); 447 | digitalWrite(relay4, LOW); 448 | break; 449 | } 450 | } 451 | 452 | 453 | //functions for defineing of speeds 454 | 455 | void speed_0() 456 | { 457 | //All Relays Off - Fan at speed 0 458 | if (DEBUG_SW)Serial.println("SPEED 0"); 459 | fan_power = 0; 460 | my_fan.updateAndReportParam("My_Speed", 0); 461 | my_fan.updateAndReportParam("Power", fan_power); 462 | digitalWrite(Speed1, LOW); 463 | digitalWrite(Speed2, LOW); 464 | digitalWrite(Speed4, LOW); 465 | 466 | } 467 | 468 | void speed_1() 469 | { 470 | //Speed1 Relay On - Fan at speed 1 471 | if (DEBUG_SW)Serial.println("SPEED 1"); 472 | curr_speed = 1; 473 | fan_power = 1; 474 | my_fan.updateAndReportParam("My_Speed", 1); 475 | my_fan.updateAndReportParam("Power", fan_power); 476 | digitalWrite(Speed1, LOW); 477 | digitalWrite(Speed2, LOW); 478 | digitalWrite(Speed4, LOW); 479 | delay(1000); 480 | digitalWrite(Speed1, HIGH); 481 | } 482 | 483 | void speed_2() 484 | { 485 | //Speed2 Relay On - Fan at speed 2 486 | if (DEBUG_SW)Serial.println("SPEED 2"); 487 | curr_speed = 2; 488 | fan_power = 1; 489 | my_fan.updateAndReportParam("My_Speed", 2); 490 | my_fan.updateAndReportParam("Power", fan_power); 491 | digitalWrite(Speed1, LOW); 492 | digitalWrite(Speed2, LOW); 493 | digitalWrite(Speed4, LOW); 494 | delay(1000); 495 | digitalWrite(Speed2, HIGH); 496 | } 497 | 498 | void speed_3() 499 | { 500 | //Speed1 & Speed2 Relays On - Fan at speed 3 501 | if (DEBUG_SW)Serial.println("SPEED 3"); 502 | curr_speed = 3; 503 | fan_power = 1; 504 | my_fan.updateAndReportParam("My_Speed", 3); 505 | my_fan.updateAndReportParam("Power", fan_power); 506 | digitalWrite(Speed1, LOW); 507 | digitalWrite(Speed2, LOW); 508 | digitalWrite(Speed4, LOW); 509 | delay(1000); 510 | digitalWrite(Speed1, HIGH); 511 | digitalWrite(Speed2, HIGH); 512 | 513 | } 514 | 515 | void speed_4() 516 | { 517 | //Speed4 Relay On - Fan at speed 4 518 | if (DEBUG_SW)Serial.println("SPEED 4"); 519 | curr_speed = 4; 520 | fan_power = 1; 521 | my_fan.updateAndReportParam("My_Speed", 4); 522 | my_fan.updateAndReportParam("Power", fan_power); 523 | digitalWrite(Speed1, LOW); 524 | digitalWrite(Speed2, LOW); 525 | digitalWrite(Speed4, LOW); 526 | delay(1000); 527 | digitalWrite(Speed4, HIGH); 528 | } 529 | 530 | 531 | // function for controling fan using regulator 532 | 533 | void fan() 534 | { 535 | if (digitalRead(s1) == LOW && speed1_flag == 1) 536 | { 537 | speed_1(); 538 | speed1_flag = 0; 539 | speed2_flag = 1; 540 | speed3_flag = 1; 541 | speed4_flag = 1; 542 | speed0_flag = 1; 543 | 544 | 545 | } 546 | if (digitalRead(s2) == LOW && digitalRead(s3) == HIGH && speed2_flag == 1) 547 | { 548 | speed_2(); 549 | speed1_flag = 1; 550 | speed2_flag = 0; 551 | speed3_flag = 1; 552 | speed4_flag = 1; 553 | speed0_flag = 1; 554 | 555 | } 556 | if (digitalRead(s2) == LOW && digitalRead(s3) == LOW && speed3_flag == 1) 557 | { 558 | speed_3(); 559 | speed1_flag = 1; 560 | speed2_flag = 1; 561 | speed3_flag = 0; 562 | speed4_flag = 1; 563 | speed0_flag = 1; 564 | } 565 | if (digitalRead(s4) == LOW && speed4_flag == 1) 566 | { 567 | speed_4(); 568 | speed1_flag = 1; 569 | speed2_flag = 1; 570 | speed3_flag = 1; 571 | speed4_flag = 0; 572 | speed0_flag = 1; 573 | } 574 | if (digitalRead(s1) == HIGH && digitalRead(s2) == HIGH && digitalRead(s3) == HIGH && digitalRead(s4) == HIGH && speed0_flag == 1) 575 | { 576 | speed_0(); 577 | speed1_flag = 1; 578 | speed2_flag = 1; 579 | speed3_flag = 1; 580 | speed4_flag = 1; 581 | speed0_flag = 0; 582 | } 583 | 584 | } 585 | --------------------------------------------------------------------------------