Code: Publisher-Subscriber eventloop

[Felix P. (zirias)]

Ich bin gerade an meinem ersten Projekt mit einem Mikrocontroller, eine 
Rolladensteuerung. Schnell habe ich festgestellt, dass ich einen 
Interrupt in an sich nicht miteinander in Verbindung stehenden 
Programmteilen brauche. Da ich eigentlich eher aus dem Bereich 
Software-Engineering komme wollte ich eine Lösung, die die logische 
Kapselung erhält.

Ich stelle hier mal meinen Code vor aus zwei Gründen: Erstens natürlich, 
um Kommentare zu erhalten von Leuten mit Erfahrung. Der Code läuft in 
simavr, aber vielleicht ist ja trotzdem etwas ungünstig oder 
verbesserungswürdig. Und zweitens, vielleicht ist es ja sogar nützlich 
für jemanden.

Ideen dahinter:

- Eine zentrale Queue mit Events.
- Struktur der Events simpel genug, dass sie problemlos in einer ISR 
erstellt werden können (in meinem Fall gerade mal 2 Bytes)
- Eine Funktion um Events auch in Software zu generieren (meine 
Software-Timer nutzen das auf Basis des TICK events).
- Event-Handler, die registriert werden können
- Timer ticks nur bei Bedarf (wenn ein Handler für das TICK event 
registriert ist)

Verwendung:

event_init();
[...]
ein paar events registrieren mit event_register(...)
[...]
event_loop(); <- kehrt nie zurück.


event.h:

#ifndef EVENT_H
#define EVENT_H

#include "common.h"

/* Maximum queued up events, if more events stay unhandled, the buffer is
 * cleared and events are lost */
#define EVQUEUESIZE 16

/* Number of event types. Must be increased when using EV_CUSTOM or defining
 * own EV_* constants in order to reserve space for registered handlers */
#define NUMEVTYPES 3

/* Maximum number of handlers registered per event type */
#define MAXEVHANDLERS 4

typedef struct event event;
typedef enum ev_type
{
    EV_TICK      = 0,
    EV_PINCHANGE    = 1,
    EV_TIMER      = 2,
    EV_CUSTOM      = 3
} ev_type;

struct event
{
    ev_type type;
    uint8_t data;
};

typedef void (*ev_handler)(const event *ev, void *data);
typedef BOOL (*ev_filter)(const event *ev, ev_handler handler, void *data);

void event_init(void);

void event_raise(ev_type type, uint8_t ev_data);

BOOL event_register(ev_type type, ev_handler handler,
  ev_filter filter, void *data);
BOOL event_unregister(ev_type type, ev_handler handler, void *data);

void event_loop(void) __attribute__((__noreturn__));

#endif

event.c:

#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <avr/io.h>

static event equeue[EVQUEUESIZE];
volatile static uint8_t eqhead = 0;
static uint8_t eqtail = 0;

static uint8_t ticksEnabled = 0;

typedef struct evhdl_record
{
    ev_handler handler;
    ev_filter filter;
    void *data;
} evhdl_record;

typedef struct evhdl_vector
{
    uint8_t nhandlers;
    evhdl_record handlers[MAXEVHANDLERS];
} evhdl_vector;

static evhdl_vector handlervector[NUMEVTYPES];

void event_init(void)
{
    /* configure interrupts: */
    GIMSK |= _BV(PCIE1);
    PCMSK1 |= _BV(PCINT8) | _BV(PCINT9) | _BV(PCINT10);
    TIMSK1 |= _BV(OCIE1A);

    /* power management, disable unused stuff: */
    PRR |= _BV(PRTIM1) | _BV(PRTIM0) | _BV(PRUSI) | _BV(PRADC);
    MCUCR &= ~(_BV(BODS) | _BV(BODSE));
    MCUCR |= _BV(BODS);
    MCUCR &= ~_BV(BODSE);
    set_sleep_mode(SLEEP_MODE_PWR_SAVE);
    sleep_enable();
}

void event_raise(ev_type type, uint8_t ev_data)
{
    cli();
    equeue[eqhead].type = type;
    equeue[eqhead].data = ev_data;
    if (++eqhead == EVQUEUESIZE) eqhead = 0;
    sei();
}

static void enableTicks(void)
{
    if (ticksEnabled++) return;
    PRR &= ~_BV(PRTIM1);
    GTCCR |= _BV(TSM) | _BV(PSR10);
//  TCCR1B = _BV(WGM12) | _BV(CS10) | _BV(CS11); /* CTC, 8MHz / 64 */
    TCCR1B = _BV(WGM12) | _BV(CS11); /* CTC, 1MHz / 8 */
    OCR1A = 1250; /* 10 ms */
    TCNT1 = 0;
    GTCCR &= ~_BV(TSM);
}

static void disableTicks(void)
{
    if (ticksEnabled && --ticksEnabled) return;
    GTCCR |= _BV(TSM) | _BV(PSR10);
    TCCR1B &= ~(_BV(CS10) | _BV(CS11) | _BV(CS12));
    GTCCR &= ~_BV(TSM);
    PRR |= _BV(PRTIM1);
}

BOOL event_register(ev_type type, ev_handler handler,
        ev_filter filter, void *data)
{
    for (uint8_t i = 0; i < MAXEVHANDLERS; ++i)
    {
        if (handlervector[type].handlers[i].handler)
        {
            if (handlervector[type].handlers[i].handler == handler
                    && handlervector[type].handlers[i].data == data)
            {
                handlervector[type].handlers[i].filter = filter;
                return TRUE;
            }
            continue;
        }
        handlervector[type].handlers[i].handler = handler;
        handlervector[type].handlers[i].filter = filter;
        handlervector[type].handlers[i].data = data;
        ++handlervector[type].nhandlers;
        if (type == EV_TICK) enableTicks();
        return TRUE;
    }
    return FALSE;
}

