sx1267 lora发送数据无法进入中断TxDone

mmy9995

如题  sx1267 lora发送数据无法进入中断TxDone，服务端也没有接收到数据，但是程序没报错。  

使用F407的开发板   发送部分代码如下：

void SX1276Send( uint8_t *buffer, uint8_t size )
{
    uint32_t txTimeout = 0;

    switch( SX1276.Settings.Modem )
    {
    case MODEM_FSK:
        {
            SX1276.Settings.FskPacketHandler.NbBytes = 0;
            SX1276.Settings.FskPacketHandler.Size = size;

            if( SX1276.Settings.Fsk.FixLen == false )
            {
                SX1276WriteFifo( ( uint8_t* )&size, 1 );
            }
            else
            {
                SX1276Write( REG_PAYLOADLENGTH, size );
            }            

            if( ( size > 0 ) && ( size <= 64 ) )
            {
                SX1276.Settings.FskPacketHandler.ChunkSize = size;
            }
            else
            {
                SX1276.Settings.FskPacketHandler.ChunkSize = 32;
            }

            // Write payload buffer
            SX1276WriteFifo( buffer, SX1276.Settings.FskPacketHandler.ChunkSize );
            SX1276.Settings.FskPacketHandler.NbBytes += SX1276.Settings.FskPacketHandler.ChunkSize;
            txTimeout = SX1276.Settings.Fsk.TxTimeout;
        }
        break;
    case MODEM_LORA:
        {
            if( SX1276.Settings.LoRa.IqInverted == true )
            {
                SX1276Write( REG_LR_INVERTIQ, ( ( SX1276Read( REG_LR_INVERTIQ ) & RFLR_INVERTIQ_TX_MASK & RFLR_INVERTIQ_RX_MASK ) | RFLR_INVERTIQ_RX_OFF | RFLR_INVERTIQ_TX_ON ) );
                SX1276Write( REG_LR_INVERTIQ2, RFLR_INVERTIQ2_ON );
            }
            else
            {
                SX1276Write( REG_LR_INVERTIQ, ( ( SX1276Read( REG_LR_INVERTIQ ) & RFLR_INVERTIQ_TX_MASK & RFLR_INVERTIQ_RX_MASK ) | RFLR_INVERTIQ_RX_OFF | RFLR_INVERTIQ_TX_OFF ) );
                SX1276Write( REG_LR_INVERTIQ2, RFLR_INVERTIQ2_OFF );
            }      

            SX1276.Settings.LoRaPacketHandler.Size = size;

            // Initializes the payload size
            SX1276Write( REG_LR_PAYLOADLENGTH, size );

            // Full buffer used for Tx            
            SX1276Write( REG_LR_FIFOTXBASEADDR, 0 );
            SX1276Write( REG_LR_FIFOADDRPTR, 0 );

            // FIFO operations can not take place in Sleep mode
            if( ( SX1276Read( REG_OPMODE ) & ~RF_OPMODE_MASK ) == RF_OPMODE_SLEEP )
            {
                SX1276SetStby( );
                delay_ms( 1 );
            }
            // Write payload buffer
            SX1276WriteFifo( buffer, size );
            txTimeout = SX1276.Settings.LoRa.TxTimeout;
        }
        break;
    }

    SX1276SetTx( txTimeout );
}


程序正常运行  返回的状态也是发送成功  但是一直进不到任何回调里

三叶草

一步一步调试下看看，这么看看不出问题

mmy9995

三叶草 发表于 2020-10-25 12:37
一步一步调试下看看，这么看看不出问题

我有加入灯光测试，代码都进入了该进入的地方  最后也是把数据包写入FIFO  然后设置模式是RF_OPMODE_TRANSMITTER   就开始等待数据的发送。  但是服务端一直接收不到。。

但我这个新板子，设置的定时器跟对应的回调都无法进入。。  不知道SX1276SetOpMode设置模式有没有起作用

请问你知道  要怎么调试比较好嘛。？

chenyuan

中断的那个引脚 配置有没有问题，另外可以先试试每隔个10ms发一两个字节（一直发），看会不会进入TXDone中断

mmy9995

chenyuan 发表于 2020-10-26 09:30
中断的那个引脚 配置有没有问题，另外可以先试试每隔个10ms发一两个字节（一直发），看会不会进入TXDone中 ...

