聚尔硕无线模块程序

最新推荐文章于 2024-05-14 16:19:21 发布
最新推荐文章于 2024-05-14 16:19:21 发布
阅读量658 收藏 1
点赞数

 

              测试PCB板引脚定义

               sbit          CS=P2^6;                    //  12864PIN4     vala显示缓冲valb加减时间处理缓冲
               sbit          SID=P2^7;                  //     12864PIN5
               sbit          SCLK=P1^0;              //     12864PIN6
               sbit          Setkey=P1^5;             //     设置按键
               sbit          funkey=P1^3;              //
               sbit          DATAUP=P1^2;         //加按键
               sbit          DATADOWN=P1^1;  //减按键

 

/

/

///WDT.h

#include "incxx.h"
#include "WDT.h"

#define d_WDTE 1                  //WDT Enable Bit
#define d_WDTM 0x0C              //WDTM[3:0] WDT Clock Source Divider Bit (0~F),4.19s

void WDT_initialize(void)          //Initialize WDT
{
    TAKEY=0x55;                    //**************************************//
    TAKEY=0xAA;                    //Set To Enable The WDTC Write Attribute//
    TAKEY=0x5A;                    //**************************************//
    WDTC=(d_WDTM)|(d_WDTE<<5);     //Set WDT Reset Time and Enable WDT
}

U8 wdtDelay = 0;
void WDT_CountClear(void)
{
    WDTK=0x55;                    //WDT Timer Clear To Zero    

    wdtDelay = 0;
    while(wdtDelay++ < 100)
        ;
}
#if 0
void WDT_Disable(void)
{
    TAKEY=0x55;                    //**************************************//
    TAKEY=0xAA;                    //Set To Enable The WDTC Write Attribute//
    TAKEY=0x5A;                    //**************************************//
    WDTC=0x00;                    //Disable WDT Function
}
#endif
/

boot.c///

#include "incXX.h"

void Init_main()
{
    IFCON |= 0x00 + 0x04;//ALE输出控制寄存器不输出
    EA = 0;    //关闭总中断


    TIMER0_initialize(); //定时器0初始化
    init_UART0();   //串口0初始化

    WDT_initialize();    //看门狗初始化
    WDT_CountClear(); //喂狗

    EA = 1;
  //IO口全部设置为普通的双向IO口
    P0M0 = 0;
    P0M1 = 0;
    
    P1M0 = 0;
    P1M1 = 0;
    
    P2M0 = 0;
    P2M1 = 0;
    
    P3M0 = 0;
    P3M1 = 0;
    
    P4M0 = 0;
    P4M1 = 0;

}
/*
void exint0() interrupt 0
{

}

U8 int001 = 0;
void exint1() interrupt 2
{
    int001 = 1;
    //SX1278_Interupt();
}
*/

void main()
{
    Init_main(); //使能低压中断，初始化定时器、串口，看门狗，设置IO口工作模式
    //开机指示
    P3 &= 0x0f;
    DelayMS(500);
    P3 |= 0xf0;
    DelayMS(500);
    P3 &= 0x0f;
    DelayMS(500);
    P3 |= 0xf0;
    DelayMS(500);
    //UART0_TX(0xaa);
    ProcessMain();

    while(1)
    {


    }
}

/

//1276.c///

#include "incXX.h"
#include "Sx1276.h"

unsigned char   Frequency[3]={0x6c,0x80,0x00};

unsigned char   SpreadingFactor=11;    //7-12,扩频因子选小一些，发射时间会更快一些。

unsigned char   CodingRate=2;        //1-4

unsigned char   Bw_Frequency=7;      //6-9

unsigned char   powerValue= 15;       //功率设置，调试的时候可以先设置小一点
/*
RegPaconfig 0x09
bit            name                  discription
 7         PaSelect             0--> RFO pin, Output power is limited to +14dBm
                                         1--> PA_BOOST pin, Output power is limited to +20dBm

6~4         MaxPower      Select max output power:Pmax=10.8+0.6*MaxPower [dBm]

3~0         OutputPower   if PaSelect=0, Pout=Pmax-(15-OutputPower)
                                         if PaSelect=1, Pout=17-(15-OutputPower)
*/
unsigned char   power_data[16]={0X80,0X81,0X82,0X83,0X84,0X85,0X86,0X87,0X88,0x89,0x8a,0x8b,0x8c,0x8d,0x8e,0x8f};

unsigned char   RF_EX0_STATUS;

unsigned char   CRC_Value;

unsigned char   SX1278_RLEN;


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

#if 0
void FSK_SEND_PACKET(void)
{
    SX1276LoRaSetOpMode( Stdby_mode );
    SX1276WriteBuffer(REG_LR_DIOMAPPING1,0x01);
    SX1276WriteBuffer(REG_LR_DIOMAPPING2,0x20);
}
#endif    

