Bitstream test

.github/workflows/ports_psoc6.yml

@@ -38,7 +38,7 @@ jobs:
         run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
       - name: Save firmware bin
         if: success() && github.repository_owner == 'infineon'
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with: 
           name: mpy-psoc6_${{ matrix.board }}_${{ steps.commit_sha.outputs.sha_short }}
           path: ports/psoc6/build/firmware.hex
@@ -57,7 +57,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Download binaries
-      uses: actions/download-artifact@v3
+      uses: actions/download-artifact@v4
     - name: Container setup
       run: |
         echo ${{ secrets.SELF_HOSTED_PASSWORD }} | sudo -S chmod 666 /var/run/docker.sock
@@ -83,9 +83,15 @@ jobs:
         ./psoc6/run_psoc6_tests.sh -c --psoc6 --dev0 ${devs[0]} 
     - name: Run psoc6 hardware extended tests
       run: | 
-        devs=($(python tools/psoc6/get-devs.py port -b ${{ matrix.board }} -y tools/psoc6/${{ runner.name }}-devs.yml --hw-ext 0.1.0))
+        devs=($(python tools/psoc6/get-devs.py port -b ${{ matrix.board }} -y tools/psoc6/${{ runner.name }}-devs.yml --hw-ext 0.2.0.a))
         cd tests
         ./psoc6/run_psoc6_tests.sh -c --psoc6-hwext --dev0 ${devs[0]} 
+    - name: Run psoc6 bitstream tests
+      run: | 
+        devs0=($(python tools/psoc6/get-devs.py port -b ${{ matrix.board }} -y tools/psoc6/${{ runner.name }}-devs.yml --hw-ext 0.2.0.a))
+        devs1=($(python tools/psoc6/get-devs.py port -b ${{ matrix.board }} -y tools/psoc6/${{ runner.name }}-devs.yml --hw-ext 0.2.0.b))
+        cd tests
+        ./psoc6/run_psoc6_tests.sh -c -b --dev0 ${devs0[0]} --dev1 ${devs1[0]}
     # TODO: Enable when HIL is upgraded 
     # - name: Run all implemented tests
     #   if:  github.event_name == 'pull_request'

tests/psoc6/bitstream/bitstream_rx.py

@@ -0,0 +1,95 @@
+import os
+import time
+from machine import Pin
+from machine import bitstream
+
+""""
+This script is running together with the bitstream_tx.py test.
+One pin generates a synchronisation signal to inform the transmitter that receiver is ready, and
+another is configured as an input, which is used for receiving the bitstream signals.
+"""
+
+# Allocate pin based on board
+machine = os.uname().machine
+if "CY8CPROTO-062-4343W" in machine:
+    bitstream_in_pin_name = "P12_1"
+    rx_ready_signal_pin_name = "P13_5"
+
+elif "CY8CPROTO-063-BLE" in machine:
+    bitstream_in_pin_name = "P5_2"
+    rx_ready_signal_pin_name = "P6_2"
+
+expected_values = [
+    8000,
+    5000,
+    8000,
+    5000,
+    8000,
+    5000,
+    8000,
+    5000,
+    3000,
+    1000,
+    3000,
+    1000,
+    3000,
+    1000,
+    3000,
+    1000,
+]
+tolerance = 100
+
+
+def notify_readiness_to_tx():
+    rx_ready_signal_pin = Pin(
+        rx_ready_signal_pin_name, Pin.OUT, value=0
+    )  # signal to inform the transmitter that receiver is read
+    rx_ready_signal_pin.low()
+    # delay
+    for i in range(1000):
+        pass
+    rx_ready_signal_pin.high()
+    rx_ready_signal_pin.deinit()
+
+
+def bitstream_rx_measure():
+    global periods
+    periods = []
+    last_value = 0
+    bitstream_in_pin = Pin(bitstream_in_pin_name, Pin.IN)
+    start_time = time.ticks_us()
+    current_value = 0
+
+    for i in range(17):
+        while current_value == last_value:
+            current_value = bitstream_in_pin.value()
+        current_time = time.ticks_us()
+        time_period = time.ticks_diff(current_time, start_time)
+        last_value = current_value
+        start_time = current_time
+        periods.append(time_period)
+
+    bitstream_in_pin.deinit()
+
+
+def validate_bitstream():
+    for i in range(len(periods) - 1):
+        diff = abs(periods[i + 1] - expected_values[i])
+        if diff <= tolerance:
+            print("true")
+        else:
+            print("false")
+            print(
+                "expected :"
+                + str(expected_values[i])
+                + " period: "
+                + str(periods[i + 1])
+                + " diff: "
+                + str(diff)
+            )
+
+
+print("bitstream rx")
+notify_readiness_to_tx()
+bitstream_rx_measure()
+validate_bitstream()

