quinta-feira, 4 de abril de 2024

Acompanhamento sideral DIY (faça você mesmo).




 Voltando aqui depois de bastante tempo para fazer um sistema de acompanhamento sideral simples para montagem de telescópio equatorial somente com eixo RA (EQ1).

A ideia é fazer um sistema simples barato e de qualidade. Podem implementar bluetooth e Wi-Fi pra controle no celular, mas sinceramente não vejo necessidade nenhuma, pois localizou o astro pela buscadora, ajustou, ligou o acompanhamento, não precisa mexer mais. Vou passar superficialmente por alguns assuntos apenas para ilustrar a base do funcionamento do sistema, sendo necessário alguma pesquisa extra por conta do leitor.

RA significa (right ascension) ou ascensão correta. 

Como a montagem equatorial funciona:

O planeta Terra esta se movimentando no próprio eixo com uma duração de 23 horas, 56 minutos e 4 segundos para os 360º (dia sideral). Já o dia solar é o que tem o tempo “normal” ao qual estamos acostumados, com alguns minutos a mais que entram na conta porque a medida de 24 horas de um dia é feita com base no movimento do Sol no céu. Isso porque, enquanto a Terra segue ocupada em sua órbita, ela fica um pouco “atrasada” em relação à nossa estrela, que se desloca em relação a nós. Então, para alcançar o Sol na mesma posição em que estava, nosso planeta “precisa girar mais um pouco”, e aí sim ficamos com 24 horas no nosso dia.


Então para o acompanhamento sideral dar certo, utilizaremos como referência o dia sideral 23h56m4s.


E como um extra, se quiser fazer o acompanhamento da Lua com precisão, o “dia Lunar” tem 24h48min.

Ler mais nesse artigo: http://astro.if.ufrgs.br/lua/lua.htm

Como sabemos, o planeta Terra é redondo e para alinhar o eixo de rotação do telescópio com o eixo do planeta, tem que se considerar a latitude do local do telescópio. Para ficar mais fácil de entender veja essa ilustração.





Sobre o equipamento em questão, estou usando uma montagem equatorial simples EQ1, onde até temos um ajuste de declinação simples manual, e onde trabalharemos, que é no eixo RA, que é constituído por uma main gear (engrenagem principal) de 100 dentes e uma worm gear (engrenagem helicoidal). Essas engrenagens tem uma relação 100:1, uma volta na engrenagem helicoidal avançada 1 (um) dente da engrenagem principal.

Imagem do RA EQ1.

Lembrando que é sempre bom regular o equilíbrio da montagem com o equipamento e distribuição de peso.





Vamos falar um pouco do motor de passo. Utilizei um 17Hs441S. Este é o modelo do fabricante. Mas pode ser qualquer um com essas especificações; nema 17 (que é o padrão de furacões e tamanho do motor), 4,2kg (esse é um valor em um modo de operação específico, mas normalmente anunciam desta forma). 1,8° por passo ou 200 passos por revolução.

Os passos por revolução é a resolução do motor, 360° dividido pelos 200 passos temos 1,8° por passo. Existe motores com resolução de 400 passos por revolução resultando em 0,9° por passo, mas são difíceis de encontrar.

E temos o driver e para este projeto aqui está a cereja para a qualidade do projeto. Estou usando o driver TMC2209. Ele é um driver que permite “ampliar” a resolução dos motores. Entenda resolução aqui como uma forma de deixar a movimentação o mais suave possível! E além disso deixa mais silenciosa a operação do motor, coisa que as vezes incomoda um pouco (casos de outros drivers fique barulhento).


Imagem de um sinal pwm


Na imagem acima vemos o funcionamento de um driver comum, cada pulso ele aciona e desaciona uma bobina fazendo o eixo se movimentar. 1:1 fase a fase o motor fica com a resolução 200 passos por revolução, limitando a 1,8° por passo. O que é muito pouco para o acompanhamento fluido, sendo perceptível os “tranquinhos do motor”.

