Freitag, 26. Februar 2016

CUL Stick flashen

Irgendwie existieren gefühlt tausend Beschreibungen dazu im Internet, es gibt viele Seiten dazu im FHEM Forum und im FHEM Wiki. Alle sind ähnlich und keine führte bei mir wirklich direkt zum Ziel. Deswegen mal wieder: ich habe alles intensiv durchprobiert und einen ziemlich simplen Weg gefunden. Aber! Dieser Weg ist heute scheinbar richtig, ob das morgen noch so ist kann ich nicht garantieren.
FHEM kann es fast automatisch und bringt fast alles mit.

Vorbereitung


Man braucht den DFU-Programmer
 sudo apt-get install dfu-programmer  

Diesen müssen wir für fhem ausführbar machen damit er nicht nur unter root läuft und wir fhem nicht zu root machen müssen!
 sudo chmod u+s /usr/bin/dfu-programmer  

Programmierung


Den CUL Stick richtig stecken - und das ist nicht einfach! Man muss die kleine Taste auf der Unterseite beim Stecken gedrückt halten!
Ich finde es geht gut mit
  1. einem USB Verlängerungskabel welches man in die USB Schnittstelle steckt, 
  2. dann setzt man den USB Stecker vorsichtig an, 
  3. hält beides (Stick und USB Kupplung/Buchse) auf dem flachen Tisch mit Daumen (Stick) und Mittelfinger (Buchse) der linken Hand fest, 
  4. drückt mit der rechten und einem kleinen Stift (Zahnstocher) den Taster und 
  5. schiebt mit Daumen den Stick, der Mittelfinger fixiert die Buchse.

Jetzt gibt man in der Kommandozeile von FHEM ein
 usb scan  

Es kommt die Auschrift: CUL_V3: flash it with: CULflash none CUL_V3

Also in die Kommandozeile genau das eingeben was er sagt (copy&paste):
 CULflash none CUL_V3  

Der Erfolg wird mit der Ausschrift:
 CULflash Validating...  
 28630 bytes used (99.85%)  
und einem Blinken des CUL Stick quittiert.

In FHEM verwenden

Wenn der Stick läuft und blinkt können wir ein erneutes usb scan eingeben. Die Ausschrift die folgt kann man wieder direkt ernst nehmen:
 ### ttyACM0: checking if it is a CUL   
 create as a fhem device with: define CUL_0 CUL /dev/ttyACM0@9600 1034   
 ### ttyAMA0: checking if it is a CUL   
 cannot open the device   
und einfach die Empfehlung in die Kommandozeile kopieren
 define CUL_0 CUL /dev/ttyACM0@9600 1034  

Update oder neu flashen

Wenn der CUL Stick mal einen neue Firmware bekommen soll, geht das auch einfach in FHEM:
 CULflash CUL_0 CUL_V3  

Man kann den CUL Stick auch löschen (Terminal)
 dfu-programmer atmega32u4 erase   
Man muss es aber normalerweise nicht, einfach rausziehen und in den Programmiermodus versetzen reicht.

Montag, 22. Februar 2016

Windows Setup Stick

Vorbemerkung

Ich installiere immer mal Windows: bei Freunden, Testsysteme, meine produktiven System neu machen usw. So oft, damit sich dass komplett lohnt was ich hier beschreibe ist es auch nicht. Aber ich bin nun mal Fan von solchen Dingen.
Ab Windows 7 kann man alle Versionen in ein Setup verpacken, auch 32 bit und 64  bit Versionen kann man mischen, was jedoch schon etwas anspruchsvoller ist.
Es gibt viele "Kochanleitungen" dafür, ich habe mir eine Art Framework mit Powershell dafür gebaut und mache es ausschließlich mit Bordmitteln. Das Powershell Script läuft nicht automatisch, ich arbeite immer nur entsprechende Zeilen ab, setze mal Kommentare und modifiziere bei Bedarf.

Wenn man sich alles in eine Script schreibt und dieses mit dem Standard ps1 benennt, sollte man unbedingt diese erste Zeile einfügen:
 Exit 0  
Das schützt vor den ungeahnten Folgen eines Doppelklicks auf die Datei.

Einfach mal einen bootfähigen USB Stick erzeugen

