Mark Underwood / MaximTinyTester

minimalist hardware testing support

Dependents:   MAX5715BOB_Tester MAX11131BOB_Tester MAX5171BOB_Tester MAX11410BOB_Tester ... more

MaximTinyTester.cpp@18:9874cd1e6cb0, 2021-06-08 (annotated)

Committer:
whismanoid
Date:
Tue Jun 08 04:00:15 2021 -0700
Revision:
18:9874cd1e6cb0
Parent:
17:65fb4afe4991 
MaximTinyTester AnalogIn5_Read_Report_voltageV() for MAX5719

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 17:65fb4afe4991 70 mask = 0; // 0=require all bits
whismanoid 0:93d4119d3f14 71 input_timeout_time_msec = 250;
whismanoid 0:93d4119d3f14 72 settle_time_msec = 250;
whismanoid 1:f98ddb04f9e0 73 blink_time_msec = 75;
whismanoid 0:93d4119d3f14 74 analogInPin_fullScaleVoltage[0] = 3.300;
whismanoid 0:93d4119d3f14 75 analogInPin_fullScaleVoltage[1] = 3.300;
whismanoid 0:93d4119d3f14 76 analogInPin_fullScaleVoltage[2] = 3.300;
whismanoid 0:93d4119d3f14 77 analogInPin_fullScaleVoltage[3] = 3.300;
whismanoid 0:93d4119d3f14 78 analogInPin_fullScaleVoltage[4] = 3.300;
whismanoid 0:93d4119d3f14 79 analogInPin_fullScaleVoltage[5] = 3.300;
whismanoid 0:93d4119d3f14 80 }
whismanoid 0:93d4119d3f14 81
whismanoid 0:93d4119d3f14 82 /** reset the pass/fail counters.
whismanoid 0:93d4119d3f14 83 *
whismanoid 0:93d4119d3f14 84 * @post nPass and nFail are reset to 0
whismanoid 0:93d4119d3f14 85 *
whismanoid 0:93d4119d3f14 86 */
whismanoid 0:93d4119d3f14 87 void MaximTinyTester::clear(void)
whismanoid 0:93d4119d3f14 88 {
whismanoid 0:93d4119d3f14 89 nPass = 0;
whismanoid 0:93d4119d3f14 90 nFail = 0;
whismanoid 3:080aa1bb1bc0 91 // PinName NC means NOT_CONNECTED; DigitalOut::is_connected() returns false
whismanoid 3:080aa1bb1bc0 92 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 93 m_RFailLED = LED_ON;
whismanoid 3:080aa1bb1bc0 94 }
whismanoid 3:080aa1bb1bc0 95 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 96 m_GPassLED = LED_ON;
whismanoid 3:080aa1bb1bc0 97 }
whismanoid 3:080aa1bb1bc0 98 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 99 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 100 }
whismanoid 17:65fb4afe4991 101 mask = 0; // reset mask (0=require all bits) after every FunctionCall_Expect
whismanoid 0:93d4119d3f14 102 }
whismanoid 0:93d4119d3f14 103
whismanoid 0:93d4119d3f14 104 /** report that a test has completed with success.
whismanoid 0:93d4119d3f14 105 *
whismanoid 0:93d4119d3f14 106 * @post nPass is increased by 1
whismanoid 0:93d4119d3f14 107 *
whismanoid 0:93d4119d3f14 108 */
whismanoid 0:93d4119d3f14 109 void MaximTinyTester::PASS()
whismanoid 0:93d4119d3f14 110 {
whismanoid 0:93d4119d3f14 111 ++nPass;
whismanoid 1:f98ddb04f9e0 112 // m_RFailLED = LED_ON; m_GPassLED = LED_ON; m_BBusyLED = LED_ON;
whismanoid 1:f98ddb04f9e0 113 // pulse blue LED during test to indicate activity
whismanoid 3:080aa1bb1bc0 114 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 115 m_GPassLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 116 }
whismanoid 3:080aa1bb1bc0 117 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 118 m_BBusyLED = LED_ON;
whismanoid 3:080aa1bb1bc0 119 }
whismanoid 1:f98ddb04f9e0 120 wait_ms(blink_time_msec); // delay
whismanoid 3:080aa1bb1bc0 121 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 122 m_GPassLED = LED_ON;
whismanoid 3:080aa1bb1bc0 123 }
whismanoid 3:080aa1bb1bc0 124 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 125 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 126 }
whismanoid 1:f98ddb04f9e0 127 wait_ms(blink_time_msec); // delay
whismanoid 0:93d4119d3f14 128 associatedCmdLine.serial().printf("\r\n+PASS ");
whismanoid 17:65fb4afe4991 129 mask = 0; // reset mask (0=require all bits) after every FunctionCall_Expect
whismanoid 0:93d4119d3f14 130 }
whismanoid 0:93d4119d3f14 131
whismanoid 0:93d4119d3f14 132 /** report that a test has completed with failure.
whismanoid 0:93d4119d3f14 133 *
whismanoid 0:93d4119d3f14 134 * @post nFail is increased by 1
whismanoid 0:93d4119d3f14 135 *
whismanoid 0:93d4119d3f14 136 */
whismanoid 0:93d4119d3f14 137 void MaximTinyTester::FAIL()
whismanoid 0:93d4119d3f14 138 {
whismanoid 0:93d4119d3f14 139 ++nFail;
whismanoid 1:f98ddb04f9e0 140 // m_RFailLED = LED_ON; m_GPassLED = LED_ON; m_BBusyLED = LED_ON;
whismanoid 1:f98ddb04f9e0 141 // pulse blue LED during test to indicate activity
whismanoid 3:080aa1bb1bc0 142 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 143 m_RFailLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 144 }
whismanoid 3:080aa1bb1bc0 145 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 146 m_BBusyLED = LED_ON;
whismanoid 3:080aa1bb1bc0 147 }
whismanoid 1:f98ddb04f9e0 148 wait_ms(blink_time_msec); // delay
whismanoid 3:080aa1bb1bc0 149 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 150 m_RFailLED = LED_ON;
whismanoid 3:080aa1bb1bc0 151 }
whismanoid 3:080aa1bb1bc0 152 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 153 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 154 }
whismanoid 1:f98ddb04f9e0 155 wait_ms(blink_time_msec); // delay
whismanoid 0:93d4119d3f14 156 associatedCmdLine.serial().printf("\r\n-FAIL ");
whismanoid 0:93d4119d3f14 157 #if USE_LEDS
whismanoid 0:93d4119d3f14 158 rgb_led.red(); // diagnostic rbg led RED
whismanoid 0:93d4119d3f14 159 //~ rgb_led.green(); // diagnostic rbg led GREEN
whismanoid 0:93d4119d3f14 160 //~ rgb_led.blue(); // diagnostic rbg led BLUE
whismanoid 0:93d4119d3f14 161 //~ rgb_led.white(); // diagnostic rbg led RED+GREEN+BLUE=WHITE
whismanoid 0:93d4119d3f14 162 //~ rgb_led.cyan(); // diagnostic rbg led GREEN+BLUE=CYAN
whismanoid 0:93d4119d3f14 163 //~ rgb_led.magenta(); // diagnostic rbg led RED+BLUE=MAGENTA
whismanoid 0:93d4119d3f14 164 //~ rgb_led.yellow(); // diagnostic rbg led RED+GREEN=YELLOW
whismanoid 0:93d4119d3f14 165 //~ rgb_led.black(); // diagnostic rbg led BLACK
whismanoid 0:93d4119d3f14 166 #endif // USE_LEDS
whismanoid 17:65fb4afe4991 167 mask = 0; // reset mask (0=require all bits) after every FunctionCall_Expect
whismanoid 0:93d4119d3f14 168 }
whismanoid 0:93d4119d3f14 169
whismanoid 9:3ec00515891d 170 /** Print a message to the console during test.
whismanoid 9:3ec00515891d 171 */
whismanoid 9:3ec00515891d 172 void MaximTinyTester::print(const char* stringLiteralMessage)
whismanoid 9:3ec00515891d 173 {
whismanoid 9:3ec00515891d 174 associatedCmdLine.serial().printf("\r\n %s", stringLiteralMessage);
whismanoid 9:3ec00515891d 175 }
whismanoid 9:3ec00515891d 176
whismanoid 0:93d4119d3f14 177 /** Report number of pass and number of fail test results
whismanoid 0:93d4119d3f14 178 */
whismanoid 0:93d4119d3f14 179 void MaximTinyTester::Report_Summary(void)
whismanoid 0:93d4119d3f14 180 {
whismanoid 0:93d4119d3f14 181 associatedCmdLine.serial().printf("\r\nSummary: %d PASS %d FAIL\r\n", nPass, nFail);
whismanoid 0:93d4119d3f14 182 //~ associatedCmdLine.serial().printf(g_SelfTest_nPass);
whismanoid 0:93d4119d3f14 183 //~ associatedCmdLine.serial().printf(" PASS ");
whismanoid 0:93d4119d3f14 184 //~ associatedCmdLine.serial().printf(g_SelfTest_nFail);
whismanoid 0:93d4119d3f14 185 //~ associatedCmdLine.serial().printf(" FAIL\r\n");
whismanoid 0:93d4119d3f14 186 if (nFail == 0) {
whismanoid 3:080aa1bb1bc0 187 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 188 m_RFailLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 189 }
whismanoid 3:080aa1bb1bc0 190 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 191 m_GPassLED = LED_ON;
whismanoid 3:080aa1bb1bc0 192 }
whismanoid 3:080aa1bb1bc0 193 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 194 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 195 }
whismanoid 1:f98ddb04f9e0 196 //~ rgb_led.green(); // diagnostic rbg led GREEN
whismanoid 1:f98ddb04f9e0 197 }
whismanoid 1:f98ddb04f9e0 198 else {
whismanoid 3:080aa1bb1bc0 199 if (m_RFailLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 200 m_RFailLED = LED_ON;
whismanoid 3:080aa1bb1bc0 201 }
whismanoid 3:080aa1bb1bc0 202 if (m_GPassLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 203 m_GPassLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 204 }
whismanoid 3:080aa1bb1bc0 205 if (m_BBusyLED.is_connected()) {
whismanoid 3:080aa1bb1bc0 206 m_BBusyLED = LED_OFF;
whismanoid 3:080aa1bb1bc0 207 }
whismanoid 0:93d4119d3f14 208 //~ rgb_led.red(); // diagnostic rbg led RED
whismanoid 0:93d4119d3f14 209 }
whismanoid 0:93d4119d3f14 210 }
whismanoid 0:93d4119d3f14 211
whismanoid 10:b11ab5d7ac58 212 bool MaximTinyTester::Expect(const char *nameOfTest, int actual_result, int expect_result)
whismanoid 10:b11ab5d7ac58 213 {
whismanoid 17:65fb4afe4991 214 if ((int)(actual_result & mask) != (int)(expect_result & mask)) // Expect (int)
whismanoid 10:b11ab5d7ac58 215 {
whismanoid 10:b11ab5d7ac58 216 FAIL();
whismanoid 10:b11ab5d7ac58 217 associatedCmdLine.serial().printf("%s", nameOfTest);
whismanoid 10:b11ab5d7ac58 218 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 10:b11ab5d7ac58 219 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 10:b11ab5d7ac58 220 return false;
whismanoid 10:b11ab5d7ac58 221 }
whismanoid 10:b11ab5d7ac58 222 else
whismanoid 10:b11ab5d7ac58 223 {
whismanoid 10:b11ab5d7ac58 224 PASS();
whismanoid 10:b11ab5d7ac58 225 associatedCmdLine.serial().printf("%s", nameOfTest);
whismanoid 10:b11ab5d7ac58 226 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 10:b11ab5d7ac58 227 return true;
whismanoid 10:b11ab5d7ac58 228 }
whismanoid 10:b11ab5d7ac58 229 }
whismanoid 10:b11ab5d7ac58 230
whismanoid 10:b11ab5d7ac58 231 bool MaximTinyTester::Expect(const char *nameOfTest, double actual_result, double expect_result)
whismanoid 10:b11ab5d7ac58 232 {
whismanoid 10:b11ab5d7ac58 233 double err_result = (actual_result - expect_result);
whismanoid 10:b11ab5d7ac58 234 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 10:b11ab5d7ac58 235 {
whismanoid 10:b11ab5d7ac58 236 PASS();
whismanoid 10:b11ab5d7ac58 237 associatedCmdLine.serial().printf("%s", nameOfTest);
whismanoid 10:b11ab5d7ac58 238 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 10:b11ab5d7ac58 239 return true;
whismanoid 10:b11ab5d7ac58 240 }
whismanoid 10:b11ab5d7ac58 241 else
whismanoid 10:b11ab5d7ac58 242 {
whismanoid 10:b11ab5d7ac58 243 FAIL();
whismanoid 10:b11ab5d7ac58 244 associatedCmdLine.serial().printf("%s", nameOfTest);
whismanoid 10:b11ab5d7ac58 245 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 10:b11ab5d7ac58 246 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 10:b11ab5d7ac58 247 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 10:b11ab5d7ac58 248 return false;
whismanoid 10:b11ab5d7ac58 249 }
whismanoid 10:b11ab5d7ac58 250 }
whismanoid 10:b11ab5d7ac58 251
whismanoid 0:93d4119d3f14 252 /** Test a software function
whismanoid 0:93d4119d3f14 253 *
whismanoid 0:93d4119d3f14 254 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 0:93d4119d3f14 255 *
whismanoid 0:93d4119d3f14 256 * @param[in] functionUnderTest points to the function under test
whismanoid 0:93d4119d3f14 257 *
whismanoid 8:9171f0ab3c17 258 * @param[in] arg_1_voltageV is a test argument given to the function under test
whismanoid 0:93d4119d3f14 259 *
whismanoid 0:93d4119d3f14 260 * @param[in] expect_result contains the expected result
whismanoid 0:93d4119d3f14 261 *
whismanoid 0:93d4119d3f14 262 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 263 *
whismanoid 0:93d4119d3f14 264 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 265 *
whismanoid 0:93d4119d3f14 266 */
whismanoid 12:55db0f4a417d 267 bool MaximTinyTester::FunctionCall_u_f_Expect(const char *nameOfFunctionUnderTest,
whismanoid 0:93d4119d3f14 268 Callback<uint16_t(double)> functionUnderTest,
whismanoid 8:9171f0ab3c17 269 double arg_1_voltageV,
whismanoid 8:9171f0ab3c17 270 uint16_t expect_result)
whismanoid 0:93d4119d3f14 271 {
whismanoid 8:9171f0ab3c17 272 uint16_t actual_result = functionUnderTest(arg_1_voltageV);
whismanoid 17:65fb4afe4991 273 if ((uint16_t)(actual_result & mask) != (uint16_t)(expect_result & mask)) // FunctionCall_u_f_Expect
whismanoid 0:93d4119d3f14 274 {
whismanoid 0:93d4119d3f14 275 FAIL();
whismanoid 8:9171f0ab3c17 276 associatedCmdLine.serial().printf("%s(%6.4fV)", nameOfFunctionUnderTest, arg_1_voltageV);
whismanoid 0:93d4119d3f14 277 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 0:93d4119d3f14 278 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 0:93d4119d3f14 279 return false;
whismanoid 0:93d4119d3f14 280 }
whismanoid 0:93d4119d3f14 281 else
whismanoid 0:93d4119d3f14 282 {
whismanoid 0:93d4119d3f14 283 PASS();
whismanoid 8:9171f0ab3c17 284 associatedCmdLine.serial().printf("%s(%6.4fV)", nameOfFunctionUnderTest, arg_1_voltageV);
whismanoid 0:93d4119d3f14 285 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 0:93d4119d3f14 286 return true;
whismanoid 0:93d4119d3f14 287 }
whismanoid 0:93d4119d3f14 288 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 289 }
whismanoid 0:93d4119d3f14 290
whismanoid 15:ac3e4930df8b 291
whismanoid 15:ac3e4930df8b 292 /** Test a software function
whismanoid 15:ac3e4930df8b 293 *
whismanoid 15:ac3e4930df8b 294 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 15:ac3e4930df8b 295 *
whismanoid 15:ac3e4930df8b 296 * @param[in] functionUnderTest points to the function under test
whismanoid 15:ac3e4930df8b 297 *
whismanoid 15:ac3e4930df8b 298 * @param[in] arg_1_voltageV is a test argument given to the function under test
whismanoid 15:ac3e4930df8b 299 *
whismanoid 15:ac3e4930df8b 300 * @param[in] expect_result contains the expected result
whismanoid 15:ac3e4930df8b 301 *
whismanoid 15:ac3e4930df8b 302 * @post nPass and nFail counters are updated
whismanoid 15:ac3e4930df8b 303 *
whismanoid 15:ac3e4930df8b 304 * @return true if success, false if test failed
whismanoid 15:ac3e4930df8b 305 *
whismanoid 15:ac3e4930df8b 306 */
whismanoid 15:ac3e4930df8b 307 // MaximTinyTester FunctionCall_lu_f_Expect support MAX5719
whismanoid 15:ac3e4930df8b 308 bool MaximTinyTester::FunctionCall_lu_f_Expect(const char *nameOfFunctionUnderTest,
whismanoid 15:ac3e4930df8b 309 Callback<uint32_t(double)> functionUnderTest,
whismanoid 15:ac3e4930df8b 310 double arg_1_voltageV,
whismanoid 15:ac3e4930df8b 311 uint32_t expect_result)
whismanoid 15:ac3e4930df8b 312 {
whismanoid 15:ac3e4930df8b 313 uint32_t actual_result = functionUnderTest(arg_1_voltageV);
whismanoid 17:65fb4afe4991 314 if ((uint32_t)(actual_result & mask) != (uint32_t)(expect_result & mask)) // FunctionCall_lu_f_Expect
whismanoid 15:ac3e4930df8b 315 {
whismanoid 15:ac3e4930df8b 316 FAIL();
whismanoid 16:bb4b003a5cd2 317 associatedCmdLine.serial().printf("%s(%6.6fV)", nameOfFunctionUnderTest, arg_1_voltageV);
whismanoid 15:ac3e4930df8b 318 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 15:ac3e4930df8b 319 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 15:ac3e4930df8b 320 return false;
whismanoid 15:ac3e4930df8b 321 }
whismanoid 15:ac3e4930df8b 322 else
whismanoid 15:ac3e4930df8b 323 {
whismanoid 15:ac3e4930df8b 324 PASS();
whismanoid 16:bb4b003a5cd2 325 associatedCmdLine.serial().printf("%s(%6.6fV)", nameOfFunctionUnderTest, arg_1_voltageV);
whismanoid 15:ac3e4930df8b 326 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 15:ac3e4930df8b 327 return true;
whismanoid 15:ac3e4930df8b 328 }
whismanoid 15:ac3e4930df8b 329 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 15:ac3e4930df8b 330 }
whismanoid 15:ac3e4930df8b 331
whismanoid 0:93d4119d3f14 332 /** Test a software function
whismanoid 0:93d4119d3f14 333 *
whismanoid 0:93d4119d3f14 334 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 0:93d4119d3f14 335 *
whismanoid 0:93d4119d3f14 336 * @param[in] functionUnderTest points to the function under test
whismanoid 0:93d4119d3f14 337 *
whismanoid 8:9171f0ab3c17 338 * @param[in] arg_1_u16 is a test argument given to the function under test
whismanoid 0:93d4119d3f14 339 *
whismanoid 0:93d4119d3f14 340 * @param[in] expect_result contains the expected result
whismanoid 0:93d4119d3f14 341 *
whismanoid 0:93d4119d3f14 342 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 343 *
whismanoid 0:93d4119d3f14 344 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 345 *
whismanoid 0:93d4119d3f14 346 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 347 *
whismanoid 0:93d4119d3f14 348 */
whismanoid 12:55db0f4a417d 349 bool MaximTinyTester::FunctionCall_f_d_Expect(const char *nameOfFunctionUnderTest,
whismanoid 10:b11ab5d7ac58 350 Callback<double(int)> functionUnderTest,
whismanoid 10:b11ab5d7ac58 351 int arg_1_u16,
whismanoid 8:9171f0ab3c17 352 double expect_result)
whismanoid 0:93d4119d3f14 353 {
whismanoid 8:9171f0ab3c17 354 double actual_result = functionUnderTest(arg_1_u16);
whismanoid 0:93d4119d3f14 355 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 356 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 357 {
whismanoid 0:93d4119d3f14 358 PASS();
whismanoid 8:9171f0ab3c17 359 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1_u16);
whismanoid 0:93d4119d3f14 360 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 0:93d4119d3f14 361 return true;
whismanoid 0:93d4119d3f14 362 }
whismanoid 0:93d4119d3f14 363 else
whismanoid 0:93d4119d3f14 364 {
whismanoid 0:93d4119d3f14 365 FAIL();
whismanoid 8:9171f0ab3c17 366 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1_u16);
whismanoid 0:93d4119d3f14 367 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 0:93d4119d3f14 368 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 369 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 370 return false;
whismanoid 0:93d4119d3f14 371 }
whismanoid 0:93d4119d3f14 372 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 373 }
whismanoid 0:93d4119d3f14 374
whismanoid 5:67a1cd5a67cc 375 /** Test a software function
whismanoid 5:67a1cd5a67cc 376 *
whismanoid 5:67a1cd5a67cc 377 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 5:67a1cd5a67cc 378 *
whismanoid 5:67a1cd5a67cc 379 * @param[in] functionUnderTest points to the function under test
whismanoid 5:67a1cd5a67cc 380 *
whismanoid 12:55db0f4a417d 381 * @param[in] arg_1_int is a test argument given to the function under test
whismanoid 12:55db0f4a417d 382 * @param[in] arg_2_int is a test argument given to the function under test
whismanoid 12:55db0f4a417d 383 *
whismanoid 12:55db0f4a417d 384 * @param[in] expect_result contains the expected result
whismanoid 12:55db0f4a417d 385 *
whismanoid 12:55db0f4a417d 386 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 12:55db0f4a417d 387 *
whismanoid 12:55db0f4a417d 388 * @post nPass and nFail counters are updated
whismanoid 12:55db0f4a417d 389 *
whismanoid 12:55db0f4a417d 390 * @return true if success, false if test failed
whismanoid 12:55db0f4a417d 391 *
whismanoid 12:55db0f4a417d 392 */
whismanoid 12:55db0f4a417d 393 bool MaximTinyTester::FunctionCall_f_d_d_Expect(const char *nameOfFunctionUnderTest,
whismanoid 12:55db0f4a417d 394 Callback<double(int, int)> functionUnderTest,
whismanoid 12:55db0f4a417d 395 int arg_1_int,
whismanoid 12:55db0f4a417d 396 int arg_2_int,
whismanoid 12:55db0f4a417d 397 double expect_result)
whismanoid 12:55db0f4a417d 398 {
whismanoid 12:55db0f4a417d 399 double actual_result = functionUnderTest(arg_1_int, arg_2_int);
whismanoid 12:55db0f4a417d 400 double err_result = (actual_result - expect_result);
whismanoid 12:55db0f4a417d 401 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 12:55db0f4a417d 402 {
whismanoid 12:55db0f4a417d 403 PASS();
whismanoid 12:55db0f4a417d 404 associatedCmdLine.serial().printf("%s(%d,%d)", nameOfFunctionUnderTest, arg_1_int, arg_2_int);
whismanoid 12:55db0f4a417d 405 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 12:55db0f4a417d 406 return true;
whismanoid 12:55db0f4a417d 407 }
whismanoid 12:55db0f4a417d 408 else
whismanoid 12:55db0f4a417d 409 {
whismanoid 12:55db0f4a417d 410 FAIL();
whismanoid 12:55db0f4a417d 411 associatedCmdLine.serial().printf("%s(%d,%d)", nameOfFunctionUnderTest, arg_1_int, arg_2_int);
whismanoid 12:55db0f4a417d 412 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 12:55db0f4a417d 413 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 12:55db0f4a417d 414 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 12:55db0f4a417d 415 return false;
whismanoid 12:55db0f4a417d 416 }
whismanoid 12:55db0f4a417d 417 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 12:55db0f4a417d 418 }
whismanoid 12:55db0f4a417d 419
whismanoid 12:55db0f4a417d 420 /** Test a software function
whismanoid 12:55db0f4a417d 421 *
whismanoid 12:55db0f4a417d 422 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 12:55db0f4a417d 423 *
whismanoid 12:55db0f4a417d 424 * @param[in] functionUnderTest points to the function under test
whismanoid 12:55db0f4a417d 425 *
whismanoid 8:9171f0ab3c17 426 * @param[in] arg_1_u32 is a test argument given to the function under test
whismanoid 5:67a1cd5a67cc 427 *
whismanoid 5:67a1cd5a67cc 428 * @param[in] expect_result contains the expected result
whismanoid 5:67a1cd5a67cc 429 *
whismanoid 5:67a1cd5a67cc 430 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 5:67a1cd5a67cc 431 *
whismanoid 5:67a1cd5a67cc 432 * @post nPass and nFail counters are updated
whismanoid 5:67a1cd5a67cc 433 *
whismanoid 5:67a1cd5a67cc 434 * @return true if success, false if test failed
whismanoid 5:67a1cd5a67cc 435 *
whismanoid 5:67a1cd5a67cc 436 */
whismanoid 14:10219b869ac3 437 bool MaximTinyTester::FunctionCall_f_u_Expect(const char *nameOfFunctionUnderTest,
whismanoid 14:10219b869ac3 438 Callback<double(uint16_t)> functionUnderTest,
whismanoid 14:10219b869ac3 439 uint16_t arg_1_u16,
whismanoid 14:10219b869ac3 440 double expect_result)
whismanoid 14:10219b869ac3 441 {
whismanoid 14:10219b869ac3 442 double actual_result = functionUnderTest(arg_1_u16);
whismanoid 14:10219b869ac3 443 double err_result = (actual_result - expect_result);
whismanoid 14:10219b869ac3 444 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 14:10219b869ac3 445 {
whismanoid 14:10219b869ac3 446 PASS();
whismanoid 14:10219b869ac3 447 associatedCmdLine.serial().printf("%s(0x%x)", nameOfFunctionUnderTest, arg_1_u16);
whismanoid 14:10219b869ac3 448 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 14:10219b869ac3 449 return true;
whismanoid 14:10219b869ac3 450 }
whismanoid 14:10219b869ac3 451 else
whismanoid 14:10219b869ac3 452 {
whismanoid 14:10219b869ac3 453 FAIL();
whismanoid 14:10219b869ac3 454 associatedCmdLine.serial().printf("%s(0x%x)", nameOfFunctionUnderTest, arg_1_u16);
whismanoid 14:10219b869ac3 455 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 14:10219b869ac3 456 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 14:10219b869ac3 457 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 14:10219b869ac3 458 return false;
whismanoid 14:10219b869ac3 459 }
whismanoid 14:10219b869ac3 460 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 14:10219b869ac3 461 }
whismanoid 14:10219b869ac3 462
whismanoid 14:10219b869ac3 463 /** Test a software function
whismanoid 14:10219b869ac3 464 *
whismanoid 14:10219b869ac3 465 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 14:10219b869ac3 466 *
whismanoid 14:10219b869ac3 467 * @param[in] functionUnderTest points to the function under test
whismanoid 14:10219b869ac3 468 *
whismanoid 14:10219b869ac3 469 * @param[in] arg_1_u32 is a test argument given to the function under test
whismanoid 14:10219b869ac3 470 *
whismanoid 14:10219b869ac3 471 * @param[in] expect_result contains the expected result
whismanoid 14:10219b869ac3 472 *
whismanoid 14:10219b869ac3 473 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 14:10219b869ac3 474 *
whismanoid 14:10219b869ac3 475 * @post nPass and nFail counters are updated
whismanoid 14:10219b869ac3 476 *
whismanoid 14:10219b869ac3 477 * @return true if success, false if test failed
whismanoid 14:10219b869ac3 478 *
whismanoid 14:10219b869ac3 479 */
whismanoid 12:55db0f4a417d 480 bool MaximTinyTester::FunctionCall_f_lu_Expect(const char *nameOfFunctionUnderTest,
whismanoid 5:67a1cd5a67cc 481 Callback<double(uint32_t)> functionUnderTest,
whismanoid 8:9171f0ab3c17 482 uint32_t arg_1_u32,
whismanoid 8:9171f0ab3c17 483 double expect_result)
whismanoid 5:67a1cd5a67cc 484 {
whismanoid 8:9171f0ab3c17 485 double actual_result = functionUnderTest(arg_1_u32);
whismanoid 5:67a1cd5a67cc 486 double err_result = (actual_result - expect_result);
whismanoid 5:67a1cd5a67cc 487 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 5:67a1cd5a67cc 488 {
whismanoid 5:67a1cd5a67cc 489 PASS();
whismanoid 8:9171f0ab3c17 490 associatedCmdLine.serial().printf("%s(0x%lx)", nameOfFunctionUnderTest, arg_1_u32);
whismanoid 5:67a1cd5a67cc 491 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 492 return true;
whismanoid 5:67a1cd5a67cc 493 }
whismanoid 5:67a1cd5a67cc 494 else
whismanoid 5:67a1cd5a67cc 495 {
whismanoid 5:67a1cd5a67cc 496 FAIL();
whismanoid 8:9171f0ab3c17 497 associatedCmdLine.serial().printf("%s(0x%lx)", nameOfFunctionUnderTest, arg_1_u32);
whismanoid 5:67a1cd5a67cc 498 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 499 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 5:67a1cd5a67cc 500 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 5:67a1cd5a67cc 501 return false;
whismanoid 5:67a1cd5a67cc 502 }
whismanoid 5:67a1cd5a67cc 503 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 5:67a1cd5a67cc 504 }
whismanoid 5:67a1cd5a67cc 505
whismanoid 5:67a1cd5a67cc 506 /** Test a software function
whismanoid 5:67a1cd5a67cc 507 *
whismanoid 5:67a1cd5a67cc 508 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 5:67a1cd5a67cc 509 *
whismanoid 5:67a1cd5a67cc 510 * @param[in] functionUnderTest points to the function under test
whismanoid 5:67a1cd5a67cc 511 *
whismanoid 8:9171f0ab3c17 512 * @param[in] arg_1_d is a test argument given to the function under test
whismanoid 5:67a1cd5a67cc 513 *
whismanoid 5:67a1cd5a67cc 514 * @param[in] expect_result contains the expected result
whismanoid 5:67a1cd5a67cc 515 *
whismanoid 5:67a1cd5a67cc 516 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 5:67a1cd5a67cc 517 *
whismanoid 5:67a1cd5a67cc 518 * @post nPass and nFail counters are updated
whismanoid 5:67a1cd5a67cc 519 *
whismanoid 5:67a1cd5a67cc 520 * @return true if success, false if test failed
whismanoid 5:67a1cd5a67cc 521 *
whismanoid 5:67a1cd5a67cc 522 */
whismanoid 12:55db0f4a417d 523 bool MaximTinyTester::FunctionCall_f_f_Expect(const char *nameOfFunctionUnderTest,
whismanoid 5:67a1cd5a67cc 524 Callback<double(double)> functionUnderTest,
whismanoid 8:9171f0ab3c17 525 double arg_1_d,
whismanoid 8:9171f0ab3c17 526 double expect_result)
whismanoid 5:67a1cd5a67cc 527 {
whismanoid 8:9171f0ab3c17 528 double actual_result = functionUnderTest(arg_1_d);
whismanoid 5:67a1cd5a67cc 529 double err_result = (actual_result - expect_result);
whismanoid 5:67a1cd5a67cc 530 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 5:67a1cd5a67cc 531 {
whismanoid 5:67a1cd5a67cc 532 PASS();
whismanoid 8:9171f0ab3c17 533 associatedCmdLine.serial().printf("%s(%6.6f)", nameOfFunctionUnderTest, arg_1_d);
whismanoid 5:67a1cd5a67cc 534 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 535 return true;
whismanoid 5:67a1cd5a67cc 536 }
whismanoid 5:67a1cd5a67cc 537 else
whismanoid 5:67a1cd5a67cc 538 {
whismanoid 5:67a1cd5a67cc 539 FAIL();
whismanoid 8:9171f0ab3c17 540 associatedCmdLine.serial().printf("%s(%6.6f)", nameOfFunctionUnderTest, arg_1_d);
whismanoid 5:67a1cd5a67cc 541 associatedCmdLine.serial().printf(" expect %6.6f", expect_result);
whismanoid 5:67a1cd5a67cc 542 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 5:67a1cd5a67cc 543 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 5:67a1cd5a67cc 544 return false;
whismanoid 5:67a1cd5a67cc 545 }
whismanoid 5:67a1cd5a67cc 546 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 5:67a1cd5a67cc 547 }
whismanoid 5:67a1cd5a67cc 548
whismanoid 7:5b40b6370f8a 549 /** Test a software function
whismanoid 7:5b40b6370f8a 550 *
whismanoid 7:5b40b6370f8a 551 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 552 *
whismanoid 7:5b40b6370f8a 553 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 554 *
whismanoid 8:9171f0ab3c17 555 * @param[in] expect_result contains the expected result
whismanoid 8:9171f0ab3c17 556 *
whismanoid 8:9171f0ab3c17 557 * @post nPass and nFail counters are updated
whismanoid 8:9171f0ab3c17 558 *
whismanoid 8:9171f0ab3c17 559 * @return true if success, false if test failed
whismanoid 8:9171f0ab3c17 560 *
whismanoid 8:9171f0ab3c17 561 */
whismanoid 16:bb4b003a5cd2 562 bool MaximTinyTester::FunctionCall_d_Expect(const char *nameOfFunctionUnderTest,
whismanoid 16:bb4b003a5cd2 563 Callback<int()> functionUnderTest,
whismanoid 16:bb4b003a5cd2 564 int expect_result)
whismanoid 16:bb4b003a5cd2 565 {
whismanoid 16:bb4b003a5cd2 566 int actual_result = functionUnderTest();
whismanoid 17:65fb4afe4991 567 if ((int)(actual_result & mask) != (int)(expect_result & mask)) // FunctionCall_d_Expect
whismanoid 17:65fb4afe4991 568 {
whismanoid 17:65fb4afe4991 569 FAIL();
whismanoid 17:65fb4afe4991 570 associatedCmdLine.serial().printf("%s()", nameOfFunctionUnderTest);
whismanoid 17:65fb4afe4991 571 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 17:65fb4afe4991 572 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 17:65fb4afe4991 573 return false;
whismanoid 17:65fb4afe4991 574 }
whismanoid 17:65fb4afe4991 575 else
whismanoid 17:65fb4afe4991 576 {
whismanoid 17:65fb4afe4991 577 PASS();
whismanoid 17:65fb4afe4991 578 associatedCmdLine.serial().printf("%s()", nameOfFunctionUnderTest);
whismanoid 17:65fb4afe4991 579 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 17:65fb4afe4991 580 return true;
whismanoid 17:65fb4afe4991 581 }
whismanoid 17:65fb4afe4991 582 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 17:65fb4afe4991 583 }
whismanoid 17:65fb4afe4991 584
whismanoid 17:65fb4afe4991 585 /** Test a software function
whismanoid 17:65fb4afe4991 586 *
whismanoid 17:65fb4afe4991 587 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 17:65fb4afe4991 588 *
whismanoid 17:65fb4afe4991 589 * @param[in] functionUnderTest points to the function under test
whismanoid 17:65fb4afe4991 590 *
whismanoid 17:65fb4afe4991 591 * @param[in] expect_result contains the expected result
whismanoid 17:65fb4afe4991 592 *
whismanoid 17:65fb4afe4991 593 * @post nPass and nFail counters are updated
whismanoid 17:65fb4afe4991 594 *
whismanoid 17:65fb4afe4991 595 * @return true if success, false if test failed
whismanoid 17:65fb4afe4991 596 *
whismanoid 17:65fb4afe4991 597 */
whismanoid 17:65fb4afe4991 598 bool MaximTinyTester::FunctionCall_md_Expect(const char *nameOfFunctionUnderTest,
whismanoid 17:65fb4afe4991 599 Callback<int16_t()> functionUnderTest,
whismanoid 17:65fb4afe4991 600 int16_t expect_result)
whismanoid 17:65fb4afe4991 601 {
whismanoid 17:65fb4afe4991 602 int16_t actual_result = functionUnderTest();
whismanoid 17:65fb4afe4991 603 if ((int16_t)(actual_result & mask) != (int16_t)(expect_result & mask)) // FunctionCall_md_Expect
whismanoid 16:bb4b003a5cd2 604 {
whismanoid 16:bb4b003a5cd2 605 FAIL();
whismanoid 16:bb4b003a5cd2 606 associatedCmdLine.serial().printf("%s()", nameOfFunctionUnderTest);
whismanoid 16:bb4b003a5cd2 607 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 16:bb4b003a5cd2 608 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 16:bb4b003a5cd2 609 return false;
whismanoid 16:bb4b003a5cd2 610 }
whismanoid 16:bb4b003a5cd2 611 else
whismanoid 16:bb4b003a5cd2 612 {
whismanoid 16:bb4b003a5cd2 613 PASS();
whismanoid 16:bb4b003a5cd2 614 associatedCmdLine.serial().printf("%s()", nameOfFunctionUnderTest);
whismanoid 16:bb4b003a5cd2 615 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 16:bb4b003a5cd2 616 return true;
whismanoid 16:bb4b003a5cd2 617 }
whismanoid 16:bb4b003a5cd2 618 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 16:bb4b003a5cd2 619 }
whismanoid 16:bb4b003a5cd2 620
whismanoid 16:bb4b003a5cd2 621 /** Test a software function
whismanoid 16:bb4b003a5cd2 622 *
whismanoid 16:bb4b003a5cd2 623 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 16:bb4b003a5cd2 624 *
whismanoid 16:bb4b003a5cd2 625 * @param[in] functionUnderTest points to the function under test
whismanoid 16:bb4b003a5cd2 626 *
whismanoid 16:bb4b003a5cd2 627 * @param[in] expect_result contains the expected result
whismanoid 16:bb4b003a5cd2 628 *
whismanoid 16:bb4b003a5cd2 629 * @post nPass and nFail counters are updated
whismanoid 16:bb4b003a5cd2 630 *
whismanoid 16:bb4b003a5cd2 631 * @return true if success, false if test failed
whismanoid 16:bb4b003a5cd2 632 *
whismanoid 16:bb4b003a5cd2 633 */
whismanoid 12:55db0f4a417d 634 bool MaximTinyTester::FunctionCall_su_Expect(const char *nameOfFunctionUnderTest,
whismanoid 8:9171f0ab3c17 635 Callback<uint8_t()> functionUnderTest,
whismanoid 8:9171f0ab3c17 636 uint8_t expect_result)
whismanoid 8:9171f0ab3c17 637 {
whismanoid 8:9171f0ab3c17 638 uint8_t actual_result = functionUnderTest();
whismanoid 17:65fb4afe4991 639 if ((uint8_t)(actual_result & mask) != (uint8_t)(expect_result & mask)) // FunctionCall_su_Expect
whismanoid 8:9171f0ab3c17 640 {
whismanoid 8:9171f0ab3c17 641 FAIL();
whismanoid 8:9171f0ab3c17 642 associatedCmdLine.serial().printf("%s()", nameOfFunctionUnderTest);
whismanoid 8:9171f0ab3c17 643 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 8:9171f0ab3c17 644 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 8:9171f0ab3c17 645 return false;
whismanoid 8:9171f0ab3c17 646 }
whismanoid 8:9171f0ab3c17 647 else
whismanoid 8:9171f0ab3c17 648 {
whismanoid 8:9171f0ab3c17 649 PASS();
whismanoid 8:9171f0ab3c17 650 associatedCmdLine.serial().printf("%s()", nameOfFunctionUnderTest);
whismanoid 8:9171f0ab3c17 651 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 8:9171f0ab3c17 652 return true;
whismanoid 8:9171f0ab3c17 653 }
whismanoid 8:9171f0ab3c17 654 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 8:9171f0ab3c17 655 }
whismanoid 8:9171f0ab3c17 656
whismanoid 8:9171f0ab3c17 657 /** Test a software function
whismanoid 8:9171f0ab3c17 658 *
whismanoid 8:9171f0ab3c17 659 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 8:9171f0ab3c17 660 *
whismanoid 8:9171f0ab3c17 661 * @param[in] functionUnderTest points to the function under test
whismanoid 8:9171f0ab3c17 662 *
whismanoid 7:5b40b6370f8a 663 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 664 *
whismanoid 7:5b40b6370f8a 665 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 666 *
whismanoid 7:5b40b6370f8a 667 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 668 *
whismanoid 7:5b40b6370f8a 669 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 670 *
whismanoid 7:5b40b6370f8a 671 */
whismanoid 12:55db0f4a417d 672 bool MaximTinyTester::FunctionCall_su_su_Expect(const char *nameOfFunctionUnderTest,
whismanoid 12:55db0f4a417d 673 Callback<uint8_t(uint8_t)> functionUnderTest,
whismanoid 12:55db0f4a417d 674 uint8_t arg_1,
whismanoid 12:55db0f4a417d 675 uint8_t expect_result)
whismanoid 12:55db0f4a417d 676 {
whismanoid 12:55db0f4a417d 677 uint8_t actual_result = functionUnderTest(arg_1);
whismanoid 17:65fb4afe4991 678 if ((uint8_t)(actual_result & mask) != (uint8_t)(expect_result & mask)) // FunctionCall_su_su_Expect
whismanoid 12:55db0f4a417d 679 {
whismanoid 12:55db0f4a417d 680 FAIL();
whismanoid 12:55db0f4a417d 681 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1);
whismanoid 12:55db0f4a417d 682 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 12:55db0f4a417d 683 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 12:55db0f4a417d 684 return false;
whismanoid 12:55db0f4a417d 685 }
whismanoid 12:55db0f4a417d 686 else
whismanoid 12:55db0f4a417d 687 {
whismanoid 12:55db0f4a417d 688 PASS();
whismanoid 12:55db0f4a417d 689 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1);
whismanoid 12:55db0f4a417d 690 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 12:55db0f4a417d 691 return true;
whismanoid 12:55db0f4a417d 692 }
whismanoid 12:55db0f4a417d 693 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 12:55db0f4a417d 694 }
whismanoid 12:55db0f4a417d 695
whismanoid 12:55db0f4a417d 696 /** Test a software function
whismanoid 12:55db0f4a417d 697 *
whismanoid 12:55db0f4a417d 698 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 12:55db0f4a417d 699 *
whismanoid 12:55db0f4a417d 700 * @param[in] functionUnderTest points to the function under test
whismanoid 12:55db0f4a417d 701 *
whismanoid 12:55db0f4a417d 702 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 12:55db0f4a417d 703 *
whismanoid 12:55db0f4a417d 704 * @param[in] expect_result contains the expected result
whismanoid 12:55db0f4a417d 705 *
whismanoid 12:55db0f4a417d 706 * @post nPass and nFail counters are updated
whismanoid 12:55db0f4a417d 707 *
whismanoid 12:55db0f4a417d 708 * @return true if success, false if test failed
whismanoid 12:55db0f4a417d 709 *
whismanoid 12:55db0f4a417d 710 */
whismanoid 12:55db0f4a417d 711 bool MaximTinyTester::FunctionCall_su_d_Expect(const char *nameOfFunctionUnderTest,
whismanoid 10:b11ab5d7ac58 712 Callback<uint8_t(int)> functionUnderTest,
whismanoid 10:b11ab5d7ac58 713 int arg_1,
whismanoid 7:5b40b6370f8a 714 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 715 {
whismanoid 7:5b40b6370f8a 716 uint8_t actual_result = functionUnderTest(arg_1);
whismanoid 17:65fb4afe4991 717 if ((uint8_t)(actual_result & mask) != (uint8_t)(expect_result & mask)) // FunctionCall_su_d_Expect
whismanoid 7:5b40b6370f8a 718 {
whismanoid 7:5b40b6370f8a 719 FAIL();
whismanoid 7:5b40b6370f8a 720 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1);
whismanoid 7:5b40b6370f8a 721 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 722 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 723 return false;
whismanoid 7:5b40b6370f8a 724 }
whismanoid 7:5b40b6370f8a 725 else
whismanoid 7:5b40b6370f8a 726 {
whismanoid 7:5b40b6370f8a 727 PASS();
whismanoid 7:5b40b6370f8a 728 associatedCmdLine.serial().printf("%s(%d)", nameOfFunctionUnderTest, arg_1);
whismanoid 7:5b40b6370f8a 729 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 730 return true;
whismanoid 7:5b40b6370f8a 731 }
whismanoid 7:5b40b6370f8a 732 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 733 }
whismanoid 7:5b40b6370f8a 734
whismanoid 7:5b40b6370f8a 735 /** Test a software function
whismanoid 7:5b40b6370f8a 736 *
whismanoid 7:5b40b6370f8a 737 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 738 *
whismanoid 7:5b40b6370f8a 739 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 740 *
whismanoid 7:5b40b6370f8a 741 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 742 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 743 *
whismanoid 7:5b40b6370f8a 744 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 745 *
whismanoid 7:5b40b6370f8a 746 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 747 *
whismanoid 7:5b40b6370f8a 748 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 749 *
whismanoid 7:5b40b6370f8a 750 */
whismanoid 12:55db0f4a417d 751 bool MaximTinyTester::FunctionCall_su_su_su_Expect(const char *nameOfFunctionUnderTest,
whismanoid 12:55db0f4a417d 752 Callback<uint8_t(uint8_t, uint8_t)> functionUnderTest,
whismanoid 12:55db0f4a417d 753 uint8_t arg_1,
whismanoid 12:55db0f4a417d 754 uint8_t arg_2,
whismanoid 12:55db0f4a417d 755 uint8_t expect_result)
whismanoid 12:55db0f4a417d 756 {
whismanoid 12:55db0f4a417d 757 uint8_t actual_result = functionUnderTest(arg_1, arg_2);
whismanoid 17:65fb4afe4991 758 if ((uint8_t)(actual_result & mask) != (uint8_t)(expect_result & mask)) // FunctionCall_su_su_su_Expect
whismanoid 12:55db0f4a417d 759 {
whismanoid 12:55db0f4a417d 760 FAIL();
whismanoid 12:55db0f4a417d 761 associatedCmdLine.serial().printf("%s(%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2);
whismanoid 12:55db0f4a417d 762 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 12:55db0f4a417d 763 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 12:55db0f4a417d 764 return false;
whismanoid 12:55db0f4a417d 765 }
whismanoid 12:55db0f4a417d 766 else
whismanoid 12:55db0f4a417d 767 {
whismanoid 12:55db0f4a417d 768 PASS();
whismanoid 12:55db0f4a417d 769 associatedCmdLine.serial().printf("%s(%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2);
whismanoid 12:55db0f4a417d 770 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 12:55db0f4a417d 771 return true;
whismanoid 12:55db0f4a417d 772 }
whismanoid 12:55db0f4a417d 773 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 12:55db0f4a417d 774 }
whismanoid 12:55db0f4a417d 775
whismanoid 12:55db0f4a417d 776 /** Test a software function
whismanoid 12:55db0f4a417d 777 *
whismanoid 12:55db0f4a417d 778 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 12:55db0f4a417d 779 *
whismanoid 12:55db0f4a417d 780 * @param[in] functionUnderTest points to the function under test
whismanoid 12:55db0f4a417d 781 *
whismanoid 12:55db0f4a417d 782 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 12:55db0f4a417d 783 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 12:55db0f4a417d 784 *
whismanoid 12:55db0f4a417d 785 * @param[in] expect_result contains the expected result
whismanoid 12:55db0f4a417d 786 *
whismanoid 12:55db0f4a417d 787 * @post nPass and nFail counters are updated
whismanoid 12:55db0f4a417d 788 *
whismanoid 12:55db0f4a417d 789 * @return true if success, false if test failed
whismanoid 12:55db0f4a417d 790 *
whismanoid 12:55db0f4a417d 791 */
whismanoid 12:55db0f4a417d 792 bool MaximTinyTester::FunctionCall_su_d_d_Expect(const char *nameOfFunctionUnderTest,
whismanoid 10:b11ab5d7ac58 793 Callback<uint8_t(int, int)> functionUnderTest,
whismanoid 10:b11ab5d7ac58 794 int arg_1,
whismanoid 10:b11ab5d7ac58 795 int arg_2,
whismanoid 7:5b40b6370f8a 796 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 797 {
whismanoid 7:5b40b6370f8a 798 uint8_t actual_result = functionUnderTest(arg_1, arg_2);
whismanoid 17:65fb4afe4991 799 if ((uint8_t)(actual_result & mask) != (uint8_t)(expect_result & mask)) // FunctionCall_su_d_d_Expect
whismanoid 7:5b40b6370f8a 800 {
whismanoid 7:5b40b6370f8a 801 FAIL();
whismanoid 7:5b40b6370f8a 802 associatedCmdLine.serial().printf("%s(%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2);
whismanoid 7:5b40b6370f8a 803 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 804 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 805 return false;
whismanoid 7:5b40b6370f8a 806 }
whismanoid 7:5b40b6370f8a 807 else
whismanoid 7:5b40b6370f8a 808 {
whismanoid 7:5b40b6370f8a 809 PASS();
whismanoid 7:5b40b6370f8a 810 associatedCmdLine.serial().printf("%s(%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2);
whismanoid 7:5b40b6370f8a 811 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 812 return true;
whismanoid 7:5b40b6370f8a 813 }
whismanoid 7:5b40b6370f8a 814 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 815 }
whismanoid 7:5b40b6370f8a 816
whismanoid 12:55db0f4a417d 817 /** Test a software function
whismanoid 12:55db0f4a417d 818 *
whismanoid 12:55db0f4a417d 819 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 12:55db0f4a417d 820 *
whismanoid 12:55db0f4a417d 821 * @param[in] functionUnderTest points to the function under test
whismanoid 12:55db0f4a417d 822 *
whismanoid 12:55db0f4a417d 823 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 12:55db0f4a417d 824 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 12:55db0f4a417d 825 *
whismanoid 12:55db0f4a417d 826 * @param[in] expect_result contains the expected result
whismanoid 12:55db0f4a417d 827 *
whismanoid 12:55db0f4a417d 828 * @post nPass and nFail counters are updated
whismanoid 12:55db0f4a417d 829 *
whismanoid 12:55db0f4a417d 830 * @return true if success, false if test failed
whismanoid 12:55db0f4a417d 831 *
whismanoid 12:55db0f4a417d 832 */
whismanoid 12:55db0f4a417d 833 bool MaximTinyTester::FunctionCall_su_d_lu_Expect(const char *nameOfFunctionUnderTest,
whismanoid 12:55db0f4a417d 834 Callback<uint8_t(int, uint32_t)> functionUnderTest,
whismanoid 12:55db0f4a417d 835 int arg_1,
whismanoid 12:55db0f4a417d 836 uint32_t arg_2,
whismanoid 12:55db0f4a417d 837 uint8_t expect_result)
whismanoid 12:55db0f4a417d 838 {
whismanoid 12:55db0f4a417d 839 uint8_t actual_result = functionUnderTest(arg_1, arg_2);
whismanoid 17:65fb4afe4991 840 if ((uint8_t)(actual_result & mask) != (uint8_t)(expect_result & mask)) // FunctionCall_su_d_lu_Expect
whismanoid 12:55db0f4a417d 841 {
whismanoid 12:55db0f4a417d 842 FAIL();
whismanoid 13:c294236d7465 843 associatedCmdLine.serial().printf("%s(%d,%ld)", nameOfFunctionUnderTest, arg_1, arg_2);
whismanoid 12:55db0f4a417d 844 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 12:55db0f4a417d 845 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 12:55db0f4a417d 846 return false;
whismanoid 12:55db0f4a417d 847 }
whismanoid 12:55db0f4a417d 848 else
whismanoid 12:55db0f4a417d 849 {
whismanoid 12:55db0f4a417d 850 PASS();
whismanoid 13:c294236d7465 851 associatedCmdLine.serial().printf("%s(%d,%ld)", nameOfFunctionUnderTest, arg_1, arg_2);
whismanoid 12:55db0f4a417d 852 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 12:55db0f4a417d 853 return true;
whismanoid 12:55db0f4a417d 854 }
whismanoid 12:55db0f4a417d 855 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 12:55db0f4a417d 856 }
whismanoid 12:55db0f4a417d 857
whismanoid 12:55db0f4a417d 858 bool MaximTinyTester::FunctionCall_su_d_plu_Expect(const char *nameOfFunctionUnderTest,
whismanoid 10:b11ab5d7ac58 859 Callback<uint8_t(int, uint32_t*)> functionUnderTest,
whismanoid 10:b11ab5d7ac58 860 int arg_1,
whismanoid 10:b11ab5d7ac58 861 uint32_t* arg_2,
whismanoid 10:b11ab5d7ac58 862 uint8_t expect_result,
whismanoid 10:b11ab5d7ac58 863 uint32_t expect_buffer)
whismanoid 10:b11ab5d7ac58 864 {
whismanoid 10:b11ab5d7ac58 865 uint8_t actual_result = functionUnderTest(arg_1, arg_2);
whismanoid 10:b11ab5d7ac58 866 uint32_t actual_buffer = *arg_2;
whismanoid 10:b11ab5d7ac58 867 if ((actual_result != expect_result) || (actual_buffer != expect_buffer))
whismanoid 10:b11ab5d7ac58 868 {
whismanoid 10:b11ab5d7ac58 869 FAIL();
whismanoid 10:b11ab5d7ac58 870 associatedCmdLine.serial().printf("%s(%d,buf)", nameOfFunctionUnderTest, arg_1);
whismanoid 10:b11ab5d7ac58 871 //associatedCmdLine.serial().print(nameOfFunctionUnderTest);
whismanoid 10:b11ab5d7ac58 872 //associatedCmdLine.serial().print("(");
whismanoid 10:b11ab5d7ac58 873 //associatedCmdLine.serial().print(arg_1);
whismanoid 10:b11ab5d7ac58 874 //associatedCmdLine.serial().print(F(",buf)"));
whismanoid 13:c294236d7465 875 associatedCmdLine.serial().printf(" expect %d buf=%ld", expect_result, expect_buffer);
whismanoid 10:b11ab5d7ac58 876 //associatedCmdLine.serial().print(F(" expect "));
whismanoid 10:b11ab5d7ac58 877 //associatedCmdLine.serial().print(expect_result);
whismanoid 10:b11ab5d7ac58 878 //associatedCmdLine.serial().print(F(" buf="));
whismanoid 10:b11ab5d7ac58 879 //associatedCmdLine.serial().print(expect_buffer);
whismanoid 13:c294236d7465 880 associatedCmdLine.serial().printf(" but got %d buf=%ld", actual_result, actual_buffer);
whismanoid 10:b11ab5d7ac58 881 //associatedCmdLine.serial().print(F(" but got "));
whismanoid 10:b11ab5d7ac58 882 //associatedCmdLine.serial().print(actual_result);
whismanoid 10:b11ab5d7ac58 883 //associatedCmdLine.serial().print(F(" buf="));
whismanoid 10:b11ab5d7ac58 884 //associatedCmdLine.serial().print(actual_buffer);
whismanoid 10:b11ab5d7ac58 885 return false;
whismanoid 10:b11ab5d7ac58 886 }
whismanoid 10:b11ab5d7ac58 887 else
whismanoid 10:b11ab5d7ac58 888 {
whismanoid 10:b11ab5d7ac58 889 PASS();
whismanoid 10:b11ab5d7ac58 890 associatedCmdLine.serial().printf("%s(%d,buf)", nameOfFunctionUnderTest, arg_1);
whismanoid 10:b11ab5d7ac58 891 //associatedCmdLine.serial().print(nameOfFunctionUnderTest);
whismanoid 10:b11ab5d7ac58 892 //associatedCmdLine.serial().print("(");
whismanoid 10:b11ab5d7ac58 893 //associatedCmdLine.serial().print(arg_1);
whismanoid 10:b11ab5d7ac58 894 //associatedCmdLine.serial().print(F(",buf)"));
whismanoid 13:c294236d7465 895 associatedCmdLine.serial().printf(" expect %d buf=%ld", expect_result, expect_buffer);
whismanoid 10:b11ab5d7ac58 896 //associatedCmdLine.serial().print(F(" expect "));
whismanoid 10:b11ab5d7ac58 897 //associatedCmdLine.serial().print(expect_result);
whismanoid 10:b11ab5d7ac58 898 //associatedCmdLine.serial().print(F(" buf="));
whismanoid 10:b11ab5d7ac58 899 //associatedCmdLine.serial().print(expect_buffer);
whismanoid 10:b11ab5d7ac58 900 return true;
whismanoid 10:b11ab5d7ac58 901 }
whismanoid 10:b11ab5d7ac58 902 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 10:b11ab5d7ac58 903 }
whismanoid 10:b11ab5d7ac58 904
whismanoid 7:5b40b6370f8a 905 /** Test a software function
whismanoid 7:5b40b6370f8a 906 *
whismanoid 7:5b40b6370f8a 907 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 908 *
whismanoid 7:5b40b6370f8a 909 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 910 *
whismanoid 7:5b40b6370f8a 911 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 912 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 913 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 914 *
whismanoid 7:5b40b6370f8a 915 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 916 *
whismanoid 7:5b40b6370f8a 917 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 918 *
whismanoid 7:5b40b6370f8a 919 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 920 *
whismanoid 7:5b40b6370f8a 921 */
whismanoid 12:55db0f4a417d 922 bool MaximTinyTester::FunctionCall_su_su_su_su_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 923 Callback<uint8_t(uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 924 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 925 uint8_t arg_2,
whismanoid 7:5b40b6370f8a 926 uint8_t arg_3,
whismanoid 7:5b40b6370f8a 927 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 928 {
whismanoid 7:5b40b6370f8a 929 uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3);
whismanoid 17:65fb4afe4991 930 if ((uint8_t)(actual_result & mask) != (uint8_t)(expect_result & mask)) // FunctionCall_su_su_su_su_Expect
whismanoid 7:5b40b6370f8a 931 {
whismanoid 7:5b40b6370f8a 932 FAIL();
whismanoid 7:5b40b6370f8a 933 associatedCmdLine.serial().printf("%s(%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3);
whismanoid 7:5b40b6370f8a 934 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 935 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 936 return false;
whismanoid 7:5b40b6370f8a 937 }
whismanoid 7:5b40b6370f8a 938 else
whismanoid 7:5b40b6370f8a 939 {
whismanoid 7:5b40b6370f8a 940 PASS();
whismanoid 7:5b40b6370f8a 941 associatedCmdLine.serial().printf("%s(%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3);
whismanoid 7:5b40b6370f8a 942 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 943 return true;
whismanoid 7:5b40b6370f8a 944 }
whismanoid 7:5b40b6370f8a 945 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 946 }
whismanoid 7:5b40b6370f8a 947
whismanoid 7:5b40b6370f8a 948 /** Test a software function
whismanoid 7:5b40b6370f8a 949 *
whismanoid 7:5b40b6370f8a 950 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 951 *
whismanoid 7:5b40b6370f8a 952 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 953 *
whismanoid 7:5b40b6370f8a 954 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 955 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 956 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 957 * @param[in] arg_4 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 958 *
whismanoid 7:5b40b6370f8a 959 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 960 *
whismanoid 7:5b40b6370f8a 961 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 962 *
whismanoid 7:5b40b6370f8a 963 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 964 *
whismanoid 7:5b40b6370f8a 965 */
whismanoid 12:55db0f4a417d 966 bool MaximTinyTester::FunctionCall_su_su_su_su_su_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 967 Callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 968 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 969 uint8_t arg_2,
whismanoid 7:5b40b6370f8a 970 uint8_t arg_3,
whismanoid 7:5b40b6370f8a 971 uint8_t arg_4,
whismanoid 7:5b40b6370f8a 972 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 973 {
whismanoid 7:5b40b6370f8a 974 uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3, arg_4);
whismanoid 17:65fb4afe4991 975 if ((uint8_t)(actual_result & mask) != (uint8_t)(expect_result & mask)) // FunctionCall_su_su_su_su_su_Expect
whismanoid 7:5b40b6370f8a 976 {
whismanoid 7:5b40b6370f8a 977 FAIL();
whismanoid 7:5b40b6370f8a 978 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4);
whismanoid 7:5b40b6370f8a 979 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 980 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 981 return false;
whismanoid 7:5b40b6370f8a 982 }
whismanoid 7:5b40b6370f8a 983 else
whismanoid 7:5b40b6370f8a 984 {
whismanoid 7:5b40b6370f8a 985 PASS();
whismanoid 7:5b40b6370f8a 986 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4);
whismanoid 7:5b40b6370f8a 987 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 988 return true;
whismanoid 7:5b40b6370f8a 989 }
whismanoid 7:5b40b6370f8a 990 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 991 }
whismanoid 7:5b40b6370f8a 992
whismanoid 7:5b40b6370f8a 993 /** Test a software function
whismanoid 7:5b40b6370f8a 994 *
whismanoid 7:5b40b6370f8a 995 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 996 *
whismanoid 7:5b40b6370f8a 997 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 998 *
whismanoid 7:5b40b6370f8a 999 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1000 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1001 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1002 * @param[in] arg_4 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1003 * @param[in] arg_5 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1004 *
whismanoid 7:5b40b6370f8a 1005 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 1006 *
whismanoid 7:5b40b6370f8a 1007 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 1008 *
whismanoid 7:5b40b6370f8a 1009 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 1010 *
whismanoid 7:5b40b6370f8a 1011 */
whismanoid 12:55db0f4a417d 1012 bool MaximTinyTester::FunctionCall_su_su_su_su_su_su_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 1013 Callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 1014 uint8_t arg_1,
whismanoid 7:5b40b6370f8a 1015 uint8_t arg_2,
whismanoid 7:5b40b6370f8a 1016 uint8_t arg_3,
whismanoid 7:5b40b6370f8a 1017 uint8_t arg_4,
whismanoid 7:5b40b6370f8a 1018 uint8_t arg_5,
whismanoid 7:5b40b6370f8a 1019 uint8_t expect_result)
whismanoid 7:5b40b6370f8a 1020 {
whismanoid 7:5b40b6370f8a 1021 uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3, arg_4, arg_5);
whismanoid 17:65fb4afe4991 1022 if ((uint8_t)(actual_result & mask) != (uint8_t)(expect_result & mask)) // FunctionCall_su_su_su_su_su_su_Expect
whismanoid 7:5b40b6370f8a 1023 {
whismanoid 7:5b40b6370f8a 1024 FAIL();
whismanoid 7:5b40b6370f8a 1025 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4, arg_5);
whismanoid 7:5b40b6370f8a 1026 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 1027 associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 1028 return false;
whismanoid 7:5b40b6370f8a 1029 }
whismanoid 7:5b40b6370f8a 1030 else
whismanoid 7:5b40b6370f8a 1031 {
whismanoid 7:5b40b6370f8a 1032 PASS();
whismanoid 7:5b40b6370f8a 1033 associatedCmdLine.serial().printf("%s(%d,%d,%d,%d,%d)", nameOfFunctionUnderTest, arg_1, arg_2, arg_3, arg_4, arg_5);
whismanoid 7:5b40b6370f8a 1034 associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 1035 return true;
whismanoid 7:5b40b6370f8a 1036 }
whismanoid 7:5b40b6370f8a 1037 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 1038 }
whismanoid 7:5b40b6370f8a 1039
whismanoid 7:5b40b6370f8a 1040 // TODO1 #167 support callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)>
whismanoid 7:5b40b6370f8a 1041 /** Test a software function
whismanoid 7:5b40b6370f8a 1042 *
whismanoid 7:5b40b6370f8a 1043 * @param[in] nameOfFunctionUnderTest is the user-facing name of the function under test
whismanoid 7:5b40b6370f8a 1044 *
whismanoid 7:5b40b6370f8a 1045 * @param[in] functionUnderTest points to the function under test
whismanoid 7:5b40b6370f8a 1046 *
whismanoid 7:5b40b6370f8a 1047 * @param[in] arg_1 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1048 * @param[in] arg_2 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1049 * @param[in] arg_3 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1050 * @param[in] arg_4 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1051 * @param[in] arg_5 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1052 * @param[in] arg_6 is a test argument given to the function under test
whismanoid 7:5b40b6370f8a 1053 *
whismanoid 7:5b40b6370f8a 1054 * @param[in] expect_result contains the expected result
whismanoid 7:5b40b6370f8a 1055 *
whismanoid 7:5b40b6370f8a 1056 * @post nPass and nFail counters are updated
whismanoid 7:5b40b6370f8a 1057 *
whismanoid 7:5b40b6370f8a 1058 * @return true if success, false if test failed
whismanoid 7:5b40b6370f8a 1059 *
whismanoid 7:5b40b6370f8a 1060 */
whismanoid 12:55db0f4a417d 1061 //bool MaximTinyTester::FunctionCall_su_su_su_su_su_su_su_Expect(const char *nameOfFunctionUnderTest,
whismanoid 7:5b40b6370f8a 1062 // Callback<uint8_t(uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t)> functionUnderTest,
whismanoid 7:5b40b6370f8a 1063 // uint8_t arg_1,
whismanoid 7:5b40b6370f8a 1064 // uint8_t arg_2,
whismanoid 7:5b40b6370f8a 1065 // uint8_t arg_3,
whismanoid 7:5b40b6370f8a 1066 // uint8_t arg_4,
whismanoid 7:5b40b6370f8a 1067 // uint8_t arg_5,
whismanoid 7:5b40b6370f8a 1068 // uint8_t arg_6,
whismanoid 7:5b40b6370f8a 1069 // uint8_t expect_result)
whismanoid 7:5b40b6370f8a 1070 //{
whismanoid 7:5b40b6370f8a 1071 // uint8_t actual_result = functionUnderTest(arg_1, arg_2, arg_3, arg_4, arg_5, arg_6);
whismanoid 7:5b40b6370f8a 1072 // if (actual_result != expect_result)
whismanoid 7:5b40b6370f8a 1073 // {
whismanoid 7:5b40b6370f8a 1074 // FAIL();
whismanoid 7:5b40b6370f8a 1075 // 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 1076 // associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 1077 // associatedCmdLine.serial().printf(" but got %d", actual_result);
whismanoid 7:5b40b6370f8a 1078 // return false;
whismanoid 7:5b40b6370f8a 1079 // }
whismanoid 7:5b40b6370f8a 1080 // else
whismanoid 7:5b40b6370f8a 1081 // {
whismanoid 7:5b40b6370f8a 1082 // PASS();
whismanoid 7:5b40b6370f8a 1083 // 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 1084 // associatedCmdLine.serial().printf(" expect %d", expect_result);
whismanoid 7:5b40b6370f8a 1085 // return true;
whismanoid 7:5b40b6370f8a 1086 // }
whismanoid 7:5b40b6370f8a 1087 // //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 7:5b40b6370f8a 1088 //}
whismanoid 7:5b40b6370f8a 1089
whismanoid 0:93d4119d3f14 1090 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 1091 *
whismanoid 0:93d4119d3f14 1092 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 1093 *
whismanoid 0:93d4119d3f14 1094 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 1095 *
whismanoid 0:93d4119d3f14 1096 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 1097 *
whismanoid 0:93d4119d3f14 1098 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 1099 *
whismanoid 0:93d4119d3f14 1100 */
whismanoid 0:93d4119d3f14 1101 bool MaximTinyTester::AnalogIn0_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 1102 {
whismanoid 0:93d4119d3f14 1103 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[0];
whismanoid 2:9b20cadbfa15 1104 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1105 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1106 {
whismanoid 2:9b20cadbfa15 1107 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1108 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1109 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1110 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1111 }
whismanoid 0:93d4119d3f14 1112
whismanoid 0:93d4119d3f14 1113 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1114 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1115 float normValue_0_1 = analogInPin0.read();
whismanoid 0:93d4119d3f14 1116 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1117 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1118 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1119 {
whismanoid 0:93d4119d3f14 1120 PASS();
whismanoid 0:93d4119d3f14 1121 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1122 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1123 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1124 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1125 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1126 );
whismanoid 0:93d4119d3f14 1127 //
whismanoid 0:93d4119d3f14 1128 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1129 return true;
whismanoid 0:93d4119d3f14 1130 }
whismanoid 0:93d4119d3f14 1131 else
whismanoid 0:93d4119d3f14 1132 {
whismanoid 0:93d4119d3f14 1133 FAIL();
whismanoid 0:93d4119d3f14 1134 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1135 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1136 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1137 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1138 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1139 );
whismanoid 0:93d4119d3f14 1140 //
whismanoid 0:93d4119d3f14 1141 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1142 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1143 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1144 }
whismanoid 0:93d4119d3f14 1145 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1146 return false;
whismanoid 0:93d4119d3f14 1147 }
whismanoid 0:93d4119d3f14 1148
whismanoid 0:93d4119d3f14 1149 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 1150 *
whismanoid 0:93d4119d3f14 1151 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 1152 *
whismanoid 0:93d4119d3f14 1153 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 1154 *
whismanoid 0:93d4119d3f14 1155 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 1156 *
whismanoid 0:93d4119d3f14 1157 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 1158 *
whismanoid 0:93d4119d3f14 1159 */
whismanoid 0:93d4119d3f14 1160 bool MaximTinyTester::AnalogIn1_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 1161 {
whismanoid 0:93d4119d3f14 1162 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[1];
whismanoid 2:9b20cadbfa15 1163 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1164 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1165 {
whismanoid 2:9b20cadbfa15 1166 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1167 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1168 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1169 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1170 }
whismanoid 0:93d4119d3f14 1171
whismanoid 0:93d4119d3f14 1172 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1173 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1174 float normValue_0_1 = analogInPin1.read();
whismanoid 0:93d4119d3f14 1175 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1176 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1177 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1178 {
whismanoid 0:93d4119d3f14 1179 PASS();
whismanoid 0:93d4119d3f14 1180 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1181 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1182 associatedCmdLine.serial().printf("AIN1 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1183 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1184 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1185 );
whismanoid 0:93d4119d3f14 1186 //
whismanoid 0:93d4119d3f14 1187 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1188 return true;
whismanoid 0:93d4119d3f14 1189 }
whismanoid 0:93d4119d3f14 1190 else
whismanoid 0:93d4119d3f14 1191 {
whismanoid 0:93d4119d3f14 1192 FAIL();
whismanoid 0:93d4119d3f14 1193 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1194 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1195 associatedCmdLine.serial().printf("AIN1 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1196 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1197 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1198 );
whismanoid 0:93d4119d3f14 1199 //
whismanoid 0:93d4119d3f14 1200 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1201 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1202 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1203 }
whismanoid 0:93d4119d3f14 1204 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1205 return false;
whismanoid 0:93d4119d3f14 1206 }
whismanoid 0:93d4119d3f14 1207
whismanoid 0:93d4119d3f14 1208 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 1209 *
whismanoid 0:93d4119d3f14 1210 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 1211 *
whismanoid 0:93d4119d3f14 1212 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 1213 *
whismanoid 0:93d4119d3f14 1214 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 1215 *
whismanoid 0:93d4119d3f14 1216 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 1217 *
whismanoid 0:93d4119d3f14 1218 */
whismanoid 0:93d4119d3f14 1219 bool MaximTinyTester::AnalogIn2_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 1220 {
whismanoid 0:93d4119d3f14 1221 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[2];
whismanoid 2:9b20cadbfa15 1222 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1223 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1224 {
whismanoid 2:9b20cadbfa15 1225 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1226 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1227 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1228 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1229 }
whismanoid 0:93d4119d3f14 1230
whismanoid 0:93d4119d3f14 1231 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1232 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1233 float normValue_0_1 = analogInPin2.read();
whismanoid 0:93d4119d3f14 1234 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1235 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1236 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1237 {
whismanoid 0:93d4119d3f14 1238 PASS();
whismanoid 0:93d4119d3f14 1239 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1240 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1241 associatedCmdLine.serial().printf("AIN2 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1242 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1243 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1244 );
whismanoid 0:93d4119d3f14 1245 //
whismanoid 0:93d4119d3f14 1246 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1247 return true;
whismanoid 0:93d4119d3f14 1248 }
whismanoid 0:93d4119d3f14 1249 else
whismanoid 0:93d4119d3f14 1250 {
whismanoid 0:93d4119d3f14 1251 FAIL();
whismanoid 0:93d4119d3f14 1252 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1253 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1254 associatedCmdLine.serial().printf("AIN2 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1255 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1256 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1257 );
whismanoid 0:93d4119d3f14 1258 //
whismanoid 0:93d4119d3f14 1259 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1260 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1261 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1262 }
whismanoid 0:93d4119d3f14 1263 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1264 return false;
whismanoid 0:93d4119d3f14 1265 }
whismanoid 0:93d4119d3f14 1266
whismanoid 0:93d4119d3f14 1267 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 1268 *
whismanoid 0:93d4119d3f14 1269 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 1270 *
whismanoid 0:93d4119d3f14 1271 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 1272 *
whismanoid 0:93d4119d3f14 1273 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 1274 *
whismanoid 0:93d4119d3f14 1275 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 1276 *
whismanoid 0:93d4119d3f14 1277 */
whismanoid 0:93d4119d3f14 1278 bool MaximTinyTester::AnalogIn3_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 1279 {
whismanoid 0:93d4119d3f14 1280 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[3];
whismanoid 2:9b20cadbfa15 1281 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1282 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1283 {
whismanoid 2:9b20cadbfa15 1284 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1285 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1286 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1287 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1288 }
whismanoid 0:93d4119d3f14 1289
whismanoid 0:93d4119d3f14 1290 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1291 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1292 float normValue_0_1 = analogInPin3.read();
whismanoid 0:93d4119d3f14 1293 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1294 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1295 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1296 {
whismanoid 0:93d4119d3f14 1297 PASS();
whismanoid 0:93d4119d3f14 1298 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1299 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1300 associatedCmdLine.serial().printf("AIN3 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1301 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1302 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1303 );
whismanoid 0:93d4119d3f14 1304 //
whismanoid 0:93d4119d3f14 1305 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1306 return true;
whismanoid 0:93d4119d3f14 1307 }
whismanoid 0:93d4119d3f14 1308 else
whismanoid 0:93d4119d3f14 1309 {
whismanoid 0:93d4119d3f14 1310 FAIL();
whismanoid 0:93d4119d3f14 1311 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1312 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1313 associatedCmdLine.serial().printf("AIN3 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1314 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1315 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1316 );
whismanoid 0:93d4119d3f14 1317 //
whismanoid 0:93d4119d3f14 1318 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1319 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1320 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1321 }
whismanoid 0:93d4119d3f14 1322 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1323 return false;
whismanoid 0:93d4119d3f14 1324 }
whismanoid 0:93d4119d3f14 1325
whismanoid 0:93d4119d3f14 1326 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 1327 *
whismanoid 0:93d4119d3f14 1328 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 1329 *
whismanoid 0:93d4119d3f14 1330 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 1331 *
whismanoid 0:93d4119d3f14 1332 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 1333 *
whismanoid 0:93d4119d3f14 1334 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 1335 *
whismanoid 0:93d4119d3f14 1336 */
whismanoid 0:93d4119d3f14 1337 bool MaximTinyTester::AnalogIn4_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 1338 {
whismanoid 0:93d4119d3f14 1339 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[4];
whismanoid 2:9b20cadbfa15 1340 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1341 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1342 {
whismanoid 2:9b20cadbfa15 1343 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1344 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1345 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1346 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1347 }
whismanoid 0:93d4119d3f14 1348
whismanoid 0:93d4119d3f14 1349 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1350 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1351 float normValue_0_1 = analogInPin4.read();
whismanoid 0:93d4119d3f14 1352 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1353 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1354 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1355 {
whismanoid 0:93d4119d3f14 1356 PASS();
whismanoid 0:93d4119d3f14 1357 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1358 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1359 associatedCmdLine.serial().printf("AIN4 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1360 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1361 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1362 );
whismanoid 0:93d4119d3f14 1363 //
whismanoid 0:93d4119d3f14 1364 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1365 return true;
whismanoid 0:93d4119d3f14 1366 }
whismanoid 0:93d4119d3f14 1367 else
whismanoid 0:93d4119d3f14 1368 {
whismanoid 0:93d4119d3f14 1369 FAIL();
whismanoid 0:93d4119d3f14 1370 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1371 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1372 associatedCmdLine.serial().printf("AIN4 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1373 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1374 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1375 );
whismanoid 0:93d4119d3f14 1376 //
whismanoid 0:93d4119d3f14 1377 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1378 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1379 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1380 }
whismanoid 0:93d4119d3f14 1381 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1382 return false;
whismanoid 0:93d4119d3f14 1383 }
whismanoid 0:93d4119d3f14 1384
whismanoid 0:93d4119d3f14 1385 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 0:93d4119d3f14 1386 *
whismanoid 0:93d4119d3f14 1387 * @param[in] expect_result contains the expected voltage
whismanoid 0:93d4119d3f14 1388 *
whismanoid 0:93d4119d3f14 1389 * @pre err_threshold determines how closely the result must match the expected value
whismanoid 0:93d4119d3f14 1390 *
whismanoid 0:93d4119d3f14 1391 * @post nPass and nFail counters are updated
whismanoid 0:93d4119d3f14 1392 *
whismanoid 0:93d4119d3f14 1393 * @return true if success, false if test failed
whismanoid 0:93d4119d3f14 1394 *
whismanoid 0:93d4119d3f14 1395 */
whismanoid 0:93d4119d3f14 1396 bool MaximTinyTester::AnalogIn5_Read_Expect_voltageV(double expect_result)
whismanoid 0:93d4119d3f14 1397 {
whismanoid 0:93d4119d3f14 1398 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[5];
whismanoid 2:9b20cadbfa15 1399 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1400 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1401 {
whismanoid 2:9b20cadbfa15 1402 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1403 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1404 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1405 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1406 }
whismanoid 0:93d4119d3f14 1407
whismanoid 0:93d4119d3f14 1408 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1409 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1410 float normValue_0_1 = analogInPin5.read();
whismanoid 0:93d4119d3f14 1411 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1412 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1413 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1414 {
whismanoid 0:93d4119d3f14 1415 PASS();
whismanoid 0:93d4119d3f14 1416 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1417 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1418 associatedCmdLine.serial().printf("AIN5 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1419 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1420 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1421 );
whismanoid 0:93d4119d3f14 1422 //
whismanoid 0:93d4119d3f14 1423 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1424 return true;
whismanoid 0:93d4119d3f14 1425 }
whismanoid 0:93d4119d3f14 1426 else
whismanoid 0:93d4119d3f14 1427 {
whismanoid 0:93d4119d3f14 1428 FAIL();
whismanoid 0:93d4119d3f14 1429 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1430 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1431 associatedCmdLine.serial().printf("AIN5 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1432 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1433 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1434 );
whismanoid 0:93d4119d3f14 1435 //
whismanoid 0:93d4119d3f14 1436 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1437 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1438 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1439 }
whismanoid 0:93d4119d3f14 1440 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1441 return false;
whismanoid 0:93d4119d3f14 1442 }
whismanoid 0:93d4119d3f14 1443
whismanoid 0:93d4119d3f14 1444 bool MaximTinyTester::AnalogIn_Read_Expect_voltageV(AnalogIn& analogInPin, double expect_result)
whismanoid 0:93d4119d3f14 1445 {
whismanoid 0:93d4119d3f14 1446 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[0];
whismanoid 2:9b20cadbfa15 1447 // skip if expect_result exceeds ADC full scale
whismanoid 2:9b20cadbfa15 1448 if (adc_full_scale_voltage < expect_result)
whismanoid 2:9b20cadbfa15 1449 {
whismanoid 2:9b20cadbfa15 1450 // print a warning message that we can't perform the measurement
whismanoid 2:9b20cadbfa15 1451 associatedCmdLine.serial().printf("\r\n..... AIN full scale %1.3fV < expect %6.6f cannot perform measurement",
whismanoid 2:9b20cadbfa15 1452 adc_full_scale_voltage, expect_result);
whismanoid 2:9b20cadbfa15 1453 return true; // ignore, test conditions are invalid; do not call PASS() or FAIL()
whismanoid 2:9b20cadbfa15 1454 }
whismanoid 0:93d4119d3f14 1455
whismanoid 0:93d4119d3f14 1456 // TODO: tinyTester.Analog_Input_Expect_V replaces SelfTest_AnalogInput_Expect_ch_V
whismanoid 0:93d4119d3f14 1457 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1458 float normValue_0_1 = analogInPin.read();
whismanoid 0:93d4119d3f14 1459 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 0:93d4119d3f14 1460 double err_result = (actual_result - expect_result);
whismanoid 0:93d4119d3f14 1461 if (( -err_threshold < err_result) && ( err_result < err_threshold))
whismanoid 0:93d4119d3f14 1462 {
whismanoid 0:93d4119d3f14 1463 PASS();
whismanoid 0:93d4119d3f14 1464 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1465 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1466 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1467 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1468 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1469 );
whismanoid 0:93d4119d3f14 1470 //
whismanoid 0:93d4119d3f14 1471 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1472 return true;
whismanoid 0:93d4119d3f14 1473 }
whismanoid 0:93d4119d3f14 1474 else
whismanoid 0:93d4119d3f14 1475 {
whismanoid 0:93d4119d3f14 1476 FAIL();
whismanoid 0:93d4119d3f14 1477 //~ SelfTest_print_VoltageOfCode(cmdLine, value_u12);
whismanoid 0:93d4119d3f14 1478 // Platform board uses simple analog inputs
whismanoid 0:93d4119d3f14 1479 associatedCmdLine.serial().printf("AIN0 = %7.3f%% = %1.3fV ",
whismanoid 0:93d4119d3f14 1480 normValue_0_1 * 100.0,
whismanoid 0:93d4119d3f14 1481 normValue_0_1 * adc_full_scale_voltage
whismanoid 0:93d4119d3f14 1482 );
whismanoid 0:93d4119d3f14 1483 //
whismanoid 0:93d4119d3f14 1484 associatedCmdLine.serial().printf(" expect %6.6f +/- %6.6f", expect_result, err_threshold);
whismanoid 0:93d4119d3f14 1485 associatedCmdLine.serial().printf(" but got %6.6f", actual_result);
whismanoid 0:93d4119d3f14 1486 associatedCmdLine.serial().printf(" err=%6.6f", err_result);
whismanoid 0:93d4119d3f14 1487 }
whismanoid 0:93d4119d3f14 1488 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 0:93d4119d3f14 1489 return false;
whismanoid 0:93d4119d3f14 1490 }
whismanoid 0:93d4119d3f14 1491
whismanoid 18:9874cd1e6cb0 1492
whismanoid 18:9874cd1e6cb0 1493 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 18:9874cd1e6cb0 1494 * and report the measured value to the test log.
whismanoid 18:9874cd1e6cb0 1495 * Information only; does not pass or fail.
whismanoid 18:9874cd1e6cb0 1496 *
whismanoid 18:9874cd1e6cb0 1497 * @return voltage in Volts
whismanoid 18:9874cd1e6cb0 1498 *
whismanoid 18:9874cd1e6cb0 1499 */
whismanoid 18:9874cd1e6cb0 1500 double MaximTinyTester::AnalogIn0_Read_Report_voltageV()
whismanoid 18:9874cd1e6cb0 1501 {
whismanoid 18:9874cd1e6cb0 1502 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[0];
whismanoid 18:9874cd1e6cb0 1503
whismanoid 18:9874cd1e6cb0 1504 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1505 float normValue_0_1 = analogInPin0.read();
whismanoid 18:9874cd1e6cb0 1506 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 18:9874cd1e6cb0 1507 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1508 associatedCmdLine.serial().printf("\r\n AIN0 = %7.3f%% = %1.3fV ",
whismanoid 18:9874cd1e6cb0 1509 normValue_0_1 * 100.0,
whismanoid 18:9874cd1e6cb0 1510 normValue_0_1 * adc_full_scale_voltage
whismanoid 18:9874cd1e6cb0 1511 );
whismanoid 18:9874cd1e6cb0 1512 //
whismanoid 18:9874cd1e6cb0 1513 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 18:9874cd1e6cb0 1514 return actual_result;
whismanoid 18:9874cd1e6cb0 1515 }
whismanoid 18:9874cd1e6cb0 1516
whismanoid 18:9874cd1e6cb0 1517 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 18:9874cd1e6cb0 1518 * and report the measured value to the test log.
whismanoid 18:9874cd1e6cb0 1519 * Information only; does not pass or fail.
whismanoid 18:9874cd1e6cb0 1520 *
whismanoid 18:9874cd1e6cb0 1521 * @return voltage in Volts
whismanoid 18:9874cd1e6cb0 1522 *
whismanoid 18:9874cd1e6cb0 1523 */
whismanoid 18:9874cd1e6cb0 1524 double MaximTinyTester::AnalogIn1_Read_Report_voltageV()
whismanoid 18:9874cd1e6cb0 1525 {
whismanoid 18:9874cd1e6cb0 1526 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[1];
whismanoid 18:9874cd1e6cb0 1527
whismanoid 18:9874cd1e6cb0 1528 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1529 float normValue_0_1 = analogInPin1.read();
whismanoid 18:9874cd1e6cb0 1530 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 18:9874cd1e6cb0 1531 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1532 associatedCmdLine.serial().printf("\r\n AIN1 = %7.3f%% = %1.3fV ",
whismanoid 18:9874cd1e6cb0 1533 normValue_0_1 * 100.0,
whismanoid 18:9874cd1e6cb0 1534 normValue_0_1 * adc_full_scale_voltage
whismanoid 18:9874cd1e6cb0 1535 );
whismanoid 18:9874cd1e6cb0 1536 //
whismanoid 18:9874cd1e6cb0 1537 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 18:9874cd1e6cb0 1538 return actual_result;
whismanoid 18:9874cd1e6cb0 1539 }
whismanoid 18:9874cd1e6cb0 1540
whismanoid 18:9874cd1e6cb0 1541 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 18:9874cd1e6cb0 1542 * and report the measured value to the test log.
whismanoid 18:9874cd1e6cb0 1543 * Information only; does not pass or fail.
whismanoid 18:9874cd1e6cb0 1544 *
whismanoid 18:9874cd1e6cb0 1545 * @return voltage in Volts
whismanoid 18:9874cd1e6cb0 1546 *
whismanoid 18:9874cd1e6cb0 1547 */
whismanoid 18:9874cd1e6cb0 1548 double MaximTinyTester::AnalogIn2_Read_Report_voltageV()
whismanoid 18:9874cd1e6cb0 1549 {
whismanoid 18:9874cd1e6cb0 1550 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[2];
whismanoid 18:9874cd1e6cb0 1551
whismanoid 18:9874cd1e6cb0 1552 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1553 float normValue_0_1 = analogInPin2.read();
whismanoid 18:9874cd1e6cb0 1554 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 18:9874cd1e6cb0 1555 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1556 associatedCmdLine.serial().printf("\r\n AIN2 = %7.3f%% = %1.3fV ",
whismanoid 18:9874cd1e6cb0 1557 normValue_0_1 * 100.0,
whismanoid 18:9874cd1e6cb0 1558 normValue_0_1 * adc_full_scale_voltage
whismanoid 18:9874cd1e6cb0 1559 );
whismanoid 18:9874cd1e6cb0 1560 //
whismanoid 18:9874cd1e6cb0 1561 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 18:9874cd1e6cb0 1562 return actual_result;
whismanoid 18:9874cd1e6cb0 1563 }
whismanoid 18:9874cd1e6cb0 1564
whismanoid 18:9874cd1e6cb0 1565 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 18:9874cd1e6cb0 1566 * and report the measured value to the test log.
whismanoid 18:9874cd1e6cb0 1567 * Information only; does not pass or fail.
whismanoid 18:9874cd1e6cb0 1568 *
whismanoid 18:9874cd1e6cb0 1569 * @return voltage in Volts
whismanoid 18:9874cd1e6cb0 1570 *
whismanoid 18:9874cd1e6cb0 1571 */
whismanoid 18:9874cd1e6cb0 1572 double MaximTinyTester::AnalogIn3_Read_Report_voltageV()
whismanoid 18:9874cd1e6cb0 1573 {
whismanoid 18:9874cd1e6cb0 1574 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[3];
whismanoid 18:9874cd1e6cb0 1575
whismanoid 18:9874cd1e6cb0 1576 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1577 float normValue_0_1 = analogInPin3.read();
whismanoid 18:9874cd1e6cb0 1578 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 18:9874cd1e6cb0 1579 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1580 associatedCmdLine.serial().printf("\r\n AIN3 = %7.3f%% = %1.3fV ",
whismanoid 18:9874cd1e6cb0 1581 normValue_0_1 * 100.0,
whismanoid 18:9874cd1e6cb0 1582 normValue_0_1 * adc_full_scale_voltage
whismanoid 18:9874cd1e6cb0 1583 );
whismanoid 18:9874cd1e6cb0 1584 //
whismanoid 18:9874cd1e6cb0 1585 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 18:9874cd1e6cb0 1586 return actual_result;
whismanoid 18:9874cd1e6cb0 1587 }
whismanoid 18:9874cd1e6cb0 1588
whismanoid 18:9874cd1e6cb0 1589 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 18:9874cd1e6cb0 1590 * and report the measured value to the test log.
whismanoid 18:9874cd1e6cb0 1591 * Information only; does not pass or fail.
whismanoid 18:9874cd1e6cb0 1592 *
whismanoid 18:9874cd1e6cb0 1593 * @return voltage in Volts
whismanoid 18:9874cd1e6cb0 1594 *
whismanoid 18:9874cd1e6cb0 1595 */
whismanoid 18:9874cd1e6cb0 1596 double MaximTinyTester::AnalogIn4_Read_Report_voltageV()
whismanoid 18:9874cd1e6cb0 1597 {
whismanoid 18:9874cd1e6cb0 1598 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[4];
whismanoid 18:9874cd1e6cb0 1599
whismanoid 18:9874cd1e6cb0 1600 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1601 float normValue_0_1 = analogInPin4.read();
whismanoid 18:9874cd1e6cb0 1602 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 18:9874cd1e6cb0 1603 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1604 associatedCmdLine.serial().printf("\r\n AIN4 = %7.3f%% = %1.3fV ",
whismanoid 18:9874cd1e6cb0 1605 normValue_0_1 * 100.0,
whismanoid 18:9874cd1e6cb0 1606 normValue_0_1 * adc_full_scale_voltage
whismanoid 18:9874cd1e6cb0 1607 );
whismanoid 18:9874cd1e6cb0 1608 //
whismanoid 18:9874cd1e6cb0 1609 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 18:9874cd1e6cb0 1610 return actual_result;
whismanoid 18:9874cd1e6cb0 1611 }
whismanoid 18:9874cd1e6cb0 1612
whismanoid 18:9874cd1e6cb0 1613 /** Test an analog voltage input to the platform (output from the device under test)
whismanoid 18:9874cd1e6cb0 1614 * and report the measured value to the test log.
whismanoid 18:9874cd1e6cb0 1615 * Information only; does not pass or fail.
whismanoid 18:9874cd1e6cb0 1616 *
whismanoid 18:9874cd1e6cb0 1617 * @return voltage in Volts
whismanoid 18:9874cd1e6cb0 1618 *
whismanoid 18:9874cd1e6cb0 1619 */
whismanoid 18:9874cd1e6cb0 1620 double MaximTinyTester::AnalogIn5_Read_Report_voltageV()
whismanoid 18:9874cd1e6cb0 1621 {
whismanoid 18:9874cd1e6cb0 1622 float adc_full_scale_voltage = analogInPin_fullScaleVoltage[5];
whismanoid 18:9874cd1e6cb0 1623
whismanoid 18:9874cd1e6cb0 1624 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1625 float normValue_0_1 = analogInPin5.read();
whismanoid 18:9874cd1e6cb0 1626 double actual_result = normValue_0_1 * adc_full_scale_voltage;
whismanoid 18:9874cd1e6cb0 1627 // Platform board uses simple analog inputs
whismanoid 18:9874cd1e6cb0 1628 associatedCmdLine.serial().printf("\r\n AIN5 = %7.3f%% = %1.3fV ",
whismanoid 18:9874cd1e6cb0 1629 normValue_0_1 * 100.0,
whismanoid 18:9874cd1e6cb0 1630 normValue_0_1 * adc_full_scale_voltage
whismanoid 18:9874cd1e6cb0 1631 );
whismanoid 18:9874cd1e6cb0 1632 //
whismanoid 18:9874cd1e6cb0 1633 //~ associatedCmdLine.serial().printf("\r\n");
whismanoid 18:9874cd1e6cb0 1634 return actual_result;
whismanoid 18:9874cd1e6cb0 1635 }
whismanoid 18:9874cd1e6cb0 1636
whismanoid 0:93d4119d3f14 1637 bool MaximTinyTester::DigitalIn_Read_Expect_WarnOnly(DigitalIn& digitalInPin, const char* pinName, int expect_result, const char *expect_description)
whismanoid 0:93d4119d3f14 1638 {
whismanoid 0:93d4119d3f14 1639 int actual_UPO_value = -1;
whismanoid 0:93d4119d3f14 1640 for (int retry_count = 0; retry_count < 10; retry_count++) {
whismanoid 0:93d4119d3f14 1641 actual_UPO_value = digitalInPin.read(); // g_MAX5171_device.UPOinputValue();
whismanoid 17:65fb4afe4991 1642 if (actual_UPO_value == expect_result) // DigitalIn_Read_Expect_WarnOnly
whismanoid 17:65fb4afe4991 1643 {
whismanoid 0:93d4119d3f14 1644 PASS();
whismanoid 0:93d4119d3f14 1645 associatedCmdLine.serial().printf("%s signal=%d %s", pinName, expect_result, expect_description);
whismanoid 0:93d4119d3f14 1646 return true;
whismanoid 0:93d4119d3f14 1647 }
whismanoid 0:93d4119d3f14 1648 // UPO condition not met, retry for a while until give up
whismanoid 0:93d4119d3f14 1649 wait_ms(input_timeout_time_msec / 10); // delay
whismanoid 0:93d4119d3f14 1650 }
whismanoid 0:93d4119d3f14 1651 associatedCmdLine.serial().printf("\r\n!WARN "); // SelfTest_FAIL(cmdLine);
whismanoid 0:93d4119d3f14 1652 associatedCmdLine.serial().printf("expected %s signal=%d %s", pinName, expect_result, expect_description);
whismanoid 0:93d4119d3f14 1653 associatedCmdLine.serial().printf(", but got actual %s=%d", pinName, actual_UPO_value);
whismanoid 0:93d4119d3f14 1654 associatedCmdLine.serial().printf(", missing %s connections?", pinName);
whismanoid 0:93d4119d3f14 1655 return false;
whismanoid 0:93d4119d3f14 1656 }
whismanoid 0:93d4119d3f14 1657
whismanoid 0:93d4119d3f14 1658 void MaximTinyTester::Wait_Output_Settling()
whismanoid 0:93d4119d3f14 1659 {
whismanoid 0:93d4119d3f14 1660 wait_ms(settle_time_msec); // delay
whismanoid 0:93d4119d3f14 1661 }
whismanoid 0:93d4119d3f14 1662
whismanoid 0:93d4119d3f14 1663
whismanoid 0:93d4119d3f14 1664 // End of file