unit Controller_ISSB;
//=============================================================================
// Контроллера канала питания источника ионов (АК2)
//=============================================================================
interface

USES
     Controllers;

const
     cDataSignature='ISSB';                       // Ветвь в реестре
     
     cBasePort=$ED00;                             // Базовый порт
     cValidPorts=[$90..$97];                      // Доступные порты
     cValidReadPorts=[$90];                       // Порты для чтения
     cValidWritePorts=[$91..$97];                 // порты для записи

type

                              // Тип шаговых двигателей
     tMotor=(mCorrZ, mCorrY, mFocusU, mExtrU, mEmisI, mIonizU);
     tMotorCounter=0..3;
//     tMotorSignalScale=0..1000;
//     tMotorSignalScales=array[tMotor] of tMotorSignalScale;
     tMotorData=record
          Pos       :word;
          MaxPos    :word;
          OptPos    :word;
          Counter   :tMotorCounter;
     end;
     tMotors=array[tMotor] of TMotorData;


                              // Тип аварийных сигналов
     tFlagsWarringSignal=(wsCatodOk, wsBPGI_ON, wsHighVoltage_ON,wsOverload, wsBeam_Off);
     tCodesWarringSignal=0..31;
     tFlagToCode=array[tFlagsWarringSignal] of tCodesWarringSignal;
const
     FlagToCode:tFlagToCode = ($1,$2,$4,$8,$10);
type
     tWarringSignal=record
          CodeWarringSignal  :tCodesWarringSignal;
          FlagWarringSignal  :set of tFlagsWarringSignal;
     end;

                              // сохраняемые параметры
     tData=record
          Motors         :tMotors;
          WarringSignal  :tWarringSignal;
     end;


                              // Класс контроллера
     tISSB=class(tController)
     private
          procedure BeamSet(b:byte);
          procedure MotorSet(m:tMotor; b:byte);
          function  WarringSignalGet:byte;
     public
          Data           :tData;

          constructor Create;
          destructor Destroy; override;

          procedure Init; override;

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

          function ValidPort(Port:word; BasePort:word):boolean; override;
          function ValidReadPort(Port:word):boolean; override;
          function ValidWritePort(Port:word):boolean; override;

          function DataSize:cardinal; override;
          function SetData(aData:Pointer):boolean; override;
          function GetData(aData:Pointer):boolean; override;
          function SubPath:string; override;

          procedure WarringSignalOn(Signal:tFlagsWarringSignal);
          procedure WarringSignalOff(Signal:tFlagsWarringSignal);
     end;


implementation

uses
     Windows;





//*****************************************************************************
//     t I S S B
//*****************************************************************************


//-----------------------------------------------------------------------------
// Инициализирует класс контроллера, устанавливает значения рабочих параметров класса.
//-----------------------------------------------------------------------------
constructor tISSB.Create;
begin
     inherited;
end;


//-----------------------------------------------------------------------------
// Деинициализирует класс контроллера, сохраняя значения рабочих параметров.
//-----------------------------------------------------------------------------
destructor tISSB.Destroy;
begin
     inherited;
end;




//-----------------------------------------------------------------------------
// Устанавливает значения рабочих параметров по умолчанию.
//-----------------------------------------------------------------------------
procedure tISSB.Init;
var
     m         :tMotor;
begin
     Data.WarringSignal.CodeWarringSignal:=$13;
     Data.WarringSignal.FlagWarringSignal:=[wsCatodOk, wsBeam_Off, wsBPGI_ON];
     for m:=Low(m) to High(m) do begin
          Data.Motors[m].Pos:=0;
          Data.Motors[m].MaxPos:=100;
     end;
     Data.Motors[mEmisI].MaxPos:=500;
     Data.Motors[mIonizU].MaxPos:=500;
     for m:=Low(m) to High(m) do begin
          Data.Motors[m].OptPos:=((Data.Motors[m].MaxPos) div 2) + 3*ord(m);
     end;
end;





//-----------------------------------------------------------------------------
//      Возвращает TRUE если Port и BasePort соответствуют порту данного класса
// контроллера(см. таблицу`````````), иначе возвращает FALSE.
//-----------------------------------------------------------------------------
function tISSB.ValidPort(Port:word; BasePort:word):boolean;
begin
     Result:=(Port in cValidPorts) and (BasePort=cBasePort);
end;



//-----------------------------------------------------------------------------
//     Возвращает TRUE если Port соответствуют порту, разрешенному для чтения
// байта из него, данного класса контроллера(см. таблицу`````````). Иначе возращает FALSE.
//-----------------------------------------------------------------------------
function tISSB.ValidReadPort(Port:word):boolean;
begin
     Result:=Port in cValidReadPorts;
end;



//-----------------------------------------------------------------------------
//      Возвращает TRUE если Port соответствуют порту, разрешенному для записи
// байта в данный порт, данного класса контроллера(см. таблицу`````````). Иначе
// возвращает FALSE.
//-----------------------------------------------------------------------------
function tISSB.ValidWritePort(Port:word):boolean;
begin
     Result:=Port in cValidWritePorts;
end;


