安信可lora模块测试程序

75 阅读 0 评论 50 点赞

我是靠谱客的博主友好泥猴桃，最近开发中收集的这篇文章主要介绍安信可lora模块测试程序，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

main.c

/******************************************************************************/
/* --安信可科技有限公司-- */
/*
// 函数说明：main.c
// 说明：该lora模块程序用于测试
// 编写人员： sky
// 编写日期： 2016-11-24
// 版本号:V1.0
// 维护日志：
//
//
*/
// 免责声明：该程序仅供参考学习，若自定义其他功能，请查看参考手册
// (c) Anxinke Corporation. All rights reserved.
/******************************************************************************/
#include "typedef.h"
#include "gpio.h"
#include "string.h"
#include "uart.h"
#include "SX1278.h"
//#include "delay.h"

void main(void) {
   unsigned char RF_REC_RLEN_i = 0;
   int flag = 0;
   int led = 0;
   unsigned char recv[30];
   uartInit();
   //uartSendString("READY!rn");

   P1M1 = 0X03;
   P1M0 = 0XFC;
   P3M1 &= 0XFC;
   P3M0 |= 0X04;
   //uartSendString("HERE!rn");
   register_rf_func(&ctrlTypefunc);
   SX1276Reset();
   SX1276LORA_INT();

   uartSendString("READY!rn");
   P32 = 1;
   P17 = 1;
   while (1) {
       if (P30 == 0 || P31 == 0) {
           P17 = 1;
           P32 = 0;
           SX1276WriteBuffer( REG_LR_IRQFLAGS, 0xff);

           uartSendString("hello world!rn");
           FUN_RF_SENDPACKET("ai-thinker", 10);
           Delay1s(1000);
           SX1276WriteBuffer( REG_LR_IRQFLAGS, 0xff);
       } else {
           P32 = 1;
           RF_EX0_STATUS = SX1276ReadBuffer( REG_LR_IRQFLAGS);
           if (RF_EX0_STATUS > 0) {
               if ((RF_EX0_STATUS & 0x40) == 0x40) {
                   //GPIO_OUTPUT_SET(GPIO_ID_PIN(2),0);
                   CRC_Value = SX1276ReadBuffer( REG_LR_MODEMCONFIG2);
                   if (CRC_Value & 0x04 == 0x04) {
                       SX1276WriteBuffer(REG_LR_FIFOADDRPTR, 0x00);
                       SX1278_RLEN = SX1276ReadBuffer(REG_LR_NBRXBYTES);
                       //uartSendString("recvieve data num=%drn",SX1278_RLEN);
                       lpTypefunc.lpSwitchEnStatus(enOpen);
                       lpTypefunc.lpByteWritefunc(0x00);
                       for (RF_REC_RLEN_i = 0; RF_REC_RLEN_i < SX1278_RLEN;
                               RF_REC_RLEN_i++) {
                           recv[RF_REC_RLEN_i] = lpTypefunc.lpByteReadfunc();
                       }
                       lpTypefunc.lpSwitchEnStatus(enClose);
                       recv[RF_REC_RLEN_i] = '';
                       if(strncmp(recv,"ai-thinker",10))
                       {
                       uartSendString("recievern");
                       P17 = 0;
                       }
                   }
//   lpTypefunc.lpRecvDataTousr(recv,SX1278_RLEN);
                   SX1276LoRaSetOpMode(Stdby_mode);
                   SX1276WriteBuffer(REG_LR_IRQFLAGSMASK, IRQN_RXD_Value); //打开发送中断
                   SX1276WriteBuffer(REG_LR_HOPPERIOD, PACKET_MIAX_Value);
                   SX1276WriteBuffer( REG_LR_DIOMAPPING1, 0X00);
                   SX1276WriteBuffer( REG_LR_DIOMAPPING2, 0x00);
                   SX1276LoRaSetOpMode(Receiver_mode);
//   lpTypefunc.paSwitchCmdfunc(rxOpen);
               } else if ((RF_EX0_STATUS & 0x08) == 0x08) {
                   SX1276LoRaSetOpMode(Stdby_mode);
                   SX1276WriteBuffer(REG_LR_IRQFLAGSMASK, IRQN_RXD_Value); //打开发送中断
                   SX1276WriteBuffer(REG_LR_HOPPERIOD, PACKET_MIAX_Value);
                   SX1276WriteBuffer( REG_LR_DIOMAPPING1, 0X00);
                   SX1276WriteBuffer( REG_LR_DIOMAPPING2, 0x00);
                   SX1276LoRaSetOpMode(Receiver_mode);
//   lpTypefunc.paSwitchCmdfunc(rxOpen);
               } else if ((RF_EX0_STATUS & 0x04) == 0x04) {
                   if ((RF_EX0_STATUS & 0x01) == 0x01) { //表示CAD 检测到扩频信号模块进入了接收状态来接收数据
                       SX1276LoRaSetOpMode(Stdby_mode);
                       SX1276WriteBuffer(REG_LR_IRQFLAGSMASK, IRQN_RXD_Value); //打开发送中断
                       SX1276WriteBuffer(REG_LR_HOPPERIOD, PACKET_MIAX_Value);
                       SX1276WriteBuffer( REG_LR_DIOMAPPING1, 0X02);
                       SX1276WriteBuffer( REG_LR_DIOMAPPING2, 0x00);
                       SX1276LoRaSetOpMode(Receiver_mode);
//   lpTypefunc.paSwitchCmdfunc(rxOpen);
                   } else {
                       SX1276LoRaSetOpMode(Stdby_mode);
                       SX1276WriteBuffer(REG_LR_IRQFLAGSMASK,
                               IRQN_SEELP_Value); //打开发送中断
                       SX1276WriteBuffer( REG_LR_DIOMAPPING1, 0X00);
                       SX1276WriteBuffer( REG_LR_DIOMAPPING2, 0X00);
                       SX1276LoRaSetOpMode(Sleep_mode);
                       //PA_SEELP_OUT();
                   }
               } else {
                   SX1276LoRaSetOpMode(Stdby_mode);
                   SX1276WriteBuffer(REG_LR_IRQFLAGSMASK, IRQN_RXD_Value); //打开发送中断
                   SX1276WriteBuffer(REG_LR_HOPPERIOD, PACKET_MIAX_Value);
                   SX1276WriteBuffer( REG_LR_DIOMAPPING1, 0X02);
                   SX1276WriteBuffer( REG_LR_DIOMAPPING2, 0x00);
                   SX1276LoRaSetOpMode(Receiver_mode);
//   lpTypefunc.paSwitchCmdfunc(rxOpen);
               }
               RF_REC_RLEN_i = 0;
               SX1276WriteBuffer( REG_LR_IRQFLAGS, 0xff);
               Delay1s(300);
           } else {
               P17 = 1;
           }
       }

}
}

