Informe Labo Controlffffff

UNIVERSIDAD NACIONAL DE
SAN ANTONIO ABAD DEL CUSCO
FACULTAD : INGENIERÍA ELÉCTRICA,

ELECTRÓNICA, MECÁNICA Y MINAS
ESCUELA PROFECIONAL:
INGENIERÍA ELECTRÓNICA
ASIGNATURA: LABORATORIO DE
CONTROL
PROYECTO: ANIMACIÓN DE BRAZO

ROBÓTICO 3D
DOCENTE: Ing. Alex Jhon Quispe Mescco
INTEGRANTES:
 Lloclle Delgado Humberto 070770
 Flores Vasquez Jose Luis 042969
 Sicos Quispe Ricardo Yescan 083251
 Mamani Quispe Adriel 111878
Cusco,febrero del 2017

Introduccion
La cinemática directa de tres brazos robóticos sencillos, de 1, 2 y 3 grados

de libertad usando transformadas homogéneas y la herramienta Octave ,
corriendo en una máquina con Ubuntu Linux
instalación de octave en Ubuntu
sudo apt-get install octave3.2
Robot con un grado de libertad
Sólo es necesario usar una transformación homogénea determinada por una

rotación de <math>q_1</math> grados alrededor del eje <math>x_1</math> y una
traslación de <math>l_1</math> sobre el eje <math>y_1</math>:
<math>A_1=Rotx(q_1)Trasy(l_1)</math>
Fig 1: Cinemática del robot 1
En la Figura 1 se muestra la geometría del robot y la nomenclatura empleada

para los sistemas de referencia
Un brazo robot de 2 grados de libertad
Las dos matrices de transformación son:
 <math>A_1=Rotx(q_1)Trasy(l_1)</math>
donde: Rotx y Trasy son las mismas matrices del ejemplo anterior
Fig 3: Cinemática del robot 2
la Figura 3 se muestra la geometría del robot y la nomenclatura empleada para

los sistemas de referencia
Robot con 2 grados de libertad para posicionamiento del manipulador y 1

para su orientación
La nueva matriz de transformación es:
 <math>A_3=Rotx(q_3)</math>
Fig 4: Cinemática del robot
la Figura 4 se muestra la geometría del robot y la nomenclatura empleada para

los sistemas de referencia
Un brazo robot de 3 grados de libertad
Las matrices de transformación homogéneas son:
 <math>A_0=Rotz(g_0)</math>
donde las matrices Rotx y Trasy son las mismas
Fig 6: Cinemática del Robot 3
¿Que es un Aceleró metro?
Un aceleró metro es un es un tipo de sensor analógico transductor que
detecta el movimiento o el giro, es decir, es capaz de responder con una
señal eléctrica ante una perturbación inducida por la aplicación de una
fuerza o la gravedad. Este dispositivo es capaz de detectar si está en
horizontal o vertical o por ejemplo si los agitamos en el aire.
acelerómetro de 3 ejes ADXL335 con Arduino

para usar el acelerómetro ADXL335 con Arduino. El acelerómetro ADXL335 es un
sensor de alta calidad que incluye unos condensadores de desacoplo en la
placa para su óptimo funcionamiento y que ya viene preparado para usarse en
cualquier tipo de proyecto con microcontroladores incluyendo proyectos de
robótica.
Este acelerómetro devuelve una tensión proporcional a la aceleración
detectada por el sensor, con lo que podemos interpretar las señales
fácilmente con Arduino o con nuestro microcontrolador favorito mediante los
pines analógicos.
Esquema y conexiones
Alimentaremos el módulo desde el pin de 3.3v del Arduino y conectaremos el
pin GND del sensor a cualquier pin GND del Arduino. Los pines X, Y y Z del
sensor van conectados a los pines A1, A2 y A3 del Arduino respectivamente, y
con esto, ya lo tenemos todo preparado para subir el sketch de prueba.
El ADXL335 proporcionará a Arduino, tres voltajes proporcionales a la
aceleración de cada eje X, Y y Z. Algo muy importante es que se trata de un
dispositivo que se alimenta a 3.3 V, por lo que hay que tener cuidado al
conectarlo a nuestro Arduino de no hacerlo a la salida de 5v, ya que
dañaríamos el sensor.
Que es un giroscopio
Si giramos alrededor de un eje del acelerómetro no nos variará la medida,
esto no lo mide el acelerómetro, los giros los mide el giroscopio. Si
combinamos un acelerómetro de 3 ejes con un giroscopio de tres ejes tendremos
perfectamente definida la orientación de el objeto en el espacio y respecto
del espacio (tendríamos un IMU de 6 ejes). Si le añadimos además una brújula
digital o magnetometro de 3 ejes, también tendremos la orientación respecto a
los polos magnéticos. Este sistema completo seria un IMU de 9 ejes. Y de ahí
saltaríamos al gps, altímetro. Etc
Pro Micro arduino
En concreto cuenta con 18 pines para datos y se configura según la función
que deseemos como se ve en la siguiente imagen cuenta con 18 salidas/entradas
digitales.
Las cuales 5 tienen función PWM, 9 funcionan también como entradas
analógicas, 2 como puerto UART, 2 más para el puerto I2C, y 3 para el puerto
ISP. Es decir, tiene de todo
Un detalle que cuenta con tres leds: Encendido, RX y TX. No cuenta con un led
especifico para el pin 13 como tienen todos los Arduinos, pero ojo, que eso
no quiere decir que no podamos hacer un ¡Hola mundo!, todo lo contrario, con
este Arduino podemos usar el pin RX y TX como leds programables, ambos
Simulink 3D Animation Viewer

