Media Center entwickeln

[Cyberaxx]

@Ansgar
Die Schaltung zur Selbsthaltung(auf Transitoren basierend) habe ich gerade nicht parat, da müsste ich erst in meinen Schulunterlagen schauen. Es gibt aber auch Selbsthaltungen die rein über ein Relais geschaltet werden.
Werde sie mal posten sobald ich sie gefunden habe. Hier mal dargestellt mit einem Schütz
http://upload.wikimedia.org/wikipedi...bsthaltung.gif

Programmiertechnisch braucht man da nichts zu machen, es ist alles eine reine Hardware Lösung.
In der Theorie schaut das in etwa so aus:
Das Scütz ist eigentlich nichts weiter als ein Relais.
Wird der S2 gedrückt, so schaltet das Schütz und schliesst die Verbindung 13/14. Wird der Taster S2 wieder los gelassen so bleibt die Verbindung zwischen 13/14 weiterhin bestehen solange bis S1 gelöst wird. Denn dann verliert das Relais den Strom und öffnet wieder die Verbindung 13/14. An dem Relais kann man mehr als nur ein Gerät schalten. Es steht mindestens noch ein Schaltkreis zur Verfügung den wir nutzen können. Hieran wird nun die 230V Leitung des PC angeschlossen. Der Tster S1 wird durch einen weiteren Relaiskontakt geschaltet. An S2 wird der so gesehen der IOW angeschlossen, bzw. besser gesagt nur der IR-Empfänger. Wir brauchen nur ein einziges mal einen Spannungsanstieg um das Relais K1 zu schalten. Dazu wird der RC5 Code der Fernbedienung nicht genutzt sondern nur das Positive Datensignal. Liegt also am IR Sensor eine Spannung an so schaltet das Relais durch. Jetzt gibt es 2 Möglichkeiten, die eine ist der PC startet automatisch bei anliegen der Spannung. Die andere Möglichkeit wäre durch erweiterung der Schaltung. Schaltet jetzt der PC ein, so wird durch beispielsweise der Power-Led das Relais was hier S1 darstellt geschlossen und die Selbsthaltung ist aktiv. Schaltet der PC sich ab, die Power-LED erlischt und das Relais öffnet sich wieder, die Selbsthaltung schaltet sich wieder ab.
Da PC und die Relais jeweils verzögerungen haben, wird die Schaltung natürlich durch Transistoren und Kondensatoren ersetzt damit genug Zeit bleibt bis der PC wirklich läuft. Kondensatoren sind kleine Energiespeicher. Werden sie Paralell zu den Relais geschaltet werden sie geladen, fällt die Spannung ab so entladen sie sich und liefern noch je nach grösse Spannung um die die Schaltung Temporär zu versorgen damit sichergestellt ist das auch wirklich der PC läuft.
Ich hoffe ich konnte dir das so einigermassen erklären.
Hier noch ein Schaltbild wie es im groben ausschaut mit den Relais.
http://dsnweb.de/schaltung.jpg
So könnte es nachher in etwas aussehen. Da die Schaltung auf 5V ausgelegt wird, kann natürlich der TSOP mit dem IOW im Share stehen. Dazu muss jedoch der IOW ein wenig umgebaut werden, damit dieser unabhängig vom USB auch Spannung bekommt. Zudem könnte man es noch soweit entwickeln das selbst keine Netzversorgung mehr auf dem IOW liegen muss, dieser könnte über einen Akku betrieben werden, dieser lädt sich dann im normal Betrieb wieder auf.


@shmia
Was ist denn an einem CollectionItem und einer Collection auszusetzen gegenüber der ObjectList?
Hier einmal meine Menü Klasse, leider noch mit Fehlern behaftet beim freigeben der Panels.

Delphi-Quellcode:

unit menu_class;

interface

uses
  Classes, Defines, Windows, SysUtils, Controls, Graphics, JvPanel;

type
  TButtonStyle = (etButton, etSeperator, etText);

type
  TMenuEntry = class(TCollectionItem)
  private
    FPanel: TJvPanel;
    FButtonStyle: TButtonStyle;
  public
    destructor Destroy(); override;
    property Button: TJvPanel read FPanel write FPanel;
    property ButtonStyle: TButtonStyle read FButtonStyle write FButtonStyle;
  end;

type
  TMenuEntries = class(TCollection)
  private
    function GetEntry(Index: Integer): TMenuEntry;
  public
    constructor Create;
    destructor Destroy; override;
    function Add(AOwner: TWinControl): TMenuEntry;
    procedure Del(Index: Integer);
    property MenuEntry[Index: Integer]: TMenuEntry read GetEntry;
  end;

type
  TMenuManager = class(TObject)
  private
    FOwner: TWinControl;
    FXPos: Integer;
    FYPos: Integer;
    FTempYPos: Integer;
    FMenuEntries: TMenuEntries;
    FActiveButton: Integer;
    FItemClick: TNotifyEvent;
    function GetAcctiveButton: Integer;
    procedure SetActiveButton(const Value: Integer);
    procedure OnClick(Sender: TObject);
  public
    constructor Create(AOwner: TWinControl; XPos, YPos: Integer);
    destructor Destroy; override;
    procedure AddButton(Caption: String; ButtonStyle: TButtonStyle = etButton);
    procedure RemoveButton(Index: Integer);
    procedure ClearButtons;
    function Count: Integer;
    property ButtonActive: Integer read GetAcctiveButton write SetActiveButton;
    property OnItemClick: TNotifyEvent read FItemClick write FItemClick;
  end;

