samedi 16 décembre 2023

Intégrer des icônes SVG avec Angular Material

 

Angular Material, une bibliothèque d'UI pour Angular, offre une panoplie d'éléments visuels prêts à l'emploi, incluant des icônes. Les icônes SVG, sont des images vectorielles extensibles. Elles offrent une flexibilité et une netteté visuelle exceptionnelle, et leur utilisation avec Angular Material peut être réalisée de manière transparente. Même si Angular Material propose par défaut une bonne collection d'icone (liste ici), il peut être utile d'ajouter ses propres icones

Dans ce guide, nous allons voir les étapes pour intégrer et utiliser nos icônes SVG avec Angular Material.

 

Étape 1 : Installation d'Angular Material

Assurez-vous d'avoir Angular Material installé dans votre projet Angular. Si ce n'est pas déjà fait, utilisez Angular CLI pour ajouter Angular Material :

ng add @angular/material

 

Étape 2 : Intégration des icônes SVG

Placez vos fichiers SVG dans un répertoire approprié de votre projet, par exemple, dans  assets/icons.

 

Étape 3 : Création d'un module pour la configuration des icônes

Lors de l'intégration d'icônes SVG avec Angular Material, séparer la configuration des icônes dans un module dédié peut rendre votre code plus modulaire et maintenable. 

Créez un nouveau fichier, par exemple icon-config.module.ts, pour gérer la configuration des icônes. N'oubliez pas d'importer MatIconModule.

import { NgModule } from '@angular/core';
import { MatIconModule, MatIconRegistry } from '@angular/material/icon';
import { DomSanitizer } from '@angular/platform-browser';

@NgModule({
  imports: [MatIconModule],
})
export class IconConfigModule {
  constructor(
private matIconRegistry: MatIconRegistry,
private domSanitizer: DomSanitizer
) { // Ajoutez ici la configuration de vos icônes SVG this.matIconRegistry 
.addSvgIcon('nom_de_votre_icone1',this.setPath(`${this.path}/
chemin_vers_votre_icone1.svg`)) .addSvgIcon('nom_de_votre_icone2',this.setPath(`${this.path}/chemin_vers_votre_icone2.svg`)); } 

private setPath(url: string): SafeResourceUrl {
return this.domSanitizer.bypassSecurityTrustResourceUrl(url);
} }

 

Étape 4 : Intégration du module dans votre application

Dans votre module principal (app.module.ts), importez et utilisez IconConfigModule :

import { NgModule } from '@angular/core'; import { BrowserModule } from '@angular/platform-browser'; import { IconConfigModule } from './icon-config.module'; // Chemin vers votre module d'icônes @NgModule({ declarations: [ // ... ], imports: [ BrowserModule, IconConfigModule, // ... ], providers: [], bootstrap: [AppComponent], }) export class AppModule { // ... }

Étape 5 : Utilisation des icônes SVG

Une fois la configuration effectuée, utilisez les icônes SVG dans votre application avec <mat-icon>.

 <mat-icon svgIcon="nom_de_votre_icone"></mat-icon>

Conclusion

En suivant ces étapes, vous pouvez intégrer facilement des icônes SVG dans votre application Angular utilisant Angular Material, offrant ainsi une interface utilisateur esthétique et personnalisée.

 

mercredi 29 mars 2023

Design Pattern Composite : exemple C#

 Voila un exemple simple en C# pour illustrer le pattern composite.

Diagramme UML


Les sources

La classe Forme

abstract class Forme
{
    protected string nom;

    public Forme(string nom)
    {
        this.nom = nom;
    }

    public virtual void Ajouter(Forme f)
    {
        throw new NotImplementedException();
    }

    public virtual void Retirer(Forme f)
    {
        throw new NotImplementedException();
    }

    public virtual void Afficher(int profondeur)
    {
        Console.WriteLine(new string('-', profondeur) + nom);
    }

    public abstract double CalculerAire();
}


La classe Carre
class Carre : Forme
{
    private double cote;

    public Carre(string nom, double cote) : base(nom)
    {
        this.cote = cote;
    }

    public override double CalculerAire()
    {
        return cote * cote;
    }
}

