Controlar Led 13 de Arduino desde email

#1
Hola:

Hice un código con C# de la consola en el cual puedes apagar y encender el famoso y popular Led 13. Uso el LCD Keypad Shield para ver en pantalla los mensajes a parte desde el PC.

El código es una versión alfa pero funcional. Puede recibir códigos desde un correo electrónico pero no puede ejecutar comandos desde el teclado ni directamente desde Arduino, voy por parte.

Les dejo el código para que hagan pruebas y comente sus impresiones sobre lo que he hecho para mejorarlo. Si, está en modo consola, má adelante se hará con Windows Form y WPF, a parte de C#, también con Visual Basic .net y Visual C++.

Puedes enviar con tu movil (o celular) en cualquier parte y enviar comandos.

Dejo claroue tiene sistema de filtros de los email, solo acepta comandos de los email que hayas filtrado, de lo contrario cualquiera te puede cerrar o bajar las persianas de tu casa, ajjajajajjaja.

Recuerdo que la aplicación es alfa, falta codear que de respuesta desde el P hacia el movil el estado de las persianas, ventiladores o luces de la casa como están y si realmente se ha ejecutado dicha orden.

A descargar si no lo tienen, Visual Studio Community gratuito.

Código Arduino:
Código:
#include <LiquidCrystal.h>

// Inicializa la librería con sus pines indicados.
// RS, RW, Enable, D4, D5, D6, D7.
LiquidCrystal lcd(8, NULL, 9, 4, 5, 6, 7);
// LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

// Pin 10 para saber que es luz de fondo.
const byte LuzFondo = 10;

const byte Led = 13;   // Declaramos la variable pin del Led.
char caracter;
String comando;

void setup()
{
  pinMode(Led, OUTPUT);  // Inicializa el pin del LED como salida:
  Serial.begin(115200);     // Puerto serie 115200 baudios.
  lcd.begin(16, 2);         // Formato de pantalla.
  lcd.clear();      // Borra la pantalla y su posición superior izquierda.
  lcd.print("    Arduino     ");
  delay(1000);
}

void loop()
{
  /*
    Voy leyendo carácter a carácter lo que se recibe por el canal serie
    (mientras llegue algún dato allí), y los voy concatenando uno tras otro
    en una cadena. En la práctica, si usamos el "Serial monitor" el bucle while
    acabará cuando pulsamos Enter. El delay es conveniente para no saturar el
    canal serie y que la concatenación se haga de forma ordenada.
  */
  while (Serial.available() > 0)
  {
    caracter = Serial.read();
    comando.concat(caracter);
    delay(10);
  }

  /*
    Una vez ya tengo la cadena "acabada", compruebo su valor y hago que
    la placa Arduino reacciones según sea este. Aquí podríamos hacer lo
    que quisiéramos: si el comando es "tal", enciende un Led, si es cual,
    mueve un motor... y así.
  */

  // Si los carácteres es recibido y verdadero.
  if (comando.equals("Luz_ON") == true)
  {
    digitalWrite(Led, HIGH); // Enciende el Led 13.
    Serial.write("ON - Led encendido.");    // Envía este mensaje al PC.
    lcd.setCursor(0, 1);
    lcd.print("Luz ON.         "); // Mostrar en el LCD.
  }


  if (comando.equals("Luz_OFF") == true)
  {
    digitalWrite(Led, LOW); // Apaga el Led 13.
    Serial.write("OFF - Led apagado. ");  // Envía este mensaje al PC.
    lcd.setCursor(0, 1);
    lcd.print("Luz OFF.        "); // Mostrar en el LCD.
  }

  // Limpiamos la cadena para volver a recibir el siguiente comando.
  comando = "";
}
Luz_OFF // Apaga el Led de Arduino.

Luz_ON // Enciende el Led de Arduino.

Salir. // Sale del programa C# o se cierra.

Son solo tres comandos. Esos comandos indicado arriba solo lo pones en el email en Asuntos y lo detecta. En mensaje no tienes que poner nada, los lee y muestra en pantalla pero nada más.

Código C#:
C#:
// Activar / desactivar Acceso de aplicaciones poco seguras en Google.
// https://myaccount.google.com/lesssecureapps

using System;
using System.Collections.Generic;
using OpenPop.Pop3;
using OpenPop.Mime;
using System.Text.RegularExpressions;
using System.IO.Ports;
using System.Text;
using System.Timers;

