Comunicação IoT Com a Dragonboard 410C: 5 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

É bastante comum desenvolver ou, até mesmo, comprar um produto IoT para a sua casa. Abrir uma cortina, ligar uma tomada, ajustar a temperatura de um ambiente, monitoramento de segurança, outros benefícios de equipamentos IoT.

Agora, seria interessante transformar esses alertas das "coisas" da sua casa, em solicitações de serviço, e ainda melhor, em serviços que você conhece e que já está acostumado. O comerciante "zé da água" não tem condições de entrar num grande marketplace para vender a sua água e tão pouco ter recursos para adquirir e manter um sistema de pedidos.

Para que você use serviços como o do seu 'Zé da água', que você sempre confiou, será como montar uma base de uma plataforma IoT com um dragonboard, para resolver essa comunicação.

Etapa 1: Prepare um Sua Dragonboard 410C

Neste passo vamos preparar nosso Drabonboard 410C para tornar o gateway de nossa estrutura IoT dentro de sua casa.

Primeiramente, vamos instalar um sistema operacional na placa. Caso você opte por utilizar a localização GPS, que ajudará muito o cliente no momento de registro, sugerimos que instale o sistema operacional Linaro 17.04.1, caso contrário, veja as opções de na página do Dragonboard 410C da 96boards, neste link.

Após a instalação do seu sistema operacional, instale a biblioteca libmraa para a utilização das GPIOs, da Dragonboard 410C. Para isso, você deve seguir os passos abaixo (abra o console do seu sistema operacional para executar os comandos):

Pré requisitos libmraa

• sudo apt-get update
• sudo apt-cache search pcre
• sudo apt-get install libpcre3-dev
• sudo apt-get install git
• sudo apt-get install cmake
• sudo apt-get install python-dev
• sudo apt-get install swig

Instalação mraa

• sudo git clone
• sudo mkdir mraa / build && cd $ _
• sudo cmake.. -DBUILDSWIGNODE = OFF
• sudo make
• sudo make install

Para usar uma biblioteca com Python, que é o caso deste instrutível, vamos adicionar o exportar da nossa variavel de ambiente do Python para uma biblioteca. Para isso, utilize o editor de texto de sua preferência para seguir os passos abaixo, vamos utilziar o VIM:

• sudo vim ~ /.bashrc
• pressione a teclar i, para iniciar a edição do arquivo
• adicione a linha a seguir no final do arquivo: export PYTHONPATH = $ PYTHONPATH: $ (dirname $ (find / usr / local -name mraa.py))
• pressione ESC para sair da edição do arquivo e digite ': x!' e entrar para salvar e sair do arquivo.

Com isso já conseguimos utilizar uma biblioteca mraa com Pyhton.

Agora, vamos instalar os softwares para facilitar a leitura do GPS (lembrnado que para a utilização dessa parte, recomendamos o uso do sistema operacional Linaro 17.04.1). Não seu console, execute o comando abaixo:

sudo apt-get install gnss-gpsd gpsd gpsd-clients

Para testar, execute o código abaixo, também no seu console:

gpsmon –n

OBS: A antena interna da Drabonboard é para ser utilizada fora de casos e locais mais abertos. Até mesmo em locais disponíveis, a leitura pode demorar de 5 a 10 minutos, então não fique preocupado se não exibir as informações prontamente.

Pensando no projeto, com certeza iremos encapsular o (s) hardware (s) num caso, e nenhum menor dos cenários, este caso estará dentro de uma casa ou apartamento. Para resolver, podemos usar antenas externas, tanto para wi-fi, quanto para GPS.

OBS: A instalação da antena externa não é um procedimento tão simples para quem não tem familiaridade com procedimentos de soldagem com SMD, portanto, adquirir um serviço especializado se necessário.

Para realizar ou alternar das antenas internas para externas, será necessário seguir os procedimentos que a Qualcomm disponibilizou no documento deste link.

OBS: É muito mais fácil de encontrar os componentes (capacitores, resistores e indutores) na internet do que em loja física. O mesmo para antenas, que sugerimos a compra no site da SmartCore.

Para que nosso gateway não fique dependente de uma configuração e conexão wi-fi, com a internet, iremos utilzar um módulo GSM. Os módulos GSM externos, geralmente normais de uma tensão estável e específica, então vamos criar uma saída de alimentação diretamente da entrada de alimentação da Dragonboard 410C.

Na imagem de capa deste passo, estão destacados nos pontos de saída que devem ser usados para a soldagem dos cabos para a alimentação do módulo GSM (ATENÇÃO COM A POLARIDADE).

