{ Вспомогательные  функции }

{---------------------------------------------------------------------------
The control units for mass-spectrometer MI1201-AGM
(c) Copyright	 Aleksandrov O.E., 1998

Модуль управления масс-спектрометром МИ1201-АГМ
(c) Собственность     Александрова О.Е., 1998

   Molecular Physics department	 	620002, Екатеринбург, К-2
   USTU, Ekaterinsburg, K-2, 620002     УГТУ,
   RUSSIA     	   			Кафедра молекулярной физики
   phone 75-48-39                       тел. 75-48-39

   E-mail: aleks@dpt.ustu.ru
----------------------------------------------------------------------------}
Unit MiscFunc;
{$IfNDef Seg16}
// !!! Компиляция без директивы { $DEFINE Seg16 } требует Delphi 3
{$EndIF}

INTERFACE
  USES
    {$IfNDef Seg16}Windows,{$EndIF}
    MiTypes
    ;

type
  tBDCByte=0..99;
  tBDCWord=0..9999;

  { единицы измерения }
  tMeasureUnit=(uNone, mkVolt, mkAmper);

{$IfDef Seg16}
function GetTickCount:longint;
{$EndIf Def Seg16}

{$IfNDef Seg16}
// Возвращает минимальное значение приращения для GetTickCount
function GetTickCountResolution:word;
{$EndIf Def Seg16}

{$IfNDef Seg16}
function timeSpentTime(StartTimeTiks:cardinal):cardinal; register;
function timeSpentEx(StartTimeTiks,Time_ms:cardinal):boolean; register;
function TimeSpentTicks(StartTimeTiks:cardinal):cardinal; register;
function TimeSpent(StartTimeTiks,Time_ms:cardinal):boolean; register;
{$else}
function TimeSpentTicks(StartTimeTiks:longint):longint;
function TimeSpent(StartTimeTiks,Time_ms:longint):boolean;
{$EndIf Def Seg16}

{ конвертирует двоично-десятичное преставление БАЙТА (2 десятичных цифры)
в двоичное}
function ByteBdc2Bin(BDC:Byte):byte;
function ByteBin2Bdc(bin:Byte):word;

{ конвертирует двоично-десятичное преставление СЛОВА (4 десятичных цифры)
в двоичное}
function WordBdc2Bin(BDC:Word):word;
function WordBin2Bdc(bin:Word):longint;

function BytesToLongint(b1,b2,b3,b4:Byte):longint;
function BytesToWord(bLo, bHi:byte):word;

{ возвращает строку с двоичной записью NUM (32 разряда)}
function DWord2BinaryStr(num:longint):string;

{ возвращает строку с двоичной записью NUM (16 разрядов)}
function Word2BinaryStr(num:word):string;

{ возвращает строку с двоичной записью NUM (8 разрядов)}
function Byte2BinaryStr(num:byte):string;

{ возвращает строку названия единицы измерения }
function MUnit2Str(u:tMeasureUnit):string;

type
  ttiFlag=(fEndInterval);
  ttiFlags=set of ttiFlag;
  tTimeInterval=object
   public
    procedure Start(TimeInterval:tTiks);
    procedure ReStart;
    function  Increment(TimeInterval:tTiks):tTiks;
    function  Decrement(TimeInterval:tTiks):tTiks;
    function  IntervalEnd:boolean;
    function  NotIntervalEnd:boolean;
    procedure CancelInterval;
    function  TimeSpend:tTiks;
    function  TimeSpendSinceStarted:tTiks;
    function  TimeLeft:tTiks;
   private
      prTimeInterval,prStartTime,prTimeSpend:tTiks;
      prFlags:ttiFlags;
  end;

{function  ControlSum(var Data; Size:word):word;}

IMPLEMENTATION
  Uses {$IfNDef Seg16}MMSystem,{$EndIf} StrTrs32;

procedure tTimeInterval.Start;
begin
//  prStartTime:=GetTickCount;
  prStartTime:=timeGetTime;
  prTimeInterval:=TimeInterval;
  prTimeSpend:=0;
  prFlags:=[];
end;

procedure tTimeInterval.ReStart;
begin
  prStartTime:=timeGetTime;
//  prStartTime:=GetTickCount;
  prTimeSpend:=0;
  prFlags:=[];
end;

function  tTimeInterval.Increment;
begin
  if IntervalEnd then
    Start(TimeInterval)
  else if TimeInterval>0 then begin
    Inc(prTimeInterval,TimeInterval);
    Exclude(prFlags,fEndInterval);
  end;
  Increment:=TimeLeft;
end;

