/*********************************************************************
 * @fn      Util_stopClock
 *
 * @brief   Stop a clock.
 *
 * @param   pClock - pointer to clock struct
 *
 * @return  none
 */
void Util_stopClock(Clock_Struct *pClock)
{
  Clock_Handle handle = Clock_handle(pClock);

  // Stop clock instance
  Clock_stop(handle);
}
/*********************************************************************
 * @fn      Util_rescheduleClock
 *
 * @brief   Reschedule a clock by changing the timeout and period values.
 *
 * @param   pClock - pointer to clock struct
 * @param   clockPeriod - longevity of clock timer in milliseconds
 * @return  none
 */
void Util_rescheduleClock(Clock_Struct *pClock, uint32_t clockPeriod)
{
  bool running;
  uint32_t clockTicks;
  Clock_Handle handle;

  handle = Clock_handle(pClock);
  running = Clock_isActive(handle);

  if (running)
  {
    Clock_stop(handle);
  }

  // Convert period in milliseconds to ticks.
  clockTicks = clockPeriod * (1000 / Clock_tickPeriod);

  Clock_setTimeout(handle, clockTicks);
  Clock_setPeriod(handle, clockTicks);

  if (running)
  {
    Clock_start(handle);
  }
}
static Int32 IpcFramesInLink_deletePrdObj(IpcFramesInLink_Obj * pObj)
{
    /* Stop the clock */
    Clock_stop(pObj->prd.clkHandle);
    Clock_destruct(&(pObj->prd.clkStruct));
    pObj->prd.clkHandle = NULL;
    pObj->prd.clkStarted = FALSE;

    return IPC_FRAMES_IN_LINK_S_SUCCESS;
}
Int32 NullSrcLink_drvStop(NullSrcLink_Obj * pObj)
{
    Clock_stop(pObj->timer);

#ifdef SYSTEM_DEBUG_NULL
    Vps_printf(" %d: NULL_SRC: Stop Done !!!\n", Utils_getCurTimeInMsec());
#endif

    return FVID2_SOK;
}
/*
 *  ======== Event_post ========
 */
Void Event_post(Event_Object *event, UInt eventId)
{
    UInt tskKey, hwiKey;
    Event_PendElem *elem;
    Queue_Handle pendQ;

    Assert_isTrue((eventId != 0), Event_A_nullEventId);

    Log_write3(Event_LM_post, (UArg)event, (UArg)event->postedEvents, (UArg)eventId);

    pendQ = Event_Instance_State_pendQ(event);

    /* atomically post this event */
    hwiKey = Hwi_disable();

    /* or in this eventId */
    event->postedEvents |= eventId;

    /* confirm that ANY tasks are pending on this event */
    if (Queue_empty(pendQ)) {
        Hwi_restore(hwiKey);
        return;
    }

    tskKey = Task_disable();

    /* examine pendElem on pendQ */
    elem = (Event_PendElem *)Queue_head(pendQ);

    /* check for match, consume matching eventIds if so. */
    elem->matchingEvents = Event_checkEvents(event, elem->andMask, elem->orMask);

    if (elem->matchingEvents != 0) {

        /* remove event elem from elem queue */
        Queue_remove((Queue_Elem *)elem);

        /* mark the Event as having been posted */
        elem->pendState = Event_PendState_POSTED;

        /* disable Clock object */
        if (BIOS_clockEnabled && (elem->tpElem.clock != NULL)) {
            Clock_stop(elem->tpElem.clock);
        }

        /* put task back into readyQ */
        Task_unblockI(elem->tpElem.task, hwiKey);
    }

    Hwi_restore(hwiKey);

    /* context switch may occur here */
    Task_restore(tskKey);
}
Exemple #6
0
void LCD_Disable()
{
	Clock_stop(LCD_CLOCK);
	ScibRegs.SCICTL1.all =0x0000;
	EALLOW;
	GpioCtrlRegs.GPAPUD.bit.GPIO14 = 1;
	GpioCtrlRegs.GPAMUX1.bit.GPIO14 = 0;
	GpioDataRegs.GPACLEAR.bit.GPIO14 = 1;
	EDIS;
    LCD_S.init = 0;

}
/*********************************************************************
 * @fn      SensorTagIO_reset
 *
 * @brief   Reset characteristics
 *
 * @param   none
 *
 * @return  none
 */
