Comandos mínimos en

arduino
SEMAN IV
min(x, y)
• Calcula el mínimo de dos números para cualquier tipo de datos
devolviendo el número más pequeño.

• valor = min(valor, 100); // asigna a valor el más pequeños de los dos números
especificados.

• Si 'valor' es menor que 100 valor recogerá su propio valor

• si ´valor´ es mayor que 100 valor pasara a valer 100.
max(x, y)
• Calcula el máximo de dos números para cualquier tipo de datos
devolviendo el número mayor de los dos.

• valor = max(valor, 100); // asigna a valor el mayor de los dos números 'valor’
y 100.

• De esta manera nos aseguramos de que valor será como mínimo 100.
randomSeed(seed)
• Establece un valor, o semilla, como punto de partida para la función
random().

• randomSeed(valor); // hace que valor sea la semilla del random

• Debido a que Arduino es incapaz de crear un verdadero número aleatorio,

randomSeed le permite colocar una variable, constante, u otra función de
control dentro de la función random, lo que permite generar números
aleatorios "al azar". Hay una variedad de semillas, o funciones, que pueden
ser utilizados en esta función, incluido millis () o incluso analogRead () que
permite leer ruido eléctrico a través de un pin analógico.
random(max)
random(min, max)
• La función random devuelve un número aleatorio entero de un
intervalo de valores especificado entre los valores min y max.

• valor = random(100, 200); // asigna a la variable 'valor' un numero aleatorio

comprendido entre 100-200

• Nota: Use esta función después de usar el randomSeed().

Elementos de control de flujo
• El lenguaje de programación de Arduino, como muchos lenguajes de
programación, ha heredado características de los primeros lenguajes
de programación BASIC, estas características incluyen sentencias para
el control del flujo como Goto, Return y Break.
• en muchas ocasiones rompen el flujo de programa y dificultan la
comprensión del mismo.
Goto
• Esta sentencia realiza un salto a cualquier parte del programa que este
marcada con la etiqueta correspondiente, la posición desde la que
realicemos el salto quedará almacenada en la pila del programa para que
podamos regresar al lugar desde donde realicemos el salto.

• Los saltos que podemos realizar con Arduino están limitados a la pila de
programa, no pueden ser infinitos, por lo que no es recomendable anidar
bucles y saltos, ya que podemos romper el flujo de programa
Return
• Termina una función y devuelve un valor desde una función a la
función que llama, si se desea.
Lo que escribamos por debajo de return en la función donde lo
usemos, no se ejecutará nunca. Ya que, cuando llega a return, vuelve
a la función que lo llamó..
Break
• es una sentencia que se debe de evitar a toda costa, tan solo
debemos usarla cuando sea totalmente necesario. Esta sentencia
rompe la iteración del bucle donde se encuentre, haciendo salir al
programa del bucle sin tener en cuenta que se cumplan las
condiciones para salir del mismo.
Entradas y salidas E/S
• cuenta con pines E/S para
comunicarse con el exterior. Estos
pines E/S tienen características
especiales que los hacen propicios
para una u otra tarea en función
del tipo de pin. Estas E/S pueden
englobarse en 3 tipos básicos, E/S
analógicas, E/S digitales y E/S para
la comunicación serie.
• Existen también pines de
propósito especiales como salidas
de reloj u osciladores y pines de
alimentación con los que
podemos suministrar diferentes
tensiones a placas externas
• Los pines de Arduino están configurados por defecto como entradas, por
lo que no es necesario indicarles el modo de trabajo si vamos a trabajar
con ellos como entradas.
• Las entradas se encuentran en un estado de alta impedancia, lo que va a
evitar en muchos casos que dañemos la placa al realizar una mala
conexión. Si establecemos un pin como salida y por error entra corriente
por dicho pin lo más seguro es que dañemos el microcontrolador de
manera irreversible.
• Los pines que tengamos configurados como salida (OUTPUT) van a
suministrar una corriente máxima de 40mA por separado, sin que la
corriente total de las salidas pueda superar los 200mA. Esta corriente es
suficiente para hacer brillar un led, pero insuficiente para activar
elementos de mayor potencia.
E/S Digitales
• Los pines asignados a E/S digitales, son pines que trabajan con dos
estados HIGH (alto) o LOW (BAJO). Según el modelo de Arduino que
estemos usando, va a tomar el estado HIGH (alto) como 5v o como
3.3v, el estado LOW (bajo) está asociado a un nivel de voltaje 0.
Lectura de entradas digitales (digitalRead)
• Al hacer una lectura digital, vamos a leer el valor de un pin
almacenando el resultado como HIGH (alto o 1) o como LOW (bajo o
0).

