CC2745P10-Q1: [BLE 6.0 CS DKC]*SDK version:9.11.00.18. Why can the handover function only be successfully executed immediately after the binding is successful, and cannot be successfully run at any other time?

Hello James, 

1. Are you using multiple antennas on the CC2745R10-Q1 nodes?

2. Can you provide me the sysconfig file for each CC2745R10-Q1 node?

3. How long does it take for the data to be transferred from the serving node to the candidate node over the CAN bus? 

4. Do you observe the connection between the serving node and the phone ending after a few seconds? Or is the connection stable after connecting? 

I will do some testing on my end to see if I can observe this concern. 

Thanks,
Isaac

Hi, Isaac:

Thank you for your reply.

1.Yes, I use the dual-antenna setup. Under the dual-antenna setup, python 's handover code will also work.

2.The following is my sysconfig file

candidate_node：

ble.basicBLE                                        = true;
ble.numOfAdvSets                                    = 1;
ble.numOfDefAdvSets                                 = 1;
ble.deviceRole                                      = "PERIPHERAL_CFG+CENTRAL_CFG";
ble.maxPDUSize                                      = 255;
ble.disableDisplayModule                            = true;
ble.appExternalControlMode                          = true;
ble.L2CAPCOC                                        = true;
ble.maxRLSize                                       = 6;
ble.maxBonds                                        = 6;
ble.dupFilter                                       = "SCAN_FLT_DUP_DISABLE";
ble.connectionMonitorRole                           = true;
ble.channelSounding                                 = true;
ble.csMeasureDistance                               = true;
ble.numAntennas                                     = 2;
ble.antennasMuxValues                               = 0xC6;
ble.addressMode                                     = "ADDRMODE_PUBLIC";
ble.maxConnNum                                      = 2;
ble.centraSupTimeout                                = 2000;
ble.scanInt                                         = 1100;
ble.scanWin                                         = 1100;
ble.scanPeriod                                      = 128;
ble.scanDuration                                    = 127995;
ble.fltPduType                                      = ["SCAN_FLT_PDU_SCANNABLE_ONLY"];
ble.L2CAPCOCInitiator                               = "L2CAPCOC_INITIATOR";
ble.bondPairing                                     = "GAPBOND_PAIRING_MODE_INITIATE";
ble.connIntMin                                      = 30;
ble.connIntMax                                      = 30;
ble.connectionHandover                              = true;
ble.deviceName                                      = "CarNode";
ble.radioConfig.codeExportConfig.$name              = "ti_devices_radioconfig_code_export_param0";
ble.adcNoiseConfig.codeExportConfig.$name           = "ti_devices_radioconfig_code_export_param1";
ble.bleCsConfig.codeExportConfig.$name              = "ti_devices_radioconfig_code_export_param2";
ble.connUpdateParamsPeripheral.$name                = "ti_ble_general_ble_conn_update_params0";
ble.advSet1.$name                                   = "ti_ble_broadcaster_advertisement_set0";
ble.advSet1.advParam1.$name                         = "ti_ble_broadcaster_advertisement_params0";
ble.advSet1.advParam1.primIntMin                    = 20;
ble.advSet1.advParam1.primIntMax                    = 20;
ble.advSet1.advData1.$name                          = "ti_ble_broadcaster_advertisement_data0";
ble.advSet1.advData1.numOfUUIDs16More               = 1;
ble.advSet1.advData1.UUID016More                    = 0xFFF0;
ble.advSet1.advData1.GAP_ADTYPE_LOCAL_NAME_COMPLETE = true;
ble.advSet1.scanRes1.$name                          = "ti_ble_broadcaster_advertisement_data1";
ble.advSet1.scanRes1.GAP_ADTYPE_LOCAL_NAME_COMPLETE = false;
ble.advSet1.scanRes1.GAP_ADTYPE_POWER_LEVEL         = false;
ble.connUpdateParamsCentral.$name                   = "ti_ble_general_ble_conn_update_params1";
ble.APULPF3.$name                                   = "ti_drivers_APU0";
scripting.suppress("Channel Sounding preview \\(Not yet certified\\)", ble, "channelSounding");
scripting.suppress("In order to enable multiple antennas, please make sure to enable PBEGPO2 and PBEGPO3 inside TI Drivers -> RCL Observables -> signals", ble, "numAntennas");

