instructables

Arduino Star-Finder for Telescopes

by Daniel Hingston

Arduino Star-Finder for Telescopes: Page 1

Spa ce is big . Re a lly big . Owning a small measured using potentiometers. The Arduino then
telescope can give a lot of pleasure, but it's often a compares the position of the target object to the
struggle trying to locate speci c objects in the night orientation of the telescope, and using LEDs on the
sky. In this project I made and integrated an Arduino- handset indicates to the user whether the telescope
powered star- nder with a small re ecting telescope, must be moved up, down, left or right. When the
to allow me to easily nd the galaxies, nebulae and target object is within the eld of view, all four LEDs
clusters that I wanted to observe. will illuminate. At this point the observer may view the
target object through the telescope. The program
W ha t : This device calculates the current position in constantly updates the position information, to assist
the night sky of a list of galaxies, nebulae and star the observer in tracking the target object as it moves
clusters. It then measures the current heading and across the night sky. I used a 3D printer to create
elevation of the telescope, and displays to the user ttings to house the potentiometers, and to make the
how to orientate their telescope so that the chosen handset and battery box holder.
target object will be visible. The electronics are all
contained within a convenient handset, attached to Edit 20 20 - ne w pro je ct v ide o !
the telescope mount on a 0.5m cable.

W hy : Traditional methods of nding objects in the

night sky (using charts, maps, following
constellations) are slow and require experience, and
h t t ps: //www. yo u t u be . c o m/e mbe d/Ivg f Fe qmS wo
motorised 'Go-To' telescopes are very expensive. This
project nds a happy medium between the two. Clear
night skies are not common, so using this Arduino
star- nder allows you to make the most of your
Ple a se n o t e : this project assumes some prior
precious viewing time.
experience with Arduino, basic amateur electronics,
3D printing and CAD (possibly). I've tried to cover all
Ho w : The Arduino receives position and time data
of the background information relating to the
from a small GPS module. Using this, and known
astronomy, and justi cations about why I designed it
coordinates for a list of objects (my initial code
how I did. To avoid creating an overly wordy
includes 45 astronomical objects, and it's easy to
Instructable I've therefore left out some minutiae of
expand this list if you choose), their current position in
the project that would be tedious, for instance wiring
the night sky (relative to the observer) is calculated.
of LEDs and switches etc. If there's anything that
The name, position and type of the current chosen
confuses you, please ask a question and I'll try and
object are displayed on a small LCD screen on the
answer. Also don't forget that the wonderful thing
handset. By using a rocker switch, the observer can
about Arduino is the huge level of online support, so
choose which of the database's objects to observe.
if you've got a question, however basic, hopefully
The heading and elevation of the telescope are
you'll quickly nd an answer online too. This is also my

rst Instructable, so please go easy on me! view the Sun through the telescope at any time.
Doing so will cause permanent eye damage.
** Ca ut io n **: when building and testing your
telescope star- nder, please take immense care to not

Arduino Star-Finder for Telescopes: Page 2

Step 1: The Theory

Arduino Star-Finder for Telescopes: Page 3

(I'm sure you're interested about the astronomy principles Date and time are received by the GPS module, and
which this Instructables project uses, but if you're not, then time is given as Universal Time (UT). Signi cantly,
please skip ahead a step or two). Universal Time as measured by a GPS system has
never been adjusted for leap seconds since the
system was initialised in 1980, hence GPS time is
T he m e t ho do lo g y for calculating the azimuth and currently 18 seconds ahead of true Universal Time.
altitude values for the desired object is well detailed The Arduino GPS library program compensates for
in a book called 'Practical Astronomy with your this by automatically subtracting 18 seconds from the
Calculator or Spreadsheet' by Peter Du ett-Smith. I'd recorded time to nd Universal Time as necessary for
thoroughly recommend this book for any amateur the calculations.
astronomer, as it shows you how to calculate many
di erent things. Recent editions even show you how T im e Sy s t e m s :
to implement the calculations in spreadsheets. The initial part of the mathematics is concerned with
converting UTC to Local Sidereal Time (LST), which is
Input Da t a : done via Greenwich Sidereal Time (GST). Sidereal Time
The inputs to the calculation are as follows: the ‘right is de ned as the hour-angle of vernal equinox. GST is
ascension and declination’ coordinates for the target the Sidereal Time as observed on the Greenwich
object, geographical latitude and longitude of the meridian (0° longitude). The conversion to LST takes
observer, and the current time and date. into account the longitude of the observer, as the

sidereal time gets earlier or later depending on to the inclination of the telescope, and azimuth is
position relative to the Greenwich meridian. analogous to the heading.

All relative positions of all astronomical objects are Co o rdina t e s y s t e m t ra ns f o rm a t io n:

located according to the angles of right ascension
and declination (Ra/Dec). These two angles locate the (1) H=LST-
object on the celestial sphere, according to the
equatorial coordinate system. As the coordinate Where H = hour-angle, LST = local sidereal time and
system gradually moves (as the shape and orientation = right ascension.
of the Earth’s orbit changes gradually), the Ra/Dec
coordinates are adjusted. This adjustment is (2) sina=sin ·sin +cos ·cos ·cosH
performed in relation to the current astronomical
epoch. Presently, the J2000 epoch is current, and the Where a = altitude, = observer’s latitude, =
Ra/Dec gures for all astronomical items will be declination and H = hour-angle.
quoted for the J2000 period. The Ra/Dec data is
combined with the LST gure to calculate hour-angle (3) cosA= (sin -sin ·sina)/(cos ·cosa)
(Equation 1). Equations 2 and 3 are then used to
determine the current altitude and azimuth of the Where A = azimuth, = declination, = observer’s
target object. Azimuth and Altitude are the latitude and a = altitude.
coordinates of the horizon coordinate system. This is a
coordinate system unique to that position on the You will see these formulae being used in the Arduino
Earth’s surface, where 0° of altitude is the observer’s program shown in a later step.
horizon. When considering the alignment of a
telescope to these coordinates, altitude is analogous

Arduino Star-Finder for Telescopes: Page 4

Step 2: The Implementation

Ho w t o do t his w it h a o rda ble a m a t e ur e quipm e nt ?

Small GPS modules are easy to use with Arduino, and provide time and location data. Using this, the Arduino can
calculate the position of a given galaxy/nebula/cluster at any time. To provide feedback to the user about where to
point the telescope, the system will need to measure the current position of the telescope, compare this to the
correct positioning, and then tell the user how to adjust the telescope so that it will be pointing at the astronomical
object. To measure the position of the telescope, we will use potentiometers. Potentiometers are rotary devices
whose electrical resistance changes over their range of rotation. By calibration, these can be used to determine
where a telescope is currently pointing, using one potentiometer to measure the telescope's rotation, and one to
measure the elevation. The telescope purchased for this project has a Dobsonian mount, and this is vital! A
Dobsonian mount (developed by the legendary amateur astronomer John Dobson - have a look for his videos on
YouTube, you will want to try grinding your own mirrors and other amazing things) allows the telescope tube to
rotate horizontally and tilt vertically, compared to the complex movements of other telescope mounts. This will
make it very straightforward for us to program and measure.

Achie v ing Accura cy This was the challenging bit, and required weeks of experimentation. Luckily I've done this
so that you don't have to! There are four main quaniti able sources of error in this system, and they must be
managed to ensure that the telescope will manage to nd what we want. Firstly, let's calculate the Field of View
(FOV) of our telescope.

Key speci cations:

Focal length of telescope: 650mm

Focal length of eyepiece lens: 25mm
Apparent Field of View: 50 degrees

Magni cation = (Focal length of telescope)/(Focal length of eyepiece) = 26 x

True FOV = (Apparent Field of View)/(Magni cation) = 1. 9 23 de g re e s

So what this means is that when using the 'Super 25' eyepiece lens, you will see an area of the sky 1.923 degrees
across. Therefore we need to make sure that the device is accurate enough to always locate an object within this
angle. So to make sure that the device would work, I tried to quantify each source of error, and do some statistics to
predict the performance of the system. You don't need to do this step unless you're also interested.

Arduino Star-Finder for Telescopes: Page 5

1. GPS Accura cy
This was my rst time working with GPS and Arduino together. To assess the accuracy of the unit, it was necessary to
compare the GPS module’s output latitude and longitude gures to the latitude and longitude of a known location.

The location of trig points, or triangulation stations, are precisely listed by the Ordnance Survey, the UK’s mapping
agency. I took the GPS unit to six of these locations, and test results were taken, so that the device’s gures could be
compared to the known OS coordinates. Repeating this test a few times gave me enough results to provide a mean
gure of GPS accuracy, which was 11.6m. Using a formula called the Haversine Formula, again from Practical
Astronomy with your Calculator, I could nd that this should a ect the overall telescope alignment by an almost
non-existent 0.000581 degrees. Clearly this was not going to be the issue!

2. Po t e nt io m e t e rs
In this project, we're using potentiometers to measure the angle and heading of the telescope. This is potentially a
large source of error, rstly from the potentiometers themselves (including quality of the pots, plus the quality of
their installation into the telescope mount), plus how we read this data with the Arduino. An a ordable
magnetometer and gyroscope unit (the 1120 3-Axis Accelerometer and Magnetometer from Adafruit) was tested,
but was found to have an accuracy of greater than 1°, insu cient for this purpose. Optical encoders do not have a
su ciently high resolution if used in a 1:1 ratio with the movement of the telescope, and would therefore require a
gear system to raise the number of counts per degree of movement, hence why potentiometers with a linear
resistance output were chosen.

So what will be their resolution? To work this out we need to look at how the Arduino measures the analogue signal
from the potentiometers. The ATmega2560chip of the Arduino has a 10-bit analogue to digital converter (ADC),
which means that the voltage reading from the potentiometer is mapped onto a set of discrete values from 0 to
1023. The number of integer values within this range is what determines the maximum resolution of the
potentiometer reading.

The potentiometer selected for measuring the rotation of the telescope, a 6187R 1 K Single Turn Precision
Potentiometer from TT Electronics has an electrical travel over 340°. To nd the angular resolution we divide 340°
by the 1024 intervals, using equation 6, and see that the angular resolution is 0.332°. This is equivalent to 17.2% of
the width of the eld of view using the 25 mm eyepiece lens. To improve the resolution of the potentiometer
readings, an external 12-bit ADC, the ADS1015 4-channel ADC from Adafruit was selected. This small module
performs the analogue to digital conversion, and supplies the Arduino with the digital readout. The new range of
output discrete values is between 0 and 1660. This seemed to be the best compromise between the Arduino's 10-bit
ADC and the Adafruit 14-bit ADC that is also available. The elevation of the telescope will have a greater resolution,
as the telescope is being rotated over a smaller arc than it is in being rotated in heading. This results in an error of
0.10 degrees in heading, and 0.077 degrees in pitch, so not a big deal either.

3. Accura cy o f Ra /De c Da t a
For each of the 45 objects in the database (16 clusters, 20 nebulae and 9 galaxies), the gures for the J2000 right
ascension and declination coordinates were taken from the HyperLeda database. This source quotes the accuracy of
the coordinates is 10 arcseconds (0.00277°). The reason for this inaccuracy is likely because of the di culty of
determining the centre of these astronomical objects in order to de ne their position, as many of them are rather
amorphous in shape. Object 19 in the database for instance, the Crescent Nebula, has an apparent width of 0.33°
and an apparent height of 0.17°. As it has an irregular shape, it is not possible to accurately determine the true
centre of the object, hence a partial explanation for the inaccuracy in the Ra/Dec data.

4 . Pro g ra m Erro r
By far the greatest source of error was generated by the Arduino and its program. I'm sure a better programmer
Arduino Star-Finder for Telescopes: Page 6
could reduce this signi cantly, but I'm a relative amateur, and found managing the large numbers, decimals and all
the associated arithmetic quite challenging. To assess the magnitude of this, the Arduino results were compared to
position results calculated in Microsoft Excel, and it was found that the mean error was 0.72 degrees.

S UM M ARY: O v e ra ll Erro r
In Excel, each of the four identi ed sources of error was independently randomised, then combined to produce this
graph (heading image of this step). That image shows 5000 randomised results and their distribution within the
FOV of the telescope. Results within that black circle would be visible to the observer. The analysis was performed
so that the errors may partially cancel each other out, as would be the case in reality. 81.94% of these theoretical
points fall within the eld of view. Whilst not perfect, this seemed good enough in my mind to continue with the
practical details of the project.

Step 3: Ingredients

Here's the list of components I used for this project (note that the above image only pictures a few of them, that's
just a shot of my GPS test setup). With the exception of the major components, I haven't speci ed a particular
product or supplier. This is because that might not be helpful to people who like in a di erent country to me, and
also because for many of these components (switches etc.) it doesn't hugely matter what you use.

Arduino Star-Finder for Telescopes: Page 7

 Skywatcher Heritage 130p Flextube Dobsonian Telescope
Adafruit ADS1015 12-bit ADC (analogue to digital converter)
16x2 LCD Display (I used Winstar WH1602B-RTI-JT Red Characters)
Arduino Mega 2560 Microcontroller Board
GPS Module (I used GY-GPS6MV2)
Battery holder for AA batteries (6 cells in series to produce 9V)
Small breadboard to t inside the control box
SPST Rocker Switch with red LED
SPST Momentary Pushbutton Switch with red LED
Four red LEDs
SPDT Rocker Switch, Centre O
Rubber tube to use as hose to connect the handset to the telescope mount.
Arduino Uno (not part of the nished device, but useful to have a second Arduino for testing
purposes)
Suitable resistors to use with each of the LEDs.
One continuous rotation potentiometer for measuring the Azimuth (Heading) of the telescope.
One potentiometer for measuring the Altitude (Inclination) of the telescope.

You'll also need jumper leads of di erent lengths and types, multicore wire, solder, insulation tape, lament for
your 3D printer, and a computer with the Arduino IDE software installed to allow you to program the Arduino.

Step 4: Additions to the Telescope Mount

Arduino Star-Finder for Telescopes: Page 8

For this project, we need to add a variety of pieces to held by a cup shape attached to a stem which sits on
the telescope mount. I've included .step les of these the shoulder of the telescope mount. The purpose of
parts in the next step of this Instructable. I've added this is to rotate the shaft of the potentiometer relative
them as .step rather than .stl as .step les are more to the body of the potentiometer as the telescope tilts
easily modi able if you want to import them into your (allowing us to measure its angle).
own CAD software, and if you want to convert to .stl
les for 3D printing, then there are several free online Te le s co pe Az im ut h Axis Po t e nt io m e t e r
converters that allow you to do this easily. Note that Ho lde r (3rd Image, consists of 4 pieces)
these les are designed to t the Dobsonian telescope Similarly, this assembly is used to mate a
that I owned, but if you would like to implement this potentiometer to the rotation of the telescope,
system for a di erent Dobsonian telescope you will relative to the telescope mount's base. The
need to adapt at least the potentiometer holders, Skywatcher telescope I modi ed has a central bolt. I
although the design principle will be the same. added the small printed part underneath to stop it
rotating relative to the telescope baseplate. The pieces
Co nt ro l B ox (1st Image, consists of 3 pieces) above mate the shaft of the potentiometer to that
This consists of two shell halves, plus a small piece bolt, and the body of the potentiometer to the upper
which is used inside to clamp the tube that tethers surface of the telescope lower plate, thus meaning
the control box to the telescope mount. That clamp that when the mount is rotated, the shaft of the
piece is bolted across the tube, compressing it and potentiometer will be rotated relative to it's body
holding it in place. (allowing us to measure the heading of the telescope).

Te le s co pe Alt it ude Axis Po t e nt io m e t e r B a t t e ry B ox Ho lde r (4th Image, consists of 1

Ho lde r (2nd Image, consists of 3 pieces) piece)
The Skywatcher telescope I bought came with a Simple part, used to mount the injection moulded
tensioning knob. You loosen this to adjust the battery box to the telescope mount. Has two small
inclination of the telescope tube, then tighten it o to mounting holes so can be screwed directly onto the
stop it sagging freely. I replaced this with a 3D printed laminated plywood telescope mount.
one, which accepts the shaft of a potentiometer on
the other end. The body of the potentiometer is then

Arduino Star-Finder for Telescopes: Page 9

Step 5: Just Keep Printing, Just Keep Printing

T he . S T P File s I am lucky enough to own a printer, it's an ANET A6,

I've attached the parts I designed for this project as similar to the popular A8, but with some extra
STEP (or STP) les, as those are easily importable into features. If you're not into 3D printing yet, I'd highly
the CAD software of your choice, and then modi able recommend looking at acquiring a printer for
(or directly exportable to STL les for 3D printing - yourself, there are many a ordable models available.
which can also be done using a free online converter). The A6 isn't the world's best printer, but if calibrated
If you're competent with CAD software, then feel free correctly and modi ed appropriately it can produce
to incorporate any changes you'd like to make to the some perfectly ne results. High accuracy isn't that
control box, or modify the other pieces to t your important for these parts, so I used a layer height of
telescope in case you're using a di erent one to me. I 0.2mm, and printed at 65mm/s. I chose white PLA
originally designed the parts using Autodesk Inventor lament because I'm familiar with PLA, and the white
(for which you can get a free license if you're a lament visually blended in with the white laminate
student). of the telescope mount.

T he Print e r

Arduino Star-Finder for Telescopes: Page 10

Arduino Star-Finder for Telescopes: Page 11
 Download
https://www.instructables.com/ORIG/FDY/D2JU/JG754UNE/FDYD2JUJG754UNE.stp
…

Download
https://www.instructables.com/ORIG/FIO/IGBR/JG754UNF/FIOIGBRJG754UNF.stp
…

Download
https://www.instructables.com/ORIG/FR3/2AUO/JG754UNJ/FR32AUOJG754UNJ.stp
…

Download
https://www.instructables.com/ORIG/F46/SRQN/JG754UNR/F46SRQNJG754UNR.stp
…

Download
https://www.instructables.com/ORIG/FKO/QXZS/JG754UNS/FKOQXZSJG754UNS.stp
…

Download
https://www.instructables.com/ORIG/FS8/WQ2O/JG754UNZ/FS8WQ2OJG754UNZ.stp
…

Download
https://www.instructables.com/ORIG/F47/244F/JG754UOI/F47244FJG754UOI.stp
…

Arduino Star-Finder for Telescopes: Page 12

 https://www.instructables.com/ORIG/FNO/AIPN/JG754UOL/FNOAIPNJG754UOL.stp
… Download

Download
https://www.instructables.com/ORIG/FGI/7AK9/JG754UON/FGI7AK9JG754UON.stp
…

Download
https://www.instructables.com/ORIG/FBL/90EJ/JG754UOP/FBL90EJJG754UOP.stp
…

