Maxim Integrated / Mbed OS MAX5715BOB_Serial_Tester

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   MaximTinyTester CmdLine MAX541 MAX5715 USBDevice

Files at this revision

API Documentation at this revision

Revision 2:b3a8a0ca0a94, committed 2019-06-10

Comitter:
whismanoid
Date:
Mon Jun 10 15:33:06 2019 +0000
Parent:
1:40369075c365
Child:
3:8913cb4a8b9f
Commit message:
replace C++11 lambda expressions with named functions

Changed in this revision

main.cpp Show annotated file Show diff for this revision Revisions of this file 
--- a/main.cpp	Mon Jun 10 07:59:34 2019 +0000
+++ b/main.cpp	Mon Jun 10 15:33:06 2019 +0000
@@ -3527,6 +3527,98 @@
 }
 #endif // USE_MAXIMTINYTESTER
 //--------------------------------------------------
+#if APPLICATION_MAX5715 // SelfTest
+#if USE_MAXIMTINYTESTER
+//
+// Note: ide.mbed.com does not support C++11 Lambda Expressions
+// -- see https://os.mbed.com/questions/82580/Is-there-solution-for-defining-of-interr/
+//
+// define function under test using C++11 lambda expression [](){}
+// uint8_t MAX5715::Init(void)
+// uint8_t (*fn_MAX5715_Init)() = [](){ return g_MAX5715_device.Init(); };
+uint8_t fn_MAX5715_Init() { return g_MAX5715_device.Init(); };
+//
+// define function under test using C++11 lambda expression [](){}
+// uint16_t MAX5715::DACCodeOfVoltage(double voltageV)
+// uint16_t (*fn_MAX5715_DACCodeOfVoltage)(double) = [](double voltageV){ return g_MAX5715_device.DACCodeOfVoltage(voltageV); };
+uint16_t fn_MAX5715_DACCodeOfVoltage(double voltageV) { return g_MAX5715_device.DACCodeOfVoltage(voltageV); };
+//
+// define function under test using C++11 lambda expression [](){}
+// double MAX5715::VoltageOfCode(uint16_t value_u14)
+//double (*fn_MAX5715_VoltageOfCode)(uint16_t) = [](uint16_t value_u14){ return g_MAX5715_device.VoltageOfCode(value_u14); };
+double fn_MAX5715_VoltageOfCode(uint16_t value_u14) { return g_MAX5715_device.VoltageOfCode(value_u14); };
+//
+// define function under test using C++11 lambda expression [](){}
+// void MAX5715::CODEnLOADn(uint8_t channel_0_3, uint16_t dacCodeLsbs)
+// void (*fn_MAX5715_CODEnLOADn)(uint8_t channel_0_3, uint16_t dacCodeLsbs) = [](uint8_t channel_0_3, uint16_t dacCodeLsbs){ return g_MAX5715_device.CODEnLOADn(channel_0_3, dacCodeLsbs); };
+void fn_MAX5715_CODEnLOADn (uint8_t channel_0_3, uint16_t dacCodeLsbs) { return g_MAX5715_device.CODEnLOADn(channel_0_3, dacCodeLsbs); };
+//
+#endif // USE_MAXIMTINYTESTER
+#endif // APPLICATION_MAX5715 // SelfTest
+//--------------------------------------------------
+#if APPLICATION_MAX11131 // SelfTest
+#if USE_MAXIMTINYTESTER
+//
+// Note: ide.mbed.com does not support C++11 Lambda Expressions
+// -- see https://os.mbed.com/questions/82580/Is-there-solution-for-defining-of-interr/
+//
+// define function under test using C++11 lambda expression [](){}
+//
+#endif // USE_MAXIMTINYTESTER
+#endif // APPLICATION_MAX11131 // SelfTest
+//--------------------------------------------------
+#if APPLICATION_MAX5171 // SelfTest
+#if USE_MAXIMTINYTESTER
+//
+// Note: ide.mbed.com does not support C++11 Lambda Expressions
+// -- see https://os.mbed.com/questions/82580/Is-there-solution-for-defining-of-interr/
+//
+// define function under test using C++11 lambda expression [](){}
+// uint8_t MAX5171::Init(void)
+// uint8_t (*fn_MAX5171_Init)() = [](){ return g_MAX5171_device.Init(); };
+uint8_t fn_MAX5171_Init() { return g_MAX5171_device.Init(); };
+//
+// define function under test using C++11 lambda expression [](){}
+// uint16_t MAX5171::DACCodeOfVoltage(double voltageV)
+// uint16_t (*fn_MAX5171_DACCodeOfVoltage)(double) = [](double voltageV){ return g_MAX5171_device.DACCodeOfVoltage(voltageV); };
+uint16_t fn_MAX5171_DACCodeOfVoltage(double voltageV) { return g_MAX5171_device.DACCodeOfVoltage(voltageV); };
+//
+// define function under test using C++11 lambda expression [](){}
+// double MAX5171::VoltageOfCode(uint16_t value_u14)
+// double (*fn_MAX5171_VoltageOfCode)(uint16_t) = [](uint16_t value_u14){ return g_MAX5171_device.VoltageOfCode(value_u14); };
+double fn_MAX5171_VoltageOfCode(uint16_t value_u14) { return g_MAX5171_device.VoltageOfCode(value_u14); };
+//
+// define function under test using C++11 lambda expression [](){}
+// uint8_t MAX5171::CODE_LOAD(uint16_t dacCodeLsbs)
+// uint8_t (*fn_MAX5171_CODE_LOAD)(uint16_t dacCodeLsbs) = [](uint16_t dacCodeLsbs){ return g_MAX5171_device.CODE_LOAD(dacCodeLsbs); };
+uint8_t fn_MAX5171_CODE_LOAD(uint16_t dacCodeLsbs) { return g_MAX5171_device.CODE_LOAD(dacCodeLsbs); };
+//
+//
+#endif // USE_MAXIMTINYTESTER
+#endif // APPLICATION_MAX5171 // SelfTest
+//--------------------------------------------------
+#if APPLICATION_MAX11410 // SelfTest
+#if USE_MAXIMTINYTESTER
+//
+// Note: ide.mbed.com does not support C++11 Lambda Expressions
+// -- see https://os.mbed.com/questions/82580/Is-there-solution-for-defining-of-interr/
+//
+// define function under test using C++11 lambda expression [](){}
+//
+#endif // USE_MAXIMTINYTESTER
+#endif // APPLICATION_MAX11410 // SelfTest
+//--------------------------------------------------
+#if APPLICATION_MAX12345 // SelfTest
+#if USE_MAXIMTINYTESTER
+//
+// Note: ide.mbed.com does not support C++11 Lambda Expressions
+// -- see https://os.mbed.com/questions/82580/Is-there-solution-for-defining-of-interr/
+//
+// define function under test using C++11 lambda expression [](){}
+//
+#endif // USE_MAXIMTINYTESTER
+#endif // APPLICATION_MAX12345 // SelfTest
+//--------------------------------------------------
 void SelfTest_print_DACCodeOfVoltage(CmdLine& cmdLine, double voltageV)
 {
     cmdLine.serial().printf("DACCodeOfVoltage(%6.4fV)", voltageV);
@@ -3943,19 +4035,19 @@
     // -- see https://os.mbed.com/questions/82580/Is-there-solution-for-defining-of-interr/
     // define function under test using C++11 lambda expression [](){}
     // uint8_t MAX5715::Init(void)
-    uint8_t (*fn_MAX5715_Init)() = [](){ return g_MAX5715_device.Init(); };
+    //uint8_t (*fn_MAX5715_Init)() = [](){ return g_MAX5715_device.Init(); };
     //
     // define function under test using C++11 lambda expression [](){}
     // uint16_t MAX5715::DACCodeOfVoltage(double voltageV)
-    uint16_t (*fn_MAX5715_DACCodeOfVoltage)(double) = [](double voltageV){ return g_MAX5715_device.DACCodeOfVoltage(voltageV); };
+    //uint16_t (*fn_MAX5715_DACCodeOfVoltage)(double) = [](double voltageV){ return g_MAX5715_device.DACCodeOfVoltage(voltageV); };
     //
     // define function under test using C++11 lambda expression [](){}
     // double MAX5715::VoltageOfCode(uint16_t value_u14)
-    double (*fn_MAX5715_VoltageOfCode)(uint16_t) = [](uint16_t value_u14){ return g_MAX5715_device.VoltageOfCode(value_u14); };
+    //double (*fn_MAX5715_VoltageOfCode)(uint16_t) = [](uint16_t value_u14){ return g_MAX5715_device.VoltageOfCode(value_u14); };
     //
     // define function under test using C++11 lambda expression [](){}
     // void MAX5715::CODEnLOADn(uint8_t channel_0_3, uint16_t dacCodeLsbs)
-    void (*fn_MAX5715_CODEnLOADn)(uint8_t channel_0_3, uint16_t dacCodeLsbs) = [](uint8_t channel_0_3, uint16_t dacCodeLsbs){ return g_MAX5715_device.CODEnLOADn(channel_0_3, dacCodeLsbs); };
+    //void (*fn_MAX5715_CODEnLOADn)(uint8_t channel_0_3, uint16_t dacCodeLsbs) = [](uint8_t channel_0_3, uint16_t dacCodeLsbs){ return g_MAX5715_device.CODEnLOADn(channel_0_3, dacCodeLsbs); };
     //
 #else // USE_MAXIMTINYTESTER
     //
@@ -4825,19 +4917,19 @@
     // -- see https://os.mbed.com/questions/82580/Is-there-solution-for-defining-of-interr/
     // define function under test using C++11 lambda expression [](){}
     // uint8_t MAX5171::Init(void)
-    uint8_t (*fn_MAX5171_Init)() = [](){ return g_MAX5171_device.Init(); };
+    //uint8_t (*fn_MAX5171_Init)() = [](){ return g_MAX5171_device.Init(); };
     //
     // define function under test using C++11 lambda expression [](){}
     // uint16_t MAX5171::DACCodeOfVoltage(double voltageV)
-    uint16_t (*fn_MAX5171_DACCodeOfVoltage)(double) = [](double voltageV){ return g_MAX5171_device.DACCodeOfVoltage(voltageV); };
+    //uint16_t (*fn_MAX5171_DACCodeOfVoltage)(double) = [](double voltageV){ return g_MAX5171_device.DACCodeOfVoltage(voltageV); };
     //
     // define function under test using C++11 lambda expression [](){}
     // double MAX5171::VoltageOfCode(uint16_t value_u14)
-    double (*fn_MAX5171_VoltageOfCode)(uint16_t) = [](uint16_t value_u14){ return g_MAX5171_device.VoltageOfCode(value_u14); };
+    //double (*fn_MAX5171_VoltageOfCode)(uint16_t) = [](uint16_t value_u14){ return g_MAX5171_device.VoltageOfCode(value_u14); };
     //
     // define function under test using C++11 lambda expression [](){}
     // uint8_t MAX5171::CODE_LOAD(uint16_t dacCodeLsbs)
-    uint8_t (*fn_MAX5171_CODE_LOAD)(uint16_t dacCodeLsbs) = [](uint16_t dacCodeLsbs){ return g_MAX5171_device.CODE_LOAD(dacCodeLsbs); };
+    //uint8_t (*fn_MAX5171_CODE_LOAD)(uint16_t dacCodeLsbs) = [](uint16_t dacCodeLsbs){ return g_MAX5171_device.CODE_LOAD(dacCodeLsbs); };
     //
     //double one_LSB = (g_MAX5171_device.VRef / 16383); // 14-bit DAC FS
     tinyTester.err_threshold = (g_MAX5171_device.VRef / 16383); // 14-bit DAC FS