Secuenciador de 10 LED con NE555 y CD4017 (Efecto OVNI) | Proyecto de electrónica educativa

En este video se presenta el montaje y funcionamiento de un secuenciador de diez luces LED, realizado con el temporizador NE555 y el contador decimal CD4017. Es un proyecto de electrónica educativa apropiado para estudiar generación de pulsos, circuitos digitales, conteo secuencial y control de indicadores luminosos.

El circuito se alimenta con 5 V. El integrado NE555 trabaja en modo astable y genera una señal periódica de reloj. La frecuencia de esta señal está determinada principalmente por las resistencias de 1 kΩ y 10 kΩ, junto con el condensador de 10 µF.

Cada pulso producido por el NE555 se aplica a la entrada de reloj del CD4017. Este contador activa sucesivamente sus diez salidas, provocando que los LED se enciendan uno después de otro. Al llegar a la décima salida, la secuencia comienza nuevamente desde el primer LED y se repite continuamente, generando un efecto visual de luz en movimiento.

La resistencia de 270 Ω limita la corriente que circula por los LED y los protege frente a una corriente excesiva. En las imágenes se observa el circuito experimental montado inicialmente sobre una placa de pruebas y conectado a una placa perforada que contiene los diez LED.

Esta práctica permite comprender de forma visual la relación entre la frecuencia del reloj, el conteo digital y la activación secuencial de cargas. También puede utilizarse como base para luces decorativas, indicadores de avance, señalizadores, carteles luminosos y otros efectos electrónicos.

Termómetro digital con Arduino UNO,  sensor DHT22 y Display LED TM163 – Prueba con soldador y enfriamiento por cooler

En este video se presenta una experiencia práctica con un termómetro digital electrónico, construido con un Arduino UNO, un sensor de temperatura y humedad DHT22 y un módulo visualizador LED de cuatro dígitos TM1637.

El montaje permite observar directamente en el display la temperatura medida por el sensor y comprobar cómo responde el sistema ante cambios reales de temperatura.

#include <TM1637Display.h>
#include <DHT.h>

//---------------------------------------
// Conexiones del display TM1637
//---------------------------------------
#define CLK 2
#define DIO 3

//---------------------------------------
// Conexión del sensor DHT22
//---------------------------------------
#define DHTPIN 4
#define DHTTYPE DHT22

TM1637Display display(CLK, DIO);
DHT dht(DHTPIN, DHTTYPE);

// Segmentos especiales
const uint8_t SEGMENTO_MENOS = SEG_G;
const uint8_t LETRA_C = SEG_A | SEG_D | SEG_E | SEG_F;
const uint8_t VACIO = 0x00;

void setup()
{
  display.setBrightness(7);  // Brillo máximo
  display.clear();

  dht.begin();

  // Pequeña indicación inicial
  uint8_t inicio[] = {
    SEG_G,
    SEG_G,
    SEG_G,
    SEG_G
  };

  display.setSegments(inicio);
  delay(1500);
}

void loop()
{
  float temperatura = dht.readTemperature();

  // Verifica si la lectura es válida
  if (isnan(temperatura))
  {
    mostrarError();
  }
  else
  {
    mostrarTemperatura(temperatura);
  }

  // El DHT22 necesita unos 2 segundos
  // entre mediciones
  delay(2000);
}

void mostrarTemperatura(float temperatura)
{
  uint8_t segmentos[4];

  // Redondea la temperatura a una décima
  int temperaturaEntera = round(temperatura * 10.0);

  // Temperaturas positivas: 24.5C
  if (temperaturaEntera >= 0)
  {
    int decenas = temperaturaEntera / 100;
    int unidades = (temperaturaEntera / 10) % 10;
    int decimas = temperaturaEntera % 10;

    if (decenas == 0)
    {
      segmentos[0] = VACIO;
    }
    else
    {
      segmentos[0] = display.encodeDigit(decenas);
    }

    // 0x80 enciende el punto decimal
    segmentos[1] = display.encodeDigit(unidades) | 0x80;
    segmentos[2] = display.encodeDigit(decimas);
    segmentos[3] = LETRA_C;
  }

  // Temperaturas negativas entre -9,9 y 0 °C
  else if (temperaturaEntera >= -99)
  {
    int valor = -temperaturaEntera;
    int unidades = valor / 10;
    int decimas = valor % 10;

    segmentos[0] = SEGMENTO_MENOS;
    segmentos[1] = display.encodeDigit(unidades) | 0x80;
    segmentos[2] = display.encodeDigit(decimas);
    segmentos[3] = LETRA_C;
  }

  // Temperaturas inferiores a -9,9 °C:
  // se muestran sin decimal
  else
  {
    int valor = round(-temperatura);

    segmentos[0] = SEGMENTO_MENOS;
    segmentos[1] = display.encodeDigit((valor / 10) % 10);
    segmentos[2] = display.encodeDigit(valor % 10);
    segmentos[3] = LETRA_C;
  }

  display.setSegments(segmentos);
}