No funcionamento dos drivers pode ser selecionado algumas resoluções diferentes, como por exemplo a que usei para o projeto. No driver tmc2209 é possível selecionar o modo de 1/64 que consegue através do controle de intensidade das 2 bobinas do motor dividir 1 passo em 64 micro passos. O sinal do pwm (pulse width modulation) modulação por largura de pulso, tem modulação de amplitude também, fazendo com que o sinal pareça uma senoide, e consequentemente deixando o movimento do motor mais suave. Comparando ficaria com um ângulo de 0,028125° por micropasso, bem melhor e bem mais suave.


Imagem pwm quase senoidal.


Vídeo falando mais sobre micro passos na CNC (Controle Numérico Computadorizado).


Mas essa configuração de micro passos tem seu preço fazendo com que o motor perca um pouco de torque. Situação que pode ser contornada com uma polia de redução que além de multiplicar o torque acrescenta mais resolução no sistema. No meu caso utilizei 2 polias uma de 60 dentes e outra de 20 dentes padrão GT2. Optei pela correia de 6mm de largura por ser bem leve o torque requisitado, essa com 170mm para ajustar a polia do RA com a polia do motor.

Para observação visual funciona muito bem, ou até mesmo astrofotografia com pouco tempo de exposição, porém se a expectativa é usar para astrofotografia profissional ou de qualidade elevada, é bom melhorar essa resolução… pode se utilizar redução de polias ainda maior, caixa de engrenagens, engrenagens orbitais ou o meu preferido redução harmônica, ou mais fácil de encontrar como harmonic drives. Com tamanhos super compactos e redução de 100:1 ou mais.



vídeo mostrando uma redução harmônica


Agora começa a parte chata. Temos que calcular quantos passos, ou no caso micro passos vamos precisar para dar uma volta completa no RA do telescópio.
Só multiplicar as reduções… 
Engrenagem principal = 100
Redução das polias = 3
Passos do motor = 200
Micropassos do driver = 64

100*3*200*64 = 3.840.000 dividido por 360° temos 10.666,66666666667, vamos considerar só 10.666 micro passos por grau. (Guarda essa informação).

Agora precisamos saber quanto tempo demora esses 360°. Lembra lá no começo do texto, o planeta terra demora 23h56m4s para dar uma volta “360°” completa no seu próprio eixo. Então… 

Vamos converter tudo isso para segundos pra facilitar.
23*60*60+56*60+4 = 86.164 segundos.

Dividido por 360° temos 239,34 segundos por grau.


Sabendo disso conseguimos saber o tempo de acionamento de cada micro passo.

Então dividimos 239,34 : 10.666 = 0,02243953 segundos por micro passo.

Na programação do Arduino utilizaremos essa medida em micro segundos.

Então multiplicamos por 1.000.000.
Dando nosso intervalo de acionamento de 22.439µs.


Calculo para a Lua e Sol (tempo para a mesma posição no céu depois de 360º de rotação da Terra).

Lua 24h48m
Vamos converter tudo isso para segundos pra facilitar.
24*60*60+48*60 = 89.280 segundos.
Dividido por 360° temos 248 segundos por grau.

Sol 24h
Vamos converter tudo isso para segundos pra facilitar.
24*60*60 = 86.400 segundos.
Dividido por 360° temos 240 segundos por grau.


E é só isso. Simple né.

Rsrs não não é… Tenho que agradecer ao post do “gspeed” da comunidade cloudynights que com toda a paciência explicou os cálculos e ainda disponibilizou o código de Arduino, sendo que modifiquei aqui para servir ao meu propósito de utilizar uma EQ1 com driver tmc2209:



Agora vamos as ligações elétricas onde optei por selecionar a resolução do driver manualmente pelos pinos MS1 e MS2.

Esquema de ligação com Arduino. Pode ser usado qualquer Arduino que tenha o atmega 328 16mhz, pra dar conta e funcionar direitinho é importante ser o de 16mhz, normalmente é, mas é legal ficar atento.

Lista de compras:
Arduino (Uno, Nano, Pro Mini). pode ser qualquer um, lembrando que o pro mini precisa de um programador externo.
Motor padrão nema17 1,8 graus ou 200 passos.
Driver TMC2209
1 capacitor eletrolítico 25v 100uf, ou com maior tensão se for usar mais que 24v, eu indico usar 12v.
Fonte 12v 1A.
1 push button (botão tactil).
1 conector P4.
Fio com conector para motor nema, normalmente vem junto.







