Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

22/01/2016 #1

Avatar de mecatrodatos

Tutorial y proyectos con Arduino
Corría el año 2005 cuando unos chicos de Italia querían crear una placa electrónica simple para alumnos, más barata y más fácil de usar que los diseños disponibles en ese momento.Y lo nombraron Arduino.
La versión inicial fue voluminosa, complicada para conectar, y carecía de USB, y otras características se encuentran comúnmente en estos días. Ahora, Arduino es famoso por su simplicidad y facilidad de uso. Los niños están construyendo proyectos con Arduino que solamente hace 10 años habría requerido de ingenieros.

Todo el diseño es de código abierto y los clones de la placa se pueden encontrar en todas partes del mundo. No hay un número conocido de placas Arduino pero es en el rango de cientos de miles o incluso más. Todo el mundo puede diseñar su propia implementación personalizada. Hoy en día, Arduino se usa en todos los rincones del planeta, e incluso ha impulsado otras revoluciones, con el código abierto el desarrollo y fabricación de impresión en 3D.

Pero, ¿Qué es Arduino?

Arduino es una placa electrónica, diseñada para conectar a la electrónica y realizar control.
Podemos escribir código para el Arduino que recibirá los datos del medio ambiente, y hacer decisiones y realizar acciones basadas en los datos. Robots, impresoras 3D, juguetes e incluso drones.

Este tutorial contiene proyectos que muestran cómo implementar los temas clave del Arduino, comenzando con la interacción básica con botones y LEDs, y escalonando a la interacción con el Sistema de Posicionamiento (GPS), hacer música, o comunicarse con Internet. Se pretende este espacio para los amantes de programación o electrónica que quieren combinar lo mejor de ambos mundos para construir proyectos interactivos y funcionales a la vanguardia con la tecnología y entorno Android.

La descarga del software de Arduino

Lo primero que necesitamos es el Arduino entorno de desarrollo integrado (IDE). Una de las mejores partes de Arduino es que el software en el que tenemos que programar las tarjetas es de código libre y abierto. El Arduino IDE es compatible con Windows, Mac OS X y Linux.

Sólo necesitamos una cosa para completar esta paso un ordenador conectado a Internet.

Cómo hacerlo…

Siga estos sencillos pasos:

1. Visite el sitio web de Arduino en http://arduino.cc/.
2. En el menú principal, vaya a la sección de descargas.
3. Seleccione su sistema operativo y descargar la última versión estable del Software de Arduino.
4. Una vez realizada la descarga, instale el software de Arduino.


NUESTRO PRIMER PROGRAMA EN ARDUINO

PREPARAR LA CONEXIÓN

En primer lugar, conectamos nuestra placa Arduino mediante un cable USB A-B, del tipo que se emplean habitualmente para conectar impresoras. Abrimos el entorno IDE de Arduino seleccionamos el modelo de placa que estemos empleando, seleccionamos el puerto de comunicación al que está conectado. Ya tenemos la conexión configurada y lista para realizar la carga de nuestro primer programa.

Fundamentos Código C - Arduino


El Arduino utiliza un lenguaje de programación C /C / ++. En este tutorial, vamos a recordar algunos conceptos básicos de C / C ++. Un buen libro de referencia para C: http://es.wikipedia.org/wiki/El_leng...amaci%C3%B3n_C.


