pruio.bas

Go to the documentation of this file.

#DEFINE __PRUIO_COMPILING__

' uio driver header file
#INCLUDE ONCE "pruio_prussdrv.bi"
' driver header file
#INCLUDE ONCE "pruio.bi"
' Header file with convenience macros BBB2x46.
#INCLUDE ONCE "pruio_pins.bi"
' Header file with convenience macros PBB2x36.
#INCLUDE ONCE "pruio_pins_pocket.bi"
' Header file with convenience macros BB_Blue.
#INCLUDE ONCE "pruio_pins_blue.bi"
' Header file with convenience macros SD card slot.
#INCLUDE ONCE "pruio_pins_sd.bi"
' Header file with Pru_Init instructions.
#INCLUDE ONCE "pasm_init.bi"
' Header file with Pru_Run instructions.
#INCLUDE ONCE "pasm_run.bi"
' FB include
#INCLUDE ONCE "dir.bi"


#DEFINE PMUX_NAME "pruio-"

#DEFINE PMUX_ERRR 258

#DEFINE ArrayBytes(_A_) (UBOUND(_A_) + 1) * SIZEOF(_A_(0))


DECLARE FUNCTION memcpy CDECL ALIAS "memcpy"(BYVAL AS ANY PTR, BYVAL AS ANY PTR, BYVAL AS ULONG /'size_t'/) AS ANY PTR

' private functions from pruio_prussdrv.bas
DECLARE FUNCTION setPin_save CDECL( _
    BYVAL AS Pruio_ PTR _
  , BYVAL AS UInt8 _
  , BYVAL AS UInt8) AS ZSTRING PTR
DECLARE FUNCTION setPin_lkm_bb CDECL( _
    BYVAL AS Pruio_ PTR _
  , BYVAL AS UInt8 _
  , BYVAL AS UInt8) AS ZSTRING PTR
DECLARE FUNCTION setPin_lkm CDECL( _
    BYVAL AS Pruio_ PTR _
  , BYVAL AS UInt8 _
  , BYVAL AS UInt8) AS ZSTRING PTR
DECLARE FUNCTION setPin_dtbo CDECL( _
    BYVAL AS Pruio_ PTR _
  , BYVAL AS UInt8 _
  , BYVAL AS UInt8) AS ZSTRING PTR
DECLARE FUNCTION setPin_nogo CDECL( _
    BYVAL AS Pruio_ PTR _
  , BYVAL AS UInt8 _
  , BYVAL AS UInt8) AS ZSTRING PTR


