DS18B20 en asm

[groundman]

hola.estoy estudiando el sensor de temperatura DS18B20 y ya me esta doliendo la cabeza.estoy intentando hacer el reset y el sensor no me responde.
en principio se trata de mandarle un impulso a masa de 500uS y luego poner poner el pin del pic como entrada.esperar 20uS
y esperar indefinidamente a que el sensor de temperatura mande una señal a masa.

pero este acontecimiento nunca sucede.he comprobado si la entrada del pic estan bien configurada probando con un pulsador.y funciona perfectamante.
al sensor lo he alimentado con 5v y le he puesto una resistencia pull-up de 4k7.

o esa resistencia no le vale o los tiempos de retardo no corresponden.en el proteus aunque no he consegudo todabia leer datos.si que logre
realizar el reset.aunque con una pull-up digital.no con la resistencia analogica de 4k7 ni con una de 1M como comentaban por ahi.

la frecuencia a la que esta trabajando el pic es de 48Mhz con un crystal de 4Mhz.digo que en el proteus los tiempos son correctos.
pero para saber si en el circuito son los mismos igual tendria que mirarlos con un osciloscopio.

[groundman]

sigo intentandolo y no lo consigo.he mirado con el osciloscopio el retardo de los 500uS.y efectivamente el proteus no me estaba dando valores correctos.
aunque me daba 500uS.en la parte fisica eran 400uS.ya lo he retocado pero nada.he comprobado varias resistencias y tampoco.
el sensor no manda la señal de estado bajo.

en el programa hay una rutina que espera a que el sensor responda.pero y si hay un problema!.entonces nunca sadria de ese bucle?.

me parece qu el programa no esta bien hecho.tendre que modificarlo.para que envie varias peticiones hasta que conteste.

[sander]

puede postear su programa?, asi le echamos un ojo.

Saludos

[groundman]

gracias sander por tu ofrecimiento.pero parece que encontre el problema.ya me responde.cuando envio el reset y me responde con el presence.

cuando mire en el osciloscopio,vi un aseñal de 500uS.pero no me percate de que era positiva.y debe de ser a masa.supongo que no configure bien la
E/S del pic.
ahora me queda interpretar los comandos.y familiarizarme con el sensor.haber si me sale a la primera.ya pondre por aqui mis resultados.

[groundman]

por fin ya me funciona.

todo el problema estaba en la forma en que se configuraba el pin de E/S.ya puedo leer la temperatura fisicamente desde el sensor.aunque
no con el proteus.lo estoy haciendo con el emulador en circuito.MPLAB ICD2

[sander]

que bien que lograste resolverlo, felicidades.

Saludos

[groundman]

bueno.resulta que he buscado por todos sitios una libreria para usar el DS18B20 con un pic de la serie 18Fxxxx
pero no he encontado nada.asi que la estoy desarroyando yo mismo.ya tengo todos los comandos realizados.excepto los de buscar las roms y evento
de alarmas.

he encontrado este codigo.pero no es para este pic.y hay cosas que no entiendo.

Código: [Seleccionar]

;******************************************************************
;*                                                                *
;*  Filename: 10F200 1-Wire K8LH.asm                              *
;*    Author: Mike McLaren, K8LH   (k8lh@arrl.net)                *
;*      Date: 20-Jan-09                                           *
;*                                                                *
;*  Variation of Mike Webb's 10F200 Serial DS1820 Sensor Program  *
;*                                                                *
;*     MPLab: 8.14    (tabs=8)                                    *
;*     MPAsm: 5.21                                                *
;*                                                                *
;******************************************************************

;******************************************************************
;       Title   One Wire temperature reader
;       Author  Mike Webb
;       Date    10th January 2009
;       Pic     10F200 or 12F509
;******************************************************************

        errorlevel      -302
        include "p10f200.inc"

        __CONFIG   _MCLRE_OFF & _CP_OFF & _WDT_OFF

        radix   dec

OW_Bit  equ     2               ; GP2
RS_Bit  equ     0               ; GP0

#define DataLow         b'11111111' - (1<<OW_Bit) - (1<<RS_Bit)
#define DataHigh        b'11111111' - (1<<RS_Bit)
#define DataBit         GPIO,OW_Bit


;--< global vars >-------------------------------------------------
        cblock  0x10
