Configure o Wi-Fi do Raspberry Pi via Bluetooth para, em seguida, enviar dados para Ubidots

Ammar Chauhan
· 9 minutos de leitura
Enviar por e-mail

Pelo menos uma vez na vida você teve dificuldades para configurar as credenciais de Wi-Fi de um Raspberry Pi simplesmente porque não tinha um monitor à mão naquele momento.

Neste guia, descreverei como configurar um Raspberry Pi com um ponto de acesso (AP) através de um aplicativo Android. Não pode conectar um cabo Ethernet porque está em um local novo? Não se preocupe! Seguindo este guia, você poderá usar seu Pi em qualquer lugar. Basta escanear as redes, escolher a rede desejada, inserir as credenciais e pronto!

Eu implementei uma ferramenta simples que permite configurar o SSID e a PSK do Wi-Fi do Raspberry Pi via comunicação Bluetooth. Por enquanto, é bem básica – você só precisa ter emparelhado seu celular Android com o Raspberry Pi previamente, e eu escrevi um aplicativo Android simples.

Pessoalmente, acho isso muito útil para quem está sempre com o Raspberry Pi por perto, movendo-o de uma oficina para outra, levando-o de casa para a escola, além de todos os outros casos possíveis que você possa imaginar agora... Agora, sem mais delongas, vamos começar a construir coisas legais, começando pela instalação do script Python que será executado no nosso Raspberry Pi.

Requisitos

Passo a passo

  1. Configurando o Bluetooth do Raspberry Pi
  2. Emparelhando Raspberry Pi e celular Android
  3. Configuração do sensor DHT22 – Hardware
  4. Configuração do sensor DHT22 – Software
  5. Envio/Visualização de dados para Ubidots

1. Configurando o Bluetooth do Raspberry Pi

Inicialmente, você precisará de um monitor e um teclado conectados, ou acessar o Raspberry Pi via SSH para poder realizar todas as configurações necessárias através do Terminal Raspbian.

Execute os comandos abaixo com atenção para estabelecer as configurações adequadas:

  1. Instale o bluez (biblioteca Bluetooth em Python):
$ sudo apt-get install python-bluez

2. Inicie o daemon Bluetooth em modo de compatibilidade. Para isso, edite o arquivo /etc/systemd/system/dbus-org.bluez.service executando o comando abaixo:

$ sudo nano /etc/systemd/system/dbus-org.bluez.service

3. Em seguida, modifique o ExecStart :

ExecStart=/usr/lib/bluetooth/bluetoothd –C

4. Agora, carregue o perfil da porta serial usando o comando abaixo:

$ sudo sdptool adicionar SP

5. Para salvar as alterações corretamente, reinicie o seu Raspberry Pi:

$ sudo reboot

Após a reinicialização, vamos emparelhar o Bluetooth com o nosso celular Android

2. Emparelhando o Raspberry Pi e o telefone Android.

1. Emparelhe seu telefone Android com o Raspberry Pi. Para fazer isso, ative o Bluetooth do seu telefone e execute o comando abaixo no seu Raspberry Pi:

$ bluetoothctl

Em seguida, após o início do processo de emparelhamento, insira os seguintes parâmetros. (Consulte a imagem para ter uma melhor ideia do fluxo do processo)

ligar detectável na varredura

Nesse momento, seu telefone aparecerá na lista de dispositivos disponíveis. Anote o endereço do seu telefone.

confiar<PHONE_ADDRESS> par<PHONE_ADDRESS>

2. Para simplesmente sair do controle do Bluetooth, digite o comando quit:

$ sair

3. [OPCIONAL – DICA PROFISSIONAL] Você pode pular a configuração acima e configurar o Bluetooth com a interface do Raspbian. Basta pressionar o ícone do Bluetooth e selecionar o Bluetooth do seu telefone.

4. Após emparelhar o Bluetooth, adicione o script Python diretamente no Raspbian digitando o nano e copiando/colando o código-fonte, ou você pode copiar diretamente o arquivo run.py.

$ sudo nano run.py

Código-fonte (Copiar/Colar):

