Circulos Graduados Digitales: una experiencia distinta en la observación visual

Los sistemas GOTO de las monturas de telescopio nos permiten ir automáticamente a cualquier objeto del firmamento. El hecho es que sin saber poner el telescopio en estación y sin saber dónde están las estrellas, cúmulos, galaxias o nebulosas podemos verlas fácilmente gracias a una montura motorizada que es capaz de compensar nuestro error de puesta en estación y se desplaza automáticamente al objeto que queramos. ¿Es esto una ventaja o por contra una funcionalidad que nos limita el conocimiento del cielo y el disfrute de la observación visual?

 

Esta es la cuestión que me planteé de cara a las vacaciones de verano del 2020, y concluí que posiblemente sí, que el sistema GOTO hace todo demasiado fácil y le resta en alguna medida interés al proceso de observación, a la vez que dificulta el aprendizaje. La alternativa al GOTO es la técnica del salto de estrellas, es decir, utilizar estrellas suficientemente brillantes para ubicarnos en el firmamento y a partir su localización movernos a los objetos que queremos visualizar, por ejemplo, ayudados de los círculos graduados de una montura ecuatorial. Esta forma de operar te exige un mejor conocimiento del cielo y aprender a usar los círculos.

 

Siendo consecuente con esta idea, tomé la decisión de viajar con una montura ecuatorial no motorizada, un tubo ligero y una guía del firmamento, en concreto una versión del Comellas que tenía desde hace años, envejecido no precisamente por haberlo usado demasiado. Posiblemente fue un pronto romántico, añorando el cómo se hacían las cosas antes de las facilidades que nos ofrece la tecnología, pero me lancé a probar la experiencia.

 

La montura manual tiene algunas evidentes ventajas para viajar: es ligera, económica y no requiere sistema de alimentación. Pero a la vez plantea un reto si queremos ver más allá de la Luna, los planetas o estrellas más brillantes: es necesario un conocimiento superior del cielo y aprender a usar los círculos graduados. Para localizar por ejemplo una estrella doble débil el dato del que disponemos es la zona en la que está y su ascensión recta y declinación. La técnica que plantea Comellas es precisamente explorar el cielo por zonas, moviéndose de un objeto a otro utilizando las coordenadas. Y así empecé mi aventura con una montura EQ3, una linterna roja y el libro.

 

 

 

Y el resultado fue a la vez extraordinario y frustrante. Extraordinario porque cuando consigues encuadrar lo que estás buscando y comparas tu experiencia visual con la descripción tan rica en detalles de Comellas, realmente disfrutas un montón. Pero a la vez es frustrante porque no es en absoluto fácil, al menos si no tienes bastante experiencia. Los círculos graduados tienen poca resolución: en el caso de la EQ3, en declinación cada raya representa 2º y en ascensión recta 10 minutos. La flecha de la montura que apunta a los círculos no es fácil asociarla a un valor preciso. Además, la ascensión recta hay que irla rectificando continuamente, la Tierra se mueve y nosotros debemos compensar el movimiento ajustando el círculo graduado al no tener motor. A estas complicaciones se suma que estás a oscuras y los círculos graduados no los ves si no los iluminas, pero además tienes que hacer un ejercicio de contorsión del cuello para verlos, cada uno en un ángulo diferente de la montura. Todo esto que comento no es para desalentar respecto a la idea, de hecho, creo que nunca he aprendido tanto como este verano gracias a esta experiencia de uso manual de una montura ecuatorial. Pero como todo es mejorable, empecé a pensar cómo potenciar lo bueno de la experiencia, y la vez evitar los inconvenientes mejorando la precisión, la resolución y la usabilidad de los círculos graduados. 

 

