Publicado el Deja un comentario

Mosfet IRLB 3034: El preferido de Ger.ar

Los MOSFET (Metal-Oxide-Semiconductor Field-Effect Transistor) se utilizan comúnmente en aplicaciones de potencia, como amplificadores de audio, controladores de motor, fuentes de alimentación conmutadas y otros dispositivos electrónicos de alta potencia.

El IRLB3034 es un MOSFET de potencia fabricado por la empresa Infineon Technologies.

Características clave del IRLB3034:

  1. Tipo: N-Channel (Canal N)
  2. Tensión de drenaje a fuente (VDS): Hasta 40V
  3. Corriente continua del drenaje (ID): 195 amperios
  4. Resistencia de encendido (RDS(on)): 1.4 mΩ (miliohmios) típicos a 10V de compuerta
  5. Tensión de compuerta a fuente (VGS): ± 20V

Ventajas sobre los transistores tradicionales:

Capacidades de conmutación: Este MOSFET tiene una alta capacidad de conmutación, lo que lo hace adecuado para aplicaciones donde se requiere una rápida conmutación, como en convertidores de energía y sistemas de control de motores.

Protección contra sobrecalentamiento: Algunas versiones de MOSFETs pueden incluir características de protección contra sobrecalentamiento, aunque esto puede variar según el modelo específico. Es importante verificar la hoja de datos para conocer las características de protección específicas.

Temperatura de operación: La hoja de datos proporcionará la temperatura máxima de operación permitida para garantizar un rendimiento estable y confiable.

Curvas de transferencia y características dinámicas: Estos gráficos y curvas en la hoja de datos te brindarán información sobre cómo responde el MOSFET a diferentes niveles de voltaje de compuerta, corriente de drenaje, etc.

El IRLB3034 generalmente viene en un encapsulado TO-220, que es común y facilita la instalación en placas de circuito impreso y disipadores de calor.

Código para probar con IDE


/*
  Prueba para Usar MOSFET IRLB3034 como interruptor digital con microcontrolador
  Funciones de la librería Arduino.h
*/
 
 
int led = D0;           // the PWM pin the LED is attached to
int brightness = 0;    // how bright the LED is
int fadeAmount = 4;    // how many points to fade the LED by
int maxFade = 25;
 
// the setup routine runs once when you press reset:
void setup() {
  // declare pin 9 to be an output:
  pinMode(led, OUTPUT);
  Serial.begin(115200);
}
 
// the loop routine runs over and over again forever:
void loop() {
  // set the brightness of pin 9:
  analogWrite(led, brightness);
 
  // change the brightness for next time through the loop:
  brightness = brightness + fadeAmount;
 
  // reverse the direction of the fading at the ends of the fade:
  if (brightness <= 0 || brightness >= maxFade) {
    fadeAmount = -fadeAmount;
    if (fadeAmount>0) delay (5000);
  }
  Serial.print("brightness: ");
  Serial.println(brightness);
  delay(30);
}
Publicado el 3 comentarios

Comunicación por modulo CAN MCP2515

MCP2515 es un controlador de red de área de controlador (Controller Area Network o CAN) que se utiliza comúnmente en sistemas embebidos para facilitar la comunicación entre dispositivos a través del protocolo CAN.

Años atrás, los coches tenían cientos y cientos de metros de cable, conectando cada interruptor directamente con, por ejemplo, las luces o la bocina. A medida que los automóviles se volvieran más complejos, esta simple lógica ya no funcionaría.

En 1986, Bosch introdujo el sistema de bus CAN, que resolvió este problema y abarató y facilitó la fabricación de automóviles. CAN es ahora el estándar de la industria y se utiliza en todo, desde automóviles y camiones hasta autobuses y tractores, e incluso aviones y barcos.

Saber cómo leer y analizar mensajes CAN en con un microcontrolador, permite obtener datos de un automóvil, como la temperatura del refrigerante, la posición del acelerador, la velocidad del vehículo y las rpm del motor, y utilizarlos en sus proyectos en el tablero.

El módulo de interfaz de bus CAN MCP2515 es la mejor solución para agregar conectividad CAN a su Arduino con interfaz SPI. Este tutorial le mostrará cómo conectar el módulo MCP2515 a un Arduino, pero primero, una introducción rápida al protocolo CAN.
Conceptos básicos del sistema de bus CAN

Una red de área de controlador (bus CAN) es un estándar de comunicaciones diseñado para permitir que los dispositivos del vehículo se comuniquen entre sí sin una computadora host.

Para comprender mejor el bus CAN, piense en su automóvil como un cuerpo humano. En este contexto, el bus CAN es el sistema nervioso.