Aquí está un ejemplo simple de básica Arduino C / C ++ manipulación de dos variables:
Código PHP:
// Variables globales
int var1 10;
int var2 20;
void setup () {
// Sólo ejecutar una vez cuando se inicia el Arduino
var2 5// Var2 se convierte en 5 una vez que las botas de Arduino
}
void loop () {
// Código ejecuta de arriba hacia abajo y repite continuamente
if (var1 var2) {// Si var1 es mayor que var2
var2 ++; // Incremento var2 por 1

else {
// Si var1 no es mayor que var2
var2 0// Var2 se convierte en 0
}

El código juega con dos variables enteras. Aquí tenemos un desglose del código para explicar mejor cada paso.

En primer lugar, declaramos de dos variables var1 y var2-y les asignamos los valores de 10 y 20 respectivamente.

Código:
// Variables globales

int var1 = 10;
int var2 = 20;
Cuando arranca el Arduino, primero asigna las variables globales en la memoria.
En la función setup (), cambiamos el valor de var2 a 5:

Código:
void setup () {
// Sólo ejecutar una vez cuando se inicia el Arduino
var2 = 5; // Var2 se convierte en 5 una vez que las botas de Arduino
}
Después Arduino asigna las variables globales, ejecuta el código dentro de la función setup () una vez.
Después de esto, la función loop () se ejecutará en varias ocasiones.
En el interior, tenemos una condición que jugará con los valores de var2.
Si var1 es mayor que var2, aumentamos var2 por uno.
Finalmente, var1 no será mayor que var2, y luego establece var2 a 0.
Esto dará lugar a la adición de un infinito e igualando de var2.
Este es un ejemplo de cómo el Arduino ejecuta el código en sus dos funciones principales.
22/01/2016 #2

Avatar de Juan Tamarit

Muy bien explicado. Aunque tengo la siguiente consulta:

¿Cuál es el sentido de asignar 20 a var2 en el comienzo del programa si luego va a ser reasignada a 5 en la función "setup"?

¿No resulta innecesario y podría solo declararse var1 al principio y que var2 se declare en el "setup"?

Es decir: al declarar o modificar una variable en el setup ¿no permanece ésta registrada en el programa? ¿Es necesario declararla antes y, de ser así, es necesario declararle algún valor?

Muchas gracias por tu post
23/01/2016 #3

Avatar de TRILO-BYTE

es como hacer esto

unsigned char numero=10;

void main()
{
numero =0;
}

¿que hise?

nada solo me comi unas instrucciones en la ROM jaja

es un error que muchos cometen a la hora de programar.
24/01/2016 #4

Avatar de J2C

.



Pues todo muy lindo, pero nos estamos yendo en palabras y apreciaciones personales y solo el ejemplo inicial que subio Mecatrodatos.

A mi entender lo mejor seria subir mas ejemplos aunque no funcionen y en "forma colaborativa" tratar de ir salvando los problemas para que el mismo sea 100% funcional.




Recuerdo haberlo leído apenas lo subio y recomendado que lo colocaran en este F47 cosa que se encargo de realizar D@rkbytes y borro mi comentario totalmente Off Topic .




Saludos, JuanKa.-
24/01/2016 #5

Avatar de mecatrodatos

Fundamentos Código - pines de Arduino

La característica más importante de la Arduino es su control sobre la entrada / salida digital (I / O) de sus pines.

En cada pin, podemos establecer un valor de tensión de 5 V, lo que representa lógica ALTA, o 0 V, lo que representa lógico bajo. También, podemos leer si un valor de 5 V o 0 V se aplica externamente.

Aquí vamos a aprender cómo.


Para esta práctica, asegúrese de que tiene el Arduino IDE ejecutado en un ordenador.

Cómo hacerlo…

El siguiente código convierte un pin en Alto y Bajo lógico en repetidas ocasiones durante la lectura de la tensión externa aplicado a otro:

Código:
void setup() {
// Establecer el pin 2 como salida digital
pinMode(2, OUTPUT);
// Establecer el pin 3 como entrada digital
pinMode(3, INPUT);
}
void loop(){
//Establecer  pin 2 en Alto logico
digitalWrite(2, HIGH);
// Espera 100 milisegundos
delay(100);
// Establecer  pin 2 en Bajo logico
digitalWrite(2, LOW);
// Espera 100 milisegundos
delay(100);
// Leer el valor del pin 3 y almacenarlo en una variable
int pinValue = digitalRead(3);
}
Cómo funciona…

El código establece la configuración de dos pines y el modo de entrada de ellos.

Aquí está el desglose del código:

En setup (), se utiliza la función pinMode () para establecer pin número 2 como una salida. Cuando nosotros configurar un pin como salida, podemos establecer que el pin ya sea como Alto (5 V) o bajo (0 V). Adicional, hemos establecido el pin número 3 como entrada. Un pin configurado como entrada puede leer tensiones externas aplicadas a la misma. El pin puede leer ALTO si la tensión es de alrededor de 5 V y BAJO si la tensión está cerca o igual a 0 V:

void setup () {
// Establecer el pin 2 como salida digital
pinMode (2, OUTPUT);
// Establecer el pin 3 como entrada digital
pinMode (3, INPUT);
}
En la función loop (), se utiliza la función digitalWrite () para establecer el pin número 2 en ALTO. Entonces, esperamos a 100 milisegundos mediante la función delay (). Esta función detiene la ejecución del código durante el tiempo especificado, en milisegundos. Después de eso, establece el pin en BAJO y espera otros 100 milisegundos. Al final, se lee el valor del pin 3 en una variable:

Código:
void loop () {
// Establecer pin 2 ALTO
digitalWrite (2, HIGH);
// Espera 100 milisegundos
delay (100);
// Establecer el pin 2 BAJO
digitalWrite (2, LOW);
// Espera 100 milisegundos
delay(100);
// Leer el valor del pin 3 y almacenarlo en una variable
int pinValue = digitalRead (3);
}
25/01/2016 #6

Avatar de mecatrodatos

Uso de Arduino

Problema:
¿Quieres empezar con un proyecto que es fácil de construir y divertido de usar.

Solución:
Este proyecto ofrece una muestra de algunas de las técnicas que se tratan en detalle en las secciones del tutorial.

El circuito se basa en el código intermitente LED de la anterior entrada, pero en vez de estar utilizando un retardo fijo, la tasa se determina por un sensor sensible a la luz llamado LDR .

Código:
const int ledPin = 13; // Asigna LED a pin digital 13
const int sensorPin = 0; // connectar sensor a entrada analogico pin  0
void setup()
{
pinMode(ledPin, OUTPUT); // Habilitar salida pin LED
}
void loop()
{
int rate = analogRead(sensorPin); // leer entrada analogica
digitalWrite(ledPin, HIGH); //  LED on
delay(rate); // Esperar duración dependiendo del nivel de luz
digitalWrite(ledPin, LOW); //  LED off
delay(rate);
}
Explicación:

El valor de la resistencia de 4.7K no es crítico. Cualquier desde 1K a 10K puede ser utilizada. El nivel de luz en la LDR cambiará el nivel de tensión en el pin analógico 0. El comando analogRead proporciona un valor que oscila entre alrededor de 200, cuando el LDR es oscuro a 800 o así que cuando es muy brillante. Este valor determina la duración de la LED de encendido y apagado, por lo que el tiempo de parpadeo aumenta con la intensidad de la luz.

Puede escalar la velocidad de parpadeo mediante la función de Map de Arduino de la siguiente manera:
Código:
const int ledPin = 13; // conectar LED em pin digital numero 13
const int sensorPin = 0; // conectar sensor a entrada analogica numero 0
// las dos líneas siguientes establecen el mínimo y el retardo máximo entre parpadeos
const int minDuration = 100; //espera mínimo entre parpadeos
const int maxDuration = 1000; // espera maxima entre parpadeos
void setup()
{
pinMode(ledPin, OUTPUT); // Habilitar pin led como entrada
}
void loop()
{
int rate = analogRead(sensorPin); // Leer entrada analogica
// la línea siguiente escala la frecuencia de parpadeo entre los valores mínimos y máximos
rate = map(rate, 200,800,minDuration, maxDuration); // convertir tasa de parpadeo
rate = constrain(rate, minDuration,maxDuration); // limitar el valor
digitalWrite(ledPin, HIGH); // establecer el LED en ON
delay(rate); // espere duración depende del nivel de luz
digitalWrite(ledPin, LOW); // establecer el LED en OFF
delay(rate);
}
La función delay() es un comando de retardo, que no hace otra cosa que incrementar milisegundos que asignamos entre los paréntesis.

En los ejercicios anteriores vimos el ejemplo más sencillo que se encuentra en la carpeta de Arduino en la sección de ejemplos, que consiste que un LED prenda y apague en los intervalos de tiempo con la función delay().

En la función de retardo, Arduino lo que hace es contar los milisegundos. En un proyecto sencillo como el del ejercicio de apertura de este tutorial no hay problema en tener al microcontrolador ocupado en la tarea de contar milisegundos, pero en desarrollos complejos no es permitido, ya nuestro Arduino tiene que ocuparse de otras tareas.

Por esta razón podemos recurrir a otra función millis() de Arduino para controlar el tiempo que está encendido el LED mientras el microcontrolador queda libre para hacer otras cosas. En otros entornos de programación hay otras alternativas aplicables a nuestros criterios y necesidades.
31/01/2016 #7

Avatar de mecatrodatos

Arduino usa un pequeño micro-controlador, que ejecuta un programa a la vez, pero puede hacer tareas simultáneamente. Vamos a desear que Arduino realice programas perceptibles a nosotros (como en el caso, del parpadeo de un led), Mientras la placa Arduino está ejecutando un delay no se pueden, leer eventos ejemplo sensores.

Recuerdas el código de Blink?

Código:
 /*
int led = 13;
 
void setup()
{                
  pinMode(led, OUTPUT);     
}
 
void loop() {
  digitalWrite(led, HIGH);
  delay(500);
  digitalWrite(led, LOW);
  delay(500);
}
¿Por qué no al delay?

A pesar de que es lo primero que aprendimos a programar con Arduino y es muy sencillo, resulta que congela el procesador por completo y no hará más tareas hasta pasado el delay. Cuando tenemos un código de varias líneas que contiene una instrucción delay para esperar a que pase un tiempo determinado nos encontramos que Arduino está inoperativo la mayor parte del tiempo y tiene que estar esperando el resto del tiempo sin capacidad de responder a ninguno de los eventos que suceden a su alrededor. Este ejemplo de Aduino se la pasa casi todo el tiempo en la función delay, Por ese motivo vamos controlar el tiempo que está encendido el LED sin recurrir a la función delay() .

Código:
/* Parpadeo sin delay()
Enciende y apaga un LED conectado a un pin digital sin utilizar la función delay(). Esto significa que otro código se puede ejecutar al mismo tiempo sin ser interrumpido por el código que controla el parpadeo del LED
Circuito: Un LED conectado entre el pin 13 y el pin GND.
Nota: en muchos Arduinos hay un LED en la placa conectado al pin 13, por lo que no sería necesario un LED externo para este ejemplo.*/

// Las constantes no cambian. Las usamos aquí para establecer los números de los pines.
int ledPin = 13;   // el número del pin conectado al LED

//  variables que cambiarán de valor.
int ledState = LOW;   // ledState se usará para establecer el estado del LED

long previousMillis = 0;   // almacenará la última vez que el estado del LED
//se actualizó

// La siguiente variable es del tipo long porque el tiempo medido en
// milisegundos supera rápidamente al número que puede ser almacenado en una
// variable del tipo int
long interval = 1000;   // intervalo del parpadeo (en milisegundos)

void setup() 
{
// establece el pin digital como salida:
pinMode(ledPin, OUTPUT);
}

void loop()
{
// Aquí es donde se consigna el código que debe ejecutarse 

// Se comprobará si es el momento de parpadear el LED, esto es, si la
// diferencia entre el tiempo transcurrido y el tiempo en que parpadeó
// por última vez el LED es mayor que el intervalo que establecimos en
// la declaración de variables.

unsigned long currentMillis = millis();    // Se toma el tiempo actual

// se comprueba si el tiempo actual menos el tiempo en que el LED cambió
// de estado por última vez es mayor que el intervalo.
if (currentMillis - previousMillis > interval){

// Si se cumple la condición se guarda el nuevo tiempo
// en el que el LED cambia de estado
previousMillis = currentMillis;

// Y ahora cambiamos de estado el LED, si está encendido a
// apagado o viceversa.
if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;

// Hacemos que el contenido de la variable llegue al LED
digitalWrite(ledPin, ledState);
}
}
Por defecto, Arduino utiliza el timer0 para las funciones de tiempo por el software báse: delay(), millis() y micros(). El timer1 lo utiliza la librería servo. Y el timer2 lo utiliza la función tone().
La función millis() nos devuelve el tiempo en milisegundos transcurridos desde que trabaja la placa Arduino con el programa actual. Esta función establece un unsigned long, es decir un número de 32 bits. Puesto que la función millis() cuenta milisegundos, la precisión es suficiente para la mayoría de los proyectos habituales. Si necesitamos más precisión recurriremos a la función micros ().

Algunos dirán es un código demasiado complicado para una tarea tan sencilla de parpadeo de un LED. Es un código complejo, pero eficiente. Si deseas que tu placa de Arduino no se quede al hacer tareas. Aquí hay un código multitarea que nos abre el camino a la programación Orientada a Objetos

Código:
//No se requiere nada adicional para poder ejecutar este código en tu Arduino 

int ledPin1 = 13; // LED VERDE
int ledState1 = HIGH; // Inicialmente está apagado
unsigned long previousMillis1 = 0; //Sera el que almacene en que ms fue la última vez que se encendió o apago
long OnTime1 = 300; //Tiempo que el led VERDE permanecerá encendido
long OffTime1 = 800; // Tiempo que el led VERDE permanecerá apagado

int ledPin2 = 14; // LED AZUL
int ledState2 = HIGH; // Inicialmente está apagado
unsigned long previousMillis2 = 0; //Sera el que diga en que ms fue la última vez que se encendio o apago
long OnTime2 = 250; //Tiempo que el led AZUL permanecerá encendido
long OffTime2 = 500; //Tiempo que el led AZUL permanecerá apagado

void setup()
{
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
}
void loop()
{
  //Revisa si es momento de apagar el LED
  unsigned long currentMillis = millis();
  if((ledState1 == LOW) && (currentMillis - previousMillis1 >= OnTime1)) //Si el LED VERDE esta prendido y la última vez que se encendió fue hace más de 300 ms entonces vamos a apagarlo!
  {
    ledState1 = HIGH; // Cambia el valor de la variable para luego escribirla
    previousMillis1 = currentMillis; // "La última vez fue AHORA"
    digitalWrite(ledPin1, ledState1); // Hace efectivo el cambio en el LED
  }
  else if ((ledState1 == HIGH) && (currentMillis - previousMillis1 >= OffTime1))
  {
    ledState1 = LOW;
    previousMillis1 = currentMillis;
    digitalWrite(ledPin1, ledState1);
  }
  
  
  if((ledState2 == HIGH) && (currentMillis - previousMillis2 >= OnTime2))
  {
    ledState2 = LOW;
    previousMillis2 = currentMillis;
    digitalWrite(ledPin2, ledState2);
  }
  else if ((ledState2 == LOW) && (currentMillis - previousMillis2 >= OffTime2)) //Si el LED AZUL está apagado y la última vez que se apago fue hace más de 500 ms entonces vamos a prenderlo!
  {
    ledState2 = HIGH; // Cambia el valor de la variable para luego escribirla
    previousMillis2 = currentMillis; // "La última vez fue AHORA"
    digitalWrite(ledPin2, ledState2); // Hace efectivo el cambio en el LED
  }
}
29/09/2016 #8

Avatar de Scooter

Cuidado con milis, cuando desborde hará una temporización rara.
14/04/2017 #9

Avatar de mecatrodatos

PROYECTO No.1 ALARMA CON ARDUINO

Quiero reabrir este hilo con un proyecto simple que cualquier persona con deseos de aprender desearía, un sistema de alarma básico que se activa cuando se detecta movimiento por un sensor. Este sencillo proyecto no sólo es divertido, sino que también nos ayudará a repasar los fundamentos de la programación y la electrónica de Arduino, que son las habilidades que usaremos.

Básicamente será una alarma simple (un zumbador que hace sonido, más un LED rojo) combinado con un detector de movimiento. El usuario también podrá detener la alarma presionando un botón.

• En primer lugar, vamos a ver cuáles son los requisitos para este proyecto, en términos de hardware y software
• A continuación, veremos cómo montar las piezas de hardware para este proyecto
• Después de eso, configuraremos nuestro sistema usando el IDE de Arduino

REQUISITOS DE HARDWARE Y SOFTWARE

En primer lugar, vamos a ver cuáles son los componentes necesarios para este proyecto. Como este es el primer proyecto de este hilo, pasaremos un poco más de tiempo aquí para detallar los diferentes componentes, ya que estos son los componentes que vamos a utilizar en todos los proyectos.

El primer componente central para el proyecto es el Arduino Uno:

En varios ejemplos de este hilo, éste será el "cerebro" de los proyectos que haremos. En todos los proyectos, usaré el Arduino Uno R3. Sin embargo, pueden utilizar una placa equivalente de otra marca u otra placa Arduino, por ejemplo la placa Arduino Mega.

Otro componente crucial de nuestro sistema de alarma será el zumbador: Este es un componente muy simple que se utiliza para hacer sonidos simples con Arduino. No se puede reproducir un MP3 con él, pero está bien para un sistema de alarma. Usted puede, por supuesto, utilizar cualquier zumbador que tenga disponible; El objetivo es hacer un sonido.

Después de eso, vamos a necesitar un detector de movimiento: Aquí, utilicé un detector de movimiento PIR muy simple. Este sensor medirá la luz infrarroja (IR) que se emite al mover objetos en su campo de visión, por ejemplo, personas que se mueven. Es realmente fácil y bastante barato para la interfaz con Arduino. Puede utilizar cualquier marca que desee para este sensor; Solo necesita un nivel de voltaje de 5V para ser compatible con la placa Arduino Uno. Por último, aquí está la lista de todos los componentes que vamos a utilizar en este proyecto:

• Arduino Uno
• Buzzer
• PIR
• LED (
• 330 Ohm resistor
• Button
• 1k Ohm resistor
• Breadboard
• Jumper wires

Tenga en cuenta que vamos a utilizar el IDE de Arduino en todos los proyectos, por lo que asegúrese de instalar la última versión.

CONFIGURACIÓN DE HARDWARE

Ahora vamos a montar el hardware para este proyecto. Como este es el primer proyecto, será simple. Sin embargo, hay bastantes componentes, así que asegúrese de seguir todos los pasos. Aquí hay un esquema para ayudarle durante el proceso:

https://circuits.io/circuits/4651204-alarma-arduino

Empecemos poniendo todos los componentes en el protoboard. Coloque el zumbador, el botón y el LED en la placa primero, de acuerdo con los esquemas. Luego, coloque la resistencia de 330 Ohm en serie con el ánodo de LED (la pata más larga) y conecte la resistencia de 1k Ohm a un pin del botón.
Así es como debe mirar esta etapa:

Ahora vamos a conectar cada componente a la placa Arduino. Comencemos con la fuente de alimentación. Conecte el pin de 5V de la tarjeta Arduino a un carril de alimentación rojo del protoboard y el pin GND de la tarjeta Arduino a un carril de alimentación azul del protoboard.

Entonces, vamos a conectar el zumbador. Conecte un pin del zumbador al pin número 5 de la tarjeta Arduino y el otro pin al riel de alimentación azul del protoboard.

Después de eso, vamos a conectar el LED. Conecte la clavija libre de la resistencia a la clavija 6 de la tarjeta Arduino y la clavija libre del LED (el cátodo) al suelo a través del raíl de alimentación azul.

También vamos a conectar el pulsador a nuestro Arduino. Consulte el esquema para estar seguro sobre las conexiones ya que es un poco más complejo. Básicamente, es necesario conectar el pin libre de la resistencia a la tierra y conectar el pasador que se conecta al botón a la clavija de 5V a través de la barra de potencia de color rojo. Finalmente, conecte el otro lado del botón al pin 12 de la tarjeta Arduino.

Por último, vamos a conectar el sensor de movimiento PIR a la tarjeta Arduino. Conecte el pasador VCC del sensor de movimiento al raíl de alimentación rojo y el pasador GND al riel de potencia azul. Finalmente, conecte el pin SIG (o el pin OUT) al número 7 de Arduino. El resultado final es el siguiente:

Si su proyecto se parece a esta imagen, felicidades, acaba de montar su primer proyecto. Ahora puede pasar a la siguiente sección.

Configuración del sistema de alarma

Ahora que el hardware para nuestro proyecto está listo, podemos escribir el código para el proyecto para que tengamos un sistema de alarma utilizable. El objetivo es hacer que el zumbador produzca un sonido cuando se detecte movimiento y también para que el parpadeo del LED. Sin embargo, cuando se pulsa el botón, la alarma se apagará.

Aquí está el código completo para este proyecto:

Código:
// Código para el sistema de alarma simple

// Pines
const int alarm_pin = 5;
const int led_pin = 6;
const int motion_pin = 7;
const int button_pin = 12;

// Alarma
boolean alarm_mode = false;

// Variables para el LED parpadeante
int ledState = LOW;
long previousMillis = 0; 
long interval = 100;  // Intervalo de parpadeo (milisegundos)

void setup()
{
  // Establece los pines a la salida
  pinMode(led_pin,OUTPUT);
  pinMode(alarm_pin,OUTPUT);

  // Establece boton como entrada
  pinMode(button_pin, INPUT);
  
  // Espere antes de iniciar la alarma
  delay(5000);
}

void loop()
{
  // Movimiento detectado?
  if (digitalRead(motion_pin)) {
    alarm_mode = true; 
  }

  // Si el modo de alarma está activado, destellar el LED
  // realizar la sentencia de alarma
  if (alarm_mode){
    unsigned long currentMillis = millis();
    if(currentMillis - previousMillis > interval) {
      previousMillis = currentMillis;   
      if (ledState == LOW)
        ledState = HIGH;
      else
        ledState = LOW;
    // Activacion del LED
    digitalWrite(led_pin, ledState);
    }
    tone(alarm_pin,1000);
  }

  // si la alarma esta desactivada
  if (alarm_mode == false) {
  
    // Sin tono y LED apagados
    noTone(alarm_pin);  
    digitalWrite(led_pin, LOW);
  }

  // Si se pulsa el botón, apague la alarma
  int button_state = digitalRead(button_pin);
  if (button_state) {alarm_mode = false;}
}
Ahora vamos a ver, en más detalle, las diferentes partes del código. Comienza por declarar qué pines están conectados a diferentes elementos del proyecto, como el zumbador de alarma:

Código:
const int alarm_pin = 5;
const int led_pin = 6;
const int motion_pin = 7;
const int button_pin = 12;
Después de eso, en la función setup () , declaramos los pines como entradas o salidas, de la siguiente manera:
Código:
// Selection de pines de salida
pinMode(led_pin,OUTPUT);
pinMode(alarm_pin,OUTPUT);
// Establece boton como entrada
pinMode(button_pin, INPUT);
Luego, en la función loop () , comprobamos si la alarma se ha activado comprobando el estado del sensor de movimiento:


Código:
if (digitalRead(motion_pin)) {
  alarm_mode = true;
}
Tenga en cuenta que si detectamos algún movimiento, inmediatamente ponemos la variable alarm_mode a true. Veremos cómo el código hace uso de esta variable ahora mismo. Ahora, si la variable alarm_mode es verdadera, tenemos que activar la alarma, hacer que el buzzeremit un sonido, y también destellar el LED. Esto se realiza mediante el fragmento de código siguiente:

Código:
if (alarm_mode){
    unsigned long currentMillis = millis();
    if(currentMillis - previousMillis > interval) {
      previousMillis = currentMillis;  
      if (ledState == LOW)
        ledState = HIGH;
      else
        ledState = LOW;
    // Switch the LED
    digitalWrite(led_pin, ledState);
    }
    tone(alarm_pin,1000);
  }
Además, si alarm_mode eS falsa, necesitamos desactivar la alarma inmediatamente deteniendo la emisión del sonido y apagando el LED. Esto se hace con el código siguiente:

Código:
if (alarm_mode == false) {
 
    // No tone & LED off
    noTone(alarm_pin); 
    digitalWrite(led_pin, LOW);
  }
Finalmente, leemos continuamente el estado del pulsador. Si se pulsa el botón, inmediatamente desactivaremos la alarma:

Código:
int button_state = digitalRead(button_pin);
if (button_state) {alarm_mode = false;}
Por lo general, debemos cuidar el efecto de rebote del botón para asegurarnos de que no tengamos lecturas erráticas cuando se presiona el botón. Sin embargo, aquí solo nos interesa el botón que está siendo presionado, así que no necesitamos agregar un código de rebote adicional para el botón.

Ahora que hemos anotado el código para el proyecto, es hora de llegar a la parte más emocionante: probar el sistema de alarma! Prueba del sistema de alarma Ahora estamos listos para probar nuestro sistema de alarma. Simplemente tome el código para este proyectoy póngalo en su IDE de Arduino.

En el IDE, elija el tipo de tabla correcto (por ejemplo, Arduino Uno) y también el puerto serie correcto.

Ahora puede cargar el código en el tablero. Una vez hecho, pase su mano delante del sensor de movimiento PIR; La alarma debe apagarse inmediatamente. Entonces, presione el botón para detenerlo.

Si le funciona felicitaciones, acaba de construir su primer proyecto: un sistema de alarma basado en Arduino!

Si no funciona bien, hay varias cosas que puede comprobar. En primer lugar, vaya a través de la parte de configuración de hardware para asegurarse de que su proyecto está configurado correctamente.

Además, puede verificar que al pasar la mano delante del sensor PIR, se vuelva roja. Si este no es el caso, muy probablemente su sensor de movimiento PIR tiene un problema y debe ser reemplazado.

Resumen

En este hilo, construimos una alarma basada en Arduino con sólo unos pocos componentes.Hay varias maneras de ir más lejos y mejorar este proyecto. Puede agregar más funciones al proyecto agregando más líneas al código. Por ejemplo, puede agregar un temporizador para que la alarma sólo se apague después de un período de tiempo determinado, o puede crear un modo en el que una pulsación del botón active o desactive el modo de alarma

En la próxima , vamos a construir otro proyecto que sea muy útil .
Imágenes Adjuntas
Tipo de Archivo: png ESQUEMATICO ALARMA.png (84,1 KB (Kilobytes), 9 visitas)
Archivos Adjuntos
Tipo de Archivo: rar ALARMA_ARDUINO.rar (800 Bytes, 8 visitas)
Respuesta
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Buscar más temas sobre:
Lupa Arduino y Raspberry Pi

Cerrar
Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.