Die einfachste Art sich einen Windows Setup Stick zu bauen funktioniert nur für eine Windows Version. Dazu braucht man
  • einen Stick mit mindestens 4 GB.
  • ISO Image oder DVD von der Windows Version
  • Das System Tool diskpart, vorhanden ab Windows XP

Achtung: genau hinschauen! 
Alle weiteren Befehle löschen vorhanden Daten auf einem Laufwerk!

Wir stecken den Stick in eine freie USB Schnittstelle und starten eine cmd shell als Administrator: z.B.  mit Windows + x und dann Eingabeaufforderung (Administrator) und legen los:

  1. Diskpart öffnet eine neue shell, wir befinden uns jetzt innerhalb von diskpart.
  2. Mit list disk lassen wir uns die Datenträger anzeigen. Diskpart begnügt sich mit den ersten drei Buchstaben eines Befehls -> für Schreibfaule: lis dis reicht.
  3. Wir identifizieren unseren USB Stick, z.B. Datenträger 3. 
  4. Mit select disk 3 wählen wir den Datenträger aus.
  5. Mit clean wird er Stick gelöscht.
  6. Nun wird mit create partition primary eine neue Partition erzeugt und diese mit dem Befehl active als Bootpartition markiert.
  7. Formatieren erfolgt mit format fs=fat32 quick. Normalerweise wird der Stick nach Abschluss der Formatierung sofort im Explorer als Laufwerk sichtbar. Sollte das nicht so sein, geben wir noch assign ein. 
  8. Mit exit verlassen wir diskpart, mit einem weiteren exit die cmd shell.

Nun ist der Stick für immer vorbereitet, diesen Vorgang brauchen wir nur einmalig zu machen. Der Stick ist bewusst im FAT32 Format formatiert, da EFI (das moderne BIOS) nur von diesem Dateisystem booten kann. Der einmal so vorbereitete Stick kann jederzeit mit einem neuen Windows als Setup Stick ausgestattet werden. Dazu wird einfach der komplette Inhalt der DVD (ISO) auf diesen Stick kopiert, mit dem Explorer, xcopy oder was auch immer. Die Wurzelverzeichnisse der Laufwerke müssen anschließen identisch aussehen,, also keine Unterverzeichnisse anlegen oder einfach die ISO Datei kopieren! Wer nur schnell einen Setup Stick braucht ist jetzt fertig. Wer alle Windows Versionen auf einen Stick haben will muss noch ein bisschen weiter machen.

Die Basisarbeit

Wir brauchen etwas an "Umgebung", performanten Speicherplatz, Tools usw. Ich arbeite alles in einer Powershell ab und habe dafür jeweils ein paar Zeilen Script vorbereitet. Diese passe ich dann gegebenenfalls einfach an.

Ich habe kein perfektes Script, was alles alleine tut.
Ich warne davor den hier vorgestellten Code einfach auszuführen ohne, dass man verstanden hat was passiert!

Die Powershell starten wir am Besten in der ISE Version (Entwicklungsumgebung) im Administrator Kontext (also ausführen als...)
Zunächst ein paar Definitionen und Pfade erzeugen:
 ########### Basis Arbeit - unbedingt ausführen  
 ########### Erzeuge Struktur zur Image Erstellung  
 $WorkDir = "D:\WindowsSetupDir"     # Arbeitsverzeichniss, Laufwerk spielt für Performance eine Rolle  
 $Source  = "E:"             # Hier liegt die Quell DVD des aktuell zu bearbeitenden Windows  
 $USBStick = "F:\"            # Laufwerk für den Ziel USB Stick  
 # Die Pfade werden als Basis gesetzt und können für Performance auch verändert werden  
 $DistDir =  "$WorkDir\" + "distribution"  
 $bootDir =  "$WorkDir\mount" + "\" + "boot"  
 $windowsDir = "$WorkDir\mount" + "\" + "windows"   
 # Erzeuge Pfadstruktur falls nicht vorhanden  
 if( -not (Test-Path $WorkDir) ) { New-Item $WorkDir -type directory }  
 if( -not (Test-Path $DistDir) ) { New-Item $DistDir -type directory }  
 if( -not (Test-Path $bootDir) ) { New-Item $bootDir -type directory }  
 if( -not (Test-Path $windowsDir) ) { New-Item $windowsDir -type directory }  

