ARDUINO-Instalación Software y Hardware

Instituto Robótica –Aprende PERU
INTRODUCCION AL HARDWARE Y SOFTWARE ARDUINO

¿Qué es ARDUINO?
Arduino es una plataforma de prototipos electrónica de código
abierto (open-source) basada en hardware y software flexibles y
fáciles de usar.
Instalación Software Arduino
Antes de empezar a usar el hardware de Arduino, vamos a conocer

el software de Arduino, dejarlo instalado y configurado para poder
empezar a trabajar.
Descargar la última versión del IDE de Arduino
desde: http://arduino.cc/en/Main/Software.
Click en Windows Installer, para Windows XP y hasta
Una vez instalado abrimos el programa

Hardware Arduino
Arduino no solo es una placa azul muy popular con la que hacer
semáforos, encender leds o usado en las impresoras 3D. Arduino va
mucho más allá y vamos a verlo en este capítulo.
El HW de Arduino es básicamente una placa con un microcontrolador.

Un microcontrolador (abreviado µC, UC o MCU) es un circuito
integrado programable, capaz de ejecutar las órdenes grabadas en
su memoria. Está compuesto de varios bloques funcionales, los
cuales cumplen una tarea específica. Un microcontrolador incluye en
su interior las tres principales unidades funcionales de una
computadora: unidad central de procesamiento, memoria y
periféricos de entrada/salida.
ATmega328
EJERCICIOS DE ARDUINO.
Led parpadeante. Se trata de conectar un led al pin13, haciendo que
luzca durante 500 ms y que se apague durante 100 ms, este proceso
se repetirá cíclicamente. Objetivos:
• Reconocer partes de la placa.
• Aprender a conexionar leds a la placa.
• Familiarizarse con el entorno de programación.
• Reconocer las partes de un programa de arduino.
• Conocer órdenes como: pinMode, digitalWrite y delay.

Secuencia de leds. Se trata de encender y apagar 4 leds
secuencialmente. Los leds deben estar conectados a los pines 5,6,7
y 8. Se deben encender y posteriormente apagar los leds desde el
pin 5 al 8, con un tiempo de duración de encendido y apagado de 200
milisegundos. Objetivos:
• Aprender a declarar variables y variables tipo lista de valores.
• Aprender a declarar una función y llamarla cuando sea necesario.
Secuencia de leds con pulsador.

Se trata de encender y apagar 4 leds secuencialmente al accionar un

pulsador. El pulsador debe estar conectado al pin 4, y los leds a los
pines 5,6,7 y 8. Se deben encender y posteriormente apagar los leds
desde el pin 5 al 8, con un tiempo de duración de encendido y
apagado de 200 milisegundos. Nota: la secuencia principal del
programa debe estar reproducida en una función a la que llamará el
programa principal.
• Aprender a conectar una entrada digital a arduino (pulsador).
• Aprender a declarar variables tipo lista de valores.
• Aprender a declarar una función y llamarla cuando sea necesario.
• Conocer órdenes de control de programa como: If.

CLASE DE AUTOMATIZACION
La automatización es un sistema donde se trasfieren tareas de producción,
realizadas habitualmente por operadores humanos a un conjunto de elementos
tecnológicos.
Un sistema automatizado consta de dos partes principales:
Parte de Mando
Parte Operativa
La Parte Operativa es la parte que actúa directamente sobre la máquina. Son los
elementos que hacen que la máquina se mueva y realice la operación deseada.
Los elementos que forman la parte operativa son los accionadores de las
máquinas como motores, cilindros, compresores ..y los captadores como
fotodiodos, finales de carrera
La Parte de Mando suele ser un autómata programable (tecnología programada),
aunque hasta hace bien poco se utilizaban relés electromagnéticos, tarjetas
electrónicas o módulos lógicos neumáticos (tecnología cableada) . En un sistema
de fabricación automatizado el autómata programable esta en el centro del
sistema. Este debe ser capaz de comunicarse con todos los constituyentes de
sistema automatizado.
Que es un relé
Es un interruptor magnético que se acciona por una corriente eléctrica que se

acciona por dos de sus pines.
NORMAL CERRADO
NORMAL ABIERTO
PINES BOBINA
PIN COMUN
CODIGO ARDUINO
int pinOut = 2; void
setup()
{
//configuramos el pin 2 como salida
pinMode (pinOut, OUTPUT);
}
void loop()
{
//Le mandamos la señal de HIGH a la salida del

//Arduino, la salida es el pin 2
digitalWrite (pinOut, HIGH);
//Hacemos un delay de 1 segundo
delay (550); digitalWrite (pinOut,
LOW); delay (550);
}
Sensor HC-SR04 para crear una
alarma con Arduino
El Sensor ultrasónico HC-SR04 es un circuito que detecta o mide la distancia y
es compatible con Arduino. Básicamente, el sensor puede detectar objetos,
distancia o nivel en un rango mínimo de 2 cm a un máximo de 400 cm. Se puede
utilizar, por ejemplo, para diferente tipos de proyectos como lo son alarmas de
proximidad, medir niveles de agua de un tinaco o cualquier otro objeto que
almacene algún tipo de líquidos. Ten en cuenta que para que este sensor
funcione de manera correcta, se requiere de una superficie lisa y perpendicular
a la dirección de propagación del sensor.
En primer lugar, el sensor ultrasónico HC-SR04 se alimenta con 5 volts a 1.5 mA

