Node.js server for VSOP87 planet calculations

[philpownall]

Greg,

First, thank you for your truly excellent code and website - it is truly a testament to your hard work and "astronomical" effort. As an amateur astronomer and engineer of things, I have found your VSOP87 code invaluable. I have found most astronomy websites extremely cumbersome and inscrutable, and I long desired something much more concise and understandable - I just wanted planet positions and rise/set times for an ESP32 project (A Planet Tracker Clock), and I have managed to build my prototype with your code.

As the title suggests, I was wondering if you have considered a fully-capable Node.js server code for your examples: I have built a basic json server using your example .js files - it is only 30 lines of Javascript !

I had to make some relatively cosmetic changes to your standard Javascript files to make them compatible with Node.js (requires and module.exports, and static rather than function declarations). I used CelestialProgrammingReduce_small.js, vsop87a_small.js, and vsop87a_small_velocities for my implementation. And, I modified the alt_az_small.js example to calculate the planet positions at the current time (and rise/fall times, as in your rise and set webpage) and publish it all in a json.

I poll the Node.js server from my Home Assistant server to get the json data into a dashboard, which looks great (see attached).

Finally, I can also get the planetary data into an ESP32 running ESPHome using a http_request (similar to arduino). With a couple of servo motors and a display, I have a Planet Tracker/Clock which can track any of the planets and the Sun/Moon. The LED tracks the planet (Azimuth and Elevation), selected from a built-in web page.

I'll be publishing all of the 3D design files on Tinkercad and the project on Thingiverse, where I will be sure to include an acknowledgement for your work. A standalone Node.js server would be the icing on the cake, and make to project into a complete self-contained amateur observatory.

Thanks and regards,

[gmiller123456]

Looks really cool, and thanks for the feedback. I'm not really sure what you mean by a Node.js server. My plan for this project is to supply a as bare bones as possible implementation, because as you already discovered, it might require slight tweaks for certain platforms. But I do have many other projects that build off of it.

Also, please post some links to your project and 3D files if they're public.

[philpownall]

Once again, many thanks for your extensive code collection, and for publishing it online. My goal is to get the planetary calculations entirely on an ESP32 microcontroller so that I can build standalone things, but running using a REST API hosted on my own network is a pretty good solution for now.

Offering a REST API to your website would be a great addition, and a help to amateur astronomers everywhere - a much easier alternative to JPL Horizons.

A Node.js server runs Javascipt outside of a browser, in this case to provide a REST API delivering data over WiFi. The code for my example is rather embarrassingly small: here is the entire code of app.js:

var express = require('express');
const Alt_az_small = require('./alt_az_small.js');

var app = express ();
app.use(express.json());

const PORT = process.env.PORT || 3000;

const mylat = 44.2307;
const mylong = -76.4813;

app.listen(PORT, () => {
  console.log("Planet Positions Server Listening on PORT:", PORT);
});

app.get("/status", (request, response) => {
   const status = {
      "Status": "Running"
   };
   
   response.send(status);
});

app.get("/planets", (request, response) => {
   const datenow = Date.now();
   const planets = Alt_az_small.GetPlanets(datenow, mylat, mylong);
   
   response.send(planets);
});

To run, you enter "node app.js" at the linux prompt (Node.js must be installed on the host system).

calling the REST API from curl produces the current planet positions like this:

curl http://localhost:3000/planets
{"Planets":"2024-09-19T10:56:09.226Z","Sun":{"RA":"177.24","Dec":"1.19","Alt":"0.23","Az":"88.55","Rise":"06:52:01","Set":"19:10:38"},"Moon":{"RA":"13.48","Dec":"6.21","Alt":"16.55","Az":"262.44","Rise":"19:42:38","Set":"08:29:55"},"Mercury":{"RA":"169.00","Dec":"6.72","Alt":"9.98","Az":"90.31","Rise":"05:58:48","Set":"18:57:54"},"Venus":{"RA":"203.79","Dec":"-9.60","Alt":"-26.19","Az":"77.32","Rise":"09:22:11","Set":"20:12:51"},"Mars":{"RA":"99.33","Dec":"23.43","Alt":"66.66","Az":"148.78","Rise":"00:06:03","Set":"15:33:19"},"Saturn":{"RA":"347.21","Dec":"-7.87","Alt":"-12.06","Az":"270.72","Rise":"18:48:53","Set":"05:53:28"},"Jupiter":{"RA":"79.92","Dec":"22.40","Alt":"67.53","Az":"195.83","Rise":"22:53:39","Set":"14:10:27"},"Uranus":{"RA":"54.90","Dec":"19.26","Alt":"53.79","Az":"236.60","Rise":"21:28:51","Set":"12:15:03"},"Neptune":{"RA":"359.20","Dec":"-1.79","Alt":"0.76","Az":"266.76","Rise":"19:12:58","Set":"07:05:22"}}

I modified your alt_az_small.js to add module exports and call the reduce function like this:

var CPReduce = require('./CelestialProgrammingReduce_small.js');

