Cubo Led

1
BASE TEORICA
ARDUINO
CONCEPTO: Arduino (Genuino a nivel internacional hasta octubre 2016), es una compaa de
hardware libre y una comunidad tecnolgica que disea y manufactura placas de desarrollo de
hardware, compuestas por Microcontroladores, elementos pasivos y activos . Por otro lado las placas
son programadas a travs de un entorno de desarrollo (IDE), el cul compila el cdigo al modelo
seleccionado de placa.
Arduino se enfoca en acercar y facilitar el uso de la electrnica y programacin de sistemas

embebidos en proyectulos multidisciplinarios.12Toda la plataforma, incluyendo sus componentes
de hardware (esquemticos) y Software, son liberados con licencia de cdigo abierto que permite
libertad de acceso a ellos.
El hardware consiste en una placa de circuito impreso con un microcontrolador, usualmente Atmel
AVR, puertos digitales y analgicos de entrada/salida, los cuales pueden conectarse a placas de
expansin (shields), que amplan los funcionamientos de la placa Arduino. Asimismo, posee un
puerto de conexin USB desde donde se puede alimentar la placa y establecer comunicacin con
el computador.
Por otro lado, el software consiste en un entorno de desarrollo (IDE) basado en el entorno de
processing y lenguaje de programacin basado en Wiring, as como en el cargador de arranque
(bootloader) que es ejecutado en la placa.4 El microcontrolador de la placa se programa mediante
un computador, usando una comunicacin serial mediante un convertidor de niveles RS-232 a TTL
serial.
La primera placa Arduino fue introducida en 2005, ofreciendo un bajo costo y facilidad de uso para
novatos y profesionales. Buscaba desarrollar proyectos interactivos con su entorno mediante el uso
de actuadores y sensores. A partir de octubre de 2012, se incorporaron nuevos modelos de placas
de desarrollo que usan microcontroladores Cortex M3, ARM de 32 bits, que coexisten con los
originales modelos que integran microcontroladores AVR de 8 bits. ARM y AVR no son
plataformas compatibles en cuanto a su arquitectura y por lo que tampoco lo es su set de
instrucciones, pero se pueden programar y compilar bajo el IDE predeterminado de Arduino sin
ningn cambio.
Las placas Arduino estn disponibles de dos formas: ensambladas o en forma de kits "Hazlo t
mismo" (por sus siglas en ingls "DIY"). Los esquemas de diseo del Hardware estn disponibles
bajo licencia Libre, con lo que se permite que cualquier persona pueda crear su propia placa
Arduino sin necesidad de comprar una prefabricada. Adafruit Industries estim a mediados del
ao 2011 que, alrededor de 300 000 placas Arduino haban sido producidas comercialmente y en
el ao 2013 estim que alrededor de 700 000 placas oficiales de la empresa Arduino estaban en
manos de los usuarios.
Arduino se puede utilizar para desarrollar objetos interactivos autnomos o puede ser conectado a
software tal como Adobe Flash, Processing, Max/MSP, Pure Data, etc. Una tendencia tecnolgica
es utilizar Arduino como tarjeta de adquisicin de datos desarrollando interfaces en software como
JAVA, Visual Basic y LabVIEW.6 Las placas se pueden montar a mano o adquirirse. El entorno de
desarrollo integrado libre se puede descargar gratuitamente.
Hay muchos otros microcontroladores y plataformas microcontroladoras disponibles para

computacin fsica. Parallax Basic Stamp, Netmedias BX-24, Phidgets, MITs Handyboard, y
muchas otras ofertas de funcionalidad similar. Todas estas herramientas toman los desordenados
SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

2
detalles de la programacin de microcontrolador y la encierran en un paquete fcil de usar. Arduino

tambin simplificael proceso de trabajo con microcontroladores, pero ofrece algunas ventajas para
profesores, estudiantes y aaficionados interesados sobre otros sistemas:
Barato: Las placas Arduino son relativamente baratas comparadas con otras plataformas
microcontroladoras. La versin menos cara del modulo Arduino puede ser ensamblada a
mano, e incluso los mdulos de Arduino preensamblados cuestan menos de 50$.
Multiplataforma: El software de Arduino se ejecuta en sistemas operativos Windows,
Macintosh OSX y GNU/Linux. La mayora de los sistemas microcontroladores estn
limitados a Windows.
Entorno de programacin simple y claro: El entorno de programacin de Arduino es fcil
de usar para principiantes, pero sucientemente flexible para que usuarios avanzados puedan
aprovecharlo tambin. Para profesores, est convenientemente basado en el entorno de
programacin Processing, de manera que estudiantes aprendiendo a programar en ese
entorno estarn familiarizados con el aspecto y la imagen de Arduino.
Cdigo abierto y software extensible: El software Arduino est publicado como
herramientas de cdigo abierto, disponible para extensin por programadores
experimentados. El lenguaje puede ser expandido mediante librerias C++, y la gente que
quiera entender los detalles tcnicos pueden hacer el salto desde Arduino a la
programacin en lenguaje AVR C en el cual est basado. De forma similar, puedes aadir
cdigo AVR-C directamente en tus programas Arduino si quieres.
Cdigo abierto y hardware extensible: El Arduino est basado en microcontroladores
ATMEGA8 y ATMEGA168 de Atmel. Los planos para los mdulos estn publicados bajo
licencia Creative Commons, por lo que diseadores experimentados de circuitos pueden
hacer su propia versin del mdulo, extendindolo y mejorndolo. Incluso usuarios
relativamente inexpertos pueden construir la versin de la placa del mdulo para entender
como funciona y ahorrar dinero.
LENGUAJE DE PROGRAMACIN ARDUINO
La plataforma Arduino se programa mediante el uso de un lenguaje propio basado en el lenguaje

