GUIA DE LABORATORIO N° 1

ESTRUCTURAS DE PROGRAMACIÓN EN ARDUINO

Guía: M.Sc. Banher Vladimir Chambi Quispe

1. OBJETIVO

Conocer el funcionamiento de Arduino por medio de

experimentación y elaboración de programas
básicos para su armado y simulación.
2. MATERIALES
- Arduino UNO o Nano o ESP32
- Resistencias de 220 ohm (10)
- Diodos LED de colores (10)
- Cables o jumpers
- Protoboard o placa de pruebas
- Pulsadores cantidad 6
- Pantalla LCD I2C
- Batería de 9 Voltios o baterías recargables
- Cable OTG

3. FUNDAMENTO TEÓRICO
La estructura básica de programación de Arduino es bastante simple y divide en dos partes: setup
(Configuración) y loop (Bucle).
setup()
La función setup() se invoca una sola vez cuando el programa empieza. Se utiliza para inicializar los modos de
trabajo del pin´s, aunque no haya declaración a ejecutar.
Así mismo se puede utilizar para establecer el estado inicial de las salidas de la placa.
Void setup ()
{
pinMode(Pin, OUTPUT); // config. El ‘Pin’ como salida
digitalWrite(Pin,HIGH); // Pone el ‘Pin’ en estado HIGH
}
Loop()
Después de llamar a una función loop() hace precisamente lo que sugiere su nombre, hace que se ejecute
cíclicamente, lo que posibilita que el programa este respondiendo continuamente ante los eventos que se
produzcan en la placa.
void loop()
{
DigitalWrite(Pin,HIGH); // pone en uno (ON,5 VOLTIOS) en el PIN
Delay (1000) // espera un segundo (1000 ms)
DigitalWrite(Pin,LOW); // pone en cero (OFF,CERO VOLTIOS) en el PIN
Delay (1000) // espera un segundo (1000 ms)
}
FUNCIONES

Una función es un bloque de código que tiene un tipo de variable un nombre y sus argumentos.
Las funciones de usuario pueden ser escritas para realizar tareas repetitivas y reducir el tamaño del código o
programa.

Tipo nombreFunción (Parámetros)

{ Instrucciones;

}
{} ENTRE LLAVES

Las llaves sirven para definir el principio y el fin de un bloque de instrucciones. Se utilizan para los bloques de
programación setup(),loop(),if,for,while…, etc.

VARIABLES
Una variable debe ser declarada y opcionalmente asignada a un determinado valor. En la declaración de
variable se indica el tipo de datos que almacenará (int, float, long).

int entradavariable = 0;

TIPOS DE DATOS
Arduino permite manejar los siguientes tipos de datos.
Byte: Almacena un valor de 8 bits. Tiene un rango de 0 a 255.
Int: Almacena un valor entero de 16 bits con un rango 32767 a -32768.
Long: Valor entero almacenado en 32 bits.
Float: tipo flotante almacenado de 32 bits.
Arrays: Se trata de una colección de valores que pueden ser accedidos con un número de índice (el primer valor del índice es 0).
Definición y asignación. int myArray[]={valor0, valor1, valor2…}
Asignación del cuarto componente. myArray[3] = 10;
Recuperar los datos del componente y asignarlo a x. x= myArray[3];

ASIGNACIONES COMPUESTAS
Las asignaciones compuestas combinan una operación aritmética con una variable asignada. Estas son
comúnmente utilizadas en los bucles tal como se describe más adelante. Estas asignaciones compuestas
pueden ser:
x ++ // igual que x = x +1, o incremento de x en +1
x -- // igual que x = x - 1, o decremento de x en -1 x += y // igual que x = x + y, o incremento de x en +y x -= y // igual que x = x - y,
o decremento de x en -y x *= y // igual que x = x * y, o multiplica x por y
x /= y // igual que x = x / y, o divide x por y

Nota: Por ejemplo, x * = 3 hace que x se convierta en el triple del antiguo valor x y por lo tanto x es
reasignada al nuevo valor.

OPERADORES DE COMPARACIÓN
Las comparaciones de una variable o constante con otra se utilizan con frecuencia en las estructuras
condicionales del tipo if.. para testear si una condición es verdadera. En los ejemplos que siguen en las
próximas páginas se verá su utilización práctica usando los siguientes tipo de condicionales: x == y // x es igual a
y
x != y // x no es igual a y x < y // x es menor que y
x > y // x es mayor que y
x <= y // x es menor o igual que y x >= y // x es mayor o igual que y

OPERADORES LÓGICOS
Los operadores lógicos son usualmente una forma de comparar dos expresiones y devolver un VERDADERO
o FALSO dependiendo del operador. Existen tres operadores lógicos, AND (&&), OR (||) y NOT (!), que a
menudo se utilizan en estamentos de tipo if:
Lógica AND:
if (x > 0 && x < 5) //cierto sólo si las dos expresiones son ciertas
Lógica OR:
if (x > 0 || y > 0) // cierto si una cualquiera de las expresiones es cierta

Lógica NOT:
if (!x > 0) // cierto solo si la expresión es falsa

CONSTANTES
El lenguaje de programación de Arduino tiene unos valores predeterminados, que son llamados
constantes. Se utilizan para hacer los programas más fáciles de leer. Las constantes se clasifican en
grupos.

CIERTO/FALSO (TRUE/FALSE)
Estas son constantes booleanas que definen los niveles HIGH (alto) y LOW (bajo) cuando estos se refieren
al estado de las salidas digitales. FALSE se asocia con 0 (cero), mientras que TRUE se asocia con 1, pero
TRUE también puede ser cualquier otra cosa excepto cero. Por lo tanto, en sentido booleano, -1, 2 y -200
son todos también se definen como TRUE. (esto es importante tenerlo en cuanta). if (b == TRUE);
{
ejecutar las instrucciones;
}
HIGH/LOW
Estas constantes definen los niveles de salida altos o bajos y se utilizan para la lectura o la escritura digital
para las patillas. ALTO se define como en la lógica de nivel 1, ON, ó 5 voltios, mientras que BAJO es lógica
nivel 0, OFF, o 0 voltios.

digitalWrite(13, HIGH); // activa la salida 13 con un nivel alto (5v.)

INPUT/OUTPUT

Estas constantes son utilizadas para definir, al comienzo del programa, el modo de funcionamiento de los
pines mediante la instrucción pinMode de tal manera que el pin puede ser una entrada INPUT o una salida
OUTPUT.
pinMode(13, OUTPUT); // designamos que el PIN 13 es una salida

CONTROL DE FLUJO
if (si condicional) do… while
if (unaVariable ?? valor) do
{ {
ejecutaInstrucciones; x = leeSensor();
} delay(50);
} while (x < 100);
 if… else (si….. sino For
for (inicialización; condición; expresión) {
..) if (inputPin < 500)
Instrucciones;
{
}
instruccionesA;
}
else if (inputPin >= 1000) While
{ while (unaVariable ?? valor)
instruccionesB; {
{ ejecutarSentencias;
else }
{
instruccionesC;
}

ENTRADAS Y SALIDAS DIGITALES

pinMode(pin, mode)

Esta instrucción es utilizada en la parte de configuración setup () y sirve para configurar el modo de trabajo de
un PIN pudiendo ser INPUT (entrada) u OUTPUT (salida).

pinMode(pin, OUTPUT); // configura ‘pin’ como salida

Los terminales de Arduino, por defecto, están configurados como entradas, por lo tanto no es necesario
definirlos en el caso de que vayan a trabajar como entradas. Los pines configurados como entrada quedan, bajo
el punto de vista eléctrico, como entradas en estado de alta impedancia.

Estos pines tienen a nivel interno una resistencia de 10 KΩ a las que se puede acceder mediante software.
Estas resistencias se acceden de la siguiente manera:

pinMode(pin, INPUT); // configura el ‘pin’ como entrada

digitalWrite(pin, HIGH); // activa las resistencias internas

Las resistencias internas normalmente se utilizan para conectar las entradas a interruptores.

Los pines configurados como OUTPUT (salida) se dice que están en un estado de baja impedancia estado y
pueden proporcionar 40 mA (miliamperios) de corriente a otros dispositivos y circuitos. Esta corriente es
suficiente para alimentar un diodo LED (no olvidando poner una resistencia en serie), pero no es lo suficiente
grande como para alimentar cargas de mayor consumo como relés o motores.

Un cortocircuito en las patillas Arduino provocará una corriente elevada que puede dañar o destruir el chip
Atmega. A menudo es una buena idea conectar en la OUTUPT (salida) una resistencia externa de 470 o de
1000 Ω.

digitalRead(pin)

Lee el valor de un pin (definido como digital) dando un resultado HIGH (alto) o LOW (bajo). El pin se puede
especificar ya sea como una variable o una constante (0-13).

valor = digitalRead(Pin); // hace que 'valor sea igual al estado leído en ´Pin´ digitalWrite(pin, value );

Envía al ´pin´ definido previamente como OUTPUT el valor HIGH o LOW (poniendo en 1 o 0 la salida). El pin se
puede especificar ya sea como una variable o como una constante (0-13).

CONTROL DEL TIEMPO

delay(ms)

Detiene la ejecución del programa la cantidad de tiempo en ms que se indica en la propia instrucción. De tal
manera que 1000 equivale a 1seg.

delay(1000); // espera 1 segundo

millis()

Devuelve el número de milisegundos transcurrido desde el inicio del programa en Arduino hasta el momento
actual. Normalmente será un valor grande (dependiendo del tiempo que esté en marcha la aplicación después
de cargada o después de la última vez que se pulsó el botón “reset” de la tarjeta).

valor = millis(); // valor recoge el número de milisegundos

Nota: Este número se desbordará (si no se resetea de nuevo a cero), después de aproximadamente 9

horas.

4. LABORATORIO
Diagrama esquemático Simulación

COMPONENTES EN PROTEUS BUTTON

CODIGO FUENTE EN ARDUINO RES
a) Luces secuenciales: Elaborar un algoritmo y código en C para generar un juego de luces secuenciales
de ocho pines con un tiempo de 1 segundo y simularlo COMPUTADOR.
b) Luces de sirena: conectar dos leds en salidas definidas por el grupo y generar una señal con dos salidas
secuencialmente generando una señal cuadrada de encendido y apagado.
c) Auto Fantástico: Elaborar un programa en C para generar un juego de luces de modo que genere la
secuencia del auto fantástico y simularlo.
d) Diseño de un semáforo con dos Vías
https://duino.pro/como-instalar-esp32-en-el-ide-de-arduino-tutorial/