Yann Garcia / FM24Vxx_I2C

Simplified access to Ramtron (Cypress) FM24Vxx F-RAM devices

Dependents:   FM24Vxx_I2CApp

FM24Vxx_I2C.cpp@2:bf7d1264d3ff, 2013-04-13 (annotated)

Committer:
Yann
Date:
Sat Apr 13 14:23:41 2013 +0000
Revision:
2:bf7d1264d3ff
Parent:
1:6a16bddd7222 
Added new Read method from Reed Kimble request

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Yann 0:fa858f79d48d 1 /* mbed simplified access to RAMTRON FV24xx Serial 3V F-RAM Memory (I2C)
Yann 0:fa858f79d48d 2 * Copyright (c) 20103 ygarcia, MIT License
Yann 0:fa858f79d48d 3 *
Yann 0:fa858f79d48d 4 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
Yann 0:fa858f79d48d 5 * and associated documentation files (the "Software"), to deal in the Software without restriction,
Yann 0:fa858f79d48d 6 * including without limitation the rights to use, copy, modify, merge, publish, distribute,
Yann 0:fa858f79d48d 7 * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
Yann 0:fa858f79d48d 8 * furnished to do so, subject to the following conditions:
Yann 0:fa858f79d48d 9 *
Yann 0:fa858f79d48d 10 * The above copyright notice and this permission notice shall be included in all copies or
Yann 0:fa858f79d48d 11 * substantial portions of the Software.
Yann 0:fa858f79d48d 12 *
Yann 0:fa858f79d48d 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
Yann 0:fa858f79d48d 14 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
Yann 0:fa858f79d48d 15 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
Yann 0:fa858f79d48d 16 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
Yann 0:fa858f79d48d 17 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Yann 0:fa858f79d48d 18 */
Yann 0:fa858f79d48d 19 #include <iostream>
Yann 0:fa858f79d48d 20 #include <sstream>
Yann 0:fa858f79d48d 21
Yann 0:fa858f79d48d 22 #include "FM24Vxx_I2C.h"
Yann 0:fa858f79d48d 23
Yann 0:fa858f79d48d 24 namespace _FM24VXX_I2C {
Yann 0:fa858f79d48d 25
Yann 0:fa858f79d48d 26 unsigned char CFM24VXX_I2C::I2CModuleRefCounter = 0;
Yann 0:fa858f79d48d 27
Yann 0:fa858f79d48d 28 CFM24VXX_I2C::CFM24VXX_I2C(const PinName p_sda, const PinName p_scl, const unsigned char p_address, const PinName p_wp, const unsigned int p_frequency) : _internalId("") {
Yann 0:fa858f79d48d 29 DEBUG_ENTER("CFM24VXX_I2C")
Yann 0:fa858f79d48d 30
Yann 0:fa858f79d48d 31 if (CFM24VXX_I2C::I2CModuleRefCounter != 0) {
Yann 0:fa858f79d48d 32 error("CFM24VXX_I2C: Wrong params");
Yann 0:fa858f79d48d 33 }
Yann 0:fa858f79d48d 34 #ifdef __DEBUG
Yann 0:fa858f79d48d 35 std::ostringstream out(std::ostringstream::out);
Yann 0:fa858f79d48d 36 out << "CFM24VXX_I2C #" << CFM24VXX_I2C::I2CModuleRefCounter;
Yann 0:fa858f79d48d 37 _internalId.assign(out.str());
Yann 0:fa858f79d48d 38 DEBUG("CFM24VXX_I2C: _internalId='%s'", _internalId.c_str())
Yann 0:fa858f79d48d 39 #endif // __DEBUG
Yann 0:fa858f79d48d 40 _i2cInstance = new I2C(p_sda, p_scl);
Yann 0:fa858f79d48d 41 CFM24VXX_I2C::I2CModuleRefCounter += 1;
Yann 0:fa858f79d48d 42 DEBUG_ENTER("CFM24VXX_I2C: refCounter=%d", CFM24VXX_I2C::I2CModuleRefCounter)
Yann 0:fa858f79d48d 43 // Memory page select is set to 0
Yann 0:fa858f79d48d 44 _slaveAddress = (p_address << 2) | 0xa0; // Slave address format is: 1 0 1 0 A2 A1 PS R/W, PS set to 0
Yann 0:fa858f79d48d 45 DEBUG("CFM24VXX_I2C: I2C slave adress: 0x%02x", _slaveAddress)
Yann 0:fa858f79d48d 46 _i2cInstance->frequency(p_frequency); // Set the frequency of the I2C interface
Yann 0:fa858f79d48d 47
Yann 0:fa858f79d48d 48 if (p_wp != NC) {
Yann 0:fa858f79d48d 49 DEBUG("CFM24VXX_I2C: WP managed");
Yann 0:fa858f79d48d 50 _wp = new DigitalOut(p_wp);
Yann 0:fa858f79d48d 51 _wp->write(0); // Disable write protect
Yann 0:fa858f79d48d 52 } else {
Yann 0:fa858f79d48d 53 DEBUG("CFM24VXX_I2C: WP not managed");
Yann 0:fa858f79d48d 54 _wp = NULL; // Not used
Yann 0:fa858f79d48d 55 }
Yann 0:fa858f79d48d 56
Yann 0:fa858f79d48d 57 // Retrieve device identifiers
Yann 0:fa858f79d48d 58 _deviceID = NULL;
Yann 0:fa858f79d48d 59 GetDevideIDs();
Yann 1:6a16bddd7222 60
Yann 1:6a16bddd7222 61 _sn = NULL;
Yann 1:6a16bddd7222 62 GetSerialNumbers();
Yann 0:fa858f79d48d 63
Yann 0:fa858f79d48d 64 DEBUG_LEAVE("CFM24VXX_I2C")
Yann 0:fa858f79d48d 65 }
Yann 0:fa858f79d48d 66
Yann 0:fa858f79d48d 67 CFM24VXX_I2C::~CFM24VXX_I2C() {
Yann 0:fa858f79d48d 68 DEBUG_ENTER("~CFM24VXX_I2C")
Yann 0:fa858f79d48d 69
Yann 0:fa858f79d48d 70 // Release I2C instance
Yann 0:fa858f79d48d 71 DEBUG_ENTER("~CFM24VXX_I2C: refCounter=%d", CFM24VXX_I2C::I2CModuleRefCounter)
Yann 0:fa858f79d48d 72 CFM24VXX_I2C::I2CModuleRefCounter -= 1;
Yann 0:fa858f79d48d 73 if (CFM24VXX_I2C::I2CModuleRefCounter == 0) {
Yann 0:fa858f79d48d 74 delete _i2cInstance;
Yann 0:fa858f79d48d 75 _i2cInstance = NULL;
Yann 0:fa858f79d48d 76 if (_deviceID != NULL) {
Yann 0:fa858f79d48d 77 delete _deviceID;
Yann 0:fa858f79d48d 78 _deviceID = NULL;
Yann 0:fa858f79d48d 79 }
Yann 0:fa858f79d48d 80 }
Yann 0:fa858f79d48d 81 // Release _wp if required
Yann 0:fa858f79d48d 82 if (_wp != NULL) {
Yann 0:fa858f79d48d 83 _wp->write(0);
Yann 0:fa858f79d48d 84 delete _wp;
Yann 0:fa858f79d48d 85 }
Yann 0:fa858f79d48d 86
Yann 0:fa858f79d48d 87 DEBUG_LEAVE("~CFM24VXX_I2C")
Yann 0:fa858f79d48d 88 }
Yann 0:fa858f79d48d 89
Yann 0:fa858f79d48d 90 bool CFM24VXX_I2C::WriteProtect(const bool p_writeProtect) {
Yann 0:fa858f79d48d 91 if (_wp != NULL) {
Yann 0:fa858f79d48d 92 DEBUG("WP set to: %x", (int)p_writeProtect)
Yann 0:fa858f79d48d 93 _wp->write((int)(p_writeProtect));
Yann 0:fa858f79d48d 94 return true;
Yann 0:fa858f79d48d 95 }
Yann 0:fa858f79d48d 96
Yann 0:fa858f79d48d 97 return false;
Yann 0:fa858f79d48d 98 }
Yann 0:fa858f79d48d 99
Yann 1:6a16bddd7222 100 bool CFM24VXX_I2C::GetDevideIDs() {
Yann 1:6a16bddd7222 101 DEBUG_ENTER("CFM24VXX_I2C::GetDevideIDs")
Yann 1:6a16bddd7222 102
Yann 1:6a16bddd7222 103 // 1. Memory address
Yann 1:6a16bddd7222 104 char i2cBuffer[1];
Yann 1:6a16bddd7222 105 i2cBuffer[0] = (unsigned char)(_slaveAddress & 0xfc); //FIXME Change 0xfc into a const SET_PAGE_SELECT_0
Yann 1:6a16bddd7222 106 DEBUG("CFM24VXX_I2C::GetDevideIDs: pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 1:6a16bddd7222 107 // 2. Send I2C start + 0xF8 + I2C ReStart
Yann 1:6a16bddd7222 108 if (_i2cInstance->write(0xf8, i2cBuffer, 1, true) == 0) {
Yann 2:bf7d1264d3ff 109 //wait(0.02);
Yann 1:6a16bddd7222 110 DEBUG("CFM24VXX_I2C::GetDevideIDs: Write F8 done")
Yann 1:6a16bddd7222 111 // 3. read data + I2C stop
Yann 1:6a16bddd7222 112 unsigned char buffer[3];
Yann 1:6a16bddd7222 113 int result = _i2cInstance->read(0xf9, (char *)buffer, 3);
Yann 2:bf7d1264d3ff 114 //wait(0.02);
Yann 1:6a16bddd7222 115 if (result == 0) {
Yann 1:6a16bddd7222 116 // 4. Setup the device IDs
Yann 1:6a16bddd7222 117 _deviceID = new CFM24VXX_IDs(buffer[0], buffer[1], buffer[2]);
Yann 1:6a16bddd7222 118 DEBUG("CFM24VXX_I2C::GetDevideIDs: %02x - %02x - %02x", buffer[0], buffer[1], buffer[2])
Yann 1:6a16bddd7222 119
Yann 1:6a16bddd7222 120 DEBUG_LEAVE("CFM24VXX_I2C::GetDevideIDs: %x", (bool)(result == 0))
Yann 1:6a16bddd7222 121 return (bool)(result == 0);
Yann 1:6a16bddd7222 122 }
Yann 1:6a16bddd7222 123 }
Yann 1:6a16bddd7222 124
Yann 1:6a16bddd7222 125 _deviceID = new CFM24VXX_IDs(0xff, 0xff, 0xff);
Yann 1:6a16bddd7222 126 DEBUG_LEAVE("CFM24VXX_I2C::GetDevideIDs (false)")
Yann 1:6a16bddd7222 127 return false;
Yann 0:fa858f79d48d 128 }
Yann 0:fa858f79d48d 129
Yann 1:6a16bddd7222 130 bool CFM24VXX_I2C::GetSerialNumbers() {
Yann 1:6a16bddd7222 131 DEBUG_ENTER("CFM24VXX_I2C::GetSerialNumber")
Yann 1:6a16bddd7222 132 // 1. Memory address
Yann 1:6a16bddd7222 133 char i2cBuffer[1];
Yann 1:6a16bddd7222 134 i2cBuffer[0] = (unsigned char)(_slaveAddress & 0xfc); //FIXME Change 0xfc into a const SET_PAGE_SELECT_0
Yann 1:6a16bddd7222 135 DEBUG("CFM24VXX_I2C::GetSerialNumber: pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 1:6a16bddd7222 136 // 2. Send I2C start + 0xF8 + I2C ReStart
Yann 1:6a16bddd7222 137 if (_i2cInstance->write(0xf8, i2cBuffer, 1, true) == 0) {
Yann 2:bf7d1264d3ff 138 //wait(0.02);
Yann 1:6a16bddd7222 139 DEBUG("CFM24VXX_I2C::GetSerialNumber: Write F8 done")
Yann 1:6a16bddd7222 140 // 3. read data + I2C stop
Yann 1:6a16bddd7222 141 unsigned char buffer[8]; // See FM24V10_ds.pdf Page 10/16 Figure 15. 8-Byte Serial Number (read-only)
Yann 1:6a16bddd7222 142 int result = _i2cInstance->read(0xcd, (char *)buffer, 8);
Yann 2:bf7d1264d3ff 143 //wait(0.02);
Yann 1:6a16bddd7222 144 if (result == 0) {
Yann 1:6a16bddd7222 145 // 4. Check if it is supported
Yann 1:6a16bddd7222 146 if (buffer[7] != 0x00) { // SN supported
Yann 1:6a16bddd7222 147 // 5. Compute CRC
Yann 1:6a16bddd7222 148 unsigned char crc = ChecksumSN(buffer);
Yann 1:6a16bddd7222 149 // 6. Check CRCs
Yann 1:6a16bddd7222 150 if (buffer[7] == crc) {
Yann 1:6a16bddd7222 151 _sn = new CFM24VXX_SN(buffer);
Yann 1:6a16bddd7222 152 DEBUG_LEAVE("CFM24VXX_I2C::GetSerialNumber: true")
Yann 1:6a16bddd7222 153 return true;
Yann 1:6a16bddd7222 154 } else { // SN supported
Yann 1:6a16bddd7222 155 DEBUG_LEAVE("CFM24VXX_I2C::GetSerialNumber: Checksum mismatch")
Yann 1:6a16bddd7222 156 return false;
Yann 1:6a16bddd7222 157 }
Yann 1:6a16bddd7222 158 } else { // SN supported
Yann 1:6a16bddd7222 159 DEBUG_LEAVE("CFM24VXX_I2C::GetSerialNumber: Serial number not supported")
Yann 1:6a16bddd7222 160 return true;
Yann 1:6a16bddd7222 161 }
Yann 1:6a16bddd7222 162 }
Yann 1:6a16bddd7222 163 }
Yann 1:6a16bddd7222 164
Yann 1:6a16bddd7222 165 DEBUG_LEAVE("CFM24VXX_I2C::GetSerialNumber (false)")
Yann 1:6a16bddd7222 166 return false;
Yann 1:6a16bddd7222 167 }
Yann 1:6a16bddd7222 168
Yann 0:fa858f79d48d 169 bool CFM24VXX_I2C::EraseMemoryArea(const short p_startAddress, const int p_count, const unsigned char p_pattern) {
Yann 0:fa858f79d48d 170 DEBUG_ENTER("CFM24VXX_I2C::EraseMemoryArea: 0x%02x - %d - 0x%02x", p_startAddress, p_count, p_pattern)
Yann 0:fa858f79d48d 171
Yann 0:fa858f79d48d 172 std::vector<unsigned char> eraseBuffer(p_count, p_pattern);
Yann 0:fa858f79d48d 173 return Write(p_startAddress, eraseBuffer, false);
Yann 0:fa858f79d48d 174 }
Yann 0:fa858f79d48d 175
Yann 0:fa858f79d48d 176 bool CFM24VXX_I2C::Write(const short p_address, const unsigned char p_byte) {
Yann 0:fa858f79d48d 177 DEBUG_ENTER("CFM24VXX_I2C::Write (byte): Memory address: 0x%02x - 0x%02x", p_address, p_byte)
Yann 0:fa858f79d48d 178
Yann 0:fa858f79d48d 179 // 1.Prepare buffer
Yann 0:fa858f79d48d 180 char i2cBuffer[3]; // Memory address + one byte of data
Yann 0:fa858f79d48d 181 // 1.1. Memory address
Yann 0:fa858f79d48d 182 short address = p_address + 1; // Index start to 1
Yann 0:fa858f79d48d 183 i2cBuffer[0] = (unsigned char)(address >> 8);
Yann 0:fa858f79d48d 184 DEBUG("CFM24VXX_I2C::Write (byte): pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 0:fa858f79d48d 185 i2cBuffer[1] = (unsigned char)((unsigned char)address & 0xff);
Yann 0:fa858f79d48d 186 DEBUG("CFM24VXX_I2C::Write (byte): pI2CBuffer[1]: 0x%02x", i2cBuffer[1])
Yann 0:fa858f79d48d 187 // 1.2. Datas
Yann 0:fa858f79d48d 188 i2cBuffer[2] = p_byte;
Yann 0:fa858f79d48d 189 DEBUG("CFM24VXX_I2C::Write (byte): value=0x%02x", i2cBuffer[2])
Yann 0:fa858f79d48d 190
Yann 0:fa858f79d48d 191 // 2. Send I2C start + I2C address + Memory Address + Datas + I2C stop
Yann 0:fa858f79d48d 192 int result = _i2cInstance->write(_slaveAddress, i2cBuffer, 3);
Yann 2:bf7d1264d3ff 193 //wait(0.02);
Yann 0:fa858f79d48d 194
Yann 0:fa858f79d48d 195 DEBUG_LEAVE("CFM24VXX_I2C::Write (byte) %x", (bool)(result == 0))
Yann 0:fa858f79d48d 196 return (bool)(result == 0);
Yann 0:fa858f79d48d 197 }
Yann 0:fa858f79d48d 198
Yann 0:fa858f79d48d 199 bool CFM24VXX_I2C::Write(const short p_address, const short p_short, const CFM24VXX_I2C::Mode p_mode) {
Yann 0:fa858f79d48d 200 DEBUG_ENTER("CFM24VXX_I2C::Write (short): Memory address:0x%02x, Mode:%d", p_address, p_mode)
Yann 0:fa858f79d48d 201
Yann 0:fa858f79d48d 202 // 1.Prepare buffer
Yann 0:fa858f79d48d 203 char i2cBuffer[4]; // Memory address + one short (2 bytes)
Yann 0:fa858f79d48d 204 // 1.1. Memory address
Yann 0:fa858f79d48d 205 short address = p_address + 1; // Index start to 1
Yann 0:fa858f79d48d 206 i2cBuffer[0] = (unsigned char)(address >> 8);
Yann 0:fa858f79d48d 207 DEBUG("CFM24VXX_I2C::Write (short): pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 0:fa858f79d48d 208 i2cBuffer[1] = (unsigned char)((unsigned char)address & 0xff);
Yann 0:fa858f79d48d 209 DEBUG("CFM24VXX_I2C::Write (short): pI2CBuffer[1]: 0x%02x", i2cBuffer[1])
Yann 0:fa858f79d48d 210 // 1.2. Datas
Yann 0:fa858f79d48d 211 if (p_mode == BigEndian) {
Yann 0:fa858f79d48d 212 i2cBuffer[2] = (unsigned char)(p_short >> 8);
Yann 0:fa858f79d48d 213 i2cBuffer[3] = (unsigned char)((unsigned char)p_short & 0xff);
Yann 0:fa858f79d48d 214 } else {
Yann 0:fa858f79d48d 215 i2cBuffer[2] = (unsigned char)((unsigned char)p_short & 0xff);
Yann 0:fa858f79d48d 216 i2cBuffer[3] = (unsigned char)(p_short >> 8);
Yann 0:fa858f79d48d 217 }
Yann 0:fa858f79d48d 218 DEBUG("CFM24VXX_I2C::Write (short): value=0x%02x%02x", i2cBuffer[2], i2cBuffer[3])
Yann 0:fa858f79d48d 219
Yann 0:fa858f79d48d 220 // 2. Send I2C start + I2C address + Memory Address + Datas + I2C stop
Yann 0:fa858f79d48d 221 int result = _i2cInstance->write(_slaveAddress, i2cBuffer, 4);
Yann 2:bf7d1264d3ff 222 //wait(0.02);
Yann 0:fa858f79d48d 223
Yann 0:fa858f79d48d 224 DEBUG_LEAVE("CFM24VXX_I2C::Write (short) %x", (bool)(result == 0))
Yann 0:fa858f79d48d 225 return (bool)(result == 0);
Yann 0:fa858f79d48d 226 }
Yann 0:fa858f79d48d 227
Yann 0:fa858f79d48d 228 bool CFM24VXX_I2C::Write(const short p_address, const int p_int, const CFM24VXX_I2C::Mode p_mode) {
Yann 0:fa858f79d48d 229 DEBUG_ENTER("CFM24VXX_I2C::Write (int): Memory address:0x%02x, Mode:%d", p_address, p_mode)
Yann 0:fa858f79d48d 230
Yann 0:fa858f79d48d 231 // 1.Prepare buffer
Yann 0:fa858f79d48d 232 char i2cBuffer[6]; // Memory address + one integer (4 bytes)
Yann 0:fa858f79d48d 233 // 1.1. Memory address
Yann 0:fa858f79d48d 234 short address = p_address + 1; // Index start to 1
Yann 0:fa858f79d48d 235 i2cBuffer[0] = (unsigned char)(address >> 8);
Yann 0:fa858f79d48d 236 DEBUG("CFM24VXX_I2C::Write (int): pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 0:fa858f79d48d 237 i2cBuffer[1] = (unsigned char)((unsigned char)address & 0xff);
Yann 0:fa858f79d48d 238 DEBUG("CFM24VXX_I2C::Write (int): pI2CBuffer[1]: 0x%02x", i2cBuffer[1])
Yann 0:fa858f79d48d 239 // 1.2. Datas
Yann 0:fa858f79d48d 240 if (p_mode == BigEndian) {
Yann 0:fa858f79d48d 241 i2cBuffer[2] = (unsigned char)(p_int >> 24);
Yann 0:fa858f79d48d 242 i2cBuffer[3] = (unsigned char)(p_int >> 16);
Yann 0:fa858f79d48d 243 i2cBuffer[4] = (unsigned char)(p_int >> 8);
Yann 0:fa858f79d48d 244 i2cBuffer[5] = (unsigned char)((unsigned char)p_int & 0xff);
Yann 0:fa858f79d48d 245 } else {
Yann 0:fa858f79d48d 246 i2cBuffer[2] = (unsigned char)((unsigned char)p_int & 0xff);
Yann 0:fa858f79d48d 247 i2cBuffer[3] = (unsigned char)(p_int >> 8);
Yann 0:fa858f79d48d 248 i2cBuffer[4] = (unsigned char)(p_int >> 16);
Yann 0:fa858f79d48d 249 i2cBuffer[5] = (unsigned char)(p_int >> 24);
Yann 0:fa858f79d48d 250 }
Yann 0:fa858f79d48d 251 DEBUG("CFM24VXX_I2C::Write (int): value=0x%02x%02x%02x%02x", i2cBuffer[2], i2cBuffer[3], i2cBuffer[4], i2cBuffer[5])
Yann 0:fa858f79d48d 252
Yann 0:fa858f79d48d 253 // 2. Send I2C start + I2C address + Memory Address + Datas + I2C stop
Yann 0:fa858f79d48d 254 int result = _i2cInstance->write(_slaveAddress, i2cBuffer, 6);
Yann 2:bf7d1264d3ff 255 //wait(0.02);
Yann 0:fa858f79d48d 256
Yann 0:fa858f79d48d 257 DEBUG_LEAVE("CFM24VXX_I2C::Write (int) %x", (bool)(result == 0))
Yann 0:fa858f79d48d 258 return (bool)(result == 0);
Yann 0:fa858f79d48d 259 }
Yann 0:fa858f79d48d 260
Yann 0:fa858f79d48d 261 bool CFM24VXX_I2C::Write(const short p_address, const std::string & p_string, const bool p_storeLength, const int p_length2write) {
Yann 0:fa858f79d48d 262 DEBUG_ENTER("CFM24VXX_I2C::Write (std::string)")
Yann 0:fa858f79d48d 263 return Write(p_address, p_string.c_str(), p_storeLength, p_length2write);
Yann 0:fa858f79d48d 264 }
Yann 0:fa858f79d48d 265
Yann 0:fa858f79d48d 266 bool CFM24VXX_I2C::Write(const short p_address, const std::vector<unsigned char> & p_datas, const bool p_storeLength, const int p_length2write) {
Yann 0:fa858f79d48d 267 DEBUG_ENTER("CFM24VXX_I2C::Write (std::vector)")
Yann 0:fa858f79d48d 268
Yann 0:fa858f79d48d 269 int length = (p_length2write == -1) ? p_datas.size() : p_length2write;
Yann 0:fa858f79d48d 270 unsigned char array[length];
Yann 0:fa858f79d48d 271 std::copy(p_datas.begin(), p_datas.end(), array);
Yann 0:fa858f79d48d 272 bool result = Write(p_address, array, p_storeLength, length);
Yann 2:bf7d1264d3ff 273 //wait(0.02);
Yann 0:fa858f79d48d 274
Yann 0:fa858f79d48d 275 DEBUG_LEAVE("CFM24VXX_I2C::Write (std::vector): %d", result)
Yann 0:fa858f79d48d 276 return result;
Yann 0:fa858f79d48d 277 }
Yann 0:fa858f79d48d 278
Yann 2:bf7d1264d3ff 279 bool CFM24VXX_I2C::Write(const short p_address, const char *p_string, const bool p_storeLength, const int p_length2write) {
Yann 0:fa858f79d48d 280 DEBUG_ENTER("CFM24VXX_I2C::Write (char *): Memory address: 0x%02x - %x - %d", p_address, p_storeLength, p_length2write)
Yann 0:fa858f79d48d 281
Yann 1:6a16bddd7222 282 DEBUG("CFM24VXX_I2C::Write (char *): Slave address: %02x", _slaveAddress)
Yann 0:fa858f79d48d 283 // 1.Prepare buffer
Yann 2:bf7d1264d3ff 284 int length = (p_length2write == -1) ? strlen(p_string) : p_length2write;
Yann 0:fa858f79d48d 285 if (p_storeLength) {
Yann 0:fa858f79d48d 286 length += 4; // Add four bytes for the length as integer
Yann 0:fa858f79d48d 287 }
Yann 0:fa858f79d48d 288 DEBUG("CFM24VXX_I2C::Write (char *): length:%d", length)
Yann 0:fa858f79d48d 289
Yann 0:fa858f79d48d 290 char i2cBuffer[2 + length];
Yann 0:fa858f79d48d 291 // 1.1. Memory address
Yann 0:fa858f79d48d 292 short address = p_address + 1;
Yann 0:fa858f79d48d 293 i2cBuffer[0] = (unsigned char)(address >> 8);
Yann 0:fa858f79d48d 294 DEBUG("CFM24VXX_I2C::Write (char *): pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 0:fa858f79d48d 295 i2cBuffer[1] = (unsigned char)((unsigned char)address & 0xff);
Yann 0:fa858f79d48d 296 DEBUG("CFM24VXX_I2C::Write (char *): pI2CBuffer[1]: 0x%02x", i2cBuffer[1])
Yann 0:fa858f79d48d 297 // 1.2. Datas
Yann 0:fa858f79d48d 298 if (p_storeLength) {
Yann 0:fa858f79d48d 299 // Fill the length
Yann 0:fa858f79d48d 300 i2cBuffer[2] = (unsigned char)(length >> 24);
Yann 0:fa858f79d48d 301 i2cBuffer[3] = (unsigned char)(length >> 16);
Yann 0:fa858f79d48d 302 i2cBuffer[4] = (unsigned char)(length >> 8);
Yann 0:fa858f79d48d 303 i2cBuffer[5] = (unsigned char)((unsigned char)length & 0xff);
Yann 0:fa858f79d48d 304 for (int i = 0; i < length - 4; i++) {
Yann 2:bf7d1264d3ff 305 i2cBuffer[6 + i] = *(p_string + i);
Yann 0:fa858f79d48d 306 }
Yann 0:fa858f79d48d 307 } else { // The length was not stored
Yann 0:fa858f79d48d 308 for (int i = 0; i < length; i++) {
Yann 2:bf7d1264d3ff 309 i2cBuffer[2 + i] = *(p_string + i);
Yann 0:fa858f79d48d 310 }
Yann 0:fa858f79d48d 311 }
Yann 0:fa858f79d48d 312
Yann 0:fa858f79d48d 313 // 2. Send I2C start + I2C address + Memory Address + Datas + I2C stop
Yann 0:fa858f79d48d 314 int result = _i2cInstance->write(_slaveAddress, i2cBuffer, 2 + length);
Yann 2:bf7d1264d3ff 315 //wait(0.02);
Yann 0:fa858f79d48d 316
Yann 0:fa858f79d48d 317 DEBUG_LEAVE("CFM24VXX_I2C::Write (char *) %x", (bool)(result == 0))
Yann 0:fa858f79d48d 318 return (bool)(result == 0);
Yann 0:fa858f79d48d 319 }
Yann 0:fa858f79d48d 320
Yann 0:fa858f79d48d 321 bool CFM24VXX_I2C::Write(const short p_address, const unsigned char *p_datas, const bool p_storeLength, const int p_length2write) {
Yann 0:fa858f79d48d 322 DEBUG_ENTER("CFM24VXX_I2C::Write (byte *): Memory address: 0x%02x - %x - %d", p_address, p_storeLength, p_length2write)
Yann 0:fa858f79d48d 323 return Write(p_address, (const char *)p_datas, p_storeLength, p_length2write);
Yann 0:fa858f79d48d 324 }
Yann 0:fa858f79d48d 325
Yann 0:fa858f79d48d 326 bool CFM24VXX_I2C::Read(const short p_address, unsigned char * p_byte) {
Yann 0:fa858f79d48d 327 DEBUG_ENTER("CFM24VXX_I2C::Read (byte): Memory address:0x%02x", p_address)
Yann 0:fa858f79d48d 328
Yann 0:fa858f79d48d 329 // 1.Prepare buffer
Yann 0:fa858f79d48d 330 char i2cBuffer[2];
Yann 0:fa858f79d48d 331 // 1.1. Memory address
Yann 0:fa858f79d48d 332 i2cBuffer[0] = (unsigned char)(p_address >> 8);
Yann 0:fa858f79d48d 333 DEBUG("CFM24VXX_I2C::Read (byte): pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 0:fa858f79d48d 334 i2cBuffer[1] = (unsigned char)((unsigned char)p_address & 0xff);
Yann 0:fa858f79d48d 335 DEBUG("CFM24VXX_I2C::Read (byte): pI2CBuffer[1]: 0x%02x", i2cBuffer[1])
Yann 0:fa858f79d48d 336
Yann 0:fa858f79d48d 337 // 2. Send I2C start + memory address
Yann 0:fa858f79d48d 338 if (_i2cInstance->write(_slaveAddress, i2cBuffer, 2, true) == 0) {
Yann 2:bf7d1264d3ff 339 //wait(0.02);
Yann 0:fa858f79d48d 340 DEBUG("CFM24VXX_I2C::Read (byte): Write memory done")
Yann 0:fa858f79d48d 341 // 2. Read data + I2C stop
Yann 0:fa858f79d48d 342 int result = _i2cInstance->read(_slaveAddress, (char *)p_byte, 1);
Yann 2:bf7d1264d3ff 343 //wait(0.02);
Yann 0:fa858f79d48d 344
Yann 0:fa858f79d48d 345 DEBUG_LEAVE("CFM24VXX_I2C::Read (byte): %x", (bool)(result == 0))
Yann 0:fa858f79d48d 346 return (bool)(result == 0);
Yann 0:fa858f79d48d 347 }
Yann 0:fa858f79d48d 348
Yann 0:fa858f79d48d 349 DEBUG_LEAVE("CFM24VXX_I2C::Read (byte) (false)")
Yann 0:fa858f79d48d 350 return false;
Yann 0:fa858f79d48d 351 }
Yann 0:fa858f79d48d 352
Yann 0:fa858f79d48d 353 bool CFM24VXX_I2C::Read(const short p_address, short *p_short, const CFM24VXX_I2C::Mode p_mode) {
Yann 0:fa858f79d48d 354 DEBUG_ENTER("CFM24VXX_I2C::Read (short): Memory address:0x%02x, Mode:%d", p_address, p_mode)
Yann 0:fa858f79d48d 355
Yann 0:fa858f79d48d 356 // 1.Prepare buffer
Yann 0:fa858f79d48d 357 char i2cBuffer[2];
Yann 0:fa858f79d48d 358 // 1.1. Memory address
Yann 0:fa858f79d48d 359 i2cBuffer[0] = (unsigned char)(p_address >> 8);
Yann 0:fa858f79d48d 360 DEBUG("CFM24VXX_I2C::Read (short): pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 0:fa858f79d48d 361 i2cBuffer[1] = (unsigned char)((unsigned char)p_address & 0xff);
Yann 0:fa858f79d48d 362 DEBUG("CFM24VXX_I2C::Read (short): pI2CBuffer[1]: 0x%02x", i2cBuffer[1])
Yann 0:fa858f79d48d 363
Yann 0:fa858f79d48d 364 // 2. Send I2C start + memory address
Yann 0:fa858f79d48d 365 if (_i2cInstance->write(_slaveAddress, i2cBuffer, 2, true) == 0) {
Yann 2:bf7d1264d3ff 366 //wait(0.02);
Yann 0:fa858f79d48d 367 DEBUG("CFM24VXX_I2C::Read (short): Write memory done")
Yann 0:fa858f79d48d 368 // 2. Read data + I2C stop
Yann 0:fa858f79d48d 369 int result = _i2cInstance->read(_slaveAddress, i2cBuffer, 2);
Yann 0:fa858f79d48d 370 if (result == 0) {
Yann 1:6a16bddd7222 371 DEBUG("CFM24VXX_I2C::Read (short): value: 0x%02x - 0x%02x", i2cBuffer[0], i2cBuffer[1])
Yann 0:fa858f79d48d 372 if (p_mode == BigEndian) {
Yann 0:fa858f79d48d 373 *p_short = (short)(i2cBuffer[0] << 8 | i2cBuffer[1]);
Yann 0:fa858f79d48d 374 } else {
Yann 0:fa858f79d48d 375 *p_short = (short)(i2cBuffer[1] << 8 | i2cBuffer[0]);
Yann 0:fa858f79d48d 376 }
Yann 0:fa858f79d48d 377
Yann 0:fa858f79d48d 378 DEBUG_LEAVE("CFM24VXX_I2C::Read (short): 0x%04x", *p_short)
Yann 0:fa858f79d48d 379 return true;
Yann 0:fa858f79d48d 380 }
Yann 0:fa858f79d48d 381 }
Yann 0:fa858f79d48d 382
Yann 0:fa858f79d48d 383 DEBUG_LEAVE("CFM24VXX_I2C::Read (short) (false)")
Yann 0:fa858f79d48d 384 return false;
Yann 0:fa858f79d48d 385 }
Yann 0:fa858f79d48d 386
Yann 0:fa858f79d48d 387 bool CFM24VXX_I2C::Read(const short p_address, int *p_int, const CFM24VXX_I2C::Mode p_mode) {
Yann 0:fa858f79d48d 388 DEBUG_ENTER("CFM24VXX_I2C::Read (int): Memory address:0x%02x, Mode:%d", p_address, p_mode)
Yann 0:fa858f79d48d 389
Yann 0:fa858f79d48d 390 // 1.Prepare buffer
Yann 0:fa858f79d48d 391 char i2cBuffer[4];
Yann 0:fa858f79d48d 392 // 1.1. Memory address
Yann 0:fa858f79d48d 393 i2cBuffer[0] = (unsigned char)(p_address >> 8);
Yann 0:fa858f79d48d 394 DEBUG("CFM24VXX_I2C::Read (int): pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 0:fa858f79d48d 395 i2cBuffer[1] = (unsigned char)((unsigned char)p_address & 0xff);
Yann 0:fa858f79d48d 396 DEBUG("CFM24VXX_I2C::Read (int): pI2CBuffer[1]: 0x%02x", i2cBuffer[1])
Yann 0:fa858f79d48d 397
Yann 0:fa858f79d48d 398 // 2. Send I2C start + memory address
Yann 0:fa858f79d48d 399 if (_i2cInstance->write(_slaveAddress, i2cBuffer, 2, true) == 0) {
Yann 2:bf7d1264d3ff 400 //wait(0.02);
Yann 0:fa858f79d48d 401 DEBUG("CFM24VXX_I2C::Read (int): Write memory done")
Yann 0:fa858f79d48d 402 // 2. Read data + I2C stop
Yann 0:fa858f79d48d 403 int result = _i2cInstance->read(_slaveAddress, i2cBuffer, 4);
Yann 0:fa858f79d48d 404 if (result == 0) {
Yann 1:6a16bddd7222 405 DEBUG("CFM24VXX_I2C::Read (int): value: 0x%02x - 0x%02x - 0x%02x - 0x%02x", i2cBuffer[0], i2cBuffer[1], i2cBuffer[2], i2cBuffer[3])
Yann 2:bf7d1264d3ff 406 //wait(0.02);
Yann 0:fa858f79d48d 407 if (p_mode == BigEndian) {
Yann 0:fa858f79d48d 408 *p_int = (int)(i2cBuffer[0] << 24 | i2cBuffer[1] << 16 | i2cBuffer[2] << 8 | i2cBuffer[3]);
Yann 0:fa858f79d48d 409 } else {
Yann 0:fa858f79d48d 410 *p_int = (int)(i2cBuffer[3] << 24 | i2cBuffer[2] << 16 | i2cBuffer[1] << 8 | i2cBuffer[0]);
Yann 0:fa858f79d48d 411 }
Yann 0:fa858f79d48d 412
Yann 0:fa858f79d48d 413 DEBUG_LEAVE("CFM24VXX_I2C::Read (int): %d", *p_int)
Yann 0:fa858f79d48d 414 return true;
Yann 0:fa858f79d48d 415 }
Yann 0:fa858f79d48d 416
Yann 0:fa858f79d48d 417 DEBUG_LEAVE("CFM24VXX_I2C::Read (int):false")
Yann 0:fa858f79d48d 418 return false;
Yann 0:fa858f79d48d 419 }
Yann 0:fa858f79d48d 420
Yann 0:fa858f79d48d 421 DEBUG_LEAVE("CFM24VXX_I2C::Read (int) (false)")
Yann 0:fa858f79d48d 422 return false;
Yann 0:fa858f79d48d 423 }
Yann 0:fa858f79d48d 424
Yann 0:fa858f79d48d 425 bool CFM24VXX_I2C::Read(const short p_address, std::vector<unsigned char> & p_datas, const bool p_readLengthFirst, const int p_length2write) {
Yann 0:fa858f79d48d 426 DEBUG_ENTER("CFM24VXX_I2C::Read (vector): Memory address:0x%02x, readLength:%01x, Length:%d", p_address, p_readLengthFirst, p_length2write)
Yann 0:fa858f79d48d 427
Yann 0:fa858f79d48d 428 // 1.Prepare buffer
Yann 0:fa858f79d48d 429 short address = p_address;
Yann 0:fa858f79d48d 430 int length = 0;
Yann 0:fa858f79d48d 431 if (p_readLengthFirst) {
Yann 0:fa858f79d48d 432 if (!Read(address, &length)) { // Read the length in big endian mode
Yann 0:fa858f79d48d 433 DEBUG_LEAVE("CFM24VXX_I2C::Read (vector) Failed to read length")
Yann 0:fa858f79d48d 434 return false;
Yann 0:fa858f79d48d 435 }
Yann 0:fa858f79d48d 436 DEBUG("CFM24VXX_I2C::Read (vector): length= %d", length)
Yann 0:fa858f79d48d 437 if (length == 0) {
Yann 0:fa858f79d48d 438 return true;
Yann 0:fa858f79d48d 439 }
Yann 0:fa858f79d48d 440 address += 4; // Skip the length value
Yann 0:fa858f79d48d 441 length -= 4; // length is the size of (string length + string)
Yann 0:fa858f79d48d 442 } else {
Yann 0:fa858f79d48d 443 if (p_length2write == -1) {
Yann 0:fa858f79d48d 444 length = p_datas.size();
Yann 0:fa858f79d48d 445 } else {
Yann 0:fa858f79d48d 446 length = p_length2write;
Yann 0:fa858f79d48d 447 }
Yann 0:fa858f79d48d 448 }
Yann 0:fa858f79d48d 449 DEBUG("CFM24VXX_I2C::Read (vector): length= %d", length)
Yann 0:fa858f79d48d 450
Yann 0:fa858f79d48d 451 // 2. Memory address
Yann 0:fa858f79d48d 452 char i2cBuffer[2];
Yann 0:fa858f79d48d 453 i2cBuffer[0] = (unsigned char)(address >> 8);
Yann 0:fa858f79d48d 454 DEBUG("CFM24VXX_I2C::Read (vector): pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 0:fa858f79d48d 455 i2cBuffer[1] = (unsigned char)((unsigned char)address & 0xff);
Yann 0:fa858f79d48d 456 DEBUG("CFM24VXX_I2C::Read (vector): pI2CBuffer[1]: 0x%02x", i2cBuffer[1])
Yann 0:fa858f79d48d 457
Yann 0:fa858f79d48d 458 // 3. Send I2C start + memory address
Yann 0:fa858f79d48d 459 if (_i2cInstance->write(_slaveAddress, i2cBuffer, 2, true) == 0) {
Yann 2:bf7d1264d3ff 460 //wait(0.02);
Yann 0:fa858f79d48d 461 DEBUG("CFM24VXX_I2C::Read (vector): Write memory done")
Yann 0:fa858f79d48d 462 // 4. read data + I2C stop
Yann 0:fa858f79d48d 463 unsigned char buffer[length];
Yann 0:fa858f79d48d 464 int result = _i2cInstance->read(_slaveAddress, (char *)buffer, length);
Yann 2:bf7d1264d3ff 465 //wait(0.02);
Yann 0:fa858f79d48d 466 if (result == 0) {
Yann 0:fa858f79d48d 467 p_datas.assign(buffer, buffer + length);
Yann 0:fa858f79d48d 468
Yann 0:fa858f79d48d 469 DEBUG_LEAVE("CFM24VXX_I2C::Read (vector): %x", (bool)(result == 0))
Yann 0:fa858f79d48d 470 return (bool)(result == 0);
Yann 0:fa858f79d48d 471 }
Yann 0:fa858f79d48d 472 }
Yann 0:fa858f79d48d 473
Yann 0:fa858f79d48d 474 DEBUG_LEAVE("CFM24VXX_I2C::Read (vector) (false)")
Yann 0:fa858f79d48d 475 return false;
Yann 0:fa858f79d48d 476 }
Yann 0:fa858f79d48d 477
Yann 0:fa858f79d48d 478 bool CFM24VXX_I2C::Read(const short p_address, std::string & p_string, const bool p_readLengthFirst, const int p_length2write) {
Yann 0:fa858f79d48d 479 DEBUG_ENTER("CFM24VXX_I2C::Read (string): Memory address:0x%02x, readLength:%01x, Length:%d", p_address, p_readLengthFirst, p_length2write)
Yann 0:fa858f79d48d 480
Yann 0:fa858f79d48d 481 // 1.Prepare buffer
Yann 0:fa858f79d48d 482 short address = p_address;
Yann 0:fa858f79d48d 483 int length = -1;
Yann 0:fa858f79d48d 484 if (p_readLengthFirst) { // The string was stored with its length
Yann 0:fa858f79d48d 485 if (!Read(address, &length)) { // Read the length as integer in big endian mode
Yann 0:fa858f79d48d 486 DEBUG_ERROR("CFM24VXX_I2C::Read (string): Failed to read length")
Yann 0:fa858f79d48d 487 return false;
Yann 0:fa858f79d48d 488 }
Yann 2:bf7d1264d3ff 489 //wait(0.02);
Yann 0:fa858f79d48d 490 DEBUG("CFM24VXX_I2C::Read (string): length=%d", length)
Yann 0:fa858f79d48d 491 if (length == 0) {
Yann 0:fa858f79d48d 492 DEBUG_ERROR("CFM24VXX_I2C::Read (string): empty")
Yann 0:fa858f79d48d 493 return true;
Yann 0:fa858f79d48d 494 }
Yann 0:fa858f79d48d 495 address += 4; // Skip the length value size
Yann 0:fa858f79d48d 496 length -= 4; // length is the size of (string length + string)
Yann 0:fa858f79d48d 497 } else { // The string length is provided by p_length2write parameter
Yann 0:fa858f79d48d 498 if (p_length2write == -1) {
Yann 0:fa858f79d48d 499 length = p_string.size();
Yann 0:fa858f79d48d 500 } else {
Yann 0:fa858f79d48d 501 length = p_length2write;
Yann 0:fa858f79d48d 502 p_string.resize(p_length2write);
Yann 0:fa858f79d48d 503 }
Yann 0:fa858f79d48d 504 }
Yann 0:fa858f79d48d 505 DEBUG("CFM24VXX_I2C::Read (string): Address=0x%02x - Length=%d", address, length)
Yann 0:fa858f79d48d 506
Yann 0:fa858f79d48d 507 // 2. Memory address
Yann 0:fa858f79d48d 508 char i2cBuffer[2];
Yann 0:fa858f79d48d 509 i2cBuffer[0] = (unsigned char)(address >> 8);
Yann 0:fa858f79d48d 510 DEBUG("CFM24VXX_I2C::Read (string): pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 0:fa858f79d48d 511 i2cBuffer[1] = (unsigned char)((unsigned char)address & 0xff);
Yann 0:fa858f79d48d 512 DEBUG("CFM24VXX_I2C::Read (string): pI2CBuffer[1]: 0x%02x", i2cBuffer[1])
Yann 0:fa858f79d48d 513
Yann 0:fa858f79d48d 514 // 3. Send I2C start + memory address with repeat start
Yann 0:fa858f79d48d 515 if (_i2cInstance->write(_slaveAddress, i2cBuffer, 2, true) == 0) {
Yann 2:bf7d1264d3ff 516 //wait(0.02);
Yann 0:fa858f79d48d 517 DEBUG("CFM24VXX_I2C::Read (string): Write memory done")
Yann 0:fa858f79d48d 518 // 4. Read data + I2C stop
Yann 0:fa858f79d48d 519 char buffer[length];
Yann 0:fa858f79d48d 520 int result = _i2cInstance->read(_slaveAddress, (char *)buffer, length);
Yann 0:fa858f79d48d 521 if (result == 0) {
Yann 0:fa858f79d48d 522 p_string.assign(buffer, length);
Yann 0:fa858f79d48d 523
Yann 0:fa858f79d48d 524 return true;
Yann 0:fa858f79d48d 525 }
Yann 0:fa858f79d48d 526 }
Yann 0:fa858f79d48d 527
Yann 0:fa858f79d48d 528 DEBUG_LEAVE("CFM24VXX_I2C::Read (string) (false)")
Yann 0:fa858f79d48d 529 return false;
Yann 0:fa858f79d48d 530 }
Yann 1:6a16bddd7222 531
Yann 2:bf7d1264d3ff 532 bool CFM24VXX_I2C::Read(const short p_address, char *p_string, const bool p_storeLength, const int p_length2write) {
Yann 2:bf7d1264d3ff 533 DEBUG_ENTER("CFM24VXX_I2C::Read (char *): Memory address:0x%02x, readLength:%01x, Length:%d", p_address, p_storeLength, p_length2write)
Yann 2:bf7d1264d3ff 534
Yann 2:bf7d1264d3ff 535 // 1.Prepare buffer
Yann 2:bf7d1264d3ff 536 short address = p_address;
Yann 2:bf7d1264d3ff 537 int length = -1;
Yann 2:bf7d1264d3ff 538 if (p_storeLength) { // The string was stored with its length
Yann 2:bf7d1264d3ff 539 if (!Read(address, &length)) { // Read the length as integer in big endian mode
Yann 2:bf7d1264d3ff 540 DEBUG_ERROR("CFM24VXX_I2C::Read (char *): Failed to read length")
Yann 2:bf7d1264d3ff 541 return false;
Yann 2:bf7d1264d3ff 542 }
Yann 2:bf7d1264d3ff 543 //wait(0.02);
Yann 2:bf7d1264d3ff 544 DEBUG("CFM24VXX_I2C::Read (char *): length=%d", length)
Yann 2:bf7d1264d3ff 545 if (length == 0) {
Yann 2:bf7d1264d3ff 546 DEBUG_ERROR("CFM24VXX_I2C::Read (char *): empty")
Yann 2:bf7d1264d3ff 547 return true;
Yann 2:bf7d1264d3ff 548 }
Yann 2:bf7d1264d3ff 549 address += 4; // Skip the length value size
Yann 2:bf7d1264d3ff 550 length -= 4; // length is the size of (string length + string)
Yann 2:bf7d1264d3ff 551 } else { // The string length is provided by p_length2write parameter
Yann 2:bf7d1264d3ff 552 if (p_length2write == -1) {
Yann 2:bf7d1264d3ff 553 DEBUG_ERROR("CFM24VXX_I2C::Read (char *): undefined length")
Yann 2:bf7d1264d3ff 554 return false;
Yann 2:bf7d1264d3ff 555 } else {
Yann 2:bf7d1264d3ff 556 length = p_length2write;
Yann 2:bf7d1264d3ff 557 }
Yann 2:bf7d1264d3ff 558 }
Yann 2:bf7d1264d3ff 559 DEBUG("CFM24VXX_I2C::Read (char *): Address=0x%02x - Length=%d", address, length)
Yann 2:bf7d1264d3ff 560
Yann 2:bf7d1264d3ff 561 // 2. Memory address
Yann 2:bf7d1264d3ff 562 char i2cBuffer[2];
Yann 2:bf7d1264d3ff 563 i2cBuffer[0] = (unsigned char)(address >> 8);
Yann 2:bf7d1264d3ff 564 DEBUG("CFM24VXX_I2C::Read (char *): pI2CBuffer[0]: 0x%02x", i2cBuffer[0])
Yann 2:bf7d1264d3ff 565 i2cBuffer[1] = (unsigned char)((unsigned char)address & 0xff);
Yann 2:bf7d1264d3ff 566 DEBUG("CFM24VXX_I2C::Read (char *): pI2CBuffer[1]: 0x%02x", i2cBuffer[1])
Yann 2:bf7d1264d3ff 567
Yann 2:bf7d1264d3ff 568 // 3. Send I2C start + memory address with repeat start
Yann 2:bf7d1264d3ff 569 if (_i2cInstance->write(_slaveAddress, i2cBuffer, 2, true) == 0) {
Yann 2:bf7d1264d3ff 570 //wait(0.02);
Yann 2:bf7d1264d3ff 571 DEBUG("CFM24VXX_I2C::Read (char *): Write memory done")
Yann 2:bf7d1264d3ff 572 // 4. Read data + I2C stop
Yann 2:bf7d1264d3ff 573 char buffer[length];
Yann 2:bf7d1264d3ff 574 int result = _i2cInstance->read(_slaveAddress, buffer, length);
Yann 2:bf7d1264d3ff 575 memcpy((void *)p_string, (const void *)buffer, length);
Yann 2:bf7d1264d3ff 576
Yann 2:bf7d1264d3ff 577 DEBUG_LEAVE("CFM24VXX_I2C::Read (char *): %x", (bool)(result == 0))
Yann 2:bf7d1264d3ff 578 return (bool)(result == 0);
Yann 2:bf7d1264d3ff 579 }
Yann 2:bf7d1264d3ff 580
Yann 2:bf7d1264d3ff 581 DEBUG_LEAVE("CFM24VXX_I2C::Read (char *) (false)")
Yann 2:bf7d1264d3ff 582 return false;
Yann 2:bf7d1264d3ff 583 }
Yann 2:bf7d1264d3ff 584
Yann 1:6a16bddd7222 585 unsigned char CFM24VXX_I2C::ChecksumSN(const unsigned char *pdatas, const unsigned int length) {
Yann 1:6a16bddd7222 586 DEBUG_ENTER("CFM24VXX_I2C::ChecksumSN")
Yann 1:6a16bddd7222 587
Yann 1:6a16bddd7222 588 unsigned char crctable[256] = {
Yann 1:6a16bddd7222 589 0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15,
Yann 1:6a16bddd7222 590 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
Yann 1:6a16bddd7222 591 0x70, 0x77, 0x7E, 0x79, 0x6C, 0x6B, 0x62, 0x65,
Yann 1:6a16bddd7222 592 0x48, 0x4F, 0x46, 0x41, 0x54, 0x53, 0x5A, 0x5D,
Yann 1:6a16bddd7222 593 0xE0, 0xE7, 0xEE, 0xE9, 0xFC, 0xFB, 0xF2, 0xF5,
Yann 1:6a16bddd7222 594 0xD8, 0xDF, 0xD6, 0xD1, 0xC4, 0xC3, 0xCA, 0xCD,
Yann 1:6a16bddd7222 595 0x90, 0x97, 0x9E, 0x99, 0x8C, 0x8B, 0x82, 0x85,
Yann 1:6a16bddd7222 596 0xA8, 0xAF, 0xA6, 0xA1, 0xB4, 0xB3, 0xBA, 0xBD,
Yann 1:6a16bddd7222 597 0xC7, 0xC0, 0xC9, 0xCE, 0xDB, 0xDC, 0xD5, 0xD2,
Yann 1:6a16bddd7222 598 0xFF, 0xF8, 0xF1, 0xF6, 0xE3, 0xE4, 0xED, 0xEA,
Yann 1:6a16bddd7222 599 0xB7, 0xB0, 0xB9, 0xBE, 0xAB, 0xAC, 0xA5, 0xA2,
Yann 1:6a16bddd7222 600 0x8F, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9D, 0x9A,
Yann 1:6a16bddd7222 601 0x27, 0x20, 0x29, 0x2E, 0x3B, 0x3C, 0x35, 0x32,
Yann 1:6a16bddd7222 602 0x1F, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0D, 0x0A,
Yann 1:6a16bddd7222 603 0x57, 0x50, 0x59, 0x5E, 0x4B, 0x4C, 0x45, 0x42,
Yann 1:6a16bddd7222 604 0x6F, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7D, 0x7A,
Yann 1:6a16bddd7222 605 0x89, 0x8E, 0x87, 0x80, 0x95, 0x92, 0x9B, 0x9C,
Yann 1:6a16bddd7222 606 0xB1, 0xB6, 0xBF, 0xB8, 0xAD, 0xAA, 0xA3, 0xA4,
Yann 1:6a16bddd7222 607 0xF9, 0xFE, 0xF7, 0xF0, 0xE5, 0xE2, 0xEB, 0xEC,
Yann 1:6a16bddd7222 608 0xC1, 0xC6, 0xCF, 0xC8, 0xDD, 0xDA, 0xD3, 0xD4,
Yann 1:6a16bddd7222 609 0x69, 0x6E, 0x67, 0x60, 0x75, 0x72, 0x7B, 0x7C,
Yann 1:6a16bddd7222 610 0x51, 0x56, 0x5F, 0x58, 0x4D, 0x4A, 0x43, 0x44,
Yann 1:6a16bddd7222 611 0x19, 0x1E, 0x17, 0x10, 0x05, 0x02, 0x0B, 0x0C,
Yann 1:6a16bddd7222 612 0x21, 0x26, 0x2F, 0x28, 0x3D, 0x3A, 0x33, 0x34,
Yann 1:6a16bddd7222 613 0x4E, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5C, 0x5B,
Yann 1:6a16bddd7222 614 0x76, 0x71, 0x78, 0x7F, 0x6A, 0x6D, 0x64, 0x63,
Yann 1:6a16bddd7222 615 0x3E, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2C, 0x2B,
Yann 1:6a16bddd7222 616 0x06, 0x01, 0x08, 0x0F, 0x1A, 0x1D, 0x14, 0x13,
Yann 1:6a16bddd7222 617 0xAE, 0xA9, 0xA0, 0xA7, 0xB2, 0xB5, 0xBC, 0xBB,
Yann 1:6a16bddd7222 618 0x96, 0x91, 0x98, 0x9F, 0x8A, 0x8D, 0x84, 0x83,
Yann 1:6a16bddd7222 619 0xDE, 0xD9, 0xD0, 0xD7, 0xC2, 0xC5, 0xCC, 0xCB,
Yann 1:6a16bddd7222 620 0xE6, 0xE1, 0xE8, 0xEF, 0xFA, 0xFD, 0xF4, 0xF3
Yann 1:6a16bddd7222 621 };
Yann 1:6a16bddd7222 622 unsigned char crc = 0x00;
Yann 1:6a16bddd7222 623 unsigned int length_ = length;
Yann 1:6a16bddd7222 624 unsigned char *pdata = (unsigned char *)pdatas;
Yann 1:6a16bddd7222 625 while (length_-- != 0) {
Yann 1:6a16bddd7222 626 crc = crctable[crc ^ *pdata++];
Yann 1:6a16bddd7222 627 DEBUG("CFM24VXX_I2C::ChecksumSN: current checksum= 0x%02x - pdata:%08x", crc, pdata)
Yann 1:6a16bddd7222 628 }
Yann 1:6a16bddd7222 629
Yann 1:6a16bddd7222 630 DEBUG_LEAVE("CFM24VXX_I2C::ChecksumSN: 0x%02x", crc)
Yann 1:6a16bddd7222 631 return crc;
Yann 1:6a16bddd7222 632 }
Yann 1:6a16bddd7222 633
Yann 0:fa858f79d48d 634 #if defined(__DEBUG)
Yann 0:fa858f79d48d 635 void CFM24VXX_I2C::DumpMemoryArea(const int p_address, const int p_count) {
Yann 0:fa858f79d48d 636 DEBUG_ENTER("CFM24VXX_I2C::DumpMemoryArea: %d - %d", p_address, p_count)
Yann 0:fa858f79d48d 637
Yann 0:fa858f79d48d 638 DEBUG("CFM24VXX_I2C::DumpMemoryArea: Reading datas...");
Yann 0:fa858f79d48d 639 std::vector<unsigned char> datas(p_count);
Yann 0:fa858f79d48d 640 if (!Read(p_address, datas, false)) { // Read bytes, including the lenght indication, buffer size is not set before the call
Yann 0:fa858f79d48d 641 std::cout << "CFM24VXX_I2C::DumpMemoryArea: read failed\r" << std::endl;
Yann 0:fa858f79d48d 642 } else {
Yann 0:fa858f79d48d 643 std::cout << "CFM24VXX_I2C::DumpMemoryArea: Read bytes:\r" << std::endl;
Yann 0:fa858f79d48d 644 HEXADUMP(&datas[0], p_count);
Yann 0:fa858f79d48d 645 std::cout << "\r" << std::endl;
Yann 0:fa858f79d48d 646 }
Yann 0:fa858f79d48d 647 }
Yann 0:fa858f79d48d 648 #endif // _DEBUG
Yann 0:fa858f79d48d 649
Yann 0:fa858f79d48d 650 } // End of namespace _FM24VXX_I2C