Nicolas BESSON's weblog

Windows Embedded products road map

2011-11-26T03:12:00.000-08:00

Microsoft announces the Windows Embedded vNext products releases.
Check out Olivier's Bloch blog for details

- Nicolas

Windows Embedded Compact 7: Enabling the Mouse to Activate Hyperlinks in the Web Browser

2011-11-24T02:17:00.000-08:00

Have issue with the mouse click in IE under Windows Embedded Compact 7, then check out this work around.

- Nicolas

July2011 Optional Updates Are On ECE For XPe SP3, Standard 2009 and Standard 7

2011-08-11T03:06:00.000-07:00

July2011 Optional Updates Are On ECE For XPe SP3, Standard 2009 and Standard 7: "

*UPDATED 8/10/11 - Added link for Standard 7*

The July 2011 Optional Updates are now available on the ECE site for Windows® Embedded Standard 2009, Microsoft® Windows® XP Service Pack 3 and Windows Embedded Standard 7. Fixes include:

The list below applies to XP Embedded SP3 and Windows Embedded Standard 2009

KB2540135 - This update fixes the following issue

This update fixes an issue where the File Based Write Filter (FBWF) Provider might crash while getting FbwfCacheDetail instances, after seven or more files have been added to or changed in the FBWF overlay, resulting in the FbwfCacheDetail instances containing corrupted file names in the FileName property.

The list below applies to XP Embedded SP3, Windows Embedded Standard 2009 and Windows Embedded Standard 7 SP1

KB2539566 – This update fixes the following issues

The Enhanced Write Filter Provider will crash if all EWF volumes have their Overlays disabled and the user tries to subscribe to a EwfOverlayStoreConfiguration event query. Until the new EWF Provider instance is created, all other commands will fail. Expected return code in this case would be 0x80070057 = ERROR_INVALID_PARAMETER. If a crash has occurred, the return code is 0x80041004 = WBEM_E_PROVIDER_FAILURE.

The event notification threshold values in EWF are inverted.

The list below applies to Windows Embedded Standard 7 SP1 and Windows Embedded Standard 7

KB2570814 (Windows Embedded Standard 7 SP1 only)- This update fixes the following issues:

FBWFAPI by design does not allow multiple commands to be executed at the same time and it returns a clear error. The fix introduces locks in the File Based Write Filter (FBWF) Provider’s FBWFAPI calls, and all parallel requests will get served without errors returned.

The cache detail (changed or added files in the FBWF cache) file can be flushed from the cache in the timespan between FbwfCacheDetail instantiation and property data gathering, which results in property data gathering returning an unexpected error.

The event notification threshold values in FBWF are inverted.

KB2573437- This update fixes the following issue:

The runtime to be incorrectly configured as “SERVICE_DEMAND_START”. Specifically, when the “Enhanced Write Filter with HORM” package is added to an image with one or more protected volumes that are configured with default settings for “DisableDefragSvc”, the runtime should be configured to disable Auto Defragmentation service (DefragSvc), by setting the “DefragSvc” service to “SERVICE_DISABLED”.

This update also fixes the following issue for Windows Embedded Standard 7:

An issue that causes EWF to be configured on all existing volumes on the system. Specifically, when the “Enhanced Write Filter with HORM” package is added to an image with one or more protected volumes that are configured with default settings for “EWFMode”. To correctly install this update, this KB must be applied to a Distribution Share prior to building and subsequent deployment of an image. Note that this fix was incorporated into Windows Embedded Standard SP1 when it shipped.

KB2573449 - This update fixes the following issues:

Extends EWF support for storage devices that use TRIM. Without this update, TRIM commands sent by the Filesystem will bypass EWF and violate write filtering guarantees provided by EWF.

This update also fixes the following issue for Windows Embedded Standard 7:

A fatal registry corruption or BlueScreen (STOP error) can occur when EWF is enabled and “ewfmgr /all /commitanddisable” is executed followed by a reboot. Note that this fix was incorporated into Windows Embedded Standard SP1 when it shipped.

If you have questions on accessing the ECE, please email MS Mobile & Embedded Communications Feedback & Support, ECE@microsoft.com.

Thanks,

- Lynda

Technorati Tags: XPe,Embedded Standard,WES7

"

- Nicolas

Windows Embedded Compact 7 Silverlight OpenGL Rendering Plug-in for the Freescale i.MX53 QSb

2011-08-03T02:08:00.000-07:00

Windows Embedded Compact 7 Silverlight OpenGL Rendering Plug-in for the Freescale i.MX53 QSb: "

Developers who have selected the Freescale i.MX53 QSb to run nice multimedia applications with the Windows Embedded Compact 7 operating system can benefit from an optimized rendering solution.

- Nicolas

Windows Embedded Compact 7 Self Train Videos

2011-05-23T23:55:00.001-07:00

Microsoft release few days ago a set of technical videos, for self training on this technology. Covering from debugging to power management, those videos will help you to understand the internal mechanism of this operating system.

Check out the videos at : Microsoft Showcase.

- Nicolas

Freescale i.MX53 Quick Start BSP availability

2011-03-03T01:33:00.000-08:00

Adeneo Embedded, a preferred partner of Freescale Semiconductors for Windows Embedded, Linux and Android system integration on Freescale i.MX architecture, announce today the availability of 2 new reference board support packages for i.MX53 processor.
Targeting the newly released Freescale i.MX53 Quick Start development platform, Windows Embedded Compact 7 and Android reference BSPs provide extended user experience to OEMs developing advanced graphical and multimedia solutions for industrial, medical or home appliances market.
Android BSP is available for free in source code from Adeneo Embedded website. Compact7 source BSP license can be purchased for only US$500. By delivering both Android and Compact7 reference solutions for i.MX53, Adeneo Embedded expands further its collaboration with Freescale and reinforces its availability to help device makers in their developments through support, training and development services around Windows Embedded, Linux and Android technologies.

- Nicolas

Windows Embedded Compact 7 BSPs from Adeneo Embedded

2011-03-02T01:25:00.000-08:00

As mentioned yesterday the Microsoft Windows Embedded Compact 7 OS has been released and now Adeneo Embedded is releasing Windows Embedded Compact 7 BSPs for the following platforms and architectures:

Atmel AT91SAM9 architecture, covering AT91SAM9G20, AT91SAM9G45 and AT91SAM9M10 reference development kits.
Freescale i.MX architecture, with reference BSPs for i.MX28 and i.MX53, targeting Freescale i.MX28EVK and i.MX53 QuickStart platforms.
NXP LPC3250 reference development kit
Texas Instruments AM37x and DM37x with a reference BSP for the BeagleBoard-XM, based on the unified BSP architecture for TI Cortex-A8 platforms co-developed by Adeneo and Texas Instruments.

Adeneo Embedded will be releasing a complete set of reference BSPs in time with the general availability of Microsoft Windows Embedded Compact 7. Visitors attending the Embedded World tradeshow, taking place in Nuremberg from the 1-3 March, can view demonstrations of these solutions at the Microsoft Booth in hall 11-318, where Adeneo Embedded will be exhibiting.

- Nicolas

Adeneo Embedded website refreshed

2011-03-02T00:53:00.000-08:00

The Adeneo Embedded team is proud to share with you their new website, easier, cleaner. Check out the new content at http://www.adeneo-embedded.com

- Nicolas

Windows Embedded Compact MSDN

2011-03-01T08:41:00.000-08:00

All the MSDN documentation for the Windows Embedded Compact 7 operating system is available only, giving you a chance to check what's new during the download of the tool :-)

- Nicolas

Windows Embedded Compact 7 Release

2011-03-01T08:24:00.000-08:00

Here we are... Microsoft announces today the availability of the Windows Embedded Compact 7 operating system, allowing OEM to build more powerfull and connected devices. This new release integrates the support for the latest technologies like Silverlight 3.0, multitouch panels, multi core processors, and a bunch of other features.
Check out the list from the the product datasheet link.

- Nicolas

WEC 7 : First Worldwide training

2011-01-06T07:39:00.000-08:00

Adeneo Embedded will deliver Windows Embedded Compact 7 trainings based on the Microsoft official training curriculum.
The next sessions in Europe are

February 8th-11th – Paris, France
March 1st-4th – Sonderborg, Denmark
March 8th-11th – Milano, Italy
March 15th-18th – Paris, France

The next session in North America are

February 28th-March 3rd – Boston, MA
March 14th-17th – Dallas, TX
April 18th-21st – Denver, CO

Check out the Press Release for content and contacts informations.

- Nicolas

Windows Phone 7 Programming Free Ebook

2010-11-16T23:35:00.000-08:00

If you plan to start some development around Windows Phone 7 devices, I would suggest you to read this free ebook recently published :

Programming Windows Phone 7 by Charles Petzold (available here)

- Nicolas

Adeneo announces unified BSP for TI SoCs, partner awards - News - Windows for Devices

2010-11-03T12:32:00.000-07:00

Adeneo announces unified BSP for TI SoCs, partner awards - News - Windows for Devices

- Nicolas

Driver wrapper for C#

2010-11-03T10:55:00.001-07:00

From .NET Compact Framework, there is no API allowing access to the driver interfaces, as the main reason of the framework existance is to be able to run on whatever hardware an application without having to recompile it, this by the usage of the CLR (Common Language Runtime).

But developper working on embedded systems usually have to access those drivers that are specific to the platform. So in that case they need an access to the native APIs.

Identify the needs
Before getting access to the driver from C# you have to identify the APIs that have to be mapped from native to managed environment. Accessing a driver from native code is performed using the following APIs :
- CreateFile : in order to open a driver instance
- CloseHandle : to close the opened instance
- ReadFile : read data from the stream
- WriteFile : write data into the stream
- Seek : move data pointer in the stream
- DeviceIoControl : to perform driver specific actions with the usage of the CTL_CODE macro for commands IDs

