Urządzenie wskazujące położenie Międzynarodowej Stacji Kosmicznej

Listing 1. Firmware programu do wskazywania pozycji ISS

// ISS Tracker - David Hunt
// Wersja 1.4
// Licencja - Attribution Non-Commercial Share Alike (by-nc-sa)
// pobierz wszystkie niezbędne biblioteki za pomocą menedżera bibliotek
#include < AccelStepper . h >
// do sterowania silnikami krokowymi
#include < ezTime . h >
#include < WiFi . h >
#include < HTTPClient . h >
// aby pobrać dane z API
#include < ArduinoJson . h >
// aby wyodrębnić informacje o lokalizacji ISS
#include < U8g2lib . h >
// wyszukaj U8g2 w menedżerze bibliotek
#include < Wire . h >

time_t next_pass_timestamp = 1572652800 ; // 2 listopada 2019 jako punkt odniesienia
const char ssid [ ] = "Twoja sieć tutaj" ; // SSID sieci (nazwa)
const char pass [ ] = "Hasło routera" ; // twoje hasło sieciowe
const int touch_threshold = 40 ; // wejście touchpin (T0) jest GPIO4
const pływak steps_per_degree = XXL Standard 4096 / 360 ; // 4096 kroków na obrót w trybie pół kroku
double my_latitude = 51,89970 ; // zmień tutaj swoją lokalizację
double my_longitude = - 2.12084 ; // znajdź swoje współrzędne za pomocą google maString next_pass_JSON; // dane o lokalizacji są pobierane w formacie JSON
int next_risetime ;
int next_duration ;

U8G2_SSD1306_128X32_UNIVISION_F_HW_I2C u8g2 ( U8G2_R0 ) ;
// Definicje pinów silnika w numerach GPIO
#define motor_pin_az1 13 // IN1 w sterowniku ULN2003
#define motor_pin_az2 12 // IN2 w sterowniku ULN2003
#define motor_pin_az3 14 // IN3 w sterowniku ULN2003
#define motor_pin_az4 27 // IN4 na Sterownik ULN2003

# zdefiniować motor_pin_el1 26 // IN1 na sterowniku ULN2003
# zdefiniować motor_pin_el2 25 // IN2 na sterowniku ULN2003
# zdefiniować motor_pin_el3 33 // IN3 na sterowniku ULN2003
# zdefiniować motor_pin_el4 32 // IN4 na sterowniku ULN2003

#define MotorInterfaceType 8 // 8 = tryb pół kroku, 4 = tryb pełnego kroku
// Inicjalizacja za pomocą sekwencji pinów IN1-IN3-IN2-IN4 do korzystania z biblioteki AccelStepper z silnikiem krokowym 28BYJ-48:
AccelStepper azimuth_motor = AccelStepper ( MotorInterfaceType , motor_pin_az1 , motor_pin_az3 , motor_pin_az2 , motor_pin_az4 ) ;
AccelStepper elevation_motor = AccelStepper ( MotorInterfaceType , motor_pin_el1 , motor_pin_el3 , motor_pin_el2 , motor_pin_el4 ) ;

Strefa czasowa my_timezone ;

