Hackathon - Curso introductorio

#include <Arduino.h>
#include <Wire.h>
#include <SPI.h>

#define MIKROBUS_AN 4
#define MIKROBUS_RST 15
#define MIKROBUS_CS 6
#define MIKROBUS_SCK 8
#define MIKROBUS_MISO 18
#define MIKROBUS_MOSI 17
#define MIKROBUS_PWM 5
#define MIKROBUS_INT 7
#define MIKROBUS_RX 9
#define MIKROBUS_TX 10
#define MIKROBUS_SCL 13
#define MIKROBUS_SDA 12

#define BOARD_LED 16

void setup(){

  // mikroBUS GPIO
  pinMode( MIKROBUS_AN, OUTPUT );
  pinMode( MIKROBUS_RST, OUTPUT );
  pinMode( MIKROBUS_CS, OUTPUT );
  pinMode( MIKROBUS_PWM, OUTPUT );
  pinMode( MIKROBUS_INT, OUTPUT );
  pinMode( BOARD_LED, OUTPUT );

  digitalWrite( MIKROBUS_AN, HIGH );
  digitalWrite( MIKROBUS_RST, HIGH );
  digitalWrite( MIKROBUS_CS, HIGH );
  digitalWrite( MIKROBUS_PWM, HIGH );
  digitalWrite( MIKROBUS_INT, HIGH );
  digitalWrite( BOARD_LED, HIGH );

  // UART config
  Serial.begin( 115200 ); // USB/UART0
  Serial2.begin( 115200, SERIAL_8N1, MIKROBUS_RX, MIKROBUS_TX ); // mikroBUS
  
  // I2C config
  Wire.setPins( MIKROBUS_SDA, MIKROBUS_SCL ); // mikroBUS
  Wire.begin();

  // SPI config
  SPI.begin( MIKROBUS_SCK, MIKROBUS_MISO, MIKROBUS_MOSI ); // mikroBUS
}

void loop(){

  digitalWrite( MIKROBUS_AN, LOW );
  digitalWrite( MIKROBUS_RST, LOW );
  digitalWrite( MIKROBUS_CS, LOW );
  digitalWrite( MIKROBUS_PWM, LOW );
  digitalWrite( MIKROBUS_INT, LOW );

  delay( 1000 );

  digitalWrite( MIKROBUS_AN, HIGH );
  digitalWrite( MIKROBUS_RST, HIGH );
  digitalWrite( MIKROBUS_CS, HIGH );
  digitalWrite( MIKROBUS_PWM, HIGH );
  digitalWrite( MIKROBUS_INT, HIGH );

  delay( 1000 );

}

#include <Arduino.h>
#include <Wire.h>

// ************ CONFIGURACION DE PINOUT MIKROBUS ***************
#define MIKROBUS_AN 4
#define MIKROBUS_RST 15
#define MIKROBUS_CS 6
#define MIKROBUS_SCK 8
#define MIKROBUS_MISO 18
#define MIKROBUS_MOSI 17
#define MIKROBUS_PWM 5
#define MIKROBUS_INT 7
#define MIKROBUS_RX 9
#define MIKROBUS_TX 10
#define MIKROBUS_SCL 13
#define MIKROBUS_SDA 12

#define BOARD_LED 16

void writeXN02Binary( uint8_t stat ){

    // XN02
    Wire.beginTransmission( 2 );
    // Registro de salidas
    Wire.write( 0x01 );
    // Valor de salidas
    Wire.write( stat );
    Wire.endTransmission();

}

void writeXN02( bool o1 = LOW, bool o2 = LOW, bool o3 = LOW, bool o4 = LOW, bool o5 = LOW, bool o6 = LOW, bool o7 = LOW, bool o8 = LOW ){
    uint8_t data = 0;

    data |= o1;
    data |= o2 << 1;
    data |= o3 << 2;
    data |= o4 << 3;
    data |= o5 << 4;
    data |= o6 << 5;
    data |= o7 << 6;
    data |= o8 << 7;

    writeXN02Binary( data );
}

void setup() {

  // Configuración de comunicaciones seriales
  Serial.begin(115200);
  Wire.setPins( MIKROBUS_SDA, MIKROBUS_SCL );
  Wire.begin();

}

