LoRa 无线通信模块 之 发送0.01V

参考的原子哥的例程，谢谢原子哥，你真伟大。佩服！！！
他们都是 比较牛的人，就是把自己会的毫无保留的分享给后辈学习。
代码是先.c 文件 后.h文件。
注意其中的的IO 口配置。
我亲自测试通过，接收可以收到准确的信息。
KEIL 4 编译通过，keil5 编译通过。
有错误一定给说说，我好进步谢谢。

#include “sys.h”
#include “usart.h”
#include “delay.h”
#include “lora.h”

int main(void)
{
u8 suk;
Stm32_Clock_Init(9); //系统时钟设置
delay_init(72); //延时初始化
uart_init(72,115200); //串口初始化为9600
printf(“开始 Lora 无线测试\r\n”);
suk = LoRa_Init();
while(LoRa_Init())
{
delay_ms(300);
printf("\r\n 初始化 不成功 \r\n");
}
printf("\r\n 初始化 成功 \r\n");

printf("初始化 LoRa_Init = %d\r\n",suk);


printf("\r\n 配置 lora 模块 \r\n");
LoRa_Set();     //lora 配置 设置串口波特率 

    
while(1)
{   
  delay_ms(1000);	
  printf("Lora 正在 发送 数据 \r\n");
  if(!LORA_AUX&&(LoRa_CFG.mode!=LORA_MODE_SLEEP))//空闲且非省电模式
  {
		 LoRa_SendData();//发送数据    
   }
		
	//数据接收
	//LoRa_ReceData();
}

}

#include “lora.h”
#include “stdarg.h”
#include “stdio.h”
#include “string.h”
#include “sys.h”
#include “usart.h”
#include “delay.h”
#include “usart2.h”

//设备参数初始化(具体设备参数见lora_cfg.h定义)
_LoRa_CFG LoRa_CFG=
{
.addr = LORA_ADDR, //设备地址
.power = LORA_POWER, //发射功率
.chn = LORA_CHN, //信道
.wlrate = LORA_RATE, //空中速率
.wltime = LORA_WLTIME, //睡眠时间
.mode = LORA_MODE, //工作模式
.mode_sta = LORA_STA, //发送状态
.bps = LORA_TTLBPS , //波特率设置
.parity = LORA_TTLPAR //校验位设置
};

/**********************************
//将1个字符转换为16进制数字
//chr:字符,0_9/AF/a~F
//返回值:chr对应的16进制数值
***********************************/
u8 chr2hex(u8 chr)
{
if(chr>=‘0’&&chr<=‘9’)return chr-‘0’;
if(chr>=‘A’&&chr<=‘F’)return (chr-‘A’+10);
if(chr>=‘a’&&chr<=‘f’)return (chr-‘a’+10);
return 0;
}