// użyj internetu, aby sprawdzić czas następnego przelotu
void get_next_pass ( double lat , double lon , int & p_risetime , int & p_duration ) {
HTTPClient http ;
const char * api_host = "http://api.open-notify.org/iss-pass.json?lat=" ;
char my_lat_position [ 10 ] ;
char my_lon_position [ 10 ] ;
char api_address [ 255] ;
//
zamień współrzędne zapisane jako podwójne na łańcuchy z dokładnością do 4 dp dtostrf ( lat , 7 , 4 , my_lat_position ) ;
dtostrf ( lon , 7 , 4 , my_lon_position ) ;
// utwórz adres URL za pomocą polecenia get
strcpy ( api_address , api_host ) ;
strcat ( api_address , my_lat_position ) ;
strcat ( api_address , "& lon =") ;
strcat ( api_address , my_lon_position ) ;
// pobierz tylko czas i datę następnego przebiegu
strcat ( api_address , "& n = 1" ) ;

http . begin ( api_address ) ;
int httpCode = http . GET ( ) ;
if ( httpCode > 0 ) {
String payload = http . getString ( ) ;
// Serial.println (httpCode);
// Serial.println (ładunek);
const size_t capacity = JSON_OBJECT_SIZE ( 2 ) + JSON_OBJECT_SIZE ( 3 ) + 200;
DynamicJsonDocument doc ( pojemność ) ;
DeserializationError error = deserializeJson ( doc , payload ) ;
p_duration = doc [ "odpowiedź" ] [ 0 ] [ "czas trwania" ] ; // zapisz tę wartość do next_duration
p_risetime = doc [ "response" ] [ 0 ] [ "risetime" ] ; // zapisz tę wartość do next_risetime
}
else {
Serial . println ( "Błąd żądania HTTP" ) ;
}
http . koniec ( ) ; // Zwolnij zasoby
}
// przekonwertuj to do postaci czytelnej dla człowieka w dniach, godzinach, minutach i sekundach
String time_to_next_flyby ( int next_observation ) {
int time_remaining ;
int next_rise_days ;
int next_rise_hours ;
int next_rise_minutes ;
int next_rise_seconds ;
Strunowy countdown_time ;
time_remaining = next_observation - teraz ( ) ;
next_rise_days = time_remaining / ( 3600 * 24 ) ;
time_remaining % = ( 3600 * 24 ) ;
next_rise_hours = time_remaining / 3600 ;
time_remaining % = 3600 ;
next_rise_minutes = time_remaining / 60 ;
next_rise_seconds = time_remaining 60 % ;
countdown_time + = next_rise_days ;
countdown_time + = "dni" ;
countdown_time + = next_rise_hours ;

if ( next_rise_minutes < 10 ) {
countdown_time + = ": 0" ; } // dodaj wiodące zero dla pojedynczej cyfry
else {
countdown_time + = ":" ;
}
countdown_time + = next_rise_minutes ;
if ( next_rise_seconds < 10 ) {
countdown_time + = ": 0" ; } // dodaj wiodące zero dla pojedynczej cyfry
else {
countdown_time + = ":" ;
}
countdown_time + = next_rise_seconds ;
return countdown_time ;
}

