Yann Garcia / Mbed 2 deprecated 24LCxx_I2CApp

This program illustrates how to use the 24LCxx_I2C library In this version, NTP service was added to set RTC time

Dependencies:   NetServices mbed

main.cpp@0:944015c441cb, 2010-11-25 (annotated)

Committer:
Yann
Date:
Thu Nov 25 06:59:09 2010 +0000
Revision:
0:944015c441cb
Child:
1:71ea5acdee1b
V0.0.1

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Yann 0:944015c441cb 1 #include <string>
Yann 0:944015c441cb 2
Yann 0:944015c441cb 3 #include "24LCxx_I2C.h"
Yann 0:944015c441cb 4
Yann 0:944015c441cb 5 /*
Yann 0:944015c441cb 6 * Declare functions
Yann 0:944015c441cb 7 */
Yann 0:944015c441cb 8
Yann 0:944015c441cb 9 void AvailableIndicator();
Yann 0:944015c441cb 10 char DisplayMenuAndGetChoice(); // Display and get the user choice
Yann 0:944015c441cb 11 void RunStateMachine_WithStdStringValue(); // Write and read a string
Yann 0:944015c441cb 12 void RunStateMachine_WithByteValue(); // Write and read a byte
Yann 0:944015c441cb 13 void RunStateMachine_WithShortValue(C2424LCXX_I2C::Mode p_mode); // Write and read a short
Yann 0:944015c441cb 14 void RunStateMachine_WithIntegerValue(C2424LCXX_I2C::Mode p_mode); // Write and read an integer
Yann 0:944015c441cb 15 void RunStateMachine_WithStdVectorOfByteValue(); // Write and read a buffer of bytes
Yann 0:944015c441cb 16 void RunStateMachine_WithLengthPlusStdVectorOfByteValue(); // Write and read a buffer of bytes
Yann 0:944015c441cb 17
Yann 0:944015c441cb 18 /*
Yann 0:944015c441cb 19 * Declare statics
Yann 0:944015c441cb 20 */
Yann 0:944015c441cb 21 enum States {
Yann 0:944015c441cb 22 Idle,
Yann 0:944015c441cb 23 Write,
Yann 0:944015c441cb 24 Written,
Yann 0:944015c441cb 25 Read
Yann 0:944015c441cb 26 };
Yann 0:944015c441cb 27 States g_state; // Process states for memory operations
Yann 0:944015c441cb 28
Yann 0:944015c441cb 29 DigitalOut g_availableLed(LED1); // To verify if program in running
Yann 0:944015c441cb 30 Ticker g_available; // LED1 will flash with a period of 2s
Yann 0:944015c441cb 31
Yann 0:944015c441cb 32 C2424LCXX_I2C g_myEEPROM(p28, p27, 0x01, p5, 400000); // Create an instance of the class C2424LCXX_I2C, p28: SDA, p29:SDL, p5: wired to WP input of 24LCxx, address: A3=0,A2=0,A=1, on 3.3V I2C bus
Yann 0:944015c441cb 33
Yann 0:944015c441cb 34 int main() {
Yann 0:944015c441cb 35
Yann 0:944015c441cb 36 wait(1); // Needed after startup
Yann 0:944015c441cb 37
Yann 0:944015c441cb 38 // Launch available indocator
Yann 0:944015c441cb 39 g_available.attach(&AvailableIndicator, 2.0);
Yann 0:944015c441cb 40
Yann 0:944015c441cb 41 g_myEEPROM.WriteProtect(false); // Disabe WP (pin 7) - See DS21203M - Clause 2.4 Write-Protect (WP)
Yann 0:944015c441cb 42
Yann 0:944015c441cb 43 while (true) { // Interrupt driven processing
Yann 0:944015c441cb 44 g_state = Idle;
Yann 0:944015c441cb 45 switch (DisplayMenuAndGetChoice()) {
Yann 0:944015c441cb 46 case 'a':
Yann 0:944015c441cb 47 do {
Yann 0:944015c441cb 48 RunStateMachine_WithStdStringValue();
Yann 0:944015c441cb 49 } while (g_state != Idle);
Yann 0:944015c441cb 50 break;
Yann 0:944015c441cb 51 case 'b':
Yann 0:944015c441cb 52 do {
Yann 0:944015c441cb 53 RunStateMachine_WithByteValue();
Yann 0:944015c441cb 54 } while (g_state != Idle);
Yann 0:944015c441cb 55 break;
Yann 0:944015c441cb 56 case 'c':
Yann 0:944015c441cb 57 do {
Yann 0:944015c441cb 58 RunStateMachine_WithShortValue(C2424LCXX_I2C::BigEndian);
Yann 0:944015c441cb 59 } while (g_state != Idle);
Yann 0:944015c441cb 60 break;
Yann 0:944015c441cb 61 case 'd':
Yann 0:944015c441cb 62 do {
Yann 0:944015c441cb 63 RunStateMachine_WithShortValue(C2424LCXX_I2C::LittleEndian);
Yann 0:944015c441cb 64 } while (g_state != Idle);
Yann 0:944015c441cb 65 break;
Yann 0:944015c441cb 66 case 'e':
Yann 0:944015c441cb 67 do {
Yann 0:944015c441cb 68 RunStateMachine_WithIntegerValue(C2424LCXX_I2C::BigEndian);
Yann 0:944015c441cb 69 } while (g_state != Idle);
Yann 0:944015c441cb 70 break;
Yann 0:944015c441cb 71 case 'f':
Yann 0:944015c441cb 72 do {
Yann 0:944015c441cb 73 RunStateMachine_WithIntegerValue(C2424LCXX_I2C::LittleEndian);
Yann 0:944015c441cb 74 } while (g_state != Idle);
Yann 0:944015c441cb 75 break;
Yann 0:944015c441cb 76 case 'g':
Yann 0:944015c441cb 77 do {
Yann 0:944015c441cb 78 RunStateMachine_WithStdVectorOfByteValue();
Yann 0:944015c441cb 79 } while (g_state != Idle);
Yann 0:944015c441cb 80 break;
Yann 0:944015c441cb 81 case 'h':
Yann 0:944015c441cb 82 do {
Yann 0:944015c441cb 83 RunStateMachine_WithLengthPlusStdVectorOfByteValue();
Yann 0:944015c441cb 84 } while (g_state != Idle);
Yann 0:944015c441cb 85 break;
Yann 0:944015c441cb 86 default:
Yann 0:944015c441cb 87 printf("Invalid user choice\r\n");
Yann 0:944015c441cb 88 break;
Yann 0:944015c441cb 89 } // End of 'switch' statement
Yann 0:944015c441cb 90 } // End of 'while' statement
Yann 0:944015c441cb 91 } // End of program - nerver reached
Yann 0:944015c441cb 92
Yann 0:944015c441cb 93 void AvailableIndicator()
Yann 0:944015c441cb 94 {
Yann 0:944015c441cb 95 g_availableLed = !g_availableLed;
Yann 0:944015c441cb 96 } // End of AvailableIndicator
Yann 0:944015c441cb 97
Yann 0:944015c441cb 98 char DisplayMenuAndGetChoice()
Yann 0:944015c441cb 99 {
Yann 0:944015c441cb 100 printf("\r\n\r\n24LCxx_I2C v0.1\r\n");
Yann 0:944015c441cb 101 printf("\tWrite/Read with std::string:\t\t\ta\r\n");
Yann 0:944015c441cb 102 printf("\tWrite/Read with a byte:\t\t\t\tb\r\n");
Yann 0:944015c441cb 103 printf("\tWrite/Read with a short (Big Endian):\t\tc\r\n");
Yann 0:944015c441cb 104 printf("\tWrite/Read with a short (Little Endian):\td\r\n");
Yann 0:944015c441cb 105 printf("\tWrite/Read with an integer (Big Endian):\te\r\n");
Yann 0:944015c441cb 106 printf("\tWrite/Read with an integer (Little Endian):\tf\r\n");
Yann 0:944015c441cb 107 printf("\tWrite/Read with std::vector<byte>:\t\tg\r\n");
Yann 0:944015c441cb 108 printf("\tWrite/Read with std::vector<byte> + length:\th\r\n");
Yann 0:944015c441cb 109 printf("Enter your choice:\r\n");
Yann 0:944015c441cb 110 return getchar();
Yann 0:944015c441cb 111 }
Yann 0:944015c441cb 112
Yann 0:944015c441cb 113 void RunStateMachine_WithStdStringValue()
Yann 0:944015c441cb 114 {
Yann 0:944015c441cb 115 DEBUG_ENTER("RunStateMachine_WithStdStringValue")
Yann 0:944015c441cb 116
Yann 0:944015c441cb 117 switch (g_state) {
Yann 0:944015c441cb 118 case Idle:
Yann 0:944015c441cb 119 g_state = Write;
Yann 0:944015c441cb 120 break;
Yann 0:944015c441cb 121 case Write: {
Yann 0:944015c441cb 122 DEBUG("Writing data...");
Yann 0:944015c441cb 123 time_t ctTime;
Yann 0:944015c441cb 124 ctTime = time(NULL);
Yann 0:944015c441cb 125 std::string str("Current time is: ");
Yann 0:944015c441cb 126 str += ctime(&ctTime);
Yann 0:944015c441cb 127 str += " UTC";
Yann 0:944015c441cb 128 printf("RunStateMachine_WithStdStringValue: Write '%s'\r\n", str.c_str());
Yann 0:944015c441cb 129 if (!g_myEEPROM.Write(256, str)) { // Write the string, including the length indicator
Yann 0:944015c441cb 130 DEBUG_FATAL("RunStateMachine_WithStdStringValue: write failed at address 256")
Yann 0:944015c441cb 131 g_state = Idle;
Yann 0:944015c441cb 132 } else {
Yann 0:944015c441cb 133 g_state = Written;
Yann 0:944015c441cb 134 }
Yann 0:944015c441cb 135 }
Yann 0:944015c441cb 136 break;
Yann 0:944015c441cb 137 case Written:
Yann 0:944015c441cb 138 g_state = Read;
Yann 0:944015c441cb 139 break;
Yann 0:944015c441cb 140 case Read: {
Yann 0:944015c441cb 141 DEBUG("Reading datas...");
Yann 0:944015c441cb 142 std::string readtext;
Yann 0:944015c441cb 143 if (!g_myEEPROM.Read(256, readtext)) { // Read the string, including the length indicator
Yann 0:944015c441cb 144 #ifdef __DEBUG
Yann 0:944015c441cb 145 DEBUG_FATAL("RunStateMachine_WithStdStringValue: write failed at address 256")
Yann 0:944015c441cb 146 #else // __DEBUG
Yann 0:944015c441cb 147 printf("RunStateMachine_WithStdStringValue: write failed at address 256\r\n");
Yann 0:944015c441cb 148 #endif // __DEBUG
Yann 0:944015c441cb 149 } else {
Yann 0:944015c441cb 150 printf("RunStateMachine_WithStdStringValue: Read:'%s'\r\n", readtext.c_str());
Yann 0:944015c441cb 151 }
Yann 0:944015c441cb 152 }
Yann 0:944015c441cb 153 g_state = Idle;
Yann 0:944015c441cb 154 break;
Yann 0:944015c441cb 155 default:
Yann 0:944015c441cb 156 printf("RunStateMachine_WithStdStringValue: Default!\r\n");
Yann 0:944015c441cb 157 g_state = Idle;
Yann 0:944015c441cb 158 break;
Yann 0:944015c441cb 159 }
Yann 0:944015c441cb 160
Yann 0:944015c441cb 161 DEBUG_LEAVE("RunStateMachine_WithStdStringValue")
Yann 0:944015c441cb 162 }
Yann 0:944015c441cb 163
Yann 0:944015c441cb 164 void RunStateMachine_WithByteValue() {
Yann 0:944015c441cb 165 DEBUG_ENTER("RunStateMachine_WithByteValue")
Yann 0:944015c441cb 166
Yann 0:944015c441cb 167 switch (g_state) {
Yann 0:944015c441cb 168 case Idle:
Yann 0:944015c441cb 169 g_state = Write;
Yann 0:944015c441cb 170 break;
Yann 0:944015c441cb 171 case Write:
Yann 0:944015c441cb 172 DEBUG("Writing data...")
Yann 0:944015c441cb 173 printf("RunStateMachine_WithByteValue: Write 0xaa\r\n");
Yann 0:944015c441cb 174 if (!g_myEEPROM.Write(128, (unsigned char)0xaa)) {
Yann 0:944015c441cb 175 #ifdef __DEBUG
Yann 0:944015c441cb 176 DEBUG_FATAL("RunStateMachine_WithByteValue: write failed at address 128")
Yann 0:944015c441cb 177 #else // __DEBUG
Yann 0:944015c441cb 178 printf("RunStateMachine_WithByteValue: write failed at address 128\r\n");
Yann 0:944015c441cb 179 #endif // __DEBUG
Yann 0:944015c441cb 180 g_state = Idle;
Yann 0:944015c441cb 181 } else {
Yann 0:944015c441cb 182 g_state = Written;
Yann 0:944015c441cb 183 }
Yann 0:944015c441cb 184 break;
Yann 0:944015c441cb 185 case Written:
Yann 0:944015c441cb 186 g_state = Read;
Yann 0:944015c441cb 187 break;
Yann 0:944015c441cb 188 case Read: {
Yann 0:944015c441cb 189 DEBUG("Reading datas...")
Yann 0:944015c441cb 190 unsigned char value = 0x00;
Yann 0:944015c441cb 191 if (!g_myEEPROM.Read(128, &value)) {
Yann 0:944015c441cb 192 #ifdef __DEBUG
Yann 0:944015c441cb 193 DEBUG_FATAL("RunStateMachine_WithByteValue: Read operation failed at address 128")
Yann 0:944015c441cb 194 #else // __DEBUG
Yann 0:944015c441cb 195 printf("RunStateMachine_WithByteValue: Read operation failed at address 128\r\n");
Yann 0:944015c441cb 196 #endif // __DEBUG
Yann 0:944015c441cb 197 } else {
Yann 0:944015c441cb 198 printf("RunStateMachine_WithByteValue: Read '0x%02x'\r\n", value);
Yann 0:944015c441cb 199 }
Yann 0:944015c441cb 200 }
Yann 0:944015c441cb 201 g_state = Idle;
Yann 0:944015c441cb 202 break;
Yann 0:944015c441cb 203 default:
Yann 0:944015c441cb 204 printf("RunStateMachine_WithByteValue: Default!\r\n");
Yann 0:944015c441cb 205 g_state = Idle;
Yann 0:944015c441cb 206 break;
Yann 0:944015c441cb 207 }
Yann 0:944015c441cb 208
Yann 0:944015c441cb 209 DEBUG_LEAVE("RunStateMachine_WithByteValue")
Yann 0:944015c441cb 210 }
Yann 0:944015c441cb 211
Yann 0:944015c441cb 212 void RunStateMachine_WithShortValue(C2424LCXX_I2C::Mode p_mode) {
Yann 0:944015c441cb 213 DEBUG_ENTER("RunStateMachine_WithShortValue")
Yann 0:944015c441cb 214
Yann 0:944015c441cb 215 switch (g_state) {
Yann 0:944015c441cb 216 case Idle:
Yann 0:944015c441cb 217 g_state = Write;
Yann 0:944015c441cb 218 break;
Yann 0:944015c441cb 219 case Write:
Yann 0:944015c441cb 220 DEBUG("Writing data...")
Yann 0:944015c441cb 221 printf("RunStateMachine_WithShortValue: Write 0xbeef\r\n");
Yann 0:944015c441cb 222 if (!g_myEEPROM.Write(64, (short)0xbeef, p_mode)) { // See http://en.wikipedia.org/wiki/Hexspeak for more ideas on hexadecimal wording!!!
Yann 0:944015c441cb 223 DEBUG_FATAL("RunStateMachine_WithShortValue: write failed at address 64")
Yann 0:944015c441cb 224 g_state = Idle;
Yann 0:944015c441cb 225 } else {
Yann 0:944015c441cb 226 g_state = Written;
Yann 0:944015c441cb 227 }
Yann 0:944015c441cb 228 break;
Yann 0:944015c441cb 229 case Written:
Yann 0:944015c441cb 230 g_state = Read;
Yann 0:944015c441cb 231 break;
Yann 0:944015c441cb 232 case Read: {
Yann 0:944015c441cb 233 DEBUG("Reading datas...");
Yann 0:944015c441cb 234 short value = 0;
Yann 0:944015c441cb 235 if (!g_myEEPROM.Read(64, &value, p_mode)) {
Yann 0:944015c441cb 236 #ifdef __DEBUG
Yann 0:944015c441cb 237 DEBUG_FATAL("RunStateMachine_WithShortValue: write failed at address 64")
Yann 0:944015c441cb 238 #else // __DEBUG
Yann 0:944015c441cb 239 printf("RunStateMachine_WithShortValue: write failed at address 64\r\n");
Yann 0:944015c441cb 240 #endif // __DEBUG
Yann 0:944015c441cb 241 } else {
Yann 0:944015c441cb 242 printf("RunStateMachine_WithShortValue: Read '0x%04x' / '%hu'\r\n", value, (unsigned short)value);
Yann 0:944015c441cb 243 }
Yann 0:944015c441cb 244 }
Yann 0:944015c441cb 245 g_state = Idle;
Yann 0:944015c441cb 246 break;
Yann 0:944015c441cb 247 default:
Yann 0:944015c441cb 248 printf("RunStateMachine_WithShortValue: Default!\r\n");
Yann 0:944015c441cb 249 g_state = Idle;
Yann 0:944015c441cb 250 break;
Yann 0:944015c441cb 251 }
Yann 0:944015c441cb 252
Yann 0:944015c441cb 253 DEBUG_LEAVE("RunStateMachine_WithShortValue")
Yann 0:944015c441cb 254 }
Yann 0:944015c441cb 255
Yann 0:944015c441cb 256 void RunStateMachine_WithIntegerValue(C2424LCXX_I2C::Mode p_mode) {
Yann 0:944015c441cb 257 DEBUG_ENTER("RunStateMachine_WithIntegerValue")
Yann 0:944015c441cb 258
Yann 0:944015c441cb 259 switch (g_state) {
Yann 0:944015c441cb 260 case Idle:
Yann 0:944015c441cb 261 g_state = Write;
Yann 0:944015c441cb 262 break;
Yann 0:944015c441cb 263 case Write:
Yann 0:944015c441cb 264 DEBUG("Writing data...")
Yann 0:944015c441cb 265 printf("RunStateMachine_WithIntegerValue: Write 0xdeaddead\r\n");
Yann 0:944015c441cb 266 if (!g_myEEPROM.Write(32, (int)0xdeaddead, p_mode)) {
Yann 0:944015c441cb 267 DEBUG_FATAL("RunStateMachine_WithIntegerValue: write failed at address 32")
Yann 0:944015c441cb 268 g_state = Idle;
Yann 0:944015c441cb 269 } else {
Yann 0:944015c441cb 270 g_state = Written;
Yann 0:944015c441cb 271 }
Yann 0:944015c441cb 272 break;
Yann 0:944015c441cb 273 case Written:
Yann 0:944015c441cb 274 g_state = Read;
Yann 0:944015c441cb 275 break;
Yann 0:944015c441cb 276 case Read: {
Yann 0:944015c441cb 277 DEBUG("Reading datas...")
Yann 0:944015c441cb 278 int value = 0;
Yann 0:944015c441cb 279 if (!g_myEEPROM.Read(32, &value, p_mode)) {
Yann 0:944015c441cb 280 #ifdef __DEBUG
Yann 0:944015c441cb 281 DEBUG_FATAL("RunStateMachine_WithIntegerValue: write failed at address 32")
Yann 0:944015c441cb 282 #else // __DEBUG
Yann 0:944015c441cb 283 printf("RunStateMachine_WithIntegerValue: write failed at address 32\r\n");
Yann 0:944015c441cb 284 #endif // __DEBUG
Yann 0:944015c441cb 285 } else {
Yann 0:944015c441cb 286 printf("RunStateMachine_WithIntegerValue: Read '0x%08x' / '%d'\r\n", value, (unsigned int)value);
Yann 0:944015c441cb 287 }
Yann 0:944015c441cb 288 }
Yann 0:944015c441cb 289 g_state = Idle;
Yann 0:944015c441cb 290 break;
Yann 0:944015c441cb 291 default:
Yann 0:944015c441cb 292 printf("RunStateMachine_WithIntegerValue: Default!\r\n");
Yann 0:944015c441cb 293 g_state = Idle;
Yann 0:944015c441cb 294 break;
Yann 0:944015c441cb 295 }
Yann 0:944015c441cb 296
Yann 0:944015c441cb 297 DEBUG_LEAVE("RunStateMachine_WithIntegerValue")
Yann 0:944015c441cb 298 }
Yann 0:944015c441cb 299
Yann 0:944015c441cb 300 void RunStateMachine_WithStdVectorOfByteValue() {
Yann 0:944015c441cb 301 DEBUG_ENTER("RunStateMachine_WithStdVectorOfByteValue")
Yann 0:944015c441cb 302
Yann 0:944015c441cb 303 switch (g_state) {
Yann 0:944015c441cb 304 case Idle:
Yann 0:944015c441cb 305 g_state = Write;
Yann 0:944015c441cb 306 break;
Yann 0:944015c441cb 307 case Write: {
Yann 0:944015c441cb 308 std::vector<unsigned char> datas;
Yann 0:944015c441cb 309 datas.push_back(0xfe);
Yann 0:944015c441cb 310 datas.push_back(0xed);
Yann 0:944015c441cb 311 datas.push_back(0xfa);
Yann 0:944015c441cb 312 datas.push_back(0xce);
Yann 0:944015c441cb 313 DEBUG("Writing data...")
Yann 0:944015c441cb 314 printf("RunStateMachine_WithStdVectorOfByteValue: Write {0xfe, 0xed, 0xfa, 0xce}\r\n");
Yann 0:944015c441cb 315 if (!g_myEEPROM.Write(16, datas, false)) { // Write the full buffer, not including the length indication
Yann 0:944015c441cb 316 DEBUG_FATAL("RunStateMachine_WithStdVectorOfByteValue: write failed at address 16")
Yann 0:944015c441cb 317 g_state = Idle;
Yann 0:944015c441cb 318 } else {
Yann 0:944015c441cb 319 g_state = Written;
Yann 0:944015c441cb 320 }
Yann 0:944015c441cb 321 }
Yann 0:944015c441cb 322 break;
Yann 0:944015c441cb 323 case Written:
Yann 0:944015c441cb 324 g_state = Read;
Yann 0:944015c441cb 325 break;
Yann 0:944015c441cb 326 case Read: {
Yann 0:944015c441cb 327 DEBUG("Reading datas...")
Yann 0:944015c441cb 328 std::vector<unsigned char> datas(4);
Yann 0:944015c441cb 329 if (!g_myEEPROM.Read(16, datas, false)) { // Read bytes, without the lenght indication, buffer size shall be set before the call
Yann 0:944015c441cb 330 #ifdef __DEBUG
Yann 0:944015c441cb 331 DEBUG_FATAL("RunStateMachine_WithStdVectorOfByteValue: write failed at address 16")
Yann 0:944015c441cb 332 #else // __DEBUG
Yann 0:944015c441cb 333 printf("RunStateMachine_WithStdVectorOfByteValue: write failed at address 16\r\n");
Yann 0:944015c441cb 334 #endif // __DEBUG
Yann 0:944015c441cb 335 } else {
Yann 0:944015c441cb 336 printf("RunStateMachine_WithStdVectorOfByteValue: Read {%02x, %02x, %02x, %02x}\r\n", datas[0], datas[1], datas[2], datas[3]);
Yann 0:944015c441cb 337 }
Yann 0:944015c441cb 338 }
Yann 0:944015c441cb 339 g_state = Idle;
Yann 0:944015c441cb 340 break;
Yann 0:944015c441cb 341 default:
Yann 0:944015c441cb 342 printf("RunStateMachine_WithStdVectorOfByteValue: Default!\r\n");
Yann 0:944015c441cb 343 g_state = Idle;
Yann 0:944015c441cb 344 break;
Yann 0:944015c441cb 345 }
Yann 0:944015c441cb 346
Yann 0:944015c441cb 347 DEBUG_LEAVE("RunStateMachine_WithStdVectorOfByteValue")
Yann 0:944015c441cb 348 }
Yann 0:944015c441cb 349
Yann 0:944015c441cb 350 void RunStateMachine_WithLengthPlusStdVectorOfByteValue() {
Yann 0:944015c441cb 351 DEBUG_ENTER("RunStateMachine_WithLengthPlusStdVectorOfByteValue")
Yann 0:944015c441cb 352
Yann 0:944015c441cb 353 switch (g_state) {
Yann 0:944015c441cb 354 case Idle:
Yann 0:944015c441cb 355 g_state = Write;
Yann 0:944015c441cb 356 break;
Yann 0:944015c441cb 357 case Write: {
Yann 0:944015c441cb 358 DEBUG("Writing data...")
Yann 0:944015c441cb 359 std::vector<unsigned char> datas;
Yann 0:944015c441cb 360 datas.push_back(0xde);
Yann 0:944015c441cb 361 datas.push_back(0x5e);
Yann 0:944015c441cb 362 datas.push_back(0xa5);
Yann 0:944015c441cb 363 datas.push_back(0xed);
Yann 0:944015c441cb 364 printf("RunStateMachine_WithLengthPlusStdVectorOfByteValue: Write {0xde, 0x5e, 0xa5, 0xed}\r\n");
Yann 0:944015c441cb 365 if (!g_myEEPROM.Write(8, datas)) { // Write the full buffer, including the length indication
Yann 0:944015c441cb 366 DEBUG_FATAL("RunStateMachine_WithLengthPlusStdVectorOfByteValue: write failed at address 8")
Yann 0:944015c441cb 367 g_state = Idle;
Yann 0:944015c441cb 368 } else {
Yann 0:944015c441cb 369 g_state = Written;
Yann 0:944015c441cb 370 }
Yann 0:944015c441cb 371 }
Yann 0:944015c441cb 372 break;
Yann 0:944015c441cb 373 case Written:
Yann 0:944015c441cb 374 g_state = Read;
Yann 0:944015c441cb 375 break;
Yann 0:944015c441cb 376 case Read: {
Yann 0:944015c441cb 377 DEBUG("Reading datas...")
Yann 0:944015c441cb 378 std::vector<unsigned char> datas;
Yann 0:944015c441cb 379 if (!g_myEEPROM.Read(8, datas)) { // Read bytes, including the lenght indication, buffer size is not set before the call
Yann 0:944015c441cb 380 #ifdef __DEBUG
Yann 0:944015c441cb 381 DEBUG_FATAL("RunStateMachine_WithStdVectorOfByteValue: write failed at address 8")
Yann 0:944015c441cb 382 #else // __DEBUG
Yann 0:944015c441cb 383 printf("RunStateMachine_WithStdVectorOfByteValue: write failed at address 8\r\n");
Yann 0:944015c441cb 384 #endif // __DEBUG
Yann 0:944015c441cb 385 } else {
Yann 0:944015c441cb 386 printf("RunStateMachine_WithLengthPlusStdVectorOfByteValue: Read bytes: ");
Yann 0:944015c441cb 387 vector<unsigned char>::iterator it;
Yann 0:944015c441cb 388 for (it = datas.begin() ; it < datas.end(); it++) {
Yann 0:944015c441cb 389 printf("0x%02x ", *it);
Yann 0:944015c441cb 390 }
Yann 0:944015c441cb 391 printf("\r\n");
Yann 0:944015c441cb 392 }
Yann 0:944015c441cb 393 }
Yann 0:944015c441cb 394 g_state = Idle;
Yann 0:944015c441cb 395 break;
Yann 0:944015c441cb 396 default:
Yann 0:944015c441cb 397 printf("RunStateMachine_WithLengthPlusStdVectorOfByteValue: Default!\r\n");
Yann 0:944015c441cb 398 g_state = Idle;
Yann 0:944015c441cb 399 break;
Yann 0:944015c441cb 400 }
Yann 0:944015c441cb 401
Yann 0:944015c441cb 402 DEBUG_LEAVE("RunStateMachine_WithLengthPlusStdVectorOfByteValue")
Yann 0:944015c441cb 403 }