Пример #1
0
s32 bsp_close(u32 fd)
{
    s32 ret;
    struct bsp_rfile_close_req stReq;

    osSemaphoreWait(g_stRfileMain.semAll, osWaitForever);

    stReq.opType = EN_RFILE_OP_CLOSE;
    stReq.pstlist = NULL;
    stReq.fd = fd;

    ret = bsp_icc_send(ICC_CPU_APP, RFILE_MCORE_ICC_WR_CHAN, &stReq, sizeof(struct bsp_rfile_close_req));
    if (sizeof(struct bsp_rfile_close_req) != ret)
    {
        bsp_trace(BSP_LOG_LEVEL_DEBUG, BSP_MODU_RFILE, "%d.\n", __LINE__);
        
        g_stRfileMain.ret = -1;
    }
    else
    {
        osSemaphoreWait(g_stRfileMain.semReq, osWaitForever);
    }

    osSemaphoreRelease(g_stRfileMain.semAll);

    return g_stRfileMain.ret;
}
bool_t osWaitForEvent(OsEvent *event, systime_t timeout)
{
   int32_t ret;

   //Wait until the specified event is in the signaled
   //state or the timeout interval elapses
   if(timeout == INFINITE_DELAY)
   {
      //Infinite timeout period
      ret = osSemaphoreWait(event->id, osWaitForever);
   }
   else
   {
#if defined(osCMSIS_RTX)
      systime_t n;

      //Loop until the assigned time period has elapsed
      do
      {
         //Limit the timeout value
         n = MIN(timeout, 10000);
         //Wait for the specified time interval
         ret = osSemaphoreWait(event->id, n);
         //Decrement timeout value
         timeout -= n;

         //Check timeout value
      } while(ret == 0 && timeout > 0);
#else
      //Wait for the specified time interval
      ret = osSemaphoreWait(event->id, timeout);
#endif
   }

#if defined(osCMSIS_RTX)
   //Check return value
   if(ret > 0)
   {
      //Force the event back to the nonsignaled state
      while(osSemaphoreWait(event->id, 0) > 0);

      //The specified event is in the signaled state
      return TRUE;
   }
   else
   {
      //The timeout interval elapsed
      return FALSE;
   }
#else
   //Check return value
   if(ret == osOK)
      return TRUE;
   else
      return FALSE;
#endif
}
void Start_input_buttonTask(void const * argument)
{
  GPIO_InitTypeDef GPIO_InitStruct;
  fsm_event_f button_fsm_event;

  /* Take both semaphores for the first time */
  osSemaphoreWait(sem_input_button_short_pressHandle, osWaitForever);
  osSemaphoreWait(sem_input_button_long_pressHandle, osWaitForever);

  /* Infinite loop */
  for(;;)
  {
    /* If I/O button is pressed */
    if (osSemaphoreWait(sem_input_button_short_pressHandle, osWaitForever) == osOK)
    {
      /* Make falling edge sensitive */
      GPIO_InitStruct.Pin = WAKEUP_Pin;
      GPIO_InitStruct.Mode = GPIO_MODE_IT_FALLING;
      GPIO_InitStruct.Pull = GPIO_NOPULL;
      HAL_GPIO_Init(WAKEUP_GPIO_Port, &GPIO_InitStruct);

      // TEST
      osSemaphoreRelease(sem_ecg_keygenHandle);

      /* Wait for falling edge */
      if (osSemaphoreWait(sem_input_button_long_pressHandle, 2000) == osErrorOS)
      {
        /* If falling edge is NOT detected before timeout
         * we have a long press
         */
        button_fsm_event = fsm_button_long;
        while(osMailPut(queue_fsm_eventsHandle, (void *) &button_fsm_event) != osOK)
        {
          osDelay(1);
        }
      }
      else
      {
        /* Make rising edge sensitive again */
        GPIO_InitStruct.Pin = WAKEUP_Pin;
        GPIO_InitStruct.Mode = GPIO_MODE_IT_RISING;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(WAKEUP_GPIO_Port, &GPIO_InitStruct);

        /* If falling edge is detected before timeout
         * we have a short press
         */
        button_fsm_event = fsm_button_short;
        while(osMailPut(queue_fsm_eventsHandle, (void *) &button_fsm_event) != osOK)
        {
          osDelay(1);
        }
      }
    }
  }
}
void osResetEvent(OsEvent *event)
{
#if defined(osCMSIS_RTX)
   //Force the specified event to the nonsignaled state
   while(osSemaphoreWait(event->id, 0) > 0);
#else
   //Force the specified event to the nonsignaled state
   osSemaphoreWait(event->id, 0);
#endif
}
Пример #5
0
s32 bsp_open(const s8 *path, s32 flags,  s32 mode)
{
    s32 ret;
    u32 ulNameLen, ulSize;
    struct bsp_rfile_open_req *pstReq;

    osSemaphoreWait(g_stRfileMain.semAll, osWaitForever);

    if(!path)
    {
        return BSP_ERROR;
    }

    ulNameLen = strlen(path) + 1;

    ulSize = sizeof(struct bsp_rfile_open_req) + ulNameLen;
    
    if(ulSize > RFILE_LEN_MAX)
    {
        return BSP_ERROR;
    }

    pstReq = Rfile_Malloc(ulSize);
    if(!pstReq)
    {
        return BSP_ERROR;
    }

    pstReq->opType = EN_RFILE_OP_OPEN;
    pstReq->pstlist = NULL;
    pstReq->nameLen = ulNameLen;
    pstReq->mode = mode;
    pstReq->flags = flags;

    memcpy(pstReq->aucData, path, ulNameLen);

    ret = bsp_icc_send(ICC_CPU_APP, RFILE_MCORE_ICC_WR_CHAN, pstReq, ulSize);
    if (ulSize != ret)
    {
        bsp_trace(BSP_LOG_LEVEL_DEBUG, BSP_MODU_RFILE, "%d.\n", __LINE__);
        g_stRfileMain.ret = -1;
    }
    else
    {
        osSemaphoreWait(g_stRfileMain.semReq, osWaitForever);
    }

    Rfile_Free(pstReq);

    osSemaphoreRelease(g_stRfileMain.semAll);

    return g_stRfileMain.ret;
}
Пример #6
0
/*!
 @brief Program entry point
 */
