Zigbee 和 Thread 论坛 - 最近的话题

CC2674P10: The CC2674P10's maximum communication distance is 20dBm.

jun cao — Sat, 09 May 2026 02:23:54 GMT

Part Number: CC2674P10

Hi everyone:

I purchased the CC2674P10 chip and designed a PCB development board (20dBm RF circuit). I compiled the firmware based on TI's official ZNP example, then flashed the firmware to the development board. I connected the development board as a Zigbee adapter to Zigbee2MQTT, added a Zigbee device using Zigbee2MQTT, and then started testing the control distance.

When the distance between the Zigbee device and the development board exceeds 200 meters, Zigbee2MQTT cannot control the Zigbee device.

What is the maximum communication distance officially tested by TI?

CC2652P: 路由器无法入网

yizhe pang — Fri, 17 Apr 2026 09:03:42 GMT

Part Number: CC2652P
Other Parts Discussed in Thread: CC1352P, SYSCONFIG, Z-STACK

在simplelink_cc13xx_cc26xx_sdk_8_32_00_07例程中的zc_light 和zr_light(CC2652P)。添加了和ESP的串口通信，，zigbee网络的数据通信，经检查：

协调器和路由器的 EXT_PANID、信道（15）、PANID 配置一致
协调器已正常建网（打印 NETWORK OK）
路由器正常扫描、一直处于 “搜索网络” 状态，无报错
模块供电、串口、天线配置正常

可能是什么问题导致

建网时的RSSI

CC2530: CC2530 P0_2 IO 口受干扰后，导致功耗超高

Unknown Unknown23 — Thu, 16 Apr 2026 10:41:08 GMT

Part Number: CC2530

您好！我们在一个项目发现同样配置，P0_2、P0_3都配置为输出0，这两个IO都没接任何外设，当P0_2口用镊子触碰就会导致功耗剧增，这时测量这脚电压为0.63V左右，同样方式触碰P0_3脚，就不会出现这问题，当出现这问题只能断电重启就才会恢复正常。请您们帮分析下会是什么问题，如何解决这问题，期待您们回复，感谢！

CC2652P: 协调器建立网络，在有持续信道干扰的情况下，协调器会一直循环active Scan模式不退出。

Aries Lord — Wed, 18 Mar 2026 15:06:06 GMT

Part Number: CC2652P
Other Parts Discussed in Thread: CC2530

CC2652P设置为协调器，使用Zstackapi_bdbStartCommissioningReq函数，commissioning_mode设置为 BDB_COMMISSIONING_MODE_NWK_FORMATION，创建网络。

使用Smart RF Studio连接一片CC2530，在2475MHz频率发出持续干扰信号，CC2652P不再触发zstackmsg_CmdIDs_BDB_NOTIFICATION消息。本来应该由协调器收到zstackmsg_CmdIDs_BDB_NOTIFICATION消息内容应该是BDB_COMMISSIONING_FORMATION=BDB_COMMISSIONING_FAILURE。

进一步跟踪调试代码，在函数ZDApp_NetworkStartEvt中，程序一直在执行NLME_SetEnergyThreshold函数，同时跟踪mac_cb.c文件中对MAC_MLME_SCAN_CNF的处理，发现MAC_MLME_SCAN_CNF最开始只有1~2次ZMAC_ED_SCAN，以后就一直卡在ZMAC_ACTIVE_SCAN下不停循环。

断开用于干扰的CC2530后，CC2652P建立网络成功。

CC2652P: Zigbee 中的ACK是否可以携带数据负载？

?? ? — Sun, 01 Mar 2026 07:24:46 GMT

Part Number: CC2652P
Other Parts Discussed in Thread: CC2530

大家好，我想知道CC2530接收到数据包后回复的ACK是不是固定的，不能携带数据负载？而比较新的Zigbee芯片如CC2652的ACK是不是可以携带数据负载？

CC2652P7: CC2652P7如何实现软件抓包

shen fei — Thu, 12 Feb 2026 07:34:57 GMT

Part Number: CC2652P7

Hi TI,

我想要使用CC2652P7实现对环境内的zigbee数据进行抓包/解析/过滤/串口打印等功能，类似zigbee dongle+packet sniffer的功能。

*我的ZigBee是非加密的方案！

应用端实际想要实现的是：ZC直接通过抓包的方式来知晓周围设备的MAC/短地址/PANID等信息！

是否有相关的demo可以实现？或者有可以实现让ZC获取环境中PANID/MAC等信息的API吗？

CC2340R5: CC2340R5开发，若多个终端向协调器长时间发送数据会发生终端数据发送失败的情况

xin li — Fri, 06 Feb 2026 09:31:42 GMT

Part Number: CC2340R5

使用cc2340R5进行zigbee开发，终端和协调器程序均修改自：simplelink_lowpower_f3_sdk_9_14_00_41---->examples---->nortos---->LP_EM_CC2340R5---->zigbee---->onoff_light例程

设置信道为11，所有终端均可与协调器通信，且单对单通信时未发生断连；

当1个协调器同时连接3个终端时，终端以每秒发送一次数据的频率给协调器发送32字节的zigbee数据，其中每个终端给协调器发送的数据在协调器所打印的数据中的位置都不一定，可能在前，也可能在后，但发送时间过长时，协调器不再打印其中某些终端的数据，需要终端重新上电才可重新连接并且发送数据。

请问是需要添加多设备管理吗？

CC2340R5: zigbee使用zcl多次发送固定数组数据后显示内存不足

