Geek is in da House : retrouvez-moi en conférence aux Microsoft TechDays 2014 le 11, 12 et 13 février

9 février 2014

logo_mstechdays

L’évènement le plus reconnu par les professionnels du numérique en Europe vous ouvre ses portes les 11, 12 et 13 février 2014 au Palais des Congrès de Paris.

Avec 18 000 visiteurs, les TechDays, ce sont trois jours dédiés aux nouvelles technologies et aux enjeux de la transformation numérique.

En quelques mots :

  • 1 Keynote dédié aux développeurs le mardi 11 février
  • 1 Keynote dédié aux professionnels de l’IT le mercredi 12 février
  • 1 Keynote dédié aux décideurs IT et décideurs métiers autour de l’innovation le jeudi 13 février
  • Plus de 300 sessions
  • Un salon d’exposition de 5500m² avec près de 140 exposants spécialisés
  • Une TechDays TV, chaîne de télévision sur Internet, pour suivre l’essentiel des 3 jours de l’événement

A cette occasion retrouvez-moi en conférence aux côtés de 3 Microsoftees (et non des moindres) : David Catuhe, Stanislas Quastana et Laurent Ellerbach ce mercredi 12 février de 17h45 à 18h45 pour la mythique “Geek is in da House” !

Cette année le geek est toujours dans la maison avec un gros sujet autour de la domotique et quelques surprises dont un retour sur une expérience ésotérique pour les geeks. Encore et toujours du WAF, du backup d’Internet et de la geekerie de qualité française ! Inscrivez-vous le plus rapidement possible car l’année dernière nous avons dû refuser du monde !!!

Fiche de la session : http://www.microsoft.com/france/mstechdays/programmes/2014/fiche-session.aspx?ID=23b47a33-e0a4-45be-848d-607ed0a13a8b

Vous l’aurez compris : beaucoup de domotique cette année et des projets bien geek, du WAF, du fun, et des surprises à gagner !!

Pour suivre la session :

  • Retrouvez-nous au Palais des Congrès de Paris. Par ici les inscriptions, mais attention venez tôt pour avoir de la place Sourire
  • Retrouvez la session rediffusée en direct sur la TechDays TV

A mercredi Clignement d'œil

SlightBox V2 – La version “mini”

9 février 2014

Après un premier prototype d’une solution « Ambilight » maison développée avec des modules .NET Gadgeteer, la “SlightBox V2” est une version miniaturisée et beaucoup moins chère.

Rappel des épisodes précédents :

Pour rappel (voir l’article sur le fonctionnement de la V1), la SlightBox V1 est une box développée avec les modules .NET Gadgeteer uniquement dans le but servir d’interface USB/SPI pour le pilotage des bandes de leds LDP8806. Pour rendre la solution plus compacte et moins onéreuse,  nous allons utiliser une puce MCP2210 de Microchip qui n’est ni plus ni moins qu’une interface USB/SPI en une seule puce  !!

Plusieurs sociétés proposent des modules prêt-à-l’emploi équipés de cette puce. Pour ma part, j’ai sélectionné le produit de Embedded Adventures, le “MCP2210 USB2SPI Module” vendu 15.30$ (hors frais de port) et livré avec une API .NET.

MOD-1013_1_600

Il ne vous faudra plus qu’une petite boite, un connecteur DC pour l’alimentation et un connecteur JST pour y connecter la bande de LED LDP8806.

Pour rappel, nous utiliserons la sortie MOSI pour les “Datas” (équivalent de la PIN 7 sur une socket “S” Gadgeteer), le “SCK” pour l’horloge (équivalent de la PIN 9) et le “GND” pour le ground.

WP_003714WP_003732

WP_003746

A la différence de la SlightBox V1 j’ai supprimé l’interrupteur et la LED témoin de l’alimentation.

WP_003740WP_003741

La SlightBox V1 (à gauche) vs la SlightBox V2 (à droite)

Côté software, la logique reste exactement la même ! La seule différence est dans la façon dont le logiciel va envoyer les données à la bande de LED :

  • Avec la SlightBox V1, c’est la box “Gagdeteer” qui fait office d’interface. Nous utilisons le module “Serial USB” qui est reconnu comme un port COM virtuel au niveau du Windows. Le programme Windows “Slight” envoie donc les données sur le port COM virtuel de la SlightBox qui seront ensuite retranscrits par le programme Gadgeteer sur la sortie “SPI” via le module “Extender”.
  • Avec la SlightBox V2, c’est la puce MCP2210 qui fait office d’interface. Il faut alors utiliser l’API mis à disposition par le fabricant pour pouvoir envoyer nos données !

