Mark Underwood / MaximTinyTester

minimalist hardware testing support

Dependents:   MAX5715BOB_Tester MAX11131BOB_Tester MAX5171BOB_Tester MAX11410BOB_Tester ... more

MaximTinyTester.cpp@8:9171f0ab3c17, 2020-03-17 (annotated)

Committer:
whismanoid
Date:
Tue Mar 17 04:00:17 2020 +0000
Revision:
8:9171f0ab3c17
Parent:
7:5b40b6370f8a
Child:
9:3ec00515891d
support uint8_t() 0 args for MAX11410 SelfTest setups

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 0:93d4119d3f14 166 /** Report number of pass and number of fail test results
whismanoid 0:93d4119d3f14 167 */
whismanoid 0:93d4119d3f14 168 void MaximTinyTester::Report_Summary(void)
whismanoid 0:93d4119d3f14 169 {
whismanoid 0:93d4119d3f14 170 associatedCmdLine.serial().printf("\r\nSummary: %d PASS %d FAIL\r\n", nPass, nFail);
whismanoid 0:93d4119d3f14 171 //~ associatedCmdLine.serial().printf(g_SelfTest_nPass);
whismanoid 0:93d4119d3f14 172 //~ associatedCmdLine.serial().printf(" PASS ");
whismanoid 0:93d4119d3f14 173 //~ associatedCmdLine.serial().printf(g_SelfTest_nFail);
whismanoid 0:93d4119d3f14 174 //~ associatedCmdLine.serial().printf(" FAIL\r\n");
whismanoid 0:93d4119d3f14 175 if (nFail == 0) {
whismanoid 3:080aa1bb1bc0 176 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 177 m_RFailLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 178 }
whismanoid 3:080aa1bb1bc0 179 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 180 m_GPassLED = LED_ON;
whismanoid 3:080aa1bb1bc0 181 }
whismanoid 3:080aa1bb1bc0 182 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 183 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 184 }
whismanoid 1:f98ddb04f9e0 185 //~ rgb_led.green(); // diagnostic rbg led GREEN
whismanoid 1:f98ddb04f9e0 186 }
whismanoid 1:f98ddb04f9e0 187 else {
whismanoid 3:080aa1bb1bc0 188 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 189 m_RFailLED = LED_ON;
whismanoid 3:080aa1bb1bc0 190 }
whismanoid 3:080aa1bb1bc0 191 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 192 m_GPassLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 193 }
whismanoid 3:080aa1bb1bc0 194 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 195 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 196 }
whismanoid 0:93d4119d3f14 197 //~ rgb_led.red(); // diagnostic rbg led RED
whismanoid 0:93d4119d3f14 198 }
whismanoid 0:93d4119d3f14 199 }
whismanoid 0:93d4119d3f14 200
whismanoid 0:93d4119d3f14 201 /** Test a software function
whismanoid 0:93d4119d3f14 202 *
whismanoid 0:93d4119d3f14 203 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 0:93d4119d3f14 204 *
whismanoid 0:93d4119d3f14 205 * @param[in] functionUnderTest points to the function under test
whismanoid 0:93d4119d3f14 206 *
whismanoid 8:9171f0ab3c17 207 * @param[in] arg_1_voltageV is a test argument given to the function under test
whismanoid 0:93d4119d3f14 208 *
whismanoid 0:93d4119d3f14 209 * @param[in] expect_result contains the expected result
whismanoid 0:93d4119d3f14 210 *
whismanoid 0:93d4119d3f14 211 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 212 *
whismanoid 0:93d4119d3f14 213 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 214 *
whismanoid 0:93d4119d3f14 215 */
whismanoid 0:93d4119d3f14 216 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 0:93d4119d3f14 217 Callback<uint16_t(double)> functionUnderTest,
whismanoid 8:9171f0ab3c17 218 double arg_1_voltageV,
whismanoid 8:9171f0ab3c17 219 uint16_t expect_result)
whismanoid 0:93d4119d3f14 220 {
whismanoid 8:9171f0ab3c17 221 uint16_t actual_result = functionUnderTest(arg_1_voltageV);
whismanoid 0:93d4119d3f14 222 if (actual_result != expect_result)
whismanoid 0:93d4119d3f14 223 {
whismanoid 0:93d4119d3f14 224 FAIL();
whismanoid 8:9171f0ab3c17 225 associatedCmdLine.serial().printf("%s(%6.4fV)", nameOfFunctionUnderTest, arg_1_voltageV);
whismanoid 0:93d4119d3f14 226 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 0:93d4119d3f14 227 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 0:93d4119d3f14 228 return false;
whismanoid 0:93d4119d3f14 229 }
whismanoid 0:93d4119d3f14 230 else
whismanoid 0:93d4119d3f14 231 {
whismanoid 0:93d4119d3f14 232 PASS();
whismanoid 8:9171f0ab3c17 233 associatedCmdLine.serial().printf("%s(%6.4fV)", nameOfFunctionUnderTest, arg_1_voltageV);
whismanoid 0:93d4119d3f14 234 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 0:93d4119d3f14 235 return true;
whismanoid 0:93d4119d3f14 236 }
whismanoid 0:93d4119d3f14 237 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 238 }
whismanoid 0:93d4119d3f14 239
whismanoid 0:93d4119d3f14 240 /** Test a software function
whismanoid 0:93d4119d3f14 241 *
whismanoid 0:93d4119d3f14 242 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 0:93d4119d3f14 243 *
whismanoid 0:93d4119d3f14 244 * @param[in] functionUnderTest points to the function under test
whismanoid 0:93d4119d3f14 245 *
whismanoid 8:9171f0ab3c17 246 * @param[in] arg_1_u16 is a test argument given to the function under test
whismanoid 0:93d4119d3f14 247 *
whismanoid 0:93d4119d3f14 248 * @param[in] expect_result contains the expected result
whismanoid 0:93d4119d3f14 249 *
whismanoid 0:93d4119d3f14 250 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 251 *
whismanoid 0:93d4119d3f14 252 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 253 *
whismanoid 0:93d4119d3f14 254 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 255 *
whismanoid 0:93d4119d3f14 256 */
whismanoid 0:93d4119d3f14 257 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 0:93d4119d3f14 258 Callback<double(uint16_t)> functionUnderTest,
whismanoid 8:9171f0ab3c17 259 uint16_t arg_1_u16,
whismanoid 8:9171f0ab3c17 260 double expect_result)
whismanoid 0:93d4119d3f14 261 {
whismanoid 8:9171f0ab3c17 262 double actual_result = functionUnderTest(arg_1_u16);
whismanoid 0:93d4119d3f14 263 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 264 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 265 {
whismanoid 0:93d4119d3f14 266 PASS();
whismanoid 8:9171f0ab3c17 267 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1_u16);
whismanoid 0:93d4119d3f14 268 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 0:93d4119d3f14 269 return true;
whismanoid 0:93d4119d3f14 270 }
whismanoid 0:93d4119d3f14 271 else
whismanoid 0:93d4119d3f14 272 {
whismanoid 0:93d4119d3f14 273 FAIL();
whismanoid 8:9171f0ab3c17 274 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1_u16);
whismanoid 0:93d4119d3f14 275 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 0:93d4119d3f14 276 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 277 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 278 return false;
whismanoid 0:93d4119d3f14 279 }
whismanoid 0:93d4119d3f14 280 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 281 }
whismanoid 0:93d4119d3f14 282
whismanoid 5:67a1cd5a67cc 283 /** Test a software function
whismanoid 5:67a1cd5a67cc 284 *
whismanoid 5:67a1cd5a67cc 285 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 5:67a1cd5a67cc 286 *
whismanoid 5:67a1cd5a67cc 287 * @param[in] functionUnderTest points to the function under test
whismanoid 5:67a1cd5a67cc 288 *
whismanoid 8:9171f0ab3c17 289 * @param[in] arg_1_u32 is a test argument given to the function under test
whismanoid 5:67a1cd5a67cc 290 *
whismanoid 5:67a1cd5a67cc 291 * @param[in] expect_result contains the expected result
whismanoid 5:67a1cd5a67cc 292 *
whismanoid 5:67a1cd5a67cc 293 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 5:67a1cd5a67cc 294 *
whismanoid 5:67a1cd5a67cc 295 * @post nPass and nFail counters are updated
whismanoid 5:67a1cd5a67cc 296 *
whismanoid 5:67a1cd5a67cc 297 * @return true if success, false if test failed
whismanoid 5:67a1cd5a67cc 298 *
whismanoid 5:67a1cd5a67cc 299 */
whismanoid 5:67a1cd5a67cc 300 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 5:67a1cd5a67cc 301 Callback<double(uint32_t)> functionUnderTest,
whismanoid 8:9171f0ab3c17 302 uint32_t arg_1_u32,
whismanoid 8:9171f0ab3c17 303 double expect_result)
whismanoid 5:67a1cd5a67cc 304 {
whismanoid 8:9171f0ab3c17 305 double actual_result = functionUnderTest(arg_1_u32);
whismanoid 5:67a1cd5a67cc 306 double err_result = (actual_result - expect_result);
whismanoid 5:67a1cd5a67cc 307 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 5:67a1cd5a67cc 308 {
whismanoid 5:67a1cd5a67cc 309 PASS();
whismanoid 8:9171f0ab3c17 310 associatedCmdLine.serial().printf("%s(0x%lx)", nameOfFunctionUnderTest, arg_1_u32);
whismanoid 5:67a1cd5a67cc 311 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 312 return true;
whismanoid 5:67a1cd5a67cc 313 }
whismanoid 5:67a1cd5a67cc 314 else
whismanoid 5:67a1cd5a67cc 315 {
whismanoid 5:67a1cd5a67cc 316 FAIL();
whismanoid 8:9171f0ab3c17 317 associatedCmdLine.serial().printf("%s(0x%lx)", nameOfFunctionUnderTest, arg_1_u32);
whismanoid 5:67a1cd5a67cc 318 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 319 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 5:67a1cd5a67cc 320 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 5:67a1cd5a67cc 321 return false;
whismanoid 5:67a1cd5a67cc 322 }
whismanoid 5:67a1cd5a67cc 323 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 5:67a1cd5a67cc 324 }
whismanoid 5:67a1cd5a67cc 325
whismanoid 5:67a1cd5a67cc 326 /** Test a software function
whismanoid 5:67a1cd5a67cc 327 *
whismanoid 5:67a1cd5a67cc 328 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 5:67a1cd5a67cc 329 *
whismanoid 5:67a1cd5a67cc 330 * @param[in] functionUnderTest points to the function under test
whismanoid 5:67a1cd5a67cc 331 *
whismanoid 8:9171f0ab3c17 332 * @param[in] arg_1_d is a test argument given to the function under test
whismanoid 5:67a1cd5a67cc 333 *
whismanoid 5:67a1cd5a67cc 334 * @param[in] expect_result contains the expected result
whismanoid 5:67a1cd5a67cc 335 *
whismanoid 5:67a1cd5a67cc 336 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 5:67a1cd5a67cc 337 *
whismanoid 5:67a1cd5a67cc 338 * @post nPass and nFail counters are updated
whismanoid 5:67a1cd5a67cc 339 *
whismanoid 5:67a1cd5a67cc 340 * @return true if success, false if test failed
whismanoid 5:67a1cd5a67cc 341 *
whismanoid 5:67a1cd5a67cc 342 */
whismanoid 5:67a1cd5a67cc 343 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 5:67a1cd5a67cc 344 Callback<double(double)> functionUnderTest,
whismanoid 8:9171f0ab3c17 345 double arg_1_d,
whismanoid 8:9171f0ab3c17 346 double expect_result)
whismanoid 5:67a1cd5a67cc 347 {
whismanoid 8:9171f0ab3c17 348 double actual_result = functionUnderTest(arg_1_d);
whismanoid 5:67a1cd5a67cc 349 double err_result = (actual_result - expect_result);
whismanoid 5:67a1cd5a67cc 350 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 5:67a1cd5a67cc 351 {
whismanoid 5:67a1cd5a67cc 352 PASS();
whismanoid 8:9171f0ab3c17 353 associatedCmdLine.serial().printf("%s(%6.6f)", nameOfFunctionUnderTest, arg_1_d);
whismanoid 5:67a1cd5a67cc 354 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 355 return true;
whismanoid 5:67a1cd5a67cc 356 }
whismanoid 5:67a1cd5a67cc 357 else
whismanoid 5:67a1cd5a67cc 358 {
whismanoid 5:67a1cd5a67cc 359 FAIL();
whismanoid 8:9171f0ab3c17 360 associatedCmdLine.serial().printf("%s(%6.6f)", nameOfFunctionUnderTest, arg_1_d);
whismanoid 5:67a1cd5a67cc 361 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 362 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 5:67a1cd5a67cc 363 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 5:67a1cd5a67cc 364 return false;
whismanoid 5:67a1cd5a67cc 365 }
whismanoid 5:67a1cd5a67cc 366 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 5:67a1cd5a67cc 367 }
whismanoid 5:67a1cd5a67cc 368
whismanoid 7:5b40b6370f8a 369 /** Test a software function
whismanoid 7:5b40b6370f8a 370 *
whismanoid 7:5b40b6370f8a 371 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 372 *
whismanoid 7:5b40b6370f8a 373 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 374 *
whismanoid 8:9171f0ab3c17 375 * @param[in] expect_result contains the expected result
whismanoid 8:9171f0ab3c17 376 *
whismanoid 8:9171f0ab3c17 377 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 8:9171f0ab3c17 378 *
whismanoid 8:9171f0ab3c17 379 * @post nPass and nFail counters are updated
whismanoid 8:9171f0ab3c17 380 *
whismanoid 8:9171f0ab3c17 381 * @return true if success, false if test failed
whismanoid 8:9171f0ab3c17 382 *
whismanoid 8:9171f0ab3c17 383 */
whismanoid 8:9171f0ab3c17 384 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 8:9171f0ab3c17 385 Callback<uint8_t()> functionUnderTest,
whismanoid 8:9171f0ab3c17 386 uint8_t expect_result)
whismanoid 8:9171f0ab3c17 387 {
whismanoid 8:9171f0ab3c17 388 uint8_t actual_result = functionUnderTest();
whismanoid 8:9171f0ab3c17 389 if (actual_result != expect_result)
whismanoid 8:9171f0ab3c17 390 {
whismanoid 8:9171f0ab3c17 391 FAIL();
whismanoid 8:9171f0ab3c17 392 associatedCmdLine.serial().printf("%s()", nameOfFunctionUnderTest);
whismanoid 8:9171f0ab3c17 393 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 8:9171f0ab3c17 394 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 8:9171f0ab3c17 395 return false;
whismanoid 8:9171f0ab3c17 396 }
whismanoid 8:9171f0ab3c17 397 else
whismanoid 8:9171f0ab3c17 398 {
whismanoid 8:9171f0ab3c17 399 PASS();
whismanoid 8:9171f0ab3c17 400 associatedCmdLine.serial().printf("%s()", nameOfFunctionUnderTest);
whismanoid 8:9171f0ab3c17 401 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 8:9171f0ab3c17 402 return true;
whismanoid 8:9171f0ab3c17 403 }
whismanoid 8:9171f0ab3c17 404 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 8:9171f0ab3c17 405 }
whismanoid 8:9171f0ab3c17 406
whismanoid 8:9171f0ab3c17 407 /** Test a software function
whismanoid 8:9171f0ab3c17 408 *
whismanoid 8:9171f0ab3c17 409 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 8:9171f0ab3c17 410 *
whismanoid 8:9171f0ab3c17 411 * @param[in] functionUnderTest points to the function under test
whismanoid 8:9171f0ab3c17 412 *
whismanoid 7:5b40b6370f8a 413 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 414 *
whismanoid 7:5b40b6370f8a 415 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 416 *
whismanoid 7:5b40b6370f8a 417 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 7:5b40b6370f8a 418 *
whismanoid 7:5b40b6370f8a 419 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 420 *
whismanoid 7:5b40b6370f8a 421 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 422 *
whismanoid 7:5b40b6370f8a 423 */
whismanoid 7:5b40b6370f8a 424 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 425 Callback<uint8_t(uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 426 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 427 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 428 {
whismanoid 7:5b40b6370f8a 429 uint8_t actual_result = functionUnderTest(arg_1);
whismanoid 7:5b40b6370f8a 430 if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 431 {
whismanoid 7:5b40b6370f8a 432 FAIL();
whismanoid 7:5b40b6370f8a 433 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1);
whismanoid 7:5b40b6370f8a 434 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 435 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 436 return false;
whismanoid 7:5b40b6370f8a 437 }
whismanoid 7:5b40b6370f8a 438 else
whismanoid 7:5b40b6370f8a 439 {
whismanoid 7:5b40b6370f8a 440 PASS();
whismanoid 7:5b40b6370f8a 441 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1);
whismanoid 7:5b40b6370f8a 442 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 443 return true;
whismanoid 7:5b40b6370f8a 444 }
whismanoid 7:5b40b6370f8a 445 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 446 }
whismanoid 7:5b40b6370f8a 447
whismanoid 7:5b40b6370f8a 448 /** Test a software function
whismanoid 7:5b40b6370f8a 449 *
whismanoid 7:5b40b6370f8a 450 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 451 *
whismanoid 7:5b40b6370f8a 452 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 453 *
whismanoid 7:5b40b6370f8a 454 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 455 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 456 *
whismanoid 7:5b40b6370f8a 457 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 458 *
whismanoid 7:5b40b6370f8a 459 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 7:5b40b6370f8a 460 *
whismanoid 7:5b40b6370f8a 461 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 462 *
whismanoid 7:5b40b6370f8a 463 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 464 *
whismanoid 7:5b40b6370f8a 465 */
whismanoid 7:5b40b6370f8a 466 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 467 Callback<uint8_t(uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 468 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 469 uint8_t arg_2,
whismanoid 7:5b40b6370f8a 470 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 471 {
whismanoid 7:5b40b6370f8a 472 uint8_t actual_result = functionUnderTest(arg_1, arg_2);
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,%d)", nameOfFunctionUnderTest, arg_1, arg_2);
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,%d)", nameOfFunctionUnderTest, arg_1, arg_2);
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 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 500 *
whismanoid 7:5b40b6370f8a 501 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 502 *
whismanoid 7:5b40b6370f8a 503 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 7:5b40b6370f8a 504 *
whismanoid 7:5b40b6370f8a 505 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 506 *
whismanoid 7:5b40b6370f8a 507 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 508 *
whismanoid 7:5b40b6370f8a 509 */
whismanoid 7:5b40b6370f8a 510 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 511 Callback<uint8_t(uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 512 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 513 uint8_t arg_2,
whismanoid 7:5b40b6370f8a 514 uint8_t arg_3,
whismanoid 7:5b40b6370f8a 515 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 516 {
whismanoid 7:5b40b6370f8a 517 uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3);
whismanoid 7:5b40b6370f8a 518 if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 519 {
whismanoid 7:5b40b6370f8a 520 FAIL();
whismanoid 7:5b40b6370f8a 521 associatedCmdLine.serial().printf("%s(%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3);
whismanoid 7:5b40b6370f8a 522 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 523 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 524 return false;
whismanoid 7:5b40b6370f8a 525 }
whismanoid 7:5b40b6370f8a 526 else
whismanoid 7:5b40b6370f8a 527 {
whismanoid 7:5b40b6370f8a 528 PASS();
whismanoid 7:5b40b6370f8a 529 associatedCmdLine.serial().printf("%s(%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3);
whismanoid 7:5b40b6370f8a 530 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 531 return true;
whismanoid 7:5b40b6370f8a 532 }
whismanoid 7:5b40b6370f8a 533 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 534 }
whismanoid 7:5b40b6370f8a 535
whismanoid 7:5b40b6370f8a 536 /** Test a software function
whismanoid 7:5b40b6370f8a 537 *
whismanoid 7:5b40b6370f8a 538 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 539 *
whismanoid 7:5b40b6370f8a 540 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 541 *
whismanoid 7:5b40b6370f8a 542 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 543 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 544 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 545 * @param[in] arg_4 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 546 *
whismanoid 7:5b40b6370f8a 547 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 548 *
whismanoid 7:5b40b6370f8a 549 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 7:5b40b6370f8a 550 *
whismanoid 7:5b40b6370f8a 551 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 552 *
whismanoid 7:5b40b6370f8a 553 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 554 *
whismanoid 7:5b40b6370f8a 555 */
whismanoid 7:5b40b6370f8a 556 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 557 Callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 558 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 559 uint8_t arg_2,
whismanoid 7:5b40b6370f8a 560 uint8_t arg_3,
whismanoid 7:5b40b6370f8a 561 uint8_t arg_4,
whismanoid 7:5b40b6370f8a 562 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 563 {
whismanoid 7:5b40b6370f8a 564 uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3, arg_4);
whismanoid 7:5b40b6370f8a 565 if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 566 {
whismanoid 7:5b40b6370f8a 567 FAIL();
whismanoid 7:5b40b6370f8a 568 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4);
whismanoid 7:5b40b6370f8a 569 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 570 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 571 return false;
whismanoid 7:5b40b6370f8a 572 }
whismanoid 7:5b40b6370f8a 573 else
whismanoid 7:5b40b6370f8a 574 {
whismanoid 7:5b40b6370f8a 575 PASS();
whismanoid 7:5b40b6370f8a 576 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4);
whismanoid 7:5b40b6370f8a 577 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 578 return true;
whismanoid 7:5b40b6370f8a 579 }
whismanoid 7:5b40b6370f8a 580 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 581 }
whismanoid 7:5b40b6370f8a 582
whismanoid 7:5b40b6370f8a 583 /** Test a software function
whismanoid 7:5b40b6370f8a 584 *
whismanoid 7:5b40b6370f8a 585 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 586 *
whismanoid 7:5b40b6370f8a 587 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 588 *
whismanoid 7:5b40b6370f8a 589 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 590 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 591 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 592 * @param[in] arg_4 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 593 * @param[in] arg_5 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 594 *
whismanoid 7:5b40b6370f8a 595 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 596 *
whismanoid 7:5b40b6370f8a 597 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 7:5b40b6370f8a 598 *
whismanoid 7:5b40b6370f8a 599 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 600 *
whismanoid 7:5b40b6370f8a 601 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 602 *
whismanoid 7:5b40b6370f8a 603 */
whismanoid 7:5b40b6370f8a 604 bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 605 Callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 606 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 607 uint8_t arg_2,
whismanoid 7:5b40b6370f8a 608 uint8_t arg_3,
whismanoid 7:5b40b6370f8a 609 uint8_t arg_4,
whismanoid 7:5b40b6370f8a 610 uint8_t arg_5,
whismanoid 7:5b40b6370f8a 611 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 612 {
whismanoid 7:5b40b6370f8a 613 uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3, arg_4, arg_5);
whismanoid 7:5b40b6370f8a 614 if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 615 {
whismanoid 7:5b40b6370f8a 616 FAIL();
whismanoid 7:5b40b6370f8a 617 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4, arg_5);
whismanoid 7:5b40b6370f8a 618 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 619 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 620 return false;
whismanoid 7:5b40b6370f8a 621 }
whismanoid 7:5b40b6370f8a 622 else
whismanoid 7:5b40b6370f8a 623 {
whismanoid 7:5b40b6370f8a 624 PASS();
whismanoid 7:5b40b6370f8a 625 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4, arg_5);
whismanoid 7:5b40b6370f8a 626 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 627 return true;
whismanoid 7:5b40b6370f8a 628 }
whismanoid 7:5b40b6370f8a 629 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 630 }
whismanoid 7:5b40b6370f8a 631
whismanoid 7:5b40b6370f8a 632 // TODO1 #167 support callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)>
whismanoid 7:5b40b6370f8a 633 /** Test a software function
whismanoid 7:5b40b6370f8a 634 *
whismanoid 7:5b40b6370f8a 635 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 636 *
whismanoid 7:5b40b6370f8a 637 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 638 *
whismanoid 7:5b40b6370f8a 639 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 640 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 641 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 642 * @param[in] arg_4 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 643 * @param[in] arg_5 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 644 * @param[in] arg_6 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 645 *
whismanoid 7:5b40b6370f8a 646 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 647 *
whismanoid 7:5b40b6370f8a 648 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 7:5b40b6370f8a 649 *
whismanoid 7:5b40b6370f8a 650 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 651 *
whismanoid 7:5b40b6370f8a 652 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 653 *
whismanoid 7:5b40b6370f8a 654 */
whismanoid 7:5b40b6370f8a 655 //bool MaximTinyTester::FunctionCall_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 656 // Callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 657 // uint8_t arg_1,
whismanoid 7:5b40b6370f8a 658 // uint8_t arg_2,
whismanoid 7:5b40b6370f8a 659 // uint8_t arg_3,
whismanoid 7:5b40b6370f8a 660 // uint8_t arg_4,
whismanoid 7:5b40b6370f8a 661 // uint8_t arg_5,
whismanoid 7:5b40b6370f8a 662 // uint8_t arg_6,
whismanoid 7:5b40b6370f8a 663 // uint8_t expect_result)
whismanoid 7:5b40b6370f8a 664 //{
whismanoid 7:5b40b6370f8a 665 // uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3, arg_4, arg_5, arg_6);
whismanoid 7:5b40b6370f8a 666 // if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 667 // {
whismanoid 7:5b40b6370f8a 668 // FAIL();
whismanoid 7:5b40b6370f8a 669 // 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 670 // associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 671 // associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 672 // return false;
whismanoid 7:5b40b6370f8a 673 // }
whismanoid 7:5b40b6370f8a 674 // else
whismanoid 7:5b40b6370f8a 675 // {
whismanoid 7:5b40b6370f8a 676 // PASS();
whismanoid 7:5b40b6370f8a 677 // 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 678 // associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 679 // return true;
whismanoid 7:5b40b6370f8a 680 // }
whismanoid 7:5b40b6370f8a 681 // //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 682 //}
whismanoid 7:5b40b6370f8a 683
whismanoid 0:93d4119d3f14 684 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 685 *
whismanoid 0:93d4119d3f14 686 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 687 *
whismanoid 0:93d4119d3f14 688 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 689 *
whismanoid 0:93d4119d3f14 690 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 691 *
whismanoid 0:93d4119d3f14 692 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 693 *
whismanoid 0:93d4119d3f14 694 */
whismanoid 0:93d4119d3f14 695 bool MaximTinyTester::AnalogIn0_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 696 {
whismanoid 0:93d4119d3f14 697 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[0];
whismanoid 2:9b20cadbfa15 698 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 699 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 700 {
whismanoid 2:9b20cadbfa15 701 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 702 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 703 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 704 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 705 }
whismanoid 0:93d4119d3f14 706
whismanoid 0:93d4119d3f14 707 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 708 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 709 float normValue_0_1 = analogInPin0.read();
whismanoid 0:93d4119d3f14 710 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 711 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 712 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 713 {
whismanoid 0:93d4119d3f14 714 PASS();
whismanoid 0:93d4119d3f14 715 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 716 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 717 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 718 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 719 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 720 );
whismanoid 0:93d4119d3f14 721 //
whismanoid 0:93d4119d3f14 722 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 723 return true;
whismanoid 0:93d4119d3f14 724 }
whismanoid 0:93d4119d3f14 725 else
whismanoid 0:93d4119d3f14 726 {
whismanoid 0:93d4119d3f14 727 FAIL();
whismanoid 0:93d4119d3f14 728 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 729 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 730 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 731 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 732 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 733 );
whismanoid 0:93d4119d3f14 734 //
whismanoid 0:93d4119d3f14 735 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 736 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 737 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 738 }
whismanoid 0:93d4119d3f14 739 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 740 return false;
whismanoid 0:93d4119d3f14 741 }
whismanoid 0:93d4119d3f14 742
whismanoid 0:93d4119d3f14 743 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 744 *
whismanoid 0:93d4119d3f14 745 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 746 *
whismanoid 0:93d4119d3f14 747 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 748 *
whismanoid 0:93d4119d3f14 749 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 750 *
whismanoid 0:93d4119d3f14 751 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 752 *
whismanoid 0:93d4119d3f14 753 */
whismanoid 0:93d4119d3f14 754 bool MaximTinyTester::AnalogIn1_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 755 {
whismanoid 0:93d4119d3f14 756 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[1];
whismanoid 2:9b20cadbfa15 757 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 758 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 759 {
whismanoid 2:9b20cadbfa15 760 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 761 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 762 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 763 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 764 }
whismanoid 0:93d4119d3f14 765
whismanoid 0:93d4119d3f14 766 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 767 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 768 float normValue_0_1 = analogInPin1.read();
whismanoid 0:93d4119d3f14 769 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 770 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 771 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 772 {
whismanoid 0:93d4119d3f14 773 PASS();
whismanoid 0:93d4119d3f14 774 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 775 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 776 associatedCmdLine.serial().printf("AIN1 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 777 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 778 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 779 );
whismanoid 0:93d4119d3f14 780 //
whismanoid 0:93d4119d3f14 781 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 782 return true;
whismanoid 0:93d4119d3f14 783 }
whismanoid 0:93d4119d3f14 784 else
whismanoid 0:93d4119d3f14 785 {
whismanoid 0:93d4119d3f14 786 FAIL();
whismanoid 0:93d4119d3f14 787 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 788 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 789 associatedCmdLine.serial().printf("AIN1 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 790 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 791 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 792 );
whismanoid 0:93d4119d3f14 793 //
whismanoid 0:93d4119d3f14 794 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 795 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 796 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 797 }
whismanoid 0:93d4119d3f14 798 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 799 return false;
whismanoid 0:93d4119d3f14 800 }
whismanoid 0:93d4119d3f14 801
whismanoid 0:93d4119d3f14 802 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 803 *
whismanoid 0:93d4119d3f14 804 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 805 *
whismanoid 0:93d4119d3f14 806 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 807 *
whismanoid 0:93d4119d3f14 808 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 809 *
whismanoid 0:93d4119d3f14 810 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 811 *
whismanoid 0:93d4119d3f14 812 */
whismanoid 0:93d4119d3f14 813 bool MaximTinyTester::AnalogIn2_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 814 {
whismanoid 0:93d4119d3f14 815 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[2];
whismanoid 2:9b20cadbfa15 816 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 817 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 818 {
whismanoid 2:9b20cadbfa15 819 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 820 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 821 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 822 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 823 }
whismanoid 0:93d4119d3f14 824
whismanoid 0:93d4119d3f14 825 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 826 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 827 float normValue_0_1 = analogInPin2.read();
whismanoid 0:93d4119d3f14 828 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 829 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 830 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 831 {
whismanoid 0:93d4119d3f14 832 PASS();
whismanoid 0:93d4119d3f14 833 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 834 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 835 associatedCmdLine.serial().printf("AIN2 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 836 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 837 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 838 );
whismanoid 0:93d4119d3f14 839 //
whismanoid 0:93d4119d3f14 840 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 841 return true;
whismanoid 0:93d4119d3f14 842 }
whismanoid 0:93d4119d3f14 843 else
whismanoid 0:93d4119d3f14 844 {
whismanoid 0:93d4119d3f14 845 FAIL();
whismanoid 0:93d4119d3f14 846 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 847 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 848 associatedCmdLine.serial().printf("AIN2 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 849 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 850 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 851 );
whismanoid 0:93d4119d3f14 852 //
whismanoid 0:93d4119d3f14 853 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 854 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 855 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 856 }
whismanoid 0:93d4119d3f14 857 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 858 return false;
whismanoid 0:93d4119d3f14 859 }
whismanoid 0:93d4119d3f14 860
whismanoid 0:93d4119d3f14 861 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 862 *
whismanoid 0:93d4119d3f14 863 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 864 *
whismanoid 0:93d4119d3f14 865 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 866 *
whismanoid 0:93d4119d3f14 867 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 868 *
whismanoid 0:93d4119d3f14 869 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 870 *
whismanoid 0:93d4119d3f14 871 */
whismanoid 0:93d4119d3f14 872 bool MaximTinyTester::AnalogIn3_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 873 {
whismanoid 0:93d4119d3f14 874 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[3];
whismanoid 2:9b20cadbfa15 875 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 876 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 877 {
whismanoid 2:9b20cadbfa15 878 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 879 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 880 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 881 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 882 }
whismanoid 0:93d4119d3f14 883
whismanoid 0:93d4119d3f14 884 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 885 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 886 float normValue_0_1 = analogInPin3.read();
whismanoid 0:93d4119d3f14 887 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 888 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 889 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 890 {
whismanoid 0:93d4119d3f14 891 PASS();
whismanoid 0:93d4119d3f14 892 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 893 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 894 associatedCmdLine.serial().printf("AIN3 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 895 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 896 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 897 );
whismanoid 0:93d4119d3f14 898 //
whismanoid 0:93d4119d3f14 899 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 900 return true;
whismanoid 0:93d4119d3f14 901 }
whismanoid 0:93d4119d3f14 902 else
whismanoid 0:93d4119d3f14 903 {
whismanoid 0:93d4119d3f14 904 FAIL();
whismanoid 0:93d4119d3f14 905 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 906 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 907 associatedCmdLine.serial().printf("AIN3 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 908 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 909 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 910 );
whismanoid 0:93d4119d3f14 911 //
whismanoid 0:93d4119d3f14 912 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 913 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 914 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 915 }
whismanoid 0:93d4119d3f14 916 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 917 return false;
whismanoid 0:93d4119d3f14 918 }
whismanoid 0:93d4119d3f14 919
whismanoid 0:93d4119d3f14 920 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 921 *
whismanoid 0:93d4119d3f14 922 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 923 *
whismanoid 0:93d4119d3f14 924 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 925 *
whismanoid 0:93d4119d3f14 926 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 927 *
whismanoid 0:93d4119d3f14 928 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 929 *
whismanoid 0:93d4119d3f14 930 */
whismanoid 0:93d4119d3f14 931 bool MaximTinyTester::AnalogIn4_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 932 {
whismanoid 0:93d4119d3f14 933 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[4];
whismanoid 2:9b20cadbfa15 934 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 935 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 936 {
whismanoid 2:9b20cadbfa15 937 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 938 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 939 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 940 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 941 }
whismanoid 0:93d4119d3f14 942
whismanoid 0:93d4119d3f14 943 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 944 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 945 float normValue_0_1 = analogInPin4.read();
whismanoid 0:93d4119d3f14 946 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 947 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 948 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 949 {
whismanoid 0:93d4119d3f14 950 PASS();
whismanoid 0:93d4119d3f14 951 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 952 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 953 associatedCmdLine.serial().printf("AIN4 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 954 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 955 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 956 );
whismanoid 0:93d4119d3f14 957 //
whismanoid 0:93d4119d3f14 958 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 959 return true;
whismanoid 0:93d4119d3f14 960 }
whismanoid 0:93d4119d3f14 961 else
whismanoid 0:93d4119d3f14 962 {
whismanoid 0:93d4119d3f14 963 FAIL();
whismanoid 0:93d4119d3f14 964 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 965 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 966 associatedCmdLine.serial().printf("AIN4 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 967 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 968 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 969 );
whismanoid 0:93d4119d3f14 970 //
whismanoid 0:93d4119d3f14 971 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 972 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 973 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 974 }
whismanoid 0:93d4119d3f14 975 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 976 return false;
whismanoid 0:93d4119d3f14 977 }
whismanoid 0:93d4119d3f14 978
whismanoid 0:93d4119d3f14 979 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 980 *
whismanoid 0:93d4119d3f14 981 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 982 *
whismanoid 0:93d4119d3f14 983 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 984 *
whismanoid 0:93d4119d3f14 985 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 986 *
whismanoid 0:93d4119d3f14 987 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 988 *
whismanoid 0:93d4119d3f14 989 */
whismanoid 0:93d4119d3f14 990 bool MaximTinyTester::AnalogIn5_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 991 {
whismanoid 0:93d4119d3f14 992 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[5];
whismanoid 2:9b20cadbfa15 993 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 994 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 995 {
whismanoid 2:9b20cadbfa15 996 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 997 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 998 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 999 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1000 }
whismanoid 0:93d4119d3f14 1001
whismanoid 0:93d4119d3f14 1002 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1003 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1004 float normValue_0_1 = analogInPin5.read();
whismanoid 0:93d4119d3f14 1005 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1006 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1007 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1008 {
whismanoid 0:93d4119d3f14 1009 PASS();
whismanoid 0:93d4119d3f14 1010 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1011 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1012 associatedCmdLine.serial().printf("AIN5 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1013 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1014 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1015 );
whismanoid 0:93d4119d3f14 1016 //
whismanoid 0:93d4119d3f14 1017 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1018 return true;
whismanoid 0:93d4119d3f14 1019 }
whismanoid 0:93d4119d3f14 1020 else
whismanoid 0:93d4119d3f14 1021 {
whismanoid 0:93d4119d3f14 1022 FAIL();
whismanoid 0:93d4119d3f14 1023 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1024 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1025 associatedCmdLine.serial().printf("AIN5 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1026 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1027 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1028 );
whismanoid 0:93d4119d3f14 1029 //
whismanoid 0:93d4119d3f14 1030 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1031 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1032 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1033 }
whismanoid 0:93d4119d3f14 1034 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1035 return false;
whismanoid 0:93d4119d3f14 1036 }
whismanoid 0:93d4119d3f14 1037
whismanoid 0:93d4119d3f14 1038 bool MaximTinyTester::AnalogIn_Read_Expect_voltageV(AnalogIn& analogInPin, double expect_result)
whismanoid 0:93d4119d3f14 1039 {
whismanoid 0:93d4119d3f14 1040 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[0];
whismanoid 2:9b20cadbfa15 1041 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1042 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1043 {
whismanoid 2:9b20cadbfa15 1044 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1045 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1046 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1047 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1048 }
whismanoid 0:93d4119d3f14 1049
whismanoid 0:93d4119d3f14 1050 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1051 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1052 float normValue_0_1 = analogInPin.read();
whismanoid 0:93d4119d3f14 1053 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1054 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1055 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1056 {
whismanoid 0:93d4119d3f14 1057 PASS();
whismanoid 0:93d4119d3f14 1058 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1059 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1060 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1061 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1062 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1063 );
whismanoid 0:93d4119d3f14 1064 //
whismanoid 0:93d4119d3f14 1065 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1066 return true;
whismanoid 0:93d4119d3f14 1067 }
whismanoid 0:93d4119d3f14 1068 else
whismanoid 0:93d4119d3f14 1069 {
whismanoid 0:93d4119d3f14 1070 FAIL();
whismanoid 0:93d4119d3f14 1071 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1072 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1073 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1074 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1075 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1076 );
whismanoid 0:93d4119d3f14 1077 //
whismanoid 0:93d4119d3f14 1078 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1079 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1080 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1081 }
whismanoid 0:93d4119d3f14 1082 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1083 return false;
whismanoid 0:93d4119d3f14 1084 }
whismanoid 0:93d4119d3f14 1085
whismanoid 0:93d4119d3f14 1086 bool MaximTinyTester::DigitalIn_Read_Expect_WarnOnly(DigitalIn& digitalInPin, const char* pinName, int expect_result, const char *expect_description)
whismanoid 0:93d4119d3f14 1087 {
whismanoid 0:93d4119d3f14 1088 int actual_UPO_value = -1;
whismanoid 0:93d4119d3f14 1089 for (int retry_count = 0; retry_count < 10; retry_count++) {
whismanoid 0:93d4119d3f14 1090 actual_UPO_value = digitalInPin.read(); // g_MAX5171_device.UPOinputValue();
whismanoid 0:93d4119d3f14 1091 if (actual_UPO_value == expect_result) {
whismanoid 0:93d4119d3f14 1092 PASS();
whismanoid 0:93d4119d3f14 1093 associatedCmdLine.serial().printf("%s signal=%d %s", pinName, expect_result, expect_description);
whismanoid 0:93d4119d3f14 1094 return true;
whismanoid 0:93d4119d3f14 1095 }
whismanoid 0:93d4119d3f14 1096 // UPO condition not met, retry for a while until give up
whismanoid 0:93d4119d3f14 1097 wait_ms(input_timeout_time_msec / 10); // delay
whismanoid 0:93d4119d3f14 1098 }
whismanoid 0:93d4119d3f14 1099 associatedCmdLine.serial().printf("\r\n!WARN "); // SelfTest_FAIL(cmdLine);
whismanoid 0:93d4119d3f14 1100 associatedCmdLine.serial().printf("expected %s signal=%d %s", pinName, expect_result, expect_description);
whismanoid 0:93d4119d3f14 1101 associatedCmdLine.serial().printf(", but got actual %s=%d", pinName, actual_UPO_value);
whismanoid 0:93d4119d3f14 1102 associatedCmdLine.serial().printf(", missing %s connections?", pinName);
whismanoid 0:93d4119d3f14 1103 return false;
whismanoid 0:93d4119d3f14 1104 }
whismanoid 0:93d4119d3f14 1105
whismanoid 0:93d4119d3f14 1106 void MaximTinyTester::Wait_Output_Settling()
whismanoid 0:93d4119d3f14 1107 {
whismanoid 0:93d4119d3f14 1108 wait_ms(settle_time_msec); // delay
whismanoid 0:93d4119d3f14 1109 }
whismanoid 0:93d4119d3f14 1110
whismanoid 0:93d4119d3f14 1111
whismanoid 0:93d4119d3f14 1112 // End of file