UNIT Ugenerat;
{-----------------------------------------------------------------------------
  NOM DE L'UNITE : UGENERAT.PAS
  BUT            : Générateur de fréquence.
  AUTEUR         : Michael Amarantidis / Stéphane Claus
  DATE           : Février, Mars 1997
 
  MODIFIE LE     : 12.04.1997  -  EDT:01
  RAISON         : - Ajout de commentaires
                   - Affiche les infos lors du changement de la fréquence en
                     la saisissant dans la zone de texte
 
  MODIFIE LE     : 23.04.1997  -  EDT:02
  RAISON         : N'affiche pas le facteur de division lors de la saisie d'une
                   nouvelle fréquence au clavier, car sinon la fréquence que
                   l'on frappe est automatiquement écrasée par une fréquence
                   calculée en fonction du facteur
 
  MODIFIE LE     : 22.05.1997  -  EDT:03
  RAISON         : - Affiche à nouveau le facteur de division lors de la saisie
                     d'une nouvelle fréquence au clavier. Mais dans la fonction
                     aedtFacteurChange n'affiche pas le fréquence voulue (c'est
                     pas une fréquence qu'on cherche dans ce cas là, mais un
                     certain facteur de division)
                   - Limite à 5 caractères de long le champ du facteur de
                     division (aedtFacteur)
 
  MODIFIE LE     :
  RAISON         :
 
  REMARQUES      : - Une fois le générateur lancé, il n'est plus possible de
                     l'arrêter !
 -----------------------------------------------------------------------------}
 
 
{=============================================================================}
INTERFACE   {============================================== I N T E R F A C E }
{=============================================================================}
 
 
 
USES
  SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
  Forms, Dialogs, DigDisp, StdCtrls, Buttons, Vcl8254, Spin, ExtCtrls,
  UAlnEdit;
 
 
TYPE
  TfrmGenerateur = CLASS(TForm)
    digdspTitre: TDigitalDisplay;
    bitbtnOK: TBitBtn;
    bitbtnAide: TBitBtn;
    grpbcFacteurDivision: TGroupBox;
    spnbtnFacteur1: TSpinButton;
    rgrpCompteur: TRadioGroup;
    lblFact1: TLabel;
    lblFact10: TLabel;
    lblFact100: TLabel;
    lblFact1000: TLabel;
    spnbtnFacteur10: TSpinButton;
    spnbtnFacteur100: TSpinButton;
    spnbtnFacteur1000: TSpinButton;
    spnbtnFacteur10000: TSpinButton;
    lblFact10000: TLabel;
    grpbxFrequence: TGroupBox;
    lblFreqReelle: TLabel;
    lblFreqDesiree: TLabel;
    spnbtnChangeFreq: TSpinButton;
    lblHz1: TLabel;
    lblHz2: TLabel;
    aedtFreqVoulue: TAlignEdit;
    aedtFreqReelle: TAlignEdit;
    grpbxQuartz: TGroupBox;
    lblQuartz: TLabel;
    aedtFacteur: TAlignEdit;
    PROCEDURE FormActivate(Sender: TObject);
    PROCEDURE spnbtnFacteurDownClick(Sender: TObject);
    PROCEDURE rgrpCompteurClick(Sender: TObject);
    PROCEDURE spnbtnFacteurUpClick(Sender: TObject);
    PROCEDURE aedtFreqVoulueChange(Sender: TObject);
    PROCEDURE aedtFacteurChange(Sender: TObject);
  PRIVATE
    { Private-déclarations }
  PUBLIC
    { Public-déclarations }
  END; {CLASS}
 
 
VAR
  frmGenerateur: TfrmGenerateur;
 
 
 
{=============================================================================}
IMPLEMENTATION   {================================= I M P L E M E N A T I O N }
{=============================================================================}
 
 
 
{$R *.DFM}
 
 
USES
  UPrincpl;
 
 
VAR
  NoCompteurChoisi : SHORTINT;
 
 