我试了一下可以进入TXDone中断了，  TXDone是通过EXTI1_IRQHandler中断进去的，但第一次进去后，lora状态设置成了Sleep模式，然后就会不停地进入EXTI1_IRQHandler中断，请问这是怎么回事呢。？
EXTI1_IRQHandler代码如下：
void EXTI1_IRQHandler( void )//SX1276&#214;D&#182;&#207;&#207;&#223;IDO0é&#207;éy&#209;&#216;ì&#248;±&#228;&#189;&#248;è&#235;
{
    volatile uint8_t irqFlags = 0;

    switch( SX1276.Settings.State )
    {               
        case RF_RX_RUNNING:
            // RxDone interrupt
            switch( SX1276.Settings.Modem )
            {
            case MODEM_FSK:
                if( SX1276.Settings.Fsk.CrcOn == true )
                {
                    irqFlags = SX1276Read( REG_IRQFLAGS2 );
                    if( ( irqFlags & RF_IRQFLAGS2_CRCOK ) != RF_IRQFLAGS2_CRCOK )
                    {
                        // Clear Irqs
                        SX1276Write( REG_IRQFLAGS1, RF_IRQFLAGS1_RSSI |
                                                    RF_IRQFLAGS1_PREAMBLEDETECT |
                                                    RF_IRQFLAGS1_SYNCADDRESSMATCH );
                        SX1276Write( REG_IRQFLAGS2, RF_IRQFLAGS2_FIFOOVERRUN );

                        if( SX1276.Settings.Fsk.RxContinuous == false )
                        {
                            SX1276.Settings.State = RF_IDLE;
                            TimerStart( &RxTimeoutSyncWord );
                        }
                        else
                        {
                            // Continuous mode restart Rx chain
                            SX1276Write( REG_RXCONFIG, SX1276Read( REG_RXCONFIG ) | RF_RXCONFIG_RESTARTRXWITHOUTPLLLOCK );
                        }
                        TimerStop( &RxTimeoutTimer );

                        if( ( RadioEvents != NULL ) && ( RadioEvents->RxError != NULL ) )
                        {
                            RadioEvents->RxError( );
                        }
                        SX1276.Settings.FskPacketHandler.PreambleDetected = false;
                        SX1276.Settings.FskPacketHandler.SyncWordDetected = false;
                        SX1276.Settings.FskPacketHandler.NbBytes = 0;
                        SX1276.Settings.FskPacketHandler.Size = 0;
                        break;
                    }
                }
               
                // Read received packet size
                if( ( SX1276.Settings.FskPacketHandler.Size == 0 ) && ( SX1276.Settings.FskPacketHandler.NbBytes == 0 ) )
                {
                    if( SX1276.Settings.Fsk.FixLen == false )
                    {
                        SX1276ReadFifo( ( uint8_t* )&SX1276.Settings.FskPacketHandler.Size, 1 );
                    }
                    else
                    {
                        SX1276.Settings.FskPacketHandler.Size = SX1276Read( REG_PAYLOADLENGTH );
                    }
                    SX1276ReadFifo( RxTxBuffer + SX1276.Settings.FskPacketHandler.NbBytes, SX1276.Settings.FskPacketHandler.Size - SX1276.Settings.FskPacketHandler.NbBytes );
                    SX1276.Settings.FskPacketHandler.NbBytes += ( SX1276.Settings.FskPacketHandler.Size - SX1276.Settings.FskPacketHandler.NbBytes );
                }
                else
                {
                    SX1276ReadFifo( RxTxBuffer + SX1276.Settings.FskPacketHandler.NbBytes, SX1276.Settings.FskPacketHandler.Size - SX1276.Settings.FskPacketHandler.NbBytes );
                    SX1276.Settings.FskPacketHandler.NbBytes += ( SX1276.Settings.FskPacketHandler.Size - SX1276.Settings.FskPacketHandler.NbBytes );
                }

                if( SX1276.Settings.Fsk.RxContinuous == false )
                {
                    SX1276.Settings.State = RF_IDLE;
                    TimerStart( &RxTimeoutSyncWord );
                }
                else
                {
                    // Continuous mode restart Rx chain
                    SX1276Write( REG_RXCONFIG, SX1276Read( REG_RXCONFIG ) | RF_RXCONFIG_RESTARTRXWITHOUTPLLLOCK );
                }
                TimerStop( &RxTimeoutTimer );

                if( ( RadioEvents != NULL ) && ( RadioEvents->RxDone != NULL ) )
                {
                    RadioEvents->RxDone( RxTxBuffer, SX1276.Settings.FskPacketHandler.Size, SX1276.Settings.FskPacketHandler.RssiValue, 0 );
                }
                SX1276.Settings.FskPacketHandler.PreambleDetected = false;
                SX1276.Settings.FskPacketHandler.SyncWordDetected = false;
                SX1276.Settings.FskPacketHandler.NbBytes = 0;
                SX1276.Settings.FskPacketHandler.Size = 0;
                break;
            case MODEM_LORA:
                {
                    int8_t snr = 0;

                    // Clear Irq
                    SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_RXDONE );

                    irqFlags = SX1276Read( REG_LR_IRQFLAGS );
                    if( ( irqFlags & RFLR_IRQFLAGS_PAYLOADCRCERROR_MASK ) == RFLR_IRQFLAGS_PAYLOADCRCERROR )
                    {
                        // Clear Irq
                        SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_PAYLOADCRCERROR );

                        if( SX1276.Settings.LoRa.RxContinuous == false )
                        {
                            SX1276.Settings.State = RF_IDLE;
                        }
                        TimerStop( &RxTimeoutTimer );

                        if( ( RadioEvents != NULL ) && ( RadioEvents->RxError != NULL ) )
                        {
                            RadioEvents->RxError( );
                        }
                        break;
                    }

                    SX1276.Settings.LoRaPacketHandler.SnrValue = SX1276Read( REG_LR_PKTSNRVALUE );
                    if( SX1276.Settings.LoRaPacketHandler.SnrValue & 0x80 ) // The SNR sign bit is 1
                    {
                        // Invert and divide by 4
                        snr = ( ( ~SX1276.Settings.LoRaPacketHandler.SnrValue + 1 ) & 0xFF ) >> 2;
                        snr = -snr;
                    }
                    else
                    {
                        // Divide by 4
                        snr = ( SX1276.Settings.LoRaPacketHandler.SnrValue & 0xFF ) >> 2;
                    }

                    int16_t rssi = SX1276Read( REG_LR_PKTRSSIVALUE );
                    if( snr < 0 )
                    {
                        if( SX1276.Settings.Channel > RF_MID_BAND_THRESH )
                        {
                            SX1276.Settings.LoRaPacketHandler.RssiValue = RSSI_OFFSET_HF + rssi + ( rssi >> 4 ) +
                                                                          snr;
                        }
                        else
                        {
                            SX1276.Settings.LoRaPacketHandler.RssiValue = RSSI_OFFSET_LF + rssi + ( rssi >> 4 ) +
                                                                          snr;
                        }
                    }
                    else
                    {   
                        if( SX1276.Settings.Channel > RF_MID_BAND_THRESH )
                        {
                            SX1276.Settings.LoRaPacketHandler.RssiValue = RSSI_OFFSET_HF + rssi + ( rssi >> 4 );
                        }
                        else
                        {
                            SX1276.Settings.LoRaPacketHandler.RssiValue = RSSI_OFFSET_LF + rssi + ( rssi >> 4 );
                        }
                    }

                    SX1276.Settings.LoRaPacketHandler.Size = SX1276Read( REG_LR_RXNBBYTES );
                    SX1276ReadFifo( RxTxBuffer, SX1276.Settings.LoRaPacketHandler.Size );
               
                    if( SX1276.Settings.LoRa.RxContinuous == false )
                    {
                        SX1276.Settings.State = RF_IDLE;
                    }
                    TimerStop( &RxTimeoutTimer );

                    if( ( RadioEvents != NULL ) && ( RadioEvents->RxDone != NULL ) )
                    {
                        RadioEvents->RxDone( RxTxBuffer, SX1276.Settings.LoRaPacketHandler.Size, SX1276.Settings.LoRaPacketHandler.RssiValue, SX1276.Settings.LoRaPacketHandler.SnrValue );
                    }
                }
                break;
            default:
                break;
            }
            break;
        case RF_TX_RUNNING:
            TimerStop( &TxTimeoutTimer );
            // TxDone interrupt
            switch( SX1276.Settings.Modem )
            {
            case MODEM_LORA:
                // Clear Irq
                SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE );
                // Intentional fall through
            case MODEM_FSK:
            default:
                SX1276.Settings.State = RF_IDLE;
                if( ( RadioEvents != NULL ) && ( RadioEvents->TxDone != NULL ) )
                {
                    RadioEvents->TxDone( );
                }
                break;
            }
            break;
        default:
            break;
    }
}

