copilot

• Accelerometer: Measures acceleration in 3 axes $(X, Y, Z)$.
• Gyroscope: Measures rotational velocity in 3 axes.
• Integrated Digital Motion Processor (DMP): Processes complex motion algorithms, reducing the workload on the main MCU (Microcontroller Unit).
• I2C Interface: Communicates with the host MCU via I2C bus, making it easy to integrate into various projects.

• Motion Tracking: Used in smartphones, gaming consoles, drones, and other devices that require precise motion tracking.
• Inertial Measurement Units (IMU): Common in robotics and stabilization platforms.
• Wearable Devices: Adds motion-sensing capabilities for fitness and health tracking.

• CLKIN: Clock input.
• VLOGIC: Logic level reference.
• AD0: I2C address select.
• REGOUT: Regulated output voltage.
• FSYNC: Frame synchronization input.
• INT: Interrupt pin.
• VDD: Power supply voltage.
• GND: Ground.
• AUX_DA and AUX_CL: Auxiliary I2C data and clock lines.
• SCL: I2C clock line.
• SDA: I2C data line.
• Other pins are marked as "NC" or reserved, which means they are typically not connected or used for future purposes.

1. Power Supply: Connect $IC1:VDD$ to 3.3V or 5V (depending on the module version) and $IC1:GND$ to Ground.
2. I2C Interface: Connect $IC1:SCL$ to the MCU's SCL pin and $IC1:SDA$ to the MCU's SDA pin.
3. Address Select: Connect $IC1:AD0$ to GND or VDD to set the I2C address.

riro9510

copilot

1. Alimentación:
   • Conecta VDD de IC1 (MPU-6050) a 3.3V o 5V del ESP32 (U2:3V3 para 3.3V o U2:5V para 5V).
   • Conecta GND de IC1 a GND del ESP32 (U2:GND).
2. Interfaz I2C:
   • Conecta SCL de IC1 a GPIO22 del ESP32 (U2:GPIO22).
   • Conecta SDA de IC1 a GPIO21 del ESP32 (U2:GPIO21).
3. Selección de Dirección I2C:
   • Conecta AD0 de IC1 a GND o VDD. Esto determinará la dirección I2C del MPU-6050 (Generalmente $0x68$ cuando AD0 está a GND y $0x69$ cuando AD0 está a VDD).

• Conectar IC1:GND a U2:GND.
• Conectar IC1:VDD a U2:3V3.
• Conectar IC1:SCL a U2:GPIO22.
• Conectar IC1:SDA a U2:GPIO21.
• Conectar IC1:AD0 a GND (estándar para la dirección $0x68$).

Cpp
#include 
#include 

MPU6050 mpu;

void setup() {
  Wire.begin();
  Serial.begin(115200);
  
  while (!mpu.begin(MPU6050_SCALE_2000DPS, MPU6050_RANGE_16G)) {
    Serial.println("Conectando al MPU6050...");
    delay(1000);
  }
  
  Serial.println("MPU6050 conectado!");
}

void loop() {
  Vector normAccel = mpu.readNormalizeAccel();
  
  Serial.print("X: ");
  Serial.print(normAccel.XAxis);
  Serial.print(" Y: ");
  Serial.print(normAccel.YAxis);
  Serial.print(" Z: ");
  Serial.println(normAccel.ZAxis);
  
  delay(500);
}

• Filtro de Ruido: Agrega algún filtro de software para eliminar ruido y obtener lecturas más estables.
• Montaje Seguro: Asegúrate de montar el MPU-6050 firmemente en la lavadora para evitar vibraciones adicionales que no representan el balanceo real de la tina.

riro9510

copilot

• 1 (CLKIN)
• 2 (NC)
• 3 (NC)
• 4 (NC)
• 5 (NC)
• 6 (AUX_DA)
• 7 (AUX_CL)
• 8 (VLOGIC)
• 9 (AD0)
• 10 (REGOUT)
• 11 (FSYNC)
• 12 (INT)
• 13 (VDD)
• 14 (NC)
• 15 (NC)
• 16 (NC)
• 17 (NC)
• 18 (GND)
• 19 (RESV)
• 20 (CPOUT)
• 21 (RESV)
• 22 (RESV)
• 23 (SCL)
• 24 (SDA)
• 25 (25)

1. Alimentación:
   • Conecta IC1:VDD (Pin 13) a U2:3V3 (Pin 1).
   • Conecta IC1:GND (Pin 18) a U2:GND (Pin 14).
2. Interfaz I2C:
   • Conecta IC1:SCL (Pin 23) a U2:GPIO22.
   • Conecta IC1:SDA (Pin 24) a U2:GPIO21.
3. Selección de Dirección I2C:
   • Conecta IC1:AD0 (Pin 9) a GND para la dirección $0x68$ o a VDD para $0x69$.

• Conectar IC1:GND (Pin 18) a U2:GND (Pin 14).
• Conectar IC1:VDD (Pin 13) a U2:3V3 (Pin 1).
• Conectar IC1:SCL (Pin 23) a U2:GPIO22.
• Conectar IC1:SDA (Pin 24) a U2:GPIO21.
• Conectar IC1:AD0 (Pin 9) a GND.

riro9510

copilot

• Selección de Dirección I2C:
  • Conectado a GND: La dirección I2C del MPU-6050 será $0x68$.
  • Conectado a VDD (3.3V): La dirección I2C del MPU-6050 será $0x69$.

• Conectar AD0 a GND para la dirección I2C $0x68$ (valor por defecto).
• Conectar AD0 a VDD (3.3V) para la dirección I2C $0x69$.

• Conecta IC1:AD0 (Pin 9) a GND si deseas usar la dirección $0x68$.

riro9510

copilot

1. SCL (Serial Clock Line):
   • Función: Es la línea de reloj que sincroniza la transferencia de datos entre el microcontrolador (en este caso, el ESP32) y el dispositivo I2C (en este caso, el MPU-6050).
   • Responsable de: Indicar cuándo se debe leer o escribir un bit de datos en la línea SDA.
   • Conexión usual con ESP32: Pin GPIO22.
2. SDA (Serial Data Line):
   • Función: Es la línea de datos que lleva la información entre el microcontrolador y el dispositivo I2C.
   • Responsable de: Transferir los datos serializados entre el maestro (el ESP32) y el esclavo (el MPU-6050).
   • Conexión usual con ESP32: Pin GPIO21.

• Comunicación: El I2C es un bus de comunicación bidireccional que permite la transferencia de datos entre múltiples dispositivos utilizando dos líneas (SCL y SDA).
• Direcciones: Cada dispositivo en el bus I2C tiene una dirección única (como se define usando el pin AD0 para el MPU-6050).
• Roles: Un dispositivo actúa como maestro y los otros como esclavos. En tu proyecto, el ESP32 actúa como el maestro y el MPU-6050 como el esclavo.

• Conecta IC1:SCL (Pin 23) a U2:GPIO22 (SCL del ESP32).
• Conecta IC1:SDA (Pin 24) a U2:GPIO21 (SDA del ESP32).

• /user/project a /user/project.
• /user/project a /user/project.

Cpp
#include 
#include 
#include 

Adafruit_MPU6050 mpu;

