LP-EM-CC1354P10: [DMM BLE + PROP] Hitting SYS/BIOS Error: Stuck in for(;;) after RF scheduling

Prajakta Kadam

Part Number: LP-EM-CC1354P10
Other Parts Discussed in Thread: CC1354P10, SYSBIOS, CC1352P7

Tool/software:

Hi Marie,

I’m working on a TI DMM (Dynamic Multi-protocol Manager) project using BLE (Simple Peripheral) and a custom Sub-1 GHz PROP stack on a CC1354P10 device.

The setup is:

1. BLE: running GAP advertising in short duration windows (about 10 ticks, using GapAdv_enable with GAP_ADV_ENABLE_OPTIONS_USE_DURATION).

2.PROP: continuously trying RX→TX bursts using RF_runScheduleCmd, scheduled via DMM with lower priority.

3. After running for some time (especially under heavier RF scheduling), the application suddenly halts inside the SYS/BIOS runtime Error_raise function.

4. When connecting a debugger, I see it stuck at:

if (Error_policy_D == Error_SPIN) {
for (;;) {
}
}
else if (((eb == &defErr) && (Error_policy_D == Error_UNWIND)) || (Error_policy_D == Error_TERMINATE)) {
System_abort("ti_sysbios_runtime_Error_raise: terminating execution\n");
}

Please check what are the reasons behind this error.

Best Regards,

Prajakta Kadam

4 months ago

0 Toby 3 months ago

TI__Mastermind 35070 points

Hello Prajakta,

Thanks for reporting this.

Can you share more details in your implementation? DMM file?

Thanks,
Toby

0 Prajakta Kadam 3 months ago in reply to Toby

Prodigy 30 points

Hello Toby,

Thanks for your response.

Sure, I can share more details. We're using a dual-mode configuration with BLE (Simple Peripheral) and Sub-1 GHz (Proprietary) running on a CC1354P device. The DMM configuration uses DMMPolicy_StackRole_BlePeripheral and a custom DMMPolicy_StackRole_Custom1 for the proprietary stack.

We're using the DMM global priority table to give BLE higher priority, specifically globalPriorityTable_bleLpropH. The scheduling is done using RF_scheduleCmd() from both stacks.

Please find the attached DMM configuration file (dmm_policy.c and dmm_policy.h) along with the relevant RF scheduling logic from the proprietary application.

Let me know if you need additional logs or source files.

Fullscreen dmm_policy_config.c Download

#include "dmm_policy_config.h"
//#include <ti_dmm_application_policy.h>
#include <ti_dmm_custom_activities.h>


#include "dmm_policy_config.h"
#include <ti_dmm_custom_activities.h>

/* Stack indices */
#define BLE_IDX     BLE_STACK_POLICY_IDX
#define PROP_IDX    CUSTOM1_STACK_POLICY_IDX

#include "dmm_policy_config.h"
#include <ti_dmm_custom_activities.h>

#define BLE_IDX     BLE_STACK_POLICY_IDX
#define PROP_IDX    CUSTOM1_STACK_POLICY_IDX

#include "dmm_policy_config.h"
#include <ti_dmm_custom_activities.h>

/* Stack indices, per your macros */
#define BLE_IDX   BLE_STACK_POLICY_IDX     // 0
#define PROP_IDX  CUSTOM1_STACK_POLICY_IDX // 1

#define DMMPOLICY_APPLIED_ACTIVITY_PROP_RXTX   0x1000

/* Policy entries:
 *  - Policy 0: BLE Advertising  → PROP paused
 *  - Policy 1: BLE Connecting/Connected/High-BW → PROP paused
 *  - Policy 2: BLE Idle → PROP active
 */
