unit Hardware;

interface
uses
     Windows,
     Controllers,
     Controller_ISSB,
     Controller_Voltage,
     Controller_Panel,
     Controller_IonCounter,
     Controller_CVF,
     Controller_UnRolling,
     MassScale, Peak,
     uReadWriteParams;

type



     tParams=record
          ModeGenPeak:byte;

          PeakCount      :tPeakCount;
          MinMass        :tMass;
          MaxMass        :tMass;
          Sigma          :tMass;
          SigmaSigma     :tMass;
          MinAmplitude   :cardinal;
          MaxAmplitude   :cardinal;
          Noise0         :cardinal;
          Noise1         :cardinal;

          NameSpectrFile:string;
          NamePeakFile:string;

          CounterMassCoef:extended;
          CounterdC:extended;

          ShiftChannel:array[1..10] of extended;
     end;

//--------------------------------------------------------------------------

     tNameController=(ctrlISSB,ctrlVoltage,ctrlCtrlPanel,ctrlIonCounter,ctrlCVF,ctrlUnRolling);
     tControllers=array[tNameController] of tController;

     tMI1201AGMEmulator=class
     private
          mutex:tHandle;
          Peaks:tMassScale;
          RWParams:tReadWriteParams;

          function TryLock:boolean;
          function Lock:boolean;
          procedure UnLock;
          function GetMass:cardinal;


     public
          Controllers         :tControllers;
          
          constructor Create;
          destructor Destroy; override;

          function InB(Port:word):byte;
          procedure OutB(b:byte; Port:word);

          procedure UpdateWarringSignal;
          procedure UpdateSignal;
          function GetNoise(Time:cardinal;sgnl:tSignal):tSignal;
          procedure SetVoltage(n:byte; Value:real);
          function GetVoltage(n:byte):real;

          procedure ReadParams;
          procedure WriteParams;
          procedure ReInitPeaks;
     end;


var
     MI1201AGM:tMI1201AGMEmulator;
     StartRun:boolean;
     Params:tParams;
implementation



//*****************************************************************************
// t M I 1 2 0 1 A G M E m u l a t o r
//*****************************************************************************


//-----------------------------------------------------------------------------
//    Инициализирует класс tMI1201, а также классы контроллеров, класс генерации
// выходного сигнала. Осуществляет чтение параметров работы параметров из файла,
// для чего инициализируется соответствующий класс, считывает параметры в
// глобальную переменную Params.
//-----------------------------------------------------------------------------
constructor tMI1201AGMEmulator.Create;
begin
     mutex:=CreateMutex(nil, TRUE, nil);

     RWParams:=tReadWriteParams.Create;
     ReadParams;

     Peaks:=tMassScale.Create;

     Controllers[ctrlISSB]:=tISSB.Create;
     Controllers[ctrlVoltage]:=tVoltage.Create;
     Controllers[ctrlCtrlPanel]:=tCtrlPanel.Create;
     Controllers[ctrlCVF]:=tCVF.Create;
     Controllers[ctrlIonCounter]:=tIonCounter.Create;
     Controllers[ctrlUnRolling]:=tUnRolling.Create;

     UnLock;
end;



//-----------------------------------------------------------------------------
//    Деинсталлирует класс tMI1201, а также классы контроллеров, класс генерации
// выходного сигнала и класс чтения из файла параметров.
//-----------------------------------------------------------------------------
destructor tMI1201AGMEmulator.Destroy;
var
     i:tNameController;
begin
     if Lock then begin
          for i:=Low(i) to High(i) do begin
               Controllers[i].Destroy;
               Controllers[i]:=nil;
//               FreeAndNil(Controllers[i]);
          end;
          Peaks.Destroy;
          Peaks:=nil;
          RWParams.Destroy;
     end;
     UnLock;
end;



//-----------------------------------------------------------------------------
//     Вызывает процедуру с параметром b определенного класса контроллера.
// Класс контроллера определяется значением параметра Port.
//-----------------------------------------------------------------------------
procedure tMI1201AGMEmulator.OutB(b:Byte; Port:word);
var
     i:tNameController;
     BasePort:word;
begin
     if TryLock then begin
          BasePort:=Port and $FF00;
          Port:=Port and $FF;
          for i:=Low(i) to High(i) do begin
               if Controllers[i].ValidPort(Port, BasePort) then begin
                    if Controllers[i].ValidWritePort(Port) then begin
                         Controllers[i].OutB(b,Port);
                     end else begin
//                   RunError(201);
                    end;
                end else begin
//               RunError(201);
               end;
          end;
      end else begin
          halt(0);
          MessageBox(0,'TryLock','mi1201 outb', MB_OK);
     end;
     UnLock;
end;



