Le blog de BokC

Intégrer des icônes SVG avec Angular Material

2023-12-16T08:00:00.103+01:00

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.

Design Pattern Composite : exemple C#

2023-03-29T08:00:00.002+02:00

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());
}

Les microservices - Introduction

2016-04-18T08:00:00.000+02:00

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

Revue du web S3-2015

2015-01-18T21:00:00.000+01:00

Quelques liens intéressant :

Développement

Java

Testing with files and directories in JUnit with @Rule

Design pattern

10 Object Oriented Design Principles Java Programmer should know

Revue du web S51-2014

2014-12-21T21:00:00.000+01:00

Les liens de la semaines :

Developpement

Agilité

Chapitre 9 du livre de Sandro Mancuso sur le Software Craftsmanship

Java

EAGER fetching is a code smell

Revue du web S50-2014

2014-12-14T21:00:00.000+01:00

Quelques articles intéressants découverts cet semaine :

Développement

Agilité

Imprimante 3D

GCode Simulator

Revue du web S49-2014

2014-12-07T21:00:00.000+01:00

Les liens de la semaine :

Developpement

Agilité

Domotique

Thinking Cleaner et votre robot aspirateur Roomba est compatible Wi-Fi et Apple HomeKit

Revu du web S48-2014

2014-11-30T21:00:00.000+01:00

Quelques liens interressants découverts cette semaine :

Developpement

Agilité

Revu du web S47-2014

2014-11-23T21:00:00.000+01:00

Les liens de la semaines :

Developpement

Agilité

Clubic Pro > IT business > Sécurité et données Mozilla, l'EFF et Cisco lancent des certificats SSL gratuits pour chiffrer le Web

Revu du web S44-2014

2014-11-02T21:00:00.000+01:00

Les liens de la semaines :

Imprimante 3D

Developpement

Agilité

Chapitre 4 du livre de Sandro Mancuso sur le Software Craftsmanship
Un site sur les Katas : CodeKata

Domotique

Mort programmée du Karotz : La fin des aventures de Karotz

Revu du web S43-2014

2014-10-26T21:00:00.000+01:00

Quelques belles découvertes cette semaine :

Développement

Java

Une liste de frameworks, librairies et logiciels pour java, classés par théme : Awesome java

Android

Android : les bibliothèques utiles

Agile

Chapitre 3 du livre de Sandro Mancuso sur le Craftsmanship

Arduino

Un pilote distribué par Windows Update « brique » une puce aimée des bidouilleurs

Impression 3D

Microsoft vous invite à transformer votre Kinect en scanner 3D

Revu du web S42-2014

2014-10-19T21:00:00.000+02:00

Les découvertes de la semaine :

Arduino

Carte de développement Intel Galileo 2eme génération : présentation Intel, présentation Arduino.
L'imprimante 3D Arduino est en pré-vente!!!

Raspberry Py

Compute Module IO Board Hardware Design Files Now Available!

Drone

La fondation Linux lance : Dronecode

Développement

Agilité

Revu du web S41-2014

2014-10-12T21:00:00.000+02:00

Les découvertes de la semaine :

Domotique

Programmation

Bibliotheque d'objet 3D : Cults

Revu du web S40-2014

2014-10-05T21:00:00.000+02:00

Quelques découvertes durant cette semaine :

Electronique

Feuilles de calcul pour les éléments de filtres (passe haut, passe bas, ...)

Matérialiser une idée n’a jamais été aussi simple avec Pango

Tier lieux

Panorama : comment creer un tiers lieu?

Développement

Agile

Java

Simplifier votre code : projet Lombok

Revu du web S39-2014

2014-09-28T21:00:00.000+02:00

Quoi de neuf cette semaine?

Développement :

DIY

Outillage :

Et hop ! Un deuxième établi fait maison...

Revu du web S38-2014

2014-09-21T20:00:00.000+02:00

Je vous propose un mélimélo de lien découvert cette semaine sur la toile :

Photos :

Qingyan Old Town

Domotique :

Une box domotique qui monte : jeedom

DIY :

Imprimante 3D

Dremel présente une imprimante 3D grand public à $999

Raspberry :

New Raspbian and NOOBS releases

Arduino :

Arduino Internet Time Client

FabLab:

FABLAB DES VOSGES

Arduino : encodeur rotatif (KY040)

2014-09-16T08:00:00.000+02:00

Widgets Amazon.fr

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

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

2014-08-08T08:00:00.001+02:00

Widgets Amazon.fr

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

Arduino: 1er pas avec un LCD

2014-04-05T08:00:00.000+02:00

Widgets Amazon.fr

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

PMD: Ajouter une régle XPath dans Sonar

2013-03-04T08:00:00.000+01:00

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

Domotique : Commande groupée

2013-02-11T10:06:00.000+01:00

Le site "Toute la Domotique" effectue jusqu'au 03 Mars 2013 à 20h une commande groupée en partenariat avec le site "solution-domotique.com".

Pour les intéressés, c'est par la.

Domotique : Commande groupée

2012-11-22T09:27:00.001+01:00

Le site "Toute la Domotique" effectue du 26 novembre au 7 décembre une commande groupée en partenariat avec le site "Planete-domotique.com".

