Luz de pista do Raspberry PI de alerta precoce usando dados de mapeamento de vôo: 14 etapas (com imagens)

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:37

Esta lâmpada surgiu por vários motivos, pelo qual estou sempre interessado nos aviões que sobrevoam e durante o verão, nos fins de semana, muitas vezes há alguns bastante emocionantes voando por aí. Embora você só tenda a ouvi-los à medida que passam. Então, a outra razão é que parece que a rota de vôo para aviões que partem do aeroporto de London City às vezes será ouvida e eles têm alguns voos bem barulhentos em andamento. Por ser o único que me interessa em gravar alguns vídeos para o YouTube, é realmente irritante ter que descartar uma gravação por causa de um avião barulhento. Então, eu me perguntei se os dados que você vê em sites como o flightradar24 estão disponíveis publicamente, uma vez que descobri que algo semelhante estava disponível na rede opensky, surgiu a lâmpada de alerta precoce. Não demorou muito para surgir a ideia de usar uma réplica de uma luz de pista para abrigar o projeto.

Você pode descobrir mais sobre a Rede OpenSky em https://www.opensky-network.org Eu também queria desta vez fazer uma boa lente de resina em vez de usar PLA translúcido e embora eu tenha um receptor ADS-B que queria manter tão simples e barato. O ADS-B também precisa de uma antena e isso não serviria para uma lâmpada ir para a prateleira do escritório. Então, esperançosamente, você achará a construção interessante, pois cobre impressão 3D, moldagem de resina e matemática, bem como para extrapolar as posições de aeronaves que podem potencialmente passar por cima.

Etapa 1: Projetando o caso

A pesquisa do Google apresenta muitos designs diferentes de lâmpadas de passarela e o design desta foi feito usando influências de design de muitas marcas diferentes de lâmpadas reais. Também é dimensionado para ficar em uma sala ou em uma prateleira, em vez de no tamanho real, já que tendem a ser muito maiores na vida real.

Os designs foram elaborados no Fusion 360 e importei alguns elementos anteriores, como o suporte zero pi raspberry de projetos anteriores. Ser capaz de reutilizar os elementos elimina muito a dor de cabeça de aprender o básico. Você também pode baixar os arquivos aqui

Etapa 2: Fundindo as lentes - #fail

O elemento de design mais importante desta lâmpada seria a lente. Então eu abordei isso primeiro, pois sem um espelho autêntico e bonito o projeto iria funcionar. Estou documentando aqui as falhas que tive em tentar conseguir isso, embora também tenha decidido inicialmente fazer a lente âmbar. As luzes da pista vêm em âmbar e azul e foi só depois que comecei a fazer a âmbar que mudei de ideia e decidi que queria uma azul.

Pelo que pude perceber, os âmbar são usados na linha de espera e os azuis são usados para alinhar a pista, e esses são os que parecem ser os mais arquetípicos encontrados se você procurar por luzes de pista. No entanto, aqui está minha primeira tentativa de fazer uma lente âmbar. Para fazer a lente, eu ia usar resina clarificada com um aditivo de cor e, embora já tenha feito alguns moldes antes, me perguntei se seria possível imprimir um molde 3D e usá-lo. Então comecei fazendo um molde dividido em 3D e imprimindo-o em PetG. Eu estava convencido de que quantidades judiciosas de desmoldante seriam suficientes para curar o molde. Acontece que, com algumas tentativas, fiz a resina grudar no molde como cola e simplesmente não parecia possível separá-los. Embora eu tivesse a escala real que usaria, decidi contra ela e imprimi a lente para usar com moldagem de silicone tradicional.

Etapa 3: Diferentes tipos de resina

Como um aparte rápido, usei 3 tipos de resinas transparentes / coloridas para este projeto.

