コード例 #1
0
ファイル: tc11_mutex.c プロジェクト: bnuh/munsailbot
static void taskEntryC0(uint16_t initCondition)
{
    /* A minor problem because of using one function for all tasks: The function needs to
       know, which specific task executes it. We start the task with task-dependent general
       purpose events ant let the function evaluate the parameter to find out. */
    uint8_t idxTask;
    if(initCondition == EVT_START_TASK_T0_C0)
        idxTask = 0;
    else if(initCondition == EVT_START_TASK_T1_C0)
        idxTask = 1;
    else    
    {
        ASSERT(initCondition == EVT_START_TASK_T2_C0);
        idxTask = 2;
    }

    /* Next problem: All tasks using this function use the round robin pattern in order to
       have permament unforeseen task switches. The idle task can set an event to start
       such a task, but then it'll never be activated again. It would fail to activate any
       of the remaining tasks. Therefore, we chain the initial activation: one task
       initiates the next one. */
    if(idxTask == 0)
        rtos_sendEvent(EVT_START_TASK_T1_C0);
    else if(idxTask == 1)
        rtos_sendEvent(EVT_START_TASK_T2_C0);
    
    /* Here, the actual task code begins. The next statement will never return. */
    taskC0(idxTask);
    
} /* End of taskEntryC0 */
コード例 #2
0
ファイル: itq_interTaskQueue.c プロジェクト: bnuh/munsailbot
void itq_writeElem(int16_t queuedElem)
{
    rtos_enterCriticalSection();    
    {
        _ringBuf[_writePos++] = queuedElem;
        
        /* A productive implementation would probably deny writing and return an error
           indication. We don't need such code as it simply is a requirement of our test
           case that an overrun must never happen. */
        ASSERT(_writePos != _readPos);
    }
    rtos_leaveCriticalSection();
    
    /* Only now, after completion of the actual queuing the semaphore is incremented to
       signal the new data to possibly waiting consumer tasks. Queuing and signaling is
       not atomic, we already left the critical section. This is however not dangerous. The
       meaning of the semaphore is not to precisely indicate the number of queued elements
       but to give a guarantee that there's at least one element in case I could acquire
       the semaphore.
         By the way, incrementing the semaphore by a call of rtos_sendEvent implicitly ends
       a critical section. We could implement write and increment as atomic by simply
       omitting the call of rtos_leaveCriticalSection - this would however make the code
       less readable and is useless. */
    rtos_sendEvent(EVT_SEMAPHORE_ELEM_IN_QUEUE);
    
} /* End of itq_writeElem */
コード例 #3
0
static void task01_class00(uint16_t initCondition)

{
    for(;;)
    {
        uint16_t u;

        ++ _noLoopsTask01_C0;

        /* For test purpose only: This task consumes the CPU for about 50% of the cycle
           time. */
        delay(5 /*ms*/);

        /* Release high priority task for a single cycle. It should continue operation
           before we return from the suspend function sendEvent. Check it. */
        u = _noLoopsTask00_C1;
        rtos_sendEvent(/* eventVec */ RTOS_EVT_EVENT_00);
        ASSERT(u+1 == _noLoopsTask00_C1)

        /* Double-check that this task keep in sync with the triggered task of higher
           priority. */
        ASSERT(_noLoopsTask01_C0 == _noLoopsTask00_C1)

        /* This tasks cycles with about 10 ms. This will succeed only if the other task in
           the same priority class does not use lengthy blocking operations. */
        rtos_suspendTaskTillTime(/* deltaTimeTillRelease */ 10 /*ms*/);
    }
} /* End of task01_class00 */
コード例 #4
0
ファイル: tc06_roundRobin.c プロジェクト: bnuh/munsailbot
static void task01_class00(uint16_t initCondition)

