74hc595 y cd74hc4067 juntos

TRANSPONDER · October 15, 2023, 11:34am

Buenos días a todos, Soy David, y nuevo en el foro y todo.

Estoy realizando un proyecto con un un ESP-WROOM-32 para que controle 4 motores de 12V mediante L298N vía WEB o a posteriori BLUETHOOT..., para ello he usado dos multiplexores 74HC595, el primero para controlar los pines n1-4 de cada L298N, y un segundo en cascada para 8 leds que se enciendan o apaguen si las compuertas que mueven los motores están abiertas o cerradas.... Éstos multiplexores están conectados a los pines: STCP o RCLK (12) al 21, SHCP o SRCL(11) al 22 y DS o SER(14) al 23 del ESP-WROOM-32, y mi pregunta es: ¿Qué pines puedo usar para añadir el CD74HC4067 para los botones del control manual? o reorganizar el conexionado, he provado con const int muxSIG = 34;
S0 = 16; S1 = 17; S2 = 18 y S3 = 19 y no he conseguido nada a parte de que se queden encendidos todos los leds (la prueba de los motores la efectúo con leds en vez de los Drivers de los motores).

Gracias por todo.

Adjunto imagen del esquema en dearrollo, me falta por colocar los interruptores y el código, perdonad pues soy un poco torpe y es la forma que tengo de organizarme...


// Comprueba la placa seleccionada

#if defined(ESP8266)
#include <ESP8266WiFi.h>
#elif defined(ESP32) // Comprueba si la placa seleccionada es ESP32
#include <WiFi.h>
#else
#error "Placa no compatible"
#endif

const char* ssid = "Mi_SSID";
const char* password = "Mi_contraseña@";

IPAddress local_IP(192, 168, 1, 200);
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0); 
IPAddress primaryDNS(8, 8, 8, 8); //opcional 
IPAddress secondaryDNS(8, 8, 4, 4); //opcional 

//  Definimos variable general sumatoria:

int salida_multiplexor_01;
int salida_multiplexor_02;

//  Definimos las salidas de los multiplexores:

//  Multiplexor 1

int r1a = 1;   // salida 1
int r1c = 2;   // salida 2
int r2a = 4;   // salida 3
int r2c = 8;   // salida 4
int r3a = 16;  // salida 5
int r3c = 32;  // salida 6
int r4a = 64;  // salida 7
int r4c = 128; // salida 8

// Multiplexor 2

int lc1 = 1;   // salida 1
int lc2 = 2;   // salida 2
int lc3 = 4;   // salida 3
int lc4 = 8;   // salida 4
int lc5 = 16;  // salida 5
int lc6 = 32;  // salida 6
int lc7 = 64;  // salida 7
int lc8 = 128; // salida 8


int latchPin = 21; //STCP o RCLK pin 12 del multiplexor 74HC595. 21
int clockPin = 22; //SHCP o SRCLK pin 11 del multiplexor 74HC595. 22
int dataPin = 23; //DS o SER pin 14  del multiplexor 74HC595. 23
//int outputEnablePin = 3; // PWM del esp al OE pin 13  del multiplexor 74HC595.

WiFiServer server(80); // Port 80

//definimos los estados para control.
String estadoR1 = "OFF";
String estadoR2 = "OFF";
String estadoR3 = "OFF";
String estadoR4 = "OFF";
//String estado = "";

bool rejilla1Abierta = false;
bool rejilla2Abierta = false;
bool rejilla3Abierta = false;
bool rejilla4Abierta = false;

// Definimos los tiempos de Apertura y cierre.
int tiempoApertura = 1000; // Tiempo para Abrir.
int tiempoCierre = 1000;  // Tiempo para Cerrar.

 // Tiempo para volver a conectarse cuando se pierde la conexión.
int wait30 = 30000;