Als Basisversion für unseren Setupstick verwenden wir immer die neueste Windows Version die wir einsetzen wollen, falls Serverversionen eine Rolle spielen, die neueste Serverversion. Diese DVD kommt ins Laufwerk (E: in meinem Beispiel) und das Arbeitsverzeichnis wird vorbereitet.
 ########### Basis DVD kopieren  
 #Prüfe ob Setup DVD im Laufwerk  
 if( -not (Test-Path $Source\) )   
 {Write-Host Setup DVD nicht vorhanden. Prüfe ob eine DVD in Laufwerk $Source eingelegt  
 Exit 1   
 }  
 # Kopiere den Inhalt der Basis DVD ins Arbeitsverzeichnis falls es leer ist  
 if( (Get-ChildItem $DistDir | Measure-Object).Count -eq 0)   
 {  
 xcopy $Source\ $DistDir /s/e  
 }  
 ##########  
Klar geht das auch einfacher, aber so gibt es ein bisschen Komfort. In meinem konkreten Beispiel habe ich Windows 10 Version 1511 vom November 2015 verwendet. Da muss man jetzt noch einen Zwischenschritt einlegen: Die Datei e:\sources\install.esd muss umgewandelt werden.
Falls eine andere Version vorliegt:
Prüfen ob die Datei e:\sources\install.wim existiert - wenn ja kann der nächste Schritt übersprungen werden.

Windows 10 MediaCreationTool

Von Windows 10 werden keine ISO Images mehr zum download angeboten, vielmehr kann man sich mit dem MediaCreationTool herunterladen "was man braucht". Ich bevorzuge dabei immer ein ISO Image, das ist universell einsetzbar. Je nach Zeitpunkt des download ändert Microsoft schon mal den Inhalt der dabei heruntergeladen wird. Die für uns wichtigste Datei ist die install.wim. Neben der Endung und Form "WIM" kann die Datei auch install.esd heißen (aktuell bei der Version 1511 ist das der Fall). ESD ist eine speziell gepackte Version des WIM Formates und kann nicht so direkt weiter verarbeitet werden. Wir müssen diese Datei erst konvertieren. Ich bin ein Freund von Boardmitteln, dass geht zwar etwas umständlich, aber ich habe alles in ein paar Zeilen Script für Powershell gepackt.
Was passiert?
  • Wir erzeugen ein temporäres virtuelles Laufwerk,
  • Das Image install.esd wird darin ausgepackt
  • Das Image install.wim wird aus dem virtuellen Laufwerk wieder erzeugt.

Alle Vorgänge für Windows Images (WIM) müssen immer pro enthaltener Windows Version durchgeführt werden.
In der Datei install.esd sind zwei Versionen enthalten. Dies können wir mit dism anzeigen lassen:
 dism /Get-WimInfo /WimFile:$DistDir\sources\install.esd  
Das cmdlet von Powershell kann dafür leider nicht verwendet werden, es kann offenbar mit esd Dateien derzeit nicht umgehen, von unsere fertigen wim Datei können wir uns das aber jederzeit anzeigen lassen:
 Get-WindowsImage -ImagePath $DistDir\sources\install.wim  

