Schwierigkeiten beim Ausführen mit Powershell

status_Q · 19. Mai 2020

Hallo Community,

ich bin blutiger Anfänger im Scripting. Ich weiße lediglich etwas fortgeschritteneres Wissen in der SPS Programmierung (Siemens Step 7, TIA) auf.

Hintergrund:

ein Speichermedium "USB" wird auf einer Testapplikation fest verbaut. Mittels einer Testsoftware werden USB-Ports durchgeschaltet. Das Script soll immer dann ausgeführt werden, wenn ein Portwechsel stattgefunden hat. Dieser Testaufbau wird flexibel an einigen Geräten eingesetzt. Da sich der Laufwerksbuchstabe jedes mal ändert soll ein universell einsetzbares Script erstellt werden um Kommunikation und Datentransfer testen zu können.

Ziel meines Scriptes ist es, anhand der DeviceID eines USB-Sticks, den Laufwerksbuchstaben zu ermitteln. Wurde dieser gefunden, soll eine .txt-Datei gelesen werden.

Durch intensive Recherche und "Try-and-Error" konnte ich einen kleinen Erfolg verbuchen. Mein Script wird erfolgreich in der PowerShell ISE ausgeführt.

#-----------------Start des Scripts------------------------------------#
write-output @("Starte Auslesen der angeschlossenen USB Drives")


    start-sleep -s 3
#-----------------------------------------------------------------------#

                  #-------Wird einmalig benötigt um die DeviceID des USB Sticks manuell auszulesen und in Variablen zu schreiben-------#
#-------------------------------------------------------------------------------------------------------------------------------#
    
                            #------Anzeige aller Laufwerk vom Typ "Entfernbar"---------#
 <#                                   Get-Volume|where {$_.Drivetype -eq"Removable"}
 
                                    #-----------Filterung von USB Geräte-------------#
                                    Get-Disk|where {$_.BusType -eq"USB"}|Select-Object SerialNumber, FriendlyName

                                            #------------Filterung von USB-Geräten anhand von Beschreibung und DeviceID----------#

                                    Get-WmiObject Win32_USBControllerDevice | ForEach-Object { [wmi]$_.dependent } |where-object -FilterScript {($_.deviceid)}| select-Object description,deviceid

                            #-----------Hier wird der Laufwerkszuordnung ermittelt, es werden alle Pfade von USB Sticks angezeiget. Richtiger Pfad wird manuell in Variable $DUMMYDISKPATH eingetragen-----------#

                                    Get-Volume |where {$_.Drivetype -eq"Removable"}|ForEach-Object {
                                        $VolObj = $_
                                            $ParObj = Get-Partition | Where-Object { 
                                                                    $_.AccessPaths -contains $VolObj.Path }

                                        if ($ParObj.DiskId) {
                                                $ParObj |Select-Object -Property Diskpath
                                                
                                        if ($ParObj.DriveLetter) {
                                                $ParObj |Select-Object -Property Driveletter
                                                
                                    }}}                                                                                                             

                   
            <# Get-WmiObject Win32_USBControllerDevice | ForEach-Object { 
                            [wmi]$_.dependent } |Where-Object -FilterScript {
                            ($_.deviceid -eq "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0")
                            } | select-Object description,deviceid   
            #>

#>

#---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#


