Preallarme Raspberry PI Runway Light utilizzando i dati di mappatura di volo: 14 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:02

Questa lampada è nata da diversi motivi in quanto sono sempre interessato agli aerei che sorvolano e durante l'estate nei fine settimana spesso ne volano alcuni piuttosto eccitanti. Anche se tendi a sentirli solo mentre passano. Quindi l'altro motivo è che sembra che la traiettoria di volo per gli aerei in partenza dall'aeroporto di London City a volte venga ascoltata e che hanno alcuni voli piuttosto rumorosi in corso. Mentre mi diletto a registrare alcuni video per YouTube, è davvero fastidioso dover scartare una registrazione a causa di un aereo rumoroso. Quindi mi sono chiesto se i dati che vedi su siti come flightradar24 sono disponibili pubblicamente, una volta scoperto che qualcosa di simile era disponibile dalla rete opensky è nata la spia di allarme rapido. Non ci è voluto molto tempo per poi venire con l'idea di utilizzare una replica di una luce di pista per ospitare il progetto.

Puoi scoprire di più su The OpenSky Network su https://www.opensky-network.org Anche questa volta volevo realizzare una bella lente in resina invece di usare PLA traslucido e anche se ho un ricevitore ADS-B volevo mantenere questo semplice ed economico. L'ADS-B ha anche bisogno di un'antenna e questo non farebbe per una lampada da mettere sullo scaffale dell'ufficio. Quindi si spera che troverai la build interessante in quanto copre la stampa 3D, lo stampaggio in resina e la matematica, nonché per estrapolare le posizioni degli aerei che potenzialmente potrebbero passare sopra la testa.

Passaggio 1: progettazione della custodia

La ricerca su Google fornisce molti modelli diversi di lampade da passerella e il design di questa è stato realizzato utilizzando le influenze del design di molte marche diverse di lampade reali. È anche ridimensionato per sedersi in una stanza o su uno scaffale piuttosto che a grandezza naturale, poiché tendono ad essere molto più grandi nella vita reale.

I progetti sono stati elaborati in Fusion 360 e ho importato alcuni elementi precedenti come il supporto raspberry pi zero da progetti precedenti. Essere in grado di riutilizzare gli elementi elimina molto il mal di testa per ottenere le nozioni di base. Puoi anche scaricare i file qui

Passaggio 2: lanciare le lenti - #fail

L'elemento di design più importante di questa lampada sarebbe stato l'obiettivo. Quindi ho affrontato questo prima come senza un bell'autentico specchio il progetto avrebbe funzionato. Sto documentando qui gli errori che ho avuto nel tentativo di ottenere ciò, nonostante inizialmente avessi anche deciso di rendere l'obiettivo ambra. Le luci della pista sono sia ambra che blu ed è stato solo dopo aver iniziato a fare quella ambra che ho cambiato idea e ho deciso che ne volevo una blu.

Da quello che posso capire, quelli color ambra sono usati sulla linea di attesa e quelli blu sono usati per allineare la pista, e questi sono quelli che sembrano essere i più archetipici che si trovano se si cercano le luci della pista. Tuttavia, ecco il mio primo tentativo di realizzare una lente ambrata. Per realizzare l'obiettivo, avrei usato resina trasparente con un additivo colorato e, sebbene avessi già fatto alcuni stampi prima, mi chiedevo se sarebbe stato possibile stampare uno stampo 3D e usarlo. Così ho iniziato creando uno stampo diviso in 3D e stampandolo in PetG. Ero convinto che una quantità ragionevole di rilascio di muffa sarebbe stata sufficiente per eliminare la muffa. A quanto pare con il paio di tentativi ho fatto aderire la resina allo stampo come colla e non mi sembrava possibile separarli. Anche se avevo quello in scala reale che stavo per usare, ho deciso di non farlo e ho stampato l'obiettivo da utilizzare con la tradizionale modellatura in silicone.

Passaggio 3: diversi tipi di resina

Per inciso, ho usato 3 tipi di resine trasparenti/colorate per questo progetto.

