Alerte précoce Raspberry PI Runway Light utilisant les données de cartographie de vol : 14 étapes (avec photos)

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

Cette lampe est née de plusieurs raisons en ce sens que je suis toujours intéressé par les avions qui survolent et pendant l'été le week-end, il y en a souvent des assez excitants qui volent autour. Bien que vous n'ayez tendance à les entendre qu'au fur et à mesure qu'ils passent. Ensuite, l'autre raison est qu'il semble que la trajectoire de vol des avions au départ de l'aéroport de London City sera parfois entendue et qu'ils ont des vols assez bruyants. Étant donné que je m'essaie à enregistrer des vidéos pour YouTube, il est vraiment ennuyeux de devoir supprimer un enregistrement à cause d'un avion bruyant. Je me suis donc demandé si les données que vous voyez sur des sites comme flightradar24 sont accessibles au public, une fois que j'ai découvert que quelque chose de similaire était disponible sur le réseau opensky, le voyant d'alerte précoce est né. Il n'a pas fallu trop de temps pour avoir l'idée d'utiliser une réplique d'un phare de piste pour abriter le projet.

Vous pouvez en savoir plus sur The OpenSky Network sur https://www.opensky-network.org Je voulais aussi cette fois-ci faire une belle lentille en résine au lieu d'utiliser du PLA translucide et bien que j'aie un récepteur ADS-B que je voulais garder ce simple et pas cher. L'ADS-B a également besoin d'une antenne et cela ne suffirait pas pour qu'une lampe aille sur l'étagère du bureau. J'espère donc que vous trouverez la construction intéressante car elle couvre également l'impression 3D, le moulage de résine et les mathématiques pour extrapoler les positions des avions qui pourraient potentiellement passer au-dessus de votre tête.

Étape 1: Conception du boîtier

La recherche Google propose de nombreuses conceptions différentes de lampes de piste et la conception de celle-ci a été réalisée en utilisant des influences de conception de nombreuses marques différentes de vraies lampes. Il est également dimensionné pour s'asseoir dans une pièce ou sur une étagère plutôt qu'en taille réelle, car ils ont tendance à être beaucoup plus grands dans la vraie vie.

Les conceptions ont été élaborées dans Fusion 360 et j'ai importé des éléments précédents tels que le support raspberry pi zero de projets précédents. Pouvoir réutiliser des éléments prend beaucoup de maux de tête pour obtenir les bases. Vous pouvez également télécharger les fichiers ici

Étape 2: Couler les lentilles - #fail

L'élément de conception le plus important de cette lampe allait être la lentille. J'ai donc abordé cela en premier car sans un beau miroir authentique, le projet allait fonctionner. Je documente ici les échecs que j'ai eus en essayant d'y parvenir, même si j'ai également initialement décidé de rendre l'objectif ambré. Les feux de piste sont à la fois ambre et bleu et ce n'est qu'après avoir commencé à faire l'ambre que j'ai changé d'avis et décidé que je voulais un bleu.

D'après ce que je peux comprendre, les oranges sont utilisés sur la ligne d'attente et les bleus sont utilisés pour aligner la piste, et ce sont ceux qui semblent être les plus archétypiques trouvés si vous recherchez des feux de piste. Cependant, voici ma première tentative de fabrication d'une lentille ambrée. Pour fabriquer la lentille, j'allais utiliser de la résine transparente avec un additif de couleur, et bien que j'aie déjà fait quelques moules, je me demandais s'il serait possible d'imprimer un moule 3D et de l'utiliser. J'ai donc commencé par fabriquer un moule fendu en 3D et l'imprimer en PetG. Des quantités judicieuses de démoulage, j'en étais convaincu, seraient suffisantes pour éliminer le moule. Il s'avère qu'avec quelques tentatives, j'ai fait coller la résine au moule comme de la colle et il ne semblait tout simplement pas possible de les séparer. Bien que j'avais celui à grande échelle que j'allais utiliser, j'ai décidé de ne pas l'utiliser et j'ai imprimé l'objectif à utiliser avec un moulage en silicone traditionnel.

Étape 3: Différents types de résine

En passant, j'ai utilisé 3 types de résines claires/colorées pour ce projet.