Map the native API
In order to map the native API into C#, the usage of the interop services is required.
Note : you can find native API mapping from pinvoke.net (http://www.pinvoke.net/) website.

Create a driver class
We have to define the Driver class that will handle all the wrapping actions for us.


using System;
using System.Runtime.InteropServices;

namespace Adeneo_Embedded
{
   public class Driver
   {
   }
}

Map the mandatory native functions

CreateFile function


// This function creates, opens, or truncates a file, communications
// resource, disk device, or console. It returns a handle that can be
// used to access the object. It can also open and return a handle to
// a directory.
[DllImport ("coredll.dll")]
private static extern int CreateFile(
 string lpFileName,
 int dwDesiredAccess,
 int dwShareMode,
 int lpSecurityAttributes,
 int dwCreationDisposition,
 int dwFlagsAndAttributes,
 int hTemplateFile);

CloseHandle function


// This function closes an open object handle
[DllImport ("coredll.dll")]
private static extern int CloseHandle(int hObject);

ReadFile function


// This function reads data from a file, starting at the position indicated
// by the file pointer. After the read operation has been completed, the
// file pointer is adjusted by the number of bytes actually read.
[DllImport ("coredll.dll")]
private static extern int ReadFile(
 int hFile,
 byte[] lpBuffer,
 int nNumberOfBytesToRead,
 ref int lpNumberOfBytesRead,
 ref OVERLAPPED lpOverlapped);

WriteFile function


// This function writes data to a file. WriteFile starts writing data to
// the file at the position indicated by the file pointer. After the write
// operation has been completed, the file pointer is adjusted by the number
// of bytes actually written.
[DllImport ("coredll.dll")]
private static extern int WriteFile(
 int hFile,
 byte[] lpBuffer,
 int nNumberOfBytesToWrite,
 ref int lpNumberOfBytesWritten,
 ref OVERLAPPED lpOverlapped);

DeviceIoControl function


// This function sends an IOCTL directly to a specified device driver,
// causing the corresponding device to perform the specified operation.
[DllImport ("coredll.dll")]
private static extern int DeviceIoControl(
 int hFile,
 uint dwIoControlCode,
 byte[] lpInBuffer,
 uint nInBufferSize,
 byte[] lpOutBuffer,
 uint nOutBufferSize,
 ref uint lpBytesReturned,
 ref OVERLAPPED lpOverlapped);

Redefine the CTL_CODE macro
When driver developper is implementing the driver IoControls and when the application developper want to execute this command, then both should refer to the same identifier. To get a unique identifier for a driver command, the CTL_CODE macro is used.


//
// Macro definition for defining IOCTL and FSCTL function control codes.  Note
// that function codes 0-2047 are reserved for Microsoft Corporation, and
// 2048-4095 are reserved for customers.
//

public uint CTL_CODE(uint DeviceType, uint Function, uint Method, uint Access )
{
}

Redefine the constant values
CreateFile, DeviceIoControl, and CTL_CODE code is using constant that also have to be redefined in our driver class.


#region "constants"
 private const int GENERIC_READ = unchecked((int)0x80000000);
 private const int GENERIC_WRITE = 0x40000000;
 private const int OPEN_EXISTING = 3;
          private const int INVALID_HANDLE_VALUE = -1;

#region "CTL_CODE"
#region "Method"
 //
 // Define the method codes for how buffers are passed for I/O and FS controls
 //
 public const uint METHOD_BUFFERED = 0;
 public const uint METHOD_IN_DIRECT = 1;
 public const uint METHOD_OUT_DIRECT = 2;
 public const uint METHOD_NEITHER = 3;
#endregion // "Method"

#region "Access"
 //
 // Define the access check value for any access
 //
 //
 // The FILE_READ_ACCESS and FILE_WRITE_ACCESS constants are also defined in
 // ntioapi.h as FILE_READ_DATA and FILE_WRITE_DATA. The values for these
 // constants *MUST* always be in sync.
 //

 public const uint FILE_ANY_ACCESS = 0;
 public const uint FILE_READ_ACCESS = ( 0x0001 );  // file & pipe
 public const uint FILE_WRITE_ACCESS = ( 0x0002 );    // file & pipe
#endregion // "Access"

#region "DeviceType"
// begin_ntddk begin_nthal begin_ntifs
//
// Define the various device type values.  Note that values used by Microsoft
// Corporation are in the range 0-32767, and 32768-65535 are reserved for use
// by customers.
//
 public const uint FILE_DEVICE_BEEP                = 0x00000001;
 public const uint FILE_DEVICE_CD_ROM              = 0x00000002;
 public const uint FILE_DEVICE_CD_ROM_FILE_SYSTEM  = 0x00000003;
 public const uint FILE_DEVICE_CONTROLLER          = 0x00000004;
 public const uint FILE_DEVICE_DATALINK            = 0x00000005;
 public const uint FILE_DEVICE_DFS                 = 0x00000006;
 public const uint FILE_DEVICE_DISK                = 0x00000007;
 public const uint FILE_DEVICE_DISK_FILE_SYSTEM    = 0x00000008;
 public const uint FILE_DEVICE_FILE_SYSTEM         = 0x00000009;
 public const uint FILE_DEVICE_INPORT_PORT         = 0x0000000a;
 public const uint FILE_DEVICE_KEYBOARD            = 0x0000000b;
 public const uint FILE_DEVICE_MAILSLOT            = 0x0000000c;
 public const uint FILE_DEVICE_MIDI_IN             = 0x0000000d;
 public const uint FILE_DEVICE_MIDI_OUT            = 0x0000000e;
 public const uint FILE_DEVICE_MOUSE               = 0x0000000f;
 public const uint FILE_DEVICE_MULTI_UNC_PROVIDER  = 0x00000010;
 public const uint FILE_DEVICE_NAMED_PIPE          = 0x00000011;
 public const uint FILE_DEVICE_NETWORK             = 0x00000012;
 public const uint FILE_DEVICE_NETWORK_BROWSER     = 0x00000013;
 public const uint FILE_DEVICE_NETWORK_FILE_SYSTEM = 0x00000014;
 public const uint FILE_DEVICE_NULL                = 0x00000015;
 public const uint FILE_DEVICE_PARALLEL_PORT       = 0x00000016;
 public const uint FILE_DEVICE_PHYSICAL_NETCARD    = 0x00000017;
 public const uint FILE_DEVICE_PRINTER             = 0x00000018;
 public const uint FILE_DEVICE_SCANNER             = 0x00000019;
 public const uint FILE_DEVICE_SERIAL_MOUSE_PORT   = 0x0000001a;
 public const uint FILE_DEVICE_SERIAL_PORT         = 0x0000001b;
 public const uint FILE_DEVICE_SCREEN              = 0x0000001c;
 public const uint FILE_DEVICE_SOUND               = 0x0000001d;
 public const uint FILE_DEVICE_STREAMS             = 0x0000001e;
 public const uint FILE_DEVICE_TAPE                = 0x0000001f;
 public const uint FILE_DEVICE_TAPE_FILE_SYSTEM    = 0x00000020;
 public const uint FILE_DEVICE_TRANSPORT           = 0x00000021;
 public const uint FILE_DEVICE_UNKNOWN             = 0x00000022;
 public const uint FILE_DEVICE_VIDEO               = 0x00000023;
 public const uint FILE_DEVICE_VIRTUAL_DISK        = 0x00000024;
 public const uint FILE_DEVICE_WAVE_IN             = 0x00000025;
 public const uint FILE_DEVICE_WAVE_OUT            = 0x00000026;
 public const uint FILE_DEVICE_8042_PORT           = 0x00000027;
 public const uint FILE_DEVICE_NETWORK_REDIRECTOR  = 0x00000028;
 public const uint FILE_DEVICE_PARTITION           = 0x00000029;
 public const uint FILE_DEVICE_STORE               = 0x00000030;

#endregion // "DeviceType"


#endregion // "CTL_CODE"
#endregion // "constants"

Filling the empty egg
A bit of additional work is required to accomplish our task, the driver class goal is to map the driver access within C#, but also an abstraction class to deeply simplify the access to the driver and then offer a servicing class for your application.


#region "private members"
   private int mintHandle  = INVALID_HANDLE_VALUE;   // driver handle
#endregion // "private members"

#region "Constructor-Destrcutor"
public Driver()
{
}

~ Driver ()
{  
   if (mintHandle != INVALID_HANDLE_VALUE)
       Close ();
}
#endregion // Constructor-Destrcutor

#region "Open"
public bool Open(String strDriverName)
{
   if (mintHandle != INVALID_HANDLE_VALUE)
 {
       Close ();
 }
 
   mintHandle = CreateFile(strDriverName, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);

   return mintHandle != INVALID_HANDLE_VALUE;
}
#endregion          // open the driver

#region "Close"
public bool Close()
{
 bool bResult = false;
 int  iValue;
   if (mintHandle != INVALID_HANDLE_VALUE)
 {
       iValue = CloseHandle (mintHandle);
  if (iValue != 0)
  {
   bResult = true;
   mintHandle = INVALID_HANDLE_VALUE;
  }
 }
 
  return bResult;
}
#endregion          // close the driver

#region "Read"
public bool Read(byte []buffer, ref int lpBytesToRead)
{
 bool bResult = false;
   int lpNumberOfBytesRead = 0;
   int intResult = 0;
 OVERLAPPED lpOverlapped = new OVERLAPPED();

   if (mintHandle != INVALID_HANDLE_VALUE)
 {
       intResult = ReadFile(mintHandle, buffer, lpBytesToRead, ref lpNumberOfBytesRead, ref lpOverlapped);
      
       if (intResult == 0)
       {
           throw new Exception("Error reading driver");
       }
       else
       {
           lpBytesToRead = lpNumberOfBytesRead;
           bResult = true;
       }
 }
 
  return bResult;
}
#endregion          // read data from the driver

#region "Write"
public bool Write(byte []buffer, ref int lpBytesToWrite)
{
 bool bResult = false;
   int lpNumberOfBytesWrite = 0;
   int intResult = 0;
 OVERLAPPED lpOverlapped = new OVERLAPPED();

   if (mintHandle != INVALID_HANDLE_VALUE)
 {
       intResult = WriteFile(mintHandle, buffer, lpBytesToWrite, ref lpNumberOfBytesWrite, ref lpOverlapped);
      
       if (intResult == 0)
       {
           throw new Exception("Error writing driver");
       }
       else
       {
           lpBytesToWrite = lpNumberOfBytesWrite;
           bResult = true;
       }
 }
 
  return bResult;
}
#endregion          // read data from the driver

#region "IOControl"
public bool IOControl(uint IoControlCode, byte []bufferIn, uint bufferSizeIn, byte []bufferOut, ref uint lpBufferSizeOut)
{
 bool bResult = false;
   uint lpNumberOfBytesReturned = 0;
   int intResult = 0;
   OVERLAPPED lpOverlapped = new OVERLAPPED();

   if (mintHandle != INVALID_HANDLE_VALUE)
 {
    intResult = DeviceIoControl(mintHandle, IoControlCode, bufferIn, bufferSizeIn, bufferOut, lpBufferSizeOut, ref lpNumberOfBytesReturned, ref lpOverlapped);
 
       if (intResult == 0)
       {
           throw new Exception("Error IOcontrol driver");
       }
       else
       {
           lpBufferSizeOut = lpNumberOfBytesReturned;
           bResult = true;
       }
 }
 
  return bResult;
}
#endregion          // read data from the driver

This is it, now we have a class that really simplify the access to the drivers.


Driver myI2CDriver = new Driver();
myI2CDriver.Open("I2C1:");
…
myI2CDriver.Close();

- Nicolas

WEC 7 : Build Solution performing a Buid & Sysgen

2010-11-02T09:01:00.000-07:00

Using the CTP version of Windows Embedded Compact 7 available from the Microsoft Connect website (http://connect.microsoft.com), you will face a unexpected behavior of the development environment.

When building a solution using the Build menu, you will launch a Build and Sysgen (blddemo.bat) command instead of a Sysgen (blddemo -q) as it was the case in the previous version. This Build and Sysgen action is rebuilding the complete content of the $(_WINCEROOT)\Public folder, that is usually useful when you are making modification into this folder. In the case of the build of a runtime image, this step is not required and is increasing the build time.
As this action is not required, it is useful to avoid the execution of a such action. This can be done by modifying the blddemo.bat file located in $(_WINCEROOT)\PUBLIC\COMMON\OAK\MISC and adding in the first lines :

If "%1"=="" goto :EOF

- Nicolas

Automaticaly Add files to an SDK - refreshed

2010-11-02T08:26:00.000-07:00

When building an SDK using Platform Builder 6.0 (and previous), you may need to include your own files. Those files are the list of IOcontrols of drivers you implemented, or header files required to link to a new library that you want to provide in your SDK. In that case you have to include those files to your SDKs.
The first one is a manual inclusion of those files using the configuration wizard of the SDK. That’s mean that every time you generates the SDK you have to take care of those files.
The second solution is to automated this mechanism by copying those files to a specific folder that will be used automatically by the wizard during the generation of the SDK.

Identification of the sdk folder
The SDK tool uses the content of the cesysgen folder (located in your OSDesign folder), and the sdk folder located in the same folder as the cesysgen and OAK folder.$(_PROJECTROOT)\sdk or $(_PROJECTSDKROOT)
The SDK tool adds the content of the sdk\Inc and sdk\Lib folder to the SDK msi file. So you must store the files you need to provide with the SDK in those sub folders. Doing it manually is never the solution, so by asking the Windows embedded CE build environment to do it, it is more reliable. This could be done during the build of those libraries or drivers.

Add an automated task
Using the sources files you can add dependencies and enable automated task for the build engine. You could also use the postlink macro, but this is not the purpose of this article.
In the sources file add the following lines :


#------------------------------------------------------------------------------
# SDK files
#------------------------------------------------------------------------------
# Enable copy to the SDK directory
WINCETARGETFILES=$(WINCETARGETFILES) CopyFilesToSDK

# Hearder files
SDK_H_FILES=gpio_iocontrol.h driverheadertoshare.h

#Lib files       
SDK_LIB_FILES=

Any target files that you specify using WINCETARGETFILES are added to the list of dependencies that must be satisfied to generate a successful build. Also by listing the files you need for your SDK in the SDK_ FILES variable, you will generate a list actions that will be solved later in the makefile.inc.

Add an automated copy instructions
In association to the SOURCES file you must provide a makefile.inc (located in the same folder), this file is proceeded after your sources files during the build. In this file you must satisfy the dependency list, so it must contain information about the CopyFilesToSDK.
Makefile.inc content will be the following :


#
# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to include new files
# in the SDK.
#

CopyFilesToSDK:
  if not EXIST $(_PROJECTSDKROOT)\Inc mkdir $(_PROJECTSDKROOT)\Inc
   FOR  %%f IN ($(SDK_H_FILES)) DO xcopy /I /D /Q %%f $(_PROJECTSDKROOT)\Inc > nul

  if not EXIST $(_PROJECTSDKROOT)\Lib mkdir $(_PROJECTSDKROOT)\Lib\$(_CPUINDPATH)
   FOR %%f IN ($(SDK_LIB_FILES)) DO xcopy /I /D /Q $(_RELEASELIBDIR)\%%f $(_PROJECTSDKROOT)\Lib\$(_CPUINDPATH)\ > nul

The copy will be done in batch script language and executed by the build engine.
After the build of the driver or the library, you may find all your required files in the $(_PROJECTSDKROOT) folder.
In this article I described only one list of files to be proceeded, but it make sense to have two lists, one for the header files and the sdk\Inc folder and another one for the sdk\Lib folder for the libraries.

- Nicolas

How fun is Windows Embedded Standard 7

2010-10-20T22:48:00.000-07:00

The last release of Microsoft Windows Embedded Standard, is based on Windows 7 operating system, and devices will come to the market in the next days. So Microsoft is demonstrating the capabilities of this Operating System in an Home Entertainment context.

- Nicolas

Awesome video of Windows Embedded Compact 7 running on TI OMAP based platform

2010-10-19T06:10:00.000-07:00

Texas Instruments and Adeneo Embedded present during the last Computex event a PTI platform based on an OMAP 3530 processor running the next version of Microsoft Embedded operating system called Windows Embedded Compact 7.0 (WEC 7).

- Nicolas

2nd place : Phone Seven Competition

2010-10-13T06:13:00.000-07:00

Adeneo Embedded and GoProd participated to the French Windows Phone 7 competition with WinMote application. With WinMote, you start all your medias on your PC from your Windows Phone 7. With this application, we get the 2nd place of the competition !

Check the video

- Nicolas

Develop a driver easily...

2010-10-11T02:11:00.000-07:00

CEDriverWiz is a Windows Embedded CE wizard that works within the Visual Studio IDE, helps simplify the tasks needed to setup the initial subproject workspace to develop stream interface device driver for Windows CE 6.0.

Check out all the details about this nice project on CodePlex.

- Nicolas

Windows Embedded Standard 7 Compatible Applications

2010-10-03T23:32:00.000-07:00

Most applications that run on Windows 7, Windows Vista, and Windows XP will run on Windows Embedded Standard 7. Through the use of templates, we now make it easy to ensure that all of your application development projects will run on Windows Embedded Standard 7. These templates allow an application developer to indicate which components should be included in the build in order to support their application on embedded systems.

Microsoft is providing for the most used applications, templates that you can use to integrate those apps in your runtime image. Check out the list here.
- Nicolas

Windows Phone 7 App Contest

2010-09-22T06:07:00.000-07:00

For the launch of Windows Phone 7, the French Microsoft entity organize a contest for the killer app.

Check out on Developper.net facebook page, the registered application and vote for your favorite one (before Friday evening).
http://www.facebook.com/Developpeurs.net

One of my favorite is : WinMote 7 application
www.facebook.com/video/video.php?v=474533036010

- Nicolas

Windows Embedded Developer Update

2010-07-22T23:21:00.000-07:00

On June 28, 2010 Windows Embedded Developer Update for Windows Embedded Standard 7 users was made available for download. Windows Embedded Developer Update gives developers an easy method to discover, download and install updates, providing them with full control of their development environment and the confidence to know they've got the latest update.

To download Windows Embedded Developer Update please visit the Windows Embedded Download Center

For a video overview on Windows Embedded Developer Update visit The Windows Embedded News Center

For more information on how to use Windows Embedded Developer Update visit MSDN

- Nicolas

Make Image and the "Out of buffer space" error

2010-07-16T00:57:00.000-07:00

An error that you could face on is the "Out of buffer space" error occuring during the Windows CE makeimage step.

.....
CeNlsCmp: JamoSort Compose: 1120
CeNlsCmp: Default Lang Except uppercase: 52
CeNlsCmp: Default Lang Except lowercase: 32
CeNlsCmp: 0 Lang Except tables: 0
Total data: 96714
CeNlsCmp: Done. Success parsing locale file
makeimg: FATAL ERROR: Out of buffer space.
makeimg: FATAL ERROR: Out of buffer space.

BLDDEMO: EVM_3530 build complete.
.....

It just happens to me this morning, while buiding a RunTime image for a project, and even looking into the log and error files, no specific details should explain the reason why.
By looking more in details I found that the path to my reldir folder was longer than the previous projects I work on. So I moved my OSDesign to a different folder with a shorter path length. And it fix this issue.

So the make image process is waiting for a path that could not exceed a path length. In this case reduce this path length by renaming with shorter names the folder containing your OSDesign (if this one isn't located inside _WINCEROOT\OSDesigns folder)

- Nicolas

Windows Embedded Handheld revealed

2010-06-24T07:30:00.000-07:00

Microsoft just officially launch the operating system dedicated for enterprise and rugged devices. In the middle between Windows CE and Windows Phone, this new operating system offers to OEM a standardized platform to build their devices. The first company to provide such device is Motorola with its ES400.

Check out Steve Ballmer interview : http://www.microsoft.com/windowsembedded/en-us/products/handheld/overview.mspx

- Nicolas

PipeTerm for Windows Embedded CE 6.0

2010-04-26T00:06:00.000-07:00

PipeTerm is a Windows Embedded CE 6.0 PowerToy that can be used to display serial port (debug) output from a booting/running CE 6.0 operating system image being hosted in Virtual PC 2007.

Check it here.

- Nicolas

Windows Embedded CE 6.0 R3 Silverlight demo on a Freescale reference design

2010-04-22T06:29:00.000-07:00

Check out this video of Silverlight for Windows Embedded demos done by Adeneo-Embedded and running on a Freescale tablet reference design.

- Nicolas

Webcast : Silverlight for Windows Embedded CE (French)

2010-04-14T00:15:00.000-07:00

Missed the Techdays 2010 or would like to review the really interesting conference about Silverlight for Windows Embedded, you can check this out here.

- Nicolas

Create and Manage Telnet users

2010-04-09T02:46:00.000-07:00

Windows Embedded CE is provided with a Telnet server, that you can use on your target to access it from the network. This Telnet service can work in two different modes :

without authentication : anybody connecting to the Telnet have access to the target
with authentication enable : only trusted user with password have access to the target

Enable Telnet Server :
In your OSDesign, select the Telnet Server component located in :
Core OS -> CEBASE -> Communication Services and Networking -> Servers -> Telnet Server

Disable authentication :
Simply add the following lines to your project.reg to disable service authentication. All users then will have access to the service as no credential will be requested.

[HKEY_LOCAL_MACHINE\COMM\TELNETD]
 "IsEnabled"=dword:1
 "UseAuthentication"=dword:0

Enable authentication :
When enabling authentication, you have to add in addition to the Telnet server support, the NTLM component located in :
Core OS -> CEBASE -> Security -> Authentication Services (SSPI) -> NTLM
And you also have to add in registry the list of users that will have access to the service. Users can be classified by groups of users (check MSDN for details).

[HKEY_LOCAL_MACHINE\COMM\TELNETD]
 "IsEnabled"=dword:1
 "UseAuthentication"=dword:1
 "UserList"="Bob"

In the sample above, we are adding user named Bob, and only this user will have access to the telnet service.

Set and Change user password :
By default there is no default password for the different users defined on the system, and the password is ciphered and stored in the registry. This password cannot be set at Runtime image build time, and is usually set on first system boot. The sample code below set the password for user Bob.

#include "ntlmssp.h"

#define DEFAULT_USER        L"Bob"
#define DEFAULT_NEW_PASS    L"password"
...
 BOOL bRet = NTLMSetUserInfo(DEFAULT_USER, DEFAULT_NEW_PASS);

 if (bRet == FALSE)
     RETAILMSG(1, (L"Failed to set user info"));
 else
     RETAILMSG(1, (L"User info updated"));
...

- Nicolas

Microsoft Certification Contest in France

2010-04-07T05:07:00.000-07:00

Microsoft is launching a contest around its Certifications, you can win a 5 days trip to the Tech*Ed taking place June 8th in New Orleans, Louisiana. And get a second chance for Free.

The How To of the Microsoft Certifications is here.

- Nicolas

Enable RamDisk, and Mass Storage under Windows CE [Updates]

2010-04-06T07:41:00.001-07:00

A Ram Disk is a storage disk located in RAM of your device, meaning its content isn't persistent between system boot. The RamDisk usually used for storing temporary content like software updates source binaries.

Reserve Memory space on target :
The Ram disk will be located at a customizable memory address and size on the device, and will be mounted on your root file system as any other file system. In order to reserve the physical memory area, you have to modify the config.bib file of your BSP and add a reserved section for RAM Disk as shown as below. It make sense to map this area on a physical portion of the RAM.

MEMORY



;   Name     Start     Size      Type

;   -------  --------  --------  ----

BLDR     80000000  00058000  RESERVED

DRVGLOB  80058000  00001000  RESERVED

EMACBUF  80059000  0000E000  RESERVED

NK       80067000  01000000  RAMIMAGE

RAM      81067000  02BA7000  RAM      ; 43.65 MB

RAMDISK  83C0E000  00300000  RESERVED ;  3.00 MB

In the example above, I reduced the size of RAM to have enough room for the RAMDISK section of 0x300000 (3MBytes).

Include RamDisk into OSDesign
Add the RamDisk support to your runtime image, by enabling the SYSGEN_RAMDISK variable into the OSDesign property window.

Configure RamDisk
The RamDisk driver is by default mounted by the storage manager and no configuration of the storage driver name allowed. So I prefer to make few registry modifications in my platform.reg to be able to fix the driver DSK name and index.

; HIVE BOOT SECTION

[HKEY_LOCAL_MACHINE\Drivers\BuiltIn\RamDisk]

"Dll"="ramdisk.dll"

"Prefix"="DSK"

"FriendlyName"="RAM Disk Driver"

"Order"=dword:0

"Ioctl"=dword:4

"IClass"=multi_sz:"{A4E7EDDA-E575-4252-9D6B-4195D48BB865}"

"Profile"="RAMDisk"

"Size"=dword:300000

"Address"=dword:83C0E000

"SectorSize"=dword:200

"index"=dword:9



[HKEY_LOCAL_MACHINE\System\StorageManager\AutoLoad\RAMDisk]

"DriverPath"="Drivers\\BuiltIn\\RamDisk"

"LoadFlags"=dword:1

"BootPhase"=dword:0



; END HIVE BOOT SECTION

Note that the Address and Size of the RamDisk driver definition match the values defined in the config.bib. The storage driver will then be accessible through DSK9:, and you can then easily configure a USB Function mass storage profile to point on this storage.

Configure USB Function Mass Storage
The USB Function driver loads profiles when device plugged to a host, the profile to be loaded by default is set through the registry.

[HKEY_LOCAL_MACHINE\Drivers\USB\FunctionDrivers]

"DefaultClientDriver"=- ; erase previous default

[HKEY_LOCAL_MACHINE\Drivers\USB\FunctionDrivers]

"DefaultClientDriver"="Mass_Storage_Class"



[HKEY_LOCAL_MACHINE\Drivers\USB\FunctionDrivers\Mass_Storage_Class]

"DeviceName"=- ; erase previous default

[HKEY_LOCAL_MACHINE\Drivers\USB\FunctionDrivers\Mass_Storage_Class]

"DeviceName"="DSK9:"

Note as the "DeviceName" is set to DSK9: matching the driver index described before for the RamDisk.
Note don't forget to add the USB Function driver of the BSP and set the following variables : SYSGEN_USBFN, SYSGEN_USBFN_STORAGE

To go further :
- RamDisk can be used in association to the ROM Only mechanism to reduce write access to the physical storage.
- RamDisk and USB Function, this to provide a way to drop files on your target using USB mass storage profile.

Special thanks to Juanito for the hints

[Updated on 08-22-2011] : fixed a platform configuration file name.

- Nicolas

Windows Mobile 6.5.3 Developer Tool Kit

2010-02-19T02:21:00.000-08:00

After a first try few weeks ago, Microsoft finally release the Windows Mobile 6.5.3 Developer Tool Kit. This update version provides access to the gesture API for your applications.

Get this update from Microsoft website.

- Nicolas

Adeneo at Embedded World

2010-02-19T02:06:00.000-08:00

Adeneo Embedded will be at the Embedded World Exhibition in Nürnberg, Germany on March 2 - 4, 2010. As a Windows Embedded Gold Partner, we will share the Microsoft Windows Embedded booth (Hall 11 / Booth 318). Leverage this event to meet with us and talk about your projects based on Windows Embedded and/or Windows Mobile technologies. More information about the event: http://www.embedded-world.de/en/

- Nicolas

Adeneo First Training in Israel

2010-01-22T06:27:00.000-08:00

Adeneo Embedded, as a leading Windows Embedded Gold partner is working in collaboration with Arrow, Atmel for delivering a series of Windows Embedded CE 6.0 R3 workshop.

Please join us in Israel on Feb 24th 2010 to learn about newest version of Windows Embedded CE 6.0 R3, and how Arrow, Atmel and Adeneo Embedded can help you with your next Windows Embedded development.
Link to the invitation you can use for the registration. For further details or questions, please contact sales@adeneo-embedded.com

- Nicolas

Meet me on Feb 8th at Techdays 2010 (Paris)

2010-01-15T01:10:00.000-08:00

During the French Techdays event taking place in Paris from Feb. 8th to 10th, you will be able to meet some MVP for Windows Embedded. So come to the Windows Embedded booth to meet me in person.

During this event I will also do a presentation of the Silverlight Embedded feature of Windows Embedded CE 6.0 R3 , scheduled on Feb. 8th at 1:30 PM. Focussing on the development of Silverlight applications for Windows Embedded CE this talk will demonstrate cool applications illustration the capabilities of the language.

Microsoft France organise during this event, the first application development contest for students using Visual Studio tools and Windows Embedded platforms, to be showcased at TechDays Paris, an event which attracts 16,000 developers.
You will have the chance to exchange with us on your application.

Check-out this web page for more ( in French obviously !! )

To register for this event check this.

- Nicolas

.NET Micro Framework 4.0 for Blackfin BF518F FMC

2009-11-22T23:56:00.000-08:00

Avnet just released a new development kit based on Analog Devices BF518F that incorporates a .NET MicroFramework 4.0 port developed by Adeneo Embedded.
Adeneo Embedded, which is engaged in .NET MicroFramework development since 2006 was selected by Analog Devices and Avnet for the development of the reference port, but also as a long term partner for supporting OEMs willing to use this development kit to jumpstart the design of their embedded device based on .NET Micro Framework.
With more than 10 years of experience in development with Microsoft Embedded technologies, Adeneo Embedded is one of the Worldwide leading System Integrator helping OEMs securing their design with Windows Embedded, Windows Mobile or .NET Micro Framework technologies. With this new strategic long term partnership with Analog Devices and Avnet, and as one of the first company worldwide providing to the market a .NET Micro Framework 4.0 port.

For more information about the Avnet BF518F FMC dev.kit, please check Avnet dedicated page, or look at the following video.

For support or help with the development of .NET MicroFramework based product, please contact our sales team: sales@adeneo-embedded.com

-Nicolas

Mobile Marketplace opens for 6.0 and 6.1

2009-11-17T07:46:00.000-08:00

Microsoft finally opens its Market place for Windows Mobile applications to the 6.X mobile devices family.

http://marketplace.windowsphone.com/Default.aspx
- Nicolas

Industrial Automation with Windows Embedded

2009-11-05T05:38:00.000-08:00

With a single platform, one development environment, and real-time everywhere, Windows Embedded offers a reliable, flexible, connected, and cost-efficient foundation for industrial automation Learn during this presentation how the various Windows® Embedded operating systems can be used by OEMs to create industrial embedded devices. We will help you identify the key challenges for an Industrial Automation project and learn about available solutions, from the market trends, total cost of ownership and technical standpoints.

Online Webinars :

French : November 17th 2009 10:00AM - 11:00AM (register)
English : February 19th 2010 9:00AM - 11:00AM GMT (register)

Roadshow :

Columbus, OH : October 21, 2009 8:00AM – 1:00PM (register)
Boston, MA : October 27, 2009 8:00AM – 1:00PM (register)
Mountain View, CA : November 12, 2009 8:00AM – 1:00PM (register)
Houston, TX : November 18, 2009 8:00AM – 1:00PM (register)
Paris, France : December 16, 2009 9:00AM - 3:00PM (register)

- Nicolas

Microsoft AppFab 2009 contest

2009-11-03T06:13:00.000-08:00

Microsoft Market Place is now open, and Microsoft wants to help developers to publish their applications in this store.
The French Microsoft entity organized a contest for developers, ending by November 31th 2009. Lots of prizes to win so check out the details at https://www.appfab09.fr/

- Nicolas

USB Function profile switcher

2009-11-02T05:51:00.000-08:00

The USB Function driver under Windows CE and Windows Mobile, allows user to change on the fly the loaded profile. It can be used as a Serial or a Mass storage device. The Serial profile (or NDIS on some Windows Mobile devices) is used to do data synchronization through ActiveSync. The Mass storage on its side allows the user to see the device internal storage as a standard USB storage device, from the host device.
To switch between the two modes, some Windows Mobile device manufacturer provides application, usually located in the Settings/Connections panel. But for Windows CE user it have to be implemented.

By calling a specific IoControl of the USB Function driver, you can tell it to load a different profile. The available profiles are listed in the registry in [HKEY_LOCAL_MACHINE\Drivers\USB\FunctionDrivers] and the current active profile is specified in the DefaultClientDriver value in this registry node.


void SwitchUSBFunctionProfile(BOOL bEnableActiveSync)
{
 HANDLE hUSBFn;
 UFN_CLIENT_INFO info;
 DWORD dwBytes;

 // Open the USB function driver
 hUSBFn = CreateFile(USB_FUN_DEV, DEVACCESS_BUSNAMESPACE,
          0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
          NULL);

 if(bEnableActiveSync)
 {
  // Enable USB Function profile for activesync
  swprintf(info.szName, _T("Serial_Class"));
  DeviceIoControl(hUSBFn, IOCTL_UFN_CHANGE_CURRENT_CLIENT,
    info.szName, sizeof(info.szName), NULL, 0, &dwBytes, NULL))
 }
 else
 {
  // Enable USB Function for mass-storage
  swprintf(info.szName, _T("Mass_Storage_Class"));
  DeviceIoControl(hUSBFn, IOCTL_UFN_CHANGE_CURRENT_CLIENT,
    info.szName, sizeof(info.szName), NULL, 0, &dwBytes, NULL);
 }
}

The defines values are located in %_WINCEROOT%\PUBLIC\COMMON\OAK\INC\usbfnioctl.h
- Nicolas

Get an USB Flash key booting DOS

2009-10-26T03:24:00.000-07:00

While using Windows Embedded CE or Windows Embedded Standard, you need to boot your device under DOS, in order to format, create partition on the storage, or to use loadcepc to launch your runtime image. Nowadays, floppy disk readers are vintage hardware that you probably don't have anymore, and more over Floppy disk are covered of dust and you are afraid to use them. In this case you have to boot your device using a USB Flash disk, thanks to the fact that most of the actual BIOS do support them.

Tools
- HP USB Disk Storage Format Tool (http://hp-usb-disk-storage-format-tool.software.informer.com/)
- Winimage (http://www.winimage.com/download.htm)
- DOS floppy disk image (get from Windows Embedded CE 6 CEPC BSP)
%_WINCEROOT%\PLATFORM\CEPC\SRC\BOOTLOADER\DOS\BOOTDISK\DISKIMAGE\cepcboot.144

Extract the DOS image
For the first step we have to extract from the cepcboot.144 floppy disk image, the files for DOS. Using Winimage, open the image file, select all the files and go the Image->Extract. Enter c:\Temp\FloppyContent as a folder for the extracted files, and select "Extract with pathname" option.

Format the USB Flash disk
Plug the USB disk and wait for USB device availability notification.
Using the HP USB Disk tool, select the USB device in the list box, use FAT as File System, Select Create a DOS startup disk, choose "using DOS system files located at", and choose the folder used in winimage for the extraction.

Hit Start and voila your device is ready to boot dos. Then you can add the tools you need to prepare the device to boot...

Note
I have identified some USB devices that, are not compatible, cannot be used for booting x86 devices, but did not find the link between them.
This tutorial should also work with Compact Flash devices and SDCard (miniSD, microSD) devices.

Thanks to Eric for his help.
-Nicolas

Network Projector demonstration

2009-10-26T00:40:00.000-07:00

Joe Broxson, from Adeneo Embedded, is demonstrating the network projector feature of Windows Embedded CE on OMAP3530 based Gumstix Overo device.
Check out the video at http://www.youtube.com/watch?v=y3c5TZVSFzY
- Nicolas

Trick my Windows Mobile device [Part 1]

2009-10-13T08:27:00.001-07:00

Change the startup splash screen :

Get bored by the Windows Mobile splash screen display at you Windows Mobile device startup ... here is the solution to customize it. Just pick up you favorite picture, adjuste it to your Windows Mobile device screen resolution, and save it to a png file (mywelcomehead.png).

Then copy it to the Windows folder on your device and then adjust the following keys in the registry :

[HKLM\Software\Microsoft\Splash Screen]
"CarrierBitmap"="\windows\mywelcomehead.png"
"MSBitmap"="\windows\mywelcomehead.png"

And that's it, restart your device and the nice picture shows up :-)

More for HTC users :
For HTC, you can also change the startup animation, by provisioning on your device and in the registry an animated gif file, just set the following registry key.
Sample below for an animated gif named myanimation.gif and located in \Windows\

[HKLM\Software\HTC\HTCAnimation]
"StartupGif"="\Windows\myanimation.gif"

WARNING : As usual, use this information at your own risk.

- Nicolas

Post Mortem Debug of Windows Mobile with Visual Studio 2005

2009-10-13T06:14:00.000-07:00

We saw on the previous post on Post Mortem debugging, the way to open KDMP files with WinDbg. But those system dump files can also be loaded using Visual Studio 2005 (and higher).

First step : Configure your device
Just follow the instructions in the previous post for the configuration of you Windows Mobile device (registry configuration to specify the location of the kdmp files).

Second step : Locate and copy the kdmp files
Locate the kdmp files on your device and copy it to your Development machine.

Third step : Open the kdmp file and run debugger
From VS2005, go to File -> open project/solution, and select the kdmp file.

Then go to Debug -> Start menu or hit F5 key, this will launch the debugger locally. The exception is then catch, and the assembly source code is shown.

At this time, the debugger is not able to make the link between the binary and the source code, as the symbols are not set. For this show the modules by going in Debug -> Windows -> Modules menu (screen must looks like the screen shot above). Select the module on which the exception occurs in our case it MemException.exe, right click on it and select the "Load Symbols" popup menu.
Provide the path to the pdb files and TAADAAA the source code is displayed.

Have a good debugging then...

- Nicolas

Post Mortem Debug under Windows Mobile with WinDbg

2009-10-13T05:08:00.001-07:00

Under Windows Mobile, DrWatson is watching you (... in fact your applications) and identify while they crashe. This is only visible when exceptions occurs, showing memory error reports. At this time a memory dump of the stack and process context is done and stored in a KDMP file located by default in \Windows\System\DumpFiles. This type of files can be then loaded inside the WinDbg application used for desktop application debugging.

Required Tools :
Before starting any debugging you need to get the following tools :
- WinDbg from Microsoft available here (Install Debugging Tools for Windows 32-bit Version).
- Remote Registry Editor provided with Visual Studio 2005.

Sample Application :

An easy way to get memory exceptions, is by accessing unreferenced pointer, we do illustrate the next step of this article with the very simple application code below.


// MemException application
//

#include "stdafx.h"
#include <windows.h>
#include <commctrl.h>

void PrintHello ()
{
OutputDebugString(L"Hello World");
}

void GenerateNullPointerException ()
{
BYTE *pByte = NULL;
*pByte = 0xFF;
}

int _tmain(int argc, _TCHAR* argv[])
{
PrintHello ();
GenerateNullPointerException();

return 0;
}

First Step : Locate the kdump files

By default the kdump files are located in \Windows\System\DumpFiles folders and are deleted after the error reporting dialog box is closed. So to get those files, you have to copy them while the dialog box is displayed, but unfortunately those files are in readonly mode.
Using the registry you can change the file location folder for the kdump files.

[HKEY_LOCAL_MACHINE\System\ErrorReporting\DumpSettings]
"DumpDirectory"="\Temp\DumFiles" (string entry)
"DumpEnabled"=dword:1 (dword entry)

Second step : Copy the kdump files

While dump files are move to \Temp\Dumpfiles, as shown in the example above, files are not accessed as read only and can then by copy to your desktop hard drive, through active sync.
Note : Don't close the warning message box, before doing the copy as DrWatson is removing the files right after.

Third Step : Open the kdump files

The kdump files are generated by Dr Watson, and can be interpreted by WinDbg, usually used for Windows Desktop debugging.
Launch the WinDbg application and get to File -> Open Crash Dump menu.
Select the kdmp file retrieve from your device.

Then in the command line area of Windbg, launch the command :
!analyze -v

If you look carefully to the output, you will see that the symbols are not loaded, as we did not configure the path to the pdb files (debug information files) of our binary ("Symbols can not be loaded because symbol path is not initialized."). So we have to provide the path to the PDB files, by going to File -> Symbol File Path menu and by adding the path to our pdb files. The PDB files are always located in the build folder, where the .exe or .dll file is generated. DO NOT FORGET to check the reload option located on the bottom left of the Symbol Search Path window. And then validate.

At this time, WinDbg is able to locate the line of code in the application where the exception occurs. When you just have the pdb file but not the source files, WinDbg will not shows up any source code, but will give you the exact location in the source code.

FOLLOWUP_IP:
MemException!GenerateNullPointerException+14 [d:\nbesson\projects\vs2005\memexception\memexception\memexception.cpp @ 16]
00011028 0030c2e5 strb r3, [r2]

Known Issues with symbols
Sometimes, WinDbg is unable to find the debug files to locate the source code during the analyze of the dump file. In this case you have to make sure that files hasn't been renamed during copy on the device.
Use the following command to get the link to the source code :
- .sympath : to check the symboles folder, if missing folder go to "File->Symbol File Path" or hit Ctrl+S, add the folder and do not forget to reload
- .reload : to reload symbols
- !sym noisy : to enable verbosity on symbol files access
and finaly if after all those steps the symbol files is not loaded, use the .reload /f <binary file name> to force the symbols loading for this specific binary.

Now enjoy debugging !

-Nicolas

Windows Mobile Network Analyzer PowerToy

2009-10-12T00:38:00.001-07:00

Checking network capabilities and configuration of a Windows Mobile device is always tricky. You are used to do it under Windows, but same tools are not user friendly on a touch device.

This week end, I had to check the network capabilities of my Windows Mobile 6.1 device, to get the Bluetooth PANU working. I found the Windows Mobile Network Analyzer PowerToy from Microsoft website. This application check the Ip Configuration and the ping feature on the device like ipconfig and ping. A complete Log file is generated, providing the details on the network configuration.

This tool save my Sunday :-)

- Nicolas

Comparison between Windows Embedded Standard 2009 and Windows Embedded Standard 2011 - Windows For Devices Articles - Windows for Devices

2009-10-08T08:19:00.001-07:00

Comparison between Windows Embedded Standard 2009 and Windows Embedded Standard 2011 - Windows For Devices Articles - Windows for Devices

Shared via AddThis

Windows Embedded CE 6.0 R3

2009-09-23T00:17:00.000-07:00

Microsoft announced at ESC East (Boston), that Windows Embedded CE 6.0 R3, an upgrade of the R2, will be publicly available on 10/2009.
One of the major improvement is the support of Silverlight to help developers to improve their user interfaces and then user experiences. Also in top of that, the gesture support has been added for the pleasure of the users.

All information and get ready for Windows Embedded CE 6.0 R3 on Microsoft website.
- Nicolas

Coming training sessions

2009-09-08T23:51:00.000-07:00

Adeneo published the list of their next worldwide training sessions.

Windows CE:

Dallas,TX on Sept. 28th to Oct. 1st with a FREE Freescale i.MX25 view
Munich, Germany on Oct. 5th to Oct. 8th with a FREE TI OMAP35xx view
Boston, MA on Oct. 19th to Oct. 22nd with a FREE TI OMAP35xx view
Milano, Italy MA on Oct. 19th to Oct. 22nd with a FREE Atmel AT91SAM9263 view

Linux:

Paris, France on Sept. 28th to Oct. 1st with a FREE Freescale i.MX27 view

- Nicolas

Windows Embedded Standard 2011 (“Quebec”) CTP Available Now!

2009-09-08T23:50:00.000-07:00

Article from Windows Embedded Standard blog by Shayna :

Have you been itching to get more information about what is coming next from the Windows Embedded Standard team? Well now is your chance! Earlier today we announced the release of a Community Technology Preview (CTP) for Windows Embedded Standard 2011 (this is the official product name of our next release that was code named “Quebec”).

To download the CTP simply go to http://connect.microsoft.com/windowsembedded and sign in with your Windows Live ID. If you haven’t previously participated in one of our CTPs, you will need to add the “Windows Embedded Standard” program to your Connection Directory. As you are playing around with the product please submit your bugs and suggestions using the Feedback forms on Connect, and you can chat with the rest of the community and members of our team on the MSDN forums specifically set up for Windows Embedded Standard 2011!

Unleash the power of Windows 7 technologies in Windows Embedded Standard 2011 using a solid platform that fits into existing customer infrastructure. To quote Kevin Dallas, general manager of Windows Embedded this “CTP empowers our worldwide ecosystem of OEMs, partners and developers to take advantage of the next generation platform’s enhanced Windows 7-based features and provide feedback, prior to its general release to manufacturing. We encourage the embedded community to take full advantage of the CTP’s availability and join in our excitement as we look ahead to the future availability of Windows Embedded platforms incorporating Windows 7 technologies.”

You’ll see lots more blog posts in the coming weeks covering various feature areas of Windows Embedded Standard 2011 – so stay tuned!

- Nicolas

Windows Embedded CE self pace training

2009-08-17T23:51:00.000-07:00

Joe Broxon from Adeneo Corporation release few months from now a self pace training on Windows Embedded CE 6.0. This video has been realized during a training done at Microsoft.

Building Solutions with Windows Embedded CE 6.0 R2

- Nicolas

Windows Embedded web cast and videos

2009-08-17T23:46:00.000-07:00

Joe Broxon from Adeneo Corporation just release new web casts on the Windows Embedded Standard technology.
The first three are webcasts, they are all 100 level, but are a good explanation of some of the other embedded technologies from Microsoft besides Windows Embedded CE. Here are the links:

- Nicolas

WES 2009 Installation Error

2009-08-07T01:56:00.001-07:00

While installing Windows Embedded Standard 2009 you probably already experienced different errors.

Error 1:
An error occurs, but no details are provided, and the system revert the complete installation of the tools. In this case it means probably that the WES Iso access run into time out, really plausible while installing the tools through a network share. In this case, burn the DVD and restart installation.
Error 2:
After the tools installed, the installer is updating the content of the component repository. The repository is always located here \\device name\Repositories (where device name is the name of the host computer). This folder is a shared folder on the system and depending on the security settings on your computer this share can potentially write protected by default. For this reason installation tool is no capable to copy the files to the folder and you will have the following error message.
To Fix this, simply change the share properties and it the retry button.

Hope this will helps you to install the tools :-)
- Nicolas

WES and WinPE scripting

2009-08-07T01:39:00.001-07:00

Every time you use Windows Embedded Standard, you have to prepare the target hard drive to make it bootable and ready to receive the new generated WES image. In this case I'm using a customized WinPE 2.0 iso to boot the target device (tool retrieve from the Windows Automated Installation KIT or AIK).

Prepare Hard drive scripts :

diskpart.script : this script will remove the existing partitions of the drive 0, and create a new one of 800 MB (in my case to leave empty space for the EWF feature)

list disk
select disk 0
clean
create partition primary size=800
select part 1
assign letter=C
format fs=ntfs quick
active
list part
exit

prepdisk.bar : this script launch diskpart with the upper script in parameter, followed by bootsec to store the Windows XP boot sector.

@echo off
echo ---------------------------------------------------------
echo !!!!!!!!!!!!!!!!! READ THIS CAREFULLY !!!!!!!!!!!!!!!!!!!
echo.
echo You are ready to erase the content of your hardrive
echo.
echo Do you want to continue - Press Ctrl + C to quit
echo ---------------------------------------------------------
pause
echo ---------------------------------------------------------
echo Are you really sure ?
echo.
echo Continue or Quit now by pressing Ctrl + C
echo ---------------------------------------------------------
pause
diskpart /s .\diskpart.script
bootsect /nt52 c:
echo ---------------------------------------------------------
echo               ==== Disk Ready for WinPE ====
echo ---------------------------------------------------------

- Nicolas

SDK, DTK, DRK: WTF?!

2009-07-22T05:08:00.000-07:00

Don't know the meaning .. check this out here

- Nicolas

Change the Screen Rotation in your application

2009-07-02T01:58:00.000-07:00

Windows Mobile devices allows user to rotate the screen orientation, on some devices, this rotation is automatically done while sliding keyboard is opened to provide the good orientation to user to get a chance to type text using the hardware keyboard. More advanced devices get an accelerometer and can automatically rotate the screen while the user physically rotate the device from portrait to landscape and vice versa.
Windows Embedded CE devices on their side can also have screen rotation enabled, but as they are usually for industrial purposes, this feature is not necessarily enabled.

On both version, when user have to do screen rotation the ChangeDisplaySettingsEx function is used. The sample code below shows up the steps to perform screen rotation.

 
BOOL RotateScreen(int iRotationAngle)
{
  int iAngle;

  // Check if rotation angle is a multiple of 90 degres
  if ((iRotationAngle % 90) != 0)
  {
    return FALSE;
  }
        
  // Screen rotation is a bit field value
  // 0 = 0, 1 = 90, 2 = 180, 4 = 270
  iAngle = iRotationAngle / 90;
  if( iAngle == 3 )
    iAngle = 0x4;

  //
  DEVMODE devMode;
  memset (&devMode, 0, sizeof (devMode));
  devMode.dmSize = sizeof (devMode);
  devMode.dmFields = DM_DISPLAYQUERYORIENTATION;

  // Retrieve the supported screen rotation angles
  if (DISP_CHANGE_SUCCESSFUL != ChangeDisplaySettingsEx(NULL, &devMode, NULL, CDS_TEST, NULL))
  {
    return FALSE;
  }

  // Check if required screen rotation is supported
  if (iAngle == 0 || iAngle & devMode.dmDisplayOrientation)
  {
    memset(&devMode, 0, sizeof (devMode));
    devMode.dmSize               = sizeof (devMode);
    devMode.dmFields             = DM_DISPLAYORIENTATION;
    devMode.dmDisplayOrientation = iAngle;
   
    if (DISP_CHANGE_SUCCESSFUL != ChangeDisplaySettingsEx(NULL, &devMode, NULL, CDS_RESET, NULL))
    {
       return FALSE;         
    }
    else return TRUE;
  }

  return FALSE;
}

Thanks to Alban for his help.

- Nicolas

State and Notifications Broker API

2009-07-02T01:03:00.000-07:00

The State and Notification Broker API provide an easy way to get notified while system state changed or registry content changed. This API is available for both Windows Embedded and Windows Mobile operating systems, and works with a provider and client.

The Provider:
The provider create in registry one entry per state managed, and is in charge of the update of those entries when states changed. Usually system states are defined in HKEY_CURRENT_USER\System\State and HKEY_LOCAL_MACHINE\System\State, and user defined (or applicative) states are located in HKEY_CURRENT_USER\Software\State and HKEY_LOCAL_MACHINE\Software\State. The snapi.h header file defines most of the system states notifications for various system functionalities like Phone, Mails, SMS Appointment, Battery, Screen Rotation ... and custom entries should be managed by your own.

The Client:
The client register to a state defined in registry by the Provider, and get notified by the operating system while value changed. Different notifications mechanism can be used :

Application activation : can start a client application while registry content changed (or state changed)
Message Queue : signal a state notification through a Message Queue
Window message : signal a state notification via a Windows Message loop (WindowProc)
Callback : signal a state notification using a call back function

The client should register for state notification using one of the following function depending on the type of notification required (RegistryNotifyApp, RegistryNotifyWindow, RegistryNotifyCallback or RegistryNotifyMsgQueue). When state change notification is received the client should read the value using the regular regsitry functions access, or RegistryGetDWORD or RegistryGetString. While notification is no longer required, the client have to call RegistryCloseNotification to close the notification.

No specific action is required by the provider except to update the registry values while internal application transition should generate external state notifications.

You can find a usage sample in the Windows Mobile SDK sample source code of the Battery Statistic :
%ProgramFiles%\Windows Mobile 6 SDK\Samples\PocketPC\CPP\win32\battstat

- Nicolas

Windows Mobile Local Authentication PlugIn

2009-06-16T01:16:00.000-07:00

The Local Authentication Plugin (LAP) is a way to identify the user of a mobile phone, while applications need special rights to access features or perform actions. Basically user is prompted for authentication through a password that he previously configure on his mobile. The default LAP provided by Microsoft (see below), is a single PIN password, but you can implement your own if you need.

LAP Implementation
A LAP is a signed DLL share the following entry points :

InitLAP : Call by the system to initialise the LAP while loaded.
DeinitLAP : Call while LAP is unloaded
VerifyUserStart : Call to start the GUI of the LAP
VerifyUser : Call to validate the user, with or without a GUI. This functions returns while the user has been authenticated successfully or fails. Multiple calls to this function can be done by the system. Options parameter specifies how the user have to be validated.

VU_NO_UI : while the system needs to validate the user, without displaying a window to the user.

VerifyUserStop : Call to destroy the GUI and clean up.
VerifyUserToTop : Call to bring to top the LAP Window.
LAPCreateEnrollmentConfigDialog : Used to display configuration window to configure the pass-phrase of the LAP

To implement your own LAP you can start from scratch or use the sample LAP provided with the Windows Mobile SDK :

for pocket PC : %ProgramFiles%\Windows Mobile 6 SDK\Samples\PocketPC\CPP\win32\LAP
for smart phone : %ProgramFiles%\Windows Mobile 6 SDK\Samples\Smartphone\CPP\win32\LAP

LAP Installation
The Local Authentication Subsystem (LASS) is in charge of the management of the LAP display and user validation.
To define a new LAP, add a new key in the registry :

[HKEY_LOCAL_MACHINE\Comm\Security\LASSD\LAP\myLAP]
"Dll"="myLAPDll.dll"

To select the current active LAP set the

[HKEY_LOCAL_MACHINE\Comm\Security\LASSD\LAP]
"ActiveLap"="myLAP"

LAP Configuration

The LAP Configuration should be done by the user through the Enrollment window accessible form the Parameter Menu using the Lock icon. In this window the user should be able to change its pass-phrase (or other if the LAP is not based on pass-phrase authentication).
For security reason this pass-phrase should not be saved in the registry as a clear string, but should be encrypted using a custom algorithm or the Windows MobileCryptoAPI.

Validate a User in your application

To check if user has been authenticated on the device you have two possibilities :

ValidateUser is a blocking call to the LASS service, and give a way to provide parameters to the LAP, like an AE Key (specific security policy id), options (like VU_NO_UI to check the user without prompting any Window). Functions will return only after user authentication.

APP A;
HWND hMyWindow;

VerifyAndCallSecureFunction()
{
  DWORD LastError;
  GUID AEKeyForFoo = ...;
  if (VerifyUser(&AEKeyForFoo,"App A",hMyWindow,
           VU_UNTIL_SUCCESS,0)) // Call into LASS; 
                                // This will 
    CallSecureFunction() // call into active LAP 
                         // and show LAP-specific UI
  else
    TellUserVerificationFailed(GetLastError())); 
                         // display your own UI
}

SHDeviceLockAndPrompt is a non blocking call, but will require user authentication for any activity on the device.

- Nicolas

CERegEditor : an alternative to Remote Registry Editor

2009-06-09T03:01:00.000-07:00

Found a great atlternative to the Remote Registry Editor, without the requirement of the installation of a Visual Studio Smart Device component. Useful for non developper's guys...
One of my favorite feature is the registry comparison, between two snapshots.
Check out this cool application here.
- Nicolas

Easy way to componentize modules

2009-06-09T00:45:00.000-07:00

Since Windows CE 4.2, Mike Hall is maintaining a power toy application helping to componentize your applications, drivers to integrate them inside your catalog views. This application is now available under the MSDN Code Gallery.

Big thanks to Mike for this CEFileWiz application helping beginners for an easy and quick understanding of the requirements for a componentized module.
- Nicolas

Get Ready for Windows Mobile 6.5

2009-06-03T23:36:00.000-07:00

Microsoft announced last month the Windows Mobile 6.5 Release, and provide today an access to the Windows Mobile 6.5 Tool Kit to get your softwares ready for new coming mobile devices runnning this version of the operating system.

Check it out at http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=20686a1d-97a8-4f80-bc6a-ae010e085a6e

- Nicolas

WES 2009, Virtual PC and Windows PE [Updated]

2009-06-02T01:08:00.000-07:00

When experiencing Windows Embedded Standard, you need an x86 device to boot the OS. The first solution is to use a spare computer and deploy the Runtime image to the hard drive at every OS re-generation. Except if you are a skew driver fan, but mounting and unmounting the hard-drive to push the new binaries on the target, is quite painful after two or three manipulations. So another solution could be to use the current hard drive of your development computer, and reserve a partition for WES. In this case no screw driver is required, as the partition is visible directly under the OS of you development computer. The only restriction, in this case, is too reboot the development machine to get the WES OS booted. But this solution is also painful, as booting the development OS can take a while, and all development tools have to be reloaded. The ultimate solution is to use an x86 virtualizer, like Virtual PC or other. When using the virtualizer, the way to reboot the WES OS is by launching the virtualizer software.

Use a Virtual PC :

First you need to create a new virtual machine and a hard drive, you can find all the details in the Virtual PC blog.
Then you have to prepare the hard drive to receive the WES files. And for this, you have to create a partition.... and at this point you are locked, except if you have in your drawer, an old booting floppy disk and a floppy disk reader...
Microsoft is providing for IT's a Windows Automated Installation Kit, available for free from their website. This kit provides cool applications, called WinPE, and ways to easily have a booting CD-ROM iso that can be customised to integrate all the applications that can be useful to deploy an OS, like Windows XP, Vista, and WES.

Prepare your booting CD-ROM :
After downloading and installing the AIK package, launch Startup Menu->Microsoft Windows AIK->Windows PE Tools Command Prompt.

1) Initial Folder Creation
copype x86 [Destination_Folder_Path]