void SX1276WriteBuffer( unsigned char addr, unsigned char buffer)
{ 
    gSwitchEnStatus(enOpen); //NSS = 0;
    gByteWritefunc( addr | 0x80 );
    gByteWritefunc( buffer);
    gSwitchEnStatus(enClose); //NSS = 1;

}
    
unsigned char SX1276ReadBuffer(unsigned char addr)
{
    unsigned char Value;
    gSwitchEnStatus(enOpen); //NSS = 0;
    gByteWritefunc( addr & 0x7f  );
    Value = gByteReadfunc();
    gSwitchEnStatus(enClose);//NSS = 1;
    return Value; 
}
    
void SX1276LoRaSetOpMode( RFMode_SET opMode )
{
    unsigned char opModePrev;
    opModePrev=SX1276ReadBuffer(REG_LR_OPMODE);  //读0x01模式寄存器
    opModePrev &=0xf8;  //清零低三位
    opModePrev |= (unsigned char)opMode; //或上形参
    SX1276WriteBuffer( REG_LR_OPMODE, opModePrev); //重新写回去    
}

void SX1276LoRaFsk( Debugging_fsk_ook opMode )
{
    unsigned char opModePrev;
    opModePrev=SX1276ReadBuffer(REG_LR_OPMODE); //读0x01模式寄存器
    opModePrev &=0x7F; //清零最高位
    opModePrev |= (unsigned char)opMode;  //或上形参
    SX1276WriteBuffer( REG_LR_OPMODE, opModePrev); //重新写回去        
}
    
void SX1276LoRaSetRFFrequency(void)
{
    SX1276WriteBuffer( REG_LR_FRFMSB, Frequency[0]);  //写0x06寄存器
    SX1276WriteBuffer( REG_LR_FRFMID, Frequency[1]);  //写0x07寄存器
    SX1276WriteBuffer( REG_LR_FRFLSB, Frequency[2]);  //写0x08寄存器
}

void SX1276LoRaSetRFPower(unsigned char power )
{
    //Set Pmax to +20dBm for PA_HP, Must turn off PA_LF or PA_HF, and set RegOcp
    //SX1276WriteBuffer( REG_LR_PACONFIG,  power_data[power] ); //若没有这一句，频谱仪几乎测不到信号,但是可以进行正常收发。
    //SX1276WriteBuffer( REG_LR_OCP, 0x3f);  //add by skay,20160810, 写电流保护寄存器，
    SX1276WriteBuffer( REG_LR_PADAC, 0x87);  //high power
    SX1276WriteBuffer( REG_LR_PACONFIG,  power_data[power] ); //若没有这一句，频谱仪几乎测不到信号,但是可以进行正常收发。
}

    
void SX1276LoRaSetSpreadingFactor(unsigned char factor )
{
    unsigned char RECVER_DAT;
    SX1276LoRaSetNbTrigPeaks( 3 ); //0x03-->SF7 to SF12
    RECVER_DAT=SX1276ReadBuffer( REG_LR_MODEMCONFIG2); //读0x1E寄存器  
    RECVER_DAT = ( RECVER_DAT & RFLR_MODEMCONFIG2_SF_MASK ) | ( factor << 4 );
    SX1276WriteBuffer( REG_LR_MODEMCONFIG2, RECVER_DAT );     
}
    
void SX1276LoRaSetNbTrigPeaks(unsigned char value )
{
    unsigned char RECVER_DAT;
    RECVER_DAT = SX1276ReadBuffer( 0x31);  //Read RegDetectOptimize,
    RECVER_DAT = ( RECVER_DAT & 0xF8 ) | value; //process;
    SX1276WriteBuffer( 0x31, RECVER_DAT );  //write back;
}
    
void SX1276LoRaSetErrorCoding(unsigned char value )
{    
    unsigned char RECVER_DAT;
    RECVER_DAT=SX1276ReadBuffer( REG_LR_MODEMCONFIG1); //读0x1D寄存器
    RECVER_DAT = ( RECVER_DAT & RFLR_MODEMCONFIG1_CODINGRATE_MASK ) | ( value << 1 );
    SX1276WriteBuffer( REG_LR_MODEMCONFIG1, RECVER_DAT);
}
    
void SX1276LoRaSetPacketCrcOn(BOOL_t enable )
{    
    unsigned char RECVER_DAT;
    RECVER_DAT= SX1276ReadBuffer( REG_LR_MODEMCONFIG2);  //读0x1E寄存器 
    RECVER_DAT = ( RECVER_DAT & RFLR_MODEMCONFIG2_RXPAYLOADCRC_MASK ) | ( enable << 2 );
    SX1276WriteBuffer( REG_LR_MODEMCONFIG2, RECVER_DAT );
}
    
