Mostrando entradas con la etiqueta Electrónica. Mostrar todas las entradas
Mostrando entradas con la etiqueta Electrónica. Mostrar todas las entradas

viernes, 13 de junio de 2025

Raspberry Pi sensor DHT11 y DHT22

DHT11
Uno de los sensores más populares utilizados en conjunto con la Raspberry Pi es el DHT11, un sensor de humedad y temperatura de bajo costo y fácil de usar.

¿Qué son los sensores DHT11 y DHT22?

Los sensores DHT11 y DHT22 son dispositivos electrónicos que mide la temperatura y la humedad relativa del aire. Es un sensor digital, lo que significa que los datos que proporciona son en formato digital y pueden ser fácilmente leídos por un microcontrolador como la Raspberry Pi.

DHT22


A pesar de su bajo costo, el DHT11 más que el DHT22, son bastante precisos y fiables, lo que los convierte en una excelente opción para una amplia gama de aplicaciones.

El DHT11 esta más indicado para Proyectos educativos o prototipos simples y ambientes interiores controlados como pueden ser habitaciones, oficinas.

Sin embargo el DHT22 será más útil en proyectos de tipo invernadero, neveras y exteriores.

Funciones del Sensor

  • Medición de temperatura
  • Medición de humedad
  • Salida digital
  • Bajo consumo
  • Fácil de usar

Comparativa: DHT11 vs DHT22

Característica DHT11 DHT22
Precisión (Temp) ±2°C ±0.5°C
Rango (Temp) 0°C a 50°C -40°C a 80°C
Precisión (Hum) ±5% RH ±2% RH
Rango (Hum) 20% a 80% RH 0% a 100% RH
Frecuencia de Muestreo 1 Hz 0.5 Hz
Resolución 1°C / 1% RH 0.1°C / 0.1% RH
Consumo Eléctrico 0.5 - 2.5 mA

Instalación y Configuración en Python:

Para utilizar los sensores DHT11 y DHT22 con una Raspberry Pi, necesitaremos un entorno de programación adecuado y una biblioteca para interactuar con el sensor. Python es uno de los lenguajes de programación más populares para la Raspberry Pi, y existen varias bibliotecas que facilitan la lectura de datos del DHT11.

Necesitamos instalar la biblioteca Adafruit. Ahora en un terminal de tu Raspberry Pi y ejecuta el siguiente comando para instalar la biblioteca adafruit-circuitpython-dht:


pip3 install adafruit-circuitpython-dht


Esta biblioteca proporciona una manera sencilla para leer datos de los sensores DHT11 y DHT22.

Ahora tenemos que conectar el sensor DHT a a la Raspberry Pi. Para esto identificaremos los pines de cada sensor y los conectamos siguiendo las serigrafias que vienen en el sensor:

  • Data: al GPIO21 (pin40)
  • VCC: al cualquier pin 5V
  • GND: al cualquier pin GND

Ahora en la terminal creamos un nuevo archivo Python llamado "dht11_test.py y escribimos el siguiente código que nos mostrará en pantalla los datos de temperatura y humedad del DHT11:



# Código para lectura del sensor DHT11
import time

import board

import adafruit_dht

#Inicia el dispositivo DHT con el pin de datos conectado a:
dhtDevice = adafruit_dht.DHT11(board.D21)

# Si no deseas usar pulseio puedes usar DHT11 use_pulseio=False
# Esto puede ser necesario en ordenadores de tipo Raspberry Pi con Linux
# Pero no funcionará en CircuitPython
# dhtDevice = adafruit_dht.DHT11(board.D18, use_pulseio=False)

while True:
    try:
        # Imprime los valores en el puerto serie
        temperature_c = dhtDevice.temperature
        temperature_f = temperature_c * (9 / 5) + 32
        humidity = dhtDevice.humidity
        print(f"Temp: {temperature_f:.1f} F / {temperature_c:.1f} C    Humidity: {humidity}% ")

    except RuntimeError as error:
	# Los errores ocurren con bastante frecuencia, los DHT son difíciles de leer, 
    simplemente sigue adelante.

        print(error.args[0])
        time.sleep(2.0)
        continue
    except Exception as error:
        dhtDevice.exit()
        raise error

    time.sleep(2.0)

Guarda el archivo como dht11_test.py y ejecútalo desde la terminal:


python3 dht11_test.py
o
python3 -m dht11_test


Para el caso del DHT22 es exactamente igual menos la linea "sensor = adafruit_dht.DHT11" que tenemos que cambiar por "sensor = adafruit_dht.DHT22" y se ve así:


# Código para lectura del sensor DHT22
import time

import board

import adafruit_dht

#Inicia el dispositivo DHT con el pin de datos conectado a:
dhtDevice = adafruit_dht.DHT22(board.D21)

# Si no deseas usar pulseio puedes usar DHT22 use_pulseio=False
# Esto puede ser necesario en ordenadores de tipo Raspberry Pi con Linux
# Pero no funcionará en CircuitPython
# dhtDevice = adafruit_dht.DHT22(board.D21, use_pulseio=False)

while True:
    try:
        # Imprime los valores en el puerto serie
        temperature_c = dhtDevice.temperature
        temperature_f = temperature_c * (9 / 5) + 32
        humidity = dhtDevice.humidity
        print(f"Temp: {temperature_f:.1f} F / {temperature_c:.1f} C    Humidity: {humidity}% ")

    except RuntimeError as error:
	# Los errores ocurren con bastante frecuencia, los DHT son difíciles de leer,
    simplemente sigue adelante.

        print(error.args[0])
        time.sleep(2.0)
        continue
    except Exception as error:
        dhtDevice.exit()
        raise error

    time.sleep(2.0)

Guardamos el archivo como dht22_test.py y ejecutamos desde la terminal:


python3 dht22_test.py
o
python3 -m dht22_test

El código de este ejemplo llamado dht_simpletest.py lo podemos encontrar en el repositorios de Adafruit_CircuitPython_DHT


Solución de errores:

uno de los errores que más comunes es el uso de la librería "board". Muchas veces podemos recibir el siguiente mensaje:


    import board
ModuleNotFoundError: No module named 'board'

O también este:


    dhtDevice = adafruit_dht.DHT11(board.D21)
                                   ^^^^^^^^^
AttributeError: module 'board' has no attribute 'D21'

Nos hace referencia a la librería board que se instala normalmente con "pip install board". Pero al estar haciendo uso de Adafruit CircuitPython necesitamos la librería que esta asociadad a Adafruit llamada "Adafruit-Blinka"

