Agrégation informatique externe 2024, épreuve 3, option ingénierie informatiqueSujet et rapport du jury

AGRÉGATION
CONCOURS EXTERNE

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

RECTIFICATIF

• -Les questions 8 et 9 sont annulées. Les candidats n'ont pas à les traiter.
• -Page 11
  Question 11 (a) pour remplir le circuit, les candidats doivent préalablement recopier la figure 10 sur leur copie (pas de document réponse pour cette question).
• -Page 38 - E Fichiers
  Au lieu de :
  • -Fichier Gestion.js en fig ; 39

• • -Fichier Gestion.js en fig ; 42

• -Un dossier questionnement de la page 3 à la page 30 ;
  • 1.Présentation : page 3 à 4
  • 2.Partie 1 : page 5 à 12
  • 3.Partie 2 : page 13 à 19
  • 4.Partie 3 : page 20 à 25
  • 5.Partie 4 : page 26 à 30.
• -des annexes techniques à partir de la page 31.
  • -Schéma de principe d'une borne
  • -Rapport cyclique EVSE
  • -Courant de charge d'une borne
  • -Protocole Modbus
  • -Orno WE514 description
  • -Fonction Modbus
  • -Trame Modbus Maitre
  • -Trame Modbus Esclave
  • -Dialogue Modbus
  • -Documentation OrnoWE514
  • -Trame Orno WE514 Requete Réponse
  • -Registres internes Orno WE514
  • -Contacteur modbus
  • -Organisation des ressources logicielles
  • -Fichier Borne.js
  • -Fichier Contacteur.js
  • -Fichier Mesureur.js
  • -Fichier Gestion.js
  • -Programme Principal
  • -Fichier EventPortSerie.js
• -des documents réponses

• -Les deux premières parties du questionnement ne sont pas indépendantes;
• -Les parties 3 et 4 sont chacune indépendantes. Cependant, elles partagent un ensemble d'hypothèses présentées au démarrage de la partie 3 page 20 ;
• -Un parcours attentif de l'ensemble du document est conseillé avant de composer.

Table des matières

Etude de la réalisation et de la gestion d'une ou de plusieurs bornes de recharge pour véhicules électriques

Figure 1 - Véhicule électrique à la recharge sur une borne de recharge individuelle.

Figure 2 - Bornes de recharges associées à plusieurs places de parking.

1 Analyse d'une borne

Figure 3 - Organisation de l'installation.

• -de mettre en fonctionnement la recharge;
• -de mesurer la tension, l'intensité et la puissance délivrée au véhicule;
• -d'afficher différentes informations et de fixer la consigne maximale de courant.

Figure 4 - Organisation d'une borne.

1.1 Protocole J1772

Figure 5 - Norme J1772

• -CP (Control Pilot) permet de dialoguer avec le véhicule électrique;
• -PP (Proximity Pilot);
• -PE (Prise de terre) ;
• -L1, L2 et L3 Phase 1 à 3;
• -N (Neutre).

• --12V afin d'indiquer qu'elle n'est pas disponible;

• +12V afin d'indiquer qu'elle est prête.

Figure 6 - Installation

1.2 Protocole Modbus

1.2.1 Analyse du Mesureur

1.2.2 Analyse gestionnaire

1.2.3 Analyse de la Classe Contacteur

class Contacteur{
    constructor(adresseRelais=20){
        this._adresseRelais=adresseRelais
        this._etat=false
    }
    on (){..}
    off(){..}
}

Figure 8 - Diagramme de classes

1.3 Le Contrôle de Redondance Cyclique (CRC)

1.3.1 L'algorithme

Figure 9 - Algorithme de calcul du CRC16.

• (a)Après le traitement des trois premiers octets de la réponse à la requête de ce diagramme temporel, la variable CRC a la valeur 0xF0E0. Calculer la valeur finale du CRC et montrer les étapes du calcul.
• (b)Remplir le diagramme temporel avec le code CRC calculé.

1.3.2 Implémentation matérielle

• (a)Dessiner une implémentation en série basée sur un registre à décalage à rétroaction linéaire (linear feedback shift register - LFSR).
• (b)Donner l'équation qui calcule combien de cycles d'horloge sont nécessaires pour le calcul du CRC16 dans une implémentation en série?

