裸机：按键和CPU的中断系统

于 2024-08-26 22:15:00 发布
阅读量327 收藏 21
点赞数 9
分类专栏： 嵌入式 文章标签： 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43441284/article/details/141403835
版权

按键的2种响应方法

(1)SoC处理按键有2种思路：轮询方式和中断方式。
(2)轮询方式，就是SoC主动的每隔一段时间去读取（按键所对应的）GPIO的电平高低，以此获得按键信息；缺点在于CPU要一直注意按键事件，会影响CPU做其他事情。
(3)中断方式，就是SoC事先设定好GPIO触发的中断所对应的中断处理程序ISR，当外部按键按下或弹开时会自动触发GPIO对应的外部中断，导致ISR执行，从而自动处理按键信息。

轮询方式处理按键

找到按键对应的GPIO：SW5:GPH0_2 SW6:GPH0_3
SW78910:GPH2_0123
原理图上可以看出：按下时是低电平，弹起时是高电平
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

GPH0CON(0xE0200C00) GPH2DAT(0xE0200C04) GPH2CON(0xE0200C40) GPH2DAT(0xE0200C44)
应该在CON寄存器中将GPIO设置为input模式，然后去读取DAT寄存器（读取到的相应位的值为1表示外部是高电平（对应按键弹起），读取到的位的值为0表明外部是低电平（按键按下））

轮询方式处理按键的程序流程
(1)第一步，先初始化GPIO模式为input；
(2)第二步，循环读取GPIO的电平值，然后判断有无按键按下
key.c

//操作寄存器的宏

#define GPH0CON		0xE0200C00
#define GPH0DAT		0xE0200C04

#define GPH2CON		0xE0200C40
#define GPH2DAT		0xE0200C44

#define rGPH0CON	(*(volatile unsigned int *)GPH0CON)
#define rGPH0DAT	(*(volatile unsigned int *)GPH0DAT)
#define rGPH2CON	(*(volatile unsigned int *)GPH2CON)
#define rGPH2DAT	(*(volatile unsigned int *)GPH2DAT)

//初始化
void key_init(void)
{
	// GPH0CON 的bit8~15全部设备为0 设置为输入模式
	rGPH0CON &= ~(0xFF<<8);//1取反就是0 
	// GPH2CON 的bit1~15全部设备为0 设置为输入模式
	rGPH2CON &= ~(0xFFFF<<0);
}

//轮询按键
void key_polling(void)
{
	// 依次读取GPIO的值 0 就是按下 1就是松开
	while (1)
	{
		//GPH0DAT 判断bit2 
		if (rGPH0DAT & (1<<2))
		{
			// 为1没有按下
			led_off();
		}
		else
		{
			//0就是按下
			led_on();
			putc('2');
		}
		
		//GPH0DAT 判断bit3 
		if (rGPH0DAT & (1<<3))
		{
			// 为1没有按下
			led_off();
		}
		else
		{
			//0就是按下
			led_on();
			putc('3');
		}
		
		//GPH2DAT 判断bit0 
		if (rGPH2DAT & (1<<0))
		{
			// 为1没有按下
			led_off();
		}
		else
		{
			//0就是按下
			led_on();
			putc('0');
		}
	}
}

轮询成功
在这里插入图片描述

按键消抖

(1)按键这种物理器件本身会有抖动信号，抖动信号指的是在电平由高到低（也就是按键按下时）或者电平由低到高（也就是按键弹起时）过程中，电平的变化不是立刻变化，而是经过了一段时间的不稳定期才完成变化，在这个不稳定期间电平可能会时高时低反复变化，这个不稳定期就叫抖动（抖动期内获取按键信息是不可靠的，要想办法消抖）。
(2)什么叫消抖？消抖就是用硬件或者软件方法来尽量减小抖动期对按键获取的影响。消抖常用2种思路：第一是硬件消抖，消抖思路就是尽量减小抖动时间，方法是通过硬件添加电容等元件来减小抖动；第二是软件消抖，消抖思路是发现一次按键按下/弹起事件后，不立即处理按键，而是延时一段时间（一般10～20ms，这就是消抖时间）后再次获取按键键值，如果此次获取和上次一样是按下/弹起，那就认为真的按下/弹起了。

//GPH0DAT 判断bit2 
		if (rGPH0DAT & (1<<2))
		{
			// 为1没有按下
			delay20ms();
			if (rGPH0DAT & (1<<2)){//确实是按下
				led_off();
			}
		}
		else
		{
			//0就是按下
			delay20ms();
			if (!(rGPH0DAT & (1<<2))){//确实是按下
				led_on();
				putc('2');
			}

		}

什么是中断

中断是计算机运行过程中一种重要的机制，用于响应和处理突发事件或紧急事件。具体来说，中断是指当计算机正在执行某个程序时，由于内部或外部事件的触发，会暂时中止当前程序的执行，转而处理这一事件。当事件处理完毕后，计算机会返回到被中断的程序，并从原断点处继续执行。

中断的分类
按照来源分类：
内部中断：由处理器内部的模块或事件引发，如定时器溢出、串口接收缓冲区非空等。内部中断主要用于定期执行特定任务、检测状态变化等。
外部中断：由外部设备或外部信号引发，如按键按下、外部传感器信号变化等。外部中断用于响应外部事件，并及时处理相关任务。
按照可屏蔽性分类：
可屏蔽中断：可由程序控制其屏蔽的中断。在处理某些关键任务时，可以通过设置中断屏蔽寄存器来阻止某些中断的响应。
非屏蔽中断或不可屏蔽中断：不能由程序控制其屏蔽，处理机必须立即处理的中断。这类中断主要用于处理必须立即响应的紧急情况，如断电、电源故障等。
中断的过程
中断过程通常包括以下几个步骤：

中断源发出中断请求：当内部或外部事件发生时，中断源会向CPU发出中断请求。
CPU响应中断：CPU在接收到中断请求后，会暂停当前程序的执行，并保存当前的状态（如程序计数器、寄存器内容等），以便中断处理完成后能够恢复到原断点处继续执行。
执行中断服务程序：CPU跳转到中断向量表中找到对应的中断服务程序入口地址，并开始执行中断服务程序。中断服务程序负责处理中断事件，并可能修改系统的状态或执行特定的任务。
恢复并继续执行原程序：当中断服务程序执行完毕后，CPU会恢复之前保存的状态，并返回到被中断的程序原断点处继续执行。
中断的作用和意义
中断的主要作用和意义在于提高CPU的效率和系统的响应速度。通过中断机制，CPU可以在执行主程序的同时，及时响应和处理各种突发事件或紧急事件，从而实现对系统的有效控制和管理。此外，中断还有助于实现程序的并行化和多任务处理，提高系统的整体性能和可靠性。
为什么需要中断？因为单核CPU实际无法并行的，但是通过中断机制，可以实现假并行（宏观上的并行，微观上实际还是串行的）。

SoC对中断的实现机制：异常向量表

