“第008课 第1个ARM裸板程序及引申(部分免费)”的版本间的差异

来自百问网嵌入式Linux wiki
 
(未显示3个用户的23个中间版本)
第1行: 第1行:
 +
<div body style="width:800px;">
 
= 第001节_辅线1_硬件知识_LED原理图 =
 
= 第001节_辅线1_硬件知识_LED原理图 =
  
第10行: 第11行:
  
 
先来讲讲怎么看原理图:
 
先来讲讲怎么看原理图:
LED样子有很多种,像插脚的,贴片的。
+
LED样子有很多种,像插脚的,贴片的。<br>
![](./lesson/lesson1/lesson1_001.jpg)
+
[[File:chapter8_lesson1_001.jpg|800px]]
 
它们长得完全不一样,因此我们在原理图中将它抽象出来。
 
它们长得完全不一样,因此我们在原理图中将它抽象出来。
  
 
点亮LED需要通电源,同时为了保护LED,加个电阻减小电流。
 
点亮LED需要通电源,同时为了保护LED,加个电阻减小电流。
控制LED灯的亮灭,可以手动开关LED,但在电子系统中,不可能让人来控制开关,通过编程,利用芯片的引脚去控制开关。
+
控制LED灯的亮灭,可以手动开关LED,但在电子系统中,不可能让人来控制开关,通过编程,利用芯片的引脚去控制开关。<br>
![](./lesson/lesson1/lesson1_002.jpg)
+
 
 +
[[File:chapter8_lesson1_002.jpg|800px]]
  
 
LED的驱动方式,常见的有四种。
 
LED的驱动方式,常见的有四种。
方式1:使用引脚输出3.3V点亮LED,输出0V熄灭LED。
+
 
方式2:使用引脚拉低到0V点亮LED,输出3.3V熄灭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。
+
* 方式3:使用引脚输出1.2V点亮LED,输出0V熄灭LED。
![](./lesson/lesson1/lesson1_003.png)
+
 
 +
* 方式4:使用引脚输出0V点亮LED,输出1.2V熄灭LED。<br>
 +
 
 +
 
 +
[[File:chapter8_lesson1_003.png|800px]]
  
 
由此,主芯片引脚输出高电平/低电平,即可改变LED状态,而无需关注GPIO引脚输出的是3.3V还是1.2V。
 
由此,主芯片引脚输出高电平/低电平,即可改变LED状态,而无需关注GPIO引脚输出的是3.3V还是1.2V。
 
所以简称输出1或0:
 
所以简称输出1或0:
逻辑1-->高电平
+
 
逻辑0-->低电平
+
* 逻辑1-->高电平
 +
 
 +
* 逻辑0-->低电平
  
 
=第002节_辅线1_硬件知识_S3C2440启动流程与GPIO操作 =
 
=第002节_辅线1_硬件知识_S3C2440启动流程与GPIO操作 =
  
 
在原理图中,同名的Net表示是连在一起的。
 
在原理图中,同名的Net表示是连在一起的。
 +
  
 
怎么样GPF4怎么输出1或0?
 
怎么样GPF4怎么输出1或0?
 +
 
1. 配置为输出引脚;
 
1. 配置为输出引脚;
 +
 
2. 设置状态;
 
2. 设置状态;
 +
  
 
因此,设置GPFCON[9:8]=0b01,即GPF4配置为输出;
 
因此,设置GPFCON[9:8]=0b01,即GPF4配置为输出;
 +
 
设置GPFDAT[4]=1或者0,即输出高电平或低电平;
 
设置GPFDAT[4]=1或者0,即输出高电平或低电平;
 +
 +
  
 
S3C2440框架:
 
S3C2440框架:
![](./lesson/lesson2/lesson2_001.png)
+
 
 +
[[File:chapter8_lesson2_001.png|800px]]
 +
 
 +
 
  
 
S3C2440启动流程:
 
S3C2440启动流程:
Nor启动:
+
 
 +