Para realizar a comunicação interna, iremos utilizar o protocolo MQTT, e definir um Dragonboard 410C como hotspot. Vamos instalar o software Mosquitto para tornar a nossa placa um broker mqtt, com uma execução da linha abaixo no seu console:

sudo apt-get install mosquitto

Com isso o software já disponível instalado e ativo.

Para definir a sua Dragonboard 410C como um hotspot, siga os passos:

• Clique no icone de redes no canto inferior direito
• Clique em 'Editar conexões'
• Após abrir uma tela 'Conexões de rede', clique em 'Adicionar'
• Selecione a opção Wi-fi, e clique em 'Criar'
• Para abrir uma tela de configuração da rede, insira um nome em SSID
• Na mesma tela mude para 'Hotspot' no campo 'Modo'
• Caso queira incluir uma senha para a rede, configure-a na aba 'Segurança Wi-fi'
• Para finalizar clique em 'Salvar'

Agora qualquer dispositivo pode se conectar à rede exclusiva da Dragonboard 410C, e utilizar o seu broker para publicar e subscrever.

Com estes preparos acima, estamos prontos para seguir com o desenvolvimento.

Etapa 2: preparar uma API Sua Cloud

Este passo é algo que depende muito de projeto para projeto. Pode ser que seja feito de forma precisa, ou o cloud já existe com a necessidade de criar o mecanismo de API, ou até mesmo já ter uma API pronta para utilizar.

Vamos descrever um passo a passo para iniciar uma API básica, pelo menos para o teste deste instructable. Caso queira seguir um tutorial mais completo, sugiro ver o artigo deste link. Em todo caso, sugiro desenvolver algo mais estruturado, caso a hardware do projeto seja comercial.

Primeiramente, precisamos de um lugar para colocarmos a nossa API, e para não gastos gastos com estes testes, iremos utilizar a plataforma Heroku. Siga os passos para iniciar a sua aplicação:

• Acesse o site da Heroku, por este link
• Clique em 'Sign Up', no canto superior dieito, para iniciar o seu registro
• Após o registro, em seu painel, clique em 'Novo' e escolha a opção 'Criar novo aplicativo'
• Insira um nome para a sua aplicação
• Em seguida, clique em 'Criar Aplicativo'
• Seu app está pronto, podendo ver seu funcionamento clicando em 'Open App', no canto superior dirento
• Instale o Heroku Cli, para fazer os deploys para a sua aplicação, seguindo a instrução para seu sistema operacional, de acordo com a documentação deste link
• Agora você deve seguir as instruções de implantação para começar o desenvolvimento da sua API, disponível em

Seguindo os passos acima, já temos uma pasta na sua máquina, para desenvolver uma API. Agora vamos instalar o NodeJS e um framework Express, seguindo os passos abaixo:

• curl -sL https://deb.nodesource.com/setup_11.x | sudo -E bash -
• sudo apt-get install -y nodejs
• sudo apt-get install npm
• Caso não utilize uma distribuição Linux que utilize o Advanced Packaging Tool (APT), ou outro sistema operacional, consulte o link
• Agora execute npm install express-generator -g
• Acesse o diretório que foi realizado os procedimentos da aplicação da Heroku com 'cd _PASTA_SEU_APP_'
• Inicie um nó de aplicação com 'npm init', e os outros comandos abaixo
• CD../
• expresso _PASTA_SEU_APP_
• cd _PASTA_SEU_APP_
• npm install

Para deixar dois endpoints preparados, um de GET e um de POST, siga os passo abaixo:

• Acesse uma 'rota' de macarrão
• abra o arquivo 'index.js'
• Escolha o trecho de código abaixo, que irá adicionar como rotas na raiz da sua aplicação para os dois métodos (GET e POST):

router.get ('/', function (req, res, next) {res.setHeader ('Content-Type', 'application / json'); res.send (JSON.stringify ({msg: 'Hello API'}, nulo, 3));}); router.post ('/', função (req, res, próximo) {var msg = 'vazio'; if (typeof req.body.msg! = 'undefined') msg = req.body.msg; res.setHeader ('Content-Type', 'application / json'); res.send (JSON.stringify ({msg: msg}, null, 3));});

Agora você percebe o deploy do seu app para um Heroku:

• login do heroku
• git add.
• git commit -am "commit inicial"
• git push heroku mestre