Para testes fica meio bagunçado, então é bom prestar bem a atenção para não fazer bobagens.


Aqui soldado na placa Arduino pro mini.


Código:

/*
* RAto Arduino code to move telescope eq mount Right Ascension at
* Version 1.0 for Thiagogó - include modifications ratio and button settings
* 1x and detect button press to cycle among speeds 1x->8x->-6x->-stop
* Tracking speed select long press +1 Second - sideral 23h56m4s ->- moon 24h48m ->- Sun 24h
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
* Original - by gspeed @ astronomia.com / qde / cloudynights.com forum
* Wirings: https://mappite.org/stars/RAto-drv8825.png
* This code or newer versions at https://mappite.org/stars/RAto.ino
*
*
* This code is free software under GPL v3 License use at your risk and fun ;)
*
* UPDATE: new project aGotino can be used for just RA tracking as well
* check for updates on
* https://github.com/mappite/aGotino
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* How to calculate STEP_DELAY to drive motor at right speed to follow stars
*
* Worm Ratio 100 // 100 EQ1
* Pulley/Gear Ratio 3:1 // depends on your pulley setup e.w. 60T/20T = 3:1
* Steps per revolution 400 // or 200, usually (my is 200 1.8º)
* Microstep 62 // make sure to enable pins in driver
*
* Steps per degree 10666 // WormRatio*OtherRatio*StepsPerRevolution*Microsteps/360
* // = number of microsteps to rotate the scope by 1 degree
*
* STEP_DELAY 22439 // 1000000*((23*60*60+56*60+4)/360)/stepsPerDegree
* // = microseconds to advance a microstep
* // 23*60*60+56*60+4 is the number of secs for earth 360deg rotation
*
* STEP_DELAY 23251 // 1000000*((24*60*60+48*60)/360)/stepsPerDegree
* // = microseconds to advance a microstep
* // 24*60*60+48*60 this is the number relative to the Moon being in the same position after 1 rotation of the earth.
*
* STEP_DELAY 22501 // 1000000*((24*60*60)/360)/stepsPerDegree
* // = microseconds to advance a microstep
* // 24*60*60 this is the number relative to the Sun being in the same position after 1 rotation of the earth.
*
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
*
*/

// in micros, step duration to follow stars
unsigned long STEP_DELAY = 22439; //22439 in 64 steps or 44879 in 32 steps

// pin connections
const int dirPin = 4;
const int stepPin = 3;
const int Enable = 5;
const int ledPin = LED_BUILTIN;


//botão
const int buttonPin = 2;
unsigned char buttonState;
unsigned long duration;
unsigned long resettime;
int tracking = 0;
unsigned long lastDebounceTime = 0;
unsigned long debounceDelay = 20; //debounce botão

//som
#define tone_out1 8
#define tone_out2 9
short speaker_pin1 = 8; //arduino speaker output +
short speaker_pin2 = 9; //arduino speaker output -


// buffer time in micros: when we are at STEP_DELAY_MIN micros from having
// to change pulse status let's call (blocking) delayMicroseconds to allow a smooth pulse signal
// this must be less than 16383 and more than what logic does at each loop to honor STEP_DELAY
unsigned long STEP_DELAY_MIN = 100;

unsigned long lastTime; // micros, last time pulse has changed status
boolean stepPinStatus = false;

int velocity = 0; // speed is a reserved keyword ;)
unsigned long i = 0; // for debug

void setup() {
Serial.begin(19200);
Serial.print("RAto: READY");
// init Driver Motor pins as Outputs
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
pinMode(Enable, OUTPUT);
// Set motor direction clockwise (HIGH)
digitalWrite(dirPin, HIGH);
// make sure no signal is sent
digitalWrite(stepPin, LOW); // no signal
digitalWrite(Enable, HIGH); // driver OFF
// init Button pin as Input Pullup so no need resistor
pinMode(buttonPin, INPUT_PULLUP);
// init led and turn on for 0.5 sec
pinMode(tone_out1, OUTPUT); // Dinâmica pin8 de saída +
pinMode(tone_out2, OUTPUT); // Speaker pin9 saída -
pinMode(LED_BUILTIN, OUTPUT);
Serial.print(" and RUNNING with pulse length: ");
Serial.println(STEP_DELAY);
// Resolution is 4microsecs on 16Mhz board
lastTime = micros();
play_welcome_beep();
}

