Lazarus on Raspberry Pi/zh CN: what changed

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

Old	New		Line
1	1		树莓派上的Lazarus
2	2
3	3		![Lazarus on Raspbian Wheezy](/wiki-images/e/ef/Lazarus_on_Raspberry_Pi_Raspian_Wheezy_version_2012-10-28.png) (Raspberry Pi only)
4	4
5	5		Raspberry Pi(数莓派)是一个信用卡大小的单板计算机。它由英国的Raspberry Pi基金为了激励在学校的计算机基础科学教学发起的。Raspberry Pis也可以用来作为媒体服务器以及其他用途机器人、控制工程等多种用途。 Raspberry Pi基金会推荐[[Raspbian]] Wheezy作为标准的操作系统。大家可以选择在RPI运行RISC OS、各种Linux发行版以及[[Android]]等操作系统。 Lazarus可以在原生的Raspbian操作系统下运行。
6	6
7	7		## 安装与编译器Lazarus
8	8
9	9		### 在 Raspbian上简单安装
10	10
11	11		#### Raspberry Pi 1
12	12
13	13		在 Raspbian OS上，安装Lazarus与 Free Pascal很容易。打开命令行窗口输入下面的指令：
14	14
15	15		``` bash
16	16		sudo apt-get update
17	17		sudo apt-get upgrade
18	18		sudo apt-get install fpc
19	19		sudo apt-get install lazarus
20	20		```
21	21
22	22		这里安装的是为Raspberry Pi预编译的稳定版FPC与Lazarus 。当然，需要有网络连接。安装过程大概需要30分钟，这个过程是自动完成等的。安装完成以后，你就可以从LXDE的开始菜单的“Programming”启动Lazarus了。
23	23
24	24		![](/wiki-images/0/02/Install_Lazarus_Rasbian_Part1_en.png)
25	25
26	26		安装步骤 1
27	27
28	28		![](/wiki-images/4/4a/Install_Lazarus_Rasbian_Part2_en.png)
29	29
30	30		安装步骤 2
31	31
32	32		![](/wiki-images/5/53/Install_Lazarus_Rasbian_Part3_en.png)
33	33
34	34		安装步骤 3
35	35
36	36		![](/wiki-images/2/24/Install_Lazarus_Rasbian_Part4_en.png)
37	37
38	38		安装步骤 4
39	39
40	40		如果你需要一个新的版本，或者抱怨Lazarus 的问题， [点击](http://www.raspberrypi.org/forums/viewtopic.php?f=34&t=88145).
41	41
42	42		#### Raspberry Pi 2
43	43
44	44		自2015六月起，普通的“out of the box”安装方法也适用于安装树莓派2的B型。但是安装时获得的版本是相当旧的。想要获得新版FPC和Lazarus请看链接 [相关文章](http://www.tweaking4all.com/hardware/raspberry-pi/install-lazarus-pascal-on-raspberry-pi-2/).
45	45
46	46		![](/wiki-images/c/cc/Lazarus_0_9_30_4_on_RPi_2.png)
47	47
48	48		Lazarus "out of the box" on Raspberry Pi 2
49	49
50	50		### 从Windows 对Raspberry Pi的交叉编译
51	51
52	52		1\. 使用 fpcup
53	53
54	54		使用fpcup是实现交叉编译的一种方法，输入下面的指令： [[fpcup\|fpcup#Linux_ARM_cross_compiler]]
55	55
56	56		2\. 使用脚本
57	57
58	58		可以使用手动批处理文件，按照以下步骤。
59	59
60	60		2.1 先决条件
61	61
62		-	~~`FPC 2.7.1或更高的安装源代码`\~~
63		-	`下载并安装Windows版本的Linaro binutils for linux gnueabihf到%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)
	62	+	```text
	63	+	FPC 2.7.1或更高的安装源代码
	64	+	下载并安装Windows版本的Linaro binutils for linux gnueabihf到%FPCPATH%/bin/win32-armhf-linux [https://launchpad.net/linaro-toolchain-binaries/trunk/2013.10/+download/gcc-linaro-arm-linux-gnueabihf-4.8-2013.10_win32.zip]
	65	+	```
64	66
65	67		2.2 创建脚本（需要匹配实际路径）
66	68
67	69		``` bat
68	70		set PATH=C:\pp\bin\i386-win32;%PATH%;
69	71		set FPCMAKEPATH=C:/pp
70	72		set FPCPATH=C:/pp
71	73		set OUTPATH=C:/pp271
72	74		%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
73	75
74	76		%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
75	77		if errorlevel 1 goto quit
76	78		%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%
77	79
78	80		:quit
79	81		pause
80	82		```
81	83
82	84		使用生成的ppcrossarm.exe和 ARM RTL，你可以创建跨平台的Lazarus工程，生成Raspberry Pi和其他armhf设备的应用程序。注意，这里不包括所有Window 库。
83	85
84	86		### 编译源代码
85	87
86	88		如果你想要从Subversion编译Lazarus源代码。请看 \[<http://www.michellcomputing.co.uk/blog/?p=72>: Michell Computing: Lazarus on the Raspberry Pi\]
87	89
88	90		![](/wiki-images/8/8d/Start_Menu_with_Lazarus_en.png)
89	91
90	92		How to start Lazarus in Raspbian Wheezy
91	93
92	94		![](/wiki-images/8/87/Lazarus_on_Raspberry_Pi.jpg)
93	95
94	96		Lazarus on Raspberry Pi
95	97
96	98		![](/wiki-images/c/c7/Rpi_gpio_pins.png)
97	99
98	100		Numbering of GPIO pins
99	101
100	102		用Gentoo（及其他版本）在Raspberry上编译源码
101	103
102	104		- Gentoo是一个基于Linux的自由操作系统
103	105
104	106		------------------------------------------------------------------------
105	107
106	108		如果你想安装最新版的FPC及附件，或者是集成FPC编译器：请阅读下面的指南这是关于Gentoo的例子，本指南适用其他版本：[[Install fpc on Raspberry with Gentoo]]
107	109
108	110		## 访问外部硬件
109	111
110	112		![](/wiki-images/f/f2/Rpi_pinout_all_50.png)
111	113
112	114		Raspberry Pi的发展的目标之一是方便轻松地访问外部设备，如传感器和控制器。Lazarus有五种方法来访问I/O设备：
113	115
114	116		1. [[Lazarus on Raspberry Pi\|原生代码直接访问]]，使用[[BaseUnix]]单元
115	117		2. 通过 [[Lazarus on Raspberry Pi\|封装外壳调用]]
116	118		3. 通过 [[Lazarus on Raspberry Pi\|wiringPi 库]].
117	119		4. 使用单元 [[Lazarus on Raspberry Pi\|rpi_hal]].
118	120		5. 使用单元 [[Lazarus on Raspberry Pi\|PiGpio]].
119	121		6. 通过 [PascalIO](https://github.com/SAmeis/pascalio) 库访问.
120	122
121	123		### 1. 原生代码直接访问
122	124
123	125		![对Raspberry Pi的GPIO端口访问的简单测试程序\\|thumb\\|300px\\|right](/wiki-images/d/d2/Testprogram_for_GPIO_on_RPI_annotated.png) ![程序访问GPIO的测试电路\\|thumb\\|300px\\|right](/wiki-images/7/7c/Rpi_testcircuit_1d.png) ![演示实现电路\\|thumb\\|300px\\|right](/wiki-images/7/7e/Rpi_testcircuit_1p_annotaded.png)
124	126
125	127		这种访问外部硬件的方法，不需要额外的库。唯一的要求是baseunix库，这是Free Pascal的RTL部分。
126	128
127	129		#### 通过GPIO端口控制开关
128	130
129	131		下面将演示一个简单程序。控制GPIO的17号引脚的电压，可以用来控制LED、晶体管或继电器。程序包含GPIO17ToggleBox的实例[[doc:lcl/stdctrls/ttogglebox.html\|ToggleBox]]和日志返回LogMemo类的实例[[doc:lcl/stdctrls/tmemo.html\|TMemo]]。
130	132
131	133		例如，一个LED的阳极连接到引脚11上（BCM2835 SoC对应的GPIO为17）和LED的阴极通过一个68欧姆的电阻连接引脚6（GND）。随后，LED会随着应用程序的toggle box切换点亮和熄灭。
132	134
133	135		该代码需要root权限运行,即从root帐号（不推荐）运行或通过“su'。
134	136
135	137		控制单元:
136	138
137	139		``` pascal
138	140		unit Unit1;
139	141
140	142		{Demo application for GPIO on Raspberry Pi}
141	143		{Inspired by the Python input/output demo application by Gareth Halfacree}
142	144		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
143	145
144	146		{$mode objfpc}{$H+}
145	147
146	148		interface
147	149
148	150		uses
149	151		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
150	152		Unix, BaseUnix;
151	153
152	154		type
153	155
154	156		{ TForm1 }
155	157
156	158		TForm1 = class(TForm)
157	159		LogMemo: TMemo;
158	160		GPIO17ToggleBox: TToggleBox;
159	161		procedure FormActivate(Sender: TObject);
160	162		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
161	163		procedure GPIO17ToggleBoxChange(Sender: TObject);
162	164		private
163	165		{ private declarations }
164	166		public
165	167		{ public declarations }
166	168		end;
167	169
168	170		const
169	171		PIN_17: PChar = '17';
170	172		PIN_ON: PChar = '1';
171	173		PIN_OFF: PChar = '0';
172	174		OUT_DIRECTION: PChar = 'out';
173	175
174	176		var
175	177		Form1: TForm1;
176	178		gReturnCode: longint; {stores the result of the IO operation}
177	179
178	180		implementation
179	181
180	182		{$R *.lfm}
181	183
182	184		{ TForm1 }
183	185
184	186		procedure TForm1.FormActivate(Sender: TObject);
185	187		var
186	188		fileDesc: integer;
187	189		begin
188	190		{ Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
189	191		try
190	192		fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
191	193		gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
192	194		LogMemo.Lines.Add(IntToStr(gReturnCode));
193	195		finally
194	196		gReturnCode := fpclose(fileDesc);
195	197		LogMemo.Lines.Add(IntToStr(gReturnCode));
196	198		end;
197	199		{ Set SoC pin 17 as output: }
198	200		try
199	201		fileDesc := fpopen('/sys/class/gpio/gpio17/direction', O_WrOnly);
200	202		gReturnCode := fpwrite(fileDesc, OUT_DIRECTION[0], 3);
201	203		LogMemo.Lines.Add(IntToStr(gReturnCode));
202	204		finally
203	205		gReturnCode := fpclose(fileDesc);
204	206		LogMemo.Lines.Add(IntToStr(gReturnCode));
205	207		end;
206	208		end;
207	209
208	210		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
209	211		var
210	212		fileDesc: integer;
211	213		begin
212	214		{ Free SoC pin 17: }
213	215		try
214	216		fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
215	217		gReturnCode := fpwrite(fileDesc, PIN_17[0], 2);
216	218		LogMemo.Lines.Add(IntToStr(gReturnCode));
217	219		finally
218	220		gReturnCode := fpclose(fileDesc);
219	221		LogMemo.Lines.Add(IntToStr(gReturnCode));
220	222		end;
221	223		end;
222	224
223	225		procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
224	226		var
225	227		fileDesc: integer;
226	228		begin
227	229		if GPIO17ToggleBox.Checked then
228	230		begin
229	231		{ Swith SoC pin 17 on: }
230	232		try
231	233		fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
232	234		gReturnCode := fpwrite(fileDesc, PIN_ON[0], 1);
233	235		LogMemo.Lines.Add(IntToStr(gReturnCode));
234	236		finally
235	237		gReturnCode := fpclose(fileDesc);
236	238		LogMemo.Lines.Add(IntToStr(gReturnCode));
237	239		end;
238	240		end
239	241		else
240	242		begin
241	243		{ Switch SoC pin 17 off: }
242	244		try
243	245		fileDesc := fpopen('/sys/class/gpio/gpio17/value', O_WrOnly);
244	246		gReturnCode := fpwrite(fileDesc, PIN_OFF[0], 1);
245	247		LogMemo.Lines.Add(IntToStr(gReturnCode));
246	248		finally
247	249		gReturnCode := fpclose(fileDesc);
248	250		LogMemo.Lines.Add(IntToStr(gReturnCode));
249	251		end;
250	252		end;
251	253		end;
252	254
253	255		end.
254	256		```
255	257
256	258		Main program:
257	259
258	260		``` pascal
259	261		program io_test;
260	262
261	263		{$mode objfpc}{$H+}
262	264
263	265		uses
264	266		{$IFDEF UNIX}{$IFDEF UseCThreads}
265	267		cthreads,
266	268		{$ENDIF}{$ENDIF}
267	269		Interfaces, // this includes the LCL widgetset
268	270		Forms, Unit1
269	271		{ you can add units after this };
270	272
271	273		{$R *.res}
272	274
273	275		begin
274	276		Application.Initialize;
275	277		Application.CreateForm(TForm1, Form1);
276	278		Application.Run;
277	279		end.
278	280		```
279	281
280	282		#### 读取引脚的状态
281	283
282	284		![读取一个GPIO引脚状态的演示程序\\|thumb\\|300px\\|right](/wiki-images/7/73/2013-04-28-193243_1280x1024_scrot.png) ![程序访问GPIO的测试电路\\|thumb\\|300px\\|right](/wiki-images/f/f4/Rpi_testcircuit_2d.png) ![实际电路\\|thumb\\|300px\\|right](/wiki-images/2/2f/Rpi_testcircuit_2p_annotaded.png)
283	285
284	286		当然也可以从GPIO端口读取一个开关的状态。
285	287
286	288		下面的简单例子非常类似于前一个例子。使用GPIO的18号引脚，控制二进制设备如开关输入，晶体管或继电器。这个程序包含一个名称为[[doc:lcl/stdctrls/tcheckbox.html\|CheckBox]]的GPIO18CheckBox 与LogMemo的实例[[doc:lcl/stdctrls/tmemo.html\|TMemo]]日志返回代码。
287	289
288	290		在实例中，第12引脚的一端连接一个按钮，按钮的一端（对应的GPIO引脚18的BCM2835 SoC）通过一个10欧姆的上拉电阻和引脚1连接（+3.3 V，看接线图）。按钮的另一端连接6号引脚（GND）。按钮的开关状态对应和程序中复选框的打开或关闭状态对应。
289	291
290	292		注意，当按钮释放时18脚的电位为高（由通过上拉电阻连接到引脚1），当按钮压下时电压为低（因为在这种情况下，引脚18是通过开关连接到GND）。因此，按钮按下时GPIO引脚信号为0，当释放时信号为1。
291	293
292	294		这个程序同样需要root权限
293	295
294	296		控制单元:
295	297
296	298		``` pascal
297	299		unit Unit1;
298	300
299	301		{Demo application for GPIO on Raspberry Pi}
300	302		{Inspired by the Python input/output demo application by Gareth Halfacree}
301	303		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
302	304
303	305		{This application reads the status of a push-button}
304	306
305	307		{$mode objfpc}{$H+}
306	308
307	309		interface
308	310
309	311		uses
310	312		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls,
311	313		ButtonPanel, Unix, BaseUnix;
312	314
313	315		type
314	316
315	317		{ TForm1 }
316	318
317	319		TForm1 = class(TForm)
318	320		ApplicationProperties1: TApplicationProperties;
319	321		GPIO18CheckBox: TCheckBox;
320	322		LogMemo: TMemo;
321	323		procedure ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
322	324		procedure FormActivate(Sender: TObject);
323	325		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
324	326		private
325	327		{ private declarations }
326	328		public
327	329		{ public declarations }
328	330		end;
329	331
330	332		const
331	333		PIN_18: PChar = '18';
332	334		IN_DIRECTION: PChar = 'in';
333	335
334	336		var
335	337		Form1: TForm1;
336	338		gReturnCode: longint; {stores the result of the IO operation}
337	339
338	340		implementation
339	341
340	342		{$R *.lfm}
341	343
342	344		{ TForm1 }
343	345
344	346		procedure TForm1.FormActivate(Sender: TObject);
345	347		var
346	348		fileDesc: integer;
347	349		begin
348	350		{ Prepare SoC pin 18 (pin 12 on GPIO port) for access: }
349	351		try
350	352		fileDesc := fpopen('/sys/class/gpio/export', O_WrOnly);
351	353		gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
352	354		LogMemo.Lines.Add(IntToStr(gReturnCode));
353	355		finally
354	356		gReturnCode := fpclose(fileDesc);
355	357		LogMemo.Lines.Add(IntToStr(gReturnCode));
356	358		end;
357	359		{ Set SoC pin 18 as input: }
358	360		try
359	361		fileDesc := fpopen('/sys/class/gpio/gpio18/direction', O_WrOnly);
360	362		gReturnCode := fpwrite(fileDesc, IN_DIRECTION[0], 2);
361	363		LogMemo.Lines.Add(IntToStr(gReturnCode));
362	364		finally
363	365		gReturnCode := fpclose(fileDesc);
364	366		LogMemo.Lines.Add(IntToStr(gReturnCode));
365	367		end;
366	368		end;
367	369
368	370		procedure TForm1.ApplicationProperties1Idle(Sender: TObject; var Done: Boolean);
369	371		var
370	372		fileDesc: integer;
371	373		buttonStatus: string[1] = '1';
372	374		begin
373	375		try
374	376		{ Open SoC pin 18 (pin 12 on GPIO port) in read-only mode: }
375	377		fileDesc := fpopen('/sys/class/gpio/gpio18/value', O_RdOnly);
376	378		if fileDesc > 0 then
377	379		begin
378	380		{ Read status of this pin (0: button pressed, 1: button released): }
379	381		gReturnCode := fpread(fileDesc, buttonStatus[1], 1);
380	382		LogMemo.Lines.Add(IntToStr(gReturnCode) + ': ' + buttonStatus);
381	383		LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
382	384		if buttonStatus = '0' then
383	385		GPIO18CheckBox.Checked := true
384	386		else
385	387		GPIO18CheckBox.Checked := false;
386	388		end;
387	389		finally
388	390		{ Close SoC pin 18 (pin 12 on GPIO port) }
389	391		gReturnCode := fpclose(fileDesc);
390	392		LogMemo.Lines.Add(IntToStr(gReturnCode));
391	393		LogMemo.SelStart := Length(LogMemo.Lines.Text) - 1;
392	394		end;
393	395		end;
394	396
395	397		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
396	398		var
397	399		fileDesc: integer;
398	400		begin
399	401		{ Free SoC pin 18: }
400	402		try
401	403		fileDesc := fpopen('/sys/class/gpio/unexport', O_WrOnly);
402	404		gReturnCode := fpwrite(fileDesc, PIN_18[0], 2);
403	405		LogMemo.Lines.Add(IntToStr(gReturnCode));
404	406		finally
405	407		gReturnCode := fpclose(fileDesc);
406	408		LogMemo.Lines.Add(IntToStr(gReturnCode));
407	409		end;
408	410		end;
409	411
410	412		end.
411	413		```
412	414
413	415		上面的例子主程序是相同的，。
414	416
415	417		### 2. 通过封装的外壳访问硬件
416	418
417	419		访问硬件的另一种方法是通过封装终端命令。这是通过使用[[Executing External Programs\|fpsystem]]功能。这种方法可以访问baseunix单元不支持的功能。下面的代码实现了一个具有相同功能的程序，该程序是从上面的第一个清单所产生的。
418	420
419	421		控制单元:
420	422
421	423		``` pascal
422	424		unit Unit1;
423	425
424	426		{Demo application for GPIO on Raspberry Pi}
425	427		{Inspired by the Python input/output demo application by Gareth Halfacree}
426	428		{written for the Raspberry Pi User Guide, ISBN 978-1-118-46446-5}
427	429
428	430		{$mode objfpc}{$H+}
429	431
430	432		interface
431	433
432	434		uses
433	435		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls, Unix;
434	436
435	437		type
436	438
437	439		{ TForm1 }
438	440
439	441		TForm1 = class(TForm)
440	442		LogMemo: TMemo;
441	443		GPIO17ToggleBox: TToggleBox;
442	444		procedure FormActivate(Sender: TObject);
443	445		procedure FormClose(Sender: TObject; var CloseAction: TCloseAction);
444	446		procedure GPIO17ToggleBoxChange(Sender: TObject);
445	447		private
446	448		{ private declarations }
447	449		public
448	450		{ public declarations }
449	451		end;
450	452
451	453		var
452	454		Form1: TForm1;
453	455		gReturnCode: longint; {stores the result of the IO operation}
454	456
455	457		implementation
456	458
457	459		{$R *.lfm}
458	460
459	461		{ TForm1 }
460	462
461	463		procedure TForm1.FormActivate(Sender: TObject);
462	464		begin
463	465		{ Prepare SoC pin 17 (pin 11 on GPIO port) for access: }
464	466		gReturnCode := fpsystem('echo "17" > /sys/class/gpio/export');
465	467		LogMemo.Lines.Add(IntToStr(gReturnCode));
466	468		{ Set SoC pin 17 as output: }
467	469		gReturnCode := fpsystem('echo "out" > /sys/class/gpio/gpio17/direction');
468	470		LogMemo.Lines.Add(IntToStr(gReturnCode));
469	471		end;
470	472
471	473		procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
472	474		begin
473	475		{ Free SoC pin 17: }
474	476		gReturnCode := fpsystem('echo "17" > /sys/class/gpio/unexport');
475	477		LogMemo.Lines.Add(IntToStr(gReturnCode));
476	478		end;
477	479
478	480		procedure TForm1.GPIO17ToggleBoxChange(Sender: TObject);
479	481		begin
480	482		if GPIO17ToggleBox.Checked then
481	483		begin
482	484		{ Swith SoC pin 17 on: }
483	485		gReturnCode := fpsystem('echo "1" > /sys/class/gpio/gpio17/value');
484	486		LogMemo.Lines.Add(IntToStr(gReturnCode));
485	487		end
486	488		else
487	489		begin
488	490		{ Switch SoC pin 17 off: }
489	491		gReturnCode := fpsystem('echo "0" > /sys/class/gpio/gpio17/value');
490	492		LogMemo.Lines.Add(IntToStr(gReturnCode));
491	493		end;
492	494		end;
493	495
494	496		end.
495	497		```
496	498
497	499		主程序与上面的例子相同。这个程序必须用根权限执行。
498	500
499	501		### 3. wiringPi方法与函数
500	502
501	503		Alex Schaller封装的Gordon Henderson的Arduino兼容wiringpi库,提供了一种类似Arduino电路板的编码方案。
502	504
503	505		Function wiringPiSetup:longint: 使用wiringpi引脚编号方案初始化wiringpi系统
504	506
505	507		Procedure wiringPiGpioMode(mode:longint): 用Broadcom的GPIO引脚编号方案wiringpi初始化系统。
506	508
507	509		Procedure pullUpDnControl(pin:longint; pud:longint): 控制内部GPIO引脚上拉/下拉电阻。
508	510
509	511		Procedure pinMode(pin:longint; mode:longint): 设置一个PIN的模式：输入、输出或pwm_output。
510	512
511	513		Procedure digitalWrite(pin:longint; value:longint): 设置一个输出位。
512	514
513	515		Procedure pwmWrite(pin:longint; value:longint): 设置一个输出PWM（脉宽调制）值，0到1024之间。
514	516
515	517		Function digitalRead(pin:longint):longint: 读取一个给定引脚的值，返回1或0。
516	518
517	519		Procedure delay(howLong:dword): 等待多少毫秒。
518	520
519	521		Procedure delayMicroseconds(howLong:dword): 等待多少微秒。
520	522
521	523		Function millis:dword: 返回程序调用wiringpisetup函数花费的毫秒数。
522	524
523	525		### 4. rpi_hal-hardware抽象库 (GPIO, I2C and SPI 函数与方法)
524	526
525	527		这个单元大约1700行代码，由Stefan Fischer提供，提供程序和函数访问RPI硬件I2C，SPI和GPIO：
526	528
527	529		下面是函数和方法的摘录：
528	530
529	531		procedure gpio_set_pin (pin:longword;highlevel:boolean); { 设置 RPi GPIO 引脚速率为高或低; 速率 @ 700MHz -\> 0.65MHz }
530	532
531	533		function gpio_get_PIN (pin:longword):boolean; { 获取 RPi GPIO 引脚等级,当Pin为'1'时返回True,为'0'时返回false; 速率 @ 700MHz -\> 1.17MHz }
532	534
533	535		procedure gpio_set_input (pin:longword); { 设置 RPi GPIO 引脚为直接输入}
534	536
535	537		procedure gpio_set_output(pin:longword); { 设置 RPi GPIO 引脚为直接输出 }
536	538
537	539		procedure gpio_set_alt (pin,altfunc:longword); { 设置 RPi GPIO 引脚为备用功能 0..5 }
538	540
539	541		procedure gpio_set_gppud (mask:longword); { 设置RPI GPIO拉上/下登记（gppud）}
540	542
541	543		...
542	544
543	545		function rpi_snr :string; { 信噪比: 0000000012345678 }
544	546
545	547		function rpi_hw :string; { 处理器类型: BCM2708 }
546	548
547	549		function rpi_proc:string; { ARMv6-compatible processor rev 7 (v6l) }
548	550
549	551		...
550	552
551	553		function i2c_bus_write(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;
552	554
553	555		function i2c_bus_read (baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : integer;
554	556
555	557		function i2c_string_read(baseadr,reg:word; var <data:databuf_t>; lgt:byte; testnr:integer) : string;
556	558
557	559		function i2c_string_write(baseadr,reg:word; s:string; testnr:integer) : integer;
558	560
559	561		...
560	562
561	563		procedure SPI_Write(devnum:byte; reg,data:word);
562	564
563	565		function SPI_Read(devnum:byte; reg:word) : byte;
564	566
565	567		procedure SPI_BurstRead2Buffer (devnum,start_reg:byte; xferlen:longword);
566	568
567	569		procedure SPI_BurstWriteBuffer (devnum,start_reg:byte; xferlen:longword); { 从缓冲区SPI的地址写入一段字节的内容 }
568	570
569	571		...
570	572
571	573		测试程序 (testrpi.pas):
572	574
573	575		``` pascal
574	576		//Simple Test program, which is using rpi_hal;
575	577
576	578		program testrpi;
577	579		uses rpi_hal;
578	580		begin
579	581		writeln('Show CPU-Info, RPI-HW-Info and Registers:');
580	582		rpi_show_all_info;
581	583		writeln('Let Status LED Blink. Using GPIO functions:');
582	584		GPIO_PIN_TOGGLE_TEST;
583	585		writeln('Test SPI Read function. (piggy back board with installed RFM22B Module is required!)');
584	586		Test_SPI;
585	587		end.
586	588		```
587	589
588	590		### 5. 底层pascal单元 PiGpio(代替wiringpi C语言库的GPIO控制)
589	591
590		-	这个单元 (pigpio.pas[2](https://docs.google.com/file/d/0B-b-5ooIWPvGN1BIcEJzRDgyeUE/edit?usp=sharing)) 270 行代码是由Gabor Szollosi提供的 , 运行速度飞快(例如GPIO引脚输出开关频率达到8MHz) :
	592	+	这个单元 (pigpio.pas[1](https://docs.google.com/file/d/0B-b-5ooIWPvGN1BIcEJzRDgyeUE/edit?usp=sharing)) 270 行代码是由Gabor Szollosi提供的 , 运行速度飞快(例如GPIO引脚输出开关频率达到8MHz) :
591	593
592	594		``` pascal
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 = $20000;//bcm2835 gpio register 0x2000 0000. new fpMap uses page offset, one page is 4096bytes
611	613		// hex 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		-	~~Controlling Lazarus unit:(Project files[3](https://drive.google.com/folderview?id=0B-b-5ooIWPvGU043ZTZ0cUc2YkE&usp=sharing))~~
	865	+	Controlling Lazarus unit:(Project files[2](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		## 参考
1055	1057
1056	1058		- Eben Upton and Gareth Halfacree. Raspberry Pi User Guide. John Wiley and Sons, Chichester 2012, ISBN 111846446X
1057	1059		- B. J. Rao (2013) The Raspberry Pi, Pi Vision and Lazarus/FPC. [Blaise Pascal Magazine](http://www.blaisepascal.eu). 29: 14-21.
1058	1060
1059	1061		## 外部链接
1060	1062
1061	1063		- [Raspberry Pi 基础](http://www.raspberrypi.org)
1062	1064		- [Raspberry Pi Spy: Raspberry Pi tutorials, scripts, help and downloads](http://www.raspberrypi-spy.co.uk)
1063	1065		- [Lazarus wrapper unit for Gordon Henderson's wiringPi C library](http://www.lazarus.freepascal.org/index.php/topic,17404.0.html)
1064	1066		- [Pin layout of the wiringPi library](https://projects.drogon.net/raspberry-pi/wiringpi/pins/)
1065	1067		- [Additional information on Lazarus and Raspberry Pi at eLinux.org](http://www.elinux.org/Lazarus_on_RPi)
1066	1068		- [Getting Started with Pascal on the Pi](http://www.pp4s.co.uk/main/gs-pi-intro.html)
1067	1069		- [Lazberry Pi: Comprehensive information on Lazarus on the Raspberry Pi computer](http://superbitysoft.co.uk/lazberrypi/).
1068	1070		- [Stefan Fischer's Lazarus unit rpi_hal](http://www.lazarus.freepascal.org/index.php/topic,20991.0.html).
1069	1071		- [Improved Lazarus Unit for fast access to GPIO](http://www.meltonisl.com/software.html).
1070	1072
1071	1073		---
1072	1074		From the Free Pascal wiki, page "Lazarus on Raspberry Pi/zh CN", as it stood on 2020-02-19 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history