void mostrarError()
{
  uint8_t error[] = {
    SEG_G,
    SEG_G,
    SEG_G,
    SEG_G
  };

  display.setSegments(error);
}

Componentes utilizados

• Arduino UNO.
• Sensor digital de temperatura y humedad DHT22.
• Display LED TM1637 de cuatro dígitos y siete segmentos.
• Punta de soldador utilizada como fuente de calor.
• Cooler o ventilador para producir enfriamiento por aire.
• Placa de pruebas.
• Cables de conexión.
• Fuente de alimentación mediante el puerto USB del Arduino.

Conexiones principales

El display TM1637 se conecta al Arduino UNO de la siguiente manera:

• VCC del display → 5 V.
• GND del display → GND.
• CLK del display → pin digital D2.
• DIO del display → pin digital D3.

El sensor DHT22 se conecta de esta forma:

• + del sensor → 5 V.
• − del sensor → GND.
• OUT del sensor → pin digital D4.

El Arduino recibe la información digital proporcionada por el DHT22, procesa el valor de temperatura y lo representa en el display TM1637 con una cifra decimal y la indicación correspondiente a grados Celsius.

Durante la experiencia se utiliza la punta caliente de un soldador como fuente de calor. Al acercarla progresivamente al sensor, sin establecer contacto directo, puede observarse cómo aumenta la temperatura indicada en el display. De esta manera se demuestra prácticamente la conversión de una magnitud física —la temperatura— en una señal digital que puede ser procesada y representada visualmente.

También se utiliza un cooler o ventilador que genera una corriente de aire sobre la zona de medición. Al retirar la fuente de calor y mantener el flujo de aire, puede observarse el proceso inverso: la temperatura disminuye gradualmente hasta aproximarse nuevamente a la temperatura ambiente.

La experiencia permite reconocer cuatro etapas fundamentales de un sistema electrónico de medición:

Temperatura → sensor DHT22 → procesamiento mediante Arduino UNO → visualización en el display TM1637

Este ensayo resulta especialmente útil con fines educativos, ya que permite estudiar de forma directa conceptos como sensores digitales, medición electrónica, procesamiento de señales, respuesta térmica, transferencia de calor, calentamiento, enfriamiento por convección forzada y visualización digital.

Es una práctica sencilla para laboratorios de electrónica, instrumentación, programación de microcontroladores y sistemas de medición. El soldador proporciona una fuente de calor fácilmente controlable, mientras que el cooler permite comprobar claramente el efecto que produce una corriente de aire sobre la velocidad de enfriamiento del sensor.

Controlador digital de temperatura con Arduino UNO, DHT22, TM1637 y relé ajustable

En este video se presenta la construcción y prueba de un controlador digital de temperatura con salida mediante relé, desarrollado con un Arduino UNO, un sensor DHT22, un display LED TM1637, un pulsador HW-483 y un potenciómetro de 10 kΩ.

El sistema mide continuamente la temperatura ambiente y la presenta en el display con una cifra decimal y la letra C, correspondiente a grados Celsius.

Al mantener presionado el pulsador HW-483, el display deja momentáneamente de mostrar la temperatura y presenta el valor de consigna. Este valor puede ajustarse mediante el potenciómetro dentro de una escala comprendida entre −5 y 50 °C. Al soltar el pulsador, la consigna queda fijada y el display vuelve a mostrar automáticamente la temperatura medida por el sensor.

Cuando la temperatura supera el valor establecido, el Arduino conmuta un módulo de relé de 5 V, que puede utilizarse para accionar un cooler, ventilador u otro sistema de refrigeración. El programa incorpora una pequeña histéresis para impedir que el relé conecte y desconecte repetidamente cuando la temperatura se encuentra muy próxima a la consigna.

Componentes utilizados

• Arduino UNO.

• Sensor digital de temperatura y humedad DHT22.

• Display LED TM1637 de cuatro dígitos.

• Pulsador HW-483.

• Potenciómetro de 10 kΩ.

• Módulo relé de 5 V.

• Cooler o ventilador pequeño.

• Protoboard y cables de conexión.

• Soldador utilizado como fuente de calor.

• Alimentación mediante el puerto USB del Arduino.

Prueba de funcionamiento

Para comprobar el comportamiento del controlador se ajusta primero una determinada temperatura de consigna utilizando el pulsador y el potenciómetro.