tests/psoc6/bitstream/bitstream_rx.py.exp

@@ -0,0 +1,17 @@
+bitstream rx
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true
+true

tests/psoc6/bitstream/bitstream_tx.py

@@ -0,0 +1,54 @@
+import sys
+import time
+import os
+from machine import Pin
+from machine import bitstream
+
+"""
+This script is running together with the bitstream_rx.py test.
+One pin generates the test bitstream pattern, and another is configured as 
+an input, which is used for synchronization with the receiver.
+"""
+
+# Allocate pin based on board
+machine = os.uname().machine
+if "CY8CPROTO-062-4343W" in machine:
+    bitstream_pin_name = "P12_1"
+    wait_signal_pin_name = "P13_5"
+elif "CY8CPROTO-063-BLE" in machine:
+    bitstream_pin_name = "P5_2"
+    wait_signal_pin_name = "P6_2"
+
+signal_received = False
+
+
+def signal_irq(arg):
+    global signal_received
+    signal_received = True
+
+
+def wait_for_rx_ready():
+    global signal_received
+    wait_signal_pin = Pin(wait_signal_pin_name, Pin.IN)
+    wait_signal_pin.irq(handler=signal_irq, trigger=Pin.IRQ_RISING)
+    while not signal_received:
+        pass
+
+    signal_received = False
+    wait_signal_pin.deinit()
+    # print("rx ready")
+
+
+def send_bitstream():
+    timing = [3000000, 1000000, 8000000, 5000000]
+    buf = bytearray([0xF0])
+    bitstream_pin = Pin(bitstream_pin_name, Pin.OUT, value=0)
+    for i in range(2):
+        bitstream(bitstream_pin, 0, timing, buf)
+
+    bitstream_pin.deinit()
+
+
+# print("bitstream tx")
+wait_for_rx_ready()
+send_bitstream()

tests/psoc6/hw_ext/adc.py

@@ -20,16 +20,11 @@
     adc_pin_mid = "P10_3"
     adc_pin_max = "P10_0"
     adc_wrong_pin_name = "P13_7"
-    # Enable after DUT setup
-    print("SKIP")
-    raise SystemExit
 elif "CY8CPROTO-063-BLE" in machine:
-    adc_pin_gnd = "P10_1"
+    adc_pin_gnd = "P10_2"
     adc_pin_mid = "P10_3"
-    adc_pin_max = "P10_0"
+    adc_pin_max = "P10_4"
     adc_wrong_pin_name = "P13_7"
-    print("SKIP")
-    raise SystemExit
 
 # 0.35V
 tolerance_uv = 350000
@@ -41,22 +36,18 @@
 
 def validate_adc_uv_value(adc_pin, exp_volt, act_volt):
     print(
-        "\nExpected voltage - ",
+        "Expected voltage - ",
         exp_volt,
-        "(uV) on pin ",
-        adc_pin,
-        "is approx same as obtained voltage(uV): ",
+        "(uV) is approx same as obtained voltage(uV): ",
         (exp_volt - tolerance_uv) < act_volt < (exp_volt + tolerance_uv),
     )
 
 
 def validate_adc_raw_value(adc_pin, exp_volt, act_volt):
     print(
-        "\nExpected voltage - ",
+        "Expected voltage - ",
         exp_volt,
-        "(raw) on pin ",
-        adc_pin,
-        "is approx same as obtained voltage(raw): ",
+        "(raw) is approx same as obtained voltage(raw): ",
         (exp_volt - tolerance_raw) < act_volt < (exp_volt + tolerance_raw),
     )
 
