cubebite_rnd_SPSGRFC433 - Cubebite Publish

Users » jmhong » Code » cubebite_rnd_SPSGRFC433
JunMo Hong / Mbed 2 deprecated cubebite_rnd_SPSGRFC433
Cubebite Publish
Dependencies: mbed
Fork of HelloWorld_IDS01A4 by ST
main.cpp

Committer:: jmhong
Date:: 2018-02-13
Revision:: 14:1a6faeda6579
Parent:: 13:d802c6ed2e75
File content as of revision 14:1a6faeda6579:

/**
 ******************************************************************************
 * @file    main.cpp
 * @author  JMHong, Cubebite
 * @version V1.0.0
 * @date    June 19th, 2018
 * @brief   mbed test application for the STMicroelectronics X-NUCLEO-IDB01A4/5
 *          Spirit1 Module(SPSGRFC-433)
 ******************************************************************************
 * @attention
 *
 * <h2><center>&copy; COPYRIGHT(c) 2018 Cubebite</center></h2>
 *
 ******************************************************************************
 */



//*************************************************************************************
//Define : Test, Compile 
//*************************************************************************************
/* 180108 cubebite HJM : cubebite Testing define, 1개씩만 켜야 함. */
#define CUBEBITE_RF_SPEED_TEST_SEND_ON
//#define CUBEBITE_RF_SPEED_TEST_RECV_ON


/* 180109 cubebite HJM : cubebite Compile define, 1개씩만 켜야 함. */
//#define CUBEBITE_BOARD_F746ZG
#define CUBEBITE_BOARD_F401RE


#define CUBEBITE_RF_SETTING_VALUE_PRINT
//*************************************************************************************




//*************************************************************************************
//Define : Debug
//*************************************************************************************
/* 180108 cubebite HJM : SimpleSpirit1 Debug define */
#define NDEBUG
#define HEAVY_DEBUG
#define DEBUG_IRQ


/* 180108 cubebite HJM : cubebite Debug define */
//#define CUBEBITE_DEBUG
//*************************************************************************************




//*************************************************************************************
//Include
//*************************************************************************************
#ifndef __MAIN_H__
#define __MAIN_H__
#include "main.h"
#endif  //__MAIN_H__
//*************************************************************************************




enum RecvReturnValue
{
    CUBEBITE_RECV_OK = 0, CUBEBITE_RECV_ERROR_READ_NOTHING, CUBEBITE_RECV_ERROR_READ_NOT_MATCH
};

enum SendReturnValue
{
    CUBEBITE_SEND_OK = 0, CUBEBITE_SEND_ERROR, CUBEBITE_SEND_COLLISION, CUBEBITE_SEND_NOACK, CUBEBITE_SEND_ERROR_UNKNOWN
};





static void callback_func(int event);

static int ReadRcvdData(SimpleSpirit1& myspirit);
static int ReadRcvdData_ClockMeasure_AckEnd(SimpleSpirit1& myspirit);

static int SendData(SimpleSpirit1& myspirit);
static int SendData_ClockMeasure_AckStart(SimpleSpirit1& myspirit);





/*
    <RF 설정 값>
황무지     -> 전파
고속도로    -> 주파수
차선      -> 채널 
    
#define POWER_DBM                   11.6
#define CHANNEL_SPACE               100e3
#define FREQ_DEVIATION              20e3
#define BANDWIDTH                   100.5e3
#define MODULATION_SELECT           GFSK_BT1
#define DATARATE                    38400
#define XTAL_OFFSET_PPM             0
#define SYNC_WORD                   0x88888888
#define LENGTH_WIDTH                8   // betzw - NOTE: only 255 bytes for payload!!!
#define CRC_MODE                    PKT_CRC_MODE_16BITS_2
#define EN_WHITENING                S_DISABLE
#define INFINITE_TIMEOUT            0.0

#define BASE_FREQUENCY              433.0e6

*/


/**
 * @brief  main routine
 * @param  None
 * @retval int
 */