int main (void) {
	Mode currentMode;
	mainThread_ID = osThreadGetId();
	
	// start threads. Low priority ensures main will finish
	osThreadDef (tM_run, osPriorityBelowNormal, 1, 0);
	tempThread_ID = osThreadCreate( osThread (tM_run), NULL);
	osThreadDef (aM_run, osPriorityBelowNormal, 1, 0);
	accThread_ID = osThreadCreate( osThread (aM_run), NULL);
	
	LED_init();
	buttonInit();
	tM_init();
	aM_init();
	
	// lock both mode semaphores, they are both in "used" mode
	osSemaphoreWait( tempSema, osWaitForever);
	osSemaphoreWait( accSema, osWaitForever);
	

	
	// start in TEMP_MODE
	currentMode = TEMP_MODE;
	osSemaphoreRelease( tempSema);
	
	TIM3_Init(ACC_FREQ);
	
	while(1) {
        //will start and wait for a tap before anything happends
        //it will run the threads though
		osSignalWait(0x1, osWaitForever);
        
        // once we're past here, it means a tap has been detected!
        
		switch( currentMode) {
			case TEMP_MODE:
                // we wait until the semaphore becomes available
				osSemaphoreWait( tempSema, osWaitForever);
				osDelay	(500);
				acc_clearLatch();
				osSemaphoreRelease(accSema);
				currentMode = ACC_MODE;           
			break;
			case ACC_MODE:                
				osSemaphoreWait( accSema, osWaitForever);
				osDelay	(500);
				acc_clearLatch();
				osSemaphoreRelease(tempSema);
				currentMode = TEMP_MODE;
			break;
		}		
	}
}
Пример #7
0
s32 bsp_write(u32 fd, const s8 *ptr, u32 size)
{
    s32 ret = -1;
    u32 ulCur, ulLen;

    osSemaphoreWait(g_stRfileMain.semAll, osWaitForever);

    if(!ptr)
    {
        return BSP_ERROR;
    }

    /* 如果长度超过ICC最大长度限制,需要拆分传送 */
    ulCur = 0;
    while(ulCur < size)
    {
        ulLen = ((size - ulCur) > RFILE_WR_LEN_MAX) ? RFILE_WR_LEN_MAX : (size - ulCur);

        ret = rfile_write(fd, ((u8*)ptr+ulCur), ulLen);

        ulCur += ret;

        if(ret != ulLen)
        {
            break;
        }
    }

    osSemaphoreRelease(g_stRfileMain.semAll);

    return ulCur;
}
Пример #8
0
/**
  * @brief  Semaphore Thread 2 function
  * @param  argument: shared semaphore
  * @retval None
  */