#------------------------------------------------Schleife für Auslesen der USB-Daten-----------------------------------------------------------------#
    $loopUSBcheck=1
 Do{

         $TestingDriveUSB = New-Object -TypeName PSObject
             $DUMMYusbID = "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0" #Hier wird die DeviceID des USB Sticks geschrieben
             $DUMMYDISKPATH = "\\?\usbstor#disk&ven_verbatim&prod_store_n_go&rev_pmap#0700039a2b79de49&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}" #Hier wird der Pfad des USB Sticks aus Diskpath geschrieben
             $DUMMYletter = $ParObj.DriveLetter
  
                     $TestingdriveName = Get-WmiObject Win32_USBControllerDevice | ForEach-Object { #Hier wird nach der Art des Sticks mit der DeviceID gesucht
                                [wmi]$_.dependent } |Where-Object -FilterScript {
                                    ($_.deviceid -eq $DUMMYusbID)
                                           }| select-Object description
                                           

                     $TestingdriveID = Get-WmiObject Win32_USBControllerDevice | ForEach-Object {  #Hier wird die DeviceID anhand von Statischer Variable gesucht
                                [wmi]$_.dependent } |Where-Object -FilterScript {
                                    ($_.deviceid -eq $DUMMYusbID)
                                            } | select-Object deviceid

  
                       $TestingdriveLetter = Get-Volume |where {$_.Drivetype -eq"Removable"}|ForEach-Object { #Hier wird der Laufwerksbuchstabe ermittelt
                                $VolObj = $_
                                $ParObj = Get-Partition | Where-Object { 
                                     $_.AccessPaths -contains $VolObj.Path }

                                if ($ParObj.DiskId -eq $DUMMYDISKPATH) {
                                   $ParObj |Select-Object -Property Diskpath
                                                
                                if ($ParObj.DriveLetter -eq $DUMMYletter) {
                                   $ParObj |Select-Object -Property Driveletter
                                                
                                    }}}

#--------------------------------------------------Ausgabe der ermittelten USB-Daten in einer Tabelle-------------------------------------------------------------------------#

          $TestingDriveUSB|Add-Member -MemberType NoteProperty -Name DeviceID -Value $TestingdriveID                                                                          
          $TestingDriveUSB|Add-Member -MemberType NoteProperty -Name Art -Value $TestingdriveName
          $TestingDriveUSB|Add-Member -MemberType NoteProperty -Name Driveletter -Value $DUMMYletter

    start-sleep -s 3

        echo $TestingDriveUSB
        
$loopUSBcheck
    $loopUSBcheck++
}
Until(($TestingDriveUSB.Driveletter -eq $DUMMYletter) -and ($TestingdriveID.deviceid -eq $DUMMYusbID) -or ($LoopUSBcheck -gt 25)){break}  
#-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------#

#-------------Laufwerk mounten + Laufwerkswechsel-----------------------#

write-output @("Greife auf Laufwerk zu.....")
    start-sleep -s 3
if ($Pfad=$TestingDriveUSB.Driveletter +":\"){
    Set-Location $Pfad
        Write-Output "Teste Laufwerkswechsel..."
            start-sleep -s 3
             Test-Path $Pfad 
                write-output "$Pfad Laufwerkswechsel gültig!"}
else {Write-Output "Mounten fehlgeschlagen, da $Pfad und $TestingDriveUSB.Driveletter unterschiedlich"}
     
#----------------------------------------------------------------------#

#---------Suche Dateien-------------------------------------------------------------------------------#

Echo "Suche Dateien....."
    start-sleep -s 3

#----------------------Wird benötigt um Dateien in Konsole anzuzeigen---------------------------------#

        <#Get-ChildItem $Pfad -Recurse | where {$_.Extension -eq".txt"} | % {
            Write-Output $_.FullName}
        #>
#-----------------------------------------------------------------------------------------------------#

          if (Get-ChildItem $Pfad -Recurse | where {$_.Extension -eq".txt"} | % {
                 Write-Output $_.FullName} ){ 
                    write-output "Suche erfolgreich"}
         else { 
                write-output "Suche fehlgeschlagen"}{break}
  
#----------------------------------------------------------------------------------------------------#

#----------------------------------Lese Datei--------------------------------------------------------#

Echo "Starte Auslesen...."
 start-sleep -s 3
    Get-Content -Path $Pfad\HalloWelt.txt
        if (Get-Content -Path $Pfad\HalloWelt.txt){
                Write-Output "Auslesen erfolgreich"}
        else{
                Write-Output "Fehlgeschlagen!"}{break}
#---------------------------------------------------------------------------------------------------#

#----------------------------Wechsle Laufwerkverzeichnis--------------------------------------------#
Set-Location C:\
#---------------------------------------------------------------------------------------------------#


read-host -Prompt "exit"

Führe ich das Script allerdings direkt in der PowerShell Konsole oder via Verknüpfung aus, wird mir der Laufwerksbuchstabe des Sticks nicht mehr angezeigt. Dadurch kann ich nicht mehr das Verzeichnis wechseln und auch nicht die Datei lesen.

Ich hoffe auf höfliche und Konstruktive Kritik sowie Hilfestellung zu meiner Thematik.

Sollten noch mehr Infos benötigt werden, lasst es mich gerne Wissen.

Vielen Herzlichen Dank

Beste Grüße

Status_Q

MurdocX · 19. Mai 2020

Der Teil unter "#------Anzeige aller Laufwerk vom Typ "Entfernbar"---------#" sollte auskommentiert sein?