void SX1276LoRaSetSignalBandwidth(unsigned char bw )
{
    unsigned char RECVER_DAT;
    RECVER_DAT=SX1276ReadBuffer( REG_LR_MODEMCONFIG1);  //读0x1D寄存器
    RECVER_DAT = ( RECVER_DAT & RFLR_MODEMCONFIG1_BW_MASK ) | ( bw << 4 );
    SX1276WriteBuffer( REG_LR_MODEMCONFIG1, RECVER_DAT );
}
    
void SX1276LoRaSetImplicitHeaderOn(BOOL_t enable )
{
    unsigned char RECVER_DAT;
    RECVER_DAT=SX1276ReadBuffer( REG_LR_MODEMCONFIG1 );  //读0x1D寄存器
    RECVER_DAT = ( RECVER_DAT & RFLR_MODEMCONFIG1_IMPLICITHEADER_MASK ) | ( enable );
    SX1276WriteBuffer( REG_LR_MODEMCONFIG1, RECVER_DAT );
}
    
void SX1276LoRaSetSymbTimeout(unsigned int value )
{
    unsigned char RECVER_DAT[2];
    RECVER_DAT[0]=SX1276ReadBuffer( REG_LR_MODEMCONFIG2 );    //读0x1E寄存器
    RECVER_DAT[1]=SX1276ReadBuffer( REG_LR_SYMBTIMEOUTLSB );  //读0x1F寄存器
    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 SX1276LoRaSetPayloadLength(unsigned char value )
{
    SX1276WriteBuffer( REG_LR_PAYLOADLENGTH, value );  //写0x22寄存器
} 
    
#if 0
void SX1276LoRaSetPreamLength(unsigned int value )
{
    unsigned char a[2];
    a[0]=(value&0xff00)>>8;
    a[1]=value&0xff;
    SX1276WriteBuffer( REG_LR_PREAMBLEMSB, a[0] );
    SX1276WriteBuffer( REG_LR_PREAMBLELSB, a[1] );
}
#endif

void SX1276LoRaSetMobileNode(BOOL_t enable )
{     
    unsigned char RECVER_DAT;
    RECVER_DAT=SX1276ReadBuffer( REG_LR_MODEMCONFIG3 );  //读0x26寄存器
    RECVER_DAT = ( RECVER_DAT & RFLR_MODEMCONFIG3_MOBILE_NODE_MASK ) | ( enable << 3 );
    SX1276WriteBuffer( REG_LR_MODEMCONFIG3, RECVER_DAT );
}

void SX1276LORA_INT(void)
{
    SX1276LoRaSetOpMode(Sleep_mode);  //设置睡眠模式
    SX1276LoRaFsk(LORA_mode);         // 设置扩频模式
    SX1276LoRaSetOpMode(Stdby_mode);  // 设置为普通模式
    SX1276WriteBuffer( REG_LR_DIOMAPPING1,GPIO_VARE_1); //写0x40寄存器,DIO引脚映射设置
    SX1276WriteBuffer( REG_LR_DIOMAPPING2,GPIO_VARE_2); //写0x41寄存器
    SX1276LoRaSetRFFrequency();  //频率设置
    SX1276LoRaSetRFPower(powerValue);  //功率设置
    SX1276LoRaSetSpreadingFactor(SpreadingFactor);     // 扩频因子设置
    SX1276LoRaSetErrorCoding(CodingRate);         //有效数据比
    SX1276LoRaSetPacketCrcOn(true);             //CRC 校验打开
    SX1276LoRaSetSignalBandwidth( Bw_Frequency );     //设置扩频带宽, 125khz
    SX1276LoRaSetImplicitHeaderOn(false);         //同步头是显性模式
    SX1276LoRaSetPayloadLength( 0xff);
    SX1276LoRaSetSymbTimeout( 0x3FF );
    SX1276LoRaSetMobileNode(true);              // 低数据的优化

    RF_RECEIVE();
}
    
void FUN_RF_SENDPACKET(unsigned char *RF_TRAN_P,unsigned char LEN)
{    
    unsigned char ASM_i;
    
    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); //写Tx FIFO基址
    SX1276WriteBuffer( REG_LR_FIFOADDRPTR, 0 ); //SPI interface address pointer in FIFO data buffer
    gSwitchEnStatus(enOpen);   //开片选
    gByteWritefunc( 0x80 );
    for( ASM_i = 0; ASM_i < LEN; ASM_i++ )
    {
        gByteWritefunc( *RF_TRAN_P );RF_TRAN_P++;
    }
    gSwitchEnStatus(enClose);  //关片选
    SX1276WriteBuffer(REG_LR_DIOMAPPING1,0x40);  //发射中断映射到DIO0引脚
    SX1276WriteBuffer(REG_LR_DIOMAPPING2,0x00);
    SX1276LoRaSetOpMode( Transmitter_mode );     //设置为传输模式
    
}
void RF_RECEIVE (void)
{
    SX1276LoRaSetOpMode(Stdby_mode );
    SX1276WriteBuffer(REG_LR_IRQFLAGSMASK,IRQN_RXD_Value);  //0x11,打开接收中断
    SX1276WriteBuffer(REG_LR_HOPPERIOD,    PACKET_MIAX_Value );//0x24寄存器
    SX1276WriteBuffer( REG_LR_DIOMAPPING1, 0X00 ); //DIO引脚映射设置，按默认
    SX1276WriteBuffer( REG_LR_DIOMAPPING2, 0X00 );    
    SX1276LoRaSetOpMode( Receiver_mode );  //设置为连续接收模式
}
#if 0    
void RF_CAD_RECEIVE (void)
{
    SX1276LoRaSetOpMode( Stdby_mode );
    SX1276WriteBuffer(REG_LR_IRQFLAGSMASK,  IRQN_CAD_Value);    //打开发送中断
    SX1276WriteBuffer( REG_LR_DIOMAPPING1, 0X80 );
    SX1276WriteBuffer( REG_LR_DIOMAPPING2, 0X00 );    
    SX1276LoRaSetOpMode( CAD_mode );
}
#endif

