Dev hardware test (#368)

* name of requirements.txt changed, digital io test fixed, eeprom user space test fixed

* osensa eeprom test fix

* adc, rtd hardware test

* delete test_adc_read.py, revised digital io test

* added hardware test workflow which requires publish

* hardware test passing

* pylint fix

* label added to route job to the hardware test unit

Author: sjpark608

.github/workflows/build-and-publish-TestPyPI.yml

@@ -69,3 +69,26 @@ jobs:
         git config user.email ${{ env.commit_email }}
         git cherry-pick ${{ env.bump_commit }}
         git push origin dev
+  Hardware_Test:
+    needs: publish
+    name: Hardware Tests
+    runs-on: [self-hosted, linux, ARM64, hw-test]
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9"]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Install Dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m venv venv_hardware_test
+          source venv_hardware_test/bin/activate
+          python -m pip install pytest
+          if [ -f requirements_hw_test.txt ]; then pip install -r requirements_hw_test.txt; fi
+      - name: Test with pytest
+        run: |
+          source venv_hardware_test/bin/activate
+          python -m pytest ./tests/hardware_tests

requirements_integration.txt renamed to requirements_hw_test.txt

@@ -5,27 +5,23 @@
 from edgepi.digital_input.edgepi_digital_input import EdgePiDigitalInput
 from edgepi.digital_output.edgepi_digital_output import EdgePiDigitalOutput
 from edgepi.digital_input.digital_input_constants import DinPins
-from edgepi.digital_output.digital_output_constants import DoutPins
+from edgepi.digital_output.digital_output_constants import DoutPins, DoutTriState
 
 @pytest.mark.parametrize("din_pin, dout_pin", [
     (DinPins.DIN1, DoutPins.DOUT1),
     (DinPins.DIN2, DoutPins.DOUT2),
-    (DinPins.DIN3, DoutPins.DOUT3),
-    (DinPins.DIN4, DoutPins.DOUT4),
-    (DinPins.DIN5, DoutPins.DOUT5),
-    (DinPins.DIN6, DoutPins.DOUT6),
-    (DinPins.DIN7, DoutPins.DOUT7),
-    (DinPins.DIN8, DoutPins.DOUT8),
+    (DinPins.DIN3, DoutPins.DOUT3)
 ])
 def test_input_state(din_pin, dout_pin):
     din=EdgePiDigitalInput()
     dout = EdgePiDigitalOutput()
+    dout.set_dout_state(dout_pin, DoutTriState.LOW)
     initial_state = din.digital_input_state(din_pin)
-    dout.set_dout_state(dout_pin, True)
+    dout.set_dout_state(dout_pin, DoutTriState.HIGH)
     sleep(0.1)
     changed_state = din.digital_input_state(din_pin)
     assert initial_state is not changed_state
-    dout.set_dout_state(dout_pin, False)
+    dout.set_dout_state(dout_pin, DoutTriState.LOW)
     sleep(0.1)
     changed_state = din.digital_input_state(din_pin)
     assert initial_state is changed_state

tests/hardware_tests/test_adc_read.py

@@ -53,7 +53,7 @@ def test_osensa_space_modify_1(eeprom):
     assert eeprom_data_origin.adc1_calib_params != eeprom_data_modify.adc1_calib_params
     assert eeprom_data_origin.adc2_calib_params != eeprom_data_modify.adc2_calib_params
 
-    eeprom.read_edgepi_data(eeprom_data_origin)
+    eeprom.write_edgepi_data(eeprom_data_origin)
 
 # TC and RTD modification
 def test_osensa_space_modify_2(eeprom):
@@ -97,10 +97,10 @@ def test_osensa_space_modify_3(eeprom):
     eeprom_data_modify = eeprom.read_edgepi_data()
     time.sleep(0.5)
 
-    eeprom_data_modify.config_key.certificate = "yeeeeeeet"
-    eeprom_data_modify.config_key.private_key = "ajksbvjkalsbkvalva"
-    eeprom_data_modify.data_key.certificate = "asjkdbvakjsnvjka"
-    eeprom_data_modify.data_key.private_key = "lozxivhzlnjqq"
+    eeprom_data_modify.config_key.certificate = "This is test string"
+    eeprom_data_modify.config_key.private_key = "This is test string"
+    eeprom_data_modify.data_key.certificate = "This is test string"
+    eeprom_data_modify.data_key.private_key = "This is test string"
 
     eeprom.write_edgepi_data(eeprom_data_modify)
     time.sleep(0.5)

tests/hardware_tests/test_digital_io.py

@@ -13,7 +13,7 @@
 PATH = os.path.dirname(os.path.abspath(__file__))
 
 import pytest
-from edgepi.eeprom.eeprom_constants import EdgePiMemoryInfo, EEPROMInfo
+from edgepi.eeprom.eeprom_constants import EEPROMInfo
 from edgepi.eeprom.edgepi_eeprom import EdgePiEEPROM
 
 
@@ -31,26 +31,6 @@ def read_dummy_json(file_name: str):
         dummy = json.load(file)
     return dummy
 
-def test__page_write_register(eeprom):
-    for val in range(0, 256):
-        _logger.info(f"test__page_write_register: Test Value = {val}")
-        data = [val]*16384
-        initial_data = eeprom.read_user_space(0, len(data))
-        _logger.info(f"test__page_write_register: Initial Value = {len(initial_data)}")
-        addrx = EdgePiMemoryInfo.USER_SPACE_START_BYTE.value
-        # pylint: disable=protected-access
-        page_n = eeprom._EdgePiEEPROM__generate_list_of_pages(addrx, data)
-        for indx, page in enumerate(page_n):
-            # pylint: disable=protected-access
-            eeprom._EdgePiEEPROM__page_write_register(addrx+(indx*EEPROMInfo.PAGE_SIZE.value), page)
-            time.sleep(0.002)
-        _logger.info(f"test__page_write_register: Page Written = {len(page_n)}")
-        new_data = eeprom.read_user_space(0, len(data))
-        _logger.info(f"test__page_write_register: New Value = {len(new_data)}")
-        for indx, init_data in enumerate(initial_data):
-            assert init_data != new_data[indx]
-            assert new_data[indx] == data[indx]
-
 def test_reset_user_space(eeprom):
     reset_vals = []
     eeprom.reset_user_space()

tests/hardware_tests/test_eeprom_osensaspace.py

@@ -6,25 +6,25 @@
 
 
 # This has to be manually set with temperature machine. Use this value for testing.
-RTD_TEMP = 50
-ERROR = 1
+RTD_TEMP = 28
+ERROR = 4
 
 
 @pytest.fixture(name="rtd", scope="module")
 def fixture_rtd():
     adc = EdgePiADC()
+    adc.reset()
     adc.set_rtd(True)
     return adc
 
 def test_single_sample_rtd(rtd):
     out = rtd.single_sample_rtd()
     assert out == pytest.approx(RTD_TEMP, abs=ERROR)
 
-
 def test_read_rtd_temperature(rtd):
     rtd.set_config(conversion_mode=ConvMode.CONTINUOUS)
-    rtd.start_conversions(ADCNum.ADC_1)
+    rtd.start_conversions(ADCNum.ADC_2)
     for _ in range(10):
         out = rtd.read_rtd_temperature()
         assert out == pytest.approx(RTD_TEMP, abs=ERROR)
-    rtd.stop_conversions(ADCNum.ADC_1)
+    rtd.stop_conversions(ADCNum.ADC_2)

tests/hardware_tests/test_eeprom_userspace.py

@@ -5,15 +5,15 @@
 from time import sleep
 import pytest
 from edgepi.adc.edgepi_adc import EdgePiADC
-from edgepi.adc.adc_constants import AnalogIn, ADCNum, DiffMode
+from edgepi.adc.adc_constants import AnalogIn, ADCNum, DiffMode, ADCChannel
 from edgepi.dac.edgepi_dac import EdgePiDAC
 from edgepi.dac.dac_constants import DACChannel
 
 
 _logger = logging.getLogger(__name__)
 
 
-NUM_CHANNELS = 8
+NUM_CHANNELS = 2
 READS_PER_WRITE = 1
 RW_ERROR = 1e-1 # TODO: change to mV
 MAX_VOLTAGE = 5.0
@@ -36,6 +36,7 @@
 @pytest.fixture(name="adc_1", scope="module")
 def fixture_adc_1():
     adc = EdgePiADC()
+    adc.reset()
     adc.start_conversions(ADCNum.ADC_1)
     yield adc
     adc.stop_conversions(ADCNum.ADC_1)
@@ -44,6 +45,7 @@ def fixture_adc_1():
 @pytest.fixture(name="adc_2", scope="module")
 def fixture_adc_2():
     adc = EdgePiADC()
+    adc.reset()
     adc.start_conversions(ADCNum.ADC_2)
     yield adc
     adc.stop_conversions(ADCNum.ADC_2)
@@ -114,11 +116,11 @@ def _generate_diff_test_cases():
                 f"read_write_error_tolerance: +/- {RW_ERROR} V, num_read_trials: {READS_PER_WRITE}"
             )
         )