Esta librería instalara "board" y otras librerías como "pyserial" o "pyusb".

En el caso de que haya un error nos puede aparecer este mensaje:


Unable to set line 18 to input


Si aparece este error, nos hace referencia al pin, que o bien no esta activo o no es el puerto correcto donde esta conectado el sensor DHT 11.

Aplicaciones del DHT11 y Raspberry Pi

La combinación de Raspberry Pi y DHT11 o DHT22 ofrece un sinfín de posibilidades para proyectos de IoT. Algunas de las aplicaciones más comunes incluyen:

  • Estaciones meteorológicas caseras: Crea una estación meteorológica personalizada para monitorear la temperatura y humedad en tu hogar o jardín.
  • Sistemas de control de invernaderos: Automatiza el riego y la ventilación de tu invernadero en función de las condiciones ambientales.
  • Monitoreo de condiciones ambientales: Utiliza el sensor para monitorear la temperatura y humedad en espacios cerrados, como oficinas o almacenes.
  • Proyectos de domótica: Puedes integrar el sensor en sistemas de domótica para crear ambientes más cómodos y eficientes.
  • Prototipos de IoT: Utilizalos como punto de partida para desarrollar prototipos de dispositivos IoT más complejos.

Conclusión:

El sensor DHT11 es una herramienta invaluable para cualquier persona interesada en proyectos de electrónica y programación. En combinación con la Raspberry Pi, ofrece una plataforma potente y flexible para crear una amplia variedad de aplicaciones.

Con este artículo, has adquirido los conocimientos básicos para comenzar a trabajar con el DHT11 y la Raspberry Pi. ¡Anímate a experimentar y crear tus propios proyectos!

Instalación librería Adafruit-Blinka

Librería adafruit-circuitpython-dht

Aquí tienes otros enlaces de este blog relacionados con Raspberry Pi:

Programa de ejemplo de este articulo en GitHub

Raspberry Pi 3 Oled i2C

Raspberry Pi PWM

Poner Ip fija en Raspberry Pi


Un saludo a todos!!

lunes, 13 de noviembre de 2017

Arduino: Driver L293, DHT 11, nRF2401 (parte1)

Muy buenas a todos!!

Esto va sobre ruedas, y nunca mejor dicho, ya tengo la primera versión del mando XboxRC24 transmitter y para sus pruebas he utilizado un vehículo que construí cuando trabajaba con los microcontroladores 16f, que buenos recuerdos, siempre liado con los puertos COM del portátil...

Lo termine (todos sabemos que estos proyectos nunca terminan) y al poco tiempo empecé con Arduino.

Arduino nRF2401
Arduino nRF2401

Hace un tiempo lo actualice a esta plataforma utilizando el HC-06 encargado de la transmisiones de datos, ahora se encargará el nRF2401. Con un mayor alcance, un consumo casi de risa y siendo realmente estable es la mejor solución que he visto hasta ahora en el tema de radio control.


La base de este proyecto es completamente artesanal, realizado en aluminio y plástico reciclado.

La estructura de aluminio son unos separadores de los que se utilizan en la obra en cocinas y baños.

La base sobre la que va montada la electrónica son de una caja registradora.

Cuenta con una batería Ni-Cd de 9,6V y 900mAh, como ya he comentado y seguramente vuelva a comentar, el tema de las baterías tengo que estudiarlo más a fondo ya que es algo que a día de hoy esta muy avanzado. Es un diseño sencillo pero muy robusto, ideal para cacharrear con el.

Tenéis mas fotos de su construcción original en la entrada que escribí en su momento: Oruga cebek C-6083 V2

A partir de esas todo lo demás pertenece a la ultima actualización.

La electrónica:

Esquema de conexiones pata Tanque XboxRC24
Esquema de conexiones para Tanque XboxRC24

jueves, 26 de octubre de 2017

Arduino ejemplos: LCD con I2c

Buenas a todos Arduineros y Arduineras!!!

Si ya vimos antes como utilizar un LCD 16x02, Arduino: El LCD 16x2 y
Arduino: Diferentes efectos en un LCD 16x2
directamente conectando a Arduino usando en total un mínimo de 6 líneas, esto puede que no sea un problema si tú proyecto no utiliza muchos sensores, pero si es necesario usar el máximo de pines disponibles existe una solución que puedes usar, el módulo I2c para LCD.
Con este dispositivo conseguiremos un ahorro en los pines de nuestro Arduino pudiendo, además, conectar más dispositivos I2c a las mismas líneas de control.

El bus TWI/i2c:


El bus serie i2c fue creado por Philips en 1982 para la comunicación entre microcontroladores y periféricos.

El TWI (Two Wired Interface) es idéntico a nivel técnico pero Atmel tuvo que cambiar las siglas por motivos de licencias, pero a efectos prácticos es lo mismo.

I2c está diseñado como un bus de comunicación Maestro-Esclavo, con esto uno de los dispositivos (maestro) regula la comunicación y los demás dispositivos (esclavos) que atienden sus peticiones.

Este bus está formado por dos líneas, SLK y SDA.

  • SLK (Serial Clock) marca la velocidad de comunicación y marca los tiempos para la lectura/escritura en el bus.
  • SDA (Serial Data) es la línea por donde se transmite la información.

Cada dispositivo conectado al bus tiene una dirección, así que para conectarnos con el debemos saber dicha dirección, con este programa podréis saber cual es la dirección de vuestro dispositivo:

leer dirección de un dispositivo i2C

Conexión Arduino modulo i2C:
Conexión Arduino UNO con LCD i2C
Conexión Arduino UNO con LCD i2C

viernes, 8 de septiembre de 2017

Controlar DFPlayer Mini con Android por Bluetooth Parte 2

Buenas Arduineros y Arduineras!!!

Para que no se hiciera una entrada un poco larga, he decidido hacerlo en dos partes, la parte 1 que es la parte del programa para Android DFplayer Mini BT y la parte de Arduino con las conexiones y programación que es esta segunda.

Para que todo el proyecto funcione tenemos que habilitar varios puertos seriales ya que DFPlayer utiliza la comunicación serial, con lo que tenemos que habilitar otro puerto serial adicional, es decir si antes usábamos dos puertos seriales para comunicación PC==Arduino==DFPlayer ahora también necesitamos otro puerto serial para el Bluetooth HC-06.

