Llum de pista Raspberry PI d’alerta primerenca mitjançant dades de mapatge de vol: 14 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

Aquesta làmpada va sorgir per diversos motius perquè sempre m’interessen els avions que volen a sobre i durant l’estiu els caps de setmana sovint n’hi ha uns de força emocionants. Tot i que només tendeix a escoltar-los a mesura que passen. Aleshores, l’altra raó és que sembla que el trajecte de vol dels avions sortints de l’aeroport de London City de vegades serà escoltat i tenen alguns vols força sorollosos. Com estic dedicat a gravar alguns vídeos per a YouTube, és realment molest haver de desfer una gravació a causa d’un avió sorollós. Així que em vaig preguntar si les dades que veieu a llocs com flightradar24 estan disponibles públicament, un cop vaig descobrir que alguna cosa similar estava disponible a la xarxa opensky, va néixer el llum d'alerta primerenca. No va trigar gaire a arribar a la idea d’utilitzar una rèplica d’un llum de pista per allotjar el projecte.

Podeu obtenir més informació sobre l’OpenSky Network a https://www.opensky-network.org També he volgut fer aquesta vegada una lent de resina agradable en lloc d’utilitzar PLA translúcid i, tot i que tinc un receptor ADS-B, volia mantenir això és senzill i barat. L’ADS-B també necessita una antena i això no faria que una làmpada entrés al prestatge de l’oficina. Així que, amb sort, trobareu la construcció interessant ja que inclou la impressió 3D, el modelat de resina i les matemàtiques, per extrapolar les posicions dels avions que potencialment poden passar per sobre.

Pas 1: dissenyar el cas

La cerca a Google presenta molts dissenys diferents de làmpades de pista i el disseny d’aquest s’ha fet amb influències de disseny de moltes marques diferents de làmpades reals. També està reduït per seure a una habitació o a un prestatge en lloc de fer-ho a mida completa, ja que solen ser molt més grans a la vida real.

Els dissenys es van elaborar a Fusion 360 i vaig importar alguns elements anteriors com ara el titular zero raspberry pi de projectes anteriors. Poder reutilitzar elements suposa una gran quantitat de maldecaps per reduir els conceptes bàsics. També podeu descarregar els fitxers aquí

Pas 2: llançament de les lents: #fail

L'element de disseny més important d'aquesta làmpada seria la lent. Així que vaig abordar això primer, ja que sense un bonic mirall autèntic el projecte anava a funcionar. Estic documentant aquí els fracassos que he tingut en intentar aconseguir-ho, malgrat que inicialment també vaig decidir fer la lent ambarina. Els llums de les pistes són de color ambre i blau i només després d’haver començat a fabricar l’ambre vaig canviar d’opinió i vaig decidir que en volia un de blau.

Pel que puc distingir, els de color ambre s’utilitzen a la línia de subjecció i els de color blau s’utilitzen per alinear la pista, i són els que semblen ser els més arquetípics que es troben si busqueu llums de pista. Tanmateix, aquí teniu el meu primer intent de fer una lent ambarina. Per fabricar l’objectiu, anava a utilitzar resina transparent amb additiu de color i, tot i que he fet alguns motlles abans de preguntar-me si seria possible imprimir un motlle 3D i utilitzar-lo. Així que vaig començar a fer un motlle dividit en 3D i a imprimir-lo a PetG. Una quantitat prudent d’alliberament de motlles estava convençut que seria suficient per esperar el motlle. Amb el parell d'intents, vaig fer que la resina s'enganxés al motlle com una cola i no semblava possible separar-les. Tot i que tenia la de mida completa que anava a utilitzar, vaig decidir-me en contra i vaig imprimir la lent per utilitzar-la amb el modelat tradicional de silicona.

Pas 3: diferents tipus de resina

De forma ràpida, he utilitzat tres tipus de resines clares / de colors per a aquest projecte.

