SKETCH 6 - il GOTO adattato alle equatoriali
In questa pagina modificheremo lo Sketch per adattarlo meglio alle montature equatoriali.
La volta scorsa avevo detto che la funzione goto_object( ) confrontava le coordinate scegliendo la via più breve per raggiungere il target. In effetti questo è vero in generale, non considerando le due coordinate in coppia, ma singolarmente.
Immaginiamo però di osservare un corpo celeste con un telescopio su una montatura equatoriale; supponiamo che questo astro abbia le seguenti coordinate:
AR = 15h 00m 00s e DEC = + 70° 00' 00''
Terminata la breve osservazione, ci vogliamo spostare con il GOTO verso un altro astro avente la stessa declinazione, ma Ascensione Retta opposta, cioè
AR = 03h 00m 00s e DEC = + 70° 00' 00''
La cosa è fattibile se l'astro è circumpolare. Il GOTO ha due possibilità:
Nota la latitudine del luogo di osservazione φ, un astro è circumpolare se la sua declinazione è maggiore del seguente angolo (ovviamente si trascurano ostacoli come montagne, ecc.):
DECtarget > 90° – φ
quindi al polo nord sono circumpolari tutte le stelle con declinazione maggiore di zero, all'equatore invece, non ci sono stelle circumpolari.
Sorge spontanea una domanda: in questi casi, conviene sempre passare per il polo celeste per raggiungere il target? Assolutamente no!
Conviene solo se l'ampiezza dell'angolo della coordinata di AR per raggiungere l'obiettivo è maggiore dell'angolo compiuto dall'asse di DEC per raggiungere il lato opposto al polo, sommato del rimanente angolo di AR necessario per raggiungere il target. Con un disegno tutto diventa più chiaro:
In questa pagina modificheremo lo Sketch per adattarlo meglio alle montature equatoriali.
La volta scorsa avevo detto che la funzione goto_object( ) confrontava le coordinate scegliendo la via più breve per raggiungere il target. In effetti questo è vero in generale, non considerando le due coordinate in coppia, ma singolarmente.
Immaginiamo però di osservare un corpo celeste con un telescopio su una montatura equatoriale; supponiamo che questo astro abbia le seguenti coordinate:
AR = 15h 00m 00s e DEC = + 70° 00' 00''
Terminata la breve osservazione, ci vogliamo spostare con il GOTO verso un altro astro avente la stessa declinazione, ma Ascensione Retta opposta, cioè
AR = 03h 00m 00s e DEC = + 70° 00' 00''
La cosa è fattibile se l'astro è circumpolare. Il GOTO ha due possibilità:
- lascia fermo l'asse DEC e ruota di 180° l'asse di AR (ed è quello che farebbe arduino con il precedente Sketch);
- non agisce sull'asse AR, ma ruota l'asse di declinazione di 40° verso nord.
Nota la latitudine del luogo di osservazione φ, un astro è circumpolare se la sua declinazione è maggiore del seguente angolo (ovviamente si trascurano ostacoli come montagne, ecc.):
DECtarget > 90° – φ
quindi al polo nord sono circumpolari tutte le stelle con declinazione maggiore di zero, all'equatore invece, non ci sono stelle circumpolari.
Sorge spontanea una domanda: in questi casi, conviene sempre passare per il polo celeste per raggiungere il target? Assolutamente no!
Conviene solo se l'ampiezza dell'angolo della coordinata di AR per raggiungere l'obiettivo è maggiore dell'angolo compiuto dall'asse di DEC per raggiungere il lato opposto al polo, sommato del rimanente angolo di AR necessario per raggiungere il target. Con un disegno tutto diventa più chiaro:
Chiameremo:
- p il punto in cui la lunghezza dei due percorsi per raggiungerlo è la stessa;
- δ la distanza in gradi (somma di AR e DEC) che intercorre tra la posizione iniziale del telescopio e il punto p, nella figura corrisponde a 40+ 70 = 110°;
- β l'angolo percorso dall'asse DEC per partire dalla posizione iniziale (cioè la declinazione attuale del telescopio), oltrepassare il polo celeste e raggiungere la declinazione del target.
β = (90° – DECtel) + (90° – DECtarget) δ = β + [ (180° – β) / 2 ]
Quindi, se rispetto alla posizione del telescopio, il target si trova ad un distanza di AR inferiore o uguale a δ conviene proseguire con GOTO tradizionale, in caso contrario sarà più breve il percorso attraverso il polo celeste. Ovviamente δ è in funzione di due variabili: la declinazione del telescopio e la declinazione del target, quindi varierà di volta in volta.
ATTENZIONE: quando viene fatto questo confronto, bisogna ricordarsi di lavorare con grandezze omogenee. In una rotazione completa lungo la coordinata di AR, ci sono 86400 secondi perché questa coordinata è suddivisa in 24 ore. In una rotazione completa lungo la coordinata di DEC invece, ci sono 1296000 secondi (d'arco) perché questa è suddivisa in 360°. Per rendere omogenee le due grandezze è sufficiente moltiplicare per 15 i secondi della coordinata di AR, poi si può procedere con il confronto.
Infine, rimanendo sempre nel confronto tra i due percorsi, ricordo di non trascurare il problema che si presenta quando il target e il reticolo del telescopio si trovano a cavallo del cerchio orario delle 0h 00m 00s. Ragionando in ore, per semplicità, se il target si trova alle 23h 00m 00s e il telescopio è puntato alle 1h 00m 00s, la distanza da considerare tra i due punti è di 2 ore e non di 23h – 1h = 22 ore... Per ottenere il 2 da questa sottrazione, si utilizza la seguente regola:
se ( ARtarget – ARtel ) > 12ore tolgo 24 ore al risultato della sottrazione
nell'esempio sopra si ha 22 ore – 24 ore = –2 ore e poi considero il valore assoluto con la funzione abs( ), perché una lunghezza è sempre positiva.
Nel caso opposto, cioè se il target si trova alle 1h 00m 00s mentre il telescopio è puntato alle 23h 00m 00s si avrà 1h – 23h = –22 ore, pertanto la regola sarà:
se ( ARtarget – ARtel ) < –12ore aggiungo 24 ore al risultato della sottrazione, ottenendo –22 ore + 24 ore = 2 ore
La stessa cosa vale per l'emisfero sud, qui però, bisogna prestare attenzione ai segni invertiti nel calcolo del δ. Anche se banale, è meglio precisarlo.
Rimane ancora una considerazione da fare. Purtroppo stellarium non invia i dati relativi alla latitudine del luogo di osservazione, nonostante questa funzione sia disponibile nel protocollo LX200. Non resta quindi che inserirla o attraverso una tastiera se siamo astrofili nomadi, o scritta direttamente nello Sketch se lavoriamo in postazione fissa. Procedendo a piccoli passi, tralasceremo per il momento la tastiera.
Applichiamo quindi questa variante al precedente Sketch per fare in modo che il GOTO scelga veramente la via più breve per raggiungere il target.
IMPORTANTE: Ovviamente non vengono presi in considerazione ostacoli fisici dovuti alle varie montature, come motori che urtano contro parti della stessa o altro. Ogni montatura è diversa e ciascuno deve conoscere a fondo la propria e prendere le relative contromisure. Come già detto, tutto questo lavoro ha solo uno scopo didattico, poi ognuno è libero di fare quello che ritiene sotto la propria responsabilità e non la mia. Se ruotando l'asse di AR rompete con il contrappeso il naso alla suocera non ringraziate o accusate me... è solo opera vostra!
Diamo on'occhiata allo Sketch, le modifiche principali sono nella funzione getDEC( ), nel loop e qualcosina in goto_object( ). I commenti sono in fondo alla pagina.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Created 31 March 2014 * * by EDC * * http://epsilonphoto.weebly.com/ * * * * This program is free software, you can redistribute it and/or modify. * * Is in the public domain, it only has a didactic purpose and you can modify it * * to your liking. I do not provide any guarantee for any damage it may cause * * to property or persons. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ #include <stdlib.h> const int buttonAlign = 53; // pin in cui l'interruttore abilita l'allineamento con una stella int buttonState = 0; // variabile in cui arduino andrà a leggere lo stato logico di buttonAlign char input[20]; // array di char in cui verranno memorizzati i dati in ingresso char txAR[10]; // array di char in cui verranno memorizzati i dati in uscita char txDEC[11]; // array di char in cui verranno memorizzati i dati in uscita long ARtel, DECtel; // coordinate del telescopio espresse in secondi long ARtarget, DECtarget; // coordinate del target espresse in secondi long ARdist, ARdiff, DECdiff; // differenza tra le coordinate del target e del telescopio long arHH, arMM, arSS; // coordinata AR del telescopio da trasmattere a stellarium char SIGNtel; // segno della DEC: 43 = + 45 = - long decDEG, decMM, decSS; // coordinata DEC del telescopio da trasmettere a stellarium long memoDEC; // memorizza DECtarget (serve se si attraversa il polo celeste) long latitude; long betaN, deltaN, betaS, deltaS; int A = 0; boolean circumpolar, enablegoto; void setup() { pinMode(buttonAlign, INPUT); Serial.begin(9600); ARtarget = ARtel = 22300; // coordinata iniziale di AR (in secondi) per visualizzare il reticolo del telescopio DECtarget = DECtel = 35105; // coordinata iniziale di DEC (in secondi) per visualizzare il reticolo del telescopio latitude = 165600; circumpolar = false; enablegoto = false; } void loop() { if(Serial.available()>0){ communication(); } ARdiff = ARtarget - ARtel; DECdiff = DECtarget - DECtel; if ((A == 1) && (DECdiff == 0)){ // una volta arrivato al polo, inverte di 12 ore la coordinata AR del telescopio A = 0; if(ARtel >= 43200){ ARtel = ARtel - 43200; }else{ ARtel = ARtel + 43200; } DECtarget = memoDEC; // ristabilisce le coordinate originali del target DECdiff = DECtarget - DECtel; } if ((A == 0) && (DECdiff == 0) && (ARdiff == 0)){ enablegoto = false; // disabilita il goto } if((enablegoto == true) && ((ARdiff != 0) || (DECdiff != 0))){ goto_object(); } } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void communication(){ int i=0; input[i++] = Serial.read(); delay(5); while((input[i++] = Serial.read()) != '#'){ delay(5); } input[i]='\0'; if(input[1]==':' && input[2]=='G' && input[3]=='R' && input[4]=='#'){ // con il comando #:GR# stellarium chiede l'invio della coordinata di AR transmitAR(); } if(input[1]==':' && input[2]=='G' && input[3]=='D' && input[4]=='#'){ // con il comando #:GD# stellarium chiede l'invio della coordinata di AR transmitDEC(); } if(input[1]==':' && input[2]=='Q' && input[3]=='#'){ // con il comando #:Q# stellarium chiede l'arresto dei motori // inviare l'arresto ai motori } if(input[0]==':' && input[1]=='S' && input[2]=='r'){ // con il comando :Sr stellarium invia la coordinata di AR getAR(); } if(input[0]==':' && input[1]=='S' && input[2]=='d'){ // con il comando :Sd stellarium invia la coordinata di DEC getDEC(); } if(input[0]==':' && input[1]=='M' && input[2]=='S' && input[3]=='#'){ // con il comando :MS# stellarium chiede se la rotazione è possibile Serial.print("0"); buttonState = digitalRead(buttonAlign); // legge se l'interruttore per l'allineamento iniziale è su ON o OFF if (buttonState == HIGH) { // se HIGH aggiorna le coordinate, altrimenti proseguià con il GOTO ARtel = ARtarget; DECtel = DECtarget; }else{ enablegoto = true; // abilita il goto } } } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void transmitAR(){ // trasmissione dati nella forma HH:MM:SS# arHH = ARtel/3600; // ricava le ore della coordinata AR del telescopio arMM = (ARtel-arHH*3600)/60; // ricava i minuti della coordinata AR del telescopio arSS = (ARtel-arHH*3600)-arMM*60; // ricava i secondi della coordinata AR del telescopio sprintf(txAR, "%02d:%02d:%02d#", int(arHH), int(arMM), int(arSS)); Serial.print(txAR); } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void transmitDEC(){ // trasmissione dati nella forma sDDßMM:SS# (dove s è il segno + o -) (DECtel < 0) ? SIGNtel = 45: SIGNtel = 43; // controllo del segno della coordinata DEC del telescopio decDEG = abs(DECtel)/3600; // ricava i gradi della coordinata DEC del telescopio decMM = (abs(DECtel) - decDEG*3600)/60; // ricava i minuti della coordinata DEC del telescopio decSS = (abs(DECtel) - decDEG*3600) - decMM*60; // ricava i secondi della coordinata DEC del telescopio sprintf(txDEC, "%c%02d%c%02d:%02d#", SIGNtel, int(decDEG), 223, int(decMM), int(decSS)); Serial.print(txDEC); } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void getAR(){ // riceve la coordinata AR del target nel formato :Sr HH:MM:SS# Serial.print("1"); ARtarget = (atol(input+4))*3600 + (atol(input+7))*60 + atol(input+10); // converte in secondi la coordinata AR del target } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void getDEC(){ // riceve la coordinata AR del target nel formato :Sd +DDßMM:SS# Serial.print("1"); DECtarget = (atol(input+5))*3600 + (atol(input+8))*60 + atol(input+11); // converte in secondi la coordinata DEC del target if (input[4] == '-'){ // per una corretta conversione ha prelevato solo la parte numerale DECtarget *=(-1); // (cioè senza il segno) pertanto se la coordinata DEC è negativa, dopo } // la conversione in secondi viene moltiplica per -1 memoDEC = DECtarget; betaN = (324000-DECtel)+(324000-DECtarget); deltaN = betaN + ((648000-betaN)/2); betaS = ((-324000)-DECtel)+((-324000)-DECtarget); deltaS = abs(betaS) + ((648000-abs(betaS))/2); if (((latitude > 0) && (DECtarget > (324000-latitude))) || ((latitude < 0) && (DECtarget < ((-324000)-latitude)))) { // verifica se il target è circumpolare circumpolar = true; }else{ circumpolar = false; } ARdist = ARtarget - ARtel; if (ARdist < (-43200)){ // calcola la distanza minima in AR ARdist = ARdist + 86400; } if (ARdist > 43200){ // calcola la distanza minima in AR ARdist = ARdist - 86400; } if ((latitude > 0) && (circumpolar = true) && ((abs(ARdist)*15) > deltaN)){ // ARdist*15 perché le grandezze devono essere omogenee (AR = 24h, DEC = 360°) DECtarget = 324000; // imposta la via per il polo nord celeste A = 1; } if ((latitude < 0) && (circumpolar = true) && ((abs(ARdist)*15) > deltaS)){ // ARdist*15 perché le grandezze devono essere omogenee (AR = 24h, DEC = 360°) DECtarget = (-324000); // imposta la via per il polo sud celeste A = 1; } } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void goto_object(){ if (A != 1){ // il movimento in AR è disabilitato (A = 1) se si deve passare per il polo if ((ARdiff >0 && ARdiff <= 43200) || (ARdiff <=(-43200))){ // confronta le coordinate di AR e sceglie la via più breve per raggiungere il target go_east(); } if ((ARdiff > 43200) || (ARdiff <0 && ARdiff > (-43200))){ go_west(); } } if (DECtarget > DECtel){ // confronta le coordinate di DEC e sceglie la via più breve per raggiungere il target go_north(); } if (DECtarget < DECtel){ go_south(); } } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void go_east(){ ARtel++; // in questo Sketch l'incremento è semplicemente aritmetico, in realtà deve provenire if(ARtel >= 86400){ // da una lettura dei dati dell'encoder, oppure per le montature sprovviste, dal ARtel = ARtel - 86400; // numero dei passi del motore (meno preciso perché non tiene conto del backlash } // dell'eventuale motoriduttore o degli step persi. // inviare comando al motore AR } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void go_west(){ ARtel--; // in questo Sketch il decremento è semplicemente aritmetico, in realtà deve provenire if(ARtel < 0){ // da una lettura dei dati dell'encoder, oppure per le montature sprovviste, dal ARtel = ARtel + 86400; // numero dei passi del motore (meno preciso perché non tiene conto del backlash } // dell'eventuale motoriduttore o degli step persi. // inviare comando al motore AR } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void go_north(){ // in questo Sketch l'incremento è semplicemente aritmetico, in realtà deve provenire DECtel++; // da una lettura dei dati dell'encoder, oppure per le montature sprovviste, dal // inviare comando al motore DEC // numero dei passi del motore (meno preciso perché non tiene conto del backlash // dell'eventuale motoriduttore o degli step persi. } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void go_south(){ // in questo Sketch il decremento è semplicemente aritmetico, in realtà deve provenire DECtel--; // da una lettura dei dati dell'encoder, oppure per le montature sprovviste, dal // inviare comando al motore DEC // numero dei passi del motore (meno preciso perché non tiene conto del backlash // dell'eventuale motoriduttore o degli step persi. } //--------------------------------------------------------------------------------------------------------------------------------------------------------
sesto_sketch.ino | |
File Size: | 13 kb |
File Type: | ino |
log_telescopeserver1_6.txt | |
File Size: | 73 kb |
File Type: | txt |
Innanzitutto dobbiamo impostare la nostra latitudine φ espressa in secondi d'arco in void setup( ). Nello Sketch c'è la mia: +46° ovvero 165600''
Nella funzione getDEC( ), vengono calcolati i δ sia per l'emisfero nord che per il sud, viene stabilito se il target è circumpolare e infine viene valutato se conviene passare per il polo celeste. In caso affermativo, viene inibito il movimento di AR (spiegherò poi il perché di questa scelta) e assegnato il polo come nuovo target, non prima di aver memorizzato in memoDEC la declinazione del target originale. Viene poi portata a 1 il valore della variabile "A" che serve da indice.
Giunti al loop si viene mandati a goto_object( ) Qui se A è diverso da 1, il ciclo continua come al solito, se invece A = 1, il movimento di AR è inibito e il telescopio procede verso il polo muovendosi solo in DEC.
Raggiunto il polo, DECdiff ovviamente è zero, è quindi riassegnato il valore 0 alla variabile indice A, viene invertita di dodici ore la coordinata di AR del telescopio (perché dovrà scendere dal lato opposto) e viene riassegnata la coordinata originale di DEC del target. La coordinata di AR del target, invece, è sempre rimasta in memoria in ARtarget senza subire alcun spostamento perché il blocco era imposto sul "motore" di AR.
A questo punto arduino è libero di raggiungere il target perché è stato abilitato il "motore" di AR.
Raggiunto il target, nel loop viene disabilitato il gotoobj e si è pronti per ricominciare per una nuova destinazione.
Le cose che mi hanno fatto impazzire:
inizialmente pensavo di lasciare inalterata getDEC( ) e di lavorare solo in goto_object( ), ma ho avuto grossi problemi.
Memorizzavo le due coordinate del target (sia AR che DEC) nelle rispettive memoAR e memoDEC.
Uguagliavo ARtarget con ARtel, in modo da non far spostare il telescopio lungo questa coordinata e assegnavo come DECtarget il polo.
Avviato il programma, il telescopio non si muoveva lungo AR (bene), saliva lungo la DEC (molto bene), ma si arrestava prima del polo, alla declinazione iniziale del target (decisamente male!). In qualche modo veniva riassegnata la coordinata originale di DEC del target.
Il problema consisteva nel fatto che il ciclo di loop è molto rapido e dopo aver ricavato il DECtarget nella funzione getDEC( ), il ciclo andava in goto_object( ) dove avvenivano le assegnazioni per raggiungere il polo. A questo punto pensavo che il loop non andasse una seconda volta in getDEC( ), perché nell'array input[ ] ci dovevano essere dati diversi (se ricordate stellarium, dopo aver inviato la coordinata di declinazione, invia il comando :MS#. Mi sbagliavo, questa ricezione non era ancora avvenuta, pertanto data la permanenza nell'array dei dati della declinazione del target, la coordinata del polo che avevo assegnato veniva sovrascritta.
Ho quindi trasferito tutto il malloppo in getDEC( ) e finalmente il polo era raggiungibile. Si presentava però un altro problema: prima di partire verso il polo, il telescopio ruotava di pochi gradi in AR in direzione del target. Mi chiedevo come poteva succedere dato che in getDEC( ) avevo imposto ARtarget = ARtel. In sostanza l'uguaglianza delle coordinate non era immediata.
La causa era sempre dovuta alla rapidità del loop. Ricevuta la coordinata di AR, il programma provvedeva allo spostamento del telescopio lungo questa, prima ancora di ricevere la coordinata di DEC (di conseguenza ancor prima di sapere se il GOTO sceglierà di andare attraverso il polo). Sono stato costretto a interdire l'accesso a goto_object( ) fino all'arrivo del comando :MS#, infatti qui troverete il comando enablegoto = true. A questo punto ho preferito bloccare anche l'accesso al movimento in AR ponendo A = 1 in getDEC( ) rendendo inutile uguagliare ARtarget con ARtel.
Al momento tutto sembra funzionare.
Se riscontrate degli errori o malfunzionamenti, vi sarei grato se me li segnalate attraverso il modulo CONTACT, posto in questo sito in alto a destra.
Ricordo di modificare la latitudine se volete fare alcune prove in corrispondenza del polo sud, altrimenti il sistema non funziona perché le costellazioni australi non sono circumpolari alle nostre latitudini...
Nella funzione getDEC( ), vengono calcolati i δ sia per l'emisfero nord che per il sud, viene stabilito se il target è circumpolare e infine viene valutato se conviene passare per il polo celeste. In caso affermativo, viene inibito il movimento di AR (spiegherò poi il perché di questa scelta) e assegnato il polo come nuovo target, non prima di aver memorizzato in memoDEC la declinazione del target originale. Viene poi portata a 1 il valore della variabile "A" che serve da indice.
Giunti al loop si viene mandati a goto_object( ) Qui se A è diverso da 1, il ciclo continua come al solito, se invece A = 1, il movimento di AR è inibito e il telescopio procede verso il polo muovendosi solo in DEC.
Raggiunto il polo, DECdiff ovviamente è zero, è quindi riassegnato il valore 0 alla variabile indice A, viene invertita di dodici ore la coordinata di AR del telescopio (perché dovrà scendere dal lato opposto) e viene riassegnata la coordinata originale di DEC del target. La coordinata di AR del target, invece, è sempre rimasta in memoria in ARtarget senza subire alcun spostamento perché il blocco era imposto sul "motore" di AR.
A questo punto arduino è libero di raggiungere il target perché è stato abilitato il "motore" di AR.
Raggiunto il target, nel loop viene disabilitato il gotoobj e si è pronti per ricominciare per una nuova destinazione.
Le cose che mi hanno fatto impazzire:
inizialmente pensavo di lasciare inalterata getDEC( ) e di lavorare solo in goto_object( ), ma ho avuto grossi problemi.
Memorizzavo le due coordinate del target (sia AR che DEC) nelle rispettive memoAR e memoDEC.
Uguagliavo ARtarget con ARtel, in modo da non far spostare il telescopio lungo questa coordinata e assegnavo come DECtarget il polo.
Avviato il programma, il telescopio non si muoveva lungo AR (bene), saliva lungo la DEC (molto bene), ma si arrestava prima del polo, alla declinazione iniziale del target (decisamente male!). In qualche modo veniva riassegnata la coordinata originale di DEC del target.
Il problema consisteva nel fatto che il ciclo di loop è molto rapido e dopo aver ricavato il DECtarget nella funzione getDEC( ), il ciclo andava in goto_object( ) dove avvenivano le assegnazioni per raggiungere il polo. A questo punto pensavo che il loop non andasse una seconda volta in getDEC( ), perché nell'array input[ ] ci dovevano essere dati diversi (se ricordate stellarium, dopo aver inviato la coordinata di declinazione, invia il comando :MS#. Mi sbagliavo, questa ricezione non era ancora avvenuta, pertanto data la permanenza nell'array dei dati della declinazione del target, la coordinata del polo che avevo assegnato veniva sovrascritta.
Ho quindi trasferito tutto il malloppo in getDEC( ) e finalmente il polo era raggiungibile. Si presentava però un altro problema: prima di partire verso il polo, il telescopio ruotava di pochi gradi in AR in direzione del target. Mi chiedevo come poteva succedere dato che in getDEC( ) avevo imposto ARtarget = ARtel. In sostanza l'uguaglianza delle coordinate non era immediata.
La causa era sempre dovuta alla rapidità del loop. Ricevuta la coordinata di AR, il programma provvedeva allo spostamento del telescopio lungo questa, prima ancora di ricevere la coordinata di DEC (di conseguenza ancor prima di sapere se il GOTO sceglierà di andare attraverso il polo). Sono stato costretto a interdire l'accesso a goto_object( ) fino all'arrivo del comando :MS#, infatti qui troverete il comando enablegoto = true. A questo punto ho preferito bloccare anche l'accesso al movimento in AR ponendo A = 1 in getDEC( ) rendendo inutile uguagliare ARtarget con ARtel.
Al momento tutto sembra funzionare.
Se riscontrate degli errori o malfunzionamenti, vi sarei grato se me li segnalate attraverso il modulo CONTACT, posto in questo sito in alto a destra.
Ricordo di modificare la latitudine se volete fare alcune prove in corrispondenza del polo sud, altrimenti il sistema non funziona perché le costellazioni australi non sono circumpolari alle nostre latitudini...
Quinto Sketch
|
Sesto Sketch
|