trsync: Introduce new "trigger synchronization" support

Separate out the stepper stopping code from endstop.c into its own trsync.c code file. Signed-off-by: Kevin O'Connor <kevin@koconnor.net>
2021-02-04 10:07:13 -05:00
parent f3bd4e6acf
commit 05c2d51a12
7 changed files with 299 additions and 110 deletions
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,7 +1,8 @@
 # Main code build rules

 src-y += sched.c command.c basecmd.c debugcmds.c
-src-$(CONFIG_HAVE_GPIO) += initial_pins.c gpiocmds.c stepper.c endstop.c
+src-$(CONFIG_HAVE_GPIO) += initial_pins.c gpiocmds.c stepper.c endstop.c \
+    trsync.c
 src-$(CONFIG_HAVE_GPIO_ADC) += adccmds.c
 src-$(CONFIG_HAVE_GPIO_SPI) += spicmds.c thermocouple.c
 src-$(CONFIG_HAVE_GPIO_I2C) += i2ccmds.c
--- a/src/endstop.c
+++ b/src/endstop.c
@@ -1,6 +1,6 @@
 // Handling of end stops.
 //
-// Copyright (C) 2016-2019  Kevin O'Connor <kevin@koconnor.net>
+// Copyright (C) 2016-2021  Kevin O'Connor <kevin@koconnor.net>
 //
 // This file may be distributed under the terms of the GNU GPLv3 license.

@@ -9,30 +9,17 @@
 #include "board/irq.h" // irq_disable
 #include "command.h" // DECL_COMMAND
 #include "sched.h" // struct timer
-#include "stepper.h" // stepper_stop
+#include "trsync.h" // trsync_do_trigger

 struct endstop {
    struct timer time;
    struct gpio_in pin;
    uint32_t rest_time, sample_time, nextwake;
-    uint8_t flags, stepper_count, sample_count, trigger_count;
-    struct stepper *steppers[0];
+    struct trsync *ts;
+    uint8_t flags, sample_count, trigger_count, trigger_reason;
 };

-enum { ESF_PIN_HIGH=1<<0, ESF_HOMING=1<<1, ESF_REPORT=1<<2 };
-
-static struct task_wake endstop_wake;
-
-static void
-stop_steppers(struct endstop *e)
-{
-    e->flags = ESF_REPORT;
-    uint8_t count = e->stepper_count;
-    while (count--)
-        if (e->steppers[count])
-            stepper_stop(e->steppers[count]);
-    sched_wake_task(&endstop_wake);
-}
+enum { ESF_PIN_HIGH=1<<0, ESF_HOMING=1<<1 };

 static uint_fast8_t endstop_oversample_event(struct timer *t);

@@ -68,7 +55,7 @@ endstop_oversample_event(struct timer *t)
    }
    uint8_t count = e->trigger_count - 1;
    if (!count) {
-        stop_steppers(e);
+        trsync_do_trigger(e->ts, e->trigger_reason);
        return SF_DONE;
    }
    e->trigger_count = count;
@@ -79,28 +66,10 @@ endstop_oversample_event(struct timer *t)
 void
 command_config_endstop(uint32_t *args)
 {
-    uint8_t stepper_count = args[3];
-    struct endstop *e = oid_alloc(
-        args[0], command_config_endstop
-        , sizeof(*e) + sizeof(e->steppers[0]) * stepper_count);
+    struct endstop *e = oid_alloc(args[0], command_config_endstop, sizeof(*e));
    e->pin = gpio_in_setup(args[1], args[2]);
-    e->stepper_count = stepper_count;
-    e->sample_count = 1;
 }
-DECL_COMMAND(command_config_endstop,
-             "config_endstop oid=%c pin=%c pull_up=%c stepper_count=%c");
-
-void
-command_endstop_set_stepper(uint32_t *args)
-{
-    struct endstop *e = oid_lookup(args[0], command_config_endstop);
-    uint8_t pos = args[1];
-    if (pos >= e->stepper_count)
-        shutdown("Set stepper past maximum stepper count");
-    e->steppers[pos] = stepper_oid_lookup(args[2]);
-}
-DECL_COMMAND(command_endstop_set_stepper,
-             "endstop_set_stepper oid=%c pos=%c stepper_oid=%c");
+DECL_COMMAND(command_config_endstop, "config_endstop oid=%c pin=%c pull_up=%c");

 // Home an axis
 void
@@ -113,6 +82,7 @@ command_endstop_home(uint32_t *args)
    e->sample_count = args[3];
    if (!e->sample_count) {
        // Disable end stop checking
+        e->ts = NULL;
        e->flags = 0;
        return;
    }
