This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

  • TI Thinks Resolved

CCS/LAUNCHXL-CC2650: Problem in sending/receiving packets

Prodigy 220 points

Replies: 8

Views: 158

Part Number: LAUNCHXL-CC2650

Tool/software: Code Composer Studio

I have two LAUNCHXL-CC2650 one of them keep sending packets and the other one should receive the packets and resend it but for some kind of reason I'm not able to receive all the packets or some of them are lost and I really don't know how to solve this problem I tried lots of stuff but no luck at all the result is always the same so the two code are:

sending program :

_______________________________________________________________________________________________________________________________

#include <stdlib.h>
#include <xdc/std.h>
#include <xdc/runtime/System.h>

#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>

/* Drivers */
#include <ti/drivers/rf/RF.h>
#include <ti/drivers/PIN.h>

/* Board Header files */
#include "Board.h"

#include "smartrf_settings/smartrf_settings.h"
#include <stdio.h>
#include <stdlib.h>
// XDCtools Header files
#include <xdc/std.h>
#include <xdc/runtime/System.h>
#include <xdc/cfg/global.h>

// BIOS Header files
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>


#include <ti/drivers/UART.h>


#include "Board.h"

#include <stdint.h>
#include "hal_types.h"
#include "comdef.h"
#include <hal_flash.h>
#include <osal.h>
#include <osal_snv.h>
#include <driverlib/vims.h>
#include <driverlib/aon_batmon.h>


#include <hal_defs.h>
#include <hal_assert.h>

#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>
#include <ti/drivers/rf/RF.h>
#include <ti/drivers/PIN.h>
#include <driverlib/rf_prop_mailbox.h>
#include "RFQueue.h"
#include "smartrf_settings/smartrf_settings.h"

/* Pin driver handle */
static PIN_Handle ledPinHandle;
static PIN_State ledPinState;

/*
 * Application LED pin configuration table:
 *   - All LEDs board LEDs are off.
 */
PIN_Config pinTable[] =
{
    Board_LED1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
    PIN_TERMINATE
};


/***** Defines *****/
#define TX_TASK_STACK_SIZE 1024
#define TX_TASK_PRIORITY   2

/* Packet TX Configuration */
#define PAYLOAD_LENGTH      30
#define PACKET_INTERVAL     (uint32_t)(4000000*0.5f) /* Set packet interval to 500ms */



/***** Prototypes *****/
static void txTaskFunction(UArg arg0, UArg arg1);



/***** Variable declarations *****/
static Task_Params txTaskParams;
Task_Struct txTask;    /* not static so you can see in ROV */
static uint8_t txTaskStack[TX_TASK_STACK_SIZE];

static RF_Object rfObject;
static RF_Handle rfHandle;

uint32_t time;
static uint8_t packet[PAYLOAD_LENGTH];
static PIN_Handle pinHandle;
uint8  MemBuffWrite1[30] ; // a buffer to write on the NV area of the memory
uint8  MemBuffWrite2[30] ; // a buffer to write on the NV area of the memory
uint8  MemBuffWrite3[30] ; // a buffer to write on the NV area of the memory
uint8  MemBuffWrite4[30] ; // a buffer to write on the NV area of the memory
uint8  MemBuffWrite5[30] ; // a buffer to write on the NV area of the memory







uint8  MemBuffRead[30] ;  // a buffer to read from the NV area of the memory



int i; // a counter for the receiving loop
int j; // a counter for the sending loop
int loopNumber=0;
uint8 status = SUCCESS; //the status of writing/reading

/***** Function definitions *****/
void TxTask_init(PIN_Handle inPinHandle)
{
    pinHandle = inPinHandle;

    Task_Params_init(&txTaskParams);
    txTaskParams.stackSize = TX_TASK_STACK_SIZE;
    txTaskParams.priority = TX_TASK_PRIORITY;
    txTaskParams.stack = &txTaskStack;
    txTaskParams.arg0 = (UInt)1000000;


    Task_construct(&txTask, txTaskFunction, &txTaskParams, NULL);

}