Topología del bus CAN

La comunicación física se produce a través del mazo de cables del bus CAN, que consta de dos cables, CAN bajo y CAN alto. Ambos cables están trenzados firmemente para que la interferencia electromagnética afecte la señal en ambos cables de manera uniforme, minimizando así los errores.
puede par trenzado.

Los extremos más alejados del cable están terminados con resistencias de 120 ohmios. Debido a que el bus CAN es un bus de datos de alta velocidad, si el bus no está terminado, la señal se reflejará e interferirá con la siguiente señal de datos que baja por la línea, lo que podría interrumpir las comunicaciones.

La red CAN (Controller Area Network) típicamente utiliza dos cables para la transmisión de datos bidireccional: el cable CAN alto (CAN-High) y el cable CAN bajo (CAN-Low). Estos cables forman un par diferencial que permite la comunicación robusta y resistente a interferencias electromagnéticas.

La velocidad de comunicación en una red CAN puede variar. Los estándares CAN admiten velocidades de transmisión que van desde 50 Kbps (kilobits por segundo) hasta 1 Mbps (megabit por segundo). La elección de la velocidad dependerá de los requisitos específicos de la aplicación.

También es importante tener en cuenta que la distancia de la comunicación en una red CAN puede variar según la velocidad de transmisión. A velocidades más altas, la distancia efectiva de la comunicación puede ser más corta debido a la atenuación de la señal. Por ejemplo, como mencionaste, a 1 Mbps, la distancia típica puede ser de hasta 40 metros, mientras que a 50 Kbps, podría extenderse hasta 1000 metros.

Esquema del módulo de bus CAN MCP2515

Antes de ver el esquema del módulo, debe comprender un par de cosas sobre los circuitos integrados, es decir, MCP2515 y TJA1050.

MCP2515 IC es el controlador principal que internamente consta de tres subcomponentes principales: el módulo CAN, la lógica de control y el bloque SPI.

El módulo CAN es responsable de transmitir y recibir mensajes en el bus CAN. Control Logic maneja la configuración y operación del MCP2515 interconectando todos los bloques. El bloque SPI es responsable de la interfaz de comunicación SPI.

En cuanto al IC TJA1050, dado que actúa como interfaz entre el controlador CAN MCP2515 y el bus CAN físico, este IC es responsable de tomar los datos del controlador y transmitirlos al bus.

La siguiente imagen muestra el esquema del módulo CAN MCP2515 y muestra cómo MCP2515 IC y TJA1050 IC están conectados en el módulo.

Estructura del mensaje CAN:

  1. Campo de Encabezado (Header):
    • Inicio del Trama (SOF – Start of Frame): Es un bit dominante (0) que indica el inicio de la trama.
    • Campo de Arbitraje: Contiene la Identificación del Mensaje (ID) que determina la prioridad del mensaje. Los bits de menor valor tienen mayor prioridad.
    • Bit de Control: Indica si el mensaje es estándar o extendido.
    • Bit RTR (Remote Transmission Request): Indica si el mensaje es una solicitud de transmisión remota.
  2. Campo de Control: Contiene información sobre la longitud de los datos y otros bits de control.
  3. Campo de Datos (Data Field): Contiene los datos que se están transmitiendo. La longitud de este campo puede ser de 0 a 8 bytes.
  4. Campo de CRC (Cyclic Redundancy Check): Contiene bits de verificación de redundancia cíclica para garantizar la integridad de la trama.
  5. Campo de Confirmación (ACK): Después de la transmisión de la trama, los nodos receptores envían un ACK para confirmar que recibieron correctamente la trama.
  6. Campo de Separación entre Tramas (Interframe Space): Espacio entre tramas para distinguir entre tramas sucesivas.
  7. Campo de Fin de Trama (EOF – End of Frame): Indica el final de la trama.

Ahora bien: ¿Hace falta saber toda la estructura?

Podemos quedarnos con esto:

Formato del mensaje CAN:

En la comunicación CAN, los datos se transmiten en la red como un formato de mensaje particular. Este formato de mensaje contiene muchos segmentos, pero dos segmentos principales son los identificador y datos que ayuda a enviar y responder mensajes en el bus CAN.

Identificador o CAN ID:

El Identificador CAN (también conocido como CAN ID o PGN – Parameter Group Number) es crucial en la red CAN para identificar los mensajes y asignar prioridades. Aquí hay más detalles:

  1. Longitud del Identificador:
    • Puede tener una longitud de 11 bits (CAN estándar) o 29 bits (CAN extendido).
    • En CAN estándar, el identificador es de 11 bits y en CAN extendido, el identificador es de 29 bits.
  2. Prioridad:
    • En una red CAN, los mensajes con identificadores más bajos tienen mayor prioridad.
    • Los bits de menor valor en el campo de arbitraje del encabezado determinan la prioridad del mensaje.
  3. Tipos de Identificadores:
    • Estándar (11 bits): Utilizado para redes CAN estándar.
    • Extendido (29 bits): Se utiliza en redes CAN extendidas para manejar un mayor número de nodos y mensajes.
  4. Parameter Group Number (PGN):
    • En el contexto de J1939, un protocolo basado en CAN utilizado comúnmente en vehículos comerciales, el identificador se conoce como PGN.
    • El PGN se encuentra en los bits de mayor valor del identificador y agrupa mensajes relacionados.

Ejemplo de Identificador CAN estándar (11 bits): | ID10 | ID9 | ID8 | ID7 | ID6 | ID5 | ID4 | ID3 | ID2 | ID1 | ID0 |

Ejemplo de Identificador CAN extendido (29 bits): | ID28 | ID27 | ... | ID2 | ID1 | ID0 |

La combinación de identificador y bits de control en el campo de arbitraje ayuda a determinar qué mensaje tiene prioridad en el bus CAN, permitiendo una comunicación eficiente y organizada en entornos con múltiples nodos.

Datos:

los datos en un mensaje CAN representan la información real que se está transmitiendo desde un dispositivo a otro. Aquí están los detalles adicionales sobre los datos en un mensaje CAN:

  1. Campo de Datos:
    • Contiene los datos reales del sensor o control que se están transmitiendo.
    • La longitud de este campo puede variar de 0 a 8 bytes, dependiendo de la cantidad de datos que se estén enviando.
  2. Código de Longitud de Datos (DLC):
    • Indica la longitud de los datos en el campo de datos.
    • Puede tener un valor entre 0 y 8, lo que significa que el campo de datos puede contener entre 0 y 8 bytes de información.

Cables:

En sistemas CAN, se utilizan cables específicos para garantizar una transmisión de datos confiable y resistente a interferencias electromagnéticas. Aquí hay algunas características clave de los cables utilizados en redes CAN:

  1. Apantallamiento:
    • Los cables CAN suelen tener una capa de apantallamiento para proteger la señal de posibles interferencias electromagnéticas (EMI).
    • El apantallamiento ayuda a prevenir la entrada o salida de ruido electromagnético que podría afectar la integridad de las señales CAN.
  2. Pares Trenzados:
    • Los cables CAN suelen ser de par trenzado, lo que significa que hay dos conductores entrelazados a lo largo del cable.
    • La torsión de los pares ayuda a reducir la interferencia electromagnética entre los cables, mejorando la calidad de la señal.
  3. Impedancia Característica:
    • Los cables CAN están diseñados para tener una impedancia característica específica (generalmente 120 ohmios) para minimizar las reflexiones de la señal y garantizar una transmisión de datos adecuada.
    • La impedancia característica se mantiene constante a lo largo del cable para evitar distorsiones en la señal.
  4. Conectores:
    • Los conectores utilizados son generalmente del tipo macho-hembra y cumplen con estándares específicos.
    • Los conectores comunes incluyen conectores de 9 pines en aplicaciones automotrices y conectores de tipo D-sub en aplicaciones industriales.
  5. Longitud del Cable:
    • La longitud del cable CAN está limitada por la velocidad de transmisión y la calidad de la señal que se desea mantener.
    • En redes CAN estándar, la longitud máxima típica es de 40 metros, pero en aplicaciones específicas, como en vehículos, se pueden usar repetidores para extender la longitud total del bus CAN.
  6. Resistencia de Terminación:
    • Al final del bus CAN, se suelen colocar resistencias de terminación de 120 ohmios para evitar reflexiones de la señal y mejorar la integridad de la transmisión.

Es importante seleccionar cables adecuados y seguir las especificaciones recomendadas para garantizar un rendimiento confiable en las redes CAN. Las características específicas pueden variar según el entorno de aplicación, como automoción, industrial o sistemas embebidos.

Conexión con Placa de Desarrollo tipo Uno (Atmega328P)

Código para compilar con IDE:

Si bien ya vamos por la versión 2.veintipico, soy fan de la 1.8.19 ¿Por qué será?

Código para Transmitir

#include <SPI.h>
#include <mcp2515.h>

struct can_frame canMsg;
MCP2515 mcp2515(10);


void setup() {
  Serial.begin(115200);
  
  mcp2515.reset();
  mcp2515.setBitrate(CAN_125KBPS);
  mcp2515.setNormalMode();
  
  Serial.println("------- Escribir tecnología CAN ----------");
  Serial.println("ID  DLC   DATA");
}