• valor = digitalRead (pin); //la variable "valor" toma el estado asociado al pin

• Podemos especificar el pin asignándole directamente la numeración

del pin digital que queremos leer o con una variable o constante
previamente definida.
Escritura de salidas digitales (digitalWrite)
• Cuando hacemos una escritura digital vamos a mandar al pin definido previamente como salida el valor
HIGH o LOW. El valor HIGH se va a traducir (en función del tipo de Arduino) por una señal de 5 o 3.3 voltios.

• digitalWrite (pin, HIGH); //Establece el pin en estado alto (5 o 3.3v)

E/S Analógicas
• para poder interactuar con el entono no nos es suficiente con
detectar o no una señal o poder activar o desactivar cosas, sino que
necesitamos cuantificar el valor de magnitudes reales y responder en
proporción.
• Para poder leer y escribir valores analógicos, Arduino cuenta con una
serie de E/S destinadas a este fin, con las que podremos leer y escribir
niveles de tensión que irán de 0 a 5 o 3.3v (dependiendo del modelo
de Arduino que estemos usando).
Lectura de entradas analógicas (analogRead)
• La función analogRead realizará una lectura del pin analógico que se le
indique, almacenando el valor leído en un registro de 10 bit's. Almacenar
este valor en un registro de 10 bit's va a implicar que tengamos un rango
de valores que va de 0 a 1023, asignándole el 0 a un nivel de 0 voltios y el
1024 a un nivel de 5 voltios, lo que va a determinar la resolución que
podemos obtener al hacer lecturas analógicas.

• valor = analogRead (pin); //la variable valor toma el nivel del pin analógico

• Los pines de entrada analógicos no necesitan ser declarados como entrada

(INPUT), ya que son siempre entradas.
Escritura de salidas analógicas (analogWrite)
• Las salidas analógicas están
asociadas a los pines PWM (Pulse
Width Modultation) o modulación
por ancho de pulso, estos pines,
son pines digitales, pero con la
particularidad de poseer el PWM,
y es que realmente Arduino no
entrega a la salida una señal
analógica pura, sino que consigue
un nivel de tensión determinado
por medio de la modulación del
ancho de pulso.
• El nivel de tensión que tendremos a
la salida del pin, va a ser igual al nivel
de tensión promedio proporcional al
ancho de los pulsos.
• Como se observa en la imagen
superior, variando en ancho del
pulso, podemos obtener una señal
promedio equivalente. Para la
primera señal, cuyo ancho de pulso
es del 10%, nos daría una señal
analógica de 0.5v (el 10% de 5V),
para la segunda una señal de 2.5v y
para la tercera señal obtendríamos
una señal equivalente de 4.5v.
• Las salidas analógicas trabajan con registros de 8 bit's, o lo que es lo
mismo, pueden tomar valores comprendidos entre 0 y 255,
correspondiendo el 0 a un nivel de 0 voltios y el 255 al máximo voltaje
(5 o 3.3 voltios dependiendo de la placa que estemos usando).

• analogWrite (pin, valor); //saca por el pin el nivel de tensión equivalente a

valor
• con entradas y salidas analógicas hay que tener en cuenta que al
realizar una lectura analógica el resultado se guarda en una variable
de 10 bit's, pero la escritura se hace con una variable de 8 bit's, por lo
que si queremos usar el valor leído para escribir en algún pin, primero
deberemos de adaptar la variable de 10 a 8 bit's, si no hacemos esto,
el valor que escribamos va a estar fuera de rango y no va a mostrar el
nivel de tensión correcto.
Puerto serie
• una serie de pines que tienen la capacidad de comunicarse con otros
dispositivos usando la comunicación serie para ello. Con esta
comunicación serie se puede realizar también una comunicación con
el ordenador a través del USB gracias al chip FDTI que incorpora la
placa y que realiza la conversión USB-serie.
• se pueden crear proyectos muy complejos con multitud de
dispositivos que se comuniquen e interactúen entre sí
Inicialización de la comunicación serie
(Serial.begin)
• Para poder utilizar el puerto serie hay que inicializarlo estableciendo la velocidad
de la conexión. Esta inicialización se hace siempre dentro de la función setup() .
• Un valor típico para realizar la conexión es 9600 baudios , aunque se pueden
asignar otros muchos valores.

