This project consists on a first approach to control a telescope mechanism, builded from scratch and based on Arduino microcontroller, from a computer with GNU/Linux and the Stellarium software.

By the moment, the code has been tested only in a mini-dobsonian mount with a green laser pointer instead of a real telescope. The laser points towards the celestial objects indicated from Stellarium, by using a stepper motors system.

The software is divided on two main blocks, the first one implemented in Python (computer) and the other one for Arduino microcontroller (device):

Contains the necessary scripts for testing isolately the communications with Stellarium, communications with the device, and the Arduino library for coordinate transformation (Matrix Method implementation).

A Python module that makes the creation, manipulation and analysis of binary data as simple and natural as possible.

After completing my homemade telescope mount it was powered by a Meade DS motor kit. This system was extremely slow, underpowered and unreliable. It was also impossible for me to change the programming or maintain the system. I decided to make my own telescope control system from the ground up and the Arduino platform seemed the obvious choice. This project needed a wide range of inputs and outputs, so has been done using an Arduino Mega 1280 board, although a Mega 2560 would do just as well. DC motors or Stepper motors Microcontrollers like Arduino have a fundamental problem with stepper motors. Steppers require constant attention from the Arduino to keep going around. Especially when microstepping. This does not leave a lot of time in the Arduino for performing other tasks. Whilst one would architect this using multiple microcontrollers, such an approach seems silly when a single Arduino Mega has far more computing power that you need. Therefore I chose to use DC motors. Why ASCOM with Arduino Whilst the Arduino can happily handle all the tasks associated with running the motors and pointing the telescope, in a modern observatory the PC rules. A wide range of astronomy applications are needed for successful imaging. All such applications talk to telescopes using the common ASCOM interface. None of the planetarium etc software I wanted to use knows a damn thing about my Arduino system: Therefore I had to write an ASCOM driver to sit between the Arduino and the application software I needed to use. Fortunately ASCOM Drivers are well templated and easy to write. The video below shows this tool chain in action. What is the hardware? Mount Motors Spur Gearhead GS 38 A 38 mm, 0.1 - 0.6 Nm, 110454 RE-max 24 24 mm, Precious Metal Brushes CLL, 6.5 Watt, with terminals, 220432 Encoder MR, Typ M, 512 CPT, 2 Channels, with Line Driver, 201937 At the heart of the system is a pair of Maxon Motor precious metal brushed coreless DC motors with 512 cpr encoders and 30:1 reduction gearboxes. These motors are a marvel of technology and can rotate extremely slowly under Arduino control with zero magnetic cogging. When tracking the sky, the motors turn at 12rpm. This combination gives a resolution of around 24 ticks per arc second when reading 4x via the encoder IC. This is plenty for provide tracking GOTO and tracking accuracy. However, it is a problem when slewing and the tick rate goes up to around 200kHz. Trying to use an encoder with an Arduino at high rates leads to all sorts of problems. For example, the overloaded interrupt lines will corrupt the serial data. For better to use a dedicated encoder counting IC. Interfacing the motors to the arduino is a simple L298 dual H Bridge driver. The Encoders are interfaced to the Arduino using an encoder counting IC to cope with the very high tick rates when slewing. The diagram below roughly outlines the high level layout of the system Please see here for discussion on Arduino PWM The Arduino Mega 1280 is housed in a box on the telescope. This includes the L298 unit, the encoder counter, various hall sensors for doing PEC and fuses and relays. Arduino can actually turn off the power to the telescope mount itself - handy when you detect an problem. What does my Arduino software actually do? The Arduino is entirely responsible for running the motors and pointing the telescope. During sidereal tracking, the arduino monitors the tick rates from the encoders and adjusts the PWM signal to the L298 to keep the telescope tracking the sky at the correct speed. That is a fairly simple task. The complexities arise with GOTO. If my planetarium software wants the scope to GOTO a target, it simply tells the arduino the required RA and DEC. At his point a bunch of stuff happens on the Arduino First the DS1307 real time clock module is consulted by the Arduino to get the current local time. Arduino then uses the known longitude of the observatory to calculate the local sidereal time. Knowledge of the target RA is then used to find the required Hour angle. The required hour angle and declination are then used to calculate the required shaft angles. There are around 80000 encoder ticks per degree - so we can find the required encoder tick target Signals are then sent to slew the motors at full speed until the required encoder tick count is reach, slowing down and stopping at the correct place Beyond this core, a whole range of other functions are implemented in the arduino including Parking the telescope when finished Unparking Emergency shut down Syncing the pointing to a known star Periodic error correction of the transmission gears (PEC) Autoguiding Local monitoring of temperature and humidity. Finding a home position (using Hall sensors) There is a whole range of safety monitor routine built into the code to detect if something has gone wrong. If a slew is taking to long, or the telescope is moving to slowly, the Arduino will shut down the power to the mount and then go into sulk mode. It won't let the power come back on until a human has come along and cleared the error bit. Can I download your Arduino source code In short, no. The code is closely matched to my telescope and has taken me months of research and development. It is not impossible that this may turn into a commercial project one day therefore I do not wish to share my entire source code. However I would be delighted to answer questions about the project through the contact form and will happily share section of the code if it helps you with your project. However, I do give isntructions on how to write it yourself here in my guide for writing Arduino telescope controllers