¿Como tener más de dos puertos seriales con Arduino?

miércoles, 30 de agosto de 2017

Arduino: Reproducir MP3 con DFPlayer Mini

Buenas a todos Arduineros y Arduineras!!!

Esta vez vamos a ver como reproducir música con un pequeño reproductor de audio digital MP3 llamado DFPlayer Mini. Gracias a su ligereza su amplia compatibilidad y su bajo consumo lo hace ideal para proyectos como la creación de dispositivos de audio, proyectos roboticos o de educación.

El reproductor DFPlayer Mini lo podemos encontrar en cualquier página a un precio muy económico como Aliexpress o Amazon.

Como siempre, este tipo de módulos tienen un costo bastante reducido alrededor de menos de 2€ y estas son las caracteristícas principales que vamos a encontrar el módulo:

  • Frecuencias de muestreo (kHz): 8/11.025/12/16/22.05/24/32/44.1/48.
  • Salida de 24Bits con soporte para rango dinámico 90dB, SNR apoyo 85dB.
  • Soporta microSD en FAT16, FAT32, y tarjetas de 32GB norflash.
  • Modos de control I/O , Serial, AD.
  • Amplificador incorporado para conectarlo directamente a un altavoz.
  • Modulo de decodificación para los formatos MP3, WAV y WMA
  • Soporta hasta 100 carpetas y cada carpeta puede contener hasta 255 canciones.
  • Sonido ajustable en 30 niveles.
  • 6 niveles de Ecualización.
  • Amplificador de 3W.

Los pines del módulo DFPlayer Mini vienen distribuidos de la siguiente manera:

jueves, 22 de diciembre de 2016

Actualizar el Firmware del ESP8266 con Arduino Nano

Y Felices Fiestas a todos!!!

Ayer tuve un pequeño problema cuando estaba programando un menú configurador para hacer más sencilla la manera de configurar el ESP8266.

Estaba con el menú del Baudrate cuando me equivoque al meter un baudrate que no era valido con los comandos AT y el ESP8266 dejo de funcionar.

Tengo varios módulos más, pero ya que estaba en faena me decidí a solucionarlo en el momento...

Eso pensé en un principio, pero no fue tan sencillo unir las piezas, me explico:

Ante la imposibilidad de comunicarme con él, la solución era evidente, tenia que volver a cargar el firmware del ESP8266.

Buscando información sobre como actualizar el firmware, casi todo lo que encontré era referido al adaptador de FTDI a USB. Hasta que, investigando, en alguna parte leí que uno de esos adaptadores utiliza el chip CH340 y esto me hizo recordar que este es el mismo driver que utiliza en la comunicación serial el Arduino Nano.

Una vez recopilada toda la información este es el circuito no podía ser más sencillo:

Una vez montado solo hay que subir el siguiente Sketch:

lunes, 26 de septiembre de 2016

Arduino: Pantalla TFT de 3.5" primeros pasos

Muy buenas a todos los Arduineros y Arduineras

Ya estamos de vuelta del verano!! Ya hace un tiempo que he adquirido una pantalla TFT. Es una pantalla que puedes encontrar fácilmente en Ebay y a la cual se le puede sacar mucho jugo. Lo único malo es que no dispone de panel táctil aunque si adaptador de tarjeta microSD. Tiene una resolución de 480x320.

Especificaciones técnicas:

  • Dimensiones: 3.5"
  • Controlador: ILI9481 o ILI9488 driver
  • Resolución: 480x320
  • Data bits: 8 - 16
  • Número de pines de la interfaz: 8 pin
  • Lector de tarjetas: Si, microSD

lunes, 21 de marzo de 2016

Arduino: leer códigos de mando a distancia (Read remote control)

Buenas a todos Arduineros y Arduineras!!!

Hace un tiempo que quería hacer este ejemplo ya que considero que puede tener muchas posibilidades. Aunque en este ejemplo solo vamos a leer los códigos de un mando a distancia, lo bueno es que puede ser casi cualquier mando a distancia tanto de TV, DVD, etc. Con esto ¿qué podemos hacer? Podemos, por ejemplo, encender luces conectadas a relés, subir y bajar unas persianas, abrir una puerta... en fin todo lo que se os pueda ocurrir.


Librería IRremote

Para realizar este ejemoplo solo vamos a necesitar la librería llamada IRremote.h

AVISO: esta librería me ha dado problemas ya que se supone que ya viene incluida en el IDE de Arduino, pero no se por que no funciono, leyendo en foros descubrí que la mejor solución es reinstalar la librería.

Para esto lo primero que tenemos que hacer es eliminar estos archivos que están alojados en las rutas:
libraries\RobotIRremote\IRremoteTools.cpp
y
libraries\RobotIRremote\IRremoteTools.h

Estos archivos están alojados en la carpeta de librerías de Arduino IDE que no es la misma que la carpeta donde se alojan las librerías que cargamos nosotros al añadir una librería comunes.

vs1838B

Dicho esto, solo nos queda conectar el receptor de infrarrojos en Arduino y comenzar a recibir datos de nuestro mando. Para conectarlo hay que mirar que tipo de IR tenemos, en nuestro caso es el VS1838B y la numeración de sus pines es:

  • 1 - OUT
  • 2 - GND
  • 3 - VSS (+5v)
Arduino_Lector_IR

A la hora de crear el ejemplo en Fritzing solo me deja este tipo de sensor IR que en lo único que se diferencia es en la posición de las conexiones.

Una vez tenemos esto abrimos el IDE de Arduino y empezamos con este sencillo programa:


#include "IRremote.h"

// Declarar Constantes
const int receiverPin = 11; 

// Declarar objetos
IRrecv irrecv(receiverPin);  // Creamos una instancia para 'irrecv'
decode_results results;   // Creamos una instancia para 'decode_results'


void setup()
{
  Serial.begin(115200);
  Serial.println(F("Lector de infrarojos Infotronikblog"));
  
  // Activar el receptor
  irrecv.enableIRIn(); 
}

// Función principal 
void loop()
{
  // Cuando recibe una señal IR
  if (irrecv.decode(&results))
  {
    // Imprime el código de cada botón
    Serial.println(results.value, HEX);
  
    // Recibe el siguiente valor
    irrecv.resume();
    
    delay(100);
  }
}


Salida del monitor serial con el IDE de Arduino

Como se puede observar en la salida del monitor serial tendremos un código diferente para cada tecla del control remoto.