static void txTaskFunction(UArg arg0, UArg arg1)
{
    osal_snv_init();  //initializing osal_snv (Initialize the operating system of osal functions)

    uint32_t time;
    RF_Params rfParams;
    RF_Params_init(&rfParams);

    RF_cmdPropTx.pktLen = PAYLOAD_LENGTH;
    RF_cmdPropTx.pPkt = packet;
    RF_cmdPropTx.startTrigger.triggerType = TRIG_ABSTIME;
    RF_cmdPropTx.startTrigger.pastTrig = 1;
    RF_cmdPropTx.startTime = 0;

    uint8 AuxVar[30];   // Auxiliary char variable
    uint8 FlashID= 0x81;   // the ID for NV is form 0x80 to 0x8F
//    uint32_t standbyDurationUs = (1000000*10);  //sleep duration is 5 second * 2

    memset (AuxVar, '\0', sizeof(AuxVar)); //set all the bits in the AuxVar
    uint8  MemBuffWrite1[30] ="Bassel Packet number 1\r\n"; // a buffer to write on the NV area of the memory
    uint8  MemBuffWrite2[30]="Bassel Packet number 2\r\n" ; // a buffer to write on the NV area of the memory
    uint8  MemBuffWrite3[30]="Bassel Packet number 3\r\n" ; // a buffer to write on the NV area of the memory
    uint8  MemBuffWrite4[30]="Bassel Packet number 4\r\n" ; // a buffer to write on the NV area of the memory
    uint8  MemBuffWrite5[30]="Bassel Packet number 5\r\n" ; // a buffer to write on the NV area of the memory




status =  osal_snv_write(0x81, 30, MemBuffWrite1 ); // write the received data on a NV valid ID
status =  osal_snv_write(0x82, 30, MemBuffWrite2 ); // write the received data on a NV valid ID
status =  osal_snv_write(0x83, 30, MemBuffWrite3 ); // write the received data on a NV valid ID
status =  osal_snv_write(0x84, 30, MemBuffWrite4 ); // write the received data on a NV valid ID
status =  osal_snv_write(0x85, 30, MemBuffWrite5 ); // write the received data on a NV valid ID

uint32_t standbyDurationUs = (1000000*10);  //sleep duration is 5 second * 2



    /* Request access to the radio */
    rfHandle = RF_open(&rfObject, &RF_prop, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup, &rfParams);

    /* Set the frequency */
    RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);

    /* Get current time */
    time = RF_getCurrentTime();
    while(1)
    {

        for (i=1;i<6;i++) //loop to receive the data 5 times
        {

            Task_sleep(standbyDurationUs / Clock_tickPeriod); // put the system to sleep



            status = osal_snv_read( FlashID, 30, MemBuffRead); // read the received data from the same NV valid ID


            memcpy (AuxVar,MemBuffRead, sizeof(MemBuffRead)); //copy the value of the received data to the AuxVar to be shown
            memcpy (packet,AuxVar, sizeof(AuxVar)); //copy the value of the received data to the AuxVar to be shown

            time += PACKET_INTERVAL;
            RF_cmdPropTx.startTime = time;

            /* Send packet */
            RF_EventMask result = RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTx, RF_PriorityNormal, NULL, 0);
            if (!(result & RF_EventLastCmdDone))
            {
                /* Error */
                while(1);
            }

            PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));

               System_printf("the function is working and the saved value is %s\n",AuxVar);
                   System_flush();

                          FlashID++; //change the NV valid ID to use another one
//                          RFQueue_nextEntry(); //wait for the next data and change the value of the received data

        }//end the receiving loop

        if (FlashID=0x85){ //when reaching packet number 5
            FlashID=0x81; //return to the first used NV valid ID
        /* Set absolute TX time to utilize automatic power management */
        }
    }
}

/*
 *  ======== main ========
 */
