Mark Underwood / MaximTinyTester

minimalist hardware testing support

Dependents:   MAX5715BOB_Tester MAX11131BOB_Tester MAX5171BOB_Tester MAX11410BOB_Tester ... more

MaximTinyTester.cpp@11:bfa56dab822c, 2020-03-29 (annotated)

Committer:
whismanoid
Date:
Sun Mar 29 15:57:49 2020 -0700
Revision:
11:bfa56dab822c
Parent:
10:b11ab5d7ac58
Child:
12:55db0f4a417d
support FunctionCall_i_pi_Expect() and Expect() for MAX11410 SelfTest

Who changed what in which revision?

UserRevisionLine numberNew contents of line
whismanoid 0:93d4119d3f14 1 // /*******************************************************************************
whismanoid 0:93d4119d3f14 2 // * Copyright (C) 2019 Maxim Integrated Products, Inc., All Rights Reserved.
whismanoid 0:93d4119d3f14 3 // *
whismanoid 0:93d4119d3f14 4 // * Permission is hereby granted, free of charge, to any person obtaining a
whismanoid 0:93d4119d3f14 5 // * copy of this software and associated documentation files (the "Software"),
whismanoid 0:93d4119d3f14 6 // * to deal in the Software without restriction, including without limitation
whismanoid 0:93d4119d3f14 7 // * the rights to use, copy, modify, merge, publish, distribute, sublicense,
whismanoid 0:93d4119d3f14 8 // * and/or sell copies of the Software, and to permit persons to whom the
whismanoid 0:93d4119d3f14 9 // * Software is furnished to do so, subject to the following conditions:
whismanoid 0:93d4119d3f14 10 // *
whismanoid 0:93d4119d3f14 11 // * The above copyright notice and this permission notice shall be included
whismanoid 0:93d4119d3f14 12 // * in all copies or substantial portions of the Software.
whismanoid 0:93d4119d3f14 13 // *
whismanoid 0:93d4119d3f14 14 // * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
whismanoid 0:93d4119d3f14 15 // * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
whismanoid 0:93d4119d3f14 16 // * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
whismanoid 0:93d4119d3f14 17 // * IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
whismanoid 0:93d4119d3f14 18 // * OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
whismanoid 0:93d4119d3f14 19 // * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
whismanoid 0:93d4119d3f14 20 // * OTHER DEALINGS IN THE SOFTWARE.
whismanoid 0:93d4119d3f14 21 // *
whismanoid 0:93d4119d3f14 22 // * Except as contained in this notice, the name of Maxim Integrated
whismanoid 0:93d4119d3f14 23 // * Products, Inc. shall not be used except as stated in the Maxim Integrated
whismanoid 0:93d4119d3f14 24 // * Products, Inc. Branding Policy.
whismanoid 0:93d4119d3f14 25 // *
whismanoid 0:93d4119d3f14 26 // * The mere transfer of this software does not imply any licenses
whismanoid 0:93d4119d3f14 27 // * of trade secrets, proprietary technology, copyrights, patents,
whismanoid 0:93d4119d3f14 28 // * trademarks, maskwork rights, or any other form of intellectual
whismanoid 0:93d4119d3f14 29 // * property whatsoever. Maxim Integrated Products, Inc. retains all
whismanoid 0:93d4119d3f14 30 // * ownership rights.
whismanoid 0:93d4119d3f14 31 // *******************************************************************************
whismanoid 0:93d4119d3f14 32 // */
whismanoid 0:93d4119d3f14 33 // *********************************************************************
whismanoid 0:93d4119d3f14 34 // @file MaximTinyTester.cpp
whismanoid 0:93d4119d3f14 35 // *********************************************************************
whismanoid 0:93d4119d3f14 36
whismanoid 0:93d4119d3f14 37 #include "MaximTinyTester.h"
whismanoid 0:93d4119d3f14 38
whismanoid 3:080aa1bb1bc0 39 #ifndef LED_ON
whismanoid 3:080aa1bb1bc0 40 # define LED_ON 0
whismanoid 3:080aa1bb1bc0 41 #endif
whismanoid 3:080aa1bb1bc0 42 #ifndef LED_OFF
whismanoid 3:080aa1bb1bc0 43 # define LED_OFF 1
whismanoid 3:080aa1bb1bc0 44 #endif
whismanoid 3:080aa1bb1bc0 45
whismanoid 0:93d4119d3f14 46 MaximTinyTester::MaximTinyTester(CmdLine& AssociatedCmdLine,
whismanoid 0:93d4119d3f14 47 AnalogIn& analogInPin0,
whismanoid 0:93d4119d3f14 48 AnalogIn& analogInPin1,
whismanoid 0:93d4119d3f14 49 AnalogIn& analogInPin2,
whismanoid 0:93d4119d3f14 50 AnalogIn& analogInPin3,
whismanoid 0:93d4119d3f14 51 AnalogIn& analogInPin4,
whismanoid 1:f98ddb04f9e0 52 AnalogIn& analogInPin5,
whismanoid 1:f98ddb04f9e0 53 DigitalOut& m_RFailLED,
whismanoid 1:f98ddb04f9e0 54 DigitalOut& m_GPassLED,
whismanoid 1:f98ddb04f9e0 55 DigitalOut& m_BBusyLED)
whismanoid 0:93d4119d3f14 56 : associatedCmdLine(AssociatedCmdLine)
whismanoid 0:93d4119d3f14 57 , analogInPin0(analogInPin0)
whismanoid 0:93d4119d3f14 58 , analogInPin1(analogInPin1)
whismanoid 0:93d4119d3f14 59 , analogInPin2(analogInPin2)
whismanoid 0:93d4119d3f14 60 , analogInPin3(analogInPin3)
whismanoid 0:93d4119d3f14 61 , analogInPin4(analogInPin4)
whismanoid 0:93d4119d3f14 62 , analogInPin5(analogInPin5)
whismanoid 1:f98ddb04f9e0 63 , m_RFailLED(m_RFailLED)
whismanoid 1:f98ddb04f9e0 64 , m_GPassLED(m_GPassLED)
whismanoid 1:f98ddb04f9e0 65 , m_BBusyLED(m_BBusyLED)
whismanoid 0:93d4119d3f14 66 {
whismanoid 0:93d4119d3f14 67 nPass = 0;
whismanoid 0:93d4119d3f14 68 nFail = 0;
whismanoid 0:93d4119d3f14 69 err_threshold = 0.030; // 30mV
whismanoid 0:93d4119d3f14 70 input_timeout_time_msec = 250;
whismanoid 0:93d4119d3f14 71 settle_time_msec = 250;
whismanoid 1:f98ddb04f9e0 72 blink_time_msec = 75;
whismanoid 0:93d4119d3f14 73 analogInPin_fullScaleVoltage[0] = 3.300;
whismanoid 0:93d4119d3f14 74 analogInPin_fullScaleVoltage[1] = 3.300;
whismanoid 0:93d4119d3f14 75 analogInPin_fullScaleVoltage[2] = 3.300;
whismanoid 0:93d4119d3f14 76 analogInPin_fullScaleVoltage[3] = 3.300;
whismanoid 0:93d4119d3f14 77 analogInPin_fullScaleVoltage[4] = 3.300;
whismanoid 0:93d4119d3f14 78 analogInPin_fullScaleVoltage[5] = 3.300;
whismanoid 0:93d4119d3f14 79 }
whismanoid 0:93d4119d3f14 80
whismanoid 0:93d4119d3f14 81 /** reset the pass/fail counters.
whismanoid 0:93d4119d3f14 82 *
whismanoid 0:93d4119d3f14 83 * @post nPass and nFail are reset to 0
whismanoid 0:93d4119d3f14 84 *
whismanoid 0:93d4119d3f14 85 */
whismanoid 0:93d4119d3f14 86 void MaximTinyTester::clear(void)
whismanoid 0:93d4119d3f14 87 {
whismanoid 0:93d4119d3f14 88 nPass = 0;
whismanoid 0:93d4119d3f14 89 nFail = 0;
whismanoid 3:080aa1bb1bc0 90 // PinName NC means NOT_CONNECTED; DigitalOut::is_connected() returns false
whismanoid 3:080aa1bb1bc0 91 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 92 m_RFailLED = LED_ON;
whismanoid 3:080aa1bb1bc0 93 }
whismanoid 3:080aa1bb1bc0 94 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 95 m_GPassLED = LED_ON;
whismanoid 3:080aa1bb1bc0 96 }
whismanoid 3:080aa1bb1bc0 97 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 98 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 99 }
whismanoid 0:93d4119d3f14 100 }
whismanoid 0:93d4119d3f14 101
whismanoid 0:93d4119d3f14 102 /** report that a test has completed with success.
whismanoid 0:93d4119d3f14 103 *
whismanoid 0:93d4119d3f14 104 * @post nPass is increased by 1
whismanoid 0:93d4119d3f14 105 *
whismanoid 0:93d4119d3f14 106 */
whismanoid 0:93d4119d3f14 107 void MaximTinyTester::PASS()
whismanoid 0:93d4119d3f14 108 {
whismanoid 0:93d4119d3f14 109 ++nPass;
whismanoid 1:f98ddb04f9e0 110 // m_RFailLED = LED_ON; m_GPassLED = LED_ON; m_BBusyLED = LED_ON;
whismanoid 1:f98ddb04f9e0 111 // pulse blue LED during test to indicate activity
whismanoid 3:080aa1bb1bc0 112 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 113 m_GPassLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 114 }
whismanoid 3:080aa1bb1bc0 115 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 116 m_BBusyLED = LED_ON;
whismanoid 3:080aa1bb1bc0 117 }
whismanoid 1:f98ddb04f9e0 118 wait_ms(blink_time_msec); // delay
whismanoid 3:080aa1bb1bc0 119 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 120 m_GPassLED = LED_ON;
whismanoid 3:080aa1bb1bc0 121 }
whismanoid 3:080aa1bb1bc0 122 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 123 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 124 }
whismanoid 1:f98ddb04f9e0 125 wait_ms(blink_time_msec); // delay
whismanoid 0:93d4119d3f14 126 associatedCmdLine.serial().printf("\r\n+PASS ");
whismanoid 0:93d4119d3f14 127 }
whismanoid 0:93d4119d3f14 128
whismanoid 0:93d4119d3f14 129 /** report that a test has completed with failure.
whismanoid 0:93d4119d3f14 130 *
whismanoid 0:93d4119d3f14 131 * @post nFail is increased by 1
whismanoid 0:93d4119d3f14 132 *
whismanoid 0:93d4119d3f14 133 */
whismanoid 0:93d4119d3f14 134 void MaximTinyTester::FAIL()
whismanoid 0:93d4119d3f14 135 {
whismanoid 0:93d4119d3f14 136 ++nFail;
whismanoid 1:f98ddb04f9e0 137 // m_RFailLED = LED_ON; m_GPassLED = LED_ON; m_BBusyLED = LED_ON;
whismanoid 1:f98ddb04f9e0 138 // pulse blue LED during test to indicate activity
whismanoid 3:080aa1bb1bc0 139 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 140 m_RFailLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 141 }
whismanoid 3:080aa1bb1bc0 142 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 143 m_BBusyLED = LED_ON;
whismanoid 3:080aa1bb1bc0 144 }
whismanoid 1:f98ddb04f9e0 145 wait_ms(blink_time_msec); // delay
whismanoid 3:080aa1bb1bc0 146 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 147 m_RFailLED = LED_ON;
whismanoid 3:080aa1bb1bc0 148 }
whismanoid 3:080aa1bb1bc0 149 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 150 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 151 }
whismanoid 1:f98ddb04f9e0 152 wait_ms(blink_time_msec); // delay
whismanoid 0:93d4119d3f14 153 associatedCmdLine.serial().printf("\r\n-FAIL ");
whismanoid 0:93d4119d3f14 154 #if USE_LEDS
whismanoid 0:93d4119d3f14 155 rgb_led.red(); // diagnostic rbg led RED
whismanoid 0:93d4119d3f14 156 //~ rgb_led.green(); // diagnostic rbg led GREEN
whismanoid 0:93d4119d3f14 157 //~ rgb_led.blue(); // diagnostic rbg led BLUE
whismanoid 0:93d4119d3f14 158 //~ rgb_led.white(); // diagnostic rbg led RED+GREEN+BLUE=WHITE
whismanoid 0:93d4119d3f14 159 //~ rgb_led.cyan(); // diagnostic rbg led GREEN+BLUE=CYAN
whismanoid 0:93d4119d3f14 160 //~ rgb_led.magenta(); // diagnostic rbg led RED+BLUE=MAGENTA
whismanoid 0:93d4119d3f14 161 //~ rgb_led.yellow(); // diagnostic rbg led RED+GREEN=YELLOW
whismanoid 0:93d4119d3f14 162 //~ rgb_led.black(); // diagnostic rbg led BLACK
whismanoid 0:93d4119d3f14 163 #endif // USE_LEDS
whismanoid 0:93d4119d3f14 164 }
whismanoid 0:93d4119d3f14 165
whismanoid 9:3ec00515891d 166 /** Print a message to the console during test.
whismanoid 9:3ec00515891d 167 */
whismanoid 9:3ec00515891d 168 void MaximTinyTester::print(const char* stringLiteralMessage)
whismanoid 9:3ec00515891d 169 {
whismanoid 9:3ec00515891d 170 associatedCmdLine.serial().printf("\r\n %s", stringLiteralMessage);
whismanoid 9:3ec00515891d 171 }
whismanoid 9:3ec00515891d 172
whismanoid 0:93d4119d3f14 173 /** Report number of pass and number of fail test results
whismanoid 0:93d4119d3f14 174 */
whismanoid 0:93d4119d3f14 175 void MaximTinyTester::Report_Summary(void)
whismanoid 0:93d4119d3f14 176 {
whismanoid 0:93d4119d3f14 177 associatedCmdLine.serial().printf("\r\nSummary: %d PASS %d FAIL\r\n", nPass, nFail);
whismanoid 0:93d4119d3f14 178 //~ associatedCmdLine.serial().printf(g_SelfTest_nPass);
whismanoid 0:93d4119d3f14 179 //~ associatedCmdLine.serial().printf(" PASS ");
whismanoid 0:93d4119d3f14 180 //~ associatedCmdLine.serial().printf(g_SelfTest_nFail);
whismanoid 0:93d4119d3f14 181 //~ associatedCmdLine.serial().printf(" FAIL\r\n");
whismanoid 0:93d4119d3f14 182 if (nFail == 0) {
whismanoid 3:080aa1bb1bc0 183 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 184 m_RFailLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 185 }
whismanoid 3:080aa1bb1bc0 186 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 187 m_GPassLED = LED_ON;
whismanoid 3:080aa1bb1bc0 188 }
whismanoid 3:080aa1bb1bc0 189 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 190 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 191 }
whismanoid 1:f98ddb04f9e0 192 //~ rgb_led.green(); // diagnostic rbg led GREEN
whismanoid 1:f98ddb04f9e0 193 }
whismanoid 1:f98ddb04f9e0 194 else {
whismanoid 3:080aa1bb1bc0 195 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 196 m_RFailLED = LED_ON;
whismanoid 3:080aa1bb1bc0 197 }
whismanoid 3:080aa1bb1bc0 198 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 199 m_GPassLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 200 }
whismanoid 3:080aa1bb1bc0 201 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 202 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 203 }
whismanoid 0:93d4119d3f14 204 //~ rgb_led.red(); // diagnostic rbg led RED
whismanoid 0:93d4119d3f14 205 }
whismanoid 0:93d4119d3f14 206 }
whismanoid 0:93d4119d3f14 207
whismanoid 10:b11ab5d7ac58 208 bool MaximTinyTester::Expect(const char *nameOfTest, int actual_result, int expect_result)
whismanoid 10:b11ab5d7ac58 209 {
whismanoid 10:b11ab5d7ac58 210 if (actual_result != expect_result)
whismanoid 10:b11ab5d7ac58 211 {
whismanoid 10:b11ab5d7ac58 212 FAIL();
whismanoid 10:b11ab5d7ac58 213 associatedCmdLine.serial().printf("%s", nameOfTest);
whismanoid 10:b11ab5d7ac58 214 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 10:b11ab5d7ac58 215 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 10:b11ab5d7ac58 216 return false;
whismanoid 10:b11ab5d7ac58 217 }
whismanoid 10:b11ab5d7ac58 218 else
whismanoid 10:b11ab5d7ac58 219 {
whismanoid 10:b11ab5d7ac58 220 PASS();
whismanoid 10:b11ab5d7ac58 221 associatedCmdLine.serial().printf("%s", nameOfTest);
whismanoid 10:b11ab5d7ac58 222 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 10:b11ab5d7ac58 223 return true;
whismanoid 10:b11ab5d7ac58 224 }
whismanoid 10:b11ab5d7ac58 225 }
whismanoid 10:b11ab5d7ac58 226
whismanoid 10:b11ab5d7ac58 227 bool MaximTinyTester::Expect(const char *nameOfTest, double actual_result, double expect_result)
whismanoid 10:b11ab5d7ac58 228 {
whismanoid 10:b11ab5d7ac58 229 double err_result = (actual_result - expect_result);
whismanoid 10:b11ab5d7ac58 230 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 10:b11ab5d7ac58 231 {
whismanoid 10:b11ab5d7ac58 232 PASS();
whismanoid 10:b11ab5d7ac58 233 associatedCmdLine.serial().printf("%s", nameOfTest);
whismanoid 10:b11ab5d7ac58 234 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 10:b11ab5d7ac58 235 return true;
whismanoid 10:b11ab5d7ac58 236 }
whismanoid 10:b11ab5d7ac58 237 else
whismanoid 10:b11ab5d7ac58 238 {
whismanoid 10:b11ab5d7ac58 239 FAIL();
whismanoid 10:b11ab5d7ac58 240 associatedCmdLine.serial().printf("%s", nameOfTest);
whismanoid 10:b11ab5d7ac58 241 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 10:b11ab5d7ac58 242 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 10:b11ab5d7ac58 243 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 10:b11ab5d7ac58 244 return false;
whismanoid 10:b11ab5d7ac58 245 }
whismanoid 10:b11ab5d7ac58 246 }
whismanoid 10:b11ab5d7ac58 247
whismanoid 0:93d4119d3f14 248 /** Test a software function
whismanoid 0:93d4119d3f14 249 *
whismanoid 0:93d4119d3f14 250 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 0:93d4119d3f14 251 *
whismanoid 0:93d4119d3f14 252 * @param[in] functionUnderTest points to the function under test
whismanoid 0:93d4119d3f14 253 *
whismanoid 8:9171f0ab3c17 254 * @param[in] arg_1_voltageV is a test argument given to the function under test
whismanoid 0:93d4119d3f14 255 *
whismanoid 0:93d4119d3f14 256 * @param[in] expect_result contains the expected result
whismanoid 0:93d4119d3f14 257 *
whismanoid 0:93d4119d3f14 258 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 259 *
whismanoid 0:93d4119d3f14 260 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 261 *
whismanoid 0:93d4119d3f14 262 */
whismanoid 0:93d4119d3f14 263 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 0:93d4119d3f14 264 Callback<uint16_t(double)> functionUnderTest,
whismanoid 8:9171f0ab3c17 265 double arg_1_voltageV,
whismanoid 8:9171f0ab3c17 266 uint16_t expect_result)
whismanoid 0:93d4119d3f14 267 {
whismanoid 8:9171f0ab3c17 268 uint16_t actual_result = functionUnderTest(arg_1_voltageV);
whismanoid 0:93d4119d3f14 269 if (actual_result != expect_result)
whismanoid 0:93d4119d3f14 270 {
whismanoid 0:93d4119d3f14 271 FAIL();
whismanoid 8:9171f0ab3c17 272 associatedCmdLine.serial().printf("%s(%6.4fV)", nameOfFunctionUnderTest, arg_1_voltageV);
whismanoid 0:93d4119d3f14 273 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 0:93d4119d3f14 274 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 0:93d4119d3f14 275 return false;
whismanoid 0:93d4119d3f14 276 }
whismanoid 0:93d4119d3f14 277 else
whismanoid 0:93d4119d3f14 278 {
whismanoid 0:93d4119d3f14 279 PASS();
whismanoid 8:9171f0ab3c17 280 associatedCmdLine.serial().printf("%s(%6.4fV)", nameOfFunctionUnderTest, arg_1_voltageV);
whismanoid 0:93d4119d3f14 281 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 0:93d4119d3f14 282 return true;
whismanoid 0:93d4119d3f14 283 }
whismanoid 0:93d4119d3f14 284 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 285 }
whismanoid 0:93d4119d3f14 286
whismanoid 0:93d4119d3f14 287 /** Test a software function
whismanoid 0:93d4119d3f14 288 *
whismanoid 0:93d4119d3f14 289 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 0:93d4119d3f14 290 *
whismanoid 0:93d4119d3f14 291 * @param[in] functionUnderTest points to the function under test
whismanoid 0:93d4119d3f14 292 *
whismanoid 8:9171f0ab3c17 293 * @param[in] arg_1_u16 is a test argument given to the function under test
whismanoid 0:93d4119d3f14 294 *
whismanoid 0:93d4119d3f14 295 * @param[in] expect_result contains the expected result
whismanoid 0:93d4119d3f14 296 *
whismanoid 0:93d4119d3f14 297 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 298 *
whismanoid 0:93d4119d3f14 299 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 300 *
whismanoid 0:93d4119d3f14 301 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 302 *
whismanoid 0:93d4119d3f14 303 */
whismanoid 0:93d4119d3f14 304 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 10:b11ab5d7ac58 305 Callback<double(int)> functionUnderTest,
whismanoid 10:b11ab5d7ac58 306 int arg_1_u16,
whismanoid 8:9171f0ab3c17 307 double expect_result)
whismanoid 0:93d4119d3f14 308 {
whismanoid 8:9171f0ab3c17 309 double actual_result = functionUnderTest(arg_1_u16);
whismanoid 0:93d4119d3f14 310 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 311 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 312 {
whismanoid 0:93d4119d3f14 313 PASS();
whismanoid 8:9171f0ab3c17 314 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1_u16);
whismanoid 0:93d4119d3f14 315 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 0:93d4119d3f14 316 return true;
whismanoid 0:93d4119d3f14 317 }
whismanoid 0:93d4119d3f14 318 else
whismanoid 0:93d4119d3f14 319 {
whismanoid 0:93d4119d3f14 320 FAIL();
whismanoid 8:9171f0ab3c17 321 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1_u16);
whismanoid 0:93d4119d3f14 322 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 0:93d4119d3f14 323 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 324 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 325 return false;
whismanoid 0:93d4119d3f14 326 }
whismanoid 0:93d4119d3f14 327 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 328 }
whismanoid 0:93d4119d3f14 329
whismanoid 5:67a1cd5a67cc 330 /** Test a software function
whismanoid 5:67a1cd5a67cc 331 *
whismanoid 5:67a1cd5a67cc 332 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 5:67a1cd5a67cc 333 *
whismanoid 5:67a1cd5a67cc 334 * @param[in] functionUnderTest points to the function under test
whismanoid 5:67a1cd5a67cc 335 *
whismanoid 8:9171f0ab3c17 336 * @param[in] arg_1_u32 is a test argument given to the function under test
whismanoid 5:67a1cd5a67cc 337 *
whismanoid 5:67a1cd5a67cc 338 * @param[in] expect_result contains the expected result
whismanoid 5:67a1cd5a67cc 339 *
whismanoid 5:67a1cd5a67cc 340 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 5:67a1cd5a67cc 341 *
whismanoid 5:67a1cd5a67cc 342 * @post nPass and nFail counters are updated
whismanoid 5:67a1cd5a67cc 343 *
whismanoid 5:67a1cd5a67cc 344 * @return true if success, false if test failed
whismanoid 5:67a1cd5a67cc 345 *
whismanoid 5:67a1cd5a67cc 346 */
whismanoid 5:67a1cd5a67cc 347 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 5:67a1cd5a67cc 348 Callback<double(uint32_t)> functionUnderTest,
whismanoid 8:9171f0ab3c17 349 uint32_t arg_1_u32,
whismanoid 8:9171f0ab3c17 350 double expect_result)
whismanoid 5:67a1cd5a67cc 351 {
whismanoid 8:9171f0ab3c17 352 double actual_result = functionUnderTest(arg_1_u32);
whismanoid 5:67a1cd5a67cc 353 double err_result = (actual_result - expect_result);
whismanoid 5:67a1cd5a67cc 354 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 5:67a1cd5a67cc 355 {
whismanoid 5:67a1cd5a67cc 356 PASS();
whismanoid 8:9171f0ab3c17 357 associatedCmdLine.serial().printf("%s(0x%lx)", nameOfFunctionUnderTest, arg_1_u32);
whismanoid 5:67a1cd5a67cc 358 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 359 return true;
whismanoid 5:67a1cd5a67cc 360 }
whismanoid 5:67a1cd5a67cc 361 else
whismanoid 5:67a1cd5a67cc 362 {
whismanoid 5:67a1cd5a67cc 363 FAIL();
whismanoid 8:9171f0ab3c17 364 associatedCmdLine.serial().printf("%s(0x%lx)", nameOfFunctionUnderTest, arg_1_u32);
whismanoid 5:67a1cd5a67cc 365 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 366 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 5:67a1cd5a67cc 367 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 5:67a1cd5a67cc 368 return false;
whismanoid 5:67a1cd5a67cc 369 }
whismanoid 5:67a1cd5a67cc 370 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 5:67a1cd5a67cc 371 }
whismanoid 5:67a1cd5a67cc 372
whismanoid 5:67a1cd5a67cc 373 /** Test a software function
whismanoid 5:67a1cd5a67cc 374 *
whismanoid 5:67a1cd5a67cc 375 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 5:67a1cd5a67cc 376 *
whismanoid 5:67a1cd5a67cc 377 * @param[in] functionUnderTest points to the function under test
whismanoid 5:67a1cd5a67cc 378 *
whismanoid 8:9171f0ab3c17 379 * @param[in] arg_1_d is a test argument given to the function under test
whismanoid 5:67a1cd5a67cc 380 *
whismanoid 5:67a1cd5a67cc 381 * @param[in] expect_result contains the expected result
whismanoid 5:67a1cd5a67cc 382 *
whismanoid 5:67a1cd5a67cc 383 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 5:67a1cd5a67cc 384 *
whismanoid 5:67a1cd5a67cc 385 * @post nPass and nFail counters are updated
whismanoid 5:67a1cd5a67cc 386 *
whismanoid 5:67a1cd5a67cc 387 * @return true if success, false if test failed
whismanoid 5:67a1cd5a67cc 388 *
whismanoid 5:67a1cd5a67cc 389 */
whismanoid 5:67a1cd5a67cc 390 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 5:67a1cd5a67cc 391 Callback<double(double)> functionUnderTest,
whismanoid 8:9171f0ab3c17 392 double arg_1_d,
whismanoid 8:9171f0ab3c17 393 double expect_result)
whismanoid 5:67a1cd5a67cc 394 {
whismanoid 8:9171f0ab3c17 395 double actual_result = functionUnderTest(arg_1_d);
whismanoid 5:67a1cd5a67cc 396 double err_result = (actual_result - expect_result);
whismanoid 5:67a1cd5a67cc 397 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 5:67a1cd5a67cc 398 {
whismanoid 5:67a1cd5a67cc 399 PASS();
whismanoid 8:9171f0ab3c17 400 associatedCmdLine.serial().printf("%s(%6.6f)", nameOfFunctionUnderTest, arg_1_d);
whismanoid 5:67a1cd5a67cc 401 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 402 return true;
whismanoid 5:67a1cd5a67cc 403 }
whismanoid 5:67a1cd5a67cc 404 else
whismanoid 5:67a1cd5a67cc 405 {
whismanoid 5:67a1cd5a67cc 406 FAIL();
whismanoid 8:9171f0ab3c17 407 associatedCmdLine.serial().printf("%s(%6.6f)", nameOfFunctionUnderTest, arg_1_d);
whismanoid 5:67a1cd5a67cc 408 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 409 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 5:67a1cd5a67cc 410 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 5:67a1cd5a67cc 411 return false;
whismanoid 5:67a1cd5a67cc 412 }
whismanoid 5:67a1cd5a67cc 413 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 5:67a1cd5a67cc 414 }
whismanoid 5:67a1cd5a67cc 415
whismanoid 7:5b40b6370f8a 416 /** Test a software function
whismanoid 7:5b40b6370f8a 417 *
whismanoid 7:5b40b6370f8a 418 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 419 *
whismanoid 7:5b40b6370f8a 420 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 421 *
whismanoid 8:9171f0ab3c17 422 * @param[in] expect_result contains the expected result
whismanoid 8:9171f0ab3c17 423 *
whismanoid 8:9171f0ab3c17 424 * @post nPass and nFail counters are updated
whismanoid 8:9171f0ab3c17 425 *
whismanoid 8:9171f0ab3c17 426 * @return true if success, false if test failed
whismanoid 8:9171f0ab3c17 427 *
whismanoid 8:9171f0ab3c17 428 */
whismanoid 8:9171f0ab3c17 429 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 8:9171f0ab3c17 430 Callback<uint8_t()> functionUnderTest,
whismanoid 8:9171f0ab3c17 431 uint8_t expect_result)
whismanoid 8:9171f0ab3c17 432 {
whismanoid 8:9171f0ab3c17 433 uint8_t actual_result = functionUnderTest();
whismanoid 8:9171f0ab3c17 434 if (actual_result != expect_result)
whismanoid 8:9171f0ab3c17 435 {
whismanoid 8:9171f0ab3c17 436 FAIL();
whismanoid 8:9171f0ab3c17 437 associatedCmdLine.serial().printf("%s()", nameOfFunctionUnderTest);
whismanoid 8:9171f0ab3c17 438 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 8:9171f0ab3c17 439 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 8:9171f0ab3c17 440 return false;
whismanoid 8:9171f0ab3c17 441 }
whismanoid 8:9171f0ab3c17 442 else
whismanoid 8:9171f0ab3c17 443 {
whismanoid 8:9171f0ab3c17 444 PASS();
whismanoid 8:9171f0ab3c17 445 associatedCmdLine.serial().printf("%s()", nameOfFunctionUnderTest);
whismanoid 8:9171f0ab3c17 446 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 8:9171f0ab3c17 447 return true;
whismanoid 8:9171f0ab3c17 448 }
whismanoid 8:9171f0ab3c17 449 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 8:9171f0ab3c17 450 }
whismanoid 8:9171f0ab3c17 451
whismanoid 8:9171f0ab3c17 452 /** Test a software function
whismanoid 8:9171f0ab3c17 453 *
whismanoid 8:9171f0ab3c17 454 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 8:9171f0ab3c17 455 *
whismanoid 8:9171f0ab3c17 456 * @param[in] functionUnderTest points to the function under test
whismanoid 8:9171f0ab3c17 457 *
whismanoid 7:5b40b6370f8a 458 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 459 *
whismanoid 7:5b40b6370f8a 460 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 461 *
whismanoid 7:5b40b6370f8a 462 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 463 *
whismanoid 7:5b40b6370f8a 464 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 465 *
whismanoid 7:5b40b6370f8a 466 */
whismanoid 7:5b40b6370f8a 467 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 10:b11ab5d7ac58 468 Callback<uint8_t(int)> functionUnderTest,
whismanoid 10:b11ab5d7ac58 469 int arg_1,
whismanoid 7:5b40b6370f8a 470 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 471 {
whismanoid 7:5b40b6370f8a 472 uint8_t actual_result = functionUnderTest(arg_1);
whismanoid 7:5b40b6370f8a 473 if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 474 {
whismanoid 7:5b40b6370f8a 475 FAIL();
whismanoid 7:5b40b6370f8a 476 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1);
whismanoid 7:5b40b6370f8a 477 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 478 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 479 return false;
whismanoid 7:5b40b6370f8a 480 }
whismanoid 7:5b40b6370f8a 481 else
whismanoid 7:5b40b6370f8a 482 {
whismanoid 7:5b40b6370f8a 483 PASS();
whismanoid 7:5b40b6370f8a 484 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1);
whismanoid 7:5b40b6370f8a 485 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 486 return true;
whismanoid 7:5b40b6370f8a 487 }
whismanoid 7:5b40b6370f8a 488 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 489 }
whismanoid 7:5b40b6370f8a 490
whismanoid 7:5b40b6370f8a 491 /** Test a software function
whismanoid 7:5b40b6370f8a 492 *
whismanoid 7:5b40b6370f8a 493 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 494 *
whismanoid 7:5b40b6370f8a 495 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 496 *
whismanoid 7:5b40b6370f8a 497 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 498 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 499 *
whismanoid 7:5b40b6370f8a 500 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 501 *
whismanoid 7:5b40b6370f8a 502 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 503 *
whismanoid 7:5b40b6370f8a 504 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 505 *
whismanoid 7:5b40b6370f8a 506 */
whismanoid 7:5b40b6370f8a 507 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 10:b11ab5d7ac58 508 Callback<uint8_t(int, int)> functionUnderTest,
whismanoid 10:b11ab5d7ac58 509 int arg_1,
whismanoid 10:b11ab5d7ac58 510 int arg_2,
whismanoid 7:5b40b6370f8a 511 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 512 {
whismanoid 7:5b40b6370f8a 513 uint8_t actual_result = functionUnderTest(arg_1, arg_2);
whismanoid 7:5b40b6370f8a 514 if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 515 {
whismanoid 7:5b40b6370f8a 516 FAIL();
whismanoid 7:5b40b6370f8a 517 associatedCmdLine.serial().printf("%s(%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2);
whismanoid 7:5b40b6370f8a 518 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 519 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 520 return false;
whismanoid 7:5b40b6370f8a 521 }
whismanoid 7:5b40b6370f8a 522 else
whismanoid 7:5b40b6370f8a 523 {
whismanoid 7:5b40b6370f8a 524 PASS();
whismanoid 7:5b40b6370f8a 525 associatedCmdLine.serial().printf("%s(%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2);
whismanoid 7:5b40b6370f8a 526 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 527 return true;
whismanoid 7:5b40b6370f8a 528 }
whismanoid 7:5b40b6370f8a 529 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 530 }
whismanoid 7:5b40b6370f8a 531
whismanoid 10:b11ab5d7ac58 532 bool MaximTinyTester::FunctionCall_i_pi_Expect(const char *nameOfFunctionUnderTest,
whismanoid 10:b11ab5d7ac58 533 Callback<uint8_t(int, uint32_t*)> functionUnderTest,
whismanoid 10:b11ab5d7ac58 534 int arg_1,
whismanoid 10:b11ab5d7ac58 535 uint32_t* arg_2,
whismanoid 10:b11ab5d7ac58 536 uint8_t expect_result,
whismanoid 10:b11ab5d7ac58 537 uint32_t expect_buffer)
whismanoid 10:b11ab5d7ac58 538 {
whismanoid 10:b11ab5d7ac58 539 uint8_t actual_result = functionUnderTest(arg_1, arg_2);
whismanoid 10:b11ab5d7ac58 540 uint32_t actual_buffer = *arg_2;
whismanoid 10:b11ab5d7ac58 541 if ((actual_result != expect_result) || (actual_buffer != expect_buffer))
whismanoid 10:b11ab5d7ac58 542 {
whismanoid 10:b11ab5d7ac58 543 FAIL();
whismanoid 10:b11ab5d7ac58 544 associatedCmdLine.serial().printf("%s(%d,buf)", nameOfFunctionUnderTest, arg_1);
whismanoid 10:b11ab5d7ac58 545 //associatedCmdLine.serial().print(nameOfFunctionUnderTest);
whismanoid 10:b11ab5d7ac58 546 //associatedCmdLine.serial().print("(");
whismanoid 10:b11ab5d7ac58 547 //associatedCmdLine.serial().print(arg_1);
whismanoid 10:b11ab5d7ac58 548 //associatedCmdLine.serial().print(F(",buf)"));
whismanoid 11:bfa56dab822c 549 associatedCmdLine.serial().printf(" expect %d buf=%d", expect_result, expect_buffer);
whismanoid 10:b11ab5d7ac58 550 //associatedCmdLine.serial().print(F(" expect "));
whismanoid 10:b11ab5d7ac58 551 //associatedCmdLine.serial().print(expect_result);
whismanoid 10:b11ab5d7ac58 552 //associatedCmdLine.serial().print(F(" buf="));
whismanoid 10:b11ab5d7ac58 553 //associatedCmdLine.serial().print(expect_buffer);
whismanoid 11:bfa56dab822c 554 associatedCmdLine.serial().printf(" but got %d buf=%d", actual_result, actual_buffer);
whismanoid 10:b11ab5d7ac58 555 //associatedCmdLine.serial().print(F(" but got "));
whismanoid 10:b11ab5d7ac58 556 //associatedCmdLine.serial().print(actual_result);
whismanoid 10:b11ab5d7ac58 557 //associatedCmdLine.serial().print(F(" buf="));
whismanoid 10:b11ab5d7ac58 558 //associatedCmdLine.serial().print(actual_buffer);
whismanoid 10:b11ab5d7ac58 559 return false;
whismanoid 10:b11ab5d7ac58 560 }
whismanoid 10:b11ab5d7ac58 561 else
whismanoid 10:b11ab5d7ac58 562 {
whismanoid 10:b11ab5d7ac58 563 PASS();
whismanoid 10:b11ab5d7ac58 564 associatedCmdLine.serial().printf("%s(%d,buf)", nameOfFunctionUnderTest, arg_1);
whismanoid 10:b11ab5d7ac58 565 //associatedCmdLine.serial().print(nameOfFunctionUnderTest);
whismanoid 10:b11ab5d7ac58 566 //associatedCmdLine.serial().print("(");
whismanoid 10:b11ab5d7ac58 567 //associatedCmdLine.serial().print(arg_1);
whismanoid 10:b11ab5d7ac58 568 //associatedCmdLine.serial().print(F(",buf)"));
whismanoid 11:bfa56dab822c 569 associatedCmdLine.serial().printf(" expect %d buf=%d", expect_result, expect_buffer);
whismanoid 10:b11ab5d7ac58 570 //associatedCmdLine.serial().print(F(" expect "));
whismanoid 10:b11ab5d7ac58 571 //associatedCmdLine.serial().print(expect_result);
whismanoid 10:b11ab5d7ac58 572 //associatedCmdLine.serial().print(F(" buf="));
whismanoid 10:b11ab5d7ac58 573 //associatedCmdLine.serial().print(expect_buffer);
whismanoid 10:b11ab5d7ac58 574 return true;
whismanoid 10:b11ab5d7ac58 575 }
whismanoid 10:b11ab5d7ac58 576 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 10:b11ab5d7ac58 577 }
whismanoid 10:b11ab5d7ac58 578
whismanoid 7:5b40b6370f8a 579 /** Test a software function
whismanoid 7:5b40b6370f8a 580 *
whismanoid 7:5b40b6370f8a 581 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 582 *
whismanoid 7:5b40b6370f8a 583 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 584 *
whismanoid 7:5b40b6370f8a 585 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 586 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 587 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 588 *
whismanoid 7:5b40b6370f8a 589 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 590 *
whismanoid 7:5b40b6370f8a 591 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 592 *
whismanoid 7:5b40b6370f8a 593 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 594 *
whismanoid 7:5b40b6370f8a 595 */
whismanoid 7:5b40b6370f8a 596 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 597 Callback<uint8_t(uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 598 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 599 uint8_t arg_2,
whismanoid 7:5b40b6370f8a 600 uint8_t arg_3,
whismanoid 7:5b40b6370f8a 601 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 602 {
whismanoid 7:5b40b6370f8a 603 uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3);
whismanoid 7:5b40b6370f8a 604 if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 605 {
whismanoid 7:5b40b6370f8a 606 FAIL();
whismanoid 7:5b40b6370f8a 607 associatedCmdLine.serial().printf("%s(%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3);
whismanoid 7:5b40b6370f8a 608 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 609 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 610 return false;
whismanoid 7:5b40b6370f8a 611 }
whismanoid 7:5b40b6370f8a 612 else
whismanoid 7:5b40b6370f8a 613 {
whismanoid 7:5b40b6370f8a 614 PASS();
whismanoid 7:5b40b6370f8a 615 associatedCmdLine.serial().printf("%s(%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3);
whismanoid 7:5b40b6370f8a 616 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 617 return true;
whismanoid 7:5b40b6370f8a 618 }
whismanoid 7:5b40b6370f8a 619 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 620 }
whismanoid 7:5b40b6370f8a 621
whismanoid 7:5b40b6370f8a 622 /** Test a software function
whismanoid 7:5b40b6370f8a 623 *
whismanoid 7:5b40b6370f8a 624 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 625 *
whismanoid 7:5b40b6370f8a 626 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 627 *
whismanoid 7:5b40b6370f8a 628 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 629 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 630 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 631 * @param[in] arg_4 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 632 *
whismanoid 7:5b40b6370f8a 633 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 634 *
whismanoid 7:5b40b6370f8a 635 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 636 *
whismanoid 7:5b40b6370f8a 637 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 638 *
whismanoid 7:5b40b6370f8a 639 */
whismanoid 7:5b40b6370f8a 640 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 641 Callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 642 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 643 uint8_t arg_2,
whismanoid 7:5b40b6370f8a 644 uint8_t arg_3,
whismanoid 7:5b40b6370f8a 645 uint8_t arg_4,
whismanoid 7:5b40b6370f8a 646 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 647 {
whismanoid 7:5b40b6370f8a 648 uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3, arg_4);
whismanoid 7:5b40b6370f8a 649 if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 650 {
whismanoid 7:5b40b6370f8a 651 FAIL();
whismanoid 7:5b40b6370f8a 652 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4);
whismanoid 7:5b40b6370f8a 653 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 654 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 655 return false;
whismanoid 7:5b40b6370f8a 656 }
whismanoid 7:5b40b6370f8a 657 else
whismanoid 7:5b40b6370f8a 658 {
whismanoid 7:5b40b6370f8a 659 PASS();
whismanoid 7:5b40b6370f8a 660 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4);
whismanoid 7:5b40b6370f8a 661 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 662 return true;
whismanoid 7:5b40b6370f8a 663 }
whismanoid 7:5b40b6370f8a 664 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 665 }
whismanoid 7:5b40b6370f8a 666
whismanoid 7:5b40b6370f8a 667 /** Test a software function
whismanoid 7:5b40b6370f8a 668 *
whismanoid 7:5b40b6370f8a 669 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 670 *
whismanoid 7:5b40b6370f8a 671 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 672 *
whismanoid 7:5b40b6370f8a 673 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 674 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 675 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 676 * @param[in] arg_4 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 677 * @param[in] arg_5 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 678 *
whismanoid 7:5b40b6370f8a 679 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 680 *
whismanoid 7:5b40b6370f8a 681 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 682 *
whismanoid 7:5b40b6370f8a 683 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 684 *
whismanoid 7:5b40b6370f8a 685 */
whismanoid 7:5b40b6370f8a 686 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 687 Callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 688 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 689 uint8_t arg_2,
whismanoid 7:5b40b6370f8a 690 uint8_t arg_3,
whismanoid 7:5b40b6370f8a 691 uint8_t arg_4,
whismanoid 7:5b40b6370f8a 692 uint8_t arg_5,
whismanoid 7:5b40b6370f8a 693 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 694 {
whismanoid 7:5b40b6370f8a 695 uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3, arg_4, arg_5);
whismanoid 7:5b40b6370f8a 696 if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 697 {
whismanoid 7:5b40b6370f8a 698 FAIL();
whismanoid 7:5b40b6370f8a 699 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4, arg_5);
whismanoid 7:5b40b6370f8a 700 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 701 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 702 return false;
whismanoid 7:5b40b6370f8a 703 }
whismanoid 7:5b40b6370f8a 704 else
whismanoid 7:5b40b6370f8a 705 {
whismanoid 7:5b40b6370f8a 706 PASS();
whismanoid 7:5b40b6370f8a 707 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4, arg_5);
whismanoid 7:5b40b6370f8a 708 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 709 return true;
whismanoid 7:5b40b6370f8a 710 }
whismanoid 7:5b40b6370f8a 711 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 712 }
whismanoid 7:5b40b6370f8a 713
whismanoid 7:5b40b6370f8a 714 // TODO1 #167 support callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)>
whismanoid 7:5b40b6370f8a 715 /** Test a software function
whismanoid 7:5b40b6370f8a 716 *
whismanoid 7:5b40b6370f8a 717 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 718 *
whismanoid 7:5b40b6370f8a 719 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 720 *
whismanoid 7:5b40b6370f8a 721 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 722 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 723 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 724 * @param[in] arg_4 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 725 * @param[in] arg_5 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 726 * @param[in] arg_6 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 727 *
whismanoid 7:5b40b6370f8a 728 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 729 *
whismanoid 7:5b40b6370f8a 730 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 731 *
whismanoid 7:5b40b6370f8a 732 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 733 *
whismanoid 7:5b40b6370f8a 734 */
whismanoid 7:5b40b6370f8a 735 //bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 736 // Callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 737 // uint8_t arg_1,
whismanoid 7:5b40b6370f8a 738 // uint8_t arg_2,
whismanoid 7:5b40b6370f8a 739 // uint8_t arg_3,
whismanoid 7:5b40b6370f8a 740 // uint8_t arg_4,
whismanoid 7:5b40b6370f8a 741 // uint8_t arg_5,
whismanoid 7:5b40b6370f8a 742 // uint8_t arg_6,
whismanoid 7:5b40b6370f8a 743 // uint8_t expect_result)
whismanoid 7:5b40b6370f8a 744 //{
whismanoid 7:5b40b6370f8a 745 // uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3, arg_4, arg_5, arg_6);
whismanoid 7:5b40b6370f8a 746 // if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 747 // {
whismanoid 7:5b40b6370f8a 748 // FAIL();
whismanoid 7:5b40b6370f8a 749 // associatedCmdLine.serial().printf("%s(%d,%d,%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6);
whismanoid 7:5b40b6370f8a 750 // associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 751 // associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 752 // return false;
whismanoid 7:5b40b6370f8a 753 // }
whismanoid 7:5b40b6370f8a 754 // else
whismanoid 7:5b40b6370f8a 755 // {
whismanoid 7:5b40b6370f8a 756 // PASS();
whismanoid 7:5b40b6370f8a 757 // associatedCmdLine.serial().printf("%s(%d,%d,%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4, arg_5, arg_6);
whismanoid 7:5b40b6370f8a 758 // associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 759 // return true;
whismanoid 7:5b40b6370f8a 760 // }
whismanoid 7:5b40b6370f8a 761 // //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 762 //}
whismanoid 7:5b40b6370f8a 763
whismanoid 0:93d4119d3f14 764 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 765 *
whismanoid 0:93d4119d3f14 766 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 767 *
whismanoid 0:93d4119d3f14 768 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 769 *
whismanoid 0:93d4119d3f14 770 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 771 *
whismanoid 0:93d4119d3f14 772 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 773 *
whismanoid 0:93d4119d3f14 774 */
whismanoid 0:93d4119d3f14 775 bool MaximTinyTester::AnalogIn0_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 776 {
whismanoid 0:93d4119d3f14 777 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[0];
whismanoid 2:9b20cadbfa15 778 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 779 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 780 {
whismanoid 2:9b20cadbfa15 781 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 782 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 783 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 784 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 785 }
whismanoid 0:93d4119d3f14 786
whismanoid 0:93d4119d3f14 787 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 788 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 789 float normValue_0_1 = analogInPin0.read();
whismanoid 0:93d4119d3f14 790 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 791 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 792 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 793 {
whismanoid 0:93d4119d3f14 794 PASS();
whismanoid 0:93d4119d3f14 795 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 796 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 797 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 798 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 799 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 800 );
whismanoid 0:93d4119d3f14 801 //
whismanoid 0:93d4119d3f14 802 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 803 return true;
whismanoid 0:93d4119d3f14 804 }
whismanoid 0:93d4119d3f14 805 else
whismanoid 0:93d4119d3f14 806 {
whismanoid 0:93d4119d3f14 807 FAIL();
whismanoid 0:93d4119d3f14 808 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 809 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 810 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 811 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 812 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 813 );
whismanoid 0:93d4119d3f14 814 //
whismanoid 0:93d4119d3f14 815 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 816 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 817 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 818 }
whismanoid 0:93d4119d3f14 819 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 820 return false;
whismanoid 0:93d4119d3f14 821 }
whismanoid 0:93d4119d3f14 822
whismanoid 0:93d4119d3f14 823 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 824 *
whismanoid 0:93d4119d3f14 825 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 826 *
whismanoid 0:93d4119d3f14 827 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 828 *
whismanoid 0:93d4119d3f14 829 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 830 *
whismanoid 0:93d4119d3f14 831 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 832 *
whismanoid 0:93d4119d3f14 833 */
whismanoid 0:93d4119d3f14 834 bool MaximTinyTester::AnalogIn1_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 835 {
whismanoid 0:93d4119d3f14 836 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[1];
whismanoid 2:9b20cadbfa15 837 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 838 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 839 {
whismanoid 2:9b20cadbfa15 840 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 841 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 842 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 843 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 844 }
whismanoid 0:93d4119d3f14 845
whismanoid 0:93d4119d3f14 846 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 847 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 848 float normValue_0_1 = analogInPin1.read();
whismanoid 0:93d4119d3f14 849 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 850 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 851 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 852 {
whismanoid 0:93d4119d3f14 853 PASS();
whismanoid 0:93d4119d3f14 854 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 855 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 856 associatedCmdLine.serial().printf("AIN1 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 857 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 858 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 859 );
whismanoid 0:93d4119d3f14 860 //
whismanoid 0:93d4119d3f14 861 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 862 return true;
whismanoid 0:93d4119d3f14 863 }
whismanoid 0:93d4119d3f14 864 else
whismanoid 0:93d4119d3f14 865 {
whismanoid 0:93d4119d3f14 866 FAIL();
whismanoid 0:93d4119d3f14 867 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 868 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 869 associatedCmdLine.serial().printf("AIN1 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 870 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 871 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 872 );
whismanoid 0:93d4119d3f14 873 //
whismanoid 0:93d4119d3f14 874 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 875 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 876 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 877 }
whismanoid 0:93d4119d3f14 878 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 879 return false;
whismanoid 0:93d4119d3f14 880 }
whismanoid 0:93d4119d3f14 881
whismanoid 0:93d4119d3f14 882 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 883 *
whismanoid 0:93d4119d3f14 884 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 885 *
whismanoid 0:93d4119d3f14 886 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 887 *
whismanoid 0:93d4119d3f14 888 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 889 *
whismanoid 0:93d4119d3f14 890 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 891 *
whismanoid 0:93d4119d3f14 892 */
whismanoid 0:93d4119d3f14 893 bool MaximTinyTester::AnalogIn2_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 894 {
whismanoid 0:93d4119d3f14 895 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[2];
whismanoid 2:9b20cadbfa15 896 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 897 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 898 {
whismanoid 2:9b20cadbfa15 899 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 900 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 901 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 902 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 903 }
whismanoid 0:93d4119d3f14 904
whismanoid 0:93d4119d3f14 905 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 906 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 907 float normValue_0_1 = analogInPin2.read();
whismanoid 0:93d4119d3f14 908 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 909 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 910 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 911 {
whismanoid 0:93d4119d3f14 912 PASS();
whismanoid 0:93d4119d3f14 913 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 914 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 915 associatedCmdLine.serial().printf("AIN2 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 916 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 917 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 918 );
whismanoid 0:93d4119d3f14 919 //
whismanoid 0:93d4119d3f14 920 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 921 return true;
whismanoid 0:93d4119d3f14 922 }
whismanoid 0:93d4119d3f14 923 else
whismanoid 0:93d4119d3f14 924 {
whismanoid 0:93d4119d3f14 925 FAIL();
whismanoid 0:93d4119d3f14 926 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 927 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 928 associatedCmdLine.serial().printf("AIN2 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 929 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 930 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 931 );
whismanoid 0:93d4119d3f14 932 //
whismanoid 0:93d4119d3f14 933 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 934 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 935 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 936 }
whismanoid 0:93d4119d3f14 937 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 938 return false;
whismanoid 0:93d4119d3f14 939 }
whismanoid 0:93d4119d3f14 940
whismanoid 0:93d4119d3f14 941 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 942 *
whismanoid 0:93d4119d3f14 943 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 944 *
whismanoid 0:93d4119d3f14 945 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 946 *
whismanoid 0:93d4119d3f14 947 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 948 *
whismanoid 0:93d4119d3f14 949 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 950 *
whismanoid 0:93d4119d3f14 951 */
whismanoid 0:93d4119d3f14 952 bool MaximTinyTester::AnalogIn3_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 953 {
whismanoid 0:93d4119d3f14 954 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[3];
whismanoid 2:9b20cadbfa15 955 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 956 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 957 {
whismanoid 2:9b20cadbfa15 958 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 959 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 960 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 961 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 962 }
whismanoid 0:93d4119d3f14 963
whismanoid 0:93d4119d3f14 964 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 965 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 966 float normValue_0_1 = analogInPin3.read();
whismanoid 0:93d4119d3f14 967 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 968 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 969 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 970 {
whismanoid 0:93d4119d3f14 971 PASS();
whismanoid 0:93d4119d3f14 972 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 973 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 974 associatedCmdLine.serial().printf("AIN3 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 975 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 976 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 977 );
whismanoid 0:93d4119d3f14 978 //
whismanoid 0:93d4119d3f14 979 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 980 return true;
whismanoid 0:93d4119d3f14 981 }
whismanoid 0:93d4119d3f14 982 else
whismanoid 0:93d4119d3f14 983 {
whismanoid 0:93d4119d3f14 984 FAIL();
whismanoid 0:93d4119d3f14 985 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 986 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 987 associatedCmdLine.serial().printf("AIN3 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 988 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 989 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 990 );
whismanoid 0:93d4119d3f14 991 //
whismanoid 0:93d4119d3f14 992 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 993 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 994 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 995 }
whismanoid 0:93d4119d3f14 996 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 997 return false;
whismanoid 0:93d4119d3f14 998 }
whismanoid 0:93d4119d3f14 999
whismanoid 0:93d4119d3f14 1000 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 1001 *
whismanoid 0:93d4119d3f14 1002 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 1003 *
whismanoid 0:93d4119d3f14 1004 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 1005 *
whismanoid 0:93d4119d3f14 1006 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 1007 *
whismanoid 0:93d4119d3f14 1008 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 1009 *
whismanoid 0:93d4119d3f14 1010 */
whismanoid 0:93d4119d3f14 1011 bool MaximTinyTester::AnalogIn4_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 1012 {
whismanoid 0:93d4119d3f14 1013 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[4];
whismanoid 2:9b20cadbfa15 1014 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1015 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1016 {
whismanoid 2:9b20cadbfa15 1017 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1018 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1019 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1020 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1021 }
whismanoid 0:93d4119d3f14 1022
whismanoid 0:93d4119d3f14 1023 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1024 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1025 float normValue_0_1 = analogInPin4.read();
whismanoid 0:93d4119d3f14 1026 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1027 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1028 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1029 {
whismanoid 0:93d4119d3f14 1030 PASS();
whismanoid 0:93d4119d3f14 1031 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1032 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1033 associatedCmdLine.serial().printf("AIN4 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1034 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1035 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1036 );
whismanoid 0:93d4119d3f14 1037 //
whismanoid 0:93d4119d3f14 1038 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1039 return true;
whismanoid 0:93d4119d3f14 1040 }
whismanoid 0:93d4119d3f14 1041 else
whismanoid 0:93d4119d3f14 1042 {
whismanoid 0:93d4119d3f14 1043 FAIL();
whismanoid 0:93d4119d3f14 1044 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1045 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1046 associatedCmdLine.serial().printf("AIN4 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1047 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1048 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1049 );
whismanoid 0:93d4119d3f14 1050 //
whismanoid 0:93d4119d3f14 1051 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1052 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1053 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1054 }
whismanoid 0:93d4119d3f14 1055 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1056 return false;
whismanoid 0:93d4119d3f14 1057 }
whismanoid 0:93d4119d3f14 1058
whismanoid 0:93d4119d3f14 1059 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 1060 *
whismanoid 0:93d4119d3f14 1061 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 1062 *
whismanoid 0:93d4119d3f14 1063 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 1064 *
whismanoid 0:93d4119d3f14 1065 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 1066 *
whismanoid 0:93d4119d3f14 1067 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 1068 *
whismanoid 0:93d4119d3f14 1069 */
whismanoid 0:93d4119d3f14 1070 bool MaximTinyTester::AnalogIn5_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 1071 {
whismanoid 0:93d4119d3f14 1072 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[5];
whismanoid 2:9b20cadbfa15 1073 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1074 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1075 {
whismanoid 2:9b20cadbfa15 1076 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1077 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1078 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1079 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1080 }
whismanoid 0:93d4119d3f14 1081
whismanoid 0:93d4119d3f14 1082 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1083 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1084 float normValue_0_1 = analogInPin5.read();
whismanoid 0:93d4119d3f14 1085 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1086 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1087 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1088 {
whismanoid 0:93d4119d3f14 1089 PASS();
whismanoid 0:93d4119d3f14 1090 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1091 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1092 associatedCmdLine.serial().printf("AIN5 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1093 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1094 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1095 );
whismanoid 0:93d4119d3f14 1096 //
whismanoid 0:93d4119d3f14 1097 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1098 return true;
whismanoid 0:93d4119d3f14 1099 }
whismanoid 0:93d4119d3f14 1100 else
whismanoid 0:93d4119d3f14 1101 {
whismanoid 0:93d4119d3f14 1102 FAIL();
whismanoid 0:93d4119d3f14 1103 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1104 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1105 associatedCmdLine.serial().printf("AIN5 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1106 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1107 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1108 );
whismanoid 0:93d4119d3f14 1109 //
whismanoid 0:93d4119d3f14 1110 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1111 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1112 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1113 }
whismanoid 0:93d4119d3f14 1114 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1115 return false;
whismanoid 0:93d4119d3f14 1116 }
whismanoid 0:93d4119d3f14 1117
whismanoid 0:93d4119d3f14 1118 bool MaximTinyTester::AnalogIn_Read_Expect_voltageV(AnalogIn& analogInPin, double expect_result)
whismanoid 0:93d4119d3f14 1119 {
whismanoid 0:93d4119d3f14 1120 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[0];
whismanoid 2:9b20cadbfa15 1121 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1122 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1123 {
whismanoid 2:9b20cadbfa15 1124 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1125 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1126 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1127 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1128 }
whismanoid 0:93d4119d3f14 1129
whismanoid 0:93d4119d3f14 1130 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1131 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1132 float normValue_0_1 = analogInPin.read();
whismanoid 0:93d4119d3f14 1133 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1134 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1135 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1136 {
whismanoid 0:93d4119d3f14 1137 PASS();
whismanoid 0:93d4119d3f14 1138 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1139 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1140 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1141 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1142 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1143 );
whismanoid 0:93d4119d3f14 1144 //
whismanoid 0:93d4119d3f14 1145 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1146 return true;
whismanoid 0:93d4119d3f14 1147 }
whismanoid 0:93d4119d3f14 1148 else
whismanoid 0:93d4119d3f14 1149 {
whismanoid 0:93d4119d3f14 1150 FAIL();
whismanoid 0:93d4119d3f14 1151 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1152 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1153 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1154 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1155 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1156 );
whismanoid 0:93d4119d3f14 1157 //
whismanoid 0:93d4119d3f14 1158 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1159 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1160 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1161 }
whismanoid 0:93d4119d3f14 1162 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1163 return false;
whismanoid 0:93d4119d3f14 1164 }
whismanoid 0:93d4119d3f14 1165
whismanoid 0:93d4119d3f14 1166 bool MaximTinyTester::DigitalIn_Read_Expect_WarnOnly(DigitalIn& digitalInPin, const char* pinName, int expect_result, const char *expect_description)
whismanoid 0:93d4119d3f14 1167 {
whismanoid 0:93d4119d3f14 1168 int actual_UPO_value = -1;
whismanoid 0:93d4119d3f14 1169 for (int retry_count = 0; retry_count < 10; retry_count++) {
whismanoid 0:93d4119d3f14 1170 actual_UPO_value = digitalInPin.read(); // g_MAX5171_device.UPOinputValue();
whismanoid 0:93d4119d3f14 1171 if (actual_UPO_value == expect_result) {
whismanoid 0:93d4119d3f14 1172 PASS();
whismanoid 0:93d4119d3f14 1173 associatedCmdLine.serial().printf("%s signal=%d %s", pinName, expect_result, expect_description);
whismanoid 0:93d4119d3f14 1174 return true;
whismanoid 0:93d4119d3f14 1175 }
whismanoid 0:93d4119d3f14 1176 // UPO condition not met, retry for a while until give up
whismanoid 0:93d4119d3f14 1177 wait_ms(input_timeout_time_msec / 10); // delay
whismanoid 0:93d4119d3f14 1178 }
whismanoid 0:93d4119d3f14 1179 associatedCmdLine.serial().printf("\r\n!WARN "); // SelfTest_FAIL(cmdLine);
whismanoid 0:93d4119d3f14 1180 associatedCmdLine.serial().printf("expected %s signal=%d %s", pinName, expect_result, expect_description);
whismanoid 0:93d4119d3f14 1181 associatedCmdLine.serial().printf(", but got actual %s=%d", pinName, actual_UPO_value);
whismanoid 0:93d4119d3f14 1182 associatedCmdLine.serial().printf(", missing %s connections?", pinName);
whismanoid 0:93d4119d3f14 1183 return false;
whismanoid 0:93d4119d3f14 1184 }
whismanoid 0:93d4119d3f14 1185
whismanoid 0:93d4119d3f14 1186 void MaximTinyTester::Wait_Output_Settling()
whismanoid 0:93d4119d3f14 1187 {
whismanoid 0:93d4119d3f14 1188 wait_ms(settle_time_msec); // delay
whismanoid 0:93d4119d3f14 1189 }
whismanoid 0:93d4119d3f14 1190
whismanoid 0:93d4119d3f14 1191
whismanoid 0:93d4119d3f14 1192 // End of file