Application Android/iOS pour accéder à distance à votre routeur OpenWrt : 11 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

J'ai récemment acheté un nouveau routeur (Xiaomi Mi Router 3G). Et bien sûr, ce nouveau matériel génial m'a inspiré pour commencer à travailler sur ce projet;)

Étape 1: Je suppose que vous avez déjà OpenWrt…

Je devais d'abord installer OpenWrt… La plupart du temps, j'ai suivi ce guide (spécifique à ce modèle de routeur): https://dzone.com/articles/hacking-into-xiaomi-mi-… En travaillant là-dessus, j'ai trouvé cette vidéo géniale: Installation Openwrt, benchmark WiFi, Girlfriend Flashing. Wow j'ai tellement ri !:)

Attention! L'installation d'OpenWrt peut briquer votre routeur. Mais une fois terminé, il débloque toute la puissance et le contrôle. Je ne suis pas assez courageux pour fournir des instructions ici, car elles peuvent être différentes pour chaque modèle de routeur.

Mais si vous avez déjà OpenWrt sur votre routeur, vous pourrez commencer ce didacticiel en un rien de temps

BTW, certaines cartes de développement sont livrées avec OpenWrt prêt à l'emploi, comme Onion Omega, VoCore, LinkIt Smart 7688 et d'autres. Ce didacticiel explique également quelques idées de base derrière la création de telles applications, afin que vous puissiez facilement l'adapter pour fonctionner avec Raspberry Pi et autres.

Pour ce projet, j'utiliserai principalement un logiciel pré-installé (disponible sur n'importe quel routeur compatible OpenWrt). Mais pour certaines fonctionnalités avancées, j'ai dû installer des packages supplémentaires. Cela se fait en quelques clics, je vais donc inclure les instructions ici.

Aussi, je suppose que vous connaissez déjà:

• Comment ouvrir/utiliser le terminal SSH sur votre routeur OpenWrt
• Comment télécharger/modifier des fichiers sur votre routeur (utilisez FileZilla ou scp/sftp)
• Comment travailler avec la console Linux

Étape 2: Logiciels et outils

Côté smartphone, j'utilise Blynk. Il fournit des applications iOS et Android pour contrôler n'importe quel matériel. Vous pouvez facilement créer de belles interfaces graphiques pour tous vos projets en glissant-déposant simplement des widgets, directement sur votre smartphone. Blynk est principalement utilisé avec Arduino, Raspberry Pi, etc. Mais pourquoi ne pas l'exécuter sur le routeur lui-même ?;)

Du côté de l'appareil, j'utiliserai Lua pour scripter les fonctionnalités nécessaires. Je pourrais également utiliser Python ou Node.js, mais malheureusement ces options ne sont pas toujours disponibles, en raison du manque de ressources sur certains routeurs. Ou C/C++, mais ce n'est pas si pratique de travailler avec (recompiler pour chaque changement, etc.) D'un autre côté, Lua est pré-installé, est simple à utiliser et à apprendre. Il est utilisé par l'interface Web par défaut, LuCI.

Étape 3: Création d'une application minimale

Commencer avec Blynk et Lua est aussi simple que:

• Téléchargez l'application Blynk (depuis l'App Store, Google Play)
• Créez un nouveau projet et obtenez le jeton d'authentification
• Suivez les instructions d'installation de Blynk Lua pour OpenWrt.

Utilisez SSH pour accéder à la console de votre routeur. Après avoir exécuté l'exemple par défaut:

lua./exemples/client.lua

Nous devrions voir quelque chose comme ceci:

De liaison…

Poignée de main SSL… Prêt.

Ce qui signifie que la connexion sécurisée et bidirectionnelle à l'application est établie ! YAY !

Nous pouvons maintenant facilement étendre l'exemple fourni, afin qu'il fasse quelque chose d'intéressant. J'ai créé une copie de cet exemple pour le modifier:

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

Étape 4: Ajout d'informations: nombre de clients, adresse IP WAN, temps de disponibilité

L'idée de base est d'obtenir périodiquement les informations du système d'exploitation, d'effectuer des calculs simples si nécessaire, puis d'envoyer le résultat à Blynk pour affichage.