* Nor启动:
 +
 
 
Nor Flash的基地址为0,片内RAM地址为0x4000 0000;
 
Nor Flash的基地址为0,片内RAM地址为0x4000 0000;
 +
 
CPU读出Nor上第1个指令(前4字节),执行;
 
CPU读出Nor上第1个指令(前4字节),执行;
 +
 
CPU继续读出其它指令执行。
 
CPU继续读出其它指令执行。
  
②Nand启动:
+
 
 +
 
 +
* Nand启动:
 +
 
 
片内4k RAM基地址为0,Nor Flash不可访问;
 
片内4k RAM基地址为0,Nor Flash不可访问;
 +
 
2440硬件把Nand前4K内容复制到片内的RAM,然后CPU从0地址取出第1条指令执行。
 
2440硬件把Nand前4K内容复制到片内的RAM,然后CPU从0地址取出第1条指令执行。
 
  
 
= 第003节_编写第1个程序点亮LED =
 
= 第003节_编写第1个程序点亮LED =
  
 
在开始写第1个程序前,先了解一些概念。
 
在开始写第1个程序前,先了解一些概念。
 +
 
2440是一个SOC,它里面的CPU有R1、R2、R3……等 寄存器;
 
2440是一个SOC,它里面的CPU有R1、R2、R3……等 寄存器;
 +
 
它里面的GPIO控制器也有很多寄存器,如 GPFCON、GPFDAT。
 
它里面的GPIO控制器也有很多寄存器,如 GPFCON、GPFDAT。
 +
 
这两个寄存器是有差异的,在写代码的时候,CPU里面的寄存器可以直接访问,其它的寄存器要以地址进行访问。
 
这两个寄存器是有差异的,在写代码的时候,CPU里面的寄存器可以直接访问,其它的寄存器要以地址进行访问。
 +
  
 
把GPF4配置为输出,需要把0x100写入GPFCON这个寄存器,即写到0x5600 0050上;
 
把GPF4配置为输出,需要把0x100写入GPFCON这个寄存器,即写到0x5600 0050上;
 +
 
把GPF4输出1,需要把0x10写到地址0x5600 0054上;
 
把GPF4输出1,需要把0x10写到地址0x5600 0054上;
 +
 
把GPF4输出0,需要把0x00写到地址0x5600 0054上;
 
把GPF4输出0,需要把0x00写到地址0x5600 0054上;
 +
 
这里的写法会破坏寄存器的其它位,其它位是控制其它引脚的,为了让第一个裸板程序尽可能的简单,才简单粗暴的这样处理。
 
这里的写法会破坏寄存器的其它位,其它位是控制其它引脚的,为了让第一个裸板程序尽可能的简单,才简单粗暴的这样处理。
 +
  
 
写程序需要用到几条汇编代码:
 
写程序需要用到几条汇编代码:
①LDR  (load):读寄存器
+
 
举例:LDR R0,[R1]
+
①LDR  (load):读寄存器
 +
 
 +
举例:<code>LDR R0,[R1]</code>
 +
 
 
假设R1的值是x,读取地址x上的数据(4字节),保存到R0中;
 
假设R1的值是x,读取地址x上的数据(4字节),保存到R0中;
  
②STR  (store):写寄存器
+
 
举例:STR R0,[R1]
+
②STR  (store):写寄存器
 +
 
 +
举例:<code>STR R0,[R1]</code>
 +
 
 
假设R1的值是x,把R0的值写到地址x(4字节);
 
假设R1的值是x,把R0的值写到地址x(4字节);
  
③B  跳转
 
  
  ④MOV  (move)移动,赋值
+
③B 跳转
举例1:MOV R0,R1  
+
 
 +
 
 +
④MOV  (move)移动,赋值
 +
举例1:<code>MOV R0,R1</code>
 
把R1的值赋值给R0;
 
把R1的值赋值给R0;
举例2:MOV R0,#0x100  
+
 
 +
