Azure: Crear IoT Hub y conectar un dispositivo IoT (es-MX)
En este artículo, le mostraremos cómo crear un recurso IoT HUB y conectar su dispositivo de IoT.
Requisitos previos:
- Hardware requerido:
- Windows 10 PC
- Kit de hardware IoT: https://www.adafruit.com/product/3605 o hardware similar.
- Acceso a una red WiFi
- Sistema operativo requerido:
- Windows 10
- Otros requerimientos:
- Suscripción activa de Azure
- Software requerido:
- IoT Device Explorer, descargue: https://github.com/Azure/azure-iot-sdk-csharp/releases/download/2017-1023/SetupDeviceExplorer.msi
Pasos:
1. Verifiquemos la configuración de conexión del dispositivo IoT. Consulte https://learn.adafruit.com/adafruit-feather-huzzah-esp8266/using-arduino-ide.
2. Vayamos al Portal de Azure, haga clic en Crear nuevo y escribamos "iot hub":
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfb573931ef.png
- Ahora proporcionemos los siguientes parámetros para crear su IoT Hub:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfb5c7cb626.png
4. Ahora verifiquemos que IoT Hub se haya creado correctamente:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfb61a92802.png
- Vayamos a las Políticas de acceso compartido:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfb6c8a0084.png
6. A continuación, damos clic en Políticas de acceso compartido, seleccione "iothubowner" y habilitemos "registro de escritura" y copiemos las claves de acceso compartido:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfb72b606fb.png
- Ahora regressamos al escritorio y abrimos el Device Explorer Twin. Si aún no está instalado, instálelo (https://github.com/Azure/azure-iot-sdkcsharp/releases/download/2017-10-23/SetupDeviceExplorer. msi) y ejecuta el Explorador de dispositivos:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfb7dd25533.png
- Ahora seleccionemos la etiqueta de Administración y haga clic en Crear dispositivo, proporcione un nombre para su Dispositivo de IdC y luego pegue las Credenciales de acceso compartido que copió previamente:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfb80e82a84.png
Veremos una notificación cuando el dispositivo se haya creado correctamente:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfb9089abc8.png
- Ahora en la etiqueta de Administración, hagamos clic derecho en el dispositivo que acaba de crear y haga clic en "Copiar cadena de conexión para el dispositivo seleccionado"
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfb95bf26ca.png
- Ahora inicia Arduino. Puedes descargarlo desde aquí:
https://www.arduino.cc/download_handler.php?f=/arduino-1.8.5-windows.exe.
Ahora agreguemos las bibliotecas de Microsoft IoT y Arduino haciendo clic en Sketch -> Include Library -> Manage Libraries y busque "AzureIoT". Instale la biblioteca AzureIoTHub por Arduino, AzureIoTProtocol_MQTT por Microsoft y AzureIoTUtility por Microsoft, como se muestra a continuación.
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/arduino-include-library-wikiazure.png
- Comenzando con un archivo nuevo y copiemos el siguiente código:
#include <ESP8266WiFi.h>
#include <ESP8266WiFiAP.h>
#include <ESP8266WiFiGeneric.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266WiFiScan.h>
#include <ESP8266WiFiSTA.h>
#include <ESP8266WiFiType.h>
#include <WiFiClient.h>
#include <WiFiClientSecure.h>
#include <WiFiServer.h>
#include <AzureIoTUtility.h>
#include <AzureIoTHub.h>
#include <AzureIoTProtocol_MQTT.h>
#include <DHT.h>
String ssid = "iot"; // your network SSID (name)
String pass = "microsoft"; // your network password (use for WPA, or use as key for WEP)
static const char* connectionString = "HostName=daveiotdemo1.azure-devices.net;DeviceId=daveie;SharedAccessKey=1298128GASJDA12=";
#define DHTPIN 2 // what digital pin we're connected to
#define DHTTYPE DHT22 // DHT11 or DHT22
IOTHUB_CLIENT_LL_HANDLE iotHubClientHandle;
IOTHUB_CLIENT_STATUS status;
WiFiClientSecure espClient;
DHT dht(DHTPIN, DHTTYPE);
void initWifi() {
if (WiFi.status() != WL_CONNECTED)
{
WiFi.stopSmartConfig();
WiFi.enableAP(false);
// Connect to WPA/WPA2 network. Change this line if using open or WEP network:
WiFi.begin(ssid.c_str(), pass.c_str());
Serial.print("Waiting for Wifi connection.");
while (WiFi.status() != WL_CONNECTED) {
Serial.print(".");
delay(500);
}
Serial.println("Connected to wifi");
initTime();
initIoTHub();
}
}
void initTime() {
time_t epochTime;
configTime(0, 0, "pool.ntp.org", "time.nist.gov");
while (true) {
epochTime = time(NULL);
if (epochTime == 0) {
Serial.println("Fetching NTP epoch time failed! Waiting 2 seconds to retry.");
delay(2000);
} else {
Serial.print("Fetched NTP epoch time is: ");
Serial.println(epochTime);
break;
}
}
}
static void sendMessage(const char* message)
{
static unsigned int messageTrackingId;
IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromString(message);
if (IoTHubClient_LL_SendEventAsync(iotHubClientHandle, messageHandle, sendMessageCallback, (void*)(uintptr_t)messageTrackingId) != IOTHUB_CLIENT_OK)
{
Serial.println(" ERROR: Failed to hand over the message to IoTHubClient");
}
else
{
(void)printf(" Message Id: %u Sent.\r\n", messageTrackingId);
}
IoTHubMessage_Destroy(messageHandle);
messageTrackingId++;
}
void sendMessageCallback(IOTHUB_CLIENT_CONFIRMATION_RESULT result, void* userContextCallback)
{
unsigned int messageTrackingId = (unsigned int)(uintptr_t)userContextCallback;
(void)printf(" Message Id: %u Received.\r\n", messageTrackingId);
}
static IOTHUBMESSAGE_DISPOSITION_RESULT IoTHubMessageCallback(IOTHUB_MESSAGE_HANDLE message, void* userContextCallback)
{
IOTHUBMESSAGE_DISPOSITION_RESULT result = IOTHUBMESSAGE_ACCEPTED;
const char* messageId = "UNKNOWN"; // in case there is not a messageId associated with the message -- not required
messageId = IoTHubMessage_GetMessageId(message);
const unsigned char* buffer;
size_t size;
if (IoTHubMessage_GetByteArray(message, &buffer, &size) != IOTHUB_MESSAGE_OK)
{
Serial.println(" Error: Unable to IoTHubMessage_GetByteArray");
result = IOTHUBMESSAGE_ABANDONED;
}
else
{
char* tempBuffer = (char*)malloc(size + 1);
if (tempBuffer == NULL)
{
Serial.println(" Error: failed to malloc");
result = IOTHUBMESSAGE_ABANDONED;
}
else
{
result = IOTHUBMESSAGE_ACCEPTED;
(void)memcpy(tempBuffer, buffer, size);
String messageStringFull((char*)tempBuffer);
String messageString = "UNKNOWN";
messageString = messageStringFull.substring(0,size);
/* if (messageString.startsWith("OTA")) {
String fullURL = messageString.substring(messageString.indexOf("://") - 4);;
// t_httpUpdate_return OTAStatus = OTA.update(fullURL.c_str());
// if we do OTA, then we never return the IOTHUBMESSAGE_ACCEPTED and we have issues
}*/
String messageProperties = "";
MAP_HANDLE mapProperties = IoTHubMessage_Properties(message);
if (mapProperties != NULL)
{
const char*const* keys;
const char*const* values;
size_t propertyCount = 0;
if (Map_GetInternals(mapProperties, &keys, &values, &propertyCount) == MAP_OK)
{
if (propertyCount > 0)
{
size_t index;
for (index = 0; index < propertyCount; index++)
{
messageProperties += keys[index];
messageProperties += "=";
messageProperties += values[index];
messageProperties += ",";
}
}
}
}
Serial.print(" Message Id: ");
Serial.print(messageId);
Serial.print(" Received. Message: \"");
Serial.print(messageString);
Serial.print("\", Properties: \"");
Serial.print(messageProperties);
Serial.println("\"");
}
free(tempBuffer);
}
return result;
}
void initIoTHub() {
iotHubClientHandle = IoTHubClient_LL_CreateFromConnectionString(connectionString, MQTT_Protocol);
if (iotHubClientHandle == NULL)
{
(void)printf("ERROR: Failed on IoTHubClient_LL_Create\r\n");
} else {
IoTHubClient_LL_SetMessageCallback(iotHubClientHandle, IoTHubMessageCallback, NULL);
}
}
void LEDOn() {
digitalWrite(LED_BUILTIN, LOW);
}
void LEDOff() {
digitalWrite(LED_BUILTIN, HIGH);
}
void setup() {
Serial.begin(115200);
dht.begin();
initWifi();
pinMode(LED_BUILTIN, OUTPUT);
LEDOff();
}
void loop() {
initWifi(); // always checking the WiFi connection
LEDOn();
// we will process every message in the Hub
while ((IoTHubClient_LL_GetSendStatus(iotHubClientHandle, &status) == IOTHUB_CLIENT_OK) && (status == IOTHUB_CLIENT_SEND_STATUS_BUSY))
{
IoTHubClient_LL_DoWork(iotHubClientHandle);
ThreadAPI_Sleep(1000);
}
String JSONMessage = "{\'temperature\':";
JSONMessage += dht.readTemperature();
JSONMessage += "}";
sendMessage(JSONMessage.c_str());
LEDOff();
delay(5000);
}
Ahora modifique ssid, pass y connectionString en las líneas 18 - 20 como se muestra a continuación y haga clic en el botón "Compilar y cargar":
String ssid = "iot"; // your network SSID (name)
String pass = "microsoft"; // your network password (use for WPA, or use as key for WEP)
static const char* connectionString = "HostName=daveiotdemo1.azure-devices.net;DeviceId=daveie;SharedAccessKey=1298128GASJDA12=";
- Ahora regresemos a Device Explorer, haga clic en Message To Device. Escribamos un mensaje , agreguemos las propiedades deseadas y hagamos clic en enviar, como se muestra a continuación:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/Iot-Message-to-device-wikiazure.png
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfbea51ab9f.png
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfb573931ef.png
Intenté tomar una fotografía más cercana de mi dispositivo en caso de que quiera validar la conectividad de su sensor:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfbf46d5839.png
Usando Serial Monitor, debería poder mirar el porcentaje de humedad, la temperatura en ° C y ° F:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfbd81a9e01.png
También debería poder monitorear los mensajes a través de Serial Monitor como se muestra a continuación:
https://wikiazure.azureedge.net/wp-content/uploads/2018/03/img_5abfbb095fbe4.png
Esto completa el artículo sobre cómo crear un Hub de IoT y conectar su dispositivo de IoT.
Conclusión
Azure proporciona una plataforma robusta en IoT con integración perfecta y una diversidad de proveedores de hardware certificados para permitir soluciones de IoT de forma transparente.