/******************************************************************************/
/* --安信可科技有限公司-- */
/*
// 函数说明：main.c
// 说明：该程序用于测试lora模块
// 编写人员： sky
// 编写日期： 2016-11-24
// 版本号:V1.0
// 维护日志：
//
//
*/
// 免责声明：该程序仅供参考学习，若自定义其他功能，请查看参考手册
// (c) Anxinke Corporation. All rights reserved.
/******************************************************************************/
#include "typedef.h"
#include "gpio.h"
#include "uart.h"

static bit bUartFlag;

/******************************************************************************/
// 函数名称：uartInit
//输入参数 :无
//输出参数：无
// 函数功能:设置好定时器0的工作模式
/******************************************************************************/
void uartInit(void)
{
AUXR |= 0x80;//定时器0位IT模式
TMOD &= 0xF0; //设置定时器为模式0(16位自动重装载)
TL0 = (0xFFFF - MCU_FREQ / UART_BUAD) & 0xFF;//设置定时初值
TH0 = ((0xFFFF - MCU_FREQ / UART_BUAD) >> 8) & 0xFF; //设置定时器初值
TR0 = 0; //定时器0开始计时
ET0 = 0; //使能定时器0中断
EA = 1;
}

/******************************************************************************/
// 函数名称:uartSendData
//输入参数:ucData发送字节
//输出参数:无
//函数功能:使能串口发送一个字节数据
/******************************************************************************/
void uartSendData(u8 ucData)
{
u8 ucCnt;
UART_TX_LOW(); //串口起始位开始
TR0 = 1; //定时器0开始计时
ET0 = 1; //使能定时器0中断
bUartFlag = ON;
while(bUartFlag == ON);
   /*
   *由地位开始，将数据通过串口输出
   */
for (ucCnt = 0; ucCnt < 8; ucCnt++) {
UART_TX_SET(ucData & 0x01);
ucData >>= 1;
bUartFlag = ON;
while(bUartFlag == ON);
}
UART_TX_HIGH();
bUartFlag = ON;
while(bUartFlag == ON);
TR0 = 0;
ET0 = 0;
}
/******************************************************************************/
// 函数名称uartSendString
// 输入参数:ps:字符串首地址
// 输出参数:无
// 串口功能:发送字符串通过串口输出
/******************************************************************************/
void uartSendString(char *pS)
{
while (*pS)
{
uartSendData(*pS++);
}
}

