easydemo_4131s/radio/myRadio.c

#include "board.h"
#include "myRadio.h"
#include "myRadio_gpio.h"

/**-------------------------radio include----------------------------------**/
#include "RF.h"
#include "rf_setting.h"
/**-------------------------radio include end----------------------------------**/

static int8_t rfTxPower;
static uint32_t rfFrequence;
static uint32_t rfBaudrate;
static rfRxCallBack rxCb;
static uint8_t rfRxBuffer[255];
static uint32_t rf_handle;
static uint8_t rf_workProcess;
static uint8_t chipType;
/**-------------------------radio params----------------------------------**/
static bool rf_irq;
/**-------------------------radio params end----------------------------------**/
void myRadio_delay(uint32_t time_ms)
{
    uint32_t i, j;
    i = time_ms;
    while (i --)
    {
        for ( j = 0; j < 14000; j++)
        {
            ;
        }
    }
}
/**
 * @brief IO口中断回调
 *      IO口产生中断后会执行该函数
 *      用于接收射频工作的中断响应
 * 
 * @param index 
 */
void myRadio_gpioCallback(uint8_t index)
{
    rf_irq = true;
}
/**
 * @brief 射频初始化
 * 
 * @param agr0 
 * @param agr1_ptr 无线工作状态响应回调
 *          产生回调给外部使用，@rfRxCallBack
 */
void myRadio_init(int agr0, void *agr1_ptr)
{
    myRadio_gpio_init(myRadio_gpioCallback);
    
/**-------------------------radio init----------------------------------**/
    RF_Init(rfBaudrate, chipType);
		
    //读取版本号，可用于测试spi是否正常
    uint16_t reversion = 0;
    RF_ReadBuf(REV, (uint8_t *)&reversion, 2);
    if (reversion != 0X503C)
    {
        while(1);
    }
    
/**-------------------------radio init end----------------------------------**/
    RF_EXT_PA_TO_IDLE();
    if ((rfRxCallBack )agr1_ptr)
    {
        rxCb = (rfRxCallBack )agr1_ptr;
    }
    rf_handle = 0xe5;
}
/**
 * @brief 射频底层执行程序
 *      要放在主循环中执行
 * 
 */
void myRadio_process(void)
{
    uint8_t   bMain_IT_Status;
    rfRxPacket_ts rfRxPacket;
    status_tu status;

    if (rf_handle == 0)
    {
        return;
    }
    if (rf_irq == false)
    {
        return;
    }
    rf_irq = false;
    if ((rf_workProcess != 1) && (rf_workProcess != 2))
    {
        return;
    }
    rf_workProcess = 0;
    status.value = RF_GetStatus();
    if (status.bits.RX_DR)
    {
        status.bits.RX_DR = 0;
        rfRxPacket.len = 12;
        RF_ReadBuf(R_RX_PAYLOAD, rfRxPacket.payload, rfRxPacket.len);  
        rfRxPacket.rssi = 127;
        RF_ClearFIFO();
        RF_ClearStatus (); 
        rxCb(RX_STA_SECCESS, rfRxPacket);
    }
    //发送成功中断
    //或者发送后收到ACK中断
    if (status.bits.TX_DS)
    {
        status.bits.TX_DS = 0;
        RF_ClearFIFO();
        RF_ClearStatus (); 
        rxCb(TX_STA_SECCESS, rfRxPacket);
    }
    //发送fifo溢出中断
    if (status.bits.TX_FULL)
    {
        
    }
    //发送重传次数完成中断
    if (status.bits.MAX_RT)
    {
        
    }
    //可以读取pipe 号中断
    if (status.bits.RX_P_NO <= 0x05)
    {
        
    }
    //RX fifo为空中断
    if (status.bits.RX_P_NO == 0x07)
    {
        
    }
    if (status.value)
    {
        RF_ClearFIFO();
        RF_ClearStatus (); 
    }
}
/**
 * @brief 退出射频进入休眠
 * 
 */
