\documentclass[12pt,oneside,reqno]{report}	%reqno permite enumerar la ecuación a la derecha.
\usepackage[left=2.5cm,top=2cm,right=2.5cm,bottom=2cm]{geometry}	%Paquete para editar tamaño de encabezado, pie de página y márgenes.
\usepackage[utf8]{inputenc}
\renewcommand{\rmdefault}{phv} % Arial
\renewcommand{\sfdefault}{phv} % Arial
\usepackage[spanish,english]{babel}	%Paquete para realizar la compilación del formato en otros idiomas.
\usepackage{graphicx}		%Paquete para inserción y modificación de imágenes.
\usepackage{hyperref}		%Paquete para inserción de hipervínculos.
\usepackage{t1enc}
\usepackage{rotating}
\usepackage{array}
\usepackage{fancyhdr}
\usepackage{url}
\usepackage[compact]{titlesec}
\usepackage{times}
\usepackage{pdfpages}		%Paquete para añadir PDFs.
\usepackage{amsmath}		%Paquete para introducción de matrices.

\newcommand{\degree}{\ensuremath{^\circ}}	%Este comando permite añadir grados Celsius tecleando \degree.

%******************Elimina la palabra CHAPTER/CAPÍTULO del encabezado.*****************
\makeatletter
\def\@makechapterhead#1{%
  \vspace*{50\p@}%
  {\parindent \z@ \raggedright \normalfont
    \interlinepenalty\@M
    \Huge\bfseries  \thechapter.\quad #1\par\nobreak
    \vskip 40\p@
  }}
\makeatother
%**************************************************************************************


%******************************Paquete para hipervínculos******************************
\usepackage{xcolor}
\definecolor{dark-red}{rgb}{0.4,0.15,0.15}
\definecolor{dark-blue}{rgb}{0.15,0.15,0.4}
\definecolor{medium-blue}{rgb}{0,0,0.5}
\hypersetup{
    colorlinks, linkcolor={dark-red},
    citecolor={dark-blue}, urlcolor={medium-blue}
}
%**************************************************************************************


%************************Paquetes para elaboracion del apendice.***********************
\usepackage[page,header]{appendix}
\usepackage{titletoc}
%**************************************************************************************

\usepackage{color}
\definecolor{gray97}{gray}{.97}
\definecolor{gray75}{gray}{.75}
\definecolor{gray45}{gray}{.45}

%**************************************Paquete para introducir código fuente********************************************
\usepackage{listings}
\lstset{ frame=Ltb,
     framerule=0pt,
     aboveskip=0.5cm,
     framextopmargin=3pt,
     framexbottommargin=3pt,
     framexleftmargin=0.4cm,
     framesep=0pt,
     rulesep=.4pt,
     backgroundcolor=\color{gray97},
     rulesepcolor=\color{black},
     %
     stringstyle=\ttfamily,
     showstringspaces = false,
     basicstyle=\small\ttfamily,
     commentstyle=\color{gray45},
     keywordstyle=\bfseries,
     %
     numbers=left,
     numbersep=15pt,
     numberstyle=\tiny,
     numberfirstline = false,
     breaklines=true,
   }
 