void loop() {
  if (mcp2515.readMessage(&canMsg) == MCP2515::ERROR_OK) {
    Serial.print("El ID es: "); // print ID
    Serial.print(canMsg.can_id, HEX); // print ID
    Serial.print(", dlc:  "); 
    Serial.print(canMsg.can_dlc, HEX); // print DLC
    Serial.print(", mensaje: ");
    
    for (int i = 0; i<canMsg.can_dlc; i++)  {  // print the data
      Serial.print(canMsg.data[i],HEX);
      Serial.print(" | ");
    }

    Serial.println();      
  }
}

ver en github

Código para recibir:

#include <SPI.h>
#include <mcp2515.h>

struct can_frame canMsg1;
struct can_frame canMsg2;
MCP2515 mcp2515(10);


void setup() {
  canMsg1.can_id  = 0x0F6;
  canMsg1.can_dlc = 8;
  canMsg1.data[0] = 0x8E;
  canMsg1.data[1] = 0x87;
  canMsg1.data[2] = 0x32;
  canMsg1.data[3] = 0xFA;
  canMsg1.data[4] = 0x26;
  canMsg1.data[5] = 0x8E;
  canMsg1.data[6] = 0xBE;
  canMsg1.data[7] = 0x86;

  canMsg2.can_id  = 0x036;
  canMsg2.can_dlc = 8;
  canMsg2.data[0] = 0x0E;
  canMsg2.data[1] = 0x00;
  canMsg2.data[2] = 0x00;
  canMsg2.data[3] = 0x08;
  canMsg2.data[4] = 0x01;
  canMsg2.data[5] = 0x00;
  canMsg2.data[6] = 0x00;
  canMsg2.data[7] = 0xA0;
  
  while (!Serial);
  Serial.begin(115200);
  
  mcp2515.reset();
  mcp2515.setBitrate(CAN_125KBPS);
  mcp2515.setNormalMode();
  
  Serial.println("Ejemplo: Leer tecnología CAN");
}

void loop() {
  mcp2515.sendMessage(&canMsg1);
  mcp2515.sendMessage(&canMsg2);

  Serial.println("Messages sent");
  
  delay(1000);
}

ver en github

Publicado el Deja un comentario

RCWL0515/RCWL0516: Sensores de Movimiento con Radar por Microondas

Los módulos RCWL0515 y RCWL0516 son sensores de movimiento basados en la tecnología de radar de microondas. Aunque son similares en muchos aspectos, hay algunas diferencias notables entre ellos.

RCWL0515:

  1. Rango de Frecuencia: El RCWL0515 generalmente opera en un rango de frecuencia de 5.8 GHz.
  2. Ajuste de Sensibilidad: Tiene un potenciómetro que permite ajustar la sensibilidad del sensor.
  3. Modo de Operación: Puede funcionar en dos modos: H (alta sensibilidad) y L (baja sensibilidad). El usuario puede seleccionar el modo según sus necesidades.

RCWL0516:

  1. Rango de Frecuencia: El RCWL0516 opera en un rango de frecuencia más amplio, típicamente de 4.7 GHz a 5.8 GHz.
  2. Ajuste de Sensibilidad: A diferencia del RCWL0515, el RCWL0516 no tiene un potenciómetro de ajuste de sensibilidad. La sensibilidad se ajusta automáticamente.
  3. Modo de Operación: No tiene modos de operación seleccionables como el RCWL0515; en su lugar, el RCWL0516 ajusta automáticamente su sensibilidad según las condiciones ambientales.

Módulo RCWL0516 Descripción de pines

Número de PINPin NameDescription
1.3V3Regulated 3.3V output
2.GNDGround reference for module
3.OUTAnalog output from the sensor
4.VINVoltage input for the module
5.CDSSensor Disable

Ambos módulos comparten características comunes, como el uso de la tecnología Doppler para la detección de movimiento y la capacidad de salida de señales de activación. Pueden ser utilizados en proyectos de electrónica y domótica para la detección de presencia y movimiento.

El sensor RCWL0515 sería una versión reducida del RCWL0516, no provee fuente de alimentación auxiliar de 3.3V ni acceso al pin CDS.

Detectando con un microcontrolador y Arduino IDE

-> Funciona con el mismo ejemplo de Sensor PIR

Publicado el Deja un comentario

¿Qué placa de Desarrollo con ESP32 uso?

El microcontrolador ESP32 es el dispositivo electrónico que más me sorprende. Más que esto ya sería un microprocesador de última generación o algún «Sensor de control Mental». Pero de estos últimos, uno es algo caro como para experimentar (Mi PC tiene un Intel i5) y el otro no se ha inventado aún.