O primeiro era um tipo de mercado Hobby chamado Pebeo-Gedeo e é normalmente vendido para encapsular pequenos itens e usado para joias e pesos de papel de mesa, etc. Isso funcionou muito bem e curou bem em cerca de 24-36 horas. No entanto, é bastante caro para a quantidade que você recebe, mas é prático e facilmente disponível em lojas de hobby e artesanato. É misturado na proporção de 2: 1. A segunda era uma resina pré-colorida que é misturada a uma proporção de 10: 1 com o endurecedor e isso demorava mais para curar, cerca de uma semana para ser honesto antes de estar totalmente curado. A última era uma resina transparente, que também foi misturada na proporção de 2: 1 e esta curada em cerca de 2 dias, você pode colorir isso com gotas de pigmento, mas você precisa ter certeza de usar sempre a mesma proporção de cor se você estão fazendo lotes separados. Também funciona como o mais econômico. Por último, o RTV para o molde era um GP-3481 RTV e isso leva cerca de 24 horas para definir e tem um tempo de preparação bastante longo, então você tem bastante tempo para misturá-lo e despejá-lo.

No momento eu não tenho um pote de vacumn (atualmente em ordem) para que você possa ser assediado por bolhas tanto no molde quanto no derramamento de resina. Não é um grande problema para isso, mas com uma lente transparente ou semelhante, você gostaria de pensar em alguma maneira de tirar as bolhas das mixagens.

Etapa 4: Fundição da lente no molde de silicone nº 2

Portanto, esta é a segunda tentativa de fazer uma lente de resina e o primeiro estágio foi fazer as duas lentes no Fusion 360 e depois imprimi-las em ABS e também um balde para segurá-las. Este seria o molde para o molde e ajuda a reduzir a quantidade de silicone a ser usada. Você pode fazer isso facilmente com um cartão, mas é apenas uma abordagem diferente. Para dar uma chance melhor de se soltar do molde, primeiro apliquei um verniz e depois apliquei uma boa cobertura de agente desmoldante de cera.

Em seguida, derramei um pouco de GP-3481, que é cerca de 27 RTV da costa e, em seguida, deixei assentar nas próximas 24 horas antes de desmoldar. Feito isso, usei a resina transparente misturada na proporção de 2: 1 com cerca de 4/5 gotas do pigmento de cor e misturei bem por uns bons quatro minutos. Derramei isso no molde e, em seguida, coloquei um copo na resina para fornecer um vazio mais tarde para uma lâmpada ou LEDs. Após cerca de 24 horas, a resina estava pronta para ser removida e a lente ficou muito boa. Existem bolhas de ar presentes, mas ainda não tenho um recipiente a vácuo para desgaseificar a resina antes de despejar.

Etapa 5: Impressão e preparação 3D

O modelo foi projetado de forma que a seção central se encaixe na base. Isso evitou o mascaramento durante o processo de pintura. Todo o modelo foi impresso em Hatchbox ABS e depois lixado. Começando com grão 60 até cerca de 800 grão deu um acabamento de superfície bom o suficiente para este modelo.

Etapa 6: Montagem e pintura

Depois que as impressões são lixadas, elas foram pintadas com um primer de alta espessura. Lixado levemente e pulverizado com primer cinza. As partes principais foram pintadas em amarelo ford e, em seguida, em verde riacho usado para a base. realces de prata tamiya foram então aplicados aos parafusos e um pouco de cromo de prata molotow usado no suporte da lente.

Etapa 7: primeiro encontre os aviões em uma área delimitadora

Com o hardware classificado, o software precisava ser trabalhado. Existem alguns sites agora que fornecem rastreamento de voos, mas não muitos que fornecem uma API para acessar esses dados. Alguns que o fazem, apenas o fazem comercialmente, mas felizmente existe um site chamado https://opensky-network.org que você pode usar gratuitamente.

Para acessar esses dados você tem que se registrar e então você pode usar sua API, ela fornece várias funções e formas de puxar os dados. Estamos interessados em todos os voos dentro de uma área e eles têm uma chamada de API ao vivo para isso. https://opensky-network.org/apidoc/ chamada caixa delimitadora. A chamada API requer os cantos da caixa em que você está interessado, é claro, nosso Lat / Lon como o ponto central. Você pode verificar se a matemática funciona neste site, que desenha uma caixa dependendo do que você digita. Http://tools.geofabrik.de mas por enquanto o script a seguir fornece os pontos que precisamos para conectar na API.