Puh. Der Code ist - mit Verlaub - wirklich unsauber geschrieben. Da muss dringend mehr Ordentlichkeit rein. Gerade bei der Größe...

Manchmal Echo, dann wieder write-output dann mit @ Klammer ()
Befehle sind nicht ausgeschrieben (where ?) > where-object
Abschnitte laufen über Region https://devblogs.microsoft.com/scripting/use-regions-in-powershell-ise-2/
Variablen deklarierst du oben einmal, nicht bei jedem DoLoop
Kommentare kommen an den Zeilenanfang, nicht zwischendrin
Ein Befehl pro Zeile bspw.

Zitat

#Hier wird nach der Art des Sticks mit der DeviceID gesucht
$TestingdriveName = Get-WmiObject -Class Win32_USBControllerDevice |
ForEach-Object -Process { [wmi]$_.dependent} |
Where-Object -FilterScript { ($_.deviceid -eq $DUMMYusbID) }|
Select-Object -Property description

Warum verwendest du eigentlich Start-Sleep?

Fragen über Fragen... Übrigens willkommen an Board ;-)

bearbeitet 19. Mai 2020 von MurdocX

status_Q · 19. Mai 2020

ganz links im Code ist der beginnt ein Mehrzeiliger Kommentar. Der komplette Block ist auskommentiert.

MurdocX · 19. Mai 2020

Siehe Edit.

Schau Dir bitte mal IseSteroids an. Das gibts auch in einer Testversion, die sollte für Dein Script reichen. Dann siehst du die Probleme schneller.

Diese Objekte werden erst innerhalb der DoLoop-Schleife definiert und es ist zum Schleifenende nicht klar, ob diese überhaupt existieren. Abschlussbedingen werden vorher definiert und nur gefüllt. Das Objekt sollte dann schon Instanziert (erstellt) worden sein. Die letzten Klammern und das "break" haben da nichts verloren, denn die Schleife wird mit Until beendet und irgendwie wieder geöffnet als neue Schleife.

https://www.windowspro.de/script/schleifen-powershell-foreach-while-do-until-continue-break


}
Until(($TestingDriveUSB.Driveletter -eq $DUMMYletter) -and ($TestingdriveID.deviceid -eq $DUMMYusbID) -or ($loopUSBcheck -gt 25)){
    break
}

bearbeitet 19. Mai 2020 von MurdocX

status_Q · 19. Mai 2020

Hallo MurdocX,

Herzlichen Dank für die Begrüßung und deiner Verbesserungsvorschläge.

die echo-Ausgaben sind wohl noch Altlasten aus meinen Anfangszeiten der php Programmierungen.

echo ersetzt durch "write-output"
@ und () wurden bei den Ausgaben ebenfalls entfernt
where wurde durch where-object ersetzt
Region wurden eingepflegt
Variablen wurden jetzt vor DO-Loop deklariert
Kommentare am Zeilenanfang
Code habe ich neu strukturiert -->ein Befehlt pro Zeile
Break wurde entfernt

Zitat

Warum verwendest du eigentlich Start-Sleep?

wenn ich das Script in der ISE ohne start-Sleep ausführe, "Springt" das script förmlich ohne jegliche Ausgabe an read-host -prompt "Exit". Durch Eingabe von Bspw. Enter werden dann alle Meldungen ausgegeben.

Zitat

Schau Dir bitte mal IseSteroids an. Das gibts auch in einer Testversion, die sollte für Dein Script reichen. Dann siehst du die Probleme schneller.

wird ich mal testen. Danke

Zitat


}
Until(($TestingDriveUSB.Driveletter -eq $DUMMYletter) -and ($TestingdriveID.deviceid -eq $DUMMYusbID) -or ($LoopUSBcheck -gt 25))

Zitat

Diese Objekte werden erst innerhalb der DoLoop-Schleife definiert und es ist zum Schleifenende nicht klar, ob diese überhaupt existieren. Abschlussbedingen werden vorher definiert und nur gefüllt. Das Objekt sollte dann schon Instanziert (erstellt) worden sein. Die letzten Klammern und das "break" haben da nichts verloren, denn die Schleife wird mit Until beendet und irgendwie wieder geöffnet als neue Schleife.

aber genau das möchte ich. Erst wenn Driveletter und DeviceID matchen soll die Schleife beendet werden. Falls dies nicht geschieht (PC vergibt nach Portwechsel neuen Laufwerksbuchstaben, USB-Stick fehlt, USB-Port falsch verdrahtet ect.), wird die Schleife weitere 25 mal ausgeführt und anschließend beendet.