static void SemaphoreThread2 (void const *argument)
{ 
  uint32_t count = 0;
  osSemaphoreId semaphore = (osSemaphoreId) argument;
  
  for(;;)
  {
    if (semaphore != NULL)
    {
      /* Try to obtain the semaphore. */
      if(osSemaphoreWait(semaphore , 0) == osOK)
      {
        /* Resume Thread 1 (higher priority)*/
        osThreadResume(SemThread1Handle);
        
        count = osKernelSysTick() + 5000;
        
        /* Toggle LED3 every 200 ms for 5 seconds*/
        while (count >= osKernelSysTick())
        {
          BSP_LED_Toggle(LED3);
          
          osDelay(200);
        }
        
        /* Turn off LED3 */
        BSP_LED_Off(LED3);

        /* Release the semaphore to unblock Thread 1 (higher priority)  */
        osSemaphoreRelease(semaphore);
      }
    }
  }
}
bool_t osCreateEvent(OsEvent *event)
{
   osSemaphoreDef_t semaphoreDef;

#if defined(osCMSIS_RTX)
   semaphoreDef.semaphore = event->cb;
#else
   semaphoreDef.dummy = 0;
#endif

   //Create a binary semaphore object
   event->id = osSemaphoreCreate(&semaphoreDef, 1);

   //Check whether the returned semaphore ID is valid
   if(event->id != NULL)
   {
      //Force the specified event to the nonsignaled state
      osSemaphoreWait(event->id, 0);
      //Event successfully created
      return TRUE;
   }
   else
   {
      //Failed to create event object
      return FALSE;
   }
}
Пример #10
0
/**
  * @brief  Semaphore Thread 1 function
  * @param  argument: shared semaphore
  * @retval None
  */
