All about Win CE

How to add Win CE 6.0 office viewer, PDF viewer support ?

2011-02-23T13:57:00.001+08:00

How to add Win CE 6.0 office viewer, PDF viewer support ?

Turns out, it is simpler than I thought - it is a third party app - unlike Win CE 5.0 which has it as standard catalog component to choose from.

I was scouring NET to find out Win CE 6.0 viewers support which is boasted about in Win CE Features Page
but never has any direct links for how-to add those features.

Visit here to download & install it in your Win CE 6.0 development PC.

Once installed, the catalog components for the File Viewers will be under “\Third Party\File Viewers”

Win CE 6.0 Office viewer/PDF viewer components

So check the boxes and "sysgen".
You are good to go.

Try it out folks !! - Simple enough !!

NOTE: There are limitations (viewer)

Check the file name "xxxxReleaseNote.html" you can typically find it in path C:\WINCE600\PUBLIC\Viewers once you finished installation

SilverLight on Win CE 6.0 - by Vaulter Minute (very useful)

2009-11-09T19:43:00.002+08:00

Silverlight for Embedded tutorial

Windows Embedded CE 6.0 R3 has been released yesterday, you can download it from here:
http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=bc247d88-ddb6-4d4a-a595-8eee3556fe46
One of the most exciting new features of R3 is Silverlight For Embedded.
With this technology the UI of an application can be described using XAML, an XML-based language, and can be designed using visual tools like Expression Blend.
This will allow UI designers to work on embedded devices using the same tools they use on the desktop and it will let embedded developers concentrate on the core application features and not on the design of the UI.
I hope that this will lead to visually pleasing but also more user friendly interfaces on any kind of embedded device. Using visual tools for UI design should also improve development time and allow minor fixes to the UI without code modifications. This will improve device development times and reduce maintenance costs.
This simple tutorial will show how you can design a very basic UI in Expression Blend 2, load it inside an application and interact with it.
The first step you need to perform is include the components needed to support Silverlight For Embedded inside your OS Image and rebuild it.
Jochen Dieckfoß provided a good description of that process on his blog here:
http://discovertheexperience.blogspot.com/2009/09/windows-embedded-ce-60-r3-using.html
Now that you have an OS image supporting Silverlight for Embedded you can start to design your UI.
Start Expression Blend and create a new Silverlight application.

You'll have to use Expression Blend 2 SP1 (thanks Shai for the useful advice!) because this is the release that support Silverlight 2, the version that is currently supported on embedded devices.
This will create a Visual Studio solution (that we don't need for this tutorial).
As you can see the wizard allows you to choose a language between C# and Visual Basic. Silverlight for Embedded supports only C++ programming and it's currently not integrated with Expression Blend, so you'll not use the source code generated by this tool.
Remember to disable Visual Studio integration inside Expression Blend or it will generate C# or VB.NET code for event handlers etc.

After you created a new project, Expression Blend will present you with an empty XAML document (named page.xaml by default).

We can draw a simple button inside it picking it from the rich collection of controls provided by Silverlight.

Using the properties window we can assign a name to our new button.

The properties toolbox allows you to customize many aspects of your button: it's colors, it's rotation (yes you can have a vertical button or a button turned at 45 degrees!), it's opacity etc.
We will experiment with all these features in the next tutorials, for now we will keep the button as is and save our XAML.
If you open the XAML file using a text editor or view it using the XAML view inside Expression Blend you'll see that it's quite simple:


xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" x:Class="SimpleApp.Page" 
Width="640" Height="480">

We have a top level container (UserControl) that uses a Grid layout (objects are organized in rows and columns) and contains our button.
The button has attributes for placement inside its own grid cell (the only one we have), alignment, content (the text "Button") and its name ("MyButton").
Now we can start Platform Builder and add a new subproject to our OS Design.
You may develop your Silverlight for Embedded application also using Visual Studio 2005 or 2008 Smart Device application if you generate an SDK from your R3 OS design and install it on your development PC, but for this tutorial we will keep things simple...
Move to the solution tab, right click on the subprojects node and select "add new...".
Create a Win32 application.

And choose the simple Win32 application template.

This will create an application containing only WinMain, it's enough to start experimenting with our first Silverlight for Embedded UI.
The first thing we should do is add the Silverlight for Embedded includes to our source code:

#include "pwinuser.h"

#include "xamlruntime.h"

#include "xrdelegate.h"

#include "xrptr.h"

We will add the XAML that we generate with expression blend to our application resources. In this way we will not need to distibute the XAML file with it. On the other side changes to the XAML will require a rebuild of the application, you may choose the best method to integrate XAML and C++ source code in your application.
To include resources inside your executable file you need to add a resource script (rc file) to your subproject.
Right click on the subproject in solution view, select "add\new item" and then select resource file from the dialog box and assign a name to it (usually you have only one resource file per application so using the application name for that file sounds like a good idea).

Now that you have your resource file you can add the XAML data to it by creating a new resource.
Go to the "resource view" tab, right click on your resource file and select "add resource..."

Now you can import your XAML file data inside your executable. It will be stored inside it (at the end of the file) as binary data.

Type "XAML" as resource type.

For the tutorial you can leave the default ID (IDR_XAML1) for that resource, but it's a good idea to give meaningful names to your XAML components in a real project.

To use our resource IDs we need to include "resource.h" inside our .cpp file:

#include "resource.h"

Then, inside our application main function (WinMain) we can start to interact with the XAML runtime.
First of all we need to initialize it:

    if (!XamlRuntimeInitialize())

        return -1;

If XamlRuntimeInitialize succeeded, the Silverlight for Embedded runtime is loaded inside your application and it's ready to handle the UI.
Each Silverlight for Embedded application has a singleton "Application" object that allows us to access global application properties and features.
To access it we should use the GetXRApplicationInstance API.

    HRESULT retcode;

    IXRApplicationPtr app;

    if (FAILED(retcode=GetXRApplicationInstance(&app)))

        return -1;

Someone will notice that we are using HRESULTs and classes that use the "I" prefix and the "Ptr" suffix and understand that this new technlogy is based on COM (Component Object Model) that may sound like an ancient tool in those .NET and managed code days but it's still the foundation of many technlogies on both CE and desktop Windows releases. All Silverlight for Embedded objects are implemented as COM objects that export specific interfaces (COM interfaces have names beginning with "I"). Since using interfaces directly requires handling of their reference count and this may lead to memory leaks or premature object deletions, COM programmers prefer to use "smart pointers" that are wrappers around the interfaces and manage reference counting internally, destroying the COM object when the smart pointer object goes out of scope inside your C++ application (function return if it's allocated on the stack, object destruction if it's declared as a class member etc.). Smart point classes add the "Ptr" suffix to the interface name.
After this 30 seconds introduction to COM, we can return to our application.
The first thing we have to do with our application object is tell it where it can find its resources (XAML, images etc.).
We included them inside the executable using the resource file and so we can pass our HINSTANCE handle to it:

    if (FAILED(retcode=app->AddResourceModule(hInstance)))

        return -1;

Now that we have initialized our application object we can create our main window and let Silverlight for Embedded manage its contents:

    XRWindowCreateParams wp;

    ZeroMemory(&wp, sizeof(XRWindowCreateParams));

    wp.Style       = WS_OVERLAPPED;

    wp.pTitle      = L"S4E Test";

    wp.Left        = 0;

    wp.Top         = 0;

    XRXamlSource xamlsrc;

    xamlsrc.SetResource(hInstance,TEXT("XAML"),MAKEINTRESOURCE(IDR_XAML1));

    IXRVisualHostPtr vhost;

    if (FAILED(retcode=app->CreateHostFromXaml(&xamlsrc, &wp, &vhost)))

        return -1;

The VisualHost object "hosts" the runtime and allows us to access its contents and load our XAML from resources (using the XRXamlSource object).
Now our XA
The object inside our Silverlight for Embedded application are organized in a objects tree. To access the object inside it we need a pointer to its root:

    IXRFrameworkElementPtr root;

    if (FAILED(retcode=vhost->GetRootElement(&root)))

        return -1;

From the root object we can access our button using the name we assigned to it inside Expression Blend:

    IXRButtonBasePtr btn;

    if (FAILED(retcode=root->FindName(TEXT("MyButton"), &btn)))

        return -1;

To receive a notification when the user clicks our button we need to provide a delegate. A delegate is a pointer to a member of an istance of a C++ class that should have a specific prototype.
We can declare a simple C++ class inside our .cpp source and implement our button click event delegate inside it:

class BtnEventHandler

public:

    HRESULT OnClick(IXRDependencyObject* source,XRMouseButtonEventArgs* args)

        MessageBox(NULL,TEXT("Click!"),TEXT("Silverlight for Embedded test"),MB_OK);

        return S_OK;

};

