Tutorial:Serial Communication - Revision history

Alb42: /* Preparing the serial device */ image of RS232 to TTL

2018-12-20T17:43:31Z

Preparing the serial device: image of RS232 to TTL

Alb42: typos

2018-12-20T17:31:35Z

typos

Alb42: Serial device test for RS232

2018-12-20T17:10:12Z

Serial device test for RS232

Alb42: /* Timeout */ link corrected

2018-12-09T13:59:07Z

Timeout: link corrected

Alb42: /* Timeout */ minor text correction

2018-12-09T13:58:15Z

Timeout: minor text correction

Alb42: Temperature control added

2018-12-09T13:51:27Z

Temperature control added

Alb42: Error checking added to Source

2018-12-09T11:46:17Z

Error checking added to Source

Alb42: error in syntax parser removed, more headlines

2018-12-08T18:56:35Z

error in syntax parser removed, more headlines

Alb42: Tutorial until first program finished

2018-12-08T18:46:55Z

Tutorial until first program finished

Alb42: To the first output from serial

2018-12-08T17:23:00Z

To the first output from serial

Show changes

@@ Line 4: / Line 4: @@
 == Preparing the serial device ==
+[[File:RS232TTL.jpg|200x200px|thumbnail|right]]
 As an example of a serial device we will use an Arduino UNO connected via serial to TTL adapter to the Amiga computer or USB providing a virtual serial port to MorphOS. Be aware you can not directly connect the TX/RX of the Arduino to the Amiga RS232 you need some more electronics, search Google for e.g. "RS232 Shield Arduino" or "RS232 to TTL adapter".

@@ Line 204: / Line 204: @@
      io^.io_SerFlags := (io^.io_SerFlags or SERF_XDISABLED) and (not SERF_PARTY_ON);
      io^.io_Baud := Baud;                      // Set baud rate
      io^.IOSer.io_Command := SDCMD_SETPARAMS;  // message command = Set Parameter
 </source>
@@ Line 384: / Line 387: @@
 As we have the serial communication is control, we make something more useful with the Arduino. For example we can attach some sensor to the Arduino and read out the value with the Amiga. Let us start with a temperature sensor, which is fairly easy because it does not need much programming and the value does not change too often.
-As an example I use a DS18B20 Temperature sensor which uses 1-Wire protocol. There are already ready to use libraries in the Arduino library collection. The library is called "MAX31850 DallasTemp" (wich also have a dependancy to a 1-wire library). Which the library installed you need to connect the sensor to your Arduino. I use the GPIO Pin 10 (because the others are occupied with other things), but you can use any Pin you like.
+As an example I use a DS18B20 Temperature sensor which uses 1-Wire protocol. There are already ready to use libraries in the Arduino library collection. The library is called "MAX31850 DallasTemp" (wich also have a dependancy to a 1-wire library). With the library installed you need to connect the sensor to your Arduino. I use the GPIO Pin 10 (because the others are occupied with other things), but you can use any Pin you like.
 [[File:TemperatureArduino.png]]
 Connect the lines as shown in the picture, as shown you only need a 4.7 k ohm resistor and some cables (and a bread board to build on it).
-To read the temperature from the sensor we write a little Arduino program and print out it to serial port.
+To read the temperature from the sensor we write a little Arduino program which prints out the temperature to serial port.
 <source lang="C">
 #include <OneWire.h>

@@ Line 5: / Line 5: @@
 == Preparing the serial device ==
-As an example of a serial device we will use an Arduino UNO connected via USB providing a virtual serial port to the Amiga computer. One could also connect the Arduino to the RS232 of the Amiga (if you do not have a USB port) but be aware you can not directly connect the TX/RX of the Arduino to the Amiga RS232 you need some more electronics, search Google for e.g. "RS232 Shield Arduino".
+As an example of a serial device we will use an Arduino UNO connected via serial to TTL adapter to the Amiga computer or USB providing a virtual serial port to MorphOS. Be aware you can not directly connect the TX/RX of the Arduino to the Amiga RS232 you need some more electronics, search Google for e.g. "RS232 Shield Arduino" or "RS232 to TTL adapter".
 First we need to program the Arduino. As a start we keep it simple and just use a very simple program which just print out a "Hello World" with a number.
@@ Line 180: / Line 180: @@
    Res: LongInt;
    DevOpen: Boolean = False;
-   DeviceName: AnsiString = 'usbmode.device'; // or serial device
+   DeviceName: AnsiString = 'serial.device'; // or usbmodem.device
    UnitNumber: Integer = 0;
@@ Line 211: / Line 211: @@
      io^.io_SerFlags := (io^.io_SerFlags or SERF_XDISABLED) and (not SERF_PARTY_ON);
      io^.io_Baud := Baud;                     // Set baud rate
      io^.IOSer.io_Command := SDCMD_SETPARAMS; // message type = Set Parameter
      SendIO(PIORequest(io));                  // send the message
