Пример #1
0
Файл: main.c Проект: IOIOI/nRF51
/**@brief Thread for handling the Application's BLE Stack events.
 *
 * @details This thread is responsible for handling BLE Stack events sent from on_ble_evt().
 *
 * @param[in]   arg   Pointer used for passing some arbitrary information (context) from the
 *                    osThreadCreate() call to the thread.
 */
void ble_stack_thread(void const * arg)
{
    uint32_t    err_code;
    osEvent     evt;
    ble_evt_t * p_ble_evt;

    UNUSED_PARAMETER(arg);

    while (1)
    {
        evt = osMessageGet(ble_stack_msg_box, osWaitForever); // wait for message

        if (evt.status == osEventMessage)
        {
            p_ble_evt = evt.value.p;

            switch (p_ble_evt->header.evt_id)
            {
                case BLE_GAP_EVT_CONNECTED:

                    err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
                    APP_ERROR_CHECK(err_code);
                    m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
                    break;

                default:
                    // No implementation needed.
                    break;
            }
            (void)osPoolFree(ble_evt_pool, p_ble_evt);
        }
    }
}
static void ecg_2_lead_gui_tick(state_ptr state)
{
  uint32_t i = 0;
  osEvent event;

  uint32_t bpm = 0;
  char str_bpm[4] = "-?-";

  int32_t lead_I = 0, lead_II = 0;

  /* Do transition actions */
  /* Get bpm data */
  event = osMessageGet(queue_ecg_bpm_screenHandle, 0);
  if (event.status == osEventMessage)
  {
    /* Retrieve value */
    bpm = (((uint32_t) event.value.v) >> 10);
    sprintf(str_bpm, "%u", bpm);

    item_area_set_text(&menu_ecg.items[1].item.area, str_bpm);
    while (osMailPut(queue_lcdHandle, (void *) &menu_ecg.items[1]) != osOK)
    {
      osDelay(1);
    }
  }
Пример #3
0
/**
  * @brief  Storage Thread
  * @param  argument: pointer that is passed to the thread function as start argument.
  * @retval None
  */
static void StorageThread(void const * argument)
{
  osEvent event;
  
  for( ;; )
  {
    event = osMessageGet( StorageEvent, osWaitForever );
    
    if( event.status == osEventMessage )
    {
      switch(event.value.v)
      {
      case USBDISK_CONNECTION_EVENT:
        f_mount(&USBDISK_FatFs,USBDISK_Drive,  0);
        StorageStatus[USB_DISK_UNIT] = 1;
        break;
        
      case USBDISK_DISCONNECTION_EVENT:
        f_mount(0, USBDISK_Drive, 0);
        StorageStatus[USB_DISK_UNIT] = 0;
        break;  
      }
    }
  }
}
Пример #4
0
// Handle command event processing.
void commandProcessingThread(void const *argument)
{
	UINT8 currentIndex;

	for (;;)
	{
		// Wait for a command message.
		osEvent commandEvent = osMessageGet(commandQueue, osWaitForever);

		// Is this a command event?
		if (commandEvent.status == osEventMessage)
		{
			// Point to the message.
			commandMessage *message = (commandMessage *) commandEvent.value.p;

			// Execute all the commands
			currentIndex = 0;
			while (currentIndex < message->length) {
				currentIndex += handleCommand(message, currentIndex);
			}

			// Free the message.
			osPoolFree(commandMemPool, message);
		}
	}
}
Пример #5
0
/**
  * @brief  Message Queue Consumer Thread.
  * @param  argument: Not used
  * @retval None
  */
static void MessageQueueConsumer (const void *argument)
{
  osEvent event;
  
  for(;;)
  {
    /* Get the message from the queue */
    event = osMessageGet(osQueue, 100);
    
    if(event.status == osEventMessage)
    {
      if(event.value.v != ConsumerValue)
      {
        /* Catch-up. */
        ConsumerValue = event.value.v;
        
        /* Toggle LED3 to indicate error */
        BSP_LED_Toggle(LED3);
      }
      else
      {  
        /* Increment the value we expect to remove from the queue next time
        round. */
        ++ConsumerValue;
      }			
    }		
  }
}
Пример #6
0
/*---------------------------------------------------------------------------*
 * Routine:  sys_arch_mbox_tryfetch
 *---------------------------------------------------------------------------*
 * Description:
 *      Similar to sys_arch_mbox_fetch, but if message is not ready
 *      immediately, we'll return with SYS_MBOX_EMPTY.  On success, 0 is
 *      returned.
 * Inputs:
 *      sys_mbox_t mbox         -- Handle of mailbox
 *      void **msg              -- Pointer to pointer to msg received
 * Outputs:
 *      u32_t                   -- SYS_MBOX_EMPTY if no messages.  Otherwise,
 *                                  return ERR_OK.
 *---------------------------------------------------------------------------*/
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg) {
    osEvent event = osMessageGet(mbox->id, 0);
    if (event.status != osEventMessage)
        return SYS_MBOX_EMPTY;
    
    *msg = (void *)event.value.v;
    
    return ERR_OK;
}
Пример #7
0
void MainTask()
{	
	for(;;)
	{
		// Wait for adc result and write it to the UART connected to the PC.
		osEvent result = osMessageGet(mainTaskMessageQId, osWaitForever);
		HAL_UART_Transmit(&huart2, (uint8_t*)&result.value.v, 4, 100);
	}
}
/**
  * @brief  Audio task
  * @param  argument: pointer that is passed to the thread function as start argument.
  * @retval None
  */