void setup() {
  Serial.begin(115200);
  while (!Serial) delay(10); // Espera serial
  
  if (!mpu.begin()) {
    Serial.println("No se detecta MPU6050. Verifica conexiones.");
    while (1) delay(10);
  }

  Serial.println("MPU6050 iniciado!");
  mpu.setAccelerometerRange(MPU6050_RANGE_16_G);
  mpu.setGyroRange(MPU6050_RANGE_250_DEG);
  mpu.setFilterBandwidth(MPU6050_BAND_21_HZ);
}

void loop() {
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);

  Serial.print("Acelerometro X: "); Serial.print(a.acceleration.x); Serial.print(" m/s^2 ");
  Serial.print("Y: "); Serial.print(a.acceleration.y); Serial.print(" m/s^2 ");
  Serial.print("Z: "); Serial.print(a.acceleration.z); Serial.println(" m/s^2");

  delay(500);
}

riro9510

copilot

• SCL (Serial Clock Line): El maestro en la comunicación I2C (en este caso, el ESP32) genera la señal de reloj. No necesitas un cristal adicional porque el ESP32 genera esta señal de reloj internamente.
• SDA (Serial Data Line): Los datos se sincronizan con esta señal de reloj y no requieren componentes externos adicionales, aparte de las resistencias pull-up.

• Valor típico: 4.7 kΩ
• Conexión: Desde SCL a VDD y desde SDA a VDD

1. MPU-6050 a ESP32:
   • Conectar IC1:SCL (Pin 23) a U2:GPIO22.
   • Conectar IC1:SDA (Pin 24) a U2:GPIO21.
   • Conectar IC1:VDD (Pin 13) a U2:3V3 (Pin 1).
   • Conectar IC1:GND (Pin 18) a U2:GND (Pin 14).
   • Conectar IC1:AD0 (Pin 9) a GND (o a VDD dependiendo de la dirección I2C que elijas).

• Conecta /user/project a /user/project.
• Conecta /user/project a /user/project.
• Conecta /user/project a /user/project.
• Conecta /user/project a /user/project.

Cpp
#include 
#include 
#include 

Adafruit_MPU6050 mpu;

void setup() {
  Serial.begin(115200);
  Wire.begin(); // Iniciar I2C
  if (!mpu.begin()) {
    Serial.println("No se detecta MPU6050. Verifica conexiones.");
    while (1) delay(10);
  }

  Serial.println("MPU6050 iniciado!");
}

void loop() {
  sensors_event_t a, g, temp;
  mpu.getEvent(&a, &g, &temp);

  Serial.print("Acelerometro X: "); Serial.print(a.acceleration.x); Serial.print(" m/s$$^2$$ ");
  Serial.print("Y: "); Serial.print(a.acceleration.y); Serial.print(" m/s$$^2$$ ");
  Serial.print("Z: "); Serial.print(a.acceleration.z); Serial.println(" m/s$$^2$$");

  delay(500);
}

copilot

1. Power Supply Connection: It can be used to connect external power supplies to the board.
2. Peripheral Connectors: It might be used to connect various peripherals, sensors, or interfaces.
3. Programming Interface: Can serve as a port for programming or debugging purposes.

• PIN_1
• PIN_2
• PIN_3
• PIN_4

riro9510

copilot

1. Connector Type and Series: Determine the specific series and type of the connector. For example, if TE Connectivity AMP Connectors' 282836-4 is part of a specific series, look for cable assemblies or mating connectors in that series.
2. Pin Count and Pitch: Ensure the counterpart also has 4 pins and the same pitch $(\text{spacing between pins})$.
3. Mounting Type: If J2 is a PCB-mounted connector, the counterpart could be a cable connector designed to mate with it.
4. Supplier Recommendations: Check the datasheets or product catalog from TE Connectivity, as they often recommend mating parts.

• Consult the 282836-4 Datasheet: It will often list compatible mating parts.
• Search Electronic Component Distributors: Websites like Digi-Key, Mouser, or Arrow might list compatible connectors.
• Look for Keywords: Use terms like "4-position MATE-N-LOK connector" and ensure compatibility with the 282836-4 connector.

riro9510

copilot

• Pin 1: Connected to U3:VO ($3.3V$ output from the voltage regulator).
• Pin 2: Connected to U3:GND, U1:GND, Q1:E, and Q2:E (Common ground).
• Pin 3: Connected to U2:GPIO22 (General-purpose I/O pin).
• Pin 4: Connected to U2:GPIO23 (General-purpose I/O pin).

1. Power and Ground Connection
   • Pin 1: Provides a $3.3V$ power supply from the output of the voltage regulator U3.
   • Pin 2: Provides a common ground ($0V$).
2. Control and Interface
   • Pin 3: Connected to GPIO22 on the ESP32-DEVKITC-32UE. This could be used as a signal line for control or communication.
   • Pin 4: Connected to GPIO23 on the ESP32-DEVKITC-32UE. Another signal line for control or communication purposes.

• Peripheral Interface: If you are connecting a peripheral module, J2 could provide the necessary power and signal lines for communication/control.
• Sensor Connections: Could be used to connect sensors that need $3.3V$ power and ground, with data lines going to GPIO22 and GPIO23.
• Programming/Debugging Port: Though less likely, this configuration could possibly be used for programming or debugging purposes, particularly if you are sending and receiving data through the GPIO pins.

• Connect J2:PIN_1:PIN_1 to U3:VO.
• Connect J2:PIN_2:PIN_2 to U3:GND, U1:GND, Q1:E, and Q2:E.
• Connect J2:PIN_3:PIN_3 to U2:GPIO22.
• Connect J2:PIN_4:PIN_4 to U2:GPIO23.

riro9510

copilot

1. Determine Requirements:
   • Pressure Range: What range of pressure will the switch need to detect?
   • Type of Output: Normally open (NO), normally closed (NC), or SPDT (Single Pole Double Throw)?
   • Electrical Characteristics: Voltage and current ratings.
   • Environmental Conditions: Temperature, humidity, etc.
2. Search for Components:
   • Look for pressure switches from well-known suppliers like Honeywell, OMRON, or TE Connectivity.
   • Consider using a digital pressure sensor if more precise measurement and control are needed.

• Honeywell: Models like the Honeywell 5000 Series are popular for many applications and come in various configurations.

• Designator: P1
• Pins: 1 (Common), 2 (Normally Open)

1. Power Connection: Connect one side of the switch to your power source or a signal line.
   • Connect $P1$:Common to your desired voltage rail or GPIO pin (depending on the function).
2. Output Connection: Connect the normally open pin to the rest of the circuit where you want to detect the pressure status.
   • Connect $P1$:NO to the input of the device you want to control or monitor.

Markdown
## Designator: P1
MPN: [Selected_Pressure_Switch_MPN]
Pins: 1 (name: Common), 2 (name: NO)
Element Properties:
Manufacturer Name: [Manufacturer]
Designator Prefix: P
License: https://creativecommons.org/licenses/by/4.0/

• For Power Trigger:
  • Connect your voltage rail (e.g., 3.3V or 5V) to $P1$:Common.
• For Detection:
  • Connect $P1$:NO to a GPIO pin or an input to your control circuitry.

riro9510

copilot

• Description: This is a low-cost, high-precision sensor that provides measurements of barometric pressure and temperature.
• Features:
  • Pressure range: 300 to 1100 hPa
  • Interface: I2C and SPI
  • Operating Voltage: 1.71V to 3.6V
  • Accuracy: ±1 hPa

