escuelatecnicajorgenewbery.files.wordpress.com · Web viewARDUINO ARDUINO: Es una tarjeta...

Prof. Fiorillo Roberto

ARDUINO

ARDUINO:

Es una tarjeta electrónica que integra básicamente a un microcontrolador y un conjunto de pines de conexión de entradas y salidas que permiten, mediante un programa interaccionar con el medio físico mediante sensores y actuadores electrónicos así se podrá crear proyectos tecnológicos y dotarlos de sensores que detecten magnitudes físicas como luz, calor, fuerza y en base a esa información encender leds, servomotores, relés etc.

Microcontrolador:

Es un circuito integrado que se puede programar, o sea que puede ejecutar ordenes que tenga almacenadas en su memoria, tiene las tres funciones principales de una computadora, la unidad central de proceso, memoria y entradas – salidas.

ENTRADAS Y SALIDAS

Permiten comunicar los programas con el mundo exterior, los pines de entradas permiten leer magnitudes físicas, por ejemplo un LDR que detecta el nivel de luminosidad, una vez leído el valor si por ejemplo queremos encender un led, este se debe conectar a una salida para activarlo.

En arduino las entradas pueden ser analógicas o digitales, y las salidas sólo digitales, cada pin tiene doble función, puede ser entrada o salida y hay que especificar en el programa como se va a usar.

DONDE SE CONECTAN LOS SENSORES A LAS ENTRADAS ANALÓGICAS O DIGITALES?

Los sensores utilizados en los proyectos que vamos a utilizar son de salida analógica, es decir proporcionan una variación de voltaje dentro de un rango ( de 0 a +5V) dependiendo de lo que varíe la magnitud física medida, muchos sensores son resistivos ( luz, temp. , humedad) es decir que varían su resistencia eléctrica. Una vez realizadas las conexiones, si midiéramos la salida del sensor con un voltímetro nos daría un valor decimal por ejemplo 3,3 V ( siempre en el rango de 0 a

1


5 V), el microcontrolador solo es capaz de interpretar números binarios ( 0 o 1) por lo que para traducir los valores analógicos dispone internamente de un conversor analógico – digital de manera que podremos tener valores discretos de la medida de los sensores analógicos.

COMO SE PROGRAMA ARDUINO

Las partes principales son :

Bloque de inclusión de módulos y declaración de variables, bloque de configuración voidsetup (), donde se indica el modo de funcionamiento de los pines ( entrada o salida) comunicación serie, etc

Bloque de ejecución continua void loop () , en este bloque se incluyen las acciones que queremos que realice el programa, se ejecutará línea a línea de forma secuencial y continua. Cuando llegue a la última instrucción incluida en la función loop volverá a ejecutar la primera y continuará en un bucle infinito.

2


PLACA ARDUINO

3


Pines de la placa elementos con los que podemos interactuar, empezando en el sentido de las agujas del reloj desde el centro de la parte superior:

Pin de referencia analógica ( AREF) Señal de tierra digital ( GND) Pines digitales ( 2 – 13) Pines digitales ( 0 – 1 / entrada y salida del puerto serie : TX / RX) Botón de reset ( S1) Entrada del circuito del programador serie Pines de entrada analógica ( 0 – 5 ) Pines de alimentación y tierra ( 5V – 9 V) Entrada de fuente de alimentación externa ( 9 – 12 V DC ) X1

4


Entorno de programación ARDUINO

el entorno de Arduino está constituido por un editor de texto para escribir el código, un área de mensajes, una consola de texto, una barra de herramientas con botones para las funciones comunes y una serie de menús. Permite la conexión por USB, con el hardware de Arduino para cargar los programas. en la segunda barra desde arriba los simbolos que allí

aparecen significan lo siquiente ( de izquierda a derecha) :

5


PROGRAMACIÓN

Escribiendo Programas

Un programa en Arduino está hecho de código, escrito en un lenguaje de programación llamado C. Cuando escribimos un código es importante tener en cuenta que Arduino no actúa como un ser humano, no razona. Si alguien pronuncia una palabra incorrecta probablemente entendamos el significado – Arduino sin embargo no. Si tecleas incorrectamente un comando mientras escribes código en el IDE de Arduino, no va a entender lo que quieres hacer.

Otra cosa a tener en cuenta es que Arduino es lógico pero no racional. No sabe que quieres hacer, sólo hace lo que le digas hacer.

Estructura Básica

Cuando escribimos código en el IDE de Arduino usamos tres partes básicas en la estructura del programa.

declaración de variables setup() loop()

Las funciones setup() y loop() son esenciales escribirlas para el funcionamiento del programa. A medida que tengas más confianza en la escritura de código para Arduino te darás cuenta que no es obligatorio para escribir código usar estos pasos. Sin embargo viene bien

6


estructurar el programa para hacer fácil su revisión y ayuda a buscar errores en el código. El siguiente código es un ejemplo de un programa sencillo que hace parpadear el LED de la placa Arduino:

intledPin=13;voidsetup(){digitalWrite(ledPin,OUTPUT);}voidloop(){digitalWrite(ledPin,HIGH);delay(1000);digitalWrite(ledPin,LOW);delay(1000);}

Variables

Una variable es un contenedor para guardar algún dato. Digamos que quiere leer un sensor de algún tipo. Este sensor te dará un valor en formato numérico. Si quiere usar este valor en otra parte del programa puede guadar este valor en una variable. Antes de almacenar el valor necesita declarar la variable, esto significa que le digas al programa que la variable existe y que tipo de variable es.

Tenemos que poner un nombre a la variable. El nombre podría ser cualquiera pero es una idea buena dar a sus variables nombres que sean lógicos. Cuando revisé su programa será fácil determinar qué tipo de valor se almacena en una variable nombrada “temSensor”. Puede ser más difícil recordar cual es el contenido en variables con nombres como “banana”, “peter” o “supercalifragilisticexpialidocious”. Más explicaciones en la sección Tipos y

Void setup

Arduino lo primero que hace cuando arranca es mirar la void setup(). Éste es uno de los pasos esenciales del funcionamiento del programa. La void setup() es la parte que inicializa las configuraciones de los diferentes elementos del programa de Arduino; por ejemplo la configuración de un pin o establecer la velocidad de comunicación. La void setup() sólo se ejecuta una vez en el inicio y no se volverá a ejecutar hasta que Arduino se apagué y vuelva a arrancar o se resetea.

El siguiente código es un ejemplo de una void setup que pone la configuración de un pin como salida.

voidsetup(){pinMode(pin,OUTPUT);}

Void loop

La void loop() es el segundo paso esencial para el funcionamiento de un programa. Aquí es donde se ejecutan las acciones de su programa. Como su nombre indica, ésta parte se ejecuta una y otra vez. En un programa de Arduino todo el código se ejecuta línea a línea. Después de ejecutar la void setup() en el arranque continua con la void loop().

7


Entonces empieza a hacer todo lo que está en su código desde el comienzo hasta el final de la void loop(). Cuando llega al final de la void loop() simplemente vuelve a empezar con los cambios del programa. El siguiente código es la void loop() del ejemplo del principio del capítulo:

voidloop(){digitalWrite(ledPin,HIGH);delay(1000);digitalWrite(ledPin,LOW);delay(1000);}

[Get Code]Esta void loop() empieza con una línea de código que activa el pin cuyo número se indica en el nombre de la variable “ledPin”. La siguiente línea de código produce un retardo y después desactiva el mismo pin y a continuación realiza un nuevo retardo. Si ejecutamos este código en Arduino con un LED conectado al pin con el número indicado en la variable “ledPin”, el LED parpadeará encendiéndose y apagándose con un segundo de retardo hasta apagar la alimentación.

Marcas de puntuación. Paréntesis y llaves

Las marcas de puntuación se utilizan para definir el inicio y el final de ciertas partes del código. Hay dos tipos de marcas usados en la escritura de código para Arduino. Los primeros son los paréntesis izquierdo y derecho () y son normalmente llamados entre paréntesis. Estos soportes se utilizan para escribir funciones dentro de nuestros programas. Se utilizan para intercambio de una variable en algún otro lugar dentro de nuestro programa.

También es posible tener una función con los paréntesis vacíos, pero es necesario poner después el nombre de la función o Arduino tendrá un error de compilación. Un ejemplo de funciones que utilizan paréntesis vacíos son la void setup() y la void loop().

El segundo tipo son las llaves {}. Estas se usan para indicar el principio y final de una función. Sin estas llaves Arduino no será capaz de saber dónde empieza y termina la función y que se considera como la siguiente parte del código. Un uso común de estas llaves se hace en la función void setup().

