DS18B20 Primero escaneo y luego GETTEMP

Buen dia les explico un poquito la mano…

Este codigo lo que hace es escuchar el pin 2 de la arduino, donde yo anteriormente setee que en el “one_wire_bus_PIN2” estan enchufados 2 sensores.
que son estos
DeviceAddress Sensor01 = { 0x28, 0xFF, 0x62, 0x96, 0x74, 0x04, 0x00, 0x78 };
DeviceAddress Sensor02 = { 0x28, 0xFF, 0x23, 0x4C, 0x78, 0x04, 0x00, 0xFD }

-----------------------------------------------------------------------------------------------------------------------Una vez que le aclaré al programa que en el bus pin 2 el sensor01 es xxxxx y el sensor01 es xxxx2. Hace toda una operacion matematica para tirarme los grados centigrados, con un if que si es mayor a 24 ºc me prenda un led situado en el pin 13. si no… que lo apague. (las lecturas son cada 3 segundos)

(este es el codigo)

#include <OneWire.h>

//Get DallasTemperature Library here:  http://milesburton.com/Main_Page?title=Dallas_Temperature_Control_Library
#include <DallasTemperature.h>

/*-----( Declare Constants and Pin Numbers )-----*/
#define ONE_WIRE_BUS_PIN 2

/*-----( Declare objects )-----*/
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(ONE_WIRE_BUS_PIN);
int led = 13;
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);

/*-----( Declare Variables )-----*/
// Assign the addresses of your 1-Wire temp sensors.
// See the tutorial on how to obtain these addresses:
// http://www.hacktronics.com/Tutorials/arduino-1-wire-address-finder.html

DeviceAddress Sensor01 = { 0x28, 0xFF, 0x62, 0x96, 0x74, 0x04, 0x00, 0x78 }; 
DeviceAddress Sensor02 = { 0x28, 0xFF, 0x23, 0x4C, 0x78, 0x04, 0x00, 0xFD };

void setup()   /****** SETUP: RUNS ONCE ******/
{
 pinMode(led, OUTPUT);
 // start serial port to show results
 Serial.begin(9600);
 Serial.print("Cargando Libreria Read Temp SGIT ");
 Serial.println(DALLASTEMPLIBVERSION);
 
 // Initialize the Temperature measurement library
 sensors.begin();
 
 // set the resolution to 10 bit (Can be 9 to 12 bits .. lower is faster)
 sensors.setResolution(Sensor01, 10);
 sensors.setResolution(Sensor02, 10);
 
}//--(end setup )---

void loop()   /****** LOOP: RUNS CONSTANTLY ******/
{
 delay(3000);
 Serial.println();
 Serial.print("Numero de sensores en el mismo canal = ");  
 Serial.println(sensors.getDeviceCount());   
 Serial.print("Obteniendo Temperaturas... ");  
 Serial.println();   
 
 // Command all devices on bus to read temperature  
 sensors.requestTemperatures();  
 
 Serial.print("Sensor01 Temperatura:   ");
 printTemperature(Sensor01);
 Serial.println();

 Serial.print("Sensor02 Temperatura:   ");
 printTemperature(Sensor02);
 Serial.println();
  
}//--(end main loop )---

/*-----( Declare User-written Functions )-----*/
void printTemperature(DeviceAddress deviceAddress)
{

float tempC = sensors.getTempC(deviceAddress);

  if (tempC == -127.00) 
  {
  Serial.print("Error al obtener temperatura");
    }
   if (tempC > 20.00) 
  {
 digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
   Serial.print("ALTA TEMPERATURA");
    } 
   if (tempC < 20.00) 
  {
  digitalWrite(led, LOW);
    }
  else
  {
  Serial.print("C: ");
  Serial.print(tempC);
  
  }
   
}

Si entendiste esto, vas a ver que.

Yo en un BUS puedo tener enchufados x cantidad de termometros, si declaro la MACADRESS (por asi decirlo) de cada sensor, entonces aplica el codigo anterior y me tira la temp.

Yo puedo tener un BUS en el pin2 y otro Bus en el pin 3.
por lo que tendria que declarar

“one_wire_bus_PIN2” (x sesores con identificacion x12cx3zaraza)
y luego
“one_wire_bus_PIN3” (x sensores con identificacion x123123xzarazados)

Aplico el codigo de temperatura y me muestra los datos.

Lo que pasa con el codigo anterior es que si se me jode un sensor tengo que al cambiarlo tambien cambiar la macadress del sensor en el codigo, sin embargo con este codigo uno puede hacer que el arduino te escanee el bus que dijiste y te tire las direcciones de todos los sensores enchufados en ese bus…

#include <OneWire.h>

/*-----( Declare Constants and Pin Numbers )-----*/
#define SENSOR_1_PIN 2 // For BUS 1
#define SENSOR_2_PIN 3 // For BUS 2

/*-----( Declare objects )-----*/
OneWire  Bus1(SENSOR_1_PIN);  // Create a 1-wire object
OneWire  Bus2(SENSOR_2_PIN);  // Create another 1-wire object

void setup()  /****** SETUP: RUNS ONCE ******/
{
 Serial.begin(9600);
 Serial.println("Searching for DS18B20's on two different busses");
 Serial.println();

 Serial.println("Searching for DS18B20's on BUS ONE");  
 discoverBusOneWireDevices();  

 Serial.println();
 Serial.println();

 Serial.println("Searching for DS18B20's on BUS TWO");    
 discoverBusTwoWireDevices();  
 
}//--(end setup )---

void loop()   /****** LOOP: RUNS CONSTANTLY ******/
{
 // Nothing happening here
}

/*-----( Declare User-written Functions )-----*/

void discoverBusOneWireDevices(void) 
{
 byte i;
 byte present = 0;
 byte data[12];
 byte addr[8];

 Serial.print("Looking for 1-Wire devices...\n\r");// "\n\r" is NewLine 
 while(Bus1.search(addr)) {
   Serial.print("\n\rFound \'1-Wire\' device with address:\n\r");
   for( i = 0; i < 8; i++) {
     Serial.print("0x");
     if (addr[i] < 16) {
       Serial.print('0');
     }
     Serial.print(addr[i], HEX);
     if (i < 7) {
       Serial.print(", ");
     }
   }
   if ( OneWire::crc8( addr, 7) != addr[7]) {
     Serial.print("CRC is not valid!\n\r");
     return;
   }
 }
 Serial.println();
 Serial.print("Done");
 Bus1.reset_search();
 return;
}// END

//------------------------------------------------------------
void discoverBusTwoWireDevices(void) 
{
 byte i;
 byte present = 0;
 byte data[12];
 byte addr[8];

 Serial.print("Looking for 1-Wire devices...\n\r");// "\n\r" is NewLine 
 while(Bus2.search(addr)) {
   Serial.print("\n\rFound \'1-Wire\' device with address:\n\r");
   for( i = 0; i < 8; i++) {
     Serial.print("0x");
     if (addr[i] < 16) {
       Serial.print('0');
     }
     Serial.print(addr[i], HEX);
     if (i < 7) {
       Serial.print(", ");
     }
   }
   if ( OneWire::crc8( addr, 7) != addr[7]) {
     Serial.print("CRC is not valid!\n\r");
     return;
   }
 }
 Serial.println();
 Serial.print("Done");
 Bus2.reset_search();
 return;
}//END


//*********( THE END )***********

(esto lo que hace es buscar en el pin que le declare todas las mac adrees de los sensores y despues me hace un serial print y me las muestra)

PREGUNTAAA

Yo lo que quiero hacer es usar este codigo y que el resultado del escaneo me lo tire como

BusPIN2
Sensor01 (x32232390i9zaraza)
sensor01 (x394834743)

Entonces luego los asigna automaticamente, con esto lo que yo me evito es tocar el codigo si se rompe un sensor… por que uniendo estos 2 tengo…

El escaner que busca los sensores segun el bus… y luego los declara para que se utilice en el codigo para sacar la temperatura.

Espero que se entienda

Saludos a todos

Necesito orientacion (no pretendo que me escriban el codigo)

saludos nuevamente.

Hola.
Por favor; primeramente edita tu post y envuelve las secciones de código entre etiquetas code. Para ello seleccionas y pinchas el icono en forma de papiro que tienes encima del editor (al parar el ratón sobre él verás que aparece code junto al puntero). Verás que tu post se verá más bonito y, lo que es más importante, íntegro, porque verás que algunos símbolos importantes han desaparecido (por ejemplo algunos índices que van entre corchetes).
Y finalmente explica exactamente qué quieres: ¿un bus o dos? ¿un número fijo o variable de sensores?

Muchas gracias por los comentarios, ahora pude dejarlo como me pediste.

Basicamente explicandome mejor.

Lo que necesito es tomar la temperatura de 4 heladeras, como es muy importante para mi que esa temperatura sea exacta voy a poner 1 bus por heladera y a su vez 2 sensores DS18B20 por bus.

Resumiendo

son 4 buses uno en cada pin de arduino correspondiente, que a su vez deben poder escanear las identificaciones de los DS18B20 que le ponga (QUE VAN A SER 2). Luego el programa debe tomar esas 2 direcciones hacer un Get_Temp de ellos entonces los mostrarian con un print.

"Temperatura Heladera I: 10ºC SP 10.05ºC SS"
"Temperatura Heladera II 11ºC SP 12ºC SS"

SP: Sensor Primario
SC Sensor Secundario.

AHora la razon por la cual hago este post es:

Estos sensores de cada heladera trabajaran a muy baja temperatura, por lo que es probable que cada x tiempo alguno falle y haya que reemplazarlo.

SI yo aplico el codigo I que menciono al comienzo del post, tengo que declarar la direccion individual de cada DS18B20

Basicamente lo que quiero hacer es unir los 2 codigos para que la arduino, escanee por bus, identifique los id de ambos sensores y luego las declare en la formula para hacer el GET-TEMP

¿Es logico esto?

Saludos y muchas gracias.

Solo el código va entre tags, tus comentarios no.

Bueno rescato esto con esfuerzo

PREGUNTAAA

Yo lo que quiero hacer es usar este codigo y que el resultado del escaneo me lo tire como

BusPIN2
Sensor01 (x32232390i9zaraza)
sensor01 (x394834743)

Entonces luego los asigna automaticamente, con esto lo que yo me evito es tocar el codigo si se rompe un sensor... por que uniendo estos 2 tengo..

El escaner que busca los sensores segun el bus... y luego los declara para que se utilice en el codigo para sacar la temperatura.

Ahora tirón de orejas. No estas en Argentina zaraza, habla en español neutro que todos entiendan.

Bien lo que quieres es usar el segundo código que autodetecta los sensores Dallas con la parte del primer código que te muestra las temperaturas no?

surbyte:
Solo el código va entre tags, tus comentarios no.

Bueno rescato esto con esfuerzo

Ahora tirón de orejas. No estas en Argentina zaraza, habla en español neutro que todos entiendan.

Bien lo que quieres es usar el segundo código que autodetecta los sensores Dallas con la parte del primer código que te muestra las temperaturas no?

Disculpa, gracias por las indicaciones haremos lo posible para que no se me escape. (problema de apuros)

Exacto, quiero fucionar ambos codigos. Mas aribba en otra rta que puse.. comento bien la situacion de mi proyecto y ahi entenderas el concepto fisico y el por que de este problema.

lavergarock:
Muchas gracias por los comentarios, ahora pude dejarlo como me pediste.

Basicamente explicandome mejor.

Lo que necesito es tomar la temperatura de 4 heladeras, como es muy importante para mi que esa temperatura sea exacta voy a poner 1 bus por heladera y a su vez 2 sensores DS18B20 por bus.

Resumiendo

son 4 buses uno en cada pin de arduino correspondiente, que a su vez deben poder escanear las identificaciones de los DS18B20 que le ponga (QUE VAN A SER 2). Luego el programa debe tomar esas 2 direcciones hacer un Get_Temp de ellos entonces los mostrarian con un print.

"Temperatura Heladera I: 10ºC SP 10.05ºC SS"
"Temperatura Heladera II 11ºC SP 12ºC SS"

SP: Sensor Primario
SC Sensor Secundario.

AHora la razon por la cual hago este post es:

Estos sensores de cada heladera trabajaran a muy baja temperatura, por lo que es probable que cada x tiempo alguno falle y haya que reemplazarlo.

SI yo aplico el codigo I que menciono al comienzo del post, tengo que declarar la direccion individual de cada DS18B20

Basicamente lo que quiero hacer es unir los 2 codigos para que la arduino, escanee por bus, identifique los id de ambos sensores y luego las declare en la formula para hacer el GET-TEMP

¿Es logico esto?

Saludos y muchas gracias.

Jajaja, bueno te explico algo.
El codigo va con tags.
Si citas algo de otra persona va con tags quote, pero si escribes tu, no va con tags.
Asi que tenlo presente para la proxima.

No se si es lógico, pero entiendo lo que planteas y desde tu punto de vista esta bien.

porque tenes dos dalas conectados a dos pines distintos? Eso no es lógico.
Deberías montar todos en el mismo bus.

No no,

Tengo el pin 2 referido al bus1 en donde tengo conectados 2 dallas. Luego

Tengo el pin 3 referido al bus2 en donde tengo conectados 2 dallas. y asi y asi.

Lo que tengo conectado en diferentes pines es el bus1.

y porque no estan todos conectados a un solo pin. Si puede manejar muchos dallas.

Por que al realizar el Get DallasTemperature lo realiza (como en el 1er codigo) por BUS.

Al tener diferenciado por Bus diferenciado, puedo referime bien a que en todo el codigo donde me refiero a

BUS1 " se que es la heladera 1"

Bus2 “se que es la heladera 2” y asi en total 4.

Como bien dije cada bus va a tener 2 sensores uno primario y uno secundario.
En el primer codigo yo puedo poner que el bus1 es el sensor xxxxx1 y el xxxxx2; Bus2 xxxx43 y xxxxx47; etc

Si pongo todos en el mismo bus, voy a escanear los 8 Dallas y no voy a saber cual es de cual heladera, es decir voy a depender si o si de saber las identificaciones de cada sensor y saber cual está en cada heladera.

El problema está en que una vez realizado este programa si se un dalas de cualquier de los buses se rompa no tengo que tocar el codigo.

Es por ello lo de buses separados por que si logro hacer que escanee por bus y luego pueda declarar las direcciones individuales de cada bus en el get temp cuando se rompa uno y lo cambien no tendria por que afectar al codigo.

Lo bueno de esto es que yo le dejo al usuario 4 salidas con 2 sensores cada una.
Por lo que se que la salida 1 es el pin 2 de aruduino, salida 2 es el pin 3 de arduino,

Espero haberme explicado mejor.

Bien. Te comprendo y aunque aun te la puedo seguir peleando lo dejo ahi porque quien soy para cuestionarte.
Dejame que fusione los dos programas para avanzar con esto.

Igual no hay drama yo escucho, no hace mucho tiempo estoy con arduino por lo que a lo mejor tienes una mejor idea... o un concepto diferente al mio que no hace que las cosas se compliquen tanto.

Llevará display LCD?, porque si fuera asi imagina esta situación. Arrancas con los Dallas con los que vas a trabajar, el programa lee los MAC y tu los identificas, como S1 a Sn y por lo tanto sabes su ubicación.
Cuando uno se rompe o deja de funcionar vas a reemplazarlo y el que no encuentra es el reemplazado por una nueva MAC y misma ubicación.
Algo mas inteligente no?
De todas formas tu metodo funciona y el mio requiere de decirle quien es quien.

y si se rompen dos? no encontraria dos y ya no sabria identificarlo.

Si llevaria LCD.

¿Vos ves alguna forma de hacer que el codigo sea independiente a los sensores para que no tenngas que hacer actualizacion de la arduino cada vez que cambies uno?

abrazo.

Hola.
Es perfectamente factible detectar y asignar las direcciones en el setup para uno o varios bus onewire. Básicamente es hacerlo dos veces :). Lo que puede ser “complicado” es no saber el número máximo de dispositivos que vamos a encontrar en un bus, ya que habrá que reservar en memoria espacio para guardar las direcciones de cada uno. Se podría hacer también, asignando memoria dinámicamente, pero la programación es más “delicada”.
Dame un rato y pongo algo por aquí para dos buses con dos sensores.

noter:
Dame un rato y pongo algo por aquí para dos buses con dos sensores.

Me estoy dando la cabeza contra la pared con este articulo, pero puede serles util para las pruebas.
Yo mientras tambien continuo probando.

Es en un ambiente distinto pero la misma escencia.

No agregues mas variables (códigos), se elije un camino y se continúa en el.
Si luego necesitas enviar via Ethernet, es otra cosa.

bueno acá esta. Funciona con un leve error, lo que yo defini como tempHeladera21 y 22 al imprimirlos lo hace al revés.

#include <OneWire.h>
#include <DallasTemperature.h>

// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS_1 2
#define ONE_WIRE_BUS_2 3
#define TEMPERATURE_PRECISION 9

// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire1(ONE_WIRE_BUS_1);
OneWire oneWire2(ONE_WIRE_BUS_2);

// Pass our oneWire reference to Dallas Temperature. 
DallasTemperature sensors1(&oneWire1);
DallasTemperature sensors2(&oneWire2);
// arrays to hold device addresses
DeviceAddress tempHeladera11, tempHeladera12, tempHeladera21, tempHeladera22;

void setup(void)
{
  // start serial port
  Serial.begin(9600);
  Serial.println("Dallas Temperature IC Control Library Demo");

  // Start up the library
  sensors1.begin();
  sensors2.begin();
  
  // locate devices on the bus
  Serial.print("Localizando dispositivos Heladera1...");
  Serial.print("Encontrado ");
  Serial.print(sensors1.getDeviceCount(), DEC);
  Serial.println(" dispositivos.");

  Serial.print("Localizando dispositivos Heladera2...");
  Serial.print("Encontrado ");
  Serial.print(sensors2.getDeviceCount(), DEC);
  Serial.println(" dispositivos.");
  
  // report parasite power requirements
  Serial.print("La alimentacion parásita en Heladera 1 esta: "); 
  if (sensors1.isParasitePowerMode()) 
      Serial.println("ON");
  else 
      Serial.println("OFF");
  // report parasite power requirements
  Serial.print("La alimentacion parásita en Heladera 2 esta: "); 
  if (sensors2.isParasitePowerMode()) 
      Serial.println("ON");
  else 
      Serial.println("OFF");

  // assign address manually.  the addresses below will beed to be changed
  // to valid device addresses on your bus.  device address can be retrieved
  // by using either oneWire.search(deviceAddress) or individually via
  // sensors.getAddress(deviceAddress, index)
  //tempHeladera1 = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 };
  //tempHeladera2   = { 0x28, 0x3F, 0x1C, 0x31, 0x2, 0x0, 0x0, 0x2 };

  // search for devices on the bus and assign based on an index.  ideally,
  // you would do this to initially discover addresses on the bus and then 
  // use those addresses and manually assign them (see above) once you know 
  // the devices on your bus (and assuming they don't change).
  // 
  // method 1: by index
  if (!sensors1.getAddress(tempHeladera11, 0)) 
      Serial.println("Imposible encontrar direccion para Dispositivo 11 en Heladera 1"); 
  if (!sensors1.getAddress(tempHeladera12, 1)) 
      Serial.println("Imposible encontrar direccion para Dispositivo 12 en Heladera 1");

  if (!sensors2.getAddress(tempHeladera21, 0)) 
      Serial.println("Imposible encontrar direccion para Dispositivo 21 en Heladera 2"); 
  if (!sensors2.getAddress(tempHeladera22, 1)) 
      Serial.println("Imposible encontrar direccion para Dispositivo 22 en Heladera 2");


  // method 2: search()
  // search() looks for the next device. Returns 1 if a new address has been
  // returned. A zero might mean that the bus is shorted, there are no devices, 
  // or you have already retrieved all of them.  It might be a good idea to 
  // check the CRC to make sure you didn't get garbage.  The order is 
  // deterministic. You will always get the same devices in the same order
  //
  // Must be called before search()
  //oneWire.reset_search();
  // assigns the first address found to tempHeladera1
  //if (!oneWire.search(tempHeladera1)) Serial.println("Unable to find address for tempHeladera1");
  // assigns the seconds address found to tempHeladera2
  //if (!oneWire.search(tempHeladera2)) Serial.println("Unable to find address for tempHeladera2");

  // show the addresses we found on the bus
  Serial.print("Dispositivo 11 Direccion: ");
  printAddress(tempHeladera11);
  Serial.println();
  Serial.print("Dispositivo 12 Direccion: ");
  printAddress(tempHeladera12);  
  Serial.println();

  Serial.print("Dispositivo 21 Direccion: ");
  printAddress(tempHeladera21);
  Serial.println();
  Serial.print("Dispositivo 22 Direccion: ");
  printAddress(tempHeladera22);
  Serial.println();

  // set the resolution to 9 bit
  sensors1.setResolution(tempHeladera11, TEMPERATURE_PRECISION);
  sensors1.setResolution(tempHeladera12, TEMPERATURE_PRECISION);
  sensors2.setResolution(tempHeladera21, TEMPERATURE_PRECISION);
  sensors2.setResolution(tempHeladera22, TEMPERATURE_PRECISION);

  Serial.print("Device 11 Resolution: ");
  Serial.print(sensors1.getResolution(tempHeladera11), DEC); 
  Serial.print("Device 12 Resolution: ");
  Serial.print(sensors1.getResolution(tempHeladera11), DEC); 
  Serial.println();

  Serial.print("Device 21 Resolution: ");
  Serial.print(sensors2.getResolution(tempHeladera21), DEC); 
  Serial.print("Device 22 Resolution: ");
  Serial.print(sensors2.getResolution(tempHeladera22), DEC); 
  Serial.println();
}

// function to print a device address
void printAddress(DeviceAddress deviceAddress)
{
  for (uint8_t i = 0; i < 8; i++)
  {
    // zero pad the address if necessary
    if (deviceAddress[i] < 16) Serial.print("0");
    Serial.print(deviceAddress[i], HEX);
  }
}

// function to print the temperature for a device
void printTemperature(DallasTemperature &sensor, DeviceAddress deviceAddress)
{
  float tempC = sensor.getTempC(deviceAddress);
  Serial.print("Temp C: ");
  Serial.print(tempC);
}

// function to print a device's resolution
void printResolution(DallasTemperature &sensor, DeviceAddress deviceAddress)
{
  Serial.print("Resolution: ");
  Serial.print(sensor.getResolution(deviceAddress));
  Serial.println();    
}

// main function to print information about a device
void printData(DallasTemperature &sensor, DeviceAddress deviceAddress)
{
  Serial.print("Device Address: ");
  printAddress(deviceAddress);
  Serial.print(" ");
  printTemperature(sensor, deviceAddress);
  Serial.println();
}

void loop(void)
{ 
  // call sensors.requestTemperatures() to issue a global temperature 
  // request to all devices on the bus
  Serial.print("Requesting temperatures...");
  sensors1.requestTemperatures();
  sensors2.requestTemperatures();
  Serial.println("DONE");

  // print the device information
  printData(sensors1, tempHeladera11);
  printData(sensors1, tempHeladera12);  
  printData(sensors2, tempHeladera21);
  printData(sensors2, tempHeladera22);  
}

Muchas gracias, lo he probado recien y funciona.

Voy a tocarlo un poco y voy a hacerle las modificaciones que me comentaste.

Asi lo vuelvo a subir.

Si. Tienes textos de mas tal vez. Pero tomé el ejemplo de OneWire o de DallasTemperatura, los tuyos estaban malo incompletos, aunque encontré la pagina, me daban errores, Asi que tomé la idea y ajusté.

Lo interesante fue hacer que las rutinas de impresion funcionen para los dos sensores como esta

void printData(DallasTemperature &sensor, DeviceAddress deviceAddress)
{
  Serial.print("Device Address: ");
  printAddress(deviceAddress);
  Serial.print(" ");
  printTemperature(sensor, deviceAddress);
  Serial.println();
}

Igualmente lo modifica Noter y deja una pinturita. Pero a mi me gustó justamente esa solución que pasa el parámetro del sensor y lo hace utilizaba para ambos.