Pour simplifier le développement côté Windows, nous utiliserons une simple interface pour décrire une « SlightBox » :

1
2
3
4
5
6
7
8
namespace SLight.Devices
{
    public interface ISlightBox : IDisposable
    {
        void Initialize();
        void WriteDatas(byte[] datas);
    }
}

L’implémentation de la SlightBox V2 utilisera alors l’API de la puce MCP2210 pour envoyer les données sur le port SPI à notre bande de leds via la  fonction « TxferSpiData »  :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
namespace SLight.Devices
{
    public class SlightBoxMCP2210 : ISlightBox
    {
        private const int LATCH_BITS = 4;
        private const int SPI_BIT_RATE = 16000;
 
        private const uint MCP2210_VID = 0x04D8;   // VID for Microchip Technology Inc.
        private const uint MCP2210_PID = 0x00DE;   // PID for MCP2210
 
        private bool isConnected = false;
        private DevIO usbDevice = null;
 
        public void Initialize()
        {
            this.usbDevice = new DevIO(MCP2210_VID, MCP2210_PID);
            this.isConnected = this.usbDevice.Settings.GetConnectionStatus();
            if (this.isConnected)
            {
                this.usbDevice.Settings.SetSpiBitRate(DllConstants.CURRENT_SETTINGS_ONLY, SPI_BIT_RATE);
                Console.WriteLine("Connected and ready to use !");
            }
            else
            {
                MessageBox.Show("SlightBox MCP2210 not connected !");
                this.Initialize();
            }
        }
 
        public void WriteDatas(byte[] datas)
        {
            byte[] dataRead = new byte[datas.Length + LATCH_BITS];
            byte[] datasToSend = new byte[datas.Length + LATCH_BITS];
            Array.Copy(datas, 0, datasToSend, LATCH_BITS, datas.Length);
            this.usbDevice.Settings.SetSpiTxferSize(DllConstants.CURRENT_SETTINGS_ONLY, (ushort)datasToSend.Length);
            this.usbDevice.Functions.TxferSpiData(datasToSend, dataRead);
        }
 
        public void Dispose()
        {
        }
    }
}

Et voilà en quelques lignes et quelques soudures comment minuaturiser le concept “Slight”.  Côté performance, c’est exactement la même chose qu’avec la V1.

Et si vous ne l’avez toujours pas vu, voici le résultat :

Développé initialement pour “Slight” (ma solution “Ambilight” maison), la SlightBox et plus particulièrement la SlightBox V2 en raison de sa taille réduite, peut servir dans un tas d’application où nous avons besoin de piloter des bandes de LED.

Retrouvez plus d’informations et photos sur la page Facebook SlightBox.

SlightBox V1 : un système « Ambilight » avec C# et Gadgeteer

9 février 2014

Cet article a été initialement publié dans le magazine Programmez! n°165 paru en Juillet/Aout 2013.

Inventée en 2002 par Phillips, la technologie Ambilight consiste à générer des effets lumineux autour de l’écran en fonction du contenu vidéo. Nous allons découvrir dans cet article comment développer notre propre système « Ambilight » en utilisant des modules « .NET Gadgeteer » et un peu de C#. Préparez Visual Studio, une perceuse et un fer à souder !

Principe de fonctionnement

Il n’est pas très complexe de développer un système « Ambilight » performant. Dans cette première version, le prototype « SLightBox » est conçu pour fonctionner avec Windows. Cela vous permettra de profiter de ce système sur vos ordinateurs ou media-centers quel que soit le contenu vidéo (photo, vidéo, jeu ou toute autre application ou média).

Pour réaliser un prototype rapide du concept, les modules .NET Gadgeteer basés sur le .NET Microframework offrent une plateforme de développement très facile à utiliser pour les développeurs.

Comme cette première solution se base sur l’utilisation d’un PC, l’analyse du contenu vidéo sera relativement simple à entreprendre : capturer l’écran afin de récupérer l’ensemble des pixels affichés !

Pour obtenir une expérience visuelle immersive nous avons besoin de dispositifs lumineux derrière l’écran longeant chacun des côtés. Pour que l’effet soit optimal, l’écran devra être placé à plus ou moins 30 cm d’un mur, si possible de couleur claire (idéalement blanc). De plus ces dispositifs lumineux, comme des LEDs par exemple, devront être contrôlables individuellement.