void loop() {

  // Secuencia de leds
  writeXN02( HIGH );
  delay( 1000UL );
  writeXN02( HIGH, HIGH );
  delay( 1000UL );
  writeXN02( HIGH, HIGH, HIGH );
  delay( 1000UL );
  writeXN02( HIGH, HIGH, HIGH, HIGH);
  delay( 1000UL );
  writeXN02( HIGH, HIGH, HIGH, HIGH, HIGH );
  delay( 1000UL );
  writeXN02( HIGH, HIGH, HIGH, HIGH, HIGH, HIGH );
  delay( 1000UL );
  writeXN02( HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH );
  delay( 1000UL );
  writeXN02( HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH );
  delay( 1000UL );

}

#include <Arduino.h>
#include <Wire.h>

// ************ CONFIGURACION DE PINOUT MIKROBUS ***************
#define MIKROBUS_AN 4
#define MIKROBUS_RST 15
#define MIKROBUS_CS 6
#define MIKROBUS_SCK 8
#define MIKROBUS_MISO 18
#define MIKROBUS_MOSI 17
#define MIKROBUS_PWM 5
#define MIKROBUS_INT 7
#define MIKROBUS_RX 9
#define MIKROBUS_TX 10
#define MIKROBUS_SCL 13
#define MIKROBUS_SDA 12

#define BOARD_LED 16

float readXN04Temperature( ){

    float temperature;
    uint16_t temperature_int;
    // XN04
    Wire.beginTransmission( 4 );
    // Registro de temperature
    Wire.write( 0x01 );
    Wire.endTransmission();

    Wire.requestFrom( 4, 2 );
    
    temperature_int = ( (Wire.read() << 8) | Wire.read() );
    temperature = temperature_int/100.0f;

    return temperature;
}

float readXN04Humidity( ){

    float humidity;
    uint16_t humidity_int;
    // XN04
    Wire.beginTransmission( 4 );
    // Registro de humidity
    Wire.write( 0x02 );
    Wire.endTransmission();

    Wire.requestFrom( 4, 2 );
    
    humidity_int = ( (Wire.read() << 8) | Wire.read() );
    humidity = humidity_int/100.0f;

    return humidity;

}

uint16_t readXN04Luminosity( ){

    uint16_t lux;
    // XN04
    Wire.beginTransmission( 4 );
    // Registro de lux
    Wire.write( 0x03 );
    Wire.endTransmission();

    Wire.requestFrom( 4, 2 );
    
    lux = ( (Wire.read() << 8) | Wire.read() );

    return lux;

}

void setup() {

  // Configuración de comunicaciones seriales
  Serial.begin(115200);
  Wire.setPins( MIKROBUS_SDA, MIKROBUS_SCL );
  Wire.begin();

}

void loop() {

  float temperatura, humedad;
  uint16_t lux;

  // Obtener temperatura
  temperatura = readXN04Temperature(  );
  // Obtener humedad
  humedad = readXN04Humidity(  );
  // Obtener luminosidad
  lux = readXN04Luminosity(  );

  Serial.print( "Temperatura: " );
  Serial.print( temperatura );
  Serial.println( " C" );

  Serial.print( "Humedad: " );
  Serial.print( humedad );
  Serial.println( " %" );

  Serial.print( "Luminosidad: " );
  Serial.print( lux );
  Serial.println( " lx" );
  
  delay( 2000UL );
}

#include <Arduino.h>
#include <Wire.h>

// ************ CONFIGURACION DE PINOUT MIKROBUS ***************
#define MIKROBUS_AN 4
#define MIKROBUS_RST 15
#define MIKROBUS_CS 6
#define MIKROBUS_SCK 8
#define MIKROBUS_MISO 18
#define MIKROBUS_MOSI 17
#define MIKROBUS_PWM 5
#define MIKROBUS_INT 7
#define MIKROBUS_RX 9
#define MIKROBUS_TX 10
#define MIKROBUS_SCL 13
#define MIKROBUS_SDA 12

#define BOARD_LED 16

void writeXN11(uint8_t relay, uint8_t stat)
{
  uint8_t reg = 0x00;
  uint8_t data = 0x00;

  if ( stat ){
    data = 0x01;
  } else {
    data = 0x00;
  }

  switch( relay ){
    case 1:
    case 2:
    reg = relay;
    break;
    default:
    return;
  }

  // XN11
  Wire.beginTransmission(11);
  // Valor de salidas
  Wire.write( reg );
  Wire.write(data);
  Wire.endTransmission();
}

void setup() {

  // Configuración de comunicaciones seriales
  Serial.begin(115200);
  Wire.setPins( MIKROBUS_SDA, MIKROBUS_SCL );
  Wire.begin();

  writeXN11( 1, LOW );
  writeXN11( 2, LOW );

}