xin li — Thu, 22 Jan 2026 05:21:10 GMT

Part Number: CC2340R5

如下方代码所示，先获取缓冲区，再使用zb_aps_send_user_payload()函数发送数据，发送完成或者失败后释放获得的缓冲区；

但是我使用定时每秒发送一次数据时，大约20分钟后程序就会卡死，显示内存错误，必须重新上电才能继续运行，且程序正常运行时间不确定。请问这是什么问题，这个代码是使用TI提供的例程中nortos->zigbee下面的onoff_light程序修改来的。望各位能够提供一点帮助，非常感谢。

zb_bufid_t param= zb_buf_get_out();

获取成功再执行下方函数，

zb_ret_t ret = zb_aps_send_user_payload(

// param,

// addr, /* dst_addr (协调器地址) */

// 0x0104, /* profile id (自定义应用配置文件) */

// 0xf00d, /* cluster id (自定义集群ID) */

// ZB_OUTPUT_ENDPOINT, /* destination endpoint (协调器的端点5) */

// ZB_SWITCH_ENDPOINT, /* source endpoint (终端设备的端点10) */

// ZB_APS_ADDR_MODE_16_ENDP_PRESENT, /* address mode */

// ZB_TRUE, /* APS ACK enabled */

// data_array, /* payload pointer */

// data_size); /* size of payload */

// if (ret != RET_OK) {

// uartPrintf("Failed to send custom array, error code: %d\r\n", ret);

// zb_buf_free(param); /* 发送失败时释放缓冲区 */

// } else {

// // 发送成功，立即释放缓冲区

// zb_buf_free(param);

// uartPrintf("Custom array buffer freed after successful transmission\r\n");

// }

CC2530: Reference source

switch — Tue, 11 Nov 2025 11:19:48 GMT

Part Number: CC2530

Hi ti team，

The customer is using CC2350 in their new project, which is applied in cable power temperature measurement. Due to the small product size, it's not possible to fit an LDO. Could you please confirm whether CC2350 can provide a stable 1.8V/3.3V power supply as an external reference source? The requirement is that the 1.8V/3.3V output of CC2350 has small and stable ripple.

CC2530：How to achieve high-frequency communication between the terminals and the coordinator

Guangqi Li — Wed, 24 Sep 2025 07:34:25 GMT

Part Number: CC2530
Other Parts Discussed in Thread: Z-STACK

As a novice user of the CC2530, I recently encountered a problem that I couldn't solve; Firstly, I carried out the work based on three terminals and one coordinator（ZStack-2.5.1）. The aim was to achieve voltage acquisition at a rate of 30Hz or higher (at the terminals), and then send the data to the coordinator in a point-to-point manner. The coordinator would then print out the data via the serial port.

Currently, the solution I am adopting is that the coordinator sends AD acquisition commands to the three terminals in a cyclic manner through point-to-point polling; after receiving the data returned by the current terminal, it then sends an AD acquisition command to the next terminal to have it upload the data; if I want to achieve a sampling rate of 30Hz, then the time for one polling cycle (polling the three terminals) by the coordinator needs to be 30ms; however, at present, the time for the coordinator to poll all three terminals is approximately 100ms (as shown in the figure1).

I have tried many methods, including modifying the parameters in files such as f8wCoord.cfg, f8wConfig.cfg and f8wEndev.cfg(as shown in the figure2,3,4). Eventually, I could only increase the sampling rate to around 10Hz.Below, I have provided the core code for implementing this function.
I really need everyone's help to solve this problem. If you could offer me some suggestions, I would be extremely grateful.

/*********************************************************************
 * INCLUDES
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "AF.h"
#include "OnBoard.h"
#include "OSAL_Tasks.h"
#include "SampleApp.h"
#include "ZDApp.h"
#include "ZDObject.h"
#include "ZDProfile.h"

#include "hal_drivers.h"
#include "hal_key.h"
#if defined ( LCD_SUPPORTED )
  #include "hal_lcd.h"
#endif
#include "hal_led.h"
#include "hal_uart.h"
#include "hal_adc.h"
#include "OSAL_PwrMgr.h"


/*********************************************************************
 * MACROS
 */

/*********************************************************************
 * CONSTANTS
 */

#if !defined( SAMPLE_APP_PORT )
#define SAMPLE_APP_PORT  0
#endif

#if !defined( SAMPLE_APP_BAUD )
  #define SAMPLE_APP_BAUD  HAL_UART_BR_115200
#endif

// When the Rx buf space is less than this threshold, invoke the Rx callback.
#if !defined( SAMPLE_APP_THRESH )
#define SAMPLE_APP_THRESH  64
#endif

#if !defined( SAMPLE_APP_RX_SZ )
#define SAMPLE_APP_RX_SZ  128
#endif

#if !defined( SAMPLE_APP_TX_SZ )
#define SAMPLE_APP_TX_SZ  128
#endif

// Millisecs of idle time after a byte is received before invoking Rx callback.
#if !defined( SAMPLE_APP_IDLE )
#define SAMPLE_APP_IDLE  6
#endif

// Loopback Rx bytes to Tx for throughput testing.
#if !defined( SAMPLE_APP_LOOPBACK )
#define SAMPLE_APP_LOOPBACK  FALSE
#endif

// This is the max byte count per OTA message.
#if !defined( SAMPLE_APP_TX_MAX )
#define SAMPLE_APP_TX_MAX  80
#endif

#define SAMPLE_APP_RSP_CNT  4
#define ADC_CHANNEL_COUNT 5  // 采集5路AD

const uint8 adcChannels[ADC_CHANNEL_COUNT] = 
{
  HAL_ADC_CHANNEL_0,  // P0_0
  HAL_ADC_CHANNEL_4,  // P0_4
  HAL_ADC_CHANNEL_5,  // P0_5
  HAL_ADC_CHANNEL_6,  // P0_6
  HAL_ADC_CHANNEL_7   // P0_7
};

// This list should be filled with Application specific Cluster IDs.
const cId_t SampleApp_ClusterList[SAMPLE_MAX_CLUSTERS] =
{
  SAMPLEAPP_P2P_CLUSTERID,
  SAMPLEAPP_FLASH_CLUSTERID,
  SAMPLEAPP_ADDR_CLUSTERID
};

const SimpleDescriptionFormat_t SampleApp_SimpleDesc =
{
  SAMPLEAPP_ENDPOINT,              //  int   Endpoint;
  SAMPLEAPP_PROFID,                //  uint16 AppProfId[2];
  SAMPLEAPP_DEVICEID,              //  uint16 AppDeviceId[2];
  SAMPLEAPP_DEVICE_VERSION,        //  int   AppDevVer:4;
  SAMPLEAPP_FLAGS,                 //  int   AppFlags:4;
  SAMPLE_MAX_CLUSTERS,          //  byte  AppNumInClusters;
  (cId_t *)SampleApp_ClusterList,  //  byte *pAppInClusterList;
  SAMPLE_MAX_CLUSTERS,          //  byte  AppNumOutClusters;
  (cId_t *)SampleApp_ClusterList   //  byte *pAppOutClusterList;
};

endPointDesc_t SampleApp_epDesc =
{
  SAMPLEAPP_ENDPOINT,
 &SampleApp_TaskID,
  (SimpleDescriptionFormat_t *)&SampleApp_SimpleDesc,
  noLatencyReqs
};

/*********************************************************************
 * TYPEDEFS
 */

/*********************************************************************
 * GLOBAL VARIABLES
 */
devStates_t SampleApp_NwkState;   
uint8 SampleApp_TaskID;           // Task ID for internal task/event processing.
uint8 SampleApp_TransID;  // This is the unique message ID (counter)

/*********************************************************************
 * EXTERNAL VARIABLES
 */

/*********************************************************************
 * EXTERNAL FUNCTIONS
 */

/*********************************************************************
 * LOCAL VARIABLES
 */

static uint8 SampleApp_MsgID;

afAddrType_t SampleApp_Periodic_DstAddr; //广播
afAddrType_t SampleApp_Flash_DstAddr;    //组播
afAddrType_t SampleApp_P2P_DstAddr;      //点播


static afAddrType_t SampleApp_TxAddr;
static uint8 SampleApp_TxSeq;
static uint8 SampleApp_TxBuf[SAMPLE_APP_TX_MAX+1];
static uint8 SampleApp_TxLen;

static afAddrType_t SampleApp_RxAddr;
static uint8 SampleApp_RxSeq;
static uint8 SampleApp_RspBuf[SAMPLE_APP_RSP_CNT];

//重要,定时终端ID
//范围:1~MAX_DEVICE,不同的终端或者协调器，要修改此值
uint8 deviceId = 1;
DEVICES mDevice[MAX_DEVICE];

/*********************************************************************
 * LOCAL FUNCTIONS
 */

static void SampleApp_ProcessMSGCmd( afIncomingMSGPacket_t *pkt );
void SampleApp_CallBack(uint8 port, uint8 event); 
static void SampleApp_Send_ADC_Message( void );
static void floatToStr(float vol, char *result, int maxLen);
static void reverse(char *str, int len);
static void intToStr(int num, char *str, int *index);
void SendMsgToShortAddr(uint8* buff, uint8 len, uint16 addr);
void SendShortAddrToCoor();
void SendAckToCoordinator(void);


#define SAMPLEAPP_CMD_TRIGGER_ADC 0x01  // 触发ADC采集的指令
#define SAMPLEAPP_COORDINATOR 0x0000    // 协调器短地址
#define MAX_CONNECTED_DEVICES 10        // 最大连接设备数
#define CMD_SEND_INTERVAL 5             // 指令发送间隔(ms)
#define RESPONSE_TIMEOUT_MS 1000         // 响应超时时间(ms)


static uint8 connectedDevices[MAX_CONNECTED_DEVICES];  // 存储已连接设备ID
static uint8 deviceCount = 0;                          // 已连接设备数量
static uint8 currentDeviceIndex = 0;                   // 当前轮询的设备索引
static uint8 isCoordinator = FALSE;                    // 是否为协调器
//static uint8 ADsuccess = 0;                    // 是否为协调器
static uint8 isWaitingForResponse = FALSE;             // 新增：是否在等待终端响应
static uint16 currentTargetAddr = 0;                   // 当前发送目标地址

/*********************************************************************
 * @fn      SampleApp_Init
 *
 * @brief   This is called during OSAL tasks' initialization.
 *
 * @param   task_id - the Task ID assigned by OSAL.
 *
 * @return  none
 */
void SampleApp_Init( uint8 task_id )
{
  halUARTCfg_t uartConfig;

  SampleApp_TaskID = task_id;
  SampleApp_RxSeq = 0xC3;
  SampleApp_NwkState = DEV_INIT; 
  SampleApp_TransID = 0;

  MT_UartInit();                  //串口初始化
  MT_UartRegisterTaskID(task_id); //注册串口任务
  afRegister( (endPointDesc_t *)&SampleApp_epDesc );
  RegisterForKeys( task_id );
  osal_pwrmgr_device(PWRMGR_ALWAYS_ON); 
  
    for(uint8 i=0; i<MAX_DEVICE; i++)
  {
    mDevice[i].id=i+1;//1~MAX_DEVICE
    mDevice[i].shortAddr=0;//短地址清0
  }  

 // 初始化已连接设备列表
  memset(connectedDevices, 0, sizeof(connectedDevices));
  deviceCount = 0;
  currentDeviceIndex = 0;
  
  SampleApp_Periodic_DstAddr.addrMode = (afAddrMode_t)AddrBroadcast;//广播
  SampleApp_Periodic_DstAddr.endPoint = SAMPLEAPP_ENDPOINT;
  SampleApp_Periodic_DstAddr.addr.shortAddr = 0xFFFF;

  // Setup for the flash command's destination address - Group 1
  SampleApp_Flash_DstAddr.addrMode = (afAddrMode_t)afAddrGroup;//组播
  SampleApp_Flash_DstAddr.endPoint = SAMPLEAPP_ENDPOINT;
  SampleApp_Flash_DstAddr.addr.shortAddr = SAMPLEAPP_FLASH_GROUP;
  
  SampleApp_P2P_DstAddr.addrMode = (afAddrMode_t)Addr16Bit; //点播 
  SampleApp_P2P_DstAddr.endPoint = SAMPLEAPP_ENDPOINT; 
  SampleApp_P2P_DstAddr.addr.shortAddr = 0x0000;            //发给协调器

  
}

/*********************************************************************
 * @fn      SampleApp_ProcessEvent
 *
 * @brief   Generic Application Task event processor.
 *
 * @param   task_id  - The OSAL assigned task ID.
 * @param   events   - Bit map of events to process.
 *
 * @return  Event flags of all unprocessed events.
 */
UINT16 SampleApp_ProcessEvent( uint8 task_id, UINT16 events )
{
  (void)task_id;  // Intentionally unreferenced parameter
 
  
  if ( events & SYS_EVENT_MSG )
  {
    afIncomingMSGPacket_t *MSGpkt;

    while ( (MSGpkt = (afIncomingMSGPacket_t *)osal_msg_receive( SampleApp_TaskID )) )
    {
      switch ( MSGpkt->hdr.event )
      {
      case AF_INCOMING_MSG_CMD:
        SampleApp_ProcessMSGCmd( MSGpkt );
        break;
        
      case ZDO_STATE_CHANGE:
        SampleApp_NwkState = (devStates_t)(MSGpkt->hdr.status);
        if (SampleApp_NwkState == DEV_ZB_COORD)
        {
            // 标识当前设备为协调器
            isCoordinator = TRUE;
            HalUARTWrite(0, "Coordinator started\r\n", 20);
            
            // 启动设备轮询定时器
            osal_start_timerEx( SampleApp_TaskID,
                             SAMPLEAPP_POLL_DEVICES_EVT,
                              CMD_SEND_INTERVAL );
        }
        else if ((SampleApp_NwkState == DEV_ROUTER) || 
                 (SampleApp_NwkState == DEV_END_DEVICE))
        {
            // 终端设备入网后发送自身ID给协调器
            SendShortAddrToCoor();
            osal_pwrmgr_device(PWRMGR_ALWAYS_ON);
        }
        else
        {
        }
        break;


      default:
        break;
      }

      osal_msg_deallocate( (uint8 *)MSGpkt );
    }

    return ( events ^ SYS_EVENT_MSG );
  }

  // 协调器轮询设备事件
  if ( events & SAMPLEAPP_POLL_DEVICES_EVT && isCoordinator )
  {
    if (deviceCount > 0 && !isWaitingForResponse)
    //if (deviceCount > 0 )
    {
      // 发送ADC采集指令给当前设备
      uint8 cmd = SAMPLEAPP_CMD_TRIGGER_ADC;
      uint16 targetAddr = 0;
      //ADsuccess = 0;
      
      // 查找当前设备的短地址
      for(uint8 i=0; i<MAX_DEVICE; i++)
      {
        if(mDevice[i].id == connectedDevices[currentDeviceIndex])
        {
          targetAddr = mDevice[i].shortAddr;
          break;
        }
      }
      
      // 发送指令
      if(targetAddr != 0)
      {
        char log[32];
        char send[] = "sended\r\n";
        sprintf(log, "Sending ADC cmd to device %d\r\n", connectedDevices[currentDeviceIndex]);
        HalUARTWrite(0, log, strlen(log));
        SendMsgToShortAddr(&cmd, 1, targetAddr);
        //HalUARTWrite(0, send, strlen(send));
        isWaitingForResponse = TRUE;  // 标记为等待响应状态
        currentTargetAddr = targetAddr;  // 保存当前目标地址
        
        // 启动响应超时定时器
        osal_start_timerEx(SampleApp_TaskID, SAMPLEAPP_RESPONSE_TIMEOUT_EVT, RESPONSE_TIMEOUT_MS);
      }
      
      // 更新索引，循环轮询
     currentDeviceIndex = (currentDeviceIndex + 1) % deviceCount;
    }
    
    // 重新启动定时器
      osal_start_timerEx( SampleApp_TaskID,
                       SAMPLEAPP_POLL_DEVICES_EVT,
                       CMD_SEND_INTERVAL );
    
    return (events ^ SAMPLEAPP_POLL_DEVICES_EVT);
  }
  
  // 触发下一个设备轮询
  //if (events & SAMPLEAPP_NEXT_DEVICE_EVT && isCoordinator)
  //{
    // 切换到下一个设备
    //currentDeviceIndex = (currentDeviceIndex + 1) % deviceCount;
    // 触发下一次轮询
    //osal_start_timerEx(SampleApp_TaskID, SAMPLEAPP_POLL_DEVICES_EVT, 5);  // 短延迟后轮询下一个
    //return (events ^ SAMPLEAPP_NEXT_DEVICE_EVT);
  //}

  // 响应超时事件处理
  if (events & SAMPLEAPP_RESPONSE_TIMEOUT_EVT && isCoordinator)
  {
    if (isWaitingForResponse)
    {
      // 超时处理
      char log[64];
      sprintf(log, "Response timeout from device at address 0x%X\r\n", currentTargetAddr);
      HalUARTWrite(0, log, strlen(log));
      
      // 重置等待状态，继续轮询
      isWaitingForResponse = FALSE;
      currentTargetAddr = 0;
      
      // 继续轮询下一个设备
      currentDeviceIndex = (currentDeviceIndex + 1) % deviceCount;
    }
    
    return (events ^ SAMPLEAPP_RESPONSE_TIMEOUT_EVT);
  }

  return ( 0 );  // Discard unknown events.
}

/*********************************************************************
 * @fn      SerialApp_ProcessMSGCmd
 *
 * @brief   Data message processor callback. This function processes
 *          any incoming data - probably from other devices. Based
 *          on the cluster ID, perform the intended action.
 *
 * @param   pkt - pointer to the incoming message packet
 *
 * @return  TRUE if the 'pkt' parameter is being used and will be freed later,
 *          FALSE otherwise.
 */
void SampleApp_ProcessMSGCmd( afIncomingMSGPacket_t *pkt )
{
  uint8 buff[64]={0};
  char addrBuf[6] = {0};

  switch ( pkt->clusterId )
  {
    case SAMPLEAPP_P2P_CLUSTERID: 
      {
        // 协调器接收终端发送的ADC数据
        if(isCoordinator)
        {
          uint16 srcShortAddr = pkt->srcAddr.addr.shortAddr;
          sprintf(addrBuf, "0x%X", srcShortAddr);

          HalUARTWrite(0, "Received data from ", 18);
          HalUARTWrite(0, addrBuf, osal_strlen(addrBuf));
          HalUARTWrite(0, ": ", 2);
          HalUARTWrite(0, pkt->cmd.Data, pkt->cmd.DataLength);
          HalUARTWrite(0, "\r\n", 2);
         
          // 取消超时定时器
          osal_stop_timerEx(SampleApp_TaskID, SAMPLEAPP_RESPONSE_TIMEOUT_EVT);
          isWaitingForResponse = FALSE;
          currentTargetAddr = 0;
          //osal_start_timerEx(SampleApp_TaskID, SAMPLEAPP_NEXT_DEVICE_EVT, 5);  // 短延迟后处理下一个
        }
      }
      break;

    case SAMPLEAPP_FLASH_CLUSTERID:
      // 终端接收协调器的ADC采集指令
      if(pkt->cmd.Data[0] == SAMPLEAPP_CMD_TRIGGER_ADC)
      {
        SendAckToCoordinator();
        // 执行ADC采集并发送给协调器
        SampleApp_Send_ADC_Message();
      }
      break;
    
    case SAMPLEAPP_ADDR_CLUSTERID:
      // 协调器处理终端发送的ID和地址信息
      if(isCoordinator)
      {
        uint8 deviceId = pkt->cmd.Data[0];
        uint16 shortAddr = BUILD_UINT16(pkt->cmd.Data[1], pkt->cmd.Data[2]);
        
        // 存储设备信息
        for(uint8 i=0; i<MAX_DEVICE; i++)
        {
          if(mDevice[i].id == deviceId)
          {
            mDevice[i].shortAddr = shortAddr;
            
            // 如果是新设备，添加到已连接设备列表
            bool isNewDevice = TRUE;
            for(uint8 j=0; j<deviceCount; j++)
            {
              if(connectedDevices[j] == deviceId)
              {
                isNewDevice = FALSE;
                break;
              }
            }
            
            if(isNewDevice && deviceCount < MAX_CONNECTED_DEVICES)
            {
              connectedDevices[deviceCount++] = deviceId;
              char log[32];
              sprintf(log, "New device connected: %d\r\n", deviceId);
              HalUARTWrite(0, log, strlen(log));
            }
            break;
          }
        }
      }
      break;
      
          // 新增：处理终端发送的确认消息
    case SAMPLEAPP_ACK_CLUSTERID:
      if(isCoordinator)
      {
        uint16 srcShortAddr = pkt->srcAddr.addr.shortAddr;
        sprintf(addrBuf, "0x%X", srcShortAddr);
        HalUARTWrite(0, "Received ACK from ", 17);
        HalUARTWrite(0, addrBuf, osal_strlen(addrBuf));
        HalUARTWrite(0, "\r\n", 2);
      }
      break;

    default:
      break;
  }
}


/*********************************************************************
 * @fn      SampleApp_CallBack
 *
 * @brief   Send data OTA.
 *
 * @param   port - UART port.
 * @param   event - the UART port event flag.
 *
 * @return  none
 */
void SampleApp_CallBack(uint8 port, uint8 event)
{
  (void)port;

  if ((event & (HAL_UART_RX_FULL | HAL_UART_RX_ABOUT_FULL | HAL_UART_RX_TIMEOUT)) &&
#if SAMPLE_APP_LOOPBACK
      (SampleApp_TxLen < SAMPLE_APP_TX_MAX))
#else
      !SampleApp_TxLen)
#endif
  {
    SampleApp_TxLen += HalUARTRead(SAMPLE_APP_PORT, SampleApp_TxBuf+SampleApp_TxLen+1,
                                                      SAMPLE_APP_TX_MAX-SampleApp_TxLen);
  }
}


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