Our event handler will simply display a message box when the button is clicked.
As you can see the event handler takes two parameters. A pointer to the object that generates the event (our button) and a pointer to a structure that contains the event parameters.

To connect our event handler to the button we have to create a delegate object:

    BtnEventHandler handler;

    IXRDelegate* clickdelegate;

    if (FAILED(retcode=CreateDelegate(&handler,&BtnEventHandler::OnClick,&clickdelegate)))

        return -1;

    if (FAILED(retcode=btn->AddClickEventHandler(clickdelegate)))

        return -1;

Our event handler has been connected to the button, now we can show our UI and wait that the user presses our wonderful button:

    UINT exitcode;

    if (FAILED(retcode=vhost->StartDialog(&exitcode)))

        return -1;

Our clickdelegate object is not a smart pointer, so we will have to release it explicitly:

    clickdelegate->Release();

Before we can build our subproject we need to add the include directories and the libraries needed to support Silverlight for Embedded inside our application.
Open the subproject sources script by right clicking on the subproject and choosing "open".
Add includes:

INCLUDES=$(_OEMINCPATH)

and libraries:

TARGETLIBS= \

    $(_PROJECTROOT)\cesysgen\sdk\lib\$(_CPUINDPATH)\coredll.lib \

    $(_PROJECTROOT)\cesysgen\sdk\lib\$(_CPUINDPATH)\xamlruntime.lib \

    $(_PROJECTROOT)\cesysgen\sdk\lib\$(_CPUINDPATH)\uuid.lib \

(you should already have the TARGETLIBS directive inside your sources script)
Now you can run the application on your device and push that button!

You, like me, are too lazy to type sample code, you can download a zip containing our demo application here:
http://cid-9b7b0aefe3514dc5.skydrive.live.com/self.aspx/.Public/SilverlightSample.zip

You can find the next step here:
http://geekswithblogs.net/WindowsEmbeddedCookbook/archive/2009/10/11/silverlight-for-embedded-tutorial-step-2.aspx

Installing Windows Embedded CE 6.0 sequence

2009-10-05T13:39:00.000+08:00

Installing Windows Embedded CE 6.0 has a number of steps which are listed below (with appropriate links). Perhaps the list may be useful as a “check list” for installation if you are ever in the position of needing to install from ground up.

Installing Windows Embedded CE 6.0 – Steps:

* Install Visual Studio 2005
* Install Visual Studio 2005 SP1
* Install Visual Studio 2005 SP1 for Vista
* Install Windows Embedded CE 6.0 (Eval link)
* Install Windows Embedded CE 6.0 SP1
* Install Windows Embedded CE 6.0 R2
* Install Windows Embedded CE 6.0 cumulative product update package (through 12/31/2008)
* Install Windows Embedded CE 6.0 monthly update package (Jan 2009)
* Install Windows Embedded CE 6.0 monthly update package (Feb 2009)
* Install Windows Embedded CE 6.0 monthly update package (Mar 2009)
* Install Windows Embedded CE 6.0 monthly update package (Apr 2009)
* <-Latest QFE->