El ESP32 cuesta entre 3 y 8 dólares, tiene WiFi, BLE (que es mejor que solo Bluetooth), y dos núcleos, lo cuál lo hace muy versátil y simplificaría trabajo de programación en determinados proyectos (pues se puede dedicar un núcleo entero a una tarea que resulte compleja y lo demás ponerlo en el otro).

El microcontrolador ESP32 es lo que está dentro de la cubierta metálica. Lo que comúnmente se conoce como ESP32, sería el módulo completo, por ejemplo ESP32F o ESP32U

Este módulo, por ejemplo el ESP32U o ESP-WROOM-32U es todo un microcontrolador+WiFi+BLE. Esta versión (32U) Cuenta con una salida para conexión de antena en su placa. Funciona a 3.3V y se puede conectar (a través de soldadura SMD) y programarlo con Arduino IDE.

Las que he probado:

La ventaja de utilizar así el módulo es muy clara: su tamaño. Abre las puertas a infinidad de proyectos en un espacio recucido para cualquier tipo de dispositivo portable, prendas de vestir, drones donde el peso es mandatario evitar y un sinfín de aplicaciones más.

Las desventajas son para el desarrollador. Por eso sería redundante mas correcto decir que «Una placa de Desarrollo, facilita el desarrollo»

-Suelen tener regulador de tensión de 5V a 3.3V

-Incorporan pines espaciados 2.54mm (el estándar de Du Pont) lo que facilita mucho las conexiones

-Chip FTDI y puerto USB para rápida y fácil conexión a la computadora (requiere drivers)

-Incorporan un LED, que está para usarlo! Reprochable al fabricante que no lo incorpora.

ESP32 ESP-32S

(el módulo más genérico que encontré) se vende en Mercadolibre Argentina al precio más bajo, y en España se consigue en Amazon con la misma configuración de pines, así como en AliExpress, de un montón de fabricantes (viene de diferentes colores), para todo el mundo.

Publicado el Deja un comentario

Controlar Motor Paso a Paso con DRV8826

Un motor paso a paso es un tipo de motor eléctrico que realiza movimientos discretos o «pasos» en respuesta a señales eléctricas. Cada paso corresponde a un ángulo específico de rotación. Estos motores son ampliamente utilizados en aplicaciones que requieren un posicionamiento preciso, como impresoras 3D, máquinas CNC, robots, etc.

El DRV8826 es un controlador de motor paso a paso que se utiliza para controlar y gestionar la operación de motores paso a paso.

Paso a paso para el paso a paso (cuac):

Componentes básicos:

  1. Motor paso a paso: Este es el componente que realizará el movimiento. Los motores paso a paso tienen un número específico de pasos por revolución.
  2. Controlador de motor paso a paso (por ejemplo, DRV8826): Este componente se encarga de recibir las señales de control y alimentar el motor paso a paso de acuerdo con esas señales.
  3. Microcontrolador o Placa de Desarrollo: Se utiliza para enviar comandos al controlador del motor.
  4. Fuente de alimentación: Proporciona la energía necesaria para alimentar tanto el controlador como el motor.

Conexiones básicas:

  1. Conectar el motor al controlador: Conecta las bobinas del motor a las salidas del controlador. Asegúrate de seguir la secuencia correcta para las bobinas.
  2. Conectar el controlador al microcontrolador: Conecta los pines de control (pasos, dirección, etc.) del controlador al microcontrolador.
  3. Conectar la fuente de alimentación: Asegúrate de que tanto el controlador como el motor reciban la alimentación necesaria.

Configuración y código (ejemplo para compilar con Arduino IDE):

  • Se definen los pines de control (stepPin y dirPin).
  • En el bucle principal (loop), se establece la dirección del movimiento, y luego se realizan 200 pasos en esa dirección.
  • Se espera un segundo antes de cambiar la dirección del movimiento y realizar 200 pasos en la dirección opuesta.
  • Se repite este patrón.
// Definir pines de control
const int stepPin = 2;
const int dirPin = 3;

void setup() {
  // Configurar pines como salidas
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

void loop() {
  // Establecer la dirección del movimiento
  digitalWrite(dirPin, HIGH);  // Cambiar a LOW para invertir la dirección

  // Realizar 200 pasos
  for (int i = 0; i < 200; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);  // Ajustar según la velocidad del motor
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);  // Ajustar según la velocidad del motor
  }

  // Esperar un segundo
  delay(1000);

  // Cambiar la dirección del movimiento
  digitalWrite(dirPin, LOW);

  // Realizar 200 pasos en la dirección opuesta
  for (int i = 0; i < 200; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);  // Ajustar según la velocidad del motor
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);  // Ajustar según la velocidad del motor
  }

  // Esperar un segundo
  delay(1000);
}
Publicado el Deja un comentario