• void setup()
• {
• Serial.begin (9600); //abre el puerto serie estableciendo la
• velocidad en 9600
• } //baudios

• Arduino, puede tener 1 o más puertos para la comunicación serie, estos puertos
estarán numerados y deberán de abrirse de manera independiente según los que
queramos usar.
Escritura en el puerto serie (Serial.print)
• Si queremos que Arduino muestre información a través del puerto serie,
debemos de usar instrucciones que "impriman" en pantalla dicha
información.
• Para imprimir estos datos se usa el comando Serial.print, que mandará a
través del puerto serie el dato o la cadena de caracteres que le indiquemos.
Esta instrucción tiene algunas variantes, que veremos a continuación.

• Serial.print(dato, tipo de dato)

• Esta es la instrucción más común a la hora de enviar datos a través del

puerto serie, tan solo hay que indicar el dato que queremos enviar y el
formato en el que queremos que muestre dicho dato.
• El "tipo de dato" puede tomar los valores BIN (binario), OCT (octal),
DEC (decimal) y HEX (hexadecimal). En versiones antiguas de Arduino,
también estaba disponible el sacar los datos en formato "BYTE", pero
este formato fue eliminado, si queremos sacar un byte en pantalla,
podemos utilizar la función Serial.write(valor).

• Serial.print(78, BIN); // manda el dato "1001110"

• Serial.print(78, OCT); // manda el dato "116"
• Serial.print(78, DEC); // manda el dato "78"
• Serial.print(78, HEX); // manda el dato "4E"
• Si estamos trabajando con datos que tienen decimales (float) y
queremos mostrar un número concreto de ellos, podemos hacerlo
poniendo en tipo de dato el número de decimales que queremos
mostrar. Por defecto mostrará dos decimales.

• Serial.println(1.23456, 0); //manda por el puerto serie el valor "1"

• Serial.println(1.23456, 1); //manda por el puerto serie el valor "1.2"
• Serial.println(1.23456, 2); //manda por el puerto serie el valor "1.23"
• Serial.println(1.23456, 3); //manda por el puerto serie el valor "1.234"
• Serial.println(1.23456, 4); //manda por el puerto serie el valor "1.2346"
• también es posible mandar cadenas de caracteres, para ello tan solo hay
que encerrar el texto que queramos mostrar entre comillas.
• Serial.print("Hola mundo"); //muestra en pantalla "hola mundo“

• Cuando mandamos datos a través del puerto serie y queremos visualizar

estos datos en pantalla, es recomendable introducir espacios y saltos de
línea, ya que si no lo hacemos los datos nos van a aparecer de manera
continua y no vamos a poder diferenciar unos de otros. Para ordenar estos
datos, podemos introducir tabulaciones o saltos de línea con los siguientes
comandos:
• Serial.print("\t"); //introduce una tabulación entre los datos
• Serial.print("\n"); //introduce un salto de línea
• Si queremos crear datos en líneas diferentes, se puede optar por una
variante del Serial.print que introduce automáticamente un salto de
línea, haciendo que el siguiente dato que se vaya a escribir aparezca
en la siguiente línea.

• Serial.println(dato, tipo de dato)

• Como en el caso anterior, el tipo de dato será un campo opcional, si

no se rellena este campo, el dato aparecerán en formato decimal.
• La función Serial.println es equivalente a poner:

• Serial.print (dato, tipo de dato);

• Serial.print ("\n");
Lectura del puerto serie (Serial.read)
• La instrucción Serial.read es una instrucción que va a leer datos entrantes
del puerto serie. Estos datos deben de ser almacenados en variables para
poder trabajar con ellos.

