Taschenlampe 1.3.2

unit uFenster;
// ***********************************************************************
// K L A S S E : TLampenGUI
// -----------------------------------------------------------------------
// Version : 1.3
// Autor    : S. Spolwig, 2005
//            nach einer Vorlage von Christian Steinbrucker, OSZ TIEM, Berlin
// Aufgabe : GUI fuer die Taschenlampe
// Compiler : DELPHI 6
// Aenderung: V. 1.0 - 26-AUG-05   TTaschenlampe
//               1.1 - 27-AUG-05   TLampe ausgelagert
//               1.2 - 06-SEP-05   TBatterie ausgelagert, liefert konst. Spannung
//                                 TGluehlampe - Unterklasse
//               1.3 - 01-OKT-05   Spannung und Helligkeit sinken
// ***********************************************************************

interface
// =======================================================================
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, ExtCtrls,ComCtrls,
uTaschenlampe;

type
TLampenGUI = class(TForm)
    GehaeusePnl   : TPanel;
    LampenShp     : TShape;
    AufschriftLbl : TLabel;
    SchalterUpDown: TUpDown;
    LaufzeitTm    : TTimer;

    procedure FormCreate(Sender: TObject);
    procedure SchalterUpDownClick(Sender: TObject; Button: TUDBtnType);
    procedure LaufzeitTmTimer(Sender: TObject);

private
     procedure Darstellen(TLa : TTaschenlampe);
end;

var
LampenGUI   : TLampenGUI;
Taschenlampe: TTaschenlampe;

implementation
{$R *.dfm}
// =======================================================================

procedure TLampenGUI.FormCreate(Sender: TObject);
// -----------------------------------------------------------------------
begin
AlphaBlend   := true; // nur wenn es flackert ///////////////
Taschenlampe := TTaschenlampe.Create;
end;

procedure TLampenGUI.SchalterUpDownClick(Sender: TObject; Button: TUDBtnType);
// -----------------------------------------------------------------------
begin
if (SchalterUpDown.Position >= 1)
then
    begin
      Taschenlampe.Einschalten;
      SchalterUpDown.Position := 0
    end
else Taschenlampe.Ausschalten;
Darstellen (Taschenlampe);
end;

Procedure TLampenGUI.Darstellen (TLa : TTaschenlampe);
// -----------------------------------------------------------------------
// Auftrag: anbnehmende Helligkeit mit RGB-Farben steuern; Timer starten,
//          wenn nicht leuchtet, dann Timer abstellen
// vorher : TLa leuchtet
// nachher: Helligkeit angezeigt
// -----------------------------------------------------------------------
var
H : double;
rot,gruen, blau : TColor;

Begin
If TLa.Leuchtet = true
then
    begin
      LaufzeitTm.Enabled := true;

      H := TLa.GetHelligkeit;

      rot   := Round (255 * H/100);
      gruen := Round (255 * H/100);
      blau := Round ( 0 * H/100) + 10; // etwas nach grau hin korrigieren

      LampenShp.brush.color := RGB(rot,gruen,blau);
    end
else
    begin
      LampenShp.brush.color := RGB(0,0,0);
      LaufzeitTm.Enabled := false;
    end;
End;

procedure TLampenGUI.LaufzeitTmTimer(Sender: TObject);
// -----------------------------------------------------------------------
begin
   Darstellen (Taschenlampe);
end;

END. // -------- UNIT -------------.

UNIT uTaschenlampe;
(* ******************************************************************** *)
(* K L A S S E : TTaschenlampe                                          *)
(* -------------------------------------------------------------------- *)
(* Version     : 1.3                                                    *)
(* Autor       :                                                        *)
(* Beschreibung: Die Klasse abstrahiert und modelliert eine Taschenlampe*)
(*               mit einer diskreten Gluehlampe und 3 x 1.5 V Batterien.*)
(* Compiler    : Delphi 6.0                                             *)
(* Aenderungen : V. 1.2   - 01-OKT-05   TGluehlampe, TBatterie          *)
(*                  1.3                 abnehmende Helligkeit durch     *)
(*                                      Reduzierung der Spannung        *)
(* ******************************************************************** *)

INTERFACE
// =======================================================================

uses uGluehLampe, uBatterie;

type
TTaschenlampe = class(TObject)
   private
    Lampe     : TGluehLampe;
    Batterie1,
    Batterie2,
    Batterie3 : TBatterie;
    Schalter : boolean;

   public
    constructor Create;
    procedure   Einschalten;
    procedure   Ausschalten;
    function    Leuchtet : boolean;
    function    GetHelligkeit : integer;
end;

(* -------------------- B e s c h r e i b u n g -------------------------

Oberklasse    :
Bezugsklassen : TBatterie, TGluehlampe     import:

Methoden
--------
Einschalten
Auftrag: Schalter auf ein und Lampe mit Batteriespannung versorgen
vorher :
nachher: done

Ausschalten
Auftrag: Schalter auf aus und Spannung an der Lampe auf 0
vorher :
nachher: done

GetHelligkeit
Anfrage: nach der aktuellen Helligkeit der Lampe, Spannung sinken lassen,
           neue Spannung an Lampe
vorher : -
nachher: done

Leuchtet
Anfrage: ob die Taschenlampe 'brennt'
vorher :
nachher: leuchtet, wenn Lampe Licht gibt und Batteriespannnung > 0 und Schalter auf EIN.
           Lampe bekommt aktuelle Batteriespannung

--------------------------------------------------------------------- *)

IMPLEMENTATION
// ====================================================================