voidsetup(){//The code in the function goes in here.}

Punto y coma

Los puntos y comas son uno de los elementos más importantes para escribir código para Arduino y uno de los que más fácilmente nos olvidamos. Se usan para separar las diferentes líneas de código en su programa e indica a Arduino donde termina su comando. El siguiente ejemplo se muestra como se declara una variable con el uso correcto del punto y coma.

intmyNumber=15;

El punto y coma termina el comando y hemos declarado una variable entera con el nombre “myNumber” y esta variable tendrá el valor 15. Si te olvidas un punto y coma en tu código el IDE de Arduino resaltará la línea de código indicando la falta de punto y coma.

Comentarios de código

8

http://playground.arduino.cc/Es/OSW06?action=sourceblock&num=3


A veces puede ser útil para poner notas o escribir comentarios dentro de su código para uno mismo o para otra persona. Si se escribe el texto dentro de su programa Arduino piensa que es de código e intenta ejecutar lo que está escrito. Si lo que está escrito es algo que el Arduino no entiende, le dará un mensaje de error.

Hay dos maneras de escribir mensajes en el código y ocultarlo a Arduino. La primera de ellas es el uso de una doble barra / / delante de cualquier mensaje. Esto oculta el mensaje a Arduino pero deja lo visible para los programadores. El siguiente es un ejemplo de un mensaje oculto dentro de loop():

voidloop(){digitalWrite(ledPin,HIGH);// turns the led ondelay(1000);// wait for some timedigitalWrite(ledPin,LOW);// turns the led offdelay(1000);// wait a bit more}

Si desea ocultar los mensajes de más de una línea tiene que utilizar / * y * /. Para marcar el inicio de un mensaje que se oculta, se usa / * y para marcar el final del mensaje, use el / *. Esto ocultará todo el mensaje. El siguiente código es un ejemplo de cómo ocultar un bloque de texto dentro de loop():voidloop(){/* this code will first turn a led on then it will wait for some time after that it will turn the led off and then wait again. */digitalWrite(ledPin,HIGH);delay(1000);digitalWrite(ledPin,LOW);delay(1000);}

Tipos de variables y declaraciones

Dar a una variable un valor es también conocido como declarar una variable. Declarar una variable es definir un tipo, nombre y valor para la misma.

VARIABLE INT ( PERMITE ALMACENAR 16 BITS DE DATOS)

Int: Los enteros se usan para guardar datos numéricos sin puntos decimales. Almacenan un valor de 16 bits en el rango de 32767 a -32767. Esto quiere decir que un entero (int) ocupa 16 bits en la memoria de Arduino y puede ser cualquier número entero entre -32767 y 32767.

intmyNumber=14;

En el ejemplo anterior el "int" es el tipo de variable, "miNumero" es el nombre y 14 es el valor. Ten en cuenta que siempre tienes que darle un valor a la variable cuando la declaras. Suponemos que quieres guardar un valor de tu sensor en tu programa, pero no puedes leer el valor cuando declaras la variable fuera del void loop(), en el inicio del programa. Tú le das un valor temporal 0 a la variable cuando la declaras al inicio, como en el siguiente ejemplo:

intmySensor=0;

variable global

9


Hay dos posibles maneras de declarar una variable. Si la declaras al principio de tu programa, antes del void setup() diremos que es una variable global. Una variable global es accesible desde cualquier parte de tu programa.

Variable local:

que sólo pueden usarse dentro de la función en la que se declararon.

El siguiente ejemplo muestra una variable global llamada ledPin:

intledPin=13;voidsetup(){digitalWrite(ledPin,OUTPUT);}voidloop(){digitalWrite(ledPin,HIGH);delay(1000);digitalWrite(ledPin,LOW);delay(1000);}

La variable ledPin es visible en todo el programa y cuando es usada dentro de void loop(); será reconocida como una variable de tipo entero (integer) con el valor 13. Sin embargo, si escribes el mismo programa de la siguiente manera:voidsetup(){ intledPin=13; digitalWrite(ledPin,OUTPUT);}voidloop(){ digitalWrite(ledPin,HIGH); delay(1000); digitalWrite(ledPin,LOW); delay(1000);}

Entonces el programa te dará un error diciendote que no puede encontrar la variable ledPin que intentas usar dentro de void loop();, ya que está declarada dentro (y sólo dentro) de la función void setup();En algunos programas puede ser útil usar variables locales, pero en la mayoría de los casos es mejor declararlas como variables globales y, por tanto, declararlas antes del void setup();

Una vez que tienes una variable con un valor, tu puedes asignarle otro valor, pero ten en cuenta que borrarás el que existía previamente. Supongamos que tenemos una variable llamada miNumero y la hemos declarado como:

intmyNumber=14;

Si a lo largo de tu programa quieres darle otro valor a "myNumero", lo harás así:

10


myNumber=56;

Esto borrará el número 14 de la variable "myNumero" y lo reemplazará por el número 56. Cuando reasignamos valores las variables, no tenemos que añadir "int" al comienzo de la linea de código como hicimos cuando la declaramos. Ésto es porque nosotros sólo declaramos el tipo de variable una vez en el programa. Es posible cambiar el valor de la variable, pero no su tipo.

DIGITAL WRITE

la salida digital tiene dos valores 0 y 5 V en digital son las únicas dos posibilidades 0 o 5V , si queremos hacer que varie desde un valor a otro y que pase por todos los valores debemos usarlo en forma analógica y para ello se agrega un potenciómetro para regular el valor entre 0 y 5 V

cuando programamos el digitalWrite lo que hace es mandar tensión durante un determinado tiempo y luego deja de enviar y viceversa por ejemplo quedando el grafico de arriba.

11


High y Low (Alto y Bajo)

HIGH y LOW se usan para determinar el estado de un pin digital, que sólo tiene esos dos estados. HIGH quiere decir lo mismo que ON (o que hay 5 voltios en tu pin digital). Es lo mismo que un 1 lógico. LOW quiere decir lo mismo que OFF (o que hay 0 voltios en tu pin). Es lo mismo que un 0 lógico:

digitalWrite(ledPin,HIGH);

INPUT Y OUTPUT

Input y Output (Entrada y Salida)

INPUT y OUTPUT se usan cuando declaramos el modo de funcionamiento de nuestro pin digital, sólo existen esos dos modos:

pinMode(12,OUTPUT);

En este ejemplo "pin" es una variable con el valor correspondiente al número del pin a utilizar. OUTPUT es el modo de trabajo que queremos definir. Un pin digital tiene sólo dos modos, OUTPUT (salida) e INPUT (entrada). Si declaras un pin como OUTPUT, sólo podrás usarlo para activarlo, aplicando 5V en el pin, o para desactivarlo, aplicando 0V en el pin. Si configuras el pin como INPUT, sólo podrás usarlo para leer si hay 5V o 0V en el pin:

DIGITALREAD

El comando digitalRead() lee el estado de un pin y devuelve HIGH si está a 5V o LOW si hay 0V en él:

digitalRead(pin);

Para poder usar el valor del estado para algún fin debes guardarlo en una variable:

myVariable = digitalRead(pin);

Si quieres realizar una comparación puedes escribir el comando directamente en la sentencia:

if(digitalRead(pin)==LOW){ doSomething;}

Aunque LOW equivale siempre a 0V en una salida digital, en una entrada digital cualquier valor entre 0V y 1.5V se considerará LOW en el comando digitalRead(). Del mismo modo todos los valores entre 3.3V y 5v se considerarán como un valor HIGH.

12


PINES ANALÓGICOS

Los pines analógicos y digitales funcionan de diferente manera. Hemos mencionado que los pines digitales sólo manejan información en 1 y 0, lo que es lo mismo como ALTO (HIGH) y BAJO (LOW) o 0V y 5V. Sin embargo, en el mundo real no medimos sólo ceros y unos así Arduino tiene seis pines especiales analógicos que hacen un cálculo del voltaje en un rango codificado de 0 a 1023. Los pines analógicos no deben ser declarados, su configuración de I/O, ya que sólo son utilizados como entradas.

Analog read (pin)

Para leer el valor de un pin analógico tienes que usar el comando analogRead() y poner la referencia del pin que deseas leer:

analogRead(pin);

Al igual que con el pin digital, tienes que guardar este valor en una variable para poder usarlo

myVariable = analogRead(pin);

Puedes usar el comando directamentepara hacer comparaciones

if analogRead(pin)>500){ doSomething;}

[Get Code]

Analog write (pin,value)

Los pines digitales sólo puede ser HIGH y LOW, que es lo mismo que tener 5V o 0V en los pines digitales. Sin embargo, para los pines digitales 3, 5, 6, 9, 10 y 11 tenemos una función especial llamada analogWrite (). Con esta función es posible enviar un valor pseudo-analógico a estos pines digitales especiales. Esto se denomina modulación por anchura de pulso (PWM, pulse with modulation):

analogWrite(pin,value);

El valor de este ejemplo puede ser desde 0 a 255. Si escribes un 0, esto sería lo mismo que el poner en el pin LOW, y 255 es lo mismo que HIGH. Pero con analogWrite() obtienes 255 pasos entre HIGH y LOW, así por ejemplo:

analogWrite(pin,127);

Esto sería similar a enviar 2.5V al pin digital. En comparación con el digitalWrite(), que pasa de 0 V a 5 V en un instante, con la analogWrite() puede hacer una transición más lenta de 0V a 5V. Tenga en cuenta que la analogWrite() sólo funciona en los pines digitales marcadas con PWM (3, 5, 6, 9, 10 y 11) y no en los pines de entrada analógica de a0 a a5.

TIEMPO

13



Arduino es una pequeña computadora, pero poderoso y puede realizar 1.000.000 operaciones por segundo. Cuando vaya a hacer prototipos que no quiera ejecutar a una velocidad tan rápida. Vas a tener que decirle a Arduino que pare de vez en cuando.

Delay (retardo)

SE USA PARA PONER UNA PAUSA EN EL PROGRAMA

delay(1000);

Este delay pondrá una pausa en su programa de un segundo,

CONTAR MILISEGUNDO

Este comando millis() devolverá cuantos milisegundos han pasado desde que Arduino inició la ejecución del programa. Para poder utilizar este valor hay que guardarlo en una variable:

myVariable = millis();

Puede usarlo directamente para hacer comparaciones de tiempo:

ifmyAlarmTime==millis()){ ringAlarm;}

