AlarmeJT Code

{********************************************************************************
***                               AlarmeJT                                    ***
***    AlarmeJT is designed to work with exellent WSJT -X Joe Taylor, K1JT    ***
***    running on JT65A, JT9 and FT8 modes.                                   ***
***    -------------------------------------------------------------------    ***
***    version : 0.8 UDP beta                                                 ***
***    -------------------------------------------------------------------    ***
***    Copyright 2017 Alain Thébault (F5JMH)                                  ***
***                                                                           ***
***    UDP and NetworkMessageUtils modules by G4WJS (thank's)                 ***
***                                                                           ***
***    This file is part of AlarmeJT.                                         ***
***                                                                           ***
***    AlarmeJT is free software: you can redistribute it and/or modify       ***
***    it under the terms of the GNU General Public License as published by   ***
***    the Free Software Foundation, either version 2.0 of the License, or    ***
***    any later version.                                                     ***
***                                                                           ***
***    AlarmeJT is distributed in the hope that it will be useful,            ***
***    but WITHOUT ANY WARRANTY; without even the implied warranty of         ***
***    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          ***
***    GNU General Public License for more details.                           ***
***                                                                           ***
***    You should have received a copy of the GNU General Public License      ***
***    along with AlarmeJT.  If not, see <http://www.gnu.org/licenses/>.      ***
***                                                                           ***
***    -------------------------------------------------------------------    ***
********************************************************************************}

unit uudp;

{$mode objfpc}{$H+}

interface

uses
  {$DEFINE UseCThreads}
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}

  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
  ExtCtrls, DateUtils, IdUDPServer, IdSocketHandle,
  IdGlobal, IdComponent, NetworkMessageUtils, ufonction;

type

  { TForm1 }

  { TFUDP }

  TFUDP = class(TForm)
    IdUDPServer1: TIdUDPServer;
    Memo1: TMemo;
    procedure sentToWsjtxFreeText(message: string);    {........................WSJTx messageType 9}
    procedure sentWsjtxMT4(Call: string); {.....................................WSJTx messageType 4}
    procedure IdUDPServer1Status(ASender: TObject; const AStatus: TIdStatus;
      const AStatusText: string);
    procedure IdUDPServer1UDPException(AThread: TIdUDPListenerThread;
      ABinding: TIdSocketHandle; const AMessage: String;
      const AExceptionClass: TClass);
    procedure IdUDPServer1UDPRead(AThread: TIdUDPListenerThread;
      AData: TIdBytes; ABinding: TIdSocketHandle);
  private
    { private declarations }
  public
    { public declarations }
  end;

var
  FUDP: TFUDP;
  UFreq, UModeRX, UModeTX, UDXCall, URSTs, UHeureDeb : string;
  UCall,ULoc : string;
  UIndex:integer;
  peerPort: qword;
  SNR: LongInt;

implementation
    USES ualarmeJT, ucontact;
{$R *.lfm}

{ TForm1 }

procedure TFUDP.IdUDPServer1UDPRead(AThread: TIdUDPListenerThread;
  AData: TIdBytes; ABinding: TIdSocketHandle);
var
  index: Integer = 0;
  magic, schema, messageType: LongInt;
  id, mode, DXCall, report, TXMode, message, DXGrid, DEGrid, DECall, reportReceived: string;
  TXPower, comments, DXName: string;
  frequency: QWord;
  isNew, TXEnabled, transmitting, Decoding: Boolean;
  tm: Longword;
  ztime: TDateTime;
  DT: Double;
  DF: Cardinal;
  date: TDateTime;
  {Ajout ici}
  z: TStringList;
  Memomessage,locator: string;
  rst, RXDF, TXDF: integer;