@@ -67,30 +58,23 @@ def validate_adc_raw_value(adc_pin, exp_volt, act_volt):
 except:
     print("Invalid ADC Pin\n")
 
-adc0 = ADC(adc_pin_gnd, sample_ns=1000)
-print(adc0)
-
 block = ADCBlock(0, bits=12)
 # ADCBlock.connect(channel)
 adc1 = block.connect(3)
-print("\nADCBlock.connect(channel): ", adc1)
 block.deinit()
-print("ADCBlock.deinit(): ", block)
 
 # ADCBlock.connect(source)
 block = ADCBlock(0, bits=12)
 adc1 = block.connect(adc_pin_mid)
-print("ADCBlock.connect(source): ", adc1)
 block.deinit()
-print("ADCBlock.deinit(): ", block)
+
+adc0 = ADC(adc_pin_gnd, sample_ns=1000)
 
 # ADCBlock.connect(channel,source)
 block = ADCBlock(0, bits=12)
 adc1 = block.connect(3, adc_pin_mid)
-print("ADCBlock.connect(channel,source)", adc1)
 
 adc2 = ADC(adc_pin_max, sample_ns=1000)
-print("\n", adc2)
 
 adc0_value_uv = adc0.read_uv()
 validate_adc_uv_value(adc_pin_gnd, 0, adc0_value_uv)
@@ -108,8 +92,5 @@ def validate_adc_raw_value(adc_pin, exp_volt, act_volt):
 validate_adc_raw_value(adc_pin_max, 32767, adc2_value_raw)
 
 adc0.deinit()
-print("\n", adc0)
 adc1.deinit()
-print(adc1)
 adc2.deinit()
-print(adc2)

tests/psoc6/hw_ext/adc.py.exp

@@ -1,27 +1,8 @@
 Invalid ADC Pin
 
-<ADC Pin=81, ADCBlock_id=0, sampling_time_ns=1000>
-
-ADCBlock.connect(channel):  <ADC Pin=83, ADCBlock_id=0, sampling_time_ns=1000>
-ADCBlock.deinit():  ADCBlock(0, bits=12)
-ADCBlock.connect(source):  <ADC Pin=83, ADCBlock_id=0, sampling_time_ns=1000>
-ADCBlock.deinit():  ADCBlock(0, bits=12)
-ADCBlock.connect(channel,source) <ADC Pin=83, ADCBlock_id=0, sampling_time_ns=1000>
-
- <ADC Pin=80, ADCBlock_id=0, sampling_time_ns=1000>
-
-Expected voltage -  0 (uV) on pin  P10_1 is approx same as obtained voltage(uV):  True
-
-Expected voltage -  0 (raw) on pin  P10_1 is approx same as obtained voltage(raw):  True
-
-Expected voltage -  1650000 (uV) on pin  P10_3 is approx same as obtained voltage(uV):  True
-
-Expected voltage -  16385 (raw) on pin  P10_3 is approx same as obtained voltage(raw):  True
-
-Expected voltage -  3300000 (uV) on pin  P10_0 is approx same as obtained voltage(uV):  True
-
-Expected voltage -  32767 (raw) on pin  P10_0 is approx same as obtained voltage(raw):  True
-
- <ADC Pin=81, ADCBlock_id=0, sampling_time_ns=1000>
-<ADC Pin=83, ADCBlock_id=0, sampling_time_ns=1000>
-<ADC Pin=80, ADCBlock_id=0, sampling_time_ns=1000>
+Expected voltage -  0 (uV) is approx same as obtained voltage(uV):  True
+Expected voltage -  0 (raw) is approx same as obtained voltage(raw):  True
+Expected voltage -  1650000 (uV) is approx same as obtained voltage(uV):  True
+Expected voltage -  16385 (raw) is approx same as obtained voltage(raw):  True
+Expected voltage -  3300000 (uV) is approx same as obtained voltage(uV):  True
+Expected voltage -  32767 (raw) is approx same as obtained voltage(raw):  True