第一期_GPIO接口

 

一般分三步去点亮一个LED:

  1.看原理图,确定控制LED的引脚;(确定是输出1点亮还是输出0点亮,即是高电平还是低电平点亮LED)看原理图得知通过GPF4来控制LED的亮灭

  2.看芯片手册,确定如何设置控制这个引脚

  3.写程序

通过寄存器来操作GPIO引脚

GPxCON用于选择引脚的功能,GPxDAT用于读/写引脚数据,GPxUP用于确定是否使用内部上拉电阻。x为A...H等。

1.GPxCON寄存器

用于选择引脚的功能,每一位对应一根引脚,以GPACON为例,当其中一位被设为0时,相应的引脚为输出引脚,此时可以向GPADAT中相应位写入0或1,让此引脚输出低电平或者高电平。

2.GPXDAT寄存器

GPxDAT用于读/写引脚:当引脚被设置为输入时,读此寄存器可知相应的引脚的点平状态是高电平还是低电平;当引脚被设置为输出时,写此寄存器相应位可令此引脚输出高电平或低电平。

3.GPxUP寄存器

GPxUP:某位为1时,相应的引脚无内部上拉电阻;为0时,相应的引脚使用内部上拉电阻。

上拉、下拉电阻的作用在于,当GPIO引脚处于第三种状态时(既不是输出高电平也不是输出低电平,而是呈高阻态,即相当于没有接芯片)时,它的电平状态由上拉电阻、下拉电阻确定。

GPF4怎么设置为输出1或者0?

1.配置引脚为输出引脚

2.设置状态

因此,设置GPF4CON[9:8] = 0b01,即GPF4配置为输出;设置GPF4DAT[4] = 1或者0,即输出高电平或者低电平。

s3c2440框架与启动过程:

Nor启动:

Nor Flash的基地址为0,片内RAM的地址为0x40000000;

CPU读出Nor上的第一个指令(前4字节),执行

CPU继续读出其他指令执行

Nand 启动

片内4KRAM的基地址为0,Nor Flash不可访问

2440硬件把Nand前4K的内容复制到片内的RAM中,然后cpu从0地址取出第一条指令执行

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

2440是一个SOC,它里面的CPU有R1、R2、..R15 寄存器;

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

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

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

把GPF4输出1,需要把0x10写到地址0x5600 0054上(即GPFDAT寄存器);

把GPF4输出0,需要把0x00写到地址0x5600 0054上(即GPFDAT寄存器);

这里的写法会破坏寄存器的其它位,其它位是控制其它引脚的,为了让第一个裸板程序尽可能的简单,才简单粗暴的这样处理。

写程序需要用到几条汇编代码:

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

立即数:

1.0-255之间的数

2.右移偶数位在0-255之间的数

3.取反后在0-255之间的数

add r0,r1,#4 

r0 = r1+4

sub r0,r1,#4

r0 = r1 - 4

sub r0,r1,r2

r0 = r1 - r2

bl xxx

1.调到xxx

2.把返回地址保存在lr寄存器中

db 预先减少

da 过后减少

ib 预先增加

ia 过后增加

stmdb sp!,(fp,ip,lr,pc)高编号寄存器存在高地址,此命令是操纵多个寄存器,而且是先减少后存

ldmia  sp,(fp,sp,lr,pc)

正好与上图相反

 1 /*
 2 *点亮LED1:gpf4
 3 */
 4 .text
 5 .global _start
 6 
 7 
 8 _start:
 9 /*
10 *配置gpf4为输出引脚
11 *把0x100写到地址0x56000050
12 */
13 ldr r1, = 0x56000050
14 ldr r0, = 0x100
15 str r0, [r1]
16 /*
17 *配置gpf4输出低电平
18 */
19 ldr r1, = 0x56000054
20 ldr r0, = 0
21 str r0, [r1]
22 /*死循环*/
23 halt:
24     b halt
1 all:
2     arm-linux-gcc -c -o led_on.o led.s
3     arm-linux-ld -Ttext 0 led_on.o -o led_on.elf
4     arm-linux-objcopy -O binary -S led_on.elf led_on.bin
5 clean:
6     rm *.bin *.o *.elf
View Code

字节序:

假设 int a = 0x12345678

16进制中每位是4bit,在内存中,是以8个bit作为1byte进行存储的,因此因此0x12345678中每两位作为1byte,其中0x78是低位,0x12是高位。

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

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

位操作:

1.左移

int a = 0x123;int b = a <<2;--> b = 0x48c

右移:

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

左移多少位就是乘以2的几次方,右移多少位就是除以2的几次方

2.取反 就是0变1,1变0

3.位与

1&1 = 1

1&0 = 0

4.位或

1|0 = 1

有短路原则:即或的时候前面为1后面的就不用再计算了,因为1或上任意的都为一,与的时候前面为0后面的也就不用算了,因为0与上任何数都为0.

5.清位:把a的bit7、bit8清位(变为0)

int a = 0x123;int b = a &(~(1<<7)&~(1<<8))

6.置位  把a的bit7、bit8置位(变为1)

int a = 0x123; int b = a|(1<<7)|(1<<8)

在以后操纵寄存器的时候要先清位然后再置位

 1 int main()
 2 {
 3   unsinged int *pGPFCON = (unsigned int *)0x56000050;
 4   unsigned int *pGPFDAT  = (unsigned int *)0x56000054;
 5   /*配置GPF4为输出引脚*/
 6   *pGPFCON = 0x100;
 7   /*配置GPF4输出0*/
 8   *pGPFDAT = 0;            
 9   return 0;  
10 }
 1 .text
 2 .global _start
 3 _start:
 4     /*设置内存:sp栈*/
 5     ldr sp,=4096 /*nand启动*/
 6 //  ldr sp, =0x40000000 /*nor启动*/
 7  /*调用main*/
 8     bl main
 9 halt:
10     b halt
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

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地址处继续执行。


过程中的内存数据情况:

Chapter8 lesson9 001.jpg

 

前面那个例子,汇编调用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, #5r0=5,作为参数;

 bl	58 <led_on>:调到58地址处的led_on函数,并保存下一行代码地址到lr,即lr=58;led_on中会使用到r0;

在上一节视频里,我们编写的程序代码是先点亮led1,然后延时一会,再点亮led2,进入死循环。

但在开发板上的实际效果是led1先亮,延时一会,led2再亮,然后一会之后,led1再次亮了。

这和我们的设计的代码流程不吻合,这是因为2440里面有个看门狗定时器,开发板上电后,需要在一定时间内“喂狗”(设置相应的寄存器),否则就会重启开发板。

之所以这样设计,是为了让芯片出现死机时,能够自己复位,重新运行。


这里我们写个led灯循环的程序,步骤如下:

  1. 这里暂时用不到看门狗,先关闭看门狗,从参考手册可知,向0x53000000寄存器写0即可关闭看门狗;
  2. 设置内存的栈,通过写读操作来判断是Nand Flash还是Nor Flash;
  3. 设置GPFCON让GPF4/5/6配置为输出引脚;
  4. 循环点灯,依次设置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的程序,,步骤如下:

  1. 这里暂时用不到看门狗,先关闭看门狗,从参考手册可知,向0x53000000寄存器写0即可关闭看门狗;
  2. 设置内存的栈,通过写读操作来判断是Nand Flash还是Nor Flash;
  3. 设置GPFCON让GPF4/5/6配置为输出引脚;
  4. 设置3个按键引脚为输入引脚;
  5. 循环执行,读取按键引脚值,点亮对应的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;
}
posted @ 2019-03-01 13:26  夜空的北极星  阅读(245)  评论(0编辑  收藏  举报