Manchester Decode by using PWM Input Capture Function via stm32 MCU

MCU ST STM32F091RC

Hardware Interface Port, here we use PB01, TIM14, Channel 1.

Manchester code comes from TDA5225 receiver PP2 PIN. Carrier frequncy = 315MHz, data baudrate is about 9600 bit/s, However, this firmware we support much wide rate.

See the code here:

/*******************************************************************************
  * @file    tda5225_value_tim14.c
  * @author  Milo lu
  * @brief   Capture mancherster code by using tim14 pwm capture/Compare function.
  *         
  @Versions description:
  * v1.0.0
  * 1. adapted,first functional draft 
*/
/* Includes ------------------------------------------------------------------*/
#include "tda5225_value_tim14.h"

/** @addtogroup STM32F0xx_HAL_Examples
  * @{
  */

/** @addtogroup Templates
  * @{
  */

/* Private typedef -----------------------------------------------------------*/
#define MANCHESTER_LENGTH       32
/* Private define ------------------------------------------------------------*/
#define COMBINATION_BITS        0xC000
/*          ____    
  0 ->10 ->     |____   */
#define MANCHESTER_0            0x8000
/*                ____
  1 ->01 ->  ____|      */
#define MANCHESTER_1            0x4000
#define FDEV_ERROR              0x01F4
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Timer handler declaration */
TIM_HandleTypeDef       g_h_tim14;
/* Timer Input Capture Configuration Structure declaration */
TIM_IC_InitTypeDef      sICConfig;
CaptureStepTypeDef     CAPTURE_STEP = RFPREAMBLE;

uint32_t uwPulseTM_Baseline_Val,uwPulseTM_Baseline_DVal;
uint16_t uw_Current_Pulse_Tim,uw_Last_Pulse_Tim;
uint16_t uwIC1_Start_Val,uwIC1_End_Val,uwPulse_Approximated_Val;
uint16_t uwPulseTIM_BUF[8];
uint16_t RF_MANCHESTER_DATA_BUF[MANCHESTER_LENGTH];
uint8_t  Manchester_Index;
uint8_t  RF_DATA_BUF[(MANCHESTER_LENGTH>>1)];
/* Private function prototypes -----------------------------------------------*/
HAL_StatusTypeDef manchester_decoding(unsigned int dat,unsigned char *manchester_out);
HAL_StatusTypeDef LF_TIM14_PWM_Init(void);
HAL_StatusTypeDef RF_Receved_Start(FunctionalState k);
/* Private functions ---------------------------------------------------------*/
/**--------------------------- Manchester --------------------------------*
  * @brief  decoding manchester code
  * @param  dat--input manchester code
  * @param  *manchester_out data output
  * @retval HAL status
  * byte encoding manchester format
  *          |     ____|
  * 1 ->01 ->|____|    |
  *          |         |
  *          |____     |
  * 0 ->10 ->|    |____|
  *          |         |
  */
HAL_StatusTypeDef manchester_decoding(unsigned int dat,unsigned char *manchester_out)
{
    unsigned char i;
    unsigned int k;
    *manchester_out=0;
    for(i=0;i<8;i++)
    {
      k=dat&COMBINATION_BITS;
      if(k==MANCHESTER_1)
      {
        *manchester_out<<=1;
        *manchester_out+=1;
      }
      else if(k==MANCHESTER_0)
      {
        *manchester_out<<=1;
      }
      else
      {
        return HAL_ERROR;
      }
      dat<<=2;
    }
    return HAL_OK;
}

/**--------------------------- TIM14 --------------------------------*
  * 
  * @brief  Initializes the TIM1 PWM Time Base according to the specified
  *         parameters in the TIM_HandleTypeDef and create the associated handle.
  *         PWM capture/compare function by using tim14
  *         5000 CNT * 9600 = 48MHz
  * @param  None
  * @retval None
  */