El primer era un tipus de mercat Hobby anomenat Pebeo - Gedeo i normalment es ven per encapsular articles petits i s'utilitza per a joies i pesos de paper, etc. Tanmateix, és bastant car per la quantitat que obtingueu, però és útil i fàcil de trobar a les botigues d'artesania i aficions. Es barreja amb una proporció de 2: 1. El segon era una resina precolorida que es barreja amb una proporció de 10: 1 amb l’enduridor i que va trigar més a curar-se, aproximadament una setmana abans d’haver-se curat completament. L’última era una resina clara, que també es barrejava amb la proporció 2: 1 i que es curava en uns 2 dies, podeu acolorir-la amb gotes de pigment, però heu d’assegurar-vos d’utilitzar sempre la mateixa relació de color si estan fent lots separats. També resulta el més rendible. Per últim, el RTV per al motlle era un GP-3481 RTV i això triga unes 24 hores a configurar-se i té un temps de pot força llarg, de manera que teniu molt de temps per barrejar-lo i després abocar-lo.

En l'actualitat no tinc una olla vacumn (actualment en ordre) perquè pugueu ser assetjats per bombolles tant al motlle com a l'abocament de la resina. No és un problema excessiu per a això, però amb una lent clara o similar, voldríeu pensar en alguna manera per treure les bombolles de les mescles.

Pas 4: fosa de la lent al motlle de silicona núm. 2

Per tant, aquest és el segon intent de fabricar una lent de resina i la primera etapa va ser fabricar tant una lent a Fusion 360 i imprimir-la en ABS, com una galleda per subjectar-la. Aquest seria el primer per al motlle i ajuda a mantenir la quantitat de silicona que s’ha d’utilitzar. Podeu fer-ho fàcilment amb targeta, però només és un enfocament diferent. Per donar-li una millor possibilitat de ser alliberat del motlle, primer el vaig envernissar i després li vaig donar una bona cobertura de desprenent de cera.

Després vaig abocar una mica de GP-3481, que és aproximadament a la costa 27 RTV, i després vaig deixar que es fixés durant les properes 24 hores abans de desemmotllar-se. Un cop fet això, he utilitzat la resina clara barrejada a una proporció de 2: 1 amb unes 4/5 gotes del pigment de color i la vaig barrejar bé durant quatre minuts. Va abocar-lo al motlle i, a continuació, va col·locar un got de vidre a la resina per proporcionar un buit més tard per a una làmpada o per als LED. Al cap d’unes 24 hores, aquesta resina ja estava preparada per treure i la lent va sortir força bona. Hi ha bombolles d’aire presents, però encara no tinc cap recipient de buit per desgasificar la resina abans d’abocar.

Pas 5: Impressió i preparació 3D

El model es va dissenyar de manera que la secció central es connectés a la base. Es tractava d’evitar l’emmascarament durant el procés de pintura. El model sencer es va imprimir en ABS Hatchbox i després es va polir. Començant amb 60 gra fins a uns 800 graus va donar un acabat superficial prou bo per a aquest model.

Pas 6: Muntatge i pintura

Un cop esmaltades les impressions, es va pintar amb una imprimació d’alta construcció. Es polir lleugerament i després es va ruixar amb imprimació de color gris. Les parts principals es van pintar de groc senyal de Ford i, a continuació, es van utilitzar els verds rierols per a la base. a continuació, es van aplicar destacats de plata tamiya als cargols i es va utilitzar una mica de crom de plata molotow al portaobjectius.

Pas 7: primer cerqueu avions dins d'una àrea delimitada

Amb el maquinari ordenat, cal treballar el programari. Ara hi ha un parell de llocs que ofereixen el seguiment de vols, però no molts que ofereixen una API per accedir a aquestes dades. Alguns que ho fan només ho fan de manera comercial, però, per sort, hi ha un lloc anomenat https://opensky-network.org que podeu utilitzar de forma gratuïta.

Per accedir a aquestes dades, us heu de registrar i després podeu utilitzar la seva API; proporciona diverses funcions i maneres d’extreure les dades. Estem interessats en tots els vols dins d'una zona i tenen una trucada de l'API en directe. https://opensky-network.org/apidoc/ anomenat quadre de delimitació. La trucada a l'API requereix les cantonades del quadre que us interessi, per descomptat, el nostre Lat / Lon com a punt central. Podeu consultar les matemàtiques que funcionen en aquest lloc, que dibuixa una casella en funció del que escriviu. Http://tools.geofabrik.de però, de moment, el següent script proporciona els punts que necessitem per connectar a l'API.