de programacin de alto nivel Processing que es similar a C++.
Funciones bsicas y operadores
Arduino est basado en C y soporta todas las funciones del estndar C y algunas de C++. A
continuacin se muestra un resumen con la estructura y sintaxis del lenguaje Arduino:
Sintaxis bsica
Delimitadores: ; , { }
Comentarios: // , /* */
Cabeceras: #define, #include
Operadores aritmticos: +, -, *, /, %
Asignacin: =
Operadores de comparacin: ==, !=, <, >, <=, >=
Operadores Booleanos: &&, ||, !
Operadores de acceso a punteros: *, &
Operadores de bits: &, |, ^, ~, <<, >>
Operadores compuestos:

3
Incremento y decremento de variables: ++, --

Asignacin y operacin: +=, -=, *=, /=, &=, |=
Estructuras de control
Condicionales: if, if...else, switch case
Bucles: for, while, do. while
Bifurcaciones y saltos: break, continue, return, goto
Constantes
HIGH/LOW: representan los niveles alto y bajo de las seales de entrada y salida. Los niveles
altos son aquellos de 3 voltios o ms.
INPUT/OUTPUT: entrada o salida.
false (falso): Seal que representa al cero lgico. A diferencia de las seales HIGH/LOW, su
nombre se escribe en letra minscula.
true (verdadero): Seal cuya definicin es ms amplia que la de false. Cualquier nmero entero
diferente de cero es "verdadero", segn el lgebra de Boole, como en el caso de -200, -1 o 1. Si
es cero, es "falso".
Tipos de datos
void, boolean, char, unsigned char, byte, int, unsigned int, word, long, unsigned long, float,
double, string, array.
Conversin entre tipos

Estas funciones reciben como argumento una variable de cualquier tipo y devuelven una variable
convertida en el tipo deseado.
char(), byte(), int(), word(), long(), float()
Cualificadores y mbito de las variables
static, volatile, const.
Utilidades
sizeof()
Funciones bsicas
E/S digital
pinMode(pin, modo).
digitalWrite(pin, valor).
int digitalRead(pin).
E/S analgica
analogReference(tipo)
int analogRead(pin)

4
analogWrite(pin, valor)
E/S avanzada
shiftOut(dataPin, clockPin, bitOrder, valor)
unsigned long pulseIn(pin, valor)
Tiempo
unsigned long millis()
unsigned long micros()
delay(ms)
delayMicroseconds(microsegundos)
Matemticas
min(x, y), max(x, y), abs(x), constrain(x, a, b), map(valor, fromLow, fromHigh, toLow, toHigh),
pow(base, exponente), sqrt(x)
Trigonometra
sin(rad), cos(rad), tan(rad)
Nmeros aleatorios
randomSeed(semilla), long random(mx), long random(mn, mx)
Bits y Bytes
lowByte(), highByte(), bitRead(), bitWrite(), bitSet(), bitClear(), bit()
Interrupciones externas
attachInterrupt(interrupcin, funcin, modo)

detachInterrupt(interrupcin)
Interrupciones
interrupts(), noInterrupts()
Comunicacin por puerto serie

Las funciones de manejo del puerto serie deben ir precedidas de la palabra "Serial" aunque no
necesitan ninguna declaracin en la cabecera del programa. Por esto se consideran funciones base
del lenguaje. Estas son las funciones para transmisin serial:
begin(), available(), read(), flush(), print(), println(), write()
Manipulacin de puertos
Los registros de puertos permiten la manipulacin a ms bajo nivel y de forma ms rpida de los
contactos de entrada/salida del microcontrolador de las placas Arduino. Los contactos elctricos

5
de las placas Arduino estn repartidos entre los registros B(0-7), C (analgicos) y D(8-13). Mediante
estas variables se observa y se modificada su estado:
DDR[B/C/D]: Data Direction Register (o direccin del registro de datos) del puerto B, C D.
Es una variable de Lectura/Escritura que sirve para especificar cuales contactos sern usados
como entrada y salida.
PORT[B/C/D]: Data Register (o registro de datos) del puerto B, C D. Es una variable de
Lectura/Escritura.
PIN[B/C/D]: Input Pins Register (o registro de pines de entrada) del puerto B, C D. Variable
de slo lectura.
Por ejemplo, para especificar los contactos 9 a 13 como salidas y el 8 como entrada (puesto que el
puerto D usa los pines de la placa Arduino 8 al 13 digitales) bastara utilizar la siguiente asignacin:
DDRD = B11111110;
Como se ha podido comprobar, el conocimiento del lenguaje C, permite la programacin en