// Saudações de áudio
void play_welcome_beep()
{
for (int aa=100;aa<=800;aa=aa+100)
{
tone(tone_out1,aa,200);
tone(tone_out2,aa+3,200);
delay(50);
}
}
//fim saldaçnao de audio

void runStep(long stepDelay) {
unsigned long halfStepDelay = stepDelay/2; // duration of each pulse
unsigned long dt = micros() - lastTime; // delta time elapsed since previus stepPin status change
// micros() overflow after approximately 70 minutes but "-" logic above will work anyway to calculate dt
if ( dt > halfStepDelay) { // no luck, too fast, we can't honor halfStepDelay.
Serial.print("Can't honor the speed, dt: ");
Serial.println(dt);
} else if ( dt > halfStepDelay-STEP_DELAY_MIN) { // need to switch pulse in halfStepDelay-dt micros, let's do it:
// remaining delay to keep current pin status to honor halfStepDelay
delayMicroseconds(halfStepDelay-dt);// which is less than STEP_DELAY_MIN
//change pin status
stepPinStatus = !stepPinStatus;
digitalWrite(stepPin, (stepPinStatus?HIGH:LOW));
/* debug
i++;
if (i == 1000) {
unsigned long pulseDuration2 = (micros()-lastTime);
Serial.println("logB:");
Serial.print("stepDelay: "); Serial.println(stepDelay);
Serial.print("halfStepDelay: "); Serial.println(halfStepDelay);
Serial.print("lastTime: ");Serial.println(lastTime);
Serial.print("dt: "); Serial.println(dt);
Serial.print("delayMicroseconds:"); Serial.println((halfStepDelay-dt));
Serial.print("pulseDuration2: "); Serial.println(pulseDuration2);
delay(5000);
i= 0;
}
*/
lastTime = micros(); // last time we updated the pin status
}
}