(1)异常向量表是CPU中某些特定地址的特定定义。当中断发生的时候，中断要想办法通知CPU去处理中断，怎么做到？这就要靠异常向量表。
(2)在CPU设计时，就事先定义了CPU中一些特定地址作为特定异常的入口地址（譬如定义0x00000000地址为复位异常向量地址，则发生复位异常时CPU会自动跳转到0x00000000地址去执行指令。又譬如外部中断对应的异常向量地址为0x30000008，则发生外部中断后，CPU会硬件自动跳转到0x30000008地址去执行指令。）
(3)以上讲的是CPU硬件设计时对异常向量表的支持，下来就需要软件支持了。硬件已经决定了发生什么异常CPU自动跳转PC到哪个地址去执行，软件需要做的就是把处理这个异常的代码的首地址填入这个异常向量地址。

S5PV210的异常向量表

在这里插入图片描述
异常向量表中各个向量的相对位置是固定的，但是他们的起始地址是不固定的，各种SoC可以不一样，而且复杂ARM中还可以让用户来软件设置这个异常向量表的基地址。
扩展到所有架构的CPU中：所有架构（譬如51单片机、PIC单片机）的CPU实现中断都是通过异常向量表实现的，这个机制是不变的；但是不同CPU异常向量表的构造和位置是不同的。

异常和中断的区别和联系
(1)针对SoC来说，发生复位、软中断、中断、快速中断、取指令异常、数据异常等，我们都统一叫异常。所以说：中断其实是异常的一种。
(2)异常的定义就是突发事件，打断了CPU的正常常规业务，CPU不得不跳转到异常向量表中去执行异常处理程序；中断是异常的一种，一般特指SoC内的内部外设产生的打断SoC常规业务，或者外部中断（SoC的GPIO引脚传回来的中断）。

异常向量表的编程处理

像内存一样去访问异常向量表
(1)S5PV210的异常向量表可以改变（在CP15协处理器中），以适应操作系统的需求。但是目前系统刚启动时，此时DRAM尚未初始化，程序都在SRAM中运行。210在iRAM中设置了异常向量表，供暂时性使用。
(2)查210的iROM application note文档P13中iRAM的地址分配，可知，iRAM中的异常向量表起始地址为0xD0037400。知道了异常向量表的起始地址后，各个异常对应的入口就很好知道了。
在这里插入图片描述
interrupt.h

#ifndef __INT_H__
#define __INT_H__


#define exception_vector_table_base		0xD0037400//基地址
#define exception_reset					(exception_vector_table_base + 0x00)
#define exception_undef					(exception_vector_table_base + 0x04)
#define exception_sotf_int				(exception_vector_table_base + 0x08)
#define exception_prefetch				(exception_vector_table_base + 0x0C)
#define exception_data					(exception_vector_table_base + 0x10)
#define exception_irq					(exception_vector_table_base + 0x18)
#define exception_fiq					(exception_vector_table_base + 0x1C)

#define r_exception_reset		(*(volatile unsigned int *)exception_reset)
#define r_exception_undef		(*(volatile unsigned int *)exception_undef)
#define r_exception_sotf_int	(*(volatile unsigned int *)exception_sotf_int)
#define r_exception_prefetch	(*(volatile unsigned int *)exception_prefetch)
#define r_exception_data		(*(volatile unsigned int *)exception_data)
#define r_exception_irq			(*(volatile unsigned int *)exception_irq)
#define r_exception_fiq			(*(volatile unsigned int *)exception_fiq)


#endif

interrupt.c

数名的实质就是函数的首地址
(1)函数名在C语言中的理解方法和变量名其实没区别。编译器会把这个函数的函数体对应的代码段和这个函数的函数名（实质是符号）对应起来，等我们在使用这个函数名符号时，编译器会将函数的函数体实际上做替换。因为函数体都不止4字节，而函数名这个符号只能对应1个地址，所以实际对应的是函数体那一个代码段的首地址。
(2)拿C语言中的语法来讲，函数名就是这个函数的函数指针。

为什么中断处理要先在汇编中进行
(1)中断处理要注意保护现场（中断从SVC模式来，则保存SVC模式下的必要寄存器的值）和恢复现场（中断处理完成后，准备返回SVC模式前，要将保存的SVC模式下的必要寄存器的值恢复回去，不然到了SVC模式后寄存器的值乱了，SVC模式下原来正在进行的常规任务就被你搞坏了）
(2)保存现场包括：第一：设置IRQ栈；第二，保存LR；第三，保存R0～R12
(3)为什么要保存LR寄存器？要考虑中断返回的问题。中断ISR执行完后如何返回SVC模式下去接着执行原来的代码。中断返回其实取决于我们进入中断时如何保存现场。中断返回时关键的2个寄存器就是PC和CPSR。所以我们在进入IRQ模式时，应该将SVC模式下的下一句指令的地址（中断返回地址）和CPSR保存起来，将来恢复时才可以将中断返回地址给PC，将保存的CPSR给CPSR。
(4)中断返回地址就保存在LR中，而CPSR（自动）保存在（IRQ模式下的）SPSR中

在这里插入图片描述

汇编保存现场和恢复现场
(1)保护现场关键是保存：中断处理程序的返回地址，r0-r12（cpsr是自动保存的）
(2)恢复现场主要是恢复：r0-r12，pc，cpsr

S5PV210的向量中断控制器

异常处理的2个阶段:可以将异常处理分为2个阶段来理解。第一个阶段是异常向量表跳转；第二个阶段就是进入了真正的异常处理程序irq_handler之后的部分。
(1)第一个阶段之所以能够进行，主要依赖于CPU设计时提供的异常向量表机制。第一个阶段的主要任务是从异常发生到响应异常并且保存/恢复现场、跳转到真正的异常处理程序处。
(2)第二个阶段的目的是识别多个中断源中究竟哪一个发生了中断，然后调用相应的中断处理程序来处理这个中断。
S3C2440的第二阶段处理过程
(1)第一个问题，怎么找到具体是哪个中断：S3C2440的中断控制器中有一个寄存器（32位的），寄存器的每一个位对应一个中断源
为了解决支持更多中断源，2440又设计了一个子中断机制。在一级中断寄存器中有一些中断是共用的一个bit位，譬如AC97和WDT。对于共用中断，用子中断来区分究竟是哪一个发生了中断

第二个问题，怎么找到对应的isr的问题：首先给每个中断做了个编号，进入isr_handler之后先通过查阅中断源寄存器和子中断寄存器（中哪一位为1）确定中断的编号，然后用这个编号去isr数组（isr数组是中断初始化时事先设定好的，就是把各个中断的isr的函数名组成一个数组，用中断对应的编号作为索引来查询这个数组）中查阅得到isr地址。
评价：2440的中断处理设计不是特别优秀：第一个过程中使用子中断搞成2级的很麻烦；第二个过程中计算中断编号是个麻烦事，很耗费时间。而中断处理的时间是很宝贵的（系统有一个性能指标，叫实时性。实时性就是中断发生到响应的时间，这个时间越短越好。）
S5PV210的第二阶段处理过程
(1)第一个问题，怎么找到具体是哪个中断：S5PV210中因为支持的中断源很多，所以直接设计了4个中断寄存器，每个32位，每位对应一个中断源。（理论上210最多支持128个中断，实际支持不足128个，有些位是空的）；210没有子中断寄存器，每个中断源都是并列的。当中断发生时，在irq_handler中依次去查询4个中断源寄存器，看哪一个的哪一位被置1，则这个位对应的寄存器就发生了中断，即找到了中断编号。
(2)第二个问题，怎么找到对应的isr的问题：210中支持的中断源多了很多，如果还使用2440的那一套来寻找isr地址就太慢了，太影响实时性了。于是210开拓了一种全新的寻找isr的机制。210提供了很多寄存器来解决每个中断源对应isr的寻找问题，实现的效果是当发生相应中断时，硬件会自动的将相应isr推入一定的寄存器中，我们软件只要去这个寄存器中执行函数就行了。