/*******************************
//字符转成16进制数据
//test[] 存储位置
//buffer[] 需转换的数组
//len： 长度
*********************************/
void char2hex_buff(u8 test[],u8 buff[],u8 len)
{
u8 i=0;
for(i=0;i {
test[i] = chr2hex(buff[i]);
}
}

/****************************
//将16进制数据转换成数字
******************************/
u32 hexbuff_num(u8 test[],u8 buff[],u8 len)
{
u8 i=0;
u32 num=0;

for(i=0;i

}

/***********************
//计算数字位数
//如:100,3位数、10,1位数
***************************/
u8 num_count(u32 num)
{
u32 date=0;
u8 count=0;

date = num;
do
{
	count++;
	date/=10;
}while(date>0);

return count;

}

/**************************************
LoRa 发送命令后,检测接收到的应答
str:期待的应答结果
返回值: 0, 没有得到期待的应答结果
其他,期待应答结果的位置(str的位置)
*****************************************/
u8 lora_check_cmd(u8 str)
{
char strx=0;
if(USART2_RX_STA&0X8000) //接收到一次数据了
{
USART2_RX_BUF[USART2_RX_STA&0X7FFF]=0;//添加结束符
strx=strstr((const char)USART2_RX_BUF,(const char)str);
}
return (u8)strx;
}

/*****************
strx=strstr((const char*)USART2_RX_BUF,(const char*)str);

strstr(str1,str2);
函数用于判断字符串str2 是否是str1 的子串
如果 是 则该函数返回str2 在str1 中首次出现的地址；
否 返回NULL
*******************/

/***********************************
LoRa 发送命令:
cmd 发送的命令字符串 不需要添加回车
当cmd<0xff发送数字 大于发送字符串
ack 期待的应答结果 如果为空 则表示不需要等待应答
waitime 等待时间 单位是10ms
返回: 0 发送成功
1 发送失败
****************************************/
u8 lora_send_cmd(u8 *cmd,u8 *ack,u16 waittime)
{
u8 res=0;

USART2_RX_STA=0;      //接收置 0 

if((u32)cmd<=0XFF)           //发送数字   
{
	while((USART2->SR&0x40)==0); //等到发送 完成
	USART2->DR=(u32)cmd; 
}
else 
     u2_printf("%s\r\n",cmd);  //发送命令

/************
发送的命令 字符串 当CMD<=0XFF 发送数字
大于 时发送字符串
*********/
if(ack&&waittime) //需要等待应答
{
while(–waittime) //等待倒计时
{
delay_ms(10);
if(USART2_RX_STA&0X8000)//接收到期待的应答结果
{
if(lora_check_cmd(ack))
{
printf(" 命令发送成功\r\n");
USART2_RX_STA=0;
break;//得到有效数据
}
}
}
if(waittime==0)res=1;
}
return res;
}

/******************************
设备工作模式 用于记录设备状态
*******************************/
u8 Lora_mode = 0;
// 0 配置模式
// 1 接收模式
// 2 发送模式
static u8 int_mode=0;
//0 关闭
//1 上升
//2 下降
//aux 配置中断设置
//mode 配置模式
// 0 关闭
// 1 上升沿
// 2 下降沿
void aux_init(u8 mode)
{
if(!mode)
{
EXTI->IMR &=~(1<<4); //关闭LINE4 中断
NVIC->ICER[EXTI4_IRQn>>0x05] =
(uint32_t)0x01<<(EXTI4_IRQn&(uint8_t)0x1f);
}else
{
if(mode1)
{EXTI->RTSR|=1<<4;} //上升触发
else if(mode2)
{EXTI->FTSR|=1<<4;} //下降触发
EXTI->IMR|=1<<4; //开启line 4 上的中断
NVIC->ICER[EXTI4_IRQn>>0x05] =(uint32_t)0x01<<(EXTI4_IRQn&(uint8_t)0x1f);
}
int_mode = mode; //记录中断模式
}

/****************
LORA_AUX中断服务函数
********************/

void EXTI4_IRQHandler(void)
{
if(EXTI->PR & (1<<4))
{
if(int_mode1)//上升沿(发送:开始发送数据 接收:数据开始输出)
{
if(Lora_mode1)//接收模式
{
USART2_RX_STA=0;//数据计数清0
}
int_mode=2;//设置下降沿

   }
   else if(int_mode==2)//下降沿(发送:数据已发送完 接收:数据输出结束)	
   {
	  if(Lora_mode==1)//接收模式
	  {
		 USART2_RX_STA|=1<<15;//数据计数标记完成
	  }else if(Lora_mode==2)//发送模式(串口数据发送完毕)
	  {
		 Lora_mode=1;//进入接收模式
	  }
	  int_mode=1;//设置上升沿
     	   
   }
   aux_init(int_mode);//重新设置中断边沿
   EXTI->PR=1<<4;     //清除LINE4上的中断标志位  
}

}

/*****************
LoRa 模块参数配置
******************/
void LoRa_Set(void)
{
static u8 sendbuf[20];
static u8 lora_addrH,lora_addrL = 0;

usart2_set(LORA_TTLBPS_115200,LORA_TTLPAR_8N1); //115200 波特率 1位停止位 无检验位
usart2_rx(1); //开启串口 2 接收

while(LORA_AUX); //等待模块空闲
LORA_MD0 = 1; //进入配置模式
delay_ms(40);
Lora_mode = 0; //标记配置模式
lora_addrH = (0>>8)&0xff; //地址
lora_addrL = 0&0xff; //地址
//lora_addrH = (LoRa_CFG.addr>>8)&0xff;
//lora_addrL = LoRa_CFG.addr&0xff;
lora_send_cmd(“AT”,“OK”,70); //设置 设备地址

//设置 设备地址
sprintf((char*)sendbuf,“AT+ADDR=%02x,%02x”,lora_addrH,lora_addrL);
lora_send_cmd(sendbuf,“ok”,50);
printf(“设备地址 :%s\r\n”,sendbuf);

//设置信道和空中速率
sprintf((char*)sendbuf,“AT+WLRATE=%d,%d”,23,5);
lora_send_cmd(sendbuf,“ok”,50);
printf(“设置设备信道 空中速率:%s\r\n”,sendbuf);

//设置 发射功率
sprintf((char *)sendbuf,“AT+TPOWER=%d”,3);
lora_send_cmd(sendbuf,“ok”,50);
printf(“设置发射功率 %s:”,sendbuf);

//一般模式
sprintf((char *)sendbuf,“AT+CWMODE=%d”,0);
lora_send_cmd(sendbuf,“ok”,50);
printf(“模式 设置 %s:”,sendbuf);

//设置发送 状态
sprintf((char *)sendbuf,“AT+TMODE=%d”,0); //发送状态是 透明传输
lora_send_cmd(sendbuf,“ok”,50);
printf(“发送 状态 %s:”,sendbuf);

//设置 睡眠 时间
sprintf((char *)sendbuf,“AT+WLTIME=%d”,0); //设置 睡眠时间 是1
lora_send_cmd(sendbuf,“ok”,50);
printf(“设置 睡眠 时间 %s:”,sendbuf);

//设置 串口 波特率 和校验位
sprintf((char *)sendbuf,“AT+UART=%d,%d”,3,0); //设置发送 模块 的波特率 校验位
lora_send_cmd(sendbuf,“ok”,50);
printf(“设置 串口 波特率 校验位 %s:”,sendbuf);

LORA_MD0 = 0; //退出 配置 进入 通信
delay_ms(40);
while(LORA_AUX); //判断是否空闲 模块重新配置参数
USART2_RX_STA = 0;
//Lora_mode = 1; //标记接收 模式
//返回通信 更新
usart2_set(LORA_TTLBPS_9600,LORA_TTLPAR_8N1);
aux_init(1); //设置 LORA_AUX 上升沿中断
}

/********************
LORA 模块初始化
返回值
0 检测成功
1 检测失败
*********************/
u8 LoRa_Init(void)
{
u8 retry=0;
u8 temp=1;

 RCC->APB2ENR|=1<<2;    //使能PORTA时钟	
 RCC->APB2ENR|=1<<0;    //使能PORTA 复用功能时钟	
 GPIOA->CRH&=0XFFFF0FFF; 
 GPIOA->CRH|=0X00003000;//PA11 推挽输出
 
 GPIOA->CRL&=0XFFF0FFFF; 
 GPIOA->CRL|=0X00080000;//PA4 输入
 GPIOA->ODR&=~(1<<4);	 //PA4下拉
 
 Ex_NVIC_Config(GPIO_A,4,RTIR); //上升沿触发
 MY_NVIC_Init(2,3,EXTI4_IRQn,2);//抢占2，子优先级3，组2
 EXTI->IMR &=~(1<<4);//  关闭的LINE4中断
 NVIC->ICER[EXTI4_IRQn >> 0x05] =(uint32_t)0x01 << (EXTI4_IRQn & (uint8_t)0x1F);
 
 LORA_MD0=0;
 LORA_AUX=0;
 //等待aux 端口 空闲状态
 while(LORA_AUX)//确保LORA模块在空闲状态下(LORA_AUX=0)
 {
 printf(" 模块正忙 请稍后 \r\n");
 delay_ms(500);
 }
 usart2_Init(36,115200);   //初始化串口2 
 //usart3_Init(36,115200); //初始化串口2 
 LORA_MD0=1;        //进入AT模式
 delay_ms(40);
 retry=3;       //重复发送AT 指令
 while(retry--)
 {
     if(!lora_send_cmd("AT","OK",70))  //发送AT 指令返回0K 
     {
         printf("发送 AT 命令 成功 ");
         temp=0;//检测成功
         USART2_RX_STA=0;
         break;
     }	
 }
 if(retry==0) temp=1;//检测失败
 return temp;

}

u8 dire_date[] = {0x11,0x22,0x33,0x44,0x55};
u8 date[30] = {0}; //定向数组
u8 tran_data[30] = {0}; //透传数组
#define dire_datelen sizeof(dire_date)/sizeof(dire_date[0])
extern u32 obj_addr; //记录用户输入的目标地址
extern u8 obj_chn; //记录用户输入的目标信道
u8 wlcd_buff[10] = {0}; //LCD显示字符串缓冲区
//LORA 模块发送数据
void LoRa_SendData(void)
{
static u8 num= 0;
// u16 addr;
// u8 chn;
// u16 i=0;
if(LoRa_CFG.mode_sta == LORA_STA_Tran) //透明传输
{
sprintf((char*)tran_data,“atk-lora-01 test %d”,num); //向空中发射
u2_printf("%s\r\n",tran_data); //向大脑发送 数据
num++;
if(num255) num = 0;
}
//else if(LoRa_CFG.mode_stalora_sta_dire) //定向传输
// {
// addr = (u16)obj_addr; //目标地址
// chn = obj_chn; //目标信道
// date[i++] = (addr>>8)&0xff; //高位地址
// date[i++] = addr&0xff; //低位地址
// date[i] = chn; //无线信道
// for(i=0;i // {
// date[3+i] = dire_date[i];
// }
// for(i=0;i<(dire_datelen+3);i++)
// {
// while((USART3->SR&0x0040)==0); //循环发送直到发送完毕
// USART3->DR = (date[i]&(uint16_t)0x01ff);
// }
// //将16进制的数据转换为字符串打印
// sprintf((char *)wlcd_buff,"%x %x %x %x %x %x %x %x",
// date[0],date[1],date[2],date[3],date[4],date[5],date[6],date[7]);
//
// dire_date[4]++; //

// }
}

u8 rlcd_buff[10] = {0};
void LoRa_ReceData(void) //lora 模块接收数据
{
u16 i=0;
u16 len=0;
if(USART2_RX_STA&0x8000) //有数据过来
{
len = USART2_RX_STA&0x7fff;
USART2_RX_BUF[len] = 0; //添加结束符
USART2_RX_STA=0;
for(i=0;i {
while((USART1->SR&0x0040)0); //等待发送完毕
USART1->DR=(USART2_RX_BUF[i]&(uint16_t)0x01ff);
}
if(LoRa_CFG.mode_staLORA_STA_Tran) //透明传输
{
printf(“usart3_rx_buf : %s\r\n”,USART2_RX_BUF); //显示接收的数据
}
else
if(LoRa_CFG.mode_sta==LORA_STA_Dire) //定向参数
{
sprintf((char*)rlcd_buff,"%x %x %x %x %x",
USART2_RX_BUF[0],USART2_RX_BUF[1],USART2_RX_BUF[2],
USART2_RX_BUF[3],USART2_RX_BUF[4]);
printf(“rlcd_buf:%s\r\n”,rlcd_buff);
}//将十六进制数据转换为字符串 打印出来
memset((char*)USART2_RX_BUF,0x00,len); //串口接收的缓冲区清0
}
}

#include “delay.h”
#include “usart2.h”
#include “stdarg.h”
#include “stdio.h”
#include “string.h”
#include “lora.h”

//////////////////////////////////////////////////////////////////////////////////
//本程序只供学习使用，未经作者许可，不得用于其它任何用途
//ALIENTEK STM32开发板
//串口2驱动代码
//正点原子@ALIENTEK
//技术论坛:www.openedv.com
//修改日期:2014/3/29
//版本：V1.0
//版权所有，盗版必究。
//Copyright© 广州市星翼电子科技有限公司 2009-2019
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////

//串口发送缓存区
__align(8) u8 USART2_TX_BUF[USART2_MAX_SEND_LEN]; //发送缓冲,最大USART2_MAX_SEND_LEN字节
#ifdef USART2_RX_EN //如果使能了接收
//串口接收缓存区
u8 USART2_RX_BUF[USART2_MAX_RECV_LEN]; //接收缓冲,最大USART2_MAX_RECV_LEN个字节.

//蓝牙扫描下： timer=1S
//非蓝牙扫描下： timer=10ms
//通过判断接收连续2个字符之间的时间差不大于timer来决定是不是一次连续的数据.
//如果2个字符接收间隔超过timer,则认为不是1次连续数据.也就是超过timer没有接收到
//任何数据,则表示此次接收完毕.
//接收到的数据状态
//[15]:0,没有接收到数据;1,接收到了一批数据.
//[14:0]:接收到的数据长度
u16 USART2_RX_STA=0;
void USART2_IRQHandler(void)
{
u8 res;
if(USART2->SR&(1<<5))//接收到数据
{
res=USART2->DR;
if((USART2_RX_STA&(1<<15))0)
{
if(USART2_RX_STA {
if(!Lora_mode)
{
TIM4->CNT=0; //计数器清空
if(USART2_RX_STA0)TIM4_Set(1); //使能定时器4的中断
}
USART2_RX_BUF[USART2_RX_STA++]=res; //记录接收到的值
}
else
{
USART2_RX_STA|=1<<15; //强制标记接收完成
}
}
}
//printf("%s\r\n",USART2_RX_BUF);
}

/***********************
初始化IO 串口2
pclk1:PCLK1时钟频率(Mhz)
bound:波特率
****************************/
void usart2_Init(u32 pclk1,u32 bound)
{
RCC->APB2ENR|=1<<2; //使能PORTA口时钟
GPIOA->CRL&=0XFFFF00FF; //IO状态设置
GPIOA->CRL|=0X00008B00; //IO状态设置
GPIOA->ODR|=1<<3; //PA3上拉

RCC->APB1ENR|=1<<17;  	//使能串口时钟 	 
RCC->APB1RSTR|=1<<17;   //复位串口2
RCC->APB1RSTR&=~(1<<17);//停止复位	   	   

USART2->BRR=(pclk1*1000000)/(bound);// 波特率设置	 
USART2->CR1|=0X200C;  	//1位停止,无校验位.
USART2->CR3=1<<7;   	//使能串口2的DMA发送
UART_DMA_Config(DMA1_Channel7,(u32)&USART2->DR,(u32)USART2_TX_BUF);//DMA1通道7,外设为串口2,存储器为USART2_TX_BUF 

#ifdef USART2_RX_EN //使能接收中断
USART2->CR1|=1<<8; //PE中断使能
USART2->CR1|=1<<5; //接收缓冲区非空中断使能
MY_NVIC_Init(2,3,USART2_IRQn,2);//组2，最低优先级
TIM4_Init(99,7199); //10ms中断
USART2_RX_STA=0; //清零
TIM4_Set(0); //关闭定时器4
#endif
}

//串口2,printf 函数
//确保一次发送数据不超过USART2_MAX_SEND_LEN字节
void u2_printf(char* fmt,…)
{
va_list ap;
va_start(ap,fmt);
vsprintf((char*)USART2_TX_BUF,fmt,ap);
va_end(ap);
while(DMA1_Channel7->CNDTR!=0); //等待通道7传输完成
UART_DMA_Enable(DMA1_Channel7,strlen((const char*)USART2_TX_BUF)); //通过dma发送出去
}
//定时器4中断服务程序
void TIM4_IRQHandler(void)
{

if(TIM4->SR&0X01)//是更新中断
{	 	
	TIM4->SR&=~(1<<0);		//清除中断标志位	

	USART2_RX_STA|=1<<15;	//标记接收完成	   
	TIM4_Set(0);			//关闭TIM4  
		 


}	    

}

/******************
设置TIM4的开关
sta: 0，关闭;
1, 开启;
********************/
void TIM4_Set(u8 sta)
{
if(sta)
{
TIM4->CNT=0; //计数器清空
TIM4->CR1|=1<<0; //使能定时器4
}else TIM4->CR1&=~(1<<0); //关闭定时器4
}

/************************
配置TIM4预装载周期值
**************************/
void TIM4_SetARR(u16 period)
{
TIM4->CNT = 0; //计数器清空
TIM4->ARR&=0x00; //先清预装载周期值为0
TIM4->ARR|= period;//更新预装载周期值
}

/***************************
通用定时器中断初始化
这里始终选择为APB1的2倍，而APB1为36M
arr：自动重装值。
psc：时钟预分频数
****************************/
void TIM4_Init(u16 arr,u16 psc)
{
RCC->APB1ENR|=1<<2; //TIM4时钟使能
TIM4->ARR=arr; //设定计数器自动重装值
TIM4->PSC=psc; //预分频器
TIM4->DIER|=1<<0; //允许更新中断
TIM4->CR1|=0x01; //使能定时器4
MY_NVIC_Init(1,3,TIM4_IRQn,2);//抢占2，子优先级3，组2 在2中优先级最低
}

#endif

///////////////////////////////////////USART2 DMA发送配置部分//////////////////////////////////
//DMA1的各通道配置
//这里的传输形式是固定的,这点要根据不同的情况来修改
//从存储器->外设模式/8位数据宽度/存储器增量模式
//DMA_CHx:DMA通道CHx
//cpar:外设地址
//cmar:存储器地址
void UART_DMA_Config(DMA_Channel_TypeDef*DMA_CHx,u32 cpar,u32 cmar)
{
RCC->AHBENR|=1<<0; //开启DMA1时钟
delay_us(5);
DMA_CHx->CPAR=cpar; //DMA1 外设地址
DMA_CHx->CMAR=cmar; //DMA1,存储器地址
DMA_CHx->CCR=0X00000000; //复位
DMA_CHx->CCR|=1<<4; //从存储器读
DMA_CHx->CCR|=0<<5; //普通模式
DMA_CHx->CCR|=0<<6; //外设地址非增量模式
DMA_CHx->CCR|=1<<7; //存储器增量模式
DMA_CHx->CCR|=0<<8; //外设数据宽度为8位
DMA_CHx->CCR|=0<<10; //存储器数据宽度8位
DMA_CHx->CCR|=1<<12; //中等优先级
DMA_CHx->CCR|=0<<14; //非存储器到存储器模式
}

//开启一次DMA传输
void UART_DMA_Enable(DMA_Channel_TypeDef*DMA_CHx,u16 len)
{
DMA_CHx->CCR&=~(1<<0); //关闭DMA传输
DMA_CHx->CNDTR=len; //DMA1,传输数据量
DMA_CHx->CCR|=1<<0; //开启DMA传输
}

/********************************
串口2波特率和校验位配置
bps: 波特率（1200~115200）
parity: 校验位（无、偶、奇）
**********************************/
void usart2_set(u8 bps,u8 parity)
{

static u32 bound=0;

switch(bps)
{
	case LORA_TTLBPS_1200:   bound=1200;     break;
	case LORA_TTLBPS_2400:   bound=2400;     break;
	case LORA_TTLBPS_4800:   bound=4800;     break;
	case LORA_TTLBPS_9600:   bound=9600;     break;
	case LORA_TTLBPS_19200:  bound=19200;    break;
	case LORA_TTLBPS_38400:  bound=38400;    break;
	case LORA_TTLBPS_57600:  bound=57600;    break;
	case LORA_TTLBPS_115200: bound=115200;   break;
}

 USART2->CR1 &= 0xDFFF;//关闭串口

 USART2->BRR=(36*1000000)/(bound);// 波特率设置	 
 USART2->CR1|=0X200C;  	//1位停止,无校验位.

if(parity==LORA_TTLPAR_8N1)//无校验
{
	
	USART2->CR1&=~(1<<12);//8位数据位
	USART2->CR1&=~(1<<10);//禁止校验控制
	USART2->CR1&=~(1<<9);

}else if(parity==LORA_TTLPAR_8E1)//偶校验
{
	
	USART2->CR1|=(1<<12);//9位数据位
	USART2->CR1|=(1<<10);//校验控制使能
	USART2->CR1&=~(1<<9);//偶校验

}else if(parity==LORA_TTLPAR_8O1)//奇校验
{
	USART2->CR1|=(1<<12);//9位数据位
	USART2->CR1|=(1<<10);//校验控制使能
	USART2->CR1|=(1<<9);//奇校验
}

 USART2->CR1 |= 0x2000;//使能串口 

}

//串口接收使能控制
//enable:0,关闭 1,打开
void usart2_rx(u8 enable)
{
USART2->CR1 &= 0xDFFF;//关闭串口

 if(enable)
 {
	USART2->CR1|=(1<<3)|(1<<2);//发送和接收
 }else
 { 
	 USART2->CR1&=~(1<<2);//关闭接收
	 USART2->CR1|=(1<<3);//打开发送
 }
 
 USART2->CR1 |= 0x2000;//使能串口 

}

#ifndef _LORA_H
#define _LORA_H
#include “sys.h”

typedef struct
{
u16 addr; //设备地址
u8 chn; //信道
u8 power; //发射功率
u8 wlrate; //空中速率
u8 wltime; //休眠时间
u8 mode; //工作模式
u8 mode_sta; //发送状态
u8 bps; //串口波特率
u8 parity; //校验位
}_LoRa_CFG;

extern _LoRa_CFG LoRa_CFG;

//空中速率(单位:Kbps)
#define LORA_RATE_0K3 0 //0.3
#define LORA_RATE_1K2 1 //1.2
#define LORA_RATE_2K4 2 //2.4
#define LORA_RATE_4K8 3 //4.8
#define LORA_RATE_9K6 4 //9.6
#define LORA_RATE_19K2 5 //19.2

//休眠时间(单位:秒)
#define LORA_WLTIME_1S 0 //1秒
#define LORA_WLTIME_2S 1 //2秒

//工作模式
#define LORA_MODE_GEN 0 //一般模式
#define LORA_MODE_WK 1 //唤醒模式
#define LORA_MODE_SLEEP 2 //省电模式

//发射功率
#define LORA_PW_11dBm 0 //11dBm
#define LORA_PW_14Bbm 1 //14dBm
#define LORA_PW_17Bbm 2 //17dBm
#define LORA_PW_20Bbm 3 //20dBm

//发送状态
#define LORA_STA_Tran 0 //透明传输
#define LORA_STA_Dire 1 //定向传输

//串口波特率(单位:bps)
#define LORA_TTLBPS_1200 0 //1200
#define LORA_TTLBPS_2400 1 //2400
#define LORA_TTLBPS_4800 2 //4800
#define LORA_TTLBPS_9600 3 //9600
#define LORA_TTLBPS_19200 4 //19200
#define LORA_TTLBPS_38400 5 //38400
#define LORA_TTLBPS_57600 6 //57600
#define LORA_TTLBPS_115200 7 //115200

//串口数据校验
#define LORA_TTLPAR_8N1 0 //8位数据
#define LORA_TTLPAR_8E1 1 //8位数据+1位偶校验
#define LORA_TTLPAR_8O1 2 //8位数据+1位奇校验

//设备出厂默认参数
#define LORA_ADDR 0 //设备地址
#define LORA_CHN 23 //通信信道
#define LORA_POWER LORA_PW_20Bbm //发射功率
#define LORA_RATE LORA_RATE_19K2 //空中速率
#define LORA_WLTIME LORA_WLTIME_1S //休眠时间
#define LORA_MODE LORA_MODE_GEN //工作模式
#define LORA_STA LORA_STA_Tran //发送状态
#define LORA_TTLBPS LORA_TTLBPS_9600 //波特率
#define LORA_TTLPAR LORA_TTLPAR_8N1 //校验位

#define LORA_AUX PAin(4) //LORA模块状态引脚
#define LORA_MD0 PAout(11) //LORA模块控制引脚

extern u8 Lora_mode;

u8 LoRa_Init(void); //无线 初始化

void Aux_Int(u8 mode);//设备工作模式 用于记录设备状态

void LoRa_Set(void); //lora 模块参数配置

void LoRa_SendData(void);//LORA 模块发送数据

void LoRa_ReceData(void);//Lora 模块接收数据

#endif

#ifndef __USART2_H
#define __USART2_H
#include “sys.h”

#define USART2_MAX_RECV_LEN 1024 //最大接收缓存字节数
#define USART2_MAX_SEND_LEN 600 //最大发送缓存字节数
#define USART2_RX_EN 1 //0,不接收;1,接收.

extern u8 USART2_RX_BUF[USART2_MAX_RECV_LEN]; //接收缓冲,最大USART2_MAX_RECV_LEN字节
extern u8 USART2_TX_BUF[USART2_MAX_SEND_LEN]; //发送缓冲,最大USART2_MAX_SEND_LEN字节
extern u16 USART2_RX_STA; //接收数据状态

void usart2_Init(u32 pclk2,u32 bound); //串口2初始化
void TIM4_Set(u8 sta);
void TIM4_Init(u16 arr,u16 psc);
void TIM4_SetARR(u16 period);
void UART_DMA_Config(DMA_Channel_TypeDefDMA_CHx,u32 cpar,u32 cmar);
void UART_DMA_Enable(DMA_Channel_TypeDefDMA_CHx,u16 len);
void u2_printf(char* fmt, …);
void usart2_set(u8 bps,u8 parity);
void usart2_rx(u8 enable);
#endif