ARDUINO-MÓDULOS

Venta de Aduino uno, leonardo, nano, mega.

Módulos, Controladores, sensores y accesorios.

ALARMA CON ARDUINO Y BUZZER ACTIVO

Los buzzer activos, en ocasiones denominados zumbadores, son dispositivos que generan un sonido de una frecuencia determinada y fija cuando son conectados a tensión.

Un buzzer activo incorpora un oscilador simple por lo que únicamente es necesario suministrar corriente al dispositivo para que emita sonido. En oposición, los buzzer pasivos necesitan recibir una onda de la frecuencia.

Al incorporar de forma interna la electrónica necesaria para hacer vibrar el altavoz un buzzer activo resulta muy sencillo de conectar y controlar. Además, no suponen carga para el procesador ya que no este no tiene que generar la onda eléctrica que se convertirá en sonido.

Si usamos una placa con la electrónica integrada el montaje es realmente sencillo, ya que el propio módulo incorpora los componentes necesarios para proporcionar la corriente necesaria al buzzer activo.

Por tanto, simplemente alimentamos el módulo conectando Vcc y GND a 5V y GND de Arduino, y finalmente

En ambos casos la conexión vista desde Arduino es la misma, ya que únicamente necesitamos usar una Salida digital para encender el módulo.

EJEMPLO DE CÓDIGO DE MONTAJE

El código necesario es sencillo, ya que para a controlar el buzzer únicamente necesitamos emplear una salida digital, tal y como vimos en la entrada salidas digitales

Por ejemplo, el siguiente código simplemente encendería y apagaría el diodo láser 5 segundos, dejándolo descansar 20 segundos.

const int pin = 9;
void setup() {
  pinMode(pin, OUTPUT);  //definir pin como salida
}
void loop(){
  digitalWrite(pin, HIGH);   // poner el Pin en HIGH
  delay(5000);               // esperar 5 segundos
  digitalWrite(pin, LOW);    // poner el Pin en LOW
  delay(20000);               // esperar 20 segundos
}

En el siguiente ejemplo, queremos que el buzzer se active como alarma ante un determinado evento. Supongamos que tenemos una cierta función GetSystemState() que realiza las mediciones de sensores y cálculos necesarios para determinar si la alarma tiene que ser encendida.

Simplemente realizamos la llamada a la función, y encendemos la alarma si es necesario, manteniéndola encendida un mínimo de 5 segundos.

const int pin = 9;
bool isAlarmOn = 0;     //almacena el estado de la alarma
void setup() {
  pinMode(pin, OUTPUT);  //definir pin como salida
}
bool GetSystemState()
{
    return true;  //cambiar en función del sensor usado
}
void loop(){
  isAlarmOn = GetSystemState();

  if(isAlarmOn)
  {
     digitalWrite(pin, HIGH);    // poner el Pin en HIGH
     delay(5000);               // esperar 5 segundos
  }
  else
  {
     digitalWrite(pin, LOW);    // poner el Pin en LOW
  }
  delay(1000);
}

DESCARGAS

El software de Arduino es libre descargue de manera gratuita haciendo clic

Descarga programa Arduino clic aqui

Proyectos con arduino uno Clic Aquí

EJEMPLOS DE PROYECTOS CON ARDUINO

LED INTERMITENTE

Salida en el PIN 13, correspondiente con el LED integrado,

// led intermitente WWW.ACIMASER.COM

void setup(){
pinMode (13, OUTPUT); // declaramos pin 13 como salida
}
void loop(){
digitalWrite(13, HIGH); // encendido de led
delay (1000); // esperamos 1 segundo
digitalWrite(13, LOW); // no se apaga el led
delay (1000); // esperamos 1 segundo
}

A continuación alguno de los códigos para probar a encender LED con nuestros Arduinos, y el montaje indicado. Los códigos son similares a los que hemos visto previamente en las distintas entradas del blog, pero empleando un LED externo en lugar del LED integrado en la placa. Para ello, solo tenemos que sustituir el número de PIN 13, correspondiente con el LED integrado, por el PIN de la salida a la que vamos a emplear.

Así, el primer código sirve para encender y apagar un LED,

El montaje en una protoboard quedaría de la siguiente forma.

const int ledPIN = 9;

void setup() {
  Serial.begin(9600);    //iniciar puerto serie
  pinMode(ledPIN , OUTPUT);  //definir pin como salida
}
void loop(){
  digitalWrite(ledPIN , HIGH);   // poner el Pin en HIGH
  delay(1000);                   // esperar un segundo
  digitalWrite(ledPIN , LOW);    // poner el Pin en LOW
  delay(1000);                   // esperar un segundo
}

El siguiente código emplea las salidas digitales y la comunicación por puerto serie para hacer parpadear el LED el número de veces que enviemos por el puerto serie

const int ledPIN = 9;
int option;
void setup(){
  Serial.begin(9600);
  pinMode(ledPIN , OUTPUT);
}
void loop(){
  //si existe información pendiente
  if (Serial.available()>0){
    //leeemos la opcion
    char option = Serial.read();
    //si la opcion esta entre '1' y '9'
    if (option >= '1' && option <= '9')
    {
      //restamos el valor '0' para obtener el numero enviado
      option -= '0';
      for(int i=0;i<option;i++){
         digitalWrite(ledPIN , HIGH);
         delay(100);
         digitalWrite(ledPIN , LOW);
         delay(200);
      }
    }
  }
}

Por último, el siguiente código emplea una salida PWM para hacer variar la intensidad del LED,

const int ledPIN = 9;
byte outputValue = 0;  
void setup()
{  
   Serial.begin(9600);         // Iniciar puerto serie
}
void loop()
{
   if (Serial.available()>0){   // Si hay datos disponibles
       outputValue = Serial.read();   // Leemos la opción
     outputValue -= '0';      // Restamos '0' para convertir a un número
     outputValue *= 25;      // Multiplicamos x25 para pasar a una escala 0 a 250
     analogWrite(ledPIN , outputValue);
   }

}