Te muestro la funcion que me pasaste hace un tiempo, porque la lectura que me muestra ahora es 30.0 antes mostraba 24, pero con 0.5 ahora es entre 0.5 y 0.7 grado de resolucion.
No se muy bien que es lo que hace la funcion por eso no puedo corregir nada.
float leer_temperatura(byte n)
{
int read_ok=0;
float t=0;
if(ow_reset()==0)
{
//write_byte(0xcc); //skip ROM
Send_MatchRom();
write_byte(0x44); //convert T
}
delay_ms(1); // retardo para desahogar al sensor y evitar posibles colisiones que el sensor
if(ow_reset()==0)
{
//write_byte(0xcc); //skip ROM
numROMs=n; // Metemos en la variable 'numROMs' el número del sensor del cual queremos medir la temperatura
Send_MatchRom();
write_byte(0xbe); //read scratchpad
temperatura_l=read_byte();
temperatura_h=read_byte();
read_ok=1;
}
if(read_ok)
{
t=make16(temperatura_h,temperatura_l); //calcula la temperatura
t=(t*1000*636)/1000000;
// t=t*50;
// t=t-25;
// t=t/100;
// t+=0.3;
return t;
} else {
numero_total_de_ROMs = 0;
}
}
Perdoname el tema es que no se electronica, lo hice de tomando cosas de internet y aprendi a programar en este lenguaje solo para hacerme este aparato y hay cosas que no caso una.
Te explico algunas de las cosas que me preguntabas.
El RTCC me referia al clock interno del PIC, como reloj externo uso el DS1307 que tiene una pila para que no se corte. Lo de la cantidad de veces no lo sabia.
Si hay que leer solo una vez por segundo olvidate todo lo que trate de explicarte, creo que yo solo me entiendo jaja.
Aca te paso toda la libreria que me pasaste por las dudas de que haya algo mal.
Desde ya nuevamente te agradesco.
1wire.h
//----------------------------------------------------------------
//
// 1wire.h
//
//
//
//
//
//
//----------------------------------------------------------------
//-------------------------data pin definition--------------------
#define DQ pin_A2
//----------------------------------------------------------------
//----------- AÑADIDO POR AZI - ------------------------------------
////////////////////////////////////////////////////////////////////////////
// GLOBAL VARIABLES
//
//unsigned char ROM_NO[8];
unsigned char ROMs[8]; // ROM Bit
unsigned char lastDiscrep = 0; // last discrepancy
unsigned char doneFlag = 0; // Done flag
unsigned char FoundROM[5][8]; // table of found ROM codes
unsigned char numROMs;
unsigned char dowcrc;
unsigned char dscrc_table[] = {
0, 94,188,226, 97, 63,221,131,194,156,126, 32,163,253, 31, 65,
157,195, 33,127,252,162, 64, 30, 95, 1,227,189, 62, 96,130,220,
35,125,159,193, 66, 28,254,160,225,191, 93, 3,128,222, 60, 98,
190,224, 2, 92,223,129, 99, 61,124, 34,192,158, 29, 67,161,255,
70, 24,250,164, 39,121,155,197,132,218, 56,102,229,187, 89, 7,
219,133,103, 57,186,228, 6, 88, 25, 71,165,251,120, 38,196,154,
101, 59,217,135, 4, 90,184,230,167,249, 27, 69,198,152,122, 36,
248,166, 68, 26,153,199, 37,123, 58,100,134,216, 91, 5,231,185,
140,210, 48,110,237,179, 81, 15, 78, 16,242,172, 47,113,147,205,
17, 79,173,243,112, 46,204,146,211,141,111, 49,178,236, 14, 80,
175,241, 19, 77,206,144,114, 44,109, 51,209,143, 12, 82,176,238,
50,108,142,208, 83, 13,239,177,240,174, 76, 18,145,207, 45,115,
202,148,118, 40,171,245, 23, 73, 8, 86,180,234,105, 55,213,139,
87, 9,235,181, 54,104,138,212,149,203, 41,119,244,170, 72, 22,
233,183, 85, 11,136,214, 52,106, 43,117,151,201, 74, 20,246,168,
116, 42,200,150, 21, 75,169,247,182,232, 10, 84,215,137,107, 53};
//unsigned char page_data[32];
//////////////////////////////////////////////////////////////////////////////
// OW_RESET - performs a reset on the one-wire bus and
// returns the presence detect. Reset is 480us, so delay
// value is (480-24)/16 = 28.5 - we use 29. Presence checked
// another 70us later, so delay is (70-24)/16 = 2.875 - we use 3.
//
ow_reset(void)
{
int presence;
output_low(DQ); //pull DQ line low
delay_us(480);// leave it low for 480us
output_bit(DQ,1); // allow line to return high
delay_us(72); // wait for presence
presence = input(DQ); // get presence signal
delay_us(424);
return(presence); // presence signal returned
} // 0=presence, 1 = no part
//////////////////////////////////////////////////////////////////////////////
// READ_BIT - reads a bit from the one-wire bus. The delay
// required for a read is 15us, so the DELAY routine won't work.
// We put our own delay function in this routine in the form of a
// for() loop.
//
byte read_bit(void)
{
//byte i;
output_bit(DQ,0); // pull DQ low to start timeslot
output_bit(DQ,1); // then return high
delay_us(15); // delay 15us from start of timeslot
return(input(DQ)); // return value of DQ line
}
//////////////////////////////////////////////////////////////////////////////
// WRITE_BIT - writes a bit to the one-wire bus, passed in bitval.
//
void write_bit(byte bitval)
{
output_bit(DQ,0); // pull DQ low to start timeslot
if(bitval==1) output_bit(DQ,1); // return DQ high if write 1
delay_us(104); // hold value for remainder of timeslot
output_bit(DQ,1);
}// Delay provides 16us per loop, plus 24us. Therefore delay(5) = 104us
//////////////////////////////////////////////////////////////////////////////
// READ_BYTE - reads a byte from the one-wire bus.
//
byte read_byte(void)
{
byte i;
byte value=0;
for (i=0;i<8;i++)
{
if(read_bit()) value|=0x01<<i; // reads byte in, one byte at a time and then
// shifts it left
delay_us(120); // wait for rest of timeslot
}
return(value);
}
//////////////////////////////////////////////////////////////////////////////
// WRITE_BYTE - writes a byte to the one-wire bus.
//
void write_byte(byte val)
{
byte i;
byte temp;
for (i=0; i<8; i++) // writes byte, one bit at a time
{
temp = val>>i; // shifts val right 'i' spaces
temp &= 0x01; // copy that bit to temp
write_bit(temp); // write bit in temp into
}
delay_us(104);
}
//////////////////////////////////////////////////////////////////////////////
// ONE WIRE CRC
//
unsigned char ow_crc( unsigned char x)
{
dowcrc = dscrc_table[dowcrc^x];
return dowcrc;
}
/////////////////////////////////////////////////////////////////////////////////
// NEXT
// The Next function searches for the next device on the 1-wire bus. If
// there are no more devices on the 1-wire then false is returned.
//
unsigned char Next(void)
{
unsigned char m = 1; // ROM Bit index
unsigned char n = 0; // ROM Byte index
unsigned char k = 1; // bit mask
unsigned char x = 0;
unsigned char discrepMarker = 0; // discrepancy marker
unsigned char g; // Output bit
unsigned char nxt; // return value
int flag;
nxt = FALSE; // set the next flag to false
dowcrc = 0; // reset the dowcrc
flag = ow_reset(); // reset the 1-wire
if(flag||doneFlag) // no parts -> return false
{
lastDiscrep = 0; // reset the search
return FALSE;
}
write_byte(0xF0); // send SearchROM command
do
// for all eight bytes
{
x = 0;
if(read_bit()==1) x = 2;
delay_us(120);
if(read_bit()==1) x |= 1; // and its complement
if(x ==3) // there are no devices on the 1-wire
break;
else
{
if(x>0) // all devices coupled have 0 or 1
g = x>>1; // bit write value for search
else
{
// if this discrepancy is before the last
// discrepancy on a previous Next then pick
// the same as last time
if(m<lastDiscrep)
g = ((ROMs[n]&k)>0);
else // if equal to last pick 1
g = (m==lastDiscrep); // if not then pick 0
// if 0 was picked then record
// position with mask k
if (g==0) discrepMarker = m;
}
if(g==1) // isolate bit in ROM[n] with mask k
ROMs[n] |= k;
else
ROMs[n] &= ~k;
write_bit(g); // ROM search write
m++; // increment bit counter m
k = k<<1; // and shift the bit mask k
if(k==0) // if the mask is 0 then go to new ROM
{ // byte n and reset mask
ow_crc(ROMs[n]); // accumulate the CRC
n++; k++;
}
}
}while(n<
; //loop until through all ROM bytes 0-7
if(m<65||dowcrc) // if search was unsuccessful then
lastDiscrep=0; // reset the last discrepancy to 0
else
{
// search was successful, so set lastDiscrep,
// lastOne, nxt
lastDiscrep = discrepMarker;
doneFlag = (lastDiscrep==0);
nxt = TRUE; // indicates search is not complete yet, more
// parts remain
}
return nxt;
}
////////////////////////////////////////////////////////////////////////////
// FIRST
// The First function resets the current state of a ROM search and calls
// Next to find the first device on the 1-wire bus.
//
unsigned char First(void)
{
lastDiscrep = 0; // reset the rom search last discrepancy global
doneFlag = FALSE;
return Next(); // call Next and return its return value
}
////////////////////////////////////////////////////////////////////////////////
// FIND DEVICES
void FindDevices(void)
{
unsigned char m;
if(!ow_reset()) //Begins when a presence is detected
{
if(First()) //Begins when at least one part is found
{
numROMs=0;
do
{
numROMs++;
for(m=0;m<8;m++)
{
FoundROM[numROMs][m]=ROMs[m]; //Identifies ROM
//number on found device
}
// printf("\nROM CODE =%02X%02X%02X%02X\n",FoundROM[4][7],FoundROM[4][6],FoundROM[4][5],FoundROM[4][4],FoundROM[4][3],FoundROM[4][2],FoundROM[4][1],FoundROM[4][0]);
}while (Next()&&(numROMs<10)); //Continues until no additional devices are found
}
}
else
{
numROMs=55;
}
}
////////////////////////////////////////////////////////////////////////////////
// Perform Match ROM
//
unsigned char Send_MatchRom(void)
{
unsigned char i;
if(ow_reset()) return false;
write_byte(0x55); // match ROM
for(i=0;i<8;i++)
{
write_byte(FoundROM[numROMs]
); //send ROM code
}
return true;