int main() 
{  
    /* 180108 cubebite HJM : function return value print */
    int iReturn = 0; 

    //*************************************************************************************
    //Global variable : Create an instance by board
    //*************************************************************************************
    /* 180108 cubebite HJM : orignal code, backup */          
    //static SimpleSpirit1 &myspirit = SimpleSpirit1::CreateInstance(D11, D12, D3, D9, D10, D2); /* (SPI_CLK) = (D13:PA5:resistorR7 --> D3:PB3:resistorR4)*/
    
#ifdef  CUBEBITE_BOARD_F401RE
    /* 180108 cubebite HJM : F401re borad, AnalogIn PIN Info, A0(PA_0) A1(PA_1) A2(PA_4) A3(PB_0) A4(PC_1) A5(PC_0) */
    /* RF Module 과 상관 관계 => A0(PA_0)[SPI GPIO 3] A1(PA_1)[CSN] A2(PA_4)[SPI1 GPIO 2] A3(PB_0)[SPI1 GPIO 1] A4(PC_1)[SPI1_GPIO 0] */
    /* 180108 cubebite HJM : F401re borad Init code */
    //static SimpleSpirit1 &myspirit = SimpleSpirit1::CreateInstance(PA_7, PA_6, PA_5, PC_7, PB_6, PA_10);    //F401re borad
    static SimpleSpirit1 &myspirit = SimpleSpirit1::CreateInstance(PA_7, PA_6, PA_5, PA_0, PB_6, PA_10);    //F401re borad, IRQ Testing, GPIO 3 -> IRQ
    //static SimpleSpirit1 &myspirit = SimpleSpirit1::CreateInstance_RSSI_negative_OneHundredTwenty(PA_7, PA_6, PA_5, PA_0, PB_6, PA_10);    //F401re borad, IRQ Testing, GPIO 3 -> IRQ
#endif
    
    
    
#ifdef  CUBEBITE_BOARD_F746ZG
    /* 180108 cubebite HJM : F746zg borad, AnalogIn PIN Info, A0(PA_3) A1(PC_0) A2(PC_3) A3(PF_3) A4(PF_5) A5(PF_10)  */
    /* RF Module 과 상관 관계 => A0(PA_3)[SPI GPIO 3] A1(PC_0)[CSN] A2(PC_3)[SPI1 GPIO 2] A3(PF_3)[SPI1 GPIO 1] A4(PF_5)[SPI1_GPIO 0] */
    /* 180108 cubebite HJM : F746zg borad Init code */
    //static SimpleSpirit1 &myspirit = SimpleSpirit1::CreateInstance(PB_5, PB_4, PB_3, PD_14, PD_5, PD_6);    //F746zg borad
    static SimpleSpirit1 &myspirit = SimpleSpirit1::CreateInstance(PB_5, PB_4, PB_3, PA_3, PD_5, PD_6);    //F746zg borad, IRQ Testing, GPIO 3 -> IRQ
    //static SimpleSpirit1 &myspirit2 = SimpleSpirit1::CreateInstance2(PB_5, PB_4, PB_3, PA_3, PD_5, PD_6);    //F746zg borad, IRQ Testing, GPIO 3 -> IRQ
#endif
    //*************************************************************************************
                   
    
    
    
    /* 180108 cubebite HJM : spirit module, init code  */
    printf("[CUBEBITE] Init ");
    /* LED off */
    TestLED = 0; 
    myspirit.attach_irq_callback(callback_func);  
    iReturn = myspirit.on();
    if ( 0 == iReturn )
    {
        printf("OK.\n");    
    }
    else
    {
        printf("ERROR.\n");
    }
    
#ifdef  CUBEBITE_DEBUG
    printf("[CUBEBITE] CUBEBITE_DEBUG ON. \n");
#endif  //CUBEBITE_DEBUG


#ifdef  CUBEBITE_RF_SETTING_VALUE_PRINT
    printf("Xtal offset in ppm              : [%d]\n", XTAL_OFFSET_PPM);
    printf("base frequency                  : [%d]\n", (uint32_t)BASE_FREQUENCY);
    printf("channel space                   : [%d]\n", (uint32_t)CHANNEL_SPACE);
    printf("channel number                  : [%d]\n", CHANNEL_NUMBER);    
    printf("modulation select               : [%d]\n", MODULATION_SELECT);
    printf("data rate                       : [%d]\n", DATARATE);
    printf("frequency deviation             : [%d]\n", (uint32_t)FREQ_DEVIATION);
    printf("channel filter bandwidth        : [%d]\n", (uint32_t)BANDWIDTH);
    #ifdef  CUBEBITE_RF_SPEED_TEST_SEND_ON    
//    printf("\nOutput Power(dBm)             : [%f]\n", POWER_DBM);
    printf("\nOutput Power(dBm)             : [%f]\n", (float)CUBEBITE_OUTPUT_POWER_DBM_TEST);
    
    #endif  //CUBEBITE_RF_SPEED_TEST_SEND_ON
    
    #ifdef  CUBEBITE_RF_SPEED_TEST_RECV_ON
    printf("\nRSSI threshold Setting value  : [%d]\n", (int)CCA_THRESHOLD);
    #endif  //CUBEBITE_RF_SPEED_TEST_RECV_ON
    
    wait(2);
#endif  //CUBEBITE_RF_SETTING_VALUE_PRINT
    
    while(1) 
    {
        /* low power in idle condition., waiting for an event */
        __WFE(); 
        
#ifdef  CUBEBITE_RF_SPEED_TEST_SEND_ON  
        iReturn = SendData(myspirit);
        if (CUBEBITE_SEND_OK == iReturn)
        {
            printf("[DEBUG] send OK.\n");
        }
        else if (CUBEBITE_SEND_ERROR == iReturn)
        {
            printf("[DEBUG] send ERROR.\n");
        }
        
        iReturn = (int)myspirit.get_last_sqi(); //HJM : LQI, 현재 주변 통신 품질 값, 높을수록 좋은 것.
        printf("get_last_sqi() return       : [%d]\n", iReturn);
#endif

#ifdef  CUBEBITE_RF_SPEED_TEST_RECV_ON
        if (bRxDoneFlag)
        {            
            iReturn = ReadRcvdData(myspirit);      
            if (CUBEBITE_RECV_OK == iReturn)
            {
                //통신 속도 체크시, 응답 send code.
                printf("[DEBUG] recv OK.\n");
                
                float fReturn1 = myspirit.get_last_rssi_dbm();
                printf("get_last_rssi_dbm() return       : [%f]\n", fReturn1);  //HJM : 위의 값과 같을 거라고 예상 됨. 나중에 테스트.    
                if (-50 < fReturn1)   //-80 < fReturn1
                {
                    TestLED3 = !TestLED3;     /* Toggle LED at the receiver */                    
                }
                else if (-50 >= fReturn1)
                {
//                    TestLED = !TestLED;     /* Toggle LED at the receiver */
                    TestLED2 = !TestLED2;     /* Toggle LED at the receiver */                    
//                    TestLED3 = !TestLED3;     /* Toggle LED at the receiver */
                }                
                else if (-70 >= fReturn1)    //-100 >= fReturn1
                {
                    TestLED = !TestLED;     /* Toggle LED at the receiver */                    
                }
            }
            bRxDoneFlag = 0;                        
        }
#endif        
        
    }
  /* unreachable */
  // myspirit.off();
  // return 0;
}