static void SemaphoreThread1 (void const *argument)
{  
  uint32_t count = 0;
  osSemaphoreId semaphore = (osSemaphoreId) argument;
  
  for(;;)
  {
    if (semaphore != NULL)
    {
      /* Try to obtain the semaphore. */
      if(osSemaphoreWait(semaphore , 100) == osOK)
      {
        count = osKernelSysTick() + 5000;
        
        while (count >= osKernelSysTick())
        {
          /* Toggle LED1 */
          BSP_LED_Toggle(LED1);
          
          /* Delay 200 ms */
          osDelay(200);
        }
        
        /* Turn off LED1 */
        BSP_LED_Off(LED1);

        /* Release the semaphore */
        osSemaphoreRelease(semaphore);

        /* Suspend ourseleves to execute thread 2 (lower priority)  */
        osThreadSuspend(NULL); 
      }
    }
  }
}
int main(void)
{
  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();


  /* Initialize all configured peripherals */
  MX_GPIO_Init();

  /* Create the threads and semaphore */
  osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128);
  defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
  osThreadDef(blinkTask, BlinkTask, osPriorityNormal, 0, 128);
  blinkTaskHandle = osThreadCreate(osThread(blinkTask), NULL);
  osSemaphoreDef(sem);
  semHandle = osSemaphoreCreate(osSemaphore(sem), 1);
  osSemaphoreWait(semHandle, osWaitForever);

  /* Start scheduler */
  osKernelStart();

  /* We should never get here as control is now taken by the scheduler */

  /* Infinite loop */
  while (1);

}
Пример #12
0
void getWirelessAngles(int8_t* angles)
{
	osSemaphoreWait(wirelessAccId, osWaitForever);
	angles[0] =  wirelessAngles[0];
	angles[1] =  wirelessAngles[1];
	osSemaphoreRelease(wirelessAccId);
}
Пример #13
0
CAN_ERROR CAN_hw_tx_empty (U32 ctrl)  
{
	HAL_CAN_StateTypeDef state;
  CAN_HandleTypeDef *hCAN;
	
	int av = osSemaphoreWait(wr_sem[ctrl-1], 0);
	
  if (av >0)
	{
		switch (ctrl)
		{
	#if RTE_CAN1 == 1
			case __CTRL1:
				hCAN = &hCAN1;
				break;
	#endif
	#if RTE_CAN2 == 1
			case __CTRL2:
				hCAN= &hCan2;
				break;
	#endif
			default:
				return CAN_UNEXIST_CTRL_ERROR;
		}
		state = HAL_CAN_GetState(hCAN);
		if((state == HAL_CAN_STATE_READY) || (state == HAL_CAN_STATE_BUSY_RX))
			return CAN_OK;
		else 
			osSemaphoreRelease(wr_sem[ctrl-1]);    /* Return a token back to semaphore    */
	}

  return CAN_TX_BUSY_ERROR;
}
bool_t osWaitForSemaphore(OsSemaphore *semaphore, systime_t timeout)
{
   int32_t ret;

   //Wait until the semaphore is available or the timeout interval elapses
   if(timeout == INFINITE_DELAY)
   {
      //Infinite timeout period
      ret = osSemaphoreWait(semaphore->id, osWaitForever);
   }
   else
   {
#if defined(osCMSIS_RTX)
      systime_t n;

      //Loop until the assigned time period has elapsed
      do
      {
         //Limit the timeout value
         n = MIN(timeout, 10000);
         //Wait for the specified time interval
         ret = osSemaphoreWait(semaphore->id, n);
         //Decrement timeout value
         timeout -= n;

         //Check timeout value
      } while(ret == 0 && timeout > 0);
#else
      //Wait for the specified time interval
      ret = osSemaphoreWait(semaphore->id, timeout);
#endif
   }

#if defined(osCMSIS_RTX)
   //Check return value
   if(ret > 0)
      return TRUE;
   else
      return FALSE;
#else
   //Check return value
   if(ret == osOK)
      return TRUE;
   else
      return FALSE;
#endif
}
Пример #15
0
void test_thread(void const *name) {
    while (true) {
        osSemaphoreWait(two_slots, osWaitForever);
        printf("%s\n\r", (const char*)name);
        osDelay(1000);
        osSemaphoreRelease(two_slots);
    }
}
Пример #16
0
/*---------------------------------------------------------------------------*
 * Routine:  sys_arch_sem_wait
 *---------------------------------------------------------------------------*
 * Description:
 *      Blocks the thread while waiting for the semaphore to be
 *      signaled. If the "timeout" argument is non-zero, the thread should
 *      only be blocked for the specified time (measured in
 *      milliseconds).
 *
 *      If the timeout argument is non-zero, the return value is the number of
 *      milliseconds spent waiting for the semaphore to be signaled. If the
 *      semaphore wasn't signaled within the specified time, the return value is
 *      SYS_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
 *      (i.e., it was already signaled), the function may return zero.
 *
 *      Notice that lwIP implements a function with a similar name,
 *      sys_sem_wait(), that uses the sys_arch_sem_wait() function.
 * Inputs:
 *      sys_sem_t sem           -- Semaphore to wait on
 *      u32_t timeout           -- Number of milliseconds until timeout
 * Outputs:
 *      u32_t                   -- Time elapsed or SYS_ARCH_TIMEOUT.
 *---------------------------------------------------------------------------*/