• Power Supply: Connect the VCC pin to a suitable voltage rail (e.g., 3.3V).
• Ground: Connect the GND pin to the common ground of your circuit.
• Communication Interface:
  • If using I2C: Connect the SCL and SDA pins to your microcontroller's I2C bus.
  • If using SPI: Connect CS (Chip Select), SCK (Serial Clock), MISO (Master In Slave Out), and MOSI (Master Out Slave In) to your microcontroller's SPI interface.

• Connect BMP280:VCC to U3:VO (3.3V output from LM1117).
• Connect BMP280:GND to U3:GND.
• Connect BMP280:SCL to U2:GPIO22 (or any suitable GPIO configured for I2C SCL).
• Connect BMP280:SDA to U2:GPIO23 (or any suitable GPIO configured for I2C SDA).

Markdown
## Designator: P_BMP
MPN: BMP280
Pins: 1 (name: VCC), 2 (name: GND), 3 (name: SCL), 4 (name: SDA)
Manufacturer Name: Bosch
Designator Prefix: P
License: https://creativecommons.org/licenses/by/4.0/

copilot

1. $ \text{VI} $: Este pin es para el voltaje de entrada que deseas regular.
2. $ \text{GND} $: El pin de tierra, que se conectaría al punto de referencia o tierra de tu circuito.
3. $ \text{VO} $: Este es el pin donde obtendrás el voltaje regulado (3.3V). Puedes usar cualquiera de los dos pines etiquetados como VO.

• Conexión de entrada $VI$ y tierra $GND$:
  • Conecta U3:VI a la fuente de voltaje de entrada que quieres regular.
  • Conecta U3:GND a la tierra común del circuito.
• Conexión de salida $VO$:
  • Conecta U3:VO a tu carga o al circuito que necesita 3.3V.

• Conecta U3:VI a tu fuente de voltaje de entrada.
• Conecta U3:GND a tierra.
• Conecta U3:VO a través de cualquiera de los dos pines de salida a tu carga (necesita 3.3V).

copilot

riro9510

copilot

• Entrada Digital: Detecta estados altos (HIGH, normalmente 3.3V) o bajos (LOW, normalmente 0V).
• Salida Digital: Puede colocar el pin en un estado alto o bajo.
• ADC (Analog to Digital Converter): Algunos pines GPIO en el ESP32 pueden funcionar como entradas analógicas, convirtiendo un voltaje analógico en un valor digital.
• DAC (Digital to Analog Converter): Algunos pines GPIO pueden trabajar como salidas analógicas, convirtiendo un valor digital en un voltaje analógico.
• PWM (Pulse Width Modulation): Puede generar señales PWM, útiles para controlar motores, iluminación LED, etc.

1. Relé.
2. Transistor NPN (Ej. 2N2222, BC547).
3. Resistencia (Ej. 1kΩ).
4. Diodo (Ej. 1N4007) para protección de contrafuerza.
5. Conexiones adecuadas.

1. Conexiones del Transistor:
   • Conecta la base del transistor a través de una resistencia (1kΩ típicamente) al pin GPIO del ESP32 que se utilizará para controlar el relé.
   • Conecta el emisor del transistor a GND.
   • Conecta el colector del transistor a una de las terminales del relé.
2. Conexiones del Relé:
   • Conecta la otra terminal del relé a +5V (asegúrate de que el relé opere a esta tensión, si no ajusta de acuerdo).
   • Conecta un diodo en paralelo al relé (1N4007), con el cátodo al +5V y el ánodo al colector del transistor.
   • Conecta las cargas (motor, bomba) a los contactos NO (normalmente abiertos) del relé.
3. Conexiones del ESP32:
   • Conecta un pin GPIO del ESP32 a la base del transistor a través de la resistencia.
   • Conecta el GND del ESP32 a la misma tierra del emisor del transistor.

1. Conecta ESP32-DEVKITC-32UE:GPIOX (donde X es un pin GPIO) a la resistencia:1kΩ.
2. Conecta Resistencia:1kΩ (otro terminal) a la base del transistor.
3. Conecta el emisor del transistor a GND.
4. Conecta el colector del transistor a una terminal de la bobina del relé.
5. Conecta la otra terminal de la bobina del relé a +5V.
6. Conecta el diodo:1N4007 en paralelo con la bobina del relé (cátodo a +5V, ánodo al colector del transistor).
7. Conecta las cargas al contacto NO del relé.

riro9510

copilot

1. GPIO0: Asegúrate de no usar este pin para control de relés, ya que es utilizado para el modo de arranque (boot mode), y puede causar problemas al iniciar el ESP32.
2. GPIO2, GPIO4, GPIO5, GPIO12, GPIO13, GPIO14, GPIO15, GPIO16, GPIO17, GPIO18, GPIO19, GPIO21, GPIO22, GPIO23, GPIO25, GPIO26, GPIO27, GPIO32, GPIO33, GPIO34, GPIO35: Son pines GPIO generales y se pueden utilizar para controlar relés sin problemas.
3. GPIO6 - GPIO11: No se recomienda utilizarlos ya que están conectados internamente a la memoria flash.
4. GPIO36 (VP), GPIO39 (VN): Entradas solo utilizadas para ADC.

1. Conectar relé a través de transistor:
   • Conecta U2:GPIO4 a una resistencia de 1kΩ.
   • Conecta el otro terminal de la resistencia a la base del transistor.
   • Conecta el emisor del transistor a GND.
   • Conecta el colector del transistor a una terminal de la bobina del relé.
   • Conecta la otra terminal de la bobina del relé a +5V.
   • Conecta el diodo en paralelo con la bobina del relé (cátodo a +5V, ánodo al colector del transistor).
   • Conecta las cargas al contacto NO del relé.

• Conecta U2:GPIO4 a una resistencia de 1kΩ.
• Conecta la resistencia:1kΩ al transistor:base.
• Conecta el transistor:emisor a GND.
• Conecta el transistor:colector a una terminal del relé.
• Conecta la otra terminal del relé a +5V.
• Conecta el diodo:1N4007 (cátodo a +5V, ánodo al transistor:colector).
• Conecta las cargas al contacto NO del relé.

riro9510

copilot

1. Relé de 5V:
   • Los relés suelen tener una bobina que se energiza para cambiar los contactos. Si usas un relé de 5V, una terminal de la bobina se conectará al +5V de tu fuente de alimentación.
2. Paso:
   • La bobina del relé tiene dos pines. La primera terminal del relé ya está conectada al colector del transistor.
   • Conecta la otra terminal de la bobina del relé a +5V.

1. Propósito del Diodo:
   • Los diodos se utilizan para protección contra picos de voltaje generados cuando la bobina del relé se energiza o se apaga (back EMF).
2. Polaridad del Diodo:
   • Cátodo (marcado con una línea blanca) debe conectarse al +5V.
   • Ánodo se conectará al colector del transistor (esta es la misma terminal que ya conectaste a la bobina del relé).
3. Paso:
   • Conecta el cátodo del diodo 1N4007 al +5V.
   • Conecta el ánodo del diodo al colector del transistor.

1. Contactos del Relé:
   • Los relés tienen contactos "común" (COM), "normalmente abierto" (NO) y "normalmente cerrado" (NC).
   • "Normalmente abierto" significa que, en estado de reposo, el circuito está abierto y no pasa corriente. Al energizarse la bobina, se cierra el circuito permitiendo el paso de corriente.