La classe Cercle
class Cercle : Forme
{
    private double rayon;

    public Cercle(string nom, double rayon) : base(nom)
    {
        this.rayon = rayon;
    }

    public override double CalculerAire()
    {
        return Math.PI * rayon * rayon;
    }
}

La classe Composite
class Composite : Forme
{
    private List<Forme> enfants = new List<Forme>();

    public Composite(string nom) : base(nom)
    {
    }

    public override void Ajouter(Forme f)
    {
        enfants.Add(f);
    }

    public override void Retirer(Forme f)
    {
        enfants.Remove(f);
    }

    public override void Afficher(int profondeur)
    {
        Console.WriteLine(new string('-', profondeur) + "+ " + nom);

        foreach (Forme enfant in enfants)
        {
            enfant.Afficher(profondeur + 2);
        }
    }

    public override double CalculerAire()
    {
        double aire = 0;

        foreach (Forme enfant in enfants)
        {
            aire += enfant.CalculerAire();
        }

        return aire;
    }
}

 Exemple d'utilisation :

static void Main(string[] args)
{
    Composite groupe1 = new Composite("Groupe 1");
    groupe1.Ajouter(new Cercle("Cercle 1", 3));
    groupe1.Ajouter(new Carre("Carre 1", 4));
    groupe1.Ajouter(new Carre("Carre 2", 5));

    Composite groupe2 = new Composite("Groupe 2");
    groupe2.Ajouter(new Cercle("Cercle 2", 2));
    groupe2.Ajouter(new Carre("Carre 3", 3));
    groupe2.Ajouter(groupe1);

    groupe2.Afficher(0);

    Console.WriteLine("Aire totale : " + groupe2.CalculerAire());
}

 

lundi 18 avril 2016

Les microservices - Introduction

Microservices, de quoi parle t'on ? 

Wikipedia en donne la définition suivante :
En informatique, les microservices est un style d'architecture logiciel à partir duquel un ensemble complexe d'applications est décomposé en plusieurs processus indépendants et faiblement couplées, souvent spécialisés dans une seule tâche. Les processus indépendants communiquent les uns avec les autres en utilisant des API langage-agnostiques.
Des API REST sont souvent employées pour relier chaque microservice aux autres. Un avantage avancé est que lors d'un besoin critique en une ressource, seul le microservice lié sera augmenté, contrairement à la totalité de l'application dans une architecture classique, par exemple une architecture trois tiers. Cependant, le coût de mise en place, en raison des compétences requises, est parfois plus élevé.

Le but est de fragmenter ce qui aurait du être une application monolithique souvent difficile à tester et maintenir en de multiples petites applications faiblement couplées qui communiquent entre elles avec des protocoles de communication simple.

Avantages et Inconvénients

Les avantages 

  • Chaque microservice est relativement petit, il répond à une fonctionnalité bien spécifique. Il est donc plus facilement testable.
  • Tous les services peuvent être développés de façon indépendant les uns des autres, il est donc plus facile à déployer. Chaque microservice peut donc avoir son propre langage de programmation et choisir la meilleur "pile technologique" pour répondre au besoin.
  • Plus facile à développer, il est donc plus facile à maintenir ou à faire évoluer.
  • Les pannes sont plus isolées. Si un service tombe en panne il y a peut d’impact sur les autres.

