Luz de pista Raspberry PI de alerta temprana con datos de mapas de vuelo: 14 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Esta lámpara surgió por varias razones, ya que siempre me interesan los aviones que sobrevuelan y durante el verano, los fines de semana, a menudo hay algunos bastante emocionantes volando. Aunque solo sueles escucharlos cuando pasan. Luego, la otra razón es que parece que la ruta de vuelo de los aviones que salen del aeropuerto de la ciudad de Londres a veces se escuchará por casualidad y tienen algunos vuelos bastante ruidosos. Como me dedico a grabar algunos videos para YouTube, es realmente molesto tener que desechar una grabación debido a un avión ruidoso. Así que me pregunté si los datos que ves en sitios como flightradar24 están disponibles públicamente, una vez que descubrí que había algo similar disponible en la red opensky, nació la lámpara de advertencia temprana. No pasó mucho tiempo para que se le ocurriera la idea de utilizar una réplica de una luz de pista para albergar el proyecto.

Puede encontrar más información sobre The OpenSky Network en https://www.opensky-network.org. También quería esta vez hacer una buena lente de resina en lugar de usar PLA translúcido y, aunque tengo un receptor ADS-B, quería conservar así de sencillo y barato. El ADS-B también necesita una antena y esto no sería suficiente para que una lámpara se coloque en el estante de la oficina. Entonces, con suerte, encontrará la construcción interesante, ya que cubre la impresión 3D, el moldeado de resina y las matemáticas, así como para extrapolar las posiciones de los aviones que potencialmente podrían pasar por encima.

Paso 1: diseño de la carcasa

La búsqueda de Google presenta muchos diseños diferentes de lámpara de pista y el diseño de este se hizo utilizando influencias de diseño de muchas marcas diferentes de lámparas reales. También está escalado para sentarse en una habitación o en un estante en lugar de tamaño completo, ya que tienden a ser mucho más grandes en la vida real.

Los diseños se elaboraron en Fusion 360 e importé algunos elementos anteriores como el soporte cero raspberry pi de proyectos anteriores. Ser capaz de reutilizar elementos elimina gran parte del dolor de cabeza de aprender lo básico. También puede descargar los archivos aquí

Paso 2: Casting de lentes - #fail

El elemento de diseño más importante de esta lámpara iba a ser la lente. Así que abordé esto primero, ya que sin un bonito y auténtico espejo el proyecto iba a funcionar. Estoy documentando aquí las fallas que tuve al intentar lograrlo, a pesar de que inicialmente también decidí hacer que la lente sea de color ámbar. Las luces de la pista vienen en ámbar y azul y fue solo después de que comencé a hacer la ámbar que cambié de opinión y decidí que quería una azul.

Por lo que puedo ver, los ámbar se usan en la línea de espera y los azules se usan para alinear la pista, y estos son los que parecen ser los más arquetípicos que se encuentran si busca luces de pista. Sin embargo, este es mi primer intento de hacer una lente ámbar. Para hacer la lente, iba a usar resina transparente con un aditivo de color, y aunque ya había hecho algunos moldes antes, me preguntaba si sería posible imprimir un molde 3D y usarlo. Así que empecé a hacer un molde partido en 3D e imprimirlo en PetG. Estaba convencido de que cantidades razonables de desmoldeante serían suficientes para esparcir el molde. Como resultado, con un par de intentos hice que la resina se pegara al molde como pegamento y no parecía posible separarlos. Aunque tenía la de escala completa que iba a usar, decidí no usarla e imprimí la lente para usar con la moldura de silicona tradicional.

Paso 3: diferentes tipos de resina

Como comentario rápido, utilicé 3 tipos de resinas transparentes / coloreadas para este proyecto.

El primero fue un tipo de mercado de Hobby llamado Pebeo - Gedeo y normalmente se vende para encapsular artículos pequeños y se usa para joyería y pisapapeles de escritorio, etc. Esto funcionó bastante bien y se curó bien en aproximadamente 24-36 horas. Sin embargo, es bastante caro para la cantidad que obtienes, pero es útil y fácilmente disponible en tiendas de manualidades y pasatiempos. Está mezclado en una proporción de 2: 1. El segundo fue una resina pre-coloreada que se mezcla en una proporción de 10: 1 con el endurecedor y esto tomó más tiempo para curar, aproximadamente una semana para ser honesto antes de que se curara por completo. La última fue una resina transparente, que también se mezcló en la proporción 2: 1 y se curó en aproximadamente 2 días, puedes colorear esto con gotas de pigmento, pero debes asegurarte de usar siempre la misma proporción de color si están haciendo lotes separados. También resulta el más rentable. Por último, el RTV para el molde era un RTV GP-3481 y esto tarda aproximadamente 24 horas en configurarse y tiene un tiempo de preparación bastante largo, por lo que tiene mucho tiempo para mezclarlo y luego verterlo.