CONSTRUCTOR PruIo( _
    BYVAL Act AS UInt16 = PRUIO_DEF_ACTIVE _
  , BYVAL  Av AS UInt8  = PRUIO_DEF_AVRAGE _
  , BYVAL OpD AS UInt32 = PRUIO_DEF_ODELAY _
  , BYVAL SaD AS UInt8  = PRUIO_DEF_SDELAY)
  VAR fnr = FREEFILE '                             test interrupt access
  IF OPEN("/dev/uio5" FOR OUTPUT AS fnr) THEN _
                      Errr = @"cannot open /dev/uio5" : EXIT CONSTRUCTOR
  CLOSE #fnr

  STATIC AS STRING mux, bbb '   check for BB type and pinmuxing features
  IF 0 = OPEN("/proc/device-tree/model" FOR INPUT AS fnr) THEN
    LINE INPUT #fnr, bbb
    'IF bbb = "TI_AM335x_PocketBeagle" THEN BbType = PBB2x36
    'IF bbb = "TI AM335x BeagleBone Blue" THEN BbType = BB_Blue
    IF INSTR(bbb, "Pocket") THEN BbType = PBB2x36
    IF INSTR(bbb, "Blue") THEN BbType = BB_Blue
    CLOSE #fnr
  END IF

  IF 0 = OPEN("/sys/devices/platform/libpruio/state" FOR OUTPUT AS fnr) THEN
    IF Act AND PRUIO_ACT_FREMUX THEN
      setPin = IIF(BbType, @setPin_lkm(), @setPin_lkm_bb())
    ELSE
      setPin = @setPin_save()
      Errr = setPin(@THIS, 255, 0)
      IF Errr THEN CLOSE #fnr : setPin = @setPin_nogo() : fnr = 0
    END IF : MuxFnr = fnr
  END IF
  IF 0 = MuxFnr THEN '       no LKM, test old style device tree overlays
    VAR p = "/sys/devices/" _
      , n = DIR(p & "ocp.*", fbDirectory)
    IF LEN(n) THEN ' old kernel 3.x
      mux = p & n & "/" & PMUX_NAME : MuxFnr = 256
    ELSE ' new kernel 4.x
      p &= "platform/ocp/ocp:"
      IF LEN(DIR(p & "pruio-*", fbDirectory)) THEN mux = p & PMUX_NAME : MuxFnr = 257
    END IF
    IF MuxFnr THEN setPin = @setPin_dtbo() : MuxAcc = SADD(mux) : Errr = 0 _
              ELSE setPin = @setPin_nogo()
  END IF

  IF Act AND PRUIO_ACT_PRU1 THEN
    PruIntNo = ARM_PRU1_INTERRUPT
     PruIRam = PRUSS0_PRU1_IRAM
     PruDRam = PRUSS0_PRU1_DRAM
       PruNo = PRU1
  ELSE
    PruIntNo = ARM_PRU1_INTERRUPT
     PruIRam = PRUSS0_PRU0_IRAM
     PruDRam = PRUSS0_PRU0_DRAM
       PruNo = PRU0
  END IF
  IF prussdrv_open(PRUIO_EVNT) THEN _  '              open PRU Interrupt
                  Errr = @"failed opening PRUIO_EVNT" : EXIT CONSTRUCTOR

  prussdrv_map_prumem(PruDRam, CAST(ANY PTR, @DRam))
  prussdrv_map_extmem(@ERam)
  ESize = prussdrv_extmem_sIze()
  EAddr = prussdrv_get_phys_addr(ERam)

  prussdrv_pru_disable(PruNo) '          disable PRU (if running before)
  DRam[0] = 0
  DRam[1] = PRUIO_DAT_ALL '                          start of data block
  ParOffs = 1
  DevAct = Act

' order must match the order in
'   pruio_init.p xxx_Init and in
'   pruio_run.p  xxx_Config macro calls
'& AdcUdt::AdcUdt(); GpioUdt::GpioUdt(); PwmssUdt::PwmssUdt(); TimerUdt::TimerUdt(); /*
  Adc = NEW AdcUdt(@THIS)
  Gpio = NEW GpioUdt(@THIS)

  VAR offs = ParOffs
  ParOffs += 1 : DRam[ParOffs] = &h44E10800 '           pinmux registers

  PwmSS = NEW PwmssUdt(@THIS)
  TimSS = NEW TimerUdt(@THIS)

  ASSERT(ParOffs < DRam[1] SHR 4)
  VAR l = ArrayBytes(Pru_Init)
  IF 0 >= prussdrv_pru_write_memory(PruIRam, 0, @Pru_Init(0), l) THEN _
       Errr = @"failed loading Pru_Init instructions" : EXIT CONSTRUCTOR
  prussdrv_pruintc_init(IntcInit) '          get interrupts initialized
  prussdrv_pru_enable(PruNo)

  Pwm = NEW PwmMod(@THIS)
  Cap = NEW CapMod(@THIS)
  Qep = NEW QepMod(@THIS)