Otros articulos relacionados que te pueden interesar:

Saludos!!!

lunes, 20 de abril de 2015

Arduino: Tema Super Mario Bros sonando en nuestro Arduino

Hola a todos los Arduineros y Arduineras!!!

Desde hace ya un tiempo que no ponía nada en el blog y hoy me he encontrado con un post sobre como reproducir el tema del Super Mario Bros, clásico juego de la mítica Nintendo, en nuestra placa Arduino.

Es bastante sencillo ya que solo necesitaremos un pequeño buzzer o altavoz que conectaremos en el pin 3 de nuestro Arduino en serie con una resistencia de 1K y listo. Es un montaje realmente sencillo de construir

Aquí os dejo una imagen de las conexiones de Arduino y el altavoz:

Así de sencillo y ahora el código que necesitamos para darle ritmo a nuestro Arduino:


/*
Arduino Mario Bros Tunes
  With Piezo Buzzer and PWM
 
  Connect the positive side of the Buzzer to pin 3,
  then the negative side to a 1k ohm resistor. Connect
  the other side of the 1 k ohm resistor to
  ground(GND) pin on the Arduino.
 
  by: Dipto Pratyaksa
  last updated: 31/3/13
*/
 
/*************************************************
 * Public Constants
 *************************************************/
 
#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978
 
#define melodyPin 3
//Mario main theme melody
int melody[] = {
  NOTE_E7, NOTE_E7, 0, NOTE_E7,
  0, NOTE_C7, NOTE_E7, 0,
  NOTE_G7, 0, 0,  0,
  NOTE_G6, 0, 0, 0,
 
  NOTE_C7, 0, 0, NOTE_G6,
  0, 0, NOTE_E6, 0,
  0, NOTE_A6, 0, NOTE_B6,
  0, NOTE_AS6, NOTE_A6, 0,
 
  NOTE_G6, NOTE_E7, NOTE_G7,
  NOTE_A7, 0, NOTE_F7, NOTE_G7,
  0, NOTE_E7, 0, NOTE_C7,
  NOTE_D7, NOTE_B6, 0, 0,
 
  NOTE_C7, 0, 0, NOTE_G6,
  0, 0, NOTE_E6, 0,
  0, NOTE_A6, 0, NOTE_B6,
  0, NOTE_AS6, NOTE_A6, 0,
 
  NOTE_G6, NOTE_E7, NOTE_G7,
  NOTE_A7, 0, NOTE_F7, NOTE_G7,
  0, NOTE_E7, 0, NOTE_C7,
  NOTE_D7, NOTE_B6, 0, 0
};
//Mario main them tempo
int tempo[] = {
  12, 12, 12, 12,
  12, 12, 12, 12,
  12, 12, 12, 12,
  12, 12, 12, 12,
 
  12, 12, 12, 12,
  12, 12, 12, 12,
  12, 12, 12, 12,
  12, 12, 12, 12,
 
  9, 9, 9,
  12, 12, 12, 12,
  12, 12, 12, 12,
  12, 12, 12, 12,
 
  12, 12, 12, 12,
  12, 12, 12, 12,
  12, 12, 12, 12,
  12, 12, 12, 12,
 
  9, 9, 9,
  12, 12, 12, 12,
  12, 12, 12, 12,
  12, 12, 12, 12,
};
	/ /Underworld melody
int underworld_melody[] = {
  NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,
  NOTE_AS3, NOTE_AS4, 0,
  0,
  NOTE_C4, NOTE_C5, NOTE_A3, NOTE_A4,
  NOTE_AS3, NOTE_AS4, 0,
  0,
  NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4,
  NOTE_DS3, NOTE_DS4, 0,
  0,
  NOTE_F3, NOTE_F4, NOTE_D3, NOTE_D4,
  NOTE_DS3, NOTE_DS4, 0,
  0, NOTE_DS4, NOTE_CS4, NOTE_D4,
  NOTE_CS4, NOTE_DS4,
  NOTE_DS4, NOTE_GS3,
  NOTE_G3, NOTE_CS4,
  NOTE_C4, NOTE_FS4, NOTE_F4, NOTE_E3, NOTE_AS4, NOTE_A4,
  NOTE_GS4, NOTE_DS4, NOTE_B3,
  NOTE_AS3, NOTE_A3, NOTE_GS3,
  0, 0, 0
};
//	Underwolrd tempo
int underworld_tempo[] = {
  12, 12, 12, 12,
  12, 12, 6,
  3,
  12, 12, 12, 12,
  12, 12, 6,
  3,
  12, 12, 12, 12,
  12, 12, 6,
  3,
  12, 12, 12, 12,
  12, 12, 6,
  6, 18, 18, 18,
  6, 6,
  6, 6,
  6, 6,
  18, 18, 18, 18, 18, 18,
  10, 10, 10,
  10, 10, 10,
  3, 3, 3
};
 
void setup(void)
{
  pinMode(3, OUTPUT);	// Buzzer
  pinMode(13, OUTPUT);	// Led indicator when singing a note
 
}
void loop()
{
  // Sing the tunes
  sing(1);
  sing(1);
  sing(2);
}
int song = 0;
 
void sing(int s) {
  // Iterate over the notes of the melody:
  song = s;
  if (song == 2) {
    Serial.println(" 'Underworld Theme'");
    int size = sizeof(underworld_melody) / sizeof(int);
    for (int thisNote = 0; thisNote < size; thisNote++) {
 
      // To calculate the note duration, take one second
      // divided by the note type.
      // e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 1000 / underworld_tempo[thisNote];
 
      buzz(melodyPin, underworld_melody[thisNote], noteDuration);
 
      // To distinguish the notes, set a minimum time between them.
      // the note's duration + 30% seems to work well:
      int pauseBetweenNotes = noteDuration * 1.30;
      delay(pauseBetweenNotes);
 
      // Stop the tone playing:
      buzz(melodyPin, 0, noteDuration);
 
    }
 
  } else {
 
    Serial.println(" 'Mario Theme'");
    int size = sizeof(melody) / sizeof(int);
    for (int thisNote = 0; thisNote < size; thisNote++) {
 
      // To calculate the note duration, take one second
      // divided by the note type.
      // e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
      int noteDuration = 1000 / tempo[thisNote];
 
      buzz(melodyPin, melody[thisNote], noteDuration);
 
      // To distinguish the notes, set a minimum time between them.
      // the note's duration + 30% seems to work well:
      int pauseBetweenNotes = noteDuration * 1.30;
      delay(pauseBetweenNotes);
 
      // Stop the tone playing:
      buzz(melodyPin, 0, noteDuration);
 
    }
  }
}
 
