第十四课（6）按键中断程序示例

1、中断的处理流程：

（1）初始化中断
1、初始化中断控制器
2、初始化按键，设置为中断源
3、CPU中断使能
cpsr的 I （字母） 位 为 0
（2）处理完后要清中断
（3）处理时，要分辨中断源，执行不同的处理函数

2、编写程序

（1）我们需要把CPSR寄存器 bit7给清零，这是中断的总开关，如果bit7设置为1，CPU无法响应任何中断

start.S

    /* 清除BSS段 */
    bl clean_bss

    /* 复位之后, cpu处于svc模式
     * 现在, 切换到usr模式
     */
    mrs r0, cpsr         /* 读出cpsr */
    bic r0, r0, #0xf     /* 修改M4-M0为0b10000, 进入usr模式 */

/*1
把bit7这一位清零
*/
    bic r0, r0, #(1<<7)  /* 清除I位, 使能中断 */
    msr cpsr, r0

    /* 设置 sp_usr */
    ldr sp, =0x33f00000

    ldr pc, =sdram
sdram:
    bl uart0_init

    bl print1
    /* 故意加入一条未定义指令 */
und_code:
    .word 0xdeadc0de  /* 未定义指令 */
    bl print2

    swi 0x123  /* 执行此命令, 触发SWI异常, 进入0x8执行 */

/*2 调用两个中断 */
    bl interrupt_init /*初始化中断控制器*/
    bl eint_init /*初始化按键，设为中断源*/

/*需要初始化上面这两个函数*/
    //bl main  /* 使用BL命令相对跳转, 程序仍然在NOR/sram执行 */
    ldr pc, =main  /* 绝对跳转, 跳到SDRAM */

halt:
    b halt

（2）初始化按键，设置为中断源：

想要实现的效果：
main循环打印字符串
按下按键，产生中断，执行中断处理函数——按下亮灯/松开灭灯
处理完后 返回main继续打印

①配置引脚
把下面四个按键全部配置为外部中断按键：

P280 打开芯片手册，搜索“EINT0”，外部中断源引脚：
EINT0-GPF0 EINT 2-GPF2 EINT11-GPG3 EINT19-GPG11

②设置中断触发方式：双边沿触发
是高电平发生中断，还是低电平发生中断，还是上升沿下降沿，双边沿发生信号
所以要设置下中断触发方式

③设置EINTMASK使能eint11,19
P306 EINTMASK (External Interrupt Mask Register) 外部中断屏蔽寄存器
EINT0~3是直连到中断控制器的，之后的需要有寄存器去使能中断源。
某一位设置为1后就禁止向中断控制器发送信号

④代码：
interrupt.c

