Lazarus on Raspberry Pi/de: what changed

Revision 3 to 4. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		![Lazarus unter Raspbian Wheezy](/wiki-images/e/ef/Lazarus_on_Raspberry_Pi_Raspian_Wheezy_version_2012-10-28.png) (Raspberry Pi only)
2	2
3	3		Der Raspberry Pi ist ein kreditkartengroßer Einplatinenrechner. Er wurde in Großbritannien von der Raspberry Pi Foundation ursprünglich entwickelt, um den grundlegenden Informatikunterricht in Schulen zu fördern. Raspberry Pis können aber nicht nur für die Ausbildung, sondern für die unterschiedlichsten Zwecke, z. B. als Medienserver, Robotersteuerungen und für die Regelungstechnik eingesetzt werden.
4	4
5	5		Die Raspberry Pi Foundation empfiehlt als Standard-Betriebssystem Raspbian Wheezy. Alternative Betriebssysteme für den RPI sind z. B. RISC OS und verschiedene Linux-Distributionen, einschließlich Android.
6	6
7	7		Lazarus läuft nativ unter dem Betriebssystem Raspbian.
8	8
9	9		## Lazarus installieren und/oder compilieren
10	10
11	11		### Einfache Installation unter Raspbian
12	12
13	13		Hinweis:
14	14
15	15		In der Wheezy Version (2014-09-09) muss folgende Paketquelle in etc/apt/sources.list hinzugefügt werden.
16	16
17	17		deb <http://plugwash.raspbian.org/wsf> wheezy-wsf main
18	18
19	19		Diese Information bezieht sich auf den Artikel:
20	20
21	21		[Raspberrypi.org FPC-Fix](http://www.raspberrypi.org/forums/viewtopic.php?f=34&t=88145)
22	22
23	23		#### Raspberry Pi 1
24	24
25	25		Lazarus und Free Pascal können unter Raspbian OS schnell und einfach installiert werden. Es ist dafür nur nötig, ein Terminal-Fenster zu öffnen und die folgenden Kommandos einzugeben:
26	26
27	27		``` pascal
28	28		sudo apt-get update
29	29		sudo apt-get upgrade
30	30		sudo apt-get install fpc
31	31		sudo apt-get install lazarus
32	32		```
33	33
34	34		Damit wird, natürlich unter der Voraussetzung einer funktionierenden Netzwerkverbindung, eine vorkompilierte Lazarus-Version auf dem Raspberry Pi installiert. Die Installation kann, je nach Version und Netzwerkgeschwindigkeit, etwa 30 Minuten erfordern, sie läuft aber überwiegend automatisch ab. Nach der Installation kann Lazarus direkt über das "Programming"-Untermenü des LXDE Startmenüs gestartet werden.
35	35
36		-	Install Lazarus Rasbian Part1 de.png\\|Installation 1 Install Lazarus Rasbian Part2 de.png\\|Installation 2 Install Lazarus Rasbian Part3 de.png\\|Installation 3 Install Lazarus Rasbian Part4 de.png\\|Installation 4
	36	+	![](/wiki-images/1/19/Install_Lazarus_Rasbian_Part1_de.png)
37	37
	38	+	Installation 1
	39	+
	40	+	![](/wiki-images/4/4c/Install_Lazarus_Rasbian_Part2_de.png)
	41	+
	42	+	Installation 2
	43	+
	44	+	![](/wiki-images/6/6d/Install_Lazarus_Rasbian_Part3_de.png)
	45	+
	46	+	Installation 3
	47	+
	48	+	![](/wiki-images/f/ff/Install_Lazarus_Rasbian_Part4_de.png)
	49	+
	50	+	Installation 4
	51	+
38	52		#### Raspberry Pi 2
39	53
40	54		Seit Juni 2015 funktioniert die oben angeführte "out of the box" Installationsmethode auch auf dem Raspberry Pi 2 Model B. Allerdings ist nach gegenwärtigem Stand die installierte Version recht alt. Wer die neuesten Versionen des Free Pascal Compilers und der Lazarus IDE installieren möchte, findet eine Anleitung in [diesem Artikel](http://www.tweaking4all.com/hardware/raspberry-pi/install-lazarus-pascal-on-raspberry-pi-2/).
41	55
42		-	~~<File:Lazarus> 0 9 30 4 on RPi 2.png\\|Lazarus "out of the box" auf dem Raspberry Pi 2~~
	56	+	![](/wiki-images/c/cc/Lazarus_0_9_30_4_on_RPi_2.png)
43	57
	58	+	Lazarus "out of the box" auf dem Raspberry Pi 2
	59	+
44	60		### Übersetzen aus den Quelltexten
45	61
46	62		Alternativ kann Lazarus auch aus den Subversion-Quelltexten übersetzt werden. Einzelheiten sind unter \[<http://www.michellcomputing.co.uk/blog/?p=72>: Michell Computing: Lazarus on the Raspberry Pi\] beschrieben.
47	63
48		-	<File:Start> Menu with Lazarus de.png\\|Starten von Lazarus unter Raspbian Wheezy <File:Lazarus> on Raspberry Pi.jpg\\|Lazarus auf dem Raspberry Pi <File:rpi> gpio pins.png\\|Nummerierung der GPIO-Anschlüsse
	64	+	![](/wiki-images/a/a1/Start_Menu_with_Lazarus_de.png)
	65	+
	66	+	Starten von Lazarus unter Raspbian Wheezy
	67	+
	68	+	![](/wiki-images/8/87/Lazarus_on_Raspberry_Pi.jpg)
	69	+
	70	+	Lazarus auf dem Raspberry Pi
	71	+
	72	+	![](/wiki-images/c/c7/Rpi_gpio_pins.png)
	73	+
	74	+	Nummerierung der GPIO-Anschlüsse
49	75
50	76		## Zugriff auf externe Hardware
51	77
52	78		![](/wiki-images/f/f2/Rpi_pinout_all_50.png)
53	79
54	80		Eines der Ziele bei der Entwicklung des Raspberry Pi bestand darin, einfachen und schnellen Zugriff auf esterne Geräte wie Sensoren und Aktuatoren zu ermöglichen. Es gibt vier Möglichkeiten, die E/A-Optionen unter Lazarus und Free Pascal zu nutzen:
55	81
56	82		1. [[Lazarus on Raspberry Pi/de\|Direktzugriff]] über die [[doc:rtl/baseunix/index.html\|BaseUnix]]-Unit
57	83		2. Zugriff über [[Lazarus on Raspberry Pi/de\|gekapselte Shell-Aufrufe]]
58	84		3. Zugriff über die [[Lazarus on Raspberry Pi/de\|wiringPi library]].
59	85		4. Zugriff über die Unit [[Lazarus on Raspberry Pi/de\|rpi_hal]].
60	86
61	87		### 1. Nativer Hardware-Zugriff
62	88
63	89		![Einfaches Testprogramm für den Zugriff auf den GPIO-Port des Raspberry Pi\\|thumb\\|300px\\|right](/wiki-images/d/d2/Testprogram_for_GPIO_on_RPI_annotated.png) ![Testschaltung für den GPIO-Zugriff mit dem beschriebenen Programm\\|thumb\\|300px\\|right](/wiki-images/7/7c/Rpi_testcircuit_1d.png) ![Einfache Demo-Umsetzung der Schaltung auf einer Steckplatine\\|thumb\\|300px\\|right](/wiki-images/7/7e/Rpi_testcircuit_1p_annotaded.png) Diese Methode bietet Zugriff auf externe Hardware, ohne zusätzliche Bibliotheken oder Packages zu benötigen. Die einzige Voraussetzung ist die BaseUnix-Bibliothek, die zur RTL gehört und mit Free Pascal automatisch mitinstalliert wird.
64	90
65	91		#### Schalten eines Gerätes über den GPIO-Port
66	92
67	93		Im folgenden Beispiel ist ein einfaches Programm aufgelistet, das den GPIO-Pin 17 als Ausgang zum Schalten einer LED, eines Transistors oder eines Relais benutzt. Es enthält eine [[doc:lcl/stdctrls/ttogglebox.html\|ToggleBox]] mit dem Namen GPIO17ToggleBox und zur Aufzeichnung von Return-Codes ein [[doc:lcl/stdctrls/tmemo.html\|TMemo]]-Feld mit der Bezeichnung LogMemo.
68	94
69	95		Hardwareseitig wurde die Anode einer LED mit Pin 11 des Anschlusses auf dem Pi (entsprechend GPIO-Pin 17 des BCM2835 SOC) und ihre Kathode über einen 68-Ohm-Schutzwiderstand mit Pin 6 des Pi-Anschlusses (GND = Masse) verbunden (s. auch die Beschreibung bei Upton and Halfacree). Damit kann die LED durch die ToggleBox des Programms ein- und ausgeschaltet werden.
70	96
71	97		Das Programm muss mit Root-Rechten ausgeführt werden, d. h. entweder von einem Root-Account aus (aus Sicherheitsgründen weniger zu empfehlen) oder über das Shell-Kommando su.
72	98
73	99		Steuerungs-Unit:
74	100
75	101		``` pascal
76	102		unit Unit1;
77	103
78	104		{Demo application for GPIO on Raspberry Pi}
79	105		{Inspired by the Python input/output demo application by Gareth Halfacree}
80	106		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
81	107
82	108		{$mode objfpc}{$H+}
83	109
84	110		interface
85	111
86	112		uses
87	113		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
88	114		Unix, BaseUnix;
89	115
90	116		type
91	117
92	118		{ TForm1 }
93	119
94	120		TForm1 = class(TForm)
95	121		LogMemo: TMemo;
96	122		GPIO17ToggleBox: TToggleBox;
97	123		procedure FormActivate(Sender: TObject);
98	124		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
99	125		procedure GPIO17ToggleBoxChange(Sender: TObject);
100	126		private
101	127		{ private declarations }
102	128		public
103	129		{ public declarations }
104	130		end;
105	131
106	132		const
107	133		PIN_17: PChar = '17';
108	134		PIN_ON: PChar = '1';
109	135		PIN_OFF: PChar = '0';
110	136		OUT_DIRECTION: PChar = 'out';
111	137
112	138		var
113	139		Form1: TForm1;
114	140		gReturnCode: longint; {stores the result of the IO operation}
115	141
116	142		implementation
117	143
118	144		{$R *.lfm}
119	145
120	146		{ TForm1 }
121	147
122	148		procedure TForm1.FormActivate(Sender: TObject);
123	149		var
124	150		fileDesc: integer;
125	151		begin
126	152		{ Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
127	153		try
128	154		fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
129	155		gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
130	156		LogMemo.Lines.Add(IntToStr(gReturnCode));
131	157		finally
132	158		gReturnCode := fpclose(fileDesc);
133	159		LogMemo.Lines.Add(IntToStr(gReturnCode));
134	160		end;
135	161		{ Set SoC pin 17 as output: }
136	162		try
137	163		fileDesc := fpopen('/sys/class/gpio/gpio17/direction', O_WrOnly);
138	164		gReturnCode := fpwrite(fileDesc, OUT_DIRECTION[0], 3);
139	165		LogMemo.Lines.Add(IntToStr(gReturnCode));
140	166		finally
141	167		gReturnCode := fpclose(fileDesc);
142	168		LogMemo.Lines.Add(IntToStr(gReturnCode));
143	169		end;
144	170		end;
145	171
146	172		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
147	173		var
148	174		fileDesc: integer;
149	175		begin
150	176		{ Free SoC pin 17: }
151	177		try
152	178		fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
153	179		gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
154	180		LogMemo.Lines.Add(IntToStr(gReturnCode));
155	181		finally
156	182		gReturnCode := fpclose(fileDesc);
157	183		LogMemo.Lines.Add(IntToStr(gReturnCode));
158	184		end;
159	185		end;
160	186
161	187		procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
162	188		var
163	189		fileDesc: integer;
164	190		begin
165	191		if GPIO17ToggleBox.Checked then
166	192		begin
167	193		{ Swith SoC pin 17 on: }
168	194		try
169	195		fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
170	196		gReturnCode := fpwrite(fileDesc, PIN_ON[0], 1);
171	197		LogMemo.Lines.Add(IntToStr(gReturnCode));
172	198		finally
173	199		gReturnCode := fpclose(fileDesc);
174	200		LogMemo.Lines.Add(IntToStr(gReturnCode));
175	201		end;
176	202		end
177	203		else
178	204		begin
179	205		{ Switch SoC pin 17 off: }
180	206		try
181	207		fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
182	208		gReturnCode := fpwrite(fileDesc, PIN_OFF[0], 1);
183	209		LogMemo.Lines.Add(IntToStr(gReturnCode));
184	210		finally
185	211		gReturnCode := fpclose(fileDesc);
186	212		LogMemo.Lines.Add(IntToStr(gReturnCode));
187	213		end;
188	214		end;
189	215		end;
190	216
191	217		end.
192	218		```
193	219
194	220		Hauptprogramm:
195	221
196	222		``` pascal
197	223		program io_test;
198	224
199	225		{$mode objfpc}{$H+}
200	226
201	227		uses
202	228		{$IFDEF UNIX}{$IFDEF UseCThreads}
203	229		cthreads,
204	230		{$ENDIF}{$ENDIF}
205	231		Interfaces, // this includes the LCL widgetset
206	232		Forms, Unit1
207	233		{ you can add units after this };
208	234
209	235		{$R *.res}
210	236
211	237		begin
212	238		Application.Initialize;
213	239		Application.CreateForm(TForm1, Form1);
214	240		Application.Run;
215	241		end.
216	242		```
217	243
218	244		#### Den Status eines Anschlusses lesen
219	245
220	246		![Demo-Programm, das den Status eines GPIO-Pins ausliest\\|thumb\\|300px\\|right](/wiki-images/7/73/2013-04-28-193243_1280x1024_scrot.png) ![Testschaltung für das o. a. Programm\\|thumb\\|300px\\|right](/wiki-images/f/f4/Rpi_testcircuit_2d.png) ![Beispiel für diese Testschaltung auf einer Steckplatine\\|thumb\\|300px\\|right](/wiki-images/2/2f/Rpi_testcircuit_2p_annotaded.png)
221	247
222	248		Umgekehrt ist es natürlich auch möglich, den Status z. B. eines Schalters abzufragen, der mit dem GPIO-Port verbunden ist.
223	249
224	250		Das folgende einfache Beispiel ist dem vorherigen sehr ähnlich. Es benutzt den GPIO-Pin 18 als Eingang für ein binäres Gerät, z. B. einen Schalter, einen Transistor oder ein Relais. Das Programm enthält eine [[doc:lcl/stdctrls/tcheckbox.html\|CheckBox]] mit der Bezeichnung GPIO18CheckBox und zur Aufzeichnung von Return-Codes ein [[doc:lcl/stdctrls/tmemo.html\|TMemo]]-Feld mit dem Namen LogMemo.
225	251
226	252		Im Beispiel wurde ein Pol eines Tasters mit Pin 12 an der Anschlussleiste des Pi (entsprechend GPIO-Pin 18 des BCM2835 SOCs) und über einen 10-kOhm Pull-Up-Widerstand mit Pin 1 (+3.3V, siehe Schaltplan) verbunden. Der andere Pol wurde mit Pin 6 der Anschlussleiste (GND = Masse) verdrahtet. Das Programm liest den Status des Tasters aus und schaltet dementsprechend die CheckBox an oder aus.
227	253
228	254		Das Potential des Pins 18 ist hoch, wenn der Taster nicht gedrückt wird (wegen der Verbindung mit Pin 1 über den Pull-Up-Widerstand) und niedrig, wenn er gedrückt wird (da in dieser Situation Pin 18 über den Taster mit Masse verbunden wird). Der GPIO-Pin meldet daher 0, wenn der Taster gedrückt wird und 1, wenn er losgelassen wird.
229	255
230	256		Auch dieses Programm ist mit Root-Rechten auszuführen.
231	257
232	258		Steuerung-Unit:
233	259
234	260		``` pascal
235	261		unit Unit1;
236	262
237	263		{Demo application for GPIO on Raspberry Pi}
238	264		{Inspired by the Python input/output demo application by Gareth Halfacree}
239	265		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
240	266
241	267		{This application reads the status of a push-button}
242	268
243	269		{$mode objfpc}{$H+}
244	270
245	271		interface
246	272
247	273		uses
248	274		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
249	275		ButtonPanel, Unix, BaseUnix;
250	276
251	277		type
252	278
253	279		{ TForm1 }
254	280
255	281		TForm1 = class(TForm)
256	282		ApplicationProperties1: TApplicationProperties;
257	283		GPIO18CheckBox: TCheckBox;
258	284		LogMemo: TMemo;
259	285		procedure ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
260	286		procedure FormActivate(Sender: TObject);
261	287		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
262	288		private
263	289		{ private declarations }
264	290		public
265	291		{ public declarations }
266	292		end;
267	293
268	294		const
269	295		PIN_18: PChar = '18';
270	296		IN_DIRECTION: PChar = 'in';
271	297
272	298		var
273	299		Form1: TForm1;
274	300		gReturnCode: longint; {stores the result of the IO operation}
275	301
276	302		implementation
277	303
278	304		{$R *.lfm}
279	305
280	306		{ TForm1 }
281	307
282	308		procedure TForm1.FormActivate(Sender: TObject);
283	309		var
284	310		fileDesc: integer;
285	311		begin
286	312		{ Prepare SoC pin 18 (pin 12 on GPIO port) for access: }
287	313		try
288	314		fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
289	315		gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
290	316		LogMemo.Lines.Add(IntToStr(gReturnCode));
291	317		finally
292	318		gReturnCode := fpclose(fileDesc);
293	319		LogMemo.Lines.Add(IntToStr(gReturnCode));
294	320		end;
295	321		{ Set SoC pin 18 as input: }
296	322		try
297	323		fileDesc := fpopen('/sys/class/gpio/gpio18/direction', O_WrOnly);
298	324		gReturnCode := fpwrite(fileDesc, IN_DIRECTION[0], 2);
299	325		LogMemo.Lines.Add(IntToStr(gReturnCode));
300	326		finally
301	327		gReturnCode := fpclose(fileDesc);
302	328		LogMemo.Lines.Add(IntToStr(gReturnCode));
303	329		end;
304	330		end;
305	331
306	332		procedure TForm1.ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
307	333		var
308	334		fileDesc: integer;
309	335		buttonStatus: string[1] = '1';
310	336		begin
311	337		try
312	338		{ Open SoC pin 18 (pin 12 on GPIO port) in read-only mode: }
313	339		fileDesc := fpopen('/sys/class/gpio/gpio18/value', O_RdOnly);
314	340		if fileDesc > 0 then
315	341		begin
316	342		{ Read status of this pin (0: button pressed, 1: button released): }
317	343		gReturnCode := fpread(fileDesc, buttonStatus[1], 1);
318	344		LogMemo.Lines.Add(IntToStr(gReturnCode) + ': ' + buttonStatus);
319	345		LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
320	346		if buttonStatus = '0' then
321	347		GPIO18CheckBox.Checked := true
322	348		else
323	349		GPIO18CheckBox.Checked := false;
324	350		end;
325	351		finally
326	352		{ Close SoC pin 18 (pin 12 on GPIO port) }
327	353		gReturnCode := fpclose(fileDesc);
328	354		LogMemo.Lines.Add(IntToStr(gReturnCode));
329	355		LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
330	356		end;
331	357		end;
332	358
333	359		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
334	360		var
335	361		fileDesc: integer;
336	362		begin
337	363		{ Free SoC pin 18: }
338	364		try
339	365		fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
340	366		gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
341	367		LogMemo.Lines.Add(IntToStr(gReturnCode));
342	368		finally
343	369		gReturnCode := fpclose(fileDesc);
344	370		LogMemo.Lines.Add(IntToStr(gReturnCode));
345	371		end;
346	372		end;
347	373
348	374		end.
349	375		```
350	376
351	377		Das Hauptprogramm ist identisch zu dem des obigen Beispiels.
352	378
353	379		### 2. Hardware-Zugriff über gekapselte Shell-Aufrufe
354	380
355	381		Eine andere Möglichkeit, auf Hardware zuzugreifen, besteht in der Nutzung gekapselter Shell-Aufrufe. Dies geschieht mit Hilfe der [[Executing External Programs\|fpsystem]]-Funktion. Auf diese Weise ist es möglich, auf Funktionen zuzugreifen, die von der BaseUnix-Unit nicht unterstützt werden. Der folgende Code hat die selbe Funktionalität wie das Programm des ersten Listings oben.
356	382
357	383		Steuerungs-Unit:
358	384
359	385		``` pascal
360	386		unit Unit1;
361	387
362	388		{Demo application for GPIO on Raspberry Pi}
363	389		{Inspired by the Python input/output demo application by Gareth Halfacree}
364	390		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
365	391
366	392		{$mode objfpc}{$H+}
367	393
368	394		interface
369	395
370	396		uses
371	397		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, Unix;
372	398
373	399		type
374	400
375	401		{ TForm1 }
376	402
377	403		TForm1 = class(TForm)
378	404		LogMemo: TMemo;
379	405		GPIO17ToggleBox: TToggleBox;
380	406		procedure FormActivate(Sender: TObject);
381	407		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
382	408		procedure GPIO17ToggleBoxChange(Sender: TObject);
383	409		private
384	410		{ private declarations }
385	411		public
386	412		{ public declarations }
387	413		end;
388	414
389	415		var
390	416		Form1: TForm1;
391	417		gReturnCode: longint; {stores the result of the IO operation}
392	418
393	419		implementation
394	420
395	421		{$R *.lfm}
396	422
397	423		{ TForm1 }
398	424
399	425		procedure TForm1.FormActivate(Sender: TObject);
400	426		begin
401	427		{ Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
402	428		gReturnCode := fpsystem('echo "17" > /sys/class/gpio/export');
403	429		LogMemo.Lines.Add(IntToStr(gReturnCode));
404	430		{ Set SoC pin 17 as output: }
405	431		gReturnCode := fpsystem('echo "out" > /sys/class/gpio/gpio17/direction');
406	432		LogMemo.Lines.Add(IntToStr(gReturnCode));
407	433		end;
408	434
409	435		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
410	436		begin
411	437		{ Free SoC pin 17: }
412	438		gReturnCode := fpsystem('echo "17" > /sys/class/gpio/unexport');
413	439		LogMemo.Lines.Add(IntToStr(gReturnCode));
414	440		end;
415	441
416	442		procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
417	443		begin
418	444		if GPIO17ToggleBox.Checked then
419	445		begin
420	446		{ Swith SoC pin 17 on: }
421	447		gReturnCode := fpsystem('echo "1" > /sys/class/gpio/gpio17/value');
422	448		LogMemo.Lines.Add(IntToStr(gReturnCode));
423	449		end
424	450		else
425	451		begin
426	452		{ Switch SoC pin 17 off: }
427	453		gReturnCode := fpsystem('echo "0" > /sys/class/gpio/gpio17/value');
428	454		LogMemo.Lines.Add(IntToStr(gReturnCode));
429	455		end;
430	456		end;
431	457
432	458		end.
433	459		```
434	460
435	461		Das Hauptprogramm ist identisch zu dem der obigen Beispiele. Es erfordert wieder Root-Rechte.
436	462
437	463		### 3. wiringPi-Prozeduren und Funktionen
438	464
439	465		Mit Hilfe von Alex Schallers Wrapper-Unit für Gordon Hendersons Arduino-kompatible wiringPi-Bibliothek kann ein Nummerierungs-Schema verwendet werden, das dem der Arduino-Boards entspricht.
440	466
441	467		``` pascal
442	468		Function wiringPiSetup:longint; {Initialisiert das wiringPi-System entsprechend dem wiringPi Pin-Nummerierungs-Schema.}
443	469
444	470		Procedure wiringPiGpioMode(mode:longint); {Initialisiert das wiringPi-System mit dem Broadcom GPIO-Pin-Nummerierungs-Schema.}
445	471
446	472		Procedure pullUpDnControl(pin:longint; pud:longint); {steuert die internen pull-up/down-Widerstände eines GPIO-Pins.}
447	473
448	474		Procedure pinMode(pin:longint; mode:longint); {setzt den Betriebsmodus eines Pins auf entweder INPUT, OUTPUT oder PWM_OUTPUT.}
449	475
450	476		Procedure digitalWrite(pin:longint; value:longint); {setzt ein Ausgabe-Bit.}
451	477
452	478		Procedure pwmWrite(pin:longint; value:longint); {setzt einen Ausgabe-PWM-Wert zwischen 0 und 1024.}
453	479
454	480		Function digitalRead(pin:longint):longint; {liest den Wert des übergebenen Pins, gibt 1 oder 0.}
455	481
456	482		Procedure delay(howLong:dword); {wartet howLong Millisekunden.}
457	483
458	484		Procedure delayMicroseconds(howLong:dword); {wartet howLong Mikrosekunden.}
459	485
460	486		Function millis:dword; {gibt die Zahl der Millisekunden zurück, seit das Programm eine der wiringPiSetup-Funktionen aufgerufen hat.}
461	487		```
462	488
463	489		### 4. rpi_hal-Hardware Abstraction Library (GPIO, I2C und SPI Funktionen und Prozeduren)
464	490
465	491		Diese Unit mit ca. 1700 Lines of Code wird von Stefan Fischer zur Verfügung gestellt und bietet Prozeduren und Funktionen, die auf die rpi HW Zugriff auf I2C, SPI und GPIO bietet:
466	492
467	493		Ein Auszug der verfügbaren Funktionen und Prozeduren:
468	494
469	495		procedure gpio_set_pin (pin:longword;highlevel:boolean); { Set RPi GPIO pin to high or low level; Speed @ 700MHz -\> 0.65MHz }
470	496
471	497		function gpio_get_PIN (pin:longword):boolean; { Get RPi GPIO pin Level is true when Pin level is '1'; false when '0'; Speed @ 700MHz -\> 1.17MHz }
472	498
473	499		procedure gpio_set_input (pin:longword); { Set RPi GPIO pin to input direction }
474	500
475	501		procedure gpio_set_output(pin:longword); { Set RPi GPIO pin to output direction }
476	502
477	503		procedure gpio_set_alt (pin,altfunc:longword); { Set RPi GPIO pin to alternate function nr. 0..5 }
478	504
479	505		procedure gpio_set_gppud (mask:longword); { set RPi GPIO Pull-up/down Register (GPPUD) with mask }
480	506
481	507		...
482	508
483	509		function rpi_snr :string; { delivers SNR: 0000000012345678 }
484	510
485	511		function rpi_hw :string; { delivers Processor Type: BCM2708 }
486	512
487	513		function rpi_proc:string; { ARMv6-compatible processor rev 7 (v6l) }
488	514
489	515		...
490	516
491	517		function i2c_bus_write(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;
492	518
493	519		function i2c_bus_read (baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;
494	520
495	521		function i2c_string_read(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : string;
496	522
497	523		function i2c_string_write(baseadr,reg:word; s:string; testnr:integer) : integer;
498	524
499	525		...
500	526
501	527		procedure SPI_Write(devnum:byte; reg,data:word);
502	528
503	529		function SPI_Read(devnum:byte; reg:word) : byte;
504	530
505	531		procedure SPI_BurstRead2Buffer (devnum,start_reg:byte; xferlen:longword);
506	532
507	533		procedure SPI_BurstWriteBuffer (devnum,start_reg:byte; xferlen:longword); { Write 'len' Bytes from Buffer SPI Dev startig at address 'reg' }
508	534
509	535		...
510	536
511	537		Test Program (testrpi.pas):
512	538
513	539		``` pascal
514	540		//Simple Test program, which is using rpi_hal;
515	541
516	542		program testrpi;
517	543		uses rpi_hal;
518	544		begin
519	545		writeln('Show CPU-Info, RPI-HW-Info and Registers:');
520	546		rpi_show_all_info;
521	547		writeln('Let Status LED Blink. Using GPIO functions:');
522	548		GPIO_PIN_TOGGLE_TEST;
523	549		writeln('Test SPI Read function. (piggy back board with installed RFM22B Module is required!)');
524	550		Test_SPI;
525	551		end.
526	552		```
527	553
528	554		### 5. PascalIO
529	555
530	556		Mit dem Package [PascalIO](https://github.com/SAmeis/pascalio) kann objektorientiert auf die Schnittstellen zugegriffen werden. Es beinhaltet Klassen für die GPIO-Pins sowie für den I2C- und SPI-Bus.
531	557
532	558		#### GPIO
533	559
534	560		##### Input
535	561
536	562		``` pascal
537	563		program Project1;
538	564		uses fpgpio;
539	565		var
540	566		pin_21: TGpioPin;
541	567		begin
542	568		pin_21 := TGpioLinuxPin.Create(21);
543	569		pin_21.Direction := gdIn;
544	570		WriteLn('Pin 21 hat den Wert: ', pin_21.Value);
545	571		pin_21.Destroy;
546	572		end.
547	573		```
548	574
549	575		##### Output
550	576
551	577		``` pascal
552	578		program Project1;
553	579		uses sysutils, fpgpio;
554	580		var
555	581		i: Integer;
556	582		pin_21: TGpioPin;
557	583		begin
558	584		pin_21 := TGpioLinuxPin.Create(21);
559	585		pin_21.Direction := gdOut;
560	586		for i := 0 to 10 do
561	587		begin
562	588		pin_21.Value := (i and $01) = 0;
563	589		sleep(1000);
564	590		end;
565	591		pin_21.Destroy;
566	592		end.
567	593		```
568	594
569	595		##### Interrupt
570	596
571	597		``` pascal
572	598		program Project1;
573	599		uses fpgpio;
574	600		var
575	601		pin_21: TGpioPin;
576	602		NewValue: Boolean;
577	603		begin
578	604		pin_21 := TGpioLinuxPin.Create(21);
579	605		pin_21.Direction := gdIn;
580	606		pin_21.InterruptMode := [gimRising, gimFalling];
581	607		try
582	608		repeat
583	609		if input.WaitForInterrupt(TGpioLinuxPin.INTERRUPT_WAIT_INFINITE, NewValue) then
584	610		Writeln('Interrupt on Pin ', input.PinID, ' with value ', NewValue)
585	611		else
586	612		WriteLn('Timeout');
587	613		until False;
588	614		except
589	615		// e.g. on sig int
590	616		pin_21.Destroy;
591	617		end;
592	618		end.
593	619		```
594	620
595	621		## Literatur
596	622
597	623		- Eben Upton and Gareth Halfacree. Raspberry Pi User Guide. John Wiley and Sons, Chichester 2012, ISBN 111846446X
598	624
599	625		## Externe Links
600	626
601	627		- [Raspberry Pi Foundation](http://www.raspberrypi.org)
602	628		- [Raspberry Pi Spy: Raspberry Pi tutorials, scripts, help and downloads](http://www.raspberrypi-spy.co.uk)
603	629		- [Lazarus wrapper unit for Gordon Henderson's wiringPi C library](http://www.lazarus.freepascal.org/index.php/topic,17404.0.html)
604	630		- [Pin layout of the wiringPi library](https://projects.drogon.net/raspberry-pi/wiringpi/pins/)
605	631		- [Additional information on Lazarus and Raspberry Pi at eLinux.org](http://www.elinux.org/Lazarus_on_RPi)
606	632		- [Getting Started with Pascal on the Pi](http://www.pp4s.co.uk/main/gs-pi-intro.html)
607	633		- [Lazberry Pi: Umfangreiche Informationen zu Lazarus auf dem Raspberry Pi (englisch)](http://superbitysoft.co.uk/lazberrypi/).
608	634		- [Stefan Fischer's Lazarus unit rpi_hal](http://www.lazarus.freepascal.org/index.php/topic,20991.0.html).
609	635
610	636		---
611	637		From the Free Pascal wiki, page "Lazarus on Raspberry Pi/de", as it stood on 2020-02-18 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history