2. Conexión de la Carga:
   • Conectar un extremo de tu carga (por ejemplo, un motor o una bomba de llenado) al terminal NO del relé.
   • Conectar el otro extremo de tu carga al voltaje de alimentación necesario para la carga (puede ser el mismo +5V o una tensión diferente dependiendo de la especificación de la carga).
3. Paso:
   • Conecta un extremo de la carga (motor o bomba) al terminal NO del relé.
   • Conecta el otro extremo de la carga a la fuente de alimentación adecuada.

1. Relé:
   • Conecta una terminal de la bobina del relé al +5V.
   • Conecta la otra terminal de la bobina del relé al colector del transistor.
2. Diodo:
   • Cátodo del diodo al +5V.
   • Ánodo del diodo al colector del transistor (en paralelo con la bobina del relé).
3. Carga:
   • Conecta un extremo de la carga al terminal NO del relé.
   • Conecta el otro extremo de la carga a la fuente de alimentación adecuada.

Plain
 [ESP32 GPIO] ---- Res 1kΩ ----|
                               |
                              \|/ Base
                           ---------
                           $Transistor$
                           $  2N2222  $
                           ----|-----|
[ GND ] ------------------$ E  C $---|
                           ---------  |---|---
                                     |      |   
                                     |     $( ) 
                                     |    $$ R $$ Relé  
                                     |\   //|
                                     | \ // |
                                    _|__\\__|_
[ +5V ]----------------- $\____ // |       |   \______
                         |    \|/  $0$    |   \|/     |
                         |    $------$    |  Motor/Bomba
                         |_______________|__________|

                          Diodo
[ +5V ] ---------------$<|------|   

riro9510

copilot

• Si prefieres una solución más robusta y sin partes móviles, puedes optar por un relé de estado sólido (SSR).
• Ejemplo: Omron G3MC-202P-DC5. Es un SSR con entrada de control de 5V DC y capacidad para 240V AC en la salida.

• Si prefieres un relé electromecánico, aquí tienes una opción adecuada:
• Ejemplo: Songle SRD-05VDC-SL-C. Este relé tiene una bobina de 5V y puede manejar hasta 10A a 250V AC o 30V DC.

1. Pin de entrada de la bobina (IN): Para el control del ESP32.
2. Segundo pin de la bobina (GND): Conectar a tierra.
3. Común (COM): Conectar a una línea de alimentación.
4. Normalmente Abierto (NO): Conectar a la carga cuando la bobina está energizada.
5. Normalmente Cerrado (NC): Conectar a la carga cuando la bobina no está energizada (probablemente no lo necesites en tu caso).

1. ESP32 GPIO:
   • Conecta $U2:GPIO4$ a una resistencia de 1kΩ.
   • Conecta el otro terminal de la resistencia a la base del transistor.
   • Conecta el emisor del transistor a GND.
   • Conecta el colector del transistor al pin IN del relé $SRD-05VDC-SL-C$.
   • Conecta el pin GND del relé a GND del sistema.

1. Alimentación AC de la Lavadora:
   • Conecta el pin COM del relé a la línea de alimentación (110-220V AC).
   • Conecta el pin NO del relé a la entrada del motor de la lavadora.

1. Diodo 1N4007 para Protección de Back EMF:
   • Conecta el cátodo del diodo (marcado con una línea blanca) al pin IN del relé.
   • Conecta el ánodo del diodo al GND del relé.

1. Control del Relé:
   • Conectar $U2:GPIO4$ a una resistencia de 1kΩ.
   • Conectar la resistencia al transistor:base.
   • Conectar el emisor del transistor a GND.
   • Conectar el colector del transistor al pin IN del relé.
   • Conectar el pin GND del relé a GND del sistema.
2. Diodo de Protección:
   • Conectar el cátodo del diodo al pin IN del relé.
   • Conectar el ánodo del diodo a GND del relé.
3. Carga (Motor de Lavadora):
   • Conectar el pin COM del relé a la línea AC de 110-220V.
   • Conectar el pin NO del relé a la entrada del motor de la lavadora.

Plain
 [ESP32 GPIO] ---- Res 1kΩ ----|
                               |
                              \|/ Base
                           ---------
                           $Transistor$
                           $  2N2222  $
                           ----|-----|
[ GND ] ------------------$ E  C $---|
                           ---------  |
                                    --|---
                                 |  //|
                                 | // |
[ +5V ]-----------------|    $---$---

                        Relé $$SRD-05VDC-SL-C$$
                       Pin COM |  |      NO
                          -----    |

                         Diodo
[ 5V ] -----------------$<|-----

riro9510

copilot

• A1: Un terminal de la bobina.
• A2: El otro terminal de la bobina.
• NO (Normally Open): Normalmente abierto.
• COM (Common): Común.
• NC (Normally Closed): Normalmente cerrado.

1. Bobina del Relé (A1 y A2):
   • La bobina necesita alimentarse para activar el relé. Esta será controlada por el transistor.
2. Contactos de carga (NO, NC, y COM):
   • Estos contactos se utilizan para controlar la carga (el motor de la lavadora en este caso).

1. Conectar la bobina del relé:
   • Conecta A1 del relé al colector del transistor.
   • Conecta A2 del relé a +5V.

1. Diodo de protección:
   • Conecta el cátodo del diodo (marcado con una línea blanca) a A2 (+5V).
   • Conecta el ánodo del diodo a A1 (colector del transistor).

1. Conectar la carga:
   • Conecta COM del relé a la línea de alimentación de 110-220V AC.
   • Conecta NO del relé a la entrada del motor de la lavadora.
   • Deja NC sin conectar (si no necesitas que la carga esté encendida en estado de reposo).

• A1 y A2 de la bobina están ya explicados.
• No necesitas una conexión adicional a GND para el relé más allá de lo que el transistor y la bobina requieren.

Plain
[ESP32 GPIO] ---- Res 1kΩ ----|
                              |
                             \|/ Base
                          ---------
                          $Transistor$
                          $  2N2222  $
                          ----|-----|
[GND] -------------------$ E  C $---|---- A1 (Relé)
                          ---------  |
                                     |
                                    ---- A2 (Relé)
                                    |
                                   [ +5V ]

                    (Diodo 1N4007 de Protección)
               (cátodo) ------|<|------ (ánodo)
                             +5V      Colector del Transistor

                 (Conectar la carga al relé)
[110-220V AC] ------------- (COM Relé)
                            |
                            |
                          (NO Relé) --------------> Entrada del Motor        (Línea del motor)

• Función:
  • Cuando se desconecta la corriente de la bobina del relé, se genera un pico de voltaje inverso (back EMF) que puede dañar otros componentes del circuito. El diodo proporciona un camino seguro para disipar esta energía.
• Conexión:
  • El cátodo (línea blanca) se conecta al terminal A2 (que está conectado a +5V).
  • El ánodo se conecta al terminal A1 (que está en el colector del transistor).

1. Bobina del Relé:
   • Conecta $A1$ -----> [Colector del transistor]
   • Conecta $A2$ -----> [+5V]
2. Diodo de Protección:
   • Conecta [Cátodo] (| blanco) a $A2$ (+5V).
   • Conecta [Ánodo] (>) a $A1$ (colector del transistor).
3. Carga del Motor:
   • Conecta [COM] del relé a [110-220V AC].
   • Conecta [NO] del relé a la [entrada del motor].