u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) {
    u32_t start = us_ticker_read();
    
    if (osSemaphoreWait(sem->id, (timeout != 0)?(timeout):(osWaitForever)) < 1)
        return SYS_ARCH_TIMEOUT;
    
    return (us_ticker_read() - start) / 1000;
}
Пример #17
0
/*-----------------------------------------------------------------------------
  Routine to Move the Balls
 *----------------------------------------------------------------------------*/
void S_MoveBall (bool newBall){
	uint8_t i;
	uint8_t j;
	
	if (newBall & (actualBallNumber < maxNumberBalls)){
		ballArray[actualBallNumber][0] = plane_x+9;
		ballArray[actualBallNumber][1] = plane_y+5;
		actualBallNumber++;
	}

	for (i = 0; i < actualBallNumber; i++){
		osSemaphoreWait (glcd_semaph_id, osWaitForever);
			GLCD_SetForegroundColor (GLCD_COLOR_BLACK);
			GLCD_DrawPixel	(ballArray[i][0], ballArray[i][1]);
		osSemaphoreRelease(glcd_semaph_id);
		ballArray[i][0]+=2;
		// If the new position exceed the limits, it will be erased from the array and it wont be drawn
		if(ballArray[i][0] > GLCD_WIDTH ){
			actualBallNumber--;
			ballArray[i][0] = ballArray[actualBallNumber][0];
			ballArray[i][1] = ballArray[actualBallNumber][1];
		} else {
			osSemaphoreWait (glcd_semaph_id, osWaitForever);
				GLCD_SetForegroundColor (GLCD_COLOR_RED);
				GLCD_DrawPixel	(ballArray[i][0]+2, ballArray[i][1]);
			osSemaphoreRelease(glcd_semaph_id);
		}
		// Object is deleted if hit by a ball
		osMutexWait(objectVar_mutex_id, osWaitForever);
		for (j = 0; j < objectNumb; j++){
			if ( (ballArray[i][0] > objectArray[j][0]) & (ballArray[i][0] < objectArray[j][0]+9) & (ballArray[i][1] > objectArray[j][1]) & (ballArray[i][1] < objectArray[j][1]+9) ){
			osSemaphoreWait (glcd_semaph_id, osWaitForever);
				GLCD_SetForegroundColor (GLCD_COLOR_BLACK);
				S_DrawStar (objectArray[j][0], objectArray[j][1]);
				S_IncPlayerScore();
			osSemaphoreRelease(glcd_semaph_id);
				objectNumb--;
				objectArray[j][0] = objectArray[objectNumb][0];
				objectArray[j][1] = objectArray[objectNumb][1];
			}
		}
		osMutexRelease(objectVar_mutex_id);
	}

}
void BlinkTask(void const *argument)
{
	if(osSemaphoreWait(semHandle, osWaitForever) == osOK) {
		while(1) {
			HAL_GPIO_TogglePin(GPIOD, GPIO_PIN_12);
			osDelay(500);
		}
	}
}
Пример #19
0
/**
*@brief A function that gets the information recieved over wireless to be processed
*@param[inout] rxBuffer is the buffer to which the data is copied to
*@param[in] bufferSize The size of the passed in buffer
*@warning bufferSize must be of the same size as WIRELESS_BUFFER_SIZE, see wireless.h for details
*@retval None
*/
void getRecieved(uint8_t* rxBuffer, uint8_t bufferSize){
	
	uint8_t i = 0;
	for( i =0; i< bufferSize; i++){		
		osSemaphoreWait(rxId, osWaitForever);
		rxBuffer[i] = rxWireless[i]; //Critical access portion
		osSemaphoreRelease(rxId);
	}
}
Пример #20
0
static void demo_task1(void *arg)
{
    int count = 0;

    while (1) {
        osSemaphoreWait(pSem, 0xffffffff);
        printf("demo_task1 get sem %d\n", count++);
    };
}
Пример #21
0
CAN001_MessageHandleType* myCAN1_Get()
{
	CAN001_MessageHandleType* pmsg;
	if(can1rx.SendPos==can1rx.SendPos) osSemaphoreWait(can1rx_semaphore_id,osWaitForever);
	pmsg=&can1rx.buf[can1rx.SendPos];
	can1rx.SendPos++;
	can1rx.SendPos&=(MAXLINE-1);
	return pmsg;
}
Пример #22
0
/**
*@brief A function that safely access's the other board's accelerometer readings
*@param[inout] accValues A pointer to the new location in memory that data is copied to
*@retval None
*/
void getWirelessACCValues(float* accValues)
{
	
	int i = 0;
	for(i = 0; i < 3; i++){
		osSemaphoreWait(wirelessAccId, osWaitForever);
		accValues[i] = wirelessAccValues[i]; //Critical access portion
		osSemaphoreRelease(wirelessAccId);
	}
}
Пример #23
0
/*----------------------------------------------------------------------------
 *   Thread 2 - Normal Priority - looks for a free semaphore and uses
 *                                the resource whenever it is available
 *---------------------------------------------------------------------------*/