/******************************************************************************/
// 函数名称time0ISR
// 输入参数:无
// 输出参数:w无
//函数功能:串口0服务函数
/******************************************************************************/
void time0ISR(void) interrupt 1 using 1
{
EA = 0;
bUartFlag = OFF;
EA = 1;
}

//#include "reg51.hcd"
lpCtrlTypefunc_t lpTypefunc = { 0, 0, 0 };
unsigned char power_data[8] = { 0X80, 0X80, 0X80, 0X83, 0X86, 0x89, 0x8c, 0x8f };

lpCtrlTypefunc_t ctrlTypefunc =
{ RF_SPI_MasterIO, RF_SPI_READ_BYTE, cmdSwitchEn,

};
//unsigned char Frequency[3] = { 0x6c, 0x80, 0x00 };//470Mhz
unsigned char Frequency[3] = { 0x6c, 0x80, 0x00 };//430Mhz 频率设置
unsigned char powerValue = 7;
unsigned char SpreadingFactor = 12; //扩频因子7-12
unsigned char CodingRate = 2; //1-4
unsigned char Bw_Frequency = 7; //带宽6-9
unsigned char RF_EX0_STATUS;
unsigned char CRC_Value;
unsigned char SX1278_RLEN;
//unsigned char recv[512];

void Delay1s(unsigned int ii)
{
int j;
while(ii--){
for(j=0;j<1000;j++);
}
}

/*
function:SX1278 restart
*/

void SX1276Reset(void) {
   RF_REST_L;
   Delay1s(200);
   RF_REST_H;
   Delay1s(500);
}

/*
function:control GPIO-EN
*/
void cmdSwitchEn(cmdEntype_t cmd) {
   switch (cmd) {
   case enOpen: {
       RF_CE_L;
   }
       break;
   case enClose: {
       RF_CE_H;
   }
       break;
   default:
       break;
   }
}

void RF_SPI_MasterIO(unsigned char out) {
   unsigned char i;
   for (i = 0; i < 8; i++) {
       if (out & 0x80) /* check if MSB is high */
           RF_SDI_H;
       else
           RF_SDI_L; /* if not, set to low */

       RF_CKL_H; /* toggle clock high */
       out = (out << 1); /* shift 1 place for next bit */
       RF_CKL_L; /* toggle clock low */
   }
}

unsigned char RF_SPI_READ_BYTE() {
   unsigned char j;
   unsigned char i;
   j = 0;
   for (i = 0; i < 8; i++) {
       RF_CKL_H;
       j = (j << 1);           // shift 1 place to the left or shift in 0 //
       if ( SX1278_SDO)                   // check to see if bit is high //
           j = j | 0x01;                    // if high, make bit high //
                                           // toggle clock high //
       RF_CKL_L;                            // toggle clock low //
   }

   return j;                               // toggle clock low //
}
unsigned char SX1276ReadBuffer(unsigned char addr) {
   unsigned char Value;
   lpTypefunc.lpSwitchEnStatus(enOpen); //NSS = 0;
   lpTypefunc.lpByteWritefunc(addr & 0x7f);
   Value = lpTypefunc.lpByteReadfunc();
   lpTypefunc.lpSwitchEnStatus(enClose); //NSS = 1;

return Value;
}

/*
function:set sx1278 work mode ,here you can control the mode which is send or recieve
parm:
*/
void SX1276LoRaSetOpMode(RFMode_SET opMode) {
   unsigned char opModePrev;
   opModePrev = SX1276ReadBuffer(REG_LR_OPMODE);
   opModePrev &= 0xf8;
   opModePrev |= (unsigned char) opMode;
   SX1276WriteBuffer( REG_LR_OPMODE, opModePrev);
}