• valor = Serial.read(); //almacena el dato del puerto serie en la variable valor

• Serial.print(valor); //"imprime" el dato valor

• Si hacemos uso de las instrucciones anteriores, vamos a estar

constantemente leyendo el puerto serie, pero quizás no haya nada que leer
y el dato que estemos almacenando en la variable "valor" sea un dato
erróneo. Para evitar estos problemas y optimizar el programa, existe la
instrucción Serial.available().
• se usa para comprobar si hay caracteres disponibles para leer en el
puerto serie. Serial.available va a tomar un valor entero con el
número de bytes disponibles para leer que están almacenados en el
buffer del puerto serie. Si no hay ningún dato disponible Serial.avaible
va a valer 0, por lo que es muy fácil el uso de esta función combinada
con el condicional if.
 • if (Serial.available() > 0) //si hay algún dato disponible para leer
•{
• valor = Serial.read(); //almacena el dato del puerto serie en la variable
valor
•}

• Arduino tiene un buffer que puede almacenar como máximo 64

bytes, una vez sobrepasada esta capacidad se empezaran a escribir
los datos uno encima de otro, perdiendo la información.
Otras instrucciones de interés
• ya que se pueden cargar librerías muy interesantes (como la librería
de matemáticas) que añaden funciones con las que podemos realizar
tareas complejas de manera muy sencilla.
Delay(ms)
• detiene la ejecución del programa un tiempo determinado. El tiempo habrá que
indicarlo entre paréntesis en milisegundos (1 segundo = 1000 milisegundos).

• delay (1000); //espera durante 1 segundo (1000ms)

• Esta función va a detener el flujo de programa, haciendo que durante este tiempo
no se detecten eventos como pueden ser presionar un pulsador o la activación de
un sensor, esto puede ocasionar graves problemas en la aplicación, por lo que
siempre que se pueda hay que evitar usar la instrucción delay().
• es muy útil cuando ejecutamos tareas que requieren un tiempo mínimo para
dicha ejecución, como por ejemplo, para leer memorias externas o comunicarnos
con algunos dispositivos vamos a necesitar un tiempo mínimo para acceder a la
memoria o establecer la comunicación, este tiempo lo obtenemos deteniendo el
programa los milisegundos necesarios.
DelayMicroseconds(μs)
• La instrucción delayMicroseconds() funciona igual que delay(), con la
diferencia de realizar las temporizaciones usando microsegundos (μs)
en lugar de milisegundos (ms).
• Esta instrucción nos va a permitir realizar temporizaciones mucho
menores, haciendo que el tiempo que detenemos el flojo de
programa sea prácticamente imperceptible.

• delayMicroseconds (10); //espera durante 0'00001 segundos

Millis ()
• La instrucción millis() va a devolver el tiempo en milisegundos trascurridos
desde el inicio del programa hasta el momento actual. Esta instrucción es
muy interesante, ya que nos permite realizar temporizaciones NO
bloqueantes basadas en eventos.

• tiempo = millis(); //la variable "tiempo" toma el valor del tiempo transcurrido

• Millis está asociado a un registro de 32bit's, lo que le da la capacidad de

temporizar unos 4.294.967.296 milisegundos o lo que es lo mismo 49 días
y 17 horas. una vez transcurrido este tiempo el registro se desbordará
comenzando la cuenta de nuevo.
• Un ejemplo de temporización con • voidloop()
millis(): • {
• #define led 11 • pulsador = digitalRead(puls);
• #define puls 10 • if(pulsador == HIGH)
• boolean pulsador; • {
• unsigned long tiempo; • tiempo = millis() + 5000;
• digitalWrite(led, HIGH);
• void setup() • }
• { • if(tiempo == millis())
• pinMode(led, OUTPUT); • {
• pinMode(puls, INPUT); • digitalWrite(led, LOW);
• } • tiempo = 0;
• }
• }
PRACTICA
• Para el siguiente circuito realizar
un programa en Arduino para
encender uno a uno los led, con
un intervalo de un segundo y en
forma secuencial.
• Indicar que hace la resistencia
de 220Ω
• Calcular la corriente que debe
de entregar la placa si la caída
de tensión del led es de 3.3 volt.
• Gracias por su atención