terça-feira, 6 de dezembro de 2022

LOM204A - COLETANDO ÚLTIMOS 32 ESTADOS DE UMA CHAVE E ENVIANDO VIA LoRaWAN - CUSTOM CODE

    

LOM204A - COLETANDO ÚLTIMOS 32 ESTADOS DE UMA CHAVE E ENVIANDO VIA LoRaWAN, para CHIRPSTACK

O objetivo geral deste BLOG é demonstrar como é possível programar o módulo WISOL LOM204A02 via VISUINO e assim utilizá-lo como OPENCPU.

O objetivo específico neste projeto é programar o LOM204A02 com VISUINO, para permitir coletar os últimos N estados (até 4 bytes) de um GPIO e então enviar para um servidor LoRaWAN. 

JSON {"S":X,"C":Y}, onde S contém os últimos estados de leituras da GPIO e Y o número de estados já lidos.

É possível também receber uma mensagem de DownLink para acionar um outra GPIO (Relay), sendo este estado gravado na EEPROM (Flash) e recuperada no próximo Reset do LOM204A.

É possível pela UART, o usuário mandar a SUB-BAND que está sendo utilizado pelo projeto, a mesma é gravada também na EEPROM (Flash) e recuperada no próximo Reset do LOM204A.

Foi utilizado o recurso do VISUINO: Custom Code, o qual permite a inclusão de código Arduino, baseado nos exemplos Arduino da Library LMIC.

O estado do GPIO é obtido a cada 1 minuto.




Testado no STARTER KIT LOM204 e também no Breakout LOM204




TTN
The Thing Network

A Rede de Coisas (TTN) é uma iniciativa iniciada pela sociedade civil holandesa. O objetivo é ter redes LoRaWAN instaladas em todas as cidades do mundo. Ao interconectar essas redes locais, a TTN quer construir uma infra-estrutura mundial para facilitar uma Internet das Coisas (IoT) pública.

A The Things Network (TTN) é o servidor IoT na nuvem utilizado nesse projeto. É um dos servidores gratuitos para LoRaWAN mais utilizados, com mais de 90 mil desenvolvedores, mais de 9 mil gateways de usuários conectados à rede ao redor do mundo e mais de 50 mil aplicações em funcionamento.

A TTN comercializa nós e gateways LoRa e provê treinamento individual e coletivo para empresas e desenvolvedores que desejam utilizar o LoRa. Possui uma comunidade bem ativa nos fóruns, sempre colaborando e ajudando a resolver problemas, além de prover diversos meios de integrar a TTN com a aplicação que se deseja usar. Possui integração nativa com diversas aplicações como: Cayenne, Hypertext Transfer Protocol (HTTP), permitindo ao usuário realizar uplink para um gateway e receber downlink por HTTP, OpenSensors e EVRYTHNG . Caso o usuário queira criar sua própria aplicação, a TTN disponibiliza Application Programming Interface (API) para uso com Message Queuing Telemetry Transport (MQTT) e diversos Software Developer Kits (SDK) para uso com as linguagens Python, Java , Node.Js , NODE-RED e Go

A rede TTN utiliza o protocolo LoRaWAN objetivando uma cobertura em longo alcance para os dispositivos da rede, caracterizando-a assim com uma Wide Area Network (WAN). Devido ao baixo consumo de energia e ao uso da tecnologia LoRa, é chamada de LPWAN (Low Power Wide Area Network). O grande diferencial da TTN é seu estabelecimento como uma rede aberta (open-source) e colaborativa (crowd-sourced), onde qualquer usuário pode contribuir instalando um gateway em sua residência.

Os elementos da TTN são classificados como: 

• Endpoints (nós): Os dispositivos responsáveis pela camada de sensoriamento da rede, o endpoint LoRaWAN. Podem coletar informações através de sensores e também acionar dispositivos/máquinas via atuadores. São configurados através de uma das três classes distintas do protocolo LaRaWAN; 