Luego se acerca cuidadosamente la punta caliente de un soldador al DHT22, sin tocar directamente el sensor. El display permite observar el aumento progresivo de la temperatura.

Cuando la medición supera el valor de consigna, el Arduino activa el relé y pone en funcionamiento el cooler. La corriente de aire producida por el ventilador enfría la zona del sensor y hace que la temperatura comience a disminuir.

Al descender por debajo del límite establecido por la consigna y la histéresis, el relé se desconecta. De esta manera se comprueba el ciclo completo de medición, comparación y control:

Temperatura → sensor DHT22 → Arduino UNO → comparación con la consigna → relé → cooler

La experiencia permite estudiar de manera práctica el funcionamiento de un sistema de control de temperatura en lazo cerrado, la lectura de sensores digitales, el ajuste de una variable mediante entrada analógica, la visualización de datos y el accionamiento de una carga mediante relé.

Este proyecto puede utilizarse como base para controlar la temperatura de gabinetes electrónicos, pequeños invernaderos, incubadoras experimentales, sistemas de ventilación, equipos didácticos y otras aplicaciones de automatización.

Conexiones utilizadas

• TM1637: CLK → D2 y DIO → D3.

• DHT22: OUT → D4.

• Pulsador HW-483: señal S → D5.

• Módulo relé: entrada IN → D6.

• Potenciómetro: cursor central → A0.

• Alimentación de los módulos: 5 V y GND comunes.

Conceptos clave

Arduino UNO, DHT22, TM1637, controlador de temperatura, termostato digital, relé de 5 V, valor de consigna, histéresis, potenciómetro, pulsador HW-483, cooler, sensor de temperatura, automatización, refrigeración, control electrónico y proyecto educativo.

#Arduino #DHT22 #TM1637 #TermostatoDigital #ControlDeTemperatura #Electrónica #Automatización #ProyectoArduino

#include <TM1637Display.h>
#include <DHT.h>

//---------------------------------------
// Display TM1637
//---------------------------------------
#define CLK 2
#define DIO 3

//---------------------------------------
// Sensor DHT22
//---------------------------------------
#define DHTPIN 4
#define DHTTYPE DHT22

//---------------------------------------
// Pulsador, potenciómetro y relé
//---------------------------------------
#define PULSADOR 5
#define RELE 6
#define POTENCIOMETRO A0

//---------------------------------------
// Configuración del relé
//---------------------------------------
// La mayoría de los módulos se activan con LOW.
// Cambiar a false si el módulo se activa con HIGH.
const bool RELE_ACTIVO_EN_LOW = true;

// Histéresis total de regulación
const float HISTERESIS = 0.5;

// Límites de ajuste
const float CONSIGNA_MINIMA = -5.0;
const float CONSIGNA_MAXIMA = 50.0;

//---------------------------------------
// Objetos
//---------------------------------------
TM1637Display display(CLK, DIO);
DHT dht(DHTPIN, DHTTYPE);

//---------------------------------------
// Segmentos especiales
//---------------------------------------
const uint8_t SEGMENTO_MENOS = SEG_G;

const uint8_t LETRA_C =
  SEG_A | SEG_D | SEG_E | SEG_F;

const uint8_t VACIO = 0x00;

//---------------------------------------
// Variables
//---------------------------------------
float temperatura = 0.0;
float consigna = 25.0;

bool estadoRele = false;

unsigned long ultimaLectura = 0;

const unsigned long INTERVALO_DHT = 2000;

//---------------------------------------
// Configuración inicial
//---------------------------------------
void setup()
{
  display.setBrightness(7);
  display.clear();

  dht.begin();

  pinMode(PULSADOR, INPUT);
  pinMode(RELE, OUTPUT);

  apagarRele();

  // Indicación inicial
  uint8_t inicio[] = {
    SEG_G,
    SEG_G,
    SEG_G,
    SEG_G
  };

  display.setSegments(inicio);
  delay(1500);

  // Primera lectura del sensor
  temperatura = dht.readTemperature();

  if (!isnan(temperatura))
  {
    mostrarTemperatura(temperatura);
  }
}