举例2:<code>MOV R0,#0x100</code>
 
把0x100赋值给R0,即R0=0x100;
 
把0x100赋值给R0,即R0=0x100;
  
⑤LDR   
+
 
举例:
+
⑤LDR  
LDR R0,=0x12345678
+
   
 +
举例:<code>LDR R0,=0x12345678</code>
 
这是一条伪指令,即实际中并不存在这个指令,他会被拆分成几个真正的ARM指令,实现一样的效果。
 
这是一条伪指令,即实际中并不存在这个指令,他会被拆分成几个真正的ARM指令,实现一样的效果。
 
最后结果是R0=0x12345678。
 
最后结果是R0=0x12345678。
 +
  
 
为什么会引入伪指令?<br>
 
为什么会引入伪指令?<br>
第95行: 第141行:
  
 
有了前面5个汇编指令的基础,我们就可以写代码了。
 
有了前面5个汇编指令的基础,我们就可以写代码了。
 +
 
第一个程序只能是汇编,以前你们可能写过单片机程序,一上来就写main()函数,那是编译器帮你封装好了。
 
第一个程序只能是汇编,以前你们可能写过单片机程序,一上来就写main()函数,那是编译器帮你封装好了。
 +
 +
 
第一个LED程序代码如下:
 
第一个LED程序代码如下:
  
第152行: 第201行:
 
= 第004节_汇编与机器码 =
 
= 第004节_汇编与机器码 =
  
前面介绍过伪指令,伪指令是实际不存在的ARM命令,编译器在编译时转换成存在的ARM指令。我们代码中的`ldr r1, =0x56000050`这条伪指令的真实指令时什么呢?
+
前面介绍过伪指令,伪指令是实际不存在的ARM命令,编译器在编译时转换成存在的ARM指令。我们代码中的<code>ldr r1, =0x56000050</code>这条伪指令的真实指令时什么呢?
 +
 
 
我们可以通过反汇编来查看。
 
我们可以通过反汇编来查看。
 +
 +
 
在前面的Makefile中加上:
 
在前面的Makefile中加上:
  
第159行: 第211行:
  
 
上传服务器,编译。
 
上传服务器,编译。
 +
 
生成的led_on.dis就是反汇编文件。led_on.dis如下:
 
生成的led_on.dis就是反汇编文件。led_on.dis如下:
<syntaxhighlight lang="c" >
+
<syntaxhighlight lang="s" >
 
led_on.elf:    file format elf32-littlearm
 
led_on.elf:    file format elf32-littlearm
  
第178行: 第231行:
 
   20: 56000054 undefined
 
   20: 56000054 undefined
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
 
第一列是地址,第二列是机器码,第三列是汇编;
 
第一列是地址,第二列是机器码,第三列是汇编;
  
在反汇编文件里可以看到,`ldr r1, =0x56000050`被转换成`ldr r1, [pc, #20]`,`pc+20`地址的值为0x56000050,通过这种方式为r1赋值。
+
 