总结：第一阶段都相同，第二阶段各不同
(1)第一阶段（异常向量表阶段）2440和210几乎是完全相同的。实际上几乎所有的CPU在第一阶段都是相同的。
(2)第二阶段就彼此不同了。各个SoC根据自己对实时性的要求，和支持的中断源的多少，各自发明了各自处理中断，找到中断编号，进一步找到对应isr地址的方式。

S5PV210中断处理的主要寄存器

VICnINTENABLE和VICnINTENCLEAR//使能、禁止
VICnINTSELECT/模式
VICnIROSTATUS和VICnFIQSTATUS/中断状态
VICnVECTADDR0~VICnVECTADDR31/中断优先级
VICnVECTPRIORITY0~VICnVECTPRIORITY31//存放中断对应的isr的函数地址
VICnADDR/由硬件自动设置 只读

VICnINTENABLE和VICnINTENCLEAR
(1)VICnINTENABLE 对应interrupt enable，INTENCLEAR对应interrupt enable clear
(2)INTENABLE寄存器负责相应的中断的使能，INTENCLEAR寄存器负责相应的中断的禁止。
(3)当我们想使能（意思就是启用这个中断，意思就是当硬件产生中断时CPU能接收的到）某个中断时，只要在这个中断编号对应的VICnINTENABLE的相应bit位写1即可（注意这个位写1其他位写0对其他位没有影响）；如果我们想禁止某个中断源时，只要向VICnINTENCLEAR中相应的位写1即可。
注意：这里的设计一共有2种：有些CPU是中断使能和禁止是一个寄存器位，写1就使能写0就进制（或者反过来写1就进制写0就使能），这样的中断使能设计就要非常小心，要使用我们之前说过的读改写三部曲来操作；另一种就是使能和禁止分开为2个寄存器，要使能就写使能寄存器，要禁止就写禁止寄存器。这样的好处是我们使能/禁止操作时不需要读改写，直接写即可。

VICnINTSELECT
(1)设置各个中断的模式为irq还是fiq。一般都设置成irq
(2)IRQ和FIQ究竟有何区别。210中支持2种中断，irq和fiq。irq是普通中断，fiq是快速中断。快速中断提供一种更快响应处理的中断通道，用于对实时性要求很高的中断源。fiq在CPU设计时预先提供了一些机制保证fiq可以被快速处理，从而保证实时性。fiq的限制就是只能有一个中断源被设置为fiq，其他都是irq。
(3)CPU如何保证fiq比irq快？有2个原因：第一，fiq模式有专用的r8～r12，因此在fiq的isr中可以直接使用r8-r12而不用保存，这就能节省时间；第二，异常向量表中fiq是最后一个异常向量入口。因此fiq的isr不需要跳转，可以直接写在原地，这样就比其他异常少跳转一次，省了些时间。

VICnIRQSTATUS和VICnFIQSTATUS
(1)中断状态寄存器，是只读的。当发生了中断时，硬件会自动将该寄存器的对应位置为1，表示中断发生了。软件在处理中断第二阶段的第一阶段，就是靠查询这个寄存器来得到中断编号的。

VICnVECTPRIORITY0～VICnVECTPRIORITY31
(1)中断优先级设置寄存器，设置多个中断同时发生时先处理谁后处理谁的问题。一般来说高优先级的中断可以打断低优先级的中断，从而嵌套处理中断。当然了有些硬件/软件可以设置不支持中断嵌套。

VICnVECTADDR0～VICnVECTADDR31、VICnADDR
(1)这三个寄存器和210中断处理第二阶段的第二阶段有关。
(2)VICnVECTADDR0到31这32个寄存器分别用来存放真正的各个中断对应的isr的函数地址。相当于每一个中断源都有一个VECTADDR寄存器，程序员在设置中断的时候，把这个中断的isr地址直接放入这个中断对应的VECTADDR寄存器即可。
(3)VICnADDR这个寄存器是只需要读的，它里面的内容是由硬件自动设置的。当发生了相应中断时，硬件会自动识别中断编号，并且会自动找到这个中断的VECTADDR寄存器，然后将其读出复制到VICnADDR中，供我们使用。这样的设计避免了软件查找中断源和isr，节省了时间，提高了210的中断响应速度。

S5PV210中断处理的编程实践

中断控制器初始化
主要工作有：第一阶段绑定异常向量表到异常处理程序；禁止所有中断源；选择所有中断类型为IRQ；清理VICnADDR寄存器为0.

中断的使能与禁止
思路是先根据中断号判断这个中断属于VIC几，然后在用中断源减去这个VIC的偏移量，得到这个中断号在本VIC中的偏移量，然后1<<x位，写入相应的VIC的INTENABLE/INTENCLEAR寄存器即可。

绑定自己实现的isr到VICnVECTADDR
(1)搞清楚2个寄存器的区别：VICnVECTADDR和VICnADDR
(1)VICVECTADDR寄存器一共有4×32个，每个中断源都有一个VECTADDR寄存器，我们应该将自己为这个中断源写的isr地址丢到这个中断源对应的VECTADDR寄存器中即可。

真正的中断处理程序如何获取isr
(1)当发生中断时，硬件会自动把相应中断源的isr地址从VICnVECTADDR寄存器中推入VICnADDR寄存器中，所以我们第二阶段的第二阶段isr_handler中，只需要到相应的VICnADDR中去拿出isr地址，调用执行即可。

整个中断的流程梳理：

整个中断的工作分为2部分：
第一部分是我们为中断响应而做的预备工作：

  1. 初始化中断控制器
  2. 绑定写好的isr到中断控制器
  3. 相应中断的所有条件使能
    第二部分是当硬件产生中断后如何自动执行isr：
  4. 第一步，经过异常向量表跳转入IRQ/FIQ的入口
  5. 第二步，做中断现场保护（在start.S中），然后跳入isr_handler
  6. 第三步，在isr_handler中先去搞清楚是哪个VIC中断了，然后直接去这个VIC的ADDR
    寄存器中取isr来执行即可。
  7. 第四步，isr执行完，中断现场恢复，直接返回继续做常规任务。
    intc.h
#ifndef __INT_H__
#define __INT_H__


void intc_init(void);
void intc_enable(unsigned long intnum);
void intc_disable(unsigned long intnum);
void intc_setvectaddr(unsigned long intnum, void (*handler)(void));
void intc_clearvectaddr(void);
unsigned long intc_getvicirqstatus(unsigned long ucontroller);
void irq_handler(void);
void IRQ_handle(void);
void system_init_exception(void);



 Interrupt