En la actualidad no tengo una olla de vacío (actualmente en pedido) para que pueda ser acosado por burbujas tanto en el molde como en el vertido de resina. No es un gran problema para esto, pero con una lente transparente o similar, entonces querrás pensar en alguna forma de sacar las burbujas de las mezclas.

Paso 4: moldear la lente en el molde de silicona n. ° 2

Entonces, este es el segundo intento de hacer una lente de resina y la primera etapa fue hacer una lente en Fusion 360 y luego imprimirla en ABS, así como un cubo para sostenerla. Este sería el primero para el molde y ayuda a reducir la cantidad de silicona que se utilizará. Puede hacer esto fácilmente con una tarjeta, pero es solo un enfoque diferente. Para darle una mejor oportunidad de ser desmoldeado, primero lo barnizé y luego le di una buena cobertura de agente de desmoldeo de cera.

Luego vertí un poco de GP-3481, que está aproximadamente en la orilla 27 RTV y luego lo dejé reposar durante las siguientes 24 horas antes de desmoldar. Una vez hecho esto, utilicé la resina transparente mezclada en una proporción de 2: 1 con aproximadamente 4/5 gotas del pigmento de color y la mezclé bien durante unos buenos cuatro minutos. Vierta esto en el molde y luego coloque un vaso de chupito en la resina también para proporcionar un vacío más tarde para una lámpara o los LED. Después de aproximadamente 24 horas, esta resina estaba lista para quitarse y la lente salió bastante bien. Hay burbujas de aire presentes, pero todavía no tengo un recipiente de vacío para desgasificar la resina antes de verterla.

Paso 5: Impresión 3D y preparación

El modelo fue diseñado de manera que la sección central se enchufa en la base. Esto fue para evitar enmascaramiento durante el proceso de pintura. Todo el modelo se imprimió en Hatchbox ABS y luego se lijó. Comenzar con un grano 60 hasta un grano 800 dio un acabado de superficie suficientemente bueno para este modelo.

Paso 6: Montaje y pintura

Una vez que se lijaron las impresiones, se pintó con una imprimación de alto espesor. Ligeramente lijado y luego rociado con imprimación gris. Las partes principales se pintaron en amarillo señal de Ford, y luego se usó verde Brooklands para la base. Luego se aplicaron reflejos de plata tamiya a los pernos y se usó un poco de cromo plateado molotow en el soporte de la lente.

Paso 7: Primero encuentre aviones dentro de un área delimitada

Con el hardware ordenado, era necesario trabajar en el software. Ahora hay un par de sitios que brindan seguimiento de vuelos, pero no muchos que brinden una API para acceder a esos datos. Algunos que lo hacen, solo lo hacen de manera comercial, pero afortunadamente hay un sitio llamado https://opensky-network.org que puede usar de forma gratuita.

Para acceder a estos datos tienes que registrarte y luego puedes usar su API, proporciona varias funciones y formas de extraer los datos. Estamos interesados en todos los vuelos dentro de un área y tienen una llamada API en vivo para eso. https://opensky-network.org/apidoc/ llamado cuadro delimitador. La llamada API requiere las esquinas de la caja que le interesan, por supuesto, nuestra Lat / Lon como punto central. Puede comprobar las matemáticas funcionan en este sitio, que dibuja un cuadro según lo que escriba. Http://tools.geofabrik.de pero por ahora el siguiente script proporciona los puntos que necesitamos para conectar a la 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 ($ latitud_en_ grados); $ lon = deg2rad ($ longitud_en_ grados); $ radio = 6371; $ radio_paralelo = $ radio * cos ($ lat); $ lat_min = $ lat - $ half_side_in_km / $ radio; $ lat_max = $ lat + $ half_side_in_km / $ radio; $ lon_min = $ lon - $ half_side_in_km / $ paralelo_radio; $ lon_max = $ lon + $ half_side_in_km / $ paralelo_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); matriz de retorno ($ box_lat_min, $ box_lon_min, $ box_lat_max, $ box_lon_max);

Si desea probar su código, hay un sitio donde puede ingresar la latitud / longitud y ver los resultados en un mapa: Vea un ejemplo de cuadro delimitador en un mapa

