4. shutdown timer programmiert

shutdown timer programmiert

  • G

    Hallo,

    ich habe nun einen shuttime timer programmiert. bestimmt nicht sauber, aber er funktioniert...

    nur habe ich ein Problem beim stellen der Zeit zum herunterfahren.
    Habe dies mit dem button updown versucht zu lösen, aber es klappt leider nicht so wie ich es mir vorstelle... eigentlich sollte er wenn ich down drücke um 10min runterzählen, aber das geht erst wenn ich hochgezählt habe und dann zählt er auch nur runter bis zum voreingestellten Wert... hier der code:

    __fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{       fortschritt=0;                         //Fortschritt vom countdown (anzeige)
        h = ShutT.getTimeNow()/60;             //ergibt lokale Zeit Stunden
        m = ShutT.getTimeNow()%60;             //ergibt lokale Zeit Minuten
        hstell = h;                            //default Stellzeit
        mstell = 0;
        sprintf(buffer,"%02d:%02d",h,m);
        LokalZeit->Caption=buffer;
        sprintf(buffer,"%02d:%02d",hstell,mstell);
        StellZeit->Caption=buffer;
}

void __fastcall TForm1::UpDown1Click(TObject *Sender, TUDBtnType Button)
{    switch (Button) {

     case btNext:                                 //Stellzeit um 10min vor
                  if(mstell==50)
                  {     hstell++;
                        mstell=0;
                        if(hstell>23)hstell=0;
                  }else mstell+=10;

                  break;

     case btPrev:                                //Stellzeit um 10min zurück
                  if(mstell==0) {
                  mstell=50;
                  hstell-=1;
                  if(hstell<0){hstell=23;}
                  }else mstell-=10;

                  break;
     }
     sprintf(bufferstell,"%02d:%02d",hstell,mstell);  //Stellzeit wird in bufferstell gelesen
     StellZeit->Caption=bufferstell;                  //Stellzeit wird zur anzeige geschickt
}

    Ich weiß nicht woran es liegt, weil er ja eigentlich mit dem code hier

    if(mstell==0) {
                  mstell=50;
                  hstell-=1;
                  if(hstell<0){hstell=23;}
                  }else mstell-=10;

    immer runterzählen sollte...

    vielleicht kann mir einer helfen, wäre nice

    MfG Gustl

    0
  • G

    wenn anstatt updown zwei normale buttons verwende funktionierts...

    woran könnte das liegen?

    0
  • ?

    Mal so probiert?

    void __fastcall TForm1::UpDown1Click(TObject *Sender, TUDBtnType Button)
{
  if(Button == 0)
   Panel1->Caption = "Oben geklickt";
  else
   Panel1->Caption = "Unten geklickt";
}
    0
  • G

    Das gleiche Problem... komm einfach nicht drauf woran es liegen könnte..

    ich mache ja mit den buttons auch nichts anderes, kopiere eben nur den code von den 2 case in die buttons, die machen alles richtig.... komich

    0
  • ?

    Ist zwar (wenn auch nur knapp) am Thema vorbei, aber warum machst du das so kompliziert? Wenn du anstatt von hstell und mstell nur eine Variable benutzt (zB CountDown), die den Countdown bis zum Neustart in Minuten angibt sparst du dir einiges an Verwaltung/Überprüfung. Ich poste mal Pseudo-Code, um das zu veranschaulichen:

    class MyClass /* soll die Formularklasse sein*/
   unsigned int CountDown_; // Countdown bis zum Reboot in Sekunden

public:
   MyClass() : CountDown_( 5 * 60 ) // Default Countdown 5 Minuten

   void on_click_updown_hours( UDType nType )
   {
      if( btPrevious == nType )
      {
         decrease_timer( 3600 );
      }
      else
      {
         increase_timer( 3600 );
      }
   }

   void on_click_updown_minutes( UDType nType )
   {
      if( btPrevious == nType )
      {
         decrease_timer( 60 );
      }
      else
      {
         increase_timer( 60 );
      }
   }

   void on_click_updown_seconds( UDType nType )
   {
      if( btPrevious == nType )
      {
         decrease_timer( 1 );
      }
      else
      {
         increase_timer( 1 );
      }
   }

   void increase_timer( unsigned int Duration )
   {
      // Timer verlängern
      CountDown_ += Duration;
      update_timer_display();  
   }

   void decrease_timer( unsigned int Duration )
   {
      if( CountDown_ >= Duration )
      {
         // Timer verkürzen
         CountDown_ -= Duration; 
      }
      else
      {
         // Timer darf nicht unter 0 fallen (oder sonstigem Minimum)
         CountDown_ = 0;
      }
      update_timer_display();
   }