função 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); $ raio = 6371; $ parallel_radius = $ radius * 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); array de retorno ($ box_lat_min, $ box_lon_min, $ box_lat_max, $ box_lon_max);

Se você quiser testar seu código, existe um site onde você pode inserir a latitude / longitude e ver os resultados em um mapa: Veja um exemplo de caixa delimitadora em um mapa

Etapa 8: Calculando a direção dos aviões em relação a nós

Os resultados da chamada da API da caixa delimitadora nos dão uma lista de aviões, seu Lon / lat, velocidade, altitude e direção. Portanto, a próxima coisa que precisamos fazer é obter a direção de cada plano em relação a nós para que possamos processar posteriormente aqueles que estão pelo menos indo em nossa direção geral. Podemos fazer isso porque conhecemos nossa posição e podemos calcular o ângulo de nós em relação a cada plano.

Para fazer isso, uso um trecho de código que originalmente estava em Javascript, então o converti aqui para PHP, * calcule o rumo (inicial) entre dois pontos * * de: Formulário de Aviação de Ed Williams, https://williams.best.vwh.net/avform.htm#Crs * source = instantglobe.com/CRANES/GeoCoordTool.html * / função 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;

Se quiser ver a página onde estão as versões originais do javascript, este é o link:

dentro desse código, você também pode ver as várias sub-rotinas para cada tipo de cálculo.

Etapa 9: Calculando uma Interceptação Olhando para um Círculo

Portanto, agora temos um plano em que a direção entre ele e nossa localização é inferior a 90 (positiva ou negativa) e isso significa que há uma chance de que ele voe por perto. Usando a fórmula Haversine, também podemos calcular usando o Lon / Lat do avião e o Lon / Lat da nossa casa a distância que ele está de nós.

Olhando para o diagrama, se desenharmos um círculo ao redor de nossa casa de, digamos, cerca de 3 milhas de raio, isso nos dará a chance de ver qualquer coisa voando. Sabemos a diferença na direção entre o avião e nós, também sabemos a distância do avião de nós, então podemos calcular o triângulo usando o bom e velho SOHCAHTOA e, neste caso, usando o Tan do ângulo, podemos obter o comprimento do lado oposto. Portanto, se compararmos esse valor com o valor do raio do círculo ao redor da casa, podemos descobrir se o avião vai voar perto o suficiente para que possamos vê-lo. A próxima parte que podemos fazer é calcular o tempo que o avião vai passar usando a velocidade do ar e a distância e, se for menos do que cerca de 45 segundos, ligamos a luz. Este é um pouco do código que uso para calcular a chance de um sobrevôo. Faço isso porque há um aeroporto próximo e quando os aviões estão taxiando, eles inevitavelmente apontam para a casa. No entanto, como a altitude deles é zero e a velocidade é ritmo de caminhada, isso não deve disparar o alarme.

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;

if (($ flight_angle <90) && ($ flight_intercept <3)) {// possível voar passado

}

return $ flight_intercept;

}

Etapa 10: Distância entre dois pontos em um mapa - Fórmula Haversine

Portanto, temos que calcular a distância entre o avião e nossa localização. Em distâncias curtas em um mapa você poderia calcular aproximadamente a distância, mas como a Terra é esférica, existe uma fórmula chamada fórmula Haversine que permite levar em consideração a superfície curva. Você pode ler mais sobre a fórmula:

Agora, com a distância calculada e sabemos a velocidade do avião, podemos calcular quantos segundos levarão até que o avião esteja acima. Portanto, a luz acenderá se houver algo dentro de 30 segundos após o flypast e finalmente tivermos nossa luz de advertência.

* baseado em 0n JS em instantglobe.com/CRANES/GeoCoordTool.html e transformado em PHP * /