Überarbeiteter Code:


#region  -----------------Start des Scripts------------------------------------
write-output "Starte Auslesen der angeschlossenen USB Drives"
#start-sleep -s 3
#endregion


#region -------Wird einmalig benötigt um die DeviceID des USB Sticks manuell auszulesen und in Variablen zu schreiben-------

    
#------Anzeige aller Laufwerk vom Typ "Entfernbar"---------#
<#Get-Volume|
    where-object {$_.Drivetype -eq"Removable"}

-----------Filterung von USB Geräte-------------
Get-Disk|
	where-object{$_.BusType -eq"USB"}|
		Select-Object SerialNumber, FriendlyName

#------------Filterung von USB-Geräten anhand von Beschreibung und DeviceID----------#
Get-WmiObject Win32_USBControllerDevice | 
    ForEach-Object { [wmi]$_.dependent } |
        where-object -FilterScript {($_.deviceid)}|
            select-Object description,deviceid

#-----------Hier wird der Laufwerkszuordnung ermittelt, es werden alle Pfade von USB Sticks angezeiget. Richtiger Pfad wird manuell in Variable $DUMMYDISKPATH eingetragen-----------#
Get-Volume |
    where-object {$_.Drivetype -eq"Removable"}|
        ForEach-Object {$VolObj = $_
            $ParObj = Get-Partition | 
                Where-Object {$_.AccessPaths -contains $VolObj.Path }
                    if ($ParObj.DiskId) {$ParObj |
                        Select-Object -Property Diskpath
                    if ($ParObj.DriveLetter) {$ParObj |
                    Select-Object -Property Driveletter
}}}                                                                                                             

                   
<# Get-WmiObject Win32_USBControllerDevice | 
    ForEach-Object {[wmi]$_.dependent } |
        Where-Object -FilterScript{($_.deviceid -eq "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0")}| 
            select-Object description,deviceid   
#>

#>
#endregion



#region------------------------------------------------Schleife für Auslesen der USB-Daten-------------------------------------------------------------
#Variable wird Initialisiert
$loopUSBcheck=1
#Hier wird die DeviceID des USB Sticks geschrieben
$DUMMYusbID = "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0"
#Hier wird der Pfad des USB Sticks aus Diskpath geschrieben 
$DUMMYDISKPATH = "\\?\usbstor#disk&ven_verbatim&prod_store_n_go&rev_pmap#0700039a2b79de49&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}" 
$DUMMYletter = $ParObj.DriveLetter
 Do{
$TestingDriveUSB = New-Object -TypeName PSObject

#Hier wird nach der Art des Sticks mit der DeviceID gesucht
    $TestingdriveName = Get-WmiObject Win32_USBControllerDevice | 
        ForEach-Object { [wmi]$_.dependent } |
            Where-Object -FilterScript {($_.deviceid -eq $DUMMYusbID)}|
                select-Object description
                                           
#Hier wird die DeviceID anhand von Statischer Variable gesucht
    $TestingdriveID = Get-WmiObject Win32_USBControllerDevice |
        ForEach-Object {[wmi]$_.dependent } |
            Where-Object -FilterScript {($_.deviceid -eq $DUMMYusbID)}|
                select-Object deviceid

#Hier wird der Laufwerksbuchstabe ermittelt
    $TestingdriveLetter = Get-Volume |
        Where-Object {$_.Drivetype -eq"Removable"}|
            ForEach-Object {$VolObj = $_
                $ParObj = Get-Partition |
                    Where-Object {$_.AccessPaths -contains $VolObj.Path}
                        if ($ParObj.DiskId -eq $DUMMYDISKPATH) {$ParObj |
                            Select-Object -Property Diskpath
                        if ($ParObj.DriveLetter -eq $DUMMYletter) {$ParObj |
                            Select-Object -Property Driveletter
}}}

#--------------------------------------------------Ausgabe der ermittelten USB-Daten in einer Tabelle------------------------------------------------------------
$TestingDriveUSB|Add-Member -MemberType NoteProperty -Name DeviceID -Value $TestingdriveID                                                                          
$TestingDriveUSB|Add-Member -MemberType NoteProperty -Name Art -Value $TestingdriveName
$TestingDriveUSB|Add-Member -MemberType NoteProperty -Name Driveletter -Value $DUMMYletter

   # start-sleep -s 3
Write-Output $TestingDriveUSB
        
$loopUSBcheck
    $loopUSBcheck++
}
Until(($TestingDriveUSB.Driveletter -eq $DUMMYletter) -and ($TestingdriveID.deviceid -eq $DUMMYusbID) -or ($LoopUSBcheck -gt 25))  
#endregion