-    for diff in DiffMode:
-        voltage = 0
-        while voltage < MAX_VOLTAGE - VOLTAGE_STEP:
-            voltage += VOLTAGE_STEP
-            yield diff, voltage, voltage
+    diff = DiffMode.DIFF_2
+    voltage = 0
+    while voltage < MAX_VOLTAGE - VOLTAGE_STEP:
+        voltage += VOLTAGE_STEP
+        yield diff, voltage
 
 
 def _measure_voltage_differential(
@@ -127,48 +129,52 @@ def _measure_voltage_differential(
     # write to DAC channel
     for channel, write_voltage in write_voltages.items():
         dac.write_voltage(channel, write_voltage)
-
+        write_volt = write_voltage
+    sleep(WRITE_READ_DELAY)
     for _ in range(READS_PER_WRITE):
         read_voltage = adc.read_voltage(adc_num)
         _logger.info(f"diff_read_voltage = {read_voltage}")
-        _assert_approx(0, read_voltage, RW_ERROR)
+        _assert_approx(write_volt/2, read_voltage, RW_ERROR)
 
 
 _diff_ch_map = {
-    AnalogIn.AIN1: DACChannel.AOUT1,
-    AnalogIn.AIN2: DACChannel.AOUT2,
-    AnalogIn.AIN3: DACChannel.AOUT3,
-    AnalogIn.AIN4: DACChannel.AOUT4,
-    AnalogIn.AIN5: DACChannel.AOUT5,
-    AnalogIn.AIN6: DACChannel.AOUT6,
-    AnalogIn.AIN7: DACChannel.AOUT7,
-    AnalogIn.AIN8: DACChannel.AOUT8,
+    ADCChannel.AIN0: DACChannel.AOUT1,
+    ADCChannel.AIN1: DACChannel.AOUT2,
+    ADCChannel.AIN2: DACChannel.AOUT3,
+    ADCChannel.AIN3: DACChannel.AOUT4,
+    ADCChannel.AIN4: DACChannel.AOUT5,
+    ADCChannel.AIN5: DACChannel.AOUT6,
+    ADCChannel.AIN6: DACChannel.AOUT7,
+    ADCChannel.AIN7: DACChannel.AOUT8,
 }
 
 
-@pytest.mark.parametrize("diff, mux_p_volt, mux_n_volt", _generate_diff_test_cases())
-def test_differential_rw_adc_1(diff, mux_p_volt, mux_n_volt, adc_1, dac):
+@pytest.mark.parametrize("diff, mux_p_volt", _generate_diff_test_cases())
+def test_differential_rw_adc_1(diff, mux_p_volt, adc_1, dac):
     adc_1.select_differential(ADCNum.ADC_1, diff)
+    adc_1.start_conversions(ADCNum.ADC_1)
     _logger.info(
         f"voltage read/write diff pair: mux_p = {diff.value.mux_p}, mux_n = {diff.value.mux_n}"
         )
-    _logger.info(f"mux_p_write_voltage = {mux_p_volt}, mux_n_write_voltage = {mux_n_volt}")
+    _logger.info(f"mux_p_write_voltage = {mux_p_volt}")
     write_voltages = {
-        _diff_ch_map[diff.value.mux_p]: mux_p_volt,
-        _diff_ch_map[diff.value.mux_n]: mux_n_volt,
+        _diff_ch_map[diff.value.mux_p]: mux_p_volt
     }
     _measure_voltage_differential(adc_1, dac, ADCNum.ADC_1, write_voltages)
+    adc_1.stop_conversions(ADCNum.ADC_1)
+
 
 
-@pytest.mark.parametrize("diff, mux_p_volt, mux_n_volt", _generate_diff_test_cases())
-def test_differential_rw_adc_2(diff, mux_p_volt, mux_n_volt, adc_2, dac):
+@pytest.mark.parametrize("diff, mux_p_volt", _generate_diff_test_cases())
+def test_differential_rw_adc_2(diff, mux_p_volt, adc_2, dac):
     adc_2.select_differential(ADCNum.ADC_2, diff)
+    adc_2.start_conversions(ADCNum.ADC_2)
     _logger.info(
         f"voltage read/write diff pair: mux_p = {diff.value.mux_p}, mux_n = {diff.value.mux_n}"
         )
-    _logger.info(f"mux_p_write_voltage = {mux_p_volt}, mux_n_write_voltage = {mux_n_volt}")
+    _logger.info(f"mux_p_write_voltage = {mux_p_volt}")
     write_voltages = {
-        _diff_ch_map[diff.value.mux_p]: mux_p_volt,
-        _diff_ch_map[diff.value.mux_n]: mux_n_volt,
+        _diff_ch_map[diff.value.mux_p]: mux_p_volt
     }
     _measure_voltage_differential(adc_2, dac, ADCNum.ADC_2, write_voltages)
+    adc_2.stop_conversions(ADCNum.ADC_2)