/* 初始化按键, 设为中断源 */
void key_eint_init(void)
{
	/* 配置GPIO为中断引脚 */
	GPFCON &= ~((3<<0) | (3<<4));
	GPFCON |= ((2<<0) | (2<<4));   /* S2,S3被配置为中断引脚 */

	GPGCON &= ~((3<<6) | (3<<22));
	GPGCON |= ((2<<6) | (2<<22));   /* S4,S5被配置为中断引脚 */
	

	/* 设置中断触发方式: 双边沿触发 */
	EXTINT0 |= (7<<0) | (7<<8);     /* S2,S3 */
	EXTINT1 |= (7<<12);             /* S4 */
	EXTINT2 |= (7<<12);             /* S5 */

	/* 设置EINTMASK使能eint11,19 */
	EINTMASK &= ~((1<<11) | (1<<19));
	

（2）初始化中断控制器

①P378中断流程图：

P380 INTERRUPT SOURCES

由表格看出 EINIT4-7合用一条线，EINT8_23合用一条线

那么我们中断源是哪种流程呢？
从P380 我们的EITN0 EINT2 EINT11 EINT19 在INTERRUPT SOURCES表格里，不在INTERRUPT SUB SOURCES表格里，因此我们的中断源不需要经过sub-register。

②从流程图中，知道要设置的寄存器：
所以，我们只需要设置：
MASK 用来屏蔽中断
INTPND 等待处理，用来显示当前优先级最高的、正在发生的中断, 需要清除对应位
SRCPND 用来显示哪个中断源向 CPU 申请了中断， 需要清除对应位

INTERRUPT OFFSET (INTOFFSET) REGISTER ==>用来显示 INTPND 中哪一位被设置为1，如果读 INTPND 去知道是哪一位被设置为1需要逐位判断，显然很麻烦。

③代码：
interrupt.c

/* 初始化中断控制器 */
void interrupt_init(void)
{
	INTMSK &= ~((1<<0) | (1<<2) | (1<<5));
}

（3）start.S全部代码:

1、我们把中断初始化放到C函数里，能用C语言的就用C
/* 2 调用两个中断 * /
bl interrupt_init /* 初始化中断控制器 * /
bl eint_init / * 初始化按键，设为中断源 * /
2、P80 IRQ 的返回地址==>SUBS PC, R14_irq, #4

.text
.global _start

_start:
	b reset          /* vector 0 : reset */
	ldr pc, und_addr /* vector 4 : und */
	ldr pc, swi_addr /* vector 8 : swi */
	b halt			 /* vector 0x0c : prefetch aboot */
	b halt			 /* vector 0x10 : data abort */
	b halt			 /* vector 0x14 : reserved */
	ldr pc, irq_addr /* vector 0x18 : irq */
	b halt			 /* vector 0x1c : fiq */

und_addr:
	.word do_und

swi_addr:
	.word do_swi

irq_addr:
	.word do_irq

do_und:
	/* 执行到这里之前:
	 * 1. lr_und保存有被中断模式中的下一条即将执行的指令的地址
	 * 2. SPSR_und保存有被中断模式的CPSR
	 * 3. CPSR中的M4-M0被设置为11011, 进入到und模式
	 * 4. 跳到0x4的地方执行程序 
	 */

	/* sp_und未设置, 先设置它 */
	ldr sp, =0x34000000

	/* 在und异常处理函数中有可能会修改r0-r12, 所以先保存 */
	/* lr是异常处理完后的返回地址, 也要保存 */
	stmdb sp!, {r0-r12, lr}  
	
	/* 保存现场 */
	/* 处理und异常 */
	mrs r0, cpsr
	ldr r1, =und_string
	bl printException
	
	/* 恢复现场 */
	ldmia sp!, {r0-r12, pc}^  /* ^会把spsr的值恢复到cpsr里 */
	
und_string:
	.string "undefined instruction exception"

.align 4

do_swi:
	/* 执行到这里之前:
	 * 1. lr_svc保存有被中断模式中的下一条即将执行的指令的地址
	 * 2. SPSR_svc保存有被中断模式的CPSR
	 * 3. CPSR中的M4-M0被设置为10011, 进入到svc模式
	 * 4. 跳到0x08的地方执行程序 
	 */

	/* sp_svc未设置, 先设置它 */
	ldr sp, =0x33e00000

	/* 保存现场 */
	/* 在swi异常处理函数中有可能会修改r0-r12, 所以先保存 */
	/* lr是异常处理完后的返回地址, 也要保存 */
	stmdb sp!, {r0-r12, lr}  

	mov r4, lr
	
	/* 处理swi异常 */
	mrs r0, cpsr
	ldr r1, =swi_string
	bl printException

	sub r0, r4, #4
	bl printSWIVal
	
	/* 恢复现场 */
	ldmia sp!, {r0-r12, pc}^  /* ^会把spsr的值恢复到cpsr里 */
	
swi_string:
	.string "swi exception"

.align 4

do_irq:
	/* 执行到这里之前:
	 * 1. lr_irq保存有被中断模式中的下一条即将执行的指令的地址
	 * 2. SPSR_irq保存有被中断模式的CPSR
	 * 3. CPSR中的M4-M0被设置为10010, 进入到irq模式
	 * 4. 跳到0x18的地方执行程序 
	 */

	/* sp_irq未设置, 先设置它 */
	ldr sp, =0x33d00000

	/* 保存现场 */
	/* 在irq异常处理函数中有可能会修改r0-r12, 所以先保存 */
	/* lr-4是异常处理完后的返回地址, 也要保存 */
	sub lr, lr, #4
	stmdb sp!, {r0-r12, lr}  
	
	/* 处理irq异常 */
	bl handle_irq_c
	
	/* 恢复现场 */
	ldmia sp!, {r0-r12, pc}^  /* ^会把spsr_irq的值恢复到cpsr里 */


reset:
	/* 关闭看门狗 */
	ldr r0, =0x53000000
	ldr r1, =0
	str r1, [r0]

	/* 设置MPLL, FCLK : HCLK : PCLK = 400m : 100m : 50m */
	/* LOCKTIME(0x4C000000) = 0xFFFFFFFF */
	ldr r0, =0x4C000000
	ldr r1, =0xFFFFFFFF
	str r1, [r0]

	/* CLKDIVN(0x4C000014) = 0X5, tFCLK:tHCLK:tPCLK = 1:4:8  */
	ldr r0, =0x4C000014
	ldr r1, =0x5
	str r1, [r0]

	/* 设置CPU工作于异步模式 */
	mrc p15,0,r0,c1,c0,0
	orr r0,r0,#0xc0000000   //R1_nF:OR:R1_iA
	mcr p15,0,r0,c1,c0,0

	/* 设置MPLLCON(0x4C000004) = (92<<12)|(1<<4)|(1<<0) 
	 *  m = MDIV+8 = 92+8=100
	 *  p = PDIV+2 = 1+2 = 3
	 *  s = SDIV = 1
	 *  FCLK = 2*m*Fin/(p*2^s) = 2*100*12/(3*2^1)=400M
	 */
	ldr r0, =0x4C000004
	ldr r1, =(92<<12)|(1<<4)|(1<<0)
	str r1, [r0]

	/* 一旦设置PLL, 就会锁定lock time直到PLL输出稳定
	 * 然后CPU工作于新的频率FCLK
	 */
	
	

	/* 设置内存: 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 sdram_init
	//bl sdram_init2	 /* 用到有初始值的数组, 不是位置无关码 */

	/* 重定位text, rodata, data段整个程序 */
	bl copy2sdram

	/* 清除BSS段 */
	bl clean_bss

	/* 复位之后, cpu处于svc模式
	 * 现在, 切换到usr模式
	 */
	mrs r0, cpsr         /* 读出cpsr */
	bic r0, r0, #0xf     /* 修改M4-M0为0b10000, 进入usr模式 */
	bic r0, r0, #(1<<7)  /* 清除I位, 使能中断 */
	msr cpsr, r0

	/* 设置 sp_usr */
	ldr sp, =0x33f00000

	ldr pc, =sdram
sdram:
	bl uart0_init

	bl print1
	/* 故意加入一条未定义指令 */
und_code:
	.word 0xdeadc0de  /* 未定义指令 */
	bl print2

	swi 0x123  /* 执行此命令, 触发SWI异常, 进入0x8执行 */

	//bl main  /* 使用BL命令相对跳转, 程序仍然在NOR/sram执行 */
	ldr pc, =main  /* 绝对跳转, 跳到SDRAM */

halt:
	b halt	

（4）中断处理函数

任务：
分辨中断源 ==> 读INTERRUPT OFFSET (INTOFFSET) REGISTER
调用对应的处理函数
清除中断 ==> 看中断流程图，我们要从左往右清除中断，先清中断源EINTPEND，然后SRCPND，最后清INPEND

疑惑：为什么需要清除中断？
要靠查询中断标志来判断是否要进入中断，如果你不清除中断标志，本次中断退出，又会检测到中断标志，因此重复进入中断。

为什么是向INPND和SRCPND置1而不是置0？
通过网上搜索，我大概理解为：
2440芯片开发商如此设定，读取该寄存器时，当某一位为1时，表示发生中断，但是如果要清除该位中断标识里，要向这一位写1，写1后再读这个寄存器时，这一位就成0了。
对于用户来说，这种操作方式的优点是只经过一次写操作就可以达到目的，而不需要像传统的“读-修改-写”操作，这样显得更加高效。
反正大概意思就是人家这么设定，我们这么做，就可以了。

void key_init_irq(int irq)
{
	unsigned int val = EINTPEND;	
	unsigned int val1 = GPFDAT; 
	unsigned int val2 = GPGDAT;
	
	if(irq == 0)   //EINT0-GPF0-S2控制GPF6-D12
	{
		
		if(val1 & (1<<0)) //S2按下
			GPFDAT |= (1<<6);
		else //S2松开			
			GPFDAT &= ~(1<<6);
		
	}
	else if(irq== 2)  //EINT2-GPF2-S3控制GPF5-D11
	{
		if(val1 & (1<<2)) //S3按下
			GPFDAT |= (1<<5);
		else //S3松开		
			GPFDAT &= ~(1<<5);

	}
	else if(irq == 5) //EINT11-GPG3-S4控制GPF4-D10 EINT19-GPG11-S5控制所有LED
	{
		/* 注意：需要由EINTPEND进一步分辨是哪一个中断源产生 */
		
		if(val & (1<<11)) //表明EINT11产生
		{
			if(val2 & (1<<3)) //S4按下
				GPFDAT |= (1<<4);
			else //S4松开
				GPFDAT &= ~(1<<4);			
		}
		else if(val & (1<<19))
		{
			if(val2 & (1<<11)) //S5按下
				GPFDAT |= ((1<<4) | (1<<5) | (1<<6));
			else //S5松开		
				GPFDAT &= ~((1<<4) | (1<<5) | (1<<6));
		}
	}
	
	/* 清中断源EINTPEND */
	EINTPEND = val;
}

main.c

#include "s3c2440_soc.h"
#include "uart.h"
#include "init.h"

char g_Char = 'A';
char g_Char3 = 'a';
const char g_Char2 = 'B';
int g_A = 0;
int g_B;

int main(void)
{
	led_init();
	interrupt_init();  /* 初始化中断控制器 */
	key_eint_init();   /* 初始化按键, 设为中断源 */
	
	puts("\n\rg_A = ");
	printHex(g_A);
	puts("\n\r");

	while (1)
	{
#if 0		
		puts("\n\rg_Char = ");
		printHex(g_Char);
		puts("\n\r");


		puts("\n\rg_Char3 = ");
		printHex(g_Char3);
		puts("\n\r");
#endif
		putchar(g_Char);
		g_Char++;

		putchar(g_Char3);
		g_Char3++;
		delay(1000000);
	}

	
	return 0;
}