void setup() {

// Definimos estado pines del 74HC595 como OUTPUT.
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
//pinMode(outputEnablePin, OUTPUT);

// Definimos estado pines del 74HC595 como en estado bajo.
digitalWrite(latchPin,LOW);
digitalWrite(dataPin,LOW);
digitalWrite(clockPin,LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, LOW);
      digitalWrite(latchPin, HIGH); 

// Iniciamos el puerto serie.

  Serial.begin(115200);


// Configurando IP estatica.
  if (!WiFi.config(local_IP, gateway, subnet, primaryDNS, secondaryDNS)) {
    Serial.println("Error in configuration.");
  }

// Conectar red WiFi.
  Serial.println();
  Serial.println(WiFi.macAddress());
  Serial.print("Connectando con ");
  Serial.println(ssid);
 
  WiFi.begin(ssid, password); // Conecta a la wifi.
 
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("Conectado a WiFi.");
 
  // Iniciar Servidor Web.
  server.begin();
  Serial.println("Servidor Web Iniciado.");
 
  // Mostrar la IP y Mac del ESP.
  Serial.print("Esta es la IP para conectarse al WebServer: ");
  Serial.print("http://");
  Serial.println(WiFi.localIP());
  Serial.print("y la dirección MAC de la placa es: ");
  Serial.println(WiFi.macAddress());

  //digitalWrite(LEDON1, LOW);
  //digitalWrite(LEDOFF1, HIGH);
  //shiftOut(dataPin, clockPin, LSBFIRST, (B0000000));
         
  
Serial.println("Valor de salida salida_multiplexor_01: " + String(salida_multiplexor_01));
Serial.println("Valor de salida salida_multiplexor_02: " + String(salida_multiplexor_02));


}



////////////////////////////////////////////////////////////////////////////
//******                  Inicio void loop                          ******//
////////////////////////////////////////////////////////////////////////////


