Ejemplo n.º 1
0
//------------------------------------------------------------------------------
static tOplkError setupNmtTimerEvent(UINT32 timeout_p, tNmtEvent event_p)
{
    tOplkError      ret;
    tTimerArg       timerArg;

    timeout_p = timeout_p / 1000; // convert us into ms
    if (timeout_p == 0)  // timer was below one ms -> set one ms
        timeout_p = 1;
    timerArg.eventSink = kEventSinkNmtk;
    timerArg.argument.value = (UINT32)event_p;
    ret = timeru_modifyTimer(&nmtuInstance_g.timerHdl, (ULONG)timeout_p, timerArg);
    return ret;
}
//------------------------------------------------------------------------------
static tOplkError changeMode(tLeduMode newMode_p)
{
    tOplkError      ret;
    tLeduMode       oldMode;
    tTimerArg       timerArg;
    UINT32          timeout;
    BOOL            fLedOn;

    ret = kErrorOk;

    oldMode = leduInstance_g.statusLedMode;

    if (oldMode != newMode_p)
    {   // state changed -> save new mode
        leduInstance_g.statusLedMode = newMode_p;

        // Where are we coming from?
        if (oldMode == kLeduModeOff)
        {   // status LED was off -> switch LED on
            fLedOn = TRUE;
            leduInstance_g.statusLedState = 0xFF;
        }
        else if (oldMode == kLeduModeOn)
        {   // status LED was on -> switch LED off
            fLedOn = FALSE;
            leduInstance_g.statusLedState = 0;
        }
        else
        {   // timer should be up and running
            return ret;
        }

        // select timeout corresponding to mode
        switch (newMode_p)
        {
            case kLeduModeFlickering:
                timeout = LEDU_DURATION_FLICKERING;
                break;

            case kLeduModeBlinking:
                timeout = LEDU_DURATION_BLINKING;
                break;

            case kLeduModeSingleFlash:
            case kLeduModeDoubleFlash:
            case kLeduModeTripleFlash:
                if (fLedOn == FALSE)
                    timeout = LEDU_DURATION_FLASH_OFF;
                else
                    timeout = LEDU_DURATION_FLASH_ON;
                break;

            default:
                return ret;      // should not occur
                break;
        }

        // create new timer
        timerArg.eventSink = kEventSinkLedu;
        leduInstance_g.timerArg++;
        timerArg.argument.value = leduInstance_g.timerArg;
        ret = timeru_modifyTimer(&leduInstance_g.timerHdlLedBlink,
                                 timeout,
                                 timerArg);

        // call callback function
        ret = callStateChanged(kLedTypeStatus, fLedOn);
    }
    return ret;
}
//------------------------------------------------------------------------------
tOplkError ledu_processEvent(tEvent* pEvent_p)
{
    tOplkError          ret;
    tTimerArg           timerArg;
    UINT32              timeout = 0;
    BOOL                fLedOn = FALSE;
    tTimerEventArg*     pTimerEventArg;

    ret = kErrorOk;

    switch (pEvent_p->eventType)
    {
        // timer event
        case kEventTypeTimer:
            pTimerEventArg = (tTimerEventArg*)pEvent_p->pEventArg;

            if (pTimerEventArg->argument.value != leduInstance_g.timerArg)
            {   // zombie timer, ignore it
                break;
            }

            leduInstance_g.statusLedState++;

            // select timeout and new LED state corresponding to mode
            switch (leduInstance_g.statusLedMode)
            {
                case kLeduModeInit:
                case kLeduModeOn:
                case kLeduModeOff:
                    goto Exit;      // should not occur
                    break;

                case kLeduModeFlickering:
                    if (leduInstance_g.statusLedState >= 2)
                    {   // reset state
                        leduInstance_g.statusLedState = 0;
                        fLedOn = FALSE;
                    }
                    else
                    {
                        fLedOn = TRUE;
                    }
                    timeout = LEDU_DURATION_FLICKERING;
                    break;

                case kLeduModeBlinking:
                    if (leduInstance_g.statusLedState >= 2)
                    {   // reset state
                        leduInstance_g.statusLedState = 0;
                        fLedOn = FALSE;
                    }
                    else
                    {
                        fLedOn = TRUE;
                    }
                    timeout = LEDU_DURATION_BLINKING;
                    break;

                case kLeduModeSingleFlash:
                    if (leduInstance_g.statusLedState >= 2)
                    {   // reset state
                        leduInstance_g.statusLedState = 0;
                        timeout = LEDU_DURATION_FLASH_OFF;
                        fLedOn = FALSE;
                    }
                    else
                    {
                        timeout = LEDU_DURATION_FLASH_ON;
                        fLedOn = ((leduInstance_g.statusLedState & 0x01) != 0x00)
                            ? TRUE : FALSE;
                    }
                    break;

                case kLeduModeDoubleFlash:
                    if (leduInstance_g.statusLedState >= 4)
                    {   // reset state
                        leduInstance_g.statusLedState = 0;
                        timeout = LEDU_DURATION_FLASH_OFF;
                        fLedOn = FALSE;
                    }
                    else
                    {
                        timeout = LEDU_DURATION_FLASH_ON;
                        fLedOn = ((leduInstance_g.statusLedState & 0x01) != 0x00)
                            ? TRUE : FALSE;
                    }
                    break;

                case kLeduModeTripleFlash:
                    if (leduInstance_g.statusLedState >= 6)
                    {   // reset state
                        leduInstance_g.statusLedState = 0;
                        timeout = LEDU_DURATION_FLASH_OFF;
                        fLedOn = FALSE;
                    }
                    else
                    {
                        timeout = LEDU_DURATION_FLASH_ON;
                        fLedOn = ((leduInstance_g.statusLedState & 0x01) != 0x00)
                            ? TRUE : FALSE;
                    }
                    break;
            }

            // create new timer
            timerArg.eventSink = kEventSinkLedu;
            leduInstance_g.timerArg++;
            timerArg.argument.value = leduInstance_g.timerArg;
            ret = timeru_modifyTimer(&leduInstance_g.timerHdlLedBlink, timeout, timerArg);

            // call callback function
            ret = callStateChanged(kLedTypeStatus, fLedOn);
            break;

        default:
            ret = kErrorNmtInvalidEvent;
    }

Exit:
    return ret;
}