PC Einschaltzeit ermitteln

[RSBasic]

Ich weiß, woran das liegt. Es liegt daran, dass Windows nicht komplett herunterfährt, wenn du auf Herunterfahren klickst. Diese Funktion nennt sich Schnellstart und soll das Starten von Windows beschleunigen. Deshalb läuft deine Runtime weiter.
Wenn du richtig herunterfahren möchtest, gibt es mehrere Möglichkeiten:
a) Halte die Shift-/Umschalttaste gedrückt während du auf Herunterfahren klickst.
oder
b) Schnellstart deaktivieren:
1. Win+R drücken
2. Folgendes ausführen: ::{26EE0668-A00A-44D7-9371-BEB064C98683}\0\::{025A5937-A6BE-4686-A844-36FE4BEC8B6D}\pageGlobalSettings
3. Klicke auf: Einige Einstellungen sind monentan nicht verfügbar
4. Folgendes deaktivieren: Schnellstart aktivieren (empfohlen)

Dann fährt er auch richtig herunter.

[HemSA]

Danke an alle, jetzt kann ich weitermachen mit dem Programm.

[H.Brill]

Danke, gut zu wissen.
Es ist mir deshalb nie aufgefallen, da ich die Steckdosenleiste, die auf dem Schreibtisch liegt, danach auch ausschalte.
Ist irgendwie ne alte Angewohnheit von früher von mir (Blitzschutz bei Gewitter).

[HemSA]

Hallole,
steh mal wieder auf dem Schlauch.

Wenn ich diesen Kode laufen lasse werden alle Debugwerte angezeigt. Danach werden alle 10 Sekunden im Debug Fenster der neue Wert von Date() angezeigt.

Soweit so gut, Zeitschleife ist auf 10 Sekunden zum Test eingestellt wo die Procedure WindowsStartTime immer wieder aufgerufen wird.

Aber wenn ich die EndProcedure von Zeile 38 nach Zeile 52 verschiebe wird nur der Debug Date() in Zeile 34 angezeigt. Die anderen Debugs werden nicht angezeigt. Macht auch Sinn da ProcedureReturn r1 in Zeile 37 aktiv ist. Wenn ich allerdings ProcedureReturn r1 in Zeile 37 inaktiv mache dann habe ich einen Stack overflow.

Was ich will ist das auch die anderen Debug angezeigt werden und in Abhaengikeit von laufzeit.q ich verschiedene Funktionen machen kann (PC Neustart jetzt oder spaeter).

Die Abfrage soll natürlich nicht alle 10 Sekunden sein, spaeter sagen wir mal alle 30 Minuten.

Danke schon mal wer mich da auf den richtigen Weg bringt damit es ohne Fehler für mich nachvollziehbar funktioniert ohne overflow oder andere Fehler.

Code: Alles auswählen

;Version 1

Global laufzeit.q, a$, r1, ElapsedTime.q


Enumeration ; Windows 

  #Restartkontrolle 
  
EndEnumeration 


Enumeration ; Gadgets 
  
  ; Restartkontrolle 
  #Restartkontrolle_txtInfo1
  #Restartkontrolle_txtInfo2
  #Restartkontrolle_txtInfo3
  
EndEnumeration 

; Retrieves the number of milliseconds that have elapsed since the system was started.
Import ""
  GetTickCount64()
EndImport

;Procedure Auswertungsprogramm()
Procedure WindowsStartTime()
;  Protected r1, ElapsedTime.q
  
  ElapsedTime.q = GetTickCount64()
  r1 = Date() - ElapsedTime.q / 1000
  
  Debug Date()
 ;Debug Date() - WindowsStartTime()
  
  ProcedureReturn r1
;EndProcedure

Debug FormatDate("%YYYY.%MM.%DD %HH:%II:%SS", WindowsStartTime())
Debug r1
Debug WindowsStartTime()
Debug Date()
Debug ElapsedTime.q
Debug Date() - WindowsStartTime()
laufzeit.q = Date() - WindowsStartTime()
Debug laufzeit.q
;If laufzeit.q > 90000 ;25 Stunden
;If laufzeit.q > 10000 ;Für Test