Windows Embedded CE 6.0 R3 release

2009-10-05T10:52:00.000+08:00

Windows Embedded CE 6.0 R3 release

A new release of Windows Embedded CE 6.0 R3 has been announced yesterday at ESC Boston during Kevin Dallas’ keynote (Kevin is the GM for the Windows Embedded group at Microsoft… my big boss :-))

This new intermediate release brings some really great features that OEMs were really looking forward to see available in CE 6.

Silverlight for Windows Embedded
The power of Silverlight brought to Windows Embedded CE to create rich applications and user interfaces.
This technology is in 2 parts.

* The first one is a XAML rendering engine that will leverage Hardware Graphics acceleration to provide a great user experience on devivces. Using Expression Blend, designers will be able to built XAML based user interfaces for Embedded applications. the XAML supported is a subset of the Silverlight 2 XAML.
* The second part of the technology is a native developing API. While in Silverlight you have a managed model, in Windows Embedded CE you will use C++ to implement the business intelligence of the application.

For more details on Silverlight for Windows Embedded, check out these videos:
Introduction to Silverlight for Windows Embedded
Working with XAML in Expression Blend
Create a user control in Silverlight for Windows Embedded

Internet Explorer Embedded
Internet Explorer with panning and zooming capabilities and a customizable interface to optimize the browsing experience on devices. To have an idea of what you can expect from this new browser, check out the new Zune HD browser which is based on the same IE (careful, the Zune HD is running on Windows CE 6.0 R2, NOT on R3, only the browser is common to the CE 6.0 R3 one) in this review of the device.

Flash Lite
Browser plug in to render rich media websites. This is the version 3.1 of Flash Lite that is now included in the Windows CE tools, meaning there is no need to acquire an additional license to embed it into your device

Touch and Gesture
Plug-in engine to enable natural input capabilities and gesture animations

Connection Manager
Infrastructure technology to manage multiple network interfaces on the device

Microsoft Office and PDF Viewers
Applications to render Microsoft Office Word, PowerPoint, Excel and Adobe PDF content on the device

QQ Messenger
Device side client to connect to popular Instant Messaging service

This release should be available for download next week!
To learn more about Windows Embedded CE 6.0 R3, visit the Web Site.

Letterman confession - Quite unexpected - but eloquently put !!

2009-10-02T19:35:00.001+08:00

Courier, with a twist !!

2009-10-01T17:22:00.002+08:00

Courier User Interface

Microsoft, if it pays good attention to creating this gizmo, it would certainly create a new segment the market has never heard of ever before. It may get along well with the folks who thoroughly despise the exploits of tablet PC.

Video of the QiGi i6 running Android finally spotted

2009-02-10T19:31:00.002+08:00

Traffic Lights & Fuel Savings

2009-02-09T15:53:00.001+08:00

http://www.dirjournal.com/business-journal/traffic-lights-remain-green-for-transmitter-equipped-vehicles/

My location

2008-07-31T11:43:00.000+08:00

View Larger Map

Windows CE 6.0 R2 - SDHC Supports with ADMA Sakito's Blog

2008-07-17T11:26:00.000+08:00

Sakito's Blog

Wednesday, January 23, 2008 8:26 PM

Windows CE 6.0 R2 - SDHC Supports with ADMA

In the recent Windows CE 6.0 R2 release in Nov 2007, it supports the improved Secure Digital (SD) bus driver that supports SDHC specification 2.00 functionality, for example Secure Digital High-Capacity (SDHC) cards.

http://msdn2.microsoft.com/en-us/library/aa918430.aspx

What's new:

1. SD Bus Driver is updated to support 2.0 physical layer specification

2. SD memory driver updated to support SDHC card.

3. SD Host Controller is updated to support ADMA (Advanced DMA) (this require Hardware support in the host controller). This is a sample host controller that comes with Windows CE 6.0 R2, in x86.

QFE installer - automate that procedure

2008-07-17T11:08:00.000+08:00

The QFE Installer

Ever had to reinstall Windows CE? Then you had to reinstall all the QFE's as well. Not a nice task, it's lengthy and you have to stay close to your computer because there are about 12 screens you have click through before it actually installs. There is unfortunately no way to install all QFE's without a user controlling the mouse... until now!
The QFE installer installs all the QFE's you downloaded in the exact right order, from oldest to newest, without the need for one mouse click. Just copy the QFEInstaller.exe in the folder containing all the Windows CE QFE's and run it. Source available for free, just drop us a line.

Download QFEInstaller

Keep an eye on this blog for future tips & tricks and more tools for the CE developer!

CE 6.0 build - what to build and when ?- good one

2008-07-17T11:07:00.001+08:00

What to build when...

Submitted by Michel on May 1, 2008 - 22:48.

A question that keeps coming back on the newsgroups is "I changed some code, but it does not end up in my image", or "I changed some registry values in platform.reg, but if I look at the device registry, it's not there!".

The source of these problems is build-related. You've got to understand the build system in order to know exactly what to do. This blog post aims to give you a clear handle on "What to build when"!