#define VIC0_BASE                   (0xF2000000)
#define VIC1_BASE                   (0xF2100000)
#define VIC2_BASE                   (0xF2200000)
#define VIC3_BASE                   (0xF2300000)

// VIC0
#define     VIC0IRQSTATUS           ( *((volatile unsigned long *)(VIC0_BASE + 0x00)) )
#define     VIC0FIQSTATUS           ( *((volatile unsigned long *)(VIC0_BASE + 0x04)) )
#define     VIC0INTSELECT           ( *((volatile unsigned long *)(VIC0_BASE + 0x0c)) )
#define     VIC0INTENABLE           ( *((volatile unsigned long *)(VIC0_BASE + 0x10)) )
#define     VIC0INTENCLEAR          ( *((volatile unsigned long *)(VIC0_BASE + 0x14)) )
#define     VIC0VECTADDR            (VIC0_BASE + 0x100)
#define     VIC0ADDR                ( *((volatile unsigned long *)(VIC0_BASE + 0xf00)) )

// VIC1
#define     VIC1IRQSTATUS           ( *((volatile unsigned long *)(VIC1_BASE + 0x00)) )
#define     VIC1FIQSTATUS           ( *((volatile unsigned long *)(VIC1_BASE + 0x04)) )
#define     VIC1INTSELECT           ( *((volatile unsigned long *)(VIC1_BASE + 0x0c)) )
#define     VIC1INTENABLE           ( *((volatile unsigned long *)(VIC1_BASE + 0x10)) )
#define     VIC1INTENCLEAR          ( *((volatile unsigned long *)(VIC1_BASE + 0x14)) )
#define     VIC1VECTADDR            (VIC1_BASE + 0x100)
#define     VIC1ADDR                ( *((volatile unsigned long *)(VIC1_BASE + 0xf00)) )

// VIC2
#define     VIC2IRQSTATUS           ( *((volatile unsigned long *)(VIC2_BASE + 0x00)) )
#define     VIC2FIQSTATUS           ( *((volatile unsigned long *)(VIC2_BASE + 0x04)) )
#define     VIC2INTSELECT           ( *((volatile unsigned long *)(VIC2_BASE + 0x0c)) )
#define     VIC2INTENABLE           ( *((volatile unsigned long *)(VIC2_BASE + 0x10)) )
#define     VIC2INTENCLEAR          ( *((volatile unsigned long *)(VIC2_BASE + 0x14)) )
#define         VIC2VECTADDR            (VIC2_BASE + 0x100)
#define         VIC2ADDR                ( *((volatile unsigned long *)(VIC2_BASE + 0xf00)) )

// VIC3
#define     VIC3IRQSTATUS           ( *((volatile unsigned long *)(VIC3_BASE + 0x00)) )
#define     VIC3FIQSTATUS           ( *((volatile unsigned long *)(VIC3_BASE + 0x04)) )
#define     VIC3INTSELECT           ( *((volatile unsigned long *)(VIC3_BASE + 0x0c)) )
#define     VIC3INTENABLE           ( *((volatile unsigned long *)(VIC3_BASE + 0x10)) )
#define     VIC3INTENCLEAR          ( *((volatile unsigned long *)(VIC3_BASE + 0x14)) )
#define         VIC3VECTADDR            (VIC3_BASE + 0x100)
#define         VIC3ADDR                ( *((volatile unsigned long *)(VIC3_BASE + 0xf00)) )


#define exception_vector_table_base     0xD0037400
#define exception_reset                 (exception_vector_table_base + 0x00)
#define exception_undef                 (exception_vector_table_base + 0x04)
#define exception_sotf_int              (exception_vector_table_base + 0x08)
#define exception_prefetch              (exception_vector_table_base + 0x0C)
#define exception_data                  (exception_vector_table_base + 0x10)
#define exception_irq                   (exception_vector_table_base + 0x18)
#define exception_fiq                   (exception_vector_table_base + 0x1C)

#define r_exception_reset       (*(volatile unsigned int *)exception_reset)
#define r_exception_undef       (*(volatile unsigned int *)exception_undef)
#define r_exception_sotf_int    (*(volatile unsigned int *)exception_sotf_int)
#define r_exception_prefetch    (*(volatile unsigned int *)exception_prefetch)
#define r_exception_data        (*(volatile unsigned int *)exception_data)
#define r_exception_irq         (*(volatile unsigned int *)exception_irq)
#define r_exception_fiq         (*(volatile unsigned int *)exception_fiq)




// 中断源编号
#define INT_LIMIT               (96)

//INT NUM - VIC0
#define NUM_EINT0               (0)
#define NUM_EINT1               (1)
#define NUM_EINT2               (2)
#define NUM_EINT3               (3)
#define NUM_EINT4               (4)
#define NUM_EINT5               (5)
#define NUM_EINT6               (6)
#define NUM_EINT7               (7)
#define NUM_EINT8               (8)
#define NUM_EINT9               (9)
#define NUM_EINT10              (10)
#define NUM_EINT11              (11)
#define NUM_EINT12              (12)
#define NUM_EINT13              (13)
#define NUM_EINT14              (14)
#define NUM_EINT15              (15)
#define NUM_EINT16_31           (16)
#define NUM_Reserved17          (17) 
#define NUM_MDMA                (18)
#define NUM_PDMA0               (19)
#define NUM_PDMA1               (20)
#define NUM_TIMER0              (21)
#define NUM_TIMER1              (22)
#define NUM_TIMER2              (23)
#define NUM_TIMER3              (24)
#define NUM_TIMER4              (25)
#define NUM_SYSTIMER            (26)
#define NUM_WDT                 (27)
#define NUM_RTC_ALARM           (28)
#define NUM_RTC_TICK            (29)
#define NUM_GPIOINT             (30)
#define NUM_FIMC3               (31)

//INT NUM - VIC1
#define NUM_CORTEX0             (32+0)
#define NUM_CORTEX1             (32+1)
#define NUM_CORTEX2             (32+2)
#define NUM_CORTEX3             (32+3)
#define NUM_CORTEX4             (32+4)
#define NUM_IEM_APC             (32+5)
#define NUM_IEM_IEC             (32+6)
#define NUM_Reserved39          (32+7)
#define NUM_NFC                 (32+8)
#define NUM_CFC                 (32+9)
#define NUM_UART0               (32+10)
#define NUM_UART1               (32+11)
#define NUM_UART2               (32+12)
#define NUM_UART3               (32+13)
#define NUM_I2C                 (32+14)
#define NUM_SPI0                (32+15)
#define NUM_SPI1                (32+16)
#define NUM_SPI2                (32+17)
#define NUM_AUDIO               (32+18)
#define NUM_I2C_PMIC            (32+19)
#define NUM_I2C_HDMI            (32+20)
#define NUM_HSIRX               (32+21)
#define NUM_HSITX               (32+22)
#define NUM_UHOST               (32+23)
#define NUM_OTG                 (32+24)
#define NUM_MSM                 (32+25)
#define NUM_HSMMC0              (32+26)
#define NUM_HSMMC1              (32+27)
#define NUM_HSMMC2              (32+28)
#define NUM_MIPI_CSI            (32+29)
#define NUM_MIPI_DSI            (32+30)
#define NUM_ONENAND_AUDI        (32+31)

