AnsweredAssumed Answered

problem with runnint timer interrrupt in RTX kernel(stm32 discovery)

Question asked by ali.seyed on Jan 20, 2014
Latest reply on Jan 24, 2014 by ali.seyed
hi everybody
i need to receive a ppm wave form, from a rc(remote controller)
so i first created a simple wave form just like a pwm(for simulating before using a real rc) which is like a ppm wave form with 8 channels
and then i tried to receive it using a timer and it's interrupt for detecting rising edge(i defined timer as input capture)
each time an rising edge occurs, in the timer event handler, i send a signal to the related task to compute information from ppm(waking up the task from wait_or mode)
but problem is that program works fine, before os_evt_wait_or()
just when program arrives to line 69(exactly where the task is in the wait_or() ), it stops!!!
here is my code
===============================================================

#include "main.h"
#include "RTL.h"

// =============================================================================

OS_TID tsk_id;

//array for storing 'pulse width' of each channel
typedef struct
{
    
    uint32_t pw1;
    uint32_t pw2;
    uint32_t pw3;
    uint32_t pw4;
    uint32_t pw5;
    uint32_t pw6;
    uint32_t pw7;
    uint32_t pw8;
    
}pw;
pw pulswidth;
uint8_t channel=0;
uint32_t IC2Value=0,length=0;
// =============================================================================

void TIM_Config(void);

// =============================================================================

__task void task1(void);
__task void TaskInit(void);

// =============================================================================
// =============================================================================

int main(void)
{
    
  TIM_Config();
  os_sys_init(TaskInit);
    
}
// =============================================================================
// =============================================================================

__task void TaskInit(void)
{

    while (1)
      {
        
        tsk_id = os_tsk_create(task1,10);
        os_tsk_delete_self();
        
    }
}

// =============================================================================
__task void task1(void)
{
    
  RCC_ClocksTypeDef RCC_Clocks;
  RCC_GetClocksFreq(&RCC_Clocks);
    
    while (1)
      {
        // waiting for timer interrupt wich will arrive throught event handler
        os_evt_wait_or(0x0004,0xffff);
        
        //GPIO_SetBits(GPIOD, GPIO_Pin_14);
        
//         if(TIM_GetITStatus(TIM4, TIM_IT_CC2) == SET)
//         {


          /* Clear TIM4 Capture compare interrupt pending bit */
          TIM_ClearITPendingBit(TIM4, TIM_IT_CC2);

          /* Get the Input Capture value */
          IC2Value = TIM_GetCapture2(TIM4);
            
            // to avoid dividing by zero!
            if (IC2Value != 0)
                {
                    /* Duty cycle computation */
                length = (TIM_GetCapture1(TIM4) * 100) / IC2Value;
        
                    // if lenght is bigger than pulse priod, it means that it is not data!
                    // it is a gap for sending a new frame of data
                    // so channel number initializes to zero to getting new data
                    if(length > 16000000)
                    {
                    channel = 0;
                    }
                
                // for data channel switching
                switch(channel)
                {
                    case 1:
                        pulswidth.pw1 = length;
                    break;
                    case 2:
                        pulswidth.pw2 = length;
                    break;
                    case 3:
                        pulswidth.pw3 = length;
                    break;
                    case 4:
                        pulswidth.pw4 = length;
                    break;
                    case 5:
                        pulswidth.pw5 = length;
                    break;
                    case 6:
                        pulswidth.pw6 = length;
                    break;
                    case 7:
                        pulswidth.pw7 = length;
                    break;
                    case 8:
                        pulswidth.pw8 = length;
                    break;
                    default:
                        channel = 0;
                    break;
                }
                
                channel++;
    
                }
            else
            {

            length = 0;

            }
//         }    
    }
}

// =============================================================================

void TIM_Config(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  TIM_ICInitTypeDef TIM_ICInitStructure;

  /* TIM4 clock enable */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);

  /* GPIOB clock enable */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
 
  /* TIM4 chennel2 configuration : PB.07 */
  GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_UP ;
  GPIO_Init(GPIOB, &GPIO_InitStructure);
 
  /* Connect TIM pin to AF2 */
  GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_TIM4);

  /* Enable the TIM4 global Interrupt */
  NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
    
//=================================================================    

    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15 ;
    GPIO_Init(GPIOD, &GPIO_InitStructure);
//=================================================================

 
  TIM_ICInitStructure.TIM_Channel = TIM_Channel_2;
  TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;
  TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
  TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  TIM_ICInitStructure.TIM_ICFilter = 0x0;

  TIM_PWMIConfig(TIM4, &TIM_ICInitStructure);

  /* Select the TIM4 Input Trigger: TI2FP2 */
  TIM_SelectInputTrigger(TIM4, TIM_TS_TI2FP2);

  /* Select the slave Mode: Reset Mode */
  TIM_SelectSlaveMode(TIM4, TIM_SlaveMode_Reset);
  TIM_SelectMasterSlaveMode(TIM4,TIM_MasterSlaveMode_Enable);

  /* TIM enable counter */
  TIM_Cmd(TIM4, ENABLE);

  /* Enable the CC2 Interrupt Request */
   TIM_ITConfig(TIM4, TIM_IT_CC2, ENABLE);
    
}

// =============================================================================
//sendin a signal to task1, to getting data
 void TIM4_IRQHandler(void) __irq
{
    
    GPIO_SetBits(GPIOD, GPIO_Pin_12);
    os_evt_set(0x0004,tsk_id);
    GPIO_SetBits(GPIOD, GPIO_Pin_13);
}

Outcomes