• -Les données data qui sont codées sur un octet,
• -Un signal d_valid qui vaut 1 pour signaler au circuit chaque fois qu'un nouvel octet de donnée est valable,
• -Un signal init_comp qui vaut 1 au début pour un cycle d'horloge pour signaler au circuit la demande du calcul CRC16,
• -len code sur un octet qui donne la longueur du message.
• -clk qui est l'horloge.
• -rst qui est le reset.

Figure 10 - Implémentation en parallèle

• (a)Remplir le circuit en utilisant des multiplexeurs, des registres, des portes et des composants arithmétiques, afin de pouvoir calculer le CRC16 d'une message, quelle que soit la longueur.
• (b)Donner l'équation qui calcule le nombre de cycles d'horloge nécessaires pour le calcul du CRC16 dans une implémentation de type parallèle?

• (a)Combien de cycles d'horloge sont nécessaires pour le calcul du CRC16 pour l'implémentation en série?
• (b)Combien de cycles d'horloge sont nécessaires pour le calcul du CRC16 pour l'implémentation en paralléle?
• (c)Quelle réduction du temps de calcul (en pourcentage) l'implémentation en parallèle a-t-elle permit d'obtenir par rapport à l'implémentation en série?

2 Analyse de plusieurs bornes

2.1 Organisation matériels

Figure 11 - Organisation à plusieurs bornes

• (a)Gestionnaire;
• (b)Borne ;
• (c)Serie (celle-ci gère le port série asynchrone).

import { Borne } from "./modules/borne.js"
import {SerialPort} from "serialport"
class Gestionnaire{
    constructor(){
        this.borne1=new Borne(0x11,0x21,0x31)
        this.borne2=new Borne(0x12,0x22,0x32)
        this.borne3=new Borne(0x13 , 0x23 ,0x33)
        this.borne4=new Borne(0x05,0x10,0x50)
        this.portCom="OOM3"
        this.port=this.initSerie()
    }
    // Methodes pour le dialogue avec le port Serie
    initSerie(){..}
    write(data){..}
    read(){..}
    // Methode realisant la gestion des differentes bornes
    gestion(){..}
}
const gestion=new Gestionnaire()

// INSTANCIATION DE L'OBJET
const + gestion=new Gestionnaire()
// console.log() + permet d'afficher un message dans la console.
console.log("Production de +Trames")
console.log("Trame bour |Relais |On←: |",gestion.borne1.actif())
console.log("Trame bour |Lecture \( Tension←: y", gestion.borne2.tension())
console.log("Trame pour |Lecture | Intensite | : | ", gestion.borne3.intensite())
console.log("Trame bour |Lecture |Puissance | : |", gestion.borne4.puissance())

2.2 Méthode puissance() et ajouterCRC() de la classe Borne

Production de Trames
Trame pour Relais On : [ 33, 5, 0, 0, 255, 0, 139, 90 ]
Trame pour Lecture Tension : [ 18, 3, 1, 49, 0, 1, 214, 154]
Trame pour Lecture Intensite : [ 19, 3, 1, 57, 0, 2, 22, 136]
Trame pour Lecture Puissance : [ 5, 3, 1, 64, 0, 2, 197, 167 ]

// Extrait de la classe Borne
// On trouve les deux methodes suivantes:
puissance(){
    return this.ajouterCRC(this._Mesureur.powerActiveV1())
    }
ajouterCRC(data){
    let trame=data
    let CRC= this.CRC(trame)
    trame.push(Math.trunc(CRC%256))
    trame.push(Math.trunc(CRC/256))
    return trame
    }

• (b)Pour quelle raison avons nous CRC%256 et CRC/256 dans la méthode ajouter-CRC() ?

2.3 Analyse temporelle d'une communication Modbus

Figure 13 - Requete Modbus

2.4 Exploitation des mesures

Figure 14 - Serveur

2.5 Machine d'état

• -Elle doit gérer le séquencement de l'ensemble des transactions pour l'émission et la réception de trame au format Modbus.
• -Elle est capable de traiter un cycle de plusieurs trames formatées Modbus.
• -Les différentes réponses sont toutes enregistrées dans un buffer.
• -Elle est capable de traiter un dialogue périodique avec un ou des périphériques Modbus.
• -La communication avec le port Série s'effectue par événement.