#region-------------Laufwerk mounten + Laufwerkswechsel-----------------------

write-output "Greife auf Laufwerk zu....."
   # start-sleep -s 3
if ($Pfad=$TestingDriveUSB.Driveletter +":\"){
    Set-Location $Pfad
        Write-Output "Teste Laufwerkswechsel..."
            #start-sleep -s 3
             if (Test-Path $Pfad){ 
                    write-output "$Pfad Laufwerkswechsel gültig"}}
else {Write-Output "Mounten fehlgeschlagen, da $Pfad und $TestingDriveUSB.Driveletter unterschiedlich"}
     
#endregion

#region---------Suche Dateien-------------------------------------------------------------------------------

Write-Output "Suche Dateien....."
    #start-sleep -s 3

#----------------------Wird benötigt um Dateien in Konsole anzuzeigen---------------------------------
<#Get-ChildItem $Pfad -Recurse | 
	where {$_.Extension -eq".txt"} | 
 		% {Write-Output $_.FullName}
 #>

if (Get-ChildItem $Pfad -Recurse | 
    where {$_.Extension -eq".txt"} |
        % {Write-Output $_.FullName} )
            {write-output "Suche erfolgreich"}
else {write-output "Suche fehlgeschlagen"}
  
#endregion

#region----------------------------------Lese Datei--------------------------------------------------------

write-output "Starte Auslesen...."
 #start-sleep -s 3
    Get-Content -Path $Pfad\HalloWelt.txt
        if (Get-Content -Path $Pfad\HalloWelt.txt){
                Write-Output "Auslesen erfolgreich"}
        else{Write-Output "Fehlgeschlagen!"}
#endregion

#region----------------------------Wechsle Laufwerkverzeichnis--------------------------------------------
Set-Location C:\
#endregion---------------------------------------------------------------------------------------------------


read-host -Prompt "exit"

Sunny61 · 19. Mai 2020

Ohne auf deinen Code einzugehen, installiere dir Visual Studio Code. Das Programm ist kostenlos von Microsoft und wird noch weiterentwickelt. Die ISE wird nicht mehr weiterentwickelt. Im Visual Studio Code brauchst Du nur noch eine Erweiterung für die Powershell, schon kannst Du loslegen.

Diese Sleep Sachen brauchst Du auch in der ISE nicht, Du kannst dir mit F9 sog. Haltepunkte setzen. Einfach in die gewünschte Zeile klicken, F9 drücken, schon wird der Code nur bis dahin ausgeführt. Das, und noch viel mehr, funktioniert auch in Visual Studio Code. Unbedingt anschauen!

BOfH_666 · 19. Mai 2020

Ich würde auch eher VSCode empfehlen, auch weil Du, wenn Du eventuell mal mit Powershell 7 weitermachen willst, dann sowieso umsteigen müsstest. ;-)

Wie wär's, wollen wir zusammen Deine Aufgabe mal in seine Einzelheiten zerlegen und so Dein Script eventuell ein bissl professioneller gestallten? Ich hab nicht wirklich alles verstanden, aber vielleicht fangen wir mit dem an, was ich verstanden habe. ;-) Wenn's um die Verbindung von physischem und logischem Laufwerk und Partition und Gerät und so weiter geht, mach ich mir auch jedesmal n' Knoten ins Hirn. Besonders, wenn's dann auch noch mit WMI losgeht. Die modernere Variante von WMI ist CIM - ist in der Beziehung aber auch nicht wirklich einfacher. Aber es gibt ja 's Internet. Dieser folgende Schnipsel besorgt uns schon mal die angeschlossenen USB-Datenträger mit Laufwerksbuchstaben, Beschreibung, Name und PNPDeviceID:

Get-CimInstance -ClassName Win32_DiskDrive -Filter 'InterfaceType = "USB"' | 
ForEach-Object {
    $RAW = $_
    Get-CimAssociatedInstance -ResultClassName Win32_DiskPartition -InputObject $_ |
    Get-CimAssociatedInstance -ResultClassName Win32_LogicalDisk |
    Select-Object -Property DeviceID, Description, VolumeName, @{Name = 'PNPDeviceID'; Expression = { $RAW.PNPDeviceID } }
}

