\documentclass{slides}
\addbibresource{slides.bib}

\title{Objets connectés et robotique}
\subtitle{L3 IFA, S5}
\date{Novembre 2025}
\titlegraphic{\flushright\includegraphics[height=1.3cm]{img/logos.png}\vspace{.5cm}}

\author{
    \texorpdfstring{
        \begin{table}[]
            \begin{flushleft}
                \begin{tabular}{ll}
                                         & Vincent Lannurien~\inst{1} \\
                                         & \url{vincent.lannurien@univ-brest.fr} \\ \\
                                         & Inspiré du cours de Yvon Autret et Jean Vareille
                \end{tabular}
            \end{flushleft}
        \end{table}
    }
    {
        Vincent Lannurien
    }
}

\institute{
    \texorpdfstring{
        \begin{table}[]
            \centering
            \begin{flushleft}
                \begin{tabular}{L}
                    \inst{1}~Lab-STICC, CNRS UMR 6285, Université de Bretagne Occidentale, Brest
                \end{tabular}
            \end{flushleft}
        \end{table}
    }
    {
        Lab-STICC, CNRS UMR 6285, Université de Bretagne Occidentale, Brest
    }
}

\begin{document}

\maketitle

\begin{frame}{Introduction}
    \begin{figure}
        \begin{subfigure}{.3\textwidth}
            \centering
            \includegraphics[width=\linewidth]{img/exemples/Mars_Climate_Orbiter_2.jpg}
        \end{subfigure}
        \begin{subfigure}{.2\textwidth}
            \centering
            \includegraphics[width=\linewidth]{img/exemples/Ariane_5_V88_pillars.jpg}
        \end{subfigure}
        \begin{subfigure}{.35\textwidth}
            \centering
            \includegraphics[width=\linewidth]{img/exemples/Patriot20missile202520Aug202016.jpg}
        \end{subfigure}
    \end{figure}
        \begin{figure}
        \begin{subfigure}{.18\textwidth}
            \centering
            \includegraphics[width=\linewidth]{img/exemples/therac-25.jpg}
        \end{subfigure}
        \begin{subfigure}{.3\textwidth}
            \centering
            \includegraphics[width=\linewidth]{img/exemples/uber-arizona.jpg}
        \end{subfigure}
        \begin{subfigure}{.36\textwidth}
            \centering
            \includegraphics[width=\linewidth]{img/exemples/titan-submersible.jpg}
        \end{subfigure}
    \end{figure}
\end{frame}

