Agrégation informatique externe 2026, épreuve 3, option ingénierie informatiqueSujet

AGRÉGATION
CONCOURS EXTERNE

CONCEPTION PRÉLIMINAIRE D'UN SYSTÈME, D'UN PROCÉDÉ OU D'UNE ORGANISATION

Table des matières

INFORMATION AUX CANDIDATS

Ces codes doivent être reportés sur chacune des copies que vous remettrez.

Robot agricole autonome de l'INRAE

Présentation du système

Figure 1 : tracteur électrique ALPO de SABI-AGRI dans le contexte de la ferme expérimentale de Montoldre (Allier) ^1

Présentation du contexte

Robots de l'équipe ROMEA

Figure 2 : doubles numériques des robots de l'unité de recherche TSCF

• -véhicules à direction par dérapage (Skid steering vehicles) :
  • -Effibote3, Scout, Husky : 4 roues motrices (4 wheel drive vehicle noté 4WD) ;
  • -Ceol : 2 chenilles (2 track drive vehicle : 2TD) ;
• -véhicules à un essieu directeur (One axle steering vehicles) :
  • -Hunter, Cinteo : 1 roue directrice avant + 2 roues motrices arrières (1 front steering axle +2 rear wheel drive vehicle : 1FAS2RWD) ;
• -véhicules à deux essieux directeurs (Two axle steering vehicles) :
  • -Robucar : 2 steering axles + 4 rear wheel drive vehicle (2AS4RWD) ;
• -véhicules à deux roues directrices (Two wheel steering vehicles) :
  • -Alpo Slim : 2 front wheel steering + 4 wheel drive vehicle (2FWS4WD) ;
  • -Alpo Fat : 2 front wheel steering + 2 rear wheel drive vehicle (2FWS2RWD) ;
• -véhicules à quatre roues directrices (Four wheel steering vehicles) :
  • -Adap2e : 4 wheel steering + 4 wheel drive vehicle (4WS4WD).

ROS (Robot Operating system)

• -nœuds (nodes) : un nœud exécute un processus qui effectue une tâche spécifique, comme le contrôle des moteurs ou le traitement des données des capteurs ;
• -topics : les topics sont des canaux de communication asynchrones utilisés par les nœuds pour échanger des messages. Un nœud peut publier des messages sur un topic, et d'autres nœuds peuvent s'abonner à ce topic pour recevoir les messages. Les topics permettent un découplage temporel et spatial entre les nœuds. Les nœuds n'ont pas besoin de connaître l'existence les uns des autres pour communiquer. Ils se contentent de publier ou de s'abonner à des topics spécifiques ;
• -services : les services permettent une communication bidirectionnelle synchrone entre les nœuds. Un nœud peut offrir un service, et un autre nœud client peut appeler ce service pour obtenir une réponse ;
• -actions : les actions permettent une communication asynchrone avec des mises à jour de progression (feedback). Le nœud client peut recevoir des mises à jour régulières sur l'état de la tâche en cours ;
• -messages : les messages sont des structures de données utilisées pour transmettre des informations entre les nœuds. Ils sont définis à l'aide de fichiers de description de message ;
• -paramètres : un paramètre est une valeur configurable qui peut être définie, modifiée et lue par un nœud (node) pendant son exécution. Les paramètres permettent de personnaliser le comportement d'un nœud sans avoir à recompiler le code.

Figure 3 : diagramme d'activité ROS2 ^2

• -/robot/base/controller/kinematic ;
• -/robot/base/controller/odom ;
• -/robot/base/controller/odometry.

Système de l'étude

• -électrique et écologique : le tracteur ALPO est entièrement électrique, émettant zéro CO2, ce qui contribue à la transition agroécologique ;
• -polyvalence et robotisation : il est adapté à diverses cultures et peut être utilisé comme valet de ferme ou tracteur principal. Sa conception permet une automatisation complète pour des tâches agricoles variées ;
• -collaboration avec le robot ZILUS : dans le cadre de l'Accord Robotique, le tracteur ALPO travaille en tandem avec le robot tout-terrain ZILUS. Ensemble, ils réalisent des opérations culturales complémentaires, optimisant le temps et réduisant la pénibilité pour les agriculteurs.

Figure 4 : robot autonome ALPO

• -la première partie est consacrée à l'analyse de la commande du robot à partir de sa géométrie ;
• -la deuxième partie s'intéresse aux capteurs permettant au robot de se localiser dans son environnement ;
• -la troisième partie s'intéresse à l'amélioration de la précision de la localisation ;
• -la quatrième partie traitera de la sauvegarde des trajets dans une base de données et des aspects sécuritaire liés à son utilisation.

Partie 1 : Algorithmes de pilotage

Sous-partie 1.1 : Code de publication et de souscription aux topics

Figure 5 : schéma de la géométrie du robot ALPO