% minimizar fragmentado de listados
\lstnewenvironment{listing}[1][]
   {\lstset{#1}\pagebreak[0]}{\pagebreak[0]}
 
\lstdefinestyle{consola}	%Se define el estilo consola.
   {basicstyle=\scriptsize\bf\ttfamily,
    backgroundcolor=\color{gray75},
   }
 
\lstdefinestyle{C}		%Se define el estilo para lenguaje C.
   {language=C,
   }
%*********************************************************************************************************************************


\usepackage{fancyhdr}
\pagestyle{fancyplain}
\usepackage{lipsum}          % body text

\usepackage{layout}          % display page dimensions
%\AtBeginDocument{\layout*}  % uncomment this line *OR*
\geometry{showframe=false}    % uncomment this line (best if not both)

%***********************************Redefine el abstract para poder usar 2 en una misma página**********************************
\makeatletter
\if@titlepage
  \renewenvironment{abstract}{%
      \thispagestyle{empty}
      \setcounter{page}{0}
      \null\vfil
      \@beginparpenalty\@lowpenalty
      \begin{center}%
        \bfseries \abstractname
        \@endparpenalty\@M
      \end{center}}%
     {\par\vfil\null}
\else
  \renewenvironment{abstract}{%
      \if@twocolumn
        \section*{\abstractname}%
      \else
        \small
        \begin{center}%
          {\bfseries \abstractname\vspace{-.5em}\vspace{\z@}}%
        \end{center}%
        \quotation
      \fi}
      {\if@twocolumn\else\endquotation\fi}
\fi
\makeatother
%****************************************************************************************************************************

\begin{document}\thispagestyle{empty}
\setlength{\unitlength}{1.1 cm} %Especificar unidad de trabajo
\begin{picture}(18,4)
\put(0,0){\includegraphics[width=3cm,height=3cm]{LogoUPV}}
\put(11.5,0){\includegraphics[width=3cm,height=3cm]{LogoPolis.png}}\end{picture}
\\
\\
\begin{center}
\selectlanguage{spanish}
\textbf{{\Large DISEÑO, ELABORACIÓN Y CONTROL DE UN BRAZO DE DOS GRADOS DE LIBERTAD}}\\[0.5cm]
{{\LARGE Reporte de proyecto}}\\[0.5cm]
%{\Large Asignatura: Dinámica y control de robots}\\[1cm]
{{\LARGE Dinámica y control de robots}}\\[0.5cm]
{\Large Asesores: }\\%[0.5cm]
\begin{itemize}
 \item Dr. Martín Hernández Ordoñez
 \item Dr. Roger Miranda Colorado
\end{itemize}

{\Large Integrantes:}\\
\begin{itemize}
 \item Arias Lopez Fernando 
 \item Banda Porras Marco Antonio
 \item Becerra Reyna Edgar Isauro
 \item Farías Chávez Gilberto
 \item Guzmán Garza Alan Emmanuel
 \item Ledezma Silva Aldo
 \item Martínez Sánchez Ruben
 \item Palacios Mendoza Gabriel
 \item Pérez Segura Eva Karina
 \item Ramírez suárez Ángel Arturo 
 \end{itemize}

{\large Ingeniería Mecatrónica}\\[0.5cm]
{\large Fecha: \today}\\[0.5cm]
Ciudad Victoria, Tamaulipas. %- \today
\end{center}

%************************THIS IS THE INDEX*******************************
\tableofcontents
%************************************************************************

%************************THIS IS THE ABSTRACT****************************
 \newpage
 \selectlanguage{english}
  \begin{abstract}
    In the following document we explain in detail the analysis and development of a multipurpose service robot starting with the
    mechanical aspects of the device, followed by the electronics and finally the programming and control algorithms employed.
  \end{abstract}
  
 \selectlanguage{spanish}
\begin{abstract}
    En este documento se presenta el análisis cinemático y dinámico de un robot de servicio
    multipropósito,los aspectos mecánicos del dispositivo, seguido de la electrónica empleada y finalmente los algoritmos de
    control y demás aplicaciones elaboradas.
  \end{abstract}
  \newpage
%************************************************************************

%\chapter{Sumario.}

%\chapter{Preface.}

%\chapter{Agradecimientos.}

%\chapter{INTRODUCCIÓN.}


%\chapter{ANTECEDENTES.}

%\chapter{ESTADO DEL ARTE.}

\chapter{PROBLEMÁTICA.}
La robótica de servicio en México se encuentra en una etapa de desarrollo inicial, con únicamente algunos sistemas elaborados con
propósito de investigación \cite{Markovito} y la mayor parte de las aplicaciones industriales importadas de otras empresas alemanas
o estadounideneses en su mayoría.\\

El objetivo de la robótica es el sustituir la labor humana en tareas tediosas y peligrosas como la actividad industrial, el trabajo
en situaciones extremas (desastres naturales, condiciones de alta o baja temperatura, ambientes tóxicos o radioactivos) o simplemente
actividades tediosas (operaciones de ensamble, tareas sencillas o del hogar) en las cuales se preferiría el tener un sistema capaz
de realizarlas de forma prolongada y con una alta precisión y exactitud. La tendencia actual es generar robots de asistencia que
sean capaces de asistir en una variedad de tareas al usuario desde actividades del hogar a sociales y como acompañantes, siendo Japón
y Alemania unos de los países líderes en la industria actualmente\cite{AIBO}, \cite{PAPERO}.

\section{Propuesta realizada.}
Se propone la elaboración de un robot de servicio flexible que sea capaz de adaptar su estructura mecánica y algoritmos de control
para realizar una amplia gama de actividades de asistencia al usuario como actividades de rescate, asistencia en el hogar, limpieza,
manipulación y transporte de elementos y dispositivos varios, cuidado de menores de edad y personas con capacidades especiales o
adultos mayores entre muchas otras.\\

Para ello se pretende desarrollar una base de control que permita el añadir y modificar los componentes estructurales y actuadores
en base a esta tarea con un circuito electrónico que sea capaz de alimentar y controlar la diversa gama de actuadores deseados. Entre
los elementos que se pretende desarrollar son distintos tipos de llantas y unidades de desplazamiento además de sistemas de
actuadores multiherramienta (brazos, herramienta, etc.) que puedan ser implementados de manera fácil y rápida requiriendo una
instalación mínima.\\

Se decidió realizar el análisis cinemático y dinámico de la estructura robótica movil y el manipulador de manera
separada debido a la complejidad que implica el análisis de la estructura en su totalidad, de forma que es posible controlar la 
navegación y el manipulador de manera independiente, partiendo además de la premisa de realizar la manipulación cuando el navegador 
se encuentra en estado estático, lo cual implica que será posible considerarlo como una base fija.

\section{Objetivo general.}
Desarrollar una plataforma robótica de servicio de propósito general capaz de realizar una serie de actividades y permitir la
reprogramación y reconfiguración de la misma.

\subsection{Objetivos específicos.}
\begin{itemize}
 \item Elaborar una base robótica móvil estándar y adaptable a una gran variedad de actividades.
 \item Desarrollar la aplicación de control (framework) encargada de coordinar el resto de las aplicaciones robóticas a través de
 aplicaciones libres y abiertas. En este caso se ha seleccionado Python como el lenguaje de preferencia.
 \item Establecer un sistema de comunicación tipo Cliente/Servidor que permita comunicar y controlar la plataforma robótica a 
 distancia empleando una gran variedad de dispositivos móviles.
 \item Desarrollar un manipulador y el torso del robot empleando análisis cinemático y dinámico para calcular el efecto de la carga
 estructural y efectos durante el movimiento del manipulador con y sin carga.
 \item Crear los algoritmos de reconocimiento en base a los sensores establecidos en el sistema robótico.
 \item Programar el sistema de control para el brazo del manipulador en base a los cálculos cinemáticos y dinámicos realizados.
 \item Diseñar y construir mecanismos y dispositivos aplicables en la plataforma móvil.
\end{itemize}

\chapter{METODOLOGÍA.}
Para el desarrollo del sistema aquí presentado se requirió hacer uso del método analítico en la etapa de diseño para generar una
configuración óptima para la tarea deseada para el robot a través de los conocimientos adquiridos en las asignaturas de estática,
dinámica, control clásico, cinemática y dinámica y control de robots en las cuales se requiere considerar diversas variables que
impactan directamente en el desempeño de la estructura como es el caso de momentos y esfuerzos inherentes al movimiento de las cargas
tanto de los eslabones y elementos que conforman el sistema robótico, como de fuerzas y pares generados por efecto de factores
externos provenientes del entorno tales como la fuerza gravitatoria, fricción, efecto de impulso producto del entorno convectivo o
de fuerzas que interactúan con el sistema, o producto de la interacción del sistema mismo con el entorno durante la modificación o
manipulación del mismo.\\

Durante la etapa de análisis se generaron las ecuaciones necesarias para predecir el comportamiento estático y dinámico del robot,
esto es, durante un estado estable y en transitorio al realizar operaciones además de un diseño utilizando una aplicación de diseño
industrial, en este caso, SolidWorks2013 que permite facilitar y realizar una serie de pruebas sobre la estructura.\\

Finalizada la etapa de análisis y diseño se procedió a la elaboración del dispositivo, con lo cual se genera la estructura y se
fabrican los circuitos de potencia encargados de impulsar los actuadores que permitirán el movimiento de todas las juntas y partes
móviles del robot. Durante esta etapa se hizo uso de sistemas de potencia tales como transistores de tipo CMOS, los cuales permiten
controlar grandes cargas de alta potencia a través de señales de voltaje de baja potencia.\\

Hecho ésto, se procedió a generar los algoritmos de control del sistema, tanto para el brazo manipulador como para el robot como una
entidad integral. Para ello se ha hecho uso de diversos lenguajes especializados para cada uno de los módulos del mismo.

\chapter{DESARROLLO.}
\section{Análisis mecánico.}
Antes de la construcción del prototipo funcional del robot de servicio fue necesario realizar un análisis previo de los componentes
mecánicos para seleccionar los componentes adecuados para la estructura y optimizar el diseño del robot. De esta forma se vuelve
posible conseguir un diseño más eficaz para realizar las tareas para las cuales fué elaborado y más eficiente al disminuir la cantidad
de recursos necesarios para su construcción.\\

Para realizar los análisis requeridos se hizo uso de dos métodos:

\begin{itemize}
 \item Método analítico.\\ Se realizaron las ecuaciones necesarias para la resolución de los problemas utilizando los principios de
 \textbf{diseño mecánico}, \textbf{análisis cinemático} y \textbf{análisis dinámico} de las estructuras haciendo uso de aplicaciones
 de computación científica como \textbf{Matlab} como apoyo para la resolución de las ecuaciones.
 \item Método de ingeniería asistida por computadora.\\ Se elaboró un modelo del sistema en una aplicación de diseño industrial, siendo
 en este caso \textbf{SolidWorks 2013}, en la cual se puede visualizar el sistema y realizar simulaciones y análisis del comportamiento
 de éste ante diversas y complejas condiciones de forma rápida y sencilla.
\end{itemize}

\subsubsection{SolidWorks 2013}.
%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.6]{Images/SolidWorks2013-Logo}
  \caption{Logotipo de SolidWorks 2013.}
  \label{SolidWorks2013-Logo}
 \end{center}
\end{figure}
%**************************************************************************************

SolidWorks 2013 es un conjunto de módulos integrados para ingeniería asistida por computadora desarrollados por Dassault Systemes
para el diseño y análisis de esfuerzos de productos en el área mecánica, además de ser compatible con aplicaciones de manufactura
industrial como tornos y fresadoras CNC \cite{SolidWorks2013}.\\

Debido a la complejidad del brazo manipulador se realizó una sección separada dedicada exclusivamente a su diseño y elaboración
además de una sección dedicada al análisis mecánico del sistema del navegador donde se analiza el robot como una entidad completa y
en la cual se cuenta el brazo como un cuerpo móvil de éste.

\newpage
\subsection{Brazo manipulador.}
Un brazo manipulador consiste en una serie de vínculos casi rígidos conocidos como \textbf{eslabones} que se encuentran enlazados a
través de articulaciones conocidas como \textbf{juntas} que permiten el movimiento relativo de los vínculos adyacentes. Estas
articulaciones generalmente se instrumentan con sensores de posición que permiten medir la posición relativa de los vínculos
adyacentes.\\

Existen diversos tipos de juntas, clasificándose principalmente en \textbf{prismáticas} y \textbf{rotacionales.} Las juntas 
prismáticas permiten un desplazamiento lineal con respecto a un eje de referencia mientras que las juntas rotacionales permiten
obtener un desplazamiento angular. \cite{Craig}\\

Para el robot elaborado se hizo uso de juntas rotacionales debido a que éstas permiten un mayor espacio de trabajo como se ha
comprobado de forma teórica en \cite{Craig} y \cite{Spong}.

\subsubsection{Cinemática directa del manipulador.}
Para obtener la cinemática directa del manipulador se hizo uso de la convención de Denavit-Hartenberg que permitió establecer los
sistemas de referencia a través de los cuales se identifica el conjunto de ángulos y longitudes en el manipulador.

\begin{enumerate}
 \item Se dibujó la estructura de acuerdo a la simbología convencional para identificar las juntas rotacionales y prismáticas en la
 estructura.
 
 \item Posteriormente se establecieron los orígenes en cada una de las juntas iniciando desde la base del sistema manipulador, la
 cual se identificó como 0, hasta n siendo n-1 el número de grados de libertad que posee la estructura.
 
 \item Se identificó el eje de acción sobre el cual giran las juntas de tipo rotacional que se encuentran en el manipulador y se
 estableció el \textbf{eje z} en éstas de acuerdo a la convención.
 
 \item Siguiendo la regla de la mano derecha se estableció x partiendo perpendicular al eje z desde el eslabón $n_i$ hasta $n_{i-1}$
 para cada uno de los eslabones del manipulador.
 
 \item Se estableció y siguiendo la convención.
 
 \item Se generó una tabla de parámetros de las juntas de acuerdo a lo establecido en la convención.
 
 \begin{center}
  \begin{tabular}{||l|c|c|c|c||}
  \hline
  \hline
   i & $\theta_i$ & $\alpha_{i-1}$ & $d_i$ & $a_{i-1}$\\
   \hline
   1 & $\theta_1$ & 0 & 0 & 0\\
   \hline
   2 & $\theta_2$ & -90\degree & 0 & 0\\
   \hline
   e & 0 & 0 & $L_e$ & 0\\
   \hline
   \hline
  \end{tabular}
 \end{center}
 
 \item Se generan las matrices de transformación homogénea de acuerdo a la fórmula general:
 
 \begin{equation}
{ T }_{ i }^{ i-1 }=\begin{bmatrix} { c }_{ \theta  } & -{ s }_{ \theta  } & 0 & { a }_{ i-1 } \\ { c }_{ \theta i }{ s }_{ \alpha i } & { c }_{ \theta  }{ c }_{ \alpha i } & -{ s }_{ \alpha i-1 } & { -d }_{ i }{ s }_{ \alpha i-1 } \\ { s }_{ \theta  }{ s }_{ \alpha i } & { s }_{ \theta  }{ c }_{ \alpha i-1 } & { c }_{ \alpha i-1 } & { d }_{ i }{ c }_{ \alpha i-1 } \\ 0 & 0 & 0 & 1 \end{bmatrix}  
 \end{equation}

 \item Las matrices de transformación homogéneas obtenidas son:
 
 $${ T }_{ 1 }^{ 0 }=\begin{bmatrix} { c }_{ 1 } & -{ s }_{ 1 } & 0 & 0 \\ { s }_{ 1 } & { c }_{ 1 } & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}$$
 
 $${ T }_{ 2 }^{ 1 }=\begin{bmatrix} { c }_{ 2 } & { -s }_{ 2 } & 0 & 0 \\ 0 & 0 & 1 & 0 \\ { -s }_{ 2 } & { -c }_{ 2 } & 0 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}$$
 
 $${ T }_{ e }^{ 2 }=\begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & { L }_{ e } \\ 0 & 0 & 0 & 1 \end{bmatrix}$$
 
 \item Se obtienen las matrices de transformación homogénea con respecto al orígen utilizando Matlab, las cuales pueden verse en
 las figuras \ref{T20} y \ref{Te0}.
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/1}
   \label{T20}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/2}
   \label{Te0}
  \end{center}
 \end{figure}
