U-BLOX NINA B302 + GSM ACESSANDO THINGSTREAM.IO (SSL)
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 u-BLOX SARA G350 (02S-01). Será utilizada a porta 8883 (SSL).
Utilize a programação clássica com Sockets do Arduino! Não se preocupe com os comandos AT :)
SSL
O Secure Sockets Layer (SSL, Camada de Soquetes Seguros) é um protocolo de segurança que proporciona privacidade, autenticação e integridade às comunicações na Internet. Eventualmente, o SSL acabou evoluindo para o Transport Layer Security (TLS, Segurança da Camada de Transporte).
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
+
SARA G350
A série SARA-G3 de módulos GSM / GPRS apresenta consumo de energia extremamente baixo e um fator de forma LGA em miniatura. Os módulos SARA-G3 são intercambiáveis e foram projetados tendo em mente as diversas necessidades dos clientes M2M. Diferentes funcionalidades e conjuntos de recursos estão disponíveis para atender aos diferentes requisitos do cliente e da aplicação. SARA-G340 / G350 são módulos GSM / GPRS completos com um conjunto abrangente de recursos, incluindo um amplo conjunto de protocolos de internet (TCP, UDP, HTTP, FTP e SMTP). Elas têm acesso totalmente integrado a chips de posicionamento GNSS u-blox e módulos, junto com a funcionalidade A-GNSS (AssistNow On line e AssistNow Off-line) incorporada. SARA-G350 é o versão quad-band para conectividade global e SARA-G340 (900/1800 MHz) é a versão de banda dupla para otimização de custos uso na Europa e na Ásia. Seu rico conjunto de recursos permite que os clientes desenvolvam facilmente uma ampla gama de dispositivos M2M com desenvolvimento mínimo de software no processador host. SARA-G340 ATEX e SARA-G350 ATEX são ATEX / IECEx variantes certificadas que complementam ainda mais a série de produtos oferecendo a solução ideal para o desenvolvimento de dispositivos inteligentes implantados em ambientes potencialmente explosivos. Módulos celulares u-blox são certificados e aprovados pelo principal órgãos reguladores e operadoras. Software RIL para Android está disponível gratuitamente. Os módulos SARA-G3 são fabricados em locais com certificação 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 para equipamentos elétricos e eletrônicos para rodovias veículos.
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
MQTTS_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
- Habilite o modem da U-BLOX em defines.h
- Defina sua APN e User/Pass em defines.h
- Coloque as credenciais da Operadora de Celular em defines.h
Conexões
Conexões
Conecte o TXD do NINA no RXD do MODEM U-BLOX
Conecte o RXD do NINA no TXD do MODEM U-BLOX
Conecte o TXD do NINA no RXD do MODEM U-BLOX
Conecte o RXD do NINA no TXD do MODEM U-BLOX
Atualização de CREDENCIAIS
Mudar para
if gsmClient.connect(MQTT_SERVER, MQTT_PORT, false); para obter as credenciais (SSL) já disponíveis em um . H no GSM_Generic LIB e, em seguida, ser escrito para o SARA 350 Flash
Então volte para
if gsmClient.connect(MQTT_SERVER, MQTT_PORT); para recuperar credenciais previamente salvas (SSL).
Primeira vez para executar (para novo modem, sem o Root Certs em flash), use para carregar os Certificados da biblioteca para o flash de modem. Só precisamos disso uma vez porque é demorado.
gsmClient.connect (server, port);
Depois do primeiro carregamento, cada vez mais tarde, só usar
gsmClient.connect (server, port, false);
Isso não carregará mais os Certificador, apenas continue usando os Certs do Flash para economizar tempo.
Compile o programa e pressione o botão para gravar com a primeira opção!
Como podem observar, o programa será transferido!
Com a primeira opção, Certificados serão gravados na FLASH do u-BLOX SARA G350
Com a segunda opção, Certificados serão lidos da FLASH então abrirá a conexão ao servidor CloudFlame (veja o OK do u-BLOX SARA G350)
Código final
/****************************************************************************************************************************
GSM_MQTTS_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.4
Version Modified By Date Comments
------- ----------- ---------- -----------
1.2.4 K Hoang 11/03/2021 Initial public release to add support to many boards / modules besides MKRGSM 1400 / SARA U201
*****************************************************************************************************************************/
/*
Basic MQTT example (with 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 = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
const char *MQTT_PASS = "xxxxxxxxxxxxxxxxxxxxx";
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 = "broker.emqx.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 = 8883; //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
GSMSSLClient 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 = 115200;
//////////////////////////////////////////////////////
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);
// ... and resubscribe
client.subscribe(subTopic.c_str());
// for loopback testing
client.subscribe(topic.c_str());
}
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;
///////////////// Add this line ////////////////////////////
gsmClient.connect(MQTT_SERVER, MQTT_PORT, false);
//////////////////////////////
//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_MQTTS_ThingStream on ")); Serial.println(BOARD_NAME);
Serial.println(GSM_GENERIC_VERSION);
#if ( defined(DEBUG_GSM_GENERIC_PORT) && (_GSM_GENERIC_LOGLEVEL_ > 4) )
MODEM.debug(DEBUG_GSM_GENERIC_PORT);
#endif
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