Dieser Vorgang braucht jetzt etwas Zeit.
 ########## Windows 10 Image vorbeiten - aus esd wim Datei machen  
 #   
 # VHD kann später einfach formatiert werden, ist besser als Pfad da Rechte auf Trusted Installer gesetzt werden  
 # VHD auf anderes physisches Laufwerk legen als $DistDir  
 $VHDFile = "c:\temp.vhd"  
 $VHDDrive = "V:"  
 NEW-ITEM -Path bootemup.txt -ItemType file -force | OUT-NULL  
 ADD-CONTENT -Path bootemup.txt -Value “create vdisk file=$VHDFile maximum=25000 type=expandable”   
 ADD-CONTENT -Path bootemup.txt -Value “select vdisk file=$VHDFile”   
 ADD-CONTENT -Path bootemup.txt -Value “attach vdisk”   
 ADD-CONTENT -Path bootemup.txt -Value “create partition primary”   
 ADD-CONTENT -Path bootemup.txt -Value “assign letter=$VHDDrive”   
 ADD-CONTENT -Path bootemup.txt -Value “format quick label=vhd”   
 DISKPART /S .\bootemup.txt  
 # VHD erzeugt kann später ausgeworfen und gelöscht werden  
 dism /apply-image /imagefile:$DistDir\sources\install.esd /index:1 /applydir:$VHDDrive\  
 dism /capture-image /imagefile:$DistDir\sources\install.wim /capturedir:$VHDDrive\ /Compress:max /Name:"Windows 10 Pro" /Description:"Windows 10 Pro"  # Die Description darf nicht fehlen!   
 format $VHDDrive /Q /y   
 dism /apply-image /imagefile:$DistDir\sources\install.esd /index:2 /applydir:$VHDDrive\  
 dism /capture-image /imagefile:$DistDir\sources\install2.wim /capturedir:$VHDDrive\ /Compress:max /Name:"Windows 10" /Description:"Windows 10"  
 # Jetzt beide Images wieder vereinigen  
 Export-WindowsImage -SourceImagePath $DistDir\sources\install2.wim -SourceIndex 1 -DestinationImagePath $distDir\sources\install.wim # -DestinationName "Windows 10"   
 # esd Datei und temporäre wim Datei löschen  
 del $DistDir\sources\install.esd  
 del $DistDir\sources\install2.wim  

Das erzeugte virtuelle Laufwerk können wir später auswerfen und die VHD Datei löschen. Die erzeugte install.wim von Windows 10 sollte man sich für weitere Experimente eventuell separat sichern, da die Erzeugung doch einiges an Zeit beansprucht.

Mehrere Windows Versionen

Da Microsoft seit Windows 7 beim Setup vereinfacht gesagt nur noch von einem Image (boot.wim) bootet um dann anschließen ein anderes Image (install.wim) auf den Datenträger zu kopieren, ist dieser Vorgang relativ Versionsunabhängig. Das WIM (Windows Image) Format ist zudem noch Platzsparend, da es identische Dateien nur einmal speichert. Somit belegen z.B. Windows 8.1 in 2 Varianten sowie Server 2012 R2 in 4 Varianten in einer install.wim kaum mehr Speicherplatz als ein einzelne Version, da der Code ja weitestgehend identisch ist.
Mehrere Windows Versionen in eine install.wim packen ist simpel und schnell gemacht. (wenn man nur eine Sprache (DE) und nur eine Prozessorarchitektur (64 bit) verwendet)
Genau wie bei der Vorbereitung von Windows 10 beschrieben, wird einfach pro Version (nicht pro Installationsmedium) ein "Export" des Windows Images in die Basis install.wim durchgeführt.

Es ist jetzt eine Kombination aus Handarbeit und Scriptzeilen ausführen:
  • DVD auswerfen
  • Neue Windows DVD einlegen (wieder Laufwerk E:)
  • Anzeigen lassen welche Versionen vorhanden sind
  • Die Versionen exportieren die man haben möchte  
 ######## Weitere Images exportieren  
 # Neue DVD in Laufwerk $Source  
 Get-WindowsImage -ImagePath $Source\sources\install.wim  
 # Abfrage Index Nummer  
 $a = read-host "Welches Windows Image exportieren? -a- für Abruch"  
 If ($a -eq "a") {Exit 1}   
 Export-WindowsImage -SourceImagePath $Source\sources\install.wim -SourceIndex $a -DestinationImagePath $distDir\sources\install.wim   

Damit wir alle Versionen bei der Installation auswählen können ohne einen Windows Setup Key eingeben zu müssen, brauchen wir die Datei ei.cfg im Setup Verzeichnis. Diese wird wieder einfach mit einem kurzen Script erzeugt:

 ########## Windows ohne Seriennummer installieren   
 # Windows 10 fragt nach dem Key und diese Frage könnte man überspringen  
 # mit ei.cfg kommt die Frage nach dem Key nicht  
 "[EditionID]  
 [Channel]  
 Retail  
 [VL]  
 0"| out-file -filepath "$DistDir\sources\ei.cfg"   

USB Stick