#!/usr/bin/env python #Run.py import os from bluetooth import * from wifi import Cell, Scheme import subprocess import time wpa_supplicant_conf = "/etc/wpa_supplicant/wpa_supplicant.conf" sudo_mode = "sudo " def wifi_connect(ssid, psk): # escreve a configuração do wifi em um arquivo cmd = 'wpa_passphrase {ssid} {psk} | sudo tee -a {conf} > /dev/null'.format( ssid=str(ssid).replace('!', '\!'), psk=str(psk).replace('!', '\!'), conf=wpa_supplicant_conf ) cmd_result = "" cmd_result = os.system(cmd) print cmd + " - " + str(cmd_result) # reconfigurar wifi cmd = sudo_mode + 'wpa_cli -i wlan0 reconfigure' cmd_result = os.system(cmd) print cmd + " - " + str(cmd_result) time.sleep(10) cmd = 'iwconfig wlan0' cmd_result = os.system(cmd) print cmd + " - " + str(cmd_result) cmd = 'ifconfig wlan0' cmd_result = os.system(cmd) print cmd + " - " + str(cmd_result) p = subprocess.Popen(['hostname', '-I'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) out, err = p.communicate() if out: ip_address = out else: ip_address = "<Not Set> def ssid_discovered(): Cells = Cell.all('wlan0') wifi_info = 'Ssid encontrado: \n' for current in range(len(Cells)): wifi_info += Cells[current].ssid + "\n" wifi_info+"!" print wifi_info return wifi_info def handle_client(client_sock): # obter ssid client_sock.send(ssid_discovered()) print "Aguardando SSID..." ssid = client_sock.recv(1024) if ssid == '': return print "SSID recebido" print ssid # obter psk client_sock.send("waiting-psk!") print "Aguardando PSK..." psk = client_sock.recv(1024) if psk == '': return print "PSK recebido" print psk ip_address = wifi_connect(ssid, psk) print "endereço IP: " + ip_address client_sock.send("endereço IP:" + ip_address + "!") return try: while True: server_sock=BluetoothSocket( RFCOMM ) ​​server_sock.bind(("",PORT_ANY)) server_sock.listen(1) port = server_sock.getsockname()[1] uuid = "815425a5-bfac-47bf-9321-c5ff980b5e11" advertise_service( server_sock, "Configuração de Wi-Fi do RPi", service_id = uuid, service_classes = [ uuid, SERIAL_PORT_CLASS ], profiles = [ SERIAL_PORT_PROFILE ]) print "Aguardando conexão no canal RFCOMM %d" % port client_sock, client_info = server_sock.accept() print "Conexão aceita de ", client_info handle_client(client_sock) client_sock.close() server_sock.close() # configuração finalizada print 'Configuração finalizada\n' except (KeyboardInterrupt, SystemExit): print '\nSaindo\n'

5. Após a etapa anterior, é hora de tornar o script executável, concedendo as permissões necessárias:

$ chmod +x run.py

Para executar:

$ sudo ./run.py

6. Neste ponto, abra o aplicativo Android e selecione o Raspberry Pi nos dispositivos Bluetooth emparelhados. Insira o SSID , a PSK e toque no Iniciar Configuração . Em poucos segundos, o Wi-Fi do Raspberry Pi deverá estar conectado, como mostrado nas imagens abaixo.

7. Para executar o script durante o processo de inicialização do Raspberry Pi, edite o arquivo /etc/rc.local e adicione a seguinte linha de código:

(dormir 10;/caminho/para/script/./run.py)&

3. Configuração do sensor DHT22 - Hardware

1. Estabeleça as conexões adequadas, conforme mostrado no diagrama abaixo:

4. Configuração do sensor DHT22 - Software

1. Instale os pacotes necessários executando os seguintes comandos:

$ sudo apt-get update

$ sudo apt-get install build-essential python-dev python-openssl git

2. Carregue a biblioteca dos sensores. No meu caso, utilizo uma biblioteca pré-compilada da Adafruit que suporta uma variedade de sensores:

$ git clone https://github.com/adafruit/Adafruit_Python_DHT.git && cd Adafruit_Python_DHT

3. Com a biblioteca já carregada, execute o comando abaixo para criar uma biblioteca Python que permita a integração fácil para este e outros projetos.

$sudo python setup.py install

4. Se tudo correr bem, poderemos ler a temperatura e a umidade. A maneira mais fácil é usar primeiro os arquivos de demonstração já disponíveis no nosso Raspberry Pi:

$ exemplos de cd

5. Execute o seguinte código de exemplo. Onde o primeiro parâmetro (11) indica qual sensor foi usado (22 para o DHT22) e o segundo, a qual GPIO ele está conectado (não o número do pino, mas o número do GPIO). Isso produz uma saída como a seguinte:

$ sudo ./AdafruitDHT.py 11 4

Resultado esperado:

$ sudo ./AdafruitDHT.py 11 4 Temp=24.0* Umidade=41.0%

5. Envio de dados para Ubidots

1. Crie um script em Python usando o editor nano e cole o código abaixo no terminal. Para fazer isso, insira o seguinte comando:

$ sudo nano ubidots3.py

Código-fonte:

import time import requests import math import random import sys import Adafruit_DHT sensor = 22 # Selecione a versão do seu DHT pin = 18 # Insira o PIN do seu DHT22 TOKEN = "…" # Insira seu TOKEN aqui DEVICE_LABEL = "Raspberrypi" # Insira o rótulo do seu dispositivo aqui VARIABLE_LABEL_1 = "temperature" # Insira o rótulo da sua primeira variável aqui VARIABLE_LABEL_2 = "humidity" # Insira o rótulo da sua segunda variável aqui # Tente obter uma leitura do sensor. Use o método read_retry, que tentará até 15 vezes para obter uma leitura do sensor (aguardando 2 segundos entre cada tentativa). humidity, temperature = Adafruit_DHT.read_retry(sensor, pin) # Descomente a linha abaixo para converter a temperatura para Fahrenheit. # temperatura = temperatura * 9/5.0 + 32 # Observe que às vezes você não obterá uma leitura e # os resultados serão nulos (porque o Linux não pode # garantir o tempo das chamadas para ler o sensor). # Se isso acontecer, tente novamente! def build_payload(variable_1, variable_2): # Cria dois valores aleatórios para o envio de dados value_1 = temperatura value_2 = umidade payload = {variable_1: value_1, variable_2: value_2, } return payload def post_request(payload): # Cria os cabeçalhos para as requisições HTTP url = "ubidots" url = "{}/api/v1.6/devices/{}".format(url, DEVICE_LABEL) headers = {"X-Auth-Token": TOKEN, "Content-Type": "application/json"} # Faz as requisições HTTP status = 400 attempts = 0 while status >= 400 and attempts <= 5: req = requests.post(url=url, headers=headers, json=payload) status = req.status_code attempts += 1 time.sleep(1) # Processa os resultados se status >= 400: print("[ERRO] Não foi possível enviar dados após 5 tentativas. Verifique suas credenciais de token e sua conexão com a internet") return False print("[INFO] Requisição feita corretamente, seu dispositivo está atualizado") return True def main(): payload = build_payload( VARIABLE_LABEL_1, VARIABLE_LABEL_2) print("[INFO] Tentando enviar dados") post_request(payload) print("[INFO] Concluído") if __name__ == '__main__': while (True): print('Temp={0:0.1f}* Humidity={1:0.1f}%'.format(temperature, humidity)) humidity, temperature = Adafruit_DHT.read_retry(sensor, pin) main() time.sleep(1) ```

Após colar o código-fonte, você precisa atribuir o TOKEN Ubidots onde indicado no script Python:

$ sudo nano ubidots3.py

2. Agora que tudo está configurado, você pode executar o código de exemplo para começar a transmitir dados para sua conta Ubidots :

$ sudo python ubidots3.py

Neste ponto, se você consultar a seção de dispositivos da sua conta Ubidots , poderá ver um novo dispositivo criado com o nome “RaspberryPi”.

3. Para visualizar seus dados de forma eficiente, vamos configurar um Dashboard do Ubidots . Para criá-lo, acesse a Dashboard (Dados > Dashboard ).

4. Em seguida, clique em “ Adicionar novo widget ” e selecione o widget desejado:

5. Selecione a variável que deseja exibir:

6. Dê um nome personalizado ao widget e pressione o ícone verde para concluir a criação do widget.

Agora você pode monitorar variáveis ​​remotamente de qualquer lugar graças à plataforma de desenvolvimento de aplicativos IoT Ubidots :

Artigos recomendados:

Escrito por Ammar Chauhan

Chauhan é Engenheiro de Ciência da Computação, com mais de 2 anos de experiência trabalhando com sistemas de computação baseados em IoT das Coisas) e eletrônica DIY (faça você mesmo), além de ser apaixonado por projetos de IA (Inteligência Artificial), DIP (Processamento Dinâmico de Informação) e ML (Aprendizado de Máquina).