YuanHongbin/DoubleColumn_Trolley
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始版本

Browse Source
This commit is contained in:
YuanHongbin
2026-06-15 16:49:21 +08:00
parent 1d5f34e892
commit 7f68ef4677
137 changed files with 96883 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Project/HC32F460/source/Module/CS1237/CS1237_LEFTLOW.c
+465
View File
@@ -0,0 +1,465 @@
#include "CS1237_LEFTLOW.h"
#include "Debug.h"
#include "bsp.h"
#include "main.h"
#include "Algorithm.h"
#define CS1237_DOUT_OUT() PORT_OE(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx, Enable)
#define CS1237_DOUT_IN() PORT_OE(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx, Disable)
#define CS1237_DOUT_H() SET_LEFTLOW_CS1237_DOUT()
#define CS1237_DOUT_L() CLR_LEFTLOW_CS1237_DOUT()
#define CS1237_DOUT_GET() GET_LEFTLOW_CS1237_DOUT()
#define CS1237_SCLK_H() SET_LEFTLOW_CS1237_SCLK()
#define CS1237_SCLK_L() CLR_LEFTLOW_CS1237_SCLK()
#define CS1237_5NS(x) delay_5ns(x) //5ns延时
#define CS1237_1US(x) Ddl_Delay1us(x) //1us延时
#define CS1237_1MS(x) Ddl_Delay1ms(x) //1ms延时
#define CS1237IntEnable() ExtInt01IntEnable()
#define CS1237IntDisable() ExtInt01IntDisable()
LEFTLOW_CS1237Var_t LEFTLOW_CS1237Var;
static bool InitFlag;
static bool CS1237IrqFlag;
static bool BuildDelay;
static uint8_t CS1237Port;
static uint8_t CS1237Hz;
static uint8_t CS1237PGA;
extern void LEFTLOW_CS1237AinADataProcessCallBack(int32_t AD);
/** cs1237 时序时钟*/
static void CS1237_Clock(void)
{
CS1237_SCLK_H();
CS1237_5NS(60);
CS1237_SCLK_L();
CS1237_5NS(60);
}
/** cs1237 休眠*/
static void CS1237_Sleep(void)
{
CS1237_SCLK_H();
CS1237_1US(200);
}
/** cs1237 唤醒*/
static void CS1237_WakeUp(void)
{
CS1237_SCLK_L();
CS1237_1US(20);
}
/**设置CS1237寄存器*/
static void Set_CS1237_Config(uint8_t ad_reg)
{
uint16_t bit_cout = 0;
uint8_t reg_temp = 0x00;
//DOUT由高变低之后开始读取数据
CS1237_DOUT_OUT();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237_SCLK_L(); //时钟拉低
LEFTLOW_CS1237Var.CS1237Delay1mSCnt = 300;
CS1237IrqFlag = false;
while(CS1237IrqFlag == false) //等待芯片准备好
{
if(LEFTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
//DBG_LOG("LEFTLOW CS1237 Preparation Timeout...\r\n");
return; // 超时退出
}
}
CS1237IntDisable();
CS1237IrqFlag = false;
/* clk1-clk26 写期间不需要操作*/
for (bit_cout = 0; bit_cout < 26; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
/* clk27 DOUT输出拉高*/
CS1237_Clock(); //给一周期时钟
CS1237_DOUT_H();
/* clk28 - clk29 发送写寄存器命令字 */
CS1237_Clock(); //给一周期时钟
CS1237_Clock(); //给一周期时钟
/* clk30 - clk36 发送写寄存器命令字 */
CS1237_DOUT_OUT();
reg_temp = WRITE_CONFIG_CMD << 1; //命令长度为 7bits (写0x65)左移1位
for (bit_cout = 0; bit_cout < 7; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* clk37写寄存器模式还是输出 */
CS1237_Clock();
/* clk38 ~ clk45 写入寄存器值 */
reg_temp = ad_reg;//要配件的寄存器数值
for (bit_cout = 0; bit_cout < 8; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* 8: clk46 */
CS1237_Clock();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237IntEnable();
return ;
}
/**读CS1237寄存器*/
static int32_t Read_CS1237_Config(void)
{
uint16_t bit_cout = 0;
uint8_t reg_temp = 0x00;
//DOUT由高变低之后开始读取数据
CS1237_DOUT_OUT();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237_SCLK_L(); //时钟拉低
LEFTLOW_CS1237Var.CS1237Delay1mSCnt = 300;
CS1237IrqFlag = false;
while(CS1237IrqFlag == false) //等待芯片准备好
{
if(LEFTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
//DBG_LOG("LEFTLOW CS1237 Preparation Timeout...\r\n");
return 0; // 超时退出
}
}
CS1237IntDisable();
CS1237IrqFlag = false;
/* clk1-clk26 写期间不需要操作*/
for (bit_cout = 0; bit_cout < 26; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
/* clk27 DOUT输出拉高*/
CS1237_Clock(); //给一周期时钟
CS1237_DOUT_H();
/* clk28 - clk29 发送写寄存器命令字 */
CS1237_Clock(); //给一周期时钟
CS1237_Clock(); //给一周期时钟
/* clk30 - clk36 发送读寄存器命令字 */
CS1237_DOUT_OUT();
reg_temp = READ_CONFIG_CMD << 1; //命令长度为 7bits (写0x56)左移1位
for (bit_cout = 0; bit_cout < 7; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* clk37，读寄存器模式改输入 */
CS1237_Clock();
CS1237_DOUT_IN();
for (bit_cout = 0; bit_cout < 8; bit_cout++)
{
CS1237_SCLK_H();
reg_temp <<= 1; //左移1位准备接受数据 初始默认0
CS1237_5NS(60);//延时300ns
if(CS1237_DOUT_GET() == true) //有数值则累加
reg_temp |= 1;
CS1237_SCLK_L();
CS1237_5NS(60);
}
/* 8: clk46 */
CS1237_Clock();
CS1237_DOUT_IN();
CS1237_DOUT_H();
CS1237IntEnable();
return reg_temp ;
}
/**读取CS1237的AD数*/
static int32_t Read_CS1237_Ad_Data(void)
{
uint16_t bit_cout = 0;
int32_t data_temp = 0;
/* clk1 ~ clk24 ADC数据*/
data_temp = 0;
for (bit_cout = 0; bit_cout < 24; bit_cout++)
{
CS1237_SCLK_H();
data_temp <<= 1; //左移1位准备接受数据 初始默认0
CS1237_5NS(60);//延时300ns
if(CS1237_DOUT_GET() == true) //有数值则累加
data_temp |= 1;
CS1237_SCLK_L();
CS1237_5NS(60);
}
/* clk25 ~ clk27 */
for (bit_cout = 24; bit_cout < 27; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
CS1237_DOUT_H();
CS1237_SCLK_L();
if(data_temp > 0x7FFFFF) //取24位
{
data_temp |= 0xFF000000;
}
return data_temp;
}
void LEFTLOW_CS1237_IrqCallBack(void)
{
CS1237IrqFlag = true;
}
void LEFTLOW_CS1237_Init(void)
{
CS1237IrqFlag = false;
BuildDelay = false;
LEFTLOW_CS1237Var.AinA_AD = 0;
LEFTLOW_CS1237Var.Temp_AD = 0;
LEFTLOW_CS1237Var.Jump_AD = 0;
CS1237IntEnable();
CS1237Port = CH_SEL_A;
CS1237Hz = SPEED_SEL_640Hz;
CS1237PGA = PGA_SEL_128;
uint8_t read_reg = 0x00;
uint8_t set_reg = REFO_ON | CS1237Hz | CS1237PGA | CS1237Port;
CS1237_1MS(20);
Set_CS1237_Config(set_reg);
CS1237_1MS(20);
read_reg = Read_CS1237_Config();
CS1237_1MS(20);
if(read_reg != set_reg){
DBG_LOG("LEFTLOW CS1237 Init ERR...\r\n");
//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
InitFlag = true;
}
else {
DBG_LOG("LEFTLOW CS1237 Init OK...\r\n");
//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
CS1237Port = read_reg & 0x03;
InitFlag = true;
}
CS1237IntDisable();
}
void LEFTLOW_CS1237DataLoopCollect(void)
{
static int32_t ad_array[PACK_NUM];
static uint8_t adcnt;
static uint8_t TimeOutmagcnt;
switch(LEFTLOW_CS1237Var.Status) {
case LLCS1237_STATUS_IDLE:{
break;}
case LLCS1237_STATUS_START:{
memset(&ad_array, 0x00, sizeof(ad_array));
adcnt = 0;
TimeOutmagcnt = 0;
memset(&LEFTLOW_CS1237Var, NULL, sizeof(LEFTLOW_CS1237Var));
if(BuildDelay == true)
{
BuildDelay = false;
if(CS1237Hz == SPEED_SEL_10Hz){
LEFTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_10Hz;
}
if(CS1237Hz == SPEED_SEL_40Hz){
LEFTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_40Hz;
}
if(CS1237Hz == SPEED_SEL_640Hz){
LEFTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_640Hz;
}
if(CS1237Hz == SPEED_SEL6_1280Hz){
LEFTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_1280Hz;
}
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_DELAY;
}
else
{
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_READ;
}
break;}
case LLCS1237_STATUS_DELAY:{
if(LEFTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_READ;
}
break;}
case LLCS1237_STATUS_READ:{
CS1237IrqFlag = false;
LEFTLOW_CS1237Var.CS1237Delay1mSCnt = 100;
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_WAIT_READ;
break;}
case LLCS1237_STATUS_WAIT_READ:{
if(LEFTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_READ;
TimeOutmagcnt++;
}
if(CS1237IrqFlag == true){
CS1237IrqFlag = false;
ad_array[adcnt++] = Read_CS1237_Ad_Data();
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_READ;
}
if(TimeOutmagcnt >= PACK_NUM){
TimeOutmagcnt = 0;
if(adcnt > 0){
if(CS1237Port == CH_SEL_A){
LEFTLOW_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
LEFTLOW_CS1237AinADataProcessCallBack(LEFTLOW_CS1237Var.AinA_AD);
}
if(CS1237Port == CH_SEL_TEMP){
LEFTLOW_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
}
if(CS1237Port == CH_SEL_JUMP){
LEFTLOW_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
}
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_CH_SEL;
}
else{
if(CS1237Port == CH_SEL_A){
DBG_LOG("LEFTLOW CS1237 CHA TimeOut...\r\n");
}
if(CS1237Port == CH_SEL_TEMP){
DBG_LOG("LEFTLOW CS1237 Temp TimeOut...\r\n");
}
if(CS1237Port == CH_SEL_JUMP){
DBG_LOG("LEFTLOW CS1237 Jump TimeOut...\r\n");
}
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_CH_SEL;
}
}
if(adcnt >= PACK_NUM){
if(CS1237Port == CH_SEL_A){
LEFTLOW_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
LEFTLOW_CS1237AinADataProcessCallBack(LEFTLOW_CS1237Var.AinA_AD);
}
if(CS1237Port == CH_SEL_TEMP){
LEFTLOW_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
}
if(CS1237Port == CH_SEL_JUMP){
LEFTLOW_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
}
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_CH_SEL;
}
break;}
case LLCS1237_STATUS_CH_SEL:{
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_STOP;
BuildDelay = false;
uint8_t read_reg;
if(CS1237Port == CH_SEL_A){
#if(PORT_TEMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
CS1237Port = CH_SEL_TEMP;
BuildDelay = true;
break;
#endif
#if(PORT_JUMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_JUMP);
CS1237Port = CH_SEL_JUMP;
BuildDelay = true;
break;
#endif
}
if(CS1237Port == CH_SEL_TEMP){
#if(PORT_JUMP == 1)
read_reg = Read_CS1238_Config();
Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
CS1238Port = CH_SEL_JUMP;
BuildDelay = true;
break;
#endif
#if(PORT_A == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
CS1237Port = CH_SEL_A;
BuildDelay = true;
break;
#endif
}
if(CS1237Port == CH_SEL_JUMP){
#if(PORT_A == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
CS1237Port = CH_SEL_A;
BuildDelay = true;
break;
#endif
#if(PORT_TEMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
CS1237Port = CH_SEL_TEMP;
BuildDelay = true;
break;
#endif
}
break;}
case LLCS1237_STATUS_STOP:{
LEFTLOW_CS1237Stop();
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_IDLE;
//LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_START;//持续工作
break;}
}
}
void LEFTLOW_CS12371mSRoutine(void)
{
if(LEFTLOW_CS1237Var.CS1237Delay1mSCnt > 0)
LEFTLOW_CS1237Var.CS1237Delay1mSCnt--;
}
void LEFTLOW_CS1237Start(void)
{
CS1237_WakeUp();
CS1237_1MS(2);
BuildDelay = true;
CS1237IntEnable();
if(!InitFlag){
LEFTLOW_CS1237_Init();
return;
}
LEFTLOW_CS1237Var.Status = LLCS1237_STATUS_START;
}
void LEFTLOW_CS1237Stop(void)
{
CS1237IntDisable();
//CS1237_Sleep();
}
Project/HC32F460/source/Module/CS1237/CS1237_LEFTLOW.h
+78
View File
@@ -0,0 +1,78 @@
#include "bsp.h"
#ifndef _CS1237_LEFTLOW_H_
#define _CS1237_LEFTLOW_H_
#define READ_CONFIG_CMD 0x56
#define WRITE_CONFIG_CMD 0x65
#define CONFIG_RST 0x0C
#define REFO_OFF 0x40
#define REFO_ON 0x00
#define SPEED_SEL_10Hz 0x00
#define SPEED_SEL_40Hz 0x10
#define SPEED_SEL_640Hz 0x20
#define SPEED_SEL6_1280Hz 0x30
#define PGA_SEL_1 0x00
#define PGA_SEL_2 0x04
#define PGA_SEL_64 0x08
#define PGA_SEL_128 0x0C
#define CH_SEL_A 0x00
//#define CH_SEL_B 0x01
#define CH_SEL_TEMP 0x02
#define CH_SEL_JUMP 0x03
/*Definition of conversion time corresponding to repeatability setting*/
/*
10Hz //建立时间300ms
40Hz //建立时间75ms
640Hz //建立时间6.25ms
1280Hz //建立时间3.125ms
*/
#define tCon_10Hz 300 /* ms. */
#define tCon_40Hz 75 /* ms. */
#define tCon_640Hz 7 /* ms. */
#define tCon_1280Hz 4 /* ms. */
#define PORT_A 1 //采集通道A
//#define PORT_B 1 //采集通道B
#define PORT_TEMP 0 //采集温度
#define PORT_JUMP 0 //内短采集
#define PACK_NUM 1 //一次采集的数据包数量
#define FILTER_NUM 0 //滤波数
typedef enum{
LLCS1237_STATUS_IDLE,
LLCS1237_STATUS_START,
LLCS1237_STATUS_DELAY,
LLCS1237_STATUS_READ,
LLCS1237_STATUS_WAIT_READ,
LLCS1237_STATUS_CH_SEL,
LLCS1237_STATUS_STOP,
}LeftLowCS1237Status_m;
typedef struct{
LeftLowCS1237Status_m Status;
uint32_t CS1237Delay1mSCnt;
int32_t AinA_AD;//AINAad数据
//int32_t AinB_AD;//AINBad数据
int32_t Temp_AD;//温度ad数据
int32_t Jump_AD;//内短ad数据
}
LEFTLOW_CS1237Var_t;
void LEFTLOW_CS1237_Init(void);
void LEFTLOW_CS1237_IrqCallBack(void);
void LEFTLOW_CS1237DataLoopCollect(void);
void LEFTLOW_CS12371mSRoutine(void);
void LEFTLOW_CS1237Start(void);
void LEFTLOW_CS1237Stop(void);
#endif
Project/HC32F460/source/Module/CS1237/CS1237_LEFTUP.c
+464
View File
@@ -0,0 +1,464 @@
#include "CS1237_LEFTUP.h"
#include "Debug.h"
#include "bsp.h"
#include "main.h"
#include "Algorithm.h"
#define CS1237_DOUT_OUT() PORT_OE(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx, Enable)
#define CS1237_DOUT_IN() PORT_OE(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx, Disable)
#define CS1237_DOUT_H() SET_LEFTUP_CS1237_DOUT()
#define CS1237_DOUT_L() CLR_LEFTUP_CS1237_DOUT()
#define CS1237_DOUT_GET() GET_LEFTUP_CS1237_DOUT()
#define CS1237_SCLK_H() SET_LEFTUP_CS1237_SCLK()
#define CS1237_SCLK_L() CLR_LEFTUP_CS1237_SCLK()
#define CS1237_5NS(x) delay_5ns(x) //5ns延时
#define CS1237_1US(x) Ddl_Delay1us(x) //1us延时
#define CS1237_1MS(x) Ddl_Delay1ms(x) //1ms延时
#define CS1237IntEnable() ExtInt10IntEnable()
#define CS1237IntDisable() ExtInt10IntDisable()
LEFTUP_CS1237Var_t LEFTUP_CS1237Var;
static bool InitFlag;
static bool CS1237IrqFlag;
static bool BuildDelay;
static uint8_t CS1237Port;
static uint8_t CS1237Hz;
static uint8_t CS1237PGA;
extern void LEFTUP_CS1237AinADataProcessCallBack(int32_t AD);
/** cs1237 时序时钟*/
static void CS1237_Clock(void)
{
CS1237_SCLK_H();
CS1237_5NS(60);
CS1237_SCLK_L();
CS1237_5NS(60);
}
/** cs1237 休眠*/
static void CS1237_Sleep(void)
{
CS1237_SCLK_H();
CS1237_1US(200);
}
/** cs1237 唤醒*/
static void CS1237_WakeUp(void)
{
CS1237_SCLK_L();
CS1237_1US(20);
}
/**设置CS1237寄存器*/
static void Set_CS1237_Config(uint8_t ad_reg)
{
uint16_t bit_cout = 0;
uint8_t reg_temp = 0x00;
//DOUT由高变低之后开始读取数据
CS1237_DOUT_OUT();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237_SCLK_L(); //时钟拉低
LEFTUP_CS1237Var.CS1237Delay1mSCnt = 300;
CS1237IrqFlag = false;
while(CS1237IrqFlag == false) //等待芯片准备好
{
if(LEFTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
//DBG_LOG("LEFTUP CS1237 Preparation Timeout...\r\n");
return; // 超时退出
}
}
CS1237IntDisable();
CS1237IrqFlag = false;
/* clk1-clk26 写期间不需要操作*/
for (bit_cout = 0; bit_cout < 26; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
/* clk27 DOUT输出拉高*/
CS1237_Clock(); //给一周期时钟
CS1237_DOUT_H();
/* clk28 - clk29 发送写寄存器命令字 */
CS1237_Clock(); //给一周期时钟
CS1237_Clock(); //给一周期时钟
/* clk30 - clk36 发送写寄存器命令字 */
CS1237_DOUT_OUT();
reg_temp = WRITE_CONFIG_CMD << 1; //命令长度为 7bits (写0x65)左移1位
for (bit_cout = 0; bit_cout < 7; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* clk37写寄存器模式还是输出 */
CS1237_Clock();
/* clk38 ~ clk45 写入寄存器值 */
reg_temp = ad_reg;//要配件的寄存器数值
for (bit_cout = 0; bit_cout < 8; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* 8: clk46 */
CS1237_Clock();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237IntEnable();
return ;
}
/**读CS1237寄存器*/
static int32_t Read_CS1237_Config(void)
{
uint16_t bit_cout = 0;
uint8_t reg_temp = 0x00;
//DOUT由高变低之后开始读取数据
CS1237_DOUT_OUT();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237_SCLK_L(); //时钟拉低
LEFTUP_CS1237Var.CS1237Delay1mSCnt = 300;
CS1237IrqFlag = false;
while(CS1237IrqFlag == false) //等待芯片准备好
{
if(LEFTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
//DBG_LOG("LEFTUP CS1237 Preparation Timeout...\r\n");
return 0; // 超时退出
}
}
CS1237IntDisable();
CS1237IrqFlag = false;
/* clk1-clk26 写期间不需要操作*/
for (bit_cout = 0; bit_cout < 26; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
/* clk27 DOUT输出拉高*/
CS1237_Clock(); //给一周期时钟
CS1237_DOUT_H();
/* clk28 - clk29 发送写寄存器命令字 */
CS1237_Clock(); //给一周期时钟
CS1237_Clock(); //给一周期时钟
/* clk30 - clk36 发送读寄存器命令字 */
CS1237_DOUT_OUT();
reg_temp = READ_CONFIG_CMD << 1; //命令长度为 7bits (写0x56)左移1位
for (bit_cout = 0; bit_cout < 7; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* clk37，读寄存器模式改输入 */
CS1237_Clock();
CS1237_DOUT_IN();
for (bit_cout = 0; bit_cout < 8; bit_cout++)
{
CS1237_SCLK_H();
reg_temp <<= 1; //左移1位准备接受数据 初始默认0
CS1237_5NS(60);//延时300ns
if(CS1237_DOUT_GET() == true) //有数值则累加
reg_temp |= 1;
CS1237_SCLK_L();
CS1237_5NS(60);
}
/* 8: clk46 */
CS1237_Clock();
CS1237_DOUT_IN();
CS1237_DOUT_H();
CS1237IntEnable();
return reg_temp ;
}
/**读取CS1237的AD数*/
static int32_t Read_CS1237_Ad_Data(void)
{
uint16_t bit_cout = 0;
int32_t data_temp = 0;
/* clk1 ~ clk24 ADC数据*/
data_temp = 0;
for (bit_cout = 0; bit_cout < 24; bit_cout++)
{
CS1237_SCLK_H();
data_temp <<= 1; //左移1位准备接受数据 初始默认0
CS1237_5NS(60);//延时300ns
if(CS1237_DOUT_GET() == true) //有数值则累加
data_temp |= 1;
CS1237_SCLK_L();
CS1237_5NS(60);
}
/* clk25 ~ clk27 */
for (bit_cout = 24; bit_cout < 27; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
CS1237_DOUT_H();
CS1237_SCLK_L();
if(data_temp > 0x7FFFFF) //取24位
{
data_temp |= 0xFF000000;
}
return data_temp;
}
void LEFTUP_CS1237_IrqCallBack(void)
{
CS1237IrqFlag = true;
}
void LEFTUP_CS1237_Init(void)
{
CS1237IrqFlag = false;
BuildDelay = false;
LEFTUP_CS1237Var.AinA_AD = 0;
LEFTUP_CS1237Var.Temp_AD = 0;
LEFTUP_CS1237Var.Jump_AD = 0;
CS1237IntEnable();
CS1237Port = CH_SEL_A;
CS1237Hz = SPEED_SEL_640Hz;
CS1237PGA = PGA_SEL_128;
uint8_t read_reg = 0x00;
uint8_t set_reg = REFO_ON | CS1237Hz | CS1237PGA | CS1237Port;
CS1237_1MS(20);
Set_CS1237_Config(set_reg);
CS1237_1MS(20);
read_reg = Read_CS1237_Config();
CS1237_1MS(20);
if(read_reg != set_reg){
DBG_LOG("LEFTUP CS1237 Init ERR...\r\n");
//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
InitFlag = true;
}
else {
DBG_LOG("LEFTUP CS1237 Init OK...\r\n");
//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
CS1237Port = read_reg & 0x03;
InitFlag = true;
}
CS1237IntDisable();
}
void LEFTUP_CS1237DataLoopCollect(void)
{
static int32_t ad_array[PACK_NUM];
static uint8_t adcnt;
static uint8_t TimeOutmagcnt;
switch(LEFTUP_CS1237Var.Status) {
case LUCS1237_STATUS_IDLE:{
break;}
case LUCS1237_STATUS_START:{
memset(&ad_array, 0x00, sizeof(ad_array));
adcnt = 0;
TimeOutmagcnt = 0;
memset(&LEFTUP_CS1237Var, NULL, sizeof(LEFTUP_CS1237Var));
if(BuildDelay == true)
{
BuildDelay = false;
if(CS1237Hz == SPEED_SEL_10Hz){
LEFTUP_CS1237Var.CS1237Delay1mSCnt = tCon_10Hz;
}
if(CS1237Hz == SPEED_SEL_40Hz){
LEFTUP_CS1237Var.CS1237Delay1mSCnt = tCon_40Hz;
}
if(CS1237Hz == SPEED_SEL_640Hz){
LEFTUP_CS1237Var.CS1237Delay1mSCnt = tCon_640Hz;
}
if(CS1237Hz == SPEED_SEL6_1280Hz){
LEFTUP_CS1237Var.CS1237Delay1mSCnt = tCon_1280Hz;
}
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_DELAY;
}
else
{
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_READ;
}
break;}
case LUCS1237_STATUS_DELAY:{
if(LEFTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_READ;
}
break;}
case LUCS1237_STATUS_READ:{
CS1237IrqFlag = false;
LEFTUP_CS1237Var.CS1237Delay1mSCnt = 100;
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_WAIT_READ;
break;}
case LUCS1237_STATUS_WAIT_READ:{
if(LEFTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_READ;
TimeOutmagcnt++;
}
if(CS1237IrqFlag == true){
CS1237IrqFlag = false;
ad_array[adcnt++] = Read_CS1237_Ad_Data();
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_READ;
}
if(TimeOutmagcnt >= PACK_NUM){
TimeOutmagcnt = 0;
if(adcnt > 0){
if(CS1237Port == CH_SEL_A){
LEFTUP_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
LEFTUP_CS1237AinADataProcessCallBack(LEFTUP_CS1237Var.AinA_AD);
}
if(CS1237Port == CH_SEL_TEMP){
LEFTUP_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
}
if(CS1237Port == CH_SEL_JUMP){
LEFTUP_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
}
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_CH_SEL;
}
else{
if(CS1237Port == CH_SEL_A){
DBG_LOG("LEFTUPs CS1237 CHA TimeOut...\r\n");
}
if(CS1237Port == CH_SEL_TEMP){
DBG_LOG("LEFTUP CS1237 Temp TimeOut...\r\n");
}
if(CS1237Port == CH_SEL_JUMP){
DBG_LOG("LEFTUP CS1237 Jump TimeOut...\r\n");
}
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_CH_SEL;
}
}
if(adcnt >= PACK_NUM){
if(CS1237Port == CH_SEL_A){
LEFTUP_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
LEFTUP_CS1237AinADataProcessCallBack(LEFTUP_CS1237Var.AinA_AD);
}
if(CS1237Port == CH_SEL_TEMP){
LEFTUP_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
}
if(CS1237Port == CH_SEL_JUMP){
LEFTUP_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
}
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_CH_SEL;
}
break;}
case LUCS1237_STATUS_CH_SEL:{
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_STOP;
BuildDelay = false;
uint8_t read_reg;
if(CS1237Port == CH_SEL_A){
#if(PORT_TEMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
CS1237Port = CH_SEL_TEMP;
BuildDelay = true;
break;
#endif
#if(PORT_JUMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_JUMP);
CS1237Port = CH_SEL_JUMP;
BuildDelay = true;
break;
#endif
}
if(CS1237Port == CH_SEL_TEMP){
#if(PORT_JUMP == 1)
read_reg = Read_CS1238_Config();
Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
CS1238Port = CH_SEL_JUMP;
BuildDelay = true;
break;
#endif
#if(PORT_A == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
CS1237Port = CH_SEL_A;
BuildDelay = true;
break;
#endif
}
if(CS1237Port == CH_SEL_JUMP){
#if(PORT_A == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
CS1237Port = CH_SEL_A;
BuildDelay = true;
break;
#endif
#if(PORT_TEMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
CS1237Port = CH_SEL_TEMP;
BuildDelay = true;
break;
#endif
}
break;}
case LUCS1237_STATUS_STOP:{
LEFTUP_CS1237Stop();
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_IDLE;
//LEFTUP_CS1237Var.Status = LUCS1237_STATUS_START;//持续工作
break;}
}
}
void LEFTUP_CS12371mSRoutine(void)
{
if(LEFTUP_CS1237Var.CS1237Delay1mSCnt > 0)
LEFTUP_CS1237Var.CS1237Delay1mSCnt--;
}
void LEFTUP_CS1237Start(void)
{
CS1237_WakeUp();
CS1237_1MS(2);
BuildDelay = true;
CS1237IntEnable();
if(!InitFlag){
LEFTUP_CS1237_Init();
return;
}
LEFTUP_CS1237Var.Status = LUCS1237_STATUS_START;
}
void LEFTUP_CS1237Stop(void)
{
CS1237IntDisable();
//CS1237_Sleep();
}
Project/HC32F460/source/Module/CS1237/CS1237_LEFTUP.h
+80
View File
@@ -0,0 +1,80 @@
#include "bsp.h"
#ifndef _CS1237_LEFTUP_H_
#define _CS1237_LEFTUP_H_
#define READ_CONFIG_CMD 0x56
#define WRITE_CONFIG_CMD 0x65
#define CONFIG_RST 0x0C
#define REFO_OFF 0x40
#define REFO_ON 0x00
#define SPEED_SEL_10Hz 0x00
#define SPEED_SEL_40Hz 0x10
#define SPEED_SEL_640Hz 0x20
#define SPEED_SEL6_1280Hz 0x30
#define PGA_SEL_1 0x00
#define PGA_SEL_2 0x04
#define PGA_SEL_64 0x08
#define PGA_SEL_128 0x0C
#define CH_SEL_A 0x00
//#define CH_SEL_B 0x01
#define CH_SEL_TEMP 0x02
#define CH_SEL_JUMP 0x03
/*Definition of conversion time corresponding to repeatability setting*/
/*
10Hz //建立时间300ms
40Hz //建立时间75ms
640Hz //建立时间6.25ms
1280Hz //建立时间3.125ms
*/
#define tCon_10Hz 300 /* ms. */
#define tCon_40Hz 75 /* ms. */
#define tCon_640Hz 7 /* ms. */
#define tCon_1280Hz 4 /* ms. */
#define PORT_A 1 //采集通道A
//#define PORT_B 1 //采集通道B
#define PORT_TEMP 0 //采集温度
#define PORT_JUMP 0 //内短采集
#define PACK_NUM 1 //一次采集的数据包数量
#define FILTER_NUM 0 //滤波数
typedef enum{
LUCS1237_STATUS_IDLE,
LUCS1237_STATUS_START,
LUCS1237_STATUS_DELAY,
LUCS1237_STATUS_READ,
LUCS1237_STATUS_WAIT_READ,
LUCS1237_STATUS_CH_SEL,
LUCS1237_STATUS_STOP,
}LeftUpCS1237Status_m;
typedef struct{
LeftUpCS1237Status_m Status;
uint32_t CS1237Delay1mSCnt;
int32_t AinA_AD;//AINAad数据
//int32_t AinB_AD;//AINBad数据
int32_t Temp_AD;//温度ad数据
int32_t Jump_AD;//内短ad数据
}
LEFTUP_CS1237Var_t;
void LEFTUP_CS1237_Init(void);
void LEFTUP_CS1237_IrqCallBack(void);
void LEFTUP_CS1237DataLoopCollect(void);
void LEFTUP_CS12371mSRoutine(void);
void LEFTUP_CS1237Start(void);
void LEFTUP_CS1237Stop(void);
#endif
Project/HC32F460/source/Module/CS1237/CS1237_RIGHTLOW.c
+464
View File
@@ -0,0 +1,464 @@
#include "CS1237_RIGHTLOW.h"
#include "Debug.h"
#include "bsp.h"
#include "main.h"
#include "Algorithm.h"
#define CS1237_DOUT_OUT() PORT_OE(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx, Enable)
#define CS1237_DOUT_IN() PORT_OE(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx, Disable)
#define CS1237_DOUT_H() SET_RIGHTLOW_CS1237_DOUT()
#define CS1237_DOUT_L() CLR_RIGHTLOW_CS1237_DOUT()
#define CS1237_DOUT_GET() GET_RIGHTLOW_CS1237_DOUT()
#define CS1237_SCLK_H() SET_RIGHTLOW_CS1237_SCLK()
#define CS1237_SCLK_L() CLR_RIGHTLOW_CS1237_SCLK()
#define CS1237_5NS(x) delay_5ns(x) //5ns延时
#define CS1237_1US(x) Ddl_Delay1us(x) //1us延时
#define CS1237_1MS(x) Ddl_Delay1ms(x) //1ms延时
#define CS1237IntEnable() ExtInt06IntEnable()
#define CS1237IntDisable() ExtInt06IntDisable()
RIGHTLOW_CS1237Var_t RIGHTLOW_CS1237Var;
static bool InitFlag;
static bool CS1237IrqFlag;
static bool BuildDelay;
static uint8_t CS1237Port;
static uint8_t CS1237Hz;
static uint8_t CS1237PGA;
extern void RIGHTLOW_CS1237AinADataProcessCallBack(int32_t AD);
/** cs1237 时序时钟*/
static void CS1237_Clock(void)
{
CS1237_SCLK_H();
CS1237_5NS(60);
CS1237_SCLK_L();
CS1237_5NS(60);
}
/** cs1237 休眠*/
static void CS1237_Sleep(void)
{
CS1237_SCLK_H();
CS1237_1US(200);
}
/** cs1237 唤醒*/
static void CS1237_WakeUp(void)
{
CS1237_SCLK_L();
CS1237_1US(20);
}
/**设置CS1237寄存器*/
static void Set_CS1237_Config(uint8_t ad_reg)
{
uint16_t bit_cout = 0;
uint8_t reg_temp = 0x00;
//DOUT由高变低之后开始读取数据
CS1237_DOUT_OUT();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237_SCLK_L(); //时钟拉低
RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = 300;
CS1237IrqFlag = false;
while(CS1237IrqFlag == false) //等待芯片准备好
{
if(RIGHTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
//DBG_LOG("RIGHTLOW CS1237 Preparation Timeout...\r\n");
return; // 超时退出
}
}
CS1237IntDisable();
CS1237IrqFlag = false;
/* clk1-clk26 写期间不需要操作*/
for (bit_cout = 0; bit_cout < 26; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
/* clk27 DOUT输出拉高*/
CS1237_Clock(); //给一周期时钟
CS1237_DOUT_H();
/* clk28 - clk29 发送写寄存器命令字 */
CS1237_Clock(); //给一周期时钟
CS1237_Clock(); //给一周期时钟
/* clk30 - clk36 发送写寄存器命令字 */
CS1237_DOUT_OUT();
reg_temp = WRITE_CONFIG_CMD << 1; //命令长度为 7bits (写0x65)左移1位
for (bit_cout = 0; bit_cout < 7; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* clk37写寄存器模式还是输出 */
CS1237_Clock();
/* clk38 ~ clk45 写入寄存器值 */
reg_temp = ad_reg;//要配件的寄存器数值
for (bit_cout = 0; bit_cout < 8; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* 8: clk46 */
CS1237_Clock();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237IntEnable();
return ;
}
/**读CS1237寄存器*/
static int32_t Read_CS1237_Config(void)
{
uint16_t bit_cout = 0;
uint8_t reg_temp = 0x00;
//DOUT由高变低之后开始读取数据
CS1237_DOUT_OUT();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237_SCLK_L(); //时钟拉低
RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = 300;
CS1237IrqFlag = false;
while(CS1237IrqFlag == false) //等待芯片准备好
{
if(RIGHTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
//DBG_LOG("RIGHTLOW CS1237 Preparation Timeout...\r\n");
return 0; // 超时退出
}
}
CS1237IntDisable();
CS1237IrqFlag = false;
/* clk1-clk26 写期间不需要操作*/
for (bit_cout = 0; bit_cout < 26; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
/* clk27 DOUT输出拉高*/
CS1237_Clock(); //给一周期时钟
CS1237_DOUT_H();
/* clk28 - clk29 发送写寄存器命令字 */
CS1237_Clock(); //给一周期时钟
CS1237_Clock(); //给一周期时钟
/* clk30 - clk36 发送读寄存器命令字 */
CS1237_DOUT_OUT();
reg_temp = READ_CONFIG_CMD << 1; //命令长度为 7bits (写0x56)左移1位
for (bit_cout = 0; bit_cout < 7; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* clk37，读寄存器模式改输入 */
CS1237_Clock();
CS1237_DOUT_IN();
for (bit_cout = 0; bit_cout < 8; bit_cout++)
{
CS1237_SCLK_H();
reg_temp <<= 1; //左移1位准备接受数据 初始默认0
CS1237_5NS(60);//延时300ns
if(CS1237_DOUT_GET() == true) //有数值则累加
reg_temp |= 1;
CS1237_SCLK_L();
CS1237_5NS(60);
}
/* 8: clk46 */
CS1237_Clock();
CS1237_DOUT_IN();
CS1237_DOUT_H();
CS1237IntEnable();
return reg_temp ;
}
/**读取CS1237的AD数*/
static int32_t Read_CS1237_Ad_Data(void)
{
uint16_t bit_cout = 0;
int32_t data_temp = 0;
/* clk1 ~ clk24 ADC数据*/
data_temp = 0;
for (bit_cout = 0; bit_cout < 24; bit_cout++)
{
CS1237_SCLK_H();
data_temp <<= 1; //左移1位准备接受数据 初始默认0
CS1237_5NS(60);//延时300ns
if(CS1237_DOUT_GET() == true) //有数值则累加
data_temp |= 1;
CS1237_SCLK_L();
CS1237_5NS(60);
}
/* clk25 ~ clk27 */
for (bit_cout = 24; bit_cout < 27; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
CS1237_DOUT_H();
CS1237_SCLK_L();
if(data_temp > 0x7FFFFF) //取24位
{
data_temp |= 0xFF000000;
}
return data_temp;
}
void RIGHTLOW_CS1237_IrqCallBack(void)
{
CS1237IrqFlag = true;
}
void RIGHTLOW_CS1237_Init(void)
{
CS1237IrqFlag = false;
BuildDelay = false;
RIGHTLOW_CS1237Var.AinA_AD = 0;
RIGHTLOW_CS1237Var.Temp_AD = 0;
RIGHTLOW_CS1237Var.Jump_AD = 0;
CS1237IntEnable();
CS1237Port = CH_SEL_A;
CS1237Hz = SPEED_SEL_640Hz;
CS1237PGA = PGA_SEL_128;
uint8_t read_reg = 0x00;
uint8_t set_reg = REFO_ON | CS1237Hz | CS1237PGA | CS1237Port;
CS1237_1MS(20);
Set_CS1237_Config(set_reg);
CS1237_1MS(20);
read_reg = Read_CS1237_Config();
CS1237_1MS(20);
if(read_reg != set_reg){
DBG_LOG("RIGHTLOW CS1237 Init ERR...\r\n");
//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
InitFlag = true;
}
else {
DBG_LOG("RIGHTLOW CS1237 Init OK...\r\n");
//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
CS1237Port = read_reg & 0x03;
InitFlag = true;
}
CS1237IntDisable();
}
void RIGHTLOW_CS1237DataLoopCollect(void)
{
static int32_t ad_array[PACK_NUM];
static uint8_t adcnt;
static uint8_t TimeOutmagcnt;
switch(RIGHTLOW_CS1237Var.Status) {
case RLCS1237_STATUS_IDLE:{
break;}
case RLCS1237_STATUS_START:{
memset(&ad_array, 0x00, sizeof(ad_array));
adcnt = 0;
TimeOutmagcnt = 0;
memset(&RIGHTLOW_CS1237Var, NULL, sizeof(RIGHTLOW_CS1237Var));
if(BuildDelay == true)
{
BuildDelay = false;
if(CS1237Hz == SPEED_SEL_10Hz){
RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_10Hz;
}
if(CS1237Hz == SPEED_SEL_40Hz){
RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_40Hz;
}
if(CS1237Hz == SPEED_SEL_640Hz){
RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_640Hz;
}
if(CS1237Hz == SPEED_SEL6_1280Hz){
RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = tCon_1280Hz;
}
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_DELAY;
}
else
{
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_READ;
}
break;}
case RLCS1237_STATUS_DELAY:{
if(RIGHTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_READ;
}
break;}
case RLCS1237_STATUS_READ:{
CS1237IrqFlag = false;
RIGHTLOW_CS1237Var.CS1237Delay1mSCnt = 100;
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_WAIT_READ;
break;}
case RLCS1237_STATUS_WAIT_READ:{
if(RIGHTLOW_CS1237Var.CS1237Delay1mSCnt <= 0){
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_READ;
TimeOutmagcnt++;
}
if(CS1237IrqFlag == true){
CS1237IrqFlag = false;
ad_array[adcnt++] = Read_CS1237_Ad_Data();
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_READ;
}
if(TimeOutmagcnt >= PACK_NUM){
TimeOutmagcnt = 0;
if(adcnt > 0){
if(CS1237Port == CH_SEL_A){
RIGHTLOW_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
RIGHTLOW_CS1237AinADataProcessCallBack(RIGHTLOW_CS1237Var.AinA_AD);
}
if(CS1237Port == CH_SEL_TEMP){
RIGHTLOW_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
}
if(CS1237Port == CH_SEL_JUMP){
RIGHTLOW_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
}
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_CH_SEL;
}
else{
if(CS1237Port == CH_SEL_A){
DBG_LOG("RIGHTLOW CS1237 CHA TimeOut...\r\n");
}
if(CS1237Port == CH_SEL_TEMP){
DBG_LOG("RIGHTLOW CS1237 Temp TimeOut...\r\n");
}
if(CS1237Port == CH_SEL_JUMP){
DBG_LOG("RIGHTLOW CS1237 Jump TimeOut...\r\n");
}
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_CH_SEL;
}
}
if(adcnt >= PACK_NUM){
if(CS1237Port == CH_SEL_A){
RIGHTLOW_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
RIGHTLOW_CS1237AinADataProcessCallBack(RIGHTLOW_CS1237Var.AinA_AD);
}
if(CS1237Port == CH_SEL_TEMP){
RIGHTLOW_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
}
if(CS1237Port == CH_SEL_JUMP){
RIGHTLOW_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
}
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_CH_SEL;
}
break;}
case RLCS1237_STATUS_CH_SEL:{
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_STOP;
BuildDelay = false;
uint8_t read_reg;
if(CS1237Port == CH_SEL_A){
#if(PORT_TEMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
CS1237Port = CH_SEL_TEMP;
BuildDelay = true;
break;
#endif
#if(PORT_JUMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_JUMP);
CS1237Port = CH_SEL_JUMP;
BuildDelay = true;
break;
#endif
}
if(CS1237Port == CH_SEL_TEMP){
#if(PORT_JUMP == 1)
read_reg = Read_CS1238_Config();
Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
CS1238Port = CH_SEL_JUMP;
BuildDelay = true;
break;
#endif
#if(PORT_A == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
CS1237Port = CH_SEL_A;
BuildDelay = true;
break;
#endif
}
if(CS1237Port == CH_SEL_JUMP){
#if(PORT_A == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
CS1237Port = CH_SEL_A;
BuildDelay = true;
break;
#endif
#if(PORT_TEMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
CS1237Port = CH_SEL_TEMP;
BuildDelay = true;
break;
#endif
}
break;}
case RLCS1237_STATUS_STOP:{
RIGHTLOW_CS1237Stop();
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_IDLE;
//RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_START;//持续工作
break;}
}
}
void RIGHTLOW_CS12371mSRoutine(void)
{
if(RIGHTLOW_CS1237Var.CS1237Delay1mSCnt > 0)
RIGHTLOW_CS1237Var.CS1237Delay1mSCnt--;
}
void RIGHTLOW_CS1237Start(void)
{
CS1237_WakeUp();
CS1237_1MS(2);
BuildDelay = true;
CS1237IntEnable();
if(!InitFlag){
RIGHTLOW_CS1237_Init();
return;
}
RIGHTLOW_CS1237Var.Status = RLCS1237_STATUS_START;
}
void RIGHTLOW_CS1237Stop(void)
{
CS1237IntDisable();
//CS1237_Sleep();
}
Project/HC32F460/source/Module/CS1237/CS1237_RIGHTLOW.h
+78
View File
@@ -0,0 +1,78 @@
#include "bsp.h"
#ifndef _CS1237_RIGHTLOW_H_
#define _CS1237_RIGHTLOW_H_
#define READ_CONFIG_CMD 0x56
#define WRITE_CONFIG_CMD 0x65
#define CONFIG_RST 0x0C
#define REFO_OFF 0x40
#define REFO_ON 0x00
#define SPEED_SEL_10Hz 0x00
#define SPEED_SEL_40Hz 0x10
#define SPEED_SEL_640Hz 0x20
#define SPEED_SEL6_1280Hz 0x30
#define PGA_SEL_1 0x00
#define PGA_SEL_2 0x04
#define PGA_SEL_64 0x08
#define PGA_SEL_128 0x0C
#define CH_SEL_A 0x00
//#define CH_SEL_B 0x01
#define CH_SEL_TEMP 0x02
#define CH_SEL_JUMP 0x03
/*Definition of conversion time corresponding to repeatability setting*/
/*
10Hz //建立时间300ms
40Hz //建立时间75ms
640Hz //建立时间6.25ms
1280Hz //建立时间3.125ms
*/
#define tCon_10Hz 300 /* ms. */
#define tCon_40Hz 75 /* ms. */
#define tCon_640Hz 7 /* ms. */
#define tCon_1280Hz 4 /* ms. */
#define PORT_A 1 //采集通道A
//#define PORT_B 1 //采集通道B
#define PORT_TEMP 0 //采集温度
#define PORT_JUMP 0 //内短采集
#define PACK_NUM 1 //一次采集的数据包数量
#define FILTER_NUM 0 //滤波数
typedef enum{
RLCS1237_STATUS_IDLE,
RLCS1237_STATUS_START,
RLCS1237_STATUS_DELAY,
RLCS1237_STATUS_READ,
RLCS1237_STATUS_WAIT_READ,
RLCS1237_STATUS_CH_SEL,
RLCS1237_STATUS_STOP,
}RightLowCS1237Status_m;
typedef struct{
RightLowCS1237Status_m Status;
uint32_t CS1237Delay1mSCnt;
int32_t AinA_AD;//AINAad数据
//int32_t AinB_AD;//AINBad数据
int32_t Temp_AD;//温度ad数据
int32_t Jump_AD;//内短ad数据
}
RIGHTLOW_CS1237Var_t;
void RIGHTLOW_CS1237_Init(void);
void RIGHTLOW_CS1237_IrqCallBack(void);
void RIGHTLOW_CS1237DataLoopCollect(void);
void RIGHTLOW_CS12371mSRoutine(void);
void RIGHTLOW_CS1237Start(void);
void RIGHTLOW_CS1237Stop(void);
#endif
Project/HC32F460/source/Module/CS1237/CS1237_RIGHTUP.c
+464
View File
@@ -0,0 +1,464 @@
#include "CS1237_RIGHTUP.h"
#include "Debug.h"
#include "bsp.h"
#include "main.h"
#include "Algorithm.h"
#define CS1237_DOUT_OUT() PORT_OE(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx, Enable)
#define CS1237_DOUT_IN() PORT_OE(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx, Disable)
#define CS1237_DOUT_H() SET_RIGHTUP_CS1237_DOUT()
#define CS1237_DOUT_L() CLR_RIGHTUP_CS1237_DOUT()
#define CS1237_DOUT_GET() GET_RIGHTUP_CS1237_DOUT()
#define CS1237_SCLK_H() SET_RIGHTUP_CS1237_SCLK()
#define CS1237_SCLK_L() CLR_RIGHTUP_CS1237_SCLK()
#define CS1237_5NS(x) delay_5ns(x) //5ns延时
#define CS1237_1US(x) Ddl_Delay1us(x) //1us延时
#define CS1237_1MS(x) Ddl_Delay1ms(x) //1ms延时
#define CS1237IntEnable() ExtInt04IntEnable()
#define CS1237IntDisable() ExtInt04IntDisable()
RIGHTUP_CS1237Var_t RIGHTUP_CS1237Var;
static bool InitFlag;
static bool CS1237IrqFlag;
static bool BuildDelay;
static uint8_t CS1237Port;
static uint8_t CS1237Hz;
static uint8_t CS1237PGA;
extern void RIGHTUP_CS1237AinADataProcessCallBack(int32_t AD);
/** cs1237 时序时钟*/
static void CS1237_Clock(void)
{
CS1237_SCLK_H();
CS1237_5NS(60);
CS1237_SCLK_L();
CS1237_5NS(60);
}
/** cs1237 休眠*/
static void CS1237_Sleep(void)
{
CS1237_SCLK_H();
CS1237_1US(200);
}
/** cs1237 唤醒*/
static void CS1237_WakeUp(void)
{
CS1237_SCLK_L();
CS1237_1US(20);
}
/**设置CS1237寄存器*/
static void Set_CS1237_Config(uint8_t ad_reg)
{
uint16_t bit_cout = 0;
uint8_t reg_temp = 0x00;
//DOUT由高变低之后开始读取数据
CS1237_DOUT_OUT();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237_SCLK_L(); //时钟拉低
RIGHTUP_CS1237Var.CS1237Delay1mSCnt = 300;
CS1237IrqFlag = false;
while(CS1237IrqFlag == false) //等待芯片准备好
{
if(RIGHTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
//DBG_LOG("RIGHTUP CS1237 Preparation Timeout...\r\n");
return; // 超时退出
}
}
CS1237IntDisable();
CS1237IrqFlag = false;
/* clk1-clk26 写期间不需要操作*/
for (bit_cout = 0; bit_cout < 26; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
/* clk27 DOUT输出拉高*/
CS1237_Clock(); //给一周期时钟
CS1237_DOUT_H();
/* clk28 - clk29 发送写寄存器命令字 */
CS1237_Clock(); //给一周期时钟
CS1237_Clock(); //给一周期时钟
/* clk30 - clk36 发送写寄存器命令字 */
CS1237_DOUT_OUT();
reg_temp = WRITE_CONFIG_CMD << 1; //命令长度为 7bits (写0x65)左移1位
for (bit_cout = 0; bit_cout < 7; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* clk37写寄存器模式还是输出 */
CS1237_Clock();
/* clk38 ~ clk45 写入寄存器值 */
reg_temp = ad_reg;//要配件的寄存器数值
for (bit_cout = 0; bit_cout < 8; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* 8: clk46 */
CS1237_Clock();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237IntEnable();
return ;
}
/**读CS1237寄存器*/
static int32_t Read_CS1237_Config(void)
{
uint16_t bit_cout = 0;
uint8_t reg_temp = 0x00;
//DOUT由高变低之后开始读取数据
CS1237_DOUT_OUT();
CS1237_DOUT_H();
CS1237_DOUT_IN();
CS1237_SCLK_L(); //时钟拉低
RIGHTUP_CS1237Var.CS1237Delay1mSCnt = 300;
CS1237IrqFlag = false;
while(CS1237IrqFlag == false) //等待芯片准备好
{
if(RIGHTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
//DBG_LOG("RIGHTUP CS1237 Preparation Timeout...\r\n");
return 0; // 超时退出
}
}
CS1237IntDisable();
CS1237IrqFlag = false;
/* clk1-clk26 写期间不需要操作*/
for (bit_cout = 0; bit_cout < 26; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
/* clk27 DOUT输出拉高*/
CS1237_Clock(); //给一周期时钟
CS1237_DOUT_H();
/* clk28 - clk29 发送写寄存器命令字 */
CS1237_Clock(); //给一周期时钟
CS1237_Clock(); //给一周期时钟
/* clk30 - clk36 发送读寄存器命令字 */
CS1237_DOUT_OUT();
reg_temp = READ_CONFIG_CMD << 1; //命令长度为 7bits (写0x56)左移1位
for (bit_cout = 0; bit_cout < 7; bit_cout++)
{
if (reg_temp & 0x80) //MSB
{
CS1237_DOUT_H();
}
else
{
CS1237_DOUT_L();
}
reg_temp = reg_temp << 1;
CS1237_Clock();
}
/* clk37，读寄存器模式改输入 */
CS1237_Clock();
CS1237_DOUT_IN();
for (bit_cout = 0; bit_cout < 8; bit_cout++)
{
CS1237_SCLK_H();
reg_temp <<= 1; //左移1位准备接受数据 初始默认0
CS1237_5NS(60);//延时300ns
if(CS1237_DOUT_GET() == true) //有数值则累加
reg_temp |= 1;
CS1237_SCLK_L();
CS1237_5NS(60);
}
/* 8: clk46 */
CS1237_Clock();
CS1237_DOUT_IN();
CS1237_DOUT_H();
CS1237IntEnable();
return reg_temp ;
}
/**读取CS1237的AD数*/
static int32_t Read_CS1237_Ad_Data(void)
{
uint16_t bit_cout = 0;
int32_t data_temp = 0;
/* clk1 ~ clk24 ADC数据*/
data_temp = 0;
for (bit_cout = 0; bit_cout < 24; bit_cout++)
{
CS1237_SCLK_H();
data_temp <<= 1; //左移1位准备接受数据 初始默认0
CS1237_5NS(60);//延时300ns
if(CS1237_DOUT_GET() == true) //有数值则累加
data_temp |= 1;
CS1237_SCLK_L();
CS1237_5NS(60);
}
/* clk25 ~ clk27 */
for (bit_cout = 24; bit_cout < 27; bit_cout++)
{
CS1237_Clock(); //给一周期时钟
}
CS1237_DOUT_H();
CS1237_SCLK_L();
if(data_temp > 0x7FFFFF) //取24位
{
data_temp |= 0xFF000000;
}
return data_temp;
}
void RIGHTUP_CS1237_IrqCallBack(void)
{
CS1237IrqFlag = true;
}
void RIGHTUP_CS1237_Init(void)
{
CS1237IrqFlag = false;
BuildDelay = false;
RIGHTUP_CS1237Var.AinA_AD = 0;
RIGHTUP_CS1237Var.Temp_AD = 0;
RIGHTUP_CS1237Var.Jump_AD = 0;
CS1237IntEnable();
CS1237Port = CH_SEL_A;
CS1237Hz = SPEED_SEL_640Hz;
CS1237PGA = PGA_SEL_128;
uint8_t read_reg = 0x00;
uint8_t set_reg = REFO_ON | CS1237Hz | CS1237PGA | CS1237Port;
CS1237_1MS(20);
Set_CS1237_Config(set_reg);
CS1237_1MS(20);
read_reg = Read_CS1237_Config();
CS1237_1MS(20);
if(read_reg != set_reg){
DBG_LOG("RIGHTUP CS1237 Init ERR...\r\n");
//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
InitFlag = true;
}
else {
DBG_LOG("RIGHTUP CS1237 Init OK...\r\n");
//DBG_LOG("set_reg = %02X\tread_reg = %02X\r\n",set_reg,read_reg);
CS1237Port = read_reg & 0x03;
InitFlag = true;
}
CS1237IntDisable();
}
void RIGHTUP_CS1237DataLoopCollect(void)
{
static int32_t ad_array[PACK_NUM];
static uint8_t adcnt;
static uint8_t TimeOutmagcnt;
switch(RIGHTUP_CS1237Var.Status) {
case RUCS1237_STATUS_IDLE:{
break;}
case RUCS1237_STATUS_START:{
memset(&ad_array, 0x00, sizeof(ad_array));
adcnt = 0;
TimeOutmagcnt = 0;
memset(&RIGHTUP_CS1237Var, NULL, sizeof(RIGHTUP_CS1237Var));
if(BuildDelay == true)
{
BuildDelay = false;
if(CS1237Hz == SPEED_SEL_10Hz){
RIGHTUP_CS1237Var.CS1237Delay1mSCnt = tCon_10Hz;
}
if(CS1237Hz == SPEED_SEL_40Hz){
RIGHTUP_CS1237Var.CS1237Delay1mSCnt = tCon_40Hz;
}
if(CS1237Hz == SPEED_SEL_640Hz){
RIGHTUP_CS1237Var.CS1237Delay1mSCnt = tCon_640Hz;
}
if(CS1237Hz == SPEED_SEL6_1280Hz){
RIGHTUP_CS1237Var.CS1237Delay1mSCnt = tCon_1280Hz;
}
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_DELAY;
}
else
{
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_READ;
}
break;}
case RUCS1237_STATUS_DELAY:{
if(RIGHTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_READ;
}
break;}
case RUCS1237_STATUS_READ:{
CS1237IrqFlag = false;
RIGHTUP_CS1237Var.CS1237Delay1mSCnt = 100;
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_WAIT_READ;
break;}
case RUCS1237_STATUS_WAIT_READ:{
if(RIGHTUP_CS1237Var.CS1237Delay1mSCnt <= 0){
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_READ;
TimeOutmagcnt++;
}
if(CS1237IrqFlag == true){
CS1237IrqFlag = false;
ad_array[adcnt++] = Read_CS1237_Ad_Data();
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_READ;
}
if(TimeOutmagcnt >= PACK_NUM){
TimeOutmagcnt = 0;
if(adcnt > 0){
if(CS1237Port == CH_SEL_A){
RIGHTUP_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
RIGHTUP_CS1237AinADataProcessCallBack(RIGHTUP_CS1237Var.AinA_AD);
}
if(CS1237Port == CH_SEL_TEMP){
RIGHTUP_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
}
if(CS1237Port == CH_SEL_JUMP){
RIGHTUP_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
}
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_CH_SEL;
}
else{
if(CS1237Port == CH_SEL_A){
DBG_LOG("RIGHTUP CS1237 CHA TimeOut...\r\n");
}
if(CS1237Port == CH_SEL_TEMP){
DBG_LOG("RIGHTUP CS1237 Temp TimeOut...\r\n");
}
if(CS1237Port == CH_SEL_JUMP){
DBG_LOG("RIGHTUP CS1237 Jump TimeOut...\r\n");
}
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_CH_SEL;
}
}
if(adcnt >= PACK_NUM){
if(CS1237Port == CH_SEL_A){
RIGHTUP_CS1237Var.AinA_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
RIGHTUP_CS1237AinADataProcessCallBack(RIGHTUP_CS1237Var.AinA_AD);
}
if(CS1237Port == CH_SEL_TEMP){
RIGHTUP_CS1237Var.Temp_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237TempDataProcessCallBack(LEFTLOW_CS1237Var.Temp_AD);
}
if(CS1237Port == CH_SEL_JUMP){
RIGHTUP_CS1237Var.Jump_AD = IntFilter_32t(ad_array, adcnt, FILTER_NUM);
//CS1237JumpDataProcessCallBack(LEFTLOW_CS1237Var.Jump_AD);
}
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_CH_SEL;
}
break;}
case RUCS1237_STATUS_CH_SEL:{
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_STOP;
BuildDelay = false;
uint8_t read_reg;
if(CS1237Port == CH_SEL_A){
#if(PORT_TEMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
CS1237Port = CH_SEL_TEMP;
BuildDelay = true;
break;
#endif
#if(PORT_JUMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_JUMP);
CS1237Port = CH_SEL_JUMP;
BuildDelay = true;
break;
#endif
}
if(CS1237Port == CH_SEL_TEMP){
#if(PORT_JUMP == 1)
read_reg = Read_CS1238_Config();
Set_CS1238_Config((read_reg & 0xFC) | CH_SEL_JUMP);
CS1238Port = CH_SEL_JUMP;
BuildDelay = true;
break;
#endif
#if(PORT_A == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
CS1237Port = CH_SEL_A;
BuildDelay = true;
break;
#endif
}
if(CS1237Port == CH_SEL_JUMP){
#if(PORT_A == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_A);
CS1237Port = CH_SEL_A;
BuildDelay = true;
break;
#endif
#if(PORT_TEMP == 1)
read_reg = Read_CS1237_Config();
Set_CS1237_Config((read_reg & 0xFC) | CH_SEL_TEMP);
CS1237Port = CH_SEL_TEMP;
BuildDelay = true;
break;
#endif
}
break;}
case RUCS1237_STATUS_STOP:{
RIGHTUP_CS1237Stop();
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_IDLE;
//RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_START;//持续工作
break;}
}
}
void RIGHTUP_CS12371mSRoutine(void)
{
if(RIGHTUP_CS1237Var.CS1237Delay1mSCnt > 0)
RIGHTUP_CS1237Var.CS1237Delay1mSCnt--;
}
void RIGHTUP_CS1237Start(void)
{
CS1237_WakeUp();
CS1237_1MS(2);
BuildDelay = true;
CS1237IntEnable();
if(!InitFlag){
RIGHTUP_CS1237_Init();
return;
}
RIGHTUP_CS1237Var.Status = RUCS1237_STATUS_START;
}
void RIGHTUP_CS1237Stop(void)
{
CS1237IntDisable();
//CS1237_Sleep();
}
Project/HC32F460/source/Module/CS1237/CS1237_RIGHTUP.h
+80
View File
@@ -0,0 +1,80 @@
#include "bsp.h"
#ifndef _CS1237_RIGHTUP_H_
#define _CS1237_RIGHTUP_H_
#define READ_CONFIG_CMD 0x56
#define WRITE_CONFIG_CMD 0x65
#define CONFIG_RST 0x0C
#define REFO_OFF 0x40
#define REFO_ON 0x00
#define SPEED_SEL_10Hz 0x00
#define SPEED_SEL_40Hz 0x10
#define SPEED_SEL_640Hz 0x20
#define SPEED_SEL6_1280Hz 0x30
#define PGA_SEL_1 0x00
#define PGA_SEL_2 0x04
#define PGA_SEL_64 0x08
#define PGA_SEL_128 0x0C
#define CH_SEL_A 0x00
//#define CH_SEL_B 0x01
#define CH_SEL_TEMP 0x02
#define CH_SEL_JUMP 0x03
/*Definition of conversion time corresponding to repeatability setting*/
/*
10Hz //建立时间300ms
40Hz //建立时间75ms
640Hz //建立时间6.25ms
1280Hz //建立时间3.125ms
*/
#define tCon_10Hz 300 /* ms. */
#define tCon_40Hz 75 /* ms. */
#define tCon_640Hz 7 /* ms. */
#define tCon_1280Hz 4 /* ms. */
#define PORT_A 1 //采集通道A
//#define PORT_B 1 //采集通道B
#define PORT_TEMP 0 //采集温度
#define PORT_JUMP 0 //内短采集
#define PACK_NUM 1 //一次采集的数据包数量
#define FILTER_NUM 0 //滤波数
typedef enum{
RUCS1237_STATUS_IDLE,
RUCS1237_STATUS_START,
RUCS1237_STATUS_DELAY,
RUCS1237_STATUS_READ,
RUCS1237_STATUS_WAIT_READ,
RUCS1237_STATUS_CH_SEL,
RUCS1237_STATUS_STOP,
}RightUpCS1237Status_m;
typedef struct{
RightUpCS1237Status_m Status;
uint32_t CS1237Delay1mSCnt;
int32_t AinA_AD;//AINAad数据
//int32_t AinB_AD;//AINBad数据
int32_t Temp_AD;//温度ad数据
int32_t Jump_AD;//内短ad数据
}
RIGHTUP_CS1237Var_t;
void RIGHTUP_CS1237_Init(void);
void RIGHTUP_CS1237_IrqCallBack(void);
void RIGHTUP_CS1237DataLoopCollect(void);
void RIGHTUP_CS12371mSRoutine(void);
void RIGHTUP_CS1237Start(void);
void RIGHTUP_CS1237Stop(void);
#endif
Project/HC32F460/source/Module/SX127x/sx127x.c
+589
View File
@@ -0,0 +1,589 @@
#include "sx127x.h"
#include "Debug.h"
#if (LORA_MODULE == SX1278W1)
Sx1276Type_t LoRaPara = {
.ucChannel = 0,
.dwFreqHz = FREQ_CENT,
.ucPower = 20,
.SignalBw = SX1276_BW_250K,
.SpreadFactor = SX1276_SF_512,
.ErrorCoding = SX1276_EC_4_6,
.RegPreamble = 10,
.ucOpModePrev = RFLR_OPMODE_STANDBY,
.bAntSwPrev = RF_ANT_RECEIVER,
.RegBuff = 0,
.State = SX1276_IDLE,
.ucRxPacketSize = 0,
.ucTxPacketSize = 0,
.RxCallBack = NULL,
};
void LoraReset(void)
{
LORA_RESET_CLR();
Ddl_Delay1ms(1);
LORA_RESET_SET();
}
/////////////////////////////////////////////////
void SX1276SetAntSw(Sx1276AntStatus_m Status)
{
switch(Status){
case RF_ANT_TRANSMITTER:
LORA_ANTTXEN();
break;
case RF_ANT_RECEIVER:
LORA_ANTRXEN();
break;
case RF_ANT_CLOSE:
LORA_ANTCLOSE();
break;
}
}
void SX1276ReadBuffer(uint8_t ucAddr, uint8_t *pucBuff, uint8_t ucLen)
{
uint8_t ucCnt;
LORA_SPI_NSS_CLR();
LORA_SPI_READ_WRITE(ucAddr & 0x7F);
for( ucCnt = 0; ucCnt < ucLen; ucCnt++ ){
pucBuff[ucCnt] = LORA_SPI_READ_WRITE(0);
}
LORA_SPI_NSS_SET();
}
void SX1276WriteBuffer(uint8_t ucAddr, uint8_t *pucBuff, uint8_t ucLen)
{
uint8_t ucCnt;
LORA_SPI_NSS_CLR();
LORA_SPI_READ_WRITE(ucAddr | 0x80);
for( ucCnt = 0; ucCnt < ucLen; ucCnt++ ){
LORA_SPI_READ_WRITE(pucBuff[ucCnt]);
}
LORA_SPI_NSS_SET();
}
void SX1276Write(uint8_t ucAddr, uint8_t ucData)
{
SX1276WriteBuffer(ucAddr, &ucData, 1);
}
void SX1276Read(uint8_t ucAddr, uint8_t * pucData)
{
SX1276ReadBuffer(ucAddr, pucData, 1);
}
void SX1276WriteFifo(uint8_t *pucBuff, uint8_t ucLen)
{
SX1276WriteBuffer(0, pucBuff, ucLen);
}
void SX1276ReadFifo(uint8_t *pucBuff, uint8_t ucLen)
{
SX1276ReadBuffer(0, pucBuff, ucLen);
}
/////////////////////////////////////////////////
void SX1276LoRaSetNbTrigPeaks(uint8_t ucValue)
{
SX1276Read(0x31, &(LoRaPara.RegBuff.RegTestReserved31));
LoRaPara.RegBuff.RegTestReserved31 = (LoRaPara.RegBuff.RegTestReserved31 & 0xF8) | ucValue;
SX1276Write(0x31, LoRaPara.RegBuff.RegTestReserved31 );
}
void SX1276LoRaSetSignalBandwidth(Sx1276BwType Bw)
{
SX1276Read(REG_LR_MODEMCONFIG1, &(LoRaPara.RegBuff.RegModemConfig1));
LoRaPara.RegBuff.RegModemConfig1 = (LoRaPara.RegBuff.RegModemConfig1 & RFLR_MODEMCONFIG1_BW_MASK) | Bw;
SX1276Write(REG_LR_MODEMCONFIG1, LoRaPara.RegBuff.RegModemConfig1);
LoRaPara.SignalBw = Bw;
}
void SX1276LoRaSetSpreadingFactor(Sx1276SpreadFactorType Factor)
{
if (Factor > SX1276_SF_4096){
Factor = SX1276_SF_4096;
}
else if (Factor < SX1276_SF_64){
Factor = SX1276_SF_64;
}
if (Factor == SX1276_SF_64){
SX1276LoRaSetNbTrigPeaks(5);
}
else{
SX1276LoRaSetNbTrigPeaks(3);
}
SX1276Read(REG_LR_MODEMCONFIG2, &(LoRaPara.RegBuff.RegModemConfig2));
LoRaPara.RegBuff.RegModemConfig2 = (LoRaPara.RegBuff.RegModemConfig2 & RFLR_MODEMCONFIG2_SF_MASK ) | Factor;
SX1276Write(REG_LR_MODEMCONFIG2, LoRaPara.RegBuff.RegModemConfig2);
LoRaPara.SpreadFactor = Factor;
}
void SX1276LoRaSetErrorCoding(Sx1276ErrorCodingType Value){
SX1276Read(REG_LR_MODEMCONFIG1, &(LoRaPara.RegBuff.RegModemConfig1));
LoRaPara.RegBuff.RegModemConfig1 = (LoRaPara.RegBuff.RegModemConfig1 & RFLR_MODEMCONFIG1_CODINGRATE_MASK ) | Value;
SX1276Write(REG_LR_MODEMCONFIG1, LoRaPara.RegBuff.RegModemConfig1 );
LoRaPara.ErrorCoding = Value;
}
void SX1276LoRaSetFreqHz(uint32_t dwFreqHz)
{
LoRaPara.dwFreqHz = dwFreqHz;
dwFreqHz = ( uint32_t )( ( double )dwFreqHz / ( double )FREQ_STEP );
LoRaPara.RegBuff.RegFrfMsb = ( uint8_t )( ( dwFreqHz >> 16 ) & 0xFF );
LoRaPara.RegBuff.RegFrfMid = ( uint8_t )( ( dwFreqHz >> 8 ) & 0xFF );
LoRaPara.RegBuff.RegFrfLsb = ( uint8_t )( dwFreqHz & 0xFF );
SX1276WriteBuffer(REG_LR_FRFMSB, &(LoRaPara.RegBuff.RegFrfMsb), 3);
}
void SX1276LoRaSetSymbTimeout(uint16_t ucValue)
{
SX1276ReadBuffer(REG_LR_MODEMCONFIG2, &(LoRaPara.RegBuff.RegModemConfig2), 2);
LoRaPara.RegBuff.RegModemConfig2 = (LoRaPara.RegBuff.RegModemConfig2 & RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK) | (( ucValue >> 8) & ~RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK );
LoRaPara.RegBuff.RegSymbTimeoutLsb = ucValue & 0xFF;
SX1276WriteBuffer(REG_LR_MODEMCONFIG2, &(LoRaPara.RegBuff.RegModemConfig2), 2);
}
void SX1276LoRaSetLowDatarateOptimize(bool bEnable)
{
SX1276Read(REG_LR_MODEMCONFIG3, &(LoRaPara.RegBuff.RegModemConfig3));
LoRaPara.RegBuff.RegModemConfig3 = (LoRaPara.RegBuff.RegModemConfig3 & RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_MASK ) | ( bEnable << 3 );
SX1276Write(REG_LR_MODEMCONFIG3, LoRaPara.RegBuff.RegModemConfig3);
}
void SX1276LoRaSetPAOutput(uint8_t ucOutputPin)
{
SX1276Read(REG_LR_PACONFIG, &(LoRaPara.RegBuff.RegPaConfig));
LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_PASELECT_MASK ) | ucOutputPin;
SX1276Write(REG_LR_PACONFIG, LoRaPara.RegBuff.RegPaConfig );
}
void SX1276LoRaSetPa20dBm(bool bEnable)
{
SX1276Read(REG_LR_PADAC, &(LoRaPara.RegBuff.RegPaDac));
SX1276Read(REG_LR_PACONFIG, &(LoRaPara.RegBuff.RegPaConfig));
if ((LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_PASELECT_PABOOST ) == RFLR_PACONFIG_PASELECT_PABOOST ) {
if( bEnable == true ){
LoRaPara.RegBuff.RegPaDac = 0x87;
}
}
else{
LoRaPara.RegBuff.RegPaDac = 0x84;
}
SX1276Write(REG_LR_PADAC, LoRaPara.RegBuff.RegPaDac );
}
void SX1276LoRaSetRfPower(int8_t sbPower)
{
SX1276Read(REG_LR_PACONFIG, &(LoRaPara.RegBuff.RegPaConfig));
SX1276Read(REG_LR_PADAC, &(LoRaPara.RegBuff.RegPaDac));
if ((LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_PASELECT_PABOOST ) == RFLR_PACONFIG_PASELECT_PABOOST ) {
if ((LoRaPara.RegBuff.RegPaDac & 0x87) == 0x87){
if( sbPower < 5 ){
sbPower = 5;
}
if( sbPower > 20){
sbPower = 20;
}
LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_MAX_POWER_MASK ) | 0x70;
LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_OUTPUTPOWER_MASK ) |
( uint8_t )( ( uint16_t )( sbPower - 5 ) & 0x0F );
}
else{
if( sbPower < 2){
sbPower = 2;
}
if( sbPower > 17){
sbPower = 17;
}
LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_MAX_POWER_MASK ) | 0x70;
LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_OUTPUTPOWER_MASK ) |
( uint8_t )( ( uint16_t )( sbPower - 2 ) & 0x0F );
}
}
else{
if( sbPower < -1){
sbPower = -1;
}
if( sbPower > 14){
sbPower = 14;
}
LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_MAX_POWER_MASK ) | 0x70;
LoRaPara.RegBuff.RegPaConfig = (LoRaPara.RegBuff.RegPaConfig & RFLR_PACONFIG_OUTPUTPOWER_MASK ) |
( uint8_t )( ( uint16_t )( sbPower + 1 ) & 0x0F );
}
SX1276Write(REG_LR_PACONFIG, LoRaPara.RegBuff.RegPaConfig);
LoRaPara.ucPower = sbPower;
}
void SX1276LoRaSetOpMode(Sx1276OpModeType ucOpMode)
{
Sx1276AntStatus_m bAntSwStatus = RF_ANT_RECEIVER;
LoRaPara.ucOpModePrev = LoRaPara.RegBuff.RegOpMode & ~RFLR_OPMODE_MASK;
if( ucOpMode != LoRaPara.ucOpModePrev){
if(ucOpMode == RFLR_OPMODE_TRANSMITTER){
bAntSwStatus = RF_ANT_TRANSMITTER;
}
else if(ucOpMode == RFLR_OPMODE_RECEIVER){
bAntSwStatus = RF_ANT_RECEIVER;
}
else {
bAntSwStatus = RF_ANT_CLOSE;
}
if( bAntSwStatus != LoRaPara.bAntSwPrev ){
LoRaPara.bAntSwPrev = bAntSwStatus;
SX1276SetAntSw(bAntSwStatus);
}
LoRaPara.RegBuff.RegOpMode = (LoRaPara.RegBuff.RegOpMode & RFLR_OPMODE_MASK ) | ucOpMode;
SX1276Write( REG_LR_OPMODE, LoRaPara.RegBuff.RegOpMode);
}
}
////////////////////////////////////////////////////////////////
void Sx1276LoRaEnterRx(void)
{
uint8_t ucCnt;
SX1276LoRaSetOpMode(RFLR_OPMODE_STANDBY);
LoRaPara.RegBuff.RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT | RFLR_IRQFLAGS_VALIDHEADER | RFLR_IRQFLAGS_TXDONE;
SX1276Write(REG_LR_IRQFLAGSMASK, LoRaPara.RegBuff.RegIrqFlagsMask);
LoRaPara.RegBuff.RegHopPeriod = 255;
SX1276Write(REG_LR_HOPPERIOD, LoRaPara.RegBuff.RegHopPeriod );
// RxDone RxTimeout FhssChangeChannel ValidHeader
LoRaPara.RegBuff.RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_00 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_01 | RFLR_DIOMAPPING1_DIO3_01;
// CadDetected ModeReady
LoRaPara.RegBuff.RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_00 | RFLR_DIOMAPPING2_DIO5_00;
SX1276WriteBuffer(REG_LR_DIOMAPPING1, &(LoRaPara.RegBuff.RegDioMapping1), 2);
LoRaPara.RegBuff.RegFifoAddrPtr = LoRaPara.RegBuff.RegFifoRxBaseAddr;
SX1276Write(REG_LR_FIFOADDRPTR, LoRaPara.RegBuff.RegFifoAddrPtr);
SX1276LoRaSetOpMode(RFLR_OPMODE_RECEIVER);
for (ucCnt=0; ucCnt< LORA_BUFF_SIZE; ucCnt++){
LoRaPara.RxTxBuff[ucCnt] = 0;
}
LoRaPara.State = SX1276_IDLE;//COMST_RX
uint8_t temp;
SX1276Read(REG_LR_IRQFLAGS, &temp);
}
/////////////////////////////////////////////////
void Sx1276LoRaInit(void (*RxCallBack)(uint8_t *rBuff, uint8_t rlen))
{
if(RxCallBack != NULL) {
LoRaPara.RxCallBack = RxCallBack;
}
LoraReset();
SX1276LoRaSetOpMode(RFLR_OPMODE_SLEEP);
LoRaPara.RegBuff.RegOpMode = (LoRaPara.RegBuff.RegOpMode & RFLR_OPMODE_LONGRANGEMODE_MASK ) | RFLR_OPMODE_LONGRANGEMODE_ON;
SX1276Write(REG_LR_OPMODE, LoRaPara.RegBuff.RegOpMode );
SX1276LoRaSetOpMode(RFLR_OPMODE_STANDBY);
// RxDone RxTimeout FhssChangeChannel ValidHeader
LoRaPara.RegBuff.RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_00 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_01;
// CadDetected ModeReady
LoRaPara.RegBuff.RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_00 | RFLR_DIOMAPPING2_DIO5_00;
SX1276WriteBuffer(REG_LR_DIOMAPPING1, &(LoRaPara.RegBuff.RegDioMapping1), 2 );
SX1276ReadBuffer(REG_LR_OPMODE, (uint8_t*)&(LoRaPara.RegBuff) + 1, SIZE_OF_REGISTERS);
LoRaPara.State = SX1276_BUSY;
SX1276Read(REG_LR_VERSION, &(LoRaPara.RegBuff.RegVersion));
SX1276ReadBuffer(REG_LR_OPMODE, (uint8_t*)&(LoRaPara.RegBuff) + 1, SIZE_OF_REGISTERS);
LoRaPara.RegBuff.RegLna = RFLR_LNA_GAIN_G1;
SX1276WriteBuffer(REG_LR_OPMODE, (uint8_t*)&(LoRaPara.RegBuff) + 1, SIZE_OF_REGISTERS);
// set the RF settings
SX1276LoRaSetFreqHz(LoRaPara.dwFreqHz);
//REG_LR_MODEMCONFIG1
SX1276Read(REG_LR_MODEMCONFIG1, &(LoRaPara.RegBuff.RegModemConfig1));
//SignalBandwidth
LoRaPara.RegBuff.RegModemConfig1 = (LoRaPara.RegBuff.RegModemConfig1 & RFLR_MODEMCONFIG1_BW_MASK ) | LoRaPara.SignalBw;
//ErrorCoding
LoRaPara.RegBuff.RegModemConfig1 = (LoRaPara.RegBuff.RegModemConfig1 & RFLR_MODEMCONFIG1_CODINGRATE_MASK ) | LoRaPara.ErrorCoding;
//IMPLICITHEADER
LoRaPara.RegBuff.RegModemConfig1 = LoRaPara.RegBuff.RegModemConfig1 | RFLR_MODEMCONFIG1_IMPLICITHEADER_ON;
SX1276Write(REG_LR_MODEMCONFIG1, LoRaPara.RegBuff.RegModemConfig1);
//REG_LR_MODEMCONFIG2
SX1276Read(REG_LR_MODEMCONFIG2, &(LoRaPara.RegBuff.RegModemConfig2));
//SpreadingFactor
if( LoRaPara.SpreadFactor == SX1276_SF_64){
SX1276LoRaSetNbTrigPeaks(5);
SX1276LoRaSetLowDatarateOptimize(true); //低数据速率设置
}
else{
SX1276LoRaSetNbTrigPeaks(3);
SX1276LoRaSetLowDatarateOptimize(false); //低数据速率设置
}
LoRaPara.RegBuff.RegModemConfig2 = (LoRaPara.RegBuff.RegModemConfig2 & RFLR_MODEMCONFIG2_SF_MASK ) | LoRaPara.SpreadFactor;
//PacketCrcOn
LoRaPara.RegBuff.RegModemConfig2 = (LoRaPara.RegBuff.RegModemConfig2 & RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK ) | SX1276_CRC_ON; //SX1276_CRC_OFF
SX1276Write(REG_LR_MODEMCONFIG2, LoRaPara.RegBuff.RegModemConfig2);
LoRaPara.RegBuff.RegModemConfig2 = 0;
SX1276Read(REG_LR_MODEMCONFIG2, &(LoRaPara.RegBuff.RegModemConfig2));
SX1276LoRaSetSymbTimeout(0x3FF);
LoRaPara.RegBuff.RegPreambleMsb= (LoRaPara.RegPreamble >> 8) & 0x00ff;
LoRaPara.RegBuff.RegPreambleLsb= LoRaPara.RegPreamble & 0x00ff;
SX1276Write(REG_LR_PREAMBLEMSB, LoRaPara.RegBuff.RegPreambleMsb);
SX1276Write(REG_LR_PREAMBLELSB, LoRaPara.RegBuff.RegPreambleLsb);
SX1276Write(REG_LR_PAYLOADLENGTH, LORA_BUFF_SIZE);
SX1276Write(REG_LR_PAYLOADMAXLENGTH, LORA_BUFF_SIZE);
LoRaPara.RegBuff.RegPayloadLength = LORA_BUFF_SIZE;
#ifndef USE_LORA_860_PA
if(LoRaPara.dwFreqHz > 860000000 ){
SX1276LoRaSetPAOutput(RFLR_PACONFIG_PASELECT_RFO);
SX1276LoRaSetPa20dBm(false);
LoRaPara.ucPower = 14;
}
else
#endif
{
SX1276LoRaSetPAOutput(RFLR_PACONFIG_PASELECT_PABOOST);
SX1276LoRaSetPa20dBm(true);
LoRaPara.ucPower = 20;
}
SX1276LoRaSetRfPower(LoRaPara.ucPower);
SX1276LoRaSetOpMode(RFLR_OPMODE_STANDBY);
Sx1276LoRaEnterRx();
}
void IsrSx1276LoRaTxRx(void){
switch (LoRaPara.State){
case SX1276_IDLE:
case SX1276_RX:
// Clear Irq
SET_LORA_RX_LED();
do {
SX1276Write(REG_LR_IRQFLAGS, RFLR_IRQFLAGS_RXDONE);
SX1276Read(REG_LR_IRQFLAGS, &(LoRaPara.RegBuff.RegIrqFlags));
if((LoRaPara.RegBuff.RegIrqFlags & RFLR_IRQFLAGS_RXDONE) != RFLR_IRQFLAGS_RXDONE)
break;
}while(1);
if((LoRaPara.RegBuff.RegIrqFlags & RFLR_IRQFLAGS_PAYLOADCRCERROR ) == RFLR_IRQFLAGS_PAYLOADCRCERROR) {
// Clear Irq
SX1276Write(REG_LR_IRQFLAGS, RFLR_IRQFLAGS_PAYLOADCRCERROR);
LoRaPara.State = SX1276_IDLE;
break;
}
SX1276Read(REG_LR_PKTSNRVALUE, &(LoRaPara.RegBuff.RegPktSnrValue));
SX1276Read(REG_LR_RSSIVALUE, &(LoRaPara.RegBuff.RegRssiValue));
SX1276Read(REG_LR_PKTRSSIVALUE, &(LoRaPara.RegBuff.RegPktRssiValue));
SX1276Read(REG_LR_FIFORXCURRENTADDR, &(LoRaPara.RegBuff.RegFifoRxCurrentAddr));
SX1276Read(REG_LR_NBRXBYTES, &(LoRaPara.RegBuff.RegNbRxBytes));
LoRaPara.ucRxPacketSize = LoRaPara.RegBuff.RegNbRxBytes;
LoRaPara.RegBuff.RegFifoAddrPtr = LoRaPara.RegBuff.RegFifoRxCurrentAddr;
SX1276Write(REG_LR_FIFOADDRPTR, LoRaPara.RegBuff.RegFifoAddrPtr);
SX1276ReadFifo(LoRaPara.RxTxBuff, (LoRaPara.ucRxPacketSize > LORA_BUFF_SIZE) ? LORA_BUFF_SIZE : LoRaPara.ucRxPacketSize);
uint8_t ucLen;
if(LoRaPara.ucRxPacketSize < LORA_BUFF_SIZE) {
ucLen= LoRaPara.ucRxPacketSize;
}
else {
ucLen= LORA_BUFF_SIZE;
}
LoRaPara.RxTxBuff[ucLen] = 0;
if(LoRaPara.RxCallBack != NULL)
LoRaPara.RxCallBack(LoRaPara.RxTxBuff, ucLen);
LoRaPara.ucRxPacketSize = 0;
LoRaPara.State = SX1276_IDLE;
CLR_LORA_RX_LED();
break;
case SX1276_TX:
// Clear Irq
SX1276Write(REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE);
LORA_TXLED_OFF();
Sx1276LoRaEnterRx();
break;
default:
break;
}
}
void Sx1276LoRaLoopHandler(void)
{
if(LORA_GETDIO0() > 0){ // RxDone or TxDone
IsrSx1276LoRaTxRx();
}
}
void Sx1276LoRaSendBuffer(uint8_t* pucBuff, uint8_t ucLen)
{
LoRaPara.State = SX1276_BUSY;
if (ucLen > LORA_BUFF_SIZE){
ucLen = LORA_BUFF_SIZE;
}
LoRaPara.ucTxPacketSize = ucLen;
while(ucLen--){
LoRaPara.RxTxBuff[ucLen] = pucBuff[ucLen];
};
SX1276LoRaSetOpMode(RFLR_OPMODE_STANDBY);
LoRaPara.RegBuff.RegIrqFlagsMask = RFLR_IRQFLAGS_RXTIMEOUT | RFLR_IRQFLAGS_RXDONE | RFLR_IRQFLAGS_PAYLOADCRCERROR | RFLR_IRQFLAGS_VALIDHEADER;
//LoRaPara.RegBuff.RegHopPeriod = 0;
//SX1276Write(REG_LR_HOPPERIOD, LoRaPara.RegBuff.RegHopPeriod);
SX1276Write(REG_LR_IRQFLAGSMASK, LoRaPara.RegBuff.RegIrqFlagsMask);
// Initializes the payload size
LoRaPara.RegBuff.RegPayloadLength = LoRaPara.ucTxPacketSize;
SX1276Write(REG_LR_PAYLOADLENGTH, LoRaPara.RegBuff.RegPayloadLength);
LoRaPara.RegBuff.RegFifoTxBaseAddr = 0x00; // Full buffer used for Tx
SX1276Write(REG_LR_FIFOTXBASEADDR, LoRaPara.RegBuff.RegFifoTxBaseAddr);
LoRaPara.RegBuff.RegFifoAddrPtr = LoRaPara.RegBuff.RegFifoTxBaseAddr;
SX1276Write(REG_LR_FIFOADDRPTR, LoRaPara.RegBuff.RegFifoAddrPtr);
// Write payload buffer to LORA modem
SX1276WriteFifo(LoRaPara.RxTxBuff, LoRaPara.RegBuff.RegPayloadLength);
// TxDone RxTimeout FhssChangeChannel ValidHeader
LoRaPara.RegBuff.RegDioMapping1 = RFLR_DIOMAPPING1_DIO0_01 | RFLR_DIOMAPPING1_DIO1_00 | RFLR_DIOMAPPING1_DIO2_00 | RFLR_DIOMAPPING1_DIO3_01;
// PllLock Mode Ready
LoRaPara.RegBuff.RegDioMapping2 = RFLR_DIOMAPPING2_DIO4_01 | RFLR_DIOMAPPING2_DIO5_00;
SX1276WriteBuffer(REG_LR_DIOMAPPING1, &(LoRaPara.RegBuff.RegDioMapping1), 2);
SX1276LoRaSetOpMode(RFLR_OPMODE_TRANSMITTER);
uint8_t temp;
SX1276Read(REG_LR_IRQFLAGS, &temp);
LORA_TXLED_ON();
LoRaPara.State = SX1276_TX;
}
void Sx1276LoRaSleep(void)
{
SX1276LoRaSetOpMode(RFLR_OPMODE_SLEEP);//RFLR_OPMODE_STANDBY
}
void Sx1276LoRaWakeup(void)
{
Sx1276LoRaEnterRx();
}
////////////////////////////////////////
//配置本层参数的函数
//频道表
const uint32_t gdwSx1276ChannelTbl[SX1276_CHANNEL_MAX]={
FREQ_CENT-FREQ_DEV*8, FREQ_CENT-FREQ_DEV*7, FREQ_CENT-FREQ_DEV*6, FREQ_CENT-FREQ_DEV*5,
FREQ_CENT-FREQ_DEV*4, FREQ_CENT-FREQ_DEV*3, FREQ_CENT-FREQ_DEV*2, FREQ_CENT-FREQ_DEV*1,
FREQ_CENT+FREQ_DEV*0, FREQ_CENT+FREQ_DEV*1, FREQ_CENT+FREQ_DEV*2, FREQ_CENT+FREQ_DEV*3,
FREQ_CENT+FREQ_DEV*4, FREQ_CENT+FREQ_DEV*5, FREQ_CENT+FREQ_DEV*6, FREQ_CENT+FREQ_DEV*7,
FREQ_CENT+FREQ_DEV*8
};
//LORAPT_CHANNEL
uint8_t SX1276LoRaReadChannel(void)
{
return LoRaPara.ucChannel;
}
bool SX1276LoRaWriteChannel(uint8_t Channel)
{
if(Channel > SX1276_CHANNEL_MAX) {
return false;
}
LoRaPara.dwFreqHz = gdwSx1276ChannelTbl[Channel];
SX1276LoRaSetFreqHz(LoRaPara.dwFreqHz);
return true;
}
//LORAPT_FREQ,
uint32_t SX1276LoRaReadFreq(void)
{
return LoRaPara.dwFreqHz;
}
void SX1276LoRaWriteFreq(uint32_t Freq)
{
SX1276LoRaSetFreqHz(Freq);
}
//LORAPT_BW,
uint32_t SX1276LoRaReadBw(void)
{
return LoRaPara.SignalBw;
}
void SX1276LoRaWriteBw(Sx1276BwType SignalBw)
{
LoRaPara.SignalBw = SignalBw;
SX1276LoRaSetSignalBandwidth(SignalBw);
}
//LORAPT_SF,
uint8_t SX1276LoRaReadSf(void)
{
return LoRaPara.SpreadFactor;
}
void SX1276LoRaWriteSf(Sx1276SpreadFactorType SpreadFactor)
{
LoRaPara.SpreadFactor = SpreadFactor;
SX1276LoRaSetSpreadingFactor(LoRaPara.SpreadFactor);
}
//LORAPT_EC,
uint8_t SX1276LoRaReadEc(void)
{
return LoRaPara.ErrorCoding;
}
void SX1276LoRaWriteEc(Sx1276ErrorCodingType ErrorCoding)
{
LoRaPara.ErrorCoding = ErrorCoding;
SX1276LoRaSetErrorCoding(ErrorCoding);
}
//LORAPT_RSSI,
uint32_t SX1276LoRaParaReadRssi(void)
{
uint32_t rssi;
SX1276Read(REG_LR_PKTRSSIVALUE, &(LoRaPara.RegBuff.RegPktRssiValue));
SX1276Read(REG_LR_RSSIVALUE, &(LoRaPara.RegBuff.RegRssiValue));
rssi = (uint16_t)(LoRaPara.RegBuff.RegPktSnrValue)<<16;
rssi |= (uint16_t)(LoRaPara.RegBuff.RegRssiValue)<<8;
rssi |= LoRaPara.RegBuff.RegPktRssiValue;
return rssi;
}
uint8_t SX1276LoRaReadRssiPkt(void)
{
uint8_t RssiPkt;
SX1276Read(REG_LR_PKTRSSIVALUE, &LoRaPara.RegBuff.RegPktRssiValue);
RssiPkt = LoRaPara.RegBuff.RegPktRssiValue;
return RssiPkt;
}
//LORAPT_POWER,
void SX1276LoRaWritePwr(int8_t Pwr)
{
SX1276LoRaSetRfPower(Pwr);
}
//LORAPT_SET_RX,
void SX1276LoRaWriteRx(void)
{
Sx1276LoRaEnterRx();
}
//LORAPT_SET_SLEEP,true-Sleep, false-Wakeup
void SX1276LoRaWriteSleep(bool Sleep)
{
if(Sleep){
Sx1276LoRaSleep();
}
else {
Sx1276LoRaWakeup();
}
}
Sx1276StateType_t SX1276LoRaReadStatus(void)
{
return LoRaPara.State;
}
///////////////RSSI Calc///////////////
void SX1276LoCalcRssiSnr(int16_t *pswRssi, int8_t *psbSnr)
{
int8_t sbSnr= LoRaPara.RegBuff.RegPktSnrValue & 0x80 ? (-1)*((int8_t)(((~LoRaPara.RegBuff.RegPktSnrValue+ 1)& 0xFF)/4)): (~LoRaPara.RegBuff.RegPktSnrValue& 0xFF)/4;
if (*psbSnr > 0) {
*pswRssi= RSSI_OFFSET_LF+ LoRaPara.RegBuff.RegPktRssiValue;
}
else {
*pswRssi= NOISE_ABSOLUTE_ZERO + 10 + SIGNAL_BW_LOG_125KHZ + NOISE_FIGURE_LF + sbSnr;
}
*psbSnr= sbSnr;
}
#endif
Project/HC32F460/source/Module/SX127x/sx127x.h
+789
View File
@@ -0,0 +1,789 @@
#ifndef __SX127X_H
#define __SX127X_H
#include "bsp.h"
//Constant values need to compute the RSSI value
#define RSSI_OFFSET_LF -155
#define RSSI_OFFSET_HF -150
#define NOISE_ABSOLUTE_ZERO -174
#define NOISE_FIGURE_LF 4
#define NOISE_FIGURE_HF 6
#define SIGNAL_BW_LOG_125KHZ 5
//SX1276 definitions
#define XTAL_FREQ 32000000
#define FREQ_STEP 61.03515625
//SX1276 Internal registers Address
#define REG_LR_FIFO 0x00
// Common settings
#define REG_LR_OPMODE 0x01
#define REG_LR_BANDSETTING 0x04
#define REG_LR_FRFMSB 0x06
#define REG_LR_FRFMID 0x07
#define REG_LR_FRFLSB 0x08
// Tx settings
#define REG_LR_PACONFIG 0x09
#define REG_LR_PARAMP 0x0A
#define REG_LR_OCP 0x0B
// Rx settings
#define REG_LR_LNA 0x0C
// LoRa registers
#define REG_LR_FIFOADDRPTR 0x0D
#define REG_LR_FIFOTXBASEADDR 0x0E
#define REG_LR_FIFORXBASEADDR 0x0F
#define REG_LR_FIFORXCURRENTADDR 0x10
#define REG_LR_IRQFLAGSMASK 0x11
#define REG_LR_IRQFLAGS 0x12
#define REG_LR_NBRXBYTES 0x13
#define REG_LR_RXHEADERCNTVALUEMSB 0x14
#define REG_LR_RXHEADERCNTVALUELSB 0x15
#define REG_LR_RXPACKETCNTVALUEMSB 0x16
#define REG_LR_RXPACKETCNTVALUELSB 0x17
#define REG_LR_MODEMSTAT 0x18
#define REG_LR_PKTSNRVALUE 0x19
#define REG_LR_PKTRSSIVALUE 0x1A
#define REG_LR_RSSIVALUE 0x1B
#define REG_LR_HOPCHANNEL 0x1C
#define REG_LR_MODEMCONFIG1 0x1D
#define REG_LR_MODEMCONFIG2 0x1E
#define REG_LR_SYMBTIMEOUTLSB 0x1F
#define REG_LR_PREAMBLEMSB 0x20
#define REG_LR_PREAMBLELSB 0x21
#define REG_LR_PAYLOADLENGTH 0x22
#define REG_LR_PAYLOADMAXLENGTH 0x23
#define REG_LR_HOPPERIOD 0x24
#define REG_LR_FIFORXBYTEADDR 0x25
#define REG_LR_MODEMCONFIG3 0x26
// end of documented register in datasheet
// I/O settings
#define REG_LR_DIOMAPPING1 0x40
#define REG_LR_DIOMAPPING2 0x41
// Version
#define REG_LR_VERSION 0x42
// Additional settings
#define REG_LR_PLLHOP 0x44
#define REG_LR_TCXO 0x4B
#define REG_LR_PADAC 0x4D
#define REG_LR_FORMERTEMP 0x5B
#define REG_LR_BITRATEFRAC 0x5D
#define REG_LR_AGCREF 0x61
#define REG_LR_AGCTHRESH1 0x62
#define REG_LR_AGCTHRESH2 0x63
#define REG_LR_AGCTHRESH3 0x64
//RegOpMode
typedef enum{
RFLR_OPMODE_LONGRANGEMODE_MASK =0x7F,
RFLR_OPMODE_LONGRANGEMODE_OFF =0x00, // Default
RFLR_OPMODE_LONGRANGEMODE_ON =0x80,
RFLR_OPMODE_ACCESSSHAREDREG_MASK =0xBF,
RFLR_OPMODE_ACCESSSHAREDREG_ENABLE =0x40,
RFLR_OPMODE_ACCESSSHAREDREG_DISABLE =0x00, // Default
RFLR_OPMODE_FREQMODE_ACCESS_MASK =0xF7,
RFLR_OPMODE_FREQMODE_ACCESS_LF =0x08, // Default
RFLR_OPMODE_FREQMODE_ACCESS_HF =0x00,
RFLR_OPMODE_MASK =0xF8,
RFLR_OPMODE_SLEEP =0x00,
RFLR_OPMODE_STANDBY =0x01, // Default
RFLR_OPMODE_SYNTHESIZER_TX =0x02,
RFLR_OPMODE_TRANSMITTER =0x03,
RFLR_OPMODE_SYNTHESIZER_RX =0x04,
RFLR_OPMODE_RECEIVER =0x05,
// LoRa specific modes
RFLR_OPMODE_RECEIVER_SINGLE =0x06,
RFLR_OPMODE_CAD =0x07
}Sx1276OpModeType;
//RegBandSetting
#define RFLR_BANDSETTING_MASK 0x3F
#define RFLR_BANDSETTING_AUTO 0x00 // Default
#define RFLR_BANDSETTING_DIV_BY_1 0x40
#define RFLR_BANDSETTING_DIV_BY_2 0x80
#define RFLR_BANDSETTING_DIV_BY_6 0xC0
//RegFrf (MHz)
#define RFLR_FRFMSB_434_MHZ 0x6C // Default
#define RFLR_FRFMID_434_MHZ 0x80 // Default
#define RFLR_FRFLSB_434_MHZ 0x00 // Default
#define RFLR_FRFMSB_863_MHZ 0xD7
#define RFLR_FRFMID_863_MHZ 0xC0
#define RFLR_FRFLSB_863_MHZ 0x00
#define RFLR_FRFMSB_864_MHZ 0xD8
#define RFLR_FRFMID_864_MHZ 0x00
#define RFLR_FRFLSB_864_MHZ 0x00
#define RFLR_FRFMSB_865_MHZ 0xD8
#define RFLR_FRFMID_865_MHZ 0x40
#define RFLR_FRFLSB_865_MHZ 0x00
#define RFLR_FRFMSB_866_MHZ 0xD8
#define RFLR_FRFMID_866_MHZ 0x80
#define RFLR_FRFLSB_866_MHZ 0x00
#define RFLR_FRFMSB_867_MHZ 0xD8
#define RFLR_FRFMID_867_MHZ 0xC0
#define RFLR_FRFLSB_867_MHZ 0x00
#define RFLR_FRFMSB_868_MHZ 0xD9
#define RFLR_FRFMID_868_MHZ 0x00
#define RFLR_FRFLSB_868_MHZ 0x00
#define RFLR_FRFMSB_869_MHZ 0xD9
#define RFLR_FRFMID_869_MHZ 0x40
#define RFLR_FRFLSB_869_MHZ 0x00
#define RFLR_FRFMSB_870_MHZ 0xD9
#define RFLR_FRFMID_870_MHZ 0x80
#define RFLR_FRFLSB_870_MHZ 0x00
#define RFLR_FRFMSB_902_MHZ 0xE1
#define RFLR_FRFMID_902_MHZ 0x80
#define RFLR_FRFLSB_902_MHZ 0x00
#define RFLR_FRFMSB_903_MHZ 0xE1
#define RFLR_FRFMID_903_MHZ 0xC0
#define RFLR_FRFLSB_903_MHZ 0x00
#define RFLR_FRFMSB_904_MHZ 0xE2
#define RFLR_FRFMID_904_MHZ 0x00
#define RFLR_FRFLSB_904_MHZ 0x00
#define RFLR_FRFMSB_905_MHZ 0xE2
#define RFLR_FRFMID_905_MHZ 0x40
#define RFLR_FRFLSB_905_MHZ 0x00
#define RFLR_FRFMSB_906_MHZ 0xE2
#define RFLR_FRFMID_906_MHZ 0x80
#define RFLR_FRFLSB_906_MHZ 0x00
#define RFLR_FRFMSB_907_MHZ 0xE2
#define RFLR_FRFMID_907_MHZ 0xC0
#define RFLR_FRFLSB_907_MHZ 0x00
#define RFLR_FRFMSB_908_MHZ 0xE3
#define RFLR_FRFMID_908_MHZ 0x00
#define RFLR_FRFLSB_908_MHZ 0x00
#define RFLR_FRFMSB_909_MHZ 0xE3
#define RFLR_FRFMID_909_MHZ 0x40
#define RFLR_FRFLSB_909_MHZ 0x00
#define RFLR_FRFMSB_910_MHZ 0xE3
#define RFLR_FRFMID_910_MHZ 0x80
#define RFLR_FRFLSB_910_MHZ 0x00
#define RFLR_FRFMSB_911_MHZ 0xE3
#define RFLR_FRFMID_911_MHZ 0xC0
#define RFLR_FRFLSB_911_MHZ 0x00
#define RFLR_FRFMSB_912_MHZ 0xE4
#define RFLR_FRFMID_912_MHZ 0x00
#define RFLR_FRFLSB_912_MHZ 0x00
#define RFLR_FRFMSB_913_MHZ 0xE4
#define RFLR_FRFMID_913_MHZ 0x40
#define RFLR_FRFLSB_913_MHZ 0x00
#define RFLR_FRFMSB_914_MHZ 0xE4
#define RFLR_FRFMID_914_MHZ 0x80
#define RFLR_FRFLSB_914_MHZ 0x00
#define RFLR_FRFMSB_915_MHZ 0xE4 // Default
#define RFLR_FRFMID_915_MHZ 0xC0 // Default
#define RFLR_FRFLSB_915_MHZ 0x00 // Default
#define RFLR_FRFMSB_916_MHZ 0xE5
#define RFLR_FRFMID_916_MHZ 0x00
#define RFLR_FRFLSB_916_MHZ 0x00
#define RFLR_FRFMSB_917_MHZ 0xE5
#define RFLR_FRFMID_917_MHZ 0x40
#define RFLR_FRFLSB_917_MHZ 0x00
#define RFLR_FRFMSB_918_MHZ 0xE5
#define RFLR_FRFMID_918_MHZ 0x80
#define RFLR_FRFLSB_918_MHZ 0x00
#define RFLR_FRFMSB_919_MHZ 0xE5
#define RFLR_FRFMID_919_MHZ 0xC0
#define RFLR_FRFLSB_919_MHZ 0x00
#define RFLR_FRFMSB_920_MHZ 0xE6
#define RFLR_FRFMID_920_MHZ 0x00
#define RFLR_FRFLSB_920_MHZ 0x00
#define RFLR_FRFMSB_921_MHZ 0xE6
#define RFLR_FRFMID_921_MHZ 0x40
#define RFLR_FRFLSB_921_MHZ 0x00
#define RFLR_FRFMSB_922_MHZ 0xE6
#define RFLR_FRFMID_922_MHZ 0x80
#define RFLR_FRFLSB_922_MHZ 0x00
#define RFLR_FRFMSB_923_MHZ 0xE6
#define RFLR_FRFMID_923_MHZ 0xC0
#define RFLR_FRFLSB_923_MHZ 0x00
#define RFLR_FRFMSB_924_MHZ 0xE7
#define RFLR_FRFMID_924_MHZ 0x00
#define RFLR_FRFLSB_924_MHZ 0x00
#define RFLR_FRFMSB_925_MHZ 0xE7
#define RFLR_FRFMID_925_MHZ 0x40
#define RFLR_FRFLSB_925_MHZ 0x00
#define RFLR_FRFMSB_926_MHZ 0xE7
#define RFLR_FRFMID_926_MHZ 0x80
#define RFLR_FRFLSB_926_MHZ 0x00
#define RFLR_FRFMSB_927_MHZ 0xE7
#define RFLR_FRFMID_927_MHZ 0xC0
#define RFLR_FRFLSB_927_MHZ 0x00
#define RFLR_FRFMSB_928_MHZ 0xE8
#define RFLR_FRFMID_928_MHZ 0x00
#define RFLR_FRFLSB_928_MHZ 0x00
//RegPaConfig
#define RFLR_PACONFIG_PASELECT_MASK 0x7F
#define RFLR_PACONFIG_PASELECT_PABOOST 0x80
#define RFLR_PACONFIG_PASELECT_RFO 0x00 // Default
#define RFLR_PACONFIG_MAX_POWER_MASK 0x8F
#define RFLR_PACONFIG_OUTPUTPOWER_MASK 0xF0
//RegPaRamp
#define RFLR_PARAMP_TXBANDFORCE_MASK 0xEF
#define RFLR_PARAMP_TXBANDFORCE_BAND_SEL 0x10
#define RFLR_PARAMP_TXBANDFORCE_AUTO 0x00 // Default
#define RFLR_PARAMP_MASK 0xF0
#define RFLR_PARAMP_3400_US 0x00
#define RFLR_PARAMP_2000_US 0x01
#define RFLR_PARAMP_1000_US 0x02
#define RFLR_PARAMP_0500_US 0x03
#define RFLR_PARAMP_0250_US 0x04
#define RFLR_PARAMP_0125_US 0x05
#define RFLR_PARAMP_0100_US 0x06
#define RFLR_PARAMP_0062_US 0x07
#define RFLR_PARAMP_0050_US 0x08
#define RFLR_PARAMP_0040_US 0x09 // Default
#define RFLR_PARAMP_0031_US 0x0A
#define RFLR_PARAMP_0025_US 0x0B
#define RFLR_PARAMP_0020_US 0x0C
#define RFLR_PARAMP_0015_US 0x0D
#define RFLR_PARAMP_0012_US 0x0E
#define RFLR_PARAMP_0010_US 0x0F
//RegOcp
#define RFLR_OCP_MASK 0xDF
#define RFLR_OCP_ON 0x20 // Default
#define RFLR_OCP_OFF 0x00
#define RFLR_OCP_TRIM_MASK 0xE0
#define RFLR_OCP_TRIM_045_MA 0x00
#define RFLR_OCP_TRIM_050_MA 0x01
#define RFLR_OCP_TRIM_055_MA 0x02
#define RFLR_OCP_TRIM_060_MA 0x03
#define RFLR_OCP_TRIM_065_MA 0x04
#define RFLR_OCP_TRIM_070_MA 0x05
#define RFLR_OCP_TRIM_075_MA 0x06
#define RFLR_OCP_TRIM_080_MA 0x07
#define RFLR_OCP_TRIM_085_MA 0x08
#define RFLR_OCP_TRIM_090_MA 0x09
#define RFLR_OCP_TRIM_095_MA 0x0A
#define RFLR_OCP_TRIM_100_MA 0x0B // Default
#define RFLR_OCP_TRIM_105_MA 0x0C
#define RFLR_OCP_TRIM_110_MA 0x0D
#define RFLR_OCP_TRIM_115_MA 0x0E
#define RFLR_OCP_TRIM_120_MA 0x0F
#define RFLR_OCP_TRIM_130_MA 0x10
#define RFLR_OCP_TRIM_140_MA 0x11
#define RFLR_OCP_TRIM_150_MA 0x12
#define RFLR_OCP_TRIM_160_MA 0x13
#define RFLR_OCP_TRIM_170_MA 0x14
#define RFLR_OCP_TRIM_180_MA 0x15
#define RFLR_OCP_TRIM_190_MA 0x16
#define RFLR_OCP_TRIM_200_MA 0x17
#define RFLR_OCP_TRIM_210_MA 0x18
#define RFLR_OCP_TRIM_220_MA 0x19
#define RFLR_OCP_TRIM_230_MA 0x1A
#define RFLR_OCP_TRIM_240_MA 0x1B
//RegLna
#define RFLR_LNA_GAIN_MASK 0x1F
#define RFLR_LNA_GAIN_G1 0x20 // Default
#define RFLR_LNA_GAIN_G2 0x40
#define RFLR_LNA_GAIN_G3 0x60
#define RFLR_LNA_GAIN_G4 0x80
#define RFLR_LNA_GAIN_G5 0xA0
#define RFLR_LNA_GAIN_G6 0xC0
#define RFLR_LNA_BOOST_LF_MASK 0xE7
#define RFLR_LNA_BOOST_LF_DEFAULT 0x00 // Default
#define RFLR_LNA_BOOST_LF_GAIN 0x08
#define RFLR_LNA_BOOST_LF_IP3 0x10
#define RFLR_LNA_BOOST_LF_BOOST 0x18
#define RFLR_LNA_RXBANDFORCE_MASK 0xFB
#define RFLR_LNA_RXBANDFORCE_BAND_SEL 0x04
#define RFLR_LNA_RXBANDFORCE_AUTO 0x00 // Default
#define RFLR_LNA_BOOST_HF_MASK 0xFC
#define RFLR_LNA_BOOST_HF_OFF 0x00 // Default
#define RFLR_LNA_BOOST_HF_ON 0x03
//RegFifoAddrPtr
#define RFLR_FIFOADDRPTR 0x00 // Default
//RegFifoTxBaseAddr
#define RFLR_FIFOTXBASEADDR 0x80 // Default
//RegFifoTxBaseAddr
#define RFLR_FIFORXBASEADDR 0x00 // Default
//RegFifoRxCurrentAddr (Read Only)
//RegIrqFlagsMask
#define RFLR_IRQFLAGS_RXTIMEOUT_MASK 0x80
#define RFLR_IRQFLAGS_RXDONE_MASK 0x40
#define RFLR_IRQFLAGS_PAYLOADCRCERROR_MASK 0x20
#define RFLR_IRQFLAGS_VALIDHEADER_MASK 0x10
#define RFLR_IRQFLAGS_TXDONE_MASK 0x08
#define RFLR_IRQFLAGS_CADDONE_MASK 0x04
#define RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL_MASK 0x02
#define RFLR_IRQFLAGS_CADDETECTED_MASK 0x01
//RegIrqFlags
#define RFLR_IRQFLAGS_RXTIMEOUT 0x80
#define RFLR_IRQFLAGS_RXDONE 0x40
#define RFLR_IRQFLAGS_PAYLOADCRCERROR 0x20
#define RFLR_IRQFLAGS_VALIDHEADER 0x10
#define RFLR_IRQFLAGS_TXDONE 0x08
#define RFLR_IRQFLAGS_CADDONE 0x04
#define RFLR_IRQFLAGS_FHSSCHANGEDCHANNEL 0x02
#define RFLR_IRQFLAGS_CADDETECTED 0x01
//RegModemStat (Read Only)
#define RFLR_MODEMSTAT_RX_CR_MASK 0x1F
#define RFLR_MODEMSTAT_MODEM_STATUS_MASK 0xE0
//RegModemConfig1
#define RFLR_MODEMCONFIG1_BW_MASK 0x0F
#define RFLR_MODEMCONFIG1_BW_7_81_KHZ 0x00
#define RFLR_MODEMCONFIG1_BW_10_41_KHZ 0x10
#define RFLR_MODEMCONFIG1_BW_15_62_KHZ 0x20
#define RFLR_MODEMCONFIG1_BW_20_83_KHZ 0x30
#define RFLR_MODEMCONFIG1_BW_31_25_KHZ 0x40
#define RFLR_MODEMCONFIG1_BW_41_66_KHZ 0x50
#define RFLR_MODEMCONFIG1_BW_62_50_KHZ 0x60
#define RFLR_MODEMCONFIG1_BW_125_KHZ 0x70 // Default
#define RFLR_MODEMCONFIG1_BW_250_KHZ 0x80
#define RFLR_MODEMCONFIG1_BW_500_KHZ 0x90
#define RFLR_MODEMCONFIG1_CODINGRATE_MASK 0xF1
#define RFLR_MODEMCONFIG1_CODINGRATE_4_5 0x02
#define RFLR_MODEMCONFIG1_CODINGRATE_4_6 0x04 // Default
#define RFLR_MODEMCONFIG1_CODINGRATE_4_7 0x06
#define RFLR_MODEMCONFIG1_CODINGRATE_4_8 0x08
#define RFLR_MODEMCONFIG1_IMPLICITHEADER_MASK 0xFE
#define RFLR_MODEMCONFIG1_IMPLICITHEADER_ON 0x00
#define RFLR_MODEMCONFIG1_IMPLICITHEADER_OFF 0x01 // Default
//RegModemConfig2
#define RFLR_MODEMCONFIG2_SF_MASK 0x0F
#define RFLR_MODEMCONFIG2_SF_6 0x60
#define RFLR_MODEMCONFIG2_SF_7 0x70 // Default
#define RFLR_MODEMCONFIG2_SF_8 0x80
#define RFLR_MODEMCONFIG2_SF_9 0x90
#define RFLR_MODEMCONFIG2_SF_10 0xA0
#define RFLR_MODEMCONFIG2_SF_11 0xB0
#define RFLR_MODEMCONFIG2_SF_12 0xC0
#define RFLR_MODEMCONFIG2_TXCONTINUOUSMODE_MASK 0xF7
#define RFLR_MODEMCONFIG2_TXCONTINUOUSMODE_ON 0x08
#define RFLR_MODEMCONFIG2_TXCONTINUOUSMODE_OFF 0x00
#define RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK 0xFB
#define RFLR_MODEMCONFIG2_RXPAYLOADCRC_ON 0x04
#define RFLR_MODEMCONFIG2_RXPAYLOADCRC_OFF 0x00 // Default
#define RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK 0xFC
#define RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB 0x00 // Default
//RegHopChannel (Read Only)
#define RFLR_HOPCHANNEL_PLL_LOCK_TIMEOUT_MASK 0x7F
#define RFLR_HOPCHANNEL_PLL_LOCK_FAIL 0x80
#define RFLR_HOPCHANNEL_PLL_LOCK_SUCCEED 0x00 // Default
#define RFLR_HOPCHANNEL_PAYLOAD_CRC16_MASK 0xBF
#define RFLR_HOPCHANNEL_PAYLOAD_CRC16_ON 0x40
#define RFLR_HOPCHANNEL_PAYLOAD_CRC16_OFF 0x00 // Default
#define RFLR_HOPCHANNEL_CHANNEL_MASK 0x3F
//RegSymbTimeoutLsb
#define RFLR_SYMBTIMEOUTLSB_SYMBTIMEOUT 0x64 // Default
//RegPreambleLengthMsb
#define RFLR_PREAMBLELENGTHMSB 0x00 // Default
//RegPreambleLengthLsb
#define RFLR_PREAMBLELENGTHLSB 0x08 // Default
//RegPayloadLength
#define RFLR_PAYLOADLENGTH 0x0E // Default
//RegPayloadMaxLength
#define RFLR_PAYLOADMAXLENGTH 0xFF // Default
//RegHopPeriod
#define RFLR_HOPPERIOD_FREQFOPPINGPERIOD 0x00 // Default
//RegDioMapping1
//DIO0
#define RFLR_DIOMAPPING1_DIO0_MASK 0x3F
#define RFLR_DIOMAPPING1_DIO0_00 0x00 // Default
#define RFLR_DIOMAPPING1_DIO0_01 0x40
#define RFLR_DIOMAPPING1_DIO0_10 0x80
#define RFLR_DIOMAPPING1_DIO0_11 0xC0
//DIO1
#define RFLR_DIOMAPPING1_DIO1_MASK 0xCF
#define RFLR_DIOMAPPING1_DIO1_00 0x00 // Default
#define RFLR_DIOMAPPING1_DIO1_01 0x10
#define RFLR_DIOMAPPING1_DIO1_10 0x20
#define RFLR_DIOMAPPING1_DIO1_11 0x30
//DIO2
#define RFLR_DIOMAPPING1_DIO2_MASK 0xF3
#define RFLR_DIOMAPPING1_DIO2_00 0x00 // Default
#define RFLR_DIOMAPPING1_DIO2_01 0x04
#define RFLR_DIOMAPPING1_DIO2_10 0x08
#define RFLR_DIOMAPPING1_DIO2_11 0x0C
//DIO3
#define RFLR_DIOMAPPING1_DIO3_MASK 0xFC
#define RFLR_DIOMAPPING1_DIO3_00 0x00 // Default
#define RFLR_DIOMAPPING1_DIO3_01 0x01
#define RFLR_DIOMAPPING1_DIO3_10 0x02
#define RFLR_DIOMAPPING1_DIO3_11 0x03
//RegDioMapping2
//DIO4
#define RFLR_DIOMAPPING2_DIO4_MASK 0x3F
#define RFLR_DIOMAPPING2_DIO4_00 0x00 // Default
#define RFLR_DIOMAPPING2_DIO4_01 0x40
#define RFLR_DIOMAPPING2_DIO4_10 0x80
#define RFLR_DIOMAPPING2_DIO4_11 0xC0
//DIO5
#define RFLR_DIOMAPPING2_DIO5_MASK 0xCF
#define RFLR_DIOMAPPING2_DIO5_00 0x00 // Default
#define RFLR_DIOMAPPING2_DIO5_01 0x10
#define RFLR_DIOMAPPING2_DIO5_10 0x20
#define RFLR_DIOMAPPING2_DIO5_11 0x30
//MAP
#define RFLR_DIOMAPPING2_MAP_MASK 0xFE
#define RFLR_DIOMAPPING2_MAP_PREAMBLEDETECT 0x01
#define RFLR_DIOMAPPING2_MAP_RSSI 0x00 // Default
// RegPllHop
#define RFLR_PLLHOP_FASTHOP_MASK 0x7F
#define RFLR_PLLHOP_FASTHOP_ON 0x80
#define RFLR_PLLHOP_FASTHOP_OFF 0x00 // Default
//RegTcxo
#define RFLR_TCXO_TCXOINPUT_MASK 0xEF
#define RFLR_TCXO_TCXOINPUT_ON 0x10
#define RFLR_TCXO_TCXOINPUT_OFF 0x00 // Default
//RegPaDac
#define RFLR_PADAC_20DBM_MASK 0xF8
#define RFLR_PADAC_20DBM_ON 0x07
#define RFLR_PADAC_20DBM_OFF 0x04 // Default
//RegPll
#define RFLR_PLL_BANDWIDTH_MASK 0x3F
#define RFLR_PLL_BANDWIDTH_75 0x00
#define RFLR_PLL_BANDWIDTH_150 0x40
#define RFLR_PLL_BANDWIDTH_225 0x80
#define RFLR_PLL_BANDWIDTH_300 0xC0 // Default
//RegPllLowPn
#define RFLR_PLLLOWPN_BANDWIDTH_MASK 0x3F
#define RFLR_PLLLOWPN_BANDWIDTH_75 0x00
#define RFLR_PLLLOWPN_BANDWIDTH_150 0x40
#define RFLR_PLLLOWPN_BANDWIDTH_225 0x80
#define RFLR_PLLLOWPN_BANDWIDTH_300 0xC0 // Default
//RegModemConfig3
#define RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_MASK 0xF7
#define RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_ON 0x08
#define RFLR_MODEMCONFIG3_LOWDATARATEOPTIMIZE_OFF 0x00 // Default
#define RFLR_MODEMCONFIG3_AGCAUTO_MASK 0xFB
#define RFLR_MODEMCONFIG3_AGCAUTO_ON 0x04 // Default
#define RFLR_MODEMCONFIG3_AGCAUTO_OFF 0x00
//REGISTER
typedef struct _Sx1276RegType{
uint8_t RegFifo; // 0x00
// Common settings
uint8_t RegOpMode; // 0x01
uint8_t RegRes02; // 0x02
uint8_t RegRes03; // 0x03
uint8_t RegBandSetting; // 0x04
uint8_t RegRes05; // 0x05
uint8_t RegFrfMsb; // 0x06
uint8_t RegFrfMid; // 0x07
uint8_t RegFrfLsb; // 0x08
// Tx settings
uint8_t RegPaConfig; // 0x09
uint8_t RegPaRamp; // 0x0A
uint8_t RegOcp; // 0x0B
// Rx settings
uint8_t RegLna; // 0x0C
// LoRa registers
uint8_t RegFifoAddrPtr; // 0x0D
uint8_t RegFifoTxBaseAddr; // 0x0E
uint8_t RegFifoRxBaseAddr; // 0x0F
uint8_t RegFifoRxCurrentAddr; // 0x10
uint8_t RegIrqFlagsMask; // 0x11
uint8_t RegIrqFlags; // 0x12
uint8_t RegNbRxBytes; // 0x13
uint8_t RegRxHeaderCntValueMsb; // 0x14
uint8_t RegRxHeaderCntValueLsb; // 0x15
uint8_t RegRxPacketCntValueMsb; // 0x16
uint8_t RegRxPacketCntValueLsb; // 0x17
uint8_t RegModemStat; // 0x18
uint8_t RegPktSnrValue; // 0x19
uint8_t RegPktRssiValue; // 0x1A
uint8_t RegRssiValue; // 0x1B
uint8_t RegHopChannel; // 0x1C
uint8_t RegModemConfig1; // 0x1D
uint8_t RegModemConfig2; // 0x1E
uint8_t RegSymbTimeoutLsb; // 0x1F
uint8_t RegPreambleMsb; // 0x20
uint8_t RegPreambleLsb; // 0x21
uint8_t RegPayloadLength; // 0x22
uint8_t RegMaxPayloadLength; // 0x23
uint8_t RegHopPeriod; // 0x24
uint8_t RegFifoRxByteAddr; // 0x25
uint8_t RegModemConfig3; // 0x26
uint8_t RegTestReserved27[0x30 - 0x27]; // 0x27-0x30
uint8_t RegTestReserved31; // 0x31
uint8_t RegTestReserved32[0x40 - 0x32]; // 0x32-0x40
// I/O settings
uint8_t RegDioMapping1; // 0x40
uint8_t RegDioMapping2; // 0x41
// Version
uint8_t RegVersion; // 0x42
// Additional settings
uint8_t RegAgcRef; // 0x43
uint8_t RegAgcThresh1; // 0x44
uint8_t RegAgcThresh2; // 0x45
uint8_t RegAgcThresh3; // 0x46
// Test
uint8_t RegTestReserved47[0x4B - 0x47]; // 0x47-0x4A
// Additional settings
uint8_t RegPllHop; // 0x4B
uint8_t RegTestReserved4C; // 0x4C
uint8_t RegPaDac; // 0x4D
// Test
//uint8_t RegTestReserved4E[0x58-0x4E]; // 0x4E-0x57
// Additional settings
//uint8_t RegTcxo; // 0x58
// Test
//uint8_t RegTestReserved59; // 0x59
// Test
//uint8_t RegTestReserved5B; // 0x5B
// Additional settings
//uint8_t RegPll; // 0x5C
// Test
//uint8_t RegTestReserved5D; // 0x5D
// Additional settings
//uint8_t RegPllLowPn; // 0x5E
// Test
//uint8_t RegTestReserved5F[0x6C - 0x5F]; // 0x5F-0x6B
// Additional settings
//uint8_t RegFormerTemp; // 0x6C
// Test
//uint8_t RegTestReserved6D[0x71 - 0x6D]; // 0x6D-0x70
}Sx1276RegType;
#define SIZE_OF_REGISTERS (sizeof(Sx1276RegType))
//RF state machine
typedef enum{
RFLR_STATE_IDLE,
RFLR_STATE_RX_RUNNING,
RFLR_STATE_TX_RUNNING,
}LRStateType;
typedef enum{
RADIO_RESET_OFF,
RADIO_RESET_ON,
}tRadioResetState;
typedef enum{
RF_IDLE,
RF_BUSY,
RF_RX_DONE,
RF_RX_TIMEOUT,
RF_TX_DONE,
RF_TX_TIMEOUT,
RF_LEN_ERROR,
RF_CHANNEL_EMPTY,
RF_CHANNEL_ACTIVITY_DETECTED,
}Sx1276RetType;
typedef enum{
SX1276_BW_7K8= (0),
SX1276_BW_10K4= (1<<4),
SX1276_BW_15K6= (2<<4),
SX1276_BW_20K8= (3<<4),
SX1276_BW_31K2= (4<<4),
SX1276_BW_41K6= (5<<4),
SX1276_BW_62K5= (6<<4),
SX1276_BW_125K= (7<<4),
SX1276_BW_250K= (8<<4),
SX1276_BW_500K= (9<<4)
}Sx1276BwType;
typedef enum{
SX1276_SF_64= (6<<4),
SX1276_SF_128= (7<<4),
SX1276_SF_256= (8<<4),
SX1276_SF_512= (9<<4),
SX1276_SF_1024= (10<<4),
SX1276_SF_2048= (11<<4),
SX1276_SF_4096= (12<<4)
}Sx1276SpreadFactorType;
typedef enum{
SX1276_EC_4_5= (1<<1),
SX1276_EC_4_6= (2<<1),
SX1276_EC_4_7= (3<<1),
SX1276_EC_4_8= (4<<1)
}Sx1276ErrorCodingType;
typedef enum{
SX1276_CRC_OFF= (0),
SX1276_CRC_ON= (1<<2)
}Sx1276CrcOnType;
typedef enum{
SX1276_IH_OFF= (0),
SX1276_IH_ON= (1)
}Sx1276ImplicitHeaderOnType;
//可变速率
typedef struct _AutoSfType{
Sx1276SpreadFactorType Sf;
uint8_t ucRssiMin, ucRssiMax;
uint16_t wTimeout;
}AutoSfType, *PAutoSf;
//Parameter
typedef enum{
LORAPT_STATUS,
LORAPT_CHANNEL,
LORAPT_FREQ,
LORAPT_BW,
LORAPT_SF,
LORAPT_EC,
LORAPT_RSSI,
LORAPT_POWER,
LORAPT_SET_RX,
LORAPT_SET_SLEEP,
LORAPT_MAX
}Sx1276LoraParaType;
#define SX1276_CHANNEL_MAX 17
#define LORA_RESET_SET() SET_LORA_RST()
#define LORA_RESET_CLR() CLR_LORA_RST()
#define LORA_SPI_NSS_SET() SET_LORA_NSS()
#define LORA_SPI_NSS_CLR() CLR_LORA_NSS()
#define LORA_SPI_READ_WRITE(x) SpiSendReceive(x)
#define LORA_GETDIO0() GET_LORA_DIO0()
#define LORA_GETDIO1() GET_LORA_DIO1()
#define USE_RF_SW 0
#define USE_LORA_LED 0
#if USE_RF_SW == 1
#define LORA_ANTTXEN() { \
SET_LORA_TXEN_PIN();\
CLR_LORA_RXEN_PIN();\
}
#define LORA_ANTRXEN() { \
SET_LORA_RXEN_PIN();\
CLR_LORA_TXEN_PIN();\
}
#define LORA_ANTCLOSE() { \
CLR_LORA_RXEN_PIN();\
CLR_LORA_TXEN_PIN();\
}
#else
#define LORA_ANTTXEN()
#define LORA_ANTRXEN()
#define LORA_ANTCLOSE()
#endif
#if USE_LORA_LED == 1
#define LORA_TXLED_ON() SET_LED_PIN()
#define LORA_TXLED_OFF() CLR_LED_PIN()
#else
#define LORA_TXLED_ON() SET_LORA_TX_LED()
#define LORA_TXLED_OFF() CLR_LORA_TX_LED()
#endif
#define LORA_BUFF_SIZE 255
typedef enum {
RF_ANT_TRANSMITTER,
RF_ANT_RECEIVER,
RF_ANT_CLOSE,
}Sx1276AntStatus_m;
typedef enum {
SX1276_SLEEP,
SX1276_IDLE,
SX1276_RX,
SX1276_TX,
SX1276_BUSY,
SX1276_ERROR,
SX1276_MAX
}Sx1276StateType_t;
typedef struct {
uint8_t ucChannel;
uint32_t dwFreqHz;
int8_t ucPower;
Sx1276BwType SignalBw;
Sx1276SpreadFactorType SpreadFactor;
Sx1276ErrorCodingType ErrorCoding;
uint8_t RegPreamble;
uint8_t ucOpModePrev;
Sx1276AntStatus_m bAntSwPrev;
Sx1276RegType RegBuff;
Sx1276StateType_t State;
uint8_t ucRxPacketSize;
uint8_t ucTxPacketSize;
uint8_t RxTxBuff[LORA_BUFF_SIZE];
void (*RxCallBack)(uint8_t *rBuff, uint8_t rlen);
}Sx1276Type_t, *pSx1276Type;
//ISM Freq In China
//Up Link:
//CH0-5: 470.3-471.3MHz
//CH39-44:478.1-479.1MHz
//CH78-95:485.9-489.3MHz
//Down Link:
//CH0-47:500.3-509.7MHz
#define USE_915MHZ 0//=1使用915 =0使用433
#if (USE_915MHZ == 1)
//中心频率，不定义则默认为449000000Hz
#define FREQ_CENT 915000000ul
//860MHz-1GHz使用PA功放，不定义则默认不使用
//SX127x不定义，HOPERF模块需要定义
#define USE_LORA_860_PA
#endif
#if !defined FREQ_CENT
#define FREQ_CENT (433100000ul+ 0)//125000
//#define FREQ_DEV 250000ul
#endif
#if !defined FREQ_DEV
//#define FREQ_CENT (449000000ul+ 0)//125000
#define FREQ_DEV 250000ul
#endif
//////////////////////////////////////////////////////////////////////
void Sx1276LoRaLoopHandler(void);
void Sx1276LoRaInit(void (*RxCallBack)(uint8_t *rBuff, uint8_t rlen));
void Sx1276LoRaSendBuffer(uint8_t* pucBuff, uint8_t ucLen);
uint8_t SX1276LoRaReadChannel(void);
bool SX1276LoRaWriteChannel(uint8_t Channel);
uint32_t SX1276LoRaReadFreq(void);
void SX1276LoRaWriteFreq(uint32_t Freq);
void SX1276LoRaWriteBw(Sx1276BwType SignalBw);
uint32_t SX1276LoRaReadBw(void);
uint8_t SX1276LoRaReadSf(void);
void SX1276LoRaWriteSf(Sx1276SpreadFactorType SpreadFactor);
void SX1276LoRaWriteEc(Sx1276ErrorCodingType ErrorCoding);
uint8_t SX1276LoRaReadEc(void);
uint32_t SX1276LoRaParaReadRssi(void);
uint8_t SX1276LoRaReadRssiPkt(void);
void SX1276LoRaWritePwr(int8_t Pwr);
void SX1276LoRaWriteRx(void);
void SX1276LoRaWriteSleep(bool Sleep);
Sx1276StateType_t SX1276LoRaReadStatus(void);
void SX1276LoCalcRssiSnr(int16_t *pswRssi, int8_t *psbSnr);
void Sx1276LoRaSleep(void);
void Sx1276LoRaWakeup(void);
#endif
Project/HC32F460/source/Module/dc_motor/dc_motor.c
+1237
View File
File diff suppressed because it is too large Load Diff
Project/HC32F460/source/Module/dc_motor/dc_motor.h
+165
View File
@@ -0,0 +1,165 @@
#ifndef __DCMOTOR_H
#define __DCMOTOR_H
#define ADC_CH_NUM 3 /* 需要转换的通道数目 */
#define ADC_COLL 100 /* 单采集次数 */
#define ADC_SUM ADC_CH_NUM * ADC_COLL /* 总采集次数 */
#define HC32F170 (0u) //HC32F170JATA
#define HC32L170 (1u) //HC32L170JATA
#define HC32F460JETA (2u) //HC32F460JETA
#define MCU HC32F460JETA
#if(MCU == HC32F460JETA)
#include "hc32_ddl.h"
#define TIMER4 0
#define TIMER6 1
#define TIMER TIMER4 //HC32F460单片机PWM输出控制定时器选择
#endif
// 电机控制参数
#define PWM_PERIOD TIM_PERIOD // PWM周期值 (ARR)
#define MAX_SPEED 480 // 最大速度(PWM占空比)
#define ACCEL_STEP 10 // 加速步进值
#define DECEL_STEP 10 // 减速步进值
#define ACCEL_INTERVAL 10 // 加减速间隔(ms)
// 电机控制命令
typedef enum {
MOTOR_CMD_STOP,
MOTOR_CMD_FORWARD,
MOTOR_CMD_REVERSE
} MotorCommand;
// 电机运行状态机
typedef enum {
MOTOR_STOPPED,
MOTOR_ACCELERATING,
MOTOR_RUNNING,
MOTOR_DECELERATING
} MotorState;
// 电机转动方向
typedef enum {
DIR_STOPPED,
DIR_FORWARD,
DIR_REVERSE
} MotorDirection;
/************************************* 第一部分 电压电流温度采集 ******************************/
/* 电流计算公式：
* I=（最终输出电压-初始参考电压）/（6*0.02）A
* ADC值转换为电压值：电压=ADC值*3.3/4096，这里电压单位为V，我们换算成mV,4096/1000=4.096，后面就直接算出为mA
* 整合公式可以得出电流 I= （当前ADC值-初始参考ADC值）* （3.3 / 4.096 / 0.12）
*/
#define ADC2CURT (float)(3.3f / 4.096f / 0.12f)
/* 电压计算公式：
* V_POWER = V_BUS * 25
* ADC值转换为电压值：电压=ADC值*3.3/4096
* 整合公式可以得出电压V_POWER= ADC值 *（3.3f * 25 / 4096）
*/
#define ADC2VBUS (float)(3.3f * 25 / 4096)
/*****************************************************************************************************/
/* 停止引脚操作宏定义
* 此引脚控制H桥是否生效以达到开启和关闭电机的效果
*/
#define SHUTDOWN1_Pin Pin07
#define SHUTDOWN1_GPIO_Port PortB
//#define SHUTDOWN2_Pin GPIO_PIN_2
//#define SHUTDOWN2_GPIO_Port GPIOF
#define SHUTDOWN_GPIO_CLK_ENABLE() do{ __HAL_RCC_GPIOF_CLK_ENABLE(); }while(0) /* PF口时钟使能 */
#if(MCU == HC32F460JETA)
/* 电机停止引脚定义 这里默认是接口1 */
#define ENABLE_MOTOR PORT_SetBits(SHUTDOWN1_GPIO_Port,SHUTDOWN1_Pin)
#define DISABLE_MOTOR PORT_ResetBits(SHUTDOWN1_GPIO_Port,SHUTDOWN1_Pin)
#endif
/******************************************************************************************/
/* 编码器参数结构体 */
typedef struct
{
int encode_old; /* 上一次计数值 */
int encode_now; /* 当前计数值 */
float speed; /* 编码器速度 */
} ENCODE_TypeDef;
extern ENCODE_TypeDef g_encode; /* 编码器参数变量 */
/************************************* 第三部分 编码器测速 ****************************************************/
#define ROTO_RATIO 44 /* 线数*倍频系数，即11*4=44 */
#define REDUCTION_RATIO 30 /* 减速比30:1 */
/* 电机参数结构体 */
typedef struct
{
uint8_t state; /*电机状态*/
float current; /*电机电流*/
float volatage; /*电机电压*/
float power; /*电机功率*/
float speed; /*电机实际速度*/
float location; /*电机位置*/
int32_t motor_pwm; /*设置比较值大小 */
} Motor_TypeDef;
extern Motor_TypeDef g_motor_data; /*电机参数变量*/
/*********************************************************************************************************************/
void dcmotor_init(void); /* 直流有刷电机初始化 */
void dcmotor_start(void); /* 开启电机 */
void dcmotor_stop(void); /* 关闭电机 */
void dcmotor_dir(uint8_t para); /* 设置电机方向 */
void dcmotor_speed(uint16_t para); /* 设置电机速度 */
void motor_pwm_set(float para); /* 电机控制 */
float get_temp(uint16_t para);
void AdcLoopHander(void);
void Adc1mSRoutine(void);
void Adc_Init(void);
void calc_adc_val(uint16_t * p);
void Encoder (void);
//外部调用接口函数
MotorDirection Motor_GetDirection(void);/* 获取电机转动方向 */
void Motor_Control(MotorCommand cmd); /* 电机控制 */
void Dcmotor1msRoutine(void);
void DcmotorLoopHandler(void);
float get_current(void); /* 获取工作电流 */
float get_volatage(void); /* 获取工作电压 */
float get_Temperature(void); /* 获取工作温度 */
float get_speed(void); /* 获取电机转速 */
float get_location(void); /* 获取电机位置 */
#endif
Project/HC32F460/source/Module/mmc5983/.gitignore
+130
View File
@@ -0,0 +1,130 @@
# ---> uVision
# git ignore file for Keil µVision Project
# µVision 5 and µVision 4 Project screen layout file
*.uvguix.*
*.uvgui.*
# Listing Files
*.i
*.lst
*.m51
*.m66
*.map
# Object Files
*.axf
*.b[0-2][0-9]
*.b3[0-1]
*.bak
*.build_log.htm
*.crf
*.d
*.dep
*.elf
*.htm
*.iex
*.lnp
*.o
*.obj
*.sbr
# Firmware Files
*.bin
*.h86
*.hex
# Build Files
.bat
# Debugger Files
.ini
# JLink Files
JLinkLog.txt
# Other Files
# ---> VisualStudioCode
.vscode/*
!.vscode/settings.json
!.vscode/tasks.json
!.vscode/launch.json
!.vscode/extensions.json
!.vscode/*.code-snippets
# Local History for Visual Studio Code
.history/
# Built Visual Studio Code Extensions
*.vsix
# ---> IAR
# Compiled binaries
*.o
*.bin
*.elf
*.hex
*.map
*.out
*.obj
# Trash
*.bak
thumbs.db
*.~*
# IAR Settings
**/settings/*.crun
**/settings/*.dbgdt
**/settings/*.cspy
**/settings/*.cspy.*
**/settings/*.xcl
**/settings/*.dni
**/settings/*.wsdt
**/settings/*.wspos
# IAR Debug Exe
**/Exe/*.sim
# IAR Debug Obj
**/Obj/*.pbd
**/Obj/*.pbd.*
**/Obj/*.pbi
**/Obj/*.pbi.*
# IAR project "Debug" directory
Debug/
# IAR project "Release" directory
Release/
# IAR project settings directory
settings/
# IAR backup files
Backup*
# IAR .dep files
*.dep
# ---> IAR_EWARM
# gitignore template for the IAR EWARM
# website: https://www.iar.com/knowledge/support/technical-notes/ide/which-files-should-be-version-controlled/
# Some tools will put the EWARM files
# under a subdirectory with the same name
# as the configuration.
# Example
# EWARM/Config1/Obj /List /Exe
# EWARM/Config2/Obj /List /Exe
EWARM/**/Obj
EWARM/**/List
EWARM/**/Exe
# Autogenerated project files
*.dep
*.ewt
# Autogenerated folder for debugger
EWARM/settings
Project/HC32F460/source/Module/mmc5983/README.md
+3
View File
@@ -0,0 +1,3 @@
# MMC5983
MMC5983驱动代码
Project/HC32F460/source/Module/mmc5983/mmc5983.c
+343
View File
@@ -0,0 +1,343 @@
#include "main.h"
#include "mmc5983.h"
#include "UartDebug.h"
#include "i2c.h"
#include "Algorithm.h"
static int32_t max_in[XYZ];
static int32_t min_in[XYZ];
static bool InitFlag;
static bool MMC5983IntFlag;
static MMC5983Var_t MMC5983Var;
/*****************************************************************************************
* 函数名称: MMC5983_Write_Reg
* 功能描述: MMC5983写寄存器
* 参 数: reg 寄存器地址
val 寄存器数据
* 返 回 值: 成功返回true，失败返回false
*****************************************************************************************/
static bool MMC5983_Write_Reg(uint8_t reg, uint8_t val)
{
return I2C_MasterWriteData(M0P_I2C0, MMC5983_ADDRESS, reg, &val, 1);
}
/*****************************************************************************************
* 函数名称: MMC5983_Read_Reg
* 功能描述: MMC5983读寄存器
* 参 数: reg 寄存器地址
* 返 回 值: 返回寄存器值
*****************************************************************************************/
static uint8_t MMC5983_Read_Reg(uint8_t reg)
{
uint8_t res;
if(I2C_MasterReadData(M0P_I2C0, MMC5983_ADDRESS, reg, &res, 1) == false)
res = 0;
return res;
}
/*****************************************************************************************
* 函数名称: MMC5983_Read_Buffer
* 功能描述: MMC5983读数据
* 参 数: reg 寄存器地址
buffer 读取数据输出缓存入口
len 读取长度
* 返 回 值: 成功返回true，失败返回false
*****************************************************************************************/
static bool MMC5983_Read_Buffer(uint8_t reg, void *buffer, uint8_t len)
{
return I2C_MasterReadData(M0P_I2C0, MMC5983_ADDRESS, reg, buffer, len);
}
/*****************************************************************************************
* 函数名称: MMC5983StartCov
* 功能描述: MMC5983开启连续转换
* 参 数: 无
* 返 回 值: 无
*****************************************************************************************/
static void MMC5983StartCov(void)
{
MMC5983RegCtrl2 Ctrl2Reg; //开启/关闭连续转换
Ctrl2Reg.Byte = 0x00;
Ctrl2Reg.Bit.Cm_freq = 0x04;
Ctrl2Reg.Bit.Cmm_en = 1; //连续设1，单次设0
Ctrl2Reg.Bit.Prd_set = 3;
Ctrl2Reg.Bit.En_prd_set = 1; //连续设1，单次设0
MMC5983_Write_Reg(MMC5983_CTRL_2, Ctrl2Reg.Byte);
}
/*****************************************************************************************
* 函数名称: MMC5983_Init
* 功能描述: MMC5983初始化
* 参 数: 无
* 返 回 值: 无
*****************************************************************************************/
static void MMC5983_Init(void)
{
uint8_t id;
id = MMC5983_Read_Reg(MMC5983_ID);
//DBG_LOG("MMC5983 id=0x%x\r\n",id);
MMC5983Var.MMC5983Delay1mSCnt = 100;
while(id != 0x30){
if(MMC5983Var.MMC5983Delay1mSCnt <= 0) {
DBG_LOG("LEFT MMC5983 INIT Err...\r\n");
InitFlag = false;
return;
}
}
MMC5983RegCtrl1 Ctrl1Reg;
Ctrl1Reg.Byte = 0x00;
Ctrl1Reg.Bit.SW_RST = 1;
MMC5983_Write_Reg(MMC5983_CTRL_1, Ctrl1Reg.Byte);
MMC5983Delay(15);
MMC5983RegCtrl2 Ctrl2Reg; //开启/关闭连续转换
Ctrl2Reg.Byte = 0x00;
Ctrl2Reg.Bit.Cm_freq = 0x04;
Ctrl2Reg.Bit.Cmm_en = 0; //连续设1，单次设0
Ctrl2Reg.Bit.Prd_set = 3;
Ctrl2Reg.Bit.En_prd_set = 0; //连续设1，单次设0
MMC5983_Write_Reg(MMC5983_CTRL_2, Ctrl2Reg.Byte);
MMC5983RegCtrl3 Ctrl3Reg;
Ctrl3Reg.Byte = 0x00;
Ctrl3Reg.Bit.St_enm = 1;
Ctrl3Reg.Bit.St_enp = 1;
MMC5983_Write_Reg(MMC5983_CTRL_3, Ctrl3Reg.Byte);
MMC5983RegCtrl0 Ctrl0Reg;
Ctrl0Reg.Byte = 0x00;
Ctrl0Reg.Bit.TM_M = 1;
Ctrl0Reg.Bit.Auto_SR_en = 1;
Ctrl0Reg.Bit.NT_meas_done_en = 1;
MMC5983_Write_Reg(MMC5983_CTRL_0, Ctrl0Reg.Byte);
if(InitFlag == false){
DBG_LOG("MMC5983 INIT OK...\r\n");
InitFlag = true;
}
}
/*****************************************************************************************
* 函数名称: MMC5983_Read
* 功能描述: MMC5983读取原始数据
* 参 数: MagAdcX X轴数据
MagAdcY Y轴数据
MagAdcZ Z轴数据
* 返 回 值: 成功返回true，失败返回false
*****************************************************************************************/
static bool MMC5983_Read(int32_t *MagAdcX, int32_t *MagAdcY, int32_t *MagAdcZ)
{
static uint8_t buff[7];
if (MMC5983_Read_Buffer(MMC5983_X_OUT_H, buff, 7) == false)
return false;
*MagAdcX = (buff[0] << 10) | (buff[1] << 2) | ((buff[6] & 0xC0) >> 6);
*MagAdcY = (buff[2] << 10) | (buff[3] << 2) | ((buff[6] & 0x30) >> 4);
*MagAdcZ = (buff[4] << 10) | (buff[5] << 2) | ((buff[6] & 0x0C) >> 2);// Turn the 18 bits into unsigned 32-bit value
return true;
}
/*****************************************************************************************
* 函数名称: MMC5983_Get_Mag
* 功能描述: 外部获取MMC5983磁场强度数据
* 参 数: mag 读取数据输出缓存入口
* 返 回 值: 无
*****************************************************************************************/
void MMC5983_Get_Mag(float *mag)
{
if(mag == NULL)
return;
float ADVal[XYZ];
ADVal[X] = MMC5983Var.Mag_Original[X] - 131072.0f;
ADVal[Y] = MMC5983Var.Mag_Original[Y] - 131072.0f;
ADVal[Z] = MMC5983Var.Mag_Original[Z] - 131072.0f;
mag[0] = (float) (ADVal[X] * MMC5983_MAG_SCALE_18BIT);
mag[1] = (float) (ADVal[Y] * MMC5983_MAG_SCALE_18BIT);
mag[2] = (float) (ADVal[Z] * MMC5983_MAG_SCALE_18BIT);
}
/*****************************************************************************************
* 函数名称: MMC5983LoopHandler
* 功能描述: MMC5983循环处理函数
* 参 数: 无
* 返 回 值: 无
*****************************************************************************************/
extern void MmcDataProcessCallBack(float *Mag);
void MMC5983LoopHandler(void)
{
static int32_t mag_array[XYZ][10];
static uint8_t magcnt;
static uint8_t TimeOutMagcnt;
switch(MMC5983Var.Status) {
case MMC5983_STATUS_IDLE:{
break;}
case MMC5983_STATUS_START:{
for(int i = 0; i < 10; i++) {
mag_array[X][i] = 0;
mag_array[Y][i] = 0;
mag_array[Z][i] = 0;
}
magcnt = 0;
TimeOutMagcnt = 0;
memset(&MMC5983Var, NULL, sizeof(MMC5983Var));
MMC5983Var.Status = MMC5983_STATUS_DELAY;
break;}
case MMC5983_STATUS_DELAY:{
MMC5983StartRead();
MMC5983Var.MMC5983Delay1mSCnt = 50;
MMC5983Var.Status = MMC5983_STATUS_WAIT_DELAY;
break;}
case MMC5983_STATUS_WAIT_DELAY:{
if(MMC5983Var.MMC5983Delay1mSCnt <= 0){
MMC5983Var.Status = MMC5983_STATUS_READ;
}
break;}
case MMC5983_STATUS_READ:{
MMC5983Var.MMC5983Delay1mSCnt = 50;
MMC5983Var.Status = MMC5983_STATUS_WAIT_READ;
break;}
case MMC5983_STATUS_WAIT_READ:{
if(MMC5983Var.MMC5983Delay1mSCnt <= 0){
MMC5983Var.Status = MMC5983_STATUS_DELAY;
TimeOutMagcnt++;
}
if(MMC5983IntFlag == true){
MMC5983IntFlag = false;
MMC5983_Read(&mag_array[X][magcnt], &mag_array[Y][magcnt], &mag_array[Z][magcnt]);
magcnt++;
MMC5983Var.Status = MMC5983_STATUS_DELAY;
}
if(TimeOutMagcnt >= 10){
TimeOutMagcnt = 0;
if(magcnt > 0){
MMC5983Var.Mag_Original[X] = AverageFilter_32t(mag_array[X], magcnt);
MMC5983Var.Mag_Original[Y] = AverageFilter_32t(mag_array[Y], magcnt);
MMC5983Var.Mag_Original[Z] = AverageFilter_32t(mag_array[Z], magcnt);
magcnt = 0;
MMC5983_Get_Mag(MMC5983Var.Mag);
MmcDataProcessCallBack(MMC5983Var.Mag);
MMC5983Var.Status = MMC5983_STATUS_STOP;
}
else{
MMC5983Var.Status = MMC5983_STATUS_STOP;
// DBG_LOG("LEFT MMC5983 TimeOut...\r\n");
}
}
if(magcnt >= 10){
MMC5983Var.Mag_Original[X] = AverageFilter_32t(mag_array[X], magcnt);
MMC5983Var.Mag_Original[Y] = AverageFilter_32t(mag_array[Y], magcnt);
MMC5983Var.Mag_Original[Z] = AverageFilter_32t(mag_array[Z], magcnt);
magcnt = 0;
MMC5983_Get_Mag(MMC5983Var.Mag);
MmcDataProcessCallBack(MMC5983Var.Mag);
MMC5983Var.Status = MMC5983_STATUS_STOP;
}
break;}
case MMC5983_STATUS_STOP:{
MMC5983Stop();
MMC5983Var.Status = MMC5983_STATUS_IDLE;
//MMC5983Var.Status = MMC5983_STATUS_START;//持续工作
break;}
}
}
/*****************************************************************************************
* 函数名称: LeftMMC59831mSRoutine
* 功能描述: MMC59831ms时基循环处理函数
* 参 数: 无
* 返 回 值: 无
*****************************************************************************************/
void MMC59831mSRoutine(void)
{
if(MMC5983Var.MMC5983Delay1mSCnt > 0)
MMC5983Var.MMC5983Delay1mSCnt--;
}
/*****************************************************************************************
* 函数名称: LeftMMC5983Init
* 功能描述: MMC5983初始化
* 参 数: 无
* 返 回 值: 无
*****************************************************************************************/
void MMC5983Init(void)
{
if(!InitFlag){
MMC5983_Init();
return;
}
MMC5983Var.Status = MMC5983_STATUS_START;
}
/*****************************************************************************************
* 函数名称: LeftMMC5983Start
* 功能描述: MMC5983启动
* 参 数: 无
* 返 回 值: 无
*****************************************************************************************/
void MMC5983Start(void)
{
if(!InitFlag){
MMC5983_Init();
return;
}
MMC5983Var.Status = MMC5983_STATUS_START;
}
/*****************************************************************************************
* 函数名称: LeftMMC5983StartRead
* 功能描述: MMC5983启动读取
* 参 数: 无
* 返 回 值: 无
*****************************************************************************************/
void MMC5983StartRead(void)
{
MMC5983_Init();//读取时重新初始化
}
/*****************************************************************************************
* 函数名称: MMC5983Stop
* 功能描述: MMC5983停止
* 参 数: 无
* 返 回 值: 无
*****************************************************************************************/
void MMC5983Stop(void)
{
MMC5983RegCtrl0 Ctrl0Reg;
Ctrl0Reg.Byte = 0x00;
MMC5983_Write_Reg(MMC5983_CTRL_0, Ctrl0Reg.Byte);
MMC5983RegStatus StatusReg;
StatusReg.Byte = MMC5983_Read_Reg(MMC5983_STATUS);
if(StatusReg.Bit.Meas_M_Done == 1){
MMC5983_Write_Reg(MMC5983_STATUS, StatusReg.Byte);
}
}
/*****************************************************************************************
* 函数名称: LeftMMC5983IntCallBack
* 功能描述: MMC5983中断回调
* 参 数: 无
* 返 回 值: 无
*****************************************************************************************/
void MMC5983IntCallBack(void)
{
MMC5983IntFlag = true;
}
Project/HC32F460/source/Module/mmc5983/mmc5983.h
+140
View File
@@ -0,0 +1,140 @@
/**
*****************************************************************************
* @file ak8975.h
* @author WWJ
* @version v1.0
* @date 2019/04/09
* @environment stm32f407
* @brief
*****************************************************************************
**/
#ifndef _MMC5983_H
#define _MMC5983_H
#include "bsp.h"
#define X 0
#define Y 1
#define Z 2
#define XYZ 3
#define MAX(A, B) (A > B) ? A : B;
#define MIN(A, B) (A < B) ? A : B;
#define MMC5983_X_OUT_H 0X00 //Device ID = 0x48
#define MMC5983_X_OUT_L 0X01
#define MMC5983_Y_OUT_H 0X02
#define MMC5983_Y_OUT_L 0X03
#define MMC5983_Z_OUT_H 0X04
#define MMC5983_Z_OUT_L 0X05
#define MMC5983_XYZ_OUT 0X06
#define MMC5983_TMP_OUT 0X07
#define MMC5983_STATUS 0X08
#define MMC5983_CTRL_0 0X09
#define MMC5983_CTRL_1 0X0A
#define MMC5983_CTRL_2 0X0B
#define MMC5983_CTRL_3 0X0C
#define MMC5983_ID 0X2F
#define MMC5983_ADDRESS 0x30
#define MMC5983_MAG_SCALE_16BIT 0.24414f
#define MMC5983_MAG_SCALE_18BIT 0.061035f
#define MMC5983Delay(x) delay_ms(x)
typedef union {
struct {
uint8_t Meas_M_Done: 1;
uint8_t Meas_T_Done: 1;
uint8_t Res0: 2;
uint8_t OTP_Read_Done: 1;
uint8_t Res1: 3;
}Bit;
uint8_t Byte;
}MMC5983RegStatus;
typedef union {
struct {
uint8_t TM_M: 1;
uint8_t TM_T: 1;
uint8_t NT_meas_done_en: 1;
uint8_t Set: 1;
uint8_t Reset: 1;
uint8_t Auto_SR_en: 1;
uint8_t OTP_Read: 1;
uint8_t Res0: 1;
}Bit;
uint8_t Byte;
}MMC5983RegCtrl0;
typedef union {
struct {
uint8_t BW: 2;
uint8_t X_Inhibit: 1;
uint8_t YZ_Inhibit: 2;
uint8_t Res0: 2;
uint8_t SW_RST: 1;
}Bit;
uint8_t Byte;
}MMC5983RegCtrl1;
typedef union {
struct {
uint8_t Cm_freq: 3;
uint8_t Cmm_en: 1;
uint8_t Prd_set: 3;
uint8_t En_prd_set: 1;
}Bit;
uint8_t Byte;
}MMC5983RegCtrl2;
typedef union {
struct {
uint8_t Res0: 1;
uint8_t St_enp: 1;
uint8_t St_enm: 1;
uint8_t Res1: 3;
uint8_t Spi_3w: 1;
uint8_t Res2: 1;
}Bit;
uint8_t Byte;
}MMC5983RegCtrl3;
typedef enum{
MMC5983_STATUS_IDLE,
MMC5983_STATUS_START,
MMC5983_STATUS_DELAY,
MMC5983_STATUS_WAIT_DELAY,
MMC5983_STATUS_READ,
MMC5983_STATUS_WAIT_READ,
MMC5983_STATUS_STOP,
}MMC5983Status_m;
typedef struct {
MMC5983Status_m Status;
uint16_t MMC5983Delay1mSCnt;
float Mag[3];
int32_t Mag_Original[XYZ];
}MMC5983Var_t;
void MMC5983LoopHandler(void);
void MMC59831mSRoutine(void);
void MMC5983Init(void);
void MMC5983Start(void);
void MMC5983Stop(void);
void MMC5983IntCallBack(void);
void MMC5983Calib(void);
void MMC5983GetADValue(int32_t *Mag);
void MMC5983_Get_Mag(float *mag);
MMC5983Status_m GetMMC5983Status(void);
void MMC5983StartRead(void);
bool GetMMC5983CalibStatus(void);
#endif
/* end of ak8975.h */
Project/HC32F460/source/User/Inc/ADS1231.h
+13
View File
@@ -0,0 +1,13 @@
#ifndef __ADS1231__
#define __ADS1231__
#include "bsp.h"
void ADS1231_Open(void);
void ADS1231_SpeedSet(void);
bool ADS1231_Read(uint32_t *r_data, uint8_t channel);
void ADS1231_HighSpeedSet(void);
void ADS1231_LowSpeedSet(void);
#endif
Project/HC32F460/source/User/Inc/Algorithm.h
+60
View File
@@ -0,0 +1,60 @@
#ifndef __ALGORITHM_H
#define __ALGORITHM_H
#include <math.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdint.h>
#define CRC16_BASE 0xA001
// 峰值谷值检查结果结构体
typedef struct {
bool peaks_positive; // 所有峰值是否大于0
bool valleys_negative; // 所有谷值是否小于0
int peak_count; // 检测到的峰值数量
int valley_count; // 检测到的谷值数量
} PeakValleyCheck;
// 趋势分析结果结构体
typedef struct {
double slope; // 线性斜率
int sign_changes; // 符号变化次数
char trend_type; // 趋势类型
char steepness; // 陡峭度
} TrendResult;
PeakValleyCheck check_peaks_valleys(int data[], int length);
TrendResult analyze_trend(int data[], int length);
float calculateAverage(int *arr, int size);
double slope(int32_t *x_data, int32_t *y_data, int n) ;
long long power(int base, unsigned int exponent);
int IntFilter_16t(int16_t *Data, uint8_t Cnt, uint8_t FilterCnt);
int IntFilter_32t(int32_t *Data, uint8_t Cnt, uint8_t FilterCnt);
uint32_t IntFilter_u32t(uint32_t *Data, uint8_t Cnt, uint8_t FilterCnt);
float IntFilter_Float(float *Data, uint8_t Cnt, uint8_t FilterCnt);
uint32_t AverageFilter_u32t(uint32_t *Data, uint8_t Cnt);
int AverageFilter_32t(int32_t *Data, uint8_t Cnt);
void Fitting_Polynomial(double *AD, double *Actual, uint8_t Cnt);
float get_K(uint8_t count , int32_t *dataCol_X, int32_t *dataRow_Y);
int8_t TrendAnalyse(int32_t *Data, uint8_t Cnt, int32_t VPT);
void Waveform_Up(int32_t *Data, uint8_t dCnt, uint8_t pCnt, int32_t *vlue);
void Waveform_Down(int32_t *Data, uint8_t dCnt, uint8_t pCnt, int32_t *vlue);
bool count_most_greater(int32_t *arr, uint8_t size, int32_t target);
bool count_greater(int32_t *arr, uint8_t size, int32_t target);
bool count_smaller(int32_t *arr, uint8_t size, int32_t target);
uint16_t CRC_Modbus(uint16_t wBase, uint8_t *para, uint16_t length);
uint8_t CRC_Sum(uint8_t *_pbuff, uint16_t _cmdLen);
bool isAllZero(uint8_t *arr, int size);
int fixWithMedianIterative(int arr[], int size, int windowSize, int threshold, int maxIterations, int verbose);
int finalCheck(int arr[], int size, int threshold, int verbose);
int weightedMovingAverageWithEnhance(int32_t arr[], int size, int windowSize,
int enhanceStart, int enhanceEnd,
double enhanceFactor, int verbose);
#endif
Project/HC32F460/source/User/Inc/Debug.h
+45
View File
@@ -0,0 +1,45 @@
#ifndef __DEBUG_H
#define __DEBUG_H
#include "bsp.h"
#if (USE_DEBUG != 0)
#define BUFSIZE 128
#define DEBUG_BUFF_SIZE_MAX 512
void vcom_Send( char *format, ... );
void vcom_Send2(uint8_t *sData, uint16_t len);
#define DBG_LOG2(x, y) vcom_Send2(x, y) //打印长度超过缓存DEBUG_BUFF_SIZE_MAX的信息
#define DBG_LOG(...) vcom_Send(__VA_ARGS__)
#define DBG_LOG_F(fmt,arg...) LOG("[%s] "fmt,__FUNCTION__,##arg)
#define DBG_ARRAY(ARRAY,SIZE) { \
if(ARRAY != NULL) { \
for(int i = 0; i < SIZE; i++) { \
DBG_LOG("%02x ",ARRAY[i]); \
} \
DBG_LOG("\r\n"); \
} \
}
typedef void (*DebugExec)(int argc, char *argv[]);
typedef struct{
char *DBGCmd;
DebugExec DBGExec;
}DBGFunType;
void DebugUartIRQ(char Data);
void DebugLoopHandler(void);
void Dbg1msRoutine(void);
#else
#define DBG_LOG2(x, y)
#define DBG_LOG(...)
#define DBG_LOG_F(fmt,arg...)
#define DBG_ARRAY(ARRAY,SIZE)
#endif
#endif
Project/HC32F460/source/User/Inc/Encryption.h
+7
View File
@@ -0,0 +1,7 @@
#ifndef __ENCRYPTION_H__
#define __ENCRYPTION_H__
void Encrypt_Code(unsigned char *data, unsigned char *EPT_data);
void Decrypt_Code(unsigned char *EPT_data,unsigned char *DPT_data);
#endif
Project/HC32F460/source/User/Inc/bsp.h
+298
View File
@@ -0,0 +1,298 @@
#ifndef __BSP_H
#define __BSP_H
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "hc32_ddl.h"
/*模块启用与关闭*/
#define USE_DEBUG 1 //DEBUG开关，0、关闭，1、启用
#define USE_AD 1 //AD获取选择，0、关闭，1、启用
#define USE_WDT 0 //看门狗选择，0、关闭，1启用
#define USE_EXFALSE 0 //外部FALSE存储选择，0、关闭，1、启用
#define USE_RTC 0 //RTC时钟开关，0、关闭，1、开启
#define USE_LPTIM0 0 //LPTIM0开关，0、关闭，1、开启
#define USE_DMA 1 //DMA开关，0、关闭，1、开启
#define USE_RS485 0 //RS485开关，0、关闭，1、启用
#define USE_I2C1 0 //I2C1开关，0、关闭，1、启用
#define USE_SPI1 0 //SPI1开关，0、关闭，1、启用
#define USE_SPI3 0 //SPI3开关，0、关闭，1、启用
#define USE_USART3 1
#define USE_BOOTLOADER 0 //BOOTLOADER开关，0、关闭，1、启用
#define USE_CS1237_LEFTUP 1 //左上CS1237开关，0、关闭，1、启用
#define USE_CS1237_LEFTLOW 1 //左下CS1237开关，0、关闭，1、启用
#define USE_CS1237_RIGHTUP 1 //右上CS1237开关，0、关闭，1、启用
#define USE_CS1237_RIGHTLOW 1 //右下CS1237开关，0、关闭，1、启用
#define USE_AGC 1 //算法控制开关，0、关闭，1、启用
//<<---------------------------- MCU -------------------------------->>
//< DEBUG
#if(USE_DEBUG == 1)
#define DBG_USART_CH (M4_USART1)
#define DBG_USART_RX_PORT (PortA)
#define DBG_USART_RX_PIN (Pin11)
#define DBG_USART_TX_PORT (PortA)
#define DBG_USART_TX_PIN (Pin12)
#define DBG_USART_RX_FUNC (Func_Usart1_Rx)
#define DBG_USART_TX_FUNC (Func_Usart1_Tx)
#define DBG_USART_RI_NUM (INT_USART1_RI)
#define DBG_USART_EI_NUM (INT_USART1_EI)
#define DBG_USART_TI_NUM (INT_USART1_TI)
#define DBG_USART_TCI_NUM (INT_USART1_TCI)
#define DBG_FCG1_PERIPH (PWC_FCG1_PERIPH_USART1)
#define DBG_RXPIN_EXIT_CH (ExtiCh13)
#define DBG_RXPIN_EXIT_SRC (INT_PORT_EIRQ13)
#define DBG_RX_IRQn (Int000_IRQn)
#define DBG_ER_IRQn (Int001_IRQn)
#endif
//< USART3
//#if(USE_USART3 == 1)
//#define USAR3_CH (M4_USART3)
//#define USAR3_RX_PORT (PortH)
//#define USAR3_RX_PIN (Pin02)
//#define USAR3_TX_PORT (PortC)
//#define USAR3_TX_PIN (Pin13)
//#define USAR3_RX_FUNC (Func_Usart3_Rx)
//#define USAR3_TX_FUNC (Func_Usart3_Tx)
//#define USAR3_RI_NUM (INT_USART3_RI)
//#define USAR3_EI_NUM (INT_USART3_EI)
//#define USAR3_TI_NUM (INT_USART3_TI)
//#define USAR3_TCI_NUM (INT_USART3_TCI)
//#define USAR3_FCG1_PERIPH (PWC_FCG1_PERIPH_USART3)
//#define USAR3_RXPIN_EXIT_CH (ExtiCh14)
//#define USAR3_RXPIN_EXIT_SRC (INT_PORT_EIRQ14)
//#define USAR3_RX_IRQn (Int006_IRQn)
//#define USAR3_ER_IRQn (Int007_IRQn)
//#endif
#if(USE_USART3 == 1)
#define USART3_CH (M4_USART3)
#define USART3_RX_PORT (PortH)
#define USART3_RX_PIN (Pin02)
#define USART3_RX_FUNC (Func_Usart3_Rx)
#define USART3_USART_RI_NUM (INT_USART3_RI)
#define USART3_USART_EI_NUM (INT_USART3_EI)
#define USART3_FCG1_PERIPH (PWC_FCG1_PERIPH_USART3)
#define USART3_RX_IRQn (Int006_IRQn)
#define USART3_ER_IRQn (Int007_IRQn)
//#define USART3_RXPIN_IRQn Int002_IRQn
#endif
// RS485
#if(USE_RS485 == 1)
#define RS485_USART_CH (M4_USART1)
//#define RS485_USART_RX_PORT (PortB)
//#define RS485_USART_RX_PIN (Pin08)
//#define RS485_USART_TX_PORT (PortB)
//#define RS485_USART_TX_PIN (Pin09)
#define RS485_USART_RX_PORT (PortA)
#define RS485_USART_RX_PIN (Pin15)
#define RS485_USART_TX_PORT (PortA)
#define RS485_USART_TX_PIN (Pin12)
#define RS485_USART_RX_FUNC (Func_Usart1_Rx)
#define RS485_USART_TX_FUNC (Func_Usart1_Tx)
#define RS485_USART_RI_NUM (INT_USART1_RI)
#define RS485_USART_EI_NUM (INT_USART1_EI)
#define RS485_USART_TI_NUM (INT_USART1_TI)
#define RS485_USART_TCI_NUM (INT_USART1_TCI)
#define RS485_FCG1_PERIPH (PWC_FCG1_PERIPH_USART1)
#define RS485_RXPIN_EXIT_CH (ExtiCh14)
#define RS485_RXPIN_EXIT_SRC (INT_PORT_EIRQ14)
#define RS485_CTRL_PORT (PortC)
#define RS485_CTRL_PIN (Pin13)
#define RS485_TX() PORT_SetBits(RS485_CTRL_PORT, RS485_CTRL_PIN)
#define RS485_RX() PORT_ResetBits(RS485_CTRL_PORT, RS485_CTRL_PIN)
#endif
// SPI3
#if(USE_SPI3 == 1)
/* SPI3_SCK Port/Pin definition */
#define SPI3_SCK_PORT (PortB)
#define SPI3_SCK_PIN (Pin14)
#define SPI3_SCK_FUNC (Func_Spi3_Sck)
/* SPI3_MOSI Port/Pin definition */
#define SPI3_MOSI_PORT (PortB)
#define SPI3_MOSI_PIN (Pin10)
#define SPI3_MOSI_FUNC (Func_Spi3_Mosi)
/* SPI3_MISO Port/Pin definition */
#define SPI3_MISO_PORT (PortB)
#define SPI3_MISO_PIN (Pin12)
#define SPI3_MISO_FUNC (Func_Spi3_Miso)
/* SPI3_MOSI Port/Pin definition */
#define SPI3_NSS_PORT (PortB)
#define SPI3_NSS_PIN (Pin13)
#define SPI3_NSS_FUNC (Func_Spi3_Nss0)
#define SPI3_NSS_SET() PORT_SetBits(SPI3_NSS_PORT, SPI3_NSS_PIN)
#define SPI3_NSS_CLR() PORT_ResetBits(SPI3_NSS_PORT, SPI3_NSS_PIN)
/* SPI3 unit and clock definition */
#define SPI3_UNIT (M4_SPI3)
#define SPI3_UNIT_CLOCK (PWC_FCG1_PERIPH_SPI3)
#endif
//< RTC
#if(USE_RTC == 1)
#define RTC_IRQn Int001_IRQn
#endif
//<<----------------------------- CS1237 ------------------------------->>
//< 左上 CS1237
#if(USE_CS1237_LEFTUP == 1)
#define LEFTUP_CS1237_IRQn (Int001_IRQn)
#define LEFTUP_CS1237_DOUT_PORTx (PortB)
#define LEFTUP_CS1237_DOUT_PINx (Pin10)
#define SET_LEFTUP_CS1237_DOUT() PORT_SetBits(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx)//拉高
#define CLR_LEFTUP_CS1237_DOUT() PORT_ResetBits(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx)//拉低
#define GET_LEFTUP_CS1237_DOUT() PORT_GetBit(LEFTUP_CS1237_DOUT_PORTx, LEFTUP_CS1237_DOUT_PINx)
#define LEFTUP_CS1237_SCLK_PORTx (PortB)
#define LEFTUP_CS1237_SCLK_PINx (Pin02)
#define SET_LEFTUP_CS1237_SCLK() PORT_SetBits(LEFTUP_CS1237_SCLK_PORTx, LEFTUP_CS1237_SCLK_PINx)//拉高
#define CLR_LEFTUP_CS1237_SCLK() PORT_ResetBits(LEFTUP_CS1237_SCLK_PORTx, LEFTUP_CS1237_SCLK_PINx)//拉低
#endif
//< 左下 CS1237
#if(USE_CS1237_LEFTLOW == 1)
#define LEFTLOW_CS1237_IRQn (Int002_IRQn)
#define LEFTLOW_CS1237_DOUT_PORTx (PortB)
#define LEFTLOW_CS1237_DOUT_PINx (Pin01)
#define SET_LEFTLOW_CS1237_DOUT() PORT_SetBits(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx)//拉高
#define CLR_LEFTLOW_CS1237_DOUT() PORT_ResetBits(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx)//拉低
#define GET_LEFTLOW_CS1237_DOUT() PORT_GetBit(LEFTLOW_CS1237_DOUT_PORTx, LEFTLOW_CS1237_DOUT_PINx)
#define LEFTLOW_CS1237_SCLK_PORTx (PortB)
#define LEFTLOW_CS1237_SCLK_PINx (Pin00)
#define SET_LEFTLOW_CS1237_SCLK() PORT_SetBits(LEFTLOW_CS1237_SCLK_PORTx, LEFTLOW_CS1237_SCLK_PINx)//拉高
#define CLR_LEFTLOW_CS1237_SCLK() PORT_ResetBits(LEFTLOW_CS1237_SCLK_PORTx, LEFTLOW_CS1237_SCLK_PINx)//拉低
#endif
//< 右上 CS1237
#if(USE_CS1237_RIGHTUP == 1)
#define RIGHTUP_CS1237_IRQn (Int003_IRQn)
#define RIGHTUP_CS1237_DOUT_PORTx (PortA)
#define RIGHTUP_CS1237_DOUT_PINx (Pin04)
#define SET_RIGHTUP_CS1237_DOUT() PORT_SetBits(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx)//拉高
#define CLR_RIGHTUP_CS1237_DOUT() PORT_ResetBits(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx)//拉低
#define GET_RIGHTUP_CS1237_DOUT() PORT_GetBit(RIGHTUP_CS1237_DOUT_PORTx, RIGHTUP_CS1237_DOUT_PINx)
#define RIGHTUP_CS1237_SCLK_PORTx (PortA)
#define RIGHTUP_CS1237_SCLK_PINx (Pin05)
#define SET_RIGHTUP_CS1237_SCLK() PORT_SetBits(RIGHTUP_CS1237_SCLK_PORTx, RIGHTUP_CS1237_SCLK_PINx)//拉高
#define CLR_RIGHTUP_CS1237_SCLK() PORT_ResetBits(RIGHTUP_CS1237_SCLK_PORTx, RIGHTUP_CS1237_SCLK_PINx)//拉低
#endif
//< 右下 CS1237
#if(USE_CS1237_RIGHTLOW == 1)
#define RIGHTLOW_CS1237_IRQn (Int004_IRQn)
#define RIGHTLOW_CS1237_DOUT_PORTx (PortA)
#define RIGHTLOW_CS1237_DOUT_PINx (Pin06)
#define SET_RIGHTLOW_CS1237_DOUT() PORT_SetBits(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx)//拉高
#define CLR_RIGHTLOW_CS1237_DOUT() PORT_ResetBits(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx)//拉低
#define GET_RIGHTLOW_CS1237_DOUT() PORT_GetBit(RIGHTLOW_CS1237_DOUT_PORTx, RIGHTLOW_CS1237_DOUT_PINx)
#define RIGHTLOW_CS1237_SCLK_PORTx (PortA)
#define RIGHTLOW_CS1237_SCLK_PINx (Pin07)
#define SET_RIGHTLOW_CS1237_SCLK() PORT_SetBits(RIGHTLOW_CS1237_SCLK_PORTx, RIGHTLOW_CS1237_SCLK_PINx)//拉高
#define CLR_RIGHTLOW_CS1237_SCLK() PORT_ResetBits(RIGHTLOW_CS1237_SCLK_PORTx, RIGHTLOW_CS1237_SCLK_PINx)//拉低
#endif
//< BIT0
#define TWIN_BIT0_PORTx (PortB)
#define TWIN_BIT0_PINx (Pin12)
#define SET_TWIN_BIT0() PORT_SetBits(TWIN_BIT0_PORTx, TWIN_BIT0_PINx)//拉高
#define CLR_TWIN_BIT0() PORT_ResetBits(TWIN_BIT0_PORTx, TWIN_BIT0_PINx)//拉低
#define GET_BIT0_DOUT() PORT_GetBit(TWIN_BIT0_PORTx, TWIN_BIT0_PINx)
//< BIT1
#define TWIN_BIT1_PORTx (PortB)
#define TWIN_BIT1_PINx (Pin13)
#define SET_TWIN_BIT1() PORT_SetBits(TWIN_BIT1_PORTx, TWIN_BIT1_PINx)//拉高
#define CLR_TWIN_BIT1() PORT_ResetBits(TWIN_BIT1_PORTx, TWIN_BIT1_PINx)//拉低
#define GET_BIT1_DOUT() PORT_GetBit(TWIN_BIT1_PORTx, TWIN_BIT1_PINx)
typedef struct {
int32_t ControlLevel;//控制等级
int32_t DBGWaveOut;//调试波形输出
}__attribute__ ((packed))LayoutPara_t, *LayoutPara;//上位机下发的配置参数
typedef struct {
LayoutPara_t Layout;
uint32_t FactoryFlag;//出厂标志位
}AppPara_T, *pAppPara;
#define SAVE_APP_PARA(addr) FlashWrite(addr, sizeof(App.Para) / 4)
#define READ_APP_PARA(addr) FlashRead(addr, sizeof(App.Para) / 4)
void BSP_Init(void);
uint8_t DbgUartRec(void);
void DebugUartSend(uint8_t *sData, uint16_t sLen);
void Error_Handler(void);
void FeedDog(void);
void EnterStop(void);
void Wakeup(void);
void FlashWrite(uint32_t *wData, uint32_t wLen);
void FlashRead(uint32_t *rData, uint32_t wLen);
uint8_t RS485UartRec(void);
void RS485UsartErrIrqCallback(void);
void RS485_RxPinIntCallBack(void);
void RS485UsartRxIrqCallback(void);
void RS485UartSend(uint8_t *sData, uint16_t sLen);
void RS485_1msRoutine(void);
uint8_t Uart3Rec(void);
void Usart3ErrIrqCallback(void);
void Usart3_RxPinIntCallBack(void);
void Usart3RxIrqCallback(void);
void Usart3Send(uint8_t *sData, uint16_t sLen);
void Uart3_Config(uint32_t BaudRate);
void DbgUsartRxIrqCallback(void);
void DBGUsartErrIrqCallback(void);
void DBG_RxPinIntCallBack(void);
void SysTick_IrqHandler(void);
void RtcPeriod_IrqCallback(void);
uint16_t SpiSendReceive(uint16_t sData);
uint8_t Spi3_RWByte(M4_SPI_TypeDef *SPIx, uint8_t u8Data);
en_result_t SdioInit(void);
bool SDCardErase(uint32_t u32BlkStartAddr, uint32_t u32BlkEndAddr);
bool SDCardReadBlocks(uint32_t u32BlkStartAddr, uint32_t u32BlkEndAddr, uint8_t *ReadBuff);
bool SDCardWriteBlocks(uint32_t u32BlkStartAddr, uint32_t u32BlkEndAddr, uint8_t *WriteBuff);
void ReadAdcValue(uint16_t *ADValue);
void ADC_Start(void) ;
void ADC_Stop(void) ;
uint16_t *GetADCBuffPoint(void);
uint8_t exf_getfree(uint8_t *drv,uint32_t *total,uint32_t *free);
uint32_t mf_showfree(uint8_t *drv);
void TimeGet(struct tm *cTime);
int TimeTs(void);
void TimeShow(uint32_t dwStamp);
void TimeSync(time_t ts);
void delay_5ns(uint32_t ns);
void ExtInt10IntEnable(void);
void ExtInt10IntDisable(void);
void ExtInt01IntEnable(void);
void ExtInt01IntDisable(void);
void ExtInt04IntEnable(void);
void ExtInt04IntDisable(void);
void ExtInt06IntEnable(void);
void ExtInt06IntDisable(void);
#endif
Project/HC32F460/source/User/Inc/ddl_config.h
+160
View File
@@ -0,0 +1,160 @@
/*******************************************************************************
* Copyright (C) 2020, Huada Semiconductor Co., Ltd. All rights reserved.
*
* This software component is licensed by HDSC under BSD 3-Clause license
* (the "License"); You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*/
/******************************************************************************/
/** \file ddl_config.h
**
** A detailed description is available at
** @link DdlConfigGroup Ddl Config description @endlink
**
** - 2021-04-16 CDT First version for Device Driver Library config.
**
******************************************************************************/
#ifndef __DDL_CONFIG_H__
#define __DDL_CONFIG_H__
/*******************************************************************************
* Include files
******************************************************************************/
/* C binding of definitions if building with C++ compiler */
#ifdef __cplusplus
extern "C"
{
#endif
/**
*******************************************************************************
** \defgroup DdlConfigGroup Device Driver Library config(DDLCONFIG)
**
******************************************************************************/
//@{
/*******************************************************************************
* Global type definitions ('typedef')
******************************************************************************/
/*******************************************************************************
* Global pre-processor symbols/macros ('#define')
******************************************************************************/
/*! Chip module on-off define */
#define DDL_ON (1u)
#define DDL_OFF (0u)
/**
*******************************************************************************
** \brief This is the list of modules to be used in the device driver library
** Select the modules you need to use to DDL_ON.
**
** \note DDL_ICG_ENABLE must be turned on(DDL_ON) to ensure that the chip works
** properly.
**
** \note DDL_UTILITY_ENABLE must be turned on(DDL_ON) if using Device Driver
** Library.
**
** \note DDL_PRINT_ENABLE must be turned on(DDL_ON) if using printf function.
******************************************************************************/
#define DDL_ICG_ENABLE (DDL_ON)
#define DDL_UTILITY_ENABLE (DDL_ON)
#define DDL_PRINT_ENABLE (DDL_OFF)
#define DDL_ADC_ENABLE (DDL_ON)
#define DDL_AES_ENABLE (DDL_OFF)
#define DDL_CAN_ENABLE (DDL_OFF)
#define DDL_CLK_ENABLE (DDL_ON)
#define DDL_CMP_ENABLE (DDL_OFF)
#define DDL_CRC_ENABLE (DDL_OFF)
#define DDL_DCU_ENABLE (DDL_OFF)
#define DDL_DMAC_ENABLE (DDL_ON)
#define DDL_EFM_ENABLE (DDL_ON)
#define DDL_EMB_ENABLE (DDL_OFF)
#define DDL_EVENT_PORT_ENABLE (DDL_OFF)
#define DDL_EXINT_NMI_SWI_ENABLE (DDL_ON)
#define DDL_GPIO_ENABLE (DDL_ON)
#define DDL_HASH_ENABLE (DDL_OFF)
#define DDL_I2C_ENABLE (DDL_OFF)
#define DDL_I2S_ENABLE (DDL_OFF)
#define DDL_INTERRUPTS_ENABLE (DDL_ON)
#define DDL_INTERRUPTS_SHARE_ENABLE (DDL_OFF)
#define DDL_KEYSCAN_ENABLE (DDL_OFF)
#define DDL_MPU_ENABLE (DDL_OFF)
#define DDL_OTS_ENABLE (DDL_OFF)
#define DDL_PWC_ENABLE (DDL_ON)
#define DDL_QSPI_ENABLE (DDL_OFF)
#define DDL_RMU_ENABLE (DDL_OFF)
#define DDL_RTC_ENABLE (DDL_ON)
#define DDL_SDIOC_ENABLE (DDL_OFF)
#define DDL_SPI_ENABLE (DDL_OFF)
#define DDL_SRAM_ENABLE (DDL_ON)
#define DDL_SWDT_ENABLE (DDL_ON)
#define DDL_TIMER0_ENABLE (DDL_OFF)
#define DDL_TIMER4_CNT_ENABLE (DDL_ON)
#define DDL_TIMER4_EMB_ENABLE (DDL_OFF)
#define DDL_TIMER4_OCO_ENABLE (DDL_ON)
#define DDL_TIMER4_PWM_ENABLE (DDL_ON)
#define DDL_TIMER4_SEVT_ENABLE (DDL_OFF)
#define DDL_TIMER6_ENABLE (DDL_ON)
#define DDL_TIMERA_ENABLE (DDL_OFF)
#define DDL_TRNG_ENABLE (DDL_OFF)
#define DDL_USART_ENABLE (DDL_ON)
#define DDL_USBFS_ENABLE (DDL_OFF)
#define DDL_WDT_ENABLE (DDL_OFF)
/*! Midware module on-off define */
#define MW_ON (1u)
#define MW_OFF (0u)
/**
*******************************************************************************
** \brief This is the list of Midware modules to use
** Select the modules you need to use to MW_ON.
******************************************************************************/
#define MW_FS_ENABLE (MW_OFF)
#define MW_SD_CARD_ENABLE (MW_OFF)
#define MW_W25QXX_ENABLE (MW_OFF)
#define MW_WM8731_ENABLE (MW_OFF)
/* BSP on-off define */
#define BSP_ON (1u)
#define BSP_OFF (0u)
/**
* @brief The following is a list of currently supported BSP boards.
*/
#define BSP_EV_HC32F460_LQFP100_V1 (1u)
#define BSP_EV_HC32F460_LQFP100_V2 (2u)
/**
* @brief The macro BSP_EV_HC32F460 is used to specify the BSP board currently
* in use.
* The value should be set to one of the list of currently supported BSP boards.
* @note If there is no supported BSP board or the BSP function is not used,
* the value needs to be set to BSP_EV_HC32F460.
*/
#define BSP_EV_HC32F460 (BSP_EV_HC32F460_LQFP100_V2)
/*******************************************************************************
* Global variable definitions ('extern')
******************************************************************************/
/*******************************************************************************
* Global function prototypes (definition in C source)
******************************************************************************/
//@} // DdlConfigGroup
#ifdef __cplusplus
}
#endif
#endif /* __DDL_CONFIG_H__ */
/*******************************************************************************
* EOF (not truncated)
******************************************************************************/
Project/HC32F460/source/User/Inc/main.h
+173
View File
@@ -0,0 +1,173 @@
#ifndef __MAIN__H
#define __MAIN__H
#include <stdlib.h>
#include "bsp.h"
#define USE_FILE_SYSTEM 1
#define SDCARD_BLOCK_MAX (10000)
#define OSC_CNT 40
#define SLOPE_CNT 20
#define SLOPE_VPT 1000
#define PRESS_VPT 3
#define FOLLOW_VPT 10
#define SHIELD_VPT 5000
#define EME_STOP_VPT 4000
#define CENTRE_VPT 2000
#define STOP_TIME_MS 500
#define RUN_TIME_MS 0
#define EME_START_MS 0
#define EME_STOP_MS 2000
#define SLOPE_START_MS 3000
#define TRAVEL_TIME_MS 30000
#define PEAK 1200 //1200mm
#define VALLEY 720 //720mm
#define BDC_STOP() (SET_TWIN_BIT0(),SET_TWIN_BIT1())
#define BDC_UP() (SET_TWIN_BIT0(),CLR_TWIN_BIT1())
#define BDC_DOWN() (SET_TWIN_BIT1(),CLR_TWIN_BIT0())
//#define BDC_STOP() Motor_Control(MOTOR_CMD_STOP)
//#define BDC_UP() Motor_Control(MOTOR_CMD_FORWARD)
//#define BDC_DOWN() Motor_Control(MOTOR_CMD_REVERSE)
/*控制等级*/
typedef enum {
LEVEL_1 = 1, // 一级
LEVEL_2 = 2, // 二级
LEVEL_3 = 3, // 三级
LEVEL_4 = 4, // 四级
LEVEL_5 = 5 // 五级
}ControlLevel_m;
/*设备阈值*/
typedef struct{
int32_t Slope_VPT;
int32_t Stop_VPT;
int32_t LeftUpVPT;//左上设备阈值
int32_t LeftLowVPT;//左下设备阈值
int32_t RightUpVPT;//右上设备阈值
int32_t RightLowVPT;//右下设备阈值
int32_t LeftUpShieldVPT; //左上屏蔽阈值
int32_t LeftLowShieldVPT; //左下屏蔽阈值
int32_t RightUpShieldVPT; //右上屏蔽阈值
int32_t RightLowShieldVPT; //右下屏蔽阈值
int32_t LeftUp_Org_AdZero;//左上设备原始AD零点
int32_t LeftLow_Org_AdZero;//左下设备原始AD零点
int32_t RightUp_Org_AdZero;//右上设备原始AD零点
int32_t RightLow_Org_AdZero;//右下设备原始AD零点
}ADTrack_t;
typedef struct{//电机参数
bool InitialFlag;//初始标志位
bool RestFlag;
bool CaliFlag;
bool LoopOne;//循环一次标志位
int16_t Current_height;//当前高度mm
int16_t CaliNum;//标校数量
int32_t LU_HeightStress[488];//左上传感器对应高度应力
int32_t LL_HeightStress[488];//左下传感器对应高度应力
int32_t RU_HeightStress[488];//右上传感器对应高度应力
int32_t RL_HeightStress[488];//右上传感器对应高度应力
}MotorPara_t;
/*数据读取状态机*/
typedef enum {
READ_STATUS_IDLE,
READ_STATUS_START,
READ_STATUS_LEFTUP,
READ_STATUS_WAIT_LEFTUP,
READ_STATUS_LEFTLOW,
READ_STATUS_WAIT_LEFTLOW,
READ_STATUS_RIGHTUP,
READ_STATUS_WAIT_RIGHTUP,
READ_STATUS_RIGHTLOW,
READ_STATUS_WAIT_RIGHTLOW,
READ_STATUS_SUPPORT_CONT
}ReadStatus_m;
/*主程序状态机*/
typedef enum {
APP_STATUS_IDLE,
APP_STATUS_ON,
APP_STATUS_OFF,
APP_STATUS_MOTOR_INIT,
APP_STATUS_WAIT_MOTOR_INIT,
APP_STATUS_WAIT_MOTOR_CALI_UP,
APP_STATUS_WAIT_MOTOR_CALI_DOWN,
APP_STATUS_WAIT_STEADY,
APP_STATUS_ZERO_MARKING,
APP_STATUS_HEIGHT_CONTROL,
}AppStatus_m;
typedef struct{
__IO uint16_t rPayLen;
__IO bool HeaderFrame;
__IO uint16_t RxLen;
uint8_t RxBuff[10];
}Uart1Rx_t;
typedef struct{
__IO uint16_t rPayLen;
__IO bool HeaderFrame;
__IO uint16_t RxLen;
uint8_t RxBuff[4];
}Uart3Rx_t;
typedef struct {
AppStatus_m Status;//状态
ReadStatus_m RStatus;
AppPara_T Para;
Uart1Rx_t RxUart1Data;
Uart3Rx_t RxUart3Data;
ADTrack_t ADTrack;
MotorPara_t MotorPara;
uint32_t TD1mSDelayCnt;
uint32_t Read1mSDelayCnt;
uint32_t Uart1Delay1mSCnt;
uint32_t Uart3RxTimeOut1mSCnt;
uint32_t StopCollDelay1mSCnt;
uint32_t RunCollDelay1mSCnt;
uint32_t EmergencyDelay1mSCnt;
uint32_t SlopeCollDelay1mSCnt;
uint32_t CailUp1mSCnt;
uint32_t HeightContRolCnt;
uint8_t FeedDogDlyCnt;
bool CaliZeroFlag;//校零标志位
bool SideFlag;//侧压标志位
bool UpFlag;//上升标志位
bool DownFlag;//下降标志位
bool StopFlag;//停止标志位
bool EmeFlag;//应急标志位
bool LeftRunFalg;
bool RightRunFalg;
bool CentreRunFalg;
bool LeftUpCS1237ReadEndFlag;
bool LeftLowCS1237ReadEndFlag;
bool RightUpCS1237ReadEndFlag;
bool RightLowCS1237ReadEndFlag;
int32_t LeftUpCS1237_TrendArray[OSC_CNT];
int32_t LeftLowCS1237_TrendArray[OSC_CNT];
int32_t RightUpCS1237_TrendArray[OSC_CNT];
int32_t RightLowCS1237_TrendArray[OSC_CNT];
int32_t LeftUpCS1237_SlopeArray[SLOPE_CNT];
int32_t LeftLowCS1237_SlopeArray[SLOPE_CNT];
int32_t RightUpCS1237_SlopeArray[SLOPE_CNT];
int32_t RightLowCS1237_SlopeArray[SLOPE_CNT];
bool WaitFlag;
}AppDetect_t;
extern AppDetect_t App;
#endif
Project/HC32F460/source/User/Src/ADS1231.c
+126
View File
@@ -0,0 +1,126 @@
#include "ADS1231.h"
extern float Temperature;
void ADS1231_Open(void)
{
PDWN1_SET();
PDWN2_SET();
PDWN3_SET();
PDWN4_SET();
}
void ADS1231_HighSpeedSet(void)
{
SPEED1_SET();
SPEED2_SET();
SPEED3_SET();
SPEED4_SET();
}
void ADS1231_LowSpeedSet(void)
{
SPEED1_RESET();
SPEED2_RESET();
SPEED3_RESET();
SPEED4_RESET();
}
uint32_t GpioAGetDout(en_pin_t enPin)
{
return *(uint32_t *)((uint32_t)(&M4_PORT->PIDRA)) & (enPin);
}
uint32_t GpioBGetDout(en_pin_t enPin)
{
return *(uint32_t *)((uint32_t)(&M4_PORT->PIDRB)) & (enPin);
}
bool ADS1231_Read(uint32_t *r_data, uint8_t channel) {
uint8_t i;
uint32_t data = 0;
switch(channel) {
case 0:
if(GpioAGetDout(DRDY_DOUT1_PIN) != 0)
return false;
for(i = 0; i < 24; i++) {
SCLK1_SET();
data <<= 0x01;
__NOP(); __NOP(); __NOP(); __NOP(); __NOP(); __NOP();
SCLK1_RESET();
if(GpioAGetDout(DRDY_DOUT1_PIN) != 0)
data |= 0x01;
}
SCLK1_SET();
__NOP(); __NOP(); __NOP(); __NOP(); __NOP(); __NOP();
SCLK1_RESET();
break;
case 1:
if(GpioAGetDout(DRDY_DOUT2_PIN) != 0)
return false;
for(i = 0; i < 24; i++) {
SCLK2_SET();
data <<= 0x01;
__NOP(); __NOP(); __NOP(); __NOP(); __NOP(); __NOP();
SCLK2_RESET();
__NOP(); __NOP();
if(GpioAGetDout(DRDY_DOUT2_PIN) != 0)
data |= 0x01;
}
SCLK2_SET();
__NOP(); __NOP(); __NOP(); __NOP(); __NOP(); __NOP();
SCLK2_RESET();
break;
case 2:
if(GpioBGetDout(DRDY_DOUT3_PIN) != 0)
return false;
for(i = 0; i < 24; i++) {
SCLK3_SET();
data <<= 0x01;
__NOP(); __NOP(); __NOP(); __NOP(); __NOP(); __NOP();
SCLK3_RESET();
if(GpioBGetDout(DRDY_DOUT3_PIN) != 0 )
data |= 0x01;
}
SCLK3_SET();
__NOP(); __NOP(); __NOP(); __NOP(); __NOP(); __NOP();
SCLK3_RESET();
break;
case 3:
if(GpioBGetDout(DRDY_DOUT4_PIN) != 0 )
return false;
for(i = 0; i < 24; i++) {
SCLK4_SET();
data <<= 0x01;
__NOP(); __NOP(); __NOP(); __NOP(); __NOP(); __NOP();
SCLK4_RESET();
if(GpioBGetDout(DRDY_DOUT4_PIN) != 0 )
data |= 0x01;
}
SCLK4_SET();
__NOP(); __NOP(); __NOP(); __NOP(); __NOP(); __NOP();
SCLK4_RESET();
break;
default:
return false;
}
if(data <= 0x00ffffff) {
if(data > 0x007fffff)
*r_data = data|0xff000000;
else
*r_data = data;
}
else
return false;
return true;
}
Project/HC32F460/source/User/Src/Algorithm.c
+1057
View File
File diff suppressed because it is too large Load Diff
Project/HC32F460/source/User/Src/Debug.c
+405
View File
@@ -0,0 +1,405 @@
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stdarg.h>
#include "Debug.h"
#include "main.h"
#include "bsp.h"
#include "dc_motor.h"
#if (USE_DEBUG != 0)
#define DEBUG_CMD_CNT 8
const DBGFunType DebugFun[DEBUG_CMD_CNT];
static char buff[BUFSIZE];
volatile uint16_t iw=0; /* buffer write index*/
static uint16_t ir=0; /* buffer read index*/
static uint16_t DebugRxTimeOut1mSCnt;
static char RxBuff[128];
static uint8_t RxLen = 0;
void vcom_Print(uint8_t sLen);
void vcom_Send( char *format, ... )
{
va_list args;
va_start(args, format);
uint8_t len;
char tempBuff[DEBUG_BUFF_SIZE_MAX];
//uint32_t primask_bit;
uint8_t offset = 0;
//primask_bit = __get_PRIMASK();
//__disable_irq();
/*convert into string at buff[0] of length iw*/
len = vsprintf(&tempBuff[0], format, args);
while(offset < len) {
if((len - offset) < BUFSIZE) {
memcpy(&buff[0], &tempBuff[offset], len - offset);
vcom_Print(len - offset);
offset = len;
}
else {
memcpy(&buff[0], &tempBuff[offset], BUFSIZE);
offset += BUFSIZE;
vcom_Print(BUFSIZE);
}
}
//__set_PRIMASK(primask_bit);
//__enable_irq();
va_end(args);
}
// 定义一个函数vcom_Print，用于打印字符串
void vcom_Print(uint8_t sLen)
{
// 定义一个字符指针CurChar
char* CurChar;
// 初始化ir
ir = 0;
// 当ir小于sLen时，循环执行
while(ir < sLen)
{
// 获取字符指针CurChar
CurChar = &buff[ir++];
// 调用DebugUartSend函数，发送CurChar指向的字符，次数为1
DebugUartSend((uint8_t*)CurChar, 1);
}
}
// 定义一个函数vcom_Send2，用于发送字符串
void vcom_Send2(uint8_t *sData, uint16_t len)
{
// 遍历sData，将每个元素发送到DebugUartSend
for(int i = 0; i < len; i++) {
DebugUartSend(&sData[i], 1);
}
}
void DebugLoopHandler(void)
{
int argc = 0;
char *argv[10], *argp;
if(DebugRxTimeOut1mSCnt > 0 || RxLen == 0)
return;
//for(argv[argc] = strtok(RxBuff, " "); argv[argc] != NULL; argv[++argc] = strtok(NULL, " "));
// 解析字符串，将参数放入argv数组中
argp = strtok(RxBuff, " ");
for(int i = 0; i < 10; i++) {
if(argp != NULL) {
argv[argc++] = argp;
argp = strtok(NULL, " ");
}
else if(argc > 0){
argc--;
break;
}
}
// 获取第一个参数，并将其赋值给argp
argp = strtok(argv[argc], "'\r'");
// 如果argp不为空，则将argp的值赋值给argv[argc]，并将argc加1
if(argp != NULL) {
argv[argc++] = argp;
}
// 否则，将RxLen设置为0，并返回
else {
RxLen = 0;
return;
}
// 遍历DebugFun数组，查找argv[0]是否与DBGCmd匹配，若匹配则调用DBGExec函数
for(int i = 0; i < DEBUG_CMD_CNT; i++) {
if(strcmp(argv[0], DebugFun[i].DBGCmd) == 0)
DebugFun[i].DBGExec(argc, argv);
}
memset(RxBuff, 0x00, 128);
RxLen = 0;
}
uint32_t RxTimeCurrent;
uint32_t RxTimeLast = 0;
// 函数：Dbg1msRoutine
// 功能：1ms调试时钟routine
void Dbg1msRoutine(void)
{
// 如果1ms调试时钟计数器大于0
if(DebugRxTimeOut1mSCnt > 0)
// 1ms调试时钟计数器减1
DebugRxTimeOut1mSCnt--;
}
// 定义函数DbgUsartRxIrqCallback，用于处理串口接收中断
void DbgUsartRxIrqCallback(void)
{
// 如果1分钟超时计数器为0，则清空RxLen
if(DebugRxTimeOut1mSCnt == 0)
RxLen = 0;
// 重置1分钟超时计数器
DebugRxTimeOut1mSCnt = 3;
// 读取串口接收到的数据
uint8_t Data = DbgUartRec();
// 如果RxLen小于128，则将数据添加到RxBuff中
if(RxLen < 128) {
RxBuff[RxLen++] = Data;
}
// DBG_LOG("RxBuff = %s\n", RxBuff);
// RS485_Flag=1;//接收标志为置1
}
void DebugTest(int argc, char *argv[])
{
// 如果参数个数小于2，则返回
if(argc < 2)
return;
// 如果参数为“?”，则打印帮助信息
if(strcmp(argv[1], "?") == 0)
{
DBG_LOG("Debug Cmd:\r\n\
disp task on/off -->Open the task display.\r\n");
return;
}
// 如果参数为“on”，则打印“Test ON”
if(strcmp(argv[1], "on") == 0)
{
// TestOn();
DBG_LOG("Test ON\r\n");
}
// 如果参数为“off”，则打印“Test OFF”
else if(strcmp(argv[1], "off") == 0)
{
// TestOFF();
DBG_LOG("Test OFF\r\n");
}
}
#if 0
void DebugCmdGps(int argc, char *argv[])
{
if(argc < 2)
return;
if(strcmp(argv[1], "?") == 0) {
DBG_LOG("Debug Cmd:\r\n\
gps on/off -->Turn the gps on or off.\r\n");
return;
}
if(strcmp(argv[1], "on") == 0) {
GPSStart();
}
else if(strcmp(argv[1], "off") == 0) {
GPSStop();
}
}
#endif
void DebugCmdHelp(int argc, char *argv[])
{
DBG_LOG("Debug Cmd:\r\n\
disp task on/off -->Open the task display.\r\n\
help\
motor\
level\
wave\
");
}
#if 0
//// 定义一个无参函数DebugReadData，用于读取数据
//void DebugReadData(int argc, char *argv[])
//{
// // 定义一个无符号32位整数ADReadStart，初始值为0
// uint32_t ADReadStart = 0;
// // 定义一个ADData_t类型的数组ADBuff，大小为640
// ADData_t ADBuff[640];
//
// // 当ADReadStart小于SDCARD_BLOCK_MAX时，循环执行
// while(ADReadStart < SDCARD_BLOCK_MAX) {
// // 使用SDCardReadBlocks函数读取数据，从ADReadStart开始，读取10个块，数据存储在ADBuff中
// SDCardReadBlocks(ADReadStart, 10, (uint8_t *)ADBuff);
// // 遍历ADBuff数组，将每个元素打印出来
// for(int i = 0; i < 640; i++) {
// DBG_LOG("%d\t%d\t%d\t%d\r\n", ADBuff[i].AD0, ADBuff[i].AD1, ADBuff[i].AD2, ADBuff[i].AD3);
// }
// // ADReadStart加10
// ADReadStart += 10;
// }
//}
//// 定义一个函数SetTime，参数为int argc和char *argv[]
//void SetTime(int argc, char *argv[])
//{
// // 定义一个字符数组test，并初始化为0
// char test[10] = 0;
// // 定义一个整数num，并初始化为0
// int num = 0;
// // 如果argc小于2，则返回
// if(argc < 2)
// return;
// // 如果argv[1]等于"?"，则打印提示信息
// if(strcmp(argv[1], "?") == 0)
// {
// DBG_LOG("SetTime Cmd:\r\n\
// disp task on/off -->Open the task display.\r\n");
// return;
// }
// // 将argv[1]的值复制到test
// memcpy(test, (char *)argv[1], 10);
// // 将test转换为整数
// num = atoi(test);
// // 调用TimeSync函数，并将num作为参数传入
// TimeSync(num);
//}
#endif
extern uint8_t KeyASta;
extern uint8_t KeyBSta;
extern uint8_t RunSta;
void MotorSwitch(int argc, char *argv[])
{
// 如果参数个数小于2，则返回
if(argc < 2)
return;
// 如果第一个参数为？，则打印帮助信息
if(strcmp(argv[1], "?") == 0)
{
DBG_LOG("DCMotor Cmd:\r\n\
motor F/R/S -->Turn the motor on or off.\r\n");
return;
}
// 如果第一个参数为on，则开启SonarWork
if(strcmp(argv[1], "R") == 0)
{
KeyASta = true;
Motor_Control(MOTOR_CMD_REVERSE);
DBG_LOG("Motor FORWARD\r\n");
}
// 如果第一个参数为off，则关闭SonarWork
else if(strcmp(argv[1], "F") == 0)
{
KeyBSta = true;
Motor_Control(MOTOR_CMD_FORWARD);
DBG_LOG("Motor REVERSE\r\n");
}
else if(strcmp(argv[1], "S") == 0)
{
KeyASta = false;
KeyBSta = false;
Motor_Control(MOTOR_CMD_STOP);
DBG_LOG("Motor OFF\r\n");
}
}
extern void GradeControl(ControlLevel_m level);
void LevelSwitch(int argc, char *argv[])
{
// 如果参数个数小于2，则返回
if(argc < 2)
return;
// 如果参数为“?”，则打印帮助信息
if(strcmp(argv[1], "?") == 0)
{
DBG_LOG("level Cmd:\r\n\
level 1/2/3/4/5 -->Select control level.\r\n");
return;
}
// 如果参数为“1”，则打印“Set control level: 1”
if(strcmp(argv[1], "1") == 0)
{
App.Para.Layout.ControlLevel = LEVEL_1;//等级1
SAVE_APP_PARA((uint32_t *)&App.Para);
DBG_LOG("Set control level: 1\r\n");
DBG_LOG("SystemReset...\r\n");
NVIC_SystemReset();
}
// 如果参数为“2”，则打印“Set control level: 2”
else if(strcmp(argv[1], "2") == 0)
{
App.Para.Layout.ControlLevel = LEVEL_2;//等级2
SAVE_APP_PARA((uint32_t *)&App.Para);
DBG_LOG("Set control level: 2\r\n");
DBG_LOG("SystemReset...\r\n");
NVIC_SystemReset();
}
// 如果参数为“3”，则打印“Set control level: 1”
else if(strcmp(argv[1], "3") == 0)
{
App.Para.Layout.ControlLevel = LEVEL_3;//等级3
SAVE_APP_PARA((uint32_t *)&App.Para);
DBG_LOG("Set control level: 3\r\n");
DBG_LOG("SystemReset...\r\n");
NVIC_SystemReset();
}
// 如果参数为“4”，则打印“Set control level: 4”
else if(strcmp(argv[1], "4") == 0)
{
App.Para.Layout.ControlLevel = LEVEL_4;//等级4
SAVE_APP_PARA((uint32_t *)&App.Para);
DBG_LOG("Set control level: 4\r\n");
DBG_LOG("SystemReset...\r\n");
NVIC_SystemReset();
}
// 如果参数为“5”，则打印“Set control level: 5”
else if(strcmp(argv[1], "5") == 0)
{
App.Para.Layout.ControlLevel = LEVEL_5;//等级5
SAVE_APP_PARA((uint32_t *)&App.Para);
DBG_LOG("Set control level: 5\r\n");
DBG_LOG("SystemReset...\r\n");
NVIC_SystemReset();
}
}
void DBGWave_on_off(int argc, char *argv[])
{
// 如果参数个数小于2，则返回
if(argc < 2)
return;
// 如果参数为“?”，则打印帮助信息
if(strcmp(argv[1], "?") == 0)
{
DBG_LOG("wave Cmd:\r\n\
wave on/off -->Turn on or off waveform output.\r\n");
return;
}
// 如果参数为“on”，则打印“Test ON”
if(strcmp(argv[1], "on") == 0)
{
App.Para.Layout.DBGWaveOut = true;
SAVE_APP_PARA((uint32_t *)&App.Para);
DBG_LOG("Waveform output on.\r\n");
}
// 如果参数为“off”，则打印“Test OFF”
else if(strcmp(argv[1], "off") == 0)
{
App.Para.Layout.DBGWaveOut = false;
SAVE_APP_PARA((uint32_t *)&App.Para);
DBG_LOG("Waveform output off.\r\n");
}
}
const DBGFunType DebugFun[DEBUG_CMD_CNT] = {
"help", DebugCmdHelp,
"motor", MotorSwitch,
"level", LevelSwitch,
"wave", DBGWave_on_off,
};
#endif
Project/HC32F460/source/User/Src/Encryption.c
+87
View File
@@ -0,0 +1,87 @@
#include "Encryption.h"
//从机加密表
const unsigned char EPT_Table[32][6] = {
{1, 6, 4, 2, 3, 5}, {2, 4, 6, 3, 5, 1}, {3, 5, 6, 2, 1, 4}, {5, 3, 2, 1, 4, 6},
{4, 2, 3, 1, 5, 6}, {6, 3, 5, 1, 4, 2}, {3, 5, 2, 6, 4, 1}, {2, 5, 4, 3, 1, 6},
{2, 4, 1, 5, 3, 6}, {4, 6, 1, 3, 2, 5}, {4, 2, 1, 5, 6, 3}, {3, 2, 6, 5, 1, 4},
{2, 6, 5, 1, 4, 3}, {6, 4, 3, 1, 2, 5}, {1, 6, 3, 2, 4, 5}, {5, 3, 4, 6, 2, 1},
{5, 3, 1, 2, 6, 4}, {1, 4, 2, 6, 5, 3}, {3, 5, 2, 1, 4, 6}, {6, 1, 4, 2, 3, 5},
{4, 1, 2, 5, 3, 6}, {4, 2, 6, 3, 5, 1}, {2, 6, 1, 4, 3, 5}, {4, 3, 1, 5, 6, 2},
{5, 1, 2, 4, 6, 3}, {6, 5, 1, 3, 4, 2}, {2, 1, 6, 3, 5, 4}, {1, 5, 6, 3, 4, 2},
{3, 6, 5, 4, 2, 1}, {1, 2, 6, 3, 5, 4}, {4, 6, 5, 3, 2, 1}, {5, 3, 4, 2, 6, 1}
};
//从机解密表：
const unsigned char DPT_Table[32][5] ={
{1, 4, 2, 3, 5}, {2, 4, 3, 5, 1}, {3, 5, 2, 1, 4}, {5, 3, 2, 1, 4},
{4, 2, 3, 1, 5}, {3, 5, 1, 4, 2}, {3, 5, 2, 4, 1}, {2, 5, 4, 3, 1},
{2, 4, 1, 5, 3}, {4, 1, 3, 2, 5}, {4, 2, 1, 5, 3}, {3, 2, 5, 1, 4},
{2, 5, 1, 4, 3}, {4, 3, 1, 2, 5}, {1, 3, 2, 4, 5}, {5, 3, 4, 2, 1},
{5, 3, 1, 2, 4}, {1, 4, 2, 5, 3}, {3, 2, 1, 4, 5}, {1, 4, 5, 2, 3},
{4, 1, 2, 5, 3}, {4, 2, 3, 5, 1}, {2, 1, 4, 3, 5}, {4, 3, 1, 5, 2},
{5, 1, 2, 4, 3}, {5, 1, 3, 4, 2}, {2, 1, 3, 5, 4}, {1, 5, 3, 4, 2},
{3, 5, 4, 2, 1}, {1, 2, 3, 5, 4}, {4, 5, 3, 2, 1}, {5, 3, 4, 2, 1}
};
//数据位加密表：
const unsigned char EPT_D[32] = {
0x23, 0x4c, 0x92, 0x38, 0x52, 0xa4, 0x9a, 0x61,
0x86, 0xc8, 0x70, 0x16, 0x32, 0x58, 0x62, 0x83,
0xa5, 0x16, 0x1c, 0x49, 0x48, 0xc1, 0x8c, 0x91,
0xd0, 0x2c, 0x49, 0x42, 0xc1, 0x8c, 0x98, 0xd0
};
/****************************************************************/
/* 加密函数 */
/* */
/*函数入口: *data,未加密的普通协议数据 */
/* */
/*函数出口: *EPT_data，生成的加密协议 */
/****************************************************************/
void Encrypt_Code(unsigned char *data, unsigned char *EPT_data) {
unsigned char Edata[6];
unsigned char i = 0;
unsigned char check;
unsigned char ept_byte;
check = (data[0]+data[1]+data[2]+data[3]+data[4]+data[5]) % 0xff;
ept_byte = check % 32;
for (i = 0; i < 6; i++) {
Edata[i] = ((~(data[i] & EPT_D[ept_byte])) & EPT_D[ept_byte]) | (data[i] & (~EPT_D[ept_byte]));
}
for (i = 0; i < 6; i++) {
EPT_data[i] = Edata[EPT_Table[ept_byte][i]-1];
}
EPT_data[6] = ((~(check & 0xaa)) & 0xaa) | (check & 0x55);
}
/****************************************************************/
/* 解密函数 */
/* */
/*函数入口： *EPT_data，需要解密的加密协议 */
/* */
/*函数出口： *DPT_data，生成的普通协议 */
/****************************************************************/
void Decrypt_Code(unsigned char *EPT_data,unsigned char *DPT_data) {
unsigned char data[5];
unsigned char i = 0;
unsigned char check;
unsigned char ept_byte;
check = ((~(EPT_data[5]&0xaa))&0xaa)|(EPT_data[5]&0x55);
ept_byte = check % 32;
for(i=0;i<5;i++) {
data[i] = ((~(EPT_data[i]&EPT_D[ept_byte]))&EPT_D[ept_byte])|(EPT_data[i]&(~EPT_D[ept_byte]));
}
for(i=0;i<5;i++) {
DPT_data[DPT_Table[ept_byte][i]-1] = data[i];
}
DPT_data[5] = check;
}
Project/HC32F460/source/User/Src/bsp.c
+1624
View File
File diff suppressed because it is too large Load Diff
Project/HC32F460/source/User/Src/main.c
+1354
View File
File diff suppressed because it is too large Load Diff