#if 0
void RF_SEELP(void)
{
    SX1276LoRaSetOpMode( Stdby_mode );
    SX1276WriteBuffer(REG_LR_IRQFLAGSMASK,  IRQN_SEELP_Value);  //打开发送中断
    SX1276WriteBuffer( REG_LR_DIOMAPPING1, 0X00 );
    SX1276WriteBuffer( REG_LR_DIOMAPPING2, 0X00 );    
    SX1276LoRaSetOpMode( Sleep_mode );
}
#endif

//**************下面是中断里面处理的代码*******************************
unsigned char recv[10];
unsigned char RF_REC_RLEN_i;
void SX1278_Interupt(void)
{
    RF_EX0_STATUS=SX1276ReadBuffer( REG_LR_IRQFLAGS ); 
    if((RF_EX0_STATUS&0x40)==0x40)  //接收完成
    {
        CRC_Value=SX1276ReadBuffer( REG_LR_MODEMCONFIG2 );
        if(CRC_Value&0x04==0x04) //是否打开CRC校验
        {
            SX1276WriteBuffer (REG_LR_FIFOADDRPTR,0x00);
            SX1278_RLEN = SX1276ReadBuffer(REG_LR_NBRXBYTES); //读取最后一个包的字节数
            gSwitchEnStatus(enOpen);
            gByteWritefunc( 0x00 );
            if(SX1278_RLEN > 10)  //接收不超过10个字节
                SX1278_RLEN = 10;            
            for(RF_REC_RLEN_i=0;RF_REC_RLEN_i<SX1278_RLEN;RF_REC_RLEN_i++)
            {
                recv[RF_REC_RLEN_i]=gByteReadfunc();        
            }
            gSwitchEnStatus(enClose);
        }
        fqcRecvData(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 );

    }
    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 );
        
    }
    else if((RF_EX0_STATUS&0x04)==0x04)  //cad完成
    {  
        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 );
            
        }
        else
        {                           
        // 没检测到
            SX1276LoRaSetOpMode( Stdby_mode );
            SX1276WriteBuffer(REG_LR_IRQFLAGSMASK,    IRQN_SEELP_Value);    //打开发送中断
            SX1276WriteBuffer( REG_LR_DIOMAPPING1, 0X00 );
            SX1276WriteBuffer( REG_LR_DIOMAPPING2, 0X00 );    
            SX1276LoRaSetOpMode( Sleep_mode );
            
        }
    }
    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 );
        
    }
    SX1276WriteBuffer( REG_LR_IRQFLAGS, 0xff  );

}

///
///
///
///
///

void Delaycc(void)
{
    unsigned int xccv,ysdfg;
    for(xccv=0; xccv<1000; xccv++)
        for(ysdfg=0; ysdfg<110; ysdfg++);
}

void Delaymm(void)
{
    //unsigned char xccv;
   // for(xccv=0; xccv<20; xccv++);
}

void GPIO_Config(void)
{
    RF_REST_L;
    RF_CKL_L;
    RF_CE_H;
    RF_SDI_H;               //MOSI
    SX1278_SDO = 1;  //MISO
}

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

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

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


