hpw421初始版本
This commit is contained in:
xushaoxiang
@@ -0,0 +1,146 @@
|
||||
#include "func.h"
|
||||
#include "check.h"
|
||||
|
||||
/****************************** 校验相关操作 ******************************/
|
||||
void f_addcrc(uint8_t *data, uint16_t length)
|
||||
{
|
||||
uint16_t crc = CRC16_MODBUS(data, length-2);
|
||||
data[length-2] = crc & 0xFF;
|
||||
data[length-1] = crc >> 8;
|
||||
}
|
||||
|
||||
uint8_t f_checkcrc(const uint8_t *data, uint16_t length)
|
||||
{
|
||||
uint16_t crc = CRC16_MODBUS(data, length-2);
|
||||
if(((crc&0xFF) == data[length-2])&&(((crc>>8)&0xFF) == data[length-1]))
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/****************************** 内存相关操作 ******************************/
|
||||
//内存拷贝
|
||||
void f_memcpy(uint8_t *dest, const uint8_t *src, uint16_t size)
|
||||
{
|
||||
while(size--)
|
||||
{
|
||||
*dest++ = *src++;
|
||||
}
|
||||
}
|
||||
|
||||
//内存赋值
|
||||
void f_memset(uint8_t *data, uint8_t val, uint16_t size)
|
||||
{
|
||||
while(size--)
|
||||
{
|
||||
*data++ = val;
|
||||
}
|
||||
}
|
||||
|
||||
//内存比较
|
||||
uint8_t f_memcmp(const uint8_t *data1, const uint8_t *data2, uint16_t size)
|
||||
{
|
||||
while(size--)
|
||||
{
|
||||
if(*data1++ != *data2++)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/****************************** 字符串相关操作 ******************************/
|
||||
//字符比较
|
||||
uint8_t f_chrcmp(const uint8_t *data, uint8_t val, uint16_t size)
|
||||
{
|
||||
while(size--)
|
||||
{
|
||||
if(*data++ != val)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
//字符串比较
|
||||
uint8_t f_strcmp(const uint8_t *str1, const uint8_t *str2)
|
||||
{
|
||||
while(*str1 == *str2)
|
||||
{
|
||||
if(*str1 == 0) //比较结束
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
str1++;
|
||||
str2++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
//字符串查找，查找str1中是否有str2
|
||||
uint8_t f_strstr(const uint8_t *str1, const uint8_t *str2)
|
||||
{
|
||||
uint8_t *p, *q;
|
||||
while(*str1)
|
||||
{
|
||||
p = (uint8_t *)str1;
|
||||
q = (uint8_t *)str2;
|
||||
if(*p == *q)
|
||||
{
|
||||
while(*q && (*p == *q))
|
||||
{
|
||||
p++;
|
||||
q++;
|
||||
}
|
||||
if(*q == 0)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
str1++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
//查找字符串中某字符第一次出现的位置
|
||||
int8_t f_strchr(const uint8_t *str, uint8_t ch)
|
||||
{
|
||||
uint16_t loc = 0;
|
||||
while(*str != 0 && *str != ch)
|
||||
{
|
||||
str++;
|
||||
loc++;
|
||||
}
|
||||
return ((*str == ch) ? loc : -1);
|
||||
}
|
||||
|
||||
/******************************* 计算相关操作 *******************************/
|
||||
//计算两个数的差值
|
||||
float f_delta(const float aa, const float bb)
|
||||
{
|
||||
if(aa > bb)
|
||||
{
|
||||
return (aa - bb);
|
||||
}
|
||||
else
|
||||
{
|
||||
return (bb - aa);
|
||||
}
|
||||
}
|
||||
|
||||
//计算两个数差的绝对值
|
||||
uint32_t f_abs(const uint32_t aa, const uint32_t bb)
|
||||
{
|
||||
if(aa > bb)
|
||||
{
|
||||
return (aa - bb);
|
||||
}
|
||||
else
|
||||
{
|
||||
return (bb - aa);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
#ifndef __FUNC_H
|
||||
#define __FUNC_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
//位变量按字节对齐
|
||||
#define SWAP(a, b, type) {type temp = a; a = b; b = temp;}
|
||||
#define bytealign(bits) ((bits + 7) & 0xF8)
|
||||
|
||||
typedef union {uint32_t value; uint8_t data[4];}WORD_T;
|
||||
typedef union {float value; uint8_t data[4];}FLOAT_T;
|
||||
|
||||
|
||||
/****************************** 校验相关操作 ******************************/
|
||||
extern void f_addcrc(uint8_t *data, uint16_t length);
|
||||
extern uint8_t f_checkcrc(const uint8_t *data, uint16_t length);
|
||||
/****************************** 内存相关操作 ******************************/
|
||||
extern void f_memcpy(uint8_t *dest, const uint8_t *src, uint16_t size);
|
||||
extern void f_memset(uint8_t *data, uint8_t val, uint16_t size);
|
||||
extern uint8_t f_memcmp(const uint8_t *data1, const uint8_t *data2, uint16_t size);
|
||||
/***************************** 字符串相关操作 *****************************/
|
||||
extern uint8_t f_chrcmp(const uint8_t *data, uint8_t val, uint16_t size);
|
||||
extern uint8_t f_strcmp(const uint8_t *str1, const uint8_t *str2);
|
||||
extern uint8_t f_strstr(const uint8_t *str1, const uint8_t *str2);
|
||||
extern int8_t f_strchr(const uint8_t *str, uint8_t ch);
|
||||
|
||||
/******************************* 计算相关操作 *******************************/
|
||||
extern float f_delta(const float aa, const float bb);
|
||||
extern uint32_t f_abs(const uint32_t val1, const uint32_t val2);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,84 @@
|
||||
#include "hal_api.h"
|
||||
#include "xc_hal.h"
|
||||
#include "xc_24g.h"
|
||||
#include "radar.h"
|
||||
#include "uart.h"
|
||||
|
||||
|
||||
void api_delayms(uint32_t wait)
|
||||
{
|
||||
hal_delayms(wait);
|
||||
}
|
||||
|
||||
void api_pwm_out(uint16_t light, uint16_t *color)
|
||||
{
|
||||
hal_pwm_set(0, light);
|
||||
}
|
||||
|
||||
uint32_t api_random(void)
|
||||
{
|
||||
return hal_random();
|
||||
}
|
||||
|
||||
/************************ FLASHÇý¶¯½Ó¿Ú *****************************/
|
||||
void api_flash_init(uint8_t idnum)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
uint8_t api_flash_check(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t api_flash_erase(uint8_t id)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t api_flash_read(uint8_t id, uint8_t *data, uint16_t size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint8_t api_flash_write(uint8_t id, uint8_t *data, uint16_t size)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/************************* À×´ïÇý¶¯½Ó¿Ú ****************************/
|
||||
uint8_t api_radar_init(uint32_t setbase, uint16_t setper, uint8_t save)
|
||||
{
|
||||
return radar_init(setbase, setper, save);
|
||||
}
|
||||
|
||||
uint8_t api_radar_setbase(uint32_t setbase)
|
||||
{
|
||||
return radar_setbase(setbase);
|
||||
}
|
||||
|
||||
void api_radar_read(uint16_t *data)
|
||||
{
|
||||
radar_readval(data);
|
||||
}
|
||||
|
||||
void api_radar_getper(uint8_t *data)
|
||||
{
|
||||
radar_getper(data);
|
||||
}
|
||||
|
||||
void api_radar_getcfg(uint8_t *data)
|
||||
{
|
||||
radar_getcfg(data);
|
||||
}
|
||||
|
||||
__RAM_CODE void api_uart_recv(void (*func)(uint8_t *, uint8_t))
|
||||
{
|
||||
uart_recv(func);
|
||||
}
|
||||
|
||||
|
||||
void api_led_set(uint8_t value)
|
||||
{
|
||||
hal_led_set(value);
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
#ifndef __API_H
|
||||
#define __API_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
|
||||
#define DEVICE_TYPE 2
|
||||
|
||||
#define LAMP_TYPE 1
|
||||
|
||||
#define RF_SYNCWORD 0x58adc86e
|
||||
#define RF_TXPOWER 0x1D
|
||||
|
||||
|
||||
#define MSEC(x) (x)
|
||||
#define SEC(x) (x*1000)
|
||||
#define MIN(x) (x*60000)
|
||||
|
||||
|
||||
#ifndef BIT
|
||||
#define BIT(x) (1<<x)
|
||||
#endif
|
||||
|
||||
#ifndef NULL
|
||||
#define NULL 0
|
||||
#endif
|
||||
|
||||
extern uint8_t chipuid[12];
|
||||
extern uint8_t deviceaddr[4];
|
||||
|
||||
//api_mcu
|
||||
extern uint8_t api_mcu_init(void);
|
||||
extern void api_delayms(uint32_t wait);
|
||||
extern void api_pwm_out(uint16_t light, uint16_t *color);
|
||||
extern void api_wdt_feed(void);
|
||||
extern uint32_t api_random(void);
|
||||
extern uint32_t api_nowtick(void);
|
||||
|
||||
//api_rf
|
||||
extern void api_rf_init(uint32_t syncword, uint8_t txpa);
|
||||
extern void api_rf_send(uint8_t *data, uint8_t length);
|
||||
extern uint8_t api_rf_recv(uint8_t *data, uint8_t *rssi);
|
||||
extern uint8_t api_rf_istxpower(uint8_t txpa);
|
||||
|
||||
//api_nvm.c
|
||||
extern void api_flash_init(uint8_t idnum);
|
||||
extern uint8_t api_flash_check(void);
|
||||
extern uint8_t api_flash_erase(uint8_t id);
|
||||
extern uint8_t api_flash_read(uint8_t id, uint8_t *data, uint16_t size);
|
||||
extern uint8_t api_flash_write(uint8_t id, uint8_t *data, uint16_t size);
|
||||
|
||||
//api_radar.c
|
||||
extern uint8_t api_radar_init(uint32_t setbase, uint16_t setper, uint8_t save);
|
||||
extern uint8_t api_radar_setbase(uint32_t setbase);
|
||||
extern void api_radar_read(uint16_t *data);
|
||||
extern void api_radar_getper(uint8_t *data);
|
||||
extern void api_radar_getcfg(uint8_t *data);
|
||||
|
||||
//api_port
|
||||
extern void api_uart_recv(void (*func)(uint8_t *, uint8_t));
|
||||
extern void api_led_set(uint8_t value);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,121 @@
|
||||
#include "xc_hal.h"
|
||||
#include "uart.h"
|
||||
#include "radar.h"
|
||||
|
||||
uint8_t rad_txbuff[16] = {0};
|
||||
uint8_t rad_rxbuff[16] = {0};
|
||||
|
||||
uint8_t rad_flag = 1;
|
||||
uint8_t rad_ccc = 1;
|
||||
uint16_t rad_aaa = 100;
|
||||
uint32_t rad_bbb = 30;
|
||||
|
||||
static uint8_t cmd_setval(uint32_t setval, uint8_t save)
|
||||
{
|
||||
rad_txbuff[0] = 0xA1;
|
||||
rad_txbuff[1] = 0x07;
|
||||
rad_txbuff[2] = setval >> 8;
|
||||
rad_txbuff[3] = setval & 0xFF;
|
||||
rad_txbuff[4] = 0x00;
|
||||
rad_txbuff[5] = 0x02;
|
||||
rad_txbuff[6] = 0x00;
|
||||
rad_txbuff[7] = 0x00;
|
||||
rad_txbuff[8] = (save!=0)?1:0;
|
||||
return uart_trx(rad_txbuff, rad_rxbuff);
|
||||
}
|
||||
|
||||
static uint8_t cmd_getval(uint32_t *getval)
|
||||
{
|
||||
rad_txbuff[0] = 0xA2;
|
||||
rad_txbuff[1] = 0x00;
|
||||
if(uart_trx(rad_txbuff, rad_rxbuff))
|
||||
{
|
||||
*getval = rad_rxbuff[2]<<8|rad_rxbuff[3];
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint8_t cmd_setflag(uint8_t flag)
|
||||
{
|
||||
rad_txbuff[0] = 0xA3;
|
||||
rad_txbuff[1] = 0x01;
|
||||
rad_txbuff[2] = flag;
|
||||
return uart_trx(rad_txbuff, rad_rxbuff);
|
||||
}
|
||||
|
||||
static uint8_t cmd_getflag(uint8_t *data)
|
||||
{
|
||||
rad_txbuff[0] = 0xA4;
|
||||
rad_txbuff[1] = 0x00;
|
||||
if(uart_trx(rad_txbuff, rad_rxbuff))
|
||||
{
|
||||
*data = rad_rxbuff[2];
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
//À×´ï³õʼ»¯
|
||||
uint8_t radar_init(uint32_t setbase, uint16_t setper, uint8_t save)
|
||||
{
|
||||
uint8_t enable = 0;
|
||||
uint32_t setval = 0;
|
||||
|
||||
rad_flag = save;
|
||||
if(setper & 0x8000)
|
||||
{
|
||||
enable = 0;
|
||||
setval = 255;
|
||||
}
|
||||
else
|
||||
{
|
||||
enable = 1;
|
||||
setval = (uint64_t)(setbase * setper) / 100;
|
||||
if(setval > 255) setval = 255;
|
||||
}
|
||||
if(!cmd_setflag(enable))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
rad_ccc = enable;
|
||||
delay_ms(40);
|
||||
if(!cmd_setval(setval, save))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
rad_bbb = setval;
|
||||
rad_aaa = setper;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
uint8_t radar_setbase(uint32_t setbase)
|
||||
{
|
||||
return radar_init(setbase, rad_aaa, rad_flag);
|
||||
}
|
||||
|
||||
void radar_readval(uint16_t *data)
|
||||
{
|
||||
data[0] = (hal_rad_get())?1023:0;
|
||||
data[1] = data[0];
|
||||
}
|
||||
|
||||
void radar_getper(uint8_t *data)
|
||||
{
|
||||
data[0] = rad_aaa & 0xFF;
|
||||
data[1] = rad_aaa >> 8;
|
||||
}
|
||||
|
||||
void radar_getcfg(uint8_t *data)
|
||||
{
|
||||
cmd_getval(&rad_bbb);
|
||||
cmd_getflag(&rad_ccc);
|
||||
data[0] = rad_ccc;
|
||||
data[1] = (rad_bbb >> 0) & 0xFF;
|
||||
data[2] = (rad_bbb >> 8) & 0xFF;
|
||||
data[3] = (rad_bbb >> 16) & 0xFF;
|
||||
data[4] = (rad_bbb >> 24) & 0xFF;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
#ifndef __RADAR_H
|
||||
#define __RADAR_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
extern uint8_t radar_init(uint32_t setbase, uint16_t setper, uint8_t save);
|
||||
extern uint8_t radar_setbase(uint32_t setbase);
|
||||
extern void radar_readval(uint16_t *data);
|
||||
extern void radar_getper(uint8_t *data);
|
||||
extern void radar_getcfg(uint8_t *data);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,364 @@
|
||||
#include "app.h"
|
||||
|
||||
const configa_t configa = {
|
||||
.light1 = 70,
|
||||
.light0 = 5,
|
||||
.time = 3,
|
||||
.uidx = 10,
|
||||
.didx = 12,
|
||||
.ctemp = 50,
|
||||
.weight = 3500,
|
||||
.color1 = {255, 255, 255, 255, 255},
|
||||
.color0 = {255, 255, 255, 255, 255},
|
||||
};
|
||||
|
||||
const configb_t configb = {
|
||||
.a = 50,
|
||||
.b = 100,
|
||||
};
|
||||
|
||||
|
||||
const configc_t configc = {
|
||||
.a = 30,
|
||||
.b = 720,
|
||||
.c = 24,
|
||||
.d = 0,
|
||||
.e = 1,
|
||||
.f = 100,
|
||||
.g = 0x1D,
|
||||
.h = 10,
|
||||
};
|
||||
|
||||
|
||||
const configd_t configd = {
|
||||
.a = 20000,
|
||||
.b = 3,
|
||||
.c = 16,
|
||||
.d = 8,
|
||||
.e = 10,
|
||||
.f = 25,
|
||||
.g1 = 12,
|
||||
.g2 = 0,
|
||||
};
|
||||
|
||||
|
||||
const confige_t confige = {
|
||||
.a = 200,
|
||||
.b = 100,
|
||||
.c = 3,
|
||||
.d = 1,
|
||||
.e = 60,
|
||||
.f = 60,
|
||||
};
|
||||
|
||||
const roles_t init_aa = {
|
||||
ROLE_A,
|
||||
};
|
||||
|
||||
|
||||
const status_t init_bb = {
|
||||
STAT_1,
|
||||
};
|
||||
|
||||
param_t param;
|
||||
setting_t settinga = {0};
|
||||
setting_t settingb = {0};
|
||||
setting_t settingc = {0};
|
||||
cfga_t cfga = {0};
|
||||
cfgb_t cfgb = {0};
|
||||
cfgc_t cfgc = {0};
|
||||
|
||||
uint16_t save_mask = 0;
|
||||
uint16_t save_count = 0;
|
||||
uint16_t wmap_wait = 0;
|
||||
|
||||
|
||||
void store_init(void)
|
||||
{
|
||||
api_flash_read(ID_MAP2, (uint8_t *)¶m, sizeof(param));
|
||||
api_flash_read(ID_MAP3, (uint8_t *)&settinga.list, sizeof(settinga.list));
|
||||
api_flash_read(ID_MAP4, (uint8_t *)&settingb.list, sizeof(settingb.list));
|
||||
api_flash_read(ID_MAP5, (uint8_t *)&settingc.list, sizeof(settingc.list));
|
||||
|
||||
if(param.aa != LAMPTYPE)
|
||||
{
|
||||
api_flash_erase(ID_MAP2);
|
||||
store_clear_map(ID_MAP3);
|
||||
store_clear_map(ID_MAP4);
|
||||
store_clear_map(ID_MAP5);
|
||||
|
||||
f_memset((uint8_t *)¶m, 0xFF, sizeof(param));
|
||||
param.aa = LAMPTYPE;
|
||||
param.bb = init_bb;
|
||||
param.cc = init_aa;
|
||||
param.ca = configa;
|
||||
param.cb = configb;
|
||||
param.cd = configc;
|
||||
param.ce = configd;
|
||||
param.cf = confige;
|
||||
api_flash_write(ID_MAP2, (uint8_t *)¶m, sizeof(param));
|
||||
}
|
||||
|
||||
for(uint8_t i = 0; i < NUM_DEVICES; i++)
|
||||
{
|
||||
if(settinga.list[i].aa > 0 && settinga.list[i].aa < param.ce.a)
|
||||
{
|
||||
settinga.number++;
|
||||
}
|
||||
if(settingb.list[i].aa > 0 && settingb.list[i].aa < param.ce.a)
|
||||
{
|
||||
settingb.number++;
|
||||
}
|
||||
if(!f_chrcmp(settingc.list[i].addr, 0xFF, 4) && !f_chrcmp(settingc.list[i].addr, 0x00, 4))
|
||||
{
|
||||
settingc.number++;
|
||||
}
|
||||
}
|
||||
f_memset((uint8_t *)&cfga.list, 0xFF, sizeof(cfga.list));
|
||||
f_memset((uint8_t *)&cfgb.list, 0xFF, sizeof(cfgb.list));
|
||||
f_memset((uint8_t *)&cfgc.list, 0xFF, sizeof(cfgc.list));
|
||||
}
|
||||
|
||||
|
||||
void store_process_100ms(void)
|
||||
{
|
||||
if(save_mask & (1<<ID_MAP2))
|
||||
{
|
||||
save_mask &= ~(1<<ID_MAP2);
|
||||
api_flash_write(ID_MAP2, (uint8_t *)¶m, sizeof(param));
|
||||
}
|
||||
|
||||
if(wmap_wait > 0 && --wmap_wait == 0)
|
||||
{
|
||||
api_flash_write(ID_MAP5, (uint8_t *)&settingc.list, sizeof(settingc.list));
|
||||
}
|
||||
|
||||
if(++save_count >= 6000)
|
||||
{
|
||||
save_count = 0;
|
||||
if(save_mask & (1<<ID_MAP3))
|
||||
{
|
||||
save_mask &= ~(1<<ID_MAP3);
|
||||
api_flash_write(ID_MAP3, (uint8_t *)&settinga.list, sizeof(settinga.list));
|
||||
}
|
||||
if(save_mask & (1<<ID_MAP4))
|
||||
{
|
||||
save_mask &= ~(1<<ID_MAP4);
|
||||
api_flash_write(ID_MAP4, (uint8_t *)&settingb.list, sizeof(settingb.list));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void store_write_param(uint8_t type, uint8_t *data)
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case PARAM1:
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
break;
|
||||
case PARAM2:
|
||||
if(param.bb != data[0])
|
||||
{
|
||||
param.bb = data[0];
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
break;
|
||||
case PARAM3:
|
||||
if(param.cc != data[0])
|
||||
{
|
||||
param.cc = data[0];
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
break;
|
||||
case PARAM4:
|
||||
if(param.dd != data[0])
|
||||
{
|
||||
param.dd = data[0];
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
break;
|
||||
case PARAM5:
|
||||
if(!f_memcmp(param.ee, data, 4))
|
||||
{
|
||||
f_memcpy(param.ee, data, 4);
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
break;
|
||||
case PARAM6:
|
||||
if(!f_memcmp(param.ff, data, 4))
|
||||
{
|
||||
f_memcpy(param.ff, data, 4);
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
break;
|
||||
case PARAM7:
|
||||
if(!f_memcmp(param.gg, data, 12))
|
||||
{
|
||||
f_memcpy(param.gg, data, 12);
|
||||
api_flash_write(ID_MAP2, (uint8_t *)¶m, sizeof(param));
|
||||
}
|
||||
break;
|
||||
case PARAM8:
|
||||
if(!f_memcmp(param.ca.data, data, sizeof(param.ca)))
|
||||
{
|
||||
f_memcpy(param.ca.data, data, sizeof(param.ca));
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
break;
|
||||
case PARAM9:
|
||||
if(!f_memcmp(param.cb.data, data, 4))
|
||||
{
|
||||
f_memcpy(param.cb.data, data, 4);
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
break;
|
||||
case PARAM10:
|
||||
if(!f_memcmp(param.cd.data, data, 12))
|
||||
{
|
||||
f_memcpy(param.cd.data, data, 12);
|
||||
api_flash_write(ID_MAP2, (uint8_t *)¶m, sizeof(param));
|
||||
}
|
||||
break;
|
||||
case PARAM11:
|
||||
if(!f_memcmp(param.ce.data, data, 8))
|
||||
{
|
||||
f_memcpy(param.ce.data, data, 8);
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
break;
|
||||
case PARAM12:
|
||||
if(!f_memcmp(param.cf.data, data, 6))
|
||||
{
|
||||
f_memcpy(param.cf.data, data, 6);
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
break;
|
||||
case PARAM13:
|
||||
if(data[0] < 8 && !f_memcmp(param.cg[data[0]], data+1, 4))
|
||||
{
|
||||
f_memcpy(param.cg[data[0]], data+1, 4);
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
else if(data[0] >= 8)
|
||||
{
|
||||
f_memset((uint8_t *)¶m.cg, 0xFF, sizeof(param.cg));
|
||||
save_mask |= (1<<ID_MAP2);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//Çå³ý±í
|
||||
void store_clear_map(uint8_t mapid)
|
||||
{
|
||||
switch(mapid)
|
||||
{
|
||||
case ID_MAP3:
|
||||
settinga.number = 0;
|
||||
if(!f_chrcmp((uint8_t *)&settinga.list, 0xFF, sizeof(settinga.list)))
|
||||
{
|
||||
api_flash_erase(ID_MAP3);
|
||||
f_memset((uint8_t *)&settinga.list, 0xFF, sizeof(settinga.list));
|
||||
}
|
||||
break;
|
||||
case ID_MAP4:
|
||||
settingb.number = 0;
|
||||
if(!f_chrcmp((uint8_t *)&settingb.list, 0xFF, sizeof(settingb.list)))
|
||||
{
|
||||
api_flash_erase(ID_MAP4);
|
||||
f_memset((uint8_t *)&settingb.list, 0xFF, sizeof(settingb.list));
|
||||
}
|
||||
break;
|
||||
case ID_MAP5:
|
||||
settingc.number = 0;
|
||||
if(!f_chrcmp((uint8_t *)&settingc.list, 0xFF, sizeof(settingc.list)))
|
||||
{
|
||||
api_flash_erase(ID_MAP5);
|
||||
f_memset((uint8_t *)&settingc.list, 0xFF, sizeof(settingc.list));
|
||||
}
|
||||
break;
|
||||
case ID_MAP7:
|
||||
cfgb.number = 0;
|
||||
f_memset((uint8_t *)&cfgb.list, 0xFF, sizeof(cfgb.list));
|
||||
break;
|
||||
case ID_MAP6:
|
||||
cfga.number = 0;
|
||||
f_memset((uint8_t *)&cfga.list, 0xFF, sizeof(cfga.list));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
//дÈë±í
|
||||
void store_write_map(uint8_t mapid, uint8_t *data)
|
||||
{
|
||||
save_mask |= (1<<mapid);
|
||||
switch(mapid)
|
||||
{
|
||||
case ID_MAP5:
|
||||
if(data[0] < NUM_DEVICES) {
|
||||
settingc.number = data[0]+1;
|
||||
f_memcpy((uint8_t *)&settingc.list[data[0]], data+1, 6);
|
||||
wmap_wait = 30;
|
||||
} else {
|
||||
store_clear_map(ID_MAP5);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void store_read_map(uint8_t mapid, uint8_t *data)
|
||||
{
|
||||
switch(mapid)
|
||||
{
|
||||
case ID_MAP3:
|
||||
if(data[0] < NUM_DEVICES) {
|
||||
f_memcpy(data+1, (uint8_t *)&settinga.list[data[0]], 8);
|
||||
}
|
||||
break;
|
||||
case ID_MAP4:
|
||||
if(data[0] < NUM_DEVICES) {
|
||||
f_memcpy(data+1, (uint8_t *)&settingb.list[data[0]], 8);
|
||||
}
|
||||
break;
|
||||
case ID_MAP5:
|
||||
if(data[0] < NUM_DEVICES) {
|
||||
f_memcpy(data+1, (uint8_t *)&settingc.list[data[0]], 6);
|
||||
}
|
||||
break;
|
||||
case ID_MAP6:
|
||||
if(data[0] < NUM_DEVICES) {
|
||||
f_memcpy(data+1, cfga.list[data[0]].addr, 4);
|
||||
data[5] = cfga.list[data[0]].a;
|
||||
data[6] = cfga.list[data[0]].b;
|
||||
data[7] = cfga.list[data[0]].c;
|
||||
data[8] = cfga.list[data[0]].d & 0xFF;
|
||||
data[9] = cfga.list[data[0]].d >> 8;
|
||||
data[10] = cfga.list[data[0]].e & 0xFF;
|
||||
data[11] = cfga.list[data[0]].e >> 8;
|
||||
}
|
||||
break;
|
||||
case ID_MAP7:
|
||||
if(data[0] < NUM_cfgb) {
|
||||
f_memcpy(data+1, (uint8_t *)&cfgb.list[data[0]], 8);
|
||||
}
|
||||
break;
|
||||
case ID_MAP8:
|
||||
if(data[0] < NUM_cfgc) {
|
||||
f_memcpy(data+1, (uint8_t *)&cfgc.list[data[0]], 5);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void store_setfl(uint8_t number)
|
||||
{
|
||||
store_clear_map(ID_MAP4);
|
||||
param.cb.a = 65535;
|
||||
param.cb.b = 65535;
|
||||
f_memset((uint8_t *)¶m.cg, 0xFF, sizeof(param.cg));
|
||||
for(uint8_t i = 0; i < number && number <= 8; i++)
|
||||
{
|
||||
f_memcpy(param.cg[i], settinga.list[i].addr, 4);
|
||||
}
|
||||
api_flash_write(ID_MAP2, (uint8_t *)¶m, sizeof(param));
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
#include "uart.h"
|
||||
#include "xc_hal.h"
|
||||
#include "check.h"
|
||||
|
||||
|
||||
#define RAD_HEAD1 0xFA
|
||||
#define RAD_HEAD2 0x3C
|
||||
#define RAD_REAR1 0x3D
|
||||
#define RAD_REAR2 0xFB
|
||||
|
||||
#define TEST_HEAD1 0x2B
|
||||
#define TEST_HEAD2 0x2B
|
||||
#define TEST_REAR1 0xE4
|
||||
#define TEST_REAR2 0xC7
|
||||
|
||||
//数据协议类型
|
||||
#define TYPE_RAD 1
|
||||
#define TYPE_TEST 2
|
||||
|
||||
uint8_t port_txbuff[40] = {0};
|
||||
uint8_t port_rxdata[32] = {0};
|
||||
|
||||
volatile uint8_t rxcnt = 0;
|
||||
volatile uint8_t rxstat = 0;
|
||||
volatile uint8_t rxtype = 0;
|
||||
volatile uint8_t rxflag = 0;
|
||||
volatile uint8_t rxwait = 0;
|
||||
volatile uint8_t radar_wait = 0;
|
||||
|
||||
void uart_tick(void)
|
||||
{
|
||||
if(rxwait > 0 && --rxwait == 0)
|
||||
{
|
||||
rxstat = 0;
|
||||
}
|
||||
if(radar_wait > 0)
|
||||
{
|
||||
radar_wait--;
|
||||
}
|
||||
}
|
||||
|
||||
//端口接收中断
|
||||
void uart_rxbyte(uint8_t byte)
|
||||
{
|
||||
switch(rxstat)
|
||||
{
|
||||
case 0: //接收帧头1
|
||||
if(byte == RAD_HEAD1)
|
||||
{
|
||||
rxtype = TYPE_RAD;
|
||||
rxstat = 1;
|
||||
}
|
||||
else if(byte == TEST_HEAD1)
|
||||
{
|
||||
rxtype = TYPE_TEST;
|
||||
rxstat = 11;
|
||||
}
|
||||
break;
|
||||
case 1: //接收帧头2
|
||||
rxstat = (byte==RAD_HEAD2) ? 2 : 0;
|
||||
break;
|
||||
case 2:
|
||||
port_rxdata[0] = byte;
|
||||
rxstat = 3;
|
||||
break;
|
||||
case 3:
|
||||
rxstat = (byte==0) ? 4 : 0;
|
||||
break;
|
||||
case 4:
|
||||
rxcnt = 0;
|
||||
port_rxdata[1] = byte;
|
||||
rxstat = (byte!=0)?5:6;
|
||||
break;
|
||||
case 5:
|
||||
port_rxdata[2+rxcnt] = byte;
|
||||
if(++rxcnt >= port_rxdata[1] || rxcnt >= 30)
|
||||
{
|
||||
rxstat = 6;
|
||||
}
|
||||
break;
|
||||
case 6:
|
||||
rxstat = 7;
|
||||
break;
|
||||
case 7:
|
||||
rxstat = (byte==RAD_REAR1) ? 8 : 0;
|
||||
break;
|
||||
case 8:
|
||||
if(byte == RAD_REAR2)
|
||||
{
|
||||
rxflag = 1;
|
||||
}
|
||||
rxstat = 0;
|
||||
break;
|
||||
case 11:
|
||||
rxstat = (byte==TEST_HEAD2) ? 12 : 0;
|
||||
break;
|
||||
case 12:
|
||||
port_rxdata[0] = byte;
|
||||
rxstat = 13;
|
||||
break;
|
||||
case 13:
|
||||
rxcnt = 0;
|
||||
port_rxdata[1] = byte;
|
||||
rxstat = (byte!=0)?14:15;
|
||||
break;
|
||||
case 14:
|
||||
port_rxdata[2+rxcnt] = byte;
|
||||
if(++rxcnt >= port_rxdata[1])
|
||||
{
|
||||
rxstat = 15;
|
||||
}
|
||||
break;
|
||||
case 15:
|
||||
rxstat = (byte==TEST_REAR1) ? 16 : 0;
|
||||
break;
|
||||
case 16:
|
||||
if(byte == TEST_REAR2)
|
||||
{
|
||||
rxflag = 1;
|
||||
}
|
||||
rxstat = 0;
|
||||
break;
|
||||
}
|
||||
rxwait = 10;
|
||||
}
|
||||
|
||||
void uart_send(uint8_t *pdata, uint8_t type)
|
||||
{
|
||||
uint8_t txcnt = 0;
|
||||
|
||||
rxflag = 0;
|
||||
if(type == TYPE_RAD)
|
||||
{
|
||||
port_txbuff[txcnt++] = RAD_HEAD1;
|
||||
port_txbuff[txcnt++] = RAD_HEAD2;
|
||||
port_txbuff[txcnt++] = pdata[0];
|
||||
port_txbuff[txcnt++] = 0x00;
|
||||
port_txbuff[txcnt++] = pdata[1];
|
||||
for(uint8_t i = 0; i < pdata[1]; i++)
|
||||
{
|
||||
port_txbuff[txcnt++] = pdata[2+i];
|
||||
}
|
||||
port_txbuff[txcnt++] = CRC8_SAE(port_txbuff+2, pdata[1]+3);
|
||||
port_txbuff[txcnt++] = RAD_REAR1;
|
||||
port_txbuff[txcnt++] = RAD_REAR2;
|
||||
}
|
||||
else if(type == TYPE_TEST)
|
||||
{
|
||||
port_txbuff[txcnt++] = TEST_HEAD1;
|
||||
port_txbuff[txcnt++] = TEST_HEAD2;
|
||||
port_txbuff[txcnt++] = pdata[0];
|
||||
port_txbuff[txcnt++] = pdata[1];
|
||||
for(uint8_t i = 0; i < pdata[1]; i++)
|
||||
{
|
||||
port_txbuff[txcnt++] = pdata[2+i];
|
||||
}
|
||||
port_txbuff[txcnt++] = TEST_REAR1;
|
||||
port_txbuff[txcnt++] = TEST_REAR2;
|
||||
}
|
||||
hal_uart_send(port_txbuff, txcnt);
|
||||
}
|
||||
|
||||
uint8_t radcmd_map[] = {0x11, 0x12, 0xB3, 0x14, 0x15, 0x16, 0x17};
|
||||
uint8_t tstcmd_map[] = {0x01, 0x02, 0x03};
|
||||
|
||||
static uint8_t check_radcmd(uint8_t cmd)
|
||||
{
|
||||
for(uint8_t i = 0; i < sizeof(radcmd_map); i++)
|
||||
{
|
||||
if(cmd == radcmd_map[i])
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static uint8_t check_tstcmd(uint8_t cmd)
|
||||
{
|
||||
for(uint8_t i = 0; i < sizeof(tstcmd_map); i++)
|
||||
{
|
||||
if(cmd == tstcmd_map[i])
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void uart_recv(void (*func)(uint8_t *, uint8_t))
|
||||
{
|
||||
if(rxflag != 0)
|
||||
{
|
||||
rxflag = 0;
|
||||
if(rxtype == TYPE_RAD && check_radcmd(port_rxdata[0]))
|
||||
{
|
||||
(*func)(port_rxdata, rxtype);
|
||||
if(port_rxdata[0] != 0x12)
|
||||
{
|
||||
uart_send(port_rxdata, TYPE_RAD);
|
||||
}
|
||||
}
|
||||
if(rxtype == TYPE_TEST && check_tstcmd(port_rxdata[0]))
|
||||
{
|
||||
(*func)(port_rxdata, rxtype);
|
||||
uart_send(port_rxdata, TYPE_TEST);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t uart_trx(uint8_t *txdata, uint8_t *rxdata)
|
||||
{
|
||||
uart_send(txdata, TYPE_RAD);
|
||||
|
||||
rxflag = 0;
|
||||
rxtype = 0;
|
||||
radar_wait = 200;
|
||||
while(radar_wait != 0)
|
||||
{
|
||||
if((rxflag != 0) && (rxtype == TYPE_RAD))
|
||||
{
|
||||
rxflag = 0;
|
||||
for(int i = 0; i < port_rxdata[1]+2; i++)
|
||||
{
|
||||
rxdata[i] = port_rxdata[i];
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
//rxflag = 0;
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
#ifndef __UART_H
|
||||
#define __UART_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
extern void uart_tick(void);
|
||||
extern void uart_recv(void (*func)(uint8_t *, uint8_t));
|
||||
extern void uart_rxbyte(uint8_t data);
|
||||
extern uint8_t uart_trx(uint8_t *txdata, uint8_t *rxdata);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,690 @@
|
||||
#include "xc_24g_register.h"
|
||||
#include "xc60xx.h"
|
||||
#include "xc_24g.h"
|
||||
|
||||
static volatile uint8_t nrf_tx_status = 0; //发送完成中断
|
||||
|
||||
//定义接收队列
|
||||
uint8_t rxfifo[8][RF_BUFF_LEN+2]; //包含1RSSI+1字节包长度
|
||||
uint8_t rxread = 0, rxwrite = 0;
|
||||
|
||||
//定义RF配置
|
||||
struct _rf_cfg_t
|
||||
{
|
||||
uint16_t tx_chan; //发射信道
|
||||
uint16_t rx_chan; //接收信道
|
||||
uint32_t tx_addr; //发射地址
|
||||
uint32_t rx_addr; //接收地址
|
||||
}rf_cfg = { RF_BLE_CHN37, RF_BLE_CHN37, RF_BLE_ADDR, RF_BLE_ADDR };
|
||||
|
||||
static void nop_cnt(uint32_t cnt)
|
||||
{
|
||||
for (uint32_t i = 0; i < cnt; i++)
|
||||
__nop();
|
||||
}
|
||||
|
||||
static void nrf_rc_calib(void)
|
||||
{
|
||||
static uint8_t calib_flag = false;
|
||||
if (calib_flag)
|
||||
return;
|
||||
|
||||
uint16_t r_val = 0;
|
||||
XC_BT_RF->rccal_reg_l &= ~(0x7 << 8);
|
||||
XC_BT_RF->rccal_reg_l |= (0x5 << 8);
|
||||
delay_us(20);
|
||||
XC_BT_RF->rccal_reg_l |= (0x1 << 5); //RG_RCCAL_RESETN = 1
|
||||
delay_us(20);
|
||||
XC_BT_RF->rccal_reg_l &= ~(0x1 << 3); //RG_RCCAL_SEL = 0
|
||||
delay_us(20);
|
||||
XC_BT_RF->rccal_reg_l |= (0x1 << 2); //RG_RCCAL_EN = 1
|
||||
delay_us(02);
|
||||
XC_BT_RF->rccal_reg_l |= (0x1 << 4); //RG_RCCAL_START = 1
|
||||
delay_us(20);
|
||||
r_val = XC_BT_RF->rccal_rslt_l;
|
||||
// Waiting for AD_RCCAL_FINISH raises the calibration value AD_RCCAL_
|
||||
while (!(r_val & 0x8000)) { r_val = XC_BT_RF->rccal_rslt_l; }
|
||||
r_val = (XC_BT_RF->rccal_rslt_l & 0x7FFF) >> 10;
|
||||
XC_BT_RF->rccal_reg_l |= (0x1 << 3); //RG_RCCAL_SEL = 1
|
||||
XC_BT_RF->rccal_reg_l &= ~(0x1 << 2); //RG_RCCAL_EN = 0
|
||||
XC_BT_RF->rccal_reg_l &= ~(0x1 << 4); //RG_RCCAL_START = 0
|
||||
XC_BT_RF->rccal_reg_l &= ~(0x1F << 11);
|
||||
XC_BT_RF->rccal_reg_l |= r_val << 11;
|
||||
calib_flag = true;
|
||||
}
|
||||
|
||||
static void rf_freq_ctune(uint8_t val)
|
||||
{
|
||||
uint32_t value = cprao_aon_rf_aonreg_get();
|
||||
cprao_aon_rf_aonreg_set((value & (~(0x3f << 20))) | ((val & 0x3f) << 20));
|
||||
}
|
||||
|
||||
static void rf_reset(void)
|
||||
{
|
||||
uint32_t value = cpr_rf_reg1_get();
|
||||
cpr_rf_reg1_set(value & ~(1 << 21));
|
||||
delay_ms(2);
|
||||
cpr_rf_reg1_set(value | (1 << 21));
|
||||
delay_ms(1);
|
||||
}
|
||||
|
||||
static void nrf_modem_init(void)
|
||||
{
|
||||
cpr_bt_clk_ctl__bt_clk_en__setf(ENABLE); //BT_CLK clock control register
|
||||
cpr_bt_modem_clk_ctl__bt_modem_clk_en__setf(ENABLE); //BT_MODEM_CLK clock control register
|
||||
cpr_ctlapbclken_grctl__bt_pclk_en__setf(ENABLE); //Configure BT_PCLK_EN enable
|
||||
cprao_aon_coreldo_en_set(ENABLE);
|
||||
XC_BT_RF->ana18_reg_l &= ~((0x7 << 3) | (0x7));
|
||||
XC_BT_RF->ana18_reg_l |= (0x1 << 3);
|
||||
}
|
||||
|
||||
static void nrf_24g_config(void)
|
||||
{
|
||||
// Set sel_24G_rfchan, sel_24G_rfldoen, sel_24G_rampout regs to use 2.4G signal
|
||||
XC_BT_RF->BT.rx_ctrl_sel_l |= 0xE000;
|
||||
|
||||
#if (XINCX_RF_RATE == RATE_1M)
|
||||
XC_BT_RF->ana21_reg_l = (XC_BT_RF->ana21_reg_l & (0xFFFF8FFF)) | 0x3000;
|
||||
#elif (XINCX_RF_RATE == DR_2M)
|
||||
XC_BT_RF->ana21_reg_l = (XC_BT_RF->ana21_reg_l & (0xFFFF8FFF)) | 0x2000;
|
||||
XC_BT_RF->ana3_reg_l |= 0x01;
|
||||
#else
|
||||
XC_BT_RF->ana21_reg_l = (XC_BT_RF->ana21_reg_l & (0xFFFF8FFF)) | 0x6000;
|
||||
#endif
|
||||
|
||||
XC_BT_RF->ana29_reg_l |= 0x02; // Manual afc
|
||||
XC_BT_RF->ana28_reg_l |= 0x01; // Afc pulse
|
||||
|
||||
rf_reset(); //reset
|
||||
// enable 2.4G_mclk 2.4G_hclk 2div of 32MHz
|
||||
cpr_rf_reg1__rf24g_mclk_div__setf(1);
|
||||
cpr_rf_reg1__rf24g_hclk_en__setf(ENABLE);
|
||||
cpr_rf_reg1__rf24g_mclk_en__setf(ENABLE);
|
||||
// set 2.4G agc and iq from 2.4 modem
|
||||
cpr_rf_reg0__sel__24g_agc__setf(ENABLE);
|
||||
cpr_rf_reg0__sel__24g_hwpin__setf(ENABLE);
|
||||
|
||||
*BLE_COMN_RF24G_CTRL |= 0x700;
|
||||
|
||||
XC_BT_RF->BT.rf_ctrl1_l |= (1 << 13);
|
||||
XC_BT_RF->BT.rf_ctrl1_l &= ~(1 << 12);
|
||||
XC_BT_RF->ana2_reg_l &= ~((0xf << 5) | (0x7 << 13));
|
||||
XC_BT_RF->ana2_reg_l |= (0x9 << 5) | (0x3 << 13);
|
||||
}
|
||||
|
||||
static void nrf_set_dynpd(uint8_t dynpd)
|
||||
{
|
||||
XC_RF_2_4G->DYNPD = dynpd;
|
||||
}
|
||||
|
||||
static void nrf_set_feature(uint8_t long_pld, uint8_t fec, uint8_t whiten, uint8_t dpl, uint8_t ack_pay, uint8_t dyn_ack)
|
||||
{
|
||||
XC_RF_2_4G->FEATURE = (XC_RF_2_4G->FEATURE & (~0x3f)) | (long_pld << 5) | (fec << 4) | (whiten << 3) | (dpl << 2) | (ack_pay << 1) | dyn_ack;
|
||||
}
|
||||
|
||||
static void nrf_set_compatility_featue(uint8_t guard_cfg, uint8_t long_pld_type, uint8_t preamble_num, uint8_t preamble_type,
|
||||
uint8_t crc_scope_header, uint8_t crc_scope_addr)
|
||||
{
|
||||
XC_RF_2_4G->FEATURE = (XC_RF_2_4G->FEATURE & ~(0xff<<8)) | (guard_cfg << 15) | (long_pld_type << 14) | (preamble_num << 12) |
|
||||
(preamble_type << 11) | (crc_scope_header << 9) | (crc_scope_addr << 8);
|
||||
}
|
||||
|
||||
static void nrf_set_preamble(uint32_t preamble_word)
|
||||
{
|
||||
if(XC_RF_2_4G->FEATURE & ~(1 << 11))
|
||||
{
|
||||
XC_RF_2_4G->PREAMBLE = preamble_word;
|
||||
}
|
||||
}
|
||||
|
||||
static void nrf_set_guard_word(uint16_t guard_word)
|
||||
{
|
||||
XC_RF_2_4G->GUARD = guard_word;
|
||||
}
|
||||
|
||||
static void nrf_set_cfg_top(void)
|
||||
{
|
||||
#if (XINCX_RF_RATE == RATE_2M)
|
||||
XC_RF_2_4G->CFG_TOP = (XC_RF_2_4G->CFG_TOP & (~0x1ffff3)) | 0x1b8672;
|
||||
#else
|
||||
XC_RF_2_4G->CFG_TOP = (XC_RF_2_4G->CFG_TOP & (~0x1ffff3)) | 0x0b8272;
|
||||
#endif
|
||||
}
|
||||
|
||||
static void nrf_set_crc(uint8_t enable, uint8_t crc_bit)
|
||||
{
|
||||
if (enable)
|
||||
{
|
||||
if (crc_bit == CRC_1BIT)
|
||||
{
|
||||
XC_RF_2_4G->CFG_TOP = (XC_RF_2_4G->CFG_TOP & (~0x0c)) | (2 << 2);
|
||||
}
|
||||
else
|
||||
{
|
||||
XC_RF_2_4G->CFG_TOP = (XC_RF_2_4G->CFG_TOP & (~0x0c)) | (3 << 2);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
XC_RF_2_4G->CFG_TOP = (XC_RF_2_4G->CFG_TOP & (~0x0c)) | (1 << 2);
|
||||
}
|
||||
}
|
||||
|
||||
static void nrf_set_retr(uint8_t cnt, uint8_t delay)
|
||||
{
|
||||
XC_RF_2_4G->SETUP_RETR = cnt | (delay << 4);
|
||||
}
|
||||
|
||||
static void nrf_set_enaa(uint8_t enaa)
|
||||
{
|
||||
XC_RF_2_4G->EN_AA = (enaa << 0) | (enaa << 1) | (enaa << 2) | (enaa << 3) | (enaa << 4) | (enaa << 5);
|
||||
}
|
||||
|
||||
static void nrf_set_txaddr_width(uint8_t bytes)
|
||||
{
|
||||
switch (bytes)
|
||||
{
|
||||
case 3:
|
||||
XC_RF_2_4G->SETUP_AW = 0xa5;
|
||||
break;
|
||||
case 4:
|
||||
XC_RF_2_4G->SETUP_AW = 0xaa;
|
||||
break;
|
||||
case 5:
|
||||
XC_RF_2_4G->SETUP_AW = 0xaf;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void nrf_set_txaddr(uint32_t addr_l, uint32_t addr_h)
|
||||
{
|
||||
XC_RF_2_4G->TX_ADDR_L = addr_l;
|
||||
XC_RF_2_4G->TX_ADDR_H = (XC_RF_2_4G->TX_ADDR_H & 0xFF00) | (addr_h & 0xFF);
|
||||
}
|
||||
|
||||
static void nrf_set_rxaddr(uint32_t addr_l, uint32_t addr_h)
|
||||
{
|
||||
XC_RF_2_4G->RX_ADDR_P0_L = addr_l;
|
||||
XC_RF_2_4G->RX_ADDR_P0_H = addr_h & 0xff;
|
||||
}
|
||||
|
||||
static void nrf_set_rxlen(uint8_t len)
|
||||
{
|
||||
XC_RF_2_4G->RX_PW_Px_L = len | (0 << 8) | (0 << 16) | (0 << 24);
|
||||
XC_RF_2_4G->RX_PW_Px_H = 0 | (0 << 8);
|
||||
}
|
||||
|
||||
static void nrf_set_data_rate(uint8_t rate)
|
||||
{
|
||||
XC_RF_2_4G->SETUP_RF = rate;
|
||||
}
|
||||
|
||||
static void nrf_rssi_init(void)
|
||||
{
|
||||
uint8_t agc_map[5] = {0x44, 0x3a, 0x30, 0x26, 0x1c};
|
||||
|
||||
XC_RF_2_4G->RSSI = 1 << 6; //使能
|
||||
XC_RF_2_4G->AGC_SETTING &= ~(0xf << 16);
|
||||
XC_RF_2_4G->AGC_SETTING |= (2 << 16);
|
||||
delay_us(1);
|
||||
XC_RF_2_4G->PGA_SETTING = agc_map[0] | (agc_map[1] << 8) | (agc_map[2] << 16) | (agc_map[3] << 24);
|
||||
XC_RF_2_4G->TX_ADDR_H &= ~(0xFF << 8);
|
||||
XC_RF_2_4G->TX_ADDR_H |= (agc_map[4] << 8);
|
||||
}
|
||||
|
||||
//计算RSSI
|
||||
static uint8_t nrf_get_rssi(void)
|
||||
{
|
||||
int16_t rssi_dbm = 0;
|
||||
int16_t esti_dbm = (XC_RF_2_4G->RSSI >> 16) & 0xfff;
|
||||
uint16_t agc_gain = (XC_RF_2_4G->RSSI >> 8) & 0x7f;
|
||||
uint16_t agc = ((agc_gain >> 4) + 1) * 6 + (agc_gain & 0xf) * 2;
|
||||
|
||||
uint8_t loca_agc = (XC_RF_2_4G->PGA_SETTING >> 24) & 0xff;
|
||||
|
||||
if (loca_agc == agc) {
|
||||
rssi_dbm = ((esti_dbm * 100) / 16 - (87 + agc + 10) * 100) / 100;
|
||||
} else {
|
||||
rssi_dbm = ((esti_dbm * 100) / 16 - (87 + agc) * 100) / 100;
|
||||
}
|
||||
if (rssi_dbm <= (-90)) {
|
||||
rssi_dbm = rssi_dbm - (90 + rssi_dbm) / 2 - (90 + rssi_dbm) % 2;
|
||||
} else if ((rssi_dbm <= (-80)) && (rssi_dbm > (-90))) {
|
||||
rssi_dbm = rssi_dbm - (80 + rssi_dbm) / 2 - (80 + rssi_dbm) % 2;
|
||||
} else if ((rssi_dbm <= (-70)) && (rssi_dbm > (-80))) {
|
||||
rssi_dbm = rssi_dbm - (70 + rssi_dbm) / 2 - (70 + rssi_dbm) % 2;
|
||||
} else if ((rssi_dbm <= (-60)) && (rssi_dbm > (-70))) {
|
||||
rssi_dbm = rssi_dbm - (60 + rssi_dbm) / 2 - (60 + rssi_dbm) % 2;
|
||||
} else if ((rssi_dbm <= (-50)) && (rssi_dbm > (-60))) {
|
||||
rssi_dbm = rssi_dbm - (50 + rssi_dbm) / 2 - (50 + rssi_dbm) % 2;
|
||||
} else if (rssi_dbm <= (-40)) {
|
||||
rssi_dbm = rssi_dbm - (40 + rssi_dbm) / 2 - (40 + rssi_dbm) % 2;
|
||||
}
|
||||
return (uint8_t)(-rssi_dbm);
|
||||
}
|
||||
|
||||
void nrf_set_power(uint8_t tx_pwr)
|
||||
{
|
||||
XC_BT_RF->ana21_reg_l = (XC_BT_RF->ana21_reg_l & (~0xfc0)) | ((tx_pwr & 0x3f) << 6);
|
||||
XC_RF_2_4G->RF_CH = (XC_RF_2_4G->RF_CH & (~0x3f0000)) | (tx_pwr << 16);
|
||||
}
|
||||
|
||||
void nrf_set_channel(uint16_t channel)
|
||||
{
|
||||
#if (XINCX_RF_RATE == RATE_2M)
|
||||
XC_RF_2_4G->RF_CH = ((XC_RF_2_4G->CFG_TOP & 0x01) ? (channel - 2) : channel);
|
||||
#else
|
||||
XC_RF_2_4G->RF_CH = ((XC_RF_2_4G->CFG_TOP & 0x01) ? (channel - 1) : channel);
|
||||
#endif
|
||||
delay_us(2);
|
||||
XC_BT_RF->ana28_reg_l &= (~0x1); // Afc pulse
|
||||
delay_us(2);
|
||||
XC_BT_RF->ana28_reg_l |= 0x1; // Afc pulse
|
||||
delay_us(2);
|
||||
}
|
||||
|
||||
//L: standby, H: tx/rx mode
|
||||
#define NRF_CE_H (XC_RF_2_4G->CFG_TOP |= 0x4000)
|
||||
#define NRF_CE_L (XC_RF_2_4G->CFG_TOP &= ~0x4000)
|
||||
|
||||
void nrf_set_mode(uint8_t mode)
|
||||
{
|
||||
NRF_CE_L; //standby
|
||||
if(mode == TX_MODE)
|
||||
{
|
||||
XC_RF_2_4G->CFG_TOP &= ~0x01;
|
||||
XC_RF_2_4G->TX_ADDR_L = rf_cfg.tx_addr; //设置发射地址
|
||||
nrf_set_channel(rf_cfg.tx_chan); //设置发射信道
|
||||
}
|
||||
else if(mode == RX_MODE)
|
||||
{
|
||||
XC_RF_2_4G->CFG_TOP |= 0x01;
|
||||
XC_RF_2_4G->RX_ADDR_P0_L = rf_cfg.rx_addr; //设置接收地址
|
||||
nrf_set_channel(rf_cfg.rx_chan); //设置接收信道
|
||||
}
|
||||
NRF_CE_H; //trx mode
|
||||
}
|
||||
|
||||
__RAM_CODE uint8_t nrf_tx_event(uint8_t *buff, uint8_t len)
|
||||
{
|
||||
uint8_t sucess = 0;
|
||||
uint8_t timeout = 200; //2ms超时
|
||||
|
||||
nrf_tx_status = 0;
|
||||
__disable_irq();
|
||||
nrf_set_mode(TX_MODE); //设置发射模式
|
||||
XC_RF_2_4G->CMD_CFG = CMD_DONE | FLUSH_TX; //清除TX_FIFO
|
||||
XC_RF_2_4G->STATUS |= MASK_ALL_INTER; //清除所有中断
|
||||
for (uint8_t i = 0; i < SEND_CMD_CNT; i++)
|
||||
XC_RF_2_4G->CMD_CFG = CMD_DONE | W_TX_PLOAD;
|
||||
for (uint8_t i = 0; i < len; i++)
|
||||
XC_RF_2_4G->TX_FIFO_DATA = buff[i];
|
||||
delay_us(100);
|
||||
//等待发送完成
|
||||
while(timeout--)
|
||||
{
|
||||
delay_us(10);
|
||||
if((XC_RF_2_4G->STATUS & MASK_TX_DS) || (nrf_tx_status & MASK_TX_DS)) //发送完成
|
||||
{
|
||||
sucess = 1; //发送成功
|
||||
break;
|
||||
}
|
||||
else if((XC_RF_2_4G->STATUS & MASK_MAX_RT) || (nrf_tx_status & MASK_MAX_RT)) //到达最大重发次数
|
||||
{
|
||||
sucess = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
__enable_irq();
|
||||
XC_RF_2_4G->CMD_CFG = CMD_DONE | FLUSH_TX; //清除TX_FIFO
|
||||
XC_RF_2_4G->CMD_CFG = CMD_DONE | FLUSH_RX; //清空RX_FIFO
|
||||
//XC_RF_2_4G->STATUS |= MASK_TX_DS | MASK_MAX_RT;
|
||||
XC_RF_2_4G->STATUS |= MASK_ALL_INTER; //清除所有中断
|
||||
nrf_set_mode(RX_MODE); //设置接收模式
|
||||
|
||||
return sucess;
|
||||
}
|
||||
|
||||
__RAM_CODE uint8_t nrf_rx_event(uint8_t *buff, uint8_t *rssi)
|
||||
{
|
||||
uint8_t length = 0;
|
||||
|
||||
if (XC_RF_2_4G->STATUS & MASK_RX_DR) //接收到有效数据
|
||||
{
|
||||
XC_RF_2_4G->CMD_CFG = CMD_DONE | R_RX_PL_WID;
|
||||
length = XC_RF_2_4G->RX_FIFO_LEN & 0xff; //读接收长度
|
||||
if(length != 0)
|
||||
{
|
||||
for (uint8_t i = 0; i < RECV_CMD_CNT; i++)
|
||||
{
|
||||
nop_cnt(16);
|
||||
XC_RF_2_4G->CMD_CFG = CMD_DONE | R_RX_PLOAD;
|
||||
nop_cnt(16);
|
||||
}
|
||||
for (uint8_t i = 0; i < length; i++)
|
||||
{
|
||||
buff[i] = XC_RF_2_4G->RX_FIFO_DATA;
|
||||
}
|
||||
*rssi = nrf_get_rssi();
|
||||
}
|
||||
XC_RF_2_4G->CMD_CFG = CMD_DONE | FLUSH_RX; //清空RX_FIFO
|
||||
XC_RF_2_4G->STATUS |= MASK_RX_DR; //清空接收中断
|
||||
}
|
||||
return length;
|
||||
}
|
||||
|
||||
extern void rf_24g_handle(void); //测试接收中断
|
||||
|
||||
uint32_t regmap[32];
|
||||
void readreg(void)
|
||||
{
|
||||
uint8_t index = 0;
|
||||
|
||||
regmap[index++] = XC_RF_2_4G->CFG_TOP;
|
||||
regmap[index++] = XC_RF_2_4G->EN_AA;
|
||||
regmap[index++] = XC_RF_2_4G->EN_RXADDR;
|
||||
regmap[index++] = XC_RF_2_4G->SETUP_AW;
|
||||
regmap[index++] = XC_RF_2_4G->SETUP_RETR;
|
||||
regmap[index++] = XC_RF_2_4G->RF_CH;
|
||||
regmap[index++] = XC_RF_2_4G->SETUP_RF;
|
||||
regmap[index++] = XC_RF_2_4G->STATUS;
|
||||
regmap[index++] = XC_RF_2_4G->OBSERVE_TX; //
|
||||
regmap[index++] = XC_RF_2_4G->RSSI;
|
||||
regmap[index++] = XC_RF_2_4G->RX_ADDR_P0_H;
|
||||
regmap[index++] = XC_RF_2_4G->RX_ADDR_P0_L;
|
||||
regmap[index++] = XC_RF_2_4G->RX_ADDR_P1_H;
|
||||
regmap[index++] = XC_RF_2_4G->RX_ADDR_P1_L;
|
||||
regmap[index++] = XC_RF_2_4G->RX_ADDR_P2TOP5;
|
||||
regmap[index++] = XC_RF_2_4G->BER_ERR_CNT;
|
||||
regmap[index++] = XC_RF_2_4G->BER_RECV_CNT;
|
||||
regmap[index++] = XC_RF_2_4G->AGC_SETTING;
|
||||
regmap[index++] = XC_RF_2_4G->TX_ADDR_H;
|
||||
regmap[index++] = XC_RF_2_4G->TX_ADDR_L;
|
||||
regmap[index++] = XC_RF_2_4G->PGA_SETTING;
|
||||
regmap[index++] = XC_RF_2_4G->RX_PW_Px_H;
|
||||
regmap[index++] = XC_RF_2_4G->RX_PW_Px_L;
|
||||
regmap[index++] = XC_RF_2_4G->STATUS_FIFO;
|
||||
regmap[index++] = XC_RF_2_4G->RSSIREC; //
|
||||
regmap[index++] = XC_RF_2_4G->TXPROC_CFG;
|
||||
regmap[index++] = XC_RF_2_4G->RXPROC_CFG_H;
|
||||
regmap[index++] = XC_RF_2_4G->RXPROC_CFG_L;
|
||||
regmap[index++] = XC_RF_2_4G->DYNPD;
|
||||
regmap[index++] = XC_RF_2_4G->FEATURE;
|
||||
}
|
||||
|
||||
//接收中断
|
||||
__RAM_CODE void RF24G_Handler(void)
|
||||
{
|
||||
// NRF_CE_L;
|
||||
if(XC_RF_2_4G->STATUS & MASK_RX_DR) //接收中断
|
||||
{
|
||||
rf_24g_handle();
|
||||
|
||||
rxfifo[rxwrite][1] = nrf_rx_event(rxfifo[rxwrite]+2, rxfifo[rxwrite]);
|
||||
if(rxfifo[rxwrite][1] == RF_BUFF_LEN)
|
||||
{
|
||||
if(((rxwrite + 1) & 7) == rxread)
|
||||
{
|
||||
rxread = (rxread + 1) & 7;
|
||||
}
|
||||
rxwrite = (rxwrite + 1) & 7;
|
||||
}
|
||||
XC_RF_2_4G->STATUS |= MASK_RX_DR;
|
||||
}
|
||||
if(XC_RF_2_4G->STATUS & (MASK_TX_DS|MASK_MAX_RT)) //发射中断
|
||||
{
|
||||
nrf_tx_status = XC_RF_2_4G->STATUS;
|
||||
XC_RF_2_4G->CMD_CFG = CMD_DONE | FLUSH_TX;
|
||||
XC_RF_2_4G->STATUS |= MASK_TX_DS|MASK_MAX_RT;
|
||||
}
|
||||
nop_cnt(4);
|
||||
|
||||
}
|
||||
|
||||
void nrf_24g_init(uint32_t addr, uint16_t chan)
|
||||
{
|
||||
rf_cfg.tx_addr = addr;
|
||||
rf_cfg.rx_addr = addr;
|
||||
rf_cfg.tx_chan = chan;
|
||||
rf_cfg.rx_chan = chan;
|
||||
|
||||
/* Rf modem init*/
|
||||
nrf_modem_init();
|
||||
/* Set up 2.4G RF modem*/
|
||||
nrf_24g_config();
|
||||
/* Set up crystal oscillator capacitor array */
|
||||
rf_freq_ctune(XINCX_RF_CRY_CPT_ARRAY);
|
||||
/* Set up dynamic load */
|
||||
nrf_set_dynpd(XINCX_RF_DYNPD);
|
||||
/* Set retransmission delay and retransmission frequency */
|
||||
nrf_set_retr(XINCX_RF_ARC, XINCX_RF_ARD);
|
||||
/* Set address width */
|
||||
nrf_set_txaddr_width(XINCX_RF_TX_ADDR_WIDTH);
|
||||
/* Set PTX address */
|
||||
nrf_set_txaddr(RF_BLE_ADDR, XINCX_RF_ADDR_H);
|
||||
/* Set PRX address */
|
||||
nrf_set_rxaddr(RF_BLE_ADDR, XINCX_RF_ADDR_H);
|
||||
/* Set transfer rate */
|
||||
nrf_set_data_rate(XINCX_RF_RATE);
|
||||
/* Set CFG_TOP */
|
||||
nrf_set_cfg_top();
|
||||
/* Set CRC */
|
||||
nrf_set_crc(XINCX_RF_CRC_ENABLE, XINCX_RF_CRC_BYTE);
|
||||
/* Set data frame format */
|
||||
nrf_set_feature(XINCX_RF_LONG_PLD, XINCX_RF_FEC, XINCX_RF_WHITEN, XINCX_RF_DPL, XINCX_RF_ACK_PAY,
|
||||
XINCX_RF_DYN_ACK);
|
||||
nrf_set_compatility_featue(XINCX_RF_GUARD_CFG, XINCX_RF_LONG_PLD_TYPE, XINCX_RF_PREAMBLE_NUM,
|
||||
XINCX_RF_PREAMBLE_TYPE, XINCX_RF_CRC_SCOPE_HEADER, XINCX_RF_CRC_SCOPE_ADDR);
|
||||
/* Set the leading code */
|
||||
nrf_set_preamble(XINCX_RF_PREAMBLE);
|
||||
/* Set guard field */
|
||||
nrf_set_guard_word(XINCX_RF_GUARD);
|
||||
/* Set Payload */
|
||||
nrf_set_rxlen(XINCX_RF_PIPE_LEN);
|
||||
/*Set ack pipe*/
|
||||
nrf_set_enaa(XINCX_RF_PIPE_ENAA);
|
||||
/* RC filtering calibration */
|
||||
nrf_rc_calib();
|
||||
|
||||
nrf_set_power(XINCX_RF_POWER); //设置功率
|
||||
nrf_set_mode(RX_MODE); //设置接收模式
|
||||
|
||||
nrf_rssi_init();
|
||||
|
||||
#if (1 == XINCX_RF_NVIC_MODE)
|
||||
NVIC_EnableIRQ(RF24G_IRQn); //开启中断
|
||||
#endif
|
||||
}
|
||||
|
||||
//蓝牙模式初始化
|
||||
void nrf_ble_init(uint32_t addr, uint16_t chan)
|
||||
{
|
||||
rf_cfg.tx_addr = addr;
|
||||
rf_cfg.rx_addr = addr;
|
||||
rf_cfg.tx_chan = chan;
|
||||
rf_cfg.rx_chan = chan;
|
||||
|
||||
/* Rf modem init*/
|
||||
nrf_modem_init();
|
||||
/* Set up 2.4G RF modem*/
|
||||
nrf_24g_config();
|
||||
nrf_set_dynpd(XINCX_RF_DYNPD);
|
||||
/* Set PTX address */
|
||||
nrf_set_txaddr(RF_BLE_ADDR, XINCX_RF_ADDR_H);
|
||||
/* Set PRX address */
|
||||
nrf_set_rxaddr(RF_BLE_ADDR, XINCX_RF_ADDR_H);
|
||||
/* Set address width */
|
||||
nrf_set_txaddr_width(XINCX_RF_TX_ADDR_WIDTH);
|
||||
/* Set transfer rate */
|
||||
nrf_set_data_rate(XINCX_RF_RATE);
|
||||
/* Set CFG_TOP */
|
||||
nrf_set_cfg_top();
|
||||
/* Set CRC */
|
||||
nrf_set_crc(XINCX_RF_CRC_ENABLE, XINCX_RF_CRC_BYTE);
|
||||
/* Set data frame format */
|
||||
nrf_set_feature(XINCX_RF_LONG_PLD, XINCX_RF_FEC, XINCX_RF_WHITEN,
|
||||
XINCX_RF_DPL, XINCX_RF_ACK_PAY, XINCX_RF_DYN_ACK);
|
||||
/* Set Payload */
|
||||
nrf_set_rxlen(XINCX_RF_PIPE_LEN);
|
||||
/*Set ack pipe*/
|
||||
nrf_set_enaa(XINCX_RF_PIPE_ENAA);
|
||||
/* RC filtering calibration */
|
||||
nrf_rc_calib();
|
||||
|
||||
//XC_RF_2_4G->TXPROC_CFG = (XC_RF_2_4G->TXPROC_CFG & (~0xFF)) | 0xEE;
|
||||
|
||||
nrf_rssi_init();
|
||||
|
||||
nrf_set_power(XINCX_RF_POWER); //设置功率
|
||||
nrf_set_mode(RX_MODE); //设置接收模式
|
||||
|
||||
#if (1 == XINCX_RF_NVIC_MODE) //开启中断
|
||||
NVIC_EnableIRQ(RF24G_IRQn);
|
||||
#endif
|
||||
}
|
||||
|
||||
/********************************* 伪蓝牙白化及CRC校验 ***************************************/
|
||||
//字节高地位反转
|
||||
static uint8_t reverseBits(uint8_t input)
|
||||
{
|
||||
uint8_t temp = 0;
|
||||
if(input & 0x80) temp |= 0x01;
|
||||
if(input & 0x40) temp |= 0x02;
|
||||
if(input & 0x20) temp |= 0x04;
|
||||
if(input & 0x10) temp |= 0x08;
|
||||
if(input & 0x08) temp |= 0x10;
|
||||
if(input & 0x04) temp |= 0x20;
|
||||
if(input & 0x02) temp |= 0x40;
|
||||
if(input & 0x01) temp |= 0x80;
|
||||
return temp;
|
||||
}
|
||||
|
||||
//白化
|
||||
static void ble_whiten(uint8_t *data, uint8_t len, uint16_t freq)
|
||||
{
|
||||
uint8_t chan = (freq == RF_BLE_CHN38) ? 38 : ((freq == RF_BLE_CHN37) ? 37 : 39);
|
||||
uint8_t coeff = reverseBits(chan) | 2;
|
||||
|
||||
for (uint8_t i = 0; i < len; i++)
|
||||
{
|
||||
for (uint8_t m = 1; m; m <<= 1)
|
||||
{
|
||||
if (coeff & 0x80)
|
||||
{
|
||||
coeff ^= 0x11;
|
||||
data[i] ^= m;
|
||||
}
|
||||
coeff <<= 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//计算CRC
|
||||
static void ble_crc(uint8_t *data, uint8_t len, uint8_t *dst)
|
||||
{
|
||||
dst[0] = dst[1] = dst[2] = 0x55;
|
||||
|
||||
uint8_t temp, tempData;
|
||||
for (uint8_t i = 0; i < len; i++)
|
||||
{
|
||||
tempData = data[i];
|
||||
for (uint8_t b = 0; b < 8; b++, tempData >>= 1)
|
||||
{
|
||||
temp = dst[0] >> 7;
|
||||
dst[0] <<= 1;
|
||||
if (dst[1] & 0x80) {
|
||||
dst[0] |= 1;
|
||||
}
|
||||
dst[1] <<= 1;
|
||||
if (dst[2] & 0x80) {
|
||||
dst[1] |= 1;
|
||||
}
|
||||
dst[2] <<= 1;
|
||||
if (temp != (tempData & 1)) {
|
||||
dst[2] ^= 0x5B;
|
||||
dst[1] ^= 0x06;
|
||||
}
|
||||
}
|
||||
}
|
||||
dst[2] = reverseBits(dst[2]);
|
||||
dst[1] = reverseBits(dst[1]);
|
||||
dst[0] = reverseBits(dst[0]);
|
||||
}
|
||||
|
||||
uint8_t ble_buff[RF_BUFF_LEN]; //BLE数据包
|
||||
|
||||
//发送数据
|
||||
//type: 0-EMN数据包，1-BLE广播包
|
||||
uint8_t nrf_ble_send(uint8_t *data, uint8_t txlen)
|
||||
{
|
||||
uint8_t length = 0;
|
||||
|
||||
if(txlen > (RF_BUFF_LEN - 5)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
ble_buff[0] = 0;
|
||||
ble_buff[1] = txlen; //data length
|
||||
for(uint8_t i = 0; i < txlen; i++)
|
||||
{
|
||||
ble_buff[2+i] = data[i];
|
||||
}
|
||||
length = ble_buff[1] + 5; //head(1) + len(1) + data(len) + crc(3)
|
||||
//添加BLE_CRC和白化
|
||||
ble_crc(ble_buff, length - 3, ble_buff + length - 3);
|
||||
ble_whiten(ble_buff, length, rf_cfg.tx_chan);
|
||||
for(int i = 0; i < length; i++)
|
||||
{
|
||||
ble_buff[i] = reverseBits(ble_buff[i]);
|
||||
}
|
||||
return nrf_tx_event(ble_buff, length); //发送数据包
|
||||
}
|
||||
|
||||
//接收数据
|
||||
uint8_t nrf_ble_recv(uint8_t *data, uint8_t *rssi)
|
||||
{
|
||||
uint8_t length = 0;
|
||||
uint32_t blecrc = 0;
|
||||
|
||||
#if (1 == XINCX_RF_NVIC_MODE) //开启中断
|
||||
if(rxread != rxwrite)
|
||||
{
|
||||
*rssi = rxfifo[rxread][0]; //RSSI
|
||||
length = rxfifo[rxread][1];//数据包长度
|
||||
for(uint8_t i = 0; i < length; i++)
|
||||
{
|
||||
ble_buff[i] = rxfifo[rxread][2+i];
|
||||
}
|
||||
rxread = (rxread + 1) & 7;
|
||||
}
|
||||
#else
|
||||
length = nrf_rx_event(ble_buff, rssi);
|
||||
#endif
|
||||
|
||||
if(length != 0)
|
||||
{
|
||||
//反白化
|
||||
for(int i = 0; i < length; i++)
|
||||
{
|
||||
ble_buff[i] = reverseBits(ble_buff[i]);
|
||||
}
|
||||
ble_whiten(ble_buff, length, rf_cfg.rx_chan);
|
||||
//计算有效数据长度
|
||||
length = ble_buff[1] + 5; //head(1) + len(1) + data(len) + crc(3)
|
||||
//CRC校验
|
||||
blecrc = (ble_buff[length-1]<<16) + (ble_buff[length-2]<<8) + ble_buff[length-3];
|
||||
ble_crc(ble_buff, length-3, ble_buff+length-3);
|
||||
if(blecrc != ((ble_buff[length-1] << 16) + (ble_buff[length-2]<<8) + ble_buff[length-3]))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
length = ble_buff[1]; //数据长度
|
||||
for(uint8_t i = 0; i < length; i++)
|
||||
{
|
||||
data[i] = ble_buff[2+i];
|
||||
}
|
||||
}
|
||||
|
||||
return length;
|
||||
}
|
||||
@@ -0,0 +1,276 @@
|
||||
#ifndef __RF_2_4G_H__
|
||||
#define __RF_2_4G_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#include "xc6xxx.h"
|
||||
|
||||
// <<< Use Configuration Wizard in Context Menu >>>\n
|
||||
|
||||
// <h> XINCX_RF_ADDR - 设置地址/同步字
|
||||
//==========================================================
|
||||
// <o> XINCX_RF_ADDR_L - 地址/同步字高4字节
|
||||
#ifndef XINCX_RF_ADDR_L
|
||||
#define XINCX_RF_ADDR_L 0x1AB51376 //EMN地址
|
||||
#endif
|
||||
|
||||
// <o> XINCX_RF_ADDR_H - 地址/同步字低1字节
|
||||
#ifndef XINCX_RF_ADDR_H
|
||||
#define XINCX_RF_ADDR_H 0x00
|
||||
#endif
|
||||
|
||||
// <o> XINCX_RF_TX_ADDR_WIDTH - 地址/同步字宽度
|
||||
// <3=> 3 Bytes
|
||||
// <4=> 4 Bytes
|
||||
// <5=> 5 Bytes
|
||||
#ifndef XINCX_RF_TX_ADDR_WIDTH
|
||||
#define XINCX_RF_TX_ADDR_WIDTH 4
|
||||
#endif
|
||||
//==========================================================
|
||||
// </h>
|
||||
|
||||
// <o> XINCX_RF_CHANNEL - 设置频率/信道
|
||||
// <2402=> ADV_CHANNEL_37
|
||||
// <2426=> ADV_CHANNEL_38
|
||||
// <2480=> ADV_CHANNEL_39
|
||||
#ifndef XINCX_RF_CHANNEL
|
||||
#define XINCX_RF_CHANNEL 2402 //EMN工作在37信道
|
||||
#endif
|
||||
|
||||
// <o> XINCX_RF_POWER - 设置发射功率
|
||||
//4 - 17对应-4dBm - 8dBm
|
||||
#ifndef XINCX_RF_POWER
|
||||
#define XINCX_RF_POWER 8 //3.6dBm
|
||||
#endif
|
||||
|
||||
// <o> XINCX_RF_RATE - 设置传输速率
|
||||
// <0x02=> 1M
|
||||
// <0x0A=> 2M
|
||||
// <0x22=> 250k
|
||||
// <0x2A=> 125k
|
||||
#ifndef XINCX_RF_RATE
|
||||
#define XINCX_RF_RATE 0x02
|
||||
#endif
|
||||
|
||||
// <q> XINCX_RF_WHITEN - 使能2.4g白化
|
||||
#ifndef XINCX_RF_WHITEN
|
||||
#define XINCX_RF_WHITEN 0 //0-禁止2.4g白化, BLE使用软件白化, 1-使能2.4G白化
|
||||
#endif
|
||||
|
||||
// <q> XINCX_RF_FEC - 使能前向纠错
|
||||
#ifndef XINCX_RF_FEC
|
||||
#define XINCX_RF_FEC 0 //0-蓝牙广播不使能, 1-2.4G使能
|
||||
#endif
|
||||
|
||||
// <q> XINCX_RF_LONG_PLD - 动态长包类型
|
||||
#ifndef XINCX_RF_LONG_PLD_TYPE
|
||||
#define XINCX_RF_LONG_PLD_TYPE 1 //0-最大支持128byte, 1-最大64字节
|
||||
#endif
|
||||
|
||||
// <q> XINCX_RF_LONG_PLD - 使能动态长包
|
||||
#ifndef XINCX_RF_LONG_PLD
|
||||
#define XINCX_RF_LONG_PLD 1
|
||||
#endif
|
||||
|
||||
// <e> XINCX_RF_DPL - 使能动态负载长度
|
||||
#ifndef XINCX_RF_DPL
|
||||
#define XINCX_RF_DPL 0 //不带ACK模式，不使用动态负载长度
|
||||
#endif
|
||||
// <o> XINCX_RF_DYNPD - 使能各个PIPE动态负载长度
|
||||
#ifndef XINCX_RF_DYNPD
|
||||
#define XINCX_RF_DYNPD 0x00//0x3f
|
||||
#endif
|
||||
// </e>
|
||||
|
||||
// <e> XINCX_RF_CRC_ENABLE - 使能硬件CRC
|
||||
#ifndef XINCX_RF_CRC_ENABLE
|
||||
#define XINCX_RF_CRC_ENABLE 0 //BLE模式不使能硬件CRC，使用软件CRC
|
||||
#endif
|
||||
|
||||
// <o> XINCX_RF_CRC_BYTE - CRC字节长度
|
||||
// <1=> 1 Byte
|
||||
// <2=> 2 Bytes
|
||||
#ifndef XINCX_RF_CRC_BYTE
|
||||
#define XINCX_RF_CRC_BYTE 2
|
||||
#endif
|
||||
|
||||
// <q> XINCX_RF_CRC_SCOPE_HEADER - 2.4g CRC Scope Header
|
||||
#ifndef XINCX_RF_CRC_SCOPE_HEADER
|
||||
#define XINCX_RF_CRC_SCOPE_HEADER 1
|
||||
#endif
|
||||
|
||||
// <q> XINCX_RF_CRC_SCOPE_ADDR - 2.4g CRC Scope Addr
|
||||
#ifndef XINCX_RF_CRC_SCOPE_ADDR
|
||||
#define XINCX_RF_CRC_SCOPE_ADDR 1
|
||||
#endif
|
||||
// </e>
|
||||
|
||||
// <e> XINCX_RF_Auto ACK - 使能ACK负载
|
||||
#ifndef XINCX_RF_ACK_PAY
|
||||
#define XINCX_RF_ACK_PAY 0
|
||||
#endif
|
||||
|
||||
// <q> XINCX_RF_DYN_ACK - 使能命令W_TX_PAYLOAD_NOACK
|
||||
#ifndef XINCX_RF_DYN_ACK
|
||||
#define XINCX_RF_DYN_ACK 1 //使能不带ACK的TX包
|
||||
#endif
|
||||
|
||||
// <o> XINCX_RF_ARC - 设置自动重发次数
|
||||
#ifndef XINCX_RF_ARC
|
||||
#define XINCX_RF_ARC 0
|
||||
#endif
|
||||
|
||||
// <o> XINCX_RF_ARD - 设置自动重发延时
|
||||
#ifndef XINCX_RF_ARD
|
||||
#define XINCX_RF_ARD 0
|
||||
#endif
|
||||
// </e>
|
||||
|
||||
// <h> XINCX_RF_PIPE - 设置数据PIPE
|
||||
//==========================================================
|
||||
// <o> XINCX_RF_PIPE_LEN - 数据PIPE长度
|
||||
#ifndef XINCX_RF_PIPE_LEN
|
||||
#define XINCX_RF_PIPE_LEN 32
|
||||
#endif
|
||||
|
||||
// <q> XINCX_RF_PIPE_ENAA - 使能PIPE自动ACK
|
||||
#ifndef XINCX_RF_PIPE_ENAA
|
||||
#define XINCX_RF_PIPE_ENAA 0
|
||||
#endif
|
||||
//==========================================================
|
||||
// </h>
|
||||
|
||||
// <h> XINCX_RF_PREAMBLE - 设置前导码
|
||||
//==========================================================
|
||||
// <o> XINCX_RF_PREAMBLE - 设置前导码内容
|
||||
#ifndef XINCX_RF_PREAMBLE
|
||||
#define XINCX_RF_PREAMBLE 0x710f5555 //BLE前导码为10101010或01010101
|
||||
#endif
|
||||
|
||||
// <o> XINCX_RF_PREAMBLE_NUM - 设置前导码长度
|
||||
// <0=> 1 Byte
|
||||
// <1=> 2 Bytes
|
||||
// <2=> 3 Bytes
|
||||
// <3=> 4 Bytes
|
||||
#ifndef XINCX_RF_PREAMBLE_NUM
|
||||
#define XINCX_RF_PREAMBLE_NUM 0
|
||||
#endif
|
||||
|
||||
// <o> XINCX_RF_PREAMBLE_TYPE - 设置前导码类型
|
||||
#ifndef XINCX_RF_PREAMBLE_TYPE
|
||||
#define XINCX_RF_PREAMBLE_TYPE 0
|
||||
#endif
|
||||
//==========================================================
|
||||
// </h>
|
||||
|
||||
// <h> XINCX_RF_GUARD - 设置保护字
|
||||
//==========================================================
|
||||
// <o> XINCX_RF_GUARD - 保护字内容
|
||||
#ifndef XINCX_RF_GUARD
|
||||
#define XINCX_RF_GUARD 0x8fc9
|
||||
#endif
|
||||
|
||||
// <q> XINCX_RF_GUARD_CFG - 保护字配置
|
||||
#ifndef XINCX_RF_GUARD_CFG
|
||||
#define XINCX_RF_GUARD_CFG 0
|
||||
#endif
|
||||
//==========================================================
|
||||
// </h>
|
||||
|
||||
// <h> XINCX_RF_CRY_CPT_ARRAY - 设置晶振电容
|
||||
//==========================================================
|
||||
// <o> XINCX_RF_CRY_CPT_ARRAY - 设置晶振电容
|
||||
#ifndef XINCX_RF_CRY_CPT_ARRAY
|
||||
#define XINCX_RF_CRY_CPT_ARRAY 0x36
|
||||
#endif
|
||||
//==========================================================
|
||||
// </h>
|
||||
|
||||
// <q> XINCX_RF_NVIC_MODE - 使能中断
|
||||
#ifndef XINCX_RF_NVIC_MODE
|
||||
#define XINCX_RF_NVIC_MODE 1
|
||||
#endif
|
||||
|
||||
// <<< end of configuration section >>>
|
||||
|
||||
|
||||
/**************************** RF Command Code *******************************/
|
||||
#define R_REG 0x00 //寄存器读操作
|
||||
#define W_REG 0x20 //寄存器写操作
|
||||
#define R_RX_PL_WID 0x60 //从FIFO读取收到的数据长度
|
||||
#define R_RX_PLOAD 0x61 //从FIFO读取收到的数据
|
||||
#define W_TX_PLOAD 0xA0 //向FIFO写入发送的数据
|
||||
#define W_TX_PLOAD_NOACK 0xB0 //向FIFO写入发送的数据，不带ACK
|
||||
#define W_ACK_PLOAD 0xA8 //向FIFO写入发送ACK数据
|
||||
#define FLUSH_TX 0xE1 //清空TX FIFO
|
||||
#define FLUSH_RX 0xE2 //清空RX FIFO
|
||||
#define REUSE_TX_PL 0xE3
|
||||
|
||||
#define CMD_NOP 0xFF //空操作
|
||||
#define CMD_DONE 0x100
|
||||
|
||||
/* 状态寄存器 */
|
||||
#define STAT_TX_REUSE (1 << 6)
|
||||
#define STAT_TX_FULL (1 << 5) //TX_FIFO满标志
|
||||
#define STAT_TX_EMPTY (1 << 4) //TX_FIFO空标志
|
||||
#define STAT_RX_FULL (1 << 1) //RX_FIFO满标志
|
||||
#define STAT_RX_EMPTY (1 << 0) //RX_FIFO满标志
|
||||
|
||||
/* 中断状态位 */
|
||||
#define MASK_RX_DR (1 << 6) //RX_FIFO有效标志位，写1清除
|
||||
#define MASK_TX_DS (1 << 5) //发射完成中断，写1清除
|
||||
#define MASK_MAX_RT (1 << 4) //达到最大重发次数，写1清除
|
||||
#define MASK_ALL_INTER (MASK_RX_DR | MASK_TX_DS| MASK_MAX_RT)
|
||||
|
||||
/* CRC校验位 */
|
||||
#define CRC_1BIT 1
|
||||
#define CRC_2BIT 2
|
||||
|
||||
/* 工作模式 */
|
||||
#define TX_MODE 0
|
||||
#define RX_MODE 1
|
||||
|
||||
/* 速率设置 */
|
||||
#define RATE_1M 0x02
|
||||
#define RATE_2M 0x0A
|
||||
#define RATE_250K 0x22
|
||||
#define RATE_125K 0x2A
|
||||
|
||||
#define SEND_CMD_CNT 6
|
||||
#define RECV_CMD_CNT 4
|
||||
|
||||
#define RF_BUFF_LEN XINCX_RF_PIPE_LEN
|
||||
|
||||
#define RF_BLE_ADDR 0x1AB51376
|
||||
|
||||
#define RF_BLE_CHN37 2402
|
||||
#define RF_BLE_CHN38 2426
|
||||
#define RF_BLE_CHN39 2480
|
||||
|
||||
|
||||
//BLE广播Head
|
||||
#define BLE_ADV_IND 0x00 //通用广播指示
|
||||
#define BLE_ADV_DIRECT_IND 0x01 //定向连接指示
|
||||
#define BLE_ADV_NONCONN_IND 0x02 //不可连接指示
|
||||
#define BLE_SCAN_REQ 0x03 //主动扫描请求
|
||||
#define BLE_SCAN_RSP 0x04 //主动扫描响应
|
||||
#define BLE_CONNECT_REQ 0x05 //连接请求
|
||||
#define BLE_ADV_SCAN_IND 0x06 //可扫描指示
|
||||
|
||||
#define LOGI(...) printf(__VA_ARGS__)
|
||||
|
||||
extern void nrf_24g_init(uint32_t addr, uint16_t chan);
|
||||
extern void nrf_ble_init(uint32_t addr, uint16_t chan);
|
||||
extern void nrf_set_power(uint8_t tx_pwr);
|
||||
extern void nrf_set_channel(uint16_t channel);
|
||||
extern uint8_t nrf_ble_send(uint8_t *data, uint8_t txlen);
|
||||
extern uint8_t nrf_ble_recv(uint8_t *data, uint8_t *rssi);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __RF_2_4G__ */
|
||||
@@ -0,0 +1,190 @@
|
||||
/*
|
||||
* @Descripttion:
|
||||
* @version:
|
||||
* @Author: sueRimn
|
||||
* @Date: 2024-03-21 10:47:04
|
||||
* @LastEditors: sueRimn
|
||||
* @LastEditTime: 2024-03-21 13:50:06
|
||||
*/
|
||||
#ifndef __XC_RF_24G_REGISTER_H__
|
||||
#define __XC_RF_24G_REGISTER_H__
|
||||
#include "xc60xx.h"
|
||||
#include <stdint.h>
|
||||
|
||||
/* ===========================================================================================================================
|
||||
*/
|
||||
/* ================ BT RF ================ */
|
||||
/* ===========================================================================================================================
|
||||
*/
|
||||
/* BT RF Register Typedef */
|
||||
typedef struct
|
||||
{
|
||||
__IOM uint16_t ana0_reg_l; /* RF analog0 Reg (0x000) */
|
||||
__IOM uint16_t ana0_reg_h;
|
||||
__IOM uint16_t ana1_reg_l; /* RF analog1 Reg (0x004) */
|
||||
__IOM uint16_t ana1_reg_h;
|
||||
__IOM uint16_t ana2_reg_l; /* RF analog2 Reg (0x008) */
|
||||
__IOM uint16_t ana2_reg_h;
|
||||
__IOM uint16_t ana3_reg_l; /* RF analog3 Reg (0x00C) */
|
||||
__IOM uint16_t ana3_reg_h;
|
||||
__IOM uint16_t ana4_reg_l; /* RF analog4 Reg (0x010) */
|
||||
__IOM uint16_t ana4_reg_h;
|
||||
__IOM uint16_t ana5_reg_l; /* RF analog5 Reg (0x014) */
|
||||
__IOM uint16_t ana5_reg_h;
|
||||
__IOM uint16_t ana6_reg_l; /* RF analog6 Reg (0x018) */
|
||||
__IOM uint16_t ana6_reg_h;
|
||||
__IOM uint16_t ana7_reg_l; /* RF analog7 Reg (0x01C) */
|
||||
__IOM uint16_t ana7_reg_h;
|
||||
__IOM uint16_t ana8_reg_l; /* RF analog8 Reg (0x020) */
|
||||
__IOM uint16_t ana8_reg_h;
|
||||
__IOM uint16_t ana9_reg_l; /* RF analog9 Reg (0x024) */
|
||||
__IOM uint16_t ana9_reg_h;
|
||||
__IOM uint16_t ana10_reg_l; /* RF analog10 Reg (0x028) */
|
||||
__IOM uint16_t ana10_reg_h;
|
||||
__IOM uint16_t ana11_reg_l; /* RF analog11 Reg (0x02C) */
|
||||
__IOM uint16_t ana11_reg_h;
|
||||
__IOM uint16_t ana12_reg_l; /* RF analog12 Reg (0x030) */
|
||||
__IOM uint16_t ana12_reg_h;
|
||||
__IOM uint16_t ana13_reg_l; /* RF analog13 Reg (0x034) */
|
||||
__IOM uint16_t ana13_reg_h;
|
||||
__IOM uint16_t ana14_reg_l; /* RF analog14 Reg (0x038) */
|
||||
__IOM uint16_t ana14_reg_h;
|
||||
__IOM uint16_t ana15_reg_l; /* RF analog15 Reg (0x03C) */
|
||||
__IOM uint16_t ana15_reg_h;
|
||||
__IOM uint16_t ana16_reg_l; /* RF analog16 Reg (0x040) */
|
||||
__IOM uint16_t ana16_reg_h;
|
||||
__IOM uint16_t ana17_reg_l; /* RF analog17 Reg (0x044) */
|
||||
__IOM uint16_t ana17_reg_h;
|
||||
__IOM uint16_t ana18_reg_l; /* RF analog18 Reg (0x048) */
|
||||
__IOM uint16_t ana18_reg_h;
|
||||
__IOM uint16_t ana19_reg_l; /* RF analog19 Reg (0x04C) */
|
||||
__IOM uint16_t ana19_reg_h;
|
||||
__IOM uint16_t ana20_reg_l; /* RF analog20 Reg (0x050) */
|
||||
__IOM uint16_t ana20_reg_h;
|
||||
__IOM uint16_t ana21_reg_l; /* RF analog21 Reg (0x054) */
|
||||
__IOM uint16_t ana21_reg_h;
|
||||
__IOM uint32_t reserved1[1]; /* Reserved (0x058) - (0x05c) */
|
||||
__IOM uint16_t ana23_reg_l;
|
||||
__IOM uint16_t ana23_reg_h;
|
||||
__IOM uint16_t ana24_reg_l; /* RF analog24 Reg (0x060) */
|
||||
__IOM uint16_t ana24_reg_h;
|
||||
__IOM uint16_t ana25_reg_l; /* RF analog25 Reg (0x064) */
|
||||
__IOM uint16_t ana25_reg_h;
|
||||
__IOM uint16_t ana26_reg_l; /* RF analog26 Reg (0x068) */
|
||||
__IOM uint16_t ana26_reg_h;
|
||||
__IOM uint16_t ana27_reg_l; /* RF analog27 Reg (0x06C) */
|
||||
__IOM uint16_t ana27_reg_h;
|
||||
__IOM uint16_t ana28_reg_l; /* RF analog28 Reg (0x070) */
|
||||
__IOM uint16_t ana28_reg_h;
|
||||
__IOM uint16_t ana29_reg_l; /* RF analog29 Reg (0x074) */
|
||||
__IOM uint16_t ana29_reg_h;
|
||||
__IOM uint16_t ana30_reg_l; /* RF analog30 Reg (0x078) */
|
||||
__IOM uint16_t ana30_reg_h;
|
||||
__IOM uint16_t ana31_reg_l; /* RF analog31 Reg (0x07C) */
|
||||
__IOM uint16_t ana31_reg_h;
|
||||
__IOM uint16_t rccal_reg_l; /* RF rccal Reg (0x080) */
|
||||
__IOM uint16_t rccal_reg_h;
|
||||
__IOM uint16_t rccal_rslt_l; /* RF rccal result Reg (0x084) */
|
||||
__IOM uint16_t rccal_rslt_h;
|
||||
struct
|
||||
{
|
||||
__IOM uint16_t rx_lna_map0_l; /* BT rx lna map0 Reg (0x088) */
|
||||
__IOM uint16_t rx_lna_map0_h;
|
||||
__IOM uint16_t rx_lna_map1_l; /* BT rx lna map1 Reg (0x08C) */
|
||||
__IOM uint16_t rx_lna_map1_h;
|
||||
__IOM uint16_t rx_vga_map0_l; /* BT rx vga map0 Reg (0x090) */
|
||||
__IOM uint16_t rx_vga_map0_h;
|
||||
__IOM uint16_t rx_vga_map1_l; /* BT rx vga map1 Reg (0x094) */
|
||||
__IOM uint16_t rx_vga_map1_h;
|
||||
__IOM uint16_t rx_vga_map2_l; /* BT rx vga map2 Reg (0x098) */
|
||||
__IOM uint16_t rx_vga_map2_h;
|
||||
__IOM uint16_t rx_vga_map3_l; /* BT rx vga map3 Reg (0x09C) */
|
||||
__IOM uint16_t rx_vga_map3_h;
|
||||
__IOM uint16_t rx_vga_map4_l; /* BT rx vga map4 Reg (0x0A0) */
|
||||
__IOM uint16_t rx_vga_map4_h;
|
||||
__IOM uint16_t rx_vga_map5_l; /* BT rx vga map5 Reg (0x0A4) */
|
||||
__IOM uint16_t rx_vga_map5_h;
|
||||
__IOM uint16_t rx_vga_map6_l; /* BT rx vga map6 Reg (0x0A8) */
|
||||
__IOM uint16_t rx_vga_map6_h;
|
||||
__IOM uint16_t rx_vga_map7_l; /* BT rx vga map7 Reg (0x0AC) */
|
||||
__IOM uint16_t rx_vga_map7_h;
|
||||
__IOM uint16_t rx_pm_reg_l; /* BT rx pm Reg (0x0B0) */
|
||||
__IOM uint16_t rx_pm_reg_h;
|
||||
__IOM uint16_t rx_chan_reg_l; /* BT rx chan Reg (0x0B4) */
|
||||
__IOM uint16_t rx_chan_reg_h;
|
||||
__IOM uint16_t rx_ctrl_sel_l; /* BT rx control select Reg (0x0B8) */
|
||||
__IOM uint16_t rx_ctrl_sel_h;
|
||||
__IOM uint16_t rf_ctrl1_l;
|
||||
__IOM uint16_t rf_ctrl1_h;
|
||||
} BT;
|
||||
} BT_RF_TypeDef;
|
||||
|
||||
/* ===========================================================================================================================
|
||||
*/
|
||||
/* ================ 2.4G ================ */
|
||||
/* ===========================================================================================================================
|
||||
*/
|
||||
/* RF 2.4G Module Register Typedef */
|
||||
typedef struct
|
||||
{
|
||||
__IOM uint32_t CFG_TOP; /*!< Top-level configuration (0x000) */
|
||||
__IOM uint32_t EN_AA; /*!< Auto-acknowledgement settings (0x004) */
|
||||
__IOM uint32_t EN_RXADDR; /*!< Enable RX addresses (0x008) */
|
||||
__IOM uint32_t SETUP_AW; /*!< Address width & timing stup (0x00C) */
|
||||
__IOM uint32_t SETUP_RETR; /*!< Automatic retransmission setup (0x010) */
|
||||
__IOM uint32_t RF_CH; /*!< RF channel (0x014) */
|
||||
__IOM uint32_t SETUP_RF; /*!< RF settings (0x018) */
|
||||
__IOM uint32_t STATUS; /*!< Status, SDO output may be adjusted (0x01C) */
|
||||
__IOM uint32_t OBSERVE_TX; /*!< Transmission observation (0x020) */
|
||||
__IOM uint32_t RSSI; /*!< TSSI and RSSI indicator/control (0x024) */
|
||||
__IOM uint32_t RX_ADDR_P0_L; /*!< RX address low 32bit for data pipe 0 (0x028) */
|
||||
__IOM uint32_t RX_ADDR_P0_H; /*!< RX address high 8bit for data pipe 0 (0x02C) */
|
||||
__IOM uint32_t RX_ADDR_P1_L; /*!< RX address low 32bit for data pipe 1 (0x030) */
|
||||
__IOM uint32_t RX_ADDR_P1_H; /*!< RX address high 8bit for data pipe 1 (0x034) */
|
||||
__IOM uint32_t RX_ADDR_P2TOP5; /*!< Only LSB are set, MSB use RX_ADDR_P1 (0x038) */
|
||||
__IOM uint32_t BER_RECV_CNT; /*!< Receive total Bit Counter for BER Test (0x03C) */
|
||||
__IOM uint32_t BER_ERR_CNT; /*!< Receive error Bit Counter for BER Test (0x040) */
|
||||
__IOM uint32_t AGC_SETTING; /*!< AGC setting (0x044) */
|
||||
__IOM uint32_t PGA_SETTING; /*!< PGA setting (0x048) */
|
||||
__IOM uint32_t TX_ADDR_L; /*!< TX address low 32bit (0x04C) */
|
||||
__IOM uint32_t TX_ADDR_H; /*!< TX address high 8bit (0x050) */
|
||||
__IOM uint32_t RX_PW_Px_L; /*!< Number of bytes in data pipe0~3 (0x054) */
|
||||
__IOM uint32_t RX_PW_Px_H; /*!< Number of bytes in data pipe4~5 (0x058) */
|
||||
__IOM uint32_t ANALOG_CFG0_L; /*!< Analog register 0 low 32bit (0x05C) */
|
||||
__IOM uint32_t ANALOG_CFG0_H; /*!< Analog register 0 high 32bit (0x060) */
|
||||
__IOM uint32_t ANALOG_CFG1_L; /*!< Analog register 1 low 32bit (0x064) */
|
||||
__IOM uint32_t ANALOG_CFG1_H; /*!< Analog register 1 high 32bit (0x068) */
|
||||
__IOM uint32_t ANALOG_CFG2_L; /*!< Analog register 2 low 32bit (0x06C) */
|
||||
__IOM uint32_t ANALOG_CFG2_H; /*!< Analog register 2 high 32bit (0x070) */
|
||||
__IOM uint32_t ANALOG_CFG3_L; /*!< Analog register 3 low 32bit (0x074) */
|
||||
__IOM uint32_t ANALOG_CFG3_H; /*!< Analog register 3 high 32bit (0x078) */
|
||||
__IM uint32_t Reserved1; /*!< Reserved1 (0x07C) */
|
||||
__IOM uint32_t STATUS_FIFO; /*!< FIFO status (0x080) */
|
||||
__IOM uint32_t RSSIREC; /*!< RSSI recorder feature (0x084) */
|
||||
__IOM uint32_t TXPROC_CFG; /*!< TX Process configuration (0x088) */
|
||||
__IOM uint32_t RXPROC_CFG_L; /*!< RX Process configuration (0x08C) */
|
||||
__IM uint32_t Reserved2; /*!< Reserved2 (0x090) */
|
||||
__IOM uint32_t DYNPD; /*!< Dynamic payload length (0x094) */
|
||||
__IOM uint32_t FEATURE; /*!< Features (0x098) */
|
||||
__IM uint32_t Reserved3[3]; /*!< Reserved3 (0x09C - 0x0A4) */
|
||||
__IOM uint32_t RXPROC_CFG_H; /*!< PA Ramp Configuration (0x0A8) */
|
||||
__IOM uint32_t Reserved4; /*!< Reserved4 (0x0AC) */
|
||||
__IOM uint32_t PREAMBLE; /*!< PREAMBLE (0x0B0) */
|
||||
__IOM uint32_t GUARD; /*!< PA Ramp Configuration (0x0B4) */
|
||||
__IM uint32_t Reserved5[2]; /*!< Reserved4 (0x0B8 - 0x0BC) */
|
||||
__IOM uint32_t CMD_CFG; /*!< Command Configuration (0x0C0) */
|
||||
__IOM uint32_t TX_FIFO_DATA; /*!< Tx Fifo Data (0x0C4) */
|
||||
__IOM uint32_t RX_FIFO_DATA; /*!< Rx Fifo Data (0x0C8) */
|
||||
__IOM uint32_t RX_FIFO_LEN; /*!< Tx Fifo Data Len (0x0CC) */
|
||||
} RF_2_4G_TypeDef;
|
||||
|
||||
#define XC_BT_RF_BASE 0x53021000UL
|
||||
#define XC_RF_2_4G_BASE 0x53023000UL
|
||||
|
||||
#define XC_BT_RF ((BT_RF_TypeDef *)XC_BT_RF_BASE)
|
||||
#define XC_RF_2_4G ((RF_2_4G_TypeDef *)XC_RF_2_4G_BASE)
|
||||
|
||||
#define BLE_COMMON_BASE 0x53022000UL
|
||||
#define BLE_COMN_RF24G_CTRL ((volatile uint32_t *)(BLE_COMMON_BASE + 0x40))
|
||||
|
||||
#endif //__XC_RF_24G_REGISTER_H__
|
||||
@@ -0,0 +1,285 @@
|
||||
#include "xc6xxx.h"
|
||||
#include "xc_hal.h"
|
||||
#include "uart.h"
|
||||
|
||||
uint8_t chipuid[12];
|
||||
uint8_t deviceaddr[4];
|
||||
|
||||
volatile uint32_t tick_count = 0;
|
||||
|
||||
extern void app_tick_handler(void);
|
||||
|
||||
//系统时钟初始化
|
||||
void hal_clock_init(void)
|
||||
{
|
||||
CLOCK_InitCfg_t clock_cfg;
|
||||
|
||||
clock_cfg.hfclk_src = CLOCK_HFCLK_SRC_XTAL;
|
||||
clock_cfg.hfclk_in = CLOCK_HFCLK_IN_32M;
|
||||
clock_cfg.lfclk_src = CLOCK_LFCLK_SRC_RC;
|
||||
if (clock_cfg.lfclk_src == CLOCK_LFCLK_SRC_XTAL) {
|
||||
clock_cfg.lfclk_in = CLOCK_LFCLK_IN_32768;
|
||||
} else if (clock_cfg.lfclk_src == CLOCK_LFCLK_SRC_RC) {
|
||||
clock_cfg.lfclk_in = CLOCK_LFCLK_IN_32K;
|
||||
}
|
||||
xc_clock_init_cfg(&clock_cfg);
|
||||
}
|
||||
|
||||
//看门狗初始化
|
||||
static void hal_wdt_init(void)
|
||||
{
|
||||
#if defined(ENABLE_WDT)
|
||||
WDT_InitCfg_t wdt_cfg ;
|
||||
|
||||
//wdt_cfg.WorkMode = WDT_WORK_MODE0; //模式0：超时复位
|
||||
wdt_cfg.WorkMode = WDT_WORK_MODE1; //模式1：超时中断喂狗，两次未中断复位
|
||||
wdt_cfg.ReloadValue = WDT_ReloadValue_0xFFFF; //约2秒
|
||||
wdt_cfg.PclkSel = WDT_WORK_32K;
|
||||
|
||||
xc_wdt_init(&wdt_cfg);
|
||||
xc_wdt_start(); //启动看门狗
|
||||
|
||||
NVIC_EnableIRQ(WDT_IRQn); //使能看门狗中断
|
||||
#endif
|
||||
}
|
||||
|
||||
//定时器初始化
|
||||
static void hal_timer_init(void)
|
||||
{
|
||||
Timer_InitCfg_t timer_cfg;
|
||||
|
||||
timer_cfg.timer_src_clk = TIMER_CLK_SRC_32M_DIV; //定时器时钟源
|
||||
timer_cfg.timer_div_clk = TIMER_DIV_CLK_16MHzOr16K; //分频系数
|
||||
timer_cfg.timer_mode = TIMER_MODE_CYCLE; //运行模式
|
||||
|
||||
xc_timer_init(TIMER0_IDX, &timer_cfg);
|
||||
xc_timer_set_value(TIMER0_IDX, 1000); //设置定时时间
|
||||
xc_timer_start(TIMER0_IDX); //启动定时器
|
||||
}
|
||||
|
||||
//定时器中断
|
||||
void timer0_callback(void *context)
|
||||
{
|
||||
tick_count++;
|
||||
uart_tick();
|
||||
app_tick_handler();
|
||||
}
|
||||
|
||||
//串口初始化
|
||||
static void hal_uart_init(void)
|
||||
{
|
||||
GPIO_InitCfg_t gpio_cfg = {0};
|
||||
|
||||
//UART0_TXD引脚
|
||||
gpio_cfg.Pin = GPIO_18;
|
||||
gpio_cfg.Dir = GPIO_DIR_OUTPUT;
|
||||
gpio_cfg.Pull = GPIO_PULLUP;
|
||||
gpio_cfg.Mux = GPIO_Mux0;
|
||||
gpio_cfg.FunSel = UART0_TX;
|
||||
gpio_cfg.Int = NOT_INT;
|
||||
xc_gpio_init(&gpio_cfg);
|
||||
|
||||
//UART0_RXD引脚
|
||||
gpio_cfg.Pin = GPIO_19;
|
||||
gpio_cfg.Dir = GPIO_DIR_INPUT;
|
||||
gpio_cfg.FunSel = UART0_RX;
|
||||
xc_gpio_init(&gpio_cfg);
|
||||
|
||||
UART_InitCfg_t uart_cfg = {0};
|
||||
|
||||
uart_cfg.BaudRate = UART_BAUDRATE_115200;
|
||||
uart_cfg.Parity = UART_PARITY_DISABLE;
|
||||
uart_cfg.StopBits = UART_STOP_1_BITS;
|
||||
uart_cfg.WordLength = UART_DATA_8_BITS;
|
||||
uart_cfg.HardwareFlowControl = UART_HWFC_DISABLE;
|
||||
xc_uart_init(UART0_IDX, &uart_cfg);
|
||||
xc_uart_enable_rx_it(UART0_IDX);
|
||||
|
||||
NVIC_EnableIRQ(UART0_IRQn);
|
||||
}
|
||||
|
||||
//串口接收中断
|
||||
void uart_receive_cb(uint8_t reg_idx, uint8_t val)
|
||||
{
|
||||
if(reg_idx == UART0_IDX)
|
||||
{
|
||||
uart_rxbyte(val);
|
||||
}
|
||||
}
|
||||
|
||||
//PWM初始化
|
||||
static void hal_pwm_init(void)
|
||||
{
|
||||
PWM_InitCfg_t pwm_cfg;
|
||||
|
||||
pwm_cfg.DutyCycleAcc = 8000; //调整占空比精度
|
||||
pwm_cfg.DutyCycle = 4000; //调整占空比
|
||||
pwm_cfg.Period = 0; //调整时钟周期参数：0-255
|
||||
pwm_cfg.OutputPin = GPIO_2; //输出引脚
|
||||
pwm_cfg.OutputInvertPin = GPIO_3; //互补输出引脚
|
||||
pwm_cfg.InvertEnable = false; //互补输出使能
|
||||
pwm_cfg.InvertDelay = 0x17; //互补死区时间
|
||||
pwm_cfg.Mode = PWM_EN_MODE_EDGE_ALIGNED;
|
||||
pwm_cfg.SrcClk = PWM_CLK_SRC_32M_DIV; //时钟源
|
||||
pwm_cfg.SrcEnable = PWM_EN_SEL_ALL; //使能源选择
|
||||
xc_pwm_init(PWM0_IDX, &pwm_cfg);
|
||||
//xc_pwm_start(PWM0_IDX); //使能指定PWM
|
||||
xc_pwm_start_all(); //使能所有PWM
|
||||
}
|
||||
|
||||
//ADC初始化
|
||||
static void hal_adc_init(void)
|
||||
{
|
||||
GPIO_InitCfg_t GPIO_InitCfg;
|
||||
|
||||
GPIO_InitCfg.Pin = GPIO_1;
|
||||
GPIO_InitCfg.Dir = GPIO_DIR_INPUT;
|
||||
GPIO_InitCfg.Pull = GPIO_NOPULL;
|
||||
GPIO_InitCfg.Mux = GPIO_Mux0;
|
||||
GPIO_InitCfg.FunSel = GPIO_Dx;
|
||||
GPIO_InitCfg.Int = NOT_INT;
|
||||
xc_gpio_init(&GPIO_InitCfg);
|
||||
|
||||
ADC_InitCfg_t adc_cfg;
|
||||
|
||||
adc_cfg.Freq = ADC_FREQ_500K; //采样频率，最高采样率1M
|
||||
adc_cfg.RefVol = ADC_REF_VOL_3_3V; //参考电压
|
||||
adc_cfg.SampEdge = ADC_SAMPEDGE_RISE; //内部采样触发沿
|
||||
adc_cfg.ExtDataMode = ADC_EXT_DATA_MODE_32BIT; //采集数据模式
|
||||
adc_cfg.ExtEdgeSel = ADC_EXT_EDGE_SEL_INTER; //数据采样触发源：内部自动采样
|
||||
adc_cfg.ExtSampleNum = ADC_EXT_SAMPLE_NUM_8; //外部触发采集数目
|
||||
adc_cfg.ExtTriggerSel = ADC_EXT_TRIGGER_SEL_PWM0; //外部触发信号源
|
||||
xc_adc_init(&adc_cfg);
|
||||
}
|
||||
|
||||
uint8_t configdata[4096];
|
||||
|
||||
//获取设备地址
|
||||
static void hal_addr_init(void)
|
||||
{
|
||||
uint8_t ruid[16];
|
||||
|
||||
xc_fmc_spi_init_oprt();
|
||||
xc_fmc_spi_flash_wake_up();
|
||||
|
||||
xc_fmc_spi_flash_ruid(ruid);
|
||||
for(uint8_t i = 0; i < 12; i++)
|
||||
{
|
||||
chipuid[i] = ruid[0];
|
||||
}
|
||||
xc_fmc_spi_flash_read(0x0001E000, deviceaddr, 4); //读取设备地址
|
||||
if((deviceaddr[0]==0xFF && deviceaddr[1]==0xFF && deviceaddr[2]==0xFF && deviceaddr[3]==0xFF))
|
||||
{
|
||||
//FLASH中没有写入设备地址时，使用chipuid前字节
|
||||
for(uint8_t i = 0; i < 4; i++)
|
||||
{
|
||||
deviceaddr[i] = chipuid[i];
|
||||
}
|
||||
}
|
||||
xc_fmc_spi_flash_read(0x00010000, configdata, 4096); //这里存储的是应用程序配置
|
||||
}
|
||||
|
||||
//GPIO初始化
|
||||
static void hal_gpio_init(void)
|
||||
{
|
||||
GPIO_InitCfg_t GPIO_InitCfg = {0};
|
||||
|
||||
//LED->GPIO0
|
||||
GPIO_InitCfg.Pin = GPIO_0;
|
||||
GPIO_InitCfg.Dir = GPIO_DIR_OUTPUT;//端口方向控制
|
||||
GPIO_InitCfg.Pull = GPIO_PULLUP;//上下拉控制
|
||||
GPIO_InitCfg.Mux = GPIO_Mux0; //一级复用
|
||||
GPIO_InitCfg.FunSel = GPIO_Dx; //二级复用
|
||||
GPIO_InitCfg.Int = NOT_INT; //中断控制
|
||||
xc_gpio_init(&GPIO_InitCfg);
|
||||
xc_gpio_write_pin(GPIO_0, GPIO_PIN_SET);
|
||||
|
||||
//RAD->GPIO5
|
||||
GPIO_InitCfg.Pin = GPIO_5;
|
||||
GPIO_InitCfg.Dir = GPIO_DIR_INPUT;//端口方向控制
|
||||
GPIO_InitCfg.Pull = GPIO_PULLDOWN;//上下拉控制
|
||||
GPIO_InitCfg.Mux = GPIO_Mux0; //一级复用
|
||||
GPIO_InitCfg.FunSel = GPIO_Dx; //二级复用
|
||||
GPIO_InitCfg.Int = NOT_INT; //中断控制
|
||||
xc_gpio_init(&GPIO_InitCfg);
|
||||
}
|
||||
|
||||
//MCU初始化
|
||||
void hal_mcu_init(void)
|
||||
{
|
||||
hal_clock_init();
|
||||
hal_wdt_init();
|
||||
hal_timer_init();
|
||||
hal_uart_init();
|
||||
hal_pwm_init();
|
||||
hal_adc_init();
|
||||
hal_addr_init();
|
||||
hal_gpio_init();
|
||||
}
|
||||
|
||||
//喂狗
|
||||
void hal_wdt_feed(void)
|
||||
{
|
||||
#if defined(ENABLE_WDT)
|
||||
//xc_wdt_reload();
|
||||
#endif
|
||||
}
|
||||
|
||||
//延时
|
||||
void hal_delayms(uint32_t ms)
|
||||
{
|
||||
delay_ms(ms);
|
||||
}
|
||||
|
||||
void hal_led_set(uint8_t val)
|
||||
{
|
||||
xc_gpio_write_pin(GPIO_0, val?GPIO_PIN_SET:GPIO_PIN_RESET);
|
||||
}
|
||||
|
||||
uint8_t hal_rad_get(void)
|
||||
{
|
||||
return xc_gpio_read_pin(GPIO_5);
|
||||
}
|
||||
|
||||
//设置PWM输出
|
||||
void hal_pwm_set(uint8_t pwm_idx, uint16_t duty)
|
||||
{
|
||||
uint16_t freq = 2000;
|
||||
uint32_t acc = 16000000 / freq;
|
||||
|
||||
xc_pwm_dutycycle_set(pwm_idx,acc, ((acc * duty) / 65535));
|
||||
}
|
||||
|
||||
//读取ADC值
|
||||
uint16_t hal_adc_get(void)
|
||||
{
|
||||
uint16_t value = 0;
|
||||
xc_adc_start_get_value(ADC_CH5_PIN1, &value); //获取采样值
|
||||
return value;
|
||||
}
|
||||
|
||||
//串口发送
|
||||
void hal_uart_send(uint8_t *data, uint16_t length)
|
||||
{
|
||||
xc_uart_send_data(UART0_IDX, data, length);
|
||||
}
|
||||
|
||||
//串口发送
|
||||
void hal_uart_sendbyte(uint8_t byte)
|
||||
{
|
||||
xc_uart_send_byte(UART0_IDX, byte);
|
||||
}
|
||||
|
||||
uint32_t hal_tickcount(void)
|
||||
{
|
||||
return tick_count;
|
||||
}
|
||||
|
||||
//获取8位随机数
|
||||
uint32_t hal_random(void)
|
||||
{
|
||||
srand(tick_count);
|
||||
return rand();
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
#ifndef __HAL_H
|
||||
#define __HAL_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "xc_drv_gpio.h"
|
||||
|
||||
extern void hal_mcu_init(void);
|
||||
extern void hal_wdt_feed(void);
|
||||
extern void hal_delayms(uint32_t ms);
|
||||
extern void hal_led_set(uint8_t val);
|
||||
extern void hal_uart_send(uint8_t *data, uint16_t length);
|
||||
extern void hal_uart_sendbyte(uint8_t byte);
|
||||
extern void hal_pwm_set(uint8_t pwm_idx, uint16_t duty);
|
||||
extern uint8_t hal_rad_get(void);
|
||||
extern uint16_t hal_adc_get(void);
|
||||
extern uint32_t hal_tickcount(void);
|
||||
extern uint32_t hal_random(void);
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user