Statistics
| Branch: | Tag: | Revision:

amiro-lld / drivers / P9221R / v1 / alld_P9221R.c @ 9be47646

History | View | Annotate | Download (6.25 KB)

1
/*
2
AMiRo-LLD is a compilation of low-level hardware drivers for the Autonomous Mini Robot (AMiRo) platform.
3
Copyright (C) 2016..2019  Thomas Schöpping et al.
4

5
This program is free software: you can redistribute it and/or modify
6
it under the terms of the GNU Lesser General Public License as published by
7
the Free Software Foundation, either version 3 of the License, or
8
(at your option) any later version.
9

10
This program is distributed in the hope that it will be useful,
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
GNU Lesser General Public License for more details.
14

15
You should have received a copy of the GNU Lesser General Public License
16
along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
*/
18

    
19
/**
20
 * @file    alld_P9221R.c
21
 *
22
 * @brief   Power Monitor function implementations
23
 *
24
 * @addtogroup lld_power
25
 * @{
26
 */
27

    
28
#include <alld_P9221R.h>
29

    
30
/******************************************************************************/
31
/* LOCAL DEFINITIONS                                                          */
32
/******************************************************************************/
33

    
34
/******************************************************************************/
35
/* EXPORTED VARIABLES                                                         */
36
/******************************************************************************/
37

    
38
/******************************************************************************/
39
/* LOCAL TYPES                                                                */
40
/******************************************************************************/
41

    
42
/******************************************************************************/
43
/* LOCAL VARIABLES                                                            */
44
/******************************************************************************/
45

    
46
/******************************************************************************/
47
/* LOCAL FUNCTIONS                                                            */
48
/******************************************************************************/
49

    
50
/******************************************************************************/
51
/* EXPORTED FUNCTIONS                                                         */
52
/******************************************************************************/
53

    
54
/**
55
 * @brief Read the value of one or more of the registers.
56
 * @param[in]   i2cd        i2c driver
57
 * @param[in]   PRd         p9221r driver
58
 * @param[in]   addr        register address
59
 * @param[out]  data        register content
60
 * @param[in]   num         number of subsequent registers to read
61
 * @param[in]   timeout     timeout
62
 * @return                  An indicator whether the call was successfull
63
 */
64
apalExitStatus_t p9221r_lld_read_register(const P9221RDriver* const p9221r, const p9221r_lld_register_t addr, uint8_t* const data, const uint8_t num, const apalTime_t timeout)
65
{
66
  apalDbgAssert(p9221r != NULL);
67
  apalDbgAssert(p9221r->i2cd != NULL);
68
  apalDbgAssert(data != NULL);
69

    
70
  uint8_t tx[2] = {(addr & 0xFF00) >> 8, addr & 0x00FF};
71

    
72
  apalExitStatus_t status = apalI2CMasterTransmit(p9221r->i2cd, (P9221R_LLD_I2C_ADDR_FIXED | p9221r->addr), tx, 2, data, num, timeout);
73

    
74
  return status;
75
}
76

    
77
/**
78
 * @brief Write the value of one or more of the registers.
79
 * @param[in]   i2cd        i2c driver
80
 * @param[in]   PRd         p9221r driver
81
 * @param[in]   addr        register address
82
 * @param[in]   data        data to write
83
 * @param[in]   num         number of subsequent registers to read
84
 * @param[in]   timeout     timeout
85
 * @return                  An indicator whether the call was successfull
86
 */
87
apalExitStatus_t p9221r_lld_write_register(const P9221RDriver* const p9221r, const p9221r_lld_register_t addr, const uint16_t* const data, const uint8_t num, const apalTime_t timeout)
88
{
89
  apalDbgAssert(p9221r != NULL);
90
  apalDbgAssert(p9221r->i2cd != NULL);
91
  apalDbgAssert(data != NULL);
92

    
93
  uint8_t buffer[1+2*num];
94
  buffer[0] = addr;
95
  for (uint8_t dataIdx = 0; dataIdx < num; dataIdx++) {
96
    buffer[dataIdx*2+1] = data[dataIdx] >> 8;
97
    buffer[dataIdx*2+2] = data[dataIdx] & (0x00FFu);
98
  }
99
  return apalI2CMasterTransmit(p9221r->i2cd, (P9221R_LLD_I2C_ADDR_FIXED | p9221r->addr), buffer, 1+2*num, NULL, 0, timeout);
100
}
101

    
102
/**
103
 * @brief Read the alignment.
104
 * @param[in]   PRd         p9221r driver
105
 * @param[out]  alignment   alignment register content
106
 * @param[in]   timeout     timeout
107
 * @return                  An indicator whether the call was successfull
108
 */
109
apalExitStatus_t p9221r_lld_read_alignment(const P9221RDriver* const p9221r, int8_t* const alignment, const apalTime_t timeout)
110
{
111
    apalExitStatus_t status = p9221r_lld_read_register(p9221r, P9221R_LLD_REGISTER_ALIGNMENT_X, (uint8_t*) alignment, 2, timeout);
112

    
113
    return status;
114
}
115

    
116
/**
117
 * @brief Read the voltage.
118
 * @param[in]   i2cd        i2c driver
119
 * @param[in]   PRd         p9221r driver
120
 * @param[out]  voltage     voltage register content
121
 * @param[in]   timeout     timeout
122
 * @return                  An indicator whether the call was successfull
123
 */
124
apalExitStatus_t p9221r_lld_read_voltage(const P9221RDriver* const p9221r, float* const voltage, const apalTime_t timeout)
125
{
126
    uint8_t buffer[2];
127
    uint16_t value;
128

    
129
    apalExitStatus_t status = p9221r_lld_read_register(p9221r, P9221R_LLD_I2C_ADDR_FIXED, buffer, 2, timeout);
130

    
131
    value = ((buffer[1] & 0x0F) << 8) | buffer[0]; // 4MSB are in buffer[1] so we shift and mask, 8LSB are in buffer[0]
132
    *voltage = (((float) value) * 6 * 2.1f)/4095.0f;
133

    
134
    return status;
135
}
136

    
137
/**
138
 * @brief Read the current.
139
 * @param[in]   i2cd        i2c driver
140
 * @param[in]   PRd         p9221r driver
141
 * @param[out]  current     register content
142
 * @param[in]   timeout     timeout
143
 * @return                  An indicator whether the call was successfull
144
 */
145
apalExitStatus_t p9221r_lld_read_current(const P9221RDriver* const p9221r, float* const current, const apalTime_t timeout)
146
{
147
    uint8_t buffer[2];
148
    uint16_t value;
149

    
150
    apalExitStatus_t status = p9221r_lld_read_register(p9221r, P9221R_LLD_REGISTER_IOUT_CURRENT_LSB, buffer, 2, timeout);
151
    value = (buffer[1] << 8) | buffer[0]; // 8MSB are in buffer[1] so we shift, 8LSB are in buffer[0]
152
    *current = (((float) value) * 2 * 2.1f)/4095.0f;
153

    
154
    return status;
155
}
156

    
157
/** @} */
158