Delphi/Lazarus - IP Connection

Dies ist die Beschreibung der Delphi/Lazarus API Bindings für die IP Connection. Die IP Connection kümmert sich um die Kommunikation zwischen einem Brick Daemon oder einer WIFI/Ethernet Extension. Bevor Bricks und Bricklets über deren API angesprochen werden können muss eine IP Connection erzeugt und die TCP/IP Verbindung hergestellt werden.

Eine Installationanleitung für die Delphi/Lazarus API Bindings ist Teil deren allgemeine Beschreibung.

Beispiele

Der folgende Beispielcode ist Public Domain (CC0 1.0).

Enumerate

Download (ExampleEnumerate.pas)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
program ExampleEnumerate;

{$ifdef MSWINDOWS}{$apptype CONSOLE}{$endif}
{$ifdef FPC}{$mode OBJFPC}{$H+}{$endif}

uses
  SysUtils, IPConnection, Device;

type
  TExample = class
  private
    ipcon: TIPConnection;
  public
    procedure EnumerateCB(sender: TIPConnection;
                          const uid: string; const connectedUid: string; const position: char;
                          const hardwareVersion: TVersionNumber; const firmwareVersion: TVersionNumber;
                          const deviceIdentifier: word; const enumerationType: byte);
    procedure Execute;
  end;

const
  HOST = 'localhost';
  PORT = 4223;

var
  e: TExample;

{ Print incoming enumeration }
procedure TExample.EnumerateCB(sender: TIPConnection;
                               const uid: string; const connectedUid: string; const position: char;
                               const hardwareVersion: TVersionNumber; const firmwareVersion: TVersionNumber;
                               const deviceIdentifier: word; const enumerationType: byte);
begin
  WriteLn('UID:               ' + uid);
  WriteLn('Enumerate Type:    ' + IntToStr(enumerationType));

  if (enumerationType <> IPCON_ENUMERATION_TYPE_DISCONNECTED) then begin
    WriteLn('Connected UID:     ' + connectedUid);
    WriteLn('Position:          ' + position);
    WriteLn('Hardware Version:  ' + IntToStr(hardwareVersion[0]) + '.' +
                                    IntToStr(hardwareVersion[1]) + '.' +
                                    IntToStr(hardwareVersion[2]));
    WriteLn('Firmware Version:  ' + IntToStr(firmwareVersion[0]) + '.' +
                                    IntToStr(firmwareVersion[1]) + '.' +
                                    IntToStr(firmwareVersion[2]));
    WriteLn('Device Identifier: ' + IntToStr(deviceIdentifier));
  end;

  WriteLn('');
end;

procedure TExample.Execute;
begin
  { Create connection and connect to brickd }
  ipcon := TIPConnection.Create;
  ipcon.Connect(HOST, PORT);

  { Register enumerate callback to "EnumerateCB" }
  ipcon.OnEnumerate := {$ifdef FPC}@{$endif}EnumerateCB;

  { Trigger enumerate }
  ipcon.Enumerate;

  WriteLn('Press key to exit');
  ReadLn;
  ipcon.Destroy; { Calls ipcon.Disconnect internally }
end;

begin
  e := TExample.Create;
  e.Execute;
  e.Destroy;
end.

Authenticate

Download (ExampleAuthenticate.pas)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
program ExampleAuthenticate;

{$ifdef MSWINDOWS}{$apptype CONSOLE}{$endif}
{$ifdef FPC}{$mode OBJFPC}{$H+}{$endif}

uses
  SysUtils, IPConnection, Device;

type
  TExample = class
  private
    ipcon: TIPConnection;
  public
    procedure ConnectedCB(sender: TIPConnection; const connectReason: byte);
    procedure EnumerateCB(sender: TIPConnection;
                          const uid: string; const connectedUid: string; const position: char;
                          const hardwareVersion: TVersionNumber; const firmwareVersion: TVersionNumber;
                          const deviceIdentifier: word; const enumerationType: byte);
    procedure Execute;
  end;

const
  HOST = 'localhost';
  PORT = 4223;
  SECRET = 'My Authentication Secret!';

var
  e: TExample;

{ Authenticate each time the connection got (re-)established }
procedure TExample.ConnectedCB(sender: TIPConnection; const connectReason: byte);
begin
  case connectReason of
    IPCON_CONNECT_REASON_REQUEST:
    begin
      WriteLn('Connected by request');
    end;
    IPCON_CONNECT_REASON_AUTO_RECONNECT:
    begin
      WriteLn('Auto-Reconnect');
    end;
  end;
  { Authenticate first... }
  try
    sender.Authenticate(SECRET);
    WriteLn('Authentication succeeded');
  except
    WriteLn('Could not authenticate');
    exit;
  end;

  { ...reenable auto reconnect mechanism, as described below... }
  sender.SetAutoReconnect(true);

  { ...then trigger enumerate }
  sender.Enumerate;
end;