Les inconvénients

  • Il ne faut pas sous-estimer la complexité du développement d'une architecture distribuée. Il ne faut pas hésiter à utiliser des frameworks ou des librairies pour simplifier la mise en place d'une telle architecture.
    • De par leur nombre, le déploiement et la gestion peuvent devenir complexe. Il faut mettre en place un système de monitoring.
    • La forte dépendance au réseau : une hausse du trafique dû aux nombreux appelles entre microservice ainsi qu'une forte dépendance au bon fonctionnement de celui-ci : pas de réseau implique pas de message entre microservice

    Les communications

    Aujourd'hui on retrouve principalement 2 fonctionnements pour les microservices :
    • fonctionnement par ressources, qui utiliseront des api REST, avec un fonctionnement principalement synchrone.
    • fonctionnement par messages, qui utiliseront des bus logicielles "simples" avec un fonctionnement principalement asynchrone.

    Liens

    Wikipedia : Microservices
    Martin Fowler : Microservices, a definition of this new architectural term
    Microservice architecture patterns and best practices

    dimanche 21 septembre 2014

    mardi 16 septembre 2014

    Arduino : encodeur rotatif (KY040)

    Je vous propose de voir une première utilisation simple d'un encodeur rotatif : le KY040 avec un arduino UNO.



    Un exemple courant d'utilisation est le bouton d'un autoradio qui permet le réglage du volume mais aussi d'allumer et d'éteindre la radio. Il ressemble beaucoup à un potentiomètre mais contrairement à lui il n'est pas limité dans ça rotation et envoie un signal à chaque "crans". Il y a 30 crans par tour et l'on est capable de déterminer le sens de rotation de l'encodeur. Pour cela, l'encodeur nous envoie 2 signaux (on parlera du signal A et B) comme suit :


    Source : Arduino UNO Tutorial 6 - Rotary Encoder
    Pour faire simple, lorsque l'on est sur un cran, A et B ont le même niveau logique (0 ou 1). Si on tourne dans le sens horaire, on reçoit le changement d'état de A avant B et si on tourne dans le sens contraire on reçoit B avant A.

    Mise en place du hardware

    Pour "capturer" la rotation nous utiliserons les "interruptions" disponibles sur les entrées 2 et 3 de l'arduino. L'Uno ne disposant que de 2 entrées avec gestion des interruptions, le switch sera géré dans la fonction "loop".

    Au niveau hardware, rien de compliqué :
    • DT   --> pin 2
    • CLK --> pin 3
    • SW  --> pin 4
    Nous utiliserons l'écran LCD pour afficher le compteur ainsi que l'état des 3 entrées :
    • rs (LCD pin 4) --> Arduino pin 12
    • enable (LCD pin 6) --> Arduino pin 10
    • LCD D4 --> Arduino pin 8
    • LCD D5 --> Arduino pin 7
    • LCD D6 --> Arduino pin 6
    • LCD D7 --> Arduino pin 5

    Le programme correspondant

    On utiliser un "unsigned int" pour stocker un compteur que l'on incrémente ou décrémente suivant le sens de rotation de l'encodeur. Un appuis dessus remettra à 0 ce compteur.

    De part l'utilisation d'un "unsigned int", ce compteur est forcement compris entre 0 et 65535.

    Dernier point important, ce type de bouton génère des rebonds aux niveaux des entrées de l'arduino. Il faut donc un système d'anti-rebond. il existe plusieurs possibilités, soit hardware en utilisant par exemple des condensateurs (0.1µF devrait être bon), soit logique via un peu de code. C'est cette dernière solution que j'ai utilisé.

     

    include <liquidcrystal.h>

    LiquidCrystal lcd(12, 11, 10, 8, 7,6,5);

    // définition des pin pour le KY040
    enum PinAssignments {
      encoderPinA = 2,   // right (DT)
      encoderPinB = 3,   // left (CLK)
      clearButton = 4    // switch (SW)
    };

    volatile unsigned int encoderPos = 0;  // un compteur
    unsigned int lastReportedPos = 1;   // gestion du changement
    static boolean rotating=false;      // gestion de l'anti-rebonds

    // variable pour les routines d'interruption
    boolean A_set = false;             
    boolean B_set = false;
    boolean A_change = false;
    boolean B_change= false;

    void setup() {
      lcd.begin(20,4);
      lcd.clear();

      pinMode(encoderPinA, INPUT_PULLUP); // utilisation du pullup
      pinMode(encoderPinB, INPUT_PULLUP); // utilisation du pullup
      pinMode(clearButton, INPUT_PULLUP); // utilisation du pullup
      // activation de l'interruption 0 (pin 2)
      attachInterrupt(0, doEncoderA, CHANGE);
      // activation de l'interruption 1 (pin 3)
      attachInterrupt(1, doEncoderB, CHANGE);
    }

    void loop(){
      if (lastReportedPos != encoderPos) {
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Index: ");
        lcd.print(encoderPos, DEC);
        lastReportedPos = encoderPos;
        lcd.setCursor(0,1);
        lcd.print(digitalRead(encoderPinA));
        lcd.print(digitalRead(encoderPinB));
        lcd.print(digitalRead(clearButton));
      }
        lcd.setCursor(0,1);
        lcd.print(digitalRead(encoderPinA));
        lcd.print(digitalRead(encoderPinB));
        lcd.print(digitalRead(clearButton));
       
      if (digitalRead(clearButton) == LOW )  {
        encoderPos = 0;
        A_change = false;
        B_change= false;
        lcd.print(encoderPos);
      }

      delay (100);
    }

    // Interruption sur changement d'état de A
    void doEncoderA(){
      // debounce
      if ( rotating ) delay (1);  // attendre un petit peut
      rotating = true; //activation de l'anti-rebond
      // Confirmation du changement
      if( digitalRead(encoderPinA) != A_set ) {
        A_set = !A_set;

        if (B_change) {
          encoderPos += 1;
          B_change = false;
        } else
          A_change = true;

        rotating = false;  //libération de l'anti-rebond
      }
    }

    // Interruption sur changement d'etat de B
    void doEncoderB(){
      if ( rotating ) delay (1);
      rotating = true;
      if( digitalRead(encoderPinB) != B_set ) {
        B_set = !B_set;

        if (A_change) {
          encoderPos -= 1;
          A_change = false;
        } else
          B_change = true;

        rotating = false;
      }
    }


    Source : Arduino, Arduino UNO Tutorial 6 - Rotary Encoder, Using a Rotary Encoder with the Arduino

    vendredi 8 août 2014

    Arduino : Afficher la date et l'heure sur un LCD

    Pour afficher l'heure et la date et surtout ne pas perdre ces informations si l'arduino UNO n'est plus alimenté, on a besoin d'un module RTC à base de DS1307 (datasheets). On en trouve facilement sur internet à des prix très bas.


    Ce module embarque, en plus du composant DS1307, une pile qui permet de sauvegarder l'heure. Cette pile (CR2032) à une durée de vie de plusieurs années.

    Pour utiliser ce module on va avoir besoin d'une librairie non fournie avec l'IDE Arduino. Celle-ci peut être téléchargée ici (il suffit de faire "Download Zip" et de décompressé l'archive directement dans le répertoire librairies de l'IDE).

    Cette librairie propose un exemple ("ds1307") permettant de mettre à jour le module avec l'heure de votre ordinateur (attention : l'heure utilisée est UTC). Pour cela, il suffit de décommenter la ligne "RTC.adjust(DateTime(__DATE__, __TIME__));".

    Tout d'abord le branchement

    Le branchement est relativement simple. On se base sur le montage du LCD vu précédemment.
    Le module RTC DS1307 ce branche comme suit:

    • Gnd --> GND
    • Vcc --> 5 V
    • Sda --> analog pin A4
    • Scl --> analog pin A5

    Le programme correspondant

    /************************************************************
    Horloge Arduino
    Horloge simple avec un Arduino Duo, un module RTC DS1307
    et un afficheur LCD 20x4.

    Branchements du RTC DS1307:
    Gnd --> GND
    Vcc --> 5 V
    Sda --> analog pin A4
    Scl --> analog pin A5

    Branchements de l'afficheur LCD:
    rs (LCD pin 4) --> Arduino pin 12
    enable (LCD pin 6) --> Arduino pin 10
    LCD D4 --> Arduino pin 5
    LCD D5 --> Arduino pin 4
    LCD D6 --> Arduino pin 3
    LCD D7 --> Arduino pin 2

    ***************************************************************/

    #include <liquidcrystal.h>
    #include <wire.h>
    #include <rtclib.h>

    LiquidCrystal lcd(12, 11, 10, 5, 4,3,2);
    RTC_DS1307 rtc;

    void setup() {
        lcd.begin(20,4);
        lcd.clear();

        Wire.begin();
        rtc.begin();
    }

    void loop(){
        DateTime now = rtc.now();

        lcd.setCursor(0,0);
        lcd.print(now.year());
        lcd.print("/");
        if (now.month()<10) lcd.print="0";
        lcd.print(now.month());
        lcd.print("/");
        if (now.day()<10) lcd.print="0";
        lcd.print(now.day());
        lcd.print(" ");
        if (now.hour()<10) lcd.print="0";
        lcd.print(now.hour());
        lcd.print(":");
        if (now.minute()<10) lcd.print="0";
        lcd.print(now.minute());
        lcd.print(":");
        if (now.second()<10) lcd.print="0";
        lcd.print(now.second());

        delay(900);
    }

    Source : Arduino, Librairie RTC, Datasheet du DS1307

    samedi 5 avril 2014

    Arduino: 1er pas avec un LCD

    Voila un premier programme qui permet l'utilisation d'un écran LCD 20x4 (20 caractères sur 4 lignes).
    Cette écran sera très utile par la suite pour afficher des informations lors d'exécution de programme.

    Tout d'abord le branchement

    Dans ce premier programme, nous brancherons l'écran LCD directement sur l'Arduino UNO. Nous verrons plus tard qu'il est possible d'utiliser un module I2C pour libérer les ports de l'Arduino.


    Le programme correspondant

    #include <liquidcrystal.h>

    // Connections:
    // rs (LCD pin 4) to Arduino pin 12
    // enable (LCD pin 6) to Arduino pin 10
    // LCD pins d4, d5, d6, d7 to Arduino pins 5, 4, 3, 2
    LiquidCrystal lcd(12, 11, 10, 5, 4, 3, 2);

    void setup()
    {
      lcd.begin(20,4);           // Initialisation du lcd : 20 columns, 4 rows.
      lcd.clear();                   // Effacer le LCD
      lcd.setCursor(0,0);      // Positionner le curseur sur le 1er caractere de la 1er ligne
      lcd.print("Hello, World"); // Ecrire
      lcd.setCursor(0,1);     // Positionner le curseur sur le 1er caractere de la 2eme ligne
      lcd.print("Row 2");
      lcd.setCursor(0,2);     // Positionner le curseur sur le 1er caractere de la 3eme ligne
      lcd.print("Row 3");
      lcd.setCursor(0,3);     // Positionner le curseur sur le 1er caractere de la 4eme ligne
      lcd.print("Row 4");
    }

    void loop()
    {
    }

    Source : Arduino

    lundi 4 mars 2013

    PMD: Ajouter une régle XPath dans Sonar

    Sonar utilise plusieurs outils pour effectuer ses mesures de qualité de code. Malgré les ~1000 règles utilisées, il est parfois nécessaire de rajouter nos propres règles suivant les "bonnes pratiques" que l'on a mis en place.
    Un des outils qu'il utilise est PMD et celui-ci permet facilement de rajouter une règle en se servant du mécanisme des XPath.

    Un peu de théorie

    Sonar :
    Sonar est un logiciel libre permettant de mesurer la qualité du code source sur les projets de développement java. Sonar est distribué selon les termes de la licence LGPL v3.

    PMD :
    PMD est un framework qui permet d'analyser le code source Java. Il contient un certain nombre de règles qui assure la qualité de code : le code inutile, les imbrications trop complexes... Il permet d'obtenir le résultat par le biais d'un rapport.

    PMD utilise l'AST (Abstract Syntax Tree), plus exactement le Java AST pour exécuter ces règles.

    La pratique

    Un tutorial sur l'ajout de règle via XPath est proposé sur le site de PMD : http://pmd.sourceforge.net/pmd-5.0.2/xpathruletutorial.html. Mais celui-ci reste très basique. De plus, il est fastidieux de tester notre XPath directement dans Sonar.

    PMD Rule Designer

    Un outil, fort pratique, a été mis à disposition par l'équipe de PMD pour nous permettre d'écrire et de tester nos nouvelles règles. Celui-ci est fourni avec les binaires de PMD. Sinon un package exécutable a été fait par Usman Ismail sur le site http://www.techtraits.com. On peut le télécharger ici.
    Cette outil prend un code source (ctrl-c, ctrl-v) et montre son équivalent en AST sous forme d'arbre ce qui permet de construire son XPath sans forcément connaitre les noms de tous les éléments possible et ensuite de le tester sur ce même code.

    PMD Rule Designer

    Source : Sonar (Wikipédia),PMD (Wikipédia), Custom PMD rules using XPath