qf_time.c

Go to the documentation of this file.

//$file${src::qf::qf_time.c} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
//
// Model: qpc.qm
// File:  ${src::qf::qf_time.c}
//
// This code has been generated by QM 7.0.0 <www.state-machine.com/qm>.
// DO NOT EDIT THIS FILE MANUALLY. All your changes will be lost.
//
// Copyright (C) 2005 Quantum Leaps, LLC. All rights reserved.
//
//                    Q u a n t u m  L e a P s
//                    ------------------------
//                    Modern Embedded Software
//
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-QL-commercial
//
// The QP/C software is dual-licensed under the terms of the open-source GNU
// General Public License (GPL) or under the terms of one of the closed-
// source Quantum Leaps commercial licenses.
//
// Redistributions in source code must retain this top-level comment block.
// Plagiarizing this software to sidestep the license obligations is illegal.
//
// NOTE:
// The GPL does NOT permit the incorporation of this code into proprietary
// programs. Please contact Quantum Leaps for commercial licensing options,
// which expressly supersede the GPL and are designed explicitly for
// closed-source distribution.
//
// Quantum Leaps contact information:
// <www.state-machine.com/licensing>
// <info@state-machine.com>
//
//$endhead${src::qf::qf_time.c} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#define QP_IMPL           // this is QP implementation
#include "qp_port.h"      // QP port
#include "qp_pkg.h"       // QP package-scope interface
#include "qsafe.h"        // QP Functional Safety (FuSa) Subsystem
#ifdef Q_SPY              // QS software tracing enabled?
    #include "qs_port.h"  // QS port
    #include "qs_pkg.h"   // QS facilities for pre-defined trace records
#else
    #include "qs_dummy.h" // disable the QS software tracing
#endif // Q_SPY
 
Q_DEFINE_THIS_MODULE("qf_time")
 
//$skip${QP_VERSION} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
// Check for the minimum required QP version
#if (QP_VERSION < 730U) || (QP_VERSION != ((QP_RELEASE^4294967295U)%0x2710U))
#error qpc version 7.3.0 or higher required
#endif
//$endskip${QP_VERSION} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//$define${QF::QTimeEvt} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
 
//${QF::QTimeEvt} ............................................................
QTimeEvt QTimeEvt_timeEvtHead_[QF_MAX_TICK_RATE];
 
#ifndef Q_UNSAFE
uintptr_t QTimeEvt_timeEvtHead_dis_[QF_MAX_TICK_RATE];
#endif // ndef Q_UNSAFE
 
//${QF::QTimeEvt::ctorX} .....................................................
//! @public @memberof QTimeEvt
void QTimeEvt_ctorX(QTimeEvt * const me,
    QActive * const act,
    enum_t const sig,
    uint_fast8_t const tickRate)
{
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    Q_REQUIRE_INCRIT(300, (sig != 0)
        && (tickRate < QF_MAX_TICK_RATE));
    QF_CRIT_EXIT();
 
    QEvt_ctor(&me->super, sig);
 
    me->next     = (QTimeEvt *)0;
    me->act      = act;
    me->ctr      = 0U;
    me->interval = 0U;
    me->tickRate = (uint8_t)tickRate;
    me->flags    = 0U;
 
    #ifndef Q_UNSAFE
    me->next_dis = (uintptr_t)~Q_PTR2UINT_CAST_(me->next);
    me->ctr_dis  = (QTimeEvtCtr)~me->ctr;
    #endif // ndef Q_UNSAFE
}
 
