#include "hal.h" 
#include "LT89xx_rf.h" 
#include "LT89xx_def.h" 
#include "LT89xx_rf_cfg.h" 
#include "LT89xx.h"   
#include "V2RFEncoding.h" 

#include "pt_thread/pt_header.h" 
#include "task.h"

#include "BulbId.h" 

#define RF_FREQ_0   2402UL
//通信要注意频率 同步字
//服务端软件要注意Google CDN 的JQuery.js被封锁导致界面限制不正常 
//需要下载Google CDN Replace插件

  
//发送SYNC_WORD
CONST Sync_Word Tx_Sync_Word   =
{  
    0x7236,
    0x1809,   
};

//发送频率
CONST uint16_t Tx_Freq[] = {RF_FREQ_0+0x0F,RF_FREQ_0+0x23, RF_FREQ_0+0x37};

//接收同步字和频率
//接收通道 6个
CONST LT89XX_Sync_Word_Channel Rx_Sync_Word_Channel[] =
{
    
    {
        0x7236,
        0x1809, 
        RF_FREQ_0+0x88-0x80  //RF_FREQ_0+0x08
    },
    //Dual white	FUT091
    //8 mode	    FUT089   
    //99 mode
    
    {
        0x147A,
        0x258B, 
        RF_FREQ_0+0x89-0x80  //RF_FREQ_0+0x09
    },
    
    {
        0x7236,
        0x1809, 
        RF_FREQ_0+0xA7-0x80  //RF_FREQ_0+0x27
    },
    
    {
        0x147A,
        0x258B, 
        RF_FREQ_0+0xA8-0x80 //RF_FREQ_0+0x28
    },
    
    {
        0x7236,
        0x1809, 
        RF_FREQ_0+0xC6-0x80 //RF_FREQ_0+0x46
    },
    
    {
        0x147A,
        0x258B, 
        RF_FREQ_0+0xC7-0x80 //RF_FREQ_0+0x47
    },
      
};


void StartTaskLT89XX(void);

void SetSyncWord(uint16_t Sync_word_High,uint16_t Sync_word_Low)
{ 
    LT_WriteReg2(REG36_SYNC_WORD_15_00,Sync_word_Low);  //SYNC_WORD
    LT_WriteReg2(REG39_SYNC_WORD_63_48,Sync_word_High);  
}

void Reset_FIFO_PTR(void)
{ 
    LT_WriteReg(REG52_W_R_PTR, 0x80, 0x80);    //收发FIFO 指针数据复位 
}

void LT8920_TxData(uint8_t* pBuf,uint8_t len ,uint16_t FreqChannel)
{
    FreqChannel-=RF_FREQ_0; 
    LT_WriteReg(REG07_W_R_EN, 0x00, 00);            //停止收发,
    Reset_FIFO_PTR(); 
    LT_WriteBuf(REG50_TXRX_FIFO,pBuf,len);
    LT_WriteReg(REG07_W_R_EN, 0x01, FreqChannel);   //启动接收 ,写入频率
}

//void StartRxData(uint16_t FreqChannel,uint16_t Sync_word_High,uint16_t Sync_word_Low)

void StartRxData(LT89XX_Sync_Word_Channel *Key)
{	  
    uint16_t FreqChannel = Key->Freq;
    uint16_t Sync_word_High = Key->SyncWord.Sync_Word_63_48;
    uint16_t Sync_word_Low  = Key->SyncWord.Sync_Word_15_00;
    FreqChannel-=RF_FREQ_0;
    LT_WriteReg(REG07_W_R_EN, 0x00, 00);   //停止收发,
    
    SetSyncWord(Sync_word_High,Sync_word_Low);
    Reset_FIFO_PTR();
    LT_WriteReg(REG07_W_R_EN, 0x00, FreqChannel|0x80); //启动接收 ,写入频率
    //REG07_W_R_EN 收发和频率
    //0X24  36  //SYNC_WORD[15:0]
    //0X27  39  //SYNC_WORD[63:48]
    //0X34  52  //清除收发FIFO
}


void StopTxRxData(void)
{
    LT_WriteReg(REG07_W_R_EN, 0x00, 00);   //停止收发,
}
 

uint8_t LT8920_RxData(uint8_t* pBuf,uint8_t *len )
{
    uint8_t RegH,RegL;
    int result = LT_GetPKT(); 
    if(result)
    {
        LT_Readreg(48,&RegH,&RegL);  
        if((RegH&0x80)==0)
        {
            result = LT_ReadBuf(REG50_TXRX_FIFO,pBuf); 
            *len   = result;
            //收到数据退出
            _nop_();
        } 
    }
    return result;
}

 
AL_STATIC XDATA uint8_t RxData[16] = {0xEE, 0xB9, 0x81, 0x21, 0x9E, 0x7c, 0x5a, 0x60, 0x0d };