对于立即数0x100而言,`ldr r0,=0x100`即是转换成了`mov r0,#256`;
+
在反汇编文件里可以看到,<code>ldr r1, =0x56000050</code>被转换成<code>ldr r1, [pc, #20]</code>,<code>pc+20</code>地址的值为0x56000050,通过这种方式为r1赋值。
 +
对于立即数0x100而言,<code>ldr r0,=0x100</code>即是转换成了<code>mov r0,#256</code>;
  
 
在2440这个SOC里面,R0-R15都在CPU里面,其中:
 
在2440这个SOC里面,R0-R15都在CPU里面,其中:
第188行: 第243行:
 
  R15  别名:pc (program Counter)程序计数器=当前指令+8
 
  R15  别名:pc (program Counter)程序计数器=当前指令+8
  
==为什么 PC=当前指令+8?==
+
 
 +
 
 +
为什么 '''PC=当前指令+8'''?
 +
 
 
ARM指令采用流水线机制,当前执行地址A的指令,已经在对地址A+4的指令进行译码,已经在读取地址A+8的指令,其中A+8就是PC的值。
 
ARM指令采用流水线机制,当前执行地址A的指令,已经在对地址A+4的指令进行译码,已经在读取地址A+8的指令,其中A+8就是PC的值。
 +
  
 
C/汇编(给人类方便使用的语言)———编译器———>bin,含有机器码(给CPU使用)
 
C/汇编(给人类方便使用的语言)———编译器———>bin,含有机器码(给CPU使用)
  
 +
=第005节_编程知识_进制 =
 +
 +
17个苹果,有4种表示方式,它们表示同一个数值:
 +
[[File:chapter8_lesson5_001.png|800px]]
 +
*计算验证:
 +
十进制: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;
  
 +
* 为何引入二进制?<br>
 +
在硬件角度看,晶体管只有两个状态:on是1,off是0;
 +
数据使用多个晶体管进行表示,用二进制描述,吻合硬件状态。
  
 +
* 为何引入八进制?<br>
 +
将二进制的三位作为一组,把这一组作为一位进行表示,就是八进制。
 +
 +
* 为何引入十六进制?<br>
 +
将二进制的四位作为一组,把这一组作为一位进行表示,就是十六进制。八进制和十六进制方便我们描述,简化了长度。
 +
 +
 +
如何快速的转换2/8/16进制:
 +
首先记住'''8 4 2 1 ——>二进制权重'''
 +
 +
*举例1:
 +
将二进制0b01101110101转换成八进制:
 +
将二进制从右到左,每三个分成一组:
 +
[[File:chapter8_lesson5_002.png]]
 +
 +
结果就是1565;
 +
 +
 +
*举例2:
 +
将二进制0b01101110101转换成十六进制:
 +
将二进制从右到左,每四个分成一组:<br>
 +
[[File:chapter8_lesson5_003.png]]
 +
 +
结果就是375;
 +
 +
 +
*举例3:
 +
将十六进制0xABC1转换成二进制:
 +
将十六进制从右到左,每个分成四位:<br>
 +
[[File:chapter8_lesson5_004.png]]
 +
 +
结果就是1010 1011 1100 0001;
 +
 +
 +
 +
在C语言中怎么表示这些进制呢?<br>
 +
十进制: int a = 96;
 +
八进制: int a = 0140;//0开头
 +
十六进制: int a = 0x60;//0x开头
 +
 +
用0b开头表示二进制,约定俗成的规定。
 +
 +
=第006节_编程知识_字节序_位操作 =
 +
 +
* 字节序:
 +
假设<code>int a = 0x12345678;</code>
 +
 +
前面说了16进制每位是4个bit,在内存中,是以8个bit作为1byte进行存储的,因此0x12345678中每两位作为1byte,其中0x78是低位,0x12是高位。
 +
 +
在内存中的存储方式有两种:<br>
 +
[[File:chapter8_lesson6_001.png|700px]]
 +
 +
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语言的指针操作:
 +
 +
①所有的变量在内存中都有一块区域;
 +
 +
②可以通过变量/指针操作内存;
 +
 +
[[File:chapter8_lesson7_001.png|700px]]
 +
TYPE *p = val1;
 +
*p = val2;
 +
 +
把val2写入地址val1的内存中,写入<code>sizeof(TYPE)</code>字节;
 +
 +
TYPE *p = addr;
 +
*p = val;
 +
 +
把val写入地址addrd的内存,,写入<code>sizeof(TYPE)</code>字节;
 +
 +
 +
a. 我们写出了main函数, 谁来调用它?
 +
b. main函数中变量保存在内存中, 这个内存地址是多少?
 +
答: 我们还需要写一个汇编代码, 给main函数设置内存, 调用main函数
 +
 +
led.c源码:
 +
<syntaxhighlight lang="c" >
 +
int main()
 +
{
 +
    unsigned int *pGPFCON = (unsigned int *)0x56000050;
 +
    unsigned int *pGPFDAT = (unsigned int *)0x56000054;
 +
 +
    /*配置GPF4为输出引脚*/
 +
    *pGPFCON = 0x100;
 +
   
 +
    /*配置GPF4输出0*/
 +
    *pGPFDAT = 0;
 +
 +
    return 0;
 +
}
 +
 +
</syntaxhighlight>
 +
 +
start.S源码:
 +
<syntaxhighlight lang="c" >
 +
.text
 +
.global _start
 +
_start:
 +
    /*设置内存:sp栈*/
 +
    ldr sp,=4096 /*nand启动*/
 +
//  ldr sp, =0x40000000 /*nor启动*/
 +
 +
    /*调用main*/
 +
    bl main
 +
halt:
 +
    b halt
 +
</syntaxhighlight>
 +
 +
 +
Makefile源码:
 +
<syntaxhighlight lang="c" >
 +
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
 +
 +
</syntaxhighlight>
 +
最后将上面三个文件放入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意思是先减后存,按 高编号寄存器存在高地址 存。
 +
[[File:chapter8_lesson8_001.png|700px]]
 +
 +
 +
举例2:
 +
ldmia sp, (fp,ip,pc)
 +
 +
[[File:chapter8_lesson8_002.png|700px]]
 +
 +
=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:
 +
<syntaxhighlight lang="c" >
 +
.text
 +
.global _start
 +
 +
_start:
 +
 +
/* 设置内存: sp 栈 */
 +
ldr sp, =4096  /* nand启动 */
 +
// ldr sp, =0x40000000+4096  /* nor启动 */
 +
 +
/* 调用main */
 +
bl main
 +
 +
halt:
 +
b halt
 +
</syntaxhighlight>
 +
 +
led.c:
 +
 +
<syntaxhighlight lang="c" >
 +
int main()
 +
{
 +
unsigned int *pGPFCON = (unsigned int *)0x56000050;
 +
unsigned int *pGPFDAT = (unsigned int *)0x56000054;
 +
 +
/* 配置GPF4为输出引脚 */
 +
*pGPFCON = 0x100;
 +
 +
/* 设置GPF4输出0 */
 +
*pGPFDAT = 0;
 +
 +
return 0;
 +
}
 +
</syntaxhighlight>
 +
 +
将前面的程序反汇编得到led.dis如下:
 +
<syntaxhighlight lang="c" >
 +
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.
 +
</syntaxhighlight>
 +
 +
分析上面的汇编代码:
 +
 +
开发板上电后,将从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地址处继续执行。
 +
 +
 +
过程中的内存数据情况:
 +
 +
[[File:chapter8_lesson9_001.jpg|400px]]
 +
 +
 +
 +
前面那个例子,汇编调用main.c并没有传递参数,这里修改下c程序,让其传递参数。
 +
 +
start.S:
 +
<syntaxhighlight lang="c" >
 +
.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
 +
 +
 +
</syntaxhighlight>
 +
led.c:
 +
<syntaxhighlight lang="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;
 +
}
 +
 +