void buzz(int targetPin, long frequency, long length) {
  digitalWrite(13, HIGH);
  long delayValue = 1000000 / frequency / 2; 	// Calculate the delay value between transitions
  //// 1 second's worth of microseconds, divided by the frequency, then split in half since
  //// there are two phases to each cycle
  long numCycles = frequency * length / 1000; 	// Calculate the number of cycles for proper timing
  //// multiply frequency, which is really cycles per second, by the number of seconds to
  //// get the total number of cycles to produce
  for (long i = 0; i < numCycles; i++) { 	// for the calculated length of time...
    digitalWrite(targetPin, HIGH); 	// write the buzzer pin high to push out the diaphram
    delayMicroseconds(delayValue); 	// wait for the calculated delay value
    digitalWrite(targetPin, LOW); 	// write the buzzer pin low to pull back the diaphram
    delayMicroseconds(delayValue); 	// wait again or the calculated delay value
  }
  digitalWrite(13, LOW);
}

Este código lo encontré en la siguiente web www.princetronics.com/supermariothemesong/ pero como friki que soy me ha parecido bueno para probar como sonaría un buzzer sin hacer el típico programa de beep o notas musicales.

Es un ejemplo que hara las delicias de grandes y pequeños, ¡Anímate a construirlo!

Un saludo a todos y todas!!!

lunes, 16 de febrero de 2015

Arduino: Brazo robot con servos ( Robot arm )

Muy buenas a todos Arduineros y Arduineras!!!

Infotronikblog tiene ahora su propio brazo robot. En total 3 ejes más pinza, aunque es el modelo básico, el modelo completo tiene 4 ejes más pinza. Puedes descargar el modelo en Thingiverse.

Este diseño es más que suficiente para enseñar como funciona un brazo robot y las 3 posiciones espaciales (X Y Z) en las que se moverá el brazo. Los ejes de referencia son:

  • Eje X: Es el movimiento de izquierda a derecha.
  • Eje Y: Es el movimiento de arriba o abajo.
  • Eje Z: Es el movimiento de avance o retroceso.

Ahora que ya sabemos por donde nos movemos, estos son los componentes que moverán los ejes que componen el brazo:

  • Arduino UNO o NANO.
  • 4 servos de tipo 9g.
  • 4 pulsadores.
  • 1 potenciómetro.

La parte blanca esta impresa en ABS y la parte azul es PLA, ya que es de las primeras cosas impresas y querían probar los diferentes materiales. Después de montarlo, creo que es mejor el PLA, ya que es mas rígido.

Los movimientos corren a cargo de 4 servos de 9g que van conectados a los pines 2, 3, 4, 5 de Arduino. Para la primera prueba (solo la pinza) utilice dos pulsadores, uno para abrir y otro para cerrar muy parecido al segundo ejemplo del articulo "Arduino moviendo un servo".


Para la segunda prueba (bazo completo) utilice cuatro pulsadores conectados a los pines 6, 7, 8, 9 asignado a cada uno de los servos y un potenciómetro en el pin A0 para darle movimiento. De tal manera que si pulsamos uno de los botones mientras movemos el potenciómetro accionaremos el servo asignado a ese pulsador.



Pulsando el botón y moviendo el potenciómetro podemos mover el brazo en cualquiera de sus ejes.


Si bien el sistema no es del todo perfecto, ya que si no movemos el potenciómetro antes de accionar el pulsador el servo adquiere la posición del ultimo movimiento. Pero es más que suficiente para este ejemplo.

Una mejora puede ser también implementar la memoria EPROOM para almacenar los movimientos en determinadas posiciones y para después reproducirlos en secuencia haciendo así una tarea repetitiva.

Aquí tenéis un vídeo para que veáis un poco mejor como funciona:


Y aquí el código que hace que funcione:


#include <servo.h>

#define POT A0
#define SWITCH1 2
#define SWITCH2 3
#define SWITCH3 4
#define SWITCH4 5
#define SERVO1 6
#define SERVO2 7
#define SERVO3 8
#define SERVO4 9


int posServo1 = 90; // Angulo servo 1 (base)
int posServo2 = 90; // Angulo servo 1 (antebrazo)
int posServo3 = 90; // Angulo servo 1 (brazo)
int posServo4 = 90; // Angulo servo 1 (pinza)


void setup() 
{ 
  Serial.begin(115200);

  servo.attach(sp1);
  pinMode(SWITCH1, INPUT_PULLUP);
  pinMode(SWITCH2, INPUT_PULLUP);
  pinMode(SWITCH3, INPUT_PULLUP);
  pinMode(SWITCH4, INPUT_PULLUP);
  
}

void loop() 
{
  
  // Show the value of the buttons on the serial monitor
  Serial.print("b1=");
  Serial.println(digitalRead(b1));
  Serial.print("b2=");
  Serial.println(digitalRead(b2));

  int potValue = analogRead(POT)
  int position = map(potValue, 0, 1023, 0, 180);
  
  
  if (digitalRead(SWITCH1) == HIGH)  servo1.write(position);
  else if (digitalRead(SWITCH1) == HIGH)  servo1.write(position);
  else if(digitalRead(SWITCH1) == HIGH)  servo1.write(position);
  else (digitalRead(SWITCH1) == HIGH)  servo1.write(position);

}

Saludos a todos!!

viernes, 6 de febrero de 2015

Arduino: moviendo un servo

Buenas Arduineros y Arduineras!!

Después de ver como funcionan los leds, pulsadores y pantallas LCD, ahora le toca el turno practicar con dispositivos de salida como son los servos.


¿Que es un servo?

Un servo o servomotor es un dispositivo muy similar a un motor de corriente continua con la peculiaridad de poder posicionar su eje una posición determinada dentro de un rango de aproximadamente unos 180º. Se puede modificar tanto su posición como velocidad.

Servo 9G

Arduino tiene una biblioteca para este tipo de dispositivos llamada servo.h. Con ella podemos controlar cualquier servo de manera independiente.

Algo a tener en cuenta es que dependiendo del tipo de servo y de la cantidad de los mismos, seguramente no podrás alimentarlo desde la misma placa de Arduino.

Para este ejemplo y dado que el servo a utilizar es de los más pequeños, no habrá problema ninguno en conectarlo directamente a la placa Arduino.


