/** * @brief Resets a @p mailbox_t object. * @details All the waiting threads are resumed with status @p MSG_RESET and * the queued messages are lost. * * @param[in] mbp the pointer to an initialized @p mailbox_t object * * @api */ void chMBReset(mailbox_t *mbp) { chDbgCheck(mbp != NULL); chSysLock(); mbp->mb_wrptr = mbp->mb_rdptr = mbp->mb_buffer; chSemResetI(&mbp->mb_emptysem, mbp->mb_top - mbp->mb_buffer); chSemResetI(&mbp->mb_fullsem, 0); chSchRescheduleS(); chSysUnlock(); }
/** * @brief Deactivates the CAN peripheral. * * @param[in] canp pointer to the @p CANDriver object * * @api */ void canStop(CANDriver *canp) { chDbgCheck(canp != NULL, "canStop"); chSysLock(); chDbgAssert((canp->state == CAN_STOP) || (canp->state == CAN_READY), "canStop(), #1", "invalid state"); can_lld_stop(canp); chSemResetI(&canp->rxsem, 0); chSemResetI(&canp->txsem, 0); chSchRescheduleS(); canp->state = CAN_STOP; canp->status = 0; chSysUnlock(); }
/** * @brief Performs a reset operation on the semaphore. * @post After invoking this function all the threads waiting on the * semaphore, if any, are released and the semaphore counter is set * to the specified, non negative, value. * @post This function does not reschedule so a call to a rescheduling * function must be performed before unlocking the kernel. Note that * interrupt handlers always reschedule on exit so an explicit * reschedule must not be performed in ISRs. * * @param[in] sp pointer to a @p semaphore_t structure * @param[in] n the new value of the semaphore counter. The value must * be non-negative. * * @api */ void chSemReset(semaphore_t *sp, cnt_t n) { chSysLock(); chSemResetI(sp, n); chSchRescheduleS(); chSysUnlock(); }
THD_FUNCTION(test_support, arg) { #if CH_CFG_USE_EVENTS == TRUE thread_t *tp = (thread_t *)arg; #else (void)arg; #endif /* Initializing global resources.*/ chSemObjectInit(&gsem1, 0); chSemObjectInit(&gsem2, 0); while (true) { chSysLock(); if (chSemGetCounterI(&gsem1) < 0) chSemSignalI(&gsem1); chSemResetI(&gsem2, 0); chThdResumeI(>r1, MSG_OK); #if CH_CFG_USE_EVENTS == TRUE chEvtSignalI(tp, 0x55); #endif chSchRescheduleS(); chSysUnlock(); chThdSleepMilliseconds(250); } }
/** * @brief Stops an ongoing conversion. * * @param[in] adcp pointer to the @p ADCDriver object */ void adcStopConversion(ADCDriver *adcp) { chDbgCheck(adcp != NULL, "adcStopConversion"); chSysLock(); chDbgAssert((adcp->ad_state == ADC_READY) || (adcp->ad_state == ADC_RUNNING) || (adcp->ad_state == ADC_COMPLETE), "adcStopConversion(), #1", "invalid state"); if (adcp->ad_state == ADC_RUNNING) { adc_lld_stop_conversion(adcp); adcp->ad_grpp = NULL; adcp->ad_state = ADC_READY; chSemResetI(&adcp->ad_sem, 0); chSchRescheduleS(); } else adcp->ad_state = ADC_READY; chSysUnlock(); }
void CounterSemaphore::resetI(cnt_t n) { chSemResetI(&sem, n); }
inline void Semaphore_::reset_unsafe(Count value) { chSemResetI(&impl, value); }
/** * @brief Resets an output queue. * @details All the data in the output queue is erased and lost, any waiting * thread is resumed with status @p Q_RESET. * @note A reset operation can be used by a low level driver in order to * obtain immediate attention from the high level layers. * * @param[in] oqp pointer to an @p OutputQueue structure * * @iclass */ void chOQResetI(OutputQueue *oqp) { oqp->q_rdptr = oqp->q_wrptr = oqp->q_buffer; chSemResetI(&oqp->q_sem, (cnt_t)(oqp->q_top - oqp->q_buffer)); }
/** * @brief Resets an input queue. * @details All the data in the input queue is erased and lost, any waiting * thread is resumed with status @p Q_RESET. * @note A reset operation can be used by a low level driver in order to * obtain immediate attention from the high level layers. * * @param[in] iqp pointer to an @p InputQueue structure * * @iclass */ void chIQResetI(InputQueue *iqp) { iqp->q_rdptr = iqp->q_wrptr = iqp->q_buffer; chSemResetI(&iqp->q_sem, 0); }