implementation

{ TMenuManager }

procedure TMenuManager.AddButton(Caption: String;
  ButtonStyle: TButtonStyle);
  var
    AMenuEntry: TMenuEntry;
begin
  Self.FTempYPos := Self.FMenuEntries.Count * 40 + Self.FYPos;

  AMenuEntry := Self.FMenuEntries.Add(Self.FOwner);
  AMenuEntry.FPanel.DoubleBuffered := True;
  AMenuEntry.FPanel.Left := Self.FXPos;
  AMenuEntry.FPanel.Top := Self.FTempYPos;
  AMenuEntry.FPanel.Height := 33;
  AMenuEntry.FPanel.Width := 233;
  AMenuEntry.FPanel.Transparent := True;
  AMenuEntry.FPanel.BevelInner := bvNone;
  AMenuEntry.FPanel.BevelOuter := bvNone;
  AMenuEntry.FPanel.Color := clGray;
  AMenuEntry.FPanel.Alignment := taLeftJustify;
  AMenuEntry.FPanel.Caption := Caption;
  AMenuEntry.FPanel.Font.Color := clBlack;
  AMenuEntry.FPanel.Font.Size := 24;
  AMenuEntry.FPanel.Font.Style := [fsBold];

  if ButtonStyle = etSeperator then
    AMenuEntry.FPanel.BorderWidth := 0
      else AMenuEntry.FPanel.BorderWidth := 1;

  AMenuEntry.FPanel.Parent := FOwner;
  AMenuEntry.FPanel.OnClick := Self.OnClick;
  AMenuEntry.FPanel.Tag := AMenuEntry.Index;

  AMenuEntry.FButtonStyle := ButtonStyle;
end;

procedure TMenuManager.ClearButtons;
begin
  while Self.FMenuEntries.Count > 0 do begin
    Self.FMenuEntries.Del(Self.FMenuEntries.Count -1);
    end;
end;

function TMenuManager.Count: Integer;
begin
  Result := Self.FMenuEntries.Count;
end;

constructor TMenuManager.Create(AOwner: TWinControl; XPos, YPos: Integer);
begin
  inherited Create;

  Self.FOwner := AOwner;
  Self.FXPos := XPos;
  Self.FYPos := YPos;
  Self.FTempYPos := Self.FYPos;
  Self.FActiveButton := -1;

  Self.FMenuEntries := TMenuEntries.Create;
end;

destructor TMenuManager.Destroy;
begin
  Self.ClearButtons;
  Self.FMenuEntries.Destroy;

  inherited Destroy;
end;

function TMenuManager.GetAcctiveButton: Integer;
begin
  Result := Self.FActiveButton;
end;

procedure TMenuManager.OnClick(Sender: TObject);
begin
  if Assigned(FItemClick) then begin
    if Sender is TJvPanel then begin
      Self.SetActiveButton(TJvPanel(Sender).Tag);
      //Self.FActiveButton := TJvPanel(Sender).Tag;
      OnItemClick(Self);
      // <-- panel existiert nicht mehr
      end;
    end;   // hier error!!!!!!!!!!!!!!!!!
end;

procedure TMenuManager.RemoveButton(Index: Integer);
begin
  Self.FMenuEntries.Del(Index);
end;

procedure TMenuManager.SetActiveButton(const Value: Integer);
  var
    AMenuEntry: TMenuEntry;
begin
  if Value = -1 then
    Exit;
    
  AMenuEntry := Self.FMenuEntries.MenuEntry[Value];

  if (AMenuEntry <> nil) and (Value <> Self.FActiveButton) then begin
    if AMenuEntry.ButtonStyle = etButton then begin
      AMenuEntry.FPanel.Color := clYellow;
      if Self.FActiveButton > -1 then
        Self.FMenuEntries.MenuEntry[Self.FActiveButton].FPanel.Color := clGray;
      Self.FActiveButton := Value;
      end;
    end;
end;

{ TMenuEntries }

function TMenuEntries.Add(AOwner: TWinControl): TMenuEntry;
begin
  Result := inherited Add as TMenuEntry;

  Result.FPanel := TJvPanel.Create(AOwner);
  Result.FPanel.Parent := AOwner;
end;

constructor TMenuEntries.Create;
begin
  inherited Create(TMenuEntry);

end;

procedure TMenuEntries.Del(Index: Integer);
begin
  Self.GetEntry(Index).Free;
end;

destructor TMenuEntries.Destroy;
begin

  inherited Destroy;
end;

function TMenuEntries.GetEntry(Index: Integer): TMenuEntry;
begin
  Result := inherited Items[Index] as TMenuEntry;
end;

{ TMenuEntry }

destructor TMenuEntry.Destroy;
begin
  Self.FPanel.Free;

  inherited Destroy;
end;

end.