void thread2 (void const *argument) {
  while (1) {
    /* Wait indefinetly for a free semaphore */
    osSemaphoreWait (semaphore, osWaitForever);
    /* OK, the serial interface is free now, use it. */
    printf ("Thread 2\n");
    /* Return a token back to a semaphore. */
    osSemaphoreRelease (semaphore);
  }
}
Пример #24
0
/**
*@brief A function that safely access's the corrected values of the accelerometer
*@param[inout] accValues A pointer to the new location in memory that data is copied to
*@retval None
*/
void getACCValues(float* accValues)
{
	
	int i = 0;
	for(i = 0; i < 3; i++){
		osSemaphoreWait(accId, osWaitForever);
		accValues[i] = accCorrectedValues[i]; //Critical access portion
		osSemaphoreRelease(accId);
	}
}
Пример #25
0
/*!
 @brief Thread to display temperature
 @param argument Unused
*/
void temperature_DispFlag_thread(void const * argument)
{
	// Extracts the semaphore object from the argument.
	// This semaphore object was created in the main
	osSemaphoreId* semaphore;
	semaphore = (osSemaphoreId*)argument;
	
	uint8_t ResourceLocked = 1;  // Flag gets turned on if semaphore_lock achieved
	uint32_t tokentemp;          // Return of semwait
	
	// Wait for the semaphore with 1ms timeout
  osEvent event = osSignalWait(SIGNAL_DISP_TEMPERATURE, 1);

	while(1)
	{
		tokentemp=osSemaphoreWait (*semaphore, osWaitForever);
    ResourceLocked=1; // turn flag on if resource_locked		
		
    while (ResourceLocked)
		{
			// wait for a signal with 1ms timeout
			event = osSignalWait(SIGNAL_DISP_TEMPERATURE, 1);
			if (event.status == osEventTimeout)
			{
				// in case of timeout display
				LCD_DisplayTemperature(temp);
			}
			else
			{
				// signal received which is not timeout
				// clear the signal flag for the tilt display thread
				osSignalClear (tilt_TurnDispFlag_thread, SIGNAL_DISP_TILT);
				
				//clear the screen
				LCD_clear_display();
				
				// turn the resource_locked flag off
				ResourceLocked = 0;
				tokentemp=0;
				
				// turn the flag to display the string "temperature" once
				GLB_Temperature_display_flag=1;
				
				// release the semaphore 
				osSemaphoreRelease(*semaphore);
				
				//wait 5ms for the other thread to grab the semaphore
			  osDelay(5);
			}
		}
		
	}
	
}
Пример #26
0
void S_Thread_MovePlane (void const *arg){  
	uint16_t 	plane_x_last = 1;
	uint16_t 	plane_y_last = GLCD_HEIGHT/2;
	uint16_t 	plane_x_i;
	uint16_t 	plane_y_i;
	uint8_t		i;
	
	while(!stopThreads){
		osMutexWait(planeVar_mutex_id, osWaitForever);
		plane_x_i = plane_x;
		plane_y_i = plane_y;
		osMutexRelease(planeVar_mutex_id);
		
		if( (plane_x_last != plane_x_i) || (plane_y_last != plane_y_i) ){
		
			osSemaphoreWait (glcd_semaph_id, osWaitForever);
				S_DrawPlane(plane_x_last, plane_y_last, true);	// Delete last position plane
				S_DrawPlane(plane_x_i, plane_y_i, false);				// Draw new position plane
			osSemaphoreRelease(glcd_semaph_id);
			
			plane_x_last = plane_x_i;
			plane_y_last = plane_y_i;
		}
		
		osMutexWait(objectVar_mutex_id, osWaitForever);
		for (i = 0; i < objectNumb; i++){
			// If the square around the plane intersects with the square around the object: the plane is destroyed
			if ( ( (objectArray[i][0]>(plane_x_i-9)) & (objectArray[i][0]<(plane_x_i+9)) ) & 
				( (objectArray[i][1]>(plane_y_i-9)) & (objectArray[i][1]<(plane_y_i+9)) ) ){
				osSemaphoreWait (glcd_semaph_id, osWaitForever);
					GLCD_SetForegroundColor (GLCD_COLOR_YELLOW);
					S_DrawExplosion(plane_x_i, plane_y_i);
					S_IncMachineScore();
				osSemaphoreRelease(glcd_semaph_id);
			}
		}
		osMutexRelease(objectVar_mutex_id);
		
		osDelay(50);
	}
}
/**
 * @brief Thread function of LCD 
 * @param Not used
 * @retval None
 */
