Upcoming: Event-based G15 LCD library

Posted on June 21st, 2008 by SealedSun

I'm sure all of you have heard of Logitech's G15 gaming keyboard, yes the one with the built-in LCD. I've recently bought the first version (see picture) and obviously want to write applications that target the small 160x43 pixel screen. Logitech provides a native (C++) SDK with their drivers and someone was kind enough to descend into the creepy world of pointers and manual memory management for all .NET developers out there.

This managed wrapper, however, is an extremely low-level interface: In order to draw something onto the screen, you have to pass an array of bytes (more precisely: a pointer to its first element) that holds the bitmap to display. This is obviously not very practical and completely alienating for people who, up until now, lived in the comfortable world of Windows.Forms.

Logitech G15 (first version)

Not being able to find a more abstract library for the G15 LCD, I decided to write my own GUI library. The first task was to make rendering via System.Drawing possible. After having to find out that the only monochrome pixel format is indexed and can therefor not be targeted by a Graphics object, I resorted to using a 24BppRGB  bitmap for rendering instead. I then manually iterate over the pixels in that buffer, determining the brightness of the pixel and applying a threshold in order to get a monochrome copy into a byte array.

On top of that I am currently building a Widget/Control oriented display layer complete with event routing for the four soft buttons, Z-ordering and clipping for nested controls. Below you see the trivial implementation of the LcdLabel control:

PLAIN TEXT
C#:
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Drawing;
  5.  
  6. namespace Logitech.GamePanel
  7. {
  8.   public class LcdLabel : LcdControl
  9.   {
  10.  
  11.     public LcdLabel()
  12.     {
  13.       StringFormat = new StringFormat()
  14.       Size = new Size(LcdScreen.Width, DefaultFont.Height);
  15.     }
  16.  
  17.     private string _text;
  18.  
  19.     public string Text
  20.     {
  21.       get
  22.       {
  23.         return _text;
  24.       }
  25.       set
  26.       {
  27.         if (value == null)
  28.           value = "";
  29.         _text = value;
  30.         Update();
  31.       }
  32.     }
  33.  
  34.     public StringFormat StringFormat { get; set; }
  35.  
  36.     protected override void OnPaintBackground(PaintEventArgs e)
  37.     {
  38.       using (var back = new SolidBrush(BackgroundColor))
  39.         e.Graphics.FillRectangle(back, ClientBounds);
  40.     }
  41.  
  42.     protected override void OnPaint(PaintEventArgs e)
  43.     {
  44.       //Paints background
  45.       base.OnPaint(e);
  46.  
  47.       using (var fore = new SolidBrush(ForegroundColor))
  48.         e.Graphics.DrawString(_text, Font, fore,
  49.             ClientBounds, StringFormat);
  50.     }
  51.   }
  52. }

G15 Counter in the LCD emulator

One thing I am proud of, is my implementation of delayed and repeated button press events if a button is being hold down. The buttons use the same repeat delay as the Keyboard (configurable via the device driver/windows).
Repeated Pressed events are particularly useful for the sample application below, a little application that provides a counter that can be incremented, decremented and reset via soft buttons.