{ Print incoming enumeration }
procedure TExample.EnumerateCB(sender: TIPConnection;
                               const uid: string; const connectedUid: string; const position: char;
                               const hardwareVersion: TVersionNumber; const firmwareVersion: TVersionNumber;
                               const deviceIdentifier: word; const enumerationType: byte);
begin
  WriteLn('UID: ' + uid + ', Enumerate Type: ' + IntToStr(enumerationType));
end;

procedure TExample.Execute;
begin
  { Create IP Connection }
  ipcon := TIPConnection.Create;

  { Disable auto reconnect mechanism, in case we have the wrong secret.
    If the authentication is successful, reenable it. }
  ipcon.SetAutoReconnect(false);

  { Register connected callback to "ConnectedCB" }
  ipcon.OnConnected := {$ifdef FPC}@{$endif}ConnectedCB;

  { Register enumerate callback to "EnumerateCB" }
  ipcon.OnEnumerate := {$ifdef FPC}@{$endif}EnumerateCB;

  { Connect to brickd }
  ipcon.Connect(HOST, PORT);

  WriteLn('Press key to exit');
  ReadLn;
  ipcon.Destroy; { Calls ipcon.Disconnect internally }
end;

begin
  e := TExample.Create;
  e.Execute;
  e.Destroy;
end.

API

Grundfunktionen

constructor TIPConnection.Create

Erzeugt ein IP Connection Objekt das verwendet werden kann um die verfügbar Geräte zu enumerieren. Es wird auch für den Konstruktor von Bricks und Bricklets benötigt.

destructor TIPConnection.Destroy

Zerstört die IP Connection. Ruft intern Disconnect auf. Der Socket zum Brick Daemon wird geschlossen und alle Threads der IP Connection werden beendet.

procedure TIPConnection.Connect(const host: string; const port: word)

Erstellt eine TCP/IP Verbindung zum gegebenen host und port. Host und Port können auf einen Brick Daemon oder eine WIFI/Ethernet Extension verweisen.

Bricks/Bricklets können erst gesteuert werden, wenn die Verbindung erfolgreich aufgebaut wurde.

Blockiert bis die Verbindung aufgebaut wurde und wirft eine Exception, falls kein Brick Daemon oder WIFI/Ethernet Extension auf dem gegebenen Host und Port horcht.

procedure TIPConnection.Disconnect

Trennt die TCP/IP Verbindung zum Brick Daemon oder einer WIFI/Ethernet Extension.

procedure TIPConnection.Authenticate(const secret: string)

Führt einen Authentifizierungs-Handshake mit dem verbundenen Brick Daemon oder WIFI/Ethernet Extension durch. Ist der Handshake erfolgreich dann wechselt die Verbindung vom nicht-authentifizierten in den authentifizierten Zustand und die Kommunikation kann normal weitergeführt werden. Schlägt der Handshake fehl wird die Verbindung durch die Gegenseite geschlossen. Die Authentifizierung kann fehlschlagen wenn das Authentifizierungsgeheimnis nicht übereinstimmt oder Authentifizierung für den Brick Daemon oder die WIFI/Ethernet Extension nicht aktiviert ist.

Für mehr Informationen zur Authentifizierung siehe das dazugehörige Tutorial.

Neu in Version 2.1.0.

function TIPConnection.GetConnectionState: byte

Kann die folgenden Zustände zurückgeben:

  • IPCON_CONNECTION_STATE_DISCONNECTED (0): Keine Verbindung aufgebaut.
  • IPCON_CONNECTION_STATE_CONNECTED (1): Eine Verbindung zum Brick Daemon oder der WIFI/Ethernet Extension ist aufgebaut.
  • IPCON_CONNECTION_STATE_PENDING (2): IP Connection versucht im Moment eine Verbindung aufzubauen.
procedure TIPConnection.SetAutoReconnect(const autoReconnect: boolean)

Aktiviert oder deaktiviert Auto-Reconnect. Falls Auto-Reconnect aktiviert ist, versucht die IP Connection eine Verbindung zum vorher angegebenen Host und Port wieder herzustellen, falls die aktuell bestehende Verbindung verloren geht. Auto-Reconnect greift also erst nach einem erfolgreichen Aufruf von Connect.

Standardwert ist true.

function TIPConnection.GetAutoReconnect: boolean

Gibt true zurück wenn Auto-Reconnect aktiviert ist und false sonst.

procedure TIPConnection.SetTimeout(const timeout: longword)

Setzt den Timeout in Millisekunden für Getter und für Setter die das Response-Expected-Flag aktiviert haben.

Standardwert ist 2500.

function TIPConnection.GetTimeout: longword

Gibt den Timeout zurück, wie er von TIPConnection.SetTimeout gesetzt wurde.

procedure TIPConnection.Enumerate

Broadcast einer Enumerierungsanfrage. Alle Bricks und Bricklets werden mit einem Enumerate Callback antworten.

procedure TIPConnection.Wait

Hält den aktuellen Thread an bis TIPConnection.Unwait aufgerufen wird.