function  tTimeInterval.Decrement;
begin
  if not IntervalEnd then begin
    if TimeInterval>prTimeInterval then begin
      Dec(prTimeInterval,TimeInterval);
    end else begin
      CancelInterval;
      prTimeInterval:=0;
    end;
  end;
  Decrement:=TimeLeft;
end;

function  tTimeInterval.IntervalEnd:boolean;
begin
//  if not (fEndInterval in prFlags) and TimeSpent(prStartTime,prTimeInterval) then begin
  if not (fEndInterval in prFlags) and TimeSpentEx(prStartTime,prTimeInterval) then begin
    CancelInterval;
  end;
  IntervalEnd:=(fEndInterval in prFlags);
end;

function  tTimeInterval.NotIntervalEnd:boolean;
begin
  NotIntervalEnd:=not IntervalEnd;
end;

procedure tTimeInterval.CancelInterval;
begin
//  prTimeSpend:=TimeSpentTicks(prStartTime);
  prTimeSpend:=TimeSpentTime(prStartTime);
  Include(prFlags,fEndInterval);
end;

function tTimeInterval.TimeSpend;
begin
  if IntervalEnd then
    TimeSpend:=prTimeSpend
  else
//    TimeSpend:=TimeSpentTicks(prStartTime);
    TimeSpend:=TimeSpentTime(prStartTime);
end;

function tTimeInterval.TimeSpendSinceStarted;
begin
//  TimeSpendSinceStarted:=TimeSpentTicks(prStartTime);
  TimeSpendSinceStarted:=TimeSpentTime(prStartTime);
end;

function tTimeInterval.TimeLeft;
  var tl:integer;
begin
  if IntervalEnd then
    TimeLeft:=0
  else begin
//    tl:=prTimeInterval-TimeSpentTicks(prStartTime);
    tl:=prTimeInterval-TimeSpentTime(prStartTime);
    if tl>=0 then
      TimeLeft:=tl
    else
      TimeLeft:=0;
  end;
end;

function MUnit2Str(u:tMeasureUnit):string;
  type tUNameStr=string[3];
       tUNameArr=array[tMeasureUnit] of tUNameStr;

  const cUName:tUNameArr= ('', 'мкВ','мкА');
begin
 MUnit2Str:=cUName[u];
end;

{$IfDef Seg16}
function GetTickCount:longint;
assembler;
asm
  mov es,Seg0040; mov bx,06Ch
  mov ax,es:[bx]
  mov cx,es:[bx][2]
  mov bx,55
  mul bx
  xchg cx,ax; mov si,dx
  mul bx
  mov dx,si; add dx,ax
  mov ax,cx
end;
{$EndIf Def Seg16}

{$IfNDef Seg16}
function GetTickCountResolution:word;
  var i:integer; T0,T1:cardinal; dT,dTmin:word;
begin
  i:=10;
  repeat
    dTmin:=High(dTmin);
    T0:=GetTickCount;
    repeat
      T1:=GetTickCount;
    until (T0<>T1);
    dT:=T1-T0;
    if (dT < dTmin) then dTmin:=dT else Dec(i);
    Dec(i);
  until (i<=0) or (dTmin=1);
  GetTickCountResolution:=dTmin
end;
{$EndIf NDef Seg16}

const
  cBinaryDigits='01';
  c0Str='00000000000000000000000000000000';
  cZerosStr:string[Length(c0Str)]=c0Str;

function DWord2BinaryStr;
  var x:string[32];
begin
  x:=DWord2Str(tDWord(num), cBinaryDigits);
  DWord2BinaryStr:=Copy(cZerosStr,1,32-Length(x))+x;
end;

function Word2BinaryStr;
  var x:string[16];
begin
  x:=Word2Str(num, cBinaryDigits);
  Word2BinaryStr:=Copy(cZerosStr,1,16-Length(x))+x;
end;

function Byte2BinaryStr;
  var x:string[8];
begin
  x:=Word2Str(num, cBinaryDigits);
  Byte2BinaryStr:=Copy(cZerosStr,1,8-Length(x))+x;
end;

function ByteBdc2Bin(BDC:Byte):byte;
assembler;
asm
  mov al,BDC; xor ah,ah; shl ax,4; shr al,4
  AAD
end;

function WordBdc2Bin(BDC:Word):word;
assembler;
asm
  mov dx,BDC;
  mov al,dh
  xor ah,ah; shl ax,4; shr al,4
  AAD { AL=две старшие цифры}
  mov cl,100; mul cl; mov cx,ax {  BX=две старшие цифры}
  mov al,dl;
  xor ah,ah; shl ax,4; shr al,4
  AAD { AL = две младшие цифры }
  add ax,cx