funció 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); $ radi = 6371; $ parallel_radius = $ radi * cos ($ lat); $ lat_min = $ lat - $ half_side_in_km / $ radi; $ lat_max = $ lat + $ half_side_in_km / $ radi; $ 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); retorna matriu ($ box_lat_min, $ box_lon_min, $ box_lat_max, $ box_lon_max);

Si voleu provar el vostre codi, hi ha un lloc on podeu introduir el lat / lon i veure els resultats en un mapa: vegeu un exemple de quadre delimitant en un mapa

Pas 8: càlcul de la capçalera dels avions en relació amb nosaltres

Els resultats de la trucada API del quadre delimitador ens proporcionen una llista de plans, el seu Lon / lat, velocitat, altitud i capçalera. Per tant, el següent que hem de fer és obtenir l’encapçalament de cada pla en relació amb nosaltres per poder processar encara més aquells que almenys es dirigeixen en la nostra direcció general. Ho podem fer tal com coneixem la nostra posició i podem calcular l’angle des de nosaltres cap a cada pla.

Per fer-ho, faig servir un tros de codi que originalment estava a Javascript, de manera que el vaig convertir aquí a PHP, * calculeu el relleu (inicial) entre dos punts * * des de: Ed Williams 'Aviation Formulary, https://williams.best.vwh.net/avform.htm#Crs * source = instantglobe.com/CRANES/GeoCoordTool.html * / funció 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; retorna $ zz;

Si voleu veure la pàgina on es troben les versions originals de javascript, aquest és l’enllaç:

dins d'aquest codi, també podeu veure les diferents subrutines per a cada tipus de càlcul.

Pas 9: calcular una intercepció mirant un cercle

Per tant, ara tenim un pla on la relació entre ell i la nostra ubicació és inferior a 90 (positiva o negativa), de manera que això significa que hi ha la possibilitat que pugui volar a prop. Utilitzant la fórmula haversina també podem treballar utilitzant el Lon / Lat de l’avió i el Lon / Lat de casa nostra a la distància que ens queda lluny.

Si observem el diagrama, si dibuixem un cercle al voltant de casa, diguem-ne uns 3 quilòmetres de radi, això ens donarà la possibilitat de veure qualsevol cosa sobrevolant. Sabem la diferència d’encapçalament entre l’avió i nosaltres, també sabem la distància de l’avió respecte de nosaltres per poder treballar el triangle amb l’antic SOHCAHTOA i, en aquest cas, usant el Tan de l’angle podem obtenir el longitud del costat oposat. Per tant, si comparem aquest valor amb el valor del radi del cercle al voltant de la casa, podem esbrinar si l’avió volarà prou a prop com perquè el veiem. El següent que podem fer és determinar el temps que passarà l'avió passant utilitzant la velocitat de l'aire i la distància i, si és inferior a uns 45 segons aproximadament, encenem la llum. Aquest és una mica del codi que faig servir per determinar la possibilitat de sobrevolar. Ho faig ja que hi ha un aeroport proper i quan els avions circulen en taxi, inevitablement apunten a la casa. Tanmateix, com que la seva altitud és zero i la velocitat camina, això no hauria de provocar l'alarma.

funció get_intercept ($ cap_inici, $ cap_avió, $ distància_avió) {

$ angle_vol = abs (abs ($ cap_inici - $ cap_avió) - 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 passar per davant

}

retorna $ flight_intercept;

}

Pas 10: Distància entre dos punts en un mapa: fórmula Haversine

Per tant, hem de calcular la distància entre l’avió i la nostra ubicació. En distàncies curtes d’un mapa es pot calcular aproximadament la distància, però com que la terra és esfèrica, hi ha una fórmula anomenada fórmula haversina que permet tenir en compte la superfície corba. Podeu llegir més a continuació la fórmula:

Ara, amb la distància calculada i sabem la velocitat de l’avió, podem determinar quants segons passaran abans que l’avió es quedi a sobre. Així doncs, la llum s’encendrà si hi ha alguna cosa en un termini de 30 segons del flypast i, finalment, tenim el nostre llum d’advertència.

* basat en 0n JS a instantglobe.com/CRANES/GeoCoordTool.html i convertit en PHP * /