Download
https://www.instructables.com/ORIG/FVQ/5ERP/JG754UOQ/FVQ5ERPJG754UOQ.stp
…

Step 6: The Control Box

W ha t it co nt a ins breadboard inside the control panel, although you

The control box contains all the electronic could save a lot of space by soldering wires and
components of this project, with the exception of the components to a small piece of perforated copper
two potentiometers attached to the telescope mount, stripboard or similar. The four LEDs are a push- t into
and the battery box, which is also attached directly to the plastic case front, and the other items are held in
the telescope mount. The control box is attached to with a small amount of superglue.
the telescope on a 0.5m long length of rubber tubing.
Through the tube run the signal wires from the Jo ining t he t w o ha lv e s o f t he Co nt ro l B ox
potentiometers, and power lines from the battery box. You'll see from the .stp les for the control box that
I found it tricky to encourage the wires along the there's a recess to t a hex nut in each of the four
narrow tube, so used a little bit of soapy water to corners. By push- tting the nuts into these holes and
lubricate the tube so that the wires could be slid supergluing them there, it allows you to then pass a
through. I then washed it out and let it dry out screw in through the other half of the control box,
thoroughly before continuing. and tightly join the two halves, but also so that you
can open it to alter wiring etc. Be sure to not over-
Fit t ing o ut t he Co nt ro l B ox tighten the screws, as you might dmage their plastic
You can see from the pictures above how I did this, housings.
although there's probably a neater way. To allow me
to quickly modify things, I used a small solderless

Arduino Star-Finder for Telescopes: Page 13

Step 7: Neat Cable Management

It's worth doing a better job than me at this! There's a not included speci cs of the wiring for any of the
lot of wiring inside the control box, and can get units as there is nothing unusual, and for all of the
di cult to work with unless you're neat. The above components I have used such as the ADC and the LCD
diagram should answer any questions you have about screen, there are a multitude of good wiring
the internal layout of the control box, as well as the instructions online, many of them on Instructables.
previously shown block diagram of the system. I have

Step 8: The Arduino Program

Here's the Arduino program needed for the telescope. obeying the same format. The program is lightly
Upload this to the Arduino MEGA, making sure that annotated for clarity. Do n' t f o rg e t , you need to
your connections match the pin attachments made in install the ve libraries called for at the start of the
the program. If you want to increase the number of program in order for this to work!
astronomical objects in the object database, increase
the number of objects 'n' and add your entries below,
Download
https://www.instructables.com/ORIG/F08/FBF0/JGCJCOQQ/F08FBF0JGCJCOQQ.ino
…

Step 9: Testing, Testing

Te s t e v e ry t hing indiv idua lly !

A bad jumper lead, a poor solder joint, an incorrect polarity here and you might run into di culty. That's why it's
very important (like any amateur electronics project) to test things as you go along. That way it's easy to work out
where the errors are emerging (if they do), so that you can more easily solve them. Imagine trying to debug the
whole system at once, that would be very frustrating. The good thing is that everything can be checked by itself
before the system is combined. Here are some useful things to check as you go through the build, which might be
able to save you a lot of hassle later on:

Arduino Star-Finder for Telescopes: Page 14

 After soldering header pins onto the LCD screen and connecting it to the Arduino MEGA, check that
the display works by running an example LCD program. I managed to damage my rst LCD by
incorrect wiring which burnt it out, so check you haven't done the same.
The GPS module works and receives data. Use one of the sample programs from the TinyGPS library,
and connect the GPS to the MEGA or any spare Arduino you have handy. Note that you are unlikely to
acquire a signal whilst indoors, so it would be worth taking this outside when checking that it works
(after all that's where you'll be using your telescope)!
Potentiometers. Again, there is scope to damage them with excessive heat during soldering, and also
to make mistakes with the wiring. Make sure you're seeing a good linear output from them by
hooking them up to an Arduino.
The program - as this program works for me, you shouldn't have to do this (unless of course you are
modifying the project), but don't forget you can use the characters /* before and */ after to block
out a segment of code, in order to run only speci c portion. Also normal Arduino debugging of
printing variables to the Serial Monitor, and running your program with the Arduino attached to
your PC via a USB cable so that you can see how variables are behaving at di erent points in the
code.
Switches - always worth taking a multimeter to these to check that the operation of them is as
expected.

Ve rif y ing t he f unct io n o f t he a lig nm e nt s y s t e m

Stellarium is an excellent freeware program which can show you the night sky from any position on Earth at any
time of day. You can use this to get the Azimuth and Elevation of a particular astronomical object to compare it to
the Arduino-calculated value. Take your laptop outside to help you learn about the position of objects in the night
sky, although the screen is bad for night vision, there's a 'night mode' button which makes the entire display red.
There are also a large number of apps for tablets and smartphones, but none are quite as good as Stellarium. Be
aware that the method Stellarium uses to calculate the Az and Alt of objects is slighlty di erent to the one we use in
this project, so expect the results to be ever so slightly di erent.

Arduino Star-Finder for Telescopes: Page 15

Step 10: The Sky at Night

If everything has gone to plan, the Arduino star- nder should now be ready to use!

Ho w t o o pe ra t e t he de v ice :

Arduino Star-Finder for Telescopes: Page 16

 1. Turn device on using the illuminated rocker switch on the control box, and this should light up.
2. After a quick welcome message on the LCD screen (pictured), there will now be a brief waiting period
as the GPS module acquires a signal (you will get a message saying *NO GPS SIGNAL*) , but this
should be no more than a couple of minutes (assuming you are outside!).
3. Following this you will be prompted to "ALIGN ON POLARIS AND PRESS BUTTON". This is how the star-
nder is calibrated. Polaris was chosen as it's one of the easiest stars to nd in the night sky (northern
hemisphere). Make sure that Polaris is visible in the centre of the telescope view- nder, the press the
central momentary pushbutton, and the LCD screen will ash "COMPLETE". Now the Arduino knows
to associate those potentiometer readings with that Azimuth (heading) and Altitude (inclination).
4. After this stage you will now see the details of the rst item in the astronomical object database. The
LCD displays the name, type, and azimuth and altitude of the selected object. Using the rocker
switch, ick through the object list until you nd one you wish to observe. Objects with a negative
altitude will have a message against their name of "IS BELOW HORIZON".
5. For any particular object, the four LEDs on the control panel (beneath the LCD screen, arranged in a
cross-shape) will illuminate to show whether the telescope needs to be panned down, up, left or to
the right in order to be aligned with the target object. Move the telescope now, following these LEDs
until all four are iluminated, which shows that the telescope is on target.
6. Now you're ready to do some stargazing! Look through the telescope eyepiece lens and you should
see your chosen sight.

Step 11: P.S.

There are some things I'd like to do di erently if I had the chance to do this project again. Maybe you'll adopt some
of these ideas when you do your version of this project?

Arduino Star-Finder for Telescopes: Page 17

 Adapting for use in the Southern Hemisphere. Polaris (used by the star- nder for calibration after
being turned-on) isn't visible in the Southern Hemisphere, so you'll need to change this to one that
is.
Weatherproo ng. Although you wouldn't use a telescope in the rain, at night you get a lot of
condensation and moisture building up, so next time I would design the cases to t a waterproof
seal, to help protect the electronics.
Build a larger database of astronomical objects, to expand on the 45 that I've used.
Update the way that the object data is presented. It might be better to only list the objects that are
currently visible, instead of needing to scroll through the whole library to nd the ones that are.
Adjustable feet and a bubble level inbuilt into the base of the mount. This would help you ensure
that the base of the telescope is always level, helping with the accuracy of the alignment system.

The above picture of the moon was taken using my phone camera through this 130mm Dobsonian telescope, whereas the
picture of Whirlpool Galaxy M51a was taken by me using the 6" Bradford Robotic Telescope.

Excellent. I did something a bit similar (a satellite pointer) years ago and i used that same book. My
head still hurts when i think abut the math.
Congratulations on the job, I think it's spectacular. I am working on it and a wiring scheme would be very helpful, if possible I would be very grateful
Greetings from Spain

Hi there. Very sorry I didn't reply sooner, I have not been active on Instructables for a while, and
have just come back to the site now. I'm sorry I don't have a full wiring scheme, perhaps see
DurkV's comment below with a detailed (modified) schematic? Thank you
Very very nice project. Please, what are these constants in azalt() method means ? 6,47777 for
altpotgood and 4,88529 for azpotgood. I used MPU-6050 accelerator/gyroscope.
Thanks.
Hi Hocki. Apologies for not replying sooner, I haven't been active on Instructables for a while. I
think that those values are to scale to potentiometer readings to degrees of altitude, i.e. the

Arduino Star-Finder for Telescopes: Page 18

resolution of the potentiometers. I hope you've been able to work through this, it's not an easy thing
to build, it took me several months and a lot of testing.
Hi, I make a satellite tracker with an esp8266 and 2 step motors. It uses sgp4 orbit propagation but
now I want to add the possibility of look at stars an follow them.
Now I get the Azimuth and Elevation of a satellite and follow them in real-time. But I don't know
how to make the same with stars (in fact is more simple but I don't make any calculations, I only
use a propagator).
The question is, how I make the calculations using only TIME (Julian date, UNIX, etc) and mi
ground station coordinate? can I remove the TinyGps module without trouble?
I'll have to agree with several other people about the encoders, but why pay $30-hundreds of
dollars for the hi-res ones? If you're going to 3-D print the mount anyway, go ahead and print some
gears! Better yet, since gears can have a little slop, a toothed belt, used in some 3-D printers,
works better with less hassle. If you need more absolute position data, use both! Let the analog pot
be your rough position indicator, and let the encoder do the fine positioning. That dithering or noise
that analog pots do lowers your resolution, so use the encoder for the final 2-4 bits. If you use it in
quadrature, meaning you sense all four level transitions, an encoder labelled as '24 ppr' can give
you 96 increments per rotation. It wouldn't take much gearing to get that up to a usable level.

However, if you're going to pay a bit anyway, or just want the best accuracy with absolute position
information, look for rotary encoders with Gray Code. They're expensive, but you'll know exactly
where in the rotation you are at all times. The linear ones give amazing precision - they use an
optical reader like a computer mouse and a strip of plastic with the gray code micro-printed on it.

As for your math and program accuracy, it appears you did a fine job. You have to remember to
take into account the actual arc resolution of the telescope and total field of view. For a relatively
small focal length and aperture like this, the Arduino's accuracy is fine. There are math libraries
that could extend the resolution a bit, but they take up a lot of space the stock Arduino might not
have available. If you do wish to step it up a bit, the new Raspberry Pi 3 or 4 could be a fine
compute engine with full Linux C++ math libraries and all sorts of support. If you want to save a
few dollars, the Teensy 3.x line is extremely powerful for the price, programmable with the Arduino
IDE, and a lot of memory for those larger programs and libraries.

Keep up the great work!

Nicely done!
I am a bit surprised you say that optical encoders don't have enough precision, though. You can
get 4096 ticks per rotation precision from an optical (or magnetic, for that matter) encoder, which is
better than 0.1 degrees.
Awesome project! I've been getting into (amateur) astro-photography and have been noodling with
ideas for a polar tracker. So this project really caught my eye!

The deal with encoders is, they give incremental changes in position, not absolute position from a
known position. So this brings the necessity of a homing method, each time the unit is powered up.
Thus adding complication to the mechanics of the design and to the the operation of the device. At
each power up move each axis of the the scope mount to a "zero" position, then make calculation
for desired position for the object selected.

So I think the potentiometer is a good choice in this application. But pots have a temperature
dependence. Luckily these are usually given in the performance data sheet. So as an upgrade to
this device one could also add a temp sensor and have the software compensate for the
temperature effect on the pot.

Arduino Star-Finder for Telescopes: Page 19

Hi there, thanks for your answer. Several other people have picked up on that too, I overlooked
that as the encoders I was browsing didn't have anywhere near that precision, but it's good to know
for future that these products do exist.
There are also magnetic encoders (e.g., from Austria Microsystems) which a lot cheaper than the
optical ones and have the same kind of precision, but are harder to mount as you need to align the
magnet with the IC.
Very nice job. I especially like your error analysis, although I'm not quite sure how you ended up
with the numbers you posted. With a 12-bit ADC, shouldn't your precision be 340 / 4096 = 0.083
degrees?
Amazing work!!

When implementing any A/D converter it is imperative to include power supply errors when
evaluating performance accuracy
I, too, would appreciate a wiring diagram/schematic. Great project. Right up my line of interest right
now.
Thanks
Hi, I like your project, BUT!!!
Where is the circuit diagram, NOT A FRITZY generated one.
What are your potentiometer values and where did you purchase them?
What are you using to power the project?
Thanks Tom
wooooow just wooooow. Are you a scientist who works for NASA.

Great job! I see lots of care taken when creating this Instructable!
Would it be possible to add on an input for coordinates for closer, and faster moving objects? I'd
like to visually track the International Space Station, and other items in the night sky.
Thank you ToolboxGuy. That's a good suggestion, but I'll tell you why I didn't add it. The
mathematics for calculating the position for all 'deep-sky' objects is the same, so for galaxies,
nebulae, star clusters etcetera you can use the same process. The planets and the moon all have
different, and actually quite complex patterns of movement which would need to be calculated
differently. If you're interested, the book I recommend, 'Practical Astronomy with your Calculator'
has a lot more info on this in case you'd like to add this functionality.
I was considering a low tech approach for now - just look up the current info online, and punch in
the numbers - that kind of "input." Later, create a REST API call to fetch the coordinates from
somewhere else, confirm it's in my view of the sky at this time, and if so, take aim. If not, error
message with "not in view at this time."
I'd love to be able to just say "what's in my field of view right now, and where is it?" but Alexa and
Google aren't nearly that sophisticated yet.
The space station moves fast enough that I don't think this would be a practical way to track it.
Years ago I built a satellite tracker that used two servos to point at satellites based on their norad
coordinates. If you google arduino satellite tracker you may find other examples. Also, if you have
a smartphone there are various night sky programs to tell you where to look. Because the satellites
are bright and moving, once you know where to look you can track them pretty easily by eye.
Sounds like a fun project, I assume as that was years ago it's not on Instructables? Funnily enough
when testing my telescope for this project I was having fun by trying to track airliners as they
passed above my house, but as like they move quickly like the ISS it was really tricky (there was
no risk of accidentally observing the Sun as I positioned the house between me and it btw).