BOOL event_unregister(ev_type type, ev_handler handler, void *data)
{
    for (uint8_t i = 0; i < MAXEVHANDLERS; ++i)
    {
        if (handlervector[type].handlers[i].handler != handler
                || handlervector[type].handlers[i].data != data)
        {
            continue;
        }
        handlervector[type].handlers[i].handler = 0;
        --handlervector[type].nhandlers;
        if (type == EV_TICK) disableTicks();
        return TRUE;
    }
    return FALSE;
}

ISR(PCINT1_vect)
{
    equeue[eqhead].type = EV_PINCHANGE;
    equeue[eqhead].data = PINB;
    if (++eqhead == EVQUEUESIZE) eqhead = 0;
}

ISR(TIM1_COMPA_vect)
{
    equeue[eqhead].type = EV_TICK;
    if (++eqhead == EVQUEUESIZE) eqhead = 0;
}

void event_loop(void)
{
    sei();
    while (1)
    {
        /* run event queue */
        while (eqtail != eqhead)
        {
            event *ev = &(equeue[eqtail]);
            evhdl_vector *v = &(handlervector[ev->type]);
            if (v->nhandlers)
            {
                for (uint8_t i = 0; i < MAXEVHANDLERS; ++i)
                {
                    if (!(v->handlers[i].handler)) continue;
                    if (!(v->handlers[i].filter) ||
                            v->handlers[i].filter(ev,
                                v->handlers[i].handler, v->handlers[i].data))
                    {
                        v->handlers[i].handler(ev, v->handlers[i].data);
                    }
                }
            }
            if (++eqtail == EVQUEUESIZE) eqtail = 0;
        }

        /* sleep if no more events are pending and no timer tick enabled */
        cli();
        if (eqtail == eqhead && !ticksEnabled)
        {
            sei();
            __asm__ volatile("sleep");
        }
        else sei();
    }
    UNREACHABLE();
}

Der Code nutzt #defines aus common.h:

#ifndef COMMON_H
#define COMMON_H

#include <stdint.h>

#ifndef __GNUC__
#define __attribute__(x)
#define UNREACHABLE()
#else
#define UNREACHABLE() __builtin_unreachable()
#endif

typedef uint8_t BOOL;
#define TRUE 1
#define FALSE 0

#endif

Je nachdem, was man damit tun will, muss natürlich event_init() sowie 
enableTicks() und disableTicks() angepasst werden. Das hier ist für 
einen attinyx4 bei dem Eingänge auf PORTB überwacht werden. Der 
komplette Code liegt auf github: 
https://github.com/Zirias/shuttercontrol/tree/master/shutterctl_attiny84

Ich bin gespannt auf Kommentare und Verbesserungsvorschläge.

*edit*: Eine erste Verbesserung, die originale Version hatte eine kleine 
race condition wenn ein Interrupt genau vor dem "sleep" kam.

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Hallo Felix,
zwei Gedanken:

1) Oft sind die subscribten Empfänger ja relativ statisch. Sprich in der 
Initialisierung einer Applikation wird ein handler etabliert. Da könnte 
man auf die Idee kommen, dass es eine zweite Liste mit Handler geben 
könnte, die nicht im kostbaren RAM stehen muss. 1.1) Was soll ich 
machen, wenn event_register() false zurück gibt? Gerade im Fall, dass 
die subscriptions eher statischer Natur sind, wird der Fehler immer oder 
nie auftreten. Meiner Meinung nach eher ein Anwendungsfall für asserts.

2) Ein Beispiel sagt mehr als 1000 Worte. Hast Du ein Beispiel, an dem 
Du zeigen kannst, dass die Verwendung Deiner Lib einen erkennbaren 
Vorteil (z.B. Lesbarkeit) bringt?

mfg Torsten

P.S: Gibt es Unit-Tests?

[Felix P. (zirias)]

Hallo Torsten,

vielen Dank, ich habe jetzt lange nicht reingeschaut und gar nicht 
gemerkt, dass doch jemand geantwortet hat! Deine Anregungen aus deinem 
Punkt 1 sind sehr nützlich für mich, und sobald ich wieder Zeit finde 
für mein Projekt werde ich sie berücksichtigen -- hier sieht man eben, 
dass "embedded" nicht meine Kernkompetenz ist sondern ich damit ganz neu 
anfange, ich muss mich erst an den Gedanken gewöhnen, daraufhin zu 
optimieren, dass letztenendes die komplette Software sehr statisch ist.

Was das Beispiel angeht -- da es zunächst nur für mich war ist das 
Beispiel der benutzende Code im Github repository ;) Aber vielleicht 
würde es sich wirklich lohnen, minimale Beispiele zu bauen, um weiteres 
Verbesserungspotential aufzudecken.

Unit Tests gibt es bisher auch keine, hauptsächlich weil ich mich noch 
nicht mit entsprechenden Frameworks für C beschäftigt habe. Kannst du 
mir da etwas empfehlen?

Danke und Grüße,
Felix

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Hi Felix,

Felix P. schrieb:
> Unit Tests gibt es bisher auch keine, hauptsächlich weil ich mich noch
> nicht mit entsprechenden Frameworks für C beschäftigt habe. Kannst du
> mir da etwas empfehlen?

ne, ich mach eher nur C++. Aber im Fred nebenan tauchen ja vielleicht 
noch gute Tipps auf: 
http://www.mikrocontroller.net/topic/goto_post/4262902

mfg Torsten