2) Add custom Files
Copy required custom files to the ISO folder in \ISO. Like bootsect.exe available in "Windows AIK\Tools\PETools\x86".

3) Build the customized ISO
oscdimg -n -b[path to etfsboot.com file]\efsboot.com [path to the ISO folder] [path and name of the iso to generate]

Boot the ISO :
When the iso image is generated, then you have to boot it under Virutual PC, by launching the Configuration done previously and going to the CD menu. Then attach the iso file, and Virutal PC should boot on the virutal CD-ROM drive.

Partitions creations :

When WinPE 2.0 boot up, it initialize a shell from where you can launch batch scripts or single comands. >e gonna use diskpart to create, format partition.
Launch dispart from the shell window (PERFORM ALL THOSE COMMANDS FROM THE VIRTUAL PC COMMAND WINDOW ONLY).

1) List the available disks :

list disk

2) Select the disk

select disk 0

3) Clean Up the disk
clean

4) Create a partition

create partition primary size=XXXXX

5) Assigne a letter to the partition
assign letter=C

6) Format the partition

format fs=ntfs quick

7) Activate the partition to be bootable by the Virutal PC BIOS

active

8) Exit diskpart

exit

Then you have to store the boot sector on the partition, diskpart provided with WinPE 2.0 store by default the Vista boot sector, that is not compatible with WES 2009.
9) Prepare boot sector
bootsect /NT52 C:
Note : bootsect.exe can be found in the AIK installation folder and pushed into the CD-ROM Iso

