---
# System prepended metadata

title: CÓDIGO DE IDE DE ARDUINO PARA CONEXIÓN AL BROQUER

---

# CÓDIGO DE IDE DE ARDUINO PARA CONEXIÓN AL BROQUER
Código de programación y conexión al servidor Emqx así también conexión con comunicación inalámbrica wifi para el envío de mensajes con los temas tópicos y el payload que seria los datos previo autenticación mediante el nombre de usuario y contraseña y el socket para la conexión y publicación y suscripción para el envío y recepción de mensajes.

Definir ESP_32 para trabajar con módulo de ESP32

```
#define ESP_32 
#ifndef ESP_32
```
Define los pines del hardware en función al CPU seleccionado.

```
#ifdef ESP_32
#define PIN_TRIMPOT 34 //Definición del pin del potenciómetro
#define PIN_LED1 15     //Definición del pin del led1
#define PIN_LED2 2     //Definición del pin del led2
#define PIN_LED3 4    //Definición del pin del led3
#define PIN_LED4 5     //Definición del pin del led4
#include "WiFi.h"       //Incluye librería para el manejo del wifi
```
Se incluye las librerías necesarias Mqtt de publicación y suscripción  y de sensores
```
#include "PubSubClient.h" //Incluye libreria para el manejo del cliente mqtt 
#include <WiFiClientSecure.h> 
WiFiClientSecure espClient; 
//WiFiClient espClient; //Declaración de objeto de la clase WIFIClient
#include <DHT.h> 
#define DHTTYPE DHT22 
DHT dht (23, DHTTYPE);
```

```
#define DEVICE_LABEL        "v1/devices/cliente1/" //topico base 
#define TOPICO_PUB_POT      DEVICE_LABEL "pot" // topico a publicar desde el esp32 hacia el broker
#define TOPICO_SUB_LED1     DEVICE_LABEL "led1" // topico a suscribirse para recibir dato en el esp32
#define TOPICO_SUB_LED2     DEVICE_LABEL "led2" // topico a suscribirse para recibir dato en el esp32
#define TOPICO_SUB_TEXT     DEVICE_LABEL "text" // topico a suscribirse para recibir dato en el esp32
```

Funcion "callback", que permite gestionar las cadenas proveniente
   de un servidor mqtt cuando nos subscribimos a un determinado topico.

```
void callback(char* topic, byte* payload, unsigned int length) {

  Serial.print("Path -> ");//Imprime cadena
  Serial.print(topic);//Imprime puntero topic, que apunta a una cadena
  Serial.print("\n");//Imprime cadena espacio
  Serial.print("Payload -> ");//Imprime cadena
  payload[length] = 0;//Coloca un cero al final del byte array para convertirlo en cadena
  Serial.println((char *)payload);//Imprime puntero payload, que apunta a una cadena

  String miTopic = String(topic);//Crea objeto de la clase String con el contenido de topic
  String miPayload = String((char *)payload);//Crea objeto de la clase String con el contenido de payload

  /*
     Permite identificar mediante comparacion si se trata de algun topico subscrito.
  */
  if (miTopic.equals(TOPICO_SUB_LED1)) {
    //Se encontro el topico subscrito led1
    //Compara si el payload es igual a la cadena "1".
    if (miPayload.equals("1")) {
      digitalWrite(PIN_LED1, HIGH);//Activa la salida del led1
    } else {
      digitalWrite(PIN_LED1, LOW);//Desactiva la salida del led1
    }
  } else if (miTopic.equals(TOPICO_SUB_LED2)) {
    //Se encontro el topico subscrito led2
    //Compara si el payload es igual a la cadena "true".
    if (miPayload.equals("true")) {
      digitalWrite(PIN_LED2, HIGH);//Activa la salida del led2
    } else {
      digitalWrite(PIN_LED2, LOW);//Desactiva la salida del led2
    }
  } else if (miTopic.equals(TOPICO_SUB_TEXT)) {
    //Se encontro el topico subscrito text
    lcd.setCursor(0, 1);//Posiciona el lcd en la coordenada 0,1
    lcd.print("                ");//Imprime cadena para limpiar la fila
    lcd.setCursor(0, 1);//Posiciona el lcd en la coordenada 0,1
    lcd.print("Txt:" + miPayload);//Imprime cadena y el contenido de miPayload
  }

}
```

*Funcion "reconnect", que permite evaluar si el obeto "client" mqtt se encuentra
   conectado al servidor, de no estar conectado entonces intenta conectarse al
   servidor a traves de las credenciales del usuario registrado en dicha nube,
   una vez que se conecta al servidor, se subscribe a los topicos requeridos.*