void SensorTagIO_reset(void)
{
  ioValue = sensorTestResult();
  Io_setParameter( SENSOR_DATA, 1, &ioValue);

  ioMode = IO_MODE_LOCAL;
  Io_setParameter( SENSOR_CONF, 1, &ioMode);
  
  // Normal mode; make sure LEDs and buzzer are off
  PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_OFF);
  PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_OFF);
  Clock_stop(buzzClockHandle);
  PIN_setOutputValue(hGpioPin, Board_BUZZER, Board_BUZZER_OFF);
}
static Int32 IpcFramesInLink_reconfigPrdObj(IpcFramesInLink_Obj * pObj, UInt period)
{

    UTILS_assert(pObj->prd.clkHandle != NULL);

    if (TRUE == pObj->prd.clkStarted)
    {
        Clock_stop(pObj->prd.clkHandle);
    }
    Clock_setPeriod(pObj->prd.clkHandle, 0);
    Clock_setTimeout(pObj->prd.clkHandle, period);
    Clock_start(pObj->prd.clkHandle);
    return IPC_FRAMES_IN_LINK_S_SUCCESS;
}
/*********************************************************************
 * @fn      Util_restartClock
 *
 * @brief   Restart a clock by changing the timeout.
 *
 * @param   pClock - pointer to clock struct
 * @param   clockTimeout - longevity of clock timer in milliseconds
 *
 * @return  none
 */
void Util_restartClock(Clock_Struct *pClock, uint32_t clockTimeout)
{
  uint32_t clockTicks;
  Clock_Handle handle;

  handle = Clock_handle(pClock);

  if (Clock_isActive(handle))
  {
    // Stop clock first
    Clock_stop(handle);
  }

  // Convert timeout in milliseconds to ticks.
  clockTicks = clockTimeout * (1000 / Clock_tickPeriod);

  // Set the initial timeout
  Clock_setTimeout(handle, clockTicks);

  // Start clock instance
  Clock_start(handle);
}
/*********************************************************************
 * @fn      SensorTagIO_processCharChangeEvt
 *
 * @brief   Process a change in the IO characteristics
 *
 * @return  none
 */
