Aplicativo Android / iOS para acessar seu roteador OpenWrt remotamente: 11 etapas

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

Recentemente, comprei um novo roteador (Xiaomi Mi Router 3G). E, claro, esse novo e incrível hardware me inspirou a começar a trabalhar neste projeto;)

Etapa 1: Presumo que você já tenha o OpenWrt…

Tive que instalar o OpenWrt primeiro … Principalmente, segui este guia (específico para este modelo de roteador): https://dzone.com/articles/hacking-into-xiaomi-mi-… Enquanto trabalhava nisso, achei este vídeo incrível: Instalação Openwrt, benchmark WiFi, Girlfriend Flashing. Wow, eu ri tanto!:)

Atenção! A instalação do OpenWrt pode bloquear seu roteador. Mas, uma vez concluído, ele desbloqueia total poder e controle. Não tenho coragem de fornecer quaisquer instruções aqui, pois elas podem ser diferentes para cada modelo de roteador.

Mas se você já tem o OpenWrt em seu roteador, poderá começar com este tutorial em tempo

A propósito, algumas placas de desenvolvimento vêm com OpenWrt pronto para uso, como Onion Omega, VoCore, LinkIt Smart 7688 e outros. Este tutorial também explica algumas idéias básicas por trás da criação de tais aplicativos, para que você possa adaptá-lo facilmente para funcionar com Raspberry Pi e similares.

Para este projeto, usarei principalmente software pré-instalado (disponível em qualquer roteador habilitado para OpenWrt). Mas para algumas funcionalidades avançadas, tive que instalar pacotes adicionais. Isso é feito com apenas alguns cliques, então incluirei as instruções aqui.

Além disso, presumo que você já saiba:

• Como abrir / usar o terminal SSH para seu roteador OpenWrt
• Como fazer upload / editar arquivos em seu roteador (use FileZilla ou scp / sftp)
• Como trabalhar com console Linux

Etapa 2: Software e Ferramentas

No lado do smartphone, estou usando o Blynk. Ele fornece aplicativos iOS e Android para controlar qualquer hardware. Você pode facilmente construir lindas interfaces gráficas para todos os seus projetos simplesmente arrastando e soltando widgets, direto no seu smartphone. Blynk é usado principalmente com Arduino, Raspberry Pi, etc. Mas por que não executá-lo no próprio roteador?;)

No lado do dispositivo, estarei usando Lua para fazer o script da funcionalidade necessária. Eu também poderia usar Python ou Node.js, mas infelizmente essas opções nem sempre estão disponíveis, devido à falta de recursos em alguns roteadores. Ou C / C ++, mas não é tão conveniente de trabalhar (recompilar a cada mudança, etc.) Por outro lado, Lua vem pré-instalado, é simples de usar e aprender. É usado pela interface da web padrão, LuCI.

Etapa 3: Criação de um aplicativo mínimo

Começar com Blynk e Lua é tão fácil quanto:

• Baixe o aplicativo Blynk (na App Store, Google Play)
• Crie um novo projeto e obtenha o token de autenticação
• Siga as instruções de instalação do Blynk Lua para OpenWrt.

Use SSH para acessar o console do seu roteador. Depois de executar o exemplo padrão:

lua./examples/client.lua

Devemos ver algo assim:

Conectando…

Handshake SSL … Pronto.

O que significa que a conexão segura e bidirecional com o aplicativo foi estabelecida!

Agora podemos estender facilmente o exemplo fornecido, para que ele faça algo interessante. Criei uma cópia deste exemplo para editá-lo:

cp./examples/client.lua./blynkmon.lua

Etapa 4: Adicionar algumas informações: número de clientes, endereço IP WAN, tempo de atividade

A ideia básica é obter as informações do sistema operacional periodicamente, realizar alguns cálculos simples, se necessário, e enviar o resultado para Blynk para exibição.

No Linux / OpenWrt, temos várias maneiras de obter os dados do sistema:

• Execute um comando e analise o texto que ele produz
• Execute um comando e observe o código de saída que ele retorna
• Leia um arquivo de sistema, localizado nos diretórios / proc / e / sys / class /

Agora quero exibir o número de dispositivos conectados.

Quando executo cat / proc / net / arp no console, ele exibe a lista de dispositivos conhecidos, junto com seus endereços MAC e IP:

Endereço IP tipo HW Sinalizadores endereço HW Máscara Dispositivo

192.168.10.206 0x1 0x2 78: 02: f8: fb: d6: bf * br-lan 194.---------- 0x1 0x2 4c: 5e: 0c: 14: e0: 5c * eth0.2 192,168.10.162 0x1 0x0 04: b1: 67: 2f: e3: 74 * br-lan