HAL_StatusTypeDef LF_TIM14_PWM_Init(void)
{
  /*##-1- Configure the TIM peripheral #######################################*/
  /* TIM14 configuration: Input Capture mode ---------------------
     The external signal is connected to TIM14 CH1 pin (PB01)  
     The Both edge is used as active edge,
     The TIM14 CCR2 is used to compute the frequency value 
  ------------------------------------------------------------ */
  /*Set TIM14 instance*/
  g_h_tim14.Instance = TIM14;
  /* Initialize TIM14 peripheral as follows:
       + Period = 0xFFFF
       + Prescaler = 0
       + ClockDivision = 0
       + Counter direction = Up
  */
  g_h_tim14.Init.Period            = 0xFFFF;
  g_h_tim14.Init.Prescaler         = 0;
  g_h_tim14.Init.ClockDivision     = 0;
  g_h_tim14.Init.CounterMode       = TIM_COUNTERMODE_UP;
  g_h_tim14.Init.RepetitionCounter = 0;
  g_h_tim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if(HAL_TIM_IC_Init(&g_h_tim14) != HAL_OK)
  {
    /* Configuration Error */
    return HAL_ERROR;
  }
  /*##-2- Configure the Input Capture channel ################################*/ 
  /* Configure the Input Capture of channel 1 */
  sICConfig.ICPolarity  = TIM_ICPOLARITY_BOTHEDGE;
  sICConfig.ICSelection = TIM_ICSELECTION_DIRECTTI;
  sICConfig.ICPrescaler = TIM_ICPSC_DIV1;
  sICConfig.ICFilter    = 0;  
  if(HAL_TIM_IC_ConfigChannel(&g_h_tim14, &sICConfig, TIM_CHANNEL_1) != HAL_OK)
  {
    /* Configuration Error */
    return HAL_ERROR;
  }
  return HAL_OK;
}
HAL_StatusTypeDef RF_Receved_Start(FunctionalState k)
{
  /*##-3- Start/Stop the Input Capture in interrupt mode ##########################*/
  if(k==ENABLE)
  {
    if(HAL_TIM_IC_Start_IT(&g_h_tim14, TIM_CHANNEL_1) != HAL_OK)
    {
      /* start Error */
      return HAL_ERROR;
    }
  }
  else if(k==DISABLE)
  {
    if(HAL_TIM_IC_Stop_IT(&g_h_tim14, TIM_CHANNEL_1) != HAL_OK)
    {
      /* stop Error */
      return HAL_ERROR;
    }
  }
  return HAL_OK;
}
/**
  * @brief  Conversion complete callback in non blocking mode 
  * @param  htim : hadc handle
  * @retval None
  */