RomBuffer:8     ; must be on 16 byte boundary
LastDiscrep     ;

;--< local vars >--------------------------------------------------

LastZero        ; Search
BitMask         ; Search, OwMatch flag bit (BitMask,0)
BitIndex        ; Search
OwByte          ; OwReadByte, OwWriteByte
BitCtr          ; OwReadByte, OwWriteByte, Put232
temp            ; all delay routines & PutNybble
OwTemp          ; GetBits, Put232
        endc

TimerH  equ     LastZero        ; OwPowerBus 1 second delay
TimerL  equ     BitIndex        ; OwPowerBus 1 second delay

;--< one wire command constants >----------------------------------

#define OwSkipRom       0xCC
#define OwConvert       0x44
#define OwReadScratch   0xBE
#define OwSearchRom     0xF0
#define OwMatchRom      0x55

;--< macros >------------------------------------------------------

OwReset macro
        call    Ow.Reset
        endm

OwWrite macro   pByte
        movlw   pByte
        call    Ow.WriteByte
        endm

OwReadByte      macro
        call    Ow.ReadByte
        endm

OwReadBit       macro
        call    Ow.ReadBit
        endm

OwSendCarry     macro
        call    Ow.SendCarry
        endm

OwPowerBus      macro
        bsf     DataBit         ; setup OW pin to output a '1'
        movlw   DataLow         ; to power parisitic devices
        tris    GPIO            ; during the 'convert' command
        movlw   ~(high(1000000/768))
        movwf   TimerH          ;
dly1    decfsz  temp,F          ; 768 usec loop
        goto    dly1            ;
        decfsz  TimerL,F        ;
        goto    dly1            ;
        incfsz  TimerH,F        ;
        goto    dly1            ;
        call    Release         ; release data line
        endm

OwWriteBuffer   macro
        local   loop
        bcf     FSR,3           ; reset FSR = &RomBuffer (0x10)
loop    movf    INDF,W          ;
        call    Ow.WriteByte    ; send rom serial number byte
        call    PutHex          ; print byte as hex
        incf    FSR,F           ;
        btfss   FSR,3           ;
        goto    loop            ;
        endm

Send232 macro   pByte           ;
        movlw   pByte           ;
        call    Put232          ;
        endm

;******************************************************************
;
;  main program
;
        org     0x00

        movwf   OSCCAL          ;
Restart
        clrf    GPIO            ; set OW and serial pins '0'
        movlw   DataHigh        ; 1-wire pin hi-z, '1'
        tris    GPIO            ; serial pin output '0'
        movlw   b'11011111'     ; 11011111
                                ; 1-------, IOC off
                                ; -1------, weak pullups off
                                ; --0-----, tmr0 source Fosc/4
                                ; ---1----, tmr0 edge hi>lo
                                ; ----1---, wdt gets prescaler
                                ; -----111, wdt prescale 128:1
        option                  ;
        clrf    LastDiscrep     ; init Last Discrepency var'
OwSearchNext
        clrf    BitIndex        ; BitIndex = 0
        clrf    LastZero        ; LastZero = 0
        movlw   b'00000001'     ;
        movwf   BitMask         ; setup rom array bit mask
        OwReset                 ; reset all 1-wire devices
        OwWrite(OwSearchRom)    ; send "search rom" command
;       movlw   RomBuffer       ; OwWrite() returns W = &RomBuffer
        movwf   FSR             ; FSR = &RomBuffer (0x10)
GetBits
        OwReadBit               ; read bit A
        rlf     OwTemp,F        ; F = -------A
        OwReadBit               ; read bit B (compliment)
        rlf     OwTemp,W        ; W = ------AB
        rrf     OwTemp,F        ; put 'A' bit back into Carry
        andlw   0x03            ; filter out unused bits
        xorlw   0x03            ; AB == 11, no response?
        bz      Restart         ; yes, branch (restart), else
        xorlw   0x03            ; AB == 00, a discrepency?
        bnz     SendRomBit      ; no, branch, use 'A' bit, else
Discrepency
        movf    BitIndex,W      ; 0..63
        subwf   LastDiscrep,W   ; 0..63
        bnc     IndexGTLD       ; index > last discrepency, use '0'
        bz      SendRomBit      ; index = last discrepency, use '1'
IndexLTLD                       ; index < last discrepency, use ROM
        movf    BitMask,W       ; get ROM bit
        andwf   INDF,W          ; is ROM bit '0'?
        bnz     SendRomBit      ; no, branch with C = 1, else
        clrc                    ; set C = 0 and
IndexGTLD
        movf    BitIndex,W      ; update 'LastZero'
        movwf   LastZero        ;
SendRomBit
        movf    BitMask,W       ; set ROM bit to value in Carry
        iorwf   INDF,F          ; set ROM bit (unconditionally)
        skpc                    ; is bit a '1'? yes, skip, else
        xorwf   INDF,F          ; clr ROM bit
        OwSendCarry             ; send direction/qualifier bit
        rlf     BitMask,W       ;
        rlf     BitMask,F       ; increment rom array bit mask
        skpnc                   ; byte boundary? no, skip, else
        incf    FSR,F           ; bump RomBuffer array address
        incf    BitIndex,F      ; bump bit index, 0..63
        btfss   BitIndex,6      ; BitIndex = 64?  yes, skip, else
        goto    GetBits         ; do next bit
        movf    LastZero,W      ; update last discrepency
        movwf   LastDiscrep     ; a 0 value indicates end-of-list
;       bsf     BitMask,0       ; do "convert" (bit = 1 already)
OwMatch
        OwReset                 ; reset all 1-wire devices
        OwWrite(OwMatchRom)     ; send "match rom" command
        OwWriteBuffer           ; send + print rom serial number
        Send232(' ')            ; send <space> char
        btfss   BitMask,0       ; conversion complete?
        goto    OwScratch       ; yes, branch, else
        OwWrite(OwConvert)      ; send "convert" command
        OwPowerBus              ; power OW pin during conversion
        Send232(0x0D)           ; send <cr> char (htab 0)
        bcf     BitMask,0       ; indicate conversion complete
        goto    OwMatch         ; do "match rom" for OwScratch
OwScratch
        OwWrite(OwReadScratch)  ; send "read scratchpad" command
        movlw   -9              ;
        movwf   FSR             ; use FSR as byte counter
RdLoop  OwReadByte              ; read + print scratchpad byte
        incfsz  FSR,F           ; all 9 bytes read + printed?
        goto    RdLoop          ; no, branch, else
        Send232(0x0D)           ; send <cr> char
        Send232(0x0A)           ; send <lf> char
        goto    OwSearchNext    ; search and process next device

;******************************************************************
;
;  subroutines
;
Ow.Reset
        movlw   DataLow         ; output a '0'
        tris    GPIO            ;
        movlw   (750/4)-1       ; delay 750 usecs & release bus
        call    Delay           ; returns W = (548/4)-1
        goto    Delay           ; delay 548 usecs

Ow.WriteByte
        movwf   OwByte          ; store byte to write
        movlw   8               ; send 8 bits
        movwf   BitCtr          ;
wrloop  rrf     OwByte,F        ; move bit to carry
        call    Ow.SendCarry    ; send it
        decfsz  BitCtr,F        ; sent all bits
        goto    wrloop          ; no, so loop
        rrf     OwByte,F        ; leave OwByte intact
        retlw   RomBuffer       ; for OwSearch routine

Ow.SendCarry
        movlw   DataLow         ;
        tris    GPIO            ; initiate write slot
        skpnc                   ; send 0 bit
        movlw   DataHigh        ; send 1 bit
        tris    GPIO            ;
        movlw   56/4            ; finish 60 usec slot
Delay   movwf   temp            ;
        decfsz  temp,W          ;
        goto    Delay           ;
Release movlw   DataHigh        ;
        tris    GPIO            ; release data line
        retlw   (548/4)-1       ; for Ow.Reset routine

Ow.ReadBit
        movlw   DataLow         ; pull line low
        tris    GPIO            ; falling edge       0 usecs
        clrc                    ; assume bit = 0     1 usecs
        movlw   DataHigh        ;                    2 usecs
        tris    GPIO            ; release line at    3 usecs
        movlw   3               ; delay 10 usecs
        movwf   temp            ;
        decfsz  temp,F          ;
        goto    $-1             ; sample between 13-14 usecs
        btfsc   DataBit         ; a '0'? yes, skip (C=0), else
        setc                    ; indicate a '1' (C=1)
        goto    Delay-1         ; delay 60 usecs

Ow.ReadByte
        movlw   8               ;
        movwf   BitCtr          ; BitCtr = 8
rdloop  call    Ow.ReadBit      ; returns C = bit
        rrf     OwByte,F        ; move Carry into byte
        decfsz  BitCtr,F        ; built a full byte?
        goto    rdloop          ; no, branch, else

PutHex
        swapf   OwByte,W        ; print hi nybble
        call    PutNybble       ;
        movf    OwByte,W        ; print lo nybble
PutNybble
        andlw   0x0F            ; keep lower nibble
        movwf   temp            ; save for later
        movlw   -10             ; test if greater
        addwf   temp,W          ; than 10
        movlw   "0"             ; add "0"
        skpnc                   ; or, if greater than 10
        movlw   "0"+7           ; add "A"-10
        addwf   temp,W          ; fall through to send it
;
;  19200 baud, exact 52-usec bit timing (4 MHz)
;
Put232  bsf     GPIO,RS_Bit     ; send start bit
        movwf   OwTemp          ; save Tx data
        movlw   9               ; 8 data bits + 1 stop bit
        movwf   BitCtr          ; update bit counter
PutBit  setc                    ; shift in stop bits
        movlw  (52-8)/4         ; 52 usecs - 8 usec loop time
        movwf   temp            ; a 4 cycle / 4 usec loop
        decfsz  temp,W          ; W == 0? yes, skip, else
        goto    $-2             ; loop
        rrf     OwTemp,F        ; put data bit in C (W = 0)
        skpc                    ; a '1' bit? yes, skip, else
        iorlw   1<<RS_Bit       ; send a '0', W = 1<<RS_Bit
        movwf   GPIO            ; send bit, clear OW DataPin
        decfsz  BitCtr,F        ; all 9 bits? yes, skip, else
        goto    PutBit          ; send next bit
        retlw   0               ;

        end


como estas lineas:

retlw   (548/4)-1       ; for Ow.Reset routine

se supone que debuelve el valor (548/4)=137-1= 136. pero en el codigo esta el valor 0x51
ademas se refiere a la rutina reset.y no se porque.ya que desde donde se llama a esta rutina,el valor no es usado.

tampoco entiendo las lineas:

setc                    ; indicate a '1' (C=1)
clrc                    ; assume bit = 0     1 usecs

yo creo que es para poner a 0 o 1 el bit 0 del registro OwTemp.

y estas:

 skpnc                   ; send 0 bit
 skpc                    ; is bit a '1'? yes, skip, else

yo he puesto bc o bnc.aunque skpnc y skpc no las veo como instrucciones en el datasheet del 10f200.y si son macros,yo no los veo en el programa.

[sander]

Hola groundman, sobre lo que pusiste setc, clrc, skpnc, skpc , son pseudo instrucciones, son como macros definidas por defecto en el ensamblador. setc, clrc, son equivalentes a bsf  STATUS,C  y a bcf   STATUS,C, y las instrucciones skpnc, skpc son equivalentes a btfsc  STATUS,C  y a btfss   STATUS,C. Puedes encontrar las pseudoinstrucciones en la ayuda del ensamblador del MPLAB.


Sobre el retlw   (548/4)-1, entiendo que lo utiliza para generar un retardo adicional en la rutina Ow.Reset, ya que, el programa sale de la rutina Ow.Reset mediante una segunda llamada a Delay

Código: C

1. Ow.Reset
2.         movlw   DataLow         ; output a '0'
3.         tris    GPIO            ;
4.         movlw   (750/4)-1       ; delay 750 usecs & release bus
5.         call    Delay           ; returns W = (548/4)-1, //esta primera llamada genera un retardo de 780 us
6.         goto    Delay           ; delay 548 usecs, //aqui va otra vez a Delay, pero esta vez genera un retardo de 548 us
7.                                      ;//ademas utiliza el retlw de Delay para retornar de la subrutina Ow.Reset

Saludos

[groundman]

gracias sander por tu ayuda.ya he empezado a obtener resultados.haver si lo termino y pongo aqui todo lo aprendido.

[groundman]

ya tengo casi acabada la libreria.pude combertir el codigo anterior para el 18f2550.pero de momento no saco las rom de los sensores.

poniendo uno si me sale la rom de este.pero si pongo dos sensores en paralelo,solo me sale el que tiene una identidad rom mas alta.no se como descartar
el que ya se lee.

por lo que dice el datasheet cuando los sensores estan en paralelo,para identificar las rom.el algoritmo descarta las rom inferiores.y esto lo hace bien.
pero como aparto las rom superiores.hay que enviarles algun codigo para deshabilitarlas por ese momento?

[groundman]

en el datasheet no veo nada al respecto sobre un comando para mantener a la espera al sensor cuya rom hemos localizado.para asi buscar la siguiente rom.
lo unico que veo es que se deshabilita la alimentacion del sensor.sera lo que hace falta para mantener al sensor desactivado de la linea?

creo haber visto algo mas sobre el envio de un comando determinado.creo que la lectura del scratchpad.no se.algo se me escapa....

[groundman]

jo.... de verdad que tirarme un dia entero para encontrar el fallo.es una pasada.que poquisima informacion hay.y ya no porque este en ingles.encima lo dificil
es poder interpretar lo que se esta leyendo.tener que aprender de cabo a rabo el sistema 1 wire.se me va a ir la pelota.el error es lo mas simple del mundo.

cada vez que se realiza el algoritmo para la ROM SEARCH. cuando ya se ha obtenido la primera ROM.queda un registro de la ultima discrepancia.pues ese valor
hay que conservarlo como esta para la siguiente busqueda de la siguiente ROM.

como ese registro estaba ubicado en la rutina de inicializacion,y era borrado.pues no me buscaba la siguiente ROM.ahora no lo borro y ya funciona.

[groundman]

siguiendo con el algoritmo de busqueda de ROMs estoy aprendiedo mucho sobre como funciona esto.he probado con tres sensores en paralelo
y se da la circunstancia de que la obtencion de las ROMs se hacen ordendamente.y las primeras ROMs recibidas son las que el ultimo
byte de la ROM es de un valor inferior.

pero sigo con algunos problemas.parece ser que algunos sensores tienen conflictos con otros.porque al añadir alguno determinado,
desaparece otro.pero si quito ese,buelve a aparecer el otro.

asi que no se si la solucion que encontre de conservar el registro de ultima discrepancia es lo ideal.igual hay que hacer algo mas.
pero me parece que me quedan muchas pruebas hasta encontrar el fallo.

[groundman]

al final a fuerza de hacer pruebas.y leer mucho ingles.me percate de que el registro de ultima discrepancia tiene otra funcion
a parte de aprobechar el valor para la siguiente busqueda de otro sensor.

resulta que si al finalizar la busqueda de la ROM de algun sensor.este registro vale 0,se habra finalizado la busqueda de ROMs

respecto a lo que dige de que las ROMs se recibian ordenandamente,segun mi experiencia no ha sido asi.

estos son las ROMs recividas por orden.

1º 28 B8 26 66 05 00 00 70

2º 28 8C C1 65 05 00 00 42

3º 28 8E F1 66 05 00 00 20

4º 28 CD 18 67 05 00 00 AA

se supone que si la obtencion de las ROM es por descarte de los bit que envian los sensores,deberia haber un orden en la recepcion
de las ROM.igual la hay pero yo no la veo.

PD: el fallo de los conflictos fue que estropee un sensor al alimentarlo a la inversa.sin embargo si funcionaba individualmente.
       respecto a proteus.solo me funciona con un maximo de dos sensores en paralelo.

[groundman]

bueno aqui esta la rutina.

Código: [Seleccionar]

estos son los registros a introducir en el banco 5

LastDiscrep     ;registro de ultima discrepancia
  LastZero       
  BitMask         
  BitIndex       
  OwTemp         
CONT_ROMs ;contador de ROMs recibidas

las definiciones:

#define BANCO_GENERAL 0x05 ;banco donde se hucaran los registros generales (seleccionar el que precisemos)
#define BANCO_ROMs 0x04 ;banco donde se hubicaran las ROMs recibidas (seleccionar el que precisemos)

DS18B20_SEARCH_ROM EQU 0XF0 ;identificacion de todos los dispositivos conectados al bus
 y las macros:

GENERAL_BANK MACRO
movlw BANCO_GENERAL ; selecciona el banco indicado en la abezera
movwf BSR ;conmuta el banco
ENDM
ROMs_BANK MACRO
movlw BANCO_ROMs ; selecciona el banco indicado en la abezera
movwf BSR ;conmuta el banco
ENDM

la llamada al programa:

GENERAL_BANK ;selecciona banco de registros generales
CALL SEARCH_ROM

y el programa:

;************************************************* SEARCH_ROM **********************************************************
;Busqueda de ROMs

SEARCH_ROM movlw BANCO_ROMs ;selecciona el banco indicado en la cabezera"banco donde hubicar las ROMs"
movwf FSR2H ;conmuta el indice de direccionamiento indirecto
clrf FSR2L ;borra FSR2L
clrf CONT_ROMs ;borra registro contador de ROMs encontradas
clrf    LastDiscrep      ;inicializa registro de ultima discrepancia
COP1 incf CONT_ROMs,f ;incrementa contador de ROMs encontradas
call INI_BITS ;inicializa registros de busqueda
call ROM_SEARCH ;comando de busqueda de ROMS
call GetBits ;inicia la busqueda de identidades
clrf WREG ;valor 0x00 para W
xorwf LastDiscrep,W ;comparalo con el registro de ultima discrepancia
btfss STATUS,Z ;si el registro es diferente a 0x00,
goto COP1 ;continua con la busqueda
return ;en caso contrario retorna
;*************************************************** INI_BITS *****************************************************************

INI_BITS    clrf    BitIndex        ;inicializa registro BitIndex = 0
          clrf    LastZero        ;inicializa registro LastZero = 0
movlw   b'00000001'      ;
          movwf   BitMask          ; setup rom array bit mask
return        
       
;************************************************* GetBits ********************************************************
;Lectura de los bits recibidos
;A=bit1 B=bit0
;AB=11 - ningun dispositivo presente
;AB=01 - todos los dispositivos en el bus tienen un 0 en la hubicacion del bit que se esta leyendo
;AB=10 - todos los dispositivos en el bus tienen un 1 en la hubicacion del bit que se esta leyendo     
;AB=00 - algunos dispositivos en el bus

GetBits call OwReadBit       ; lectura del primer bit(bit A)leido del sensor y que ha sido introducido en el carry
          rlcf     OwTemp,F       ; desplaza el contenido del carry en OwTemp(bit A)
          call OwReadBit       ; lectura del segundo bit(bit B)(complemento)
          rlcf     OwTemp,W       ; desplaza el contenido del carry en OwTemp(bit B) y dejas el resultado en W
          rrcf     OwTemp,F       ; desplaza el bit A al carry
          andlw   0x03            ; selecciona bit0 y bit1 resto borralos
xorlw   0x03            ; compara bit0 y bit1.
        btfsc STATUS,Z ; y si los dos estan a 1,  (AB=11)
return ; retorna al no responder ningun dispositivo.
        xorlw   0x03            ; compara bit0 y bit1.     
bnz     SendRomBit      ; AB="01 o 10" salta a SendRomBit
; AB="00" si hay algunos dispositivos en la linea,sige.en Discrepency.
Discrepency movf    BitIndex,W      ; 0..63
          subwf   LastDiscrep,W   ; 0..63
          bnc     IndexGTLD       ; si index > ultima discrepancia, usa '0'
          bz      SendRomBit      ; index = ultima discrepcia, usa '1'
IndexLTLD  ; index < ultima discrepancia, usar ROM
movf    BitMask,W       ; inserta BitMask en W
          andwf   INDF2,W         ; esta el bit de la ROM a 0?
          bnz     SendRomBit      ; no, branch with C = 1, else
          bcf    STATUS,C        ; set C = 0 and

IndexGTLD movf    BitIndex,W      ; update 'LastZero'
          movwf   LastZero        ;

SendRomBit movf    BitMask,W       ; set ROM bit to value in Carry
iorwf   INDF2,F         ; set ROM bit (unconditionally)
          btfss   STATUS,C        ; is bit a '1'? yes, skip, else
          xorwf   INDF2,F         ; clr ROM bit
salt1      call OwSendCarry     ; send direction/qualifier bit
rlcf    BitMask,W       ;
          rlcf    BitMask,F       ; increment rom array bit mask
          btfsc  STATUS,C        ; byte boundary? no, skip, else
          incf    FSR2L,F         ; bump RomBuffer array address
salt2       incf    BitIndex,F      ; incrementa el registro de bits
          btfss   BitIndex,6      ; si no se ha llegado al bit 64
          goto    GetBits         ; continua el bucle
          movf    LastZero,W      ; actualizar ultima discrepancia
          movwf   LastDiscrep     ; si LastDiscrep es 0.se ha encontrado la ultima ROM
          return                  ; retorna

OwReadBit   call LINE_OUT ;linea como salida
bcf    STATUS,C ;borra el carry
call LINE_IN ;linea como entrada
call DEMORA_10uS
        btfsc   PORTB,5 ;comprueba PB5
        bsf  STATUS,C ;y si esta a 1,setea el carry                 
movlw     .8      ;retardo de 50uS
  call DEMORA_uS ;llamada a retardo
call DEMORA_10uS
return

OwSendCarry call LINE_OUT ;linea como salida
btfsc  STATUS,C ;borra el carry
call LINE_IN ;linea como entrada
movlw     .8      ;retardo de 50uS
call DEMORA_uS ;llamada a retardo
call DEMORA_10uS ;retardo de 10uS
call LINE_IN ;linea como entrada
        return




y librerias:

;****************************************************  ROM_SEARCH  *************************************************************
;Busqueda de las ROMs (Identidades) de todos los dispositivos conectados en el bus.(varios dispositivos en el bus)
ROM_SEARCH call DS18B20_RESET ;resetea el sensor
movlw DS18B20_SEARCH_ROM
call WRITE_18B20 ;escribe el comando
return

;*********************************************** DS18b20_RESET ***************************************************
;reset del sensor
DS18B20_RESET
movlw 0xff ;valor para 255 ciclos
movwf CONT_RESET ;introducelo en el contador regresivo
call LINE_IN ;pin del pic como entrada
call LINE_OUT ;pin del pic como salida
call DEMORA_500uS ;retardo de 500uS (solicitud de escucha al 18B20)
call LINE_IN ;pin del pic como entrada(espera de respuesta del 18B20)
call DEMORA_20uS ;retardo para recibir la respusta
espera_lo dcfsnz CONT_RESET ;si no se ha recibido el present del DS18B20 antes de 255 ciclos,
return ;retorna
btfsc PortInOut ;espera a que el 18B20 mande estado bajo
goto espera_lo ;repite hasta que sea estado bajo

espera_hi btfss PortInOut ;espera a que el 18B20 mande estado alto
goto espera_hi ;repite hasta que sea estado alto
return ;retorna
;********************************************* WRITE_18B20 ********************************************************
;Envia el byte cargado en w al sensor.

WRITE_18B20 movwf DATO18B20 ;introduce el contenido del acumulador en el registro DATO18B20
movlw 0x08 ;carga en el acumulador la cantidad de bits a enviar
movwf CONT_BITS ;y metelo en el registro CONT_BITS
call LINE_IN ;pin del pic en modo entrada
send_bit call LINE_OUT ;pin del pic en modo salida
rrcf DATO18B20,F ;rota el registro
btfss STATUS,C ;comprueba si ha habido acarreo
call LINE_OUT ;si no lo ha habido salta a send_cero
btfsc STATUS,C
call LINE_IN ;en caso contrario envia un uno.
movlw     .8      ;retardo de 50uS
call DEMORA_uS ;llamad a retardo
call LINE_IN ;flanco de subida
decfsz CONT_BITS,F ;decrementa el contador de bits.
goto send_bit ;repite hasta enviar los 8 bits

btfss PortInOut ;espera a que el 18B20 mande estado alto
goto $-2 ;repite hasta que sea estado alto
return ;retorna

;**************************************************** modo lectura*********************************************
LINE_IN bsf TrisInOut ;pin como entrada(alta impedancia)
return
;**************************************************** modo escritura*********************************************
LINE_OUT bcf TrisInOut
bcf PortInOut ;pin como salida
return

haran falta otros registros que tendreis que implementar en el codigo.si alguien quiere implementar el codigo y falta algo que lo diga
y lo paso.


no puedo pasar todo el programa y librerias porque no estan acabadas.y se tocan muchas mas cosas relacionadas con el DS18B20.
y seria un lio.