//INT NUM - VIC2
#define NUM_LCD0                (64+0)
#define NUM_LCD1                (64+1)
#define NUM_LCD2                (64+2)
#define NUM_LCD3                (64+3)
#define NUM_ROTATOR             (64+4)
#define NUM_FIMC_A              (64+5)
#define NUM_FIMC_B              (64+6)
#define NUM_FIMC_C              (64+7)
#define NUM_JPEG                (64+8)
#define NUM_2D                  (64+9)
#define NUM_3D                  (64+10)
#define NUM_MIXER               (64+11)
#define NUM_HDMI                (64+12)
#define NUM_HDMI_I2C            (64+13)
#define NUM_MFC                 (64+14)
#define NUM_TVENC               (64+15)
#define NUM_I2S0                (64+16)
#define NUM_I2S1                (64+17)
#define NUM_I2S2                (64+18)
#define NUM_AC97                (64+19)
#define NUM_PCM0                (64+20)
#define NUM_PCM1                (64+21)
#define NUM_SPDIF               (64+22)
#define NUM_ADC                 (64+23)
#define NUM_PENDN               (64+24)
#define NUM_KEYPAD              (64+25)
#define NUM_Reserved90          (64+26) 
#define NUM_HASH                (64+27) 
#define NUM_FEEDCTRL            (64+28) 
#define NUM_PCM2                (64+29)
#define NUM_SDM_IRQ             (64+30)
#define NUM_SMD_FIQ             (64+31)

//INT NUM - VIC3
#define NUM_IPC                 (96+0)
#define NUM_HOSTIF              (96+1)
#define NUM_HSMMC3              (96+2)
#define NUM_CEC                 (96+3)
#define NUM_TSI                 (96+4)
#define NUM_MDNIE0              (96+5)
#define NUM_MDNIE1              (96+6)
#define NUM_MDNIE2              (96+7)
#define NUM_MDNIE3              (96+8)
#define NUM_ADC1                (96+9)
#define NUM_PENDN1              (96+10)
#define NUM_ALL                 (200)





#endif

intc.c

#include "int.h"
#include "stdio.h"


void reset_exception(void)
{
    printf("reset_exception.\n");
}

void undef_exception(void)
{
    printf("undef_exception.\n");
}

void sotf_int_exception(void)
{
    printf("sotf_int_exception.\n");
}

void prefetch_exception(void)
{
    printf("prefetch_exception.\n");
}

void data_exception(void)
{
    printf("data_exception.\n");
}

// 初始化
//主要功能:
//绑定第一阶段异常向量表;
//禁止所有中断:
//选择所有中断类型为IRQ
//清除VICnADDR为0
void system_init_exception(void)
{
    //写跳转指令 可以直接写一个C语言的函数
    //绑定异常向量表
    r_exception_reset = (unsigned int)reset_exception;
    r_exception_undef = (unsigned int)undef_exception;
    r_exception_sotf_int = (unsigned int)sotf_int_exception;
    r_exception_prefetch = (unsigned int)prefetch_exception;
    r_exception_data = (unsigned int)data_exception;
    r_exception_irq = (unsigned int)IRQ_handle;
    r_exception_fiq = (unsigned int)IRQ_handle;
    
    // 初始化中断控制器寄存器
    intc_init();
}

//清除需要处理的中断的中断处理函数的地址
void intc_clearvectaddr(void)
{
   //VICXADDR:当前正在处理的中断的中断处理函数的地址
    VIC0ADDR = 0;
    VIC1ADDR = 0;
    VIC2ADDR = 0;
    VIC3ADDR = 0;
}

// 初始化中断控制器
void intc_init(void)
{
    // 禁止所有中断
    //避免程序跑飞
    VIC0INTENCLEAR = 0xffffffff;
    VIC1INTENCLEAR = 0xffffffff;
    VIC2INTENCLEAR = 0xffffffff;
    VIC3INTENCLEAR = 0xffffffff;

    //选择中断类型为IRQ
    VIC0INTSELECT = 0x0;
    VIC1INTSELECT = 0x0;
    VIC2INTSELECT = 0x0;
    VIC3INTSELECT = 0x0;

    // 清VICxADDR
    intc_clearvectaddr();
}


//保存需要处理的中断的中断处理函数的地址
//绑定我们写的isr到VICNVECTADDR寄存器
//绑定过之后我们就把jsr地址交给硬件了,剩下的我们不用管了,硬件自己会处理
//等发生相应中断的时候,我们直接到相应的VICNADDR中去取isr地址即可。
//intnum 物理中断号
// handler 函数指针 就是我们写的isr

//VICOVECTADDR定义为VICOVECTADDRO寄存器的地址,就相当于是VICOVECTADDRO~31这个
//数组(这个数组就是一个函数指针数组)的首地址,然后具体计算每一个中断的时候
//只需要首地址+偏移量即可。

void intc_setvectaddr(unsigned long intnum, void (*handler)(void))
{
    //VIC0
    if(intnum<32)
    {
        //给地址内容赋值内容 内容是函数指针
        *( (volatile unsigned long *)(VIC0VECTADDR + 4*(intnum-0)) ) = (unsigned)handler;
    }
    //VIC1
    else if(intnum<64)
    {
        *( (volatile unsigned long *)(VIC1VECTADDR + 4*(intnum-32)) ) = (unsigned)handler;
    }
    //VIC2
    else if(intnum<96)
    {
        *( (volatile unsigned long *)(VIC2VECTADDR + 4*(intnum-64)) ) = (unsigned)handler;
    }
    //VIC3
    else
    {
        *( (volatile unsigned long *)(VIC3VECTADDR + 4*(intnum-96)) ) = (unsigned)handler;
    }
    return;
}


// 使能中断
// 通过传参的intnum来使能某个具体的中断源,中断号号在int.h中定义,是物理中断号
void intc_enable(unsigned long intnum)
{
    unsigned long temp;
    //确定在那个寄存器 哪一位
    if(intnum<32)//0-31 在VIC0
    {
        temp = VIC0INTENABLE;

        //将具体位写1就是使能 写0没有任何影响
        temp |= (1<<intnum);        //等价于temp = (1<<intnum);
        
        VIC0INTENABLE = temp;
    }
    else if(intnum<64)//32-63 在VIC1
    {
        temp = VIC1INTENABLE;
        temp |= (1<<(intnum-32));
        VIC1INTENABLE = temp;
    }
    else if(intnum<96)//64-95 在VIC2
    {
        temp = VIC2INTENABLE;
        temp |= (1<<(intnum-64));
        VIC2INTENABLE = temp;
    }
    else if(intnum<NUM_ALL)//96-200 在VIC3
    {
        temp = VIC3INTENABLE;
        temp |= (1<<(intnum-96));
        VIC3INTENABLE = temp;
    }
    // NUM_ALL : enable all interrupt
    else//超出 就全部关闭
    {
        VIC0INTENABLE = 0xFFFFFFFF;
        VIC1INTENABLE = 0xFFFFFFFF;
        VIC2INTENABLE = 0xFFFFFFFF;
        VIC3INTENABLE = 0xFFFFFFFF;
    }

}

