Christopher Haster / events

Note! This project has moved to github.com/armmbed/mbed-events

Dependents:   SimpleHTTPExample

This repository has been superceded

This project has moved to mbed-events

Composable event loops combine the cheap synchronicity of event loops with the composability of preempted threads.

Two modular event queue classes are provided:

  • EventLoop - for loops coupled with a c++ managed thread
  • EventQueue - for manually managed event queues

The Event class takes advantage of the extensibility of FuncPtr to allow an event to be passed through APIs as a normal function.

More information on composable event loops.

EventLoop.cpp

Committer:
Christopher Haster
Date:
2016-05-10
Revision:
14:5abf2ccf2dbf
Parent:
8:3c2a014bd907
Child:
16:ff5d48fcce1b

File content as of revision 14:5abf2ccf2dbf:

#include "EventLoop.h"

#ifndef EVENTS_NO_RTOS

using namespace rtos;

EventLoop::EventLoop(osPriority priority,
                     unsigned event_count,
                     unsigned event_context,
                     uint32_t stack_size,
                     unsigned char *stack_pointer)
        : EventQueue(event_count, event_context) {
    _running = false;
    _priority = priority;
    _stack_size = stack_size;
    _stack_pointer = stack_pointer;
}

EventLoop::EventLoop(bool start,
                     osPriority priority,
                     unsigned event_count,
                     unsigned event_context,
                     uint32_t stack_size,
                     unsigned char *stack_pointer)
        : EventQueue(event_count, event_context) {
    _running = false;
    _priority = priority;
    _stack_size = stack_size;
    _stack_pointer = stack_pointer;

    if (start) {
        EventLoop::start();
    }
}

EventLoop::~EventLoop() {
    stop();
}

void EventLoop::start() {
    if (_running) {
        return;
    }

    _running = true;
    _thread = new Thread(run, this, _priority, _stack_size, _stack_pointer);
}

void EventLoop::stop() {
    if (!_running) {
        return;
    }

    Thread *thread = _thread;
    _thread = 0;

    _running = false;
    while (thread->get_state() != Thread::Inactive) {
        Thread::yield();
    }

    delete thread;
}

void EventLoop::run(const void *p) {
    EventLoop *loop = (EventLoop *)p;

    while (loop->_running) {
        loop->dispatch(0);
        Thread::yield();
    }
}

#endif