funció get_distHaversine ($ home_lat, $ home_lon, $ plane_lat, $ plane_lon) {$ R = 6371; // radi mitjà de la terra 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; retorna $ d; }

Pas 11: importació i definició de la base de dades d’avions

Una de les altres peces és que el lloc opensky ofereix una base de dades descarregable d’avions juntament amb els seus indicatius i identificatius. Els seus diversos centenars de milers d’entrades. Per tant, podem descarregar-lo i carregar-lo localment en una base de dades MariaDB per a la cerca (MySQL). Amb cada avió que apareix a sobre, recuperem els seus detalls i actualitzem un comptador per mostrar quantes vegades s’ha vist.

Actualment, també estic editant la base de dades per ressaltar els avions que m'interessin. Principalment ocells de guerra vells i altres avions interessants similars. Un parell de vegades aquest estiu ha sobrevolat un Mig-15. de manera que l’objectiu és utilitzar un camp d’alerta que he afegit i, a continuació, parpellejar la llum ràpidament quan s’està acabant alguna cosa interessant

Pas 12: Millorar els resultats i les noves funcions

Així, en teoria, tot funciona bastant bé, però trobareu amb les dades que hi ha avions que sobrevolen que no apareixen a l'API.

Això es deu al fet que no tots els avions utilitzen el transpondedor ADS-B i utilitzen transponders antics basats en MLAT. Per obtenir dades de posició en avions que utilitzen MLAT, es necessita una sèrie de receptors a terra per triangular la seva posició i alguns llocs com flightradar24 tenen una xarxa més gran de col·laboradors que ho fan en comparació amb opensky. Tant de bo amb el pas del temps la seva cobertura millorarà i estic configurant el meu propi receptor MLAT per afegir-les a aquestes dades.

Pas 13: base de codis

No oblideu si utilitzeu això, potser voldreu eliminar les sentències SQL si no teniu la base de dades d’avions i també afegiu el vostre propi valor Lon / Lat i la vostra clau API per accedir a les dades del vol.

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

define ("INTERVAL", (20 * 1)); funció fexp () {$ lat = "la vostra latitud"; $ lon = "la teva longitud"; costat $ = 15,75; $ box = get_bounding_box ($ lat, $ lon, $ side); $ latmin = $ quadre [0]; $ lonmin = $ quadre [1]; $ latmax = $ quadre [2]; $ lonmax = $ quadre [3]; $ flyurl = "https://opensky-network.org/api/states/all?lamin=$latmin&lomin=$lonmin&lamax=$latmax&lomax=$lonmax"; eco "Escaneig del cel"; $ start_time = microtime (true); $ json = file_get_contents ($ flyurl); $ data = json_decode ($ json, TRUE); $ entrant = FALS; $ num_planes = count ($ dades ['estats']); if ($ num_planes> 0) {echo "i podem veure $ num_planes plans / n"; per a ($ x = 0; $ x 0) {$ plane_eta = $ distplane / $ air_speed_kmh; } else {$ eta = 1; } if ((($ intercept) 0)) && ($ distplane0) {$ entrant = TRUE; ressò "------------------------------------------------ -------------------- / n "; eco "$ icao24 - [$ country $ callsign] a [$ geo_altitude_m M - $ geo_altitude_f ft]"; eco "[speed $ air_speed_kmh kmh and", round ($ distplane, 1), "km away] n"; eco "[en un encapçalament de", ronda ($ plane_heading, 1), "] [homeangle $ heading_d]"; eco "[$ latitude, $ longitude] n"; eco "[flypast in", decimal_to_time ($ plane_eta), "now", round ($ intercept, 1), "km away / n"; ressò "------------------------------------------------ -------------------- / n "; $ DBi = new mysqli ("127.0.0.1", "root", "la vostra contrasenya", "awacs"); $ sql = "select * from databasedatabase on` icao24` = '$ icao24' "; mysqli_set_charset ($ DBi, "utf8"); $ getplanedata = mysqli_query ($ DBi, $ sql) o morir (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 ['registre']; eco "és un"; echo $ row_getplanedata ['nom del fabricant']; ressò ""; echo $ row_getplanedata ['model']; ressò "per"; echo $ row_getplanedata ['manufacturericao']; eco "propietat de"; echo $ row_getplanedata ['propietari']; ressò "vist"; echo $ row_getplanedata ['visites']; ressò de "temps"; eco "qualificació especial ="; echo $ row_getplanedata ['especial']; ressò "\ n"; $ visites = $ fila_getplanedada ['visites'] + 1; } while ($ row_getplanedata = mysqli_fetch_assoc ($ getplanedata)); mysqli_free_result ($ getplanedata); $ sqli = "ACTUALITZA base de dades de l'avió SET visites = $ visites ON icao24 = '$ icao24'"; mysqli_set_charset ($ DBi, "utf8"); $ updateplanedata = mysqli_query ($ DBi, $ sqli) o morir (mysqli_error ($ DBi)); } else {echo "No s'ha pogut trobar aquest pla a la base de dades per afegir-lo"; $ sqli = "INSERT EN LA base de dades d'avions (icao24, visites, especials) VALORS ('$ icao24', 1, 1)"; $ updateplanedata = mysqli_query ($ DBi, $ sqli) o morir (mysqli_error ($ DBi)); } ressò "----------------------------------------------- --------------------- / n "; } else {// fa ressò de "$ callsign"; }}} else {echo "i el cel està clar / n"; } if ($ entrant) {echo "Plànol d'entrada / n"; $ command = "porcs w 17 1"; execInBackground (ordre $); } else {echo "no vols entrants / n"; $ command = "porcs w 17 0"; execInBackground (ordre $); }} function decimal_to_time ($ decimal) {$ offset = 0,002778; if ($ decimal> $ offset) {$ decimal = $ decimal - 0,002778; } $ hores = gmdate ('H', pis ($ decimal * 3600)); $ minutes = gmdate ('i', floor ($ decimal * 3600)); $ segons = gmdate ('s', pis ($ decimal * 3600)); retorna str_pad ($ hores, 2, "0", STR_PAD_LEFT). ":". str_pad ($ minuts, 2, "0", STR_PAD_LEFT). ":". str_pad ($ segons, 2, "0", STR_PAD_LEFT); } / * * calcular (inicial) que té entre dos punts * * de: Ed Williams 'Aviation Formulary, 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; retorna $ zz; } funció 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; retorna $ flight_intercept; } / * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - * / / * * Utilitzeu la fórmula Haversine per calcular la distància (en km) entre dos punts especificats per * latitud / longitud (en graus numèrics) * * des de: Fórmula Haversine - RWSinnott, "Virtuts of the Haversine", * Sky and Telescope, vol 68, no 2, 1984 * https://williams.best.vwh.net/avform.htm#Crs * * exemple d'ús de la forma: * result.value = LatLon.distHaversine (lat1.value.parseDeg (), long1.value.parseDeg (), * lat2.value.parseDeg (), long2.value.parseDeg ()); * on lat1, long1, lat2, long2 i result són camps de formulari * source = instantglobe.com/CRANES/GeoCoordTool.html * / function get_distHaversine ($ home_lat, $ home_lon, $ plane_lat, $ plane_lon) {$ R = 6371; // radi mitjà de la terra 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; retorna $ 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); $ radi = 6371; # Radi del paral·lel a una latitud determinada; $ parallel_radius = $ radi * cos ($ lat); $ lat_min = $ lat - $ half_side_in_km / $ radi; $ lat_max = $ lat + $ half_side_in_km / $ radi; $ 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); retorna matriu ($ 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 &"); }} funció checkForStopFlag () {// retorn completament opcional (TRUE); } function start () {echo "starting / n"; $ command = "porcs w 17 1"; execInBackground (ordre $); $ actiu = CERT; while ($ actiu) {usleep (1000); // opcional, si voleu tenir en compte si (microtime (true)> = $ nextTime) {fexp (); $ nextTime = microtemps (true) + INTERVAL; } $ actiu = checkForStopFlag (); }} fexp (); començar(); ?>

Pas 14: Cablatge del LED i del commutador d’aturada

El cablejat d’aquest projecte no pot ser més senzill. Només hi ha un LED connectat al pin 17 i a terra amb una resistència 270R en línia.

També incloc un botó d’apagada i engegada juntament amb un LED d’alimentació que s’executa el pin de dades TXd. Podeu obtenir més informació sobre la funció d’aturada i el codi requerit a https://github.com/Howchoo/pi-power-button.git des del lloc https://howchoo.com/g/mwnlytk3zmm/how-to- add-a-pow … Podeu llegir sobre com afegir una llum de potència aquí