riro9510

copilot

• Revisar los datasheets de tus componentes.
• Verificar tus conexiones dos veces antes de aplicar energía.
• ¡Y, sobre todo, disfrutar del proceso!

riro9510

copilot

• ESP32-DEVKITC-32UE
• Relé (Ej. SRD-05VDC-SL-C)
• Transistor NPN (Ej. 2N2222)
• Resistencia (1kΩ)
• Diodo de protección (Ej. 1N4007)
• Electroválvula
• Fuente de alimentación adecuada (5V para el control del relé, y la tensión adecuada para la electroválvula si es diferente)

1. Conexión del Transistor:
   • Conecta ESP32-DEVKITC-32UE:GPIO (por ejemplo, GPIO4) a una resistencia de 1kΩ.
   • Conecta el otro terminal de la resistencia a la base del transistor 2N2222.
   • Conecta el emisor del transistor a GND.
   • Conecta el colector del transistor al pin A1 del relé SRD-05VDC-SL-C.
2. Conexión del Relé:
   • Conecta A2 del relé a +5V.
   • Conecta el cátodo del diodo de protección 1N4007 a A2.
   • Conecta el ánodo a A1 (colector del transistor).

1. Conexión de la Electroválvula:
   • Conecta COM del relé a la línea de alimentación adecuada para la electroválvula (puede ser 110-220V AC o la especificación de la electroválvula).
   • Conecta NO del relé a la entrada de la electroválvula.
   • Deja NC sin conectar si no lo necesitas.

• Control del Transistor:
  • ESP32-DEVKITC-32UE:GPIO -> Resistencia 1kΩ -> Transistor:base
  • Transistor:emisor -> GND
  • Transistor:colector -> Relé:A1
• Bobina del Relé:
  • Relé:A2 -> +5V
  • Diodo:cátodo (línea blanca) -> +5V
  • Diodo:ánodo -> Relé:A1 (colector del transistor)
• Carga (Electroválvula):
  • Relé:COM -> Alimentación especificada (110-220V AC o lo que requiera la electroválvula)
  • Relé:NO -> Entrada de la electroválvula

Plain
 [ESP32 GPIO] ---- Res 1kΩ ----|
                              |
                             \|/ Base
                          ---------
                          $Transistor$
                          $  2N2222  $
                          ----|-----|
[GND] -------------------$ E  C $---|---- A1 (Relé)
                          ---------  |
                                     |
                                    ---- A2 (Relé)
                                    |
                                   [ +5V ]

                    (Diodo 1N4007 de Protección)
               (cátodo) ------|<|------ (ánodo)
                             +5V      Colector del Transistor

                 (Conectar la carga al relé)
[Alimentación Electroválvula] ------------- (COM Relé)
                            |
                            |
                          (NO Relé) --------------> Entrada de la Electroválvula

riro9510

copilot

1. Redundancia:
   • Ventajas:
     • Resiliencia y confiabilidad: La redundancia puede proporcionar una capa adicional de seguridad, asegurando que si una parte del sistema falla, otra puede tomar su lugar.
     • Durabilidad: Puede prolongar la vida útil del sistema al distribuir la carga entre componentes duplicados.
   • Desventajas:
     • Costo: Agregar redundancias puede aumentar significativamente el costo del proyecto en términos de componentes electrónicos y tiempo de desarrollo.
     • Complejidad: El diseño del circuito y del PCB puede volverse más complejo.

• Espacios de sobra:
  • El ESP32 tiene muchos pines GPIO, y puedes usar los que no estén en uso para funciones adicionales. Esto es beneficioso para futuras expansiones.
  • Considera mantener algunos pines libres para la depuración y las pruebas durante el desarrollo.

• Programación y Comunicación:
  • El puerto USB-C en el ESP32-DEVKITC-32UE se utiliza principalmente para la programación inicial y para comunicarse con el puerto serie.
  • Comunicación Serial: Puedes usar el USB-C simultáneamente con WiFi o Bluetooth para tareas de comunicación serial (por ejemplo, para depuración o monitoreo en tiempo real).

• Combinación de Interfaces: Puedes usar WiFi o Bluetooth para el control remoto y el USB-C para la programación y depuración.
• Monitoreo y Actualización: Usar el USB-C para monitoreo en tiempo real y depuración puede ser una buena práctica durante el desarrollo sin afectar el funcionamiento normal del sistema por WiFi o Bluetooth.
• Protección y Seguridad: Agregar protecciones básicas como diodos, fusibles de recuperación y varistores puede mejorar la durabilidad sin agregar demasiadas redundancias.

1. Redundancia:
   • Insertar redundancia si la confiabilidad es crítica.
   • Evaluar costo y beneficios al decidir.
2. Uso Extra de GPIOs:
   • Utilizar pines GPIO adicionales para expansión y funciones extras.
   • Mantener algunos pines libres para depuración y futuras necesidades.
3. Conexión USB-C:
   • Usar el USB-C para programación, depuración y monitoreo.
   • Permitir conexión simultánea con WiFi/Bluetooth y USB para flexibilidad en comunicación.

• WiFi Control: Control remoto de la lavadora y bomba a través de una app o servidor web.
• USB-C Debugging: Conectar a una computadora para visualizar mensajes de depuración mientras pruebas el sistema.
• GPIO Expansion: Añadir sensores adicionales o interfaces como pantallas en pines GPIO disponibles.

• Evalúa la importancia de la redundancia en tu proyecto específico. Si la confiabilidad es clave, puede ser beneficioso, aunque costoso.
• Maximiza el uso de GPIO y el USB-C para mejorar la funcionalidad y facilitar el desarrollo y mantenimiento del sistema.
• Asegúrate de mantener un equilibrio entre costo y beneficios según las necesidades de tu proyecto.

riro9510

copilot

1. Puente H (Puedes usar un módulo integrado como el L298N o el L293D)
2. ESP32-DEVKITC-32UE
3. Diodos de protección (si no están integrados en el módulo)
4. Fuente de alimentación adecuada para el motor

• IN1 y IN2 - Controlan la dirección del motor 1.
• ENA - Habilitación del motor 1.
• IN3 y IN4 - Controlan la dirección del motor 2.
• ENB - Habilitación del motor 2.
• OUT1 y OUT2 - Salidas para el motor 1.
• OUT3 y OUT4 - Salidas para el motor 2.
• VCC y GND - Alimentación para la lógica del módulo.
• +12V y GND - Alimentación para los motores.

1. Alimentación del Módulo:
   • VCC del módulo L298N a 5V del ESP32.
   • GND del módulo L298N a GND del ESP32.
   • +12V de alimentación al terminal +12V del puente H.
   • GND de alimentación al terminal GND del puente H.
2. Conexión del Motor:
   • Conecta el motor a los pines OUT1 y OUT2 del módulo L298N (asumiendo que estás usando el motor 1).
3. Control de Dirección y Habilitación:
   • Conecta $U2:GPIO13$ a IN1.
   • Conecta $U2:GPIO12$ a IN2.
   • Conecta $U2:GPIO14$ a ENA.
   • Deberás habilitar el motor en ENA y controlar la dirección a través de IN1 e IN2.

• Para girar a la derecha:
  • IN1 = HIGH
  • IN2 = LOW
• Para girar a la izquierda:
  • IN1 = LOW
  • IN2 = HIGH
