 unit Operations;
{ A NOTER }
{ * il faut que tous les champ des la database contiennent une valeur, sinon il y a risque d'erreur (pas grave) }
{   ex: il faut preciser un canal meme pour les TTI3510 meme s'il est non significatif

{ MODIFICATIONS                                                                     }
{ 10/10 modification des commandes d'acquisition 2D pour cable 3 bits}
{ mise a jour le 31.10.2000                                                         }

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  Db, DBTables, StdCtrls, Spin, TTI3510, CLET183, ITC4drv, ATSR200, EditReal,
  ExtCtrls, CarteMicro, DafMTMX, EuroPSD, editdata ;

type
  Toperationform = class(TForm)
    Label1: TLabel;
    Button1: TButton;
    TableConfigManip: TTable;
    Edit1: TEdit;
    TableAppareils: TTable;
    Button2: TButton;
    Edit2: TEdit;
    Label2: TLabel;
    Flipper1ON: TButton;
    Flipper1OFF: TButton;
    Flipper2ON: TButton;
    Flipper2OFF: TButton;
    Panel1: TPanel;
    Label3: TLabel;
    SetField: TButton;
    Button3: TButton;
    TableComptage: TTable;
    FieldT: TEditReal;
    GroupBox1: TGroupBox;
    ReadTempButton: TButton;
    TempBox: TEditReal;
    ChannelBox: TSpinEdit;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Flipper2ONClick(Sender: TObject);
    procedure Flipper2OFFClick(Sender: TObject);
    procedure Flipper1ONClick(Sender: TObject);
    procedure Flipper1OFFClick(Sender: TObject);
    procedure SetFieldClick(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Déclarations privées }
  public
    { functions a usage general }
    function GetIndex(fonction:string):longint;
    function GetTypeAppareil(index:longint):string;
    function GetAdresse(index:longint):longint;
    function GetCanal(index:longint):longint;
    function GetValMax(index:longint):real;
    function GetConvA(index:longint):real;
    function GetTypeCompteur(index:longint):string;
    function GetAdresseCompteur(index:longint):longint;
    { pilotage des flippers }
    function Flipper1_ON:integer;      { ok }
    function Flipper1_OFF:integer;     { ok }
    function Flipper2_ON:integer;      { ok }
    function Flipper2_OFF:integer;     { ok }
    function SetCourantFlipper1H(I:real):integer;
    function SetCourantFlipper1V(I:real):integer;
    function SetCourantFlipper2H(I:real):integer; { ok }
    function SetCourantFlipper2V(I:real):integer;
    { pilotage du champ }
    function SetChampL(value:real):integer;
    function SetFieldT(FieldValue:real):integer;
    function SetChampP(value:real):integer;
    function ReadChampL(value:real):integer;
    function ReadChampT(value:real):integer;
    function ReadChampP(value:real):integer;
    { ============================= }
    { pilotage temperature          }
    function ReadTemperatureRegulation:real;
    function ReadTemperatureRegul:real; { lecture de la temperature sur le canal de regulation }
    function toto:real;
    procedure SetTemperatureRegul(temperature:real);
{    function ReadTemperature1:real; { lecture de la temperature sur le senseur 1 }
                                    { il peut ou non etre confondu avec le canal de regulation }
    { ============================= }
    { pilotage des alim de tension }
    function SetTension1(value:real):integer;
{    function SetCourant1(value:real):integer; }
    function SetTension2(value:real):integer;
{    function SetCourant2(value:real):integer; }
    { Déclarations publiques }

    { procédures acquisition }
    {fonction générales de comptage}
    procedure suspendrecomptage;
    procedure reprendrecomptage;
    function AcquisitionFinie:boolean;
    function Acquisition2DFinie:boolean;

    { acquisition 0D }
    function LancerAcquisition0D(TT,TU,TD:cardinal;modepolar:string):integer;
    procedure lireParametres0D(var NT,Nu,ND,MT,MU,MD,TT,TU,TD:cardinal);

    { acquisition en mode statique }
    function LancerAcquisition2D(decalage:integer;TT,TU,TD:real;modepolar:string):integer;
    procedure LireSpectre2D(decalage:integer;indexspectreU,indexspectreD:integer;modepolar,comment:string);
    procedure litparametre2D(var NT,NU,ND:cardinal; var MT,MU,MD,TT,TU,TD:real);

    { acquisition en mode TOF }
    function lanceracquisition(TT:real;polarup:boolean):integer;
    procedure litparametre_TOF(polarup:boolean;var ncoups:cardinal; var moniteur,temps:real);
    function LancerAcquisition2D_TOF(TT:real;polarup:boolean;retard,largeurcanal:real;nbrframe:integer):integer;
    procedure LireSpectre2D_TOF(decalage:integer;Modepolar:string;comment:string);
    function  initcompteurenTOF (retard,largeurcanal:real;nbrframe:integer):integer;

    {opérations sur les spectres}
    function Addspectre(spectre1,spectre2,spectre3:string):boolean;
    function Subspectre(spectre1,spectre2,spectre3:string):boolean;
    {function Multspectre(spectre1,spectre2,spectre3:string):boolean;
    function Divspectre(spectre1,spectre2,spectre3:string):boolean;}
  end;

var
  operationform: Toperationform;

implementation
const
test=false;

{$R *.DFM}

{ fonction retournant l'index d'un appareil associée a une fonction donnée }
{ INPUT: fonction : string                                                 }
{ OUTPUT: l'index de l'appareil                                            }
function Toperationform.GetIndex(fonction:string):longint;
var aux:longint;
begin
     TableConfigManip.Locate('Fonction',fonction,[loCaseInsensitive]);
     if test then Writeln(TableConfigManip.FieldValues['Indexappareil']);
     aux:=TableConfigManip.FieldValues['Indexappareil'];
     GetIndex:=aux;
end;

{ fonction retournant le type d'appareil associée a un index d'appareil    }
{ INPUT: index: longint                                                }
{ OUTPUT: type de l'appareil (trouvé dans DB 'Appareils')              }
function Toperationform.GetTypeAppareil(index:longint):string;
var s:string;
begin
     TableAppareils.Locate('Index',index,[loCaseInsensitive]);
     if test then Writeln(TableAppareils.FieldValues['TypeAppareil']);
     s:=TableAppareils.FieldValues['TypeAppareil'];
     GetTypeAppareil:=s;
end;

{ fonction retournant l'adresse d'un appareil associée a un index d'appareil    }
{ INPUT: index : index de l'appareil dans la table Appareils }
{ OUTPUT: le champ adresse de l'appareil 'index'                          }
function Toperationform.GetAdresse(index:longint):longint;
var ad:longint;
begin
     TableAppareils.Locate('Index',index,[loCaseInsensitive]);
     if test then Writeln(TableAppareils.FieldValues['Adresse']);
     ad:=TableAppareils.FieldValues['Adresse'];
     GetAdresse:=ad;
end;

{ fonction retournant le canal d'un appareil associée a un index d'appareil    }
{ INPUT: index : index de l'appareil dans la table Appareils }
{ OUTPUT: le champ canal de l'appareil 'index'               }
function Toperationform.GetCanal(index:longint):longint;
var canal:longint;
begin
     TableAppareils.Locate('Index',index,[loCaseInsensitive]);
     if test then Writeln(TableAppareils.FieldValues['Canal']);
     canal:=TableAppareils.FieldValues['Canal'];
     GetCanal:=canal;
end;

{ fonction retournant l'adresse d'un appareil associée a un index d'appareil    }
{ INPUT: index : index de l'appareil dans la table Appareils }
{ OUTPUT: le champ adresse de l'appareil 'index'                          }
function Toperationform.GetValMax(index:longint):real;
var valMax:real;
begin
     TableAppareils.Locate('Index',index,[loCaseInsensitive]);
     if test then Writeln(TableAppareils.FieldValues['ValMax']);
     valMax:=TableAppareils.FieldValues['ValMax'];
     GetValMax:=valMax;
end;

{ fonction retournant l'adresse d'un appareil associée a un index d'appareil    }
{ INPUT: index : index de l'appareil dans la table Appareils }
{ OUTPUT: le champ adresse de l'appareil 'index'                          }
function Toperationform.GetConvA(index:longint):real;
var convA:real;
begin
     TableAppareils.Locate('Index',index,[loCaseInsensitive]);
     if test then Writeln(TableAppareils.FieldValues['ConvA']);
     convA:=TableAppareils.FieldValues['ConvA'];
     GetConvA:=convA;
end;


{==================================================}
{ jeu de fonctions pour obtenir les renseignements }
{ sur le type de detection                         }
{==================================================}

{ fonction retournant le type de détecteur utilisé pour le comptage    }
{ INPUT: index: longint                                                }
{ OUTPUT: type de l'appareil (trouvé dans DB 'Comptage')               }
function Toperationform.GetTypeCompteur(index:longint):string;
var s:string;
begin
     TableComptage.Locate('Index',index,[loCaseInsensitive]);
     if test then Writeln(TableComptage.FieldValues['TypeCompteur']);
     s:=TableComptage.FieldValues['TypeCompteur'];
     GetTypeCompteur:=s;
end;

{ fonction retournant l'adresse d'un appareil associée a un index d'appareil    }
{ INPUT: index : index de l'appareil dans la table Appareils }
{ OUTPUT: le champ adresse de l'appareil 'index'                          }
function Toperationform.GetAdresseCompteur(index:longint):longint;
var ad:longint;
begin
     TableComptage.Locate('Index',index,[loCaseInsensitive]);
     if test then Writeln(TableComptage.FieldValues['Adresse']);
     ad:=TableComptage.FieldValues['Adresse'];
     GetAdresseCompteur:=ad;
end;


{==================================================}
{ pilotage des flippers                            }
{==================================================}

{ allumage inconditionnel du flipper 1 }
function Toperationform.Flipper1_ON:integer;
var indexH,indexV:longint; { index des appareils branchés sur les flippers H et V }
    taH,taV:string;        { type de l'appareil (bobine H et V)}
    adresseH,adresseV:longint;  { adresses des deux appareils }
begin
     indexH:=GetIndex('Flipper1H');
     indexV:=GetIndex('Flipper1V');
     taH:=GetTypeAppareil(indexH);
     taV:=GetTypeAppareil(indexV);
     adresseH:=GetAdresse(indexH);
     adresseV:=GetAdresse(indexV);
     If taH='TTI3510' then SwitchON_TTI3510(adresseH);
     If taH='CLET183' then SwitchON_CLET183(adresseH);
     If taV='TTI3510' then SwitchON_TTI3510(adresseV);
     If taV='CLET183' then SwitchON_CLET183(adresseV);
end;

function Toperationform.Flipper1_OFF:integer;
var indexH,indexV:longint; { index des appareils branchés sur les flippers H et V }
    taH,taV:string;        { type de l'appareil (bobine H et V)}
    adresseH,adresseV:longint;  { adresses des deux appareils }
begin
     indexH:=GetIndex('Flipper1H');
     indexV:=GetIndex('Flipper1V');
     taH:=GetTypeAppareil(indexH);
     taV:=GetTypeAppareil(indexV);
     adresseH:=GetAdresse(indexH);
     adresseV:=GetAdresse(indexV);
     If taH='TTI3510' then SwitchOFF_TTI3510(adresseH);
     If taH='CLET183' then SwitchOFF_CLET183(adresseH);
     If taV='TTI3510' then SwitchOFF_TTI3510(adresseV);
     If taV='CLET183' then SwitchOFF_CLET183(adresseV);
end;

function Toperationform.Flipper2_ON:integer;
var indexH,indexV:longint; { index des appareils branchés sur les flippers H et V }
    taH,taV:string;        { type de l'appareil (bobine H et V)}
    adresseH,adresseV:longint;  { adresses des deux appareils }
begin
     indexH:=GetIndex('Flipper2H');
     indexV:=GetIndex('Flipper2V');
     taH:=GetTypeAppareil(indexH);
     taV:=GetTypeAppareil(indexV);
     adresseH:=GetAdresse(indexH);
     adresseV:=GetAdresse(indexV);
     If taH='TTI3510' then SwitchON_TTI3510(adresseH);
     If taH='CLET183' then SwitchON_CLET183(adresseH);
     If taV='TTI3510' then SwitchON_TTI3510(adresseV);
     If taV='CLET183' then SwitchON_CLET183(adresseV);
end;

function Toperationform.Flipper2_OFF:integer;
var indexH,indexV:longint; { index des appareils branchés sur les flippers H et V }
    taH,taV:string;        { type de l'appareil (bobine H et V)}
    adresseH,adresseV:longint;  { adresses des deux appareils }
begin
     indexH:=GetIndex('Flipper2H');
     indexV:=GetIndex('Flipper2V');
     taH:=GetTypeAppareil(indexH);
     taV:=GetTypeAppareil(indexV);
     adresseH:=GetAdresse(indexH);
     adresseV:=GetAdresse(indexV);
     If taH='TTI3510' then SwitchOFF_TTI3510(adresseH);
     If taH='CLET183' then SwitchOFF_CLET183(adresseH);
     If taV='TTI3510' then SwitchOFF_TTI3510(adresseV);
     If taV='CLET183' then SwitchOFF_CLET183(adresseV);
end;

{ ajustement du courant dans la bobine horizontale du deuxième flipper }
{ INPUT: I, valeur du courant en amperes                               }
{ OUTPUT: l'alim du flipper delivre le courant                         }
{         si la valeur du courant est trop elevee, retour de la valeur -1 }
{         utile dans les scans en courant                              }
function Toperationform.SetCourantFlipper1H(I:real):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;        { type de l'appareil (bobine H et V)}
    adresse,canal:longint;  { adresses des deux appareils }
    Imax:real;        { valeur max du courant autorisé dans la bobine }
begin
     index:=GetIndex('Flipper1H');
     ta:=GetTypeAppareil(index);
     adresse:=GetAdresse(index);
     canal:=GetCanal(index);
     Imax:=GetValMax(index);
     If I<=Imax then
     begin
          If ta='TTI3510' then SetCourant_TTI3510(adresse,I);
          If ta='CLET183' then SetCourant_CLET183(adresse,canal,I);
     end;
end;

{ ajustement du courant dans la bobine horizontale du deuxième flipper }
{ INPUT: I, valeur du courant en amperes                               }
{ OUTPUT: l'alim du flipper delivre le courant                         }
{         si la valeur du courant est trop elevee, retour de la valeur -1 }
{         utile dans les scans en courant                              }
function Toperationform.SetCourantFlipper1V(I:real):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;        { type de l'appareil (bobine H et V)}
    adresse,canal:longint;  { adresses des deux appareils }
    Imax:real;        { valeur max du courant autorisé dans la bobine }
begin
     index:=GetIndex('Flipper1V');
     ta:=GetTypeAppareil(index);
     adresse:=GetAdresse(index);
     canal:=GetCanal(index);
     Imax:=GetValMax(index);
     If I<=Imax then
     begin
          If ta='TTI3510' then SetCourant_TTI3510(adresse,I);
          If ta='CLET183' then SetCourant_CLET183(adresse,canal,I);
     end;
end;


{ ajustement du courant dans la bobine horizontale du deuxième flipper }
{ INPUT: I, valeur du courant en amperes                               }
{ OUTPUT: l'alim du flipper delivre le courant                         }
{         si la valeur du courant est trop elevee, retour de la valeur -1 }
{         utile dans les scans en courant                              }
function Toperationform.SetCourantFlipper2H(I:real):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;        { type de l'appareil (bobine H et V)}
    adresse,canal:longint;  { adresses des deux appareils }
    Imax:real;        { valeur max du courant autorisé dans la bobine }
begin
     index:=GetIndex('Flipper2H');
     ta:=GetTypeAppareil(index);
     adresse:=GetAdresse(index);
     canal:=GetCanal(index);
     Imax:=GetValMax(index);
     If I<=Imax then
     begin
          If ta='TTI3510' then SetCourant_TTI3510(adresse,I);
          If ta='CLET183' then SetCourant_CLET183(adresse,canal,I);
     end;
end;

{ ajustement du courant dans la bobine horizontale du deuxième flipper }
{ INPUT: I, valeur du courant en amperes                               }
{ OUTPUT: l'alim du flipper delivre le courant                         }
{         si la valeur du courant est trop elevee, retour de la valeur -1 }
{         utile dans les scans en courant                              }
function Toperationform.SetCourantFlipper2V(I:real):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;        { type de l'appareil (bobine H et V)}
    adresse,canal:longint;  { adresses des deux appareils }
    Imax:real;        { valeur max du courant autorisé dans la bobine }
begin
     index:=GetIndex('Flipper2V');
     ta:=GetTypeAppareil(index);
     adresse:=GetAdresse(index);
     canal:=GetCanal(index);
     Imax:=GetValMax(index);
     If I<=Imax then
     begin
          If ta='TTI3510' then SetCourant_TTI3510(adresse,I);
          If ta='CLET183' then SetCourant_CLET183(adresse,canal,I);
     end;
end;


{==================================================}
{ pilotage temperature }
{==================================================}
function ToperationForm.ReadTemperatureRegulation:real;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
    channel:byte;
    convA:real;    { facteur de conversion, ex. Courant(I) = convA * Champ(T) }
begin
{     index:=GetIndex('RegulationTemp'); }
     tempBox.value:=164.154;
{     ta:='ITC4'; }
     result:=ITC4.ReadTemperature_ITC4(1);
end;

function Toperationform.ReadTemperatureRegul:real; { lecture de la temperature sur le canal de regulation }
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
    channel:byte;
    convA:real;    { facteur de conversion, ex. Courant(I) = convA * Champ(T) }
begin
     result:=ITC4.ReadTemperature_ITC4(1);
end;

function Toperationform.toto:real;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
    channel:byte;
    convA:real;    { facteur de conversion, ex. Courant(I) = convA * Champ(T) }
begin
     result:=ITC4.ReadTemperature_ITC4(1);
end;

procedure Toperationform.SetTemperatureRegul(temperature:real); { set point de la température de réégulation le canal de regulation }
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
    channel:byte;
    convA:real;    { facteur de conversion, ex. Courant(I) = convA * Champ(T) }
begin
     index:=GetIndex('RegulationTemp');
     ta:=GetTypeAppareil(index);
     adresse:=GetAdresse(index);
     channel:=GetCanal(index);
     If ta='ATRS200'
     then begin
          SetTemperature_ATSR200(adresse,channel,temperature);
          end;
end;


{==================================================}
{ pilotage du champ }
{==================================================}
function Toperationform.SetChampL(value:real):integer;
begin
end;

{ champ transverse }
{ INPUT: FieldValue: valeur du champ a atteindre en mT }
{ OUTPUT: integer: code d'erreur                       }
function Toperationform.SetFieldT(FieldValue:real):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
    convA:real;    { facteur de conversion, ex. Courant(I) = convA * Champ(T) }
begin
     index:=GetIndex('MagneticFieldT');
     ta:=GetTypeAppareil(index);
     adresse:=GetAdresse(index);
     convA:=GetConvA(index);
     If ta='TTI3510'
     then begin
          SetCourant_TTI3510(adresse,convA*FieldValue);
          { SwitchON_TTI3510(adresse); }
          end;
end;

function Toperationform.SetChampP(value:real):integer;
begin
end;

function Toperationform.ReadChampL(value:real):integer;
begin
end;

function Toperationform.ReadChampT(value:real):integer;
begin
end;

function Toperationform.ReadChampP(value:real):integer;
begin
end;


{==================================================}
{ pilotage des alim de tension }
{==================================================}
function Toperationform.SetTension1(value:real):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
    canal:longint;
    convA:real;    { facteur de conversion, ex. Courant(I) = convA * Champ(T) }
begin
     index:=GetIndex('SetTension1');
     ta:=GetTypeAppareil(index);
     adresse:=GetAdresse(index);
     canal:=GetCanal(index);
     convA:=GetConvA(index);
     If ta='TTI3510' then begin
          SetCourant_TTI3510(adresse,value);
          { SwitchON_TTI3510(adresse); }
          end;
{     If ta='ATA0610' then begin SetTension_ATA0610(canal,value) end;         end; }
end;

function Toperationform.SetTension2(value:real):integer;
begin
end;

{==================================================}
{ pilotage de l'acquisition  2D                    }
{==================================================}


{ *******************************************************************************

                        fonction générales de comptage
*******************************************************************************}

procedure Toperationform.suspendrecomptage;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurPAPOLSurDafMTMX' then suspendrecomptage_PAPOL;
     If ta='CompteurPAPOLSurDafMTMX_TOF' then suspendrecomptage_PAPOL;
end;

procedure Toperationform.reprendrecomptage;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurPAPOLSurDafMTMX' then reprendrecomptage_PAPOL;
     If ta='CompteurPAPOLSurDafMTMX_TOF' then reprendrecomptage_PAPOL;
end;

function Toperationform.AcquisitionFinie:boolean;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurSimpleSurCarteMicro' then AcquisitionFinie:=acquisition0Dfinie_CarteMicro;
end;

function Toperationform.Acquisition2DFinie:boolean;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurPAPOLSurDafMTMX' then Acquisition2DFinie:=acquisition2Dfinie_PAPOL;
     If ta='CompteurPAPOLSurDafMTMX_TOF' then Acquisition2DFinie:=acquisition2Dfinie_PAPOL;
end;


{ *******************************************************************************}
function Toperationform.LancerAcquisition0D(TT,TU,TD:cardinal;modepolar:string):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurSimpleSurCarteMicro' then LancerAcquisition0D_CarteMicro(TT,TU,TD,modepolar);
{     If ta='CompteurPAPOLSurDafMTMX' then LancerAcquisition2D:=LancerAcquisition2D_PAPOL(TT,TU,TD,modepolar);
     If ta='CompteurPAPOLSurDafMTMX_TOF' then ShowMessage('Non disponible avec option TOF'); }
end;

procedure Toperationform.lireParametres0D(var NT,Nu,ND,MT,MU,MD,TT,TU,TD:cardinal);
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurSimpleSurCarteMicro' then litparametres0D_CarteMicro(NT,MT,TT);
{     If ta='CompteurPAPOLSurDafMTMX' then litparametre2D_PAPOL(NT,NU,ND,MT,MU,MD,TT,TU,TD);
     If ta='CompteurPAPOLSurDafMTMX_TOF' then ShowMessage('Non disponible avec option TOF'); }
end;







{*************************************************************************

                                         acquisition en mode statique
*****************************************************************************}

{ *******************************************************************************}
{ acquisition en mode statique avec pilotage de la polarisation (cable decalage 0, 3 ou 4) }
{ en configuration non temps de vol                                                }
function Toperationform.LancerAcquisition2D(decalage:integer;TT,TU,TD:real;modepolar:string):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurPAPOLSurDafMTMX' then LancerAcquisition2D:=LancerAcquisition2D_PAPOL(decalage,TT,TU,TD,modepolar);
     If ta='CompteurPAPOLSurDafMTMX_TOF' then LancerAcquisition2D:=LancerAcquisition2D_PAPOL(decalage,TT,TU,TD,modepolar);
end;
{ *******************************************************************************}
{ lecture des data en mode statique (cable decalage 0, 3 ou 4) }
{ configuration non temps de vol                                }
procedure Toperationform.LireSpectre2D(decalage:integer;indexspectreU,indexspectreD:integer;modepolar,comment:string);
var moniteurU,moniteurD:real;
    i:integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);

     If ta='CompteurPAPOLSurDafMTMX' then
     begin
          if (modepolar='UP') or (modepolar='UP/DOWN') then
             begin
                moniteurU:=moniteur_PAPOL('UP');
                litspectre2D_PAPOL(decalage,moniteurU,indexspectreU,comment,'UP');
             end;

          if (modepolar='DOWN') or (modepolar='UP/DOWN') then
             begin
                moniteurD:=moniteur_PAPOL('DOWN');
                litspectre2D_PAPOL(decalage,moniteurD,indexspectreD,comment,'DOWN');
             end;

     end;

     If ta='CompteurPAPOLSurDafMTMX_TOF' then
     begin
          if decalage=4 then
             begin
               if (modepolar='UP') or (modepolar='UP/DOWN') then
               begin
                  moniteurU:=moniteur_PAPOL('UP');
                  litspectre2D_PAPOL(decalage,moniteurU,indexspectreU,comment,'UP');
               end;

             if (modepolar='DOWN') or (modepolar='UP/DOWN') then
                begin
                  moniteurD:=moniteur_PAPOL('DOWN');
                  litspectre2D_PAPOL(decalage,moniteurD,indexspectreD,comment,'DOWN');
                end;
             end;
          if decalage=3 then
             begin
             moniteurU:=moniteur_PAPOL('UP');
             moniteurD:=moniteur_PAPOL('DOWN');
             litspectre2D_2_PAPOL(moniteurU,moniteurD,indexspectreU,indexspectreD,comment,comment);
             end;
      end;
end;
{ *******************************************************************************}
procedure Toperationform.litparametre2D(var NT,NU,ND:cardinal; var MT,MU,MD,TT,TU,TD:real);
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurPAPOLSurDafMTMX' then litparametre2D_PAPOL(NT,NU,ND,MT,MU,MD,TT,TU,TD);
     If ta='CompteurPAPOLSurDafMTMX_TOF' then litparametre2D_PAPOL(NT,NU,ND,MT,MU,MD,TT,TU,TD);
end;

{*************************************************************************

                                         acquisition en mode TOF
*****************************************************************************}

{************************************
permet de lancer un comptage avec polar fixe sans réinitialiser l'EuroPSD
utilisé pendant une acquisition TOF synchro interne}
function Toperationform.lanceracquisition(TT:real;polarup:boolean):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurPAPOLSurDafMTMX' then lanceracquisition:=DafMTMX_modeB(TT,polarup);
     If ta='CompteurPAPOLSurDafMTMX_TOF' then lanceracquisition:=DafMTMX_modeB(TT,polarup);
end;
{************************************}
procedure Toperationform.litparametre_TOF(polarup:boolean;var ncoups:cardinal; var moniteur,temps:real);
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurPAPOLSurDafMTMX' then ShowMessage('On n''est pas en config TOF');
     If ta='CompteurPAPOLSurDafMTMX_TOF' then litparametre_TOF_PAPOL(polarup,ncoups,moniteur,temps);
end;

{************************************
acquisition en mode TOF polar fixe
utilisé pendant une acquisition TOF externe}

function Toperationform.LancerAcquisition2D_TOF(TT:real;polarup:boolean;retard,largeurcanal:real;nbrframe:integer):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurPAPOLSurDafMTMX' then ShowMessage('On n''est pas en config TOF');
     If ta='CompteurPAPOLSurDafMTMX_TOF' then LancerAcquisition2D_TOF:=LancerAcquisition2D_TOF_PAPOL(TT,polarup,retard,largeurcanal,nbrframe);
end;

{************************************
lecture des data dans le cas d'une acquisition TOF en fonction du decalage}
procedure Toperationform.LireSpectre2D_TOF(decalage:integer;Modepolar:string;comment:string);
var moniteur,moniteurU,moniteurD:real;
    s:string;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurPAPOLSurDafMTMX' then ShowMessage('On n''est pas en config TOF');
     If ta='CompteurPAPOLSurDafMTMX_TOF'
     then begin
          if decalage=4 then
             begin
             moniteur:=moniteur_PAPOL(modepolar);
             litspectre_TOF16_PAPOL(moniteur,comment);
             end;
          if decalage=3 then
             begin
             moniteurU:=moniteur_PAPOL('UP');
             moniteurD:=moniteur_PAPOL('DOWN');
             litspectre_TOF8_PAPOL(moniteurU,moniteurD,comment);
             end;
          end;
end;
{************************************
}
function  Toperationform.initcompteurenTOF (retard,largeurcanal:real;nbrframe:integer):integer;
var index:longint; { index des appareils branchés sur les flippers H et V }
    ta:string;     { type de l'appareil }
    adresse:longint;  { adresse appareil }
begin
     index:=GetIndex('Compteur');
     ta:=GetTypeCompteur(index);
     adresse:=GetAdresseCompteur(index);
     If ta='CompteurPAPOLSurDafMTMX' then ShowMessage('On n''est pas en config TOF');
     If ta='CompteurPAPOLSurDafMTMX_TOF' then EuroPSDInitTOF(retard,largeurcanal,nbrframe);
end;
{==================================================}
{ opérations de tests divers                       }
{==================================================}


procedure Toperationform.Button1Click(Sender: TObject);
begin
     Flipper2_ON;
end;

procedure Toperationform.Button2Click(Sender: TObject);
begin
     TableConfigManip.Locate('Fonction','magneticFieldL',[loCaseInsensitive]);
     Writeln(TableConfigManip.FieldValues['Indexappareil']);
end;

procedure Toperationform.Flipper2ONClick(Sender: TObject);
begin
     Flipper2_ON;
end;

procedure Toperationform.Flipper2OFFClick(Sender: TObject);
begin
     Flipper2_OFF;
end;

procedure Toperationform.Flipper1ONClick(Sender: TObject);
begin
     Flipper1_ON;
end;

procedure Toperationform.Flipper1OFFClick(Sender: TObject);
begin
     Flipper1_OFF;
end;

procedure Toperationform.SetFieldClick(Sender: TObject);
begin
     SetFieldT(FieldT.value);
end;

procedure Toperationform.Button3Click(Sender: TObject);
begin
{     SetCourantFlipper2H(courant.value); }
end;

procedure Toperationform.FormCreate(Sender: TObject);
begin
tableconfigmanip.open;
tableappareils.open;
tablecomptage.open;
end;

{spectre3 = spectre1 + spectre2}
function Toperationform.Addspectre(spectre1,spectre2,spectre3:string):boolean;
begin
 deuxd:=spectlist.create;
 result:=deuxd.addition(spectre1,spectre2,spectre3);
end;

{spectre3 = spectre1 - spectre2}
function Toperationform.Subspectre(spectre1,spectre2,spectre3:string):boolean;
begin
 deuxd:=spectlist.create;
 result:=deuxd.soustraction(spectre1,spectre2,spectre3);
end;

{spectre3 = spectre1 * spectre2}
{function Toperationform.Multspectre(spectre1,spectre2,spectre3:string):boolean;
begin
 deuxd:=spectlist.create;
 result:=deuxd.multiplication(spectre1,spectre2,spectre3);
end;
}
{spectre3 = spectre1 / spectre2}
{function Toperationform.Divspectre(spectre1,spectre2,spectre3:string):boolean;
begin
 deuxd:=spectlist.create;
 result:=deuxd.division(spectre1,spectre2,spectre3);
end;
}
end.