Microcontrollers like Arduino have a fundamental problem with stepper motors. Steppers require constant attention from the Arduino to keep going around. Especially when microstepping. This does not leave a lot of time in the Arduino for performing other tasks. Whilst one would architect this using multiple microcontrollers, such an approach seems silly when a single Arduino Mega has far more computing power that you need. Therefore I chose to use DC motors.

Whilst the Arduino can happily handle all the tasks associated with running the motors and pointing the telescope, in a modern observatory the PC rules. A wide range of astronomy applications are needed for successful imaging. All such applications talk to telescopes using the common ASCOM interface. None of the planetarium etc software I wanted to use knows a damn thing about my Arduino system: Therefore I had to write an ASCOM driver to sit between the Arduino and the application software I needed to use. Fortunately ASCOM Drivers are well templated and easy to write. The video below shows this tool chain in action. What is the hardware? Mount Motors Spur Gearhead GS 38 A 38 mm, 0.1 - 0.6 Nm, 110454 RE-max 24 24 mm, Precious Metal Brushes CLL, 6.5 Watt, with terminals, 220432 Encoder MR, Typ M, 512 CPT, 2 Channels, with Line Driver, 201937 At the heart of the system is a pair of Maxon Motor precious metal brushed coreless DC motors with 512 cpr encoders and 30:1 reduction gearboxes. These motors are a marvel of technology and can rotate extremely slowly under Arduino control with zero magnetic cogging. When tracking the sky, the motors turn at 12rpm. This combination gives a resolution of around 24 ticks per arc second when reading 4x via the encoder IC. This is plenty for provide tracking GOTO and tracking accuracy. However, it is a problem when slewing and the tick rate goes up to around 200kHz. Trying to use an encoder with an Arduino at high rates leads to all sorts of problems. For example, the overloaded interrupt lines will corrupt the serial data. For better to use a dedicated encoder counting IC. Interfacing the motors to the arduino is a simple L298 dual H Bridge driver. The Encoders are interfaced to the Arduino using an encoder counting IC to cope with the very high tick rates when slewing. The diagram below roughly outlines the high level layout of the system Please see here for discussion on Arduino PWM The Arduino Mega 1280 is housed in a box on the telescope. This includes the L298 unit, the encoder counter, various hall sensors for doing PEC and fuses and relays. Arduino can actually turn off the power to the telescope mount itself - handy when you detect an problem. What does my Arduino software actually do? The Arduino is entirely responsible for running the motors and pointing the telescope. During sidereal tracking, the arduino monitors the tick rates from the encoders and adjusts the PWM signal to the L298 to keep the telescope tracking the sky at the correct speed. That is a fairly simple task. The complexities arise with GOTO. If my planetarium software wants the scope to GOTO a target, it simply tells the arduino the required RA and DEC. At his point a bunch of stuff happens on the Arduino First the DS1307 real time clock module is consulted by the Arduino to get the current local time. Arduino then uses the known longitude of the observatory to calculate the local sidereal time. Knowledge of the target RA is then used to find the required Hour angle. The required hour angle and declination are then used to calculate the required shaft angles. There are around 80000 encoder ticks per degree - so we can find the required encoder tick target Signals are then sent to slew the motors at full speed until the required encoder tick count is reach, slowing down and stopping at the correct place Beyond this core, a whole range of other functions are implemented in the arduino including Parking the telescope when finished Unparking Emergency shut down Syncing the pointing to a known star Periodic error correction of the transmission gears (PEC) Autoguiding Local monitoring of temperature and humidity. Finding a home position (using Hall sensors) There is a whole range of safety monitor routine built into the code to detect if something has gone wrong. If a slew is taking to long, or the telescope is moving to slowly, the Arduino will shut down the power to the mount and then go into sulk mode. It won't let the power come back on until a human has come along and cleared the error bit. Can I download your Arduino source code In short, no. The code is closely matched to my telescope and has taken me months of research and development. It is not impossible that this may turn into a commercial project one day therefore I do not wish to share my entire source code. However I would be delighted to answer questions about the project through the contact form and will happily share section of the code if it helps you with your project. However, I do give isntructions on how to write it yourself here in my guide for writing Arduino telescope controllers