• Para detener el motor:
  • ENA = LOW

Cpp
#define IN1  13
#define IN2  12
#define ENA  14

void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENA, OUTPUT);
}

void loop() {
  // Gira a la derecha
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  digitalWrite(ENA, HIGH);
  delay(5000); // Gira por 5 segundos

  // Detiene el motor
  digitalWrite(ENA, LOW);
  delay(2000); // Espera 2 segundos
  
  // Gira a la izquierda
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  digitalWrite(ENA, HIGH);
  delay(5000); // Gira por 5 segundos

  // Detiene el motor
  digitalWrite(ENA, LOW);
  delay(2000); // Espera 2 segundos
}

• Usa un módulo puente H (como el L298N) para controlar la dirección del motor.
• Controla los pines IN1, IN2 para cambiar la dirección del motor mediante GPIO del ESP32.
• Habilita y deshabilita el motor usando ENA.
• Asegúrate de que tu fuente de alimentación es adecuada para el motor.

riro9510

copilot

• VCC del L298N: Conecta a 5V del ESP32.
• GND del L298N: Conecta a GND del ESP32.
• +12V del L298N: Conecta a la alimentación de 12V o la adecuada para tu motor.
• OUT1 y OUT2: Conecta a los terminales de tu motor.

• IN1 e IN2: Conecta a los pines GPIO del ESP32 (ej. GPIO13 y GPIO12).
• ENA: Conecta a un pin GPIO del ESP32 para habilitar el motor (ej. GPIO14).

1. Alimentación Módulo L298N
   • Conecta VCC a 5V del ESP32.
   • Conecta GND del módulo a GND del ESP32.
   • Conecta +12V a la fuente de alimentación adecuada (mismo voltaje del motor).
   • Conecta GND de la alimentación a GND del sistema.
2. Motor
   • Conecta OUT1 y OUT2 del L298N a los terminales del motor.
3. Control (dirección y habilitación)
   • Conecta IN1 del L298N a GPIO13 del ESP32.
   • Conecta IN2 del L298N a GPIO12 del ESP32.
   • Conecta ENA del L298N a GPIO14 del ESP32.

Plain
                     +-----------+
                     |  L298N    |
    [ESP32]--------- | VCC    OUT1|---> Motor Terminal 1
    [ESP32]--------- | GND    OUT2|---> Motor Terminal 2
    [5V DC]--------- | 5V     IN1 |----------[ESP32:GPIO13]
    [12V DC]-------- | 12V    IN2 |----------[ESP32:GPIO12]
    [GND]----------- | GND    ENA |----------[ESP32:GPIO14]
                     +-----------+

Cpp
#define IN1  13
#define IN2  12
#define ENA  14

void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENA, OUTPUT);
}

void loop() {
  // Gira a la derecha
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  digitalWrite(ENA, HIGH);
  delay(5000); // Gira por 5 segundos

  // Detiene el motor
  digitalWrite(ENA, LOW);
  delay(2000); // Espera 2 segundos
  
  // Gira a la izquierda
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  digitalWrite(ENA, HIGH);
  delay(5000); // Gira por 5 segundos

  // Detiene el motor
  digitalWrite(ENA, LOW);
  delay(2000); // Espera 2 segundos
}

1. Relé anterior controla la alimentación del L298N:
   • Controlar el relé como antes.
   • Conectar el común del relé a la alimentación de 12V.
   • Conectar el NO del relé a la VCC del L298N.
2. Mantenimiento del control vía L298N:
   • Alimenta el L298N solo cuando el relé esté activado, conectado a la fuente de alimentación adecuada.

1. Relé habilita y deshabilita el L298N:
   • Relé controla la alimentación del L298N.
   • L298N maneja la inversión de dirección y control del motor.

• Opción 1:
  • Ventajas:
    • Más simple.
    • Menos componentes.
  • Desventajas:
    • Perderías aislamiento adicional del relé.
• Opción 2:
  • Ventajas:
    • Aislamiento adicional del relé.
  • Desventajas:
    • Más complejo.
    • Más componentes.

riro9510

copilot

1. Dos relés de 5V DC con capacidad de conmutar 110-220V AC (Ej. SRD-05VDC-SL-C).
2. ESP32-DEVKITC-32UE
3. Transistor NPN (Ej. 2N2222)
4. Resistencia (1kΩ)
5. Diodo de protección (Ej. 1N4007)
6. Motor de Alta Tensión

1. Conexión del Primer Relé:
   • COM1: Línea de AC.
   • NO1: Terminal A del motor.
   • NC1: Terminal B del motor.
2. Conexión del Segundo Relé:
   • COM2: Línea de AC.
   • NO2: Vacío.
   • NC2: Terminal B del motor (unido a NC1 del primer relé, terminal A).

1. Conexión de Control del Relé 1:
   • GPIO del ESP32 -> Resistencia -> Transistor -> Relé.
2. Conexión de Control del Relé 2:
   • Segundo GPIO del ESP32 -> Resistencia -> Transistor -> Relé.

Plain
                           +--------+
$$\text{[AC Line]}$$------------------| COM1   |------------------$$\text{[AC Line]}$$
                           | NO1    |----$$\text{[Motor Terminal A]}$$
                           | NC1    |----$$\text{[Motor Terminal B]}$$
                           +--------+

                           +--------+
$$\text{[AC Line]}$$------------------| COM2   |------------------$$\text{[AC Line]}$$
                           | NO2    |----$$\text{[Vacío]}$$
                           | NC2    |----$$\text{[Motor Terminal B]}$$
                           +--------+

$$\text{(GND)}$$---------------$$\text{(Emisor de los transistores)}$$
$$\text{(GPIO)}$$------$$\text{(Resistor)}$$----$$\text{(Base del transistor 1)}$$-----$$\text{(A1 Relé 1)}$$
                           $$\text{(Colector transistor 1)}$$-----$$\text{(A2 Relé 1, +5V)}$$
$$\text{(GPIO)}$$------$$\text{(Resistor)}$$----$$\text{(Base del transistor 2)}$$-----$$\text{(A1 Relé 2)}$$
                           $$\text{(Colector transistor 2)}$$-----$$\text{(A2 Relé 2, +5V)}$$

$$\text{(Diodo de Protección en cada relé: A1-A2)}$$

Plain
             $$\text{ESP32 GPIO13}$$   ------ $$\text{Res 1kΩ}$$ ------|>---- $$\text{Base Transistor 1}$$
                         |                          |
                        \ /                       ;
                        ---                       ;
      $$\text{GND}$$ --------|----|                           |-------------|---
                      E  C                           $$\text{A1  NC1 NO1  COM1}$$
                      Transistor                    $$\text{Relé 1}$$
                         |                          |
                      $$\text{GND}$$                            |-------------|---> $$\text{Motor Terminal A}$$
                                                     |-------------|---> $$\text{Motor Terminal B}$$
             $$\text{ESP32 GPIO12}$$   ------ $$\text{Res 1kΩ}$$ ------|>---- $$\text{Base Transistor 2}$$
                         |                          |
                        \ /                       ;
                        ---                       ;
      $$\text{GND}$$ --------|----|                           |-------------|---
                      E  C                           $$\text{A1  NC2 NO2  COM2}$$
                      Transistor                    $$\text{Relé 2}$$
                         |                          |
                      $$\text{GND}$$                            |-------------|---> $$\text{Motor Terminal B}$$
                                                     |-------------|---> $$\text{Vacío}$$
                         $$\text{+5V}$$                            |
                         ----------------------- $$\text{A2}$$