\end{enumerate}

\newpage
\subsubsection{Análisis dinámico del brazo manipulador.}
La dinámica es la ciencia encargada del análisis de los cuerpos mecánicos en movimiento y cómo las fuerzas interactúan con cada uno
de los elementos de éste.\\

Es utilizado para el control acoplado en el cual se considera el efecto que tienen las fuerzas del resto de los eslabones desde el
efector final y cómo se propagan desde éste hacia la base y viceversa. Una de las técnicas más utilizadas que hace uso de este tipo
de modelo dinámico es el control por par calculado, mediante el cual es posible calcular la velocidad, par torsor y aceleración
necesarios para que el robot sea capaz de seguir una trayectoria determinada.\\[0.5cm]

\textbf{Método de Newton-Euler.}
El método de Newton-Euler es un método desarrollado para calcular de manera iterativa las ecuaciones dinámicas que definen un
sistema determinado. Para ello se calculan los efectos de las fuerzas desde la base hacia el efector final y posteriormente la
retropropagación de dichas fuerzas a través de cada uno de los eslabones hacia la base.\\

Para ello se hace uso de una serie de ecuaciones bien definidas, comenzando con las iteraciones externas que pueden observarse a
continuación para el robot especificado:

 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/3}
   \label{NEW1}
  \end{center}
 \end{figure}

 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/4}
   \label{NEW2}
  \end{center}
 \end{figure}

\begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/5}
   \label{NEW3}
  \end{center}
 \end{figure}

\begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/6}
   \label{NEW4}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/7}
   \label{NEW5}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/8}
   \label{NEW5}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/9}
   \label{NEW6}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/10}
   \label{NEW7}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/11}
   \label{NEW8}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/12}
   \label{NEW9}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/13}
   \label{NEW10}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/14}
   \label{NEW11}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/15}
   \label{NEW12}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/16}
   \label{NEW13}
  \end{center}
 \end{figure}
 
 \begin{figure}[h!]
  \begin{center}
   \includegraphics[scale = 0.7]{Images/17}
   \label{NEW14}
  \end{center}
 \end{figure}


\subsection{Navegador móvil.}
Se realizó el diseño del navegador móvil haciendo uso de la aplicación para diseño industrial SolidWorks 2013 con el cual se obtuvo
el modelo del sistema como se observa en la figura \ref{SerbotIII_v3} y \ref{SerbotIII_v6} respectivamente.

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.4]{Images/SerbotIII_v3}
  \caption{Diseño conceptual del robot de servicio utilizando SolidWorks 2013.}
  \label{SerbotIII_v3}
 \end{center}
\end{figure}
%**************************************************************************************

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.4]{Images/SerbotIII_v6}
  \caption{Diseño conceptual del robot de servicio utilizando SolidWorks 2013.}
  \label{SerbotIII_v6}
 \end{center}
\end{figure}
%**************************************************************************************

Se obtuvo la cinemática directa del manipulador \cite{Spong} y se generaron las siguientes matrices de transformación homogéneas
teniendo en cuenta la consideración actual de que el sistema del manipulador se encuentra fijo a una base que no cambia su posición
en el espacio.

\begin{equation}
 T^1_0
\end{equation}


\newpage
\section{Programación y control.}
\subsection{Comunicación por red.}
La selección de la arquitectura del sistema de información y control del robot representa un factor clave en las limitaciones de
sus capacidades operativas y que resulta influenciado principalmente por los recursos disponibles para la elaboración del dispositivo.

Gran parte de los sistemas robóticos actuales hacen uso de una arquitectura integrada en embebidos, ya sea a través del uso de
microprocesadores y microcontroladores integrados en un sistema de control unificado o a través de la inclusión de computadoras
integradas en el robot que les permiten realizar tareas de procesamiento mucho más complejas. En general los robots suelen incorporar
las computadoras en aplicaciones más complejas y para las cuales las capacidades de un circuito integrado resultarían insuficientes,
lo cual sin embargo añade un mayor peso y dimensiones a la estructura.

En años recientes y con la mayor presencia de las redes de comunicaciones inalámbricas, particularmente de protocolos estandarizados
como es el caso del protocolo WiFi o el protocolo TCP/IP que permiten a los sistemas el comunicar instrucciones complejas y que ha
sido implementado de manera intensiva en aplicaciones de automatización industriales y de domótica.

Estas tecnologías pueden ser utilizadas en lo sistemas robóticos para permitir entre otras cosas, el enviar comandos a un sistema
robótico con acceso a la red y que puede ser controlado sin importar su localización. Esto además puede ser aprovechado para lograr
reducir las necesidades computacionales de los sistemas robóticos y mecatrónicos elaborados al convertir el sistema robótico en un
cliente más de una red de computadoras y desplazando las necesidades de computación intensiva a un servidor de alta capacidad cuya
localización es de poca importancia para el desarrollador.

Utilizando esta arquitectura se vuelve posible el contar con uno o más clientes que envíen órdenes y monitoreen el estado del sistema
robótico a distancia haciendo las peticiones al servidor, el cual se encarga de realizar al computación y algoritmos de control
necesarios y enviar únicamente el resultado ya procesado al sistema robótico para que realice la acción solicitada. De manera inversa
es posible lograr que el robot envíe los datos de manera cruda al servidor, el cual se encarga de interpretar la información y
convertirla en una forma útil al usuario sin requerir ciclos de procesamiento por parte del robot para obtener el resultado, lo cual
libera al sistema de recursos que pueden ser destinados a otras tareas.

\subsubsection{Python.}

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.6]{Images/PyLogo}
  \caption{Logo del lenguaje interpretado Python.}
  \label{PythonLOGO}
 \end{center}
\end{figure}
%**************************************************************************************

Python es un lenguaje de programación interpretado de propósito general, lo cual significa que es ejecutado línea por línea al ser
llamado a diferencia de lenguajes compilados como C y Java que generan un ejecutable, lo cual permite que Python pueda ser utilizado
para realizar pruebas de prototipado rápidas \cite{Python}.

El lenguaje es capaz de soportar programación estructurada, programación orientada a objetos, programación funcional, entre muchas
otras y al ser un lenguaje libre y abierto con una comunidad de desarrolladores muy activa, constantemente se realizan mejoras y se
liberan librerías que extienden la funcionalidad de este lenguaje.

En el proyecto del robot de servicio se buscó que Python fuera implementado como lenguaje principal de manejo de control del robot,
además de implementarlo en conjunción de la librería Tornado para la comunicación del sistema robótico con un servidor web a través
del cual se coordinan las actividades del robot y con ello se permite funcionalidades de telepresencia.

\subsubsection{Tornado.}

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.6]{Images/TornadoLogo}
  \caption{Logo de la librería para operaciones servidor/cliente Tornado.}
  \label{TornadoLOGO}
 \end{center}
\end{figure}
%**************************************************************************************

Tornado \cite{OReillyTornado}.

\subsubsection{KineticJS.}

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.6]{Images/KineticJS}
  \caption{Logo de la plataforma de desarrollo KineticJS.}
  \label{KineticJSLOGO}
 \end{center}
\end{figure}
%**************************************************************************************

KineticJS es un framework (TRADUCCION) elaborado en JavaScript para la estructura Canvas de HTML5 que permite la elaboración de
animaciones de alto desempeño, transiciones, gestión de nodos, capas, filtrado, almacenamiento en caché, manejo de eventos para
aplicaciones de escritorio y móviles entre muchas otras características \cite{KineticJS}.\\

