AMiRo-OS

/*!

 * \file   VL53L0X_platform.c

 * \brief  Code function defintions for Doppler Testchip Platform Layer

 *

 */

#include <stdio.h>    // sprintf(), vsnprintf(), printf()

#ifdef _MSC_VER

#define snprintf _snprintf

#endif

#include "vl53l0x_i2c_platform.h"

#include "vl53l0x_def.h"

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

//#include "SERIAL_COMMS.h"

//#include "comms_platform.h"

#include "vl53l0x_platform_log.h"

//#include <aos_thread.h>

#ifdef VL53L0X_LOG_ENABLE

#define trace_print(level, ...) trace_print_module_function(TRACE_MODULE_PLATFORM, level, TRACE_FUNCTION_NONE, ##__VA_ARGS__)

#define trace_i2c(...) trace_print_module_function(TRACE_MODULE_NONE, TRACE_LEVEL_NONE, TRACE_FUNCTION_I2C, ##__VA_ARGS__)

#endif

//char  debug_string[VL53L0X_MAX_STRING_LENGTH_PLT];

uint8_t cached_page = 0;

#define MIN_COMMS_VERSION_MAJOR     1

#define MIN_COMMS_VERSION_MINOR     8

#define MIN_COMMS_VERSION_BUILD     1

#define MIN_COMMS_VERSION_REVISION  0

#define MAX_STR_SIZE 255

#define MAX_MSG_SIZE 100

#define MAX_DEVICES 4

#define STATUS_OK              0x00

#define STATUS_FAIL            0x01

static unsigned char _dataBytes[MAX_MSG_SIZE];

bool_t _check_min_version(void)

{

    return TRUE;

}

uint8_t txbuf[10];

/**

 * @brief VL53L0X_write_multi

 * @param address

 * @param reg   register to write to

 * @param pdata

 * @param count

 * @return int32_t because the vl53l0x has more error messages than the chibiOS

 */

int32_t VL53L0X_write_multi(apalI2CDriver_t* i2cd, uint8_t address, uint8_t reg, uint8_t *pdata, int32_t count, apalTime_t timeout)

{

    int32_t status = APAL_STATUS_OK;

    #ifdef VL53L0X_LOG_ENABLE

        int32_t i = 0;

        char value_as_str[VL53L0X_MAX_STRING_LENGTH_PLT];

        char *pvalue_as_str;

    #endif

    /* For multi writes, the serial comms dll requires multiples 4 bytes or

     * anything less than 4 bytes. So if an irregular size is required, the

     * message is broken up into two writes.

     *

     *

     * with the apalI2CMasterTransmit it is possible to write ore than one think -> TODO!

     */

    #ifdef VL53L0X_LOG_ENABLE

        pvalue_as_str =  value_as_str;

        for(i = 0 ; i < count ; i++)

        {

            sprintf(pvalue_as_str,"%02X", *(pdata+i));

            pvalue_as_str += 2;

        }

        trace_i2c("Write reg : 0x%04X, Val : 0x%s\n", reg, value_as_str);

    #endif

    if(status == APAL_STATUS_OK)

    {

        //max is 6 + 1 and allcoate the max space of 7 ... TODO

        int i = 0;

        txbuf[0] = reg;

        for (i = 0; i < (int)count; i++){

            txbuf[i+1] = pdata[i];

        }

        if (timeout == 0){

            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, txbuf, count+1, NULL, 0, TIME_INFINITE);

        }else{

            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, txbuf, count+1, NULL, 0, timeout);

        }

    }

    //convet error status to vl53l0x-api

    if (status != APAL_STATUS_OK)

    {

        status = VL53L0X_ERROR_NONE;

        //SERIAL_COMMS_Get_Error_Text(debug_string);

        apalDbgAssert(status != STATUS_OK);

    }

    return status;

}

/**

 * @brief VL53L0X_read_multi

 * @param address

 * @param index address from register

 * @param pdata

 * @param count likly 6

 * @return

 */

int32_t VL53L0X_read_multi(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t* pdata, size_t count, apalTime_t timeout)

{

    apalDbgAssert(i2cd != NULL);

    int32_t status = STATUS_OK;

//    #ifdef VL53L0X_LOG_ENABLE

//        int32_t      i = 0;

//        char   value_as_str[VL53L0X_MAX_STRING_LENGTH_PLT];

//        char *pvalue_as_str;

//    #endif

    if(status == STATUS_OK)

    {

//        status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, (uint8_t*)&index, 1, pdata, count, timeout);

        if (timeout == 0){

            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, (uint8_t*)&index, 1, pdata, count, TIME_INFINITE);

        }else{

            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, (uint8_t*)&index, 1, pdata, count, timeout);

        }

    }

