使用STM32F103进行315MHz无线解码程序

DongInker · 发表于 2016-11-14 23:50:39

本帖最后由 DongInker 于 2016-11-15 00:11 编辑

[mw_shl_code=c,true]
/*
* Rxd315.c
*
* Auther    : Inker.Dong
* Create Date: 2016/10/11
* Address : FuZhou China
* Function : 315MHz Wire Decode
* Debug Note

* 每一位可以用2位表示 0:00 1:11 f:01
* 按键值一般为0x03,0x0C,0x30,0xC0
* PT2262 地址可自设    组合:3^12
* EV1527 地址不可设    组合:2^24
*/

#define SYSLOG 0

#include "InkerSys.h"
#include "Rxd315.h"

#define TIM_BUF_NUM (64)
/************************************************************************/
/*    static Variables                                              */
/************************************************************************/
typedef const struct cRxd315_Stat_s
{
int             cNum;
u8                cPulseNum;
u8                cR3Sync;
u8                cR3_OT;
u16             c0UpTimuS;
u16             c0DnTimuS;
u16             c1UpTimuS;
u16             c1DnTimuS;
int             (*Get315Func)(void);
void             (*SetTimFunc)(u32);
u32             (*GetTimFunc)(void);
void             (*IntEnFunc)(int);
}tcRxd315_Stat_t, *ptcRxd315_Stat_t;

static tcRxd315_Stat_t cRxd315Stat = {
1,
50,  //脉冲个数
13,  //启动信号持续时间  7*1mS
64,  //接收数据超时    64*1mS
1800,// 识别低电平时间上限 uS
1200,// 识别低电平时间下限 uS
850, // 识别高电平时间上限 uS
250, // 识别高电平时间下限 uS
GetRxd315,// 读取315MHz管脚电平状态
SetSysTick,// 写定时计数值
GetSysTick,// 读定时计数值
SetExti4En};// 设置315MHz接收管脚中断开启或关闭

static Inst_t Rxd315Inst = NULL;

/************************************************************************/
/*    Local Functions                                              */
/************************************************************************/

typedef struct Rxd315_Stat_s
{
      int          Val;
}Rxd315_Stat_t, *pRxd315_Stat_t;

typedef struct Class_s{
      Inst_t*          pInst;
      tcRxd315_Stat_t  *pStat;

      int             PrfClass;
      u16             Rxd315Cnt;
      vu8             R315State;
      vu8             R3Cnt1mS;

      vu16             R3Success;
      u8                R3OkFlag;
      u8                RxdVal[TIM_BUF_NUM];
      u32             TimBuf[TIM_BUF_NUM];// >48
      vu16             TimBufCnt;

      u32             RxdData;
      Rxd315_Stat_t *pRxd315;
} Class_t;

static Bool sRxd315Open(Inst_t* pInst,tcRxd315_Stat_t* pStat)
{
      LOG_FUNC_NAME("Rxd315Open")
      Class_t *pObj = (Class_t *)*pInst;
      int i;

      if( pObj ) return 1;
      assert(pStat);

      pObj = (Class_t*)Malloc(sizeof(Class_t));
assert(pObj);
      *pInst = (Inst_t)pObj;
      LOG_TXT1(("[%0.4X]", *pInst));

      pObj->pStat          = pStat;
      pObj->pInst          = pInst;

      pObj->PrfClass  = 0;
      pObj->Rxd315Cnt = 0;
      pObj->R315State = 1;
      pObj->R3Cnt1mS  = 0;
      pObj->R3Success = 0;
      pObj->R3OkFlag  = 0;
      pObj->pRxd315    = Calloc(pObj->pStat->cNum,sizeof(Rxd315_Stat_t));
      assert(pObj->pRxd315);

      for(i=0;i<pObj->pStat->cNum;i++)
            {
            pObj->pRxd315.Val = 0;
            }

      if(pObj->pStat->IntEnFunc)
            pObj->pStat->IntEnFunc(FALSE);

      return TRUE;
}

#if 0
/*关闭*/
static Bool sRxd315Close(Inst_t Inst)
{
      LOG_FUNC_NAME("Rxd315Close")
Class_t*  pObj = (Class_t*)Inst;

/* Check for correct instance */
assert((Inst_t)pObj == *pObj->pInst);

      Free(pObj->pRxd315);

/* Clean-up Instance */
*pObj->pInst = (Inst_t)0;
Free(pObj);
return 0;
}
#endif

static void sRxd315Msg(Inst_t Inst)
{
      Class_t*  pObj = (Class_t*)Inst;

      DPRINTF(("Rxd315Prf:%d\r\n",pObj->PrfClass));
      DPRINTF(("R3Success:%d\r\n",pObj->R3Success));
      DPRINTF(("R315State:%d\r\n",pObj->R315State));
      DPRINTF(("TimBufCnt:%d\r\n",pObj->TimBufCnt));
      if(pObj->pStat->Get315Func)
            DPRINTF(("RxdIOState:%d\r\n",pObj->pStat->Get315Func()));

      DPRINTF(("RxdData:0X%lX\r\n",pObj->RxdData));
      pObj->R3Success = 0;
}

static void sRxd315PrfClass(Inst_t Inst,int val)
{
      Class_t*  pObj = (Class_t*)Inst;

      pObj->PrfClass = val;
}

