Lab 1a: Create a basic image
To get started, we'll create a basic Windows 10 IoT Core (IoT Core) image and flash it onto a specific hardware device.
We'll create a product folder that represents our first design. For our first product design, we'll customize just enough for the IoT core device to boot up and run the built-in OOBE app, which we should be able to see on an HDMI-compatible monitor.
To make running these commands easier, we'll install and use the IoT Core shell, which presets several frequently-used paths and variables.
make sure your technician PC has the necessary tools installed prior to creating an IoT Core image.
See Get the tools needed to customize Windows IoT Core to get your technician PC ready.
The version of ADK used must match the version of IoT Core Packages used below.
You will need the following tools installed to complete this section:
- Windows Assessment and Deployment KiT (Windows ADK)
- Windows 10 IoT Core packages
- IoT Core ADK Add-Ons
- IoT Core PowerShell environment
- A text editor like Notepad or VS Code
Create a Basic Image
Create a Workspace
In Windows Explorer, go to the folder where you installed the IoT Core ADK Add-Ons, for example, C:\IoT-ADK-AddonKit, and open IoTCorePShell.cmd. It should prompt you to run as an administrator.
This will load the PowerShell module and also check the versions of the ADK, IoT Core kit. This will also check for the test certificates in the certificate store and if not present, install them automatically.
Troubleshooting: Error: "The system cannot find the path specified". If you get this, right-click the icon and modify the path in "Target" to the location you've chosen to install the tools.
In the IoTCorePShell, create a new workspace say
C:\MyWorkspacewith an OEM name
Contosofor the architecture
New-IoTWorkspace C:\MyWorkspace Contoso arm (or) new-ws C:\MyWorkspace Contoso arm
IoT Core supports four architectures, x64,x86,arm and arm64.
Only alphanumeric characters are supported in the OEM name as this is used as a prefix for various generated file names.
This generates the IoTWorkspace.xml and sets a version number for the design, which you can use for future updates. The first version number defaults to 10.0.0.0. (Why a four-part version number? Learn about versioning schemes in Update requirements).
The required packages such as Registry.Version, Custom.Cmd and Provisioning.Auto will be imported into the workspace automatically.
- Import sample packages into the workspace. You may choose to import the packages selectively or import all.
# Importing Recovery packages from sample workspace Import-IoTOEMPackage Recovery.* (or) importpkg Recovery.* # Below example imports all packages from the sample workspace Import-IoTOEMPackage * (or) importpkg *
Import a Raspberry Pi BSP
This next step is to take the Board Support Package files and extra/build their .CAB files to include in the FFU file.
Download RPi_BSP.zip to a local directory, say
Import the bsp using Import-IoTBSP
Import-IoTBSP RPi2 C:\Downloads\RPi_BSP.zip (or) importbsp RPi2 C:\Downloads\RPi_BSP.zip
For more information on available BSPs, see Windows 10 IoT Core BSPs.
Create a test project
From the IoT Core Shell Environment, create a new product folder that uses the Raspberry Pi 2 BSP. This folder represents a new device we want to build, and contains sample customization files that we can use to start our project. Create a new product using Add-IoTProduct
``` powershell Add-IoTProduct ProductA RPi2 (or) newproduct ProductA RPi2 ``` You will be prompted to enter the **SMBIOS** information such as Manufacturer name (OEM name), Family, SKU, BaseboardManufacturer and BaseboardProduct. Here are some example values:
System OEM Name: Fabricam
System Family Name: FabricamHub
System SKU Number: AI-001
Baseboard Manufacturer Arrow
Baseboard Product: Raspberry Pi 2
The BSP name is the same as the folder name for the BSP. You can see which BSPs are available by looking in the
This creates the folder:
Every image includes a file
oemcustomization.cmd which will run on every boot up of your device. You have the ability to modify this file to customize what executes on boot up. This file is located under
C:\MyWorkspace\Source-<arch>\Products\\ProductA in this example. The contents of the file is as follows:
@echo off REM OEM Customization Script file REM This script if included in the image, is called everytime the system boots. reg query HKLM\Software\IoT /v FirstBootDone >nul 2>&1 if %errorlevel% == 1 ( REM Enable Administrator User net user Administrator p@ssw0rd /active:yes if exist C:\Data\oobe ( call folderpermissions.exe 'C:\Data\oobe -e' ) REM - Enable the below if you need secure boot/bitlocker REM Enable Secureboot REM if exist c:\IoTSec\setup.secureboot.cmd ( REM call c:\IoTSec\setup.secureboot.cmd REM ) REM Enable Bitlocker REM if exist c:\IoTSec\setup.bitlocker.cmd ( REM call c:\IoTSec\setup.bitlocker.cmd REM ) reg add HKLM\Software\IoT /v FirstBootDone /t REG_DWORD /d 1 /f >nul 2>&1 ) REM The below should be called on every boot if exist C:\RecoveryConfig\Recovery.BcdEdit.cmd ( call C:\RecoveryConfig\Recovery.BcdEdit.cmd ) REM Set the crashdump file locations to data partition, set on every boot. reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CrashControl" /v DedicatedDumpFile /t REG_SZ /d C:\Data\DedicatedDumpFile.sys /f reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\CrashControl" /v DumpFile /t REG_SZ /d C:\Data\MEMORY.DMP /f
Please be aware that security features like BitLocker and SecureBoot are disabled by default for a custom test image. If you wish to include these features (in a retail image) you can uncomment out the appropriate lines in the file, prior to building your image.
Please be aware that the commands in this file run with local system privilege.
From the IoT Core Shell, get your environment ready to create products by building all of the packages in the working folders using New-IoTCabPackage:
``` powershell New-IoTCabPackage All (or) buildpkg All ```
If you get SignTool errors when building the packages in Test mode, please run
installoemcerts.cmd to install the test certificates on your Technician PC.
Build an image
Eject any removable storage drives, including the Micro SD card and any USB flash drives.
Build the FFU image file by entering the following command in the IoT Core PowerShell Environment using New-IoTFFUImage:
New-IoTFFUImage ProductA Test (or) buildimage ProductA Test
This builds an FFU file with your basic image at
C:\MyWorkspace\Build\<arch>\ProductA\Test. This test image will include additional tools that can be used for debugging purposes. Building the final FFU file will take around 10 to 30 minutes to complete.
To direct all output to console instead of log file, add
-Verboseflag, such as the one below.
new-IoTFFUImage -Verbose ProductX Test
If you get either 0x80070005 or 0x800705b4 as an error code, unplug all external drives (including micro SD cards and USB thumb drives), and try again. If this doesn't work, go back to Set up your PC and download the samples and make sure everything's installed.
Flash a Windows IoT Core image
Now that your FFU image file is built, you can ues this file to flash and deploy th eimage to your device. Listed below ar ethe steps to flash the FFU image file to specific manufacturer devices.
You will need the following tools installed to complete this section:
- Windows IoT Core Dashboard (Raspberry Pi only)
- Dragonboard Update Tool (Qualcomm DragonBorad only)
- Deployment Imaging and Servicing and management (DICM) tool (Intel devices only)
Since we're using Raspberry Pi here, we'll start with Raspberry Pi but also explain how to flash images on other devices.
Start the Windows IoT Core Dashboard.
Plug your micro SD card into your technician PC, and select it in the tool.
From the Setup a new device section, select Broadcomm [Raspberry Pi 2 & 3] under Device Type.
Select Custom under OS Build.
Click Browse and navigate and select the FFU file you created earlier. In this case, your FFU file is located at
C:\MyWorkspace\Build\<arch>\ProductA\Test\Flash.ffu. Then click Next.
Verify that your microSD card is listed under the Drive selection.
Optionally, you can set the Device Name and Administrator Password selections for your device.
Check the I accept the software license terms checkbox (lower right) and click Install.
Windows IoT Core Dashboard will now open a command window and use DISM (Deployment Image Servicing and Management Tool) to flash the FFU file to your microSD card.
Alternatively, you can also use the DISM command to manually flash the image:
dism.exe /Apply-Image /ImageFile:"D:\flash.ffu" /ApplyDrive:\\.\PhysicalDrive0 /SkipPlatformCheck
Once the flashing process is complete, eject the microSD card from the technician PC and insert it into the Raspberry Pi. Reconnect the power to boot Windows IoT Core. You should see the IoT Core Default app, which shows basic information about the image.
Qualcomm has provided the Dragonboard Update Tool application, which we will use to flash the FFU image file to the Dragonboard 410c. You can download either the x86 or x64 version (we recommend x64).
Once you have installed the DragonBoard Update Tool, you must first place the DragonBoard device in programming mode. This is done by setting dipswitch #1 (on the backside of the device) to the ON position:
Connect the DragonBoard device to your technician PC with a microUSB cable and power on the board.
Run the DragonBoard Update Tool, browse for the FFU image file you are deploying, and press the Program button. You should see a green Connection Status, and a progress bar when the device is flashing the FFU file.
Once the flashing process is complete, disconnect power from the board, as well as the microUSB cable. You then need to flip the dipswitch #1 back to the OFF position. Reconnect the power to boot Windows IoT Core.
Apollo Lake/Braswell/Cherry Trail
We will be using the DISM (Deployment Image and Servicing Management Tool) and a bootable USB stick to flash the FFU image file to the specified Intel device (Apollo Lake/Braswell/Cherry Trail). Addition information on DISM can be found here.
Creating a USB Bootable Drive
We first need to create a bootable USB drive that we can use to boot on the specified Intel hardware device. We can use Window PE (WinPE) for this (addition info on WinPE is here).
- Install WinPE from the Windows ADK Windows Preinstallation Environment Add-ons.
- Prepare USB Drive
The USB drive you wish to use must be properly formatted before we can load WinPE on it. Follow these teps to properly format your USB drive:
- Run the
diskparttool from an administrative command prompt
list diskto see the list of available disks
select disk X, where X corresponds to the disk number of your USB drive
cleanto clean the selected disk
If you encounter the following error, run
ERROR: Failed to format "F:"; DiskPart errorlevel -2147212244
create partition primaryto create a primary partition on the disk
format fs=fat32 quickto format the drive
assignto assign the drive
diskpart. Your USB drive is now formatted and ready to have WinPE installed.
- Create WinPE working files
We now need to create a working copy of the Windows PE files on the technician PC. This can be done using the Deployment and Imaging Tools Environment command line program. The easiest way to start the
Deployment and Imaging Tools Environment is to search for deploy via Start Menu.
Run the Deployment and Imaging Tools Environment command line program as an administrator, and run the following command:
copype amd64 C:\WinPE_amd64
This will create the working copy of Windows PE files at C:\WinPE_amd64.
Insert your USB drive on he technician PC and run this command to install Windows PE on the USB drive. Make sure you can replace X with the drive letter of your USB drive:
MakeWinPEMedia /UFD C:\WinPE_amd64 X:
- Copy your FFU file to the root drive of your USB drive.
- Insert your USB drive into your Intel hardware device and boot from the USB drive. You may have to enter the BIOS (or Boot Menu) of the hardware device to specify to boot from a USB drive.
- Once the Windows PE environment boots up, you will see a command window. Change the drive and current directory to the location of your FFU file (depending on drive enumeration, it could be in C: or D: ..etc.) and run the following command to flash the FFU image file:
dism.exe /Apply-Image /ImageFile:"C:\IoT\Workspaces\ContosoWS\Build\ARM\ProductX\Test\flash.ffu" /ApplyDrive:\\.\PhysicalDrive0 /SkipPlatformCheck
Most of the time, the on-board storage target to be flashed is enumerated as
PhysicalDrive0, however, if there are multiple storage devices, it can enumerate as other drive number. You can use the
list disk command in
diskpart to verify the drive number.
- Once the flashing process is complete, power down the hardware device and remove the USB drive. Reconnect power to the hardware device to boot up Windows IoT Core.
C:\>diskpart Microsoft DiskPart version 10.0.17134.1 Copyright (C) Microsoft Corporation. On computer: LWIN-CNCY-BUILD DISKPART> list disk Disk ### Status Size Free Dyn Gpt -------- ------------- ------- ------- --- --- Disk 0 Online 447 GB 1024 KB * Disk 1 Online 167 GB 1024 KB * Disk 2 Online 14 GB 0 B * DISKPART> select disk 2 Disk 2 is now the selected disk. DISKPART> clean DiskPart succeeded in cleaning the disk. DISKPART> convert mbr DiskPart successfully converted the selected disk to MBR format. DISKPART> create partition primary DiskPart succeeded in creating the specified partition. DISKPART> format fs=fat32 quick 100 percent completed DiskPart successfully formatted the volume. DISKPART> assign DiskPart successfully assigned the drive letter or mount point. DISKPART> exit
copype amd64 C:\WinPE_amd64 MakeWinPEMedia /UFD C:\WinPE_amd64 X:
DISM Command (via WinPE on the Intel hardware device)
X:\WinPE>d: D:\>dism.exe /Apply-Image /ImageFile:"C:\IoT\Workspaces\ContosoWS\Build\ARM\ProductX\Test\flash.ffu" /ApplyDrive:\\.\PhysicalDrive0 /SkipPlatformCheck
Leave the device on for now, and continue to Lab 1b: Add an app to your image.