This is the second part in a 2-part series on how to install Microsoft Windows 10 IoT Core on an Internet-of-Things (IoT) device. Part 1
described how to install Windows 10 IoT Core on a Raspberry Pi 3 device. This article will focus on the steps required to install Windows 10 IoT Core on an x86/x64 device.
What is Windows 10 IoT Core?
Windows 10 IoT Core is a version of Microsoft’s Windows 10 operating system that has been optimized for smaller devices that can run on either ARM or x86/x64 devices. These devices can run with or without a display device.
When we talk about the different IoT devices, the processor type needs some explanation. ARM devices are called Advanced RISC Machines, with RISC standing for Reduced Instruction Set Computer. What this means is that the processor has been slimmed down to only include a reduced set of commands it can process. While this means that the processor can’t do certain things, it requires a low amount of power to execute what it can do, so that translates to increased battery life. The Raspberry Pi is classified as an ARM device.
Devices with the x86/x64 architecture are classified as CISC processors, which stands for Complex Instruction Set Computer. These processors do not have their instruction sets slimmed down, so they can perform more complex operations, at the cost of increased power consumption (and therefore lower battery life). Intel’s Baytrail devices running the Intel Atom processor E3800 is an example of an x64 device.
Before you can install on an x86/x64 device, you need to make sure you have a PC that is running Windows 10 1507 (version 10.0.10240) or higher. You can find out what version you are running by clicking on the search box (next to the Start button) and typing ‘winver’. This will display a dialog as shown here:
For certain x86/x64 device you can use IoT Core Dashboard to run through the installation process. However, since the process is similar using IoT Core Dashboard (which I already covered in Part 1), I am going to go through the installation process steps using the Windows ADK IoT Core Add-Ons
You will need an IoT device to install on – here are some options that Microsoft supports:
We will be using the Intel Atom E3800 (aka Baytrail) built on an industrial PC for examples in this article. Typically we would need a micro SD card for storage but since the industrial PC comes with onboard memory storage, we do not need an SD card.
For software, we will need to install the following on the PC we build the image on:
Once you have the prerequisites installed, you are now ready to begin the installation process. We will be building a basic image, which involves combining the Windows IoT Core packages along with a board support package for the target hardware (Baytrail device) into a flashable file (FFU file).
First off, you need to set your OEM name, which will help you distinguish your created packages from packages other manufacturers have created. Edit the setOEM.cmd file, located at C:\IoT-ADK-AddonKit
and set the OEM_NAME variable accordingly. Please note you can only use alphanumeric characters.
You should now open the IoTCoreShell.cmd
file, which is a specialized command-line window that you will be doing a lot of the work for building the image. This file is located in the directory where you installed the IoT Core ADK Add-Ons (C:\IoT-ADK_AddonKit
). Open an administrator-elevated privilege command window and navigate to the C:\ IoT-ADK_AddonKit
directory. Type in IoTCoreShell.cmd
to open the IoT Core Shell. This application will prompt you to select the architecture you are working with (1 for ARM, 2 for x86, 3 for x64). We are creating an x64 image so select x64
At this point, you need to install certificates which will be used to sign the package binaries. Since this article is focused on a test image, you can run the installoemcerts.cmd
command to install test certificates in the root certificate store of the PC you are building the image on. This only needs to be done the first time you are building an image.
The next step is to extract the board support package (BSP) files for the device you are building an image for, and run the buildpkg.cmd
command to build the package files used in creating the image. You can download and extract this BSP zipfile and copy to C:\IoT-ADK-AddonKit\Source-x64\BSP
directory to begin using for building an image.
You can now begin to create the packages and build the FFU image for the Baytrail x64 device. Go back to the IoTCoreShell.cmd
command window and enter buildpkg all
which will build the .cab files for all the BSP directories the program sees under C:\IoT-ADK-AddonKit\Source-x64\BSP
. Please note that if you had selected x86
when you ran the IoTCoreShell.cmd
, running this command to build all the packages would look in the C:\IoT-ADK-AddonKit\Source-x86\BSP
to build any BSP files located there.
Once the program finishes building all the BSP packages, you can now create a new project by entering the following, where Product_Name
are the name of the product you would like and the BSP name, respectively.
newproduct <Product_Name> <BSP_Name>
So, for example, entering newproduct MyBayTrailDevice BYTx64
will create a project and its files under C:\IoT-ADK-AddonKit\Build\amd64\MyBayTrailDevice
for the BYTx64
board support package files.
You are now ready to build the actual FFU flashable image file. This can be done by entering buildimage <Product_Name> Test
, replacing Product_Name
with your product name (MyBayTrailDevice
in our example). The second parameter specifies whether you are building a Test or Retail image. This process takes about 20-30 minutes to complete and once finished you will have a file named flash.ffu
created under the C:\IoT-ADK-AddonKit\Build\amd64\ MyBayTrailDevice\Test
If you encounter any errors, the buildimage process will error out and specify a log file that has detailed information on the error.
Now that you have a flashable FFU image file, you will need to flash it onto the IoT device you are working with. For our example, this is the Baytrail device and since it has onboard storage space we need to use a bootable USB thumbdrive with the FFU file on it. In order to create this, we will use Windows PE to create a bootable disk and then copy the flash.ffu file onto it. Here are instructions to create a bootable WinPE thumbdrive:
Copy the flash.ffu
file to the root of this bootable drive once you’ve created it. You are now ready to insert this USB thumbdrive to the IoT device and power it up. Make sure you specify in the IoT device’s BIOS to boot first from a USB drive.
WinPE will boot up and open a command window for you at the x: drive. Change to the d: drive and enter dir
to see your flash.ffu
file. WinPE comes with DISM, the Deployment Image Servicing and Management
tool and we will be using this to flash the FFU file onto the IoT device. Enter the following in the command line to flash the FFU file:
dism.exe /apply-image /ImageFile:Flash.ffu /ApplyDrive:\\.\PhysicalDrive0 /skipplatformcheck
Once DISM has successfully completed the flashing process, you can power down the IoT device and remove the USB thumbdrive. Turn on the IoT device and have it boot normally off its storage. After a few minutes you should see the Windows 10 IoT Core startup screen and it should prompt you to select a language and whether you want Cortana activated. Once you make these selections the default application will appear.
Congratulations! You have successfully installed Windows 10 IoT Core on a x64 IoT device! Future steps can now be to modify the image to have it include your custom application or you can add drivers to the image if you need other functionality (such as Bluetooth or serial communications).