static void Audio_Thread(void const * argument)
{
  uint32_t numOfReadBytes;    
  osEvent event;  
  for(;;)
  {
    event = osMessageGet(AudioEvent, 100 );
    
    if( event.status == osEventMessage )
    {
      if(haudio.state == AUDIOPLAYER_PLAY)
      {
        switch(event.value.v)
        {
        case BUFFER_OFFSET_HALF:
          if(f_read(&wav_file, 
                    &haudio.buffer[0], 
                    AUDIO_BUFFER_SIZE/2, 
                    (void *)&numOfReadBytes) == FR_OK)
          { 
            if(numOfReadBytes == 0)
            {  
              haudio.state = AUDIOPLAYER_EOF;
            } 
          }
          else
          {
              haudio.state = AUDIOPLAYER_ERROR;    
          }
          break;  
          
        case BUFFER_OFFSET_FULL:
          if(f_read(&wav_file, 
                    &haudio.buffer[AUDIO_BUFFER_SIZE/2], 
                    AUDIO_BUFFER_SIZE/2, 
                    (void *)&numOfReadBytes) == FR_OK)
          { 
            if(numOfReadBytes == 0)
            { 
              haudio.state = AUDIOPLAYER_EOF;                     
            } 
          }
          else
          {
              haudio.state = AUDIOPLAYER_ERROR;   
          }
          break;   
          
        default:
          break;
        }
      }
      
    }
  }
}
Пример #9
0
/**@brief Thread for handling the Application's BLE Stack events.
 *
 * @details This thread is responsible for handling BLE Stack events sended from on_ble_evt().
 *
 * @param[in]   arg   Pointer used for passing some arbitrary information (context) from the
 *                    osThreadCreate() call to the thread.
 */
void ble_stack_thread(void const * arg)
{
    uint32_t    err_code;
    osEvent     evt;
    ble_evt_t * p_ble_evt;

    UNUSED_PARAMETER(arg);

    while (1)
    {
        evt = osMessageGet(ble_stack_msg_box, osWaitForever); // wait for message

        if (evt.status == osEventMessage)
        {
            p_ble_evt = evt.value.p;

            switch (p_ble_evt->header.evt_id)
            {
                case BLE_GAP_EVT_CONNECTED:

                    err_code = bsp_indication_set(BSP_INDICATE_CONNECTED);
                    APP_ERROR_CHECK(err_code);
                    m_conn_handle = p_ble_evt->evt.gap_evt.conn_handle;
                    break;

                case BLE_GAP_EVT_DISCONNECTED:
                    err_code = bsp_indication_set(BSP_INDICATE_IDLE);
                    APP_ERROR_CHECK(err_code);
                    advertising_start();
                    break;

                case BLE_GAP_EVT_TIMEOUT:

                    if (p_ble_evt->evt.gap_evt.params.timeout.src ==
                        BLE_GAP_TIMEOUT_SRC_ADVERTISING)
                    {
                        err_code = bsp_indication_set(BSP_INDICATE_IDLE);
                        APP_ERROR_CHECK(err_code);
                        // enable buttons to wake-up from power off
                        bsp_buttons_enable( (1 <<
                                             WAKEUP_BUTTON_ID) | (1 << BOND_DELETE_ALL_BUTTON_ID) );
                        // Go to system-off mode (this function will not return; wakeup will cause a reset).
                        err_code = sd_power_system_off();
                        APP_ERROR_CHECK(err_code);
                    }
                    break;

                default:
                    // No implementation needed.
                    break;
            }
            (void)osPoolFree(ble_evt_pool, p_ble_evt);
        }
    }
}
Пример #10
0
/*---------------------------------------------------------------------------*
 * Routine:  sys_arch_mbox_fetch
 *---------------------------------------------------------------------------*
 * Description:
 *      Blocks the thread until a message arrives in the mailbox, but does
 *      not block the thread longer than "timeout" milliseconds (similar to
 *      the sys_arch_sem_wait() function). The "msg" argument is a result
 *      parameter that is set by the function (i.e., by doing "*msg =
 *      ptr"). The "msg" parameter maybe NULL to indicate that the message
 *      should be dropped.
 *
 *      The return values are the same as for the sys_arch_sem_wait() function:
 *      Number of milliseconds spent waiting or SYS_ARCH_TIMEOUT if there was a
 *      timeout.
 *
 *      Note that a function with a similar name, sys_mbox_fetch(), is
 *      implemented by lwIP.
 * Inputs:
 *      sys_mbox_t mbox         -- Handle of mailbox
 *      void **msg              -- Pointer to pointer to msg received
 *      u32_t timeout           -- Number of milliseconds until timeout
 * Outputs:
 *      u32_t                   -- SYS_ARCH_TIMEOUT if timeout, else number
 *                                  of milliseconds until received.
 *---------------------------------------------------------------------------*/