• Gateways: Elementos responsáveis por concentrar e processar as informações enviadas pelos endpoints. Os gateways em geral estão conectados a internet, seja por WiFi/Ethernet ou 3G/4G em locais remotos. Mesmo que uma mesma rede LoRaWAN tenha diferentes objetivos, baseados em aplicações distintas, os gateways possuem o objetivo comum de fornecer a maior área de cobertura possível; 

• Aplicações: Conectar e interligar os diferentes dispositivos da rede TTN para o fornecimento de informações gerais sobre a coleta de dados dos dispositivos.
VISUINO
O Visuino é o mais recente software inovador da Mitov Software. Um ambiente de programação visual que permite programar suas placas Arduino.
Os componentes encontrados no software Visuino representam seus componentes de hardware e você poderá criar e projetar facilmente seus programas usando arrastar e soltar. Nenhum equipamento ou hardware é necessário para executar o software no modo de design. Depois de ter concluído o design, você pode conectar o upload da placa Arduino e executá-lo.

Para aquelas pessoas que não são fortes em escrever código, em seguida, projetar, compilar e criar programas Arduino nunca foi tão fácil! Por que perder tempo criando código quando já se faz todo o trabalho duro para você? Você tem sua placa Arduino e um ótimo design de hardware, veja-a rodando em minutos, não em horas!

ARDUINO

O que é Arduino? Se você sabe pouco sobre Arduino, por favor dê uma olhada abaixo:

Você conhece Arduino. Instale o IDE primeiro:
https://www.arduino.cc/en/Main/Software

LOM204 e Arduino

LOM204 é baseado em STM32L071.  No Arduino STM32 existe este core.

Como instalar Arduino STM32?
adicionar em Arquivo Preferências URLs adicionais

http://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json

BSP (utilizar 2.2.0)

Em seguida, instale o BSP para STM32. Se a instalação estiver concluída como segue:

LIB LoraWAN para Arduino - LMIC (Catena)


Adicione ao Arduino IDE:

Ok, a LIB está instalada para ser acessada pelo Visuino. 

Defina a Região
lmic_project_config.h

// project-specific definitions //#define CFG_eu868 1 //#define CFG_us915 1 #define CFG_au915 1 //#define CFG_as923 1 // #define LMIC_COUNTRY_CODE LMIC_COUNTRY_CODE_JP /* for as923-JP */ //#define CFG_kr920 1 //#define CFG_in866 1 #define CFG_sx1276_radio 1 //#define LMIC_USE_INTERRUPTS







No PACKAGE do STM32, alguns arquivos tiveram que ser alterados para ter acesso aos GPIOS do LOM204.

Em
C:\Users\Usuario\AppData\Local\Arduino15\packages\STMicroelectronics\hardware\stm32\2.2.0\variants\STM32L0xx

Descompacte

Em 

C:\Users\Usuario\AppData\Local\Arduino15\packages

Tem-se então em variants, uma placa LOM204


Gravador para utilizar com Visuino

Instale o STM32 Cube Programmer, o Arduino (STM32 PACKAGE) irá reconhecê-lo e então utilizá-lo para programar o LOM204. O Kit LOM204 possui um gravador ST-LINK embarcado.

Caso não tenhas um Kit LOM204 ou seja, apenas um módulo, utilize o um ST-LINK V2

O autor utilizou o ST-LINK.


Baixe o VISUINO PRO e instale


Foi Criado, não oficialmente , um VCOMP (Virtual Component) para o LOM204, o qual pode ser baixado aqui.


Copie para a PASTA

C:\Users\Usuario\Documents\Arduino\libraries\Mitov\Visuino

Projeto VISUINO, baseado no exemplo Lmic (TTN-OTAA.ino)




Atenção, o VISUINO instalará o SDK "STM32" em 

C:\Users\Usuario\AppData\Local\Arduino15\packages

Podes apagar, deixe o baixado pela IDE do Arduino, para que faça referência ao SDK oficial do STM32.

C:\Users\Usuario\AppData\Local\Arduino15\packages\STMicroelectronics

LMIC LoRaWAN  Stack

Certifique-se que LOM204 e programador estejam selecionados, bem como demais parâmetros e então compile.


Transfira o programa para os dois LOM204

Pronto!


Explicação do Projeto Visuino