@@ -120,45 +90,26 @@ command_endstop_home(uint32_t *args)
    e->time.func = endstop_event;
    e->trigger_count = e->sample_count;
    e->flags = ESF_HOMING | (args[5] ? ESF_PIN_HIGH : 0);
+    e->ts = trsync_oid_lookup(args[6]);
+    e->trigger_reason = args[7];
    sched_add_timer(&e->time);
 }
 DECL_COMMAND(command_endstop_home,
             "endstop_home oid=%c clock=%u sample_ticks=%u sample_count=%c"
-             " rest_ticks=%u pin_value=%c");
-
-static void
-endstop_report(uint8_t oid, struct endstop *e)
-{
-    irq_disable();
-    uint8_t eflags = e->flags;
-    e->flags &= ~ESF_REPORT;
-    uint32_t nextwake = e->nextwake;
-    irq_enable();
-
-    sendf("endstop_state oid=%c homing=%c next_clock=%u pin_value=%c"
-          , oid, !!(eflags & ESF_HOMING), nextwake, gpio_in_read(e->pin));
-}
+             " rest_ticks=%u pin_value=%c trsync_oid=%c trigger_reason=%c");

 void
 command_endstop_query_state(uint32_t *args)
 {
    uint8_t oid = args[0];
    struct endstop *e = oid_lookup(oid, command_config_endstop);
-    endstop_report(oid, e);
+
+    irq_disable();
+    uint8_t eflags = e->flags;
+    uint32_t nextwake = e->nextwake;
+    irq_enable();
+
+    sendf("endstop_state oid=%c homing=%c next_clock=%u pin_value=%c"
+          , oid, !!(eflags & ESF_HOMING), nextwake, gpio_in_read(e->pin));
 }
 DECL_COMMAND(command_endstop_query_state, "endstop_query_state oid=%c");
-
-void
-endstop_task(void)
-{
-    if (!sched_check_wake(&endstop_wake))
-        return;
-    uint8_t oid;
-    struct endstop *e;
-    foreach_oid(oid, e, command_config_endstop) {
-        if (!(e->flags & ESF_REPORT))
-            continue;
-        endstop_report(oid, e);
-    }
-}
-DECL_TASK(endstop_task);
--- a/src/stepper.c
+++ b/src/stepper.c
@@ -1,6 +1,6 @@
 // Handling of stepper drivers.
 //
-// Copyright (C) 2016-2019  Kevin O'Connor <kevin@koconnor.net>
+// Copyright (C) 2016-2021  Kevin O'Connor <kevin@koconnor.net>
 //
 // This file may be distributed under the terms of the GNU GPLv3 license.

@@ -11,7 +11,8 @@
 #include "board/misc.h" // timer_is_before
 #include "command.h" // DECL_COMMAND
 #include "sched.h" // struct timer
-#include "stepper.h" // command_config_stepper
+#include "stepper.h" // stepper_event
+#include "trsync.h" // trsync_add_signal

 DECL_CONSTANT("STEP_DELAY", CONFIG_STEP_DELAY);

@@ -44,6 +45,7 @@ struct stepper {
    struct gpio_out step_pin, dir_pin;
    uint32_t position;
    struct move_queue_head mq;
+    struct trsync_signal stop_signal;
    // gcc (pre v6) does better optimization when uint8_t are bitfields
    uint8_t flags : 8;
 };
@@ -192,7 +194,7 @@ DECL_COMMAND(command_config_stepper,
             "config_stepper oid=%c step_pin=%c dir_pin=%c invert_step=%c");

 // Return the 'struct stepper' for a given stepper oid
-struct stepper *
+static struct stepper *
 stepper_oid_lookup(uint8_t oid)
 {
    return oid_lookup(oid, command_config_stepper);
@@ -290,11 +292,11 @@ command_stepper_get_position(uint32_t *args)
 }
 DECL_COMMAND(command_stepper_get_position, "stepper_get_position oid=%c");

-// Stop all moves for a given stepper (used in end stop homing).  IRQs
-// must be off.
-void
-stepper_stop(struct stepper *s)
+// Stop all moves for a given stepper (caller must disable IRQs)
+static void
+stepper_stop(struct trsync_signal *tss, uint8_t reason)
 {
+    struct stepper *s = container_of(tss, struct stepper, stop_signal);
    sched_del_timer(&s->time);
    s->next_step_time = 0;
    s->position = -stepper_get_position(s);
@@ -309,6 +311,17 @@ stepper_stop(struct stepper *s)
    }
 }