Comunicación con otros dispositivosPara ser capaz de comunicarse con otros dispositivos electrónicos debe habilitar los puertos de comunicación de Arduino. Arduino puede comunicarse con el ordenador y con otros dispositivos electrónicos que utilizan el protocolo de comunicación serie.

Los pines digitales 0 y 1 de Arduino se reservan para comunicaciones en serie con otros dispositivos y debería evitar usar estos dos pines para otras tareas, ya que puede interferir con el funcionamiento de su programa.

FUNCION IF

if(myVariable>myOtherVariabel){ doSomething;}

14


else{ doAnotherThing;}

El ejemplo anterior trabaja del siguiente modo: Si miVariable es mayor que miOtraVariable, entonces realiza hazAlgo. Si miVariable no es mayor que miOtraVariable, entonces realiza hazOtraCosa.

No olvides usar otro par de llaves ( {} ) para delimitar el comienzo y final de la sentencia Else.

Puedes añadir tantas condiciones Else como quieras dentro de una sentencia If, pero si quieres añadir más de una, tienes que escribir todas ellas, menos la última, con un Else if seguido de una nueva condición:

if(myVariable>myOtherVariable){ doSomething;}elseif(myVariable<100){ doAnotherThing;}else{ doTheLastThing;}

En el ejemplo anterior, si miVariable no es mayor que miOtraVariable, entonces pregunta si miVariable es menor que 100 y, si no es cierto, entonces realiza hazUnaUltimaCosa.

FUNCIÓN FOR

For: permite repetir un bloque en base a una condición una determinada cantidad de veces.

Requiere de tres parametros el primero es el valor inicial de la variable por ejemplo 0 el segundo parámetro es el valor verdadero que debe cumplir si esto se cumple entonces ejecuta la accion que le indicamos entre llaves y el tercero nos indica en el siguiente bucle en cuento tiene que aumentar la variable inicial por ejemplo en un led se pone ( el brillo varia de 0 a 5V 0 es o y 5 v 255)

for (brillo =0 ; brillo <256; brillo ++)

1° parametro 2° parametro 3° parametro

valor del que parte valor que debe cumplir ( no puede ser mas de 5v) condicion

15


el comando for empieza por el valor del primer parametro analiza si se cumple la del segundo parametro y si se cumple continua con lo que indica el tercer parametro sino sale , en el ejemplo empieza de 0 V despues se fija si el valor es menor a 255 (5v ) y si es verdadero al primer valor le aumenta 1

Los bucles For se usan cuando quieres repetir una parte del código un número concreto de veces. El bucle For siempre tiene tres parametros entre paréntesis, éstos son: la inicialización del contador, la condición para terminar el bucle y el incremento de tu contador.:

forint (i=0;i<200;i++){doSomething;}

En este ejemplo "int i=0;" es la inicialización del contador para el bulce For. Aquí decimos que queremos un contador con el nombre "i" y de tipo "int", y que queremos empezar a contar desde 0. Cuando hayamos terminado de definirlo, terminamos con un punto y coma, y pasamos a la segunda parte. Definimos la condición, si i<200 terminaremos el bucle. La última parte define nuestro incremento por cada pasada en el bucle. i++ incrementará el contador en una unidad por cada pasada. La primera vez, el contador estará a 0, la siguiente estará a 1 y así sucesivamente. Cuando i alcance el valor 200, la condición i<200 ya no se cumplirá, por lo que saldremos del bucle y continuaremos con el código escrito después de la llave de cierre del bucle (}).

FUNCIÓN WHILE

Un bucle While durará hasta que la condición entre paréntesis sea falsa. Si usas un bucle While, debes asegurarte que la condición debe poder variar de algún modo (incrementandose, mediante comparaciones..) de no ser así el bucle no terminaría nunca:

while(myVariable<100){doSomething;}

Este ejemplo comprueba si miVariable es menor que 100. Si es así, entonces comienza el bucle, pero si dentro de mi bucle no hay nada que haga cambiar el valor de miVariable, el bucle no terminará nunca.

En el siguiente ejemplo hemos añadido la lectura de un sensor:

while(myVariable<100){ doSomething; myVariable=readSensor;}

Ahora cada vez que se se repita el bucle, primero realizará hazAlgo, y después guardará en miVariable, el valor obtenido en la lectura del sensor. Si el valor almacenado en miVariable es superior a 100, el bucle While se detendrá y continuará leyendo el código escrito despues de la llave de cierre. Asegurate de, si estás usando un sensor para salir del bucle, éste pueda proporcionarte un valor que cumpla tu condición del bucle.

VARIABLE LONG ( PERMITE ALMACENAR 32 BITS)

16


Long: En muchos casos el tamaño de un entero nos valdrá pero, en otros, necesitaremos almacenar variables más grandes que el tamaño que nos permite el tipo "int", para ello usaremos el tipo "long". El tipo "long" extiende el rango de valores enteros (sin decimales) a un valor de 32 bits, esto es un rango de 2147483647 a – 2147483647. Igualmente esto quiere decir que un número "long" ocupará 32 bits en la memoria de Arduino y nos permitirá usar valores entre – 2147483647 y 2147483647.

longmyBigNumber=90000;

VARIABLE BYTE ( ALMACENA COMO BYTES)

Byte: Para ahorrar espacio en la memoria de Arduino, es útil almacenar las variables como bytes. Un byte es un número entero de 8 bits con un rango de 0 a 255. Con un byte ocuparemos 8 bits de la memoria de Arduino y podremos representar cualquier número entero entre 0 y 255.

bytemySmallNumber=150;

VARIABE FLOAT ( PERMITE GUARDAR DATOS DECIMALES)

Float: El único tipo de datos que puede guardar números con decimales es "float". Float tiene mayor resolución que los enteros (int, long, byte) y se guardan como un valor de 32 bits en el rango desde 3.4028235E+38 a – 3.4028235E+38. Esto quiere decir que puedes guardar un número decimal pero sólo en ese rango. Los números decimales (float) ocupan mucha memoria de Arduino. Usar decimales es mucho más lento que usar enteros, pues Arduino necesita más tiempo para realizar cálculos con éstos.

floatmydecimalNumber=2.33;

VARIABLE ARRAY ( PERMITE ALMACENAR MATRICES , POR EJ PARA UN TECLADO DE MEMBRANA)

Arrays (Matrices): A veces puede ser útil guardar una colección de valores, entonces tendremos que utilizar una matriz. Todos los valores almacenados en una matriz se guardarán con un número índice, para acceder a cualquier valor lo harás referenciando su número índice. Las matrices se declaran de igual modo que las variables (con el tipo, el nombre y los valores). El siguiente ejemplo muestra como declarar una matriz de enteros con seis valores distintos:

intmyArray[]={1,2,3,4,5,6};

