Tutorial:Serielle Kommunikation - Revision history

Alb42: /* Vorbereiten des seriellen Gerätes */ image of the RS232 to TTL adapter

2018-12-20T17:42:52Z

Vorbereiten des seriellen Gerätes: image of the RS232 to TTL adapter

Alb42: Temperature control added german

2018-12-20T17:31:10Z

Temperature control added german

Alb42: stuff for serial device in german

2018-12-20T17:18:22Z

stuff for serial device in german

Alb42: german translation

2018-12-08T22:25:13Z

german translation

New page

<big>[[Tutorial:Start|Start]] Nächste</big><br />

Dieses Tutorial zeigt wie man Geräte mit serieller Kommunikation (RS232 oder USB) am Amiga benutzt. Als Besipiel wird hier ein Arduino UNO board benutzt. Alles was hier gezeigt wird wurde auf einem Amiga 1200 (68030/50 Mhz, OS 3.9) und einer MorphOS machine getestet, aber sollte auch genauso auf einem AmigaOS4 oder nativen AROS (i386/x86_64/ARM) so funktionieren.

== Vorbereiten des seriellen Gerätes ==

Als Modelgeräte wir benutzen ein Arduino UNO welches per USB am Amiga angeschlossen wird und dabei einen virtuellen seriellen Port zur verfügung stellt. Man könnte den Arduino auch and die RS232 Schnittstelle des Amigas anschliessen (falls man z.B. kein USB für Amiga hat) aber Achtung man kann nicht einfach die Leitungen des Arduino an den Amiga RS232 anschliessen, da braucht man ein wenig Elektronik um die Pegel zu regeln. Bei Interesse nach "RS232 Shield Arduino" googlen, da gibt es viel Auswahl.

Zuerst muss der Arduino programiert werden. Als sehr einfacher Anfang wir schreiben ein kurzes Program welches nur "Hello World" und eine laufende Nummer ausgibt. (damit man besser sieht das etwas passiert.)
<source lang="C">
const unsigned long BAUD_RATE = 9600;
int count;

void setup() {
Serial.begin(BAUD_RATE);
count = 1;
}

void loop() {
Serial.print("Hello Amiga (Msg: ");
Serial.print(count++);
Serial.println(")");
delay(500);
}
</source>
Dieses Programm sendet jede halbe Sekunde ein "Hello World (Msg: count)" and den serielle port. Dies kann man ganz gut mit dem "Serial Monitor" der Arduino IDE überprüfen

== Serielle Ausgabe am Amiga ==