// 禁止中断
void intc_disable(unsigned long intnum)
{
    unsigned long temp;

    if(intnum<32)
    {
        temp = VIC0INTENCLEAR;
        temp |= (1<<intnum);
        VIC0INTENCLEAR = temp;
    }
    else if(intnum<64)
    {
        temp = VIC1INTENCLEAR;
        temp |= (1<<(intnum-32));
        VIC1INTENCLEAR = temp;
    }
    else if(intnum<96)
    {
        temp = VIC2INTENCLEAR;
        temp |= (1<<(intnum-64));
        VIC2INTENCLEAR = temp;
    }
    else if(intnum<NUM_ALL)
    {
        temp = VIC3INTENCLEAR;
        temp |= (1<<(intnum-96));
        VIC3INTENCLEAR = temp;
    }
    // NUM_ALL : disable all interrupt
    else
    {
        VIC0INTENCLEAR = 0xFFFFFFFF;
        VIC1INTENCLEAR = 0xFFFFFFFF;
        VIC2INTENCLEAR = 0xFFFFFFFF;
        VIC3INTENCLEAR = 0xFFFFFFFF;
    }

    return;
}


//读中断状态
//通过读取VICNIRQSTATUS寄存器,判断其中哪个有一位为1,来得知那个VIC发生中断了
unsigned long intc_getvicirqstatus(unsigned long ucontroller)
{
    if(ucontroller == 0)
        return  VIC0IRQSTATUS;
    else if(ucontroller == 1)
        return  VIC1IRQSTATUS;
    else if(ucontroller == 2)
        return  VIC2IRQSTATUS;
    else if(ucontroller == 3)
        return  VIC3IRQSTATUS;
    else
    {}
    return 0;
}


// 真正的中断处理程序。意思就是说这里只考虑中断处理,不考虑保护/恢复现场
void irq_handler(void)
{
    printf("irq_handler.\n");
//SoC支持很多个(在低端CPU例如2440中有30多个,在210中有100多个)中断
//这么多中断irq在第一个阶段走的是一条路,都会进入到irq handler来
//我们在irq_handler中要去区分充竟是哪个中断发生了,然后再去调用该中断
//对应的isr......

    
    
//虽然硬件已经自动帮我们把isr放入了VICnADDR中,
//但是因为有4个,所以我们必须
//先去软件的检查出来到底哪个VIC中断了,
//也就是说isr到底在哪个VICADDR寄存器中
    unsigned long vicaddr[4] = {VIC0ADDR,VIC1ADDR,VIC2ADDR,VIC3ADDR};
    int i=0;
    void (*isr)(void) = NULL;

    for(i=0; i<4; i++)
    {
        //发生一个中断时,4个VIC中有3个是全0,1个的其中一立不是
        if(intc_getvicirqstatus(i) != 0)
        {
            isr = (void (*)(void)) vicaddr[i];//给函数指针赋值
            break;
        }
    }
    (*isr)();   //通过函数指针来调用函数

}

中断实例：外部中断

什么是外部中断？数据手册在哪里？
(1)SoC支持的中断类型中有一类叫外部中断。内部中断就是指的中断源来自于SoC内部（一般是内部外设），譬如串口、定时器等部件产生的中断；外部中断是SoC外部的设备，通过外部中断对应的GPIO引脚产生的中断。
(2)按键在SoC中就使用外部中断来实现。具体实现方法是：将按键电路接在外部中断的GPIO上，然后将GPIO配置为外部中断模式。此时人通过按按键改变按键电路的电压高低，这个电压高低会触发GPIO对应的外部中断，通过引脚传进去给CPU处理。
(3)外部中断相关的介绍和寄存器都在2.2.60章节（属于GPIO部分）

电平触发和边沿触发
(1)外部中断的触发模式主要有2种：电平触发和边沿触发。
(1)电平触发就是说GPIO上的电平只要满足条件，就会不停触发中断。电平触发分为高电平触发和低电平触发。电平触发的特点是，只要电平满足条件就会不停触发中断。
(2)边沿触发分为上升沿触发、下降沿触发和双边沿触发三种。边沿触发不关心电平常规状态，只关心电平变化的瞬间（边沿触发不关心电平本身是高还是低，只关心变化是从高到低还是从低到高的这个过程）。
分析按键的工作：如果我们关注的是按键按下和弹起这两个事件本身，那么应该用边沿触发来处理按键；如果我们关心的是按键按下/弹起的那一段时间，那么应该用电平触发。

关键寄存器：CON、PEND、MASK
(1)外部中断的主要配置寄存器有3个：EXT_CON(设置触发条件)、EXT_PEND（挂起状态）、EXT_MASK（使能禁止开关）
(2)EXT_CON配置外部中断的触发方式。触发方式就是说外部电平怎么变化就能触发中断，也就是说这个外部中断产生的条件是什么

(3)EXT_PEND寄存器是中断挂起寄存器。这个寄存器中每一位对应一个外部中断，平时没有中断时值为0。当发生了中断后，硬件会自动将这个寄存器中该中断对应的位置1，我们去处理完这个中断后应该手工将该位置0。这个PEND寄存器的位就相当于是一个标志，如果发生了中断但是我们暂时忙来不及去处理时，这个位一直是1（这就是挂起），直到我有空了去处理了这个中断才会手工清除（写代码清除）这个挂起位表示这个中断被我处理了。
(4)EXT_MASK寄存器就是各个外部中断的使能/禁止开关。

分析X210开发板的按键对应的EINT编号：
EINT2、EINT3、EINT16、EINT17、EINT18、EINT19
key.c

//操作寄存器是宏

#define GPH0CON     0xE0200C00
#define GPH0DAT     0xE0200C04

#define GPH2CON     0xE0200C40
#define GPH2DAT     0xE0200C44

#define rGPH0CON    (*(volatile unsigned int *)GPH0CON)
#define rGPH0DAT    (*(volatile unsigned int *)GPH0DAT)
#define rGPH2CON    (*(volatile unsigned int *)GPH2CON)
#define rGPH2DAT    (*(volatile unsigned int *)GPH2DAT)


//========中断方式出来==========
#define EXT_INT_0_CON   0xE0200E00
#define EXT_INT_2_CON   0xE0200E08
#define EXT_INT_0_PEND  0xE0200F40
#define EXT_INT_2_PEND  0xE0200F48
#define EXT_INT_0_MASK  0xE0200F00
#define EXT_INT_2_MASK  0xE0200F08

#define rEXT_INT_0_CON  (*(volatile unsigned int *)EXT_INT_0_CON)
#define rEXT_INT_2_CON  (*(volatile unsigned int *)EXT_INT_2_CON)
#define rEXT_INT_0_PEND (*(volatile unsigned int *)EXT_INT_0_PEND)
#define rEXT_INT_2_PEND (*(volatile unsigned int *)EXT_INT_2_PEND)
#define rEXT_INT_0_MASK (*(volatile unsigned int *)EXT_INT_0_MASK)
#define rEXT_INT_2_MASK (*(volatile unsigned int *)EXT_INT_2_MASK)
//========中断方式出来==========