Arduino debido a la similitud entre este y el lenguaje nativo del proyecto, lo que implica el
aprendizaje de algunas funciones especficas de que dispone el lenguaje del proyecto para manejar
los diferentes parmetros. Se pueden construir aplicaciones de cierta complejidad sin necesidad de
muchos conceptos previos.
Diferencias con Processing

La sintaxis del lenguaje de programacin Arduino es una versin simplificada de C/C++ y tiene
algunas diferencias respecto de Processing.2829 Debido a que Arduino est basado en C/C++
mientras que Processing se basa en Java, existen varias diferencias en cuanto a la sintaxis de ambos
lenguajes y el modo en que se programa:
Arreglos
Arduino Processing
int bar[8]; int[] bar = new int[8];

bar[0] = 1; bar[0] = 1;
int foo[] = { 0, 1, 2 };
int foo[] = { 0, 1, 2 }; o bien
int[] foo = { 0, 1, 2 };

6
Impresin de cadenas
Arduino Processing
Serial.println("hello world"); println("hello world");
int i = 5; int i = 5;
Serial.println(i); println(i);
int i = 5;
Serial.print("i = "); int i="5";
Serial.print(i); println("i =" + i);
Serial.println();
ESTRUCTURA DE UN SKETCH
La estructura bsica del lenguaje de programacin de Arduino es bastante simple y se compone de

al menos dos partes. Estas dos partes necesarias, o funciones, encierran bloques que contienen
declaraciones, estamentos o instrucciones.
void setup()
{
estamentos;
}
void loop()
{
estamentos;
}
En donde setup() es la parte encargada de recoger la configuracin y loop() es la que contienen el

programa que se ejecutar cclicamente (de ah el termino loop bucle-). Ambas funciones son
necesarias para que el programa trabaje.
La funcin de configuracin debe contener la declaracin de las variables. Es la primera funcin a

ejecutar en el programa, se ejecuta slo una vez, y se utiliza para configurar o inicializar pinMode
(modo de trabajo de las E/S), configuracin de la comunicacin en serie y otras.
La funcin bucle (loop) siguiente contiene el cdigo que se ejecutara continuamente (lectura de
entradas, activacin de salidas, etc) Esta funcin es el ncleo de todos los programas de Arduino y
la que realiza la mayor parte del trabajo.
setup()
La funcin setup() se invoca una sola vez cuando el programa empieza. Se utiliza para inicializar los
modos de trabajo de los pins, o el puerto serie. Debe ser incluido en un programa aunque no haya

7
declaracin que ejecutar. As mismo se puede utilizar para establecer el estado inicial de las salidas
de la placa.
void setup()
{
pinMode(pin, OUTPUT); // configura el 'pin' como salida
digitalWrite(pin, HIGH); // pone el pin en estado HIGH
}
loop()
Despus de llamar a setup(), la funcin loop() hace precisamente lo que sugiere su nombre, se
ejecuta de forma cclica, lo que posibilita que el programa este respondiendo continuamente ante
los eventos que se produzcan en la placa.
void loop()
{
digitalWrite(pin, HIGH); // pone en uno (on, 5v) elpin
delay(1000); // espera un segundo (1000 ms)
digitalWrite(pin, LOW); // pone en cero (off, 0v.) el delay(1000); // pin
}
funciones
Una funcin es un bloque de cdigo que tiene un nombre y un conjunto de instrucciones que son
ejecutadas cuando se llama a la funcin. Son funciones setup() y loop() de las que ya se ha hablado.
Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y para reducir el tamao
de un programa. Las funciones se declaran asociadas a un tipo de valor. Este valor ser el que
devolver la funcin, por ejemplo 'int' se utilizar cuando la funcin devuelva un dato numrico de
tipo entero. Si la funcin no devuelve ningn valor entonces se colocar delante la palabra void,
que significa funcin vaca. Despus de declarar el tipo de dato que devuelve la funcin se debe
escribir el nombre de la funcin y entre parntesis se escribirn, si es necesario, los parmetros que
se deben pasar a la funcin para que se ejecute.
tipo nombreFuncin(parmetros)
{
instrucciones;
}
La funcin siguiente devuelve un nmero entero, delayVal() se utiliza para poner un valor de retraso
en un programa que lee una variable analgica de un potencimetro conectado a una entrada de
Arduino. Al principio se declara como una variable local, v recoge el valor ledo del
potencimetro que estar comprendido entre 0 y 1023, luego se divide el valor por 4 para ajustarlo
a un margen comprendido entre 0 y 255, finalmente se devuelve el valor v y se retornara al
programa principal.
int delayVal()
{
int v; // crea una variable temporal 'v'
v= analogRead(pot); // lee el valor del potencimetro
v /= 4; // convierte 0-1023 a 0-255
return v; // devuelve el valor final
}
{} entre llaves
Las llaves sirven para definir el principio y el final de un bloque de instrucciones. Se utilizan para
los bloques de programacin setup(), loop(), if.., etc.

