Gráficas utilizando CanvasJS

Las gráficas nos ayudan a visualizar un conjunto de datos para que podamos comparar rápidamente sus valores. 

Una tabla de datos en una hoja puede resultar difícil de analizar y tardaremos más tiempo en comprender y comparar los valores. En una gráfica todo se ve mucho más claro solo con un vistazo.

Aquí podemos ver un simple ejemplo para la creación de gráficas utilizando la librería CanvasJS.

Con esta librería podemos crear rápidamente gráficas dinámicas e integrarlas en la web.

Código html:

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css"/>
    
    <title>Ejemplos Graficas</title>
</head>
<body>
    <div class="container-fluid">
        <div class="row">
            <div class="col-md-6">
            <div id="pieChart" style="height: 360px; width: 100%;">
            </div>
            </div>
            <div class="col-md-6">
            <div id="columnChart" style="height: 360px; width: 100%;">
            </div>
            </div>
        </div>
        </div>

    <script src="https://canvasjs.com/assets/script/canvasjs.min.js"> </script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>
    <script src="pack.js"></script>
</body>
</html>

Código javaScript:

var pieChartValues = [{
    y: 39.16,
    exploded: true,
    indexLabel: "Estados Unidos",
    color: "#1f77b4"
}, {
    y: 21.8,
    indexLabel: "Canada",
    color: "#ff7f0e"
}, {
    y: 21.45,
    indexLabel: "Europa",
    color: " #ffbb78"
}, {
    y: 5.56,
    indexLabel: "Malasia",
    color: "#d62728"
}, {
    y: 5.38,
    indexLabel: "Peru",
    color: "#98df8a"
}, {
    y: 3.73,
    indexLabel: "Bolivia",
    color: "#bcbd22"
}, {
    y: 2.92,
    indexLabel: "Tunez",
    color: "#f7b6d2"
}];
renderPieChart(pieChartValues);

function renderPieChart(values) {

    var chart = new CanvasJS.Chart("pieChart", {
        backgroundColor: "white",
        colorSet: "colorSet2",

        title: {
            text: "Pie Chart",
            fontFamily: "Verdana",
            fontSize: 25,
            fontWeight: "normal",
        },
        animationEnabled: true,
        data: [{
            indexLabelFontSize: 15,
            indexLabelFontFamily: "Monospace",
            indexLabelFontColor: "darkgrey",
            indexLabelLineColor: "darkgrey",
            indexLabelPlacement: "outside",
            type: "pie",
            showInLegend: false,
            toolTipContent: "<strong>#percent%</strong>",
            dataPoints: values
        }]
    });
    chart.render();
}
var columnChartValues = [{
    y: 936.04,
    label: "Paris",
    color: "#1f77b4"
}, {
    y: 391.84,
    label: "Londres",
    color: "#ff7f0e"
}, {
    y: 365.76,
    label: "Roma",
    color: " #ffbb78"
}, {
    y: 197.48,
    label: "Barcelona",
    color: "#d62728"
}, {
    y: 94.2,
    label: "Atenas",
    color: "#98df8a"
}, {
    y: 65.28,
    label: "Berlin",
    color: "#bcbd22"
}, {
    y: 51.2,
    label: "Madrid",
    color: "#f7b6d2"
}];
renderColumnChart(columnChartValues);

function renderColumnChart(values) {

    var chart = new CanvasJS.Chart("columnChart", {
        backgroundColor: "white",
        colorSet: "colorSet3",
        title: {
            text: "Datos por Ciudades",
            fontFamily: "Verdana",
            fontSize: 25,
            fontWeight: "normal",
        },
        animationEnabled: true,
        legend: {
            verticalAlign: "bottom",
            horizontalAlign: "center"
        },
        theme: "theme2",
        data: [

            {
                indexLabelFontSize: 15,
                indexLabelFontFamily: "Monospace",
                indexLabelFontColor: "darkgrey",
                indexLabelLineColor: "darkgrey",
                indexLabelPlacement: "outside",
                type: "column",
                showInLegend: false,
                legendMarkerColor: "grey",
                dataPoints: values
            }
        ]
    });

    chart.render();
}

Son dos ejemplos simples para ver el potencial que nos ofrece esta librería.

Puedes encontar más información aquí.



Si encuentras esta noticia interesante la puedes compartir en tus redes sociales, a tus seguidores les puede gustar. Utiliza los botones que tienes más abajo.