Ten en cuenta que las matrices empiezan a contar desde 0. Esto significa que la primera posición de la matriz es 0. En el ejemplo anterior, el número 1 está guardado en la primera posición de la matriz, por tanto, si queremos utilizarlo lo haremos del siguiente modo:

myNumber=myArray[0];

Esto almacenará el valor de la primera posición de la matriz (el valor 1), en nuestra variable miNumero. Por otro lado, podemos almacenar valores en la matriz haciendo referencia a la posición del número que nos interesa:

myArray[0]=23;

Esto guardará el número 23 en la posición 0 de la matriz (donde antes estaba el valor 1).

Si sabes que vas a usar una cantidad de números y los quieres almacenar en una matriz, pero no sabes qué valores van a ser, puedes declarar la variable reservando el número de posiciones que quieras, del siguiente modo:

17


intmyArray[5];

Esto creará una matriz de 5 posiciones, donde 4 será la última (Recordemos que empieza a contar de 0). No intentes almacenar datos en la quinta posición, esta posición será incorrecta, pero Arduino no te avisará a la hora de comprobar el código.

VARIABLE VALUE ( PERMITE HACER OPERACIONES MATEMATICAS)

Como Arduino es un pequeño ordenador, puede hacer operaciones matemáticas. Puede realizar las operaciones matemáticas más habituales como son, la suma, la resta, la multiplicación y la división.

myValue=1+1;/* esto guardara el número 2 en myValue */myValue=4-2;/* esto guardara el número 2 en myValue */myValue=3*4;/* esto guardara el número 12 en myValue */myValue=6/2;/* esto guardara el número 3 en myValue */

Si estás usando enteros para realizar las operaciones matemáticas no podrás obtener decimales, "float" es el único tipo de variable que puede obtenerlos. En otras palabras, si quieres dividir 10 entre 6, dará 1 como resultado. Hacer cálculos demasiado largos puede producir un desbordamiento en la memoria de Arduino, ya que todo tipo de variable tiene un tamaño máximo. Realizar cálculos con números grandes ralentizará el Arduino.

Puedes realizar cálculos entre variables, a continuación tienes los diferentes cálculos que se pueden aplicar a las variables:

x++/* incrementara en 1 el valor de x. Es lo mismo que escribir x = x + 1 */x--/* decrementara en 1 el valor de x. Es lo mismo queescribir x = x - 1 */x+=y/* incrementara el valor de y al valor de x. Es lo mismo que escribir x = x + y*/x-=y/* decrementara el valor de y al valor de x. Es lo mismo que escribir x = x - y */x*=y/* multiplicara x por y. Es lo mismo que escribir x = x * y*/x/=y/* dividira x entre y. Es lo mismo que escribir x = x / y */

VARIABLE MAPEO

Supongamos que tienes un sensor que solo proporciona valores entre 50 y 200, y que tú necesitas un rango desde 0 a 500. La función "map" puede ser útil. Ésta función remapea un rango de valores a otro rango de valores. Digamos, hace una regla de 3:

myVariable =map(mySensor,50,200,0,500);/* valorSensor, valorMinSensor, valorMaxSensor, minimoDeseado, maximoDeseado */

En el ejemplo anterior estamos usando la función "map" para guardar un valor en miVariable. El valor proviene de miValor y el 50 y el 200 marcan los valores mínimo y máximo de nuestro sensor. El 0 y el 500 es el rango deseado. La función "map" asignará el valor

18


obtenido (dentro del rango del sensor, 50-200) al rango deseado (0-500). Observe que si quieres usar la función "map" debes conocer el rango que quieres "mapear".

VARIABLE RANDOM (Aleatorio(máximo))

El comando "random" devolverá un valor aleatorio en el rango comprendido entre 0 y el valor que pongas entre paréntesis. Para poder usar ese valor tienes que guardarlo en una variable.

myVariable=random(5);

Ésto guardará un número aleatorio en miVariable, dentro del rango de 0 a 4. También puedes usar el comando "random" directamente mientras haces comparaciones:

if(3==random(5)){

doSomething;

}

El comando "random" sólo devolverá un valor entre 0 y el máximo establecido, nunca devolverá ese máximo.

Random(min,max)

Si quieres un número aleatorio comprendido en un rango que comience en un valor distinto de 0, debes especificar dicho mínimo:

myVariable=random(200,300)

COMPARACIONES LÓGICAS

Si quieres realizar comparaciones en tus programas debes usar alguno de estos comparadores. Estas comparaciones se pueden realizar entre variables o con constantes, obteniendo siempre valores Verdadero o Falso.

Igual a ==

== es usado para comparar si un elemento es igual a otro. Una comparación usando == sólo será verdadero si ambos miembros de la igualdad son idénticos:

x==y/* x es igual a y */

Distinto de !=

'!= se usa para comprobar si un elemento es distinto de otro. Una comparación usando != sólo será Verdadero si un miembro es distinto del otro:

19


x!=y/* x es distinto de y */

Menor que <

< se usa para comparar si un elemento es menor que otro. Una comparación usando < sólo será Verdadero si el miembro izquierdo es menor que el derecho:

x<y/* x es menor que y

Mayor que >

> se usa para comparar si un elemento es mayor que otro. Una comparación usando > sólo será verdadero si el miembro izquierdo es mayor que el derecho:

x>y/* x es mayor que y */

Menor o igual <=

<= se usa para comparar si un elemento es menor o igual que otro. Una comparación usando <= sólo será verdadera si el miembro izquierdo es igual o menor que el derecho:

x<=y/* x menor o igual que y */

Mayor o igual >=

>= se usa para comparar si un elemento es mayor o igual que otro. Una comparación usando >= sólo será verdadera si el elemento izquierdo es mayor o igual que el derecho:

x>=y/*x es mayor o igual que y*/

OPERADORES LÓGICOS

Los operadores lógicos se usan cuando necesitas dos o más elementos en la misma sentencia, y éstos pueden ser verdaderos o falsos. Se pueden utilizar tros comparadores lógicos.

Y (&&)

Se usa para determinar si dos o más elementos son verdaderos. SI alguno de los elementos no es verdadero, la sentencia será falsa. Para que algo sea verdadero, todos los elementos deben serlo, para que sea falso, con que uno sea falso, la sentencia lo será:

20


x<y&&y>5/* x es menor que y, e y es mayor que 5 */

O (||)

Se usa para determinar si alguno de los dos elementos es verdadero. Con que alguno de los elementos sea verdadero, la sentencia será verdadera:

x < y || y > 5

/* x es menor que y, o y es mayor que 5. Nota: Los dos elementos pueden ser verdaderos */

(:sourcend:)

Negacion (!)

Se usa para determinar si algo no es verdad. Si no se cumple, la sentencia será verdadera:

x!=5/* x no es igual a 5 */

Constantes

Las constantes son palabras que Arduino utiliza y que tienen valores predefinidos. Se usan para simplificar la lectura del codigo de tu programa.

True and False (verdadero y falso)

True y False son lo que llamamos constantes Booleanas y definen si algo lo es, o no, a nivel lógico:

booleanmyBoolean=true;

Cualquier número puede usarse como operador Booleano. Por ejemplo, 200 se puede usar como operador, y si una variable tiene ése valor y lo comparamos con 200, ésto nos devolverá Verdadero:

intmyNbrBoolean=200;/* Asignamos el valor a la variable*/myNbrBoolean==200;/* Comparamos myNbrBoolean con 200, devolvera Verdadero */

También se puede escribir con un número

intmyNbrBoolean=1;

En el primer ejemplo necesitamos comparar miBooleano con otro Booleano, y en el segundo caso comparamos miOtroBooleano con otro entero.

21


Serial begin

Para permitir la comunicación de Arduino se utiliza el comando Serial.begin(). Este comando se utiliza sólo en el void setup(). Dentro de los paréntesis se introduce la velocidad de comunicación deseada en bits por segundo, lo que también se conoce como baudios, y las velocidades disponibles son 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200:

void setup(){ Serial.begin(9600);}

[Get Code]Este código abrirá el puerto serie y pone la velocidad de comunicación a 9600 baudios.

Serial println

Este comando va a imprimir lo que pones dentro de los paréntesis y añadir un final de línea. Para imprimir números enteros tiene que poner el tipo dentro de los paréntesis:

Serial.println(12345);

Sin embargo, los caracteres de impresión y cadena de caracteres debe ser citado. Si desea imprimir un solo carácter usa las comillas simples ‘ ‘:

Serial.println(‘C’);

La línea de código anterior enviará el carácter C a través del puerto serie. Si desea imprimir una cadena de caracteres, como mensaje tiene que utilizar las dobles comillas “ “

Serial.println(“Hello from Arduino”);

Serial print