Push files to the target :
The hard drive is now ready to receive the WES runtime files, and the easy way to push those files from the development machine to the virtual hard drive is using the network and the sharing capabilities of Windows.
Share the folder used for the generation of the WES image on the development computer, and use netuse from the Virtual PC to access it.
Then use xcopy to get the files onto the virtual hard drive.

Conclusion :
Using the Virtual PC is fairly easy to get and experiment WES.

- Nicolas

Is Windows CE 6.0 R2 real time ?

2009-04-26T23:52:00.000-07:00

Who says that Windows CE 6.0 R2 is not realtime operating system!! For those who are suspicious about this fact, please have a look to this article. And check this video.

- Nicolas

Windows Embedded CE Trainings

2009-04-22T23:50:00.000-07:00

June 8^th to 11^th 2009: Paris, FR - EMEA
June 8^th to 11^th 2009: Denver, CO - US

For these sessions, Adeneo Embedded offers a 10% early bird discount for registration done at least 4 weeks before the event!
Here is the agenda:

Module 1: CE 6.0 OS features
Module 2: Platform development tools
Module 3: Inside the OS
Module 4: CE 6.0 OS Components
Module 5: CE 6.0 Build process
Module 6: Board Support Package (BSP)
Module 7: Device Driver concepts
Module 8: Customize an OS Design
Module 9: Application development
Module 10: Testing the OS