//${QF::QTimeEvt::armX} ......................................................
//! @public @memberof QTimeEvt
void QTimeEvt_armX(QTimeEvt * const me,
    uint32_t const nTicks,
    uint32_t const interval)
{
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    QF_MEM_SYS();
 
    // dynamic range checks
    #if (QF_TIMEEVT_CTR_SIZE == 1U)
    Q_REQUIRE_INCRIT(400, (nTicks < 0xFFU) && (interval < 0xFFU));
    #elif (QF_TIMEEVT_CTR_SIZE == 2U)
    Q_REQUIRE_INCRIT(400, (nTicks < 0xFFFFU) && (interval < 0xFFFFU));
    #endif
 
    #ifndef Q_UNSAFE
    Q_INVARIANT_INCRIT(401, QEvt_verify_(&me->super));
    #endif
 
    QTimeEvtCtr const ctr = me->ctr;
    uint8_t const tickRate = me->tickRate;
    #ifdef Q_SPY
    uint_fast8_t const qsId = ((QActive *)(me->act))->prio;
    #endif
 
    Q_REQUIRE_INCRIT(410,
        (nTicks != 0U)
        && (ctr == 0U)
        && (me->act != (void *)0)
        && (tickRate < (uint_fast8_t)QF_MAX_TICK_RATE));
 
    #ifndef Q_UNSAFE
    QTimeEvtCtr const dis = (QTimeEvtCtr)~me->ctr_dis;
    Q_INVARIANT_INCRIT(411, ctr == dis);
    #else
    Q_UNUSED_PAR(ctr);
    #endif // ndef Q_UNSAFE
 
    me->ctr = (QTimeEvtCtr)nTicks;
    me->interval = (QTimeEvtCtr)interval;
    #ifndef Q_UNSAFE
    me->ctr_dis = (QTimeEvtCtr)~nTicks;
    #endif // ndef Q_UNSAFE
 
    // is the time event unlinked?
    // NOTE: For the duration of a single clock tick of the specified tick
    // rate a time event can be disarmed and yet still linked into the list
    // because un-linking is performed exclusively in QTimeEvt_tick_().
    if ((me->flags & QTE_FLAG_IS_LINKED) == 0U) {
        me->flags |= QTE_FLAG_IS_LINKED; // mark as linked
 
        // The time event is initially inserted into the separate "freshly
        // armed" link list based on QTimeEvt_timeEvtHead_[tickRate].act.
        // Only later, inside the QTimeEvt_tick_() function, the "freshly
        // armed" list is appended to the main list of armed time events
        // based on QTimeEvt_timeEvtHead_[tickRate].next. Again, this is
        // to keep any changes to the main list exclusively inside the
        // QTimeEvt_tick_().
    #ifndef Q_UNSAFE
        Q_INVARIANT_INCRIT(420,
            Q_PTR2UINT_CAST_(me->next) == (uintptr_t)~me->next_dis);
        Q_INVARIANT_INCRIT(421,
            Q_PTR2UINT_CAST_(QTimeEvt_timeEvtHead_[tickRate].act) ==
                (uintptr_t)(~QTimeEvt_timeEvtHead_dis_[tickRate]));
    #endif
        me->next = (QTimeEvt *)QTimeEvt_timeEvtHead_[tickRate].act;
        QTimeEvt_timeEvtHead_[tickRate].act = me;
    #ifndef Q_UNSAFE
        me->next_dis = (uintptr_t)~Q_PTR2UINT_CAST_(me->next);
        QTimeEvt_timeEvtHead_dis_[tickRate] = (uintptr_t)~Q_PTR2UINT_CAST_(me);
    #endif // ndef Q_UNSAFE
    }
 
    QS_BEGIN_PRE(QS_QF_TIMEEVT_ARM, qsId)
        QS_TIME_PRE();        // timestamp
        QS_OBJ_PRE(me);       // this time event object
        QS_OBJ_PRE(me->act);  // the active object
        QS_TEC_PRE(nTicks);   // the # ticks
        QS_TEC_PRE(interval); // the interval
        QS_U8_PRE(tickRate);  // tick rate
    QS_END_PRE()
 
    QF_MEM_APP();
    QF_CRIT_EXIT();
}
 
