Yann Garcia / Mbed 2 deprecated FM24Vxx_I2CApp

Test application for the library FM24Vxx_I2C

Dependencies:   DebugLibrary FM24Vxx_I2C mbed

main.cpp@2:dd6a152749c5, 2013-04-03 (annotated)

Committer:
Yann
Date:
Wed Apr 03 12:56:55 2013 +0000
Revision:
2:dd6a152749c5
Parent:
1:e3c92ff30be3 
Test application for the FM24Vxx_I2C library

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