For more information and registration, contact sales@adeneo-embedded.com
For complete Windows Embedded CE 6.0 training program click here.

- Nicolas

IE8and Smart Device project issues

2009-04-14T23:57:00.000-07:00

The Visual Studio team have blogged about an issue with Visual Studio 2005/2008 after installing IE8 (Here’s a link to the blog article). You can have this issue when creating a Smart Device project in Visual Studio 2008, the fix is very simple, a change to your desktop registry.

- Nicolas

Windows Embedded Standard 2009 Exam Prep Kit Now Available

2009-03-24T13:33:00.000-07:00

The first 3 chapters of the exam preparation kit for the Windows Embedded certification are now available here. These chapters are only in English at this time, but additional languages are being developed and will be available in the next few months.

- Nicolas

Windows Embedded CE 6.0 training by Adeneo Embedded

2009-03-18T05:47:00.000-07:00

Adeneo Embedded, Windows Embedded Gold Partner, propose Windows CE 6.0 training sessions in Europe and North America with a FREE ARM based development kit offered to each attendee (value $1000).

Next sessions are
April 13th to 16th 2009: Boston, MA
April 20th to 23rd 2009: Munich, Germany
May 4th to 7th 2009: Los Angeles, CA

For these sessions, Adeneo Embedded offers a 10% early bird discount for registration done at least 4 weeks before the event !
Here is the agenda:

Module 1: CE 6.0 OS features
Module 2: Platform development tools
Module 3: Inside the OS
Module 4: CE 6.0 OS Components
Module 5: CE 6.0 Build process
Module 6: Board Support Package (BSP)
Module 7: Device Driver concepts
Module 8: Customize an OS Design
Module 9: Application development
Module 10: Testing the OS

For more information and registration, contact sales@adeneo-embedded.com
Click here for complete Windows Embedded CE 6.0 training program by Adeneo Embedded
- Nicolas

ATMEL BSPs for free

2009-03-03T12:37:00.000-08:00

This is areally exiting news, Atmel just published the source version of the Atmel AT91SAM9 ARM926EJ-S™-based embedded MPUs Board Support Package for Microsoft Windows Embedded CE 6.0 and 5.0, originaly developped by Adeneo Embedded.
This to provide an easy access to the Atmel's processors evaluation kits, and Atmel's processors.

See the Atmel Press Release about this topic.

- Nicolas

KITL ? What's that ?

2009-03-02T13:02:00.000-08:00

Always wanted to know what KITL stands for ! In this case you should have a look at this really interesting video from Kurt Kennett from Microsoft.

Windows Embedded CE: understanding KITL

- Nicolas

MCP Certification for Windows Embedded Standard

2009-03-01T12:21:00.000-08:00

Microsoft launch last week the MCP Certification for Windows Embedded Standard 2009 (next version of Windows XP Embedded).

The main topic areas are:

Windows security
Componentization
The role of packages, groups, and repository sets
Application-level development on Windows XP and Windows XP Embedded
Deployment options and methodologies
Embedded enabling features (EEFs)
Working at the hardware level
Database Manager

As usual for the Embedded MCP Exam, a preparation kit is available :

Free Preparation Kit (200 page study guide) – available starting mid-March in English, other languages through June
Languages: English, French, German, Japanese, Simplified Chinese

- Nicolas

Windows Embedded CE 6.0 R2 Training in Paris 23 to 26 Feb, 2009

2009-01-14T04:56:00.000-08:00

Paris and Rousset, France, January 14, 2009 . . .Adeneo Embedded and Atmel® Corporation (Nasdaq: ATML) announced today a Microsoft® Windows® Embedded CE 6.0 R2 training course in Paris, France from February 23 to 26, 2009. This event is a unique opportunity for software system designers to develop an application based on Windows Embedded CE, and on the industry leading AT91SAM9. The AT91SAM9 is an Embedded MPU based on the ARM926EJ-SÔ core which is rapidly becoming a platform of choice for embedded designers.

For more information about Adeneo Embedded competences, products and services, visit Adeneo Embedded Web site at http://www.adeneo-embedded.com or contact: sales@adeneo-embedded.com

For a local contact in Europe, please contact asenhaji@adeneo-embedded.com
For a local contact in America, please contact wlubow@adeneo-embedded.com

- Nicolas

Embedded Experts dedicated to the success of your design

2009-01-13T23:55:00.000-08:00

Ecully, France and Bellevue, WA, USA, January 13th, 2009. . . Adeneo and Adeneo Corporation, subsidiaries of Adetel Group successfully completed today the merging of their 32 bits embedded activity and the creation of Adeneo Embedded, a new subsidiary of AdetelGroup, entirely focused on providing support and Systems integration services to OEMs around Windows Embedded and Linux Embedded technologies

For more information about Adeneo Embedded competences, products and services, visit Adeneo Embedded Web site at http://www.adeneo-embedded.com or contact: sales@adeneo-embedded.com

For a local contact in Europe, please contact asenhaji@adeneo-embedded.com
For a local contact in America, please contact wlubow@adeneo-embedded.com

- Nicolas

TOP 25 Most Dangerous Programming Errors

2009-01-13T07:50:00.000-08:00

The NSA post this week the list of the Top most dangerous programming errors, from the SQL request to the encrypted data.....
Don't forget ... There are only 10 types of people in the world: Those who understand binary, and those who don't.

Check this out here.

- Nicolas

Req : Using Windows CE Test Kit for Unit Testing

2009-01-13T07:41:00.000-08:00

