collab/pb-hal

git clone https://git.julia.blue/collab/pb-hal

Joseph RyanAdd prep code for integrating working init routine64c6e28

tof
9.7 KiB265 linesraw
1// I2Cdev library collection - Main I2C device class
2// Abstracts bit and byte I2C R/W functions into a convenient class
3// RaspberryPi bcm2835 library port: bcm2835 library available at http://www.airspayce.com/mikem/bcm2835/index.html
4// Based on Arduino's I2Cdev by Jeff Rowberg <jeff@rowberg.net>
5//
6
7/* ============================================
8I2Cdev device library code is placed under the MIT license
9
10Permission is hereby granted, free of charge, to any person obtaining a copy
11of this software and associated documentation files (the "Software"), to deal
12in the Software without restriction, including without limitation the rights
13to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14copies of the Software, and to permit persons to whom the Software is
15furnished to do so, subject to the following conditions:
16
17The above copyright notice and this permission notice shall be included in
18all copies or substantial portions of the Software.
19
20THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26THE SOFTWARE.
27===============================================
28*/
29
30#include "I2Cdev.h"
31#include <stdio.h>
32
33I2Cdev::I2Cdev() { }
34
35void I2Cdev::initialize() {
36  bcm2835_init();
37  bcm2835_i2c_set_baudrate( i2c_baudrate  );
38}
39
40/** Enable or disable I2C, 
41 * @param isEnabled true = enable, false = disable
42 */
43void I2Cdev::enable(bool isEnabled) {
44  if ( set_I2C_pins ){
45    if (isEnabled)
46      bcm2835_i2c_end();
47    else
48      bcm2835_i2c_begin() ;
49  }
50}
51
52char sendBuf[256];
53char recvBuf[256];
54
55
56
57/** Read a single bit from an 8-bit device register.
58 * @param devAddr I2C slave device address
59 * @param regAddr Register regAddr to read from
60 * @param bitNum Bit position to read (0-7)
61 * @param data Container for single bit value
62 * @return Status of read operation (true = success)
63 */
64int8_t I2Cdev::readBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t *data) {
65  bcm2835_i2c_setSlaveAddress(devAddr);
66  sendBuf[0] = regAddr;
67  uint8_t response = bcm2835_i2c_write_read_rs(sendBuf, 1, recvBuf, 1);
68  *data = recvBuf[1] & (1 << bitNum);
69  return response == BCM2835_I2C_REASON_OK ;
70}
71
72/** Read multiple bits from an 8-bit device register.
73 * @param devAddr I2C slave device address
74 * @param regAddr Register regAddr to read from
75 * @param bitStart First bit position to read (0-7)
76 * @param length Number of bits to read (not more than 8)
77 * @param data Container for right-aligned value (i.e. '101' read from any bitStart position will equal 0x05)
78 * @return Status of read operation (true = success)
79 */
80int8_t I2Cdev::readBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t *data) {
81  // 01101001 read byte
82  // 76543210 bit numbers
83  //    xxx   args: bitStart=4, length=3
84  //    010   masked
85  //   -> 010 shifted
86  bcm2835_i2c_setSlaveAddress(devAddr);
87  sendBuf[0] = regAddr;
88  uint8_t response = bcm2835_i2c_write_read_rs(sendBuf, 1, recvBuf, 1);
89  uint8_t b = (uint8_t) recvBuf[0];
90  if (response == BCM2835_I2C_REASON_OK) {
91    uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
92    b &= mask;
93    b >>= (bitStart - length + 1);
94    *data = b;
95  }
96  return response == BCM2835_I2C_REASON_OK;
97}
98
99/** Read single byte from an 8-bit device register.
100 * @param devAddr I2C slave device address
101 * @param regAddr Register regAddr to read from
102 * @param data Container for byte value read from device
103 * @return Status of read operation (true = success)
104 */
105int8_t I2Cdev::readByte(uint8_t devAddr, uint8_t regAddr, uint8_t *data) {
106  bcm2835_i2c_setSlaveAddress(devAddr);
107  sendBuf[0] = regAddr;
108  uint8_t response = bcm2835_i2c_write_read_rs(sendBuf, 1, recvBuf, 1);
109  data[0] = (uint8_t) recvBuf[0];
110  return response == BCM2835_I2C_REASON_OK;
111}
112
113/** Read multiple bytes from an 8-bit device register.
114 * @param devAddr I2C slave device address
115 * @param regAddr First register regAddr to read from
116 * @param length Number of bytes to read
117 * @param data Buffer to store read data in
118 * @return I2C_TransferReturn_TypeDef http://downloads.energymicro.com/documentation/doxygen/group__I2C.html
119 */
120int8_t I2Cdev::readBytes(uint8_t devAddr, uint16_t regAddr, uint8_t length, uint8_t *data) {
121  bcm2835_i2c_setSlaveAddress(devAddr);
122  sendBuf[0] = regAddr >> 8;
123  sendBuf[1] = regAddr;
124  uint8_t response = bcm2835_i2c_write_read_rs(sendBuf, 2, recvBuf, length);
125  int i ;
126  for (i = 0; i < length ; i++) {
127    data[i] = (uint8_t) recvBuf[i];
128  }
129  return response == BCM2835_I2C_REASON_OK;
130}
131
132/** write a single bit in an 8-bit device register.
133 * @param devAddr I2C slave device address
134 * @param regAddr Register regAddr to write to
135 * @param bitNum Bit position to write (0-7)
136 * @param value New bit value to write
137 * @return Status of operation (true = success)
138 */
139bool I2Cdev::writeBit(uint8_t devAddr, uint8_t regAddr, uint8_t bitNum, uint8_t data) {
140  bcm2835_i2c_setSlaveAddress(devAddr);
141  //first reading registery value
142  sendBuf[0] = regAddr;
143  uint8_t response = bcm2835_i2c_write_read_rs(sendBuf, 1, recvBuf, 1 );
144  if ( response == BCM2835_I2C_REASON_OK ) {
145    uint8_t b = recvBuf[0] ;
146    b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum));
147    sendBuf[1] = b ;
148    response = bcm2835_i2c_write(sendBuf, 2);
149  }
150  return response == BCM2835_I2C_REASON_OK;
151}
152
153/** Write multiple bits in an 8-bit device register.
154 * @param devAddr I2C slave device address
155 * @param regAddr Register regAddr to write to
156 * @param bitStart First bit position to write (0-7)
157 * @param length Number of bits to write (not more than 8)
158 * @param data Right-aligned value to write
159 * @return Status of operation (true = success)
160 */
161bool I2Cdev::writeBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t data) {
162  //      010 value to write
163  // 76543210 bit numbers
164  //    xxx   args: bitStart=4, length=3
165  // 00011100 mask byte
166  // 10101111 original value (sample)
167  // 10100011 original & ~mask
168  // 10101011 masked | value
169  bcm2835_i2c_setSlaveAddress(devAddr);
170  //first reading registery value
171  sendBuf[0] = regAddr;
172  uint8_t response = bcm2835_i2c_write_read_rs(sendBuf, 1, recvBuf, 1 );
173  if ( response == BCM2835_I2C_REASON_OK ) {
174    uint8_t b = recvBuf[0];
175    uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1);
176    data <<= (bitStart - length + 1); // shift data into correct position
177    data &= mask; // zero all non-important bits in data
178    b &= ~(mask); // zero all important bits in existing byte
179    b |= data; // combine data with existing byte
180    sendBuf[1] = b ;
181    response = bcm2835_i2c_write(sendBuf, 2);
182    }
183  return response == BCM2835_I2C_REASON_OK;
184}
185
186/** Write single byte to an 8-bit device register.
187 * @param devAddr I2C slave device address
188 * @param regAddr Register address to write to
189 * @param data New byte value to write
190 * @return Status of operation (true = success)
191 */
192bool I2Cdev::writeByte(uint8_t devAddr, uint8_t regAddr, uint8_t data) {
193  bcm2835_i2c_setSlaveAddress(devAddr);
194  sendBuf[0] = regAddr;
195  sendBuf[1] = data;
196  uint8_t response = bcm2835_i2c_write(sendBuf, 2);
197  return response == BCM2835_I2C_REASON_OK ;
198}
199
200/** Read single word from a 16-bit device register.
201 * @param devAddr I2C slave device address
202 * @param regAddr Register regAddr to read from
203 * @param data Container for word value read from device
204 * @return Status of read operation (true = success)
205 */
206int8_t I2Cdev::readWord(uint8_t devAddr, uint8_t regAddr, uint16_t *data) {
207  bcm2835_i2c_setSlaveAddress(devAddr);
208  sendBuf[0] = regAddr;
209  uint8_t response = bcm2835_i2c_write_read_rs(sendBuf, 1, recvBuf, 2 );
210  data[0] = (recvBuf[0] << 8) | recvBuf[1] ;
211  return  response == BCM2835_I2C_REASON_OK ;
212}
213
214/** Read multiple words from a 16-bit device register.
215 * @param devAddr I2C slave device address
216 * @param regAddr First register regAddr to read from
217 * @param length Number of words to read
218 * @param data Buffer to store read data in
219 * @return Number of words read (-1 indicates failure)
220 */
221int8_t I2Cdev::readWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data) {
222  bcm2835_i2c_setSlaveAddress(devAddr);
223  sendBuf[0] = regAddr;
224  uint8_t response = bcm2835_i2c_write_read_rs(sendBuf, 1, recvBuf, length*2 );
225  uint8_t i;
226  for (i = 0; i < length; i++) {
227    data[i] = (recvBuf[i*2] << 8) | recvBuf[i*2+1] ;
228  }
229  return  response == BCM2835_I2C_REASON_OK ;
230}
231
232bool I2Cdev::writeWord(uint8_t devAddr, uint8_t regAddr, uint16_t data){
233  bcm2835_i2c_setSlaveAddress(devAddr);
234  sendBuf[0] = regAddr;
235  sendBuf[1] = (uint8_t) (data >> 8); //MSByte
236  sendBuf[2] = (uint8_t) (data >> 0); //LSByte
237  uint8_t response = bcm2835_i2c_write(sendBuf, 3);
238  return response == BCM2835_I2C_REASON_OK ;
239}
240
241bool I2Cdev::writeBytes(uint8_t devAddr, uint16_t regAddr, uint8_t length, uint8_t *data){
242  bcm2835_i2c_setSlaveAddress(devAddr);
243  sendBuf[0] = regAddr >> 8;
244  sendBuf[1] = regAddr;
245  uint8_t i;
246  for (i = 0; i < length; i++) {
247    sendBuf[i+2] = data[i] ;
248  }
249
250  uint8_t response = bcm2835_i2c_write(sendBuf, 2 + length);
251
252  return response == BCM2835_I2C_REASON_OK ;
253}
254
255bool I2Cdev::writeWords(uint8_t devAddr, uint8_t regAddr, uint8_t length, uint16_t *data){
256  bcm2835_i2c_setSlaveAddress(devAddr);
257  sendBuf[0] = regAddr;
258  uint8_t i;
259  for (i = 0; i < length; i++) {
260    sendBuf[1+2*i] = (uint8_t) (data[i] >> 8); //MSByte
261    sendBuf[2+2*i] = (uint8_t) (data[i] >> 0); //LSByte
262  }
263  uint8_t response = bcm2835_i2c_write(sendBuf, 1+2*length);
264  return response == BCM2835_I2C_REASON_OK ;
265}