Configure o Wi-Fi do Raspberry Pi via Bluetooth para enviar dados para Ubidots
Pelo menos uma vez na sua vida você teve dificuldade em configurar as credenciais de Wi-Fi de um Raspberry Pi só porque não tinha um monitor com você no momento.
Neste guia, descreverei como configurar um Raspberry Pi com um AP (ponto de acesso), que pode ser feito por meio de um aplicativo Android portátil. Não é possível conectar um cabo Ethernet só porque você está em um novo local? Não se preocupe - Após seguir este guia, você poderá usar seu Pi em qualquer local, bastando apenas escanear a rede, escolher a rede desejada para estabelecer a conexão, escrever as credenciais e você está conectado!
Implantei uma ferramenta simples que permite definir o SSID e PSK do Raspberry pi Wi-Fi através da comunicação Bluetooth. No momento, é super básico – você só precisa emparelhar previamente seu telefone Android com o Raspberry Pi e eu escrevi um aplicativo Android básico.
Pessoalmente, acho que isso é muito útil para quem está por aí com seu Raspberry Pi, transportando-o de uma oficina para outra, levando-o de casa para a escola, além de todos os casos possíveis que você tem em mente neste momento... Agora, sem discutir mais, vamos começar a construir coisas legais, começando com a instalação do script python que vai rodar em nosso Raspberry Pi.
Requisitos
- Raspberry pi (qualquer Raspberry pi com Wi-Fi)
- Cartão Micro SD carregado com sistema operacional Raspbian
- Telefone Android com sistema operacional 4.2 Jelly Bean
- Arquivo APK e script de execução python
Passo a passo
- Configurando o Bluetooth do Raspberry Pi
- Emparelhando Raspberry Pi e telefone Android
- Configurando o sensor DHT22 – Hardware
- Configurando o sensor DHT22 – Software
- Envio/visualização de dados para Ubidots
1. Configurando o Bluetooth do Raspberry Pi
No início você precisará de um monitor + teclado conectado, alternativamente acessar o Raspberry Pi via SSH apenas para poder estabelecer todas as configurações necessárias através do Terminal Raspbian.
Execute os comandos abaixo com cuidado para estabelecer as configurações adequadas:
- Instale o bluez (biblioteca Bluetooth do Python):
$ sudo apt-get install python-bluez
2. Inicie o daemon Bluetooth em modo de compatibilidade. Para fazer isso, edite /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 parâmetro 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 seu Pi:
$ sudo reiniciar
Após a reinicialização, vamos emparelhar o Bluetooth com nosso telefone Android
2. Emparelhamento Raspberry Pi e telefone Android.
1. Emparelhe seu telefone Android com seu Raspberry Pi. Para fazer isso, ligue o bluetooth do seu telefone e execute o comando abaixo no seu Pi:
$ bluetoothctl
Então, assim que o processo de emparelhamento começar, insira os seguintes parâmetros. (Consulte a imagem para ter uma ideia melhor do processo de fluxo)
ligar detectável ao digitalizar
Neste ponto, seu telefone aparecerá na lista de dispositivos disponíveis. Anote o endereço do seu telefone.
confiar<PHONE_ADDRESS> par<PHONE_ADDRESS>
2. Para apenas sair do bluetooth ctl, escreva o comando quit:
$ sair
3. [OPCIONAL – DICA PRO] Você pode pular a configuração acima, configurando o Bluetooth com UI do Raspbian. Basta pressionar o ícone 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 copie/cole 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 no 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 reconfigurar' cmd_result = os.system (cmd) imprimir cmd + " - " + str(cmd_result) time.sleep(10) cmd = 'iwconfig wlan0' cmd_result = os.system(cmd) imprimir 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> " return ip_address def ssid_discovered(): Cells = Cell.all('wlan0') wifi_info = 'Found ssid : \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): # get ssid client_sock.send(ssid_discovered()) print "Aguardando SSID..." ssid = client_sock.recv(1024) if ssid == ' ': return print "ssid recebido" print ssid # get 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 "ip address: " + ip_address client_sock.send("ip-address:" + 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" promote_service( server_sock, "RPi Wifi config" , service_id = uuid, service_classes = [ uuid, SERIAL_PORT_CLASS ], profiles = [ SERIAL_PORT_PROFILE ]) print "Aguardando conexão no canal RFCOMM %d" % porta 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' exceto (KeyboardInterrupt, SystemExit): print '\nSaindo\n'
5. Após a etapa acima, é 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 raspberrypi nos dispositivos Bluetooth emparelhados. Insira o SSID , PSK e clique no Iniciar configuração . Em alguns segundos o Wi-Fi do Raspberry Pi deverá estar conectado, conforme mostrado nas imagens abaixo.
7. Para executar o script durante o processo de inicialização do pi, edite /etc/rc.local e adicione a seguinte linha de código:
(dormir 10;/caminho/para/script/./run.py)&
3. Configurando o Sensor DHT22 - Hardware
1. Estabeleça as conexões adequadas, conforme mostrado no diagrama abaixo:
4. Configurando o Sensor DHT22 - Software
1. Instale os pacotes necessários executando os seguintes comandos:
$ sudo apt-get atualização
$ sudo apt-get install build-essential python-dev python-openssl git
2. Carregue a biblioteca dos sensores. No meu caso, uso uma biblioteca Adafruit pré-construída 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 fazer a integração facilmente para este e outros projetos.
$ sudo python setup.py instalar
4. Se tudo funcionar corretamente, poderemos ler a temperatura e a umidade. A maneira mais fácil é primeiro usar os arquivos de demonstração já disponíveis em nosso Pi:
exemplos de $ cd
5. Execute o código de exemplo a seguir. Onde o primeiro parâmetro (11) indica qual sensor foi utilizado (22 para o DHT22) e o segundo, a qual GPIO ele está conectado (não o número do pino, mas sim 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 python usando o editor nano e cole o código abaixo no terminal. Para fazer isso, insira o seguinte comando:
$ sudo nano ubidots 3.py
Código fonte:
tempo de importação solicitações de importação importação matemática importação aleatória importação sys importação Adafruit_DHT sensor = 22 #Selecione o pino da versão DHT = 18 #Insira seu Pin do DHT22 TOKEN = "…" # Coloque seu TOKEN aqui DEVICE_LABEL = "Raspberrypi" # Coloque a etiqueta do seu dispositivo aqui VARIABLE_LABEL_1 = "temperatura" # Coloque o rótulo da primeira variável aqui VARIABLE_LABEL_2 = "umidade" # Coloque o rótulo da segunda variável aqui # Tente obter uma leitura do sensor. Use o método read_retry que tentará novamente de # a 15 vezes para obter uma leitura do sensor (aguardando 2 segundos entre cada nova tentativa). umidade, temperatura = Adafruit_DHT.read_retry(sensor, pin) # Remova o comentário da 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(variável_1, variável_2): # Cria dois valores aleatórios para enviar dados valor_1 = temperatura valor_2 = umidade payload = {variável_1: valor_1, variável_2: valor_2, } return payload def post_request(payload): # Cria os cabeçalhos para as solicitações HTTP url = "http://industrial.api. ubidots .com" url = "{}/api/v1.6/devices/{}".format(url, DEVICE_LABEL) headers = {"X-Auth-Token": TOKEN, "Content-Type": "application/json"} # Faz com que as solicitações HTTP tenham status = 400 tentativas = 0 enquanto status >= 400 e tentativas <= 5: req = requests.post(url=url, headers=headers, json=payload) status = req.status_code tentativas += 1 time.sleep(1) # Processa resultados se status >= 400: print("[ERROR] Não foi possível enviar dados após 5 tentativas, verifique \ suas credenciais de token e internet conexão") return False print("[INFO] solicitaçã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( carga útil) print("[INFO] finalizado") if __name__ == '__main__': while (True): print('Temp={0:0.1f}* Umidade={1:0.1f}%'.format(temperatura , umidade)) umidade, temperatura = Adafruit_DHT.read_retry(sensor, pino) main() time.sleep(1) ```
Após colar o código fonte, você deve atribuir o Ubidots TOKEN onde está indicado no script python:
$ sudo nano ubidots 3.py
2. Agora com tudo configurado, você pode executar o código de exemplo para começar a transmitir dados para sua conta Ubidots :
$ sudo python ubidots 3.py
Neste ponto, se você consultar a seção de dispositivos da sua conta Ubidots poderá ver um novo dispositivo criado chamado “RaspberryPi”.
3. Para visualizar seus dados de forma eficiente, vamos configurar um Dashboard do Ubidots . Para criá-lo, vá para a seção Dashboard Dashboard )
4. Em seguida, pressione “ Adicionar novo widget ” e selecione seu widget:
5. Selecione a variável que deseja exibir:
6. Dê um nome personalizado ao widget e pressione o ícone verde para finalizar a criação do widget.
Agora você pode monitorar variáveis remotamente de qualquer local graças à plataforma de desenvolvimento de aplicativos IoT Ubidots :
Artigos recomendados:
