19
$\begingroup$

How long would it take for Juno's communication to reach the Earth? In other words: what is the time delay between perception by Juno and perception by NASA researchers?

$\endgroup$
  • 5
    $\begingroup$ As an interesting bit of trivia, the travel time of light from Jupiter to Earth is how the speed of light was first measured: en.wikipedia.org/wiki/… $\endgroup$ – Kevin Jul 5 '16 at 15:13
  • 1
    $\begingroup$ Strictly speaking, not the actual travel time of light from Jupiter to Earth (which is not measurable), but the difference in travel time between the Earth being closest to Jupiter and the Earth being furthest away. But it is a lovely story, and the only estimate we had of the speed of light for a long time. $\endgroup$ – Martin Kochanski Jul 5 '16 at 16:32
  • 3
    $\begingroup$ @Kevin: I wouldn't call that a "bit of trivia"! It wasn't just the first such measurement, it was the first empirical evidence that light travels at a finite speed at all. This raised problems that baffled physicists until Einstein banished the ether in 1905. $\endgroup$ – TonyK Jul 5 '16 at 16:35
20
$\begingroup$

Using NASA's Eyes measuring the distance from Jupiter to Earth at this moment (5th Jul 2016, 11:50 CEST) is 48 light minutes, 21.39 light seconds, and that would be the time Juno's communications take to reach Earth.

$\endgroup$
  • 2
    $\begingroup$ NASA's Eyes app is a really great resource; I use it all the time. If you're on the go, you can just check DSN Now. $\endgroup$ – Phiteros Jul 5 '16 at 17:23
15
$\begingroup$

EDIT: based on @Beska's comment, I went back and calculated the difference including light time. In other words, you have to use Jupiter's position roughly 48 minutes ago to state the travel time. Using the observe() method, which does this, there is a difference of 0.02 seconds. This doesn't really matter, considering that Juno is in a large orbit around Jupiter, not inside Jupiter - yet! :)

import numpy as np
import matplotlib.pyplot as plt

from skyfield.api import load

data   = load('de421.bsp')
ts     = load.timescale()
t      = ts.utc(2016, 7, 5, 9, 50, 0)

jupiter, earth  = data['Jupiter barycenter'], data['Earth']
jpos, epos      = jupiter.at(t).position.km, earth.at(t).position.km
d_instantaneous = np.sqrt(((jpos - epos)**2).sum())

d_light = earth.at(t).observe(jupiter).distance().km  # where WAS Jupiter 48 minutes ago?

clight = 299792.458  # km/s

print "d_instantaneous / c = ", d_instantaneous/clight
print "d_light / c =         ", d_light/clight

gives

d_instantaneous / c =  2901.39437989  
d_light / c =          2901.4127772

So it looks like NASA Eyes is using the simpler method of using instantaneous positions, and not actually back-calculating the position where Jupiter WAS when the signal would have started.


This is a different way to look at it. This is the variation of distance, light time, and also angular separations from the sun for Earth seen from Jupiter, and Jupiter seen from Earth. When they are too close, radio communication can become difficult.

I used Python and the Skyfield package. @SF. gives the right answer, I'm just plotting values as a function of time. The way I chose to do this I didn't used Skyfield's methods for light-time corrections, gravitation or astronomical aberration or atmospheric refraction, which are done with the .observe() and .apparent() methods. (Not all of those affect light time significantly anyway.) For this kind of rough plot it's not necessary so I used a short-cut.

The black dot is approximately July 4, 2016 for reference.

enter image description here

import numpy as np
import matplotlib.pyplot as plt

from skyfield.api import load

data = load('de421.bsp')

years = np.linspace(2015, 2020, 1000)

ts     = load.timescale()
t      = ts.utc(years, 0, 0)

jupiter = data['Jupiter barycenter']
earth   = data['Earth']
sun     = data['sun']

jpos = jupiter.at(t).position.km
epos = earth.at(t).position.km
spos = sun.at(t).position.km

d_je = np.sqrt(((jpos-epos)**2).sum(axis=0))
d_js = np.sqrt(((jpos-spos)**2).sum(axis=0))
d_es = np.sqrt(((epos-spos)**2).sum(axis=0))

clight = 2.9979E+05  # km/sec speed of light

t_je, t_js, t_es = [thing/clight for thing in [d_je, d_js, d_es]]

# dot products for angles
sep_js = np.arccos( ((jpos-epos)*(spos-epos)).sum(axis=0) / (d_je*d_es))
sep_es = np.arccos( ((epos-jpos)*(spos-jpos)).sum(axis=0) / (d_je*d_js))

degs = 180. / np.pi
ttjly4 = ts.utc(2016, 7, 4).tt
i = np.argmax(t.tt>ttjly4)  # find the index of the first time point after 4 July 2016

fig = plt.figure()

ax = fig.add_subplot(2, 2, 1)
ax.plot(years, d_je)
ax.plot(years[i], d_je[i], 'ok')
ax.set_title("Jupiter-Earth distance(km)")
ax.ticklabel_format(useOffset=False)

