typedef struct event_t
{
    const char* const name;
    void* value;
} event_t;

typedef void (*handler_t)(const void* const old_value, const void* const new_value);
typedef struct event_handler_t
{
    const event_t* const event;
    const handler_t handler;
} event_handler_t;

void event_notify(const event_t* const event, const void* const old_value, const void* const new_value);

/* Events generator */

#define __DECLARE_EVENT(_name, _type, _default_value, _event, _value_t, _value, _set, _get) \
                                                                                            \
    typedef _type _value_t;                                                                 \
                                                                                            \
    _value_t _value __attribute__((weak)) = _default_value;                                 \
                                                                                            \
    event_t _event __attribute__((weak, section(".events"))) = {                            \
        .name = #_name,                                                                     \
        .value = &_value,                                                                   \
    };                                                                                      \
                                                                                            \
    __attribute__((weak)) void _set(_type value)                                            \
    {                                                                                       \
        event_notify(&_event, &_value, &value);                                             \
        _value = value;                                                                     \
    }                                                                                       \
                                                                                            \
    __attribute__((weak)) _type _get(void)                                                  \
    {                                                                                       \
        return _value;                                                                      \
    }

#define DECLARE_EVENT(_name, _type, _default_value) \
    __DECLARE_EVENT(                                \
        _name,                                      \
        _type,                                      \
        _default_value,                             \
        CONCAT_N(__, _name, _event),                \
        CONCAT_N(__, _name, _value_t),              \
        CONCAT_N(__, _name, _value),                \
        CONCAT_N(_name, _set),                      \
        CONCAT_N(_name, _get))

#define __EVENT_SUBSCRIBE(_event, _handler, _wrapper, _list, _value_t)                            \
    __attribute__((weak)) void _wrapper(const void* const old_value, const void* const new_value) \
    {                                                                                             \
        _handler((const _value_t* const)old_value, (const _value_t* const)new_value);             \
    }                                                                                             \
                                                                                                  \
    event_handler_t _list __attribute__((weak, section(".event_handlers"))) = {                   \
        .event = &_event,                                                                         \
        .handler = _wrapper                                                                       \
    }

#define EVENT_SUBSCRIBE(_name, _handler)          \
    __EVENT_SUBSCRIBE(                            \
        CONCAT_N(__, _name, _event),              \
        _handler,                                 \
        CONCAT_N(__, _name, _wrapper_, __LINE__), \
        CONCAT_N(__, _name, _list_, __LINE__),    \
        CONCAT_N(__, _name, _value_t))

extern const event_t __events_start[];
extern const event_t __events_end[];

extern const event_handler_t __event_handlers_start[];
extern const event_handler_t __event_handlers_end[];

void event_notify(const event_t* const event, const void* const old_value, const void* const new_value)
{
    /* cppcheck-suppress comparePointers */
    for (const event_handler_t* event_handler = __event_handlers_start; event_handler < __event_handlers_end; event_handler++)
        if (event_handler->event == event)
            event_handler->handler(old_value, new_value);
}

SECTION_DATA_PROLOGUE(.events,,)
{
    __events_start = .;
    KEEP(*(SORT(.events*)));
    __events_end = .;
} GROUP_ROM_LINK_IN(RAMABLE_REGION, ROMABLE_REGION)

SECTION_DATA_PROLOGUE(.event_handlers,,)
{
    __event_handlers_start = .;
    KEEP(*(SORT(.event_handlers*)));
    __event_handlers_end = .;
} GROUP_ROM_LINK_IN(RAMABLE_REGION, ROMABLE_REGION)

DECLARE_EVENT(analog_output, volts_t, volts_0);

void analog_output_event_handler(const volts_t* const old, const volts_t* const new)
{
    uint32_t pulse_width = volts_to_int(volts_mul(volts_from_int(PWM_PD0_OC0A.period / 10), *new));


    int ret = pwm_set_pulse_dt(&PWM_PD0_OC0A, pulse_width);
    if (ret)
    {
        LOG_ERROR("Error %d: failed to set pulse width\n", ret);
    }
}

EVENT_SUBSCRIBE(analog_output, analog_output_event_handler);

            analog_output_set(volts_from_fraction(registers[i], 1000));

adb push PATH/application /home/root   // src --> dst
adb shell
cd /home/root                               
chmod +x application_name    // права за executable
./application                // старт