UNIT uTaschenlampe;

(* ******************************************************************** *)
(* K L A S S E : TTaschenlampe                                          *)
(* -------------------------------------------------------------------- *)
(* Version     : 1.3.2                                                  *)
(* 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           *)
(*                  1.3.2 -             OHM                             *)
(* ******************************************************************** *)

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 : ...........      import:


Methoden
--------
Einschalten
  Auftrag: TL einschalten
  vorher : -
  nacher : Schalter true; Lampe bekommt Spannung von Batt.

Ausschalten
  Auftrag: TL ausschalten
  vorher : -
  nacher : Schalter false; Lampe bekommt Spannung 0.

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 Batteriespannung > 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!
  Schalter  := false               // aus
end;


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

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

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

function TTaschenlampe.Leuchtet : boolean;
// --------------------------------------------------------------------
var
  RL : double;         // Lastwiderstand der Lampe in Ohm

begin
  Result := (Lampe.GetLicht = true) AND (Lampe.GetSpannung > 0) AND (Schalter = true);
  if true
  then
    begin
      RL := Lampe.GetWiderstand;
      Lampe.SetSpannung(Batterie1.GetSpannung(RL));
    end;
end;

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

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

UNIT uGluehlampe;

(* ******************************************************************** *)
(* K L A S S E : TGluehlampe                                            *)
(* -------------------------------------------------------------------- *)
(* Version     : 1.3.2                                                  *)
(* Autor       :                                                        *)
(* Beschreibung: Die Klasse abstrahiert und modelliert eine Lampe 4.5 V,*)
(*               300 mA                                                 *)
(* Compiler    : Delphi 6.0                                             *)
(* Aenderungen : V. 1.3.2 - 01-OKT-05   GetWiderstand                   *)
(* ******************************************************************** *)

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

type
  TGluehlampe = class(TLampe)
   private
    Nennspannung,
    Spannung  : double;   // eff. anliegende Sp.
    Widerstand: double;
   public
    constructor Create;
    procedure   SetSpannung (u : double);
    function    GetSpannung : double;     // prüfen, ob Saft da ist
    function    GetHelligkeit : integer;
    function    GetWiderstand : double;
  end;

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

Oberklasse    : TLampe
Bezugsklassen : -     import:


Methoden
--------
Create
  Auftrag: erzeugen und init.
  vorher : -
  nachher: Nennspannung ist 4.5, Spannung 0, Widerstand 15.

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 : integer;
  Anfrage: nach prozentualem Stand der Spannung = Helligkeitsfaktor
  vorher :
  nachher:  hell, wenn 100%;

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

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

//uses dialogs, sysutils;


constructor TGluehlampe.Create;
// --------------------------------------------------------------------
begin
  inherited Create;
  Nennspannung := 4.5;
  Spannung     := 0;
  Widerstand   := 15;          // R=U/I
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;


function TGluehlampe.GetWiderstand : double;
// --------------------------------------------------------------------
begin
  Result := Widerstand;
end;

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

UNIT uBatterie;

(* ******************************************************************** *)
(* K L A S S E : TBatterie                                              *)
(* -------------------------------------------------------------------- *)
(* Version     : 1.3.2                                                  *)
(* Autor       :                                                        *)
(* Beschreibung: Die Klasse abstrahiert und modelliert eine Batterie    *)
(*               mit 1.5 V, 1.200 mAh                                   *)
(* Aenderungen : v. 1.3.2 - 01-OKT-5    Spannung sinkt nach OHM         *)
(* ******************************************************************** *)

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

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

   public
    constructor Create;
    function    GetSpannung (RLast : double) : double;
  end;

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

Oberklasse    : -
Bezugsklassen :      import:

Methoden
--------
Create
  Auftrag: Erzeugen und initialisieren
  vorher :
  nachher: Spannung ist 1.5 V, Innenwiderstand ist 0

GetSpannung ()
  Anfrage: nach der aktuellen Spannung unter Belastung;
  vorher : Batt. ist init.
  nachher: Innenwiderstand ist erhoeht, Spannung vermindert

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

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

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

function TBatterie.GetSpannung (RLast : double) : double;
// --------------------------------------------------------------------
var                                      // weglassen????
  U,          // Spannung in Volt
  I,          // Strom in Amp
  UL : double;  // LastSpannung; neue Spannung an der Lampe

begin
   U  := Spannung;

   Ri := Ri + 0.001;      // der Innenwiderstand der realen Spannungsquelle steigt
   I  := U /(Ri + RLast); // der Strom sinkt
   UL := I * RLast;       // die Spannung unter Last an der Lampe sinkt

   Spannung := UL;
   Result := Spannung;
end;

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