'& */ PwmMod::PwmMod(); CapMod::CapMod(); QepMod::QepMod();
  Tim = TimSS ' redundant, but consistent API for the user

  prussdrv_pru_wait_event(PRUIO_EVNT)
  IF DRam[0] <> PRUIO_MSG_INIT_OK THEN _
     Errr = @"failed executing Pru_Init instructions" : EXIT CONSTRUCTOR

  DSize = DRam[ParOffs] - DRam[1]
  DInit = ALLOCATE(DSize * 2)
  IF 0 = DInit THEN           Errr = @"out of memory" : EXIT CONSTRUCTOR

  MOffs = DInit - DRam[1]
  DConf = DInit + DSize
  VAR p0 = CAST(ANY PTR, DRam) + DRam[1]
  memcpy(DInit, p0, DSize)
  memcpy(DConf, p0, DSize)

  Init = MOffs + DRam[offs]
  Conf = CAST(ANY PTR, Init) + DSize
  BallInit = CAST(ANY PTR, Init) + OFFSETOF(BallSet, Value(0))
  BallConf = BallInit + DSize ' initialize invalid:
  FOR b AS INTEGER = 0 TO PRUIO_AZ_BALL : BallConf[b] OR= &b11000 : NEXT

  IF Adc->initialize(Av, OpD, SaD) THEN                 EXIT CONSTRUCTOR
  IF Gpio->initialize() THEN                            EXIT CONSTRUCTOR
  IF PwmSS->initialize() THEN                           EXIT CONSTRUCTOR
  IF TimSS->initialize() THEN                           EXIT CONSTRUCTOR
  '& AdcUdt::initialize(); GpioUdt::initialize(); PwmssUdt::initialize(); TimerUdt::initialize();
END CONSTRUCTOR



DESTRUCTOR PruIo()
  VAR mux = "" : Errr = 0
  IF DRam THEN
    IF DInit THEN
      IF MuxFnr THEN '                                  pinmuxing active
        IF BallInit <> BallConf THEN '                   reset pinmuxing
          FOR i AS INTEGER = 0 TO PRUIO_AZ_BALL
            IF (BallConf[i] AND &b11000) = &b11000 THEN CONTINUE FOR ' untouched
            IF (BallConf[i] XOR BallInit[i]) AND &b1111111 THEN _ '    re-mux
              IF setPin(@THIS, i, BallInit[i]) THEN mux &= _ '         error
                  !"\nre-mux " _
                & BIN(BallConf[i], 7) & " -> " & BIN(BallInit[i], 7) _
                & " failed (" & *Errr & ")"
          NEXT
        END IF : Errr = 0
        IF MuxFnr < 256 THEN CLOSE #MuxFnr '               close MuxFile
      END IF
      prussdrv_pru_disable(PruNo)

      DRam[2] = 0
      DRam[1] = PRUIO_DAT_ALL '           reset subsystems configuration
      memcpy(CAST(ANY PTR, DRam) + DRam[1], DInit, DSize)
      DEALLOCATE(DInit)

      VAR l = ArrayBytes(Pru_Run)
      IF 0 >= prussdrv_pru_write_memory(PruIRam, 0, @Pru_Run(0), l) THEN
                          Errr = @"failed loading Pru_Exit instructions"
      ELSE
        prussdrv_pruintc_init(IntcInit) '     get interrupt initialized
        prussdrv_pru_enable(PruNo)
        prussdrv_pru_wait_event(PRUIO_EVNT)
        IF DRam[0] <> PRUIO_MSG_CONF_OK THEN _
                        Errr = @"failed executing Pru_Exit instructions"
      END IF
    ELSE
               Errr = @"destructor warning: subsystems are NOT restored"
    END IF
    prussdrv_pru_disable(PruNo)
    prussdrv_exit() '                                     power down PRU
  ELSE
                        Errr = @"destructor warning: constructor failed"
  END IF

  IF Errr THEN mux &= !"\n" & *Errr
  IF LEN(mux) THEN _
    VAR fnr = FREEFILE : OPEN ERR AS fnr : PRINT #fnr, MID(mux, 2) : CLOSE #fnr
END DESTRUCTOR