/**
 * @brief  callback_func
 * @param  callback event
 * @retval None.
 */
static void callback_func(int event) 
{
#ifdef  CUBEBITE_DEBUG
    printf("[CUBEBITE] callback_func(int event) \n");
#endif

  
    if(event == SimpleSpirit1::RX_DONE) 
    {         
        bRxDoneFlag = 1;
    }
    else if (event == SimpleSpirit1::TX_DONE) 
    {  
        bTxDoneFlag = 1;
    }
}



///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//recv






/**
 * @brief  ReadRcvdData
 * @param  None
 * @retval None
 */
static int ReadRcvdData(SimpleSpirit1& myspirit)
{  
#ifdef  CUBEBITE_DEBUG
    printf("[CUBEBITE] ReadRcvdData() 호출 됨. \n");  
#endif
 
    for(unsigned int flush_count = 0; flush_count < TEST_STR_LEN; flush_count++) uiRendBuf[flush_count] = 0 ;/* clear the read buffer */
    

    int ret = myspirit.read(uiRendBuf, sizeof(uiRendBuf));    
    if (ret == 0) 
    {
        printf("[CUBEBITE] Read() Error : Nothing to read\n");
        return CUBEBITE_RECV_ERROR_READ_NOTHING;
    }
    printf("ReadRcvdData() 1");
    
    printf("[DEBUG]recv -> %s ", uiRendBuf);

    ret = strcmp((const char *)uiRendBuf, (const char *)uiSendBuf);
    printf(" 3");
    if (0 == ret)
    {        
//        set_ack_bSendDataFlag(); //180118 HJM : 다시 바로 보내는 걸로 수정
//        printf("read, send buf collect!!\n");
//        TestLED = !TestLED;     /* Toggle LED at the receiver */
        printf(" 4");
//        bIsAckSended = true;
//        printf("[DEBUG]recv -> %s\n", uiRendBuf);
#ifdef  CUBEBITE_DEBUG
        printf("[DEBUG]recv -> %s\n", uiRendBuf);
#endif

        //746zg 보드        
//        wait(1.0);
/*
        int iRet = myspirit.send(uiSendAckBuf, sizetCurrAckBufLen);
        if (iRet == RADIO_TX_OK)
        {
        #ifdef  CUBEBITE_DEBUG
            printf("ACK : [RADIO_TX_OK]\n");
        #endif
        }
        else if (iRet == RADIO_TX_ERR)
        {
        #ifdef  CUBEBITE_DEBUG            
            printf("ACK : [RADIO_TX_ERR]\n");
        #endif
        }
        else if (iRet == RADIO_TX_COLLISION)
        {
        #ifdef  CUBEBITE_DEBUG            
            printf("ACK : [RADIO_TX_COLLISION]\n");
        #endif            
        }
        else if (iRet == RADIO_TX_NOACK)
        {
        #ifdef  CUBEBITE_DEBUG            
            printf("ACK : [RADIO_TX_NOACK]\n");
        #endif
        }                          
        */
        
        return CUBEBITE_RECV_OK;
        printf(" 5 ok\n");
    }


#ifdef  CUBEBITE_DEBUG
    printf("[CUBEBITE] ReadRcvdData() 호출 끝. \n");  
#endif

    return CUBEBITE_RECV_ERROR_READ_NOT_MATCH;
    printf(" 6 error\n");
}