// znajdź aktualne położenie ISS nad Ziemią
// i oblicz kąty, aby wskazać na nią z naszej lokalizacji
void point_to_ISS ( ) {
HTTPClient http ;
podwójna szerokość geograficzna ;
podwójna długość geograficzna ;
if ( http . begin ( "http://api.open-notify.org/iss-now.json" ) ) {
int httpCode = http . GET ( ) ;
// httpCode będzie ujemny, jeśli wystąpi błąd,
jeśli ( httpCode > 0 ) {
String ISS_Location_Data = http . getString ( ) ;
//Serial.println(httpCode); // to będzie 200 dla pomyślnego pobrania
//Serial.println(ISS_Location_Data); // dane Json
const size_t capacity = JSON_OBJECT_SIZE ( 2 ) + JSON_OBJECT_SIZE ( 3 ) + 200 ;
DynamicJsonDocument doc ( pojemność ) ;
DeserializationError error = deserializeJson ( doc, ISS_Location_Data ) ;
// const char * message = doc ["wiadomość"];
long timestamp = doc [ "timestamp" ] ;
latitude = doc [ "iss_position" ] [ "latitude" ] ;
longitude = doc [ "iss_position" ] [ "longitude" ] ;

// Wydrukuj wartości przydatne do debugowania, aby sprawdzić, czy działa
//Serial.println(timestamp);
//Serial.println(latitude, 4);
//Serial.println(longitude, 4);
}
else {
Serial . print ( "Błąd HTTP:" ) ;
Szeregowy . println ( http . errorToString ( httpCode ) . c_str ( ) ) ;
}
http . koniec ( ) ; // Zwolnij zasoby
}
else {
Serial . wydrukować( „Błąd HTTP: nie można się połączyć” ) ;
}

// ESP32 oblicza kąty w radianach (nie w stopniach)
double latitude_in_radians = latitude * PI / 180 ;
double longitude_in_radians = longitude * PI / 180 ;
double my_latitude_in_radians = my_latitude * PI / 180 ;
double my_longitude_in_radians = my_longitude * PI / 180 ;
// oblicz kierunek azymutu na ISS
double x = cos (latitude_in_radians ) * sin ( longitude_in_radians - my_longitude_in_radians ) ;
double y = cos ( my_latitude_in_radians ) * sin ( latitude_in_radians ) - sin ( my_latitude_in_radians ) * cos ( latitude_in_radians ) * cos ( longitude_in_radians - my_longitude_in_radians ) ;
podwójne b = atan2 ( x, y ) ;
//Serial.print("Bearing to ISS: ");
b = b * 180 / PI ; // konwersja na stopnie
//Serial.println(b);

// obliczyć namiar na wysokość do ISS
double earth_radius = 6371 ; // średnia wartość w km
double orbit = 412 ; // średnia wartość w km - może sprawdź też tę wartość?
double x1 = earth_radius * cos ( my_latitude_in_radians ) * cos ( my_longitude_in_radians ) ;
double y1 = earth_radius * cos ( my_latitude_in_radians ) * sin ( my_longitude_in_radians );
double z1 = earth_radius * sin ( my_latitude_in_radians ) ;
double x2 = earth_radius * cos ( latitude_in_radians ) * cos ( longitude_in_radians ) ;
double y2 = earth_radius * cos ( latitude_in_radians ) * sin ( longitude_in_radians ) ;
double z2 = earth_radius * sin (latitude_in_radians ) ;

double dist_to_nadir = sqrt ( sq ( x2 - x1 ) + sq ( y2 - y1 ) + sq ( z2 - z1 ) ) ;
//Serial.print("Distance to nadir: ");
//Serial.println(dist_to_nadir);
podwójne geocentric_angle_in_radians = 2 * asin ( dist_to_nadir / ( 2 * earth_radius ) ) ;
//Serial.print("Geocentric angle w stopniach: ");
//Serial.println(geocentric_angle_in_radians * 180 / PI);
podwójna odległość_do_ISS = sqrt ( sq ( orbita + promień_ziemia ) + sq ( promień_ziemi ) - 2 * ( orbita + promień_ziemi ) * promień_ziemi * cos ( geocentric_ang_in_radians ) ) ;
//Serial.print("Distance to ISS: ");
//Serial.println(distance_to_ISS);
double ISS_angle = ( 180 / PI ) * asin ( ( orbit + earth_radius ) * ( sin ( geocentric_angle_in_radians ) / distance_to_ISS ) ) ;

// azymutalny silnik krokowy ma 4096 pół kroków na obrót i przełożenie 113/22
azymut_motor . moveTo ( XXL Standard 4096 / 360 * 113 / 22 * b ) ;
// silnik elewacji ma 4096 pół kroków na obrót
Elevation_motor . moveTo ( XXL Standard 4096 / 360 * ISS_angle ) ;

// uruchom silnik, czekając na aktualizację współrzędnych co 5 sekund
double holding_time = now ( ) ;
while ( now ( ) - holding_time < 5 ) {
azymuth_motor . run ( ) ;
Elevation_motor . run ( ) ;
wydajność ( ) ;
}
}

// wydrukuj wiadomości na OLED używając dwóch wierszy tekstu
void display_message ( String line_one , String line_two ) {
u8g2 . setFont ( u8g2_font_8x13_tr ) ;
//u8g2.setFont(u8g2_font_fur14_tr);
u8g2 . firstPage ( ) ;
u8g2 . setCursor ( 0 , 15 ) ;
u8g2 . print ( line_one ) ;
u8g2 . setCursor ( 0 ; 31 ) ;
u8g2 . print ( line_two ) ;
u8g2 . nextPage ( ) ;
}