serving node：

ble.basicBLE                                        = true;
ble.numOfAdvSets                                    = 1;
ble.numOfDefAdvSets                                 = 1;
ble.deviceRole                                      = "PERIPHERAL_CFG+CENTRAL_CFG";
ble.maxPDUSize                                      = 255;
ble.disableDisplayModule                            = true;
ble.appExternalControlMode                          = true;
ble.L2CAPCOC                                        = true;
ble.maxRLSize                                       = 6;
ble.dupFilter                                       = "SCAN_FLT_DUP_DISABLE";
ble.connectionMonitorRole                           = true;
ble.channelSounding                                 = true;
ble.csMeasureDistance                               = true;
ble.numAntennas                                     = 2;
ble.antennasMuxValues                               = 0xC6;
ble.addressMode                                     = "ADDRMODE_PUBLIC";
ble.maxConnNum                                      = 2;
ble.centraSupTimeout                                = 2000;
ble.scanInt                                         = 1100;
ble.scanWin                                         = 1100;
ble.scanPeriod                                      = 128;
ble.scanDuration                                    = 127995;
ble.fltPduType                                      = ["SCAN_FLT_PDU_SCANNABLE_ONLY"];
ble.L2CAPCOCInitiator                               = "L2CAPCOC_INITIATOR";
ble.connIntMin                                      = 30;
ble.connIntMax                                      = 30;
ble.connectionHandover                              = true;
ble.bondPairing                                     = "GAPBOND_PAIRING_MODE_INITIATE";
ble.maxBonds                                        = 6;
ble.deviceName                                      = "CarNode";
ble.radioConfig.codeExportConfig.$name              = "ti_devices_radioconfig_code_export_param0";
ble.adcNoiseConfig.codeExportConfig.$name           = "ti_devices_radioconfig_code_export_param1";
ble.bleCsConfig.codeExportConfig.$name              = "ti_devices_radioconfig_code_export_param2";
ble.connUpdateParamsPeripheral.$name                = "ti_ble_general_ble_conn_update_params0";
ble.advSet1.$name                                   = "ti_ble_broadcaster_advertisement_set0";
ble.advSet1.advParam1.$name                         = "ti_ble_broadcaster_advertisement_params0";
ble.advSet1.advParam1.primIntMin                    = 20;
ble.advSet1.advParam1.primIntMax                    = 20;
ble.advSet1.advData1.$name                          = "ti_ble_broadcaster_advertisement_data0";
ble.advSet1.advData1.numOfUUIDs16More               = 1;
ble.advSet1.advData1.UUID016More                    = 0xFFF0;
ble.advSet1.advData1.GAP_ADTYPE_LOCAL_NAME_COMPLETE = true;
ble.advSet1.scanRes1.$name                          = "ti_ble_broadcaster_advertisement_data1";
ble.advSet1.scanRes1.GAP_ADTYPE_LOCAL_NAME_COMPLETE = false;
ble.advSet1.scanRes1.GAP_ADTYPE_POWER_LEVEL         = false;
ble.connUpdateParamsCentral.$name                   = "ti_ble_general_ble_conn_update_params1";
ble.APULPF3.$name                                   = "ti_drivers_APU0";
scripting.suppress("Channel Sounding preview \\(Not yet certified\\)", ble, "channelSounding");
scripting.suppress("In order to enable multiple antennas, please make sure to enable PBEGPO2 and PBEGPO3 inside TI Drivers -> RCL Observables -> signals", ble, "numAntennas");

peer node(cc2340R53)