unsigned char RF_SPI_READ_BYTE()
{     
    unsigned char j;
    unsigned char i;
    j=0;
    for (i = 0; i < 8; i++)
    {     
        RF_CKL_H; 
        Delaymm();
        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 //  
        Delaymm();
    }
    return j;                        // toggle clock low //
}

void cmdSwitchEn(cmdEntype_t cmdcmd)
{
    switch(cmdcmd)
    {
        case enOpen:
        {
            RF_CE_L;
            break;
        }
        case enClose:
        {
            RF_CE_H;
            break;
        }
        
        default:
            break;
    }
}

void fqcRecvData(unsigned char *lpbuf,unsigned short len)// 接收到RF的数
{
    unsigned char i;
    unsigned char Irq_flag=0;
    switch(lpbuf[1]&0x0f)
    {
        case 0x0e:P3_4=0;
            break;
        case 0x0d:P3_5=0;
            break;
        case 0x0b:P3_6=0;
            break;
        case 0x07:P3_7=0;
            break;
        default: P3 |=0xf0;
            break;
    }
    uartSendRecv();
    Delaycc();
    WDT_CountClear(); //喂狗
    Delaycc();
#if 1
    for(i=0; i<3; i++)
    {
        FUN_RF_SENDPACKET(lpbuf,len); //发射数据
        Irq_flag=SX1276ReadBuffer( REG_LR_IRQFLAGS ); 
        //while(Irq_flag&0x08 != 0x08)  //xx
        while((Irq_flag&0x08) != 0x08)
        {
            DelayMS(1);
            Irq_flag=SX1276ReadBuffer( REG_LR_IRQFLAGS ); 
        }
    }
    SX1278_RLEN = 0;
#endif
    //uartSendRecv();
    //Delaycc();
    //Delaycc();
    P3 |=0xf0;

}

void main_init(void)
{   
    GPIO_Config();
    SX1276Reset();
    SX1276LORA_INT();
    //enableInterrupts();
    SX1278_RLEN = 0;   
}

void uartSendRecv()
{
    if(SX1278_RLEN)
    {
        UartTestSend(recv,SX1278_RLEN);
        //SX1278_RLEN = 0;
    }

}

///
///
///
///
/client.c

//************************************************************************************
//    ProjectCode                    :    Sx1278_Demo
//    Function                        :    Press one key, Send a set of data to other Board,
//                                                After the other Board recept the data, Send it back and light
//                                                on the corresponding LED, also send the data to serial port.
//    CreateBy                        :    skay.chan    
//    CreateDate                    :    2016-7-20
//    ModifyDate                    :    2016-9-29
//    Document                        :    
//    WorkPlatform                : Keil4    
//    Others                            :    QQ:2168916131
//    Copyright                        :    Lchstar.com
//*************************************************************************************
#include "incXX.h"

U32 __DelayTimerMs;
void DelayMS(U8 ms)
{
    __DelayTimerMs = GetTimer();
    while(SpanTime(__DelayTimerMs) < ms)
        WDT_CountClear();

}

void UartTestSend(U8* pbuffer,U8 len)
{
    U8 i;
    for(i=0; i<len; i++)
        UART0_TX(pbuffer[i]);
}

U32 Timer0Count = 0;
void TimerTick()
{
    Timer0Count++;    
}

U32 Timer0Temp;
U32 GetTimer()
{
    ET0 = 0;
    Timer0Temp = Timer0Count;
    ET0 = 1;
    return Timer0Temp;
}
/********扫描时间间隔函数*********/
U32 SpanTime(U32 OldTime)
{
    ET0 = 0;  //关T0中断
    Timer0Temp = Timer0Count; //取当前定时计数器的计数值。
    ET0 = 1;  //使能T0中断
    if(Timer0Temp >= OldTime)
        return Timer0Temp - OldTime;  //返回两次计数器的差值
    else //如果新的值小于老的值，说明计数器已经至少走过了一轮了
        return (U32)-1 - OldTime + Timer0Temp;
}

/*
void INTInit()
{
    IE0 = 0;
    IT0 = 1;
    EX0 = 1;

    IE1 = 0;
    IT1 = 1;
    EX1 = 1;
}
*/

void ProcessMain()
{
    main_init();//复位及初始化1276
    //INTInit();
    EA = 1;  //开总中断
    DelayMS(500);
    while(1)
    {
        WDT_CountClear(); //喂狗
        DelayMS(1);              //1.10189ms
        ProcessIdle();    //处理空闲模式，发射接收都在里面，主要的就是这个函数
    }
}