8
type funcion()
{
instrucciones;
}
Una llave de apertura { siempre debe ir seguida de una llave de cierre }, si no es as el compilador
dar errores. El entorno de programacin de Arduino incluye una herramienta de gran utilidad
para comprobar el total de llaves. Slo tienes que hacer click en el punto de insercin de una llave
abierta e inmediatamente se marca el correspondiente cierre de ese bloque (llave cerrada).
; punto y coma
El punto y coma ; se utiliza para separar instrucciones en el lenguaje de programacin de Arduino.

Tambin se utiliza para separar elementos en una instruccin de tipo bucle for.
int x = 13; // declara la variable 'x' como tipo
// entero de valor 13
Nota: Si olvidis poner fin a una lnea con un punto y coma se producir en un error de
compilacin. El texto de error puede ser obvio, y se referir a la falta de un punto y coma, o puede
que no. Si se produce un error raro y de difcil deteccin lo primero que debemos hacer es
comprobar que los puntos y comas estn colocados al final de las instrucciones. 10
/* */ bloque de comentarios
Los bloques de comentarios, o comentarios multi-lnea son reas de texto ignorados por el programa
que se utilizan para las descripciones del cdigo o comentarios que ayudan a comprender el
programa. Comienzan con / * y terminan con * / y pueden abarcar varias lneas.
/* esto es un bloque de comentario no se debe olvidar
* cerrar los comentarios estos deben estar equilibrados */
Debido a que los comentarios son ignorados por el compilador y no ocupan espacio en la memoria
de Arduino pueden ser utilizados con generosidad. Tambin pueden utilizarse para "comentar"
bloques de cdigo con el propsito de anotar informaciones para depuracin y hacerlo mas
comprensible para cualquiera.
Nota: Dentro de una misma lnea de un bloque de comentarios no se puede escribir otra bloque
de comentarios (usando /*..*/).
// lnea de comentarios
Una lnea de comentario empieza con / / y terminan con la siguiente lnea de cdigo. Al igual que
los comentarios de bloque, los de lnea son ignoradas por el programa y no ocupan espacio en la
memoria.
// esto es un comentario
Una lnea de comentario se utiliza a menudo despus de una instruccin, para proporcionar ms
informacin acerca de lo que hace esta o para recordarla ms adelante.
variables
Una variable es una manera de nombrar y almacenar un valor numrico para su uso posterior por
el programa. Como su nombre indica, las variables son nmeros que se pueden variar
continuamente en contra de lo que ocurre con las constantes cuyo valor nunca cambia. Una
variable debe ser declarada y, opcionalmente, asignarle un valor. El siguiente cdigo de ejemplo

9
declara una variable llamada variableEntrada y luego le asigna el valor obtenido en la entrada
analgica del PIN2:
int variableEntrada = 0; // declara una variable y le
// asigna el valor 0
variableEntrada = analogRead(2); // la variable recoge
//el valor analgico del PIN2
'variableEntrada' es la variable en s. La primera lnea declara que ser de tipo entero int. La
segunda lnea fija a la variable el valor correspondiente a la entrada analgica PIN2. Esto hace que
el valor de PIN2 sea accesible en otras partes del cdigo. Una vez que una variable ha sido asignada,
o re-asignada, usted puede probar su valor para ver si cumple ciertas condiciones, o puede utilizar
directamente su valor. Como ejemplo ilustrativo veamos tres operaciones tiles con variables: el
siguiente cdigo prueba si la variable entradaVariable es inferior a 100, si es cierto se asigna el
valor 100 a entradaVariable y, a continuacin, establece un retardo (delay) utilizando como valor
entradaVariable que ahora ser como mnimo de valor 100:
if (entradaVariable < 100) // pregunta si la variable es menor de 100
{
entradaVariable = 100; // si es cierto asigna el valor 100
}
delay(entradaVariable); // usa el valor como retard
Nota: Las variables deben tomar nombres descriptivos, para hacer el cdigo ms legible. Los
nombres de variables pueden ser contactoSensor o pulsador, para ayudar al programador y a
cualquier otra persona a leer el cdigo y entender lo que representa la variable. Nombres de variables
como var o valor, facilitan muy poco que el cdigo sea inteligible. Una variable puede ser
cualquier 12 nombre o palabra que no sea una palabra reservada en el entorno de Arduino.
declaracin de variables
Todas las variables tienen que declararse antes de que puedan ser utilizadas. Para declarar una
variable se comienza por definir su tipo como int (entero), long (largo), float (coma flotante), etc,
asignndoles siempre un nombre, y, opcionalmente, un valor inicial. Esto slo debe hacerse una
vez en un programa, pero el valor se puede cambiar en cualquier momento usando aritmtica y
reasignaciones diversas.
El siguiente ejemplo declara la variable entradaVariable como una variable de tipo entero int, y
asignndole un valor inicial igual a cero. Esto se llama una asignacin.
int entradaVariable = 0;
Una variable puede ser declarada en una serie de lugares del programa y en funcin del lugar en
donde se lleve a cabo la definicin esto determinar en que partes del programa se podr hacer uso
de ella.
utilizacin de una variable
Una variable puede ser declarada al inicio del programa antes de la parte de configuracin setup(),
a nivel local dentro de las funciones, y, a veces, dentro de un bloque, como para los bucles del tipo
if.. for.., etc. En funcin del lugar de declaracin de la variable as se determinara el mbito de
aplicacin, o la capacidad de ciertas partes de un programa para hacer uso de ella. Una variable
global es aquella que puede ser vista y utilizada por cualquier funcin y estamento de un programa.
Esta variable se declara al comienzo del programa, antes de setup(). Una variable local es aquella
que se define dentro de una funcin o como parte de un bucle. Slo es visible y slo puede utilizarse
dentro de la funcin en la que se declar. Por lo tanto, es posible tener dos o ms variables del