ble.basicBLE                                        = true;
ble.numOfAdvSets                                    = 1;
ble.numOfDefAdvSets                                 = 1;
ble.deviceRole                                      = "PERIPHERAL_CFG+CENTRAL_CFG";
ble.deviceName                                      = "Car Node";
ble.maxPDUSize                                      = 255;
ble.disableDisplayModule                            = true;
ble.appExternalControlMode                          = true;
ble.L2CAPCOC                                        = true;
ble.maxConnNum                                      = 6;
ble.maxRLSize                                       = 6;
ble.maxBonds                                        = 6;
ble.connIntMin                                      = 30;
ble.connIntMax                                      = 30;
ble.scanInt                                         = 1000;
ble.scanDuration                                    = 5000;
ble.dupFilter                                       = "SCAN_FLT_DUP_DISABLE";
ble.connectionMonitorRole                           = true;
ble.channelSounding                                 = true;
ble.connectionHandover                              = true;
ble.bondPairing                                     = "GAPBOND_PAIRING_MODE_INITIATE";
ble.radioConfig.codeExportConfig.$name              = "ti_devices_radioconfig_code_export_param0";
ble.adcNoiseConfig.codeExportConfig.$name           = "ti_devices_radioconfig_code_export_param1";
ble.bleCsConfig.codeExportConfig.$name              = "ti_devices_radioconfig_code_export_param2";
ble.connUpdateParamsPeripheral.$name                = "ti_ble_general_ble_conn_update_params0";
ble.advSet1.$name                                   = "ti_ble_broadcaster_advertisement_set0";
ble.advSet1.advParam1.$name                         = "ti_ble_broadcaster_advertisement_params0";
ble.advSet1.advParam1.primIntMin                    = 1000;
ble.advSet1.advParam1.primIntMax                    = 1000;
ble.advSet1.advData1.$name                          = "ti_ble_broadcaster_advertisement_data0";
ble.advSet1.advData1.numOfUUIDs16More               = 1;
ble.advSet1.advData1.UUID016More                    = 0xFFF0;
ble.advSet1.advData1.GAP_ADTYPE_LOCAL_NAME_COMPLETE = true;
ble.advSet1.scanRes1.$name                          = "ti_ble_broadcaster_advertisement_data1";
ble.advSet1.scanRes1.GAP_ADTYPE_LOCAL_NAME_COMPLETE = false;
ble.advSet1.scanRes1.GAP_ADTYPE_POWER_LEVEL         = false;
ble.connUpdateParamsCentral.$name                   = "ti_ble_general_ble_conn_update_params1";

3.It takes 55 milliseconds to transfer data using CAN.

4.I tested the results of several situations

Thanks

James

2025.08.20

Hello James, 

Apologies for the delay. I have been testing with the configurations you sent. Can you clarify, are stable connection and after connection directly after connecting to the serving node, or after connection handover is completed?

For my testing, I am not using CAN, but the python demo provided within the SDK. The results are as follows: 

1. Same result also was able to complete connection handover successfully. My SysConfig is extremely similar to yours. The major configuration I looked for is the bondPairing configuration.  

2. I was able to connect, pairing failed if I kept bondPairing to initiate pairing. I received a pairing status of 0x08, which indicates pairing failed, but the reason is "unspecified. 

3. I was able to connect to the CC2340R5 peer node, maintain the connection, successfully execute connection handover, and maintain the connection afterwards. I had no problem with this setup. I tested this 10 times in a row with no problems. 

I do not have time today to check the CC2340R5 scanning and CC2745R10-Q1 serving/candidate nodes advertising. I will check this next week. Additionally, I plan to debug the 2nd test more next week. 

Can you clarify how long "immediately" is? Is this around 1 second after the connection is established? When I tested the 2nd test, the connection was maintained until pairing was initiated and subsequently failed. 

Apologies on the delay James. I will complete some additional troubleshooting and run the last test setup before Wednesday (08/22) next week. 

Thanks,
Isaac

Hi, Isaac:

Thank you for your reply.

1.A stable connection refers to a connection between the peer node and the candidate node that remains stable after the handover is complete.

2.In the last case, you don't need to test it. I retested it, and if you set the candidate node to not initiate pairing, the handover will be successful, and the connection will be stable after the handover.

3.As shown in the log below, when the BLEAPPUTIL_HANDOVER_START_CANDIDATE_EVENT_CODE event is reported, the connection status immediately changes to “Terminated.”

[15:10:59.950] Handover_CAN_Data  is complete 
[15:10:59.950] Handover_StartCN------------
[15:10:59.960] Conn status: Established
[15:10:59.960] RSSI:-127 
[15:11:00.004] 
[15:11:00.224] BLEAPPUTIL_HANDOVER_START_CANDIDATE_EVENT_CODE
[15:11:00.229] Conn status: Terminated
[15:11:00.229] BOOT UP!!!