Pour les intéressés, c'est par la.

OWFS : Régle de nommage des composants 1-Wire

2012-09-14T08:00:00.000+02:00

Le fabricant à créé un système de nommage unique des composants 1-Wire. Cette règle de nommage à été reprise par les développeurs de l' application OWFS.

Chaque répertoire (correspondant au composant connecté) est nommé de la façon suivante :

XX. YYYYYYYYYYYY

XX : représente l'ID au format hexadecimal du composant, son numéro de famille. Chaque famille est représenté par un ID différent.
YYYYYYYYYYYY : représente le numéro de série du composant. Deux composants ne peuvent pas avoir le même n° de série.

Voila la liste des Id correspondants aux diffèrentes familles de composants :

ID	Composant	Commentaire
01	DS2401 DS1990A
02	DS1991 DS1425
04	DS1994 DS2404
05	DS2405
06	DS1993
08	DS1992
09	DS1982 DS2502
0A	DS1995
0B	DS1985 DS2505
0C	DS1996
0F	DS1986 DS2506
10	DS1920 DS1820 DS18S20	Thermomètre de précision pouvant fonctionner en mode parasite
12	DS2406 DS2407
13	DS1983 DS2503
14	DS1971
18	DS1963S
1A	DS1963L
1D	DS2423
1F	DS2409
20	DS2450
21	DS1921
22	DS1822
23	DS1973
24	DS1904 DS2415
26	DS2438
27	DS2417
28	DS18B20	Thermomètre à précision ajustable
2C	DS2890
30	DS2760
33	DS1961S DS2432
39	DS1977
41	DS1922 DS2422
81	DS9490R

OWFS : script pour le demarrage

2012-09-02T08:00:00.000+02:00

Configuration pour le démarrage automatique de owfs

Créer le fichier /etc/init.d/owfs.sh

#! /bin/sh
### BEGIN INIT INFO
# Provides:          owfs
# Required-Start:
# Required-Stop:
# Default-Start:     2 3 4 5
# Default-Stop:      0 6
# Short-Description: run owfs
# Description:        run owfs
### END INIT INFO

MOUNTPOINT='/mnt/1Wire'
case "$1" in
start)
        echo "Starting script owfs with USB support...";
        echo `/usr/bin/owfs -u -s localhost:4304 --allow_other --mountpoint=$MOUNTPOINT`;
        ;;
stop)
        echo "stopping script owfs by unloading mount-point ..";
        echo `umount $MOUNTPOINT`;
        ;;
*)
        echo "Usage: $N {start|stop}" >&2
        exit 1
        ;;
esac
exit 0

Puis faire :

#sudo update-rc.d owfs.sh defaults

Source : Sebastien Mei, owfs.org

OWFS : installation sur une Debian "Wheezy"

2012-09-01T08:00:00.000+02:00

Owfs - présentation

C’est l’exploitation d'owserver sous forme de système de fichiers.

Owserver s’occupe des communications avec le DS9490R, il tourne en tant que serveur à l’écoute sur le port 4304 (cf conf /etc/owfs.conf).
Owfs, va interroger le serveur pour rendre un résultat sous forme de répertoires et de fichiers.
L’intérêt est de rendre le 1-wire plus malléable et de répondre à certains besoins.

Verification

Connecter votre contrôleur 1-wire DS9490R sur l'un de vos ports USB. Pour s'assurer qu'il est bien reconnu tappez :

# lsusb

Vous devez voir votre clef apparaite dans la liste:

Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 002 Device 003: ID 04fa:2490 Dallas Semiconductor DS1490F 2-in-1 Fob, 1-Wire adapter

Installation

OWFS se trouve dans le repository. Il suffit donc de faire un simple apt-get :

# sudo apt-get install owserver ow-shell owhttpd owfs-fuse

Configuration

Il faut ensuite modifie le fichier /etc/owfs.conf, commenter la ligne 16, décommenter la 19 :

# This part must be changed on real installation
#server: FAKE = DS18S20,DS2405
#
# USB device: DS9490
server: usb = all

Restart pour la prise en compte :

# sudo /etc/init.d/owserver restart

On crée un point de montage et on monte :

# sudo mkdir /mnt/1wire/
# sudo owfs -s localhost:4304 -m /mnt/1wire/ --allow_other

Résultat :

# ls -lh
total 0
drwxrwxrwx 1 root root 8 mars 11 00:09 81.BD2223000000
drwxr-xr-x 1 root root 8 mars 10 23:56 alarm
drwxr-xr-x 1 root root 8 mars 10 23:56 bus.0
drwxr-xr-x 1 root root 8 mars 10 23:56 bus.1
drwxr-xr-x 1 root root 8 mars 10 23:56 settings
drwxrwxrwx 1 root root 8 mars 11 00:09 simultaneous
drwxr-xr-x 1 root root 8 mars 10 23:56 statistics
drwxr-xr-x 1 root root 32 mars 10 23:56 structure
drwxr-xr-x 1 root root 8 mars 10 23:56 system
drwxr-xr-x 1 root root 8 mars 10 23:56 uncached

Source : Domolio, owfs.org