Share

Búsquedas complejas en Postgresql

La mayoría de las veces realizaremos búsquedas por patrones conocidos y fáciles de obtener, simples y repetitivos, búsquedas directas, o parciales utilizando el comando “like“. Pero otras veces la información que intentamos localizar no se encuentra formateada como esperamos, conteniendo diferentes símbolos o signos repartidos entre el texto, lo cual dificulta enormemente encontrar los datos que buscamos.

Postgres cuenta con la función “similarity“. Esta función elimina todos los caracteres extraños; guiones, comas, puntos, signos de admiración y exclamación, etc. Dejando el texto lo más limpio posible, y divide la cadena resultante en trigramas. Realizando la comparación entre estos trigramas se obtiene un porcentaje de similitud. Este procedimiento funciona realmente bien al realizar búsquedas con cadenas complejas pero el problema es que es realmente lento. En una tabla con 200.000 registros, realizar una búsqueda con similarity puede llevar de 6 a 10 segundos, incluso más.

Para utilizar similarity en Postgres, necesitamos instalar la extensión pg_trgm con el siguiente comando:

CREATE EXTENSION pg_trgm;

Podemos obtener el trigrama de una cadena con:

select show_trgm('A-Team Year?, the')

Obtendremos el siguiente array:

{”  a”,”  t”,”  y”,” a “,” te”,” th”,” ye”,”am “,”ar “,eam,ear,”he “,tea,the,yea}

Para realizar una busqueda con similarity utilizamos la siguiente consulta:

SELECT * FROM filmografia
WHERE similarity('A-Team Year?, the', titulo) > 0.90

Titulo, es el campo en el que realizamos la búsqueda. 0.90 significa el porcentaje de similitud que requerimos. Si la comparación es superior al porcentaje requerido, se incluirá en los resultados. Podemos jugar con diferentes porcentajes hasta encontrar el que mejor se adapte a las búsquedas requeridas.

Este método es muy efectivo al realizar búsquedas, aunque también es muy lento.

Búsquedas contranslate

Otro método de búsqueda que nos puede resultar útil es utilizar la función “translate“. Con translate podemos reemplazar una serie de caracteres por otros:

select lower(translate('A-Team Year?, the', ' ,-,?,(,)', ''))

Con la consulta anterior obtenemos: “ateamyearthe

Como vemos se han eliminado todos los caracteres superfluos y los espacios, e igualando la cadena de búsqueda con las cadenas a explorar, podremos realizar búsquedas más complejas con buenos resultados.

Aquí la utilizamos para realizar búsquedas eliminando todos los caracteres innecesarios:

SELECT * FROM filmografia
WHERE LOWER(translate(titulo, ' ,-,?,(,)', '')) = LOWER(translate('A-Team Year?, the', ' ,-,?,(,)', ''))

Búsquedas con “Expresiones regulares”

Al realizar determinadas búsquedas también podemos utilizar “expresiones regulares“. Nos permiten obtener resultados que de otra forma seria mucho más complicado o no seria posible.

Si por ejemplo queremos buscar todas las cadenas que comienzan por un número podemos utilizar la siguiente expresión:

SELECT * FROM filmografía
WHERE titulo ~ '^[0-9].*'

Obtendremos todas las cadenas que por lo menos el primer carácter sea un número.

Existen infinidad de formas en las que podemos obtener aquellos datos que necesitamos, aquí, solo hemos comentado algunas de ellas.



Si encuentras esta noticia interesante la puedes compartir en tus redes sociales, a tus seguidores les puede gustar. Utiliza los botones que tienes más abajo.

Share

Generar mapas con datos estadísticos, con Python y Plotly

Si necesitas representar diferentes datos estadísticos sobre un mapa del mundo o de un continente o zona del planeta determinado, existe una herramienta muy potente que te permite de forma fácil realizar esta tarea.

Con Python y la librería Plotly podrás mostrar tus datos estadísticos sobre diferentes zonas geográficas.

El código es bien sencillo, y es altamente configurable. Para que Plotly ubique los datos en cada país, es necesario incluir el nombre de dicho país en los datos, el nombre debe estar en formato internacional, por ejemplo “Estados Unidos” debe ser “United States of America“.

import funciones_db as db
import plotly.graph_objects as go
import plotly.offline as opy

datos = db.actores_paises()