La solución era claramente convertir lo analógico en digital, el sino de los tiempos modernos. Como es de esperar se pueden encontrar productos comerciales (se puede buscar en Internet por DSC, Digital Setting Circles, que son caros y que, aunque pueden usarse en distintos tipos de montura, están más enfocados a su utilización en monturas tipo Dobson y en comunicación con un software de PC o de Tablet, ya sea con USB o Bluetooth. Pero mi idea era hacer algo más sencillo, barato y autónomo, que he llamado sDSC (Simple Digital Setting Circles).

sDSC: Simple Digital Setting Circles

El sDSC es un sencillo dispositivo electrónico que básicamente tiene que leer dos encoder (uno para RA y otro para DEC) e incorporar un display que nos mostrará las coordenadas y un teclado para poder interactuar con el equipo. Después veremos los componentes concretos que se han seleccionado para dar una solución sencilla y económica.

 

La idea es operar con una montura ecuatorial manual de acuerdo con la siguiente secuencia: 

 

  • Ponemos el telescopio en estación. Para observación visual no es necesario una puesta en estación perfecta, pero como vamos a usar alineamiento con una sola estrella (como se explica a continuación) hay que conseguir una alineación mínimamente decente, que en mi caso funciona simplemente con una buena nivelación del trípode y encuadrando la Polar con los círculos en RA=0 y DEC=90.

  • En la posición inicial encendemos el sDSC que inicialmente indicará RA=0 y DEC=90.

  • Elegimos la zona en la que vamos a observar y movemos el telescopio con los mandos hacia una estrella brillante. 

  • El sDSC nos mostrará una nueva RA y DEC que ha calculado a partir de la lectura de los encoder. Pero este dato no nos sirve, al menos para la RA, y necesitamos hacer una sincronización con la estrella. El sDSC nos permite seleccionar de una lista la estrella (he escogido unas 50 brillantes con declinación>-25) y ya tenemos en pantalla la RA y DEC correcta. La RA se ira actualizando automáticamente con la rotación de la Tierra si no actuamos sobre el mando correspondiente.

  • Para ir al objeto que queremos, aunque sea débil y no lo podamos ver en el buscador, sólo tenemos que mover los mandos de RA y DEC hasta tener en el display de la sDSC las coordenadas del objeto. Si todo ha funcionado bien, tendremos el objeto visible en nuestro ocular, o en todo caso visible con muy pequeños ajustes de los mandos, dependiendo de la potencia de aumentos del ocular.

 

 

NOTA: para simplificar se ha hecho el desarrollo pensando en observadores del hemisferio norte, pero entiendo que será fácil de adaptar al sur.

Esta operativa nos resuelve todas las limitaciones de los círculos analógicos: es más precisa, tiene más resolución, y es mucho más cómoda. En los siguientes apartados entramos más en detalle respecto a cómo funciona y cómo se puede construir.

Por supuesto cabe la pregunta, ¿y no es más sencillo simplemente automatizar la montura con el correspondiente kit de motores?. Para mi la respuesta es que posiblemente sea más sencillo, pero es más caro y precisamente la idea es prescindir del GOTO y disfrutar de esta complicación adicional para aprender y tener una experiencia distinta durante la observación visual. Por otro lado, posiblemente hay muchas monturas manuales guardadas en el trastero a las que se puede dar una segunda vida con este sistema, mucho más simple y económico que la incorporación de motores.

Selección de los componentes del sDSC

Como se ha comentado antes, uno de los criterios para el equipo es que la solución sea económica. Los DSC comerciales son más caros que la propia montura manual, algunos superan el triple del precio de una EQ3. Sin embargo, vamos a construir una solución con un coste de unos 30€, incluyendo todo menos el bricolaje que haya que hacer para la caja.

 

Como es evidente se necesita una placa electrónica para incorporar la lógica y control del sistema. Actualmente hay soluciones en el mercado basadas plataformas hardware conocidas, quizás las más relevantes son Raspberry Pi y Arduino. Raspberry Pi está basada en sistema operativo Linux, y es una solución muy potente, pero posiblemente excesiva para la sencilla aplicación que queremos hacer. Arduino es una plataforma más sencilla que, sin estar soportada por un sistema operativo, permite implementar aplicaciones que interaccionen con sensores y manejen un display y un teclado, perfecta para la aplicación que queremos. Y lo más sorprendente, ¡podemos conseguir una placa Arduino por 8.99€!:

Elegida la arquitectura Arduino, necesitamos un display y un teclado. La solución seleccionada es un LCD retroiluminado de dos líneas de 16 caracteres, con teclado de 6 teclas integrado. Este display se conecta directamente a la placa Arduino con una tira de pines y nos deja disponibles las entradas digitales que necesitamos para los encoder. Y seguimos manteniéndonos en presupuesto, pues el coste del display con teclado es de 6.99€.

Por último, necesitamos los encoder. Este elemento es el que más dependerá de cómo lo acoplemos a la montura. El objetivo es disponer de la suficiente resolución, de forma que el número de pulsos que se obtenga para una vuelta completa del eje de RA (24 horas) o del eje DEC (360º) sea suficiente. Por ejemplo, si queremos una resolución de 30” en RA, necesitaremos 24*3600/30=2880 pulsos. Pero este factor dependerá de cómo acoplemos el encoder a la montura, porque puede girar a la vez que el correspondiente eje de la montura o a través de una multiplicación mecánica. En el caso de la EQ3, dado que los mandos de RA y DEC permiten acoplar directamente un encoder, con un dispositivo que genere unas decenas de pulsos por vuelta es más que suficiente, ya que ese valor hay que multiplicarlo por el número de vueltas que da el mando para generar una vuelta completa del eje de la montura. En particular para la EQ3, con un encoder de 40 pulsos acoplado al mando de RA obtenemos 5120 pulsos por vuelta completa del eje de Ascensión Recta (resolución de unos 17 segundos) y 2580 pulsos por vuelta completa del eje de Declinación (resolución de unos 8 minutos). Estos valores son suficientes para nuestro objetivo de observación visual.

 

Me he referido a un encoder de 40 pulsos por vuelta porque hay en el mercado un dispositivo muy económico y fácil de conseguir, el KY-040, un encoder óptico de tipo cuadratura (nos permite conocer el sentido de giro) e infinito (se pueden dar vueltas sin límite). ¡Y podemos conseguir cada uno por 2.23€!

En el caso de la montura EQ3, el eje para realizar el acoplamiento es de 6mm, igual que el del KY-040, por lo que necesitaremos un acoplamiento flexible de 6mm a 6mm. Una opción puede ser la que se indica a continuación, por un precio de 2.39€:

 Winwill® 3/4/5/6/7/8 / 10mm Acoplamiento del Eje de Aluminio Conector del Motor del acoplador Flexible 1Pc

 AZDelivery 3 x KY-040 Modulo Codificador Giratorio de Angulo para Arduino con eBook incluido

Tenemos ya todos los componentes por unos 30€ y sólo falta el bricolaje específico de cada montura. En el caso de la EQ3 realizar el acoplamiento es muy fácil y sólo se necesita fabricar una sencilla pieza de sujeción (una para cada eje), por ejemplo, doblando una pletina metálica, para conseguir algo parecido a lo siguiente:

El encoder se pega a la pletina con cuidado de que sólo toque la parte de PCB sin pistas ni pines. Una vez acoplados los encoder a la montura, se fija la base con una cinta de doble cara y el resultado será como se muestra a continuación:

Descripción del funcionamiento

El equipo sDSC ofrece tres tipos de pantallas:

 

 

  • Ascensión Recta y Declinación actual:

 

 

 

  • Selección de la estrella para sincronizar:

 

 

 

 

 

 

 

  • Valores actuales de los encoder:

 

 

 

 

 

 

En realidad, sólo usaremos las dos primeras pantallas, la tercera será sólo para el ajuste y puesta en marcha del sistema la primera vez.

Cuando el equipo arranca, la pantalla que se muestra es la de RA y DEC, con valores de AR=0 y DEC=90, ya que debe iniciarse el equipo con el telescopio puesto en estación y en la posición inicial. Siempre se puede volver a esta pantalla pulsando la tecla RST (reset). Se apreciará que el valor de RA se va incrementando con el paso del tiempo, un segundo por cada segundo transcurrido: el equipo reajusta automáticamente la RA, ya que no hay un motor que compense el movimiento de la Tierra.

 

Durante los primeros 3s tras el arranque, el software permite cambiar la intensidad del retro iluminado con las teclas de UP y DOWN. Transcurridos los 3s, tal y como veremos después, las dichas teclas tienen otra función.

 

También durante los 3s iniciales, si se pulsa la tecla SELECT se cambia de pantalla al modo de mostrar el valor de los encoder. Esta opción es interesante durante el proceso de puesta en marcha o para la calibración del número de pulsos por vuelta en cada eje, que como veremos después, es un valor que hay que introducir en el código fuente de la placa Arduino.

 

Una vez que estamos en la pantalla de RA y DEC, podemos mover el telescopio con los mandos y los valores de RA y DEC reflejarán los cambios leídos por los encoder. Pero si no hemos hecho ninguna sincronización, el valor de RA no tendrá ningún significado real. No así con el valor de DEC que sí reflejará un dato válido. La sincronización se debe hacer con los siguientes pasos:

  • Escoger una estrella brillante en la zona en la que queremos hacer las observaciones.

  • Mover los mandos hasta encuadrar la estrella, ayudados por el buscador del telescopio.

  • Pulsar la tecla SELECT para acceder a la pantalla de lista de estrellas de referencia. Buscar la estrella con UP y DOWN (están ordenadas alfabéticamente según el nombre común de la estrella). Una vez encontrada la estrella, pulsar SELECT.

  • Los datos de RA y DEC de la pantalla se habrán actualizado a los de la estrella. Si no tocamos el mando de RA, el valor de RA se irá incrementando y para volver a tener la estrella centrada podemos actuar sobre el mando hasta recuperar su valor de RA. Pero en realidad esto no es necesario y el telescopio seguirá sincronizado aunque en un rato la estrella que hemos usado deje de estar centrada.

  • Ya podemos ir al objeto que queramos simplemente moviendo el mando hasta ver en la pantalla la RA y DEC que reflejen las coordenadas deseadas.

Aquí es importante tener en cuenta un aspecto. Las coordenadas que se han introducido en el equipo son J2000, por lo que puede haber pequeñas desviaciones en la fecha actual de observación (JNOW). En observación visual esto no suele ser relevante. No obstante, se ha incluido una opción en el manejo del teclado para hacer pequeñas correcciones al valor actual de RA y DEC. En el display indicará con “>” si está seleccionada RA o DEC, pudiéndose cambiar con la tecla LEFT. Una vez que esté seleccionado lo que queremos ajustar, podemos usar las teclas UP y DOWN para hacer pequeños ajustes, por ejemplo, para poner el valor JNOW que leamos de una aplicación en el móvil.

 

Y esta es la forma sencilla de operar del sDSC, un dispositivo diseñado para hacer unos círculos graduados digitales que nos ayuden a manejar nuestra montura manual por un coste totalmente asequible.

Resumen teclas

UP y DOWN: 

 

  • Sólo durante los 3s iniciales sirven para ajustar la intensidad del backlight

  • Si estamos en la pantalla de visualización de RA y DEC se utiliza para aumentar o disminuir el valor de RA o DEC que indica la pantalla. Para conmutar RA o DEC para este ajuste, utilizar LEFT.

  • Si estamos en la pantalla de selección de estrella de sincronización, permite recorrer la lista hasta seleccionar la que se desee.

 

SELECT:

 

  • Sólo durante los 3s iniciales sirve para seleccionar la pantalla de visualización del valor de los encoder (suma de pulsos acumulados). Los pulsos acumulados se ponen a 0 cada vez que se hace una sincronización.

  • Su uso normal es para ir a la pantalla de selección de estrella para sincronizar.

 

LEFT:

 

  • En la pantalla de visualización de RA y DEC actual, sirve para conmutar RA y DEC (se mostrará el signo “>” señalando en cada caso la coordenada seleccionada) a efectos de ajustes de su valor con UP y DOWN.

 

RIGHT:

 

  • No se utiliza.

 

RST:

 

  • Resetea el equipo poniendo encoders a 0, RA a 0 y DEC a 90. 

Resumen de manejo de los mandos

Las indicaciones que se dan a continuación pueden parecer inicialmente un poco complicadas, pero en realidad son muy intuitivas y hecho un par de veces crea un dinámica fácil y ágil para localizar cualquier objeto en el firmamento.

 

  • Sincronización:

    • Si estamos en la posición inicial, debemos mover el mando de DEC en sentido horario si la estrella que vamos a usar para sincronizar está en este y antihorario si está en el oeste. Una vez hecho este movimiento inicial, seguir moviendo el mando de declinación hasta obtener en el display la declinación de la estrella que usaremos para sincronizar.

    • Mover el mando de RA para llegar a la estrella con el buscador, no fijarse en el valor de RA del display.

    • Mover mandos de RA y DEC para encuadrar perfectamente la estrella, ayudados del buscador. En este último ajuste de mandos para centrar la estrella, tampoco hay que fijarse en los valores del display.

    • Una vez centrada la estrella, seleccionar con el teclado la estrella de sincronización. Antes de dar a sincronizar hacer un último ajuste del mando de RA (en sentido horario) ya que la estrella se habrá desplazado un poco durante su búsqueda por el movimiento de la Tierra.

    • Si se quiere ser más preciso, se puede reajustar RA y DEC en el display a los valores JNOW que obtengamos de la correspondiente aplicación del móvil o Tablet.

 

  • Ir al objeto celeste deseado una vez hecha la sincronización:

    • Simplemente girar los mandos de RA y DEC hasta tener los valores del objeto.

    • El objeto deberá estar dentro del ocular o si el ocular tiene demasiados aumentos, serán necesario pequeños ajustes con los mandos de RA y DEC.

 

  • Observación del objeto celeste localizado:

    • Con pequeños movimientos de RA podemos mantener el objeto centrado al compensar el movimiento de la Tierra.

    • Si hemos dejado pasar cierto tiempo, el ajuste de RA se puede hacer atendiendo simplemente al display con un giro horario del mando hasta recuperar el valor RA del objeto.

 

  • Ir al siguiente objeto:

    • Si el siguiente objeto está en la zona y en el mismo lado del meridiano, no es necesario una nueva sincronización. No obstante, antes de moverse a él, podemos centrar el objeto que acabamos de ver y realizar la pequeña corrección que sea necesaria en los valores de RA y DEC del display para tener el valor JNOW.

A tener en cuenta en la sincronización

Para movernos a la estrella que usaremos para la sincronización hemos comentado que lo debemos hacer con los mandos de movimiento lento. Pero ¿es posible aflojar los bloqueos de los ejes y mover el telescopio sin los mandos? La respuesta es sí, pero teniendo presente un aspecto que vamos a explicar a continuación.

 

Si no utilizamos los mandos, tal y como se han instalado los encoder, no generaremos los pulsos, pero como vamos a sincronizar RA y DEC con los datos de la estrella podría parecer que esta operación se puede hacer sin problemas. Con la ascensión recta no hay ningún problema, sin embargo, hay que tener en cuenta que con la declinación es algo más complicado, ya que un giro del mando de declinación implica incrementar o decrementar la declinación dependiendo de en qué lado del meridiano estemos. 

 

Dado que, una vez hecha la sincronización, usaremos el mando de declinación para el movimiento a nuestro objeto, el sDSC deberá saber si en qué lado del meridiano estamos para aplicar el signo correcto al cambio en declinación, incrementando o decrementando según el sentido del giro. Si hemos hecho el desplazamiento con movimiento lento, el sDSC ya sabe si hemos ido a un lado u otro del meridiano, pero si hemos ido sin los mandos no lo sabrá. 

 

Para resolver esto habrá que tener en cuenta estas sencillas reglas si queremos usar los movimientos rápidos de los ejes:

 

  • Si estamos en la posición inicial, con DEC=90, simplemente girar un poco el mando hacia el lado del meridiano en el que esté a estrella a la que vamos. A partir de ahí, ya podemos hacer movimientos rápidos.

 

  • Si no estamos en la posición inicial, podemos movernos sin los mandos siempre que permanezcamos en el mismo lado del meridiano. En caso contrario, habrá que pasar por la posición DEC=0 y usar la regla anterior.

Conexionado

El conexionado es realmente sencillo. 

 

El primer paso es colocar el display, simplemente anclándolo a la placa Arduino (ver las instrucciones que proporciona el proveedor del displau, pero no tiene complicación ninguna).

 

Respecto a los encoder, lo primero que hay que tener en cuenta es dónde están accesibles las entradas/salidas digitales del microcontrolador del Arduino una vez que hemos conectado la placa de display y teclado. En el conector superior de la derecha están disponibles las señales digitales siguientes:

 

D13 D12 D11 D3 D2 D1 D0

 

En la foto se muestra que se ha soldado una tira de 7 pines para tener accesibles las señales digitales, aunque en realidad sólo vamos a usar las 4 de la derecha.

 

 

También se ha soldado una tira de 2 pines para tener accesible +5V y GND (ver en la parte inferior de la foto).

 

Cada uno de los encoder precisa 2 señales: CLK y DT, además de la alimentación a 5V.

 

Utilizaremos D1 y D0 para el encoder de RA y D2 y D3 para el enconder de DEC.

 

 

 

 

 

 

 

Las conexiones serán:

 

Ascensión recta:

D0: CLK del KY-040 

D1: DT del KY-040 

 

Declinación:

D2: CLS del KY-040 

D3: DT del KY-040 

Para las conexiones deberemos hacer un cable de 4 hilos (CLK, DT, +5V y GND) de longitud suficiente para conectar cada encoder a la placa de display.

 

NOTA: el pin SW de los encoder no se usa.

 

En la foto se ha mostrado la forma de conectar mediante cables estándar para conexiones en placas de prototipos. Es la forma que he utilizado para hacer un prototipo, pero no es la forma adecuada para tener un producto final. A partir de las explicaciones de este documento, lo recomendado sería alojar el conjunto en una caja y hacer las conexiones soldadas, no con cables de conexión a pines. Por otro lado, posiblemente sea buena idea, aún no lo he probado, en el formato mecánico final colocar una lámina roja transparente sobre el display para que la luz no moleste durante la observación, ya que, aunque el backlight es ajustable, el color azul del fondo y el blanco de los caracteres no parece el más adecuado.

Código fuente

A continuación de ofrece el código fuente de la aplicación. Es una versión 1.0 y lógicamente es posible que incluya errores en situaciones que no se han previsto, ¡así es la programación! Las siguientes versiones serán fruto de la experiencia de más tiempo de observación, que permitirá detectar fallos y surgirán ideas de mejora. El único aspecto a tener en cuenta es que el sistema Arduino utilizado tiene poca memoria y esto limita la extensión y complejidad de la aplicación, pero a cambio ¡es tan económico! Cualquier sugerencia y comunicación de error detectado será bienvenida.

 

Respecto a la personalización para otra montura o diferentes encoders, los únicos cambios que hay que hacer en la aplicación son la inicialización de las variables ra_ratio, dec_ratio, ra_rotation y dec_rotation. 

 

Para el caso de la EQ3, y según mis cálculos los valores correctos de las ratio son:

 

5120  pulsos por una vuelta completa de 24 horas en AR:

 

 int ra_ratio=5120;

 

2580 pulsos por una vuelta completa de 360 horas en DEC:

 

int dec_ratio=2580; 

 

También hay que definir cómo opera el sentido de giro de los encoder, que dependerá de cómo se haya hecho el acoplamiento.

 

En mi caso, con la solución mecánica que he dado, cuando se aumenta la ascensión recta el encoder gira antihorario:

 

int ra_rotation = -1; 

 

Y en mi caso, para la declinación, al hacer un giro horario desde la posición inicial vamos hacia el este:

 

int dec_rotation = 1;

 

Si en tu implementación el comportamiento es el contrario, ya sea para RA o DEC, sólo tienes que cambiar en el código el signo de la variable correspondiente.

 

Sólo son estas cuatro variables las que pueden variar de una instalación a otra.

 

A continuación, se incluye el código fuente:

// RA ENCODER

double ra;

int RA_pinA = 0; // Connected to CLK on KY-040 

int RA_pinB = 1; // Connected to DT on KY-040 

int RA_pinALast;

int RA_aVal; 

int ra_encoder = 0;

int ra_rotation = -1;

int ra_ratio=5120; // number of pulses for a complete 24-hour turn in RA (each turn of the hand is 40 pulses)

 

// DEC ENCODER

double dec;

int DEC_pinA = 2; // Connected to CLK on KY-040 

int DEC_pinB = 3; // Connected to DT on KY-040 

int DEC_pinALast;

int DEC_aVal; 

int dec_encoder = 0;

int dec_rotation = 1;

int dec_ratio=2580; // number of pulses for a complete 360 hour turn in DEC (each turn of the hand is 40 pulses)

 

char tmp[100];

unsigned long time;

int screen_type=1;

int adjust_pos=1;

int time_count=0;

int backlight=50; // initial value in the range of 0 to 255

 

 

// Star database for SYNC

// Stars with magnitude <2.25 and declination >-25 (J2000)

double ra_stars[]={4.60,10.33,3.13,6.63,12.90,13.80,2.07,5.60,5.68,9.47,15.58,0.13,19.85,14.27,5.42,5.92,5.28,7.58,0.95,20.68,11.82,0.73,11.07,5.43,17.95,2.12,14.85,6.00,1.17,3.40,6.38,13.40,2.53,7.75,7.65,17.58,10.13,5.25,20.37,5.80,0.68,6.75,13.42,18.62};

double dec_stars[]={16.5,19.8,41,16.4,56,49.3,42.3,-1.2,-1.9,-8.7,26.7,29.1,8.9,19.2,6.3,7.4,46,31.9,60.7,45.3,14.6,-18,61.8,28.6,51.5,23.5,74.2,44.9,35.6,49.9,-18,54.9,89.3,28,5.2,12.6,12,-8.2,40.3,-9.7,56.5,-16.7,-11.2,38.8};

const char *name_stars[] ={"Aldebaran","Algieba","Algol","Alhena","Alioth","Alkaid","Almach","Alnilam","Alnitak","Alphard","Alphecca","Alpheratz","Altair","Arcturus","Bellatrix","Betelgeuse","Capella","Castor","Cih","Deneb","Denebola","Diphda","Dubhe","Elnath","Eltanin","Hamal","Kochab","Menkalinan","Mirach","Mirfak","Mirzam","Mizar","Polaris","Pollux","Procyon","Rasalhague","Regulus","Rigel","Sadr","Saiph","Schedar","Sirius","Spica","Vega"};

int tot_stars=44;

int idx=-1;

 

#include <LiquidCrystal.h>

LiquidCrystal lcd(8, 9, 4, 5, 6, 7);

 

//***********************************************************************

// Initializations at startup

//***********************************************************************

void setup() {

  pinMode (RA_pinA,INPUT);

  pinMode (RA_pinB,INPUT);

  RA_pinALast = digitalRead(RA_pinA);

  

  pinMode (DEC_pinA,INPUT);

  pinMode (DEC_pinB,INPUT);

  DEC_pinALast = digitalRead(DEC_pinA);

  

  lcd.begin(16, 2);         // LCD init

  lcd.setCursor(0,0);       // column, row

  lcd.print("DSC 1.0");     // print start message

 

  delay(300);

  lcd.clear();

 

  time = millis();

  ra=0;

  dec=90;

 

  analogWrite(10, backlight);  

  

}

 

//***********************************************************************

// Converts declination into degrees and minutes

//***********************************************************************

void ConvertDEC(double t, int *g, int *m) { 

 

    int grad;

    int minute;

    int sign;

 

    if (t<0) sign=-1; else sign=1;

    t=t*sign;

    grad=t;

 

    minute = (t-grad) * 60 ; 

 

    *g=grad*sign;

    *m=minute;

      

 

 

//***********************************************************************

// Converts RA into degrees, minutes and seconds

//***********************************************************************

void ConvertRA(double t, int *h, int *m, int *s) { 

 

    int hour=t;

    int minute = (t-hour) * 60 ; 

    int second = ((t-hour)*60-minute)*60;

 

    *h=hour;

    *m=minute;

    *s=second;

      

 

//***********************************************************************

// Print current star for syncing

//***********************************************************************

void Print_Star(void){

 

  int h, m_ra, g, m_dec, s;

   

   sprintf(tmp,"%s", name_stars[idx]);

   lcd.clear();

   lcd.print(tmp);

   lcd.setCursor(0,1);

   ConvertRA(ra_stars[idx], &h, &m_ra, &s);

   ConvertDEC(dec_stars[idx], &g, &m_dec);

   sprintf(tmp, "R:%02d %02d D:%02d %02d", h, m_ra, g, m_dec);

   lcd.print(tmp);

   

}

 

//***********************************************************************

// Main loop

//***********************************************************************

void loop() {

  

  RA_aVal = digitalRead(RA_pinA);

  DEC_aVal = digitalRead(DEC_pinA);

  int x, mod;

  int g, h, m, s;

 

  // ******************** keypad control *******************************

  x = analogRead (0);

  if (x > 900) {

    // no key

  } else {

    if (x < 50) { // right

    } else if (x < 250) { // up

      if (time_count<6) { // during first 3s

        if (backlight<255){

          backlight=backlight+5; 

          analogWrite(10, backlight);

          time_count=0;

        }

      } else if (idx==-1){

        if (adjust_pos==1) ra=ra+1.0/60; else dec=dec+0.1;  // increment 1 minute in RA or 6 minutes in DEC

        if (ra>24) ra=23.9;

        if (dec>90) dec=90;

      } else {

        if (idx>0) idx--; else idx=tot_stars-1;

        Print_Star();

      }

    } else if (x < 450){ // down

      if (time_count<6) { // during first 3s

        if (backlight>0){

          backlight=backlight-5; 

          analogWrite(10, backlight);

          time_count=0;

        }

      } else if (idx==-1) {

        if (adjust_pos==1) ra=ra-2.0/60; else dec=dec-0.1; // decrement 1 minute in RA or 6 minutes in DEC

        if (ra<0) ra=0;

      } else {

        if (idx<(tot_stars-1)) idx++; else idx=0;

        Print_Star();

      }  

    } else if (x < 650){ // left

      if (adjust_pos==2) adjust_pos=1; else adjust_pos=2;

    } else if (x < 850){ // select

      if (idx>=0 && idx<tot_stars) { // if we are selecting a star for sync

        ra=ra_stars[idx];

        dec=dec_stars[idx];

        ra_encoder=0;

        dec_encoder=0;

        idx=-1;

        lcd.clear();

      } else if (time_count<6) { // during first 3s

        screen_type=2; 

        lcd.clear();

      } else {

        idx=0;

        Print_Star();

      }

    }

    delay(200);

  }

 

  // ************ pulses in  RA ***********************************

  if (RA_aVal != RA_pinALast){ // encoder rotating

    if (digitalRead(RA_pinB) != RA_aVal) { // pin A change first: clockwise

      ra_encoder ++;

      ra=ra+ra_rotation*24.0/ra_ratio;

    } else {

      ra_encoder--; 

      ra=ra-ra_rotation*24.0/ra_ratio;

    }

    if (ra<0) ra=ra+24.0; else if (ra>24.0) ra=ra-24.0;

  } 

  RA_pinALast = RA_aVal; 

 

  

  // ************ pulses in DEC ***********************************

  if (DEC_aVal != DEC_pinALast){ // encoder rotating

    if (digitalRead(DEC_pinB) != DEC_aVal) { // pin A change first: clockwise

      dec_encoder ++;

      dec=dec+dec_rotation*360.0/dec_ratio;

    } else {

      dec_encoder--; 

      dec=dec-dec_rotation*360.0/dec_ratio;

    }

    if (dec>90.0) { // detection of passage through the northern meridian

      dec_rotation=dec_rotation*-1; 

      dec=180.0-dec;

    }

  } 

  DEC_pinALast = DEC_aVal; 

 

 

  // ************* display *********************************

  if ((millis()-time)>500 && idx==-1){  // every 0.5s and if we are not selecting a star

 

    if (time_count<100) time_count++;

    ra=ra+((millis()-time)/1000.0)/3600;

    time=millis();

 

    if (screen_type==1){

      ConvertRA(ra, &h, &m, &s);

      if (adjust_pos==1) mod='>'; else mod=' ';

      sprintf(tmp,"%cRA:%02dh %02dm %02ds", mod, h, m, s);

      lcd.setCursor(0,0);

      lcd.print(tmp);

  

      ConvertDEC(dec, &g, &m);

      if (adjust_pos==2) mod='>'; else mod=' ';

      sprintf(tmp, "%cDEC:%02d%c %02d'", mod, g, 223, m);

      lcd.setCursor(0,1);

      lcd.print(tmp);

      

    } else {

 

      sprintf(tmp, "RA enc:%04d %c", ra_encoder, mod);

      lcd.setCursor(0,0);

      lcd.print(tmp);

 

      sprintf(tmp, "DEC enc:%04d", dec_encoder, mod);

      lcd.setCursor(0,1);

      lcd.print(tmp);

      

    }

    

  } 

    

 

}