//    #ifdef VL53L0X_LOG_ENABLE

//        // Build  value as string;

//        pvalue_as_str =  value_as_str;

//        for(i = 0 ; i < count ; i++)

//        {

//            sprintf(pvalue_as_str, "%02X", *(pdata+i));

//            pvalue_as_str += 2;

//        }

//        //trace_i2c("Read  reg : 0x%04X, Val : 0x%s\n", index, value_as_str);

//    #endif

    return status;

}

/**

 * @brief VL53L0X_write_byte

 * @param address

 * @param index

 * @param data

 * @return

 */

int32_t VL53L0X_write_byte(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t data, apalTime_t timeout)

{

    int32_t status = STATUS_OK;

    const size_t cbyte_count = 1;

    #ifdef VL53L0X_LOG_ENABLE

        trace_print(TRACE_LEVEL_INFO,"Write reg : 0x%02X, Val : 0x%02X\n", index, data);

    #endif

    status = VL53L0X_write_multi(i2cd, address, index, (uint8_t*)&data, cbyte_count, timeout);

    return status;

}

/**

 * @brief VL53L0X_write_word

 * @param address

 * @param index

 * @param data

 * @return

 */

int32_t VL53L0X_write_word(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint16_t data, apalTime_t timeout)

{

    int32_t status = STATUS_OK;

    uint8_t  buffer[BYTES_PER_WORD];

    // Split 16-bit word into MS and LS uint8_t

    buffer[0] = (uint8_t)(data >> 8);

    buffer[1] = (uint8_t)(data &  0x00FF);

    if(index%2 == 1)

    {

        status = VL53L0X_write_multi(i2cd, address, index, (uint8_t*)&buffer[0],1, timeout);

        status = VL53L0X_write_multi(i2cd, address, index + 1, (uint8_t*) &buffer[1],1, timeout);

        // serial comms cannot handle word writes to non 2-byte aligned registers.

    }

    else

    {

        status = VL53L0X_write_multi(i2cd, address, index, (uint8_t*)&buffer[0], BYTES_PER_WORD, timeout);

    }

    return status;

}

/**

 * @brief VL53L0X_write_dword

 * @param address

 * @param index

 * @param data

 * @return

 */

int32_t VL53L0X_write_dword(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint32_t data, apalTime_t timeout)

{

    int32_t status = STATUS_OK;

    uint8_t  buffer[BYTES_PER_DWORD];

    // Split 32-bit word into MS ... LS bytes

    buffer[0] = (uint8_t) (data >> 24);

    buffer[1] = (uint8_t)((data &  0x00FF0000) >> 16);

    buffer[2] = (uint8_t)((data &  0x0000FF00) >> 8);

    buffer[3] = (uint8_t) (data &  0x000000FF);

    status = VL53L0X_write_multi(i2cd, address, index, (uint8_t*)buffer[0], BYTES_PER_DWORD, timeout);

    return status;

}

/**

 * @brief VL53L0X_read_byte

 * @param address

 * @param index

 * @param pdata

 * @return

 */

int32_t VL53L0X_read_byte(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t *pdata, apalTime_t timeout)

{

    int32_t status = STATUS_OK;

    size_t cbyte_count = 1;

    status = VL53L0X_read_multi(i2cd, address, index, pdata, cbyte_count, timeout);

    #ifdef VL53L0X_LOG_ENABLE

        trace_print(TRACE_LEVEL_INFO,"Read reg : 0x%02X, Val : 0x%02X\n", index, *pdata);

    #endif

    return status;

}

/**

 * @brief VL53L0X_read_word

 * @param address

 * @param index

 * @param pdata

 * @return

 */

int32_t VL53L0X_read_word(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint16_t *pdata ,apalTime_t timeout)

{

    int32_t  status = STATUS_OK;

    uint8_t  buffer[BYTES_PER_WORD];

    status = VL53L0X_read_multi(i2cd, address, index, buffer, BYTES_PER_WORD, timeout);

    *pdata = ((uint16_t)buffer[0]<<8) + (uint16_t)buffer[1];

    return status;

}

/**

 * @brief VL53L0X_read_dword

 * @param address

 * @param index

 * @param pdata

 * @return

 */

int32_t VL53L0X_read_dword(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint32_t *pdata, apalTime_t timeout)

{

    int32_t status = STATUS_OK;

    uint8_t  buffer[BYTES_PER_DWORD];

    status = VL53L0X_read_multi(i2cd, address, index, buffer, BYTES_PER_DWORD, timeout);

    *pdata = ((uint32_t)buffer[0]<<24) + ((uint32_t)buffer[1]<<16) + ((uint32_t)buffer[2]<<8) + (uint32_t)buffer[3];

    return status;

}