u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout) {
    u32_t start = us_ticker_read();
    
    osEvent event = osMessageGet(mbox->id, (timeout != 0)?(timeout):(osWaitForever));
    if (event.status != osEventMessage)
        return SYS_ARCH_TIMEOUT;
    
    *msg = (void *)event.value.v;
    
    return (us_ticker_read() - start) / 1000;
}
// Receive the 'data' in the Message 'queue'. Returns 1 if a message was received, 0 otherwise.
int receive_message(float * data, osMessageQId queue){
	osEvent evt = osMessageGet(queue, 0); 
	if (evt.status == osEventMessage) {
		Message* msg = ((Message *)evt.value.p);
		*data = msg->data;			
		osPoolFree(mem_pool, msg);
		
		return 1;
	}
	
	return 0;
}
Пример #12
0
void blinkThread(void const *argument) {
  uint16_t delay = 500; /* Default delay */
  osEvent evt;

  while(1) {
    evt = osMessageGet(MsgBox, 1);
    if(evt.status == osEventMessage)
      delay = evt.value.v;

    HAL_GPIO_TogglePin(LD2_GPIO_Port, LD2_Pin);
    osDelay(delay);
  }
}
Пример #13
0
static void demo_task1(void *arg)
{
    osEvent event;

    while (1) {
        event = osMessageGet(p_msgqueue, osWaitForever);
        if (event.status == osEventMessage) {
            printf("demo_task1 get msg %d\n", event.value.v);
        } else {
            printf("demo_task1 get msg failed\n");
        }
    };
}
Пример #14
0
/**
  * @brief  USB Host Thread task
  * @param  pvParameters not used
  * @retval None
  */
static void USBH_Process_OS(void const * argument)
{
  osEvent event;
  
  for(;;)
  {
    event = osMessageGet(((USBH_HandleTypeDef *)argument)->os_event, osWaitForever );
    
    if( event.status == osEventMessage )
    {
      USBH_Process((USBH_HandleTypeDef *)argument);
    }
   }
}
/// Get a mail from a queue
osEvent osMailGet(osMailQId queue_id, uint32_t millisec)
{
  osEvent ret;

  if (queue_id == NULL) {
    ret.status = osErrorParameter;
    return ret;
  }

  ret = osMessageGet(*((void **)queue_id), millisec);
  if (ret.status == osEventMessage) ret.status = osEventMail;

  return ret;
}
Пример #16
0
/**
  * @brief  USBH_TEMPLATE_Init 
  *         The function Initialize the TEMPLATE function
  * @param  phost: Host handle
  * @retval USBH Status
  */