¿Como trabaja un servo?

Los servos utilizan la modulación por ancho de pulsos (PWM) para controlar tanto la dirección como la posición del motor de de corriente continua.

La mayoría de los servos trabajan a una frecuencia de 50Hz con la señal PWM de un periodo de 20 milisegundos.

La electrónica incorporada en estos dispositivos responde al ancho de la señal modulada.


La señal PWM

Si recibe una señal de entre 0,5 a 1,4 milisegundos, el servo se moverá en sentido horario.


                _      _     _          _    _    _
               | |    | |   | |        | |  | |  | |
               | |    | |   | |        | |  | |  | |
      _________| |____| |___| |________| |__| |__| |___________

Si la señal es de 1,6 a 2 milisegundos el giro sera antihorario:


                ______      ______     ______     ______    ______
               |      |    |      |   |      |   |      |  |      |
               |      |    |      |   |      |   |      |  |      |
      _________|      |____|      |___|      |___|      |__|      |____

Y si la señal recibida es de 1,5 milisegundos su estado sera neutro:


                 ___      ___     ___     ___    ___    ___
                |   |    |   |   |   |   |   |  |   |  |   |
                |   |    |   |   |   |   |   |  |   |  |   |
       _________|   |____|   |___|   |___|   |__|   |__|   |_____

📚La blioteca servo.h:

La biblioteca Servo.h es una librería estándar incluida en el IDE de Arduino que permite controlar servomotores de forma sencilla. Gestiona la generación de señales PWM necesarias para posicionar servomotores estándar de 0° a 180°.

  • Compatibilidad: Funciona en todas las placas Arduino (Uno, Nano, Mega, etc.).

  • Límites: Controla hasta 12 servos en Arduino Uno/Nano (24 en Mega).

  • Precisión: Usa temporizadores internos (Timer1 en Uno) para generar señales estables.

  • Voltaje: Recomendado 5V (igual que la lógica del servo).

  • Documentación: Es oficial desde Arduino Reference - Servo Library