//---------------------------------------
// Programa principal
//---------------------------------------
void loop()
{
  // El HW-483 utiliza lógica inversa:
  // LOW = pulsador presionado
  // HIGH = pulsador liberado
  bool pulsadorPresionado =
    digitalRead(PULSADOR) == LOW;

  //-------------------------------------
  // Ajuste de la consigna
  //-------------------------------------
  if (pulsadorPresionado)
  {
    int lecturaPotenciometro =
      analogRead(POTENCIOMETRO);

    consigna = convertirAConsigna(
      lecturaPotenciometro
    );

    mostrarTemperatura(consigna);

    // Pequeño retardo para estabilizar
    // la indicación del potenciómetro
    delay(50);
  }

  //-------------------------------------
  // Lectura periódica del DHT22
  //-------------------------------------
  if (millis() - ultimaLectura >= INTERVALO_DHT)
  {
    ultimaLectura = millis();

    float nuevaTemperatura =
      dht.readTemperature();

    if (isnan(nuevaTemperatura))
    {
      apagarRele();

      if (!pulsadorPresionado)
      {
        mostrarError();
      }
    }
    else
    {
      temperatura = nuevaTemperatura;

      controlarRele();

      if (!pulsadorPresionado)
      {
        mostrarTemperatura(temperatura);
      }
    }
  }

  //-------------------------------------
  // Sin pulsar se muestra la temperatura
  //-------------------------------------
  if (!pulsadorPresionado &&
      !isnan(temperatura))
  {
    mostrarTemperatura(temperatura);
  }
}

//---------------------------------------
// Convierte la lectura 0-1023
// en una consigna de -5,0 a 50,0 °C
//---------------------------------------
float convertirAConsigna(int lectura)
{
  float valor = CONSIGNA_MINIMA +
    ((float)lectura / 1023.0) *
    (CONSIGNA_MAXIMA - CONSIGNA_MINIMA);

  // Redondeo a una décima de grado
  valor = round(valor * 10.0) / 10.0;

  return valor;
}

//---------------------------------------
// Control del relé para refrigeración
//---------------------------------------
void controlarRele()
{
  float limiteSuperior =
    consigna + HISTERESIS / 2.0;

  float limiteInferior =
    consigna - HISTERESIS / 2.0;

  // Activa el relé cuando la temperatura
  // supera la consigna
  if (!estadoRele &&
      temperatura >= limiteSuperior)
  {
    encenderRele();
  }

  // Desactiva el relé cuando la temperatura
  // baja suficientemente
  if (estadoRele &&
      temperatura <= limiteInferior)
  {
    apagarRele();
  }
}

//---------------------------------------
// Activación del relé
//---------------------------------------
void encenderRele()
{
  estadoRele = true;

  if (RELE_ACTIVO_EN_LOW)
  {
    digitalWrite(RELE, LOW);
  }
  else
  {
    digitalWrite(RELE, HIGH);
  }
}

//---------------------------------------
// Desactivación del relé
//---------------------------------------
void apagarRele()
{
  estadoRele = false;

  if (RELE_ACTIVO_EN_LOW)
  {
    digitalWrite(RELE, HIGH);
  }
  else
  {
    digitalWrite(RELE, LOW);
  }
}

//---------------------------------------
// Presentación de temperatura o consigna
//---------------------------------------
void mostrarTemperatura(float valor)
{
  uint8_t segmentos[4];

  int valorEntero = round(valor * 10.0);

  //-------------------------------------
  // Valores positivos: 24.5C
  //-------------------------------------
  if (valorEntero >= 0)
  {
    int decenas = valorEntero / 100;
    int unidades = (valorEntero / 10) % 10;
    int decimas = valorEntero % 10;

    if (decenas == 0)
    {
      segmentos[0] = VACIO;
    }
    else
    {
      segmentos[0] =
        display.encodeDigit(decenas);
    }

    segmentos[1] =
      display.encodeDigit(unidades) | 0x80;

    segmentos[2] =
      display.encodeDigit(decimas);

    segmentos[3] = LETRA_C;
  }

  //-------------------------------------
  // Valores negativos entre
  // -9,9 y 0 °C
  //-------------------------------------
  else if (valorEntero >= -99)
  {
    int valorPositivo = -valorEntero;

    int unidades = valorPositivo / 10;
    int decimas = valorPositivo % 10;

    segmentos[0] = SEGMENTO_MENOS;

    segmentos[1] =
      display.encodeDigit(unidades) | 0x80;

    segmentos[2] =
      display.encodeDigit(decimas);

    segmentos[3] = LETRA_C;
  }

  //-------------------------------------
  // Valores menores que -9,9 °C
  //-------------------------------------
  else
  {
    int valorPositivo = round(-valor);

    segmentos[0] = SEGMENTO_MENOS;

    segmentos[1] =
      display.encodeDigit(
        (valorPositivo / 10) % 10
      );

    segmentos[2] =
      display.encodeDigit(
        valorPositivo % 10
      );

    segmentos[3] = LETRA_C;
  }

  display.setSegments(segmentos);
}

//---------------------------------------
// Indicación de error del sensor
//---------------------------------------
void mostrarError()
{
  uint8_t error[] = {
    SEG_G,
    SEG_G,
    SEG_G,
    SEG_G
  };

  display.setSegments(error);
}