void SensorTagIO_processCharChangeEvt(uint8_t paramID)
{ 
  if( paramID == SENSOR_CONF )
  {
    
    Io_getParameter(SENSOR_CONF, &ioMode);
    if (ioMode == IO_MODE_SELFTEST)
    {
      ioValue = sensorTestResult();
      Io_setParameter(SENSOR_DATA, 1, &ioValue);
    }
    else 
    {
      // Mode change: make sure LEDs and buzzer are off
      Io_setParameter(SENSOR_DATA, 1, &ioValue);
      
      PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_OFF);
      PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_OFF);
      Clock_stop(buzzClockHandle);
      PIN_setOutputValue(hGpioPin, Board_BUZZER, Board_BUZZER_OFF);
    }
  } 
  else if (paramID == SENSOR_DATA)
  {
    Io_getParameter(SENSOR_DATA, &ioValue);
  }
  
  if (ioMode == IO_MODE_REMOTE)
  {
    // Control by remote client: 
    // - possible to operate the LEDs and buzzer
    // - right key functionality overridden (will not terminate connection)
    if (!!(ioValue & IO_DATA_LED1))
    {
      PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_ON);
    }
    else
    {
      PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_OFF);
    }
    
    if (!!(ioValue & IO_DATA_LED2))
    {
      PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_ON);
    }
    else
    {
      PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_OFF);
    }
    
    if (!!((ioValue & IO_DATA_BUZZER)))
    {
      Clock_start(buzzClockHandle);
    }
    else
    {
      Clock_stop(buzzClockHandle);
      PIN_setOutputValue(hGpioPin, Board_BUZZER, Board_BUZZER_OFF);
    }
  }
}
Exemple #11
0
void ReadLightW(Semaphore_Handle Sema, unsigned int *results){
		char RMS_str[5];
		char RMS_cnt_str[5];
		//Set pins as output and set light sensor high.
		GPIOPinTypeGPIOOutput(GPIO_PORTE_BASE, GPIO_PIN_1);
		GPIOPinWrite(GPIO_PORTE_BASE, GPIO_PIN_1, GPIO_PIN_1);
		Timer_start(timer1);
		//Turn on timer1 for 12 microseconds.
		//Pend on LightSema
		Semaphore_pend(Sema, BIOS_WAIT_FOREVER);

		switch (adState) {
		case 0: // no line dtected
			if (*results && (black_count >= 20)){ //make sure it is a full line.
				Clock_start(DataClock);
				wasWhite = 0;	//record state.
				adState = 1;	//next state.
			}
			break;
		case 1: //first rising edge detected

			//falling edge of first line
			if (!(*results) && !wasWhite && (black_count >= 20)) {
				wasWhite = 1;
				adState = 2;
				if ((black_count <= 40) && (black_count >= 20)) {	//single line detected
					if (drive_state == FOLLOW1 || prev_follow_state == FOLLOW1){
						//First black line found, progress to follow2
						//		and start acquiring data.
						drive_state = FOLLOW2;
						prev_follow_state = FOLLOW2;
						RMS_cnt = 0;
						RMS = 0;
						Clock_start(DataClock);
					}
					else if (drive_state == FOLLOW2 || prev_follow_state == FOLLOW2){
						//Second black line found, progress to follow3
						//		and stop acquiring data.
						prev_follow_state = FOLLOW3;
						drive_state = FOLLOW3;
						Clock_stop(DataClock);
						//RMS /= RMS_cnt;		//finalize RMS
						//RMS = sqrt(RMS);
						intToStr(RMS_cnt, RMS_cnt_str, 4);
						strcpy(FullBufferPtr, "\0");
						strcpy(FullBufferPtr, "R=\0");	//Clear the fullBuffer.
						intToStr(RMS, RMS_str, 4);
						strcat(FullBufferPtr, RMS_str);
						strcat(FullBufferPtr, "\nC=\0");
						strcat(FullBufferPtr, RMS_cnt_str);
						strcat(FullBufferPtr, "\n\0");
						writeFrame("",FullBufferPtr);
						//Semaphore_post(TxDataSema);		//Let writeFrame continue.
						//Clock_stop(DataClock);
					}
				}else if (black_count > 40){ //double line detected
					StopDrivingFn();
					Clock_stop(DataClock);
				}
				black_count = 0;

			}
			break;
		case 2: //first falling edge detected
			if (*results && wasWhite && (black_count >= 20)){
				wasWhite = 0;
				adState = 3;
			}

			break;
		case 3: //second rising edge detected

			//falling edge of second line
			if (!(*results) && !wasWhite && (black_count >= 20)) {
				wasWhite = 1;
				adState = 4;
				if ((black_count <= 40) && (black_count >= 20)) {	//single line detected
					if (drive_state == FOLLOW1 || prev_follow_state == FOLLOW1){
						//First black line found, progress to follow2
						//		and start acquiring data.
						drive_state = FOLLOW2;
						prev_follow_state = FOLLOW2;
						RMS_cnt = 0;
						RMS = 0;
						Clock_start(DataClock);
					}
					else if (drive_state == FOLLOW2 || prev_follow_state == FOLLOW2){
						//First black line found, progress to follow3
						//		and stop acquiring data.
						prev_follow_state = FOLLOW3;
						drive_state = FOLLOW3;
						//Clock_stop(DataClock);
						Clock_stop(DataClock);
						//RMS /= RMS_cnt;		//finalize RMS
						//RMS = sqrt(RMS);
						intToStr(RMS_cnt, RMS_cnt_str, 4);
						strcpy(FullBufferPtr, "\0");
						strcpy(FullBufferPtr, "R=\0");	//Clear the fullBuffer.
						intToStr(RMS, RMS_str, 4);
						strcat(FullBufferPtr, RMS_str);
						strcat(FullBufferPtr, "\nC=\0");
						strcat(FullBufferPtr, RMS_cnt_str);
						strcat(FullBufferPtr, "\n\0");
						writeFrame("",FullBufferPtr);
						//Semaphore_post(TxDataSema);		//Let writeFrame continue.
					}
				}else if (black_count > 40){//double line detected
					//StopDrivingFn();
					Clock_stop(DataClock);
				}
				black_count = 0;
			}
			break;
		case 4: //second falling edge detected. Done collecting data.
			//Clock_stop(DataClock);
			//StopAcquireData();

			Clock_stop(DataClock);
			//RMS /= RMS_cnt;		//finalize RMS
			//RMS = sqrt(RMS);
			intToStr(RMS_cnt, RMS_cnt_str, 4);
			strcpy(FullBufferPtr, "\0");
			strcpy(FullBufferPtr, "R=\0");	//Clear the fullBuffer.
			intToStr(RMS, RMS_str, 4);
			strcat(FullBufferPtr, RMS_str);
			strcat(FullBufferPtr, "\nC=\0");
			strcat(FullBufferPtr, RMS_cnt_str);
			strcat(FullBufferPtr, "\n\0");
			writeFrame("",FullBufferPtr);
			//Semaphore_post(TxDataSema);		//Let writeFrame continue.
			//push whats remaining in the buffer out to transfer it.
			strcpy(FullBufferPtr, "\0");
			strcat(pingptr1, "\n\0");
			strcpy(FullBufferPtr, pingptr1);
			Semaphore_post(TxDataSema);
			strcpy(pingptr1, "\0");
			numChars = 0;
			wasWhite = 0;
			adState = 0;
			break;
		default:
			break;
		}

}
Exemple #12
0
void DriveFn (){
	static int lightFlag = 0;
	while(1){
		Semaphore_pend(DriveSema, BIOS_WAIT_FOREVER);
		switch (drive_state) {
			case START:
				//enable motors forward.
				PWMOutputState(PWM0_BASE, MOTOR_LF_EN , true);
				PWMOutputState(PWM0_BASE, MOTOR_RF_EN , true);
				//accelerate to speed
				setSpeed (200, MOTOR_RF_EN);
				setSpeed (200, MOTOR_LF_EN);
				drive_state = FOLLOW1;
				GPIO_write(Board_LED0, Board_LED_ON);
				break;
				//Follow1,2 and 3 grouped together since they do the same thing.
				//They do progress depending on the lines the robot has passed, but that
				//is handled in another area.
			case FOLLOW1:
			case FOLLOW2:
			case FOLLOW3:
				prev_follow_state = drive_state;
				if (lightFlag == 0)
					//acquire data
					lightFlag = !lightFlag;

				if (!wall_det) {
					drive_state = INTERSECTION;
				}
				else if (front_wall_det == 1){
					drive_state = UTURN;		//stop if front wall detected
				}
				//read right wall distance
				PID_Algorithm();

				break;

			case INTERSECTION:
				if (Clock_isActive(DataClock) ){	//if collecting data
					Clock_stop(DataClock);	//don't collect data in intersection
					motor_RightTurn();
					Clock_start(DataClock);
				}
				else	//if not collecting data
					motor_RightTurn();	//move along

				break;
			case UTURN:
				if (Clock_isActive(DataClock) ){	//if collecting data
					Clock_stop(DataClock);	//don't collect data in uturn
					motor_Uturn();
					Clock_start(DataClock);
				}
				else	//if not collecting data
					motor_Uturn();	//move along

				break;
			case STOP:
				//decelerate to a stop
				setSpeed (0, MOTOR_LF_EN);
				setSpeed (0, MOTOR_RF_EN);
				StopDrivingFn();
				drive_state = OFF;
				break;
			case OFF:
				//disable motors
				PWMOutputState(PWM0_BASE, MOTOR_LF_EN , false);
				PWMOutputState(PWM0_BASE, MOTOR_RF_EN , false);
				break;
		}
	}
}
/**************************************************************************************************
 * @fn          macBackoffTimerUpdateWakeup
 *
 * @brief       Recomputes and provides weakup timing hint to power module.
 *              This function does not read timing variables in a critical
 *              section. The caller must call this function within a critical
 *              section where the timing variable is modified in order
 *              to have more accurate notification.
 *
 * @param       none
 *
 * @return      none
 **************************************************************************************************
 */