Código del arduino
/////////////////////////////////////////////////////////////////
//©2011 bildr
//Released under the MIT License - Please reuse change and share
//Simple code for the ADXL335, prints calculated orientation via serial
//////////////////////////////////////////////////////////////////
//Analog read pins
const int xPin = 0;
const int yPin = 1;
const int zPin = 2;
//The minimum and maximum values that came from
//the accelerometer while standing still
//You very well may need to change these
int minVal = 275;
int maxVal = 414;

//to hold the caculated values
double x;
double y;
double z;
void setup(){
Serial.begin(9600);
void loop(){
//read the analog values from the accelerometer
int xRead = analogRead(xPin);
int yRead = analogRead(yPin);
int zRead = analogRead(zPin);
//convert read values to degrees -90 to 90 - Needed for atan2
int xAng = map(xRead, minVal, maxVal, -90, 90);
int yAng = map(yRead, minVal, maxVal, 0, 220);
int zAng = map(zRead, minVal, maxVal, -90, 90);
//Caculate 360deg values like so: atan2(-yAng, -zAng)
//atan2 outputs the value of -π to π (radians)
//We are then converting the radians to degrees
x = RAD_TO_DEG * (atan2(-yAng, -zAng) + PI);

y = RAD_TO_DEG * (atan2(-xAng, -zAng) + PI);
z = RAD_TO_DEG * (atan2(-yAng, -xAng) + PI);
//Output the caculations
//Serial.print("x: ");
Serial.print(0);
Serial.print(",");
Serial.println(yAng);
//Serial.print(",");
//Serial.println(z);
delay(300);//just here to slow down the serial output - Easier to read
Código del Matlab

function varargout = Control_brazo_robotico(varargin)
% CONTROL_BRAZO_ROBOTICO M-file for Control_brazo_robotico.fig

% CONTROL_BRAZO_ROBOTICO, by itself, creates a new
CONTROL_BRAZO_ROBOTICO or raises the existing
% singleton*.
%
% H = CONTROL_BRAZO_ROBOTICO returns the handle to a new
CONTROL_BRAZO_ROBOTICO or the handle to
% the existing singleton*.
%
% CONTROL_BRAZO_ROBOTICO('CALLBACK',hObject,eventData,handles,...)
calls the local
% function named CALLBACK in CONTROL_BRAZO_ROBOTICO.M with the given
input arguments.
%
% CONTROL_BRAZO_ROBOTICO('Property','Value',...) creates a new
CONTROL_BRAZO_ROBOTICO or raises the
% existing singleton*. Starting from the left, property value pairs
are
% applied to the GUI before Control_brazo_robotico_OpeningFcn gets
called. An
% unrecognized property name or invalid value makes property
application
% stop. All inputs are passed to Control_brazo_robotico_OpeningFcn
via varargin.
%
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only
one
% instance to run (singleton)".
%
% See also: GUIDE, GUIDATA, GUIHANDLES
% Edit the above text to modify the response to help

Control_brazo_robotico
% Last Modified by GUIDE v2.5 14-Feb-2017 12:17:19
% Begin initialization code - DO NOT EDIT
delete(instrfind({'port'},{'COM7'}));
global puerto;
puerto = serial('COM7');
puerto.BaudRate=9600;
fopen(puerto);%abre el puerto a utilizar
gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @Control_brazo_robotico_OpeningFcn,
...
'gui_OutputFcn', @Control_brazo_robotico_OutputFcn,
...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end
if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
% --- Executes just before Control_brazo_robotico is made visible.
function Control_brazo_robotico_OpeningFcn(hObject, eventdata, handles,
varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to Control_brazo_robotico (see
VARARGIN)
% Choose default command line output for Control_brazo_robotico

handles.output = hObject;
% Update handles structure

guidata(hObject, handles);
%SE DECLARA LA RUTINA QUE DEBE DE EJECUTARSE AL CERRAR LA APLICACIÓN
set(handles.figure1,'CloseRequestFcn',@closeGUI);
global world Velocidad fig Rango_A Rango_B Rango_C Rango_G_P Edit_GradoA
Edit_GradoB Edit_GradoC Edit_Giro_P AntiguoA AntiguoB AntiguoC AntiguoP n
Antiguo_Rango_A...
Antiguo_Rango_B Antiguo_Rango_C Antiguo_Rango_G_P s i fig Antiguo_i
data1 Stop
axis off
i=0.19;
s=0;
close(world);
world=vrworld('Brazo2.wrl','new');%
open(world);
fig=vrfigure(world);%cargando Mundo VRML
set(fig,'Viewpoint','Superior');
set(fig,'Viewpoint','Atras');
set(fig,'Viewpoint','Frente');
set(fig,'Name','BRAZO ROBÓTICO ')
set(fig,'ZoomFactor',0.8);
set(fig,'NavMode','Examine');
Velocidad=0.01;
set(handles.Edit_GradoA,'String','');
set(handles.Edit_GradoB,'String','');
set(handles.Edit_GradoC,'String','');
set(handles.Edit_Giro_P,'String','');
data1=[];%tabla en cero
set(handles.Tabla,'Data',data1);
%valores obtenidos de los slider
Rango_A=0;
Rango_B=0;
Rango_C=0;
Rango_G_P=0;
%valores obtenidos de Las cajas editables
Edit_GradoA=0;
Edit_GradoB=0;
Edit_GradoC=0;
Edit_Giro_P=0;
%Antigos valores obtenidos de los slider o cajas editables
AntiguoA=0;
AntiguoB=0;
AntiguoC=0;
AntiguoP=0;
Antiguo_Rango_A=100;
Antiguo_Rango_B=100;
Antiguo_Rango_C=100;
Antiguo_Rango_G_P=100;
Antiguo_i=0.19;
n=0;
Stop=0;
% --- Outputs from this function are returned to the command line.
function varargout = Control_brazo_robotico_OutputFcn(hObject, eventdata,
handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% Get default command line output from handles structure

varargout{1} = handles.output;
%_____________________________OBTENIENDO DATOS DE
BARRA____________________
% --- Executes on slider movement.
function GradoA_Callback(hObject, eventdata, handles)
global Rango_A world Velocidad AntiguoA
Rango_A=get(hObject,'Value'); %Carga en handles.slider1
Grado_A=vrnode(world,'Brazo_3Grados');%cargando nodo de VRML
Grado_A.rotation=[0 1 0 Rango_A];
AntiguoA=Rango_A;
Rango_A1=(Rango_A*180/pi);%convirtiendo valor a grados
set(handles.GradoA,'SliderStep',[Velocidad 0]);%Velocidad
set(handles.Grado_A,'String',Rango_A1); %Escribe el valor de
vrdrawnow;
function GradoB_Callback(hObject, eventdata, handles)
global Rango_B world Velocidad AntiguoB
Rango_B=get(hObject,'Value'); %Carga en handles.slider1
Grado_B=vrnode(world,'Grado2');%cargando nodo de VRML
Grado_B.rotation=[0 0 1 Rango_B];
AntiguoB=Rango_B;
Rango_B1=(Rango_B*180/pi);%convirtiendo valor a grados
set(handles.GradoB,'SliderStep',[Velocidad 0]);%Velocidad
set(handles.Grado_B,'String',Rango_B1); %Escribe el valor de
vrdrawnow;
function GradoC_Callback(hObject, eventdata, handles)
global Rango_C world Velocidad AntiguoC
Rango_C=get(hObject,'Value'); %Carga en handles.slider1
Grado_C=vrnode(world,'Grado3');%cargando nodo de VRML
Grado_C.rotation=[0 0 1 Rango_C];
AntiguoC=Rango_C;
Rango_C1=(Rango_C*180/pi);%convirtiendo valor a grados
set(handles.GradoC,'SliderStep',[Velocidad 0]);%Velocidad
set(handles.Grado_C,'String',Rango_C1); %Escribe el valor de
vrdrawnow;
function GIRO_PINZA_Callback(hObject, eventdata, handles)
global Rango_G_P world Velocidad AntiguoP
Rango_G_P=get(hObject,'Value'); %Carga en handles.slider1
Giro_P=vrnode(world,'Pinza');%cargando nodo de VRML
Giro_P.rotation=[0 1 0 Rango_G_P];
AntiguoP=Rango_G_P;
Rango_G_P1=(Rango_G_P*180/pi);%convirtiendo valor a grados
set(handles.GIRO_PINZA,'SliderStep',[Velocidad 0]);%Velocidad
set(handles.Giro_P,'String',Rango_G_P1); %Escribe el valor de
vrdrawnow;
%________________________________________________________________________
__
% --- Executes on button press in Cierra_Pinza.
function Cierra_Pinza_Callback(hObject, eventdata, handles)
global world i
set(handles.Aabre_pinza,'Enable','off');
set(handles.Cierra_Pinza,'Enable','off');
if(i==0.19)
set(handles.Aabre_pinza,'Enable','on');
set(handles.Cierra_Pinza,'Enable','on');
return
end
for i=0.4480:-0.001:0.19
Garra=vrnode(world,'Garra1');%cargando nodo de VRML
Garra.translation=[-i -0.6160 0.0240];
Garra2=vrnode(world,'Garra1_1');
if (i>0.22)
Garra2.translation=[i -0.6160 0.0240];
end
vrdrawnow;
drawnow
end
% --- Executes on button press in Aabre_pinza.
function Aabre_pinza_Callback(hObject, eventdata, handles)
global world i
if(i==0.4480)
return
end
for i=0.19:0.001:0.4480
Garra=vrnode(world,'Garra1');%cargando nodo de VRML
Garra.translation=[-i -0.6160 0.0240];
Garra2=vrnode(world,'Garra1_1');
if (i>0.22)
Garra2.translation=[i -0.6160 0.0240];
end
vrdrawnow;
drawnow
end
%________________________________________________________________________
__
%_________________Executes on button press in
Home_________________________
function Home_Callback(hObject, eventdata, handles)
global world Velocidad Rango_A Rango_B Rango_C Rango_G_P A B C P
Edit_GradoA Edit_GradoB Edit_GradoC Edit_Giro_P AntiguoA AntiguoB
AntiguoC AntiguoP
A=0;
B=0;
C=0;
P=0;
set(handles.Home,'Enable','off');
set(handles.Trial,'Enable','off');
set(handles.Run_Secuencia,'Enable','off');
set(handles.Save_Posicion,'Enable','off');
set(handles.New_Posicion,'Enable','off');
for a=pi:-Velocidad:-pi,
%--------------------------Retorno de
GradoA-------------------------------
if(Rango_A<0 && -a>=Rango_A && -a<=0 )%retorno desede posición menor
a 0 (-180,0)
Grado_A.rotation=[0 1 0 -a];
set(handles.GradoA,'Value',-a);%Retornando valor en el guide
A=(-a*180/pi);
set(handles.Grado_A,'String',A); %Escribe el valor de a en Static
Text de A
vrdrawnow;%ayuda a mostrar en timepo real la ejecición de la
animación del VRML
drawnow%ayuda a mostrar en timepo real la ejecición de la
animación del las Barras del guide
end
if(Rango_A>0 && a<=Rango_A && a>=0 )%retorno desede posición menor a
0 (180,0)
Grado_A.rotation=[0 1 0 a];
set(handles.GradoA,'Value',a);
A=(a*180/pi);
set(handles.Grado_A,'String',A); %Escribe el valor de a en Static
Text de C
vrdrawnow;
drawnow
end
%--------------------------Retorno de
GradoB-------------------------------
if(a<=Rango_B && a>=0 )
b=a;
Grado_B.rotation=[0 0 1 b];
set(handles.GradoB,'Value',b);
B=(b*180/pi);
set(handles.Grado_B,'String',B); %Escribe el valor de B en Static
Text de B
vrdrawnow;
drawnow
end
%--------------------------Retorno de
GradoC-------------------------------
if(a<=Rango_C && a>=0 )
c=a;
Grado_C.rotation=[0 0 1 c];
set(handles.GradoC,'Value',c);
C=(c*180/pi);
set(handles.Grado_C,'String',C); %Escribe el valor de C en Static
Text de C
vrdrawnow;
drawnow
end
%--------------------------Retorno de
Pinza-------------------------------
if(a<=Rango_G_P && a>=0 )
p=a;
Grado_P=vrnode(world,'Pinza');%cargando nodo de VRML
Grado_P.rotation=[0 1 0 p];
set(handles.GIRO_PINZA,'Value',p);
P=(p*180/pi);
set(handles.Giro_P,'String',P); %Escribe el valor de P en Static
Text de P
vrdrawnow;
drawnow
end
end
%asegurando retorno A en 0 completo
Grado_A.rotation=[0 1 0 0];
set(handles.GradoA,'Value',0);
set(handles.Grado_A,'String',0);
%asegurando retorno B en 0 completo
Grado_B.rotation=[0 0 1 0];
set(handles.GradoB,'Value',0);
set(handles.Grado_B,'String',0);
%asegurando retorno C en 0 completo
Grado_C.rotation=[0 0 1 0];
set(handles.GradoC,'Value',0);
set(handles.Grado_C,'String',0);
%asegurando retorno Pinza en 0 completo
Grado_P.rotation=[0 1 0 0];
set(handles.GIRO_PINZA,'Value',0);
set(handles.Giro_P,'String',0);
vrdrawnow;
drawnow
%limpiado Variables
Rango_A=0;
Rango_B=0;
Rango_C=0;
Rango_G_P=0;
Edit_GradoA=0;
Edit_GradoB=0;
Edit_GradoC=0;
Edit_Giro_P=0;
AntiguoA=0;
AntiguoB=0;
AntiguoC=0;
AntiguoP=0;
%Cierra Pinza
Cierra_Pinza_Callback(hObject, eventdata, handles)
set(handles.Home,'Enable','on');
set(handles.Trial,'Enable','on');
set(handles.Run_Secuencia,'Enable','on');
set(handles.Save_Posicion,'Enable','on');
set(handles.New_Posicion,'Enable','on');
%________________________________________________________________________
__
% --- Executes on button press in Run_Secuencia.

function Run_Secuencia_Callback(hObject, eventdata, handles)
global n data1 Edit_Giro_P Edit_GradoA Edit_GradoB Edit_GradoC fig
set(fig,'CameraPosition',[0 6 4]);
set(fig,'CameraDirection',[0 -0.4 -0.96]);
Home_Callback(hObject, eventdata, handles)%posición inicial
for n2=1:n
data1(n2,1)=-n2;
Edit_GradoA=(data1(n2,2)*pi)/180;
Edit_GradoB=(data1(n2,3)*pi)/180;
Edit_GradoC=(data1(n2,4)*pi)/180;
Edit_Giro_P=(data1(n2,5)*pi)/180;
Movimentos_Callback(hObject, eventdata, handles)
if(data1(n2,6)==1)
Aabre_pinza_Callback(hObject, eventdata, handles)

else

end
end
%________________________________________________________________________
__
% --- Executes on button press in Trial.

function Trial_Callback(hObject, eventdata, handles)
global Edit_GradoA Edit_GradoB Edit_GradoC Edit_Giro_P fig
%Secuencia1
Edit_GradoA=((180*pi)/180);
Edit_GradoB=((90*pi)/180);
Edit_GradoC=((90*pi)/180);
Edit_Giro_P=((180*pi)/180);
%Secuencia2
Edit_GradoA=((-90*pi)/180);
%Secuencia3
%Secuencia4
%Secuencia5
%________________________________________________________________________
__
function Movimentos_Callback(hObject, eventdata, handles)

global world Velocidad Rango_A Rango_B Rango_C Rango_G_P A B C P
Edit_GradoA Edit_GradoB Edit_GradoC Edit_Giro_P AntiguoA AntiguoB
AntiguoC AntiguoP
A=0;
B=0;
C=0;
P=0;
a0=AntiguoA;
b=AntiguoB;
c=AntiguoC;
p=AntiguoP;
for a=-pi:Velocidad:pi
%--------------------------Retorno de
GradoA-------------------------------
if(AntiguoA~=Edit_GradoA)
if(Edit_GradoA<0)
%decremento de barra
if(AntiguoA>Edit_GradoA)
if(a<=AntiguoA && a>=Edit_GradoA)%Para todo Edit_GradoA<=a<=AntiguoA
Rango_A=Edit_GradoA;
Grado_A.rotation=[0 1 0 a0];
set(handles.GradoA,'Value',a0);
A=round(a0*180/pi);
set(handles.Grado_A,'String',A); %Escribe el valor de
a0=a0-Velocidad;
vrdrawnow;
drawnow
end
else
%incremento de barra
if(a>=AntiguoA && a<=Edit_GradoA)%Para todo AntiguoA<=a<=Edit_GradoA
a0=a;
A= round(a0*180/pi);
vrdrawnow;
drawnow
end
end
%%retorno desede posición mmayores a 0 (0,180)

else
if(AntiguoA>Edit_GradoA)
if(a<=AntiguoA && a>=Edit_GradoA)%Para todo AntiguoA=>a>=Edit_GradoA
A=round(a0*180/pi);
a0=a0-Velocidad;
vrdrawnow;
drawnow
end
else
if(a<=Edit_GradoA && a>=AntiguoA) %Para todo Edit_GradoA=>a>=AntiguoA
a0=a;
A= round(a0*180/pi);
vrdrawnow;
drawnow
end
end
end
end
%--------------------------Retorno de
GradoB-------------------------------
if(AntiguoB~=Edit_GradoB)
if(AntiguoB>Edit_GradoB)
if(a<=AntiguoB && a>=Edit_GradoB)
Rango_B=Edit_GradoB;
B=round(b*180/pi);
set(handles.Grado_B,'String',B); %Escribe el valor de
b=b-Velocidad;
vrdrawnow;
drawnow
end
else
if(a<=Edit_GradoB && a>=AntiguoB)
Rango_B=Edit_GradoB;
b=a;
B=round(b*180/pi);
set(handles.Grado_B,'String',B); %Escribe el valor de
vrdrawnow;
drawnow
end
end
end
%--------------------------Retorno de
GradoC-------------------------------
if(AntiguoC~=Edit_GradoC)
if(AntiguoC>Edit_GradoC)
if(a<=AntiguoC && a>=Edit_GradoC)
Rango_C=Edit_GradoC;
C=round(c*180/pi);
set(handles.Grado_C,'String',C); %Escribe el valor de
c=c-Velocidad;
vrdrawnow;
drawnow
end
else
if(a<=Edit_GradoC && a>=AntiguoC)
Rango_C=Edit_GradoC;
c=a;
C=round(c*180/pi);
set(handles.Grado_C,'String',C); %Escribe el valor de
vrdrawnow;
drawnow
end
end
end
%--------------------------Retorno de
Pinza-------------------------------
if(AntiguoP~=Edit_Giro_P)
if(AntiguoP>Edit_Giro_P)
if(a<=AntiguoP && a>=Edit_Giro_P)
Rango_G_P=Edit_Giro_P;
P=round(p*180/pi);
set(handles.Giro_P,'String',P); %Escribe el valor de
p=p-Velocidad;
vrdrawnow;
drawnow
end
else
if(a<=Edit_Giro_P && a>=AntiguoP)
Rango_G_P=Edit_Giro_P;
p=a;
P=round(p*180/pi);
set(handles.Giro_P,'String',P); %Escribe el valor de
vrdrawnow;
drawnow
end
end
end
end
AntiguoA=Edit_GradoA;
AntiguoB=Edit_GradoB;
AntiguoC=Edit_GradoC;
AntiguoP=Edit_Giro_P;
%________________________________________________________________________
__
%________________________CAPTANDO ANGULOS DE
%USIARIO______________________
function Edit_GradoA_Callback(hObject, eventdata, handles)
global Edit_GradoA Edit_GradoB Edit_GradoC Edit_Giro_P AntiguoB AntiguoC
AntiguoP
Edit_GradoA=str2double(get(hObject,'String')); %Almacenar valor ingresado
y Transformar a formato double
%identifica valor no numerico
if isnan(Edit_GradoA)
errordlg('El valor debe ser numérico','ERROR');
return
end
%identificando rango
if(Edit_GradoA<-180 ||Edit_GradoA>180)
errordlg('El Rango incorrecto (-180,180)','ERROR');
return
end
Edit_GradoA=((Edit_GradoA*pi)/180);
%ASEGURANDO SOLO EL MOVIMIENTO DE BARAS A
Edit_GradoB=AntiguoB;
Edit_GradoC=AntiguoC;
Edit_Giro_P=AntiguoP;
function Edit_GradoB_Callback(hObject, eventdata, handles)

global Edit_GradoA Edit_GradoB Edit_GradoC Edit_Giro_P AntiguoA AntiguoC
AntiguoP
Edit_GradoB=str2double(get(hObject,'String')); %Almacenar valor ingresado
if isnan(Edit_GradoB)
return
end
if(Edit_GradoB<0 ||Edit_GradoB>180)
errordlg('El Rango incorrecto (0,180)','ERROR');
return
end
Edit_GradoB=((Edit_GradoB*pi)/180);
%ASEGURANDO SOLO EL MOVIMIENTO DE BARAS B
Edit_GradoA=AntiguoA;
function Edit_GradoC_Callback(hObject, eventdata, handles)

global Edit_GradoA Edit_GradoB Edit_GradoC Edit_Giro_P AntiguoB AntiguoA
AntiguoP
Edit_GradoC=str2double(get(hObject,'String')); %Almacenar valor ingresado
if isnan(Edit_GradoC)
return
end
if(Edit_GradoC<0 ||Edit_GradoC>180)
return
end
Edit_GradoC=((Edit_GradoC*pi)/180);
%ASEGURANDO SOLO EL MOVIMIENTO DE BARAS C
function Edit_Giro_P_Callback(hObject, eventdata, handles)

global Edit_Giro_P Edit_GradoA Edit_GradoB Edit_GradoC AntiguoB AntiguoC
AntiguoA
Edit_Giro_P=str2double(get(hObject,'String')); %Almacenar valor ingresado
if isnan(Edit_Giro_P)
return
end
if(Edit_Giro_P<0 ||Edit_Giro_P>180)
return
end
Edit_Giro_P=((Edit_Giro_P*pi)/180);
%ASEGURANDO SOLO EL MOVIMIENTO DE BARAS GIRO PINZA
%________________________________________________________________________
__
function closeGUI(source,eventdata)
global i
selection = questdlg('Desea cerrar la aplicación?',...
'Confirmación',...
'Si','No','Si');
switch selection,
case 'Si',
delete(gcf)
clear all
i=0.19;
case 'No'
return
end
function Save_Posicion_Callback(hObject, eventdata, handles)
global n n0 data1 Rango_A Rango_B Rango_C Rango_G_P Antiguo_Rango_A
Antiguo_Rango_B Antiguo_Rango_C Antiguo_Rango_G_P Antiguo_i i s
if(Rango_A==Antiguo_Rango_A && Rango_B==Antiguo_Rango_B &&
Rango_C==Antiguo_Rango_C && Rango_G_P==Antiguo_Rango_G_P && i==Antiguo_i)
return
else
if(i==0.19)
s=0;
else
s=1;
end
n=n+1;
%Creando Columnas
n0=1:n;
%ingresando datos
data1(n0,1)=n0;
data1(n,2)=Rango_A*180/pi;
data1(n,3)=Rango_B*180/pi;
data1(n,4)=Rango_C*180/pi;
data1(n,5)=Rango_G_P*180/pi;
data1(n,6)=s;
end
Antiguo_Rango_A=Rango_A;
Antiguo_Rango_B=Rango_B;
Antiguo_Rango_C=Rango_C;
Antiguo_Rango_G_P=Rango_G_P;
Antiguo_i=i;
function New_Posicion_Callback(hObject, eventdata, handles)

global n data1
n=0;
data1=[];%tabla en cero
% --- Executes on button press in Stop.

function Stop_Callback(hObject, eventdata, handles)
global puerto parar
fclose(puerto);
delete(puerto);
parar = 1;
pause on
pause
% % function datos=refresco_angulo()
% % global world puerto valorANGULO angulo_b
% % %while 1
% % valorANGULO=fscanf(puerto,'%d,%d'); %Toma el valor recibido por
el puerto y lo guarda en la variable
% % angulo_b=valorANGULO(2)/100;
% % Grado_B=vrnode(world,'Grado2');%cargando nodo de VRML
% % Grado_B.rotation=[0 0 1 angulo_b];
% % %end
% --- Executes on button press in boton_Inicio.
function boton_Inicio_Callback(hObject, eventdata, handles)
% hObject handle to boton_Inicio (see GCBO)
global world puerto valorANGULO angulo_b Velocidad AntiguoB parar
%for i=1:200
parar = 0;
while parar==0
valorANGULO=fscanf(puerto,'%d,%d'); %Toma el valor recibido por el
puerto y lo guarda en la variable
angulo_b=valorANGULO(2)/100;
Grado_B.rotation=[0 0 1 angulo_b];
AntiguoB=angulo_b;
Rango_B1=(angulo_b*180/pi);%convirtiendo valor a grados
set(handles.GradoB,'SliderStep',[Velocidad 0]);%Velocidad
set(handles.Grado_B,'String',Rango_B1);
vrdrawnow;
end
fotografias de guide de nuestra pruevas

Informe Labo Controlffffff

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Informe Labo Controlffffff

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSIDAD NACIONAL DE

SAN ANTONIO ABAD DEL CUSCO

FACULTAD : INGENIERÍA ELÉCTRICA,

PROYECTO: ANIMACIÓN DE BRAZO

Cusco,febrero del 2017

La cinemática directa de tres brazos robóticos sencillos, de 1, 2 y 3 grados

instalación de octave en Ubuntu

sudo apt-get install octave3.2

Robot con un grado de libertad

Sólo es necesario usar una transformación homogénea determinada por una

Fig 1: Cinemática del robot 1

En la Figura 1 se muestra la geometría del robot y la nomenclatura empleada

Un brazo robot de 2 grados de libertad

Las dos matrices de transformación son:

Fig 3: Cinemática del robot 2

la Figura 3 se muestra la geometría del robot y la nomenclatura empleada para

Robot con 2 grados de libertad para posicionamiento del manipulador y 1

La nueva matriz de transformación es:

Fig 4: Cinemática del robot

la Figura 4 se muestra la geometría del robot y la nomenclatura empleada para

Las matrices de transformación homogéneas son:

donde las matrices Rotx y Trasy son las mismas

Fig 6: Cinemática del Robot 3

¿Que es un Aceleró metro?

Un aceleró metro es un es un tipo de sensor analógico transductor que

detecta el movimiento o el giro, es decir, es capaz de responder con una

señal eléctrica ante una perturbación inducida por la aplicación de una

fuerza o la gravedad. Este dispositivo es capaz de detectar si está en

horizontal o vertical o por ejemplo si los agitamos en el aire.

acelerómetro de 3 ejes ADXL335 con Arduino

sensor de alta calidad que incluye unos condensadores de desacoplo en la

placa para su óptimo funcionamiento y que ya viene preparado para usarse en

cualquier tipo de proyecto con microcontroladores incluyendo proyectos de

Este acelerómetro devuelve una tensión proporcional a la aceleración

detectada por el sensor, con lo que podemos interpretar las señales

fácilmente con Arduino o con nuestro microcontrolador favorito mediante los

sensor van conectados a los pines A1, A2 y A3 del Arduino respectivamente, y

con esto, ya lo tenemos todo preparado para subir el sketch de prueba.

El ADXL335 proporcionará a Arduino, tres voltajes proporcionales a la

aceleración de cada eje X, Y y Z. Algo muy importante es que se trata de un

conectarlo a nuestro Arduino de no hacerlo a la salida de 5v, ya que

Si giramos alrededor de un eje del acelerómetro no nos variará la medida,

esto no lo mide el acelerómetro, los giros los mide el giroscopio. Si

combinamos un acelerómetro de 3 ejes con un giroscopio de tres ejes tendremos

perfectamente definida la orientación de el objeto en el espacio y respecto

del espacio (tendríamos un IMU de 6 ejes). Si le añadimos además una brújula

digital o magnetometro de 3 ejes, también tendremos la orientación respecto a

saltaríamos al gps, altímetro. Etc

Pro Micro arduino

En concreto cuenta con 18 pines para datos y se configura según la función

que deseemos como se ve en la siguiente imagen cuenta con 18 salidas/entradas

Las cuales 5 tienen función PWM, 9 funcionan también como entradas

ISP. Es decir, tiene de todo

Simulink 3D Animation Viewer

//Analog read pins

const int xPin = 0;

const int yPin = 1;

const int zPin = 2;

//The minimum and maximum values that came from

//the accelerometer while standing still

//You very well may need to change these

int minVal = 275;

int maxVal = 414;