{
    uint32_t tiCycle0 = millis();
    for(;;)
    {
        uint16_t u;
        
        ++ _noLoopsTask01_C0;

        /* The next operation (Arduino delay function) takes the demanded world time in ms
           (as opposed to CPU time) even if it is interrupted because of an elapsed round
           robin counter.
             As this task has a round robin time slice of 4 ms, the delay operation will
           surely be interrupted by the other task - which may consume the CPU for up to 20
           ms. The delay operation may thus return after 24 ms. */
        uint32_t ti0 = millis();
        delay(8 /* ms */);
        uint16_t dT = (uint16_t)(millis() - ti0);
        ASSERT(dT >= 7);
        ASSERT(dT <= 25);

        /* Release the high priority task for a single cycle. It should continue operation
           before we leave the suspend function here. Check it. */
        ti0 = millis();
        u = _noLoopsTask00_C1;
        rtos_sendEvent(/* eventVec */ RTOS_EVT_EVENT_00);
        ASSERT(u+1 == _noLoopsTask00_C1)
        ASSERT(_noLoopsTask01_C0 == _noLoopsTask00_C1)
        dT = (uint16_t)(millis() - ti0);
        ASSERT(dT <= 2);
        
        /* The body of this task takes up to about 26 ms (see before). If it suspends here,
           the other round robin task will most often become active and consume the CPU the
           next 20 ms. This tasks wants to cycle with 40 ms. So it'll become due while the
           other round robin task is active. This task will become active only after the
           time slice of the other task has elapsed. Exact cycle time is impossible for
           this task.
             It can even be worse if the other round robin task should be suspendend while
           this task suspends itself till the next multiple of 40 ms: Occasionally, the
           other task will resume just before this task and the activation of this task
           will be delayed by the full time slice duration of the other round robin task.
           Task overruns are unavoidable for this (ir-)regular task, but we can give an
           upper boundary for the cycle time, which is tested by assertion. */
        rtos_suspendTaskTillTime(/* deltaTimeTillRelease */ 20 /* unit 2 ms */);
        uint32_t tiCycleEnd = millis();
        dT = (uint16_t)(tiCycleEnd - tiCycle0);
        tiCycle0 = tiCycleEnd;
        ASSERT(dT <= 62);
    }
} /* End of task01_class00 */
コード例 #5
0
static void blink(uint8_t noFlashes)
{
#define TI_FLASH 150

    while(noFlashes-- > 0)
    {
        digitalWrite(LED, HIGH);  /* Turn the LED on. (HIGH is the voltage level.) */
        delay(TI_FLASH);          /* The flash time. */
        digitalWrite(LED, LOW);   /* Turn the LED off by making the voltage LOW. */
        delay(TI_FLASH);          /* Time between flashes. */

        /* Blink takes many hundreds of milli seconds. To prevent too many timeouts in
           task00_C0 we post the event also inside of blink. */
        rtos_sendEvent(/* eventVec */ RTOS_EVT_EVENT_03);
    }

    /* Wait for a second after the last flash - this command could easily be invoked
       immediately again and the series need to be separated. */
    delay(500);
    rtos_sendEvent(/* eventVec */ RTOS_EVT_EVENT_03);
    delay(500-TI_FLASH);

#undef TI_FLASH
}
コード例 #6
0
ファイル: tc14_adcInput.cpp プロジェクト: joas77/cansat
void loop()
{
    /* Give an alive sign. */
    blink(3);

#ifdef DEBUG
    printf("\nRTuinOS is idle\n");
#endif

    /* Share result of CPU load computation with the displaying idle follower task. No
       acces synchronization is needed here for two reasons: Writing a uint8 is atomic and
       we have a strict coupling in time between the idle task and the data reading task:
       They become active one after another. */
    _cpuLoad = gsl_getSystemLoad();

#ifdef DEBUG
    cli();
    uint16_t adcResult       = adc_inputVoltage;
    uint16_t adcResultButton = adc_buttonVoltage;
    uint32_t noAdcResults = adc_noAdcResults;
    uint8_t hour = clk_noHour
          , min  = clk_noMin
          , sec  = clk_noSec;
    sei();

    printf("At %02u:%02u:%02u:\n", hour, min, sec);
    printf( "ADC result %7lu at %7.2f s: %.4f V (input), %.4f V (buttons)\n"
          , noAdcResults
          , 1e-3*millis()
          , ADC_SCALING_BIN_TO_V(adcResult)
          , ADC_SCALING_BIN_TO_V(adcResultButton)
          );
    printf("CPU load: %.1f %%\n", (double)_cpuLoad/2.0);
    ASSERT(rtos_getTaskOverrunCounter(/* idxTask */ idxTaskRTC, /* doReset */ false) == 0);
    
    uint8_t u;
    for(u=0; u<RTOS_NO_TASKS; ++u)
        printf("Unused stack area of task %u: %u Byte\n", u, rtos_getStackReserve(u));
#endif

    /* Trigger the follower task, which is capable to safely display the results. */
    rtos_sendEvent(EVT_TRIGGER_IDLE_FOLLOWER_TASK);

} /* End of loop */
コード例 #7
0
ファイル: tc11_mutex.c プロジェクト: bnuh/munsailbot
void loop(void)
{
    /* Idle is used only to start the first round robin task. */
    rtos_sendEvent(EVT_START_TASK_T0_C0);

    /* In test case tc09 of RTuinOS we had written: "Since we have a pseudo mutex only,
       which is implemented by polling (try and suspend until next try) there are minor
       gaps in time where all tasks are suspended. To not run into the sendEvent again, we
       place an empty loop here. Having a true mutex implementation, we would place an
       ASSERT(false) instead."
         Now we have re-implemented the test case using a true mutex but the statement
       turned out to be wrong, such an assertion fires occasionally. The reason is, that
       the tasks apply the other suspend command rtos_delay so that it might happen that
       all of them are suspended at the same time and idle becomes active. If all calls of
       rtos_delay are commented out the assertion is indeed safe. */
    //ASSERT(false);
    while(true)
        ;

} /* End of loop */
コード例 #8
0
ファイル: dpy_display.cpp プロジェクト: bnuh/munsailbot
inline void dpy_display_t::releaseMutex()
{
    /* Release the mutex. */
    rtos_sendEvent(EVT_MUTEX_LCD);

} /* End of dpy_display_t::releaseMutex */
コード例 #9
0
ファイル: tc11_mutex.c プロジェクト: bnuh/munsailbot
static void releaseResource()
{
    /* Signal the availability of the resource to possibly waiting tasks. */
    rtos_sendEvent(EVT_MUTEX_OWNING_RESOURCE);
    
} /* End of releaseResource */