Skip to content

Driver interfaces

SkyNode integrates with physical hardware through pluggable driver modules, one per device type. Every driver implements a per-device interface that the rest of SkyNode (the device manager, telescope controller, task executors, manual command executor) talks to without caring which underlying control system is in use.

This page is the conceptual reference for those interfaces and what each driver kind provides. For picking and wiring up drivers on a specific install, see Configuration → device_configs.

For a primer on how observations actually execute against these drivers, see Operations.


Each device type has one interface that declares the contract, plus one or more drivers that implement it. Every driver has an id; each one is offered in the Driver dropdown on that device type’s Settings page, and its id is the value stored in the device config’s driver field.

Driver maturity falls into a few tiers (a classification kept by the Skynet team, not something the app displays):

  • Production — actively maintained, used on live telescopes, the default recommendation.
  • Experimental — works but isn’t a mainline target; functionality may lag, edge cases may not be handled. Talk to the Skynet team before relying on one in production.
  • Simulator — paper-only; for testing configurations without hardware. Not a production option.
Device type Driver (DRIVER_ID) Status
mount/ ascom/ (mount.ascom) Production
mount/ gbtwenty/ (gbtwenty-mount, the Green Bank 20-meter radio telescope’s OCU) Experimental
mount/ simulator/ Simulator
camera/ ascom/ Production
camera/ maxim/ (MaxIm DL) Production
camera/ simulator/ Simulator
filter_wheel/ ascom/ Production
filter_wheel/ maxim/ Production
filter_wheel/ simulator/ Simulator
focuser/ ascom/ Production
focuser/ simulator/ Simulator
enclosure/ ascom/ Production
enclosure/ astrohaven/ (Astrohaven clamshell, serial, with optional DarkSky-Pearl firmware features) Experimental
enclosure/ nmskies_roof/ (New Mexico Skies roll-off roof, read from the site’s status page; status only, SkyNode cannot open or close it) Experimental
enclosure/ simulator/ Simulator
ota/ autoslew/ (Astro Optik AutoSlew mirror cover and fans, Alpaca REST; the cover runs open-loop where AutoSlew gives no readback) Experimental
ota/ ascom_cover_calibrator/ (any ASCOM CoverCalibrator mirror cover, COM) Experimental
ota/ simulator/ (temperatures, mirror cover, fans) Simulator
instrument_rotator/ simulator/ Simulator
weather_sensor/ aag_cloudwatcher/ Experimental
weather_sensor/ aurora_eurotech/ Experimental
weather_sensor/ boltwood_i/ Experimental
weather_sensor/ boltwood_ii/ Experimental
weather_sensor/ cumulus/ Experimental
weather_sensor/ davis_weatherlink/ Experimental
weather_sensor/ green_bank/ (polls the Green Bank Observatory weather page) Experimental
weather_sensor/ skycanary/ (synthetic sensor: radar rain distance, cloud cover, lightning proximity, model-nowcast surface weather) Experimental
weather_sensor/ simulator/ Simulator
receiver/ simulator/ (stands in for the GBTwenty L-band receiver) Simulator
radio_backend/ simulator/ (radio spectrometer backend) Simulator
ip_camera/ amcrest_cgi/ (Amcrest / Dahua CGI: PTZ and IR light) Experimental
ip_camera/ onvif/ (ONVIF: PTZ and IR-cut filter) Experimental

Driver IDs follow <device type>.<driver> (for example camera.maxim, weather_sensor.boltwood_ii), except gbtwenty-mount and the IP camera drivers, whose IDs are amcrest_cgi and onvif. weather_sensor/old_csharp_drivers/ holds C# source from an earlier Skynet generation for reference only; it is not a driver and can’t be selected.

The TL;DR: for optical telescopes, ASCOM is the primary production path; MaxIm is the production alternative for cameras and filter wheels. Everything else (the GBTwenty radio mount, the native enclosure and weather-sensor drivers, the OTA cover drivers, any new hardware family) is experimental right now — workable, but not the well-trodden path. Radio receivers and backends have simulators only.

The per-device wiring pages under Wiring cover what the JSON-config block looks like for each device kind and which drivers each one exposes.


How a task threads through the driver layer

Section titled “How a task threads through the driver layer”

A typical observation lifecycle, top-down:

  1. An observation is submitted through the web app or the API.
  2. The observability service evaluates whether and when the target is reachable from this telescope under current constraints.
  3. The task scheduler generates one or more ObservationTasks with start times.
  4. SkyNode’s task manager fetches eligible tasks for its bound telescope. The telescope controller starts the task manager while automation may dispatch (automation started, control authority remote, no lease, no shutdown interlock) and stops it otherwise.
  5. The target acquisition manager converts the observation’s target into a SkyCoord (scalar for fixed frames, time-series for ephemeral / moving targets) and wraps it in an ephemeris provider.
  6. A task executor specific to the observation type (optical_imaging, optical_imaging_calibration, radio_mapping, radio_tracking) drives the per-device drivers — slewing the mount, opening the enclosure, configuring the filter wheel and camera, taking exposures — and reports results back.

