Statistics
| Branch: | Tag: | Revision:

amiro-lld / include / VL53L0X / v1 / Api_vl53l0x / platform / src / vl53l0x_i2c_platform.c @ 6ebebd4d

History | View | Annotate | Download (7.92 KB)

1

    
2

    
3
/*!
4
 * \file   VL53L0X_platform.c
5
 * \brief  Code function defintions for Doppler Testchip Platform Layer
6
 *
7
 */
8

    
9

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

    
12
#ifdef _MSC_VER
13
#define snprintf _snprintf
14
#endif
15

    
16

    
17

    
18
#include "vl53l0x_i2c_platform.h"
19
#include "vl53l0x_def.h"
20

    
21
#include <stdio.h>
22
#include <stdlib.h>
23
#include <time.h>
24
//#include "SERIAL_COMMS.h"
25
//#include "comms_platform.h"
26

    
27
#include "vl53l0x_platform_log.h"
28

    
29
//#include <aos_thread.h>
30

    
31

    
32

    
33
#ifdef VL53L0X_LOG_ENABLE
34
#define trace_print(level, ...) trace_print_module_function(TRACE_MODULE_PLATFORM, level, TRACE_FUNCTION_NONE, ##__VA_ARGS__)
35
#define trace_i2c(...) trace_print_module_function(TRACE_MODULE_NONE, TRACE_LEVEL_NONE, TRACE_FUNCTION_I2C, ##__VA_ARGS__)
36
#endif
37

    
38
//char  debug_string[VL53L0X_MAX_STRING_LENGTH_PLT];
39

    
40
uint8_t cached_page = 0;
41

    
42
#define MIN_COMMS_VERSION_MAJOR     1
43
#define MIN_COMMS_VERSION_MINOR     8
44
#define MIN_COMMS_VERSION_BUILD     1
45
#define MIN_COMMS_VERSION_REVISION  0
46

    
47

    
48
#define MAX_STR_SIZE 255
49
#define MAX_MSG_SIZE 100
50
#define MAX_DEVICES 4
51
#define STATUS_OK              0x00
52
#define STATUS_FAIL            0x01
53

    
54

    
55
static unsigned char _dataBytes[MAX_MSG_SIZE];
56

    
57
bool_t _check_min_version(void)
58
{
59
    return TRUE;
60
}
61

    
62

    
63
uint8_t txbuf[10];
64

    
65

    
66
/**
67
 * @brief VL53L0X_write_multi
68
 * @param address
69
 * @param reg   register to write to
70
 * @param pdata
71
 * @param count
72
 * @return int32_t because the vl53l0x has more error messages than the chibiOS
73
 */
74
int32_t VL53L0X_write_multi(apalI2CDriver_t* i2cd, uint8_t address, uint8_t reg, uint8_t *pdata, int32_t count, apalTime_t timeout)
75
{
76

    
77

    
78
    int32_t status = APAL_STATUS_OK;
79
    #ifdef VL53L0X_LOG_ENABLE
80
        int32_t i = 0;
81
        char value_as_str[VL53L0X_MAX_STRING_LENGTH_PLT];
82
        char *pvalue_as_str;
83
    #endif
84

    
85

    
86
    /* For multi writes, the serial comms dll requires multiples 4 bytes or
87
     * anything less than 4 bytes. So if an irregular size is required, the
88
     * message is broken up into two writes.
89
     *
90
     *
91
     * with the apalI2CMasterTransmit it is possible to write ore than one think -> TODO!
92
     */
93

    
94
    #ifdef VL53L0X_LOG_ENABLE
95

    
96
        pvalue_as_str =  value_as_str;
97

    
98
        for(i = 0 ; i < count ; i++)
99
        {
100
            sprintf(pvalue_as_str,"%02X", *(pdata+i));
101

    
102
            pvalue_as_str += 2;
103
        }
104
        trace_i2c("Write reg : 0x%04X, Val : 0x%s\n", reg, value_as_str);
105
    #endif
106

    
107

    
108
    if(status == APAL_STATUS_OK)
109
    {
110
        //max is 6 + 1 and allcoate the max space of 7 ... TODO
111
        int i = 0;
112
        txbuf[0] = reg;
113
        for (i = 0; i < (int)count; i++){
114
            txbuf[i+1] = pdata[i];
115
        }
116

    
117
        if (timeout == 0){
118
            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, txbuf, count+1, NULL, 0, TIME_INFINITE);
119
        }else{
120
            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, txbuf, count+1, NULL, 0, timeout);
121
        }