Le premier était un type de marché Hobby appelé Pebeo - Gedeo et est normalement vendu pour encapsuler de petits objets et utilisé pour les bijoux et les presse-papiers de bureau, etc. Cela a plutôt bien fonctionné et a bien durci en environ 24 à 36 heures. C'est cependant assez cher pour le montant que vous obtenez, mais c'est pratique et facilement disponible dans les magasins de loisirs et d'artisanat. Il est mélangé à un ratio de 2:1. La seconde était une résine pré-colorée qui est mélangée à un rapport de 10:1 avec le durcisseur et cela a pris le plus de temps à durcir, environ une semaine pour être honnête avant qu'elle ne soit complètement durcie. La dernière était une résine transparente, qui a également été mélangée dans le rapport 2:1 et qui a durci en environ 2 jours, vous pouvez la colorer avec des gouttes de pigment, mais vous devez vous assurer que vous utilisez toujours le même rapport de couleur si vous font des lots séparés. Il fonctionne également le plus rentable. Enfin, le RTV pour le moule était un GP-3481 RTV et cela prend environ 24 heures à mettre et a un temps de pot assez long, vous avez donc tout le temps de le mélanger puis de le verser.

Pour l'instant je n'ai pas de pot à vide (actuellement en commande) de sorte que vous pouvez être assailli par des bulles à la fois dans le moule et dans le coulage de la résine. Ce n'est pas trop un problème pour cela, mais avec une lentille transparente ou similaire, vous devriez penser à un moyen d'éliminer les bulles des mélanges.

Étape 4: Couler la lentille dans le moule en silicone #2

Il s'agit donc de la deuxième tentative de fabrication d'un objectif en résine et la première étape consistait à fabriquer à la fois un objectif dans Fusion 360, puis à l'imprimer en ABS ainsi qu'un seau pour le maintenir. Ce serait le premier pour le moule et aide à réduire la quantité de silicone à utiliser. Vous pouvez facilement le faire en carton, mais c'est juste une approche différente. Pour lui donner une meilleure chance de sortir du moule je l'ai d'abord verni puis lui ai donné une bonne couche d'agent de démoulage de cire.

J'ai ensuite versé du GP-3481 qui correspond à environ 27 Shore RTV et je l'ai ensuite laissé reposer pendant les 24 heures suivantes avant de démouler. Une fois cela fait, j'ai utilisé la résine transparente mélangée à un rapport de 2: 1 avec environ 4/5 gouttes de pigment de couleur et l'ai bien mélangée pendant quatre bonnes minutes. J'ai versé cela dans le moule, puis j'ai placé un verre à liqueur dans la résine pour créer un vide plus tard pour une lampe ou les LED. Après environ 24 heures, cette résine était prête à être retirée et la lentille s'en sortait plutôt bien. Il y a des bulles d'air présentes, mais je n'ai pas encore d'enceinte à vide pour dégazer la résine avant de la verser.

Étape 5: Impression 3D et préparation

Le modèle a été conçu de manière à ce que la section centrale se branche sur la base. C'était pour éviter le masquage pendant le processus de peinture. L'ensemble du modèle a été imprimé en Hatchbox ABS puis poncé. Commencer avec un grain 60 jusqu'à un grain environ 800 a donné une finition de surface assez bonne pour ce modèle.

Étape 6: Assemblage et peinture

Une fois les impressions poncées, elles ont ensuite été peintes avec un apprêt à haute résistance. Légèrement poncé puis pulvérisé en apprêt gris. Les pièces principales ont été peintes en jaune signal Ford, puis en vert brooklands utilisé pour la base. des reflets d'argent tamiya ont ensuite été appliqués sur les boulons et du chrome argent molotow utilisé sur le support d'objectif.

Étape 7: Trouvez d'abord des avions dans une zone de délimitation

Une fois le matériel trié, il fallait travailler sur le logiciel. Il existe maintenant quelques sites qui fournissent le suivi des vols, mais peu d'entre eux fournissent une API pour accéder à ces données. Certains qui le font ne le font que sur une base commerciale, mais heureusement, il existe un site appelé https://opensky-network.org que vous pouvez utiliser gratuitement.