</syntaxhighlight>
 +
led.elf:
 +
 +
<syntaxhighlight lang="c" >
 +
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.
 +
</syntaxhighlight>
 +
 +
简单分析下反汇编:
 +
<syntaxhighlight lang="c" >
 +
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;
 +
 +
</syntaxhighlight>
  
 
=010节_完善LED程序_编写按键程序 =
 
=010节_完善LED程序_编写按键程序 =
 
在上一节视频里,我们编写的程序代码是先点亮led1,然后延时一会,再点亮led2,进入死循环。
 
在上一节视频里,我们编写的程序代码是先点亮led1,然后延时一会,再点亮led2,进入死循环。
 +
 
但在开发板上的实际效果是led1先亮,延时一会,led2再亮,然后一会之后,led1再次亮了。
 
但在开发板上的实际效果是led1先亮,延时一会,led2再亮,然后一会之后,led1再次亮了。
这和我们的设计的代码流程不吻合,这是因为2440里面有个看门狗定时器,开发板上电后,需要在一定时间内“喂狗”(设置相应的寄存器),负责就会重启开发板。之所以这样设计,是为了让芯片出现死机时,能够自己复位,重新运行。
+
 
 +
这和我们的设计的代码流程不吻合,这是因为2440里面有个看门狗定时器,开发板上电后,需要在一定时间内“喂狗”(设置相应的寄存器),否则就会重启开发板。
 +
 
 +