El Serial.print() trabaja como el Serial.println() con la excepción que Serial.println() inserta un retorno de carro y salta a la siguiente línea. Si algo se envia por el puerto serie con Serial.println(1) el mensaje se muestra en el monitor de la siguiente manera:

1 1 1 1El avance de línea añadido por el Serial.println() es lo mismo que poner al mismo tiempo un final de linea y empezar en una nueva. Si queremos enviar Serial.print(1) través del puerto serie se recibiría como:

1111111111111111111111111111111111111

22



Tenga en cuenta que si está comunicandose con otros dispositivos electrónicos asegúrese de imprimir los datos en el formato correcto. A veces, el retorno de carro y salto de línea añadido por Serial.println() puede interferir con la comunicación. La información sobre el protocolo de comunicación adecuado para los distintos dispositivos electrónicos se pueden encontrar en la hoja de datos del dispositivo a comunicar.

Casos especiales de impresión

A veces será necesario enviar la información en diferentes formatos y entonces tiene que añadir este formato para su impresión:

Serial.println(message,format):

Los formatos disponibles son decimales, hexadecimal, octal, binario y bytes, y se utilizan como en los ejemplos siguientes:

Serial.print(b,DEC); /* Escribe 79 como código ASCII en decimal que es “79” */Serial.print(b,HEX); /* Escribe 79 como código ASCII en hexadecimal que es “4F” */Serial.print(b,OCT); /* Escribe 79 como código ASCII en octal que es “117” */Serial.print(b,BIN); /* Escribe 79 como código ASCII en binario que es “1001111” */Serial.print(b,BYTE); /* Escribe 79 como código ASCII en bytes que es “O” */

[Get Code]El ASCII (American Standard Code for Information Interchange) de codificación es una forma estándar de codificación de texto numérico. Cuando se escribe el número en su código, no está en realidad escribiendo el número, pero si el carácter representado los números, como "uno" es la palabra que representa 1.

23



Ejemplos:

24


PRACTICAS

PRÁCTICA 1

MATERIALES; 1 LED, 1 RESISTENCIA 220 OHM,

25


PRACTICA 2 ( pulsador)

MATERIALES : 1 LED , 1 PULSADOR , 1 RESISTENCIA DE 10K

26


(rojo 5v negro gnd)

se comienza indicando las conexiones

int led = 3;

int pulsador = 2;

27


void setup () {

pinMode (pulsador , INPUT) ; // indico que el pulsador es una entrada

pinMode (led, OUTPUT); // indico que el pulsador es una salida

}

void loop () {

if ( digitalRead (pulsador) ==HIGH) // se compara a ver si hay o no tensión

usando == ( esta es la condición

verdadera )

{ digitalWrite(led ,HIGH); // se indica que el led se debe encender al

pulsar (condicion verdadera)

}

else {

digitalWrite(led ,LOW) ; // se indica que si no esta pulsado se apaga

}

}

en este caso el pulsador tiene dos opciones, que este en 0V (LOW) o que este en 5V ( HIGH) si el pulsador esta apretado circula corriente ( HIGH) y si no esta apretado no circula (LOW)

para que funcione se usa la funcion if (si) lo que hace esta función es comparar si la tensión es alta (HIGH) o baja ( LOW)

primero se indica la condicion verdadera y se indica que debe suceder para el caso de que sea verdadera y luego se coloca else (sino) para determinar que debe ocurrir si la condicion no es asi

28


PRACTICA 3 ( semaforo)

MATERIALES: 3 LEDS

29


30


31


PRÁCTICA 4 ( EL COCHE FANTÁSTICO)

32


33


34


PRÁCTICA 5 ( ESTRELLA FUGAZ)

35


36


37


38


PRACTICA 6 ( SENSOR DE INCLINACIÓN)

MATERIALES:

39


40


PRÁCTICA 6 ( LECTURA DE SEÑAL ANALÓGICA)

programación variar led con potenciometro y sin potenciometro de manera que al llegar al maximo valor de luminosidad luego comience a diminuir la misma hasta apagarse

a) con

potenciometro

para el pote se usa A0

int led = 3 ;

int brillo;

int pote = 0 // como es una entrada analógica no necesita definirlo en void setup

41


void setup () {

pinMode ( led, OUTPUT);

}

void loop () {

brillo = analogRead (pote)/4; // se indica que el brillo se regula con la entrada analogica del pote

analogWrite(led,brillo); // se indica que el led cambiara su brillo con el potenciometro

}

se usa analog porque debe tomar valores analógicos ya que son los que permiten variar en toda su extension de un intervalo y así al variar la tensión varía la luminosidad del led, el digital solo puede ir de un extremo a otro por ej 0 o 5V en cambio el analógico va de 0 a 5V pasando por todos los valores intermedios , el valor que puede tomar en la placa arduino es de 0 a 255 donde 0 es 0V y 255 es 5V, por ejemplo si quiero trabajar con una tensión máxima de 2,5V tomare como valor maximo 127 ya que 2,5 es la mitad de 5 y 127 de 255, hago un proporcional para cada Voltaje

las variables analógicas trabajan con valores de 0 a 1023, pero analog write trabaja con valores de 0 a 255 esto hace que no se puede usar ese valor entonces para poder hacerlo se divide por 4 el valor de analogRead que es lo que lee el potenciometro asi al hacer 1023 /4 = 255,75 entonces al trabajar con enteros se toma ese valor 255 asi al divido por 4 tendre la variable dada por analog read dentro del rango de trabajo del analogWrite

b) sin potenciometro

int led = 3 ;

int brillo;

void setup () {

pinMode ( led, OUTPUT);

}42


void loop () {

for ( brillo = 0 ; brillo < 256 ;brillo ++ ) {

analogWrite (led,brillo); // el led ira aumentando el brillo de brillo 0, el siguiente 1 asi hasta 255

delay (15);

}

for ( brillo = 255 ; brillo >= 0 ;brillo -- ) {

analogWrite (led,brillo); // el led ira disminuyendo el brillo de brillo 255, el siguiente 254 asi hasta 0

delay (15);

}

}

se usan dos for en este caso debido a que se quiere que aumente el brillo y despues cuando llegue al maximo disminuya de lo contrario al llegar al maximo valor se apagaria y volveria a empezar de 0

PRÁCTICA 7: ( NSTRUCCIÓN DE UN INDICADOR DE NIVEL)

43


44


PRÁCTICA 9 ( SERVOMOTOR)

Funcionamiento de servomotores

45


naranja: señal( se conecta al pin digital) , rojo vcc, negro gnd,

el servo permite un movimiento de giro de 180°, si se le envia una señal durante 20 ms y un pulso de 1 ms indica 0° si se envia un pulso de 2 ms se le indica que gire 180° cualquier valor intermedio da el resto de los angulos entre ellos

Cuando se trabaja con servomotores se debe alimentar en forma externa ya que la tension que suministra el cable usb de la computadora no es suficiente para que funcione el servomotor.

Los valores deben ser de 7,5 a 12 V

y hasta 750 mA

46


para usar los servomotores arduino tiene una librería, esta librería es un conjunto de funciones que se pueden usar en el codigo, para usarla se coloca

#include <Servo.h>

Servo servo1; // esto crea un objeto tambien puedo llamarlo por ej motor 1 entonces pongo Servo motor1

luego ponemos el pin donde vamos a conectar el servo y el valor de pulso mínimo y máximo del servo, estos valores si bien son 1 ms y 2 ms , no puedo ponerlo en esa unidad ya que se generaria una redundancia con el valor del pin entonces se pone como 1000 y 2000 respectivamente ya que se expresa en microsegundos

int pinservo = 2;

int pulsominimo = 1000; // equivale a 0 ° ( VA 1000 Y NO 1 SINO SE CONFUNDIRIA CON EL PIN)

int pulsomaximo = 2000; // equivale a180°

para controlar el servo se usa la función attach, esta permite inicializar el servo , la funcion tiene tres variables la primera el pin donde se conecta el servo, la segunda el valor de pulso minimo y la tercera el valor de pulso maximo, quedando

void setup() {

servo1.attach(pinservo,pulsominimo,pulsomaximo);

}

en este caso se utiliza la función write para indicarle la posición en la que se debe ubicar el servo

void loop() {

servo1.write(0);

delay(5000);

47


servo1.write(180);

delay(5000);

}

el codigo queda entonces

#include <Servo.h>

Servo servo1; // esto crea un objeto tambien puedo llamarlo por ej motor 1 entonces pongo Servo motor1

int pinservo = 2;

int pulsominimo = 1000; // equivale a 0 °


void setup() {


}

void loop() {

servo1.write(0);

delay(5000);

servo1.write(180);

delay(5000);

}