void SX1276WriteBuffer(unsigned char addr,
       unsigned char buffer) {
   lpTypefunc.lpSwitchEnStatus(enOpen); //NSS = 0;
   lpTypefunc.lpByteWritefunc(addr | 0x80);
   lpTypefunc.lpByteWritefunc(buffer);
   lpTypefunc.lpSwitchEnStatus(enClose); //NSS = 1;
}

void register_rf_func(lpCtrlTypefunc_t *func) {
   if (func->lpByteWritefunc != 0) {
       lpTypefunc.lpByteWritefunc = func->lpByteWritefunc;
   }
   if (func->lpByteReadfunc != 0) {
       lpTypefunc.lpByteReadfunc = func->lpByteReadfunc;
   }
   if (func->lpSwitchEnStatus != 0) {
       lpTypefunc.lpSwitchEnStatus = func->lpSwitchEnStatus;
   }

}

void SX1276LoRaSetRFFrequency(void) {
   SX1276WriteBuffer( REG_LR_FRFMSB, Frequency[0]);//0x04射频载波频率最高有效位
   SX1276WriteBuffer( REG_LR_FRFMID, Frequency[1]);//0x07射频载波频率中间有效位
   SX1276WriteBuffer( REG_LR_FRFLSB, Frequency[2]);//0x00射频载波频率最低有效位
}

void SX1276LoRaSetNbTrigPeaks(unsigned char value) {
   unsigned char RECVER_DAT;
   RECVER_DAT = SX1276ReadBuffer(0x31);
   RECVER_DAT = (RECVER_DAT & 0xF8) | value;
   SX1276WriteBuffer(0x31, RECVER_DAT);
}

void SX1276LoRaSetSpreadingFactor(unsigned char factor) {
   unsigned char RECVER_DAT;
   SX1276LoRaSetNbTrigPeaks(3);
   RECVER_DAT = SX1276ReadBuffer( REG_LR_MODEMCONFIG2);
   RECVER_DAT = (RECVER_DAT & RFLR_MODEMCONFIG2_SF_MASK) | (factor << 4);
   SX1276WriteBuffer( REG_LR_MODEMCONFIG2, RECVER_DAT);
}

void SX1276LoRaSetErrorCoding(unsigned char value) {
   unsigned char RECVER_DAT;
   RECVER_DAT = SX1276ReadBuffer( REG_LR_MODEMCONFIG1);
   RECVER_DAT = (RECVER_DAT & RFLR_MODEMCONFIG1_CODINGRATE_MASK)
           | (value << 1);
   SX1276WriteBuffer( REG_LR_MODEMCONFIG1, RECVER_DAT);
// LoRaSettings.ErrorCoding = value;
}

void SX1276LoRaSetSignalBandwidth(unsigned char bw) {
   unsigned char RECVER_DAT;
   RECVER_DAT = SX1276ReadBuffer( REG_LR_MODEMCONFIG1);
   RECVER_DAT = (RECVER_DAT & RFLR_MODEMCONFIG1_BW_MASK) | (bw << 4);
   SX1276WriteBuffer( REG_LR_MODEMCONFIG1, RECVER_DAT);
// LoRaSettings.SignalBw = bw;
}

void SX1276LoRaSetImplicitHeaderOn(BOOL enable) {
   unsigned char RECVER_DAT;
   RECVER_DAT = SX1276ReadBuffer( REG_LR_MODEMCONFIG1);
   RECVER_DAT = (RECVER_DAT & RFLR_MODEMCONFIG1_IMPLICITHEADER_MASK)
           | (enable);
   SX1276WriteBuffer( REG_LR_MODEMCONFIG1, RECVER_DAT);
}

void SX1276LoRaSetPayloadLength(unsigned char value) {
SX1276WriteBuffer( REG_LR_PAYLOADLENGTH, value);
}

