SKETCH 7 - il GOTO adattato alle altazimutali
Questa volta, partendo sempre dallo Sketch 5, adatteremo il GOTO alle montature altazimutali. Se possedete solo un montatura equatoriale potete saltare questa pagina e passare direttamente alla prossima.
C'è qualche considerazione da fare, la posizione di un astro è univocamente determinata dalle coordinate equatoriali (Ascensione Retta e Declinazione), infatti sono queste ad essere riportate sulle carte e atlanti celesti.
Le coordinate altazimutali non godono di questo privilegio, vediamo il perché: dato che la terra ruota su se stessa, le stelle sembrano percorrere degli archi nel cielo, sorgono ad Est, raggiungono la massima altezza a Sud (culminano a Sud) per poi tramontare a Ovest.
È evidente che le coordinate altazimutali di una stella, non restano invariate nel tempo, ma cambiano in continuazione. A complicare le cose, queste coordinate variano anche in base al sito di osservazione. Ad esempio, due persone poste una a Trieste e l'altra ad Aosta, che osservano contemporaneamente la stessa stella, leggono sui propri cerchi graduati delle coordinate altazimutali differenti.
Anche se sicuramente già le conoscete, vediamo un attimo come sono queste coordinate.
Questa volta, partendo sempre dallo Sketch 5, adatteremo il GOTO alle montature altazimutali. Se possedete solo un montatura equatoriale potete saltare questa pagina e passare direttamente alla prossima.
C'è qualche considerazione da fare, la posizione di un astro è univocamente determinata dalle coordinate equatoriali (Ascensione Retta e Declinazione), infatti sono queste ad essere riportate sulle carte e atlanti celesti.
Le coordinate altazimutali non godono di questo privilegio, vediamo il perché: dato che la terra ruota su se stessa, le stelle sembrano percorrere degli archi nel cielo, sorgono ad Est, raggiungono la massima altezza a Sud (culminano a Sud) per poi tramontare a Ovest.
È evidente che le coordinate altazimutali di una stella, non restano invariate nel tempo, ma cambiano in continuazione. A complicare le cose, queste coordinate variano anche in base al sito di osservazione. Ad esempio, due persone poste una a Trieste e l'altra ad Aosta, che osservano contemporaneamente la stessa stella, leggono sui propri cerchi graduati delle coordinate altazimutali differenti.
Anche se sicuramente già le conoscete, vediamo un attimo come sono queste coordinate.
Nel sistema altazimutale, il piano fondamentale è l'orizzonte dell'osservatore. Perpendicolarmente ad esso, sopra l'osservatore, c'è un punto chiamato zenit, dal lato opposto c'è il nadir. L’altezza φ del polo sull'orizzonte è detta latitudine astronomica e poiché il prolungamento dell'asse terrestre coincide con il polo celeste, la latitudine geografica di un luogo coincide con la latitudine astronomica.
La posizione di qualsiasi punto sulla sfera celeste è individuata da due coordinate:
Come si vede nella figura sotto, l'altezza h va da un minimo di 0° all'orizzonte, fino a un massimo di 90° allo zenit.
L'azimut A ha un valore di 0° a Nord, ad est ha 90°, il Sud corrisponde a 180° e l'Ovest a 270°, per poi tornare a Nord a 0° dopo aver percorso una rotazione di 360°. Questa scelta dell'origine, verso ed unità di misura, non è però universalmente accettata. Alcuni, preferiscono porre l’origine a Sud (ed è quella a cui io sono abituato). Bisogna quindi prestare attenzione alle convenzioni adottate nei singoli casi. Stellarium, ad esempio, fissa l'origine della coordinata azimuth a Nord, così mi sono adeguato.
La posizione di qualsiasi punto sulla sfera celeste è individuata da due coordinate:
- l'altezza h (detta anche ordinata sferica) del punto rispetto all'orizzonte;
- l'azimut A (detto anche ascissa sferica) ovvero l'angolo misurato partendo da Sud e procedendo in direzione Ovest, fino all'intersezione tra l'orizzonte e il cerchio passante per il punto considerato che congiunge lo zenit con il nadir. Osservando la figura sopra è molto più chiaro.
Come si vede nella figura sotto, l'altezza h va da un minimo di 0° all'orizzonte, fino a un massimo di 90° allo zenit.
L'azimut A ha un valore di 0° a Nord, ad est ha 90°, il Sud corrisponde a 180° e l'Ovest a 270°, per poi tornare a Nord a 0° dopo aver percorso una rotazione di 360°. Questa scelta dell'origine, verso ed unità di misura, non è però universalmente accettata. Alcuni, preferiscono porre l’origine a Sud (ed è quella a cui io sono abituato). Bisogna quindi prestare attenzione alle convenzioni adottate nei singoli casi. Stellarium, ad esempio, fissa l'origine della coordinata azimuth a Nord, così mi sono adeguato.
Per adattare il GOTO del quinto Sketch alle montature altazimutali, dobbiamo trasformare le coordinate equatoriali in altazimutali perché stellarium trasmette e riceve solo coordinate equatoriali (vedi ad esempio il file di log di questo Sketch). Prima di procedere facciamo ancora un piccolo ripasso sulle coordinate celesti.
Lungo l'Ascensione Retta è definito l'angolo orario H (corrispondente all'ascissa sferica), cioè l’arco di equatore celeste compreso tra il mezzocielo M (il punto in cui il meridiano interseca l'equatore celeste) e la proiezione della generica stella S sull'equatore celeste.
L'angolo orario è anche definito come l'angolo al polo celeste PMS. Trattandosi di una porzione di Ascensione Retta, l’angolo orario si misura in ore, minuti e secondi. La Declinazione δ (corrispondente all'ordinata sferica), come già sappiamo, è la distanza del punto S dall'equatore celeste.
Lungo l'Ascensione Retta è definito l'angolo orario H (corrispondente all'ascissa sferica), cioè l’arco di equatore celeste compreso tra il mezzocielo M (il punto in cui il meridiano interseca l'equatore celeste) e la proiezione della generica stella S sull'equatore celeste.
L'angolo orario è anche definito come l'angolo al polo celeste PMS. Trattandosi di una porzione di Ascensione Retta, l’angolo orario si misura in ore, minuti e secondi. La Declinazione δ (corrispondente all'ordinata sferica), come già sappiamo, è la distanza del punto S dall'equatore celeste.
L'eclittica interseca l'equatore celeste in due punti ovvero:
L'origine dell'Ascensione Retta (0h 00m 00s) è fissata nel punto γ. Adesso chiamiamo TS l'angolo orario del punto γ e continuano a chiamare H l'angolo orario del generico punto S visto sopra. Allora la coordinata di AR α del punto S, sarà: α = TSL – H e quindi TSL = AR + H |
TSL è detto Tempo Siderale Locale ed ha valore 0h 00m 00s quando il punto γ transita sul meridiano, e 24h 00m 00s al transito successivo.
Facciamo un esempio: se al meridiano abbiamo la coordinata AR = 10:00:00, cioè sono le 10TS, e la stella che osserviamo si trova ad occidente con un angolo orario di 3 ore, la sua coordinata AR sarà:
AR = 10h 00m 00s – 3h 00m 00s = 7h 00m 00s.
NOTA: Ascensione Retta, Declinazione ed eclittica, sono fisse solo in prima approssimazione, perché in realtà dipendono dal tempo, anche se molto lentamente. Per questo motivo nei cataloghi sono riportate le coordinate degli oggetti celesti riferiti sempre ad una certa epoca.
Dalla trigonometria sferica si possono ricavare le equazioni di conversione tra le coordinate. Gli angoli sono espressi in radianti, compreso l'angolo orario H, pertanto questo va prima convertito da ore in gradi, successivamente in radianti.
Facciamo un esempio: se al meridiano abbiamo la coordinata AR = 10:00:00, cioè sono le 10TS, e la stella che osserviamo si trova ad occidente con un angolo orario di 3 ore, la sua coordinata AR sarà:
AR = 10h 00m 00s – 3h 00m 00s = 7h 00m 00s.
NOTA: Ascensione Retta, Declinazione ed eclittica, sono fisse solo in prima approssimazione, perché in realtà dipendono dal tempo, anche se molto lentamente. Per questo motivo nei cataloghi sono riportate le coordinate degli oggetti celesti riferiti sempre ad una certa epoca.
Dalla trigonometria sferica si possono ricavare le equazioni di conversione tra le coordinate. Gli angoli sono espressi in radianti, compreso l'angolo orario H, pertanto questo va prima convertito da ore in gradi, successivamente in radianti.
DA EQUATORIALI AD ALTAZIMUTALI
h = arcsin ( sin φ sin δ + cos φ cos δ cos H )
A = arctan [ sin H / (cos H sin φ – tan δ cos φ) ]
Quindi note la latitudine φ del luogo d’osservazione, la declinazione δ e l’angolo orario H dell’astro, si ricavano l’altezza h e l’azimut A.
h = arcsin ( sin φ sin δ + cos φ cos δ cos H )
A = arctan [ sin H / (cos H sin φ – tan δ cos φ) ]
Quindi note la latitudine φ del luogo d’osservazione, la declinazione δ e l’angolo orario H dell’astro, si ricavano l’altezza h e l’azimut A.
DA ALTAZIMUTALI A EQUATORIALI
δ = arcsin ( sin φ sin h – cos φ cos h cos A )
H = arctan [ sin A / (cos A sin φ + tan h cos φ) ]
α = TSL – H
Per cui, note l'altezza h, l'azimut A e la latitudine del luogo di osservazione φ, si ricavano la declinazione δ e l'angolo orario H, da cui si ottiene l'Ascensione Retta α dalla terza equazione. Notate la simmetria delle equazioni, ma attenzione ai segni invertiti.
δ = arcsin ( sin φ sin h – cos φ cos h cos A )
H = arctan [ sin A / (cos A sin φ + tan h cos φ) ]
α = TSL – H
Per cui, note l'altezza h, l'azimut A e la latitudine del luogo di osservazione φ, si ricavano la declinazione δ e l'angolo orario H, da cui si ottiene l'Ascensione Retta α dalla terza equazione. Notate la simmetria delle equazioni, ma attenzione ai segni invertiti.
Dobbiamo fare una precisazione sulla funzione arcotangente arctan( ). Un calcolatore restituisce questa funzione nell'intervallo (–90° ÷ +90°), mentre noi ci aspettiamo un valore compreso tra (0° ÷ 360°). Risulta evidente che abbiamo una indeterminazione su quale quadrante appartiene il valore ottenuto.
Calcolando separatamente il numeratore e il denominatore dell'argomento arcotangente e analizzando i loro segni, possiamo ricavare il quadrante a cui appartiene il risultato (vedi tabella sotto).
Calcolando separatamente il numeratore e il denominatore dell'argomento arcotangente e analizzando i loro segni, possiamo ricavare il quadrante a cui appartiene il risultato (vedi tabella sotto).
|
QUADRANTE
I II III IV |
|
Una volta ottenuto il valore dell'angolo compreso tra (–90° ÷ +90°) basterà sommare il valore dell'offset per portarlo nel quadrante esatto.
Così abbiamo ottenuto la conversione tra le coordinate. Voglio evidenziare che nella tabella l'offset è riferito alla convenzione che fissa l'origine dell'azimut a Sud.
Per averlo a Nord, quando passiamo da equatoriale ad altazimutale, dobbiamo aggiungere all'azimut ottenuto altri 180°. Così facendo dobbiamo ricordarci però di sottrarre 360° quando l'angolo ottenuto è maggiore/uguale a 360°, in questo modo azzeriamo il valore dell'azimut una volta raggiunto il Nord.
Nella conversione opposta, cioè da altazimutale a equatoriale, prima di convertire dobbiamo togliere all'azimut 180° se questo è maggiore di 180°, se invece l'azimut è minore di 180° dobbiamo sommargli 360°. Così facendo siamo ritornati alla convenzione che pone l'origine di questa coordinata a Sud. A questo punto si può procedere alla conversione con le equazioni sopra riportate (lavorando in radianti), ricordandosi alla fine di sommare l'offset in base ai segni del numeratore e del denominatore per ottenere il valore corretto dell'angolo orario H, che va riportato da gradi a ore minuti e secondi.
Per completare la conversione dobbiamo ricavare l'Ascensione Retta dalla terza equazione. Abbiamo bisogno quindi di un altro dato: il Tempo Siderale Locale (TSL).
Come già accennato per la latitudine, anche il TSL è disponibile in stellarium, ma non c'è la possibilità di inviarlo ad Arduino, malgrado tale funzione sia prevista nel protocollo LX200. Stellarium è un ottimo programma ma necessita decisamente di un ampliamento del protocollo LX200.
Per il suddetto problema, presento solo una versione ridotta dello Sketch, ovvero senza la gestione del TSL. Ad ogni modo questo Sketch rappresenta una base per iniziare un'evoluzione successiva.
Ho posto in void setup ( ) il TSL fisso a zero. Quindi per veder funzionare correttamente il GOTO, dovete mettere in pausa il tempo su stellarium e impostare l'ora in modo di avere in meridiano il cerchio orario delle ore 0h 00m 00s. Avendo impostato le coordinate iniziali del telescopio:
AR = 0h 00m 00s e DEC = 0° 00' 00''
possiamo sfruttare il suo reticolo per impostare l'angolo orario H a zero, come in figura sotto. Impostate infine la griglia altazimutale al posto dell'equatoriale e ricordate di inserire nello Sketch la stessa latitudine (espressa in secondi d'arco) che è impostata in stellarium.
Così abbiamo ottenuto la conversione tra le coordinate. Voglio evidenziare che nella tabella l'offset è riferito alla convenzione che fissa l'origine dell'azimut a Sud.
Per averlo a Nord, quando passiamo da equatoriale ad altazimutale, dobbiamo aggiungere all'azimut ottenuto altri 180°. Così facendo dobbiamo ricordarci però di sottrarre 360° quando l'angolo ottenuto è maggiore/uguale a 360°, in questo modo azzeriamo il valore dell'azimut una volta raggiunto il Nord.
Nella conversione opposta, cioè da altazimutale a equatoriale, prima di convertire dobbiamo togliere all'azimut 180° se questo è maggiore di 180°, se invece l'azimut è minore di 180° dobbiamo sommargli 360°. Così facendo siamo ritornati alla convenzione che pone l'origine di questa coordinata a Sud. A questo punto si può procedere alla conversione con le equazioni sopra riportate (lavorando in radianti), ricordandosi alla fine di sommare l'offset in base ai segni del numeratore e del denominatore per ottenere il valore corretto dell'angolo orario H, che va riportato da gradi a ore minuti e secondi.
Per completare la conversione dobbiamo ricavare l'Ascensione Retta dalla terza equazione. Abbiamo bisogno quindi di un altro dato: il Tempo Siderale Locale (TSL).
Come già accennato per la latitudine, anche il TSL è disponibile in stellarium, ma non c'è la possibilità di inviarlo ad Arduino, malgrado tale funzione sia prevista nel protocollo LX200. Stellarium è un ottimo programma ma necessita decisamente di un ampliamento del protocollo LX200.
Per il suddetto problema, presento solo una versione ridotta dello Sketch, ovvero senza la gestione del TSL. Ad ogni modo questo Sketch rappresenta una base per iniziare un'evoluzione successiva.
Ho posto in void setup ( ) il TSL fisso a zero. Quindi per veder funzionare correttamente il GOTO, dovete mettere in pausa il tempo su stellarium e impostare l'ora in modo di avere in meridiano il cerchio orario delle ore 0h 00m 00s. Avendo impostato le coordinate iniziali del telescopio:
AR = 0h 00m 00s e DEC = 0° 00' 00''
possiamo sfruttare il suo reticolo per impostare l'angolo orario H a zero, come in figura sotto. Impostate infine la griglia altazimutale al posto dell'equatoriale e ricordate di inserire nello Sketch la stessa latitudine (espressa in secondi d'arco) che è impostata in stellarium.
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Created 6 April 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> #include <math.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 A_diff, h_diff; // 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 boolean enablegoto; long latitude, TSL, A_teltx, A_tel, h_tel, H_tel, H_target, h_target, A_target; const float pigreco = 3.141593; float phi, delta_tel, H_telRAD, h_telRAD, A_telRAD, cos_phi, sin_phi; float delta_target, H_targetRAD, h_targetRAD, A_targetRAD; float numerator1, denominator1, numerator2, denominator2; void setup() { pinMode(buttonAlign, INPUT); Serial.begin(9600); A_target = A_tel = 648000; // coordinata iniziale di Azimut A (in secondi d'arco) per visualizzare il reticolo del telescopio h_target = h_tel = 158400; // coordinata iniziale di altezza h (in secondi d'arco) per visualizzare il reticolo del telescopio latitude = 166140; // latitudine del luogo di osservazione espressa in secondi d'arco phi = (float(latitude)/3600.0)*pigreco/180.0; // latitudine in radianti cos_phi = cos(phi); sin_phi = sin(phi); enablegoto = false; TSL = 0; // in questo Sketch non c'è l'orologio siderale, pertanto TSL è fissato a zero e deve essere espresso in secondi } void loop() { if(Serial.available()>0){ communication(); } A_diff = A_target - A_tel; h_diff = h_target - h_tel; if(enablegoto == true){ 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; } enablegoto = true; // abilita il goto } } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void transmitAR(){ // trasmissione dati nella forma HH:MM:SS# convert_AZ_EQ(); 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 -) convert_AZ_EQ(); (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 enablegoto = false; // mantiene disabilitato il goto fino all'arrivo della coordinata DEC } //-------------------------------------------------------------------------------------------------------------------------------------------------------- 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 enablegoto = false; convert_EQ_AZ(); } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void convert_EQ_AZ(){ H_target = TSL - ARtarget; if (H_target < 0){ H_target = H_target + 86400; // l'angolo orario è sempre positivo } H_targetRAD = (float(H_target)*15.0/3600.0)*pigreco/180.0; // angolo orario target in radianti delta_target = (float(DECtarget)/3600.0)*pigreco/180.0; // declinazione target espressa in radianti h_targetRAD = asin(sin_phi*sin(delta_target) + cos_phi*cos(delta_target)*cos(H_targetRAD)); h_targetRAD = (h_targetRAD*180.0/pigreco)*3600.0; // altezza h espressa in secondi d'arco h_target = long(h_targetRAD); numerator1 = sin(H_targetRAD); denominator1 = (cos(H_targetRAD)*sin_phi - tan(delta_target)*cos_phi); A_targetRAD = atan(numerator1/denominator1); A_targetRAD = (A_targetRAD*3600.0)*180.0/pigreco; // A_targetRAD espresso in secondi d'arco A_target = long(A_targetRAD); if ((numerator1 >= 0) && (denominator1 >=0)){ // aggiungo l'offset. Ho incluso anche la correzione per avere A_target = A_target + 648000; // l'origine dell'azimut a Nord aggiungendo altri 180° (espressi } // in secondi d'arco) if(denominator1 < 0){ A_target = A_target + 1296000; } if ((numerator1 < 0) && (denominator1 >=0)){ A_target = A_target + 1944000; } if (A_target >= 1296000){ // se l'azimut supera i 360° sottraggo 360° A_target = A_target-1296000; } } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void convert_AZ_EQ(){ A_teltx = A_tel; A_teltx = A_teltx - 648000; // ripristino l'origine dell'azimut a Sud togliendo 180° if(A_teltx < 0){ // e se risultasse negativo aggiungo 360° A_teltx = A_teltx + 1296000; } A_telRAD = (float(A_teltx)/3600.0)*pigreco/180.0; // Azimut A del telescopio espresso in radianti h_telRAD = (float(h_tel)/3600.0)*pigreco/180.0; // altezza h del telescopio espressa in radianti delta_tel = asin(sin_phi*sin(h_telRAD) - cos_phi*cos(h_telRAD)*cos(A_telRAD)); // declinazione del telescopio in radianti delta_tel = (delta_tel*180.0/pigreco)*3600.0; // declinazione del telescopio in secondi d'arco DECtel = long(delta_tel); numerator2 = sin(A_telRAD); denominator2 = (cos(A_telRAD)*sin_phi + tan(h_telRAD)*cos_phi); H_telRAD = atan(numerator2/denominator2); H_telRAD = (H_telRAD*180.0/(pigreco))*(3600.0/15.0); // H_telRAD espresso in secondi H_tel = long(H_telRAD); if(denominator2 < 0){ // aggiungo l'offset H_tel = H_tel + 43200; } if ((numerator2 < 0) && (denominator2 >=0)){ H_tel = H_tel + 86400; } if (H_tel >= 86400){ H_tel = H_tel - 86400; } ARtel = TSL - H_tel; if (ARtel < 0){ // l'Ascensione Retta è sempre positiva ARtel = ARtel + 86400; } } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void goto_object(){ if ((A_diff >0 && A_diff <= 648000) || (A_diff <=(-648000))){ //confronta le coordinate di AR e sceglie la via più breve per raggiungere il target increment_A_tel(); } if ((A_diff > 648000) || (A_diff <0 && A_diff > (-648000))){ decrement_A_tel(); } if (h_target > h_tel){ //confronta le coordinate di DEC e sceglie la via più breve per raggiungere il target go_up(); } if (h_target < h_tel){ go_down(); } } //-------------------------------------------------------------------------------------------------------------------------------------------------------- void increment_A_tel(){ A_tel++; // in questo Sketch l'incremento è semplicemente aritmetico, in realtà deve provenire if(A_tel >= 1296000){ // da una lettura dei dati dell'encoder, oppure per le montature sprovviste, dal A_tel = A_tel - 1296000; // 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 decrement_A_tel(){ A_tel--; // in questo Sketch il decremento è semplicemente aritmetico, in realtà deve provenire if(A_tel < 0){ // da una lettura dei dati dell'encoder, oppure per le montature sprovviste, dal A_tel = A_tel + 1296000; // 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_up(){ // in questo Sketch l'incremento è semplicemente aritmetico, in realtà deve provenire h_tel++; // 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_down(){ // in questo Sketch il decremento è semplicemente aritmetico, in realtà deve provenire h_tel--; // 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. } //--------------------------------------------------------------------------------------------------------------------------------------------------------
settimo_sketch.ino | |
File Size: | 16 kb |
File Type: | ino |
log_telescopeserver1_7.txt | |
File Size: | 213 kb |
File Type: | txt |
Come avete potuto notare ho aggiunto due funzioni: convert_EQ_AZ( ) e convert_AZ_EQ( ). Sono state dichiarate per questo delle variabili float, in quanto convertendo i gradi in radianti sono necessari i decimali. Devo fare una precisazione, l'utilizzo delle variabili di tipo float o double, rallentano notevolmente i processi di calcolo (provare per credere), pertanto si devono usare solo quando è necessario. Quindi la maggior parte del processo avviene con le variabili di tipo long, mentre le float entrano in gioco solo per il calcolo nelle funzioni goniometriche. Per questo motivo il calcolo di sin φ e cos φ avviene in void setup( ) dato che non devono cambiare durante il loop.
Lo sketch che avevo inizialmente scritto non funzionava correttamente. Nel processo di conversione delle coordinate perdevo delle cifre significative. Questo comportava il disallineamento del telescopio rispetto al target. Ciò era dovuto alla dimenticanza di forzare le costanti intere a float quando sono sottoposte a operazioni con queste ultime. Per forzarle è sufficiente scriverle con uno zero decimale (ad esempio 180 diventa 180.0).
Le variabili double hanno una lunghezza di 8 byte, cioè una precisione di 64 bit, quindi doppia rispetto alle float. Se come me usate arduino MEGA 2560 R3, che è basato su ATMEGA, le variabili double occupano solo 4 bytes, esattamente come le float. Pertanto l'utilizzo delle double è del tutto inutile, presenteranno lo stesso grado di precisione delle float.
Un ultimo accenno al TSL, sicuramente arduino non può gestirlo da solo in questo Sketch, il ciclo di loop non è costante nel tempo, ma dipende di volta in volta da quello che deve fare. Probabilmente una soluzione è l'utilizzo di una shield esterna.
Ci lavorerò prossimamente, ogni tanto tornate a farmi visita...
Lo sketch che avevo inizialmente scritto non funzionava correttamente. Nel processo di conversione delle coordinate perdevo delle cifre significative. Questo comportava il disallineamento del telescopio rispetto al target. Ciò era dovuto alla dimenticanza di forzare le costanti intere a float quando sono sottoposte a operazioni con queste ultime. Per forzarle è sufficiente scriverle con uno zero decimale (ad esempio 180 diventa 180.0).
Le variabili double hanno una lunghezza di 8 byte, cioè una precisione di 64 bit, quindi doppia rispetto alle float. Se come me usate arduino MEGA 2560 R3, che è basato su ATMEGA, le variabili double occupano solo 4 bytes, esattamente come le float. Pertanto l'utilizzo delle double è del tutto inutile, presenteranno lo stesso grado di precisione delle float.
Un ultimo accenno al TSL, sicuramente arduino non può gestirlo da solo in questo Sketch, il ciclo di loop non è costante nel tempo, ma dipende di volta in volta da quello che deve fare. Probabilmente una soluzione è l'utilizzo di una shield esterna.
Ci lavorerò prossimamente, ogni tanto tornate a farmi visita...