//${QF::QTimeEvt::disarm} ....................................................
//! @public @memberof QTimeEvt
bool QTimeEvt_disarm(QTimeEvt * const me) {
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    QF_MEM_SYS();
 
    QTimeEvtCtr const ctr = me->ctr;
 
    #ifndef Q_UNSAFE
    Q_INVARIANT_INCRIT(500, QEvt_verify_(&me->super));
    QTimeEvtCtr const dis = (QTimeEvtCtr)~me->ctr_dis;
    Q_INVARIANT_INCRIT(501, ctr == dis);
    #endif // ndef Q_UNSAFE
 
    #ifdef Q_SPY
    uint_fast8_t const qsId = QACTIVE_CAST_(me->act)->prio;
    #endif
 
    // was the time event actually armed?
    bool wasArmed;
    if (ctr != 0U) {
        wasArmed = true;
        me->flags |= QTE_FLAG_WAS_DISARMED;
        me->ctr = 0U; // schedule removal from the list
    #ifndef Q_UNSAFE
        me->ctr_dis = (QTimeEvtCtr)~0U;
    #endif // ndef Q_UNSAFE
 
        QS_BEGIN_PRE(QS_QF_TIMEEVT_DISARM, qsId)
            QS_TIME_PRE();            // timestamp
            QS_OBJ_PRE(me);           // this time event object
            QS_OBJ_PRE(me->act);      // the target AO
            QS_TEC_PRE(ctr);          // the # ticks
            QS_TEC_PRE(me->interval); // the interval
            QS_U8_PRE(me->tickRate);  // tick rate
        QS_END_PRE()
    }
    else { // the time event was already disarmed automatically
        wasArmed = false;
        me->flags &= (uint8_t)(~QTE_FLAG_WAS_DISARMED & 0xFFU);
 
        QS_BEGIN_PRE(QS_QF_TIMEEVT_DISARM_ATTEMPT, qsId)
            QS_TIME_PRE();            // timestamp
            QS_OBJ_PRE(me);           // this time event object
            QS_OBJ_PRE(me->act);      // the target AO
            QS_U8_PRE(me->tickRate);  // tick rate
        QS_END_PRE()
    }
 
    QF_MEM_APP();
    QF_CRIT_EXIT();
 
    return wasArmed;
}
 