Une fois la capture de l’écran réalisée, le logiciel calculera la moyenne des couleurs pour chaque zone afin d’envoyer cette couleur à sa LED associée, située derrière l’écran (on établit qu’une zone est associée à une LED uniquement). Cette opération doit avoir lieu plus de 10 fois par seconde pour rester fluide et réactive par rapport au contenu vidéo.

Le hardware

Les LEDs

La solution la plus adaptée au besoin sera d’utiliser des bandes de LEDs multicolores. Ces bandes de LED offrent la possibilité de les sectionner à certains endroits de la bande (en général par pas de 3 à 10 cm) permettant ainsi une plus grande souplesse d’utilisation. Il existe cependant deux types de bandes LEDs multicolores : les analogiques et les digitales.

Les bandes analogiques sont les plus répandues dans le commerce et les moins couteuses car l’ensemble des LEDs qui la constitue (généralement des SMD5050 qui intègrent 3 LEDS : une rouge, une bleue et une verte) sont connectées en parallèle. On contrôle ainsi la couleur de toutes les LEDs en modulant le signal avec une sortie analogique PWM (et quelques MOSFETs pour amplifier le signal).

Pour permettre un contrôle individuel de la couleur de chaque LED, les bandes dites « digitales » intègrent des microcontrôleurs pour pouvoir adresser chaque LED individuellement.

On trouve dans le commerce une multitude de microcontrôleurs pour cet usage (HL1606, WS2801, WS2811, LPD8603, TM1812, UCS1903, etc…) les plus répandus étant le WS2801 et le LPD8806.

Ce dernier permet de contrôler 6 canaux séparés de 7 bits. Il y a donc un microcontrôleur pour deux LEDs où chaque couleur est codée sur 21 bits soit 2 097 152 combinaisons de couleur/brillance possible.

En général il y a 32 LEDs (donc 16 microcontrôleurs LPD8806) par mètre mais certains fabricants proposent jusqu’à 52 LEDs/mètre.

image

Pour l’installation, il suffit de découper votre bande de LEDs suivant les dimensions de votre écran. Chacune de vos bandes doit être connectée en série en les reliant ensemble. Il y a deux connecteurs pour l’alimentation (5V) et deux connecteurs pour l’interface SPI (données et horloge).

Sur l’une des extrémités, vous souderez un connecteur JST 4 pôles pour la connexion à la « SLightBox ».

image

La « SLight Box »

Pour piloter le bus SPI depuis une application Windows nous utiliserons des modules .NET Gadgeteer. Il faut donc une carte mère (mainboard) Gadgeteer comme la FEZ Spider, FEZ Hydra ou moins cher, la FEZ Cerberus (ainsi que son module d’alimentation comme le module « SP Client »).

Pour la communication avec l’ordinateur nous utiliserons le module « USB-Serial » qui expose un port COM virtuel pour dialoguer depuis notre PC.

Pour le contrôle des LEDs, les cartes .NET Gadgeteer disposent d’une interface SPI sur les sockets de type « S » où la pin 7 est utilisée pour écrire les données (le MOSI) et la pin 9 pour l’horloge (SCK). Nous utiliserons le module Extender en soudant une petite barrette mâle (pas standard 2,54mm) pour faciliter les connexions.

image

L’ensemble de ces modules sera installé dans une petite boite en plastique avec une connectique pour :

  • l’alimentation 5V,
  • le connecteur USB du module « USB-Serial »,
  • le connecteur JST vers les bandes de LEDs.

En façade :

  • un interrupteur,
  • une LED témoin rouge d’alimentation.

image image

L’entrée 5V est coupée par l’interrupteur puis alimente le module SP (donc la mainboard Gadgeteer), la sortie JST (pour les LEDs) et la LED témoin en façade.

figure 8 v2 image

Le software

Côté Gadgeteer

La «  SlightBox Gadgeteer » est ni plus ni moins qu’une interface USB/SPI vers les bandes de LEDs. Son rôle est simple : attendre les données du PC via le port USB et les recopier sur le port SPI.

image

Au démarrage de la carte Gadgeteer, nous initialiserons la sortie SPI sur la socket du module Extender en spécifiant l’horloge à 16mhz, ainsi que le module USB en spécifiant le débit du port COM au maximum (115200 bauds) :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Configure SPI Port
GTI.SPI.Configuration spiConfig = new GTI.SPI.Configuration(
         false,	// chip select active state
         0,		// chip select setup time
         0,		// chip select hold time
         false,	// clock idle state
         true,	// clock edge (true = rising)
         16000);	// 16mhz