void loop() {

// Definimos estado pines del 74HC595 como en estado bajo.
digitalWrite(latchPin,LOW);
digitalWrite(dataPin,LOW);
digitalWrite(clockPin,LOW);

      // Si desconectado, intentar reconectar cada 30 segundos.
      if ((WiFi.status() != WL_CONNECTED) && (millis() > wait30)) {
          Serial.println("Intentando reconectar WiFi...");
          WiFi.disconnect();
          WiFi.begin(ssid, password);
          wait30 = millis() + 30000;

 
      }

 
      ////////////////////////////////////////////////////////////////////////////
      //                Verifica si un cliente se ha conectado.                 //
      ////////////////////////////////////////////////////////////////////////////

      WiFiClient client = server.available();
      if (!client) {
         return;
      }

      Serial.print("Nuevo cliente: ");
      Serial.println(client.remoteIP());

      ////////////////////////////////////////////////////////////////////////////
      //              Espera hasta que el cliente envíe datos.                  //
      ////////////////////////////////////////////////////////////////////////////

   while(!client.available()){ delay(1); }


      Serial.println("Valor de salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida_multiplexor_02: " + String(salida_multiplexor_02));



      ////////////////////////////////////////////////////////////////////////////
      //            Leer la información enviada por el cliente.                 //
      ////////////////////////////////////////////////////////////////////////////

        String req = client.readStringUntil('\r');
        Serial.println(req);


      ////////////////////////////////////////////////////////////////////////////
      //               Realizar la solicitud del cliente.                       //
      ////////////////////////////////////////////////////////////////////////////

        if (req.indexOf("on1") != -1){
          abrir_1(); // Llama a la función abrir_1()
        }
        if (req.indexOf("off1") != -1){
          cerrar_1(); // Llama a la función abrir_1()   
        }

        if (req.indexOf("on2") != -1){
          abrir_2(); // Llama a la función abrir_1()
        }
        if (req.indexOf("off2") != -1){
          cerrar_2(); // Llama a la función abrir_1()   
        }

        if (req.indexOf("on3") != -1){
          abrir_3(); // Llama a la función abrir_1()
        }
        if (req.indexOf("off3") != -1){
          cerrar_3(); // Llama a la función abrir_1()   
        }

        if (req.indexOf("on4") != -1){
          abrir_4(); // Llama a la función abrir_1()
        }
        if (req.indexOf("off4") != -1){
          cerrar_4(); // Llama a la función abrir_1()   
        }


      ////////////////////////////////////////////////////////////////////////////
      //                        Inicio página WEB                               //
      ////////////////////////////////////////////////////////////////////////////


      client.println("<!DOCTYPE HTML>");
      
      client.println("<html lang='es'>");
      client.println("<html>");
      client.println("<head><meta charset=utf-8></head>");
      client.println("<head><meta name='viewport' content='width=device-width, initial-scale=1.0");      
      
      client.println("<br>");

      client.println("<body><center><font face='Optima'>");
      client.println("<h1><center><font color=' #0000CC '>-- Servidor web ESP32 --</h1>");

      client.println("<h2><center><font color='#009900'>Control de Rejillas de ventilación</font></h2>");

      //client.println("<h4>https:www.ebconsultores.com</h4>");
      client.println("<h4><center><font color=' #0099FF '><a href='https:www.ebconsultores.com'>By EBConsultores</a>");

      client.println("<br><br>");


      if (rejilla1Abierta) {
        client.println("<a href='on1'><button style='height:70px; width:70px; border-radius:5px; border-style: solid; border-color: green; border-width: 3px; background-color: lightgreen; '><b>Abierta<br><br>R1</button></a>");
      } else {
        client.println("<a href='on1'><button style='height:70px; width:70px; border-radius:5px; background-color: LightCyan; '><b>Abrir<br><br>R1</button></a>");
      }

      if (rejilla2Abierta) {
        client.println("<a href='on2'><button style='height:70px; width:70px; border-radius:5px;  border-style: solid; border-color: green; border-width: 3px; background-color: lightgreen;'><b>Abierta<br><br>R2</button></a>");
      } else {
        client.println("<a href='on2'><button style='height:70px; width:70px; border-radius:5px; background-color: LightCyan;'><b>Abrir<br><br>R2</button></a>");
      }

      if (rejilla3Abierta) {
        client.println("<a href='on3'><button style='height:70px; width:70px; border-radius:5px;  border-style: solid; border-color: green; border-width: 3px; background-color: lightgreen;'><b>Abierta<br><br>R3</button></a>");
      } else {
        client.println("<a href='on3'><button style='height:70px; width:70px; border-radius:5px; background-color: LightCyan;'><b>Abrir<br><br>R3</button></a>");
      }

      if (rejilla4Abierta) {
        client.println("<a href='on4'><button style='height:70px; width:70px; border-radius:5px;  border-style: solid; border-color: green; border-width: 3px; background-color: lightgreen;'><b>Abierta<br><br>R4</button></a>");
      } else {
        client.println("<a href='on4'><button style='height:70px; width:70px; border-radius:5px; background-color: LightCyan;'><b>Abrir<br><br>R4</button></a>");
      }

      // client.println("<a href='on1'><button> Abrir </p>R1</button></a>");
      // client.println("<a href='on2'><button> Abrir </p>R2</button></a>");
      // client.println("<a href='on3'><button> Abrir </p>R3</button></a>");
      // client.println("<a href='on4'><button> Abrir </p>R4</button></a>");

      client.println("<br><br>");

      if (rejilla1Abierta) {
        client.println("<a href='off1'><button style='height:70px; width:70px; border-radius:5px; background-color: LightCyan;'><b>Cerrar<br><br>R1</button></a>");
      } else {
        client.println("<a href='off1'><button style='height:70px; width:70px; border-radius:5px; border-style: solid; border-color: Red; border-width: 3px; background-color: Salmon;'><b>Cerrada<br><br>R1</button></a>");
      }

      if (rejilla2Abierta) {
        client.println("<a href='off2'><button style='height:70px; width:70px; border-radius:5px; background-color: LightCyan;'><b>Cerrar<br><br>R2</button></a>");
      } else {
        client.println("<a href='off2'><button style='height:70px; width:70px; border-radius:5px; border-style: solid; border-color: Red; border-width: 3px; background-color: Salmon;'><b>Cerrada<br><br>R2</button></a>");
      }

      if (rejilla3Abierta) {
        client.println("<a href='off3'><button style='height:70px; width:70px; border-radius:5px; background-color: LightCyan;'><b>Cerrar<br><br>R3</button></a>");
      } else {
        client.println("<a href='off3'><button style='height:70px; width:70px; border-radius:5px; border-style: solid; border-color: Red; border-width: 3px; background-color: Salmon;'><b>Cerrada<br><br>R3</button></a>");
      }

      if (rejilla4Abierta) {
        client.println("<a href='off4'><button style='height:70px; width:70px; border-radius:5px;  background-color: LightCyan;'><b>Cerrar<br><br>R4</button></a>");
      } else {
        client.println("<a href='off4'><button style='height:70px; width:70px; border-radius:5px; border-style: solid; border-color: Red; border-width: 3px; background-color: Salmon;'><b>Cerrada<br><br>R4</button></a>");
      }

//      client.println("<a href='off1'><button>Cerrar</p>R1</button></a>");
//      client.println("<a href='off2'><button>Cerrar</p>R2</button></a>");
//      client.println("<a href='off3'><button>Cerrar</p>R3</button></a>");
//      client.println("<a href='off4'><button>Cerrar</p>R4</button></a>");

      client.println("<h5><center><footer><font face='optima'><font color='#808b96 '><u>Aplicación creada por: DGFP & FPDG</u></font></h2></footer>");

      client.println("</font></center></body></html>");

      client.println("</body>");
      client.println("</html>");

      ////////////////////////////////////////////////////////////////////////////
      //                           Fin página WEB                               //
      ////////////////////////////////////////////////////////////////////////////



}

