Mqtt

#include <SimpleDHT.h>
#include <ESP8266WiFi.h>
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"

#define WLAN_SSID "hardbro1"

#define WLAN_PASS "7204871501"
// Adafruit IO
#define AIO_SERVER "io.adafruit.com"
#define AIO_SERVERPORT 1883
#define AIO_USERNAME "malipadma"
#define AIO_KEY "aio_Svfv84jzGRCbNS1zbrrOKnQJi7kr"
WiFiClient client;

Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME,

AIO_KEY);
Adafruit_MQTT_Publish Temperature1 = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME
"/feeds/Temperature1");
Adafruit_MQTT_Publish Humidity1 = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME
"/feeds/Humidity1");

int pinDHT11 = 0;
SimpleDHT11 dht11(pinDHT11);
byte hum = 0;
byte temp = 0;
void setup() {
Serial.begin(115200);
Serial.println(F("Adafruit IO Example"));

Serial.println(); Serial.println();
delay(10);
Serial.print(F("Connecting to "));
Serial.println(WLAN_SSID);
WiFi.begin(WLAN_SSID, WLAN_PASS);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(F("."));
}
Serial.println();
Serial.println(F("WiFi connected"));
Serial.println(F("IP address: "));
Serial.println(WiFi.localIP());
connect();

}void connect() {
Serial.print(F("Connecting to Adafruit IO... "));
int8_t ret;
while ((ret = mqtt.connect()) != 0) {
switch (ret) {
case 1: Serial.println(F("Wrong protocol")); break;
case 2: Serial.println(F("ID rejected")); break;
case 3: Serial.println(F("Server unavail")); break;
case 4: Serial.println(F("Bad user/pass")); break;
 case 5: Serial.println(F("Not authed")); break;
case 6: Serial.println(F("Failed to subscribe")); break;
default: Serial.println(F("Connection failed")); break;
}if(ret >= 0)
mqtt.disconnect();

Serial.println(F("Retrying connection..."));
delay(10000);
}
Serial.println(F("Adafruit IO Connected!"));
}
void loop() {

if(! mqtt.ping(3)) {

if(! mqtt.connected())
connect();
}
dht11.read(&temp, &hum, NULL);
Serial.print((int)temp); Serial.print(" *C, ");
Serial.print((int)hum); Serial.println(" H");
delay(5000);

if (! Temperature1.publish(temp)) {
Serial.println(F("Failed"));
}
if (! Humidity1.publish(hum)) {
Serial.println(F("Failed"));
}
else {
Serial.println(F("Sent!"));
}
}

GSM
#include <SoftwareSerial.h>

SoftwareSerial SIM900A(2,3);

void setup()
{
SIM900A.begin(9600);
Serial.begin(9600);
Serial.println ("Text Messege Module Ready & Verified");
delay(100);
Serial.println ("enter s to send message or r to receive message");
}

void loop()
{

if (Serial.available()>0)
switch(Serial.read())
{
case 's':
SendMessage();
break;
case 'r':
RecieveMessage();
break;
}

if (SIM900A.available()>0)
Serial.write(SIM900A.read());
}

void SendMessage()
{
Serial.println ("Sending Message ....");
SIM900A.println("AT+CMGF=1");
delay(1000);
Serial.println ("Set SMS Number");
SIM900A.println("AT+CMGS=\"+917349043144\"\r");
delay(1000);
Serial.println ("Set SMS Content");
SIM900A.println("HIii mem...");
delay(100);
Serial.println ("message sent succesfully");
SIM900A.println((char)26);
Serial.println ("done");
}

void RecieveMessage()
{
Serial.println ("Receiving Messeges");
delay(1000);
SIM900A.println("AT+CNMI=2,2,0,0,0");
delay(1000);
Serial.println("Messege Received Sucessfully");
}

BLYNK LED
#define BLYNK_TEMPLATE_ID "TMPL3ShzF0te0"
#define BLYNK_TEMPLATE_NAME "blynk25"
#define BLYNK_AUTH_TOKEN "qVoqOskPSw4YbHjsmjPaycW6Be8xMrio"

