sequencer.h

Go to the documentation of this file.

#ifndef SEQUENCER_HEADER_GUARD
#define SEQUENCER_HEADER_GUARD
 
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

enum sequencer_mode {
        SEQUENCER_MODE_SINGLE, 
        SEQUENCER_MODE_REPEAT, 
 
        SEQUENCER_MODES 
};

struct sequencer_entry {
        uint16_t timer_ms; 
        uint16_t event;       
};

struct sequencer {
        struct sequencer_entry *_entries;
        size_t                  _capacity;
        size_t                  _len;
 
        size_t _iter;
 
        uint16_t _timer_ms;
 
        uint8_t _mode;
};
 
/*--------------------------------------------------------------- PUBLIC API */
void sequencer_init(struct sequencer *self, struct sequencer_entry *entries,
                    size_t capacity);

void sequencer_set_mode(struct sequencer *self, uint8_t mode);

bool sequencer_add_entry(struct sequencer *self, uint16_t timer_ms,
                         uint8_t event);

size_t sequencer_get_entry_count(struct sequencer *self);

void sequencer_reset(struct sequencer *self);

void sequencer_clean(struct sequencer *self);

uint16_t sequencer_update(struct sequencer *self, uint16_t delta_time_ms);
/*---------------------------------------------------------------------------*/
 
#ifdef SEQUENCER_IMPLEMENTATION
void sequencer_init(struct sequencer *self, struct sequencer_entry *entries,
                    size_t capacity)
{
        assert(self && entries && (capacity > 0u));
 
        self->_entries  = entries;
        self->_capacity = capacity;
        self->_len      = 0u;
 
        self->_iter = 0u;
 
        self->_timer_ms = 0u;
 
        self->_mode = SEQUENCER_MODE_SINGLE;
}
 
void sequencer_set_mode(struct sequencer *self, uint8_t mode)
{
        assert(self && (mode < (uint8_t)SEQUENCER_MODES));
 
        self->_mode = mode;
}
 
bool sequencer_add_entry(struct sequencer *self, uint16_t timer_ms,
                         uint8_t event)
{
        bool has_capacity = true;
 
        assert(self);
 
        if (self->_len >= self->_capacity) {
                has_capacity = false;
        } else {
                struct sequencer_entry *entry = &self->_entries[self->_len];
 
                entry->timer_ms  = timer_ms;
                entry->event        = event;
                self->_len      += 1u;
        }
 
        return has_capacity;
}
 
size_t sequencer_get_entry_count(struct sequencer *self)
{
        assert(self);
 
        return self->_len;
}
 
void sequencer_reset(struct sequencer *self)
{
        assert(self);
 
        self->_iter     = 0u;
        self->_timer_ms = 0u;
}
 
void sequencer_clean(struct sequencer *self)
{
        assert(self);
 
        sequencer_reset(self);
 
        self->_len = 0u;
}
 
uint16_t sequencer_update(struct sequencer *self, uint16_t delta_time_ms)
{
        uint8_t event = 0u;
 
        assert(self);
 
        /* If last element */
        if (self->_iter >= self->_len) {
                /* And mode is REPEAT*/
                if (self->_mode == (uint8_t)SEQUENCER_MODE_REPEAT) {
                        /* Repeat the sequence */
                        self->_iter = 0u;
                } else {
                        /* Else cleanup */
                        sequencer_clean(self);
                }
        }
 
        /* If we have elements in sequence */
        if (self->_iter < self->_len) {
                struct sequencer_entry *entry = &self->_entries[self->_iter];
 
                self->_timer_ms += delta_time_ms;
 
                /* Wait for timer to exceed */
                if (self->_timer_ms >= entry->timer_ms) {
                        self->_timer_ms -= entry->timer_ms;
                        self->_iter     += 1u;
 
                        /* and emit event */
                        event = entry->event;
                }
        }
 
        return event;
}
#endif /* SEQUENCER_IMPLEMENTATION */
 
#endif /* SEQUENCER_HEADER_GUARD */