1. Executive Abstract and Engineering Problem Formulation for Arduino Telescope Controller

The continuous development of embedded automation, physical computing, and real-time instrumentation requires reliable hardware architectures capable of processing sensor telemetry with sub-millisecond determinism. The development of Arduino Telescope Controller addresses manual operational bottlenecks by pairing analog/digital sensory acquisition with low-overhead firmware execution on the ATmega328P Microcontroller (Arduino Uno / Nano). Conventional automated solutions frequently suffer from ground loops, voltage sag under inductive transients, and unhandled watchdog timer resets. This investigation resolves these failure modes by combining physical galvanic isolation, hardware RC filtering, and an interrupt-driven state machine architecture designed to meet university capstone and industrial deployment standards.

2. Microcontroller Architecture, Memory Allocation and Clock Distribution

The computational core of arduino telescope controller relies on the ATmega328P Microcontroller (Arduino Uno / Nano). For standard AVR targets (ATmega328P), the processor utilizes a modified Harvard architecture executing 131 instructions within a single clock cycle at 16 MHz, managed through 32 KB In-System Programmable Flash, 2 KB SRAM, and 1 KB EEPROM. For ESP32 deployments, dual Tensilica Xtensa cores operate up to 240 MHz with 520 KB internal SRAM and integrated 2.4 GHz Wi-Fi / Bluetooth LE baseband. Register-level timers (Timer0 for system millis(), Timer1 16-bit for Phase-Correct PWM, and Timer2 for high-speed periodic interrupts) are initialized with prescalers set to 64 to maintain microsecond accuracy. Low-power brown-out detector (BOD) fuses are set to 2.7V/4.3V to prevent flash corruption during battery discharge cycles.

3. Sensory Transduction Physics, Noise Suppression and Analog Front-End

Accurate data acquisition in Arduino Telescope Controller requires converting physical phenomena into calibrated electrical potentials. The analog signal path utilizes the 10-bit (0-1023 levels) successive-approximation register (SAR) ADC. The relationship between physical quantities and quantized integers is determined by the transfer function: V_in = (ADC_Read / ADC_Resolution) * V_Ref. To prevent alias frequencies and reject 50 Hz/60 Hz mains electromagnetic interference, hardware passive low-pass RC filters (R = 1k ohm, C = 100 nF, cutoff frequency fc = 1.59 kHz) are positioned immediately adjacent to the analog pins. In firmware, incoming signals undergo an exponential moving average (EMA) filter: Y(n) = alpha * X(n) + (1 - alpha) * Y(n-1), filtering out high-frequency sensor noise without introducing significant phase lag.