fig = go.Figure(go.Choropleth(
    locations = datos['pais'],
    locationmode = "country names",
    z = datos['total'],
    text = datos['pais_a'],
    colorscale = 'Hot',
    autocolorscale = False,
    reversescale = True,
    marker_line_color = '#efefef',
    marker_line_width = 0.5,
    colorbar_ticksuffix = '%',
    colorbar_title = 'Actores',
    )
)

fig.update_layout(
    title_text = 'Número de Actores por Países',
    showlegend = False,
    geo = dict(
        scope = 'world',
        resolution = 50,
        projection_type = 'miller',
        showcoastlines = True,
        showocean = True,
        showcountries = True,
        oceancolor = '#eaeaea',
        lakecolor = '#eaeaea',
        coastlinecolor = '#dadada'
    )
)

fig.show()

En el ejemplo los datos se extraen de una base de datos.

  • locations: Indica el país al que pertenece el dato.
  • locationmode = “country names”: Indica la forma en la que se mostrara la información, es este caso por países. Si llos datos son para un determinado país y quieres mostrar los datos por provincias o estados, se debe cambiar este parametro.
  • colorscale: La paleta de colores que mostrará los datos. Algunas de las paletas disponibles; Brwnyl, Agsunset, Sunsetdark, Magenta, Sunset, Purpor, Purp, Tealgrn, Teal, Bluyl, Aggrnyl, Emrld, Darkmint, Blugrn, Mint, Pinkyl, Peach, Oryel, Redor, Burgyl, Burg, tempo, amp, speed, matter, algae, dense, deep, gray, ice, solar, haline, thermal, turbid, YlOrRd, YlOrBr, YlGnBu, YlGn, Reds, RdPu, RdBu, Purples, Greys, Greens, Rainbow. Lista completa, aqui.
  • scope: Es la parte del globo terraqueo que se mostrará. world, para mostrar todos los continentes. Otros valores para cada continente; “usa” | “europe” | “asia” | “africa” | “north america” | “south america”.
  • projection_type: Es el tipo de mapa que se representará. Admite los siguientes valores; equirectangular, mercator, orthographic, natural earth, kavrayskiy7, miller, robinson, eckert4, azimuthal equal area, azimuthal equidistant, conic equal area, conic conformal, conic equidistant, gnomonic, stereographic, mollweide, hammer, transverse mercator, albers usa, winkel tripel, aitoff, sinusoidal.
  • También es posible personalizar y mostrar/ocultar otros datos del mapa, como la separación de los paises o el color de los oceanos.
  • El código genera un archivo en html, que se abre directamente en el navegador por defecto del sistema.

Algunos ejemplos con Plotly, cambiando los parametros; colorscale, scope y projection_type.

Para visualizar los datos de cada país, tan solo debemos pasar el cursor del ratón por encima de dicho país.

Los mapas pueden ser facilmente incluidos en proyecto de dJango, directamento o a través de javascript.

Plotly es una herramienta muy completa, la cual también permite realizar infinidad de graficas estadisticas a parte de los mapas. Más información de esta completa libreria aqui.



Si encuentras esta noticia interesante la puedes compartir en tus redes sociales, a tus seguidores les puede gustar. Utiliza los botones que tienes más abajo.

Share

Como escuchar Apple Music en un dispositivo Alexa

La música es la alegre sonrisa que endulza nuestro día a día. Hace unos años la forma tradicional para escuchar música era sintonizar una emisora de radio, o comprar en alguno de los formatos disponibles, según la época; vinilo, CD o casete de audio, nuestro grupo o solista preferido. Con la llegada de Internet y el desarrollo de tecnologías como el streaming, la tendencia actual para escuchar música es precisamente el uso del streaming.

Existen diferentes alternativas para poder escuchar millones de canciones en streaming; Apple Music, Amazon Music, Spotify, Pandora, Tidal o Soundcloud, por poner las más famosas y reconocidas.

Si tienes una cuenta en Apple Music, puedes pedirle a Alexa que ponga tu música favorita en tus dispositivos Alexa.

Para ello debes instalar la Skill de “Apple Music“. Una vez instalada debes configurar la skill para enlazarla con tu cuenta de Apple Music.

Una vez realizadas las acciones anteriores, ve a “Más / Configuración / Música“. Si Apple Music no te sale en la lista, pulsa en “Vincular servicio nuevo” y selecciona el servicio de Apple Music.