void SX1276LoRaSetSymbTimeout(unsigned int value) {
   unsigned char RECVER_DAT[2];
   RECVER_DAT[0] = SX1276ReadBuffer( REG_LR_MODEMCONFIG2);
   RECVER_DAT[1] = SX1276ReadBuffer( REG_LR_SYMBTIMEOUTLSB);
   RECVER_DAT[0] = (RECVER_DAT[0] & RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK)
           | ((value >> 8) & ~RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK);
   RECVER_DAT[1] = value & 0xFF;
   SX1276WriteBuffer( REG_LR_MODEMCONFIG2, RECVER_DAT[0]);
   SX1276WriteBuffer( REG_LR_SYMBTIMEOUTLSB, RECVER_DAT[1]);
}

void SX1276LoRaSetMobileNode(BOOL enable) {
   unsigned char RECVER_DAT;
   RECVER_DAT = SX1276ReadBuffer( REG_LR_MODEMCONFIG3);
   RECVER_DAT = (RECVER_DAT & RFLR_MODEMCONFIG3_MOBILE_NODE_MASK)
           | (enable << 3);
   SX1276WriteBuffer( REG_LR_MODEMCONFIG3, RECVER_DAT);
}

void RF_RECEIVE(void) {
   SX1276LoRaSetOpMode(Stdby_mode);
   SX1276WriteBuffer(REG_LR_IRQFLAGSMASK, IRQN_RXD_Value); //打开发送中断
   SX1276WriteBuffer(REG_LR_HOPPERIOD, PACKET_MIAX_Value);
   SX1276WriteBuffer( REG_LR_DIOMAPPING1, 0X00);
   SX1276WriteBuffer( REG_LR_DIOMAPPING2, 0X00);
   SX1276LoRaSetOpMode(Receiver_mode);
// lpTypefunc.paSwitchCmdfunc(rxOpen);
}

void SX1276LoRaSetPacketCrcOn(BOOL enable) {
   unsigned char RECVER_DAT;
   RECVER_DAT = SX1276ReadBuffer( REG_LR_MODEMCONFIG2);
   RECVER_DAT = (RECVER_DAT & RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK)
           | (enable << 2);
   SX1276WriteBuffer( REG_LR_MODEMCONFIG2, RECVER_DAT);
}

void SX1276LoRaFsk(Debugging_fsk_ook opMode) {
   unsigned char opModePrev;
   opModePrev = SX1276ReadBuffer(REG_LR_OPMODE);
   opModePrev &= 0x7F;
   opModePrev |= (unsigned char) opMode;
   SX1276WriteBuffer( REG_LR_OPMODE, opModePrev);
}

void SX1276LoRaSetRFPower(unsigned char power) {
SX1276WriteBuffer( REG_LR_PADAC, 0x87);
SX1276WriteBuffer( REG_LR_PACONFIG, power_data[power]);
}

/*
function :you must call it ,the function is to init the module.
*/
void SX1276LORA_INT(void) {
   SX1276LoRaSetOpMode(Sleep_mode); //设置睡眠模式0x01
   SX1276LoRaFsk(LORA_mode);   // 设置扩频模式,只能在睡眠模式下修改
   SX1276LoRaSetOpMode(Stdby_mode); // 设置为普通模式
   SX1276WriteBuffer( REG_LR_DIOMAPPING1, GPIO_VARE_1);
   SX1276WriteBuffer( REG_LR_DIOMAPPING1, GPIO_VARE_1);
   SX1276WriteBuffer( REG_LR_DIOMAPPING2, GPIO_VARE_2);
   SX1276LoRaSetRFFrequency();
   SX1276LoRaSetRFPower(powerValue);
   SX1276LoRaSetSpreadingFactor(SpreadingFactor);   // 扩频因子设置
   SX1276LoRaSetErrorCoding(CodingRate);       //有效数据比
   SX1276LoRaSetPacketCrcOn(true);           //CRC 校验打开
   SX1276LoRaSetSignalBandwidth(Bw_Frequency);   //设置扩频带宽
   SX1276LoRaSetImplicitHeaderOn(false);       //同步头是显性模式
   SX1276LoRaSetPayloadLength(0xff);//0x22 timeout中断
   SX1276LoRaSetSymbTimeout(0x3FF);
   SX1276LoRaSetMobileNode(true);            // 低数据的优化
   RF_RECEIVE();
   uartSendString("rninit finishrn");

}