static void macBackoffTimerUpdateWakeup(void)
{
  int_fast64_t ticks;

  /* Replicate the timer in order to inform power module to wake up properly
   * in case the device enters sleep state in the future. */

  /* First find out which RAT channel between backoffTimerTrigger and
   * macBackoffTimerRollover is supposed to expire next. */
  ticks = MAC_RADIO_BACKOFF_COUNT();

  if (backoffTimerTrigger > ticks &&
      backoffTimerTrigger < macBackoffTimerRollover)
  {
    ticks = backoffTimerTrigger - ticks;
  }
  else if (macBackoffTimerRollover > ticks)
  {
    ticks = macBackoffTimerRollover - ticks;
  }
  else
  {
    /* Note that current count might have exceeded already set thresholds,
     * as the code is executed while interrupt is flagged.
     * In such a case, this function shall be called again anyways and
     * hence this condition can be ignored. */
    return;
  }

  /* TODO: For subG, backoff timer unit is not necessarily backoff period
   *       but fixed 320us and hence the following constant
   *       (MAC_SPEC_USECS_PER_BACKOFF) should be replaced with backoff
   *       timer unit period in usecs. */

  /* Convert backoff timer unit to RTOS tick unit */
  ticks *= MAC_SPEC_USECS_PER_BACKOFF;

#ifdef USE_ICALL
  ticks -= (MAC_BACKOFF_TIMER_ADDITIONAL_WAKEUP_LATENCY + ICall_pwrGetXOSCStartupTime(ticks/1000));
#elif defined OSAL_PORT2TIRTOS
  ticks -= MAC_BACKOFF_TIMER_ADDITIONAL_WAKEUP_LATENCY +
           Power_getXoscStartupTime(ticks/1000);
#endif /* defined OSAL_PORT2TIRTOS */

  if (ticks > 0)
  {
#ifdef USE_ICALL
    ticks /= osal_tickperiod;
#elif defined OSAL_PORT2TIRTOS
    ticks /= Clock_tickPeriod;
#endif  /* defined OSAL_PORT2TIRTOS */
  }

  if (ticks > 0)
  {
#ifdef USE_ICALL
    ICall_setTimer((uint_fast32_t) ticks, macBackoffTimerICallTimerCback,
                   NULL, &macBackoffTimerICallTimerID);
#endif /* USE_ICALL */
#ifdef OSAL_PORT2TIRTOS
    Clock_stop(macBackoffWakeupClock);
    Clock_setTimeout(macBackoffWakeupClock, (UInt32) ticks);
    Clock_start(macBackoffWakeupClock);
#endif /* OSAL_PORT2TIRTOS */

    /* Allow entering sleep state */
    macBackoffTimerImpending = FALSE;
#ifdef DEBUG_SW_TRACE
    DBG_PRINTL1(DBGSYS, "BO %u", ticks);
#endif /* DEBUG_SW_TRACE */
  }
  else
  {
    /* Timing is too close. Suppress sleep. */
    macBackoffTimerImpending = TRUE;
  }
  macPwrVote();
}
/*
 *  ======== PowerCC3200_sleepPolicy ========
 */