void lcd_thread(void const * argument)
{
  while (1)
  {
    osSemaphoreWait (lcd_semaphore, osWaitForever);
    if (getThreadToRun() == MODE_1)
    {
      //Accelerometer mode
      lcd_set_display_angles(getFilteredRollAngle(),getFilteredPitchAngle());
      lcd_display_string(line1, line2);
    }
  }
}
Пример #28
0
int ff_req_grant (  /* TRUE:Got a grant to access the volume, FALSE:Could not get a grant */
    _SYNC_t sobj    /* Sync object to wait */
)
{
  int ret = 0;

  if(osSemaphoreWait(sobj, _FS_TIMEOUT) == osOK)
  {
    ret = 1;
  }

  return ret;
}
Пример #29
0
/**
  * @brief  Semaphore Test.
  * @param  argument: Not used
  * @retval None
  */
static void SemaphoreTest(void const *argument)
{ 
  for(;;)
  {
    if (osSemaphore != NULL)
    {
      /* Try to obtain the semaphore */
      if(osSemaphoreWait(osSemaphore , 0) == osOK)
      {
        BSP_LED_Toggle(LED1);
      }
    }
  }
}
Пример #30
0
void SPI_DMA_xfer(uint8_t* write_buff, uint8_t* read_buff, GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, int numByte){

	// sema will be released in interrupt
	osSemaphoreWait(dmaSema_ID, osWaitForever);
	
	//set chip select low
	GPIO_ResetBits(GPIOx, GPIO_Pin);
	// wait for slave
	//while(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6) != Bit_RESET); 
	DMA2_Stream0->M0AR = (uint32_t)(&read_buff[0]);
	DMA2_Stream3->M0AR = (uint32_t)(&write_buff[0]);
	DMA2_Stream0->NDTR = numByte;
	DMA2_Stream3->NDTR = numByte;

	osDelay(10);

	DMA2_Stream0->CR |= DMA_SxCR_EN;
	DMA2_Stream3->CR |= DMA_SxCR_EN;
	
	osSemaphoreWait(dmaComplete_ID, osWaitForever);
	GPIO_SetBits(GPIOx, GPIO_Pin);

	osSemaphoreRelease(dmaSema_ID);
}