/*
function :if you want to send data,you can call it
RF_TRAN_P:data
ASM_i:the length of the data
*/
void FUN_RF_SENDPACKET(unsigned char *RF_TRAN_P,
       unsigned char LEN) {
   unsigned char ASM_i;
// lpTypefunc.paSwitchCmdfunc(txOpen);
   SX1276LoRaSetOpMode(Stdby_mode);
   SX1276WriteBuffer( REG_LR_HOPPERIOD, 0);   //不做频率跳变
   SX1276WriteBuffer(REG_LR_IRQFLAGSMASK, IRQN_TXD_Value);   //打开发送中断
   SX1276WriteBuffer( REG_LR_PAYLOADLENGTH, LEN);   //最大数据包
   SX1276WriteBuffer( REG_LR_FIFOTXBASEADDR, 0);
   SX1276WriteBuffer( REG_LR_FIFOADDRPTR, 0);
   lpTypefunc.lpSwitchEnStatus(enOpen);
   lpTypefunc.lpByteWritefunc(0x80);
   for (ASM_i = 0; ASM_i < LEN; ASM_i++) {
       lpTypefunc.lpByteWritefunc(*RF_TRAN_P);
       RF_TRAN_P++;
   }
   lpTypefunc.lpSwitchEnStatus(enClose);
   SX1276WriteBuffer(REG_LR_DIOMAPPING1, 0x40);
   SX1276WriteBuffer(REG_LR_DIOMAPPING2, 0x00);
   SX1276LoRaSetOpMode(Transmitter_mode);
}

config.h

#include "reg51.h"

#include"NRF_24L01.H"

#include"UART.H"

delay.c

/******************************************************************************/
/* -- 深圳安信可科技有限公司 -- */
/*
// 文件名：
// 说明：
// 编写人员：
// 编写日期：
// 程序维护：
// 维护记录：
//
//
*/
// 免责声明：该程序仅用于学习与交流
// (c) Anxinke Corporation. All rights reserved.
/******************************************************************************/
#include "delay.h"

/******************************************************************************/
// 函数名称：
// 输入参数：
// 输出参数：
// 函数功能：
/******************************************************************************/
void Delay100ms(void) //@22.1184MHz
{
   unsigned char i, j, k;
   _nop_();
   _nop_();
   i = 9;
   j = 104;
   k = 139;
   do
   {
       do
       {
           while (--k);
       } while (--j);
   } while (--i);
}

/******************************************************************************/
// 函数名称：
// 输入参数：
// 输出参数：
// 函数功能：
/******************************************************************************/
void _delay_us(unsigned int _us)
{
char a=0;
for(_us;_us;_us--)
for(a=0;a<1;a++);
}

delay.h

/****************************************Copyright (c)**************************************************
** Guangzhou ZHIYUAN electronics Co.,LTD.
**
** http://www.embedtools.com
**
**--------------File Info-------------------------------------------------------------------------------
** File Name:
** Last modified Date:
** Last Version: v1.00
** Description:
**
**------------------------------------------------------------------------------------------------------
** Created By:
** Created date:
** Version: v1.00
** Descriptions:
**
**------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
** Version:
** Description:
**
********************************************************************************************************/
#ifndef __DELAY_H
#define __DELAY_H
#include "typedef.h"

void _delay_us(unsigned int _us);
void Delay100ms(void);

#endif

gpio.h

/******************************************************************************/
/* -- 深圳安信可科技有限公司 -- */
/*
// 文件名：GPIO.h
// 说明：与GPIO相关宏定义
// 编写人员：Wu
// 编写日期：2012年11月12日
// 程序维护：
// 维护记录：
//
//
*/
// 免责声明：该程序仅用于学习与交流
// (c) Anxinke Corporation. All rights reserved.
/******************************************************************************/
#ifndef __GPIO_H
#define __GPIO_H

#define KEY P30
#define KEY2 P31

#define led P16
#define led2 P35

#define UART_TX_PIN P31
#define UART_TX_SET(n) UART_TX_PIN = n
#define UART_TX_HIGH() UART_TX_SET(1)
#define UART_TX_LOW() UART_TX_SET(0)
#define UART_TX_FLIP() UART_TX_PIN = !UART_TX_PIN

#define UART_RX_PIN P30
#define UART_RX_SET(n) UART_RX_PIN = n
#define UART_RX_HIGH() UART_RX_SET(1)
#define UART_RX_LOW() UART_RX_SET(0)
#define UART_RX_FLIP() UART_RX_PIN = !UART_RX_PIN