int main(void)
{
    /* Call board init functions. */
    Board_initGeneral();

    /* Open LED pins */
    ledPinHandle = PIN_open(&ledPinState, pinTable);
    if(!ledPinHandle)
    {
        System_abort("Error initializing board LED pins\n");
    }

    /* Initialize task */
    TxTask_init(ledPinHandle);

    /* Start BIOS */
    BIOS_start();

    return (0);
}

_________________________________________________________________________________________________________________________-

receiving program :

#include <stdio.h>
#include <stdlib.h>
// XDCtools Header files
#include <xdc/std.h>
#include <xdc/runtime/System.h>
#include <xdc/cfg/global.h>

// BIOS Header files
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>


#include <ti/drivers/UART.h>


#include "Board.h"

#include <stdint.h>
#include "hal_types.h"
#include "comdef.h"
#include <hal_flash.h>
#include <osal.h>
#include <osal_snv.h>
#include <driverlib/vims.h>
#include <driverlib/aon_batmon.h>


#include <hal_defs.h>
#include <hal_assert.h>


#include <ti/drivers/rf/RF.h>
#include <ti/drivers/PIN.h>
#include <driverlib/rf_prop_mailbox.h>
#include "RFQueue.h"
#include "smartrf_settings/smartrf_settings.h"




#define TS     1024 //Task size

Task_Struct task0Struct;
static uint8_t task0Stack[TS];
#define TASK_PRIORITY   2
#define PACKET_INTERVAL     (uint32_t)(4000000*0.5f) /* Set packet interval to 500ms */ // The sending Time


#define DATA_ENTRY_HEADER_SIZE 8  /* Constant header size of a Generic Data Entry */
#define MAX_LENGTH             30 /* Max length byte the radio will accept */
#define NUM_DATA_ENTRIES       2  /* NOTE: Only two data entries supported at the moment */
#define NUM_APPENDED_BYTES     2  /* The Data Entries data field will contain:
                                   * 1 Header byte (RF_cmdPropRx.rxConf.bIncludeHdr = 0x1)
                                   * Max 30 payload bytes
                                   * 1 status byte (RF_cmdPropRx.rxConf.bAppendStatus = 0x1) */

static void ReciveThePacket(RF_Handle h, RF_CmdHandle ch, RF_EventMask e); //a function to receive a packet
//and save it in a buffer to be written on the NV area
static RF_Object rfObject;
static RF_Handle rfHandle;

/* Buffer which contains all Data Entries for receiving data.
 * Pragmas are needed to make sure this buffer is 4 byte aligned (requirement from the RF Core) */
#if defined(__TI_COMPILER_VERSION__)
    #pragma DATA_ALIGN (rxDataEntryBuffer, 4);
        static uint8_t rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                                 MAX_LENGTH,
                                                                 NUM_APPENDED_BYTES)];
#elif defined(__IAR_SYSTEMS_ICC__)
    #pragma data_alignment = 4
        static uint8_t rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                                 MAX_LENGTH,
                                                                 NUM_APPENDED_BYTES)];
#elif defined(__GNUC__)
        static uint8_t rxDataEntryBuffer [RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
            MAX_LENGTH, NUM_APPENDED_BYTES)] __attribute__ ((aligned (4)));
#else
    #error This compiler is not supported.
#endif



/* Receive dataQueue for RF Core to fill in data */

static dataQueue_t dataQueue;
static rfc_dataEntryGeneral_t* currentDataEntry; //the current received data
static uint8_t packetLength;  //the length of the packet
static uint8_t* packetDataPointer; // a pointer to save the received data

uint32_t time; //the actual time to send the data


uint8  MemBuffWrite[30] ; // a buffer to write on the NV area of the memory
uint8  MemBuffRead[30] ;  // a buffer to read from the NV area of the memory



int i; // a counter for the receiving loop
int j; // a counter for the sending loop
int loopNumber=0;
uint8 status = SUCCESS; //the status of writing/reading