⚙️Funciones principales:

  • attach(): Fija el pin digital donde estará conectado el servo

  • writer():Escribe un valor en el servo, controlando su eje en consecuencia.
    Su valor esta dado en grados de 0 a 180. En un servo de rotación continua cambiara la velocidad del servo, siendo 0 toda la velocidad en una dirección y 180 en otra dirección y un valor de 90 aproximadamente sin movimiento.

  • writeMicroseconds(): Escribe un valor en microsegundos (uS) en el servo controlando su eje en consecuencia.
    En un servo estándar si el valor del parámetro es 1000 el eje girará completamente a la izquierda, con un valor de 2000 es completamente a la derecha y con un valor de 1500 se sitúa en el centro.
    Según el fabricante estos valores pueden variar, normalmente entre 700 y 2300.
    Se puede comprobar pero hay que tener en cuenta que llegar al limite puede producir daños en el servo.
    Normalmente lo adivinaras por por el ruido infernal que hará el servo.
    NO ES RECOMENDABLE pasar de esos parámetros ya que pueden producir daños en el servo.
    Para los servos de rotación continua writeMicroseconds() funciona de una manera análoga a write().

  • read(): Lee el angulo actual del servo (el ultimo valor pasado por la llamada write().

  • attached(): Comprueba si la variable servo esta unida a un pin.

  • detach(): Separa la variable servo de un pin. Si se separan todas las variables de servo, los pines 9 y 10 pueden utilizarse como PWM mediante analogWrite().

Programación:

Primer programa para un servo, mover el servo de manera simple:



#include "servo.h" 	// Cargamos la biblioteca "Servo.h"
 
int Pin = 9;		// Cargamos un 9 en la variable "Pin"
 
Servo servo1;		// Nombramos al primer servo
  
// Configuración
void setup()
{        
  servo1.attach(Pin);   // Adjuntamos el pin 9 a servo1
} 
 
//Programa principal
void loop()             
{                                 
    servo1.write(0);     // Mandamos a servo1 a la posición 0 grados      
    delay(1500);         // Hace una pausa de 1,5 segundos
    servo1.write(90);    // Mandamos a servo1 a la posición 90 grados       
    delay(1500);         // Hace una pausa de 1,5 segundos
    servo1.write(180);   // Mandamos a servo1 a la posición 180 grados        
    delay(1500);         // Hace una pausa de 1,5 segundos
    servo1.write(90);    // Mandamos a servo1 a la posición 900 grados       
    delay(1500);         // Hace una pausa de 1,5 segundos
}


Segundo programa para un servo, mover el servo con pulsadores:



#include "servo.h"

int servovar1=90;   // Indicamos la posicion inicial de servo1
Servo servo1;       // Nombramos al primer servo

int Pulsador1=6;   // Cargamos un 6 en la variable "pulsador1"
int Pulsador2=7;   // Cargamos un 7 en la variable "pulsador2"

void setup() {
  servo1.attach(9);    // Adjuntamos el pin 9 a servo1
  pinMode(Pulsador1, INPUT);  // Pulsador 1 en pin 6 es una entrada
  pinMode(Pulsador2, INPUT);  // Pulsador 2 en pin 7 es una entrada
}

void loop() {
    if(digitalRead(Pulsador1) == HIGH && digitalRead(Pulsador2) == LOW){  
      servovar1++;		// Presionamos el pulsador1 para que vaya a la izquierda
}
    else if(digitalRead(Pulsador1) == LOW && digitalRead(Pulsador2) == HIGH){  
      servovar1--;	// Presionamos el pulsador2 para que vaya a la derecha
    }
  
  servo1.write(servovar1);
  delay(10);	// Pausa de 10 milisegundos (Para más velocidad 
  				// quitar esta linea y para ir más lento aumentar el valor)
}


Un vídeo del servo con Arduino funcionando:


Ahora que ya sabes como funcionan los servos con Arduino, aquí tienes algunos artículos aplicando este código:

Moviendo desvíos con servos y Arduino

Arduino: Brazo robot con servos ( Robot arm )

Arduino: Brazo robot con servos ( Robot arm ) Parte 2

Saludos!!!

viernes, 16 de enero de 2015

Arduino: El LCD 16x2

Después de ver como funcionan los pulsadores le toca el turno a las parntallas de tipo LCD.

El LCD (Liquid Crystal Display por sus siglas en ingles) es una pantalla delgada y plana formada por pixeles.

Una de las mejores cualidades de este tipo de pantallas es su bajo consumo, pero también podemos destacar su facilidad de uso, su gran disponibilidad y fiabilidad

Este tipo de pantallas se utilizan en gran variedad de aparatos electrónicos dada su simplicidad tanto en conexiones como en su utilización. En ella se pueden reflejar desde un simple texto tipo "hello World", coordenadas GPS o cualquier tipo de variable que quepa en sus 16 caracteres.

También las hay de diferentes tipos y medidas como LCDs gráficas o LCDs a color, de 16x2 caracteres, 20x4 o incluso más.

En este ejemplo en particular usaremos la típica pantalla LCD de 16x2 caracteres.

Primero hablemos sobre sus pines y cuales son sus conexiones:

  • VSS o GND: Este pin del LCD es el pin conectado a masa (-)

  • VDD: Este pin es la alimentación del LCD y se conecta a +5V

  • Vo: Es el pin del contraste, este pin no esta siempre presente, pero si tu LCD lo tuviera, hay que conectarlo a un potenciómetro para poder regular el contraste, si lo conectas directamente a GND la pantalla no se vera correctamente.

  • RS: Es el pin de selección de registros que controla en que parte de la memoria del LCD esta escribiendo los datos.

  • R/W: Modo de lectura o escritura. Este pin va conectado normalmente a masa (GND)

  • E: Este pin habilita los registros. (Enable)

  • DB0...DB7: Son los 8 pines de datos.

  • A: Ánodo del LED de iluminación del LCD (+)

  • K: Cátodo del LED de iluminacion del LCD (-)

Su conexión con Arduino seria la siguiente:

Para facilitar el uso del LCD Arduino tiene una libreria llamada "LiquidCrystal.h" que hará mucho más fácil la comunicación entre el Arduino y la pantalla LCD.

Dentro de esta librería están las siguientes funciones:

lunes, 12 de enero de 2015

Arduino: Usando pulsadores

Como hemos visto hasta ahora, solo hemos encendido y apagado leds sin tener nosotros ningún control sobre cuando encienden o cuando apagan.

Esta vez vamos a ver como interactuar con Arduino mediante pulsadores.

Arduino interpreta estas entradas digitales TTL como 1 lógico = 5v HIGH o con un 0 lógico = 0v LOW.

¿Como interpreta Arduino un pulsador?

Cuando Arduino recibe un 1 quiere decir que en esa entrada están llegando una señal de +5v, si conectamos una resistencia a +5v en serie con un pulsador conectado a GND e intercalamos el pin correspondiente de Arduino, siempre estará en un estado alto HIGH. Al presionar el pulsador, ese voltaje pasa a GND y Arduino recibe un 0 (LOW). A esto le llamamos una resistencia PULL-UP, figura 1 de la foto.



martes, 18 de noviembre de 2014

Decoder NCE D13SR como conectar leds

Muy buenas a todos los amantes del DCC!!!

Junto con la central digital Prodigy Express adquirí también unos decodificadores de la marca NCE, el NCE D13SR con 4 funciones.

No incluyen conector NEM 652 (de 8 pin) así que vienen los cables para hacer nosotros la conexión.

Hay varias opciones, podemos compramos el conector o lo podemos fabricar nosotros mismos (hay algunas webs con varias ideas al respecto) y por último la opción más segura, soldar los cables directamente a todos los componentes motor, iluminación, etc.

Por otra parte si las luces están en la carcasa, fabricar un conector será más cómodo a la hora de manipular la locomotora en futuras reparaciones.

En mi caso he optado por soldarlos directamente siguiendo el esquema que proporciona el mismo vendedor:




Estos son los colores de los cables y los componentes que se van soldadar:

miércoles, 28 de mayo de 2014

Unidad Descarga por Condensador (CDU) para varios desvíos

Muy buenas a todos!!!

Después de un parón en el blog y en la maqueta, vuelvo para contaros como hacer para conectar varios desvíos a un solo circuito para desvíos.

Es una ampliación del mismo circuito que vimos anteriormente, al que se le han añadido unas pequeñas modificaciones con la que podremos conectar varios desvíos con un solo circuito.

El aparato que vamos a fabricar se llama CDU (Capacitor Discharge Unit) y como ya explique en la otra entrada relacionada con las bobinas utilizamos la carga almacenada en el condensador para mover las bobinas.

Ahora que ya no tengo maqueta y me he pasado a los módulos, sobre todo por el tema de espacio y de movilidad. Los hay de varias medidas, pero en mi caso me he decidido por la medida más pequeña de 920x400mm como se explica en la normativa maquetren que podéis descargar aquí.

Bien, he hecho algunas modificaciones, los condensadores han pasado de 1000uF a 2200uf
y como tardaba un poco en cargar los condensadores he bajado las resistencias, de 1K a 330ohms, los diodos D1 y D2 también los he cambiado de 1N4007 a 1N4148. Los demás diodos los he dejado como estaban.

Otro cambio que aún no tengo muy claro es cambiar los interruptores por pulsadores, creo que sería más seguro ya que solo conduciría al pulsar.

Una de las ventajas por las que me he decidido por este circuito es, además de su simplicidad, porque desde el pupitre hasta el desvío utilizamos solo dos cables, lo cual simplifica el cableado.

En el caso de querer hacer otro pupitre para controlar los desvíos en otro modulo solo tendría que llevar tres cables.

Os dejo una foto para que la veáis la unidad CDU ya instalada en el módulo:

Espero que estos circuitos y diagramas os sean de utilidad.

** Al final he puesto pulsadores y no ha habido ningún problema

Fuente: Mimaquetaz.blogspot.com;

www.escalan.es

miércoles, 13 de noviembre de 2013

Paso a nivel controlado por sensores de infrarrojos a 38Khz para maqueta ferroviaria

Muy buenas a todos y todas!!


Primero vimos como hacer un paso a nivel con un 555, un generador de 38Khz con 555 y los receptores infrarrojos de 38Khz, ahora toca unir todos los elementos y hacer un paso a nivel controlado por sensores de infrarrojos.

La teoría es sencilla, cuando el tren pasa, corta la barrera infrarroja y hace que encienda el 555 del paso a nivel.

No la alimenta directamente, si no que el sensor hace pasar la corriente hacia un condensador de 220uF conectado a una resistencia de 33Kohm. La resistencia activa la base del transistor BC547.

Con esto conseguiremos un retardo de unos 10 seg en este tiempo al tren le dará tiempo de sobra para poder pasar por el siguiente detector.


Esquema de las conexiones:

Conexión de los sensores infrarrojos


Receptor camuflado



 
Emisor infrarrojo


Una vez que esta todo montado, solo queda camuflar los receptores y los transmisores puedes ponerlos dentro de alguna edificación que no se vea mucho, pero siempre en linea el uno con el otro como se puede ver en la siguiente foto:


Linea de visión del Receptor - Emisor


Después de probar varios sistemas de infrarrojos, he de decir que este ha sido el que más me ha gustado. Con los demás que tengo instalados siempre he tenido problemas con la luz ambiente, pero con este sistema no me ha dado ningún problema. Así que ahora toca cambiar los demás receptores y tirar una linea para los emisores por toda la maqueta.




Un Saludo a todos!!!




lunes, 11 de noviembre de 2013

Receptor infrarrojo 38Khz modelismo ferroviario

Muy Buenas a todos los fanáticos de los trenes!!!

En esta entrada voy a tratar los sensores infrarrojos de 38Khz. En la entrada anterior trate hice un generador de frecuencia de 38Khz con el integrado 555, y lo hice con la idea de utilizar este tipo de sensores para cambiarlos por otros que ya tengo puestos en la maqueta.

Las ventajas que tiene este sistema frente a los sensores simples de infrarrojos, son la distancia y que no les afecta la luz ambiente. Los podemos encontrar en cualquier televisión, aire acondicionado o casi cualquier aparato que funcione con infrarrojos y tenga mando a distancia.

Como punto fuerte destacaría el que no les afecta la luz ambiente, ya que en mi caso es lo que más problemas me ha dado, por ejemplo puse 4 CNY70 para hacer el gestor de bucles, y al estar puestos con el receptor hacia arriba, cuando enciendo la luz se vuelve loco. Próximamente los cambiare por sensores a 38Khz.



Componentes necesarios:

Para el receptor de infrarrojos he utilizado solo 3 componentes:

  • Receptor IR (no tengo la descripción solo pone 338)
  • Condensador electrolítico de 4,7uF
  • Diodo 1N4148

En cuanto al diodo, al tener que poner varios receptores, (en este caso pondré 2) el diodo tiene que ser el mismo en todos los receptores, no vale poner unos con un 1N4148 y otro con un 1N4007 o QUEMAREMOS UNO DE LOS RECEPTORES. Lo digo por propia experiencia...


Y este es el resultado final al montar los receptores.

Son relativamente pequeños así que se pueden esconder en cualquier elemento decorativo así que ahora solo me queda buscar un "camuflaje" para que pase desapercibido en la maqueta.


Próximamente juntare los últimos circuitos para poder hacer un paso a nivel con sensores infrarrojos.

Saludos a todos!!!

sábado, 9 de noviembre de 2013

Generador IR 38Khz con 555

Buenas a todos los aficionados a la electrónica!!!

Harto de tener problemas con los sensores de infrarrojos, y como hace poco del trabajo conseguí un montón de receptores de IR de unos mandos de aire acondicionado.

Para hacerlos funcionar el emisor, que es de lo que trata esta entrada, tiene que trabajar a una frecuencia de 38Khz.

Esto es muy fácil de conseguir gracias con el integrado 555. Este integrado se usa para generación de temporizadores, generador de señales PWM o como comparador de voltaje.


Integrado 555 y sus salidas

La manera de transmitir es muy similar al que utilizan los mandos a distancia de los televisores.

Los componentes utilizados son los siguientes:

  • 1 x Resistencia variable de 22Kohm
  • 1 x Resistencia de 10Kohm
  • 1 x Resistencia de 4K7
  • 1 x Condensador de 0.001uF (102)
  • 1 x Condensador de 0.01uF (103)
  • 1 x Condensador electrolítico de 10uF
  • 1 x Transistor BC548 / BC547
  • X x Leds IR

Para obtener los 38Khz que necesitamos R1 que es la resistencia variable tiene que tener un valor de 18Kohm.

Lo de utilizar el transistor es para poder poner más Leds, así podre conectar varios módulos que van a utilizar este sistema, como los 2 pasos a nivel que tengo puestos y alguna cosilla más. Como me sobra alguna linea del conector que comunica una maqueta con la otra.

Y bueno este es el resultado:


Bueno ahora solo queda ponerme a trabajar en los receptores. Cuando lo tenga instalado subiré las fotos para que veáis como luce, ya que los leds de IR no son visibles a simple vista, la manera más fácil de hacerlo es con una cámara digital o la cámara de un teléfono móvil.

Saludos!!!

Revisando esta entrada he encontrado una pagina que seguramente os sera de utilidad para hacer los cálculos en modo astable en el 555 es esta: gzaloprgm.com.ar Espero que os sera de ayuda

Revisado 16/08/14

domingo, 3 de noviembre de 2013

Paso a nivel con 555

Ya he realizado antes un paso a nivel pero con transistores y condensadores. Esta vez he decidido hacerlo con un integrado 555, y la verdad estoy bastante contento con el resultado.

La web donde he encontrado el circuito se llama 555-timer-circuits.com.

Flashing railroad lights - 555-timer-circuits.com

Componentes necesarios:

  • Integrado 555
  • 1 Resistencia de 47K
  • 2 Resistencias de 220ohm
  • 1 Condensador de 10uF
  • 2 Leds rojos 3mm

En mi caso las resistencias tienen diferentes valores, pero no disponía en ese momento de todos los componentes así que utilice otros con valores muy similares.

Para los postes he utilizado unos que tenia por ahí, no se muy bien de que marca son, pero eran sin luces. Para hace las luces he utilizado led´s de 3mm

Circuito flashing lights 555 terminado
Circuito flash 555 terminado

Como se puede ver el circuito una vez terminado es bastante pequeño y puede caber en casi cualquier sitio.

Bien por esta parte tendríamos el circuito para hacer el parpadeo de los led..

Leds con hilo esmaltado
Leds con hilo esmaltado

Los leds van soldados a un hilo esmaltado muy fino que conseguí del bobinado de un electroimán y va muy bien para este tipo de usos.

El poste es del conjunto que os comente al principio, algo sencillo, aunque el color blanco no me gusta mucho, intentare pintarlo de negro dejando solo blanca la parte superior de los carteles.

Aquí puedes encontrar más proyectos con el integrado 555:

Saludos !!