namespace Recibir_email_enviar_arduino_01
{
    class Program
    {
        // Disparador de eventos del timer. Dispara cada cierto tiempo por el timer.
        public static void DisparadorEventosTimer(object source, ElapsedEventArgs e)
        {
            //ConsoleKey tecla;
            string comando = "";

            ConnectPop3 oC = new ConnectPop3();

            List<OpenPop.Mime.Message> lstMessages = oC.GetMessages();


            if (lstMessages != null)
            {

                foreach (var oMessage in lstMessages)
                {
                    Console.ForegroundColor = ConsoleColor.White;
                    Console.WriteLine("EMAIL DE: ");
                    Console.ForegroundColor = ConsoleColor.Gray;

                    string emailDesde = oMessage.Headers.From.ToString();

                    // Expresión regular detectar dirección email.
                    Regex rx = new Regex(@"<(.*?)>");
                    //Regex rx = new Regex(@"^([da-z_.-]+)@([da-z.-]+).([a-z.]{2,6})$");
                    // Guarda la dirección email en la variable "emailCompleto".
                    string emailCompleto = rx.Match(emailDesde).Groups[1].Value;
                    // Muestra solo la dirección del email.
                    Console.WriteLine(emailCompleto);

                    // ¿Son email filtrados? Sí, ejecuta las intrucciones necesarios para leer asunto y mensajes.
                    if ((emailCompleto == "metaconta@gmail.com") || (emailCompleto == "celltium@gmail.com"))
                    {
                        Console.WriteLine("{0} a pasado el filtro: ", emailCompleto);

                        Console.ForegroundColor = ConsoleColor.White;
                        Console.WriteLine();
                        Console.WriteLine("ASUNTO: ");
                        Console.ForegroundColor = ConsoleColor.Gray;
                        Console.WriteLine(oMessage.Headers.Subject + "\n"); // Asunto.
                        comando = oMessage.Headers.Subject; // Guarda el asunto en la variable "comando".
                        Console.ForegroundColor = ConsoleColor.White;
                        Console.WriteLine();
                        Console.WriteLine("MENSAJE: ");
                        Console.ForegroundColor = ConsoleColor.Gray;
                        Console.WriteLine();

                        // ¿Es texto sin formato? Sí.
                        // if (oMessage.MessagePart.IsText == true)
                        if (oMessage.MessagePart.IsText)
                        {
                            Console.WriteLine("Texto sin formato.");
                            Console.WriteLine(oMessage.MessagePart.GetBodyAsText());
                            Console.WriteLine("-------------------------------------------");
                        }
                        // No. Texto con formato.
                        else
                        {
                            Console.WriteLine("Texto con formato.");

                            // Encuentra el primer texto sin formato.
                            MessagePart plainTextPart = oMessage.FindFirstPlainTextVersion();
                            if (plainTextPart != null)
                            {
                                // El mensaje tenía una versión de texto sin formato.
                                Console.WriteLine(plainTextPart.GetBodyAsText());
                            }
                            else
                            {
                                // Trate de encontrar un cuerpo para mostrar en algunas de las otras versiones de texto.
                                List<MessagePart> textVersions = oMessage.FindAllTextVersions();
                                if (textVersions.Count >= 1)
                                {
                                    Console.WriteLine(textVersions[0].GetBodyAsText());
                                }
                                else
                                {
                                    Console.WriteLine("<<OpenPop>> Cannot find a text version body in this message to show <<OpenPop>>");
                                }
                            }
                        }
                    }

                    // No. Entonces,ignorará los email no filtrados.
                    else
                    {
                        Console.WriteLine("No ha pasado el filtro y no se leerá ningún email.");
                    }
                }
            }
            Console.ForegroundColor = ConsoleColor.Yellow; // Letras amarillas.
            Console.WriteLine();
            Console.WriteLine("FIN DEL PROGRAMA.");
            //Console.ReadKey(); // Pulse cualquier tecla para salir.
            Console.ForegroundColor = ConsoleColor.Gray;

            // Cree un nuevo objeto SerialPort con la configuración predeterminada.
            SerialPort Puerto_serie = new SerialPort("COM4")
            {
                BaudRate = 115200,
                Parity = Parity.None,
                StopBits = StopBits.One,
                DataBits = 8,
                Handshake = Handshake.None,
                RtsEnable = true,

                // Establecer los tiempos de espera de lectura / escritura.
                ReadTimeout = 500, // Milisegundos.
                WriteTimeout = 500
            };

            // Detecta cualquier dato recibido.
            Puerto_serie.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);