10
mismo nombre en diferentes partes del mismo programa que pueden contener valores diferentes.
La garanta de que slo una funcin tiene acceso a sus variables dentro del programa simplifica y
reduce el potencial de errores de programacin. El siguiente ejemplo muestra cmo declarar a unos
tipos diferentes de variables y la visibilidad de cada variable:
int value; // 'value' es visible para cualquier funcin
void setup()
{
// no es necesario configurar nada en este ejemplo
}
void loop()
{
for (int i=0; i<20;) // 'i' solo es visible
{ // dentro del bucle for
i++
} // 'f' es visible solo
float f; // dentro de loop()
}
arrays
Un array es un conjunto de valores a los que se accede con un nmero ndice. Cualquier valor
puede ser recogido haciendo uso del nombre de la matriz y el nmero del ndice. El primer valor
de la matriz es el que est indicado con el ndice 0, es decir el primer valor del conjunto es el de la
posicin 0. Un array tiene que ser declarado y opcionalmente asignados valores a cada posicin
antes de ser utilizado.
int miArray[] = {valor0, valor1, valor2...}
Del mismo modo es posible declarar una matriz indicando el tipo de datos y el tamao y
posteriormente, asignar valores a una posicin especifica:
int miArray[5]; // declara un array de enteros de 6 posiciones
miArray[3] = 10; // asigna l valor 10 a la posicin 4
Para leer de un array basta con escribir el nombre y la posicin a leer:

x = miArray[3]; // x ahora es igual a 10 que est en
// la posicin 3 del arra
Las matrices se utilizan a menudo para estamentos de tipo bucle, en los que la variable de
incremento del contador del bucle se utiliza como ndice o puntero del array. El siguiente ejemplo
usa una matriz para el parpadeo de un LED. Utilizando un bucle tipo for, el contador comienza en
cero 0 y escribe el valor que figura en la posicin de ndice 0 en la serie que hemos escrito dentro
del array parpadeo[], en este caso 180, que se enva a la salida analgica tipo PWM configurada en
el PIN10, se hace una pausa de 200 ms y a continuacin se pasa al siguiente valor que asigna el
ndice i.
int ledPin = 10; // LED en el PIN 10

byte parpadeo[] = {180, 30, 255, 200, 10, 90, 150, 60}; // array de 8 valores
void setup()
{
pinMode(ledPin, OUTPUT); // configura la salida
}
void loop()
{
for(int i=0; i<7; i++)
{
analogWrite(ledPin, parpadeo[i]);

11
delay(200); // espera 200ms

}
}
e/s digitales
pinMode(pin, mode)
Esta instruccin es utilizada en la parte de configuracin setup () y sirve para configurar el modo de
trabajo de un PIN pudiendo ser INPUT (entrada) u OUTPUT (salida).
pinMode(pin, OUTPUT); // configura pin como salida
Los terminales de Arduino, por defecto, estn configurados como entradas, por lo tanto no es
necesario definirlos en el caso de que vayan a trabajar como entradas. Los pines configurados como
entrada quedan, bajo el punto de vista elctrico, como entradas en estado de alta impedancia. Estos
pines tienen a nivel interno una resistencia de 20 K a las que se puede acceder mediante software.
Estas resistencias se accede de la siguiente manera:
pinMode(pin, INPUT); // configura el pin como
// entrada
digitalWrite(pin, HIGH); // activa las resistencias
// internas
Las resistencias internas normalmente se utilizan para conectar las entradas a interruptores. En el
ejemplo anterior no se trata de convertir un pin en salida, es simplemente un mtodo para activar
las resistencias interiores. Los pins configurado como OUTPUT (salida) se dice que estn en un
estado de baja impedancia estado y pueden proporcionar 40 mA (miliamperios) de corriente a otros
dispositivos y circuitos. Esta corriente es suficiente para alimentar un diodo LED (no olvidando
poner una resistencia en serie), pero no es lo suficiente grande como para alimentar cargas de mayor
consumo como rels, solenoides, o motores. Un cortocircuito en las patillas Arduino provocar
una corriente elevada que puede daar o destruir el chip Atmega. A menudo es una buena idea
conectar en la OUTUPT (salida) una resistencia externa de 470 o de 1000 .
digitalRead(pin)
Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto) o LOW (bajo). El
pin se puede especificar ya sea como una variable o una constante (0-13).
valor = digitalRead(Pin); // hace que 'valor sea igual
// al estado ledo en Pin
digitalWrite(pin, value)
Enva al pin definido previamente como OUTPUT el valor HIGH o LOW (poniendo en 1 o 0
la salida). El pin se puede especificar ya sea como una variable o como una constante (0-13).
digitalWrite(pin, HIGH); // deposita en el 'pin' un valor HIGH (alto o 1)
El siguiente ejemplo lee el estado de un pulsador conectado a una entrada digital y lo escribe en el
pinde salida LED:
int led = 13; // asigna a LED el valor 13
int boton = 7; // asigna a botn el valor 7
int valor = 0; // define el valor y le asigna el valor 0
void setup()
{
pinMode(led, OUTPUT); // configura el led (pin13) como salida

12
pinMode(boton, INPUT); // configura botn (pin7) como entrada

}
void loop()
{
valor = digitalRead(boton); //lee el estado de la entrada botn
digitalWrite(led, valor); // enva a la salida ledel valor ledo
}
analogWrite(pin, value)
Esta instruccin sirve para escribir un pseudo-valor analgico utilizando el procedimiento de