USBH_StatusTypeDef USBH_TEMPLATE_Init (USBH_HandleTypeDef *phost)
{
  USBH_StatusTypeDef Status = USBH_BUSY;
#if (USBH_USE_OS == 1)
  osEvent event;
  
  event = osMessageGet( phost->class_ready_event, osWaitForever );
  
  if( event.status == osEventMessage )      
  {
    if(event.value.v == USBH_CLASS_EVENT)
    {
#else 
      
  while ((Status == USBH_BUSY) || (Status == USBH_FAIL))
  {
    /* Host background process */
    USBH_Process(phost);
    if(phost->gState == HOST_CLASS)
    {
#endif        
      Status = USBH_OK;
    }
  }
  return Status;   
}

/**
  * @brief  USBH_TEMPLATE_IOProcess 
  *         TEMPLATE TEMPLATE process
  * @param  phost: Host handle
  * @retval USBH Status
  */
USBH_StatusTypeDef USBH_TEMPLATE_IOProcess (USBH_HandleTypeDef *phost)
{
  if (phost->device.is_connected == 1)
  {
    if(phost->gState == HOST_CLASS)
    {
      USBH_TEMPLATE_Process(phost);
    }
  }
  
  return USBH_OK;
}
Пример #17
0
/*----------------------------------------------------------------------------
 *  Thread 2: Receive thread
 *---------------------------------------------------------------------------*/
void recv_thread (void const *argument) {
  T_MEAS  *rptr;
  osEvent  evt;

  for (;;) {
    evt = osMessageGet(MsgBox, osWaitForever);  /* wait for message          */
    if (evt.status == osEventMessage) {
      rptr = evt.value.p;
      printf ("\nVoltage: %.2f V\n",rptr->voltage);
      printf ("Current: %.2f A\n",rptr->current);
      printf ("Number of cycles: %d\n",(int)rptr->counter);
      #ifdef __USE_FFLUSH
      fflush (stdout);
      #endif
      osPoolFree(mpool,rptr);         /* free memory allocated for message   */
    }
  }
}
Пример #18
0
/**************************************************************************//**
 * @brief
 *   Thread 1: Print LCD thread - modified to not use LCD
 *****************************************************************************/
void PrintLcdThread(void const *argument)
{
  lcdText_t *rptr;
  osEvent   evt;
  (void) argument;                 /* Unused parameter. */

  while (1)
  {
    /* Wait for message */
    evt = osMessageGet(msgBox, osWaitForever);
    if (evt.status == osEventMessage)
    {
      rptr = evt.value.p;
      /* Free memory allocated for message */
      osPoolFree(mpool, rptr);
    }
  }
}
Пример #19
0
/**
  * @brief  Start task
  * @param  pvParameters not used
  * @retval None
  */
static void StartThread(void const * argument)
{
  osEvent event;
  
  /* Init MSC Application */
  MSC_InitApplication();
  
  /* Init Host Library */
  USBH_Init(&hUSBHost, USBH_UserProcess, 0);
  
  /* Add Supported Class */
  USBH_RegisterClass(&hUSBHost, USBH_MSC_CLASS);
  
  /* Start Host Process */
  USBH_Start(&hUSBHost);
  
  /* Register the file system object to the FatFs module */
  if(f_mount(&USBH_fatfs, "", 0) != FR_OK)
  {  
    LCD_ErrLog("ERROR : Cannot Initialize FatFs! \n");
  }
  
  for( ;; )
  {
    event = osMessageGet(AppliEvent, osWaitForever);
    
    if(event.status == osEventMessage)
    {
      switch(event.value.v)
      {  
      case APPLICATION_DISCONNECT:
        Appli_state = APPLICATION_DISCONNECT;
        osSemaphoreRelease(MenuEvent);
        break;
        
      case APPLICATION_READY:
        Appli_state = APPLICATION_READY;
        
      default:
        break;
      }
    }
  }
}
Пример #20
0
static void LogCollector_Process_OS(void const * argument)
{
  osEvent event;

  for(;;)
  {
    event = osMessageGet(((EventLogger_Handle_TypeDef *)argument)->os_event, osWaitForever );

    //if(((EventLogger_Handle_TypeDef *)argument)-> LogStatus == LOG_BUFFER_FULL)

    if( event.status == osEventMessage  )
    {
    	((EventLogger_Handle_TypeDef *)argument)->pLogData = &Log_List[event.value.v];
    	((EventLogger_Handle_TypeDef*) argument)->Interface->WriteLog((EventLogger_Handle_TypeDef*) argument);
    	((EventLogger_Handle_TypeDef *)argument)->pLogData = 0;
    	LogIndex_List[event.value.v] = 0;
    }

    //osDelay(0);
   }
}
Пример #21
0
/**
  * @brief  Message Queue Consumer Thread.
  * @param  argument: Not used
  * @retval None
  */
static void QueueReceiveThread (const void *argument)
{
  osEvent event;
  
  for(;;)
  {
    /* Wait until something arrives in the queue. */
    event = osMessageGet(osQueue, osWaitForever);
    
    /*  To get here something must have arrived, but is it the expected
	value?  If it is, turn the LED on for a short while. */
    if(event.status == osEventMessage)
    {
      if(event.value.v == QUEUED_VALUE)
      {  
        BSP_LED_On(LED1);
        osDelay(LED_TOGGLE_DELAY);
        BSP_LED_Off(LED1);
      }			
    }		
  }
}
/**
  * @brief  Start task
  * @param  pvParameters not used
  * @retval None
  */
static void StartThread(void const *argument)
{
  osEvent event;
  
  /* Link the USB Host disk I/O driver */
  if(FATFS_LinkDriver(&USBH_Driver, USBDISKPath) == 0)
  {
    /* Init Host Library */
    USBH_Init(&hUSB_Host, USBH_UserProcess, 0);
    
    /* Add Supported Class */
    USBH_RegisterClass(&hUSB_Host, USBH_MSC_CLASS);
    
    /* Start Host Process */
    USBH_Start(&hUSB_Host);
    
    for( ;; )
    {
      event = osMessageGet(AppliEvent, osWaitForever);
      
      if(event.status == osEventMessage)
      {
        switch(event.value.v)
        {
        case CONNECTION_EVENT:
          MSC_Application();
          break;
          
        case DISCONNECTION_EVENT:
          f_mount(NULL, (TCHAR const*)"", 0);
          break;
          
        default:
          break;
        }
      }
    }
  }
}
/**
* @brief Wait for a generic message in the queue and copy out the generic message upon arrival
* @param msgQ: Message Q to send the message to
* @param *messagePtr: Pointer to a generic message struct
* @param timeout: How long the operating system must wait until the message is successfully placed in message Q msgQ
*/
void fetchMessage(osMessageQId msgQ, msg_genericMessage_t *messagePtr, uint32_t timeout) {
  osEvent messageEvent;
  msg_genericMessage_t *messageRxPtr;

  // Wait for a message in the message Q, msgQ
  messageEvent = osMessageGet(msgQ, timeout);

  // If the recieved data is a message
  if (messageEvent.status == osEventMessage) {
    // Grab the pointer to the generic message and copy it into the externally declared message struct
    messageRxPtr = messageEvent.value.p;
    memcpy(messagePtr, messageRxPtr, sizeof(msg_genericMessage_t));

    // Then free the message from the global memory pool
    osPoolFree(genericMPool, messageRxPtr);

  } else {
    // If there was no message received after the timeout value, set the type to NULL to indicate this
    messagePtr->messageType = MSG_TYPE_NO_MESSAGE;

  }
}
Пример #24
0
/**
  * @brief  Start task
  * @param  pvParameters not used
  * @retval None
  */
static void StartThread(void const * argument)
{
  osEvent event;
  
  /* Init HID Application */
  HID_InitApplication();
  
  /* Start Host Library */
  USBH_Init(&hUSBHost, USBH_UserProcess, 0);
  
  /* Add Supported Class */
  USBH_RegisterClass(&hUSBHost, USBH_HID_CLASS);
  
  /* Start Host Process */
  USBH_Start(&hUSBHost);
  
  for( ;; )
  {
    event = osMessageGet( AppliEvent, osWaitForever );
    
    if( event.status == osEventMessage )
    {
      switch(event.value.v)
      {  
      case APPLICATION_DISCONNECT:
        Appli_state = APPLICATION_DISCONNECT; 
        HID_UpdateMenu();
        break;
        
      case APPLICATION_READY:
        Appli_state = APPLICATION_READY;
        
      default:
        break;
      }
    }
  } 
}
Пример #25
0
/**
  * @brief  Audio task
  * @param  argument: pointer that is passed to the thread function as start argument.
  * @retval None
  */
static void Audio_Thread(void const * argument)
{
  uint32_t numOfReadBytes;    
  osEvent event;  
  for(;;)
  {
    event = osMessageGet(AudioEvent, 100 );
    
    if( event.status == osEventMessage )
    {
      if(haudio.out.state == AUDIOPLAYER_PLAY)
      {
        switch(event.value.v)
        {
        case PLAY_BUFFER_OFFSET_HALF:
          if(f_read(&wav_file, 
                    &haudio.buff[0], 
                    AUDIO_OUT_BUFFER_SIZE/2, 
                    (void *)&numOfReadBytes) == FR_OK)
          { 
            if(numOfReadBytes == 0)
            {  
              haudio.out.state = AUDIOPLAYER_EOF;
            } 
            
#if (!defined ( __GNUC__ )) 
            SpiritEQ_Apply((void *)AUDIO_EqInstance,
                           /* NB_Channel */2, 
                           (int16_t *)&haudio.buff[0], 
                           numOfReadBytes  / 4);
            
            /* Apply Loudness settings */
            SpiritLdCtrl_Apply((TSpiritLdCtrl *)AUDIO_LdCtrlPersistance,
                               /* NB_Channel */ 2, 
                               (int16_t *)&haudio.buff[0], 
                               numOfReadBytes / 4, 
                               (void *)AUDIO_LdCtrlScratch);            
            
#endif
          }
          else
          {
              haudio.out.state = AUDIOPLAYER_ERROR;    
          }
          break;  
          
        case PLAY_BUFFER_OFFSET_FULL:
          if(f_read(&wav_file, 
                    &haudio.buff[AUDIO_OUT_BUFFER_SIZE/2], 
                    AUDIO_OUT_BUFFER_SIZE/2, 
                    (void *)&numOfReadBytes) == FR_OK)
          { 
            if(numOfReadBytes == 0)
            { 
              haudio.out.state = AUDIOPLAYER_EOF;                     
            } 
#if (!defined ( __GNUC__ ))            
            SpiritEQ_Apply((void *)AUDIO_EqInstance,
                           /* NB_Channel */2, 
                           (int16_t *)&haudio.buff[AUDIO_OUT_BUFFER_SIZE /2], 
                           numOfReadBytes  / 4);
            
            
            /* Apply Loudness settings */
            SpiritLdCtrl_Apply((TSpiritLdCtrl *)AUDIO_LdCtrlPersistance,
                               /* NB_Channel */ 2, 
                               (int16_t *)&haudio.buff[AUDIO_OUT_BUFFER_SIZE /2], 
                               numOfReadBytes / 4, 
                               (void *)AUDIO_LdCtrlScratch);                
#endif   
          }
          else
          {
              haudio.out.state = AUDIOPLAYER_ERROR;   
          }
          break;   
          
        default:
          break;
        }
      }
      
    }

  }
}
Пример #26
0
/**
  * @brief  Concurrent task
  * @param  pvParameters not used
  * @retval None
  */
static void ConcurrentThread(void const *argument)
{
  osEvent event;
  FRESULT res;                                          /* FatFs function common result code */
  uint16_t byteswritten;                                /* File write count */
  uint8_t wtext[] = "This is STM32 working with FatFs"; /* File write buffer */
  
  for( ;; )
  {
    event = osMessageGet(DiskEvent, osWaitForever);
    
    if(event.status == osEventMessage)
    {
      switch(event.value.v)
      {
      case DISK_READY_EVENT:
        /* Create and Open a new text file object with write access */
        if(f_open(&MyFile2, "STM32_2.TXT", FA_CREATE_ALWAYS | FA_WRITE) != FR_OK) 
        {
          /* 'STM32_2.TXT' file Open for write Error */
          Error_Handler();
        }
        else
        {
          /* Write data to the text file */
          res = f_write(&MyFile2, wtext, sizeof(wtext), (void *)&byteswritten);
          
          if((byteswritten == 0) || (res != FR_OK))
          {
            /* 'STM32_2.TXT' file Write or EOF Error */
            Error_Handler();
          }
          else
          {
            /* Close the open text file */
            f_close(&MyFile2);
            
            /* If last access to Disk, unlink drive */
            if(disk_op == 1)
            {
              osMessagePut(DiskEvent, DISK_REMOVE_EVENT, 0);
            }
            
            disk_op = 2;
            
            /* Success of the demo: no error occurrence */
            BSP_LED_On(LED4); 
          }
        }
        break;
        
      case DISK_REMOVE_EVENT:
        /* Unlink the USB disk I/O driver */
        FATFS_UnLinkDriver(USBDISKPath);       
        break;
        
      default:
        break; 
      }
    }
  }
}
Пример #27
0
/*---------------------------------------------------------------------------*
 * Routine:  sys_mbox_free
 *---------------------------------------------------------------------------*
 * Description:
 *      Deallocates a mailbox. If there are messages still present in the
 *      mailbox when the mailbox is deallocated, it is an indication of a
 *      programming error in lwIP and the developer should be notified.
 * Inputs:
 *      sys_mbox_t *mbox         -- Handle of mailbox
 *---------------------------------------------------------------------------*/
void sys_mbox_free(sys_mbox_t *mbox) {
    osEvent event = osMessageGet(mbox->id, 0);
    if (event.status == osEventMessage)
        error("sys_mbox_free error\n");
}
/**
  * @brief  Audio task
  * @param  argument: pointer that is passed to the thread function as start argument.
  * @retval None
  */
static void Audio_Thread(void const * argument)
{
  uint32_t numOfReadBytes, numOfWrittenBytes;    
  osEvent event;  
  for(;;)
  {
    event = osMessageGet(AudioEvent, 100 );
    
    if( event.status == osEventMessage )
    {
      if(haudio.in.state == AUDIO_RECORDER_PLAYING)
      {
        switch(event.value.v)
        {
        case PLAY_BUFFER_OFFSET_HALF:
          if(f_read(&wav_file, 
                    &haudio.buff[0], 
                    AUDIO_OUT_BUFFER_SIZE/2, 
                    (void *)&numOfReadBytes) == FR_OK)
          { 
            if(numOfReadBytes == 0)
            {  
              AUDIO_RECORDER_StopPlayer();
            } 
            
          }
          else
          {
            AUDIO_RECORDER_StopPlayer(); 
          }
          break;  
          
        case PLAY_BUFFER_OFFSET_FULL:
          if(f_read(&wav_file, 
                    &haudio.buff[AUDIO_OUT_BUFFER_SIZE/2], 
                    AUDIO_OUT_BUFFER_SIZE/2, 
                    (void *)&numOfReadBytes) == FR_OK)
          { 
            if(numOfReadBytes == 0)
            { 
              AUDIO_RECORDER_StopPlayer();  
            } 
          }
          else
          {
            AUDIO_RECORDER_StopPlayer();          
          }
          break;   
          
        default:
          break;
        }
      }
      /* Recording .... */
      if(haudio.in.state == AUDIO_RECORDER_RECORDING)
      {
        switch(event.value.v)
        {
          
        case REC_BUFFER_OFFSET_HALF:
          if(f_write(&wav_file, (uint8_t*)(haudio.buff), 
                     AUDIO_IN_BUFFER_SIZE/2, 
                     (void*)&numOfWrittenBytes) == FR_OK)
          { 
            if(numOfWrittenBytes == 0)
            { 
              AUDIO_RECORDER_StopRec();
            } 
          }
          else
          {
            AUDIO_RECORDER_StopRec();
          }
          haudio.in.fptr += numOfWrittenBytes;
          break; 
          
          
        case REC_BUFFER_OFFSET_FULL:
          if(f_write(&wav_file, (uint8_t*)(haudio.buff + AUDIO_IN_BUFFER_SIZE/2), 
                     AUDIO_IN_BUFFER_SIZE/2, 
                     (void*)&numOfWrittenBytes) == FR_OK)
          { 
            if(numOfWrittenBytes == 0)
            { 
              AUDIO_RECORDER_StopRec();
            } 
          }
          else
          {
            AUDIO_RECORDER_StopRec();
          }
          haudio.in.fptr += numOfWrittenBytes;
          break; 
          
          
        default:
          break;
        }
      }
      
    }

  }
}
Пример #29
0
/* 过零点触发中断 回调函数 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  
  if (GPIO_Pin != ZERO) 
    return;
  
  bool wave_is_rise;
  // 读Pin,判断是上升沿还是下降沿    
  if (HAL_GPIO_ReadPin(PORT_ZERO, ZERO) == GPIO_PIN_RESET) {
    wave_is_rise = true;
  }
  else {
    wave_is_rise = false;
  }
  
  
  // t 顺序: 1 3 4 6
  
  // 上升沿
  if (wave_is_rise) {
    t4 = __HAL_TIM_GET_COUNTER(&htim3);
    // 上升沿是否valid?
    //      if (!it_is_valid(t4_prev, t4)) {
    //          t4_prev = t4;
    //          r++;
    //          return;
    //      }
    //r++;
  }
  else {
    // 下降沿
    t6 = __HAL_TIM_GET_COUNTER(&htim3);
    // 下降沿是否valid?
    //      if (!it_is_valid(t6_prev, t6)) {
    //          t6_prev = t6;
    //          f++;
    //          return;
    //      }
    //f++;
  }
  
  if (wave_is_rise)  // 只在波谷计算,否则退出
    return;
  
  is_lower_blow = true;  // 设置波谷flag
  is_lower_exchange = true;
  is_lower_feed = true;
  
  /* 下降沿时计算下一个零点 */ 
  // t2
  if (t3 < t1)
    t2 = (0xffff + t1 + t3) / 2;
  else
    t2 = (t1 + t3) / 2;
  
  // t5
  if (t6 < t4)
    t5 = (0xffff + t4 + t6) / 2;
  else
    t5 = (t4 + t6) / 2;
  
  // 交流电源周期
  if (t5 < t2)
    T1 = 0xffff + t5 - t2;
  else
    T1 = t5 - t2;
  // 下一个零点
  if (t5 < t4)
    t7 = t5 + 0xffff - t4 + (T1 / 4);  /*  计算不对 ! */
  else
    t7 = t5 - t4 + (T1 / 4);
  
//  counter++;
//  if (counter >=299) {
//    //printf("t4:%d,t5:%d,t6:%d,t7:%d,T1:%d\r\n", t4,t5,t6,t7,T1);
//    printf("delay:%d\r\n", t7 + TOTAL_TIME - triac_cur.fan_smoke_delay * 100);
//    counter = 0;
//  }      
  
  // 更新数值
  t1 = t4;
  t2 = t5;
  t3 = t6;
  
  // 计数器复位
  __HAL_TIM_SET_COUNTER (&htim1, 0);
  __HAL_TIM_SET_COUNTER (&htim4, 0);
  
  // 检查Q_Triac队列,更新输出的控制状态
  if (Q_TriacHandle != NULL) {
    
    // 读取值
    osEvent evt = osMessageGet(Q_TriacHandle, 0);
    if (evt.status == osEventMessage) {        
      triac_cur = *((Triac *)evt.value.p);   
      
      // 更新送料duty
      on_count = triac_cur.feed_duty * 100;
      off_count = 1000 - on_count;  // 10s = 10000ms 10000 / 10 = 1000
      
      // 返还内存
      osStatus status = osPoolFree(pool_TriacHandle, evt.value.p);
      if (status != osOK)
        printf("Free Triac memory error:%x\r\n", status);
    }
  }
  
  // 设置period
  __HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_1, t7 + TOTAL_TIME - triac_cur.fan_smoke_delay * 100);  // 80÷100×10×1000 = 80×100
  
  __HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_2, t7 + TOTAL_TIME - triac_cur.fan_exchange_delay * 100);
  __HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_3, t7);
  
  /* 输出: 条件判断  */
  
  HAL_StatusTypeDef status;
  
  //排烟通道
  if (triac_cur.fan_smoke_is_on) {
    status = HAL_TIM_OC_Start_IT(&htim4, TIM_CHANNEL_1);
    if (status != HAL_OK)
      printf("time4 c1 failed at zero:%x\r\n", status);
  }
  
  //循环通道
  if (triac_cur.fan_exchange_is_on) {
    status = HAL_TIM_OC_Start_IT(&htim4, TIM_CHANNEL_2);
    if (status != HAL_OK)
      printf("time4 c2 failed:%x\r\n", status);
  }
  
  //送料通道 ON计数 OFF计数
  if (triac_cur.feed_is_on) {
    // 送料
    if (running_feed) {
      if (on_cnt < on_count) {
        // 输出 送料: On        
        HAL_TIM_OC_Start_IT(&htim4, TIM_CHANNEL_3);
        on_cnt++;
      }
      else {
        on_cnt = 0;
        off_cnt = 0;
        running_feed = false;
        waiting_feed = true;
      }
      
    }
    // 不送料
    if (waiting_feed) {
      off_cnt ++;
      if (off_cnt >= off_count) {
        on_cnt = 0;
        off_cnt = 0;
        running_feed = true;
        waiting_feed = false;
        
      }
      
    }
  }