Podemos analisá-lo diretamente em Lua, mas geralmente é mais fácil usar utilitários especializados. No Linux, são grep, head, tail, cut, wc, awk.

Para obter o número de clientes da saída arp, preciso filtrar a tabela (remover itens não relacionados) e contar as linhas da tabela, o que resulta no seguinte comando:

cat / proc / net / arp | grep br-lan | grep 0x2 | wc -l

Vamos tentar:

root @ roteador: ~ / lua-blynk # cat / proc / net / arp | grep br-lan | grep 0x2 | wc -l

1

Excelente. Agora temos uma ideia de como podemos coletar todas as informações necessárias. Vamos automatizar isso. Para tornar nosso código limpo e extensível, vamos criar algumas funções auxiliares:

função exec_out (cmd)

arquivo local = io.popen (cmd) se não for arquivo, então retorna nil end saída local = arquivo: ler ('* todos') arquivo: close () print ("Executar:"..cmd.. "->".. output) return output end function read_file (path) local file = io.open (path, "rb") se não for file então retorna nil end local content = file: read "* a" file: close () print ("Read: "..path.." -> "..content) return content end

Usando esses utilitários, agora podemos implementar as funções reais de busca de dados:

function getArpClients ()

return tonumber (exec_out ("cat / proc / net / arp | grep br-lan | grep 0x2 | wc -l")) end function getUptime () return tonumber (exec_out ("cat / proc / uptime | awk '{print $ 1 } '")) end function getWanIP () return exec_out (" ifconfig eth0.2 | grep' inet addr: '| cut -d: -f2 | awk' {print $ 1} '") end

Você pode executar partes desses comandos shell para obter uma compreensão mais profunda de como eles funcionam e ajustá-los às suas necessidades.

A parte mais fácil é enviar os dados para o aplicativo Blynk. O exemplo padrão já configura o cronômetro, que executa algum código a cada 5 segundos, então apenas o reutilizamos:

local tmr1 = Timer: novo {intervalo = 5000, func = função ()

blynk: virtualWrite (10, getArpClients ()) blynk: virtualWrite (11, string.format ("%. 1f h", getUptime () / 60/60)) blynk: virtualWrite (12, getWanIP ()) end}

No aplicativo, adicionamos 3 widgets de rótulo e os atribuímos aos pinos virtuais 10, 11, 12 de acordo.

Embora funcione, é bastante ineficiente, já que o IP WAN ou o número de clientes não são atualizados com tanta frequência. Vamos consertar isso

Para WAN IP, nós o movemos para o manipulador conectado. Ele será executado sempre que o roteador estabelecer conexão com a nuvem Blynk. Isso deve ser suficiente:

blynk: on ("conectado", função ()

print ("Pronto.") blynk: virtualWrite (12, getWanIP ()) end)

Para Uptime e Número de clientes, criamos um cronômetro separado com 5 min. intervalo:

local tmr2 = Timer: novo {intervalo = 5 * 60 * 1000, func = função ()

blynk: virtualWrite (10, getArpClients ()) blynk: virtualWrite (11, string.format ("%. 1f h", getUptime () / 60/60)) end}

Etapa 5: Controle de WiFi: LIGADO / DESLIGADO

Até agora, estávamos apenas obtendo algumas informações do dispositivo. Vamos tentar controlá-lo!

blynk: on ("V20", função (param)

if param [1] == "1" then os.execute ("wifi up") else os.execute ("wifi down") end end)

No lado do aplicativo, acabei de adicionar um widget de botão (modo: Switch) e atribuí-lo ao V20.

É isso. Surpreendente.

Etapa 6: gráfico de estatísticas do sistema

function getCpuLoad ()

return tonumber (exec_out ("top -bn1 | grep 'CPU:' | head -n1 | awk '{print $ 2 + $ 4}'")) end function getRamUsage () return tonumber (exec_out ("free | grep Mem | awk ' {imprimir ($ 3- $ 7) / $ 2 * 100,0} '")) fim

Também precisamos enviar os dados para Blynk (vamos usar tmr1 novamente):

local tmr1 = Timer: novo {intervalo = 5000, func = função ()

blynk: virtualWrite (5, getCpuLoad ()) blynk: virtualWrite (6, getRamUsage ()) end}

No lado do aplicativo, adicione o widget SuperChart. Adicione CPU, fluxos de dados de RAM e atribua a V5, V6.

Etapa 7: Status de rotação do HDD