modulacin por ancho de pulso (PWM) a uno de los pins de Arduino marcados como pin
PWM. El ms reciente Arduino, que implementa el chip ATmega168, permite habilitar como
salidas analgicas tipo PWM los pines 3, 5, 6, 9, 10 y 11. Los modelos de Arduino ms antiguos
que implementan el chip ATmega8, solo tiene habilitadas para esta funcin los pines 9, 10 y 11. El
valor que se puede enviar a estos pines de salida analgica puede darse en forma de variable o
constante, pero siempre con un margen de 0-255.
analogWrite(pin, valor); // escribe 'valor' en el 'pin' definido como analgico
Si enviamos el valor 0 genera una salida de 0 voltios en el pin especificado; un valor de 255 genera
una salida de 5 voltios de salida en el pin especificado. Para valores de entre 0 y 255, el pin saca
tensiones entre 0 y 5 voltios - el valor HIGH de salida equivale a 5v (5 voltios). Teniendo en cuenta
el concepto de seal PWM , por ejemplo, un valor de 64 equivaldr a mantener 0 voltios de tres
cuartas partes del tiempo y 5 voltios a una cuarta parte del tiempo; un valor de 128 equivaldr a
mantener la salida en 0 la mitad del 29 tiempo y 5 voltios la otra mitad del tiempo, y un valor de
192 equivaldr a mantener en la salida 0 voltios una cuarta parte del tiempo y de 5 voltios de tres
cuartas partes del tiempo restante.
Debido a que esta es una funcin de hardware, en el pin de salida analgica (PWN) se generar una
onda constante despus de ejecutada la instruccin analogWrite hasta que se llegue a ejecutar otra
instruccin analogWrite (o una llamada a digitalRead o digitalWrite en el mismo pin).
Nota: Las salidas analgicas a diferencia de las digitales, no necesitan ser declaradas como INPUT
u OUTPUT.. El siguiente ejemplo lee un valor analgico de un pin de entrada analgica, convierte
el valor dividindolo por 4, y enva el nuevo valor convertido a una salida del tipo PWM o salida
analgica:
int led = 10; // define el pin 10 como led
int analog = 0; // define el pin 0 como analog
int valor; // define la variable valor
void setup(){} // no es necesario configurarentradas y salidas
void loop()
{
valor = analogRead(analog); // lee el pin 0 y lo
asocia a // la variable valor
valor /= 4; // divide valor entre 4 y lo reasigna a valor
analogWrite(led, value); // escribe en el pin10 valor
}
Serial.println(data)
Imprime los datos en el puerto serie, seguido por un retorno de carro automtico y salto de lnea.
Este comando toma la misma forma que Serial.print(), pero es ms fcil para la lectura de los datos
en el Monitor Serie del software.
Serial.println(analogValue); // enva el valor 'analogValue' al puerto

13
Nota: Para obtener ms informacin sobre las distintas posibilidades de Serial.println () y