So. jetzt bist Du wieder dran. Was willst Du damit machen?

bearbeitet 19. Mai 2020 von BOfH_666
Code korrigiert

status_Q · 19. Mai 2020

Hallo Zusammen,

Herzlichsten Dank für das rasche Feedback. Visual Studio Code mit PowerShell wurde installiert und einsatzbereit.

@BOfH_666 gerne können wir mein Script in seine Einzelteile zerlegen. Viele Wege führen schließlich zum Ziel. Das Problem mit CIM hatte ich bereits in der Anfangsphase, dass mir dort die DeviceID des Geräts nicht eindeutig ausgegeben wird. Siehe hierzu meinen Screenshot.

BOfH_666 · 19. Mai 2020

vor 9 Minuten schrieb status_Q:

Das Problem mit CIM hatte ich bereits in der Anfangsphase, dass mir dort die DeviceID des Geräts nicht eindeutig ausgegeben wird.

Ooops ... da ich nur noch sehr selten mit USB-Sticks arbeite, hab ich nur noch einen hier und da fällt das nicht auf. ;-) ... schau ich mir gleich mal an.

Zitat

Siehe hierzu meinen Screenshot.

Bitte keine Screenshots von Code oder Konsolen-Output oder so posten. Das ist häufig sehr schlecht zu lesen und wenn man davon etwas weiterverwenden wollte, müsste man es abtippen. Einfach den Text posten und auch als Code formatieren. :thumb1:

Edit:

So ... hab den Code oben angepasst ... so sollte es klappen.

bearbeitet 19. Mai 2020 von BOfH_666

status_Q · 19. Mai 2020

Super, vielen Dank. Schau ich mir morgen an. Jetzt ist erstmal Feierabend

bearbeitet 19. Mai 2020 von status_Q

daabm · 19. Mai 2020

Und um mal PowerShell komplett auszublenden: Schau Dir dringend mal den USBDLM von Uwe Siebert an. Der macht vieles schon automatisch, was Du gerade mühsam nachprogrammierst.

Oft hilft es, nicht erst mit dem eigenen Lösungsansatz in ein Forum zu gehen, sondern direkt mit dem zu lösenden Ursprungsproblem :-)

Ich zitiere nur mal einen Absatz aus der Hilfe:

[OnArrival]
open="%windir%\explorer.exe" %root%

So wird z.B. beim Anschließen eines USB-Laufwerks der Windows-Explorer gestartet, %root% ersetzt USBDLM dabei durch das Stammverzeichnis des angeschlossenen Laufwerks, z.B. U:\.

Das macht imho genau das, was Du suchst. Und statt explorer.exe kann da natürlich auch powershell.exe -file xyz.ps1 -newdrive %root% stehen - Du verstehst meinen Gedanken?

Du kannst aber gerne nativ in PowerShell weitermachen - ich würde da aber nur ungern unterstützen, weil das quasi "von 0 auf 100 in 1 Sekunde" ist. Eigentlich bräuchtest Du einen PnP-Eventhandler...

bearbeitet 19. Mai 2020 von daabm

status_Q · 20. Mai 2020

@daabm Der Dienst ist mir auch schon vor die Füße gestolpert, während ich nach Input für mein Script gesucht habe. Leider fällt dieser aus Lizenztechnisches Gründen und Vorgaben aus der Obrigkeit der IT-Administratoren raus (Stichwort:"Nicht freigegebene Dienste von dritten"). Trotzdem, herzlichsten Dank für diesen Einwand.

Das ich mit meinem Script einen Vollsprint in die Materie hinlege und "von 0 auf 100" starte habe ich bereits bemerkt. Aber da muss ich jetzt durch

@BOfH_666 Durch die Abänderung von dir, kann ich mir jetzt Unterschiedliche DeviceID´s der Geräte anzeigen lassen. Im nächsten Schritt würde ich jetzt die gewünschte PNPDeviceID in eine Variable schreiben. In etwa so:

 if ($RAW.PNPDeviceID -eq "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0") {
        $DUMMYDeviceID = $RAW.PNPDeviceID 
            Write-Output "USB erkannt"
 }
else {
    Write-Output "USB nicht erkannt"
}