module.exports = class Alt_az_small {

    static GetPlanets (d, mylat, mylong) {

        // initialize the planets json
        var planets = { "Planets" : "timestamp",
            "Sun": { "RA": 1.0, "Dec": 2.0, "Alt": 60.0, "Az": 300.0, "Rise": "06:44:40", "Set": "19:14:39" },
            "Moon": { "RA": 1.0, "Dec": 2.0, "Alt": 60.0, "Az": 300.0, "Rise": "06:44:40", "Set": "19:14:39" },
            "Mercury": { "RA": 1.0, "Dec": 2.0, "Alt": 60.0, "Az": 300.0, "Rise": "06:44:40", "Set": "19:14:39" },
            "Venus": { "RA": 1.0, "Dec": 2.0, "Alt": 60.0, "Az": 300.0, "Rise": "06:44:40", "Set": "19:14:39" },
            "Mars": {"RA": 1.0, "Dec": 2.0, "Alt": 60.0, "Az": 300.0, "Rise": "06:44:40", "Set": "19:14:39" },
            "Saturn": {"RA": 1.0, "Dec": 2.0, "Alt": 60.0, "Az": 300.0, "Rise": "06:44:40", "Set": "19:14:39" },
            "Jupiter": {"RA": 1.0, "Dec": 2.0, "Alt": 60.0, "Az": 300.0, "Rise": "06:44:40", "Set": "19:14:39" },
            "Uranus": {"RA": 1.0, "Dec": 2.0, "Alt": 60.0, "Az": 300.0, "Rise": "06:44:40", "Set": "19:14:39" },
            "Neptune": {"RA": 1.0, "Dec": 2.0, "Alt": 60.0, "Az": 300.0, "Rise": "06:44:40", "Set": "19:14:39" }
        };
        planets.Planets = new Date(d);

        const jd = this.JulianDateFromUnixTime(d);

        // compute Sun position for my location, now UTC
    	planets.Sun = this.computePosition(10, mylat, mylong, jd);

The computePosition function called above is an edit of your testPosition function to populate the json:

    static computePosition(body, lat, lon, jd){

    	const b=this.jplBodyToInt(body);

    	const deltaT=(CPReduce.convertUTCtoTT(jd)-jd)*60*60*24;

    	//All angles passed to CPReduce need to be in radians!!!!!
    	const observer=[lat*Math.PI/180, lon*Math.PI/180, 0];

    	//---------------------------------------------------------------------------------------------------------
    	//This is the main call that gets the position of a planet from the CPReduce library.
    	//Get the RA/Dec and Alt/Az.
    	const positions=CPReduce.reduce(b,jd,observer);
    	//---------------------------------------------------------------------------------------------------------

        const ra = positions[2];
        const dec = positions[3];
 
        const riseset = this.getRiseSet(body,jd,lat*Math.PI/180,-lon*Math.PI/180,ra,dec);

        var planetjson = {
            "RA": (positions[2] * 180.0/Math.PI).toFixed(2),
            "Dec": (positions[3] * 180.0/Math.PI).toFixed(2),
            "Alt": (positions[5] * 180.0/Math.PI).toFixed(2),
            "Az": (positions[4] * 180.0/Math.PI).toFixed(2),
            "Rise": this.formatTime(riseset[1]),
            "Set": this.formatTime(riseset[2])
        }

        return planetjson;

    }

Once the Node.js server is running, I can call it from my Home Assistant server or from an ESP32 microcontroller (as shown above).

I have not released the Planets Clock on TinkerCAD/Github yet, my Moon Clock is at
Moon Clock

• it uses the IPGeolocation Astronomy REST API rather than this one, but the interface is also a REST API.

Here is a photo of the prototype build of the Planet Clock. My Grandkids already love pushing the button to show the next planet. I'll be posting it on Github/TinkerCAD shortly, if you are OK with a reference to your website.

Planet Clock

[gmiller123456]

Ah. I wouldn't want to get in to running a service, not so much because it's tough to do, but because if it got popular it'd start costing significant money, and I don't care to get in to that side of things. I'm sure if you search around there already are some sites that provide that.

But the code should be able to run directly on the ESP32, and eliminate the need for a service. Depending on the language you're using, there is an Arduino folder that has the .ino files for testing the C versions directly. I was able to get the vsop87a_small working on an esp8266. If you're using Micropython or Lua, you should be able to use the Python or Lua code directly.

Another option is to use the less accurate ephemeris from the Explanator Supplement to the Astronomical Almanac: https://www.celestialprogramming.com/planets_with_keplers_equation.html

It's accurate generally to an arcminute, and is small enough to run even on an Arduino. But it doesn't have the Moon.

[philpownall]

I totally understand about the cost part - when a user runs the Javascript code on your webpage, he is paying for the computing. I will continue to pursue getting the code to work on an ESP32 - it is running ESPHome (a yaml precompiler to C++), which adds quite a bit of overhead to the (Arduino) libraries, but greatly simplifies the concurrent programming of servos, displays, and an embedded web page. I believe I can make the Javascript/C++ versions of your functions look like a (pretty big) custom component, which would also make it available to all users of the Home Assistant Home Automation server. I'll let you know how I do.

Thanks again for the help. Regards,