/* USER CODE BEGIN Header */
/**
******************************************************************************
* File Name : App/app_zigbee.c
* Description : Zigbee Application.
******************************************************************************
* @attention
*
*
© Copyright (c) 2020 STMicroelectronics.
* All rights reserved.
*
* This software component is licensed by ST under Ultimate Liberty license
* SLA0044, the "License"; You may not use this file except in compliance with
* the License. You may obtain a copy of the License at:
* www.st.com/SLA0044
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "app_common.h"
#include "app_entry.h"
#include "dbg_trace.h"
#include "app_zigbee.h"
#include "zigbee_interface.h"
#include "shci.h"
#include "stm_logging.h"
#include "app_conf.h"
#include "stm32wbxx_core_interface_def.h"
#include "zigbee_types.h"
#include "stm32_seq.h"
/* Private includes -----------------------------------------------------------*/
#include
#include "zcl/zcl.h"
#include "zcl/general/zcl.onoff.h"
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */
/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
/* USER CODE END PTD */
/* Private defines -----------------------------------------------------------*/
#define APP_ZIGBEE_STARTUP_FAIL_DELAY 500U
#define CHANNEL 13
#define SW1_ENDPOINT 17
#define HW_TS_SERVER_1S_NB_TICKS (1*1000*1000/CFG_TS_TICK_VAL) /* 1s */
/* USER CODE BEGIN PD */
#define SW1_GROUP_ADDR 0x0001
/* USER CODE END PD */
/* Private macros ------------------------------------------------------------*/
/* USER CODE BEGIN PM */
/* USER CODE END PM */
/* External definition -------------------------------------------------------*/
enum ZbStatusCodeT ZbStartupWait(struct ZigBeeT *zb, struct ZbStartupT *config);
enum ZbStatusCodeT ZbStartupRejoinWait(struct ZigBeeT *zb);
/* USER CODE BEGIN ED */
/* USER CODE END ED */
/* Private function prototypes -----------------------------------------------*/
static void APP_ZIGBEE_StackLayersInit(void);
static void APP_ZIGBEE_ConfigEndpoints(void);
static void APP_ZIGBEE_NwkForm(void);
static void APP_ZIGBEE_TraceError(const char *pMess, uint32_t ErrCode);
static void APP_ZIGBEE_CheckWirelessFirmwareInfo(void);
static void Wait_Getting_Ack_From_M0(void);
static void Receive_Ack_From_M0(void);
static void Receive_Notification_From_M0(void);
/* USER CODE BEGIN PFP */
static void APP_ZIGBEE_SW1_Process(void);
static void APP_ZIGBEE_ConfigGroupAddr(void);
/* USER CODE END PFP */
/* Private variables ---------------------------------------------------------*/
static TL_CmdPacket_t *p_ZIGBEE_otcmdbuffer;
static TL_EvtPacket_t *p_ZIGBEE_notif_M0_to_M4;
static TL_EvtPacket_t *p_ZIGBEE_request_M0_to_M4;
static __IO uint32_t CptReceiveNotifyFromM0 = 0;
static __IO uint32_t CptReceiveRequestFromM0 = 0;
PLACE_IN_SECTION("MB_MEM1") ALIGN(4) static TL_ZIGBEE_Config_t ZigbeeConfigBuffer;
PLACE_IN_SECTION("MB_MEM2") ALIGN(4) static TL_CmdPacket_t ZigbeeOtCmdBuffer;
PLACE_IN_SECTION("MB_MEM2") ALIGN(4) static uint8_t ZigbeeNotifRspEvtBuffer[sizeof(TL_PacketHeader_t) + TL_EVT_HDR_SIZE + 255U];
PLACE_IN_SECTION("MB_MEM2") ALIGN(4) static uint8_t ZigbeeNotifRequestBuffer[sizeof(TL_PacketHeader_t) + TL_EVT_HDR_SIZE + 255U];
struct zigbee_app_info {
bool has_init;
struct ZigBeeT *zb;
enum ZbStartType startupControl;
enum ZbStatusCodeT join_status;
uint32_t join_delay;
bool init_after_join;
struct ZbZclClusterT *onOff_client_1;
};
static struct zigbee_app_info zigbee_app_info;
/* USER CODE BEGIN PV */
/* USER CODE END PV */
enum zb_msg_filter_rc app_zb_msg_filter_cb(struct ZigBeeT *zb, uint32_t id, void *msg, void *cbarg);
static struct ZbMsgFilterT *zb_msg_filter=NULL;
static uint8_t TS_ID1;
/* Functions Definition ------------------------------------------------------*/
/**
* @brief Zigbee Message Filter callback
* @param zb, id, msg, arg
* @retval zb_msg_filter_rc
*/
enum zb_msg_filter_rc app_zb_msg_filter_cb(struct ZigBeeT *zb, uint32_t id, void *msg, void *arg)
{
if (id == ZB_MSG_FILTER_STATUS_IND) {
struct ZbNlmeNetworkStatusIndT *ind = msg;
switch (ind->status) {
case ZB_NWK_STATUS_CODE_PARENT_LINK_FAILURE:
/* Set a flag for application to attempt to rejoin network */
/* Since we will handle this in the application, tell stack
* to not process this message further by returning ZB_MSG_DISCARD. */
APP_DBG("Network Lost / Parent Link Failure");
HW_TS_Start(TS_ID1, 10*HW_TS_SERVER_1S_NB_TICKS);
return ZB_MSG_DISCARD;
default:
break;
}
}
return ZB_MSG_CONTINUE;
}
/**
* @brief Zigbee Rejoin Callback
* @param None
* @retval None
*/
static void APP_ZIGBEE_Rejoin_cb(void){
APP_DBG("Rejoin Callback");
if(ZbStartupRejoinWait(zigbee_app_info.zb) != ZB_STATUS_SUCCESS) {
/* Handle error. Try to rejoin again later? */
APP_DBG("Rejoin failure / Retry in 10 seconds");
HW_TS_Start(TS_ID1, 10*HW_TS_SERVER_1S_NB_TICKS);
}
else
{
APP_DBG("Rejoin success");
}
return;
}
/**
* @brief Zigbee application initialization
* @param None
* @retval None
*/
void APP_ZIGBEE_Init(void)
{
SHCI_CmdStatus_t ZigbeeInitStatus;
APP_DBG("APP_ZIGBEE_Init");
/* Check the compatibility with the Coprocessor Wireless Firmware loaded */
APP_ZIGBEE_CheckWirelessFirmwareInfo();
/* Register cmdbuffer */
APP_ZIGBEE_RegisterCmdBuffer(&ZigbeeOtCmdBuffer);
/* Init config buffer and call TL_ZIGBEE_Init */
APP_ZIGBEE_TL_INIT();
/* Register task */
/* Create the different tasks */
UTIL_SEQ_RegTask(1U << (uint32_t)CFG_TASK_NOTIFY_FROM_M0_TO_M4, UTIL_SEQ_RFU, APP_ZIGBEE_ProcessNotifyM0ToM4);
UTIL_SEQ_RegTask(1U << (uint32_t)CFG_TASK_REQUEST_FROM_M0_TO_M4, UTIL_SEQ_RFU, APP_ZIGBEE_ProcessRequestM0ToM4);
/* Task associated with network creation process */
UTIL_SEQ_RegTask(1U << CFG_TASK_ZIGBEE_NETWORK_FORM, UTIL_SEQ_RFU, APP_ZIGBEE_NwkForm);
/* USER CODE BEGIN APP_ZIGBEE_INIT */
/* Task associated with push button SW1 */
UTIL_SEQ_RegTask(1U << CFG_TASK_BUTTON_SW1, UTIL_SEQ_RFU, APP_ZIGBEE_SW1_Process);
/* USER CODE END APP_ZIGBEE_INIT */
/* Start the Zigbee on the CPU2 side */
ZigbeeInitStatus = SHCI_C2_ZIGBEE_Init();
/* Prevent unused argument(s) compilation warning */
UNUSED(ZigbeeInitStatus);
/* Timer associated with Rejoin Process */
HW_TS_Create(CFG_TIM_ZIGBEE_APP_REJOIN, &TS_ID1, hw_ts_SingleShot, APP_ZIGBEE_Rejoin_cb);
/* Initialize Zigbee stack layers */
APP_ZIGBEE_StackLayersInit();
} /* APP_ZIGBEE_Init */
/**
* @brief Initialize Zigbee stack layers
* @param None
* @retval None
*/
static void APP_ZIGBEE_StackLayersInit(void)
{
APP_DBG("APP_ZIGBEE_StackLayersInit");
zigbee_app_info.zb = ZbInit(0U, NULL, NULL);
assert(zigbee_app_info.zb != NULL);
/* Create the endpoint and cluster(s) */
APP_ZIGBEE_ConfigEndpoints();
/* USER CODE BEGIN APP_ZIGBEE_StackLayersInit */
BSP_LED_Off(LED_RED);
BSP_LED_Off(LED_GREEN);
BSP_LED_Off(LED_BLUE);
/* USER CODE END APP_ZIGBEE_StackLayersInit */
/* Configure the joining parameters */
zigbee_app_info.join_status = (enum ZbStatusCodeT) 0x01; /* init to error status */
zigbee_app_info.join_delay = HAL_GetTick(); /* now */
zigbee_app_info.startupControl = ZbStartTypeJoin;
/* Register callback to STATUS_IND event to detect PARENT LINK FAILURE */
zb_msg_filter = ZbMsgFilterRegister(zigbee_app_info.zb, ZB_MSG_FILTER_STATUS_IND, ZB_MSG_INTERNAL_PRIO + 1, app_zb_msg_filter_cb, NULL);
/* Initialization Complete */
zigbee_app_info.has_init = true;
/* run the task */
UTIL_SEQ_SetTask(1U << CFG_TASK_ZIGBEE_NETWORK_FORM, CFG_SCH_PRIO_0);
} /* APP_ZIGBEE_StackLayersInit */
/**
* @brief Configure Zigbee application endpoints
* @param None
* @retval None
*/
static void APP_ZIGBEE_ConfigEndpoints(void)
{
struct ZbApsmeAddEndpointReqT req;
struct ZbApsmeAddEndpointConfT conf;
memset(&req, 0, sizeof(req));
/* Endpoint: SW1_ENDPOINT */
req.profileId = ZCL_PROFILE_HOME_AUTOMATION;
req.deviceId = ZCL_DEVICE_ONOFF_SWITCH;
req.endpoint = SW1_ENDPOINT;
ZbZclAddEndpoint(zigbee_app_info.zb, &req, &conf);
assert(conf.status == ZB_STATUS_SUCCESS);
/* OnOff client */
zigbee_app_info.onOff_client_1 = ZbZclOnOffClientAlloc(zigbee_app_info.zb, SW1_ENDPOINT);
assert(zigbee_app_info.onOff_client_1 != NULL);
ZbZclClusterEndpointRegister(zigbee_app_info.onOff_client_1);
/* USER CODE BEGIN CONFIG_ENDPOINT */
/* USER CODE END CONFIG_ENDPOINT */
} /* APP_ZIGBEE_ConfigEndpoints */
/**
* @brief Handle Zigbee network forming and joining
* @param None
* @retval None
*/
static void APP_ZIGBEE_NwkForm(void)
{
if ((zigbee_app_info.join_status != ZB_STATUS_SUCCESS) && (HAL_GetTick() >= zigbee_app_info.join_delay))
{
struct ZbStartupT config;
enum ZbStatusCodeT status;
/* Configure Zigbee Logging */
ZbSetLogging(zigbee_app_info.zb, ZB_LOG_MASK_LEVEL_5, NULL);
/* Attempt to join a zigbee network */
ZbStartupConfigGetProDefaults(&config);
/* Set the centralized network */
APP_DBG("Network config : APP_STARTUP_CENTRALIZED_ROUTER");
config.startupControl = zigbee_app_info.startupControl;
/* Using the default HA preconfigured Link Key */
memcpy(config.security.preconfiguredLinkKey, sec_key_ha, ZB_SEC_KEYSIZE);
config.channelList.count = 1;
config.channelList.list[0].page = 0;
config.channelList.list[0].channelMask = 1 << CHANNEL; /*Channel in use */
/*Force SED config */
config.capability &= ~MCP_ASSOC_CAP_DEV_TYPE;
config.capability &= ~MCP_ASSOC_CAP_RXONIDLE;
config.endDeviceTimeout=1; /* Set End Device Timeout to 30 seconds */
/* Using ZbStartupWait (blocking) */
status = ZbStartupWait(zigbee_app_info.zb, &config);
APP_DBG("ZbStartup Callback (status = 0x%02x)", status);
zigbee_app_info.join_status = status;
if (status == ZB_STATUS_SUCCESS) {
/* USER CODE BEGIN 0 */
zigbee_app_info.join_delay = 0U;
zigbee_app_info.init_after_join = true;
BSP_LED_On(LED_BLUE);
}
else
{
/* USER CODE END 0 */
APP_DBG("Startup failed, attempting again after a short delay (%d ms)", APP_ZIGBEE_STARTUP_FAIL_DELAY);
zigbee_app_info.join_delay = HAL_GetTick() + APP_ZIGBEE_STARTUP_FAIL_DELAY;
}
}
/* If Network forming/joining was not successful reschedule the current task to retry the process */
if (zigbee_app_info.join_status != ZB_STATUS_SUCCESS)
{
UTIL_SEQ_SetTask(1U << CFG_TASK_ZIGBEE_NETWORK_FORM, CFG_SCH_PRIO_0);
}
/* USER CODE BEGIN NW_FORM */
else
{
zigbee_app_info.init_after_join = false;
/* Assign ourselves to the group addresses */
APP_ZIGBEE_ConfigGroupAddr();
/* Since we're using group addressing (broadcast), shorten the broadcast timeout */
uint32_t bcast_timeout = 3;
ZbNwkSet(zigbee_app_info.zb, ZB_NWK_NIB_ID_NetworkBroadcastDeliveryTime, &bcast_timeout, sizeof(bcast_timeout));
}
/* USER CODE END NW_FORM */
} /* APP_ZIGBEE_NwkForm */
struct ZbStartupRejoinWaitInfo {
bool active;
enum ZbStatusCodeT status;
};
static void ZbStartupRejoinWaitCb(struct ZbNlmeJoinConfT *conf, void *cb_arg)
{
struct ZbStartupRejoinWaitInfo *info = cb_arg;
info->status = conf->status;
info->active = false;
UTIL_SEQ_SetEvt(EVENT_ZIGBEE_STARTUP_ENDED);
} /* ZbStartupWaitCb */
enum ZbStatusCodeT ZbStartupRejoinWait(struct ZigBeeT *zb)
{
struct ZbStartupRejoinWaitInfo *info;
enum ZbStatusCodeT status;
info = malloc(sizeof(struct ZbStartupRejoinWaitInfo));
if (info == NULL) {
return ZB_STATUS_ALLOC_FAIL;
}
memset(info, 0, sizeof(struct ZbStartupRejoinWaitInfo));
info->active = true;
status = ZbStartupRejoin(zb, ZbStartupRejoinWaitCb, info);
if (status != ZB_STATUS_SUCCESS) {
info->active = false;
return status;
}
UTIL_SEQ_WaitEvt(EVENT_ZIGBEE_STARTUP_ENDED);
status = info->status;
free(info);
return status;
} /* ZbStartupRejoinWait */
/*************************************************************
* ZbStartupWait Blocking Call
*************************************************************/
struct ZbStartupWaitInfo {
bool active;
enum ZbStatusCodeT status;
};
static void ZbStartupWaitCb(enum ZbStatusCodeT status, void *cb_arg)
{
struct ZbStartupWaitInfo *info = cb_arg;
info->status = status;
info->active = false;
UTIL_SEQ_SetEvt(EVENT_ZIGBEE_STARTUP_ENDED);
} /* ZbStartupWaitCb */
enum ZbStatusCodeT ZbStartupWait(struct ZigBeeT *zb, struct ZbStartupT *config)
{
struct ZbStartupWaitInfo *info;
enum ZbStatusCodeT status;
info = malloc(sizeof(struct ZbStartupWaitInfo));
if (info == NULL) {
return ZB_STATUS_ALLOC_FAIL;
}
memset(info, 0, sizeof(struct ZbStartupWaitInfo));
info->active = true;
status = ZbStartup(zb, config, ZbStartupWaitCb, info);
if (status != ZB_STATUS_SUCCESS) {
info->active = false;
return status;
}
UTIL_SEQ_WaitEvt(EVENT_ZIGBEE_STARTUP_ENDED);
status = info->status;
free(info);
return status;
} /* ZbStartupWait */
/**
* @brief Trace the error or the warning reported.
* @param ErrId :
* @param ErrCode
* @retval None
*/
void APP_ZIGBEE_Error(uint32_t ErrId, uint32_t ErrCode)
{
switch (ErrId) {
default:
APP_ZIGBEE_TraceError("ERROR Unknown ", 0);
break;
}
} /* APP_ZIGBEE_Error */
/*************************************************************
*
* LOCAL FUNCTIONS
*
*************************************************************/
/**
* @brief Warn the user that an error has occurred.
*
* @param pMess : Message associated to the error.
* @param ErrCode: Error code associated to the module (Zigbee or other module if any)
* @retval None
*/
static void APP_ZIGBEE_TraceError(const char *pMess, uint32_t ErrCode)
{
APP_DBG("**** Fatal error = %s (Err = %d)", pMess, ErrCode);
/* USER CODE BEGIN TRACE_ERROR */
while (1U == 1U) {
BSP_LED_Toggle(LED1);
HAL_Delay(500U);
BSP_LED_Toggle(LED2);
HAL_Delay(500U);
BSP_LED_Toggle(LED3);
HAL_Delay(500U);
}
/* USER CODE END TRACE_ERROR */
} /* APP_ZIGBEE_TraceError */
/**
* @brief Check if the Coprocessor Wireless Firmware loaded supports Zigbee
* and display associated information
* @param None
* @retval None
*/
static void APP_ZIGBEE_CheckWirelessFirmwareInfo(void)
{
WirelessFwInfo_t wireless_info_instance;
WirelessFwInfo_t *p_wireless_info = &wireless_info_instance;
if (SHCI_GetWirelessFwInfo(p_wireless_info) != SHCI_Success) {
APP_ZIGBEE_Error((uint32_t)ERR_ZIGBEE_CHECK_WIRELESS, (uint32_t)ERR_INTERFACE_FATAL);
}
else {
APP_DBG("**********************************************************");
APP_DBG("WIRELESS COPROCESSOR FW:");
/* Print version */
APP_DBG("VERSION ID = %d.%d.%d", p_wireless_info->VersionMajor, p_wireless_info->VersionMinor, p_wireless_info->VersionSub);
switch (p_wireless_info->StackType) {
case INFO_STACK_TYPE_ZIGBEE_FFD:
APP_DBG("FW Type : FFD Zigbee stack");
break;
case INFO_STACK_TYPE_ZIGBEE_RFD:
APP_DBG("FW Type : RFD Zigbee stack");
break;
default:
/* No Zigbee device supported ! */
APP_ZIGBEE_Error((uint32_t)ERR_ZIGBEE_CHECK_WIRELESS, (uint32_t)ERR_INTERFACE_FATAL);
break;
}
APP_DBG("**********************************************************");
}
} /* APP_ZIGBEE_CheckWirelessFirmwareInfo */
/*************************************************************
*
* WRAP FUNCTIONS
*
*************************************************************/
void APP_ZIGBEE_RegisterCmdBuffer(TL_CmdPacket_t *p_buffer)
{
p_ZIGBEE_otcmdbuffer = p_buffer;
} /* APP_ZIGBEE_RegisterCmdBuffer */
Zigbee_Cmd_Request_t * ZIGBEE_Get_OTCmdPayloadBuffer(void)
{
return (Zigbee_Cmd_Request_t *)p_ZIGBEE_otcmdbuffer->cmdserial.cmd.payload;
} /* ZIGBEE_Get_OTCmdPayloadBuffer */
Zigbee_Cmd_Request_t * ZIGBEE_Get_OTCmdRspPayloadBuffer(void)
{
return (Zigbee_Cmd_Request_t *)((TL_EvtPacket_t *)p_ZIGBEE_otcmdbuffer)->evtserial.evt.payload;
} /* ZIGBEE_Get_OTCmdRspPayloadBuffer */
Zigbee_Cmd_Request_t * ZIGBEE_Get_NotificationPayloadBuffer(void)
{
return (Zigbee_Cmd_Request_t *)(p_ZIGBEE_notif_M0_to_M4)->evtserial.evt.payload;
} /* ZIGBEE_Get_NotificationPayloadBuffer */
Zigbee_Cmd_Request_t * ZIGBEE_Get_M0RequestPayloadBuffer(void)
{
return (Zigbee_Cmd_Request_t *)(p_ZIGBEE_request_M0_to_M4)->evtserial.evt.payload;
}
/**
* @brief This function is used to transfer the commands from the M4 to the M0.
*
* @param None
* @return None
*/
void ZIGBEE_CmdTransfer(void)
{
Zigbee_Cmd_Request_t *cmd_req = (Zigbee_Cmd_Request_t *)p_ZIGBEE_otcmdbuffer->cmdserial.cmd.payload;
/* Zigbee OT command cmdcode range 0x280 .. 0x3DF = 352 */
p_ZIGBEE_otcmdbuffer->cmdserial.cmd.cmdcode = 0x280U;
/* Size = otCmdBuffer->Size (Number of OT cmd arguments : 1 arg = 32bits so multiply by 4 to get size in bytes)
* + ID (4 bytes) + Size (4 bytes) */
p_ZIGBEE_otcmdbuffer->cmdserial.cmd.plen = 8U + (cmd_req->Size * 4U);
TL_ZIGBEE_SendM4RequestToM0();
/* Wait completion of cmd */
Wait_Getting_Ack_From_M0();
} /* ZIGBEE_CmdTransfer */
/**
* @brief This function is called when the M0+ acknowledge the fact that it has received a Cmd
*
*
* @param Otbuffer : a pointer to TL_EvtPacket_t
* @return None
*/
void TL_ZIGBEE_CmdEvtReceived(TL_EvtPacket_t *Otbuffer)
{
/* Prevent unused argument(s) compilation warning */
UNUSED(Otbuffer);
Receive_Ack_From_M0();
} /* TL_ZIGBEE_CmdEvtReceived */
/**
* @brief This function is called when notification from M0+ is received.
*
* @param Notbuffer : a pointer to TL_EvtPacket_t
* @return None
*/
void TL_ZIGBEE_NotReceived(TL_EvtPacket_t *Notbuffer)
{
p_ZIGBEE_notif_M0_to_M4 = Notbuffer;
Receive_Notification_From_M0();
} /* TL_ZIGBEE_NotReceived */
/**
* @brief This function is called before sending any ot command to the M0
* core. The purpose of this function is to be able to check if
* there are no notifications coming from the M0 core which are
* pending before sending a new ot command.
* @param None
* @retval None
*/
void Pre_ZigbeeCmdProcessing(void)
{
UTIL_SEQ_WaitEvt(EVENT_SYNCHRO_BYPASS_IDLE);
} /* Pre_ZigbeeCmdProcessing */
/**
* @brief This function waits for getting an acknowledgment from the M0.
*
* @param None
* @retval None
*/
static void Wait_Getting_Ack_From_M0(void)
{
UTIL_SEQ_WaitEvt(EVENT_ACK_FROM_M0_EVT);
} /* Wait_Getting_Ack_From_M0 */
/**
* @brief Receive an acknowledgment from the M0+ core.
* Each command send by the M4 to the M0 are acknowledged.
* This function is called under interrupt.
* @param None
* @retval None
*/
static void Receive_Ack_From_M0(void)
{
UTIL_SEQ_SetEvt(EVENT_ACK_FROM_M0_EVT);
} /* Receive_Ack_From_M0 */
/**
* @brief Receive a notification from the M0+ through the IPCC.
* This function is called under interrupt.
* @param None
* @retval None
*/
static void Receive_Notification_From_M0(void)
{
CptReceiveNotifyFromM0++;
UTIL_SEQ_SetTask(1U << (uint32_t)CFG_TASK_NOTIFY_FROM_M0_TO_M4, CFG_SCH_PRIO_0);
}
/**
* @brief This function is called when a request from M0+ is received.
*
* @param Notbuffer : a pointer to TL_EvtPacket_t
* @return None
*/
void TL_ZIGBEE_M0RequestReceived(TL_EvtPacket_t *Reqbuffer)
{
p_ZIGBEE_request_M0_to_M4 = Reqbuffer;
CptReceiveRequestFromM0++;
UTIL_SEQ_SetTask(1U << (uint32_t)CFG_TASK_REQUEST_FROM_M0_TO_M4, CFG_SCH_PRIO_0);
}
/**
* @brief Perform initialization of TL for Zigbee.
* @param None
* @retval None
*/
void APP_ZIGBEE_TL_INIT(void)
{
ZigbeeConfigBuffer.p_ZigbeeOtCmdRspBuffer = (uint8_t *)&ZigbeeOtCmdBuffer;
ZigbeeConfigBuffer.p_ZigbeeNotAckBuffer = (uint8_t *)ZigbeeNotifRspEvtBuffer;
ZigbeeConfigBuffer.p_ZigbeeNotifRequestBuffer = (uint8_t *)ZigbeeNotifRequestBuffer;
TL_ZIGBEE_Init(&ZigbeeConfigBuffer);
}
/**
* @brief Process the messages coming from the M0.
* @param None
* @retval None
*/
void APP_ZIGBEE_ProcessNotifyM0ToM4(void)
{
if (CptReceiveNotifyFromM0 != 0) {
/* If CptReceiveNotifyFromM0 is > 1. it means that we did not serve all the events from the radio */
if (CptReceiveNotifyFromM0 > 1U) {
APP_ZIGBEE_Error(ERR_REC_MULTI_MSG_FROM_M0, 0);
}
else {
Zigbee_CallBackProcessing();
}
/* Reset counter */
CptReceiveNotifyFromM0 = 0;
}
}
/**
* @brief Process the requests coming from the M0.
* @param
* @return
*/
void APP_ZIGBEE_ProcessRequestM0ToM4(void)
{
if (CptReceiveRequestFromM0 != 0) {
Zigbee_M0RequestProcessing();
CptReceiveRequestFromM0 = 0;
}
}
/* USER CODE BEGIN FD_LOCAL_FUNCTIONS */
/**
* @brief Set group addressing mode
* @param None
* @retval None
*/
static void APP_ZIGBEE_ConfigGroupAddr(void)
{
struct ZbApsmeAddGroupReqT req;
struct ZbApsmeAddGroupConfT conf;
memset(&req, 0, sizeof(req));
req.endpt = SW1_ENDPOINT;
req.groupAddr = SW1_GROUP_ADDR;
ZbApsmeAddGroupReq(zigbee_app_info.zb, &req, &conf);
} /* APP_ZIGBEE_ConfigGroupAddr */
static void APP_ZIGBEE_SW1_Process()
{
struct ZbApsAddrT dst;
uint64_t epid = 0U;
if(zigbee_app_info.zb == NULL){
return;
}
/* Check if the router joined the network */
if (ZbNwkGet(zigbee_app_info.zb, ZB_NWK_NIB_ID_ExtendedPanId, &epid, sizeof(epid)) != ZB_STATUS_SUCCESS) {
return;
}
if (epid == 0U) {
return;
}
memset(&dst, 0, sizeof(dst));
dst.mode = ZB_APSDE_ADDRMODE_GROUP;
dst.endpoint = SW1_ENDPOINT;
dst.nwkAddr = SW1_GROUP_ADDR;
APP_DBG("SW1 PUSHED (SENDING TOGGLE TO GROUP 0x0001)");
if (ZbZclOnOffClientToggleReq(zigbee_app_info.onOff_client_1, &dst, NULL, NULL) != ZCL_STATUS_SUCCESS) {
APP_DBG("Error, ZbZclOnOffClientToggleReq failed (SW1_ENDPOINT)");
}
}
/* USER CODE END FD_LOCAL_FUNCTIONS */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/