Cpp
#define RELAY1 13  // Control del primer relé
#define RELAY2 12  // Control del segundo relé

void setup() {
  pinMode(RELAY1, OUTPUT);
  pinMode(RELAY2, OUTPUT);
}

void loop() {
  // Gira a la derecha
  digitalWrite(RELAY1, HIGH);
  digitalWrite(RELAY2, LOW);
  delay(5000); // Gira por 5 segundos

  // Detiene el motor (both relays off)
  digitalWrite(RELAY1, LOW);
  digitalWrite(RELAY2, LOW);
  delay(2000); // Espera 2 segundos
  
  // Gira a la izquierda
  digitalWrite(RELAY1, LOW);
  digitalWrite(RELAY2, HIGH);
  delay(5000); // Gira por 5 segundos

  // Detiene el motor
  digitalWrite(RELAY1, LOW);
  digitalWrite(RELAY2, LOW);
  delay(2000); // Espera 2 segundos
}

• Dos relés: Utiliza dos relés para alternar la polaridad de la conexión del motor.
• Control mediante transistores: Cada relé controlado por un transistor que, a su vez, es controlado por los GPIOs del ESP32.
• Seguridad: Los diodos de protección deben estar presentes para evitar daños por corriente inversa.

riro9510

copilot

1. Evita el uso de pines adyacentes para señales críticas: Si dos pines adyacentes están bajo alta conmutación (cambio rápido de estado) o son sensibles a interferencias (como entradas analógicas), podría ser prudente separarlos para minimizar el ruido y la diafonía.
2. Agrupa pines según su función: Por ejemplo, agrupar todos los pines relacionados con I2C juntos y alejarlos de los pines de carga pesada puede ayudar a mantener la señal más limpia.

1. Separación de señales de alta frecuencia y potencia: Mantén los caminos de señal de alta frecuencia y potencia lo más alejados posible de señales de baja potencia y alta sensibilidad.
2. Planificación de la Razonable Distribución: Asegúrate de que todas las pistas puedan enrutar sin interferencias excesivas, lo que podría resultar en una malla compleja y desequilibrada.

• No pongas pines de señales críticas como Tx y Rx uno junto al otro si no es necesario. Separa estos pines con señales GND o no críticas si es posible.

• Evita que múltiples pines cambien de estado simultáneamente, ya que puede inducir ruido en la placa. Si varias señales cambian al mismo tiempo, intenta distribuirlas en pines no adyacentes.

• Si estás usando, por ejemplo, GPIO13 y GPIO12 para el primer relé y quieres usar GPIO14 para el segundo relé, es perfectamente válido y usualmente parece una elección lógica.
• Sin embargo, asegúrate de que no estás colocando elementos de comunicación de alta frecuencia (por ejemplo, pines RX/TX de UART) adyacentes sin suficientes capas de separación.

• Primer Relé: Usa GPIO13 y GPIO12.
• Segundo Relé: Usa GPIO14 y GPIO27 (no adyacentes).

Plain
 ESP32 GPIOs Plan:
 ----------------------------------
| GPIO13 (Relé 1, IN1)  |
| GPIO12 (Relé 1, IN2)  |
       ...[algunos pines entre...]
| GPIO14 (Relé 2, IN1)  |
| GPIO27 (Relé 2, IN2)  |
 ----------------------------------

Cpp
#define RELAY1_IN1 13  // Control del primer relé
#define RELAY1_IN2 12  // Control del primer relé
#define RELAY2_IN1 14  // Control del segundo relé
#define RELAY2_IN2 27  // Control del segundo relé

void setup() {
  pinMode(RELAY1_IN1, OUTPUT);
  pinMode(RELAY1_IN2, OUTPUT);
  pinMode(RELAY2_IN1, OUTPUT);
  pinMode(RELAY2_IN2, OUTPUT);
}

void loop() {
  // Gira a la derecha
  digitalWrite(RELAY1_IN1, HIGH);
  digitalWrite(RELAY1_IN2, LOW);
  delay(5000); // Gira por 5 segundos

  // Detiene el motor (both relays off)
  digitalWrite(RELAY1_IN1, LOW);
  digitalWrite(RELAY1_IN2, LOW);
  delay(2000); // Espera 2 segundos
  
  // Gira a la izquierda
  digitalWrite(RELAY2_IN1, HIGH);
  digitalWrite(RELAY2_IN2, LOW);
  delay(5000); // Gira por 5 segundos

  // Detiene el motor
  digitalWrite(RELAY2_IN1, LOW);
  digitalWrite(RELAY2_IN2, LOW);
  delay(2000); // Espera 2 segundos
}

• Planificación y Enrutamiento: Planifica tu enrutamiento con cuidado. Mantén las pistas lo más cortas y directas posible.
• Separación de Planos de Tierra y Energía: Mantén buenos planos de tierra y energía. Asegura que haya el menor ruido posible en los caminos de energía.
• Capacitores de Desacoplamiento: Usa capacitores de desacoplamiento cerca de los pines de alimentación de los circuitos integrados.

riro9510

copilot

• Un solo pin GPIO controla cada relé.
• Un transistor actúa como interruptor para cada relé.
• El diodo en paralelo con el relé protege contra el back EMF.

1. Pin del ESP32: GPIO13
2. Resistencia en serie: 1kΩ
3. Transistor: 2N2222
4. Relé: SRD-05VDC-SL-C
5. Diodo de Protección: 1N4007
6. Conecta GPIO13 del ESP32 a una resistencia de 1kΩ.
7. Conecta el otro terminal de la resistencia a la base del transistor 2N2222.
8. Conecta el emisor del transistor a GND.
9. Conecta el colector del transistor a la terminal A1 del relé.
10. Conecta la terminal A2 del relé a +5V.
11. Conecta un diodo 1N4007 entre A1 y A2 del relé: cátodo a A2 y ánodo a A1.

1. Pin del ESP32: GPIO14
2. Resistencia: 1kΩ
3. Transistor: 2N2222
4. Relé: SRD-05VDC-SL-C
5. Diodo de Protección: 1N4007
6. Conecta GPIO14 del ESP32 a una resistencia de 1kΩ.
7. Conecta el otro terminal de la resistencia a la base del transistor 2N2222.
8. Conecta el emisor del transistor a GND.
9. Conecta el colector del transistor a la terminal A1 del relé.
10. Conecta la terminal A2 del relé a +5V.
11. Conecta un diodo 1N4007 entre A1 y A2 del relé: cátodo a A2 y ánodo a A1.

1. COM de Relé 1 a AC Line
   • Conecta COM del primer relé a la línea AC (110-220V).
2. NO de Relé 1 a Motor Terminal A
   • Conecta NO del primer relé al terminal A del motor.
3. NC de Relé 1 a Motor Terminal B
   • Conecta NC del primer relé al terminal B del motor.
4. COM de Relé 2 a AC Line
   • Conecta COM del segundo relé a la línea AC (110-220V).
5. NO de Relé 2 a Vacío
   • Deja NO del segundo relé sin conectar.
6. NC de Relé 2 a Motor Terminal B
   • Conecta NC del segundo relé al terminal B del motor (unido a NC1 del primer relé, terminal A).

