Bien, vamos con los avances
primero, mediante la conexion a ethernet configuramos el UG65 para conectarlo a nuestra red wifi... aca un simple video del paso a paso:
una vez configurado nuestro UG65, entramos via WIFI a su configuración. En mi caso configure una IP estática (192.168.1.200) para no tener problemas con los dispositivos que sume en el futuro... Si no hicieron eso al seguir los pasos del video anterior, tienen que entrar en la dirección 192.168.1.1.
Dentro ya de la pantalla de configuración, nos vamos a la opción Network Server
ahi nos dirigimos a la solapa
"Aplications" y en el signo "+", vamos a crear una instancia...
Yo la llame UC1114 ... Como voy a trabajar MQTT, en
"Payload Codec", tenemos que seleccionar la opcion
"Custom" y dentro de
Payload decoder function, vamos a pegar las siguientes lineas de comandos que luego las implementaremos para decodificar el hex que envia el UC1114:
Código:
// Decoder UC1114 - 2 DI + 2 DO
function Decode(fPort, bytes) {
// bytes[8] → estado de entradas digitales
// bytes[10] → estado de salidas digitales (relés)
return {
DI1: (bytes[8] & 0x01) ? 1 : 0,
DI2: (bytes[8] & 0x02) ? 1 : 0,
DO1: (bytes[10] & 0x01) ? 1 : 0,
DO2: (bytes[10] & 0x02) ? 1 : 0
};
}
En Payload encoder function, vamos a pegar las siguientes lineas:
Código:
// Encode permite enviar comandos desde el UG65 al UC1114
// obj puede tener {DO1:1, DO2:0} por ejemplo
function Encode(fPort, obj) {
var bytes = new Array(11).fill(0); // Creamos arreglo de 11 bytes inicializados en 0
if(obj.DO1 !== undefined) {
if(obj.DO1) bytes[10] |= 0x01; // Activar DO1
else bytes[10] &= ~0x01; // Desactivar DO1
}
if(obj.DO2 !== undefined) {
if(obj.DO2) bytes[10] |= 0x02; // Activar DO2
else bytes[10] &= ~0x02; // Desactivar DO2
}
return bytes;
}
En la seccion
"Data Transmission", le damos click al signo "+" y seleccionamos
"MQTT" y configuramos la dirección broker, el puerto y el ID del cliente (el UG65)
después, referenciamos con las siguientes direcciones las siguientes variables
No se olviden de salvar cada cambio que hagan
terminado este paso, nos vamos a
"Profiles" y creamos con el signo
"+" un perfil nuevo (en mi caso UC1114-915_OTAA)
Realizada la anterior configuración y almacenada, nos vamos a la opción
"Device"
presionamos el signo "
+" para agregar nuestro dispositivo LoRaWAN (en este caso el UC1114)... Para hacer esto, van a requerir tener a mano el numero de Device EUI, App EUI y App KEY... Si no lo tienen en la etiqueta o cartoncito de la caja, pueden implementar "
Aplicación Milesight Toolbox " que por medio de un cable USB se conectan al UC1114...
Cuando terminemos de configurar todo, recuerden salvar y reinicien los dos equipos.... Volvemos a entrar y desde
"Gateway" tendriamos que poder visualizar que esta conectado
para verificar que hay vinculación con el UC1114, nos vamos a
"Packets" y ya tendríamos que poder ver los paquetes... que igualmente, esto no significa que tengamos datos validos.... eso ya lo vamos a ver después
Hasta acá, venimos bien hasta que me di cuenta que no tenia comunicación... Probé de todo, y nada... navegando y navegando con San Google, pude entender "parte" del por que no tenia comunicación vamos por partes para que se entienda...
A_ Por qué el Arduino Uno con W5100 no funciono?
Quizás me equivoque, por que algunas cosas las interpreto por descarte, otras por conocimientos básicos, y otra gracias a San Google... la idea original de implementar la conexión del Arduino y el UG65 via ethernet no funciono por
1_Capacidad de memoria y recursos limitados:
*Arduino Uno tiene solo 2 KB de RAM y 32 KB de flash... Manejar librerías de MQTT y HTTP simultáneamente, más buffers para el WebServer, excede fácilmente los recursos... Cuando compile una de las primeras betas, el IDE me indicaba que el programa tomaba un porcentaje elevado de los recursos de la ram y podria darme errores...
2_TLS y MQTT:
*Muchos gateways LoRaWAN como el UG65 soportan MQTT con TLS (seguridad SSL/TLS), y en una foro extranjero me vengo a enterar que el W5100 no soporta de forma nativa TLS ni librerías modernas de MQTT con SSL. Implementarlo iba a requerir un MCU más potente... Quizas un MEGA2560, pero para la funcion que le iba a dar, estime que era un derroche de plata...
*El ESP8266 y ESP32 tienen hardware suficiente y librerías (PubSubClient, AsyncTCP, AsyncWebServer) que soportan estas funciones de manera sencilla y son mucho mas economicos....
3_Conectividad Wi-Fi:
*Controversias mías ... Arduino Uno + W5100 solo puede conectarse por Ethernet, mientras que en la práctica yo quería conectar el UG65 vía Wi-Fi y tener varios ESPs, mas el LoRaWAN en la misma red... Usar el hardware cableado me iba a demandar sumar una caja IP65, prensa cables especiales, etc etc... Iba a ser mas complicado y después me puse a pensar que el ESP8266/ESP32 ya tiene Wi-Fi integrado y se puede conectar al router o a la red Wi-Fi del UG65; Así que acá re arranque nuevamente...
Después de poder llegar a esta conclusión, tome un ESP8266 y arranque desde cero con el siguiente sketch:
CSS:
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
// ------------------- CONFIGURACION WIFI -------------------
const char* ssid = "blablablabla";
const char* password = "blablabla";
// IP estática
IPAddress local_IP(192, 168, 1, 36);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);
// ------------------- CONFIGURACION DEL SERVIDOR -------------------
AsyncWebServer server(80);
// entradas y salidas
int DI1 = 0;
int DI2 = 0;
int DO1 = 0;
int DO2 = 0;
// HTML del dashboard
const char htmlPage[] PROGMEM = R"rawliteral(
<!DOCTYPE html>
<html>
<head>
<title>UG65_ESP8266_UC1114_dashboard</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<style>
body { font-family: Arial; text-align:center; }
button { width:120px; height:50px; font-size:16px; margin:10px; }
.circle { width:50px; height:50px; border-radius:50%; display:inline-block; margin:10px; }
.red { background:red; }
.green { background:green; }
</style>
</head>
<body>
<h2>UC1114 Dashboard</h2>
<div>
<button onclick="toggleDO('DO1',1)">Activar DO1</button>
<button onclick="toggleDO('DO1',0)">Desactivar DO1</button>
</div>
<div>
<button onclick="toggleDO('DO2',1)">Activar DO2</button>
<button onclick="toggleDO('DO2',0)">Desactivar DO2</button>
</div>
<h3>Entradas digitales</h3>
<div>
<div>DI1: <div id="di1" class="circle red"></div></div>
<div>DI2: <div id="di2" class="circle red"></div></div>
</div>
<script>
function toggleDO(doName,state) {fetch("/set?"+doName+"="+state);}
function updateInputs()
{
fetch("/status")
.then(response => response.json())
.then(data => {
document.getElementById("di1").className = "circle " + (data.DI1==1?"green":"red");
document.getElementById("di2").className = "circle " + (data.DI2==1?"green":"red");
});
}
setInterval(updateInputs, 1000);
</script>
</body>
</html>
)rawliteral";
// ------------------- FUNCIONES -------------------
void setup()
{
Serial.begin(115200);
// Conectar a Wi-Fi
Serial.println("Conectando a Wi-Fi...");
if (!WiFi.config(local_IP, gateway, subnet))
{
Serial.println("Fallo al configurar IP estática");
}
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED)
{
delay(500);
Serial.print(".");
}
Serial.println("\nConectado a Wi-Fi!");
Serial.print("IP del ESP8266: ");
Serial.println(WiFi.localIP());
// Servir dashboard
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
request->send_P(200, "text/html", htmlPage);
});
// Endpoint para cambiar DO1/DO2
server.on("/set", HTTP_GET, [](AsyncWebServerRequest *request)
{
if(request->hasParam("DO1"))
{
DO1 = request->getParam("DO1")->value().toInt();
Serial.print("DO1 cambiado a "); Serial.println(DO1);
}
if(request->hasParam("DO2"))
{
DO2 = request->getParam("DO2")->value().toInt();
Serial.print("DO2 cambiado a "); Serial.println(DO2);
}
request->send(200, "text/plain", "OK");
});
// Endpoint para enviar estado de entradas DI1 y DI2
server.on("/status", HTTP_GET, [](AsyncWebServerRequest *request){
String json = "{\"DI1\":" + String(DI1) + ",\"DI2\":" + String(DI2) + "}";
request->send(200, "application/json", json);
});
server.begin();
Serial.println("Servidor web iniciado");
}
void loop()
{
// Aquí deberías leer los estados reales del UC1114 vía UG65
// Por ahora solo simulamos que cambian aleatoriamente (para test)
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate > 5000)
{
DI1 = random(0,2);
DI2 = random(0,2);
lastUpdate = millis();
Serial.printf("DI1: %d | DI2: %d | DO1: %d | DO2: %d\n", DI1, DI2, DO1, DO2);
}
}
y logre un pequeño avance
... avance a medias por que solo pude ver el estado de las entradas, pero no pude tener control sobre las dos salidas del UC1114...
Por qué el sketch ESP8266 funcionó para leer entradas?
Esto me llevo practicamente 3 horas descubrirlo mirando ejemplos y googleando por varios foros... El sketch inicial del ESP8266 implementa un WebServer con endpoints /status.
La trampa que hice en si momento fue simular la lectura de DI1 y DI2:
CSS:
server.on("/status", HTTP_GET, [](AsyncWebServerRequest *request){
String json = "{\"DI1\":" + String(DI1) + ",\"DI2\":" + String(DI2) + "}";
request->send(200, "application/json", json);
});
Con esto, pude lograr que el dashboard mostrara el estado de las entradas con los círculos rojos/verde... O sea, la comunicación es directa vía HTTP GET desde el navegador al ESP, por lo que no depende de MQTT ni del UG65 para esta visualización básica... Como desvirtué la idea original, tome la decisión de descartarlo para la otra beta aunque funciono.
Por qué no pude activar los relés desde el dashboard
Falto la integración MQTT o enlace con UG65... El endpoint /set solo cambia variables locales DO1 y DO2 dentro del ESP.
Como no hay ninguna funcion incluida que convierta estas acciones en comandos hacia el UC1114 a través del UG65, por mas que el botón funciona en el dashboard, el UC1114 nunca recibe la orden.... Probé de todo después de descular esto y persistió el mismo problema...
Interpreto que el error esta en el Payload y formato de comando del UC1114:
A_El UC1114 espera un payload en un formato específico (hex/base64) a través del UG65 por MQTT o LoRaWAN.
B_Sin enviar el mensaje correcto a uc1114/down con la codificación requerida, el UC1114 no se va a mosquear...
Necesidad de PubSubClient y broker MQTT:
*Para enviar comandos reales, el ESP debe conectarse a un broker MQTT al que también esté conectado el UG65.
*Luego, el ESP publica los mensajes codificados hacia los topics que el UC1114 escucha.
*Sin esta capa de comunicación, los relés no cambian de estado.
Por donde sigo?
Buena pregunta... como primera instancia, cambiar la yerba del mate y trabajar desde cero en la configuracion del UG65 como cliente MQTT conectado a un broker local.
Tengo que ver como definir los topics de uplink y downlink (uc1114/up y uc1114/down) correctamente.
Trabajar y pulir en el ESP8266 de como publicar los comandos de los botones hacia el broker MQTT, pero para eso me esta faltando conocimientos para codificar DO1 y DO2 en base64/hex según formato UC1114; Subscribirse a uc1114/up para recibir cambios de DI1/DI2 y actualizar los círculos en tiempo real. (actualmente tiene un lag de casi un segundo)... O sea, hasta acá llegaron mis neuronas... y seguro que si no consigo una orientación, vuelve a la caja
...
por sacárselo, pero va a generar error al iniciar el UG65 si no lo detecta