I would like to write a post about unit testing and the Windows CETK. To go deeply in this suject I would like to know your background experience with this tool or if you are using other tools for unit testing of your applications under Windows Embedded CE or Windows Mobile.

You can submit all your testimonials to nbesson.blog@gmail.com

Thanks for your help.

- Nicolas

Windows Mobile Developer Power Toys

2009-01-07T00:56:00.000-08:00

The Windows Mobile Developer Power Toys help you develop and test your Windows Mobile applications.

The Power Toys include:

Emulator ActiveSync Connection Tool - Allows Activesync to connect to your Emulator session from Visual Studio .NET 2003.
ActiveSync Remote Display - Display Pocket PC applications on your desktop or laptop without needing any device side configuration.
CECopy - Command line tool for copying files to the device currently connected to desktop ActiveSync.
Convert PPC DAT to SP XML - Command line tool for generating Smartphone CABWizSP XML docs from existing Pocket PC CAB files.
Hopper - User input stress simulator.
JShell - UI version of the Platform Builder Target Control Window.
PPC Command Shell - Command shell for the Pocket PC 2003 device.
RAPI Debug - Displays detailed information about currently running processes.
RAPI Start - Command line tool to remotely start an application on your Pocket PC from your desktop.
TypeIt - Send characters/strings to the Smartphone 2003 Emulator via ActiveSync.

- Nicolas

Debugging Windows Mobile devices

2008-11-24T07:02:00.000-08:00

Another boring notification while debugging Windows Mobile devices, is linked to the default security level of the OS. On every start of the debugger, VS2005 launch required applications on the device that are not digitally signed, so device warn you.
One solution to disable those warning messages, is to disable and change the security level. Of course this will completely remove all the security on the device... so make sure to revert your changes after debugging process to avoid any damages on your device.
On the device you have to set the following :
[HKEY_LOCAL_MACHINE\Security\Policies\Policies]
"00001001"=dword:1
"0000101a"=dword:1

- Nicolas

ActiveSync Tweak

2008-11-24T06:53:00.000-08:00

If you are like me, connecting, disconnecting, all day long, various Windows Mobile and Windows CE devices to you computer through ActiveSync, at each connection ActiveSync bother you make a partnership !
Partnership are nice while it's your personal or business device and you bring it everywhere with you to get an updated schedule and email... but while you are debugging applications, you don't want to be prompted.
ActiveSync have a "secret" registry key to always associate connected device as guest and will never prompt you anymore for any partnership.
[HKEY_LOCAL_MACHINE\Software\Microsoft\Windows CE Services]
"GuestOnly"=dword:1

Set this value on your desktop computer and then plug your devices !!!

To revert this, just set GuestOnly to 0(zero) and partner ship will be enabled.
- Nicolas

ARM European Technical Conference

2008-11-19T03:06:00.000-08:00

The ARM European Technical Conference will take place tomorrow November 20 th in Paris. It's not too late to register for the event (link).

- Nicolas

Dll Imports

2008-11-17T00:45:00.000-08:00

When you are connecting managed code to native, it is often a pain to figure out how to write the “DllImport” properly. I'm using this site CONSTANTLY when I need access to native code from C#. It allows you to search on a function name and see user contributed definitions for the DLL Import…

http://www.pinvoke.net/

(Thanks to Joe)

- Nicolas

Flash back to Windows CE .Net 4.2

2008-10-14T11:38:00.001-07:00

Last few weeks I have been involved into a customer project running Windows CE 4.2…. Woooaa a big jump in the past. I don't know if you were already involved in Windows CE at this time, but a big gap is visible between this version of Windows CE and the latest one… Thanks to Microsoft for all those improvements… Connectivity options was Configure Remote Connection… so i took me 10 minutes to find the right menu, as every thing change… But one thing that I found really surprising is the time spent to do a sysgen under Windows CE 4.2 with the most up-to-date development Platform. It took me only 10 minutes, while it was around 40 minutes on the best computer available at the release of Windows CE 4.2… oups I should say Windows CE .Net 4.2, the time when the .Net revolution starts :-).

The KITL over serial implementation give me a big headache, as at the time of Windows CE 4.2 the frames sent and received by the target where created and checked by the OAL itself before forwarding them to the upper layer of KITL… meaning that you had to know exactly the format of the frames sent and received by Platform Builder, otherwise the default KITL over serial implementation of Platform Builder was not able to communicate with the target. You can imagine that finding this information is not so easy as the MSDN documentation at this time was not so complete as it is now. But thanks to free sample BSPs, and to my favorite web search engine , I found my grale : "The definition of the KITL frames".

So as an archive for the Windows CE community here is the KITL header definition for Windows CE 4.2 : Header - Data - Trailer

typedef struct _SERIAL_PACKET_HEADER
{
UCHAR headerSignature[HEADER_SIGNATURE_BYTES];
UCHAR pktType;
UCHAR Reserved;
USHORT payloadSize;
UCHAR crcData;
UCHAR crcHdr;
} SERIAL_PACKET_HEADER;

With :

headerSignature : the signature of the header : { 'k', 'I', 'T', 'L' }
pktType : use by KITL to identify the service associated to the frame
payloadSize : packet data size, not including this header
crcData : packet data check sum (simple, 8-bit crc)
crcHdr : header data checksum (simple, 8-bit crc)

The simple 8 bits check sum algorithm :
UCHAR ComputeChecksum(PUCHAR pBuf, USHORT len)
{
USHORT s = 0;
UCHAR csum = 0;

for(s = 0; s < len; s++)
csum += *(pBuf + s);

return csum;
}

- Nicolas

FTF EMEA 2008

2008-10-01T00:31:00.000-07:00

I will present on the Microsoft booth at the Freescale FTF EMEA 2008 that will take place October 7th in Paris. If you get a chance to come, it will be a great pleasure to exchange with you about the Microsoft Embedded Technologies.
If you didn't register yet, follow this link. See you then.

- Nicolas

Exam Preparation Kit in foreign languages available for download

2008-09-17T00:57:00.000-07:00

The Exam Preparation Kit book (link) for the Microsoft Certification for Windows Embedded CE 6.0 is available for download in the following languages:

English
French
German
Simplified Chinese

Other languages will be soon available for download.

- Nicolas

Adeneo delivers Windows Embedded CE training course with FREE development kits

2008-09-17T00:11:00.000-07:00

Adeneo announced the planning for the next training session in the USA.

Seattle, WA – Sept 22nd to 26th 2008
Dallas, TX – Nov 17th to 21st 2008
Los Angeles, CA - Feb 16th to 20th 2009
Boston, MA - Apr 13th to 17th 2009
Denver, CO - Jun 8th to 12th 2009
Seattle, WA - Sept 21st to 25th 2009
Dallas, TX - Nov 16th to 20th 2009

Content: Microsoft official Windows Embedded CE 6.0 training with labs done on ARM based development kit
Cost per attendee: $2,500
Included in price:

5 days of instructor led training on Windows Embedded CE 6.0. The training is delivered by one of our Senior Windows Embedded Developers who has the highest level of technical expertise on Windows Embedded CE - Training materials (printed manuals and a CD with all training manuals and files needed to complete the different labs)
Complete ARM based development kit which attendees can keep after the training session ($975 value)

Registration and information: Please contact contact.msembedded@adeneocorp.com
- Nicolas

SQL Compact 3.5 SP1

2008-08-14T04:26:00.000-07:00

The SQL Compact 3.5 SP1 has been released few weeks ago for Windows Mobile and was accessible only as a cab file for the Windows CE platforms. Now with the July's Windows CE QFE a component has been added to the catalog to give you a chance to easily integrate this feature inside your runtime images.

CE 6.0 July Update 2008 (includes SQL Compact 3.5 SP1)
CE 5.0 July Update 2008 (includes SQL Compact 3.5 SP1)

- Nicolas

Windows CE 6.0 MCTS Exam - Companion CD

2008-08-14T04:22:00.000-07:00

I'm receiving lots of email asking me about the Windows CE 6.0 MCTS companion CD that illustrate the different labs of the MCTS exam book. Microsoft had to delayed the delivery of the CD as we get more work to do for the translation in the 6 different languages of the book.
This translation is nearly done and the release of those books will be grouped to the access to the companion CD.

- Nicolas

Registry Modifications Notifications

2008-07-31T07:05:00.000-07:00

The Windows CE registry is a good place to store applications, users settings. Those information are shared between the different processes running on the system, so content can be modified from every where.

One concrete exemple, is the backlight control panel applet that allows user to change the different timeout for switching off the screen when user inactivity is detected.So when user make changes using this applet, registry content is modified to reflect the changes. At this time, if a backlight driver exist for the platform, this driver have to update his internal timers according to the new values.

You can imagine the same mecanism between your applications and a driver, two drivers or two applications. In this case, you have to be notified when modification are done in this registry. Use the CeFindFirstRegChange,CeFindNextRegChange, CeRegGetNotificationInfo, CeRegTestSetValueWand and CeFindCloseRegChange functions for this.

- Nicolas

New Books

2008-07-30T05:14:00.000-07:00

Two new books are available for the Windows Embedded CE 6.0 operating system

Professional Microsoft Windows Embedded CE 6.0 from Samuel Phung

Windows® Embedded CE 6.0 Fundamentals from Stanislav Pavlov and Pavel Belevsky

Another FREE companion book for this technology is the Microsoft Certification for Windows Embedded CE 6.0 Exam Preparation Kit, from Nicolas Besson, Rajesh Kakde and Ray Marcilla from Adeneo.

- Nicolas

Hardware runnning Windows CE ?

2008-07-30T02:57:00.000-07:00

From the Microsoft website you can find the referenced hardwares running Windows CE.

Have a look to this list here.
- Nicolas

Search Engine for Windows CE

2008-07-30T02:41:00.000-07:00

Looking for a Windows CE API definition, but want to get only the one for this specific OS... try the Live Search engine for Windows Embedded CE 6.0.

Go there.

[Note] Thanks to Pierre for this link.
- Nicolas

An alternative solution to web browsing for Windows Mobile

2008-06-12T23:33:00.000-07:00

The Mozilla Labs has posted a video of an alternative solution to web browsing, a direct competitor to the Pocket Internet Explorer. The Firefox browser for Windows Mobile, with current project codename Fennec.

See the video here
- Nicolas

Microsoft North America Awards 2008

2008-06-12T23:28:00.000-07:00

Microsoft announced during the TechEd in Orlando, FL the list of the Windows Embedded Partner Excellence Awards for North and South America.

Awards were listed by Microsoft as follows:

Distributor -- Bsquare, "for continuing to raise the bar on providing Microsoft customers with world-class professional services and logistics capabilities for connected devices"

Independent Hardware Vendor -- Phytec, "for driving adoption of Windows Embedded CE by providing single board computers and board support packages"

Portable Navigation Device Partner -- Intrinsyc, "for the impact it has had with its strategic OEM design engagements"

Silicon Vendor -- RMI, "for its innovative work in providing highly integrated system-on-chip modules"

Systems Integrator -- Bsquare, "for its leadership role in providing a broad range of engineering services for Windows Embedded CE and Windows XP Embedded"

Training Partner -- Adeneo, "for its leadership in providing a variety of innovative training deliverables"

WEPOS (Windows Embedded for Point of Service) OEM -- NCR, "for its commitment to leading how the world connects, interacts, and transacts"

WEPOS partner -- Odyssey Software, "for delivering innovative device management solutions to key strategic retail customers"

Windows Embedded CE OEM -- Magellan, "for its commitment to creating devices"

Windows XP Embedded OEM -- HP, "for its continued leadership in the thin-client space"

- Nicolas

Windows Embedded CE book

2008-05-27T23:59:00.000-07:00

A good way to learn about Windows Embedded CE 6.0 is by reading the training book associated to the Microsoft Certification for Windows Embedded CE 6.0 Exam.
Enjoy the reading here.

- Nicolas

Who want to be an MCP II

2008-05-05T22:54:00.000-07:00

As discussed in a previous post, Microsoft launches a certification program for Windows Embedded CE 6.0. This MCP Exam is officially launched and to be ready to pass the exam, Microsoft provides a FREE Training Kit that review all the subjects covered by the test. The Training Kit is a FREE 6 Chapters electronic book available for download. For now only Chapter 1 and 3 are ready for download but others will follow in the next days.

Chapter 01: Customizing the Operating System Design

Chapter 02: Building and Deploying the Runtime Image

Chapter 03: Performing System Programming

Chapter 04: Debugging and Testing the System

Chapter 05: Customizing a Board Support Package

Chapter 06: Developing Device Drivers

The authors, Nicolas Besson, Ray Marcilla and Rajesh Kakde have a deep experience in the development of BSP, drivers and runtime images, and provide tips to improve your skill before passing this exam.

