mod fcap to always fully deinit the timer when IDLE

comm/messages.c

@@ -71,6 +71,7 @@ static void settings_bulkread_cb(BulkRead *bulk, uint32_t chunk, uint8_t *buffer
     if (bulk->offset == 0) iw_begin();
 
     IniWriter iw = iw_init((char *)buffer, bulk->offset, chunk);
+    iw.tag = 1;
     settings_build_units_ini(&iw);
 }
 
@@ -85,7 +86,7 @@ static TF_Result lst_ini_export(TinyFrame *tf, TF_Msg *msg)
     assert_param(bulk != NULL);
 
     bulk->frame_id = msg->frame_id;
-    bulk->len = iw_measure_total(settings_build_units_ini);
+    bulk->len = iw_measure_total(settings_build_units_ini, 1);
     bulk->read = settings_bulkread_cb;
     bulk->userdata = NULL;
 

framework/settings.c

@@ -229,7 +229,6 @@ static void gex_file_preamble(IniWriter *iw, const char *filename)
     iw_hdr_comment(iw, filename);
     iw_hdr_comment(iw, "GEX v%s on %s", GEX_VERSION, GEX_PLATFORM);
     iw_hdr_comment(iw, "built %s at %s", __DATE__, __TIME__);
-    iw_cmt_newline(iw);
 }
 
 /** Generate a config file header (write instructions) */
@@ -237,6 +236,8 @@ static void ini_preamble(IniWriter *iw, const char *filename)
 {
     gex_file_preamble(iw, filename);
 
+    if (iw->tag == 0) { // tag 1 is set when exporting via the API
+        iw_cmt_newline(iw);
         iw_comment(iw, "Overwrite this file to change settings.");
         #if PLAT_LOCK_BTN
             iw_comment(iw, "Press the LOCK button to save them to Flash.");
@@ -244,6 +245,7 @@ static void ini_preamble(IniWriter *iw, const char *filename)
             iw_comment(iw, "Close the LOCK jumper to save them to Flash.");
         #endif
     }
+}
 
 // --- UNITS.INI ---
 