DMMPolicy_Policy DMMPolicy_ApplicationPolicy[] =
{
    // Policy 0: BLE Advertising
    {
      .appState[BLE_IDX] = {
        .state            = DMMPOLICY_BLE_ADV,
        .weight           = 10,
        .timingConstraint = DMMPOLICY_TIME_CRITICAL,
        .pause            = DMMPOLICY_NOT_PAUSED,
        .appliedActivity  = DMMPOLICY_APPLIED_ACTIVITY_BLE_BROADCASTING
      },
      .appState[PROP_IDX] = {
        .state            = ANY,
        .weight           = 0,
        .timingConstraint = DMMPOLICY_TIME_NONE_CRITICAL,
        .pause            = DMMPOLICY_PAUSED,
        .appliedActivity  = DMMPOLICY_APPLIED_ACTIVITY_NONE
      },
      .balancedMode = DMMPOLICY_BALANCED_NONE
    },

    // Policy 1: BLE Connecting / Connected / High-BW
    {
      .appState[BLE_IDX] = {
        .state            = (DMMPOLICY_BLE_CONNECTING |
                             DMMPOLICY_BLE_CONNECTED  |
                             DMMPOLICY_BLE_HIGH_BANDWIDTH),
        .weight           = 10,
        .timingConstraint = DMMPOLICY_TIME_RESERVED,
        .pause            = DMMPOLICY_NOT_PAUSED,
        .appliedActivity  = DMMPOLICY_APPLIED_ACTIVITY_BLE_CONNECTION
      },
      .appState[PROP_IDX] = {
        .state            = ANY,
        .weight           = 0,
        .timingConstraint = DMMPOLICY_TIME_NONE_CRITICAL,
        .pause            = DMMPOLICY_PAUSED,
        .appliedActivity  = DMMPOLICY_APPLIED_ACTIVITY_NONE
      },
      .balancedMode = DMMPOLICY_BALANCED_NONE
    },

    // Policy 2: BLE Idle
    {
      .appState[BLE_IDX] = {
        .state            = DMMPOLICY_BLE_IDLE,
        .weight           = 1,    // BLE still gets minimal slice
        .timingConstraint = DMMPOLICY_TIME_NONE_CRITICAL,
        .pause            = DMMPOLICY_NOT_PAUSED,
        .appliedActivity  = DMMPOLICY_APPLIED_ACTIVITY_NONE
      },
      .appState[PROP_IDX] = {
        .state            = APP_STATE_PROP_ACTIVE,
        .weight           = 5,    // PROP runs when BLE is idle
        .timingConstraint = DMMPOLICY_TIME_NONE_CRITICAL,
        .pause            = DMMPOLICY_NOT_PAUSED,
        .appliedActivity  = DMMPOLICY_APPLIED_ACTIVITY_PROP_RXTX
      },
      .balancedMode = DMMPOLICY_BALANCED_NONE
    }
};

uint32_t DMMPolicy_ApplicationPolicySize =
    sizeof(DMMPolicy_ApplicationPolicy)/sizeof(DMMPolicy_Policy);

DMMPolicy_PolicyTable DMMPolicy_ApplicationPolicyTable =
{
  .stackRole[BLE_IDX]  = DMMPolicy_StackRole_BlePeripheral,
  .stackRole[PROP_IDX] = DMMPolicy_StackRole_custom1,
  .policy              = DMMPolicy_ApplicationPolicy,
  .indexTable          = NULL
};




// /*DMMPolicy_Policy DMMPolicy_ApplicationPolicy[] = {
//     // Policy 0: BLE Advertising + Sub-1 GHz Active
//     {
//         .appState[BLE_STACK_POLICY_IDX] = {
//             .state = DMMPOLICY_BLE_ADV,
//             .weight = 25,
//             .timingConstraint = DMMPOLICY_TIME_CRITICAL,//DMMPOLICY_TIME_RESERVED,//DMMPOLICY_TIME_CRITICAL,//DMMPOLICY_TIME_RESERVED,
//             .pause = DMMPOLICY_NOT_PAUSED,
//             .appliedActivity = DMMPOLICY_APPLIED_ACTIVITY_NONE,
//         },
//         .appState[CUSTOM1_STACK_POLICY_IDX] = {
//             .state = APP_STATE_PROP_ACTIVE,
//             .weight = 10,
//             .timingConstraint =DMMPOLICY_TIME_NONE_CRITICAL,//DMMPOLICY_TIME_RESERVED,// DMMPOLICY_TIME_NONE_CRITICAL,//DMMPOLICY_TIME_RESERVED,
//             .pause = DMMPOLICY_NOT_PAUSED,
//             .appliedActivity = DMMPOLICY_APPLIED_ACTIVITY_NONE,
//         },
//         .balancedMode = DMMPOLICY_BALANCED_NONE,
//     },