DC lo cual, de hecho, lo hace ideal para trabajar con Arduino, en realidad, con
cualquier procesador lógico que funcione a 5V. Además si lo piensas trabajar con
otros niveles lógicos puedes implementar un divisor de voltaje para ajustar el
nivel.
CARACTERÍSTICAS DEL SENSOR ULTRASÓNICO HC-SR04
 Alimentación de 5 volts.
 Interfaz de cuatro hilos (vcc, trigger, echo, GND).
 Rango de medición: 2 cm a 400cm.
 Corriente de alimentación: 1.5mA.
 Frecuencia de pulso: 40Khz.
 Apertura del pulso ultrasónico: 15°.
 Señal de disparo: 10us.
 Dimensiones del módulo: 45x20x15mm.
ALARMA DE DISTANCIA UTILIZANDO EL SENSOR ULTRASÓNICO HC-

SR04 Y ARDUINO UNO
Para crear una alarma indicadora de distancia con el sensor hc-sr04 es necesario
el siguiente material. No obstante, ustedes pueden cambiar la salida por un
buzzer o bocina así que por este motivo la actividad se puede modificar a su
antojo.
 Sensor hc-sr04.
 Arduino UNO.
 1 LED (el color es opcional).
 Resistencia de 220Ω.
 Cable de comunicación entre PC y Arduino.
 Cables dupont macho macho.
DIAGRAMA ESQUEMÁTICO SENSOR UNTRASONICO ARDUINO
La siguiente imagen muestra cómo se conectara el sensor HC-SR04 y el Arduino

de manera correcta basándonos en nuestra programación. Por lo general, se
recomienda dejar los mismos pines, sin embargo, si quieres cambiarlos, solo
revisa que tus conexiones sean correctas.
ALARMA DE DISTANCIA UTILIZANDO EL SENSOR ULTRASÓNICO HC-

SR04 Y ARDUINO UNO
Para crear una alarma indicadora de distancia con el sensor hc-sr04 es necesario
el siguiente material. No obstante, ustedes pueden cambiar la salida por un
buzzer o bocina así que por este motivo la actividad se puede modificar a su
antojo.
 Sensor hc-sr04.
 Arduino UNO.
 1 LED (el color es opcional).
 Resistencia de 220Ω.
 Cable de comunicación entre PC y Arduino.
 Cables dupont macho macho.
DIAGRAMA ESQUEMÁTICO SENSOR UNTRASONICO ARDUINO
La siguiente imagen muestra cómo se conectara el sensor HC-SR04 y el Arduino

de manera correcta basándonos en nuestra programación. Por lo general, se
recomienda dejar los mismos pines, sin embargo, si quieres cambiarlos, solo
revisa que tus conexiones sean correctas.
long dis; long tiem; int led1 = 11; void setup( ){ Serial.begin(9600);
pinMode(10, OUTPUT); //salida del pulso generado por el sensor ultrasónico
pinMode(9, INPUT);//entrada del pulso generado por el sensor ultrasónico
pinMode(11, INPUT);//alarma de la distancia(encenderá el led)
}
void loop(){
digitalWrite(10,LOW);//recibimiento del pulso.
delayMicroseconds(5); digitalWrite(10,
HIGH);//envió del pulso.
delayMicroseconds(10); tiem=pulseIn(9, HIGH);//fórmula
para medir el pulso entrante.
dis= long(0.017*tiem);//fórmula para calcular la distancia del sensor ultrasónico.
if(dis>10){ //comparativo para la alarma se ingresa la distancia en la que
encenderá o apagara. digitalWrite(11, HIGH);
}
else
{
digitalWrite(11,LOW);
}
Serial.println("DISTANCIA EN cm ES:");
Serial.println(dis); delay(500);
}
SENSOR DE HUMEDAD Y TEMPERATURA CON ARDUINO
Una estación meteorológica puede ser un buen proyecto. En este artículo te voy
a explicar el sensor DHT11 que nos permite medir la temperatura y humedad
con Arduino.
Una de las ventajas que nos ofrece el DHT11, además de medir la temperatura
y la humedad, es que es digital. A diferencia de sensores como el LM35, este
sensor utiliza un pin digital para enviarnos la información y por lo tanto,
estaremos más protegidos frente al ruido.
Si el ejemplo más común es la estación meteorológica, también puede ser útil en

proyectos donde otros sensores y componentes dependan de la temperatura o
la humedad para tomar las medidas.
Este tutorial paso a paso te va a enseñar cómo utilizar el sensor de temperatura

y humedad DHT11 con Arduino.
DHT11 un único sensor para la temperatura y humedad

El DHT11 presume de ser un sensor con una alta fiabilidad y estabilidad debido
a su señal digital calibrada. Lo podemos comprar de dos maneras, de forma
individual donde solo tenemos el sensor DHT11, o insertado en una PCB.
La diferencia en precio no es excesiva y la versión con PCB aporta una

resistencia pull-up de 5 kΩ y un LED que nos avisa de su funcionamiento. Otra
diferencia entre estas dos versiones del DHT11 son los pines.
En la versión sin PCB tenemos 4 pines y en la versión con PCB tenemos 3 pines.
• VCC: alimentación
• I/O: transmisión de datos
• NC: no conecta, pin al aire
• GND: conexión a tierra
SUBIDA DE DATOS SENSOR DHT11 HACIA LCD 16X2

ESQUEMA FISICO
INSTALACION DE LIBRERIAS
Ahora pasaremos a subir la librería del sensor, puedes descargar aquí :
https://goo.gl/zHCYSF y por último subimos el código de programación
de todo el proyecto, pasaremos a detallar lo que se hizo:
https://goo.gl/iHdnoN
#include <LiquidCrystal.h>
LiquidCrystal lcd(3, 4, 5, 6, 7, 8); //Colocamos los pines del LCD
#include <dht11.h> //Incluimos la libreria DHT11 dht11

DHT; //Creamos el objeto DHT
#define DHT11_PIN 2 //Asignamos el pin digital #2
void setup()
{
Serial.begin(9600); lcd.begin(16, 2);
//Inicializamos la pantalla LCD
}
void loop()
{ int chk; chk = DHT.read(DHT11_PIN); //Leemos los
datos del sensor
// Mostramos la humedad
lcd.setCursor(0, 0);
lcd.print("Humedad: ");
lcd.print(DHT.humidity,1); lcd.print("
%");
//Mostramos la temperatura
lcd.setCursor(0, 1);
lcd.print("Temp.Celcius: ");
lcd.println(DHT.temperature,1);
delay(1000); // pequeño retardo para una
buena lectura
}
USO DE RELÉ CON ARDUINO Y CONEXIÓN A 220VOLTIOS DE

BOMBILLA ELECTRICA
Cuando queremos controlar elementos que están conectados a grandes
voltajes, como por ejemplo una bombilla de nuestra casa, necesitamos de un
componente que por un lado se conecte a la red eléctrica y por otro lado se pueda
conectar a nuestra placa de Arduino y que esta controle esa conexión. Para ello
disponemos de los reles, unos interruptores eléctricos que conmutan una red de
alto voltaje (por ejemplo, 220V) a través de un voltaje de control mucho inferior
(5V de la Arduino UNO o 3.3V de la Arduino UNO). Con este ejemplo serás capaz
de controlar cualquier luz de tu casa vía web con un relé y Arduino UNO.
¿QUÉ ES UN TRANSISTOR Y COMO SE USA?
Un 2N2222A con su colector, emisor y base identificados por las letras "c","e" y "b"
respectivamente.
El 2N2222, también identificado como PN2222, es un transistor bipolar NPN de

baja potencia de uso general.
Sirve tanto para aplicaciones de amplificación como de conmutación. Puede

amplificar pequeñas corrientes a tensiones pequeñas o medias; por lo tanto, sólo
puede tratar potencias bajas (no mayores de medio vatio). Puede trabajar a
frecuencias medianamente altas.
BOMBILLA ELECTRICA DE 220V

PROYECTO:
El siguiente proyecto consiste en encender y apagar una bombilla eléctrica de
220 voltios mediante el uso de arduino, asi mismo se manejara el tiempo de
encendido y apagado del foco.
MATERIALES
-Foco de 165-265VAC
-Transistor 2N222A
-Relé de 220 a 5v
-Arduino UNO
-Resistencia de 1k
-protoboard
-cables
Circuito a ensamblar
CIRCUITO A ENSAMBLAR FISICAMENTE
CODIGO ARDUINO
ENCENDIDO Y APAGADO DE LED Y BOMBILLA DE 220V
int ledPin = 13; // LED conectado al pin 13 void

setup() {
pinMode(ledPin, OUTPUT); // asigna el pin digital pin como output

(salida)
}
void loop() {
digitalWrite(ledPin, HIGH); // enciende el LED (on)

delay(30); // espera por un segundo
digitalWrite(ledPin, LOW); // apaga el LED (off)
delay(30); // espera por un segundo
}
ENCENDIDO DE FOCO 220 V CON ARDUINO MODULO BLUETOOTH HC05 Y
APLICATIVO ANDROID
ESQUEMA FISICO CODIGO
ARDUINO
int led1 = 13; int
led2 = 3;
int estado = 0;
void setup()
{
Serial.begin(9600);
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
}
void loop()
{
if( Serial.available()>0)
{
estado = Serial.read();
}
switch( estado)
{ case
'a':
digitalWrite(led1, HIGH);
break;
case 'b':
digitalWrite(led1, LOW);
break;
case 'c':
digitalWrite(led2, HIGH);
break; case 'd':
digitalWrite(led2, LOW);
break;
}
}
ROBOTICA
CREACION DE APLICACIONES ANDROID EN APP INVENTOR
1. Vamos a la página principal de App Inventor en la que hacemos click
en “Create” y a continuación iniciamos sesión en Google.
2. Empezamos un nuevo proyecto y veremos que se nos abre el apartado
gráfico de App Inventor 2:
3. Del cajón situado en la parte izquierda llamado “Palette” arrastramos el

primer elemento, “Button” hasta la pantalla en blanco de al lado. En la
parte derecha automáticamente se nos abren las características de este
botón, que únicamente le cambiaremos el nombre a “Háblame”. Este será
el botón que causará que nuestro terminal “hable”.
4. Vamos al apartado de “Media” y arrastramos el
componente TextToSpeech. Este componente no tiene interfaz gráfica así
que se nos sitúa debajo de la pantalla. Ahora ya tenemos todos los
elementos para empezar a programar.
5. Vamos al apartado “Blocks” de arriba a la derecha y hacemos click en

el componente “button” que se nos muestra debajo a la izquierda. Del
menú que se abre al lado arrastramos el bloque “When Button1 click,
do:”:
6. Hacemos lo mismo con TextToSpeech; pulsamos encima y luego

arrastramos el componente “call TextToSpeech1 .Speak Message:”.
Vemos como los dos bloques encajan a la perfección uno debajo del
otro. Seguidamente vamos a la sección de “Text”, de color morado,
donde arrastraremos el bloque vacío, el primero de todos:
7. Una vez tenemos este bloque encajado al lado del bloque de
TextToSpeech, escribimos en él lo que deseemos que nuestro
smartphone diga; por ejemplo, “Hola Andro4all”. El conjunto de todos los
bloques debería quedar así:
8. ¡Listo! La aplicación ya está programada, pero falta verla en tu

dispositivo. Vamos a la pestaña de arriba a la izquierda llamada “Built“.
En el menú que se nos despliega hay dos opciones; una para generar
un código QR, que luego de escanearlo se nos instalará la app en nuestro
terminal, y la otra opción guarda el archivo .APK en nuestro PC para
luego pasarlo a nuestro móvil y instalarlo desde ahí. Así debería quedar
tu aplicación:
APP ANDROID PARA ENCENDER Y APAGAR LED O FOCOS DE 220V

PROYECTO BRAZO ROBOTICO CONTROLADO POR MOTORES DE
REDUCCION CON ENCODER CONTROL PID DE MOTORES
MOTOR BASE (primer motor)
12V 10Rpm 4632GW-370 High Torque DC Turbo Worm Reducer Gear
Especificaciones:
Material: Metal
SEGUNDO MOTOR:
CHIHAI MOTOR Encoder 6V 100/210 / 300RPM motor DC Gear motor
Especificación:
Marca: CHIHAI MOTOR
Modelo: GM25-370
Voltage DC 6.0V
Speed 210RPM
Shaft diameter 4mm
Length 12mm
Encoder motor end 11 signals
Terminal connection length 20cm
Rated Voltage DC 6V
No-load Speed 210RPM 0.13A
Max Efficiency 2.0kg.cm/170rpm/2.0W/0.60A

Max Power 5.2kg.cm/110rpm/3.1W/1.10A
Stall Torque 10kg.cm 3.2A
Retarder Reduction Ratio 1 :34
Hall Resolution Hall x Ratio 34.02 = 341.2PPR
Tabla 2. Características del motor 2
1. CÓDIGO EN ARDUINO
1.1. Encoder const int
encoderPin_A = 2; const int
encoderPin_B = 3;
int p = 0; int pa = 0;
int pAct=0; unsigned
long timeold;
float vel; void
interrupcion()
digitalRead(encoderPin_B); // Check for rotation
if(digitalRead(encoderPin_B) == 0) // If its forward... {

p++; // Increment the counter
// Serial.println(counter);
else if(digitalRead(encoderPin_B) == 1) // If its backward...
p--; // Decrement the counter
//Serial.println(counter);
void setup()
Serial.begin(9600); attachInterrupt(0,
interrupcion,RISING);
pinMode(encoderPin_B,INPUT);
timeold = millis();
void loop ()
delay(300); detachInterrupt(0); // deja de contar mientras se
está operando vel = 10*(p-pa)/(float(millis() - timeold));
Serial.print(p-pa);
Serial.print(' ');
Serial.print(p);
Serial.print(' ');
Serial.print(pa);
Serial.print(' ');
Serial.println(vel);
pa = p; timeold =
millis();
//reiniciamos las interrupciones
attachInterrupt(0, interrupcion,RISING);
2.0. Motor 1
#include <PID_v1.h> // Librería PID de Brett Beauregard:
https://playground.arduino.cc/Code/PIDLibrary
// ********************************************** Patillaje
********************************************************************** const
byte encA = 2; // Entrada de la señal A del encoder.
const byte encB = 3; // Entrada de la señal B del
encoder.
const byte PWMA = 5; // Salida PWM a la primera patilla del motor a

través de un puente en H.
const byte PWMB = 6; // Salida PWM a la segunda patilla del motor a

través de un puente en H.
// ************************************************ Variables PID

*****************************************************************
double Setpoint = 0.0, Input = 0.0, Output = 0.0; // Setpoint=Posición

designada; Input=Posición del motor; Output=Tensión de salida para el motor.
double kp = 0.0, ki = 0.0, kd = 0.0; // Constante proporcional, integral

y derivativa.
double outMax = 0.0, outMin = 0.0; // Límites para no sobrepasar
la resolución del PWM.
// **************************************************** Otras Variables

***********************************************************
volatile long contador = 0; // En esta variable se guardará los pulsos del

encoder y que interpreremos como distancia (o ángulo si ese fuese el caso).
byte ant = 0, act = 0; // Sólo se utiliza los dos primeros bits de estas
variables y servirán para decodificar el encoder. (ant=anterior, act=actual.) byte
cmd = 0; // Un byte que utilizamos para la comunicación serie.
(cmd=comando.)
unsigned int tmp = 0; // Variable que utilizaremos para poner el tiempo

de muestreo.
const byte ledok = 13; // El pin 13 de los Arduinos tienen un led que
utilizo para mostrar que el motor ya ha llegado a la posición designada.
//
*******************************************************************************************
*************************************
PID myPID(&Input, &Output, &Setpoint, 0.0, 0.0, 0.0, DIRECT); // Parámetros y

configuración para invocar la librería.
void setup() // Inicializamos todo las variables que sean

necesarias, configuramos los pines de entrada/salida y configuramos el
terminal serie.
Serial.begin(115200); // Configura la velocidad en baudios del

terminal serie. Hoy en día "115200" es soportada por la gran mayoría de
computadores.
pinMode(PWMA, OUTPUT); // Declara las dos salidas PWM para el

control del motor (pin 5).
pinMode(PWMB, OUTPUT); // (pin 6).
digitalWrite(PWMA, LOW); // Y ambas salidas las inicializa a cero.

digitalWrite(PWMB, LOW);
TCCR0B = TCCR0B & B11111000 | 1; // Configuración de la frecuencia del

PWM para los pines 5 y 6. https://arduino-info.wikispaces.com/Arduino-
PWMFrequency
// Podemos variar la frecuencia del PWM con un número

de 1 (32KHz) hasta 7 (32Hz). El número que pongamos es un divisor de
frecuencia. Min.=7, Max.=1. Está a la máxima frecuencia y es como mejor
resultado me ha dado y además es silencioso.
attachInterrupt(digitalPinToInterrupt(encA), encoder, CHANGE); // En cualquier

flanco ascendente o descendente attachInterrupt(digitalPinToInterrupt(encB),
encoder, CHANGE); // en los pines 2 y 3, actúa la interrupción.
outMax = 255.0; // Límite máximo del controlador PID. outMin
= -outMax; // Límite mínimo del controlador PID.
tmp = 25; // Tiempo de muestreo en milisegundos.
kp = 10.0; // Constantes PID iniciales. Los valores son los

adecuados para un encoder de 334 ppr,
ki = 0.5; // pero como el lector de encoder está diseñado como
x4 equivale a uno de 1336 ppr. (ppr = pulsos por revolución.) kd = 5.0;
myPID.SetSampleTime(tmp); // Envía a la librería el tiempo de muestreo.

myPID.SetOutputLimits(outMin, outMax);// Límites máximo y
mínimo; corresponde a Max.: 0=0V hasta 255=5V (PWMA), y Min.: 0=0V
hasta -255=5V (PWMB). Ambos PWM se convertirán a la salida en valores
absolutos, nunca negativos. myPID.SetTunings(kp, ki, kd); // Constantes
de sintonización. myPID.SetMode(AUTOMATIC); // Habilita el control
PID (por defecto).
Setpoint = (double)contador; // Para evitar que haga cosas extrañas al
inciarse, igualamos los dos valores para que comience estando el motor parado.
imprimir(3); // Muestra los datos de sintonización y el tiempo de

muestreo por el terminal serie.
}
void loop()
{
Input = (double)contador; // Lectura del encoder óptico. El valor del
contador se incrementa/decrementa a través de las interrupciones extrenas
(pines 2 y 3).
while(!myPID.Compute()); // Mientras no se cumpla el tiempo de muestreo,

se queda en este bucle.
// *********************************************** Control del Motor

************************************************* if (((long)Setpoint - contador) ==
0)// Cuando está en el punto designado, parar el motor.
{
digitalWrite(PWMA, LOW); // Pone a 0 los dos pines del puente en H.
digitalWrite(PWMB, LOW); digitalWrite(ledok, HIGH); // Se enciende el led
(pin 13) para avisar visualmente que está en la posición designada.
}
else // En caso contrario hemos de ver si el motor ha de ir
hacia delante o hacia atrás. Esto lo determina el signo de la variable "Output".
{
if (Output > 0.0) // Mueve el motor hacia delante con el PWM
correspondiente a su posición.
{
digitalWrite(PWMB, LOW); // Pone a 0 el segundo pin del puente en H.
analogWrite(PWMA, abs(Output)); // Por el primer pin sale la señal PWM.
}
else // Mueve el motor hacia atrás con el PWM
correspondiente a su posición.
{
digitalWrite(PWMA, LOW); // Pone a 0 el primer pin del puente en H.
analogWrite(PWMB, abs(Output)); // Por el segundo pin sale la señal PWM.
}
}
// Recepción de datos para posicionar el motor, o modificar las constantes PID,

o el tiempo de muestreo. Admite posiciones relativas y absolutas.
if (Serial.available() > 0) // Comprueba si ha recibido algún dato por el
terminal serie.
{
cmd = 0; // Por seguridad "limpiamos" cmd. cmd
= Serial.read(); // "cmd" guarda el byte recibido.
if (cmd > 31)
{
byte flags = 0; // Borramos la bandera que decide lo
que hay que imprimir.
if (cmd > 'Z') cmd -= 32; // Si una letra entra en minúscula la
covierte en mayúscula.
if (cmd == 'W') { Setpoint += 5.0; flags = 2; } // Si (por ejemplo) es la letra
'W' mueve 5 pasos hacia delante. Estos son movimientos relativos.
if (cmd == 'Q') { Setpoint -= 5.0; flags = 2; } // Aquí son esos 5 pasos pero
hacia atrás si se pulsa la letra 'Q'.
if (cmd == 'S') { Setpoint += 400.0; flags = 2; } // Se repite lo mismo en el
resto de las teclas.
if (cmd == 'A') { Setpoint -= 400.0; flags = 2; }
if (cmd == 'X') { Setpoint += 5000.0; flags = 2; }
if (cmd == 'Z') { Setpoint -= 5000.0; flags = 2; } if
(cmd == '2') { Setpoint += 12000.0; flags = 2; } if (cmd
== '1') { Setpoint -= 12000.0; flags = 2; }
// Decodificador para modificar las constantes PID.
switch(cmd) // Si ponemos
en el terminal serie, por ejemplo "p2.5 i0.5 d40" y pulsas enter tomará esos
valores y los cargará en kp, ki y kd.
{ // También se puede
poner individualmente, por ejemplo "p5.5", sólo cambiará el parámetro kp, los
mismo si son de dos en dos.
case 'P': kp = Serial.parseFloat(); myPID.SetTunings(kp, ki, kd); flags = 1;

break; // Carga las constantes y presenta en el terminal serie los valores de las
variables que hayan sido modificadas.
case 'I': ki = Serial.parseFloat(); myPID.SetTunings(kp, ki, kd); flags = 1;

break; case 'D': kd = Serial.parseFloat(); myPID.SetTunings(kp, ki, kd);
flags = 1; break;
case 'T': tmp = Serial.parseInt(); myPID.SetSampleTime(tmp); flags =

1; break; case 'G': Setpoint = Serial.parseFloat()/0.36; flags
= 2; break; // IMPORTANTE¡¡¡Cambiar para el variar el ángulo de giro Esta
línea permite introducir una posición absoluta. Ex: g13360 (y luego enter) e irá
a esa posición.
case 'K': flags = 3; break;
digitalWrite(ledok, LOW); // Cuando entra una posición nueva se apaga

el led y no se volverá a encender hasta que el motor llegue a la posición que le
hayamos designado.
imprimir(flags);
}
}
// Encoder x4. Cuando se produzca cualquier cambio en el encoder esta parte

hará que incremente o decremente el contador.
void encoder()
{ ant=act; // Guardamos el valor 'act' en 'ant' para convertirlo
en pasado.
act=PIND & 12; // Guardamos en 'act' el valor que hay en ese

instante en el encoder y hacemos un
// enmascaramiento para aislar los dos únicos bits que

utilizamos para esta finalidad.
if(ant==12 && act==4) contador++;// Incrementa el contador si el encoder se

mueve hacia delante.
if(ant==4 && act==0) contador++;
if(ant==4 && act==12) contador--;// Decrementa el contador si el encoder se

mueve hacia atrás.
if(ant==0 && act==4) contador--;
if(ant==8 && act==0) contador--;
if(ant==12 && act==8) contador--; }
void imprimir(byte flag) // Imprime en el terminal serie los datos de las contantes
PID, tiempo de muestreo y posición. En los demás casos sólo imprime la posición
del motor.
{ if ((flag == 1) || (flag ==
3))
Serial.print("KP="); Serial.print(kp);
Serial.print(" KI="); Serial.print(ki);
Serial.print(" KD="); Serial.print(kd);
Serial.print(" Time="); Serial.println(tmp);
} if ((flag == 2) || (flag ==
3))
Serial.print("Posicion:");
Serial.println((long)Setpoint);
}
MATERIALES
-Control FLYSKY I6 CANALES
Descripción:
Una emisora apta para pilotar cualquier aeromodelo de radiocontrol, aviones , helicópteros , veleros y multicópteros.
la emisora tiene comunicación con el receptor mediante dos vías diferentes, pues éste emite señal de voltaje del
receptor que podrás ver en la pantalla de la emisora.
El receptor incluido tiene la posibilidad de emitir para verificar parámetros como la tensión del receptor etc.
el sistema AFHDS2A iene la función de identificación automática, la cual puede cambiar el modo de comunicación
automáticamente de una, a dos vías.
Es un sistema de radio de alta ganancia y usa una antena multi-direccional de alta calidad, esto cubre la banda de
frecuencia entera.
Asociado con un receptor de alta sensibilidad, este sistema de radio garantiza una transmisión de radio libre de
interferencias con transmisiones a larga distancia.
Opera a un rango de 2.405-2.475 GHz, este ancho de banda ha sido dividido en 142 canales independientes, cada
emisora usa 16 canales diferentes y 160 tipos de algoritmos distintos.
receptor de gran sensibilidad, garantiza una transmisión de radio limpia, segura y libre de interferencias incluso en
las más largas distancias.
Funciona con 4 pilas normales tipo doble A de 1,5 V, que posibilita un bajo voltaje alarma, menos que 4.2v.
También incorpora un puerto simulación DSC para poder conectar la emisora al ordenador y con software de
simulación poder entrenar con aviones, helicópteros o drones con el mayor realismo RC. El cable de conexión USB
NO está incluido.
Este sistema de radio usa componentes electrónicos de baja potencia y tienen bajo consumo.
La emisora se puede usar con cualquier receptor de una sola vía como son los normales de Fly-Sky FS-RB6, FS-
RB8, FS-GR3C.
Caracteristicas:
Tipo del modelo: Helicópteros, veleros, aviones, mutirotores.
Rango de RF: 2.4055-2.475GHz
Potencia de RF: <20dBm
Canal de RF: 140
Sensibilidad: -105dBm
Ancho de banda: 500KHz
Sistema de 2.4GHz: AFHDS 2A / AFHDS
Tipo de modulación: GFSK
Stick Resolución: 4096
Puerto DSC PS2 PPM de simulación
Longitud de la antena: 26mm (Antena dual)
Peso: 392 g
Alimentación: 6V DC 1.5AA * 4
Aviso de batería baja: Sí, cuando baja de 4.2V.
Pantalla STN, con retroiluminación, 128 * 64 píxeles, VA73 * 39 mm
Tamaño: 174 * 89 * 190m m
Cronometro para poder controlar el tiempo de vuelo
Posibilidad de actualización del firmware
4 trims digitales.
Codificación de seguridad: ppm/pcm.
Emisora en Modo-2 con el gas en el control izquierdo, uso común en España.
Codificación de seguridad: ppm/pcm
funcion exponencial, recorrido de los servos, inversores, etc.
Compatibilidad con otros receptores: FlySKy FS-R6B y FS-R8B.
Color negro
Certificados CE y FCC.
Manual en castellano.
Incluye:
Emisora FLYSKY FS-i6 2.4Ghz. 6CH MODO 2
Receptor FlySky 6 canales FS-iA6B
Requiere:
4 x Pilas AA
Video: https://youtu.be/eE85-w3Fb4E
-Controlador de vuelo o tarjeta controladora de vuelo KK 2.1.5 VERSION 2

DRONE
La tarjeta KK2.0 funciona bajo una tensión de 5V. Es alimentada por el BEC del ESC
y conectada al pin del motor M1. Los pines 5V de las salidas de los motores del M2
al M8 están unidas entre si. De este modo los ESC que estén conectados, aseguran
la alimentación de los servos. Si el modelo utiliza numerosos servos (por ejemplo
KK utilizada para estabilizar un avión), podría ser necesario asegurar la alimentación
con varios BEC’s o una batería de 5V. No es necesario retirar el hilo 5V (hilo rojo)
de los ESC’s conectados a las salidas M2 a M8, salvo si se trata de Switching BEC.
En efecto, un solo Switching BEC debe ser utilizado.
Self Level Settings : Configura el comportamiento del estabilizador. Se deben
utilizar valores muy bajos para empezar e ir aumentando según el
comportamiento del aeromodelo. En la actual versión del Firmvare, el algoritmo
del Auto-Level no está en su versión final. En particular no gestiona bien los
valores I-gain e I-limit. Deje estos valores a 0.
Self-level Gain : Fuerza la estabilización, más elevado con valores más altos.
Self-level Limit : Limita la potencia con la que la estabilización tomara el mando

sobre los motores. Limitado de antemano con valores más elevados.
Sensor Test : visualiza los valores entregados por los giróscopos y

acelerómetros. Para un correcto funcionamiento de la tarjeta todos los
captadores deben visualizar OK. Los valores deben variar cuando se inclina la
tarjeta en todos los sentidos.
Sensor Calibration : Siga las instrucciones que aparecen en la pantalla LCD con
el fin de calibrar los captadores. La calibración es necesaria solamente la primera
vez que se pone en marcha la tarjeta.
DONATE
LOAD MOTOR LAYOUT
CUADROCOPTER X MODE
YES-NEXT-NEXT
UNUSED
ACC CALIBRATION
CONTINUE
ESPERAR
ACC: 511
ACC: 512
ACC: 641
CONTINUE
CALIBRATION SUCCEDE
CONTINUE
4. CONTROL DE MOTORES BRUSHLESS CON ARDUINO

C
S
E
Trataremos sobre el cómo se puede controlar un motor "Brushless" (Motor

comúnmente usado en aeromodelismo), con lo que podremos realizar en un
futuro nuestro propio dron hecho en casa y de bajo costo.
Los motores sin escobillas funcionan debido a un campo magnético generado en
su interior, el cual se crea a partir de sus 3 bobinas, (existen variadas formas de
bobinado las mas comunes son de estrella o triangulo), estas para ser excitadas,
se tiene que dar con el ancho de pulso exacto en cada bobina para lograr un
giro completo y por consiguiente generar una aceleración y fuerza suficiente para
nuestros proyectos.
Lo bueno es que para facilitarnos la vida existen los ESC (Electronic Speed
Controller), que en Español seria : control de velocidad electrónico, esta pequeña
herramienta nos facilitara la labor de controlar la velocidad enviando un valor
desde nuestro Arduino.
Materiales
1) Para empezar lo primero que tenemos que hacer es poder controlar los
motores de los DRONES, estos motores tienen un nombre especial:
BRUSHLESS quiere decir "sin escobillas". En este tipo de motor la corriente
eléctrica pasa directamente por los bobinados del estator o carcasa, por lo
tanto aquí no son necesarias ni las escobillas ni el colector que se utilizan en
los brushed.
Los bruhsless que son motores trifásicos se eligen según el KV que significa la
cantidad de RPM (revolución por minuto) por cada voltio, veamos algunos de los
motores más conocidos.
Es de vital importancia poder conocer la relación estrecha que tiene el KV y el
torque de estos motores y es la siguiente: A mayor KV el torque es MENOR y
menor KV el torque es mayor.
2) Controladores de velocidad o ESC (Electronic Speed Controller) son los que

harán la conversión de voltaje DC (de la batería) hacia el voltaje AC (que usan
los brushless) y también permitirá regular la velocidad de los motores. Son
bastante conocidos por la cantidad de voltaje (2-6 celdas o 7.4v-22.4v) y por
la cantidad de corriente que soportan (18-20-30A).
3) Usaremos un Arduino UNO

4) Un potenciómetro
5) Batería de 3 celdas o de 12v.
Procedimiento
1) Lo primero que tenemos que haces son las conexiones del motor brushless
con el ESC y el Arduino, tenemos que recordar que el motor brushless es trifásico
así que el orden de lo cables no tiene mucha importancia, también tenemos que
colocar la batería de 12v y 2200 mAh (recomendable) para luego conectar los
pines de control que son los cables más delgados del ESC.
Una vez hecha estas conexiones pasaremos a conectar al Arduino el joystick que
viene hacer básicamente 2 potenciometros y un pulsador, de estos 2
potenciometros estaremos usando solo uno que hará que el motor acelere o
desacelere.
2) Pasaremos a subir el código de programación que lo puedes descargar aquí:

https://goo.gl/nDn0vW

ARDUINO-Instalación Software y Hardware

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

ARDUINO-Instalación Software y Hardware

Transféré par

Droits d'auteur :

Formats disponibles

Instituto Robótica –Aprende PERU

INTRODUCCION AL HARDWARE Y SOFTWARE ARDUINO

Antes de empezar a usar el hardware de Arduino, vamos a conocer

Click en Windows Installer, para Windows XP y hasta

Una vez instalado abrimos el programa

El HW de Arduino es básicamente una placa con un microcontrolador.

• Reconocer partes de la placa.

• Aprender a conexionar leds a la placa.

• Familiarizarse con el entorno de programación.

• Reconocer las partes de un programa de arduino.

• Conocer órdenes como: pinMode, digitalWrite y delay.

• Familiarizarse con el entorno de programación.

• Aprender a declarar variables y variables tipo lista de valores.

• Aprender a declarar una función y llamarla cuando sea necesario.

Secuencia de leds con pulsador.

Se trata de encender y apagar 4 leds secuencialmente al accionar un

• Familiarizarse con el entorno de programación.

• Aprender a conectar una entrada digital a arduino (pulsador).

• Aprender a declarar variables tipo lista de valores.

• Aprender a declarar una función y llamarla cuando sea necesario.

• Conocer órdenes de control de programa como: If.

Un sistema automatizado consta de dos partes principales:

Es un interruptor magnético que se acciona por una corriente eléctrica que se

//Le mandamos la señal de HIGH a la salida del

En primer lugar, el sensor ultrasónico HC-SR04 se alimenta con 5 volts a 1.5 mA

CARACTERÍSTICAS DEL SENSOR ULTRASÓNICO HC-SR04

ALARMA DE DISTANCIA UTILIZANDO EL SENSOR ULTRASÓNICO HC-

La siguiente imagen muestra cómo se conectara el sensor HC-SR04 y el Arduino

ALARMA DE DISTANCIA UTILIZANDO EL SENSOR ULTRASÓNICO HC-

La siguiente imagen muestra cómo se conectara el sensor HC-SR04 y el Arduino

SENSOR DE HUMEDAD Y TEMPERATURA CON ARDUINO

Si el ejemplo más común es la estación meteorológica, también puede ser útil en

Este tutorial paso a paso te va a enseñar cómo utilizar el sensor de temperatura

DHT11 un único sensor para la temperatura y humedad

La diferencia en precio no es excesiva y la versión con PCB aporta una

SUBIDA DE DATOS SENSOR DHT11 HACIA LCD 16X2

#include <dht11.h> //Incluimos la libreria DHT11 dht11

USO DE RELÉ CON ARDUINO Y CONEXIÓN A 220VOLTIOS DE

¿QUÉ ES UN TRANSISTOR Y COMO SE USA?

El 2N2222, también identificado como PN2222, es un transistor bipolar NPN de

Sirve tanto para aplicaciones de amplificación como de conmutación. Puede

BOMBILLA ELECTRICA DE 220V

int ledPin = 13; // LED conectado al pin 13 void

pinMode(ledPin, OUTPUT); // asigna el pin digital pin como output

digitalWrite(ledPin, HIGH); // enciende el LED (on)

3. Del cajón situado en la parte izquierda llamado “Palette” arrastramos el

5. Vamos al apartado “Blocks” de arriba a la derecha y hacemos click en

6. Hacemos lo mismo con TextToSpeech; pulsamos encima y luego

8. ¡Listo! La aplicación ya está programada, pero falta verla en tu

APP ANDROID PARA ENCENDER Y APAGAR LED O FOCOS DE 220V

MOTOR BASE (primer motor)

12V 10Rpm 4632GW-370 High Torque DC Turbo Worm Reducer Gear

CHIHAI MOTOR Encoder 6V 100/210 / 300RPM motor DC Gear motor

Max Efficiency 2.0kg.cm/170rpm/2.0W/0.60A

Tabla 2. Características del motor 2

1.1. Encoder const int

encoderPin_A = 2; const int

int pAct=0; unsigned

float vel; void

digitalRead(encoderPin_B); // Check for rotation

if(digitalRead(encoderPin_B) == 0) // If its forward... {

else if(digitalRead(encoderPin_B) == 1) // If its backward...