Pour accéder à ces données, vous devez vous inscrire et vous pouvez ensuite utiliser leur API, elle fournit plusieurs fonctions et façons d'extraire les données. Nous sommes intéressés par tous les vols dans une zone et ils ont un appel API Live pour cela. https://opensky-network.org/apidoc/ appelé cadre de délimitation. L'appel API nécessite les coins de la boîte qui vous intéressent avec bien sûr notre Lat/Lon comme point central. Vous pouvez vérifier que les mathématiques fonctionnent sur ce site, qui dessine une boîte en fonction de ce que vous tapez. https://tools.geofabrik.de mais pour l'instant, le script suivant donne les points dont nous avons besoin pour nous connecter à l'API.

fonction get_bounding_box($latitude_in_degrees, $longitude_in_degrees, $half_side_in_miles){ $half_side_in_km = $half_side_in_miles * 1.609344; $lat = deg2rad($latitude_en_degrés); $lon = deg2rad($longitude_en_degrés); $rayon = 6371; $rayon_parallèle = $rayon*cos($lat); $lat_min = $lat - $half_side_in_km/$radius; $lat_max = $lat + $half_side_in_km/$radius; $lon_min = $lon - $half_side_in_km/$parallel_radius; $lon_max = $lon + $half_side_in_km/$parallel_radius; $box_lat_min = rad2deg($lat_min); $box_lon_min = rad2deg($lon_min); $box_lat_max = rad2deg($lat_max); $box_lon_max = rad2deg($lon_max); return array($box_lat_min, $box_lon_min, $box_lat_max, $box_lon_max);

Si vous voulez tester votre code, il existe un site où vous pouvez entrer la latitude/longitude et voir les résultats sur une carte:Voir un exemple de cadre de délimitation sur une carte

Étape 8: Calcul du cap des avions par rapport à nous

Les résultats de l'appel API de la boîte englobante nous donnent une liste d'avions, leur Lon/lat, leur vitesse, leur altitude et leur cap. Donc, la prochaine chose que nous devons faire est d'obtenir le cap de chaque avion par rapport à nous afin que nous puissions traiter davantage ceux qui se dirigent au moins dans notre direction générale. Nous pouvons le faire car nous connaissons notre position et pouvons calculer l'angle entre nous et chaque plan.

Pour ce faire j'utilise un bout de code qui était à l'origine en Javascript donc je l'ai converti ici en PHP, * calculer le relèvement (initial) entre deux points * * à partir de: Ed Williams' Aviation Formulary, https://williams.best.vwh.net/avform.htm#Crs * source = instantglobe.com/CRANES/GeoCoordTool.html */ fonction get_bearing($home_lat, $home_lon, $plane_lat, $plane_lon) { $lat1 = deg2rad($home_lat); $lat2 = deg2rad($plane_lat);

$dLon = deg2rad($plane_lon-$home_lon);

$y = sin($dLon) * cos($lat2);

$x = cos($lat1)*sin($lat2) - sin($lat1)*cos($lat2)*cos($dLon); $z = atan2($y, $x); $zz = (rad2deg($z) +360)% 360; renvoie $zz;

Si vous voulez regarder la page où se trouvent les versions javascript originales, voici le lien:

dans ce code, vous pouvez également voir les différentes sous-routines pour chaque type de calcul.

Étape 9: Calcul d'une interception en regardant un cercle

Nous avons donc maintenant un avion dont le relèvement entre lui et notre emplacement est inférieur à 90 (soit positif, soit négatif) et cela signifie donc qu'il y a une chance qu'il puisse voler à proximité. En utilisant la formule de Haversine, nous pouvons également calculer en utilisant le Lon/Lat de l'avion et le Lon/Lat de notre maison la distance qui nous sépare de nous.

En regardant le diagramme, si nous dessinons un cercle autour de notre maison d'un rayon d'environ 3 miles, cela nous donne une chance de voir quoi que ce soit survoler. Nous connaissons la différence de cap entre l'avion et nous, nous connaissons également la distance de l'avion par rapport à nous afin que nous puissions ensuite calculer le triangle en utilisant le bon vieux SOHCAHTOA, et dans ce cas en utilisant le Tan de l'angle nous pouvons obtenir le longueur du côté opposé. Donc, si nous comparons cette valeur à la valeur du rayon du cercle autour de la maison, nous pouvons alors découvrir si l'avion volera suffisamment près pour que nous puissions le voir. La prochaine étape que nous pouvons faire est de déterminer le temps que l'avion passera en utilisant la vitesse de l'air et la distance et si cela est inférieur à environ 45 secondes, nous allumons la lumière. C'est un peu le code que j'utilise pour calculer les chances d'un survol. Je le fais car il y a un aéroport à proximité et lorsque les avions circulent, ils pointent inévitablement vers la maison. Cependant, comme leur altitude est nulle et que la vitesse correspond au rythme de marche, cela ne devrait pas déclencher l'alarme.

fonction get_intercept($home_head, $plane_head, $plane_distance) {

$flight_angle = abs(abs($home_head - $plane_head) - 180); $flight_angle_r = deg2rad($flight_angle); $flight_angle_t = tan($flight_angle_r); $flight_intercept = $flight_angle_t * $plane_distance;

if (($flight_angle<90) && ($flight_intercept<3)){ // possible survol

}

renvoie $flight_intercept;

}

Étape 10: Distance entre deux points sur une carte - Formule Haversine

Nous devons donc calculer la distance entre l'avion et notre emplacement. Sur de courtes distances sur une carte, vous pouvez calculer approximativement la distance, mais comme la terre est sphérique, il existe une formule appelée formule de haversine qui vous permet de prendre en considération la surface courbe. Vous pouvez lire plus loin dans la formule:

Maintenant, avec la distance calculée et nous connaissons la vitesse de l'avion, nous pouvons déterminer combien de secondes il faudra avant que l'avion ne passe au-dessus de nous. Ainsi, le voyant s'allumera s'il y a quelque chose dans les 30 secondes suivant le survol et nous avons enfin notre voyant d'avertissement.

* basé sur 0n JS sur instantglobe.com/CRANES/GeoCoordTool.html et transformé en PHP */

function get_distHaversine ($home_lat, $home_lon, $plane_lat, $plane_lon) { $R = 6371; // rayon moyen de la Terre en km $dLat = deg2rad($plane_lat-$home_lat); $dLon = deg2rad($plane_lon-$home_lon); $lat1 = deg2rad($home_lat); $lat2 = deg2rad($plane_lat);

$a = sin($dLat/2) * sin($dLat/2) + cos($lat1) * cos($lat2) * sin($dLon/2) * sin($dLon/2);

$c = 2 * atan2(sqrt($a), sqrt(1-$a)); $d = $R * $c; renvoie $d; }

Étape 11: Importation et définition de la base de données de plans

L'un des autres éléments est que le site opensky propose une base de données téléchargeable d'avions avec leurs indicatifs et leurs identifiants. Ses plusieurs centaines de milliers d'entrées. Nous pouvons donc le télécharger et le charger localement dans une base de données MariaDB pour la recherche (MySQL). Avec chaque avion qui apparaît au-dessus de nous, nous récupérons ses détails et mettons à jour un compteur pour montrer combien de fois il a été vu.

Je suis également en train d'éditer la base de données pour mettre en évidence les avions qui m'intéressent. Principalement de vieux warbirds et d'autres avions similaires intéressants. À quelques reprises cet été, un MiG-15 a survolé. le but est donc d'utiliser un champ d'alerte que j'ai ajouté, puis de faire clignoter la lumière rapidement lorsque quelque chose d'intéressant se dirige vers

Étape 12: Améliorer les résultats et les nouvelles fonctionnalités

Donc en théorie tout fonctionne plutôt bien, mais vous constaterez avec les données qu'il y a des avions qui survolent qui n'apparaissent pas dans l'API.

En effet, tous les avions n'utilisent pas le transpondeur ADS-B et utilisent des transpondeurs plus anciens basés sur MLAT. Pour obtenir des données de position sur les avions à l'aide de MLAT, il faut une série de récepteurs au sol pour trianguler leur position et certains sites comme flightradar24 ont un plus grand réseau de contributeurs qui le font par rapport à Opensky. J'espère qu'avec le temps, leur couverture s'améliorera également et je suis en train de configurer mon propre récepteur MLAT pour ajouter à ces données.

Étape 13: Base de code

N'oubliez pas que si vous allez l'utiliser, vous voudrez peut-être supprimer les instructions SQL si vous n'avez pas la base de données des avions et ajouter également votre propre valeur Lon/Lat et votre clé API pour accéder aux données de vol.

github.com/ajax-jones/runway-light-awacs

define("INTERVALLE", (20 * 1)); function fexp() { $lat = "votre latitude"; $lon = "votre longitude"; côté $ = 15,75; $box = get_bounding_box($lat, $lon, $side); $latmin = $box[0]; $lonmin = $box[1]; $latmax = $boîte[2]; $lonmax = $box[3]; $flyurl = "https://opensky-network.org/api/states/all?lamin=$latmin&lomin=$lonmin&lamax=$latmax&lomax=$lonmax"; echo "Scanner le CIEL"; $start_time = microtime(true); $json = file_get_contents($flyurl); $data = json_decode($json, TRUE); $entrant = FAUX; $num_planes = count($data['states']); if ($num_planes >0) { echo " et nous pouvons voir $num_planes avions\n "; for ($x =0; $x 0) { $plane_eta = $distplane/$air_speed_kmh; } else { $eta = 1; } if ((($intercept)0)) && ($distplane0){ $inbound = TRUE; écho "------------------------------------------------ --------------------\n"; echo "$icao24 - [$country $callsign] à [$geo_altitude_m M -- $geo_altitude_f ft] "; echo "[vitesse $air_speed_kmh kmh and ", round($distplane, 1), "km away]\n"; echo "[sur un cap de ", round($plane_heading, 1), "] [homeangle $heading_d] "; echo "[$latitude, $longitude]\n"; echo "[flypast in ", decimal_to_time($plane_eta), " now ", round($intercept, 1), "km away\n"; écho "------------------------------------------------ --------------------\n"; $DBi = new mysqli("127.0.0.1", "root", "votre mot de passe", "awacs"); $sql = "select * from Aircraftdatabase where `icao24`='$icao24'"; mysqli_set_charset($DBi, "utf8"); $getplanedata = mysqli_query($DBi, $sql) ou die(mysqli_error($DBi)); $row_getplanedata = mysqli_fetch_assoc($getplanedata); $rows_getplanedata = mysqli_num_rows($getplanedata); if($rows_getplanedata>0) { do { echo "callsign="; echo $row_getplanedata['registration']; echo " est un "; echo $row_getplanedata['nom du fabricant']; écho " "; echo $row_getplanedata['model']; echo " par "; echo $row_getplanedata['manufacturericao']; echo " appartenant à "; echo $row_getplanedata['owner']; echo " vu "; echo $row_getplanedata['visites']; echo " fois "; echo " note spéciale="; echo $row_getplanedata['special']; echo "\n"; $visits = $row_getplanedata['visits']+1; } while ($row_getplanedata = mysqli_fetch_assoc($getplanedata)); mysqli_free_result($getplanedata); $sqli = "UPDATE Aircraftdatabase SET visites = $visits WHERE icao24 = '$icao24'"; mysqli_set_charset($DBi, "utf8"); $updateplanedata = mysqli_query($DBi, $sqli) ou die(mysqli_error($DBi)); } else { echo "Impossible de trouver cet avion dans la base de données donc en l'ajoutant"; $sqli = "INSERT INTO Aircraftdatabase (icao24, visites, special) VALUES ('$icao24', 1, 1)"; $updateplanedata = mysqli_query($DBi, $sqli) ou die(mysqli_error($DBi)); } écho "----------------------------------------------- ---------------------\n"; } else { // echo "$callsign "; } } } else { echo " et le ciel est dégagé\n "; } if ($inbound) { echo "Inbound plane\n"; $commande = "cochons w 17 1"; execInBackground($commande); } else { echo "pas de vols entrants\n"; $commande = "cochons w 17 0"; execInBackground($commande); } } function decimal_to_time($decimal) { $offset = 0.002778; if ($décimal>$offset) { $décimal = $décimal - 0,002778; } $heures = gmdate('H', étage($décimal * 3600)); $minutes = gmdate('i', floor($décimal * 3600)); $secondes = gmdate('s', floor($decimal * 3600)); return str_pad($hours, 2, "0", STR_PAD_LEFT). ":". str_pad($minutes, 2, "0", STR_PAD_LEFT). ":". str_pad($secondes, 2, "0", STR_PAD_LEFT); } /* * calcule le relèvement (initial) entre deux points * * à partir de: Aviation Formulary d'Ed Williams, https://williams.best.vwh.net/avform.htm#Crs * source = instantglobe.com/CRANES/GeoCoordTool. html */ function get_bearing($home_lat, $home_lon, $plane_lat, $plane_lon) { $lat1 = deg2rad($home_lat); $lat2 = deg2rad($plane_lat); $dLon = deg2rad($plane_lon-$home_lon); $y = sin($dLon) * cos($lat2); $x = cos($lat1)*sin($lat2) - sin($lat1)*cos($lat2)*cos($dLon); $z = atan2($y, $x); $zz = (rad2deg($z) +360)% 360; renvoie $zz; } fonction get_intercept($home_head, $plane_head, $plane_distance) { $flight_angle = abs(abs($home_head - $plane_head) - 180); $flight_angle_r = deg2rad($flight_angle); $flight_angle_t = tan($flight_angle_r); $flight_intercept = $flight_angle_t * $plane_distance; renvoie $flight_intercept; } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* * Utilisez la formule Haversine pour calculer la distance (en km) entre deux points spécifiés par * latitude/longitude (en degrés numériques) * * à partir de: formule Haversine - RWSinnott, "Vertus of the Haversine", * Sky and Telescope, vol 68, no 2, 1984 * https://williams.best.vwh.net/avform.htm#Crs * * exemple d'utilisation du formulaire: * result.value = LatLon.distHaversine(lat1.value.parseDeg(), long1.value.parseDeg(), * lat2.value.parseDeg(), long2.value.parseDeg()); * où lat1, long1, lat2, long2 et result sont des champs de formulaire * source = instantglobe.com/CRANES/GeoCoordTool.html */ function get_distHaversine ($home_lat, $home_lon, $plane_lat, $plane_lon) { $R = 6371; // rayon moyen de la Terre en km $dLat = deg2rad($plane_lat-$home_lat); $dLon = deg2rad($plane_lon-$home_lon); $lat1 = deg2rad($home_lat); $lat2 = deg2rad($plane_lat); $a = sin($dLat/2) * sin($dLat/2) + cos($lat1) * cos($lat2) * sin($dLon/2) * sin($dLon/2); $c = 2 * atan2(sqrt($a), sqrt(1-$a)); $d = $R * $c; renvoie $d; } fonction get_bounding_box($latitude_in_degrees, $longitude_in_degrees, $half_side_in_miles){ $half_side_in_km = $half_side_in_miles * 1.609344; $lat = deg2rad($latitude_en_degrés); $lon = deg2rad($longitude_en_degrés); $rayon = 6371; # Rayon du parallèle à latitude donnée; $rayon_parallèle = $rayon*cos($lat); $lat_min = $lat - $half_side_in_km/$radius; $lat_max = $lat + $half_side_in_km/$radius; $lon_min = $lon - $half_side_in_km/$parallel_radius; $lon_max = $lon + $half_side_in_km/$parallel_radius; $box_lat_min = rad2deg($lat_min); $box_lon_min = rad2deg($lon_min); $box_lat_max = rad2deg($lat_max); $box_lon_max = rad2deg($lon_max); return array($box_lat_min, $box_lon_min, $box_lat_max, $box_lon_max); } function execInBackground($cmd) { if (substr(php_uname(), 0, 7) == "Windows"){ pclose(popen("start /B ". $cmd, "r")); } else { exec($cmd. " > /dev/null &"); } } function checkForStopFlag() { // complètement facultatif return(TRUE); } function start() { echo "démarrage\n"; $commande = "cochons w 17 1"; execInBackground($commande); $actif = VRAI; while($actif) { usleep(1000); // facultatif, si vous voulez être prévenant if (microtime(true) >= $nextTime) { fexp(); $nextTime = microtime(true) + INTERVALLE; } $active = checkForStopFlag(); } } fexp(); début(); ?>

Étape 14: Câblage de la LED et de l'interrupteur d'arrêt

Le câblage de ce projet ne pourrait pas être plus simple vraiment. Il n'y a qu'une seule LED connectée à la broche 17 et à la terre avec une résistance 270R en ligne.

J'inclus également un bouton d'arrêt et de mise sous tension ainsi qu'un voyant d'alimentation qui s'exécute sur la broche de données TXd. Vous pouvez en savoir plus sur la fonction d'arrêt et le code requis sur https://github.com/Howchoo/pi-power-button.git sur le site https://howchoo.com/g/mwnlytk3zmm/how-to- add-a-pow… Vous pouvez en savoir plus sur l'ajout d'un voyant d'alimentation ici