Dies ist nützlich falls ausschließlich auf Callbacks reagiert werden soll oder wenn auf einen spezifischen Callback gewartet werden soll oder wenn die IP Connection in einem Thread gestartet wird.

Wait und Unwait agieren auf die gleiche Weise wie Acquire und Release einer Semaphore.

procedure TIPConnection.Unwait

Startet einen Thread der vorher mit TIPConnection.Wait angehalten wurde wieder.

Wait und Unwait agieren auf die gleiche Weise wie Acquire und Release einer Semaphore.

Callbacks

Callbacks können registriert werden um über Ereignisse informiert zu werden. Die Registrierung erfolgt indem eine Prozedur einem Callback Property des TIPConnection Objektes zugewiesen wird:

procedure TExample.MyCallback(sender: TIPConnection; const param: word);
begin
  WriteLn(param);
end;

ipcon.OnExample := {$ifdef FPC}@{$endif}example.MyCallback;

Die verfügbaren Callback Properties und ihre Parametertypen werden im Folgenden beschrieben.

property TIPConnection.OnEnumerate
procedure(sender: TIPConnection; const uid: string; const connectedUid: string; const position: char; const hardwareVersion: TVersionNumber; const firmwareVersion: TVersionNumber; const deviceIdentifier: word; const enumerationType: byte) of object;

Der Callback empfängt sieben Parameter:

  • uid: Die UID des Bricks/Bricklets.
  • connectedUid: Die UID des Bricks mit dem das Brick/Bricklet verbunden ist. Für ein Bricklet ist dies die UID des Bricks mit dem es verbunden ist. Für einen Brick ist es die UID des untersten Master Bricks in einem Stapel. Der unterste Master Brick hat die Connected-UID "0". Mit diesen Informationen sollte es möglich sein die komplette Netzwerktopologie zu rekonstruieren.
  • position: Für Bricks: '0' - '8' (Position in Stapel). Für Bricklets: 'a' - 'h' (Position an Brick) oder 'i' (Position des Raspberry Pi (Zero) HAT) oder 'z' (Bricklet an Isolator Bricklet).
  • hardwareVersion: Major, Minor und Release Nummer der Hardwareversion.
  • firmwareVersion: Major, Minor und Release Nummer der Firmwareversion.
  • deviceIdentifier: Eine Zahl, welche den Brick/Bricklet repräsentiert.
  • enumerationType: Art der Enumerierung.

Mögliche Enumerierungsarten sind:

  • IPCON_ENUMERATION_TYPE_AVAILABLE (0): Gerät ist verfügbar (Enumerierung vom Benutzer ausgelöst: Disconnect). Diese Enumerierungsart kann mehrfach für das selbe Gerät auftreten.
  • IPCON_ENUMERATION_TYPE_CONNECTED (1): Gerät wurde neu verbunden (automatisch vom Brick gesendet nachdem die Kommunikation aufgebaut wurde). Dies kann bedeuten, dass das Gerät die vorher eingestellte Konfiguration verloren hat und neu konfiguriert werden muss.
  • IPCON_ENUMERATION_TYPE_DISCONNECTED (2): Gerät wurde getrennt (Nur bei USB-Verbindungen möglich). In diesem Fall haben nur uid und enumerationType einen gültigen Wert.

Es sollte möglich sein Plug-and-Play-Funktionalität mit diesem Callback zu implementieren (wie es im Brick Viewer geschieht).

Die Device Identifier Werte sind hier zu finden. Es gibt auch Konstanten für diese Werte, welche nach dem folgenden Muster benannt sind:

<device-type>_DEVICE_IDENTIFIER

Zum Beispiel: BRICK_MASTER_DEVICE_IDENTIFIER oder BRICKLET_AMBIENT_LIGHT_DEVICE_IDENTIFIER.

property TIPConnection.OnConnected
procedure(sender: TIPConnection; const connectReason: byte) of object;

Dieser Callback wird aufgerufen wenn die IP Connection eine Verbindung zu einem Brick Daemon oder einer WIFI/Ethernet Extension aufgebaut hat, mögliche Gründe sind:

  • IPCON_CONNECT_REASON_REQUEST (0): Verbindung aufgebaut nach Anfrage vom Benutzer.
  • IPCON_CONNECT_REASON_AUTO_RECONNECT (1): Verbindung aufgebaut durch Auto-Reconnect.
property TIPConnection.OnDisconnected
procedure(sender: TIPConnection; const disconnectReason: byte) of object;

Dieser Callback wird aufgerufen wenn die Verbindung der IP Connection zu einem Brick Daemon oder einer WIFI/Ethernet Extension getrennt wurde, mögliche Gründe sind:

  • IPCON_DISCONNECT_REASON_REQUEST (0): Trennung wurde vom Benutzer angefragt.
  • IPCON_DISCONNECT_REASON_ERROR (1): Trennung aufgrund eines unlösbaren Problems.
  • IPCON_DISCONNECT_REASON_SHUTDOWN (2): Trennung wurde vom Brick Daemon oder WIFI/Ethernet Extension eingeleitet.