PLAIN TEXT
C#:
  1. using System;
  2. using System.Drawing;
  3. using System.Threading;
  4. using Logitech.GamePanel;
  5.  
  6. namespace LcdSandbox
  7. {
  8.   class CounterPage : LcdPage
  9.   {
  10.     const string counterFormat = "Count: {0:N0}";
  11.  
  12.     LcdLabel lTitle;
  13.     LcdLabel lCounter;
  14.  
  15.     public int Count { get; set; }
  16.  
  17.     public CounterPage(LcdScreen scr)
  18.       : base(scr)
  19.     {
  20.       #region Page initialization
  21.  
  22.       //Although the page itself does not draw any text,
  23.       // the font is inherited by child controls
  24.       Font = new Font("Calibri", 12, GraphicsUnit.Pixel);
  25.  
  26.       //lTitle - A label that display a title
  27.       lTitle = new LcdLabel()
  28.       {
  29.         Location = new Point(0, 2),
  30.         Text = "I'll count for you!"
  31.       };
  32.       Controls.Add(lTitle);
  33.  
  34.       //lCounter - A label that displays the current count
  35.       lCounter = new LcdLabel()
  36.       {
  37.         Location = new Point(0, 20),
  38.         StringFormat = new StringFormat()
  39.         {
  40.           Alignment = StringAlignment.Center,
  41.           LineAlignment = StringAlignment.Center
  42.         }
  43.       };
  44.       Controls.Add(lCounter);
  45.  
  46.       //Define soft button descriptions
  47.       LcdControl BDesc;
  48.  
  49.       //Button 0 - Increment
  50.       BDesc = new LcdImage(Icons.UpArrow);
  51.       Button0.Controls.Add(BDesc);
  52.       Button0.Pressed += (obj, e) =>
  53.       {
  54.         Count++;
  55.         updateCounter();
  56.       };
  57.  
  58.       //Button 1 - Decrement
  59.       BDesc = new LcdImage(Icons.DownArrow);
  60.       Button1.Controls.Add(BDesc);
  61.       Button1.Pressed += (obj, e) =>
  62.       {
  63.         Count--;
  64.         updateCounter();
  65.       };
  66.  
  67.       //Button 2 - Reset
  68.       BDesc = new LcdImage(Icons.First);
  69.       Button2.Controls.Add(BDesc);
  70.       Button2.Pressed += (obj, e) =>
  71.       {
  72.         Count = 0;
  73.         updateCounter();
  74.       };
  75.  
  76.       //Button 3 - Exit
  77.       var exitSignal = new AutoResetEvent(false);
  78.       BDesc = new LcdImage(Icons.Delete);
  79.       Button3.Controls.Add(BDesc);
  80.       Button3.Pressed += (obj, e) =>
  81.       {
  82.         Screen.ExitMessageLoop();
  83.       };
  84.  
  85.       #endregion
  86.  
  87.       Priority = ScreenPriority.Normal;
  88.       updateCounter();
  89.     }   
  90.  
  91.     private void updateCounter()
  92.     {
  93.       lCounter.Text = String.Format(counterFormat, Count);
  94.       Update();
  95.     }
  96.  
  97.   }
  98.  
  99.   class Program
  100.   {
  101.     static void Main(string[] args)
  102.     {
  103.       using (var screen = new LcdScreen())
  104.       {
  105.         //You must not forget to open the screen
  106.         // before asigning any pages.
  107.         screen.Open("My LCD Sandbox");
  108.  
  109.         //Create a new instance of our counter page       
  110.         var page = new CounterPage(screen);
  111.  
  112.         //Tell the screen to display our counter page
  113.         screen.CurrentPage = page;
  114.  
  115.         //Temporarily set the priority to Alert
  116.         page.TemporaryAlert(500);       
  117.  
  118.         Console.WriteLine("Application running.");
  119.         Console.WriteLine("See LCD for instructions");
  120.  
  121.         //The Run method is similar to Application.Run
  122.         // from System.Windows.Forms. Until screen.Close
  123.         // or screen.ExitMessageLoop is called, this
  124.         // thread will handle events.
  125.         screen.Run();
  126.       }
  127.     }
  128.   }
  129. }

The library is in what others call 'Alpha' stage. I do plan to release it here once I'm done documenting the most commonly used methods or if someone is particularly interested and wants to start coding right now.

Tags: Programming // 2 Comments »

2 Responses to “Upcoming: Event-based G15 LCD library”

  1. ermau // Jun 23, 2008 at 01:06

    This sounds great! Can't wait to work with it, I've been meaning to do something similar I just haven't found the time.

  2. SealedSun // Jun 23, 2008 at 16:50

    Thanks, that's really motivating: :-)

Discussion Area - Leave a Comment




« »