void loop() {

  write( 1, HIGH );
  delay( 5000UL );
  write( 2, HIGH );
  delay( 5000UL );
  writeXN11( 1, LOW );
  writeXN11( 2, LOW );
  delay( 5000UL );

}

// Selecciona el modelo de módem el XC03 utiliza SIM7080G
// esta instrucción debe ir antes de incluir la librería
#define TINY_GSM_MODEM_SIM7080

// Se incluye la librería TinyGSM
#include <Arduino.h>
#include <TinyGsmClient.h>

// La comunicación requiere un puerto UART para enviar comandos AT
#define SerialAT Serial2

// El encendido del módem requiere controlar el pin Power-Key (PK)
#define PIN_MODEM_PK 7

// Configuración de la tarjeta SIM
const char apn[]  = "";
const char user[] = "";
const char pass[] = "";
const char pin[] = "";

// Variables de geolocalización
float latitude;
float longitude;
float speed;
float alt;
int vsat;
int usat;
float accuracy;
int year;
int month;
int day;
int hour;
int minute;
int second;

void setup(){
    // Inicia la comunicación con el módem, la velocidad
    // de transmisión de datos es 115200
    SerialAT.begin(115200);

    pinMode( PIN_MODEM_PK, OUTPUT );
  
    // Para reiniciar el módem el pin PK debe
    // ser 1 por al menos 3 segundos
    digitalWrite( PIN_MODEM_PK, HIGH );
    delay(3000);
    digitalWrite( PIN_MODEM_PK, LOW );

    // Reinicia la configuración del módem
    // para garantizar un correcto funcionamiento
    modem.restart();

    // Si la SIM se encuentra bloqueada por número PIN
    // la desbloquea
    modem.simUnlock( GSM_PIN );

}

void loop(){

    // Regresa una variable String con el modelo del módem 
    modem.getModemInfo();

    // Habilita la geolocalización, requiere deshabilitar
    // la comunicación celular, regresa True en caso de éxito,
    // False en caso contrario
    modem.enableGPS();

    // Obtiene las variables calculadas por el GNSS, regresa True
    // si el GNSS está listo y obtuvo la posición, False si aún no
    // se ha obtenido una posición.
    modem.getGPS( &latitude, &longitude, &speed, &alt, &vsat,
    &usat, &accuracy, &year, &month, &day, &hour, &minute, &second );

    // La posición requiere mayor precisión que una variable tipo Float,
    // utiliza la promoción de float a doble:
    // (double) myFloatVar // Al usar el valor en funciones
    // (double) myFloatVar + (double) myFloatVar2 // Al realizar operaciones aritmeticas
    // para evitar perder precisión.
    Serial.print( "Latitud: " );
    Serial.println( (double)latitude, 5 );

    Serial.print( "Longitud: " );
    Serial.println( (double)longitude, 5 );

    // Deshabilita la geolocalización
    modem.disableGPS();

    // Habilita la comunicación celular, requiere deshabilitar
    // la geolocalización
    modem.gprsConnect( apn, user, pass );

    // Consulta el estado de conexión con la red celular
    // regresa True si hay una conexión activa,
    // False en caso contrario
    modem.isGprsConnected();

    // Deshabilita la geolocalización
    modem.gprsDisconnect();
}

#define TINY_GSM_MODEM_SIM7080

#include <Arduino.h>
#include <TinyGsmClient.h>

// ********** CONFIGURACION DE COMUNICACIONES SERIALES ********
#define SerialMon Serial
#define SerialAT Serial2
#define TINY_GSM_DEBUG SerialMon

// ************ CONFIGURACION DE PINOUT MIKROBUS ***************
#define MIKROBUS_AN 4
#define MIKROBUS_RST 15
#define MIKROBUS_CS 6
#define MIKROBUS_SCK 8
#define MIKROBUS_MISO 18
#define MIKROBUS_MOSI 17
#define MIKROBUS_PWM 5
#define MIKROBUS_INT 7
#define MIKROBUS_RX 9
#define MIKROBUS_TX 10
#define MIKROBUS_SCL 13
#define MIKROBUS_SDA 12

#define BOARD_LED 16

#define PIN_MODEM_PK MIKROBUS_INT

// *************** CONFIGURACION OPERADORA LTE ******************
const char apn[]  = "";
const char user[] = "";
const char pass[] = "";