//${QF::QTimeEvt::rearm} .....................................................
//! @public @memberof QTimeEvt
bool QTimeEvt_rearm(QTimeEvt * const me,
    uint32_t const nTicks)
{
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    QF_MEM_SYS();
 
    // dynamic range checks
    #if (QF_TIMEEVT_CTR_SIZE == 1U)
    Q_REQUIRE_INCRIT(600, nTicks < 0xFFU);
    #elif (QF_TIMEEVT_CTR_SIZE == 2U)
    Q_REQUIRE_INCRIT(600, nTicks < 0xFFFFU);
    #endif
 
    uint8_t const tickRate = me->tickRate;
    QTimeEvtCtr const ctr = me->ctr;
 
    Q_REQUIRE_INCRIT(600,
        (nTicks != 0U)
        && (me->act != (void *)0)
        && (tickRate < QF_MAX_TICK_RATE));
 
    #ifndef Q_UNSAFE
    Q_INVARIANT_INCRIT(601, QEvt_verify_(&me->super));
    QTimeEvtCtr const dis = (QTimeEvtCtr)~me->ctr_dis;
    Q_INVARIANT_INCRIT(602, ctr == dis);
    #endif // ndef Q_UNSAFE
 
    #ifdef Q_SPY
    uint_fast8_t const qsId = ((QActive *)(me->act))->prio;
    #endif
 
    me->ctr = (QTimeEvtCtr)nTicks;
    #ifndef Q_UNSAFE
    me->ctr_dis = (QTimeEvtCtr)~nTicks;
    #endif // ndef Q_UNSAFE
 
    // was the time evt not running?
    bool wasArmed;
    if (ctr == 0U) {
        wasArmed = false;
 
        // NOTE: For the duration of a single clock tick of the specified
        // tick rate a time event can be disarmed and yet still linked into
        // the list, because unlinking is performed exclusively in the
        // QTimeEvt_tick_() function.
 
        // is the time event unlinked?
        if ((me->flags & QTE_FLAG_IS_LINKED) == 0U) {
            me->flags |= QTE_FLAG_IS_LINKED; // mark as linked
 
            // The time event is initially inserted into the separate "freshly
            // armed" link list based on QTimeEvt_timeEvtHead_[tickRate].act.
            // Only later, inside the QTimeEvt_tick_() function, the "freshly
            // armed" list is appended to the main list of armed time events
            // based on QTimeEvt_timeEvtHead_[tickRate].next. Again, this is
            // to keep any changes to the main list exclusively inside
            // QTimeEvt_tick_().
    #ifndef Q_UNSAFE
        Q_INVARIANT_INCRIT(620,
            Q_PTR2UINT_CAST_(me->next) == (uintptr_t)~me->next_dis);
        Q_INVARIANT_INCRIT(621,
            Q_PTR2UINT_CAST_(QTimeEvt_timeEvtHead_[tickRate].act) ==
                (uintptr_t)(~QTimeEvt_timeEvtHead_dis_[tickRate]));
    #endif
            me->next = (QTimeEvt *)QTimeEvt_timeEvtHead_[tickRate].act;
            QTimeEvt_timeEvtHead_[tickRate].act = me;
    #ifndef Q_UNSAFE
            me->next_dis = (uintptr_t)~Q_PTR2UINT_CAST_(me->next);
            QTimeEvt_timeEvtHead_dis_[tickRate] =
                (uintptr_t)~Q_PTR2UINT_CAST_(me);
    #endif // ndef Q_UNSAFE
        }
    }
    else { // the time event was armed
        wasArmed = true;
    }
 
    QS_BEGIN_PRE(QS_QF_TIMEEVT_REARM, qsId)
        QS_TIME_PRE();            // timestamp
        QS_OBJ_PRE(me);           // this time event object
        QS_OBJ_PRE(me->act);      // the target AO
        QS_TEC_PRE(nTicks);       // the # ticks
        QS_TEC_PRE(me->interval); // the interval
        QS_2U8_PRE(tickRate, (wasArmed ? 1U : 0U));
    QS_END_PRE()
 
    QF_MEM_APP();
    QF_CRIT_EXIT();
 
    return wasArmed;
}
 
//${QF::QTimeEvt::wasDisarmed} ...............................................
//! @public @memberof QTimeEvt
bool QTimeEvt_wasDisarmed(QTimeEvt * const me) {
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    QF_MEM_SYS();
 
    bool const wasDisarmed = (me->flags & QTE_FLAG_WAS_DISARMED) != 0U;
    me->flags |= QTE_FLAG_WAS_DISARMED; // mark as disarmed
 
    QF_MEM_APP();
    QF_CRIT_EXIT();
 
    return wasDisarmed;
}
 
//${QF::QTimeEvt::currCtr} ...................................................
//! @public @memberof QTimeEvt
QTimeEvtCtr QTimeEvt_currCtr(QTimeEvt const * const me) {
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    QTimeEvtCtr const ctr = me->ctr;
    QF_CRIT_EXIT();
 
    return ctr;
}
 
//${QF::QTimeEvt::init} ......................................................
//! @static @private @memberof QTimeEvt
void QTimeEvt_init(void) {
    for (uint_fast8_t tickRate = 0U;
         tickRate < Q_DIM(QTimeEvt_timeEvtHead_);
         ++tickRate)
    {
        QTimeEvt_ctorX(&QTimeEvt_timeEvtHead_[tickRate],
                       (QActive *)0, Q_USER_SIG, tickRate);
    #ifndef Q_UNSAFE
        QTimeEvt_timeEvtHead_dis_[tickRate] =
            (uintptr_t)~Q_PTR2UINT_CAST_(QTimeEvt_timeEvtHead_[tickRate].act);
    #endif
    }
}
 