+// Set the stepper to stop on a "trigger event" (used in homing)
+void
+command_stepper_stop_on_trigger(uint32_t *args)
+{
+    struct stepper *s = stepper_oid_lookup(args[0]);
+    struct trsync *ts = trsync_oid_lookup(args[1]);
+    trsync_add_signal(ts, &s->stop_signal, stepper_stop);
+}
+DECL_COMMAND(command_stepper_stop_on_trigger,
+             "stepper_stop_on_trigger oid=%c trsync_oid=%c");
+
 void
 stepper_shutdown(void)
 {
@@ -316,7 +329,7 @@ stepper_shutdown(void)
    struct stepper *s;
    foreach_oid(i, s, command_config_stepper) {
        move_queue_clear(&s->mq);
-        stepper_stop(s);
+        stepper_stop(&s->stop_signal, 0);
    }
 }
 DECL_SHUTDOWN(stepper_shutdown);
--- a/src/stepper.h
+++ b/src/stepper.h
@@ -4,7 +4,5 @@
 #include <stdint.h> // uint8_t

 uint_fast8_t stepper_event(struct timer *t);
-struct stepper *stepper_oid_lookup(uint8_t oid);
-void stepper_stop(struct stepper *s);

 #endif // stepper.h
--- a/src/trsync.c
+++ b/src/trsync.c
@@ -0,0 +1,200 @@
+// Handling of synchronized "trigger" dispatch
+//
+// Copyright (C) 2016-2021  Kevin O'Connor <kevin@koconnor.net>
+//
+// This file may be distributed under the terms of the GNU GPLv3 license.
+
+#include "basecmd.h" // oid_alloc
+#include "board/gpio.h" // struct gpio
+#include "board/irq.h" // irq_disable
+#include "board/misc.h" // timer_read_time
+#include "command.h" // DECL_COMMAND
+#include "sched.h" // struct timer
+#include "trsync.h" // trsync_do_trigger
+
+struct trsync {
+    struct timer report_time, expire_time;
+    uint32_t report_ticks;
+    struct trsync_signal *signals;
+    uint8_t flags, trigger_reason, expire_reason;
+};
+
+enum { TSF_CAN_TRIGGER=1<<0, TSF_REPORT=1<<2 };
+
+static struct task_wake trsync_wake;
+
+// Activate a trigger (caller must disable IRQs)
+void
+trsync_do_trigger(struct trsync *ts, uint8_t reason)
+{
+    uint8_t flags = ts->flags;
+    if (!(flags & TSF_CAN_TRIGGER))
+        return;
+    ts->trigger_reason = reason;
+    ts->flags = (flags & ~TSF_CAN_TRIGGER) | TSF_REPORT;
+    // Dispatch signals
+    while (ts->signals) {
+        struct trsync_signal *tss = ts->signals;
+        trsync_callback_t func = tss->func;
+        ts->signals = tss->next;
+        tss->next = NULL;
+        tss->func = NULL;
+        func(tss, reason);
+    }
+    sched_wake_task(&trsync_wake);
+}
+
+// Timeout handler
+static uint_fast8_t
+trsync_expire_event(struct timer *t)
+{
+    struct trsync *ts = container_of(t, struct trsync, expire_time);
+    trsync_do_trigger(ts, ts->expire_reason);
+    return SF_DONE;
+}
+
+// Report handler
+static uint_fast8_t
+trsync_report_event(struct timer *t)
+{
+    struct trsync *ts = container_of(t, struct trsync, report_time);
+    ts->flags |= TSF_REPORT;
+    sched_wake_task(&trsync_wake);
+    ts->report_time.waketime += ts->report_ticks;
+    return SF_RESCHEDULE;
+}
+
+void
+command_config_trsync(uint32_t *args)
+{
+    struct trsync *ts = oid_alloc(args[0], command_config_trsync, sizeof(*ts));
+    ts->report_time.func = trsync_report_event;
+    ts->expire_time.func = trsync_expire_event;
+}
+DECL_COMMAND(command_config_trsync, "config_trsync oid=%c");
+
+// Return the 'struct trsync' for a given trsync oid
+struct trsync *
+trsync_oid_lookup(uint8_t oid)
+{
+    return oid_lookup(oid, command_config_trsync);
+}
+
+// Add a callback to invoke on a trigger
+void
+trsync_add_signal(struct trsync *ts, struct trsync_signal *tss
+                  , trsync_callback_t func)
+{
+    irqstatus_t flag = irq_save();
+    if (tss->func || !func)
+        shutdown("Can't add signal that is already active");
+    tss->func = func;
+    tss->next = ts->signals;
+    ts->signals = tss;
+    irq_restore(flag);
+}
+
+// Disable trigger and unregister any signal handlers (caller must disable IRQs)
+static void
+trsync_clear(struct trsync *ts)
+{
+    sched_del_timer(&ts->report_time);
+    sched_del_timer(&ts->expire_time);
+    struct trsync_signal *tss = ts->signals;
+    while (tss) {
+        struct trsync_signal *next = tss->next;
+        tss->func = NULL;
+        tss->next = NULL;
+        tss = next;
+    }
+    ts->signals = NULL;
+    ts->flags = ts->trigger_reason = ts->expire_reason = 0;
+}
+
+void
+command_trsync_start(uint32_t *args)
+{
+    struct trsync *ts = trsync_oid_lookup(args[0]);
+    irq_disable();
+    trsync_clear(ts);
+    ts->flags = TSF_CAN_TRIGGER;
+    ts->report_time.waketime = args[1];
+    ts->report_ticks = args[2];
+    if (ts->report_ticks)
+        sched_add_timer(&ts->report_time);
+    ts->expire_reason = args[3];
+    irq_enable();
+}
+DECL_COMMAND(command_trsync_start,
+             "trsync_start oid=%c report_clock=%u report_ticks=%u"
+             " expire_reason=%c");
+
+void
+command_trsync_set_timeout(uint32_t *args)
+{
+    struct trsync *ts = trsync_oid_lookup(args[0]);
+    irq_disable();
+    uint8_t flags = ts->flags;
+    if (flags & TSF_CAN_TRIGGER) {
+        sched_del_timer(&ts->expire_time);
+        ts->expire_time.waketime = args[1];
+        sched_add_timer(&ts->expire_time);
+    }
+    irq_enable();
+}
+DECL_COMMAND(command_trsync_set_timeout, "trsync_set_timeout oid=%c clock=%u");
+
+static void
+trsync_report(uint8_t oid, uint8_t flags, uint8_t reason, uint32_t clock)
+{
+    sendf("trsync_state oid=%c can_trigger=%c trigger_reason=%c clock=%u"
+          , oid, !!(flags & TSF_CAN_TRIGGER), reason, clock);
+}
+
+void
+command_trsync_trigger(uint32_t *args)
+{
+    uint8_t oid = args[0];
+    struct trsync *ts = trsync_oid_lookup(oid);
+    irq_disable();
+    trsync_do_trigger(ts, args[1]);
+    sched_del_timer(&ts->report_time);
+    sched_del_timer(&ts->expire_time);
+    ts->flags = 0;
+    uint8_t trigger_reason = ts->trigger_reason;
+    irq_enable();
+    trsync_report(oid, 0, trigger_reason, 0);
+}
+DECL_COMMAND(command_trsync_trigger, "trsync_trigger oid=%c reason=%c");
+
+void
+trsync_task(void)
+{
+    if (!sched_check_wake(&trsync_wake))
+        return;
+    uint8_t oid;
+    struct trsync *ts;
+    foreach_oid(oid, ts, command_config_trsync) {
+        if (!(ts->flags & TSF_REPORT))
+            continue;
+        uint32_t time = timer_read_time();
+        irq_disable();
+        uint8_t trigger_reason = ts->trigger_reason, flags = ts->flags;
+        ts->flags = flags & ~TSF_REPORT;
+        irq_enable();
+
+        trsync_report(oid, flags, trigger_reason, time);
+    }
+}
+DECL_TASK(trsync_task);
+
+void
+trsync_shutdown(void)
+{
+    uint8_t oid;
+    struct trsync *ts;
+    foreach_oid(oid, ts, command_config_trsync) {
+        trsync_clear(ts);
+    }
+}
+DECL_SHUTDOWN(trsync_shutdown);
--- a/src/trsync.h
+++ b/src/trsync.h
@@ -0,0 +1,19 @@
+#ifndef __TRSYNC_H
+#define __TRSYNC_H
+
+#include <stdint.h> // uint16_t
+
+struct trsync_signal;
+typedef void (*trsync_callback_t)(struct trsync_signal *tss, uint8_t reason);
+
+struct trsync_signal {
+    struct trsync_signal *next;
+    trsync_callback_t func;
+};
+
+struct trsync *trsync_oid_lookup(uint8_t oid);
+void trsync_do_trigger(struct trsync *ts, uint8_t reason);
+void trsync_add_signal(struct trsync *ts, struct trsync_signal *tss
+                       , trsync_callback_t func);
+
+#endif // trsync.h