#define BLYNK_WRITE Simple

#include<ESP8266WiFi.h>
#include<BlynkSimpleEsp8266.h>

char auth[]= BLYNK_AUTH_TOKEN;

char ssid[]="OPPO A77";
char pass[]="123456789";

BLYNK_WRITE(V0){
digitalWrite(D0, param.asInt());

}
BLYNK_WRITE(V1){
digitalWrite(D1, param.asInt());

}
void setup(){
pinMode(D0, OUTPUT);
pinMode(D1, OUTPUT);
Blynk.begin(auth, ssid, pass, "Blynk.cloud", 80);
}
void loop(){
Blynk.run();
}

BLYNK ULTRAAA
#define BLYNK_TEMPLATE_ID "TMPL3Ne0T-B1O"
#define BLYNK_TEMPLATE_NAME "wff"
#define BLYNK_AUTH_TOKEN "ET4kzDsmBk7dIWdQAUjYFXPYUmxeLdyx"

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>

char auth[] = "YOUR_AUTH_TOKEN"; // Blynk Auth Token

const char* ssid = "hardbro1";
const char* password = "YOUR_PASSWORD";

#define TRIG_PIN D1
#define ECHO_PIN D2

void setup() {
Serial.begin(115200);
Blynk.begin(auth, ssid, password);
pinMode(TRIG_PIN, OUTPUT);
pinMode(ECHO_PIN, INPUT);
}

void loop() {
long duration, distance;
digitalWrite(TRIG_PIN, LOW);
delayMicroseconds(2);
digitalWrite(TRIG_PIN, HIGH);
delayMicroseconds(10);
digitalWrite(TRIG_PIN, LOW);

duration = pulseIn(ECHO_PIN, HIGH);

distance = (duration * 0.034) / 2; // Calculate distance in cm

Blynk.virtualWrite(V1, distance); // Send distance to Blynk

Serial.print("Distance: ");
Serial.println(distance);

Blynk.run();
delay(1000); // Update every second
}
BLYNK GAS
#define BLYNK_TEMPLATE_ID "TMPL3Ne0T-B1O"
#define BLYNK_TEMPLATE_NAME "wff"
#define BLYNK_AUTH_TOKEN "ET4kzDsmBk7dIWdQAUjYFXPYUmxeLdyx"

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <SimpleTimer.h>

#define BLYNK_PRINT Serial // Comment this out to disable prints and save space

char auth[] = "YOUR_AUTH_TOKEN"; // Blynk Auth Token

const char* ssid = "hardbro1";
const char* password = "YOUR_PASSWORD";

SimpleTimer timer;
int mq2 = A0; // MQ-2 sensor connected to analog pin A0
int data = 0;

void setup() {
Serial.begin(115200);
Blynk.begin(auth, ssid, password);
timer.setInterval(1000L, sendData); // Send data every second
}

void loop() {
timer.run(); // Initiates SimpleTimer
Blynk.run(); // Run Blynk
}

void sendData() {
data = analogRead(mq2); // Read data from MQ-2 sensor
Blynk.virtualWrite(V2, data); // Send data to virtual pin V2

// Check if gas level exceeds threshold

if (data > 700) {
Blynk.notify("Gas Detected!"); // Send notification
}
}

BLYNK DHT11
#define BLYNK_TEMPLATE_ID "TMPL3Ne0T-B1O"
#define BLYNK_TEMPLATE_NAME "wff"
#define BLYNK_AUTH_TOKEN "ET4kzDsmBk7dIWdQAUjYFXPYUmxeLdyx"

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <DHT.h>

#define DHTPIN D2
#define DHTTYPE DHT11

DHT dht(DHTPIN, DHTTYPE); // Initialize DHT sensor

char auth[] = "YOUR_AUTH_TOKEN"; // Blynk Auth Token
const char* ssid = "hardbro1";
const char* password = "YOUR_PASSWORD";

void setup() {
Serial.begin(115200);
Blynk.begin(auth, ssid, password);
dht.begin(); // Start the DHT sensor
}