Serial.print () puede consultarse el sitio web de Arduino. El siguiente ejemplo toma de una lectura
analgica pin0 y enva estos datos al ordenador cada 1 segundo.
int valor; // define la variable valor
void setup()
{
Serial.begin(9600); // configura el puerto serie a
// 9600bps
}
void loop()
{
Serial.println(analogRead(0)); // enva valor analgico
delay(1000); // espera 1 segundo
}
Serial.print(data, data type)
Vuelca o enva un nmero o una cadena de carateres, al puerto serie. Dicho comando puede tomar
diferentes formas, dependiendo de los parmetros que utilicemos para definir el formato de volcado
de los nmeros.
Parmetros
data: el nmero o la cadena de caracteres a volcar o enviar.
data type: determina el formato de salida de los valores numricos (decimal, octal, binario, etc...)
DEC, OCT, BIN, HEX, BYTE , si no se pe nada vuelva ASCII
Ejemplos:
int led = 10; // define el pin 10 como led
int analog = 0; // define el pin 0 como analog
Serial.print(b) // Vuelca o enva el valor de b como
// un nmero decimal en caracteres ASCII.
int b = 79;
Serial.print(b); // imprime la cadena "79".
Serial.print(b, HEX); // Vuelca o enva el valor de
// b como un nmero hexdecimal
// en caracteres ASCII "4F".
Serial.print(b, OCT); // Vuelca o enva el valor de
// b como un nmero Octal en
// caracteres ASCII "117".
Serial.print(b, BIN) // Vuelca o enva el valor de
// b como un nmero binario en
// caracteres ASCII "1001111".
Serial.print(b, BYTE); // Devuelve el caracter "O",
// el cual representa el
// caracter ASCII del valor
// 79. (Ver tabla ASCII).
Serial.print(str); //Vuelca o enva la cadena de
// caracteres como una cadena ASCII.
Serial.print("Hello World!"); // vuelca "Hello World!".

14
CDIGO DEL CUBO
int layer[4]={A3,A2,A1,A0}; //inicializar y declarar capas de LED

int column[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0,A5,A4}; //inicializar y
declarar leds en filas
int time = 250;
void setup()
{
for(int i = 0; i<16; i++)

{
pinMode(column[i], OUTPUT); //configuracion de las salidas de columnas
}
for(int i = 0; i<4; i++)

{
pinMode(layer[i], OUTPUT); //configuracion de las salidas de filas
}
randomSeed(analogRead(10)); //estable un orden aleatorio de las funciones de

prendido o apagado
}
void loop()
{
turnEverythingOff();
flickerOn();
turnEverythingOn();
delay(time);
turnOnAndOffAllByLayerUpAndDownNotTimed();
layerstompUpAndDown();
spiralInAndOut();
delay(time);
aroundEdgeDown();
randomflicker();
randomRain();
diagonalRectangle();
goThroughAllLedsOneAtATime();
propeller();
spiralInAndOut();
flickerOff();
delay(2000);
}
//turn all off

void turnEverythingOff()
{
for(int i = 0; i<16; i++)
{
digitalWrite(column[i], 1);
}
for(int i = 0; i<4; i++)
{
digitalWrite(layer[i], 0);

15
}
}
//turn all on
void turnEverythingOn()
{
for(int i = 0; i<16; i++)
{
}
//turning on layers
for(int i = 0; i<4; i++)
{
}
}
//turn columns off

void turnColumnsOff()
{
for(int i = 0; i<16; i++)
{
}
}
//flicker on
void flickerOn()
{
int i = 150;
while(i != 0)
{
turnEverythingOn();
delay(i);
delay(i);
i-= 5;
}
}
//turn everything on and off by layer up and down NOT TIMED

void turnOnAndOffAllByLayerUpAndDownNotTimed()
{
int x = 75;
for(int i = 5; i != 0; i--)
{
turnEverythingOn();
for(int i = 4; i!=0; i--)
{
digitalWrite(layer[i-1], 0);
delay(x);
}
for(int i = 0; i<4; i++)
{
delay(x);
}
for(int i = 0; i<4; i++)
{
delay(x);
}

16
for(int i = 4; i!=0; i--)

{
delay(x);
}
}
}
//turn everything on and off by column sideways
//up and down single layer stomp

void layerstompUpAndDown()
{
int x = 75;
for(int i = 0; i<4; i++)
{
}
for(int y = 0; y<5; y++)
{
for(int count = 0; count<1; count++)
{
for(int i = 0; i<4; i++)
{
delay(x);
}
for(int i = 4; i !=0; i--)
{
delay(x);
}
}
for(int i = 0; i<4; i++)
{
delay(x);
}
for(int i = 4; i!=0; i--)
{
delay(x);
}
}
}
//flicker off
void flickerOff()
{
turnEverythingOn();
for(int i = 0; i!= 150; i+=5)
{
delay(i+50);
turnEverythingOn();
delay(i);
}
}
//around edge of the cube down