Para configurar el orden de los servicios predeterminados, pulsa sobre “Servicios predeterminados“. En la nueva pantalla selecciona el servicio que por defecto se iniciara en tu dispositivo al solicitar una canción o emisora de radio a Alexa.

El order actual es el que verás debajo de “Servicios predeterminados“.

También puedes decirle a Alexa con que servicio quieres que reproduzca una cación, pero el comando de voz es más largo, ejemplo: “Alexa pon una canción de Madonna en Apple Music“.



Si encuentras esta noticia interesante la puedes compartir en tus redes sociales, a tus seguidores les puede gustar. Utiliza los botones que tienes más abajo.

Share

Convertir Arduino en un controlador de dispositivos con Alexa

Vamos a convertir, una tarjeta Arduino Wemos (Con modulo wifi), utilizando un modulo de reles, en un accesorio para encender/apagar diferentes dispositivos; luces, ventiladores, calefactores, discos duros o cualquier otro dispositivo que se te ocurra.

Para realizar esta tarea nos hace falta:

  • Una tarjeta Wemos.
  • Un modulo de reles, puede ser de 1, 2, 4 u 8 reles.
  • Darnos de alta en la web https://sinric.com/
  • Instalar la skill Sinric en Amazon Alexa.

Sinric es una Api gratuita desde la que vamos a poder crear todos aquellos dispositivos que necesitemos controlar. Por cada dispositivo que creamos, Sinric asigna un ID para su identificación.

Para añadir un nuevo dispositivo pulsamos en el botón “ADD” de la sección “Smart Home Device“, se abrira un panel como el de la imagen superior.

  • Friendly Name. Es el nombre con el que invocaremos a Alexa, para gestionar nuestro dispositivo, encender / apagar.
  • Description. La descripción del dispositivo.
  • Device Type. De la lista desplegable seleccionamos el que más se adapte a nuestro tipo de dispositivo.

Guardamos el nuevo dispositivo, y realizamos la misma operación para crear todos los que necesitemos.

En la pantalla principal de sinric veremos todos los dispositivos creados, es importante apuntar los ID que la aplicación ha generado. También debemos anotar el “Your API Key“, se encuentra en la parte superior, con estos datos podremos controlar los dispositivos desde nuestra Arduino.

En este repositorio de github podemos encontrar los archivos “ino” para la tarjeta Arduino, existen diferentes ejemplos para el uso de la api de sinric.

Aqui tienes el código que utilizo para gestionar mis dispositivos a traves de Alexa. Se pueden controlar 4 dispositivos, pero es muy fácil añadir más.

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <WebSocketsClient.h> //  https://github.com/kakopappa/sinric/wiki/How-to-add-dependency-libraries
#include <ArduinoJson.h> // https://github.com/kakopappa/sinric/wiki/How-to-add-dependency-libraries
#include <StreamString.h>

ESP8266WiFiMulti WiFiMulti;
WebSocketsClient webSocket;
WiFiClient client;

#define MyApiKey "Tu-Api-Key-de-Sinric" // TODO: Change to your sinric API Key. Your API Key is displayed on sinric.com dashboard
#define MySSID "El-Nombre-de-tu-WIFI" // TODO: Change to your Wifi network SSID
#define MyWifiPassword "La-Contraseña-de-tu-WIFI" // TODO: Change to your Wifi network password

#define HEARTBEAT_INTERVAL 300000 // 5 Minutes 

const int relayPin1 = D1;
const int relayPin2 = D2;
const int relayPin3 = D3;
const int relayPin4 = D4;

uint64_t heartbeatTimestamp = 0;
bool isConnected = false;

void setPowerStateOnServer(String deviceId, String value);
void setTargetTemperatureOnServer(String deviceId, String value, String scale);

// deviceId is the ID assgined to your smart-home-device in sinric.com dashboard. Copy it from dashboard and paste it here