//     // Policy 1: BLE Connected (Param Update) + Sub-1 GHz Paused
//     {
//         .appState[BLE_STACK_POLICY_IDX] = {
//             .state = DMMPOLICY_BLE_PARAMUPDATE,
//             .weight = 50,
//             .timingConstraint = DMMPOLICY_TIME_CRITICAL,//DMMPOLICY_TIME_RESERVED,//DMMPOLICY_TIME_CRITICAL,
//             .pause = DMMPOLICY_NOT_PAUSED,
//             .appliedActivity = DMMPOLICY_APPLIED_ACTIVITY_NONE,
//         },
//         .appState[CUSTOM1_STACK_POLICY_IDX] = {
//             .state = APP_STATE_PROP_PAUSED,
//             .weight = 0,
//             .timingConstraint = DMMPOLICY_TIME_NONE_CRITICAL,  //DMMPOLICY_TIME_RESERVED
//             .pause = DMMPOLICY_NOT_PAUSED,//DMMPOLICY_PAUSED,
//             .appliedActivity = DMMPOLICY_APPLIED_ACTIVITY_NONE,
//         },
//         .balancedMode = DMMPOLICY_BALANCED_NONE,
//     },
// };*/

// DMMPolicy_Policy DMMPolicy_ApplicationPolicy[] = {
//     // DMM Policy 0
//     {
//         // BLE Peripheral Policy
//         .appState[BLE_STACK_POLICY_IDX] = {
//             .state = DMMPOLICY_BLE_ADV,//DMMPOLICY_BLE_OAD,
//             .weight = 0,
//             .timingConstraint = DMMPOLICY_TIME_RESERVED,
//             .pause = DMMPOLICY_NOT_PAUSED,
//             .appliedActivity =  DMMPOLICY_APPLIED_ACTIVITY_NONE,
//         },
//         // 15.4 Sensor Policy
//         .appState[CUSTOM1_STACK_POLICY_IDX] = {
//             .state = ANY,
//             .weight = 0,
//             .timingConstraint = DMMPOLICY_TIME_RESERVED,
//             .pause = DMMPOLICY_PAUSED,
//             .appliedActivity =  DMMPOLICY_APPLIED_ACTIVITY_NONE,
//         },
//         //Balanced Mode Policy
//         .balancedMode = DMMPOLICY_BALANCED_NONE,
//     },
//     // DMM Policy 1
//     {
//         // BLE Peripheral Policy
//         .appState[BLE_STACK_POLICY_IDX] = {
//             .state = (DMMPOLICY_BLE_CONNECTING | DMMPOLICY_BLE_HIGH_BANDWIDTH),
//             .weight = 25,
//             .timingConstraint = DMMPOLICY_TIME_RESERVED,
//             .pause = DMMPOLICY_NOT_PAUSED,
//             .appliedActivity =  DMMPOLICY_APPLIED_ACTIVITY_BLE_CONNECTION,
//         },
//         // 15.4 Sensor Policy
//         .appState[CUSTOM1_STACK_POLICY_IDX] = {
//             .state = ANY,
//             .weight = 0,
//             .timingConstraint = DMMPOLICY_TIME_RESERVED,
//             .pause = DMMPOLICY_NOT_PAUSED,
//             .appliedActivity =  DMMPOLICY_APPLIED_ACTIVITY_NONE,
//         },
//         //Balanced Mode Policy
//         .balancedMode = DMMPOLICY_BALANCED_NONE,
//     },
//     // DMM Policy 2
//     {
//         // BLE Peripheral Policy
//         .appState[BLE_STACK_POLICY_IDX] = {
//             .state = ANY,
//             .weight = 0,
//             .timingConstraint = DMMPOLICY_TIME_RESERVED,
//             .pause = DMMPOLICY_NOT_PAUSED,
//             .appliedActivity =  DMMPOLICY_APPLIED_ACTIVITY_NONE,
//         },
//         // 15.4 Sensor Policy
//         .appState[CUSTOM1_STACK_POLICY_IDX] = {
//             .state = ANY,
//             .weight = 1,
//             .timingConstraint = DMMPOLICY_TIME_RESERVED,
//             .pause = DMMPOLICY_NOT_PAUSED,
//             .appliedActivity =  DMMPOLICY_APPLIED_ACTIVITY_NONE,
//         },
//         //Balanced Mode Policy
//         .balancedMode = DMMPOLICY_BALANCED_NONE,
//     },
// };


// // \brief The application policy table size
// uint32_t DMMPolicy_ApplicationPolicySize = (sizeof(DMMPolicy_ApplicationPolicy) / sizeof(DMMPolicy_Policy));