// ******************* VARIABLES GLOBALES ***********************
static TinyGsm modem(SerialAT);


// ********************* FUNCIONES GNSS *************************
bool getGNSS();


void setup() {

  // Configuración de comunicaciones seriales
  SerialMon.begin(115200);
  SerialAT.begin(115200, SERIAL_8N1, MIKROBUS_RX, MIKROBUS_TX );

  // Inicialización de I/O
  pinMode( BOARD_LED, OUTPUT );
  digitalWrite( BOARD_LED, LOW );
  pinMode( PIN_MODEM_PK, OUTPUT );
  
  // Reinicio del modem LTE por hardware
  digitalWrite( PIN_MODEM_PK, HIGH );
  delay(3000);
  digitalWrite( PIN_MODEM_PK, LOW );

  // Configuración inicial del modem LTE
  SerialMon.println("Iniciando modem LTE...");
  modem.restart();
  String modemInfo = modem.getModemInfo();
  SerialMon.print("Modem: ");
  SerialMon.println(modemInfo);

  // Finaliza las comunicaciones LTE e inicia
  // GNSS
  modem.gprsDisconnect();
  if ( !modem.enableGPS() ) {
    Serial.println( "Error al iniciar GNSS" );
    while(1){
      delay( 1000 );
    }
  }

}

void loop() {

  // Obtener posición
  updateGNSS();
  delay( 1000UL );

}

bool updateGNSS() {
  // Colocamos un tiempo de espera máximo de 30 segundos y 90 para coldboot
  static bool coldboot = true;
  const unsigned long timeout_coldboot = 90000;
  const unsigned long timeout_run = 30000;

  float latitude;
  float longitude;
  float speed;
  float alt;
  int vsat;
  int usat;
  float accuracy;
  int year;
  int month;
  int day;
  int hour;
  int minute;
  int second;

  unsigned long timer = 0;
  unsigned long timeout = 0;
  bool success = false;

  if ( coldboot ){
    timeout = timeout_coldboot;
  } else {
    timeout = timeout_run;
  }

  // Comenzamos el temporizador
  timer = millis();

  // Mientras no se agote el tiempo de espera intentar obtener la posición
  while ( ( millis() - timer ) < timeout ) {

    success = modem.getGPS( &latitude, &longitude, &speed, &alt, &vsat, &usat, &accuracy,
                            &year, &month, &day, &hour, &minute, &second );

    // Si se obtiene la posición exitosamente entonces finalizar el bucle
    if ( success ) {
      break;
    }
  }

  // Retorna el resultado de la operación, si se obtuvo la posición
  // deshabilita el abanderamiento de Coldboot y muestra los datos
  if ( !success ) {
    return false;
  }

  // La posición requiere mayor precisión que una variable tipo Float,
  // utiliza la promoción de float a doble:
  // (double) myFloatVar // Al usar el valor en funciones
  // (double) myFloatVar + (double) myFloatVar2 // Al realizar operaciones aritmeticas
  // para evitar perder precisión.
  Serial.print( "Latitud: " );
  Serial.println( (double)latitude, 5 );

  Serial.print( "Longitud: " );
  Serial.println( (double)longitude, 5 );

  Serial.print( "Velocidad ( km/h ): " );
  Serial.println( speed );

  Serial.print( "Altitud (mts): " );
  Serial.println( alt );

  Serial.print( "Satelites (en vista): " );
  Serial.println( vsat );

  Serial.print( "Satelites (utilizados): " );
  Serial.println( usat );

  Serial.print( "Precision (mts): " );
  Serial.println( accuracy );

  Serial.print( "Fecha/Hora: " );
  Serial.print( day );
  Serial.print( "/" );
  Serial.print( month );
  Serial.print( "/" );
  Serial.print( year );
  Serial.print( " " );
  Serial.print( hour );
  Serial.print( ":" );
  Serial.print( minute );
  Serial.print( ":" );
  Serial.println( second );

  coldboot = false;
  return true;
}

/*
 * Configuración del template en Blynk:
 * V0 - Control del led: 0 = apagado, 1 = encendido
 * V1 - Estado del botón BOOT
 */

// *************** TEMPLATE DE BLYNK **************************
#define BLYNK_TEMPLATE_ID "TMPxxxxxx"
#define BLYNK_TEMPLATE_NAME "Device"
#define BLYNK_AUTH_TOKEN "YourAuthToken"

#define BLYNK_PRINT Serial