void turnOn(String deviceId) {

  // Device 1
  if (deviceId == "El-ID-de-tu-Dispositivo") // Device ID of first device
  {
    Serial.print("Turn on device id: ");
    Serial.println(deviceId);

    digitalWrite(relayPin1, HIGH); // turn on relay with voltage HIGH
  }
  else {
    Serial.print("Turn on for unknown device id: ");
    Serial.println(deviceId);
  }

  // Device 2
  if (deviceId == "El-ID-de-tu-Dispositivo") // Device ID of first device
  {
    Serial.print("Turn on device id: ");
    Serial.println(deviceId);

    digitalWrite(relayPin2, HIGH); // turn on relay with voltage HIGH
  }
  else {
    Serial.print("Turn on for unknown device id: ");
    Serial.println(deviceId);
  }

  // Device 3
  if (deviceId == "El-ID-de-tu-Dispositivo") // Device ID of first device
  {
    Serial.print("Turn on device id: ");
    Serial.println(deviceId);

    digitalWrite(relayPin3, HIGH); // turn on relay with voltage HIGH
  }
  else {
    Serial.print("Turn on for unknown device id: ");
    Serial.println(deviceId);
  }

  // Device 4
  if (deviceId == "El-ID-de-tu-Dispositivo") // Device ID of first device
  {
    Serial.print("Turn on device id: ");
    Serial.println(deviceId);

    digitalWrite(relayPin4, HIGH); // turn on relay with voltage HIGH
  }
  else {
    Serial.print("Turn on for unknown device id: ");
    Serial.println(deviceId);
  }
}

void turnOff(String deviceId) {

  // Device 1
  if (deviceId == "El-ID-de-tu-Dispositivo") // Device ID of first device
  {
    Serial.print("Turn off Device ID: ");
    Serial.println(deviceId);

    digitalWrite(relayPin1, LOW);  // turn off relay with voltage LOW
  }
  else {
    Serial.print("Turn off for unknown device id: ");
    Serial.println(deviceId);
  }

  // Device 2
  if (deviceId == "El-ID-de-tu-Dispositivo") // Device ID of first device
  {
    Serial.print("Turn off Device ID: ");
    Serial.println(deviceId);

    digitalWrite(relayPin2, LOW);  // turn off relay with voltage LOW
  }
  else {
    Serial.print("Turn off for unknown device id: ");
    Serial.println(deviceId);
  }

  // Device 3
  if (deviceId == "El-ID-de-tu-Dispositivo") // Device ID of first device
  {
    Serial.print("Turn off Device ID: ");
    Serial.println(deviceId);

    digitalWrite(relayPin3, LOW);  // turn off relay with voltage LOW
  }
  else {
    Serial.print("Turn off for unknown device id: ");
    Serial.println(deviceId);
  }

  // Device 4
  if (deviceId == "El-ID-de-tu-Dispositivo") // Device ID of first device
  {
    Serial.print("Turn off Device ID: ");
    Serial.println(deviceId);

    digitalWrite(relayPin4, LOW);  // turn off relay with voltage LOW
  }
  else {
    Serial.print("Turn off for unknown device id: ");
    Serial.println(deviceId);
  }
}

void webSocketEvent(WStype_t type, uint8_t * payload, size_t length) {
  switch (type) {
    case WStype_DISCONNECTED:
      isConnected = false;
      Serial.printf("[WSc] Webservice disconnected from sinric.com!\n");
      break;
    case WStype_CONNECTED: {
        isConnected = true;
        Serial.printf("[WSc] Service connected to sinric.com at url: %s\n", payload);
        Serial.printf("Waiting for commands from sinric.com ...\n");
      }
      break;
    case WStype_TEXT: {
        Serial.printf("[WSc] get text: %s\n", payload);
        // Example payloads

        // For Switch or Light device types
        // {"deviceId": xxxx, "action": "setPowerState", value: "ON"} // https://developer.amazon.com/docs/device-apis/alexa-powercontroller.html

        // For Light device type
        // Look at the light example in github

        DynamicJsonBuffer jsonBuffer;
        JsonObject& json = jsonBuffer.parseObject((char*)payload);
        String deviceId = json ["deviceId"];
        String action = json ["action"];

        if (action == "setPowerState") { // Switch or Light
          String value = json ["value"];
          if (value == "ON") {
            turnOn(deviceId);
          } else {
            turnOff(deviceId);
          }
        }
        else if (action == "SetTargetTemperature") {
          String deviceId = json ["deviceId"];
          String action = json ["action"];
          String value = json ["value"];
        }
        else if (action == "test") {
          Serial.println("[WSc] received test command from sinric.com");
        }
      }
      break;
    case WStype_BIN:
      Serial.printf("[WSc] get binary length: %u\n", length);
      break;
  }
}