chenyuan

mmy9995 发表于 2020-10-26 14:55
我试了一下可以进入TXDone中断了，  TXDone是通过EXTI1_IRQHandler中断进去的，但第一次进去后，lora状态 ...

你看看你中断的这个引脚配置的是什么，如TX_DONE进入中断 rx_done进入中断....

1. /*!
   
2. * \brief 表示可用于收音机的中断屏蔽
   
3. *
   
4. * \remark 请注意，并非所有这些中断都适用于所有数据包类型
   
5. */
   
6. typedef enum
   
7. {
   
8.     IRQ_RADIO_NONE                          = 0x0000,
   
9.     IRQ_TX_DONE                             = 0x0001,
   
10.     IRQ_RX_DONE                             = 0x0002,
    
11.     IRQ_SYNCWORD_VALID                      = 0x0004,
    
12.     IRQ_SYNCWORD_ERROR                      = 0x0008,
    
13.     IRQ_HEADER_VALID                        = 0x0010,
    
14.     IRQ_HEADER_ERROR                        = 0x0020,
    
15.     IRQ_CRC_ERROR                           = 0x0040,
    
16.     IRQ_RANGING_SLAVE_RESPONSE_DONE         = 0x0080,
    
17.     IRQ_RANGING_SLAVE_REQUEST_DISCARDED     = 0x0100,
    
18.     IRQ_RANGING_MASTER_RESULT_VALID         = 0x0200,
    
19.     IRQ_RANGING_MASTER_RESULT_TIMEOUT       = 0x0400,
    
20.     IRQ_RANGING_SLAVE_REQUEST_VALID         = 0x0800,
    
21.     IRQ_CAD_DONE                            = 0x1000,
    
22.     IRQ_CAD_ACTIVITY_DETECTED               = 0x2000,
    
23.     IRQ_RX_TX_TIMEOUT                       = 0x4000,
    
24.     IRQ_PREAMBLE_DETECTED                   = 0x8000,
    
25.     IRQ_RADIO_ALL                           = 0xFFFF,
    
26. }RadioIrqMasks_t;