FUNCTION PruIo.config CDECL( _
    BYVAL Samp AS UInt32 = PRUIO_DEF_SAMPLS _
  , BYVAL Mask AS UInt32 = PRUIO_DEF_STPMSK _
  , BYVAL  Tmr AS UInt32 = PRUIO_DEF_TIMERV _
  , BYVAL  Mds AS UInt16 = PRUIO_DEF_LSLMOD) AS ZSTRING PTR

  prussdrv_pru_disable(PruNo) '                              disable PRU
  IF Adc->configure(Samp, Mask, Tmr, Mds)                    THEN RETURN Errr

  DRam[1] = PRUIO_DAT_ALL
  memcpy(CAST(ANY PTR, DRam) + DRam[1], DConf, DSize)

  VAR l = ArrayBytes(Pru_Run)
  IF 0 >= prussdrv_pru_write_memory(PruIRam, 0, @Pru_Run(0), l) THEN _
                  Errr = @"failed loading Pru_Run instructions" : RETURN Errr
  prussdrv_pruintc_init(IntcInit) '           get interrupt initialized
  prussdrv_pru_enable(PruNo)
  prussdrv_pru_wait_event(PRUIO_EVNT)
  SELECT CASE AS CONST Samp
  CASE 0    : l = DRam[0] <> PRUIO_MSG_CONF_OK
  CASE 1    : l = DRam[0] <> PRUIO_MSG_IO_OK
  CASE ELSE : l = DRam[0] <> PRUIO_MSG_MM_WAIT
  END SELECT
  IF l THEN     Errr = @"failed executing Pru_Run instructions" : RETURN Errr
  IF Samp < 2                                                THEN RETURN 0

  prussdrv_pru_clear_event(PRUIO_EVNT, PRUIO_IRPT)
  prussdrv_pru_send_event(PruIntNo) '              prepare fast MM start
                                                                  RETURN 0
END FUNCTION



FUNCTION PruIo.Pin CDECL( _
  BYVAL Ball AS UInt8, _
  BYVAL Mo AS UInt8 = 1) AS ZSTRING PTR
  STATIC AS STRING*50 t

  VAR x = nameBall(Ball)
  IF x THEN
    t = *x
  ELSE
    IF Ball > PRUIO_AZ_BALL THEN   Errr = @"unknown pin number" : RETURN Errr
    t = "b " & RIGHT("00" & Ball, 3)
  END IF

  VAR r = IIF(Mo, BallConf[Ball], BallInit[Ball]) _
    , m = r AND &b111
  IF m = 7 THEN
    VAR i = BallGpio(Ball) SHR 5 _
      , n = BallGpio(Ball) AND 31 _
      , m = 1 SHL n
    t &= ", GPIO " & i & "/" & RIGHT("0" & n, 2)
    IF BIT(r, 5) THEN
      t &= ": input"
    ELSE
      WITH *IIF(Mo, Gpio->Conf(i), Gpio->Init(i))
        t &= ": output-" & *IIF((.DATAOUT OR .SETDATAOUT) AND m, @"1", @"0")
      END WITH
    END IF
  ELSE
    t &= ", mode " & m _
      & ": input " & *IIF(BIT(r, 5), @"enabled", @"disabled")
  END IF

  IF BIT(r, 3) THEN
    t &= ", nopull"
  ELSE
    IF BIT(r, 4) THEN t &= ", pullup" ELSE t &= ", pulldown"
  END IF                                                        : RETURN SADD(t)
END FUNCTION