void myRadio_abort(void)
{
    if (rf_handle == 0)
    {
        return;
    }
    RF_EXT_PA_TO_IDLE();
    rf_workProcess = 0;
    if (rf_workProcess == 0xa5)
    {
        RF_Init(rfBaudrate, chipType);
    }
    
    RF_powerDown();
}
/**
 * @brief 获取射频工作中心频率
 * 
 * @return uint32_t 
 */
uint32_t myRadio_getFrequency(void)
{
    if (rf_handle == 0)
    {
        return 0;
    }
    return rfFrequence;
}
/**
 * @brief 设置射频工作中心频率
 * 
 * @param freq 
 *      具体频点，单位：Hz
 */
void myRadio_setFrequency(uint32_t freq)
{

    rfFrequence = freq;

    RF_setFreq(rfFrequence / 1000000);
    RF_CalVco(Dem_cal1_data);
}
/**
 * @brief 获取发射功率
 * 
 * @return int8_t 
 */
int8_t myRadio_getTxPower(void)
{

    return rfTxPower;
}
/**
 * @brief 设置发射功率
 * 
 * @param power 
 *          单位：dbm
 */
void myRadio_setTxPower(int8_t power)
{

    rfTxPower = power;
    RF_SetPower(RF_cal1_data, rfTxPower);	
}
/**
 * 获取射频波特率
 * @param : br->
*/
uint32_t myRadio_getBaudrate(void)
{
    if (rf_handle == 0)
    {
        return 0;
    }
    return rfBaudrate;
}
/**
 * 设置射频波特率
 * @param : br->
*/
void myRadio_setBaudrate(uint32_t br)
{

    rfBaudrate = br;

}
/**
 * @brief 设置模组型号
 * 
 * @param type 
 */
void myRadio_setChipType(uint8_t type)
{
    chipType = type;
}
/**
 * @brief 获取模组型号
 * 
 * @return uint8_t 
 */
uint8_t myRadio_getChipType(void)
{
    return chipType;
}
int16_t myRadio_getRssi(void)
{
    return 0;
}
/**
 * @brief 无线发送数据包
 * 
 * @param packet 
 */
void myRadio_transmit(rfTxPacket_ts *packet)
{
    if (rf_handle == 0)
    {
        return;
    }
    RF_EXT_PA_TO_TX();
    if (rf_workProcess != 1)
    {
        rf_workProcess = 1;
        RF_TxMode();
    }
    rf_workProcess = 1;
    RF_Tx_TransmintData(packet->payload, PAYLOAD_WIDTH);
}
/**
 * @brief 进入无线接收
 * 
 */
void myRadio_receiver(void)
{ 
    if (rf_handle == 0)
    {
        return;
    }
    RF_EXT_PA_TO_RX();
    rf_workProcess = 2;
    RF_RxMode();
}
void myRadio_setCtrl(controlMode_te mode, uint32_t value)
{
    if (rf_handle == 0)
    {
        return;
    }
    myRadio_init(0, 0);
    switch (mode)
    {
    case RADIO_EXT_CONTROL_TX_UNMODULATED:
    case RADIO_EXT_CONTROL_TX_MODULATED:
    {
        rf_workProcess = 0xa5;
        RF_EXT_PA_TO_TX();
        myRadio_setTxPower(rfTxPower);
        RF_Carrier();
        // RF_setFreq(rfFrequence / 1000000);
        myRadio_delay(100);
        myRadio_setFrequency(rfFrequence);
    }
        break;
    case RADIO_EXT_CONTROL_RX_SENSITIVITY:
    {
        RF_EXT_PA_TO_RX();
        RF_setFreq(rfFrequence / 1000000);
        myRadio_receiver();
    }
        break;
    
    default:
        break;
    }
}

/**-------------------------radio funtion----------------------------------**/

/**-------------------------radio funtion end----------------------------------**/