@@ Line 239: / Line 242: @@
    exec, serial;
 const
-   DefDevice = 'usbmodem.device';
+   DefDevice: AnsiString = 'serial.device'; // or usbmodem.device
    DefUnit = 0;
    DefBaud = 9600;
@@ Line 278: / Line 281: @@
      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 325: / Line 331: @@
      io^.io_SerFlags := (io^.io_SerFlags or SERF_EOFMODE or SERF_XDISABLED) and (not SERF_PARTY_ON);
      io^.io_Baud := Baud;                      // Set baud rate
      io^.io_TermArray.TermArray0 := $0a030303; // termination character #10 filled with $03 = end of Text
      io^.io_TermArray.TermArray1 := $03030303;

@@ Line 370: / Line 370: @@
      writeln('Everything ok, Buffer: ', Buffer);
 </source>
-The complete Source as Download: Source1.pas[http://www.alb42.de/serial/Source1.pas]
+The complete Source as Download: Serial1.pas[http://www.alb42.de/serial/Serial1.pas]
 == Temperatur sensor ==

@@ Line 370: / Line 370: @@
      writeln('Everything ok, Buffer: ', Buffer);
 </source>
-Form now on only parts of the source are shown, because it becomes too long but you can download the full source until here: Source1.pas[http://www.alb42.de/serial/Source1.pas]
+The complete Source as Download: Source1.pas[http://www.alb42.de/serial/Source1.pas]
 == Temperatur sensor ==

← Older revision		Revision as of 13:51, 9 December 2018
Line 371:		Line 371:
	</source>		</source>
	Form now on only parts of the source are shown, because it becomes too long but you can download the full source until here: Source1.pas[http://www.alb42.de/serial/Source1.pas]		Form now on only parts of the source are shown, because it becomes too long but you can download the full source until here: Source1.pas[http://www.alb42.de/serial/Source1.pas]
		+
		+	== Temperatur sensor ==
		+
		+	As we have the serial communication is control, we make something more useful with the Arduino. For example we can attach some sensor to the Arduino and read out the value with the Amiga. Let us start with a temperature sensor, which is fairly easy because it does not need much programming and the value does not change too often.
		+	As an example I use a DS18B20 Temperature sensor which uses 1-Wire protocol. There are already ready to use libraries in the Arduino library collection. The library is called "MAX31850 DallasTemp" (wich also have a dependancy to a 1-wire library). Which the library installed you need to connect the sensor to your Arduino. I use the GPIO Pin 10 (because the others are occupied with other things), but you can use any Pin you like.
		+
		+	[[File:TemperatureArduino.png]]
		+
		+	Connect the lines as shown in the picture, as shown you only need a 4.7 k ohm resistor and some cables (and a bread board to build on it).
		+	To read the temperature from the sensor we write a little Arduino program and print out it to serial port.
		+	<source lang="C">
		+	#include <OneWire.h>
		+	#include <DallasTemperature.h>
		+
		+	const unsigned long BAUD_RATE = 9600;
		+	const unsigned char ONE_WIRE_BUS = 10;
		+
		+	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>
		+
		+	If we try that with our freepascal program we can nicely read the temperature without need to change the program.
		+
		+	== Graphical User Interface ==
		+
		+	== Multiple Sensors ==

@@ Line 38: / Line 38: @@
 == Serial device with FreePascal ==
 As first we need a message port for the communication with the serial device, for that you can find a <code>CreateMsgPort()</code> and <code>DeleteMsgPort()</code> in the exec unit for that purpose.
@@ Line 72: / Line 73: @@
 This source will now test the creation of the message port and show a message and leave the program if there is a problem.
 As next item we need a <code>IORequest</code>, because we want to do serial communication it must be the specialized IORequest named <code>PIOExtSer</code> from the serial unit. (if you do not have a serial unit, you have to update your FreePascal version). The IORequest basically is the message we send to the serial device if we want send or get data or change settings. Again, to create it there is a specialized function for in the exec unit <code>CreateExtIO()</code> and <code>DeleteExtIO()</code>. Let us extent the code with creating the <code>PIOExtSer</code>
 <source lang="pascal">
@@ Line 170: / Line 172: @@
 </source>
 Notice that all the variables are initialized to nil and then in the finally part they are checked against nil before get destroyed. For this special functions this is not really needed because they will also check the supplied pointers, but many other Amiga API calls does not check for empty pointer and just crash. Therefore it's better to get used to check the pointers before supply to a Amiga API call.
 But back to the serial communication. Everything is set up that we can open the actual serial device with <code>OpenDevice()</code> and <code>CloseDevice()</code> from exec.
@@ Line 192: / Line 196: @@
        CloseDevice(PIORequest(io));
 </source>
 Before we actually can use the device we have to configure the communications, like baud rate and flow control, for that we have the first time send a message using the IORequest we created before. Starting with configuring the message we like to send
 <source lang="pascal">
@@ Line 206: / Line 213: @@
      WaitIO(PIORequest(io));  // Wait for answer
 </source>
 To read the text from the serial port, which the Arduino sends, we also need to send a message to the serial device together with a Buffer.
 <source lang="pascal">
@@ Line 293: / Line 302: @@
 if you compile that and start on your Amiga with the Arduino connected you should see something like:
-<source>
+<source lang="shell">
 Work:Sources/Serial> test
 Everything ok, Buffer:
@@ Line 304: / Line 313: @@
 Work:Sources/Serial>
 </source>
-We have our first output. As you can see the WaitIO() waits until the 256 Chars arrived. Which could be a bit annoying if you want to have immediate reaction to a change in the output. For that purpose we can use the EOFMode of the the serial device driver. It stops the collection of data when a end of file is recognized in the stream. Every output we get from the Arduino should be ending with a "return" at the end (#13 #10) so we could trigger on the #10 =($0a) to end the collection. To achieve that we change the configuration to:
+We have our first output. As you can see the WaitIO() waits until the 256 Chars arrived. Which could be a bit annoying if you want to have immediate reaction to a change in the output.
 <source lang="pascal">
@@ Line 317: / Line 330: @@
 if you use that you end up with something like that:
-<source>
+<source lang="shell">
 Work:Sources/Serial> serialtest
 Everything ok, Buffer: Hello Amiga (Msg: 23)
 Work:Sources/Serial>
 </source>
-Thats much better, we only get a single line of output immediately when the output is done the result can be read. But what happens when the message is longer than the 256 bytes in the Buffer, then it will terminate after 256 bytes and I have to read a second time to get the rest of message which will terminate at the return. But what happens, when suddenly there are no messages anymore, then the WaitIO() call will never return and you also cannot break it, just restart your computer. To prevent that I want to introduce a timeout for the IORequest to the serial device. We need the aforementioned CheckIO() for it and an other call to stop a running IORequest which is called Abort(IO). To gather the time we use the function GetTickCount() from SysUtils, which gives us the milliseconds since the computer is started, which we can use to measure times precisely. To do that we replace the SendIO()/WaitIO() Lines for the CMD_READ with:
+Thats much better, we only get a single line of output immediately when the output is done the result can be read. But what happens when the message is longer than the 256 bytes in the Buffer, then it will terminate after 256 bytes and I have to read a second time to get the rest of message which will terminate at the return.
 <source lang="pascal">

← Older revision		Revision as of 18:46, 8 December 2018
Line 291:		Line 291:
	end.		end.
	</source>		</source>
		+
		+	if you compile that and start on your Amiga with the Arduino connected you should see something like:
		+	<source>
		+	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>
		+	We have our first output. As you can see the WaitIO() waits until the 256 Chars arrived. Which could be a bit annoying if you want to have immediate reaction to a change in the output. For that purpose we can use the EOFMode of the the serial device driver. It stops the collection of data when a end of file is recognized in the stream. Every output we get from the Arduino should be ending with a "return" at the end (#13 #10) so we could trigger on the #10 =($0a) to end the collection. To achieve that we change the configuration to:
		+
		+	<source lang="pascal">
		+	io^.io_SerFlags := (io^.io_SerFlags or SERF_EOFMODE or SERF_XDISABLED) and (not SERF_PARTY_ON); // Disable parity and XON/XOFF, enable EOF
		+	io^.io_Baud := Baud; // Set baud rate
		+	io^.io_TermArray.TermArray0 := $0a030303; // termination character #10 filled with $03 = end of Text
		+	io^.io_TermArray.TermArray1 := $03030303;
		+	io^.IOSer.io_Command := SDCMD_SETPARAMS; // message type = Set Parameter
		+	SendIO(PIORequest(io)); // send the message
		+	WaitIO(PIORequest(io)); // Wait for answer
		+	</source>
		+
		+	if you use that you end up with something like that:
		+	<source>
		+	Work:Sources/Serial> serialtest
		+	Everything ok, Buffer: Hello Amiga (Msg: 23)
		+	Work:Sources/Serial>
		+	</source>
		+	Thats much better, we only get a single line of output immediately when the output is done the result can be read. But what happens when the message is longer than the 256 bytes in the Buffer, then it will terminate after 256 bytes and I have to read a second time to get the rest of message which will terminate at the return. But what happens, when suddenly there are no messages anymore, then the WaitIO() call will never return and you also cannot break it, just restart your computer. To prevent that I want to introduce a timeout for the IORequest to the serial device. We need the aforementioned CheckIO() for it and an other call to stop a running IORequest which is called Abort(IO). To gather the time we use the function GetTickCount() from SysUtils, which gives us the milliseconds since the computer is started, which we can use to measure times precisely. To do that we replace the SendIO()/WaitIO() Lines for the CMD_READ with:
		+
		+	<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>
		+	Form now on only parts of the source are shown, because it becomes too long but you can download the full source until here: Source1.pas[http://www.alb42.de/serial/Source1.pas]