#MACRO BB_NAMES()
  CASE P8_03 : RETURN @"P8_03"
  CASE P8_04 : RETURN @"P8_04"
  CASE P8_05 : RETURN @"P8_05"
  CASE P8_06 : RETURN @"P8_06"
  CASE P8_07 : RETURN @"P8_07"
  CASE P8_08 : RETURN @"P8_08"
  CASE P8_09 : RETURN @"P8_09"
  CASE P8_10 : RETURN @"P8_10"
  CASE P8_11 : RETURN @"P8_11"
  CASE P8_12 : RETURN @"P8_12"
  CASE P8_13 : RETURN @"P8_13"
  CASE P8_14 : RETURN @"P8_14"
  CASE P8_15 : RETURN @"P8_15"
  CASE P8_16 : RETURN @"P8_16"
  CASE P8_17 : RETURN @"P8_17"
  CASE P8_18 : RETURN @"P8_18"
  CASE P8_19 : RETURN @"P8_19"
  CASE P8_20 : RETURN @"P8_20"
  CASE P8_21 : RETURN @"P8_21"
  CASE P8_22 : RETURN @"P8_22"
  CASE P8_23 : RETURN @"P8_23"
  CASE P8_24 : RETURN @"P8_24"
  CASE P8_25 : RETURN @"P8_25"
  CASE P8_26 : RETURN @"P8_26"
  CASE P8_27 : RETURN @"P8_27"
  CASE P8_28 : RETURN @"P8_28"
  CASE P8_29 : RETURN @"P8_29"
  CASE P8_30 : RETURN @"P8_30"
  CASE P8_31 : RETURN @"P8_31"
  CASE P8_32 : RETURN @"P8_32"
  CASE P8_33 : RETURN @"P8_33"
  CASE P8_34 : RETURN @"P8_34"
  CASE P8_35 : RETURN @"P8_35"
  CASE P8_36 : RETURN @"P8_36"
  CASE P8_37 : RETURN @"P8_37"
  CASE P8_38 : RETURN @"P8_38"
  CASE P8_39 : RETURN @"P8_39"
  CASE P8_40 : RETURN @"P8_40"
  CASE P8_41 : RETURN @"P8_41"
  CASE P8_42 : RETURN @"P8_42"
  CASE P8_43 : RETURN @"P8_43"
  CASE P8_44 : RETURN @"P8_44"
  CASE P8_45 : RETURN @"P8_45"
  CASE P8_46 : RETURN @"P8_46"
  CASE P9_11 : RETURN @"P9_11"
  CASE P9_12 : RETURN @"P9_12"
  CASE P9_13 : RETURN @"P9_13"
  CASE P9_14 : RETURN @"P9_14"
  CASE P9_15 : RETURN @"P9_15"
  CASE P9_16 : RETURN @"P9_16"
  CASE P9_17 : RETURN @"P9_17"
  CASE P9_18 : RETURN @"P9_18"
  CASE P9_19 : RETURN @"P9_19"
  CASE P9_20 : RETURN @"P9_20"
  CASE P9_21 : RETURN @"P9_21"
  CASE P9_22 : RETURN @"P9_22"
  CASE P9_23 : RETURN @"P9_23"
  CASE P9_24 : RETURN @"P9_24"
  CASE P9_25 : RETURN @"P9_25"
  CASE P9_26 : RETURN @"P9_26"
  CASE P9_27 : RETURN @"P9_27"
  CASE P9_28 : RETURN @"P9_28"
  CASE P9_29 : RETURN @"P9_29"
  CASE P9_30 : RETURN @"P9_30"
  CASE P9_31 : RETURN @"P9_31"
  CASE P9_41 : RETURN @"P9_41"
  CASE  106  : RETURN @"P9_41"
  CASE P9_42 : RETURN @"P9_42"
  CASE  104  : RETURN @"P9_42"
  CASE JT_04 : RETURN @"JT_04"
  CASE JT_05 : RETURN @"JT_05"
#ENDMACRO



#MACRO BLUE_NAMES()
  CASE E1_3   : RETURN @"E1_3"
  CASE E1_4   : RETURN @"E1_4"
  CASE E2_3   : RETURN @"E2_3"
  CASE E2_4   : RETURN @"E2_4"
  CASE E3_3   : RETURN @"E3_3"
  CASE E3_4   : RETURN @"E3_4"
  CASE E4_3   : RETURN @"E4_3"
  CASE E4_4   : RETURN @"E4_4"
  CASE UT0_3  : RETURN @"UT0_3"
  CASE UT0_4  : RETURN @"UT0_4"
  CASE UT1_3  : RETURN @"UT1_3"
  CASE UT1_4  : RETURN @"UT1_4"
  CASE UT5_3  : RETURN @"UT5_3"
  CASE UT5_4  : RETURN @"UT5_4"
  CASE DSM2_3 : RETURN @"DSM2_3"
  CASE GP0_3  : RETURN @"GP0_3"
  CASE GP0_4  : RETURN @"GP0_4"
  CASE GP0_5  : RETURN @"GP0_5"
  CASE GP0_6  : RETURN @"GP0_6"
  CASE GP1_3  : RETURN @"GP1_3"
  CASE GP1_4  : RETURN @"GP1_4"
  CASE GP1_5  : RETURN @"GP1_5"
  CASE GP1_6  : RETURN @"GP1_6"
  CASE GPS_3  : RETURN @"GPS_3"
  CASE GPS_4  : RETURN @"GPS_4"
  CASE SPI1_3 : RETURN @"SPI1_3"
  CASE SPI1_4 : RETURN @"SPI1_4"
  CASE SPI1_5 : RETURN @"SPI1_5"
  CASE SPI1_6 : RETURN @"SPI1_6"
  CASE SPI2_6 : RETURN @"SPI2_6"