//-----------------------------------------------------------------------------
//     Возращаемое значение, является результатом функции определенного класса
// контроллера. Класс контроллера определяется значением параметра Port.
//-----------------------------------------------------------------------------
function tMI1201AGMEmulator.InB(Port:word):byte;
var
     i:tNameController;
     BasePort:word;
begin
     Result:=$FF;
     if TryLock then begin
          BasePort:=Port and $FF00;
          Port:=Port and $FF;
          for i:=Low(i) to High(i) do begin
               if Controllers[i].ValidPort(Port, BasePort) then begin
                    if Controllers[i].ValidReadPort(Port) then begin
                         Result:=Controllers[i].InB(Port);
                         break;
                     end else begin
//                    RunError(201);
                    end;
               end;
          end;
     end else begin
          halt(0);
          MessageBox(0,'TryLock','mi1201 inb', MB_OK);
     end;
     UnLock;
end;




//-----------------------------------------------------------------------------
//     Обновляет аварийные сигналы, находящиеся в классе контроллера канала
// питания источника ионов согласно состоянию блоков из класса контроллера
// пульта управления.
//-----------------------------------------------------------------------------
procedure tMI1201AGMEmulator.UpdateWarringSignal;
begin
     if (bBPGI in tCtrlPanel(Controllers[ctrlCtrlPanel]).GetStateBlock) then begin
          tISSB(Controllers[ctrlISSB]).WarringSignalOn(wsBPGI_ON);
      end else begin
          tISSB(Controllers[ctrlISSB]).WarringSignalOff(wsBPGI_ON);
     end;
     if (b10kV in tCtrlPanel(Controllers[ctrlCtrlPanel]).GetStateBlock) then begin
          tISSB(Controllers[ctrlISSB]).WarringSignalOn(wsHighVoltage_ON);
     end else begin
          tISSB(Controllers[ctrlISSB]).WarringSignalOff(wsHighVoltage_ON);
     end;
end;


//-----------------------------------------------------------------------------
//     Подготавливает данные выходных сигналов.
//-----------------------------------------------------------------------------
procedure tMI1201AGMEmulator.UpdateSignal;
var
     u:tUPT;
     m:tMass;
     Sgnl:tSignal;
begin
     m:=GetMass;

     tIonCounter(Controllers[ctrlIonCounter]).SetSignalDate(Peaks.Signal(round(m*(1+Params.ShiftChannel[10]))));

     for u:=Low(u) to High(u) do begin
          tVoltage(Controllers[ctrlVoltage]).SetVoltages(u,Peaks.Signal(round(m*(1+Params.ShiftChannel[Ord(u)-5]))));
     end;
end;


//-----------------------------------------------------------------------------
//     Считывает параметры работы эмулятора из файла в глобальную переменную Params.
//-----------------------------------------------------------------------------
procedure tMI1201AGMEmulator.ReadParams;
begin
     RWParams.ReadParams;
end;

//-----------------------------------------------------------------------------
//     Записывает параметры работы эмулятора из глобальной переменной Params в файл.
//-----------------------------------------------------------------------------
procedure tMI1201AGMEmulator.WriteParams;
begin
     RWParams.WriteParams;
end;


//-----------------------------------------------------------------------------
procedure tMI1201AGMEmulator.SetVoltage(n:byte; Value:real);
begin
     tVoltage(Controllers[ctrlVoltage]).SetVoltages(tVoltagePoint(n), Value);
end;

//-----------------------------------------------------------------------------
function tMI1201AGMEmulator.GetVoltage(n:byte):real;
begin
     Result:=tVoltage(Controllers[ctrlVoltage]).GetVoltages(tVoltagePoint(n));
end;



//==============================================================================
// Вспомогательные процедуры и функции
//==============================================================================

//-----------------------------------------------------------------------------
function tMI1201AGMEmulator.TryLock:boolean;
begin
     Result:=WaitForSingleObject(mutex,3000)=Wait_OBJECT_0;

end;

//-----------------------------------------------------------------------------
function tMI1201AGMEmulator.Lock:boolean;
begin
     Result:=WaitForSingleObject(mutex,infinite)=Wait_OBJECT_0;

end;

//-----------------------------------------------------------------------------
procedure tMI1201AGMEmulator.UnLock;
begin
     ReleaseMutex(mutex)
end;

//-----------------------------------------------------------------------------
function tMI1201AGMEmulator.GetMass:tMass;
begin
     Result:=tUnRolling(Controllers[ctrlUnRolling]).GetMass;
end;

//-----------------------------------------------------------------------------
procedure tMI1201AGMEmulator.ReInitPeaks;
begin
     Peaks.ReInit;
end;


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
function tMI1201AGMEmulator.GetNoise(Time:cardinal;sgnl:tSignal):tSignal;
begin
     Result:=Peaks.GetNoise(Time,sgnl);
end;



//=============================================================================
begin
     StartRun:=false;
end.