Aug 4, 2021

5 min read

IoT — LoRa — Deteção do veiculo baseado em sensor e utilização de MQTT para enviar dados para Thingspeak

A internet das coisas (IoT) consiste em todos objetos podem ser controlados ou monitorizados através da internet pelos utilizadores. Alem disso, IoT expande o uso da internet e desta forma fornece as ligações para os dispositivos físicos com a internet.

A IoT pode ocorrer de diversas formas como:

RFID
Internet
Bluetooth
NFC
E outros tipos de conexão

Essa troca de informações pode ser feita entre:

Pessoas e objetos
Objetos e objetos

Tecnologia LoRa

LoRa (Long Range) é uma tecnologia de rádio frequência com baixo consumo de energia. Baseia-se em técnicas de modulação de espectro de propagação derivadas da tecnologia chirp spread spectrum (CSS). Foi desenvolvido por Cycleo de Grenoble, França e adquirido pela Semtech, o membro fundador da Aliança LoRa.

Protocolo MQTT

O MQTT (Message Queuing Telemetry Transport) é um protocolo de mensagens para sensores e pequenos dispositivos móveis que executa redes TCP/IP. O esquema de troca de mensagens é fundamentado no modelo Publish–Subscribe.

Pré-requisitos

Para este tutorial é necessário:

Dragino LoRa IoT Development kit

Arduino IDE
ThingSpeak
Sensor Infravermelho

Funcionamento

O gateway Dragino LoRa / LoRaWAN suporta encaminhamento MQTT. Ele pode encaminhar os dados do sensor da rede LoRa para o servidor MQTT e vice-versa.

Para Uplink: O sensor envia dados para o LoRa Gateway através de LoRa wireless. O gateway irá processar esses dados e encaminhá-los para o MQTT Broker remoto pela Internet.
Para Downlink: O gateway assina um tópico no broker MQTT, quando houver atualização no tópico, o gateway identifica e transmite os dados para a rede LoRa Local.

Circuito

Implementação

Para configuração do gateway LG01-N, liguei a porta WAN do gateway com a porta LAN do Router para estabelecer a ligação da internet. Seguinte no computador pesquisa WiFi do dragino, normalmente aprece dragino-xxxxx.

Depois de conectar WiFi do dragino, no browser inserir 10.130.1.1

Para entrar colocar Nome de de utilizador e password.

Nome de utilizador: root

Password: dragino

Depois de iniciar sessão, pode ver página home do dragino.

Caso o Firmware não é ultima versão, basta ir https://www.dragino.com/downloads/index.phpdir=LoRa_Gateway/LG01N/Firmware/Test_Firmware/ baixar ultima versão e atualizar.

Na página LoRa inserir as seguintes configurações.

Agora ir ao ThingSpeak criar um canal.

Nome, nome do Fields e quantidade do Fields podem ser aleatórios.

Depois de criar canal, ir ao Devices>MQTT criar um dispositivo.

Nome pode ser aleatório.

Adicionar o canal criada anteriormente.

Baixar Credentials em formato txt, onde contem username/clientId e password.

Voltando para dragino na secção MQTT>MQTT Client inserir seguinte configuração e respetivo ClientID e Password no User ID e Password.

Seguir ir para MQTT>Channels para adionar canal.

Local ID pode colocar valor aleatorio, neste caso introduzi 1234.

Remote ID é o Channel ID do canal no ThingSpeak.

API Key é o Write API Key do canal no ThingSpeak.

Adicionar canal ADD_CHAN

Agora abrir o Arduino IDE

Fazer download das bibliotecas.

Copia e colar seguinte código:

//Biliotecas
#include <SPI.h>
#include <LoRa.h>
//Definir Variaveis para Sensor Inflevermelho
int sensorValue = 0;
int distanceIR = 0;
int sensorPin = A0;
//Variaveis
int estado1;
char estado1_1[8]={“\0”};
char *node_id = “<1234>”; //LocalID definido no dragino MQTT<Channel
uint8_t datasend[36];
unsigned int count = 1;
unsigned long new_time,old_time=0;
void setup() {

Serial.begin(9600);
while (!Serial);

Serial.println(F(“Start MQTT Example of the ThingSpeak”));
if (!LoRa.begin(868300000)) //868000000 is frequency
{
Serial.println(“Starting LoRa failed!”);
while (1);
}
//Spreading Factor (6 ~ 12)
LoRa.setSpreadingFactor(7);

// Setup BandWidth, option: 7800,10400,15600,20800,31250,41700,62500,125000,250000,500000
//Lower BandWidth for longer distance.
LoRa.setSignalBandwidth(125000);

// Setup Coding Rate:5(4/5),6(4/6),7(4/7),8(4/8)
LoRa.setCodingRate4(5);
LoRa.setSyncWord(0x34);
Serial.println(“LoRa init succeeded.”);
//Serial.println(frequency);
pinMode(sensorPin, INPUT); //Entrada do IR Sensor

LoRa.onReceive(onReceive);
LoRa.receive();
}
void sPark(){
// Calcular distancia IR Sensor
sensorValue = analogRead(sensorPin);
distanceIR = (6762/(sensorValue-9))-4;
if (distanceIR <= 20){
estado1 = 1;
}else{
estado1 = 0;
}
Serial.print(“Distancia Lugar 1: “);
Serial.print(distanceIR);
Serial.print(“ cm”);
Serial.print(“ estado: “);
Serial.println(estado1);
}
void sParkWrite(){
char data[50] = “\0”;
for(int i = 0; i < 50; i++)
{
data[i] = node_id[i];
}
dtostrf(estado1,0,1,estado1_1);
// Serial.println(estado1_1);
strcat(data,”field1=”);//Nome da janela no ThingSpeak
strcat(data,estado1_1);
strcpy((char *)datasend,data);
}
void SendData()
{
LoRa.beginPacket();
LoRa.print((char *)datasend);
LoRa.endPacket();
Serial.println(“Packet Sent”);
}
void loop() {

new_time=millis();
if (new_time — old_time >= 6000 || old_time == 0)
{
old_time = new_time;
Serial.print(“########### “);
Serial.print(“COUNT=”);
Serial.print(count);
Serial.println(“ ###########”);
count++;
sPark();
sParkWrite();
SendData();
LoRa.receive();
}
}
void onReceive(int packetSize) {

// received a packet
Serial.print(“Received packet : “);
// read packet
for (int i = 0; i < packetSize; i++) {
Serial.print((char)LoRa.read());
}
Serial.print(“\n\r”);
}