/*********************************************************************
 * @fn      SampleApp_Send_ADC_Message
 *
 * @brief   point to point.
 *
 * @param   none
 *
 * @return  none
 */
void SampleApp_Send_ADC_Message( void )
{
  byte str_adc[64]={0};
  //char *str_adc = "V:";
  float voltages[ADC_CHANNEL_COUNT] = {0.0};  // 存储各通道电压
  uint16 adcValues[ADC_CHANNEL_COUNT] = {0}; // 存储各通道原始值 
  byte len=19;
  //osal_memset(str_adc, ' ', 63);
  
  for (uint8 i = 0; i < ADC_CHANNEL_COUNT; i++) 
  {
    // 读取ADC值（参考电压使用AVDD，即3.3V）
    char str_vol[20] = {0};
    adcValues[i] = HalAdcRead(adcChannels[i], HAL_ADC_RESOLUTION_14);
    if(adcValues[i]>=8192)
    {
      sprintf(str_adc,"error\r\n");
    }
    else
    {// 计算电压（14位ADC，最大值8192）
      voltages[i] = (float)(adcValues[i] * 3.3)/ 8192.0;
      floatToStr(voltages[i], str_vol, sizeof(str_vol));
      strcat(str_vol,"\r\n");
      strcat(str_adc, str_vol);
      //str_adc = concatDynamic(str_adc, str_vol);
    }
  }


  //for (uint8_t i = 0; i < ADC_CHANNEL_COUNT; i++) 
  //{
    // 格式化当前通道数据并追加到字符串
    // 格式："Vx:1.234 "（x为通道号，保留3位小数）
    //strLen += sprintf(&str_adc[strLen], "V%d:%.3f ", 
    //                 (adcChannels[i] + 1),  // 通道号从1开始显示
      //               voltages[i]);
  //}

  //
  len=osal_strlen(str_adc);//计算长度
  
  // 确保数据发送给协调器
  SampleApp_P2P_DstAddr.addr.shortAddr = SAMPLEAPP_COORDINATOR;

  if ( AF_DataRequest( &SampleApp_P2P_DstAddr, &SampleApp_epDesc,
                       SAMPLEAPP_P2P_CLUSTERID,
                       len,
                       str_adc,
                       &SampleApp_MsgID,
                       AF_DISCV_ROUTE,
                       AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )
  {
   // free(str_adc);  
  }
  else
  {
   //free(str_adc);  // Error occurred in request to send.
  }
}

void SendShortAddrToCoor()
{
    char buff[5]={0};
    afAddrType_t DstAddr;
    uint16 addr=NLME_GetShortAddr();


    //点播,协调器的短地址为0
    DstAddr.addrMode = (afAddrMode_t)Addr16Bit;
    DstAddr.endPoint = SAMPLEAPP_ENDPOINT;
    DstAddr.addr.shortAddr = 0x0;

    //填发送的数据
    buff[0]=deviceId;//第一个字节，终端编号
    buff[1]=LO_UINT16(addr);//第二个字节，终端短地址低字节
    buff[2]=HI_UINT16(addr);//第三个字节，终端短地址高字节
    //
    
    //发送
    if ( AF_DataRequest( &DstAddr, &SampleApp_epDesc,
                       SAMPLEAPP_ADDR_CLUSTERID,
                       3,
                       buff,
                       &SampleApp_TransID,
                       AF_DISCV_ROUTE,
                       AF_DEFAULT_RADIUS ) == afStatus_SUCCESS )
    {
    }
    else
    {
    // Error occurred in request to send.
    }
}

void SendAckToCoordinator(void)
{
    uint8 ackMsg[] = "Received"; // 确认消息内容
    afAddrType_t dstAddr;
    
    dstAddr.addrMode = Addr16Bit;
    dstAddr.endPoint = SAMPLEAPP_ENDPOINT;
    dstAddr.addr.shortAddr = SAMPLEAPP_COORDINATOR; // 目标为协调器
    
    if ( AF_DataRequest(&dstAddr, &SampleApp_epDesc,
                  SAMPLEAPP_ACK_CLUSTERID,
                  sizeof(ackMsg) - 1, // 不包含字符串结束符
                  ackMsg,
                  &SampleApp_TransID,
                  AF_DISCV_ROUTE,
                  AF_DEFAULT_RADIUS) == afStatus_SUCCESS )
    {
    }
    else
    { // Error occurred in request to send.
    }
}

const char* afStatusStr[] = {
  "afStatus_SUCCESS",          // 0: 成功
  "afStatus_FAILED",           // 1: 失败
  "afStatus_INVALID_PARAMETER",// 2: 参数无效
  "afStatus_NO_ROUTE",         // 3: 无路由
  "afStatus_NO_RESOURCES",     // 4: 资源不足
  "afStatus_NOT_SUPPORTED",    // 5: 不支持
  "afStatus_TIMEOUT"           // 6: 超时（根据实际枚举扩展）
  // ... 其他状态码
};

void SendMsgToShortAddr(uint8* buff, uint8 len, uint16 addr)
{
    afAddrType_t DstAddr;
    SampleApp_TransID++; 
    
    //点播
    DstAddr.addrMode = (afAddrMode_t)Addr16Bit;
    DstAddr.endPoint = SAMPLEAPP_ENDPOINT;
    DstAddr.addr.shortAddr = addr;
    
    afStatus_t status = AF_DataRequest( &DstAddr, &SampleApp_epDesc,
                       SAMPLEAPP_FLASH_CLUSTERID,
                       len,
                       buff,
                       &SampleApp_TransID,
                       AF_DISCV_ROUTE,
                       AF_DEFAULT_RADIUS );

    // 准备打印缓冲区（存储状态码和描述）
    char uartBuf[64];
    uint16 bufLen;
    

    //发送
    if ( status == afStatus_SUCCESS )
    {
        char send[] = "sended\r\n";
        HalUARTWrite(0, send, strlen(send)); 
    }
    else
    {
        if (status < sizeof(afStatusStr)/sizeof(afStatusStr[0])) 
        {
          sprintf(uartBuf, "AF_DataRequest status: %d (%s)\r\n", status, afStatusStr[status]);
        } 
        else 
        {
          sprintf(uartBuf, "AF_DataRequest status: %d (Unknown)\r\n", status);
        }
        HalUARTWrite(0, (uint8*)uartBuf, strlen(uartBuf));
    }
}

// 共用体
union FloatUnion {
    float f;
    unsigned char bytes[4]; // float占4字节
};

// 反转字符串
void reverse(char *str, int len) {
    int i = 0, j = len - 1;
    char temp;
    while (i < j) {
        temp = str[i];
        str[i] = str[j];
        str[j] = temp;
        i++;
        j--;
    }
}

// 整数转换
void intToStr(int num, char *str, int *index) {
    int i = 0;
    // 处理0的特殊情况
    if (num == 0) {
        str[(*index)++] = '0';
        return;
    }
    // 提取每一位数字
    while (num != 0) {
        int rem = num % 10;
        str[i++] = (rem > 9) ? (rem - 10) + 'a' : rem + '0';
        num = num / 10;
    }
    // 反转得到正确顺序
    reverse(str + *index, i);
    *index += i;
}

// 浮点数转为字符串
void floatToStr(float vol, char *result, int maxLen) {
    union FloatUnion u;
    u.f = vol;
    int index = 0;

    // 检查缓冲区是否足够
    if (maxLen < 10) { 
        result[0] = '\0';
        return;
    }

    // 处理符号位
    if (vol < 0) {
        result[index++] = '-';
        vol = -vol; // 转为正数处理
    }

    // 分离整数部分和小数部分
    int intPart = (int)vol;
    float fracPart = vol - intPart;

    // 转换整数部分
    intToStr(intPart, result, &index);

    // 添加小数点
    result[index++] = '.';

    // 转换小数部分（保留3位）
    for (int i = 0; i < 3; i++) {
        fracPart *= 10;
        int fracDigit = (int)fracPart;
        result[index++] = fracDigit + '0';
        fracPart -= fracDigit;
    }

    // 添加字符串结束符
    result[index] = '\0';
}

Zigbee 和 Thread 论坛

moyu moyu — Thu, 28 Aug 2025 06:46:21 GMT

Part Number: CC2538

在程序代码中加入Flash擦除程序代码，使用下载器下载程序可以正常运行，但是重新上电之后，程序刚开始运行便直接卡死。

代码部分截图如下：

不加擦除代码，程序不会出现该情况。

只要加了擦除的代码，重新上电后便出现程序卡死的情况

CC2538: 加入flash擦除程序代码会卡死

moyu moyu — Thu, 28 Aug 2025 06:45:10 GMT

Part Number: CC2538

在程序代码中加入Flash擦除程序代码，使用下载器下载程序可以正常运行，但是重新上电之后，程序刚开始运行便直接卡死。

代码部分截图如下：

不加擦除代码，程序不会出现该情况。

只要加了擦除的代码，重新上电后便出现程序卡死的情况

LAUNCHXL-CC1352P: cc1352p终端加入不了cc2530协调器

ben li — Tue, 26 Aug 2025 01:27:41 GMT

Part Number: LAUNCHXL-CC1352P
Other Parts Discussed in Thread: CC2530, Z-STACK, CC1352P

cc2530协调器使用的是z-stack mesh 1.0.启用安全设置。配置预设置的网络密钥和全局秘钥。cc1352p终端使用的是z-stack 3.0连接不上都设置了对应的秘钥。

这是使用ubiqua抓取的流程。

CC2531: Can CC2531 use cc2531 code?

A Q — Mon, 18 Aug 2025 06:18:49 GMT

Part Number: CC2531
Other Parts Discussed in Thread: CC2530

I downloaded the cc2530 code to cc2531 and found a problem. I need to touch the chip with my hand for it to run.

CC2652P7: 关于CC2652通讯失败问题

wei lincheng — Thu, 07 Aug 2025 05:33:05 GMT

Part Number: CC2652P7
Other Parts Discussed in Thread: CC1352P7, SYSCONFIG

你好：

我将CC2652P7设置发送功率为20db 。zc和zed数据在距离较近（10m以内）时可以通讯上，距离较远时通讯不上，但是使用zigbee抓包可以看到数据请求，这是因为什么？抓包数据如下

器件无法工作

guangyu he — Wed, 06 Aug 2025 03:06:33 GMT

Part Number: BQ79616

BQ79616 的TSREF端口没有5V电压，其余端口电压都有，请问这种一般是什么故障

CC2340R5: 进入待机模式的条件是什么？

shan mu — Mon, 04 Aug 2025 01:35:29 GMT

Part Number: CC2340R5

在CC2340R5使用CCSV20版本开发，在syscfg下将时钟源配置为LF XOSC ，硬件上如果只有48MHZ，但没有32.768kHZ能否进入待机模式？

CC2340R5: 如何查看时钟频率和时钟树？

shan mu — Tue, 29 Jul 2025 01:20:02 GMT

Part Number: CC2340R5

如何查看时钟频率和时钟树？在CCSV20版本中，如何查看当前时钟的频率，为什么开启LGPtimer定时器使用LGPT3进行1s定时后，就无法进入待机模式下，会一直处于工作模式，LGPtimer这个定时器不是低功耗定时器吗？

CC2340R5: 在zigbee保持连接的情况下，最低功耗是多少？

shan mu — Mon, 28 Jul 2025 01:22:00 GMT

Part Number: CC2340R5
Other Parts Discussed in Thread: SYSCONFIG

在zigbee保持连接的情况下，最低功耗是多少？，待机模式下，zigbee连接能不断开吗？

CC2340R5: 如何使用LGPtimer定时1s

shan mu — Fri, 25 Jul 2025 02:47:03 GMT

Part Number: CC2340R5

void time_Init()

{

LGPTimerLPF3_Handle lgptHandle;

LGPTimerLPF3_Params params;

uint32_t counterTarget;

// Initialize parameters and assign callback function to be used

LGPTimerLPF3_Params_init(&params);

params.hwiCallbackFxn = timerCallback;

params.prescalerDiv = 0;

// Open driver

lgptHandle = LGPTimerLPF3_open(0, &params);

// Set counter target

counterTarget = 48000000 - 1; // 1 s with a system clock of 48 MHz

LGPTimerLPF3_setInitialCounterTarget(lgptHandle, counterTarget, true);

// Enable counter target interrupt

LGPTimerLPF3_enableInterrupt(lgptHandle, LGPTimerLPF3_INT_TGT);

// Start counter in count-up-periodic mode

LGPTimerLPF3_start(lgptHandle, LGPTimerLPF3_CTL_MODE_UP_PER);

}

我想要实现1s计一次数，但是用上面的方式却还是1ms是为什么

CC2340R5: 如何在另一个任务中发送数据

shan mu — Thu, 24 Jul 2025 08:43:36 GMT

Part Number: CC2340R5

我在onoff_switch示例中创建了一个新的任务，想要通过这个新的任务实现

send_aps_payload(param);的发送，但是我发现并没有作用，应该如何操作才能在另一个任务中发送。

void *sendThread(void *arg0,zb_uint8_t param)

{

/* Call driver init functions */

GPIO_init();

while (1)

{

// sleep(time);

vTaskDelay(5000);

send_aps_payload(param);

}

CC2340R5: 如何在zigbee示例中创建新的任务

shan mu — Fri, 18 Jul 2025 08:36:11 GMT

Part Number: CC2340R5

如何在onoff_light这个示例下，通过FRTOS创建一个新的任务，能和zigbee任务并存

CC2340R5: zigbee的传输大小

shan mu — Fri, 04 Jul 2025 08:32:44 GMT

Part Number: CC2340R5

您好，我想了解一下，zigbee终端向协调器发送数据包，一包能发多少字节数据，一秒能发多少包？丢包率如何？，想要稳定发送大量数据的最大限制是一秒发几包一包多少字节？

CC2652P: CC2652使用例程RFpacketsTX在runCmd时永久阻塞

?? ? — Sat, 28 Jun 2025 03:03:57 GMT

Part Number: CC2652P

导入官方例程，我想直接修改原专用rf协议为802.15.4，直接在syscfg中修改，然后在mainthread中修改对应的结构体名称

运行时程序卡在runcmd，调试发现一直等待pendcmd中的wait for semaphore函数中，

是否修改协议还需要在其他地方修改，postcmd能够发送，但改为postcmd后每次运行之后只发出一个数据包

麻烦帮我找一下原因或者修改协议还有什么需要修改的，感谢

CC2340R5: Does the SimpleLink™︎ Low Power F3 SDK (v9.11.00.18) support custom device development?

Liu Jay — Wed, 25 Jun 2025 01:33:30 GMT

Part Number: CC2340R5

Hello, I noticed that the SimpleLink™ Low Power F3 SDK (v9.11.00.18) provides the function ZB_ZCL_DECLARE_CUSTOM_ATTR_CLUSTER_ATTRIB_LIST() for declaring custom cluster attributes. However, I cannot find corresponding functions for binding clusters, configuring endpoints, or declaring device contexts.

I would like to confirm:

Does this SDK natively support fully custom devices (creating proprietary device types from scratch), or is it limited to extending standard devices with additional cluster attributes?
If full customization is supported, must I manually implement the binding of clusters, endpoint configuration, and context declaration?
Could you please specify which API functions would be required for such implementation?

Additionally, the approach demonstrated in TI's 'Zigbee Custom Device Types' tutorial (SimpleLink Academy for CC23xx) does not meet my requirements, as I need to define a device outside standard clusters to implement complex operations. Your expert guidance would be greatly appreciated.