Sensor ACS712: Medir intensidad y consumo eléctrico con Arduino IDE

El ACS712 es una herramienta útil para medir la corriente en un circuito, lo que lo hace adecuado para diversas aplicaciones en electrónica y proyectos con microcontroladores como los que vienen en las Placas de Desarrollo tipo Arduino IDE.

Es importante tener en cuenta el rango de medición adecuado y considerar la intrusividad del sensor al planificar su implementación en un proyecto.

El ACS712 es un sensor de corriente que se utiliza para medir la intensidad de corriente en un circuito, ya sea en corriente continua (CC) o alterna (CA). Aquí hay más detalles sobre sus características y aplicaciones:

Principio de Funcionamiento:

Rangos Disponibles:

Existen diferentes versiones del ACS712 que tienen diferentes rangos de medición, como 5A, 20A y 30A.

La corriente máxima que puede manejar el sensor es 5 veces el rango de medición especificado.

Salida Proporcional a la Corriente:

La salida del sensor es una señal analógica proporcional a la corriente que fluye a través del conductor. La relación es generalmente de 185 mV por amperio.

Aislamiento Galvánico:

El ACS712 proporciona un aislamiento galvánico entre el camino conductor y el circuito interno del sensor, lo que significa que el conductor puede estar conectado a un potencial diferente sin afectar la medición.

Calibración de Fábrica

Viene calibrado de fábrica, pero para obtener mediciones precisas, puede ser necesario ajustar la calibración.

Desventajas


Es un sensor intrusivo, ya que debe insertarse en el conductor, lo que podría requerir cortar un cable. Puede ser menos conveniente en comparación con sensores no intrusivos como los transformadores de corriente.

El ACS712 utiliza un sensor Hall para medir el campo magnético generado por la corriente que fluye a través de un conductor.

Internamente, tiene un camino conductor (cobre) que está expuesto al flujo de corriente que se desea medir.




Aplicaciones Típicas:

Control de motores.

Control de cargas eléctricas.

Monitoreo del consumo de corriente en fuentes de alimentación.

Protección contra sobrecorrientes.

Publicado el Deja un comentario

Sensor PIR: Detectar movimiento con Arduino IDE

Un Sensor PIR, o Sensor de Infrarrojos Pasivos por sus siglas en inglés (Passive Infrared Sensor), es un tipo de sensor electrónico que detecta la radiación infrarroja. Estos sensores se utilizan comúnmente en aplicaciones de detección de movimiento, como sistemas de seguridad, control de iluminación y puertas automáticas. La característica «pasiva» de estos sensores radica en que no emiten energía por sí mismos; en cambio, detectan la radiación infrarroja emitida o reflejada por objetos en su campo de visión.

Principio de Detección

Los sensores PIR detectan cambios en la radiación infrarroja dentro de su rango de detección. Los seres humanos y otros animales de sangre caliente emiten radiación infrarroja, y el sensor puede detectar variaciones en esta radiación a medida que los objetos se mueven dentro de su campo de visión.

Material Piroeléctrico

Los sensores PIR utilizan un material piroeléctrico, el cual genera un voltaje cuando se expone a cambios rápidos de temperatura. Este material suele estar hecho de una sustancia cristalina que tiene la propiedad de generar una carga eléctrica en respuesta a cambios de temperatura.

Diseño

Detección con Dos Elementos

Los sensores PIR suelen constar de dos mitades o elementos. Cada mitad se encarga de detectar la radiación infrarroja de una zona específica en el campo de visión del sensor. La diferencia en la salida de estos dos elementos se utiliza para determinar si hay un cambio en el patrón de radiación infrarroja, indicando movimiento.

Lente de Fresnel:

  • La lente de Fresnel es una lente delgada y plana que se utiliza para enfocar la radiación infrarroja en los elementos sensoriales del PIR.
  • Su función principal es mejorar la sensibilidad y precisión del sensor PIR al dirigir la radiación infrarroja hacia los elementos detectores. También ayuda a ampliar el área de detección del sensor.
  • Se encuentran con variedad de diseños, como segmentos o anillos concéntricos, para optimizar la detección en diferentes direcciones.

Conexión a un microcontrolador:

Conectar el Sensor PIR al Microcontrolador:

  • VCC (Alimentación): Conectar al pin de alimentación del microcontrolador (por ejemplo, 5V en placa Arduino Uno).
  • GND (Tierra): Conectar al pin de tierra (GND) del microcontrolador.
  • OUT (Salida de señal): Conectar al pin de entrada/salida digital del microcontrolador (por ejemplo, un pin digital en un microcontrolador).