• - l = LR = L^′ R^′ : voie (whee/Track) ;
• - W = LL^′ = RR^′ : empattement (wheelBase) ;
• - l/2 = O_R R^′ = L^′ O_R : demie voie (halfTrack) ;
• - φ_L : Angle de braquage avant gauche (frontLeftSteeringAngle) ;
• - φ_R : Angle de braquage avant droit (frontRightSteeringAngle) ;
• - φ : Angle de braquage du tricycle équivalent (SteeringAngle) ;
• - R_(robot) = (O_R, x_R^(→−), y_R^(→−)) : repère lié au robot ALPO ;
• - θ : Angle entre x⃗ et x_R^(→−);
• - R = (O, x⃗, y⃗) : repère du monde.

float64 longitudinal_speed # m/s
float64 front_steering_angle # rad

#include "rclcpp/rclcpp.hpp"
#include " romea_mobile_base_msgs/OneAxleSteeringCommand.hpp"
int main(int argc, char * argv[])
{
    rclcpp::init(argc, argv);
    auto node = rclcpp::Node::make_shared("minimal_alpo_publisher");
    auto publisher = node->create_publisher<romea_mobile_base_msgs::msg::OneAxleSteeringCommand>(
        "/robot/base/cmd_one_axle_steering", 10);
    rclcpp::WallRate loop_rate(100ms);
    auto message = romea_mobile_base_msgs::msg::OneAxleSteeringCommand();
    message.longitudinal_speed = 1.0;
    message.steering_angle = 0.0;
    RCLCPP_INFO(node->get_logger(), "Publication sur /robot/base/cmd_one_axle_steering");
    while (rclcpp::ok()) {
        publisher->publish(message);
        rclcpp::spin_some(node);
        loop_rate.sleep();
    }
    rclcpp::shutdown();
    return 0;
}

#include "rclcpp/rclcpp.hpp"
#include "romea_mobile_base_msgs/OneAxleSteeringCommand.hpp"
int main(int argc, char * argv[])
{
    rclcpp::init(argc, argv);
    auto node = rclcpp::Node::make_shared("minimal_alpo_subscriber");
    auto subscription = node-
>create_subscription<romea_mobile_base_msgs::msg::OneAxleSteeringCommand>(
        "/robot/base/controller/cmd_one_axle_steering", 10,
        [](romea::core::OneAxleSteeringCommand::SharedPtr msg) {
            printf("Speed: %.2f m/s, Angle: %.2f rad\n",
                msg->longitudinal_speed, msg->steering_angle);
        });
    rclcpp::spin(node);
    rclcpp::shutdown();
    return 0;
}

Sous-partie 1.2 : Equations cinématiques

Sous-partie 1.3 : Code pour piloter le robot ALPO

template<typename InterfaceType, typename KinematicType>
class MobileBaseController : public controller_interface::ControllerInterface
{
    ...
using MobileBaseController2FWS2RWD =
        MobileBaseController<ControllerInterface2FWS2RWD, core::TwoWheelSteeringKinematic>;
using MobileBaseController2FWS4WD =
        MobileBaseController<ControllerInterface2FWS4WD, core::TwoWheelSteeringKinematic>;
using MobileBaseController2WD =
        MobileBaseController<ControllerInterface2WD, core::SkidSteeringKinematic>;
    ...
}

Sous-partie 1.4 : Odométrie

Figure 6 : schéma du robot ALPO dans le repère R

romea::ros2::DeadReckoning
- previous_update_time_ : std::optional< rclcpp :: Time >
- x_ : double
- y_ : double
- theta_ : double
- previous_longitudinal_speed_ : double
- previous_lateral_speed_ : double
- previous_angular_speed_ : double
+ DeadReckoning() «constructor>
+ update(time : const rclcpp::Time&, kinematic_measure : const core::KinematicMeasure&)
+ getX() : const double&
+ getY() : const double&
+ getTheta() : const double&
+ reset()

struct KinematicMeasure
{
    KinematicMeasure();
    double longitudinalSpeed;
    double lateralSpeed;
    double angularSpeed;
    double instantaneousCurvature;
    Eigen::Matrix4d covariance;
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};

