hil-unity-checks.yml

name: Hil unity library checks

# on which event should we start push, pull request or schedule dispatches
on:
  - push

env:
  TEST_VERSION: 1.0.0

permissions:
  contents: write

# This template runes multiple workflows
jobs:


  #############################################################################
  # This action sets common variables for the flow and
  # identifies the libs to compile
  setup:

    # we run this on self hosted runner, use labels to be more specific
    # add specific names if there are some, otherwise self-hosted, X64, Linux are the default ones
    runs-on:
      - self-hosted
      - X64
      - Linux

    steps:
      # checkout the latest github action code
      - name: Checkout actions
        uses: actions/checkout@v4
        with:
          token: ${{ secrets.UNITY_TOKEN }}
          submodules: recursive

      # checkout the latest arduino-cli compiler
      - name: Setup Arduino CLI
        uses: arduino/setup-arduino-cli@master

      # Update the arduino code. Attention this does not setup XMC packages as this are set inside the self hosted runner
      # the arduino board support packages can be updated automatically
      # the XMC board support package is only linked inside the self hosted runner, which allows
      # to use none official and beta versions
      # arduino-cli core install "infineon:xmc"
      - name: Install/Update Arduino Platform
        run: |
          arduino-cli core update-index
          arduino-cli core install "arduino:avr"

      # Fetch variables and move them to the GITHUB_OUTPUT and fetch HIL information
      - id: startup
        run: |
          # switch on the HIL
          cd /opt/runner_support/
          REPO="$(basename "$GITHUB_REPOSITORY")"
          ./py_checkusb.py --switch repo --namelist $REPO --onoff on

          # set the hil-unity-checks
          hil=$(./py_checkusb.py --readyaml $GITHUB_WORKSPACE/tests/unity/hil-unity-checklist.yaml --json)
          echo "hil=${hil}" >> $GITHUB_OUTPUT

          # fetch unity libraries
          readarray -t data < <(echo $hil | jq -r '.|keys[]')
          export dev=$(jq --compact-output --null-input '$ARGS.positional' --args -- "${data[@]}")
          echo "devices=${dev}" >> $GITHUB_OUTPUT
          echo "devices=${dev}"

    # Connect the GITHUB_OUTPUT to the variables and the workflow output mechanism
    outputs:
      hil: ${{ steps.startup.outputs.hil }}
      devices: ${{ steps.startup.outputs.devices }}


  #############################################################################
  # This step allows HIL (Hardware in the loop), therefore
  # is searches for the given board/sensor combination and tries to find the actual port
  # on the self hosted runner. (see documentation for the board2port finder)
  flash:

    # We need a successful build before we can run the deploy
    needs: [setup]
    
    # we run this on self hosted runner, use labels to be more specific
    # add specific names if there are some, otherwise self-hosted, X64, Linux are the default ones
    runs-on:
      - self-hosted
      - X64
      - Linux

    # do not stop if a single job fails
    continue-on-error: true

    strategy:

      # the code to flash
      matrix:
        # the serials of the hardware boards
        device: ${{ fromJson(needs.setup.outputs.devices) }}

    # These are the steps which should run for each combination of fqbn and lib code
    steps:
      # checkout the latest github action code
      - name: Checkout actions
        uses: actions/checkout@v4

      # setup environment
      - name: Environment
        run: |
          cd $HOME
          rm -rf ~/.arduino15/packages/Infineon/hardware/xmc/*
          ln -s $GITHUB_WORKSPACE ~/.arduino15/packages/Infineon/hardware/xmc/$TEST_VERSION

          hil=${{ toJson(needs.setup.outputs.hil) }}
          REPO="$(basename "$GITHUB_REPOSITORY")"
          DEVICE="$(basename ${{ matrix.device }} )"
          LIBRARY=$(echo $hil | jq ".\"${DEVICE}\"" -r --compact-output)
          FQBN=`tr '.' ':' <<<"${DEVICE}"`

          echo "repo=$REPO" >> $GITHUB_ENV
          echo "device=$DEVICE" >> $GITHUB_ENV
          echo "version=$TEST_VERSION" >> $GITHUB_ENV
          echo "library=$LIBRARY" >> $GITHUB_ENV
          echo "fqbn=$FQBN" >> $GITHUB_ENV

          echo "Repo                  " $REPO
          echo "Device                " $DEVICE
          echo "Library               " $LIBRARY
          echo "FQBN                  " $FQBN
          echo "Version               " ${TEST_VERSION}

      # Build the test code with make and flash it to the board
      # runs via nested loops:
      # - first loop over the libraries mentioned for a device in the yaml file
      # - selects the serial ids and ports for all devices connected with this device and library
      # - second loop over the examples mentioned  below the selected device for a library in the yaml file
      # - third loop over the tests mentioned below the selected example for a device and library in the yaml file
      # - fourth loop over the make commands mentioned below the selected test for a device, example and library in the yaml file

      - name: Build
        run: |
          export TMPDIR=$HOME/tmp
          mkdir -p $TMPDIR
          rm -rf $HOME/artefact
          mkdir -p $HOME/artefact

          lib=${{ toJson(env.library) }}
          readarray -t LIBS < <(echo ${lib} | jq ".|keys[]" -r --compact-output)

          # loop over all libs in the unity test yaml
          for LIB in "${LIBS[@]}"; do
            cd /opt/runner_support/
            readarray -t SERIALS < <(echo $(./py_checkusb.py --type ${LIB} --json) | jq ".\"${LIB}\".\"${{ env.device }}\"|keys[]" -r)

            # check if we have one or more serial numbers for this lib or stop here
            if [[ -z $SERIALS ]]; then
              echo "No serial or library information found"
              exit 0
            fi

            # loop over all serials and fetch the ports
            declare -a PORTS
            for SERIAL in "${SERIALS[@]}"; do
              PORTS+=($(/opt/runner_support/find_usb.sh $SERIAL))
            done

            # loop over all examples for one library
            readarray -t EXAMPLES < <(echo $lib | jq ".\"${LIB}\"|keys[]" -r --compact-output)
            for EXAMPLE in "${EXAMPLES[@]}"; do
              echo "=============================================================================================================="
              echo "Run for EXAMPLE: ${EXAMPLE} under LIB: ${LIB}"
              echo "=============================================================================================================="

              # loop over all tests for one example and compile7flash the devices
              readarray -t TESTS < <(echo $lib | jq ".\"${LIB}\".\"${EXAMPLE}\"[]" -r --compact-output)
              for ((idx=0; idx<${#TESTS[@]}; ++idx)); do
                cd $GITHUB_WORKSPACE/tests/unity/
                echo "=============================================================================================================="
                echo "Run on index $idx for TEST: ${TESTS[idx]} under EXAMPLE: ${EXAMPLE} and LIB: ${LIB}"
                echo "=============================================================================================================="
                make FQBN=${{ env.fqbn }} PORT=${PORTS[idx]} UNITY_PATH=/opt/runner_support/Unity_github ${TESTS[idx]}
                mkdir -p ~/artefact/${LIB}/${EXAMPLE}/${TESTS[idx]}/
                mv ./build/build/* ~/artefact/${LIB}/${EXAMPLE}/${TESTS[idx]}/.
                echo "=============================================================================================================="
              done # end of TEST loop flash

              # loop over all tests for one example and monitor the serial output
              for ((idx=0; idx<${#TESTS[@]}; ++idx)); do
                echo "=============================================================================================================="
                echo "Monitor on index $idx for TEST: ${TESTS[idx]} under EXAMPLE: ${EXAMPLE} and LIB: ${LIB}"
                timeout 1m \
                        /opt/runner_support/py_console.py \
                          --port ${PORTS[idx]} \
                          --baud 115200 \
                          --report ~/artefact/${LIB}/${EXAMPLE}/${TESTS[idx]}/${{ env.device }}/report.json
                
                echo "=============================================================================================================="
              done # end of TEST loop monitor

            done # end of EXAMPLE loop
          done # end of LIB loop

      # Upload the compiled HEX files to the GitHub server
      - name: Artefact
        uses: actions/upload-artifact@v4
        with:
          name: ${{ env.device }}
          path: ~/artefact/*
          if-no-files-found: ignore


  #############################################################################
  # Switch off the HIL after all tests are done
  post:

    # we run this no matter if before fails
    if: always()
    # wait on first setup run before starting main function
    needs: [setup, flash]

    # we run this on self hosted runner, use labels to be more specific
    # add specific names if there are some, otherwise self-hosted, X64, Linux are the default ones
    runs-on:
      - self-hosted
      - X64
      - Linux

    steps:
      - name: Switch off HIL
        run: |
          cd /opt/runner_support/
          REPO="$(basename "$GITHUB_REPOSITORY")"
          ./py_checkusb.py --switch repo --namelist $REPO --onoff off