// DMMPolicy_PolicyTable DMMPolicy_ApplicationPolicyTable = {
//     .stackRole[BLE_STACK_POLICY_IDX] = DMMPolicy_StackRole_BlePeripheral,
//     .stackRole[CUSTOM1_STACK_POLICY_IDX] = DMMPolicy_StackRole_custom1,
//     .policy = DMMPolicy_ApplicationPolicy,
//     .indexTable = NULL,
// };

dmm_policy_config.h

Fullscreen dmm_priority_ble_prop.c Download

/******************************************************************************

 @file dmm_priority_ble_prop.c

 @brief Dual Mode Manager Global Priority for 15.4 Sensor and BLE Stack

 Group: WCS LPC
 Target Device: cc13xx_cc26xx

 ******************************************************************************
 
 Copyright (c) 2017-2025, Texas Instruments Incorporated
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:

 *  Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.

 *  Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.

 *  Neither the name of Texas Instruments Incorporated nor the names of
    its contributors may be used to endorse or promote products derived
    from this software without specific prior written permission.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 ******************************************************************************
 
 
 *****************************************************************************/

#include "dmm/dmm_policy.h"
#include "dmm/dmm_priority_ble_prop.h"
#include "ti_154stack_config.h"

/* BLE Activity */
typedef enum
{
    DMM_BLE_CONNECTION =0x07D0,
    DMM_BLE_CON_EST =0x03E8,
    DMM_BLE_BROADCASTING =0x0BB8,
    DMM_BLE_OBSERVING =0x0FA0,
} DMMStackActivityBLE;



typedef enum
{
    DMM_PROP_RX_TX = 0x0A01,
    DMM_PROP_FS    = 0x0A02,
} DMMStackActivityPROP;


StackActivity activityBLE_bleLpropH[ACTIVITY_NUM_BLE*PRIORITY_NUM] =
{
    DMM_GLOBAL_PRIORITY(DMM_BLE_CONNECTION, DMM_StackPNormal, 80),
    DMM_GLOBAL_PRIORITY(DMM_BLE_CONNECTION, DMM_StackPHigh, 180),
    DMM_GLOBAL_PRIORITY(DMM_BLE_CONNECTION, DMM_StackPUrgent, 240),

    DMM_GLOBAL_PRIORITY(DMM_BLE_CON_EST, DMM_StackPNormal, 80),
    DMM_GLOBAL_PRIORITY(DMM_BLE_CON_EST, DMM_StackPHigh, 200),
    DMM_GLOBAL_PRIORITY(DMM_BLE_CON_EST, DMM_StackPUrgent, 230),

    DMM_GLOBAL_PRIORITY(DMM_BLE_BROADCASTING, DMM_StackPNormal, 75),
    DMM_GLOBAL_PRIORITY(DMM_BLE_BROADCASTING, DMM_StackPHigh, 175),
    DMM_GLOBAL_PRIORITY(DMM_BLE_BROADCASTING, DMM_StackPUrgent, 220),

    DMM_GLOBAL_PRIORITY(DMM_BLE_OBSERVING, DMM_StackPNormal, 70),
    DMM_GLOBAL_PRIORITY(DMM_BLE_OBSERVING, DMM_StackPHigh, 120),
    DMM_GLOBAL_PRIORITY(DMM_BLE_OBSERVING, DMM_StackPUrgent, 160),
};

StackActivity activityPROP_bleLpropH[ACTIVITY_NUM_PROP * PRIORITY_NUM] =
{
    // DMM_GLOBAL_PRIORITY(DMM_PROP_RX_TX,   DMM_StackPNormal,   30),
    // DMM_GLOBAL_PRIORITY(DMM_PROP_RX_TX,   DMM_StackPHigh,     30),
    // DMM_GLOBAL_PRIORITY(DMM_PROP_RX_TX,   DMM_StackPUrgent,   30),

    DMM_GLOBAL_PRIORITY(DMM_PROP_RX_TX,   DMM_StackPNormal,   20),
    DMM_GLOBAL_PRIORITY(DMM_PROP_RX_TX,   DMM_StackPHigh,     20),
    DMM_GLOBAL_PRIORITY(DMM_PROP_RX_TX,   DMM_StackPUrgent,   20),

    DMM_GLOBAL_PRIORITY(DMM_PROP_FS,      DMM_StackPNormal,   15),
    DMM_GLOBAL_PRIORITY(DMM_PROP_FS,      DMM_StackPHigh,     90),
    DMM_GLOBAL_PRIORITY(DMM_PROP_FS,      DMM_StackPUrgent,   100),
};

