diff options
Diffstat (limited to 'ucs2-lib/src/ucs_i2c.c')
| -rw-r--r-- | ucs2-lib/src/ucs_i2c.c | 646 |
1 files changed, 646 insertions, 0 deletions
diff --git a/ucs2-lib/src/ucs_i2c.c b/ucs2-lib/src/ucs_i2c.c new file mode 100644 index 0000000..d2523b0 --- /dev/null +++ b/ucs2-lib/src/ucs_i2c.c @@ -0,0 +1,646 @@ +/*------------------------------------------------------------------------------------------------*/ +/* UNICENS V2.1.0-3491 */ +/* Copyright (c) 2017 Microchip Technology Germany II GmbH & Co. KG. */ +/* */ +/* This program is free software: you can redistribute it and/or modify */ +/* it under the terms of the GNU General Public License as published by */ +/* the Free Software Foundation, either version 2 of the License, or */ +/* (at your option) any later version. */ +/* */ +/* This program is distributed in the hope that it will be useful, */ +/* but WITHOUT ANY WARRANTY; without even the implied warranty of */ +/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ +/* GNU General Public License for more details. */ +/* */ +/* You should have received a copy of the GNU General Public License */ +/* along with this program. If not, see <http://www.gnu.org/licenses/>. */ +/* */ +/* You may also obtain this software under a propriety license from Microchip. */ +/* Please contact Microchip for further information. */ +/*------------------------------------------------------------------------------------------------*/ + +/*! + * \file + * \brief Implementation of the I2C Module. + * + * \cond UCS_INTERNAL_DOC + * \addtogroup G_I2C + * @{ + */ + +/*------------------------------------------------------------------------------------------------*/ +/* Includes */ +/*------------------------------------------------------------------------------------------------*/ +#include "ucs_i2c.h" +#include "ucs_misc.h" + +/*------------------------------------------------------------------------------------------------*/ +/* Internal prototypes */ +/*------------------------------------------------------------------------------------------------*/ +static void I2c_PortCreateResCb(void *self, void *result_ptr); +static void I2c_PortWriteResCb(void *self, void *result_ptr); +static void I2c_PortReadResCb(void *self, void *result_ptr); +static void I2c_TriggerEventStatusCb(void *self, void *result_ptr); +static bool I2c_RxFilter4NsmCb(Msg_MostTel_t *tel_ptr, void *self); +static void I2c_PortCreate_Result(void *self, Msg_MostTel_t *msg_ptr); +static void I2c_PortRead_Result(void *self, Msg_MostTel_t *msg_ptr); +static void I2c_PortWrite_Result(void *self, Msg_MostTel_t *msg_ptr); +static void I2c_RxError(void *self, Msg_MostTel_t *msg_ptr, I2c_ErrResultCb_t res_cb_fptr); +static void I2c_NsmResultCb(void * self, Nsm_Result_t result); + +/*------------------------------------------------------------------------------------------------*/ +/* Implementation of class I2C */ +/*------------------------------------------------------------------------------------------------*/ +/*------------------------------------------------------------------------------------------------*/ +/* Initialization Methods */ +/*------------------------------------------------------------------------------------------------*/ +/*! \brief Constructor of the I2C class. + * \param self Instance pointer + * \param init_ptr init data_ptr + */ +void I2c_Ctor(CI2c * self, I2c_InitData_t * init_ptr) +{ + MISC_MEM_SET(self, 0, sizeof(CI2c)); + + /* Set class instances */ + self->inic_ptr = init_ptr->inic_ptr; + self->base_ptr = self->inic_ptr->base_ptr; + self->nsm_ptr = init_ptr->nsm_ptr; + + self->curr_user_data.i2c_interrupt_report_fptr = init_ptr->i2c_interrupt_report_fptr; + + /* Init GPIOTriggerEvent observer */ + Obs_Ctor(&self->triggerevent_observer, self, &I2c_TriggerEventStatusCb); + + /* Subscribe Observers */ + Inic_AddObsrvGpioTriggerEvent(self->inic_ptr, &self->triggerevent_observer); + + /* Set device id */ + self->device_address = Inic_GetTargetAddress(self->inic_ptr); +} + +/*------------------------------------------------------------------------------------------------*/ +/* Service Functions */ +/*------------------------------------------------------------------------------------------------*/ +/*! \brief Creates an I2C Port with its associated parameter. + * \param self Reference to CI2c instance + * \param index I2C Port instance + * \param speed The speed grade of the I2C Port + * \param i2c_int_mask The I2C interrupt pin mask on the GPIO Port. + * \param res_fptr Required result callback function pointer. + * \return Possible return values are shown in the table below. + * Value | Description + * --------------------------- | ------------------------------------ + * UCS_RET_SUCCESS | No error + * UCS_RET_ERR_PARAM | At least one parameter is wrong + * UCS_RET_ERR_BUFFER_OVERFLOW | No message buffer available + * UCS_RET_ERR_API_LOCKED | API is currently locked + */ +Ucs_Return_t I2c_CreatePort(CI2c * self, uint8_t index, Ucs_I2c_Speed_t speed, uint8_t i2c_int_mask, Ucs_I2c_CreatePortResCb_t res_fptr) +{ + Ucs_Return_t result = UCS_RET_ERR_PARAM; + uint8_t address = 0x00U; /* Address will be ignored */ + uint8_t mode = 0x01U; /* Master Mode */ + + if ((NULL != self) && (NULL != res_fptr)) + { + result = UCS_RET_ERR_API_LOCKED; + if (!Nsm_IsLocked(self->nsm_ptr)) + { + I2c_Script_t * tmp_script = &self->curr_script; + + /* Set Data */ + tmp_script->cfg_data[0] = index; + tmp_script->cfg_data[1] = address; + tmp_script->cfg_data[2] = mode; + tmp_script->cfg_data[3] = (uint8_t)speed; + + /* Set message id */ + tmp_script->cfg_msg.FBlockId = FB_INIC; + tmp_script->cfg_msg.InstId = 0U; + tmp_script->cfg_msg.FunktId = INIC_FID_I2C_PORT_CREATE; + tmp_script->cfg_msg.OpCode = (uint8_t)UCS_OP_STARTRESULT; + tmp_script->cfg_msg.DataLen = 4U; + tmp_script->cfg_msg.DataPtr = &tmp_script->cfg_data[0]; + + /* Set script */ + tmp_script->script.send_cmd = &tmp_script->cfg_msg; + tmp_script->script.pause = 0U; + + /* Transmit script */ + result = Nsm_Run_Pv(self->nsm_ptr, &tmp_script->script, 1U, self, &I2c_RxFilter4NsmCb, &I2c_NsmResultCb); + if(result == UCS_RET_SUCCESS) + { + self->curr_user_data.int_pin_mask = i2c_int_mask; + self->curr_user_data.portcreate_res_cb = res_fptr; + self->curr_res_cb = &I2c_PortCreateResCb; + } + } + } + + return result; +} + +/*! \brief Writes a block of bytes to an I2C device at a specified I2C address. + * \param self Reference to CI2c instance + * \param port_handle Port resource handle + * \param mode The write transfer mode + * \param block_count The number of blocks to be written to the I2C address. + * \param slave_address The 7-bit I2C slave address of the peripheral to be read + * \param timeout The timeout for the I2C Port write + * \param data_len Number of bytes to be written to the addressed I2C peripheral + * \param data_ptr Reference to the data to be written + * \param res_fptr Required result callback function pointer. + * \return Possible return values are shown in the table below. + * Value | Description + * --------------------------- | ------------------------------------ + * UCS_RET_SUCCESS | No error + * UCS_RET_ERR_PARAM | At least one parameter is wrong + * UCS_RET_ERR_BUFFER_OVERFLOW | No message buffer available + * UCS_RET_ERR_API_LOCKED | API is currently locked + */ +Ucs_Return_t I2c_WritePort(CI2c * self, uint16_t port_handle, Ucs_I2c_TrMode_t mode, uint8_t block_count, uint8_t slave_address, uint16_t timeout, uint8_t data_len, uint8_t data_ptr[], Ucs_I2c_WritePortResCb_t res_fptr) +{ + Ucs_Return_t result = UCS_RET_ERR_PARAM; + + if ((NULL != self) && (NULL != res_fptr)) + { + if ((0U < data_len) && (NULL != data_ptr)) + { + result = UCS_RET_ERR_API_LOCKED; + if (!Nsm_IsLocked(self->nsm_ptr)) + { + bool is_ok = true; + + result = UCS_RET_ERR_PARAM; + if ((UCS_I2C_BURST_MODE == mode) && (0U == block_count)) + { + is_ok = false; + } + + if (is_ok) + { + uint8_t i; + I2c_Script_t * tmp_script = &self->curr_script; + + for (i = 0U; i < data_len; i++) + { + tmp_script->cfg_data[8U + i] = data_ptr[i]; + } + + /* Set Data */ + tmp_script->cfg_data[0] = MISC_HB(port_handle); + tmp_script->cfg_data[1] = MISC_LB(port_handle); + tmp_script->cfg_data[2] = (uint8_t)mode; + tmp_script->cfg_data[3] = block_count; + tmp_script->cfg_data[4] = slave_address; + tmp_script->cfg_data[5] = (mode == UCS_I2C_BURST_MODE) ? (data_len/block_count):data_len; + tmp_script->cfg_data[6] = MISC_HB(timeout); + tmp_script->cfg_data[7] = MISC_LB(timeout); + + /* Set message id */ + tmp_script->cfg_msg.FBlockId = FB_INIC; + tmp_script->cfg_msg.InstId = 0U; + tmp_script->cfg_msg.FunktId = INIC_FID_I2C_PORT_WRITE; + tmp_script->cfg_msg.OpCode = (uint8_t)UCS_OP_STARTRESULT; + tmp_script->cfg_msg.DataLen = data_len + 8U; + tmp_script->cfg_msg.DataPtr = &tmp_script->cfg_data[0]; + + /* Set script */ + tmp_script->script.send_cmd = &tmp_script->cfg_msg; + tmp_script->script.pause = 0U; + + /* Transmit script */ + result = Nsm_Run_Pv(self->nsm_ptr, &tmp_script->script, 1U, self, &I2c_RxFilter4NsmCb, &I2c_NsmResultCb); + if(result == UCS_RET_SUCCESS) + { + self->curr_user_data.portwrite_res_cb = res_fptr; + self->curr_res_cb = &I2c_PortWriteResCb; + } + } + } + } + } + + return result; +} + +/*! \brief Reads a block of bytes from an I2C device at a specified I2C address. + * \param self Reference to CI2c instance + * \param port_handle Port resource handle + * \param slave_address The 7-bit I2C slave address of the peripheral to be read + * \param data_len Number of bytes to be read from the address + * \param timeout The timeout for the I2C Port read + * \param res_fptr Required result callback function pointer. + * \return Possible return values are shown in the table below. + * Value | Description + * --------------------------- | ------------------------------------ + * UCS_RET_SUCCESS | No error + * UCS_RET_ERR_PARAM | At least one parameter is wrong + * UCS_RET_ERR_BUFFER_OVERFLOW | No message buffer available + * UCS_RET_ERR_API_LOCKED | API is currently locked + */ +Ucs_Return_t I2c_ReadPort(CI2c * self, uint16_t port_handle, uint8_t slave_address, uint8_t data_len, uint16_t timeout, Ucs_I2c_ReadPortResCb_t res_fptr) +{ + Ucs_Return_t result = UCS_RET_ERR_PARAM; + + if ((NULL != self) && (NULL != res_fptr)) + { + result = UCS_RET_ERR_API_LOCKED; + if (!Nsm_IsLocked(self->nsm_ptr)) + { + I2c_Script_t * tmp_script = &self->curr_script; + + /* Set Data */ + tmp_script->cfg_data[0] = MISC_HB(port_handle); + tmp_script->cfg_data[1] = MISC_LB(port_handle); + tmp_script->cfg_data[2] = slave_address; + tmp_script->cfg_data[3] = data_len; + tmp_script->cfg_data[4] = MISC_HB(timeout); + tmp_script->cfg_data[5] = MISC_LB(timeout); + + /* Set message id */ + tmp_script->cfg_msg.FBlockId = FB_INIC; + tmp_script->cfg_msg.InstId = 0U; + tmp_script->cfg_msg.FunktId = INIC_FID_I2C_PORT_READ; + tmp_script->cfg_msg.OpCode = (uint8_t)UCS_OP_STARTRESULT; + tmp_script->cfg_msg.DataLen = 6U; + tmp_script->cfg_msg.DataPtr = &tmp_script->cfg_data[0]; + + /* Set script */ + tmp_script->script.send_cmd = &tmp_script->cfg_msg; + tmp_script->script.pause = 0U; + + /* Transmit script */ + result = Nsm_Run_Pv(self->nsm_ptr, &tmp_script->script, 1U, self, &I2c_RxFilter4NsmCb, &I2c_NsmResultCb); + if(result == UCS_RET_SUCCESS) + { + self->curr_user_data.portread_res_cb = res_fptr; + self->curr_res_cb = &I2c_PortReadResCb; + } + } + } + + return result; +} + +/*------------------------------------------------------------------------------------------------*/ +/* Private Methods */ +/*------------------------------------------------------------------------------------------------*/ +/*! \brief Handles the result of the I2CPortCreate.StartResultAck + * \param self Instance pointer + * \param result_ptr result pointer + */ +static void I2c_PortCreateResCb(void *self, void *result_ptr) +{ + CI2c *self_ = (CI2c *)self; + uint16_t i2c_port_handle; + Ucs_I2c_Result_t res; + Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr; + + /* Init result */ + MISC_MEM_SET(&res, 0, sizeof(Ucs_I2c_Result_t)); + + if (NULL != result_ptr_) + { + i2c_port_handle = 0U; + res.code = UCS_I2C_RES_ERR_CMD; + res.details.result_type = UCS_I2C_RESULT_TYPE_TGT; + res.details.inic_result = result_ptr_->result; + if (result_ptr_->data_info != NULL) + { + if(result_ptr_->result.code == UCS_RES_SUCCESS) + { + res.code = UCS_I2C_RES_SUCCESS; + i2c_port_handle = *(uint16_t *)result_ptr_->data_info; + } + else if(result_ptr_->result.code == UCS_RES_ERR_TRANSMISSION) + { + res.details.result_type = UCS_I2C_RESULT_TYPE_TX; + res.details.tx_result = *(Ucs_MsgTxStatus_t *)(result_ptr_->data_info); + } + else if (result_ptr_->result.code == UCS_RES_ERR_CONFIGURATION) + { + res.code = UCS_I2C_RES_ERR_SYNC; + } + } + + if (NULL != self_->curr_user_data.portcreate_res_cb) + { + self_->curr_user_data.portcreate_res_cb(self_->device_address, i2c_port_handle, res, self_->base_ptr->ucs_user_ptr); + } + } +} + +/*! \brief Handles the result of the I2CPortWrite.StartResultAck + * \param self Instance pointer + * \param result_ptr result pointer + */ +static void I2c_PortWriteResCb(void *self, void *result_ptr) +{ + CI2c *self_ = (CI2c *)self; + Inic_I2cWriteResStatus_t wr_res; + Ucs_I2c_Result_t res; + Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr; + + /* Init result */ + MISC_MEM_SET(&res, 0, sizeof(Ucs_I2c_Result_t)); + + if (NULL != result_ptr_) + { + wr_res.data_len = 0U; + wr_res.port_handle = 0U; + wr_res.slave_address = 0U; + res.code = UCS_I2C_RES_ERR_CMD; + res.details.result_type = UCS_I2C_RESULT_TYPE_TGT; + res.details.inic_result = result_ptr_->result; + if (result_ptr_->data_info != NULL) + { + if(result_ptr_->result.code == UCS_RES_SUCCESS) + { + res.code = UCS_I2C_RES_SUCCESS; + wr_res = *(Inic_I2cWriteResStatus_t *)result_ptr_->data_info; + } + else if(result_ptr_->result.code == UCS_RES_ERR_TRANSMISSION) + { + res.details.result_type = UCS_I2C_RESULT_TYPE_TX; + res.details.tx_result = *(Ucs_MsgTxStatus_t *)(result_ptr_->data_info); + } + else if (result_ptr_->result.code == UCS_RES_ERR_CONFIGURATION) + { + res.code = UCS_I2C_RES_ERR_SYNC; + } + } + + if (NULL != self_->curr_user_data.portwrite_res_cb) + { + self_->curr_user_data.portwrite_res_cb(self_->device_address, wr_res.port_handle, wr_res.slave_address, wr_res.data_len, res, self_->base_ptr->ucs_user_ptr); + } + } +} + +/*! \brief Handles the result of the I2CPortRead.StartResultAck + * \param self Instance pointer + * \param result_ptr result pointer + */ +static void I2c_PortReadResCb(void *self, void *result_ptr) +{ + CI2c *self_ = (CI2c *)self; + Inic_I2cReadResStatus_t read_res; + Ucs_I2c_Result_t res; + Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr; + + /* Init result */ + MISC_MEM_SET(&res, 0, sizeof(Ucs_I2c_Result_t)); + + if (NULL != result_ptr_) + { + read_res.data_len = 0U; + read_res.data_ptr = NULL; + read_res.port_handle = 0U; + read_res.slave_address = 0U; + res.code = UCS_I2C_RES_ERR_CMD; + res.details.result_type = UCS_I2C_RESULT_TYPE_TGT; + res.details.inic_result = result_ptr_->result; + if (result_ptr_->data_info != NULL) + { + if(result_ptr_->result.code == UCS_RES_SUCCESS) + { + res.code = UCS_I2C_RES_SUCCESS; + read_res = *(Inic_I2cReadResStatus_t *)result_ptr_->data_info; + } + else if(result_ptr_->result.code == UCS_RES_ERR_TRANSMISSION) + { + res.details.result_type = UCS_I2C_RESULT_TYPE_TX; + res.details.tx_result = *(Ucs_MsgTxStatus_t *)(result_ptr_->data_info); + } + else if (result_ptr_->result.code == UCS_RES_ERR_CONFIGURATION) + { + res.code = UCS_I2C_RES_ERR_SYNC; + } + } + + if (NULL != self_->curr_user_data.portread_res_cb) + { + self_->curr_user_data.portread_res_cb(self_->device_address, read_res.port_handle, read_res.slave_address, read_res.data_len, read_res.data_ptr, res, self_->base_ptr->ucs_user_ptr); + } + } +} + +/*! \brief Handles the result of the GPIOPortTriggerEvent.Status + * \param self Instance pointer + * \param result_ptr result pointer + */ +static void I2c_TriggerEventStatusCb(void *self, void *result_ptr) +{ + CI2c *self_ = (CI2c *)self; + Inic_StdResult_t *result_ptr_ = (Inic_StdResult_t *)result_ptr; + + if ((NULL != result_ptr_) && + (NULL != self_->curr_user_data.i2c_interrupt_report_fptr)) + { + Inic_GpioTriggerEventStatus_t status; + uint16_t int_mask = self_->curr_user_data.int_pin_mask; + status = *(Inic_GpioTriggerEventStatus_t *)result_ptr_->data_info; + + if ((!status.is_first_report) && + ((int_mask == (status.rising_edges & int_mask)) || + (int_mask == (status.levels & int_mask)) || + (int_mask == (status.falling_edges & int_mask)))) + { + self_->curr_user_data.i2c_interrupt_report_fptr(self_->device_address, self_->base_ptr->ucs_user_ptr); + } + } +} + +/*! \brief Checks whether the incoming is our message and handles It if it's. + * \param tel_ptr Reference to the message object. + * \param self Reference to the user argument. + * \return Returns \c true to discard the message and free it to the pool if it's our message. Otherwise, returns + * \c false. + */ +static bool I2c_RxFilter4NsmCb(Msg_MostTel_t *tel_ptr, void *self) +{ + CI2c *self_ = (CI2c *)self; + bool ret_val = true; + + if ((tel_ptr != NULL) && (tel_ptr->id.function_id == self_->curr_script.script.send_cmd->FunktId)) + { + if (tel_ptr->id.op_type == UCS_OP_RESULT) + { + switch(tel_ptr->id.function_id) + { + case INIC_FID_I2C_PORT_CREATE: + I2c_PortCreate_Result(self_, tel_ptr); + break; + case INIC_FID_I2C_PORT_READ: + I2c_PortRead_Result(self_, tel_ptr); + break; + case INIC_FID_I2C_PORT_WRITE: + I2c_PortWrite_Result(self_, tel_ptr); + break; + default: + ret_val = false; + break; + } + } + else if (tel_ptr->id.op_type == UCS_OP_ERROR) + { + I2c_ErrResultCb_t res_cb_fptr = self_->curr_res_cb; + I2c_RxError(self_, tel_ptr, res_cb_fptr); + } + } + else + { + ret_val = false; + } + + return ret_val; +} + +/*! \brief Result callback function for NSM result. Whenever this function is called the NodeScripting has finished the + * script's execution. This function handles transmission and sync error. Only these two kind of errors can occur. + * \param self Reference to the called user instance. + * \param result Result of the scripting operation. + */ +static void I2c_NsmResultCb(void * self, Nsm_Result_t result) +{ + CI2c *self_ = (CI2c *)self; + + if (self_ != NULL) + { + Inic_StdResult_t res_data; + bool allow_report = false; + + if ((result.code == UCS_NS_RES_ERROR) && (result.details.result_type == NS_RESULT_TYPE_TX)) + { + res_data.data_info = &result.details.tx_result; + res_data.result.code = UCS_RES_ERR_TRANSMISSION; + res_data.result.info_ptr = NULL; + res_data.result.info_size = 0U; + allow_report = true; + } + else if ((result.code == UCS_NS_RES_ERROR) && (result.details.result_type == NS_RESULT_TYPE_TGT_SYNC)) + { + res_data.data_info = &result.details.inic_result; + res_data.result.code = result.details.inic_result.code; + res_data.result.info_ptr = result.details.inic_result.info_ptr; + res_data.result.info_size = result.details.inic_result.info_size; + allow_report = true; + } + else if ((result.code == UCS_NS_RES_ERROR) && ((result.details.tx_result == UCS_MSG_STAT_OK) || + (result.details.inic_result.code == UCS_RES_SUCCESS))) + { + res_data.data_info = NULL; + res_data.result.code = UCS_RES_ERR_TIMEOUT; + res_data.result.info_ptr = NULL; + res_data.result.info_size = 0U; + + TR_ERROR((self_->base_ptr->ucs_user_ptr, "[I2C]", "TIMEOUT ERROR occurred for currently I2C command. No response received from target device with address 0x%X.", 1U, self_->device_address)); + } + + if ((self_->curr_res_cb != NULL) && (allow_report)) + { + self_->curr_res_cb(self_, &res_data); + } + } +} + +/*---------------------------------- GW Functions ----------------------------------*/ + +/*! \brief Error Handler function for all I2C methods + * \param self Reference to CI2c instance + * \param msg_ptr Pointer to received message + * \param res_cb_fptr Pointer to a specified error handler function + */ +static void I2c_RxError(void *self, Msg_MostTel_t *msg_ptr, I2c_ErrResultCb_t res_cb_fptr) +{ + CI2c *self_ = (CI2c *)self; + Inic_StdResult_t res_data; + + res_data.data_info = NULL; + res_data.result = Inic_TranslateError(self_->inic_ptr, + &msg_ptr->tel.tel_data_ptr[0], + (msg_ptr->tel.tel_len)); + if (res_cb_fptr != NULL) + { + res_cb_fptr(self_, &res_data); + } +} + +/*! \brief Handler function for I2CPortCreate.ResultAck + * \details Element res_data.data_info points to the variable i2c_port_handle which holds the + * I2C Port resource handle. + * \param self Reference to CI2c instance + * \param msg_ptr Pointer to received message + */ +static void I2c_PortCreate_Result(void *self, Msg_MostTel_t *msg_ptr) +{ + CI2c *self_ = (CI2c *)self; + uint16_t i2c_port_handle; + Inic_StdResult_t res_data; + + MISC_DECODE_WORD(&i2c_port_handle, &(msg_ptr->tel.tel_data_ptr[0])); + res_data.data_info = &i2c_port_handle; + res_data.result.code = UCS_RES_SUCCESS; + res_data.result.info_ptr = NULL; + + I2c_PortCreateResCb(self_, &res_data); +} + +/*! \brief Handler function for I2CPortRead.ResultAck + * \details Element res_data.data_info points to a variable of type Inic_I2cReadResStatus_t which holds the + * the results of the I2CPortRead.StartResultAck command. + * \param self Reference to CI2c instance + * \param msg_ptr Pointer to received message + */ +static void I2c_PortRead_Result(void *self, Msg_MostTel_t *msg_ptr) +{ + CI2c *self_ = (CI2c *)self; + Inic_I2cReadResStatus_t i2c_read_res; + Inic_StdResult_t res_data; + + res_data.data_info = &i2c_read_res; + res_data.result.code = UCS_RES_SUCCESS; + res_data.result.info_ptr = NULL; + + MISC_DECODE_WORD(&i2c_read_res.port_handle, &(msg_ptr->tel.tel_data_ptr[0])); + i2c_read_res.slave_address = msg_ptr->tel.tel_data_ptr[2]; + i2c_read_res.data_len = msg_ptr->tel.tel_data_ptr[3]; + i2c_read_res.data_ptr = &msg_ptr->tel.tel_data_ptr[4]; + + I2c_PortReadResCb(self_, &res_data); +} + +/*! \brief Handler function for I2CPortWrite.ResultAck + * \details Element res_data.data_info points to a variable of type Inic_I2cWriteResStatus_t which holds the + * the results of the I2CPortWrite.StartResultAck command. + * \param self Reference to CI2c instance + * \param msg_ptr Pointer to received message + */ +static void I2c_PortWrite_Result(void *self, Msg_MostTel_t *msg_ptr) +{ + CI2c *self_ = (CI2c *)self; + Inic_I2cWriteResStatus_t i2c_write_res; + Inic_StdResult_t res_data; + + res_data.data_info = &i2c_write_res; + res_data.result.code = UCS_RES_SUCCESS; + res_data.result.info_ptr = NULL; + + MISC_DECODE_WORD(&i2c_write_res.port_handle, &(msg_ptr->tel.tel_data_ptr[0])); + i2c_write_res.slave_address = msg_ptr->tel.tel_data_ptr[2]; + i2c_write_res.data_len = msg_ptr->tel.tel_data_ptr[3]; + + I2c_PortWriteResCb(self_, &res_data); +} + +/*! + * @} + * \endcond + */ + +/*------------------------------------------------------------------------------------------------*/ +/* End of file */ +/*------------------------------------------------------------------------------------------------*/ + |