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;
}
Código original: https://mappite.org/stars/RAto.ino
postagem original: cloudynights
Para operação achei a ideia do autor, "gspeed" de operar tudo com um único botão 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 x8;
- 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.
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.