Für einen USB Setup Stick könnten wir jetzt wieder einfach alle Dateien aus dem $DistDir auf den Stick kopieren. Aber die install.wim Datei ist je nach Anzahl der integrierten Windows Versionen jetzt größer als 4 GB - die magische Grenze für FAT32. Wir müssen die install.wim also in handliche Teile splitten und es ensteht eine Gruppe aus install.swm + install<n>.swm Dateien.

Leider ist die Exclude Funktion und die Fehlerbehandlung von Copy-Item etwas grottig und ich habe es nicht besser hinbekommen:
Die erste Zeile kopiert alle Dateien auf den Stick, wenn dabei ein Fehler auftritt (WriteError: (install.wim:FileInfo)) kann man mit der zweiten Zeile, die zu große install.wim direkt gesplittet auf den Stick kopieren.

 # Alles auf USB Stick kopieren  
 Copy-Item -Path $DistDir\* -Destination $UsbStick -Recurse   
 # Image aufteilen für FAT32  
 Split-WindowsImage -ImagePath $DistDir\sources\install.wim -SplitImagePath $USBStick\sources\install.swm -FileSize 4096 -CheckIntegrity  

ISO Image

Je nach Größe der install.wim wird ein jetzt erstelltes ISO Image allerdings nicht mehr auf eine DVD passen. Ich verwende es bevorzugt für Tests mit VirtualBox oder PCs die Probleme mit dem Start von USB Sticks haben.
Wir brauchen ein zusätzliches Tool: oscdimg. Das bekommen wir aus dem aktuellsten ADK (Access und Deployment Toolkit) von Microsoft
Die Installation des ADK können wir auf zwei Punkte einschränken: Installation Windows PE (bräuchten wir für weitere Modifikationen) und Bereitstellungstools (dism).

Die Aufrufzeile ist etwas komplexer um das ISO Image wieder bootfähig zu machen.

 ######## ISO erzeugen  
 $Platform = "amd64"  
 $ADKDir = "D:\Program Files (x86)\Windows Kits\8.1\Assessment and Deployment Kit"   
 $ISOFile="d:\test.iso"  
 del $ISOFile    # falls schon vorhanden  
 $PathToOscdimg = "$ADKDir\Deployment Tools\$Platform\Oscdimg\"  
 $BootData='2#p0,e,b"{0}"#pEF,e,b"{1}"' -f "$distDir\boot\etfsboot.com","$distDir\efi\Microsoft\boot\efisys.bin"  
 & "$PathToOscdimg\oscdimg.exe" @("-bootdata:$BootData",'-u2','-udfver102',"$distDir","$ISOFile") 2>$null  

Im Gegensatz zu anderen Tools (z.B. dism) lässt sich oscdimg nicht ohne weiteres aus Powershell aufrufen, deshalb der Umweg über & und das Array mit Parametern. Außerdem liefert oscdimg einen Fehler der ignoriert werden kann, dies erledigt die Umleitung am Ende der Zeile.

Installation von zusätzlichen Dingen in das Image 

Sowohl Updates als auch zusätzliche Sprachen können direkt in die Images installiert werden. Eigentlich kann man das Setup komplett individualisieren. Ich möchte das hier nur an Hand von Updates und Sprachen zeigen.
Alles was wir bisher getan haben, passierte direkt in der Image Datei, wir haben immer nur die install.wim "gesehen".
Ab jetzt arbeiten wir innerhalb der Image Datei, dazu müssen wir mounten. Dabei die Struktur innerhalb der Image Datei in einem definierten Verzeichnis zur Verfügung gestellt. Die Basisstruktur haben wir am Anfang schon erzeugt. Um ein bestimmtes Image zu mounten hilft uns folgendes Script:

 ########## Bestimmtes Image mounten, dass Image muss ich mounten wenn ich den Inhalt des Image ändern will, z.B. Updates einspielen  
 # Jetzt Windows Image Indizies anzeigen  
 Get-WindowsImage -ImagePath $DistDir\sources\install.wim  
 # Abfrage Index Nummer  
 $a = read-host "Welches Windows Image mounten? -a- für Abruch"  
 If ($a -eq "a") {Exit 1}   
 Mount-WindowsImage -ImagePath $DistDir\sources\install.wim -Index $a -Path $windowsDir  