U8 _getinputVar = 0;
U8 _geti;
/******获取输入函数*******/
U8 GetInput()
{
    _geti = 0;
    _getinputVar = P2 & 0xF0; //读取P2.7~4的值
  //P2.7=KEY3, P2.6=KEY2, P2.5=KEY1, P2,4=KEY0
    while(_geti < 5)
    {        
        DelayMS(5);
        if(_getinputVar == (P2 & 0xF0))
            break;
        else
            _getinputVar = P2 & 0xF0;
        
        _geti++;
    }
    while((P2&0xf0) != 0xF0)
        ;
    _getinputVar >>= 4;  //右移4位，将高4位的键值移到低4位
    return _getinputVar;

}

void scLED(ledCmdType_t _ledcmd,ledVarType_t _ledvar)
{
    switch(_ledcmd)
    {
        case ledONE:
        {
            __LED0__ = _ledvar;  //#define __LED0__ P3_4
            break;
        }
        case ledTWO:
        {
            __LED1__ = _ledvar;  //#define __LED1__ P3_5
            break;
        }
        case ledTHREE:
        {
            __LED2__ = _ledvar;  //#define __LED2__ P3_6
            break;
        }
        case ledFOUR:
        {
            __LED3__ = _ledvar;  //#define __LED3__ P3_7;板上显示led4
            break;
        }
        default:
            break;
    }
}

U8 inputStatue = 0x0F;
U8 inputValue = 0x00;
U8 gSendBuffer[SENDBUFFERLEN];
U8 gRecvBuffer[SENDBUFFERLEN];

void ProcessIdle()
{
    inputValue = GetInput();
    if(inputValue != inputStatue) //有按键按下,inputStatue默认是为0x0f；
    {    
        UART0_TX(inputValue);          //先发串口看看
        ProcessOutput(inputValue);     //LED输出下状态?
        ProcessSend();                             //发射
        inputValue=0x00;                      //键值清零
        P3 |= 0xf0;                                  //关LED灯
    }
    ProcessRecv();                              //接收    
}

void ProcessRecv()
{
    if(SX1276ReadBuffer( REG_LR_IRQFLAGS ))  //读0x12状态寄存器
        SX1278_Interupt();
}

U8 inputStatueOld = 0x0F;
void ProcessSend()
{
    unsigned char i;
    unsigned char Irq_flag=0;

    gSendBuffer[0] = 0x5a;
    gSendBuffer[1] = inputValue;
    gSendBuffer[2] = 0xfa;
    for(i=0; i<3; i++)
    {
        FUN_RF_SENDPACKET(gSendBuffer,SENDBUFFERLEN); //发射数据
        Irq_flag=SX1276ReadBuffer( REG_LR_IRQFLAGS ); 
        //while(Irq_flag&0x08 != 0x08)  //xx
        while((Irq_flag&0x08) != 0x08)
        {
            DelayMS(1);
            Irq_flag=SX1276ReadBuffer( REG_LR_IRQFLAGS ); 
        }
    }
}

void ProcessOutput(U8 outputStatue)
{
    U8 temp;
    temp = outputStatue;
    if(temp & 0x01)  //是否没有按下key0
    {
        scLED(ledONE,ledOFF);          //关闭LED1
    }
    else //如果有按下key0
    {
        scLED(ledONE,ledON);            //开启LED1
    }        
    if(temp & 0x02)
    {
        scLED(ledTWO,ledOFF);           //关闭LED2
    }
    else
    {
        scLED(ledTWO,ledON);            //开启LED2
    }
    
    if(temp & 0x04)
    {
        scLED(ledTHREE,ledOFF);           //关闭LED3
    }
    else
    {
        scLED(ledTHREE,ledON);            //开启LED3
    }
    
    if(temp & 0x08)
    {
        scLED(ledFOUR,ledOFF);          //关闭LED4
    }
    else
    {
        scLED(ledFOUR,ledON);            //开启LED4
    }

}


///
///
///
//uart0.c///

#include "incXX.h"
#include "UART0.h"

//===============================================================
//DEFINITIONs
//===============================================================
// 22.1184M 115200
//#define d_S0RELH            0x03
//#define d_S0RELL            0xFA

//9600
//22.1184M
#define d_S0RELH            0x03
#define d_S0RELL            0xB8

//4M
//#define d_S0RELH            0x03
//#define d_S0RELL            0xF3

//8M
//#define d_S0RELH            0x03
//#define d_S0RELL            0xE6

//===============================================================
//GLOBAL VARIABLE
//===============================================================
bit bU0TX    = 0;

unsigned char UartBuffer[__UARTBUFFERLEN];
unsigned char UartBufferLen = 0;
U32 __UartTimer = 0;
//=========================================================================
void init_UART0(void)
{
    S0RELH     = d_S0RELH;  //串口0重载寄存器高字节
    S0RELL     = d_S0RELL;  //串口0重载寄存器字低节
    AUX        |= 0x80;            // BRS = 1
    PCON    |= 0x80;            // SMOD =1,串口通信的波特率倍增
    IEN0     |= 0x90;            // EA=1, ES0=1, interrupt enable,使能串口0中断
    S0CON     = 0x50;            // mode 1, SM20=0, Revice enable
    TI=0;   //清除发射中断标志
}

