# Curva de calentamiento del agua

{% embed url="https://plot.ly/~bpadin/1/?share_key=d2liCcM6Ve0ksTXcUYq9R2" %}

```cpp
/*
  Lectura de un sensor digital de temperatura DS18B20.
  La temperatura se presenta en un display LCD I2C y en el monitor serie.
  Cada vez que se toma una nueva medida se emite un pitido.

  -------------------- LIBRERÍAS ----------------------------
  OneWire: comunicación entre el sensor y Arduino
  DallasTemperature: cálculos en el sensor
  Wire: comunicación entre la pantalla LCD y Arduino
  LiquidCrystal_I2C: manejo de la pantalla LCD

  ------------------- SENSOR DS18B20 -----------------------
  Pin 1 (GND) → GND
  Pin 2 (DATA) → pin digital 2 (puede cambiarse)
  Pin 3 (Vdd) → +5V o +3.3V
  Hay que añadir una resistencia pull-up de 4.7 kOhm entre +5V y DATA

  ------------------- DISPLAY LCD I2C ---------------------
  SCL: pin analógico 5 (señal de reloj)
  SDA: pin analógico 4 (transmisión de datos)
  VCC: 5V
  GND: GND

  ------------------ ZUMBADOR ----------------------
  + → pin digital 13
  - → GND
*/

// Incluimos las librería OneWire y DallasTemperature para el sensor
#include <OneWire.h>
#include <DallasTemperature.h>

// Incluimos las librerías Wire y LiquidCrystal_I2C para la pantalla LCD I2C
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Llamanos lcd a la instancia que hace referencia a nuestra pantalla LCD
// Indicamos la dirección, el número de columnas y el número de filas de la pantalla
LiquidCrystal_I2C lcd(0x27, 16, 2);

// La línea de datos del sensor está conectada al pin digital 2 de Arduino
const int ONE_WIRE_BUS = 2;

// La comunicación con el sensor la establecemos a través de una instancia que llamamos oneWire
OneWire oneWire(ONE_WIRE_BUS);

// Para referirnos al sensor usamos una instancia que llamamos sensor
DallasTemperature sensor(&oneWire);

// Pin de conexión del zumbador
const int zumbador = 13;

// Tiempo de espera entre medidas en segundos
const int espera = 10;

void setup()
{
  // Iniciamos la comunicación con el monitor serie
  Serial.begin(9600);
  Serial.println("Lectura del tiempo en segundos y la temperatura en grados centígrados ");
  Serial.println("Tiempo \t Temperatura ");
  Serial.println("====================");

  // Inicializamos el sensor
  sensor.begin();

  // Inicializamos el LCD
  lcd.begin();

  // Inicializamos el pin del zumbador como salida
  pinMode(zumbador, OUTPUT);

  // Medida inicial
  sensor.requestTemperatures();
  float temperatura = sensor.getTempCByIndex(0);
  Serial.print("0\t");
  Serial.println(temperatura);
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("t = 0 s");
  lcd.setCursor(0, 1);
  lcd.print("T = ");
  lcd.print(temperatura);
  lcd.print(" ");
  lcd.write(B11011111);
  lcd.print("C");
  digitalWrite(zumbador, HIGH);
  delay(5);  
  digitalWrite(zumbador, LOW);
}

void loop()
{
  // Con la función millis() obtenemos el tiempo en milisegundos
  // que ha pasado desde que empezó el programa
  unsigned long tiempo = millis();

  // Solo tomamos medidas si el tiempo es un múltiplo del tiempo de espera
  if (tiempo % (1000 * espera) == 0)
  {
    // Usamos la función requestTemperatures() para obtener la temperatura
    sensor.requestTemperatures();

    // La función getTempCByIndex(i) nos da la temperatura del sensor i
    // Leemos la temperatura del sensor (i=0) y almacenamos el valor en una variable
    float temperatura = sensor.getTempCByIndex(0);

    // Borramos la pantalla
    lcd.clear();

    // Pasamos el tiempo a segundos y lo imprimimos en el LCD
    // Primera línea
    lcd.setCursor(0, 0);
    lcd.print("t = ");
    lcd.print(tiempo / 1000);
    lcd.print(" s");

    // Imprimimos la temperatura en el LCD
    // Segunda línea
    lcd.setCursor(0, 1);
    lcd.print("T = ");
    lcd.print(temperatura);
    lcd.print(" ");
    lcd.write(B11011111);    // Símbolo de grado
    lcd.print("C");

    // Imprimimos los datos en el monitor serie
    Serial.print(tiempo / 1000);
    Serial.print("\t");
    Serial.println(temperatura);

    // Se emite un pitido cada vez que se toma una medida
    digitalWrite(zumbador, HIGH);   // encendemos el zumbador
    delay(5);                       // esperamos 5 ms
    digitalWrite(zumbador, LOW);    // apagamos el zumbador
  }
}
```

