Creando tu Stack de LoRa

Curso de IoT: Protocolos de Comunicación

Conceptos Básicos

Qué aprenderás sobre Internet of Things

Espectro electromagnético y qué es radiofrecuencia

Clasificacion de radiofrecuencia

Regulación de la radiofrecuencia

¿Qué son las Telecomunicaciones?

Halfduplex y Fullduplex

Clasificación de transmisiones: Upstream y Downstream

Link budget

Con ciertas características, ¿Habría conexión en el sistema?

Alto data rate

Wi-fi

Bluetooth

Redes celulares

LPWANs

NB-IoT

Consideraciones para implementación de NB-IoT

LoRaWAN

Reto 2

¿Qué usarías para monitorear la posición GPS de un vehículo? y ¿Qué usarías para monitorear datos en campo?

Diseño

Arquitectura de nodos

Introducción a la práctica

Instalación de framework ESP32 e instalación de framework SAMD21

Qué es una interrupción

Práctica de WiFi

Prueba de señal Wi-fi

Protocolo HTTP desde un microcontrolador

Conectando sensores y actuadores al microcontrolador

Preparación de aplicación para recibir datos

Programación por eventos de un microcontrolador

Configuración de eventos del microcontrolador

Conexión de aplicación

Práctica con LoRa

¿Cuál es el stack de LoRaWAN?

Creando tu propio gateway

Ensamblado de gateway

Pon a andar tu gateway de LoRa

Creando tu Stack de LoRa

Conecta tu nodo a internet

Integrando datos a un dashboard

Terminando de implementar nuestro stack de LoRa

BugFixing nuestro stack de LoRa

Ensamblando el nodo de LoRa

Probando LoRa en nuestro Dashboard

Prácticas con tarjetas MKR

Cierre del curso

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Si ya tienes una cuenta,

Recursos

¿Cómo instalar y configurar la librería LMiC en Arduino?

Para comenzar a trabajar con el protocolo LoRa, es fundamental preparar un entorno adecuado. La instalación de la librería LMiC es un primer paso crucial. Este componente, desarrollado por IBM, facilita la integración de LoRa para múltiples plataformas de microcontroladores.

¿Cómo descargar y descomprimir la librería LMiC?

Para descargar la librería:

Navega al repositorio indicado por el sistema de discusiones del curso.
Descarga el archivo comprimido de la librería.
Descomprime el archivo y colócalo en una ubicación accesible, como el escritorio.

Posteriormente, debes mover la carpeta descomprimida a la carpeta de librerías de Arduino:

# Asumiendo que estás en el sistema operativo Windows
# Si estás usando otro, cambia la ruta según sea necesario
C:\Users\[TuUsuario]\Documents\Arduino\libraries

Una vez que la librería está en su lugar, reinicia el IDE de Arduino para comenzar a trabajar con ella.

¿Cómo incluir las librerías necesarias en el código?

Para comenzar a escribir tu código, primero necesitas incluir varias librerías en tu archivo. Aquí tienes un ejemplo de cómo hacerlo:

#include <lmic.h>    // Librería para manejar LoRa
#include <hal/hal.h> // Abstracción de hardware
#include <SPV.h>     // Librería para manejar SPV
#include <DHT.h>     // Librería para sensor de temperatura y humedad DHT22

Estas librerías son fundamentales para gestionar tanto el hardware como las funciones de comunicación y los sensores que deseas utilizar.

¿Cómo definir pines y estructuras esenciales?

Definir correctamente los pines y estructuras es fundamental para la funcionalidad de tu montaje. Aquí te mostramos cómo puedes hacer estas definiciones:

¿Cómo inicializar los pines y el sensor DHT22?

Primero define los pines que utilizarás para tus acciones:

#define DHTPIN 23   // Pin de datos del sensor DHT22
#define DHTTYPE DHT22 // Tipo de sensor DHT

DHT dht(DHTPIN, DHTTYPE); // Instanciar el objeto DHT

¿Cómo establecer el mapeo de pines para LoRa?

LoRa requiere un mapeo específico de pines. Para configurarlo, utiliza la estructura osjob_t de esta manera:

static const lmic_pinmap lmic_pins = {
    .nss = 18, // Pin de selección de esclavo 
    .rxtx = LMIC_UNUSED_PIN,
    .rst = 14,  // Pin de reset
    .dio = {26, 33, 32} // Pines DIO
};

