Voulez-vous bronzer ?

Et oui, en ces belles journées rien ne vaut un petit bronzage avant le ski ! 😀

Aujourd’hui, je vais parler « insoleuse »… Non il ne s’agit pas de l’insultante voisine, c’est le véritable nom donné au machine permettant de bombarder d’UV des plaques de circuit imprimé. Pourquoi faire ? Tout simplement pour faire ces propres circuits imprimés pardi !

Il y a pas mal de monde sur le net qui fabrique sa propre machine. Pour ma part (enfin devrais-je dire : « pour une fois »), j’ai décidé d’en acheter une toute faite ! Enfin presque, puisqu’elle est en kit (Faut pas déconner non plus !) 😀

On commence par déballer :

Tubes UV

Tubes UV encore dans les cartons de protection

Starters, transfo et ses fixations

Les starters, un des deux transfos et leurs fixations

Supports de fixation des tubes UV

Supports de fixation des tubes UV

Le circuit imprimé et le cordon d'alimentation

Le circuit imprimé, le cordon d'alimentation et le cache en plastique

Mousse et plaque

La mousse de maintient et la plaque de verre

valise vide

Et la valise vide !

Bon, je crois que j’ai tout. On va pourvoir démarrer ! NB : Dans un soucis de limitation du coût de fabrication de cette valise, l’éditeur a eu la brillante idée de ne pas fournir les fils électriques servant à alimenter les supports UV et les deux transformateurs… Bon, rien de bien grave, il suffit de trouver environ 40 cm de monobrin de diamètre 1,5 mm… Encore faut-il en avoir !! -_-

Je recommande donc vivement une des deux solutions suivantes :

  • Soit faire son bricolage un jour ouvré pendant les horaires d’ouverture du magasin de bricolage le plus proche
  • Soit, si vous travaillez comme la plupart des gens, achetez du câble en même temps que la valise (câble d’éclairage standard que l’on trouve dans tous les magasins de bricolage – même en supermarché !)

Bref, après avoir pesté pendant toute une soirée parce que les magasins ne sont pas ouverts, je me suis acheté du câble le lendemain pour attaquer le montage. Il faut donc commencer par couper 16 petits morceaux de câble servant à alimenter les 8 socles des tubes à UV :

Fils de cuivre

Fil de cuivre monobrin 1.5 mm d'environ 2.5 cm de long

Après c’est facile, il suffit de souder :

Soudure cable vu de dessus

Soudure cable vu de dessus

Soudure cable vu de dessous

Soudure cable vu de dessous

Et enficher les supports dans lampes à UV :

Enfichage du support des tubes UV

Enfichage du support des tubes UV

Et fixer via les vis / écrous nylon (attention à ne pas serrer trop fort ! Le but de la manœuvre est de faire en sorte que les supports soient stables sur le socle) :

Ecrous nylons

Ecrous nylons

Vient le tour des starters qui sont à souder directement sur le circuit imprimé (Ne pas hésiter à mettre pas mal d’étain) :

Les starters sont soudés directement sur le circuit

Les starters sont soudés directement sur le circuit

Il est maintenant possible de fixer les deux transfos. Cela s’effectue en vissant les deux transfos avec vis / écrous en métal, puis en soudant deux câbles monobrin de diamètre 1.5 mm :

Fixation des deux transfos

Fixation des deux transfos

On place quelques silent-blocs sous la plaque :

Silent-blocs

Silent-blocs

Une petite vue de haut pour le fun (c’est beau non ?) :

Vu de haut

Vu de haut

Et on passe à l’alimentation de la valise :

Passage du cordon secteur

Passage du cordon secteur

On soude le cordon à la plaque :

Soudure secteur

Soudure secteur

On met en place le cordon dans la valise (l’ajout d’un serre câble est vivement conseillé pour éviter que le câble se décroche en cas de tension sur le fil – Ha ha! Jeu de mots) :

Fixation définitive du cordon

Fixation définitive du cordon

Et les étapes finales qui sont la pose du cache en plastique au dessus des transformateurs, Le montage des tubes à UV (ils sont clipsés), la pose du verre sur les starters (rien n’est collé, c’est juste posé dessus) et la fixation de la mousse à l’aide de double face :

Insoleuse terminée !!

Insoleuse terminée !!

Me voilà prêt à créer mes propres circuits imprimés !! 😀

Enfin presque… Car il faut une graveuse aussi… et un typon… Et des gants… Du perchlorure de fer… Mais ça c’est pour une autre fois ! 😀

Publié dans Non classé | Marqué avec , , , | 2 commentaires

Rafistolage de Pintech

Alors aujourd’hui, un pote m’a filé deux cymbales Pintech (TC10 et TC16) pour la batterie ion drum rocker… MAIS elles ne fonctionnent plus :'(

Cymbale Pintech TC10

Cymbale Pintech TC10