PROCEDURE TfrmGenerateur.FormActivate(Sender: TObject);
{-----------------------------------------------------------------------------
  BUT ........... : Initialisation de la fiche en fonction des paramètres
                    actuels du programme
  ENTREE ........ : --
  SORTIE ........ : --
  EFFETS DE BORDS : --
  REMARQUE(S) ... : --
 -----------------------------------------------------------------------------}
VAR
  Facteur : WORD;
BEGIN
  Caption := Application.Title;                          { Affichage du titre }
  IF debugmode THEN Color := debugcolor               { Couleur de la fenêtre }
               ELSE Color := clBtnFace;
  grpbcFacteurDivision.ShowHint := affichehint;
  spnbtnFacteur10000.ShowHint := affichehint;          { Affichage des Hint ? }
  spnbtnFacteur1000.ShowHint := affichehint;
  spnbtnFacteur100.ShowHint := affichehint;
  spnbtnFacteur10.ShowHint := affichehint;
  spnbtnFacteur1.ShowHint := affichehint;
  spnbtnChangeFreq.ShowHint := affichehint;
  rgrpCompteur.ShowHint := affichehint;
  aedtFacteur.ShowHint := affichehint;
  aedtFreqVoulue.ShowHint := affichehint;
  aedtFacteur.ShowHint := affichehint;
  CASE rgrpCompteur.ItemIndex OF                 { Rafraîchissement des infos }
    0 : BEGIN
          IF NOT debugmode THEN FrmMain.PIT8254.ModeCompteur0 := mcGenerateur;
          Facteur := frmMain.PIT8254.Compteur0;
        END; {BRANCH OF CASE}
    1 : BEGIN
          IF NOT debugmode THEN FrmMain.PIT8254.ModeCompteur1 := mcGenerateur;
          Facteur := frmMain.PIT8254.Compteur1;
        END; {BRANCH OF CASE}
    2 : BEGIN
          IF NOT debugmode THEN FrmMain.PIT8254.ModeCompteur2 := mcGenerateur;
          Facteur := frmMain.PIT8254.Compteur2;
        END; {BRANCH OF CASE}
    ELSE Facteur := 2;
  END; {CASE OF}
  IF Facteur > 0 THEN BEGIN                               { Affiche les infos }
    aedtFacteur.Text := IntToStr(Facteur);
    aedtFreqVoulue.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
    aedtFreqReelle.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
  END {IF}
  ELSE BEGIN
    aedtFacteur.Text := '';
    aedtFreqVoulue.Text := '';
    aedtFreqReelle.Text := '';
  END; {ELSE}
  lblQuartz.Caption := FloatToStr(frmMain.PIT8254.Quartz) + '[Hz]';  { Quartz }
END; {PROCEDURE FormActivate}
 
 
PROCEDURE TfrmGenerateur.spnbtnFacteurDownClick(Sender: TObject);
{-----------------------------------------------------------------------------
  BUT ........... : Diminue le facteur de division => Augmente la fréquence
  ENTREE ........ : --
  SORTIE ........ : --
  EFFETS DE BORDS : --
  REMARQUE(S) ... : Cette procédure est appelée par tous les SpinBoutons
 -----------------------------------------------------------------------------}
VAR
  Facteur : LONGINT;
BEGIN
  CASE NoCompteurChoisi OF           { Valeur actuelle du facteur de division }
    0 : Facteur := FrmMain.PIT8254.Compteur0;
    1 : Facteur := FrmMain.PIT8254.Compteur1;
    2 : Facteur := FrmMain.PIT8254.Compteur2;
  END;
  Dec(Facteur, Abs((Sender AS TSpinButton).Tag));     { Diminution du facteur }
  IF Facteur < 2 THEN Facteur := 2;
  IF NOT debugmode THEN BEGIN
    CASE NoCompteurChoisi OF                       { Ecrit le nouveau facteur }
      0 : FrmMain.PIT8254.Compteur0 := Facteur;
      1 : FrmMain.PIT8254.Compteur1 := Facteur;
      2 : FrmMain.PIT8254.Compteur2 := Facteur;
    END; {CASE OF}
  END; {IF}
  aedtFacteur.Text := IntToStr(Facteur);                { Affichage des infos }
  aedtFreqReelle.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
  IF (Sender AS TSpinButton).Tag < 0 THEN BEGIN
    aedtFreqVoulue.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
  END; {IF}
