pruw1.bas

Go to the documentation of this file.

#INCLUDE ONCE "w1_prucode.bi" ' PRU firmware
#INCLUDE ONCE "pruw1.hp" ' PRU syncronization
#INCLUDE ONCE "BBB/pruio_prussdrv.bi"
#INCLUDE ONCE "BBB/pruio_intc.bi"
#INCLUDE ONCE "pruw1.bi" ' FB declarations

#IFNDEF __PRUW1_MONITOR__
 
 #MACRO PRUCALL(_C_,_V_,_T_)
  WHILE DRam[0] : SLEEP 1 : WEND
  _V_
  DRam[0] = _C_ + PruLMod
  WHILE DRam[0] : SLEEP 1 : WEND
 #ENDMACRO
#ELSE
 
 #MACRO PRUCALL(_C_,_V_,_T_)
  WHILE DRam[0] : SLEEP 1 : ?"."; : WEND
  _V_
  DRam[0] = _C_ + PruLMod
  ?!"\n";_T_; " command=&h"; HEX(DRam[0], 4); " ";
  WHILE DRam[0] : SLEEP 1 : ?"."; : WEND
  prot()
 #ENDMACRO
#ENDIF


CONSTRUCTOR PruW1(BYVAL P AS PruIo PTR, BYVAL B AS Uint8, BYVAL M AS Uint8 = PRUW1_PULLUP)
  IF 0 = P ORELSE P->Errr THEN Errr = @"libpruio issue" : EXIT CONSTRUCTOR
  WITH *P
    IF B > UBOUND(.BallGpio) THEN _
                         Errr = @"invalid pin number" : EXIT CONSTRUCTOR
    IF .Gpio->config(B, IIF(M AND PRUW1_PULLUP, PRUIO_GPIO_IN_1, PRUIO_GPIO_IN)) THEN _
             Errr = @"pin configuration not matching" : EXIT CONSTRUCTOR
    VAR r = .BallGpio(B) _ ' resulting GPIO (index and bit number)
      , i = r SHR 5 _      ' index of GPIO
      , n = r AND 31 _     ' number of bit
      , ram = PRUSS0_SRAM
    Mask = 1 SHL n
    Raw = @.Gpio->Raw(i)->Mix
    PruLMod = M AND PRUW1_PARPOW
    IF .PruNo THEN
      PruNo = 0
      PruIRam = PRUSS0_PRU0_IRAM
#IFNDEF __SRAM_BASE__
      ram = PRUSS0_PRU0_DRAM
    ELSE
      ram = PRUSS0_PRU1_DRAM
#ELSE
    ELSE
#ENDIF
      PruIRam = PRUSS0_PRU1_IRAM
      PruNo = 1
    END IF
    prussdrv_map_prumem(ram, CAST(ANY PTR, @DRam))

    prussdrv_pru_disable(PruNo) '        disable PRU (if running before)
    DRam[0] = PruLMod
    DRam[1] = .Gpio->Conf(i)->DeAd + &h100 ' device adress
    DRam[2] = Mask                         ' the mask to related bit

    VAR l = (UBOUND(Pru_W1) + 1) * SIZEOF(Pru_W1(0))
    IF 0 >= prussdrv_pru_write_memory(PruIRam, 0, @Pru_W1(0), l) THEN _
                Errr = @"failed loading PRU firmware" : EXIT CONSTRUCTOR
    prussdrv_pru_enable(PruNo)
    IF PruLMod THEN SLEEP 1 ' load capacitors
  END WITH
END CONSTRUCTOR



DESTRUCTOR PruW1()
  prussdrv_pru_disable(PruNo) ' disable PRU
END DESTRUCTOR