Algunos sensores PIR también pueden tener pines adicionales, como ajustes de sensibilidad o retardo.

Código para Arduino IDE

El siguiente código es uno de los más simples para corroborar el correcto funcionamiento del sensor.

int pirPin = 2;  // El PIN de Señal

void setup() {
  Serial.begin(9600);
  pinMode(pirPin, INPUT);
}

void loop() {
  int pirValue = digitalRead(pirPin);
  Serial.println(pirValue);
  delay(1000);  // Espera 1 segundo antes de realizar la próxima lectura
}

Observar la Salida

Abrir el Monitor Serieen la IDE de Arduino para ver la salida. Debería verse «1» cuando se detecte movimiento y «0» cuando no haya movimiento.

Publicado el 1 comentario

Sensor DHT11 y DHT22: Medir temperatura y humedad usando Arduino IDE

¿Qué son los sensores DHT11 y DHT22?

Dichos sensores, el DHT11 y el DHT22 (o AM2302) son modelos de una familia de sensores de medición simultánea de temperatura y humedad.

Estos sensores disponen de un procesador interno que realiza el proceso de la medición, proporcionando la medición mediante una señal digital, por lo que es sencillo obtener la medición desde un microcontrolador como un Atmega 328P (El que trae una placa tipo Arduino Uno) o un ESP32, que por el mismo precio cuenta con mayores prestaciones.

Ambos sensores presentan una carcasa plástica similar. Se pueden diferencia ambos modelos por el color del mismo. El DHT11 presenta una carcasa azul, mientras que en el caso del sensor DHT22 el exterior es blanco.

DHT11 es el sensor más básico, y cuenta con características técnicas más básicas. Tiene mayor precisión y rango de temperatura (fundamental para medir la humedad ambiente por encima del 80%), pero a un costo económico mayor.

Las características del DHT11 son realmente escasas, especialmente en rango de medición y precisión.

  • Medición de temperatura entre 0 a 50, con una precisión de 2ºC
  • Medición de humedad entre 20 a 80%, con precisión del 5%.
  • Frecuencia de muestreo de 1 muestras por segundo (1 Hz)

El modelo DHT22 tiene unas características relativamente muy superiores (según aplicaciones en entornos comunes):

  • Medición de temperatura entre -40 a 125 ºC, con una precisión de 0.5ºC
  • Medición de humedad entre 0 a 100%, con precisión del 2-5%.
  • Frecuencia de muestreo de 2 muestras por segundo (2 Hz)

EL DHT22 (sin llegar a ser un sensor de alta precisión) tiene cualidades que suelen ser más útiles para emplearlo en proyectos reales de monitorización o registro, que requieran una precisión convencional.

/*
Ejemplo de sketchde prueba para varios sensores de humedad/temperatura DHT

REQUIERE las siguientes bibliotecas Arduino:

Biblioteca de sensores DHT: https://github.com/adafruit/DHT-sensor-library
Biblioteca Adafruit Unified Sensor: https://github.com/adafruit/Adafruit_Sensor
*/

#include "DHT.h"
#define DHTPIN 2     // Conectar el sensor a este pin


/*
Conectar una resistencia de 10K desde el pin 2 (datos) al pin 1 (alimentación) del sensor
Inicializa el sensor DHT.
enga en cuenta que las versiones anteriores de esta biblioteca tomaron un tercer parámetro opcional para
ajusta los tiempos para procesadores más rápidos. Este parámetro ya no es necesario
a medida que el algoritmo de lectura DHT actual se ajusta para funcionar en procesos más rápidos.

*/


DHT dht(DHTPIN, DHTTYPE);

// Uncomment whatever type you're using!
//#define DHTTYPE DHT11   // DHT 11
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//#define DHTTYPE DHT21   // DHT 21 (AM2301)


void setup() {
  Serial.begin(9600);
  Serial.println(F("DHTxx test!"));

  dht.begin();
}