void loop() {
float h = dht.readHumidity(); // Read humidity
float t = dht.readTemperature(); // Read temperature in Celsius

// Check if any reads failed and exit early (to try again).
if (isnan(h) || isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
return;
}

// Send data to Blynk

Blynk.virtualWrite(V0, t); // Send temperature to virtual pin V0
Blynk.virtualWrite(V1, h); // Send humidity to virtual pin V1

// Print to Serial Monitor for debugging

Serial.print("Temperature: ");
Serial.print(t);
Serial.print(" °C, Humidity: ");
Serial.print(h);
Serial.println(" %");

Blynk.run(); // Run Blynk

delay(2000); // Update every 2 seconds
}

THINGSPEAK ULTR
#include <ESP8266WiFi.h>
String apiKey = "DEBYH0AIT4FH8VMV";
const char* ssid = "Shanta c m";
const char* password = "Priyunammu...";

unsigned long channel = 2257456;

const char* server = "api.thingspeak.com";
WiFiClient client;

const int trigPin = D6;

const int echoPin = D7;

long duration;
int distance;
void setup()
{
Serial.begin(9600);
 Serial.println("Serial Begin");
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
WiFi.begin(ssid, password);
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);

while (WiFi.status() != WL_CONNECTED)

{
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
}

void loop()
{
ultra();
delay(1000);

if (client.connect(server,80))
{
fwd_to_Thingspeak();
}
client.stop();
Serial.println("Waiting");
delay(1000);
}

void ultra()
{

digitalWrite(trigPin, LOW);
delayMicroseconds(2);

digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH) ;

distance= duration*0.034/2;
Serial.println("Distance =" + String(distance) + " cm");
}

void fwd_to_Thingspeak()
{
String postStr = apiKey;
postStr +="&field1=";
postStr += String(distance);
postStr += "\r\n\r\n";

client.print("POST /update HTTP/1.1\n");

client.print("Host: api.thingspeak.com\n");
client.print("Connection: close\n");
 client.print("X-THINGSPEAKAPIKEY: "+apiKey+"\n");
client.print("Content-Type: application/x-www-form-urlencoded\n");
client.print("Content-Length: ");
client.print(postStr.length());
client.print("\n\n");
client.print(postStr);

Serial.println("Send data to thingspeak: ");

Serial.print("Content-Length: ");
Serial.print(postStr.length());
Serial.print(" Field-1: ");
Serial.print(distance);
Serial.println(" data send");
}