////////////////////////////////////////////////////////////////////////////
//******                     Fin void loop                          ******//
////////////////////////////////////////////////////////////////////////////





////////////////////////////////////////////////////////////////////////////
//                Comandos abrir y cerrar compuertas                      //
////////////////////////////////////////////////////////////////////////////


void abrir_1() {
  delay(200);
  if (estadoR1 == "ON") {
    Serial.println("LA REJILLA 1 YA ESTABA ABIERTA");
  } else {
    if (!rejilla1Abierta) {

      // enciende la salida 1 mientras mantiene encendida la salida 9.
      salida_multiplexor_01 = salida_multiplexor_01 += r1a ; // Sumar r1a (1) a salida_multiplexor_01.
      salida_multiplexor_02 = salida_multiplexor_02 += lc1;  // Sumar lc1 (1) a salida_multiplexor_02.
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_02: " + String(salida_multiplexor_02));

      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH); 

      delay(tiempoApertura);

      // Apaga la salida 1 y vuelve a mantiene encendida la salida 9
      salida_multiplexor_01 = (salida_multiplexor_01 -= r1a); // Apaga la salida 1.
      salida_multiplexor_02 = salida_multiplexor_02;  // Mantiene encendida la salida 9.
      Serial.println("Valor de salida APAGADO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida MANTIENE LED salida_multiplexor_02: " + String(salida_multiplexor_02));
      //digitalWrite(latchPin, LOW);

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH);

      rejilla1Abierta = true; // Actualizar el estado.
      estadoR1 = "ON";  // Actualizar el estado.
    }
  }
}