// StackActivity activityBLE_bleLpropH[ACTIVITY_NUM_BLE*PRIORITY_NUM] =
// {
//     DMM_GLOBAL_PRIORITY(DMM_BLE_CONNECTION, DMM_StackPNormal, 70),
//     DMM_GLOBAL_PRIORITY(DMM_BLE_CONNECTION, DMM_StackPHigh, 170),
//     DMM_GLOBAL_PRIORITY(DMM_BLE_CONNECTION, DMM_StackPUrgent, 230),

//     DMM_GLOBAL_PRIORITY(DMM_BLE_CON_EST, DMM_StackPNormal, 70),
//     DMM_GLOBAL_PRIORITY(DMM_BLE_CON_EST, DMM_StackPHigh, 200),
//     DMM_GLOBAL_PRIORITY(DMM_BLE_CON_EST, DMM_StackPUrgent, 220),

//     DMM_GLOBAL_PRIORITY(DMM_BLE_BROADCASTING, DMM_StackPNormal, 60),
//     DMM_GLOBAL_PRIORITY(DMM_BLE_BROADCASTING, DMM_StackPHigh, 160),
//     DMM_GLOBAL_PRIORITY(DMM_BLE_BROADCASTING, DMM_StackPUrgent, 210),

//     DMM_GLOBAL_PRIORITY(DMM_BLE_OBSERVING, DMM_StackPNormal, 60),
//     DMM_GLOBAL_PRIORITY(DMM_BLE_OBSERVING, DMM_StackPHigh, 60),
//     DMM_GLOBAL_PRIORITY(DMM_BLE_OBSERVING, DMM_StackPUrgent, 85),
// };

// StackActivity activityPROP_bleLpropH[ACTIVITY_NUM_PROP * PRIORITY_NUM] =
// {
//     // Prop RX/TX stays very low
//     DMM_GLOBAL_PRIORITY(DMM_PROP_RX_TX,   DMM_StackPNormal,   40),
//     DMM_GLOBAL_PRIORITY(DMM_PROP_RX_TX,   DMM_StackPHigh,     40),
//     DMM_GLOBAL_PRIORITY(DMM_PROP_RX_TX,   DMM_StackPUrgent,   40),

//     // Prop FS: drop PN below BLE (e.g. 20)
//     DMM_GLOBAL_PRIORITY(DMM_PROP_FS,      DMM_StackPNormal,   20),  // was 85
//     DMM_GLOBAL_PRIORITY(DMM_PROP_FS,      DMM_StackPHigh,     105), // keep
//     DMM_GLOBAL_PRIORITY(DMM_PROP_FS,      DMM_StackPUrgent,   115), // keep
// };






/* the order of stacks in policy table and global table must be the same */
GlobalTable globalPriorityTable_bleLpropH[DMMPOLICY_NUM_STACKS] =
{
    {
        .globalTableArray =  activityBLE_bleLpropH,
        .tableSize = (uint8_t)(ACTIVITY_NUM_BLE*PRIORITY_NUM),
        .stackRole = DMMPolicy_StackRole_BlePeripheral,
    },

    {
        .globalTableArray =  activityPROP_bleLpropH,
        .tableSize = (uint8_t)(ACTIVITY_NUM_PROP*PRIORITY_NUM),
        .stackRole =DMMPolicy_StackRole_custom1,// DMMPolicy_StackRole_prop,
    },
};

Best Regards,
Prajakta

0 Toby 3 months ago in reply to Prajakta Kadam

TI__Mastermind 35070 points

Hi Prajakta,

Thanks for sharing this!

I'll take a deeper look throughout the next few days, and provide my next update within 3-5 business days.

Thanks,
Toby

0 Toby 3 months ago in reply to Toby

TI__Mastermind 35070 points

Hi Prajakta,

We've tried a number of things, starting from DMM Integration.

It seems there have been some changes since then, likely in the DMM driver itself (originally designed for CC13x2) or the new device drivers (for CC1354P10).

The experts on these devices are currently out of office, I will consult with them once they return around week 1 Aug.

In the meantime, are you able to develop on CC1352P7 instead on 7.41 SDK? This is a bit more mature solution for DMM.

Thanks,
Toby

Site support

Site support forum

LP-EM-CC1354P10: [DMM BLE + PROP] Hitting SYS/BIOS Error: Stuck in for(;;) after RF scheduling