Ejercicios de
Arduino
Introducción a la programación en:
Prof. Daniel Tedesco
Es un tipo de dato que nos permite guardar información, en el entorno de programación y en una parte de la ram de la placa Arduino
Programar consiste básicamente en decirle a tu Arduino y a los actuadores que este controla desde sus puertos (o “shields”) lo que tiene que hacer (o esperamos que haga, todos los programadores saben que estas son cosas frecuentemente diferentes).
Un programa (o “sketch” en la jerga Arduino) consigue este objetivo fundamentalmente mediante el procesamiento más o menos complejo de datos y la transmisión de estos datos procesados a los actuadores. Lo que llamamos variables es simplemente una manera de codificar o representar estos datos dentro del sketch para facilitar su manipulación de cara a su transmisión hacia o desde los actuadores/sensores.
Desde un punto de vista práctico, podemos considerar las variables como los cajones de un escritorio, cada uno tiene una etiqueta describiendo el contenido y dentro de él se encuentra el valor de la variable (el contenido del cajón). Hay tantos tipos de variables como de datos: números de todo tipo representados de diferentes maneras (enteros, reales, binarios, decimales, hexadecimales, etc.), textos (de un solo o varios caracteres o líneas), matrices (arrays), constantes, etc.
Para saber más: aquí
//int es una variable para un dato entero, igual a un número tanto positivos como negativos
//int va desde los -32,768 to 32,767
//Si agregamos la variablable unisgned int, duplicamos las posibilidades del valor
Estos valores están limitados por las características del hardware Arduino que es de 16 bits o 2 bytes
En C++ un String es un tipo de datos que es usado para guardar cadenas de caracteres.
Ejemplo:
String ejemplo1 = "Hola ";
String ejemplo2 = "Mundo!";
String resultado;
void setup() {
resultado = ejemplo1+ejemplo2;
Serial.begin(9600);
Serial.print("El resultado de la concatenacion es: ");
Serial.println(resultado);
}
void loop() {
// put your main code here, to run repeatedly:
}
Arrays
Un array o arreglo es un conjunto de datos que pueden indexarse y recuperarse. Es decir, es un conjunto de variables en al cuales puedo guardar datos
Arrays
Ejemplos:
int edades[5];//cantidad de casilleros o tamaño de la variable
float peso [10]; // guardo los valores de peso de 10 personas
int edades1 [] = {12, 56 ,60};// el sistema interpreta que existen 3 casilleros
int edades2[10]={12, 56, 60};// el sistema guarda 10 espacios pero solo utiliza 3
int dinero_en_cuenta[10] ={50,-12,30};//el sistema puede registrar números negativos
char mensaje[30] = "hola bienvenidos";// se pueden armar arryas de texto
Ejemplos
// C++ code
//
String ejemplo1 = "Hola ";
String ejemplo2 = "Mundo!"; // variables globales(fuera de las funciones)
String resultado;
void setup() {
int ejemplo1= "Chau "//variable local(dentro de la función)
resultado = ejemplo1+ejemplo2;
Serial.begin(9600);
Serial.print("El resultado de la concatenacion es: ");
Serial.println(resultado);
}
void loop() {
// put your main code here, to run repeatedly:
}
Variables globales: Fuera de la función
Variables locales: Dentro de una función
int dinero_en_cuenta[10] ={50,-12,30};
void setup (){
Serial.begin(9600);
delay(100);
Serial.println (String(dinero en cuenta[0]));// en el monitor serie se imprimre la posicion 0=50
}
void loop (){
}
int dinero_en_cuenta[10] ={50,-12,30};
void setup (){
Serial.begin(9600);
delay(100);
diero_en_cuenta[0] = 10;// cambio el valor de la posición 0,por 10
Serial.println (String(dinero en cuenta[0]));// en el monitor serie se imprimre la posicion 0=10
}
void loop (){
}
Un operador es un elemento de programa que se aplica a uno o varios operandos en una expresión o instrucción. Un operador es un símbolo que indica al compilador que se lleve a cabo ciertas manipulaciones matemáticas o lógicas
Los operadores aritméticos que se incluyen en el entorno de programación son suma, resta, multiplicación, división, módulo y asignación. Estos devuelven la suma, diferencia, producto, cociente o resto (respectivamente) de dos operandos
Las operadores compuestos 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:
++, –
+= , -= , *= , /=
Operadores de comparación. Las comparaciones de una variable o constante con otra se utilizan con frecuencia en las estructuras condicionales del tipo if, while, etc.. para testear si una condición es verdadera.
==, !=, <, >, <=, >=
Los operadores lógicos o booleanos son usualmente una forma de comparar dos expresiones y devuelve 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
IF es un condicional, que ejecuta una orden si ocurre previamente una condición o estado
Ejemplo:
IF - SI(si se cumple el paréntesis) {entonces se ejecuta el corchete}
Ejemplo2:
IF - SI(si se cumple el paréntesis) {entonces se ejecuta el corchete}
else -sino{ocurre otra cosa}
// C++ code//pulsar y mantener pulsado
//
void setup()
{
pinMode(2, INPUT);//configuro el pin 2 como entrada, para leer cuando el pulsador este presionado
pinMode(13, OUTPUT);//configuro el pin 13 y monitoreo el led onboard
}
void loop(){
int estadoboton = digitalRead(2);//leo el estado del pin 2, guardo el resultado en una variable
if(estadoboton == 1){//si lo que pasa en el parentesis se cumple, se ejecuta el corchete
delay(1000);//probar primeramente sin delay
digitalWrite(13, HIGH);
}
else{
delay(1000);
digitalWrite(13, LOW);
}
}
> Mayor que
< Menor que
>= Mayor o igual
!= Desigual (cambiar en el código anterior)
Es una estructura de control que sirve para repetir ciertas instrucciones un número determinado de veces. Las instrucciones que se repiten son las que el usuario decide, y el número de veces que se repiten también lo determina el usuario.
Fuente: https://www.wexterhome.com/curso-arduino/el-bucle-for/
/*
* SINTAXIS DEL BUCLE FOR
* for(expresión de inicio, condición, incremento/decremento){
* instrucciones;
* }
*/
const int LED1 = 10;
const int LED2 = 11;
const int LED3 = 12;
void setup() {
// put your setup code here, to run once:
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(LED3, OUTPUT);
}
void loop() {
// put your main code here, to run repeatedly:
digitalWrite(LED1, HIGH);
delay(500);
digitalWrite(LED1, LOW);
delay(500);
digitalWrite(LED2, HIGH);
delay(500);
digitalWrite(LED2, LOW);
delay(500);
digitalWrite(LED3, HIGH);
delay(500);
digitalWrite(LED3, LOW);
delay(500);
}
const int LED1 = 10;
const int LED2 = 11;
const int LED3 = 12;
void setup() {
// put your setup code here, to run once:
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(LED3, OUTPUT);
}
void loop() {
// put your main code here, to run repeatedly:
for(int i = 10; i<13; i++){
digitalWrite(i, HIGH);
delay(500);
digitalWrite(i, LOW);
delay(500);
}
}
Realizar las siguientes pruebas en TinkerCAD
Tabla de resistencias: Varía las resistencias de tus leds según la tabla
Interpretación de las resistencias
Calculadora de resistencias (Click en la imagen)
Diagrama
/*Actividad:
Realizá el programa y luego completá los siguientes desafíos:
¿Cómo cambiamos la intensidad el led?
¿Cómo variamos el tiempo de encendido?
¿Cómo logramos que el led quede encendido continuamente?*/
byte led = 13;
void setup() {
pinMode(led, OUTPUT);
}
void loop(){
digitalWrite(led, HIGH);
delay(500);
digitalWrite(led, LOW);
delay(500);
}
Diagrama
/*Variación de la intensidad del LED con potenciómetro.
Seguir las conexiones y una vez energizado, variar la
del potenciómetro para cambiar la intensidad del LED
Prof. Daniel Tedesco */
int led = 3;
int pot = A0;
void setup() {
pinMode(led, OUTPUT);
}
void loop() {
analogWrite(led, analogRead(pot)/4);
}
void setup() {
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
digitalWrite(12, HIGH);
delay(1000);
digitalWrite(12, LOW);
delay(1000);
}
void setup() {
pinMode(13, OUTPUT);
pinMode(12, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
digitalWrite(12, HIGH);
delay(1000);
digitalWrite(13, LOW);
digitalWrite(12, LOW);
delay(1000);
}
// C++ code
//
int pulsador = 3;
int led = 2;
int estado = LOW;
void setup()
{
pinMode(pulsador, INPUT);
pinMode(led, OUTPUT);
}
void loop()
{
while (digitalRead(pulsador) == LOW){
}
estado = digitalRead(led);
digitalWrite(led, !estado);
while (digitalRead(pulsador) == HIGH){
}
}
Encender led RGB
int led_rojo = 6;//elegimos pines PWM ~
int led_azul = 5;
int led_verde = 3; // Dividimos el led RGB en 3 variables, 1 por cada pin o color
void setup()
{
pinMode(led_rojo, OUTPUT);
pinMode(led_verde, OUTPUT);
pinMode(led_azul, OUTPUT);//Asignamos los pineso variables como salida
}
void loop()
{
analogWrite(led_rojo, 255);//Aplicamos 255 a los 3 pines para formar el color "Blanco"
analogWrite(led_verde,255);
analogWrite(led_azul, 255);
delay(5000);//dejamos un delay mayor para le color blanco
analogWrite(led_rojo, 255);//Asignamos 255 a un color y 0 a otros
analogWrite(led_verde,0);
analogWrite(led_azul, 0);
delay(2000);
analogWrite(led_rojo, 0);
analogWrite(led_verde,255);
analogWrite(led_azul, 0);
delay(2000);
analogWrite(led_rojo, 0);
analogWrite(led_verde,0);
analogWrite(led_azul, 255);
delay(2000);
}
1. Seleccionar colores en https://htmlcolorcodes.com/es/ o Photoshop
2. Seleccionar en código decimal RGB
3. Reproducirlo con Arduino
int rojo = 8;
int amarillo = 9;
int verde = 10;
void setup() {
pinMode(rojo, OUTPUT);
pinMode(amarillo, OUTPUT);
pinMode(verde, OUTPUT);
}
void loop() {
digitalWrite(rojo, HIGH);
delay(3000);
digitalWrite(rojo, LOW);
digitalWrite(amarillo, HIGH);
delay(1000);
digitalWrite(amarillo, LOW);
digitalWrite(verde, HIGH);
delay(2000);
digitalWrite(verde, LOW);
digitalWrite(amarillo, HIGH);
delay(1000);
digitalWrite(amarillo, LOW);
}
// C++ code
//
#define REDCARS 13
#define YELLOWCARS 12
#define GREENCARS 11
#define GREENPEDESTRIANS 10
#define REDPEDESTRIANS 9
#define SIGNAL 3
#define BUTTON 6
void setup()
{
pinMode(REDCARS,OUTPUT);
pinMode(YELLOWCARS,OUTPUT);
pinMode(GREENCARS,OUTPUT);
pinMode(REDPEDESTRIANS,OUTPUT);
pinMode(GREENPEDESTRIANS,OUTPUT);
pinMode(SIGNAL,OUTPUT);
pinMode(BUTTON,INPUT_PULLUP);
digitalWrite(REDCARS,LOW);
digitalWrite(YELLOWCARS,LOW);
digitalWrite(GREENCARS,HIGH);
digitalWrite(REDPEDESTRIANS,HIGH);
digitalWrite(GREENPEDESTRIANS,LOW);
digitalWrite(SIGNAL,LOW);
}
void loop()
{
if(digitalRead(BUTTON)==LOW)
{
digitalWrite(SIGNAL,HIGH);
delay(1000);
digitalWrite(YELLOWCARS,HIGH);
digitalWrite(GREENCARS,LOW);
delay(1000);
digitalWrite(YELLOWCARS,LOW);
digitalWrite(REDCARS, HIGH);
digitalWrite(SIGNAL,LOW);
digitalWrite(REDPEDESTRIANS,LOW);
digitalWrite(GREENPEDESTRIANS,HIGH);
delay(3000);
for(int i = 0;i<3;i++)
{
digitalWrite(GREENPEDESTRIANS,LOW);
delay(1000);
digitalWrite(GREENPEDESTRIANS,HIGH);
delay(1000);
}
digitalWrite(GREENPEDESTRIANS,LOW);
digitalWrite(REDPEDESTRIANS,HIGH);
digitalWrite(REDCARS, LOW);
digitalWrite(GREENCARS,HIGH);
}
}
#include <Servo.h>
Servo barrera;
int echo = 2; // Pin del sensor de ultrasonido
int trig = 3; // Pin del sensor de ultrasonido
long duracion, distancia;
int buzzer = 4; // Pin del buzzer
int led1 = 5; // Pin del primer LED
int led2 = 6; // Pin del segundo LED
void setup() {
pinMode(trig, OUTPUT); // Configura el pin del sensor de ultrasonido como salida
pinMode(echo, INPUT); // Configura el pin del sensor de ultrasonido como entrada
pinMode(buzzer, OUTPUT); // Configura el pin del buzzer como salida
pinMode(led1, OUTPUT); // Configura el pin del primer LED como salida
pinMode(led2, OUTPUT); // Configura el pin del segundo LED como salida
barrera.attach(9); // Configura el pin del servo como salida
barrera.write(90); // Inicializa el servo en 90 grados
}
void loop() {
digitalWrite(trig, LOW);
delayMicroseconds(2);
digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW);
duracion = pulseIn(echo, HIGH);
distancia = duracion * 0.034 / 2;
if (distancia < 5) {
barrera.write(0); // Mueve el servo a 0 grados
digitalWrite(buzzer, HIGH); // Activa el sonido del buzzer
digitalWrite(led1, HIGH); // Enciende el primer LED
digitalWrite(led2, LOW); // Apaga el segundo LED
delay(500); // Espera medio segundo
digitalWrite(led1, LOW); // Apaga el primer LED
digitalWrite(led2, HIGH); // Enciende el segundo LED
delay(500); // Espera medio segundo
} else {
barrera.write(90); // Mueve el servo a 90 grados
digitalWrite(buzzer, LOW); // Desactiva el sonido del buzzer
digitalWrite(led1, LOW); // Apaga el primer LED
digitalWrite(led2, LOW); // Apaga el segundo LED
}
}
Descargá el modelo 3D
para imprimir aquí
// C++ code
int led = 13;
int lecturasensor;
void setup(){
Serial.begin(9600);
pinMode(led, OUTPUT);
}
void loop(){
lecturasensor = analogRead(A0);
Serial.println(lecturasensor);
if (lecturasensor < 600) {
digitalWrite(led, LOW);
}
else {
digitalWrite (led, HIGH);}
}
/*
Vamos a configurar las diferentes salidas de nuestro arduino lograr diferentes colores utilizando la tecnica de adición
*/
//INICIO VARIABLES
int ledRojo = 9;
int ledVerde = 10;
int ledAzul = 11;
int ledTest = 13;
int rojo = 0;
int verde = 0;
int azul = 0;
int todos = 0;
/*FIN VARIABLES*/
void setup() {
//INICIO SETUP SALIDAS
pinMode(ledRojo, OUTPUT);
pinMode(ledVerde, OUTPUT);
pinMode(ledAzul, OUTPUT);
pinMode(ledTest, OUTPUT);
analogWrite(ledRojo, 0);
analogWrite(ledVerde, 0);
analogWrite(ledAzul, 0);
digitalWrite(ledTest, LOW);
//Saludo Inicial con bucle for
for(int i=0;i<3;i++){
digitalWrite(ledTest, HIGH);
delay(500);
digitalWrite(ledTest, LOW);
delay(500);
}
}
void loop() {
//INICIO ENCENDER COLORES
for (rojo = 0; rojo <= 255; rojo++) {
analogWrite(ledRojo, rojo); //Escribe un valor entre 0 y 255 en un pin analógico (~). Se puede usar para encender
delay(10); // un LED con luminosidad variable o accionar un motor a diferentes velocidades
}
for (rojo = 255; rojo >= 0; rojo--) { // en este caso, usando "rojo--" en vez de incrementar, decrementa el valor de la variable
analogWrite(ledRojo, rojo); // de control "rojo" en 1
delay(10);
}
for (verde = 0; verde <= 255; verde++) {
analogWrite(ledVerde, verde);
delay(10);
}
for (verde = 255; verde >= 0; verde--) {
analogWrite(ledVerde, verde);
delay(10);
}
for (azul = 0; azul <= 255; azul++) {
analogWrite(ledAzul, azul);
delay(10);
}
for (azul = 255; azul >= 0; azul--) {
analogWrite(ledAzul, azul);
delay(10);
}
analogWrite(ledRojo, 255); //
analogWrite(ledVerde, 0);
analogWrite(ledAzul, 0);
for (verde = 0; verde <= 255; verde++) {
analogWrite(ledVerde, verde);
delay(10);
}
for (azul = 0; azul <= 255; azul++) {
analogWrite(ledAzul, azul);
delay(10);
}
for (verde = 255; verde >= 0; verde--) {
analogWrite(ledVerde, verde);
delay(10);
}
for (rojo = 255; rojo >= 0; rojo--) {
analogWrite(ledRojo, rojo);
delay(10);
}
for (azul = 255; azul >= 0; azul--) {
analogWrite(ledAzul, azul);
delay(10);
}
delay(50);
for (todos = 0; todos <= 255; todos++) {
analogWrite(ledRojo, todos);
analogWrite(ledVerde, todos);
analogWrite(ledAzul, todos);
delay(10);
}
for (todos = 255; todos >= 0; todos--) {
analogWrite(ledRojo, todos);
analogWrite(ledVerde, todos);
analogWrite(ledAzul, todos);
delay(10);
}
}
Conectar motor paso a paso
/*
Programa que realiza un giro completo del motor 28BYJ-48 en conjunto con el controlador
basado en ULN2003, detiene 5 segundos y luego comienza nuevamente. La secuencia es la de
paso completo simple (wave drive) energizando de a una bobina por vez utilizando una
matriz para su definicion.
Alimentar Arduino con fuente de alimentacion externa de 6 a 12 Vdc.
*/
int IN1 = 8; // pin digital 8 de Arduino a IN1 de modulo controlador
int IN2 = 9; // pin digital 9 de Arduino a IN2 de modulo controlador
int IN3 = 10; // pin digital 10 de Arduino a IN3 de modulo controlador
int IN4 = 11; // pin digital 11 de Arduino a IN4 de modulo controlador
int demora = 20; // demora entre pasos, no debe ser menor a 10 ms.
// paso completo simple
int paso [4][4] = // matriz (array bidimensional) con la secuencia de pasos
{
{1, 0, 0, 0},
{0, 1, 0, 0},
{0, 0, 1, 0},
{0, 0, 0, 1}
};
void setup() {
pinMode(IN1, OUTPUT); // todos los pines como salida
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop() {
for (int i = 0; i < 512; i++) // 512*4 = 2048 pasos
{
for (int i = 0; i < 4; i++) // bucle recorre la matriz de a una fila por vez
{ // para obtener los valores logicos a aplicar
digitalWrite(IN1, paso[i][0]); // a IN1, IN2, IN3 e IN4
digitalWrite(IN2, paso[i][1]);
digitalWrite(IN3, paso[i][2]);
digitalWrite(IN4, paso[i][3]);
delay(demora);
}
}
digitalWrite(IN1, LOW); // detiene por 5 seg.
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
delay(5000);
}
/*
Programa que realiza un giro completo del motor 28BYJ-48 en conjunto con el controlador
basado en ULN2003, detiene 5 segundos y luego comienza nuevamente. La secuencia es la de
paso completo con dos bobinas para una maximo torque utilizando una matriz para su
definicion.
Alimentar Arduino con fuente de alimentacion externa de 6 a 12 Vdc.
*/
int IN1 = 8; // pin digital 8 de Arduino a IN1 de modulo controlador
int IN2 = 9; // pin digital 9 de Arduino a IN2 de modulo controlador
int IN3 = 10; // pin digital 10 de Arduino a IN3 de modulo controlador
int IN4 = 11; // pin digital 11 de Arduino a IN4 de modulo controlador
int demora = 20; // demora entre pasos, no debe ser menor a 10 ms.
// paso completo con maximo torque
int paso [4][4] = // matriz (array bidimensional) con la secuencia de pasos
{
{1, 1, 0, 0},
{0, 1, 1, 0},
{0, 0, 1, 1},
{1, 0, 0, 1}
};
void setup() {
pinMode(IN1, OUTPUT); // todos los pines como salida
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop() {
for (int i = 0; i < 512; i++) // 512*4 = 2048 pasos
{
for (int i = 0; i < 4; i++) // bucle recorre la matriz de a una fila por vez
{ // para obtener los valores logicos a aplicar
digitalWrite(IN1, paso[i][0]); // a IN1, IN2, IN3 e IN4
digitalWrite(IN2, paso[i][1]);
digitalWrite(IN3, paso[i][2]);
digitalWrite(IN4, paso[i][3]);
delay(demora);
}
}
digitalWrite(IN1, LOW); // detiene por 5 seg.
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
delay(5000);
}
/*
Programa que realiza un giro completo del motor 28BYJ-48 en conjunto con el controlador
basado en ULN2003, detiene 5 segundos y luego comienza nuevamente. La secuencia es la de
medio paso para maxima precision y torque medio utilizando una matriz para su
definicion.
Alimentar Arduino con fuente de alimentacion externa de 6 a 12 Vdc.
*/
int IN1 = 8; // pin digital 8 de Arduino a IN1 de modulo controlador
int IN2 = 9; // pin digital 9 de Arduino a IN2 de modulo controlador
int IN3 = 10; // pin digital 10 de Arduino a IN3 de modulo controlador
int IN4 = 11; // pin digital 11 de Arduino a IN4 de modulo controlador
int demora = 20; // demora entre pasos, no debe ser menor a 10 ms.
// medio paso
int paso [8][4] = // matriz (array bidimensional) con la secuencia de pasos
{
{1, 0, 0, 0},
{1, 1, 0, 0},
{0, 1, 0, 0},
{0, 1, 1, 0},
{0, 0, 1, 0},
{0, 0, 1, 1},
{0, 0, 0, 1},
{1, 0, 0, 1}
};
void setup() {
pinMode(IN1, OUTPUT); // todos los pines como salida
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop() {
for (int i = 0; i < 512; i++) // 512*8 = 4096 pasos
{
for (int i = 0; i < 8; i++) // bucle recorre la matriz de a una fila por vez
{ // para obtener los valores logicos a aplicar
digitalWrite(IN1, paso[i][0]); // a IN1, IN2, IN3 e IN4
digitalWrite(IN2, paso[i][1]);
digitalWrite(IN3, paso[i][2]);
digitalWrite(IN4, paso[i][3]);
delay(demora);
}
}
digitalWrite(IN1, LOW); // detiene por 5 seg.
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
delay(5000);
}