¿Cómo estructurar el evento en la función principal?

Las funciones de la librería LMiC operan en base a eventos. Para gestionar estos eventos:

¿Cómo construir la función de eventos?

Crea una función que pueda manejar varios casos de eventos. Utiliza un switch que pueda distinguir entre diferentes eventos, como EV_TXCOMPLETE:

void onEvent(ev_t ev) {
    Serial.print(os_getTime());
    Serial.print(": ");
    switch(ev) {
        case EV_TXCOMPLETE:
            Serial.println(F("Transmitido!"));
            break;
        default:
            Serial.println(F("Evento desconocido"));
            break;
    }
}

¿Por qué son importantes las funciones modulares?

La modularidad del código hace que sea más fácil añadir nuevas funcionalidades o cambiar partes del código sin afectar el resto. Aquí creas funciones separadas para leer datos de sensores y enviar la información por LoRa.

¿Cómo se crean las funciones para lectura y transmisión de datos?

Para mejorar la organización, crea dos funciones: una para leer datos del sensor y otra para la transmisión de estos datos:

// Función para leer datos del sensor DHT22
void readSensors() {
    float temp = dht.readTemperature();
    // Otros cálculos de sensor
}

// Función para enviar datos
void sendData(int data, int length) {
    // Código para enviar datos usando LMiC
}

¿Cuáles son los próximos pasos en el desarrollo de tu proyecto LoRa?

Con las bases asentadas, el siguiente paso incluye:

Modularizar aún más el programa.
Realizar pruebas de transmisión con los sensores.
Configurar una cuenta en The Things Network (TTN) y enlazarla con un dashboard gratuito como DashBoard.

Cada paso te acerca más a tener un sistema sólido de comunicación basada en LoRa, ampliando tus habilidades en el Internet de las Cosas. ¡Continúa aprendiendo y explorando nuevas funciones y capacidades!

Aportes 7

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Victor Manuel Sanchez Puga

hace 4 años

#include <lmic.h>
#include <hal/hal.h>
#inlcude < SPI.h >
#include < DHT.h >

#define DHTPIN 23
#define DHTYPE DHT22

DHT dht( DHTPIN, DHTYPE );

void os_getArtEui ( u1_t* buf ) { }
void os_getDevEui ( u1_t* buf ) { }
void os_getDevKey ( u1_t* buf ) { }

const lmic_pinmap lmic_pins = {
.nss = 18,
.rxtx = LMIC_UNUSED_PIN,
.rst = 14,
.dio = { 26 , 33 , 32 }
}