De creación relativamente reciente al igual que el protocolo HTML5, permite la generación de contenido dinámico en las páginas Web
de manera sencilla y rápida utilizando un paradigma orientado a objetos en el cual cada elemento de la aplicación representa una
entidad con atributos y métodos propios.

\newpage
\subsection{Visión computacional.}
Uno de los objetivos más importantes para los robots de servicio consiste en dotarlos de la capacidad de reconocer su entorno y ser
capaces de realizar un ``mapeo'' del área de trabajo en la cual se desempeñan de manera que sean capaces de reconocer y evadir los
obstáculos que se presenten durante la navegación, sean capaces de buscar y transportar objetos solicitados por el usuario, además
de reconocer y diferenciar entre distintas personas con las cuales interactuará el dispositivo.\\

Para lograr todas estas tareas se requiere contar con sensores que permitan al robot el visualizar su entorno como suelen ser
videocámaras y sensores de presencia o distancia, y en los diseños más avanzados, lásers que permitan diferenciar con precisión la
profundidad y las texturas de objetos en el espacio.\\

Antiguamente el contar con este tipo de sistemas implicaba un alto costo, particularmente en aquellas aplicaciones que han hecho uso
de sistemas de detección por láser de alta calidad, los cuales llegan a tener costos desde $\$90,000.00$ o más. En la actualidad,
gracias a la investigación realizada en tecnología de visión y sensores para la industria de los videojuegos, se ha logrado generar
sistemas integrales de sensores relativamente compactos y económicos, de los cuales se destaca el MS Kinect \cite{MS Kinect}, 
creado por la empresa PrimeSense para la compañía Microsoft como una interfaz visual entre el usuario y la consola de videojuegos
X-Box.

\subsubsection{MS Kinect.}
%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.6]{Images/MS-Kinect}
  \caption{Dispositivo interfaz Microsoft Kinect.}
  \label{MS-Kinect}
 \end{center}
\end{figure}
%**************************************************************************************

El sistema MS Kinect es una interfaz de desarrollo visual cuyo propósito original consistió en un dispositivo capaz de optimizar la
experiencia del usuario en videojuegos al permitir una interacción más natural con el ambiente mediante algoritmos capaces de
reconocer al usuario y permitirle interactuar con la realidad virtual generada por los videojuegos.\\

Este dispositivo sin embargo, vió un uso más práctico en el área de robótica debido a la enorme cantidad de prestaciones que es
capaz de proveer en un empaque compacto y económico, permitiendo al robot obtener datos confiables del entorno con mayor facilidad.
\\

Entre las prestaciones que provee el dispositivo MS Kinect se encuentran \cite{KinectSpec}:
\begin{itemize}
 \item Cámara RGB con tres canales de datos en una resolución de 1280x960 pixeles.
 \item Emisor y receptor infrarrojo para la detección de profundidad.
 \item Arreglo de cuatro micrófonos para captura de audio y localización de la fuente de origen del sonido.
 \item Acelerómetro de tres ejes para el reconocimiento de la inclinación del dispositivo.
 \item Motor para control de un grado de libertad del dispositivo.
\end{itemize}

\subsubsection{Libfreenect.}

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.8]{Images/OpenK}
  \caption{Logo de la comunidad de software libre OpenKinect.}
  \label{OpenK}
 \end{center}
\end{figure}
%**************************************************************************************

La librería libfreenect comenzó como un esfuerzo conjunto por la comunidad hacker y la organización Adafruit para comunicar el
dispositivo MS Kinect de la empresa Microsoft con la computadora debido a que éste fué diseñado con fines de entretenimiento, 
estando la empresa originalmente en contra de que su dispositivo fuera modificado. Haciendo caso omiso a ésto y a través de una
competencia establecida por la empresa Adafruit se ofreció entregar $\$3,000.00$ dólares a aquél que lograse comunicar el MS Kinect
con cualquier sistema operativo, generándose una carrera entre los mejores hackers por lograrlo mediante ingeniería inversa. 
El hacker Héctor Martín logró realizarlo y obtuvo el premio, liberando además su código para que fuera utilizado por toda la 
comunidad de software libre.\\

Así inició la comunidad OpenKinect, la cual desarrolló en base al código liberado por Héctor la librería \textit{libfreenect} que
permite reconocer y accesar cada uno de los elementos provistos por el MS Kinect a bajo nivel utilizando el lenguaje C. En la 
actualidad se han generado wrappers para otros lenguajes y ahora es posible utilizar la librería desde Python, Java, entre muchos
otros \cite{LibfreenectStory}.

\newpage
\subsection{Etapa de control.}
\subsubsection{Arduino 2560.}

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
%  \includegraphics[scale=0.6]{Images/Mega}
  \caption{Placa del Arduino Mega 2560.}
  \label{Mega2560}
 \end{center}
\end{figure}
%**************************************************************************************

El Arduino Mega 2560 es una tarjeta microcontroladora basada en el ATMega 2560. Posee 54 pines de entrada/salida digitales con 15 que
pueden ser utilizados como salida PWM, 16 entradas analógicas, 4 UARTs, un oscilador de cristal de 16MHz, conexión USB y botón de
reset.

Características de operación\cite{Mega}:\\
\begin{center}
%******************************Para hacer tablas***************************************
\begin{tabular}{||l|c||}
\hline
\hline
 Voltaje de operación & 5 volts\\
 \hline
 Voltaje de entrada & 7 a 12 volts\\
 \hline
 Pines de entrada/salida digitales & 54 con 15 de salida PWM\\
 \hline
 Pines de entrada analógica & 16\\
 \hline
 Corriente directa por pin & 40mA\\
 \hline
 Corriente directa para pin de 3.3 volts & 50mA\\
 \hline
 Memoria flash & 256kB (8 utilizados por el bootloader).\\
 \hline
 SRAM & 8kB\\
 \hline
 EEPROM & 4kB\\
 \hline
 Reloj & 16MHz\\
\hline
\hline
\end{tabular}
\end{center}
%**************************************************************************************

La plataforma es ampliamente desarrollada y posee una comunidad de desarrolladores libres que permiten que la plataforma posea una
amplia conectividad y acceso a librerías especializadas lo cual lo vuelven una solución de desarrollo ideal para el prototipado.

\section{Electrónica.}
\subsection{Etapa de potencia.}
\subsubsection{L298N.}

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
%  \includegraphics[scale=0.6]{Images/L298}
  \caption{Integrado para control de motores L298N.}
  \label{L298}
 \end{center}
\end{figure}
%**************************************************************************************

