Lazarus on Raspberry Pi: what changed

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

Old	New		Line
1	1		![](/wiki-images/e/ef/Lazarus_on_Raspberry_Pi_Raspian_Wheezy_version_2012-10-28.png)
2	2
3	3		(Raspberry Pi only)
4	4
5	5		The Raspberry Pi is a credit-card-sized single-board computer. It has been developed in the UK by the Raspberry Pi Foundation with the intention of stimulating the teaching of basic computer science in schools. Raspberry Pis are also used for multiple other purposes that are as different as media servers, robotics and control engineering.
6	6
7	7		The Raspberry Pi Foundation recommends [[Raspbian\|the Pasperry Pi OS]] as standard operating system. Alternative systems running on RPI include RISC OS and various [[Portal:Linux\|Linux]] distributions, as well as [[Portal:Android\|Android]] and [[Portal:FreeBSD\|FreeBSD]].
8	8
9	9		Lazarus runs natively under the Raspbian operating system.
10	10
11	11		## Installing and compiling Lazarus
12	12
13	13		### Introduction
14	14
15	15		Installing FPC and Lazarus on a Raspberry Pi is very little different from other Linux boxes, so please refer to [[Installing Lazarus on Linux]]. How ever, there are some RasPi particularities worth noting.
16	16
17	17		- RasPi do not always have enough memory to build Lazarus, this affects the routine rebuild of the IDE that happens when installing packages for example. The solution is to increase swap size (below).
18	18		- The Lazarus SourceForge repository does not include a pre-made RasPi package.
19	19		- If you are using the Raspberry Pi OS, its based on Debian and Debian has quite a long release cycle. So, at any one time, the repo provided Lazarus is likely to be out of date and, occasionally, so will the FPC be.
20	20		- Notwithstanding the above point, at present, late 2023, the Debian Bookworm based Raspberry Pi OS has the appropriate FPC and a Lazarus that suits most people. This will change !
21	21
22	22		### Correcting swap file size
23	23
24	24		(Info from forum user "Thaddy", updated.) If you have RPi with memory size less then 4Gb, and you want to build Lazarus from source or use FPCUPdeluxe or just rebuild the IDE after installing a package you need to allocate at least 1G if not 2G of swap. This appears to be particularly so with Raspberry Pi OS based on Bookworm rather than Bullseye.
25	25
26	26		To increase swap you should firstly ensure you have a couple of gig free and -
27	27
28	28		- sudo dphys-swapfile swapoff
29	29		- sudo nano /etc/dphys-swapfile
30	30		- in the file, find CONF_SWAPSIZE and change the value to 2048 (or 1024) and save it.
31	31		- sudo dphys-swapfile setup
32	32		- sudo dphys-swapfile swapon
33	33
34	34		You should now see the file, /var/swap, increase to 2G (or 1G). On some other operating systems, eg a "pure" debian, you may need to install the dphys-swapfile package.
35	35
36	36		If you don't have enough memory (real memory and swap) then, your compile processes (particularly assembling) will stop and the whole machine freezes. You have been warned !
37	37
38	38		While you are fiddling with the swap file, consider, if possible, moving the swap file from /var/swap to somewhere off the SDCard, unfortunately, SDCards are not good at the repetitive writes that happen in a swap file. Not critical but a good idea.
39	39
40	40		If you have problems making the swap file, see this <https://forums.raspberrypi.com/viewtopic.php?p=1881546>
41	41
42	42		### Simple installation
43	43
44	44		Most distributions have a graphic installer of some sort, look for entries like "Add / Remove Software" in your menus. Alternatively, all systems will have a command line interface. As hinted above, its likely that your distribution will have a current FPC, if so, best to use it. More interesting is Lazarus, as it changes more frequently, consider your needs. The Raspberry Pi OS, late 2023, has Lazarus 2.2.6. While version 3.0 of Lazarus is released now, it will take awhile to make it into distro's repos. Some users will, for the time being, be quite happy with Lazarus 2.2.6. Later on, you can remove the distro supplied Lazarus 2.2.6 and build 3.0 from source yourself, its easy.
45	45
46	46		A advantage of using the distro supplied FPC and Lazarus is that they test them, make sure everything needed is there and its very easy.
47	47
48	48		See [the Package Manager Model](https://wiki.freepascal.org/Installing_Lazarus_on_Linux#The_Package_Manager_Model).
49	49
50	50		### Not Quite as Simple Install
51	51
52	52		There are two other functional alternatives for installing Lazarus, building from source and using [[fpcupdeluxe]], an application that you run on your computer to manage your FPC / Lazarus install. Its very suited to people who just want to get a working install quickly, fpcupdeluxe will do the thinking for them. Fpcupdelux will install (and manage) both FPC and Lazarus and you should use them together.
53	53
54	54		Installing a non distro FPC is a touch more complicated still. Its [possible](https://wiki.freepascal.org/Installing_the_Free_Pascal_Compiler#Compiling_the_FPC_source.2C_using_preinstalled_FPC) to build a new FPC using an older, existing, FPC, might be a challenge for a less powerful Pi. An better option is to [download and install](https://wiki.freepascal.org/Installing_the_Free_Pascal_Compiler#Downloading_FPC_tar_balls) a tarball.
55	55
56	56		Its quite reasonable to use the distro provided FPC and build your own Lazarus. In fact, many users have several lazarus versions installed this way.
57	57
58	58		Building Lazarus [from source](https://wiki.freepascal.org/Installing_Lazarus_on_Linux#Build_Lazarus_from_Source) on a Raspberry Pi is no different from other Linuxes, except, perhaps, for the [[Lazarus on Raspberry Pi\|memory issue]].
59	59
60		-	~~<File:Lazarus> 0 9 30 4 on RPi 2.png\\|Lazarus "out of the box" on Raspberry Pi 2~~
	60	+	![](/wiki-images/c/cc/Lazarus_0_9_30_4_on_RPi_2.png)
	61	+
	62	+	Lazarus "out of the box" on Raspberry Pi 2
61	63
62	64		### Cross compiling for the Raspberry Pi from Windows
63	65
64	66		1\. Using fpcup
65	67
66	68		One way is to use fpcup to set up a cross compiler; follow these instructions: [[fpcup\|fpcup#Linux_ARM_cross_compiler]]
67	69
68	70		2\. Using scripts
69	71
70	72		Alternatively, for a more manual approach using batch files, you can follow these steps.
71	73
72	74		2.1 Prerequisites
73	75
74	76		`FPC 2.7.1 or higher installed with source code`\
75	77		`Install the Windows version from the Linaro binutils for linux gnueabihf into %FPCPATH%/bin/win32-armhf-linux `[`1`](https://launchpad.net/linaro-toolchain-binaries/trunk/2013.10/+download/gcc-linaro-arm-linux-gnueabihf-4.8-2013.10_win32.zip)
76	78
77	79		2.2 Example Windows Batch file (adapt paths as needed)
78	80
79	81		``` bat
80	82		set PATH=C:\pp\bin\i386-win32;%PATH%;
81	83		set FPCMAKEPATH=C:/pp
82	84		set FPCPATH=C:/pp
83	85		set OUTPATH=C:/pp271
84	86		%FPCMAKEPATH%/bin/i386-win32/make distclean OS_TARGET=linux CPU_TARGET=arm CROSSBINDIR=%FPCPATH%/bin/win32-armhf-linux CROSSOPT="-CpARMV6 -CfVFPV2 -OoFASTMATH" FPC=%FPCPATH%/bin/i386-win32/ppc386.exe
85	87
86	88		%FPCMAKEPATH%/bin/i386-win32/make all OS_TARGET=linux CPU_TARGET=arm CROSSBINDIR=%FPCPATH%/bin/win32-armhf-linux CROSSOPT="-CpARMV6 -CfVFPV2 -OoFASTMATH" FPC=%FPCPATH%/bin/i386-win32/ppc386.exe
87	89		if errorlevel 1 goto quit
88	90		%FPCMAKEPATH%/bin/i386-win32/make crossinstall CROSSBINDIR=%FPCPATH%/bin/win32-armhf-linux CROSSOPT="-CpARMV6 -CfVFPV2 -OoFASTMATH" OS_TARGET=linux CPU_TARGET=arm FPC=%FPCPATH%/bin/i386-win32/ppc386.exe INSTALL_BASEDIR=%OUTPATH%
89	91
90	92		:quit
91	93		pause
92	94		```
93	95
94	96		With the resulting ppcrossarm.exe and ARM RTL you will be able to build a cross Lazarus version as usual and compile FPC projects for the Raspberry Pi and other armhf devices.
95	97
96	98		Remember that not all - especially Windows - libraries are available for Linux arm.
97	99
98	100		### Cross compiling for the Raspberry Pi from Linux
99	101
100	102		Please see this page <https://wiki.freepascal.org/Cross_Compile_to_RasPi_from_Linux>
101	103
102	104		## Accessing external hardware
103	105
104	106		![](/wiki-images/f/f2/Rpi_pinout_all_50.png)
105	107
106	108		One of the goals in the development of Raspberry Pi was to facilitate effortless access to external devices like sensors and actuators. There are many ways to access the I/O facilities from Lazarus and Free Pascal:
107	109
108	110		1. [[Lazarus on Raspberry Pi\|Direct access]] using the [[BaseUnix]] unit
109	111		2. Access through [[Lazarus on Raspberry Pi\|encapsulated shell calls]]
110	112		3. Access through the [[Lazarus on Raspberry Pi\|wiringPi library]].
111	113		4. Access through Unit [[Lazarus on Raspberry Pi\|rpi_hal]].
112	114		5. Access through Unit [[Lazarus on Raspberry Pi\|PiGpio]].
113	115		6. Access through the [PascalIO](https://github.com/SAmeis/pascalio) library.
114	116		7. Access through the [PXL](http://asphyre.net/products/pxl) library.
115	117
116	118		### Native hardware access
117	119
118	120		![Simple test program for accessing the GPIO port on Raspberry Pi\\|thumb\\|300px\\|right](/wiki-images/d/d2/Testprogram_for_GPIO_on_RPI_annotated.png) ![Test circuit for GPIO access with the described program\\|thumb\\|300px\\|right](/wiki-images/7/7c/Rpi_testcircuit_1d.png) ![Simple demo implementation of the circuit from above on a breadboard\\|thumb\\|300px\\|right](/wiki-images/7/7e/Rpi_testcircuit_1p_annotaded.png) This method provides access to external hardware that doesn't require additional libraries. The only requirement is the BaseUnix library that is part of Free Pascal's RTL.
119	121
120	122		#### Switching a device via the GPIO port
121	123
122	124		The following example lists a simple program that controls the GPIO pin 17 as output to switch an LED, transistor or relays. This program contains a [[doc:lcl/stdctrls/ttogglebox.html\|ToggleBox]] with name GPIO17ToggleBox and for logging return codes a [[doc:lcl/stdctrls/tmemo.html\|TMemo]] called LogMemo.
123	125
124	126		For the example, the anode of a LED has been connected with Pin 11 on the Pi's connector (corresponding to GPIO pin 17 of the BCM2835 SOC) and the LED's cathode was wired via a 68 Ohm resistor to pin 6 of the connector (GND) as previously described by Upton and Halfacree. Subsequently, the LED may be switched on and off with the application's toggle box.
125	127
126	128		The code may at first require to be run as root, i.e. either from a root account (not recommended) or via su. A better option is to add the user to the gpio group, the i2c group and the spi group.
127	129
128	130		``` bash
129	131		sudo adduser pi gpio
130	132		sudo adduser pi i2c
131	133		sudo adduser pi spi
132	134		```
133	135
134	136		Controlling unit:
135	137
136	138		``` pascal
137	139		unit Unit1;
138	140
139	141		{Demo application for GPIO on Raspberry Pi}
140	142		{Inspired by the Python input/output demo application by Gareth Halfacree}
141	143		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
142	144
143	145		{$mode objfpc}{$H+}
144	146
145	147		interface
146	148
147	149		uses
148	150		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
149	151		Unix, BaseUnix;
150	152
151	153		type
152	154
153	155		{ TForm1 }
154	156
155	157		TForm1 = class(TForm)
156	158		LogMemo: TMemo;
157	159		GPIO17ToggleBox: TToggleBox;
158	160		procedure FormActivate(Sender: TObject);
159	161		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
160	162		procedure GPIO17ToggleBoxChange(Sender: TObject);
161	163		private
162	164		{ private declarations }
163	165		public
164	166		{ public declarations }
165	167		end;
166	168
167	169		const
168	170		PIN_17: PChar = '17';
169	171		PIN_ON: PChar = '1';
170	172		PIN_OFF: PChar = '0';
171	173		OUT_DIRECTION: PChar = 'out';
172	174
173	175		var
174	176		Form1: TForm1;
175	177		gReturnCode: longint; {stores the result of the IO operation}
176	178
177	179		implementation
178	180
179	181		{$R *.lfm}
180	182
181	183		{ TForm1 }
182	184
183	185		procedure TForm1.FormActivate(Sender: TObject);
184	186		var
185	187		fileDesc: integer;
186	188		begin
187	189		{ Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
188	190		try
189	191		fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
190	192		gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
191	193		LogMemo.Lines.Add(IntToStr(gReturnCode));
192	194		finally
193	195		gReturnCode := fpclose(fileDesc);
194	196		LogMemo.Lines.Add(IntToStr(gReturnCode));
195	197		end;
196	198		{ Set SoC pin 17 as output: }
197	199		try
198	200		fileDesc := fpopen('/sys/class/gpio/gpio17/direction', O_WrOnly);
199	201		gReturnCode := fpwrite(fileDesc, OUT_DIRECTION[0], 3);
200	202		LogMemo.Lines.Add(IntToStr(gReturnCode));
201	203		finally
202	204		gReturnCode := fpclose(fileDesc);
203	205		LogMemo.Lines.Add(IntToStr(gReturnCode));
204	206		end;
205	207		end;
206	208
207	209		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
208	210		var
209	211		fileDesc: integer;
210	212		begin
211	213		{ Free SoC pin 17: }
212	214		try
213	215		fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
214	216		gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
215	217		LogMemo.Lines.Add(IntToStr(gReturnCode));
216	218		finally
217	219		gReturnCode := fpclose(fileDesc);
218	220		LogMemo.Lines.Add(IntToStr(gReturnCode));
219	221		end;
220	222		end;
221	223
222	224		procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
223	225		var
224	226		fileDesc: integer;
225	227		begin
226	228		if GPIO17ToggleBox.Checked then
227	229		begin
228	230		{ Swith SoC pin 17 on: }
229	231		try
230	232		fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
231	233		gReturnCode := fpwrite(fileDesc, PIN_ON[0], 1);
232	234		LogMemo.Lines.Add(IntToStr(gReturnCode));
233	235		finally
234	236		gReturnCode := fpclose(fileDesc);
235	237		LogMemo.Lines.Add(IntToStr(gReturnCode));
236	238		end;
237	239		end
238	240		else
239	241		begin
240	242		{ Switch SoC pin 17 off: }
241	243		try
242	244		fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
243	245		gReturnCode := fpwrite(fileDesc, PIN_OFF[0], 1);
244	246		LogMemo.Lines.Add(IntToStr(gReturnCode));
245	247		finally
246	248		gReturnCode := fpclose(fileDesc);
247	249		LogMemo.Lines.Add(IntToStr(gReturnCode));
248	250		end;
249	251		end;
250	252		end;
251	253
252	254		end.
253	255		```
254	256
255	257		Main program:
256	258
257	259		``` pascal
258	260		program io_test;
259	261
260	262		{$mode objfpc}{$H+}
261	263
262	264		uses
263	265		{$IFDEF UNIX}{$IFDEF UseCThreads}
264	266		cthreads,
265	267		{$ENDIF}{$ENDIF}
266	268		Interfaces, // this includes the LCL widgetset
267	269		Forms, Unit1
268	270		{ you can add units after this };
269	271
270	272		{$R *.res}
271	273
272	274		begin
273	275		Application.Initialize;
274	276		Application.CreateForm(TForm1, Form1);
275	277		Application.Run;
276	278		end.
277	279		```
278	280
279	281		#### Reading the status of a pin
280	282
281	283		![Demo program for reading the status of a GPIO pin\\|thumb\\|300px\\|right](/wiki-images/7/73/2013-04-28-193243_1280x1024_scrot.png) ![Test circuit for GPIO access with the described program\\|thumb\\|300px\\|right](/wiki-images/f/f4/Rpi_testcircuit_2d.png) ![Possible implementation of this test circuit\\|thumb\\|300px\\|right](/wiki-images/2/2f/Rpi_testcircuit_2p_annotaded.png)
282	284
283	285		Of course it is also possible to read the status of e.g. a switch that is connected to the GPIO port.
284	286
285	287		The following simple example is very similar to the previous one. It controls the GPIO pin 18 as input for a binary device like a switch, transistor or relais. This program contains a [[doc:lcl/stdctrls/tcheckbox.html\|CheckBox]] with name GPIO18CheckBox and for logging return codes a [[doc:lcl/stdctrls/tmemo.html\|TMemo]] called LogMemo.
286	288
287	289		For the example, one pole of a push-button has been connected to Pin 12 on the Pi's connector (corresponding to GPIO pin 18 of the BCM2835 SOC) and via a 10k Ohm pull-up resistor with pin 1 (+3.3V, see wiring diagram). The other pole has been wired to pin 6 of the connector (GND). The program senses the status of the button and correspondingly switches the checkbox on or off, respectively.
288	290
289	291		Note that the potential of pin 18 is high if the button is released (by virtue of the connection to pin 1 via the pull-up resistor) and low if it is pressed (since in this situation pin 18 is connected to GND via the switch). Therefore, the GPIO pin signals 0 if the button is pressed and 1 if it is released.
290	292
291	293		This program has again to be executed as root.
292	294
293	295		Controlling unit:
294	296
295	297		``` pascal
296	298		unit Unit1;
297	299
298	300		{Demo application for GPIO on Raspberry Pi}
299	301		{Inspired by the Python input/output demo application by Gareth Halfacree}
300	302		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
301	303
302	304		{This application reads the status of a push-button}
303	305
304	306		{$mode objfpc}{$H+}
305	307
306	308		interface
307	309
308	310		uses
309	311		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
310	312		ButtonPanel, Unix, BaseUnix;
311	313
312	314		type
313	315
314	316		{ TForm1 }
315	317
316	318		TForm1 = class(TForm)
317	319		ApplicationProperties1: TApplicationProperties;
318	320		GPIO18CheckBox: TCheckBox;
319	321		LogMemo: TMemo;
320	322		procedure ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
321	323		procedure FormActivate(Sender: TObject);
322	324		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
323	325		private
324	326		{ private declarations }
325	327		public
326	328		{ public declarations }
327	329		end;
328	330
329	331		const
330	332		PIN_18: PChar = '18';
331	333		IN_DIRECTION: PChar = 'in';
332	334
333	335		var
334	336		Form1: TForm1;
335	337		gReturnCode: longint; {stores the result of the IO operation}
336	338
337	339		implementation
338	340
339	341		{$R *.lfm}
340	342
341	343		{ TForm1 }
342	344
343	345		procedure TForm1.FormActivate(Sender: TObject);
344	346		var
345	347		fileDesc: integer;
346	348		begin
347	349		{ Prepare SoC pin 18 (pin 12 on GPIO port) for access: }
348	350		try
349	351		fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
350	352		gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
351	353		LogMemo.Lines.Add(IntToStr(gReturnCode));
352	354		finally
353	355		gReturnCode := fpclose(fileDesc);
354	356		LogMemo.Lines.Add(IntToStr(gReturnCode));
355	357		end;
356	358		{ Set SoC pin 18 as input: }
357	359		try
358	360		fileDesc := fpopen('/sys/class/gpio/gpio18/direction', O_WrOnly);
359	361		gReturnCode := fpwrite(fileDesc, IN_DIRECTION[0], 2);
360	362		LogMemo.Lines.Add(IntToStr(gReturnCode));
361	363		finally
362	364		gReturnCode := fpclose(fileDesc);
363	365		LogMemo.Lines.Add(IntToStr(gReturnCode));
364	366		end;
365	367		end;
366	368
367	369		procedure TForm1.ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
368	370		var
369	371		fileDesc: integer;
370	372		buttonStatus: string[1] = '1';
371	373		begin
372	374		try
373	375		{ Open SoC pin 18 (pin 12 on GPIO port) in read-only mode: }
374	376		fileDesc := fpopen('/sys/class/gpio/gpio18/value', O_RdOnly);
375	377		if fileDesc > 0 then
376	378		begin
377	379		{ Read status of this pin (0: button pressed, 1: button released): }
378	380		gReturnCode := fpread(fileDesc, buttonStatus[1], 1);
379	381		LogMemo.Lines.Add(IntToStr(gReturnCode) + ': ' + buttonStatus);
380	382		LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
381	383		if buttonStatus = '0' then
382	384		GPIO18CheckBox.Checked := true
383	385		else
384	386		GPIO18CheckBox.Checked := false;
385	387		end;
386	388		finally
387	389		{ Close SoC pin 18 (pin 12 on GPIO port) }
388	390		gReturnCode := fpclose(fileDesc);
389	391		LogMemo.Lines.Add(IntToStr(gReturnCode));
390	392		LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
391	393		end;
392	394		end;
393	395
394	396		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
395	397		var
396	398		fileDesc: integer;
397	399		begin
398	400		{ Free SoC pin 18: }
399	401		try
400	402		fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
401	403		gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
402	404		LogMemo.Lines.Add(IntToStr(gReturnCode));
403	405		finally
404	406		gReturnCode := fpclose(fileDesc);
405	407		LogMemo.Lines.Add(IntToStr(gReturnCode));
406	408		end;
407	409		end;
408	410
409	411		end.
410	412		```
411	413
412	414		The main program is identical to that of the example from above.
413	415
414	416		### Hardware access via encapsulated shell calls
415	417
416	418		Another way to access the hardware is by encapsulating terminal commands. This is achieved by using the [[Executing External Programs\|fpsystem]] function. This method gives access to functions that are not supported by the BaseUnix unit. The following code implements a program that has the same functionality as the program resulting from the first listing above.
417	419
418	420		Controlling unit:
419	421
420	422		``` pascal
421	423		unit Unit1;
422	424
423	425		{Demo application for GPIO on Raspberry Pi}
424	426		{Inspired by the Python input/output demo application by Gareth Halfacree}
425	427		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
426	428
427	429		{$mode objfpc}{$H+}
428	430
429	431		interface
430	432
431	433		uses
432	434		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, Unix;
433	435
434	436		type
435	437
436	438		{ TForm1 }
437	439
438	440		TForm1 = class(TForm)
439	441		LogMemo: TMemo;
440	442		GPIO17ToggleBox: TToggleBox;
441	443		procedure FormActivate(Sender: TObject);
442	444		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
443	445		procedure GPIO17ToggleBoxChange(Sender: TObject);
444	446		private
445	447		{ private declarations }
446	448		public
447	449		{ public declarations }
448	450		end;
449	451
450	452		var
451	453		Form1: TForm1;
452	454		gReturnCode: longint; {stores the result of the IO operation}
453	455
454	456		implementation
455	457
456	458		{$R *.lfm}
457	459
458	460		{ TForm1 }
459	461
460	462		procedure TForm1.FormActivate(Sender: TObject);
461	463		begin
462	464		{ Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
463	465		gReturnCode := fpsystem('echo "17" > /sys/class/gpio/export');
464	466		LogMemo.Lines.Add(IntToStr(gReturnCode));
465	467		{ Set SoC pin 17 as output: }
466	468		gReturnCode := fpsystem('echo "out" > /sys/class/gpio/gpio17/direction');
467	469		LogMemo.Lines.Add(IntToStr(gReturnCode));
468	470		end;
469	471
470	472		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
471	473		begin
472	474		{ Free SoC pin 17: }
473	475		gReturnCode := fpsystem('echo "17" > /sys/class/gpio/unexport');
474	476		LogMemo.Lines.Add(IntToStr(gReturnCode));
475	477		end;
476	478
477	479		procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
478	480		begin
479	481		if GPIO17ToggleBox.Checked then
480	482		begin
481	483		{ Swith SoC pin 17 on: }
482	484		gReturnCode := fpsystem('echo "1" > /sys/class/gpio/gpio17/value');
483	485		LogMemo.Lines.Add(IntToStr(gReturnCode));
484	486		end
485	487		else
486	488		begin
487	489		{ Switch SoC pin 17 off: }
488	490		gReturnCode := fpsystem('echo "0" > /sys/class/gpio/gpio17/value');
489	491		LogMemo.Lines.Add(IntToStr(gReturnCode));
490	492		end;
491	493		end;
492	494
493	495		end.
494	496		```
495	497
496	498		The main program is identical to that of the example above. This program has to be executed with root privileges, too.
497	499
498	500		### wiringPi procedures and functions
499	501
500	502		Alex Schaller's wrapper unit for Gordon Henderson's Arduino compatible wiringPi library provides a numbering scheme that resembles that of Arduino boards.
501	503
502	504		Function wiringPiSetup:longint: Initializes wiringPi system using the wiringPi pin numbering scheme.
503	505
504	506		Procedure wiringPiGpioMode(mode:longint): Initializes wiringPi system with the Broadcom GPIO pin numbering scheme.
505	507
506	508		Procedure pullUpDnControl(pin:longint; pud:longint): controls the internal pull-up/down resistors on a GPIO pin.
507	509
508	510		Procedure pinMode(pin:longint; mode:longint): sets the mode of a pin to either INPUT, OUTPUT, or PWM_OUTPUT.
509	511
510	512		Procedure digitalWrite(pin:longint; value:longint): sets an output bit.
511	513
512	514		Procedure pwmWrite(pin:longint; value:longint): sets an output PWM value between 0 and 1024.
513	515
514	516		Function digitalRead(pin:longint):longint: reads the value of a given Pin, returning 1 or 0.
515	517
516	518		Procedure delay(howLong:dword): waits for at least howLong milliseconds.
517	519
518	520		Procedure delayMicroseconds(howLong:dword): waits for at least howLong microseconds.
519	521
520	522		Function millis:dword: returns the number of milliseconds since the program called one of the wiringPiSetup functions.
521	523
522	524		### rpi_hal-Hardware Abstraction Library (GPIO, I2C and SPI functions and procedures)
523	525
524	526		This Unit with around 1700 Lines of Code provided by Stefan Fischer, delivers procedures and functions to access the rpi HW I2C, SPI and GPIO:
525	527
526	528		Just an excerpt of the available functions and procedures:
527	529
528	530		procedure gpio_set_pin (pin:longword;highlevel:boolean); { Set RPi GPIO pin to high or low level; Speed @ 700MHz -\> 0.65MHz }
529	531
530	532		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 }
531	533
532	534		procedure gpio_set_input (pin:longword); { Set RPi GPIO pin to input direction }
533	535
534	536		procedure gpio_set_output(pin:longword); { Set RPi GPIO pin to output direction }
535	537
536	538		procedure gpio_set_alt (pin,altfunc:longword); { Set RPi GPIO pin to alternate function nr. 0..5 }
537	539
538	540		procedure gpio_set_gppud (mask:longword); { set RPi GPIO Pull-up/down Register (GPPUD) with mask }
539	541
540	542		...
541	543
542	544		function rpi_snr :string; { delivers SNR: 0000000012345678 }
543	545
544	546		function rpi_hw :string; { delivers Processor Type: BCM2708 }
545	547
546	548		function rpi_proc:string; { ARMv6-compatible processor rev 7 (v6l) }
547	549
548	550		...
549	551
550	552		function i2c_bus_write(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;
551	553
552	554		function i2c_bus_read (baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;
553	555
554	556		function i2c_string_read(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : string;
555	557
556	558		function i2c_string_write(baseadr,reg:word; s:string; testnr:integer) : integer;
557	559
558	560		...
559	561
560	562		procedure SPI_Write(devnum:byte; reg,data:word);
561	563
562	564		function SPI_Read(devnum:byte; reg:word) : byte;
563	565
564	566		procedure SPI_BurstRead2Buffer (devnum,start_reg:byte; xferlen:longword);
565	567
566	568		procedure SPI_BurstWriteBuffer (devnum,start_reg:byte; xferlen:longword); { Write 'len' Bytes from Buffer SPI Dev startig at address 'reg' }
567	569
568	570		...
569	571
570	572		Test Program (testrpi.pas):
571	573
572	574		``` pascal
573	575		//Simple Test program, which is using rpi_hal;
574	576
575	577		program testrpi;
576	578		uses rpi_hal;
577	579		begin
578	580		writeln('Show CPU-Info, RPI-HW-Info and Registers:');
579	581		rpi_show_all_info;
580	582		writeln('Let Status LED Blink. Using GPIO functions:');
581	583		GPIO_PIN_TOGGLE_TEST;
582	584		writeln('Test SPI Read function. (piggy back board with installed RFM22B Module is required!)');
583	585		Test_SPI;
584	586		end.
585	587		```
586	588
587	589		### PiGpio Low-level native pascal unit (GPIO control instead of wiringPi c library)
588	590
589	591		This Unit (pigpio.pas[2](https://docs.google.com/file/d/0B-b-5ooIWPvGN1BIcEJzRDgyeUE/edit?usp=sharing)) with 270 Lines of Code provided by Gabor Szollosi, works very fast (for ex. GPIO pin output switching frequency 8 MHz) :
590	592
591	593		``` pascal
592	594
593	595		unit PiGpio;
594	596		{
595	597		BCM2835 GPIO Registry Driver, also can use to manipulate cpu other registry areas
596	598
597	599		This code is tested only Broadcom bcm2835 cpu, different arm cpus may need different
598	600		gpio driver implementation
599	601
600	602		2013 Gabor Szollosi
601	603		}
602	604		{$mode objfpc}{$H+}
603	605
604	606		interface
605	607
606	608		uses
607	609		Classes, SysUtils;
608	610
609	611		const
610	612		REG_GPIO = $3F000;// bcm2835 gpio register 0x2000 0000 (RPi1), 0x3F00 0000 (RPi2)
611	613		// new fpMap uses page offset, one page is 4096 bytes = 0x1000 so simply calculate 0x2000 0000 / 0x1000 = 0x2000 0
612	614		PAGE_SIZE = 4096;
613	615		BLOCK_SIZE = 4096;
614	616		// The BCM2835 has 54 GPIO pins.
615	617		// BCM2835 data sheet, Page 90 onwards.
616	618		// There are 6 control registers, each control the functions of a block
617	619		// of 10 pins.
618	620
619	621		CLOCK_BASE = (REG_GPIO + $101);
620	622		GPIO_BASE = (REG_GPIO + $200);
621	623		GPIO_PWM = (REG_GPIO + $20C);
622	624
623	625		INPUT = 0;
624	626		OUTPUT = 1;
625	627		PWM_OUTPUT = 2;
626	628		LOW = False;
627	629		HIGH = True;
628	630		PUD_OFF = 0;
629	631		PUD_DOWN = 1;
630	632		PUD_UP = 2;
631	633
632	634		// PWM
633	635
634	636		PWM_CONTROL = 0;
635	637		PWM_STATUS = 4;
636	638		PWM0_RANGE = 16;
637	639		PWM0_DATA = 20;
638	640		PWM1_RANGE = 32;
639	641		PWM1_DATA = 36;
640	642
641	643		PWMCLK_CNTL = 160;
642	644		PWMCLK_DIV = 164;
643	645
644	646		PWM1_MS_MODE = $8000; // Run in MS mode
645	647		PWM1_USEFIFO = $2000; // Data from FIFO
646	648		PWM1_REVPOLAR = $1000; // Reverse polarity
647	649		PWM1_OFFSTATE = $0800; // Ouput Off state
648	650		PWM1_REPEATFF = $0400; // Repeat last value if FIFO empty
649	651		PWM1_SERIAL = $0200; // Run in serial mode
650	652		PWM1_ENABLE = $0100; // Channel Enable
651	653
652	654		PWM0_MS_MODE = $0080; // Run in MS mode
653	655		PWM0_USEFIFO = $0020; // Data from FIFO
654	656		PWM0_REVPOLAR = $0010; // Reverse polarity
655	657		PWM0_OFFSTATE = $0008; // Ouput Off state
656	658		PWM0_REPEATFF = $0004; // Repeat last value if FIFO empty
657	659		PWM0_SERIAL = $0002; // Run in serial mode
658	660		PWM0_ENABLE = $0001; // Channel Enable
659	661
660	662		type
661	663
662	664		{ TIoPort }
663	665
664	666		TIoPort = class // IO bank object
665	667		private //
666	668
667	669		//function get_pinDirection(aPin: TGpIoPin): TGpioPinConf;
668	670
669	671		public
670	672		FGpio: ^LongWord;
671	673		FClk: ^LongWord;
672	674		FPwm: ^LongWord;
673	675		procedure SetPinMode(gpin, mode: byte);
674	676		function GetBit(gpin : byte):boolean;inline; // gets pin bit}
675	677		procedure ClearBit(gpin : byte);inline;// write pin to 0
676	678		procedure SetBit(gpin : byte);inline;// write pin to 1
677	679		procedure SetPullMode(gpin, mode: byte);
678	680		procedure PwmWrite(gpin : byte; value : LongWord);inline;// write pin to pwm value
679	681		end;
680	682
681	683		{ TIoDriver }
682	684
683	685		TIoDriver = class
684	686		private
685	687
686	688		public
687	689		destructor Destroy;override;
688	690		function MapIo:boolean;// creates io memory mapping
689	691		procedure UnmapIoRegisrty(FMap: TIoPort);// close io memory mapping
690	692		function CreatePort(PortGpio, PortClk, PortPwm: LongWord):TIoPort; // create new IO port
691	693		end;
692	694
693	695		var
694	696
695	697		fd: integer;// /dev/mem file handle
696	698		procedure delayNanoseconds (howLong : LongWord);
697	699
698	700		implementation
699	701
700	702		uses
701	703		baseUnix, Unix;
702	704
703	705		procedure delayNanoseconds (howLong : LongWord);
704	706		var
705	707		sleeper, dummy : timespec;
706	708		begin
707	709		sleeper.tv_sec := 0 ;
708	710		sleeper.tv_nsec := howLong ;
709	711		fpnanosleep (@sleeper,@dummy) ;
710	712		end;
711	713		{ TIoDriver }
712	714		//*******************************************************************************
713	715		destructor TIoDriver.Destroy;
714	716		begin
715	717		inherited Destroy;
716	718		end;
717	719		//*******************************************************************************
718	720		function TIoDriver.MapIo: boolean;
719	721		begin
720	722		Result := True;
721	723		fd := fpopen('/dev/mem', O_RdWr or O_Sync); // Open the master /dev/memory device
722	724		if fd < 0 then
723	725		begin
724	726		Result := False; // unsuccessful memory mapping
725	727		end;
726	728		//
727	729		end;
728	730		//*******************************************************************************
729	731		procedure TIoDriver.UnmapIoRegisrty(FMap:TIoPort);
730	732		begin
731	733		if FMap.FGpio <> nil then
732	734		begin
733	735		fpMUnmap(FMap.FGpio,PAGE_SIZE);
734	736		FMap.FGpio := Nil;
735	737		end;
736	738		if FMap.FClk <> nil then
737	739		begin
738	740		fpMUnmap(FMap.FClk,PAGE_SIZE);
739	741		FMap.FClk := Nil;
740	742		end;
741	743		if FMap.FPwm <> nil then
742	744		begin
743	745		fpMUnmap(FMap.FPwm ,PAGE_SIZE);
744	746		FMap.FPwm := Nil;
745	747		end;
746	748		end;
747	749		//*******************************************************************************
748	750		function TIoDriver.CreatePort(PortGpio, PortClk, PortPwm: LongWord): TIoPort;
749	751		begin
750	752		Result := TIoPort.Create;// new io port, pascal calls new fpMap, where offst is page sized 4096 bytes!!!
751	753		Result.FGpio := FpMmap(Nil, PAGE_SIZE, PROT_READ or PROT_WRITE, MAP_SHARED, fd, PortGpio); // port config gpio memory
752	754		Result.FClk:= FpMmap(Nil, PAGE_SIZE, PROT_READ or PROT_WRITE, MAP_SHARED, fd, PortClk);; // port clk
753	755		Result.FPwm:= FpMmap(Nil, PAGE_SIZE, PROT_READ or PROT_WRITE, MAP_SHARED, fd, PortPwm);; // port pwm
754	756		end;
755	757		//*******************************************************************************
756	758		procedure TIoPort.SetPinMode(gpin, mode: byte);
757	759		var
758	760		fSel, shift, alt : byte;
759	761		gpiof, clkf, pwmf : ^LongWord;
760	762		begin
761	763		fSel := (gpin div 10)*4 ; //Select Gpfsel 0 to 5 register
762	764		shift := (gpin mod 10)*3 ; //0-9 pin shift
763	765		gpiof := Pointer(LongWord(Self.FGpio)+fSel);
764	766		if (mode = INPUT) then
765	767		gpiof^ := gpiof^ and ($FFFFFFFF - (7 shl shift)) //7 shl shift komplemens - Sets bits to zero = input
766	768		else if (mode = OUTPUT) then
767	769		begin
768	770		gpiof^ := gpiof^ and ($FFFFFFFF - (7 shl shift)) or (1 shl shift);
769	771		end
770	772		else if (mode = PWM_OUTPUT) then
771	773		begin
772	774		Case gpin of
773	775		12,13,40,41,45 : alt:= 4 ;
774	776		18,19 : alt:= 2 ;
775	777		else alt:= 0 ;
776	778		end;
777	779		If alt > 0 then
778	780		begin
779	781		gpiof^ := gpiof^ and ($FFFFFFFF - (7 shl shift)) or (alt shl shift);
780	782		clkf := Pointer(LongWord(Self.FClk)+PWMCLK_CNTL);
781	783		clkf^ := $5A000011 or (1 shl 5) ; //stop clock
782	784		delayNanoseconds(200);
783	785		clkf := Pointer(LongWord(Self.FClk)+PWMCLK_DIV);
784	786		clkf^ := $5A000000 or (32 shl 12) ; // set pwm clock div to 32 (19.2/3 = 600KHz)
785	787		clkf := Pointer(LongWord(Self.FClk)+PWMCLK_CNTL);
786	788		clkf^ := $5A000011 ; //start clock
787	789		Self.ClearBit(gpin);
788	790		pwmf := Pointer(LongWord(Self.FPwm)+PWM_CONTROL);
789	791		pwmf^ := 0 ; // Disable PWM
790	792		delayNanoseconds(200);
791	793		pwmf := Pointer(LongWord(Self.FPwm)+PWM0_RANGE);
792	794		pwmf^ := $400 ; //max: 1023
793	795		delayNanoseconds(200);
794	796		pwmf := Pointer(LongWord(Self.FPwm)+PWM1_RANGE);
795	797		pwmf^ := $400 ; //max: 1023
796	798		delayNanoseconds(200);
797	799		// Enable PWMs
798	800		pwmf := Pointer(LongWord(Self.FPwm)+PWM0_DATA);
799	801		pwmf^ := 0 ; //start value
800	802		pwmf := Pointer(LongWord(Self.FPwm)+PWM1_DATA);
801	803		pwmf^ := 0 ; //start value
802	804		pwmf := Pointer(LongWord(Self.FPwm)+PWM_CONTROL);
803	805		pwmf^ := PWM0_ENABLE or PWM1_ENABLE ;
804	806		end;
805	807		end;
806	808		end;
807	809		//*******************************************************************************
808	810		procedure TIoPort.SetBit(gpin : byte);
809	811		var
810	812		gpiof : ^LongWord;
811	813		begin
812	814		gpiof := Pointer(LongWord(Self.FGpio) + 28 + (gpin shr 5) shl 2);
813	815		gpiof^ := 1 shl gpin;
814	816		end;
815	817		//*******************************************************************************
816	818		procedure TIoPort.ClearBit(gpin : byte);
817	819		var
818	820		gpiof : ^LongWord;
819	821		begin
820	822		gpiof := Pointer(LongWord(Self.FGpio) + 40 + (gpin shr 5) shl 2);
821	823		gpiof^ := 1 shl gpin;
822	824		end;
823	825		//*******************************************************************************
824	826		function TIoPort.GetBit(gpin : byte):boolean;
825	827		var
826	828		gpiof : ^LongWord;
827	829		begin
828	830		gpiof := Pointer(LongWord(Self.FGpio) + 52 + (gpin shr 5) shl 2);
829	831		if (gpiof^ and (1 shl gpin)) = 0 then Result := False else Result := True;
830	832		end;
831	833		//*******************************************************************************
832	834		procedure TIoPort.SetPullMode(gpin, mode: byte);
833	835		var
834	836		pudf, pudclkf : ^LongWord;
835	837		begin
836	838		pudf := Pointer(LongWord(Self.FGpio) + 148 );
837	839		pudf^ := mode; //mode = 0, 1, 2 :Off, Down, Up
838	840		delayNanoseconds(200);
839	841		pudclkf := Pointer(LongWord(Self.FGpio) + 152 + (gpin shr 5) shl 2);
840	842		pudclkf^ := 1 shl gpin ;
841	843		delayNanoseconds(200);
842	844		pudf^ := 0 ;
843	845		pudclkf^ := 0 ;
844	846		end;
845	847		//*******************************************************************************
846	848		procedure TIoPort.PwmWrite(gpin : byte; value : Longword);
847	849		var
848	850		pwmf : ^LongWord;
849	851		port : byte;
850	852		begin
851	853		Case gpin of
852	854		12,18,40 : port:= PWM0_DATA ;
853	855		13,19,41,45 : port:= PWM1_DATA ;
854	856		else exit;
855	857		end;
856	858		pwmf := Pointer(LongWord(Self.FPwm) + port);
857	859		pwmf^ := value and $FFFFFBFF; // $400 complemens
858	860		end;
859	861		//*******************************************************************************
860	862		end.
861	863		```
862	864
863	865		Controlling Lazarus unit:(Project files[3](https://drive.google.com/folderview?id=0B-b-5ooIWPvGU043ZTZ0cUc2YkE&usp=sharing))
864	866
865	867		``` pascal
866	868		unit Unit1;
867	869
868	870		{Demo application for GPIO on Raspberry Pi}
869	871		{Inspired by the Python input/output demo application by Gareth Halfacree}
870	872		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
871	873
872	874		{$mode objfpc}{$H+}
873	875
874	876		interface
875	877
876	878		uses
877	879		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
878	880		ExtCtrls, Unix, PiGpio;
879	881
880	882		type
881	883
882	884		{ TForm1 }
883	885
884	886		TForm1 = class(TForm)
885	887		GPIO25In: TButton;
886	888		SpeedButton: TButton;
887	889		LogMemo: TMemo;
888	890		GPIO23switch: TToggleBox;
889	891		Timer1: TTimer;
890	892		GPIO18Pwm: TToggleBox;
891	893		Direction: TToggleBox;
892	894		procedure DirectionChange(Sender: TObject);
893	895		procedure GPIO18PwmChange(Sender: TObject);
894	896		procedure GPIO25InClick(Sender: TObject);
895	897		procedure FormActivate(Sender: TObject);
896	898		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
897	899		procedure GPIO23switchChange(Sender: TObject);
898	900		procedure SpeedButtonClick(Sender: TObject);
899	901		procedure Timer1Timer(Sender: TObject);
900	902		private
901	903		{ private declarations }
902	904		public
903	905		{ public declarations }
904	906		end;
905	907
906	908		const
907	909		INPUT = 0;
908	910		OUTPUT = 1;
909	911		PWM_OUTPUT = 2;
910	912		LOW = False;
911	913		HIGH = True;
912	914		PUD_OFF = 0;
913	915		PUD_DOWN = 1;
914	916		PUD_UP = 2;
915	917		// Convert Raspberry Pi P1 pins (Px) to GPIO port
916	918		P3 = 0;
917	919		P5 = 1;
918	920		P7 = 4;
919	921		P8 = 14;
920	922		P10 = 15;
921	923		P11 = 17;
922	924		P12 = 18;
923	925		P13 = 21;
924	926		P15 = 22;
925	927		P16 = 23;
926	928		P18 = 24;
927	929		P19 = 10;
928	930		P21 = 9;
929	931		P22 = 25;
930	932		P23 = 11;
931	933		P24 = 8;
932	934		P26 = 7;
933	935
934	936		var
935	937		Form1: TForm1;
936	938		GPIO_Driver: TIoDriver;
937	939		GpF: TIoPort;
938	940		PWM :Boolean;
939	941		i, d : integer;
940	942		Pin,Pout,Ppwm : byte;
941	943
942	944		implementation
943	945
944	946		{$R *.lfm}
945	947
946	948		{ TForm1 }
947	949
948	950		procedure TForm1.FormActivate(Sender: TObject);
949	951		begin
950	952		if not GPIO_Driver.MapIo then
951	953		begin
952	954		LogMemo.Lines.Add('Error mapping gpio registry');
953	955		end
954	956		else
955	957		begin
956	958		GpF := GpIo_Driver.CreatePort(GPIO_BASE, CLOCK_BASE, GPIO_PWM);
957	959		end ;
958	960		Timer1.Enabled:= True;
959	961		Timer1.Interval:= 25; //25 ms controll interval
960	962		Pin := P22;
961	963		Pout := P16;
962	964		Ppwm := P12;
963	965		i:=1;
964	966		GpF.SetPinMode(Pout,OUTPUT);
965	967		GpF.SetPinMode(Pin,INPUT);
966	968		GpF.SetPullMode(Pin,PUD_Up); // Input PullUp High level
967	969		end;
968	970
969	971		procedure TForm1.GPIO25InClick(Sender: TObject);
970	972		begin
971	973		If GpF.GetBit(Pin) then LogMemo.Lines.Add('In: '+IntToStr(1))
972	974		else LogMemo.Lines.Add('In: '+IntToStr(0));
973	975		end;
974	976
975	977		procedure TForm1.GPIO18PwmChange(Sender: TObject);
976	978		begin
977	979		if GPIO18Pwm.Checked then
978	980		begin
979	981		GpF.SetPinMode(Ppwm,PWM_OUTPUT);
980	982		PWM := True; //PWM on
981	983		end
982	984		else
983	985		begin
984	986		GpF.SetPinMode(Ppwm,INPUT);
985	987		PWM := False; //PWM off
986	988		end;
987	989		end;
988	990
989	991		procedure TForm1.DirectionChange(Sender: TObject);
990	992		begin
991	993		if Direction.Checked then d:=10 else d:=-10;
992	994		end;
993	995
994	996
995	997		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
996	998		begin
997	999		GpF.SetPinMode(Ppwm,INPUT);
998	1000		GpF.ClearBit(Pout);
999	1001		GpIo_Driver.UnmapIoRegisrty(GpF);
1000	1002		end;
1001	1003
1002	1004		procedure TForm1.GPIO23switchChange(Sender: TObject);
1003	1005
1004	1006		Begin
1005	1007		Timer1.Enabled := False;
1006	1008		if GPIO23switch.Checked then
1007	1009		begin
1008	1010		GpF.SetBit(Pout); //Turn LED on
1009	1011		end
1010	1012		else
1011	1013		begin
1012	1014		GpF.ClearBit(Pout); //Turn LED off
1013	1015		end;
1014	1016		Timer1.Enabled := True;
1015	1017		end;
1016	1018
1017	1019		procedure TForm1.SpeedButtonClick(Sender: TObject);
1018	1020		var
1019	1021		i,p,k,v: longint;
1020	1022		ido:TDateTime;
1021	1023		begin
1022	1024		ido:= Time;
1023	1025		k:= TimeStampToMSecs(DateTimeToTimeStamp(ido));
1024	1026		LogMemo.Lines.Add('Start: '+TimeToStr(ido));
1025	1027		p:=10000000 ;
1026	1028		For i:=1 to p do Begin
1027	1029		GpF.SetBit(P16);
1028	1030		GpF.ClearBit(P16);
1029	1031		end;
1030	1032		ido:= Time;
1031	1033		v:= TimeStampToMSecs(DateTimeToTimeStamp(ido));
1032	1034		LogMemo.Lines.Add('Stop: '+TimeToStr(ido)+' Frequency: '+
1033	1035		IntToStr(p div (v-k))+' kHz');
1034	1036		end;
1035	1037
1036	1038		procedure TForm1.Timer1Timer(Sender: TObject);
1037	1039		begin
1038	1040		If PWM then Begin
1039	1041		If (d > 0) and (i+d < 1024) then begin
1040	1042		i:=i+d;
1041	1043		GpF.PwmWrite(Ppwm,i);
1042	1044		end ;
1043	1045		If (d < 0) and (i+d > -1) then begin
1044	1046		i:=i+d;
1045	1047		GpF.PwmWrite(Ppwm,i);
1046	1048		end;
1047	1049		end;
1048	1050		end;
1049	1051
1050	1052
1051	1053		end.
1052	1054		```
1053	1055
1054	1056		### PXL (Platform eXtended Library) for low level native access to GPIO, I²C, SPI, PWM, UART, V4L2, displays and sensors
1055	1057
1056	1058		- Easy and fast access to GPIO, I²C, SPI, PWM, UART and high precision CPU timer.
1057	1059		- V4L2 video/image capture using onboard and USB cameras. Serial cameras such as VC0706 and LSY201.
1058	1060		- OpenGL ES hardware rendering with and without X server. Software rendering.
1059	1061		- I²C and SPI displays such as SSD1306, SSD1351, PCB8544 (Nokia), HX8357 and ILI9340.
1060	1062		- Character LCDs with direct pin wiring.
1061	1063		- Support for Software SPI and UART (bit-banging).
1062	1064		- Support for SC16IS7x0 (UART controller connected via I²C or SPI), including extra GPIO pins.
1063	1065		- Support for sensors such as BMP180, DHT22, L3GD20, LSM303 and SHT10.
1064	1066		- Other features like networking, math, image transformation, effects, drawing primitives...
1065	1067
1066	1068		More info and download of [PXL library](http://asphyre.net/products/pxl).
1067	1069
1068	1070		The PinDrive property is not implemented in the latest download from Asphyre so I am posting the code for my implementation in case anyone needs it. I found that the definition for TPinDrive is incorrect for the BCM2837 chip so I added some code to change it. This could be accomplished more easily by changing the definition but that file could conceivably be used for multiple chips (and I don't control the code) so I made all changes in the code to set the drive mode.
1069	1071
1070	1072		``` pascal
1071	1073
1072	1074		procedure TFastGPIO.SetPinDrive(const Pin: TPinIdentifier; const Value: TPinDrive);
1073	1075		const
1074	1076		GPPUDadr = $94;
1075	1077		GPPclkadr = $98;
1076	1078		type
1077	1079		TBCM28PinDrive = (drvNone, drvPullDown, drvPullUp);
1078	1080		var
1079	1081		dValue: TBCM28PinDrive;
1080	1082		PinBCM: TPinIdentifier;
1081	1083		GPPUD, GPPclk: Pointer;
1082	1084		begin
1083	1085		case Value of
1084	1086		TPinDrive.PullUp: dValue := TBCM28PinDrive.drvPullDown;
1085	1087		TPinDrive.PullDown: dValue := TBCM28PinDrive.drvPullUp;
1086	1088		else
1087	1089		dValue := TBCM28PinDrive.drvNone;
1088	1090
1089	1091		PinBCM := ProcessPinNumber(Pin);
1090	1092
1091	1093		GPPUD := GetOffsetPointer(GPPUDadr);
1092	1094		WriteMemSafe(GPPUD, Cardinal(dValue));
1093	1095		FSystemCore.MicroDelay(1);
1094	1096
1095	1097		GPPclk := GetOffsetPointer(GPPclkadr + (Cardinal(PinBCM) div 32) * 4);
1096	1098		WriteMemSafe(GPPclk, 1 shl (PinBCM mod 32));
1097	1099		FSystemCore.MicroDelay(1);
1098	1100
1099	1101		WriteMemSafe(GPPUD, 0);
1100	1102		WriteMemSafe(GPPclk, 0);
1101	1103		end;
1102	1104		```
1103	1105
1104	1106		## References
1105	1107
1106	1108		- Eben Upton and Gareth Halfacree. Raspberry Pi User Guide. John Wiley and Sons, Chichester 2012, ISBN 111846446X
1107	1109		- B. J. Rao (2013) The Raspberry Pi, Pi Vision and Lazarus/FPC. [Blaise Pascal Magazine](http://www.blaisepascal.eu). 29: 14-21.
1108	1110
1109	1111		## External and Other Links
1110	1112
1111	1113		- If you want to install the latest stable release of fpc and, additional and isolated, the trunk fpc compiler: you can read the following guide.
1112	1114
1113	1115		It was written using gentoo but this guide will be useful with any distro: [[Install fpc on Raspberry with Gentoo]] (very out of date)
1114	1116
1115	1117		- [Raspberry Pi Foundation](http://www.raspberrypi.org)
1116	1118		- [Raspberry Pi Spy: Raspberry Pi tutorials, scripts, help and downloads](http://www.raspberrypi-spy.co.uk)
1117	1119		- [Lazarus wrapper unit for Gordon Henderson's wiringPi C library](http://www.lazarus.freepascal.org/index.php/topic,17404.0.html)
1118	1120		- [Another wiringPi wrapper with waitForInterrupt() and wiringPiISR()](https://github.com/laz2wiringpi/laz2wiringpi)
1119	1121		- [Yet another wiringPi wrapper with waitForInterrupt(), wiringPiISR(), i2c, spi and serial](https://forum.lazarus.freepascal.org/index.php/topic,17404.msg405237.html#msg405237)
1120	1122		- [Pin layout of the wiringPi library](https://projects.drogon.net/raspberry-pi/wiringpi/pins/)
1121	1123		- [wiringPi fork updated for latest hardware](https://github.com/WiringPi/WiringPi)
1122	1124		- [Additional information on Lazarus and Raspberry Pi at eLinux.org](http://www.elinux.org/Lazarus_on_RPi)
1123	1125		- [Getting Started with Pascal on the Pi](http://www.pp4s.co.uk/main/gs-pi-intro.html) (noted dead link in late 2023)
1124	1126		- [Getting Started with Led, Switch and DC motor on Pi](http://www.pp4s.co.uk/main/gs-pi-gpio-intro.html) (noted dead link in late 2023)
1125	1127		- [lazi2cdev - General i2c with drivers for ADS1015 ADC, MCP23017 IO, MCP4725 DAC, PCA9685 PWM and HD44780 LCD](https://github.com/laz2wiringpi/lazI2cdev)
1126	1128		- [Lazberry Pi: Comprehensive information on Lazarus on the Raspberry Pi computer](http://superbitysoft.co.uk/lazberrypi/). (noted dead link in late 2023)
1127	1129		- Stefan Fischer's [rpi_hal library](https://github.com/rudiratlos/rpi-hal) and [rpi_hal discussion topic](http://www.lazarus.freepascal.org/index.php/topic,20991.0.html) on Lazarus forum.
1128	1130		- [Improved Lazarus Unit for fast access to GPIO](http://www.meltonisl.com/pigpio.pas).
1129	1131		- [PXL - Platform eXtended Library](http://asphyre.net/products/pxl).
1130	1132		- [RPIIO - Raspberry Pi GPIO and I2C library](https://github.com/zipplet/rpiio).
1131	1133
1132	1134		---
1133	1135		From the Free Pascal wiki, page "Lazarus on Raspberry Pi", as it stood on 2023-12-31 after a change by Dbannon, 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