48


si el angulo que se desplaza el servo no es de 180° se debe variar los valores de pulso maximo y minimo hasta encontrar el adecuado para ese motor ( el valor es 700, 2350 )

motores funcionando con potenciometro

se agregara un potenciometro que nos va a permitir mover el servo, como el pote va a ir conectada a salida analogica no es necesario definirlo pero si se va a definir una variable para que lea al potenciometro ( valorpot) el angulo que tiene que moverse el servo y el valor inicial del pote o sea 0

#include <Servo.h>

Servo servo1;

int pinservo = 2;



int valorpote;

int angulo;

int pote = 0;

void setup() {


}

en void loop se va a definir la forma como se usa el potenciometro para que haga mover el motor

49


el valor del pote se debe definir como una entrada analogica por eso al valorpote se la asocia con analogRead.

Para el angulo se usa una funcion llamada map, en esta se convierte la señal analogica en un rango de angulo valor analogico que lee el potenciometro sera 0 y 1023 y este se convierte en una rango de 0 a 180 °, este resultado se asigna a la variable angulo y se coloca un delay para darle tiempo al servo a llegar a su posicion cuanto mas pesado sea el objeto que mueva el servomotor se debe aumentar este tiempo

void loop() {

valorpote = analogRead(pote);

angulo = map(valorpote,0,1023,0,180)

servo1.write(angulo);

delay(20);

}

el programa queda asi entonces

#include <Servo.h>

Servo servo1;

int pinservo = 2;



int valorpote;

int angulo;

int pote = 0;

50


void setup() {


}

void loop() {

valorpote = analogRead(pote);

angulo = map(valorpote,0,1023,0,180)

servo1.write(angulo);

delay(20);

}

PRACTICA 10

RELE

51


El relé permite con una tensión de 5 V se puedan abrir circuitos con otras tensiones

Cuando la corriente circula por la bobina se genera un campo electromagnético que mueve el brazo superior del relé se vincula con el terminal común, cuando no circula corriente el terminal común esta en contacto con NC si se aplica tensión se genera un campo electromagnético se mueve el brazo y el terminal común pasa a normal abierto este campo se genera con 5 V y al entrar en contacto el terminal común con el normal abierto entonces se cierra el circuito.

Módulo Relé

52


dentro del módulo de relé se tiene un octoacoplador y alli un led y un transistor, este transistor es fotosensible y funciona cuando el led se enciende, entonces al circular corriente por el led , se enciende y hace funcionar al transistor, este enciende el transistor NPN y hace funcionar el relé.

El octacoptador es un elemento de protección ya que como el relé es mecanico puede fallar si esto pasa puede quemar el transistor pero nunca al led que no tiene contacto con el relé y si con la placa arduino, entonces si se falla el relé no afecta al arduino.

Esquema de conexión

53


54


rojo = gnd verde = 5V negro = pin

se indica primero el pin del relé

en void setup se define como salida y en el void loop se enciende por 5 seg el relé

el relé se activa con un nivel bajo y se apaga con un nivel alto

int rele =2;

void setup() {

pinMode(rele, OUTPUT);

}

void loop() {

digitalWrite(rele, LOW);

delay(5000);

55


digitalWrite(rele, HIGH);

delay(5000);

}

PRACTICA 11 TECLADO DE MEMBRANA

realizar la programación de una clave de una puerta

Cuando se apreta el botón se cierra el circuito

conexiones

56


código

cada vez que se usa el teclado este primer grupo de fila siempre se pone

aca se reemplaza byte en lugar de int , byte tiene una longitud de 8 bits , la mitad de int y permite almacenar valores entre 0 y 255 mientras que int tiene 16 bits y permite almacenar valores desde -32768 y 32768.

const es constante y esta le dice que el valor no puede ser modificado, o sea que si le damos un valor 4 en el programa no se puede modificar luego ( trabajo en este programa con 4 filas)

array :

57


el array es un conjunto de valores a los que se puede acceder mediante un índice , en este caso si tomara un array ( llamado MIARRAY) el tamaño se establece con el número entre corchetes por ej si tiene [6] indica que hay 6 espacios para almacenar, cada valor debe estar asociado a un número de índice, se suele asignar como i

índice inicial el valor 0, o sea el primer valor tiene índice 0 , el segundo valor índice 1 y así sucesivamente

esto se asigna indicando

VALOR = MIARRAY[0]// VALOR = 1

#include <Keypad.h> // importa libreria Keypad

const byte FILAS = 4; // define numero de filas

const byte COLUMNAS = 4; // define numero de columnas

este bloque permite definir la distribución del teclado

char keys[FILAS][COLUMNAS] = { // define la distribucion de teclas

{'1','2','3','A'},

{'4','5','6','B'},

{'7','8','9','C'},

{'*','0','#','D'},

}

se define los pines que usaran las filas y columnas

byte pinesFilas[FILAS] = {9,8,7,6}; // pines correspondientes a las filas

byte pinesColumnas[COLUMNAS] = {5,4,3,2}; // pines correspondientes a las columnas

Keypad teclado = Keypad(makeKeymap(keys), pinesFilas, pinesColumnas, FILAS, COLUMNAS); // crea objeto

HASTA ESTE BLOQUE SIEMPRE SE COPIA EXACTAMETE IGUAL CUANDO USE UN TECLADO DE MEMBRANA

char significa carácter, esto permite ingresar un numero, una letra un asterisco etc y observarlo

58


se quiere hacer una clave de ingreso para ello se debe comparar la clave ingresada con una clave maestra y si coinciden se abre la puerta, si bien la clave es de 6 digitos se le asigna 7 caracteres porque uno será nulo

char TECLA; // almacena la tecla presionada

char CLAVE[7]; // almacena en un array 6 digitos ingresados

char CLAVE_MAESTRA[7] = "123456"; // almacena en un array la contraseña maestra

byte INDICE = 0; // indice inicial del array

se indica en el void setup que se va a visualizar lo que se introduzca en el teclado

void setup()

{

Serial.begin(9600); // inicializa comunicacion serie

}