mLedStrip = new GTI.SPI(Socket.GetSocket(extender.ExtenderSocketNumber, true, extender, null), spiConfig, GTI.SPI.Sharing.Exclusive, null);
// Configure USB Serial port
usbSerial.Configure(115200, Gadgeteer.Interfaces.Serial.SerialParity.None, Gadgeteer.Interfaces.Serial.SerialStopBits.One, 8);
// Open USB Serial port
usbSerial.SerialLine.Open();
// Ready !
Debug.Print("SLightBox Ready !");

Pour la suite, il suffit d’attendre les données du port USB pour les recopier sur l’interface SPI :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
while (true)
{
    if (usbSerial.SerialLine.BytesToRead > 0)
    {
        int bytesRead;
        if ((bytesRead = usbSerial.SerialLine.Read(buffer, 0, usbSerial.SerialLine.BytesToRead)) > 0)
        {
            byte[] dataToWrite = new byte[bytesRead];
            Array.Copy(buffer, dataToWrite, bytesRead);
            mLedStrip.Write(dataToWrite);
            Thread.Sleep(10);
        }
    }
    else
    {
        Thread.Sleep(1);
    }
}

La « SlightBox » est prête, il suffit de la connecter aux LEDs par le connecteur JST, au PC par un câble USB et à un transformateur 5V. En enclenchant l’interrupteur, la « SlightBox » sera détectée comme un « port COM virtuel » et attendra les données à envoyer aux LEDs !

Pour finir, n’oubliez pas de bien dimensionner la puissance de l’alimentation 5V : il faut prévoir 0,5 ampères pour les modules Gadgeteer puis 2 ampères par mètre de LEDs (une LED consomme 60mA au maximum lorsqu’on affiche du blanc. Pour 32 LEDs/mètre, on peut théoriquement consommer près de 2A).

Côté Windows

Une fois la partie « hardware » terminée, nous pouvons nous attaquer au « cœur » de cette solution : le programme Windows : Slight.

Ce programme doit être capable de capturer l’image de votre écran afin d’analyser les couleurs dominantes et les envoyer sur le port COM virtuel qui seront ensuite transmises par SPI aux LEDs via le programme Gadgeteer de la « SlightBox ».

Pour la capture de l’écran, nous nous servirons de DirectX pour des questions de performance à l’aide de SlimDX, un framework .NET open-source pour DirectX.

Par exemple pour capturer l’écran principal :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Initialization 
this.dxDevice = new Device(
    new Direct3D(), 0, DeviceType.Hardware, IntPtr.Zero, CreateFlags.SoftwareVertexProcessing,
    new PresentParameters() { Windowed = true, SwapEffect = SwapEffect.Discard });
 
// To capture, get the screen surface
Surface surface = Surface.CreateOffscreenPlain(
                this.dxDevice,
                Screen.PrimaryScreen.Bounds.Width,
                Screen.PrimaryScreen.Bounds.Height,
                Format.A8R8G8B8, Pool.Scratch);
// Capture surface screen buffer data
Surface screenSurface = this.dxDevice.GetFrontBufferData(0, surface);
DataRectangle screenRectangle = screenSurface.LockRectangle(LockFlags.None);
DataStream screenDataStream = screenRectangle.Data;
 
// - Do work -
 
// Dispose screen surface
screenSurface.UnlockRectangle();
screenSurface.Dispose();

Le “DataStream” est un flux où chaque pixel est représenté sur 4 bits (B, G, R, A).

Au démarrage le programme Slight calcule les coordonnées de chaque zone en fonction de la disposition des bandes de LEDs et de la résolution de l’écran. On sélectionne ensuite les coordonnées d’un pixel sur vingt dans cette zone comme échantillon pour calculer la couleur moyenne de la zone.

Comme chaque zone est associée à une LED uniquement, nous ajouterons des Panels dans notre fenêtre pour visualiser les couleurs calculées pour chaque LED.

A la fin de l’initialisation nous disposons donc de la position dans le DataStream de chaque « pixel échantillon » pour chaque zone.

A l’aide d’un « Timer » déclenché toutes les 50ms, nous capturerons le DataStream de l’écran afin de calculer la couleur moyenne de chaque zone par la méthode GetColorAverage :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private Color GetColorAverage(DataStream screenDataStream, Collection positions)
{
    byte[] buffer = new byte[BITS_PER_PIXEL];
    int r = 0, g = 0, b = 0, count = 0;
    // For each pixels
    foreach (long pos in positions)
    {
        screenDataStream.Position = pos;
        screenDataStream.Read(buffer, 0, BITS_PER_PIXEL);
        r += buffer[2];
        g += buffer[1];
        b += buffer[0];
        count++;
    }
    // Return the average color for the list of pixels
    return Color.FromArgb(r / count, g / count, b / count);
}