En fait, en démontant le petit boitier derrière la cymbale, on s’aperçoit de plusieurs choses :

  1. La cymbale n’est en fait qu’un bout de plastique en forme de cymbale avec un transducteur piezo et un jack femelle… La Pintech TC10 est quand même à plus de 35 $ pièce (le piezo et le jack ne représentent pas plus de 1.5 € à eux deux)… Je ne suis pas certain qu’un bout de plastique moulé coûte plus de 30 $ à produire !! Bref !
  2. Le fil reliant le piezo et le jack est en fait sectionné… Rien de bien étonnant vu que l’ensemble est fixé sur de la mousse (et laisse donc les vibrations faire leur office)
Cymbale Pintech TC10

Le fil noir est sectionné

Cymbale Pintech TC10

On voit mieux quand c'est démonté 🙂

Bon du coup, j’ai essayé de rafistoler la chose :

Cymbale Pintech TC10

Fil ressoudé

Remontage, tests, et ça marche nikel chrome ! 😀

Même si on a toutes les chances qu’un des deux fils se casse de nouveau, au moins on peut encore jouer pas mal d’heures avec avant d’en racheter de nouvelles :p

Publié dans Jeux vidéos, Rock Band | Marqué avec , , , , | Un commentaire

Convertir les TimeStamp Java en DateTime C#

En bidouillant un peu les données récupérées par l’API Wow, je me suis rendu compte que certaines données sont en fait des TimeStamp Java. Le TimeStamp est une unité de mesure du temps utilisé principalement en Java.

Afin de pouvoir utiliser ces données dans mes traitements C#, j’ai fait quelques recherches sur le sujet…

Le TimeStamp Java s’appuie sur une date de référence. Cette date est fixée au 1 janvier 1970 à minuit. En java, lorsque l’on utilise un TimeStamp, il s’agit en réalité du nombre de millième de secondes écoulés depuis la date de référence (1 000 unités TimeSpamp donnent une seconde). En C# en revanche, l’unité de mesure est le tick (1 seconde vaut 10 000 000 ticks sous Windows). Cf. http://msdn.microsoft.com/en-us/library/system.datetime.ticks.aspx pour le détail d’un DateTime C#.

Et bien maintenant c’est tout simple ! Ce n’est qu’un peu de math… Je passe les détails du calcul, mais il suffit de multiplier par 10 000 le TimeStamp Java pour obtenir un nombre de Ticks Windows. Une fois ce nombre calculé, je n’ai plus qu’à l’ajouter à ma date de référence (01/01/1970) et le tour est joué !

Ah si, une dernière remarque : Il faut toujours penser aux fuseaux-horaires quand on joue avec les dates… Donc pour obtenir la vraie date dans le fuseau-horaire courant, il faut appliquer la fonction « ToLocaleTime ». Cette dernière se charge d’appliquer les décalages horaires adéquat en fonction de la machine sur laquelle s’exécute le traitement. Ainsi, plus besoin de s’enquiquiner avec l’ajout d’une ou deux heures…

Allez, un petit bout de code pour le fun :

/// <summary>
/// Helper pour les méthodes de compatibilité Java
/// </summary>
public static class JavaHelper
{
    private static DateTime _referenceDate = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Unspecified);

    /// <summary>
    /// Fonction permettant de convertir les TimeStamp Java en DateTime C#
    /// </summary>
    /// <param name="timeStamp">TimeStamp Java</param>
    /// <returns>Date C#</returns>
    public static DateTime ConvertJavaTimeStampToDateTime(long timeStamp)
    {
        return _referenceDate.AddTicks(timeStamp * 10000).ToLocalTime();
    }
}

NOTE : Pour le moment, la plus petite unité de mesure du temps que j’ai réussi à trouver sur UNIX est le centième de seconde (0.01 sec). il faut utiliser la fonction POSIX « times » définie dans l’include « sys/times.h ».

Publié dans C#, Informatique | Marqué avec , , , | Laisser un commentaire

Astuce C# du jour : Déplacer les DLL d’un binaire DotNet

En temps normal, sans parler du GAC (Global Assembly Cache), toutes les DLL dont dépendent un binaire C# doivent se trouver dans le même répertoire que ce dernier pour qu’il puisse s’exécuter correctement… Malheureusement, plus les projets grossissent, et plus le nombre de DLL augmente. Ce qui rend l’organisation du répertoire du binaire quelque peu anarchique !

Et bien, voici la solution miracle : Il est possible d’indiquer par configuration les répertoires potentiels où se trouvent les DLL du projet ! 😀

Prenons l’exemple d’une application quelconque « CanShooter.exe » qui a besoin de la DLL « CanShooter.Bean.dll » pour fonctionner. Si nous déplaçons la DLL dans un sous-répertoire « Custom API », l’application ne fonctionne plus !

La magie opère lorsque l’on créé un fichier de configuration de l’application nommé « CanShooter.config » et qui contient les éléments suivants :

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
 <runtime>
   <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
     <probing privatePath="Custom API"/>
   </assemblyBinding>
 </runtime>
</configuration>

Et voilà, le tour est joué ! 😀

Publié dans C#, Informatique | Marqué avec , , , , , | 3 commentaires

Client Rest