static void sR315Decode(Inst_t Inst)
{
      Class_t*  pObj = (Class_t*)Inst;
      u16 i,Tim1uS;

      pObj->RxdData = 0;
      for(i=2;i<pObj->TimBufCnt;i+=2)
            {
            Tim1uS = (pObj->TimBuf[i-1] - pObj->TimBuf)/9;
            if((Tim1uS >= pObj->pStat->c1DnTimuS) && (Tim1uS <= pObj->pStat->c1UpTimuS))
                     pObj->RxdData |= 1;
            pObj->RxdData <<= 1;
            }
      pObj->RxdData >>= 1;
}

static void sIsrRxd315(Inst_t Inst)
{
      Class_t*  pObj = (Class_t*)Inst;

      if(pObj->R315State == 1)
            {
            pObj->RxdVal[pObj->TimBufCnt] = pObj->pStat->Get315Func();
            pObj->TimBuf[pObj->TimBufCnt] = pObj->pStat->GetTimFunc();
            pObj->TimBufCnt++;
            if(pObj->TimBufCnt >= pObj->pStat->cPulseNum)
                     {
                     pObj->pStat->IntEnFunc(FALSE);
                     pObj->R315State = 0;
                     pObj->R3Cnt1mS  = 0;
                     pObj->R3OkFlag  = 1;
                     pObj->R3Success++;
                     }
            }
      else
            {
            pObj->pStat->IntEnFunc(FALSE);
            pObj->R3Cnt1mS  = 0;
            }

      if(pObj->R3OkFlag)
            {
            pObj->R3OkFlag = 0;
            sR315Decode(Inst);
            }
}

static void sF1mSRxd315(Inst_t Inst)
{
      Class_t*  pObj = (Class_t*)Inst;

      if(pObj->pStat->Get315Func == NULL)
            return ;

      if(pObj->R315State == 0)
            {
            if(pObj->pStat->Get315Func())
                     {
                     pObj->R3Cnt1mS++;
                     if(pObj->R3Cnt1mS >= pObj->pStat->cR3Sync)
                              {
                              pObj->R3Cnt1mS  = 0;
                              pObj->R315State = 1;
                              pObj->TimBufCnt = 0;
                              pObj->pStat->SetTimFunc(0XFFFFFF);
                              pObj->pStat->IntEnFunc(TRUE);
                              }
                     }
            else
                     pObj->R3Cnt1mS = 0;
            }
      else
            {
            pObj->R3Cnt1mS++;
            if(pObj->R3Cnt1mS >= pObj->pStat->cR3_OT)// 超时处理
                     {
                     pObj->R3Cnt1mS  = 0;
                     pObj->R315State = 0;
                     pObj->pStat->IntEnFunc(FALSE);
                     }
            }
}
/************************************************************************/
/*    Timer Handler                                                 */
/************************************************************************/
#include       "timer.h"

static void sRxd315Handler(void)
{
      Class_t*  pObj = (Class_t*)Rxd315Inst;

      pObj->Rxd315Cnt++;
}

static Inst_t          Rxd315HandlerInst;
static Timer_Stat_t          sRxd315TimerStat    = { "Rxd315Handler",  6000, (Timer_Func_t)sRxd315Handler };

/************************************************************************/
/*    UFD Registration                                              */
/************************************************************************/
#ifdef _ENABLE_UFD

static void UfdRxd315Msg(void)
{
      if(Rxd315Inst != NULL)
            sRxd315Msg(Rxd315Inst);
}

static void UfdRxd315Prf(int val)
{
      if(Rxd315Inst != NULL)
            sRxd315PrfClass(Rxd315Inst,val);
}

#include "UFD.h"
static UFD_CmdTbl_t sUFDCmdTbl[] =
{
UFD_HDR( ".Rxd315", "Driver for Rxd315MHz" ),

UFD_RC0( "Rxd315Msg",                   UfdRxd315Msg,       NULL,                "Rxd315 Message          R"),
UFD_RC1( "Rxd315Prf", I16,                UfdRxd315Prf,       NULL,                                     "Rxd315 Printf Class <0..1> W"),

UFD_END()
};
#endif

/************************************************************************/
/*    Application Interface                                           */
/************************************************************************/
GLOBAL void ProF_1mS_Rxd315(void)
{
      if(Rxd315Inst)
            sF1mSRxd315(Rxd315Inst);
}

GLOBAL void IsrRxd315(void)
{
      if(Rxd315Inst)
            sIsrRxd315(Rxd315Inst);
}

GLOBAL void Rxd315Init(void)
{
      if(Rxd315Inst == NULL)
            {
            sRxd315Open(&Rxd315Inst,&cRxd315Stat);

            Timer_Open(&Rxd315HandlerInst, &sRxd315TimerStat);
            assert(Rxd315HandlerInst);
            Timer_Stop(Rxd315HandlerInst);

#ifdef _ENABLE_UFD
            UFD_AddCommandTable(sUFDCmdTbl);
#endif
            }
}[/mw_shl_code][mw_shl_code=c,true]#ifndef _RXD315_H
#define _RXD315_H

GLOBAL void IsrRxd315(void);// 315MHz接收管脚判断同步信号时启动IO中断
GLOBAL void ProF_1mS_Rxd315(void);// 定时中断系统节拍 1mS执行一次
GLOBAL void Rxd315Init(void);// 注册初始化

#endif[/mw_shl_code]