Das Mounten des Images funktioniert noch mit jeder Version von dism, wollen wir aber innerhalb der Images manipulieren braucht man eine dism Version mindestens so aktuell wie die Windows Version die wir gemountet haben. Theoretisch könnte man auch unter Windows 8.1 das ADK von Windows 10 installieren und müsste dism dann im ADK Pfad ausführen. Wie die cmdlets von Powershell damit zurecht kommen?

Hinweis:
Bei allen Add Package Kommandos können "0x800f081e" Fehler auftreten. Das angegebene Package ist dann nicht exakt für diese Version und wird ignoriert, das ist nicht weiter schlimm.

Updates

Updates einspielen ist relativ simpel aber Zeitaufwendig. Die Updates können z.B.  mit dem Tool wsusoffline  heruntergeladen wurden.
Beim Aufruf der Scriptzeile muss die Version beachtet werden. (w6.3 --> Windows 8.1)
Eingespielt werden können Updates im cab und msu Format.

 ########## Updates dazu Dazu ist die aktuelle DISM Version notwendig geht also nur unter Windows 10?  
 # Update Verzeichnis wsusoffline   
 $Wsus = "E:\wsusoffline"  
 Add-WindowsPackage –Path $windowsDir –PackagePath $Wsus\client\w63-x64\glb  
 Add-WindowsPackage –Path $windowsDir –PackagePath $Wsus\client\w100-x64\glb  

Je nach Anzahl der Updates kann das ganz schön dauern.

Sprache 

Die Systeme sind auch weitestgehend sprachunabhängig aufgebaut, zusätzliche Sprachen werden einfach über Language Packs (LP) dazu installiert. Zum Verständnis warum es jetzt doch nicht ganz so einfach ist:
  • Wir brauchen ein boot System welches eventuell mehrere Sprachen (auswählen) kann und alle Systemversionen installieren (auswählen) kann.
  • Leider hat MS immer wieder die Bereitstellung und Integration der Sprachpakete verändert, für Windows 10 kann man aktuell die Sprachen nur noch über die Systemsteuerung installieren.
  • Für die Änderung der Startumgebung brauchen wir Teile aus den Windows PE Images. Diese haben wir mit dem ADK schon installiert.
Die folgenden Zeilen integrieren Language Packs in die Setup Images

 ########## Sprachumgebung deutsch und englisch  
 $PathToWinPE_OCs = "$ADKDir\Windows Preinstallation Environment\$Platform\WinPE_OCs"  
 $PackageBoot = @("$PathToWinPE_OCs\WinPE-Setup-Client.cab", "$PathToWinPE_OCs\WinPE-Setup-Server.cab")  
 # Zeige Index des Boot Images   
 Get-WindowsImage -ImagePath $DistDir\sources\boot.wim  
 # Boot Image mounten - nur einmal für Setup Sprache  
 Mount-WindowsImage -ImagePath $DistDir\sources\boot.wim -Index 2 -Path $bootDir  
 #Add Packages - es können 0x800f081e Fehler auftreten  
 #boot  
 $PackageBoot | foreach {Add-WindowsPackage –Path $bootDir –PackagePath $_ }  
 $AddPath = $PathToWinPE_OCs + "\en-us"  
 gci $AddPath | foreach {Add-WindowsPackage –Path $bootDir –PackagePath $_.FullName }  
 $AddPath = $PathToWinPE_OCs + "\de-de"  
 gci $AddPath | foreach {Add-WindowsPackage –Path $bootDir –PackagePath $_.FullName }  
 #Add Language zu Windows  
 #install  
 New-Item $DistDir\langpacks -type directory  
 New-Item $DistDir\langpacks\de-de -type directory  
 Copy-Item $SourceLang\langpacks\de-de\lp.cab $DistDir\langpacks\de-de  
 Add-WindowsPackage –Path $windowsDir –PackagePath $DistDir\langpacks\de-de\lp.cab  
 #Test ob Sprache korrekt  
 & 'DISM.exe' @("/image:$windowsDir", "/distribution:$DistDir", "/Get-Intl")  
 #Defaults Sprache Zeitzone usw. setzen  
 & 'DISM.exe' @("/image:$windowsDir", "/Set-TimeZone:W. Europe Standard Time")  
 & 'DISM.exe' @("/image:$windowsDir", "/Set-AllIntl:de-DE")  
 #Lang-Ini neu machen  
 & 'Dism.exe' @("/image:$bootDir", '/gen-langINI', "/distribution:$DistDir")  
 #& 'Dism.exe' @("/image:$windowsDir", '/gen-langINI', "/distribution:$DistDir")  
 #Die Datei wird in der Quelle erzeugt muss aber auch ins boot.wim  
 Copy-Item $DistDir\sources\lang.ini $bootDir\sources   
   

