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@1:71ea5acdee1b, 2010-11-25 (annotated)

Committer:
Yann
Date:
Thu Nov 25 13:34:01 2010 +0000
Revision:
1:71ea5acdee1b
Parent:
0:944015c441cb 
V0.0.2

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