The first and most important thing to do is to delete two options from the Platform Builder Build menu: Build and Sysgen and Rebuild and Clean Sysgen. These commands will build the entire tree (so including any source in PUBLIC and PRIVATE). For us normal developers these commands do not make any sense. If you're not in the CE development team working at Microsoft you simply don't have all the source code. Rebuilding the entire tree may work, but it will override any installed QFE (QFE's contain updated binaries and sometimes, but not always, updated source code). After rebuilding the entire tree you will sooner or later encounter strange errors that are either very hard to fix, or just impossible to fix. There is no way to revert back to a clean tree once you've done a (Re)Build and (Clean) Sysgen. The only way is to completely remove Windows CE and reinstall. Don't forget to reinstall all QFE's after that as well (download the QFEInstaller tool to help with that).

Now you know why you often see me shouting NEVER EVER DO A BUILD AND SYSGEN! in the newsgroups...

The original Advanced Build Commands menu

Step 1.: Right click on the toolbar and click Customize...
Step 2.: Click on menu Build, submenu Advanced Build Commands, then right click on Build and Sysgen and click Delete
Step 3.: Do the same for Rebuild and Clean Sysgen
Step 4.: Close the Customize window. The Advanced Build Commands menu should now have only 4 options: [Sysgen], [Clean Sysgen], [Build Current BSP and Subprojects] and [Rebuild Current BSP and Subprojects].

If you are still using Platform Builder for Windows CE 5.0 the instructions stay the same except the Build menu is Build OS and there's no submenu (everything is under the Build OS menu).

I know that some developers working with CE change code in the PUBLIC and PRIVATE trees. If you do that you need to do a build and sysgen to include your changes in your kernels BUT: You will end up with a corrupted CE installation. If you need to change PUBLIC or PRIVATE code you have to clone the code. Cloning code is in most cases not much more than a simple copy. Copy the sources you want to change to a folder in your BSP, change the sources file so that it builds a DLL instead of a lib and voila, you're done. I know I make it sound easier than it is, but taking a shortcut and modifying code in the PUBLIC or PRIVATE trees will prove to be a long way around in the long run.

Phew! Now that we got that out of the way let's see what build command we've got to use in what situation:

Change Platform Settings: Make image

If you change any Platform Settings (like IMGNOKITL, IMGNODEBUGGER, IMGPROFILER) all you have to do is a Make Image.

Change driver source code in your BSP: Build the driver and Make Image

If you change driver source code, all you have to do is just build the driver (WINCEREL must be set to 1 but it is set by default so unless you changed it there's no need to worry) and do a makeimg. If you only want to debug the driver you can also add the DLL to the Release Directory Modules list (menu Tools) and just restart the device (or reload the device driver on the device) without having to do a makeimg and download to device. Building just the driver is a simple right-click on the driver and Build in the IDE or "build" in the driver's folder on the command line.

Change multiple source code files in your BSP: Build the BSP and Make Image

The safe option, this way you can't forget to rebuild anything. Building the BSP is a simple right-click on the PLATFORM\BSP folder and Build in the IDE or "build" in the BSP's root folder on the command line.

Change platform.reg, bib, dat or db files in your BSP: Sysgen BSP, Copy Files to Release Directory, Build All Projects and Make Image

A lot of steps, but this will still not take longer than a couple of minutes. If you change any of the platform.* files we need to re-filter (Sysgen) those files and make sure the filtered files are copied into the FLATRELEASEDIR (Copy Files to Release Directory). That last action did however clear the project binaries from the FLATRELEASEDIR so we need to make sure those binaries and settings are getting copied into the FLATRELEASEDIR again (Build All Projects) and finally we are ready to Make Image. Now your registry changes will be in the image (check reginit.ini to make sure, last entry wins).

Change some source files and platform.reg, bib, dat or db files in your BSP: Build and Sysgen the BSP, Copy Files to Release Directory, Build All Projects and Make Image

Only difference with previous situation is that you now have to build the BSP to include the source code changes.

Change the workspace configuration (add or delete a component): Sysgen the entire workspace

For most components a simple Sysgen is enough. For some components (like when changing from RAM based registry to Hive based Registry) a Clean Sysgen is needed. This action takes the longest (anywhere from 5 minutes for a small workspace configuration on a very fast machine to a couple of hours for a really big configuration and a very slow machine). A Sysgen is a right-click on the workspace, Advanced Build Commands->Sysgen in the IDE or "blddemo -q" on the command line.

Sometimes it's easier to build from the command line. If you are unsure what command to type you can always perform the action in the IDE first and watch the 3rd line in the build output window starting with "Starting Build:". Behind the colon is the exact command line for that action, eg Sysgen on the BSP: "Starting Build: SysgenPlatform %_TARGETPLATROOT% preproc&&SysgenPlatform %_TARGETPLATROOT% postproc", so on the command line you would type "SysgenPlatform %_TARGETPLATROOT% preproc" followed by enter and the 2nd command "SysgenPlatform %_TARGETPLATROOT% postproc" followed by enter.

If you use the commandline, make sure you never forget "-q" when running "blddemo" as "blddemo" without "-q" is a Build and Sysgen!

I hope this blog post will help you speed up your builds and lower your frustration with the build system!

Good luck!

Offline installation of CE 5.0 R2 update

2008-07-17T11:06:00.001+08:00

Offline installation of the CE 6.0 R2 update

Submitted by Michel on May 2, 2008 - 04:23.

The Microsoft installer for the CE 6.0 R2 update is a webinstaller. This means there is no way to download once - install often. Since the complete R2 update is over 1 GB of data it would be nice to be able to download the package to a folder from which you can install the R2 update offline. This is especially handy if you need to install the R2 update on multiple machines.

Another reason would be if you, like me, get errors during installation. When I tried to install the R2 update I got error messages like:

"Error 1335. The cabinet file 'MSI4E0.tmp' required for this installation is corrupt and cannot be used. This could indicate a network error, an error reading from the CD-ROM, or a problem with this package.".

So I dissected the MSI log files and was able to determine some downloaded cabinets were in fact corrupted. The corruption only seemed to occur when downloading using the Microsoft Installer package. When I manually downloaded the cabinets there was no corruption. By looking at the log files I could get a list of all required cabinet files. Since there are quite a few of those cabinets, and I figured this could be handy for more people, I wrote a tool that downloads the entire package from the Microsoft download server into a folder. Once the download is complete (1.1 GB) run the installer (Windows Embedded CE 6.0 R2.msi) to install the R2 update. You don't need to be connected to the internet while installing.

Download the tool (including source): DownloadCE6R2.zip

How to build reliably - almost any platform ?? check this out

2008-07-17T11:04:00.000+08:00

CruiseControl

CruiseControl is a framework for a continuous build process. It includes, but is not limited to, plugins for email notification, Ant, and various source control tools. A web interface is provided to view the details of the current and previous builds.

CruiseControl is distributed under a BSD-style license and is free for use. CruiseControl adheres to an open source model and therefore makes the source code freely available.

CruiseControl is maintained and developed by a group of dedicated volunteers.

What is Continuous Integration?

Continuous Integration by Martin Fowler and Matthew Foemmel.

An important part of any software development process is getting reliable builds of the software. Despite its importance, we are often surprised when this isn't done. We stress a fully automated and reproducible build, including testing, that runs many times a day. This allows each developer to integrate daily thus reducing integration problems.

automating your build process with CE 5.0

2008-07-17T11:02:00.002+08:00

Command Line Build

Submitted by Erwin on May 15, 2008 - 22:31.

This post will show you how to create a batch file that will build your Windows CE OS without using the Visual Studio/Platform Builder IDE.

Often the question is asked how to setup an environment which automatically extracts all information from version control and then builds your code. There are a lot of tools that can help you do that: an open source alternative can be found at http://cruisecontrol.sourceforge.net.

To build your kernel without having to use the IDE create a batch file with the following content:
@echo off SET _WINCEROOT=C:\WINCE500 SET _OSDESIGNDIR=%_WINCEROOT%\PBWorkspaces\YOUR_WORKSPACE_FOLDER SET _OSDESIGN=%_OSDESIGNDIR%\YOUR_WORKSPACE_FILE.pbxml SET _OSDESIGNCONFIG=YOUR_OSDESIGN_CONFIG_NAME

"%ProgramFiles%\Windows CE Platform Builder\5.00\CEPB\BIN\pbxmlutils" /getbuildenv /workspace "%_OSDESIGN%" /config "%_OSDESIGNCONFIG%"> SetEnv.bat cd "%_OSDESIGNDIR%" call SetEnv.bat delete SetEnv.bat cd "%_OSDESIGNDIR%" blddemo clean -q

Note that for CE 6.0 pbxmlutils is located in "%ProgramFiles%\Microsoft Platform Builder\6.00\cepb\IdeVS\" and you use SET _WINCEROOT=C:\WINCE600

You need to replace the first 3 SET variables to match your specific project:

YOUR_WORKSPACE_FOLDER: Workspace folder which is located under the PBWorkspaces (CE 5.0) or OSDesigns (CE 6.0) folder. This is the folder that contains YOUR_WORKSPACE_FILE.

YOUR_WORKSPACE_FILE: The name of your OS Design workspace; the file with extension .pbxml. This file is located in YOUR_WORKSPACE_FOLDER.

YOUR_OSDESIGN_CONFIG_NAME: This is the configuration name you select in the IDE of Platform Builder, eg Emulator: x86_Release. You can also open your .pbxml file with notepad to find out what the configuration name is (search for Configuration Name).

Happy building!

Great link for free win ce apps

2008-07-17T11:02:00.001+08:00

[HOME] [Windows] [WindowsCE] [About this site]


CEHTTP (EN)	HTTP/1.1 web server.
CeSMTPD (EN)	SMTP/POP3 Server.
ITaskMgr (EN)	Task manager like Windows.
Drop Commander (JP)	A nostalgic game for DoCoMo Pocket post pet.
Blue Clock (JP)	It's a simple clock for DoCoMo Pocket post pet.

[HOME] [Windows] [WindowsCE] [About this site]

2005/09/04Copyright (C) Yuichiro Ishitani Allrights reserved.

Honda FCX clarity - next cool thing on the road

2008-06-16T15:01:00.000+08:00

Honda FCX Clarity

The most remarkable thing about driving Honda's FCX Clarity prototype isn't how it emits nothing but water, its torquey, 13,500 rpm electric motor, the hydrogen equivalent of 68 miles per gallon or the perverse pleasure that goes with driving a multimillion-dollar automobile. It's the air-conditioned seats. Notice I said driving, because other than the whirring buzz of the motor, the Clarity goes, brakes and turns just like any other car. I had to keep reminding myself I was indeed behind the wheel of a hydrogen fuel-cell powered feat of engineering. Frankly, the Clarity feels like a slightly larger Accord. Again, Honda's latest FCX uses no gasoline whatsoever and behaves just like — no, make that exactly like — a regular car. And those AC seats? They have built-in fans to blow thermoelectrically cooled air, so no ozone-killing chlorofluorocarbons are needed to chill your fat butt. Pretty neat.

Jalopnik Drives the Honda FCX Clarity

The technology behind the Clarity is basically a flashback to tenth-grade chemistry. Tank-stored gaseous hydrogen is pumped into the "stack," which consists of layer upon layer of fuel cells. Inside each cell, hydrogen gas reacts with a hydrogen electrode, causing a catalytic reaction that ionizes the hydrogen atom (electricity is of course nothing but flowing electrons). The electron-less atom (ion) next bonds with oxygen to create water, which recirculates through the stack to keep the electrolytic membranes damp, before exiting the vehicle through the tail pipe. In turn, the fuel cell stack powers an electric motor, which drives the front wheels. There is also an auxiliary lithium ion battery to store extra juice created by the stack, the motor (which behaves like a generator when decelerating) and additional energy gathered from the regenerative braking system. The battery is used during start-up or to assist the engine if the demands of the right foot exceed the power output of the stack. See? Piece of sugar-free cake.

As intense and complicated as all that sounds, you'd never suspect the FCX Clarity was anything but a run-of-the-mill Honda. While some have complained that it looks like a Hondaized Prius, the Clarity is so large as to mitigate that comparison. I maintain it looks like an elongated Accord with Infiniti G Coupe haunches, a chopped front end and a chrome new-gen Volkswagen beard. Sure, it's a little longer than the Hondas we're used to, but that's the price paid for having a fuel tank that can store enough hydrogen for a 270-mile journey while ensuring plenty of back seat legroom and a real trunk. The Clarity is also a bit wider than most Japanese mid-size family sedans because the stack is nestled between the front seats. Hey, you have plenty of elbow room.

The interior is extremely comfortable, nearly luxurious and made from all sorts of high-tech green materials, like corn. The instrument panel is similar to the current Civic but manages to crank up the Fisher-Price-meets-Buck-Rogers chic. For example, a small blue circle appears in the center of the digital dash when the Clarity is "idling." During acceleration the ball grows larger and turns green. Really stand on the go pedal and the ball morphs into a glowing-orange sun. The backseats are especially spacious. There's plenty of legroom, and the door panels are scooped out, giving the back compartment a circular feel.

Our drive started at the ritzy Fairmont Mira Mar Hotel on Ocean Drive in Santa Monica, where Autoblog Sam turned north onto Pacific Coast Highway and wound his way through Malibu and that city's recently charred canyons. I looped us back. While dealing with stop-and-go traffic in Malibu, we were surrounded on all sides by Hybrids. Every fifth car seemed to be a Prius. At one point we even found ourselves behind a Ford Escape Hybrid with a license plate that read, "NO HUMMR." I was reminded of Star Trek IV when Kirk and the boyz warp back to the year 1986 and Bones finds a woman hooked up to a kidney dialysis machine. He feeds her some pills made from super futuristic technology, unhooks her from the apparatus and declares the then contemporary state of medicine, "Barbaric." All around us people were driving vehicles that in their minds are atop the environmental food chain. Yet they're still emitting loads of dirty old carbon dioxide (and whatever else) into the atmosphere derived from a tank full of Middle Eastern crude. Meanwhile we're zooming past all of 'em, dripping only water while nestled comfortably behind the wheel of the future.

Malibu, California

Naysayers, Ron Paultards, the blindly patriotic and those not convinced that human activity is cooking our globe will all roll their eyes and dismiss the FCX Clarity as nothing but vaporware. A passing fad. A cynical gesture by Honda aimed at appeasing "environmental nazis," CAFE standards and nothing else. All that's fine, as people said similar things about Henry Ford's Model T. But even if you hate Al Gore and despise Ed Begley Jr., there's no way $100 for a barrel of oil (up from under $60 one year ago) makes you happy. Something has to give, and give in a big way.

Ford Model T

Coincidently, 2008 marks 100 years since Ford put America on wheels by rolling out the Model T. It's also the year Honda will begin leasing FCX Clarity models (and their home-based, natural gas powered hydrogen refueling stations) to select customers around Southern California and in Japan. Yes, the natural gas emits CO2, but only half as much as petroleum. More important, tank-to-wheel energy efficiency is more than double that of Honda's existing hybrids, and three times that of their small internal combustion cars like the Fit. And remember, if the hydrogen is created using green energy — solar, wind, geo-thermal, hydro or atomic — there are no greenhouse emissions whatsoever.

At this point you probably want to know how fast the FCX Clarity accelerates, its top speed and how many Gs it pulls around corners. Well, Honda didn't bother to say much about the Clarity's performance other than it's comparable to a "2.4-liter internal combustion vehicle of similar size." So, we have to guesstimate. As the 100 kW (136 hp) electric motor creates 189 ft-lb of torque from zero rpm, zero-to-60 times are most likely in the low seven-second range. Never forget that Americans buy horsepower and drive torque. Top speed is limited to 100 mph. Much more impressive is how effortlessly the Clarity cruises. At one point the speedo indicated 53 mph and I was convinced I'd accidentally switched the display to metric. A moment later we passed one of those police "your speed is" contraptions that indicated 53 good old American miles per hour. The ride, helped out by the long wheelbase, is outstanding. The Clarity weighs in at 3582 lbs. A four-cylinder Accord weighs 3,433 lbs. and the V6 model weighs 3600 lbs. Going around a corner, you'd be hard pressed to detect a difference between the three. But performance is hardly the point.

Honda FCX Engineers and their Baby

Every year I go to New York to watch the Packers play the Vikings. We watch the game at your typical sports bar with a dozen or so TVs hanging from the walls. One year a Giants or Jets game finished up early and the local station switched over to the Green Bay/Minnesota game we had until then been watching on Satellite. However, the local channel's feed was about ten seconds ahead of the satellite. "Turn it off! Turn it off!" one of the more colorful patrons began screaming, "Turn that fuckin' TV off!" We tried to reason with him, explaining that it doesn't matter if one feed is ten seconds in front of the other. "No way man," he shot back, "That's the future!"

Climbing out of the FCX Clarity and back into my own car, I couldn't help but feel the same. Sitting in the world's most heinous traffic surrounded by millions of my fellow Angelenos all burning countless zillion gallons of gasoline, how on earth is all this going to change? Where's the hydrogen infrastructure going to come from, if it comes at all? I don't know. Honda is going to stick a few refueling stations in and around Los Angeles along an already existing hydrogen pipeline (common in industrialized areas) but obviously that's not enough. Their home energy station is pretty damn useless if you live in an apartment. And the $600 per month lease is no friend to most of us. Honda (and Ford and Toyota and GM and every manufacturer investing in fuel cell technology) has a real chicken-and-egg situation on their hands. Fortunately the Honda FCX Clarity is one hell of a chicken.

Honda FCX Clarity Press Shots

Intel shows off robotic hand with "Pre Touch" object conformation - Engadget

2008-06-15T23:22:00.000+08:00

Intel shows off robotic hand with "Pre Touch" object conformation - Engadget

Blaft

2008-06-09T12:28:00.000+08:00

Blaft

Windowz 7

2008-05-28T15:25:00.000+08:00

So, we are on for Windows 7... when is that again ?.... oh.... that no one is sure about ... not even Billy boy..

Hope this latest flick of touchpanel magic works out big for Billy Boy!!

http://www.betanews.com/article/Can_a_touchscreen_interface_turn_around_Windows/1211950453

What's for sure is the way people deal with computers is gonna change, one again. When I say "people" it may refer to anyone that sits with computer to get his life going... That's right "dealing" with is the word. One has to sit there, open up, and do something to enjoy his photographs or store them safe in his album.

Especially the ones that have no idea what that box can do, have a real struggle getting to know the things that keeps them at par with these gizmos which are a practical reality of the world we live in.

Users of Digi-cams and DV(s) have a long awaited and deserve better treatment from what this new world order of technology has to offer. They should never be "dealing" with a box to do what they wanna do. That makes no sense at all.

Windows CE books - last update 07/12/2007

2007-07-12T10:37:00.000+08:00

Windows CE6 drivers: what you need to know

2007-07-11T17:25:00.000+08:00

by Sue Loh (Dec. 6, 2006)Foreword: One of the biggest concerns people have about Windows CE 6 is backward compatibility with Windows CE 5. Although the Windows CE team expects "very high compatibility" for applications and OAL (OEM Adaptation Layer) code, the same can't be said for device drivers.In this brief technical whitepaper, Sue Loh, a developer on the Windows CE team, explains how drivers need to change, and why.

CE6 drivers: what you need to knowby Sue LohMany, in fact most, device drivers will need modifications in order to run on CE6. While binary compatibility (being able to run the exact same driver without a rebuild) is not likely, we do expect it to be easy to port almost all drivers. That was our goal once we realized many drivers would have to change.The primary reasons that drivers will need change are:
Deprecated APIs
Memory passing
Asynchronous buffer access
User interface handling The biggest difference in CE6 is how drivers access embedded pointers and other data, as I described in detail in my earlier article on memory marshalling. There are two main things you need to do to fix memory accesses. First, look through your existing code for calls to mapping APIs like MapCallerPtr or MapPtrToProcess, and convert them to calls to marshalling APIs like CeOpenCallerBuffer / CeCloseCallerBuffer. Second, look for calls to SetKMode and SetProcPermissions. They most likely correspond to asynchronous memory access, for which you'll now need CeAllocAsynchronousBuffer / CeFreeAsynchronousBuffer.That will take care of most of the porting work. The other thing to look for is UI functionality. If your driver has any UI, you won't be able to run it in the kernel. And most CE6 drivers will run in the kernel. Even if your driver will run in user mode, we recommend using the kernel UI handling to maximize portability between user and kernel mode. In CE6, drivers that require UI should break that UI functionality out into a companion user-mode DLL. Move all the resources, shell calls, etc. into the new DLL. Then use the new CeCallUserProc API to call into the user-mode helper.
BOOL CeCallUserProc( LPCWSTR pszDllName, LPCWSTR pszFuncName, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned); This is something like a combination of LoadLibrary / GetProcAddress with an IOCTL call. When a kernel-mode driver calls this API, we'll load the DLL inside an instance of udevice.exe. When a user-mode driver calls this API, the DLL will load in-proc inside the same instance of udevice.exe that the user-mode driver is running in. So drivers that use this API can run in kernel or user mode without change.The one big difference between CeCallUserProc and an IOCTL is that CeCallUserProc does NOT allow embedded pointers. All arguments must be stored inside the single "in" buffer passed to CeCallUserProc, and return data must be stored in the single "out" buffer. The problem is, if kernel code calls user code, user code cannot use CeOpenCallerBuffer or any other method to get the contents of kernel memory. We never allow user-mode code to access kernel-mode memory.And, while you are modifying your drivers to use the new marshalling helpers and CeCallUserProc, you might as well check to see if it needs to do any secure-copy or exception handling it never did before -- as I outlined in the marshalling article. Remember, now that drivers run in the kernel, you must be more careful than ever to preserve the security and stability of the system.User-Mode DriversAs we've already mentioned, CE6 now supports running drivers inside a user-mode driver host, udevice.exe. User-mode drivers work pretty much the same as kernel-mode drivers: an application calls ActivateDevice(Ex) and DeactivateDevice on the driver. The device manager will check registry settings to see if the driver is supposed to be loaded in user mode. You can also use registry settings to specify an instance "ID" of udevice.exe to use, if you want multiple user-mode drivers to load into the same process.For example, there is one user-mode driver group with ID 3. Multiple drivers load into this group. If you look inside the CE6 %_WINCEROOT%\public\common\oak\files\common.reg (an unprocessed version of what you get in your release directory), you'll see how this group is created and a few drivers that belong to it.
[HKEY_LOCAL_MACHINE\Drivers\ProcGroup_0003] "ProcName"="udevice.exe" "ProcVolPrefix"="$udevice" ; Flags==0x10 is DEVFLAGS_LOAD_AS_USERPROC [HKEY_LOCAL_MACHINE\Drivers\BuiltIn\Ethman] "Flags"=dword:12 "UserProcGroup"=dword:3 [HKEY_LOCAL_MACHINE\Drivers\Console] "Flags"=dword:10 "UserProcGroup"=dword:3 [HKEY_LOCAL_MACHINE\Drivers\BuiltIn\SIP] "Flags"=dword:10 "UserProcGroup"=dword:3 If you don't specify a process group, your driver will be launched inside a unique instance of udevice.exe.The device manager creates a reflector service object to help the user-mode driver do its job. The reflector service launches udevice.exe, mounts the specified volume and registers the file system volume APIs for communicating with the driver. Communication between applications and the user mode driver pass through the reflector, which helps with buffer marshalling. The reflector also assists the user-mode driver with operations that user-mode code is not normally allowed to make, like mapping physical memory; more on this later.It is our goal that drivers should be as close to 100% portable between kernel and user mode as possible. However, kernel code will always be more privileged than user code will be. Taking advantage of the increased kernel capabilities will make your kernel-mode driver impossible to port to user mode.What are some of the incompatibilities you need to know about?As I explained in the marshalling article, user-mode drivers cannot write back pointer parameters asynchronously. I take it a step further and say that user-mode drivers cannot operate on caller memory asynchronously. That you're better off keeping such drivers in kernel mode for now, or restructuring their communication with the caller so that nothing is asynchronous.Another detail you should know about is that user-mode drivers cannot receive embedded pointers from the kernel. This is exactly the same as saying that CeCallUserProc cannot support embedded pointers. If you're writing a driver that talks to kernel-mode drivers, and those kernel-mode drivers pass you embedded pointers, then your driver may have no choice but to run in kernel mode. If you can reorganize the communication between drivers, you may be able to "flatten" the structure so that, like CeCallUserProc, all the data is stored directly in the IN and OUT buffers instead of referenced via embedded pointers.There are some APIs which used to require trust that now are (mostly) blocked against use in user mode. One notable example is VirtualCopy, and its wrapper function MmMapIoSpace. Most user-mode code cannot call VirtualCopy. User-mode drivers can, with a little help from the reflector. The reflector can call VirtualCopy on behalf of a user-mode driver, but it will not do so unless it knows the driver is allowed to use the addresses it's copying. Under each driver setup entry in the registry, there are IOBase and IOLen keys that we use to mark physical memory. When your driver calls VirtualCopy, the reflector will check these values to make sure your driver is allowed to access the physical address. For example, the serial driver might specify a physical address like this:
[HKEY_LOCAL_MACHINE\Drivers\BuiltIn\Serial] "IoBase"=dword:02F8 "IoLen"=dword:8 If you have just one buffer to copy, use DWORD values. Use multi-strings to specify multiple base addresses and sizes.
[HKEY_LOCAL_MACHINE\Drivers\BuiltIn\Serial] "IoBase"=multi_sz:"2f8","3f6" "IoLen"=multi_sz:"8","2" Since only privileged applications can write to this part of the registry, the registry keys should protect against unprivileged code trying to gain access to these addresses.Notable APIs that user-mode code cannot call:
VM APIs: VirtualCopy[Ex], LockPages[Ex], CreateStaticMapping
Interrupt APIs: InterruptInitialize, InterruptDone, LoadIntChainHandler
You cannot install IISR directly, though you can install GIISR via the reflector. (GIISR exposes well known interfaces and the reflector can do the required checks on these calls.)
OAL IOCTLs that are not explicitly permitted by the kernel Call-backs from a user-mode driver to any process are also prohibited. The most important repercussion of this is, if you move a bus driver to user mode, you'd have to move the client drivers to user mode too. You can't have the client driver in the kernel since you cannot call back to the bus driver. You may want to put the bus driver and all of its client drivers in the same udevice.exe instance, so that the callbacks are all within a single process.OEMs can choose to expose additional OAL IOCTLs and APIs to user mode by building a kernel-mode driver that provides these services -- by essentially writing their own version of a reflector. There is a kernel-mode driver, the oalioctl driver, that OEMs can extend to this end. Anyone who's not an OEM would have to write their own kernel-mode driver to do it. But be warned! Using oalioctl or writing new kernel-mode drivers to expose this functionality is essentially opening up a security gap that we (Microsoft) sought to close. Personally I advise against it.Writing CE5 drivers to be compatible with CE6I would like to mention that Steve Maillet, one of our eMVPs, had a good suggestion: you can set up abstractions which combine the CE5 and CE6 driver needs, so that all you have to do is reimplement the abstraction layer in order to port from CE5 to CE6. He even presented his abstraction layer at this year's MEDC (Mobile & Embedded DevCon, 2006).

Differences between Windows CE 5.0 and Windows CE 6.0

2007-07-08T19:17:00.000+08:00

Im into this - yes, CE

So whatever I learn its gonna be right here - alright !!!

Differences between Windows CE 5.0 and Windows CE 6.0

http://www.windowsfordevices.com/articles/AT9457847627.html

A thousand dollars back !!

2006-12-26T10:42:00.000+08:00

Some of the most unexpected things happen when you least expect it. It seems this was my turn to experience this adage.

Tax man gives me back approx.. a 1000 USD back !! wow !! Something to celebrate !! a christmas gift perhaps !! ??

Im as happy as the day I got married !!

thatz cooooooooooooool

All about Win CE

How to add Win CE 6.0 office viewer, PDF viewer support ?

SilverLight on Win CE 6.0 - by Vaulter Minute (very useful)

Silverlight for Embedded tutorial

Installing Windows Embedded CE 6.0 sequence

Windows Embedded CE 6.0 R3 release

Letterman confession - Quite unexpected - but eloquently put !!

Courier, with a twist !!

Video of the QiGi i6 running Android finally spotted

Traffic Lights & Fuel Savings

My location

Windows CE 6.0 R2 - SDHC Supports with ADMA Sakito's Blog

Windows CE 6.0 R2 - SDHC Supports with ADMA

QFE installer - automate that procedure

CE 6.0 build - what to build and when ?- good one

What to build when...

Offline installation of CE 5.0 R2 update

Offline installation of the CE 6.0 R2 update

How to build reliably - almost any platform ?? check this out

documentation

contributing

CruiseControl

What is Continuous Integration?

Related links

automating your build process with CE 5.0

Command Line Build

Great link for free win ce apps

Honda FCX clarity - next cool thing on the road

Honda FCX Clarity

Jalopnik Drives the Honda FCX Clarity

Honda FCX Clarity Press Shots

Intel shows off robotic hand with "Pre Touch" object conformation - Engadget

Blaft

Windowz 7

Windows CE books - last update 07/12/2007

Windows CE6 drivers: what you need to know

Differences between Windows CE 5.0 and Windows CE 6.0

A thousand dollars back !!