Meu roteador tem uma unidade HDD externa conectada como um dispositivo de armazenamento conectado à rede. O fato é que esta unidade está configurada para começar a girar quando alguém a acessa e para suspender após um tempo limite.

Obviamente, seria legal saber quantas vezes ele liga ao longo do dia. Então, adicionei outro fluxo de dados ao meu gráfico do sistema.

É um pouco mais complicado obter o status da unidade de disco rígido, mas encontrei um jeito! Em primeiro lugar, instale o smartmontools a partir do console SSH:

atualização de opkg

opkg install smartmontools

Então, em nosso código, precisamos executar um comando especial e verificar o código de saída:

função exec_ret (cmd)

local exit = os.execute (cmd) print ("Run:"..cmd.. "-> exit:".. exit) return exit end function getHddSpinning () if exec_ret ("smartctl --nocheck = standby --info / dev / sda> / dev / null ") == 0 então retorna 1 senão retorna 0 fim fim

Nota: meu HDD é / dev / sda

Etapa 8: Gráfico de atividades da rede

Criamos outro widget SuperChart (semelhante ao anterior), adicionamos fluxos de dados TX e RX e atribuímos a V1 e V2. Nota: Eu quero exibir o statc da porta WAN e minha porta WAN é eth0.2

Funções auxiliares:

function getWanRxBytes ()

return tonumber (read_file ("/ sys / class / net / eth0.2 / statistics / rx_bytes")) end function getWanTxBytes () return tonumber (read_file ("/ sys / class / net / eth0.2 / statistics / tx_bytes")) fim

Em seguida, adicione algum código ao mesmo tmr1. Isso é mais complicado, pois só precisamos calcular e exibir a diferença em bytes transmitidos / recebidos:

prevTx local, prevRx

local tmr1 = Timer: new {interval = 5000, func = function () local tx = getWanTxBytes () local rx = getWanRxBytes () se prevTx e prevTx ~ = tx then blynk: virtualWrite (1, tx - prevTx) end se prevRx e prevRx ~ = rx then blynk: virtualWrite (2, rx - prevRx) end prevTx = tx prevRx = rx blynk: virtualWrite (5, getCpuLoad ()) blynk: virtualWrite (6, getRamUsage ()) blynk: virtualWrite (7, getHdlynSpinning (7, getHdlynSpinning)) fim}

Etapa 9: Notificações

Também gostaria de ser notificado quando meu roteador perder energia ou conexão com a Internet. Para isso, precisamos do widget Notificação.

Nas configurações do widget, habilite "notificação offline". Nenhum código necessário. Mas também podemos enviar notificações personalizadas de nosso código.

Etapa 10: Execução automática em segundo plano

Por enquanto, o script deve ser executado manualmente, mas quero que seja executado em segundo plano automaticamente quando o roteador for ligado.

Isso é feito criando um serviço. Crie um arquivo /etc/init.d/blynkmon:

#! / bin / sh /etc/rc.common

START = 99 STOP = pidfile = "/ var / run / blynkmon.pid" start () {if [-f $ pidfile]; então echo "blynkmon já em execução" exit 0 fi cd / root / lua-blynk lua blynkmon.lua your-auth-token> / dev / null & echo $! > $ pidfile} stop () {if [! -f $ pidfile]; em seguida, echo "blynkmon não está executando" exit 0 fi kill -9 $ (cat $ pidfile) rm $ pidfile}

Observação: não se esqueça de substituir seu token de autenticação

Em seguida, ative o serviço blynkmon:

habilitar serviço blynkmon

Etapa 11: Conclusão e outras ideias

Você pode escanear este QR para obter o clone do meu Projeto Blynk. Requer alguns pontos de energia (4600), pois usa muitos widgets!

Encontre o código Lua completo aqui:

Até aqui tudo bem, mas aqui estão algumas idéias que eu gostaria de adicionar em um futuro próximo.

• Adicione o comando de reinicialização. Evite clicar nele acidentalmente.
• Adicione o widget Terminal para executar qualquer comando do Linux.

• Adicionar gráfico de temperatura da CPU.

  UPD: Infelizmente, o OpenWrt não possui alguns drivers para o modelo do meu roteador. Mas está disponível para muitos outros roteadores

• Adicione uma notificação quando um determinado dispositivo entrar / sair da rede. Já temos informações do arp, agora verifique apenas o endereço MAC.

Dessa forma, podemos monitorar e controlar impressoras 3D, robôs, um PC / laptop comum, coisas do Arduino / ESP8266 / ESP32 / RaspberryPi, dispositivos Smart Home e praticamente qualquer coisa ao redor. Avise-me se tiver alguma outra ideia interessante. O que você acha de tudo isso?