122
    }
123

    
124
    //convet error status to vl53l0x-api
125
    if (status != APAL_STATUS_OK)
126
    {
127
        status = VL53L0X_ERROR_NONE;
128
        //SERIAL_COMMS_Get_Error_Text(debug_string);
129
        apalDbgAssert(status != STATUS_OK);
130
    }
131

    
132
    return status;
133
}
134

    
135

    
136

    
137

    
138
/**
139
 * @brief VL53L0X_read_multi
140
 * @param address
141
 * @param index address from register
142
 * @param pdata
143
 * @param count likly 6
144
 * @return
145
 */
146
int32_t VL53L0X_read_multi(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t* pdata, size_t count, apalTime_t timeout)
147
{
148

    
149
    apalDbgAssert(i2cd != NULL);
150

    
151
    int32_t status = STATUS_OK;
152
//    #ifdef VL53L0X_LOG_ENABLE
153
//        int32_t      i = 0;
154
//        char   value_as_str[VL53L0X_MAX_STRING_LENGTH_PLT];
155
//        char *pvalue_as_str;
156
//    #endif
157

    
158
    if(status == STATUS_OK)
159
    {
160

    
161
//        status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, (uint8_t*)&index, 1, pdata, count, timeout);
162
        if (timeout == 0){
163
            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, (uint8_t*)&index, 1, pdata, count, TIME_INFINITE);
164
        }else{
165
            status = apalI2CMasterTransmit(i2cd, (apalI2Caddr_t)address, (uint8_t*)&index, 1, pdata, count, timeout);
166
        }
167

    
168
    }
169

    
170

    
171
//    #ifdef VL53L0X_LOG_ENABLE
172

    
173
//        // Build  value as string;
174
//        pvalue_as_str =  value_as_str;
175

    
176
//        for(i = 0 ; i < count ; i++)
177
//        {
178
//            sprintf(pvalue_as_str, "%02X", *(pdata+i));
179
//            pvalue_as_str += 2;
180
//        }
181

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

    
185

    
186
    return status;
187
}
188

    
189

    
190

    
191
/**
192
 * @brief VL53L0X_write_byte
193
 * @param address
194
 * @param index
195
 * @param data
196
 * @return
197
 */
198
int32_t VL53L0X_write_byte(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t data, apalTime_t timeout)
199
{
200

    
201
    int32_t status = STATUS_OK;
202
    const size_t cbyte_count = 1;
203

    
204
    #ifdef VL53L0X_LOG_ENABLE
205
        trace_print(TRACE_LEVEL_INFO,"Write reg : 0x%02X, Val : 0x%02X\n", index, data);
206
    #endif
207

    
208

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

    
211

    
212

    
213
    return status;
214

    
215
}
216

    
217

    
218
/**
219
 * @brief VL53L0X_write_word
220
 * @param address
221
 * @param index
222
 * @param data
223
 * @return
224
 */
