第008课 第1个ARM裸板程序及引申(点亮LED灯)

原文地址： http://wiki.100ask.org

第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?

配置为输出引脚；

设置状态；

因此，设置GPFCON[9:8]=0b01,即GPF4配置为输出；

设置GPFDAT[4]=1或者0，即输出高电平或低电平；

S3C2440框架：



S3C2440启动流程：

Nor启动：

Nor Flash的基地址为0，片内RAM地址为0x4000 0000;

CPU读出Nor上第1个指令（前4字节），执行；

CPU继续读出其它指令执行。

Nand启动：

片内4k RAM基地址为0，Nor Flash不可访问；

2440硬件把Nand前4K内容复制到片内的RAM，然后CPU从0地址取出第1条指令执行。

第003节_编写第1个程序点亮LED

在开始写第1个程序前，先了解一些概念。

2440是一个SOC，它里面的CPU有R1、R2、R3……等 寄存器；

它里面的GPIO控制器也有很多寄存器，如 GPFCON、GPFDAT。

这两个寄存器是有差异的，在写代码的时候，CPU里面的寄存器可以直接访问，其它的寄存器要以地址进行访问。

把GPF4配置为输出，需要把0x100写入GPFCON这个寄存器，即写到0x5600 0050上；

把GPF4输出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赋任意大小值，编译器会自动拆分成真正的的指令，实现目的。

有了前面5个汇编指令的基础，我们就可以写代码了。

第一个程序只能是汇编，以前你们可能写过单片机程序，一上来就写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, =0x56000050

这条伪指令的真实指令时什么呢?

我们可以通过反汇编来查看。