PT_THREAD(TaskLT89xxRxData(struct pt *pt1,
    LT89XX_Sync_Word_Channel *key, 
    uint8_t* pBuf,
    uint8_t *len1,
    uint8_t TimeOut 
    ))
{   
    static idata uint8_t Rx_TimeOut = 0;	  
    _nop_();  
    PT_BEGIN(pt1); 
    Rx_TimeOut = 0;
    while(1)
    { 
        _nop_(); 
        //StartRxData(FreqChannel,Sync_word_High,Sync_word_Low);   
        StartRxData(key);  
        *len1 = 0;
        while(1)
        { 
            _nop_(); 
            delay_us(200);
            if(LT_GetPKT())
            {  
                uint8_t RegH,RegL;
                LT_Readreg(48,&RegH,&RegL);  
                
                if((RegH&0x80)==0)
                {
                    *len1 = LT_ReadBuf(REG50_TXRX_FIFO,pBuf);
                     DecodePackage(pBuf,*len1);
                }
                
                PT_EXIT(pt1);
                //收到数据退出
            } 
            Rx_TimeOut++;
            if(Rx_TimeOut>TimeOut)  //下一次是2ms后
            {
                PT_EXIT(pt1);       
                //长期没有收到数据,重新开始
            }
            else
            {
                Delay10us( );
                //PT_YIELD(pt1);       //记录下次进入点,下次从此开始 
            }
        }
        
    }
     
    PT_END(pt1); 
}

 void Broadcast(uint8_t* pBuf,uint8_t len)
 { 
    uint16_t j = 0;
    uint16_t count = 0; 
    uint16_t freq = 0;
    uint16_t sync_word_high = 0;
    uint16_t sync_word_low  = 0;
    StopTxRxData();
    sync_word_high  = Tx_Sync_Word.Sync_Word_63_48;
    sync_word_low   = Tx_Sync_Word.Sync_Word_15_00;
    SetSyncWord(sync_word_high,sync_word_low);
    StopTxRxData();
    Reset_FIFO_PTR(); 
      
    
    do
    { 
        for(j=0;j<sizeof(Tx_Freq)/sizeof(uint16_t);j++)   //往频道广播
        //for(j=0;j<sizeof(Rx_Sync_Word_Channel)/sizeof(LT89XX_Sync_Word_Channel);j++)   //往接收频道广播
        
        {
            freq            = Tx_Freq[j];
            //freq            = Rx_Sync_Word_Channel[j].Freq;
            LT8920_TxData(pBuf,len,freq); 
             _nop_();  _nop_();  _nop_(); 
            //delay_us(250);  //  阻塞延时
            while(LT_GetPKT()==0)
            {
                _nop_();
            } 
             _nop_();  _nop_();  _nop_(); 
        }  
        count++;
        _nop_();
    }
    while(count<33);
    count = 0;
 }

PT_THREAD(TaskLT89xx_thread(struct pt *pt1))
{    
    uint8_t len = 9;
    static xdata  uint16_t i = 0; 
    static struct pt ptRxData;  
    _nop_(); 
    PT_BEGIN(pt1); 

    i = 0;  
     
    for(i=0;i<sizeof(Rx_Sync_Word_Channel)/sizeof(LT89XX_Sync_Word_Channel);i++)
    { 
        PT_INIT(&ptRxData); 
        
        PT_WAIT_THREAD(pt1,TaskLT89xxRxData(&ptRxData,&Rx_Sync_Word_Channel[i],RxData,&len,100));
           
        //延时2ms
        Delay10us( );  //  阻塞延时 Delay10us
        if(len>0)
        {
            Broadcast(RxData,len);
        } 
        _nop_();
    } 
    PT_END(pt1);  
}

#ifndef  TASK_WITH_NAME      
#errror "please include al_helper.h"
#endif

void TaskLT89xx_thread_entry(void *param ) 
{        
    struct  pt *pt1 ;
    PT_BIND(pt1);
    TaskLT89xx_thread(pt1);  
    UNUSED(param);
}

XDATA int8_t TimerLT89xxRX = -1;
void StartTaskLT89XX(void)
{ 
    if(TimerLT89xxRX==-1) 
        StartTimer2(&TimerLT89xxRX,TIMER_MODE_CYCROUTINE,1,TaskLT89xx_thread_entry,NULL);
}
void InitLT89xxRF(void)
{
    InitLT89xx();
    StartTaskLT89XX();
}


uint8_t DecodePackage(uint8_t *pBuf,uint8_t len1)
{ 
    uint8_t i;
    if(len1==9)
    { 
        xdata uint8_t Package[9]; 
        memcpy(Package, pBuf, len1);
        decodeV2Packet(Package);
        SetBulbInfo(Package,len1);
        /*
        printf("decode Info:"); 
        for(i=0;i<9;i++)
        {
            printf("0x%02x ",Package[i]);
        }  
        printf("\r\n"); 
        */
        _nop_();
    }
    
    UNUSED(i);
    return len1 ;
}