%
% SimulazioneSoftware.tex
%

\documentclass{beamer}

\usepackage{beamerthemeshadow}
\usepackage{listings}
\usepackage{graphics}
\usepackage{times}
\usepackage{algorithm2e}

\usepackage{pgf,pgfarrows,pgfnodes,pgfautomata,pgfheaps,pgfshade}
% \usepackage{amsmath,amssymb} \usepackage[latin1]{inputenc}
% \usepackage{colortbl}
\usepackage[english]{babel}

\newcommand{\erlang}{
\lstset{language=Prolog, basicstyle=\ttfamily\footnotesize,frame=trBL,
  frameround=fttt}}

\newcommand{\erlangsmall}{
\lstset{language=Prolog, basicstyle=\ttfamily\scriptsize,frame=trBL,
  frameround=fttt}}

\newcommand{\clang}{
\lstset{language=Prolog, basicstyle=\ttfamily\footnotesize,frame=trBL,
  frameround=fttt}}

\newcommand{\clangsmall}{
\lstset{language=Prolog, basicstyle=\bf\ttfamily\scriptsize,frame=trBL,
  frameround=fttt}}

\newcommand{\clangtiny}{
\lstset{language=Prolog, basicstyle=\bf\ttfamily\tiny,frame=trBL,
  frameround=fttt}}

\erlang

\newcommand\blue{\color[rgb]{0,0,1}}
\newcommand\green{\color[rgb]{0,0.5,0}}
\newcommand\red{\color[rgb]{1,0,0}}
\newcommand\black{\color[rgb]{0,0,0}}