void DeadReckoning::update(
    const rclcpp::Time & time,
    const core::KinematicMeasure & kinematic_measure)
{
    if (previous_update_time_.has_value()) {
        double dt = (time - *previous_update_time_).seconds();
        //A compléter sur votre copie
}

• Question 16 : Écrire le modèle de classe (template) between0And2Pi() permettant de retourner un angle compris entre 0 et 2π pour un angle passé en paramètre compris entre − 4π et 4π.

Sous-partie 1.5 : Code commande moteurs

bool AlpoHardware::send_data_(uint32_t id)
{
    try {
        drivers::socketcan::CanId can_id(id, 0, 8);
        can_sender_.send(sended_frame_data_.data(), 8, can_id, TIMEOUT);
        return true;
    } catch (drivers::socketcan::SocketCanTimeout & e) {
        RCLCPP_ERROR_STREAM(
            rclcpp::get_logger("AlpoHardware"),
            "Send can data" << std::hex << id << ": timeout");
    } catch (std::runtime_error & e) {
        RCLCPP_ERROR_STREAM(
            rclcpp::get_logger("AlpoHardware"),
            "Send can data" << std::hex << id << ": " << e.what());
    }
    return false;
}

Sous-partie 1.6 : Pilotage des roues directrices

Figure 8 : schémas cinématiques (2D et 3D) de la direction de la roue du robot ALPO

• -La longueur variable selon la longueur de tige du vérin sortie AB = l = l_m ini + Δl;
• -La longueur de l'axe de roue constant BC = e;
• -La longueur entre l'attache du vérin et le pivot de roue AC = d;
• -La course du vérin : Δ l_max ;
• -Les points A, B et C sont dans le plan (x_R^(→−), y_R^(→−)).

/* Constantes géométriques */
#define D_CONSTANT 150.0f // Constante d en mm
#define E_CONSTANT 200.0f // Constante e en mm
#define LMINI_CONSTANT 100.0f // Constante l_mini en mm
#define DLMAX_CONSTANT 200.0f // Constante dl_max en mm
/* Adresses bus CAN */
#define CAN_ID_SETPOINTS_L1_L2 0x17 // Réception des consignes l1, l2
#define CAN_ID_FEEDBACK_P1_P2 0x26 // Envoi des positions p1, p2
/* Paramètres Fuzzy PID */
typedef struct {
    float kp, ki, kd;
    float integral;
    float prev_error;
    float output_min, output_max;
} FuzzyPID_t;
/* Variables globales */
volatile float setpoint_l1 = 150.0f, setpoint_l2 = 150.0f; // Consignes de longueur depuis CAN
volatile float setpoint_p1 = 0.0f, setpoint_p2 = 0.0f; // consignes d’angles calculées
volatile float actual_l1 = 0.0f, actual_l2 = 0.0f; // Longueurs réelles mesurées
volatile float actual_p1 = 0.0f, actual_p2 = 0.0f; // Angles vrais calculés
FuzzyPID_t pid1 = {.kp = 2.0f, .ki = 0.1f, .kd = 0.5f, .output_min = -100.0f, .output_max =
100.0f};
FuzzyPID_t pid2 = {.kp = 2.0f, .ki = 0.1f, .kd = 0.5f, .output_min = -100.0f, .output_max =
100.0f};
float calculate_length_from_angle(float angle);
float calculate_angle_from_length(float length);
float fuzzy_pid_compute(FuzzyPID_t *pid, float setpoint, float input, float dt);
void read_analog_sensors(void);
void calculate_angular_setpoints(void);
void send_positions_can(void);
void control_actuators(float cmd1, float cmd2);

void read_analog_sensors(void)
{
    uint32_t adc_value1, adc_value2;
    /* Lecture de la tension du potentiomètre 1 (CAN 0) */
    HAL_ADC_Start(&hadc);
    HAL_ADC_PollForConversion(&hadc, 100);
    adc_value1 = HAL_ADC_GetValue(&hadc);
    /* Lecture de la tension du potentiomètre 2 (CAN 1) */
    HAL_ADC_Start(&hadc);
    HAL_ADC_PollForConversion(&hadc, 100);
    adc_value2 = HAL_ADC_GetValue(&hadc);
    /* Conversion CAN vers longueurs */
    // A compléter sur votre copie
    actual_l1 =
    actual_12 =
}

1.6.1. BUS de données CAN

Partie 2 : Mise en œuvre des capteurs

Sous-partie 2.1 : Capteur IMU

2.1.1. Capteur XSense MTi-1

Figure 9 : mesures d'un capteur bruité en fonction du temps

• - μ : moyenne
• - σ^2 : variance

• - a_x : accélération vraie (m ⋅ s^(− 2))
• - z : mesure du capteur (m ⋅ s^(− 2))
• - P(a_x|z) : probabilité de l'accélération vraie sachant la mesure
• - P(z|a_x) : probabilité de la mesure sachant l'accélération vraie

Figure 10 : accélérations en fonction du temps

2.1.2. Algorithme ZeroVelocityEstimator

void OnlineVariance::update(const double & value)
{
    std::lock_guard<std::mutex> lock(mutex_);
    long long int integerValue = static_cast<long long int>(value * multiplier_);
    long long int squaredIntegerValue = integerValue * integerValue;
    sumOfData_ += integerValue;
    sumOfSquaredData_ += squaredIntegerValue;
    if (data_.size() != windowSize_) {
        data_.push_back(integerValue);
        squaredData_.push_back(squaredIntegerValue);
    } else {
        sumOfData_ -= data_[index_];
        sumOfSquaredData_ -= squaredData_[index_];
        data_[index_] = integerValue;
        squaredData_[index_] = squaredIntegerValue;
    }
    double average = sumOfData_ / (double(multiplier_) * data_.size());
    double squaredAverage = (sumOfSquaredData_) / double(squaredMultiplier_);
    double variance = (squaredAverage - data_.size() * average * average) / (windowSizeMinusOne_);
    average_ = average;
    variance_ = variance;

    index_ = (index_ + 1) % windowSize_;
}
bool ZeroVelocityEstimator::update(
    const double & accelerationAlongXBodyAxis,
    const double & accelerationAlongYBodyAxis,
    const double & accelerationAlongZBodyAxis,
    const double & angularSpeedAroundXBodyAxis,
    const double & angularSpeedAroundYBodyAxis,
    const double & angularSpeedAroundZBodyAxis)
{
    varAccelerationAlongXBodyAxis_.update(accelerationAlongXBodyAxis);
    varAccelerationAlongYBodyAxis_.update(accelerationAlongYBodyAxis);
    varAccelerationAlongZBodyAxis_.update(accelerationAlongZBodyAxis);
    varAngularSpeedAroundXBodyAxis_.update(angularSpeedAroundXBodyAxis);
    varAngularSpeedAroundYBodyAxis_.update(angularSpeedAroundYBodyAxis);
    varAngularSpeedAroundZBodyAxis_.update(angularSpeedAroundZBodyAxis);
    if (varAccelerationAlongXBodyAxis_.isAvailable()) {
        return varAccelerationAlongXBodyAxis_.getVariance() < accelerationVarianceThreshold_ &&
            varAccelerationAlongYBodyAxis_.getVariance() < accelerationVarianceThreshold_ &&
            varAccelerationAlongZBodyAxis_.getVariance() < accelerationVarianceThreshold_ &&
            varAngularSpeedAroundXBodyAxis_.getVariance() < angularSpeedVarianceThreshold_ &&
            varAngularSpeedAroundYBodyAxis_.getVariance() < angularSpeedVarianceThreshold_ &&
            varAngularSpeedAroundZBodyAxis_.getVariance() < angularSpeedVarianceThreshold_;
    } else {
        return false;
    }
}

Sous-partie 2.2 : Camera stéréo

2.2.1. Modélisation d'une caméra

2.2.1.1. Détermination des paramètres intrinsèques et extrinsèques

Figure 11 : schéma du sténopé non inverseur

• - C : centre optique (centre du plan image) de coordonnées C_X, C_y dans le repère R_s;
• - F : point focal ;
• - CF = focale f de la caméra ;
• - R_W : le repère du monde ;
• - R_c : le repère de la caméra ;
• - R_s : le repère du capteur de la caméra.

• -Pour un point 3D [XYZ]^T → s ⋅ [XYZ1]^T où s est un facteur d'échelle.

KL = [[694.73129118 0. 323.36232288]
    [ 0. 693.46394108 244.73613664]
    [ 0. 0. 1. ]]
KR= [[672.9993327 0. 317.45531544]
    [ 0. 670.58191223 248.92553524]
    [ 0. 0. 1. ]]

2.2.1.2. Caméra stéréo

Figure 12 : disparités pour une caméra stéréo

R = [[ 0.99986465 -0.01071751 0.01248304]
    [ 0.01119544 0.99918168 -0.03886691]
    [-0.01205627 0.0390014 0.99916642]]
t = [[ 0.15626554]
    [ 0.00094655]
    [-0.01880167]]

2.2.2. Appariement des points

Figure 13 : calcul de la similarité pour chaque bloc de l'image

def calculate_disparity(left_image, right_image, window_size):
    left_shape = left_image.shape
    height = left_shape[0]
    width = left_shape[1]
    disparity_map = np.zeros((height, width))
    //A compléter sur votre copie
    # calcul de la carte des disparités
        # calcul des disparités
        disparity_map[i, j] = np.abs(j - best_match)
    # Normalisation
    normalized_disparity_map = (disparity_map - np.min(disparity_map)) / (np.max(disparity_map) -
np.min(disparity_map)) * 255
    return disparity_map, normalized_disparity_map

2.2.3. Connexion avec ROS

mat.at<Type>(y, x)

2.2.4. Mise en œuvre de la caméra stéréo OAK D Lite

// A compléter
objectTracker->
...
while(pipeline.isRunning()) {
    auto imgFrame = preview->get<dai::ImgFrame>();
    auto track = tracklets->get<dai::Tracklets>();
    bool personDetected = false;
    float personZDistance = 0.0f;
    bool stopSignDetected = false;
    float stopSignZDistance = 0.0f;
    auto trackletsData = track->tracklets;
    for(const auto& t : trackletsData) {
    // A compléter sur votre copie

    // Créer et publier le message
    auto message = camera::msg::PersonDetection();
    message.person_detected = personDetected;
    message.person_z_distance = personZDistance;
    message.stop_sign_detected = stopSignDetected;
    message.stop_sign_z_distance = stopSignZDistance;
    message.header.stamp = node->now();
    publisher->publish(message);
    rclcpp::spin_some(node);
}

Sous-partie 2.3 : GNSS RTK

2.3.1. Correction RTK

2.3.2. Modules GNSS RTK LC29H

Partie 3 : Fusion de capteurs

Figure 14 : modélisation d'un capteur

Sous-partie 3.1 : Localisation du robot

• -bel() : la fonction de croyance
• - s : la pose vraie du robot
• - s_t : état du robot au temps t
• - u_({0 : t}) = {u_0, u_2, …, u_t} : commandes passées aux actionneurs ou mesures des capteurs proprioceptifs
• - Z_({1 : t}) = {Z_1, Z_2, …, Z_t} : mesures passées en provenance des capteurs extéroceptifs

Figure 15 : graphe des dépendances pour un robot se déplaçant

Sous-partie 3.2 : Filtre de Kalman étendu

• - s^_(k|k − 1) : estimée de la pose au temps k connaissant celle à k − 1;
• - f_s : fonction non linéaire de transition d'état ;
• - w_k ∼ N(0, T_k) : bruit d'évolution, gaussien et de matrice de covariance T_k.

• - z^_k : estimée de la mesure au temps k;
• - h_z : fonction de mesure ;
• - v_k ∼ N(0, R_k) : bruit de mesure, gaussien et de matrice de covariance R_k.

Figure 16 : diagramme d'état pour un EKF

struct R2WLocalisationMetaState
{
    enum StateIndex
    {
        POSITION_X = 0,
        POSITION_Y,
        ORIENTATION_Z,
        STATE_SIZE
    };
    enum InputIndex
    {
        LINEAR_SPEED_X_BODY = 0,
        LINEAR_SPEED_Y_BODY,
        ANGULAR_SPEED_Z_BODY,
        INPUT_SIZE
    };
};

Partie 4 : Base de données

• -chaque trajet d'un robot est enregistré sous forme d'une séquence de waypoints et est associé à un seul robot. Un trajet est caractérisé par un numéro unique de trajet, une date et une heure de début de trajet, la durée totale du trajet enregistré ainsi que les coordonnées (longitude et latitude) du point de départ. Pour chaque waypoint est indiqué : la date/heure de mesure/enregistrement, la longitude, la latitude et la vitesse linéaire V_(O_R ∈ robot / sol) du robot ;
• -à chaque trajet sont associées des métadonnées obligatoires : date et heure du trajet, l'identifiant de l'opérateur (la gestion des utilisateurs est hors périmètre de cette question), conditions environnementales (liste prédéfinie : pluie, soleil, neige) complétées par un champ libre. La date de dernière modification est stockée aussi, ce qui permet d'indiquer le dernier changements ou remarque entré par l'opérateur ;
• -les robots sont caractérisés par un identifiant unique (immuable), une marque, un modèle dans cette marque, un numéro unique (inchangé toute sa vie), une date de mise en service, un statut reflétant sont état de fonctionnement (liste fixe : actif, en maintenance, hors service), sa prochaine date de maintenance prévue, son énergie de propulsion (liste fixe : électrique, solaire, hybride, essence, gasoil agricole) ;
• -chaque robot a la capacité d'être équipé en standard de dix capteurs environnementaux standardisés, communiquant sur ISOBUS, et pouvant varier d'un robot à l'autre. Chaque capteur est caractérisé par un identifiant unique, un modèle et une description. Les données renvoyées par les capteurs sont des valeurs numériques de type FLOAT et doivent être enregistrées régulièrement lors de chaque trajet ;
• -les capteurs peuvent être installés sur un robot ou un autre selon les objectifs des trajets. Pour permettre une traçabilité il est souhaitable de stocker l'historique des installations et désinstallations de chaque capteur sur les robots.

• -le nombre de capteurs et d'actionneurs peut évoluer (structure flexible) ;
• -les modifications des métadonnées doivent être traçables (date de dernière modification) ;
• -un trajet est toujours associé à un seul robot, et un état à un seul trajet ;
• -les opérateurs sont identifiés par un simple champ texte, leur gestion et leur authentification étant gérées par ailleurs.

• -par login et mot de passe pour les utilisateurs humains ;
• -par clef ssh pour les connexions machines.

Figure 17 : Modèle Logique des Données (MLD)

• - H : entropie de Shannon en bits ;
• - L : nombre de symboles composant le mot de passe ;
• - N : nombre de symboles possibles.

Documents techniques

DT1 Graphe ROS du robot ALPO

• computeInstantaneousCurvature(leftInstantaneousCurvature : const double&, rightInstantneousCurvature : const double&, track : const double&) : double
• computeInstantaneousCurvature(leftWheelSteeringAngle : const double&, rightWheelSteeringAngle : const double&, wheelbase : const double&, track : const double&) : double
• computeSteeringAngle(leftWheelSteeringAngle : const double&, rightWheelSteeringAngle : const double&, wheelbase : const double&, track : const double&) : double
• computeMaximallnstantaneousCurvature(wheelbase : const double, halfTrack : const double, maximalWheelSteeringAngle : const double&) : double
• computeLeftWheelSteeringAngle(tanSteeringAngle : const double&, instantaneousCurvature : const double&, halfTrack : const double&) : double
• computeRightWheelSteeringAngle(tanSteeringAngle : const double&, instantaneousCurvature : const double&, halfTrack : const double&) : double
  romea::core::TwoWheelSteeringKinematic::Parameters
• wheelBase : double
• wheelTrack : double
• wheelLinearSpeedVariance : double
• wheelSteeringAngleVariance : double
• Parameters() «constructor»
  

  

DT4 Diagramme de classe socket_can

drivers::socketcan::SocketCanReceiver

• m_file_descriptor : int32_t
• m_enable_fd : bool

• SocketCanReceiver(interface : const std::string&, enable_fd : const bool, enable_loopback : const bool) «explicit constructor»
• receive(data : void* const, timeout : const std::chrono::nanoseconds) : Canld

• wait(timeout : const std::chrono::nanoseconds)
  drivers::socketcan::SocketCanSender

• -m_default_id : Canld
• + SocketCanSender(interface : const std::string&, enable_fd : const bool, default_id : const Canld&) «explicit constructor»
• + send(data : const void* const, length : const std::size_t, id : const Canld, timeout : const std::chrono::nanoseconds)
• -wait(timeout : const std::chrono::nanoseconds)

sensor_msgs/PointCloud2 Message

File: sensor_msgs/PointCloud2.msg

Raw Message Definition

# This message holds a collection of N-dimensional points, which may
# contain additional information such as normals, intensity, etc. The
# point data is stored as a binary blob, its layout described by the
# contents of the "fields" array.
# The point cloud data may be organized 2d (image-like) or 1d
# (unordered). Point clouds organized as 2d images may be produced by
# camera depth sensors such as stereo or time-of-flight.
# Time of sensor data acquisition, and the coordinate frame ID (for 3d
# points).
Header header
# 2D structure of the point cloud. If the cloud is unordered, height is
# 1 and width is the length of the point cloud.
uint32 height
uint32 width
# Describes the channels and their layout in the binary data blob.
PointField[] fields
bool is bigendian # Is this data bigendian?
uint32 point_step # Length of a point in bytes
uint32 row_step # Length of a row in bytes
uint8[] data # Actual point data, size is (row_step*height)
bool is_dense # True if there are no invalid points

Compact Message Definition

std_msgs/Header header
uint32 height
uint32 width
sensor_msgs/PointField[] fields
bool is_bigendian
uint32 point_step
uint32 row_step
uint8[] data
bool is_dense

DT6 Classe std ::array() (bibliothèque standard C++)

template <class Ty, std::size_t N>
class array;

void *memcpy(
    void *dest,
    const void *src,
    size_t count
);

dest

src

count

template <class Ty>
struct atomic;

• -Étant donné qu'une opération atomique est asynchrone, une deuxième opération atomique sur le même objet à partir d'un thread différent peut obtenir l'état de l'objet uniquement avant ou après la première opération atomique.
• -En fonction de l'argument memory_order, une opération atomique établit des exigences de classement pour la visibilité des effets d'autres opérations atomiques dans le même thread. Par conséquent, elle empêche les optimisations du compilateur qui enfreignent les contraintes d'ordre.

atomic<char>
atomic<int>
atomic<unsigned int>
atomic<long>
atomic<unsigned long>
atomic<float>
etc.

DT9 Extrait de la documentation IMU XSense MTi-1

Figure 1: MTi 1-series module diagram

2.2 Sensors specifications

DT10 Bibliothèque Numpy (résumé)

import numpy as np # Import recommandé

a = np.array([1][2][3][4]) # Tableau 1D à partir de liste
b = np.array([[1][2][3], [4][5][6]]) # Tableau 2D à partir de liste de listes
np.zeros((3,4)) # Tableau de zéros
np.ones((2,3)) # Tableau de uns
np.empty((2,2)) # Valeurs vides (indéfinies) :
np.arange(0, 10, 2) # Valeurs croissantes :
np.random.rand(3,3) # Valeurs aléatoires :

a.shape # dimensions du tableau
a.dtype # type des éléments
a.size # nombre total d'éléments

a[i] # Accès élément (1D)
b[i,j] # Accès élément (2D)
a[start:stop:step] # Extraction
b[:, j], b[i, :] # Extraction de colonnes ou lignes

Opérations arithmétiques sur tableaux : +, -, *, /, **

np.sqrt(a), np.exp(a), np.sin(a), np.abs(a), etc.

a.sum() ou np.sum(a) # Somme
a.mean() # Moyenne
np.median(a) # Médiane
a.std() # Écart-type
a.var() # Variance
a.min(), a.max() # Min/Max
a.argmin(), a.argmax() # Indices min/max

np.append(a, x) # Ajout d'éléments
np.insert(a, index, x) # Insertion
np.delete(a, index) # Suppression
b = a.copy() # Copie

np.eye(n) # matrice identité nxn
np.linspace(start, stop, num) # vecteur avec num points espacés uniformément
np.reshape(a, newshape) # changer la forme sans changer les données

# Classes
names:
    0: person
    1: bicycle
    2: car
    3: motorcycle
    4: airplane
    5: bus
    6: train
    7: truck
    8: boat
    9: traffic light
    10: fire hydrant
    11: stop sign
    12: parking meter
    13: bench
    14: bird
    15: cat
    16: dog
    17: horse
    18: sheep
    19: cow
    20: elephant
    21: bear
    22: zebra
    23: giraffe
    24: backpack
    25: umbrella
    26: handbag
    27: tie
    28: suitcase
    29: frisbee
    30: skis
    31: snowboard
    32: sports ball
    33: kite
    34: baseball bat
    35: baseball glove
    36: skateboard
    37: surfboard
    38: tennis racket
    39: bottle
    40: wine glass
    41: cup
    42: fork
    43: knife
    44: spoon
    45: bowl
    46: banana
    47: apple
    48: sandwich
    49: orange
    50: broccoli

DT12 Extrait de Quectel LC29H Series GNSS Protocol Specification

2.1. Structure of NMEA Protocol Messages

Figure 1: Structure of NMEA Protocol Messages

2.3.2. PQTMSAVEPAR

• -If successful, the module returns:

• -If failed, the module returns:

2.3.3. PQTMRESTOREPAR

• -If successful, the module returns:

• -If failed, the module returns:

2.3.8. PQTMCFGSVIN

//Set:
$PQTMCFGSVIN,W,<Mode>,<MinDur>,<3D_AccLimit>,<ECEF_X>,<ECEF_Y>,<ECEF_Z>*<Checksu
m><CR><LF>
//Get:
$PQTMCFGSVIN,R*<Checksum><CR><LF>

• -If successful, the module returns:

• -If failed, the module returns:

2.3.13. PQTMCFGNMEADP

//Set:
$PQTMCFGNMEADP,W,<UTC_DP>,<POS_DP>,<ALT_DP>,<DOP_DP>,<SPD_DP>,<COG_DP>*<Ch
ecksum><CR><LF>
//Get:
$PQTMCFGNMEADP,R*<Checksum><CR><LF>

• -If successful, the module returns:

• If failed, the module returns:
  $PQTMCFGNMEADP,ERROR,<ErrCode>*<Checksum><CR><LF>

2.3.14. PQTMCFGRCVRMODE

//Set:
$PQTMCFGRCVRMODE,W,<Mode>*<Checksum><CR><LF>
//Get:
$PQTMCFGRCVRMODE,R*<Checksum><CR><LF>

• -If successful, the module returns:
  //Response to Set command:
  $PQTMCFGRCVRMODE,OK*<Checksum><CR><LF>
  //Response to Get command:
  $PQTMCFGRCVRMODE,OK,<Mode>*<Checksum><CR><LF>
• -If failed, the module returns:
  $PQTMCFGRCVRMODE,ERROR,<ErrCode>*<Checksum><CR><LF>

2.4.9. PAIR050: PAIR_COMMON_SET_FIX_RATE

#include <chrono>
#include <depthai/depthai.hpp>
#include <rclcpp/rclcpp.hpp>
#include "camera/msg/person_detection.hpp"
int main(int argc, char * argv[]) {
    // Initialisation ROS2
    rclcpp::init(argc, argv);
    auto node = std::make_shared<rclcpp::Node>("person_detector");
    auto publisher = node->create_publisher<camera::msg::PersonDetection>("person_detection",
10);
    bool fullFrameTracking = false;
    // Création du pipeline
    dai::Pipeline pipeline;
    // Définition des entrées sorties
    auto camRgb = pipeline.create<dai::node::Camera>()->build(dai::CameraBoardSocket::CAM_A);
    auto monoLeft = pipeline.create<dai::node::Camera>()->build(dai::CameraBoardSocket::CAM_B);
    auto monoRight = pipeline.create<dai::node::Camera>()->build(dai::CameraBoardSocket::CAM_C);
    // Création du nœud stéréo
    auto stereo = pipeline.create<dai::node::StereoDepth>();
    auto leftOutput = monoLeft->requestOutput(std::make_pair(640, 400));
    auto rightOutput = monoRight->requestOutput(std::make_pair(640, 400));
    leftOutput->link(stereo->left);
    rightOutput->link(stereo->right);
    // Création du réseau de détection
    dai::NNModelDescription modelDescription{"yolov6-nano"};
    auto spatialDetectionNetwork = pipeline.create<dai::node::SpatialDetectionNetwork>()-
>build(camRgb, stereo, modelDescription);
    spatialDetectionNetwork->setConfidenceThreshold(0.6f);
    spatialDetectionNetwork->input.setBlocking(false);
    spatialDetectionNetwork->setBoundingBoxScaleFactor(0.5f);
    spatialDetectionNetwork->setDepthLowerThreshold(100);
    spatialDetectionNetwork->setDepthUpperThreshold(5000);
    // Création du traqueur d’objet
    auto objectTracker = pipeline.create<dai::node::ObjectTracker>();
    objectTracker->setDetectionLabelsToTrack({0}); // track only person (index 0)
    objectTracker->setTrackerType(dai::TrackerType::SHORT_TERM_IMAGELESS);
    objectTracker->setTrackerIdAssignmentPolicy(dai::TrackerIdAssignmentPolicy::SMALLEST_ID);
    // Création des files d'attente de sortie
    auto preview = objectTracker->passthroughTrackerFrame.createOutputQueue();
    auto tracklets = objectTracker->out.createOutputQueue();
    // Liaison des nœuds
    if(fullFrameTracking) {
        camRgb->requestFullResolutionOutput()->link(objectTracker->inputTrackerFrame);
        objectTracker->inputTrackerFrame.setBlocking(false);
        objectTracker->inputTrackerFrame.setMaxSize(1);
    } else {
        spatialDetectionNetwork->passthrough.link(objectTracker->inputTrackerFrame);
    }
    spatialDetectionNetwork->passthrough.link(objectTracker->inputDetectionFrame);
    spatialDetectionNetwork->out.link(objectTracker->inputDetections);
    // Lancement du pipeline
    pipeline.start();
    while(pipeline.isRunning()) {
        auto imgFrame = preview->get<dai::ImgFrame>();
        auto track = tracklets->get<dai::Tracklets>();
        bool personDetected = false;
        float z_distance = 0.0f;

        // track->tracklets contient les informations sur les objets détectés
        auto trackletsData = track->tracklets;
        for(const auto& t : trackletsData) {
            personDetected = true;
            z_distance = t.spatialCoordinates.z; // en mm
        }
        // Créer et publier le message personnalisé
        auto message = camera::msg::PersonDetection();
        message.detected = personDetected;
        message.z_distance = z_distance;
        message.header.stamp = node->now(); // Ajoute le timestamp actuel
        publisher->publish(message);
        // Permet à ROS2 de traiter les callbacks
        rclcpp::spin_some(node);
    }
    // Arrêt ROS2
    rclcpp::shutdown();
    return 0;
}

DT14 Extraits du règlement (UE) 2016/679 du parlement européen et du conseil du 27 avril 2016 entré en application le 25 mai 2018

1. «données à caractère personnel», toute information se rapportant à une personne physique identifiée ou identifiable (ci-après dénommée «personne concernée») ; est réputée être une «personne physique identifiable» une personne physique qui peut être identifiée, directement ou indirectement, notamment par référence à un identifiant, tel qu'un nom, un numéro d'identification, des données de localisation, un identifiant en ligne, ou à un ou plusieurs éléments spécifiques propres à son identité physique, physiologique, génétique, psychique, économique, culturelle ou sociale ;
2. «traitement», toute opération ou tout ensemble d'opérations effectuées ou non à l'aide de procédés automatisés et appliquées à des données ou des ensembles de données à caractère personnel, telles que la collecte, l'enregistrement, l'organisation, la structuration, la conservation, l'adaptation ou la modification, l'extraction, la consultation, l'utilisation, la communication par transmission, la diffusion ou toute autre forme de mise à disposition, le rapprochement ou l'interconnexion, la limitation, l'effacement ou la destruction ;
   [...]
3. «responsable du traitement», la personne physique ou morale, l'autorité publique, le service ou un autre organisme qui, seul ou conjointement avec d'autres, détermine les finalités et les moyens du traitement; lorsque les finalités et les moyens de ce traitement sont déterminés par le droit de l'Union ou le droit d'un État membre, le responsable du traitement peut être désigné ou les critères spécifiques applicables à sa désignation peuvent être prévus par le droit de l'Union ou par le droit d'un État membre ;
   [...]

CHAPITRE II

1. Les données à caractère personnel doivent être :
   a) traitées de manière licite, loyale et transparente au regard de la personne concernée (licéité, loyauté, transparence) ;
   b) collectées pour des finalités déterminées, explicites et légitimes, et ne pas être traitées ultérieurement d'une manière incompatible avec ces finalités ; le traitement ultérieur à des fins archivistiques dans l'intérêt public, à des fins de recherche scientifique ou historique ou à des fins statistiques n'est pas considéré, conformément à l'article 89, paragraphe 1, comme incompatible avec les finalités initiales (limitation des finalités) ;
   c) adéquates, pertinentes et limitées à ce qui est nécessaire au regard des finalités pour lesquelles elles sont traitées (minimisation des données) ;
   d) exactes et, si nécessaire, tenues à jour ; toutes les mesures raisonnables doivent être prises pour que les données à caractère personnel qui sont inexactes, eu égard aux finalités pour lesquelles elles sont traitées, soient effacées ou rectifiées sans tarder (exactitude);
   e) conservées sous une forme permettant l'identification des personnes concernées pendant une durée n'excédant pas celle nécessaire au regard des finalités pour lesquelles elles sont traitées; les données à caractère personnel peuvent être conservées pour des durées plus longues dans la mesure où elles seront traitées exclusivement à des fins archivistiques dans l'intérêt public, à des fins de recherche scientifique ou historique ou à des fins statistiques conformément à l'article 89, paragraphe 1, pour autant que soient mises en œuvre les mesures techniques et organisationnelles appropriées requises par le présent règlement afin de garantir les droits et libertés de la personne concernée (limitation de la conservation);
   f) traitées de façon à garantir une sécurité appropriée des données à caractère personnel, y compris la protection contre le traitement non autorisé ou illicite et contre la perte, la destruction ou les dégâts d'origine accidentelle, à l'aide de mesures techniques ou organisationnelles appropriées (intégrité et confidentialité) ;
2. Le responsable du traitement est responsable du respect du paragraphe 1 et est en mesure de démontrer que celui-ci est respecté (responsabilité).