Lazarus on Raspberry Pi/de: what changed

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

Old	New		Line
1		-	<img src="Lazarus_on_Raspberry_Pi_Raspian_Wheezy_version_2012-10-28.png" title="Lazarus unter Raspbian Wheezy" width="200" alt="Lazarus unter Raspbian Wheezy" /> (Raspberry Pi only)
	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	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
37	37
38	38		#### Raspberry Pi 2
39	39
40	40		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	41
42	42		<File:Lazarus> 0 9 30 4 on RPi 2.png\\|Lazarus "out of the box" auf dem Raspberry Pi 2
43	43
44	44		### Übersetzen aus den Quelltexten
45	45
46	46		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	47
48	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
49	49
50	50		## Zugriff auf externe Hardware
51	51
52		-	~~<img src="rpi_pinout_all_50.png" title="Belegung der externen Anschlüsse des Raspberry Pi" width="300" />~~
	52	+	![](/wiki-images/f/f2/Rpi_pinout_all_50.png)
53	53
54	54		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	55
56	56		1. [[Lazarus on Raspberry Pi/de\|Direktzugriff]] über die [[doc:rtl/baseunix/index.html\|BaseUnix]]-Unit
57	57		2. Zugriff über [[Lazarus on Raspberry Pi/de\|gekapselte Shell-Aufrufe]]
58	58		3. Zugriff über die [[Lazarus on Raspberry Pi/de\|wiringPi library]].
59	59		4. Zugriff über die Unit [[Lazarus on Raspberry Pi/de\|rpi_hal]].
60	60
61	61		### 1. Nativer Hardware-Zugriff
62	62
63	63		![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	64
65	65		#### Schalten eines Gerätes über den GPIO-Port
66	66
67	67		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	68
69	69		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	70
71	71		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	72
73	73		Steuerungs-Unit:
74	74
75	75		``` pascal
76	76		unit Unit1;
77	77
78	78		{Demo application for GPIO on Raspberry Pi}
79	79		{Inspired by the Python input/output demo application by Gareth Halfacree}
80	80		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
81	81
82	82		{$mode objfpc}{$H+}
83	83
84	84		interface
85	85
86	86		uses
87	87		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
88	88		Unix, BaseUnix;
89	89
90	90		type
91	91
92	92		{ TForm1 }
93	93
94	94		TForm1 = class(TForm)
95	95		LogMemo: TMemo;
96	96		GPIO17ToggleBox: TToggleBox;
97	97		procedure FormActivate(Sender: TObject);
98	98		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
99	99		procedure GPIO17ToggleBoxChange(Sender: TObject);
100	100		private
101	101		{ private declarations }
102	102		public
103	103		{ public declarations }
104	104		end;
105	105
106	106		const
107	107		PIN_17: PChar = '17';
108	108		PIN_ON: PChar = '1';
109	109		PIN_OFF: PChar = '0';
110	110		OUT_DIRECTION: PChar = 'out';
111	111
112	112		var
113	113		Form1: TForm1;
114	114		gReturnCode: longint; {stores the result of the IO operation}
115	115
116	116		implementation
117	117
118	118		{$R *.lfm}
119	119
120	120		{ TForm1 }
121	121
122	122		procedure TForm1.FormActivate(Sender: TObject);
123	123		var
124	124		fileDesc: integer;
125	125		begin
126	126		{ Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
127	127		try
128	128		fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
129	129		gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
130	130		LogMemo.Lines.Add(IntToStr(gReturnCode));
131	131		finally
132	132		gReturnCode := fpclose(fileDesc);
133	133		LogMemo.Lines.Add(IntToStr(gReturnCode));
134	134		end;
135	135		{ Set SoC pin 17 as output: }
136	136		try
137	137		fileDesc := fpopen('/sys/class/gpio/gpio17/direction', O_WrOnly);
138	138		gReturnCode := fpwrite(fileDesc, OUT_DIRECTION[0], 3);
139	139		LogMemo.Lines.Add(IntToStr(gReturnCode));
140	140		finally
141	141		gReturnCode := fpclose(fileDesc);
142	142		LogMemo.Lines.Add(IntToStr(gReturnCode));
143	143		end;
144	144		end;
145	145
146	146		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
147	147		var
148	148		fileDesc: integer;
149	149		begin
150	150		{ Free SoC pin 17: }
151	151		try
152	152		fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
153	153		gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
154	154		LogMemo.Lines.Add(IntToStr(gReturnCode));
155	155		finally
156	156		gReturnCode := fpclose(fileDesc);
157	157		LogMemo.Lines.Add(IntToStr(gReturnCode));
158	158		end;
159	159		end;
160	160
161	161		procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
162	162		var
163	163		fileDesc: integer;
164	164		begin
165	165		if GPIO17ToggleBox.Checked then
166	166		begin
167	167		{ Swith SoC pin 17 on: }
168	168		try
169	169		fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
170	170		gReturnCode := fpwrite(fileDesc, PIN_ON[0], 1);
171	171		LogMemo.Lines.Add(IntToStr(gReturnCode));
172	172		finally
173	173		gReturnCode := fpclose(fileDesc);
174	174		LogMemo.Lines.Add(IntToStr(gReturnCode));
175	175		end;
176	176		end
177	177		else
178	178		begin
179	179		{ Switch SoC pin 17 off: }
180	180		try
181	181		fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
182	182		gReturnCode := fpwrite(fileDesc, PIN_OFF[0], 1);
183	183		LogMemo.Lines.Add(IntToStr(gReturnCode));
184	184		finally
185	185		gReturnCode := fpclose(fileDesc);
186	186		LogMemo.Lines.Add(IntToStr(gReturnCode));
187	187		end;
188	188		end;
189	189		end;
190	190
191	191		end.
192	192		```
193	193
194	194		Hauptprogramm:
195	195
196	196		``` pascal
197	197		program io_test;
198	198
199	199		{$mode objfpc}{$H+}
200	200
201	201		uses
202	202		{$IFDEF UNIX}{$IFDEF UseCThreads}
203	203		cthreads,
204	204		{$ENDIF}{$ENDIF}
205	205		Interfaces, // this includes the LCL widgetset
206	206		Forms, Unit1
207	207		{ you can add units after this };
208	208
209	209		{$R *.res}
210	210
211	211		begin
212	212		Application.Initialize;
213	213		Application.CreateForm(TForm1, Form1);
214	214		Application.Run;
215	215		end.
216	216		```
217	217
218	218		#### Den Status eines Anschlusses lesen
219	219
220	220		![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	221
222	222		Umgekehrt ist es natürlich auch möglich, den Status z. B. eines Schalters abzufragen, der mit dem GPIO-Port verbunden ist.
223	223
224	224		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	225
226	226		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	227
228	228		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	229
230	230		Auch dieses Programm ist mit Root-Rechten auszuführen.
231	231
232	232		Steuerung-Unit:
233	233
234	234		``` pascal
235	235		unit Unit1;
236	236
237	237		{Demo application for GPIO on Raspberry Pi}
238	238		{Inspired by the Python input/output demo application by Gareth Halfacree}
239	239		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
240	240
241	241		{This application reads the status of a push-button}
242	242
243	243		{$mode objfpc}{$H+}
244	244
245	245		interface
246	246
247	247		uses
248	248		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
249	249		ButtonPanel, Unix, BaseUnix;
250	250
251	251		type
252	252
253	253		{ TForm1 }
254	254
255	255		TForm1 = class(TForm)
256	256		ApplicationProperties1: TApplicationProperties;
257	257		GPIO18CheckBox: TCheckBox;
258	258		LogMemo: TMemo;
259	259		procedure ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
260	260		procedure FormActivate(Sender: TObject);
261	261		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
262	262		private
263	263		{ private declarations }
264	264		public
265	265		{ public declarations }
266	266		end;
267	267
268	268		const
269	269		PIN_18: PChar = '18';
270	270		IN_DIRECTION: PChar = 'in';
271	271
272	272		var
273	273		Form1: TForm1;
274	274		gReturnCode: longint; {stores the result of the IO operation}
275	275
276	276		implementation
277	277
278	278		{$R *.lfm}
279	279
280	280		{ TForm1 }
281	281
282	282		procedure TForm1.FormActivate(Sender: TObject);
283	283		var
284	284		fileDesc: integer;
285	285		begin
286	286		{ Prepare SoC pin 18 (pin 12 on GPIO port) for access: }
287	287		try
288	288		fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
289	289		gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
290	290		LogMemo.Lines.Add(IntToStr(gReturnCode));
291	291		finally
292	292		gReturnCode := fpclose(fileDesc);
293	293		LogMemo.Lines.Add(IntToStr(gReturnCode));
294	294		end;
295	295		{ Set SoC pin 18 as input: }
296	296		try
297	297		fileDesc := fpopen('/sys/class/gpio/gpio18/direction', O_WrOnly);
298	298		gReturnCode := fpwrite(fileDesc, IN_DIRECTION[0], 2);
299	299		LogMemo.Lines.Add(IntToStr(gReturnCode));
300	300		finally
301	301		gReturnCode := fpclose(fileDesc);
302	302		LogMemo.Lines.Add(IntToStr(gReturnCode));
303	303		end;
304	304		end;
305	305
306	306		procedure TForm1.ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
307	307		var
308	308		fileDesc: integer;
309	309		buttonStatus: string[1] = '1';
310	310		begin
311	311		try
312	312		{ Open SoC pin 18 (pin 12 on GPIO port) in read-only mode: }
313	313		fileDesc := fpopen('/sys/class/gpio/gpio18/value', O_RdOnly);
314	314		if fileDesc > 0 then
315	315		begin
316	316		{ Read status of this pin (0: button pressed, 1: button released): }
317	317		gReturnCode := fpread(fileDesc, buttonStatus[1], 1);
318	318		LogMemo.Lines.Add(IntToStr(gReturnCode) + ': ' + buttonStatus);
319	319		LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
320	320		if buttonStatus = '0' then
321	321		GPIO18CheckBox.Checked := true
322	322		else
323	323		GPIO18CheckBox.Checked := false;
324	324		end;
325	325		finally
326	326		{ Close SoC pin 18 (pin 12 on GPIO port) }
327	327		gReturnCode := fpclose(fileDesc);
328	328		LogMemo.Lines.Add(IntToStr(gReturnCode));
329	329		LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
330	330		end;
331	331		end;
332	332
333	333		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
334	334		var
335	335		fileDesc: integer;
336	336		begin
337	337		{ Free SoC pin 18: }
338	338		try
339	339		fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
340	340		gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
341	341		LogMemo.Lines.Add(IntToStr(gReturnCode));
342	342		finally
343	343		gReturnCode := fpclose(fileDesc);
344	344		LogMemo.Lines.Add(IntToStr(gReturnCode));
345	345		end;
346	346		end;
347	347
348	348		end.
349	349		```
350	350
351	351		Das Hauptprogramm ist identisch zu dem des obigen Beispiels.
352	352
353	353		### 2. Hardware-Zugriff über gekapselte Shell-Aufrufe
354	354
355	355		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	356
357	357		Steuerungs-Unit:
358	358
359	359		``` pascal
360	360		unit Unit1;
361	361
362	362		{Demo application for GPIO on Raspberry Pi}
363	363		{Inspired by the Python input/output demo application by Gareth Halfacree}
364	364		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
365	365
366	366		{$mode objfpc}{$H+}
367	367
368	368		interface
369	369
370	370		uses
371	371		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, Unix;
372	372
373	373		type
374	374
375	375		{ TForm1 }
376	376
377	377		TForm1 = class(TForm)
378	378		LogMemo: TMemo;
379	379		GPIO17ToggleBox: TToggleBox;
380	380		procedure FormActivate(Sender: TObject);
381	381		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
382	382		procedure GPIO17ToggleBoxChange(Sender: TObject);
383	383		private
384	384		{ private declarations }
385	385		public
386	386		{ public declarations }
387	387		end;
388	388
389	389		var
390	390		Form1: TForm1;
391	391		gReturnCode: longint; {stores the result of the IO operation}
392	392
393	393		implementation
394	394
395	395		{$R *.lfm}
396	396
397	397		{ TForm1 }
398	398
399	399		procedure TForm1.FormActivate(Sender: TObject);
400	400		begin
401	401		{ Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
402	402		gReturnCode := fpsystem('echo "17" > /sys/class/gpio/export');
403	403		LogMemo.Lines.Add(IntToStr(gReturnCode));
404	404		{ Set SoC pin 17 as output: }
405	405		gReturnCode := fpsystem('echo "out" > /sys/class/gpio/gpio17/direction');
406	406		LogMemo.Lines.Add(IntToStr(gReturnCode));
407	407		end;
408	408
409	409		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
410	410		begin
411	411		{ Free SoC pin 17: }
412	412		gReturnCode := fpsystem('echo "17" > /sys/class/gpio/unexport');
413	413		LogMemo.Lines.Add(IntToStr(gReturnCode));
414	414		end;
415	415
416	416		procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
417	417		begin
418	418		if GPIO17ToggleBox.Checked then
419	419		begin
420	420		{ Swith SoC pin 17 on: }
421	421		gReturnCode := fpsystem('echo "1" > /sys/class/gpio/gpio17/value');
422	422		LogMemo.Lines.Add(IntToStr(gReturnCode));
423	423		end
424	424		else
425	425		begin
426	426		{ Switch SoC pin 17 off: }
427	427		gReturnCode := fpsystem('echo "0" > /sys/class/gpio/gpio17/value');
428	428		LogMemo.Lines.Add(IntToStr(gReturnCode));
429	429		end;
430	430		end;
431	431
432	432		end.
433	433		```
434	434
435	435		Das Hauptprogramm ist identisch zu dem der obigen Beispiele. Es erfordert wieder Root-Rechte.
436	436
437	437		### 3. wiringPi-Prozeduren und Funktionen
438	438
439	439		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	440
441	441		``` pascal
442	442		Function wiringPiSetup:longint; {Initialisiert das wiringPi-System entsprechend dem wiringPi Pin-Nummerierungs-Schema.}
443	443
444	444		Procedure wiringPiGpioMode(mode:longint); {Initialisiert das wiringPi-System mit dem Broadcom GPIO-Pin-Nummerierungs-Schema.}
445	445
446	446		Procedure pullUpDnControl(pin:longint; pud:longint); {steuert die internen pull-up/down-Widerstände eines GPIO-Pins.}
447	447
448	448		Procedure pinMode(pin:longint; mode:longint); {setzt den Betriebsmodus eines Pins auf entweder INPUT, OUTPUT oder PWM_OUTPUT.}
449	449
450	450		Procedure digitalWrite(pin:longint; value:longint); {setzt ein Ausgabe-Bit.}
451	451
452	452		Procedure pwmWrite(pin:longint; value:longint); {setzt einen Ausgabe-PWM-Wert zwischen 0 und 1024.}
453	453
454	454		Function digitalRead(pin:longint):longint; {liest den Wert des übergebenen Pins, gibt 1 oder 0.}
455	455
456	456		Procedure delay(howLong:dword); {wartet howLong Millisekunden.}
457	457
458	458		Procedure delayMicroseconds(howLong:dword); {wartet howLong Mikrosekunden.}
459	459
460	460		Function millis:dword; {gibt die Zahl der Millisekunden zurück, seit das Programm eine der wiringPiSetup-Funktionen aufgerufen hat.}
461	461		```
462	462
463	463		### 4. rpi_hal-Hardware Abstraction Library (GPIO, I2C und SPI Funktionen und Prozeduren)
464	464
465	465		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	466
467	467		Ein Auszug der verfügbaren Funktionen und Prozeduren:
468	468
469	469		procedure gpio_set_pin (pin:longword;highlevel:boolean); { Set RPi GPIO pin to high or low level; Speed @ 700MHz -\> 0.65MHz }
470	470
471	471		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	472
473	473		procedure gpio_set_input (pin:longword); { Set RPi GPIO pin to input direction }
474	474
475	475		procedure gpio_set_output(pin:longword); { Set RPi GPIO pin to output direction }
476	476
477	477		procedure gpio_set_alt (pin,altfunc:longword); { Set RPi GPIO pin to alternate function nr. 0..5 }
478	478
479	479		procedure gpio_set_gppud (mask:longword); { set RPi GPIO Pull-up/down Register (GPPUD) with mask }
480	480
481	481		...
482	482
483	483		function rpi_snr :string; { delivers SNR: 0000000012345678 }
484	484
485	485		function rpi_hw :string; { delivers Processor Type: BCM2708 }
486	486
487	487		function rpi_proc:string; { ARMv6-compatible processor rev 7 (v6l) }
488	488
489	489		...
490	490
491	491		function i2c_bus_write(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;
492	492
493	493		function i2c_bus_read (baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;
494	494
495	495		function i2c_string_read(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : string;
496	496
497	497		function i2c_string_write(baseadr,reg:word; s:string; testnr:integer) : integer;
498	498
499	499		...
500	500
501	501		procedure SPI_Write(devnum:byte; reg,data:word);
502	502
503	503		function SPI_Read(devnum:byte; reg:word) : byte;
504	504
505	505		procedure SPI_BurstRead2Buffer (devnum,start_reg:byte; xferlen:longword);
506	506
507	507		procedure SPI_BurstWriteBuffer (devnum,start_reg:byte; xferlen:longword); { Write 'len' Bytes from Buffer SPI Dev startig at address 'reg' }
508	508
509	509		...
510	510
511	511		Test Program (testrpi.pas):
512	512
513	513		``` pascal
514	514		//Simple Test program, which is using rpi_hal;
515	515
516	516		program testrpi;
517	517		uses rpi_hal;
518	518		begin
519	519		writeln('Show CPU-Info, RPI-HW-Info and Registers:');
520	520		rpi_show_all_info;
521	521		writeln('Let Status LED Blink. Using GPIO functions:');
522	522		GPIO_PIN_TOGGLE_TEST;
523	523		writeln('Test SPI Read function. (piggy back board with installed RFM22B Module is required!)');
524	524		Test_SPI;
525	525		end.
526	526		```
527	527
528	528		### 5. PascalIO
529	529
530	530		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	531
532	532		#### GPIO
533	533
534	534		##### Input
535	535
536	536		``` pascal
537	537		program Project1;
538	538		uses fpgpio;
539	539		var
540	540		pin_21: TGpioPin;
541	541		begin
542	542		pin_21 := TGpioLinuxPin.Create(21);
543	543		pin_21.Direction := gdIn;
544	544		WriteLn('Pin 21 hat den Wert: ', pin_21.Value);
545	545		pin_21.Destroy;
546	546		end.
547	547		```
548	548
549	549		##### Output
550	550
551	551		``` pascal
552	552		program Project1;
553	553		uses sysutils, fpgpio;
554	554		var
555	555		i: Integer;
556	556		pin_21: TGpioPin;
557	557		begin
558	558		pin_21 := TGpioLinuxPin.Create(21);
559	559		pin_21.Direction := gdOut;
560	560		for i := 0 to 10 do
561	561		begin
562	562		pin_21.Value := (i and $01) = 0;
563	563		sleep(1000);
564	564		end;
565	565		pin_21.Destroy;
566	566		end.
567	567		```
568	568
569	569		##### Interrupt
570	570
571	571		``` pascal
572	572		program Project1;
573	573		uses fpgpio;
574	574		var
575	575		pin_21: TGpioPin;
576	576		NewValue: Boolean;
577	577		begin
578	578		pin_21 := TGpioLinuxPin.Create(21);
579	579		pin_21.Direction := gdIn;
580	580		pin_21.InterruptMode := [gimRising, gimFalling];
581	581		try
582	582		repeat
583	583		if input.WaitForInterrupt(TGpioLinuxPin.INTERRUPT_WAIT_INFINITE, NewValue) then
584	584		Writeln('Interrupt on Pin ', input.PinID, ' with value ', NewValue)
585	585		else
586	586		WriteLn('Timeout');
587	587		until False;
588	588		except
589	589		// e.g. on sig int
590	590		pin_21.Destroy;
591	591		end;
592	592		end.
593	593		```
594	594
595	595		## Literatur
596	596
597	597		- Eben Upton and Gareth Halfacree. Raspberry Pi User Guide. John Wiley and Sons, Chichester 2012, ISBN 111846446X
598	598
599	599		## Externe Links
600	600
601	601		- [Raspberry Pi Foundation](http://www.raspberrypi.org)
602	602		- [Raspberry Pi Spy: Raspberry Pi tutorials, scripts, help and downloads](http://www.raspberrypi-spy.co.uk)
603	603		- [Lazarus wrapper unit for Gordon Henderson's wiringPi C library](http://www.lazarus.freepascal.org/index.php/topic,17404.0.html)
604	604		- [Pin layout of the wiringPi library](https://projects.drogon.net/raspberry-pi/wiringpi/pins/)
605	605		- [Additional information on Lazarus and Raspberry Pi at eLinux.org](http://www.elinux.org/Lazarus_on_RPi)
606	606		- [Getting Started with Pascal on the Pi](http://www.pp4s.co.uk/main/gs-pi-intro.html)
607	607		- [Lazberry Pi: Umfangreiche Informationen zu Lazarus auf dem Raspberry Pi (englisch)](http://superbitysoft.co.uk/lazberrypi/).
608	608		- [Stefan Fischer's Lazarus unit rpi_hal](http://www.lazarus.freepascal.org/index.php/topic,20991.0.html).
609	609
610	610		---
611	611		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