Arduino Practica

ASOCIACIÓN SIERVOS DE LA CARIDAD
OBRA DON GUANELLA

INSTITUTO “SAN JOSÉ” A-355
TALLER
GUÍA Nº1
Sección: Especialización en Electrónica
3º Año Turno Mañana
Profesores: Occhiuzzi Walter / Caputo Oscar
2018
1
¿Qué es un ARDUINO?
Arduino es una plataforma de hardware y software de código abierto, basada en una sencilla placa con entradas y salidas,
analógicas y digitales, en un entorno de desarrollo que está basado en el lenguaje de programación Processing. Es decir, una
plataforma de código abierto para prototipos electrónicos.
Al ser “open source”, tanto su diseño como su distribución, puede utilizarse libremente para el desarrollo de cualquier tipo de
proyecto sin necesidad de licencia.
El proyecto fue concebido en Italia en el año 2005 por el zaragozano David Cuartielles, ingeniero electrónico y docente de la
Universidad de Mälmo (Suecia) y Massimo Banzi, italiano, diseñador y desarrollador Web. En el 2005 se ensayan pruebas de esta
tarjeta en los EEUU; resultan satisfactorias y así se comienzan a hacer contacto con distribuidores locales en el mercado
americano.
¿Cómo está formado un ARDUINO?
El ARDUINO básicamente está conformado por una placa en la que están integrados un microcontrolador de 8 bits (Atmel)
desde su creación en el 2005, y desde el 2012 se han creado placas de Arduino con microprocesadores de 32 bits capaces de
ejecutar funciones más exigentes.
El lenguaje de programación multifuncional con el que trabaja la placa Arduino puede trabajar con muchos otros lenguajes
como el Visual Basic de Microsoft, un sistema para programar soluciones sistemáticas dentro del ambiente Windows.
El ATmega328p como cualquier otro microcontrolador tiene registros, algunos de estos registros están relacionados con los
puertos de entrada/salida, cada puerto tiene un nombre específico y sus registros asociados, de hecho, el 328p tiene el puerto
B, C y D, y cada puerto un diferente número de pines .
Cada pin puede tener múltiples funciones, como la generación de PWM (modulación de ancho de pulso) , o las capacidades de
ADC (conversor analógico digital; los pines usados en la placa Arduino poseen tres puertos en el caso de ATmega328p (Arduino
Uno):
 B (pines digitales del 8 al 13)

 C (entradas analógicas)
 D (pines digitales del 0 al 7)
El Arduino Mega presenta varios puertos B,C,D,E,F, etc.
Las plataformas Arduino están basadas en los microcontroladores Atmega168, Atmega328, Atmega1280, ATmega8 y otros
similares, chips sencillos y de bajo costo que permiten el desarrollo de múltiples diseños.
2
3
Objetivos del curso:
 Conocer el mundo del software libre y el hardware libre.
 Aprender los conceptos básicos de programación Arduino.
 Aprender los conceptos básicos de la electrónica orientada a Arduino.
 Realizar prácticas con Arduino (concretar una idea teórica; por ejemplo hacer parpadear un led con intervalos de un
segundo)
El alumno realizará los prácticos con el “kit Arduino” que consta de los siguientes elementos como el “Arduino Uno”, más un
protoboard, más los componentes electrónicos solicitados para las prácticas; tales como: Leds, buzzer, resistencias,
potenciómetros, etc.
Podrá así tener control sobre indicadores luminosos, pudiendo manejar los tiempos activación de los mismos; como por
ejemplo será la secuencia de encendido de un semáforo; o también el poder manejar un dispositivo mecánico como lo es un
servomotor; haciendo desplazar su brazo móvil a derecha o izquierda; en amplitudes y tiempos deseados.
4
ARDUINO UNO/ NANO
5
Esta plaqueta electrónica está basada en el micro ATmega328; posee 14 entradas/salidas digitales, de las cuales 6 de estas
pueden utilizarse como salidas PWM (Power Wide Modulation = Modulación de ancho de pulso) y otras 6 son entradas
analógicas.
El ritmo de ejecución de los programas lo marca un oscilador de 16 Mhz.
Además cuenta con un conector USB, un conector de alimentación y un botón de preseteado.
Podremos entonces alimentarlas de dos maneras alternativas; por un cable USB a nuestra PC o con una fuente de 9 Volt
continua.
Cabe destacar que si usamos un cable USB no solo alimentamos el Arduino; sino también cargamos la programación de
realizamos al micro ATmega328 para que la plaqueta haga su trabajo correspondiente.
Características técnicas del Arduino Uno
Microcontrolador: ATmega328
Voltage: 5V
Voltaje de entrada (recomendado): 7-12V
Voltaje de entrada (limites): 6-20V
Digital I/O Pins: 14 (de los cuales 6 son salida PWM)
Entradas Analogicas: 6
DC Current per I/O Pin: 40 mA
DC Current parar 3.3V Pin: 50 mA
Flash Memory: 32 KB (ATmega328) de los cuales 0.5 KB son utilizados para el arranque
Clock Speed: 16 MHz
6
Entradas y salidas digitales/ analógicas
Una Arduino puede pensarse simplificadamente como un sistema que acepta información en forma de señal de entrada,
desarrolla ciertas operaciones sobre ésta y luego produce señales de salida.
En los sistemas electrónicos, una magnitud física variable se representa generalmente mediante una señal eléctrica que varía de
manera tal que describe esa magnitud. Por lo general, se hace referencia a las señales continuas como señales analógicas,
mientras que asociamos las señales discretas a señales digitales: el ejemplo más claro es el de las señales binarias, donde la
señal sólo pueden tomar dos niveles, 0 o 1.
Las terminales digitales de una placa Arduino pueden ser utilizadas para entradas o salidas de propósito general a través de los
comandos de programación pinMode(), digitalRead(), y digitalWrite().
Serial: 0 (RX) y 1 (TX). Utilizado para recibir (RX) y transmitir (TX) datos serie TTL.
Interruptores externos: 2 y 3. Estas terminales pueden ser configuradas para disparar una interrupción con un valor bajo, un
pulso de subida o bajada, o un cambio de valor.
PWM: 3, 5, 6, 9, 10, y 11. Proporcionan salidas PWM con la función analogWrite(). En placas con ATmega8, las salidas PWM
solo están disponibles en los pines 9, 10, y 11.
LED: 13. Corresponden a un led en placa conectado al pin digital 13. cuando el pin tiene valor HIGH, el LED está
encendido, cuando el pin está en LOW, está apagado
Pines Analógicos
Los pines de entrada analógicos soportan conversiones analógico-digital (ADC) de 10 bit utilizando la función analogRead().
Las entradas analógicas pueden ser también usadas como pines digitales: entrada analógica 0 como pin digital 14 hasta la
entrada analógica 5 como pin digital 19.
Pines de alimentación
VIN (a veces marcada como "9V"). Es el voltaje de entrada a la placa Arduino cuando se está utilizando una fuente de
alimentación externa (En comparación con los 5 voltios de la conexión USB o de otra fuente de alimentación regulada). Puedes
proporcionar voltaje a través de este pin.
5V. La alimentación regulada utilizada para alimentar el microcontrolador y otros componentes de la placa. Esta puede venir
de VIN a través de un regulador en placa o ser proporcionada por USB u otra fuente regulada de 5V.
3V3. (solo en el Diacemila) Una fuente de 3.3 voltios generada por el chip FTDI de la placa.
GND. Pines de tierra.
7
Protoboard. Características:
8
Conjunto Arduino + protoboard
9
SOFTWARE
SECCIÓN DE DECLARACIÓN DE VARIABLES

const int ledPin = 13; // “ ledPin” sera reemplazado por “led” o “led01”
const int buttonPin = 2; // “buttonPin” sera reemplazado por “pulsador” o “pulsador 01”
int buttonState = 0;
En esta sección se declaran que tendrán asociados los números de pines que queramos utilizar. Por ejemplo el pin 13 tendrá un
Led; y el pin 2 tendrá un pulsador (button)
SECCIÓN SETUP
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(buttonPin, INPUT);
}
Aquí se asigna al Led y al pulsador que característica tendrá frente a su circuito asociado; es decir podrán ser salidas o entradas
según el caso. Como vemos el Led será OUTPUT (salida) y el pulsador será INPUT (entrada).
10
SECCIÓN LOOP
void loop() {
buttonState = digitalRead(buttonPin);
digitalWrite(ledPin, HIGH);
delay(1000);
digitalWrite(ledPin, LOW);
delay(1000);
if (buttonState == HIGH) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin, LOW);
}
Estas son las instrucciones o programa en sí mismo; al ejecutarse las mismas; es decir al correr el programa; se van cumpliendo
nuestros objetivos; en este caso hay dos recuadros; en el 1ro un Led se enciende durante un segundo y luego se apaga también
durante un segundo, y luego se repite indefinidamente. En el 2do ; se prende un Led, pero si presionamos el pulsador, el
mismo se apaga; al soltarlo vuelve a encender.
11
Conexionado en Protoboard
TP1 al TP7
TP8 al TP12
12
TP1
“Encender un led de forma permanente”
const int led01 = 13; //Se declara al pin 13 como el pin que utilizamos para encender un led
void setup() {
pinMode(led01, OUTPUT); //Configura el pin del led como de salida OUT
}
void loop() {
digitalWrite(led01, HIGH); //Enciende un led permanente
}
TP2
“Hacer parpadear un led (encendido intermitente; 1 segundo encendido y 1 segundo apagado)”
void setup() {
pinMode(led01, OUTPUT); //Configura el pin del led como de salida OUT
}
void loop() {
digitalWrite(led01, HIGH); //Enciende el led
delay(1000); // lo enciende durante 1 segundo
digitalWrite(led01, LOW); //Apaga el led

delay(1000); // lo apaga durante 1 segundo
TP3
“Hacer parpadear un led (encendido intermitente; 200 milisegundos encendido y 800 milisegundos apagado,
repetir la secuencia 3 veces, pausa de 5 seg”
void setup() {
pinMode(led01, OUTPUT); //Configura el pin del led como de salida OUTPUT
}
void loop() {
13
delay(200); // lo enciende durante 200 milisegundos
delay(800); // lo apaga durante 800 milisegundos
delay(5000);
}
TP4
“Hacer parpadear un led encendido intermitente; 100 milisegundos encendido y 900 milisegundos apagado y
poder apagarlo manteniendo presionado un pulsador; que al soltarlo volverá a la secuencia original ”
const int pulsador01 = 2; //Se declara al pin 2 como el pin que utilizamos con el pulsador
int buttonState = 0; // condición de activado del pulsador
void setup() {
pinMode(led01, OUTPUT); //Configura el pin del led como de salida (OUTPUT)
pinMode(pulsador01, INPUT); //Configura al pin del pulsador como de entrada (INPUT)
void loop() {
buttonState = digitalRead(pulsador01);
if (buttonState ==HIGH) {
}
else {
digitalWrite(led01,LOW); //Apaga el led, de forma permanente mientras tengamos presionado el pulsador.
}
}
TP5
“Encender dos Leds (rojo y verde) en forma alternativa; utilizando un pulsador para esta operatoria; por
ejemplo inicialmente el led verde está encendido, y cuando presionamos el pulsador se apaga el verde y
enciende el led rojo; cuando dejamos de presionarlo, el rojo apaga y nuevamente el verde queda encendido”
14
const int led01 = 13; //Se declara al pin 13 como el pin que usamos para encender un led verde
const int led02 = 8; //Se declara al pin 13 como el pin que utilizamos para encender un led rojo
void setup() {
pinMode(led01, OUTPUT); //Configura el pin del led como de salida OUTPUT (verde)
pinMode(led02,OUTPUT); //Configura el pin del led como de salida OUTPUT (rojo)
pinMode(pulsador01, INPUT); //Configura al pin del pulsador como de entrada INPUT
}
void loop() {
digitalWrite(led01, HIGH); //Enciende el led verde
digitalWrite(led02, LOW); //Apaga el led rojo
}
else {
digitalWrite(led01, LOW); //Apaga el led verde
digitalWrite(led02, HIGH); //Enciende el led rojo
}
}
TP6
“Encender dos Leds (rojo y verde) alternativamente uno encendido y el otro apagado, con un ritmo de 100
mseg (rápido) y cuando presionemos el pulsador la secuencia de encendido de leds pasará a 1000 mseg
(lenta). Al soltar el pulsador se vuelve a la secuencia original”
const int led01 = 13; //Se declara al pin 13 como el pin que utilizamos para encender un led verde
void setup() {
}
void loop() {
buttonState = digitalRead(buttonPin);
15
}
else {

}
}
TP7
“inicialmente mantener los dos leds apagados; luego si presionamos uno de los dos pulsadores debe encender
un led (verde) ; si presionamos el otro pulsador debe únicamente encender el led restante (rojo).Al soltar
cualquiera de los pulsadores la secuencia debe quedar retenida; y si presionamos el pulsador restante se
conmuta el encendido (prende uno y apaga el otro)”
int pulsador01State = 0; // condición de activado del pulsador
void setup() {
void loop() {
pulsador01State = digitalRead(pulsador01);
if (pulsador01State == LOW) {
digitalWrite(led02, LOW); //Desactiva el led rojo
}
16
digitalWrite(led01, LOW); //Desactiva el rojo
TP8
“inicialmente mantener los dos leds apagados; luego si presionamos uno de los dos pulsadores debe encender
un led (verde) ; si presionamos el otro pulsador debe únicamente encender el led restante (rojo). Al soltar
cualquiera de los pulsadores la secuencia debe anularse y volver a la condición inicial(leds apagados) ”
void setup() {
void loop() {
if (pulsador01State == HIGH and pulsador02State == HIGH) {

}
}

digitalWrite(led01, LOW); //Desactiva el rojo
17
}
TP9
“inicialmente mantener los dos leds encendidos con 100mseg de parpadeo uno y otro (prende uno y apaga el
otro y viceversa); luego si presionamos uno de los dos pulsadores debe encender un led (verde) solamente ; si
presionamos el otro pulsador debe encender únicamente el led restante (rojo). Al soltar cualquiera de los
pulsadores la secuencia debe ser la del inicio”
const int pulsador02 = 3;
int pulsador02State = 0;
void setup() {
}
void loop() {
// if (pulsador01State == HIGH and pulsador02State == HIGH) {

delay(100);

delay(100);
// }

18
}
}
TP10
“Ultilizando un pulsador encender un led verde que se mantendrá prendido durante 5 segundos, luego se
prenderá un led rojo; quedando ambos encendidos indefinidamente. Con otro pulsador se podrá apagar la
secuencia para volver al inicio”
int pulsador02State = 0;
void setup() {
}
void loop() {

delay (5000);

}
}
19
TP11
“Hacer encender tres Leds (rojo, amarillo y verde) en forma secuencial (alternativa) ; con 1 segundo de
encendido en cada uno de ellos. (Siempre un Led encendido y el resto apagado)
const int ledPin1 = 13; //verde

const int ledPin = 8; // amarillo
const int ledPin2 = 12; //rojo
void setup() {
pinMode(ledPin, OUTPUT);
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
digitalWrite(8, LOW);
delay(1000);
delay(1000);
delay(1000);
TP12
“Hacer encender 6 Leds (rojo, amarillo y verde) en forma secuencial (alternativa); con 100 milisegundos de
encendido el verde, 900 mseg apagado (todos); luego 100 mseg de encendido el amarillo , 900 mseg apagado
(todos); y por último el rojo 100 mseg encendido y 900 mseg apagado, también todos. (siempre un Led
encendido y el resto apagado)
const int led01 = 13;


20
void setup() {
pinMode(led01, OUTPUT);
void loop() {
digitalWrite(13, HIGH); //verde

digitalWrite(8, HIGH); //verde
delay(100);
delay(900);
digitalWrite(12, HIGH); //amarillo
digitalWrite(11, HIGH); //amarillo
delay(100);
delay(900);
digitalWrite(10, HIGH); //rojo
21
digitalWrite(9, HIGH); //rojo
delay(100);
TP13
“Hacer encender seis Leds (rojo, amarillo y verde) en forma secuencial (alternativa); con 200 milisegundos de
encendido en cada uno de ellos. (siempre un Led encendido y el resto apagado). Incluir un pulsador que
detenga la secuencia de barrido.

const int led01 = 13; //verde
const int led02 = 8; // amarillo
const int led03 = 12; //rojo

const int led05 = 10; //amarillo
const int led06 = 9; // rojo
void setup() {
pinMode(pulsador01, INPUT);
}
void loop() {
buttonState = digitalRead(pulsador01Pin);
digitalWrite(13, LOW)
22
delay(200);
delay(200);
delay(200);
delay(200);
delay(200);
delay(200);
else {
23
}
}
TP14
“Hacer encender 6 leds simultaneamente con secuencia 200 mseg prendido y 800 mseg apagado; luego si
presionamos un pulsador esta secuencia se altera siendo más lenta, con 1 segundos encendidos y 1 segundo
apagados, si soltamos el pulsador, se vuelve a la secuencia original.


void setup() {
pinMode(pulsador01, INPUT);
}
void loop() {
delay(200);
digitalWrite(8,LOW);
delay(800);
}
24
else {
delay(1000);
digitalWrite(8,LOW);
delay(1000);
}
}
TP15
“Armar una secuencia de dos semáforos con los seis Leds de los prácticos anteriores”


void setup() {
void loop() {
25
//SEMÁFORO1
digitalWrite(8, LOW);//amarillo....de entrada todos por un instante apagados
digitalWrite(12, LOW);//rojo
digitalWrite(13, LOW);//verde
//SEMÁFORO2
digitalWrite(10, LOW);//amarillo....de entrada todos por un instante apagados
digitalWrite(9, LOW);//rojo
digitalWrite(11, LOW);//verde
//1ra secuencia
digitalWrite(13, HIGH);//verde...enciende durante 20 segundos SEMÁFORO1
digitalWrite(9, HIGH);//rojo...enciende durante 20 segundos SEMÁFORO2
delay(20000);
----------------------------------------------------------------
digitalWrite(13, LOW);//verde....queda apagado SEMÁFORO1
-----------------------------------------------------------------
// 2da secuencia
digitalWrite(8, HIGH);//amarillo....enciende durante 2 segundos SEMÁFORO1
digitalWrite(9, HIGH);//rojo....enciende durante 2 segundos SEMÁFORO2
delay (2000)
26
-----------------------------------------------------------------------
digitalWrite(8, LOW);//amarillo....queda apagado SEMÁFORO1
-----------------------------------------------------------------------
//3ra secuencia
digitalWrite(10, HIGH);//amarillo....enciende durante 2 segundos SEMÁFORO2
delay(2000);
--------------------------------------------------------------------
digitalWrite(9, LOW);//rojo....queda apagado SEMÁFORO 2
digitalWrite(10, LOW);//amarillo.... queda apagado SEMÁFORO 2
//4ta secuencia

digitalWrite(11, HIGH);//verde...enciende durante 20 segundos SEMÁFORO2
27
delay(20000);
(a completar por el alumno; instrucciones e ilustración)
}
}
28
SEÑALES ANALÓGICAS Y MODULACIÓN DE ANCHO DE PULSO
(PWM)
29
TP16
“Hacer variar la resistencia de un potenciómetro lineal (de 0 a 5 kohm) pudiendo observar dichos valores
traducidos en volt (0 a 5 volt analógico) en el monitor serie de la barra herramientas del software Arduino”
const int analogPin = A0;
void setup() {
// inicializa la comunicación serial en 9600 bits por segundo

Serial.begin(9600);
void loop() {
int valor_sensor = analogRead(A0);

// lee el pin de entrada analógico (pin A0)
float voltaje = valor_sensor * (5.0 / 1023.0);

// convierte el valor analógico en valor digital de 10 bits
delay(300);
// toma muestras y las visualiza en monitor serie cada 300 milisegundos
Serial.println(voltaje);
// las muestra en monitor serie verticalmente, una detrás de la otra, actualizándose.
TP17 “Haciendo ingresar a un Servomotor una señal PWM (modulación de ancho de pulso) desde el
Arduino Uno; lograr que la bielita del mecanismo gire de derecha a izquierda y viceversa”
const int servo = 4;
void setup() {
pinMode(servo, OUTPUT);
void loop() {
30
digitalWrite(servo, HIGH); //Se mueve en un sentido
delay(2); // o también en microsegundos, por ej. delayMicroseconds (2000);
digitalWrite(servo, LOW);
delay(8); // o también en microsegundos, por ej. delayMicroseconds (8000);
//digitalWrite(servo, HIGH); Se mueve en sentido contrario al anterior

//delay(1);
//digitalWrite(servo, LOW);
//delay(9);
TP18 “Encender un led de manera progresiva; con un nivel bajo de luminosidad; pasando por 5 etapas
diferentes, siendo la última, la plena. Utilizar para ello un potenciómetro con el cual diferenciemos esas
etapas (de 0 a 5 volt en 5 escalones o niveles)”
const int ledPin = 13; //Se declara al pin 13 como el pin que utilizamos para encender un led
const int analogPin = A0;
void setup() {
pinMode(ledPin, OUTPUT); //Configura el pin del led como de salida OUTPUT
// inicializa la comunicación serial en 9600 bits por segundo

Serial.begin(9600);
void loop() {
int valor_sensor = analogRead(A0);

// lee el pin de entrada analógico (pin A0)
float voltaje = valor_sensor * (5.0 / 1023.0);

// convierte el valor analógico en valor digital de 10 bits
// delay(300); no se habilita porque sino DISTORCIONA los tiempos de parpadeo del led
// toma muestras y las visualiza en monitor serie cada 300 milisegundos
// las muestra en monitor serie verticalmente, una detrás de la otra, actualizándose.
if (voltaje > 0 and voltaje < 1) {
digitalWrite(ledPin, HIGH); //Enciende el led

31
delayMicroseconds(10); // lo enciende durante 10 milisegundos
digitalWrite(ledPin, LOW); //Apaga el led
delayMicroseconds (8000); // lo apaga durante 8000 milisegundos

}



32
EJERCITACIÓN:
1. Crear una secuencia de 6 leds prendiéndose cada uno 200 mseg en sentido horario y manteniendo
presionado un pulsador generar la secuencia contraria. (los leds prenden de a uno por vez)
2. Idem al anterior, pero los leds quedan encendidos, y una vez completada la secuencia horaria u
antihoraria se apagan durante 200 mseg y se vuelve a iniciar las secuencias.
3. Presionando un pulsador hacer parpadear los 2 leds verdes con 100 mseg encendido y 400
apagados; si soltamos dicho pulsador estos leds deben estar prendidos permanentemente.
4. Encender los 2 leds verdes de forma intermitente (100 mseg encendido 500 mseg apagado), luego si
presionamos un pulsador se apagan los leds verdes y quedan encendidos los leds amarillos
permanentemente; por último si presionamos otro pulsador encienden los leds rojos
alternativamente (derecha/ izquierda , 100 mseg encendidos y 500 mseg apagados). Siempre al
soltar cualquiera de los 2 pulsadores, se vuelve a la secuencia original (leds verdes)
5. Hacer encender los leds verdes con 3 niveles de luminosidad diferentes (alto, medio, bajo); el nivel
bajo sin presionar pulsadores, el nivel medio presionando un pulsador; y el nivel alto presionando el
restante.
6. Generar barras de 3 leds a derecha e izquierda (rojo, amarillo, verde) que enciendan en forma
alternativa (500 mseg prendida y 500 mseg apagada); si presionamos un pulsador deberían apagarse
todos los leds; si presionamos el pulsador restante deberían encenderse todos. En cualquiera de los
casos; si dejamos de presionarlos se vuelve a la secuencia original.
7. Utilizando un potenciómetro lineal, hacer encender los 2 leds verdes intermitentes (100 mseg
encendidos y 500 mseg apagados) cuando el A0 recibe una tensión generada por esta resistencia
variable de 0 a 2 volt ; a partir de 2 volt encender un led amarillo de forma intermitente (300 mseg
encendido y 300 mseg apagado, izquierda derecha); luego a partir de 4 volt encender los 2 led rojos
permanente.
8. Generar un termómetro a leds con graduación o escala de 1 led encendido cada 10 °C . Hasta los
60º, es decir máximo de 6 leds encendidos. A medida que la temperatura se incrementa los leds se
van prendiendo y no se apagan los anteriores. Utilizar para ello el potenciómetro.
33
9. Ídem al anterior, encendiendo solo un led rojo según la banda de temperatura alcanzada ( siempre
enciende un led; los demás apagados)
10. Girando un potenciómetro de 0 a 5 volt, generar 6 niveles de encendido de los leds; en solo los 2
leds rojos.
11. Generar un barrido de un servomotor de izquierda a derecha usando un potenciómetro en su

totalidad de escala (0 a 5 volt)
12. Utilizando un servomotor lograr que el bracito del mismo adopte 5 posiciones: Izquierda horizontal,
izquierda 45º , central vertical, derecha 45º y derecha horizontal. Para ello ingresar 5 PWM diferentes
utilizando un potenciómetro para lograr esa escala ( de 0 a1volt, de 1 a 2 volt, de 2 a 3 volt, de 3 a 4
volt, y de 4 a 5 volt)
13. “Hacer encender de manera progresiva dos leds de la siguiente manera: Inicialmente cuando uno de
ellos está a pleno, el otro debe estar encendido de manera tenue; y así de manera escalonada (5
etapas) y utilizando un potenciómetro lograr que el led que esta a pleno baje su intensidad hasta
tenue y el otro led de tenue a valor pleno. En la 3ra etapa ambos coincidirán en un valor intermedio.
El color de los leds a utilizar es a elección del alumno” ; las escalas preferentemente cada 1 volt; es
decir, de 0 a 1 volt , de 1 a 2 volt, de 2 a 3 volt, de 3 a 4 volt y de 4 a 5 volt.
14.
Utilizando un potenciómetro, lograr que los dos leds verdes de la plaqueta enciendan
permanentemente si el valor de tensión es inferior a 1,5 volt. Luego hacer titilar los dos leds amarillos
(500 mseg encendidos y 500 mseg apagados) si el valor de tensión se encuentra entre los 1,5 a 4,5
volt; pero esto hacerlo alternadamente, es decir, cuando un led amarillo prende, el otro debe estar
apagado y viceversa.
Y por último, cuando la tensión este entre los 4,5 volt a los 5 volt, que los dos leds rojos titilen al
mismo tiempo con de 300 mseg de encendido y 700 mseg de apagado.
34
BRAZO ROBÓTICO BÁSICO
Programación de un brazo para generar un movimiento libre operado desde

potenciómetros (3)
const int buttonPin = 2 ; // pulsador sobre el joystick

const int ledPin = 12; //led verde
const int servo = 5; // se designa que pin digital del Arduino inyectará una PWM para determinado servomotor
const int servo2 = 3;
const int analogPin = A0; // se designa que pin analógico del Arduino recibirá una señal analógica (0 a 5 volt)
desde los potenciómetros de los joystick.
const int analogPin2 = A1;
35
int x = 0 ; // valores iniciales a cero

int y = 0 ;
int z = 0 ;
int P = 0 ;
void setup() {
pinMode(ledPin, OUTPUT); // salida a led

pinMode (buttonPin, INPUT); // entrada de pulsador
pinMode(servo, OUTPUT); // digitales de salida

pinMode(servo2, OUTPUT);
pinMode(analogPin, INPUT); // analógicos de entrada

pinMode(analogPin2, INPUT);
Serial.begin(9600); Se comunica con velocidad de 9600 baudios

delay(1000); // cada 1 milésima de segundo ejecuta los siguientes paso de programa
void loop() {
int valor_sensor = analogRead(A0); // se tomarán los valores analógicos para lograr con ellos un valor númerico
de 10 bits (luego de una conversión)
int valor_pote = analogRead(A1);
int valor_giro = analogRead(A2);
int valor_pinza = analogRead(A3);
float voltaje = valor_sensor * (1 / 1023.0);

float volt = valor_pote * (1 / 1023.0);
36
float giro = valor_giro * (1 / 1023.0);
float pinza = valor_pinza * (1 / 1023.0);
//servo1
int x = (700 + ( voltaje * (4 / 0.0060)));

// el valor “0,0060” que se observa en la fórmula es un valor empírico es decir junto con el “4” , ambos sirven para
aumentar o engrosar el valor “voltaje” que nosotros ingresamos cuando movemos un joystick o un potenciómetro;
es decir el valor base 700 (mseg) de PWM que moverá el servo es afectado por :
( voltaje * (4 / 0.0060)))
Así tendremos el valor base (700) o un mayor valor; por lo tanto el eje llamado X se moverá cuando toquemos el
potenciómetro.
Retocando el valor que está dentro de la fórmula, en este caso “0.0060” …es decir agrandándolo o achicandolo
lograremos que el BRAZO SE MUEVA MÁS RÁPIDO o MÁS LENTO; pero los extremos alcanzados serán los mismos.
digitalWrite(servo, HIGH); // PWM modulación de ancho de pulso; en este caso es cresta positiva (+5 Volt) la "x"
nos dice el número de miliseg que dura.
delayMicroseconds( x);
digitalWrite(servo, LOW); PWM modulación de ancho de pulso; en este caso es "no pulso", o sea 0 Volt la
"10000 - x" nos dice el número de miliseg que dura.
delayMicroseconds(10000-x);
//servo2
int z = (700 + ( volt * (4 / 0.0028)));
digitalWrite(servo2, HIGH);
delayMicroseconds( z);
digitalWrite(servo2, LOW);
delayMicroseconds(10000-z);
37
// Servo4
int y = (900 + ( giro * (4 / 0.003)));
delayMicroseconds( y);
delayMicroseconds(10000-y);
// Servo3
int p = (900 + ( pinza * (4 / 0.003)));
delayMicroseconds( p);
delayMicroseconds(10000-p);
Aclaración:
Los valores extremos en PWM a inyectarse en los servomotores para comandar el brazo serán de
entre 500 a 2400 mseg; con estos el bracito plástico rotará aproximadamente 180º
38
Programación de un brazo para generar un movimiento ya prefijado y ubicar el
extremo del brazo en coordenadas determinadas (ejes x, y ,z)
En las siguientes instrucciones se podrán observar los “límites” aproximados que tenemos; en el caso del eje “X”
como vemos 700 a 1300 mseg para llevarlo a las posiciones extremas (atrás 700 y todo adelante 1300 mseg).
También se observará que no aparecen como en el práctico anterior la variable “voltaje” o la fórmula:
Int x=(700 + (voltaje * (4 / 0.0060))) ;
Esto sucede porque nosotros ingresamos un valor directo, no se ejecuta y calcula un valor numérico por la fórmula
anterior…sino que nosotros adoptamos los valores, en este caso para el eje X
//servo1
int x = 1000; // de 700 atrás a 1300 adelante
digitalWrite(servo, HIGH);
delayMicroseconds( x);
digitalWrite(servo, LOW);
delayMicroseconds(10000-x);
//servo2
int z = 1000; // de 700 arriba a 2100 abajo .... 1400 aproximadamente medio
delayMicroseconds( z);
delayMicroseconds(10000-z);
39
// Servo4
int y = 1000; // de 1000 a la izquierda a 2200 a la derecha....y 1600 al medio GIRO
delayMicroseconds( y);
delayMicroseconds(10000-y);
// Servo3
int p = 1000; // de 600 a 2400 .... para cerrar la PINZA
delayMicroseconds( p);
delayMicroseconds(10000-p);
40
ARDUINO NANO
41
Arduino Nano: Plaqueta de ensayo
El alumno podrá contar con una plaqueta para insertar zocalo mediante un Arduino del tipo “Nano” ; una versión
más pequeña en tamaño pero similar en características al “Uno” usado durante el curso. La finalidad del práctico
es que cada alumno podrá:
 Armar su placa en clase (plaqueta + kit de componentes)

 Chequear su correcto montaje (evitando soldaduras frías, falsos contactos y cortocircuitos)
 Insertar el Arduino Nano en la placa y verificar conectividad a PC
 Ensayar con su arduino Nano varios de los prácticos desarrollados para el “Uno”
42
MÓVIL IMPULSADO POR MOTOR (tipo scaletrix) COMANDADO POR
ARDUINO NANO + INTERFACE POTENCIA
Esta programación será realizada por los alumnos que cargarán en el

arduino NANO determinadas secuencias de recorrido del móvil.
43
Simulador de ARDUINO
Los alumnos harán uso de simuladores como el que vemos en la figura

anterior; la finalidad es hacer correr algunos de los programas
realizados durante el curso para chequear su correcto funcionamiento.
44
45

Arduino Practica

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

Arduino Practica

Cargado por

Copyright:

Formatos disponibles

ASOCIACIÓN SIERVOS DE LA CARIDAD

OBRA DON GUANELLA

¿Cómo está formado un ARDUINO?

 B (pines digitales del 8 al 13)

Características técnicas del Arduino Uno

GND. Pines de tierra.

SECCIÓN DE DECLARACIÓN DE VARIABLES

digitalWrite(led01, LOW); //Apaga el led

digitalWrite(led01, LOW); //Apaga el led verde

if (pulsador01State == HIGH and pulsador02State == HIGH) {

digitalWrite(led02, HIGH); //Enciende el led verde

// if (pulsador01State == HIGH and pulsador02State == HIGH) {

digitalWrite(led01, HIGH); //Enciende el led verde

digitalWrite(led02, HIGH); //Enciende el led verde

digitalWrite(led01, HIGH); //Enciende el led verde

digitalWrite(led01, HIGH); //Enciende el led verde

digitalWrite(led02, LOW); //Apaga el led verde

const int ledPin1 = 13; //verde

const int led01 = 13;

const int led04 = 11;

digitalWrite(13, HIGH); //verde

const int pulsador01 = 2;

const int led04 = 11; //verde

const int pulsador01 = 2;

const int led04 = 11; //verde

const int led01 = 8; // amarillo

const int led04 = 9; // rojo

digitalWrite(12, HIGH);//rojo....enciende durante 20 segundos SEMÁFORO1

(a completar por el alumno; instrucciones e ilustración)

const int analogPin = A0;

// inicializa la comunicación serial en 9600 bits por segundo

int valor_sensor = analogRead(A0);

float voltaje = valor_sensor * (5.0 / 1023.0);

const int servo = 4;

//digitalWrite(servo, HIGH); Se mueve en sentido contrario al anterior

// inicializa la comunicación serial en 9600 bits por segundo

int valor_sensor = analogRead(A0);

float voltaje = valor_sensor * (5.0 / 1023.0);

if (voltaje > 0 and voltaje < 1) {

digitalWrite(ledPin, HIGH); //Enciende el led

if (voltaje > 1 and voltaje < 2) {

digitalWrite(ledPin, HIGH); //Enciende el led

digitalWrite(ledPin, HIGH); //Enciende el led

if (voltaje > 3 and voltaje < 4) {

digitalWrite(ledPin, HIGH); //Enciende el led

if (voltaje > 4 and voltaje < 5) {

digitalWrite(ledPin, HIGH); //Enciende el led

11. Generar un barrido de un servomotor de izquierda a derecha usando un potenciómetro en su

Programación de un brazo para generar un movimiento libre operado desde

const int buttonPin = 2 ; // pulsador sobre el joystick

int x = 0 ; // valores iniciales a cero

pinMode(ledPin, OUTPUT); // salida a led

pinMode(servo, OUTPUT); // digitales de salida

pinMode(analogPin, INPUT); // analógicos de entrada

Serial.begin(9600); Se comunica con velocidad de 9600 baudios

float voltaje = valor_sensor * (1 / 1023.0);

int x = (700 + ( voltaje * (4 / 0.0060)));

int z = (700 + ( volt * (4 / 0.0028)));

Int x=(700 + (voltaje * (4 / 0.0060))) ;

int x = 1000; // de 700 atrás a 1300 adelante

int y = 1000; // de 1000 a la izquierda a 2200 a la derecha....y 1600 al medio GIRO

int p = 1000; // de 600 a 2400 .... para cerrar la PINZA

 Armar su placa en clase (plaqueta + kit de componentes)

ARDUINO NANO + INTERFACE POTENCIA