在前面的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    ldr r1, [pc, #20]   ; 1c <.text+0x1c>
4:   e3a00c01    mov r0, #256    ; 0x100
8:   e5810000    str r0, [r1]
c:   e59f100c    ldr r1, [pc, #12]   ; 20 <.text+0x20>
10:   e3a00000    mov r0, #0  ; 0x0
14:   e5810000    str r0, [r1]

00000018 <halt>:
18:   eafffffe    b   18 <halt>
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个字节，在内存中，是以8个字节作为1byte进行存储的，因此0x12345678中每两位作为1byte,其中0x78是低位，0x12是高位。

在内存中的存储方式有两种：



0x12345678的低位（0x78）存在低地址，即方式1，叫做小字节序(Little endian)；

0x12345678的高位（0x12）存在低地址，即方式2，叫做大字节序(Big endian)；

一般的arm芯片都是小字节序，对于2440可以设置某个寄存器，让整个系统使用大字节序或小字节序，它默认使用小字节序。

位操作：

移位

左移：

int a = 0x123; int b = a<<2;–> b=0x48C

右移：

int a = 0x123; int b = a>>2;–> b=0x48

左移是乘4，右移是除4；

取反

原来问0的位变1，原来为1的位变0；

int a = 0x123; int b = ~a;a=2

位与

1 & 1 = 1

1 & 0 = 0

0 & 1 = 0

0 & 0 = 0

int a = 0x123; int b = 0x456; int c = a&b;–> c=0x2

位或

1 | 1 = 1

1 | 0 = 1

0 | 1 = 1

0 | 0 = 0

int a = 0x123; int b = 0x456; int c = a|b;–> c=0x577

置位

把a的bit7、8置位（变为1）

int a = 0x123; int b = a|(1<<7)|(1<<8);–> c=0x1a3

清位

把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    mov sp, #4096   ; 0x1000
4:   eb000000    bl  c <main>

00000008 <halt>:
8:   eafffffe    b   8 <halt>

0000000c <main>:
c:   e1a0c00d    mov ip, sp
10:   e92dd800    stmdb   sp!, {fp, ip, lr, pc}
14:   e24cb004    sub fp, ip, #4  ; 0x4
18:   e24dd008    sub sp, sp, #8  ; 0x8
1c:   e3a03456    mov r3, #1442840576 ; 0x56000000
20:   e2833050    add r3, r3, #80 ; 0x50
24:   e50b3010    str r3, [fp, #-16]
28:   e3a03456    mov r3, #1442840576 ; 0x56000000
2c:   e2833054    add r3, r3, #84 ; 0x54
30:   e50b3014    str r3, [fp, #-20]
34:   e51b2010    ldr r2, [fp, #-16]
38:   e3a03c01    mov r3, #256    ; 0x100
3c:   e5823000    str r3, [r2]
40:   e51b2014    ldr r2, [fp, #-20]
44:   e3a03000    mov r3, #0  ; 0x0
48:   e5823000    str r3, [r2]
4c:   e3a03000    mov r3, #0  ; 0x0
50:   e1a00003    mov r0, r3
54:   e24bd00c    sub sp, fp, #12 ; 0xc
58:   e89da800    ldmia   sp, {fp, sp, pc}
Disassembly of section .comment:

00000000 <.comment>:
0:   43434700    cmpmi   r3, #0  ; 0x0
4:   4728203a    undefined
8:   2029554e    eorcs   r5, r9, lr, asr #10
c:   2e342e33    mrccs   14, 1, r2, cr4, cr3, {1}
10:   Address 0x10 is out of bounds.

分析上面的汇编代码：

开发板上电后，将从0地址开始执行，即开始执行

mov    sp, #4096:设置栈地址在4k RAM的最高处，sp=4096;
bl    c <main>:调到c地址处的main函数，并保存下一行代码地址到lr，即lr=8;
mov    ip, sp:给ip赋值sp的值，ip=sp=4096
stmdb  sp!, {fp, ip, lr, pc}:按高编号寄存器存在高地址，依次将pc、lr、ip、fp存入sp-4中；
sub    fp, ip, #4：fp的值为ip-4=4096-4=4092;
sub    sp, sp, #8:sp的值为sp-8=(4096-4x4)-8=4072;
mov    r3, #1442840576:r3赋值0x5600 0000;
add    r3, r3, #80:r3的值加0x50,即r3=0x5600 0050;
str    r3, [fp, #-16]:r3存入[fp-16]所在的地址，即地址4076处存放0x5600 0050；
mov    r3, #1442840576：r3赋值0x5600 0000;
add    r3, r3, #84:r3的值加0x54,即r3=0x5600 0054;
str    r3, [fp, #-20]:r3存入[fp-20]所在的地址，即地址4072处存放0x5600 0054；
ldr    r2, [fp, #-16]：r2取[fp-16]地址处的值，即[4076]地址的值，r2=0x5600 0050；
mov    r3, #256:r3赋值为0x100；
str    r3, [r2]：将r3写到r2内容所对应的地址，即0x5600 0050地址处的值为0x100;;对应c语言*pGPFCON = 0x100;;
ldr    r2, [fp, #-20]:r2取[fp-20]地址处的值，即[4072]地址的值，r2=0x5600 0054；
mov    r3, #0:r3赋值为0x00；
str    r3, [r2]:将r3写到r2内容所对应的地址，即0x5600 0054地址处的值为0x00;对应c语言*pGPFDAT = 0;
mov    r3, #0:r3赋值为0x00；
mov    r0, r3：r0=r3=0x00;
sub    sp, fp, #12:sp=fp-12=4092-12=4080;
ldmia  sp, {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    mov sp, #4096   ; 0x1000
4:   e3a00004    mov r0, #4  ; 0x4
8:   eb000012    bl  58 <led_on>
c:   e59f000c    ldr r0, [pc, #12]   ; 20 <.text+0x20>
10:   eb000003    bl  24 <delay>
14:   e3a00005    mov r0, #5  ; 0x5
18:   eb00000e    bl  58 <led_on>

0000001c <halt>:
1c:   eafffffe    b   1c <halt>
20:   000186a0    andeq   r8, r1, r0, lsr #13

00000024 <delay>:
24:   e1a0c00d    mov ip, sp
28:   e92dd800    stmdb   sp!, {fp, ip, lr, pc}
2c:   e24cb004    sub fp, ip, #4  ; 0x4
30:   e24dd004    sub sp, sp, #4  ; 0x4
34:   e50b0010    str r0, [fp, #-16]
38:   e51b3010    ldr r3, [fp, #-16]
3c:   e2433001    sub r3, r3, #1  ; 0x1
40:   e50b3010    str r3, [fp, #-16]
44:   e51b3010    ldr r3, [fp, #-16]
48:   e3730001    cmn r3, #1  ; 0x1
4c:   0a000000    beq 54 <delay+0x30>
50:   eafffff8    b   38 <delay+0x14>
54:   e89da808    ldmia   sp, {r3, fp, sp, pc}

00000058 <led_on>:
58:   e1a0c00d    mov ip, sp
5c:   e92dd800    stmdb   sp!, {fp, ip, lr, pc}
60:   e24cb004    sub fp, ip, #4  ; 0x4
64:   e24dd00c    sub sp, sp, #12 ; 0xc
68:   e50b0010    str r0, [fp, #-16]
6c:   e3a03456    mov r3, #1442840576 ; 0x56000000
70:   e2833050    add r3, r3, #80 ; 0x50
74:   e50b3014    str r3, [fp, #-20]
78:   e3a03456    mov r3, #1442840576 ; 0x56000000
7c:   e2833054    add r3, r3, #84 ; 0x54
80:   e50b3018    str r3, [fp, #-24]
84:   e51b3010    ldr r3, [fp, #-16]
88:   e3530004    cmp r3, #4  ; 0x4
8c:   1a000003    bne a0 <led_on+0x48>
90:   e51b2014    ldr r2, [fp, #-20]
94:   e3a03c01    mov r3, #256    ; 0x100
98:   e5823000    str r3, [r2]
9c:   ea000005    b   b8 <led_on+0x60>
a0:   e51b3010    ldr r3, [fp, #-16]
a4:   e3530005    cmp r3, #5  ; 0x5
a8:   1a000002    bne b8 <led_on+0x60>
ac:   e51b2014    ldr r2, [fp, #-20]
b0:   e3a03b01    mov r3, #1024   ; 0x400
b4:   e5823000    str r3, [r2]
b8:   e51b3018    ldr r3, [fp, #-24]
bc:   e3a02000    mov r2, #0  ; 0x0
c0:   e5832000    str r2, [r3]
c4:   e3a03000    mov r3, #0  ; 0x0
c8:   e1a00003    mov r0, r3
cc:   e24bd00c    sub sp, fp, #12 ; 0xc
d0:   e89da800    ldmia   sp, {fp, sp, pc}
Disassembly of section .comment:

00000000 <.comment>:
0:   43434700    cmpmi   r3, #0  ; 0x0
4:   4728203a    undefined
8:   2029554e    eorcs   r5, r9, lr, asr #10
c:   2e342e33    mrccs   14, 1, r2, cr4, cr3, {1}
10:   Address 0x10 is out of bounds.

简单分析下反汇编：

mov    sp, #4096:设置栈地址在4k RAM的最高处，sp=4096;
mov    r0, #4:r0=4，作为参数；
bl 58 <led_on>:调到58地址处的led_on函数，并保存下一行代码地址到lr，即lr=8;在led_on中会使用到r0;
ldr    r0, [pc, #12]:r0=[pc+12]处的值=[c+12=20]的值=0x186a0=1000000，作为参数；
bl 24 <delay>:调用24地址处的delay函数，并保存下一行代码地址到lr，即lr=24;在delay中会使用到r0;
mov    r0, #5：r0=5，作为参数；
bl 58 <led_on>：调到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;
}