ax = fig.add_subplot(2, 2, 2)
ax.plot(years, t_je/60.)
ax.plot(years[i], t_je[i]/60., 'ok')
ax.set_title("Jupiter-Earth light-time (minutes)")
ax.ticklabel_format(useOffset=False)

ax = fig.add_subplot(2, 2, 3)
ax.plot(years, degs*sep_js )
ax.plot(years[i], degs*sep_js[i], 'ok' )
ax.set_title("Jupiter-Sun separation @Earth (deg)")
ax.ticklabel_format(useOffset=False)

ax = fig.add_subplot(2, 2, 4)
ax.plot(years, degs*sep_es )
ax.plot(years[i], degs*sep_es[i], 'ok' )
ax.set_title("Earth-Sun separation @Jupiter (deg)")
ax.ticklabel_format(useOffset=False)

plt.show()
$\endgroup$
  • $\begingroup$ The detail is great, but this could use a bit of explanation at the beginning explaining why this is all needed. (The OP sounds like (s)he is just expecting a single, unchanging number.) $\endgroup$ – Beska Jul 5 '16 at 18:20
  • $\begingroup$ @Beska thanks for your suggestion! I've added some info. Looks like NASA Eyes is using an unnecessary approximation. Do you want to notify JPL? Next step is to get a hold of the actual orbit and positions of the Juno spacecraft itself, and not use Jupiter's barycenter. $\endgroup$ – uhoh Jul 6 '16 at 3:41
  • 1
    $\begingroup$ "not inside Jupiter - yet!" And by the time Juno is inside Jupiter, we won't really worry about the travel time of radio signals between it and Earth, anyway. $\endgroup$ – a CVn Jul 6 '16 at 8:52
  • $\begingroup$ @uhoh - your answer provides a large amount of useful data, but as I have not enough reputation to add straight comments I'd thought I'd show you this utility in a seperate "answer": ssd.jpl.nasa.gov/?horizons You can retrieve the epherimedes for most of the major and minor bodies in the solar system, along with a large chunk of the comets/asteroids and most of the NASA spacecraft out in deep space. It outputs things in easy to parse values in timesteps you set. I've not tried to import it into python yet, but it was easy to work with in C. Could only be (wonderfully) easier in Python! $\endgroup$ – fuchstraumer Jul 12 '16 at 17:29
  • $\begingroup$ @uhoh - It seems similar to the library you linked already. You might be able to even get Juno's actual position, I haven't checked the system in a while though. As was pointed out (by the code) the communication time will vary, both as Juno continues to approach and as Jupiter moves along its orbital path. Jupiter has an orbital period that is much longer than earths, but not as obnoxiously long as the outer gas giants / pluto and as such will come into play in some fashion. We also have to consider earth's distance from the sun, and how this will come into play. The interplay of these two is $\endgroup$ – fuchstraumer Jul 12 '16 at 17:29
3
$\begingroup$

Jupiter is about 5.2 A.U. from the sun and earth is 1 A.U. from the sun. So distance between Jupiter and Earth ranges from 4.2 to 6.2 A.U.

1 A.U. takes about 500 seconds for light to traverse. So light's travel time from earth to Jupiter takes 2100 to 3100 seconds which is 35 to 52 minutes.

$\endgroup$
  • $\begingroup$ I like your "script" better than mine $\endgroup$ – uhoh Jul 8 '16 at 16:19
  • 1
    $\begingroup$ @uhoh I like your answer. But a detailed examination can be intimidating. So sometimes I strive for brevity. $\endgroup$ – HopDavid Jul 8 '16 at 16:23
0
$\begingroup$

The space.com folks assert the closest earth and jupiter can get in their elliptical paths is 588 million kilometers. My physics text states the speed of light is 1002 million kilometers per hour. Division yields decimal hours, then multiplication to get minutes: approximately 35 minutes. Since the actual distance between Jupiter and the Earth the day after Juno arrived is probably a bit more than the minimum I started with, so radio connect is a minimum 35 minutes.

$\endgroup$
  • $\begingroup$ That sounds about right for the minimum. Do they give a maximum distance also? From 2015.0 to 2020.0 only, the plot above shows variation from about 36 to 53 minutes. But it looks like the distance right now is closer to the maximum. $\endgroup$ – uhoh Jul 6 '16 at 3:56
  • 1
    $\begingroup$ Your physics text has too low a value for the speed of light. It's 299 792 458 m/s which is 1079 million km/h. $\endgroup$ – Hobbes Jul 12 '16 at 20:09
0
$\begingroup$

Minimum distance of Jupiter from Earth (space.com) $\approx588*10^6 \text{km}$

Maximum distance of Jupiter from Earth (space.com) $\approx968*10^6 \text{km}$

$c \approx 3.0*10^8 m/s$

Minimum time for signal to reach Earth:

$$588*10^6 \text{km} * (1000m / 1\text{km}) * (1/c) * (1\text{min} / 60\text{sec}) \approx 32.67 \text{min}$$

Maximum time for signal to reach Earth:

$$968*10^6 \text{km} * (1000\text{m} / 1\text{km}) * (1/c) * (1\text{min} / 60\text{sec}) \approx 53.78 \text{min}$$

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.