The driver interfaces are designed so the same observation type implementation works against any compliant driver: supporting a new mount means a new mount driver, and the optical imaging executor does not change.


The mount interface is the most surface-area-rich because mounts have to track moving targets, apply pointing corrections, and play scan patterns.

The contract exposes, among others:

  • point(target=…, ephem_provider=…, offset_pattern=None, …) — slew to the target and begin tracking.
  • track(target=…, ephem_provider=…, offset_pattern=None, …) — track the target, continuously updating pointing.
  • park(), unpark(), find_home(), stop() — the standard mount verbs.
  • set_offset_pattern(pattern) — swap the active offset pattern while keeping the same ephemeris provider; used to start, stop, or retarget a raster/daisy scan mid-track.
  • set_fixed_offset(...) — apply a small persistent trim (for a pointing model, instrument offset, autoguider correction).
  • stop_tracking() — disengage the drive.
  • commanded_pointing_altaz(when_utc) — report the composite (target + fixed offset + pattern) pointing at a given time, used for limit checks and telemetry.

For mounts that don’t support offset patterns natively, the simple offset player schedules and plays patterns in software by advancing a playhead in device time and feeding the result through set_fixed_offset.

Inside the driver, the target is a plain astropy.coordinates.SkyCoord — scalar for fixed frames (equatorial, galactic, horizontal), time series for everything else. This is deliberately simpler than the hub’s Target schema (which also captures the position kind: fixed, catalog, ephemeral, orbital, …). The conversion happens in the target acquisition manager.

  • Fixed offsets are constant adjustments — pointing model corrections, instrument centering. They persist until you change them.
  • Offset patterns evolve over time. A pattern evaluates to a longitude/latitude delta given an elapsed time, and is the foundation of raster, daisy, and other mapping scans.

When both are active, they compose: the mount points at target + fixed_offset + pattern_offset(t).

The GBTwenty mount driver drives the Operational Control Unit (OCU) over serial (or a socket:// URL to the OCU simulator), streams position-velocity (PD) commands to keep the PD buffer filled, and applies fixed offsets and the active pattern after transforming coordinates into the mount’s encoder frame.

As secondary safeguards it checks pointing limits and slew feasibility before a track starts, clamps the commanded velocity feed-forward to the configured maximums, and refuses PD points outside the limits. The OCU remains the authoritative limit enforcer.


Enclosure drivers control the shutter (open, close, read its state) and, for a rotating dome, azimuth and rotation. Mirror covers and fans are OTA devices, not part of the enclosure.

Enclosures can be bound at two levels in Configuration:

  • managed_by: "this_node" — SkyNode is the active controller for this enclosure and opens the driver itself.
  • managed_by: "another_node" — SkyNode subscribes to state but does not connect; a sibling or observatory node drives the hardware.
  • managed_by: "no_node" — nothing drives it; SkyNode skips the device.
  • allow_control: true — actively command rotation and shutter from SkyNode (requires managed_by: "this_node").

The split exists because some sites run a single physical enclosure controlled by an observatory node, with telescope nodes only observing its state.


Weather sensors connect over many heterogeneous transports — TCP, file tail, HTTP, vendor COM. Each native driver adapts one of these transports to the common interface, which normalizes readings into the fields SkyNode’s weather-sensor constraints evaluate (cloud temperature delta, wind speed and direction, rain rate, rain distance, lightning distance, surface wetness, humidity, pressure, light level, ambient temperature, where the sensor provides them).

Like enclosures, weather sensors carry managed_by — the node that owns a sensor connects locally; other nodes that need its readings consume them from the local MQTT broker when they share one, otherwise via the hub.


Camera, filter wheel, focuser, OTA, instrument rotator

Section titled “Camera, filter wheel, focuser, OTA, instrument rotator”

These follow the same pattern: an interface declaring the operations the task executors need (start exposure, set filter, move focuser, set rotator angle, get/set cooling, open/close a mirror cover, …) and one or more backend implementations (ASCOM, MaxIm, AutoSlew, simulator).


Receiver and radio backend — simulators only

Section titled “Receiver and radio backend — simulators only”

The receiver and radio backend interfaces have simulator implementations only (a stand-in for the GBTwenty L-band receiver and a simulated spectrometer backend); there are no hardware drivers yet.

The radio task executors (radio tracking and radio mapping) run against these simulators and the GBTwenty mount driver (or its OCU simulator).