constructor TTaschenlampe.Create;
// --------------------------------------------------------------------
begin
inherited Create;
Lampe     := TGluehLampe.Create;
Batterie1 := TBatterie.Create;   // 3 Batt. einbauen
// Batterie2 := TBatterie.Create;
// Batterie3 := TBatterie.Create;
Schalter := false // aus
end;

procedure TTaschenlampe.Einschalten;
// --------------------------------------------------------------------
var U : double;

begin
Schalter := true;
U := Batterie1.GetSpannung; //+ Batterie2.GetSpannung + Batterie3.GetSpannung;
Lampe.SetSpannung(U);
end;

procedure TTaschenlampe.Ausschalten;
// --------------------------------------------------------------------
begin
Schalter := false;
Lampe.SetSpannung(0);
end;

function TTaschenlampe.Leuchtet : boolean;
// --------------------------------------------------------------------
begin
Result := (Lampe.GetLicht = true) AND (Batterie1.GetSpannung > 0) AND (Schalter = true);
if true
then Lampe.SetSpannung(Batterie1.GetSpannung); // kriegt neue Spannung
end;

function TTaschenlampe.GetHelligkeit : integer;
// --------------------------------------------------------------------
begin
Result := Lampe.GetHelligkeit; // Aufruf durchreichen
end;

END. // -------- UNIT -------------

UNIT uLampe;

///// alles unverändert

UNIT uGluehlampe;
(* ******************************************************************** *)
(* K L A S S E : TGluehlampe                                            *)
(* -------------------------------------------------------------------- *)
(* Version     : 1.3                                                    *)
(* Autor       :                                                        *)
(* Beschreibung: Die Klasse abstrahiert und modelliert eine Lampe 4.5 V *)
(*               mit einer einer zufälligen Lebensdauer.                *)
(*               Helligkeit nimmt um einen festen Betrag propotional    *)
(*               zur Spannung ab                                        *)
(* Compiler    : Delphi 6.0                                             *)
(* Aenderungen : V. 1.3 - 01-OKT-05   GetHelligkeit                     *)
(* ******************************************************************** *)

INTERFACE
// =======================================================================
uses uLampe;

type
TGluehlampe = class(TLampe)
   private
    Nennspannung,
    Spannung      : double;   // eff. anliegende Sp.

   public
    constructor Create;
    procedure   SetSpannung (u : double);
    function    GetSpannung   : double;
    function    GetHelligkeit : integer;
end;

(* -------------------- B e s c h r e i b u n g -------------------------

Oberklasse    : TLampe
Bezugsklassen : -     import:

Methoden
--------
Create
Auftrag: Erzeugen und initialisieren
vorher : -
nachher: Nennspannung ist 4.5 ; Spannung 0

SetSpannung
Auftrag: Lampe mit Strom versorgen und leuchten lassen
vorher : -
nachher: Leuchtet oder nicht

Get...
Auftrag: Attribut aus dem Objekt lesen
vorher : Objekt ist init.
nachher: -

GetHelligkeit
Anfrage: nach prozentualem Stand der Spannung = Helligkeitsfaktor
vorher :
nachher: hell, wenn 100%;

--------------------------------------------------------------------- *)

IMPLEMENTATION
// uses sysutils, dialogs;
// ====================================================================
constructor TGluehlampe.Create;
// --------------------------------------------------------------------
begin
inherited Create;
Nennspannung := 4.5;
Spannung     := 0; //
end;

procedure TGluehlampe.SetSpannung (u : double);
// --------------------------------------------------------------------
begin
Spannung := u;
if Spannung > 0
then Leuchten;
end;

function TGluehlampe.GetSpannung : double;
// --------------------------------------------------------------------
begin
Result := Spannung;
end;

function TGluehlampe.GetHelligkeit : integer;
// --------------------------------------------------------------------
begin
   Result := Round(Spannung / Nennspannung * 100); // 100 % = hell
   if Result <= 0
   then Result := 1;
//showmessage(inttostr(result));
end;

END. // -------- UNIT -------------

UNIT uBatterie;
(* ******************************************************************** *)
(* K L A S S E : TBatterie                                              *)
(* -------------------------------------------------------------------- *)
(* Version     : 1.3                                                    *)
(* Autor       :                                                        *)
(* Beschreibung: Die Klasse abstrahiert und modelliert eine Batterie    *)
(*               mit 1.5 V                                              *)
(* Aenderungen : V. 1.3 - 01-OKT-5 Spannung sinkt bei Stromentnahme    *)
(* ******************************************************************** *)

INTERFACE
// =======================================================================

type
TBatterie = class(TObject)
   private
    Spannung : double;              // eff. Spannung

   public
    constructor Create;
    function    GetSpannung : double;
end;

(* -------------------- B e s c h r e i b u n g -------------------------

Oberklasse    : -
Bezugsklassen :      import:

Methoden
--------
Create
Auftrag: Erzeugen und Anfangsspannung festlegen
vorher :
nachher: Spannung ist 1.5 V.

Get...
Anfrage: nach der Spannung
vorher : Spannung ist init.
nachher: Spannung ist um x.x V gesunken

--------------------------------------------------------------------- *)

IMPLEMENTATION
// ====================================================================

constructor TBatterie.Create;
// --------------------------------------------------------------------
begin
inherited Create;
Spannung := 1.5;
end;

function TBatterie.GetSpannung : double;
// --------------------------------------------------------------------
begin
Result := Spannung;
if (Spannung >= 0.001 )              // nach jeder Entnahme sinkt die Spann.
then Spannung := (Spannung - 0.001);
end;

END. // -------- UNIT -------------