225
int32_t VL53L0X_write_word(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint16_t data, apalTime_t timeout)
226
{
227
    int32_t status = STATUS_OK;
228

    
229
    uint8_t  buffer[BYTES_PER_WORD];
230

    
231
    // Split 16-bit word into MS and LS uint8_t
232
    buffer[0] = (uint8_t)(data >> 8);
233
    buffer[1] = (uint8_t)(data &  0x00FF);
234

    
235
    if(index%2 == 1)
236
    {
237
        status = VL53L0X_write_multi(i2cd, address, index, (uint8_t*)&buffer[0],1, timeout);
238
        status = VL53L0X_write_multi(i2cd, address, index + 1, (uint8_t*) &buffer[1],1, timeout);
239
        // serial comms cannot handle word writes to non 2-byte aligned registers.
240
    }
241
    else
242
    {
243
        status = VL53L0X_write_multi(i2cd, address, index, (uint8_t*)&buffer[0], BYTES_PER_WORD, timeout);
244
    }
245

    
246
    return status;
247

    
248
}
249

    
250

    
251

    
252

    
253

    
254
/**
255
 * @brief VL53L0X_write_dword
256
 * @param address
257
 * @param index
258
 * @param data
259
 * @return
260
 */
261
int32_t VL53L0X_write_dword(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint32_t data, apalTime_t timeout)
262
{
263
    int32_t status = STATUS_OK;
264
    uint8_t  buffer[BYTES_PER_DWORD];
265

    
266
    // Split 32-bit word into MS ... LS bytes
267
    buffer[0] = (uint8_t) (data >> 24);
268
    buffer[1] = (uint8_t)((data &  0x00FF0000) >> 16);
269
    buffer[2] = (uint8_t)((data &  0x0000FF00) >> 8);
270
    buffer[3] = (uint8_t) (data &  0x000000FF);
271

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

    
274
    return status;
275

    
276
}
277

    
278

    
279

    
280
/**
281
 * @brief VL53L0X_read_byte
282
 * @param address
283
 * @param index
284
 * @param pdata
285
 * @return
286
 */
287
int32_t VL53L0X_read_byte(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint8_t *pdata, apalTime_t timeout)
288
{
289
    int32_t status = STATUS_OK;
290
    size_t cbyte_count = 1;
291

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

    
294
    #ifdef VL53L0X_LOG_ENABLE
295
        trace_print(TRACE_LEVEL_INFO,"Read reg : 0x%02X, Val : 0x%02X\n", index, *pdata);
296
    #endif
297

    
298
    return status;
299

    
300
}
301

    
302

    
303

    
304

    
305
/**
306
 * @brief VL53L0X_read_word
307
 * @param address
308
 * @param index
309
 * @param pdata
310
 * @return
311
 */
312
int32_t VL53L0X_read_word(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint16_t *pdata ,apalTime_t timeout)
313
{
314
    int32_t  status = STATUS_OK;
315
    uint8_t  buffer[BYTES_PER_WORD];
316

    
317
    status = VL53L0X_read_multi(i2cd, address, index, buffer, BYTES_PER_WORD, timeout);
318
    *pdata = ((uint16_t)buffer[0]<<8) + (uint16_t)buffer[1];
319

    
320
    return status;
321

    
322
}
323

    
324

    
325

    
326

    
327
/**
328
 * @brief VL53L0X_read_dword
329
 * @param address
330
 * @param index
331
 * @param pdata
332
 * @return
333
 */
334
int32_t VL53L0X_read_dword(apalI2CDriver_t* i2cd, uint8_t address, uint8_t index, uint32_t *pdata, apalTime_t timeout)
335
{
336
    int32_t status = STATUS_OK;
337
    uint8_t  buffer[BYTES_PER_DWORD];
338

    
339
    status = VL53L0X_read_multi(i2cd, address, index, buffer, BYTES_PER_DWORD, timeout);
340
    *pdata = ((uint32_t)buffer[0]<<24) + ((uint32_t)buffer[1]<<16) + ((uint32_t)buffer[2]<<8) + (uint32_t)buffer[3];
341

    
342
    return status;
343

    
344
}
345

    
346

    
347

    
348

    
349

    
350

    
351

    
352

    
353