Il primo era un tipo di mercato Hobby chiamato Pebeo - Gedeo ed è normalmente venduto per incapsulare piccoli oggetti e utilizzato per gioielli e fermacarte da scrivania, ecc. Ha funzionato abbastanza bene e si è indurito bene in circa 24-36 ore. È comunque piuttosto costoso per l'importo che ottieni, ma è pratico e facilmente reperibile nei negozi di hobby e artigianato. È miscelato con un rapporto 2:1. La seconda era una resina pre-colorata che viene miscelata in un rapporto di 10:1 con l'indurente e questo ha richiesto più tempo per indurire, circa una settimana a dire il vero prima che si fosse completamente indurito. L'ultima era una resina trasparente, anch'essa miscelata nel rapporto 2:1 e che polimerizzava in circa 2 giorni, puoi colorarla con gocce di pigmento, ma devi assicurarti di usare sempre lo stesso rapporto di colore se stanno facendo lotti separati. Funziona anche il più conveniente. Infine, l'RTV per lo stampo era un GP-3481 RTV e questo richiede circa 24 ore per essere impostato e ha un tempo di cottura piuttosto lungo, quindi hai tutto il tempo per mescolarlo e poi versarlo.

Al momento non ho un vaso sottovuoto (attualmente in ordinazione) in modo da poter essere assalito da bolle sia nello stampo che nel versamento della resina. Non è un grosso problema per questo, ma con una lente chiara o simile, dovresti pensare a un modo per far uscire le bolle dai mix.

Passaggio 4: fusione della lente nello stampo in silicone n. 2

Quindi questo è il secondo tentativo di realizzare un obiettivo in resina e il primo passo è stato quello di realizzare sia un obiettivo in Fusion 360 e quindi stamparlo in ABS sia un secchio per tenerlo. Questo sarebbe il primo per lo stampo e aiuta a mantenere bassa la quantità di silicone da utilizzare. Puoi facilmente farlo con la carta, ma è solo un approccio diverso. Per dargli una migliore possibilità di staccarsi dallo stampo l'ho prima verniciato e poi gli ho dato una buona copertura di distaccante ceroso.

Ho quindi versato un po' di GP-3481 che è circa Shore 27 RTV e poi l'ho lasciato riposare nelle 24 ore successive prima di sformarlo. Fatto ciò ho utilizzato la resina trasparente miscelata in rapporto 2:1 con circa 4/5 gocce di pigmento colorato e mescolata bene per ben quattro minuti. Ho versato questo nello stampo e poi ho inserito anche un bicchierino nella resina per fornire un vuoto in seguito per una lampada o per i LED. Dopo circa 24 ore questa resina era pronta per essere rimossa e la lente è venuta abbastanza bene. Sono presenti bolle d'aria, ma al momento non ho un recipiente a vuoto per degassare la resina prima di versarla.

Passaggio 5: stampa 3D e preparazione

Il modello è stato progettato in modo che la sezione centrale si inserisca nella base. Questo per evitare il mascheramento durante il processo di verniciatura. L'intero modello è stato stampato in Hatchbox ABS e poi carteggiato. A partire da una grana 60 fino a circa 800 grana ha dato una finitura superficiale abbastanza buona per questo modello.

Passaggio 6: assemblaggio e verniciatura

Una volta che le stampe sono state carteggiate, è stato poi dipinto con un primer ad alto spessore. Leggermente carteggiato e poi spruzzato in primer grigio. Le parti principali sono state dipinte in giallo segnale Ford, e poi in verde Brooklands utilizzato per la base. i punti salienti dell'argento tamiya sono stati quindi applicati ai bulloni e del cromo argento molotow utilizzato sul supporto dell'obiettivo.

Passaggio 7: prima trova i piani all'interno di un'area di delimitazione

Con l'hardware ordinato, il software doveva essere lavorato. Ora ci sono un paio di siti che forniscono il monitoraggio dei voli, ma non molti che forniscono un'API per accedere a tali dati. Alcuni che lo fanno, lo fanno solo su base commerciale, ma fortunatamente c'è un sito chiamato https://opensky-network.org che puoi usare gratuitamente.

Per accedere a questi dati devi registrarti e quindi puoi utilizzare la loro API, fornisce diverse funzioni e modi per estrarre i dati. Siamo interessati a tutti i voli all'interno di un'area e hanno una chiamata API Live per questo. https://opensky-network.org/apidoc/ chiamato riquadro di delimitazione. La chiamata API richiede gli angoli della casella che ti interessano con ovviamente il nostro Lat/Lon come punto centrale. Puoi controllare la matematica funziona su questo sito, che disegna una casella a seconda di ciò che scrivi. https://tools.geofabrik.de ma per ora lo script seguente fornisce i punti di cui abbiamo bisogno per collegare l'API.