void cerrar_1() {
  delay(200);
  if (estadoR1 == "OFF") {
    Serial.println("LA REJILLA 1 YA ESTABA CERRADA");
  } else {
  //  if (!rejilla1Abierta) {

      // enciende la salida 2 mientras mantiene encendida la salida 9.
      salida_multiplexor_01 = (salida_multiplexor_01 += r1c) ; // Sumar r1C (2) a salida_multiplexor_01 y mantener encendida la salida 9.
      salida_multiplexor_02 = salida_multiplexor_02;

      Serial.println("");
      Serial.println("ESTAS CERRANDO LA REJILLA 1, ENCENDIENDO LED 2 MUX 1" );
      Serial.println("");
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_02: " + String(salida_multiplexor_02));
      Serial.println("");

      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH); 

      delay(tiempoCierre);

      // Apaga las salidas 2 y 9
      salida_multiplexor_01 = (salida_multiplexor_01 - r1c); // Apaga la salida 1.
      salida_multiplexor_02 = (salida_multiplexor_02 - lc1);  // Apaga la salida 9.
      Serial.println("");
      Serial.println("ESTAS CERRANDO LA REJILLA 1, APAGANDO LED 1 Y 9" );
      Serial.println("");
      Serial.println("Valor de salida APAGADO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida MANTIENE LED salida_multiplexor_02: " + String(salida_multiplexor_02));
      //digitalWrite(latchPin, LOW);
      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH);

      rejilla1Abierta = false; // Actualizar el estado.
      estadoR1 = "OFF";  // Actualizar el estado.
  //  }
  }
 } 

 void abrir_2() {
  delay(200);
  if (estadoR2 == "ON") {
    Serial.println("LA REJILLA 2 YA ESTABA ABIERTA");
  } else {
    if (!rejilla2Abierta) {

      // enciende la salida 2 mientras mantiene encendida la salida 10.
      salida_multiplexor_01 = salida_multiplexor_01 += r2a ; // Sumar r2a (4) a salida_multiplexor_01.
      salida_multiplexor_02 = salida_multiplexor_02 += lc2;  // Sumar lc2 (2) a salida_multiplexor_02.
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_02: " + String(salida_multiplexor_02));

      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH); 

      delay(tiempoApertura);

      // Apaga la salida 2 y mantiene encendida la salida 10
      salida_multiplexor_01 = (salida_multiplexor_01 -= r2a); // Apaga la salida 2.
      salida_multiplexor_02 = salida_multiplexor_02;  // Mantiene encendida la salida 10.
      Serial.println("Valor de salida APAGADO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida MANTIENE LED salida_multiplexor_02: " + String(salida_multiplexor_02));
      //digitalWrite(latchPin, LOW);

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH);

      rejilla2Abierta = true; // Actualizar el estado.
      estadoR2 = "ON";  // Actualiza el estado.
    }
  }
}

 void cerrar_2() {
  delay(200);
  if (estadoR2 == "OFF") {
    Serial.println("LA REJILLA 2 YA ESTABA CERRADA");
  } else {
  //  if (!rejilla2Abierta) {

      // enciende la salida 4 mientras mantiene encendida la salida 10.
      salida_multiplexor_01 = (salida_multiplexor_01 += r2c) ; // Sumar r2C (8) a salida_multiplexor_01 y mantener encendida la salida 10.
      salida_multiplexor_02 = salida_multiplexor_02;

      Serial.println("");
      Serial.println("ESTAS CERRANDO LA REJILLA 2, ENCENDIENDO LED 4 MUX 1" );
      Serial.println("");
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_02: " + String(salida_multiplexor_02));
      Serial.println("");

      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH); 

      delay(tiempoCierre);

      // Apaga las salidas 4 y 10
      salida_multiplexor_01 = (salida_multiplexor_01 - r2c); // Apaga la salida 4.
      salida_multiplexor_02 = (salida_multiplexor_02 - lc2);  // Apaga la salida 10.
      Serial.println("");
      Serial.println("ESTAS CERRANDO LA REJILLA 2, APAGANDO LED 4 Y 10" );
      Serial.println("");
      Serial.println("Valor de salida APAGADO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida MANTIENE LED salida_multiplexor_02: " + String(salida_multiplexor_02));
      //digitalWrite(latchPin, LOW);
      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH);

      rejilla2Abierta = false; // Actualizar el estado.
      estadoR2 = "OFF";  // Actualiza el estado.
  //  }
  }
 } 

 void abrir_3() {
  delay(200);
  if (estadoR3 == "ON") {
    Serial.println("LA REJILLA 3 YA ESTABA ABIERTA");
  } else {
    if (!rejilla3Abierta) {

      // enciende las salidas 5 y 11

      salida_multiplexor_01 = salida_multiplexor_01 += r3a ; // Sumar r3a (16) a salida_multiplexor_01.
      salida_multiplexor_02 = salida_multiplexor_02 += lc3; // Sumar lc3 (4) a salida_multiplexor_02.
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_02: " + String(salida_multiplexor_02));

      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH); 

      delay(tiempoApertura);

      // Apaga la salida 5 y mantiene encendida la salida 11.

      salida_multiplexor_01 = (salida_multiplexor_01 -= r3a); // Apaga la salida 5.
      salida_multiplexor_02 = salida_multiplexor_02;  // Mantiene encendida la salida 11.
      Serial.println("Valor de salida APAGADO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida MANTIENE LED salida_multiplexor_02: " + String(salida_multiplexor_02));
      //digitalWrite(latchPin, LOW);

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH);

      rejilla3Abierta = true; // Actualiza el estado.
      estadoR3 = "ON";  // Actualiza el estado.
    }
  }
}