static int ReadRcvdData_ClockMeasure_AckEnd(SimpleSpirit1& myspirit)
{  
#ifdef  CUBEBITE_DEBUG
    printf("[CUBEBITE] ReadRcvdData() 호출 됨. \n");  
#endif
 
    for(unsigned int flush_count = 0; flush_count < TEST_STR_LEN; flush_count++) uiRendBuf[flush_count] = 0 ;/* clear the read buffer */

    int ret = myspirit.read(uiRendBuf, sizeof(uiRendBuf));
    if (ret == 0) 
    {
        printf("[CUBEBITE] Read() Error : Nothing to read\n");
        return CUBEBITE_RECV_ERROR_READ_NOTHING;
    }
#ifdef  CUBEBITE_RF_SPEED_TEST_RECV_ON
    ret = strcmp((const char *)uiRendBuf, (const char *)uiSendBuf);
    if (0 == ret)
    {        
//        set_ack_bSendDataFlag(); //180118 HJM : 다시 바로 보내는 걸로 수정
//        printf("read, send buf collect!!\n");
        TestLED = !TestLED;     /* Toggle LED at the receiver */
//        bIsAckSended = true;
#ifdef  CUBEBITE_DEBUG
        printf("[DEBUG]recv -> %s\n", uiRendBuf);
#endif

        //746zg 보드        
//        wait(1.0);
/*
        int iRet = myspirit.send(uiSendAckBuf, sizetCurrAckBufLen);
        if (iRet == RADIO_TX_OK)
        {
        #ifdef  CUBEBITE_DEBUG
            printf("ACK : [RADIO_TX_OK]\n");
        #endif
        }
        else if (iRet == RADIO_TX_ERR)
        {
        #ifdef  CUBEBITE_DEBUG            
            printf("ACK : [RADIO_TX_ERR]\n");
        #endif
        }
        else if (iRet == RADIO_TX_COLLISION)
        {
        #ifdef  CUBEBITE_DEBUG            
            printf("ACK : [RADIO_TX_COLLISION]\n");
        #endif            
        }
        else if (iRet == RADIO_TX_NOACK)
        {
        #ifdef  CUBEBITE_DEBUG            
            printf("ACK : [RADIO_TX_NOACK]\n");
        #endif
        }                          
        */
        
        return CUBEBITE_RECV_OK;
    }
#endif

#ifdef  CUBEBITE_RF_SPEED_TEST_SEND_ON 
    //401re 보드
    if (true == bIsSendFirstClockFunctionStarted)
    {
        clocktimeRFSpeedTestEnd = clock();
    } 
    //printf("[DEBUG]recv -> %s\n", uiRendBuf);
#endif    


#ifdef  CUBEBITE_DEBUG
    printf("[CUBEBITE] ReadRcvdData() 호출 끝. \n");  
#endif

    return CUBEBITE_RECV_ERROR_READ_NOT_MATCH;
}