@@ -284,7 +286,7 @@ extern void plat_print_system_pinout(IniWriter *iw);
 void settings_build_pinout_txt(IniWriter *iw)
 {
     gex_file_preamble(iw, "PINOUT.TXT");
-
+    iw_cmt_newline(iw);
     rsc_print_all_available(iw);
     ureg_print_unit_resources(iw);
     plat_print_system_pinout(iw);

framework/unit_registry.c

@@ -340,19 +340,27 @@ bool ureg_finalize_all_init(void)
         } else {
             pUnit->status = pUnit->driver->init(pUnit);
             if (pUnit->status != E_SUCCESS) {
-                dbg("!!! error initing unit %s: %s", pUnit->name,
+                dbg("!!! error initing unit %s: %s", pUnit->name, error_get_message(pUnit->status));
-                    error_get_message(pUnit->status));
             }
 
             // try to assign unique callsigns
-            // FIXME this is wrong, sometimes leads to duplicate CS
             if (pUnit->callsign == 0) {
-                pUnit->callsign = callsign++;
+                // this is very inefficient but should be reliable
+                bool change;
+                do {
+                    change = false;
+                    UlistEntry *xli = ulist_head;
+                    while (xli != NULL) {
+                        if (xli->unit.callsign != 0) {
+                            if (xli->unit.callsign == callsign) {
+                                change = true;
+                                callsign++;
                             }
-            else {
-                if (pUnit->callsign >= callsign) {
-                    callsign = (uint8_t) (pUnit->callsign + 1);
                         }
+                        xli = xli->next;
+                    }
+                } while (change && callsign < 255);
+                pUnit->callsign = callsign;
             }
         }
 
@@ -398,8 +406,9 @@ void ureg_build_ini(IniWriter *iw)
 
     // Unit list
     iw_section(iw, "UNITS");
-    iw_comment(iw, "Create units by adding their names next to a type (e.g. PIN=A,B),");
+    iw_comment(iw, "Create units by adding their names next to a type (e.g. DO=A,B),");
     iw_comment(iw, "remove the same way. Reload to update the unit sections below.");
+    iw_cmt_newline(iw);
 
     // This could certainly be done in some more efficient way ...
     re = ureg_head;
@@ -412,7 +421,6 @@ void ureg_build_ini(IniWriter *iw)
 
         const UnitDriver *const pDriver = re->driver;
 
-        iw_cmt_newline(iw);
         iw_comment(iw, pDriver->description);
         iw_string(iw, pDriver->name);
         iw_string(iw, "=");

gex.mk

@@ -14,6 +14,8 @@ GEX_SRC_DIR = \
     User/units/i2c \
     User/units/spi \
     User/units/adc \
+    User/units/sipo \
+    User/units/fcap \
     User/TinyFrame \
     User/CWPack \
     User/tasks

platform/hw_utils.c

@@ -240,34 +240,47 @@ char * pinmask2str_up(uint32_t pins, char *buffer)
     return buffer;
 }
 
-/** Spread packed port pins using a mask */
+#pragma GCC push_options
-uint32_t pinmask_spread(uint32_t packed, uint32_t mask)
+#pragma GCC optimize ("O2")
+/** spread a packed pinfield using a mask */
+uint32_t pinmask_spread_32(uint32_t packed, uint32_t mask)
 {
     uint32_t result = 0;
     uint32_t poke = 1;
+    if(packed == 0) return 0;
+
     for (int i = 0; i < 32; i++) {
-        if (mask & (1<<i)) {
+        if (mask & 1) {
             if (packed & poke) {
                 result |= 1<<i;
+                packed ^= poke;
+                if (packed == 0) break;
             }
             poke <<= 1;
         }
+        mask >>= 1;
+        // if (mask == 0) break;
     }
+
     return result;
 }
 
 /** Pack spread port pins using a mask */
-uint32_t pinmask_pack(uint32_t spread, uint32_t mask)
+uint32_t pinmask_pack_32(uint32_t spread, uint32_t mask)
 {
     uint32_t result = 0;
     uint32_t poke = 1;
     for (int i = 0; i<32; i++) {
-        if (mask & (1<<i)) {
+        if (mask & 1) {
             if (spread & (1<<i)) {
                 result |= poke;
+                spread ^= (1<<i);
+                if (spread == 0) break;
             }
             poke <<= 1;
         }
+        mask >>= 1;
+        // if (mask == 0) break;
     }
     return result;
 }
@@ -284,6 +297,7 @@ uint8_t pinmask_translate(uint32_t mask, uint8_t index)
     }
     return 0;
 }
+#pragma GCC pop_options
 
 /** Configure unit pins as analog (part of unit teardown) */
 void hw_deinit_unit_pins(Unit *unit)

platform/hw_utils.h

@@ -98,7 +98,13 @@ char * pinmask2str_up(uint32_t pins, char *buffer);
  * @param mask - positions of the bits (eg. 0x8803)
  * @return - bits spread to their positions (always counting from right)
  */
-uint32_t pinmask_spread(uint32_t packed, uint32_t mask);
+uint32_t pinmask_spread_32(uint32_t packed, uint32_t mask);
+
+/** Spread packed port pins using a mask - 16-bit version */
+static inline uint16_t pinmask_spread(uint16_t packed, uint16_t mask)
+{
+    return (uint16_t) pinmask_spread_32(packed, mask);
+}
 
 /**
  * Pack spread port pins using a mask
@@ -107,7 +113,13 @@ uint32_t pinmask_spread(uint32_t packed, uint32_t mask);
  * @param mask - mask of the bits we want to pack (eg. 0x8803)
  * @return - packed bits, right aligned (eg. 0b1110)
  */
-uint32_t pinmask_pack(uint32_t spread, uint32_t mask);
+uint32_t pinmask_pack_32(uint32_t spread, uint32_t mask);
+
+/** Pack spread port pins using a mask - 16-bit version */
+static inline uint16_t pinmask_pack(uint32_t spread, uint32_t mask)
+{
+    return (uint16_t) pinmask_pack_32(spread, mask);
+}
 
 /**
  * Convert spread port pin number to a packed index using a mask

platform/irq_dispatcher.c

@@ -61,6 +61,7 @@ static struct callbacks_ {
     struct cbslot dma2_7;
     struct cbslot dma2_8;
 
+    struct cbslot tim2;
     struct cbslot tim6;
     struct cbslot tim7;
     struct cbslot tim15;
@@ -102,7 +103,7 @@ void irqd_init(void)
     HAL_NVIC_SetPriority(ADC1_COMP_IRQn, 1, 0); // ADC group completion - higher prio than DMA to let it handle the last halfword first
 
 //    NVIC_EnableIRQ(TIM1_IRQn);                  /*!< TIM1 global Interrupt                                          */
-//    NVIC_EnableIRQ(TIM2_IRQn);                  /*!< TIM2 global Interrupt                                           */
+    NVIC_EnableIRQ(TIM2_IRQn);                  /*!< TIM2 global Interrupt                                           */
 //    NVIC_EnableIRQ(TIM3_IRQn);                  /*!< TIM3 global Interrupt                                           */
 
     NVIC_EnableIRQ(TIM6_DAC_IRQn);              /*!< TIM6 global and DAC channel underrun error Interrupt            */
@@ -159,6 +160,7 @@ static struct cbslot *get_slot_for_periph(void *periph)
         else if (periph == USART5) slot = &callbacks.usart5;
 #endif
 
+    else if (periph == TIM2) slot = &callbacks.tim2;
     else if (periph == TIM6) slot = &callbacks.tim6;
     else if (periph == TIM7) slot = &callbacks.tim7;
     else if (periph == TIM15) slot = &callbacks.tim15;
@@ -304,6 +306,11 @@ void EXTI4_15_IRQHandler(void)
 
 // TIM14 is used to generate HAL timebase and its handler is in the file "timebase.c"
 
+void TIM2_IRQHandler(void)
+{
+    CALL_IRQ_HANDLER(callbacks.tim2);
+}
+
 void TIM6_DAC_IRQHandler(void)
 {
     CALL_IRQ_HANDLER(callbacks.tim6);

platform/platform.c

@@ -2,6 +2,7 @@
 // Created by MightyPork on 2017/11/26.
 //
 
+#include <units/fcap/unit_fcap.h>
 #include "platform.h"
 #include "usbd_core.h"
 #include "USB/usb_device.h"
@@ -17,6 +18,7 @@
 #include "units/test/unit_test.h"
 #include "units/usart/unit_usart.h"
 #include "units/spi/unit_spi.h"
+#include "units/sipo/unit_sipo.h"
 #include "hw_utils.h"
 
 void plat_init_resources(void)
@@ -86,6 +88,8 @@ void plat_init_resources(void)
     ureg_add_type(&UNIT_USART);
     ureg_add_type(&UNIT_1WIRE);
     ureg_add_type(&UNIT_ADC);
+    ureg_add_type(&UNIT_SIPO);
+    ureg_add_type(&UNIT_FCAP);
 
     // Free all present resources
     {

units/digital_out/_dout_settings.c

@@ -47,13 +47,13 @@ error_t DOut_loadIni(Unit *unit, const char *key, const char *value)
         suc = parse_port_name(value, &priv->port_name);
     }
     else if (streq(key, "pins")) {
-        priv->pins = parse_pinmask(value, &suc);
+        priv->pins = (uint16_t) parse_pinmask(value, &suc);
     }
     else if (streq(key, "initial")) {
-        priv->initial = parse_pinmask(value, &suc);
+        priv->initial = (uint16_t) parse_pinmask(value, &suc);
     }
     else if (streq(key, "open-drain")) {
-        priv->open_drain = parse_pinmask(value, &suc);
+        priv->open_drain = (uint16_t) parse_pinmask(value, &suc);
     }
     else {
         return E_BAD_KEY;

units/fcap/_fcap_api.c

@@ -0,0 +1,11 @@
+//
+// Created by MightyPork on 2018/02/03.
+//
+
+#include "platform.h"
+#include "unit_base.h"
+#include "unit_fcap.h"
+
+#define FCAP_INTERNAL
+#include "_fcap_internal.h"
+

units/fcap/_fcap_core.c

@@ -0,0 +1,210 @@
+//
+// Created by MightyPork on 2018/02/20.
+//
+
+#include "platform.h"
+
+#define FCAP_INTERNAL
+#include "_fcap_internal.h"
+
+static void UFCAP_PWMBurstReportJob(Job *job)
+{
+    Unit *unit = job->unit;
+    struct priv * const priv = unit->data;
+
+    uint8_t buf[20];
+    PayloadBuilder pb = pb_start(buf, 20, NULL);
+
+    pb_u16(&pb, PLAT_AHB_MHZ);
+    pb_u16(&pb, priv->pwm_burst.n_count);
+    pb_u64(&pb, priv->pwm_burst.period_acu);
+    pb_u64(&pb, priv->pwm_burst.ontime_acu);
+
+    assert_param(pb.ok);
+
+    com_respond_pb(priv->request_id, MSG_SUCCESS, &pb);
+
+    // timer is already stopped, now in OPMODE_BUSY
+    priv->opmode = OPMODE_IDLE;
+}
+
+void UFCAP_TimerHandler(void *arg)
+{
+    Unit *unit = arg;
+    assert_param(unit);
+    struct priv * const priv = unit->data;
+    assert_param(priv);
+
+    TIM_TypeDef * const TIMx = priv->TIMx;
+
+    if (priv->opmode == OPMODE_PWM_CONT) {
+        if (LL_TIM_IsActiveFlag_CC1(TIMx)) {
+//            assert_param(!LL_TIM_IsActiveFlag_CC1OVR(TIMx));
+            if (priv->n_skip > 0) {
+                priv->n_skip--;
+            } else {
+                priv->pwm_cont.last_period = LL_TIM_IC_GetCaptureCH1(TIMx);
+                priv->pwm_cont.last_ontime = priv->pwm_cont.ontime;
+            }
+            LL_TIM_ClearFlag_CC1(TIMx);
+            LL_TIM_ClearFlag_CC1OVR(TIMx);
+        }
+
+        if (LL_TIM_IsActiveFlag_CC2(TIMx)) {
+//            assert_param(!LL_TIM_IsActiveFlag_CC2OVR(TIMx));
+            priv->pwm_cont.ontime = LL_TIM_IC_GetCaptureCH2(TIMx);
+            LL_TIM_ClearFlag_CC2(TIMx);
+            LL_TIM_ClearFlag_CC2OVR(TIMx);
+        }
+    }
+    else if (priv->opmode == OPMODE_PWM_BURST) {
+        if (LL_TIM_IsActiveFlag_CC1(TIMx)) {
+//            assert_param(!LL_TIM_IsActiveFlag_CC1OVR(TIMx));
+            const uint32_t period = LL_TIM_IC_GetCaptureCH1(TIMx);
+            const uint32_t ontime = priv->pwm_burst.ontime;
+
+            if (priv->n_skip > 0) {
+                priv->n_skip--;
+            } else {
+                priv->pwm_burst.ontime_acu += ontime;
+                priv->pwm_burst.period_acu += period;
+                if (++priv->pwm_burst.n_count == priv->pwm_burst.n_target) {
+                    priv->opmode = OPMODE_BUSY;
+                    UFCAP_StopMeasurement(unit);
+
+                    Job j = {
+                        .cb = UFCAP_PWMBurstReportJob,
+                        .unit = unit,
+                    };
+                    scheduleJob(&j);
+                }
+            }
+
+            LL_TIM_ClearFlag_CC1(TIMx);
+            LL_TIM_ClearFlag_CC1OVR(TIMx);
+        }
+
+        if (LL_TIM_IsActiveFlag_CC2(TIMx)) {
+//            assert_param(!LL_TIM_IsActiveFlag_CC2OVR(TIMx));
+            priv->pwm_burst.ontime = LL_TIM_IC_GetCaptureCH2(TIMx);
+            LL_TIM_ClearFlag_CC2(TIMx);
+            LL_TIM_ClearFlag_CC2OVR(TIMx);
+        }
+    }
+    else if (priv->opmode == OPMODE_IDLE) {
+        // clear everything - in idle it would cycle in the handler forever
+        TIMx->SR = 0;
+    }
+}
+
+static void UFCAP_ClearTimerConfig(Unit *unit)
+{
+    struct priv * const priv = unit->data;
+    TIM_TypeDef * const TIMx = priv->TIMx;
+
+    // CLEAR CURRENT STATE, STOP
+    UFCAP_StopMeasurement(unit);
+
+    // CONFIGURE TIMER BASIC PARAMS
+    LL_TIM_SetPrescaler(TIMx, 0);
+    LL_TIM_SetAutoReload(TIMx, 0xFFFFFFFF);
+    LL_TIM_EnableARRPreload(TIMx);
+    LL_TIM_GenerateEvent_UPDATE(TIMx);
+}
+
+/**
+ * Reset all timer registers
+ *
+ * @param unit
+ */
+void UFCAP_StopMeasurement(Unit *unit)
+{
+    struct priv * const priv = unit->data;
+    TIM_TypeDef * const TIMx = priv->TIMx;
+
+    LL_TIM_DeInit(TIMx); // clear all flags and settings
+}
+
+/**
+ * Switch the FCAP module opmode
+ *
+ * @param unit
+ * @param opmode
+ */
+void UFCAP_SwitchMode(Unit *unit, enum fcap_opmode opmode)
+{
+    struct priv * const priv = unit->data;
+
+    if (opmode == priv->opmode) return;
+
+    priv->opmode = opmode;
+
+    switch (opmode) {
+        case OPMODE_IDLE:
+            // XXX maybe we should report the abort to the PC-side listener
+            UFCAP_StopMeasurement(unit);
+            break;
+
+        case OPMODE_PWM_CONT:
+            priv->pwm_cont.last_ontime = 0;
+            priv->pwm_cont.last_period = 0;
+            priv->pwm_cont.ontime = 0;
+            priv->n_skip = 1; // discard the first cycle (will be incomplete)
+            UFCAP_ConfigureForPWMCapture(unit); // is also stopped and restarted
+            break;
+
+        case OPMODE_PWM_BURST:
+            priv->pwm_burst.ontime = 0;
+            priv->pwm_burst.n_count = 0;
+            priv->pwm_burst.period_acu = 0;
+            priv->pwm_burst.ontime_acu = 0;
+            priv->n_skip = 1; // discard the first cycle (will be incomplete)
+            UFCAP_ConfigureForPWMCapture(unit); // is also stopped and restarted
+            break;
+        default:
+            trap("Unhandled opmode %d", (int)opmode);
+    }
+}
+
+/**
+ * Configure peripherals for an indirect capture (PWM measurement) - continuous or burst
+ * @param unit
+ */
+void UFCAP_ConfigureForPWMCapture(Unit *unit)
+{
+    struct priv * const priv = unit->data;
+    TIM_TypeDef * const TIMx = priv->TIMx;
+    const uint32_t ll_ch_a = priv->ll_ch_a;
+    const uint32_t ll_ch_b = priv->ll_ch_b;
+
+    UFCAP_ClearTimerConfig(unit);
+
+    // Enable channels and select mapping to TIx signals
+
+    // A - will be used to measure period
+    // B - will be used to measure the duty cycle
+
+    //         _________                  ______
+    // _______|         |________________|
+    //        A         B                A
+    //        irq       irq,cap          irq
+    //        reset
+
+    // B irq may be used if we want to measure a pulse width
+
+    // Normally TI1 = CH1, TI2 = CH2.
+    // It's possible to select the other channel, which we use to connect both TIx to the shame CHx.
+    LL_TIM_IC_SetActiveInput(TIMx, ll_ch_a, priv->a_direct ? LL_TIM_ACTIVEINPUT_DIRECTTI   : LL_TIM_ACTIVEINPUT_INDIRECTTI);
+    LL_TIM_IC_SetActiveInput(TIMx, ll_ch_b, priv->a_direct ? LL_TIM_ACTIVEINPUT_INDIRECTTI : LL_TIM_ACTIVEINPUT_DIRECTTI);
+    LL_TIM_CC_EnableChannel(TIMx, ll_ch_a | ll_ch_b);
+
+    LL_TIM_IC_SetPolarity(TIMx, ll_ch_a, LL_TIM_IC_POLARITY_RISING);
+    LL_TIM_IC_SetPolarity(TIMx, ll_ch_b, LL_TIM_IC_POLARITY_FALLING);
+    LL_TIM_SetSlaveMode(TIMx, LL_TIM_SLAVEMODE_RESET);
+    LL_TIM_SetTriggerInput(TIMx, LL_TIM_TS_TI1FP1); // Use Filtered Input 1 (TI1)
+    LL_TIM_EnableMasterSlaveMode(TIMx);
+
+    LL_TIM_EnableIT_CC1(TIMx);
+    LL_TIM_EnableIT_CC2(TIMx);
+    LL_TIM_EnableCounter(TIMx);
+}

units/fcap/_fcap_init.c

@@ -0,0 +1,120 @@
+//
+// Created by MightyPork on 2018/02/03.
+//
+
+#include "platform.h"
+#include "unit_base.h"
+
+#define FCAP_INTERNAL
+#include "_fcap_internal.h"
+
+/** Allocate data structure and set defaults */
+error_t UFCAP_preInit(Unit *unit)
+{
+    struct priv *priv = unit->data = calloc_ck(1, sizeof(struct priv));
+    if (priv == NULL) return E_OUT_OF_MEM;
+
+    priv->signal_pname = 'A';
+    priv->signal_pnum = 0;
+
+    priv->opmode = OPMODE_PWM_CONT;
+
+    return E_SUCCESS;
+}
+
+/** Finalize unit set-up */
+error_t UFCAP_init(Unit *unit)
+{
+    bool suc = true;
+    struct priv *priv = unit->data;
+
+    // ---- Resolve what to configure ----
+
+    TIM_TypeDef * const TIMx = TIM2;
+    Resource timRsc = R_TIM2;
+
+    uint32_t ll_ch_a = 0;
+    uint32_t ll_ch_b = 0;
+
+    switch (priv->signal_pname) {
+        case 'A':
+            switch (priv->signal_pnum) {
+                case 5:
+                case 15:
+                case 0: ll_ch_a = LL_TIM_CHANNEL_CH1; break;
+                case 1: ll_ch_a = LL_TIM_CHANNEL_CH2; break;
+                default:
+                    dbg("Bad signal pin!");
+                    return E_BAD_CONFIG;
+            }
+            break;
+        case 'B':
+            switch (priv->signal_pnum) {
+                case 3: ll_ch_a = LL_TIM_CHANNEL_CH2; break;
+                default:
+                    dbg("Bad signal pin!");
+                    return E_BAD_CONFIG;
+            }
+            break;
+
+        default:
+            dbg("Bad signal pin port!");
+            return E_BAD_CONFIG;
+    }
+    const uint32_t ll_timpin_af = LL_GPIO_AF_2;
+
+    bool a_direct = true;
+    switch (ll_ch_a) {
+        case LL_TIM_CHANNEL_CH1:
+            ll_ch_b = LL_TIM_CHANNEL_CH2;
+            break;
+
+        case LL_TIM_CHANNEL_CH2:
+            ll_ch_b = LL_TIM_CHANNEL_CH1;
+            a_direct = false;
+            break;
+    }
+
+    // ---- CLAIM ----
+
+    TRY(rsc_claim_pin(unit, priv->signal_pname, priv->signal_pnum));
+    TRY(rsc_claim(unit, timRsc));
+
+    // ---- INIT ----
+    assert_param(ll_ch_a != ll_ch_b);
+
+    priv->TIMx = TIMx;
+    priv->ll_ch_a = ll_ch_a;
+    priv->ll_ch_b = ll_ch_b;
+    priv->a_direct = a_direct;
+
+    TRY(hw_configure_gpio_af(priv->signal_pname, priv->signal_pnum, ll_timpin_af));
+
+    hw_periph_clock_enable(TIMx);
+    irqd_attach(TIMx, UFCAP_TimerHandler, unit);
+
+    UFCAP_SwitchMode(unit, OPMODE_IDLE);
+
+    return E_SUCCESS;
+}
+
+/** Tear down the unit */
+void UFCAP_deInit(Unit *unit)
+{
+    struct priv *priv = unit->data;
+
+    // de-init peripherals
+    if (unit->status == E_SUCCESS ) {
+        UFCAP_SwitchMode(unit, OPMODE_IDLE);
+
+        TIM_TypeDef *TIMx = priv->TIMx;
+        LL_TIM_DeInit(TIMx);
+        irqd_attach(TIMx, UFCAP_TimerHandler, unit);
+    }
+
+    // Release all resources, deinit pins
+    rsc_teardown(unit);
+
+    // Free memory
+    free_ck(unit->data);
+}

units/fcap/_fcap_internal.h

@@ -0,0 +1,90 @@
+//
+// Created by MightyPork on 2018/02/03.
+//
+
+#ifndef GEX_F072_FCAP_INTERNAL_H
+#define GEX_F072_FCAP_INTERNAL_H
+
+#ifndef FCAP_INTERNAL
+#error bad include!
+#endif
+
+#include "unit_base.h"
+
+enum fcap_opmode {
+    OPMODE_IDLE = 0,
+    OPMODE_BUSY = 1, // used after capture is done, before it's reported
+    OPMODE_PWM_CONT = 2,
+    OPMODE_PWM_BURST = 3, // averaging
+};
+
+/** Private data structure */
+struct priv {
+    // settings
+    char signal_pname;   // the input pin - one of TIM2 channels
+    uint8_t signal_pnum;
+
+    // internal state
+    TIM_TypeDef *TIMx;
+    uint32_t ll_ch_b;
+    uint32_t ll_ch_a;
+    bool a_direct;
+
+    enum fcap_opmode opmode;
+
+    TF_ID request_id;
+    uint8_t n_skip; //!< Periods to skip before starting the real capture
+
+    union {
+        struct {
+            uint32_t ontime; // length of the captured positive pulse in the current interval
+            uint32_t last_period; //!< length of the captured interval between two rising edges
+            uint32_t last_ontime; //!< length of the last captured ontime
+        } pwm_cont;
+
+        struct {
+            uint32_t ontime; // length of the captured positive pulse in the current interval
+            uint64_t period_acu; //!< length of the captured interval between two rising edges, sum
+            uint64_t ontime_acu; //!< length of the last captured ontime, sum
+            uint16_t n_count; //!< Periods captured
+            uint16_t n_target; //!< Periods captured - requested count
+        } pwm_burst;
+    };
+};
+
+/** Allocate data structure and set defaults */
+error_t UFCAP_preInit(Unit *unit);
+
+/** Load from a binary buffer stored in Flash */
+void UFCAP_loadBinary(Unit *unit, PayloadParser *pp);
+
+/** Write to a binary buffer for storing in Flash */
+void UFCAP_writeBinary(Unit *unit, PayloadBuilder *pb);
+
+// ------------------------------------------------------------------------
+
+/** Parse a key-value pair from the INI file */
+error_t UFCAP_loadIni(Unit *unit, const char *key, const char *value);
+
+/** Generate INI file section for the unit */
+void UFCAP_writeIni(Unit *unit, IniWriter *iw);
+
+// ------------------------------------------------------------------------
+
+/** Finalize unit set-up */
+error_t UFCAP_init(Unit *unit);
+
+/** Tear down the unit */
+void UFCAP_deInit(Unit *unit);
+
+// ------------------------------------------------------------------------
+
+void UFCAP_TimerHandler(void *arg);
+
+void UFCAP_StopMeasurement(Unit *unit);
+
+void UFCAP_ConfigureForPWMCapture(Unit *unit);
+
+void UFCAP_SwitchMode(Unit *unit, enum fcap_opmode opmode);
+
+#endif //GEX_F072_FCAP_INTERNAL_H

units/fcap/_fcap_settings.c

@@ -0,0 +1,62 @@
+//
+// Created by MightyPork on 2018/02/03.
+//
+
+#include "platform.h"
+#include "unit_base.h"
+
+#define FCAP_INTERNAL
+#include "_fcap_internal.h"
+
+/** Load from a binary buffer stored in Flash */
+void UFCAP_loadBinary(Unit *unit, PayloadParser *pp)
+{
+    struct priv *priv = unit->data;
+
+    uint8_t version = pp_u8(pp);
+    (void)version;
+
+    priv->signal_pname = pp_char(pp);
+    priv->signal_pnum = pp_u8(pp);
+}
+
+/** Write to a binary buffer for storing in Flash */
+void UFCAP_writeBinary(Unit *unit, PayloadBuilder *pb)
+{
+    struct priv *priv = unit->data;
+
+    pb_u8(pb, 0); // version
+
+    pb_char(pb, priv->signal_pname);
+    pb_u8(pb, priv->signal_pnum);
+}
+
+// ------------------------------------------------------------------------
+
+/** Parse a key-value pair from the INI file */
+error_t UFCAP_loadIni(Unit *unit, const char *key, const char *value)
+{
+    bool suc = true;
+    struct priv *priv = unit->data;
+
+    if (streq(key, "signal-pin")) {
+        suc = parse_pin(value, &priv->signal_pname, &priv->signal_pnum);
+    }
+    else {
+        return E_BAD_KEY;
+    }
+
+    if (!suc) return E_BAD_VALUE;
+    return E_SUCCESS;
+}
+
+/** Generate INI file section for the unit */
+void UFCAP_writeIni(Unit *unit, IniWriter *iw)
+{
+    struct priv *priv = unit->data;
+
+    iw_comment(iw, "Signal input pin");
+    iw_comment(iw, "One of: A0, A1, A5, A15, B3");
+    iw_entry(iw, "signal-pin", "%c%d", priv->signal_pname,  priv->signal_pnum);
+}
+

units/fcap/unit_fcap.c

@@ -0,0 +1,84 @@
+//
+// Created by MightyPork on 2017/11/25.
+//
+
+#include "unit_base.h"
+#include "unit_fcap.h"
+
+#define FCAP_INTERNAL
+#include "_fcap_internal.h"
+
+// ------------------------------------------------------------------------
+
+enum FcapCmd_ {
+    CMD_STOP = 0,
+    CMD_PWM_CONT_START = 1,
+    CMD_PWM_BURST_START = 2,
+    CMD_PWM_CONT_READ = 10,
+};
+
+/** Handle a request message */
+static error_t UFCAP_handleRequest(Unit *unit, TF_ID frame_id, uint8_t command, PayloadParser *pp)
+{
+    struct priv *priv = unit->data;
+
+    switch (command) {
+        case CMD_STOP:
+            UFCAP_SwitchMode(unit, OPMODE_IDLE);
+            return E_SUCCESS;
+
+        case CMD_PWM_CONT_START:
+            if (priv->opmode == OPMODE_PWM_CONT) return E_SUCCESS; // no-op
+            if (priv->opmode != OPMODE_IDLE) return E_BUSY;
+
+            UFCAP_SwitchMode(unit, OPMODE_PWM_CONT);
+            return E_SUCCESS;
+
+        case CMD_PWM_BURST_START:
+            if (priv->opmode != OPMODE_IDLE) return E_BAD_MODE;
+
+            uint16_t count = pp_u16(pp);
+            priv->pwm_burst.n_target = count;
+            priv->request_id = frame_id;
+            UFCAP_SwitchMode(unit, OPMODE_PWM_BURST);
+            return E_SUCCESS;
+
+        case CMD_PWM_CONT_READ:
+            if (priv->opmode != OPMODE_PWM_CONT) {
+                return E_BAD_MODE;
+            }
+            if (priv->pwm_cont.last_period == 0) {
+                return E_BUSY;
+            }
+
+            PayloadBuilder pb = pb_start(unit_tmp512, UNIT_TMP_LEN, NULL);
+            pb_u16(&pb, PLAT_AHB_MHZ);
+            pb_u32(&pb, priv->pwm_cont.last_period);
+            pb_u32(&pb, priv->pwm_cont.last_ontime);
+
+            com_respond_pb(frame_id, MSG_SUCCESS, &pb);
+            return E_SUCCESS;
+
+        default:
+            return E_UNKNOWN_COMMAND;
+    }
+}
+
+// ------------------------------------------------------------------------
+
+/** Frequency capture */
+const UnitDriver UNIT_FCAP = {
+    .name = "FCAP",
+    .description = "Frequency and pulse measurement",
+    // Settings
+    .preInit = UFCAP_preInit,
+    .cfgLoadBinary = UFCAP_loadBinary,
+    .cfgWriteBinary = UFCAP_writeBinary,
+    .cfgLoadIni = UFCAP_loadIni,
+    .cfgWriteIni = UFCAP_writeIni,
+    // Init
+    .init = UFCAP_init,
+    .deInit = UFCAP_deInit,
+    // Function
+    .handleRequest = UFCAP_handleRequest,
+};

units/fcap/unit_fcap.h

@@ -0,0 +1,16 @@
+//
+// Created by MightyPork on 2017/11/25.
+//
+// Digital input unit; single or multiple pin read access on one port (A-F)
+//
+
+#ifndef U_FCAP_H
+#define U_FCAP_H
+
+#include "unit.h"
+
+extern const UnitDriver UNIT_FCAP;
+
+// UU_ prototypes
+
+#endif //U_FCAP_H

units/sipo/_sipo_api.c

@@ -0,0 +1,110 @@
+//
+// Created by MightyPork on 2018/02/03.
+//
+
+#include "platform.h"
+#include "unit_base.h"
+#include "unit_sipo.h"
+
+#define SIPO_INTERNAL
+#include "_sipo_internal.h"
+
+static void send_pulse(bool pol, GPIO_TypeDef *port, uint32_t ll)
+{
+    if (pol) {
+        LL_GPIO_SetOutputPin(port, ll);
+    }
+    else {
+        LL_GPIO_ResetOutputPin(port, ll);
+    }
+
+    __asm_loop(2);
+
+    if (pol) {
+        LL_GPIO_ResetOutputPin(port, ll);
+    }
+    else {
+        LL_GPIO_SetOutputPin(port, ll);
+    }
+}
+
+#pragma GCC push_options
+#pragma GCC optimize ("O2")
+error_t UU_SIPO_Write(Unit *unit, const uint8_t *buffer, uint16_t buflen, uint16_t terminal_data)
+{
+    CHECK_TYPE(unit, &UNIT_SIPO);
+    struct priv *priv = unit->data;
+
+    if (buflen % priv->data_width != 0) {
+        dbg("Buflen %d vs width %d", (int)buflen, (int)priv->data_width);
+        return E_BAD_COUNT; // must be a multiple of the channel count
+    }
+
+    // buffer contains data for the individual data pins, back to back as AAA BBB CCC (whole bytes)
+    const uint8_t data_width = priv->data_width;
+    const uint16_t bytelen = buflen / data_width;
+    const uint16_t mask = priv->data_pins;
+
+    uint8_t offsets[16];
+    for (int i=0; i<16; i++) offsets[i] = (uint8_t) (bytelen * i);
+
+    for (int32_t bn = bytelen - 1; bn >= 0; bn--) {
+        // send the byte
+        for (int32_t i = 0; i < 8; i++) {
+            uint16_t packed = 0;
+            for (int32_t j = data_width - 1; j >= 0; j--) {
+                packed |= (buffer[bn + offsets[j]] >> i) & 1;
+                if (j > 0) packed <<= 1;
+            }
+
+            uint16_t spread = pinmask_spread(packed, mask);
+            priv->data_port->BSRR = spread | (((~spread) & mask) << 16);
+
+            // Shift clock pulse
+            send_pulse(priv->shift_pol, priv->shift_port, priv->shift_ll);
+        }
+    }
+
+    // load the final data - this may be used by some other circuitry or
+    // simply to rest the lines at a defined known level
+    uint16_t spread = pinmask_spread(terminal_data, mask);
+    priv->data_port->BSRR = spread | (((~spread) & mask) << 16);
+
+    send_pulse(priv->store_pol, priv->store_port, priv->store_ll);
+    return E_SUCCESS;
+}
+#pragma GCC pop_options
+
+error_t UU_SIPO_DirectData(Unit *unit, uint16_t data_packed)
+{
+    CHECK_TYPE(unit, &UNIT_SIPO);
+    struct priv *priv = unit->data;
+
+    uint16_t spread = pinmask_spread(data_packed, priv->data_pins);
+    priv->data_port->BSRR = spread | (((~spread) & priv->data_pins) << 16);
+    return E_SUCCESS;
+}
+
+error_t UU_SIPO_DirectClear(Unit *unit)
+{
+    CHECK_TYPE(unit, &UNIT_SIPO);
+    struct priv *priv = unit->data;
+    send_pulse(priv->clear_pol, priv->clear_port, priv->clear_ll);
+    return E_SUCCESS;
+}
+
+error_t UU_SIPO_DirectShift(Unit *unit)
+{
+    CHECK_TYPE(unit, &UNIT_SIPO);
+    struct priv *priv = unit->data;
+    send_pulse(priv->shift_pol, priv->shift_port, priv->shift_ll);
+    return E_SUCCESS;
+}
+
+error_t UU_SIPO_DirectStore(Unit *unit)
+{
+    CHECK_TYPE(unit, &UNIT_SIPO);
+    struct priv *priv = unit->data;
+    send_pulse(priv->store_pol, priv->store_port, priv->store_ll);
+    return E_SUCCESS;
+}

units/sipo/_sipo_init.c

@@ -0,0 +1,126 @@
+//
+// Created by MightyPork on 2018/02/03.
+//
+
+#include "platform.h"
+#include "unit_base.h"
+
+#define SIPO_INTERNAL
+#include "_sipo_internal.h"
+
+/** Allocate data structure and set defaults */
+error_t USIPO_preInit(Unit *unit)
+{
+    struct priv *priv = unit->data = calloc_ck(1, sizeof(struct priv));
+    if (priv == NULL) return E_OUT_OF_MEM;
+
+    priv->store_pname = 'A';
+    priv->store_pnum = 0;
+    priv->store_pol = true;
+
+    priv->shift_pname = 'A';
+    priv->shift_pnum = 1;
+    priv->shift_pol = true;
+
+    priv->clear_pname = 'A';
+    priv->clear_pnum = 2;
+    priv->clear_pol = false;
+
+    priv->data_pname = 'A';
+    priv->data_pins = (1<<3);
+
+    return E_SUCCESS;
+}
+
+/** Finalize unit set-up */
+error_t USIPO_init(Unit *unit)
+{
+    bool suc = true;
+    struct priv *priv = unit->data;
+
+    // --- Parse config ---
+    priv->store_ll = hw_pin2ll(priv->store_pnum, &suc);
+    priv->store_port = hw_port2periph(priv->store_pname, &suc);
+    Resource store_rsc = hw_pin2resource(priv->store_pname, priv->store_pnum, &suc);
+    if (!suc) return E_BAD_CONFIG;
+    TRY(rsc_claim(unit, store_rsc));
+
+    priv->shift_ll = hw_pin2ll(priv->shift_pnum, &suc);
+    priv->shift_port = hw_port2periph(priv->shift_pname, &suc);
+    Resource shift_rsc = hw_pin2resource(priv->shift_pname, priv->shift_pnum, &suc);
+    if (!suc) return E_BAD_CONFIG;
+    TRY(rsc_claim(unit, shift_rsc));
+
+    priv->clear_ll = hw_pin2ll(priv->clear_pnum, &suc);
+    priv->clear_port = hw_port2periph(priv->clear_pname, &suc);
+    Resource clear_rsc = hw_pin2resource(priv->clear_pname, priv->clear_pnum, &suc);
+    if (!suc) return E_BAD_CONFIG;
+    TRY(rsc_claim(unit, clear_rsc));
+
+    // Claim all needed pins
+    TRY(rsc_claim_gpios(unit, priv->data_pname, priv->data_pins));
+    priv->data_port = hw_port2periph(priv->data_pname, &suc);
+
+    // --- Init hardware ---
+
+    priv->data_width = 0;
+    for (int i = 0; i < 16; i++) {
+        if (priv->data_pins & (1 << i)) {
+            uint32_t ll_pin = hw_pin2ll((uint8_t) i, &suc);
+            LL_GPIO_SetPinMode(priv->data_port, ll_pin, LL_GPIO_MODE_OUTPUT);
+            LL_GPIO_SetPinOutputType(priv->data_port, ll_pin, LL_GPIO_OUTPUT_PUSHPULL);
+            LL_GPIO_SetPinSpeed(priv->data_port, ll_pin, LL_GPIO_SPEED_FREQ_HIGH);
+            priv->data_width++;
+        }
+    }
+
+    // Set the initial state - zeros
+    priv->data_port->ODR &= ~priv->data_pins;
+
+
+    // STORE
+    LL_GPIO_SetPinMode(priv->store_port, priv->store_ll, LL_GPIO_MODE_OUTPUT);
+    LL_GPIO_SetPinOutputType(priv->store_port, priv->store_ll, LL_GPIO_OUTPUT_PUSHPULL);
+    LL_GPIO_SetPinSpeed(priv->store_port, priv->store_ll, LL_GPIO_SPEED_FREQ_HIGH);
+
+    if (priv->store_pol)
+        LL_GPIO_ResetOutputPin(priv->store_port, priv->store_ll);
+    else
+        LL_GPIO_SetOutputPin(priv->store_port, priv->store_ll);
+
+    // SHIFT
+    LL_GPIO_SetPinMode(priv->shift_port, priv->shift_ll, LL_GPIO_MODE_OUTPUT);
+    LL_GPIO_SetPinOutputType(priv->shift_port, priv->shift_ll, LL_GPIO_OUTPUT_PUSHPULL);
+    LL_GPIO_SetPinSpeed(priv->shift_port, priv->shift_ll, LL_GPIO_SPEED_FREQ_HIGH);
+
+    if (priv->shift_pol)
+        LL_GPIO_ResetOutputPin(priv->shift_port, priv->shift_ll);
+    else
+        LL_GPIO_SetOutputPin(priv->shift_port, priv->shift_ll);
+
+    // CLEAR
+    LL_GPIO_SetPinMode(priv->clear_port, priv->clear_ll, LL_GPIO_MODE_OUTPUT);
+    LL_GPIO_SetPinOutputType(priv->clear_port, priv->clear_ll, LL_GPIO_OUTPUT_PUSHPULL);
+    LL_GPIO_SetPinSpeed(priv->clear_port, priv->clear_ll, LL_GPIO_SPEED_FREQ_HIGH);
+
+    if (priv->clear_pol)
+        LL_GPIO_ResetOutputPin(priv->clear_port, priv->clear_ll);
+    else
+        LL_GPIO_SetOutputPin(priv->clear_port, priv->clear_ll);
+
+    // initial clear
+    UU_SIPO_DirectClear(unit);
+
+    return E_SUCCESS;
+}
+
+
+/** Tear down the unit */
+void USIPO_deInit(Unit *unit)
+{
+    // Release all resources, deinit pins
+    rsc_teardown(unit);
+
+    // Free memory
+    free_ck(unit->data);
+}

units/sipo/_sipo_internal.h

@@ -0,0 +1,121 @@
+//
+// Created by MightyPork on 2018/02/03.
+//
+
+#ifndef GEX_F072_SIPO_INTERNAL_H
+#define GEX_F072_SIPO_INTERNAL_H
+
+#ifndef SIPO_INTERNAL
+#error bad include!
+#endif
+
+#include "unit_base.h"
+
+/** Private data structure */
+struct priv {
+    // settings
+    char    store_pname;
+    uint8_t store_pnum;
+    bool    store_pol;   //!< Store pulse active edge
+
+    char    shift_pname;
+    uint8_t shift_pnum;
+    bool    shift_pol;   //!< Shift clock active edge
+
+    char    clear_pname;
+    uint8_t clear_pnum;
+    bool    clear_pol;   //!< Clear signal active level
+
+    char     data_pname;
+    uint16_t data_pins;
+
+    // live fields
+    uint32_t store_ll;
+    uint32_t shift_ll;
+    uint32_t clear_ll;
+
+    GPIO_TypeDef *store_port;
+    GPIO_TypeDef *shift_port;
+    GPIO_TypeDef *clear_port;
+    GPIO_TypeDef *data_port;
+
+    uint8_t data_width;
+};
+
+/** Allocate data structure and set defaults */
+error_t USIPO_preInit(Unit *unit);
+
+/** Load from a binary buffer stored in Flash */
+void USIPO_loadBinary(Unit *unit, PayloadParser *pp);
+
+/** Write to a binary buffer for storing in Flash */
+void USIPO_writeBinary(Unit *unit, PayloadBuilder *pb);
+
+// ------------------------------------------------------------------------
+
+/** Parse a key-value pair from the INI file */
+error_t USIPO_loadIni(Unit *unit, const char *key, const char *value);
+
+/** Generate INI file section for the unit */
+void USIPO_writeIni(Unit *unit, IniWriter *iw);
+
+// ------------------------------------------------------------------------
+
+/** Finalize unit set-up */
+error_t USIPO_init(Unit *unit);
+
+/** Tear down the unit */
+void USIPO_deInit(Unit *unit);
+
+// ------------------------------------------------------------------------
+
+/**
+ * Write a buffer to the pins.
+ * Buffer contains data for the individual channels, sequentially (AAAAAA BBBBBB CCCCCC ...)
+ * The bytes are sent LSB first, from the last byte (e.g. 1,2,3 - 3 is sent first, LSB-first).
+ *
+ * The chunks order is from the lowest to the highest bit
+ *
+ * @param unit
+ * @param buffer - buffer of data to send
+ * @param buflen - number of bytes in the buffer
+ * @param terminal_data - data to set before sending the store pulse (final data lines state, will not appear in the SIPOs)
+ * @return success
+ */
+error_t UU_SIPO_Write(Unit *unit, const uint8_t *buffer, uint16_t buflen, uint16_t terminal_data);
+
+/**
+ * Direct access to the output data pins (may be useful for debugging, or circuits that use them
+ * for something else when not loading a new value).
+ *
+ * @param unit
+ * @param data_packed - packed data to set on the output (right-aligned, highest to lowest pin)
+ * @return success
+ */
+error_t UU_SIPO_DirectData(Unit *unit, uint16_t data_packed);
+
+/**
+ * Send a clear pulse.
+ *
+ * @param unit
+ * @return success
+ */
+error_t UU_SIPO_DirectClear(Unit *unit);
+
+/**
+ * Send a shift pulse.
+ *
+ * @param unit
+ * @return success
+ */
+error_t UU_SIPO_DirectShift(Unit *unit);
+
+/**
+ * Send a store pulse.
+ *
+ * @param unit
+ * @return success
+ */
+error_t UU_SIPO_DirectStore(Unit *unit);
+
+#endif //GEX_F072_SIPO_INTERNAL_H

units/sipo/_sipo_settings.c

@@ -0,0 +1,122 @@
+//
+// Created by MightyPork on 2018/02/03.
+//
+
+#include "platform.h"
+#include "unit_base.h"
+
+#define SIPO_INTERNAL
+#include "_sipo_internal.h"
+
+/** Load from a binary buffer stored in Flash */
+void USIPO_loadBinary(Unit *unit, PayloadParser *pp)
+{
+    struct priv *priv = unit->data;
+
+    uint8_t version = pp_u8(pp);
+    (void)version;
+
+    priv->store_pname = pp_char(pp);
+    priv->store_pnum = pp_u8(pp);
+    priv->store_pol = pp_bool(pp);
+
+    priv->shift_pname = pp_char(pp);
+    priv->shift_pnum = pp_u8(pp);
+    priv->shift_pol = pp_bool(pp);
+
+    priv->clear_pname = pp_char(pp);
+    priv->clear_pnum = pp_u8(pp);
+    priv->clear_pol = pp_bool(pp);
+
+    priv->data_pname = pp_char(pp);
+    priv->data_pins = pp_u16(pp);
+}
+
+/** Write to a binary buffer for storing in Flash */
+void USIPO_writeBinary(Unit *unit, PayloadBuilder *pb)
+{
+    struct priv *priv = unit->data;
+
+    pb_u8(pb, 0); // version
+
+    pb_char(pb, priv->store_pname);
+    pb_u8(pb, priv->store_pnum);
+    pb_bool(pb, priv->store_pol);
+
+    pb_char(pb, priv->shift_pname);
+    pb_u8(pb, priv->shift_pnum);
+    pb_bool(pb, priv->shift_pol);
+
+    pb_char(pb, priv->clear_pname);
+    pb_u8(pb, priv->clear_pnum);
+    pb_bool(pb, priv->clear_pol);
+
+    pb_char(pb, priv->data_pname);
+    pb_u16(pb, priv->data_pins);
+}
+
+// ------------------------------------------------------------------------
+
+/** Parse a key-value pair from the INI file */
+error_t USIPO_loadIni(Unit *unit, const char *key, const char *value)
+{
+    bool suc = true;
+    struct priv *priv = unit->data;
+
+    if (streq(key, "store-pin")) {
+        suc = parse_pin(value, &priv->store_pname, &priv->store_pnum);
+    }
+    else if (streq(key, "shift-pin")) {
+        suc = parse_pin(value, &priv->shift_pname, &priv->shift_pnum);
+    }
+    else if (streq(key, "clear-pin")) {
+        suc = parse_pin(value, &priv->clear_pname, &priv->clear_pnum);
+    }
+
+    else if (streq(key, "store-pol")) {
+        priv->store_pol = (bool) avr_atoi(value);
+    }
+    else if (streq(key, "shift-pol")) {
+        priv->shift_pol = (bool) avr_atoi(value);
+    }
+    else if (streq(key, "clear-pol")) {
+        priv->clear_pol = (bool) avr_atoi(value);
+    }
+
+    else if (streq(key, "data-port")) {
+        suc = parse_port_name(value, &priv->data_pname);
+    }
+    else if (streq(key, "data-pins")) {
+        priv->data_pins = (uint16_t) parse_pinmask(value, &suc);
+    }
+
+    else {
+        return E_BAD_KEY;
+    }
+
+    if (!suc) return E_BAD_VALUE;
+    return E_SUCCESS;
+}
+
+/** Generate INI file section for the unit */
+void USIPO_writeIni(Unit *unit, IniWriter *iw)
+{
+    struct priv *priv = unit->data;
+
+    iw_comment(iw, "Shift pin & its active edge (1-rising,0-falling)");
+    iw_entry(iw, "shift-pin", "%c%d", priv->shift_pname,  priv->shift_pnum);
+    iw_entry(iw, "shift-pol", "%d", priv->shift_pol);
+
+    iw_comment(iw, "Store pin & its active edge");
+    iw_entry(iw, "store-pin", "%c%d", priv->store_pname,  priv->store_pnum);
+    iw_entry(iw, "store-pol", "%d", priv->store_pol);
+
+    iw_comment(iw, "Clear pin & its active level");
+    iw_entry(iw, "clear-pin", "%c%d", priv->clear_pname,  priv->clear_pnum);
+    iw_entry(iw, "clear-pol", "%d", priv->clear_pol);
+
+    iw_comment(iw, "Data port and pins");
+    iw_entry(iw, "data-port", "%c", priv->data_pname);
+    iw_entry(iw, "data-pins", "%s", pinmask2str_up(priv->data_pins, unit_tmp512));
+}
+

units/sipo/unit_sipo.c

@@ -0,0 +1,73 @@
+//
+// Created by MightyPork on 2017/11/25.
+//
+
+#include "unit_base.h"
+#include "unit_sipo.h"
+
+#define SIPO_INTERNAL
+
+#include "_sipo_internal.h"
+
+// ------------------------------------------------------------------------
+
+enum SipoCmd_ {
+    CMD_WRITE = 0,
+    CMD_DIRECT_DATA = 1,
+    CMD_DIRECT_SHIFT = 2,
+    CMD_DIRECT_CLEAR = 3,
+    CMD_DIRECT_STORE = 4,
+};
+
+/** Handle a request message */
+static error_t USIPO_handleRequest(Unit *unit, TF_ID frame_id, uint8_t command, PayloadParser *pp)
+{
+    switch (command) {
+        case CMD_WRITE:
+            {
+                uint32_t len;
+                uint16_t terminal_packed = pp_u16(pp);
+                const uint8_t *tail = pp_tail(pp, &len);
+                TRY(UU_SIPO_Write(unit, (uint8_t *) tail, (uint16_t) len, terminal_packed));
+            }
+            return E_SUCCESS;
+
+        case CMD_DIRECT_DATA:
+            TRY(UU_SIPO_DirectData(unit, pp_u16(pp)));
+            return E_SUCCESS;
+
+        case CMD_DIRECT_CLEAR:
+            TRY(UU_SIPO_DirectClear(unit));
+            return E_SUCCESS;
+
+        case CMD_DIRECT_SHIFT:
+            TRY(UU_SIPO_DirectShift(unit));
+            return E_SUCCESS;
+
+        case CMD_DIRECT_STORE:
+            TRY(UU_SIPO_DirectStore(unit));
+            return E_SUCCESS;
+
+        default:
+            return E_UNKNOWN_COMMAND;
+    }
+}
+
+// ------------------------------------------------------------------------
+
+/** Unit template */
+const UnitDriver UNIT_SIPO = {
+    .name = "SIPO",
+    .description = "Shift register driver (595, 4094)",
+    // Settings
+    .preInit = USIPO_preInit,
+    .cfgLoadBinary = USIPO_loadBinary,
+    .cfgWriteBinary = USIPO_writeBinary,
+    .cfgLoadIni = USIPO_loadIni,
+    .cfgWriteIni = USIPO_writeIni,
+    // Init
+    .init = USIPO_init,
+    .deInit = USIPO_deInit,
+    // Function
+    .handleRequest = USIPO_handleRequest,
+};

units/sipo/unit_sipo.h

@@ -0,0 +1,16 @@
+//
+// Created by MightyPork on 2017/11/25.
+//
+// Digital input unit; single or multiple pin read access on one port (A-F)
+//
+
+#ifndef U_SIPO_H
+#define U_SIPO_H
+
+#include "unit.h"
+
+extern const UnitDriver UNIT_SIPO;
+
+// UU_ prototypes
+
+#endif //U_SIPO_H

utils/error.h

@@ -28,6 +28,7 @@
     X(CHECKSUM_MISMATCH, NULL) /* bus checksum failed */ \
     X(PROTOCOL_BREACH, NULL)   /* eating with the wrong spoon */  \
     X(BUSY, NULL)              /* Unit is busy */ \
+    X(BAD_MODE, NULL)        /* Command not permissible in current opmode */ \
     \
     /* VFS user errors (those are meant to be shown to user) */ \
     X(VFS_ERROR_DURING_TRANSFER, "Error during transfer") \

utils/ini_writer.c

@@ -119,9 +119,10 @@ void iw_entry(IniWriter *iw, const char *key, const char *format, ...)
     iw_newline(iw);	// one newline after entry
 }
 
-uint32_t iw_measure_total(void (*handler)(IniWriter *))
+uint32_t iw_measure_total(void (*handler)(IniWriter *), uint32_t tag)
 {
     IniWriter iw = iw_init(NULL, 0xFFFFFFFF, 1);
+    iw.tag = tag;
     iw_begin();
     handler(&iw);
     iw_end();

utils/ini_writer.h

@@ -18,6 +18,7 @@ typedef struct iniwriter_ {
     char *ptr;
     uint32_t skip;
     uint32_t count;
+    uint32_t tag; // general purpose field (used to identify for which purpose is the file being read)
 } IniWriter;
 
 /**
@@ -43,7 +44,7 @@ void iw_end(void);
  * @param count - number of bytes to write, truncate rest
  * @return structure initializer
  */
-#define iw_init(buffer, skip, count) (IniWriter){buffer, skip, count}
+#define iw_init(xbuffer, xskip, xcount) (IniWriter){.ptr=(xbuffer), .skip=(xskip), .count=(xcount)}
 
 /**
  * Try to write a buffer to the file
@@ -131,6 +132,6 @@ void iw_entry(IniWriter *iw, const char *key, const char *format, ...)
  * @param handler - function that normally writes to the writer
  * @return byte count
  */
-uint32_t iw_measure_total(void (*handler)(IniWriter *));
+uint32_t iw_measure_total(void (*handler)(IniWriter *), uint32_t tag);
 
 #endif //INIWRITER_H

vfs/vfs_user.c

@@ -73,9 +73,9 @@ void vfs_user_build_filesystem(void)
     // Setup the filesystem based on target parameters
     vfs_init(daplink_drive_name, 0/*unused "disk size"*/);
 
-    vfs_create_file("UNITS   INI", read_file_units_ini, NULL, iw_measure_total(settings_build_units_ini));
+    vfs_create_file("UNITS   INI", read_file_units_ini, NULL, iw_measure_total(settings_build_units_ini, 0));
-    vfs_create_file("SYSTEM  INI", read_file_system_ini, NULL, iw_measure_total(settings_build_system_ini));
+    vfs_create_file("SYSTEM  INI", read_file_system_ini, NULL, iw_measure_total(settings_build_system_ini, 0));
-    vfs_create_file("PINOUT  TXT", read_file_pinout_txt, NULL, iw_measure_total(settings_build_pinout_txt));
+    vfs_create_file("PINOUT  TXT", read_file_pinout_txt, NULL, iw_measure_total(settings_build_pinout_txt, 0));
 }