Paso 8: Calcular el rumbo de los aviones en relación con nosotros

Los resultados de la llamada a la API del cuadro delimitador nos dan una lista de aviones, su longitud / latitud, velocidad, altitud y rumbo. Entonces, lo siguiente que debemos hacer es obtener el rumbo de cada plano en relación con nosotros para que podamos procesar aún más aquellos que al menos se dirigen en nuestra dirección general. Podemos hacer esto ya que conocemos nuestra posición y podemos calcular el ángulo entre nosotros y cada plano.

Para hacer eso, uso un fragmento de código que originalmente estaba en Javascript, así que lo convertí aquí a PHP, * calcular la demora (inicial) entre dos puntos * * de: Formulario de aviación de 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; return $ zz;

Si quieres mirar la página donde están las versiones originales de javascript, este es el enlace:

dentro de ese código, también puede ver las diversas subrutinas para cada tipo de cálculo.

Paso 9: Calcular una intersección mirando un círculo

Entonces, ahora tenemos un avión donde el rumbo entre él y nuestra ubicación es menor a 90 (ya sea positivo o negativo) y esto significa que existe la posibilidad de que vuele cerca. Usando la fórmula de haversine también podemos calcular usando la longitud / latitud del avión y la longitud / latitud de nuestra casa la distancia que está lejos de nosotros.

Mirando el diagrama, si dibujamos un círculo alrededor de nuestra casa de aproximadamente 3 millas de radio, esto nos da la oportunidad de ver algo volando. Conocemos la diferencia de rumbo entre el avión y nosotros, también conocemos la distancia entre el avión y nosotros para luego calcular el triángulo usando el viejo SOHCAHTOA, y en este caso usando el Tan del ángulo podemos obtener el longitud del lado opuesto. Entonces, si comparamos este valor con el valor del radio del círculo alrededor de la casa, podemos averiguar si el avión volará lo suficientemente cerca para que lo veamos. Lo siguiente que podemos hacer es calcular el tiempo que pasará el avión usando la velocidad del aire y la distancia y, si es menos de unos 45 segundos aproximadamente, encendemos la luz. Este es un fragmento del código que utilizo para calcular la posibilidad de un sobrevuelo. Hago esto porque hay un aeropuerto cercano y cuando los aviones están rodando, inevitablemente apuntan a la casa. Sin embargo, como su altitud es cero y la velocidad es el ritmo al caminar, esto no debería activar la alarma.

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

$ ángulo_de_vuelo = abs (abs ($ cabeza_inicial - $ cabeza_plano) - 180); $ ángulo_de_vuelo_r = deg2rad ($ ángulo_de_vuelo); $ ángulo_de_vuelo_t = tan ($ ángulo_de_vuelo_r); $ flight_intercept = $ flight_angle_t * $ plane_distance;

if (($ flight_angle <90) && ($ flight_intercept <3)) {// posible pasar volando

}

return $ flight_intercept;

}

Paso 10: Distancia entre dos puntos en un mapa - Fórmula de Haversine

Entonces tenemos que calcular la distancia entre el avión y nuestra ubicación. En distancias cortas en un mapa, podría calcular aproximadamente la distancia, pero como la tierra es esférica, existe una fórmula llamada fórmula haversine que le permite tomar en consideración la superficie curva. Puede leer más en la fórmula:

Ahora, con la distancia calculada y sabemos la velocidad del avión, podemos calcular cuántos segundos pasarán antes de que el avión esté sobre nuestras cabezas. Entonces, la luz se encenderá si hay algo dentro de los 30 segundos posteriores al vuelo y por fin tenemos nuestra luz de advertencia.

* basado en JS en instantglobe.com/CRANES/GeoCoordTool.html y convertido en PHP * /