\newcommand\tape[9]{
\framebox{#1}
\framebox{#2}
\framebox{#3}
\framebox{#4}
\framebox{#5}
\framebox{#6}
\framebox{#7}
\framebox{#8}
\framebox{#9}}

\newcommand\two[2]{
\framebox{#1}
\framebox{#2}}

\newcommand\six[6]{
\framebox{#1}
\framebox{#2}
\framebox{#3}
\framebox{#4}
\framebox{#5}
\framebox{#6}}

\newcommand\three[3]{
\framebox{#1}
\framebox{#2}
\framebox{#3}}

\title[Simulazione di un Sistema Dinamico]{Simulazione Software di un
  Sistema Dinamico}
%%

\author[Corrado Santoro]
       {Corrado Santoro}

\date{ }

\institute[University of Catania]
  {
    \begin{center}
      \textbf{\red{}ARSLAB - Autonomous and Robotic Systems Laboratory}\\
      Dipartimento di Matematica e Informatica - Universit\`{a} di Catania, Italy\\
      \texttt{santoro@dmi.unict.it}\\
      \includegraphics[width=60pt]{robotEscher_Eura_blur.eps}\\%%~~~~\includegraphics[width=80pt]{logo_dmi.png}
      Programmazione Sistemi Robotici\\
    \end{center}
  }



\begin{document}

\frame{\titlepage}


\newcommand\LT[1]{\mathcal{L}\{#1\}}
\newcommand\ILT[1]{\mathcal{L}^{-1}\{#1\}}


%%
\begin{frame}[fragile]
%%
  \frametitle{Dal continuo al discreto}
%%
%%
\begin{itemize}
\item\footnotesize{}L'implementazione/simulazione di un sistema di controllo
  pu\`{o} essere effettuata con un approccio
  \begin{itemize}
  \item\footnotesize{}\textbf{\red{}tempo-continuo}
  \item\textbf{\red{}tempo-discreto}
  \end{itemize}
\item\textbf{tempo-continuo:} l'implementazione si effettua risolvendo le
  equazioni differenziali che caratterizzano il sistema e determinando la
  forma analica $y(t)$
\item\textbf{tempo-discreto:} l'implementazione si effettua
  \textbf{discretizzando} il sistema, ossia trasformandolo da
  {\blue{}tempo-continuo} a \textbf{\red{}tempo-discreto}
\end{itemize}
\end{frame}
%%





%%
\begin{frame}[fragile]
%%
  \frametitle{Discretizzazione di un sistema}
%%
%%
\begin{itemize}
\item\footnotesize{}L'operazione di discretizzazione implica ``campionare''
  tutti i segnali con un intervallo di tempo prefissato $\Delta t$:
\end{itemize}
%%
\begin{eqnarray*}
x(t), t \in \mathcal{R}& \Rightarrow & x(k\Delta t), k \in \mathcal{N}\\
\dot{x}(t), t \in \mathcal{R}& \Rightarrow & \frac{x( (k+1) \Delta t) - x(k
 \Delta t)}{\Delta t}, k \in \mathcal{N}\\
x(t)& \Rightarrow & x(k)\\
\dot{x}(t) & \Rightarrow & \frac{x(k+1) - x(k)}{\Delta t}
\end{eqnarray*}
%%
\end{frame}
%%



%%
\begin{frame}[fragile]
%%
  \frametitle{Discretizzazione di un sistema}
%%
Il sistema
%%
\[
\left\{
\begin{array}{rcl}
\dot{x} & = & A x + B u\\
y & = & C x + D u
\end{array}
\right.
\]
%%

discretizzato con tempo di campionamento $\Delta t$ diventa:
\red{}
\[
\left\{
\begin{array}{rcl}
\frac{x(k+1)-x(k)}{\Delta t} & = & A ~ x(k) + B ~ u(k)\\
y(k) & = & C ~ x(k) + D ~ u(k)
\end{array}
\right.
\]

\black{}
\[
\left\{
\begin{array}{rcl}
x(k+1)-x(k) & = & A ~x(k)~ \Delta t + B ~u(k)~ \Delta t \\
y(k) & = & C ~x(k) + D ~u(k)
\end{array}
\right.
\]

\red{}
\[
\left\{
\begin{array}{rcl}
x(k+1) & = & (A \Delta t + I) ~ x(k) + B~ u(k)~ \Delta t\\
y(k) & = & C ~x(k) + D ~u(k)
\end{array}
\right.
\]

%%
\end{frame}
%%




%%
\begin{frame}[fragile]
%%
  \frametitle{Discretizzazione di un sistema}
%%
Il sistema
%%
\[
\left\{
\begin{array}{rcl}
\dot{x} & = & A x + B u\\
y & = & C x + D u
\end{array}
\right.
\]
%%

discretizzato con tempo di campionamento $\Delta t$ diventa:

\red{}
\[
\left\{
\begin{array}{rcl}
x(k+1) & = & A' x(k) + B' u(k)\\
y(k) & = & C x(k) + D u(k)
\end{array}
\right.
\]

\black{}
dove:

\begin{eqnarray*}
A' & = & A\Delta t + I \\
B' & = & B\Delta t
\end{eqnarray*}


Sebbene la forma analitica sia diversa, i \textbf{\red{}due sistemi sono equivalenti}

%%
\end{frame}
%%


%%
\begin{frame}[fragile]
%%
  \frametitle{Sistemi discreti}
%%
In un sistema discreto:
%%

\[
\left\{
\begin{array}{rcl}
x(k+1) & = & A' x(k) + B' u(k)\\
y(k) & = & C x(k) + D u(k)
\end{array}
\right.
\]
\\
scompare l'equazione differenziale che descrive l'evoluzione dello stato
nel \emph{tempo}

~\\

Essa \`{e} sostituita dalla \textbf{equazione alle differenze}:
\[
\red{}x(k+1)  =  A' x(k) + B' u(k)
\]
che indica
qual \`{e} il valore che assumer\`{a} lo stato al \emph{successivo istante
  di campionamento} ({\red{}legge di aggiornamento dello stato})

%%
\end{frame}
%%



%%
\begin{frame}[fragile]
%%
  \frametitle{Esempio: Massa su piano con attrito}
%%
\begin{center}
\includegraphics[scale=0.2]{massa_attrito_2.eps}
\end{center}
%%
%%
\[
\left\{
\begin{array}{rcl}
\red
\begin{bmatrix}
\dot{v} \\ \dot{p}
\end{bmatrix}
& = &
\begin{bmatrix}
-\frac{b}{M} & 0\\
1 & 0
\end{bmatrix}
{\red%%
\begin{bmatrix}
v \\ p
\end{bmatrix}}
+
\begin{bmatrix}
\frac{1}{M} \\ 0
\end{bmatrix}
{\blue%%
\begin{bmatrix}
f
\end{bmatrix}}
\\
{\green%%
\begin{bmatrix}
y
\end{bmatrix}}
& = &
\begin{bmatrix}
0 & 1
\end{bmatrix}
{\red%%
\begin{bmatrix}
v \\ p
\end{bmatrix}}
\end{array}
\right.
\]
%%

%%
\begin{eqnarray*}
A = \begin{bmatrix}
-\frac{b}{M} & 0\\
1 & 0
\end{bmatrix}
&
B = \begin{bmatrix}
\frac{1}{M} \\ 0
\end{bmatrix}
\\
C = \begin{bmatrix}
0 & 1
\end{bmatrix}
&
D = \begin{bmatrix}
0
\end{bmatrix}
\end{eqnarray*}

\end{frame}
%%





%%
\begin{frame}[fragile]
%%
  \frametitle{Discretizziamo}
%%
%%
%%
%%
\begin{eqnarray*}
A' & = & A\Delta t + I = \begin{bmatrix}
-\frac{b}{M} & 0\\
1 & 0
\end{bmatrix} \Delta t + \begin{bmatrix}
1 & 0\\
0 & 1
\end{bmatrix} =
\begin{bmatrix}
-\frac{b}{M}\Delta t + 1 & 0\\
\Delta t & 1
\end{bmatrix}\\
%%
B' & = & B\Delta t = \begin{bmatrix}
\frac{1}{M} \\ 0
\end{bmatrix} \Delta t =
 \begin{bmatrix}
\frac{\Delta t}{M}\\ 0
\end{bmatrix}
\end{eqnarray*}
%%
%%

\[
\left\{
\begin{array}{rcl}
\red
\begin{bmatrix}
v(k+1) \\ p(k+1)
\end{bmatrix}
& = &
\begin{bmatrix}
-\frac{b}{M}\Delta t + 1 & 0\\
\Delta t & 1
\end{bmatrix}
{\red%%
\begin{bmatrix}
v(k) \\ p(k)
\end{bmatrix}}
+
\begin{bmatrix}
\frac{\Delta t}{M} \\ 0
\end{bmatrix}
{\blue%%
\begin{bmatrix}
f(k)
\end{bmatrix}}
\\
{\green%%
\begin{bmatrix}
y(k)
\end{bmatrix}}
& = &
\begin{bmatrix}
0 & 1
\end{bmatrix}
{\red%%
\begin{bmatrix}
v(k) \\ p(k)
\end{bmatrix}}
\end{array}
\right.
\]
%%

\end{frame}
%%






%%
\begin{frame}[fragile]
%%
  \frametitle{Discretizziamo}
%%
%%
%%
%%
\[
\left\{
\begin{array}{rcl}
\red
\begin{bmatrix}
v(k+1) \\ p(k+1)
\end{bmatrix}
& = &
\begin{bmatrix}
-\frac{b}{M}\Delta t + 1 & 0\\
\Delta t & 1
\end{bmatrix}
{\red%%
\begin{bmatrix}
v(k) \\ p(k)
\end{bmatrix}}
+
\begin{bmatrix}
\frac{\Delta t}{M} \\ 0
\end{bmatrix}
{\blue%%
\begin{bmatrix}
f(k)
\end{bmatrix}}
\\
{\green%%
\begin{bmatrix}
y(k)
\end{bmatrix}}
& = &
\begin{bmatrix}
0 & 1
\end{bmatrix}
{\red%%
\begin{bmatrix}
v(k) \\ p(k)
\end{bmatrix}}
\end{array}
\right.
\]
%%
~\\~\\
%%
\begin{block}{}
\[
\left\{
\begin{array}{rcl}
v(k+1) & = & (-\frac{b}{M}\Delta t + 1)v(k) + \frac{\Delta t}{M} f(k)\\
p(k+1) & = &  v(k) \Delta t + p(k)\\
y(k) & = & p(k)
\end{array}
\right.
\]
\end{block}
%%
\end{frame}
%%




%%
\begin{frame}[fragile]
%%
  \frametitle{Implementazione di un \textbf{Sistema Dinamico}}
%%
\begin{block}{~~}
Un \textbf{sistema dinamico} \`{e} una \textbf{black box} caratterizzata da:
\begin{itemize}
\item uno \textbf{stato} (\textbf{\red{}variabili persistenti})
\item un \textbf{comportamento} (\textbf{\red{}codice})
\end{itemize}
\end{block}
%%
~\\
%%
\begin{block}{~~}
La sua implementazione pi\`{u} naturale \`{e} un \textbf{\red{}oggetto} in cui:
\begin{itemize}
\item gli \textbf{\red{}attributi} rappresentano lo \textbf{stato}
\item i \textbf{\red{}metodi} rappresentano il \textbf{comportamento}
\end{itemize}
%%
\end{block}
%%
%%
%%
%%
\end{frame}
%%



%%
\begin{frame}[fragile]
%%
  \frametitle{Implementazione del sistema massa con attrito}
%%
Generalizziamo.... possiamo pensare ad una \textbf{classe base} dove rappresentiamo:
\begin{itemize}
\item{\red{}il tempo di campionamento, \textbf{\texttt{m\_delta\_t}}}
\item{\red{}il metodo (virtuale ed astratto), \textbf{\texttt{evaluate}}, che rappresenta il
  comportamento del sistema}
\end{itemize}
%%
~\\
%%
\black\clangsmall%%
\begin{lstlisting}
class DynamicSystem {

public:
  DynamicSystem(float delta_t) { m_delta_t = delta_t; };
  virtual float evaluate(float input) = 0;

protected:
  float m_delta_t;
};
\end{lstlisting}
%%
\end{frame}
%%





%%
\begin{frame}[fragile]
%%
  \frametitle{Implementazione del sistema massa con attrito}
%%
\begin{block}{}
\[
\left\{
\begin{array}{rcl}
v(k+1) & = & (-\frac{b}{M}\Delta t + 1)v(k) + \frac{\Delta t}{M} f(k)\\
p(k+1) & = &  v(k) \Delta t + p(k)\\
y(k) & = & p(k)
\end{array}
\right.
\]
\end{block}
%%
{\red{}Specializziamo....}
%%
\black\clangsmall%%
\begin{lstlisting}
class MassaAttrito : public DynamicSystem {

public:
  MassaAttrito(float m, float b, float delta_t);
  float evaluate(float input);

private:
  float m_massa, m_b;  // costanti del sistema
  float v_k, p_k;      // stato del sistema
};
\end{lstlisting}
%%
\end{frame}
%%






%%
\begin{frame}[fragile]
%%
  \frametitle{Implementazione del sistema massa con attrito}
%%
\begin{block}{}
\[
\left\{
\begin{array}{rcl}
v(k+1) & = & (-\frac{b}{M}\Delta t + 1)v(k) + \frac{\Delta t}{M} f(k)\\
p(k+1) & = &  v(k) \Delta t + p(k)\\
y(k) & = & p(k)
\end{array}
\right.
\]
\end{block}
%%
{\red{}Specializziamo....}
%%
\black\clangsmall%%
\begin{lstlisting}
MassaAttrito::MassaAttrito(float m, float b, float delta_t)
  : DynamicSystem(delta_t)
{
  m_massa = m;  m_b = b;  // impostazione attributi
  v_k = 0;  p_k = 0;      // stato iniziale
}

float MassaAttrito::evaluate(float input)
{
  float y = p_k;                       // calcolo uscita
  v_k = (-m_b / m_massa * m_delta_t + 1) * v_k
         + m_delta_t / m_massa * input;  // aggiornamento v_k
  p_k = v_k * m_delta_t + p_k;         // aggiornamento p_k
  return y;
}
\end{lstlisting}
%%
\end{frame}
%%








%%
\begin{frame}[fragile]
%%
  \frametitle{Implementazione di un \textbf{Sistema Dinamico}}
%%
Organizzazione dei sorgenti:\\
\begin{itemize}
\item{\red{}\textbf{\texttt{dynamic\_system.h}}}: definizione della classe \textbf{DynamicSystem}
\item{\red{}\textbf{\texttt{massa\_attrito.h}}}: definizione della classe \textbf{MassaAttrito}
\item{\red{}\textbf{\texttt{massa\_attrito.cpp}}}: implementazione dei metodi della classe \textbf{MassaAttrito}
\item{\red{}\textbf{\texttt{main.cpp}}}: test del sistema
\end{itemize}
%%
%%
\end{frame}
%%






%%
\begin{frame}[fragile]
%%
  \frametitle{Implementazione del sistema massa con attrito}
%%
%%
{\red{}main program....}
%%
\black\clangsmall%%
\begin{lstlisting}
#include <fstream>
#include "dynamic_system.h"
#include "massa_molla.h"

int main(int argc, char **argv)
{
  MassaAttrito m(1.0, 0.6, 0.01);
  // Massa = 1 kg
  // Coeff.Attrito = 0.6 N s/m
  // Delta T = 10 ms

  float input = 2; // spinta di 2 N

  std::ofstream output_file("data.txt"); // output file dei dati

  for (int i = 0; i < 1000;i++) {   // 10 secs = 1000 iterazioni
    float output = m.evaluate(input);
    output_file << (i*0.01) << " " << output << std::endl;
  }

  output_file.close();
}
\end{lstlisting}
%%
\end{frame}
%%



%%
\begin{frame}[fragile]
%%
  \frametitle{Output della simulazione: Posizione}
%%
\begin{center}
\includegraphics[scale=0.8]{massa_attrito_posizione.eps}
\end{center}
%%
%%
\end{frame}
%%



%%
\begin{frame}[fragile]
%%
  \frametitle{Implementazione del sistema massa con attrito}
%%
\begin{block}{}
\[
\left\{
\begin{array}{rcl}
v(k+1) & = & (-\frac{b}{M}\Delta t + 1)v(k) + \frac{\Delta t}{M} f(k)\\
p(k+1) & = &  v(k) \Delta t + p(k)\\
y(k) & = & v(k)
\end{array}
\right.
\]
\end{block}
%%
{\red{}Consideriamo come output la velocit\`{a}....}
%%
\black\clangsmall%%
\begin{lstlisting}
MassaAttrito::MassaAttrito(float m, float b, float delta_t)
  : DynamicSystem(delta_t)
{
  m_massa = m;  m_b = b;  // impostazione attributi
  v_k = 0;  p_k = 0;      // stato iniziale
}

float MassaAttrito::evaluate(float input)
{
  float y = v_k;                       // calcolo uscita
  v_k = (-m_b / m_massa * m_delta_t + 1) * v_k
         + m_delta_t / m_massa * input;  // aggiornamento v_k
  p_k = v_k * m_delta_t + p_k;         // aggiornamento p_k
  return y;
}
\end{lstlisting}
%%
\end{frame}
%%







%%
\begin{frame}[fragile]
%%
  \frametitle{Output della simulazione: Velocit\`{a}}
%%
\begin{center}
\includegraphics[scale=0.8]{massa_attrito_velocita.eps}
\end{center}
%%
%%
\end{frame}
%%




%%
\begin{frame}[fragile]
%%
  \frametitle{Esercitazione: Massa-molla}
%%
\begin{center}
\includegraphics[scale=0.2]{massa_molla_forzata.eps}
\end{center}
%%
%%
\[
\left\{
\begin{array}{rcl}
\red
\begin{bmatrix}
\dot{x} \\ \dot{v}
\end{bmatrix}
& = &
\begin{bmatrix}
0 & 1 \\
-\frac{k}{M} & -\frac{b}{M}
\end{bmatrix}
{\red%%
\begin{bmatrix}
x \\ v
\end{bmatrix}}
+
\begin{bmatrix}
0 \\ \frac{1}{M}
\end{bmatrix}
{\blue%%
\begin{bmatrix}
F
\end{bmatrix}}
\\
{\green%%
\begin{bmatrix}
y
\end{bmatrix}}
& = &
\begin{bmatrix}
1 & 0
\end{bmatrix}
{\red%%
\begin{bmatrix}
x \\ v
\end{bmatrix}}
\end{array}
\right.
\]
%%

%%
\begin{eqnarray*}
A = \begin{bmatrix}
0 & 1 \\
-\frac{k}{M} & -\frac{b}{M}
\end{bmatrix}
&
B = \begin{bmatrix}
0 \\ \frac{1}{M}
\end{bmatrix}
\\
C = \begin{bmatrix}
1 & 0
\end{bmatrix}
&
D = \begin{bmatrix}
0
\end{bmatrix}
\end{eqnarray*}

\end{frame}
%%












%%
%%------------
%%






\frame{\titlepage}


\end{document}
%%
%%