void loop(){

TECLA = teclado.getKey(); // obtiene tecla presionada y asigna a variable

if (TECLA) // comprueba que se haya presionado una tecla

{

CLAVE[INDICE] = TECLA; // almacena en array la tecla presionada

INDICE++; // incrementa indice en uno, indica que el segundo valor va en el segundo índice

Serial.print(TECLA); // envia a monitor serial la tecla presionada

}

con la funcion if lo que hacemos es determinar, si ya hay 6 dígitos introducidos, entonces compara la clave introducida con la maestra ( función stream compear (strcmp) si es la misma devolvera e valor correcta, sino incorrecta

59


if(INDICE == 6) // si ya se almacenaron los 6 digitos

{

if(!strcmp(CLAVE, CLAVE_MAESTRA)) // compara clave ingresada con clave maestra

Serial.println(" Correcta"); // imprime en monitor serial que es correcta la clave

else

Serial.println(" Incorrecta"); // imprime en monitor serial que es incorrecta la clave

INDICE = 0;

}

}

codigo terminado

#include <Keypad.h> // importa libreria Keypad

const byte FILAS = 4; // define numero de filas

const byte COLUMNAS = 4; // define numero de columnas

char keys[FILAS][COLUMNAS] = { // define la distribucion de teclas

{'1','2','3','A'},

{'4','5','6','B'},

{'7','8','9','C'},

{'*','0','#','D'},

};

byte pinesFilas[FILAS] = {9,8,7,6}; // pines correspondientes a las filas

60


byte pinesColumnas[COLUMNAS] = {5,4,3,2}; // pines correspondientes a las columnas

Keypad teclado = Keypad(makeKeymap(keys), pinesFilas, pinesColumnas, FILAS, COLUMNAS); // crea objeto

char TECLA; // almacena la tecla presionada

char CLAVE[7]; // almacena en un array 6 digitos ingresados

char CLAVE_MAESTRA[7] = "123456"; // almacena en un array la contraseña maestra

byte INDICE = 0; // indice del arra

void setup()

{

Serial.begin(9600); // inicializa comunicacion serie

}

void loop(){

TECLA = teclado.getKey(); // obtiene tecla presionada y asigna a variable

if (TECLA) // comprueba que se haya presionado una tecla

{

CLAVE[INDICE] = TECLA; // almacena en array la tecla presionada

INDICE++; // incrementa indice en uno

Serial.print(TECLA); // envia a monitor serial la tecla presionada

}

61


if(INDICE == 6) // si ya se almacenaron los 6 digitos

{

if(!strcmp(CLAVE, CLAVE_MAESTRA)) // compara clave ingresada con clave maestra

Serial.println(" Correcta"); // imprime en monitor serial que es correcta la clave

else

Serial.println(" Incorrecta"); // imprime en monitor serial que es incorrecta la clave

INDICE = 0;

}

}

62

PRÁCTICA 9

SENSOR LDR

Ldr

Led

Resistencia 4,7 k

Resistencia 120 ohm

62


const int FOTOPIN = A0;

int valorSensor = 0;

const int LED = 3;

int valorMapeado = 0;

void setup() {

pinMode(FOTOPIN, INPUT);

pinMode(LED, OUTPUT);

Serial.begin(9600);

}

63


void loop() {

valorSensor = analogRead(FOTOPIN);

valorMapeado = map(valorSensor, 900, 640, 0, 255);

analogWrite(LED, valorMapeado);

Serial.print("Valor del Sensor: ");

Serial.println(valorSensor);

Serial.print("Valor del Sensor Mapeado: ");

Serial.println(valorMapeado);

}

PRACTICA 10

BUZZER

1 BUZZER

RESISTENCIA 100 OHM

64


1. Int buzzer = 4;2. void setup()3. {4. pinMode(buzzer, OUTPUT); // sets the pin as output5. }6. 7. void loop()8. {9. analogWrite(buzzer,128); //emite sonido10. delay(500); //espera medio segundo11. digitalWrite(buzzer, LOW); //deja de emitir12. delay(500);//espera medio segundo13. }

PRACTICA 11

MELODIA 8 GENERADOR DE NOTAS

//generador de notas

int piezo=10;

int notas[]={659.25,698.26,783.99,783.99,698.46,659.26,587.33,544.37,544.37};//cadenas que corresponden a los tiempos de las distintas notas

int n=0;

65


int m=0;

int tnota=100;//n° de repeticiones del pulso, da la duracion de la nota

int pausa=100;

void setup(){

pinMode(piezo,OUTPUT);

}

void loop(){

for(n=0;n<9;n++){//iteracion que recorre la lista con las 8 notas

for(m=0;m<=tnota;m++){

digitalWrite(piezo,HIGH);

delayMicroseconds(notas[n]);//tiempo en el que esta a 5V la salida del piezoelectrico

digitalWrite(piezo,LOW);

delayMicroseconds(notas[n]);//tiempo que esta a 0V

}

delay(pausa);

}

PRACTICA 12

TIMBRE

int zumbador=6;

int boton=2;

void setup()

{

66


pinMode(6,OUTPUT);

pinMode(2,INPUT);

}

void loop()

{

int boton=digitalRead(2);

if(boton==1){

tone(6,440);

}

else{

noTone(6);

}

}

PRACTICA 13

Timbre con botón + led

67


const int pinBoton = 12; // pin del botón

const int pinLed = 10; // pin del led

const int pinBuzzer = 9; // pin del buzzer

int estadoBoton = 0; // variable para el valor del estado del botón

void setup() {

// pin del buzzer como salida

pinMode(pinBuzzer, OUTPUT); // pin del buzzer como salida

pinMode(pinLed, OUTPUT); // pin del botón como entrada

pinMode(pinBoton, INPUT);

}

68


void loop() {

estadoBoton = digitalRead(pinBoton); // lee el valor del estado del botón con pinBoton y lo guarda en la variable estadoBoton

// revisa el estado con un if

if (estadoBoton == HIGH) { // si es HIGH, el botón esta oprimido

digitalWrite(pinLed, HIGH); // así que enciende el pin

tone (9, 440, 200);

}

else // si no es el caso, entonces

{

digitalWrite(pinBuzzer, LOW); // el botón no esta oprimido, así que apaga el led

digitalWrite(pinLed, LOW); // el botón no esta oprimido, así que apaga el led

}

}

PRACTICA 14

TIMBRE CON DOS PULSADORES

69


int boton1=2;int boton2=4;int buzzer = 7;int buttonState1 = 0;int buttonState2 = 0;void setup() {// put your setup code here, to run once:tone(7,3000,1000); pinMode(boton1, INPUT);pinMode(boton2, INPUT);pinMode(buzzer, OUTPUT);}void loop() { // put your main code here, to run repeatedly:buttonState1 = digitalRead(boton1);buttonState2 = digitalRead(boton2);if (buttonState1 == HIGH) {tone(7,440,1000); } else if (buttonState2 == HIGH){tone(7,1000,1000);}

}

70


int zumbador=6;

int boton=2;

void setup()

{

pinMode(6,OUTPUT);

pinMode(2,INPUT);

}

void loop()

{

int boton=digitalRead(2);

if(boton==1){

tone(6,440);

}

else{

noTone(6);

}

}

PRACTICA 15

MOTOR

SERVO MOTOR

POTENCIOMETRO

71


#include <Servo.h>

Servo servo1;

void setup()

{

servo1.attach(3);//pin donde se conecta el servo1

}

void loop()

{

int val1=analogRead(3);//valor que devuelve el servo1

val1=map(val1,0,1023,0,179);//el valor varia entre 0 y 180 grados el valor anlogico va desde 0 a 1023 digital es 0 a 180

servo1.write(val1);

delay(15);

}

72


PRACTICA 16

VARIOS SERVOS

#include <Servo.h>

Servo servo1;

Servo servo2;

void setup()

{



}

void loop()

{


val1=map(val1,0,1023,0,179);//el valor varia entre 0 y 180 grados el valor anlogico va desde 0 a 1023 digital es 0 a 180

servo1.write(val1);

delay(15);


val2=map(val2,0,1023,0,179); //valor servo2

servo2.write(val2);

delay(15);

}

MUSICA

73


Crear música con Arduino o sonidos sueltos es relativamente fácil y suele ser una práctica muy interesante para hacer con alumnos que están empezando a familiarizarse con la programación.

En principio únicamente vamos a necesitar un zumbador piezoeléctrico y la placa de Arduino para poder generar música con Arduino. Una vez se comprende la generación de sonidos se pueden realizar proyectos más complejos implementando un pequeño instrumento electrónico donde le podamos indicar notas mediante teclas, sensores capacitivos, sensores de ultrasonidos, etc.

Un zumbador piezoaeléctrico consigue generar un sonido al vibrar en la frecuencia de la señal eléctrica que recibe. El valor en frecuencia de la señal determinará el tono en el que suene el piezoeléctrico. Es un sonido de muy baja calidad pero vamos a poder generar notas y con ello música.

Si usamos una interfaz de programación basada en Scratch como mBlock seguramente tengamos bloques disponibles para realizar sonidos, únicamente tendremos que tener en cuenta la notación anglosajona para “traducir” una partitura. Para familiarizarte con la programación de música mediante bloques te recomiendo que leas la entrada Música con mBot que es aplicable igualmente a Arduino.

En esta ocasión vamos a generar música con Arduino mediante código porque va a ser la manera de poder hacer sonar nuestro proyecto en cualquier nota que aparezca en la partitura que consultemos, ya que vamos a poder programar también sostenidas, algo que no se puede hacer por ejemplo con mBlock.

74

https://juegosrobotica.es/musica-con-mbot/


Vamos a hacer uso de la instrucción tone cuyos argumentos son el pin de salida al cual tenemos conectado el zumbador, la frecuencia de la señal que vamos a generar y que es la que variará la nota y la duración en milisegundos (opcional). Con varias instrucciones tone podremos hacer música con Arduino.

tone(pin, frecuencia)

tone(pin, frecuencia, tiempo)

El pin de salida debe ser de tipo PWM ya que debemos poder variar su frecuencia. En Arduino Uno, Mini y Nano podrán ser 3, 5, 6, 9, 10 y 11

La frecuencia adecuada para cada nota la tenéis en una tabla al final del tutorial.

El tiempo es la duración de la nota. Cada figura tendrá un tiempo determinado por el tiempo de la negra (t),de tal manera que una blanca durará doble que una negra y una corchea la mitad. La relación de los tiempos de las figuras es fija, pero el tempo lo vamos a marcar nosotros. Si no declaramos el tiempo en la instrucción tone deberemos hacer un delay con la duración y utilizar la instrución noTone posteriormente.

Por ejemplo si establecemos que una negra sea 1 segundo nos quedaría lo siguiente:

Figura Tiempo(ms)

Blanca 2000

Negra 1000

75


Corchea 500

Semicorchea 250

Fusa 125

Utilizaremos la instrucción noTone si no indicamos un tiempo en la instrucción tone. Esta instrucción indica que se deje de emitir la señal por el pin indicado.

noTone(pin)

Con esto ya podemos generar música con Arduino o notas musicales sueltas.

Debemos conectar el zumbador con su patilla marcada como negativa a masa (GND) y la patilla marcada como positiva a nuestro pin con posibilidad de salida PWM. No te preocupes si lo conectas al revés, simplemente no funcionará y tendrás que cambiarlo, pero no habrá humo en tu lugar de trabajo.

Este puede ser un ejemplo para hacer sonar una semicorchea Do de la 4ª octava (según los timepos de ejemplo de la tabla de arriba) a través del pin 3:

void setup(){pinMode(3, OUTPUT); // Fija el pin 3 como salida.}

void loop(){tone(3, 261.63, 250); // Lanza señal a 261,63Hz por el pin 3 durante 250ms.}

Este bucle sería equivalente a poner:

76


void loop(){tone(3,261.63); // Lanza señal a 261,63Hz por el pin 3.delay(250); // Espera 250ms.noTone(3); // Dejamos de emitir la señal.}Si la música con Arduino que queremos crear es una melodía relativamente larga lo mejor es utilizar arrays para almacenar todas las notas (frecuencias) y todos los tiempos.

Primero definimos los arrays:

long DO=523.25, //definimos las frecuencias de las notas DoS=554.37, RE=587.33, RES=622.25, MI=659.26, FA=698.46, FAS=739.99, SOL=783.99, SOLS=830.61, LA=880, LAS=932.33, SI=987.77, RE2=1174.66, FAS2=1479.98, PAU=30000; //pausaint melodia[] = {SI, RE2, SI, RE2, PAU, SI, LA, SI, SI, SI, PAU, RE2, SI, SI, PAU, RE2, PAU, RE2, RE2, PAU, SI, RE2, SI, RE2, PAU, SI, LA, SI, SI, SI, PAU, RE2, SI, SI, PAU, RE2, PAU, RE2, RE2, PAU, RE2, PAU, SI, RE2, PAU, SI, RE2, PAU, SI, RE2, PAU, SI, PAU, RE2, SI, LA, SI, PAU, RE2,PAU, SI, RE2, PAU, SI, RE2, PAU, SI, RE2, PAU, SI, PAU, RE2, SI, LA, SI, PAU, FAS2, PAU, RE2, FAS2, PAU, RE2, FAS2, PAU, RE2 ,FAS2, PAU, RE2, FAS2, PAU, RE2, LA, SOLS, SI, PAU, FAS2, PAU,RE2, FAS2, PAU, RE2, FAS2, PAU, RE2, FAS2, PAU, RE2, FAS2, PAU, RE2, LA, SI, SI};int d=1000, e=500, m=250, c=125; //definimos los tiempos de doble, entera, media y cuartaint duracionNota[] = {m, m, m, m, e, c, m, m, c, m, e, m, m, m, e, m, m, m, m, d, m, m, m, m, e, c, m, m, c, m, e, m, m, m, e, m, m, m, m, d,m, m, m, m, m, m, m, m, m, m, m, m, c, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m,m, m, m, m, m, m, m, m, m, m, m, m, c, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m,};En el bucle incluiremos los arrays dentro de la función tone:

for (int notaActual = 0; notaActual < 112; notaActual++) { //va a repetir las 112 notastone(11, melodia[notaActual]); //da el tono a la frecuencia de la nota en ese momentodelay(duracionNota[notaActual]);//se mantiene con la nota el tiempo definido para esa nota

77


noTone(11); //finaliza la melodía}

78


79


PRACTICA 18

Marcha sith

//led for visualization (use 13 for built-in led)

int speakerPin = 10;

//speaker connected to one of the PWM ports

#define c 261

#define d 294

80


#define e 329

#define f 349

#define g 391

#define gS 415

#define a 440

#define aS 455

#define b 466

#define cH 523

#define cSH 554

#define dH 587

#define dSH 622

#define eH 659

#define fH 698

#define fSH 740

#define gH 784

#define gSH 830

#define aH 880

//frequencies for the tones we're going to use

//used http://home.mit.bme.hu/~bako/tonecalc/tonecalc.htm to get these

void setup()

{

pinMode(speakerPin, OUTPUT);

81


//sets the speakerPin to be an output

}

void loop() // run over and over again

{

march();

}

void beep (unsigned char speakerPin, int frequencyInHertz, long timeInMilliseconds)

{

int x;

long delayAmount = (long)(1000000/frequencyInHertz);

long loopTime = (long)((timeInMilliseconds*1000)/(delayAmount*2));

for (x=0;x<loopTime;x++)

{

digitalWrite(speakerPin,HIGH);

delayMicroseconds(delayAmount);

digitalWrite(speakerPin,LOW);

delayMicroseconds(delayAmount);

}

delay(20);

//a little delay to make all notes sound separate

82


}

void march()

{

//for the sheet music see:

//http://www.musicnotes.com/sheetmusic/mtd.asp?ppn=MN0016254

//this is just a translation of said sheet music to frequencies / time in ms

//used 500 ms for a quart note

beep(speakerPin, a, 500);



beep(speakerPin, f, 350);

beep(speakerPin, cH, 150);





//first bit

beep(speakerPin, eH, 500);


83



beep(speakerPin, fH, 350);


beep(speakerPin, gS, 500);




//second bit...

beep(speakerPin, aH, 500);




beep(speakerPin, gSH, 250);

beep(speakerPin, gH, 250);

beep(speakerPin, fSH, 125);



delay(250);

beep(speakerPin, aS, 250);

beep(speakerPin, dSH, 500);

84


beep(speakerPin, dH, 250);

beep(speakerPin, cSH, 250);

//start of the interesting bit


beep(speakerPin, b, 125);


delay(250);









//more interesting stuff (this doesn't quite get it right somehow)





85


beep(speakerPin, gSH, 250);

beep(speakerPin, gH, 250);




delay(250);

beep(speakerPin, aS, 250);

beep(speakerPin, dSH, 500);

beep(speakerPin, dH, 250);

beep(speakerPin, cSH, 250);

//repeat... repeat


beep(speakerPin, b, 125);


delay(250);






86



beep(speakerPin, c, 125);


//and we're done \ó/

}

BIBLIOTECA

Ubicación en placa Void setup Void loopLed int led = pinMode(led, OUTPUT) {

digitalWrite(led, HIGH); delay( ); digitalWrite(led, LOW); delay ( );

Pulsador int led= ;int boton= ;

{ pinMode(led,OUTPUT);pinMode(boton,INPUT);}

{ int boton=digitalRead(boton); if(boton==1){ digitalWrite(led,HIGH); } else{ digitalWrite(led,LOW); }}

Sensor movimiento

int ledPin= ;//ledint inPin= ;//sensorint value=0; //valor que toma el sensor

pinMode(ledPin,OUTPUT); pinMode(inPin,INPUT);

value=digitalRead(inPin);//lee el valor del sensor digitalWrite(ledPin,value);

Potenciómetro int ledPin=12;int potPin=2;

pinMode(ledPin,OUTPUT); value=analogRead(potPin);//lee el valor del sensor

87


int value=0; //valor que toma el sensor

digitalWrite(ledPin,HIGH);//enciende el led digitalWrite(ledPin,LOW);//apaga el led delay(value);//detiene el programa un tiempo

Sensor ldr const int FOTOPIN = A0;int valorSensor = 0;const int LED = 3;int valorMapeado = 0;

pinMode(FOTOPIN, INPUT); pinMode(LED, OUTPUT); Serial.begin(9600);

valorSensor = analogRead(FOTOPIN); valorMapeado = map(valorSensor, 900, 640, 0, 255);//valores de luminosidad analogWrite(LED, valorMapeado);

Serial.print("Valor del Sensor: "); Serial.println(valorSensor); Serial.print("Valor del Sensor Mapeado: "); Serial.println(valorMapeado);

Buzzer Int buzzer = 4; pinMode(buzzer, OUTPUT);

analogWrite(buzzer,128); //emite sonido

14. delay(500); //espera medio segundo

15. digitalWrite(buzzer, LOW); //deja de emitir delay(500);//espera medio segundo

timbre int zumbador=x;int boton=y;

pinMode(x,OUTPUT);pinMode(y,INPUT);

{ int boton=digitalRead (y); if(boton==1){ tone(x ,440);//se indica un tono ( ej 440) } else{ noTone(x); }}

Servo motores #include <Servo.h>Servo motor1;


int val1=analogRead(3); val1=map(val1,0,1023,0,179); servo1.write(val1); delay(15);

88


89

escuelatecnicajorgenewbery.files.wordpress.com · Web viewARDUINO ARDUINO: Es una tarjeta...

Documents

Transcript of escuelatecnicajorgenewbery.files.wordpress.com · Web viewARDUINO ARDUINO: Es una tarjeta...