Autor Tema: trabajando con DS18b20  (Leído 4702 veces)

0 Usuarios y 2 Visitantes están viendo este tema.

Desconectado antonioj

  • PIC10
  • *
  • Mensajes: 4
trabajando con DS18b20
« en: 05 de Mayo de 2008, 11:48:27 »
Hola.
Soy Antonio, estoy haciendo un proyecto y tengo una duda sobre el DS18b20.
Mi duda es, si puedo conectarlo en el puerto RA5 del pic16F876, para el DS18b20 necesito una entrada en drenador abierto creo que la entradas RA0 a Ra3 y RA5 de este pic lo son pero he estado mirando la hoja de caracteristicas del pic y no lo veo claro.
Lo he simulado en proteus y no va.

Un saludo

Desconectado aitopes

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5100
    • uControl
Re: trabajando con DS18b20
« Respuesta #1 en: 05 de Mayo de 2008, 11:51:09 »
Hola!

Bienvenido al foro.

No deberias tener problema con ese pin.
Saludos!

Ariel.
Si cualquier habilidad que aprende un niño será obsoleta antes de que la use, entonces, ¿qué es lo que tiene que aprender? La respuesta es obvia:
La única habilidad competitiva a largo plazo es la habilidad para aprender
“. Seymour Papert

Desconectado esteban_santiago83

  • PIC10
  • *
  • Mensajes: 10
Re: trabajando con DS18b20
« Respuesta #2 en: 14 de Mayo de 2008, 12:41:30 »
Antonio soy Esteban, yo tambien debo usar ese sensor pero con el pic16f628a, el problema es que no tengo ni idea de la programación para la comunicación 1-wire, crees que puedas darme una mano con los archivos asembler que estas usando?
Esteban

Desconectado RALF2

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 2060
Re: trabajando con DS18b20
« Respuesta #3 en: 14 de Mayo de 2008, 21:40:34 »
Hola amigos!
Estevan si necesitas una salida en drenador abierto pos utiliza el port RA.4 que tiene esa funcion y para operar con el debes colocar una resistencia por ejemplo 10k del positivo de la fuente a RA.4  :mrgreen:

Si necesita ejemplos de seguro en el foro encontraras varios  :mrgreen:

Saludos

Desconectado antonioj

  • PIC10
  • *
  • Mensajes: 4
Re: trabajando con DS18b20
« Respuesta #4 en: 20 de Mayo de 2008, 16:39:06 »
Esteban yo he recogido la información del libro Microcontrolador PIC16f84, en le viene como se trabaja con el sensor DS18B20 y subrutinas que te hacen muy fácil la programación.
tiene una página web http://www.pic16f84a.com/Proteus.htm donde tambien puedes preguntarle al autor dudas.
Espero que te sirva de ayuda.

Un saludo 

ralf2 tiene razón el pic RA4 es de drenador abierto y se puede conectar el ds18b20

Desconectado maunix

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 4751
    • Mi Sitio Web Personal
Re: trabajando con DS18b20
« Respuesta #5 en: 21 de Mayo de 2008, 08:33:57 »
antonioj, ¿realmente hablas de una entrada drenador abierto o de una salida?
- La soberbia de un Einstein es entendible.. la de un salame es intolerable (A.Dolina)
- En teoría no hay diferencia entre la teoría y la práctica. En la práctica... si la hay.
- Lee, Lee, Lee y luego pregunta.(maunix)
- Las que conducen y arrastran al mundo no son las máquinas, sino las ideas (V. Hugo)
- Todos los hombres se parecen por sus palabras; solamente las obras evidencian que no son iguales.(Moliere)
- Todo debería ser hecho tan simple como sea posible pero no mas simple que eso.(A.Einstein)

Desconectado MLO__

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 4581
Re: trabajando con DS18b20
« Respuesta #6 en: 21 de Mayo de 2008, 11:59:53 »
Hola.

Yo he simulado al DS18S20 y al DS18B20 y los dos me han corrido muy bien ( al DS18S20 lo he montado en HW y corre sin problemas, incluso teniendo al micro trabajando con interrupciones, 2 del timer y una del serial ), sin necesidad de que el pin del pic sea open drain .... creo que es el sensor el que tiene esa particularidad. Lo que diferencia a los sensores es la resolucion y que el 18B20 tiene un registro extra para programar justamente esa resolucion de conversion.

Yo lo conecto de la manera Power Parasity y me ha funcionado. Posteo el codigo.
Código: [Seleccionar]
#include <16F873A.h>
#fuses XT

#use delay(clock=4M)
#use rs232(baud=9600, xmit=pin_c6, rcv=pin_c7, bits=8, parity=N)

#define TOUCH_PIN pin_a0
#define pulses pin_b0
#define pulse_1 pin_b3
#define on output_high
#define off output_low

#include <touch.c>
#include<string.h>

int const lenbuff = 8;

int8 pass[5] = "\0";
int8 ints_T0 = 0;
int8 ints_T1 = 0;
int xbuff=0x00;
char cbuff[lenbuff];
char rcvchar=0x00;
int1 data_ok=0;

void inicbuff(void);
void addcbuff(char data_rs);

#int_rda
void serial_isr(void) // Interrupción recepción serie USART ///////////////////////////////////////////////////////////////////////////////////////////////
{   
  rcvchar=0x00;
  if(kbhit())
 {
    rcvchar=getc();
    addcbuff(rcvchar);
  }
}

#int_TIMER0
void pulsos_isr(void)
{
++ints_T0;
if(ints_T0>=3)
{
ints_T0 = 0;
if(input_state(pulses))
off(pulses);
else
on(pulses);
}
}

#int_TIMER1
void pulsos_1_isr(void)
{
++ints_T1;
if(ints_T1>=3)
{
ints_T1=0;
if(input_state(pulse_1))
off(pulse_1);
else
on(pulse_1);
}
}

void inicbuff(void)// Inicia a \0 cbuff ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////-------------------
{
  int i;

  for(i=0;i<lenbuff;i++)
  {  // Bucle que pone a 0 todos los
    cbuff[i]=0x00;          // caracteres en el buffer
  }
  xbuff=0x00;                // Inicializo el índice de siguiente
                            // carácter
}

void addcbuff(char data_rs)// Añade a cbuff ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
{
  switch(data_rs)
 {
    case '\r':
      data_ok=true;
      break;
    case '\n':
  data_ok=true;
  break;
    default:
      cbuff[xbuff++]=data_rs;
  }
}

void main (void)
{
   int8 buffer[2];

   setup_adc(ADC_OFF);
   setup_adc_ports(NO_ANALOGS);
   setup_timer_0(RTCC_8_BIT | RTCC_INTERNAL | RTCC_DIV_256);
   setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);
   enable_interrupts(INT_TIMER0);
   enable_interrupts(INT_TIMER1);
   enable_interrupts(INT_RDA);
   enable_interrupts(GLOBAL);

   printf("DS18S20 - MLO\r\n\r\n");
   printf("type temp to read T\r\n");
   while (TRUE)
  {
     if(touch_present())
    {
        touch_write_byte(0xCC);
        touch_write_byte (0x44);
        output_high(TOUCH_PIN);
        delay_ms(800);

        touch_present();
        touch_write_byte(0xCC);
        touch_write_byte (0xBE);
        buffer[0] = touch_read_byte();
        buffer[1] = touch_read_byte();

        delay_ms (1000);
     }
if(data_ok)
{
data_ok = false;
disable_interrupts(INT_RDA);
strcpy(pass, "temp");
if(!strncmp(cbuff, pass, 4))
printf ("Temperature: %c%3.1f C\r\n", (buffer[1])?'-':' ', (float)buffer[0]/2);
else
printf("No Command!!!!\r\n\r\n");
inicbuff();
enable_interrupts(INT_RDA);

}
  }
}

El micro envia el valor de la temperatura solo cuando se escribe el comando "temp" ( lo hice asi para probar el funcionamiento del sensor con la interrupcion de la USART).

Saludos.
El papel lo aguanta todo

Desconectado esteban_santiago83

  • PIC10
  • *
  • Mensajes: 10
Re: trabajando con DS18b20
« Respuesta #7 en: 26 de Mayo de 2008, 12:12:52 »
Antonio tengo otra duda, lo que pasa es que en el programa que hice, primero llamo a la subrutina de inicializa que esta en la pagina que me diste, luego llamo a leer temperatura y finalmente lo resetea, crees que de esta forma este bien? o será que despues de leer la temperatura debo nuevamente llamar a inicializa para que el dispositivo empiece con la conversión de temperatura siguiente?
Una duda final, el dato que resulta es decimal verdad, ahora quiero enviar este dato via serial a una aplicación en visual basic y mostrarlo en la pantalla, sabes como debo hacerlo?
Gracias

Desconectado piccar56

  • PIC10
  • *
  • Mensajes: 10
Re: trabajando con DS18b20
« Respuesta #8 en: 16 de Julio de 2008, 13:05:12 »
hola steban_santiago83
hace poco tiempo yo trabaje con el sensor de  temperatura DS18B20, desarrolle una  pequeña libreria que hasta ahora me  funciona bien; esta tiene   cuatro funciones  pequeñas:
ds1820_init(); // inicialiaza el sensor                           
ds1820_read();// retorna (int8) el valor de la temperatura  en grados ºC 0 a 128 parte real                       
ds1820_sig();// retorna(int1)   1= -ºC ; un 0= +ºC           
ds1820_dec() //retorna un valor decimal de la temperatura  puede ser 0 o 5 .

solo llamaba  a incializar una vez en todo el programa; cada ves que queria leer la  temperatura   solo tengo que llamar a de1820_read().
 a continuacion el codigo:
Código: [Seleccionar]
////////////////////////////////////////////////////////////////////////////
////   Libreria para DS18B20 (sensor de temperatura )                   ////
////   DS18B20 conectado al PIN_B3                                      ////
////   autor: carlos alberto yaco tincusi                               ////
////   funciones:                                                       ////
////   ds1820_init(); // inicialiaza el sensor                          ////
////   ds1820_read();// retorna (int8) el valor de la temperatura       ////
////   en grados ºC 0 a 128 parte real                                  ////
////   ds1820_sig();// retorna(int1)   1= -ºC ; un 0= +ºC               ////
////   ds1820_dec() //retorna un valor decimal de la temperatura        ////                                                               ////
////   puede ser 0 o 5                                                  ////
////////////////////////////////////////////////////////////////////////////

#define ds1820rw PIN_B3 // PUEDES CAMBIAR AL PIN QUE DESEEA
#byte comando=0x7c
#byte portb=6
int tempe1=0;// parte entera de la temperatura
int1 tempe2=0;// parte decimal de la temperatura
int dec=0; //parte deciaml  0.0 o 0.5
int aux=0; //Variable auxiliar multipropósito
int16 tempe=0; // temperatura 16 bits
void entrada(void);//configuracion como entrada ds1820rw
void salida (void);//configuracion como salida ds1820rw
void write1(void);// escribir un bit 1 en el ds1820
void write0(void);// escribir u bit 0 en el ds1820
void leer_bit(void);// leer un bit del ds1820
void escribir_ds1820(void); //escribir ds1820
void read_ds1820(void); //leer ds1820
void conversion (void);// calculo de la temperatura
void ds1820_init(void)
{
entrada();
salida();
output_low(ds1820rw);
delay_us(480);
entrada();
delay_us(80);
delay_us(400);
}
int8 ds1820_read(void)
{
int1 tempe2=0;
ds1820_init();
comando=0xcc;//saltar rom
escribir_ds1820();
comando=0x44; //conversion A/D
escribir_ds1820();
delay_us(2000);//espero
ds1820_init();
comando=0xcc;//saltar rom
escribir_ds1820();
comando=0xbe;//inviar temperatura
escribir_ds1820();
delay_ms(750);
read_ds1820();
conversion();
return(tempe1);
}
void leer_bit(void)
{
bit_set(tempe,15);
salida();
output_low(ds1820rw);
delay_us(10);
entrada();
   if(bit_test(portb,3)==0)
   {
   bit_clear(tempe,15);
   }
delay_us(50);
}
void entrada (void)
{
set_tris_b(0b00001000);
}
void salida (void)
{
set_tris_b(0b00000000);
}
void write1(void)
{
salida();
output_low(ds1820rw);
delay_us(10);
entrada();
delay_us(50);
}
void write0(void)
{
salida();
output_low(ds1820rw);
delay_us(60);
entrada();
}
void escribir_ds1820(void)
{
   for(aux=1;aux<=8;aux++)
   {
      if (bit_test(comando,0)==0)
      {
      write0();
      }
      else
      {
      write1();
      }
   shift_right(&comando,1,0);
   }
}
void read_ds1820(void)
{
   for (aux=1;aux<=16;aux++)
   {
   shift_right(&tempe,2,1);
   leer_bit();
   }
      if (bit_test(tempe,15)==1)
      {
      tempe2=1;
      }
      else
      {
      tempe2=0;
      }
      if (bit_test(tempe,3)==1)
      {
      dec=5;
      }
      else
      {
      dec=0;
      }

}
void conversion (void)
{
tempe=tempe&0b0000011111110000;
   for(aux=1;aux<=4;aux++)
   {
   shift_right(&tempe,2,0);
   }
if(tempe2==1)
{
tempe=~tempe;
tempe=tempe+1;
if (dec==5)
{
tempe=tempe-1;
}
}
bit_clear(tempe,7);
tempe1=tempe;
}
int1 ds1820_sig(void)
{
return(tempe2);
}
int8 ds1820_dec(void)
{
return(dec);
}


PD:  le di la libreria a un amigo y me  digo que  solo funcionaba cuando se conectaba  al PINB3 el ds18b20(para el cual estaba diseño la libreria en su inicio)