// ******************* MODEM SIM7080 **************************
#define TINY_GSM_MODEM_SIM7080

#include <Arduino.h>
#include <Wire.h>
#include <TinyGsmClient.h>
#include <BlynkSimpleTinyGSM.h>

// ********** CONFIGURACION DE COMUNICACIONES SERIALES ********
#define SerialMon Serial
#define SerialAT Serial2
#define TINY_GSM_DEBUG SerialMon

// ************ CONFIGURACION DE PINOUT MIKROBUS ***************
#define MIKROBUS_AN 4
#define MIKROBUS_RST 15
#define MIKROBUS_CS 6
#define MIKROBUS_SCK 8
#define MIKROBUS_MISO 18
#define MIKROBUS_MOSI 17
#define MIKROBUS_PWM 5
#define MIKROBUS_INT 7
#define MIKROBUS_RX 9
#define MIKROBUS_TX 10
#define MIKROBUS_SCL 13
#define MIKROBUS_SDA 12

#define BOARD_LED 16
#define BOARD_BUTTON 0

#define PIN_MODEM_PK MIKROBUS_INT

// *************** CONFIGURACION OPERADORA LTE ******************
const char apn[] = "";
const char user[] = "";
const char pass[] = "";

// ************** CONFIGURACION SERVIDOR BLYNK ******************
const char domain[] = "ny3.blynk.cloud";
const char auth[] = BLYNK_AUTH_TOKEN;

// ******************* VARIABLES GLOBALES ***********************
static BlynkTimer scheduler;
static TinyGsm modem(SerialAT);

// Si el estado del botón ha cambiado actualizar el valor en Blynk
void updateButton(  )
{
    static int prev_status = HIGH;

    int current_status = digitalRead( BOARD_BUTTON );

    // Actualizar información a la nube solo si el
    // estado del botón ha cambiado, esto
    // disminuye la cantidad de datos utilizados
    if ( current_status == prev_status ){
        return;
    }

    prev_status = current_status;

    Blynk.virtualWrite(V1, current_status);
}

void setup()
{

    // Configuración de comunicaciones seriales
    SerialMon.begin(115200);
    SerialAT.begin(115200, SERIAL_8N1, MIKROBUS_RX, MIKROBUS_TX);
    Wire.setPins(MIKROBUS_SDA, MIKROBUS_SCL);
    Wire.begin();

    // Inicialización de I/O
    pinMode( BOARD_BUTTON, INPUT_PULLUP );
    pinMode(BOARD_LED, OUTPUT);
    digitalWrite(BOARD_LED, LOW);
    pinMode(PIN_MODEM_PK, OUTPUT);

    // Reinicio del modem LTE por hardware
    digitalWrite(PIN_MODEM_PK, HIGH);
    delay(3000);
    digitalWrite(PIN_MODEM_PK, LOW);

    // Configuración inicial del modem LTE
    SerialMon.println("Iniciando modem LTE...");
    modem.restart();
    String modemInfo = modem.getModemInfo();
    SerialMon.print("Modem: ");
    SerialMon.println(modemInfo);

    // Iniciar comunicación con Blynk.Cloud
    Blynk.begin(auth, modem, apn, user, pass, domain);

    // Revisa el valor del botón cada segundo
    scheduler.setInterval(1000UL, updateButton);
}

void loop()
{
    Blynk.run();
    scheduler.run();
}

// ****************** FUNCIONES DE BLYNK **********************

BLYNK_CONNECTED()
{
    Serial.println("Conectado");
    // Obtener últimos valores del servidor
    Blynk.syncVirtual(V0);
}

BLYNK_DISCONNECTED()
{
    Serial.println("Desconectado");
}

BLYNK_WRITE(V0)
{
    int led = param.asInt();

    if ( led ){
        digitalWrite( BOARD_LED, HIGH );
    } else {
        digitalWrite( BOARD_LED, LOW );
    }
}

/*
 * Configuración del template en Blynk:
 * V0 - Control del led: 0 = apagado, 1 = encendido
 * V1 - Estado del botón BOOT
 * V2 - Temperatura
 * V3 - Umbral de temperatura
 */

// *************** TEMPLATE DE BLYNK **************************
#define BLYNK_TEMPLATE_ID "TMPxxxxxx"
#define BLYNK_TEMPLATE_NAME "Device"
#define BLYNK_AUTH_TOKEN "YourAuthToken"

#define BLYNK_PRINT Serial

// ******************* MODEM SIM7080 **************************
#define TINY_GSM_MODEM_SIM7080