void ReciveThePacket(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{




  if (e & RF_EventRxEntryDone) //check if the receiver has finished its job and is again available
    {

//      RFQueue_nextEntry(); //wait for the next data and change the value of the received data

        /* Get current unhandled data entry */
        currentDataEntry = RFQueue_getDataEntry(); // get the current received packet

        /* Handle the packet data, located at &currentDataEntry->data:
         * - Length is the first byte with the current configuration
         * - Data starts from the second byte */
       packetLength      = *(uint8_t*)(&currentDataEntry->data);
       packetDataPointer = (uint8_t*)(&currentDataEntry->data + 1);




        memcpy(MemBuffWrite, packetDataPointer, (packetLength + 1)); //copy the packet with its actual length+1 to the writing buffer

     }
}

Void Taskfunction (UArg arg0, UArg arg1) // task function which well do all the job
{

    osal_snv_init();  //initializing osal_snv (Initialize the operating system of osal functions)


    RF_Params rfParams;
    RF_Params_init(&rfParams); //Function to initialize the RF_Params struct to its defaults





       //UART parameters with speed of 115200

            UART_Handle uart;
            UART_Params uartParams;
            // Create a UART with data processing off.
            UART_Params_init(&uartParams);  //Function to initialize the UART_Params struct to its defaults
            uartParams.writeDataMode = UART_DATA_BINARY;
            uartParams.readDataMode = UART_DATA_BINARY;
            uartParams.readReturnMode = UART_RETURN_FULL;
            uartParams.readEcho = UART_ECHO_OFF;
            uartParams.baudRate = 115200;
            uart = UART_open(Board_UART0, &uartParams); //Function to initialize a given UART peripheral


           uint8 AuxVar[30];   // Auxiliary char variable
           uint8 FlashID= 0x81;   // the ID for NV is form 0x80 to 0x8F
           uint32_t standbyDurationUs = (1000000*10);  //sleep duration is 5 second * 2

           memset (AuxVar, '\0', sizeof(AuxVar)); //set all the bits in the AuxVar


            /* Modify CMD_PROP_RX command for application needs */
             RF_cmdPropRx.pQueue = &dataQueue;           /* Set the Data Entity queue for received data */
             RF_cmdPropRx.rxConf.bAutoFlushIgnored = 1;  /* Discard ignored packets from Rx queue */
             RF_cmdPropRx.rxConf.bAutoFlushCrcErr = 1;   /* Discard packets with CRC error from Rx queue */
             RF_cmdPropRx.maxPktLen = MAX_LENGTH;        /* Implement packet length filtering to avoid PROP_ERROR_RXBUF */
             RF_cmdPropRx.pktConf.bRepeatOk = 1;
             RF_cmdPropRx.pktConf.bRepeatNok = 1;


             // CMD_PROP_TX
             RF_cmdPropTx.pktLen = sizeof(MemBuffRead);
             RF_cmdPropTx.pPkt = MemBuffRead;
             RF_cmdPropTx.startTrigger.triggerType = TRIG_ABSTIME;
             RF_cmdPropTx.startTrigger.pastTrig = 1;
             RF_cmdPropTx.startTime = 0;





             /* Request access to the radio */
          rfHandle = RF_open(&rfObject, &RF_prop, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup, &rfParams);


while(1) //Infinite loop

{
    /* Set the frequency to 2440 */

    RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);

    if( RFQueue_defineQueue(&dataQueue,
                                      rxDataEntryBuffer,
                                      sizeof(rxDataEntryBuffer),
                                      NUM_DATA_ENTRIES,
                                      MAX_LENGTH + NUM_APPENDED_BYTES))
             {
                  /* Failed to allocate space for all data entries */
                 while(1); //don't do anything if this happen
             }
time = RF_getCurrentTime(); //get the actual time for this infinite loop in order to send the packet
loopNumber++; //increase the loop number
System_printf("loop number: %d\n",loopNumber);
System_flush();

for (i=1;i<6;i++) //loop to receive the data 5 times
{


    /* Enter RX mode and wait for a new packet to come  */
        RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropRx, RF_PriorityNormal, &ReciveThePacket, IRQ_RX_ENTRY_DONE); //receive the packet

        RFQueue_nextEntry(); //wait for the next data and change the value of the received data




    status =  osal_snv_write(FlashID, 30, MemBuffWrite ); // write the received data on a NV valid ID


    status = osal_snv_read( FlashID, 30, MemBuffRead); // read the received data from the same NV valid ID


    memcpy (AuxVar,MemBuffRead, sizeof(MemBuffRead)); //copy the value of the received data to the AuxVar to be shown


    UART_write(uart, AuxVar, sizeof(AuxVar)); //show the received data via UART

       System_printf("the function is working and the saved value is %s\n",AuxVar);
           System_flush();
           System_printf("The packet is successfully received and it its number: %d",i);
                  System_flush();
                  System_printf("   The Address of the packet in SNV is  %x",FlashID);
                  System_flush();
                  System_printf("   The packet is %s%x",AuxVar,AuxVar);
                  System_flush();

                 FlashID++; //change the NV valid ID to use another one

}//end the receiving loop

if (FlashID=0x85){ //when reaching packet number 5
    FlashID=0x81; //return to the first used NV valid ID

    /* Change the frequency to 2420 to send the received packets*/

    RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs1, RF_PriorityNormal, NULL, 0);



        for (j=1;j<6;j++) //loop to send the saved packets
        {
          status = osal_snv_read( FlashID, 30, MemBuffRead); //read the saved data from the specified NV valid ID

          /* Set absolute TX time to utilize automatic power management */
          time += PACKET_INTERVAL; //increase the time with the time of sending (0.5 second in this case)

          RF_cmdPropTx.startTime = time; // put the time to send the packet

        /* Send packet */
        RF_EventMask result = RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTx, RF_PriorityNormal, NULL, 0);
        if (!(result & RF_EventLastCmdDone)) // in case an error while sending happens
       {
            /* Error */
            while(1); // stay here and do nothing
        }

                System_printf("The packet is successfully transmitted and it its number: %d",j);

           System_flush();
              System_printf("   The Address of the packet in SNV is  %x",FlashID);
             System_flush();

              System_printf("   The packet is %s%x",MemBuffRead,MemBuffRead);
              System_flush();

              FlashID++; //change the the specified NV valid ID to the next one to send the next saved data
        }
        FlashID=0x81; //return to the first used NV valid ID
        Task_sleep(standbyDurationUs / Clock_tickPeriod); // put the system to sleep

    } //end sending loop

}//end the infinite loop

}




 // ======== main ========