4.I hope you can provide me with your Python code for the third case so I can test it. I have only been able to successfully handover occasionally.

Thanks

James

2025.08.25

Hello James, 

Understood. I wanted to clarify which connection you were implying. Changing the pairing configuration to wait for pairing instead of initiate pairing was going to be my recommendation. Happy to see you figured that out. 

The third test should work as well if you change the pairing configuration of the candidate node to wait for pairing. My test is more basic than yours. I am toggling the board LEDs when the connection is established, and then if the connection is terminated. I have been testing using the python script attached. I modified the connection handover script to scan instead of advertising. Note, when I run the test, the connection is maintained indefinitely after connection handover is completed. The setup is as follows: 

CC2745R10-Q1 Serving Node: Initiate Pairing, Scanning 

CC2745R10-Q1 Candidate Node: Wait for Pairing

CC2340R5 Peer Node: Wait for Pairing, Advertiser

Add nodes have 2 antenna paths as well. 

import os
import datetime
import sys
import time

## Uncomment line below for local debug of packages
# sys.path.append(r"../unpi")
# sys.path.append(r"../rtls")
# sys.path.append(r"../ble_device")

from ble_device import (
    BleDevice,
    BleDevicePeripheral,
    BleDeviceLoggingLevel,
    PeripheralEventType,
    CentralEventType,
    ConnectionEventType,
    HandoverEventType,
    AddressType,
    PairingEventType,
)


def get_logging_file_path():
    data_time = datetime.datetime.now().strftime("%m_%d_%Y_%H_%M_%S")

    logging_file_path = os.path.join(
        os.path.curdir, os.path.basename(__file__).replace(".py", "_log")
    )

    if not os.path.isdir(logging_file_path):
        os.makedirs(logging_file_path)

    logging_file = os.path.join(
        logging_file_path,
        f"{data_time}_{os.path.basename(__file__).replace('.py', '.log')}",
    )

    return os.path.abspath(logging_file)


def print_connection_data(connection_data):
    print("Connection Data")
    print("----------------------------------------------------------------------")
    print(f"status:                 {connection_data['status']}")
    print(f"opcode:                 {connection_data['opcode']}")
    print(
        f"address_type:           {AddressType(connection_data['address_type']).name}"
    )
    print(
        f"dev_address:            {':'.join(format(x, '02X') for x in reversed(connection_data['dev_address']))}"
    )
    print(f"connection_handle:      {connection_data['connection_handle']}")
    print(f"connection_role:        {connection_data['connection_role']}")
    print(f"connection_interval:    {connection_data['connection_interval']}")
    print(f"connection_latency:     {connection_data['connection_latency']}")
    print(f"connection_timeout:     {connection_data['connection_timeout']}")
    print(f"clock_accuracy:         {connection_data['clock_accuracy']}")
    print("----------------------------------------------------------------------")


def print_pairing_data(pairing_data):
    print("Pairing Complete")
    print(f"Connection Handle:     {pairing_data['connection_handle']}")
    print(f"State:                 {pairing_data['state']}")
    print(f"Status:                {pairing_data['status']}")
    print("------------------------------------------------------")


def search_peer_name(peer_names, adv_data):
    i = 0
    while i < len(adv_data):
        length = adv_data[i]
        if length == 0:
            return None
        field_type = adv_data[i + 1]
        if field_type == 0x09:  # Complete Local Name
            name = bytes(adv_data[i + 2 : i + 1 + length]).decode("utf-8")
            print(f"adv local name: {name}")
            if name in peer_names:
                return name
        i += length + 1

    return None