begin
     //FUDP.IdUDPServer1.Bindings := '127.0.0.1:2237,[::]:2237';

  peerPort := ABinding.PeerPort;     {............................................récupération du port d'écoute}

//  peerPort := 2237;

  // Memo1.Lines.Add('Datagram received - length: ' + IntToStr(Length(AData))); { DO NOT DELETE THIS }
  while index < Length(AData) do
  begin
    Unpack(AData, index, magic);
    //Memo1.Lines.Add('index:' + IntToStr(index) + ' magic:$' + IntToHex(magic,8)); { DO NOT DELETE THIS }
    if (magic = LongInt($ADBCCBDA)) and (index < Length(AData)) then
    begin
      Unpack(AData, index, schema);
      if (schema = 2) and (index < Length(AData)) then
      begin
        Unpack(AData,index,messageType);
        Unpack(AData,index,id);
        //Memo1.Lines.Add('Message type:' + IntToStr(messageType) + ' from:[' + id + ']');   { DO NOT DELETE THIS }

        case messageType of
        0: begin
        //Memo1.Lines.Add('Heartbeat!');  { DO NOT DELETE THIS }
        FalarmeJT.SLedEcoute.Brush.Color:=clGreen;
        end;
        1:         {............................................................Status}
        begin
          Unpack(AData,index,frequency);
          Unpack(AData,index,mode);
          Unpack(AData,index,DXCall);
          Unpack(AData,index,report);
          Unpack(AData,index,TXMode);
          Unpack(AData,index,TXEnabled);
          Unpack(AData,index,transmitting);

          Unpack(AData,index,Decoding);
          Unpack(AData,index,RXDF);
          Unpack(AData,index,TXDF);
          Unpack(AData,index,DECall);
          Unpack(AData,index,DEGrid);
          Unpack(AData,index,DXGrid);

//{ Désactivé car pose problème pour le moment il faudrait dégager le Memo du MT4 ONLY FOR DEBUG
          Memo1.Lines.Add('Status: Frequency: ' + IntToStr(frequency) + ' Mode: ' + mode + ' DX Call: ' + DXCall
                                    + ' Report: ' + report + ' TX Mode: ' + TXMode + ' TX Enabled: ' + BoolToStr(TXEnabled)
                                    + ' Transmitting: ' + BoolToStr(transmitting) + ' Decoding: ' + BoolToStr(Decoding)
                                    + ' RXDF: ' + intToStr(RXDF) + ' TXDF: ' + intToStr(TXDF) + ' DECall: ' + DECall + ' DEGrid: ' + DEGrid
                                    + ' DXGrid: ' + DXGrid);
//}
          Contact.ContactAffiche(DXCall,intToStr(frequency),TXMode,report,DXGrid,BoolToStr(transmitting),BoolToStr(Decoding)); {.... Report = RSTs mode remplacé par TXMode}

          if transmitting then
             FalarmeJT.SLedTransmit.Brush.Color:=clRed
          else
             FalarmeJT.SLedTransmit.Brush.Color:=clGreen;
        end;

        2:         {............................................................Décodage}
        begin
          Unpack(AData,index,isNew);
          Unpack(AData,index,tm);
          ztime := IncMilliSecond(0,tm);
          Unpack(AData,index,SNR);
          Unpack(AData,index,DT);
          Unpack(AData,index,DF);
          Unpack(AData,index,mode);
          Unpack(AData,index,message);

          Memomessage :='Decode:'+' '+BoolToStr(isNew)+' '+FormatDateTime('hhmm',ztime)+' '+IntToStr(SNR)
                                   +' '+ FloatToStrF(DT, ffGeneral,4,1)+' '+IntToStr(DF)
                                   +' '+ mode +' '+ message +' '+ timeToStr(ztime) +' '+ FloatToStr(DT) +' '+ intToStr(tm);
          Memo1.Lines.Add(Memomessage);
          rst:=SNR;                                                             // Ajout rst
          mode:=decodeMode(mode);   {.......................................... #=JT65 et @=JT9 tilde = FT8 ou :=qra64}
          try
          z:=TStringList.Create;
          z.Delimiter:=' ';
          z.DelimitedText:=message;
          if z.count > 1 then begin
             z.Add(message);
             if z[1] = 'DX' then begin
                DXCall := z[2];
                locator := z[3];
             end
             else begin
                  DXCall := z[1];
                  locator := z[2];
             end;

             UCall := z[0];
             locator := z[2];
             Pvalid(UCall,DXCall,mode,locator,rst);                             // Ajout rst
//             saveinfo(FormatDateTime('hhmm',time),DXCall,mode,SNR);             { en test }
          end;
          except
            on E : Exception do WriteLn(Format('ERROR : %s',[e.Message]));
          end;
          z.Free;
        end;

        3:         {............................................................Clear}
        begin
          Memo1.Lines.Add('Clear');
        end;

        5:         {............................................................QSO logged}
        begin
          Unpack(AData,index,date);
          Unpack(AData,index,DXCall);
          Unpack(AData,index,DXGrid);
          Unpack(AData,index,frequency);
          Unpack(AData,index,mode);
          Unpack(AData,index,report);
          Unpack(AData,index,reportReceived);
          Unpack(AData,index,TXPower);
          Unpack(AData,index,comments);
          Unpack(AData,index,DXName);

          Memo1.Lines.Add('QSO logged: Date:' + FormatDateTime('dd-mmm-yyyy hh:mm:ss',date)
                               + ' DX Call:' + DXCall + ' DX Grid:' + DXGrid
                               + ' Frequency:' + IntToStr(frequency) + ' Mode:' + mode + ' Report sent: ' + report
                               + ' Report received:' + reportReceived + ' TX Power:' + TXPower
                               + ' Comments:' + comments + ' Name:' + DXName);
        end
        else
          Memo1.Lines.Add('Unrecognized message type:' + IntToStr(messageType));
        end;
      end;
    end;
  end;
end;

procedure TFUDP.IdUDPServer1UDPException(AThread: TIdUDPListenerThread;
  ABinding: TIdSocketHandle; const AMessage: String;
  const AExceptionClass: TClass);
begin
  Memo1.Lines.Add('UDP server exception: ' + AMessage);
end;

procedure TFUDP.IdUDPServer1Status(ASender: TObject; const AStatus: TIdStatus;
  const AStatusText: string);
begin
  Memo1.Lines.Add('UDP server status: ' + AStatusText);
end;

procedure TFUDP.sentToWsjtxFreeText(message: string);
var
  AData: TIdBytes;
  index: Integer = 0;
  messageType, magic, schema: LongInt;
  TXEnabled: Boolean;
  id: String;
begin
  magic := $ADBCCBDA;
  schema:=2;
  messageType:=9;
  id:='WSJT-X';
  TXEnabled:=True;

  pack(AData, magic);
  pack(AData, schema);
  Pack(AData,messageType);
  pack(AData,id);
  pack(AData, message);
  Pack(AData,TXEnabled);

  IdUDPServer1.SendBuffer('127.0.0.1', PeerPort, AData);
end;



procedure TFUDP.sentWsjtxMT4(Call: string);
var
   AData: TIdBytes;
   messageType, magic, schema: LongInt;
   id, Ip: String;    //, mode
   i: integer;
   resultat: TStringList;
   DT: Double;
   tp2: integer;
   message: string;
   cpt: integer;

begin
  magic := $ADBCCBDA;
  schema:=2;
  messageType:=4;
  id:='WSJT-X';

  for i:=0 to Memo1.Lines.Count -1 do
   if pos(Call+' ',memo1.Lines[i])>0 then
     begin
   Resultat := TStringList.Create;
   Resultat.Delimiter := ' ';
   Resultat.QuoteChar := ' ';
   Resultat.DelimitedText := Memo1.Lines[i];

   pack(AData, magic);            {.............................................Magic number}
   pack(AData, schema);          {..............................................Schema}
   Pack(AData,messageType);        {............................................MessageType}
   pack(AData,id);                   {..........................................ID}


   cpt:=resultat.Count-1;
   tp2:=StrToInt(resultat[cpt]);
{
   if (pos('/',resultat[8])<> 0) then
     begin
          tp2:=StrToInt(resultat[11]);    // Dans le cas PREF/CALL
     end;

   if Length(resultat[8]) = 2 then       // Dans le cas de CQ DX CALL
     begin
         tp2:=StrToInt(resultat[13]);
     end else begin
         tp2:=StrToInt(resultat[12]);
     end;
}

   pack(AData,tp2);                  {..........................................Time}
   Pack(AData,strToint(resultat[3]));    {......................................SNR}
   DT:=StrToFloat(resultat[4]);
   pack(AData,DT);    {.........................................................DT}
   pack(AData,StrToIntDef(resultat[5],0));    {.................................DF}
   pack(AData,resultat[6]);    {................................................mode}
   message:=resultat[7]+' '+resultat[8];      //+' '+resultat[9]
   pack(AData, message);       {................................................message}

//         ShowMessage (message);
//         Ip := '127.0.0.1';
//   IdUDPServer1.SendBuffer(Ip, 2237, AData);
   IdUDPServer1.SendBuffer('127.0.0.1', PeerPort, AData);
     end;
  resultat.Free;
  end;

end.