unit R1;

interface

uses gltype, glproc, mathobj, Classes,SysUtils, MVTU_TLB;

function TElectro_R1(at,adt:RealType;var time,dtime:RealType;
                  var AU,AY:TPtrExt;var AX,ADX:array of RealType;
                  var CU,CY : TIntArray;var Prop:TPtrArray;var Vars:Pointer;
                  Action:Integer):Integer;export;
//-------------------------------------------------------------//
                  implementation
//-------------------------------------------------------------//

type
  PElectro_R1Rec = ^TElectro_R1Rec;
  TElectro_R1Rec = record
    i  : ^realtype; //коэффициент передачи редуктора
    J2 : ^realtype; //момент инерции нагрузки
    a  : ^realtype; //половина ширины люфта
    c  : ^realtype; //коэффициент упругости, приведённый к валу нагрузки
    F  : ^realtype; //коэффициент упругости, приведённый к валу нагрузки
    q0  : ^realtype; //начальный угол поворота вала нагрузки
    pq0 : ^realtype; //начальная частота вращения вала нагрузки
  end;

  PElectro_R1Vars = ^TElectro_R1Vars;
  TElectro_R1Vars = record
    b, n, kJ, dlt, adx0, aa, bb, cc: realtype;
  end;

function TElectro_R1Convert(Action:  integer;
                          Vars:    Pointer;
                          Prop:    TPtrArray;
                          PropStr: TStringList;
                          BlockId: integer;
                          var MVTU: IMVTU_Server):integer;
  const RecName:PChar = 'Редуктор (упрощённый)';
  var
      Res: integer;
begin
  case Action of
    //Возвращаем ссылку на имя записи в базе МВТУ-4
    cnv_GetRecName: Result:=integer(RecName);
    cnv_Convert: try
                   //Присваиваем параметры для блока
                   MVTU.SetBlockProp(BlockId,'i',PChar(PropStr[0]),Res);
                   MVTU.SetBlockProp(BlockId,'J2',PChar(PropStr[1]),Res);
                   MVTU.SetBlockProp(BlockId,'a',PChar(PropStr[2]),Res);
                   MVTU.SetBlockProp(BlockId,'c',PChar(PropStr[3]),Res);
                   MVTU.SetBlockProp(BlockId,'F',PChar(PropStr[4]),Res);
                   MVTU.SetBlockProp(BlockId,'q0',PChar(PropStr[5]),Res);
                   MVTU.SetBlockProp(BlockId,'pq0',PChar(PropStr[6]),Res);
                 finally
                 end;
  end;
end;

function TElectro_R1;export;
var
  k : Integer;
begin
  Result := 0;
  case Action of
    f_GetConvertFuncAdr: Result:=integer(@TElectro_R1Convert);
    // Выделяем память под переменные блока:
    f_Create        : Vars := New(PElectro_R1Vars);
    // Освобождаем память переменных блока:
    f_Free          : Dispose(Vars);
    f_GetDeriCount  : Result := 2; //две дифференциальных переменных в блоке --
                                   //угол поворота(q), скорость вращения(pq)
    f_GetInit       : Result := 1; //блок приоритетный или нет???
    f_GetCount      : begin
                        for k:=0 to (CY.Count-1) do CY.arr^[k]:=1; // размер выходов строго определён
                        for k:=0 to (CU.Count-1) do CU.arr^[k]:=1; // и входов тоже ( 1 )
                      end;
    f_UpdateJacoby,
    f_InitState,
    f_UpdateOuts,
    f_RestoreOuts,
    f_GoodStep      : with PElectro_R1Vars(Vars)^ do
                      with PElectro_R1Rec(Prop.arr)^ do begin
                        if Action = f_InitState then begin
                          AX[0]:=pq0^;
                          AX[1]:=q0^;
                          n := 1/i^;
                          b := -a^;
                          kJ := 1/J2^;
                        end;

                        // обыгрываем (нечестно) блок сложения трёх чисел:
                        aa := n * AU.Ptr(0).arr^[0];
                        bb := AX[1];
                        cc := AX[0]*F^;
                        dlt := aa - bb;
                        dlt := dlt -cc;
                        //обыгрываем зону нечувствительности:
                        if (dlt < b) then
                          adx0 := c^ * (dlt - b)
                        else if (dlt > a^) then
                          adx0 := c^ * (dlt - a^)
                        else
                          adx0 := 0;

                        AY.Ptr(0).arr^[0] := AX[1]; // q
                        AY.Ptr(1).arr^[0] := AX[0]; // pq
                        AY.Ptr(2).arr^[0] := adx0;
                      end;
    f_GetDeri       : with PElectro_R1Vars(Vars)^ do
                      with PElectro_R1Rec(Prop.arr)^ do begin
                        // обыгрываем (нечестно) блок сложения трёх чисел:
                        aa := n * AU.Ptr(0).arr^[0];
                        bb := AX[1];
                        cc := AX[0]*F^;
                        dlt := aa - bb;
                        dlt := dlt -cc;
                        //обыгрываем зону нечувствительности:
                        if (dlt < b) then
                          adx0 := c^ * (dlt - b)
                        else if (dlt > a^) then
                          adx0 := c^ * (dlt - a^)
                        else
                          adx0 := 0;
                        ADX[0] := kJ * adx0;
                        ADX[1] := AX[0]; // q
                        //ADX[2] := adx2;
                      end;
    f_EditErr       :   if (   (PElectro_R1Rec(Prop.arr)^.J2^  <= 0)
                            OR (PElectro_R1Rec(Prop.arr)^.a^  < 0)
                            OR (PElectro_R1Rec(Prop.arr)^.c^  < 0)
                           )
                            then Result:=er_RangeMin;
   end; // case
end; //TElectro_R1
end.