void userRF_TIM14_CaptureCallback(TIM_HandleTypeDef *htim)
{
  static uint8_t preamble_cnt = 0,bits_of_byte;
  static uint16_t one_byte;
  
  if ( (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1)&&(htim->Instance == TIM14))
  {
    /* Get the Input Capture value */ 
    uwIC1_Start_Val = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);
    /* Capture computation */
    uw_Current_Pulse_Tim = (uwIC1_Start_Val - uwIC1_End_Val);
    
    /* get approximated value */
    uwPulse_Approximated_Val = uw_Current_Pulse_Tim;
    switch(CAPTURE_STEP)
    {
    case RFPREAMBLE:
      {
        if(uw_Current_Pulse_Tim > uw_Last_Pulse_Tim)
        {
          if(uw_Current_Pulse_Tim - uw_Last_Pulse_Tim < 200)
          {
            /* wait for a stable frequence */
            uwPulseTIM_BUF[preamble_cnt ++]= uwPulse_Approximated_Val;
          }
        }
        else if(uw_Last_Pulse_Tim - uw_Current_Pulse_Tim < 200)
        {
          /* wait for a stable frequence */
          uwPulseTIM_BUF[preamble_cnt ++]= uwPulse_Approximated_Val;
        }
        else 
        {
          preamble_cnt = 0;
        }
        uw_Last_Pulse_Tim = uw_Current_Pulse_Tim;
        
        /* got a stable frequence */
        if(preamble_cnt >= 8)
        {
          /* Frequency computation: for this example TIMx (TIM14) is clocked by
           APB1Clk ,Here we do not using frequence value but pulse time*/
          /*frequence = HAL_RCC_GetPCLK1Freq() / uw_Current_Pulse_Tim;*/
          uwPulseTM_Baseline_Val = uwPulseTIM_BUF[0];
          uwPulseTM_Baseline_Val += uwPulseTIM_BUF[1];
          uwPulseTM_Baseline_Val += uwPulseTIM_BUF[2];
          uwPulseTM_Baseline_Val += uwPulseTIM_BUF[3];
          uwPulseTM_Baseline_Val += uwPulseTIM_BUF[4];
          uwPulseTM_Baseline_Val += uwPulseTIM_BUF[5];
          uwPulseTM_Baseline_Val += uwPulseTIM_BUF[6];
          uwPulseTM_Baseline_Val += uwPulseTIM_BUF[7];
          uwPulseTM_Baseline_Val>>=3;
          uwPulseTM_Baseline_DVal=(uwPulseTM_Baseline_Val<<1);
          Manchester_Index = 0;
          bits_of_byte=0;
          one_byte=0;
          CAPTURE_STEP = RFHEADER;
        }
        break;
      }
    case RFHEADER:
      {
        /*uwPulseTIM_BUF[preamble_cnt++]=uwPulse_Approximated_Val;*/
        if((uwPulse_Approximated_Val<(uwPulseTM_Baseline_DVal+FDEV_ERROR))&&
          (uwPulse_Approximated_Val>(uwPulseTM_Baseline_DVal-FDEV_ERROR)))
        {
          /* start from high-to-low transition on PB01 */
          one_byte<<=1;
          /* got header */
          one_byte+=1;
          bits_of_byte++;
          CAPTURE_STEP = RF_DATA_RISING_EDGE;
        }
        else if((uwPulse_Approximated_Val<(uwPulseTM_Baseline_Val+FDEV_ERROR))&&
               (uwPulse_Approximated_Val>(uwPulseTM_Baseline_Val-FDEV_ERROR)))
        {
          /*continue waiting for header...*/
        }
        else
        {
          /*failed ...repeat*/
          one_byte = 0;
          bits_of_byte = 0;
          CAPTURE_STEP = RFHEADER;
        }
        break;
      }
    case RF_DATA_RISING_EDGE:/*Get low time*/
      {
        /*wait for falling edge trigger*/
        CAPTURE_STEP = FR_DATA_FALLING_EDGE;
        /*uwPulseTIM_BUF[preamble_cnt++]=uwPulse_Approximated_Val;*/
        if((uwPulse_Approximated_Val<(uwPulseTM_Baseline_DVal+FDEV_ERROR))&&
          (uwPulse_Approximated_Val>(uwPulseTM_Baseline_DVal-FDEV_ERROR)))
        {
          one_byte<<=1;
          bits_of_byte++;
          if(bits_of_byte >= 16)
          {
            RF_MANCHESTER_DATA_BUF[Manchester_Index++] = one_byte;
            if(Manchester_Index>=MANCHESTER_LENGTH)
            {
              CAPTURE_STEP = RFEND;/*end*/
            }
            one_byte = 0;
            bits_of_byte = 0;
          }
          one_byte<<=1;
          bits_of_byte++;
          if(bits_of_byte >= 16)
          {
            RF_MANCHESTER_DATA_BUF[Manchester_Index++] = one_byte;
            if(Manchester_Index>=MANCHESTER_LENGTH)
            {
              CAPTURE_STEP = RFEND;/*end*/
            }
            one_byte = 0;
            bits_of_byte = 0;
          }
        }
        else if((uwPulse_Approximated_Val<(uwPulseTM_Baseline_Val+FDEV_ERROR))&&
               (uwPulse_Approximated_Val>(uwPulseTM_Baseline_Val-FDEV_ERROR)))
        {
          one_byte<<=1;
          bits_of_byte++;
          if(bits_of_byte >= 16)
          {
            RF_MANCHESTER_DATA_BUF[Manchester_Index++] = one_byte;
            if(Manchester_Index>=MANCHESTER_LENGTH)
            {
              CAPTURE_STEP = RFEND;/*end*/
            }
            one_byte = 0;
            bits_of_byte = 0;
          }
        }
        break;
      }
    case FR_DATA_FALLING_EDGE:/*Get high time*/
      {
        /*wait for rising edge trigger*/
        CAPTURE_STEP = RF_DATA_RISING_EDGE;
        /*uwPulseTIM_BUF[preamble_cnt++]=uwPulse_Approximated_Val;*/
        if((uwPulse_Approximated_Val<(uwPulseTM_Baseline_DVal+FDEV_ERROR))&&
          (uwPulse_Approximated_Val>(uwPulseTM_Baseline_DVal-FDEV_ERROR)))
        {
          one_byte<<=1;
          one_byte+=1;
          bits_of_byte++;
          if(bits_of_byte >= 16)
          {
            RF_MANCHESTER_DATA_BUF[Manchester_Index++] = one_byte;
            if(Manchester_Index>=MANCHESTER_LENGTH)
            {
              CAPTURE_STEP = RFEND;/*end*/
            }
            one_byte = 0;
            bits_of_byte = 0;
          }
          one_byte<<=1;
          one_byte+=1;
          bits_of_byte++;
          if(bits_of_byte >= 16)
          {
            RF_MANCHESTER_DATA_BUF[Manchester_Index++] = one_byte;
            if(Manchester_Index>=MANCHESTER_LENGTH)
            {
              CAPTURE_STEP = RFEND;/*end*/
            }
            one_byte = 0;
            bits_of_byte = 0;
          }
        }
        else if((uwPulse_Approximated_Val<(uwPulseTM_Baseline_Val+FDEV_ERROR))&&
               (uwPulse_Approximated_Val>(uwPulseTM_Baseline_Val-FDEV_ERROR)))
        {
          /* Rising edge = 1 */
          one_byte<<=1;
          one_byte+=1;
          bits_of_byte++;
          if(bits_of_byte >= 16)
          {
            RF_MANCHESTER_DATA_BUF[Manchester_Index++] = one_byte;
            if(Manchester_Index>=MANCHESTER_LENGTH)
            {
              CAPTURE_STEP = RFEND;/*end*/
            }
            one_byte = 0;
            bits_of_byte = 0;
          }
        }
        else
        {
          one_byte = 0;
          bits_of_byte = 0;
          CAPTURE_STEP = RFEND;/*end*/
        }
        break;
      }
    case RFEND:
      {
        for(uint8_t i = 0;i < Manchester_Index;i++)
        {
          if(manchester_decoding(RF_MANCHESTER_DATA_BUF[i],&RF_DATA_BUF[i]) != HAL_OK)
          {
            break;
          }
        }
        if((RF_DATA_BUF[0]==0x2A)&&(RF_DATA_BUF[1]==0x1D) || (RF_DATA_BUF[0]==0x6D))
        {
          userSirenPwmPulsesOutput(10);
        }
        
        for(uint8_t i = 0; i < Manchester_Index; i++)
        {
          RF_DATA_BUF[i] = 0;
        }
        preamble_cnt = 0;
        CAPTURE_STEP = RFPREAMBLE;
        break;
      }
    default:
      {
        break;
      }
    }
    
    uwIC1_End_Val = uwIC1_Start_Val;
  }
}
/**
  * @}
  */