void UART0_ISR(void) interrupt d_UART0_Vector
{
    unsigned char RXBUF0;

    if(RI)                        // INT_RX
    {
        RI = 0;                    // RI clear
        RXBUF0 = S0BUF;            // Read BUF, user code...
        UartBuffer[UartBufferLen++] = RXBUF0;
        if(UartBufferLen >= __UARTBUFFERLEN)
            UartBufferLen = __UARTBUFFERLEN - 1;
        __UartTimer = GetTimer();
    }
    else                        // INT_TX
    {
        bU0TX    =0;
        TI        =0;                // TI clear
    }
}

void UART0_TX(unsigned char n_temp0)
{    
    bU0TX    = 1;
    S0BUF    = n_temp0;
    while(bU0TX)
    {
        ;
    }
}

/

///timer.c///

#include "Timer.h"
#include "incXX.h"

#define TIMER0_VECTOR 1 //TIMER0 Interrupt Vevtor
#define d_T0MOD 0x01 //TMOD[3:0] TIMER0 Mode setting 
#define d_T1MOD 0x01 //TMOD[7:4] TIMER1 Mode setting
#define ET2 0x00 //TIMER2 overflow Interrupt Enable (Default 0 Disable)
#define ET1 0x00 //TIMER1 overflow Interrupt Enable (Default 0 Disable)
#define ET0 0x01 //TIMER0 overflow Interrupt Enable (Default 0 Disable)
unsigned int d_MODEVALUE_T0 = 65536; //MODE0 13bit 8192
                          //MODE1 16bit 65536
                          //MODE2 8bit 256(Auto Reload)
                          //MODE3 8bit 256                          
unsigned int d_RELOADVALUE_T0 = 128; //User Define Reload Value 

int i=100;

#define FOSC 22118400
//#define FOSC 8000000
#define T0MS    (65535 - FOSC/12/1000 + 5)


void TIMER0_initialize(void)  //Initialize TIMER0
{
    IEN0=(ET2<<5)|(ET1<<3)|(ET0<<1); //IE=IEN0,使能外部中断1
    TMOD=(d_T1MOD<<4)|(d_T0MOD); //T1,T0都为16位定时计数器.
    
    TL0 = T0MS;
    TH0 = T0MS>>8;
    TF0 = 0; //清除定时器0溢出标志

  TR0=1; //Timer0 Start bit     
}

void TIMER0_ISR(void) interrupt TIMER0_VECTOR 
{
    
    TL0 = T0MS;
    TH0 = T0MS>>8;
    TF0 = 0;

    TimerTick();
    
}

 

 