\begin{frame}
    \begin{itemize}
        \item \url{https://en.wikipedia.org/wiki/Mars_Climate_Orbiter}
        \begin{itemize}
            \item problème d'unités (système métrique vs système impérial)
        \end{itemize}
        \item \url{https://en.wikipedia.org/wiki/Ariane_flight_V88}
        \begin{itemize}
            \item erreur de conversion (\textit{overflow})
        \end{itemize}
        \item \url{https://en.wikipedia.org/wiki/14th_Quartermaster_Detachment}
        \begin{itemize}
            \item bug d'arrondi (\textit{overflow})
        \end{itemize}
        \item \url{https://en.wikipedia.org/wiki/Therac-25}
        \begin{itemize}
            \item erreur de programmation concurrente (\textit{race condition})
        \end{itemize}
        \item \url{https://en.wikipedia.org/wiki/Death_of_Elaine_Herzberg}
        \begin{itemize}
            \item détection d'obstacle inopérante
        \end{itemize}
        \item \url{https://en.wikipedia.org/wiki/Titan_submersible_implosion}
        \begin{itemize}
            \item certifications de sécurité insuffisantes
        \end{itemize}
    \end{itemize}
\end{frame}

\begin{frame}{Commençons par un test...}
    \begin{itemize}
        \item \textit{Trolley problem} (\url{https://en.wikipedia.org/wiki/Trolley_problem}) : le dilemme du tramway
    \end{itemize}

    \begin{center}
        \includegraphics[width=0.5\linewidth]{img/dilemma.png}
    \end{center}

    \begin{alertblock}{\centering \emoji{thinking}}
        \begin{center}
            Que feriez-vous ?
            $\rightarrow$ \url{https://www.moralmachine.net/hl/fr}
        \end{center}
    \end{alertblock}
\end{frame}

\begin{framefont}{\small}
\begin{frame}[t]{Plan de la présentation}
    \begin{columns}
        \column{0.5\textwidth}
        \tableofcontents%[hideallsubsections]

        \column{0.5\textwidth}
        \begin{center}
            \includegraphics[width=0.9\columnwidth]{img/logos.png}
        \end{center}
    \end{columns}
\end{frame}
\end{framefont}

\section{Organisation de l'UE}

\begin{frame}{Organisation de l'UE -- Contenu}
    \begin{itemize}
        \item Objectifs :
        \begin{itemize}
            \item Savoir concevoir des systèmes cyberphysiques simples, autonomes
            \item Comprendre les compromis entre performance (latence, débit) et consommation (énergie, mémoire)
        \end{itemize}
        \item Méthode :
        \begin{itemize}
            \item Le plus de \textbf{manipulations} possible !
            \item Dimension \textbf{matérielle} (un peu d'électronique, un peu de mécanique)
            \item Dimension \textbf{logicielle} (de l'informatique !)
        \end{itemize}
    \end{itemize}
\end{frame}

\begin{frame}{Organisation de l'UE -- Logistique}
    \begin{itemize}
        \item Volume horaire :
        \begin{itemize}
            \item CM : 8h
            \item TP : 14h
        \end{itemize}
        \item Travail en groupes :
        \begin{itemize}
            \item Binômes dans les groupes de TP
            \item Deux binômes par robot
        \end{itemize}
        \item Examen :
        \begin{itemize}
            \item Démo lors des TP
            \item Rendu de projet
        \end{itemize}
        \item Intervenants :
        \begin{itemize}
            \item Vincent Lannurien -- \url{vincent.lannurien@univ-brest.fr}
            \item Alan Le Boudec -- \url{alan.leboudec@univ-brest.fr}
        \end{itemize}
    \end{itemize}
\end{frame}

\section{Projet à réaliser}

\begin{frame}{Portée du projet}
    \textbf{Objectifs :}

    \begin{itemize}
        \item Prise en main de l'environnement de développement
        \item Implantation d'algorithmes simples sur le robot
        \item Calcul déporté
    \end{itemize}

    \vspace{24px}
    \pause

    Tout ce que l'on ne va pas faire :

    \begin{itemize}
        \item Électronique : montages complexes, conception de carte...
        \item Traitement du signal : radio, interférences...
        \item Sécurité : authentification, détection d'intrusion...
    \end{itemize}
\end{frame}

\begin{frame}{Étapes du projet}
    \begin{itemize}
        \item Commande : Fonctionnement de base d'un robot
        \begin{itemize}
            \item Envoi de messages : avancer, reculer, tourner, etc.
            \item Communications : filaire (série), sans-fil (radio)
            \item Interface web de commande : Node.js, JavaScript
        \end{itemize}
        \item Environnement : capteurs et actionneurs
        \begin{itemize}
            \item Utilisation d'un capteur de distance
            \item Fonctionnement des moteurs
        \end{itemize}
        \item Contrôle : Programmation de missions simples
        \begin{itemize}
            \item Comportement autonome :
            \begin{itemize}
                \item Avancer jusqu'à trouver un obstacle
                \item Avancer jusqu'à trouver une ouverture
                \item Faire un quart de tour
                \item Contourner un objet
            \end{itemize}
        \end{itemize}
        \item En option :
        \begin{itemize}
            \item Plus de capteurs
            \item Plus de cartes
        \end{itemize}
    \end{itemize}
\end{frame}

\section{Contexte}

\begin{frame}{Définitions -- Systèmes cyberphysiques}
    \begin{definition}
        \textit{Cyber-Physical Systems (CPS) are integrations of computation with physical processes.}~\footfullcite{leeCyberPhysicalSystems2008}
    \end{definition}

    \begin{itemize}
        \item Énergie : \textit{smart grids}
        \item Transport : systèmes ferroviaires, aviation civile, automobile autonome...
        \item Santé : dispositifs médicaux "connectés"
        \item Industrie : usines automatisées, robots industriels
        \item Ville "intelligente"
    \end{itemize}
\end{frame}

\begin{frame}{Définitions -- Systèmes cyberphysiques}
    \begin{definition}
        \textit{Cyber-Physical Systems (CPS) are integrations of computation with physical processes.}~\footfullcite{leeCyberPhysicalSystems2008}
    \end{definition}

    \begin{center}
        \includegraphics[width=0.6\linewidth]{img/cps.png}
    \end{center}

    \addtocounter{footnote}{1}
    \footnotetext{\fullcite{inderwildiImpactIntelligentCyberphysical2020}}
\end{frame}

\begin{frame}{Définitions -- Systèmes autonomes}
    \begin{columns}
        \column{0.5\linewidth}
        \begin{itemize}
            \item Robotique, systèmes autonomes~\footnote[frame]{\fullcite{kephartVisionAutonomicComputing2003}} :
            \begin{itemize}
                \item \textbf{Capteurs} : produisent une vue de l'environnement du système
                \item \textbf{Actionneurs} : commandent le système selon son état et sa consigne
            \end{itemize}
            \item Objets connectés, \textit{Internet of Things} (\textit{IoT}) : contrôle, commande à distance
        \end{itemize}

        \column{0.5\linewidth}
        \includegraphics[width=\columnwidth]{img/mape-k.png}
    \end{columns}
\end{frame}

\begin{frame}{Quelques tendances [\href{https://digital-strategy.ec.europa.eu/fr/policies/next-generation-internet-things}{réf.}]}
    \begin{itemize}
        \item 41 milliards d'appareils \textit{IoT} déployés en 2025
        \item Intelligence artificielle de plus en plus déployée en périphérie de réseau (Apple Intelligence, Google AI Edge)
        \item Défis : interopérabilité, durabilité
    \end{itemize}

    \begin{center}
        \includegraphics[width=0.5\linewidth]{img/cloud-edge.png}
    \end{center}
\end{frame}

\begin{frame}{Numérique -- Quels impacts ? (2022) [\href{https://infos.ademe.fr/magazine-avril-2022/faits-et-chiffres/numerique-quel-impact-environnemental/}{réf.}]}
    \begin{columns}
        \column{0.5\linewidth}
        Pour chaque Français, le numérique représente :

        \begin{itemize}
            \item \textbf{Consommation électrique} : 10\%
            \item \textbf{Empreinte carbone} : 2.5\%
            \item \textbf{Déchets} : 299 kg/habitant/an
            \item \textbf{Fabrication} : 78\% de l'impact
            \item \textbf{Utilisation} : 21\% de l'impact
        \end{itemize}

        \column{0.5\linewidth}
        \includegraphics[width=\columnwidth]{img/ademe-impacts.jpg}
    \end{columns}
\end{frame}

\begin{frame}{Numérique -- Quels impacts ? (2025) [\href{https://infos.ademe.fr/magazine-janvier-2025/numerique-quel-impact-environnemental-en-2022/}{réf.}]}
    \begin{columns}
        \column{0.7\linewidth}
        \begin{center}
            \includegraphics[width=0.4\columnwidth]{img/ademe-impacts-2025.png}
            \includegraphics[width=0.4\columnwidth]{img/ademe-impacts-2025-3.png}
        \end{center}

        \begin{itemize}
            \item Hausse de l'impact des \textbf{centres de données} : 46\% de l'empreinte carbone du numérique
        \end{itemize}

        \column{0.3\linewidth}
        \includegraphics[width=\columnwidth]{img/ademe-impacts-2025-2.png}
    \end{columns}
\end{frame}

\section{Informatique embarquée}

\subsection{Microcontrôleurs}

\begin{frame}{Microcontrôleurs : Utilisations et limites}
    \begin{columns}
        \column{0.7\linewidth}
        \begin{center}
            \includegraphics[width=0.145\columnwidth]{img/coffee-maker.png}
            \includegraphics[width=0.22\columnwidth]{img/shutter.png}
            \includegraphics[width=0.21\columnwidth]{img/electric-car.png}
        \end{center}

        \begin{itemize}
            \item \textbf{Circuit intégré} : calcul (processeur), mémoire (mémoire vive et non-volatile), interfaces d'Entrées/Sorties
            \item \textbf{Non-programmable} : son comportement est gravé dans le silicone
            \item \textbf{Utilisation} : partout où un processeur généraliste n'est pas nécessaire
            \begin{itemize}
                \item + : Plus simple à comprendre, à vérifier
                \item + : Consommation d'énergie minimale
                \item - : Peu flexible
            \end{itemize}
            \item \textbf{Coût} : en 2018, en moyenne, \$0.03 pour un µc 8-bit, \$1 pour un µc 32-bit $\rightarrow$ ratio $\frac{1}{100}$ par rapport à un PC grand public
        \end{itemize}

        \column{0.3\linewidth}
        \includegraphics[width=\columnwidth]{img/brain.png}
    \end{columns}
\end{frame}

\subsection{Arduino}

\begin{frame}{Arduino Uno : caractéristiques (ATmega328P)}
    \begin{columns}
        \column{0.65\linewidth}
        $\rightarrow$ Plateforme de \textbf{prototypage}

        $\rightarrow$ Permet de reprogrammer le système

        \begin{itemize}
            \item Alimentation : 7 à 12V ou via port USB (40 mA min.)
            \item Horloge : 16 MHz
            \item Mémoire SRAM : 2 kB
            \item Mémoire EEPROM : 1 kB
            \item Mémoire flash : 32 kB
            \item Broches d'E/S : D0 à D13 (40 mA par broche)
            \item Entrées analogiques : A0 à A5
            \item Bus série, I2C et SPI
            \item Gestion des interruptions
            \item Dimensions : 74 x 53 x 15 mm
        \end{itemize}

        \column{0.35\linewidth}
        \includegraphics[width=\columnwidth]{img/arduino-uno.jpg}
        \includegraphics[width=\columnwidth]{img/atmega328p.jpg}
    \end{columns}
\end{frame}

\begin{frame}{Arduino Uno : détails [\href{https://learn.sparkfun.com/tutorials/what-is-an-arduino\#whats-on-the-board}{réf.}]}
    \begin{columns}
        \column{0.5\linewidth}
        \includegraphics[width=\columnwidth]{img/arduino_uno_breakout.png}

        \column{0.5\linewidth}
        \begin{enumerate}
            \item ...
            \item ...
            \item ...
            \item ...
            \item ...
            \item ...
            \item ...
            \item ...
            \item ...
            \item ...
            \item ...
            \item ...
            \item ...
            \item ...
        \end{enumerate}
    \end{columns}
\end{frame}

\begin{frame}{Arduino Uno : détails [\href{https://learn.sparkfun.com/tutorials/what-is-an-arduino\#whats-on-the-board}{réf.}]}
    \begin{columns}
        \column{0.5\linewidth}
        \includegraphics[width=\columnwidth]{img/arduino_uno_breakout.png}

        \column{0.5\linewidth}
        \begin{enumerate}
            \item Connecteur USB
            \item Connecteur \textit{barrel jack}
            \item Pins \textbf{GND} (masse) : référentiel 0V
            \item Pin \textbf{5V}
            \item Pin \textbf{3.5V}
            \item Pins \textbf{analogiques} (Entrées) -- A0 à A5
            \item Pins \textbf{numériques} (E/S) -- 0 à 13
            \item Pins \textbf{numériques} (PWM) -- 3, 5, 6, 9, 10, 11
            \item Pin \textbf{AREF} : référentiel plafond en tension
            \item Bouton \textit{reset}
            \item Témoin d'alimentation
            \item Témoins \textbf{Tx / Rx}
            \item Circuit intégré \textbf{ATmega328P}
            \item Régulateur de tension (sécurité)
        \end{enumerate}
    \end{columns}
\end{frame}

\begin{frame}{Arduino Uno : \textit{shields}}
    \begin{center}
        \includegraphics[width=0.7\linewidth]{img/arduino-uno-shields.jpg}
        \url{https://www.shieldlist.org/}
    \end{center}
\end{frame}

\subsection{Programmation}

\begin{frame}[fragile]{Programmation Arduino -- Pas de système d'exploitation !}
    \begin{minted}{c}
        void setup() {
        // put your setup code here, to run once:

        }

        void loop() {
        // put your main code here, to run repeatedly:

        }
    \end{minted}
\end{frame}

\begin{frame}{Programmation Arduino -- Lectures, écritures}
    \begin{columns}
        \column{0.5\linewidth}
        \begin{itemize}
            \item \textbf{GPIO} : \textit{General-Purpose Input Output}
            \item Lecture analogique : tension sur un \textit{pin}
            \begin{itemize}
                \item Conversion analogique vers numérique (\textit{ADC})
                \item $[0.0, 5.0[V \rightarrow int [0, 1024[$
                \item Précision : 10 bits, résolution : 4.9 mV/valeur
            \end{itemize}
            \item Lecture/Écriture numérique : états binaires
            \begin{itemize}
                \item $0$ (\texttt{LOW}, 0V)
                \item $1$ (\texttt{HIGH}, 3.3V ou 5V)
            \end{itemize}
            \item Écriture analogique ?
            \begin{itemize}
                \item Le microcontrôleur ne peut pas générer une tension arbitraire...
            \end{itemize}
        \end{itemize}

        \column{0.5\linewidth}
        \begin{center}
            \includegraphics[width=0.8\columnwidth]{img/pwm.png}
        \end{center}

        \begin{itemize}
            \item Décrire un phénomène continu par des modulations
            \item Technique : \textit{PWM}
        \end{itemize}
    \end{columns}
\end{frame}

\begin{frame}{Programmation Arduino -- Exercice}
    \begin{exampleblock}{Un premier programme Arduino}
        On utilise le simulateur :

        \begin{itemize}
            \item \href{https://wokwi.com/projects/new/arduino-uno}{https://wokwi.com/projects/new/arduino-uno}
        \end{itemize}
    \end{exampleblock}

    \begin{enumerate}
        \item \TODO Écriture numérique : allumer puis éteindre une LED sur le pin 5 ;
        \item \TODO Écriture analogique : faire varier l'intensité de la LED pour produire un effet de fondu, en boucle.
    \end{enumerate}
\end{frame}

\subsection{Entrées/Sorties}

\begin{frame}{Communications série : UART [\href{http://bts2m.free.fr/TP_Arduino/01_UART.html}{réf.}]}
    \begin{itemize}
        \item \textbf{UART} : \textit{Universal Asynchronous Receiver Transmitter}
        \item Convertit des données \textit{parallèles} (un octet en mémoire) en données \textit{série} (des bits sur un fil)
        \item Liaison avec 3 fils : \textbf{Tx} (\textit{transmit} de l'émetteur), \textbf{Rx} (\textit{receive} du récepteur), \textbf{GND} (masse)
        \item \textit{Full duplex} : émission et réception simultanées ; point à point : 2 éléments
        \item Vitesse : en général 9600 bauds (bits/seconde), au maximum 115200 bauds (environ 14 kB/seconde...)
        \item "Masqué" derrière le port USB de l'Arduino !
    \end{itemize}

    \begin{center}
        \includegraphics[width=0.6\linewidth]{img/uart.png}
    \end{center}
\end{frame}

\begin{frame}{Communications série : I2C [\href{https://passionelectronique.fr/liaisons-series-uart-i2c-spi/}{réf.}]}
    \begin{itemize}
        \item \textbf{I2C} : \textit{Inter-Integrated Circuit}
        \item Topologie "maître-esclave", adresses uniques, bits de lecture/écriture
        \item Liaison avec trois fils : \textbf{SDA} (signal de données), \textbf{SCL} (signal d'horloge), \textbf{GND} (masse)
        \item \textit{Semi duplex} : communications bidirectionnelles, mais pas simultanées ; multi-points
        \item Vitesse : en général 100 kbps (10x plus rapide que l'UART), au maximum 3.4 Mbps (environ 425 kB/seconde)
    \end{itemize}

    \begin{center}
        \includegraphics[width=0.6\linewidth]{img/i2c.jpg}
    \end{center}
\end{frame}

\begin{frame}{Communications sans-fil : Zigbee}
    \begin{itemize}
        \item \textbf{Zigbee} : protocole / norme ouverte IEEE 802.15.4
        \item Topologie en maillage (\textit{mesh})
        \item Communications sans-fil courte distance (10 mètres @ 1 mW)
        \item Bande de fréquences non réservée : pas de licence
        \item Vitesse : 2.5 à 30 kB/seconde ; très faible consommation d'énergie
    \end{itemize}

    \begin{center}
        \includegraphics[width=0.6\linewidth]{img/zigbee-chart.png}
    \end{center}
\end{frame}

\begin{frame}
    \begin{center}
        \includegraphics[width=0.9\linewidth]{img/zigbee-table.png}
    \end{center}
\end{frame}

\section{Robotique}

\subsection{Généralités}

\begin{frame}{Qu'est-ce qu'un robot ?}
    \begin{center}
        \includegraphics[width=0.5\linewidth]{img/sojourner-mars.jpg}

        \footnotesize \textit{Sojourner} sur la surface de Mars, décembre 1997 [\href{https://science.nasa.gov/photojournal/sojourner-rover-near-the-dice/}{réf.}]
    \end{center}
\end{frame}

\begin{frame}{Qu'est-ce qu'un robot ?}
    \textbf{Robot = système de systèmes}

    \begin{itemize}
        \item \textbf{Mobilité} : énergie, déplacement (propulsion), orientation (direction)
        \item \textbf{Charge utile} : capteurs, informations, matériels, etc.
        \item \textbf{Intelligence} : contrôle, commande, communication, décision
    \end{itemize}
\end{frame}

% \begin{frame}{Capteurs -- Classes}
%     \begin{itemize}
%         \item Proprioceptifs :
%         \begin{itemize}
%             \item Attitude, position, vitesse, etc.
%             \item Donnent des informations sur l'état de l'élément piloté
%         \end{itemize}
%         \item Extéroceptifs
%         \begin{itemize}
%             \item Localisation, obstacles, etc.
%             \item Donnent des informations sur l'environnement de l'élément piloté
%         \end{itemize}
%         \item Actifs
%         \begin{itemize}
%             \item Sonar, radar, LiDAR, etc.
%         \end{itemize}
%         \item Passifs
%         \begin{itemize}
%             \item Contacts, acoustique, gyroscope, etc.
%         \end{itemize}
%     \end{itemize}
% \end{frame}

\begin{frame}{Intelligence -- Capteurs [\href{https://spe-lavoisier.fr/1SI/Cours/Chapitre4.php}{réf.}]}
    \begin{columns}
        \column{0.5\linewidth}
        Caractéristiques d'un capteur :
        \begin{itemize}
            \item Temps de réponse
            \item Fréquence d'échantillonnage
            \item Précision, finesse, résolution, stabilité
            \item Coût
            \item Taux d'erreur (dispersion, aberrations, etc.)
            \item Robustesse (environnement)
            \item Charge de calcul induite
            \item Poids, consommation d'énergie, dimensions, etc.
        \end{itemize}

        \column{0.5\linewidth}
        \includegraphics[width=\columnwidth]{img/sensor-error.png}
    \end{columns}
\end{frame}

\begin{frame}{Intelligence -- Contrôle, commandes, asservissement}
    \begin{itemize}
        \item Éléments contrôlés en boucle fermée : \textbf{asservissements}
        \item Système automatique qui ajuste son comportement en fonction de \textbf{consignes} et de \textbf{mesures}
        \item Exemple :
        
        \begin{exampleblock}{\emoji{repeat} Boucle d'asservissement}
            \begin{enumerate}
                \item \emoji{dart} \textbf{Consigne} : objectif à atteindre (ex : avancer à 10 cm du mur)
                \item \emoji{bar-chart} \textbf{Mesure} : capteur qui lit la position (GPS), la distance réelle (LiDAR), etc.
                \item \emoji{cross-mark} \textbf{Erreur} : différence entre consigne et mesure
                \item \emoji{brain} \textbf{Contrôleur} : calcule la \textbf{commande} à partir de l'erreur
                \item \emoji{robot} \textbf{Commande} : signal envoyé au système (ex : augmenter la vitesse des moteurs)
            \end{enumerate}
        \end{exampleblock}
    \end{itemize}    
\end{frame}

\subsection{Commande à distance}

\begin{frame}{Commande -- Un langage pour se parler}
    \begin{itemize}
        \item Architecture :
        \begin{itemize}
            \item PC : Envoi de commandes filaire $\rightarrow$ USB $\rightarrow$ Robot Arduino
            \item PC : Envoi de commandes sans fil $\rightarrow$ XBee $\rightarrow$ Robot Arduino
        \end{itemize}
        \item Peu importe le type de liaison, le même programme s'exécute sur l'Arduino
        \item $\rightarrow$ Il faut programmer l'Arduino pour \textbf{recevoir}, \textbf{décoder} et \textbf{exécuter} des lignes de commande.
    \end{itemize}
\end{frame}

\begin{frame}{Commande -- Capteurs et actionneurs}
    \begin{alertblock}{Sur nos robots...}
        \begin{itemize}
            \item De quels capteurs disposons-nous ?
            \item De quels actionneurs disposons-nous ?
        \end{itemize}        
    \end{alertblock}
\end{frame}

\begin{frame}{Commande -- Un langage pour se parler}
    \begin{alertblock}{Communications}
        \begin{itemize}
            \item Objectifs : avancer, reculer, tourner...
            \item Quels éléments va-t-on commander ?
            \item Sur la base de quelles informations ?
            \item $\rightarrow$ De quelles \textbf{commandes} avons-nous besoin ?
        \end{itemize}
    \end{alertblock}
\end{frame}

\begin{frame}{Commande -- Un langage pour se parler -- Syntaxe}
    \begin{itemize}
        \item Une ligne de commande peut contenir :
        \begin{itemize}
            \item Une commande élémentaire : \texttt{[cmd]}
            \item Une séquence de commandes élémentaires : \texttt{[[cmd\_1][cmd\_2]]}
        \end{itemize}
        \item Une commande peut prendre un paramètre : \texttt{[cmd param]}
        \begin{itemize}
            \item Séparation par un espace
        \end{itemize}
    \end{itemize}

    \begin{exampleblock}{Exemple de ligne de commande}
        \texttt{[[mda 255][mga 255]]}
    \end{exampleblock}
\end{frame}

\subsection{Interface utilisateur}

\begin{frame}[fragile]{Programmation Node.js}
    \begin{itemize}
        \item Langage : \textbf{JavaScript}
        \item Programmation \textbf{asynchrone}, ou \textbf{événementielle}
    \end{itemize}

    \vspace{20px}

    \begin{minted}{javascript}
        // Charger une bibliothèque
        const { Something } = require('something');

        // Instancier un objet
        const thing = new Something({ "some": "value" });

        // Écouter un événement
        thing.on('someEvent', (data) => {
            // Faire quelque chose...
            console.log(data);
        });
    \end{minted}
\end{frame}

% \begin{frame}{IHM}
%     ...
% \end{frame}

\subsection{Comportement autonome}

\begin{frame}{Comportement autonome -- Origines historiques}
    \begin{columns}
        \column{0.5\linewidth}
        \begin{itemize}
            \item Sans régulation : la machine peut \textbf{accélérer dangereusement} ou \textbf{ralentir}
            \item Problèmes de sécurité et de fiabilité
            \item $\rightarrow$ Comment stabiliser la vitesse des machines à vapeur (moulins, locomotives, etc.) ?
        \end{itemize}

        \column{0.5\linewidth}
        \begin{center}
            \includegraphics[width=\columnwidth]{img/mulhouse_electropolis.jpg}

            {\footnotesize Machine à vapeur Sulzer et alternateur Brown Boveri (Electropolis, Mulhouse)}
        \end{center}
    \end{columns}
\end{frame}

\begin{frame}{Comportement autonome -- Théorie du contrôle}
    \begin{columns}
        \column{0.3\linewidth}
        \includegraphics[width=\columnwidth]{img/regulateur_huygens.jpg}

        \column{0.7\linewidth}
        \begin{itemize}
            \item Comment stabiliser la vitesse des machines à vapeur (moulins, locomotives, etc.) ?
            \item \textbf{Régulateur à boules} pour machines à vapeur (James Watt \emoji{flag-scotland}) (XX~\textsuperscript{ème})
            \item Plus la machine accélère, plus les boules s'écartent, réduisant l'arrivée de vapeur $\rightarrow$ diminution de la vitesse
            \item Initialement proposé par Christian Huygens \emoji{flag-netherlands} (XVII~\textsuperscript{ème})
            \item Principe purement mécanique
            \item Limites :
            \begin{itemize}
                \item Réponse lente
                \item Pas de correction d'erreur persistante
                \item Pas d'anticipation des variations rapides
                \item Pas adapté aux systèmes numériques !
            \end{itemize}
        \end{itemize}
    \end{columns}
\end{frame}

\begin{frame}{Comportement autonome -- Théorie du contrôle}
    \begin{columns}
        \column{0.4\linewidth}
        \begin{itemize}
            \item \textbf{PID} : mis en équation en 1922 par Nicolas Minorsky \emoji{flag-russia}
            \item Testé sur un cuirassé de l'US Navy, l'USS New Mexico
            \item En pilotage automatique, en partant d'une erreur de 2 degrés, le navire a pu faire mieux qu'un barreur humain en maintenant son cap avec une précision d'1/3 de degré
        \end{itemize}

        \column{0.6\linewidth}
        \includegraphics[width=\columnwidth]{img/uss_new_mexico.jpg}
    \end{columns}
\end{frame}

\begin{frame}{Contrôle -- Fonctionnement du PID}
    \begin{center}
        \textit{Feedback loop} : stabiliser automatiquement des systèmes en s'appuyant sur les comportements passés

        \vspace{16px}

        \includegraphics[width=0.8\linewidth]{img/pid.png}
    \end{center}
\end{frame}

\begin{frame}{Contrôle -- Fonctionnement du PID}
    Équation du PID en version discrète (pour une implantation numérique) :

    \begin{equation}
        u[n] = K_p \cdot e[n] + K_i \cdot \sum_{i=0}^{n} e[i] + K_d \cdot (e[n] - e[n-1])
    \end{equation}
\end{frame}

\begin{frame}{Contrôle -- Fonctionnement du PID}
    Équation du PID en version discrète (pour une implantation numérique) :

    \begin{equation}
        u[n] = K_p \cdot e[n] + K_i \cdot \sum_{i=0}^{n} e[i] + K_d \cdot (e[n] - e[n-1])
    \end{equation}

    \begin{itemize}
        \item Composante $p$ : correction proportionnelle à l'erreur
        \begin{itemize}
            \item \emoji{cross-mark} Problème : erreur persistante $\rightarrow$ délai de correction très long
        \end{itemize}
        \item Composante $i$ : correction proportionnelle à la somme des erreurs précédentes
        \begin{itemize}
            \item \emoji{cross-mark} Problème : instabilité de la trajectoire $\rightarrow$ oscillations
        \end{itemize}
        \item Composante $d$ : correction prédictive basée sur la variation de l'erreur
        \begin{itemize}
            \item \emoji{check-mark} L'erreur augmente $\rightarrow$ on "accélère" la correction
            \item \emoji{check-mark} L'erreur diminue $\rightarrow$ on "freine" la correction
        \end{itemize}
    \end{itemize}
\end{frame}

\begin{frame}{Contrôle -- Objectifs du PID}
    \centering
    \begin{tabular}{
        >{\centering\arraybackslash}p{0.45\linewidth}
        >{\centering\arraybackslash}p{0.45\linewidth}
    }
        \textbf{Sans PID} & \textbf{Avec PID} \\[4pt]
        \midrule \\
        \textcolor{red!70!black}{Réactions brutales} & \textcolor{green!50!black}{Réactions fluides} \\[6pt]
        \textcolor{red!70!black}{Oscillations} & \textcolor{green!50!black}{Stabilité} \\[6pt]
        \textcolor{red!70!black}{Dépassement} & \textcolor{green!50!black}{Précision} \\
    \end{tabular}
\end{frame}

\subsection{Calcul déporté}

\begin{frame}{Calcul déporté -- Une affaire de compromis}
    \begin{itemize}
        \item Il est possible de réaliser une partie des calculs sur le PC qui commande le robot
        \item Mais...
    \end{itemize}

    \vspace{16px}

    \begin{exampleblock}{Avantages, inconvénients ?}
        \begin{itemize}
            \item Quels sont ici les \textbf{compromis} à réaliser ?
            \item Comment appelle-t-on un tel système ?
        \end{itemize}
    \end{exampleblock}
\end{frame}

\begin{frame}{Calcul déporté -- Une affaire de compromis}
    \begin{itemize}
        \item Compromis techniques :
        \begin{itemize}
            \item \textbf{Temps de calcul} : PID simple adapté à l'Arduino Uno ?
            \item \textbf{Mémoire} : quel historique des erreurs peut-on stocker ?
            \item \textbf{Énergie} : gains avec le PID ?
            \item \textbf{Latence} : calcul local = réponse rapide
        \end{itemize}
    \end{itemize}
\end{frame}

% \section{Présentation du robot}

% \begin{frame}{Inventaire (\textit{Bill of Material})}
%     \begin{center}
%         \includegraphics[width=0.5\linewidth]{img/point.png}
%     \end{center}
% \end{frame}

\appendix

\section{Bibliographie}

\begin{frame}[allowframebreaks]{Références}
    \printbibliography[heading=none]
\end{frame}

% \appendix

% \section{Annexes}

% \begin{frame}{Annexe 1 -- ...}
% \end{frame}

\end{document}