#ENDMACRO



#MACRO POCKET_NAMES()
  CASE P1_02 : RETURN @"P1_02"
  CASE P1_04 : RETURN @"P1_04"
  CASE P1_06 : RETURN @"P1_06"
  CASE P1_08 : RETURN @"P1_08"
  CASE P1_10 : RETURN @"P1_10"
  CASE P1_12 : RETURN @"P1_12"
  CASE P1_20 : RETURN @"P1_20"
  CASE P1_26 : RETURN @"P1_26"
  CASE P1_28 : RETURN @"P1_28"
  CASE P1_29 : RETURN @"P1_29"
  CASE P1_30 : RETURN @"P1_30"
  CASE P1_31 : RETURN @"P1_31"
  CASE P1_32 : RETURN @"P1_32"
  CASE P1_33 : RETURN @"P1_33"
  CASE P1_34 : RETURN @"P1_34"
  CASE P1_35 : RETURN @"P1_35"
  CASE P1_36 : RETURN @"P1_36"
  CASE P2_01 : RETURN @"P2_01"
  CASE P2_02 : RETURN @"P2_02"
  CASE P2_03 : RETURN @"P2_03"
  CASE P2_04 : RETURN @"P2_04"
  CASE P2_05 : RETURN @"P2_05"
  CASE P2_06 : RETURN @"P2_06"
  CASE P2_07 : RETURN @"P2_07"
  CASE P2_08 : RETURN @"P2_08"
  CASE P2_09 : RETURN @"P2_09"
  CASE P2_10 : RETURN @"P2_10"
  CASE P2_11 : RETURN @"P2_11"
  CASE P2_17 : RETURN @"P2_17"
  CASE P2_18 : RETURN @"P2_18"
  CASE P2_19 : RETURN @"P2_19"
  CASE P2_20 : RETURN @"P2_20"
  CASE P2_22 : RETURN @"P2_22"
  CASE P2_24 : RETURN @"P2_24"
  CASE P2_25 : RETURN @"P2_25"
  CASE P2_27 : RETURN @"P2_27"
  CASE P2_28 : RETURN @"P2_28"
  CASE P2_29 : RETURN @"P2_29"
  CASE P2_30 : RETURN @"P2_30"
  CASE P2_31 : RETURN @"P2_31"
  CASE P2_32 : RETURN @"P2_32"
  CASE P2_33 : RETURN @"P2_33"
  CASE P2_34 : RETURN @"P2_34"
  CASE P2_35 : RETURN @"P2_35"
#ENDMACRO



FUNCTION PruIo.nameBall CDECL(BYVAL Ball AS UInt8) AS ZSTRING PTR
  SELECT CASE AS CONST BbType '                               find model
  CASE PBB2x36
    SELECT CASE AS CONST Ball ' 2x36 headers (Pocket)
    POCKET_NAMES()
    END SELECT
  CASE BB_Blue
    SELECT CASE AS CONST Ball ' connectors (Blue)
    BLUE_NAMES()
    END SELECT
  CASE ELSE
    SELECT CASE AS CONST Ball ' 2x46 headers (Black, Green, White)
    BB_NAMES()
    END SELECT
  END SELECT
  SELECT CASE AS CONST Ball
  CASE SD_01 : RETURN @"SD_01"
  CASE SD_02 : RETURN @"SD_02"
  CASE SD_03 : RETURN @"SD_03"
  CASE SD_05 : RETURN @"SD_05"
  CASE SD_07 : RETURN @"SD_07"
  CASE SD_08 : RETURN @"SD_08"
  CASE SD_10 : RETURN @"SD_10"
  END SELECT : RETURN 0
END FUNCTION