复制代码

这是SX1280的会产生中断的一些条件配置你这上面应该是库里面的吧，这有啥问题，也没看到你说的那个设置为SLEEP

还有为啥进入中断后要将他进入睡眠呢？

mmy9995

chenyuan 发表于 2020-10-26 16:35
你看看你中断的这个引脚配置的是什么，如TX_DONE进入中断 rx_done进入中断....
这是SX1280的会产生中断 ...

因为进入中断成功后，会进入发送成功的回调里，也就是TxDone()函数里，在这个函数里设置了休眠，等待下一次再有数据发送的时候再启动

函数里进入EXTI1_IRQHandler中断后是用SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE );语句清除中断标志，让他不再进入中断， 但是现在清除中断标志不起作用，会不停地进入EXTI1_IRQHandler中断，导致main()的主程序不能运行下去。。就卡在这个中断里了

我代码里相应的配置应该是这个：
/*!
* 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

mmy9995

chenyuan 发表于 2020-10-26 16:35
你看看你中断的这个引脚配置的是什么，如TX_DONE进入中断 rx_done进入中断....
这是SX1280的会产生中断 ...

上面发的中断函数太多了 我删减了一下  如下：第一次进这个中断会进到SX1276Write和 RadioEvents->TxDone( )里，后面不停地进中断后因为状态改了进不了这些函数里了  就在第一个switch的default那里循环跳进跳出

void EXTI1_IRQHandler( void )//SX1276中断线IDO0上升沿跳变进入
{
    volatile uint8_t irqFlags = 0;

    switch( SX1276.Settings.State )
    {               
        case RF_TX_RUNNING:
            TimerStop( &TxTimeoutTimer );
            // TxDone interrupt
            switch( SX1276.Settings.Modem )
            {
            case MODEM_LORA:
                // Clear Irq
                SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE );
                // Intentional fall through
            case MODEM_FSK:
            default:
                SX1276.Settings.State = RF_IDLE;
                if( ( RadioEvents != NULL ) && ( RadioEvents->TxDone != NULL ) )
                {
                    RadioEvents->TxDone( );
                }
                break;
            }
            break;
        default:
            break;
    }
}

chenyuan

mmy9995 发表于 2020-10-26 16:46
因为进入中断成功后，会进入发送成功的回调里，也就是TxDone()函数里，在这个函数里设置了休眠，等待下一 ...

等待下一次启动，RF启动应该也需要时间吧，另外TX发送数据也是需要时间的，我这个SX1280的我记的是我发送14字节的数据大概需要2ms的时间，会不会是你时间的一个问题，另外看你主题说服务端没有收到数据，我的理解是在发送端设置TX命令前，接收端要先设置RX，这样才能收到正确的数据，你先用例程实现简单的收发，再在上面进行二次开发吧

还有SX1276Write( REG_LR_IRQFLAGS, RFLR_IRQFLAGS_TXDONE );这个清除的只是RF的中断标志，并不是说清除了之后就不会进中断了，你要给中断引脚一个上升沿触发，他还是会进中断的，只是不会进中断中的   case TX..等等这些分支

xiaoshigua

你检查一下你的DIO0引脚是否插对

wenzy

mmy9995 发表于 2020-10-26 14:55
我试了一下可以进入TXDone中断了，  TXDone是通过EXTI1_IRQHandler中断进去的，但第一次进去后，lora状态 ...

mcu的外部中断标志不用清的吗？这么牛皮？