//${QF::QTimeEvt::tick_} .....................................................
//! @static @private @memberof QTimeEvt
void QTimeEvt_tick_(
    uint_fast8_t const tickRate,
    void const * const sender)
{
    #ifndef Q_SPY
    Q_UNUSED_PAR(sender);
    #endif
 
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    QF_MEM_SYS();
 
    Q_REQUIRE_INCRIT(800, tickRate < Q_DIM(QTimeEvt_timeEvtHead_));
 
    QTimeEvt *prev = &QTimeEvt_timeEvtHead_[tickRate];
 
    QS_BEGIN_PRE(QS_QF_TICK, 0U)
        ++prev->ctr;
        QS_TEC_PRE(prev->ctr);   // tick ctr
        QS_U8_PRE(tickRate);     // tick rate
    QS_END_PRE()
 
    // scan the linked-list of time events at this rate...
    uint_fast8_t lbound = 2U*QF_MAX_ACTIVE; // fixed upper loop bound
    for (; lbound > 0U; --lbound) {
        Q_ASSERT_INCRIT(810, prev != (QTimeEvt *)0); // sanity check
 
        QTimeEvt *te = prev->next; // advance down the time evt. list
    #ifndef Q_UNSAFE
        Q_INVARIANT_INCRIT(811,
            Q_PTR2UINT_CAST_(te) == (uintptr_t)~prev->next_dis);
    #endif // ndef Q_UNSAFE
 
        if (te == (QTimeEvt *)0) { // end of the list?
 
            // any new time events armed since the last QTimeEvt_tick_()?
            if (QTimeEvt_timeEvtHead_[tickRate].act != (void *)0) {
    #ifndef Q_UNSAFE
                Q_INVARIANT_INCRIT(812,
                    Q_PTR2UINT_CAST_(QTimeEvt_timeEvtHead_[tickRate].act)
                    == (uintptr_t)~QTimeEvt_timeEvtHead_dis_[tickRate]);
    #endif // ndef Q_UNSAFE
                prev->next = (QTimeEvt*)QTimeEvt_timeEvtHead_[tickRate].act;
                QTimeEvt_timeEvtHead_[tickRate].act = (void *)0;
    #ifndef Q_UNSAFE
                prev->next_dis = (uintptr_t)~Q_PTR2UINT_CAST_(prev->next);
                QTimeEvt_timeEvtHead_dis_[tickRate] =
                    (uintptr_t)~Q_PTR2UINT_CAST_((void *)0);
    #endif // ndef Q_UNSAFE
 
                te = prev->next; // switch to the new list
            }
            else { // all currently armed time events are processed
                break; // terminate the for-loop
            }
        }
 
        // the time event 'te' must be valid
        Q_ASSERT_INCRIT(820, te != (QTimeEvt *)0);
 
        QTimeEvtCtr ctr = te->ctr;
    #ifndef Q_UNSAFE
        Q_INVARIANT_INCRIT(821, QEvt_verify_(&te->super));
        QTimeEvtCtr const dis = (QTimeEvtCtr)~te->ctr_dis;
        Q_INVARIANT_INCRIT(822, ctr == dis);
    #endif // ndef Q_UNSAFE
 
        if (ctr == 0U) { // time event scheduled for removal?
            prev->next = te->next;
    #ifndef Q_UNSAFE
            prev->next_dis = (uintptr_t)~Q_PTR2UINT_CAST_(te->next);
    #endif // ndef Q_UNSAFE
 
            // mark time event 'te' as NOT linked
            te->flags &= (uint8_t)(~QTE_FLAG_IS_LINKED & 0xFFU);
 
            // do NOT advance the prev pointer
            QF_MEM_APP();
            QF_CRIT_EXIT(); // exit crit. section to reduce latency
 
            // NOTE: prevent merging critical sections
            // In some QF ports the critical section exit takes effect only
            // on the next machine instruction. If the next instruction is
            // another entry to a critical section, the critical section
            // might not be really exited, but rather the two adjacent
            // critical sections would be MERGED. The QF_CRIT_EXIT_NOP()
            // macro contains minimal code required to prevent such merging
            // of critical sections in QF ports, in which it can occur.
            QF_CRIT_EXIT_NOP();
        }
        else if (ctr == 1U) { // is time event about to expire?
            QActive * const act = (QActive *)te->act;
            if (te->interval != 0U) { // periodic time evt?
                te->ctr = te->interval; // rearm the time event
    #ifndef Q_UNSAFE
                te->ctr_dis = (QTimeEvtCtr)~te->interval;
    #endif // ndef Q_UNSAFE
                prev = te; // advance to this time event
            }
            else { // one-shot time event: automatically disarm
                te->ctr = 0U;
                prev->next = te->next;
    #ifndef Q_UNSAFE
                te->ctr_dis = (QTimeEvtCtr)~0U;
                prev->next_dis = (uintptr_t)~Q_PTR2UINT_CAST_(te->next);
    #endif // ndef Q_UNSAFE
 
                // mark time event 'te' as NOT linked
                te->flags &= (uint8_t)(~QTE_FLAG_IS_LINKED & 0xFFU);
                // do NOT advance the prev pointer
 
                QS_BEGIN_PRE(QS_QF_TIMEEVT_AUTO_DISARM, act->prio)
                    QS_OBJ_PRE(te);       // this time event object
                    QS_OBJ_PRE(act);      // the target AO
                    QS_U8_PRE(tickRate);  // tick rate
                QS_END_PRE()
            }
 
            QS_BEGIN_PRE(QS_QF_TIMEEVT_POST, act->prio)
                QS_TIME_PRE();            // timestamp
                QS_OBJ_PRE(te);           // the time event object
                QS_SIG_PRE(te->super.sig);// signal of this time event
                QS_OBJ_PRE(act);          // the target AO
                QS_U8_PRE(tickRate);      // tick rate
            QS_END_PRE()
 
    #ifdef QXK_H_
            if ((enum_t)te->super.sig < Q_USER_SIG) {
                QXThread_timeout_(act);
                QF_MEM_APP();
                QF_CRIT_EXIT();
            }
            else {
                QF_MEM_APP();
                QF_CRIT_EXIT(); // exit crit. section before posting
 
                // QACTIVE_POST() asserts if the queue overflows
                QACTIVE_POST(act, &te->super, sender);
            }
    #else
            QF_MEM_APP();
            QF_CRIT_EXIT(); // exit crit. section before posting
 
            // QACTIVE_POST() asserts if the queue overflows
            QACTIVE_POST(act, &te->super, sender);
    #endif
        }
        else { // time event keeps timing out
            --ctr; // decrement the tick counter
            te->ctr = ctr; // update the original
    #ifndef Q_UNSAFE
            te->ctr_dis = (QTimeEvtCtr)~ctr;
    #endif // ndef Q_UNSAFE
 
            prev = te; // advance to this time event
 
            QF_MEM_APP();
            QF_CRIT_EXIT(); // exit crit. section to reduce latency
 
            // prevent merging critical sections, see NOTE above
            QF_CRIT_EXIT_NOP();
        }
        QF_CRIT_ENTRY(); // re-enter crit. section to continue the loop
        QF_MEM_SYS();
    }
 
    Q_ENSURE_INCRIT(890, lbound > 0U);
    QF_MEM_APP();
    QF_CRIT_EXIT();
}
 
//${QF::QTimeEvt::noActive} ..................................................
//! @static @public @memberof QTimeEvt
bool QTimeEvt_noActive(uint_fast8_t const tickRate) {
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    Q_REQUIRE_INCRIT(900, tickRate < QF_MAX_TICK_RATE);
    QF_CRIT_EXIT();
 
    bool inactive;
    if (QTimeEvt_timeEvtHead_[tickRate].next != (QTimeEvt *)0) {
        inactive = false;
    }
    else if ((QTimeEvt_timeEvtHead_[tickRate].act != (void *)0)) {
        inactive = false;
    }
    else {
        inactive = true;
    }
    return inactive;
}
//$enddef${QF::QTimeEvt} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^