/home/andref/projetos/epos--/src/abstraction/alarm.cc

// EPOS-- Alarm Abstraction Implementation

// This work is licensed under the Creative Commons
// Attribution-NonCommercial-NoDerivs License. To view a copy of this license,
// visit http://creativecommons.org/licenses/by-nc-nd/2.0/ or send a letter to
// Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

#include <alarm.h>
#include <display.h>


__BEGIN_SYS

// Class attributes
Timer Alarm::_timer;
volatile Timer::Tick Alarm::_elapsed;
Alarm::Handler Alarm::_master;
Timer::Tick Alarm::_masterTicks = 1;
Alarm::AlarmQueue Alarm::_requests;
Alarm::HandlerQueue Alarm::_handlerQueue;
Thread *Alarm::_alarmThread;

// Methods

int Alarm::alarmLoop() {
        _alarmThread = Thread::running();

        while (true) {
                Handler h = NULL;

                DISABLE_SCHED {
                        if (!_handlerQueue.empty()) {
                                h = *_handlerQueue.remove()->object();
                        }
                        else {
                                _alarmThread->suspend();
                                continue;
                        }
                }
                if (h) h();
        }

        return 0;
}

Alarm::~Alarm() {
        db<Alarm>(TRC) << "~Alarm()\n";
        _requests.remove(this);
}

Alarm::Alarm(const RTC::Microseconds & time, int times,
                Handler handler) : _times(times), _link(this),
                _sem(0), _handler(handler), _handlerLink(&_handler) {

        _ticks = (time + period() / 2) / period();
        if (_ticks && _times) {
                _requests.insert(&_link);
        }
}

Alarm::Alarm(const RTC::Microseconds& time, int times)
                        : _times(times), _link(this), _sem(0),
                        _handler(NULL), _handlerLink(&_handler) {

        _ticks = (time + period() / 2) / period();
        db<Alarm>(TRC) << "Alarm t=" << time /*<< ",h=" << (void *)handler*/
        << ",x=" << times << ",ticks=" << _ticks << endl;
        if (_ticks && times) {
                _requests.insert(&_link);
        }
        db<Alarm>(TRC) << "Alarm r=" << _link.rank() << " " << _ticks << endl;
}


void Alarm::master(const RTC::Microseconds& time, const Handler& handler) {
        db<Alarm>(TRC) << "master(t=" << time << ",h="
        << (void *)handler << ")\n";

        _master = handler;
        _masterTicks = (time + period() / 2) / period();
}

void Alarm::wait() {
        if (_times) 
                _sem.p();
}

void Alarm::delay(const RTC::Microseconds& time) {
        db<Alarm>(TRC) << "delay(t=" << time << ")\n";
        Alarm alarm(time, SINGLE_TIME);
        alarm.wait();
        db<Alarm>(TRC) << "exiting from delay" << endl;
}

void Alarm::timerHandler(void) {
        static Timer::Tick next = 1;
        static Semaphore* sem = 0;

        ++_elapsed;

        if (Traits<Alarm>::visible) {
                Display display;
                int lin, col;
                display.position(&lin, &col);
                display.position(0, 79);
                display.putc(_elapsed);
                display.position(lin, col);
        }

        if (!(_elapsed % _masterTicks))
                _master();


        if (next)
                --next;
        else if (!_requests.empty()) {
                if (sem) sem->freeResources();

                AlarmQueue::Element* e = _requests.remove();
                Alarm* alarm = e->object();
                next = alarm->_ticks;
                alarm->_times--;
                if (alarm->_times) {
                        _requests.insert(e);
                }
                sem = &alarm->_sem;

                if (alarm->_handlerLink.object()) {
                        _handlerQueue.insert(&alarm->_handlerLink);
                        _alarmThread->resume();
                }
        }
}

__END_SYS

---