Digital
Diferencia entre 2 posibles estados.
Ej: frio – calor
o sistema binario usado por computers
switch
Diferencia entre múltiples estados.
Rango: tibio
Análogo
dimmer
Analog In – Entradas análogas
Pins análogos son entradas análogas. Reciben tensiones entre 5V y 0 voltios. Los pines análogos, al contrario de los digitales, no necesitan ser declarados como modo INPUT o OUTPUT .
Conversión análogo digital o ADC (analog to digital converter)
convertir tensiones de 0 a 5 voltios en números enteros que van del 0 al 1023. En otras palabras, representa la información en números de 10 bits.
Son AI: resistencias variables : potenciómetro – fotocélula – FSR
Comandos básicos
analogRead(pin), Lee o captura el valor de entrada del especificado pin análogo. Placa Arduino realiza una conversión análoga a digital de 10 bits. Esto quiere decir que mapeará los valores de voltaje de entrada, entre 0 y 5 voltios,
a valores enteros comprendidos entre 0 y 1023.
Analog In – Comunicación Serial
Esto nos permite comunicarnos con un computador e intercambiar datos o siemplemente monitorear que pasa con el sketch que esta corriendo en Arduino.
Podemos visualizar los datos procedentes de la tarjeta usando Monitorización del Puerto Serie (último botón a la derecha).
A veces nos interesa poder mandar datos de los sensores hacia el computador o incluso poder mandar comandos desde el PC a Arduino. Por ejemplo, si queremos visualizar, la lectura de un potenciómetro. Si la comunicación en serie esta activada, no se podrán usar los pines 0 y 1 como entrada/salida digital.
Es recomendable dejar tiempos de espera entre los envíos de datos para ambos sentidos (uso por ejemplo de un delay(10)) ,ya que se puede saturar o colapsar el puerto.
Comandos básicos:
Serial.begin
configura el puerto serie a una velocidad determinada. Se expresa en bits por segundo. Va en el setup().
Serial.print()
Descompone un número obtenido de un sensor, por ejemplo, en símbolos ASCII y los lanza uno a uno por el puerto serie en modo de caracteres ASCII. Por ejemplo, el número 100 se representará con la secuencia de números ASCII: 49, 48, 48.
Serial.println(): lanza el valor 13, que quiere decir retorno de carro y el valor 10 que quiere decir fin o salto de línea por el puerto serie.
Serial.print(dato,BYTE): lanza el valor dato por el puerto serie, en modo Byte o Binario.
Analog In – Comunicación Serial
* PWM: 3, 5, 6, 9, 10 y 11.
PWM outputs de 8-bits utilizando función analogWrite().
Para que me sirve?
Manejo de intensidad: luz, T, sonido, etc.
Analog Out – PWM
Analog Out – PWM
PWM (Pulse-width modulation) o serial de modulación por ancho de pulso.
Ancho de pulso, representa al ancho (en tiempo) del pulso con una modulación o cantidad de pulsos (estado on/off) por segundo.
El periodo es medido en segundos y la frecuencia en hertz
La señal PWM se utiliza como técnica para controlar circuitos analógicos, comúnmente usadas para el control de motores DC (si decrementas la frecuencia, la inercia del motor es mas pequeña y el motor se mueve mas lentamente), ajustar la intensidad de brillo de un LED, etc.
En Arduino la señal de salida PWM (pines 3, 5, 6, 9, 10 y 11) es una senal de frecuencia constante (30769 Hz) y que solo nos permite cambiar el "duty cycle" o el tiempo que el pulso esta activo (on) o inactivo (off), utilizando la función analogWrite().
Analog Out – PWM
Con el siguiente código y con solo realizar modificaciones en los intervalos de tiempo que el pin seleccionado tenga valor HIGH o LOW, a través de la función digitalWrite (), generamos la señal PWM.
// señal PWM //
int digPin = 10; // pin digital 10
void setup() {
pinMode(digPin, OUTPUT); // pin en modo salida
}
void loop() {
digitalWrite(digPin, HIGH); // asigna el valor HIGH al pin
delay(500); // espera medio segundo
digitalWrite(digPin, LOW); // asigna el valor LOW al pin
delay(500); // espera medio segundo
}
Analog Out – PWM
El programa pone el pin a HIGH una vez por segundo, la frecuencia que se genera en dicho pin es de 1 pulso por segundo o 1 Hertz de pulso de frecuencia (periodo de 1 segundo) . Cambiando la temporización del programa, podremos cambiar la frecuencia de la señal. Por ejemplo, si cambiamos las dos lineas con delay(500) a delay(250), multiplicaremos la frecuencia por dos, de forma que estamos enviando el doble de la cantidad de pulsos por segundo que antes.,o sea que el LED ya no blinkea, sino que esta brillando al 50% de su brillo normal.
Ahora cambia los números del LED en 1/4 del tiempo en que esta off. Has correr el sketch y veras que el brillo es de 25%. Esta técnica se llama pulse width modulation (PWM), la idea es que el LED blinkea tan rápido que no te das cuenta, pero cambias su rango de brillo entre el tiempo on y el tiempo off. También se aplica a motores y es controlada con la instrucción analogWrite()
PRACTICA
P1. Manejo de una salida digital. Intermitente (*BLINK).
P2. Secuencia Básica de 3 LEDs. (SEMAFORO)
http://www.youtube.com/watch?v=I3U9I7s5lMM
O
(*semaforo 2)
http://www.youtube.com/watch?v=wzqun5cktXk&feature=player_embedded
Como lo haríamos?
Salidas/Entradas Digitales (DI – DO)
Pines digitales son salidas o entradas que reciben niveles altos (5V) o bajos (0V) de tensión y que son interpretados como un 1 o un 0 respectivamente.
Para controlar estas salida /entradas, se utilizan los siguientes comandos:
pinMode(pin, mode) Configura el pin como entrada o salida pin corresponde al número del pin y mode puede ser INPUT o OUTPUT
digitalWrite(pin, value) Escribe un 0 o un 1 (0 o 5V) en el pin especificado
int digitalRead(pin) Lee el valor de un pin digital.
Nota: Los pines digitales 0 y 1 pueden ser utilizados como salidas o entradas siempre que se estén utilizando para la comunicación serial
Salidas/Entradas Digitales (DI – DO)
Pins digitales (pines análogos no necesitan ser declarados como modo INPUT o OUTPUT) son salidas o entradas digitales, esto es niveles altos (5V) o bajos (0V) de tensión que pasan por cada uno de los pines excepto los pines 0 (TX) y 1 (RX) que se emplean para la comunicación en serie o comunicación de Arduino con otros dispositivos.
Para controlar estas salida /entradas, se utilizan ciertos comandos:
pinMode
digitalWrite
delay
digitalWrite(LED, LOW)
digitalWrite(LED, HIGH)
Ejemplo en codigo
int ledPin = 13; // LED conectado al pin 13
int inPin = 7; // pulsador conectado al pin 7
int val = 0; // Variable para almacenar el valor leído
void setup()
{
pinMode(ledPin, OUTPUT); // configura el pin 13 como salida
pinMode(inPin, INPUT); // configure el pin 7 como entrada
}
void loop()
{
val = digitalRead(inPin); // Lee el valor del pin 7
digitalWrite(ledPin,val); // Enciende el LED si el pulsador está presionado
}
Tipos de Sensores Digitales
Sensores simples, como botones push, termostatos, infrarojo, PIR (passive infrared sensor), proximidad o switches tilt.
Manejando mayores cargas (motores, lámparas)
Cada pin digital de Arduino puede entregar hasta 20mA, esta es una pequeña cantidad de corriente, suficiente para un LED.
Si intentas manejar un dispositivo con un mayor consumo, como un motor, el pin se exigirá pudiendo quemarse hasta el microprocesador.
Para manejar mayores cargas, podemos usar un componente externo llamado MOSFET, que funciona como un switch electrónico que puede ser controlado aplicando voltaje a uno de sus 3 pines. Es algo así como el interruptor de luz de nuestras casas en donde la acción del dedo que enciende y apaga la luz es reemplazada por un pin de la placa Arduino que envía voltaje al MOSFET.
Arduino conectado a un MOSFET (IRF250)
Int MotorPin = 9;
void setup(){ // configura el pin 9 como salida pinMode(MotorPin, OUTPUT);
}
void loop(){
// Enciende el Motor digitalWrite(ledPin,val); }
Práctica: Manejo de una entrada digital, lectura de un pulsador
SubDescripción del ejercicio: Conectaremos un pulsador a la entrada digital 2 para luego leer si este se encuentra presionado utilizando el comando digitalRead (inPin)
El pulsador es un componente que conecta dos puntos de un circuito cuando es presionado.
Para generar una señal de tensión con el pulsador, se necesita un divisor de tensión.
Ejemplo de tipos de conexionado:
En alto cuando se presiona el botón
En bajo cuando se presiona el botón
Manejo de una entrada digital, lectura de un pulsador
Elementos necesarios:
Una resistencia de 10K Ohms.
Una resistencia de 100 Ohms.
– Un pulsador.
– Un diodo LED (Utilizaremos el que está en la placa)
Cables para realizar las conexiones.
Utilizaremos el esquema de conexión pull-down, junto con un pulsador, para conectar a un pin de entrada digital, y de esta forma, poder saber cuando el pulsador es presionado. Si el pulsador está presionado, el valor del pin 2 será de 0 voltios (LOW) en caso contrario será de + 5 voltios (HIGH).
Manejo de una entrada digital, lectura de un pulsador
Manejo de una entrada digital, lectura de un pulsador
Recordemos que a diferencia de esta imagen utilizaremos el led incorporado en la placa.
Ejemplo: Código para Lectura del pulsador
int ledPin = 13; // Escoge el pin para el led
int inPin = 2; // Escoge el pin para el pulsador
int val = 0; // variable para leer el estado del pin
void setup() {
pinMode(ledPin, OUTPUT); // declara el LED como salida
pinMode(inPin, INPUT); // declara el pulsador como entrada
}
void loop() {
val = digitalRead(inPin); // Lee el valor del pulsador
if (val == HIGH) // verifica si la entrada es HIGH (Pulsador sin presionar)
{
digitalWrite(ledPin, LOW); // apaga el LED
}
else
{ digitalWrite(ledPin, HIGH); // Enciende el LED
}
}
Este sencillo ejemplo enseña como encender una ampolleta de 220V de corriente alterna (AC) mediante un circuito de 5V de corriente continua (DC) controlado por Arduino. Se puede utilizar con cualquier otro circuito de 220V con un máximo de 10A (con el relé del ejemplo).
Componentes: el Relé es un dispositivo, que
funciona como un interruptor controlado por
un circuito eléctrico en el que, por medio de
un electroimán, se acciona un juego de uno
varios contactos que permiten abrir o cerrar
otros circuitos eléctricos independientes.
Práctica: Control de un relé
o transistor NPN
Práctica: Control de un relé
/* Enciende y apaga una ampolleta de 220V, cada 2 segundos,
mediante un relé conectado al PIN 8 de Arduino */
int relayPin = 8; // PIN al que va conectado el relé
void setup()
{
pinMode(relayPin, OUTPUT); //Configura el Pin8 como salida
}
void loop()
{
digitalWrite(relayPin, HIGH); // ENCENDIDO
delay(2000);
digitalWrite(relayPin, LOW); // APAGADO
delay(2000);
}
codigo Control de un relé
Control de un relé
Control de un buzzer
-buzzer y pwm.
http://www.arduino.cc/en/Tutorial/PlayMelody
ejemplo: Generador de notas musicales
Un piezoeléctrico es un dispositivo que utiliza algún tipo de material que responde a determinado estímulo resonando, o bien al contrario, si se le hace vibrar genera una tensión. (Cristal, buzzers…).
Si suena demasiado basta con introducir una resistencia entre el Arduino y el buzzer.
Un buzzer es un dispositivo de esta familia que cuando se le excita con una tensión empieza vibrar y emite sonido monótono. Simplemente al aplicar cierta tensión oscilante conseguimos emitir sonidos a una frecuencia determinada.
buzzer: Generador de notas musicales
/* Play Melody en carpeta de codigos
* Program to play melodies stored in an array, it requires to know
* about timing issues and about how to play tones.
*
* The calculation of the tones is made following the mathematical
* operation:
*
* timeHigh = 1/(2 * toneFrequency) = period / 2
*
* where the different tones are described as in the table:
*
* note frequency period PW (timeHigh)
* c 261 Hz 3830 1915
* d 294 Hz 3400 1700
* e 329 Hz 3038 1519
* f 349 Hz 2864 1432
* g 392 Hz 2550 1275
* a 440 Hz 2272 1136
* b 493 Hz 2028 1014
* c 523 Hz 1912 956
buzzer: Generador de notas musicales
/* Play Melody
* Program to play melodies stored in an array, it requires to know
* about timing issues and about how to play tones.
*
* The calculation of the tones is made following the mathematical
* operation:
*
* timeHigh = 1/(2 * toneFrequency) = period / 2
*
* where the different tones are described as in the table:
*
* note frequency period PW (timeHigh)
* c 261 Hz 3830 1915
* d 294 Hz 3400 1700
* e 329 Hz 3038 1519
* f 349 Hz 2864 1432
* g 392 Hz 2550 1275
* a 440 Hz 2272 1136
* b 493 Hz 2028 1014
* c 523 Hz 1912 956
Práctica: Generador de notas musicales
Manejando entradas analógas
Elementos analógos de entrada
Los sensores análogos a diferencia de los digitales entregan una salida continua, ya sea de voltaje o corriente. Es decir, no solo 0 o 5V , si no que también valores intermedios.
Cada sensor posee su propia escala por lo que probablemente tendrás que ocupar matemáticas para poder calcular el valor correcto de la medición.
Funciones para el manejo de entradas análogas
int analogRead(pin) Lee el valor de un pin analógico. Entrega un valor entre 0 y 1023 que representa 0 o 5V es decir 4.9mV por unidad.
int ledPin = 9; // LED conectado al pin 9
int analogPin = 3; // potenciómetro conectado al pin 3
int val = 0; // variable para almacenar el valor leído
void setup()
{
pinMode(ledPin, OUTPUT); // Configura el pin como salida
}
void loop()
{
val = analogRead(analogPin); // Lee el pin de entrada (valor entre 0 a 1023)
}
Arduino y sus entradas analógicas
Arduino tiene un conversor análogo digital interno de 6 canales accesibles desde los pines marcados en la placa como ANALOG IN 0-5. Estos pueden leer un voltaje que se encuentre entre los 0 y los 5 voltios. La medición tiene una resolución de 10 bits (1024 valores) lo que nos daría una resolución de (5/1024) = 0.0048 =4.8 mv.
En este caso (ADC interno) para poder hacer la medición buscaremos la forma de implementar un divisor de voltaje con el sensor que estemos trabajando, el valor de la resistencia de división deberá estar en el mismo orden de magnitud que pueda dar la máxima lectura del sensor.
En electrónica, un divisor de voltaje (o tensión o potencial) es un circuito lineal simple que produce un voltaje como output (Vout) que es una fracción de su voltaje como input (Vin). División de voltaje se refiere a la partición del voltaje.
Divisores de tensión para acoplar sensores
Un ejemplo simple de divisor de voltaje, consiste en dos resistencias en serie o un potenciómetro. Es comúnmente utilizado para crear un voltaje de referencia y también puede ser usado como un atenuador de a baja frecuencia.
Para poder leer estos cambios en la resistencia, los pondremos en un circuito (divisor de voltaje) y pasaremos una corriente a través de ellos de tal forma que podemos medir el cambio de voltaje resultante sobre el sensor. ya hecha la medición tendremos que convertir ese voltaje a un valor digital, para este trabajo se utiliza el componente electrónico llamado conversor analógico digital (ADC).
Divisores de tensión para acoplar sensores
Nota: Las entradas analógicas al igual que las digitales soportan valores de 0 a 5V.
Arduino y sus entradas analógicas
El potenciómetro es un dispositivo electromecánico que consta de una resistencia de valor fijo sobre la que se desplaza un contacto deslizante, el cursor, que la divide eléctricamente.
Vout=((R1/(R1+R2))*Vin (Aplicando la ley de Ohm)
Un potenciómetro es especificado por su resistencia total, R, entre los terminales externos 1 y 3; El movimiento del cursor origina un cambio en la resistencia medida entre el terminal central, 2, y uno cualquiera de los extremos.
Este cambio de resistencia puede utilizarse para medir desplazamientos lineales o angulares de una pieza acoplada al cursor.
Se conectan en paralelo al circuito y se comporta como un divisor de tensión.
Potenciómetro para simular una entrada analógica
Potenciómetro como una entrada analógica
int potPin = 2; // Pin A/I pot
int ledPin = 13; // Pin D/O LED
int val = 0; // variable guarda valor del sensor
void setup()
{
pinMode(ledPin, OUTPUT); // ledPin output
}
void loop()
{
val = analogRead(potPin); // lee valor del sensor
digitalWrite(ledPin, HIGH); // enciende LED
delay(val); //detiene el programa por un tiempo
// determinado por la variable
digitalWrite(ledPin, LOW); // apaga el LED
delay(val); //detiene el programa por un tiempo
// determinado por la variable
}
Una fotocélula (o LDR -Light-Dependent Resistor) es una resistencia que varia su intensidad según la luz que recibe. Cuanta más luz menos resistencia ejerce a la corriente
Una LDR considera un sensor de luminosidad, se pueden usar para apagar las luces es de día o encenderlas cuando es de noche. Estas variables son de tipo analógico, como medir el sonido, la inclinación, la presión o el desplazamiento.
Midiendo Luz con Arduino
Listado de componentes:
* 1 LDR
* 1 Resistencia de 1kO
* Un par de cables
Práctica: Midiendo Luz con Arduino
Nota: El LDR del Kit ya viene con la resistencia por lo que no necesitamos agregar nada adicional
int LightPin = 3; // selecciona el pin de entrada para el sensor de luz
int ledPin = 13; // selecciona el pin para el LED
int val = 0; // variable para almacenar el valor capturado desde el sensor
void setup() {
pinMode(ledPin, OUTPUT); // declara el ledPin en modo salida
serial.begin(9600);
}
void loop() {
val = analogRead(LightPin); // read the value from the sensor
digitalWrite(ledPin, HIGH); // enciende el LED
delay(val); // detiene el programa por un tiempo
digitalWrite(ledPin, LOW); // apaga el LED
delay(val); // detiene el programa por un tiempo
serial.println (“Sensor de luz: d”, val);
}
Midiendo Luz con Arduino
* En set de codigos AI_lee LDR
Recuerda encender el monitor serial para leer los valores del LDR
Midiendo Luz con Arduino
Diagrama de circuitos
Diagrama de circuitos
Links prácticos:
-Tom Igoe (ITP)
http://tigoe.net/pcomp/
-arduino
http://blog.makezine.com/archive/2008/11/aduino_gift_guide.html
Proyecto paraguas
Proyecto paraguas