czhaii
关注
lora低功耗模式以及组网简单分析
pxw1992的博客
03-13 8850
上面的DIO maping 看懂就比较好理解了，DIO0,DIO1,DIO3, 发送和接收都可以出发中断，cad模式需要使用CADDetected和CADDone。 CADDetected这个中断就是有数据接收了，触发进入接收模式，前导码个数的计算还是比较简单的。 从上图可以看出，若要可靠唤醒 WOR，发送包的前导码必须大于 T1+2*T2 才能可靠唤醒。 TS=2^SF/BW 这个值是一个字节传输所用的时间，发送前导码的个数要T1+2*T2才能唤醒。 举个例子：SF=9,BW=1..
sleep-mode:使您的设备进入睡眠模式
05-03
睡眠模式 使您的设备进入睡眠模式。 安装 $ npm install --save sleep-mode 用法 var sleepMode = require ( 'sleep-mode' ) ; sleepMode ( function ( err , stderr , stdout ) { if ( ! err && ! stderr ) { console . log ( stdout ) ; } } ) ; 命令行界面 $ npm install --global sleep-mode $ sleep-mode 执照 麻省理工学院:copyright:
SX1278_LORA、SX1262_CW_LORA下信号分析
最新发布
weixin_52522953的博客
05-14 316
sx1278在LORA模式、sx1262在CW模式和LORA模式下信号发射频谱
SX1262 控制命令和寄存器映射表
创客之家
01-13 1381
介绍SX1262的控制命令和寄存器
SX126x-数字接口SPI和控制功能
只想.静静的博客
12-06 3832
目录 1 前言 2 Reset 3 SPI接口 3.1 属性要求 3.2 时序参数要求 1）离开Sleep模式时的时序 4 BUSY引脚 4.1 Tsw 4.2 TswMode 5 DIO 5.1 DIO1 5.2 DIO2 5.3 DIO3 6 IRQ 7 各模式下引脚状态 1 前言 本文主要介绍SX126x系列芯片的数字接口和控制引脚。主要包括如下几个部分： Reset引脚 SPI接口 Busy引脚 IRQ DIO引脚 2 Reset ...
NodeMCU-小程序数据显示模板.rar
08-21
通过 ESP8266(NodeMCU) 的无线连接能力，配合微信小程序的便捷用户交互，实现了对远程设备数据的实时监控和可视化。对于初学者或希望快速构建物联网应用的人来说，这是一个非常有价值的实践项目。在实际使用中，...
ZigBee 2007-Pro无线透明传输详解
文档由锋硕电子科技有限公司编写，内容涵盖ZigBee 2007-Pro无线系统的功能描述、工程架构、选项设置、初始化、任务事件处理、网络建立和设备加入流程、绑定过程以及数据的发送和接收。" ZigBee是一种低功耗、短距离...
基于android的智能家居监控系统的设计与实现硕论3万字.docx
06-21
- **架构**：Android采用分层架构设计，从底层的Linux内核到应用程序框架层，提供了丰富的API接口。 - **用户体验**：通过利用Android提供的UI组件和服务，可以构建美观且交互良好的用户界面。 - **语音识别技术**：...
ZigBee开发套件配套资源.rar
07-06
2. **开发板手册**：ZigBee开发板通常包含微控制器、无线射频模块和其他必要的硬件组件。手册会详细说明如何操作开发板，包括引脚定义、电源管理、调试接口以及如何连接到电脑进行编程。 3. **示例代码**：为了快速...
sx1278收发程序及中文版手册
11-15
sx1278收发程序及中文版手册
sx1278 参考设计
07-20
lora sx1278 参考设计，包含原理图，pcb文件和bom列表。
CE RF认证标准
03-12
CE RF认证标准的认证标准，对于刚进入这行的童鞋，学习一下标准，还是有帮助的
STM32开发笔记87: SX1268驱动程序设计（设置为STDBY模式）
snmplink的博客
09-01 2990
单片机型号：STM32L053R8T6 本系列开发日志，将详述SX1268驱动程序的整个设计过程，本篇介绍将芯片设置为STDBY模式的相关驱动程序。 一、STDBY模式 芯片上电、复位和从睡眠模式唤醒，都会从Startup模式自动进入到STDBY模式。STDBY模式又称为待机模式或者旁路模式。 在待机模式下，主机应在进入RX或TX模式之前配置芯片。默认情况下，系统选择13MHZ的RC振荡器...
LoRa无线通信技术介绍（六）SX127X芯片收发程序讲解
DT程序员的博客
03-15 1227
接收LORA芯片SX127X的收发程序。
无线通讯LoRa---SX1278芯片开发笔记
热门推荐
沉西乐恩的博客
07-07 5万+
1、资源搜集Datasheet 和驱动源码 从Semtech官网下载最新驱动代码 http://www.semtech.com/apps/filedown/down.php?file=sx12xxDrivers-V2.1.0.zip Datasheet我上传了资源，中文版和英文版都有，还带了笔记的 http://download.csdn.net/detail/csdn_logo/9560...
LoRa笔记03 LoRa sx1276 sx1278空中唤醒研究
IoT小能手
02-20 3万+
这篇笔记将讲LoRa节点的空中唤醒具体应用。
物联网之LoRa开发与应用四（LoRaPingPang系统设计）
许新天的博客
08-16 1万+
深入了解LoRa技术原理 内容概要： 1、LoRa扩频通信原理 2、LoRa关键技术参数 3、LoRa数据收发任务 模拟无线通信： 数字无线通信： 无线通信传播方式：地波传播（低于2MHz）、天波传播（2MHz~30MHz）、直线传播（30MHz以上） 无线通信传播路径：反射、散射、衍射 无线通信噪声： 扩频通信技术：从各种类型的噪声和多径失真中获得免疫性 ...
lora 移植到android_LoRa---官方例程移植
weixin_39583029的博客
12-22 956
SX1278芯片上移植Semtech官方PING-PONG例程移植环境：keil5.20硬件平台：stm32f051+sx12782、准备文件：SX12xxDrivers-V2.1.0文件夹下只有src为我们需要使用的文件夹，src文件夹下有platform文件夹、radio文件夹和一个文件main.c，platform文件夹存放的是不同硬件平台的驱动，我们只需要sx12xxEiger文件夹和p...
315M无线模块接收程序详解与代码分享
本文主要介绍了如何使用315M无线模块进行接收程序的编写，提供了相关的C语言程序代码，适用于嵌入式系统开发或者电子工程领域。程序涉及到液晶显示功能，便于用户查看接收数据。 在无线通信中，315M模块是一种常见...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值