El integrado utilizado para el control del motor de corriente directa del navegador es el modelo L298N el cual es un integrado altamente
utilizado para aplicaciones con requerimientos de corriente de hasta 2 Amperes en estado estable y 2.5 a 3 Amperes en etapa de
transitorio.

Los pines del integrado poseen la siguiente configuración:
%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.6]{Images/L298N}
  \caption{Pines del integrado L298N.}
  \label{L298N}
 \end{center}
\end{figure}
%**************************************************************************************

\subsection{Sensores.}
\subsubsection{Codificador óptico.}
Para realizar el control a través de odometría y la retroalimentación por medio de la cinemática y dinámica inversas del brazo
manipulador se hace uso de dispositivos electrónicos conocidos como codificadores ópticos, los cuales consisten en una serie de
discos acoplados a las flechas de giro del motor o a dispositivos o mecanismos encargados de transmitir el movimiento de éstas (
cadenas, engranes, etc.) y entregar una medida del desplazamiento en un formato específico que pueda ser utilizado por el sistema
para determinar su posición y otras variables de interés como velocidad y aceleración.

Para esta operación se ha seleccionado el uso de codificadores ópticos debido a su alta confiabilidad y facilidad de uso.

%En el apéndice B se ilustran los esquemas de conexión del sistema de control con la etapa de potencia hacia los motores.


%\chapter{RESULTADOS.}
%\section{Experimentación.}

\chapter{CONCLUSIONES.}
A través del desarrollo de este sistema fue posible poner en práctica todo el conjunto de conocimientos adquiridos durante la
carrera de Ingeniería Mecatrónica además de permitir observar la forma en que se vuelve posible integrar distintas tecnologías para
generar un sistema integral reprogramable para realizar una serie de tareas específicas.\\

Se elaboró el análisis cinemático y dinámico de un sistema de dos grados de libertad con el propósito de utilizarlo como base para
el control desacoplado y posterior avance hacia controles acoplados que consideren el efecto de los eslabones en la estructura y
calcular las fuerzas y pares necesarios para desplazar el brazo manipulador hacia una trayectoria especificada.\\

%*************************************************El apéndice*********************************************************
%Aquí se introducen códigos, circuitos o ecuaciones relacionadas con el tema que no tengan cabida en el desarrollo.
\begin{appendix}
 \appendix
 \chapter{Códigos del framework KineticJS.}
 \section{Declaración de entidades utilizando KineticJS.}
 A continuación se presenta un ejemplo sencillo del uso de la plataforma KineticJS en el cual se declara una nueva capa de trabajo
 para KineticJS y se genera una entidad llamada círculo que permite la creación de un círculo rojo con contorno negro en el navegador
 web empleando únicamente KineticJS.
 
 \subsection{Instrucciones.}
 \begin{enumerate}
  \item Generar un nuevo archivo en un procesador de textos, en este caso se hizo uso del editor libre \textbf{Sublime Text 2} en el
  sistema operativo Ubuntu Linux tal y como se observa en la figura \ref{SublimeKinetic1}.
  
  %******************************Para insertar imágenes**********************************
  \begin{figure}[h!]
  \begin{center}
  \includegraphics[scale=0.5]{Images/SublimeKinetic1}
  \caption{Creación de un nuevo archivo de texto en Sublime Text 2.}
  \label{SublimeKinetic1}
  \end{center}
  \end{figure}
  %**************************************************************************************

 \item Se introduce el código presentado en \ref{KineticJS-Code1} en el archivo y se guarda en formato .html.
 
 \item Se abre el navegador y se observa el resultado. \textbf{NOTA: } Debido a la forma en que el código adquiere los archivos de
 KineticJS se vuelve absolutamente necesario que se cuente con una conexión a Internet. En caso contrario el documento aparecerá en
 blanco. En la figura \ref{KineticJS-Circle1}
 
 %******************************Para insertar imágenes**********************************
  \begin{figure}[h!]
  \begin{center}
  \includegraphics[scale=0.5]{Images/KineticJS-Circle1}
  \caption{Resultado obtenido de la implementación del código en el navegador web Chromium.}
  \label{KineticJS-Circle1}
  \end{center}
  \end{figure}
  %**************************************************************************************
 \end{enumerate}

 \subsection{Código.}
  \begin{lstlisting}
  <!DOCTYPE HTML>
<html>
  <head>
    <style>
      body {
        margin: 0px;
        padding: 0px;
      }
    </style>
  </head>
  <body>
    <div id="container"></div>
    <script src="http://d3lp1msu2r81bx.cloudfront.net/kjs/js/lib/kinetic-v4.7.0.min.js"></script>
    <script defer="defer">

    //********************************************************************************************
    //******************************HERE BEGINS THE KINETICJS CODE.*******************************
    //********************************************************************************************
    //Defines a new KineticJS stage where the animation will be played.
      var stage = new Kinetic.Stage({
        container: 'container',       //It is of type 'container'
        width: 578,                   //Width of 578 pixels.
        height: 200                   //Height of 200 pixels.
      });

      //Defines a new layer that will contain the objets.
      var layer = new Kinetic.Layer();

      //Defines a new circle entity.
      var circle = new Kinetic.Circle({
        x: stage.getWidth() / 2,      //Positioned horizontaly at the middle of the stage.
        y: stage.getHeight() / 2,     //Positioned vertically at the middle of the stage.
        radius: 70,                   //With a radius of 70.
        fill: 'red',                  //Color red.
        stroke: 'black',              //Black contour.
        strokeWidth: 4                //The contour has a width of 4.
      });

      //Adds the shape to the layer
      layer.add(circle);

      //Adds the layer to the stage
      stage.add(layer);
    </script>
  </body>
</html>
 \end{lstlisting}
 \begin{figure}
 \caption{Código empleado para la generación de la figura en KineticJS.}
 \label{KineticJS-Code1}
 \end{figure}