; ProcedureReturn r1
EndProcedure

If laufzeit.q > 10000 ;Für Test
    MessageRequester("Info", "PC hatte seit 24 Stunden keinen Restart", #PB_MessageRequester_Ok | #PB_MessageRequester_Info)
    
    Result = MessageRequester("", "PC jetzt neu starten?", #PB_MessageRequester_YesNo)
  a$ = "Ergebnis des Requesters war: "
  If Result = #PB_MessageRequester_Yes       ; Ja-Schalter wurde gedrückt
    a$ + "Ja"
  Else                                       ; Nein-Schalter wurde gedrückt
    a$ + "Nein"
  EndIf
  MessageRequester("Information", a$, #PB_MessageRequester_Ok)
  
EndIf
  
;EndProcedure


Procedure Zeitschleife(hWnd.l, uMsg, IDEvent, dwTime)
  Static Init
  If Init = #False
     Init = #True
  EndIf
 
  Select IDEvent
    Case 1
 ;     Auswertungsprogramm()
      WindowsStartTime()
  EndSelect
 
EndProcedure


Procedure Hauptprogramm()

  Protected quit.l 
  Protected EventID.l 
  Protected EventGadget.l 
  Protected EventWindow.l



If OpenWindow(#Restartkontrolle, 0, 0, 400, 100, "22.08.2023 - Neustartkontrolle", #PB_Window_ScreenCentered | #PB_Window_SystemMenu| #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget | #PB_Window_TitleBar )
 
       TextGadget(#Restartkontrolle_txtInfo1, 50,  20, 100, 20, "xxxx")
       TextGadget(#Restartkontrolle_txtInfo2, 50,  40, 150, 20, "xxxx")
       TextGadget(#Restartkontrolle_txtInfo3, 50,  60, 100, 20, "xxxx")
 
       Delay(3000)
       SetWindowState(#Restartkontrolle, #PB_Window_Minimize)
   
;       Auswertungsprogramm()
       WindowsStartTime()
       SetTimer_(WindowID(#Restartkontrolle), 1, 10000, @Zeitschleife()) ;==> kurze Zeit für Test
        
    Repeat 
    
    EventID     = WaitWindowEvent() 
    EventGadget = EventGadget() 
    EventWindow = EventWindow()     
   
    Select EventID
    
      Case #PB_Event_CloseWindow
      
        Select EventWindow 
            
            Case #Restartkontrolle    :  quit =1      
 
        EndSelect
    
        
    EndSelect
    
    Until Quit=1


    KillTimer_(WindowID(#Restartkontrolle), 1)
 
EndIf

EndProcedure

Hauptprogramm()

[RSBasic]

Ich habe ein paar wichtige Tipps:
1. Ich empfehle dir EnableExplicit, sonst übersiehst du schnell Fehler.
2. Warum benutzt du SetTimer_()? Du kannst die native Funkton AddWindowTimer() benutzen.
3. Bitte achte auf korrekte Einrückung. Drücke Strg+A und anschließend Strg+I. Dann ist alles richtig eingerückt. Sonst wird es zu unübersichtlich.
4. Bitte benutze nur englische Variablennamen, kein denglisch oder deutsch.

Nun zur Ursache deines Problems:
Warum du ein Stackoverflow bekommst, liegt daran, weil du die Prozedur WindowsStartTime() unendlich rekursiv aufrufst. D.h. in WindowsStartTime() rufst du WindowsStartTime() auf und dort wird wieder WindowsStartTime() aufgerufen und das immer und immer wieder.
Ich hab mal im Debugger nachgeschaut. Deine Prozedur wird über 8000x rekursiv aufgerufen und dann kommt es zum StackOverflow, weil diese Prozedur nie beendet wird.

[Axolotl]

Moin HemSA,

Ich habe mir mal erlaubt, deinen Code (teilweise) in meinen Programmierstil zu portieren.
Vielleicht hilft es dir ja ein bisschen, Du must es natürlich nicht so machen.

P.S: Es ist auch kein fertiges Program, sondern nur ein Gerüst.

Code: Alles auswählen

;Version 1.1 

EnableExplicit  ; always recommended to find typos 

; Retrieves the number of milliseconds that have elapsed since the system was started.
Import ""
  GetTickCount64()
EndImport 

; --- Define UI constants ---

Enumeration EWindow ; Windows   .. I like named enums this way 
  #WINDOW_Main    ; #Restartkontrolle 
EndEnumeration 

Enumeration EGadget ; Gadgets 
  #GADGET_txtInfo1
  #GADGET_txtInfo2
  #GADGET_txtInfo3
EndEnumeration 

Enumeration ETimer  ; Timer 
  #TIMER_CheckInterval
  #TIMER_MinimizeWindowAfterStart 
EndEnumeration 

; --- 

Procedure.i CheckStartTime() 
  Protected tickcount.q, dt, ret 

  tickcount = GetTickCount64() / 1000  ;:Debug "TickCount [s]  = " + tickcount 

  dt = Date()  
  ret = dt - tickcount 

  SetGadgetText(#GADGET_txtInfo1, "TickCount = " + tickcount + " s") 
  SetGadgetText(#GADGET_txtInfo2, "Heute     = " + FormatDate("%YYYY.%MM.%DD %HH:%II:%SS", dt) + " | " + dt) 
  SetGadgetText(#GADGET_txtInfo3, "Differenz = " + FormatDate("%YYYY.%MM.%DD %HH:%II:%SS", ret) + " | " + ret) 

  ; check and execute actions ... 
  If ret > 1000000 
    Debug #PB_Compiler_Procedure + "() -- ret = " + ret + " >  1000000 " 
  ElseIf ret > 100000 
    Debug #PB_Compiler_Procedure + "() -- ret = " + ret + " >  100000 " 
  ElseIf ret > 10000 
    Debug #PB_Compiler_Procedure + "() -- ret = " + ret + " >  10000 " 

;   ProcedureReturn #True   ; exit program 
  EndIf 
  ProcedureReturn #False  ; keep program running 
EndProcedure

; ---

Procedure OpenWindowMain()
  If OpenWindow(#WINDOW_Main, 0, 0, 400, 100, "22.08.2023 - Neustartkontrolle", #PB_Window_ScreenCentered | #PB_Window_SystemMenu| #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget | #PB_Window_TitleBar )
    TextGadget(#GADGET_txtInfo1, 50,  20, 350, 20, "xxxx")
    TextGadget(#GADGET_txtInfo2, 50,  40, 350, 20, "xxxx")
    TextGadget(#GADGET_txtInfo3, 50,  60, 350, 20, "xxxx")

    ProcedureReturn #True 
  EndIf 
  ProcedureReturn #False 
EndProcedure 

; ---

Procedure OnEventTimer()
  Debug #PB_Compiler_Procedure + "() " 
EndProcedure 

; ---

Procedure main() 
  If OpenWindowMain() 
    ; minimize the window 3s after program start 
    AddWindowTimer(#WINDOW_Main, #TIMER_MinimizeWindowAfterStart, 3000) 

    ; call check procedure 
    AddWindowTimer(#WINDOW_Main, #TIMER_CheckInterval, 10000)  ; check every 60 s 

    ; First possibility -> use own OnEventTimer() procedure 
    BindEvent(#PB_Event_Timer, @OnEventTimer(), #WINDOW_Main, #TIMER_CheckInterval) 

    ; call it here to update UI 
    CheckStartTime()  
    
    Repeat  ; main loop     
      Select WaitWindowEvent() 
        Case #PB_Event_CloseWindow 
          Break  ; leave the main loop 
; --- not necessary, because of one window only ... 
;         Select EventWindow  
;           Case #WINDOW_Main 
;             Break      
;         EndSelect

        Case #PB_Event_RestoreWindow  
          ; show window for 3 s only, minimize again 
        ; AddWindowTimer(#WINDOW_Main, #TIMER_MinimizeWindowAfterStart, 3000) 

        Case #PB_Event_Timer 
          Select EventTimer() 
            Case #TIMER_MinimizeWindowAfterStart 
              SetWindowState(#WINDOW_Main, #PB_Window_Minimize) 
              RemoveWindowTimer(#WINDOW_Main, #TIMER_MinimizeWindowAfterStart) 

            ; Second possibility -> use main loop 
            Case #TIMER_CheckInterval 
              If CheckStartTime()  ; <> ZERO -> leave the main loop 
                Break 
              EndIf 

          EndSelect   

      EndSelect   
    ForEver  

    RemoveWindowTimer(#WINDOW_Main, #TIMER_CheckInterval) 
  EndIf

  ProcedureReturn 0  ; default 
EndProcedure

End main()

[HemSA]

Danke euch beiden, RSBasic und Axoloti,
werde mal eure Ideen zu Herze nehmen.

Warum verwend ich SetTimer_()? Das liegt daran das ich seit früheren Zeiten das mal so gemacht habe.
Ich mache nicht viele Programme, ist auch schon etwas her. Aber ich mache eigentlich kaum nur Windows Programme.
Ich mache eigentlich meistens Prozedur Programme die im Hintergrund laufen und dabei immer in einem bestimmten Zeitcyklus Daten hergeben die dann ausgewertet werden um dann folgende Schritte zu machen. Das einzigste Windows ist eigentlich nur mein Begrüssungs Window das dann sich nach 3 Sekunden verkleinert.
So brauche im Hauptgerüst nichts aendern da auch meistens die Hauptprozedur Auswertungsprogramm heisst.

Wie in diesem Programm das ich machen will. Es laeuft im Hintergrund und wenn die Einschaltzeit 25 Stunden überschritten ist soll es eine Warnung ausgeben das der PC neu gestartet werden soll. Danach mache ich noch eine Abfrage ob es nun gleich sein soll oder spaeter. Und das laeuft immer im Hintergrund ab.

Kann AddWindowTimer() auch Prozeduren immer zu einem bestimmten Takt aufrufen? In der Hilfe steht da nur was von Windows die immer wieder aufgerufen werden.

Wie gesagt, werde mir mal eure Ideen zu Herzen nehmen, für neue Programmierstils soll man ja auch immer offen sein.

Ich habe mit PB 2.93 angefangen.

[Axolotl]

Hi HemSA,

ja, genau dafür ist AddWindowTimer() gemacht.
Die Procedure "CheckStartTime(()" in meinen Beispielen ist so zu sagen die Auswertefunktion.
Windows hat diese Grenzen bei der elapsed Time, das wird dann wohl auch für AddWindowTimer() für die Timeout Zeit gelten.

Code: Alles auswählen

; #USER_TIMER_MINIMUM   ==  $0000000A  == 10
; #USER_TIMER_MAXIMUM   ==  $7FFFFFFF  == 2147483647

Absolut, ich denke das man als "Programmierer" nie auslernt - das ist ja gerade das coole... (für mich zumindest)
TIPP: Ich versuche immer so zu coden, dass ich in vielen Jahren noch einfach verstehe was der Code macht. Und wenn die Konstanten, Variablen und Proceduren entsprechende Namen haben, dann braucht es (eigentlich) auch nicht mehr so viel Kommentare.....

BTW: Ich würde dein Program so bauen.... (Es fehlen noch die Shutdown-Teile, stattdessen gibt es eine InfoBox())

Zum Thema Shutdown gibt es im englischen Forum diesen Beitrag.

Code: Alles auswählen

 
;Version 1.2 

EnableExplicit  ; always recommended to find typos 

; Retrieves the number of milliseconds that have elapsed since the system was started.
Import ""
  GetTickCount64()
EndImport 

; --- Define UI constants ---

Enumeration EWindow ; Windows   .. I like named enums this way 
  #WINDOW_Main 
EndEnumeration 

Enumeration EGadget ; Gadgets 
  #GADGET_txtInfo1
  #GADGET_txtInfo2
  #GADGET_txtInfo3
  #GADGET_btnRestart 
EndEnumeration 

Enumeration ETimer  ; Timer 
  #TIMER_CheckInterval        
  #TIMER_MinimizeWindowDelay  
EndEnumeration 

; --- constants --- 

#Caption$       = "Restart Monitor"
#MainCaption$   = #Caption$ + " 0." + #PB_Editor_CompileCount

; 
#TIME_OneHourInSeconds         = 3600    ; 1 hour * 60 min * 60 sec 
; 
CompilerIf #PB_Compiler_Debugger  
#INTERVAL_CheckInterval        = 10000    ; for test reasons 10 s  
CompilerElse 
#INTERVAL_CheckInterval        = #TIME_OneHourInSeconds * 1000  ; every hour in runtime version 
CompilerEndIf  
#INTERVAL_MinimizeWindowDelay  =  3000 ; == 3 s 


; --- sweet little helpers --- 

Macro InfoBox(Message) 
  MessageRequester(#Caption$, Message, #PB_MessageRequester_Info | #PB_MessageRequester_Ok) 
EndMacro 

Macro AskYNBox(Question) 
  Bool(MessageRequester(#Caption$, Question, #PB_MessageRequester_Info | #PB_MessageRequester_YesNo) = #PB_MessageRequester_Yes) 
EndMacro 

; --- 

Procedure.i CheckStartTime(MaxRunningHours)  ; 
  Protected tickcount.q, dt, hours, days, text$ 

  tickcount = GetTickCount64() / 1000  ; tickcount in seconds  

  ; update UI 
  hours = tickcount / #TIME_OneHourInSeconds 
  SetGadgetText(#GADGET_txtInfo1, "PC is running " + hours + " hour(s).") 

  ; converted to days and hours 
  days  = hours / 24 
  hours % 24  
  SetGadgetText(#GADGET_txtInfo2, "that are " + days + " day(s) and " + hours + " hour(s)." ) 

  ; computer start time 
  dt = Date() - tickcount      ; we need seconds here 
  SetGadgetText(#GADGET_txtInfo3, "Computer Starttime = " + FormatDate("%YYYY.%MM.%DD %HH:%II:%SS", dt)) 

  ; check on ... what ever 
  If tickcount > MaxRunningHours * #TIME_OneHourInSeconds 

    SetWindowState(#WINDOW_Main, #PB_Window_Normal) 

    InfoBox("Okay. Here we want to force a new start of the computer ....... ") 

    DisableGadget(#GADGET_btnRestart, 0)  ; Enable Button 
  EndIf 

  ProcedureReturn #False  ; keep program running 
EndProcedure


; --- UI Window Main --- 

Procedure OpenWindowMain()
  If OpenWindow(#WINDOW_Main, 0, 0, 400, 128, #MainCaption$, #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_ScreenCentered) 
    StickyWindow(#WINDOW_Main, 1)   ; always on top 

    TextGadget(#GADGET_txtInfo1, 40, 16, 360, 20, "")
    TextGadget(#GADGET_txtInfo2, 40, 40, 360, 20, "")
    TextGadget(#GADGET_txtInfo3, 40, 64, 360, 20, "") 
    ; 
    ButtonGadget(#GADGET_btnRestart, 80, 96, 240, 24, "Restart") 
    DisableGadget(#GADGET_btnRestart, 1)  ; keep Button Disabled 

    ProcedureReturn #True   ; success 
  EndIf 
  ProcedureReturn #False  ; failure 
EndProcedure 

; ---

Procedure main() 
  Protected MaxRunningHours, tmp  

  MaxRunningHours = 25 ; hours (as default) 
  ; 
  ; you can forward the value as a parameter (e.g. in the startup link) 
  If CountProgramParameters() 
    tmp = Val(ProgramParameter(0)) 
    If tmp > 10 And tmp < 1000  ; check some limits (I dont know?) 
      MaxRunningHours = tmp           :Debug "MaxRunningHours set to " + MaxRunningHours 
    EndIf 
  EndIf 

  If OpenWindowMain() 
    ; minimize the window 'Seconds' after program start 
    AddWindowTimer(#WINDOW_Main, #TIMER_MinimizeWindowDelay, #INTERVAL_MinimizeWindowDelay) 

    ; call check procedure 
    AddWindowTimer(#WINDOW_Main, #TIMER_CheckInterval, #INTERVAL_CheckInterval)  ; check every 60 s 

    ; call it here to update UI 
    CheckStartTime(MaxRunningHours)  
    
    Repeat  ; main loop     
      Select WaitWindowEvent() 
        Case #PB_Event_CloseWindow 
          Break  ; leave the main loop 
        ; If AskYNBox("Are you sure you want to end the program now?") 
        ;   Break  ; leave the main loop 
        ; EndIf 

        Case #PB_Event_RestoreWindow                              :Debug "Restore Window" 
          ; show window for 'Seconds' only, minimize again 
          ; --> remove the comment char in the next line (and see what happend) 
        ; AddWindowTimer(#WINDOW_Main, #TIMER_MinimizeWindowDelay, #INTERVAL_MinimizeWindowDelay) 

        Case #PB_Event_Timer  ; on Timer event 
          Select EventTimer()   ; look which timer event occured 
            Case #TIMER_MinimizeWindowDelay 
              SetWindowState(#WINDOW_Main, #PB_Window_Minimize) 
              ; 
              ; only a single shot, we remove the timer here ... 
              RemoveWindowTimer(#WINDOW_Main, #TIMER_MinimizeWindowDelay)  

            Case #TIMER_CheckInterval 
              If CheckStartTime(MaxRunningHours)  ; <> ZERO -> leave the main loop 
                Break 
              EndIf 

          EndSelect   

        Case #PB_Event_Gadget  ; on Gadget Event 
          Select EventGadget() 
            Case #GADGET_btnRestart 
              If AskYNBox("Are you sure you want to restart your computer now?") 
                ;
                ; space for improvement 
                ; 
              EndIf 
              Debug "Restart the system now or later or never ..." 
          EndSelect 

      EndSelect   
    ForEver  

    RemoveWindowTimer(#WINDOW_Main, #TIMER_CheckInterval) 
  EndIf

  ProcedureReturn 0  ; default 
EndProcedure

End main()

[HemSA]

Danke Euch beiden, habe viele neue Funktionen gelernt, die ich jetzt umsetzen werde.

[HemSA]

Nun ist es erledigt und es klappt wie ich will.

Den Shotdown have ich so erledigt:

Code: Alles auswählen

#EWX_LOGOFF   = 0 ; Meldet sich neu am Netzwerk an
#EWX_SHUTDOWN = 1 ; Fährt den Computer herunter
#EWX_REBOOT   = 2 ; Startet den Computer neu
#EWX_FORCE    = 4 ; Beendet alle Programme ohne Aufforderung an den Benutzer
#EWX_POWEROFF = 8 ; Fährt den Computer herunter und schaltet ihn ab, wenn möglich

Procedure Shutdown( flags.l ) 
  Privileges.TOKEN_PRIVILEGES 
  OpenProcessToken_(GetCurrentProcess_(), 40, @hToken) 
  Privileges\PrivilegeCount           = 1 
  Privileges\Privileges[0]\Attributes = #SE_PRIVILEGE_ENABLED 
  LookupPrivilegeValue_(0, "SeShutdownPrivilege", @Privileges\Privileges[0]\Luid) 
  AdjustTokenPrivileges_(hToken, 0, @Privileges, 0, 0, 0) 
  CloseHandle_(hToken) 
  ExitWindowsEx_(flags, 0) 
EndProcedure 


Shutdown( #EWX_REBOOT )

Danke nochmal an euch drei.