#endif

sx1278.c

//#include "reg51.hcd"
lpCtrlTypefunc_t lpTypefunc = { 0, 0, 0 };
unsigned char power_data[8] = { 0X80, 0X80, 0X80, 0X83, 0X86, 0x89, 0x8c, 0x8f };

lpCtrlTypefunc_t ctrlTypefunc =
{ RF_SPI_MasterIO, RF_SPI_READ_BYTE, cmdSwitchEn,

void Delay1s(unsigned int ii)
{
int j;
while(ii--){
for(j=0;j<1000;j++);
}
}

/*
function:SX1278 restart
*/

void SX1276Reset(void) {
   RF_REST_L;
   Delay1s(200);
   RF_REST_H;
   Delay1s(500);
}

       RF_CKL_H; /* toggle clock high */
       out = (out << 1); /* shift 1 place for next bit */
       RF_CKL_L; /* toggle clock low */
   }
}

return Value;
}

}

void SX1276LoRaSetPayloadLength(unsigned char value) {
SX1276WriteBuffer( REG_LR_PAYLOADLENGTH, value);
}

void SX1276LoRaSetRFPower(unsigned char power) {
SX1276WriteBuffer( REG_LR_PADAC, 0x87);
SX1276WriteBuffer( REG_LR_PACONFIG, power_data[power]);
}

}

SX1278.H

#ifndef __SX1278_H
#define __SX1278_H
#include "typedef.h"
//#include <intrins.h>
//#include <string.h>
#include "UART.H"
//#include "delay.h"

#define SX1278_SDO P10
#define RF_REST_L P14=0 /* MMC CE = L */
#define RF_REST_H P14=1 /* MMC CE = H */
#define RF_CE_L P15=0 /* MMC CE = L */
#define RF_CE_H P15=1 /* MMC CE = H */
#define RF_CKL_L P12=0 /* MMC CKL = L */
#define RF_CKL_H P12=1 /* MMC CKL = H */
#define RF_SDI_L P13=0 /* MMC CKL = L */
#define RF_SDI_H P13=1 /* MMC CKL = H */

#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

#define GPIO_VARE_1 0X00
#define GPIO_VARE_2 0X00
#define RFLR_MODEMCONFIG2_SF_MASK 0x0f
#define RFLR_MODEMCONFIG1_CODINGRATE_MASK 0xF1
#define RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK 0xFB
#define RFLR_MODEMCONFIG1_BW_MASK 0x0F
#define RFLR_MODEMCONFIG1_IMPLICITHEADER_MASK 0xFE
#define RFLR_MODEMCONFIG2_SYMBTIMEOUTMSB_MASK 0xfc
#define RFLR_MODEMCONFIG3_MOBILE_NODE_MASK 0xF7

#define TIME_OUT_INT 0x80
#define PACKET_RECVER_INT 0x40
#define CRC_ERROR_INT 0x20
#define RECVER_HEAR_INT 0x10
#define FIFO_SEND_OVER 0x08
#define RFLR_IRQFLAGS_CAD 0x04
#define RFLR_IRQFLAGS_FHSS 0x02
#define RFLR_IRQFLAGS_CADD 0x01

#define IRQN_TXD_Value 0xF7
#define IRQN_RXD_Value 0x9F
#define IRQN_CAD_Value 0xFA
#define IRQN_SEELP_Value 0xFF
#define PACKET_MIAX_Value 0xff

typedef enum
{
Sleep_mode   = (unsigned char)0x00,
Stdby_mode   = (unsigned char)0x01,
TX_mode    = (unsigned char)0x02,
Transmitter_mode   = (unsigned char)0x03,
RF_mode        = (unsigned char)0x04,
Receiver_mode   = (unsigned char)0x05,
receive_single   = (unsigned char)0x06,
CAD_mode       = (unsigned char)0x07,
}RFMode_SET;

typedef enum
{
FSK_mode = (unsigned char)0x00,
LORA_mode = (unsigned char)0x80,
} Debugging_fsk_ook;

typedef enum{false=0,true=1}BOOL;

typedef enum{enOpen,enClose}cmdEntype_t;

typedef enum{rxOpen,txOpen}cmdpaType_t;