void loop() {
if (velocity != 0){
runStep(STEP_DELAY/velocity);
}
/*
* logic executed at each loop must take less than (STEP_DELAY/2-STEP_DELAY_MIN)
* and less than STEP_DELAY_MIN. This is just a an IF for now...
*/
int currentState = (digitalRead (2));
if (currentState != buttonState) {
duration = millis();
resettime = millis();
}
if(currentState ==LOW){
if ((millis() - duration >20) && (millis() - duration < 1000)) {
//troca velocidade do acompanhamento
Serial.print("New Velocity: ");
// 1x -> 8x -> -6x
if (velocity == 1 && (digitalRead (2)==HIGH)) {
velocity = 8;
digitalWrite(LED_BUILTIN, HIGH);
tone(tone_out1,1800,40);
delay(80);
digitalWrite(dirPin, HIGH);
digitalWrite(Enable, LOW);
} else if (velocity == 8 && (digitalRead (2)==HIGH)) {
velocity = 6;
digitalWrite(LED_BUILTIN, HIGH);
tone(tone_out1,1800,40);
delay(80);
digitalWrite(dirPin, LOW); // change direction
} else if (velocity == 6 && (digitalRead (2)==HIGH)) {
velocity = 0;
digitalWrite(LED_BUILTIN, HIGH);
tone(tone_out1,1800,40);
delay(80);
        tone(tone_out1,1800,40);
delay(80);
tone(tone_out1,1800,40);
delay(80);
digitalWrite(dirPin, HIGH);
digitalWrite(Enable, HIGH);
} else if (velocity == 0 && (digitalRead (2)==HIGH)) {
velocity = 1;
digitalWrite(LED_BUILTIN, HIGH);
tone(tone_out1,1800,40);
delay(80);
tone(tone_out1,1800,40);
delay(80);
digitalWrite(dirPin, HIGH);
digitalWrite(Enable, LOW);
}
Serial.println(velocity);
digitalWrite(LED_BUILTIN, LOW);
lastTime = micros(); // reset time
}
if (millis() - duration > 1100) {
Serial.print("New Tracking: ");
//troca modo de acompanhamento
if (tracking == 0){
STEP_DELAY = 23251; //moon tracking
tracking = 1;
digitalWrite(LED_BUILTIN, HIGH);
tone(tone_out1,1000,250);
tone(tone_out2,1003,250);
delay(200);
tone(tone_out1,2000,250);
tone(tone_out2,2003,250);
delay(200);
tone(tone_out1,1000,250);
tone(tone_out2,1003,250);
delay(200);
tone(tone_out1,2000,250);
tone(tone_out2,2003,250);
}
else if (tracking == 1){
STEP_DELAY = 22501; //Sun tracking
tracking = 2;
digitalWrite(LED_BUILTIN, HIGH);
tone(tone_out1,1000,250);
tone(tone_out2,1003,250);
delay(200);
tone(tone_out1,2000,250);
tone(tone_out2,2003,250);
delay(200);
tone(tone_out1,1000,250);
tone(tone_out2,1003,250);
delay(200);
tone(tone_out1,2000,250);
tone(tone_out2,2003,250);
delay(200);
tone(tone_out1,1000,250);
tone(tone_out2,1003,250);
delay(200);
tone(tone_out1,2000,250);
tone(tone_out2,2003,250);
}
else if (tracking == 2){
STEP_DELAY = 22439; //Sideral tracking
tracking = 0;
digitalWrite(LED_BUILTIN, HIGH);
tone(tone_out1,1000,250);
tone(tone_out2,1003,250);
delay(200);
tone(tone_out1,2000,250);
tone(tone_out2,2003,250);
delay(200);
}
digitalWrite(LED_BUILTIN, LOW);
Serial.println(tracking);
Serial.print(" and RUNNING with pulse length: ");
Serial.println(STEP_DELAY);
duration = millis();
lastTime = micros(); // reset time
}

}
buttonState = currentState;
}



postagem original: cloudynights

Para operação achei a ideia do autor, "gspeed" de operar tudo com um único botão! Achei bem pratica e simples. Modifiquei só o funcionamento do botão para não ter delay e acrescentei a parada de acompanhamento e troca de velocidade de acompanhamento. Coloquei indicação sonora para sinalizar o modo, mas pode trocar o buzzer por um led. (buzzer vai ligado nos pinos positivo + buzzer no pino 9 e negativo - do buzzer no pino 8) se ficar muito alto pode colocar um resistor de 220ohms ou menos no positivo.

Ao ligar:
    - Motor e driver desabilitado;
    - 1 click - aciona motor para acompanhamento;
    - próximo click - acelera a frente x8;
    - próximo click - acelera reverso x7;
    - próximo click - desabilita o drive e motor;
    - próximo click - aciona motor para acompanhamento;
Os próximos clicks repetem as ações.

Segurar por 1 segundo troca o tempo de acompanhamento
 - Começa configurado para acompanhamento sideral (estrelas);
   - segura por 1 segundo vai para acompanhamento Lunar;
    - segura por 1 segundo vai para acompanhamento Solar;
       - segura por 1 segundo volta para acompanhamento sideral (estrelas).

Para um acompanhamento preciso é indispensável o correto posicionamento do tripé estável e nivelado, correto em relação ao eixo Norte e Sul verdadeiro e ângulo de Latitude para localidade da observação.

Vídeo muito bom sobre alinhamento de montagem equatorial.

                                    Outro vídeo muito bom sobre alinhamento de montagem equatorial.



E para acoplar o motor na EQ1 modelei um adaptador personalizado, se tiver impressora 3D pode baixar aqui: https://www.thingiverse.com/thing:6549450



Se não tiver impressora, pode pedir para fazer ou adaptar com chapas de alumínio.





Essa versão com ventilação para o driver


Estou usando com fonte 12v 2a, mas da pra usar com bateria de moto ou bateria de aeromodelo 3S 11.1v.