END; {PROCEDURE spnbtnFacteurDownClick}
 
 
PROCEDURE TfrmGenerateur.spnbtnFacteurUpClick(Sender: TObject);
{-----------------------------------------------------------------------------
  BUT ........... : Augmente le facteur de division => Diminue la fréquence
  ENTREE ........ : --
  SORTIE ........ : --
  EFFETS DE BORDS : --
  REMARQUE(S) ... : Cette procédure est appelée par tous les SpinBoutons
 -----------------------------------------------------------------------------}
VAR
  Facteur : LONGINT;
BEGIN
  CASE NoCompteurChoisi OF           { Valeur actuelle du facteur de division }
    0 : Facteur := FrmMain.PIT8254.Compteur0;
    1 : Facteur := FrmMain.PIT8254.Compteur1;
    2 : Facteur := FrmMain.PIT8254.Compteur2;
  END;
  Inc(Facteur, Abs((Sender AS TSpinButton).Tag));   { Augmentation du facteur }
  IF Facteur > 65535 THEN Facteur := 65535;
  IF NOT debugmode THEN BEGIN
    CASE NoCompteurChoisi OF                       { Ecrit le nouveau facteur }
      0 : FrmMain.PIT8254.Compteur0 := Facteur;
      1 : FrmMain.PIT8254.Compteur1 := Facteur;
      2 : FrmMain.PIT8254.Compteur2 := Facteur;
    END; {CASE OF}
  END; {IF}
  aedtFacteur.Text := IntToStr(Facteur);                { Affichage des infos }
  aedtFreqReelle.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
  IF (Sender AS TSpinButton).Tag < 0 THEN BEGIN
    aedtFreqVoulue.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
  END; {IF}
END; {PROCEDURE spnbtnFacteurUpClick}
 
 
PROCEDURE TfrmGenerateur.rgrpCompteurClick(Sender: TObject);
{-----------------------------------------------------------------------------
  BUT ........... : Choix d'un compteur
  ENTREE ........ : --
  SORTIE ........ : --
  EFFETS DE BORDS : --
  REMARQUE(S) ... : Le choix d'un compteur configurera ce dernier en mode
                    générateur
 -----------------------------------------------------------------------------}
VAR
  Facteur : WORD;
BEGIN
  NoCompteurChoisi := rgrpCompteur.ItemIndex;             { Choix du compteur }
  CASE NoCompteurChoisi OF
    0 : BEGIN                                      { Configuration compteur 0 }
          IF NOT debugmode THEN FrmMain.PIT8254.ModeCompteur0 := mcGenerateur;
          Facteur := frmMain.PIT8254.Compteur0;
        END; {BRANCH OF CASE}
    1 : BEGIN                                      { Configuration compteur 1 }
          IF NOT debugmode THEN FrmMain.PIT8254.ModeCompteur1 := mcGenerateur;
          Facteur := frmMain.PIT8254.Compteur1;
        END; {BRANCH OF CASE}
    2 : BEGIN                                      { Configuration compteur 2 }
          IF NOT debugmode THEN FrmMain.PIT8254.ModeCompteur2 := mcGenerateur;
          Facteur := frmMain.PIT8254.Compteur2;
        END; {BRANCH OF CASE}
  END; {CASE OF}
  IF Facteur > 0 THEN BEGIN                               { Affiche les infos }
    aedtFacteur.Text := IntToStr(Facteur);
    aedtFreqVoulue.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
    aedtFreqReelle.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
  END {IF}
  ELSE BEGIN
    aedtFacteur.Text := '';
    aedtFreqVoulue.Text := '';
    aedtFreqReelle.Text := '';
  END; {ELSE}
  grpbcFacteurDivision.Enabled := TRUE;         { Active les autres contrôles }
  grpbxFrequence.Enabled := TRUE;