Com isso você já tem seus endpoints de testes prontos. Para testar os endpoints sugerimos instalar o software Postman, neste link. Insira uma url do seu aplicativo (Ex: https://_SEU_APP_.herokuapp.com/) e selecione o método GET ou POST, e clique em 'ENVIAR'. Para o método POST, siga os passos:

• Clique na aba 'Corpo'
• Selecione uma opção 'x-www-form-urlencoded
• Insira a chave 'msg'
• Em Value, pode inserir qualquer mensagem

Com essas instruções temos a nossa API de testes pronta para o uso.

Etapa 3: Instalando E Manipulando O Modulo GSM

Para não dependermos de uma conexão Wifi, vamos usar uma comunicação GSM para abrir o caminho de dados para usarmos uma nossa API, não configurada nenhuma etapa anterior.

É aconselhável a utilização de módulos GSM homologados, mas para os testes do nosso protótipo, iremos utilizar um módulo simples e que atende a nossa demanda do momento, o módulo SIM800L. Este módulo foi produzido e distribuído em massa pelo fabricando, mas sem qualquer homologação, tanto que não está disponível no site do fabricando.

Vamos às físicas físicas, entre o módulo GSM e a nossa Dragonboard 410C.

Como manter nenhuma etapa 'Prepare um Dragonboard sua', teremos que regular a tensão para usar o módulo. Para isso, usar um regulador de tensão para baixo, para diminuir a tensão de entrada. Utilizamos o Regulador De Tensão Stepdown Buck Conversor Dc Lm2596 3a Nf, para este teste

Siga os passos abaixo para realizar as regras físicas:

• Conecte uma saída positiva da Dragonboard, como ilustrado no passo 'Prepare a sua Dragonboard', e conecte na entrada 'IN +' do regulador de tensão
• Conecte uma saída negativa da Dragonboard, como ilustrado no passo 'Prepare a your Dragonboard', e conecte na entrada 'IN -' do regulador de tensão
• IMPORTANTE: Ligue a Dragonboard, e regule com o auxilio de uma chave de fenda, regule o trimpot para que a saída (OUT + e OUT -) tenha 4.2V. Siga adiante apenas se a saída estiver com esse valor. Caso seja utilizado outro módulo GSM, a tensão adequada. Este passo deve ser repetido, sempre que houver inclusão de um hardware, pois pode haver variação.
• Conecte uma saída do regulador de tensão 'OUT +' no pino VCC, indicado na imagem de capa deste passo
• Conecte uma saída do regulador de tensão 'OUT -' no pino GND, indicado na imagem de capa deste passo
• Conecte o pino RXD do módulo GSM no pino 5 UART 0 TX da Dragonboard, ambos indicados nas imagens de capa deste passo
• Conecte o pino TXD do módulo GSM no pino 7 UART 0 RX da Dragonboard, ambos indicados nas imagens de capa deste passo
• Conecte o pino GND do módulo GSM no pino 1, 2, 39 OU 40 GND da Dragonboard, ambos indicados nas imagens de capa deste passo. Isto é fundamental para o estabelecimento de tráfego de dados pela RX TX

OBS: Não se esqueça de conectar uma antena no módulo GSM, pelos pinos NET ou IPX ANT, indicado na imagem de capa deste passo.

Agora vamos ao software. Vamos usar uma biblioteca que instalamos anteriormente, para realizar uma comunicação serial entre o módulo GSM e um Dragonboard 410C.

Siga os passos para importar a biblioteca e testar a comunicação com o módulo:

• Crie um arquivo com extensão.py, como sugestão 'gsm.py'
• No arquivo, inicie importando uma biblioteca mrra, e também uma biblioteca time para definir atrasos

importar mraa

Defina uma variável para o caminho da UART que conectamos ao módulo GSM

port = '/ dev / tty96B0'

Instancie a UART com ajuda da biblioteca mraa

uart = mraa. Uart (porta)

Crie uma função para enviar para os comandos AT para o módulo GSM

def escrever (msg):

uart.write (bytearray (str (msg) + '\ n', 'utf-8'))

Crie um loop para fazer a leitura do módulo GSM

enquanto Verdadeiro: r = uart.read (128) if r! = '': print (r.decode ('UTF-8')) i = str (input ()) write (i) time.sleep (0,5)

• Salve o arquivo e volte para o console
• Executar o arquivo

python gsm.py

Digite 'AT', e se tudo conectado corretamente, você irá receber na tela a mensgem 'OK'

Para que nosso módulo não dependa de digitarmos cada comando AT - encontrados neste link - faremos duas funções, uma que irá realizar uma conexão com um APN e outra que irá consumir em nossa API.

A primeira função será de conexão:

def conectar ():

tempo.sono (0,5) escrever ("AT") tempo.sono (0,5) escrever ('AT + CREG = 1') tempo.sono (0,5) escrever ('AT + COPS = 2') tempo.sono (0,5) write ('AT + SAPBR = 3, 1, "Contype", "GPRS"') time.sleep (0,5) write ('AT + SAPBR = 3, 1, "APN", "*****"') time.sleep (0,5) write ('AT + SAPBR = 3, 1, "USER", "*****"') time.sleep (0.5) write ('AT + SAPBR = 3, 1, "PWD", "*****" ') time.sleep (0.5) write (' AT + SAPBR = 1, 1 ') time.sleep (0.5) write (' AT + SAPBR = 2, 1 ') time.sleep (6)

Sugiro que rode cada comanda antes de utilizar esta função. Segue algumas idéias sobre estes comandos:

• Para definir corretamente o valor do comando AT + COPS, que serve para selecionar a sua rede, primeiro execute AT + COPS = ?, aguarde que apareça as redes disponíveis, e altere o valor na função conectar () para o indexador da rede exibida após o comando AT_COPS =?
• Os comandos de definição da APN estão com asteriscos pois depende de cada operadora do cartão SIM, obtenha se informar com um operador para saber qual o endereço da APN, usuário e senha.
• Repare que a cada

Agora vamos implementar uma função que irá enviar consumir a nossa API:

def send (p, m, d = ''):

write ('AT + HTTPINIT') time.sleep (0,5) write ('AT + HTTPSSL = 1') time.sleep (0,5) write ('AT + HTTPPARA = "CID", 1') time.sleep (0,5) write ('AT + HTTPPARA = "URL", "_URL_APP_HEROKU _ /' + p + '"') time.sleep (0,5) write ('AT + HTTPPARA = "USERDATA", "Autorização: Portador ******** ********* / r / n "') time.sleep (0,5) if m ==' GET ': write (' AT + HTTPACTION = 0 ') else: write (' AT + HTTPPARA = "CONTEÚDO", "application / x-www-form-urlencoded" ') time.sleep (0,5) write (' AT + HTTPDATA = '+ str (len (d)) +', 10000 ') time.sleep (0,5) write (str (t)) time.sleep (10) write ('AT + HTTPACTION = 1') time.sleep (6) write ('AT +

Segue algumas idéias para estes comandos:

• A função recebe 3 parâmetros. 'p' para o caminho que será obtido da API, 'm' para o método que você irá utilizar da sua api (GET / POST /…), e 'd' para os dados enviados em caso do método não for GET
• O comando 'AT + HTTPS' é opcional, no caso de usar SSL
• O argumento 'm' deve ser enviado no formato querystring (Ex: msg = ola + dragonboard & arg2 = teste &…)
• O comando 'AT + HTTPPARA = "USERDATA…' é opcional, apenas se houver necessidade de definir algum header no request

Mais uma vez sugerir rodar cada comando, individualmente e em ordem, antes da utilização.

Antes de adquirir seu cartão SIM, consulte se a operadora trabalha com a mesma tecnologia que o módulo GSM que você estiver usando, mas é aconselhável usar o cartão SIM de empresas especializadas em comunicação IoT, por questões de compatibilidade, custos e praticidade.

Com as configurações e implementações acima, estamos prontos para nos comunicarmos com a nuvem através da nossa Dragonboard 410C.

Etapa 4: Preparando Dispositivos Para Se Comunicar Com a Dragonboard

Neste passo, iremos usar uma placa de prototipagem NODEMCU ESP8266 ESP-12, como exemplo. Esta e qualquer outra placa de prototipagem, como o nome já diz, é ótima para protótipos, mas no momento em que o hardware para definido como produto, deve ser desenvolvido um complexo dedicado. Este módulo já possui WiFi, então irá facilitar a comunicação.

Para nos comunicarmos com a nossa Dragonboard 410C, precisamos de 2 bibliotecas:

• ESP8266WiFi> biblioteca para ativar a conexão da placa
• PubSubClient> biblioteca para realizar uma comunicação com o corretor MQTT

Defina como variáveis globais, as definições da rede Wi-fi e do corretor, ambos da nossa Dragonboard 410C:

• const char * SSID = "_REDE_DRAGONBOARD_"; // Nome da rede definida como Hotspot na Dragonboard
• const char * PASSWORD = ""; // Insira o valor da senha se houver definido na configuração do Hotspot
• const char * BROKER = "_IP_DRAGONBOARD_"; // Execute 'ip a' na sua Dragonboard para descobrir o ip da rede interna

Crie o objeto de rede Wi-fi da placa e instância do cliente MQTT com este objeto:

• WiFiClient espWIFI;
• PubSubClient MQTT (espWIFI);

Na função de configuração, inicie a conexão WIFI e a comunicação MQTT:

• WiFi.begin (SSID, SENHA);
• MQTT.setServer (BROKER, 1883);
• MQTT.setCallback (callback_mqtt); // Caso você faça se inscrever em algum tópico

Nenhuma função de loop, é a linha abaixo para que o MQTT entre em loop:

MQTT.loop ();

Você pode criar uma função de verificação de conexão de WIFI e do corretor, para não ter problemas com intermitência. Para isso, crie um função com as linhas abaixo, e chame-a na função de loop:

void checkConnections () {

if (! MQTT.connected ()) while (! MQTT.connected ());

if (WiFi.status ()! = WL_CONNECTED) {WiFi.begin (SSID, PASSWORD); while (WiFi.status ()! = WL_CONNECTED);}

}

E finalmente, iremos enviar algum dado para a Drabonboard 410C, com o seguinte comando:

MQTT.publish ('_ NOME_DO_TOPICO_', "Ola Dragonboard");

Não vou entrar em detalhes para exemplificar a leitura de sensores e etc, pois vai variar muito de projeto para projeto e de hardware para hardware. Basta incluir esta linha onde necessário, que os dados serão enviados para um corretor.

Voltando para a nossa Dragonboard410C, vamos criar um arquivo teste em python, para checarmos os dados recebidos pelo broker, mas antes, vamos instalar uma biblioteca que nos auxiliará na conexão do broker. Para isso execute as linhas abaixo no console da Dragonboard 410C:

• sudo apt-get install python pip
• pip install paho-mqtt

Agora vamos criar um arquivo python com o nome, como exemplo, mqtt.py. Nele vamos definir algumas funções que serão explicadas a seguir:

importar paho.mqtt.client como mqttimport sys

Broker = "_IP_DRAGONBOARD_" port = 1883 tempo limite = 60 TopicSubscribe = "_MESMO_TOPICO_DISPOSITIVO_EXTERNO_"

def onConnect (client, userdata, flags, rc): client.subscribe (TopicSubscribe)

def onMessage (client, userdata, msg): message = str (msg.payload) print (message)

try: client = mqtt. Client () client.on_connect = onConnect client.on_message = onMessage client.connect (Broker, porta, tempo limite) client.loop_forever () exceto: sys.exit (0)

Neste arquivo definimos duas funções, a 'onConnect' que será chamada no momento em que houver conexão com o broker, e a função 'onMessage' que será executada quando houver mensagem fornecida nos assinantes definidos na função 'onConnect'.

Execute o arquivo com 'python mqtt.py' e se todas as conexões anteriores foram feitas com sucesso, você receberá na sua tela os dados que estão sendo enviados pelo seu dispositivo externo, no caso deste exemplo, pelo NODEMCU.

Note que é na função onMessage, que recebemos a informação e exibimos no seu console. Então é neste ponto que você tratará os dados recebidos e no momento certo, enviará via GSM para a sua API, pela função 'send' do seu arquivo de teste gsm.py, que criamos no passo 'Instalando e manipulando o módulo GSM'.

Uma observação importante: Para realizar uma alimentação da placa NODEMCU ESP8266 ESP-12, em especifico, sugiro que consulte o documento deste link. Muito cuidado neste momento, pois uma simples falha de inversão de polos pode queimar uma placa, mas caso isso aconteça uma boa noticia é que tem um preço que facilita uma troca rapidamente.

Etapa 5: Considerações Finais

Se estiver tudo configurado como necessário nos passos anteriores, você já está comunicando o seu dispositivo IoT com o mundo, com auxilio da sua Dragonboard 410C. É importante ressaltar que, neste caso, foram instruídos vários hardwares e softwares, mas apenas para fins de exemplificar a comunicação. Os sensores e outros recursos que serão utilizados no dispositivo externo, todo o preparo e implementação da sua API Cloud, os recursos de hardware ligados à Dragonboard, e também a forma com que os dados são protegidos, fica a critério de quem executar o projeto. Para definir como produto final, sugerimos apĺicar as tecnologias e procedimentos adequados para tal

O uso de aplicativos e aplicações de gestão, para os comerciantes ligados aos serviços, deixamos em aberto também, bastando trabalhar bem a sua API, e a consumindo estas frentes.