void onEvent ( ev_t ev ) {
switch ( ev ) {
case EV_TXCOMPLETE:

     break;
     default:
     Serial.println ( "Evento desconocido" );
     break;

}

void setup ( ) {
// put your setup main code here, to run repeatedly:
}

void loop ( ) {
// put your main code here, to run repeatedly:
}

void enviar_datos ( uint8_t *mydata, unint16_t len) {
LMIC_setTxData2 ( 1,mydata,len,0);
}

void getInfoAndSend ( ) {
float temp = dht.readTemperature ( );

}

Camilo Andres lizarazo

hace 6 años

este es el repositorio. ! https://github.com/things-nyc/arduino-lmic

Julián Peláez Restrepo

hace 4 años

Quien no tenga un TTGo sino un devkit32 y un modulo de radio rf95 o hpd13a puede usar el siguiente codigo, debe mapear los pines MISO, MOSI, SCK, y todas las tierras del radio deben estar aterrizadas

#include <CayenneLPP.h>
#include<lmic.h>
#include<hal/hal.h>
#include <SPI.h>
#include<DHT.h>


#define DHTPIN 22
#define DHTYPE DHT11
#define LED_BUILTIN 2

DHT dht(DHTPIN,DHTYPE);
CayenneLPP lpp(51);

uint32_t DEV_ADDR = 0x26021285;
uint8_t NET_SESS_KEY[16] = { 0xFE, 0x99, 0x29, 0x91, 0xD2, 0x60, 0x99, 0x63, 0xCA, 0xC0, 0x67, 0xAB, 0xA7, 0xFF, 0xBD, 0x52 };
uint8_t APP_SESS_KEY[16] = { 0xD9, 0x8C, 0xC1, 0xA2, 0x8D, 0x43, 0xBD, 0x07, 0x61, 0xAE, 0xCF, 0x8D, 0x76, 0xB4, 0x48, 0x5C };

void os_getArtEui(u1_t* buf){}
void os_getDevEui(u1_t* buf){}
void os_getDevKey(u1_t* buf){}

const unsigned TX_INTERVAL = 10;
unsigned long previousMillis = 0;

const lmic_pinmap lmic_pins = {
  .nss =5,
  .rxtx = LMIC_UNUSED_PIN,
  .rst =14,
  .dio = {26,33,32}
};

void onEvent(ev_t ev)
{
  switch(ev)
  {
    case EV_TXCOMPLETE:
      Serial.println("[LMIC] Radio Tx Complete");
      digitalWrite(LED_BUILTIN, LOW);
      break;
    default:
      Serial.println("Evento Desconocido");
      break;
  }
}

void enviar_datos(uint8_t *mydata, uint16_t len)
{
  if(LMIC.opmode & OP_TXRXPEND)
  {
    Serial.println("[LMIC] OP_TXRXPEND, not sending");
  }
  else
  {
      LMIC_setTxData2(1,mydata,len,0);
  }
  
}

void getInfoAndSend()
{
  digitalWrite(LED_BUILTIN, HIGH);
  // Leer sensores y transmitir
  float temp = dht.readTemperature();
  lpp.addTemperature(1,temp);
  enviar_datos(lpp.getBuffer(),lpp.getSize() ); 
}

void setup() 
{
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);
  Serial.print("Led ON");
  Serial.println();
  delay(1000);
  digitalWrite(LED_BUILTIN, LOW);
  Serial.print("Led OFF");
  Serial.println();
  Serial.println("[INFO] Iniciando");
  dht.begin();
  os_init();
  LMIC_reset();
  LMIC_setSession(0x1,DEV_ADDR, NET_SESS_KEY, APP_SESS_KEY);
  // put your setup code here, to run once:
  for(int chan=0; chan<72;++chan)
  {
    LMIC_disableChannel(chan);
  }
  // Escojemos 904.3 Mhz, 915 Mhz en la banda de 902 - 928 Mhz
  LMIC_enableChannel(10);
  LMIC_setLinkCheckMode(0);
  
  LMIC_setDrTxpow(DR_SF7,20);
  previousMillis = millis();
}

void loop() 
{
  // put your main code here, to run repeatedly:
  if( millis() > previousMillis + (TX_INTERVAL*1000) )
  {
    getInfoAndSend();
    previousMillis=millis();
  }
  os_runloop_once();
}```

Mario Alejandro Sepúlveda Rojas

hace 3 años

#include <lmic.h>
#include <hal/hal.h>
#inlcude < SPI.h >
#include < DHT.h >

#define DHTPIN 23
#define DHTYPE DHT22

DHT dht( DHTPIN, DHTYPE );

void os_getArtEui ( u1_t* buf ) { }
void os_getDevEui ( u1_t* buf ) { }
void os_getDevKey ( u1_t* buf ) { }

const lmic_pinmap lmic_pins = {
.nss = 18,
.rxtx = LMIC_UNUSED_PIN,
.rst = 14,
.dio = { 26 , 33 , 32 }
}

void onEvent ( ev_t ev ) {
switch ( ev ) {
case EV_TXCOMPLETE:

     break;
     default:
     Serial.println ( "Evento desconocido" );
     break;
}

void setup ( ) {
// put your setup main code here, to run repeatedly:
}

void loop ( ) {
// put your main code here, to run repeatedly:
}

void enviar_datos ( uint8_t *mydata, unint16_t len) {
LMIC_setTxData2 ( 1,mydata,len,0);
}

void getInfoAndSend ( ) {
float temp = dht.readTemperature ( );

}

Brayam Ruiz

hace 6 años

Cuantos son el numero Maximo de dispositivos soportados en simultaneo? gracias

Tomás González Domínguez

hace 5 años

Lo recomendable es instalar los diferentes softwares en la carpeta /opt

Joan Francisco Alvarado Molina

hace 4 años

Buenas tardes, tengo problemas al visualizr este video