THING GAS
#include <ESP8266WiFi.h>
String apiKey = "SKP9YQY2CFVNK919"; // Enter your Write API key from ThingSpeak
const char *ssid = "Alexahome"; // replace with your wifi ssid and wpa2 key
const char *pass = "hngzhowxiantan";
const char* server = "api.thingspeak.com";
WiFiClient client;
void setup()
{
Serial.begin(115200);
delay(10);
Serial.println("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, pass);
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
}
void loop()
{
float h = analogRead(A0);
if (isnan(h))
{
Serial.println("Failed to read from MQ-5 sensor!");
return;
}

if (client.connect(server, 80)) // "184.106.153.149" or api.thingspeak.com

{
String postStr = apiKey;
postStr += "&field1=";
postStr += String(h/1023*100);
postStr += "r\n";
client.print("POST /update HTTP/1.1\n");
client.print("Host: api.thingspeak.com\n");
client.print("Connection: close\n");
client.print("X-THINGSPEAKAPIKEY: " + apiKey + "\n");
client.print("Content-Type: application/x-www-form-urlencoded\n");
client.print("Content-Length: ");
client.print(postStr.length());
client.print("\n\n");
client.print(postStr);
Serial.print("Gas Level: ");
Serial.println(h/1023*100);
Serial.println("Data Send to Thingspeak");
}
delay(500);
client.stop();
Serial.println("Waiting...");

// thingspeak needs minimum 15 sec delay between updates.

delay(1500);
}

THING DHT11
#include <DHT.h> // Including library for dht

#include <ESP8266WiFi.h>

String apiKey = "H38TEGNC0XKW43BB"; // Enter your Write API key from

ThingSpeak

const char *ssid = "how2electronics"; // replace with your wifi ssid and wpa2
key
const char *pass = "alhabibi";
const char* server = "api.thingspeak.com";

#define DHTPIN 0 //pin where the dht11 is connected

DHT dht(DHTPIN, DHT11);

WiFiClient client;

void setup()
{
Serial.begin(115200);
delay(10);
dht.begin();

Serial.println("Connecting to ");
Serial.println(ssid);

WiFi.begin(ssid, pass);

while (WiFi.status() != WL_CONNECTED)

{
delay(500);
 Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");

void loop()
{

float h = dht.readHumidity();
float t = dht.readTemperature();

if (isnan(h) || isnan(t))
{
Serial.println("Failed to read from DHT sensor!");
return;
}

if (client.connect(server,80)) // "184.106.153.149" or
api.thingspeak.com
{

String postStr = apiKey;

postStr +="&field1=";
postStr += String(t);
postStr +="&field2=";
postStr += String(h);
postStr += "\r\n\r\n";

client.print("POST /update HTTP/1.1\n");

client.print("Host: api.thingspeak.com\n");
client.print("Connection: close\n");
client.print("X-THINGSPEAKAPIKEY: "+apiKey+"\n");
client.print("Content-Type: application/x-www-form-
urlencoded\n");
client.print("Content-Length: ");
client.print(postStr.length());
client.print("\n\n");
client.print(postStr);

Serial.print("Temperature: ");
Serial.print(t);
Serial.print(" degrees Celcius, Humidity: ");
Serial.print(h);
Serial.println("%. Send to Thingspeak.");
}
client.stop();

Serial.println("Waiting...");

// thingspeak needs minimum 15 sec delay between updates

delay(1000);
}
THING IR
#include <ESP8266WiFi.h>
#include "ThingSpeak.h"

const char* ssid = "hardbro1";

const char* password = "YOUR_PASSWORD";

WiFiClient client;

unsigned long myChannelNumber = 2664328;

const char * myWriteAPIKey = "BFZURARIYW43ZV29";

int irSensorPin = D2;

int irValue;

void setup() {
Serial.begin(115200);
pinMode(irSensorPin, INPUT);
WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(1000);
Serial.println("Connecting to WiFi...");
}
Serial.println("Connected to WiFi");
ThingSpeak.begin(client);
}

void loop() {
irValue = digitalRead(irSensorPin);
Serial.print("IR Sensor Value: ");
Serial.println(irValue);

ThingSpeak.setField(1, irValue);
int x = ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);

if (x == 200) {
Serial.println("Channel update successful.");
} else {
Serial.println("Problem updating channel. HTTP error code " + String(x));
}
delay(30000); // Update every 30 seconds
}

SMART IRRIGATION
#define BLYNK_TEMPLATE_ID "TMPL3Ne0T-B1O"
#define BLYNK_TEMPLATE_NAME "wff"
#define BLYNK_AUTH_TOKEN "ET4kzDsmBk7dIWdQAUjYFXPYUmxeLdyx"
#define BLYNK_PRINT Serial
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <DHT.h>
char auth[] = BLYNK_AUTH_TOKEN;
char ssid[] = "vivo Y33s";
char pass[] = "7204871501";
BlynkTimer timer;

#define DHTPIN 4
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

void sendSensor()
{

int value = analogRead(A0);

value = map(value,400,1023,100,0);
float h = dht.readHumidity();
float t = dht.readTemperature();
if (isnan(h) || isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
return;
}

Blynk.virtualWrite(V0, value);
Blynk.virtualWrite(V1, t);
Blynk.virtualWrite(V2, h);
Serial.print("Soil Moisture : ");
Serial.print(value);
Serial.print("Temperature : ");
Serial.print(t);
Serial.print(" Humidity : ");
Serial.println(h);
}
void setup()
{
Serial.begin(115200);
Blynk.begin(auth, ssid, pass);
dht.begin();
timer.setInterval(100L, sendSensor);
}
void loop()
{
Blynk.run();
timer.run();
}

ARDUINO TO NODE MCU

Arduino uno
#include <DHT.h>

#define DHTPIN 2
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);
void setup() {
Serial.begin(9600);
dht.begin();
}

void loop() {
float h = dht.readHumidity();
float t = dht.readTemperature();

if (isnan(h) || isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
return;
}

Serial.print("H:");
Serial.print(h);
Serial.print(",T:");
Serial.println(t);

delay(20000);
}

Node mcu
#include <ESP8266WiFi.h>
#include <ThingSpeak.h>

const char* ssid = "OPPO A77";

const char* password = "hardbro1";
unsigned long myChannelNumber =2662012;
const char* myWriteAPIKey = "B5R9P7IN8O4R4O8I";

WiFiClient client;

void setup() {
Serial.begin(9600);
WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(1000);
Serial.println("Connecting to WiFi...");
}
Serial.println("Connected to WiFi");
ThingSpeak.begin(client);
}

