/**
 * @brief  Creates a new custom timer which has 1ms resolution
 * @note   It uses @ref malloc for memory allocation for timer structure
 * @param  ReloadValue: Number of milliseconds when timer reaches zero and callback function is called
 * @param  AutoReloadCmd: If set to 1, timer will start again when it reaches zero and callback is called
 * @param  StartTimer: If set to 1, timer will start immediately
 * @param  *TM_DELAY_CustomTimerCallback: Pointer to callback function which will be called when timer reaches zero
 * @param  *UserParameters: Pointer to void pointer to user parameters used as first parameter in callback function
 * @retval Pointer to allocated timer structure
 */
TM_DELAY_Timer_t* TM_DELAY_TimerCreate(uint32_t ReloadValue, uint8_t AutoReloadCmd, uint8_t StartTimer, void (*TM_DELAY_CustomTimerCallback)(struct _TM_DELAY_Timer_t*, void *), void* UserParameters);

TM_DELAY_Timer_t* TM_DELAY_TimerCreate(uint32_t ReloadValue, uint8_t AutoReloadCmd, uint8_t StartTimer, void (*TM_DELAY_CustomTimerCallback)(struct _TM_DELAY_Timer_t*, void *), void* UserParameters) {
    TM_DELAY_Timer_t* tmp;
    
    /* Check if available */
    if (CustomTimers.Count >= DELAY_MAX_CUSTOM_TIMERS) {
        return NULL;
    }
    
    /* Try to allocate memory for timer structure */
    tmp = (TM_DELAY_Timer_t *) LIB_ALLOC_FUNC(sizeof(TM_DELAY_Timer_t));
    
    /* Check if allocated */
    if (tmp == NULL) {
        return NULL;
    }
    
    /* Fill settings */
    tmp->ARR = ReloadValue;
    tmp->CNT = tmp->ARR;
    tmp->Flags.F.AREN = AutoReloadCmd;
    tmp->Flags.F.CNTEN = StartTimer;
    tmp->Callback = TM_DELAY_CustomTimerCallback;
    tmp->UserParameters = UserParameters;
    
    /* Increase number of timers in memory */
    CustomTimers.Timers[CustomTimers.Count++] = tmp;
    
    /* Return pointer to user */
    return tmp;
}

typedef struct _TM_DELAY_Timer_t {
    union {
        struct {            
            uint8_t AREN:1;  /*!< Auto-reload enabled */
            uint8_t CNTEN:1; /*!< Count enabled */
        } F;
        uint8_t FlagsVal;
    } Flags;
    uint32_t ARR;                                        /*!< Auto reload value */
    uint32_t CNT;                                        /*!< Counter value, counter counts down */
    void (*Callback)(struct _TM_DELAY_Timer_t*, void *); /*!< Callback which will be called when timer reaches zero */
    void* UserParameters;                                /*!< Pointer to user parameters used for callback function */
} TM_DELAY_Timer_t;

TM_DELAY_Timer_t timer;

void testTimer(void)
{
    LED_RED_TOGGLE();
}

TM_DELAY_TimerCreate(250, 1, 1, ffff, pppp);

struct douche {
    enum douche_state state;
    TM_DELAY_Timer_t pump_timer; // вкладена структура, не вказівник!
    TM_DELAY_Timer_t timeout;    // вкладена структура, не вказівник!
    uint8_t water_level;
    // що там ще треба
};
 
struct douche douche1;

void pump_timer_func(TM_DELAY_Timer_t *t)
{
    // Від адреси таймера t віднімаємо зміщення від початку структури
    // struct douche до початку її поля pump_timer. Отримуємо адресу
    // екземпляра структури, у якому лежить цей екземпляр таймера.
    struct douche *d = container_of(t, struct douche, pump_timer);
    switch (d->state) {
    case pump_off:
        pump_power_on();
        timer_start(t, pump_on_time);
        d->state = pump_on;
        break;
    // ...
    }
}

void timeout_func(TM_DELAY_Timer_t *t)
{
    struct douche *d = container_of(t, struct douche, timeout);
    switch (d->state) {
    case pump_on:
        pump_power_off();
        disable_timer(&d->pump_timer);
        d->state = pump_off;
        break;
    // ...
    }
}

// ... 
// а у douche2 інші адреси таймерів всередині цієї структури, бо інша початкова
// адреса самої структури, тому плутанини не буде
// до речі, '&' перед іменем функції геть не обов'язковий (я б навіть сказав, що надлишковий)
    timer_init(&douche1.pump_timer, pump_timer_func);
    timer_init(&douche1.timeout, timeout_func);

    timer_start(&douche1.timeout, 300); // ну чи там як.

char bufStr[64];
sprintf(bufStr, "WARNING voltage %s %f", voltageStruct->name, voltageStruct->voltage);
logerUART(bufStr);

sprintf(bufStr, "WARNING voltage %s", voltageStruct->name);