FUNCTION PruIo.rb_start CDECL() AS ZSTRING PTR
  IF DRam[0] <> PRUIO_MSG_MM_WAIT THEN _
                      Errr = @"ring buffer mode not ready" : RETURN Errr

  DRam[1] = Adc->Samples SHL 1 ' size of ring buffer
  DRam[2] = EAddr
  DRam[3] = 0
  DRam[4] = 1 SHL 4

  prussdrv_pru_clear_event(PRUIO_EVNT, PruIntNo) '             off we go
  RETURN 0
END FUNCTION



FUNCTION PruIo.mm_start CDECL( _
    BYVAL Trg1 AS UInt32 = 0 _
  , BYVAL Trg2 AS UInt32 = 0 _
  , BYVAL Trg3 AS UInt32 = 0 _
  , BYVAL Trg4 AS UInt32 = 0) AS ZSTRING PTR

    IF DRam[0] <> PRUIO_MSG_MM_WAIT THEN _
                           Errr = @"measurement mode not ready" : RETURN Errr

    STATIC AS UInt32 tmin = (1 SHL 22), t_pin
    DRam[3] = 0

'#DEFINE PRUIO_PRE_TRIG(_T_) Trg##_T_ >= tmin ANDALSO (Trg##_T_ AND (1 SHL 4)) THEN : _
#DEFINE PRUIO_PRE_TRIG(_T_) Trg##_T_ >= tmin ANDALSO (Trg##_T_ AND (&b10000)) THEN : _
  IF BIT(Trg##_T_, 5) ORELSE BIT(Adc->Conf->STEPENABLE, (Trg##_T_ AND &b1111) + 1) THEN : _
    VAR n = (Trg##_T_ SHR 22) * Adc->ChAz : _
    IF n < Adc->Samples THEN : DRam[3] = n SHL 1 : _
    ELSE :  Errr = @"Trg" #_T_ ": too much pre-trigger samples" : RETURN Errr : _
    END IF : _
  ELSE : Errr = @"Trg" #_T_ ": pre-trigger step must be active" : RETURN Errr : _
  END IF

#DEFINE PRUIO_GPIO_TRIG(_T_) BIT(Trg##_T_, 21) THEN : _
    t_pin = (Trg##_T_ SHR 8) AND &b1111111 : _
    IF t_pin > PRUIO_AZ_BALL THEN _
              Errr = @"Trg" #_T_ ": unknown trigger pin number" : RETURN Errr : _
    END IF : _
    IF &b111 <> (BallConf[t_pin] AND &b111) THEN _
    Errr = @"Trg" #_T_ ": trigger pin must be in mode 7 (GPIO)" : RETURN Errr : _
    ELSE Trg##_T_ AND= &b11111111111100000000000011111111uL : _
         Trg##_T_  OR= BallGpio(t_pin) SHL 8 : _
    END IF : _
  END IF

  IF Trg1 THEN
    IF PRUIO_PRE_TRIG(1)
    ELSE
      IF PRUIO_GPIO_TRIG(1)
      IF Trg2 THEN
        IF PRUIO_PRE_TRIG(2)
        ELSE
          IF PRUIO_GPIO_TRIG(2)
          IF Trg3 THEN
            IF PRUIO_PRE_TRIG(3)
            ELSE
              IF PRUIO_GPIO_TRIG(3)
              IF Trg4 THEN
                IF PRUIO_PRE_TRIG(4)
                ELSE
                  IF PRUIO_GPIO_TRIG(4)
                END IF
              END IF
            END IF
          END IF
        END IF
      END IF
    END IF
  END IF

  DRam[1] = ESize
  DRam[2] = EAddr
  DRam[4] = Trg1
  DRam[5] = Trg2
  DRam[6] = Trg3
  DRam[7] = Trg4

  prussdrv_pru_clear_event(PRUIO_EVNT, PruIntNo) '           off we go

  prussdrv_pru_wait_event(PRUIO_EVNT) '      wait for end of measurement
  prussdrv_pru_clear_event(PRUIO_EVNT, PRUIO_IRPT) '     clear interrupt
  prussdrv_pru_send_event(PruIntNo) '                 prepare next start
  RETURN 0
END FUNCTION