\textbf{Ejemplo tomado de \cite{KineticJS-Ejemplo1}.}
 
 
 \chapter{Códigos del framework Tornado.}
 \section{Estableciendo conexión con un servidor web.}
 El siguiente código entrega una respuesta a una cadena introducida por el usuario en la consola de la terminal.
 
 \begin{enumerate}
  \item Se genera un nuevo archivo de texto. Para este ejemplo se hizo uso del procesador de textos libre \textbf{Sublime Text 2}, el
  cual puede ser inicializado desde terminal tal y como se observa en la figura \ref{SublimeTornado1}
  
   %******************************Para insertar imágenes**********************************
  \begin{figure}[h!]
  \begin{center}
  \includegraphics[scale=0.5]{Images/SublimeKinetic1}
  \caption{Creación de un nuevo archivo de texto en Sublime Text 2.}
  \label{SublimeTornado1}
  \end{center}
  \end{figure}
  %**************************************************************************************
  
  \item Posteriormente se introduce el código que se observa en la figura \ref{Tornado-Code1} y se guarda como Server.py.
  
  \item Se inicializa en la terminal el servidor en Python utilizando el comando:
  
  \begin{lstlisting}
   $ python Server.py --port=8080
  \end{lstlisting}
  
  como se observa en la figura \ref{Tornado1}.
  
  %******************************Para insertar imágenes**********************************
  \begin{figure}[h!]
  \begin{center}
  \includegraphics[scale=0.5]{Images/Tornado1}
  \caption{Inicialización del servidor Tornado en consola.}
  \label{Tornado1}
  \end{center}
  \end{figure}
  %**************************************************************************************

  \item Se abre una segunda terminal de consola y se teclea el comando:
  
  \begin{lstlisting}
   $ curl http://localhost:8000/
  \end{lstlisting}
  
  y se generará una respuesta en la terminal por parte del servidor tal y como se observa en la figura \ref{Tornado2}.
  
  %******************************Para insertar imágenes**********************************
  \begin{figure}[h!]
  \begin{center}
  \includegraphics[scale=0.5]{Images/Tornado2}
  \caption{Respuesta del servidor hacia el dispositivo cliente.}
  \label{Tornado2}
  \end{center}
  \end{figure}
  %**************************************************************************************

  
 \end{enumerate}
 
 \begin{lstlisting}
  import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web

from tornado.options import define, options
define("port", default=8000, help="run on the given port", type=int)
class IndexHandler(tornado.web.RequestHandler):
    def get(self):
        greeting = self.get_argument('greeting', 'Hello')
        self.write(greeting + ', friendly user!')
        
if __name__ == "__main__":
    tornado.options.parse_command_line()
    app = tornado.web.Application(handlers=[(r"/", IndexHandler)])
    http_server = tornado.httpserver.HTTPServer(app)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.instance().start()
 \end{lstlisting}
 \begin{figure}
 \caption{Código empleado para realizar una comunicación cliente-servidor.}
 \label{Tornado-Code1}
 \end{figure}

 \chapter{Elementos del sistema mecánico.}
 \includepdf[pages={1}]{Images/SerbotIII-Concepto.PDF}
 \section{Brazo manipulador.}
 \includepdf[pages={1}]{Images/DCR-Serbot_III-Brazo_manipulador.PDF}
 
 \chapter{Instalación de la librería libfreenect.}
Para la correcta instalación de la librería libfreenect se hizo uso de la compilación manual del código fuente a través de la página
GitHub en la plataforma Ubuntu Linux versión 13.10 (Saucy Salamander).

\section{Herramienta utilizada.}
\begin{itemize}
 \item Computadora personal Lenovo con procesador AMD E-300 APU 32 bits, 128 GB de disco duro y 1.6 GB de memoria RAM.
 \item Sistema operativo Ubuntu Linux 13.10 Saucy Salamander.
 \item Conexión a Internet.
\end{itemize}

\section{Procedimiento \cite{LibfreenectInstall}.}
\begin{itemize}
 \item Instalar las librerías y componentes preliminares mediante el comando:
 
 \begin{lstlisting}[style = consola]
  $ sudo apt-get install git-core cmake libglut3-dev pkg-config build-essential libxmu-dev libxi-dev libusb-1.0-0-dev
  $sudo apt-get install git-core cmake freeglut3-dev pkg-config build-essential libxmu-dev libxi-dev libusb-1.0-0-dev
 \end{lstlisting}
 
 \item Clonar la librería libfreenect en un directorio de instalación. En este caso se clonó en el directorio ~/Programs/
 \begin{lstlisting}[style = consola]
  $ git clone git://github.com/OpenKinect/libfreenect.git
 \end{lstlisting}
 
 \item Ingresar al directorio de la librería.
 \begin{lstlisting}[style = consola]
  $ cd libfreenect
 \end{lstlisting}
 
 \item Generar un directorio en el cual se configurará el código de la librería para el sistema e ingresar al directorio.
 \begin{lstlisting}[style = consola]
  $ mkdir Build
  $ cd Build
 \end{lstlisting}
 
 \item Generar el código, configurar e instalar.
 \begin{lstlisting}[style = consola]
  $ cmake ..
  $ make
  $ sudo make install
  $ sudo ldconfig /usr/local/lib64/
 \end{lstlisting}
 
 \item Para poder utilizar la librería sin tener que ingresar como administrador, añadir el usuario a los permisos de video y 
 copiar el archivo de reglas de libfreeenct al directorio /etc/udev/rules.d.
 \begin{lstlisting}[style = consola]
  $ sudo adduser $USUARIO video
  $ sudo gedit /etc/udev/rules.d/51-kinect.rules
 \end{lstlisting}
 
 \item Copiar el siguiente código y pegarlo en el archivo generado.
 \begin{lstlisting}
  # ATTR{product}=="Xbox NUI Motor"
  SUBSYSTEM=="usb", ATTR{idVendor}=="045e", ATTR{idProduct}=="02b0", MODE="0666"
  # ATTR{product}=="Xbox NUI Audio"
  SUBSYSTEM=="usb", ATTR{idVendor}=="045e", ATTR{idProduct}=="02ad", MODE="0666"
  # ATTR{product}=="Xbox NUI Camera"
  SUBSYSTEM=="usb", ATTR{idVendor}=="045e", ATTR{idProduct}=="02ae", MODE="0666"
 \end{lstlisting}
 
 \item Reiniciar la sesión y ejecutar un ejemplo para ver si funciona correctamente.
 \begin{lstlisting}[style = consola]
  bin/glview
 \end{lstlisting}
\end{itemize}

\chapter{Simulación del brazo robot.}
Para el control del robot se hizo uso del método de control desacoplado en el cual cada una de las juntas del robot contiene un
control independiente del resto y que se encarga de modular los movimientos de la junta sobre la cual actúa sin considerar las
fuerzas y momentos del resto de los eslabones.

Entre las ventajas principales de este tipo de control se encuentra una mayor velocidad de procesamiento debido a que contiene un
número menor de variables y puede considerarse un sistema lineal.

En la figura \ref{PD} se presenta el controlador PD utilizado para regular los movimientos del robot en base a una entrada.

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.5]{Images/PD}
  \caption{Bloque de controlador PD.}
  \label{PD}
 \end{center}
\end{figure}
%**************************************************************************************

Se elaboró el diseño del robot en SolidWorks y se exportó en formato .xml para poder acceder al ensamble en Matlab utilizando el
complemento Simmechanics de Matlab. Mediante este complemento se simuló el comportamiento del robot utilizando el control PD
que aparece en la figura \ref{PD}.

La estructura del robot puede observarse en la figura \ref{ROBOT}.

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.5]{Images/ROBOT}
  \caption{Modelo del robot elaborado en SolidWorks.}
  \label{ROBOT}
 \end{center}
