/** * Copyright (c) 2017 - 2020, Nordic Semiconductor ASA * * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, * are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * * 2. Redistributions in binary form, except as embedded into a Nordic * Semiconductor ASA integrated circuit in a product or a software update for * such product, 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. * * 3. Neither the name of Nordic Semiconductor ASA nor the names of its * contributors may be used to endorse or promote products derived from this * software without specific prior written permission. * * 4. This software, with or without modification, must only be used with a * Nordic Semiconductor ASA integrated circuit. * * 5. Any software provided in binary form under this license must not be reverse * engineered, decompiled, modified and/or disassembled. * * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA 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 "nrf_twi_sensor.h" #include #define NRF_LOG_MODULE_NAME twi_sensor #if NRF_TWI_SENSOR_CONFIG_LOG_ENABLED #define NRF_LOG_LEVEL NRF_TWI_SENSOR_CONFIG_LOG_LEVEL #define NRF_LOG_INFO_COLOR NRF_TWI_SENSOR_CONFIG_INFO_COLOR #define NRF_LOG_DEBUG_COLOR NRF_TWI_SENSOR_CONFIG_DEBUG_COLOR #else #define NRF_LOG_LEVEL 0 #endif // NRF_TWI_SENSOR_CONFIG_LOG_ENABLED #include "nrf_log.h" NRF_LOG_MODULE_REGISTER(); ret_code_t nrf_twi_sensor_init(nrf_twi_sensor_t * p_twi_sensor) { return nrf_balloc_init(p_twi_sensor->p_pool); } static void sensor_read_reg_cb(ret_code_t result, void * p_user_data) { nrf_twi_sensor_read_cmd_t * p_cmd = &((nrf_twi_sensor_cmd_t *) p_user_data)->read; NRF_LOG_INFO("Read cb reg addr: 0x%02X, result %d", p_cmd->reg_address, result); NRF_LOG_DEBUG("\r\nCallback pointer: %p\r\nData:", p_cmd->user_cb); NRF_LOG_HEXDUMP_DEBUG(p_cmd->transfers[1].p_data, p_cmd->transfers[1].length); if (p_cmd->user_cb != NULL) { p_cmd->user_cb(result, (void*)p_cmd->transfers[1].p_data); } nrf_balloc_free(p_cmd->p_instance->p_pool, p_user_data); } ret_code_t nrf_twi_sensor_reg_read(nrf_twi_sensor_t const * p_instance, uint8_t sensor_addr, uint8_t reg_address, nrf_twi_sensor_reg_cb_t user_cb, uint8_t * p_data, uint8_t length) { ASSERT(p_instance != NULL); ASSERT(p_data != NULL); NRF_LOG_INFO("Sensor addr: 0x%02X" "\r\nRead reg addr: 0x%02X, bytes %d", sensor_addr, reg_address, length); nrf_twi_sensor_read_cmd_t * p_cmd = (nrf_twi_sensor_read_cmd_t *) nrf_balloc_alloc(p_instance->p_pool); if (p_cmd == NULL) { NRF_LOG_WARNING("Memory not allocated."); return NRF_ERROR_NO_MEM; } p_cmd->p_instance = p_instance; p_cmd->user_cb = user_cb; p_cmd->reg_address = reg_address; p_cmd->transfers[0] = (nrf_twi_mngr_transfer_t) NRF_TWI_MNGR_WRITE(sensor_addr, &p_cmd->reg_address, 1, NRF_TWI_MNGR_NO_STOP); p_cmd->transfers[1] = (nrf_twi_mngr_transfer_t) NRF_TWI_MNGR_READ(sensor_addr, p_data, length, NRF_TWI_MNGR_NO_STOP); p_cmd->transaction = (nrf_twi_mngr_transaction_t) { .callback = sensor_read_reg_cb, .p_user_data = p_cmd, .p_transfers = p_cmd->transfers, .number_of_transfers = ARRAY_SIZE(p_cmd->transfers) }; ret_code_t err_code = nrf_twi_mngr_schedule(p_instance->p_twi_mngr, &p_cmd->transaction); if (err_code != NRF_SUCCESS) { NRF_LOG_WARNING("Transaction not scheduled.\r\nSensor addr: 0x%02X Error code: %d", sensor_addr, err_code); nrf_balloc_free(p_instance->p_pool, p_cmd); } return err_code; } static void sensor_write_reg_cb(ret_code_t result, void * p_user_data) { nrf_twi_sensor_write_cmd_t * p_cmd = &((nrf_twi_sensor_cmd_t *) p_user_data)->write; NRF_LOG_INFO("Write cb reg addr: 0x%02X, result %d", p_cmd->send_msg[0], result); nrf_balloc_free(p_cmd->p_instance->p_pool, p_user_data); } ret_code_t nrf_twi_sensor_write(nrf_twi_sensor_t const * p_instance, uint8_t sensor_addr, uint8_t const * p_data, uint8_t length, bool copy_flag) { ASSERT(p_instance != NULL); ASSERT(p_data != NULL); NRF_LOG_INFO("Sensor addr: 0x%02X Write length %d", sensor_addr, length); NRF_LOG_DEBUG("Data: "); NRF_LOG_HEXDUMP_DEBUG(p_data, length); nrf_twi_sensor_write_cmd_t * p_cmd = (nrf_twi_sensor_write_cmd_t *) nrf_balloc_alloc(p_instance->p_pool); if (p_cmd == NULL) { NRF_LOG_WARNING("Memory not allocated. Sensor addr: 0x%02X", sensor_addr); return NRF_ERROR_NO_MEM; } p_cmd->p_instance = p_instance; p_cmd->transfer = (nrf_twi_mngr_transfer_t) NRF_TWI_MNGR_WRITE(sensor_addr, p_data, length, 0); if (copy_flag == true) { if (length > NRF_TWI_SENSOR_SEND_BUF_SIZE) { NRF_LOG_ERROR("Data too long to copy. Sensor addr: 0x%02X" "\r\nRequested write length: %d, max length: %d", sensor_addr, length, NRF_TWI_SENSOR_SEND_BUF_SIZE); nrf_balloc_free(p_instance->p_pool, p_cmd); return NRF_ERROR_INVALID_LENGTH; } memcpy(p_cmd->send_msg, p_data, length); p_cmd->transfer.p_data = p_cmd->send_msg; } p_cmd->transaction = (nrf_twi_mngr_transaction_t) { .callback = sensor_write_reg_cb, .p_user_data = p_cmd, .p_transfers = &p_cmd->transfer, .number_of_transfers = 1 }; ret_code_t err_code = nrf_twi_mngr_schedule(p_instance->p_twi_mngr, &p_cmd->transaction); if (err_code != NRF_SUCCESS) { NRF_LOG_WARNING("Transaction not scheduled.\r\nSensor addr: 0x%02X Error code: %d", sensor_addr, err_code); nrf_balloc_free(p_instance->p_pool, p_cmd); } return err_code; } ret_code_t nrf_twi_sensor_reg_write(nrf_twi_sensor_t const * p_instance, uint8_t sensor_addr, uint8_t reg_address, uint8_t * p_data, uint8_t length) { ASSERT(p_instance != NULL); ASSERT(p_data != NULL); NRF_LOG_INFO("Write register: 0x%02X", reg_address); if (length > NRF_TWI_SENSOR_SEND_BUF_SIZE - 1) // Subtracting one byte for address { NRF_LOG_ERROR("Data too long to copy. Sensor addr: 0x%02X" "\r\nRequested write length: %d, max length: %d", sensor_addr, length, NRF_TWI_SENSOR_SEND_BUF_SIZE - 1); return NRF_ERROR_INVALID_LENGTH; } uint8_t buf[NRF_TWI_SENSOR_SEND_BUF_SIZE]; buf[0] = reg_address; memcpy(&buf[1], p_data, length); return nrf_twi_sensor_write(p_instance, sensor_addr, buf, length + 1, true); }