Plain
-----------------------------+          +-----------------------
|            Relé 1          |          |          Relé 2
-----------------------------+          +-----------------------
 A1 (GPIO13) - (Res 1kΩ) - Base        A1 (GPIO14) - (Res 1kΩ) - Base
 C - Colector - NO - Motor Terminal A  C - Colector - NC - Motor Terminal B 
 E - Emisor - GND                     E - Emisor - GND
 A2 - +5V                              A2  - +5V
 [Diodo 1N4007 en paralelo]
   COM - AC Line                        COM - AC Line
   NO - Motor Terminal A                NC - Motor Terminal B
   NC - Motor Terminal B                NO - [Vacío]

Cpp
#define RELAY1 13  // GPIO para Relé 1
#define RELAY2 14  // GPIO para Relé 2

void setup() {
  pinMode(RELAY1, OUTPUT);
  pinMode(RELAY2, OUTPUT);
}

void loop() {
  // Gira en una dirección
  digitalWrite(RELAY1, HIGH);
  digitalWrite(RELAY2, LOW);
  delay(5000); // Gira por 5 segundos

  // Detener el motor (ambos relés apagados)
  digitalWrite(RELAY1, LOW);
  digitalWrite(RELAY2, LOW);
  delay(2000); // Espera 2 segundos

  // Gira en la otra dirección
  digitalWrite(RELAY1, LOW);
  digitalWrite(RELAY2, HIGH);
  delay(5000); // Gira por 5 segundos

  // Detener el motor
  digitalWrite(RELAY1, LOW);
  digitalWrite(RELAY2, LOW);
  delay(2000); // Espera 2 segundos
}

riro9510

copilot

1. Selecciona el Componente:
   • Haz clic en el componente que deseas duplicar en tu esquemático.
2. Duplicar Componente:
   • Usa el atajo de teclado Ctrl + D (Windows) o Cmd + D (Mac) para duplicar el componente seleccionado.
   • También puedes hacer clic derecho sobre el componente y seleccionar "Duplicar" en el menú contextual.
3. Posiciona el Componente Duplicado:
   • Después de duplicar, mueve el componente a la ubicación deseada en el esquemático y haz clic para colocarlo.

1. Selecciona el Relé:
   • Haz clic en el relé que ya tienes en tu esquemático (por ejemplo, $K1$).
2. Duplicar el Relé:
   • Presiona Ctrl + D o Cmd + D.
   • También puedes hacer clic derecho y seleccionar Duplicar.
3. Posicionar el Nuevo Relé:
   • Mueve el relé duplicado a su nueva posición y haz clic para colocarlo.
4. Renombrar y Ajustar:
   • Necesitarás ajustar el designador del componente duplicado (por ejemplo, cambiar "K1" a "K2") y asegurarte de que todas las conexiones sean correctas.

• Designadores Únicos: Asegúrate de cambiar los designadores de los componentes duplicados para que sean únicos. Flux.ai debería hacer esto automáticamente, pero siempre es bueno verificar.
• Enrutamiento de Conexiones: Duplica también las conexiones y asegúrate de ajustar el enrutamiento para evitar cruces innecesarios y mantener el diseño ordenado.
• Verificación: Después de duplicar y reposicionar los componentes, verifica que todas las conexiones sean correctas y que los componentes están correctamente ubicados y etiquetados.

1. Seleccionar Relé (K1):
   • Haz clic en $K1$.
2. Duplicar Relé:
   • Presiona Ctrl + D o Cmd + D.
   • Coloca el relé duplicado y verifica que ahora es, por ejemplo, $K2$.
3. Seleccionar Transistor (Q1):
   • Haz clic en $Q1$.
4. Duplicar Transistor:
   • Presiona Ctrl + D o Cmd + D.
   • Coloca el transistor duplicado y verifica que ahora es, por ejemplo, $Q2$.

• Conexión a GPIO del ESP32:
  • Duplica y ajusta $GPIO$.
  • Asegura que la resistencia y el diodo de protección también se dupliquen correctamente en cada conexión nueva.

riro9510

copilot

riro9510

copilot

1. Número de Pines del Conector: Asegúrate de que el conector tiene suficientes pines para todas las conexiones necesarias.
2. Capacidad de Corriente: Asegura que el conector puede manejar la corriente requerida.
3. Facilidad de Acceso: Elige un conector que sea fácil de ensamblar y soldar.

      +-------+
     |  5-Pin  |
      +-------+
     P1: AC Line
     P2: COM (Relé 1)
     P3: NO (Relé 1)
     P4: COM (Relé 2)
     P5: NO (Relé 2)

1. COM (Relé 1): Conecta a P2.
2. NO (Relé 1): Conecta a P3.
3. COM (Relé 2): Conecta a P4.
4. NO (Relé 2): Conecta a P5.

Plain
       +---------------------------------------------------------------+
       |                           Conector                            |
       +---------------------------------------------------------------+
       |   P1 (AC Line) ---+----| COM Relé 1 |--> Motor Terminal A     |
       |   P2 (COM) -----+                         |
       |                        |                         |                              
       |                        +----| NO Relé 1  |--> Motor Terminal A     |
       |   P3 (NO)                                                           |
       |                                                                              |
       |   P4 (COM) ----+----| COM Relé 2 |--> Motor Terminal B
       |  P5 (NO)          +----| NO Relé 2 |     

      *******************************
                        \ /
                      
                       GPIO del ESP32   
       +---------------------------------------------------------------+
    GPIO 13  ---| Res 1kΩ---Transistor---| A1 Relé 1  |-----+-----|
       GND  ----------|---------| Emitter          |  ||----------- 

    GPIO 14  ---| Res 1kΩ---Transistor---| A1 Relé 2  |-----+-----|
       GND  ----------|---------|  Emitter         |  ||-----------
                       
  +5V                                          A2 Relés (ambos)      

1. Conectar las Entradas del Conector:
   • Conecta la línea AC a P1 del conector.
   • Conecta COM del Relé 1 a P2.
   • Conecta NO del Relé 1 a P3.
   • Conecta COM del Relé 2 a P4.
   • Conecta NO del Relé 2 a P5.
2. Enrutar las Salidas del Relé al Motor:
   • Conecta la salida de P2 (COM Relé 1) al terminal A del motor.
   • Conecta la salida de P3 (NO Relé 1) al mismo terminal A del motor.
   • Conecta la salida de P4 (COM Relé 2) al terminal B del motor.
   • Conecta la salida de P5 (NO Relé 2) al terminal B del motor.

1. Colocación: Coloca el conector cerca de los relés para minimizar las longitudes de las pistas y mantener el enrutamiento limpio.
2. GND: Asegúrate de tener un buen plano de tierra.
3. Energía: Mantén las pistas de energía cortas y gruesas para minimizar la resistencia.

1. Selecciona y coloca el conector: Selecciona el conector en tu librería de componentes de Flux.ai y colócalo en el diseño PCB.
2. Realiza las conexiones: Conecta los pines del conector a las salidas de los relés y a las entradas del motor correspondiente.

• Uso de Conector centralizado: Simplifica la organización y el enrutamiento de las conexiones.
• Planificación del enrutado: Mantén las pistas ordenadas y organizadas.
• Verificación de Diseño: Siempre verifica el diseño del PCB para asegurar que no haya cruces innecesarios ni pistas cortas.

riro9510

copilot

riro9510

copilot