void loop() {
if (Serial.available()) {
String data = Serial.readStringUntil('\n');
 int humidityIndex = data.indexOf("H:");
int temperatureIndex = data.indexOf(",T:");

if (humidityIndex != -1 && temperatureIndex != -1) {

float h = data.substring(humidityIndex + 2, temperatureIndex).toFloat();
float t = data.substring(temperatureIndex + 3).toFloat();

Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
Serial.print(t);
Serial.println(" *C");

ThingSpeak.setField(1, h);
ThingSpeak.setField(2, t);

int responseCode = ThingSpeak.writeFields(myChannelNumber, myWriteAPIKey);

if (responseCode == 200) {
Serial.println("Data sent successfully");
} else {
Serial.print("Error sending data. HTTP code: ");
Serial.println(responseCode);
}
}
}

delay(20000);
}

ALEXA
#include "arduino_secrets.h"
#include "thingProperties.h"

#define RelayPin1 5 //D1

#define RelayPin2 4 //D2
#define RelayPin3 14 //D5
#define RelayPin4 12 //D6

#define wifiLed 16 //D0

int toggleState_1 = 0;
int toggleState_2 = 0;
int toggleState_3 = 0;
int toggleState_4 = 0;

void relayOnOff(int relay) {

switch (relay) {
 case 1:
if (toggleState_1 == 0) {
digitalWrite(RelayPin1, LOW);
toggleState_1 = 1;
Serial.println("Device1 ON");
}
else {
digitalWrite(RelayPin1, HIGH);
toggleState_1 = 0;
Serial.println("Device1 OFF");
}
delay(100);
break;
case 2:
if (toggleState_2 == 0) {
digitalWrite(RelayPin2, LOW); // turn on relay 2
toggleState_2 = 1;
Serial.println("Device2 ON");
}
else {
digitalWrite(RelayPin2, HIGH); // turn off relay 2
toggleState_2 = 0;
Serial.println("Device2 OFF");
}
delay(100);
break;
case 3:
if (toggleState_3 == 0) {
digitalWrite(RelayPin3, LOW); // turn on relay 3
toggleState_3 = 1;
Serial.println("Device3 ON");
} else {
digitalWrite(RelayPin3, HIGH); // turn off relay 3
toggleState_3 = 0;
Serial.println("Device3 OFF");
}
delay(100);
break;
case 4:
if (toggleState_4 == 0) {
digitalWrite(RelayPin4, LOW); // turn on relay 4
toggleState_4 = 1;
Serial.println("Device4 ON");
}
else {
digitalWrite(RelayPin4, HIGH); // turn off relay 4
toggleState_4 = 0;
Serial.println("Device4 OFF");
}
delay(100);
break;
default : break;
}
}