FUNCTION PruW1.scanBus(BYVAL SearchType AS UInt8 = &hF0) AS ZSTRING PTR
  VAR max_slave = 64 _
          , cnt = 1 _
     , desc_bit = 64 _
   , search_bit = 0 _
  , last_device = 0 _
    , last_zero = -1 _
          , ret = 0 _
           , rn = 0uLL _
      , last_rn = rn
  WHILE 0 = last_device ANDALSO cnt < max_slave
    last_rn = rn
    rn = 0
    IF resetBus() THEN                Errr = @"no devices" : RETURN Errr
    sendByte(SearchType)
    FOR i AS INTEGER = 0 TO 63
      SELECT CASE i
      CASE      desc_bit : search_bit = 1 ' took the 0 path last_device time, so take the 1 path
      CASE IS > desc_bit : search_bit = 0 ' take the 0 path on the next branch
      CASE ELSE          : search_bit = (last_rn SHR i) AND &b1
      END SELECT

      PRUCALL(CMD_TRIP + search_bit SHL 8,,"tripple:")
      ret = DRam[4] AND &b111

      SELECT CASE AS CONST ret
      CASE 0 : last_zero = i
      CASE 3 : CONTINUE WHILE ' should never happen (error -> next device)
      END SELECT
      rn OR= CULNGINT(ret) SHR 2 SHL i
    NEXT
    IF desc_bit = last_zero ORELSE last_zero < 0 THEN last_device = 1
    desc_bit = last_zero
    VAR u = UBOUND(Slots) + 1
    REDIM PRESERVE Slots(u)
    Slots(u) = rn
    cnt += 1
  WEND :                                                     RETURN 0
END FUNCTION



SUB PruW1.sendByte(BYVAL V AS UInt8)
  PRUCALL(CMD_SEND + 1 SHL 8,DRam[4] = V,"sendByte: " & HEX(V, 2) & " (&b" & BIN(V, 8) & ")")
END SUB



SUB PruW1.sendRom(BYVAL V AS ULONGINT)
  PRUCALL(CMD_SEND + 8 SHL 8,*CAST(ULONGINT PTR, @DRam[4]) = V,"sendRom: " & HEX(PEEK(ULONGINT, @DRam[4]), 16))
END SUB



FUNCTION PruW1.recvBlock(BYVAL N AS UInt8) AS UInt8
#IFDEF __PRUW1_MONITOR__
  IF N > 112 THEN Errr = @"block too big (< 112 bytes in monitoring)" : RETURN 0
#ENDIF
  PRUCALL(CMD_RECV + N SHL 8,,"recvBlock: " & N)
  RETURN N
END FUNCTION



FUNCTION PruW1.recvByte()AS UInt8
  PRUCALL(CMD_RECV + 1 SHL 8,,"recvByte: ")
  RETURN DRam[4] AND &hFF
END FUNCTION



FUNCTION PruW1.getIn() AS UInt8
  RETURN IIF(*Raw AND Mask, 1, 0)
END FUNCTION



FUNCTION PruW1.resetBus() AS UInt8
  PRUCALL(CMD_RESET,,"resetBus:")
  RETURN DRam[4] AND &b1
END FUNCTION



FUNCTION PruW1.calcCrc(BYVAL N AS UInt8) AS UInt8
  VAR crc = 0, p = CAST(UBYTE PTR, @DRam[4])
  FOR p = p TO p + N - 1
    crc = Crc8_Table(crc XOR *p)
  NEXT : RETURN crc
END FUNCTION



SUB PruW1.prot()
  STATIC AS UInt32 p = LOG_BASE, b = 0
  ?
  FOR i AS INTEGER = 1 TO DRam[3]
    IF BIT(DRam[p], b) THEN ?"-"; ELSE ?"_";
    IF 0 = i MOD 70 THEN ?
    IF b < 31 THEN b += 1 ELSE b = 0 : IF p < 2047 THEN p += 1 ELSE p = LOG_BASE
  NEXT : ?
END SUB



FUNCTION PruW1.checkPara()AS UInt8
  IF resetBus() THEN                Errr = @"no devices" : RETURN 0
  sendByte(&hCC)  ' SKIP_ROM command -> broadcast message
  sendByte(&hB4)  ' READ_POWER command
  RETURN IIF(BIT(recvByte(), 0), 0, 1)
END FUNCTION



FUNCTION T_fam10(BYVAL Rom AS UBYTE PTR) AS SHORT EXPORT
  RETURN PEEK(SHORT, Rom) SHR 1 SHL 8 + (Rom[7] - Rom[6] - 4) SHL 4
END FUNCTION



FUNCTION T_fam20(BYVAL Rom AS UBYTE PTR) AS SHORT EXPORT
  RETURN PEEK(SHORT, Rom) SHL 4
END FUNCTION