Buffer Circular


Estado do GPIO lido pelo CustomCode Buffer Circular

Imprime a cada 20 segundos o estado do GPIO e últimos 32 estados (CustomCode)

void printBin(unsigned long int aByte) {
  for (int8_t aBit = 31; aBit >= 0; aBit--)
    Serial.write(bitRead(aByte, aBit) ? '1' : '0');
  Serial.println();
}
CustomCode LMIC - Credenciais

CustomCode LMIC - LoRaWAN Stack

Estado do Relay é alterado e gravado na EEPROM via DownLink - JSON {"RELAY":0}

Pela UART é enviada a SUB-BAND utilizada para LoRaWAN - JSON {"SUBBAND":0}


Eventos do LoRaWAN - Lmic


Sinalizar em GPIO o Status das Operações do Lmic

Execução

Significa se você não mandou pela UART a SUB-BAND e EPROM está com "Sujeira"


bit_t LMIC_selectSubBand(u1_t band) { bit_t result = 0; ASSERT(band < 8); //<============================== for (int b = 0; b<8; ++b) { if (band == b) result |= LMIC_enableSubBand(b); else result |= LMIC_disableSubBand(b); } return result; }


Altere para (assim se SUB-BAND for maior que 7, altere para 1)


bit_t LMIC_selectSubBand(u1_t band) { bit_t result = 0; int band_aux; band_aux = band; if(band_aux>7) band_aux = 1; //Configurado no Gateway ASSERT(band_aux < 8); for (int b = 0; b<8; ++b) { if (band_aux == b) result |= LMIC_enableSubBand(b); else result |= LMIC_disableSubBand(b); } return result; }


Recompile, grave, envie JSON


Pegue Credenciais OTAA no CHIRPSTACK e altere



Atenção LSB para DEVEUI

Publicação TTN



DOWNLINK PARA ACIONAR RELE

Deve mandar a mensagem 

{"RELAY":X}, onde 1 LIGA RELÊ e 0 DESLIGA RELÊ


GPIO vai para ALTO (Ligado à um RELÊ)

EXEMPLO

Significa que últimas 20 leituras do GPIO retornaram 0
Fontes:


Dúvidas

suporte@smartcore.com.br


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

quarta-feira, 30 de novembro de 2022

LSM110A - Programando com RTOS RIOT E ENVIANDO DADOS PARA U-BLOX ThingStream

  

O objetivo deste BLOG é demonstrar como é possível utilizar o RIOT para programação do WISOL LSM110A. Foi utilizado o Starter Kit LSM110A para o teste. O exemplo permitirá com linhas de comando o envio de texto via LoRa (ABP, AU915) ao servidor U-BLOX ThingStream MQTT (configurado no Gateway da Dragino), ou seja, não será necessário ter um servidor LoRaWAN TTN ou CHIRPSTACK.

Baseado no lora-e5-dev-mini

BETA - EM TESTES - APENAS PARA PROGRAMADORES COM RIOT IOT E CONHECEDORES DO DRAGINO GATEWAY - (OPENWRT E MQTT)

Compilado no WSL2 (Ubuntu on Windows), mas pode ser também no MinGW ou Ubuntu.

LSM110A Starter KIT
Módulo

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.




Ambiente thingstream

Características:
  • o custo do Thingstream como um MQTT Broker é muito menor do que o custo daqueles associados ao Azure e AWS;
  • o gerenciador de fluxo de dados é uma excelente vantagem, dados podem ser tratados no servidor e então encaminhados;
  • permite programação Node.js;
  • a segurança é diferente e muito mais simplificada do que tentar fazer uma troca de certificados com a AWS etc;
  • tem uma conexão segura em vez do dispositivo. Isso realmente simplifica a integração;
  • capacidade de se inscrever em vários tópicos diferentes;
  • nós para acessos para vários serviços da AWS Amazon, Azure IoT, IBM Watson, IFTTT (DashBoard e uma infinidade de outras opções)
  • criação de Coisas (Thing);
  • monitoração de eventos MQTT;
  • alertas quando algo não vai bem.
No modo tradicional, se você quer acessar AWS, AZURE, etc:
  • você deve fazer registro
  • gerar certificados
  • manter, guardar e proteger seus Certificados
  • despachar cada Certificado um por um para os Devices na produção
  • você precisa manter identidades diferentes por cada um dispositivo e entregá-los com segurança
  • fortes impactos na complexidade na logística, produção tempo, configuração do sistema e custos de manutenção
Com ThingStream, se você quer acessar AWS, AZURE, etc:
  • você deve fazer um registro de CA (certificate authority) (Access ID e Secret Key), exemplo, IAM na AMAZON.
  • quando você cria um Device (Things) no ThingStream, você deve pegar as credenciais (Username, Password, Client ID) (Device Certificate), basicamente muda Client Id e Password para cada Device
  • utilize estas credenciais (Things) (Username, Password e Client ID) no Device (U-BLOX NINA W106) para acessar o ThingStream  via MQTT
  • crie Tópicos (Topics) que devem acessados pelos Devices (U-BLOX NINA W106), ou seja, para fazer Publish ou Subscribe
  • no DATAFLOW manager (Flows), o Nó ThingStream Subscribe deve estar conectado à um Tópico previamente criado para o seu Device (U-BLOX NINA W106), é por ele que começa o disparo para o DATAFLOW manager
  • Dentro do DATAFLOW pode de ter vários Nós ThingStream Subscribe
  • no DATAFLOW manager tenha fácil acesso à AWS, AZURE, etc utilizando Access ID e Secret Key e então solicite os serviços disponíveis (S3, LAMBDA, etc) (No caso da AMAZON)

Dentro do ThingStream você tem o FLOW, o que permite tratar e encaminhar os dados para outros lugares.

Saldo de "Publish"

Registros dos Eventos


Planos acessíveis

RIOT: O sistema operacional amigável para a Internet das Coisas.

O RIOT alimenta a Internet das Coisas, como o Linux alimenta a Internet. O RIOT é um sistema operacional gratuito e de código aberto desenvolvido por uma comunidade de base que reúne empresas, universidades e entusiastas, distribuídos em todo o mundo.

O RIOT é um sistema operacional de IoT com recursos em tempo real. Foi desenvolvido por um consórcio de universidades na Alemanha e na França, que incluía a Universidade Livre de Berlim, o Instituto Francês de Pesquisa em Ciência da Computação e Automação e a Universidade de Ciências Aplicadas de Hamburgo. É lançado sob a Licença Pública Geral Menor GNU (LGPL).

É baseado na arquitetura de microkernel e é executado em microcontroladores de 8 a 32 bits. O RIOT suporta multithreading e toda a pilha de rede IoT.

O RIOT suporta a maioria dos dispositivos IoT de baixa potência e arquiteturas de microcontroladores (32 bits, 16 bits, 8 bits). O RIOT tem como objetivo implementar todos os padrões abertos relevantes que suportam uma Internet das Coisas conectada, segura, durável e amiga da privacidade.

O RIOT é um desenvolvimento amigável

Programe como você está acostumado. Não perca tempo com ambientes novos ou complexos.

Programação padrão em C ou C ++
Ferramentas padrão como gcc, gdb, valgrind
Código dependente de hardware minimizado
Zero curva de aprendizado para programação incorporada
Codifique uma vez, execute em plataformas de 8 bits (por exemplo, Arduino Mega 2560), plataformas de 16 bits (por exemplo, MSP430) e em plataformas de 32 bits (por exemplo, ARM)
Conformidade parcial com POSIX. Rumo à conformidade total com POSIX.
Desenvolva no Linux ou Mac OS usando a porta nativa, implemente no dispositivo incorporado

O RIOT é favorável aos recursos

Beneficie-se de uma arquitetura de microkernel e de um agendador sem marcação em dispositivos muito leves.

Robustez e flexibilidade da footprint de código
Permitindo a máxima eficiência energética
Capacidade em tempo real devido à latência de interrupção ultra baixa (~ 50 ciclos de clock) e agendamento com base em prioridades
Multiencadeamento com sobrecarga de encadeamento ultra baixo (<25 bytes por encadeamento)

O RIOT é amigável à Internet das coisas

Prepare seus aplicativos para as coisas menores da Internet com suporte comum ao sistema.

6LoWPAN, IPv6, RPL e UDP
CoAP e CBOR
Alocação de memória estática e dinâmica
Temporizadores de alta resolução e longo prazo
Ferramentas e utilitários (shell do sistema, SHA-256, filtros Bloom, ...)

Estrutura do RIOT


LSM110A E RIOT

Como o módulo LSM110A é baseado no chip STM32WL55 (CPU), será possível rodar o RIOT sem problemas. 


O link abaixo, é roteiro Básico para que você possa preparar o ambiente para programar o LSM110A


Durante o processo você "deverá" instalar

git, Arm Toolchain, gcc, make, python3, pip3

Clone RIOT OS
git clone github.com/RIOT-OS/RIOT.git
cd RIOT
Editando arquivos em

\RIOT\tests\pkg_semtech-loramac

Makefile

BOARD ?= lora-e5-dev include ../Makefile.tests_common BOARD_WITHOUT_LORAMAC_RX := \ arduino-mega2560 \ i-nucleo-lrwan1 \ stm32f0discovery \ waspmote-pro \ LORA_DRIVER ?= sx126x_stm32wl LORA_REGION ?= AU915 USEPKG += semtech-loramac USEMODULE += $(LORA_DRIVER) # load loramac RX if board supports it ifeq (,$(filter $(BOARD),$(BOARD_WITHOUT_LORAMAC_RX))) USEMODULE += semtech_loramac_rx endif USEMODULE += auto_init_loramac USEMODULE += shell USEMODULE += shell_cmds_default USEMODULE += fmt FEATURES_OPTIONAL += periph_eeprom # Default IotLab Config to run the test ifneq (,$(filter iotlab%,$(MAKECMDGOALS))) IOTLAB_NODES ?= 1 IOTLAB_TYPE ?= st-lrwan1:sx1276 IOTLAB_SITE ?= saclay include $(RIOTBASE)/dist/testbed-support/Makefile.iotlab endif include $(RIOTBASE)/Makefile.include


RIOT\build\pkg\semtech-loramac\src\mac\region
REGION_AU915.C (SUB-Bands)
void RegionAU915InitDefaults( InitType_t type ) { switch( type ) { case INIT_TYPE_INIT: { // Channels // 125 kHz channels for( uint8_t i = 0; i < AU915_MAX_NB_CHANNELS - 8; i++ ) { Channels[i].Frequency = 915200000 + i * 200000; Channels[i].DrRange.Value = ( DR_5 << 4 ) | DR_0; Channels[i].Band = 0; } // 500 kHz channels for( uint8_t i = AU915_MAX_NB_CHANNELS - 8; i < AU915_MAX_NB_CHANNELS; i++ ) { Channels[i].Frequency = 915900000 + ( i - ( AU915_MAX_NB_CHANNELS - 8 ) ) * 1600000; Channels[i].DrRange.Value = ( DR_6 << 4 ) | DR_6; Channels[i].Band = 0; } // Initialize channels default mask ChannelsDefaultMask[0] = 0xFF00; ChannelsDefaultMask[1] = 0x0000; ChannelsDefaultMask[2] = 0x0000; ChannelsDefaultMask[3] = 0x0000; ChannelsDefaultMask[4] = 0x0000; ChannelsDefaultMask[5] = 0x0000;














Compilando
make BOARD=lora-e5-dev -C tests/pkg_semtech-loramac
TESTANDO NO WISOL LSM110A

text data bss dec hex filename 62604 184 7584 70372 112e4 /home/ubuntu/RIOT/tests/pkg_semtech-loramac/bin/b-l072z-lrwan1/tests_pkg_semtech-loramac.elf make: Leaving directory '/home/ubuntu/RIOT/tests/pkg_semtech-loramac' ubuntu@DESKTOP-GRCNLV8:~/RIOT$


Na pasta

/home/ubuntu/RIOT/tests/pkg_semtech-loramac/bin/lora-e5-dev
será gerado o tests_pkg_semtech-loramac.bin

Utilize STM32 PROGRAMMER para gravar


Abra o Emulador de Terminal

TX1 e RX1 do KIT LSM110A

Usando o SHELL

Este aplicativo fornece o comando loramac para configurar o MAC, juntar-se a uma rede e enviar/receber dados para/a partir de uma rede LoRaWAN. Subcomandos tx e join estão bloqueados até que o MAC esteja pronto. Classe A é ativado por padrão.

OTA

Juntando-se com over the air activation (OTA)

Defina seu dispositivo EUI, aplicativo EUI, chave de aplicativo:

> loramac set deveui AAAAAAAAAAAAAAAA
> loramac set appeui BBBBBBBBBBBBBBBB
> loramac set appkey CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
Junte-se a uma rede usando o procedimento OTAA:

> loramac join otaa
Join procedure succeeded!
Unindo-se à ativação por personalização (ABP)

OTAA é sempre preferido em cenários do mundo real. No entanto, a ABP pode ser prática para testes ou workshops.

Defina o endereço do dispositivo, a chave da sessão da rede, a chave da sessão do aplicativo:

> loramac set devaddr AAAAAAAA
> loramac set nwkskey BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
> loramac set appskey CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
Junte-se a uma rede usando o procedimento ABP:

> loramac join abp
Join procedure succeeded!
Salvar contadores de quadros na memória flash não é (ainda) suportado. Antes de enviar dados, é necessário limpar contadores de quadros no Servidor de Rede! Caso contrário, as mensagens de uplink não funcionarão.

NOTA: Se usar TTN com ABP, certifique-se de definir a taxa de dados correta para RX2. Caso contrário, mensagens confirmadas e de downlink não funcionarão. O datarate para RX2 deve ser DR3 (SF9BW125) como visto na visão geral das frequências LoRaWAN:

> loramac set rx2_dr 3
Envio e recebimento de dados

Enviar dados confirmáveis na porta 2 (cnf e porta são opcionais):

> loramac tx This\ is\ RIOT! cnf 2
Envie dados não cconfirmáveis sobre a porta 10:

> loramac tx This\ is\ RIOT! uncnf 10
Ao usar mensagens de downlink classe A (modo padrão) serão recebidas no próximo uplink:

> loramac tx hello
    Data received: RIOT, port: 1
Outros comandos shell

Salve a configuração LoRaWAN do dispositivo (EUIs e chaves) em EEPROM (se fornecido pelo microcontrolador):

> loramac save
Na próxima reinicialização do dispositivo, esses parâmetros serão lidos automaticamente a partir do armazenamento não volátil EEPROM e, portanto, você pode se juntar diretamente à rede sem inseri-los novamente da linha de comando.

Remova a configuração LoRaWAN armazenada anteriormente:
> loramac erase
Alterne o índice de taxa de dados padrão (de 0 a 16). 5 é para SF7, BW125:

> loramac set dr 5
Mude para taxa de dados adaptativo (DataRate)

loramac set adr on
Execute um comando Link Check (será acionado na próxima transmissão):

> loramac link_check
A lista de comandos disponíveis:

> help
  help
  Command              Description
  ---------------------------------------
  loramac              control the loramac stack
  reboot               Reboot the node
Sequência de testes

  • Pegue as credenciais do LSM110A, no caso são os valores Default na FLASH, durante a geração do Binário do RIOT.

loramac get devaddr
DEVADDR: 00000000
loramac get nwkskey
NWKSKEY: 00000000000000000000000000000000
loramac get appskey
APPSKEY: 00000000000000000000000000000000   

Cadastrando ABP keys

00000000|0000..|0000...

Apontando para ThingStream



LoRaWAN para MQTT


loramac join abp


loramac tx hello uncnf 1



Topic

ThingStream MQTT recebendo pacotes

TESTES EXTRAS



MONTAGEM


VSC

Saindo da linha de Comando para VISUAL CODE

VÍDEO

loramac tx AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA uncnf 1

DÚVIDAS

FORUMS RIOT

REFERÊNCIAS


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