void setup ( ) {
Serial . rozpocząć ( 115200 ) ;
opóźnienie ( 3000 ) ; // spróbuj tego, aby umożliwić OLED nawiązanie komunikacji?
u8g2 . begin ( ) ; // dla OLED
u8g2 . enableUTF8Print ( ) ; //
// Ustaw maksymalne kroki silnika na sekundę:
azymuth_motor . setMaxSpeed ( 800 ) ; // duże przełożenie, więc przyspiesz to
azymuth_motor . setAcceleration( 100,0 ) ;
Elevation_motor . setMaxSpeed ( 400 ) ;
Elevation_motor . setAcceleration ( 100,0 ) ;

// ######################### sekcja kalibracji ##################### ##########
display_message ( "Strzałka zatrzymaj, gdy" , "skierowana w dół" ) ;
while ( touchRead ( T0 ) > touch_threshold ) {
elevation_motor . ruch ( 400 ) ;
Elevation_motor . run ( ) ;
}
// przycisk został naciśnięty, gdy wskaźnik elewacji jest skierowany w dół
display_message ( "Silnik podniesienia" , "ustaw na zero" ) ;
Elevation_motor . setCurrentPosition ( 0 ) ;
opóźnienie ( 1000 ) ;
display_message ( "Stop strzałka na" , "lewa strona" ) ;
while ( touchRead ( T0 ) > touch_threshold ) {
azymut_motor . ruch ( 400 ) ;
azimuth_motor . run ( ) ;
}
// przycisk jest naciśnięty, gdy wskaźnik azymutu jest skierowany do przodu
display_message („Silnik azymutu” , „ustawiony na zero” ) ;
opóźnienie ( 2000 ) ; // pauza, aby poinformować, że został naciśnięty przycisk
azimuth_motor . setCurrentPosition ( 0 ) ;
// przesuń elewację, aby wskazywała na Polaris
// ten kąt jest taki sam jak szerokość geograficzna obserwatora, punkt odniesienia w dół, więc +90
elevation_motor . moveTo ( steps_per_degree * ( my_latitude + 90 ) ) ;
Elevation_motor . runToPosition ( ) ;
display_message ( "Wskaż Polaris" , "Następnie naciśnij przycisk" ) ;
while ( touchRead ( T0 ) > touch_threshold ) { } // czekaj na naciśnięcie przycisku
display_message ( "Teraz skalibrowano" , "" ) ;
opóźnienie ( 2000 ) ; // pauza, aby powiadomić cię o naciśnięciu przycisku
// ######################## koniec sekcji kalibracji ######## ####################

// ######################### Połącz się z WiFi #################### ###################
Serial . println ( "Śledzenie ISS" ) ;
display_message ( "Wyszukiwanie" , ssid ) ;
Szeregowy . println ( ssid ) ;
WiFi . begin ( ssid , pass ) ;
while ( WiFi . status ( ) ! = WL_CONNECTED ) {
opóźnienie ( 500 ) ;
Szeregowy . print ( „.” ) ;
}
Seryjny . println ( "Połączono z Wi-Fi" ) ;
display_message ( "Połączono z" , ssid ) ;

// ######################### Synchronizuj czas z UTC ################### ############
// Odkomentuj poniższy wiersz, aby zobaczyć, co robi za kulisami
setDebug ( INFO ) ;
waitForSync ( ) ; // nie rób nic, dopóki nie nadejdzie właściwy czas

Szeregowy . println ( "Bieżący czas UTC:" + UTC . dateTime ( ) ) ;
my_timezone . setLocation ( F ( "GB" ) ) ; // <a href="/ https://en.wikipedia.org/wiki/List_of_tz_database_time_zones "> https://en.wikipedia.org/wiki/List_of_tz_database ...>
opóźnienie ( 3000 ) ;
Szeregowy . print ( F ( "Czas lokalny:" ) ) ;
Szeregowy .println ( my_timezone . dateTime ( ) ) ;
}
void loop ( ) {
events ( ) ; // dzięki temu silniki będą się poruszać
//Serial.println("COOKIE: "+ UTC.dateTime (COOKIE));
// Serial.println (dateTime (next_pass_timestamp, "D dM H: i: s"));
if ( now ( ) + next_duration > next_risetime ) { // następny przelot tylko wtedy, gdy obecny
minie get_next_pass ( my_latitude , my_longitude, next_risetime , next_duration ) ;
}
Seryjny . print ( "Następny przelot:" ) ;
//Serial.print(dateTime(next_risetime, "D dM H: i: s"));
Szeregowy . println ( time_to_next_flyby ( next_risetime ) ) ;
point_to_ISS ( ) ;
opóźnienie ( 1000 ) ;
//display_message(UTC.dateTime("H:i:s T "), my_timezone.dateTime (" H: i: s "));
display_message ( UTC . dateTime ( "H: i: s T") , time_to_next_flyby ( next_risetime ) ) ;
}