Matomo/interfaces club
Objectifs du module info.
La carte PC a accès à deux ressources indépendantes : la carte électronique et la caméra firewire.
Son but est donc de les utiliser au mieux afin de jouer le plus intelligemment (ou plutôt efficacement) possible.
Le programme doit aussi être facilement configurable et pratique à déboguer, notamment en vue d'un changement tactique de dernière minute.
Unités.
Cette partie pourrait presque faire partie du guide de style, elle concerne les unités utilisés par les interfaces.
Si pour une raison ou une autre une autre unité est utilisée, il faudra préciser clairement dans le commentaire et dans le nom de la fonction ou de la variable quelle unité est utilisée.
Numérotation des éléments du terrain.
Voir les schémas annexes...
On considère que les éléments sont fixes et que c'est le robot qui démarre d'un cote ou de l'autre.
Les éléments importants du terrain sont numérotés de la façon suivante :
Description des couches et modules.
Comme le montre le diagramme UML, le programme est divisé en couche représentant différents niveaux d'abstraction permettant de passer du protocole de communication avec le matériel, au niveau le plus abstrait qui permet de faire jouer un match complet en quelques lignes de script.
Légende des priorités.
Il existe un système de priorité de développement pour organiser le développement. 
3 niveaux de priorités :
Couche "Auxiliaires Globaux".
Cette couche regroupe l'ensemble des modules pouvant servir à plusieurs niveaux, on y retrouve typiquement des modules de débogages, de configurations, des définitions de types globaux ou des modules facilitant le codage (plus spécifique au C++).
Types Globaux.
Ce sont tous les types qui ne sont pas spécifiques à un module, et qui pourront donc être employés par plusieurs couches différentes. On a notamment des types permettant de spécifier des positions.
 Priorité globale : ***
 typedef int64;
 typedef uint64;
 typedef int32;
 typedef uint32;
 typedef int16;
 typedef uint16;
 typedef int8;
 typedef uint8;
 class cRange
 bool IsInRange(float value);
 float GetNearestValueFrom(float value);
 class cPos3D
 cVector4D GetCoordInBase(const cBase &);
 void SetCoordInBase(const cBase &, const cVector4D &);
 class cBase
 cBase(cBase *Parent);
 SetPosition(const cVector3D&), Rotate();
 cBase RepereAbsolu;
 cBase RepereRobot;
On utilise deux repères globaux à l'application : 
Math.
Primitives mathématiques diverses qui servent en particulier au positionnement (matrice4x4, vecteur3d)
 Priorité globale : ***
 class cMatrix4x4
 //opérations basiques sur les matrices :
 //addition, multiplication... (avec une autre matrice ou un scalaire)

class cVector4D
 //opérations basiques sur les vecteurs:
 //addition, multiplication... (avec un autre vecteur, un scalaire ou une matrice)
+ fonctions permettant de créer des matrices de rotation, translation...
Constantes Globales.
Constantes généralement en relation avec le règlement, le terrain ou la mécanique du robot.
 FIELD_WIDTH
 FIELD_HEIGHT
 HOLE_RADIUS
 BALL_RADIUS
 TOTEM_RADIUS
 BALL_NB
 HOLE_NB
Voir la section sur la numérotation des éléments du terrain.
 HOLE_POSITION[x][y]
 TOTEM_POSITION[x][y]
 BALL_START_POSITION[x][y]
 BEACON_POSITION[x][y]
Helpers divers et Abstraction OS.
Couche d'abstraction avec le système d'exploitation.
En particulier il s'agit d'objets simplifiant :
 Priorité globale : ***
 class cMutex
 Lock();
 Release();
 class cEvent
 Wait();
 Set();
+Gestionnaire d’événement/message avec des fonctions du style :
LinkEventToCallback(event, callback);
// Problème de durée de vie des événements ?
class cThread
 virtual int32 threadMain();
//Automatise la protection de variable avec un mutex
template 
class cProtectedData<typename T>
 T Get();
 void Set(const &T);
 //Classe permettant de modifier l'objet directement
 //(sans en faire de copie)
 class Accessor;
// Idem cProtectedData, mais stocke la variable en
// plusieurs exemplaires (technique du backbuffering)
template
class cBufferedData<typename T>
template class cSingleton<typename>;
uint64 GetCurrentTick();
uint64 GetTickFrequency();
date GetTodayDate();
 Priorité : **
 //Classes mères de client/serveur TCP/IP
 class cTCPIPServer;
 class cTCPIPClient;