#include <Arduino.h>
#include <Wire.h>
#include <TinyGsmClient.h>
#include <BlynkSimpleTinyGSM.h>

// ********** CONFIGURACION DE COMUNICACIONES SERIALES ********
#define SerialMon Serial
#define SerialAT Serial2
#define TINY_GSM_DEBUG SerialMon

// ************ CONFIGURACION DE PINOUT MIKROBUS ***************
#define MIKROBUS_AN 4
#define MIKROBUS_RST 15
#define MIKROBUS_CS 6
#define MIKROBUS_SCK 8
#define MIKROBUS_MISO 18
#define MIKROBUS_MOSI 17
#define MIKROBUS_PWM 5
#define MIKROBUS_INT 7
#define MIKROBUS_RX 9
#define MIKROBUS_TX 10
#define MIKROBUS_SCL 13
#define MIKROBUS_SDA 12

#define BOARD_LED 16

#define UPDATE_BUTTON 0
#define PIN_MODEM_PK MIKROBUS_INT

// *************** CONFIGURACION OPERADORA LTE ******************
const char apn[] = "";
const char user[] = "";
const char pass[] = "";

// ************** CONFIGURACION SERVIDOR BLYNK ******************
const char domain[] = "ny3.blynk.cloud";
const char auth[] = BLYNK_AUTH_TOKEN;

// ******************* VARIABLES GLOBALES ***********************
static BlynkTimer scheduler;
static TinyGsm modem(SerialAT);

float readXN04Temperature();

void updateTemperature()
{
    Blynk.virtualWrite(V0, readXN04Temperature());
}

void setup()
{

    // Configuración de comunicaciones seriales
    SerialMon.begin(115200);
    SerialAT.begin(115200, SERIAL_8N1, MIKROBUS_RX, MIKROBUS_TX);
    Wire.setPins(MIKROBUS_SDA, MIKROBUS_SCL);
    Wire.begin();

    // Inicialización de I/O
    pinMode(BOARD_LED, OUTPUT);
    digitalWrite(BOARD_LED, LOW);
    pinMode(PIN_MODEM_PK, OUTPUT);

    // Reinicio del modem LTE por hardware
    digitalWrite(PIN_MODEM_PK, HIGH);
    delay(3000);
    digitalWrite(PIN_MODEM_PK, LOW);

    // Configuración inicial del modem LTE
    SerialMon.println("Iniciando modem LTE...");
    modem.restart();
    String modemInfo = modem.getModemInfo();
    SerialMon.print("Modem: ");
    SerialMon.println(modemInfo);

    // Iniciar comunicación con Blynk.Cloud
    Blynk.begin(auth, modem, apn, user, pass, domain);

    // Una vez inicializada la comunicación con el servidor
    // éste se puede interrumpir y reanudar utilizando las
    // funciones:

    // Interrumpir la conexión con el servidor de Blynk
    // Blynk.disconnect();

    // Reanudar la conexión con el servidor de Blynk
    // Blynk.connect();

    // Inicia los temporizadores
    scheduler.setInterval(30000UL, updateTemperature);
}

void loop()
{
    Blynk.run();
    scheduler.run();
}

// ****************** FUNCIONES DE XNODES **********************

float readXN04Temperature()
{

    float temperature;
    uint16_t temperature_int;
    // XN04
    Wire.beginTransmission(4);
    // Registro de temperature
    Wire.write(0x01);
    Wire.endTransmission();

    Wire.requestFrom(4, 2);

    temperature_int = ((Wire.read() << 8) | Wire.read());
    temperature = temperature_int / 100.0f;

    return temperature;
}

// ****************** FUNCIONES DE BLYNK **********************

BLYNK_CONNECTED()
{
    Serial.println("Conectado");
    // Obtener últimos valores del servidor
    Blynk.syncVirtual(V0, V4);
}

BLYNK_DISCONNECTED()
{
    Serial.println("Desconectado");
}

BLYNK_WRITE(V0)
{
    int led = param.asInt();

    if ( led ){
        digitalWrite( BOARD_LED, HIGH );
    } else {
        digitalWrite( BOARD_LED, LOW );
    }
}

BLYNK_WRITE(V4)
{
    double treshold = param.asDouble();

    if ( readXN04Temperature() < treshold ){
        Serial.println( "Temperatura actual menor al umbral" );
    } else {
        Serial.println( "Temperatura actual mayor al umbral" );
    }
}