void cerrar_3() {
  delay(200);
  if (estadoR3 == "OFF") {
    Serial.println("LA REJILLA 2 YA ESTABA CERRADA");
  } else {
  //  if (!rejilla3Abierta) {

      // enciende la salida 6 mientras mantiene encendida la salida 11.
      salida_multiplexor_01 = (salida_multiplexor_01 += r3c) ; // Sumar r3C (32) a salida_multiplexor_01.
      salida_multiplexor_02 = salida_multiplexor_02;  // Mantener encendida la salida 11.

      Serial.println("");
      Serial.println("ESTAS CERRANDO LA REJILLA 3, ENCENDIENDO LED 6 MUX 1" );
      Serial.println("");
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_02: " + String(salida_multiplexor_02));
      Serial.println("");

      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH); 

      delay(tiempoCierre);

      // Apaga las salidas 6 y 11
      salida_multiplexor_01 = (salida_multiplexor_01 - r3c); // Apaga la salida 6.
      salida_multiplexor_02 = (salida_multiplexor_02 - lc3);  // Apaga la salida 11.
      Serial.println("");
      Serial.println("ESTAS CERRANDO LA REJILLA 3, APAGANDO LED 6 Y 11" );
      Serial.println("");
      Serial.println("Valor de salida APAGADO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida MANTIENE LED salida_multiplexor_02: " + String(salida_multiplexor_02));
      //digitalWrite(latchPin, LOW);
      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH);

      rejilla3Abierta = false; // Actualizar el estado
      estadoR3 = "OFF";
  //  }
  }
 } 

void abrir_4() {
  delay(200);
  if (estadoR4 == "ON") {
    Serial.println("LA REJILLA 4 YA ESTABA ABIERTA");
  } else {
    if (!rejilla4Abierta) {

      // enciende las salidas 7 y 12

      salida_multiplexor_01 = salida_multiplexor_01 += r4a ; // Sumar r4a (64) a salida_multiplexor_01.
      salida_multiplexor_02 = salida_multiplexor_02 += lc4; // Sumar lc4 (8) a salida_multiplexor_02.
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_02: " + String(salida_multiplexor_02));

      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH); 

      delay(tiempoApertura);

      // Apaga la salida 7 y mantiene encendida la salida 12.

      salida_multiplexor_01 = (salida_multiplexor_01 -= r4a); // Apaga la salida 7.
      salida_multiplexor_02 = salida_multiplexor_02;  // Mantiene encendida la salida 12.
      Serial.println("Valor de salida APAGADO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida MANTIENE LED salida_multiplexor_02: " + String(salida_multiplexor_02));
      //digitalWrite(latchPin, LOW);

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH);

      rejilla4Abierta = true; // Actualiza el estado.
      estadoR4 = "ON";  // Actualiza el estado.
    }
  }
}

void cerrar_4() {
  delay(200);
  if (estadoR4 == "OFF") {
    Serial.println("LA REJILLA 4 YA ESTABA CERRADA");
  } else {
  //  if (!rejilla4Abierta) {

      // enciende la salida 8 mientras mantiene encendida la salida 11.
      salida_multiplexor_01 = (salida_multiplexor_01 += r4c) ; // Sumar r4C (128) a salida_multiplexor_01.
      salida_multiplexor_02 = salida_multiplexor_02;  // Mantener encendida la salida 12.

      Serial.println("");
      Serial.println("ESTAS CERRANDO LA REJILLA 4, ENCENDIENDO LED 8 MUX 1" );
      Serial.println("");
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida ENCENDIDO salida_multiplexor_02: " + String(salida_multiplexor_02));
      Serial.println("");

      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH); 

      delay(tiempoCierre);

      // Apaga las salidas 8 y 12
      salida_multiplexor_01 = (salida_multiplexor_01 - r4c); // Apaga la salida 8.
      salida_multiplexor_02 = (salida_multiplexor_02 - lc4);  // Apaga la salida 12.
      Serial.println("ESTAS CERRANDO LA REJILLA 3, APAGANDO LED 8 Y 12" );
      Serial.println("");
      Serial.println("Valor de salida APAGADO salida_multiplexor_01: " + String(salida_multiplexor_01));
      Serial.println("Valor de salida MANTIENE LED salida_multiplexor_02: " + String(salida_multiplexor_02));
      //digitalWrite(latchPin, LOW);
      
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_02);
      shiftOut(dataPin, clockPin, MSBFIRST, salida_multiplexor_01);
      digitalWrite(latchPin, HIGH);

      rejilla4Abierta = false; // Actualizar el estado
      estadoR4 = "OFF";
  //  }
  }
 } 

////////////////////////////////////////////////////////////////////////////
//              Fin Comandos abrir y cerrar compuertas                    //
////////////////////////////////////////////////////////////////////////////

Surbyte · October 15, 2023, 12:56pm

Moderador:
Por favor, lee las Normas del foro y postea en un nuevo post tu código usando etiquetas de código, nada de zip, el sistema tiene espacio suficiente para que se vea el código.s
Ve a edición, luego selecciona todo el código que has publicado, lo cortas y click en (<CODE/>)

