Lazarus on Raspberry Pi: what changed

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

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