private:
   void update_timer_display()
   {
      unsigned int Hours   = CountDown_ / 3600;
      unsigned int Minutes = (CountDown_ / 60) % 60;
      unsigned int Seconds = CountDown_ % 60;

      // UpDown Control für Stunden aktualisieren
      if( UpDownHours->Value != Hours )
      {          
        UpDownHours->Value     = Hours;
      } 
      // UpDown Control für Minuten aktualisieren
      if( UpDownMinutes->Value != Minutes )
      {
         UpDownMinutes->Value   = Minutes;
      }
      // UpDown Control für Sekunden aktualisieren
      if( UpDownSeconds->Value != Seconds )
      {
         UpDownSeconds->Value   = Seconds;      
      }
   }
};

    Naja, sowas in der Art halt.

    0
  • G

    Es gibt viele Wege dies zu realisieren. Danke.

    Aber was ich nicht verstehe ist, warum es mit buttons geht und mit dem updown button eben nicht.

    hier nochmal der code mit buttons und updown:

    //unit1.cpp
//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{        mstell = 0;
         hstell = 0;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::UpDown1Click(TObject *Sender, TUDBtnType Button)
{
        switch (Button) {

     case btNext:                                 //Stellzeit um 10min vor
                  if(mstell==50) {
                  hstell++;
                  mstell=0;
                  if(hstell>23)hstell=0;
                  }else mstell+=10;

                  break;

     case btPrev:                                //Stellzeit um 10min zurück
                  if(mstell==0) {
                  mstell=50;
                  hstell-=1;
                  if(hstell<0){hstell=23;}
                  }else mstell-=10;

                  break;
     }
     sprintf(buffer,"%02d:%02d",hstell,mstell);  //Stellzeit wird in bufferstell gelesen
     StaticText1->Caption=buffer;                  //Stellzeit wird zur anzeige geschick
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BupClick(TObject *Sender)
{           if(mstell==50)
            {
            hstell++;
            mstell=0;
            if(hstell>23)hstell=0;
            }else mstell+=10;

        sprintf(buffer,"%02d:%02d",hstell,mstell);  //Stellzeit wird in bufferstell gelesen
        StaticText1->Caption=buffer;                //Stellzeit wird zur anzeige geschick
}
//---------------------------------------------------------------------------
void __fastcall TForm1::BdownClick(TObject *Sender)
{           if(mstell==0) {
            mstell=50;
            hstell-=1;
            if(hstell<0){hstell=23;}
            }else mstell-=10;

        sprintf(buffer,"%02d:%02d",hstell,mstell);  //Stellzeit wird in bufferstell gelesen
        StaticText1->Caption=buffer;                //Stellzeit wird zur anzeige geschick
}
//---------------------------------------------------------------------------

    //unit1.h
//---------------------------------------------------------------------------

#ifndef Unit1H
#define Unit1H
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ComCtrls.hpp>
#include <stdio.h>
#include <Buttons.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// IDE-managed Components
        TStaticText *StaticText1;
        TUpDown *UpDown1;
        TBitBtn *Bup;
        TBitBtn *Bdown;
        void __fastcall UpDown1Click(TObject *Sender, TUDBtnType Button);
        void __fastcall BupClick(TObject *Sender);
        void __fastcall BdownClick(TObject *Sender);
private:  int hstell, mstell;
          char buffer[9];	// User declarations
public:		// User declarations
        __fastcall TForm1(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

    sollte das nicht das gleich sein und beides funktionieren... ?

    0
  • D

    Bei UpDown wird das OnClick nur aufgerufen, wenn der Wert geändert wurde.
    Wenn das Ding schon am Anschlag steht - nach dem Start - passiert nix.

    (Setz min/ max auf grosse Werte - plus bzw. minus) und Start- Wert auf 0.

    Gruss
    Frank

    0
  • G

    Hallo Frank, leider verstehe ich nicht ganz was du meinst.

    Wo soll ich hier min und max festlegen?

    0
  • G

    UpDown1->Min=-200;
    UpDown1->Max=200;

    Danke, jetzt gehts 🙂

    0
Anmelden zum Antworten