void loop() {
  // Wait a few seconds between measurements.
  delay(2000);

  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  // Read temperature as Celsius (the default)
  float t = dht.readTemperature();
  // Read temperature as Fahrenheit (isFahrenheit = true)
  float f = dht.readTemperature(true);

  // Check if any reads failed and exit early (to try again).
  if (isnan(h) || isnan(t) || isnan(f)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  // Compute heat index in Fahrenheit (the default)
  float hif = dht.computeHeatIndex(f, h);
  // Compute heat index in Celsius (isFahreheit = false)
  float hic = dht.computeHeatIndex(t, h, false);

  Serial.print(F("Humidity: "));
  Serial.print(h);
  Serial.print(F("%  Temperature: "));
  Serial.print(t);
  Serial.print(F("°C "));
  Serial.print(f);
  Serial.print(F("°F  Heat index: "));
  Serial.print(hic);
  Serial.print(F("°C "));
  Serial.print(hif);
  Serial.println(F("°F"));
}
Publicado el 1 comentario

Código para conectar dos ESP32 por Wi-Fi (Sin router de por medio)

Servidor:

#include <WiFi.h>
const char* ssid = "Nombre_Red_Servidor";
const char* password = "Contraseña_Servidor";
WiFiServer server(80);
int buttonPin = 5;
int buttonState = 0;
void setup() {
  Serial.begin(115200);
  pinMode(buttonPin, INPUT_PULLUP);
  // Configurar el ESP32 como un punto de acceso
  WiFi.softAP(ssid, password);
  IPAddress IP = WiFi.softAPIP();
  Serial.print("AP IP address: ");
  Serial.println(IP);
  server.begin();
  Serial.println("Server started");
}
void loop() {
  WiFiClient client = server.available();
  if (client) {
    //Serial.println("New client connected");
    while (client.connected()) {
      // Leer el estado del botón
      buttonState = 99;
      //String response = String(buttonState) + "," + String(analogRead(A0)) + "," + String(random(100));
      //client.println(response);
      if (client.available()) {
        String request = client.readStringUntil('\r');
        Serial.print("Client says: ");
        Serial.print(request);
        Serial.print(", ");
        int b = request.length();
        //Serial.print("b=");
        //Serial.println(b);
        if (b > 2) {
          int value1 = request.substring(0, request.indexOf(',')).toInt();
          request = request.substring(request.indexOf(',') + 1);
          int value2 = request.toInt();
          Serial.print("Received values from client: ");
          Serial.print(value1);
          Serial.print(", ");
          Serial.println(value2);
        }
      }
      //////// cada 3 segundos envia
      static unsigned long a;
      if (millis() > a + 5000) {
        a = millis();
        // Enviar dos variables simuladas al servidor
        int value1 = 2; // Valor simulado 1
        int value2 = 4; // Valor simulado 2
        int value3 = 6; // Valor simulado 2
          String response = String(value1) + "," + String(value2)+ "," + String(value3);
        //String response = String(buttonState) + "," + String(analogRead(A0)) + "," + String(random(100));
        Serial.print("Sending response: ");
        Serial.println(response);
        client.println(response);
        client.stop();
      }
    }
    //Serial.println("Client disconnected");
  }
}

Cliente:

#include <WiFi.h>
const char* ssid = "Nombre_Red_Servidor"; // Reemplaza con el SSID de tu red
const char* password = "Contraseña_Servidor"; // Reemplaza con la contraseña de tu red
const char* serverIP = "192.168.4.1"; // Reemplaza con la dirección IP del servidor
const int serverPort = 80;
void setup() {
  Serial.begin(115200);
  Serial.println("Conectándose a la red WiFi...");
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Conectado a la red WiFi. Dirección IP: ");
  Serial.println(WiFi.localIP());
}
void loop() {
  // Simular dos valores enteros para enviar al servidor
  int value1 = 1; // Valor simulado 1 (número aleatorio entre 0 y 9)
  int value2 = 3; // Valor simulado 2 (número aleatorio entre 0 y 99)
  // Construir la solicitud al servidor en el formato "value1,value2"
  String request = String(value1) + "," + String(value2);
  Serial.print("Enviando solicitud al servidor: ");
  Serial.println(request);
  // Establecer la conexión con el servidor
  WiFiClient client;
  if (client.connect(serverIP, serverPort)) {
    // Enviar la solicitud al servidor
    client.println(request);
    // Esperar la respuesta del servidor
    String response = client.readStringUntil('\r');
    Serial.print("Respuesta del servidor: ");
    Serial.println(response);
    
    // Si necesitas utilizar los valores de la respuesta separados por comas, puedes hacerlo de la siguiente manera:
    int serverValue1 = response.substring(0, response.indexOf(',')).toInt();
    response = response.substring(response.indexOf(',') + 1);
    int serverValue2 = response.substring(0, response.indexOf(',')).toInt();
    //response = response.substring(response.indexOf(',') + 1);
    //int serverValue3 = response.toInt();
    Serial.print("Valores recibidos del servidor: ");
    Serial.print(serverValue1);
    Serial.print(", ");
    Serial.print(serverValue2);
    //Serial.print(", ");
    //Serial.println(serverValue3);
  }
  
  // Esperar 5 segundos antes de enviar una nueva solicitud
  delay(5000);
}