función get_distHaversine ($ home_lat, $ home_lon, $ plane_lat, $ plane_lon) {$ R = 6371; // radio medio de la Tierra 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 (raíz cuadrada ($ a), raíz cuadrada (1- $ a)); $ d = $ R * $ c; return $ d; }

Paso 11: Importación y definición de la base de datos de planos

Una de las otras piezas es que el sitio opensky ofrece una base de datos descargable de aviones junto con sus indicativos e identificadores. Son varios cientos de miles de entradas. Entonces podemos descargar esto y cargarlo localmente en una base de datos MariaDB para búsqueda (MySQL). Con cada avión que aparece sobre nuestras cabezas, recuperamos sus detalles y actualizamos un contador para mostrar cuántas veces se ha visto.

Actualmente también estoy editando la base de datos para resaltar los aviones que me interesan. Principalmente pájaros de guerra antiguos y otros aviones interesantes similares. Un par de veces este verano ha sobrevolado un Mig-15. por lo que el objetivo es usar un campo de alerta que agregué y luego encender la luz rápidamente cuando se acerca algo interesante

Paso 12: Mejora de resultados y nuevas funciones

Entonces, en teoría, todo funciona bastante bien, pero con los datos encontrarás que hay aviones que sobrevuelan y que no aparecen en la API.

Esto se debe a que no todos los aviones usan el transpondedor ADS-B y usan transpondedores más antiguos basados en MLAT. Para obtener datos de posición en aviones usando MLAT, se requiere una serie de receptores en tierra para triangular su posición y algunos sitios como flightradar24 tienen una red más grande de contribuyentes que hacen esto en comparación con opensky. Con suerte, con el tiempo su cobertura también mejorará y estoy configurando mi propio receptor MLAT para agregar a estos datos.

Paso 13: Codebase

No olvide que si va a usar esto, es posible que desee eliminar las declaraciones SQL si no tiene la base de datos de aviones y también agregar su propio valor Lon / Lat y clave API para acceder a los datos de vuelo.

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

define ("INTERVALO", (20 * 1)); function fexp () {$ lat = "su latitud"; $ lon = "su longitud"; $ lado = 15,75; $ caja = get_bounding_box ($ lat, $ lon, $ side); $ latmin = $ caja [0]; $ lonmin = $ caja [1]; $ latmax = $ caja [2]; $ lonmax = $ caja [3]; $ flyurl = "https://opensky-network.org/api/states/all?lamin=$latmin&lomin=$lonmin&lamax=$latmax&lomax=$lonmax"; echo "Explorando el CIELO"; $ start_time = microtime (verdadero); $ json = file_get_contents ($ flyurl); $ datos = json_decode ($ json, VERDADERO); $ entrante = FALSO; $ num_planes = count ($ data ['estados']); if ($ num_planes> 0) {echo "y podemos ver $ num_planes planos / n"; para ($ x = 0; $ x 0) {$ plane_eta = $ distplane / $ air_speed_kmh; } más {$ eta = 1; } if ((($ intercepción) 0)) && ($ distplane0) {$ inbound = TRUE; eco "------------------------------------------------ --------------------\norte"; echo "$ icao24 - [$ country $ indicativo] en [$ geo_altitude_m M - $ geo_altitude_f ft]"; echo "[velocidad $ air_speed_kmh kmh y", round ($ distplane, 1), "km de distancia] n"; echo "[en un encabezado de", round ($ plane_heading, 1), "] [homeangle $ encabezado_d]"; echo "[$ latitud, $ longitud] n"; echo "[flypast in", decimal_to_time ($ plane_eta), "ahora", redondo ($ intercepción, 1), "km de distancia / n"; eco "------------------------------------------------ --------------------\norte"; $ DBi = new mysqli ("127.0.0.1", "root", "su contraseña", "awacs"); $ sql = "seleccionar * de la base de datos de la aeronave donde` icao24` = '$ icao24' "; mysqli_set_charset ($ DBi, "utf8"); $ getplanedata = mysqli_query ($ DBi, $ sql) o morir (mysqli_error ($ DBi)); $ row_getplanedata = mysqli_fetch_assoc ($ getplanedata); $ row_getplanedata = mysqli_num_rows ($ getplanedata); if ($ rows_getplanedata> 0) {do {echo "indicativo ="; echo $ row_getplanedata ['registro']; echo "es un"; echo $ row_getplanedata ['nombre del fabricante']; eco " "; echo $ row_getplanedata ['modelo']; echo "por"; echo $ row_getplanedata ['manufacturericao']; echo "propiedad de"; echo $ row_getplanedata ['propietario']; echo "visto"; echo $ row_getplanedata ['visitas']; echo "tiempos"; echo "calificación especial ="; echo $ row_getplanedata ['especial']; echo "\ n"; $ visitas = $ row_getplanedata ['visitas'] + 1; } while ($ row_getplanedata = mysqli_fetch_assoc ($ getplanedata)); mysqli_free_result ($ getplanedata); $ sqli = "ACTUALIZAR la base de datos del avión SET visitas = $ visitas DONDE icao24 = '$ icao24'"; mysqli_set_charset ($ DBi, "utf8"); $ updateplanedata = mysqli_query ($ DBi, $ sqli) o morir (mysqli_error ($ DBi)); } else {echo "No se pudo encontrar este plano en la base de datos, así que lo agregué"; $ sqli = "INSERTAR EN la base de datos de la aeronave (icao24, visitas, especial) VALORES ('$ icao24', 1, 1)"; $ updateplanedata = mysqli_query ($ DBi, $ sqli) o morir (mysqli_error ($ DBi)); } eco "----------------------------------------------- ---------------------\norte"; } else {// echo "$ indicativo"; }}} else {echo "y el cielo está despejado / n"; } if ($ entrante) {echo "Plano entrante / n"; $ comando = "cerdos w 17 1"; execInBackground ($ comando); } else {echo "sin vuelos entrantes / n"; $ comando = "cerdos w 17 0"; execInBackground ($ comando); }} función decimal_to_time ($ decimal) {$ offset = 0.002778; if ($ decimal> $ compensación) {$ decimal = $ decimal - 0.002778; } $ horas = gmdate ('H', piso ($ decimal * 3600)); $ minutos = gmdate ('i', piso ($ decimal * 3600)); $ segundos = gmdate ('s', piso ($ decimal * 3600)); return str_pad ($ horas, 2, "0", STR_PAD_LEFT). ":". str_pad ($ minutos, 2, "0", STR_PAD_LEFT). ":". str_pad ($ segundos, 2, "0", STR_PAD_LEFT); } / * * calcular el rumbo (inicial) entre dos puntos * * de: Formulario de aviación de 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; return $ zz; } function get_intercept ($ home_head, $ plane_head, $ plane_distance) {$ flight_angle = abs (abs ($ home_head - $ plane_head) - 180); $ ángulo_de_vuelo_r = deg2rad ($ ángulo_de_vuelo); $ ángulo_de_vuelo_t = tan ($ ángulo_de_vuelo_r); $ flight_intercept = $ flight_angle_t * $ plane_distance; return $ flight_intercept; } / * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - * / / * * Utilice la fórmula de Haversine para calcular la distancia (en km) entre dos puntos especificados por * latitud / longitud (en grados numéricos) * * de: fórmula de Haversine - RWSinnott, "Virtues of the Haversine", * Sky and Telescope, vol 68, no 2, 1984 * https://williams.best.vwh.net/avform.htm#Crs * * ejemplo de uso del formulario: * result.value = LatLon.distHaversine (lat1.value.parseDeg (), long1.value.parseDeg (), * lat2.value.parseDeg (), long2.value.parseDeg ()); * donde lat1, long1, lat2, long2 y result son campos de formulario * source = instantglobe.com/CRANES/GeoCoordTool.html * / function get_distHaversine ($ home_lat, $ home_lon, $ plane_lat, $ plane_lon) {$ R = 6371; // radio medio de la Tierra 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 (raíz cuadrada ($ a), raíz cuadrada (1- $ a)); $ d = $ R * $ c; return $ d; } función 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 ($ latitud_en_ grados); $ lon = deg2rad ($ longitud_en_ grados); $ radio = 6371; # Radio del paralelo en la latitud dada; $ radio_paralelo = $ radio * cos ($ lat); $ lat_min = $ lat - $ half_side_in_km / $ radio; $ lat_max = $ lat + $ half_side_in_km / $ radio; $ lon_min = $ lon - $ half_side_in_km / $ paralelo_radio; $ lon_max = $ lon + $ half_side_in_km / $ paralelo_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); matriz de retorno ($ 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 () {// retorno completamente opcional (TRUE); } function start () {echo "start / n"; $ comando = "cerdos w 17 1"; execInBackground ($ comando); $ activo = VERDADERO; while ($ activo) {usleep (1000); // opcional, si quiere ser considerado if (microtime (true)> = $ nextTime) {fexp (); $ nextTime = microtime (verdadero) + INTERVAL; } $ activo = checkForStopFlag (); }} fexp (); comienzo(); ?>

Paso 14: Cableado del LED y el interruptor de apagado

Realmente, el cableado de este proyecto no podría ser más sencillo. Solo hay un LED que está conectado al pin 17 y a tierra con una resistencia 270R en línea.

También incluyo un botón de apagado y encendido junto con un LED de encendido que sale del pin de datos TXd. Puede leer más sobre la función de apagado y el código requerido en https://github.com/Howchoo/pi-power-button.git desde el sitio https://howchoo.com/g/mwnlytk3zmm/how-to- add-a-pow… Puede leer acerca de cómo agregar una luz de encendido aquí