Mark Underwood / MaximTinyTester

minimalist hardware testing support

Dependents:   MAX5715BOB_Tester MAX11131BOB_Tester MAX5171BOB_Tester MAX11410BOB_Tester ... more

MaximTinyTester.cpp@7:5b40b6370f8a, 2020-03-09 (annotated)

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