wenn ich davon ausgehe, dass die -Property DeviceID von CIM = Laufwerksbuchstabe des USB-Sticks ist und ich das ganze Testweiße ausgebe:

 if ($RAW.PNPDeviceID -eq "USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0") {
        $DUMMYDeviceID = $RAW.PNPDeviceID 
        write-Output $RAW.DeviceID
            Write-Output "USB erkannt"         
 }
else {
    Write-Output "USB nicht erkannt"
}

-------------------------------
  Ausgabe in Konsole:
   
   DeviceID Description        VolumeName PNPDeviceID
-------- -----------        ---------- -----------
E:       Wechseldatenträger Transcend  USBSTOR\DISK&VEN_JETFLASH&PROD_TRANSCEND_64GB&REV_1100\CCF2QI87N652XP2V&0
Q:       Wechseldatenträger VERBATIM   USBSTOR\DISK&VEN_VERBATIM&PROD_STORE_N_GO&REV_PMAP\0700039A2B79DE49&0
\\.\PHYSICALDRIVE1
USB erkannt

folglich habe ich echt Schwierigkeiten, mir den Laufwerksbuchstaben ausgeben zu lassen.

BOfH_666 · 20. Mai 2020

Du machst es Dir gern schwerer als nötig, oder? ;-)

Ich weiß ja nicht, mit wievielen USB-Sticks Du da hantieren willst und wie stark sich die in der PNPDeviceID unterscheiden - besonders, wenn es USB-Sticks der gleichen Marke sind - aber ich könnte mir vorstellen, dass ein Teil der PNPDeviceID auch genügt, um einen bestimmten Stick eindeutig zu identifizieren. Ich hier im folgenden Schnipsel habe ich einfach mal nur den letzten Teil Deiner PNPDeviceID benutzt.

$USBStorageDeviceList = 
Get-CimInstance -ClassName Win32_DiskDrive -Filter 'InterfaceType = "USB"' | 
ForEach-Object {
    $RAW = $_
    Get-CimAssociatedInstance -ResultClassName Win32_DiskPartition -InputObject $_ |
    Get-CimAssociatedInstance -ResultClassName Win32_LogicalDisk |
    Select-Object -Property DeviceID, Description, VolumeName, @{Name = 'PNPDeviceID'; Expression = { $RAW.PNPDeviceID } }
}

$matchPattern = [REGEX]::Escape('0700039A2B79DE49&0')
$DesiredDevice = 
$USBStorageDeviceList | Where-Object -Property PNPDeviceID -Match -Value $matchPattern

$DesiredDevice.DeviceID

Vielleicht machst Du doch nochmal einen kleinen Schritt zurück und schaffst Dir wenigstens die essenziellsten Grundlagen von Powershell drauf. Ich empfehle dafür immer noch gern den Video-Kurs vom Erfinder: Getting Started with PowerShell 3.0 ... oder wenn Du lieber was zum Nachschlage möchtest: Windows PowerShell™ 4: TFM ... und wenn dann noch zeit ist: The Unofficial PowerShell Best Practices and Style Guide

bearbeitet 20. Mai 2020 von BOfH_666

status_Q · 25. Mai 2020

vielen Dank für die tatkräftige Unterstützung an alle Beteiligten. Ich melde mich aus meinem langen Wochenende zurück. Ich beherzige eure Vorschläge und führe mir erst einmal die Basics zu Gemüte. Dennoch waren eure Ansätze sehr vielversprechend und Aufschlussreich. Nochmals vielen Dank und einen guten Start in die Woche!

Anmelden

Schwierigkeiten beim Ausführen mit Powershell

Empfohlene Beiträge

status_Q 0

Link zu diesem Kommentar

MurdocX 949

Link zu diesem Kommentar

status_Q 0

Link zu diesem Kommentar

MurdocX 949

Link zu diesem Kommentar

status_Q 0

Link zu diesem Kommentar

Sunny61 806

Link zu diesem Kommentar

BOfH_666 577

Link zu diesem Kommentar

status_Q 0

Link zu diesem Kommentar

BOfH_666 577

Link zu diesem Kommentar

status_Q 0

Link zu diesem Kommentar

daabm 1.354

Link zu diesem Kommentar

status_Q 0

Link zu diesem Kommentar

BOfH_666 577

Link zu diesem Kommentar

status_Q 0

Link zu diesem Kommentar

Schreibe einen Kommentar

Menu

Aktivitäten