Arduino Star-Finder for Telescopes: Page 20

It was a while ago. I did a writeup on it but nothing like the quality of your work:
http://forum.arduino.cc/index.php?topic=72921.0
Very interesting. I added this as my next project.
Question, how much hate mail have you received, or think you will receive for having used 666 in
your code? ;-D
Haha, I think that was a subconscious thing due to the Iron Maiden I was listening to at the time ....

Good taste in music too!

Up the irons!
Brilliant project.
Thinking: Wouldn't using stepper motors enable a high degree of accuracy ? After having aligned,
the telescope/Arduino would always know, where it's pointing.
I have a Dobsonian telescope using steppers, but the electronics are "shot".
I'll see if i can build on your project.
Thanks for posting !
Thank you, I appreciate your feedback. It would be a really good expansion on this to also motorise
the mount too. I steered away from that as it adds cost, complexity of gearing, and difficulty of
eliminating any 'backlash' in the drive mechanisms, but yes I'd agree it would be cool. Sounds like
you've done something similar to that before, I'd be interested to hear more about it or see some
pics if you've got any. Good luck with the repairs if that's what you're doing!
Nice project! Love your profile pic btw :)

Thanks Gadisha, I'm a big fan of the old 70s Hitchhiker's Guide to the Galaxy TV series.

Nice project. I don’t know whether I’ll build one but I definitely will go through the sketch in detail.
I used the 12 bit version of these encoders in a different project
http://www.madscientisthut.com/Shopping/agora.cgi?
cart_id=2909535.207305&p_id=ASRE10BIT&xm=on
so 4096 ticks per rev. They were also fairly easy to interface to an Arduino. I used code available
from website as a starting point.
Hi there, thanks for your kind comment. That looks like a useful piece of kit, there have been a few
other users suggesting that encoders may prove to be more useful in this application than
potentiometers, and I'd be interested to experiment more with this.
I don't really have words to compliment you enough! This is one of the most incredible projects I
have ever seen - and I'm not just saying that! You can't hear my tone of voice, but I am in complete
awe. This is a very well done Instructable and a great project! Thank you for taking the time to
share all this information!
Cheers dude, my pleasure.

Great project! You may be able to improve the Arduino calculation accuracy simply by using an
STM32-based 32-bit processor, like in the "Blue Pill", without even changing your code. These
high speed (72 mHz vs. 16 mHz for Arduino) processors/boards can be programmed by the
Arduino IDE, and can be purchased from China for as little as $1.85.
Thank you, thanks for your comment, that's an interesting suggestion. Being able to reduce the
calculation error would be a very useful thing, I'll definitely order one of those and at some point run
some bench tests to confirm what difference in output values may be seen. Cheers!

Arduino Star-Finder for Telescopes: Page 21

You probably mean MHz, as m is for milli while M is for mega, which is 1,000,000,000 times more

Love your project. I've been meaning to add Taki's algorithm to my own digital setting circles
projects and allow it to be used without an iPad/SkySafari. I'll definitely have to take a look at your
code and see if it can be integrated into mine.
That said, you would be much better off using optical encoders + quadrature encoding. Would be
significantly higher resolution. I currently use 10K count encoders from US Digital which equate to
40,000 ticks per revolution or 0.009deg accuracy. Note that your mount has to be perfectly
square/perpendicular and can't have any other defects to see the full resolution, but either way, it's
orders of magnitude better then analog pots.
You can find cheaper/lower resolution encoders to keep the cost down, but for about $30/ea you
can get 2500 count encoders which end up being 0.036deg.
Hi there, thanks for your comment. Several other users too have commented about these
encoders, so it seems like I missed a trick here, but good to know. I'll definitely look up those
particular units as that's a very useful piece of kit. The other issue of the potentiometers is that they
produce minorly fluctuating output values, only to a minor degree, but not ideal. Thanks
Great tutorial dude!! Really well explained and very easy to make! Voted ! Good luck!

Thank you! Appreciate the compliment.

Wow, this is a great project!

I know that the connections between components can be figured out by going through the .ino file
and noting which signals are assigned to which pins but is there a Fritzing or similar wiring diagram
available, something a little more in depth than the block diagram?
Thank you! Yes it would be good to do a Fritzing, you're right. I'll try and add one in if I get a free
evening soon.
Great job, Arthur. I'll try to make one!Detalhes

Amazing project. Well done.

Amazing project!

Cool beans

Arduino Star-Finder for Telescopes: Page 22