MANUAL INTRODUCTORIO AL ARDUINO UNO
PROYECTO DE INSTRUMENTACION ELECTRONICA ALUMNO DE ING. FISICA: CRISTIAN MONZON COELLO 2013
INTRODUCCIÓN AL ARDUINO Arduino es una plataforma de electrónica abierta (open-source) para la creación de prototipos basada en software y hardware libre, flexible y fácil de usar. Enfocada a un público no experto como artistas, diseñadores, entusiastas de la electrónica, o cualquier interesado en crear entornos u objetos interactivos. Está basada en una placa con un micro controlador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidis multidisciplinares. ciplinares. El proyecto Arduino fue concebido en Italia en el año 2005, sus creadores son el zaragozano za ragozano David Cuartielles, ingeniero electrónico y docente de la Universidad de Mälmo, Suecia y Massimo Banzi, italiano, diseñador y desarrollador Web. Su nombre viene del nombre del bar “Bar di Re Arduino” donde Massimo Banzi pasaba algunas horas, el cual a su vez viene
del nombre de un antiguo rey italiano allá por el año 1002. Este proyecto acerca la electrónica a la gente común, pues hace frente a la programación compleja y cerrada de las plataformas plataformas especializadas existentes, existentes, con una plataforma propia, que utiliza software y hardware libre, además de presentarse como la solución para iniciar en el mundo de la electrónica/robótica electrónica/robótica con un bajo coste. Arduino es una herramienta para hacer que los ordenadores puedan sentir y controlar el mundo físico a través de tu ordenador personal. Es una plataforma de desarrollo de computación física que puede tomar información del entorno a través de sus pines de entrada, para esto toda una gama de sensores puede ser usada y puede afectar aquello que le rodea controlando luces, motores y otros actuadores. El microcontrolador en la placa Arduino se programa mediante el lenguaje de programación Arduino (basado en Wiring) y el entorno de desarrollo Arduino (basado en Processing). Hay multitud de diferentes versiones de placas Arduino: Como el Arduino UNO, así como el Duemilanove, que usan Atmel ATmega328. La anterior Diecimila, y las primeras unidades de Duemilanove usaban el Atmel ATmega168, mientras que las placas más antiguas usan el ATmega8. El Arduino Mega está basado en el ATmega1280. Además de muchas placas otras placas copias de Arduino, también son compatibles y legales debido a la filosofía abierta del Arduino.
INTRODUCCIÓN AL ARDUINO Arduino es una plataforma de electrónica abierta (open-source) para la creación de prototipos basada en software y hardware libre, flexible y fácil de usar. Enfocada a un público no experto como artistas, diseñadores, entusiastas de la electrónica, o cualquier interesado en crear entornos u objetos interactivos. Está basada en una placa con un micro controlador y un entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos multidis multidisciplinares. ciplinares. El proyecto Arduino fue concebido en Italia en el año 2005, sus creadores son el zaragozano za ragozano David Cuartielles, ingeniero electrónico y docente de la Universidad de Mälmo, Suecia y Massimo Banzi, italiano, diseñador y desarrollador Web. Su nombre viene del nombre del bar “Bar di Re Arduino” donde Massimo Banzi pasaba algunas horas, el cual a su vez viene
del nombre de un antiguo rey italiano allá por el año 1002. Este proyecto acerca la electrónica a la gente común, pues hace frente a la programación compleja y cerrada de las plataformas plataformas especializadas existentes, existentes, con una plataforma propia, que utiliza software y hardware libre, además de presentarse como la solución para iniciar en el mundo de la electrónica/robótica electrónica/robótica con un bajo coste. Arduino es una herramienta para hacer que los ordenadores puedan sentir y controlar el mundo físico a través de tu ordenador personal. Es una plataforma de desarrollo de computación física que puede tomar información del entorno a través de sus pines de entrada, para esto toda una gama de sensores puede ser usada y puede afectar aquello que le rodea controlando luces, motores y otros actuadores. El microcontrolador en la placa Arduino se programa mediante el lenguaje de programación Arduino (basado en Wiring) y el entorno de desarrollo Arduino (basado en Processing). Hay multitud de diferentes versiones de placas Arduino: Como el Arduino UNO, así como el Duemilanove, que usan Atmel ATmega328. La anterior Diecimila, y las primeras unidades de Duemilanove usaban el Atmel ATmega168, mientras que las placas más antiguas usan el ATmega8. El Arduino Mega está basado en el ATmega1280. Además de muchas placas otras placas copias de Arduino, también son compatibles y legales debido a la filosofía abierta del Arduino.
ALGUNAS VERSIONES DEL ARDUINO ARDUINO
PLACAS CLONES COMPATIBLES
ARDUINO SHIELDS
El concepto de los shields nos permite apilar placas con diferentes funcionalidades, proporcionando flexibilidad al Arduino, para adaptarse a diferentes proyectos rápidamente, basta comprar el shield requerido. Ejemplos: _Shield Xbee - Este shield permite conectar inalámbricamente varios Arduino a distancias de 100 pies en edificios y 300 pies en el exterior usando el módulo Maxstream Xbee Zigbee. _Shield Motores- Este shield permite a Arduino controlar motores eléctricos de corriente continua, servos y motores paso a paso y leer encoders. _Shield Ethernet - Este shield permite a una placa Arduino conectarse a una red Ethernet y tener acceso a y desde Internet.
Muchas empresas ofrecen diferentes tipos de shields, acuerdo a lo que se requeriera obtener. Y si no se encontrara un shield adecuado, usted lo puede construir adaptándolo a la placa.
ALGUNOS SHIELDS DE ARDUINO
ALGUNOS SHIELDS DE ARDUINO
HARDWARE DEL ARDUINO UNO
ESPECIFICACIONES TECNICAS DEL ARDUINO UNO
Microcontrolador ATmega328
Voltaje de operación 5V
Voltaje de entrada (recomendado) 9-12 V
Voltaje de entrada (limite) 6-20 V
Digital I/O Pins 14 (con 6 salidas PWM)
Entradas analógicas Pins 6
DC corriente I/O Pin 40 mA
DC corriente 3.3V Pin 50 Ma
Conversor USB - Serie (chip FTDI)
Memoria Flash 32 KB (2 KB para el boot loader)
SRAM 1 KB
EEPROM 512 byte
Velocidad de reloj 16 MHz
ARDUINO UNO La tarjeta Arduino UNO, es una placa basada en el microprocesador ATmega328. Tiene 13 pines para entradas/salidas digitales (6 de estas pueden ser usadas como salidas PWM), 6 pines para entradas analógicas,
además de un puerto serial que permite realizar
comunicación con periférico una conexión USB. También tiene un pulsador para resetear cualquier fallo que exista en los procesos que se vayan a realiza con la tarjeta. Una vez programado el Arduino, no necesita estar conectado al PC.
Pines de alimentation (Power Pins) Bien alimentemos al Arduino mediante la conexión USB o mediante una fuente externa (recomendada de 9-12V), vamos a tener unas salidas de tensión continua debido a unos reguladores de tensión y condensadores de estabilización. Estos pines son: VIN: se trata de la fuente tensión de entrada que contendrá la tensión a la que estamos alimentando al Arduino mediante la fuente externa. 5V: fuente de tensión regulada de 5V, esta tensión puede venir ya sea de pin VIN a través de un regulador interno, o se suministra a través de USB o de otra fuente de 5V regulada. 3.3V: fuente de 3.3 voltios generados por el regulador interno con un consumo máximo de corriente de 50mA. GND: pines de tierra.
Digital Inputs/Outputs
Cada uno de los 14 pines digitales se puede utilizar como una entrada o salida. Cada pin puede proporcionar o recibir un máximo de 40 mA y tiene una resistencia de pullup (desconectado por defecto) de 20 a 50 kOhm. Sólo pueden leer/escribir dos valores. 0(LOW) y 1(HIGH). En el caso de Arduino, se trabaja con una lógica de 0-5V. Suele tomarlos valores como HIGH cuando son mayores a 1,5V.
Además, algunos pines tienen funciones especializadas como: Pin 0 (RX) y 1 (TX). Se utiliza para recibir (RX) y la transmisión (TX) de datos serie TTL. Pin 2 y 3. Interrupciones externas. Se trata de pines encargados de interrumpir el programa secuencial establecido por el usuario. Pin 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines son de apoyo a la comunicación SPI. Pin 13. LED. Hay un LED conectado al pin digital 13. Cuando el pin es de alto valor, el LED está encendido, cuando el valor está bajo, es apagado.
Pin 3, 5, 6, 9, 10 y 11. PWM (modulación por ancho de pulso) que emiten pulsos de 5V para que Vmedia sea de un valor d eterminado. Constituyen 6 bits de salida PWM con la función analogWrite (). PWM es muy utilizado para controlar la velocidad de motores o la intensidad de diodos LED. También es utilizado para indicar el ángulo de giro de un servomotor.
Analog Inputs El Arduino posee 6 entradas analógicas, etiquetadas desde la A0 a A5, cada una de las cuales ofrecen 10 bits de resolución (es decir, 1024 estados). Por defecto, tenemos una tensión de 5V, pero podemos cambiar este rango utilizando el pin de AREF y utilizando la función analogReference(), donde le introducimos una señal externa de continua que la utilizara como referencia.
INSTALACION DEL ARDUINO
El IDE Arduino f unciona en Windows, Mac OS X y Linux solo se tiene que descargar de: http://arduino.cc/es/Main/Software para el sistema operativo empleado.
Windows XP, vista, 7 Si tu computador tiene de sistema operativo Windows en versión 7, Vista o XP, debes realizar la siguiente sucesión de sencillos pasos:
Conectar la placa Arduino Uno al PC y ver este aviso. No nos debemos pre-ocupar
Visitar Panel de control y luego Administrador de dispositivos , allí buscar la siguiente opción
Click derecho sobre Dispositivo desconocido y luego sobre la opción Actua-lizar
software del controlador.
Ingresar a la opción Buscar software de controlador en el equipo
Examinar y buscar la carpeta de Arduino previamente descomprimida. Dentro de esa carpeta acceder a la carpeta Drivers y dar Aceptar
Una vez buscamos la carpeta de Drivers le damos Siguiente
A veces en algunas máquinas aparecerá esta ventana:
Recibimos la confirmación del Puerto COM asignado, este número de Puerto COM es muy importante tenerlo en cuenta a la hora de programar.
MAC OS X (v. 10.3.9 o posterior) 1. Descargar el entorno Arduino . Para programar la placa Arduino necesitas el entorno Arduino. Descarga la última versión desde http://www.arduino.cc/en/Main/Software. Cuando termine la descarga, descomprime el archivo descarga do. Asegurate de conservar la estructura de carpetas. Haz doble click en la carpeta para abrirla. Debería haber archivos y subcarpetas en su interior. 2. Instalar los drivers USB. Si estas usando un Arduino USB, necesitarás instalar los drivers para el chip FTDI de la placa. Estos pueden encontrarse en el directorio drivers de la distribución Arduino. Si tienes un Mac más antiguo como un Powerbook, iBook, G4 o G5, deberías usar los drivers PPC: FTDIUSBSerialDriver_v2_1_9.dmg. Si tienes un Mac más nuevo como un MacBook, Mac Book Pro o Mac Pro, necesitas los drivers de Intel: FTDIUSBSerialDriver_v2_2_9_Intel.dmg. Haz doble click para montar la imagen del disco y ejecutar el FTDIUSBSerialDriver.pkg
La última versión en drives: http://www.ftdichip.com/Drivers/VCP.htm.
GNU/Linux
Estas instrucciones se centran en la distribución Ubuntu1, para más información sobre cómo instalar el entorno Arduino en otras distribuciones visitar http://www.arduino.cc/playground/Learning/Linux. 1. Ejecutar el Gestor de Paquetes Synaptic (en Sistema > Administración). 2. Primero necesitas habilitar los repositorios ‘’Universe’’ y ‘’Multiverse’’ para que puedas acceder a todos los paquetes que necesitas. Ir a Configuración > Repositorios. Haz click en Añadir. Marca ‘’Software restringido por copyright o cuestiones legales (multiverse)’’ y ‘’Software libre mantenido por la comunidad (universe)’’ y haz click en Añadir. Haz click en Cerrar y click en Cerrar en el diálogo ‘’Los repositorios han cambiado’’. 3. Haz click en el botón Recargar de la barra de herramientas. 4. Marca para instalar: ‘’sun-java5-jre’’, ‘’gcc-avr’’, ‘’avr-libc’’. 5. Haz click en Aplicar en la barra de herramientas. 6. Haz click en Aplicar en el cuadro de diálogo. Esto instalará los paquetes seleccionados. 7. Acepta la licencia de Java. 8. Espera hasta completar la instalación: el cuadro de diálogo dirá _Cambios aplicados_. Haz click en Cerrar. 9. Cierra Synaptic. 10. Descarga la distribición de GNU/Linux de Arduino desde http://www.arduino.cc/en/ Main/Software. Haz doble click en el archivo .zip y arrastra la carpeta que contiene a algún lugar (por ejemplo el Escritorio). 11. Ejecuta el Terminal (en Aplicaciones > Accesorios). 12. Escribe ‘’sudo update-alternatives -config java’’ y presiona Enter. Teclea el número de opción que tiene ‘’ java-1.5.0-sun’’ en él y presiona Enter. Esto hará de la versión de Java de Sun la predeterminada de tu sistema (necesaria porque la versión GNU todavía no soporta todo lo necesitado por el entorno Arduino). 13. Haz doble click en ‘’arduino’’ en el directorio de aplicación de Arduino. Esto debería lanzar un diálogo preguntando dónde guardas los archivos de tus rutinas de Arduino. Un directorio ‘’Arduino’’ en tu carpeta home es la ubicación típica. Haz click en OK. El entorno Arduino debería abrirse.
CONOCIENDO EL ENTORNO DE DESARROLLO DE ARDUINO El entorno Arduino no precisa instalación, se lanza desde la misma carpeta en la que se haya descargado, haciendo doble clic en “arduino.exe”.
Una vez se ha iniciado el entorno, aparecerá la ventana principal, que contiene las siguientes partes principales (luego se verán con detalle cada una de ellas)
Para que la computadora reconozca a la placa Arduino, primero tenenos que configurar el tipo de placa una vez abierta la aplicación nos vamos a Tools>Board>Arduino UNO
Además de elegir el puerto serial en el cual trabajamos, en este caso el COM30, nos vamos a: Tools>Serial Port>COM 30
PROGRAMACIÓN DE UN ARDUINO Vamos a comenzar a programar Arduino. Arduino utiliza una mezcla curiosa de lenguajes de programación. Esta implementado en Java, pero para programar los chips utiliza C++. Un programa diseñado para ejecutarse sobre un Arduino se conoce como sketch, que podríamos traducir como “boceto” o “borrador”. U n sketch siempre tiene la misma estructura.
Además el IDE de Arduino, nos permite adjuntar librerías como en el lenguaje C++, por ejemplo si queremos adjuntar la librería EEPROM, escribimos en la parte superior, como cabecera del sketch: #include Para ver más librerías nos vamos a: Sketch >Importar Libreria>…..
FUNCIONES BÁSICAS E/S DIGITALES pinMode(pin,modo)
Configura el pin especificado para comportarse como una entrada (INPUT) o una salida (OUTPUT). Ejm: pinMode(Pin13, OUTPUT)
digitalWrite(pin,valor) Asigna el valor HIGH (5V) o LOW (0V) a un pin digital. Ejm: digitalWrite(Pin13 , HIGH);
digitalRead(pin) Lee el valor de un pin digital especificado, HIGH o LOW. Ejm: val = digitalRead(Pin13);
E/S ANALÓGICAS
analogRead(pin) Lee el valor de tensión en el pin analógico especificado. La placa Arduino posee 6 canales conectados a un conversor analógico digital de 10 bits. Esto significa que convertirá tensiones entre 0 y 5 voltios a un número entero entre 0 y 1023. Esto proporciona una resolución en la lectura de: 5 voltios / 1024 unidades, es decir, 0.0049 voltios (4.9mV) por unidad. El rango de entrada puede ser cambiado usando la función analogReference(). Ejm: val = analogRead(Pin3)
analogWrite(pin,valor) Escribe un valor analógico (PWM) en un pin. Puede ser usado para controlar la luminosidad de un LED o la velocidad de un motor. Después de llamar a la función analogWrite(), el pin generará una onda cuadrada estable con el ciclo de trabajo especificado hasta que se vuelva a llamar a la función analogWrite() (o una llamada a las funciones
digitalRead() o digitalWrite() en el mismo pin). La frecuencia de la señal PWM será de aproximadamente 490 Hz. los valores de analogRead van desde 0 a 1023 y los valores de analogWrite van desde 0 a 255 Parametros: pin: Es el pin en el cual se quiere generar la señal PWM. valor: El ciclo de trabajo deseado comprendido entre 0 (siempre apagado) y 255 (siempre encendido). Ejm: val = analogRead(analogPin); analogWrite(ledPin, val / 4);
COMUNICACIÓN SERIE
Se utiliza para la comunicación entre la placa Arduino y un ordenador u otros dispositivos. Todas las placas Arduino tienen al menos un puerto serie Serial. Se comunica a través de los pines digitales 0 (RX) y 1 (TX), así como con el ordenador mediante USB. Por lo tanto, si utilizas estas funciones, no puedes usar los pines 0 y 1 c omo entrada o salida digital. Puedes utilizar el monitor serial del Arduino para comunicarte con la placa. Haz clic en el botón del monitor de puerto serie en la barra de herramientas y selecciona la misma velocidad en baudios utilizada en la llamada a begin().
Serial.begin(speed) Establece la velocidad de datos en bits por segundo (baudios) para la transmisión de datos en serie. Para comunicarse con el ordenador, utilice una de estas velocidades: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200. Ejm: Serial.begin(9600);
Serial.read() Lee los datos entrantes del puerto serie. Ejm; Byte = Serial.read();
Serial.print(val,[format]) Imprime los datos al puerto serie como texto ASCII. val: el valor a imprimir de cualquier tipo format: especifica la base (formato) a usar; los valores permitidos son BYTE, BIN (binarios o base 2), OCT (octales o base 8), DEC (decimales o base 10), HEX (hexadecimales o base 16). Para números de coma flotante, este parámetro especifica el número de posiciones decimales a usar. Ejemplos: o Serial.print(78) imprime "78" o Serial.print(78, DEC) imprime "78” o Serial.println(1.23456, 2) imprime "1.23"
Serial.println(val,[format]) Imprime los datos al puerto serie como texto ASCII seguido de un retorno de carro (ASCII 13, o '\r') y un carácter de avance de línea (ASCII 10, o '\n'). Ejemplos: o Serial.println(analogValue); // imprime como ASCII decimal o Serial.println(analogValue, HEX);// imprime como ASCII hexadecimal
Serial.available() Devuelve el número de bytes (caracteres) disponibles para ser leídos por el puerto serie. Se refiere a datos ya recibidos y disponibles en el buffer de recepción del puerto (que tiene una capacidad de 128 bytes). Ejemplo: if (Serial.available() > 0) { } //realiza la lectura del puerto serie
Para más referencias sobre el lenguaje usado en el IDE de Arduino, además sobre los tipos de variables a declarar, el manejo de estructura de del programa, la sintaxis empleada en él, para aprender a usar las librerías y entre otros, podemos ayudarnos con la página web de Arduino, para una referencia más detallada de los comandos empleados: http://arduino.cc/es/Reference/HomePage
CARGANDO MI PRIMER PROGRAMA El primer programa que podemos cargar, muy usado como para empezar en el Arduino, algo como un ‘’HOLA MUNDO’’ en la placa Arduino, es el prendi do y apagado de un led,
usando algún pin digital, en este caso el 13 que tiene una resistencia interna, además de un led de estado, que se ubica al frente del pin 13 en el Arduino. Para ello solo tenemos que buscar en el IDE:
Archivo>>01.Basics>>Blink
Entonces tenemos, el siguiente programa, el cual lo cargamos con el botón redondo con la flechita, que está en la parte superior del IDE: // Blink: Prende un LED por un segundo, y lo apaga por otro segundo, así repetidamente. int led = 13; void setup() { pinMode(led, OUTPUT);
// inicializamos el pin 13 con salida
} void loop() { digitalWrite(led, HIGH); // enciende el LED delay(1000);
// 1000 milisegundos
digitalWrite(led, LOW); // apaga el LED delay(1000); }
// 1000 milisegundos
Entonces notamos la intermitencia del foquito, con un periodo de un segundo, tiempo que podemos variar en el paréntesis de delay( ) del programa.
ENCENDER UN LED CON UN PULSADOR
/* Encender LED con un pulsador Oprimir un pulsador y mientras este se mantenga accionado un LED se enciende */ int pulsador=2; //Pin donde se encuentra el pulsador, entrada int led=13; //Pin donde se encuentra el LED, salida void setup() // Se ejecuta cada vez que el Arduino se inicia { pinMode(pulsador, INPUT); //Configurar el pulsador como una en trada pinMode(led,OUTPUT); //Configurar el LED como una salida } void loop() { //Condicional para saber estado del pulsador if (digitalRead(pulsador)==HIGH) //Pulsador oprimido { digitalWrite(led,HIGH); //Enciende el LED } else //Pulsador NO oprimido { digitalWrite(led,LOW); //Apaga el LED } }
LECTURA SERIAL DE UNA ENTRADA ANÁLOGA
/* LECTURA SERIAL DE ENTRADA ANÁLOGA Leer una entrada análoga y mostrar por la pantalla del Computador (consola serial) el valor luego de girar el potenciómetro */ void setup() // Se ejecuta cada vez que el Arduino se inicia { Serial.begin(9600); //Inicia comunicación serial } void loop() { //Guardar en una variable entera el valor del potenciómetro 0 a 1024 int valor= analogRead(A0); //Imprime en la consola serial el valor de la variable Serial.println(valor); //Retardo para la visualización de datos en la consola serial delay(100); }
ESCRITURA SERIAL
/* ESCRITURA SERIAL
Consiste en escribir por la pantalla del computador (consola serial) una letra predeterminada, la primera vez que se escriba está un LED se enciende, si se vuelve a escribir por segunda vez el LED se apaga. */ int led = 13; //Pin donde se encuentra el LED, salida char leer; //Variable donde se almacena l a letra boolean prendido=false; //Estado LED la primera vez, apagado void setup() // Se ejecuta cada vez que el Arduino se inicia { Serial.begin(9600); //Inicia comunicación serial pinMode(led, OUTPUT); //Configurar el LED como una sali da } void loop() { //Guardar en una variable el valor de la consola serial leer=Serial.read(); // Si es la letra 'a' y además el LED está apagado if ( (leer=='a') && (prendido==false) ) { digitalWrite(led,HIGH); // Enciende el LED prendido=true; // Actualiza el estado del LED } // Si es la letra 'a' y además el LED está encendido else if ( (leer=='a') && (prendido==true) ) { digitalWrite(led,LOW); // Apaga el LED prendido=false; // Actualiza el estado del LED } }
ENCENDER UN LED POR PWM
/* ENCIENDE/APAGA UN LED DE FORMA PROPORCIONAL
Programa que enciende proporcionalmente un LED cuando llega a su máximo punto de brillo comienza a apagarse proporcionalmente. */ int brillo = 0; //Variable de brillo inicia en 0 int variacion = 5; //Variable de incremento configurada de 5 en 5 int led = 9; //Pin donde se encuentra el LED, salida void setup () // Se ejecuta cada vez que el Arduino se inicia { pinMode(led, OUTPUT); //Configurar el LED como un a salida } void loop () { // Escritura analoga (PWM) en el LED escribo el valor de brillo analogWrite(led, brillo); // Incremento la variable brillo de 5 en 5 brillo = brillo + variacion; // Nota: PWM ----> 0 - 255 // Si el brillo es 0 o 255 if (brillo == 0 || brillo == 255) variacion = -variacion; //La variación se vuelve negativa delay (30); //Tiempo de incremento en el brillo }
CONTROL ON/OFF CON POTENCIÓMETRO
/* Control ON/OFF con potenciómetro Programa que enciende un LED cuando el valor de la entrada análoga comandada por el potenciómetro está en cierto valor, cuando este valor cambia el LED se apaga, es un sistema con control ON/OFF */ void setup() // Se ejecuta cada vez que el Arduino se inicia { Serial.begin(9600); //Inicia comunicación serial pinMode(13,OUTPUT); //Configurar el pin 13 como una salida } void loop(){ //Guardar en una variable el valor de la lectura análoga int valor = analogRead(A0); Serial.println(valor); //Imprime el valor por la consola //Si el valor es mayor o igual a 500 if (valor >= 500) { digitalWrite(13,HIGH); //Enciende el LED en el pin 13 } //Si el valor es menor a 500 else { digitalWrite(13,LOW); //Apaga el LED en el pin 13 } delay(100); //Retardo de 100ms para ver los datos de la consola }
CONTROL DE UN LED CON UNA FOTOCELDA
//Programa que enciende un LED de manera proporcional a la cantidad de luz que incida en una fotocelda. void setup() // Se ejecuta cada vez que el Arduino se inicia { Serial.begin(9600); //Inicia comunicación serial pinMode(9,OUTPUT); //Configurar el pin 9 como una salida de PWM } void loop(){ //Guardar en una variable el valor de la lectura análoga de la fotocelda int foto = analogRead(A0); //Verifica el valor máximo y realizar una conversión int conversion = 780 - foto; //Condicional para establecer un valor absoluto if ( conversion < 0) conversion = conversion * -1; //Multiplicar por -1 porque es negativo Serial.print("Foto : "); //Imprimir datos del valor de la lectura análoga de la fotocelda Serial.print(foto); Serial.println(""); Serial.print("Conv : "); //Imprimir datos del valor de la conversión Serial.print(conversion); Serial.println(""); analogWrite(9, conversion); //Escritura análoga de PWM en el LED de acuerdo a la conversión delay(100); //Retardo para datos en la consola }
CONTADOR DE PULSOS
// CONTADOR DE PULSOS: Programa que muestra por pantalla (consola serial) el número de veces que el pulsador //ha sido presionado, se realiza un proceso que de acuerdo al número de pulsos se enciende un LED int conta = 0; //Variable para guardar el conteo de los pulsos void setup() // Se ejecuta cada vez que el Arduino se inicia { Serial.begin(9600); //Inicia comunicación serial pinMode(2,INPUT); //Configura el pin 2 como una entrada, pulsador pinMode(13,OUTPUT); //Configura el pin 13 como una salida, LED } void loop() { if ( digitalRead(2) == HIGH ) // Si el pulsador esta oprimido { if ( digitalRead(2) == LOW ) // Si el pulsador no está oprimido, flanco de bajada { conta++; //Incrementa el contador Serial.println(conta); //Imprime el valor por consola delay (100); // Retardo } } if (conta==5) // Si el valor del contador es 5 { digitalWrite(13,HIGH); //Enciende el LED } if (conta==8) // Si el valor del contador es 8 { digitalWrite(13,LOW); // Apaga el LED } }
LED RGB APOYADO DE TABLA DE COLORES
//Programa que hace uso de una función llamada color para generar diversas tonalidades en un LED RGB int ledRojo = 9; //Declara Pin LED Rojo int ledVerde=10; //Declara Pin LED Verde int ledAzul=11; //Declara Pin LED Azul void setup() // Se ejecuta cada vez que el Arduino se inicia { pinMode(ledRojo,OUTPUT); //El LED Rojo como una salida pinMode(ledVerde,OUTPUT); //El LED Verde como una salida pinMode(ledAzul,OUTPUT); //El LED Azul como una salida } void loop() { // Llamado a la función Color que recibe color(255,0,0); //Rojo, 1er posicion: Intensidad Rojo delay(1000); color(0,255,0); //Verde, 2da posición: Intensidad Verde delay(1000); color(0,0,255); //Azul, 3ra posición: Intensidad Azul delay(1000); color(255,255,255); //Blanco delay(1000); color(255,0,255); //Magenta delay(1000); color(255,128,0); //Naranja delay(1000); } void color(int rojo, int verde, int azul){ //Funcion color analogWrite(ledRojo, 255-rojo); //Escritura de PWM del color Rojo analogWrite(ledVerde, 255-verde); //Escritura de PWM del color Verde analogWrite(ledAzul, 255-azul); //Escritura de PWM del color Azul }
CONTROL ON/OFF DE UN MOTOR Para este experimento necesitamos un transistor NPN, para darle potencia al motor, al pequeño motor. Armamos el siguiente esquema con los componentes con el Arduino.
Tener en cuenta la posición de las patas del transistor de acuerdo al grafico.
CONTROL ON/OFF DE UN MOTOR
/* Programa que hace uso de un motor y un pulsador, mientras se mantenga pulsado, el motor debe estar encendido (ON) de lo contrario debe estar apagado (OFF) */ int pulsador =7; //Declara Pin del pusaldor int motor=3; //Declara Pin del motor void setup() // Se ejecuta cada vez que el Arduino se inicia { pinMode(pulsador,INPUT); //El pulsador como una entrada pinMode(motor,OUTPUT); //El motor como una salida } void loop() { // Si el pulsador se encuentra oprimido if(digitalRead(pulsador) == HIGH){ digitalWrite(motor,HIGH); //Enciende el motor }else{ //si el pulsador no está oprimido digitalWrite(motor,LOW); //Apaga el motor } }
CONTROL POR PWM DE UN MOTOR
CONTROL POR PWM DE UN MOTOR /* Control por PWM de un motor
Programa que hace uso de un motor y la Consola serial de Arduino, tiene la posibilidad de configurar al motor 5 velocidades distintas, desde el teclado del PC puedes enviarle la velocidad deseada. Las 5 velocidades se configuran con 5 PWM distintos. */ int motor=3; //Declara Pin del motor void setup() // Se ejecuta cada vez que el Arduino se inicia { Serial.begin(9600); //Inicia la comunicacion serial Arduino-PC } void loop() { // Si hay algun valor en la Consola Serial if (Serial.available()){ //Variable donde se guarda el caracter enviado desde teclado char a = Serial.read(); // Si el caracter ingresado esta entre 0 y 5 if (a>='0' && a<='5'){ //Variable para escalar el valor ingresado a rango de PWM int velocidad = map(a,'0','5',0,255); //Escritura de PWM al motor analogWrite(motor,velocidad); //Mensaje para el usuario Serial.print("El motor esta girando a la velocidad "); Serial.println(a); }else{ // Si el caracter ingresado NO esta entre 0 y 5 //Mensaje para el usuario Serial.print("Velocidad invalida"); Serial.println(a); } } }
SERVOMOTOR CONTROLADO CON UN POTENCIOMETRO
// Usamos la librería Servo que ya tiene funciones predeterminadas #include
Servo miServo; // Creamos un objeto Servo para controlar nuestro servo int potenciómetro = 0; // Potenciómetro en el Pin Analógico 0 int valor; // Variable para guardar la lectura del potenciómetro void setup() { miServo.attach(9); // Conectamos el servo en el Pin PWM 9 }
void loop() { valor = analogRead(potenciómetro); // Leemos el valor del potenciómetro valor = map(valor, 0, 1023, 0, 179); // Mapeamos su valor al rango del servo [0-180] miServo.write(valor); // Le pasamos al servo el valor escalado
delay(15); // Retraso de 15 milisegundos para refrescar el servo
}
GENERAR TONOS CON UN BUZZER
GENERAR TONOS CON UN BUZZER /* GENERAR TONOS CON UN BUZZER
Programa que hace uso de un buzzer (chicharra) y un potenciómetro, la idea es generar diversos tonos en el buzzer a partir del estado análogo del potenciómetro. Además se hace uso de la función tone que es muy útil para generar diversas melodías */
int buzzer = 9; //Declara Pin del buzzer int tono = 0; //Declara Pin del potenciómetro void setup() // Se ejecuta cada vez que el Arduino se inicia { // No se configuran parámetros inciales, pero se debe // colocar el encabezado de la función setup() } void loop() { //Variable entera donde se almacena el valor del potenciómetro int sensor = analogRead(tono); //Variable donde se escala la frecuencia de 100 a 5000Hz int frecuencia = map(sensor,0,1023,100,5000); //Variable entera para guardar el tiempo deseado en ms int duracion = 250; //Funcion tone(), que recibe: // 1ra posición: Pin del elemento sonoro // 2da posición: Frecuencia deseada en Hz // 3ra posición: Duración del tono tone(buzzer, frecuencia, duracion); //Retardo delay(100); }
MEMORIA EEPROM PARA ALMACENAMIENTO El EEPROM (Electrically-Erasable Programmable Read-Only Memory) que es una memoria ROM programable y borrable eléctricamente, a diferencia de la EPROM que ha de borrarse mediante un aparato que emite rayos ultravioletas. Son memorias no volátiles. Aunque una EEPROM puede ser leída un número ilimitado de veces, sólo puede ser borrada y reprogramada entre 100.000 y un millón de veces.
Para añadir su librería, la cabecera EEPROM: Basta con incluir la directiva #include en nuestro código.
FUNCIONES:
EEPROM.write(dirección, valor) Escribe un valor en la EEPROM. Dirección (Address): Disponemos de 511 celdas (int) Valor (Value): Disponemos de 0 a 255 Tipo Byte)
EEPROM.read(dirección) Lee un valor de la EEPROM Value (Address): Disponemos de 511 celdas (int) Retorna: Byte. (Podemos hacer cast a int)
Código de ejemplo (Desde la página oficial de Arduino)
WRITE #include void setup() { for (int i = 0; i < 512; i++) EEPROM.write(i, i); } void loop() { }
READ #include int a = 0; int value; void setup() { Serial.begin(9600); } void loop() { value = EEPROM.read(a); Serial.print(a); Serial.print("\t"); Serial.print(value); Serial.println(); a = a + 1; if (a == 512) a = 0; delay(500); }
SENSOR DE TEMPERATURA LM35 CON PANTALLA LCD
En este experimento usaremos el sensor de temperatura LM35 y ademas de un pantalla LCD, de la cual existe una librería en el Arduino. El sensor LM35 el cual nos mide una temperatura de -55ºC a 150ºC y una precisión de 0.5ºC a 25ºC; este sensor es suficientemente completo, se puede utilizar para realizar pequeños inventos o proyectos