END; {PROCEDURE rgrpCompteurClick}
 
 
PROCEDURE TfrmGenerateur.aedtFreqVoulueChange(Sender: TObject);
{-----------------------------------------------------------------------------
  BUT ........... : Change de fréquence, en prenant celle que l'utilisateur
                    désire
  ENTREE ........ : --
  SORTIE ........ : --
  EFFETS DE BORDS : --
  REMARQUE(S) ... : Le bloc try...except
                    Un bloc qui gère des exceptions est un bloc try..except.
                    Dans la partie try du bloc, les instructions s'exécutent
                    dans l'ordre normal, sauf s'il se produit une exception;
                    dans ce cas, l'exécution passe directement à la partie
                    except. Si aucune exception ne se produit, le bloc se
                    termine sans utiliser la partie except.
                    La partie except est une liste d'exceptions spécifiques et
                    des réponses qui y sont faites, chacune d'elles étant une
                    instruction on..do. Si aucune des instructions on..do ne
                    s'applique à l'exception active, c'est le gestionnaire
                    d'exception par défaut de la partie else qui s'exécute.
                    Lorsqu'un gestionnaire (spécifique ou par défaut) gère
                    l'exception, le bloc se termine.
                    L'exécution ne reprend pas dans le bloc à la suite d'une
                    exception.
 -----------------------------------------------------------------------------}
VAR
  Frequence  : EXTENDED;                                 { Nouvelle fréquence }
  FacteurSup : LONGINT;                                     { Pour les calculs}
  FacteurInf : LONGINT;
  Facteur    : LONGINT;                         { Nouveau facteur de division }
  FreqSup    : REAL;                                        { Pour les calculs}
  FreqInf    : REAL;
BEGIN
  TRY
    { On voit rouge ! }
    aedtFreqVoulue.Color := clRed;
    {-- Lit la fréquence saisie }
    Frequence := StrToFloat(aedtFreqVoulue.Text);
    {-- Hors limite ? }
    IF Frequence > (frmMain.PIT8254.Quartz / 2) THEN BEGIN
      Frequence := frmMain.PIT8254.Quartz / 2;
    END; {IF}
    IF Frequence < (frmMain.PIT8254.Quartz / 65535) THEN BEGIN
      Frequence := frmMain.PIT8254.Quartz / 65535;
    END; {IF}
    {-- Cherche le facteur de division le plus proche }
    FacteurSup   := Round(frmMain.PIT8254.Quartz / Frequence);
    FacteurInf   := Trunc(Int(frmMain.PIT8254.Quartz / Frequence));
    {-- Calcule les fréquence avec les facteurs trouvés précedemment }
    FreqSup := frmMain.PIT8254.Quartz / FacteurInf;
    FreqInf := frmMain.PIT8254.Quartz / FacteurSup;
    {-- Recherche le facteur de division qui nous permet d'être le plus proche
        de la fréquence voulue }
    IF ((Frequence = FreqSup) OR
       ((FreqSup - Frequence) < (Frequence - FreqInf))) THEN BEGIN
      Facteur := FacteurInf;
    END {IF}
    ELSE IF ((Frequence = FreqInf) OR
            ((FreqSup - Frequence) > (Frequence - FreqInf))) THEN BEGIN
      Facteur := FacteurSup;
    END; {ELSE IF}
    {-- Est-ce que les facteurs trouvés sont acceptables ?}
    IF Facteur < 2 THEN Facteur := 2;
    IF Facteur > 65535 THEN Facteur := 65535;
    {-- Change la fréquence }
    IF NOT debugmode THEN BEGIN
      CASE NoCompteurChoisi OF
        0 : FrmMain.PIT8254.Compteur0 := Facteur;
        1 : FrmMain.PIT8254.Compteur1 := Facteur;
        2 : FrmMain.PIT8254.Compteur2 := Facteur;
      END; {CASE OF}
    END; {IF}
    {-- Affiche les infos }
    {EDT:02 N'affiche pas le facteur => n'appelle pas aedtFacteurChange car
            sinon, on se met en boucle et il est impossible de changer la
            fréquence }
    {EDT:03 Affiche le facteur, mais dans la fonction aedtFacteurChange ne
            change pas la fréquence voulue }
    aedtFacteur.Text := IntToStr(Facteur);
    aedtFreqReelle.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
    {-- Couleur standard }
    aedtFreqVoulue.Color := clWindow;
  EXCEPT
    {-- Valeur incorrecte }
    aedtFreqVoulue.Color := clRed;                          { On voit rouge ! }
  END; {TRY}