typedef struct{
void (*lpByteWritefunc)(unsigned char src);
unsigned char (*lpByteReadfunc)();
void (*lpSwitchEnStatus)(cmdEntype_t cmd);
// void (*paSwitchCmdfunc)(cmdpaType_t cmd);
// void (*lpRecvDataTousr)(unsigned char *lpbuf,unsigned short length);
}lpCtrlTypefunc_t;

void register_rf_func(lpCtrlTypefunc_t *func);
void PA_SEELP_OUT(void);
void Delay1s(unsigned int ii);
void SX1276WriteBuffer(unsigned char addr, unsigned char buffer);
unsigned char SX1276ReadBuffer( unsigned char addr);
void SX1276LoRaSetOpMode(RFMode_SET opMode);
extern void SX1276LoRaFsk(Debugging_fsk_ook opMode);
void SX1276LoRaSetRFFrequency(void);
void SX1276LoRaSetRFPower(unsigned char power);
void SX1276LoRaSetSpreadingFactor(unsigned char factor);
void SX1276LoRaSetNbTrigPeaks(unsigned char value);
void SX1276LoRaSetErrorCoding(unsigned char value);
void SX1276LoRaSetPacketCrcOn(BOOL enable);
void SX1276LoRaSetSignalBandwidth(unsigned char bw);
void SX1276LoRaSetImplicitHeaderOn(BOOL enable);
void SX1276LoRaSetSymbTimeout(unsigned int value);
void SX1276LoRaSetPayloadLength(unsigned char value);
//void SX1276LoRaSetPreamLength(unsigned int value);
void SX1276LoRaSetMobileNode(BOOL enable);
void SLEEPLORA_INT(void);
//void FSK_SEND_PACKET(void);
void FUN_RF_SENDPACKET(unsigned char *RF_TRAN_P,unsigned char LEN);
void RF_RECEIVE (void);
//void RF_CAD_RECEIVE (void);
//void RF_SEELP(void);
void SX1276LORA_INT(void);
//void SX1278_Interupt(void);

extern unsigned char RF_EX0_STATUS;

extern unsigned char CRC_Value;
extern lpCtrlTypefunc_t lpTypefunc;
extern unsigned char SX1278_RLEN;

void SX1276Reset(void);
void RF_SPI_MasterIO(unsigned char out);
unsigned char RF_SPI_READ_BYTE();
void cmdSwitchEn(cmdEntype_t cmd);
/*
#define IRQ P11
#define CE P14
#define CSN P15
#define SCK P12
#define MOSI P13
#define MISO P10
*/
extern unsigned char Frequency[3];
extern unsigned char powerValue;
extern unsigned char SpreadingFactor; //7-12
extern unsigned char CodingRate ; //1-4
extern unsigned char Bw_Frequency; //6-9
extern unsigned char RF_EX0_STATUS;
extern unsigned char CRC_Value;
extern lpCtrlTypefunc_t ctrlTypefunc;
extern unsigned char SX1278_RLEN;
#endif

typedef.h

/******************************************************************************/
/* -- 深圳安信可科技有限公司 -- */
/*
// 文件名：
// 说明：
// 编写人员：
// 编写日期：
// 程序维护：
//   维护记录：
//
//
*/
// 免责声明：该程序仅用于学习与交流
// (c) Anxinke Corporation. All rights reserved.
/******************************************************************************/
#ifndef __TYPEDEF_H
#define __TYPEDEF_H

#include "reg51.h"
#include "intrins.h"

#define MCU_FREQ 22118400 // 设置晶振频率

#define ON 1
#define OFF 0

typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;

typedef unsigned char uchar;
typedef unsigned int uint;
typedef unsigned char BYTE;

#endif

uart.c

static bit bUartFlag;

uart.h

/******************************************************************************/
/* -- 深圳安信可科技有限公司 -- */
/*
// 文件名：uart.h
// 说明：串口宏定义
// 编写人员：Wu
// 编写日期：2012年11月12日
// 程序维护：
//   维护记录：
//
//
*/
// 免责声明：该程序仅用于学习与交流
// (c) Anxinke Corporation. All rights reserved.
/******************************************************************************/
#ifndef __UART_H
#define __UART_H

#define UART_BUAD 115200

void uartInit(void);
void uartSendData(u8 ucData);
void uartSendString(char *s);

#endif