Guia Arduino 20220704

UNIVERSIDAD MAYOR DE SAN ANDRES SEMINARIO TALLER:
FACULTAD DE TECNOLOGIA PRIMEROS PASOS CON

CARRERA: ELECTRONICA Y TELECOMUNICACIONES ARDUINO
___________________________________________________________________________________________________________
PRIMEROS PASOS CON ARDUINO
1. Instalación del Software (Entorno Integrado de desarrollo)
Para la instalar el Software requerido para desarrollo de aplicaciones en Arduino, visitar

la pagina www.arduino.cc, en la sección “Software” descargar el entorno “Arduino IDE
1.8.15”.
Una vez descargado ejecutarlo. Después de efectuar una rápida verificación del
archivo se mostrara la primera ventana que pide aceptar los términos de la licencia,
hacer clic en “I Agree”
La siguiente ventana debe tener todas las opciones habilitadas, hacer clic en “Next>”
_____________________________________________________________________________________________________________________
RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 1 -

___________________________________________________________________________________________________________
A continuación escoger la ruta de instalación, o dejar la misma por defecto, hacer clic
en “Install”.
Esperar a que se instale el software, una vez finalizado hacer clic en “Close”
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
De esta manera el escritorio mostrara el icono correspondiente desde el cual

ingresaremos al programa:
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
2. INSTALACION DRIVER ARDUINO UNO
Conectar la tarjeta a un Puerto USB, recordar que para posteriores usos de la tarjeta
Arduino es recomendable utilizar el mismo puerto USB. Al efectuar esta operación el
sistema operativo mostrara la siguiente ventana:
Escoger la primera opción, tal como muestra el grafico y hacer clic en “Siguiente”,
aparecerá la siguiente ventana:
En la misma escoger la segunda opción y hacer clic en “Siguiente”.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Como puede observarse en la anterior ventana, escoger la segunda opción, hacer clic
en examinar y buscar la carpeta Archivos de programa – Arduino – Drivers – FTDI USB
Drivers, seleccionar la misma, hacer clic en “Aceptar” y luego clic en “Siguiente”.
Para el caso de Arduino de procedencia China buscar la carpeta “CH341SER” en la
documentación del presente seminario, seleccionar la misma y hacer clic en “Aceptar”.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Una vez realizadas las anteriores operaciones el sistema operativo instalará el driver
respectivo para el chip que permite comunicarnos con la tarjeta Arduino Uno a través de
un Puerto USB.
Al mostrarse la anterior ventana hacer clic en “Finalizar”; el mencionado chip presente

en cada placa Arduino no es más que un conversor de USB a puerto serial, cuando
Windows instala sus drivers este chip es reconocido y recibe un número de COM
(puerto de comunicaciones), para utilizar la placa Arduino es necesario conocer el
mencionado número, para ver este detalle ir a:
Inicio – panel de control – sistema – Hardware – Administrador de dispositivos – puertos

(COM y LPT); se mostrara la siguiente ventana:
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Y aquí podemos observar que el puerto para la placa Arduino es “COM 5”, tomar nota
de este detalle y cerrar todas las ventanas abiertas.
Ojo, este valor puede cambiar de una computadora a otra, lo importante es que el
adaptador sea reconocido por Windows y podamos averiguar que numero de puerto le
fue asignado.
3. UTILIZACION DEL SOFTWARE ARDUINO
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Con ayuda del icono en el escritorio ejecutar el programa, se mostrara la siguiente
ventana:
Como toda aplicación Windows, esta ventana muestra una barra de título en la parte
superior, la primera parte que dice “sketch_jul01a” es el nombre por defecto que
Arduino asigna al programa que vamos a realizar (sketch se podría traducir como:
bosquejo, croquis o esquema); la segunda parte del texto mostrado en la barra de titulo
no se puede modificar, indica el nombre del programa y la versión utilizada.
Para comenzar veamos como guardar un programa y como cambiar el nombre por
defecto del mismo, para ello ir al menú “Archivo”, escoger la opción “Guardar como…”,
escoger la ruta donde se desea guardar este primer programa, asignar un nombre para
el mismo y hacer clic en “Guardar”, de esta manera, en la ubicación escogida se habrá
creado una carpeta con el nombre asignado y en la misma un archivo con extensión
“ino” que también lleva el mismo nombre.
Para mi caso asigne como nombre Javier 01 y la barra de titulo queda de la siguiente
manera:
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Bien, Ahora observemos la parte central de la ventana, el espacio en fondo blanco, todo
programa para Arduino requiere de dos bloques, el primero de configuración que lleva
el nombre “setup”, y el segundo de repetición o bucle, identificado como “loop”. El inicio
y final de un bloque ó de una estructura de control están identificados por los símbolos
de llave abierta y llave cerrada, a partir de ahora toda llave abierta que veamos o
escribamos significa “comienzo”, y toda llave cerrada significara “fin”; siempre que se
coloque una llave abierta, esta deberá ir acompañada de su respectiva pareja, la llave
cerrada.
Para identificar las parejas de llaves sugiero colocarlas en la misma columna y no como
lo hace el entorno de Arduino por defecto, las líneas de texto que comienzan con doble
barra inclinada son solamente comentarios, por el momento ellas no son de gran ayuda
(a menos que tengan conocimientos de inglés), entonces podemos proceder a
borrarlas, si seguimos ambos consejos los bloques de programación deberán quedar
así:
Como inicializar la ventana de códigos para comenzar un programa

_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Ahora sí, estamos listos para comenzar a codificar nuestro primer programa, y si hay
suerte subirlo al módulo Arduino y verlo funcionar. Para guardar las modificaciones
realizadas hasta el momento ir al menú “Archivo” y escoger la opción “Salvar”.
Cuando vayamos a comenzar cualquier programa en el entorno Arduino siempre

acomodar las llaves y borrar los comentarios en inglés, tal como se observa en anterior
figura.
4. PROGRAMA EJEMPLO 1 PARA ARDUINO
Para confeccionar el primer programa en Arduino escogeremos aquel que debe

encender y apagar un LED (el programa clásico), pero antes veamos algunos detalles
del hardware de Arduino UNO. Esta tarjeta posee, entre otras cosas, 14 terminales
digitales (numerados del 0 al 13) cada una de ellas puede ser configurada como
entrada o salida digital, en la combinación que requieran nuestras aplicaciones, el punto
de referencia, punto de tierra o GND de estas 14 terminales es aquella identificada
como “GND” precisamente.
Entonces, como vamos a realizar un programa que sea capaz de encender y apagar un
LED, comencemos por escoger el terminal digital al cual conectaremos nuestro
indicador luminoso, recomiendo escoger el terminal 13, en cuyo caso la conexión del
mencionado LED deberá ser efectuada tal como muestra el siguiente gráfico:
Y con ellos tenemos listo el hardware de nuestro primer programa.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
4.1. Instrucción pinMode
Para elaborar la parte que corresponde al software, comenzaremos por indicar que el
terminal 13 actuara como salida, para ello la instrucción a utilizar es “pinMode”, esta
requiere dos parámetros encerrados entre paréntesis, el número de terminal y el tipo,
finalmente un punto y coma.
Para el tipo de terminal, si el mismo será una salida digital escribiremos “OUTPUT”, si
se requiriera que un terminal actué como entrada digital se deberá digitar “INPUT”; esta
codificación se la realiza en el bloque de configuración (setup), entonces el programa
quedara con el siguiente aspecto:
Dos detalles a tomar en cuenta, cada instrucción en el entorno Arduino termina con un
punto y coma, para poder observar con mayor claridad el par de llaves que indican
inicio y final del bloque de configuración, las instrucciones escritas en el interior de la
misma deberán tener sangría, para ello presionar la tecla de tabulación una o dos veces
antes de comenzar a digitar las mismas o utilizar la tecla espaciadora unas 3 veces.
4.2. Instrucción digitalWrite
Ahora que definimos el terminal a utilizar, y además el modo de funcionamiento

(entrada o salida), solo nos resta colocar las instrucciones que permitan encender y
apagar el respectivo LED, para ello recurrimos a la instrucción “digitalWrite” la cual
asigna un “cero” o “uno” lógico a la salida indicada, recordar que en esta tarjeta “cero”
lógico se representa con 0 voltios, lo cual provoca que el LED se apague; y “uno” lógico
se representa con 5 voltios, tensión que hace posible que el LED se encienda.
La instrucción “digitalWrite” requiere dos parámetros: el terminal sobre el cual actuara y

el nivel lógico que debe generar (HIGH ó 1 para activarlo, y LOW ó 0 lógico para
desactivarlo); como deseamos que el LED conectado al terminal 13 se encienda y
apague la codificación podría quedar como alguna de las opciones mostradas en la
siguiente figura:
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Todas las instrucciones escritas al interior del bloque “loop” se repiten de manera
automática e indefinida, recordar hacer uso de sangría al escribir las instrucciones que
encienden y apagan el LED.
4.3. Compilar un programa
El programa codificado debería funcionar, para verificar el mismo en busca de errores

de sintaxis hacer uso de la herramienta compilar/verificar, cuyo icono es un símbolo de
tiqueado:
Al activar esta herramienta se procederá a compilar el programa y después de unos

instantes, si no hay ningún error de sintaxis, aparecerá unos mensajes en la parte
inferior indicando el porcentaje utilizado en memoria de programa y en memoria
dinámica.
4.4. Mensajes de Error
Si al efectuar la compilación se encuentran errores, esta operación se detendrá,

aparecerá un mensaje describiendo el error y la línea de código que contiene el mismo
será resaltada, tomar en cuenta que el error puede estar en la línea resaltada o en la
anterior, como ejemplo olvidemos colocar el punto y coma al final de la primera
instrucción “digitalWrite”, al compilar el programa se mostrara esto:
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
El mensaje dice más o menos “Falta ; antes de digitalWrite”; ahora supongamos que
olvido la “H” de “HIGH”, el resultado es este:
Toma a “HIG” como una variable que no ha sido declarada; pongamos todo en orden y
procedamos a subir nuestro programa a la placa Arduino; antes de efectuar esta
operación debemos conectar la misma a un puerto USB mediante el cable
correspondiente, ahora configuramos el tipo de placa que tenemos mediante el menú
“Herramientas” escogiendo la opción que comienza con “Placa:” y para la misma
seleccionamos “Arduino/Genuino Uno”
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
A continuación seleccionamos el puerto serial que utiliza la placa Arduino, este número
de puerto debe ser el mismo que se generó cuando instalamos el driver de la tarjeta, se
acuerdan ¿verdad?, caso contrario vuelvan a leer el subtítulo “Instalación Driver
Arduino Uno”.
Esta configuración de puerto también se la efectúa en el menú “Herramientas”:
Ojo, el número de puerto serial (COM) puede variar de una computadora a otra, lo
importante es que en la ventana anterior podamos escoger el puerto asignado al
controlador de Arduino, incluso no es raro que aparezca más de un puerto serial, de
todos los que se muestren escoger el generado para Arduino y procurar utilizar siempre
el mismo puerto USB del computador.
Con todo listo no queda más que hacer clic sobre el icono de “Subir”, identificado por
una flecha a la derecha:
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Realizando esta operación el programa se vuelve a compilar, y después de unos
instantes este es subido a la placa, si todo resulta bien el LED correspondiente debería
encenderse y apagarse, pero resulta que solo lo vemos encendido, ¿cierto?.
En realidad el programa si está funcionando, el LED se enciende y apaga, pero a una

velocidad tal que para la vista humana lo percibe como encendido, para que realmente
podamos ver el efecto de encendido y apagado después de cada instrucción
“digitalWrite” deberemos recurrir a la instrucción “delay”
4.5. Instrucción delay
Permite efectuar una pausa o retardo en nuestros programas, después de escribirla

solo se requiere un parámetro entre paréntesis, el tiempo de pausa en milisegundos,
finalmente un punto y coma. Añadiendo esta función a nuestro primer programa para
que las mismas sean de medio segundo (500 milisegundos); la codificación deberá
quedar así:
Subir el programa y ahora si o si el LED deberá encenderse y apagarse a intervalos de

medio segundo, si este es el caso merecen un gran abrazo (de oso) y también una gran
felicitación por que lograron con éxito:
 Instalar el software del Arduino

 instalar su respectivo driver
 Conocer parte del hardware de la placa Arduino Uno
 Codificar un programa sin errores
 Y finalmente subirlo a la placa para verlo funcionar.
Realmente son lo máximo, para aquellos compañer@s que no lograron estos objetivos
se merecen un jalón de orejas, luego de hacerlo (el jalón quiero decir) vuelvan a leer la
presente guía desde el principio.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Al efectuar el primer programa pudimos observar que la placa Arduino posee 14

terminales configurables como entradas o salidas digitales, para este segundo
ejemplo utilizaremos 8 de ellas configuradas como salidas digitales a las cuales
conectaremos ocho LEDs y con ellos construiremos un juego de luces, haciendo
que las mismas se enciendan y apaguen en secuencia definida por programa.
Los terminales a utilizar serán del 6 al 13, entonces nuestro hardware quedara
de la siguiente manera:
Ahora procedamos a dedicarnos al

software, tal como en el primer programa
ingresamos entorno de desarrollo y
modificamos los textos hasta que el editor
tenga el siguiente aspecto:
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Comencemos por la primera parte
que corresponde a la configuración
(setup), como ya mencionamos
este programa hará uso de 8
terminales (del 6 al 13)
configurados como salidas
digitales, entonces recurrimos a la
instrucción pinMode para que la
codificación quede como en la
figura.
Ahora definamos la secuencia que

deseamos generar, para este
segundo programa la misma estará
compuesta por 9 combinaciones de
ceros y unos lógicos, los cuales a
su vez harán que los LEDs
conectados a los terminales
respectivos se enciendan y apaguen del modo deseado; estos detalles se
muestran en la siguiente tabla:
La primera combinación hará que solo se encienda el LED conectado al terminal

6, todos los demás permanecerán apagados; la segunda combinación provoca
que se enciendan dos LEDs (en terminales 6 y 7) los demás permanecen
apagados, así sucesivamente hasta llegar a la combinación 9 que apagara todos
los LEDs.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Para asignar la primera combinación a los

terminales respectivos recurriremos a varias
instrucciónes digitalWrite del siguiente modo:
Si compilamos y cargamos el programa a la

placa con solo este código, este se ejecutara y
mostrara de manera permanente la primera
combinación, para lograr ver la segunda
combinación volvemos a utilizar ocho
instrucciones digitalWrite sin olvidar que al final
de cada grupo de instrucciones se requiere la
instrucción delay:
Compilando y cargando el programa a la

placa Arduino se lograra observar las dos
primeras combinaciones a intervalos de
medio segundo. Aprovechemos la
habilidad de copiar y pegar que tenemos
para continuar con la codificación hasta
completar las 9 combinaciones.
Y listo, compilando y cargando el

programa a la placa observar que todo
funciona tal como lo describe la tabla de
secuencia propuesta.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
5.1. Modificaciones al segundo programa:
El segundo ejemplo de esta guía funciona de acuerdo a los requerimientos

descritos al principio de la misma, las combinaciones se van mostrando a
intervalos de medio segundo, esto debido al valor 500 en la instrucción delay; si
deseamos que esta secuencia cambie de velocidad, que se ejecute más rápido,
tendremos que cambiar el valor 500 a otro menor, 200 por decir un ejemplo,
como el programa hace uso de 9 instrucciones delay, este cambio de valor de
500 a 200 se la efectuara en 9 puntos. Hacer los cambios y cargar el programa a
la placa.
Ahora, supongamos que la velocidad a la que se ejecuta la secuencia es muy

rápida, deseamos que sea más lenta que al principio, a intervalos de 1 segundo,
entonces volvemos a cambiar el valor 200 de las instrucciones delay por el valor
1000; este cambio deberá efectuarse en 9 puntos del programa. Hacer los
cambios y cargar el programa.
Como vemos con los dos ejemplos anteriores, cambiar la velocidad de la

secuencia es un poco moroso, para facilitar esta tarea y hacer un código más
eficiente debemos recurrir al uso de variables.
5.2. Variables
Una variable es una porción de memoria, que tiene un nombre o identificador y

que además puede guardar un determinado valor para poder ser utilizado o
modificado en nuestros programas, para poder utilizar una variable lo primero es
declararla, ¿Dónde? se preguntaran, pues de acuerdo al lugar donde ha sido
declarada se determina el ámbito de la misma, para no complicarnos mucho las
variables a utilizar en la presente guía serán todas de tipo global, esto significa
que pueden ser utilizadas y modificadas en cualquier parte del programa. Una
variable global se declara al inicio del programa, antes del bloque “setup”
5.3. Tipos de datos
Mencionamos que una variable puede guardar un determinado valor, de acuerdo

al tipo de valor que deseamos almacenar la variable será declarada con un tipo
de dato específica, en la programación de Arduino podemos utilizar los
siguientes tipos de datos:
byte almacena un valor numérico de 8 bits sin decimales

int almacena un valor numérico de 16 bits sin decimales
long almacena un valor numérico de 32 bits sin decimales
float almacena un valor numérico de 32 bits con decimales
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Los valores que utiliza la función delay con de tipo entero (int), entonces la
variable que almacenara el valor para la mencionada función también será de
este tipo, la declaración y asignación de valor se la realiza de la siguiente
manera:
Como puede observarse, la declaración está escrita antes del bloque “setup”,
comienza con la palabra “int” que determina el tipo de datos que se almacenara,
a continuación el nombre o identificador de la variable, en este caso “tiempo” y
luego de un signo de igual el valor inicial que adoptara la mencionada variable;
esta parte de asignación de valor inicial es opcional.
Ahora modificar el código en el bloque “loop” de nuestro segundo ejemplo, donde

se tenga la función “delay” en lugar del valor fijo, cambiar este por la variable
declarada:
void loop()
{
digitalWrite (13,0);
digitalWrite (9,0);
digitalWrite (8,1);
delay (tiempo);
digitalWrite (9,1);
digitalWrite (8,1);
delay (tiempo);
.
.
.
.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
}
De este modo, cuando se desee cambiar la velocidad de la secuencia solo se

cambiara el valor en la primera línea del programa, en la inicialización de la
variable y no en 7 o más puntos del código. Subir el programa a la placa y
observar su correcto funcionamiento.
A través de este ejemplo aprendimos a generar secuencias en las salidas, las

cuales no solo pueden ser 6, podemos llegar a tener hasta 12 salidas (dejando
libres los terminales 0 y 1) y una cantidad muy grande de combinaciones, todas
las que podamos imaginar, el único inconveniente es que: para modificar una
combinación debemos modificar los ceros y unos en muchos lugares del código,
lo cual lleva bastante tiempo. Una solución a ese inconveniente será desarrollada
en el siguiente ejemplo, costara un poco más de trabajo pero los resultados
serán muy satisfactorios, espero que pongan mucha atención y concentración.
Antes de desarrollar el siguiente ejemplo hay ciertos detalles que debemos

conocer, tales como el uso de operaciones aritméticas, de estructuras de control,
operadores, etc.; todo ello permitirá generar secuencias de manera más eficiente
al igual que otros programas y aplicaciones.
5.4. Operaciones Aritméticas
En el entorno de programación para Arduino las operaciones que podemos

efectuar son:
Suma Mediante el símbolo +

Resta Mediante el símbolo –
Multiplicación Mediante el símbolo *
División Mediante el símbolo /
Modulo o residuo Mediante el símbolo %
Para el último caso, el operador % nos proporciona el residuo resultante de una

división, por ejemplo, si tenemos dos variables enteras cuyos valores son 9 y 4,
al efectuar una división entre las mismas el resultado obtenido será 2, y al aplicar
el operador de modulo entre los mismos datos el resultado obtenido será 1.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
5.5. Asignaciones Compuestas
Son aquellas que combinan operaciones aritméticas con una o más variables,
estas se utilizan en estructuras de control, como la “for: mencionada
anteriormente.
x ++ // igual que escribir x=x+1, incrementa la variable x en uno

x -- // igual que escribir x=x-1, decrementa la variable x en uno
x+=y // igual que escribir x=x+y, incrementa la variable x con valor de y
x-=y // igual que escribir x=x-y, decrementa la variable x con valor de y
x*=y // igual que escribir x=x*y, multiplica la variable x por el valor de y
x/=y // igual que escribir x=x/y, divide la variable x entre el valor de y
En los últimos cuatro casos del anterior listado, el valor de “y” puede ser
reemplazado por un valor constante (un número cualquiera).
5.6. Operadores de comparación
Son aquellas que permiten efectuar comparaciones entre valores y/o variables
en estructuras de control o cualquier otro lugar que el programador requiera, las
que están disponibles en el entorno de desarrollo para Arduino son las
siguientes:
x == y // x es igual a y
x != y // x es distinto a y
x<y // x es menor que y
x>y // x es mayor que y
x <= y // x es menor igual que y
x >= y // x es mayor igual que y
5.7. Operadores Lógicos
Permiten compara dos expresiones y devolver como resultado un Falso o un

Verdadero, se utilizan en estructuras de control que serán detalladas más
adelante, entre los operadores disponibles están:
Operador lógico AND, representado por el símbolo &&

Operador lógico OR, representado por el símbolo ||
Operador lógico NOT, representado por el símbolo !
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
5.8. Estructura de control FOR
Esta estructura es un contador automático, para su funcionamiento se requieren

tres parámetros separados por punto y coma, el primero indica el valor inicial
para el conteo, el segundo determina el valor final del conteo, el tercero se
encarga del incremento o decremento del conteo. La sintaxis general es la
siguiente:
for ( valor inicial ; valor final ; incremento/decremento )

{
Instrucción…..
Instrucción ….
………..
}
Las instrucciones escritas entre las llaves abierta y cerrada de la propia

estructura se repiten la misma cantidad de veces que dura el conteo, para que
esto quede más claro veamos un par de ejemplos:
Si se quisiera que el led conectado al terminal 13 se encienda y apague 5 veces
a intervalos de medio segundo y luego realizar una pausa de 3 segundos
podríamos escribir el siguiente código:
int tiempo1 = 500;
int tiempo2 = 3000;
void setup()
{
pinMode (13, OUTPUT);
}
void loop()
{
delay (tiempo1);
delay (tiempo1);
delay (tiempo1);
delay (tiempo1);
delay (tiempo1);
delay (tiempo1);
delay (tiempo1);
delay (tiempo1);
delay (tiempo1);
delay (tiempo2);
}
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Un poco largo el código ¿verdad?, bien, para reducirlo recurrimos a un contador

que haga un conteo de 0 a 4, ó de 1 a 5, en cualquiera de los casos las
instrucciones al interior del código se repetirán 5 veces.
Un detalle que se me olvidaba, para hacer uso de una estructura for se requiere
una variable, de tipo entera preferiblemente, la cual será la encargada de llevar el
conteo, es decir, esta variable cambiara de valor comenzando en 1 y terminando
en 5 para este ejemplo en particular.
Tomando en cuenta que la variable declarada para el contador se llamara

“conteo”, la estructura for deberá ser escrita de la siguiente manera:
for ( conteo=1 ; conteo <= 5 ; conteo ++ )
Para finalizar este ejemplo: el nuevo código a escribir para conseguir que el LED
del terminal 13 se encienda y apague 5 veces, y luego una pausa de 3 segundos
será:
int tiempo1 = 500;
int tiempo2 = 3000;
int conteo;
void setup()
{
}
void loop()
{
for ( conteo=1 ; conteo <= 5 ; conteo ++ )
{
delay (tiempo1);
delay (tiempo1);
}
delay (tiempo2);
}
Fácil, ¿no ve?, de esta manera se puede hacer que una porción de código se
repita n veces, y nada impide que el valor de la variable contador, o la misma
variable sea utilizada al interior del código que ejecuta esta estructura. Esto lo
veremos en ejemplos posteriores.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
5.9. Conversión de Binario a Decimal
Si volvemos a observar con detalle la tabla de secuencia propuesta para el

segundo ejemplo veremos que las combinaciones de unos y ceros que son las
encargadas de hacer encender y apagar los LEDs no son más que números en
sistema binario, cada uno de 6 bits.
Estas combinaciones binarias pueden ser convertidos a sistema decimal

haciendo uso de calculadora o cualquier otro método que conozcamos; en este
caso particular prefiero recurrir a la suma de ponderaciones; cada posición
binaria tiene un peso específico (valores entre paréntesis en la siguiente tabla),
para saber el equivalente en decimal bastara con sumar las ponderaciones de
las posiciones que tienen uno lógico
La idea de este trabajo de conversión es realizar programas donde se pueda

colocar los datos en decimal, en lugar de estar escribiendo muchos ceros y unos,
en distintas posiciones del código.
5.10. Conversión de Decimal a Binario

_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Este trabajo lo tendrá que realizar nuestro programa, para ello utilizaremos el
método de división sucesiva donde los residuos obtenidos de cada operación
forman el equivalente binario.
Entonces, como nuestras combinaciones son de 6 bits debemos efectuar 6
divisiones sucesivas obteniendo en cada operación los residuos que serán
enviados a cada una de los terminales que actúan como salidas en la placa
Arduino; el código que efectúa esta operación puede tener el siguiente aspecto:
digitalWrite (8,dato % 2);

dato = dato/2;
dato = dato/2;
dato = dato/2;
dato = dato/2;
dato = dato/2;
dato = dato/2;
Este código toma el valor asignado en la variable dato, lo convierte a binario y

muestra este resultado en los terminales 8 al 13 de la placa Arduino, un
programa completo para subirlo a la placa y ver en funcionamiento esta
conversión está a continuación:
int dato;
void setup()
{ pinMode (13, OUTPUT);
}
void loop()
{ dato=7;
digitalWrite(8,dato % 2);
dato=dato/2;
dato=dato/2;
dato=dato/2;
dato=dato/2;
dato=dato/2;
}
Al ejecutarse el programa, la variable dato tiene asignado el valor decimal 7,

entonces la tarjeta deberá mostrar el dato 000111 en las salidas respectivas,
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
cambiar el valor asignado a la variable dato por otros obtenidos de la última tabla
y subir el programa para ver su correcto funcionamiento,
Volviendo a nuestro objetivo de generar secuencias, el anterior programa

muestra cómo controlar las seis salidas binarias partiendo de un dato decimal,
esta operación es de gran utilidad porque nuestras secuencias podrán ser
expresadas como un conjunto de numero decimales en lugar de un conjunto de
combinaciones binarias; el mencionado conjunto de números decimales que
describen una secuencia incluso puede ser almacenado en un vector para
facilitar la generación de secuencias.
5.11. Vectores
Hasta el momento sabemos que una variable es una porción de memoria,

identificada por un nombre y que además puede almacenar un valor:
Un vector, en programación, no es más que un conjunto de posiciones de

memoria, identificados por un nombre común, diferenciados unos de otros por un
subíndice y capaces de almacenar datos,
Tomar en cuenta que los subíndices de un vector siempre comienzan en cero, al

igual que las variables, si en nuestros programas deseamos utilizar vectores,
estos deben ser declarados. Para declarar un vector primero indicar el tipo de
datos que podrá almacenar, luego el nombre que identificara a todo el arreglo,
entre corchetes el tamaño del mismo (esto es opcional en Arduino) y si se desea
inicializar los valores enumerar los mismos entre llaves utilizando como
separador la coma:
int datos [ ] = { 1 , 3 , 7 , 15 , 31, 63 , 0 };.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Nuestro tercer programa generador de secuencias hará uso de un vector para
almacenar las distintas combinaciones en notación decimal, luego, mediante una
estructura for las iremos procesando de una en una y la codificación será mucho
más reducida que la planteada originalmente para el segundo ejemplo. A
continuación la codificación mencionada:
int dato, conta;

int tiempo = 200;
byte vector [ ] = { 1,3,7,15,31,63,0 };
void setup()
}
void loop()
{
for ( conta = 0 ; conta <= 6 ; conta++ )
{
dato=vector[conta];
digitalWrite(8,dato%2);
dato=dato/2;
dato=dato/2;
dato=dato/2;
dato=dato/2;
dato=dato/2;
delay(tiempo);
}
}
Editarlo, subirlo a la placa y se observara que este código efectúa la misma

función que la del segundo ejemplo, pero en este caso la modificación de la
secuencia es mucho más rápida y eficiente.
A modo de divertirnos y de pasada comprobar lo fácil que es modificar una

secuencia con el anterior ejemplo, modificar el mismo para poder observar los
datos descritos en la siguiente tabla.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
.
Tomar nota del siguiente detalle, al generar la secuencia de 7 combinaciones, la
estructura for utilizada hacia un conteo de 0 a 6, justamente para recorres las 7
posiciones del vector, para la anterior tabla el contador automático deberá ir de 0
a 17.
Ahora una pequeña modificación en los rangos del contador automático, presten
mucha atención: como todo vector comienza en posición cero vamos a
aprovechar esta primera ubicación para indicar la cantidad de combinaciones
que tiene nuestra secuencia, este valor luego podrá ser utilizada por la estructura
for para que el conteo solo llegue hasta el valor indicado, de esta manera será
aún más fácil programar secuencias.
Entonces, para el ejemplo de 7 combinaciones el vector declarado será:
Byte datos [ ] = { 7, 1 , 3 , 7 , 15 , 31, 63 , 0 };
Y la codificación del programa tendrá las siguientes modificaciones:
int dato, conta;

_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
int tiempo = 200;
byte vector [ ] = { 7, 1 , 3 , 7 , 15 , 31 , 63 , 0 };
void setup()
}
void loop()
{
for ( conta = 1 ; conta <= vector [0] ; conta++ )
{
dato=vector[conta];
dato=dato/2;
dato=dato/2;
dato=dato/2;
dato=dato/2;
dato=dato/2;
delay(tiempo);
}
}
Y listo, para crear secuencias solo modificar la declaración del vector.
7. UTILIZACION DE ENTRADAS BINARIAS
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Como ya lo mencionamos los distintos terminales digitales de una placa Arduino
pueden ser configuradas como salidas o entradas, ahora nos toca ver como
configurarlas para que actúen como entradas y como aprovechar esta situación
en nuestros programas.
AL igual que lo hicimos en los primeros tres ejemplos de programación, para

configurar un determinado terminal como entrada binaria se recurrirá a la
instrucción pinMode, la cual debe tener el número de terminal que deseamos
configurar y la palabra INPUT. Por ejemplo, si deseamos que los terminales 2 al
7 actúen como entradas binarias la codificación en el bloque de configuraciones
será:
void setup()
{
pinMode ( 7, INPUT );
}
7.1. Hardware Para Entradas Binarias
Cuando un terminal es configurado como entrada binaria esta debe adoptar un

nivel lógico permanente, lo más sencillo para conseguir este objetivo es conectar
la misma al positivo de la fuente mediante un resistor de 10 K Ohmios, esto hará
que la entrada binaria este con “1” lógico de manera constante, para actuar
sobre una entrada binaria los primeros ejemplos harán uso de pulsadores (los de
membrana son buena alternativa) o interruptores normalmente abiertos, estos
serán conectados de la siguiente manera:
Circuito para implementar entradas binarias
Teniendo el anterior diagrama implementado, al ejecutar un programa este vera

que las entradas binarias están con un nivel lógico alto (1), solo cuando el
usuario accione uno de los pulsadores, durante ese tiempo la entrada binaria
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
recibirá un nivel lógico bajo (0), tomar en cuenta este detalle al momento de
codificar los programas.
Realizar un programa que lea el estado de las 6 entradas digitales configuradas

anteriormente (terminales de 2 al 7) y que refleje los estados encontrados en las
6 salidas digitales utilizadas en los primeros programas de esta guía (terminales
del 8 al 13.
8.1. Instrucción digitalRead
Esta instrucción es la que permite leer el estado lógico que recibe una entrada
binaria, para utilizarla solo debe especificarse el número de terminal que fue
declarado como entrada digital. El valor leído puede ser almacenado en una
variable.
Dato = digitalRead (2);
El valor obtenido puede ser llevado a una variable o ser utilizada en operaciones
de comparación. Si se opta por la segunda opción se deberá hacer uso de
alguna estructura de control para determinar las acciones a realizar de acuerdo
al valor recibido, entre las más utilizadas para este propósito están:
Estructura de control if
Estructura de control if – else
Estructura de control while
8.2. Estructura if
Permite verificar una condición, a través de una comparación y de ser verdadero

el resultado de la misma se ejecutan las instrucciones que están contenidas
entre las llaves de la estructura, si la comparación resulta falsa no se ejecuta
instrucción alguna y se continua con la siguiente línea de programa, la sintaxis
general es:
if ( dato == valor )
{
Instrucción
Instrucción
......
}
Para nuestro cuarto ejemplo “dato” podría ser el valor leído de una entrada
digital; “valor” puede ser “0” o “1” y las instrucciones encerradas entre llaves
serán las encargadas de encender o apagar el LED conectado a la salida binaria
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
correspondiente. Recordar que el doble signo de igualdad efectua una
comparación entre “dato” y “valor”, si ambas expresiones son iguales se
ejecutaran las instrucciones encerradas entre las llaves propias de la estructura.
El programa solicitado debe leer las seis entradas digitales, y de acuerdo al valor
encontrado las salidas binarias deberán adoptar el mismo valor, la relación de
correspondencia entre una salida y una entrada será la siguiente:
 Valor leído en entrada 2 llevarlo a salida 13

El resultado de la codificación podría ser el siguiente:
void setup()
{
pinMode (7, INPUT);

pinMode (6, INPUT);
pinMode (5, INPUT);
pinMode (4, INPUT);
pinMode (3, INPUT);
pinMode (2, INPUT);
}
void loop()
{
digitalWrite(13,0);
digitalWrite(12,0);
digitalWrite(11,0);
digitalWrite(10,0);
digitalWrite(9,0);
digitalWrite(8,0);
if(digitalRead(2)==1)
{ digitalWrite(13,1);
}
}
}
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
}
}
}
}
Observar que el programa al inicio coloca a “0” todas las salidas binarias, luego
de efectuar una comparación con el valor “1” si esta resulta cierta la salida
binaria correspondiente es puesta también en “1”. Subir el programa a la placa
para verificar su funcionamiento.
Cuando una estructura de control ejecuta una sola instrucción el par de llaves
puede obviarse, pero es mejor ir acostumbrándose a utilizarlas ya que obviar las
mismas puede generar errores difíciles de encontrar.
8.3. Estructura if – else
Tiene la siguiente sintaxis:
if ( dato == valor )
{
Instrucción
Instrucción
......
}
else
{
Instrucción
Instrucción
......
}
Si se quiere hacer una traducción de los términos de esta estructura podríamos

decir que “if” se traduce en “si…..”, y “else” se traduciría en “ Y si no….”;
entonces concluimos que esta estructura efectúa una comparación, si esta
resulta cierta se ejecutan solamente las instrucciones encerradas entre las llaves
del ‘if”, si el resutado de la comparación en falta se ejecutan solo las
instrucciones encerradas entre las llaves correspondientes al “else”.
Volviendo a realizar el programa de control de entradas y salidas, pero ahora con

la estructura if-else, el código resultante en el bloque loop seria:
void loop()
{
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
}
else
}
}
else
}
}
else
}
}
else
}
}
else
}
}
else
}
Notar que en este caso no se requiere inicializar los valores de las salidas
digitales cada vez que inicia el bloque loop.
Aprovechando que contamos con seis entradas digitales realizar un programa

que lea el estado presente en casa una de ellas y efectué las siguientes
operaciones:
Si la entrada del pin 2 está en “0” lógico, activar la salida 13.

_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Si la entrada del pin 3 está en “0” lógico, activar las salidas 13 y 12.
Si la entrada del pin 4 está en “0” lógico, activar las salidas 13, 12 y 11
Si la entrada del pin 5 está en “0” lógico, activar las salidas 13, 12, 11 y 10
Si la entrada del pin 6 está en “0” lógico, activar las salidas 13, 12, 11, 10 y 9
Si la entrada del pin 7 está en “0” lógico, activar las salidas 13, 12, 11, 10, 9 y 8
Si todas las entradas están en “1” lógico desactivar todas las salidas
La codificación para conseguir este objetivo, en el bloque loop, podría ser:
void loop()
{
}
else
}
digitalWrite(12,1);
}
else
digitalWrite(12,0);
}
digitalWrite(12,1);
digitalWrite(11,1);
}
else
digitalWrite(12,0);
digitalWrite(11,0);
}
digitalWrite(12,1);
digitalWrite(11,1);
digitalWrite(10,1);
}
else
digitalWrite(12,0);
digitalWrite(11,0);
digitalWrite(10,0);
}
digitalWrite(12,1);
digitalWrite(11,1);
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
digitalWrite(10,1);
digitalWrite(9,1);
}
else
digitalWrite(12,0);
digitalWrite(11,0);
digitalWrite(10,0);
digitalWrite(9,0);
}
digitalWrite(12,1);
digitalWrite(11,1);
digitalWrite(10,1);
digitalWrite(9,1);
digitalWrite(8,1);
}
else
digitalWrite(12,0);
digitalWrite(11,0);
digitalWrite(10,0);
digitalWrite(9,0);
digitalWrite(8,0);
}
Subirlo a la placa y probarlo.
A estas alturas del partido se acuerdan del programa para generar secuencias
recurriendo a un vector, espero que si, ahora añadiremos una mejora a dicho
programa, aprovechando que aprendimos a utilizar las entradas digitales
utilizaremos dos de ellas como control de velocidad, la idea es que al presionar
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
un pulsador, la velocidad de la secuencia aumente, y al presionar otro de los
pulsadores, la velocidad disminuya.
Recordar que la velocidad de la secuencia está controlada por el valor asignado

a la variable “tiempo”, a su vez este valor se transfiere a la función “delay”, si el
valor asignado a la función se incrementa la velocidad disminuye, y viceversa.
Entonces el programa deberá verificar el nivel lógico presente en las entradas

binarias que actuaran como control de velocidad, si alguna de ellas se pone a “0”
lógico el valor de la variable “tiempo” deberá incrementarse o reducirse en una
unidad.
Para que el valor de retardo cambie a intervalos de 100 ms haremos que el valor
de la variable “tiempo” sea multiplicada por 100 al asignarse este a la función
“delay”; tomar en cuenta que el valor del retardo no puede reducirse a valores
inferiores a cero y tampoco es conveniente que se incremente hasta valores muy
grandes, por este motivo se deberá controlar los valores máximo y mínimo que
podrá adoptar la variable “tiempo”. El mínimo será 1 ( 1 x 100 ms = 100 ms) y el
máximo para este ejemplo no sobrepasara el valor 9 ( 9 x 100 ms = 900 ms).
El control del valor máximo y mínimo que puede adoptar la variable “tiempo” se la
efectuara a través de estructuras if, el resultado de la codificación para este
programa podría tener el siguiente aspecto:
int dato, conta;

int tiempo = 3;
byte vector [ ] = { 7, 1 , 3 , 7 , 15 , 31 , 63 , 0 };
void setup()
pinMode (2, INPUT);

pinMode (3, INPUT);
void loop()
{
for ( conta = 1 ; conta <= vector [0] ; conta++ )
{
dato = vector[conta];
digitalWrite( 8 , dato%2 );
dato=dato/2;
dato=dato/2;
dato=dato/2;
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
dato=dato/2;
dato=dato/2;
delay(tiempo * 100);
if ( digitalRead(2) == 0)
{ if (tiempo >= 2)
{ tiempo = tiempo - 1;
}
}
{ if (tiempo <= 8)
{ tiempo = tiempo + 1;
}
}
}
}
Notar que el primer if encargada de verifica el valor de la entrada binaria 2 tiene

otro if anidado el cual antes de hacer una reducción en el valor de “tiempo”
verifica que este no sea muy pequeño. El if que lee el valor de la entrada binaria
3 también tiene otro if anidado que verifica que el valor de la variable “tiempo” al
ser multiplicada por 100 ms no sobrepase 1 segundo.
Para este ejemplo desarrollaremos una aplicación que puede ser denominada
“Secuencial Múltiple”, la misma tendrá programadas múltiples secuencias las
cuales se podrán ir cambiando mediante dos entradas binarias, al igual que se
hace con el control de velocidad del anterior ejemplo, para ello recurriremos a un
vector de múltiples dimensiones, el cual suele ser denominado matriz.
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
11.1. Arreglos multidimensionales ó matrices
Son conjuntos de datos dispuestos en filas y columnas, al igual que en los

vectores la cantidad de filas puede no estar declarada, pero la cantidad de
columnas que utilizaremos si debe tener una dimensión fija, para evitar
inconvenientes al efectuar una declaración de matriz siempre indicaremos las
dimensiones máximas que puede tener.
Al igual que en una variable, o en un vector, para poder utilizar una matriz lo
primero es declararla, para ello asignamos un nombre y entre dos pares de
corchetes la cantidad de filas y columnas (en ese orden) que podrán utilizarse,
ejemplo:
int secuencias[3][10] =
{
{ 2 , 1 , 2 , 4 , 8 , 16 , 32 },
{ 9 , 32 , 16 , 8 , 4 , 2 , 1 , 0 },
{ 1 ,33 , 18 , 12},
};
La anterior expresión declara una matriz llamada secuencias, de 3 filas y 10

columnas, estas son las dimensiones máximas del arreglo, pero no generamos
ningún error si se utilizan datos en cantidades menores. Recomiendo utilizar el
formato mostrado anteriormente para que se muestre claramente los datos que
corresponden a cada fila y columna.
Para efectuar la programación definiremos unas 5 secuencias a través de las

siguientes tablas:
Primera secuencia:
Segunda secuencia:
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Tercera secuencia:
Cuarta secuencia:
Quinta secuencia
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
Como podemos observar la cantidad de combinaciones de cada secuencia varia

de tamaño, esto no es inconveniente ya que para la declaración utilizaremos la
de mayor cantidad de datos, en este caso la tercera secuencia (12 datos), y
adicionando una posición para que el primer dato determine la cantidad de
combinaciones. El resultado es una matriz de 5 filas y 13 columnas.
byte secuencias[5][13] =
{
{ 6 , 1 , 2 , 4 , 8 , 16 , 32 },
{ 6 , 32 , 16 , 8 , 4 , 2 , 1 },
{ 12 , 0 , 32 , 48 , 56 , 60 , 62 , 63 , 31 , 15 , 7, 3 , 1 },
{ 5 , 48 ,12 , 3 , 12, 48 },
{ 5 , 33 ,18 , 12 , 18 , 33 },
};
La codificación final para el ejemplo 7 se muestra a continuación:
byte secuencias[5][13] =
{
{ 6 , 1 , 2 , 4 , 8 , 16 , 32 },
{ 6 , 32 , 16 , 8 , 4 , 2 , 1 },
{ 12 , 0 , 32 , 48 , 56 , 60 , 62 , 63 , 31 , 15 , 7, 3 , 1 },
{ 5 , 48 ,12 , 3 , 12, 48 },
{ 5 , 33 ,18 , 12 , 18 , 33 },
};
int conta , tiempo = 3;

int dato, efecto = 0;
void setup()
pinMode (5, INPUT);

pinMode (4, INPUT);
pinMode (3, INPUT);
pinMode (2, INPUT);
}
_____________________________________________________________________________________________________________________

___________________________________________________________________________________________________________
void loop()
{ for (conta = 1 ; conta <=secuencias[efecto][0] ; conta++)
{ dato = secuencias [ efecto ] [ conta ] ;
digitalWrite ( 8 , dato%2 );
dato = dato / 2;
dato = dato / 2;
dato = dato / 2;
dato = dato / 2;
dato = dato / 2;
delay ( tiempo * 100 ) ;
if ( digitalRead(2) == 0 )
if ( tiempo >= 2 )
tiempo = tiempo - 1;
if (tiempo <= 8)
tiempo = tiempo + 1;
if( digitalRead(4) == 0 )
if( efecto >= 1 )
efecto = efecto - 1;
if( digitalRead(5) == 0 )
if( efecto <= 3 )
efecto = efecto + 1;
}
}
_____________________________________________________________________________________________________________________

Guia Arduino 20220704

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia Arduino 20220704

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD MAYOR DE SAN ANDRES SEMINARIO TALLER:

FACULTAD DE TECNOLOGIA PRIMEROS PASOS CON

PRIMEROS PASOS CON ARDUINO

1. Instalación del Software (Entorno Integrado de desarrollo)

Para la instalar el Software requerido para desarrollo de aplicaciones en Arduino, visitar

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 1 -

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 2 -

De esta manera el escritorio mostrara el icono correspondiente desde el cual

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 3 -

En la misma escoger la segunda opción y hacer clic en “Siguiente”.

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 4 -

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 5 -

Al mostrarse la anterior ventana hacer clic en “Finalizar”; el mencionado chip presente

Inicio – panel de control – sistema – Hardware – Administrador de dispositivos – puertos

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 6 -

3. UTILIZACION DEL SOFTWARE ARDUINO

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 7 -

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 8 -

Como inicializar la ventana de códigos para comenzar un programa

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 9 -

Cuando vayamos a comenzar cualquier programa en el entorno Arduino siempre

4. PROGRAMA EJEMPLO 1 PARA ARDUINO

Para confeccionar el primer programa en Arduino escogeremos aquel que debe

Y con ellos tenemos listo el hardware de nuestro primer programa.

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 10 -

4.2. Instrucción digitalWrite

Ahora que definimos el terminal a utilizar, y además el modo de funcionamiento

La instrucción “digitalWrite” requiere dos parámetros: el terminal sobre el cual actuara y

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 11 -

4.3. Compilar un programa

El programa codificado debería funcionar, para verificar el mismo en busca de errores

Al activar esta herramienta se procederá a compilar el programa y después de unos

4.4. Mensajes de Error

Si al efectuar la compilación se encuentran errores, esta operación se detendrá,

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 12 -

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 13 -

Esta configuración de puerto también se la efectúa en el menú “Herramientas”:

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 14 -

En realidad el programa si está funcionando, el LED se enciende y apaga, pero a una

4.5. Instrucción delay

Permite efectuar una pausa o retardo en nuestros programas, después de escribirla

Subir el programa y ahora si o si el LED deberá encenderse y apagarse a intervalos de

 Instalar el software del Arduino

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 15 -

5. PROGRAMA EJEMPLO 2 PARA ARDUINO

Al efectuar el primer programa pudimos observar que la placa Arduino posee 14

Ahora procedamos a dedicarnos al

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 16 -

Ahora definamos la secuencia que

La primera combinación hará que solo se encienda el LED conectado al terminal

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 17 -

Para asignar la primera combinación a los

Si compilamos y cargamos el programa a la

Compilando y cargando el programa a la

Y listo, compilando y cargando el

RECOPILADO Y EDITADO POR T.S. JAVIER JORGE TICONA CHAMBI - Pág. 18 -

5.1. Modificaciones al segundo programa:

El segundo ejemplo de esta guía funciona de acuerdo a los requerimientos

Ahora, supongamos que la velocidad a la que se ejecuta la secuencia es muy

Como vemos con los dos ejemplos anteriores, cambiar la velocidad de la

Una variable es una porción de memoria, que tiene un nombre o identificador y

5.3. Tipos de datos

Mencionamos que una variable puede guardar un determinado valor, de acuerdo

byte almacena un valor numérico de 8 bits sin decimales