Cuando vea el código te responderemos.

TRANSPONDER · October 15, 2023, 1:06pm

Gracias Surbyte, tienes toda la razón del mundo, solo que mi código lo tenía dividido en varios archivos ".h" y no quería liar mucho, pero los he agregado al código.

Surbyte · October 15, 2023, 1:13pm

Deberias adjuntar un esquema para hacernos mas facil la tarea.
Aunque sea a mano alzada. Le tomas captura y lo subes.
Algo en bloques no tiene por que ser hecho con un sofware (por favor que no sea fritzing).

TRANSPONDER · October 15, 2023, 1:35pm

Lo siento, pero ya lo estaba preparando y de momento solo necesito el pinout para los multiplexores.... Que con tantas funciones que tiene cada pin del ESP me pierdo...

De nuevo gracias y perdón por las molestias.

Surbyte · October 15, 2023, 1:51pm

A ver como te ayudo, pero al final tendré que hacerlo yo.
No se como trabajas pero yo siempre dibujo lo que voy a hacer antes de ponerle código, y nunca al revés.
No vi que agregaste un esquema
Por favor, si alguien te pregunta algo responde en nuevo post, no vayas editando el primer post a cada instante porque todo luce como que te hablamos y tu ya lo tenias hecho.
A ver como luce el esquema.

No entiendo porque no usas los pines del ESP32 para varias tareas.
Yo usaria 595 y multiplexor cuando todos los pines me quedaron cubiertos.

Los 595 estan funcionando bien porque he reemplazado el manejo web por un ingreso via Serial y el accionanmiento on1 y off1 no trabaja como se espera.
off1 me enciende el led 1 instante y luego lo apaga.
on1 no hace nada. Tal vez mi simulacion no este trabajando bien.

Vamos por partes. Estoy probando tus HC595 y no trabajan como debe.
Como dije reemplacé tu servicio WEB por otro Serial. que con este simulador nos resulta posible si no estamos asociados a su CLUB.

Lo pones a correr con botón verde y abajo pones tus mismos comandos html
on1, off1
Mira a ver que error he cometido.

TRANSPONDER · October 15, 2023, 8:02pm

Gracias Surbyte, he visto que te lo has currado muy rápido, y en los multiplexores no usas la salida Q0, que corresponderia a las salidas r1a (rejilla 1 abrir) y lc1 ("led control 1" indicaría que la rejilla 1 esta abierta).

Explico un poco el funcionamiento para no estar conectando los motores, he sustituido los L298N por diodos led para comprobar que efectivamente funciona la salida, r1a (Q0 del multiplexor 1 "amarillo") gira el motor en un sentido durante un tiempo dado (tiempoApertura) y me deja encendido el lc1 (Q0 del multiplexor 2 "verde"). Al activar la salida rc1 (Q1 del mux 1), para cerrar la rejilla, enciende el led "Azul" otro tiempo dado, (tiempoCierre, ya que he observado que el tiempo para abrir o cerrar no es el mismo) y transcurrido el tiempo apaga el led de control (lc1). y es sucesivamente, a futuro quiero incorporar los rojos para indicar que está cerrada la rejilla.

La cuestión es que me funciona por web solo que tengo que perfeccionar dos cosas de momento, guardar el estado de las rejillas en memoria no volátil, y la que digamos necesito, sería el conexionado con pines* nuevos o crear un bus de datos para añadir un CD74HC4067 y añadir unos pulsadores, ya que si pierde la conexion wifi o no tengo bluetooth, abrir y cerrar las rejillas manualmente.

Adjunto esquema, a ver si lo entendéis, ya que soy un desastre en dibujo.

Probé el usar todos los pines, pero como es un lío de funciones o usaba alguno que no debía, activaba todos los pines y empezaban a girar los motores, y por descarte me quedé con esos tres pines de cuatro posibles aunque no sean correctos (por eso pido ayuda).

Surbyte · October 16, 2023, 2:29am

Seguro que te funciona por WIFI pero con el emulador no puedo hacerlo y por eso usé el recurso Serie. para el caso lo mismo.
Bien, ahora me doy cuenta que habias dicho que los leds reemplazaban los L298 y claramente eso tiene otro funcionamiento al que quise entender.
Vamos con el multiplexor.
Lo conecto y comparto el circuito.

TRANSPONDER · October 16, 2023, 6:36am