            Puerto_serie.Open(); // Abrir puerto.

            // ConsoleKey tecla;
            Console.WriteLine("Pulse tecla 1 para encender y 2 para apagar:");

            do
            {

                switch (comando)
                {
                    case "Luz_ON":
                        EncenderLuz();
                        break;

                    case "Luz_OFF":
                        ApagarLuz();
                        break;

                    case "Salir":
                        Environment.Exit(1); // Salir de la consola.
                        break;

                    default:
                        Console.WriteLine("Esperando comandos válidos");
                        break;
                }

                //tecla = Console.ReadKey(true).Key; // Espera pulsación de teclas.



                //switch (tecla)
                //{
                //    case ConsoleKey.D1: // Tecla 1 del teclado estandar.
                //    case ConsoleKey.NumPad1: // Tecla 1 del número del pad.
                //        EncenderLuz();
                //        break;

                //    case ConsoleKey.D2:
                //    case ConsoleKey.NumPad2:
                //        ApagarLuz();
                //        break;

                //    default:
                //        Console.WriteLine("Tecla el 1, el 2 y Escape para salir.");
                //        break;
                //}

                Puerto_serie.Close(); // Cerrar puerto.

            } while (comando == "salir"); // while (tecla != ConsoleKey.Escape); // Pulsa Escape para salir del menú.

            void EncenderLuz()
            {
                byte[] miBuffer1 = Encoding.ASCII.GetBytes("Luz_ON"); // Codificación ASCII y guarda en la variable array tipo byte.
                Puerto_serie.Write(miBuffer1, 0, miBuffer1.Length); // Envía los datos del buffer todo su contenido.
                Console.WriteLine("Comando \"Luz_ON\" enviado."); // Muestra en pantalla comandos enviado.
            }

            void ApagarLuz()
            {
                byte[] miBuffer2 = Encoding.ASCII.GetBytes("Luz_OFF");
                Puerto_serie.Write(miBuffer2, 0, miBuffer2.Length);
                Console.WriteLine("Comando \"Luz_OFF\" enviado.");
            }

            Console.WriteLine("Presione cualquier tecla para terminar...");
            Console.WriteLine();
            Console.ReadKey(); // Espera pulsar una tecla cualquiera.
            Puerto_serie.Close(); // Cierra el puerto serie.
        }

        static void Main(string[] args)
        {
            // Título de la ventana.
            Console.Title = "Recibir e-mail con Consola C# y enviar al LCD de Arduino";

            // Tamaño ventana consola.
            Console.WindowWidth = 80; // X. Ancho.
            Console.WindowHeight = 40; // Y. Alto.

            // Cursor invisible.
            Console.CursorVisible = false;

            // Título del programa.
            Console.WriteLine("\t-----------------------------------------------------");
            Console.WriteLine("\tRecibir Correo Electrónico y enviar al LCD de Arduino");
            Console.WriteLine("\t-----------------------------------------------------");
            Console.WriteLine();

            try
            {
                Timer miTimer = new Timer
                {
                    Enabled = true
                };
                miTimer.Elapsed += new ElapsedEventHandler(DisparadorEventosTimer);
                miTimer.Interval = 5000; // Escaneo cada 5 segundos.
                miTimer.Start(); // Activa el temporizador.


                Console.ReadKey(); // Pulse cualquier tecla para salir.
            }

            // Cualquier error mostrado en mensaje y de color rojo.
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine();
                Console.WriteLine(ex);
                Console.ReadKey();
            }


        }

        // Detecta cualquier dato entrante.
        private static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            SerialPort sp = (SerialPort)sender;
            string entradaDatos = sp.ReadExisting(); // Almacena los datos recibidos en la variable tipo string.
            Console.WriteLine("Dato recibido desde Arduino: " + entradaDatos); // Muestra en pantalla los datos recibidos.
        }
    }

    public class ConnectPop3
    {
        public string email = "celltium@gmail.com";
        public string contraseña = "g0923490xgh0945g450Xj4025g"; // Ficticio.
        public int puerto = 995;
        public bool usarSLL = true;
        public string Hostame = "pop.gmail.com";

        public List<OpenPop.Mime.Message> GetMessages()
        {
            using (Pop3Client oClient = new Pop3Client())
            {
                oClient.Connect(Hostame, puerto, usarSLL);
                oClient.Authenticate(email, contraseña);

                int messageCount = oClient.GetMessageCount();
                List<OpenPop.Mime.Message> lstMessages = new List<OpenPop.Mime.Message>(messageCount);

                for (int i = messageCount; i > 0; i--)
                {
                    lstMessages.Add(oClient.GetMessage(i));
                }

                return lstMessages;
            }
        }
    }
}
Como no cabe en la web, lo pongo como descarga.