/**
  * @}
  */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

/**
  ******************************************************************************
  * @file    rf_spi2_setup.h 
  * @author  MCD Application Team
  * @brief   Header for main.c module
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
  *
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *   1. Redistributions of source code must retain the above copyright notice,
  *      this list of conditions and the following disclaimer.
  *   2. Redistributions in binary form must reproduce the above copyright notice,
  *      this list of conditions and the following disclaimer in the documentation
  *      and/or other materials provided with the distribution.
  *   3. Neither the name of STMicroelectronics nor the names of its contributors
  *      may be used to endorse or promote products derived from this software
  *      without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  ******************************************************************************
  */
  
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef _TDA5225_VALUE_TIM14_H
#define _TDA5225_VALUE_TIM14_H
/* Includes ------------------------------------------------------------------*/
#include "stm32f0xx_hal.h"
#include <stdio.h>
#include <string.h>

#include "sr_tim2_setup.h" 

/* Exported types ------------------------------------------------------------*/
typedef enum
{
  RFPREAMBLE = 0,
  RFHEADER,
  RF_DATA_RISING_EDGE,
  FR_DATA_FALLING_EDGE,
  RFEND,
}CaptureStepTypeDef;
/* Exported constants --------------------------------------------------------*/
/* Exported macro ------------------------------------------------------------*/
/* Exported functions ------------------------------------------------------- */
HAL_StatusTypeDef LF_TIM14_PWM_Init(void);
HAL_StatusTypeDef RF_Receved_Start(FunctionalState k);
#endif /* __MAIN_H */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

Thanks, Enjoy.

End.