之所以这样设计,是为了让芯片出现死机时,能够自己复位,重新运行。
 +
 
  
 
这里我们写个led灯循环的程序,步骤如下:
 
这里我们写个led灯循环的程序,步骤如下:
第287行: 第896行:
 
# 设置3个按键引脚为输入引脚;
 
# 设置3个按键引脚为输入引脚;
 
# 循环执行,读取按键引脚值,点亮对应的led灯;
 
# 循环执行,读取按键引脚值,点亮对应的led灯;
 +
  
 
完整代码如下:
 
完整代码如下:
第357行: 第967行:
 
}
 
}
 
</syntaxhighlight>
 
</syntaxhighlight>
 +
</div>
 
='''《《所有章节目录》》'''=
 
='''《《所有章节目录》》'''=
 
<categorytree mode=all background-color:white;">ARM裸机加强版</categorytree>
 
<categorytree mode=all background-color:white;">ARM裸机加强版</categorytree>
 
[[Category:ARM裸机加强版 ]]
 
[[Category:ARM裸机加强版 ]]

2019年2月14日 (四) 14:16的最新版本

第001节_辅线1_硬件知识_LED原理图

当我们学习C语言的时候,我们会写个Hello程序。那当我们写ARM程序,也该有一个简单的程序引领我们入门,这个程序就是点亮LED。

我们怎样去点亮一个LED呢? 分为三步:

  1. 看原理图,确定控制LED的引脚;
  2. 看主芯片的芯片手册,确定如何设置控制这个引脚;
  3. 写程序;

先来讲讲怎么看原理图: LED样子有很多种,像插脚的,贴片的。
Chapter8 lesson1 001.jpg 它们长得完全不一样,因此我们在原理图中将它抽象出来。

点亮LED需要通电源,同时为了保护LED,加个电阻减小电流。 控制LED灯的亮灭,可以手动开关LED,但在电子系统中,不可能让人来控制开关,通过编程,利用芯片的引脚去控制开关。

Chapter8 lesson1 002.jpg

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。


Chapter8 lesson1 003.png

由此,主芯片引脚输出高电平/低电平,即可改变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框架:

Chapter8 lesson2 001.png


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种表示方式,它们表示同一个数值: Chapter8 lesson5 001.png

  • 计算验证:
十进制: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转换成八进制: 将二进制从右到左,每三个分成一组: Chapter8 lesson5 002.png

结果就是1565;


  • 举例2:

将二进制0b01101110101转换成十六进制: 将二进制从右到左,每四个分成一组:
Chapter8 lesson5 003.png

结果就是375;


  • 举例3:

将十六进制0xABC1转换成二进制: 将十六进制从右到左,每个分成四位:
Chapter8 lesson5 004.png

结果就是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是高位。

在内存中的存储方式有两种:
Chapter8 lesson6 001.png

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语言的指针操作:

①所有的变量在内存中都有一块区域;

②可以通过变量/指针操作内存;

Chapter8 lesson7 001.png

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意思是先减后存,按 高编号寄存器存在高地址 存。 Chapter8 lesson8 001.png


举例2:

ldmia sp, (fp,ip,pc)

Chapter8 lesson8 002.png

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


过程中的内存数据情况:

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;

010节_完善LED程序_编写按键程序

在上一节视频里,我们编写的程序代码是先点亮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;
}