def main():
    logging_file = get_logging_file_path()

    serving_node = BleDevice(
        device_comport="COM442",
        logging_file=logging_file,
        logging_level=BleDeviceLoggingLevel.DEBUG,
        sync_command=False,
    )

    candidate_node = BleDevice(
        device_comport="COM111",
        logging_file=logging_file,
        logging_level=BleDeviceLoggingLevel.DEBUG,
        sync_command=False,
    )

    if serving_node.initialize() and candidate_node.initialize():

        peer_names = ["Key Node"]

        connection_data = []  # Holds temporary connection data
        peer_name = None  # Holds temporary peer name
        connections = {}  # Dictionary of peer names to connection handle

        for i in range(len(peer_names)):
            # Start scanning
            print("Start Scanning")
            serving_node.central.start_scan(0, 0, 0)
            continue_scan = True
            while continue_scan:
                time.sleep(1e-12)

                if serving_node.all_event_list.is_event_in_list(
                    CentralEventType.NWP_ADV_REPORT
                ):
                    adv_report = serving_node.all_event_list.get_event_from_list(
                        CentralEventType.NWP_ADV_REPORT
                    )
                    if adv_report:
                        print("Adv report detected")
                        # Search the name in the advertising data
                        peer_name = search_peer_name(peer_names, adv_report["data"])
                        if peer_name != None:
                            # Stop the scan
                            serving_node.central.stop_scan()
                            continue_scan = False
                            # Save the peer address and address type
                            peer_addr_type = adv_report["address_type"]
                            peer_address = adv_report["address"].copy()
                            print(f"Create a connection with {peer_address} as a central")
                            serving_node.central.connect(peer_addr_type, peer_address, 1, 0)
                            connection_data = serving_node.wait_for_event(
                                event_type=ConnectionEventType.NWP_LINK_ESTABLISHED_EVENT,
                                timeout=60,
                            )

                            if connection_data:
                                print(
                                    f"Connection created with: {peer_name}, connection handle: {connection_data['connection_handle']}"
                                )
                                # Stop the scan
                                serving_node.central.stop_scan()
                                continue_scan = False
                                # Set peer name in dictionary
                                connections[peer_name] = connection_data[
                                    "connection_handle"
                                ]
                            else:
                                print(f"ERROR: Connection failed with {peer_name}")
                                return None


        # Print connection data
        if connection_data:
            print_connection_data(connection_data)

            start_time = time.time()
            pairing_timeout = 15
            print(
                f"Waiting for pairing events from peer {peer_name}", end="", flush=True
            )
            while True:
                print(".", end="", flush=True)
                event_type, event_data = serving_node.wait_for_any_event(timeout=0.2)

                if event_type is not None and event_data is not None:
                    if event_type == PairingEventType.NWP_PAIRING_STATE_COMPLETE:
                        print("\nPairing Complete Event Received")
                        pairing_data = event_data
                        break
                    elif event_type == PairingEventType.NWP_PAIRING_STATE_ENCRYPTED:
                        print("\nPairing Encrypted Event Received")
                        pairing_data = event_data
                        break

                # Check for timeout
                if time.time() - start_time > pairing_timeout:
                    print(
                        f"\nTimeout waiting for pairing events ({pairing_timeout} seconds)"
                    )
                    return None

            # Print pairing data
            # if pairing_data and pairing_data["status"] == 0:
            #     print_pairing_data(pairing_data)
            # else:
            #     print(f"ERROR: pairing with {peer_name} Failed!")
            #     return None

        if pairing_data:
            print("Pairing Complete")
            print(f"connection_handle:     {pairing_data['connection_handle']}")
            print(f"state:                 {pairing_data['state']}")
            print(f"status:                {pairing_data['status']}")
            print("------------------------------------------------------")

        print("Start Serving Node")
        # Start Serving Node
        print(pairing_data)

        if pairing_data["status"] == 0:
            print(f"Connection Handle: {connection_data['connection_handle']}")
            # In order to trigger GATT car_access, min_gatt_handle and max_gatt_handle should be set to valid gatt handles
            serving_node.handover.start_serving_node(
                conn_handle=connection_data["connection_handle"],
                min_gatt_handle=0x0000,
                max_gatt_handle=0x0000,
                handover_sn_mode=1,
            )

            handover_data = serving_node.wait_for_event(
                event_type=HandoverEventType.NWP_HANDOVER_SN_DATA, timeout=60
            )

            if handover_data:
                print(f"connection handle:      {handover_data['connection_handle']}")
                print(f"status:                 {handover_data['status']}")
                print(f"data length:            {handover_data['data_len']}")
                print(f"data:                   {handover_data['data']}")

                if handover_data['status'] == 0:
                    print("Start Candidate Node")
                    candidate_node.handover.start_candidate_node(
                        offset=65000,
                        max_err_time=0,
                        max_num_conn_events=6,
                        data=handover_data["data"],
                    )

                    # Wait for the candidate node status
                    candidate_node_status = candidate_node.wait_for_event(
                        event_type=HandoverEventType.NWP_HANDOVER_CN_STATUS, timeout=30
                    )

                    # Wait for the connection complete event on the candidate side
                    connection_data = candidate_node.wait_for_event(
                        event_type=ConnectionEventType.NWP_LINK_ESTABLISHED_EVENT,
                        timeout=30,
                    )

                    # Report the candidate car_access status to the serving node
                    if candidate_node_status:
                        serving_node.handover.close_serving_node(
                            status=candidate_node_status["status"]
                        )

                    # print connection data
                    if connection_data:
                        print_connection_data(connection_data)

    serving_node.done()
    candidate_node.done()

    print("Example ended")

    exit(0)


