第001节_辅线1_硬件知识_LED原理图
当我们学习C语言时，我们会写一篇文章Hello程序。当我们写的时候ARM程序，也应该有一个简单的程序来引导我们开始，这个程序是点亮的LED。
如何点亮一个？LED呢？
分为三步：
看原理图，确定控制LED的引脚;
写程序;
先说原理图怎么看:
LED样子有很多种，像插脚的，贴片的。
它们看起来完全不同，所以我们在原理图中抽象出来。
点亮LED需要通电保护LED，增加电阻以减少电流。
控制LED灯亮灭时，可手动开关LED，但在电子系统中，不可能通过编程和芯片引脚来控制开关。
LED有四种常见的驱动方式。
方法1:引脚输出3.3V点亮LED，输出0V熄灭LED。
方法2：将引脚拉低至0V点亮LED，输出3.3V熄灭LED。
由于省电等原因，部分芯片引脚驱动能力不足，此时可采用三极管驱动。
方法3:引脚输出1.2V点亮LED，输出0V熄灭LED。
方法4:引脚输出0V点亮LED，输出1.2V熄灭LED。
因此，主芯片引脚输出高电平/低电平可以改变LED状态，不需要注意GPIO引脚输出为3.3V还是1.2V。
所以简称输出1或0:
逻辑1-->高电平
逻辑0-->低电平
第002节_辅线1_硬件知识_S3C2440启动流程与GPIO操作
在原理图中，同名Net表示是连在一起的。
怎么样GPF4如何输出1或0？
1. 输出引脚配置；
2. 设置状态；
因此，设置GPFCON[9:8]=0b01,即GPF4配置为输出；
设置GPFDAT[4]=1或0，即输出高电平或低电平；
S3C2440框架：
S3C2440启动流程：
Nor启动：
Nor Flash基地址为0，片中RAM地址为0x4000 0000;
CPU读出Nor执行第一个指令(前4字节)；
CPU继续阅读其他指令执行。
Nand启动：
片内4k RAM基地址为0，Nor Flash不可访问；
2440硬件把Nand前4K将内容复制到片中RAM，然后CPU第一条指令从0地址取出执行。
第003节_编写第一个程序点亮LED
在写第一个程序之前，先了解一些概念。
2440是一个SOC，它里面的CPU有R1、R2、R3……等 寄存器；
它里面的GPIO控制器也有很多寄存器，比如 GPFCON、GPFDAT。
在编写代码时，这两个寄存器是不同的，CPU寄存器可以直接访问，其他寄存器应以地址访问。
把GPF4需要将0配置为输出x100写入GPFCON这个寄存器，即写到0x5600 0050上；
把GPF输出1，需要0x10写到地址0x5600 0054上；
把GPF4输出0，需要0x00写到地址0x5600 0054上；
这里的写作方法会破坏寄存器的其他位置，其他位置控制其他引脚。为了尽可能简单地处理第一个裸板程序。
编写程序需要几个汇编代码：
①LDR (load):读寄存器
举例：LDR R0,[R1]
假设R1的值是x，在地址x上读取数据(4字节)并保存到R0中；
②STR (store):写寄存器
举例：STR R0,[R1]
假设R1的值是x，把R0值写到地址x(4字节)；
③B 跳转
④MOV (move)移动，赋值
举例1：MOV R0,R1
把R1的值赋值给R0;
举例2：MOV R0,#0x100
把0x100赋值给R0,即R0=0x100;
⑤LDR
举例：LDR R0,=0x12345678
这是一个伪指令，即实际上没有这个指令，他将被分成几个真实的指令ARM指令，达到同样的效果。
最后结果是R0=0x12345678。
为什么会引入伪指令？
在ARM在32个指令中，有些字节表示指令，有些字节表示数据，所以没有32个数据，不能表示32个任意值，只能表示一个较小的简单值，称为即时数。引入伪指令后，使用LDR可以为R0赋任意大小值，编译器会自动拆分成真正的的指令，实现目的。
基于前五个汇编指令，我们可以编写代码。
第一个程序只能汇编。你以前可能写过单片机程序，一上来就写。main()函数，编译器帮你包装。
第一个LED程序代码如下：
/*
* 点亮LED1: gpf4
*/
.text
.global _start
_start:
/* 配置GPF4为输出引脚
* 把0x100写到地址0x56000050
*/
ldr r1, =0x56000050
ldr r0, =0x100/* mov r0, #0x100 */
str r0, [r1]
/* 设置GPF4输出高电平
* 把0写到地址0x56000054
*/
ldr r1, =0x56000054
ldr r0, =0/* mov r0, #0 */
str r0, [r1]
/* 死循环 */
halt:
b halt
将代码上传到服务器，
先编译：
arm-linux-gcc -c -o led_on.o led_on.s ；
再链接：
arm-linux-ld -Ttext 0 led_on.o -o led_on.elf ；
生成bin文件：
arm-linux-objcopy -O binary -S led_on.elf led_on.bin ；
如果我们每次输入上述命令，很容易输错，所以我们把它们写在文件中，这个文件被称为Makefile.
关于Makefile以后再谈。这次需要的。Makefile如下：
all:
arm-linux-gcc -c -o led_on.o led_on.S
arm-linux-ld -Ttext 0 led_on.o -o led_on.elf
arm-linux-objcopy -O binary -S led_on.elf led_on.bin
clean:
rm *.bin *.o *.elf
以后只需要 使用 make 编译命令， make clean 清理命令。
最后烧写在开发板上，只能看到一个LED亮，符合我们的预期。
第004节_汇编和机器代码
前面介绍了伪指令，实际上并不存在。ARM编译器在编译过程中将编译器转换为存在的命令ARM指令。在我们的代码中ldr r1, =0x伪指令的真实指令是什么？
可通过反汇编查看。
在前面的Makefile中加上：
arm-linux-objdump -D led_on.elf > led_on.dis
上传服务器，编译。
生成的led_on.dis是反汇编文件。led_on.dis如下：
led_on.elf: file format elf32-littlearm
Disassembly of section .text:
00000000 <_start>:
0:e59f1014 ldrr1, [pc, #20]; 1c <.text>
4:e3a00c01 movr0, #256; 0x100
8:e5810000 strr0, [r1]
c:e59f100c ldrr1, [pc, #12]; 20 <.text>
10:e3a00000 movr0, #0; 0x0
14:e5810000 strr0, [r1]
00000018 :
18:eafffffe b18
1c:56000050 undefined
20:56000054 undefined
第一列是地址，第二列是机器码，第三列是汇编；
在反汇文件里可以看到，ldr r1, =0x56000050被转换成ldr r1, [pc, #20],pc+20地址的值为0x56000050,通过这种方式为r1赋值。
对于立即数0x100而言，ldr r0,=0x100即是转换成了mov r0,#256;
在2440这个SOC里面，R0-R15都在CPU里面，其中：
R13 别名：sp (Stack Pointer)栈指针
R14 别名：lr (Link Register)返回地址
R15 别名：pc (program Counter)程序计数器=当前指令+8
为什么 PC=当前指令+8？
ARM指令采用流水线机制，当前执行地址A的指令，已经在对地址A+4的指令进行译码，已经在读取地址A+8的指令，其中A+8就是PC的值。
C/汇编(给人类方便使用的语言)———编译器———>bin，含有机器码(给CPU使用)
第005节_编程知识_进制
17个苹果，有4种表示方式，它们表示同一个数值：
计算验证：
十进制：17=1x10^1 + 7x10^0;
二进制：17=1x2^4 + 0x2^3 + 0x2^2 + 0x2^1 + 1x2^0;
八进制：17=2x8^1 + 1x8^0;
十六进制：17=1x16^1 + 1x16^0;
为何引入二进制？
在硬件角度看，晶体管只有两个状态：on是1,off是0；
数据使用多个晶体管进行表示，用二进制描述，吻合硬件状态。
为何引入八进制？
将二进制的三位作为一组，把这一组作为一位进行表示，就是八进制。
为何引入十六进制？
将二进制的四位作为一组，把这一组作为一位进行表示，就是十六进制。八进制和十六进制方便我们描述，简化了长度。
如何快速的转换2/8/16进制：
首先记住8 4 2 1 ——>二进制权重
举例1：
将二进制0b01101110101转换成八进制：
将二进制从右到左，每三个分成一组：
结果就是1565；
举例2：
将二进制0b01101110101转换成十六进制：
将二进制从右到左，每四个分成一组：
结果就是375；
举例3：
将十六进制0xABC1转换成二进制：
将十六进制从右到左，每个分成四位：
结果就是1010 1011 1100 0001；
在C语言中怎么表示这些进制呢？
十进制： int a = 96;
八进制： int a = 0140;//0开头
十六进制： int a = 0x60;//0x开头
用0b开头表示二进制，约定俗成的规定。
第006节_编程知识_字节序_位操作
字节序：
假设int a = 0x12345678；
前面说了16进制每位是4个bit，在内存中，是以8个bit作为1byte进行存储的，因此0x12345678中每两位作为1byte,其中0x78是低位，0x12是高位。
在内存中的存储方式有两种：
0x12345678的低位(0x78)存在低地址，即方式1，叫做小字节序(Little endian)；
0x12345678的高位(0x12)存在低地址，即方式2，叫做大字节序(Big endian)；
一般的arm芯片都是小字节序，对于2440可以设置某个寄存器，让整个系统使用大字节序或小字节序，它默认使用小字节序。
位操作：
1. 移位
左移：
int a = 0x123; int b = a<<2;--> b=0x48C
右移：
int a = 0x123; int b = a>>2;--> b=0x48
左移是乘4，右移是除4；
2. 取反
原来问0的位变1，原来为1的位变0；
int a = 0x123; int b = ~a;a=2
3. 位与
1 & 1 = 1
1 & 0 = 0
0 & 1 = 0
0 & 0 = 0
int a = 0x123; int b = 0x456; int c = a&b;--> c=0x2
4. 位或
1 | 1 = 1
1 | 0 = 1
0 | 1 = 1
0 | 0 = 0
int a = 0x123; int b = 0x456; int c = a|b;--> c=0x577
5. 置位
把a的bit7、8置位(变为1)
int a = 0x123; int b = a|(1<<7)|(1<<8);--> c=0x1a3
6. 清位
把a的bit7、8清位(变为0)
int a = 0x123; int b = (a& ~(1<<7))&(~(1<<8));--> c=0x23
置位和清位在后面寄存器的操作中，会经常使用。
第007节_编写C程序控制LED
C语言的指针操作：
①所有的变量在内存中都有一块区域；
②可以通过变量/指针操作内存；
TYPE *p = val1;
*p = val2;
把val2写入地址val1的内存中，写入sizeof(TYPE)字节;
TYPE *p = addr;
*p = val;
把val写入地址addrd的内存，，写入sizeof(TYPE)字节;
a. 我们写出了main函数, 谁来调用它?
b. main函数中变量保存在内存中, 这个内存地址是多少?
答: 我们还需要写一个汇编代码, 给main函数设置内存, 调用main函数
led.c源码：
int main()
{
unsigned int *pGPFCON = (unsigned int *)0x56000050;
unsigned int *pGPFDAT = (unsigned int *)0x56000054;
/*配置GPF4为输出引脚*/
*pGPFCON = 0x100;
/*配置GPF4输出0*/
*pGPFDAT = 0;
return 0;
}
start.S源码：
.text
.global _start
_start:
/*设置内存：sp栈*/
ldr sp,=4096 /*nand启动*/
// ldr sp, =0x40000000 /*nor启动*/
/*调用main*/
bl main
halt:
b halt
Makefile源码：
all:
arm-linux-gcc -c -o led.o led.c
arm-linux-gcc -c -o start.o start.S
arm-linux-ld -Ttext 0 start.o led.o -o led.elf
arm-linux-objcopy -O binary -S led.elf led.bin
arm-linux-objdump -D led.elf > led.dis
clean:
rm *.bin *.o *.elf *.dis
最后将上面三个文件放入Ubuntu主机编译，然后烧写到开发板即可。
第008节_几条汇编指令_bl_add_sub_ldm_stm
⑥ADD/SUB 加法/减法
举例1：
add r0,r1,#4
效果为
r0=r1+4；
举例2：
sub r0,r1,#4
效果为
r0=r1-4；
举例3：
sub r0,r1,r2
效果为
r0=r1-r2；
⑦BL (Brarch and Link)带返回值的跳转
跳转到指定指令，并将返回地址(下一条指令)保存在lr寄存器；
⑧LDM/STM 读内存，写入多个寄存器/把多个寄存器的值写入内存
可搭配的后缀有 过后增加(Increment After)、预先增加(Increment Before)、过后减少(Decrement After)、预先减少(Decrement Before)；
举例1：
stmdb sp!, (fp,ip,lr,pc)
假设Sp=4096。
db意思是先减后存，按 高编号寄存器存在高地址 存。
举例2：
ldmia sp, (fp,ip,pc)
009节_解析C程序的内部机制
003_led.c内部机制分析：
start.S:
①设置栈；
②调用main，并把返回值地址保存到lr中；
led.c的main()内容：
①定义2个局部变量；
②设置变量；
③return 0；
问题：
①为什么要设置栈？
因为c函数要用。
②怎么使用栈？
a.保存局部变量；
b.保存lr等寄存器；
③调用者如何传参数给被调用者？
④被调用者如何传返回值给调用者？
⑤怎么从栈中恢复那些寄存器？
在arm中有个ATPCS规则，约定r0-r15寄存器的用途。
r0-r3:调用者和被调用者之间传参数；
r4-r11:函数可能被使用，所以在函数的入口保存它们，在函数的出口恢复它们；
下面分析个实例
start.S:
.text
.global _start
_start:
/* 设置内存: sp 栈 */
ldr sp, =4096 /* nand启动 */
//ldr sp, =0x40000000+4096 /* nor启动 */
/* 调用main */
bl main
halt:
b halt
led.c:
int main()
{
unsigned int *pGPFCON = (unsigned int *)0x56000050;
unsigned int *pGPFDAT = (unsigned int *)0x56000054;
/* 配置GPF4为输出引脚 */
*pGPFCON = 0x100;
/* 设置GPF4输出0 */
*pGPFDAT = 0;
return 0;
}
将前面的程序反汇编得到led.dis如下：
led.elf: file format elf32-littlearm
Disassembly of section .text:
00000000 <_start>:
0:e3a0da01 movsp, #4096; 0x1000
4:eb000000 blc
00000008 :
8:eafffffe b8
0000000c :
c:e1a0c00d movip, sp
10:e92dd800 stmdbsp!, {fp, ip, lr, pc}
14:e24cb004 subfp, ip, #4; 0x4
18:e24dd008 subsp, sp, #8; 0x8
1c:e3a03456 movr3, #1442840576; 0x56000000
20:e2833050 addr3, r3, #80; 0x50
24:e50b3010 strr3, [fp, #-16]
28:e3a03456 movr3, #1442840576; 0x56000000
2c:e2833054 addr3, r3, #84; 0x54
30:e50b3014 strr3, [fp, #-20]
34:e51b2010 ldrr2, [fp, #-16]
38:e3a03c01 movr3, #256; 0x100
3c:e5823000 strr3, [r2]
40:e51b2014 ldrr2, [fp, #-20]
44:e3a03000 movr3, #0; 0x0
48:e5823000 strr3, [r2]
4c:e3a03000 movr3, #0; 0x0
50:e1a00003 movr0, r3
54:e24bd00c subsp, fp, #12; 0xc
58:e89da800 ldmiasp, {fp, sp, pc}
Disassembly of section .comment:
00000000 <.comment>:
0:43434700 cmpmir3, #0; 0x0
4:4728203a undefined
8:2029554e eorcsr5, r9, lr, asr #10
c:2e342e33 mrccs14, 1, r2, cr4, cr3, {1}
10:Address 0x10 is out of bounds.
分析上面的汇编代码：
开发板上电后，将从0地址开始执行，即开始执行
movsp, #4096:设置栈地址在4k RAM的最高处，sp=4096;
bl c :调到c地址处的main函数，并保存下一行代码地址到lr，即lr=8;
movip, sp:给ip赋值sp的值，ip=sp=4096
stmdbsp!, {fp, ip, lr, pc}:按高编号寄存器存在高地址，依次将pc、lr、ip、fp存入sp-4中；
subfp, ip, #4：fp的值为ip-4=4096-4=4092;
subsp, sp, #8:sp的值为sp-8=(4096-4x4)-8=4072;
movr3, #1442840576:r3赋值0x5600 0000;
addr3, r3, #80:r3的值加0x50,即r3=0x5600 0050;
strr3, [fp, #-16]:r3存入[fp-16]所在的地址，即地址4076处存放0x5600 0050；
movr3, #1442840576：r3赋值0x5600 0000;
addr3, r3, #84:r3的值加0x54,即r3=0x5600 0054;
strr3, [fp, #-20]:r3存入[fp-20]所在的地址，即地址4072处存放0x5600 0054；
ldrr2, [fp, #-16]：r2取[fp-16]地址处的值，即[4076]地址的值，r2=0x5600 0050；
movr3, #256:r3赋值为0x100；
strr3, [r2]：将r3写到r2内容所对应的地址，即0x5600 0050地址处的值为0x100;;对应c语言*pGPFCON = 0x100;;
ldrr2, [fp, #-20]:r2取[fp-20]地址处的值，即[4072]地址的值，r2=0x5600 0054；
movr3, #0:r3赋值为0x00；
strr3, [r2]:将r3写到r2内容所对应的地址，即0x5600 0054地址处的值为0x00;对应c语言*pGPFDAT = 0;
movr3, #0:r3赋值为0x00；
movr0, r3：r0=r3=0x00;
subsp, fp, #12:sp=fp-12=4092-12=4080;
ldmiasp, {fp, sp, pc}:从栈中恢复寄存器，fp=4080地址处的值=原来的fp,sp=4084地址处的值=4096，pc=4088地址处的值=8，随后调到0x08地址处继续执行。
过程中的内存数据情况：
前面那个例子，汇编调用main.c并没有传递参数，这里修改下c程序，让其传递参数。
start.S:
.text
.global _start
_start:
/* 设置内存: sp 栈 */
ldr sp, =4096 /* nand启动 */
//ldr sp, =0x40000000+4096 /* nor启动 */
mov r0, #4
bl led_on
ldr r0, =100000
bl delay
mov r0, #5
bl led_on
halt:
b halt
led.c:
void delay(volatile int d)
{
while (d--);
}
int led_on(int which)
{
unsigned int *pGPFCON = (unsigned int *)0x56000050;
unsigned int *pGPFDAT = (unsigned int *)0x56000054;
if (which == 4)
{
/* 配置GPF4为输出引脚 */
*pGPFCON = 0x100;
}
else if (which == 5)
{
/* 配置GPF5为输出引脚 */
*pGPFCON = 0x400;
}
/* 设置GPF4/5输出0 */
*pGPFDAT = 0;
return 0;
}
led.elf:
led.elf: file format elf32-littlearm
Disassembly of section .text:
00000000 <_start>:
0:e3a0da01 movsp, #4096; 0x1000
4:e3a00004 movr0, #4; 0x4
8:eb000012 bl58
c:e59f000c ldrr0, [pc, #12]; 20 <.text>
10:eb000003 bl24
14:e3a00005 movr0, #5; 0x5
18:eb00000e bl58
0000001c :
1c:eafffffe b1c
20:000186a0 andeqr8, r1, r0, lsr #13
00000024 :
24:e1a0c00d movip, sp
28:e92dd800 stmdbsp!, {fp, ip, lr, pc}
2c:e24cb004 subfp, ip, #4; 0x4
30:e24dd004 subsp, sp, #4; 0x4
34:e50b0010 strr0, [fp, #-16]
38:e51b3010 ldrr3, [fp, #-16]
3c:e2433001 subr3, r3, #1; 0x1
40:e50b3010 strr3, [fp, #-16]
44:e51b3010 ldrr3, [fp, #-16]
48:e3730001 cmnr3, #1; 0x1
4c:0a000000 beq54
50:eafffff8 b38
54:e89da808 ldmiasp, {r3, fp, sp, pc}
00000058 :
58:e1a0c00d movip, sp
5c:e92dd800 stmdbsp!, {fp, ip, lr, pc}
60:e24cb004 subfp, ip, #4; 0x4
64:e24dd00c subsp, sp, #12; 0xc
68:e50b0010 strr0, [fp, #-16]
6c:e3a03456 movr3, #1442840576; 0x56000000
70:e2833050 addr3, r3, #80; 0x50
74:e50b3014 strr3, [fp, #-20]
78:e3a03456 movr3, #1442840576; 0x56000000
7c:e2833054 addr3, r3, #84; 0x54
80:e50b3018 strr3, [fp, #-24]
84:e51b3010 ldrr3, [fp, #-16]
88:e3530004 cmpr3, #4; 0x4
8c:1a000003 bnea0
90:e51b2014 ldrr2, [fp, #-20]
94:e3a03c01 movr3, #256; 0x100
98:e5823000 strr3, [r2]
9c:ea000005 bb8
a0:e51b3010 ldrr3, [fp, #-16]
a4:e3530005 cmpr3, #5; 0x5
a8:1a000002 bneb8
ac:e51b2014 ldrr2, [fp, #-20]
b0:e3a03b01 movr3, #1024; 0x400
b4:e5823000 strr3, [r2]
b8:e51b3018 ldrr3, [fp, #-24]
bc:e3a02000 movr2, #0; 0x0
c0:e5832000 strr2, [r3]
c4:e3a03000 movr3, #0; 0x0
c8:e1a00003 movr0, r3
cc:e24bd00c subsp, fp, #12; 0xc
d0:e89da800 ldmiasp, {fp, sp, pc}
Disassembly of section .comment:
00000000 <.comment>:
0:43434700 cmpmir3, #0; 0x0
4:4728203a undefined
8:2029554e eorcsr5, r9, lr, asr #10
c:2e342e33 mrccs14, 1, r2, cr4, cr3, {1}
10:Address 0x10 is out of bounds.
简单分析下反汇编：
movsp, #4096:设置栈地址在4k RAM的最高处，sp=4096;
movr0, #4:r0=4，作为参数；
bl58 :调到58地址处的led_on函数，并保存下一行代码地址到lr，即lr=8;在led_on中会使用到r0;
ldrr0, [pc, #12]:r0=[pc+12]处的值=[c+12=20]的值=0x186a0=1000000，作为参数；
bl24 :调用24地址处的delay函数，并保存下一行代码地址到lr，即lr=24;在delay中会使用到r0;
movr0, #5：r0=5，作为参数；
bl58 ：调到58地址处的led_on函数，并保存下一行代码地址到lr，即lr=58;在led_on中会使用到r0;
010节_完善LED程序_编写按键程序
在上一节视频里，我们编写的程序代码是先点亮led1，然后延时一会，再点亮led2，进入死循环。
但在开发板上的实际效果是led1先亮，延时一会，led2再亮，然后一会之后，led1再次亮了。
这和我们的设计的代码流程不吻合，这是因为2440里面有个看门狗定时器，开发板上电后，需要在一定时间内“喂狗”(设置相应的寄存器)，否则就会重启开发板。
之所以这样设计，是为了让芯片出现死机时，能够自己复位，重新运行。
这里我们写个led灯循环的程序，步骤如下：
这里暂时用不到看门狗，先关闭看门狗，从参考手册可知，向0x53000000寄存器写0即可关闭看门狗；
设置内存的栈，通过写读操作来判断是Nand Flash还是Nor Flash;
设置GPFCON让GPF4/5/6配置为输出引脚;
循环点灯，依次设置GPFDAT寄存器；
完整代码如下：
.text
.global _start
_start:
/* 关闭看门狗 */
ldr r0, =0x53000000
ldr r1, =0
str r1, [r0]
/* 设置内存: sp 栈 */
/* 分辨是nor/nand启动
* 写0到0地址, 再读出来
* 如果得到0, 表示0地址上的内容被修改了, 它对应ram, 这就是nand启动
* 否则就是nor启动
*/
mov r1, #0
ldr r0, [r1] /* 读出原来的值备份 */
str r1, [r1] /* 0->[0] */
ldr r2, [r1] /* r2=[0] */
cmp r1, r2 /* r1==r2? 如果相等表示是NAND启动 */
ldr sp, =0x40000000+4096 /* 先假设是nor启动 */
moveq sp, #4096 /* nand启动 */
streq r0, [r1] /* 恢复原来的值 */
bl main
halt:
b halt
led.c
void delay(volatile int d)
{
while (d--);
}
int main(void)
{
volatile unsigned int *pGPFCON = (volatile unsigned int *)0x56000050;
volatile unsigned int *pGPFDAT = (volatile unsigned int *)0x56000054;
int val = 0; /* val: 0b000, 0b111 */
int tmp;
/* 设置GPFCON让GPF4/5/6配置为输出引脚 */
*pGPFCON &= ~((3<<8) | (3<<10) | (3<<12));
*pGPFCON |= ((1<<8) | (1<<10) | (1<<12));
/* 循环点亮 */
while (1)
{
tmp = ~val;
tmp &= 7;
*pGPFDAT &= ~(7<<4);
*pGPFDAT |= (tmp<<4);
delay(100000);
val++;
if (val == 8)
val =0;
}
return 0;
}
2440里面有很多寄存器，如果每次对不同的寄存器进行查询和操作会很麻烦，因此可以先提前定义成宏，做成一个头文件，每次调用就行。
再举一个按键控制LED的程序，，步骤如下：
这里暂时用不到看门狗，先关闭看门狗，从参考手册可知，向0x53000000寄存器写0即可关闭看门狗；
设置内存的栈，通过写读操作来判断是Nand Flash还是Nor Flash;
设置GPFCON让GPF4/5/6配置为输出引脚;
设置3个按键引脚为输入引脚;
循环执行，读取按键引脚值，点亮对应的led灯；
完整代码如下：
#include "s3c2440_soc.h"
void delay(volatile int d)
{
while (d--);
}
int main(void)
{
int val1, val2;
/* 设置GPFCON让GPF4/5/6配置为输出引脚 */
GPFCON &= ~((3<<8) | (3<<10) | (3<<12));
GPFCON |= ((1<<8) | (1<<10) | (1<<12));
/* 配置3个按键引脚为输入引脚:
* GPF0(S2),GPF2(S3),GPG3(S4)
*/
GPFCON &= ~((3<<0) | (3<<4)); /* gpf0,2 */
GPGCON &= ~((3<<6)); /* gpg3 */
/* 循环点亮 */
while (1)
{
val1 = GPFDAT;
val2 = GPGDAT;
if (val1 & (1<<0)) /* s2 --> gpf6 */
{
/* 松开 */
GPFDAT |= (1<<6);
}
else
{
/* 按下 */
GPFDAT &= ~(1<<6);
}
if (val1 & (1<<2)) /* s3 --> gpf5 */
{
/* 松开 */
GPFDAT |= (1<<5);
}
else
{
/* 按下 */
GPFDAT &= ~(1<<5);
}
if (val2 & (1<<3)) /* s4 --> gpf4 */
{
/* 松开 */
GPFDAT |= (1<<4);
}
else
{
/* 按下 */
GPFDAT &= ~(1<<4);
}
}
return 0;
}