Pour adresser la couleur à la bonne LED nous devons écrire la liste des couleurs des zones les unes derrière les autres.

Pour rappel, avec le LPD8806 les couleurs sont définies en GRB (Vert, Rouge, Bleu) sur 7 bits. On pourrait donc diviser la valeur capturée du R, G et B par deux. Néanmoins pour rendre les couleurs plus riches, nous appliquerons une petite correction gamma : (127 * (La_Couleur_sur_8_bits / 255) ^ Correction_Gamma) + 0.5 (où « Correction_Gamma » est par défaut à 2,5 mais peut varier entre 1 et 5 en fonction de vos préférences).

Ainsi pour chaque capture :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
byte[] colorData = new byte[ledBytesCount];
// For each zones (= for each leds)
for (int i = 0; i < numberOfLeds; i++) 
{
    Color pixelColor = Color.Black;
    if (pixelsList.Count > i)
    {
        // Get color average
        pixelColor = this.GetColorAverage(screenDataStream, pixelsList[i]);
        // Update UI
        this.updatePanelColorActions[i](pixelColor);
    }
    // Build colorData
    int index = i * BITS_PER_LED;
    if (this.GammaCorrectionEnabled)
    {
        colorData[index + 0] = (byte)(LPD8806_MASK | (byte)(Math.Pow((double)pixelColor.G / 255.0, this.gammaCorrectionValue) * 127.0 + 0.5));
        colorData[index + 1] = (byte)(LPD8806_MASK | (byte)(Math.Pow((double)pixelColor.R / 255.0, this.gammaCorrectionValue) * 127.0 + 0.5));
        colorData[index + 2] = (byte)(LPD8806_MASK | (byte)(Math.Pow((double)pixelColor.B / 255.0, this.gammaCorrectionValue) * 127.0 + 0.5));
    }
    else
    {
        colorData[index + 0] = (byte)(LPD8806_MASK | (pixelColor.G / 2));
        colorData[index + 1] = (byte)(LPD8806_MASK | (pixelColor.R / 2));
        colorData[index + 2] = (byte)(LPD8806_MASK | (pixelColor.B / 2));
    }
}
// Send datas to the SerialPort
byte[] datas = new byte[ledBytesCount + LPD8806_LATCH_BITS];
Array.Copy(colorData, 0, datas, LPD8806_LATCH_BITS, ledBytesCount);
this.port.Write(datas, 0, datas.Length);

Avec les déclarations suivantes :

1
2
3
4
5
6
SerialPort port = new SerialPort("COMx", 115200, Parity.None, 8, StopBits.One);
const int BITS_PER_PIXEL = 4; 
const int BITS_PER_LED = 3; 
const int LPD8806_LATCH_BITS = 21;
const byte LPD8806_MASK = 0x80;
int ledBytesCount = numberOfLeds * BITS_PER_LED;

Le tableau d’actions « updatePanelColorActions » permet de mettre à jour la couleur du Panel associée dans la fenêtre :

image

Voilà l’application terminée, il ne reste plus qu’à tester son bon fonctionnement et ses performances grâce à des vidéos de test spécialement conçues pour Ambilight que vous trouverez sur YouTube.

image

Nous pouvons encore enrichir son fonctionnement en ajoutant la capacité de s’adapter dynamiquement au format de la vidéo ! En effet, lorsque vous regardez une vidéo en 4:3 ou 21:9 sur un écran 16:9 vous n’échapperez pas aux bandes noires horizontales ou verticales. Les zones calculées par Slight risqueraient de ne « rien voir » d’autre que du noir sur certain bord.

Pour combler cette lacune, il faut recalculer les coordonnées des zones en prenant compte de la taille des bandes noires.

Pour cela, au démarrage de l’application, on calcule les coordonnées des pixels d’une ligne fictive partant de chaque bord de l’écran vers le centre.

Plusieurs fois par seconde, on remonte cette ligne tant que le pixel est noir ! Dès lors qu’il ne l’est plus, cela signifie alors que nous sommes au début du contenu vidéo !