function 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_in_degrees); $lon = deg2rad($longitude_in_degrees); $raggio = 6371; $raggio_parallelo = $raggio*cos($lat); $lat_min = $lat - $half_side_in_km/$raggio; $lat_max = $lat + $half_side_in_km/$raggio; $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);

Se vuoi testare il tuo codice, c'è un sito dove puoi inserire lat/lon e vedere i risultati su una mappa: Vedi un esempio di riquadro di delimitazione su una mappa

Passaggio 8: calcolo della rotta degli aerei in relazione a noi

I risultati della chiamata API del riquadro di delimitazione ci danno un elenco di aerei, il loro Lon/lat, velocità, altitudine e direzione. Quindi la prossima cosa che dobbiamo fare è ottenere la rotta di ciascun aereo in relazione a noi in modo da poter elaborare ulteriormente quelli che si stanno almeno dirigendo nella nostra direzione generale. Possiamo farlo poiché conosciamo la nostra posizione e possiamo calcolare l'angolo da noi a ciascun piano.

Per farlo uso un pezzo di codice che originariamente era in Javascript, quindi l'ho convertito qui in PHP, * calcola il rilevamento (iniziale) tra due punti * * da: Aviation Formulary di Ed Williams, https://williams.best.vwh.net/avform.htm#Crs * source = instantglobe.com/CRANES/GeoCoordTool.html */ funzione get_cuscinetto($lat_di_casa, $lat_di_casa, $lat_di_piano, $lat_di_pianta) { $lat1 = deg2rad($lat_di_casa); $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; restituire $zz;

Se vuoi guardare la pagina dove si trovano le versioni javascript originali, questo è il link:

all'interno di quel codice, puoi anche vedere le varie sottoroutine per ogni tipo di calcolo.

Passaggio 9: calcolo di un'intercetta osservando un cerchio

Quindi ora abbiamo un aereo in cui il rilevamento tra esso e la nostra posizione è inferiore a 90 (positivo o negativo) e quindi questo significa che c'è una possibilità che possa volare nelle vicinanze. Usando la formula di haversine possiamo anche calcolare usando il Lon/Lat dell'aereo e il Lon/Lat della nostra casa la distanza che è lontana da noi.

Guardando il diagramma, se disegniamo un cerchio intorno alla nostra casa di circa 3 miglia di raggio, questo ci dà la possibilità di vedere qualcosa che sorvola. Conosciamo la differenza di rotta tra l'aereo e noi, conosciamo anche la distanza dell'aereo da noi così possiamo poi calcolare il triangolo usando il buon vecchio SOHCAHTOA, e in questo caso usando il Tan dell'angolo possiamo ottenere il lunghezza del lato opposto. Quindi, se confrontiamo questo valore con il valore del raggio del cerchio intorno alla casa, possiamo scoprire se l'aereo volerà abbastanza vicino da consentirci di vederlo. Il prossimo passo che possiamo fare è calcolare il tempo che l'aereo sorvolerà usando la velocità dell'aria e la distanza e se questo è inferiore a circa 45 secondi, accendiamo la luce. Questo è un po' del codice che uso per calcolare la possibilità di un sorvolo. Lo faccio perché c'è un aeroporto vicino e quando gli aerei sono in rullaggio, inevitabilmente puntano verso la casa. Tuttavia, poiché la loro altitudine è zero e la velocità è a passo d'uomo, questo non dovrebbe far scattare l'allarme.

function get_intercept($home_head, $plane_head, $plane_distanza) {

$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)){ // possibile sorvolare

}

return $intercetta_volo;

}

Passaggio 10: distanza tra due punti su una mappa - Formula di Haversine

Quindi dobbiamo calcolare la distanza tra l'aereo e la nostra posizione. Su brevi distanze su una mappa è possibile calcolare approssimativamente la distanza, ma poiché la terra è sferica, esiste una formula chiamata formula di haversine che consente di prendere in considerazione la superficie curva. Puoi leggere ulteriormente nella formula:

Ora con la distanza calcolata e conosciamo la velocità dell'aereo possiamo calcolare quanti secondi passeranno prima che l'aereo sia sopra la testa. Quindi la luce si accenderà se c'è qualcosa entro 30 secondi dal passaggio aereo e finalmente avremo la nostra spia di avvertimento.

* basato 0n JS su instantglobe.com/CRANES/GeoCoordTool.html e trasformato in PHP */

function get_distHaversine ($home_lat, $home_lon, $plane_lat, $plane_lon) { $R = 6371; // raggio medio terrestre in 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; restituire $d; }

Passaggio 11: importazione e definizione del database del piano

Uno degli altri pezzi è che il sito opensky offre un database scaricabile di aerei insieme ai loro nominativi e ident. Le sue diverse centinaia di migliaia di voci. Quindi possiamo scaricarlo e caricarlo localmente in un database MariaDB per la ricerca (MySQL). Con ogni aereo che appare in alto, recuperiamo i suoi dettagli e aggiorniamo un contatore per mostrare quante volte è stato visto.

Attualmente sto anche modificando il database per evidenziare gli aerei che mi interessano. Principalmente vecchi uccelli da guerra e altri aerei interessanti simili. Un paio di volte quest'estate è sorvolato un Mig-15. quindi l'obiettivo è utilizzare un campo di avviso che ho aggiunto e quindi far lampeggiare velocemente la luce quando qualcosa di interessante sta arrivando

Passaggio 12: miglioramento dei risultati e nuove funzionalità

Quindi in teoria tutto funziona abbastanza bene, ma con i dati scoprirai che ci sono aerei che sorvolano che non appaiono nell'API.

Questo perché non tutti gli aerei utilizzano il transponder ADS-B e utilizzano transponder più vecchi basati su MLAT. Per ottenere i dati di posizione sugli aerei utilizzando MLAT, è necessaria una serie di ricevitori a terra per triangolare la loro posizione e alcuni siti come flightradar24 hanno una rete più ampia di contributori che lo fanno rispetto a opensky. Spero che nel tempo anche la loro copertura migliorerà e sto configurando il mio ricevitore MLAT da aggiungere a questi dati.

Passaggio 13: base di codice

Non dimenticare che se hai intenzione di usarlo potresti voler rimuovere le istruzioni SQL se non hai il database degli aerei e anche aggiungere il tuo valore Lon/Lat e la chiave API per accedere ai dati di volo.

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

define("INTERVALLO", (20 * 1)); function fexp() { $lat = "la tua latitudine"; $lon = "la tua longitudine"; $lato = 15,75; $box = get_bounding_box($lat, $lon, $side); $latmin = $box[0]; $lonmin = $scatola[1]; $latmax = $scatola[2]; $lonmax = $scatola[3]; $flyurl = "https://opensky-network.org/api/states/all?lamin=$latmin&lomin=$lonmin&lamax=$latmax&lomax=$lonmax"; echo "Scansione del CIELO"; $start_time = microtime(true); $json = file_get_contents($flyurl); $data = json_decode($json, TRUE); $in entrata = FALSO; $num_planes = count($data['stati']); if ($num_planes >0) { echo " e possiamo vedere $num_planes\n "; for ($x =0; $x 0) { $plane_eta = $distplane/$air_speed_kmh; }else { $eta = 1; } if ((($intercetta)0)) && ($distplane0){ $in entrata = TRUE; eco "------------------------------------------------ --------------------\n"; echo "$icao24 - [$country $nominativo] at [$geo_altitude_m M -- $geo_altitude_f ft] "; echo "[speed $air_speed_kmh kmh and ", round($distplane, 1), "km away]\n"; echo "[su un'intestazione di ", round($heading_plane, 1), "] [homeangle $heading_d] "; echo "[$latitudine, $longitudine]\n"; echo "[flypassast in ", decimal_to_time($plane_eta), " now ", round($intercept, 1), "km away\n"; eco "------------------------------------------------ --------------------\n"; $DBi = new mysqli("127.0.0.1", "root", "tua password", "awacs"); $sql = "seleziona * dal database degli aeromobili dove `icao24`='$icao24'"; mysqli_set_charset($DBi, "utf8"); $getplanedata = mysqli_query($DBi, $sql) or 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['registrazione']; echo " è un "; echo $row_getplanedata['nomeproduttore']; eco " "; echo $row_getplanedata['model']; echo "da"; echo $row_getplanedata['fabbricao']; echo "di proprietà di"; echo $row_getplanedata['proprietario']; eco "visto"; echo $row_getplanedata['visite']; echo "tempi"; echo " valutazione speciale="; echo $row_getplanedata['speciale']; echo "\n"; $visite = $row_getplanedata['visits']+1; } while ($row_getplanedata = mysqli_fetch_assoc($getplanedata)); mysqli_free_result($getplanedata); $sqli = "AGGIORNA SET database aeromobili visite = $visite WHERE icao24 = '$icao24'"; mysqli_set_charset($DBi, "utf8"); $updateplanedata = mysqli_query($DBi, $sqli) or die(mysqli_error($DBi)); } else { echo "Impossibile trovare questo aereo nel DB quindi lo aggiungo"; $sqli = "INSERIRE VALORI ('$icao24', 1, 1) nel database degli aeromobili (icao24, visite, speciali)"; $updateplanedata = mysqli_query($DBi, $sqli) or die(mysqli_error($DBi)); } eco "----------------------------------------------- ---------------------\n"; } else { // echo "$nominativo "; } } } else { echo " e il cielo è sereno\n "; } if ($inbound) { echo "Aereo in arrivo\n"; $comando = "maiali w 17 1"; execInBackground($comando); } else { echo "nessun volo in arrivo\n"; $comando = "maiali w 17 0"; execInBackground($comando); } } funzione decimal_to_time($decimal) { $offset = 0.002778; if ($decimale>$offset) { $decimale = $decimale - 0.002778; } $ore = gmdate('H', floor($decimale * 3600)); $minuti = gmdate('i', floor($decimale * 3600)); $secondi = gmdate('s', floor($decimale * 3600)); return str_pad($ore, 2, "0", STR_PAD_LEFT). ":". str_pad($minuti, 2, "0", STR_PAD_LEFT). ":". str_pad($secondi, 2, "0", STR_PAD_LEFT); } /* * calcola il rilevamento (iniziale) tra due punti * * da: Aviation Formulary di 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; restituire $zz; } function 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; return $intercetta_volo; } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* * Usa la formula di Haversine per calcolare la distanza (in km) tra due punti specificati da * latitudine/longitudine (in gradi numerici) * * da: Formula di Haversine - RWSinnott, "Virtues of the Haversine", * Sky and Telescope, vol 68, no 2, 1984 * https://williams.best.vwh.net/avform.htm#Crs * * esempio di utilizzo dal form: * result.value = LatLon.distHaversine(lat1.value.parseDeg(), long1.value.parseDeg(), * lat2.value.parseDeg(), long2.value.parseDeg()); * dove lat1, long1, lat2, long2 e risultato sono campi del modulo * source = instantglobe.com/CRANES/GeoCoordTool.html */ function get_distHaversine ($home_lat, $home_lon, $plane_lat, $plane_lon) { $R = 6371; // raggio medio terrestre in 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; restituire $d; } function 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_in_degrees); $lon = deg2rad($longitude_in_degrees); $raggio = 6371; # Raggio del parallelo alla latitudine data; $raggio_parallelo = $raggio*cos($lat); $lat_min = $lat - $half_side_in_km/$raggio; $lat_max = $lat + $half_side_in_km/$raggio; $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() { // completamente opzionale return(TRUE); } funzione start() { echo "inizio\n"; $comando = "maiali w 17 1"; execInBackground($comando); $attivo = VERO; while($attivo) { usleep(1000); // facoltativo, se vuoi essere premuroso if (microtime(true) >= $nextTime) { fexp(); $nextTime = microtime(true) + INTERVAL; } $active = checkForStopFlag(); } } fexp(); cominciare(); ?>

Passaggio 14: cablaggio del LED e dell'interruttore di spegnimento

Il cablaggio di questo progetto non potrebbe essere più semplice. C'è solo un LED che è collegato al pin 17 ea massa con un resistore 270R in linea.

Includo anche un pulsante di spegnimento e accensione insieme a un LED di alimentazione che si allontana dal pin dati TXd. Puoi leggere di più sulla funzione di spegnimento e sul codice richiesto su https://github.com/Howchoo/pi-power-button.git dal sito https://howchoo.com/g/mwnlytk3zmm/how-to- add-a-pow… Puoi leggere sull'aggiunta di una luce di alimentazione qui