Ok, yo he probado a conectar SIG o EN al pin 34 y S0, S1, S2 y S3 a 16, 17 18 y 19 respectivamente y EN a GND, pero no me ha funcionado, ya no sé si por conexión o programación...

Surbyte · October 16, 2023, 2:04pm

Según la hoja de datos del CD74HC4067 EN debe estar a GND.

Con EN en 1 esta todo deshabilitado.
Con EN en 0 según la entrada S0..S3 tienes la salida a SIG Signal.

TRANSPONDER · October 16, 2023, 3:03pm

Tienes razón, me equivoqué al escribir, es "SIG o Z" en el GPIO34....
ahora queda descubrir que pines se pueden usar tranquilamente, pues unos ponen en estado dormido el ESP, otros activan todo...y estoy aprendiendo, no soy electrónico para entender el datasheet...

MaximoEsfuerzo · October 16, 2023, 3:50pm

Fijate si te ayuda

Surbyte · October 16, 2023, 7:07pm

Bueno he avanzado pero el multiplexor no funciona bien con el simulador.

A ver si alguien encuentra la falla.

TRANSPONDER · October 17, 2023, 12:44pm

Buenas tardes, puede ser que el CD74HC4067 está alimentado con 3,3V y requiere 5V. no sé como trabaja el emulador, pero pueden venir por ahí los tiros...

de todas maneras voy a montar el multiplexor con tu configuración de pines, si puedes, me enseñas como funciona el código para añadirlo al mío...

Surbyte · October 17, 2023, 1:59pm

Extrae lo que te he agregado, configuración de pines

const int S0  = 2;
const int S1  = 4;
const int S2  = 5;
const int S3  = 18;
const int SIG = 19;

en el setup estas líneas

 pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  pinMode(SIG, INPUT_PULLUP);

en el loop

leo_multiplexor();

y como rutina extra

void leo_multiplexor() {
  int tmp;
  for (int i= 0; i<16; i++) {  

    digitalWrite(S0, i & 0x01 );
    digitalWrite(S1, i & 0x02 );
    digitalWrite(S2, i & 0x04 );
    digitalWrite(S3, i & 0x08 );
     if (i%16 == 0)                   // esto asegura que muestra 16 valores 1 o 0
      Serial.println(); 
    estadoMul[i] = digitalRead(SIG); 
    Serial.printf("%d ", estadoMul[i]);
  }
}

Si pongo a 0 todos se muestran en 0 y esta mal.
Si pongo a 1 todos se muestran en 1 y esta mal.
le puse mucho tiempo y no pude encontrar la solucion. Es un error del simulador o mío. No lo se pero me cansó.

TRANSPONDER · October 17, 2023, 2:06pm

A ver si entre todos lo conseguimos...
y a máximoEsfuerzo, mi placa es esta:

cada placa es un mundo...

Surbyte · October 17, 2023, 2:09pm

Yo hago todos los desarrollos basados en ESP32 Dev Module el más basico.

bueno aca esta con el 74HC4067 solo
En el simulador no responde como debería pruébalo fisicamente a ver si funciona.
Deberias poner resistencias pull-up en cada entrada, aunque no recuerdo si quieres leer valores digitales o analógicos.

TRANSPONDER · October 17, 2023, 3:48pm

Eres una máquina, a ver si puedo probarlo antes del fin de semana y os comento a todos...

Muchas gracias.

MaximoEsfuerzo · October 17, 2023, 6:15pm

Y vos le ves alguna diferencia de pinado?

Y en el supuesto que los pines estuviesen en distinta posición, lo que importa es cuál GPIO es más o menos conveniente de usar. Y eso no cambia.

Surbyte · October 18, 2023, 3:40am

El pinout esta bien @MaximoEsfuerzo, si no usas el multiplexor responde bien.
Si lo pones y usas potenciometros, responde bien.
Si le pones entradas digitales responde mal.

Topic		Replies	Views
Pines digitales Español	5	1255	May 6, 2021
Se pueden conectar todos los pines de un 1298n a pines digitales en arduino? Español	4	354	March 22, 2024
ESP8266 - Utilizar SPI secundario Microcontroladores	15	1231	February 3, 2023
Duda con pines de comunicación Hardware	5	820	May 7, 2021
Problema de pines PWM Software	11	95	May 19, 2025

74hc595 y cd74hc4067 juntos

Related topics