Ra-01 Odt

DeINF[ DEPARTAMENT DINFORMTICA ]
IES El Puig de Santa Maria
Sumario
1 Brazo robot..........................................................................................................................2
2 Proyectos que se pueden realizar........................................................................................3
3 Conexiones Brazo Arduino Mega.......................................................................................4
4 Explicacin del cdigo..........................................................................................................5
4.1 Configuracin del brazo - robot.....................................................................................5
4.2 Clase Motor...................................................................................................................6
4.3 Implementacin clase Motor.........................................................................................8
4.4 Clase Brazo.................................................................................................................12
4.5 Implementacin clase Brazo.......................................................................................13
4.5 Otros defines...............................................................................................................19
4.6 Programa que controla el brazo..................................................................................20
4.7 Interfaz processing para el control del brazo de robot................................................25
4.8 Programa processing que implementa la interfaz.......................................................26
5. Control de Motores de CC con el chip L293D y arduino....................................................33
5.1 Esquema del L293D....................................................................................................33
2.2 Conexiones del L293D con arduino.............................................................................34
Autores.................................................................................................................................35
1/35
C/ Avinguda de lInstitut, s/n. El Puig-46540. Tel: 961 206 025. E-mail: 46023894@edu.gva.es
1 Brazo robot.
Es el brazo mecnico de la dotacin de tecnologa. Dispone de cinco grados de libertad, y por tanto cinco
motores. Los motores son de corriente continua (cc).
Se puede conectar el brazo a una controladora arduino?
Como son motores de cc
para cada motor se
requieren tres conexiones de
arduino, de las cuales una
de ellas debe ser pwm, para
un control con precisin. Por
tanto se necesitan 15
conexiones digitales y de
ellas 5 pwm. Este nmero
hace imposible conectar las
arduino bsicas para
controlar todos los motores.
Adems cada dos motores
utilizan un integrado con dos
puente H.
Es decir para un control total
del brazo se requiere una
arduino Mega.
En la imagen se pueden ver los cables conectados a cada uno de los motores. Los colores de los cables son
arbitrarios.
En la tabla se identifica cada motor, la
operacin que hace y qu conexin le
corresponde.
2/35
Tabla descriptiva:
PIN Accin Observaciones

1 No conectado a nada
2 Controla pinza: M2 Cable amarillo
3 Controla el codo: M3 Cable naranja
4 Controla la rotacin de la base: M4 Cable rosa
6 Controla la elevacin del brazo (junto a la base): M6 Cable marrn
7 Rotacin de la pinza: M7 Cable negro
2 Proyectos que se pueden realizar.

Num- Materia y nivel recomendado Descripcin
Proyecto
1 Tecnologa, 4t ESO Montar el brazo y hacerlo funcionar manualmente
2 Tecnologa / Informtica 4t ESO / Identificar cada motor y conectar brazo a controladora
1r Bachiller arduino Mega. Programar la controladora para cambiar botes
X de un lugar A a un lugar B.
3 Tecnologa / Informtica 4t ESO / Disear e imprimir objeto que sujete finales de carrera, dos
1r Bachiller finales de carrera para cada motor.
4 Tecnologa / Informtica 4t ESO / Usando el proyecto 3, programar la controladora para
1r Bachiller cambiar botes X de un lugar A a un lugar B. Analizar las
diferencias.
5 Tecnologa / Informtica 4t ESO / Colocar brazo sobre plataforma mvil, controlada por
1r Bachiller bluetooth.
3/35
3 Conexiones Brazo Arduino Mega.
Chip 1 Pin driver L293D Pin Arduino

1 enable 13 pwm
Motor 2:
Controla apertura pinza: 2 input motor1
12
M2 izqdo
Cable amarillo
7 input motor1 11

1 enable 10 pwm
Motor 3: 2 input motor1
Controla el codo: M3, 9
Cable naranja
izqdo
7 input motor1 8
9 enable 7pwm
Motor 4: 10input motor 2
6
Controla base: M4, dcho
Cable rosa 15 inputmotor 2
5
dcho
Motor 6: 1 enable 3 pwm
Controla la elevacin del 2 input motor1
brazo (junto a la base): 30
M6,
izqdo
Cable marrn 7 input motor1 31
9 enable 2pwm
Motor 7: 10 input motor 2
Rotacin de la pinza: 22
M7,
dcho
Cable negro 15 inputmotor 2
23
dcho
4/35
4 Explicacin del cdigo.
4.1 Configuracin del brazo - robot.

/**
Motores cc
De cada motor se dice en el comentario :
su numero, seguido del significado los valores asignados a las const int. Color cable que conecta con el
motor del brazo. Funcionalidad del motor.
Evidentemento los colores son arbitrarios.
*/
//chip 1: L293D
//motor 2: los nmeros son los pines usados de arduino-mega. Cable amarillo. Apertura / Cierre pinza.
const int EnableM2 = 13;
const int M2_2 = 12;
//chip 2: L293D
//motor 3: los nmeros son los pines usados de arduino. Cable naranja. Codo.
const int M3_2 = 9;
const int M3_7 = 8;
//motor 4: los nmeros son los pines usados de arduino. Cable rosa. Rotacion base.
//chip 3: L293D
//motor 6: los nmeros son los pines usados de arduino. Cable marron. Elevacion brazo.
5/35
//motor 7: los nmeros son los pines usados de arduino. Cable negro. Rotacion pinza.
/**
Array (lista) de parmetros para los motores. Cada motor queda definido con tres valores o parmetros. El
primero es para el pin Enable y los otros dos para input1 e input2. Para ms detalles ver documentacin del
chip L293D.
*/
int listaParametrosMotores[15]={EnableM2, M2_2, M2_7,// 0 = pinza
EnableM3, M3_2, M3_7, // 1 = codo
EnableM4, M4_10, M4_15, // 2 = base
EnableM6, M6_2, M3_7, // 3 = hombro
EnableM7, M7_10, M4_15 // 4 = munyeca
};
/**
Crea un objeto brazo.
A este se le pueden aplicar las operaciones en el interfaz de la clase Brazo, que son entre otras:
abrirpinza, cerrarpinza, parapinza, subircodo, bajarcodo ...
*/
Brazo miBrazo;
4.2 Clase Motor.

class Motor
{
private:
int pinEnable, pinA, pinB, estado;
int velocidad; //valores entre 0 y 9, que ser mapean a 0 - 255
public:
Motor();
~Motor();
Motor(int Enable, int pin1, int pin2, int v);
int getPinEnable();
int getPinA();
6/35
int getPinB();
int getVelocidad();
int getEstado();
void setPinEnable(int unPin);
void setPinA(int unPin);
void setPinB(int unPin);
void setVelocidad(int v);
void disable();
void enable();
void adelante();
void atras();
void para();
void cambiarVelocidad(int v);
};
7/35
4.3 Implementacin clase Motor.

Motor::Motor()
{
pinEnable = 0;
pinA = 0;
pinB = 0;
velocidad = 0;
estado = DISABLE;
}
Motor::~Motor()
{
}
Motor::Motor(int Enable, int pin1, int pin2, int v)
{
if (DEBUG) Serial.println("constructor con parametros");
this->pinEnable = Enable;
this->pinA = pin1;
this->pinB = pin2;
this->velocidad = v;
this->estado = DISABLE;
}
int Motor::getPinEnable()
{
if (DEBUG) Serial.println("pinEnable: ");
return pinEnable;
}
int Motor::getPinA()
{
if (DEBUG) Serial.println("PinA: ");
return pinA;
}
8/35
int Motor::getPinB()
{
if (DEBUG) Serial.println("PinB: ");
return pinB;
}
int Motor::getVelocidad()
{
if (DEBUG) Serial.println("velocidad: ");
return velocidad;
}
void Motor::setPinEnable(int unPin)
{
if (DEBUG) Serial.println("");
this->pinEnable = unPin;
}
void Motor::setPinA(int unPin)
{
this->pinA = unPin;
}
void Motor::setPinB(int unPin)
{
this->pinB = unPin;
}
void Motor::setVelocidad(int v)
{
this->velocidad = v;
}
9/35
void Motor::disable()
{
if (DEBUG) Serial.println("disable motor");
digitalWrite(pinEnable, LOW);
estado = DISABLE;
}
void Motor::enable()
{
if (DEBUG) Serial.println("enable motor");
analogWrite(pinEnable, 2);
estado = ENABLE;
}
void Motor::adelante()
{
if (DEBUG) Serial.println("adelante");
digitalWrite(pinA,HIGH);
digitalWrite(pinB,LOW);
estado = ADELANTE;
}
void Motor::atras()
{
if (DEBUG) Serial.println("atras");
digitalWrite(pinA,LOW);
digitalWrite(pinB,HIGH);
estado = ATRAS;
}
void Motor::para()
{
if (DEBUG) Serial.println("para");
digitalWrite(pinA,LOW);
digitalWrite(pinB,LOW);
estado = PARADO;
}
10/35
void Motor::cambiarVelocidad(int v)
{
setVelocidad(v);
//mapear valor
int speed = map(v, 0, 9, 0, 255); //Re-mapea un numero desde un rango a otro
analogWrite(pinEnable , v); //v es un valor entre 0 y 255, no se map por que resulta muy complicado
controlar
}
11/35
4.4 Clase Brazo.
#include "Motor.h" //Nuestro brazo robtico es una lista o array de motores

/**
Clase Brazo.
*/
/**
Equivalencia entre el ndice del array y el nmero de motor del brazo:
0 - Motor 2 > pinza Abrir / Cerrar
1 - Motor 3 > codo Subir / Bajar
2 - Motor 4 > base Horario / Antihorario
3 - Motor 6 > hombro Subir / Bajar
4 - Motor 7 > munyeca Horario / Antihorario
*/
const int motores_q_t_brazo = 5;//Numero de motores que tiene el brazo
class Brazo
{
private:
Motor motores[motores_q_t_brazo];// del 0 al 4
public:
Brazo();
~Brazo();
Brazo(int aMotores[]);
void disableBrazo();
void enableBrazo();
//operaciones que se pueden realizar con el brazo
//es decir movimientos que pueden tener cada uno de los motores.
//0 - Motor 2 > pinza Abrir / Cerrar
void abrirpinza();
void cerrarpinza();
void parapinza();
void cambiarVelocidadpinza(int v);
//1 - Motor 3 > codo Subir / Bajar
12/35
void subircodo();
void bajarcodo();
void paracodo();
void cambiarVelocidadcodo(int v);
//2 - Motor 4 > base Horario / Antihorario
void girahorariobase();
void giraantihorariobase();
void parabase();
void cambiarVelocidadbase(int v);
//3 - Motor 6 > hombro Subir / Bajar
void subirhombro();
void bajarhombro();
void parahombro();
void cambiarVelocidadhombro(int v);
//4 - Motor 7 > munyeca Horario / Antihorario
void girahorariomunyeca();
void giraantihorariomunyeca();
void paramunyeca();
void cambiarVelocidadmunyeca(int v);
};
4.5 Implementacin clase Brazo.
/**
Implementa class Brazo.cpp
*/
#include <Arduino.h> // Arduino includes
#include "Brazo.h"
Brazo::Brazo()
{
for (int i = 0; i < motores_q_t_brazo; i++)
motores[i]=Motor();//inicializa los motores a sus valores por defecto.
}
13/35
Brazo::~Brazo()
{
}
/**
aMotores es un array de 15 elementos, que se agrupan de tres en tres para definir los cinco motores
*/
Brazo::Brazo(int aMotores[])
{
int a,b,c;
for (int i = 0; i < motores_q_t_brazo; i++){//inicializa los motores con los valores del array.
a=aMotores[i*3+0];//valores posibles 0,3,6,9,12
b=aMotores[i*3+1];//valores posibles 1,4,7,10,13
c=aMotores[i*3+2];//valores posibles 2,5,8,11,14
motores[i] = Motor(a,b,c, 100);
}
}
void Brazo::disableBrazo()
{
if (DEBUG) Serial.println("Disable Brazo");
for (int i = 0; i < motores_q_t_brazo; i++){
motores[i].disable();
}
if (DEBUG) Serial.println("*************");
}
void Brazo::enableBrazo()
{
if (DEBUG) Serial.println("Enable Brazo");
for (int i = 0; i < motores_q_t_brazo; i++){
motores[i].enable();
}
if (DEBUG) Serial.println("*************");
14/35
//operaciones que se pueden realizar con el brazo

//es decir movimientos que pueden tener cada uno de los motores.
//0 - Motor 2 > pinza Abrir / Cerrar
void Brazo::abrirpinza()
{
if (DEBUG) Serial.println("abre pinza");
motores[0].adelante();
}
void Brazo::cerrarpinza()
{
if (DEBUG) Serial.println("cierra pinza");
motores[0].atras();
}
void Brazo::parapinza()
{
if (DEBUG) Serial.println("para pinza");
motores[0].para();
}
void Brazo::cambiarVelocidadpinza(int v)
{
if (DEBUG) Serial.println("abre pinza");
motores[0].cambiarVelocidad(v);
}
//1 - Motor 3 > codo Subir / Bajar

void Brazo::subircodo()
{
if (DEBUG) Serial.println("sube codo");
15/35
void Brazo::bajarcodo()
{
if (DEBUG) Serial.println("baja codo");
motores[1].atras();
}
void Brazo::paracodo()
{
if (DEBUG) Serial.println("para codo");
motores[1].para();
}
void Brazo::cambiarVelocidadcodo(int v)
{
if (DEBUG) Serial.println("cambia velocidad codo");
}
//2 - Motor 4 > base Horario / Antihorario

void Brazo::girahorariobase()
{
if (DEBUG) Serial.println("gira base en sentido horario");
}
void Brazo::giraantihorariobase()
{
if (DEBUG) Serial.println("gira base en sentido antihorario");
motores[2].atras();
}
void Brazo::parabase()
{
16/35
if (DEBUG) Serial.println("para base");

motores[2].para();
}
void Brazo::cambiarVelocidadbase(int v)
{
if (DEBUG) Serial.println("cambia velocidad base");
}
//3 - Motor 6 > hombro Subir / Bajar

void Brazo::subirhombro()
{
if (DEBUG) Serial.println("subir hombro");
}
void Brazo::bajarhombro()
{
if (DEBUG) Serial.println("bajar hombro");
motores[3].atras();
}
void Brazo::parahombro()
{
if (DEBUG) Serial.println("subir hombro");
motores[3].para();
}
void Brazo::cambiarVelocidadhombro(int v)
{
if (DEBUG) Serial.println("cambiar velocidad hombro");
}
17/35
//4 - Motor 7 > munyeca Horario / Antihorario

void Brazo::girahorariomunyeca()
{
if (DEBUG) Serial.println("gira mueca sentido horario");
}
void Brazo::giraantihorariomunyeca()
{
if (DEBUG) Serial.println("gira mueca sentido antihorario");
motores[4].atras();
}
void Brazo::paramunyeca()
{
if (DEBUG) Serial.println("para munyeca");
motores[4].para();
}
void Brazo::cambiarVelocidadmunyeca(int v)
{
if (DEBUG) Serial.println("cambia velocidad munyeca");
}
18/35
4.5 Otros defines.
/**
Defines para depuracion.
*/
#define BAUD 9600
#define DEBUG true
#define DEBDRV false
/**
Estados del motor
*/
//Tiempo de espera:
#define DOSSEG 2000
//Estados del motor
#define DISABLE 0
#define ENABLE 1
#define ADELANTE 2
#define ATRAS 3
#define PARADO 4
19/35
4.6 Programa que controla el brazo.

Usa la clase Brazo (que a su vez usa la clase Motor). Por tanto los cuatro archivos que implementan las clases
mas el programa controlador que las usa, debern estar en la misma carpeta.
Si se conecta la placa arduino mega al puerto serie, se pueden enviar ordenes al brazo usando la utilidad
del IDE de arduino Herramientas > Monitor Serie. Tambin se puede usar cualquier otro programa de
comunicacin como por ejemplo el CuteCom. Las teclas a usar para la seleccin de los motores y sus
movimientos asociados parecen como comentarios en el programa. El programa tiene abundantes
comentarios que facilitar su comprensin.
#include "Brazo.h"
#define BAUD 9600
#define DEBUG true
/**
* La seleccin del grado de libertad, es decir a usar se hace por medio de las siguientes teclas:
* Q Base, seguido de las flechas izq o derecha para indicar la direccin de giro.
* A Hombro, seguido de las flechas arriba o abajo para definir si sube o baja.
* Z Codo, seguido de las flechas arriba o abajo para definir si sube o baja.
* S Mueca, seguido de las flechas izq o derecha para indicar la direccin de giro.
* X Pinza, seguido de las flechas izq o derecha para indicar apertura o cierre.
*/
/*
/**
Motores cc: CONFIGURACION DE PINES
De cada motor se dice en el comentario :
su numero, seguido del significado los valores asignados a las const int. Color cable que conecta con el
motor del brazo. Funcionalidad del motor.
Evidentemente los colores usados en los cables son arbitrarios.
Si se cambia la configuracin de los pines en el placa, se debe cambiar aqu y vicieversa.
*/
//chip 1: L293D
//motor 2: los nmeros son los pines usados de arduino-mega. Cable amarillo. Apertura / Cierre pinza.
20/35
//chip 2: L293D
//motor 3: los nmeros son los pines usados de arduino. Cable naranja. Codo.
const int M3_2 = 9;
const int M3_7 = 8;
//motor 4: los nmeros son los pines usados de arduino. Cable rosa. Rotacion base.
//chip 3: L293D
//motor 6: los nmeros son los pines usados de arduino. Cable marron. Elevacion brazo.
//motor 7: los nmeros son los pines usados de arduino. Cable negro. Rotacion pinza.
//lista de valores que se pasan al brazo de robot. Se corresponden con la configuracin anterior
int listaParametrosMotores[15] = {EnableM2, M2_2, M2_7, // 0 = pinza
EnableM3, M3_2, M3_7, // 1 = codo
EnableM4, M4_10, M4_15, // 2 = base
EnableM6, M6_2, M6_7, // 3 = hombro
EnableM7, M7_10, M7_15 // 4 = munyeca
};
Brazo br, *pbr;//se crea un objeto brazo y una referencia a un objeto Brazo
//estructura de un movimiento asociado a un motor

struct MOV {
Brazo a;
21/35
int numeromotor;//valores del 0 al 4, motor que se ver afectado

int direccion;// valores 0-adelante, 1-atras, 2-para, movimiento que realizar el motor
} mov;
void setup() {
Serial.begin(BAUD);
Serial.println("setup, empezando");
br = Brazo( listaParametrosMotores);//se configura el objeto brazo creado
pbr = &br;//se inicializa la referencia al brazo creado
}
void loop() {
if ( Serial.available()) { //Si el puerto serie esta disponible?
char ch = Serial.read(); //variable tipo char desde puerto serial
//Serial.println(ch);
//comprobar motor seleccionado.
//valido ser TRUE si se ha pulsado alguno de los carecteres mostrados
bool valido = (ch == 'a' || ch == 'A' || ch == 'q' || ch == 'Q' || ch == 'z' || ch == 'Z' || ch == 's' || ch ==
'S' || ch == 'x' || ch == 'X' || ch == 'n' || ch == 'N' || ch == 'm' || ch == 'M' || ch == 'p' || ch == 'P');
if (valido) //si el caracter es vlido
{
mov.a = br;//inicializa la estructura de movimientos
Serial.println(ch);
switch (ch)
{
case 'a':// mover hombro
case 'A':
Serial.println("Mover Hombro");
mov.numeromotor = 3;
break;
case 'q':// mover base
case 'Q':
Serial.println("Mover Base");
22/35
break;
case 'z':// mover Codo
case 'Z':
Serial.println("Mover Codo");
break;
case 'x':// mover munyeca
case 'X':
Serial.println("Mover Munyeca");
break;
case 's':// mover pinza
case 'S':
Serial.println("Mover Pinza");
//delay(1000);
break;
case 'n':
case 'N':
Serial.println("Mover el motor adecuado");
mov.a.mover(mov.numeromotor, 0);
//delay(1000);
break;
case 'm':
case 'M':
Serial.println("Mover el motor adecuado");
//delay(1000);
break;
case 'p':
case 'P':
Serial.println("Parar el motor adecuado");
23/35
//delay(1000);
break;
}
}// fin de if (valido)
}//fin if Serial.available()
24/35
4.7 Interfaz processing para el control del brazo de robot.

Para facilitar el manejo del brazo se ha implementado una interfaz en processing. El interfaz muestra los
motores que se pueden seleccionar y las acciones asociadas a cada motor que se pueden realizar. Las
pruebas realizadas hasta ahora han funcionado correctamente. Aunque la velocidad de respuesta ha sido
lenta. Posiblemente aumentando la velocidad del puerto serie. Esta interfaz, es totalmente funcional tiene
una amplia gama de mejoras que se pueden realizar. Entre las que cabe destacar:
1. Deteccin del puerto serie en el que est conectado el brazo.
2. Mejora de las estructuras de datos a usar para el manejo de las ordenes.
3. Reemplazar los nombres de los motores por imgenes o iconos.
4. Aadir ttulos.
5. Aadir un logo / imagen animada.
6. Etc.
Ilustracin 1: Interfaz Robot (desarrollado con processing)
25/35
4.8 Programa processing que implementa la interfaz.

El programa est profusamente documentado para ayudar a su comprensin.
/**
Dibuja 5 botones en la parte superior del area de trabajo, coge los textos del array de String's textos.
Dibuja 3 botones en la parte inferior de la ventana, coge los textos de los dos primeros del array de String's
textos. El indice del texto del primer parmetro es indicado como parmetro.
el tercer botn que dibuja siempre tiene como texto la posicin 11.
Al seleccionar un elemento de la parte de arriba se cambian las operaciones que se pueden hacer en la parte
de abajo.
Realiazadas las selecciones se envian al brazo robot
*/
int BAUD = 9600;
PFont miFont;//para usar una fuente
//textos de los botones. Se crea una lista
String[] textos = {"Pinza", "Codo", "Base", "Hombro", "Mueca", "Subir", "Bajar", "Abrir", "Cerrar", "Girar
Horario", "Girar Antihorario", "Parar"};
int NINGUNO = -1;
int btSeleccionado = NINGUNO;//para seleccionar el motor,
int accionSelectexto = NINGUNO;//para seleccionar texto del array de textos
int accionSelec = NINGUNO;//para enviar al brazo robot
int color_por_defecto1 = #16EA0C;
int color_seleccion1 = 0;
int color_act = color_por_defecto1;
import processing.serial.*; //Importa libreria para comunicar con puerto serie
Serial myPort; //define objeto serial para comunicaciones
void setup()
{
size(700, 400);
dibLinCentral();
miFont = createFont("DejaVu", 16, true);//crea una fuente
println((Object[])Serial.list());//muestra en la consola la lista de puertos serie disponibles
myPort = new Serial(this,Serial.list()[32],BAUD);// crea un objeto serial concretamente el que se pasa entre
corchetes
26/35
}
void draw()
{
background(255);
dibRecSeleccion();//dib. botones de seleccin de motores = grados de libertad del brazo robot
dibLinCentral(); // dib. la lnea central
dibRecAccion(9); // dib. los botones de seleccin de las operaciones que se pueden realizar
if (btSeleccionado != NINGUNO)//si hay algn boton seleccionado
{
textFont(miFont,16);//especifica la fuente con la escribir el texto
text(" ", width/2+20, height/2+20);//borra la accin que pudiese haber previamente
text("MOTOR: "+textos[btSeleccionado]+"> SELECCIONADO", width/2-20, height/2-20);//muestra el motor
seleccionado
switch (btSeleccionado) {//dependiendo del motor seleccionado se pueden realizar unos u otros
movimientos con el brazo, y se necesitan actualizar los botones
case 0://Se ha seleccionado pinza. Operaciones que se pueden hacer: abrir, cerrar.
dibRecAccion(7); //dib las acciones relacionadas con la pinza
myPort.write('S');//se le dice al brazo que prepare el motor de la pinza
//delay(100);
break;
case 1://Se ha seleccionado codo. Operaciones que se pueden hacer: subir, bajar
dibRecAccion(5);//...
myPort.write('Z');//...
//delay(100);
break;
case 2://Se ha seleccionado base. Operaciones que se pueden hacer: girar horario, girar antihorario
dibRecAccion(9);//...
myPort.write('Q'); //...
//delay(100);
break;
case 3://hombro: subir o bajar
dibRecAccion(5);//Se ha seleccionado hombro. Operaciones que se pueden hacer: subir, bajar
myPort.write('A');
//delay(100);
27/35
break;
case 4://Se ha seleccionado munyeca. Operaciones que se pueden hacer: girar horario, girar antihorario
dibRecAccion(9);
myPort.write('X');
//delay(100);
break;
}
}
if (accionSelectexto != NINGUNO)
{
textFont(miFont,16);//especifica la fuente con la escribir el texto
text("MOTOR: "+textos[accionSelectexto]+"> Movimiento", width/2+20, height/2+20);
switch(accionSelec)
{
case 0://adelante
myPort.write('N');
//delay(100);
break;
case 1://atras
myPort.write('M');
//delay(100);
break;
case 2://adelante
myPort.write('P');
//delay(100);
break;
}
}
}
/**
Dibuja linea central
*/
28/35
void dibLinCentral()
{
stroke(#E320E0);//selecciona tinta
strokeWeight(5);//espesor linea
line(0, height/2, width, height/2);
}
/**
Dibuja rectangulos
Dibuja 5 botones en la parte superior del area de trabajo, coge los textos del array de String's textos.
*/
void dibRecSeleccion()
{
int ancho=130, alto=32, posX=8, posY=height/4, margen=8;
stroke(#FC035A);
for (int i=0; i<5; i++)
{
fill(color_por_defecto1);
rect(posX, posY, ancho, alto);
fill(0);
text(textos[i], posX+5, posY+alto*2/3);
posX = posX + ancho + margen;
}
}
/**
Dibuja 3 botones en la parte inferior de la ventana, coge los textos de los dos primeros del array de String's
textos. El indice del texto del primer parmetro es indicado como parmetro.
el tercer botn que dibuja siempre tiene como texto la posicin 11.
*/
void dibRecAccion(int accion1)
{
int ancho=213, alto=32, posX=15, posY=height*3/4, margen=15;
int color_relleno_boton = #2707E3, parar = 11; //parar es la posicin de la accin comun a todos los
motores
stroke(#FC035A);//tinta borde
29/35
//dib primer botn de accion

fill(color_relleno_boton);//color relleno botn
rect(posX, posY, ancho, alto);//fib rectangulo
fill(0);//color para texto, de lo contrario escribe con el color de relleno anterior
text(textos[0+accion1], posX+5, posY+alto*2/3);//escribe el texto de la posicion accion1 de la lista
//dib el siguiente boton

posX = posX + ancho + margen;//calcula la posX del boton 2
fill(color_relleno_boton);
rect(posX, posY, ancho, alto);//dib rectangulo
fill(0);
text(textos[accion1+1], posX+5, posY+alto*2/3);//escribe texto
//dib el boton de la accion para, que es comun a todos los motores

posX = posX + ancho + margen;//calcula la posX del boton 2
fill(color_relleno_boton);
rect(posX, posY, ancho, alto);//dib rectangulo
fill(0);
text(textos[parar], posX+5, posY+alto*2/3);//escribe texto
}
/**
Al hacer clic en el ratn se recorren todos los botones de motores y se comprueba, con el if, si se ha pulsado
en alguno de ellos.
Si se pulsa se guarda la posicin del botn seleccionado, se reinicializa la accin a realizar a NINGUNO
(accionSelectexto = NINGUNO),
se borra la accin anterior text(" ", width/2+20, height/2+20)
*/
void mouseClicked()
{
int ancho=130, alto=32, posX=8, posY=height/4, margen=8;
stroke(#FC035A);
//println("mouseClicked:");
for (int i=0; i<5; i++)
{
//print(" i: "+ i);
30/35
if (mouseX >posX && mouseX< posX+ancho && mouseY >posY && mouseY<posY+alto) {//comprobar en
que area se hace el clic
//print(" posX: "+posX);
btSeleccionado = i;//se guarda la posicin del botn pulsado
accionSelectexto = NINGUNO;//se elimina la accin anterior
text(" ", width/2+20, height/2+20);//se borra el texto asociado a la accin anterior
}
posX = posX + ancho + margen;//se pasa a la posicin del siguiente botn
//print("\n");
}
//if (btSeleccionado !=NINGUNO )
{
ancho = 213; //ancho del botn de accin
alto = 32; // alto del botn de accin
posX = 15; // posicin X del primer botn de accin
margen = 15; // distancia entre botones
posY = height*3/4;//posicin Y de los botones
for (int i=0; i<3; i++)//recorrer los tres botones
{
//print("accin i: "+ i);
if (mouseX >posX && mouseX< posX+ancho && mouseY >posY && mouseY<posY+alto) {//comprobar en
que area se hace el clic
//print(" posX: "+posX);
if (btSeleccionado == 2 || btSeleccionado == 4 ) {// los motores 2 y 4 tiene los mismos nombres para las
acciones, comprobar en el String[] textos
accionSelectexto = i + 9;//indice del texto a seleccionar
accionSelec = i;//indice de la accin a realizar
}
if (btSeleccionado == 1 || btSeleccionado == 3 ) {// los motores 1 y 3 tiene los mismos nombres para las
acciones, comprobar en el String[] textos
accionSelectexto = i + 5;//...
accionSelec = i;//...
}
if (btSeleccionado == 0 ) {//seleccionada la Pinza
31/35
accionSelectexto = i + 7;//...
accionSelec = i;//...
}
if (i == 2 ) {//seleccionada la accin de parar. Accin comn a todos los motores
accionSelectexto = 11;//posicin del texto "Parar" en String[] textos
accionSelec = i;
}
}
posX = posX + ancho + margen;//actualiza la posicin del siguiente botn a comprobar.
//print("\n");
}
}
}
32/35
5. Control de Motores de CC con el chip L293D y arduino.
Seguimos el tutorial de prometec,

manejo de motores de corriente contnua con el integrado L293D, este CI incluye dos
puentes H, es por tanto capaz de manejar dos motores de corriente contnua.
Material necesario:
Motor de cc
Integrado L293D
Placa board
Pila y portapilas 9v (para alimentar los motores)
Placa arduino y cable.
5.1 Esquema del L293D
Conectamos el motor a los pines 3 y 6. El

pin 8 a 9V, el pin 16 a 5V arduino. Los
pines gnd al gnd de arduino y de la pila
de 9v, nos quedan los pines 2, 3,y 7 para
conectar a las salidas digitales de arduino.
8 - Vs y 16-Vss mejor a pilas que
alimentan el motor (6 Voltios).
El funcionamiento de los pines 2 y 7 es el

siguiente:
enable Pin 2 Pin 7 motor
low - - parado
high high low Motor
adelante
high low high Motor atras
high high high Motor parado
high low low Motor parado
Conectamos el pin 1, a la entrada 10 de arduino, el pin 2 a la entrada 9 de arduino, y el pin

7 a la entrada 8 de arduino.
33/35
2.2 Conexiones del L293D con arduino
Pin driver L293D Pin Arduino

1 enable 10 pwm
2 input motor1 izqdo 9
7 input motor1 8
9 enable 5pwm
10input motor 2 dcho 6
15 inputmotor 2 dcho 7
34/35
Autores.
Este trabajo lo han realizado Maria (IES Puol) y yo (IES El Puig).
35/35

Ra-01 Odt

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Ra-01 Odt

Încărcat de

Drepturi de autor:

Formate disponibile

DeINF[ DEPARTAMENT DINFORMTICA ]

IES El Puig de Santa Maria

PIN Accin Observaciones

2 Proyectos que se pueden realizar.

3 Conexiones Brazo Arduino Mega.

Chip 1 Pin driver L293D Pin Arduino

Chip 2 Pin driver L293D Pin Arduino

4 Explicacin del cdigo.

4.1 Configuracin del brazo - robot.

4.2 Clase Motor.

4.3 Implementacin clase Motor.

4.4 Clase Brazo.

#include "Motor.h" //Nuestro brazo robtico es una lista o array de motores

4.5 Implementacin clase Brazo.

//operaciones que se pueden realizar con el brazo

//1 - Motor 3 > codo Subir / Bajar

//2 - Motor 4 > base Horario / Antihorario

if (DEBUG) Serial.println("para base");

//3 - Motor 6 > hombro Subir / Bajar

//4 - Motor 7 > munyeca Horario / Antihorario

4.5 Otros defines.

4.6 Programa que controla el brazo.

//estructura de un movimiento asociado a un motor

int numeromotor;//valores del 0 al 4, motor que se ver afectado

}// fin de if (valido)

4.7 Interfaz processing para el control del brazo de robot.

Ilustracin 1: Interfaz Robot (desarrollado con processing)

4.8 Programa processing que implementa la interfaz.

//dib primer botn de accion

//dib el siguiente boton

//dib el boton de la accion para, que es comun a todos los motores

5. Control de Motores de CC con el chip L293D y arduino.

Seguimos el tutorial de prometec,

5.1 Esquema del L293D

Conectamos el motor a los pines 3 y 6. El

El funcionamiento de los pines 2 y 7 es el

Conectamos el pin 1, a la entrada 10 de arduino, el pin 2 a la entrada 9 de arduino, y el pin

2.2 Conexiones del L293D con arduino

Pin driver L293D Pin Arduino

S-ar putea să vă placă și