end;

function ByteBin2Bdc(bin:Byte):word;
assembler;
asm
  push bx
  mov al,bin; xor ah,ah
  mov cx,10
  xor dx,dx
  div cx {AX:=AX div 10; DX:=AX mod 10}
  mov bl,dl { 1-я десятичная цифра  ->  -> в [1..4] бит BX }
  xor dx,dx
  div cx {AX:=AX div 10; DX:=AX mod 10}
  shl dl,4
  or bl,dl { 2-я десятичная цифра  -> в [5..8] бит BX }
  xor dx,dx
  div cx {AX:=AX div 10; DX:=AX mod 10}
  mov bh,dl { 3-я десятичная цифра  -> в [9..12] бит BX }
  mov ax,bx
  pop bx
end;

function WordBin2Bdc(bin:Word):longint;
assembler;
asm
  push bx
  mov ax,bin;
  mov cx,10
  xor dx,dx
  div cx {AX:=AX div 10; DX:=AX mod 10}
  mov bl,dl { 1-я десятичная цифра -> в [1..4] бит BX }
  xor dx,dx
  div cx {AX:=AX div 10; DX:=AX mod 10}
  shl dl,4
  or bl,dl  { 2-я десятичная цифра  -> в [5..8] бит BX }
  xor dx,dx
  div cx {AX:=AX div 10; DX:=AX mod 10}
  mov bh,dl { 3-я десятичная цифра  -> в [9..12] бит BX }
  or ax,ax; jz @End
  xor dx,dx
  div cx {AX:=AX div 10; DX:=AX mod 10}
  shl dl,4
  or bh,dl  { 4-я десятичная цифра  -> в [13..16] бит BX }
  xor dx,dx
  div cx {AX:=AX div 10; DX:=AX mod 10}
  { 5-я десятичная цифра в  -> в [1..4] бит DX }
  @End:
  mov ax,bx
  pop bx
end;

function BytesToLongint(b1,b2,b3,b4:Byte):longint;
assembler;
{$IfDef Seg16}
asm
  mov al,b1; mov ah,b2; mov dl,b3; mov dh,b4
end;
{$Else}
asm
  mov al,b3; mov ah,b4; shl eax,16
  mov al,b1; mov ah,b2;
end;
{$EndIf}

function BytesToWord(bLo, bHi:byte):word;
assembler;
asm
  mov al,bLo; mov ah,bHi;
end;

function TimeSpentTicks;
assembler;
asm
{$IfNDef Seg16}
   push StartTimeTiks
   call GetTickCount;
   pop edx
   sub eax,edx
{$else}
   call GetTickCount;
   sub ax,word(StartTimeTiks)
   sbb dx,0
   sub dx,word(StartTimeTiks[2])
{$EndIf Def Seg16}
end;

{$IfNDef Seg16}
function timeSpentTime(StartTimeTiks:cardinal):cardinal; register;
assembler;
asm
   push StartTimeTiks
   call timeGetTime;
   pop edx
   sub eax,edx
end;

function timeSpentEx(StartTimeTiks,Time_ms:cardinal):boolean; register;
assembler;
asm
   or  Time_ms,Time_ms; jz @Spent
   push Time_ms
   push StartTimeTiks
   call timeGetTime;
   pop edx
   sub eax,edx
   pop edx
   sub eax,edx
   jb @NotSpent
   @Spent:
     mov eax,TRUE
   ret
   @NotSpent:
     mov eax,FALSE
end;
{$EndIf Def Seg16}

function TimeSpent;
assembler;
asm
{$IfNDef Seg16}
   or  Time_ms,Time_ms; jz @Spent
   push Time_ms
   push StartTimeTiks
   call GetTickCount;
   pop edx
   sub eax,edx
   pop edx
   sub eax,edx
   jb @NotSpent
   @Spent:
     mov eax,TRUE
   ret
   @NotSpent:
     mov eax,FALSE
{$else}
   cmp word(Time_ms),0; jne @Cont
   cmp word(Time_ms[2]),0; je @Spent
   @Cont:
   call GetTickCount;
   sub ax,word(StartTimeTiks)
   sbb dx,0
   sub dx,word(StartTimeTiks[2])
   sub ax,word(Time_ms)
   sbb dx,0
   jc @Spent
   sub dx,word(Time_ms[2])
   ja @NotSpent
     @Spent: mov eax,TRUE
   jmp @end
   @NotSpent:
     mov eax,FALSE
   @end:
{$EndIf Def Seg16}
end;
END.