If you are not a English native reader, this book will be translated in 5 additional languages in the next weeks and will be also accessible for download for FREE.

I hope that you will enjoy reading this book as much as I had writing it.

For the exam details and download follow the link .

- Nicolas

Running Windows Mobile 6.1 on your PC

2008-04-29T06:58:00.000-07:00

Microsoft provides a way to test the last release of its operating system for Windows Mobile devices. The Windows Mobile 6.1 Runtime images provided can be loaded in a VirtualPC 2007 instance.

A good way to test the compatibility of your applications with the next release of the OS for a time to market as short as possible.
Get the WM 6.1 Images on the Device Emulator with MDM here.

Enjoy.

- Nicolas

Accessing native API from C#

2008-04-28T05:10:00.000-07:00

The .Net Compact Framework, in his CLR (Common Language Runtime), contains a fixed set of API, and when working on an embedded device running Windows Embedded CE, most of the time, the managed code developers require access to some native APIs like custom DLL provided by a third party company. In this case the required APIs cannot be directly accessed in C# by the application and developer have to use the P/Invoke mechanism for the marshalling of the data from the managed to the native environment.

[DllImport ("coredll.dll")]
private static extern int CreateFile(
string lpFileName, int dwDesiredAccess,
int dwShareMode, int lpSecurityAttributes,
int dwCreationDisposition, int dwFlagsAndAttributes,
int hTemplateFile);

The DllImport macro is used to specify to the CLR that the next function declared is located inside a native dll, coredll.dll for instance. The tricky operation when defining Marshalling operation is the way to define the native types into managed types. Because if the wrong type definition is used, the CLR is going to Marshall the data in a way that is not expected by the native functions, and can be the reason of a crash or memory leaks on the system (null pointer, bad type conversion, …).

Accessing Device Drivers from C#

You have the same issue when trying to access device drivers from a C# application as the .Net Compact Framework do not contain any classes that allow developer to load a open driver and access it. Under Windows Embedded CE, device drivers are managed by the device manager, and in any case you do not access a driver directly through its Dll. You always have to use file system API to do so. For this reason, the CreateFile, CloseHandle, WriteFile, ReadFile, SetFilePojnter and DeviceIoControl functions should be redefined in C# to specify the Marshalling of the various functions’ parameters.

[DllImport ("coredll.dll")]
private static extern int CreateFile(
string lpFileName,
int dwDesiredAccess,
int dwShareMode,
int lpSecurityAttributes,
int dwCreationDisposition,
int dwFlagsAndAttributes,
int hTemplateFile);

[DllImport ("coredll.dll")]
private static extern int CloseHandle(int hObject);

[DllImport ("coredll.dll")]
private static extern int ReadFile(
int hFile,
byte[] lpBuffer,
int nNumberOfBytesToRead,
ref int lpNumberOfBytesRead,
ref OVERLAPPED lpOverlapped);

[DllImport ("coredll.dll")]
private static extern int WriteFile(
int hFile,
byte[] lpBuffer,
int nNumberOfBytesToWrite,
ref int lpNumberOfBytesWritten,
ref OVERLAPPED lpOverlapped);

[DllImport ("coredll.dll")]
private static extern int SetFilePointer(
int hFile,
int nDistanceToMove,
ref int lpDistanceToMoveHigh,
uint nMoveMethod);

[DllImport ("coredll.dll")]
private static extern int DeviceIoControl(
int hFile,
uint dwIoControlCode,
byte[] lpInBuffer,
uint nInBufferSize,
byte[] lpOutBuffer,
uint nOutBufferSize,
ref uint lpBytesReturned,
ref OVERLAPPED lpOverlapped);

The OVERLAPPED parameter, used by ReadFile, WriteFile and DeviceIoControl, should also be re-defined as this type is unknown in C#. In native code this object is a structure of basic types and will be defined like this in C#:

private class OVERLAPPED
{
public int Internal; // Reserved for operating system use.
public int InternalHigh; // Reserved for operating system use.
public int Offset; // Specifies a file position at which to start the transfer.
public int OffsetHigh; // Specifies the high word of the byte offset at which to start the transfer.
public int hEvent; // Handle to an event set to the signaled state when the operation has been completed.
}

To have a nice way to use those different native functions, the DllImport definition should be wrapped inside a standard C# class and public function with managed types parameters can be provided to the developer.
For example the Open function published by a device driver wrapper class could be write like this :

int m_intHandle = INVALID_HANDLE_VALUE;

public bool Open(String strDriverName)
{
m_intHandle = CreateFile(strDriverName, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
return m_intHandle != INVALID_HANDLE_VALUE;
}

Avoid Memory Leaks

Unlike managed code when allocating memory in native, do not forget to explicitly destroy those objects to avoid memory leaks. Even if you are accessing the native code from a managed application, the Garbage Collector is not able to detect those memory objects and freed them for you.

- Nicolas

ESC Silicon Valley (San Jose, CA)

2008-04-17T17:46:00.000-07:00

The Embedded System Conference (ESC) runs this week at San Jose, and Kevin Dallas general manager of the Windows Embedded Business at Microsoft, helped by Nick McCarty from Adeneo, did a very cool presentation of Windows Embedded CE 6.0 R2 to a large audience.

Mike Hall, who appreciates this monkey demo, talks about it on his blog.

- Nicolas

MVP Global Summit 2008

2008-04-17T17:03:00.000-07:00

All the worldwide MVPs (Most Valuable Professional) met this week at the Microsoft Headquarter for a yearly information and feedback discussion. Most of the information provided during this week are under NDA and cannot be shared with you but the thing that I can say is that the next version of Windows CE, the version 7.0 will have a lot of new cool features for the graphical interface development, connectivity, … And the name of Windows CE 7.0 will be 'Windows Embedded Compact 2009' according to the new marketing naming scheme for the Microsoft Embedded operating systems.

This 4 days event has been closed by Steve Ballmer, who as usual, did his show and received few gift from the Canadian MVPs and an US MVP (the Simpson tie).

- Nicolas

Power Management under Windows CE [part 3/3]

2008-04-12T06:58:00.000-07:00

Applications can also interact with the power manager to change the current power state of the system or to be notified on power state transitions.

Application System Interaction

Using the Power Manager, applications can request system power state using the SetSystemPowerState. This is true for the system but applications can also interact with drivers. Imagine that a device driver is powered off after being used, this for power consumption reason, when applications requires an access to this driver, the driver must be turned on again. Using SetPowerRequirement, applications can ask drivers through the Power Manager, to switch to a specific power state. Then using ReleasePowerRequirement, the power requirement will be release and the driver will switch back to his original power state.

Request power notification

Using message queue, applications can be notified of power transition occurring on the system. When system is entering suspend, this is transparent for applications, and the only way for applications to be notified of resuming from suspend is to register to this message queue using the RequestPowerNotification function. The messages read from the message queue provide information on the status of the system.

Modify the Power Manager

The source code of the power manager is provided with Windows Embedded CE and can be located in %_WINCEROOT% \PUBLIC\COMMON\OAK\DRIVERS\PM . This gives you a chance to adapt the behavior of the Power Manager to your requirements. Most of the time, you do not have to make any modification in the code; instead use the registry to change the default behavior.

In conclusion the power management is straightforward for Windows Embedded CE when the power requirement of your device is simple, but can start to be tricky when more complicated. In any case, the system can be fully customized through the registry or for advanced usage by modifying the behavior of the Power Manager by directly modifying the source code. Applications can be notified of power transition and act if required, but it can also interact with the system to change the power state of drivers or the system. On their side device drivers can implement power management to support 5 different levels, and optimize the power consumption of your device. The Power Manager is the only one on the system to manage the power, applications and drivers always have to send request to the Power Manager that will relay the requests to the correct system component according to his internal state machine.

-Nicolas

Power Management under Windows CE [part 2/3]

2008-04-11T00:11:00.001-07:00

In the last article we saw that the Power Manager is in charge of the management of the power on a Windows CE device, and interact with the system to change the system power consumption according to the user and system activity. Each driver can support 5 different levels of power states that can be setup from the registry.

Device Drivers Interface

The Power Manager is using IoControls to communicate with the drivers, to set, get the current power state of the driver. So drivers have to implement the support of those IoControl codes if they can manage the power of the managed device. The command codes are the following:

IOCTL_POWER_CAPABILITIES: used by the Power Manager to identify the power capabilities of the device driver. This command is called once when Power Manager enumerates the device on the system.
IOCTL_POWER_GET: used to get the current power state of the device.
IOCTL_POWER_SET: used to request a power transition.
IOCTL_POWER_QUERY: used to validate that the driver will support a power transition from its current state to the specified state.

Power Manager interface for device drivers

The device drivers cannot change their power state by themselves, without notifying the power manager; otherwise the power manager is not aware of state modification and cannot optimize the power on the device. When drivers require power level modification, they should request the power manager for that by calling DevicePowerNotify from the driver. Then the power manager will use the IoControls to request user to change is power state.

Next time we will identify how the applications can request system power transition.

[Updated] : Access to part 3/3

- Nicolas

Power Management under Windows CE [part 1/3]

2008-04-10T06:41:00.000-07:00

Embedded devices are usually powered by batteries and the power have to be correctly managed to improve the device autonomy and by the way the user experience. Windows Embedded CE is provided with a Power Manager that will interact with the different drivers of the system to reduce power consumption when required.

System Power States

The OS have 4 different power states that will be the four states of the internal power manager state machine. The state transition will be linked to system conditions : user activities, system activities, application requests and timers.

The four states are :

On : in this state the device is full active and user can use all the different peripherals, and by consequence the current consumption is maximum

User Idle : this state is reach when user is not using the device after a time out, the power consumption can be reduced by, for example, decreasing the display backlight intensity and disabling peripherals.

System Idle : after application inactivity, the power manager switch to this state.

Suspend : in this state the device is consuming the less power as possible, but the device cannot be used, the processor clock is decreased (or turned in a suspend state if supported), the peripherals are usually turned off and the SDRAM is still refreshed.

The transition from On to User Idle and User Idle to Suspend is done after timers expirations, those timers value can be setup through the registry to customize your device. You can managed timers when device is powered by a battery and/or by AC, to optimize your device current consumption depending on the power source.

[HKLM\SYSTEM\CurrentControlSet\Control\Power\Timeouts]
"ACUserIdle"=dword:5 ; in seconds

This will set a timeout of 5 seconds to enter the User Idle state when the device is powered by AC. The status of the power source is not identified by the Power Manager, itself, it will require the development of a battery driver. The battery driver will provide power source transition notifications to the power manager.

Drivers Power States

On the system drivers can support 5 different levels of power according to the peripheral capabilities:

D0 : Full on, the peripheral is fully functional

D1 : Low On, fully functional the device consumption is reduce comparing to D0 state

D2 : Standby, device is partially powered, and able to wake up on request

D3 : Sleep, the device is consuming as less power as possible and can be used to wake up the system

D4 : Off, the device is off an do no consume any power

Each state is optional and a driver can support only few of them. The power manager will request to the driver the different supported power state at initialization.

System Power States vs Drivers Power States

The Power Manager is fully configurable through the registry, so default configuration is provided to at least manage power by its own without any pre-requisite. Each power state of the drivers will be associated to a system power state as follow :

On -> D0

User Idle -> D1

System Idle -> D2

Suspend -> D3

The Power Manager will request device driver to change their power state at system power state transitions, according to this list. As explained before, those values can be overridden using the registry by creating new entries like this :

[HKLM\SYSTEM\CurrentControlSet\Control\Power\State\UserIdle]
"bkl1:"=dword:4 ; backlight off

[HKLM\SYSTEM\CurrentControlSet\Control\Power\State\SystemIdle]
"bkl1:"=dword:4 ; backlight off

[HKLM\SYSTEM\CurrentControlSet\Control\Power\State\Suspend]
"bkl1:"=dword:4 ; backlight off

In this example, the driver named bkl1: will be turned off when the system power state will switch to User Idle, System Idle and Suspend states. You can either define power state for drivers individually in the registry or group them into IClass definition. When defining a driver in the registry you can specify which class of driver this driver is associated to.

[HKLM\SYSTEM\CurrentControlSet\Control\Power\State\SystemIdle\{ A32942B7-920C-486b-B0E6-92A702A99B35 }]
"Default"=dword:4 ; D4

This configuration will turn off all the device from the Iclass (A32942B7-920C-486b-B0E6-92A702A99B35). This IClass value is the GUID used by the power manageable devices.

That’s all for today, but two additional articles are following in the next few days. I will talk about the device driver interface requirements, and application interface used to communicate with the Power Manager and receive notification from him.

[Updated] : Access to part 2/3

- Nicolas