void setup() {
 // Initialize serial and wait for port to open:
Serial.begin(9600);
// This delay gives the chance to wait for a Serial Monitor without blocking if
none is found
delay(1500);

// Defined in thingProperties.h
initProperties();

// Connect to Arduino IoT Cloud

ArduinoCloud.begin(ArduinoIoTPreferredConnection);

setDebugMessageLevel(2);
ArduinoCloud.printDebugInfo();

pinMode(RelayPin1, OUTPUT);
pinMode(RelayPin2, OUTPUT);
pinMode(RelayPin3, OUTPUT);
pinMode(RelayPin4, OUTPUT);

pinMode(wifiLed, OUTPUT);

//During Starting all Relays should TURN OFF

digitalWrite(RelayPin1, HIGH);
digitalWrite(RelayPin2, HIGH);
digitalWrite(RelayPin3, HIGH);
digitalWrite(RelayPin4, HIGH);

digitalWrite(wifiLed, HIGH); //Turn OFF WiFi LED

}

void loop() {
ArduinoCloud.update();

if (WiFi.status() != WL_CONNECTED)
{
digitalWrite(wifiLed, HIGH); //Turn OFF WiFi LED
}
else{
digitalWrite(wifiLed, LOW); //Turn ON WiFi LED
}
}

void onLight1Change() {
if (light1 == 1)
{
digitalWrite(RelayPin1, LOW);
Serial.println("Device1 ON");
toggleState_1 = 1;
}
else
{
digitalWrite(RelayPin1, HIGH);
Serial.println("Device1 OFF");
toggleState_1 = 0;
 }
}

void onLight2Change() {
if (light2 == 1)
{
digitalWrite(RelayPin2, LOW);
Serial.println("Device2 ON");
toggleState_2 = 1;
}
else
{
digitalWrite(RelayPin2, HIGH);
Serial.println("Device2 OFF");
toggleState_2 = 0;
}
}

void onLight3Change() {
if (light3 == 1)
{
digitalWrite(RelayPin3, LOW);
Serial.println("Device2 ON");
toggleState_3 = 1;
}
else
{
digitalWrite(RelayPin3, HIGH);
Serial.println("Device3 OFF");
toggleState_3 = 0;
}
}

void onLight4Change() {
if (light4 == 1)
{
digitalWrite(RelayPin4, LOW);
Serial.println("Device4 ON");
toggleState_4 = 1;
}
else
{
digitalWrite(RelayPin4, HIGH);
Serial.println("Device4 OFF");
toggleState_4 = 0;
}
}

ALEX arduino_secrets
#define SECRET_SSID "motoedge50fusion_4523" //Enter WIFI NAME
#define SECRET_PASS "123456789" //Enter WIFI PASSWORD
#define SECRET_DEVICE_KEY "13f233d3-72fa-4d3e-9eac-8b487c702701"
//Enter Secret Key

ALEXA thingProperties
#include <ArduinoIoTCloud.h>
#include <Arduino_ConnectionHandler.h>

const char THING_ID[] = "558cc306-7661-453a-9fba-bb27187e3569";

const char DEVICE_LOGIN_NAME[] = "13f233d3-72fa-4d3e-9eac-8b487c702701";

const char SSID[] = SECRET_SSID;

const char PASS[] = SECRET_PASS;
const char DEVICE_KEY[] = SECRET_DEVICE_KEY;

void onLight1Change();
void onLight2Change();
void onLight3Change();
void onLight4Change();

CloudSwitch light1;
CloudSwitch light2;
CloudSwitch light3;
CloudSwitch light4;

void initProperties(){

ArduinoCloud.setBoardId(DEVICE_LOGIN_NAME);
ArduinoCloud.setSecretDeviceKey(DEVICE_KEY);
ArduinoCloud.setThingId(THING_ID);
ArduinoCloud.addProperty(light1, READWRITE, ON_CHANGE, onLight1Change);
ArduinoCloud.addProperty(light2, READWRITE, ON_CHANGE, onLight2Change);
ArduinoCloud.addProperty(light3, READWRITE, ON_CHANGE, onLight3Change);
ArduinoCloud.addProperty(light4, READWRITE, ON_CHANGE, onLight4Change);

WiFiConnectionHandler ArduinoIoTPreferredConnection(SSID, PASS);