4. Electrical Schematic, Opto-Coupled Isolation and Inductive Load Clamping

The electrical power distribution system for arduino telescope controller isolates noisy actuation peripherals from digital logic lines. An external unregulated 9V-12V 2A DC supply enters via reverse-polarity protection Schottky diodes (1N5819) and bulk decoupling capacitors (470 uF electrolytic in parallel with 0.1 uF multi-layer ceramic). Power is regulated down to clean 5.0V TTL. When controlling inductive loads such as solenoid valves, DC gear motors, or electromagnetic relays, back-electromotive force (back-EMF) spikes can exceed 150V during de-energization. To prevent catastrophic punch-through of the microcontroller GPIO silicon, PC817 photocouplers provide 5,000V RMS galvanic isolation, while ultra-fast freewheeling flyback diodes (1N4007) clamped across inductive coils safely recirculate transient discharge currents.

5. Embedded C/C++ Firmware Architecture and Non-Blocking Scheduling

The firmware execution pipeline is implemented in native Arduino C/C++ (`.ino`). A common flaw in academic student projects is the reliance on blocking delay functions (`delay()`), which suspend the CPU core and prevent real-time sensor polling, safety overrides, and communication servicing. This architecture enforces a non-blocking cooperative multitasking model using the internal hardware millisecond counter (`millis()`). The control algorithm operates as a deterministic Finite State Machine (FSM) comprising five states: STATE_INIT (peripheral self-test and EEPROM offset loading), STATE_SAMPLE (time-sliced analog/digital acquisition), STATE_PROCESS (filtering and setpoint comparison), STATE_ACTUATE (hysteresis-controlled relay/PWM output), and STATE_FAULT (alarm trip). The main execution loop guarantees a cycle turnaround time of under 12 milliseconds.

6. Digital Bus Interfaces: I2C, SPI and High-Speed UART Telemetry

Peripheral communication within Arduino Telescope Controller is orchestrated across standardized serial bus topologies. Display metrics (16x2 I2C LCD / 0.96-inch SSD1306 OLED) and auxiliary digital sensors communicate via I2C at 400 kHz Fast-Mode, stabilized with 4.7k ohm pull-up resistors on SDA and SCL lines. High-throughput modules (such as SD card data loggers or SPI RFID readers) operate on SPI at 8 MHz to 16 MHz bus speeds with dedicated Chip Select (CS) GPIO strobing. Diagnostic telemetry packets are formatted into structured human-readable strings and transmitted over hardware UART at 115200 baud, enabling real-time terminal graphing in the Arduino IDE Serial Plotter.

7. Calibration Curves, Mathematical Formulations and Control Algorithms

Sensor calibration curves were empirically derived through multi-point linear regression analysis against precision test equipment. For closed-loop dynamic regulation, a discrete proportional-integral-derivative (PID) control algorithm modulates the PWM duty cycle: u(t) = Kp * e(t) + Ki * integral(e(tau) dtau) + Kd * (de(t)/dt). Anti-windup clamping limits the integral accumulator within safe hardware bounds, preventing actuator saturation. Deadband hysteresis (+/- 2.5% of full-scale value) prevents rapid chatter and mechanical relay wear around the setpoint threshold.

8. Empirical Testing, Stress Benchmarks and Troubleshooting Diagnostics

Extensive bench testing verified system stability under extreme electrical and thermal conditions. Continuous 72-hour burn-in trials recorded zero unhandled exceptions, zero buffer overflows, and zero brownout reset events. The hardware watchdog timer (WDT) is configured with a 2-second timeout window, automatically clearing watchdog reset registers at the conclusion of each valid state machine pass. In the event of sensor disconnection, the firmware enters a fail-safe mode, safely de-energizing all relays and sounding a pulse alarm.