// 
}
Пример #30
0
/* 过零点触发中断 回调函数 */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
  
  if (GPIO_Pin != ZERO) 
    return;
  
  bool rising_edge;
  // 读Pin,判断是上升沿还是下降沿    
  if (HAL_GPIO_ReadPin(PORT_ZERO, ZERO) == GPIO_PIN_SET) {
    rising_edge = true;
  }
  else {
    rising_edge = false;
  }
  
  // t 顺序: 1 3 4 6
  
  // 上升沿
  if (rising_edge) {
    t6 = __HAL_TIM_GET_COUNTER(&htim3);
  }
  else {
    // 下降沿
    t4 = __HAL_TIM_GET_COUNTER(&htim3);
  }

  if (!rising_edge)  // 只在波谷计算,否则退出
    return;
  
/*----------------------------------------------------------------------------*/
    
  is_lower_blow = true;  // 设置波谷flag
  is_lower_exchange = true;
  is_lower_feed = true;
  
  /* 下降沿时计算下一个零点 */ 
  // t1 t3 t4 t6
  if ((t1<t3) && (t3<t4) && (t4<t6)) {  
    t2 = (t1+t3) / 2; 
    t5 = (t4+t6) / 2;
  }
  else if(t3<t1) {
    t2 = (t1+t3+0xffff) / 2;
    t5 = (t4+t6)/2 + 0xffff;
  }
  else if(t4<t3) {
    t2 = (t1+t3) / 2;
    t5 = (t4+t6)/2 + 0xffff;
  }
  else if(t6<t4) {
    t2 = (t1+t3) / 2;
    t5 = (t4+t6+0xffff) / 2;
  }
  
    T1 = t5 - t2;
    
    // 下一个零点    
  if (t6<t5) {
    t7 = t5 + T1/4 - t6 -0xffff;
  }
  else {
    t7 = t5 + T1/4 - t6;
  }  

  //  debug
