main: handle various forms of process termination more safely

This attempts to solve the problem where, if the rotator is actively
rotating and the program is killed, the LabJack will not be reset and
the rotator will keep running. We install various signal handlers to
try to catch common cases (ctrl+c, terminal getting closed out from
under us). There are still ways to end the process that leave the
LabJack running (such as if it crashes, though there are currently no
known crashes), but I don't think it's possible to completely avoid
that.

The posix signal handling story is a bit ugly. Trying to do pretty much
anything in the asynchronous signal handlers will cause undefined
behavior. Acquiring a mutex and joining a thread are right at the top
of the very long list of things that you cannot do safely in an async
signal handler. One potential solution to this problem is to replace
locks with atomics, which isn't appropriate for our use case (we have
to make sure the controller thread actually has shut down the LabJack
before exiting the process). The other well-known solution is to
manually create a thread that listens for signals synchronously, and
this is the approach taken here.

After having done this, I had the thought that because we are linking
libc anyway, an `atexit` handler might work, but I don't actually know
if it would, and I don't think it's worthwhile to do the work at this
point.

build.zig

@@ -4,12 +4,24 @@ pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const use_udev = b.option(
+    const libusb_use_udev = b.option(
         bool,
         "use_udev",
         "link and use udev (Linux only. Default: false)",
     ) orelse false;
 
+    const libusb_enable_logging = b.option(
+        bool,
+        "libusb_enable_logging",
+        "enable libusb's built-in logging (Default: false)",
+    ) orelse false;
+
+    const libusb_enable_debug_logging = b.option(
+        bool,
+        "libusb_enable_debug_logging",
+        "enable libusb's debug logging (Default: false)",
+    ) orelse false;
+
     const exe = b.addExecutable(.{
         .name = "yaes",
         .root_source_file = b.path("src/main.zig"),
@@ -38,7 +50,13 @@ pub fn build(b: *std.Build) void {
     } else {
         const ljacklm_dep = b.dependency(
             "ljacklm",
-            .{ .target = target, .optimize = optimize, .use_udev = use_udev },
+            .{
+                .target = target,
+                .optimize = optimize,
+                .libusb_use_udev = libusb_use_udev,
+                .libusb_enable_logging = libusb_enable_logging,
+                .libusb_enable_debug_logging = libusb_enable_debug_logging,
+            },
         );
         exe.linkLibrary(ljacklm_dep.artifact("ljacklm"));
     }

deps/labjack/exodriver/build.zig

@@ -4,10 +4,22 @@ pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const use_udev = b.option(
+    const libusb_use_udev = b.option(
         bool,
-        "use_udev",
-        "link and use udev (Linux only. Default: false)",
+        "libusb_use_udev",
+        "libusb: link and use udev (Linux only. Default: false)",
+    ) orelse false;
+
+    const libusb_enable_logging = b.option(
+        bool,
+        "libusb_enable_logging",
+        "enable libusb's built-in logging (Default: false)",
+    ) orelse false;
+
+    const libusb_enable_debug_logging = b.option(
+        bool,
+        "libusb_enable_debug_logging",
+        "enable libusb's debug logging (Default: false)",
     ) orelse false;
 
     const liblabjackusb = b.addStaticLibrary(.{
@@ -31,7 +43,13 @@ pub fn build(b: *std.Build) !void {
 
     const usb_dep = b.dependency(
         "usb",
-        .{ .target = target, .optimize = optimize, .use_udev = use_udev },
+        .{
+            .target = target,
+            .optimize = optimize,
+            .use_udev = libusb_use_udev,
+            .enable_logging = libusb_enable_logging,
+            .enable_debug_logging = libusb_enable_debug_logging,
+        },
     );
     liblabjackusb.linkLibrary(usb_dep.artifact("usb"));
 

deps/labjack/ljacklm/build.zig

@@ -4,10 +4,22 @@ pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    const use_udev = b.option(
+    const libusb_use_udev = b.option(
         bool,
-        "use_udev",
-        "link and use udev (Linux only. Default: false)",
+        "libusb_use_udev",
+        "libusb: link and use udev (Linux only. Default: false)",
+    ) orelse false;
+
+    const libusb_enable_logging = b.option(
+        bool,
+        "libusb_enable_logging",
+        "enable libusb's built-in logging (Default: false)",
+    ) orelse false;
+
+    const libusb_enable_debug_logging = b.option(
+        bool,
+        "libusb_enable_debug_logging",
+        "enable libusb's debug logging (Default: false)",
     ) orelse false;
 
     const libljacklm = b.addStaticLibrary(.{
@@ -30,7 +42,13 @@ pub fn build(b: *std.Build) !void {
 
     const usb_dep = b.dependency(
         "labjackusb",
-        .{ .target = target, .optimize = optimize, .use_udev = use_udev },
+        .{
+            .target = target,
+            .optimize = optimize,
+            .libusb_use_udev = libusb_use_udev,
+            .libusb_enable_logging = libusb_enable_logging,
+            .libusb_enable_debug_logging = libusb_enable_debug_logging,
+        },
     );
     libljacklm.linkLibrary(usb_dep.artifact("labjackusb"));
 

deps/libusb/build.zig

@@ -10,6 +10,18 @@ pub fn build(b: *std.Build) !void {
         "link and use udev (Linux only. Default: false)",
     ) orelse false;
 
+    const enable_logging = b.option(
+        bool,
+        "enable_logging",
+        "enable libusb's built-in logging (Default: false)",
+    ) orelse false;
+
+    const enable_debug_logging = b.option(
+        bool,
+        "enable_debug_logging",
+        "enable libusb's debug logging (Default: false)",
+    ) orelse false;
+
     const libusb = b.addStaticLibrary(.{
         .name = "usb",
         .target = target,
@@ -59,8 +71,8 @@ pub fn build(b: *std.Build) !void {
         .{ .style = .{ .autoconf = b.path("config.h.in") } },
         .{
             .DEFAULT_VISIBILITY = .@"__attribute__ ((visibility (\"default\")))",
-            .ENABLE_DEBUG_LOGGING = oneOrNull(optimize == .Debug),
-            .ENABLE_LOGGING = oneOrNull(optimize == .Debug),
+            .ENABLE_DEBUG_LOGGING = oneOrNull(enable_debug_logging),
+            .ENABLE_LOGGING = oneOrNull(enable_logging),
             .HAVE_ASM_TYPES_H = null,
             .HAVE_CLOCK_GETTIME = oneOrNull(linux_target),
             .HAVE_DECL_EFD_CLOEXEC = oneOrNull(linux_target),

readme.md

@@ -24,7 +24,7 @@ Unfortunately, all platforms have additional steps that must be taken (some easi
 
 #### Windows
 
-This compiles for, and runs on, Windows. However, the Labjack U12 by default gets assigned the Windows USB HID driver, which causes the USB report descriptor control transfer read to get mangled for mystery reasons that presumably made sense to some egghead at Microsoft at some point in time. Fortunately, this can be relatively easily fixed by using a tool like [zadig] to set the Labjack U12 to use the WinUSB driver instead of the HID driver. This is not an endorsement of the above outlined process, but rather an explanation for persons either foolish or desperate.
+This compiles for, and runs on, Windows. However, in order for it to work out of the box, it has to link against the (proprietary) Windows LabJack U12 driver instead of the open source libUSB driver. This has two main limitations: the Windows driver is only available for the `x86` and `x86-64` architectures, and it is exclusively distributed as a dynamic library, meaning that `yaes.exe` must be distributed alongside `ljackuw.dll`. When building for Windows targets, the appropriate library file will be copied to the binary installation directory (`zig-out/bin` by default).
 
 #### macOS
 
@@ -33,5 +33,3 @@ This works on macOS, though it has to be run with `sudo`, as access to the USB h
 #### Linux
 
 You probably need to install the included udev rules file in order for the USB device to be accessible as a user. This is buried in the source tree as `deps/labjack/exodriver/90-labjack.rules`. These should probably go in `/etc/udev/rules.d` if you are installing them manually and I have properly understood the various Linux folder conventions.
-
-[zadig]: https://zadig.akeo.ie

src/Config.zig

@@ -5,31 +5,37 @@ const lj = @import("./labjack.zig");
 
 const Config = @This();
 
-var global_internal: Config = undefined;
-pub const global: *const Config = &global_internal;
+var global_internal: std.json.Parsed(Config) = undefined;
+pub const global: *const Config = &global_internal.value;
 
 pub fn load(allocator: std.mem.Allocator, reader: anytype, err_writer: anytype) !void {
     var jread = std.json.Reader(1024, @TypeOf(reader)).init(allocator, reader);
     defer jread.deinit();
 
-    global_internal = try std.json.parseFromTokenSourceLeaky(
+    global_internal = try std.json.parseFromTokenSource(
         Config,
         allocator,
         &jread,
         .{},
     );
 
-    try global_internal.validate(err_writer);
+    try global.validate(err_writer);
 }
 
 pub fn loadDefault(allocator: std.mem.Allocator) void {
-    _ = allocator;
-    global_internal = .{};
+    const arena = allocator.create(std.heap.ArenaAllocator) catch unreachable;
+    arena.* = std.heap.ArenaAllocator.init(allocator);
+    global_internal = .{
+        .arena = arena,
+        .value = .{},
+    };
 }
 
-pub fn destroy(allocator: std.mem.Allocator) void {
+pub fn deinit() void {
     // TODO: implement this probably
-    _ = allocator;
+    const allocator = global_internal.arena.child_allocator;
+    global_internal.arena.deinit();
+    allocator.destroy(global_internal.arena);
 }
 
 pub fn validate(self: Config, err_writer: anytype) !void {
@@ -86,6 +92,7 @@ pub fn validate(self: Config, err_writer: anytype) !void {
 rotctl: RotControlConfig = .{
     .listen_address = "127.0.0.1",
     .listen_port = 4533,
+    .autopark = false,
 },
 labjack: LabjackConfig = .{
     .device = .autodetect,
@@ -121,6 +128,7 @@ controller: ControllerConfig = .{
     // this is a symmetric mask, so the minimum usable elevation is elevation_mask deg
     // and the maximum usable elevation is 180 - elevation_mask deg
     .elevation_mask = 0.0,
+    .feedback_window_samples = 3,
 },
 
 pub const VoltAngle = struct { voltage: f64, angle: f64 };
@@ -144,6 +152,7 @@ pub const MinMax = struct {
 const RotControlConfig = struct {
     listen_address: []const u8,
     listen_port: u16,
+    autopark: bool,
 };
 
 const LabjackConfig = struct {
@@ -173,6 +182,8 @@ const ControllerConfig = struct {
     angle_offset: AzEl,
     elevation_mask: f64,
 
+    feedback_window_samples: u8,
+
     const OutPair = struct {
         increase: lj.DigitalOutputChannel,
         decrease: lj.DigitalOutputChannel,

src/RotCtl.zig

@@ -10,12 +10,9 @@ const log = std.log.scoped(.RotCtl);
 
 writer: std.io.BufferedWriter(512, std.net.Stream.Writer),
 running: bool,
-rotator: YaesuController,
+rotator: *YaesuController,
 
 pub fn run(allocator: std.mem.Allocator) !void {
-    // var server = std.net.StreamServer.init(.{ .reuse_address = true });
-    // defer server.deinit();
-
     const listen_addr = try std.net.Address.parseIp(
         config.rotctl.listen_address,
         config.rotctl.listen_port,
@@ -30,20 +27,19 @@ pub fn run(allocator: std.mem.Allocator) !void {
     var interface: RotCtl = .{
         .writer = undefined,
         .running = true,
-        .rotator = try YaesuController.init(allocator),
+        .rotator = try YaesuController.create(allocator),
     };
 
-    while (true) {
+    while (interface.running) {
         const client = try server.accept();
         defer {
             log.info("disconnecting client", .{});
-            interface.rotator.stop();
+            if (!config.rotctl.autopark)
+                interface.rotator.stop();
             client.stream.close();
         }
 
         interface.writer = .{ .unbuffered_writer = client.stream.writer() };
-        interface.running = true;
-        defer interface.running = false;
 
         log.info("client connected from {}", .{client.address});
 
@@ -60,7 +56,13 @@ pub fn run(allocator: std.mem.Allocator) !void {
                 std.mem.trim(u8, fbs.getWritten(), &std.ascii.whitespace),
             ) catch break;
         }
+
+        // loop ended due to client disconnect
+        if (interface.running and config.rotctl.autopark)
+            interface.rotator.startPark();
     }
+
+    interface.rotator.control_thread.join();
 }
 
 fn write(self: *RotCtl, buf: []const u8) !void {
@@ -172,7 +174,6 @@ fn handleHamlibCommand(
     if (first.len == 1 or first[0] == '\\') {
         switch (first[0]) {
             // NOTE: this is not technically supported by rotctld.
-            'q', 'Q' => try self.quit(first, &tokens),
             'S' => try self.stop(first, &tokens),
             'K' => try self.park(first, &tokens),
             'p' => try self.getPosition(first, &tokens),
@@ -243,8 +244,8 @@ const HamlibCommand = struct {
 };
 
 const rotctl_commands = [_]HamlibCommand{
-    .{ .short = 'q', .callback = quit }, // quit
-    .{ .short = 'Q', .callback = quit }, // quit
+    .{ .long = "quit", .callback = quit },
+    .{ .long = "exit", .callback = quit },
     .{ .long = "AOS", .callback = blindAck },
     .{ .long = "LOS", .callback = blindAck },
     .{ .short = 'P', .long = "set_pos", .callback = setPosition }, // azimuth: f64, elevation: f64

src/YaesuController.zig

@@ -8,6 +8,8 @@ const log = std.log.scoped(.yaesu_controller);
 
 const YaesuController = @This();
 
+pub var singleton: ?*YaesuController = null;
+
 control_thread: std.Thread,
 lock: *std.Thread.Mutex,
 controller: *const Controller,
@@ -17,22 +19,47 @@ pub const AzEl = struct {
     elevation: f64,
 };
 
-pub fn init(allocator: std.mem.Allocator) !YaesuController {
-    const lock = try allocator.create(std.Thread.Mutex);
-    errdefer allocator.destroy(lock);
-    lock.* = .{};
+pub const CalibrationRoutine = enum {
+    feedback,
+    orientation,
+};
+
+pub fn calibrate(allocator: std.mem.Allocator, routine: CalibrationRoutine) !void {
+    const controller = try YaesuController.create(allocator);
+    defer {
+        controller.quit();
+        controller.control_thread.join();
+    }
+
+    switch (routine) {
+        .feedback => try controller.calibrate_feedback(),
+        .orientation => try controller.calibrate_orientation(),
+    }
+}
+
+pub fn create(allocator: std.mem.Allocator) !*YaesuController {
+    if (singleton) |_| {
+        log.err("Controller singleton already exists.", .{});
+        return error.AlreadyInitialized;
+    }
 
     const controller = try allocator.create(Controller);
     errdefer allocator.destroy(controller);
-    controller.init(lock);
+    controller.* = try Controller.init(allocator);
+    errdefer controller.deinit(allocator);
     // do this in the main thread so we can throw the error about it synchronously.
     try controller.connectLabjack();
 
-    return .{
+    const self = try allocator.create(YaesuController);
+    errdefer allocator.destroy(self);
+    self.* = .{
         .control_thread = try std.Thread.spawn(.{}, runController, .{controller}),
-        .lock = lock,
+        .lock = &controller.lock,
         .controller = controller,
     };
+
+    singleton = self;
+    return self;
 }
 
 fn inRange(request: f64, comptime dof: enum { azimuth, elevation }) bool {
@@ -73,7 +100,7 @@ pub fn setTarget(self: YaesuController, target: AzEl) error{OutOfRange}!void {
 
     const controller = @constCast(self.controller);
     controller.target = masked_target;
-    controller.requested_state = .running;
+    controller.requestState(.running);
 }
 
 pub fn currentPosition(self: YaesuController) AzEl {
@@ -83,16 +110,15 @@ pub fn currentPosition(self: YaesuController) AzEl {
     return self.controller.position;
 }
 
-pub fn startCalibration(self: YaesuController) void {
-    // there are two different types of calibration:
-    // 1. feedback calibration, running to the extents of the rotator
-    // 2. sun calibration, which determines the azimuth and elevation angle
-    //    offset between the rotator's physical stops and geodetic north
-    //
-    // The former is (fairly) trivial to automate, just run until stall
-    // (assuming there's no deadband in the feedback). The latter requires
-    // manual input as the human is the feedback hardware in the loop.
-    _ = self;
+pub fn waitForUpdate(self: YaesuController) AzEl {
+    const controller = @constCast(self.controller);
+
+    self.lock.lock();
+    defer self.lock.unlock();
+
+    controller.condition.wait(self.lock);
+
+    return controller.position;
 }
 
 pub fn quit(self: YaesuController) void {
@@ -100,7 +126,7 @@ pub fn quit(self: YaesuController) void {
     defer self.lock.unlock();
 
     const controller = @constCast(self.controller);
-    controller.requested_state = .stopped;
+    controller.requestState(.stopped);
 }
 
 pub fn stop(self: YaesuController) void {
@@ -109,13 +135,25 @@ pub fn stop(self: YaesuController) void {
 
     const controller = @constCast(self.controller);
     controller.target = controller.position;
-    controller.requested_state = .idle;
+    controller.requestState(.idle);
 }
 
 pub fn startPark(self: YaesuController) void {
     self.setTarget(config.controller.parking_posture) catch unreachable;
 }
 
+fn calibrate_feedback(self: YaesuController) !void {
+    _ = self;
+    log.err("this isn't implemented yet, sorry.", .{});
+    return error.NotImplemented;
+}
+
+fn calibrate_orientation(self: YaesuController) !void {
+    _ = self;
+    log.err("this isn't implemented yet, sorry.", .{});
+    return error.NotImplemented;
+}
+
 fn runController(controller: *Controller) void {
     controller.run() catch {
         log.err(
@@ -125,16 +163,77 @@ fn runController(controller: *Controller) void {
     };
 }
 
+const FeedbackBuffer = struct {
+    samples: []f64,
+    index: usize = 0,
+
+    fn initZero(allocator: std.mem.Allocator, samples: usize) !FeedbackBuffer {
+        const buf = try allocator.alloc(f64, samples * 2);
+        @memset(buf, 0);
+        return .{ .samples = buf };
+    }
+
+    fn deinit(self: FeedbackBuffer, allocator: std.mem.Allocator) void {
+        allocator.free(self.samples);
+    }
+
+    fn push(self: *FeedbackBuffer, sample: [2]lj.AnalogReadResult) void {
+        const halfpoint = @divExact(self.samples.len, 2);
+        defer self.index = (self.index + 1) % halfpoint;
+
+        self.samples[self.index] = sample[0].voltage;
+        self.samples[self.index + halfpoint] = sample[1].voltage;
+    }
+
+    inline fn mean(data: []f64) f64 {
+        var accum: f64 = 0;
+        for (data) |pt| {
+            accum += pt;
+        }
+        return accum / @as(f64, @floatFromInt(data.len));
+    }
+
+    fn lerp(input: f64, cal_points: Config.MinMax) f64 {
+        return (input - cal_points.minimum.voltage) * cal_points.slope() + cal_points.minimum.angle;
+    }
+
+    fn get(self: FeedbackBuffer) AzEl {
+        const halfpoint = @divExact(self.samples.len, 2);
+
+        return .{
+            .azimuth = lerp(
+                mean(self.samples[0..halfpoint]),
+                config.labjack.feedback_calibration.azimuth,
+            ) + config.controller.angle_offset.azimuth,
+            .elevation = lerp(
+                mean(self.samples[halfpoint..]),
+                config.labjack.feedback_calibration.elevation,
+            ) + config.controller.angle_offset.elevation,
+        };
+    }
+
+    fn getRaw(self: FeedbackBuffer) AzEl {
+        const halfpoint = @divExact(self.samples.len, 2);
+        return .{
+            .azimuth = mean(self.samples[0..halfpoint]),
+            .elevation = mean(self.samples[halfpoint..]),
+        };
+    }
+};
+
 const Controller = struct {
     target: AzEl,
     position: AzEl,
+    feedback_buffer: FeedbackBuffer,
 
     current_state: ControllerState,
     requested_state: ControllerState,
 
-    lock: *std.Thread.Mutex,
     labjack: lj.Labjack,
 
+    lock: std.Thread.Mutex = .{},
+    condition: std.Thread.Condition = .{},
+
     const ControllerState = enum {
         initializing,
         idle,
@@ -143,13 +242,13 @@ const Controller = struct {
         stopped,
     };
 
-    fn init(self: *Controller, lock: *std.Thread.Mutex) void {
-        self.* = .{
+    fn init(allocator: std.mem.Allocator) !Controller {
+        return .{
             .target = .{ .azimuth = 0, .elevation = 0 },
             .position = .{ .azimuth = 0, .elevation = 0 },
+            .feedback_buffer = try FeedbackBuffer.initZero(allocator, config.controller.feedback_window_samples),
             .current_state = .stopped,
             .requested_state = .idle,
-            .lock = lock,
             .labjack = switch (config.labjack.device) {
                 .autodetect => lj.Labjack.autodetect(),
                 .serial_number => |sn| lj.Labjack.with_serial_number(sn),
@@ -157,12 +256,28 @@ const Controller = struct {
         };
     }
 
+    fn deinit(self: Controller, allocator: std.mem.Allocator) void {
+        self.feedback_buffer.deinit(allocator);
+    }
+
     fn connectLabjack(self: *Controller) !void {
         const info = try self.labjack.connect();
         try self.labjack.setAllDigitalOutputLow();
         self.labjack.id = info.local_id;
     }
 
+    // this function is run with the lock already acquired
+    fn propagateState(self: *Controller) void {
+        if (self.current_state == .stopped) return;
+        self.current_state = self.requested_state;
+    }
+
+    // this function is run with the lock already acquired
+    fn requestState(self: *Controller, request: ControllerState) void {
+        if (self.current_state == .stopped) return;
+        self.requested_state = request;
+    }
+
     fn lerpOne(input: f64, cal_points: Config.MinMax) f64 {
         return (input - cal_points.minimum.voltage) * cal_points.slope() + cal_points.minimum.angle;
     }
@@ -180,7 +295,21 @@ const Controller = struct {
         };
     }
 
-    fn signDeadzone(offset: f64, deadzone: f64) enum { negative, zero, positive } {
+    const Sign = enum {
+        negative,
+        zero,
+        positive,
+
+        pub fn symbol(self: Sign) u21 {
+            return switch (self) {
+                .negative => '-',
+                .zero => '×',
+                .positive => '+',
+            };
+        }
+    };
+
+    fn signDeadzone(offset: f64, deadzone: f64) Sign {
         return if (@abs(offset) < deadzone)
             .zero
         else if (offset < 0)
@@ -189,26 +318,23 @@ const Controller = struct {
             .positive;
     }
 
-    fn updateAzEl(self: *const Controller) !AzEl {
-        const inputs = .{ config.controller.azimuth_input, config.controller.elevation_input };
+    fn updateFeedback(self: *Controller) !void {
+        const inputs = .{
+            config.controller.azimuth_input,
+            config.controller.elevation_input,
+        };
 
         const raw = try self.labjack.readAnalogWriteDigital(
             2,
             inputs,
-            .{false} ** 4,
+            null,
             true,
         );
 
-        return lerpAndOffsetAngles(raw);
+        self.feedback_buffer.push(raw);
     }
 
-    fn drive(self: *const Controller, pos_error: AzEl) !AzEl {
-        // NOTE: feedback will be roughly config.controller.loop_interval_ns out of
-        //       date. For high loop rates, this shouldn't be an issue.
-
-        const inputs = .{ config.controller.azimuth_input, config.controller.elevation_input };
-        var drive_signal: [4]bool = .{false} ** 4;
-
+    fn drive(self: *const Controller, pos_error: AzEl) !void {
         const azsign = signDeadzone(
             pos_error.azimuth,
             config.controller.angle_tolerance.azimuth,
@@ -219,95 +345,111 @@ const Controller = struct {
             config.controller.angle_tolerance.elevation,
         );
 
+        var drive_signal: [4]bool = .{false} ** 4;
         drive_signal[config.controller.azimuth_outputs.increase.io] = azsign == .positive;
         drive_signal[config.controller.azimuth_outputs.decrease.io] = azsign == .negative;
         drive_signal[config.controller.elevation_outputs.increase.io] = elsign == .positive;
         drive_signal[config.controller.elevation_outputs.decrease.io] = elsign == .negative;
 
-        log.info("drive: az = {s}, el = {s}. outputs: {any}", .{ @tagName(azsign), @tagName(elsign), drive_signal });
+        const raw = self.feedback_buffer.getRaw();
 
-        const raw = try self.labjack.readAnalogWriteDigital(2, inputs, drive_signal, true);
+        log.info(
+            // -180.1 is 6 chars. -5.20 is 5 chars
+            "az: {d: >6.1}° ({d: >5.2} V) Δ {d: >6.1}° => {u}, el: {d: >6.1}° ({d: >5.2} V) Δ {d: >6.1}° => {u}",
+            .{
+                self.position.azimuth,
+                raw.azimuth,
+                pos_error.azimuth,
+                azsign.symbol(),
+                self.position.elevation,
+                raw.elevation,
+                pos_error.elevation,
+                elsign.symbol(),
+            },
+        );
 
-        return lerpAndOffsetAngles(raw);
+        try self.labjack.writeIoLines(drive_signal);
+    }
+
+    fn setPosition(self: *Controller, position: AzEl) void {
+        self.position = position;
+        self.condition.broadcast();
     }
 
     fn run(self: *Controller) !void {
         self.current_state = .initializing;
 
-        var timer: LoopTimer = .{ .interval_ns = config.controller.loop_interval_ns };
+        var timer = LoopTimer.init(config.controller.loop_interval_ns);
 
-        while (timer.mark()) : (timer.sleep()) switch (self.current_state) {
-            .initializing, .idle => {
-                const pos = self.updateAzEl() catch {
-                    self.lock.lock();
-                    defer self.lock.unlock();
-
-                    self.current_state = .stopped;
-                    continue;
-                };
+        while (timer.mark()) : (timer.sleep()) {
+            const fbfail = if (self.updateFeedback()) |_| false else |_| true;
 
+            {
                 self.lock.lock();
                 defer self.lock.unlock();
 
-                self.position = pos;
-                self.current_state = self.requested_state;
-            },
-            .calibration => {
-                self.lock.lock();
-                defer self.lock.unlock();
+                self.setPosition(self.feedback_buffer.get());
+                if (fbfail) self.requestState(.stopped);
+                self.propagateState();
+            }
 
-                // run calibration routine. psych, this does nothing. gottem
-                self.current_state = .idle;
-                self.requested_state = self.current_state;
-            },
-            .running => {
-                const pos_error: AzEl = blk: {
+            switch (self.current_state) {
+                .initializing, .idle => {},
+                .calibration => {
                     self.lock.lock();
                     defer self.lock.unlock();
 
-                    break :blk .{
-                        .azimuth = self.target.azimuth - self.position.azimuth,
-                        .elevation = self.target.elevation - self.position.elevation,
+                    // run calibration routine. psych, this does nothing. gottem
+                    self.current_state = .idle;
+                    self.requestState(.idle);
+                },
+                .running => {
+                    const pos_error: AzEl = blk: {
+                        self.lock.lock();
+                        defer self.lock.unlock();
+
+                        break :blk .{
+                            .azimuth = self.target.azimuth - self.position.azimuth,
+                            .elevation = self.target.elevation - self.position.elevation,
+                        };
                     };
-                };
 
-                const pos = self.drive(pos_error) catch {
-                    self.lock.lock();
-                    defer self.lock.unlock();
+                    self.drive(pos_error) catch {
+                        self.lock.lock();
+                        defer self.lock.unlock();
 
-                    self.current_state = .stopped;
-                    continue;
-                };
-
-                self.lock.lock();
-                defer self.lock.unlock();
-
-                self.position = pos;
-                self.current_state = self.requested_state;
-            },
-            .stopped => {
-                // attempt to reset the drive outputs
-                _ = self.updateAzEl() catch {};
-                break;
-            },
-        };
+                        self.current_state = .stopped;
+                        continue;
+                    };
+                },
+                .stopped => {
+                    // attempt to reset the drive outputs
+                    try self.labjack.writeIoLines(.{false} ** 4);
+                    break;
+                },
+            }
+        }
     }
 };
 
 pub const LoopTimer = struct {
     interval_ns: u64,
+    timer: std.time.Timer,
 
-    start: i128 = 0,
+    pub fn init(interval_ns: u64) LoopTimer {
+        return .{
+            .interval_ns = interval_ns,
+            .timer = std.time.Timer.start() catch @panic("Could not create timer"),
+        };
+    }
 
     pub fn mark(self: *LoopTimer) bool {
-        self.start = std.time.nanoTimestamp();
+        self.timer.reset();
         return true;
     }
 
     pub fn sleep(self: *LoopTimer) void {
-        const now = std.time.nanoTimestamp();
-        const elapsed: u64 = @intCast(now - self.start);
-
-        std.time.sleep(self.interval_ns - elapsed);
+        const elapsed = self.timer.read();
+        std.time.sleep(self.interval_ns -| elapsed);
     }
 };

src/labjack.zig

@@ -68,6 +68,30 @@ pub const Labjack = struct {
             return status.toError();
     }
 
+    pub fn writeIoLines(self: Labjack, out: [4]bool) LabjackError!void {
+        var id = self.cId();
+
+        var d_modes: c_long = 0xFF_FF;
+        var d_outputs: c_long = 0;
+        var d_states: c_long = 0;
+        const io_modes: c_long = 0b1111;
+        var io_outputs: c_long = PackedOutput.fromBoolArray(out).toCLong();
+
+        const status = c_api.DigitalIO(
+            &id,
+            self.demo(),
+            &d_modes,
+            io_modes,
+            &d_outputs,
+            &io_outputs,
+            1, // actually update the pin modes
+            &d_states,
+        );
+
+        if (!status.okay())
+            return status.toError();
+    }
+
     /// Read one analog input channel, either single-ended or differential
     pub fn analogReadOne(self: Labjack, input: AnalogInput) LabjackError!AnalogReadResult {
         if (!input.channel.isDifferential() and input.gain_index != 0) {

src/main.zig

@@ -1,18 +1,81 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
 const Config = @import("./Config.zig");
 const lj = @import("./labjack.zig");
 const RotCtl = @import("./RotCtl.zig");
+const YaesuController = @import("./YaesuController.zig");
 
 const udev = @import("udev_rules");
 
 const log = std.log.scoped(.main);
 
+fn quit() noreturn {
+    if (YaesuController.singleton) |controller| {
+        controller.quit();
+        controller.control_thread.join();
+    }
+    std.process.exit(1);
+}
+
+const moreposix = struct {
+    pub extern "c" fn sigaddset(set: *std.posix.sigset_t, signo: c_int) c_int;
+    pub extern "c" fn sigdelset(set: *std.posix.sigset_t, signo: c_int) c_int;
+    pub extern "c" fn sigemptyset(set: *std.posix.sigset_t) c_int;
+    pub extern "c" fn sigfillset(set: *std.posix.sigset_t) c_int;
+    pub extern "c" fn sigismember(set: *const std.posix.sigset_t, signo: c_int) c_int;
+    // stdlib prototype is wrong, it doesn't take optional pointers.
+    pub extern "c" fn pthread_sigmask(how: c_int, noalias set: ?*const std.posix.sigset_t, noalias oldset: ?*std.posix.sigset_t) c_int;
+};
+
+const psigs = [_]c_int{ std.posix.SIG.INT, std.posix.SIG.HUP, std.posix.SIG.QUIT };
+
+fn posixSignalHandlerThread() void {
+    var set: std.posix.sigset_t = undefined;
+    _ = moreposix.sigemptyset(&set);
+    for (psigs) |sig|
+        _ = moreposix.sigaddset(&set, sig);
+
+    var sig: c_int = 0;
+    _ = std.posix.system.sigwait(&set, &sig);
+    log.info("Got exit signal", .{});
+    quit();
+}
+
+// Windows runs this handler in a thread, so calling quit directly should be safe.
+fn windowsEventHandler(code: std.os.windows.DWORD) callconv(std.os.windows.WINAPI) std.os.windows.BOOL {
+    _ = code;
+    log.info("Got exit signal", .{});
+    quit();
+}
+
+fn addExitHandler() !void {
+    if (comptime builtin.os.tag == .windows) {
+        try std.os.windows.SetConsoleCtrlHandler(windowsEventHandler, true);
+    } else if (comptime std.Thread.use_pthreads) {
+        var set: std.posix.sigset_t = undefined;
+        _ = moreposix.sigemptyset(&set);
+        for (psigs) |sig|
+            _ = moreposix.sigaddset(&set, sig);
+
+        _ = moreposix.pthread_sigmask(std.posix.SIG.BLOCK, &set, null);
+        // nobody cares about the thread
+        _ = try std.Thread.spawn(.{}, posixSignalHandlerThread, .{});
+    } else {
+        log.err("not windows and not pthreads = disaster", .{});
+    }
+}
+
 fn printStderr(comptime fmt: []const u8, args: anytype) void {
     std.debug.print(fmt ++ "\n", args);
 }
 
 pub fn main() !u8 {
+    if (comptime builtin.os.tag == .windows) {
+        // set output to UTF-8 on Windows
+        _ = std.os.windows.kernel32.SetConsoleOutputCP(65001);
+    }
+
     var gpa = std.heap.GeneralPurposeAllocator(.{}){};
     defer _ = gpa.deinit();
     const allocator = gpa.allocator();
@@ -47,37 +110,52 @@ pub fn main() !u8 {
         }
 
         Config.loadDefault(allocator);
+        defer Config.deinit();
         return writeDefaultConfig(if (args.len == 3) args[2] else null);
     } else if (std.mem.eql(u8, args[1], commands.run)) {
         if (args.len > 3) {
             printHelp(exename, .run);
             return 1;
         }
-        blk: {
-            const confpath = if (args.len == 3) args[2] else "yaes.json";
-            const conf_file = std.fs.cwd().openFile(confpath, .{}) catch {
-                log.warn("Could not load config file '{s}'. Using default config.", .{confpath});
-                Config.loadDefault(allocator);
-                break :blk;
-            };
-            defer conf_file.close();
+        loadConfigOrDefault(allocator, if (args.len == 3) args[2] else null) catch
+            return 1;
 
-            Config.load(allocator, conf_file.reader(), std.io.getStdErr().writer()) catch |err| {
-                log.err("Could not parse config file '{s}': {s}.", .{ confpath, @errorName(err) });
-                return 1;
-            };
-        }
-        defer Config.destroy(allocator);
+        defer Config.deinit();
 
-        const ver = lj.getDriverVersion();
-        std.debug.print("Driver version: {d}\n", .{ver});
-
-        RotCtl.run(allocator) catch |err| {
-            log.err("rotator controller ceased unexpectedly! {s}", .{@errorName(err)});
+        addExitHandler() catch {
+            log.err("Could not install quit handler.", .{});
             return 1;
         };
 
-        return 0;
+        RotCtl.run(allocator) catch |err| {
+            log.err("rotator controller ceased unexpectedly! {s}", .{@errorName(err)});
+            quit();
+        };
+    } else if (std.mem.eql(u8, args[1], commands.calibrate)) {
+        if (args.len < 3 or args.len > 4) {
+            printHelp(exename, .calibrate);
+            return 1;
+        }
+
+        loadConfigOrDefault(allocator, if (args.len == 4) args[3] else null) catch
+            return 1;
+        defer Config.deinit();
+
+        const routine = std.meta.stringToEnum(YaesuController.CalibrationRoutine, args[2]) orelse {
+            log.err("{s} is not a known calibration routine.", .{args[2]});
+            printHelp(exename, .calibrate);
+            return 1;
+        };
+
+        addExitHandler() catch {
+            log.err("Could not install quit handler.", .{});
+            return 1;
+        };
+
+        YaesuController.calibrate(allocator, routine) catch |err| {
+            log.err("Calibration failed: {s}", .{@errorName(err)});
+            quit();
+        };
     } else if (std.mem.eql(u8, args[1], commands.help)) {
         if (args.len != 3) {
             printHelp(exename, .help);
@@ -97,6 +175,24 @@ pub fn main() !u8 {
         printHelp(exename, .main);
         return 1;
     }
+
+    return 0;
+}
+
+fn loadConfigOrDefault(allocator: std.mem.Allocator, path: ?[]const u8) !void {
+    const confpath = path orelse "yaes.json";
+    const conf_file = std.fs.cwd().openFile(confpath, .{}) catch {
+        log.warn("Could not load config file '{s}'. Using default config.", .{confpath});
+        Config.loadDefault(allocator);
+        return;
+    };
+    defer conf_file.close();
+
+    Config.load(allocator, conf_file.reader(), std.io.getStdErr().writer()) catch |err| {
+        log.err("Could not parse config file '{s}': {s}.", .{ confpath, @errorName(err) });
+        return error.InvalidConfig;
+    };
+    log.info("Loaded config from '{s}'.", .{confpath});
 }
 
 fn installUdevRules(outpath: ?[]const u8) u8 {
@@ -261,7 +357,7 @@ const command_help = .{
         \\  Perform a calibration routine and write an updated configuration with its results.
         \\
         \\Arguments:
-        \\  routine      Must be one of `feedback` or `orientation`. The different calibration routines have
+        \\  routine      Must be either `feedback` or `orientation`. The different calibration routines have
         \\               different requirements. `orientation` calibration is a sun-pointing-based routine and
         \\               should be performed after `feedback` calibration is complete.
         \\  config_file  [Optional] the path of a config file to load. This file will be updated with the