17
void aroundEdgeDown()
{
for(int x = 200; x != 0; x -=50)
{
for(int i = 4; i != 0; i--)
{
digitalWrite(column[5], 0);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
}
}
}
//random flicker
void randomflicker()
{
int x = 10;
for(int i = 0; i !=750; i+=2)
{
int randomLayer = random(0,4);
int randomColumn = random(0,16);

18
digitalWrite(layer[randomLayer], 1);
digitalWrite(column[randomColumn], 0);
delay(x);
digitalWrite(layer[randomLayer], 0);
delay(x);
}
}
//random rain
void randomRain()
{
int x = 100;
for(int i = 0; i!=60; i+=2)
{
int randomColumn = random(0,16);
digitalWrite(layer[0], 1);
delay(x+50);
delay(x);
delay(x);
delay(x+50);
}
}
//diagonal rectangle
void diagonalRectangle()
{
int x = 350;
for(int count = 0; count<5; count++)
{
//top left
for(int i = 0; i<8; i++)
{
}
delay(x);
//middle middle
for(int i = 4; i<12; i++)
{
}
delay(x);
//bottom right
for(int i = 8; i<16; i++)

19
{
}
delay(x);
//bottom middle
for(int i = 4; i<12; i++)
{
}
delay(x);
//bottom left
for(int i = 0; i<8; i++)
{
}
delay(x);
//middle middle
for(int i = 4; i<12; i++)
{
}
delay(x);
//top right
for(int i = 8; i<16; i++)
{
}
delay(x);
//top middle
for(int i = 4; i<12; i++)
{
}
delay(x);
}
//top left
for(int i = 0; i<8; i++)
{
}
delay(x);

20
//propeller
void propeller()
{
int x = 90;
for(int y = 4; y>0; y--)
{
for(int i = 0; i<6; i++)
{
//turn on layer
digitalWrite(layer[y-1], 1);
//a1
turnColumnsOff();
delay(x);
//b1
turnColumnsOff();
delay(x);
//c1
turnColumnsOff();
delay(x);
//d1
turnColumnsOff();
delay(x);
//d2
turnColumnsOff();
delay(x);
//d3
turnColumnsOff();
delay(x);
}
}
//d4
turnColumnsOff();

21
delay(x);
}
//spiral in and out
void spiralInAndOut()
{
turnEverythingOn();
int x = 60;
for(int i = 0; i<6; i++)
{
//spiral in clockwise
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
//spiral out counter clockwise

delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);

22
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
//spiral in counter clock wise

delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
//spiral out clock wise

delay(x);
delay(x);
delay(x);
delay(x);
delay(x);

23
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
delay(x);
}
}
//go through all leds one at a time

void goThroughAllLedsOneAtATime()
{
int x = 15;
for(int y = 0; y<5; y++)
{
//0-3
for(int count = 4; count != 0; count--)
{
digitalWrite(layer[count-1], 1);
for(int i = 0; i<4; i++)
{
delay(x);
delay(x);
}
}
//4-7
for(int count = 0; count < 4; count++)
{
digitalWrite(layer[count], 1);
for(int i = 4; i<8; i++)
{
delay(x);
delay(x);
}
}
//8-11
for(int count = 4; count != 0; count--)
{

24
for(int i = 8; i<12; i++)

{
delay(x);
delay(x);
}
}
//12-15
for(int count = 0; count < 4; count++)
{
for(int i = 12; i<16; i++)
{
delay(x);
delay(x);
}
}
}
}

Cubo Led

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cubo Led

Uploaded by

Copyright:

Available Formats

1

Arduino se enfoca en acercar y facilitar el uso de la electrnica y programacin de sistemas

Hay muchos otros microcontroladores y plataformas microcontroladoras disponibles para

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

detalles de la programacin de microcontrolador y la encierran en un paquete fcil de usar. Arduino

LENGUAJE DE PROGRAMACIN ARDUINO

La plataforma Arduino se programa mediante el uso de un lenguaje propio basado en el lenguaje

Funciones bsicas y operadores

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

Incremento y decremento de variables: ++, --

Conversin entre tipos

char(), byte(), int(), word(), long(), float()

Cualificadores y mbito de las variables

static, volatile, const.

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

attachInterrupt(interrupcin, funcin, modo)

Comunicacin por puerto serie

begin(), available(), read(), flush(), print(), println(), write()

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

Como se ha podido comprobar, el conocimiento del lenguaje C, permite la programacin en

Diferencias con Processing

int bar[8]; int[] bar = new int[8];

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

Serial.println("hello world"); println("hello world");

La estructura bsica del lenguaje de programacin de Arduino es bastante simple y se compone de

En donde setup() es la parte encargada de recoger la configuracin y loop() es la que contienen el

La funcin de configuracin debe contener la declaracin de las variables. Es la primera funcin a

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

El punto y coma ; se utiliza para separar instrucciones en el lenguaje de programacin de Arduino.

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

utilizacin de una variable

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

Para leer de un array basta con escribir el nombre y la posicin a leer:

int ledPin = 10; // LED en el PIN 10

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

delay(200); // espera 200ms

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

pinMode(boton, INPUT); // configura botn (pin7) como entrada

Esta instruccin sirve para escribir un pseudo-valor analgico utilizando el procedimiento de

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

Nota: Para obtener ms informacin sobre las distintas posibilidades de Serial.println () y

Serial.print(data, data type)

data: el nmero o la cadena de caracteres a volcar o enviar.

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

CDIGO DEL CUBO

int layer[4]={A3,A2,A1,A0}; //inicializar y declarar capas de LED

for(int i = 0; i<16; i++)

for(int i = 0; i<4; i++)

randomSeed(analogRead(10)); //estable un orden aleatorio de las funciones de

//turn all off

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

//turn columns off

//turn everything on and off by layer up and down NOT TIMED

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

for(int i = 4; i!=0; i--)

//turn everything on and off by column sideways

//up and down single layer stomp

//around edge of the cube down

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY

SISTEMAS DIGITALES ING. GLADYS ECHEGARAY