função get_distHaversine ($ home_lat, $ home_lon, $ plane_lat, $ plane_lon) {$ R = 6371; // raio médio da terra em 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; return $ d; }

Etapa 11: Importando e Definindo o Banco de Dados Plane

Uma das outras peças é que o site opensky oferece um banco de dados de aviões para download, juntamente com seus indicativos e idents. Suas várias centenas de milhares de entradas. Portanto, podemos baixar isso e carregá-lo localmente em um banco de dados MariaDB para pesquisa (MySQL). A cada plano que aparece acima, recuperamos seus detalhes e atualizamos um contador para mostrar quantas vezes ele foi visto.

Também estou editando o banco de dados para destacar os aviões nos quais estou interessado. Principalmente pássaros de guerra antigos e outros aviões semelhantes interessantes. Algumas vezes neste verão, um Mig-15 sobrevoou. então o objetivo é usar um campo de alerta que eu adicionei e, em seguida, piscar a luz rapidamente quando algo interessante estiver se aproximando

Etapa 12: Melhorar os resultados e novos recursos

Então, em teoria, tudo funciona muito bem, mas você verá com os dados que existem aviões que sobrevoam que não aparecem na API.

Isso ocorre porque nem todos os aviões estão usando o transponder ADS-B e usam transponders mais antigos baseados no MLAT. Para obter dados de posição em aeronaves usando MLAT, é necessária uma série de receptores no solo para triangular sua posição e alguns sites como o flightradar24 têm uma rede maior de colaboradores fazendo isso em comparação com o opensky. Espero que com o tempo sua cobertura também melhore e estou configurando meu próprio receptor MLAT para adicionar a esses dados.

Etapa 13: Codebase

Não se esqueça que, se for usar isso, você pode querer remover as instruções SQL se não tiver o banco de dados de aviões e também adicionar seu próprio valor Lon / Lat e chave API para acessar os dados de voo.

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

define ("INTERVALO", (20 * 1)); function fexp () {$ lat = "sua latitude"; $ lon = "sua longitude"; $ lado = 15,75; $ box = get_bounding_box ($ lat, $ lon, $ side); $ latmin = $ box [0]; $ lonmin = $ box [1]; $ latmax = $ box [2]; $ lonmax = $ box [3]; $ flyurl = "https://opensky-network.org/api/states/all?lamin=$latmin&lomin=$lonmin&lamax=$latmax&lomax=$lonmax"; echo "Varrendo o CÉU"; $ start_time = microtime (verdadeiro); $ json = file_get_contents ($ flyurl); $ data = json_decode ($ json, TRUE); $ entrada = FALSO; $ num_planes = count ($ data ['states']); if ($ num_planes> 0) {echo "e podemos ver $ num_planes planos / n"; para ($ x = 0; $ x 0) {$ plane_eta = $ distplane / $ air_speed_kmh; } mais {$ eta = 1; } if ((($ intercept) 0)) && ($ distplane0) {$ inbound = TRUE; echo "------------------------------------------------ -------------------- / n "; echo "$ icao24 - [$ country $ callsign] em [$ geo_altitude_m M - $ geo_altitude_f ft]"; echo "[speed $ air_speed_kmh kmh and", round ($ distplane, 1), "km away] n"; echo "[em um título de", round ($ plane_heading, 1), "] [homeangle $ header_d]"; echo "[$ latitude, $ longitude] n"; echo "[flypast in", decimal_to_time ($ plane_eta), "now", round ($ intercept, 1), "km away / n"; echo "------------------------------------------------ -------------------- / n "; $ DBi = new mysqli ("127.0.0.1", "root", "sua senha", "awacs"); $ sql = "selecionar * do banco de dados da aeronave onde` 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 "indicativo ="; echo $ row_getplanedata ['registro']; echo "é um"; echo $ row_getplanedata ['manufacturername']; echo ""; echo $ row_getplanedata ['model']; echo "por"; echo $ row_getplanedata ['manufacturericao']; echo "propriedade de"; echo $ row_getplanedata ['proprietário']; echo "visto"; echo $ row_getplanedata ['visitas']; echo "times"; echo "classificação especial ="; echo $ row_getplanedata ['especial']; echo "\ n"; $ visitas = $ row_getplanedata ['visitas'] + 1; } while ($ row_getplanedata = mysqli_fetch_assoc ($ getplanedata)); mysqli_free_result ($ getplanedata); $ sqli = "ATUALIZAR visitas SET de banco de dados de aeronaves = $ visitas ONDE icao24 = '$ icao24'"; mysqli_set_charset ($ DBi, "utf8"); $ updateplanedata = mysqli_query ($ DBi, $ sqli) ou die (mysqli_error ($ DBi)); } else {echo "Não foi possível encontrar este plano no banco de dados, então adicionando-o"; $ sqli = "INSERIR NO banco de dados da aeronave (icao24, visitas, especiais) VALORES ('$ icao24', 1, 1)"; $ updateplanedata = mysqli_query ($ DBi, $ sqli) ou die (mysqli_error ($ DBi)); } echo "----------------------------------------------- --------------------- / n "; } else {// echo "$ indicativo"; }}} else {echo "e os céus estão limpos / n"; } if ($ inbound) {echo "Avião de entrada / n"; $ command = "pigs w 17 1"; execInBackground ($ command); } else {echo "sem voos de entrada / n"; $ command = "pigs w 17 0"; execInBackground ($ command); }} função decimal_to_time ($ decimal) {$ offset = 0,002778; if ($ decimal> $ deslocamento) {$ decimal = $ decimal - 0,002778; } $ horas = gmdate ('H', floor ($ decimal * 3600)); $ minutos = gmdate ('i', floor ($ decimal * 3600)); $ segundos = gmdate ('s', floor ($ decimal * 3600)); retornar str_pad ($ horas, 2, "0", STR_PAD_LEFT). ":". str_pad ($ minutos, 2, "0", STR_PAD_LEFT). ":". str_pad ($ segundos, 2, "0", STR_PAD_LEFT); } / * * calcule o rumo (inicial) entre dois pontos * * de: Formulário de Aviação 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; } função 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 $ flight_intercept; } / * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - * / / * * Use a fórmula Haversine para calcular a distância (em km) entre dois pontos especificados por * latitude / longitude (em graus numéricos) * * de: Fórmula Haversine - RWSinnott, "Virtues of the Haversine", * Sky and Telescope, vol 68, no 2, 1984 * https://williams.best.vwh.net/avform.htm#Crs * * exemplo de uso do formulário: * result.value = LatLon.distHaversine (lat1.value.parseDeg (), long1.value.parseDeg (), * lat2.value.parseDeg (), long2.value.parseDeg ()); * onde lat1, long1, lat2, long2 e result são campos de formulário * source = instantglobe.com/CRANES/GeoCoordTool.html * / function get_distHaversine ($ home_lat, $ home_lon, $ plane_lat, $ plane_lon) {$ R = 6371; // raio médio da terra em 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; return $ 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); $ raio = 6371; # Raio do paralelo na latitude dada; $ parallel_radius = $ radius * 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); array 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); } função start () {echo "começando / n"; $ command = "pigs w 17 1"; execInBackground ($ command); $ ativo = TRUE; while ($ active) {usleep (1000); // opcional, se você quiser ser atencioso if (microtime (true)> = $ nextTime) {fexp (); $ nextTime = microtime (verdadeiro) + INTERVAL; } $ active = checkForStopFlag (); }} fexp (); começar(); ?>

Etapa 14: Conectando o LED e o interruptor de desligamento

A fiação deste projeto não poderia ser mais simples. Há apenas um LED conectado ao pino 17 e aterrado com um resistor 270R embutido.

Eu também incluo um botão de desligar e ligar junto com um LED de energia que sai do pino de dados TXd. Você pode ler mais sobre a função de desligamento e o código necessário em https://github.com/Howchoo/pi-power-button.git no site https://howchoo.com/g/mwnlytk3zmm/how-to- add-a-pow… Você pode ler sobre como adicionar uma luz de energia aqui