void PowerCC3200_sleepPolicy()
{
    bool returnFromSleep = FALSE;
    uint32_t constraintMask;
    uint32_t ticks;
    uint64_t time;
    uint64_t match;
    uint64_t curr;
    uint64_t remain;
    uint32_t taskKey;
    uint32_t swiKey;

    /* disable interrupts */
    CPUcpsid();

    /* disable Swi and Task scheduling */
    swiKey = Swi_disable();
    taskKey = Task_disable();

    /* query the declared constraints */
    constraintMask = Power_getConstraintMask();

    /*
     *  Do not go into LPDS if not allowed into DEEPSLEEP.
     *  Check to see if we can go into LPDS (lowest level sleep).
     *  If not allowed, then attempt to go into DEEPSLEEP.
     *  If not allowed in DEEPSLEEP then just SLEEP.
     */

     /* check if we are allowed to go to LPDS */
    if ((constraintMask &
        ((1 << PowerCC3200_DISALLOW_LPDS) |
        (1 << PowerCC3200_DISALLOW_DEEPSLEEP))) == 0) {
        /*
         * Check how many ticks until the next scheduled wakeup.  A value of
         * zero indicates a wakeup will occur as the current Clock tick period
         * expires; a very large value indicates a very large number of Clock
         * tick periods will occur before the next scheduled wakeup.
         */
        /* Get the time remaining for the RTC timer to expire */
        ticks = Clock_getTicksUntilInterrupt();

        /* convert ticks to microseconds */
        time = ticks * Clock_tickPeriod;

        /* check if can go to LPDS */
        if (time > Power_getTransitionLatency(PowerCC3200_LPDS, Power_TOTAL)) {
            /* get the current and match values for RTC */
            match = MAP_PRCMSlowClkCtrMatchGet();
            curr = MAP_PRCMSlowClkCtrGet();
            remain = match - curr -
                (((uint64_t)PowerCC3200_TOTALTIMELPDS * 32768) / 1000000);

            /* set the LPDS wakeup time interval */
            MAP_PRCMLPDSIntervalSet(remain);

            /* enable the wake source to be timer */
            MAP_PRCMLPDSWakeupSourceEnable(PRCM_LPDS_TIMER);

            /* go to LPDS mode */
            Power_sleep(PowerCC3200_LPDS);

            /* set 'returnFromSleep' to TRUE*/
            returnFromSleep = TRUE;
        }
    }

    /* check if we are allowed to go to DEEPSLEEP */
    if ((constraintMask & (1 << PowerCC3200_DISALLOW_DEEPSLEEP) == 0) &&
        (!returnFromSleep)) {
        /*
         * Check how many ticks until the next scheduled wakeup.  A value of
         * zero indicates a wakeup will occur as the current Clock tick period
         * expires; a very large value indicates a very large number of Clock
         * tick periods will occur before the next scheduled wakeup.
         */
        ticks = Clock_getTicksUntilInterrupt();

        /* convert ticks to microseconds */
        time = ticks * Clock_tickPeriod;

        /* check if can go to DEEPSLEEP */
        if (time > Power_getTransitionLatency(PowerCC3200_DEEPSLEEP,
            Power_TOTAL)) {
            /* schedule the wakeup event */
            ticks -= PowerCC3200_RESUMETIMEDEEPSLEEP / Clock_tickPeriod;
            Clock_setTimeout(Clock_handle(&clockObj), ticks);
            Clock_start(Clock_handle(&clockObj));

            /* go to DEEPSLEEP mode */
            Power_sleep(PowerCC3200_DEEPSLEEP);
            Clock_stop(Clock_handle(&clockObj));

            /* set 'returnFromSleep' to TRUE so we don't go to sleep (below) */
            returnFromSleep = TRUE;
        }
    }

    /* re-enable interrupts */
    CPUcpsie();

    /* restore Swi scheduling */
    Swi_restore(swiKey);

    /* restore Task scheduling */
    Task_restore(taskKey);

    /* sleep only if we are not returning from one of the sleep modes above */
    if (!(returnFromSleep)) {
        MAP_PRCMSleepEnter();
    }
}
void OneMsTaskTimer::stop() {
    Clock_stop(myClock);
}
Exemple #16
0
void Clock::stop()
{
    Clock_stop(ClockHandle);
}