Yann Garcia / Mbed 2 deprecated FM24Vxx_I2CApp

Test application for the library FM24Vxx_I2C

Dependencies:   DebugLibrary FM24Vxx_I2C mbed

main.cpp@0:30f4bcb2a3c0, 2013-03-23 (annotated)

Committer:
Yann
Date:
Sat Mar 23 15:54:36 2013 +0000
Revision:
0:30f4bcb2a3c0
Child:
1:e3c92ff30be3
Createapplication test for library interface for FM24V10 1Mb Serial 3V F-RAM Memory

Who changed what in which revision?

UserRevisionLine numberNew contents of line
Yann 0:30f4bcb2a3c0 1 #include <string>
Yann 0:30f4bcb2a3c0 2 #include <iostream>
Yann 0:30f4bcb2a3c0 3 #include <iomanip>
Yann 0:30f4bcb2a3c0 4
Yann 0:30f4bcb2a3c0 5 #include "FM24Vxx_I2C.h"
Yann 0:30f4bcb2a3c0 6
Yann 0:30f4bcb2a3c0 7 struct UserChoice {
Yann 0:30f4bcb2a3c0 8 char choice;
Yann 0:30f4bcb2a3c0 9 unsigned char moduleId;
Yann 0:30f4bcb2a3c0 10 };
Yann 0:30f4bcb2a3c0 11
Yann 0:30f4bcb2a3c0 12 /*
Yann 0:30f4bcb2a3c0 13 * Declare functions
Yann 0:30f4bcb2a3c0 14 */
Yann 0:30f4bcb2a3c0 15 void AvailableIndicator(); // LED1 flashing for program while program is alive
Yann 0:30f4bcb2a3c0 16 UserChoice DisplayMenuAndGetChoice(); // Display and get the user choice
Yann 0:30f4bcb2a3c0 17 void RunStateMachine_WithStdStringValue(); // Write and read a string
Yann 0:30f4bcb2a3c0 18 void RunStateMachine_WithByteValue(); // Write and read a byte
Yann 0:30f4bcb2a3c0 19 void RunStateMachine_WithShortValue(CFM24VXX_I2C::Mode p_mode); // Write and read a short
Yann 0:30f4bcb2a3c0 20 void RunStateMachine_WithIntegerValue(CFM24VXX_I2C::Mode p_mode); // Write and read an integer
Yann 0:30f4bcb2a3c0 21 void RunStateMachine_WithStdVectorOfByteValue(); // Write and read a buffer of bytes
Yann 0:30f4bcb2a3c0 22 void RunStateMachine_WithLengthPlusStdVectorOfByteValue(); // Write and read a buffer of bytes
Yann 0:30f4bcb2a3c0 23 void ReadStdStringValue(const int p_address); // Read a string
Yann 0:30f4bcb2a3c0 24
Yann 0:30f4bcb2a3c0 25 enum States {
Yann 0:30f4bcb2a3c0 26 Idle, // Idle state / Read memory operation done
Yann 0:30f4bcb2a3c0 27 Write, // Write memory operation
Yann 0:30f4bcb2a3c0 28 Written, // Write memory operation done
Yann 0:30f4bcb2a3c0 29 Read // Read memory operation
Yann 0:30f4bcb2a3c0 30 };
Yann 0:30f4bcb2a3c0 31 States g_state; // Process states for memory operations
Yann 0:30f4bcb2a3c0 32
Yann 0:30f4bcb2a3c0 33 DigitalOut g_availableLed(LED1); // To verify if program in running
Yann 0:30f4bcb2a3c0 34 Ticker g_available; // LED1 will flash with a period of 2s
Yann 0:30f4bcb2a3c0 35 DigitalOut g_singleSeqNumScope(p6); // To synchronize the num scope to capture I2C trame
Yann 0:30f4bcb2a3c0 36 UserChoice g_userChoice; // Used to store user choice from displayed menu
Yann 0:30f4bcb2a3c0 37
Yann 0:30f4bcb2a3c0 38 CFM24VXX_I2C g_myEEPROM(p9, p10, 0x01, p5, 400000); // Create an instance of the class CFM24VXX_I2C, p9/28: SDA, p10/29:SDL, p5: wired to WP input of FM24Vxx, address: A2=0,A1=1, on I2C bus
Yann 0:30f4bcb2a3c0 39
Yann 0:30f4bcb2a3c0 40 int main() {
Yann 0:30f4bcb2a3c0 41
Yann 0:30f4bcb2a3c0 42 g_singleSeqNumScope = 0;
Yann 0:30f4bcb2a3c0 43
Yann 0:30f4bcb2a3c0 44 // Launch available indicator
Yann 0:30f4bcb2a3c0 45 g_available.attach(&AvailableIndicator, 2.0);
Yann 0:30f4bcb2a3c0 46
Yann 0:30f4bcb2a3c0 47 g_myEEPROM.WriteProtect(false); // Disabe WP (pin 7) - See DS21203M - Clause 2.4 Write-Protect (WP)
Yann 0:30f4bcb2a3c0 48
Yann 0:30f4bcb2a3c0 49 while (true) { // Interrupt driven processing
Yann 0:30f4bcb2a3c0 50 g_state = Idle; // Set initial state
Yann 0:30f4bcb2a3c0 51 g_userChoice = DisplayMenuAndGetChoice(); // Retrieve the user selection
Yann 0:30f4bcb2a3c0 52 DEBUG("User selects I2C Module %x", g_userChoice.moduleId)
Yann 0:30f4bcb2a3c0 53 switch (g_userChoice.choice) {
Yann 0:30f4bcb2a3c0 54 case 'a':
Yann 0:30f4bcb2a3c0 55 do {
Yann 0:30f4bcb2a3c0 56 RunStateMachine_WithStdStringValue();
Yann 0:30f4bcb2a3c0 57 } while (g_state != Idle);
Yann 0:30f4bcb2a3c0 58 break;
Yann 0:30f4bcb2a3c0 59 case 'b':
Yann 0:30f4bcb2a3c0 60 do {
Yann 0:30f4bcb2a3c0 61 RunStateMachine_WithByteValue();
Yann 0:30f4bcb2a3c0 62 } while (g_state != Idle);
Yann 0:30f4bcb2a3c0 63 break;
Yann 0:30f4bcb2a3c0 64 case 'c':
Yann 0:30f4bcb2a3c0 65 do {
Yann 0:30f4bcb2a3c0 66 RunStateMachine_WithShortValue(CFM24VXX_I2C::BigEndian);
Yann 0:30f4bcb2a3c0 67 } while (g_state != Idle);
Yann 0:30f4bcb2a3c0 68 break;
Yann 0:30f4bcb2a3c0 69 case 'd':
Yann 0:30f4bcb2a3c0 70 do {
Yann 0:30f4bcb2a3c0 71 RunStateMachine_WithShortValue(CFM24VXX_I2C::LittleEndian);
Yann 0:30f4bcb2a3c0 72 } while (g_state != Idle);
Yann 0:30f4bcb2a3c0 73 break;
Yann 0:30f4bcb2a3c0 74 case 'e':
Yann 0:30f4bcb2a3c0 75 do {
Yann 0:30f4bcb2a3c0 76 RunStateMachine_WithIntegerValue(CFM24VXX_I2C::BigEndian);
Yann 0:30f4bcb2a3c0 77 } while (g_state != Idle);
Yann 0:30f4bcb2a3c0 78 break;
Yann 0:30f4bcb2a3c0 79 case 'f':
Yann 0:30f4bcb2a3c0 80 do {
Yann 0:30f4bcb2a3c0 81 RunStateMachine_WithIntegerValue(CFM24VXX_I2C::LittleEndian);
Yann 0:30f4bcb2a3c0 82 } while (g_state != Idle);
Yann 0:30f4bcb2a3c0 83 break;
Yann 0:30f4bcb2a3c0 84 case 'g':
Yann 0:30f4bcb2a3c0 85 do {
Yann 0:30f4bcb2a3c0 86 RunStateMachine_WithStdVectorOfByteValue();
Yann 0:30f4bcb2a3c0 87 } while (g_state != Idle);
Yann 0:30f4bcb2a3c0 88 break;
Yann 0:30f4bcb2a3c0 89 case 'h':
Yann 0:30f4bcb2a3c0 90 do {
Yann 0:30f4bcb2a3c0 91 RunStateMachine_WithLengthPlusStdVectorOfByteValue();
Yann 0:30f4bcb2a3c0 92 } while (g_state != Idle);
Yann 0:30f4bcb2a3c0 93 break;
Yann 0:30f4bcb2a3c0 94 case 'i':
Yann 0:30f4bcb2a3c0 95 ReadStdStringValue(0x0100);
Yann 0:30f4bcb2a3c0 96 break;
Yann 0:30f4bcb2a3c0 97 case 'j':
Yann 0:30f4bcb2a3c0 98 ReadStdStringValue(0);
Yann 0:30f4bcb2a3c0 99 break;
Yann 0:30f4bcb2a3c0 100 case 'k':
Yann 0:30f4bcb2a3c0 101 #if defined(__DEBUG)
Yann 0:30f4bcb2a3c0 102 g_myEEPROM.DumpMemoryArea(0, 0x14);
Yann 0:30f4bcb2a3c0 103 #else // __DEBUG
Yann 0:30f4bcb2a3c0 104 std::cout << "DEBUG mode is not set, nothing to do!\r" << std::endl;
Yann 0:30f4bcb2a3c0 105 #endif // __DEBUG
Yann 0:30f4bcb2a3c0 106 break;
Yann 0:30f4bcb2a3c0 107 case 'l':
Yann 0:30f4bcb2a3c0 108 g_myEEPROM.EraseMemoryArea(0, 0x14);
Yann 0:30f4bcb2a3c0 109 break;
Yann 0:30f4bcb2a3c0 110 case 'm':
Yann 0:30f4bcb2a3c0 111 {
Yann 0:30f4bcb2a3c0 112 std::string test("Test");
Yann 0:30f4bcb2a3c0 113 g_myEEPROM.Write(10, test);
Yann 0:30f4bcb2a3c0 114 }
Yann 0:30f4bcb2a3c0 115 break;
Yann 0:30f4bcb2a3c0 116 case 'n':
Yann 0:30f4bcb2a3c0 117 ReadStdStringValue(10);
Yann 0:30f4bcb2a3c0 118 break;
Yann 0:30f4bcb2a3c0 119 default:
Yann 0:30f4bcb2a3c0 120 std::cout << "Invalid user choice\r" << std::endl;
Yann 0:30f4bcb2a3c0 121 break;
Yann 0:30f4bcb2a3c0 122 } // End of 'switch' statement
Yann 0:30f4bcb2a3c0 123 } // End of 'while' statement
Yann 0:30f4bcb2a3c0 124 } // End of program - nerver reached
Yann 0:30f4bcb2a3c0 125
Yann 0:30f4bcb2a3c0 126 void AvailableIndicator()
Yann 0:30f4bcb2a3c0 127 {
Yann 0:30f4bcb2a3c0 128 g_availableLed = !g_availableLed;
Yann 0:30f4bcb2a3c0 129 } // End of AvailableIndicator
Yann 0:30f4bcb2a3c0 130
Yann 0:30f4bcb2a3c0 131 UserChoice DisplayMenuAndGetChoice()
Yann 0:30f4bcb2a3c0 132 {
Yann 0:30f4bcb2a3c0 133 static UserChoice userChoice;
Yann 0:30f4bcb2a3c0 134
Yann 0:30f4bcb2a3c0 135 // Display the title
Yann 0:30f4bcb2a3c0 136 std::cout << "\r" << std::endl << "FM24Vxx_I2C v0.1\r" << std::endl;
Yann 0:30f4bcb2a3c0 137 // Display the menu
Yann 0:30f4bcb2a3c0 138 std::cout << "\tWrite/Read with std::string:\t\t\ta\r" << std::endl;
Yann 0:30f4bcb2a3c0 139 std::cout << "\tWrite/Read with a byte:\t\t\t\tb\r" << std::endl;
Yann 0:30f4bcb2a3c0 140 std::cout << "\tWrite/Read with a short (Big Endian):\t\tc\r" << std::endl;
Yann 0:30f4bcb2a3c0 141 std::cout << "\tWrite/Read with a short (Little Endian):\td\r" << std::endl;
Yann 0:30f4bcb2a3c0 142 std::cout << "\tWrite/Read with an integer (Big Endian):\te\r" << std::endl;
Yann 0:30f4bcb2a3c0 143 std::cout << "\tWrite/Read with an integer (Little Endian):\tf\r" << std::endl;
Yann 0:30f4bcb2a3c0 144 std::cout << "\tWrite/Read with std::vector<byte>:\t\tg\r" << std::endl;
Yann 0:30f4bcb2a3c0 145 std::cout << "\tWrite/Read with std::vector<byte> + length:\th\r" << std::endl;
Yann 0:30f4bcb2a3c0 146 std::cout << "\tRead with std::string:\t\t\t\ti\r" << std::endl;
Yann 0:30f4bcb2a3c0 147 std::cout << "\tRead a string is address 0x0000:\t\tj\r" << std::endl;
Yann 0:30f4bcb2a3c0 148 std::cout << "\tHexadump from address 0x0000:\t\t\tk\r" << std::endl;
Yann 0:30f4bcb2a3c0 149 std::cout << "\tErase from address 0x0000:\t\t\tl\r" << std::endl;
Yann 0:30f4bcb2a3c0 150 std::cout << "\tWrite 'Test' at address 0x000a:\t\t\tm\r" << std::endl;
Yann 0:30f4bcb2a3c0 151 std::cout << "\tRead from address 0x000a:\t\t\tn\r" << std::endl;
Yann 0:30f4bcb2a3c0 152 std::cout << "Enter your choice: " << std::flush;
Yann 0:30f4bcb2a3c0 153 userChoice.choice = getchar();
Yann 0:30f4bcb2a3c0 154 return userChoice;
Yann 0:30f4bcb2a3c0 155 }
Yann 0:30f4bcb2a3c0 156
Yann 0:30f4bcb2a3c0 157 void RunStateMachine_WithStdStringValue()
Yann 0:30f4bcb2a3c0 158 {
Yann 0:30f4bcb2a3c0 159 DEBUG_ENTER("RunStateMachine_WithStdStringValue")
Yann 0:30f4bcb2a3c0 160
Yann 0:30f4bcb2a3c0 161 switch (g_state) {
Yann 0:30f4bcb2a3c0 162 case Idle:
Yann 0:30f4bcb2a3c0 163 g_state = Write;
Yann 0:30f4bcb2a3c0 164 break;
Yann 0:30f4bcb2a3c0 165 case Write: {
Yann 0:30f4bcb2a3c0 166 DEBUG("Writing data...");
Yann 0:30f4bcb2a3c0 167 time_t ctTime;
Yann 0:30f4bcb2a3c0 168 ctTime = time(NULL);
Yann 0:30f4bcb2a3c0 169 std::string str("Current time is: ");
Yann 0:30f4bcb2a3c0 170 str += ctime(&ctTime);
Yann 0:30f4bcb2a3c0 171 str += " UTC";
Yann 0:30f4bcb2a3c0 172 std::cout << "RunStateMachine_WithStdStringValue: Write '" << str << "'\r" << std::endl;
Yann 0:30f4bcb2a3c0 173 g_singleSeqNumScope = 1;
Yann 0:30f4bcb2a3c0 174 if (!g_myEEPROM.Write(256, str)) { // Write the string, including the length indicator
Yann 0:30f4bcb2a3c0 175 #ifdef __DEBUG
Yann 0:30f4bcb2a3c0 176 DEBUG_FATAL("RunStateMachine_WithStdStringValue: write failed at address 256")
Yann 0:30f4bcb2a3c0 177 #else // __DEBUG
Yann 0:30f4bcb2a3c0 178 std::cout << "RunStateMachine_WithStdStringValue: write failed at address 256\r" << std::endl;
Yann 0:30f4bcb2a3c0 179 #endif // __DEBUG
Yann 0:30f4bcb2a3c0 180 g_state = Idle;
Yann 0:30f4bcb2a3c0 181 } else {
Yann 0:30f4bcb2a3c0 182 g_state = Written;
Yann 0:30f4bcb2a3c0 183 }
Yann 0:30f4bcb2a3c0 184 g_singleSeqNumScope = 0;
Yann 0:30f4bcb2a3c0 185 }
Yann 0:30f4bcb2a3c0 186 break;
Yann 0:30f4bcb2a3c0 187 case Written:
Yann 0:30f4bcb2a3c0 188 g_state = Read;
Yann 0:30f4bcb2a3c0 189 wait(1.0); // To prevent I2C bus capacity memeory
Yann 0:30f4bcb2a3c0 190 break;
Yann 0:30f4bcb2a3c0 191 case Read: {
Yann 0:30f4bcb2a3c0 192 DEBUG("Reading datas...");
Yann 0:30f4bcb2a3c0 193 std::string readtext;
Yann 0:30f4bcb2a3c0 194 if (!g_myEEPROM.Read(256, readtext)) { // Read the string, including the length indicator
Yann 0:30f4bcb2a3c0 195 #ifdef __DEBUG
Yann 0:30f4bcb2a3c0 196 DEBUG_FATAL("RunStateMachine_WithStdStringValue: write failed at address 256")
Yann 0:30f4bcb2a3c0 197 #else // __DEBUG
Yann 0:30f4bcb2a3c0 198 std::cout << "RunStateMachine_WithStdStringValue: write failed at address 256\r" << std::endl;
Yann 0:30f4bcb2a3c0 199 #endif // __DEBUG
Yann 0:30f4bcb2a3c0 200 } else {
Yann 0:30f4bcb2a3c0 201 std::cout << "RunStateMachine_WithStdStringValue: Read: " << readtext << "\r" << std::endl;
Yann 0:30f4bcb2a3c0 202 }
Yann 0:30f4bcb2a3c0 203 }
Yann 0:30f4bcb2a3c0 204 g_state = Idle;
Yann 0:30f4bcb2a3c0 205 break;
Yann 0:30f4bcb2a3c0 206 default:
Yann 0:30f4bcb2a3c0 207 std::cout << "RunStateMachine_WithStdStringValue: Default!\r" << std::endl;
Yann 0:30f4bcb2a3c0 208 g_state = Idle;
Yann 0:30f4bcb2a3c0 209 break;
Yann 0:30f4bcb2a3c0 210 }
Yann 0:30f4bcb2a3c0 211
Yann 0:30f4bcb2a3c0 212 DEBUG_LEAVE("RunStateMachine_WithStdStringValue")
Yann 0:30f4bcb2a3c0 213 }
Yann 0:30f4bcb2a3c0 214
Yann 0:30f4bcb2a3c0 215 void RunStateMachine_WithByteValue() {
Yann 0:30f4bcb2a3c0 216 DEBUG_ENTER("RunStateMachine_WithByteValue")
Yann 0:30f4bcb2a3c0 217
Yann 0:30f4bcb2a3c0 218 switch (g_state) {
Yann 0:30f4bcb2a3c0 219 case Idle:
Yann 0:30f4bcb2a3c0 220 g_state = Write;
Yann 0:30f4bcb2a3c0 221 break;
Yann 0:30f4bcb2a3c0 222 case Write:
Yann 0:30f4bcb2a3c0 223 DEBUG("Writing data...")
Yann 0:30f4bcb2a3c0 224 std::cout << "RunStateMachine_WithByteValue: Write 0xaa\r" << std::endl;
Yann 0:30f4bcb2a3c0 225 g_singleSeqNumScope = 1;
Yann 0:30f4bcb2a3c0 226 if (!g_myEEPROM.Write(128, (unsigned char)0xaa)) {
Yann 0:30f4bcb2a3c0 227 #ifdef __DEBUG
Yann 0:30f4bcb2a3c0 228 DEBUG_FATAL("RunStateMachine_WithByteValue: write failed at address 128")
Yann 0:30f4bcb2a3c0 229 #else // __DEBUG
Yann 0:30f4bcb2a3c0 230 std::cout << "RunStateMachine_WithByteValue: write failed at address 128\r" << std::endl;
Yann 0:30f4bcb2a3c0 231 #endif // __DEBUG
Yann 0:30f4bcb2a3c0 232 g_state = Idle;
Yann 0:30f4bcb2a3c0 233 } else {
Yann 0:30f4bcb2a3c0 234 g_state = Written;
Yann 0:30f4bcb2a3c0 235 }
Yann 0:30f4bcb2a3c0 236 g_singleSeqNumScope = 0;
Yann 0:30f4bcb2a3c0 237 break;
Yann 0:30f4bcb2a3c0 238 case Written:
Yann 0:30f4bcb2a3c0 239 g_state = Read;
Yann 0:30f4bcb2a3c0 240 wait(1.0); // To prevent I2C bus capacity memeory
Yann 0:30f4bcb2a3c0 241 break;
Yann 0:30f4bcb2a3c0 242 case Read: {
Yann 0:30f4bcb2a3c0 243 DEBUG("Reading datas...")
Yann 0:30f4bcb2a3c0 244 unsigned char value = 0x00;
Yann 0:30f4bcb2a3c0 245 if (!g_myEEPROM.Read(128, &value)) {
Yann 0:30f4bcb2a3c0 246 #ifdef __DEBUG
Yann 0:30f4bcb2a3c0 247 DEBUG_FATAL("RunStateMachine_WithByteValue: Read operation failed at address 128")
Yann 0:30f4bcb2a3c0 248 #else // __DEBUG
Yann 0:30f4bcb2a3c0 249 std::cout << "RunStateMachine_WithByteValue: Read operation failed at address 128\r" << std::endl;
Yann 0:30f4bcb2a3c0 250 #endif // __DEBUG
Yann 0:30f4bcb2a3c0 251 } else {
Yann 0:30f4bcb2a3c0 252 std::cout << "RunStateMachine_WithByteValue: Read '0x" << std::setw(2) << std::setfill('0') << std::ios::hex << value << "'\r" << std::endl;
Yann 0:30f4bcb2a3c0 253 }
Yann 0:30f4bcb2a3c0 254 }
Yann 0:30f4bcb2a3c0 255 g_state = Idle;
Yann 0:30f4bcb2a3c0 256 break;
Yann 0:30f4bcb2a3c0 257 default:
Yann 0:30f4bcb2a3c0 258 std::cout << "RunStateMachine_WithByteValue: Default!\r" << std::endl;
Yann 0:30f4bcb2a3c0 259 g_state = Idle;
Yann 0:30f4bcb2a3c0 260 break;
Yann 0:30f4bcb2a3c0 261 }
Yann 0:30f4bcb2a3c0 262
Yann 0:30f4bcb2a3c0 263 DEBUG_LEAVE("RunStateMachine_WithByteValue")
Yann 0:30f4bcb2a3c0 264 }
Yann 0:30f4bcb2a3c0 265
Yann 0:30f4bcb2a3c0 266 void RunStateMachine_WithShortValue(CFM24VXX_I2C::Mode p_mode) {
Yann 0:30f4bcb2a3c0 267 DEBUG_ENTER("RunStateMachine_WithShortValue")
Yann 0:30f4bcb2a3c0 268
Yann 0:30f4bcb2a3c0 269 switch (g_state) {
Yann 0:30f4bcb2a3c0 270 case Idle:
Yann 0:30f4bcb2a3c0 271 g_state = Write;
Yann 0:30f4bcb2a3c0 272 break;
Yann 0:30f4bcb2a3c0 273 case Write:
Yann 0:30f4bcb2a3c0 274 DEBUG("Writing data...")
Yann 0:30f4bcb2a3c0 275 std::cout << "RunStateMachine_WithShortValue: Write 0xbeef\r" << std::endl;
Yann 0:30f4bcb2a3c0 276 if (!g_myEEPROM.Write(64, (short)0xbeef, p_mode)) { // See http://en.wikipedia.org/wiki/Hexspeak for more ideas on hexadecimal wording!!!
Yann 0:30f4bcb2a3c0 277 DEBUG_FATAL("RunStateMachine_WithShortValue: write failed at address 64")
Yann 0:30f4bcb2a3c0 278 g_state = Idle;
Yann 0:30f4bcb2a3c0 279 } else {
Yann 0:30f4bcb2a3c0 280 g_state = Written;
Yann 0:30f4bcb2a3c0 281 }
Yann 0:30f4bcb2a3c0 282 break;
Yann 0:30f4bcb2a3c0 283 case Written:
Yann 0:30f4bcb2a3c0 284 g_state = Read;
Yann 0:30f4bcb2a3c0 285 wait(1.0); // To prevent I2C bus capacity memeory
Yann 0:30f4bcb2a3c0 286 break;
Yann 0:30f4bcb2a3c0 287 case Read: {
Yann 0:30f4bcb2a3c0 288 DEBUG("Reading datas...");
Yann 0:30f4bcb2a3c0 289 short value = 0;
Yann 0:30f4bcb2a3c0 290 if (!g_myEEPROM.Read(64, &value, p_mode)) {
Yann 0:30f4bcb2a3c0 291 #ifdef __DEBUG
Yann 0:30f4bcb2a3c0 292 DEBUG_FATAL("RunStateMachine_WithShortValue: write failed at address 64")
Yann 0:30f4bcb2a3c0 293 #else // __DEBUG
Yann 0:30f4bcb2a3c0 294 std::cout << "RunStateMachine_WithShortValue: write failed at address 64\r" << std::endl;
Yann 0:30f4bcb2a3c0 295 #endif // __DEBUG
Yann 0:30f4bcb2a3c0 296 } else {
Yann 0:30f4bcb2a3c0 297 std::cout << "RunStateMachine_WithShortValue: Read '0x" << std::cout << std::setw(4) << std::setfill('0') << std::hex << value << "' / '" << (unsigned short)value << "'\r" << std::endl;
Yann 0:30f4bcb2a3c0 298 }
Yann 0:30f4bcb2a3c0 299 }
Yann 0:30f4bcb2a3c0 300 g_state = Idle;
Yann 0:30f4bcb2a3c0 301 break;
Yann 0:30f4bcb2a3c0 302 default:
Yann 0:30f4bcb2a3c0 303 std::cout << "RunStateMachine_WithShortValue: Default!\r" << std::endl;
Yann 0:30f4bcb2a3c0 304 g_state = Idle;
Yann 0:30f4bcb2a3c0 305 break;
Yann 0:30f4bcb2a3c0 306 }
Yann 0:30f4bcb2a3c0 307
Yann 0:30f4bcb2a3c0 308 DEBUG_LEAVE("RunStateMachine_WithShortValue")
Yann 0:30f4bcb2a3c0 309 }
Yann 0:30f4bcb2a3c0 310
Yann 0:30f4bcb2a3c0 311 void RunStateMachine_WithIntegerValue(CFM24VXX_I2C::Mode p_mode) {
Yann 0:30f4bcb2a3c0 312 DEBUG_ENTER("RunStateMachine_WithIntegerValue")
Yann 0:30f4bcb2a3c0 313
Yann 0:30f4bcb2a3c0 314 switch (g_state) {
Yann 0:30f4bcb2a3c0 315 case Idle:
Yann 0:30f4bcb2a3c0 316 g_state = Write;
Yann 0:30f4bcb2a3c0 317 break;
Yann 0:30f4bcb2a3c0 318 case Write:
Yann 0:30f4bcb2a3c0 319 DEBUG("Writing data...")
Yann 0:30f4bcb2a3c0 320 std::cout << "RunStateMachine_WithIntegerValue: Write 0xdeaddead\r" << std::endl;
Yann 0:30f4bcb2a3c0 321 if (!g_myEEPROM.Write(32, (int)0xdeaddead, p_mode)) {
Yann 0:30f4bcb2a3c0 322 DEBUG_FATAL("RunStateMachine_WithIntegerValue: write failed at address 32")
Yann 0:30f4bcb2a3c0 323 g_state = Idle;
Yann 0:30f4bcb2a3c0 324 } else {
Yann 0:30f4bcb2a3c0 325 g_state = Written;
Yann 0:30f4bcb2a3c0 326 }
Yann 0:30f4bcb2a3c0 327 break;
Yann 0:30f4bcb2a3c0 328 case Written:
Yann 0:30f4bcb2a3c0 329 g_state = Read;
Yann 0:30f4bcb2a3c0 330 wait(1.0); // To prevent I2C bus capacity memeory
Yann 0:30f4bcb2a3c0 331 break;
Yann 0:30f4bcb2a3c0 332 case Read: {
Yann 0:30f4bcb2a3c0 333 DEBUG("Reading datas...")
Yann 0:30f4bcb2a3c0 334 int value = 0;
Yann 0:30f4bcb2a3c0 335 if (!g_myEEPROM.Read(32, &value, p_mode)) {
Yann 0:30f4bcb2a3c0 336 #ifdef __DEBUG
Yann 0:30f4bcb2a3c0 337 DEBUG_FATAL("RunStateMachine_WithIntegerValue: write failed at address 32")
Yann 0:30f4bcb2a3c0 338 #else // __DEBUG
Yann 0:30f4bcb2a3c0 339 std::cout << "RunStateMachine_WithIntegerValue: write failed at address 32\r" << std::endl;
Yann 0:30f4bcb2a3c0 340 #endif // __DEBUG
Yann 0:30f4bcb2a3c0 341 } else {
Yann 0:30f4bcb2a3c0 342 std::cout << std::setw(8) << std::setfill('0') << std::hex << "RunStateMachine_WithIntegerValue: Read '0x" << value << "'/ '" << (unsigned int)value << "'\r" << std::endl;
Yann 0:30f4bcb2a3c0 343 }
Yann 0:30f4bcb2a3c0 344 }
Yann 0:30f4bcb2a3c0 345 g_state = Idle;
Yann 0:30f4bcb2a3c0 346 break;
Yann 0:30f4bcb2a3c0 347 default:
Yann 0:30f4bcb2a3c0 348 std::cout << "RunStateMachine_WithIntegerValue: Default!\r" << std::endl;
Yann 0:30f4bcb2a3c0 349 g_state = Idle;
Yann 0:30f4bcb2a3c0 350 break;
Yann 0:30f4bcb2a3c0 351 }
Yann 0:30f4bcb2a3c0 352
Yann 0:30f4bcb2a3c0 353 DEBUG_LEAVE("RunStateMachine_WithIntegerValue")
Yann 0:30f4bcb2a3c0 354 }
Yann 0:30f4bcb2a3c0 355
Yann 0:30f4bcb2a3c0 356 void RunStateMachine_WithStdVectorOfByteValue() {
Yann 0:30f4bcb2a3c0 357 DEBUG_ENTER("RunStateMachine_WithStdVectorOfByteValue")
Yann 0:30f4bcb2a3c0 358
Yann 0:30f4bcb2a3c0 359 switch (g_state) {
Yann 0:30f4bcb2a3c0 360 case Idle:
Yann 0:30f4bcb2a3c0 361 g_state = Write;
Yann 0:30f4bcb2a3c0 362 break;
Yann 0:30f4bcb2a3c0 363 case Write: {
Yann 0:30f4bcb2a3c0 364 std::vector<unsigned char> datas;
Yann 0:30f4bcb2a3c0 365 datas.push_back(0xfe);
Yann 0:30f4bcb2a3c0 366 datas.push_back(0xed);
Yann 0:30f4bcb2a3c0 367 datas.push_back(0xfa);
Yann 0:30f4bcb2a3c0 368 datas.push_back(0xce);
Yann 0:30f4bcb2a3c0 369 DEBUG("Writing data...")
Yann 0:30f4bcb2a3c0 370 std::cout << "RunStateMachine_WithStdVectorOfByteValue: Write {0xfe, 0xed, 0xfa, 0xce}\r" << std::endl;
Yann 0:30f4bcb2a3c0 371 if (!g_myEEPROM.Write(16, datas, false)) { // Write the full buffer, not including the length indication
Yann 0:30f4bcb2a3c0 372 DEBUG_FATAL("RunStateMachine_WithStdVectorOfByteValue: write failed at address 16")
Yann 0:30f4bcb2a3c0 373 g_state = Idle;
Yann 0:30f4bcb2a3c0 374 } else {
Yann 0:30f4bcb2a3c0 375 g_state = Written;
Yann 0:30f4bcb2a3c0 376 }
Yann 0:30f4bcb2a3c0 377 }
Yann 0:30f4bcb2a3c0 378 break;
Yann 0:30f4bcb2a3c0 379 case Written:
Yann 0:30f4bcb2a3c0 380 g_state = Read;
Yann 0:30f4bcb2a3c0 381 wait(1.0); // To prevent I2C bus capacity memeory
Yann 0:30f4bcb2a3c0 382 break;
Yann 0:30f4bcb2a3c0 383 case Read: {
Yann 0:30f4bcb2a3c0 384 DEBUG("Reading datas...")
Yann 0:30f4bcb2a3c0 385 std::vector<unsigned char> datas(4);
Yann 0:30f4bcb2a3c0 386 if (!g_myEEPROM.Read(16, datas, false)) { // Read bytes, without the lenght indication, buffer size shall be set before the call
Yann 0:30f4bcb2a3c0 387 #ifdef __DEBUG
Yann 0:30f4bcb2a3c0 388 DEBUG_FATAL("RunStateMachine_WithStdVectorOfByteValue: write failed at address 16")
Yann 0:30f4bcb2a3c0 389 #else // __DEBUG
Yann 0:30f4bcb2a3c0 390 std::cout << "RunStateMachine_WithStdVectorOfByteValue: write failed at address 16\r" << std::endl;
Yann 0:30f4bcb2a3c0 391 #endif // __DEBUG
Yann 0:30f4bcb2a3c0 392 } else {
Yann 0:30f4bcb2a3c0 393 std::cout << "RunStateMachine_WithStdVectorOfByteValue: Read {" << "', '" << datas[0] << "', '" << datas[1] << "', '" << datas[2] << "', '" << datas[3] <<"'}\r" << std::endl;
Yann 0:30f4bcb2a3c0 394 }
Yann 0:30f4bcb2a3c0 395 }
Yann 0:30f4bcb2a3c0 396 g_state = Idle;
Yann 0:30f4bcb2a3c0 397 break;
Yann 0:30f4bcb2a3c0 398 default:
Yann 0:30f4bcb2a3c0 399 std::cout << "RunStateMachine_WithStdVectorOfByteValue: Default!\r" << std::endl;
Yann 0:30f4bcb2a3c0 400 g_state = Idle;
Yann 0:30f4bcb2a3c0 401 break;
Yann 0:30f4bcb2a3c0 402 }
Yann 0:30f4bcb2a3c0 403
Yann 0:30f4bcb2a3c0 404 DEBUG_LEAVE("RunStateMachine_WithStdVectorOfByteValue")
Yann 0:30f4bcb2a3c0 405 }
Yann 0:30f4bcb2a3c0 406
Yann 0:30f4bcb2a3c0 407 void RunStateMachine_WithLengthPlusStdVectorOfByteValue() {
Yann 0:30f4bcb2a3c0 408 DEBUG_ENTER("RunStateMachine_WithLengthPlusStdVectorOfByteValue")
Yann 0:30f4bcb2a3c0 409
Yann 0:30f4bcb2a3c0 410 switch (g_state) {
Yann 0:30f4bcb2a3c0 411 case Idle:
Yann 0:30f4bcb2a3c0 412 g_state = Write;
Yann 0:30f4bcb2a3c0 413 break;
Yann 0:30f4bcb2a3c0 414 case Write: {
Yann 0:30f4bcb2a3c0 415 DEBUG("Writing data...")
Yann 0:30f4bcb2a3c0 416 std::vector<unsigned char> datas;
Yann 0:30f4bcb2a3c0 417 datas.push_back(0xde);
Yann 0:30f4bcb2a3c0 418 datas.push_back(0x5e);
Yann 0:30f4bcb2a3c0 419 datas.push_back(0xa5);
Yann 0:30f4bcb2a3c0 420 datas.push_back(0xed);
Yann 0:30f4bcb2a3c0 421 std::cout << "RunStateMachine_WithLengthPlusStdVectorOfByteValue: Write {0xde, 0x5e, 0xa5, 0xed}\r" << std::endl;
Yann 0:30f4bcb2a3c0 422 if (!g_myEEPROM.Write(8, datas)) { // Write the full buffer, including the length indication
Yann 0:30f4bcb2a3c0 423 DEBUG_FATAL("RunStateMachine_WithLengthPlusStdVectorOfByteValue: write failed at address 8")
Yann 0:30f4bcb2a3c0 424 g_state = Idle;
Yann 0:30f4bcb2a3c0 425 } else {
Yann 0:30f4bcb2a3c0 426 g_state = Written;
Yann 0:30f4bcb2a3c0 427 }
Yann 0:30f4bcb2a3c0 428 }
Yann 0:30f4bcb2a3c0 429 break;
Yann 0:30f4bcb2a3c0 430 case Written:
Yann 0:30f4bcb2a3c0 431 g_state = Read;
Yann 0:30f4bcb2a3c0 432 wait(1.0); // To prevent I2C bus capacity memeory
Yann 0:30f4bcb2a3c0 433 break;
Yann 0:30f4bcb2a3c0 434 case Read: {
Yann 0:30f4bcb2a3c0 435 DEBUG("Reading datas...")
Yann 0:30f4bcb2a3c0 436 std::vector<unsigned char> datas;
Yann 0:30f4bcb2a3c0 437 if (!g_myEEPROM.Read(8, datas)) { // Read bytes, including the lenght indication, buffer size is not set before the call
Yann 0:30f4bcb2a3c0 438 #ifdef __DEBUG
Yann 0:30f4bcb2a3c0 439 DEBUG_FATAL("RunStateMachine_WithStdVectorOfByteValue: write failed at address 8")
Yann 0:30f4bcb2a3c0 440 #else // __DEBUG
Yann 0:30f4bcb2a3c0 441 std::cout << "RunStateMachine_WithStdVectorOfByteValue: write failed at address 8\r" << std::endl;
Yann 0:30f4bcb2a3c0 442 #endif // __DEBUG
Yann 0:30f4bcb2a3c0 443 } else {
Yann 0:30f4bcb2a3c0 444 std::cout << "RunStateMachine_WithLengthPlusStdVectorOfByteValue: Read bytes:\r" << std::endl;
Yann 0:30f4bcb2a3c0 445 vector<unsigned char>::iterator it;
Yann 0:30f4bcb2a3c0 446 for (it = datas.begin() ; it < datas.end(); it++) {
Yann 0:30f4bcb2a3c0 447 std::cout << "0x" << std::setw(2) << std::setfill('0') << std::hex << *it << " ";
Yann 0:30f4bcb2a3c0 448 }
Yann 0:30f4bcb2a3c0 449 std::cout << "\r" << std::endl;
Yann 0:30f4bcb2a3c0 450 }
Yann 0:30f4bcb2a3c0 451 }
Yann 0:30f4bcb2a3c0 452 g_state = Idle;
Yann 0:30f4bcb2a3c0 453 break;
Yann 0:30f4bcb2a3c0 454 default:
Yann 0:30f4bcb2a3c0 455 std::cout << "RunStateMachine_WithLengthPlusStdVectorOfByteValue: Default!\r" << std::endl;
Yann 0:30f4bcb2a3c0 456 g_state = Idle;
Yann 0:30f4bcb2a3c0 457 break;
Yann 0:30f4bcb2a3c0 458 }
Yann 0:30f4bcb2a3c0 459
Yann 0:30f4bcb2a3c0 460 DEBUG_LEAVE("RunStateMachine_WithLengthPlusStdVectorOfByteValue")
Yann 0:30f4bcb2a3c0 461 }
Yann 0:30f4bcb2a3c0 462
Yann 0:30f4bcb2a3c0 463 void ReadStdStringValue(const int p_address) {
Yann 0:30f4bcb2a3c0 464 DEBUG_ENTER("ReadStdStringValue: %d", p_address)
Yann 0:30f4bcb2a3c0 465
Yann 0:30f4bcb2a3c0 466 DEBUG("Reading datas...");
Yann 0:30f4bcb2a3c0 467 std::string readtext;
Yann 0:30f4bcb2a3c0 468 if (!g_myEEPROM.Read(p_address, readtext)) { // Read the string, including the length indicator
Yann 0:30f4bcb2a3c0 469 #ifdef __DEBUG
Yann 0:30f4bcb2a3c0 470 DEBUG_FATAL("ReadStdStringValue: write failed at address 256")
Yann 0:30f4bcb2a3c0 471 #else // __DEBUG
Yann 0:30f4bcb2a3c0 472 std::cout << "ReadStdStringValue: write failed at address 256\r" << std::endl;
Yann 0:30f4bcb2a3c0 473 #endif // __DEBUG
Yann 0:30f4bcb2a3c0 474 } else {
Yann 0:30f4bcb2a3c0 475 std::cout << "ReadStdStringValue: Read:'" << readtext << "'\r" << std::endl;
Yann 0:30f4bcb2a3c0 476 }
Yann 0:30f4bcb2a3c0 477
Yann 0:30f4bcb2a3c0 478 DEBUG_LEAVE("ReadStdStringValue")
Yann 0:30f4bcb2a3c0 479 }