int main(void)
{

 // Call board init functions
 Board_initGeneral();
 Board_initUART();




 // Construct BIOS objects
    Task_Params taskParams ;
    Task_Params_init(&taskParams);
    taskParams.stackSize = TS;
    taskParams.stack = &task0Stack;
    taskParams.priority = TASK_PRIORITY;
    taskParams.arg0 = (UInt)1000000;



    Task_construct(&task0Struct, (Task_FuncPtr)Taskfunction, &taskParams, NULL); //call the Task


    BIOS_start();

    return (0);
}

_______________________________________________________________________________________________________________________________

I always get something like

loop number: 1
the function is working and the saved value is Bassel Packet number 1

The packet is successfully received and it its number: 1   The Address of the packet in SNV is  81   The packet is Bassel Packet number 1
200005b8the function is working and the saved value is Bassel Packet number 2

The packet is successfully received and it its number: 2   The Address of the packet in SNV is  82   The packet is Bassel Packet number 2
200005b8the function is working and the saved value is Bassel Packet number 4

The packet is successfully received and it its number: 3   The Address of the packet in SNV is  83   The packet is Bassel Packet number 4
200005b8the function is working and the saved value is Bassel Packet number 5

The packet is successfully received and it its number: 4   The Address of the packet in SNV is  84   The packet is Bassel Packet number 5
200005b8the function is working and the saved value is Bassel Packet number 1

The packet is successfully received and it its number: 5   The Address of the packet in SNV is  85   The packet is Bassel Packet number 1

loop number: 2
the function is working and the saved value is Bassel Packet number 3

