U-BLOX NINA B302 + GSM ACESSANDO THINGSTREAM.IO
O objetivo deste BLOG é mostrar um exemplo em ARDUINO que permite o NINA B302 se comunicar com um servidor MQTT da U-BLOX (mqtt.thingstream.io) via GSM, baseado no modem LISA U200. Será utilizada a porta 1883 (non SSL).
Utilize a programação clássica com Sockets do Arduino! Não se preocupe com os comandos AT :)
Utilize a programação clássica com Sockets do Arduino! Não se preocupe com os comandos AT :)
MQTT
Para os dispositivos de Internet das Coisas (IoT), a conexão com a Internet é um requisito. A conexão com a Internet permite que os dispositivos trabalhem entre si e com serviços de backend. O protocolo de rede subjacente da Internet é o TCP/IP. Desenvolvido com base na pilha TCP/IP, o MQTT (Message Queue Telemetry Transport) tornou-se o padrão para comunicações de IoT.
Implementa também SSL e SN-MQTT
+
LISA-U2
Com W-CDMA de 6 bandas (UMTS) e GPRS / EDGE de banda quádrupla, os módulos LISA-U2 são adequados para redes em todo o mundo.
Os recursos incluem taxas de dados de até 21,1 Mbit / s (downlink),um rico conjunto de protocolos da Internet, área muito pequena, área muito baixa consumo de energia e temperatura operacional estendida alcance. Os módulos LISA-U2 fornecem acesso totalmente integrado a produtos de posicionamento u-blox. A diversidade de antenas permite a Módulos LISA-U2 para fornecer as maiores velocidades de dados. Os módulos LISA-U2 são ideais para aplicações industriais / de consumidor que requerem transmissão de dados em alta velocidade e aplicações máquina a máquina. Eles são a escolha perfeita para terminais de internet móvel, tablets, infotainment para automóvel, sistemas de navegação conectados, segurança e vigilância sistemas, eCall, gerenciamento de frota, sistemas de medição, anti-roubo e outras aplicações automotivas. O pacote compacto SMT permite fácil fabricação emigração do u-blox SARA, LEON e outros módulos LISA é simples. Isso permite que os clientes tirem o máximo proveito de seus investimentos em hardware e software e fornece tempo de comercialização muito curto. Está disponível um amplo conjunto de certificados reguladores e de operadores nacionais.
Os módulos LISA-U2 são fabricados em locais certificados pela ISO / TS 16949. Cada módulo é testado e inspecionado durante a produção. Os módulos são qualificados de acordo com a ISO 16750 -Condições ambientais e testes elétricos de eletricidade e equipamentos eletrônicos para veículos rodoviários.
Adquirimos então os seguintes componentes
-Botão de RESET;
-Botão de Modo BOOTLOADER (W102);
-Plugável no PROTOBOARD;
-Acesso às várias GPIOS;
Pequena
Instalando Arduino Adafruit no NINA B302
Abaixo o roteiro para você seguir:
Baixe e instale o Arduino IDE
Inicie o Arduino IDE, vá em Preferências e adicione
https://www.adafruit.com/package_adafruit_index.json
Baixe e instale o Arduino IDE
Inicie o Arduino IDE, vá em Preferências e adicione
https://www.adafruit.com/package_adafruit_index.json
como "URL adicional do gerenciador de pastas"
Abra o Boards Manager no menu Tools -> Board e instale o "Adafruit nRF52 by Adafruit"
Selecione sua placa nRF5 no menu Ferramentas -> Placa
Adafruit Bluefruit nRF52 Feather
Abra o Boards Manager no menu Tools -> Board e instale o "Adafruit nRF52 by Adafruit"
Selecione sua placa nRF5 no menu Ferramentas -> Placa
Adafruit Bluefruit nRF52 Feather
OBSERVAÇÃO: Durante a instalação, o Arduino IDE leva alguns minutos para extrair as ferramentas após o download, por favor, seja paciente
Use o gravador SEGGER JLINK para gravar o BREAKOUT com módulo NINA B302, conecte nos pinos do SWCLK (pino 7) e SWDIO (pino 9) do SEGGER JLINK nos pinos SWDCLK e SWDIO do BREAKOUT (pinos nas laterais, próximo à antena). Não esquecer de ligar os GND do BREAKOUT no GND do SEGGER JTAG, bem como alimentar o BREAKOUT com 3.3V.
Ligue os pinos SWD DIO e CLK ...
...nestes pinos da placa BREAKOUT
Você pode também usar o ST-LINK V2
Abra J-FLASH lite e grave o bootloader da Adafruit
O mesmo se encontra em
....\packages\adafruit\hardware\nrf52\0.19.0\bootloader\feather_nrf52840_express
Compile depois para o NINA B302
https://github.com/adafruit/Adafruit_nRF52_Bootloader
Com ele, você poderá transferir programas via DFU USB. Maiores detalhes sobre este bootloader
https://learn.adafruit.com/introducing-the-adafruit-nrf52840-feather/update-bootloader
Segundo a documentação, se você pressionar o reset, o módulo aguardará por um certo tempo se há algo sendo enviado pelo Arduino, ou seja, o programa a ser gravado via DFU.
ATENÇÃO, o bootloader usa USB para gravação do NINA 302, OU SEJA, CRIA UMA COMM VIRTUAL, TAMBÉM PARA SER A SERIAL PADRÃO DO ARDUINO
INSTALE OS DRIVERS
https://github.com/adafruit/Adafruit_Windows_Drivers
Conecte na USB + e USB - um cabo USB, AGUARDE INSTALAR OS DRIVERS
https://www.u-blox.com/sites/default/files/NINA-B3_DataSheet_%28UBX-17052099%29.pdf
Ligue os pino do NINA B302 no NINA W102 (com WIFININA GRAVADO)
INSTALE LIB
Observe os pré-requisitos
Thanks to Khoi Hoang to help to port GSM to NINA B302
Thanks to Khoi Hoang to help to port GSM to NINA B302
Abra o exemplo
MQTT_THINGSTREAM
Altere
// GOT FROM ThingsStream!
const char *MQTT_SERVER = "mqtt.thingstream.io";
const char *MQTT_USER = "ZZZZZZZZZZZZZZZZZZZZ";
const char *MQTT_PASS = "ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ";
const char *MQTT_CLIENT_ID = "device:ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ";
Com os dados obtidos do THINGSTREAM
Código final
/****************************************************************************************************************************
GSM_MQTT_ThingStream.ino - Dead simple MQTT Client for GSM/GPRS shields
For ESP8266, ESP32, SAMD21/SAMD51, nRF52, SAM DUE, Teensy and STM32 with GSM modules
GSM_Generic is a library for the ESP8266, ESP32, SAMD21/SAMD51, nRF52, SAM DUE, Teensy and STM32 with GSM modules
Based on and modified from MKRGSM Library (https://github.com/arduino-libraries/MKRGSM)
Built by Khoi Hoang https://github.com/khoih-prog/GSM_Generic
Licensed under GNU Lesser General Public License
Copyright (C) 2017 Arduino AG (http://www.arduino.cc/)
This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License
as published by the Free Software Foundation, either version 2.1 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program.
If not, see <https://www.gnu.org/licenses/>.
Version: 1.2.1
Version Modified By Date Comments
------- ----------- ---------- -----------
1.0.0 K Hoang 04/03/2021 Initial coding to add support to many boards besides MKRGSM 1400
1.1.0 K Hoang 06/03/2021 Rewrite to prepare for supporting more GSM/GPRS modules
1.2.0 K Hoang 08/03/2021 More modifications to prepare for supporting more GSM/GPRS modules
1.2.1 K Hoang 08/03/2021 Fix bug
*****************************************************************************************************************************/
/*
Basic MQTT example (without SSL!)
This sketch demonstrates the basic capabilities of the library.
It connects to an MQTT server then:
- publishes {Hello from MQTTClient_SSL on NUCLEO_F767ZI} to the topic [STM32_Pub]
- subscribes to the topic [STM32_Sub], printing out any messages
it receives. NB - it assumes the received payloads are strings not binary
It will reconnect to the server if the connection is lost using a blocking
reconnect function. See the 'mqtt_reconnect_nonblocking' example for how to
achieve the same result without blocking the main loop.
You will need to populate "certificates.h" with your trust anchors
(see https://github.com/OPEnSLab-OSU/SSLClient/blob/master/TrustAnchors.md)
and my_cert/my_key with your certificate/private key pair
(see https://github.com/OPEnSLab-OSU/SSLClient#mtls).
*/
#include "defines.h"
//////////////////////////////////////////////////////
// Please enter your sensitive data in the Secret tab or arduino_secrets.h
// PIN Number
const char PINNUMBER[] = SECRET_PINNUMBER;
// APN data
const char GPRS_APN[] = SECRET_GPRS_APN;
const char GPRS_LOGIN[] = SECRET_GPRS_LOGIN;
const char GPRS_PASSWORD[] = SECRET_GPRS_PASSWORD;
//////////////////////////////////////////////////////
#include <PubSubClient.h>
const char my_cert[] = "FIXME";
const char my_key[] = "FIXME";
#define USING_THINGSTREAM_IO true
#if USING_THINGSTREAM_IO
const char *MQTT_PREFIX_TOPIC = "nina-b302-sniffer/";
const char *MQTT_ANNOUNCE_TOPIC = "/status";
const char *MQTT_CONTROL_TOPIC = "/control";
const char *MQTT_BLE_TOPIC = "/ble";
// GOT FROM ThingsStream!
const char *MQTT_SERVER = "mqtt.thingstream.io";
const char *MQTT_USER = "xxxxxxxxxxxxxxxxxxx";
const char *MQTT_PASS = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
const char *MQTT_CLIENT_ID = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
String topic = MQTT_PREFIX_TOPIC + String("12345678") + MQTT_BLE_TOPIC;
String subTopic = MQTT_PREFIX_TOPIC + String("12345678") + MQTT_BLE_TOPIC;
#else
const char* MQTT_SERVER = "mqtt.thingstream.io"; // Broker address
const char* ID = "MQTTClient_SSL-Client"; // Name of our device, must be unique
String topic = "STM32_Pub"; // Topic to subcribe to
String subTopic = "STM32_Sub"; // Topic to subcribe to
#endif
void mqtt_receive_callback(char* topic, byte* payload, unsigned int length);
const int MQTT_PORT = 1883; //if you use SSL //1883 no SSL
unsigned long lastMsg = 0;
// Initialize the SSL client library
// Arguments: EthernetClient, our trust anchors
//////////////////////////////////////////////////////
// initialize the library instance
GSMClient gsmClient;
GPRS gprs;
GSM gsmAccess;
// connection state
bool connected = false;
// BaudRate to communicate to GSM/GPRS modem. If be limit to max 115200 inside modem
unsigned long baudRateSerialGSM = 19200;
//////////////////////////////////////////////////////
PubSubClient client(MQTT_SERVER, MQTT_PORT, mqtt_receive_callback, gsmClient);
/*
Called whenever a payload is received from a subscribed MQTT topic
*/
void mqtt_receive_callback(char* topic, byte* payload, unsigned int length)
{
Serial.print("MQTT Message receive [");
Serial.print(topic);
Serial.print("] ");
for (unsigned int i = 0; i < length; i++)
{
Serial.print((char)payload[i]);
}
Serial.println();
}
void reconnect()
{
// Loop until we're reconnected
while (!client.connected())
{
Serial.print("Attempting MQTT connection to ");
Serial.println(MQTT_SERVER);
// Attempt to connect
#if USING_THINGSTREAM_IO
int connect_status = client.connect(MQTT_CLIENT_ID, MQTT_USER, MQTT_PASS, topic.c_str(), 2, false, "");
#else
int connect_status = client.connect(ID);
#endif
if (connect_status)
{
Serial.println("...connected");
// Once connected, publish an announcement...
String data = "Hello from MQTTClient_SSL on " + String(BOARD_NAME);
client.publish(topic.c_str(), data.c_str());
Serial.println("Published connection message successfully!");
Serial.print("Subcribed to: ");
Serial.println(subTopic);
// This is a workaround to address https://github.com/OPEnSLab-OSU/SSLClient/issues/9
//ethClientSSL.flush();
// ... and resubscribe
client.subscribe(subTopic.c_str());
// for loopback testing
client.subscribe(topic.c_str());
// This is a workaround to address https://github.com/OPEnSLab-OSU/SSLClient/issues/9
//ethClientSSL.flush();
}
else
{
Serial.print("failed, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
// Wait 5 seconds before retrying
delay(5000);
}
}
}
void connectToGPRS()
{
#define NUMBER_OF_CONNECTION_TRIES 10
uint8_t tryNumber = 1;
// After starting the modem with GSM.begin()
// attach the shield to the GPRS network with the APN, login and password
while ((gsmAccess.begin(baudRateSerialGSM, PINNUMBER) != GSM_READY) ||
(gprs.attachGPRS(GPRS_APN, GPRS_LOGIN, GPRS_PASSWORD) != GPRS_READY))
{
// failed, retry
Serial.print("Connect GPRS failed, try = "); Serial.println(tryNumber);
if (++tryNumber > NUMBER_OF_CONNECTION_TRIES)
{
Serial.println("\nCan't connected to GPRS.");
connected = false;
return;
}
delay(1000);
}
connected = true;
//Get IP.
IPAddress LocalIP = gprs.getIPAddress();
Serial.print("\nConnected to GPRS. IP address = ");
Serial.println(LocalIP);
}
void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(115200);
while (!Serial);
delay(200);
Serial.print(F("\nStart GSM_MQTT_ThingStream on ")); Serial.println(BOARD_NAME);
Serial.println(GSM_GENERIC_VERSION);
connectToGPRS();
}
#define MQTT_PUBLISH_INTERVAL_MS 5000L
String data = "Hello from GSM_MQTT_ThingStream on " + String(BOARD_NAME);
const char *pubData = data.c_str();
void loop()
{
static unsigned long now;
if (gsmAccess.status() != GSM_READY || gprs.status() != GPRS_READY)
{
connectToGPRS();
}
if (connected)
{
if (!client.connected())
{
reconnect();
}
// Sending Data
now = millis();
if (now - lastMsg > MQTT_PUBLISH_INTERVAL_MS)
{
lastMsg = now;
if (!client.publish(topic.c_str(), pubData))
{
Serial.println("Message failed to send.");
}
Serial.print("MQTT Message Send : " + topic + " => ");
Serial.println(data);
}
client.loop();
}
}
Compile o programa e pressione o botão para gravar.
Como podem observar, o programa será transferido!
Abra a serial e veja ser publicado dados em um Tópico
Servidor MQTT THINGSTREAM recebendo dados do Tópico do NINA B302 via GSM
Comandos AT (em Background)
https://www.u-blox.com/en/docs/UBX-17056481
https://www.u-blox.com/sites/default/files/NINA-B3_DataSheet_%28UBX-17052099%29.pdf
https://developer.ibm.com/br/articles/iot-mqtt-why-good-for-iot/
https://www.u-blox.com/sites/default/files/NINA-B3_DataSheet_%28UBX-17052099%29.pdf
https://developer.ibm.com/br/articles/iot-mqtt-why-good-for-iot/
Sobre a SMARTCORE
A SmartCore fornece módulos para comunicação wireless, biometria, conectividade, rastreamento e automação.
Nosso portfólio inclui modem 2G/3G/4G/NB-IoT/Cat.M, satelital, módulos WiFi, Bluetooth, GNSS / GPS, Sigfox, LoRa, leitor de cartão, leitor QR code, mecanismo de impressão, mini-board PC, antena, pigtail, LCD, bateria, repetidor GPS e sensores.
Mais detalhes em www.smartcore.com.br
Nenhum comentário:
Postar um comentário