DUzun's Web
Programare, proiecte personale, divertisment

unit PrHost;

{ Aici este encapsulat protocolul de comunicare fara moderator }

{-----------------------------------------------------------------------------

  Descriere: 

  Concurenta libera...

 -----------------------------------------------------------------------------}

interface

{-----------------------------------------------------------------------------}

uses

  VProtocol, Funcs, IOStreams, CmdByte, 

  ExtCtrls, Classes;

{-----------------------------------------------------------------------------}

type

  TPrHost = class(TVProtocol)     

     RetryCounter: word;

  private

    StateOnRead: word;

    p, len, tgt, src:  byte;

​

  public

    constructor Create(AOwner: TComponent; FileName: ShortString = '');

​

    function getState():word;

    procedure OnConect(); override;

    procedure OnRead(var State: word); 

    procedure TimerProc(Sender: TObject); 

   end;

{-----------------------------------------------------------------------------}

implementation

{-----------------------------------------------------------------------------}

{ TPrHost }

{-----------------------------------------------------------------------------}

constructor TPrHost.Create;

begin

  inherited Create(AOwner, FileName);

  OnTimer     := TimerProc;

end;

{-----------------------------------------------------------------------------}

function TPrHost.getState: word; begin Result := StateOnRead; end;

{-----------------------------------------------------------------------------}

procedure TPrHost.OnConect();

begin

  StateOnRead := 0; // begining 

  MyAddr := 0;  

  MaxAddr := 0;  

end;

{-----------------------------------------------------------------------------}

procedure TPrHost.OnRead;

begin

    case ReadResult of

     IO_Failed: State := 0; // Reinitializare la eroare

     IO_NoData: ;

     IO_OK:     ;

    end;

  case State of

  0:begin  // Initializare

    RetryCounter := 4; // Nr de incercari

    case ReadResult of

     IO_OK:     State := 1; // Ma conectez...

     IO_NoData: State := 2; // Nimeni conectat

     IO_Failed: exit;       // Mai citeste o data

    end;

  end;

  1:begin  // Conectare

    dec(RetryCounter);

    case ReadResult of

     IO_OK:     State := 3;

     IO_NoData: if(RetryCounter=0)then State:=2 else exit;

     IO_Failed: {???};

    end;

    OnRead(State);

  end;

  2:begin  // Nimeni online

    MaxAddr := $01;

    MyAddr  := $01;

    State   := 5;

  end;

  3:begin  // Asteapta adresa

    if(ReadResult=IO_OK)then

      if(src=$01)and(tgt=$00)and(len>0)then

        case RBAr[p] of

          cmd_tellMe: begin

             SendCmd(cmd_giveAddr, src);

             Writing:=true;

          end;

          cmd_OK or cmd_giveAddr:begin MyAddr:=RBAr[p+1]; State:=4;end;

        end

  end;

  4:begin    // Spune tuturor ca sunt prezent

    if(ReadResult=IO_OK)then

      if(src<>MyAddr)and({(tgt=$00)or}(tgt=MyAddr))and(len>0)then

        case RBAr[p] of

          cmd_tellMe: begin

            SendCmd(cmd_start, ToAll);

            Writing:=true;

            State:=5;

          end;

          cmd_isPresent:begin SendCmd(cmd_OK or cmd_isPresent,src);end;

        end

  end;

  5:begin  // Citire date

    if(ReadResult=IO_OK)then begin

      if((src<>MyAddr)and(tgt=MyAddr)or(tgt=ToAll))and(len>0)then

      case RBAr[p] of   // parsing commands

        cmd_isPresent: SendCmd(RBAr[p] or cmd_OK, src);

        cmd_start: if MaxAddr+1=src then inc(MaxAddr);

        cmd_stop: begin

           if MyAddr=MaxAddr then begin

              MyAddr:=src;

              SendCmd(cmd_readID);

           end else if MyAddr=$01 then begin

              Send(cmd_giveAddr or cmd_OK, GenBAr(src,0,1), MaxAddr);

           end;

           dec(MaxAddr);

        end;

        cmd_giveAddr:begin

            inc(MaxAddr);

            Send(cmd_giveAddr or cmd_OK, GenBAr(MaxAddr,0,1), src);

        end;

        cmd_write:   begin

            lBAr := Copy(RBAr,p,len);

            setLength(lBAr, len+1);

            lBAr[len]:=src;

            RSBuf.Each := lBAr;

        end;

        cmd_tellMe:begin

            Writing:=true;

            dec(CycleCounter, CycleCounter and 1);

        end;

​

        cmd_OK or cmd_giveAddr:MyAddr:=RBAr[p+1];

        cmd_OK or cmd_readID: IDs[src]:=Copy(RBAr,p+1,len-1);

        else

      end;

    end;

  end;

  else

     if ReadResult = IO_OK then begin

        RSBuf.Each := RBAr;

     end;

  end;

end;

{-----------------------------------------------------------------------------}

procedure TPrHost.TimerProc;

begin

   { Reading }

   if(CycleCounter and 1 = 0)then begin 

      p := 0;

      if ReadResult = IO_OK then begin

        ISOSplit(RBAr, p, len, src, tgt);

        if (src<>ToAll)and(src > MaxAddr) then MaxAddr := src;

        if (tgt<>ToAll)and(tgt > MaxAddr) then MaxAddr := tgt;

      end else begin

        len:=0;

        src:=0;

      end;

      OnRead(StateOnRead); // --- Data parsing ---

​

     { $01 is DJ, Boss }

     if(MyAddr=$01)and(CycleCounter and 2 = 0)then begin

        inc(LastAddr);     // Who can write?

        if LastAddr > MaxAddr then LastAddr:=0;

        if LastAddr <> MyAddr then begin

          SetLength(lBAr,3);

          lBAr[0]:=cmd_tellMe;

          lBAr[1]:=$FF and CycleCounter;

          lBAr[2]:=$FF and (CycleCounter shr 8);

          SendData(lBAr, LastAddr);

        end;

        Writing := true; // write in the next Cycle

     end;

   end else begin

  { Writing }

     if(Writing)then begin // --- Have right to write  ---

       Reading := true;   // --- Can write only one frame ---

     end else          

   end;

end;

{-----------------------------------------------------------------------------}

end.

​

​