```
void reconnect() {

  /*
     Bucle donde se evalua si el "cliente" mqtt esta conectado al servidor,
     mientras no se conecte no terminara el bucle.
  */
  while (!client.connected()) {

    Serial.println("Intentando conexion MQTT");//Imprime cadena

    /*
       Se declara una cadena para utilizar como id de la conexion, la cual
       debe ser unica en cada intento de conexion, para ello se recurre
       al metodo random para generar un numero aleatorio.
    */
    String clientId = "iot_1_";//Crea objeto de la clase String
    clientId = clientId + String(random(0xffff), HEX);//Genera una cadena con valor random

    /*
       Se intenta conectar al servidor (broker) mqtt mediante las credenciales
       de la plataforma, si consigue conectarse devuelve TRUE.
    */
    if (client.connect(clientId.c_str(), mqtt_user, mqtt_pass)) {
      Serial.println("Conexion a MQTT exitosa!!");//Imprime cadena
      client.subscribe(TOPICO_SUB_LED1);//Suscripcion a topico
      client.subscribe(TOPICO_SUB_LED2);//Suscripcion a topico
      client.subscribe(TOPICO_SUB_TEXT);//Suscripcion a topico
    } else {
      Serial.print("Fallo la conexion ");//Imprime cadena
      Serial.println(client.state());//Imprime error de la conexion
      Serial.print(" Se intentara denuevo en 5 segundos");//Imprime cadena
      delay(2000);//Espera 2 segundos para seguir intentando conectarse
    }
  }
}
```

*Metodo para configurar el red local WIFI
*
v```
oid setup_wifi() {

  Serial.println();//Imprime nueva linea
  Serial.print("Conectando a: ");//Imprime cadena
  Serial.println(ssid);//Imprime cadena con el contenido de ssid

  WiFi.begin(ssid, password);//Configura el WIFI del modulo

  /*
     Mientras el WIFI se intenta conectar a la red local se hara una
     espera de 500mseg y luego se imprime un simbolo hasta que
     se conecte a la red local.
  */
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);//Espera de 500mseg
    Serial.print(".");//Imprime cadena
  }

  Serial.println("");//Imprime cadena
  Serial.println("Conectando a la red Wifi! ");//Imprime cadena
  Serial.print("Direccion IP: ");//Imprime cadena
  Serial.println(WiFi.localIP());//Imprime la ip asignada por el router local

}
```



*Funcion "setup", que se ejecuta una sola vez al principio del programa.
*

void setup() {

  pinMode(PIN_LED1, OUTPUT);//configura el pin como salida
  pinMode(PIN_LED2, OUTPUT);//configura el pin como salida
  Serial.begin(115200);//configura el puerto serial
  setup_lcd();//configura la lcd
  setup_wifi();//configura el wifi
  /*
     Pasamos las credenciales para el servidor mqtt (broker)
  */
  client.setServer(mqtt_server, mqtt_port);
  /*
     Pasamos el puntero a la funcion de llamada "callback" encargada de
     gestionar la recepcion de subscripciones que enviara el servidor mqtt.
  */
  client.setCallback(callback);

}

/*
   Declaracion de variable tipo long. Empleado para
   guardar y comparar los milisegundos transcurridos.
*/
long trimpot_ms = 0;

/*
   Funcion "loop", que se ejecuta siempre luego de "setup".
*/
void loop() {
  /*************************************************************************************/
  /*
   * Este bloque consulta si han transcurrido 5seg, de ser verdad entonces
   * lee el trimpot y evalua si existe cambio en su valor.
   */
  /*************************************************************************************/
  if (millis() - trimpot_ms > 5000) {
    trimpot_ms = millis();//Actualiza el valor de "trimpot_ms"

#ifdef ESP_32
    /*
       Escala el resultado en 12 bits al rango de 0 a 100
    */
    int adc_val = map(analogRead(PIN_TRIMPOT), 0, 4095, 0, 100);
#elif defined ESP_8266
    /*
       Escala el resultado en 10 bits al rango de 0 a 100
    */
    int adc_val = map(analogRead(PIN_TRIMPOT), 0, 1023, 0, 100);
#endif
    String val = String(adc_val);//Convierte en cadena el resultado
    client.publish(TOPICO_PUB_POT, val.c_str()); //Publicando al broker mqtt

    lcd.setCursor(0, 0);//Posiciona el lcd en la coordenada 0,0
    lcd.print("                ");//Imprime cadena
    lcd.setCursor(0, 0);//Posiciona el lcd en la coordenada 0,0
    lcd.print("Pot:" + val);//Imprime el resultado en la pantalla

    Serial.println("Mensaje enviado -> " +  val);//Imprime el resultado
  }
  /*************************************************************************************/
  /*
   * Esta parte se monitorea la conexion al broker mqtt y se procesar
   * las tareas del cliente.
   */
  /*************************************************************************************/
  if (client.connected() == false) {
    //Consulta si el cliente mqtt se encuentra desconectado del broker
    reconnect();//Invoca la funcion "reconnect"
  }
  client.loop();//Procesa todas las tareas del objeto "cliente"
  /*************************************************************************************/
}