Et voilà, c’est fait ! J’ai fait un petit client Rest tout simplissime en C# 🙂

L’idée est ici d’avoir une petite API qui se charge pour moi de faire l’appel Web et la dé-sérialisation des données dans un objet C#. Je m’appuie sur les contrats WCF pour la définition de l’objet en mémoire (DataContract, DataMember, etc.).

Imaginons que je désire récupérer les informations de mon personnage de Wow avec sa guilde. Blizzard a mis à disposition des serveurs que nous pouvons interroger en JSON. Pour notre cas de figure, la documentation de Blizzard indique ceci :

URL = Host + "/api/wow/character/" + Realm + "/" + CharacterName
       + "?locale=" + locale + "&fields=" + optional(s) field(s)

Realm = <proper realm name> | <normalized realm name>

Ce qui nous donnera un appel Web qui ressemblera à ceci :

GET /api/wow/character/La Croisade écarlate/Shoubido?fields=guild
Host: eu.battle.net

La documentation indique également la structure des données en sortie :

HTTP/1.1 200 OK
<http headers>

{
   "realm": "Medivh",
   "name": "Uther",
   "level": 85,
   "lastModified": 1307596000000,
   "thumbnail": "medivh/1/1-avatar.jpg",
   "race": 1,
   "achievementPoints": 9745,
   "gender": 0,
   "class": 2,
   "guild":{
    "name":"Knights of the Silver Hand",
    "realm":"Medivh",
    "level":25,
    "members":50,
    "achievementPoints":7500,
    "emblem":{
      "icon":119,
      "iconColor":"ffb1b8b1",
      "border":0,
      "borderColor":"ffffffff",
      "backgroundColor":"ff006391"
    }
  }
}

Nous allons dans un premier temps nous focaliser sur la classe qui contiendra les données à récupérer. La déclaration est par exemple la suivante :

    [DataContract]
    public class CharacterRawData : IExtensibleDataObject
    {
        [DataMember(Name = "realm", IsRequired = true)]
        public string Realm { get; set; }

        [DataMember(Name = "name", IsRequired = true)]
        public string Name { get; set; }

        [DataMember(Name = "level", IsRequired = true)]
        public long Level { get; set; }

        [DataMember(Name = "lastModified", IsRequired = true)]
        public long LastModified { get; set; }

        // ... Les autres champs ne sont pas présentés

        public ExtensionDataObject ExtensionData { get; set; }
    }

Le point important dans cette déclaration de classe est qu’il faut hériter de l’interface IExtensibleDataObject. Petit rappel WCF : Cette interface impose la présence de la propriété ExtensionData qui sera alimentée par les champs non déclarés dans la classe au moment de la sérialisation / dé-sérialisation des données par le moteur WCF. Ainsi, nous ne pouvons pas perdre les informations restituées par le serveur de Blizzard.

Une fois cet objet défini, il suffit d’utiliser mon petit client Rest comme suit :

// Création du client Rest
var restClient = new RestClient(new Uri("http://eu.battle.net"));

// On demande au client Rest de récupérer les données
var result = restClient.Retrieve<CharacterRawData>(
  RestResource.Create("/api/wow/character/{realm}/{character name}")
  .AddPathParameter("realm", "La Croisade écarlate")
  .AddPathParameter("character name", "Shoubido")
  .AddQueryParameter("fields", "pvp")
  .AddQueryParameter("locale", CultureInfo.CurrentCulture));

En fait, pour résumer :

  1. Nous créons un client Rest avec l’adresse du serveur que nous désirons interroger
  2. Nous appelons la méthode « Retrieve » du client Rest. Le type générique de cette méthode correspond au type de la classe qu’elle doit utiliser pour dé-sérialiser les données du serveur (Le type doit obligatoirement implémenter l’interface « IExtensibleDataObject »). Donc ici, la variable « result » est de type « CharacterRawData ». La méthode « Retrieve » prend en paramètre une ressource Rest (« RestResource »). Cette ressource définie les éléments nécessaires pour interroger le serveur.
  3. Nous utilisons la méthode statique « RestResource.Create » pour créer une nouvelle ressource Rest. Cette ressource définie l’URL à interroger (chemin + paramètres GET éventuels).
  4. Le chemin est paramétrée avec le nom de la guilde et le nom du personnage. Chaque paramètre du chemin est définie entre accolades. Afin de valoriser ces paramètres, il faut utiliser la fonction « AddPathParameter » qui prend en paramètre le nom du paramètre ainsi que sa valeur (qui peut être de tout type – Le client Rest convertira la valeur en chaîne de caractères).
  5. Enfin, l’URL peut posséder des paramètres GET qui sont valorisés en utilisant la fonction « AddQueryParameter » qui prend en paramètre le nom du paramètre GET ainsi que sa valeur (qui peut être de tout type – Le client Rest convertira la valeur en chaîne de caractères).

Et voilà, le tour est joué ! 😀 Le code source de ce petit client Rest se trouve ici.

Enjoy !

Publié dans C#, Informatique | Marqué avec , , , , | Laisser un commentaire