Laurent Ellerbach

Ce blog est principalement destiné à publier des informations relatives à Microsoft, à ses technologies, aux outils Visual Studio et à ses versions Express notamment Visual Basic

  • Laurent Ellerbach

    frimr du Web 2.0…

    • 0 Comments

    Dans le monde du Web, il y a ceux qui sont « in » (Web 2.0) et ceux qui sont « out » (Web 1.0) et ceux qui n'existent pas (pas Web ou encore au minitel, il paraît qu'il y en aurait encore quelques uns). Pour découvrir le monde du Web 2.0, sérieux et respectable, il ne faut en aucun manquer le site FRIMR. THE site sur lequel aller si vous avec un « gros moi » (bref si vous êtes « in ») : http://www.frimr.com/

  • Laurent Ellerbach

    Un peu d'humour en cette pério de rentrée des classes...

    • 0 Comments

    C'est à peu près ce que mon fils m'a dit quand il est rentré de son premier jour de classe...

     

    Rough First Day
  • Laurent Ellerbach

    J’ai hacké mon onduleur ou le reverse engineering de protocoles de communication (part 9)

    • 1 Comments

    Comme indiqué dans mon précédent post, je vais expliquer le fonctionnement d'un timer. Très utilise lorsqu'on souhaite faire une action spécifique à intervalle régulier. Je vais également en profiter pour montrer comment créer une propriété en lecture et écriture. En plus, je vais expliquer comment lever des exceptions dans son propre code.

    Une bonne partie de tout cela se trouve condensé dans la fonction d'ouverture de l'onduleur. Voici donc le code avec les déclarations de variables et constantes nécessaires à la compréhension.

     

    Const ERREUR_IDENTITE = "Impossible d'obtenir l'identité de l'onduleur"

    Const ERREUR_ALIM_BATTERIE = "Impossible d'obtenir les informations de batterie"

    Const ERREUR_ALIM_SECTEUR = "Impossible d'obtenir les informations de secteur"

    Const PERIOD_APPEL = 3000 '2 secondes = 2000 milisecondes

    Private myPeriodeAppel As Integer = PERIOD_APPEL

    Private myPort As SerialPort

    Private myPortSerie As String = "" 'stocke le nom du port

    Private myTimer As Timer

     

    Public Function Ouvrir(ByVal StrPort As String) As Boolean

    Try

    'ouvre le port série avec le bonnes infos

    myPortSerie = StrPort

    myPort = New SerialPort(StrPort, 2400, Ports.Parity.None, 8, Ports.StopBits.One)

    'le caractère de fin de ligne est chr(13), c'est à dire Entrée

    myPort.NewLine = Chr(13)

    'délais d'attente de 2 secondes

    myPort.ReadTimeout = 2000

    myPort.Open()

    myPort.DtrEnable = True

    'vérifie que l'on a bien un onduleur et rempli les bonnes fonctions

    If Not (EnvoiCommande(OnduleurCommande.Identite)) Then

    Throw New System.Exception(ERREUR_IDENTITE)

    End If

    If Not (EnvoiCommande(OnduleurCommande.Batterie)) Then

    Throw New System.Exception(ERREUR_ALIM_BATTERIE)

    End If

    If Not (EnvoiCommande(OnduleurCommande.Tension)) Then

    Throw New System.Exception(ERREUR_ALIM_SECTEUR)

    End If

    'toutes les propriétés ont été remplies

    'intialise le timer, récupère les infos toutes les 5 secondes

    myTimer = New Timer(AddressOf VerifierStatut)

    myTimer.Change(0, myPeriodeAppel)

    Return True

    Catch ex As Exception

    'si ça ne s'ouvre pas, répercute l'exception

    Throw ex

    Return False

    End Try

    End Function

    La fonction Ouvrir prend un paramètre qui doit contenir une chaîne de type COM1, COM2 ou autre permettant d'ouvrir le port série. Le tout se trouve dans un try – catch qui va permet de récupérer les exceptions qui peuvent être levées. En cas de problème, sur le port série, il est important de ne pas laisser planter l'application et de le remonter à l'appelant.

    Sur le même principe, lorsque le port série est ouvert, la fonction EnvoiCommande(OnduleurCommande.Identite) renvoie True si les informations de type modèle, sous modèle, version sont récupérés. Si ce n'est pas le cas, elle renvoie False. Du coup, si un onduleur n'est pas présent, les informations ne seront pas récupérées et False sera renvoyé. Dans ce cas, nous sommes devant un problème et on lève une exception. Cela se fait simplement à l'aide le la ligne Throw New System.Exception("ce que l'on veut envoyer"). Simple et efficace.

    Quand au timer, simple également. Il suffit de déclarer une variable de type Timer, ici myTimer. Ensuite, il faut créer une fonction de callback (rappel). Elle permettra au lors du déclanchement du timer de venir se brancher et d'exécuter le code de la fonction. La fonction de call back s'appelle VerifierStatut. Sa définiton est ci-dessous. L'initialisation se fait donc en indiquant myTimer = New Timer(AdressOf VerifierStatut). AdressOf renvoie un pointeur de la fonction de callback. Il ne reste plus qu'à initialiser le timer : myTimer.Change(0, myPeriodeAppel). 0 indique qu'il doit se déclencher maintenant. Le myPeriodeAppel indique l'intervalle en milli secondes d'appel de la fonction de callback.

    Private Sub VerifierStatut(ByVal stateInfo As Object)

    'pas de vérification particulière. En cas de problème, les exceptions sont trappées dans la fonction EnvoiCommande

    EnvoiCommande(OnduleurCommande.Tension)

    End Sub

    Dans mon cas, par défaut, lors de l'ouverture de l'onduleur, l'appel se fait toutes les 3000 milli secondes soit toutes les 3 secondes. J'ai implémenté en plus dans ma gestion d'onduleur une propriété qui permet de modifier cette valeur. Je ne sais pas encore par avance tous les combiens de temps, il est nécessaire de l'appeler. Donc, je me garde la possibilité de modifier cette valeur. Cependant, pour des questions de performances, je ne souhaite pas que l'appel soit fait à moins d'une seconde. J'exprime donc ma propriété en secondes et choisi des byte.

    L'implémentation de la propriété donne cela :

    Public Property PeriodeAppel() As Byte

    Get

    Return (myPeriodeAppel / 1000)

    End Get

    Set(ByVal value As Byte)

    If value > 0 Then

    myPeriodeAppel = value * 1000

    myTimer.Change(0, myPeriodeAppel)

    End If

    End Set

    End Property

    La lecture (Get) est simple, je renvoie la période d'appel divisée par 1000 car en interne ma variable est en milli secondes.

    Pour l'écriture (Set), je vérifie que la valeur est bien supérieur à 0 (donc au moins égale à 1). Je la multiplie par 1000, et je change la période d'appel de mon timer.

    Avec VB.NET, il est donc très facile de lever des exceptions, facile également d'implémenter et gérer un timer, de mettre en place des propriétés, en lecture et en écriture. Avec un comportement particulier qui modifie l'application dans la partie lecture ou écriture.

    Le prochain post sera certainement consacré à la mise en place d'un service Windows. Seule chose qu'il me reste à faire par rapport à mon ambition d'origine ! So stay tune…

  • Laurent Ellerbach

    J'ai reparamétré tout mon réseau...

    • 0 Comments

    Bon, je sais, ça va juste faire rire mais je suis fier de moi :-D J'ai reparamétré tout mon réseau ce soir à la maison. Tout est parti de mon passage à Vista RC1 hier. Et oui, en arrivant chez moi, il m'a fallu me reconnecter à mon réseau Wireless. Et c'est là que j'ai commencé à pâlir… J'ai 2 bornes, l'une est une vieille Compaq qui se manage avec un soft à condition de connaître son adresse IP et l'autre, c'est une borne MN-500 de Microsoft. Je l'ai passé en mode bridge le jour où j'ai installé ma neuf box (je sui passé récemment chez Neuf en dégroupage total).

    Seul problème, c'est que depuis, impossible de me connecter dessus… Et oui, en suivant la notice, elle devient non manageable (au préalable, il était possible de se connecter à une page Web pour l'administrer). C'est le seul endroit où ma clé Wep était stockée en clair… Pas de bol… Bref, il me fallait trouver une solution pour au moins me connecter en Wireless chez moi avec mon nouveau Vista. Du coup, j'ai essayé d'installer les outils de management de la borne, sans succès (on ne sait jamais si le soft avait été super bien fait, il aurait au moins trouvé la borne à travers les adresses MAC). Mais rien. Bref, il m'a fallut la reseté hard (j'ai cherché un bon moment) et finalement, j'ai réussit à m'y connecté. Cette fois, je n'ai pas fait la manip de la doc, juste une manip un peu plus simple, je lui ai donné une IP fixe dans le range des IP qui vont bien hors du scope DHCP. J'ai reparamétré le Wireless, remis une nouvelle clé WEP. Du coup, j'ai retrouvé et installé les outils de management de mon autre borne pour lui donner la nouvelle clé. Mais là pas glop non plus, pas de moyen simple de trouver son IP. En effet, la partie réseau de la neuf box est pour être polie très mal fichue et ne permet même pas d'avoir la liste des machines auxquelles elle a distribué des IP. Pire, elle distribue même des adresses IP identiques à plusieurs machines… Je me suis donc motivé, j'ai pris le taureau par les cornes et j'ai décidé d'ajouter un rôle à mon fabuleux serveur Windows 2003 Server. J'ai donc ajouté le rôle DHCP. J'ai tout paramétré bien comme il faut, créé les étendues qui vont bien, ajouter l'adresse de la neuf box comme routeur, ajouter les adresses DNS de la neuf box mais aussi les vraies qui sont distribues à la neuf box, quitte à faire autant être plus performant et éviter un routage. La neuf box est tellement pourrie (aï, j'ai été un peu moins poli) qu'il n'est même pas possible d'arrêter le DHCP proprement. Bref, un peu de bidouille et elle ne semble pas distribué d'adresse (au pire, j'ai poubélisé une plage d'une adresse).

    Hop, un reboot de la borne Compaq et elle récupère une IP bien propre. Le soft de management là-dessus, le mot de passe d'accès (ouf, je m'en souvenais) et j'ai donné la nouvelle clé (je me suis souvenu de l'astuce du 0xclé-en-hexa pour remettre la clé correctement). Je me suis reconnecté aux bornes avec mon PC sous Vista et j'ai testé indépendamment les deux bornes wireless pour vérifier que tout soit OK. J'ai donc repassé la clé sur le PC de la cuisine (connecté exclusivement en wireless) et le Windows Média Center de la salle (je ne m'en sers pas en wireless mais j'ai paramétré quand même).

    Bref, maintenant, tout marche, mes machines récupèrent bien une IP qui n'est pas déjà distribuée sur le réseau, je peux avoir accès à la liste et au nom des machines et je peux administrer mes 2 bornes. Cool !

    Total 2 heures pour réussir à remettre tout cela dans le droit chemin :-)

  • Laurent Ellerbach

    Comment installer Visual Studio Express sur Vista RC1

    • 1 Comments

    Hier, j'ai fait le grand saut sur la toute dernière build 552 (la RC1 officielle de Vista). Il m'a fallu 2h30 pour sauvegarder les données et seulement une trentaine de minutes pour installer Vista… J'y ai ajouté Office 12 Beta technical refresh en français. Viens maintenant l'installation de Visual Basic Express (version gratuite, comme les autres de la gamme Visual Studio Express).

    J'ai suivi les recommandations d'être un simple utilisateur sur ma machine (seulement membre du groupe user). Ca a parfaitement été pour installer Office 12 (moyennant élévation de privilège sur demande automatique de Vista). Ca a également été pour quelques autres applications.

    Par contre, avec Visual Studio Express, ça ne fonctionne pas. Ca a l'air dû à un problème avec le BITS (le background internet transfer service) qui gère les téléchargements en tâche de fond. Du coup, aucun produit de la gamme Express ne s'installe. Une erreur au chargement des produits on line est renvoyée.

    Le contournement consiste donc à s'ajouter au groupe des administrateurs locaux (administrators en anglais ou administreurs en français), de se déloguer et de se reloguer (attention, pour que l'ajout au groupe prenne pleinement effet, il faut se déloguer et se reloguer).

    Ensuite, l'installation se passe sans histoire. Le produit fonctionne parfaitement bien. Il est ensuite possible de se retirer du groupe des administrateurs et le produit continue de parfaitement fonctionner. Attention, suivant le code que vous écrivez, les demandes d'élévation de privilèges vont être nombreuses. En même temps, c'est très bien pour apprendre à écrire du code qui nécessite un minimum de permission.

  • Laurent Ellerbach

    J’ai hacké mon onduleur ou le reverse engineering de protocoles de communication (part 8)

    • 4 Comments

    J’ai donc continuer de développer ma solution de gestion d’onduleur. J’ai profité de mon retour à la maison pour continuer les tests physiques sur mes onduleurs. Oui, j’ai bien dit mes onduleurs. En fait, j’en possède 3 du même modèle. Ce qui a aussi motivé l’écriture de ce service de gestion…

    La suite des tests m’a permis de compléter le protocole de communication et de déterminer à quoi servent la plupart des bits :

    00001000 = statut. 1 bit par info.

    b0b1b2b3b4b5b6b7

    • b0 = passe à 1 lorsqu’une panne de courant arrive, lorsque l’alimentation est coupée
    • b1 = passe à 1 lorsque la batterie est faible
    • b2 = ??? pas encore déterminé. Impossible en utilisation normale de le faire passer à 1. Il reste à 0.
    • b3 = ??? Idem
    • b4 = est à 1 en fonctionnement normal. Il indique que les sorties sont alimentées
    • b5= passe à 1 quand on est en mode test. Le mode test est déclenché par l’envoie de la commande T
    • b6 = ??? pas non plus réussit à déterminer à quoi ce bit sert
    • b7 = passe à 1 quand l’alimentation est sur batterie

    Cela m’a également permis d’étalonner les niveau de la batterie. Le niveau haut varie de 14 à 10,7. L’échelle de consommation est quasi linéaire.

    Côté code, j’ai décidé d’implémenter des événements. Ainsi, lorsqu’un de ces bits change, j’envoie l’événement correspondant. Cela permet de gérer avec de la souplesse ce qui peut arriver. Il faut d’abord dans le code déclarer les événements :

    'se déclenche lorsque le secteur est coupé, en général va avec l'événement FonctionnementBatterie

    Public Event ArretAlimSecteur()

    'se déclenche lorsque le secteur est remis (et qu'il était coupé)

    Public Event RetourAlimSecteur()

    'lorsque l'onduleur fonctionne sur batterie

    Public Event FonctionnementBatterie()

    'ou lorsqu'il fonctionne de nouveau normalement

    Public Event ArretFonctionnementBatterie()

    'Lorsque la batterie est faible

    Public Event BatterieFaible()

    'lorsque l'onduleur est arrêté

    Public Event OnduleurArrete()

    Puis, pour chaque bit, on vérifie si un changement d’état s’est passé. Ca donne cela :

    'position 0 = panne secteur

    Dim BoolTemp As Boolean

    ' récupère la valeur (0 ou 1) du bit 0 de la chaîne de 8 bits

    BoolTemp = Val(mc.Item(7).Value.Substring(0, 1))

    If BoolTemp <> myOnduleurPanneSecteur Then

    If BoolTemp Then

    RaiseEvent ArretAlimSecteur()

    Else

    RaiseEvent RetourAlimSecteur()

    End If

    myOnduleurPanneSecteur = BoolTemp

    End If

    Le principe est simple, il faut récupérer la valeur dans une variable temporaire. Puis on compare à la valeur actuelle. Si la valeur est la même, alors pas de changement d’état et on ne fait rien. Si les valeurs sont différentes, alors on regarde la valeur de la variable.

    Dans le cas où le bit est à 1, alors cela signifie que le courant a été coupé. On envoie donc l’événement ArretAlimSecteur. Dans le cas où il passe à 0, on peut signifier que le courant est revenu en envoyant l’événement RetourAlimSecteur. Le mot magic RaiseEvent permet d’envoyer l’événement.

    Ne pas oublier à la fin d’attribuer la nouvelle valeur à la variable privée stockant cette information.

    Côté du code qui intercepte les événements, ce n’est pas plus compliqué. Il faut déclarer une variable avec le mot clé WithEvents.

    Public WithEvents myOnduleur As New Onduleur

    On se retrouve ensuite avec une fonction de ce type qui permet d’intercepter l’événement et de le traiter :

    Private Sub myOnduleur_ArretAlimSecteur() Handles myOnduleur.ArretAlimSecteur

    'Faire quelque chose ici :-)

     

    End Sub

     

    S’il y a des paramètres à passer, cela se passe de la même façon. Il suffit de les décrire dans la définition puis de les envoyer ans le RaiseEvent et de les récupérer comme avec n’importe quel événement dans la fonction Handles.

    L’utilisation des événements est donc très simple. Un vrai bonheur.

    Avec cela, j’ai fini d’écrire ma classe de gestion de l’onduleur. Elle permet de se connecter à l’onduleur, de récupérer les informations, en cas de panne de courant ou autre, d’envoyer l’événement correspondant.

    Je récupère les données de façon régulière à l’aide d’un timer. Le fonctionnement d’un timer au prochain post…

     

  • Laurent Ellerbach

    J’ai hacké mon onduleur ou le reverse engineering de protocoles de communication (part 7)

    • 0 Comments

    Me voici donc maintenant avec 3 chaînes de texte à analyser et dont il faut que je ressorte plusieurs informations. Les chaînes sont bien délimitées. Le protocole complet est expliqué dans le sixième post.

    Voici les 3 principales chaînes :

    • #BELKIN Master 1.00
    • (238.0 237.0 236.0 024 50.0 13.9 32.0 00001000
    • #230.0 2.2 12.00 50.0

    En temps normal, je rechercherais les espaces, j’extrairai les valeurs entre les espaces et les convertirais. Vu que les chaînes semblent avoir tout le temps la même taille, même pas la peine de regarder les espaces, un extrait de type mid( "#230.0 2.2 12.00 50.0",1,5) pour le 230.0 suffirait amplement. Chaque partie peut être extraite ainsi. Une simple vérification de longueur de chaîne suffira. Histoire de compliquer un peu la chose et surtout dans la philosophie de me remettre au code et d’apprendre de nouvelles choses, je me suis dit que je regarderais bien les expressions régulières. Et là, le bonheur. Je connaissais un peu la théorie mais pas du tout la pratique. Et je me suis bien amusé :-).

    Comme toujours, j’ai commencé par rechercher de l’info sur le sujet. D’abord la doc officielle sur le sujet (bof), puis des exemples sur MSDN (mieux) et dans les communautés (mieux). Je suis tombé sur pas mal d’applications qui permettaient de valider et tester ces expressions régulières et même de générer le code associé. Bien pratique pour se mettre en jambe.

    J’ai donc suivi quelques tutoriaux, fait quelques exemples et je me suis lancé pour mes propres chaînes. Je suis parti du principe, pour toutes les chaînes, que la taille des chaînes ne varierai pas et qu’elles étaient toujours formées de la même façon. Que si cela n’était pas respecté, il y avait erreur. Que pour la chaîne contenant du texte, il n’y avait que 2 mots renvoyés. Voici donc un peu de code (toujours pour faire plaisir à Benjamin) pour illustrer cela :

    Public Function DecryptTest(ByVal StrCrypter As String, ByVal IntTypeCrypter As OnduleurCommande) As Boolean

    Select Case IntTypeCrypter

    Case OnduleurCommande.Identite

    ' on décrypte le I : #BELKIN Master 1.00

    Dim re As New Regex("\b[A-Za-z].*?\b|\b\d\.\d\d\b")

    Dim mc As MatchCollection

    mc = re.Matches(StrCrypter)

    If mc.Count = 3 Then

    myModele = mc.Item(0).Value

    mySousModele = mc.Item(1).Value

    myModeleVersion = mc.Item(2).Value

    Else

    Return False

    End If

     

    Case OnduleurCommande.AlimentationBatterie

    ' on décrypte le F : #230.0 2.2 12.00 50.0

    Dim re As New Regex("\b\d\d\d\.\d\b|\b\d\.\d\b|\b\d\d\.\d\d\b|\b\d\d\.\d")

    Dim mc As MatchCollection

    mc = re.Matches(StrCrypter)

    If mc.Count = 4 Then

    myTensionSortieBatterie = Val(mc.Item(0).Value)

    myAmperageBatterie = Val(mc.Item(1).Value)

    myTensionBatterie = Val(mc.Item(2).Value)

    myFrequenceSortieBatterie = Val(mc.Item(3).Value)

    Else

    Return False

    End If

     

    Case OnduleurCommande.AlimentationSecteur

    ' on décrypte le Q1 : (238.0 237.0 236.0 024 50.0 13.9 32.0 00001000

    Dim re As New Regex("\b\d\d\d\.\d\b|\b\d\d\d\b|\b\d\d\.\d\b|\b\d\d\d\d\d\d\d\d")

    Dim mc As MatchCollection

    mc = re.Matches(StrCrypter)

    If mc.Count = 8 Then

    myTensionAlim = Val(mc.Item(0).Value)

    myTensionSortiePrimaire = Val(mc.Item(1).Value)

    myTensionSortieSecondaire = Val(mc.Item(2).Value)

    myPourcentageChargeOnduleur = Val(mc.Item(3).Value)

    myFrequence = Val(mc.Item(4).Value)

    myPourcentageChargeBatterie = (Val(mc.Item(5).Value) / 14.0 * 100.0)

    myTemperature = Val(mc.Item(6).Value)

    ' on s’occupera plus tard de la chaîne de 8 caractères

    Else

    Return False

    End If

    Case Else

    Return False

    End Select

     

    Return True

    End Function

    Pour lire le code, tous les myQuelqueChose sont des variables privées qui contiennent toutes les propriétés de l’onduleur. Le type dépend de la variable à stocker. La fonction Val a l’avantage d’être surchargée et de renvoyer des types standards.

    Analysons l’extraction des informations de la chaîne Q1. Création d’une expression régulière :

    Dim re As New Regex("\b\d\d\d\.\d\b|\b\d\d\d\b|\b\d\d\.\d\b|\b\d\d\d\d\d\d\d\d")

    Création d’une collection d’informations (type String) renvoyées par le passage à l’expression régulière :

    Dim mc As MatchCollection

    Passage de l’expression régulière sur la chaîne de caractère StrCrypter qui contient (238.0 237.0 236.0 024 50.0 13.9 32.0 00001000 :

    mc = re.Matches(StrCrypter)

    S’il y a eu 8 morceaux trouvés alors c’est OK et on décrypte la chaîne :

    If mc.Count = 8 Then

    Comment fonctionne l’expression régulière ? Avant de répondre, je précise que je ne suis pas devenu un expert en quelques jours donc, il y a peut-être mieux que ce que j’ai fait, plus simple ou plus compliqué. Mais en tout cas, cela fonctionne très bien :

    • \b\d\d\d\.\d\b :
      • \d signifie valeur numérique, c’est la même chose que lorsqu’on écrit [0-9], je ne me prive donc pas d’utiliser le raccourci :-)
      • \. Désigne le point en tant que tel. Si . est utilisé seul, il désigne n’importe quel caractère.
      • \b indique qu’il faut qu’il y ait un espace ou une ponctuation avant le caractère
      • Cette expression me permet d’extraire les 3 premières chaînes de type 238.0
    • |\b\d\d\d\b :
      • | signifie ou logique. Ce qui suit sera donc extrait en plus de ce qui précède
      • 3 \d indique 3 chiffres associé au \b du début, il permet d’extraire le 024
    • |\b\d\d\.\d\b :
      • Rien de nouveau dans cette expression, même logique que la première. Elle permet d’extraire les 50.0, 13.9 et 32.0
    • |\b\d\d\d\d\d\d\d\d :
      • Tout simple, récupère les 8 derniers chiffres

    La collection dans les recherches est toujours remplie dans l’ordre où les éléments ont été trouvés. Il ne me reste donc plus qu’après à remplir mes variables privées avec les informations trouvées, dans l’ordre où elles apparaissent.

    Côté du texte, j’ai un peu rusé et utilisé une combine. L’expression \b[A-Za-z].*?\b me permet d’extraire une chaîne de texte située entre 2 espaces ou ponctuation quelque soit la longueur de la chaîne. Tout réside dans le qualificateur paresseux *? qui permet de renvoyer aussi peu de répétition que possible. Associé au \b qui le suit et au . qui le précède, il renvoie donc ce qui se trouve avant les ponctuations. Et permet de découper les mots. Je sens que je vais le garder dans mes favoris :-)

    J’aurais également pu valider que la chaîne comprenait bien BELKIN, Master et 1.00 en utilisant l’expression régulière BELKIN|Master|1\.00 qui doit me renvoyer 3 chaînes. J’ai préféré l’autre solution car elle me paraissait un peu plus souple. Et surtout parce que j’étais tout fier d’avoir trouvé une expression sympa pour séparer les mots ! Cela rend mon code un peu plus générique et permettra une utilisation avec un autre type d’onduleur utilisant le même protocole.

    Me voilà donc maintenant bien avancé avec mon protocole presque complet, le code qui permet de le décrypter, mon code d’envoi de mail. Il me reste donc à coder un peu d’intelligence pour permettre la remontée d’alerte, l’utilisation en tant que service Windows (hors de question de devoir être logué pour que ce programme fonctionne) et coder la communication avec l’onduleur. Bref, stay tune, la suite dans les prochains posts.

  • Laurent Ellerbach

    Développer ses propres jeux pour XBOX 360 : c’est possible !

    • 0 Comments

    Et oui, plus besoin d’être une société pignon sur rue dans le développement de jeu pour développer ses propres jeux pour XBOX 360. C’est possible grâce à XNA Game Studio Express. Plus d’infos sur : http://www.microsoft.com/presspass/press/2006/aug06/08-13XNAGameStudioPR.mspx

    Une news officielle attendue depuis longtemps dans la communauté des développeurs.

  • Laurent Ellerbach

    J’ai hacké mon onduleur ou le reverse engineering de protocoles de communication (part 6)

    • 6 Comments

    Voici la suite des aventures de l’analyse du protocole de communication expliqué dans la quatrième partie. J’ai donc essayé à partir des commandes envoyées à l’onduleur de compléter ce que j’ai trouvé en écoutant la conversation entre l’application livrée avec l’onduleur et l’onduleur. J’ai donc utilisé l’application développée précédemment pour envoyer les commandes. Je notais le résultat de chaque commande. Ensuite, j’ai essayé à partir de l’application livrée avec et des informations renvoyées de déchiffrer les résultats. Avoir une application existante aide grandement, cela facilite la comparaison des résultats. Sinon, il faut essayer de deviner par tâtonnement. Moins drôle. Il me reste quelques zones d’incertitude cependant que je vais devoir approfondir. Pour les commandes que je n’avais pas (exemple S), j’ai tout simplement envoyé chaque lettre de l’alphabet et j’ai attendu le retour. La plupart du temps, c’est un écho, assez classique dans les protocoles. Quand rien ne revenait, j’analysais l’onduleur lui-même. Parfois rien ne se passait du tout (exemple envoi de la commande Q). Cela impliquait qu’il pouvait manquer une lettre/chiffre derrière ou que le mode était déjà enclenché (exemple commande C quand on est déjà en courant continue).

    Commande I

    Renvoie l’identifiant de l’onduleur : #BELKIN Master 1.00

    1 caractère # qui identifie le début de la chaîne

    16 caractères qui contiennent la marque de l’onduleur, ici BELKIN

    11 caractères qui contiennent le modèle de l’onduleur, ici Master

    11 caractères qui contiennent la version du firmware ici 1.00

    Commande S

    Arrête l’onduleur. Attention, si l’onduleur est alimenté en courant il se remet en marche automatiquement. Commande à utiliser donc de préférence lors d’une coupure de courant si besoin.

    Commande T

    Passe l’onduleur en mode batterie test pendant 10s.

    Commande C

    Repasse l’onduleur en mode alimentation par secteur. Utile lorsqu’on force l’onduleur à se mettre en mode batterie avec la commande TL ou T. Pas de différence visible avec la commande CT.

    Commande TL

    Passe l’onduleur en mode batterie.

    Commande CT

    Repasse l’onduleur en mode alimentation par secteur. Voir commande C.

    Commande Q1

    Renvoie un statut des tensions, fréquences, températures et charges : (238.0 237.0 236.0 024 50.0 13.9 32.0 00001000

    238.0 = Voltage d’alimentation = 238.0 V

    237.0 = Voltage tension de sortie primaire ( ?) = 237.0 V

    236.0 = Voltage tension de sortie secondaire ( ?) = 236.0 V

    024 = charge de l’onduleur en %

    50.0 = fréquence en Hertz

    13.9 = Charge de la batterie (?), reste à déterminer l’échelle, a priori 14.

    32.0 = température en °C

    00001000 = statut. 1 bit par info. Pas encore déterminé l’utilité de tous les bits. Tests à effectuer

    Commande F

    Renvoie un statut de la batterie : #230.0 2.2 12.00 50.0

    230.0 = Voltage de la sortie batterie

    2.2 = courant en ampère

    12.00 = tension de la batterie

    50.0 = Fréquence de sortie

    Je suis content de ce premier jet de résultat qu’il me reste à approfondir avec quelques tests complémentaires. Cela vade toute façon me permettre d’avancer rapidement dans l’écriture d’une classe de gestion de l’onduleur. A suivre au prochain post !

  • Laurent Ellerbach

    J’ai hacké mon onduleur ou le reverse engineering de protocoles de communication (part 5)

    • 0 Comments

    Dans mon premier post, j’indiquais avoir trouvé en quelques minutes comment faire pour envoyer un mail en SMTP. Parce que ce n’est tout de même pas si simple si le serveur SMTP nécessite une authentification et toujours pour faire plaisir à Benjamin qui trouve que je n’ai pas écrit assez de code, voici ce qu’il faut écrire :

    'objet mail

    Dim email As New MailMessage("from@mail.fr", "to@mail.fr")

    'le nom du serveur SMTP ou son adresse IP

    Dim MonSmtpMail As New SmtpClient("smtp.mail.fr")

    'sujet du message

    email.Subject = "Test message onduleur"

    'corps du message

    email.Body = "Ceci est un message de test pour l'envoie du mail à travers l'onduleur"

    'indique qu'il ne faut pas utiliser les informations de sécurité de l'utisilateur

    MonSmtpMail.UseDefaultCredentials = False

    'crée un nouveau credential

    MonSmtpMail.Credentials = New Net.NetworkCredential("login", "motdepasse")

    'indique qu'il faut envoyer le mail par le réseau

    MonSmtpMail.DeliveryMethod = SmtpDeliveryMethod.Network

    'gestion d'erreur

    Try

    MonSmtpMail.Send(email)

     

    Catch ex As Exception

    MessageBox.Show(ex.Message)

    End Try

    La vraie ruse se trouve dans l’utilisation du NetWorkCredential qui permet de créer des informations de sécurité avec un login, un mot de passe et un domaine (optionnel).

    S’il n’y a pas besoin d’authentification, ou si l’authentification est intégrée, alors les 3 lignes avant le try ne sont pas nécessaires.

    Alors Benj, t’en penses quoi de ce code ?

    La suite au prochain post…

  • Laurent Ellerbach

    J’ai hacké mon onduleur ou le reverse engineering de protocoles de communication (part 4)

    • 2 Comments

    Me voici donc au quatrième épisode. Pour suivre les épisodes précédents, c’est ici pour le premier, ici pour le second et ici pour le troisième. Pour rappel, j’ai donc réussi à obtenir les informations nécessaires à l’ouverture du port série. J’en ai profité pour donner quelques explications qui permettent avec différentes méthode d’obtenir ces informations. Même si l’exemple est basé sur un port série, cela fonctionne avec à peu près n’importe quel type de protocole. Le principe de base reste le même.

    Je tiens quand même à apporter quelques précisions si vous utilisez un procédé d’acquisition discret tel que la carte son. Dans l’exemple que j’ai donné, je suis parti sur une acquisition à 44,1 KHz (ce qui correspond à ce que la plupart des cartes d’acquisition audio fond en standard). Il ne faut pas oublier le théorème de Nyquist – Shanon qui stipule que la fréquence maximale que l’on peut acquérir est égale à la moitié de la fréquence d’acquisition. Donc si l’on acquière à 44,1 KHz, cela donne donc une fréquence maximale de 22,05 KHz. En effet, il faut au moins 2 points dans une période pour déterminer la fréquence d’un sinus pur. Si l’on utilise une carte son, avec cette fréquence d’acquisition, cela permet de calculer jusqu’à 19 600 baud. Au-delà, il faut donc acquérir avec une fréquence plus importante (si la carte le permet) ou vraiment utiliser un oscilloscope.

    Aller, je gardais une autre solution pour ce post : utiliser un port parallèle qui permet d’acquérir avec une fréquence suffisamment importante pour aller jusqu’à 115 KHz /2 soit 57,5 KHz. Le montage n’est pas plus compliqué et il faut écrire à la main le bout de soft qui permet de faire cela. Quand j’étais étudiant (il y a bien longtemps maintenant…), nous nous amusions à faire des chenillards et autres affichages loufoques à base de port parallèle. Un port très sympathique qui a inspiré la plupart des affichages LCD de façade…

    Bon, revenons-en au code. J’ai promis à Benjamin (qui est dans mon équipe) que je publierais un peu code. Alors, Benj, chose promise, chose due :-) Je vais donc publier un morceau de code qui permet de se connecter à l’onduleur, de lui envoyer du texte et de récupérer ce qui en revient. Ce code est basé sur un projet (How-to Using the Comm Port) de GotDotNet. Il permet aux utilisateurs du framework 1.0 et 1.1 de bénéficier d’une classe super bien faite pour accéder aux ports séries. Ca me rappelle celle que j’avais dû faire et que j’utilisais à l’époque en C++. De base dans le framework 2.0, il y a tout ce qu’il faut avec la classe SerialPort, elle aussi bien faite. Je suis parti du projet de GotDotNet car je l’ai trouvé très rapidement et qu’il y avait du code pour m’inspirer. Donc, benj, ouvre les yeux, voici mon code :

    ' BtnSendOnduleur est un bouton :-)

    Private Sub BtnSendOnduleur_Click(ByVal sender As System.Object, ByVal e As

    System.EventArgs) Handles BtnSendOnduleur.Click

    ' Les Ports, c’est comme les fichiers, dès qu’on s’en sert, faut les try catch.

    Try

    m_CommPort.Open(1, 2400, 8, Rs232.DataParity.Parity_None, Rs232.DataStopBit.StopBit_1, 64)

    ' TxtSendOnduleur est une boîte de texte, texte à envoyer à l’onduleur

    m_CommPort.Write(Encoding.ASCII.GetBytes(TxtSendOnduleur.Text & Chr(13)))

    'Une pose quand on ouvre un port, ça fait toujours du bien

    System.Threading.Thread.Sleep(200)

    Application.DoEvents()

    ' Try pour la récupération des données.

    Try

    ' Je lit une donnée et toutes celles qui suivent. Quand le retour est -1, c’est timeout, donc, en principe, plus de données à lire

    While (m_CommPort.Read(1) <> -1)

    ' txtStatus est une boîte de texte qui permet de mettre le résultat de la lecture du port.

    txtStatus.Text = txtStatus.Text + Chr(m_CommPort.InputStream(0))

    End While

     

    m_CommPort.Close()

    Return

    Catch exc As Exception

    ' Rien à lire ou un problème

    m_CommPort.Close()

    Return

    End Try

    Catch exc As Exception

    ' Impossible d’ouvrir le port

    MsgBox("Port pas ouvert.", MsgBoxStyle.OkOnly, Me.Text)

    Return

    End Try

    End Sub

    Maintenant que tu as vu le code, je vais expliquer à quoi il me sert. Revenons sur l’exercice que j’ai fait avec PortMon. Voici la suite de ce que j’ai récupéré pas la suite :

    28    0.00002172    RupsMon.exe    IRP_MJ_WRITE    Serial0    SUCCESS    Length 2: F.    

    29    0.11777290    RupsMon.exe    IOCTL_SERIAL_WAIT_ON_MASK    Serial0    SUCCESS        

    30    0.00445378    RupsMon.exe    IRP_MJ_WRITE    Serial0    SUCCESS    Length 3: Q1.    

    31    0.00000703    RupsMon.exe    IOCTL_SERIAL_GET_COMMSTATUS    Serial0    SUCCESS        

    32    0.00000273    RupsMon.exe    IOCTL_SERIAL_GET_COMMSTATUS    Serial0    SUCCESS        

    33    0.00000576    RupsMon.exe    IRP_MJ_READ    Serial0    SUCCESS    Length 22: #230.0 2.2 12.00 50.0.    

    34    2.09370086    RupsMon.exe    IOCTL_SERIAL_WAIT_ON_MASK    Serial0    SUCCESS        

    35    0.00000559    RupsMon.exe    IOCTL_SERIAL_PURGE    Serial0    SUCCESS    Purge: TXCLEAR     

    36    0.00002896    RupsMon.exe    IRP_MJ_WRITE    Serial0    SUCCESS    Length 3: Q1.    

    37    0.00000333    RupsMon.exe    IOCTL_SERIAL_WAIT_ON_MASK    Serial0    INVALID PARAMETER        

    38    0.00000359    RupsMon.exe    IOCTL_SERIAL_GET_COMMSTATUS    Serial0    SUCCESS        

    39    0.00000191    RupsMon.exe    IOCTL_SERIAL_GET_COMMSTATUS    Serial0    SUCCESS        

    40    0.00000388    RupsMon.exe    IRP_MJ_READ    Serial0    SUCCESS    Length 47: (239.0 239.0 239.0 022 50.0 13.9 32.0 00001000.    

    41    0.00002742    RupsMon.exe    IRP_MJ_WRITE    Serial0    SUCCESS    Length 2: F.    

    42    0.11799550    RupsMon.exe    IOCTL_SERIAL_WAIT_ON_MASK    Serial0    SUCCESS        

    43    0.00000374    RupsMon.exe    IOCTL_SERIAL_GET_COMMSTATUS    Serial0    SUCCESS        

    44    0.00000183    RupsMon.exe    IOCTL_SERIAL_GET_COMMSTATUS    Serial0    SUCCESS        

    45    0.00000380    RupsMon.exe    IRP_MJ_READ    Serial0    SUCCESS    Length 22: #230.0 2.2 12.00 50.0.    

    46    0.00011600    RupsMon.exe    IRP_MJ_WRITE    Serial0    SUCCESS    Length 3: Q1.    

    47    0.22647997    RupsMon.exe    IOCTL_SERIAL_WAIT_ON_MASK    Serial0    SUCCESS        

    48    0.00000381    RupsMon.exe    IOCTL_SERIAL_GET_COMMSTATUS    Serial0    SUCCESS        

    49    0.00000182    RupsMon.exe    IOCTL_SERIAL_GET_COMMSTATUS    Serial0    SUCCESS        

    50    0.00000407    RupsMon.exe    IRP_MJ_READ    Serial0    SUCCESS    Length 47: (239.0 239.0 239.0 022 50.0 13.9 32.0 00001000.    

    En gros, quand la commande F ou Q1 est envoyée, il y a un retour. Pour définir ce que le point représente, j’ai fait une acquisition en binaire. Cela donne pour Q1 : IRP_MJ_WRITE    Serial0    SUCCESS    Length 3: 51 31 0D

    0D = 13 en décimal, ce qui correspond au caractère « entrée ». Très classique dans le cas de communication avec des appareils en port série. D’où dans le code, TxtSendOnduleur.Text & Chr(13) qui permet d’envoyer du texte (F ou Q1 pour faire les premiers tests) avec le caractère « entrée ». Mon programme permet donc d’envoyer une commande, de récupérer le résultat et de l’afficher dans une boîte de texte. A noter que j’ai fait ce code uniquement pour me dérouiller. Inutile dans mon cas, j’aurais pu utiliser le bon vieux terminal Windows qui fait exactement la même chose (en mieux). J’ai écrit ce code, toujours dans l’optique de me dérouiller. De toute façon, ce n’est pas perdu, j’aurais besoin d’en écrire et à peu près le même pour mon application finale. Je reviendrais sur cet excellent outil qu’est le Terminal Windows et qui m’a presque fait oublier ma VT100

    A noter qu’avec VB 2005, pour ouvrir un port, on peut utiliser l’excellente classe My en faisant un Dim MonPort As System.IO.Ports.SerialPort = My.Computer.Ports.OpenSerialPort("COM1", 2400, IO.Ports.Parity.None, 8, IO.Ports.StopBits.One). Ensuite, la classe SerialPort permet d’envoyer et récupérer des données. Je l’utiliserais dans mon application finale.

    Du coup, cette application, m’a permit d’envoyer diverses commandes et de voir la réaction de l’onduleur et le retour qu’il a pu m’en faire. Cela m’a permit de déterminer (quasiment) toutes les commandes disponibles et donc de déterminer quel est le langage entre l’onduleur et le PC. La suite au prochaine numéro…

  • Laurent Ellerbach

    J’ai hacké mon onduleur ou le reverse engineering de protocoles de communication (part 3)

    • 3 Comments

    Pour faire suite aux deux premiers article sur le sujet, je vais rentrer un peu dans le dur de l’analyse du protocole de communication de mon onduleur. Pour mémoire, je me suis arrêté en disant que j’avais lancé PortMon et que j’avais vu plein de choses intéressantes. Voici donc les résultats :

    0    0.00004426    RupsMon.exe    IRP_MJ_CREATE    Serial0    SUCCESS    Options: Open     

    1    0.00000178    RupsMon.exe    IOCTL_SERIAL_SET_TIMEOUTS    Serial0    SUCCESS    RI:-1 RM:5 RC:80 WM:0 WC:0    

    2    0.00000091    RupsMon.exe    IOCTL_SERIAL_GET_BAUD_RATE    Serial0    SUCCESS        

    3    0.00000104    RupsMon.exe    IOCTL_SERIAL_GET_LINE_CONTROL    Serial0    SUCCESS        

    4    0.00000083    RupsMon.exe    IOCTL_SERIAL_GET_CHARS    Serial0    SUCCESS        

    5    0.00000100    RupsMon.exe    IOCTL_SERIAL_GET_HANDFLOW    Serial0    SUCCESS        

    6    0.00000087    RupsMon.exe    IOCTL_SERIAL_GET_BAUD_RATE    Serial0    SUCCESS        

    7    0.00000082    RupsMon.exe    IOCTL_SERIAL_GET_LINE_CONTROL    Serial0    SUCCESS        

    8    0.00000083    RupsMon.exe    IOCTL_SERIAL_GET_CHARS    Serial0    SUCCESS        

    9    0.00000089    RupsMon.exe    IOCTL_SERIAL_GET_HANDFLOW    Serial0    SUCCESS        

    10    0.00000689    RupsMon.exe    IOCTL_SERIAL_SET_BAUD_RATE    Serial0    SUCCESS    Rate: 2400    

    11    0.00000391    RupsMon.exe    IOCTL_SERIAL_SET_RTS    Serial0    SUCCESS        

    12    0.00000351    RupsMon.exe    IOCTL_SERIAL_SET_DTR    Serial0    SUCCESS        

    13    0.00000250    RupsMon.exe    IOCTL_SERIAL_SET_LINE_CONTROL    Serial0    SUCCESS    StopBits: 1 Parity: NONE WordLength: 8    

    14    0.00000124    RupsMon.exe    IOCTL_SERIAL_SET_CHAR    Serial0    SUCCESS    EOF:0 ERR:0 BRK:0 EVT:d XON:11 XOFF:13    

    15    0.00000238    RupsMon.exe    IOCTL_SERIAL_SET_HANDFLOW    Serial0    SUCCESS    Shake:1 Replace:40 XonLimit:2048 XoffLimit:512    

    16    0.00000225    RupsMon.exe    IOCTL_SERIAL_SET_WAIT_MASK    Serial0    SUCCESS    Mask: RXCHAR     

    17    0.00000260    RupsMon.exe    IOCTL_SERIAL_SET_WAIT_MASK    Serial0    SUCCESS    Mask: RXFLAG         

    Alors, comment lire ces résultats ? Et bien c’est simple, à l’ouverture du port série, PortMon intercepte les appels au port série. On y voit un IOCTL_SERIAL_SET_BAUD_RATE Serial0 SUCCESS Rate: 2400 qui nous indique que le port a été ouvert à 2400 baud. En lisant les quelques lignes qui suivent, on trouve les autres informations :

    • 1 bit de stop
    • Pas de parité
    • Un mot de 8 bits

    Nous avons donc la première information nécessaire pour communiquer avec l’onduleur. Nous avons eu pas mal de chance car il est possible que les appels ne passent pas en mode user et donc l’espionnage du port série avec un outil tel que PortMon ne fonctionne pas. C’est par exemple le cas du service Windows onduleur. Alors comment faire dans ces cas là ? Et bien, il faut ressortir l’oscilloscope. L’oscilloquoi ? L’oscilloscope. Un instrument qui permet d’analyser des signaux, le truc que l’on utilise en TP au collège. Le principe est simple, il suffit de brancher une des bornes de l’oscilloscope sur la masse et l’autre sur une des bornes de communication. Ensuite, il faut faire parler entre eux les appareils (dans notre cas l’ordinateur et l’onduleur) et capturer les signaux (les oscilloscopes modernes permettent tous de le faire). Ensuite, il suffit d’analyser la longueur d’un bit ou de plusieurs bits et d’en déduire la fréquence. Je vais expliquer comment faire un peu plus loin.

    A défaut d’avoir un onduleur, il est possible de capturer les signaux sur une carte son par exemple. Le montage est simple et fonctionne également. Il suffit pour cela de faire la même chose qu’avec l’oscilloscope (la masse de l’entrée micro sur la masse du port série et la borne 2 sur l’entrée gauche et la borne 3 sur l’entrée droite par exemple. Ensuite, il suffit d’enregistrer avec n’importe quel logiciel de capture de son ce qui passe sur le micro. Attention, il faut fixer le gain plutôt faible car 5 volts (tension de sortie du port série) est assez important. Normalement, pas de problème côté carte son mais bon, mieux vaut être prévoyant pour ne pas abîmer le matériel. Au pire, le signal « clipera » (saturera) mais ce n’est pas important dans notre cas, nous essayons seulement de capturer des bits donc des 0 et des 1. Peu importe le niveau de crête. L’analyse se passe de la même façon qu’avec l’oscilloscope. La période de plusieurs bits donne la fréquence. Pour la calculer, c’est simple, il faut juste connaître la fréquence d’échantillonnage (comme sur l’oscilloscope). Imaginons que l’on capture un signal à 44KHz, la période est donc de 2,3 10^-5 secondes. Avec un logiciel permettant de zoomer suffisamment, sur le signal acquis, il est possible de calculer la période du signal. Imaginons que nous ayons 18 points entre deux crêtes, cela nous donne donc une période de 4,09 10^-4 secondes et donc une fréquence de 2440 Hz (rappel, fréquence en Hertz = 1 / période en seconde). Et donc on retombe facilement sur 2400 Hz. Evidemment, la vrai vie, c’est un petit peu plus compliqué que cette théorie. En général, on est obligé de prendre plusieurs bits, de prier pour que les bits ne soient pas doublés (ça peut arrive avec beaucoup de malchance) car sinon la fréquence est multipliée par deux.

    Avec un peu d’expérience, on y arrive assez facilement. Avec cette méthode, une fois la fréquence déterminée, il est possible de déterminer la parité (il faut plusieurs mots différents pour être sûr), le nombre de bits de stop et aussi la longueur d’un mot. Ca peut prendre un peu de temps et il faut faire dialoguer les appareils entre eux pas mal de fois pour être sûr de ne pas se tromper. Et c’est là que la norme complète aide beaucoup :-) J’ai eu à faire ce type de manipulation, lorsque je développait l’application de récupération d’information du PDP. C’était sur le port parallèle. Croyez-moi, ça forme :-) Une bonne expérience que l’on devrait faire faire à tous les étudiants en TP d’informatique/électronique. En plus, les tests après permettent de valider les informations trouvées par cette expérience.

    Maintenant, j’ai toutes les informations nécessaires pour me connecter à l’onduleur, il me faut maintenant déterminer son protocole pour pouvoir dialoguer avec lui. La suite au prochain post !

  • Laurent Ellerbach

    J’ai hacké mon onduleur ou le reverse engineering de protocoles de communication (part 2)

    • 6 Comments

    Cette fois-ci, je vais rentrer plus dans le concret des quelques étapes clés à suivre pour déchiffrer le fonctionnement d’un protocole de communication. Pour ceux qui veulent suivre la genèse de l’article, allez voir le premier post.

    Je vais commencer par rappeler quelques principes de base quand on veut faire du reverse engineering. Loin de moi l’idée d’être exhaustif et de proposer une méthode infaillible et universelle. Ils sont juste basés sur le bon sens et des grands principes d’ingénierie. J’appliquerais ces principes sur mon exemple d’onduleur.

    La première étape consiste à se munir des bons outils : la documentation complète du vecteur d’information, des outils d’écoutes, des outils d’analyse et des outils de simulation. Pour un port série, c’est assez simple. C’est un des premiers ports à être apparu sur les ordinateurs. De base, il ne nécessite que 3 fils de base: une masse, une ligne de donnée montante et une ligne de données descendante. Certains montages peuvent nécessités d’autres lignes qui permettaient notamment, au début, de faire du contrôle de données.

    Alors pour commencer, qu’est-ce que RS232 ? Et bien, c’est une norme de communication série que l’on trouve RS232 à l’EIA/TIA et qui est identique aux normes CCITT V.24/V.28, X.20bis/X.21bis et ISO IS2110. Des mots bien compliqués pour l’appeler familièrement un « port série ». De bonnes explications en anglais sur Wikipedia. Pourquoi série ? Et bien tout simplement parce que les données sont transmises en série, les unes après les autres sur une seule ligne. La différence avec un port parallèle, c’est que sur le port parallèle, il faut un fil par bit (en général), et les données d’un mot sont transmises toutes en même temps. Le principe du port série est d’ailleurs réutilisé sur les ports SATA (contrôleurs de disques dur nouvel génération) qui remplace les ports PATA qui eux transmettaient les informations en parallèle. Le port USB est également un très bon exemple d’utilisation de transmission en série des informations. Chaque technologie présente ses avantages et ses inconvénients. Je ne rentrerais pas dans le détail ici car j’ai besoin d’espionner à un niveau plus haut dans les couches OSI que sur la couche de transport en tant que tel.

    Le port série se présente sous la forme de prises DB25 (25 broches), DB9 (9 broches) ou RJ45 (8 broches). Les plus courants sont DB9 (on les trouve sur les PC actuels). Les DB25 ne sont plus utilisés depuis pas mal d’années et on évite les RJ45 pour ne pas les confondre avec les prises réseaux. Côté physique, les 3 seuls chiffres à retenir sur une DB9, ce sont 2, 3 et 5. 5 est la masse. La câblage de base consiste donc à relier 2 appareils en mettant directement les broches 2 et 3 en liaison (ou très rarement 2-2 et 3-3) et relier entre elles les broches 5. Dans mon cas, un câble série était livré, je n’ai pas eu besoin de me prendre la tête avec du câblage. Cependant, cela peut s’avérer utile d’avoir 2 câbles tout prêts, un droit et un croisé (appelé câble null modem) pour faire ce type de manipulation. Les autres broches peuvent avoir leur importance suivant ce que l’on cherche à faire. Mais elles ne sont pas obligatoires. Tous les câblages sont disponibles dans la doc de Windows 2000 par exemple.

    Côté communication, le port série fonctionne avec :

    • un débit données, exprimé en baud : (150), 300, (600), 1 200, 2 400, (3 600), 4 800, 9 600, 19 200, 28 400, 38 400, 57 600, 115 200, entre parenthèse les débits possibles mais plus utilisés ou rarement utilisés. Avec les nouveaux chpsets, il est possible d’obtenir une plage plus large notamment entre 28,4 et 57,6 K baud.
    • un nombre de bit par mot 7 ou 8,
    • une parité : None (aucune), Odd (paire), Even (Impaire), Mark (marquée)
    • 1 ou 2 bits de stop

    Les informations sont codées du bit de point faible vers le bit de poids fort suivi du bit de parité (si pas none) et du ou des bits de stop. A priori, rien n’interdit les transmissions simultanées. Dans ce cas, il faut être sûr que les broches ready to send et ready do receive sont bien reliées les unes avec les autres.

    Pour pouvoir correctement espionner ce qui circule sur le port série, la première difficulté consiste donc à trouver la bon paramétrage. Ce n’est pas si facile car les possibilités sont nombreuses. Dans mon cas, je ne possède pas la documentation du protocole de communication, impossible donc de connaître les bonnes informations. Et rien n’est écrit sur le matériel. Pas d’information disponible.

    J’ai la « chance » d’avoir un logiciel qui communique déjà avec mon onduleur. La seule chose que je vais donc avoir besoin de faire, c’est de l’espionner pour obtenir ces informations. L’avantage d’être à ce niveau là, c’est que c’est du logiciel. Et comme on dit, en logiciel tout est possible . Donc, je pars m’équiper d’un outil d’écoute. J’en connais un très bien : PortMon. Il provient de Sysinternals. Un site avec de nombreux outils tous indispensables au bon développeur et administrateur réseau. Sysinternals vient d’ailleurs d’être racheté par Microsoft il y a quelques semaines. Mark Russinovich et Bryce Cogswell ont toujours été pour moi des idoles et ils vont certainement le rester longtemps. Le fonctionnement de PortMon est parfaitement documenté sur le site.

    PortMon permet d’écouter ce qui se passe sur un port série ou un port parallèle. Je lance donc PortMon, je paramètre l’utilisation du port pour l’ordinateur local et utilise le port COM1. Je lance ensuite l’outil de monitoring de l’onduleur et j’écoute. Et vous savez quoi ? Et bien, on trouve plein de choses intéressantes… La suite au prochain post.

     

  • Laurent Ellerbach

    J’ai hacké mon onduleur ou le reverse engineering de protocoles de communication (part 1)

    • 15 Comments

    C’est un titre un peu long mais bon, il exprime le fond de mon problème : j’ai acheté un onduleur (un Belkin) pour mettre sur mon serveur et un de mes PC à la maison. Par contre, faudra être un peu patient car il va y avoir plusieurs post sur le sujet.

    Le truc, c’est que l’application de gestion livrée avec est… comment dire… sans dire de gros mots… un peu vieillissante et inutilisable pour faire de l’administration. Une vieille appli au look de la fin des années 90, pas d’accès à distance, pas de SNMP, pas de page Web, bref rien :-(. Pour ne pas polémiquer, je préfère ne pas mettre de capture d’écran. Mais bon, pour les curieux, je vous les tiens à disposition…

    Du coup, je me suis lancé dans la recherche d’application un peu mieux. Au bout de quelques heures de recherche, quelques applications téléchargées et installées, je m’aperçois que tous les onduleurs ont un protocole de communication totalement différent. Les logiciels d’un constructeur ne fonctionnent qu’avec leur propre onduleur. Les applications sont d’ailleurs toutes très variées, seules les versions pro proposent du SNMP et quasi pas de soft qui permette d’avoir un état dans une page Web.

    Je me suis donc rabattu sur le service « Onduleur » de Windows (on le trouve dans « Gestion d’énergie » sauf sur les portables). Et là, pas mieux. Un service de base où mis à part si l’on possède un APC, il n’y a pas grand-chose. Visiblement n’importe quel onduleur possède des instructions minimums qui permettent de vérifier son état : sur secteur, sur batterie, batterie faible. Les possibilités sont très limitées : arrêter la machine et exécuter un programme. Point barre.

    Je suis donc parti sur l’écriture d’un programme en ligne de commande qui permette d’envoyer un mail en SMTP. Cela me permettra en cas de panne électrique d’être alerté par mail de la coupure de courant. Mieux que rien. Je me suis dit que ça allait me faire du bien, presque 2 ans et demi sans écrire une ligne de code. Ca va me dérouiller un peu.

    Côté outil, je pars donc sur Visual Basic Express 2005. Une solution parfaite pour m’y remettre. Parfaite car j’adore Visual Basic (je « parle » aussi C/C++,Java, Pascal, Fortran, C#, ADA et « baragouine un peu » en Eiffel, Python, PhP). Parfaite aussi pour les étudiants, les débutants et les passionnés : le produit est gratuit, permet de développer en .NET 2.0 et offre des possibilités de recherche super sympa (j’y reviendrais plus loin). Après 15 minutes de téléchargement (OK, j’ai une bonne ligne ADSL), l’installation se passe sans encombre. Je prends évidemment la librairie MSDN avec moi. Pas besoin de SQL Express pour mon besoin (pour l’instant). SQL Express est une base de données, basée sur SQL Server et gratuite. SQL Express est idéal pour les développements, les tests, une utilisation en production avec quelques utilisateurs simultanés.

    Evidemment, j’active mon Visual Basic Express 2005, qui permet d’avoir accès à de nombreux avantages :

    • Corbis Image Pack — Un assortiment de 250 images Corbis gratuites à inclure dans vos sites Web et vos applications
    • La suite IconBuffet Studio Edition Icon — Une collection de plus de 100 icônes IconBuffet.com, professionnelles et gratuites
    • Une variété de composants — Une sélection de composants à utiliser dans vos applications
    • Des livres électroniques et des articles — Des livres électroniques Microsoft Press complets ainsi que des articles intéressants pour les débutants, les amateurs, et les personnes essayant les outils de développement Microsoft pour la première fois.

    D’ailleurs en ce moment, il y a un jeu Activ'Express avec 20 lots à gagner chaque mois. Bref aucune excuse pour ne pas activer ses version de Visual Studio Express.

    Côté développement, je me dis que j’allais commencer par chercher dans l’aide. Toujours commencer par réfléchir avant de coder :-). D’ailleurs la bonne règle, c’est autant de temps à réfléchir qu’à coder. Un nouveau menu est présent « Communauté » et « Recherche dans les communautés ». A l’intérieur, on trouve des recherches sur des exemples. Je lance donc la recherche qui m’ouvre une nouvelle fenêtre, je tape « envoi mail smtp ». J’obtiens de nombreux résultats dont un très bien sur MSDN intitulé « Envoi de courrier, exemple » en ce qui concerne Microsoft et un autre très bien aussi sur le réseau Codes-Sources (superbement piloté par mon ami Nix) intitulé « VB.NET envoi de mail pas SMTP avec authentification ».

    Résultat : avec ces deux exemples, en moins de 10 minutes, j’avais fait mon programme. Très cool côté productivité, moins cool côté « me remettre à faire un peu de code ». Du coup, c’est là que me vient l’idée d’aller plus loin et de réécrire un logiciel qui permette de gérer mon onduleur ! Mon onduleur possède deux ports de communication : série et USB. Je me lance pour série, je connais bien…

    Cela me rappellera mon jeune temps de développeur. J’étais à l’époque étudiant à l’ENSAM (les Arts et Métiers). Je passais mon temps libre et mes vacances à travailler pour la société SAMx. Cet éditeur de logiciel est spécialisé dans les logiciels d’analyse scientifique. Leurs logiciels communiquent avec des microsondes et spectromètres électroniques. La plupart de ces appareils à l’époque ne communiquait qu’en port série et/ou parallèle. Je me souviens d’un développement où l’objectif était de récupérer des données (des images représentant des cartographies) depuis des PDP vers des PC (à l’époque en 1996 sous Windows 95). C’était l’époque des premiers ports parallèle EPP et ECP. La technologie n’était tellement pas sèche qu’il m’a fallut développer un dongle spécifique pour réussir à fonctionner avec l’ensemble des chipsets disponibles sur le marché. J’ai appris à cette époque à vraiment me servir d’un oscilloscope… Au final, la solution fonctionnait parfaitement avec un port série sur lequel les informations de commande étaient envoyées et un port parallèle sur lequel les informations étaient reçues. Pour les autres développements, je n’avais que rarement accès aux matériels (une microsonde, cela prend une pièce complète, SAMx n’en possédait pas, nous allions chez des clients faire les test) et je devait donc d’une part bien développer en respectant les protocoles de communication (documentés dans des superbes docs comme celles des standards) et d’autre part bien émuler les tests ! C’est à cette époque que la VT100 est devenue une de mes meilleure amie.

    De là, j’ai gardé de très bons restes. Restes que j’ai appliqués à mon onduleur. Et vous comprendrez le titre de ce post au prochain post :-)

     

  • Laurent Ellerbach

    CodePlex est live : une plateforme de partage de code source

    • 0 Comments

    CodePlex, c’est une plateforme de partage de code source, en Shared Source et édité par Microsoft. On y trouvera tout type de code source. Pour le moment, il y a des choses très intéressante pour ceux qui font du Web 2.0 comme la plate-forme Atlas.

    http://www.codeplex.com/

    Le côté intéressant de la plateforme, c’est son développement en C#, en utilisant Visual Studio Team System et Team Foundation Server (cf http://www.microsoft.com/france/msdn/vstudio/teamsystem/default.mspx) et le framework 2.0.

    Bientôt seront disponible des projets communautaires externes à Microsoft.

  • Laurent Ellerbach

    On10 : un site à découvrir pour les passionnés de technologie

    • 0 Comments

    Pour ceux qui ne le connaissent pas encore, le site on10 est à découvrir : http://www.on10.net/

    Il s’adressent à ceux qui pensent que la technologie peut changer le monde. Il y a notamment tout plein de vidéos très sympa : http://www.on10.net/media/

    Bref, une sorte de Channel9 http://channel9.msdn.com mais pour ceux qui ne sont pas trop tech mais aiment les technos…

  • Laurent Ellerbach

    MSDN wiki ou comment enrichir MSDN Library en mode wiki

    • 0 Comments

    Pour tous ceux qui utilisent la librairie d’information MSDN, il manquait quelque chose : la possibilité de la compléter. Et bien c’est chose faite depuis quelques jours. http://msdnwiki.microsoft.com est désormais disponible en version bêta., en anglais pour le moment mais prochainement en français également.

    C’est le même fonctionnement qu’un wiki avec des contributeurs, des modérateurs, des sujets fermés, etc.

    A vous de jouer 

  • Laurent Ellerbach

    Bill Gates va se consacrer à sa foundation à pleine temps à partir de Juillet 2008

    • 0 Comments

    Ca vient d’être annoncé il y a une demi heure. Toutes les informations sont disponibles sur http://www.microsoft.com/presspass/press/2006/jun06/06-15CorpNewsPR.mspx

  • Laurent Ellerbach

    WinFX est mort, vive .NET Framework 3.0

    • 0 Comments

    La nuit a été riche en changement de nom. WinFX s’appelle désormais .NET Framework 3.0. Dans les autres changements de nom, on trouve aussi InfoCard qui devient Windows CardSpace. Le changement de nom va prendre un bon moment à se propager partout sur tous nos sites et documents. Merci d’être indulgent 

  • Laurent Ellerbach

    Télécharger gratuitement et légalement des logiciels Microsoft pour les étudiants !!

    • 0 Comments

    Si vous êtes étudiants en France, alors vous pouvez avoir accès à de nombreux logiciels Microsoft gratuitement et en toute légalité !

    Que faire ? Tout simplement se connecter sur http://www.microsoft.com/france/msdn/abonnements/academic/etudiants/telechargementdirect.mspx

    Quels sont les logiciels disponibles ?

    Visual Studio 2005 Professionnal

    Développez vos applications Windows, web, mobiles ou basées sur Microsoft Office Plus d'informations

    Visio

    Clarifiez vos idées et donnez vie à vos concepts ! Plus d'informations

    MS Project

    L'outil idéal pour planifier et gérer vos projets ! Plus d'informations

    One Note

    Organisez et réutilisez vos notes quand vous voulez ! Plus d'informations

    SQL Server 2005

    Le logiciel d'analyse et de gestion des données. Plus d'informations

    InfoPath 2003

    Travaillez sur des formulaires riches et dynamiques ! Plus d'informations

    Virtual PC 2004

    Pour exécuter plusieurs systèmes d'exploitation sur un seul ordinateur. Plus d'informations

     

    A ne pas rater !

  • Laurent Ellerbach

    Mes anciens blogs…

    • 1 Comments

    J’ai changé plusieurs fois de blog. Le dernier se trouve sur : http://thespoke.net/blogs/laurelle/default.aspx

    Celui d’avant sur http://blogs.labo-dotnet.com/laurelle/

    Vous trouverez des recettes de cuisine sur ces anciens blogs. Le reste étant principalement de l’actualité.

    Ce qui est sympa, c’est que finalement après avoir changé plusieurs fois de blog, je reviens là où j’avais créé mon premier blog. C’était il y a bientôt 5 ans. A l’époque la liste des blogueurs de Microsoft tenait sur 1/2 page… Que de souvenirs… Malheureusement, il n’existe plus depuis. Mais avec mes recettes de cuisine que je postais en français et en anglais, j’avais beaucoup de succès. Pas loin de 5000 visites tous les jours. Ca fait rêver.

  • Laurent Ellerbach

    Gérer sa cave à vin

    • 0 Comments

    Vous trouverez sur http://www.microsoft.com/france/msdn/vbasic/macaveavin/default.mspx une application permettant de gérer sa cave à vin. L’application a été développée en Visual Basic Express et les sources sont disponibles. VB Express est en plus gratuit, ce qui permet d’avoir une solution entièrement gratuite est personnalisable. Bref, que du bonheur.

    Pour faire fonctionner « Ma cave à vin », c’est simple :

    1. Télécharger et installer VB 2005 Express avec SQL Server 2005 Express 2. Télécharger la solution MaCaveAVin3. Compiler l’application

    4. Consommer l’application sans modération et les bouteilles avec  modération

Page 5 of 5 (122 items) 12345