Spacebook: AGI's near Real-Time satellite viewer | Hacker News Reader

Spacebook: AGI's near Real-Time satellite viewer

apps.agi.com

167 pointsdricornelius41 comments

This one is pretty good too, and doesn't eat all my RAM - http://stuffin.space/

Interesting stuff, it appears to be their own data (I'm guessing aggregated from sources like the UN registry and observation). I was curious about the statistics on satellite missions so I put it into a table:

  Operational satellites by mission:
  total                   2154
  Communications          740
  Scientific              592
  Navigation              135
  Technology Development  109
  Earth Observation       99
  Surveillance            58
  Engineering             20
  Weather                 13
  Not Recorded            8
  Early Warning           3
  Search and Rescue       1
  Space Station Flight    1

A few interesting things :

The sum of all mission-detailed satellites is lower than the total (even thought there’s a « no recorded » line

There’s a grand total of 58 surveillance satellites around the earth today ? Yeah... I think there’s a few missing

This is wonderful.

If it catches your fancy, I have also found termtrack to be a great way to fill in a corner of a tmux window.

https://pypi.org/project/termtrack/

So the Cesium you see at the bottom is actually a new startup they spun out of AGI (note the letter order, very different from AIG).

They build an open-source WebGL-based competitor to Google Maps' engine.

Patrick Cozzi, the driving force behind the technology is one of both the smartest and nicest people I've met during my career.

We use Cesium at https://ayvri.com (with some of our own magic sprinkled in). It is an incredible bit of software, completely agree with your comments regarding Patrick. He's also the driving force behind glTf and wrote the book on virtual worlds in webGL. https://www.amazon.com/Patrick-Cozzi/e/B004LGLPIA/ref=dp_byl...

http://www.lizard-tail.com/isana/lab/orbital_decay/

If you want to see how long it takes for satellite orbits to decay in LEO, check this out. Illustrates how quickly some of these satellites would reenter without station keeping.

    Total objects:          17,642
    Status non-operational: 15,389

Yikes?

Yea for sure.. I would hope that there is some rule now related to making sure things can be deorbited with some scheme relatively easily? For example a mandatory unit that attaches to the side of your satellite that has a small antenna only possible to communicate with using a high gain antenna on the ground that can transmit back using a battery that is only for that unit and can only command some relays to fire thrusters to de orbit the thing and read back basic telemetry to help validate what the slow down burn direction is.. anybody know how they accomplish this?

To deorbit a satellite, you need an antenna (to receive the command), electricity (working solar panel / battery), working on board computer, fuel, correct attitude determination. So basically you need a full working satellite. As soon as one of these element fails, your satellite is dead. At 10-20 k dollars per kg, you dont want to add another satellite to your already expensive satellite.

Concerning rules, there is some progress, because nobody wants a Kessler syndrome, too much is at stake. For instance, European satellites are launched only if they naturally deorbit in less than 25 years (for LEO, of course. Above a certain height, atmospheric drag is too weak).

Actually, the newly-proposed FCC rules would require fail-safe deorbit systems when operating above 550 km and below 2000 km. Above 550 km, most stuff takes more than 25 years to deorbit, and the NGSO volume below 2000 km is considered the most useful (and thus most likely to get crowded). These fail-safe systems should be designed to cause the satellite to deorbit within 25 years of activation.

https://docs.fcc.gov/public/attachments/FCC-18-159A1.pdf

The FCC hasn't proscribed exactly what these look like (that's implementation), but electrodynamic tethers would seem likely.

So basically a small college football stadium's worth of people spread out over a surface area somewhere between Neptune's and Saturn's.

...albeit some of the people weigh 8 tons and move at the speed of 7km per second...

https://en.wikipedia.org/wiki/Envisat

7km/s is "standing still" in low-Earth orbit.

Not if you're moving in a different direction. The opposite one, for instance.

The amount of delta-V required to orbit opposite of Earth's rotation is immense and very few projects have wasted the resources on it. I think most collision concerns come from inclinations and changing orbital altitude due to atmospheric drag. These are predictable effects, but it gets dicey quickly if your surface area increases because your vessel explodes.

It's not as rare as you might think. All sun-synchronous orbits are slightly retrograde (inclination = 98 degrees or so at 600 km) in order to take advantage of the precession caused by the earth's equatorial bulge and maintain the same local solar time in the ground track.

Also, Israel always launches in a retrograde orbit, since they have neighbors to the east who would react too well to what looks for all intents and purposes like a missile launch, or to expended rocket stages dropped on their heads. For that reason, Israel launches retrograde over the Mediterranean.

Even neglecting a retrograde orbit, though, just a slight difference in inclination is enough to totally ruin your day. Even if you're only off by one degree, if you're travelling at 7.8 km/s your closing perpendicular velocity at the node crossing is 7800*sin(1 degree) = 136 m/s. That's almost 500 km/h, plenty fast enough to ruin your day.

I made a similar site 20 years ago (an applet, what else) and a lot of people seem to be wondering "how does it work" or "where does the data come from?". I can only describe how I implemented it, but it's probably similar.

Data is not "real time" for each satellite in any sense. But since satellites follow orbits, it's enough to have recent state, and you can extrapolate where they are. The data comes from places like NORAD, and has a standardized format called a "Two line element set". https://en.wikipedia.org/wiki/Two-line_element_set

Here is the current state of the international space station for example as described in a TLE:

    ISS (ZARYA)             
    1 25544U 98067A   19238.30917157  .00002323  00000-0  48072-4 0  9991
    2 25544  51.6438  13.4147 0007728 328.5901 233.9236 15.50389701186137

It's mostly opaque but we can see near the end of the second line that at the current orbit means it does around 15.5 orbits per day. When I implemented my app, I just grabbed some data from a public link with up to date TLE's. Such as this one, for the 100 brightest satellites is a good start for a simple visualization app.

https://www.celestrak.com/NORAD/elements/visual.txt

Once you have the TLE for a satellite which describes where it was a while ago, you need a function that gives you the current state vector for the satellite, given the time delta since the known state. Far from earth this can be done approximately with simple orbital mechanics, but close to earth you need to account for athmospheric drag and also the uneven or "bumpy" gravitational field. At some point someone devised a set of algorithms for this called the simplified perturbations models in 1988 https://en.wikipedia.org/wiki/Simplified_perturbations_model...

Basically current_state = SGP4(old_state, time_since_old_state)

Luckily, these functions were released together with a Fortran implementation, so porting it to whatever language you want is fairly straight forward. Here is an example port of SGP4 to python https://github.com/brandon-rhodes/python-sgp4/blob/master/sg...

https://en.wikipedia.org/wiki/Kessler_syndrome

I hope we get the GPS III constellation up and running before any catastrophic LEO cascades. Having a self sustaining common clock system that can run for centuries has a very high scientific value (and really, just a huge value for any industrial, commercial, and consumer applications).

LEO cascades would not affect GPS in any way, as GPS satellites are in much higher orbits.

LEO cascades would affect our ability to launch anything into orbit.

From what information are you assuming these will run for centuries? Most sats have a design life of like 10 to 25 years max. Also keep in mind that station-keeping and correction data is mandatory to keep the accuracy in check. I think I read somewhere that after 180 days of un-corrected drift the GPS would be able to get you within a few km of your target - not meters/feet.

I was told by someone who follows theses things more closely than me that block III GPS would have an inter satellite network that could share clock information independently of ground control. While looking into it the closest I could find was references to OCX, which is ground based controls. So maybe we're not there yet idk.

If people want to see some good satellite data, I very much recommend https://worldview.earthdata.nasa.gov/

Are there standard libraries or agencies or something for aggregating the latest data and then based on your satellite's planned trajectory, ensuring that you aren't getting too close to another satellite?

I am guessing that space is pretty big even in low earth orbit and so probabilities are small even with thousands of objects. But even so, if you are spending millions of dollars, you would want to have some idea rather than just keeping your fingers crossed.

NORAD tracks everything in space, and works directly with satellite operators to reduce collision risks on the rare occasion that it could happen.

Is there a global database or protocol or blockchain or something where satellite positional data is aggregated? Like if you are launching a satellite then you log into a website or something and enter the planned orbit. Or something.

Or is it just a bunch of random tracking efforts with duplication and incompletion?

The data for Spacebook, like almost all public satellite position data, comes from tracking radars run by the US Air Force. They have a public website and database with API at https://space-track.org.

I've been working on my own website using the space-track.org API to show you when/where/how to see satellites in the sky with your naked eyes from your own backyard. Hopefully launching soon.

How exactly does blockchain solve this problem, other than being the buzzword of the day?

The vast majority of this data comes from the United States Strategic Command's Space Surveillance Network, which provides orbit information in SGP4 format for public use:

https://en.wikipedia.org/wiki/United_States_Space_Surveillan...

So many dead satellites. Is there solution to that, or is there a problem with it in the first place?

Most of the current debris comes from an anti-satellite missile test (China) and 1 collision caused by an out-of-control (Russian COSMOS) satellite. So, basically stop blowing shit up in orbit and it should be ok.

What's neat is you can see the actual Starlink chain and a few other defined satellite trains. I'd link to it but I don't see a way to link directly to a particular satellite.

Wow that's a lot.

Using this I just learned that Beidou's orbit is geosynchronous with a high inclination. That's a lot of delta-V!

Not really. They're launched from a base at 28 deg N. So assuming they launch due east, you can get to a 56 deg inclination and spend less delta-v than you'd need to drop the inclination to zero.

Was expecting social media, al la seveneves, but that is much better. I wonder where the data comes from?

I might be wrong, but I don't think they are data captured in real-time.

Based on a cursory understanding of the AGI STK, these satellite positions are calculated from ephemeris data which are updated on a regular basis (e.g. weekly). https://en.wikipedia.org/wiki/Ephemeris

The ephemeris data is updated approximately daily and also allows you to predict the satellite's position fairly accurately several days in the future. Satellites change orbits very infrequently, so it's close enough to real time for most purposes.

Most of the data is typically in a two-line element format [0]. You can grab it here https://www.space-track.org or here https://celestrak.com/NORAD/elements/

(although I believe the celestrak data comes from space-track, correct me if I'm wrong)

The satellite positions are then estimated using an algorithm such as sgp4 implemented in quite a few languages:

* https://github.com/joshuaferrara/go-satellite (<-- disclaimer: this is mine)

* https://github.com/brandon-rhodes/python-sgp4

* https://github.com/shashwatak/satellite-js

Check out Dr. Kelso's (he works for AGI now) original work here in Pascal, plus a few links to C++ works: https://celestrak.com/software/tskelso-sw.php

[0] https://celestrak.com/columns/v04n03/

so cool

Reply on news.ycombinator.com