Nun wollen wir diesen Text auch am Amiga sehen, wenn der Arduino am RS232 angeschlossen ist muss man nur ein Terminalprogramm starten wie z.B. NComm[http://aminet.net/package/comm/term/ncomm306]. Dort setzt man das Device zu serial.device, die Unitnummer zu 0 und Baudrate zu 9600 und schon sollte man den Output des obigen Programms sehen.

Wenn man den Arduino per USB anschließt sollte der installierte USB Stack (z.B. Poseidon) automatisch den richtigen Treiber (cdcacm.class) benutzen und damit den Virtuellen seriellen Port verfügbar machen. Das sollte ungefähr so aus sehen:

[[File:ArduinoUSB.png]]

Falls er nicht automatisch den richtigen Treiber benutzt (z.B. auf MorphOS) muss man diesen erzwingen für den 0. Endpunkt. (USB Prefs/Trident öffnen, Devices, Doppelklick auf"Arduino UNO", "CDC control interface (0)" auswählen, rechte Maustaste "forced binding" "cdcacm.class", Warnung abnicken, Usb rausziehen und wieder anschliessen).
Dieser virtuelle serielle port soltle jetzt verfügbar sein über das usbmodem.device. Der Rest ist gleich wie beim RS232 Anschluss nur das das device usbmodem.device heisst.

== Serielles Gerät mit FreePascal ==
=== Message port ===

Als erstes brauchen wir einen Messageport für die Kommunikation mit dem Triber, dafür gibt es <code>CreateMsgPort()</code> und <code>DeleteMsgPort()</code> in der Unit Exec.

<source lang="pascal">
program test;
uses
Exec;
var
Mp: PMsgPort;
begin
Mp := CreateMsgPort;
// do something
DeleteMsgPort(Mp);
end.
</source>
Falls es nicht genug Speicher gibt um den Messageport anzulegen der Aufruf wird fehlschlagen und ein nil (=0) zurückgeben. Natürlich sollten wir das Ergebnis testen und das Program verlassen falls es ein Problem gibt. Man kann entweder den Messageport mit nil vergleichen oder die spezielle Funktion <code>Assigned()</code> benutzen.
<source lang="pascal">
program test;
uses
Exec;
var
Mp: PMsgPort;
begin
Mp := CreateMsgPort;
if not Assigned(Mp) then
begin
writeln('Failed to create MsgPort');
Exit;
end;
// do something
DeleteMsgPort(Mp);
end.
</source>
Dieses Programm testet ob die Erzeugung des Messageports funktioniert hat und wenn nicht gibt es eine Nachricht aus und verlässt das Programm.

=== IO Request ===
Für den nächsten Schritt brauchen wir einen <code>IORequest</code>, praktisch ein Befehl an den Treiber, da wir serielle Kommunikation betreiben wollen benötigen wir eine spezialisierten IORequest namens <code>PIOExtSer</code> welchen wir in der serial unit finden. (Falls die serial unit nicht gefunden wird, muss das FreePascal aktualisiert werden)
Um so einen IORequest zu erstellen benötigen wir die beiden Funktionen <code>CreateExtIO()</code> und <code>DeleteExtIO()</code> aus der exec unit. Wir erweitern unser Programm und erzeugen so ein <code>PIOExtSer</code>.
<source lang="pascal">
program test;
uses
Exec;
var
Mp: PMsgPort;
Io: PIOExtSer;
begin
// create Messageport
Mp := CreateMsgPort;
if not Assigned(Mp) then
begin
writeln('Failed to create MsgPort');
Exit;
end;
// create IO Serial
Io := PIOExtSer(CreateExtIO(mp, SizeOf(TIOExtSer)));
if not Assigned(Io) then
begin
Writeln('Cannot alloc IOExtSer');
Exit;
end;
// do something
DeleteExtIO(PIORequest(Io));
DeleteMsgPort(Mp);
end.
</source>
An dieser Stelle möchte ich auf ein kleines Problem hinweisen. Falls der Messageport erfolgreich erzeugt wurde aber der IORequest schlägt fehl, das Programm wird einfach beendet und der Messageport wird nicht wieder zerstört. Man kann geschachtelte if Blöcke benutzen:
<source lang="pascal">
program test;
uses
Exec, Serial;
var
Mp: PMsgPort;
Io: PIOExtSer;
begin
// create Messageport
Mp := CreateMsgPort;
if Assigned(Mp) then
begin
// create IO Serial
Io := PIOExtSer(CreateExtIO(mp, SizeOf(TIOExtSer)));
if Assigned(Io) then
begin
// do something
DeleteExtIO(PIORequest(Io));
end
else
begin
Writeln('Cannot alloc IOExtSer');
end;
DeleteMsgPort(Mp);
end
else
begin
writeln('Failed to create MsgPort');
end;
end.
</source>
Man kann das so machen, aber wenn es sehr viele Ebenen hat wird es sehr schnell unübersichtlich. I bevorzuge den <code>try...finally..end;</code> Ansatz oder separate Initialisieren() und Zerstoere() Funktionen, welche bei besonders einfach sind bei Objektorientierter Programmierung da man einen Konstruktor und Destruktor der Klasse hat den man dafür benutzen kann.
Achtung: Wenn man Klassen oder try finally Blöcke benutzen möchte muss man den Compiler im Delphi oder ObjectFPC Modus benutzen. z.B. <code>{$mode objfpc}</code>.

<source lang="pascal">
program test;
{$mode objfpc}
uses
Exec, Serial;
var
Mp: PMsgPort = nil;
Io: PIOExtSer = nil;
begin
try
// create Messageport
Mp := CreateMsgPort;
if not Assigned(Mp) then
begin
writeln('Failed to create MsgPort');
Exit;
end;
// create IO Serial
Io := PIOExtSer(CreateExtIO(mp, SizeOf(TIOExtSer)));
if not Assigned(Io) then
begin
Writeln('Cannot alloc IOExtSer');
Exit;
end;

// do something

finally
if Assigned(Io) then
DeleteExtIO(PIORequest(Io));
if Assigned(Mp) then
DeleteMsgPort(Mp);
end;
end.
</source>
Man beachte das alle Variablen mit nil initialisiert werden und dann im finally Teil auf nil getestet werden und nur dann zerstört werden. Diese Funktionen benötigen das eigentlich nicht, da sie intern auch auf nil testen. Aber viele andere Amiga API Funktionen testen nicht auf leere Pointer und stürzen einfach ab. Daher sollte man sich angewöhnen alle Pointer zu testen bevor man sie an Amiga API Funktionen übergibt.

=== Öffnen des seriellen Devices ===

Aber zurück zu der seriellen Kommunikation. Es ist alles vorbereitet damit wir das seriellen Sevice öffnen können dafür bietet die exec Unit <code>OpenDevice()</code> und <code>CloseDevice()</code>.
<source lang="pascal">
var
Res: LongInt;
DevOpen: Boolean = False;
DeviceName: AnsiString = 'usbmode.device'; // or serial device
UnitNumber: Integer = 0;

// ...
Res := OpenDevice(PChar(DeviceName), UnitNumber, PIORequest(io), 0);
if Res <> 0 then
begin
Writeln('Unable to open device "' + DeviceName + ' ' + IntToStr(UnitNumber) + '" :' + IntToStr(Res));
Exit;
end;
DevOpen := True;

// ...
if DevOpen then
CloseDevice(PIORequest(io));
</source>

=== Serielle Device Parameter setzen ===

Bevor wir das Device wirklich benutzen können müssen wir noch einige Parameter setzen, wie Baudrate und Flow control. Dafür müssen wir das erste mal eine Nachricht and den Serielle Device Treiber schicken mit dem IORequest den vorhin erzeugt haben.
Zuerst wir konfigurieren den IORequest:
<source lang="pascal">
io^.io_SerFlags := (io^.io_SerFlags or SERF_XDISABLED) and (not SERF_PARTY_ON); // Parity und XON/XOFF ausschalten
io^.io_Baud := Baud; // Baud rate setzen
io^.IOSer.io_Command := SDCMD_SETPARAMS; // Message Kommando = Setze Parameter
</source>
Um die Nachricht zu versenden wir können <code>DoIO()</code> oder <code>SendIO()</code> neutzen. DoIO() blockiert bis die Nachricht abgearbeitet ist. SendIO() kehrt sofort zurück, läuft im Hintergrund weiter und wir müssen testen ob die Nachricht beendet ist. I prefer SendIO() because you have more control about what happens and you can break the request if it needs too long time. With <code>CheckIO()</code> you can test if the request is already finished or use WaitIO() for the end of operation. All together it looks like that:
<source lang="pascal">
io^.io_SerFlags := (io^.io_SerFlags or SERF_XDISABLED) and (not SERF_PARTY_ON); // Parity und XON/XOFF ausschalten
io^.io_Baud := Baud; // Baud rate setzen
io^.IOSer.io_Command := SDCMD_SETPARAMS; // Message Kommando = Setze Parameter
SendIO(PIORequest(io)); // sende die Nachricht
WaitIO(PIORequest(io)); // Warte auf die Antwort
</source>

=== Text lesen ===
Um Text vom seriellen Port zu lesen, welches der Arduino sendet, wir müssen wieder eine Nachricht senden mit dem Kommando CMD_READ und einem Puffer wo der Text abgelegt werden soll.
<source lang="pascal">
var
Buffer: array[0..256] of char;
// ...
FillChar(Buffer[0], 257, #0); // Buffer löschen (immer ein #0 am Ende)
io^.IOSer.io_Length := 256; // einer weniger als die wirkliche Groesse dahaer immer ein #0 am ende
io^.IOSer.io_Data := @Buffer[0]; // Zeiger auf den ersten wert als Start
io^.IOSer.io_Command := CMD_READ; // Kommando = Lesen

SendIO(PIORequest(io));
WaitIO(PIORequest(io));
// ...
</source>
Damit haben wir alles was wir brauchen um den Text vom Arduino zu lesen. Alles zusammen:
<source lang="pascal">
program test;
{$mode objfpc}{$H+}
uses
SysUtils,
exec, serial;
const
DefDevice = 'usbmodem.device';
DefUnit = 0;
DefBaud = 9600;
var
Mp: PMsgPort = nil;
Io: PIOExtSer = nil;
DevOpen: Boolean = False;
Res: LongInt;
DeviceName: string = DefDevice;
UnitNumber: Integer = DefUnit;
Baud: Integer = DefBaud;
Buffer: array[0..256] of char;
begin
try
// create Messageport
Mp := CreateMsgPort;
if not Assigned(Mp) then
begin
writeln('Failed to create MsgPort');
Exit;
end;
// create IO Serial
Io := PIOExtSer(CreateExtIO(mp, SizeOf(TIOExtSer)));
if not Assigned(Io) then
begin
Writeln('Cannot alloc IOExtSer');
Exit;
end;
// Open the device
Res := OpenDevice(PChar(DeviceName), UnitNumber, PIORequest(io), 0);
if Res <> 0 then
begin
Writeln('Unable to open device "' + DeviceName + ' ' + IntToStr(UnitNumber) + '" :' + IntToStr(Res));
Exit;
end;
DevOpen := True;
// configure serial interface
io^.io_SerFlags := (io^.io_SerFlags or SERF_XDISABLED) and (not SERF_PARTY_ON);
io^.io_Baud := Baud;
io^.IOSer.io_Command := SDCMD_SETPARAMS;
SendIO(PIORequest(io));
WaitIO(PIORequest(io));

// read 256 chars from the serial port
FillChar(Buffer[0], 257, #0);
io^.IOSer.io_Length := 256;
io^.IOSer.io_Data := @Buffer[0];
io^.IOSer.io_Command := CMD_READ;
SendIO(PIORequest(io));
WaitIO(PIORequest(io));

// everything ok - print out the Buffer
writeln('Everything ok, Buffer: ', Buffer);
finally
if DevOpen then
CloseDevice(PIORequest(io));
if Assigned(Io) then
DeleteExtIO(PIORequest(Io));
if Assigned(Mp) then
DeleteMsgPort(Mp);
end;
end.
</source>

Wenn man das kompiliert und auf dem Amiga starten mit dem Arduino angeschlossen, man sollte folgendes erhalten:
<source lang="shell">
Work:Sources/Serial> test
Everything ok, Buffer:
Amiga (Msg: 10)
Hello Amiga (Msg: 11)
Hello Amiga (Msg: 12)
Hello Amiga (Msg: 13)
Hello Amiga (Msg: 14)
Hello Amiga (Msg: 15
Work:Sources/Serial>
</source>
Wir haben unseren ersten Text vom Arduino. Wie man sehen kann wartet der WaitIO() aufruf bis 256 Zeichen eingetroffen sind. Was aber etwas störend sein kann, wenn man eine direkte Reaktion auf einen Text haben möchte und nicht soviel Text gesendet wird.

=== EOF Modus ===

Dafür können wir den EOF Moudus des seriellen Devicetreibers benutzen. Dieser stoppt die Textaufnahme wenn ein "Ende des Files" erhalten wird im Zeichenstrom. Jede Zeile vom Arduino sollte mit einem Return (#13 #10) enden so wir könnten das #10 =($0a) Zeichen benutzen um die Textaufnahme vorzeitig abzubrechen. Um das zu erreichen ändern wir die Parameter die wir am Anfang mir SETPARAM gesetzt haben zu:

<source lang="pascal">
io^.io_SerFlags := (io^.io_SerFlags or SERF_EOFMODE or SERF_XDISABLED) and (not SERF_PARTY_ON); // Parity und XON/XOFF ausschalten, EOF anschalten
io^.io_Baud := Baud; // Baudrate setzen
io^.io_TermArray.TermArray0 := $0a030303; // Ende des Files Zeichen #10 Rest gefüllt mit $03 = End of Text
io^.io_TermArray.TermArray1 := $03030303;
io^.IOSer.io_Command := SDCMD_SETPARAMS; // Nachtichten Kommando type = Setze Parameter
SendIO(PIORequest(io)); // Sende Nachricht
WaitIO(PIORequest(io)); // Warte auf Antwort
</source>

Wenn man das so ändert erhält man schliesslich:
<source lang="shell">
Work:Sources/Serial> serialtest
Everything ok, Buffer: Hello Amiga (Msg: 23)
Work:Sources/Serial>
</source>

Das ist schon viel besser, wir erhalten nur eine einzige Zeile des Texts und diese daher auch sofort. Falls der Text länger als 256 Zeichen ist bricht er natürlich immer noch dort ab und man muss nochmal nach dem Rest fragen (oder einen grösseren Buffer bereitstellen).

Aber was passiert, wenn kein Text mehr gesendet wird? Der WaitIO() Aufruf blockiert für immer und man kann ihn auch nicht unterbrechen (ausser mit einem Computerneustart). Um das zu umgehen programmieren wir einen Timeout dazu.

=== Timeout ===
Wir brauchen die vorher erwähnte Funktion <code>CheckIO()</code> um zu prüfen ob das Kommando abgearbeitet wurd und eine Funktion um einen IORequest abzubrechen wenn ein Timeout eintritt, diese Funktion heisst <code>Abort(IO)</code>. Um die Zeit zu überprüfen kann man sehr einfach die Funktion <code>GetTickCount()</code> aus SysUtils benutzen, diese gibt uns die Zeit in Millisekunden, welche wir benutzen können um sehr genau Zeitabstände zu messen. Für den Timeout ersetzen wir <code>SendIO()/WaitIO()</code> für das Kommando CMD_READ mit:

<source lang="pascal">
var
t: LongWord;
// ...
t1 := GetTickCount;
repeat
if CheckIO(PIORequest(io)) <> nil then
Break;
Sleep(25);
until GetTickCount - t1 > 10000;
if CheckIO(PIORequest(io)) <> nil then
begin
WaitIO(PIORequest(io));
writeln('Everything ok, Buffer: ', Buffer);
end
else
begin
AbortIO(PIORequest(io));
writeln('Timeout, not enough data: ', Buffer);
end;
</source>
Von hier an gibt es nur noch Teile des Sopurce, da es sonst zu lang wird, allerdings kannst du den kompletten Source hier runterladen: Source1.pas[http://www.alb42.de/serial/Source1.pas]

← Older revision		Revision as of 17:31, 20 December 2018
Line 384:		Line 384:
	</source>		</source>
	Von hier an gibt es nur noch Teile des Sopurce, da es sonst zu lang wird, allerdings kannst du den kompletten Source hier runterladen: Source1.pas[http://www.alb42.de/serial/Source1.pas]		Von hier an gibt es nur noch Teile des Sopurce, da es sonst zu lang wird, allerdings kannst du den kompletten Source hier runterladen: Source1.pas[http://www.alb42.de/serial/Source1.pas]
		+
		+	== Temperatursensor ==
		+
		+	Da die serielle Übertragung jetzt funktioniert, können wir etwas mehr sinnvolles mit dem Arduino machen. Zum Beispiel Sendoren and den Arduino anschliessen, die Werte auslesen und an den Amiga schicken.
		+	Fangen wir mit einem Temperatursensor an, dies is relativ einfach weil es nicht viel Programmierung benötigt und die Werte siuch nicht sehr schnell ändern. Ich habe dafür einen DS18B20 Temperatursensor welches mittels 1-Wite Protokoll kommuniziert. Es gibt dafür schon fertig Libraries in der Arduino Library Kollektion. Die Library, die man hier benötigt heisst "MAX31850 DallasTemp" (diese braucht auch eine weitere Library zum 1-Wire zugriff, diese wird aber normalerweise automatisch mitinstalliert). Nachdem die Library installiert ist muss man den Sensor noch an den Arduino anschliessen. Ich benutze den GPIO Pin 10 dafür (weil bei meinem Arduino andere Pins schon für andere Sachen belegt sind) man kann auch einen anderen Pin benutzen.
		+
		+	[[File:TemperatureArduino.png]]
		+
		+
		+	Schliesse die Kabel wie im Bild gezeigt an, wie im Bild zu sehen benötigt man nur den Temperatursensor, einen 4.7 kOhm Widerstand und einige Kabel (und vielleicht ein Breadboard um alles draufzustecken).
		+	Um die Temperatur vom Sensor auszulesen schreiben wir ein neues kleines Arduinoprogram welches die Temperatur an den seriellen Port sendet.
		+	<source lang="C">
		+	#include <OneWire.h>
		+	#include <DallasTemperature.h>
		+
		+	const unsigned long BAUD_RATE = 9600;
		+	const unsigned char ONE_WIRE_BUS = 10; // Pin des Temperatur sensors
		+
		+	OneWire oneWire(ONE_WIRE_BUS);
		+	DallasTemperature sensoren(&oneWire);
		+
		+	void setup() {
		+	sensoren.begin();
		+	Serial.begin(BAUD_RATE);
		+	}
		+
		+	void loop() {
		+	sensoren.requestTemperatures();
		+	if (sensoren.getDeviceCount() > 0)
		+	{
		+	float temperatur = sensoren.getTempCByIndex(0);
		+	Serial.println(temperatur);
		+	}
		+	else
		+	{
		+	Serial.println("N");
		+	}
		+	delay(200);
		+	}
		+	</source>
		+
		+	Wenn wir jetzt unser FreePascal-Programm starten zeigt es die Temperatur welcher der Sensor misst, ohne das wir das Programm ändern müssten.
		+
		+	== Graphische Benutzeroberfläche ==
		+
		+	== Mehrere Sensoren ==

@@ Line 4: / Line 4: @@
 == Vorbereiten des seriellen Gerätes ==
 Als Modelgerät benutzen wir ein Arduino UNO welches per RS232 am Amiga angeschlossen wird bzw. via USB am MorphOS Computer und dabei einen virtuellen seriellen Port zur Verfügung stellt. Achtung man kann nicht einfach die Leitungen des Arduino an den Amiga RS232 anschliessen, da braucht man ein wenig Elektronik um die Pegel zu regeln. Bei Interesse nach "RS232 Shield Arduino" oder "RS232 zu TTL-Konverter" googlen, da gibt es viel Auswahl.
 Zuerst muss der Arduino programiert werden. Als sehr einfacher Anfang wir schreiben ein kurzes Program welches nur "Hello World" und eine laufende Nummer ausgibt. (damit man besser sieht das etwas passiert.)
 <source lang="C">
 const unsigned long BAUD_RATE = 9600;

@@ Line 5: / Line 5: @@
 == Vorbereiten des seriellen Gerätes ==
-Als Modelgeräte wir benutzen ein Arduino UNO welches per USB am Amiga angeschlossen wird und dabei einen virtuellen seriellen Port zur verfügung stellt. Man könnte den Arduino auch and die RS232 Schnittstelle des Amigas anschliessen (falls man z.B. kein USB für Amiga hat) aber Achtung man kann nicht einfach die Leitungen des Arduino an den Amiga RS232 anschliessen, da braucht man ein wenig Elektronik um die Pegel zu regeln. Bei Interesse nach "RS232 Shield Arduino" googlen, da gibt es viel Auswahl.
+Als Modelgerät benutzen wir ein Arduino UNO welches per RS232 am Amiga angeschlossen wird bzw. via USB am MorphOS Computer und dabei einen virtuellen seriellen Port zur Verfügung stellt. Achtung man kann nicht einfach die Leitungen des Arduino an den Amiga RS232 anschliessen, da braucht man ein wenig Elektronik um die Pegel zu regeln. Bei Interesse nach "RS232 Shield Arduino" oder "RS232 zu TTL-Konverter" googlen, da gibt es viel Auswahl.
 Zuerst muss der Arduino programiert werden. Als sehr einfacher Anfang wir schreiben ein kurzes Program welches nur "Hello World" und eine laufende Nummer ausgibt. (damit man besser sieht das etwas passiert.)
@@ Line 183: / Line 183: @@
    Res: LongInt;
    DevOpen: Boolean = False;
-   DeviceName: AnsiString = 'usbmode.device'; // or serial device
+   DeviceName: AnsiString = 'serial.device'; // or usbmodem.device
    UnitNumber: Integer = 0;
@@ Line 205: / Line 205: @@
 Zuerst wir konfigurieren den IORequest:
 <source lang="pascal">
-     io^.io_SerFlags := (io^.io_SerFlags or SERF_XDISABLED) and (not SERF_PARTY_ON); // Parity und XON/XOFF ausschalten
+    // Parity und XON/XOFF ausschalten
-     io^.io_Baud := Baud;                                                            // Baud rate setzen
+     io^.io_SerFlags := (io^.io_SerFlags or SERF_XDISABLED) and (not SERF_PARTY_ON);
-     io^.IOSer.io_Command := SDCMD_SETPARAMS;                                        // Message Kommando = Setze Parameter
+     io^.io_Baud := Baud;                     // Baud rate setzen
 </source>
 Um die Nachricht zu versenden wir können <code>DoIO()</code> oder <code>SendIO()</code> neutzen. DoIO() blockiert bis die Nachricht abgearbeitet ist. SendIO() kehrt sofort zurück, läuft im Hintergrund weiter und wir müssen testen ob die Nachricht beendet ist. I prefer SendIO() because you have more control about what happens and you can break the request if it needs too long time. With <code>CheckIO()</code> you can test if the request is already finished or use WaitIO() for the end of operation. All together it looks like that:
 <source lang="pascal">
-     io^.io_SerFlags := (io^.io_SerFlags or SERF_XDISABLED) and (not SERF_PARTY_ON); // Parity und XON/XOFF ausschalten
+    // Parity und XON/XOFF ausschalten
-     io^.io_Baud := Baud;                                                            // Baud rate setzen
+     io^.io_SerFlags := (io^.io_SerFlags or SERF_XDISABLED) and (not SERF_PARTY_ON);
-     io^.IOSer.io_Command := SDCMD_SETPARAMS;                                        // Message Kommando = Setze Parameter
+     io^.io_Baud := Baud;                     // Baud rate setzen
      SendIO(PIORequest(io));  // sende die Nachricht
      WaitIO(PIORequest(io));  // Warte auf die Antwort
@@ Line 241: / Line 249: @@
    exec, serial;
 const
-   DefDevice = 'usbmodem.device';
+   DefDevice = 'serial.device'; // or usbmodem.device
    DefUnit = 0;
    DefBaud = 9600;
@@ Line 280: / Line 288: @@
      io^.io_SerFlags := (io^.io_SerFlags or SERF_XDISABLED) and (not SERF_PARTY_ON);
      io^.io_Baud := Baud;
      io^.IOSer.io_Command := SDCMD_SETPARAMS;
      SendIO(PIORequest(io));
@@ Line 324: / Line 335: @@
 <source lang="pascal">
-     io^.io_SerFlags := (io^.io_SerFlags or SERF_EOFMODE or SERF_XDISABLED) and (not SERF_PARTY_ON); // Parity und XON/XOFF ausschalten, EOF anschalten
+    // Parity und XON/XOFF ausschalten, EOF anschalten
-     io^.io_Baud := Baud;                                                                            // Baudrate setzen
+     io^.io_SerFlags := (io^.io_SerFlags or SERF_EOFMODE or SERF_XDISABLED) and (not SERF_PARTY_ON);
-     io^.io_TermArray.TermArray0 := $0a030303;                                                       // Ende des Files Zeichen #10 Rest gefüllt mit $03 = End of Text
+     io^.io_Baud := Baud;                      // Baudrate setzen
      io^.io_TermArray.TermArray1 := $03030303;
-     io^.IOSer.io_Command := SDCMD_SETPARAMS;                                                        // Nachtichten Kommando type = Setze Parameter
+     io^.IOSer.io_Command := SDCMD_SETPARAMS;  // Nachtichten Kommando type = Setze Parameter
      SendIO(PIORequest(io));  // Sende Nachricht
      WaitIO(PIORequest(io));  // Warte auf Antwort