void setup() {
  Serial.begin(115200);

  // Relay PIN eg: https://github.com/wemos/D1_mini_Examples/blob/master/examples/04.Shields/Relay_Shield/Blink/Blink.ino
  pinMode(relayPin1, OUTPUT);
  pinMode(relayPin2, OUTPUT);
  pinMode(relayPin3, OUTPUT);
  pinMode(relayPin4, OUTPUT);
  

  WiFiMulti.addAP(MySSID, MyWifiPassword);
  Serial.println();
  Serial.print("Connecting to Wifi: ");
  Serial.println(MySSID);

  // Waiting for Wifi connect
  while (WiFiMulti.run() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  if (WiFiMulti.run() == WL_CONNECTED) {
    Serial.println("");
    Serial.print("WiFi connected. ");
    Serial.print("IP address: ");
    Serial.println(WiFi.localIP());
  }

  // server address, port and URL
  webSocket.begin("iot.sinric.com", 80, "/");

  // event handler
  webSocket.onEvent(webSocketEvent);
  webSocket.setAuthorization("apikey", MyApiKey);

  // try again every 5000ms if connection has failed
  webSocket.setReconnectInterval(5000);   // If you see 'class WebSocketsClient' has no member named 'setReconnectInterval' error update arduinoWebSockets
}

void loop() {
  webSocket.loop();

  if (isConnected) {
    uint64_t now = millis();

    // Send heartbeat in order to avoid disconnections during ISP resetting IPs over night. Thanks @MacSass
    if ((now - heartbeatTimestamp) > HEARTBEAT_INTERVAL) {
      heartbeatTimestamp = now;
      webSocket.sendTXT("H");
    }
  }
}

// If you are going to use a push button to on/off the switch manually, use this function to update the status on the server
// so it will reflect on Alexa app.
// eg: setPowerStateOnServer("deviceid", "ON")

// Call ONLY If status changed. DO NOT CALL THIS IN loop() and overload the server.
void setPowerStateOnServer(String deviceId, String value) {
  DynamicJsonBuffer jsonBuffer;
  JsonObject& root = jsonBuffer.createObject();
  root["deviceId"] = deviceId;
  root["action"] = "setPowerState";
  root["value"] = value;
  StreamString databuf;
  root.printTo(databuf);

  webSocket.sendTXT(databuf);
}

//eg: setPowerStateOnServer("deviceid", "CELSIUS", "25.0")

// Call ONLY If status changed. DO NOT CALL THIS IN loop() and overload the server.
void setTargetTemperatureOnServer(String deviceId, String value, String scale) {
  DynamicJsonBuffer jsonBuffer;
  JsonObject& root = jsonBuffer.createObject();
  root["action"] = "SetTargetTemperature";
  root["deviceId"] = deviceId;

  JsonObject& valueObj = root.createNestedObject("value");
  JsonObject& targetSetpoint = valueObj.createNestedObject("targetSetpoint");
  targetSetpoint["value"] = value;
  targetSetpoint["scale"] = scale;

  StreamString databuf;
  root.printTo(databuf);

  webSocket.sendTXT(databuf);
}

Rellena los siguientes apartados con tus datos:

  • Tu-Api-Key-de-Sinric.
  • El-Nombre-de-tu-WIFI
  • La-Contraseña-de-tu-WIFI
  • El-ID-de-tu-Dispositivo

Carga el archivo “ino” en la tarjeta Arduino.

Ahora queda montar tu tarjeta Arduino Wemos con la placa de reles, hacer las conexiones entre Arduino y reles, y las conexiones para la corriente electrica de los enchufes que utilices.

Para comprobar que todo funciona correctamente, aun nos queda realizar un paso más.

Desde la aplicación “Amazon Aleza“, de tu dispositivo móvil, instala la skill de “Sinric“, puedes ver más información pinchando en el enlace.

Una vez configurada debes pulsar en “Más” y “Añadir dispositivo“. Pulsa sobre uno de los dispositivos, por ejemplo “Luz“, y en la siguiente pantalla, pulsa en “Otro“. Pulsa en el botón “Detectar Dispositivos“. Si todo fue bien, pasados unos minutos, Alexa habra detectado los nuevos dispositivos.

Dile a Alexa que encienda alguno de los dispositivos que has creado en Sinric.

Recuerda que estos dispositivos se comportan exactamente como cualquier otro dispositivo que has comprado. Creando rutinas, puedes programarlo para que se encienda/apage a una hora determinada o cuando se produzca un determinado evento.



Si encuentras esta noticia interesante la puedes compartir en tus redes sociales, a tus seguidores les puede gustar. Utiliza los botones que tienes más abajo.

Share