if __name__ == "__main__":
    main()

Let me know if you are able to get the third case working. I will need more time to enable the test for the fourth case. 

Thanks,

Isaac

Hi, Isaac:

1. Thank you for providing the Python code for testing. I tested the Python code on SDK 9.11.0.18, and the handover function worked properly. I also tested the Python code on SDK 9.12.0.19, and the handover function worked properly in both cases, whether using the phone or the CC2340R53 as the peer node.

2. When I port Python code to C code and use CAN to transmit parameters, the handover function works successfully if I use the phone as the peer node. However, when using the CC2340R53 as the peer node, the handover function rarely succeeds, only occasionally working once in a while.

3. We need to enable Channel Sounding functionality after handover, but currently pairing cannot be performed after handover, so Channel Sounding cannot be activated. Are there any methods available to achieve this goal?

Thanks

James

2025.09.01

Hello James, 

Have you confirmed the validity of the connection handover data being sent over CAN? Does this match the data being sent through the python script when the connection handover is working? Have you debugged the C code further? 

Can you determine if the connection handover data sent is valid? Seems that the embedded C implementation is leaving something out when transferring data, or within the connection handover process. Additionally, what status are you receiving on the candidate node side for pairing? Let me know if you find anything while debugging further. 

Thanks,
Isaac

Hi, Isaac:

Thank you for your prompt reply.

1.I'm currently testing on SDK 9.12.0.19. I've verified the validity of the transmitted data, and the data length in the new SDK 9.12.0.19 has changed from the original 268 bytes to 300 bytes now. Additionally, when using a phone as the peer node, the handover function in my code works properly.

2.I re-debugged TI's Python code and found that when using the CC2340R53 as the peer node, the handover function is not actually implemented. I also debugged the candidate node and observed that during the handover process, the candidate node does connect to the peer node, but the connection drops immediately afterward. Right after that, the peer node reconnects to the serving node at once. This gives the illusion that the peer node has successfully completed the handover, but in reality, it remains connected to the serving node the entire time.

Thanks

James

2025.09.03

Hello James, 

I have tested a few times while doing some additional debug. I see what you are saying. Sometimes the candidate node maintains the connection with the CC2340R53 peer node, sometimes the serving node cannot connect, and sometimes the candidate node drops the connection, and the serving node maintains the connection. 

I am working to debug this more but will need some more time. A few questions in the meantime: 

1. What have you set the values for the time taken for the CAN transfer, maximum failed connection events and the time deviation on the candidate node side? 

2. What do you mean when you say "the handover function is not actually implemented" for the CC2340R53 peer node? I am able to observe the CC2340R53 peer node stay connected to the candidate node after the connection handover has completed on some occasions. 

Again, I will continue debugging tomorrow. I hope for have some more information by next Monday (09/08). Thank you for your patience. 

Thanks,

Isaac

Hi, Isaac:

1.The following are the parameters I set on the candidate node side:

            cnParams_fii.timeDelta = 65000;
            cnParams_fii.timeDeltaErr = 0;
            cnParams_fii.maxFailedConnEvents = 10;
            cnParams_fii.txBurstRatio = 0;
            cnParams_fii.pHandoverData = Handover_CN_Data;

2.What I mean is that the Python code can occasionally achieve a successful handover, but most of the time, it reconnects back to the serving node. This result is consistent with the tests I conducted using C code. Handover succeeds only occasionally—previously, I had always assumed that the Python code would consistently achieve successful handover.

Thanks

James

2025.09.04