//  counter++;
//  if (counter >= 149) {
//    Zero *z;
//    z = (Zero*)osPoolAlloc(pool_ZeroHandle);
//    if (z!=NULL) {
//      z->t1 = t1;
//      z->t3 = t3;
//      z->t4 = t4;
//      z->t6 = t6;
//      z->t7 = t7;
//      z->T1 = T1;
//      osMessagePut(Q_ErrorHandle, (uint32_t)z, 0);
//    }
//    
//    counter = 0;
//  }  
//  
  
  // 更新数值
  t1 = t4;
  t3 = t6;
    
  /*--------------------------------------------------------------------------*/
  
  // 只处理下半波
  
  if (t7 == 0) {
    t7 = 220;
  }
  
  is_lower_blow = true;  // 设置波谷flag
  is_lower_exchange = true;
  is_lower_feed = true;
  
  //uint32_t compare = 0;
  
  // 检查Q_Triac队列,更新输出的控制状态
  if (Q_TriacHandle != NULL) {    
    // 读取值
    osEvent evt = osMessageGet(Q_TriacHandle, 0);
    if (evt.status == osEventMessage) {  
      Triac *p = (Triac *)evt.value.p;  
      
      triac_cur.fan_exchange_delay = p->fan_exchange_delay; 
      triac_cur.fan_exchange_is_on = p->fan_exchange_is_on;
      triac_cur.fan_smoke_is_on = p->fan_smoke_is_on;
      triac_cur.fan_smoke_power = p->fan_smoke_power;
      triac_cur.feed_by_manual = p->feed_by_manual;
      triac_cur.feed_duty = p->feed_duty;
      triac_cur.feed_full = p->feed_full;
      triac_cur.feed_is_on = p->feed_is_on;
      
      // 更新送料duty
      if (triac_cur.feed_duty != 0) {
        // 500×triac_cur.feed_duty÷100
        on_count = 5 * triac_cur.feed_duty;  
        off_count = 500 - on_count;  // 10s = 10000ms 10000 / 20 = 500
      }
       
      // 返还内存
      osStatus status = osPoolFree(pool_TriacHandle, evt.value.p);
      if (status != osOK)
        printf("Free Triac memory error:%x\r\n", status);
    }
  }
  