//========轮询方式出来==========
//初始化
void key_init(void)
{
    // GPH0CON 的bit8~15全部设备为0 设置为输入模式
    rGPH0CON &= ~(0xFF<<8);//1取反就是0 
    // GPH2CON 的bit1~15全部设备为0 设置为输入模式
    rGPH2CON &= ~(0xFFFF<<0);
}
void delay20ms(void)
{
    volatile unsigned int i = 900;      
    while (i--);                            
}


//轮询按键
void key_polling(void)
{
    // 依次读取GPIO的值 0 就是按下 1就是松开
    while (1)
    {
        //GPH0DAT 判断bit2 
        if (rGPH0DAT & (1<<2))
        {
            // 为1没有按下
            delay20ms();
            if (rGPH0DAT & (1<<2)){//确实是按下
                led_off();
            }
        }
        else
        {
            //0就是按下
            delay20ms();
            if (!(rGPH0DAT & (1<<2))){//确实是按下
                led_on();
                putc('2');
            }

        }
        
        //GPH0DAT 判断bit3 
        if (rGPH0DAT & (1<<3))
        {
            // 为1没有按下
            led_off();
        }
        else
        {
            //0就是按下
            led_on();
            putc('3');
        }
        
        //GPH2DAT 判断bit0 
        if (rGPH2DAT & (1<<0))
        {
            // 为1没有按下
            led_off();
        }
        else
        {
            //0就是按下
            led_on();
            putc('0');
        }
    }
}
//========轮询方式出来==========

//========中断方式出来==========
//中断方式处理
void key_init_interrupt(void)
{
    // 1. 外部中断对应的GPIO模式设置
    rGPH0CON |= 0xFF<<8;        // GPHO_2GPH0_3设置为外部中断模式
    rGPH2CON |= 0xFFFF<<0;      // GPH2_0123设置为外部中断模式
    
    // 2、中断触发模式设置
    rEXT_INT_0_CON &= ~(0xFF<<8);   // bit8~bit15全部清零
    rEXT_INT_0_CON |= ((2<<8)|(2<<12));     // EXT_INT2和EXT_INT3设置为下降沿触发
    rEXT_INT_2_CON &= ~(0xFFFF<<0);
    rEXT_INT_2_CON |= ((2<<0)|(2<<4)|(2<<8)|(2<<12));   
    
    // 3. 中断允许 清挂起
    rEXT_INT_0_MASK &= ~(3<<2);         // 中断允许
    rEXT_INT_2_MASK &= ~(0x0f<<0);
    
    // 4. 清挂起 清除是写1 不是写0
    rEXT_INT_0_PEND |= (3<<2); //bit2 3写1
    rEXT_INT_2_PEND |= (0x0F<<0);
}

// EINT2ͨ通道对应的按键 GPH0_2对应的按键
void isr_eint2(void)
{
    //真正的isr应该做2件事情。
    //第一,中断处理代码,就是真正干活的代码
    printf("isr_eint2_LEFT.\n");
    // 清除中断挂起
    rEXT_INT_0_PEND |= (1<<2);
    intc_clearvectaddr();
}

void isr_eint3(void)
{
    //真正的isr应该做2件事情。
    //第一,中断处理代码,就是真正干活的代码
    printf("isr_eint3_DOWN.\n");
    // 清除中断挂起
    rEXT_INT_0_PEND |= (1<<3);
    intc_clearvectaddr();
}

void isr_eint16171819(void)
{
    //真正的isr应该做2件事情。
    //第一,中断处理代码,就是真正干活的代码
    //进一步区分具体是那个中断
    //通过EXT_INT_2_PEND寄存器来区分
    if (rEXT_INT_2_PEND & (1<<0))
    {
        printf("eint16\n");
    }
    if (rEXT_INT_2_PEND & (1<<1))
    {
        printf("eint17\n");
    }
    if (rEXT_INT_2_PEND & (1<<2))
    {
        printf("eint18\n");
    }
    if (rEXT_INT_2_PEND & (1<<3))
    {
        printf("eint19\n");
    }

    // 清除中断挂起
    rEXT_INT_2_PEND |= (0x0f<<0);
    intc_clearvectaddr();
}

//========中断方式出来==========

main.c

#include "stdio.h"

#define KEY_EINT2       NUM_EINT2       // left
#define KEY_EINT3       NUM_EINT3       // down
#define KEY_EINT16_19   NUM_EINT16_31   // 其余4个共用的

void uart_init(void);
void led_init(void);
void key_polling(void);

void delay(int i)
{
    volatile int j = 10000;
    while (i--)
        while(j--);
}


int main(void)
{
    uart_init();
    //key_init();
    key_init_interrupt();
    
    // 如果程序中要使用中断，就要调用中断初始化来初步初始化中断控制器
    system_init_exception();
    
    printf("-------------key interrypt test--------------");
    
    // 绑定isr到中断控制器硬件
    intc_setvectaddr(KEY_EINT2, isr_eint2);
    intc_setvectaddr(KEY_EINT3, isr_eint3);
    intc_setvectaddr(KEY_EINT16_19, isr_eint16171819);
    
    // 使能中断
    intc_enable(KEY_EINT2);
    intc_enable(KEY_EINT3);
    intc_enable(KEY_EINT16_19);
    
    // 在这里加个心跳
    while (1)
    {
        printf("OK ");
        delay(10000);
    }
    
    return;
}

在这里插入图片描述

总结

首先讲解按键的原理，学会原理图，知道按键的两种检测方法，轮询和中断，理解中断，首先需要中断向量表，当中断发送，硬件就会自动跳转到中断向量表，找到对应中断需要跳转到的地址去执行相关指令。

学习记录，侵权联系删除。
来源：朱老师物联网大课堂