The packet is successfully received and it its number: 1   The Address of the packet in SNV is  81   The packet is Bassel Packet number 3
200005b8the function is working and the saved value is Bassel Packet number 4

The packet is successfully received and it its number: 2   The Address of the packet in SNV is  82   The packet is Bassel Packet number 4
200005b8the function is working and the saved value is Bassel Packet number 5

The packet is successfully received and it its number: 3   The Address of the packet in SNV is  83   The packet is Bassel Packet number 5
200005b8the function is working and the saved value is Bassel Packet number 1

The packet is successfully received and it its number: 4   The Address of the packet in SNV is  84   The packet is Bassel Packet number 1
200005b8the function is working and the saved value is Bassel Packet number 2

The packet is successfully received and it its number: 5   The Address of the packet in SNV is  85   The packet is Bassel Packet number 2

I've tried to make the sending time much longer , change the number of the packets and tried as well to put some kind of delay (using delay cycle)

I've tried so many thing but I don't know where is the problem


I'm using SDK ble_sdk_2_02_02_25

CCS  Version: 8.3.0.00009

Thank you so much for any help

Best Regards

Bassel

  • Hi Bassel,

    Have you tried to listen for the packets using SmartRF Studio to see if you are actually sending them out? It could be a good start to try to figure out which side of the equation is failing.

    Best regards,

    M-W

  • In reply to M-W:

    Hello M-W,

    Thanks so much for replaying I have tried that and it seems that the program should have sent 10 packets but I received just 3 of them so I don't know if that has anything to do with the packets themselves (because they are string -type packets and by using SmartRF Studio and they are unreadable :���m��x[�5!����p���V��w`��i�QmX�W��&��'A<nxK�\ ) or this is the real issue and I tried to modify the sending time as well but that hasn't helped me at all

    Thank you so much for any help or tip

    Best regards

    Bassel

  • In reply to Bassel Barakat:

    Hi Basel,

    It does not matter what the payload is, SmartRF studio should be able to receive them assuming everything is in order. Have you tried using smart of studio to control both device and test your RF settings doing TX/RX test?

    Best regards,

    M-W

  • In reply to M-W:

    Hello M-W,

    Thank you so much for replying I have tried what you have suggested and I discovered that the problem is in the receiving program and there are for some kind of reason lost packets always (error in receiving some packets) so I tried to send the same packet more than 3 times in order to receive all the packets without any lost packet but of course that consume lots of power which I can't afford and I tried to do everything I know to come up with a solution but I couldn't find anyway to solve the problem

    Thank you so much for any help or tip

    Best regards

    Bassel

  • In reply to Bassel Barakat:

    Hi Bassel,

    Have you tried out running the default rfPacketTx/Rx examples and see if you see the same packet loss there using your RF settings files?
    It sounds to me you might have a setting issue as SmartRF studio are able to receive it, testing out the default examples and comparing them with what you are doing might help you find out if there is any difference. Re-exporting settings if possible might also me an idea.

    Best regards,

    M-W

  • In reply to M-W:

    Hallo M-W,

    Thanks so much for replying .I have tried TX/RX example and they work just fine and the main different is that in RX there is a Task and  a RxTask_init and the RFQueue_nextEntry(); is in the callback whereas in mine there is just a task and the RFQueue_nextEntry(); in the Task (not in the callback because the program stops working otherwise ) and I don#t know if that has anything to do with my problem or not but the problem is here somehow

    Thank you again so much for any help or tip

    Best regards

    Bassel

  • In reply to Bassel Barakat:

    Hi Bassel,

    Are you using multiple RF Queues entries or are you only using one?

    If this is the only difference between your applications I would try to re-mimic the working code and then figure out why it is crashing in your case when you do it in the callback.

    Best regards,

    M-W

  • In reply to M-W:

    Hello M-W,

    I'm so sorry for this late reply but I have an exam so I was really busy preparing for it and thank you so much your reply.

    I have just one RF Queues entries and the system doesn't crash but rather stop at RF Queues entries if I use it in the callback and never go forward

    Thank you again so much for any help or tip

    Best regards

    Bassel

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.