Voir doc spécifique OSAL.
Timer.
Le timer peut envoyer des évènements à certains moments clefs du match. On peut aussi lui demander de lever un évènement toutes les x secondes. Il permet en plus de chronométrer, et de profiler facilement certaines parties du code.
 Priorité globale : **
 (seule sont indispensables les méthodes permettant de connaître la fin du match, et de calculer un temps simplement et précisément)
 uint64 GetCurrentTick();
 uint64 GetTickFreq();
 void MatchBeginNow();
 uint32 GetMsAfterBeginning();
 uint32 GetMsBeforeEnd();
 [IT]: EndOfMatch();
 [IT]: TimeBeforeEnd(int sec);
 [IT]: TimeAfterBeginning(int sec);
 [IT]: WarnMeIn(int ms);
 [IT]: WarnMeEvery(int ms);
 class cProfiler - Priorité : *
 SegmentStart();
 SegmentEnd();
 GetAveragePeriod();
 GetAverageFrequency();
 GetCallNumber();
IHM/Debug.
Le but de ce module est de faciliter le debuggage (éventuellement à distance). On y retrouve des classes permettant de logguer du texte, de tracer des courbes, d'afficher des images à l'écran assez facilement ou encore de lire le clavier de manière asynchrone.
 //Classe de log, fournit des ostream (type cout)
 //l'affichage se fait dans des consoles graphiques
 class cLog - Priorité : ***
 static std::ostream &Debug();
 static std::ostream &Error();
 static std::ostream &Info();
 //type de figure pouvant etre dessine sur le terrain2D
 class cPattern - Priorité : **
 Move(const cPos2D &);
 Hide(); / Show();
 Blink(hz);

//Fenetre d'affichage de terrain vue du dessus
 class cFieldDisplayer - Priorité : **
 cPattern *AddPattern(Dot/Pixel/Line/Cross/Circle/Square + color);
 [IT]: OnMouseClick() + GetMousePos()
 //Fenêtre d'affichage vidéo
 class cVideoDisplayer - Priorité : ***
 DrawPicture(rgb);
 //Fenetre d'affichage de courbe
 class cPlotDisplayer - Priorité : *
 AddPoint(x, y);
 SetScale(minX, maxX, minY, maxY);
 //La fonction callback prend en paramètre l'id de la touche pressée
 Priorité : **
 [IT] OnKeyPressed();
 [IT] OnSpecKeyPressed(keyid);
Config Manager.
Le Config Manager permet de configurer les constantes de chaque module au démarrage du programme. Il pourra par exemple lire ces constantes depuis un fichier de script (type .ini ou .xml).
 class Config - Priorité : **
 void Load(file);
 int32 GetVar(string);
Couche IA (Intelligence Artificielle).
Il s'agit de la couche décisionnelle de plus haut niveau : à terme la tactique devrait être programmé uniquement dans ces modules.
IA/Script.
 Priorité : *
Il s'agit du module le plus haut : c'est lui qui prend les décisions, il peut éventuellement se servir d'un fichier de script (type Python ou Lua) pour lire les actions qu'il doit exécuter.
Il n'y a pas réellement d'interface pour ce module étant donné que c'est à lui d'utiliser les autres modules. Par contre si on décide d'utiliser un fichier de script, il faudra définir des fonctions "glues" permettant d’appeler les fonctions haut niveau du programme C++ depuis le script.
On récupère une balle a une position sure et on va la déposer dans le trou le plus simple.
 onStarter()
 cParallelLinePath path1;
 cBallPickupWP wp1(BALL_START_POSITION(B1.1));
 path1.push(wp1);
 Controler::Run(path1);

~ Approximatif : ~
 onBallPickupReached(-400)
 Automatisme::ActivateRollerDuring(800);
 ~
 onNewBallInEjector()
 Controler::Stop();
 cParallelLinePath path2;
 if(Automatisme::GetBallColor(LEFT_EJECTOR) == WHITE_BALL)
 cBallDropping wp2(LEFT_EJECTOR, HOLE_POSITION(H2.1));
 else if(Automatisme::GetBallColor(RIGHT_EJECTOR) == WHITE_BALL)
 cBallDropping wp2(RIGHT_EJECTOR, HOLE_POSITION(H2.1));
 path2.push(wp2);
 Controler::Run(path2);