220 lines
9.1 KiB
TeX
220 lines
9.1 KiB
TeX
% Preamble
|
|
\documentclass{beamer}
|
|
\usepackage{cmap}
|
|
\usepackage[french]{babel}
|
|
\usepackage{amsmath, amssymb}
|
|
\usepackage{tikz}
|
|
\usepackage{multicol}
|
|
\usetikzlibrary{arrows.meta, backgrounds, calc, fit, positioning, scopes, shadows}
|
|
|
|
|
|
\mode<presentation>
|
|
\usetheme{Dresden}
|
|
|
|
\definecolor{vulm}{HTML}{7d1dd3}
|
|
\definecolor{yulm}{HTML}{ffe500}
|
|
|
|
\AtBeginSection[]{\begin{frame}{Plan}\tableofcontents[sectionstyle=show/shaded]\end{frame}}
|
|
|
|
\setbeamercolor{structure}{fg = vulm}
|
|
\setbeamercolor{section in head/foot}{fg = yulm}
|
|
\setbeamercolor{subsection in head/foot}{fg = yulm}
|
|
\setbeamercolor{background canvas}{bg = yulm!10}
|
|
\setbeamertemplate{navigation symbols}{}
|
|
|
|
\author{Matthieu \textsc{Boyer} \& Sélène \textsc{Corbineau}}
|
|
\title{Simulation d'un Contrôleur de Petite Machine à Bois}
|
|
|
|
% Document
|
|
\begin{document}
|
|
\maketitle
|
|
\section{Positionnement du Problème}\label{sec:le-probleme}
|
|
|
|
\begin{frame}
|
|
\frametitle{Petite Machine à Bois}
|
|
\begin{figure}
|
|
\centering
|
|
\includegraphics[width=.9\textwidth]{images/cnc}
|
|
\caption{Une Petite Machine à Bois}
|
|
\label{fig:cnc}
|
|
\end{figure}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Format d'Entrée}
|
|
On convertit un fichier \texttt{.svg} en fichier \texttt{.gc} qui est une abstraction des commandes à exécuter.
|
|
\begin{figure}
|
|
\centering
|
|
\begin{tikzpicture}
|
|
\draw[vulm, fill=yulm!30] (0, 0) rectangle +(2, 2) node[pos=.5] {\texttt{.svg}};
|
|
\draw[vulm, ->] (2, 1) -- (3, 1);
|
|
\draw[vulm, fill=yulm!30] (3, 0) rectangle +(2, 2) node[pos=.5] {\texttt{.gc}};
|
|
\draw[vulm, ->] (5, 1) -- (6, 1);
|
|
\draw[vulm, fill=yulm!30, double] (6, 0) rectangle +(2, 2) node[pos=.5] {\texttt{CNC}};
|
|
\end{tikzpicture}
|
|
\end{figure}
|
|
\visible<2->{Le format GCode est standardisé, et indépendant des capacités de la machine.}
|
|
\end{frame}
|
|
|
|
\tikzset{
|
|
comp/.style = {
|
|
minimum width = 8cm,
|
|
minimum height = 4.5cm,
|
|
text width = 8cm,
|
|
inner sep = 0pt,
|
|
text = green,
|
|
align = center,
|
|
font = \Huge,
|
|
transform shape,
|
|
thick
|
|
},
|
|
monitor/.style = {draw = none, xscale = 18/16, yscale = 11/9},
|
|
display/.style = {shading = axis, left color = black!60, right color = black},
|
|
ut/.style = {fill = gray}
|
|
}
|
|
|
|
\tikzset{
|
|
computer/.pic = {
|
|
% screen (with border)
|
|
\node(-m) [comp, pic actions, monitor]
|
|
{\phantom{\parbox{\linewidth}{\tikzpictext}}};
|
|
% display (without border)
|
|
\node[comp, pic actions, display] {\tikzpictext};
|
|
\begin{scope}[x = (-m.east), y = (-m.north)]
|
|
% filling the lower part
|
|
\path[pic actions, draw = none]
|
|
([yshift=2\pgflinewidth]-0.1,-1) -- (-0.1,-1.3) -- (-1,-1.3) --
|
|
(-1,-2.4) -- (1,-2.4) -- (1,-1.3) -- (0.1,-1.3) --
|
|
([yshift=2\pgflinewidth]0.1,-1);
|
|
% filling the border of the lower part
|
|
\path[ut]
|
|
(-1,-2.4) rectangle (1,-1.3)
|
|
(-0.9,-1.4) -- (-0.7,-2.3) -- (0.7,-2.3) -- (0.9,-1.4) -- cycle;
|
|
% drawing the frame of the whole computer
|
|
\path[pic actions, fill = none]
|
|
(-1,1) -- (-1,-1) -- (-0.1,-1) -- (-0.1,-1.3) -- (-1,-1.3) --
|
|
(-1,-2.4) coordinate(sw)coordinate[pos=0.5] (-b west) --
|
|
(1,-2.4) -- (1,-1.3) coordinate[pos=0.5] (-b east) --
|
|
(0.1,-1.3) -- (0.1,-1) -- (1,-1) -- (1,1) -- cycle;
|
|
% node around the whole computer
|
|
\node(-c) [fit = (sw)(-m.north east), inner sep = 0pt] {};
|
|
\end{scope}
|
|
}
|
|
}
|
|
|
|
\begin{frame}
|
|
\frametitle{Communication}
|
|
\begin{figure}
|
|
\centering
|
|
\hfill
|
|
\begin{minipage}{.5\textwidth}
|
|
\begin{tikzpicture}
|
|
\pic(comp0) [
|
|
draw, fill = gray!30, pic text = {Contrôleur de Petite Machine à Bois}, scale=.3
|
|
] {computer};
|
|
\coordinate (cnc) at ($(comp0-c.south) + (0, -1)$);
|
|
\path (comp0-c.east) edge [loop right, min distance=.7cm, in=330, out=30, looseness=8, -{Latex[width=3mm]}, vulm] node[right, vulm, rectangle, fill=yulm!30, draw=vulm] {GCode} (comp0-c.east);
|
|
\draw[vulm, fill=yulm!30] ($(cnc) + (-1, 0)$) rectangle +(2, -1) node[pos=0.5] {Socket};
|
|
\draw[vulm, ->, double] ($(comp0-c.south) + (0.2, 0)$) --node[anchor=west, vulm]{$\omega_{c}$} ($(cnc.north) + (0.2, 0)$);
|
|
\draw[vulm, <-, double] ($(comp0-c.south) + (-0.2, 0)$) --node[anchor=east, vulm]{$\theta$} ($(cnc.north) + (-0.2, 0)$);
|
|
\draw[vulm, ->, double] ($(cnc) + (0.2, -1)$) -- node[anchor=west, vulm]{$\omega_{c}$} ($(cnc) + (0.2, -2)$);;
|
|
\draw[vulm, <-, double] ($(cnc) + (-0.2, -1)$) -- node[anchor=east, vulm]{$\theta$} ($(cnc) + (-0.2, -2)$);;
|
|
\draw[vulm, fill=yulm!30] ($(cnc) + (-2, -2)$) rectangle +(4, -1) node[pos=0.5] {Petite Machine à Bois};
|
|
\end{tikzpicture}
|
|
\end{minipage}
|
|
\hfill
|
|
\begin{minipage}{.4\textwidth}
|
|
\begin{tikzpicture}[scale=.5]
|
|
\node[vulm, font=\small] (top) at (0, 0) {\parbox{.9\linewidth}{\textbf{Contrôleur:} traduit le GCode et envoie les vitesses de commande $\omega_{c}$ pour les moteurs.}};
|
|
\node[vulm, font=\small] (mid) at ($(top.south) + (0, -2)$) {\parbox{.9\linewidth}{\textbf{Socket:} sert d'intermédiaire pour la connexion (CNC).}};
|
|
\node[vulm, font=\small] (bot) at ($(mid.south) + (0, -2)$) {\parbox{.9\linewidth}{\textbf{Petite Machine à Bois:} envoie les positions $\theta$ de ses moteurs pas-à-pas.}};
|
|
\node[draw=vulm, thick, fit={(top) (mid) (bot)}, inner sep=3pt] (box) {};
|
|
\end{tikzpicture}
|
|
\end{minipage}
|
|
\hfill
|
|
\end{figure}
|
|
\end{frame}
|
|
|
|
|
|
\section{Implémentation}\label{sec:l'implementation}
|
|
|
|
\begin{frame}
|
|
\frametitle{Traducteur}
|
|
On agit simplement ligne par ligne, voici quelques commandes:
|
|
\begin{center}
|
|
\begin{minipage}{.95\textwidth}
|
|
\begin{multicols}{2}
|
|
\begin{itemize}
|
|
\item[G0:] Aller au point donné;
|
|
\item[G1:] Aller au point donné, en coupant au passage;
|
|
\item[G2,G3:] Faire un arc de cercle, en sens trigonométrique ou non;
|
|
\item[G4:] Dormir;
|
|
\item[G5:] Suivre une courbe de Bézier cubique. Permet d'en suivre plusieurs d'affilée de manière dérivable;
|
|
\item[G20:] WTF IS A KILOMETER;
|
|
\item[G21:] Changer d'unité en mm;
|
|
\item[G28:] Retourner à la maison;
|
|
\item[G30:] Retourner à la maison, en passant par un point donné.
|
|
\end{itemize}
|
|
\end{multicols}
|
|
\end{minipage}
|
|
\end{center}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Module de Contrôle Hardware}
|
|
Le module Hardware du contrôleur maintient une représentation mémoire de la position \emph{théorique} de la tête, transmise au contrôleur.
|
|
Il demande à la socket (et donc au \emph{vrai} hardware) les positions mesurées des moteurs pas-à-pas.
|
|
\begin{figure}
|
|
\centering
|
|
\begin{tikzpicture}
|
|
\draw[vulm, fill=yulm!30] (0, 0) rectangle +(2, 1) node[pos=0.5] (h) {Hardware};
|
|
\draw[vulm, fill=yulm!30] (6, 0) rectangle +(2, 1) node[pos=0.5] (c) {Contrôleur};
|
|
\draw[vulm, fill=yulm!30] (0, -2) rectangle +(2, 1) node[pos=0.5] (s) {Socket};
|
|
\draw[vulm, ->] ($(h.east) + (.2, 0.1)$) -- node[above, vulm] {Position $\rho$ \& Cible $\tau$} ($(c.west) + (-0.1, 0.1)$);
|
|
\draw[vulm, <-] ($(h.east) + (.2, -0.1)$) -- node[below, vulm] {Déplacement $\Gamma_{c}$} ($(c.west) + (-0.1, -0.1)$);
|
|
\draw[vulm, ->] ($(h.south) + (.1, -.3)$) -- node[right, vulm] {$\omega_{c}$} ($(s.north) + (.1, 0.3)$);
|
|
\draw[vulm, <-] ($(h.south) + (-.1, -.3)$) -- node[left, vulm] {$\theta$} ($(s.north) + (-.1, 0.3)$);
|
|
\end{tikzpicture}
|
|
\end{figure}
|
|
Il envoie ensuite à la socket pour envoyer les vitesses de commandes traduites dans la spécification des moteurs.
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Contrôleur en Vitesse}
|
|
Dans une première approximation, on poursuit le point de contrôle à vitesse constante.
|
|
On calcule $\delta = \rho - \tau$.
|
|
Selon le signe de $\delta_{x}$ (resp. $y, z$) on définit $\omega_{c}$ la vitesse de commande de sorte que:
|
|
\begin{equation*}
|
|
\norm{\omega_{c}} = 1 \text{ et } \left(\omega_{c}\right)_{x} \leq \texttt{FAST_XY_FEEDRATE} \text{(resp. $y, z$)}
|
|
\end{equation*}
|
|
Un contrôleur plus poussé est obtenu en ajoutant une proportionnalité par rapport à l'écart \emph{théorie - mesure}.
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{Simulateur}
|
|
Pour modéliser la Petite Machine à Bois, on construit un simulateur physique simple.
|
|
On discrétise le temps par:
|
|
\begin{equation*}
|
|
\Delta t = t\left( \text{dernière requête reçue} \right) - t\left( \text{dernière requête traitée} \right)
|
|
\end{equation*}
|
|
On a ensuite par le PFD:
|
|
\begin{equation*}
|
|
\dot{J_{\omega}} = \underset{\text{Inertie}}{-f\omega} + \underset{\text{Couple Commande}}{\left( \omega_{c} - \omega_{t} \right)}, \text{d'où } \omega_{t + 1} = \omega_{t} + \Delta t \left( -f\omega + \left( \omega_{c} - \omega_{t} \right) \right)
|
|
\end{equation*}
|
|
On introduit par ailleurs un terme d'erreur lié aux frottements, et on peut encore raffiner le modèle.
|
|
\end{frame}
|
|
|
|
|
|
\section{Réalisme}
|
|
|
|
\begin{frame}
|
|
\frametitle{Connexion et Précision}
|
|
L'utilisation d'une socket et d'un modèle théorique restreint comme intermédiaire permet de prendre en compte, durant les phases de test, les différents facteurs d'erreurs pouvant intervenir durant l'exécution:
|
|
\begin{itemize}
|
|
\item Une connexion trop volatile;
|
|
\item Des erreurs liées au glissement des moteurs pas-à-pas;
|
|
\item Des erreurs liées à la dureté du matériau à couper, et à son anisotropie.
|
|
\end{itemize}
|
|
\end{frame}
|
|
|
|
\end{document}
|