///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//send






/**
 * @brief  SendData
 * @param  None
 * @retval None
 */
static int SendData(SimpleSpirit1& myspirit)
{
#ifdef  CUBEBITE_DEBUG
    printf("[CUBEBITE] SendData() 호출 됨.\n");
#endif
    while(myspirit.is_receiving()); /* wait for ongoing RX ends 180110 HJM 아마 이 전에 보내던 거 마저 다 보내려고 하는 거 같다. */

    size_t curr_len = strlen((const char*)uiSendBuf) + 1;
    int iRet = 0;

    printf("SendData() uiSendBuf -> [%s]\n", uiSendBuf);
    iRet = myspirit.send(uiSendBuf, curr_len);
    if (iRet == RADIO_TX_OK)
    {
#ifdef  CUBEBITE_DEBUG        
        printf("[RADIO_TX_OK]\n");
#endif
        return CUBEBITE_SEND_OK;
    }
    else if (iRet == RADIO_TX_ERR)
    {
#ifdef  CUBEBITE_DEBUG
        printf("[RADIO_TX_ERR]\n");
#endif
        return CUBEBITE_SEND_ERROR;
    }
    else if (iRet == RADIO_TX_COLLISION)
    {
#ifdef  CUBEBITE_DEBUG        
        printf("[RADIO_TX_COLLISION]\n");
#endif        
        return CUBEBITE_SEND_COLLISION;
    }
    else if (iRet == RADIO_TX_NOACK)
    {
#ifdef  CUBEBITE_DEBUG                
        printf("[RADIO_TX_NOACK]\n");
#endif  
        return CUBEBITE_SEND_NOACK;              
    }
    
#ifdef  CUBEBITE_DEBUG
    printf("[CUBEBITE] SendData() 호출 끝.\n");
#endif

    return CUBEBITE_SEND_ERROR_UNKNOWN;
}


static int SendData_ClockMeasure_AckStart(SimpleSpirit1& myspirit)
{
#ifdef  CUBEBITE_DEBUG
    printf("[CUBEBITE] SendData() 호출 됨.\n");
#endif
    while(myspirit.is_receiving()); /* wait for ongoing RX ends 180110 HJM 아마 이 전에 보내던 거 마저 다 보내려고 하는 거 같다. */

    size_t curr_len = strlen((const char*)uiSendBuf) + 1;
    int iRet = 0;

    iRet = myspirit.send(uiSendBuf, curr_len);
    if (iRet == RADIO_TX_OK)
    {
#ifdef  CUBEBITE_DEBUG        
        printf("[RADIO_TX_OK]\n");
#endif

#ifdef  CUBEBITE_RF_SPEED_TEST_SEND_ON     
        if (false == bIsSendFirstClockFunctionStarted)
        {
            clocktimeRFSpeedTestStart = clock();    
            bIsSendFirstClockFunctionStarted = true;            
        }
#endif

        return CUBEBITE_SEND_OK;
    }
    else if (iRet == RADIO_TX_ERR)
    {
#ifdef  CUBEBITE_DEBUG
        printf("[RADIO_TX_ERR]\n");
#endif
        return CUBEBITE_SEND_ERROR;
    }
    else if (iRet == RADIO_TX_COLLISION)
    {
#ifdef  CUBEBITE_DEBUG        
        printf("[RADIO_TX_COLLISION]\n");
#endif        
        return CUBEBITE_SEND_COLLISION;
    }
    else if (iRet == RADIO_TX_NOACK)
    {
#ifdef  CUBEBITE_DEBUG                
        printf("[RADIO_TX_NOACK]\n");
#endif  
        return CUBEBITE_SEND_NOACK;              
    }
    
#ifdef  CUBEBITE_DEBUG
    printf("[CUBEBITE] SendData() 호출 끝.\n");
#endif

    return CUBEBITE_SEND_ERROR_UNKNOWN;
}
Repository toolbox

Export to desktop IDE
Build repository
Repository details

Type:	Program
Mbed OS support:	Mbed 2 deprecated
Created:	09 Jan 2018
Imports:	3
Forks:	0
Commits:	15
Dependents:	0
Dependencies:	1
Followers:	1
main.cpp

File content as of revision 14:1a6faeda6579:

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning
