Chat

Welcome to Flux

Treat Flux like your intern. Tell it what you'd like to build and it'll get to work. You can also ask it questions, brainstorm ideas, and teach it your preferences. Learn More

Explain project
Write a project description
Find schematic issues
Create a test plan
Simulate a circuit
Prepare for Manufacturing
Component Selection Workflow
New Subsystem Wizard
Write I2C initialization code
Generate firmware skeleton
en base a este código #include \<OneWire.h> \#include \<DallasTemperature.h> \#i...

como hacer para que al ingresar al bloque 2 pueda sonar una alarma que se pueda apagar con la tecla B
2y
// Definición de pines #define ONE_WIRE_BUS 9 //const int ONE_WIRE_BUS = 9; const int Buzzer_1 = 34; const int Buzzer_2 = 35; const int Rele_Resistencia_de_Macerado = 51; const int Rele_Bomba_1_Recirculado_Macerado = 52; const int Rele_heladera_Frio = 50; const int Rele_heladera_Calor = 53; const int led1_Agua_Macerado_y_Lavado = 40; const int led3_Calentado_Recirculado = 41; const int led2_Hervido = 42; const int led4_Adiciones_Tardias = 48; const int led5_Macerado_ON = 44; const int led6_Macerado_OFF = 45; const int led7_Heladera_Frio = 46; const int led8_Heladera_Calor = 47;
OneWire oneWire(ONE_WIRE_BUS); DallasTemperature sensors(&oneWire); LiquidCrystal_I2C lcd(0x27, 20, 4); RTC_DS1307 rtc;
DateTime tiempoInicio;
boolean INICIO_HERVIDO = true; boolean INICIO = true; boolean tiempoIniciado = false;
const byte ROWS = 4; const byte COLS = 4; char keys[ROWS][COLS] = { {'1', '2', '3', 'A'}, {'4', '5', '6', 'B'}, {'7', '8', '9', 'C'}, {'*', '0', '#', 'D'} }; byte rowPins[ROWS] = {22, 24, 26, 28}; byte colPins[COLS] = {23, 25, 27, 29}; Keypad teclado = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
/// Sensores float Sensor_Agua, Sensor_Mosto, Sensor_Hervido, Sensor_Fermentacion; void midoTemperaturas() { sensors.requestTemperatures(); Sensor_Agua = sensors.getTempCByIndex(0); Sensor_Mosto = sensors.getTempCByIndex(1); Sensor_Hervido = sensors.getTempCByIndex(2); Sensor_Fermentacion = sensors.getTempCByIndex(3); }
// Función para configurar los pines de salida void ConfigurarPinesSalida() { pinMode(led1_Agua_Macerado_y_Lavado, OUTPUT); pinMode(led2_Hervido, OUTPUT); pinMode(led3_Calentado_Recirculado, OUTPUT); pinMode(led4_Adiciones_Tardias, OUTPUT); pinMode(led5_Macerado_ON, OUTPUT); pinMode(led6_Macerado_OFF, OUTPUT); pinMode(led7_Heladera_Frio, OUTPUT); pinMode(led8_Heladera_Calor, OUTPUT);
pinMode(Buzzer_1, OUTPUT); pinMode(Buzzer_2, OUTPUT);
pinMode(Rele_Resistencia_de_Macerado, OUTPUT); pinMode(Rele_Bomba_1_Recirculado_Macerado, OUTPUT); pinMode(Rele_heladera_Frio, OUTPUT); pinMode(Rele_heladera_Calor, OUTPUT);
digitalWrite(Rele_Resistencia_de_Macerado, HIGH); digitalWrite(Rele_Bomba_1_Recirculado_Macerado, HIGH); digitalWrite(Rele_heladera_Frio, HIGH); digitalWrite(Rele_heladera_Calor, HIGH); }
void mostrarTiempo() { DateTime now = rtc.now(); TimeSpan diferencia = now - tiempoInicio;
lcd.setCursor(0, 3); lcd.print(diferencia.hours()); lcd.print(":");
if (diferencia.minutes() = 67.5) { digitalWrite(led3_Calentado_Recirculado, 0); digitalWrite (Rele_Resistencia_de_Macerado, 1); digitalWrite (Rele_Bomba_1_Recirculado_Macerado, 1); }
    break;
2y
This looks like an Arduino code for a brewing system. To explain briefly, here is what this Arduino program does:
  1. It uses the 1-Wire protocol for communication with the DS18B20 sensors used for temperature monitoring of different brewing processes like maceration, boiling, and fermentation.
  2. It uses digital IO pins to interact with LEDs, buzzers and relays that form an interface for the user and control different stages of the brewing process.
  3. It uses an I2C LCD display for user feedback and a keypad for user inputs.
  4. It uses an RTC (Real Time Clock) for timing purposes.
  5. In the brewing system, different brewing processes like maceration, boiling, and fermentation each have a dedicated temperature sensor.
  6. The brewing process can be controlled through the inputs from the keypad. Key presses correlate with different steps in the brewing process.
  7. For each brewing process, a separate case operation is set up in the main loop, and these can be selected via the keypad input.
To connect the components mentioned in the code to your project you should:
  • Connect the four DS18B20 sensors (designated as Sensor Agua, Sensor Macerado, Sensor Hervido, Sensor Fermentación) on the DQ line to pin 9 on the A1 (Arduino Mega). Each sensor DS18B20: VDD pin should be connected to a +3V3 supply, and GND pin to ground.
  • Connect both buzzers (+ pin of Buzzer 1 to A1:34 and + pin of Buzzer 2 to A1:35). The negative (-) pins of the buzzers connect to the ground of the power supply.
  • Connect the pins of the Keypad to pins 22-29 on A1 (Arduino Mega). They act as the row and column pins for the keypad.
  • Connect the Relay modules (to control resistance heaters and pumps) to pins 50,51,52 and 53 on A1.
  • Connect the LEDs used for indicating various statuses, to pins 40-48 on the A1.
For example, connections for the DS18B20 temperature sensor:
  • Connect Sensor Agua:GND to A1:GND1,
  • Connect Sensor Agua:VDD to A1:+3V3,
  • Connect Sensor Agua:DQ to A1:9.
The same would apply for the other three DS18B20 sensors.
Remember to assure that all ground planes are common to each other to prevent any ground potential issues. Make sure also to check the voltage levels of the components are compatible with the Arduino Mega IO pins (5V).
Note that the above suggestions were made assuming typical connections offered by the Arduino platform and the input/output operations stated in the provided code. Please review and make changes as necessary.
2y
Cómo hacer para que al ingresar al bloque 2 pueda sonar una alarma que se pueda apagar precionando la tecla B
2y
Para que una alarma suene al ingresar al bloque 2 y se pueda apagar al presionar la tecla 'B', puedes modificar el código en el caso '2' del switch dentro de la función void loop() de la siguiente manera:

Cpp


      switch (secuencia) {
        case 2: 
          if ( entrada == 1 ) {
            // Aquí rimero sonamos la alarma
            tone(Buzzer_1, 200); // Puedes ajustar el segundo parámetro para cambiar la frecuencia del sonido
    
            // El resto del código se mantiene igual...
    
            lcd.clear();
            entrada = 2;
            digitalWrite (led1_Agua_Macerado_y_Lavado, LOW);
            noTone(Buzzer_2);
            lcd.clear();
            lcd.setCursor(0, 0);
            lcd.print("2 -AGUA DE LAVADO- 3");
            lcd.setCursor (1, 1);
            lcd.print("23");
            lcd.print((char)223);
            lcd.setCursor(0, 2);
            lcd.print("-MACERADO- 22");
            lcd.print((char)223);
          }

          // ...

        break;
Y luego, en sección que verifica cual tecla ha sido presionada (igualmente dentro de la función void loop()), añade un caso para la tecla B de la siguiente manera:

Cpp


        if (key != NO_KEY) {
        // Realiza acciones según la tecla presionada
        switch (key) {
          
          //...
          
          case 'B': // Para apagar la alarma
            noTone(Buzzer_1);
            break;

          //...
        }
Ahora, cuando ingreses al caso 2, la alarma debería empezar a sonar y debería detenerse cuando presiones la tecla 'B'.
2y
este código es diferente pero realiza lo mismo. #include #include #include #include #include #include
// Definición de pines #define ONE_WIRE_BUS 9 const int Buzzer_1 = 34; const int Buzzer_2 = 35; const int Rele_Resistencia_de_Macerado = 51; const int Rele_Bomba_1_Recirculado_Macerado = 52; const int Rele_heladera_Frio = 50; const int Rele_heladera_Calor = 53; const int led1_Agua_Macerado_y_Lavado = 40; const int led3_Calentado_Recirculado = 41; const int led2_Hervido = 42; const int led4_Adiciones_Tardias = 48; const int led5_Macerado_ON = 44; const int led6_Macerado_OFF = 45; const int led7_Heladera_Frio = 46; const int led8_Heladera_Calor = 47;
OneWire oneWire(ONE_WIRE_BUS); DallasTemperature sensors(&oneWire); RTC_DS1307 rtc; LiquidCrystal_I2C lcd(0x27, 20, 4);
boolean INICIO_HERVIDO = true; boolean INICIO_Tecla_A = true; boolean INICIO_Tecla_B = true; boolean tiempoIniciado = false; DateTime tiempoInicio; TimeSpan tiempoTranscurrido; boolean zumbador2Activado = false; boolean alarma2Activada = false;
const byte ROWS = 4; const byte COLS = 4; char keys[ROWS][COLS] = { {'1', '2', '3', 'A'}, {'4', '5', '6', 'B'}, {'7', '8', '9', 'C'}, {'*', '0', '#', 'D'} }; byte rowPins[ROWS] = {22, 24, 26, 28}; byte colPins[COLS] = {23, 25, 27, 29};
Keypad teclado = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
/// Sensores float Sensor_Agua, Sensor_Mosto, Sensor_Hervido, Sensor_Fermentacion; void midoTemperaturas() { sensors.requestTemperatures(); Sensor_Agua = sensors.getTempCByIndex(0); Sensor_Mosto = sensors.getTempCByIndex(1); Sensor_Hervido = sensors.getTempCByIndex(2); Sensor_Fermentacion = sensors.getTempCByIndex(3); }
// Función para configurar los pines de salida void ConfigurarPinesSalida() { pinMode(led1_Agua_Macerado_y_Lavado, OUTPUT); pinMode(led2_Hervido, OUTPUT); pinMode(led3_Calentado_Recirculado, OUTPUT); pinMode(led4_Adiciones_Tardias, OUTPUT); pinMode(led5_Macerado_ON, OUTPUT); pinMode(led6_Macerado_OFF, OUTPUT); pinMode(led7_Heladera_Frio, OUTPUT); pinMode(led8_Heladera_Calor, OUTPUT);
pinMode(Buzzer_1, OUTPUT); pinMode(Buzzer_2, OUTPUT);
pinMode(Rele_Resistencia_de_Macerado, OUTPUT); pinMode(Rele_Bomba_1_Recirculado_Macerado, OUTPUT); pinMode(Rele_heladera_Frio, OUTPUT); pinMode(Rele_heladera_Calor, OUTPUT);
digitalWrite(Rele_Resistencia_de_Macerado, HIGH); digitalWrite(Rele_Bomba_1_Recirculado_Macerado, HIGH); digitalWrite(Rele_heladera_Frio, HIGH); digitalWrite(Rele_heladera_Calor, HIGH); }
void mostrarTiempo() { DateTime now = rtc.now(); TimeSpan diferencia = now - tiempoInicio;
lcd.setCursor(0, 3); lcd.print(diferencia.hours()); lcd.print(":");
if (diferencia.minutes() = 67.5) { digitalWrite(led3_Calentado_Recirculado, 0); digitalWrite (Rele_Resistencia_de_Macerado, 1); digitalWrite (Rele_Bomba_1_Recirculado_Macerado, 1); }
// Iniciar las alarmas de tiempo al ingresar a la sección "MACERADO" if (activarAlarma1) { tiempoAlarma1 = rtc.now(); activarAlarma1 = false; }
tiempoTranscurrido = rtc.now() - tiempoAlarma1;

// Activar el zumbador 2 después de 2 minutos
if (tiempoTranscurrido.minutes() >= 2 && !zumbador2Activado) {
  tone(Buzzer_2, 600);
  lcd.setCursor(2, 3);
  lcd.print("Alarma 2 activada");
  zumbador2Activado = true; // Zumbador 2 activado
}

// Activar la alarma2 después de 3 minutos y hacerla sonar de forma continua
if (tiempoTranscurrido.minutes() >= 3 && !alarma2Activada) {
  tone(Buzzer_2, 600);
  lcd.setCursor(2, 3);
  lcd.print("Alarma 2 activada");
  alarma2Activada = true; // Alarma 2 activada
}

// Apagar el zumbador 2 solo si se presiona la tecla B
if (INICIO_Tecla_B && zumbador2Activado) {
  noTone(Buzzer_2);
  lcd.setCursor(2, 3);
  lcd.print("Alarma 2 cancelada");
  INICIO_Tecla_B = false;
  zumbador2Activado = false; // Restablecer el estado del zumbador 2
}

// Apagar la alarma2 solo si se presiona la tecla B
if (INICIO_Tecla_B && alarma2Activada) {
  noTone(Buzzer_2);
  lcd.setCursor(2, 3);
  lcd.print("Alarma 2 cancelada");
  INICIO_Tecla_B = false;
  alarma2Activada = false; // Restablecer el estado de la alarma 2
}




// BLOQUE 3
if ( tecla == '3') {
  secuencia = 3;
  entrada = 1;
}
}
else if ( secuencia == 3 ) { if ( entrada == 1 ) { entrada = 2; lcd.clear (); lcd.setCursor(0, 0); lcd.print("3 -AGUA DE LAVADO- 4"); lcd.setCursor (0, 1); lcd.print("75"); lcd.print((char)223); lcd.setCursor(0, 2); lcd.print("-MACERADO- 67"); lcd.print((char)223); }
// BLOQUE 4

if ( tecla == '4') {
  secuencia = 4;
  entrada = 1;
}
}
else if ( secuencia == 4 ) { if ( entrada == 1 ) { entrada = 2; }
// BLOQUE 5

if ( tecla == '5') {
  secuencia = 5;
  entrada = 1;
}
}
else if ( secuencia == 5 ) { if ( entrada == 1 ) { entrada = 2;
}

if ( tecla == '6') {
  secuencia = 6;
  entrada = 1;
}
} else if ( secuencia == 6 ) { if ( entrada == 1 ) { entrada = 2;
}

if ( tecla == '2') {
  secuencia = 2;
  entrada = 1;
}
} }
se puede optimizar o mejorar?
2y
En su mayor parte, el código está bien diseñado y es bastante conciso. Sin embargo, hay ciertas mejoras y optimizaciones que se pueden realizar para hacer el código más eficiente:
  1. Funciones reutilizables: Existen varias partes del código que se repiten (por ejemplo, la configuración inical de la LCD en cada bloque de secuencias). Este tipo de secciones repetitivas pueden ser movidas a funciones reutilizables. Esta práctica no solo hará que el código sea más simple y fácil de leer, sino que también reducirá la probabilidad de errores y facilitará el mantenimiento del código.
  2. Evitar el uso de las constantes HIGH y LOW para controlar los releés: En su código, está utilizando HIGH para desactivar los releés y LOW para activarlos. Esto puede hacer que el código sea confuso para quienes no estén familiarizados con su proyecto. Sería preferible definir nuevas constantes, como RELE_OFF y RELE_ON, y usar estas constantes para un mejor control y claridad del código.
  3. Estructura de datos para releés, LEDs y sensores: En lugar de tener una variable separada para cada LED, releé y sensor, podría utilizar arrays y posiblemente estructuras para almacenar esta información. Esto hará que el código sea más manejable y fácil de actualizar si decide aumentar el número de componentes controlados.
  4. Uso de enumeraciones para estados de secuencia: En lugar de utilizar números enteros (por ejemplo, secuencia = 2), sería preferible utilizar valores de enumeración. Los valores enumerados son más fácilmente interpretables que los números solos, lo que mejorará la legibilidad del código.
Este código parece estar en una etapa temprana de su desarrollo y es probable que vaya a tener más características y componentes añadidos con el tiempo. Estas mejoras lo prepararán para un desarrollo más estructurado y eficiente a medida que su proyecto se expanda.

1

2y
se puede simplificar este código // Iniciar las alarmas de tiempo al ingresar a la sección "MACERADO" if (activarAlarma1) { tiempoAlarma1 = rtc.now(); activarAlarma1 = false; }
tiempoTranscurrido = rtc.now() - tiempoAlarma1;

// Activar el zumbador 2 después de 2 minutos
if (tiempoTranscurrido.minutes() >= 2 && !zumbador2Activado) {
  tone(Buzzer_2, 600);
  lcd.setCursor(2, 3);
  lcd.print("Alarma 2 activada");
  zumbador2Activado = true; // Zumbador 2 activado
}

// Activar la alarma2 después de 3 minutos y hacerla sonar de forma continua
if (tiempoTranscurrido.minutes() >= 3 && !alarma2Activada) {
  tone(Buzzer_2, 600);
  lcd.setCursor(2, 3);
  lcd.print("Alarma 2 activada");
  alarma2Activada = true; // Alarma 2 activada
}

// Apagar el zumbador 2 solo si se presiona la tecla B
if (INICIO_Tecla_B && zumbador2Activado) {
  noTone(Buzzer_2);
  lcd.setCursor(2, 3);
  lcd.print("Alarma 2 cancelada");
  INICIO_Tecla_B = false;
  zumbador2Activado = false; // Restablecer el estado del zumbador 2
}

// Apagar la alarma2 solo si se presiona la tecla B
if (INICIO_Tecla_B && alarma2Activada) {
  noTone(Buzzer_2);
  lcd.setCursor(2, 3);
  lcd.print("Alarma 2 cancelada");
  INICIO_Tecla_B = false;
  alarma2Activada = false; // Restablecer el estado de la alarma 2
}
2y
Sí, se puede simplificar y optimizar el código para las alarmas de la tecla B y el zumbador. En la versión simplificada, eliminamos la redundancia en la configuración de cada alarma y en la cancelación de cada alarma a través de la tecla B. También se puede simplificar la detección de las alarmas eliminando algunas de las variables de booleanas innecesarias.
Aquí está el código modificado:

Cpp


// Iniciar las alarmas de tiempo al ingresar a la sección "MACERADO"
if (activarAlarma1) {
  tiempoAlarma1 = rtc.now();
  activarAlarma1 = false;
}

tiempoTranscurrido = rtc.now() - tiempoAlarma1;

// Configurar y ejecutar alarmas
for(int minutos = 2; minutos <= 3; minutos++)
{
    if(tiempoTranscurrido.minutes() >= minutos && !alarmaActivada[minutos])
    {
        tone(Buzzer_2, 600);
        alarmaActivada[minutos] = true; // Alarma activada
              
        lcd.setCursor(2, 3);
        lcd.print("Alarma " + String(minutos) + " activada");
    } 
} 

// Apagar las alarmas solo si se presiona la tecla B
if (INICIO_Tecla_B) {
  
  for(int minutos = 2; minutos <= 3; minutos++)
  {
      // Si la alarma fue activada
      if(alarmaActivada[minutos])
      {
         noTone(Buzzer_2);
         lcd.setCursor(2, 3);
         lcd.print("Alarma " + String(minutos) + " cancelada");
         
         alarmaActivada[minutos] = false; // Restablecer el estado de las alarmas  
      }                
  }
  
  INICIO_Tecla_B = false;    
}
En este código modificado, se considera a alarmaActivada como un array booleano de longitud 4 para almacenar el estado de la alarma para cada uno de los minutos desde 2 a 3 inclusive. Por otro lado, se utiliza un loop for para la activación y cancelación de las alarmas, eliminando la redundancia del código.
2y
tengo la posibilidad de copiar y pegar esta solución?
2y
Sí, puedes copiar y pegar la solución anteriomente proporcionada en tu entorno de desarrollo. Si estás utilizando el Arduino IDE, simplemente puedes copiar todo el código proporcionado arriba y pegarlo en tu IDE para reemplazar las secciones equivalentes de tu propio código.
Si encuentras claros errores después de pegarlo, comprueba si todas las funciones y las variables que he utilizado están presentes en tu sketch de Arduino.
Si estás desarrollando en un entorno diferente, debes asegurarte de que las funcionalidades del lenguaje que he utilizado son compatibles con tu entorno de desarrollo.
Asegúrate de probar el código después de realizar cambios para verificar que todas las funciones de tu proyecto siguen funcionando como se espera y han sido implementadas correctamente.
2y
1
Sensor Fermentación
Buzzer 1
Sensor Macerado
Sensor Hervido
Sensor Agua
buzzer 2
A1
Resistencia macerado
led Agua

No files yet

Documents

    Documents are markdown text files which describe project goals, capture details, or even simulation outputs.

    Assets

    No assets added.

    Frail Coffee T-800

    Frail Coffee T-800 thumbnail
    Welcome to your new project. Imagine what you can build here.

    Properties

    Properties describe core aspects of the project.

    Pricing & Availability

    Distributor

    Qty 1

    Digi-Key

    $63.32

    LCSC

    $2.21–$2.66

    Mouser

    $48.40

    Controls