\end{figure}
%**************************************************************************************

Introduciendo una señal de referencia senoidal se obtiene la salida que puede observarse en la figura \ref{GRAPH}.

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.5]{Images/GRAPH}
  \caption{Gráfica del comportamiento del sistema a una señal senoidal.}
  \label{GRAPH}
 \end{center}
\end{figure}
%**************************************************************************************

\chapter{Control PID para robot físico.}
Para el control físico del robot se utilizó de igual forma Simulink en conjunto con el wrapper para Arduino, a través del cual es
posible obtener y emitir señales desde Matlab de acuerdo a los parámetros especificados.

Las constantes utilizadas fueron:
 
 $$K_p = 3$$
 $$K_i = 20$$
 $$K_d = 0.09$$

Correspondientes a las constantes de proporcionalidad que se encarga de añadir más energía al sistema, la constante de integración
y derivación encargadas de regular el sobretiro y tiempo de asentamiento del sistema respectivamente.

En la figura \ref{C1} se puede observar el sistema encargado de controlar el manipulador haciendo uso de la librería Arduino para
Matlab.

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.5]{Images/C1}
  \caption{Control de brazo manipulador en Matlab Simulink.}
  \label{C1}
 \end{center}
\end{figure}
%**************************************************************************************

En la figura \ref{C2} se muestra el control PID que se encuentra en el subsistema control PID.

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.9]{Images/C2}
  \caption{Controlador PID.}
  \label{C2}
 \end{center}
\end{figure}
%**************************************************************************************

En la figura \ref{C3} se observa el acoplamiento del codificador óptico hacia el sistema mediante el cual es posible localizar la
posición de la junta en cada momento determinado recibiendo pulsos.

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.9]{Images/C3}
  \caption{Procesamiento de la señal del codificador óptico.}
  \label{C3}
 \end{center}
\end{figure}
%**************************************************************************************

Finalmente en la figura \ref{C4} se ilustra la salida de Arduino.

%******************************Para insertar imágenes**********************************
\begin{figure}[h!]
 \begin{center}
  \includegraphics[scale=0.9]{Images/C4}
  \caption{Salida de Simulink hacia Arduino.}
  \label{C4}
 \end{center}
\end{figure}
%**************************************************************************************

\end{appendix}
 
\begin{thebibliography}{100} 
 \bibitem{Markovito}Markovito: Home Page. Visto por última vez: 25/octubre/2013.\\
 \url{http://ccc.inaoep.mx/~markovito/}
 
 \bibitem{PAPERO}PAPERO.Visto por última vez: 25/octubre/2013.\\
 \url{http://www.ipapero.com/}
 
 \bibitem{AIBO}Sony AIBO. Visto por última vez: 25/octubre/2013.\\
 \url{http://www.sony-europe.com/support/aibo/4_0_support_breakdown.asp}
 
 \bibitem{Seattle}Seattle Robotics. Visto por última vez: 21/agosto/2013.\\
 \url{http://www.seattlerobotics.org/encoder/mar98/fuz/fl_part1.html#INTRODUCTION}
 
 \bibitem{SocietyOfRobotsChasis}Society of Robots - Chasis construction. Visto por última vez: 20/septiembre/2013.\\
 \url{http://www.societyofrobots.com/mechanics_chassisconstruction.shtml}
 
 \bibitem{SocietyOfRobotsStatic}Society of Robots - Statics. Visto por última vez: 20/septiembre/2013.\\
 \url{http://www.societyofrobots.com/mechanics_statics.shtml}
 
 \bibitem{SocietyOfRobotsDynamics}Society of Robots - Dynamics. Visto por última vez: 20/septiembre/2013.\\
 \url{http://www.societyofrobots.com/mechanics_dynamics.shtml}
 
 \bibitem{SocietyOfRobotsArm}Society of Robots - Arm design. Visto por última vez: 20/septiembre/2013.\\
 \url{http://www.societyofrobots.com/robot_arm_tutorial.shtml}
 
 \bibitem{SolidWorks2013}Shih, Randy H. \textit{Learning SolidWorks 2013}. SDC Publications. 2012. Estados Unidos de Norteamérica.
 486 páginas. ISBN: 978 - 1 - 58503 - 769 - 8.
 
 \bibitem{Python}Python.org. Visto por última vez: 20/septiembre/2013.\\
 \url{http://www.python.org/}

 \bibitem{OReillyTornado} Dory, Michael; Parrish, Adam; Berg, Brendan. \textit{Introduction to Tornado.} Editorial O'Reilly.
 Primera edición. 2012. Estados Unidos de Norteamérica. 136 páginas. ISBN: 978 - 1 - 449 - 30907 - 7.
 
 \bibitem{MS Kinect}Kinect for Windows. Visto por última vez: 2 de noviembre del 2013.\\
 \url{http://www.microsoft.com/en-us/kinectforwindows/}
 
 \bibitem{KinectSpec}Kinect for Windows sensor components and specifications. Visto por última vez: 2 de noviembre del 2013.\\
 \url{http://msdn.microsoft.com/en-us/library/jj131033.aspx}
 
 \bibitem{LibfreenectStory}OpenKinect. The history. Visto por última vez: 3 de noviembre del 2013.\\
 \url{http://openkinect.org/wiki/History}
 
 \bibitem{LibfreenectInstall}OpenKinect. Getting Started. Visto por última vez: 3 de noviembre del 2013.\\
 \url{http://openkinect.org/wiki/Getting_Started}
 
 \bibitem{KineticJS}KineticJS. Visto por última vez: 18/septiembre/2013.\\
 \url{http://kineticjs.com/}
 
 \bibitem{KineticJS-Ejemplo1}HTML5 Canvas Tutorials. Visto por última vez: 18/septiembre/2013.\\
 \url{http://www.html5canvastutorials.com/kineticjs/html5-canvas-kineticjs-circle-tutorial/}
 
 \bibitem{Mega}Arduino Mega - Schematics. Visto por última vez: 21/agosto/2013.\\
 \url{http://arduino.cc/en/Main/arduinoBoardMega2560}
 
 \bibitem{Spong}W. Spong, Mark; Vidyasagar, M. \textit{Robot Dynamics and Control.} Editorial John Wiley and Sons Inc. Primera
 edición. Estados Unidos de Norteamérica. ISBN: 0-471-61243-X.
 
 \bibitem{Craig}Craig, John J. \textit{ROBÓTICA.} PEARSON EDUCACIÓN. México, 2006. ISBN: 970-26-0772-8. Páginas: 408.

 %\bibitem{BibliographyArticle} Autor1, Autor2 \& Autor3. \textit{Título de la publicación.}\\
 %Departamento investigador – Escuela de publicación. País donde se investigó. MES Y AÑO DE PUBLICACIÓN.
\end{thebibliography}
\end{document}          