END; {PROCEDURE aedtFreqVoulueChange}
 
 
PROCEDURE TfrmGenerateur.aedtFacteurChange(Sender: TObject);
{ BUT: Change de facteur de division en saisissant simplement le facteur }
{-----------------------------------------------------------------------------
  BUT ........... :
  ENTREE ........ : --
  SORTIE ........ : --
  EFFETS DE BORDS : --
  REMARQUE(S) ... : Le bloc try...except
                    Un bloc qui gère des exceptions est un bloc try..except.
                    Dans la partie try du bloc, les instructions s'exécutent
                    dans l'ordre normal, sauf s'il se produit une exception;
                    dans ce cas, l'exécution passe directement à la partie
                    except. Si aucune exception ne se produit, le bloc se
                    termine sans utiliser la partie except.
                    La partie except est une liste d'exceptions spécifiques et
                    des réponses qui y sont faites, chacune d'elles étant une
                    instruction on..do. Si aucune des instructions on..do ne
                    s'applique à l'exception active, c'est le gestionnaire
                    d'exception par défaut de la partie else qui s'exécute.
                    Lorsqu'un gestionnaire (spécifique ou par défaut) gère
                    l'exception, le bloc se termine.
                    L'exécution ne reprend pas dans le bloc à la suite d'une
                    exception.
 -----------------------------------------------------------------------------}
VAR
  Facteur : LONGINT;
BEGIN
  TRY
    aedtFacteur.Color := clRed;                    { Kamarad Soviet, It's Red }
    {-- Conversion du facteur saisi en un nombre }
    Facteur := StrToInt(aedtFacteur.Text);
    IF ((Facteur >= 2) AND (Facteur <= 65535)) THEN BEGIN
      {-- Plage du facteur correct }
      aedtFreqReelle.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
      IF NOT debugmode THEN BEGIN
        {-- Change la fréquence }
        CASE NoCompteurChoisi OF
          0 : FrmMain.PIT8254.Compteur0 := Facteur;
          1 : FrmMain.PIT8254.Compteur1 := Facteur;
          2 : FrmMain.PIT8254.Compteur2 := Facteur;
        END; {CASE OF}
      END; {IF}
      {EDT:01  Affiche les infos }
      {EDT:03  N'affiche pas la fréquence voulue, car on se met en boucle... }
      {aedtFreqVoulue.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);}
      aedtFreqReelle.Text := FloatToStr(frmMain.PIT8254.Quartz / Facteur);
      aedtFacteur.Color := clWindow;                       { Couleur standard }
    END; {IF}
  EXCEPT
    aedtFacteur.Color := clRed;                             { It's ALWAYS Red }
  END; {TRY}
END; {PROCEDURE aedtFacteurChange}
 
 
 
{=============================================================================}
{ INITIALISATIONS ------------------------------------------- Initialisations }
{=============================================================================}
 
 
 
INITIALIZATION
END. {UNIT Ugenerat}