li星野
关注
  • 9
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
s5pv210中断详解
qq_35718950的博客
01-06 691
本文根据《朱老师物联网大讲堂》学习视频编写。如有侵权请联系 S5PV210中断体系介绍 一、什么是中断？ (1)中断的发明是用来解决宏观上的并行需要的。宏观就是从整体上来看，并行就是多件事情都完成了。 (2)微观上的并行，就是指的真正的并行，就是精确到每一秒甚至每一刻，多个事情都是在同时进行的。宏观上面的并行并不等于围观的并行，有时候宏观上是并行的，微观上是串行的。 (3)例子中一个人在
嵌入式裸机按键和CPU的中断系统学习笔记
donke_dong
08-06 564
准备工作 一.按键介绍与硬件连接 按键介绍 按键是常见的外部中断设备，类似于我们电路中的开关。一般的按键都有4个引脚，这4个引脚成2对：其中一对是常开触点（不按则断开，按下则闭合）；一对是常闭触点（平时不按时是闭合的，按下后是断开的），硬件设计时可根据实际情况进行选择。 按键消抖 (1)按键这种物理器件本身会有抖动信号，抖动信号指的是在电平由高到低（也就是按键按下时）或者电平由低到高（也就是按键弹起时）过程中，电平的变化不是立刻变化，而是经过了一段时间的不稳定期才完成变化，在这个不稳定期间电平可能会时高时低
[smart210] s5pv210的中断体系
weixin_30832143的博客
08-14 129
平台：smart210 CPU：s5pv210 目标：学习s5pv210的中断体系，从一个子中断的使能等设置的流程中体会完整的中断过程。 知识储备：向量中断控制器的介绍 主要有4个VIC，4个TZIC还有一个很特殊的ARM PrimeCell PL192。主要的VIC和TZIC可以支持93个中断源。其中TZIC是为TrustZone技术所准备的，ARM TrustZone® 技术是系统范围的安全...
s5pv210——中断
weixin_30783629的博客
01-27 140
1：s5pv210的中断步骤 (1)：建立异常向量表； (2)：中断初始化； (3)：使能（如外部中断，写中断处理函数）； (4)：建立中断号与中断处理函数的联系，使能中断； 当中断发生时，中断处理函数会自动处理中断； 流程如下： 2：建立异常向量表： s5pv210异常向量表的基地址为0xD003_7400，下图为异常对于基地址的偏移量； 第一步建立异...
S5PV210的中断处理机制详解
最新发布
weixin_42031299的博客
10-04 1040
参考博客：；
s5pv210中断系统
07-19
s5pv210中断共有93个中断源，被分成4组，所对应的寄存器和中断号以及应用领域详情可参考page560。  237个IO口中有178个(除GPI、MP0)都支持中断  GPH0-3做为专用外部中断(共32个外部中断，17个中断源)，有着自己独立的中断控制寄存器,而其它GPIO
按键和CPU的中断系统-1.8.ARM裸机第八部分
06-08
之后开始了CPU中断系统的讲解，详细介绍了中断的概念和设计原理，以2440和210为原型讲解了CPU如何实现中断以及如何编程利用中断。本课程的目标是深入理解中断原理和使用轮询、中断两种方式来实现按键获取。
arm裸机的按键设置和中断
heyunpign的博客
11-24 592
按键的物理特性 **(1)、平时没人按的时候，弹簧把按键按钮弹开。此时内部断开的。 (2)、有人按下的时候，手的力量克服弹簧的弹力，将按钮按下，此时内部保持接通（闭合）状态；如果手拿开，则弹簧作用下按钮又弹开，同时内部又断开。 (3)、一般的按键都有4个引脚，这4个引脚成2对：其中一对是常开触点（像上面描述的不按则断开，按下则闭合）；一对是常闭触点（平时不按时是闭合的，按下后是断开的）** 按键的电学原理（结合原理图分析） **(1)硬件接法： SW5:GPH0_2 SW6:GPH0_3 SW78
从ARM裸机程序之按键中断方式控制LED
11-12
总结来说，"从ARM裸机程序之按键中断方式控制LED"是一个涉及嵌入式系统基础知识的主题，包括ARM处理器的中断处理机制、GPIO接口的操作以及中断服务例程的设计。通过学习和实践这样的例子，开发者能够更好地理解硬件...
6410裸机按键中断
05-11
6410裸机按键中断是嵌入式系统开发中的一个关键知识点，主要涉及的是三星6410处理器如何处理硬件中断，特别是与用户交互的按键中断。在嵌入式系统中，裸机指的是没有操作系统或者操作系统非常轻量级的情况，开发者...
S5PV210的中断编程
Echo_Ana的博客
09-26 551
ARM处理器响应中断的时候，总是从固定的中断异常向量取地址开始的，而在高级语言环境下开发中断服务程序时，无法控制从固定地址处开始至中断服务程序的跳转流程。为了使得上层应用程序与硬件中断跳转联系起来，需要编写一段中间的服务程序来进行连接，即中断解析程序。 对中断编程，有以下的4部分程序： 1）建立系统中断向量表，并且设置微处理器内核的程序状态寄存器CPSR中的F位和I位，一般情况下中断均需要
基于S5PV210的中断和外部按键中断
李辉的博客
12-23 486
基于S5PV210的中断和外部按键中断                                                           --参考朱有鹏ARM裸机课堂 1、什么是中断？ 中断的目的就是为了处理更加重要的事情和任务。 并行的处理事情，单核的CPU在微观上是无法实现并行的，只能实现宏观的并行。 2、SOC对中断的实现机制：异常向量表； 为什
S5PV210外部中断
Just do it
01-03 1064
210里面有很多种中断有内部中断有外部中断。 什么是内部中断和外部中断？ SoC支持的中断类型中有一类叫外部中断。内部中断就是指的中断源来自SoC内部（一般是内部外设），譬如串口、定时器等部件产生的中断；外部中断是SoC外部的设备，通过外部中断对应的GPIO引脚产生的中断。（区别就是中断源一个在内部，一个在外部）。 关键性的寄存器：EXT_CON, EXT_PEND, EXT_MASK. ...
ARM架构的外部中断介绍(S5PV210芯片)
weixin_42031299的博客
10-04 1282
(1)外部中断控制器每4位对应一个外部中断，其中3位有效，一位保留，32个外部中断对应4个外部中断控制器；(2)外部中断控制设置外部中断的触发方式；
按键与中断——S5PV210的中断体系详解
主要记录嵌入式学习与开发过程。
05-11 1562
以下内容源于朱有鹏嵌入式课程的学习与整理，如有侵权请告知删除。
S5PV210中断的介绍与配置
MDXZ
10-14 868
一、介绍 1、三星S5PV210中断体系介绍 异常向量表（矢量中断控制器） 异常向量表是CPU中某些特定地址的特定定义，当中断发生的时候，中断要通知CPU处理中断，在CPU设计时，定义了CPU中一些特定地址作为特定异常的入口地址，异常向量表的实现，是基于SoC内部的矢量中断控制器。 关于矢量中断控制器的描述，这里摘录了网友“亦大乐谍“的博客： S5PV210是三星推出的一款基于Cortex-A8...
S5PV210开发之1.0.8------中断系统
shun1296的博客
08-16 232
S5PV210中断+按键 //中断大致过程 1.中断前的保护现场操作 2.进入中断执行isr程序 3.退出isr，返回现场 1.初始化中断控制器 1.异常向量表关联相应中断函数 #define exception_irq (exception_vector_table_base + 0x18) #define exception_fiq (exception_vector_table_base + 0x1C) #define r_exception_irq (*(volatile unsigned
中断——S5PV210的中断源
主要记录嵌入式学习与开发过程。
05-12 705
以下内容源于朱有鹏嵌入式课程的学习与整理，如有侵权请告知删除。
S5PV210中断向量表理解
lingchenckobe的博客
07-03 514
在uboot中，重新设置了中断向量表，即不在0地址处了，而在裸机中，第一种可以重新设置中断向量表，在_start标号处(这样的裸机代码要参考uboot的流程写法)，第二种可以不重新设置，直接把中断处理程序地址放入0xd003,7400处，一旦发生异常，就会跳过去执行。上述过程针对210，因为210的0地址处放的是固化代码，不能再放用户写的程序了，所以设置了这个机制。而2440发生异常时，就直接在0...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

li星野

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值