2.5.1 Diagramme de séquence

Figure 15 - Diagramme de séquence

• (b)Le mesureur de la borne1 est à l'adresse 0x05, le mesureur de la borne2 est à l'adresse 0x06, en vous aidant des résultats fournit par la machine d'état pour un cycle de fonctionnement (fig 16), indiquer le véhicule déjà chargé?

2.5.2 Structure de la machine d'état

2.5.3 Programmation événementielle

1. Importer le module EventEmitter de node:events

• import { EventEmitter, errorMonitor } from "node:events";

2. Declarer un objet de type EventEmitter

• const eventModbus=new EventEmitter()

3. Mettre en place les ecouteurs d'evenements,

• • eventModbus.emit ("Trame" , "Trame emise ")

Figure 17 - Machine d'état

3 Allocation des demandes aux chargeurs

• -on note r_–_v = ⌊(r_v)/T⌋ la date au plus tôt pour l'arrivée du véhicule dans la place associée au chargeur ;
• -on note également r¯_v = ⌈(r_v)/T⌉ la date considérée pour démarrer la charge du véhicule.

• -on note d¯_v = ⌈(r_v)/T⌉ la date considérée pour le départ effectif du véhicule;
• -on note également d_–_v = ⌊(r_v)/T⌋ la date maximum de fin de charge.

3.1 Gestion des liens entre chargeurs et demandes

<BaseDemandes>
    <demande immatriculation="XW-540-FF" heureArrivee="10" minuteArrivee="50"
heureDepart="12" minuteDepart="25" energieRequise="50">
    </demande>
    <demande immatriculation="WK-975-XZ" heureArrivee="11" minuteArrivee="45"
heureDepart="19" minuteDepart="40" energieRequise="65">
    </demande>
    <demande immatriculation="PR-277-BA" heureArrivee="9" minuteArrivee="45"
heureDepart="14" minuteDepart="22" energieRequise="61">
    </demande>
</BaseDemandes>

• -chaque demande doit pouvoir être réalisée entre les instants 0 et δ, sachant que les heures et les minutes stockées dans le fichier xml ont des valeurs correctes, càd les heures sont comprises entre 0 et 23 et les minutes entre 0 et 59;
• -le temps de charge est suffisant pour récupérer l'énergie requise par la demande.

import xml.etree.ElementTree as ET
import math as MT
def dictionnaire_demandes(root,delta,tau,w):
    dico_demandes = {}
    for child in root:

        # recuperation des donnees d'une demande et conversions
        inst_a = Demande.time_to_secondes(int(child.get("heureArrivee")),
int(child.get("minuteArrivee")))
        inst_d = Demande.time_to_secondes(int(child.get("heureDepart")),
int(child.get("minuteDepart")))
        im = child.get("immatriculation")
        energie = int(child.get("energieRequise"))
        #calcul des attributs d'une demande
        (a)
        #test de la correction de la demande et creation
        if (b)...
        else:
            dico_demandes[im] = Demande(inf_arr,sup_arr,inf_dep,sup_dep,
duree,im)
    return dico_demandes

• (b)effectuer les tests nécessaires pour que la demande soit réalisable et la stocker dans le dictionnaire le cas échéant. Renvoyer un message d'erreur explicite en cas de problème.

class Chargeur:
    def __init__(self):
        self.liste_demandes = []