WIM Datei schließen

Zum Schluss muss die gemountete Image Datei wieder geschlossen werden. Dabei kann man die gemachten Änderungen speichern oder verwerfen:

 ########## Gemountetes Image schließen  
 #Variante commit Image  
 Dismount-WindowsImage -Save -Path $windowsDir  
 Dismount-WindowsImage -Save -Path $bootDir  
 #Variante Discard Image  
 #Dismount-WindowsImage -Discard -Path $windowsDir  
 #Dismount-WindowsImage -Discard -Path $bootDir  

Zwei Architekturen x86 und amd64

Zwei Architekturen in ein install.wim Image zu packen ist relativ einfach, um dann aber wirklich installieren zu können brauchen wir eine Dual Boot Umgebung. Gestartet wird die Installation mittels WindowsPE - wir müssen also eine WindowsPE Dualboot Umgebung bauen. Das wiederum von der neuesten Version. Ich nehme als Ausgangspunkt eine x64 Umgebung und addiere eine x86 Umgebung dazu. Man braucht dazu noch die x86 boot.wim entweder von der x86 DVD (ISO) oder aus dem ADK. Der folgende Script Code ist Beispielhaft und muss der konkreten Situation angepasst werden.

 ############# Für zwei Architekturen x86 und amd64  
 #Dual Boot Image erstellen, Originaleintrag lassen, boot.wim x64 so lassen, boot.wim x86 umbenennen in boot_x86.wim und ins sources verzeichnis kopieren   
 & 'bcdedit' @("/store", "$DistDir\boot\bcd", "/enum") | select-string "osdevice" #Die GUID ermitteln vom Standard  
 #-->{7619dcc8-fafe-11d9-b411-000476eba25f}  
 & 'bcdedit' @("/store", "$DistDir\boot\bcd", "/copy", "{default}", "/d", "Windows Boot X86") # Guid merken  
 #-->{d9b3b7ea-cb40-11e4-8323-000461814078}  
 # Den kopierten Eintrag editieren/ändern  
 & 'bcdedit' @("/store", "$DistDir\boot\bcd", "/set", "{d9b3b7ea-cb40-11e4-8323-000461814078}", "device", "ramdisk=[boot]\sources\boot_x86.wim,{7619dcc8-fafe-11d9-b411-000476eba25f}")  
 & 'bcdedit' @("/store", "$DistDir\boot\bcd", "/set", "{d9b3b7ea-cb40-11e4-8323-000461814078}", "osdevice", "ramdisk=[boot]\sources\boot_x86.wim,{7619dcc8-fafe-11d9-b411-000476eba25f}")  
 # Auswahl bei Win PE aktivieren, braucht man bei Win Setup nicht?  
 #& 'bcdedit' @("/store", "$DistDir\boot\bcd", "/deletevalue", "{default}", "bootmenupolicy")   
 ############# Ende Dualboot  

Empfehlung

Der USB Stick zum Setup ist schnell erzeugt und man braucht keine speziellen Tools. Mehrere Windows Versionen (7, 8, 8.1 und 10 oder auch Server 2008 und 2012) in einer Sprache und einer Prozessor Architektur lassen sich leicht auf einen Stick vereinen. Man hat damit ein universelles Setup Medium an der Hand.
Von Zeit zu Zeit kann man mal Updates integrieren, vor allem wenn Service Packs erschienen sind. Ansonsten ist der Zeitaufwand hierfür relativ groß.
Die Mischung von Sprachversionen und Prozessor Architekturen auf einem Setup Medium ist aufwendig und kompliziert. Lohnt sich meines Erachtens nicht!