Sous Linux/OpenWrt, nous avons plusieurs manières d'obtenir les données système:

• Exécutez une commande et analysez le texte qu'elle génère
• Exécutez une commande et regardez le code de sortie qu'elle renvoie
• Lire un fichier système, situé dans les répertoires /proc/ et /sys/class/

Maintenant, je veux afficher le nombre d'appareils connectés.

Lorsque j'exécute cat /proc/net/arp sur la console, il affiche la liste des périphériques connus, ainsi que leurs adresses MAC et IP:

Adresse IP Type HW Drapeaux Adresse HW Masque Périphérique

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

On peut l'analyser directement dans Lua, mais il est souvent plus simple d'utiliser des utilitaires spécialisés. Sous Linux, ce sont grep, head, tail, cut, wc, awk.

Pour obtenir le nombre de clients à partir de la sortie arp, je dois filtrer la table (supprimer les éléments non liés) et compter les lignes de la table, ce qui donne la commande suivante:

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

Essayons:

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

1

Super. Nous avons maintenant une idée de la façon dont nous pouvons collecter toutes les informations requises. Automatisons-le. Pour rendre notre code propre et extensible, créons quelques fonctions d'assistance:

fonction exec_out(cmd)

fichier local = io.popen(cmd) sinon fichier alors retourne nil end local output = file:read('*all') file:close() print("Run: "..cmd.." -> ".. output) return output end function read_file(path) local file = io.open(path, "rb") sinon file then return nil end local content = file:read "*a" file:close() print("Read: "..path.." -> "..content) renvoie le contenu fin

En utilisant ces utilitaires, nous pouvons maintenant implémenter les fonctions réelles de récupération de données:

fonction 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

Vous pouvez exécuter des parties de ces commandes shell pour mieux comprendre son fonctionnement et l'adapter à vos besoins.

La partie la plus simple consiste à envoyer les données à l'application Blynk. L'exemple par défaut configure déjà le minuteur, qui exécute du code toutes les 5 secondes, nous le réutilisons donc:

local tmr1 = Timer:new{interval = 5000, func = function()

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

Dans l'application, nous ajoutons 3 widgets d'étiquette et les attribuons aux broches virtuelles 10, 11, 12 en conséquence.

Bien que cela fonctionne, c'est plutôt inefficace, car l'IP WAN ou le nombre de clients ne sont pas mis à jour aussi fréquemment. Corrigons ce problème

Pour l'IP WAN, nous la déplaçons vers le gestionnaire connecté. Il sera exécuté chaque fois que le routeur établira une connexion à Blynk Cloud. Cela devrait suffire:

blynk:on("connecté", fonction()

print("Prêt.") blynk:virtualWrite(12, getWanIP()) end)

Pour la disponibilité et le nombre de clients, nous créons une minuterie séparée avec 5 min. intervalle:

local tmr2 = Timer:new{interval = 5*60*1000, func = function()

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

Étape 5: Contrôle WiFi: ON/OFF

Jusqu'à présent, nous ne recevions que quelques informations de l'appareil. Essayons de le contrôler !

blynk:on("V20", fonction(param)

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

Côté application, je viens d'ajouter un widget Button (mode: Switch) et de l'affecter à V20.

C'est ça. Incroyable.

Étape 6: Graphique des statistiques du système

fonction 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 ' {imprimer (3 $ à 7 $)/2 $ * 100,0}'")) fin

Nous devons également envoyer les données à Blynk (utilisons à nouveau tmr1):

local tmr1 = Timer:new{interval = 5000, func = function()

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

Du côté de l'application, ajoutez le widget SuperChart. Ajoutez des flux de données CPU, RAM et attribuez-les à V5, V6.

Étape 7: État de rotation du disque dur

Mon routeur dispose d'un lecteur de disque dur externe connecté en tant que périphérique de stockage en réseau. Le fait est que ce lecteur est configuré pour commencer à tourner lorsque quelqu'un y accède et pour se suspendre après un délai d'attente.

Évidemment, ce serait cool de savoir combien de fois il s'allume au cours d'une journée. J'ai donc ajouté un autre flux de données à mon graphique système.

C'est un peu plus compliqué d'obtenir l'état du disque dur, mais j'ai trouvé un moyen ! Tout d'abord, installez smartmontools depuis la console SSH:

mise à jour opkg

opkg installer smartmontools

Ensuite, dans notre code, nous devons exécuter une commande spéciale et vérifier le code de sortie:

fonction 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 then return 1 else return 0 end end

Remarque: mon disque dur est /dev/sda

Étape 8: Graphique d'activité du réseau

Nous créons un autre widget SuperChart (similaire au précédent), ajoutons des flux de données TX et RX et attribuons à V1 et V2. Remarque: je souhaite afficher la statc du port WAN et mon port WAN est eth0.2

Fonctions d'assistance:

fonction 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")) finir

Ensuite, ajoutez du code au même tmr1. C'est plus compliqué, car il suffit de calculer et d'afficher la différence en octets transmis/reçus:

local prevTx, prevRx

local tmr1 = Timer:new{interval = 5000, func = function() local tx = getWanTxBytes() local rx = getWanRxBytes() if prevTx et prevTx ~= tx then blynk:virtualWrite(1, tx - prevTx) end if prevRx et prevRx ~= rx then blynk:virtualWrite(2, rx - prevRx) end prevTx = tx prevRx = rx blynk:virtualWrite(5, getCpuLoad()) blynk:virtualWrite(6, getRamUsage()) blynk:virtualWrite(7, getHddSpinning(getHddSpining))) finir}

Étape 9: Notifications

Je voulais également être averti lorsque mon routeur perd de l'alimentation ou de la connexion Internet. Pour cela, nous avons besoin d'un widget de notification.

Dans les paramètres du widget, activez la "notification hors ligne". Aucun code nécessaire. Mais nous pouvons également envoyer des notifications personnalisées à partir de notre code.

Étape 10: Exécution automatique en arrière-plan

Pour l'instant, le script doit être exécuté manuellement, mais je souhaite qu'il s'exécute automatiquement en arrière-plan lors de la mise sous tension du routeur.

Cela se fait en créant un service. Créez un fichier /etc/init.d/blynkmon:

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

START=99 STOP= pidfile="/var/run/blynkmon.pid" start() { if [-f $pidfile]; puis echo "blynkmon déjà en cours d'exécution" exit 0 fi cd /root/lua-blynk lua blynkmon.lua your-auth-token > /dev/null & echo $! > $pidfile } stop() { if [! -f $pidfile]; then echo "blynkmon ne fonctionne pas" exit 0 fi kill -9 $(cat $pidfile) rm $pidfile }

Remarque: n'oubliez pas de remplacer votre-auth-token

Ensuite, activez le service blynkmon:

service blynkmon activer

Étape 11: Conclusion et idées supplémentaires

Vous pouvez scanner ce QR pour obtenir le clone de mon projet Blynk. Il nécessite quelques points d'énergie (4600), car il utilise beaucoup de widgets !

Trouvez le code Lua complet ici:

Jusqu'ici tout va bien, mais voici quelques idées que j'aimerais ajouter dans un proche avenir.

• Ajouter une commande de redémarrage. Empêchez de cliquer dessus accidentellement.
• Ajoutez un widget Terminal pour exécuter n'importe quelle commande Linux.

• Ajouter un graphique de température du processeur.

  UPD: Malheureusement, OpenWrt manque actuellement de certains pilotes pour mon modèle de routeur. Mais il est disponible pour de nombreux autres routeurs

• Ajoutez une notification lorsqu'un périphérique particulier rejoint / quitte le réseau. Nous avons déjà des informations sur l'arp, vérifiez maintenant uniquement l'adresse MAC.

De cette façon, nous pouvons surveiller et contrôler des imprimantes 3D, des robots, un PC/ordinateur portable ordinaire, des éléments Arduino/ESP8266/ESP32/RaspberryPi, des appareils Smart Home et pratiquement tout ce qui se trouve autour. Faites-moi savoir si vous avez d'autres idées intéressantes. Que pensez-vous de tout cela ?