• (a)Soient deux intervalles non vides [x_1, y_1[ et [x_2, y_2[. Exprimer une condition nécessaire et suffisante simple sur les valeurs x_1, x_2, y_1 et y_2 pour que l'intersection de ces intervalles soit vide;
• (b)en déduire le code Python de la méthode intervalles_disjoints(self, v) de la classe Demande qui retourne True si la demande courante et la demande v peuvent partager le même chargeur.

def rajoute_demande(self,v):
    if (self.liste_demandes==[]):
        self.liste_demandes.append(v)
        v.lien_chargeur (self)
        return True
    tailleListe=len (self.liste_demandes)
    for i in range(tailleListe):
        if not v.intervalles_disjoints(self.liste_demandes[i]):
            return False
        #Si l'insertion est possible avant self.liste_demandes[i]
        (a)
            return True
    # Sortie de boucle
    (b)

• (a)Donner le code manquant (a) qui teste si la demande v peut être rajoutée juste avant la demande self.liste_demandes[i] et effectue cette insertion correctement;
• (b)dans quel cas sort on de la boucle sans passer par un return? En déduire le code (b) manquant ;
• (c)quelle est la complexité de la primitive rajoute_demande(self,v) dans le meilleur et le pire des cas. Justifier votre réponse en exhibant un pire cas et un meilleur cas.

3.2 Attribution des places de parking aux demandes

def allocation_demande_chargeurs(dicoDemandes, listeChargeurs):
    resultat = []
    for d in dicoDemandes.values():
        for c in listeChargeurs:
            if (c.rajoute_demande(d)):
                break
        if (not d.chargeur):
            resultat.append(d)
    return resultat

• (b)Est-ce que il existe une allocation sur 3 chargeurs qui permette de satisfaire toutes ces demandes? Justifier votre réponse.

• -Les sommets de G_D sont les demandes, soit V = D;
• -Pour tout couple (u, v) ∈ D^2 avec u ≠ v, l'arête e = {u, v} ∈ E si [r_–_u, d¯_u[ ∩ [r_–_v, d¯_v[ ≠ ∅, autrement dit u et v ne peuvent être allouées au même chargeur (et à la même place de parking) compte tenu des contraintes temporelles.

• (a)Construire le graphe d'intervalles G_D associé aux 6 commandes décrites par la table 1;
• (b)quel est le nombre minimum de couleurs nécessaires pour obtenir une coloration de ce graphe? Justifier votre réponse.

• (a)Démontrer que l'on une coloration en k couleurs de G_D si et seulement si on peut allouer les demandes à k chargeurs ;
• (b)en déduire que, dans le cas général, le nombre minimum de chargeur m^⋆(D) vaut χ(G_D);
• (c)en déduire pour l'exemple une allocation des demandes en m^⋆(D) chargeurs à partir d'une coloration du graphe G_D en χ(G_D) couleurs.

• (a)Donner le résultat de l'exécution de la fonction allocation_demande_chargeurs pour ces 6 demandes pour 3 chargeurs. On rappelle que les demandes sont stockées dans un dictionnaire en suivant les attributs inf_r croissants;
• (b)que vaut ω(G_D) pour l'exemple?

• (a)Montrer que, si l'algorithme attribue une demande d au chargeur c_p, alors le graphe G_D possède une clique de taille p;
• (b)en déduire que, si l'algorithme alloue toutes les demandes, le nombre de chargeurs utilisés est minimal. Pour cela, on pourra démontrer que m¯ le nombre de chargeurs alloués par l'algorithme vérifie m¯ = m^⋆(D) = χ(G_D) = ω(G_D).

• (a)Quelle est la complexité nécessaire pour trier les demandes selon le champs inf_r croissant en effectuant un tri de comparaison ?
• (b)Evaluer une borne supérieure de la complexité de allocation_demande_chargeurs. Justifier votre réponse ;
• (c)Peut-on améliorer cette complexité? Justifier votre réponse.

4 Détermination des périodes de chargement des véhicules

4.1 Allocation des périodes de charges aux demandes

Figure 20 - Une allocation réalisable de la charge des véhicules pour l'exemple de la table 1 pour δ = 8 et m˜ = 2. Les zones grisées correspondent aux instants effectifs de charge.

• (a)Donner la liste Liste_Xvt pour l'exemple représenté par la figure 20. Les cases grisées correspondent aux instants effectifs de charge; pour simplifier la réponse, les éléments de D sont identifiés par la lettre associée;
• (b)donner en deux lignes maximum le principe d'un algorithme de complexité strictement meilleure que O(p) pour chercher si un couple (v, t) est dans Liste_Xvt croissante. Ici, p représente le nombre d'éléments de Liste_Xvt.
• (c)démontrer la complexité de cet algorithme. Pour cela :
  • 1.exprimer la suite α_p qui correspond au nombre maximum de comparaisons pour retrouver le couple dans une liste de p éléments en fonction de α_(p − 1), …, α_0. Justifier votre réponse;
  • 2.résoudre la suite α_p pour p = 2^k;
  • 3.en déduire pour tout entier q > 0 l'ordre de grandeur de u_q et la complexité de l'algorithme dans le pire des cas. Pour cela, on supposera que la suite α_p est croissante.

• (a)A tout instant t ∈ {0, …, δ − 1}, il y a au plus m˜ véhicules en charge;
• (b)le véhicule associé à la demande v ne peut être effectivement chargé que dans l'intervalle {r¯_v, …, d_–_v};
• (c)le véhicule associé à la demande v est chargé pendant au plus p_v intervalles;
• (d)il faut maximiser le nombre total de périodes effectives de charge.

• - V_X = D ∪ {0, …, δ − 1};
• -Pour tout couple (v, t) ∈ D × {0, …, δ − 1} on a deux cas :
  • 1.Si x_(v, t) = 1, alors l'arc (v, t) ∈ A_X;

2. sinon, l'arc (t, v) ∈ A_X.
   Un graphe est bipartie si il est possible de partitionner des sommets en deux sousensembles disjoints tel que tout arc a = (i, j) relie deux sommets dans des sous-ensembles différents. Dans le cas présent, ces deux sous-ensembles sont D et {0, …, δ}.
   Pour tout sommet s ∈ V_X, l'ensemble Γ_X^+(s) des successeurs de s dans X est defini par Γ_X^+(s) = {s^′ ∈ V_X, (s, s^′) ∈ A_X}. De même, l'ensemble Γ_X^−(s) des précédecesseurs de s dans X est defini par Γ_X^−(s) = {s^′ ∈ V_X, (s^′, s) ∈ A_X}.

• (a)Donner le graphe X associé à la solution réalisable exprimée par la figure 20;
• (b)pour tout sommet s ∈ V_X, donner les ensembles Γ_X^+(s) et Γ_X^−(s) pour le graphe X associé à la figure 20.

• (a)Donner dans le cas général l'ensemble des conditions qui permettent de s'assurer que Y est associé à une solution réalisable pour le problème d'affectation des instants de charges pour au plus m˜ chargeurs qui chargent à chaque instant. Justifier votre réponse ;
• (b)exprimer le critère considéré en fonction de la cardinalité des ensembles de successeurs et/ou prédécesseurs. Justifier votre réponse ;
• (c)quelle est la valeur du critère pour le graphe bipartie X obtenu dans la question 41(a) et associé à la figure 20 ? Justifier votre réponse.

• (a)Donner, si il en existe, les sommets incomplets pour le graphe bipartie X;
• (b)donner un chemin améliorant μ de X. Ce chemin est-il unique?

• (a)Construire le graphe X^′ à partir de celui obtenu dans la question 41(a) et associé à la figure 20. Donner la liste Liste_Xvt_prime associée à une nouvelle matrice x_(⋆, ⋆)^′ de X^′. Est-ce que x_(⋆, ⋆)^′ est une solution réalisable du problème? Est-elle optimale?
• (b)on se place maintenant dans le cas général. Soit alors X un graphe bipartie associé à une solution réalisable x_(⋆, ⋆), μ un chemin améliorant et X^′ le graphe construit

• àpartir de μ et X. Démontrer que la solution x_(⋆, ⋆)^′ est réalisable et strictement meilleure que x_(⋆, ⋆);
• (c)Dans le cas général, est-ce que la solution x_(⋆, ⋆)^′ obtenue est toujours optimale? Justifiez votre réponse.

4.2 Accès à la station de recharge

typedef volatile long lock_t;
lock_t test_and_set (lock_t* lock) {
    (a)
}
void acquire(lock_t* lock){

(b)

• (a)Remplir la fonction test_and_set en langage C.
• (b)Remplir la fonction acquire qui permet d'acquérir le verrou en langage C.
• (c)Remplir la fonction release qui permet de liberer le verrou en langage C.
• (d)Lorsque le test_and_set est appelée en tant que fonction C, renvoie-t-elle 0 ou 1 lorsque vous avez réussi à acquérir le verrou? Quelle est la valeur du verrou après?

lock_t access = 0;
void entry(){

• (a)

void exit(){

• (b)

• (a)Remplissez la fonction d'entree (entry) dans la station de recharge afin d'éviter toute situation de concurrence.
• (b)Remplissez la fonction de sortie (exit) dans la station de recharge afin d'éviter toute situation de concurrence.

A Schéma d'une borne

Figure 21 - Schéma de principe d'une borne de recharge.

Figure 23 - Courant de charge max en fonction du rapport cyclique

B Protocole Modbus

B. 1 Que signifie Modbus RTU ?

B. 2 Qu'est-ce qu'un maître Modbus RTU ?

B. 3 Qu'est-ce qu'un esclave Modbus RTU ?

B. 4 Format de la trame Modbus

B. 5 Exemple d'un dialogue entre un Maître et un esclave

Figure 29 - Trame Modbus temporelle

B. 6 Module Orno WE514

Figure 34 - Registres internes et configuration

C Contacteur de puissance

• -Contacteur de puissance fig.35.
• -Relais Modbus commandant le contacteur de puissance fig.36.
• -Description sur le fonctionnement du relais fig.37.

D Organisation des fichiers

Page 37

Figure 35 - Contacteur de puissance

Format	Description	Image
Baud rate :9600 8 NONE 1	Relais de faible puissance commandé en Modbus RTU

E Fichiers

• -Fichier Borne.js en fig ;39
• -Fichier Contacteur.js en fig;40
• -Fichier Mesureur.js en fig;41
• -Fichier Gestion.js en fig ;39
• -Fichier Programme principal en fig;43
• -Fichier eventPortSerie.js en fig;44

• 1.Interface de communication RS485
• 2.Interface de communication TTL
• 3.Entrée d'isolement de l'optocoupleur 2 canaux
• 4.Sortie d'isolation de optocoupleur à 2 canaux
• 5.Un bouton d'utilisateur
• 6.Un indicateur utilisateur LED
• 7.Un indicateur de puissance
• 8.Un microcontrôleur STM32F030F4
• 9.2 voyants d'état de relais LED
• 10.Interface du terminal d'alimentation (alimentation 12V)

• -Trame : 0110000000010200096656

• -Trame : 001000000001020009 6B C6

• -Relay No. 0 is on: 01050000 FF 00 8C 3A
• -Relay No. 0 is closed: 010500000000 CD CA
• -Relay No. 1 is open: 01050001 FF 00 DD FA
• -Relay No. 1 is closed: 010500010000 9C 0A

• -Trame : 010100000008 3D CC Interrogation à l'adresse 01.
• -Réponse : 01010102 D0 49

Figure 38 - Organisation des différentes sources dans l'espace de travail

Classe Borne.js
import { Contacteur } from "./contacteur.js"
import {IHM} from "./ihm.js"
import { Mesureur } from "./mesureur.js"
class Borne{
    constructor(adresseMesureur=10,adresseContacteur=20,adresseIHM=30){
        this._Mesureur=new Mesureur(adresseMesureur)
        this._Contacteur=new Contacteur(adresseContacteur)
        this._IHM=new IHM(adresseIHM)
    }
    actif(){
        return this.ajouterCRC(this._Contacteur.on())
    }
    inactif(){
        return this.ajouterCRC(this._Contacteur.off())
    }
    tension(){
        return this.ajouterCRC(this._Mesureur.voltageV1())
    }
    intensite(){
        return this.ajouterCRC(this._Mesureur.currentV1())
    }
    puissance(){
        return this.ajouterCRC(this._Mesureur.powerActiveV1())
    }
    CRC(data) {
            ..
            return crc;
        }
    ajouterCRC(data){
        let trame=data
        let CRC= this.CRC(trame)
        trame.push(Math.trunc(CRC%256))
        trame.push(Math.trunc(CRC/256))
        return trame
        }
}
export {Borne}

export {Contacteur}
class Contacteur{
    constructor(adresseRelais=2){
        this._adresseRelais=adresseRelais
        this._etat=false
    }
    on (){..}
    off(){..}
}

export{Mesureur}
class Mesureur{
    constructor(adresseOrno=20){
        this._adresseOrno=adresseOrno
    }
    voltageV1(){..}
    currentV1(){..}
    powerActiveV1(){
        let trame=[]
        const fonction=0x03
        trame [0]=this._adresseOrno
        trame[1]=fonction
        trame[2]=0 x01
        trame[3]=0 x40
        trame[4]=0 x00
        trame[5]=0x02
        return trame
        }
    frequency(){..}
    configAdress(adress){..}
    configBauds(bauds){..}
    configParity(parity){..}
}

import { Borne } from "./modules/borne.js"
import {SerialPort} from "serialport"
class Gestionnaire{
    constructor(){
        this.borne1=new Borne(0x11,0x21,0x31)
        this.borne2=new Borne(0x12,0x22,0x32)
        this.borne3=new Borne(0x13,0x23,0x33)
        this.borne4=new Borne(0x05,0x10,0x50)
        this.portCom="COM3"
        this.port=this.initSerie()
    }
    // Methodes pour le dialogue avec le port Serie
    initSerie(){
        return new SerialPort(
        {
            path:this.portCom,
            baudRate:9600,
            parity:"none",
            dataBits:8,
            stopBits:1
        },
        (err)=>{
            if(err){
                console.log("erreur ",err.message)
            }
        })
    }
    write(data){..}
    read(){..}
    // Gestion des differentes bornes
    gestion(){
    }
}

Programme principal

// Programme Principal
const gestion=new Gestionnaire()
console.log("Production de Trames")
console.log("trame Relais On ",gestion.borne1.actif())
console.log("trame Lecture Tension ",gestion.borne2.tension())
console.log("trame Lecture Intensite", gestion.borne3.intensite())
console.log("trame Lecture Puissance", gestion.borne4.puissance())

// Cette fonction realise bien une communication serie
// → Ouverture & Fermeture du port
// → Ecriture & Lecture de donnees
import { SerialPort } from "serialport";
// Dans le module SerialPort les emetteurs sont implementes
import { EventEmitter, errorMonitor } from "node:events";
export const eventPortSerie = new EventEmitter();
const portCom1 = "/dev/ttyUSB1";
const port1 = new SerialPort(
    {
        path: portCom1,
        baudRate: 9600,
        parity: "none",
        databits: 8,
        stopbits: 1,
    },
    (err) => {
        if (err) {
            console.log("erreur ", err.message);
        }
    }
);
// Mise en place des differents ecouteurs
port1.on("open", showPortOpen); // A l’ouverture
port1.on("data", readSerialData);
// A la reception de donnee dans le buffer
port1.on("close", showPortClose); // A la fermeture du port
port1.on("error", showError); // Si erreur de transmission

Suite Fichier eventPortSerie.js

/*
Mise en place d'un ecouteur sur le canal "emettre" de l'objet eventPortSerie.
Ce canal permet de recevoir de l'exterieur puis d'envoyer des donnees
sur le port serie.
*/
eventPortSerie.on("emettre", envoieDonnee)
function envoieDonnee(data){
    write(data);
    // Fonction permettant d'envoyer des donnees sur le port COM
}
function showPortOpen() {
    const message = 'Le port serie est connecte sur ${portCom1}
    avec un baudRate de ${port1.baudRate}';
    console.log(message);
    eventPortSerie.emit("start", "le port serie est disponible");
}
function readSerialData(data) {
    eventPortSerie.emit("DataOk", data);
}
function showPortClose() {
    console.log("port closed.");
}
function showError(error) {
    console.log("Serial port error: " + error);
    eventEmitter.emit("Erreur","erreur Com");
}
function write(donnee) {
    if (port1.isOpen = true) {
        port1.write(donnee);
        eventPortSerie.emit("travail", "ok");
    } else {
        console.log("le port est ferme");
        eventPortSerie.emit(" Erreur", "Port ferme");
    }
}

Figure 45 - Fichier eventPortSerie.js suite

on () {
    let trame=[]
    this._etat=true
    const fonction=?
    trame [0] = this._ adresseRelais
    trame[1]=fonction
    trame[2]=?
    trame[3]=?
    trame[4]=?
    trame[5]=?
    return trame

}
off(){
    let trame=[]
    this.__etat=false
    const fonction=?
    trame [0]=this.__adresseRelais
    trame[1]=fonction
    trame[2]=?
    trame[3]=?
    trame[4]=?
    trame[5]=?
    return trame
}

3 Réponse à la question 13

NE RIEN ECRIRE DANS CE CADRE

4 Réponse à la question 23

5 Réponse à la question 27