Pour éviter un comportement instable, chaque côté utilise trois lignes différentes (au ¼, ½ et ¾) où chaque pixel de couleur trouvé doit être à la même distance du bord sur les deux autres lignes. De plus, le redimensionnement n’a lieu que si les dix dernières mesures ont donné le même résultat.

Ainsi peu importe le contenu vidéo, Slight s’adaptera en toute circonstance !

Conclusion

Le résultat en vidéo :

Comme vous l’avez découvert dans cet article, la réalisation d’un système Ambilight pour PC est relativement aisée à entreprendre avec quelques modules Gadgeteer, un Visual Studio et quelques composants, sans oublier les bandes de LEDs digitales.

Les modules Gadgeteer sont très pratiques pour confectionner des prototypes de tout genre bien que dans ce projet ils soient largement sous-utilisés.

Pour rendre le système moins cher, la « SlightBox v2 » est basée sur une puce MCP2210 USB/SPI dédiée et remplace ainsi les 4 modules Gadgeteer. L’application Windows reste la même dans sa logique mais communique avec la SlightBox non pas via un port COM virtuel du module Gadgeteer mais par le driver HID du fabricant de cette puce.

Pour aller encore plus loin, la « SlightBox v3 » sort du cadre du PC : branchez-la directement sur vos périphériques HDMI (box internet, câble/satellite, DVD/Bluray, consoles de jeux, etc..) et profitez des avantages de Slight sur votre TV sans aucun PC !

Retrouvez plus d’informations et photos sur la page Facebook SlightBox.

Slight : un système Ambilight à base de .NET Gadgeteer

7 mai 2013

SLIGHT LOGO-06Réalisé début Avril, je suis fier de vous présenter le premier prototype de « S-light », ma solution « Ambilight » artisanale !

Il s’agit ici du 1er prototype, deux autres versions déjà en cours de développement paraitront dans les semaines/mois à venir ;)

Cette première version fonctionne avec une application .NET/WPF sur votre PC pour calculer les couleurs de votre écran et piloter des bandes de LED RGB collées derrière votre écran via la « Slight Box », une petite boite refermant des modules .NET Gadgeteer basés sur le .NET Micro-framework.

Plutôt que de rédiger de longues phrases, voici une démonstration en image :

Pour connaître tous les détails techniques ainsi que les secrets de fabrication, je vous donne rendez-vous le mois prochain dans le magazine Programmez! pour un article complet sur le sujet. En attendant voici quelques images :

Rendez-vous le mois prochain dans le magazine Programmez! disponible dans vos kiosques préférés :)

Un grand merci à Pierre-Marie Cronier (Creative director & Co-founder Studio Josette) pour le logo, les photos et la vidéo de présentation de Slight.

UPDATE1  : le projet S-light se nomme maintenant SlightBox et pré-ouverture du site www.slightbox.net (ouverture prévue en Septembre 2013)
UPDATE2 : Création de la page fan sur Facebook ! Suivez l’actualité de SlightBox sur : https://www.facebook.com/slightbox
UPDATE3 : Un article sur la SlightBox Gadgeteer est paru dans magazine Programmez de Juillet-Aout, disponible dans vos kiosques préférés :

Magazine Programmez! été 2013

[SWYH] StreamWhatYouHear.com

6 novembre 2012

Présenté dans mon post précédent, Stream What You Hear (raccourci “SWYH”) est une petite application Windows permettant de streamer le son de votre ordinateur Windows vers un périphérique compatible DLNA comme une TV, un ampli,  et bien d’autre (voir l’article de présentation de SWYH et du protocole DLNA) !

Initialement j’ai développé ce logiciel pour mes besoins personnels en Juin/Juillet 2012 n’ayant pas trouvé d’alternative simple et gratuite sur Internet ! Le mois dernier j’ai décidé de mettre ce logiciel à la disposition de tous sur mon site Internet histoire d’en faire profiter le plus grand nombre !

En trois semaines déjà plusieurs centaines de téléchargements et beaucoup de feedbacks  ! J’ai donc pris quelques heures (merci WordPress) pour monter un site dédié à SWYH que vous retrouverez à l’adresse : http://www.StreamWhatYouHear.com/ !

Et parce qu’une bonne nouvelle n’arrive jamais seule Clignement d'œil J’en ai profité pour mettre à jour SWYH en version 1.1 qui corrige plusieurs bugs et ajoute quelques nouvelles fonctionnalités !

Longue vie à SWYH Sourire

(ps : n’hésitez pas à utiliser le Forum sur le site de SWYH pour remonter vos feedbacks, bugs, critiques, etc…)