/*----------------------------------------------------------------------------*/
  
  
  // 设置period
  if (triac_cur.fan_smoke_power == 0) { 
    triac_cur.fan_smoke_power = 60;
  }
  
  // 最低延时2.5ms,最高延时6ms
  uint32_t delay = t7 + triac_cur.fan_smoke_power;  
  if (delay>8999) {
    delay = last_delay;    
  }
  else {
    last_delay = delay;
  }
  
  
    // 计数器复位
  __HAL_TIM_SET_COUNTER (&htim2, 0);
  __HAL_TIM_SET_COUNTER (&htim4, 0);
  
  __HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_1, delay); 
  __HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_2, t7+T1/4);
  __HAL_TIM_SET_COMPARE(&htim4, TIM_CHANNEL_3, t7+T1/4);
  
  
  /* 输出: 条件判断  */  

  //排烟通道
  if (triac_cur.fan_smoke_is_on) {
     __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC1);
  }
    
  //循环通道
  if (triac_cur.fan_exchange_is_on) {
    __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC2);
  }
    
  //送料通道
  if ((triac_cur.feed_by_manual || triac_cur.feed_full) && (!triac_cur.feed_is_on)) {
    __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC3);
  }
  //送料通道 ON计数 OFF计数
  if (triac_cur.feed_is_on && (!triac_cur.feed_by_manual)) {  // 0
    // 送料
    if (feed_run) {
      __HAL_TIM_ENABLE_IT(&htim4, TIM_IT_CC3);      
      count_feed ++;
      if (count_feed >= on_count) {        
        count_feed = 0;
        feed_run = false;
      }
      
    } 
    else {
      // 不送料
      count_feed ++;
      if (count_feed >= off_count) {
        count_feed = 0;
        feed_run = true;        
      }
    }  
  } // if 0
  
}