//-----------------------------------------------------------------------------
//      Возвращает размер памяти в байтах, необходимый для сохранения рабочих
// параметров класса контроллера.
//-----------------------------------------------------------------------------
function tISSB.DataSize:cardinal;
begin
     Result:=SizeOf(tData);
end;



//-----------------------------------------------------------------------------
//      Из указанной aDate области памяти, копируются данные рабочих параметров
// класса контроллера.
//-----------------------------------------------------------------------------
function tISSB.SetData(aData:Pointer):boolean;
begin
     Result:=false;
     try
          Move(aData^, Data, DataSize);
          Result:=True;
     except
     end;
end;



//-----------------------------------------------------------------------------
// В указанную aDate область памяти копируются рабочие параметры класса контроллера.
//-----------------------------------------------------------------------------
function tISSB.GetData(aData:Pointer):boolean;
begin
     Result:=false;
     try
          Move(Data, aData^, DataSize);
          Result:=True;
     except
     end;
end;



//-----------------------------------------------------------------------------
//      Возвращает имя раздела реестра ОС семейства Windows куда сохраняются
// рабочие параметры класса контроллера.
//-----------------------------------------------------------------------------
function tISSB.SubPath:string;
begin
     Result:=cDataSignature;
end;


//-----------------------------------------------------------------------------
// Включает заданный аварийный сигнал
//-----------------------------------------------------------------------------
procedure tISSB.WarringSignalOn(Signal:tFlagsWarringSignal);
begin
     if not(Signal in Data.WarringSignal.FlagWarringSignal) then begin
          Include(Data.WarringSignal.FlagWarringSignal, Signal);
          Inc(Data.WarringSignal.CodeWarringSignal, FlagToCode[Signal]);
     end;
end;

//-----------------------------------------------------------------------------
// Отключает заданный аварийный сигнал
//-----------------------------------------------------------------------------
procedure tISSB.WarringSignalOff(Signal:tFlagsWarringSignal);
begin
     if (Signal in Data.WarringSignal.FlagWarringSignal) then begin
          Exclude(Data.WarringSignal.FlagWarringSignal, Signal);
          Dec(Data.WarringSignal.CodeWarringSignal, FlagToCode[Signal]);
     end;
end;

//-----------------------------------------------------------------------------
//      Управление параметром луча стабилизатора напряжения
// (b=0 обозначает - луч выключить; b=1 - луч включить; b <> 0,1 - ошибка.).
//-----------------------------------------------------------------------------
procedure tISSB.BeamSet(b:byte);
begin
     case b of
          1:WarringSignalOn(wsBeam_Off);
          0:WarringSignalOff(wsBeam_Off);
          else begin
               MessageBox(0,'BeamSet','ISSB', MB_OK);
               RunError(201);
          end;
     end;
end;



//-----------------------------------------------------------------------------
//      Изменение значения величины для устройства, заданного параметром m .
// Увеличивая параметр b на 1 (или по кругу 0,1,2,3,0,..) по сравнению с предыдущим
// вызовом, увеличиваем для заданного устройства значение величины на 1, уменьшая
// b - уменьшаем значение величины на 1.
//-----------------------------------------------------------------------------
procedure tISSB.MotorSet(m:tMotor; b:Byte);
var
     Def:Shortint;
begin
     b:=b and 3;
     with Data.Motors[m] do begin
          Def:=b-Counter;
          case Abs(Def) of
               0:begin
                    Counter:=b;
               end;

               1:begin
                    if Def>0 then begin
                         if Pos<MaxPos then begin
                              Inc(Pos);
                         end;
                     end else begin
                         if Pos>0 then begin
                              Dec(Pos);
                         end;
                    end;
                    Counter:=b;
               end;

               2:begin
//                    Counter:=b;
                    MessageBox(0,'MotorSet','ISSB', MB_OK);
                    RunError(201);
               end;

               3:begin
                    if Def<0 then begin
                         if Pos<MaxPos then begin
                              Inc(Pos);
                         end;
                     end else begin
                         if Pos>0 then begin
                              Dec(Pos);
                         end;
                    end;
                    Counter:=b;
               end;
          end;
     end;
end;



//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
procedure tISSB.OutB(b:byte; Port:word);
begin
     case Port of
          $91:begin
               BeamSet(b);
          end;

          $92:begin
               MotorSet(mCorrZ,b);
          end;

          $93:begin
               MotorSet(mCorrY,b);
          end;

          $94:begin
               MotorSet(mFocusU,b);
          end;

          $95:begin
               MotorSet(mExtrU,b);
          end;

          $96:begin
               MotorSet(mEmisI,b);
          end;

          $97:begin
               MotorSet(mIonizU,b);
          end;
     end;
end;



//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
function tISSB.InB(Port:word):byte;
begin
     Result:=$FF;
     case Port of
          $90:begin
               Result:=WarringSignalGet;
          end;
     end;
end;


//-----------------------------------------------------------------------------
//      Возвращает код аварийного сигнала.
//-----------------------------------------------------------------------------
function tISSB.WarringSignalGet:Byte;
begin
     Result:=Data.WarringSignal.CodeWarringSignal;
end;

end.