Los que los prueben, espero cualquier impresión.

Saludos.

Una imagen.
 

Adjuntos

#2
Muy bueno el proyecto, yo hice algo similar pero con un esp32 y no mando email si no mensajes mqtt lo único malo es que dependo de un servidor si el servidor se cae nada puedo hacer.
si quieres, me dices y te comparto el archivo .ino
 
#3
Buenas:

Lo puedes compartir por aquí.

Antres usaba el MySQL, tenía que tener un Pc encendido, ahora con la Raspberry Pi hace lo mismo. En cuando a la configuración que desees usar sea por MySQL, o por email, puedes usar varios servidores a disposición si te falla alguno, como si te falla gmail automáticamente se va al hotmail por poner un ejemplo.

Dejo aquí solo el ejemplo por si lo quieren probar dar conclusiones sobre enviar email desde la consola C#, funciona de maravilla.

Código C#:

C#:
// Activar / desactivar Acceso de aplicaciones poco seguras en Google.
// https://myaccount.google.com/lesssecureapps

using System;
using System.IO;
using System.Net;
using System.Net.Mail;
using System.Text;

namespace Enviar_email_Consola_06_cs
{
    class Program
    {
        static void Main(string[] args)
        {
            string usuario, contraseña, destinatario, asunto, mensaje;

            // Título de la ventana.
            Console.Title = "Enviar e-mail con Consola C#";

            // Tamaño ventana consola.
            Console.WindowWidth = 80; // X. Ancho.
            Console.WindowHeight = 40; // Y. Alto.

            // Tamaño del cursor. Del 1 al 100.
            Console.CursorSize = 50;

            // Título del programa.
            Console.WriteLine("\t\t----------------------------------------");
            Console.WriteLine("\t\t\tEnviar Correo Electrónico");
            Console.WriteLine("\t\t----------------------------------------");

            try
            {
                Console.WriteLine("\n");
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write("\t\tTu correo electrónico: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                usuario = Console.ReadLine();
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write("\t\tIntroducir contraseña: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                contraseña = LeerPassword();
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write("\t\tDestinatario: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                destinatario = Console.ReadLine();
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write("\t\tAsunto: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                asunto = Console.ReadLine();
                Console.WriteLine();

                //----------------------------------------------
                byte[] bytes = new byte[2000]; // Nuevo tamanho máximo.
                Stream inputStream = Console.OpenStandardInput(bytes.Length);
                Console.SetIn(new StreamReader(inputStream));
                //----------------------------------------------

                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.Write("\t\tMensaje: ");
                Console.ForegroundColor = ConsoleColor.Gray;
                mensaje = Console.ReadLine();
                Console.WriteLine();

                MailMessage correo = new MailMessage(usuario, destinatario, asunto, mensaje);

                SmtpClient servidor = new SmtpClient("smtp.gmail.com")
                {
                    Port = 587
                };
                NetworkCredential credenciales = new NetworkCredential(usuario, contraseña);
                servidor.Credentials = credenciales;
                servidor.EnableSsl = true;

                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("\t\tEnviando correo...");
                servidor.Send(correo);
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("\t\tCorreo enviado satisfactoriamente.");
                correo.Dispose();
                Console.CursorVisible = false;
                Console.ReadKey();
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("ERROR: \n");
                Console.WriteLine("\t\t" + ex.Message);
                Console.WriteLine();
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("\t\tNo se ha enviado el correo.");
                Console.ReadKey();
            }

        }

        // A la hora de introducir la contraseña, se sustituye por asterístos (*) en pantalla.
        public static string LeerPassword()
        {
            ConsoleKeyInfo cki;
            StringBuilder sb = new StringBuilder();
            int contador = 0;

            do
            {
                cki = Console.ReadKey(true);
                if (cki.Key != ConsoleKey.Enter)
                {

                    sb.Append(cki.KeyChar);
                    if (contador < 4)
                    {
                        Console.Write("*");
                    }
                    contador++;
                }

                else
                {
                    break;
                }

            } while (true);
            Console.WriteLine();
            return sb.ToString();
        }
    }
}
Saludos.
 
#4
bueno, aquí dejo el archivo .ino.
lo que está en asterisco son los datos que deben colocar


C++:
//sda=5 sck=18 mosi=23 miso=19 rst=17(tx2)
#include <WiFi.h>
#include <MFRC522.h>
#include <BLE2902.h>
#include <BLEUtils.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include "esp_system.h"
#include <PubSubClient.h>

BLECharacteristic *pCharacteristic;

#define SS_PIN 5
#define LED_Pin 2
#define RST_PIN 17
#define Door_Pin 16
#define turnOnDelay 3000
#define SERVICE_UUID "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define CHARACTERISTIC_UUID_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"

enum { STEP_BTON, STEP_BTOFF, STEP_END };

byte touch;
byte button;
byte newbutton;
byte buttonState= 0;
byte threshold_D= 30;
byte threshold_U= 60;
byte watchdogCount= 0;
byte debounceDelay= 65;
byte lastButtonState= 1;
const int wdtTimeout= 30000;
unsigned long Off_Millis;
unsigned long Door_On_At;
unsigned long currentMillis= 0;
unsigned long lastDebounceTime= 0;
bool WiFion=0;
bool FLAG = 0;
bool state0= 0;
bool state1= 1;
bool Door_State= 0;
bool deviceConnected = false;
const char* ssid= "***********";
const char* brokerPass= "******";
const char* broker= "**********";
const char* password= "*****************";
const char* brokerUser= "**************";
const char* ledTopic= "*****************";
const char* doorTopic= "****************";

WiFiClient espClient;
PubSubClient client(espClient);
MFRC522 mfrc522(SS_PIN, RST_PIN);

class MyServerCallbacks: public BLEServerCallbacks{
  void onConnect(BLEServer* pServer){
    deviceConnected = true;
  };
  void onDisconnect(BLEServer* pServer){
    deviceConnected = false;
  }
};

class MyCallbacks: public BLECharacteristicCallbacks{
  void onWrite(BLECharacteristic *pCharacteristic){
    std::string rxValue= pCharacteristic->getValue();
    if (rxValue.length() > 0) {
      if (rxValue.find("A")!= -1){
//        digitalWrite(LED_Pin, !digitalRead(LED_Pin));
//        client.publish(ledTopic, "0", true);


        if(digitalRead(LED_Pin)==1){
          digitalWrite(LED_Pin, 0);
          client.publish(ledTopic, "0", true);
          //delay(65);
        }else{
          digitalWrite(LED_Pin, 1);
          client.publish(ledTopic, "1", true);
          //delay(65);
        }

        
      }
      if (rxValue.find("B")!= -1){
        digitalWrite(Door_Pin, !digitalRead(Door_Pin));
        if(state0==0 || digitalRead(Door_Pin)==0){
          state0=0;
        }
        if(state0==1 || digitalRead(Door_Pin)==1){
          state0=1;
        }
      }
    }
  }
};

hw_timer_t *timer= NULL;

void IRAM_ATTR resetModule(){
  ets_printf("\nreboot\n");
  esp_restart();
}

void setup(){
  Serial.begin(115200);
  SPI.begin(); 
  mfrc522.PCD_Init();
  timer= timerBegin(0, 80, 1);
  timerAttachInterrupt(timer, &resetModule, 1);
  timerAlarmWrite(timer, wdtTimeout* 1000, 0);
  timerAlarmEnable(timer);
  pinMode(0, INPUT_PULLUP);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
  pinMode(LED_Pin, OUTPUT);
  pinMode(Door_Pin, OUTPUT);
  client.setServer(broker, 1883);
  client.setCallback(callback);
  BLEDevice::init("Esp_Cuarto");
  BLEServer *pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());
  BLEService *pService = pServer->createService(SERVICE_UUID);
  pCharacteristic = pService->createCharacteristic(
    CHARACTERISTIC_UUID_TX,
    BLECharacteristic::PROPERTY_NOTIFY
  );                   
  pCharacteristic->addDescriptor(new BLE2902());
  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
    CHARACTERISTIC_UUID_RX,
    BLECharacteristic::PROPERTY_WRITE
  );
  pCharacteristic->setCallbacks(new MyCallbacks());
  pService->start();
  pServer->getAdvertising()->start();
  onButton();
}

void loop(){
  float loopTime = micros();
  Serial.println(touch);
  timerWrite(timer, 0);
  Touch();
  Time_Door();
  static uint8_t lastPinState= 1;
  uint8_t pinState= digitalRead(0);
  if(!pinState&& lastPinState){
    onButton();
  }
  lastPinState= pinState;
  if(WiFion==1){
    if(WiFi.status()!= WL_CONNECTED){
      Serial.println("conexion WiFi perdida\nRe-connectando");
      WiFi.reconnect();
    }
    if(!client.connected()){
      reconnect();
    }
  }
  client.loop();
  NFC();
  loopTime = micros() - loopTime;
loopTime= float(loopTime*0.000001);
 
  //Serial.print("loop time is = ");
  //Serial.println(loopTime, 8);
}

void onButton(){
  //static uint32_t step = STEP_BTON;
  static uint32_t step = STEP_BTOFF;
  switch(step){
    case STEP_BTON:
      digitalWrite(13,0);
      digitalWrite(12,1);
      WiFi.disconnect(true);
      WiFion=0;
    break;
    case STEP_BTOFF:
      digitalWrite(12,0);
      digitalWrite(13,1);
      Setup_Wifi();
      WiFion=1;
    break;
    case STEP_END:
    break;
    default:
    break;
  }
  if(step == STEP_END){
    step = STEP_BTON;
    onButton();
  } else {
    step++;
  }
  delay(100);
}

void Setup_Wifi(){
  WiFi.begin(ssid, password);
  while (WiFi.status()!= WL_CONNECTED){
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connectado");
}

void Touch(){
  touch=touchRead(T7);  //pin 27
  if(touch< threshold_D){
    button= 1;
  }
  if(touch> threshold_U){
    button= 0;
  }
  newbutton= button;
  if(newbutton!= lastButtonState){
    lastDebounceTime= millis();
    lastButtonState= newbutton;
  }
  if((millis()- lastDebounceTime)> debounceDelay){
    if(buttonState!= lastButtonState){
      buttonState= lastButtonState;
      if(buttonState== 1){
        if(digitalRead(LED_Pin)==1){
          digitalWrite(LED_Pin, 0);
          client.publish(ledTopic, "0", true);
          //delay(65);
        }else{
          digitalWrite(LED_Pin, 1);
          client.publish(ledTopic, "1", true);
          //delay(65);
        }
      }
    }
  }
}

void Time_Door(){
  currentMillis= millis();
  if(state1== 0){
    Off_Millis = currentMillis;
    FLAG= 1;
    state1= 1;
  }
  if(FLAG){
    if((unsigned long)(currentMillis- Off_Millis)>= turnOnDelay){
      client.publish(doorTopic, "1", 1);
      delay(100);
      digitalWrite(Door_Pin, 1);
      state0= 1;
      Door_State= 1;
      Door_On_At= currentMillis;
      FLAG= 0;
    }
  }
}

void reconnect(){
  while(!client.connected()){
    if(client.connect("sebsjara", brokerUser, brokerPass)){
      Serial.println(broker);
      client.subscribe(ledTopic);
      client.subscribe(doorTopic);
    } else{
      Serial.println("\nintentando reconectar");
      delay(1000);
    }
  }
}

void NFC(){
  if(!mfrc522.PICC_IsNewCardPresent()){
    return;
  }
  if(!mfrc522.PICC_ReadCardSerial()){
    return;
  }
  String content= "";
  byte letter;
  for (byte i= 0; i< mfrc522.uid.size; i++){
    content.concat(String(mfrc522.uid.uidByte[i]< 0x10 ? " 0" : " "));
    content.concat(String(mfrc522.uid.uidByte[i], HEX));
  }
  content.toUpperCase();
  if (content.substring(1)== "13 D4 B6 21"&& state0== 1|| content.substring(1)== "01 02 03 04"&& state0== 1){
    client.publish(doorTopic, "0");
    delay(100);
    digitalWrite(Door_Pin, 0);
    state0= 0;
    state1=0;
  }
}

void callback(char* topic, byte* payload, unsigned int length){
  if((char)payload[0]== '1'&& strcmp(topic,"/sebsjara97@gmail.com/led")== 0){
    digitalWrite(LED_Pin, 1); ;
  }
  if((char)payload[0]== '0'&& strcmp(topic,"/sebsjara97@gmail.com/led")== 0){
    digitalWrite(LED_Pin, 0);
  }
  if((char)payload[0]== '1'&& strcmp(topic,"/sebsjara97@gmail.com/door")== 0){
    digitalWrite(Door_Pin, 1);
    state0= 1;
  }
  if((char)payload[0]== '0'&& strcmp(topic,"/sebsjara97@gmail.com/door")== 0){
    digitalWrite(Door_Pin, 0);
    state0= 0;
  }
}
 

Temas similares


Arriba