/*------------------------------------------------------------------------------------------------*/
-/* Unicens Integration Helper Component */
+/* UNICENS Integration Helper Component */
/* Copyright 2017, Microchip Technology Inc. and its subsidiaries. */
/* */
/* Redistribution and use in source and binary forms, with or without */
static void OnLldCtrlRxMsgAvailable( void *lld_user_ptr );
static void OnLldCtrlTxTransmitC( Ucs_Lld_TxMsg_t *msg_ptr, void *lld_user_ptr );
static void OnUnicensRoutingResult(Ucs_Rm_Route_t* route_ptr, Ucs_Rm_RouteInfos_t route_infos, void *user_ptr);
-static void OnUnicensMostPortStatus(uint16_t most_port_handle,
- Ucs_Most_PortAvail_t availability, Ucs_Most_PortAvailInfo_t avail_info,
- uint16_t free_streaming_bw, void* user_ptr);
+static void OnUnicensNetworkStatus(uint16_t change_mask, uint16_t events, Ucs_Network_Availability_t availability,
+ Ucs_Network_AvailInfo_t avail_info, Ucs_Network_AvailTransCause_t avail_trans_cause, uint16_t node_address,
+ uint8_t node_position, uint8_t max_position, uint16_t packet_bw, void *user_ptr);
static void OnUnicensDebugXrmResources(Ucs_Xrm_ResourceType_t resource_type,
Ucs_Xrm_ResObject_t *resource_ptr, Ucs_Xrm_ResourceInfos_t resource_infos,
Ucs_Rm_EndPoint_t *endpoint_inst_ptr, void *user_ptr);
uint16_t rising_edges, uint16_t falling_edges, uint16_t levels, void * user_ptr);
static void OnUcsI2CWrite(uint16_t node_address, uint16_t i2c_port_handle,
uint8_t i2c_slave_address, uint8_t data_len, Ucs_I2c_Result_t result, void *user_ptr);
+static void OnUcsAmsWrite(Ucs_AmsTx_Msg_t* msg_ptr, Ucs_AmsTx_Result_t result, Ucs_AmsTx_Info_t info, void *user_ptr);
/************************************************************************/
/* Public Function Implementations */
result = Ucs_SetDefaultConfig(&my->uniInitData);
if(UCS_RET_SUCCESS != result)
{
- UCSI_CB_OnUserMessage(my->tag, true, "Can not set default values to Unicens config (result=0x%X)", 1, result);
+ UCSI_CB_OnUserMessage(my->tag, true, "Can not set default values to UNICENS config (result=0x%X)", 1, result);
assert(false);
return;
}
my->uniInitData.general.debug_error_msg_fptr = &OnUnicensDebugErrorMsg;
my->uniInitData.ams.enabled = ENABLE_AMS_LIB;
my->uniInitData.ams.rx.message_received_fptr = &OnUcsAmsRxMsgReceived;
+ my->uniInitData.network.status.notification_mask = 0xC2;
+ my->uniInitData.network.status.cb_fptr = &OnUnicensNetworkStatus;
my->uniInitData.lld.lld_user_ptr = my;
my->uniInitData.lld.start_fptr = &OnLldCtrlStart;
my->uniInitData.lld.tx_transmit_fptr = &OnLldCtrlTxTransmitC;
my->uniInitData.rm.report_fptr = &OnUnicensRoutingResult;
- my->uniInitData.rm.xrm.most_port_status_fptr = &OnUnicensMostPortStatus;
my->uniInitData.rm.debug_resource_status_fptr = &OnUnicensDebugXrmResources;
my->uniInitData.gpio.trigger_event_status_fptr = &OnUcsGpioTriggerEventStatus;
void UCSI_Service(UCSI_Data_t *my)
{
+ Ucs_Return_t ret;
UnicensCmdEntry_t *e;
bool popEntry = true; /*Set to false in specific case, where function will callback asynchrony.*/
assert(MAGIC == my->magic);
UCSI_CB_OnUserMessage(my->tag, true, "UnicensCmd_GpioWritePort failed", 0);
break;
case UnicensCmd_I2CWrite:
- if (UCS_RET_SUCCESS == Ucs_I2c_WritePort(my->unicens, e->val.I2CWrite.destination, 0x0F00,
+ ret = Ucs_I2c_WritePort(my->unicens, e->val.I2CWrite.destination, 0x0F00,
(e->val.I2CWrite.isBurst ? UCS_I2C_BURST_MODE : UCS_I2C_DEFAULT_MODE), e->val.I2CWrite.blockCount,
- e->val.I2CWrite.slaveAddr, e->val.I2CWrite.timeout, e->val.I2CWrite.dataLen, e->val.I2CWrite.data, OnUcsI2CWrite))
+ e->val.I2CWrite.slaveAddr, e->val.I2CWrite.timeout, e->val.I2CWrite.dataLen, e->val.I2CWrite.data, OnUcsI2CWrite);
+ if (UCS_RET_SUCCESS == ret)
popEntry = false;
+ else {
+ UCSI_CB_OnUserMessage(my->tag, true, "Ucs_I2c_WritePort failed ret=%d", 1, ret);
+ assert(e->val.I2CWrite.result_fptr != NULL);
+ e->val.I2CWrite.result_fptr(NULL /*processing error*/, e->val.I2CWrite.request_ptr);
+ }
+ break;
+ case UnicensCmd_SendAmsMessage:
+ {
+ Ucs_AmsTx_Msg_t *msg;
+ msg = Ucs_AmsTx_AllocMsg(my->unicens, e->val.SendAms.payloadLen);
+ if (NULL == msg)
+ {
+ /* Try again later */
+ popEntry = false;
+ break;
+ }
+ if (0 != e->val.SendAms.payloadLen)
+ {
+ assert(NULL != msg->data_ptr);
+ memcpy(msg->data_ptr, e->val.SendAms.pPayload, e->val.SendAms.payloadLen);
+ }
+ msg->custom_info_ptr = NULL;
+ msg->data_size = e->val.SendAms.payloadLen;
+ msg->destination_address = e->val.SendAms.targetAddress;
+ msg->llrbc = 10;
+ msg->msg_id = e->val.SendAms.msgId;
+ if (UCS_RET_SUCCESS == Ucs_AmsTx_SendMsg(my->unicens, msg, OnUcsAmsWrite))
+ {
+ popEntry = false;
+ }
else
- UCSI_CB_OnUserMessage(my->tag, true, "Ucs_I2c_WritePort failed", 0);
+ {
+ Ucs_AmsTx_FreeUnusedMsg(my->unicens, msg);
+ UCSI_CB_OnUserMessage(my->tag, true, "Ucs_AmsTx_SendMsg failed", 0);
+ }
break;
+ }
default:
assert(false);
break;
bool UCSI_SendAmsMessage(UCSI_Data_t *my, uint16_t msgId, uint16_t targetAddress, uint8_t *pPayload, uint32_t payloadLen)
{
- Ucs_AmsTx_Msg_t *msg;
- Ucs_Return_t result;
+ UnicensCmdEntry_t entry;
assert(MAGIC == my->magic);
- if (NULL == my->unicens) return false;
- msg = Ucs_AmsTx_AllocMsg(my->unicens, payloadLen);
- if (NULL == msg) return false;
- if (0 != payloadLen)
+ if (NULL == my) return false;
+ if (payloadLen > UCS_AMS_SIZE_TX_MSG)
{
- assert(NULL != msg->data_ptr);
- memcpy(msg->data_ptr, pPayload, payloadLen);
+ UCSI_CB_OnUserMessage(my->tag, true, "SendAms was called with payload length=%d, allowed is=%d", 2, payloadLen, UCS_AMS_SIZE_TX_MSG);
+ return false;
}
- msg->custom_info_ptr = NULL;
- msg->data_size = payloadLen;
- msg->destination_address = targetAddress;
- msg->llrbc = 10;
- msg->msg_id = msgId;
- result = Ucs_AmsTx_SendMsg(my->unicens, msg, NULL);
- if (UCS_RET_SUCCESS != result)
- Ucs_AmsTx_FreeUnusedMsg(my->unicens, msg);
- return UCS_RET_SUCCESS == result;
+ entry.cmd = UnicensCmd_SendAmsMessage;
+ entry.val.SendAms.msgId = msgId;
+ entry.val.SendAms.targetAddress = targetAddress;
+ entry.val.SendAms.payloadLen = payloadLen;
+ memcpy(entry.val.SendAms.pPayload, pPayload, payloadLen);
+ return EnqueueCommand(my, &entry);
}
bool UCSI_GetAmsMessage(UCSI_Data_t *my, uint16_t *pMsgId, uint16_t *pSourceAddress, uint8_t **pPayload, uint32_t *pPayloadLen)
}
bool UCSI_I2CWrite(UCSI_Data_t *my, uint16_t targetAddress, bool isBurst, uint8_t blockCount,
- uint8_t slaveAddr, uint16_t timeout, uint8_t dataLen, uint8_t *pData)
+ uint8_t slaveAddr, uint16_t timeout, uint8_t dataLen, uint8_t *pData,
+ Ucsi_ResultCb_t result_fptr, void *request_ptr)
{
UnicensCmdEntry_t entry;
assert(MAGIC == my->magic);
entry.val.I2CWrite.slaveAddr = slaveAddr;
entry.val.I2CWrite.timeout = timeout;
entry.val.I2CWrite.dataLen = dataLen;
+ entry.val.I2CWrite.result_fptr = result_fptr;
+ entry.val.I2CWrite.request_ptr = request_ptr;
memcpy(entry.val.I2CWrite.data, pData, dataLen);
return EnqueueCommand(my, &entry);
}
UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
error_code = error_code;
assert(MAGIC == my->magic);
- UCSI_CB_OnUserMessage(my->tag, true, "Unicens general error, code=0x%X, restarting", 1, error_code);
+ UCSI_CB_OnUserMessage(my->tag, true, "UNICENS general error, code=0x%X, restarting", 1, error_code);
e.cmd = UnicensCmd_Init;
e.val.Init.init_ptr = &my->uniInitData;
EnqueueCommand(my, &e);
static void OnUnicensRoutingResult(Ucs_Rm_Route_t* route_ptr, Ucs_Rm_RouteInfos_t route_infos, void *user_ptr)
{
+ uint16_t conLabel;
UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
assert(MAGIC == my->magic);
- UCSI_CB_OnRouteResult(my->tag, route_ptr->route_id, UCS_RM_ROUTE_INFOS_BUILT == route_infos);
+ conLabel = Ucs_Rm_GetConnectionLabel(my->unicens, route_ptr);
+ UCSI_CB_OnRouteResult(my->tag, route_ptr->route_id, UCS_RM_ROUTE_INFOS_BUILT == route_infos, conLabel);
}
-static void OnUnicensMostPortStatus(uint16_t most_port_handle,
- Ucs_Most_PortAvail_t availability, Ucs_Most_PortAvailInfo_t avail_info,
- uint16_t free_streaming_bw, void* user_ptr)
+static void OnUnicensNetworkStatus(uint16_t change_mask, uint16_t events, Ucs_Network_Availability_t availability,
+ Ucs_Network_AvailInfo_t avail_info, Ucs_Network_AvailTransCause_t avail_trans_cause, uint16_t node_address,
+ uint8_t node_position, uint8_t max_position, uint16_t packet_bw, void *user_ptr)
{
- /*TODO: implement*/
- most_port_handle = most_port_handle;
- availability = availability;
- avail_info = avail_info;
- free_streaming_bw = free_streaming_bw;
- user_ptr = user_ptr;
+ UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
+ assert(MAGIC == my->magic);
+ UCSI_CB_OnNetworkState(my->tag, UCS_NW_AVAILABLE == availability, packet_bw, max_position);
}
static void OnUnicensDebugXrmResources(Ucs_Xrm_ResourceType_t resource_type,
{
UnicensCmdEntry_t e;
UCSI_CB_OnUserMessage(my->tag, false, "Node=%X: Available", 1, node_address);
- /* Enable usage of remote GPIO ports */
- e.cmd = UnicensCmd_GpioCreatePort;
- e.val.GpioCreatePort.destination = node_address;
- e.val.GpioCreatePort.debounceTime = 20;
- EnqueueCommand(my, &e);
/* Execute scripts, if there are any */
if (node_ptr && node_ptr->script_list_ptr && node_ptr->script_list_size)
{
UCSI_CB_OnUserMessage(my->tag, true, "Node=%X: unknown code", 1, node_address);
break;
}
+
+ UCSI_CB_OnMgrReport(my->tag, code, node_address, node_ptr);
}
static void OnUcsNsRun(Ucs_Rm_Node_t * node_ptr, Ucs_Ns_ResultCode_t result, void *ucs_user_ptr)
{
UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
assert(MAGIC == my->magic);
+
+ if ((my->currentCmd->cmd == UnicensCmd_I2CWrite)
+ && (my->currentCmd->val.I2CWrite.result_fptr)) {
+
+ my->currentCmd->val.I2CWrite.result_fptr(&result.code, my->currentCmd->val.I2CWrite.request_ptr);
+ }
+ else {
+ assert(false);
+ }
+
OnCommandExecuted(my, UnicensCmd_I2CWrite);
if (UCS_I2C_RES_SUCCESS != result.code)
UCSI_CB_OnUserMessage(my->tag, true, "Remote I2C Write to node=0x%X failed", 1, node_address);
}
-/*----------------------------------------
- * Debug Message output from Unicens stack:
- *----------------------------------------
- */
+static void OnUcsAmsWrite(Ucs_AmsTx_Msg_t* msg_ptr, Ucs_AmsTx_Result_t result, Ucs_AmsTx_Info_t info, void *user_ptr)
+{
+ UCSI_Data_t *my = (UCSI_Data_t *)user_ptr;
+ assert(MAGIC == my->magic);
+ OnCommandExecuted(my, UnicensCmd_SendAmsMessage);
+ if (UCS_AMSTX_RES_SUCCESS != result)
+ UCSI_CB_OnUserMessage(my->tag, true, "SendAms failed with result=0x%x, info=0x%X", 2, result, info);
+}
+
+/************************************************************************/
+/* Debug Message output from UNICENS stack: */
+/************************************************************************/
#if defined(UCS_TR_ERROR) || defined(UCS_TR_INFO)
#include <stdio.h>
#define TRACE_BUFFER_SZ 200
{
va_list argptr;
char outbuf[TRACE_BUFFER_SZ];
- void *tag;
+ void *tag = NULL;
UCSI_Data_t *my = (UCSI_Data_t *)ucs_user_ptr;
if (my)
{
tag = my->tag;
}
va_start(argptr, vargs_cnt);
- vsprintf(outbuf, entry_str, argptr);
+ vsnprintf(outbuf, sizeof(outbuf), entry_str, argptr);
va_end(argptr);
UCSI_CB_OnUserMessage(tag, true, "Error | %s | %s", 2, module_str, outbuf);
}
{
va_list argptr;
char outbuf[TRACE_BUFFER_SZ];
- void *tag;
+ void *tag = NULL;
UCSI_Data_t *my = (UCSI_Data_t *)ucs_user_ptr;
if (my)
{
tag = my->tag;
}
va_start(argptr, vargs_cnt);
- vsprintf(outbuf, entry_str, argptr);
+ vsnprintf(outbuf, sizeof(outbuf), entry_str, argptr);
va_end(argptr);
UCSI_CB_OnUserMessage(tag, false, "Info | %s | %s", 2, module_str, outbuf);
}
Code Review / apps / agl-service-unicens.git / blobdiff