easydemo_2342S/app/myRadio.c

#include "myRadio.h"
#include "board.h"
#include "stm32f10x.h"
#include "stm32f10x_exti.h"
#include "misc.h"

//------------radio include
#include "sx1208.h"
//------------
#include "myRadio_gpio.h"
// #include "myRadio_setting.h"

int8_t rfTxPower;
sx1208_rx_pkt_t *rx_pkt;
static rfRxCallBack rxCb;
static uint8_t rfRxBuffer[255];

void myRadio_delay(uint32_t time_ms)
{
    uint32_t i, j;
    i = time_ms;
    while (i --)
    {
        for ( j = 0; j < 1000; j++)
        {
            ;
        }
    }
}

void EXTI0_IRQHandler(void)
{
    if (EXTI_GetITStatus(EXTI_Line0) != RESET)
    {
        /* Clear the EXTI line 1 pending bit */
        EXTI_ClearITPendingBit(EXTI_Line0);
        sx1208_onDioIrq();
    }
}
// BOARD_PIN_SPI_GPIOB
void NVIC_Config()
{
    NVIC_InitTypeDef NVIC_InitStructure;
    EXTI_InitTypeDef EXTI_InitStructure;

    EXTI_ClearITPendingBit(EXTI_Line0);
    EXTI_InitStructure.EXTI_Line = EXTI_Line0;
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    EXTI_Init(&EXTI_InitStructure);
    GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource0);
    /* Enable and set EXTI1 Interrupt */
    NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
}
void sx1208_event(sx1208_event_t state, void *ptr)
{
    switch (state)
    {
    case SX1208_TX_DONE:
    {
        rfRxPacket_ts rfRxPacket;
        if (rxCb)
        {
            rxCb(TX_STA_SECCESS, rfRxPacket);
        }
    }
    break;
    case SX1208_RX_DONE:
    {
        rfRxPacket_ts rfRxPacket;
        rx_pkt = ptr;
        if (rx_pkt->len > MAX_RF_PACKET_LEN)
        {
            rx_pkt->len = MAX_RF_PACKET_LEN;
        }

        memset(rfRxPacket.payload, 0, sizeof(rfRxPacket.payload));
        memcpy(rfRxPacket.payload, rx_pkt->buf, rx_pkt->len);
        rfRxPacket.len = rx_pkt->len;
        rfRxPacket.rssi = (-rx_pkt->raw_rssi) / 2;
        if (rxCb)
        {
            rxCb(RX_STA_SECCESS, rfRxPacket);
        }
    }
    break;
    case SX1208_RX_ERROR:
    {
        rfRxPacket_ts rfRxPacket;
        if (rxCb)
        {
            rxCb(RX_STA_TIMEOUT, rfRxPacket);
        }
    }
    break;
    case SX1208_RX_TIMEOUT:
    {
        rfRxPacket_ts rfRxPacket;
        if (rxCb)
        {
            rxCb(RX_STA_TIMEOUT, rfRxPacket);
        }
    }
    break;
    default:
        break;
    }
}
void myRadio_init(int agr0, void *agr1_ptr)
{
    sx1208_config_t sx1208_config;
    myRadio_gpio_init();
    NVIC_Config();
    sx1208_init(sx1208_event);
    sx1208_config.protocol = SX1208_PROTOCOL_NONE;

    sx1208_config.frf = 915000000;
    // sx1208_config.bitrate = 4800;
    // sx1208_config.fdev = 5005;
    sx1208_config.bitrate = 10000;
    sx1208_config.fdev = 25000;

    sx1208_config.crc_mode = SX1208_CRC_OFF;
    sx1208_config.header_mode = SX1208_HEADER_ENABLE;
    sx1208_config.payload_len = 0; // Set

    sx1208_config.tx_power = 20;

    sx1208_config.tx_preamble_len = 6;
    sx1208_config.rx_preamble_len = 5;

    sx1208_config.sync_word_len = 4;
    sx1208_config.sync_word[0] = 0x55;
    sx1208_config.sync_word[1] = 0x55;
    sx1208_config.sync_word[2] = 0x98;
    sx1208_config.sync_word[3] = 0xF3;
    // sx1208_config.sync_word[0] = 0xC1;
    // sx1208_config.sync_word[1] = 0x94;
    // sx1208_config.sync_word[2] = 0xC1;
    // sx1208_config.sync_word[3] = 0x00;
    // sx1208_initParams();
    sx1208_set_config(&sx1208_config);
    if ((rfRxCallBack)agr1_ptr)
    {
        rxCb = (rfRxCallBack)agr1_ptr;
    }
}

void myRadio_process(void)
{
    sx1208_process();
}
void myRadio_abort(void)
{
    sx1208_set_mode(SX1208_MODE_STANDBY);
}

void myRadio_setChipType(uint8_t type)
{
}
uint8_t myRadio_getChipType(void)
{
    return 0;
}
uint32_t myRadio_getFrequency(void)
{
    return 0;
}
int8_t myRadio_getRssi(void)
{
    return (-sx1208_read_rssi()) / 2;
}
void myRadio_setFrequency(uint32_t freq)
{
    sx1208_set_frf(freq);
}
int8_t myRadio_getTxPower(void)
{
    return rfTxPower;
}
void myRadio_setTxPower(int8_t power)
{
    rfTxPower = power;
    sx1208_set_tx_power(power);
}
void myRadio_transmit(rfTxPacket_ts *packet)
{
    sx1208_send(packet->payload, packet->len, 0);
}
void myRadio_receiver(void)
{
    sx1208_receive(rfRxBuffer, 255, 0);
}
void myRadio_receiverSync(rfRxPacket_ts *packet)
{
}
void myRadio_setCtrl(controlMode_te mode, uint32_t value)
{
    static uint8_t old_mode = 0xff;
    // if (old_mode == mode)
    // {
    //     return;
    // }

    switch (mode)
    {
    case RADIO_EXT_CONTROL_TX_UNMODULATED:
    {
        sx1208_set_frf(value);
        sx1208_set_fdev(0);
        sx1208_tx_test_mode();
    }
    break;
    case RADIO_EXT_CONTROL_RX_SENSITIVITY:
    {
        sx1208_set_frf(value);
        //   sx1208_set_bitrate(4800);
        //   sx1208_set_fdev(8000);
        //   sx1208_set_rxbw(8000, 4800);
        sx1208_set_bitrate(10000);
        sx1208_set_fdev(25000);
        sx1208_set_rxbw(25000, 10000);
        sx1208_rx_test_mode();
    }
    break;

    default:
        break;
    }
    old_mode = mode;
}