精华内容
下载资源
问答
  • STM8单片机的中断优先级

    千次阅读 2016-06-17 20:03:49
    STM8没有专门的中断状态寄存器,所以只能通过刚进入中断就读取IDR来判断,不过在某些情况下,此种方法就不好用了,所以在设计时候就要考虑清楚,是不是会冲突.最好把有冲突的中断放到不同组。 STM8外部中断采用...
    STM8S的中断由中断控制器(ITC)控制。STM8所有IO都支持中断,分为PA~PE 5个组,每组IO对应一个中断服务函数(也就是每组IO只有一个向量)。STM8没有专门的中断状态寄存器,所以只能通过刚进入中断就读取IDR来判断,不过在某些情况下,此种方法就不好用了,所以在设计的时候就要考虑清楚,是不是会冲突.最好把有冲突的中断放到不同的组。

    STM8的外部中断采用软件优先级+硬件优先级的控制方法,来控制优先级分组.软件优先级优先于硬件优先级。硬件优先级由向量号确定,向量号越小,优先级越高如下面图中断映射,中断向量表。

    STM8软件优先级设置可以分为4个等级(0~3),实际上可设置的就三个等级:1~3。优先级顺序:0<1<2<3,3的优先级最高,高优先级的中断可以打断低优先级的中断
    多个中断同时发生:在软件优先级相同的情况下,由硬件优先级决定谁先响应.但是硬件优先级不可打断。也就是相同软件优先级的中断,硬件优先级低的中断在执行了...此时来一个硬件优先级高的中断是不可以打断低优先级的中断的。STM8还有个TLI外部中断,这个优先级可以打断软件优先级为3的中断,TLI的优先级不可设置.(基本就是最高级别了,除了RESET)。

    总结:同时中断看硬件优先级(向量表)
    嵌套中断的时候,应该看软件优先级。(3是最高级)

    展开全文
  • STM8没有专门的中断状态寄存器,所以只能通过刚进入中断就读取IDR来判断,不过在某些情况下,此种方法就不好用了,所以在设计时候就要考虑清楚,是不是会冲突.最好把有冲突的中断放到不同组。 STM8外部中断采用...
    STM8S的中断由中断控制器(ITC)控制。STM8所有IO都支持中断,分为PA~PE 5个组,每组IO对应一个中断服务函数(也就是每组IO只有一个向量)。STM8没有专门的中断状态寄存器,所以只能通过刚进入中断就读取IDR来判断,不过在某些情况下,此种方法就不好用了,所以在设计的时候就要考虑清楚,是不是会冲突.最好把有冲突的中断放到不同的组。

    STM8的外部中断采用软件优先级+硬件优先级的控制方法,来控制优先级分组.软件优先级优先于硬件优先级。硬件优先级由向量号确定,向量号越小,优先级越高如下面图中断映射,中断向量表。

    STM8软件优先级设置可以分为4个等级(0~3),实际上可设置的就三个等级:1~3。优先级顺序:0<1<2<3,3的优先级最高,高优先级的中断可以打断低优先级的中断
    多个中断同时发生:在软件优先级相同的情况下,由硬件优先级决定谁先响应.但是硬件优先级不可打断。也就是相同软件优先级的中断,硬件优先级低的中断在执行了...此时来一个硬件优先级高的中断是不可以打断低优先级的中断的。STM8还有个TLI外部中断,这个优先级可以打断软件优先级为3的中断,TLI的优先级不可设置.(基本就是最高级别了,除了RESET)。

    总结:同时中断看硬件优先级(向量表)
    嵌套中断的时候,应该看软件优先级。(3是最高级)

     
    注意:
    设置优先级之前必须关闭中断,否则会导致hard fault。
    疑惑:
    • reference manual中有如下描述,MAIN, IT4, IT3, IT2, IT1, IT0, TRAP/TLI (same priority), and RESET但是不知道IT4等代表什么含义

       

    转载于:https://www.cnblogs.com/smileintheday/p/6523909.html

    展开全文
  • 多线程基础 | 线程的优先级、线程...和优先级队列一样,每个线程有一个队行的优先级的数值来判断线程优先级的高低,取值范围为1~10,数字越大优先级越高,默认值为5。 理论上讲优先级高的先被执行。实际上,优先级高只

    1.线程优先级

    线程优先级的设置和获取分别可以用setPriority()方法和getPriority()方法。

    和优先级队列一样,每个线程有一个队行的优先级的数值来判断线程优先级的高低,取值范围为1~10,数字越大优先级越高,默认值为5。

    理论上讲优先级高的先被执行。实际上,优先级高只是被cpu先执行概率大,并不是说优先级高的一定就会先被执行。因此我们在项目开发中不能使用优先级来完成一些特定的任务。

    优先级的继承性

    若B线程是在A线程中创建出来的,那么称B线程是A线程的子线程,这两个线程具有相同的优先级

    class ThreadA extends Thread {
        @Override
        public void run() {
            this.setPriority(1);
            System.out.println("A线程的优先级为:" + this.getPriority());
            ThreadB threadB = new ThreadB();
            threadB.start();
        }
    }
    
    class ThreadB extends Thread {
        @Override
        public void run() {
            System.out.println("B线程的优先级为:" + this.getPriority());
        }
    }
    
    public class TestApp {
        public static void main(String[] args) {
            ThreadA threadA = new ThreadA();
            threadA.start();
        }
    }
    

    运行结果为:
    在这里插入图片描述

    优先级的特点:

    1. 线程优先级的继承特性:也就是如果线程A启动线程B,那么线程A和B的优先级是一样的;
    2. 线程优先级的规则性:即线程会优先级的大小顺序执行,但是不一定是优先级较大的先执行完,因为线程的优先级还有下面第三个特性:
    3. 线程优先级的随机特性优先级越高,大部分情况下在多个线程的情况下优先级高的先完成所有的任务。但是优先级并不是衡量那个线程运行结果顺序的标准,因为cpu只是尽量将执行资源交给优先级高的线程。优先级高的线程不一定每一次都先执行完run方法中的任务,也就是说线程优先级与打印顺序无关,他们的关系具有不确定性和随机性。

    2.守护线程

    守护线程是一个特殊的线程。它是一个在后台执行的线程,当所有非守护线程结束之后守护线程会自动结束。

    如下面实例的程序,把子线程设置为守护线程,子线程的执行逻辑为一个死循环,一直打印子线程的名字。等到七秒之后,非守护线程主线程执行完成,子线程也自动结束,子线程的死循环结束。

    public class DaemonTest {
        public static void main(String[] args) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        System.out.println(Thread.currentThread().getName()); // 子线程一直打印
                    }
                }
            });
            
            t.setDaemon(true); // 把子线程设置成守护线程 一定要在线程启动之前
            t.start();
            try {
                TimeUnit.SECONDS.sleep(7);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()); // 主线程名字
        }
    }
    

    守护线程的使用场景: 垃圾回收、服务器线程等。 垃圾是用户创建出来的线程产生的,当用户线程如果结束,就没有必要再去回收了。

    3.线程的生命周期

    线程的生命周期指的就是线程从生到死的过程。

    我们知道,要开启一个线程,不管怎么样,都是要创建一个Thread对象的,那么线程的状态都是定义在Thread类下的,从源码中可以找到总共有New(新建)、Runnable(运行)、blocked(阻塞)、waitingtimed_waiting(等待)、terminated(终止)这几个状态。

    线程的New状态:

    • 当我们用关键字new创建一个thread对象时,此时它并不是出于执行状态,因为没有调用start方法启动该线程,那么线程的状态为new状态。准确地说,它只是Thread对象的状态,因为没有start之前,该线程根部就不存在,与你用关键字new创建一个普通的java对象没有什么区别new状态通过start()方法进入runnable状态。

    线程的Runnable状态:

    • Runnable状态:分成了两种状态,可执行(就绪态)和运行态。运行态顾名思义。就绪态指的是已经调用了start方法,但是线程还没有被cpu调度执行,只是具有了运行的资格。可执行(就绪态)的线程只能意外终止或者进入运行状态。

    线程的blocked状态:

    • 线程阻塞状态。当程序进行某个阻塞的io操作,比如因网络数据的读写而进入的blocked状态,或获取某个锁资源,等待时,加入到该锁的阻塞队列中进入blocked状态。

    线程的waiting状态:

    • 一个线程在等待执行一个(唤醒)动作时,该线程进入Waiting状态。进入这个状态后不能自动唤醒,必须等待另一个线程发出特定的指令才能够被唤醒。

    线程的timed_waiting状态:

    • 和上面的类似,只是这个状态的线程不会一直等下去,会有一个超时时间。

    线程的terminated状态

    • terminated是一个线程的最终状态,在该状态中线程将不会切换到其他任何状态,线程进入terminated状态,意味着该线程的整个生命周期结束了。

    线程运行正常结束,结束生命周期,或线程运行出错意外结束。JVM crash会导致所有的线程都结束。

    在这里插入图片描述
    NEW、RUNNABLE、TERMINATED这三个状态时一个线程必定会经历的,其余几个状态只有当线程遇到某种状态或执行了某个方法才会经历。

    4.线程join

    调用join()方法可以让其他线程处于waiting状态。

    如下面实例,我们分别在子线程调用join()方法前后获取一下主线程的状态

    class JoinThread extends Thread {
        Thread thread;
    
        public JoinThread(String str, Thread thread) {
            super(str);
            this.thread = thread;
        }
    
        @Override
        public void run() { 
    
            for (int i = 0; i < 3; i++) {
                System.out.println(this.getName());
                System.out.println("state: " + thread.getState()); 
            }
        }
    }
    
    public class TestApp {
        public static void main(String[] args) {  //主线程
            JoinThread thread = new JoinThread("子线程",Thread.currentThread());
            thread.start(); //启动子线程
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //主线程waiting  那么后面的代码在这段时间将不会被执行 直到调用join方法的这个线程执行完之后才会执行后续代码
            System.out.println("state: " + Thread.currentThread().getState());   //主线程被唤醒执行后的状态
            for (int i = 0; i < 4; i++) {
                System.out.println("主线程");
            }
        }
    }
    

    运行结果如图所示,可以看到,在调用了join()方法之后,主线程一直处于等待状态,直至子线程执行完毕:
    在这里插入图片描述

    若不调用join方法 ,那么子线程和主线程是同时在执行的,而不是如图先执行了子线程再执行了主线程。

    通过实例,来看一下join()方法的应用场景,假设你负责一个旅游app的航班功能,分别推送三个航空公司的航班时间给用户。

    我们可以启动三个线程,分别代表三家公司,主线程负责打印最后的结果,当三个子线程完成查询工作后,主线程才开始自己的功能执行。(为了方便,我们只设置8:00的航班)

    我们可以让三个子线程分别调用join()方法,使主线程处于等待状态。代码如下:

    class AirPlaneSearch implements Runnable {
        List<String> list;
    
        public AirPlaneSearch(List<String> list) {
            this.list = list;
        }
    
        @Override
        public void run() {   //查询各个航空公司的信息
            System.out.println("开始从" + Thread.currentThread().getName() + "查询航班信息");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (list) { // 加上线程锁 避免同时多个线程执行add操作
                list.add(Thread.currentThread().getName() + "8:00");
            }
        }
    }
    
    /**
     * 使用join方法
     */
    public class AirLine {
        public static void main(String[] args) {
            List<String> list = new LinkedList<>();
            AirPlaneSearch runnable = new AirPlaneSearch(list);
            Thread t1 = new Thread(runnable, "南方航空");
            Thread t2 = new Thread(runnable, "东方航空");
            Thread t3 = new Thread(runnable, "海南航空");
            t1.start();
            t2.start();
            t3.start();
            try {
                t1.join();
                t2.join();
                t3.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Iterator<String> iterator = list.iterator();
            System.out.println("--------------------------------------------");
            System.out.println("所查询的航班信息如下: ");
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }
    }
    

    运行结果如下:
    在这里插入图片描述在子线程的功能完成之后才输出list中的航班信息

    5.CountDownLatch 和CyclicBarrier

    用CountDownLatch可以避免写太多的join代码,先new出来一个CountDownLatch对象,将需要进行join操作的线程个数当作参数传递给构造函数,在子线程结束的时候对CountDownLatch进行减一操作,直至减为0后主线程开始执行它的功能。

    还是以航班信息为例,代码如下:

    class AirPlaneSearch2 implements Runnable {
        List<String> list;
        CountDownLatch latch ;
    
        public AirPlaneSearch2(List<String> list, CountDownLatch latch) {
            this.list = list;
            this.latch = latch;
        }
    
        @Override
        public void run() {   //查询各个航空公司的信息
            System.out.println("开始从" + Thread.currentThread().getName() + "查询航班信息");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (list) {
                list.add(Thread.currentThread().getName() + "8:00");
            }
            latch.countDown(); // count执行了一次减一
        }
    }
    
    /**
     * 使用CountDownLatch
     */
    public class AirLine2 {
        public static void main(String[] args) {
            List<String> list = new LinkedList<>();
            CountDownLatch latch = new CountDownLatch(3); //有几个子线程就设置为几
            AirPlaneSearch2 runnable = new AirPlaneSearch2(list,latch);
            Thread t1 = new Thread(runnable, "南方航空");
            Thread t2 = new Thread(runnable, "东方航空");
            Thread t3 = new Thread(runnable, "海南航空");
            t1.start();
            t2.start();
            t3.start();
            try {
                latch.await();    //等待latch中的count被减为 0 什么时候减为 0 后面的代码才开始执行
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Iterator<String> iterator = list.iterator();
            System.out.println("--------------------------------------------");
            System.out.println("所查询的航班信息如下: ");
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
        }
    }
    

    运行结果如下:
    在这里插入图片描述
    CyclicBarrier的参数和CountDownLatch差不多,按航班信息的例子来说,参数依然是3,不过CyclicBarrier不用使用方法进行减一操作,它会自动减一,直至0才开始执行中另一个参数Runnable()中的代码。

    class AirPlaneSearch3 implements Runnable {
        List<String> list;
        CyclicBarrier barrier;
    
        public AirPlaneSearch3(List<String> list, CyclicBarrier barrier) {
            this.list = list;
            this.barrier = barrier;
        }
    
        @Override
        public void run() {   //查询各个航空公司的信息
            System.out.println("开始从" + Thread.currentThread().getName() + "查询航班信息");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (list) {
                list.add(Thread.currentThread().getName() + "8:00");
            }
            //遇到awit自动减一
            try {
                //所有的线程相互等待直到把barrier中的值减为0
                barrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
    
    /**
     * 使用CyclicBarrier
     */
    public class AirLine3 {
        public static void main(String[] args) {
            final List<String> list = new LinkedList<>();
            // 什么时候barrier 减为0 Runnable中的方法被执行
            CyclicBarrier barrier = new CyclicBarrier(3, new Runnable(){
                @Override
                public void run() {
                    Iterator<String> iterator = list.iterator();
                    System.out.println("--------------------------------------------");
                    System.out.println("所查询的航班信息如下: ");
                    while (iterator.hasNext()){
                        System.out.println(iterator.next());
                    }
                }
            });
            AirPlaneSearch3 runnable = new AirPlaneSearch3(list,barrier);
            Thread t1 = new Thread(runnable, "南方航空");
            Thread t2 = new Thread(runnable, "东方航空");
            Thread t3 = new Thread(runnable, "海南航空");
            t1.start();
            t2.start();
            t3.start();
        }
    }
    

    运行结果如下:
    在这里插入图片描述
    由代码可以看出来:由于使用起来并不灵活,一般CyclicBarrier在实际开发中并不常用。

    6.线程中断

    上面说到,调用join()方法的线程可以试别的线程进入等待状态,在开发中可能会遇到让线程的等待状态被打断的情况,调用interrupt()方法,可以中断一个线程的等待状态。

    以下面实例来说,子线程调用join()方法后主线程进入等待状态,直到子线程打印操作结束后主线程才开始执行,而当第3次(由于cpu的调度,不一定正好三次)打印操作执行完后调用interrupt()方法,可以直接抛出异常,使得主线程的等待状态被打断。

    class JoinThread extends Thread {
        Thread thread;
        private static int i = 0;
    
        public JoinThread(String str, Thread thread) {
            super(str);
            this.thread = thread;
        }
    
        @Override
        public void run() {
            while(true) {
                i++;
                System.out.println(this.getName());
                if (i == 3) {
                    thread.interrupt();
                }
            }
        }
    }
    
    public class TestApp {
        public static void main(String[] args) {
            JoinThread thread = new JoinThread("子线程",Thread.currentThread());
            thread.start();
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int i = 0; i < 4; i++) {
                System.out.println("主线程");
            }
        }
    }
    

    运行结果如下:
    在这里插入图片描述

    线程中断的方法:
    Object的wait/wait (1ong) /wait (long, int)方法
    Thread的sleep (int) /sleep (long, int)
    Thread的join/join(long) /join(long, int)方法
     。。。。。。
    

    为什么调用了interrupt方法就会让线程的waiting状态被打断?

    答:调用了interrupt方法,会将线程中断位(interrupt
    flag)由false变成true,而在join方法会判断线程中断位的状态,如果为true就会抛出异常,从而结束线程的等待状态。如果异常被捕获到,线程中断位的值就会再变成false(被擦除)。
    获取线程中断位的方法可以通过实例方法this.isInterrupt()或静态方法Thread.interrupt(),两者的区别为后者再中断位被置为true后调用,线程中断位的值会被擦除,而前者不会主动擦除。

    7.如何关闭一个线程

    一个线程的结束再正常情况下即为一个线程的生命周期正常结束掉,通俗来说就是线程的run()方法从第一行代码执行到了最后一行。

    还有一种非正常结束,当这个线程还在工作当中,但不希望它继续工作下去了,就要采取一些方式让他结束掉。

    利用对线程中断位的值的控制可以做到对线程进行非正常的关闭

    class SonThread implements Runnable {
        @Override
        public void run() {
            while(true) {
                if(Thread.currentThread().isInterrupted()){
                    break;
                }
                System.out.println("子线程执行中");
            }
        }
    }
    
    public class TestApp {
        public static void main(String[] args) {
            SonThread runnable = new SonThread();
            Thread t = new Thread(runnable);
            t.start();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t.interrupt();
        }
    }
    

    当三秒之后调用interrupt,此时线程中断位置为false,子线程break出死循环,线程结束。

    缺点:如果程序在其他地方调用了类似方法(如sleep、join等),那么中断位的值是会被擦除的,导致程序出现错误的几率变高。

    捕获异常的方式同理:

    class SonThread implements Runnable {
        @Override
        public void run() {
            while(true) {
                try {
                    TimeUnit.NANOSECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break; // 捕获到异常之后要跳出循环
                }
                System.out.println("子线程执行中");
            }
        }
    }
    
    public class TestApp {
        public static void main(String[] args) {
            SonThread runnable = new SonThread();
            Thread t = new Thread(runnable);
            t.start();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t.interrupt();
        }
    }
    

    运行结果如下,三秒之后线程中断位值改变,抛出异常,结束线程:

    在这里插入图片描述

    抛出异常的处理方式的缺点:执行逻辑发生了改变 并且执行效率受到影响。

    上面两种方式都有各自的缺点,在实际的项目开发当中并实用,有一种更好的处理方式,可以避免这两种情况的缺点。

    我们给子线程提供一个静态变量flag,和一个关闭线程的静态方法。在run方法中定义:当flag的值变成true的时候break,在主线程处三秒后调用该静态方法使flag的值发生改变。

    class SonThread implements Runnable {
        private static volatile boolean flag = false;
    
        public static void CloseThread() {
            flag = true;
        }
    
        @Override
        public void run() {
            while(true) {
                if (flag) {
                    break;
                }
                System.out.println("子线程执行中");
            }
        }
    }
    
    public class TestApp {
        public static void main(String[] args) {
            SonThread runnable = new SonThread();
            Thread t = new Thread(runnable);
            t.start();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            SonThread.CloseThread();
        }
    }
    

    这样既不会抛出异常,也不会出现值被擦除的现象。

    关于volatile的线程安全问题将会在下一篇博客中讲解
    
    展开全文
  • 简单按键输入中断判断方法 1.了解按键接线。常见按键接线方式是:按键一端接到MCU,另外一端接到GND。如下图所示: 2.第一部分按键引脚初始化程序:需要结合你电路图。本文中按键连接到PC6,所以初始化...

    简单的按键输入中断判断方法

    1.了解按键的接线。常见的按键接线方式是:按键一端接到MCU,另外一端接到GND。如下图所示:
    在这里插入图片描述

    2.第一部分按键引脚初始化程序:需要结合你的电路图。本文中的按键连接到PC6,所以初始化STM32中C组的第6引脚为输入。

    第二部分是NVIC初始化:
    设置中断源:哪一个引脚就对应哪一个中断源。
    设置IRQ通道:每一个引脚对应的通道不一样,可以跳转到stm32f10x.h文件中查看。
    分配抢占优先级和响应优先级。注意一个工程的NVIC分组是同一个,对应的设置可以查看NVIC表格(网上有很多,可自行查找)。

    第三部分:外部中断的配置。
    配置外部中断线。每一个引脚对应一条中断线。
    配置中断方式:中断或是事件。
    配置边沿触发:上升沿、下降沿、边沿。

    /*
     *功能:KEY初始化
     * 参数:无
     * 返回值:无
     */
    void KEY_Init(void)
    { 
    		EXTI_InitTypeDef EXTI_InitStruct;
    		NVIC_InitTypeDef NVIC_InitStruct;
    		GPIO_InitTypeDef GPIO_InitStruct;
    		
    		RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
    		RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
    		
    		/************* 第一部分 **************/
    		GPIO_InitStruct.GPIO_Pin = GPIO_Pin_6;
    		GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IPU;	
    		GPIO_Init(GPIOC, &GPIO_InitStruct);
    
    	
    		/************* 第二部分 **************/
    		GPIO_EXTILineConfig(GPIO_PortSourceGPIOC,GPIO_PinSource6);
    		NVIC_InitStruct.NVIC_IRQChannel=EXTI9_5_IRQn;
    		NVIC_InitStruct.NVIC_IRQChannelCmd=ENABLE;
    		NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority=2;
    		NVIC_InitStruct.NVIC_IRQChannelSubPriority=2;
    		NVIC_Init(&NVIC_InitStruct);
    		
    		/************* 第三部分 **************/
    		EXTI_InitStruct.EXTI_Line=EXTI_Line6;
    		EXTI_InitStruct.EXTI_LineCmd=ENABLE;
    		EXTI_InitStruct.EXTI_Mode=EXTI_Mode_Interrupt;
    		EXTI_InitStruct.EXTI_Trigger=EXTI_Trigger_Falling;
    		EXTI_Init(&EXTI_InitStruct);
    }
    

    3.中断服务程序,在中断处理函数里面可以实现简单的处理程序。尽量不要在里面处理太多东西,内容尽量的少。

    //按键中断服务程序
    void EXTI9_5_IRQHandler(void)
    {
       if(EXTI_GetITStatus(EXTI_Line6) != RESET)  //检测是否触发对应的中断
        {
           delay_ms(10);
            key1_on=~key1_on;
    			
    			if(key1_on)
    			{
    				LCD_ShowString_12X24(24*6,5, "LED", White, Black,1);
    			}
    			else
    			{	
    				LCD_ShowString_12X24(24*6,5, "   ", White, Black,1);
    			}
        }
    		EXTI_ClearITPendingBit(EXTI_Line6);
    }
    

    注意:可能遇到的问题
    问题:按键反应太过灵敏,有时候按一次会触发多次。
    解决:在按键的两端(上图中的4和2)连接一个104电容。

    展开全文
  • 方法 说明 alert(msg) 浏览器弹出警告框 console.log(msg) 浏览器控制台打印输出信息 prompt(info) 浏览器弹出输入框,用户可以输入 prompt('请输入您年龄'); alert('弹出框'); console.log...
  • Java中原来在Thread中提供了stop()方法来终止线程,但这个方法是不安全,所以一般不建议使用。 本文向大家介绍使用interrupt方法中断线程。 使用interrupt方法来终端线程可分为两种情况: (1)线程处于阻塞...
  • setPriority(int p) 设置线程的优先级;interrupt() 有条件中断线程;sleep(long s) (static)使线程睡眠;让出cpu资源;currentThread() (static)获取当前正在执行线程;isAlive() 判断线程是否在活动状态;yield()...
  • 文章目录1 线程状态简述2 Thread类常用方法2.1 start()与run()2.2 sleep()与yield()2.2.1 sleep()2.2.2 yield()2.3 wait()2.4 join()2.5 interrupt()(1)判断线程是否被中断(2)如何中断线程(3)总结3 线程优先级...
  • STM32学习 第七天

    2019-07-18 17:59:36
    一、判断步进电机线圈的引线快捷方法:将两根线短接在一起,转动步进电机的...具有高抢占式优先级的中断可以在具有低抢占式优先级的中断处理过程中被响应,即中断嵌套,或者说高抢占式优先级可以在低抢占式优先级...
  • Thread类包含的方法 start() 启动线程 isAlive() 判断线程当前是否正在运行 setPriority() 设置优先级 jion() 使一个线程等待另一个线程结束 sleep(mills:long) 指定线程休眠指定毫秒 yield() 使线程暂停并允许执行...
  • java多线程之线程基础

    2021-04-21 19:29:48
    使用匿名内部类4.Lambda表达式线程池创建线程挂起和恢复什么是挂起线程为什么要挂起线程如何挂起线程被废弃的方法可以使用的方法什么时候时候使用挂起线程线程的中断操作stop() 废弃方法Thread.interrupt方法自行...
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    5.19 如何访问位于机器地址0处的中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零空指针内部表示。 5.20运行时“nullpointerassignment”错误是什么意思?应该怎样捕捉它? 第6章 数组和指针...
  • 8259AICW2给定为80H,工作于电平触发方式,全嵌套中断优先级,数据总线无缓冲,采用中断自动结束方式。请填充下面程序中空白项(注意:控制字中可0可1位选0,8255未用端口设成输入方式),(微处理器8086A1、A2...
  • 微型计算机讲稿

    2004-10-15 18:46:45
    1. 中断基本概念:中断、开中断、关中断、中断优先级、中断嵌套、中断响应条件、中断过程 2. 8086中断系统 。中断矢量表及存放位置,如何填写 。中断分类:内部中断(软件中断) 外部中断(硬件中断...
  • 5.19 如何访问位于机器地址0处的中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零空指针内部表示。  5.20运行时“nullpointerassignment”错误是什么意思?应该怎样捕捉它?  第6章 数组和...
  • 5.19 如何访问位于机器地址0处的中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零空指针内部表示。 62  5.20 运行时“null pointer assignment”错误是什么意思?应该怎样捕捉它? 62 第6章...
  • 5.19 如何访问位于机器地址0处的中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零空指针内部表示。 5.20运行时“nullpointerassignment”错误是什么意思?应该怎样捕捉它? 第6章 数组和...
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    可我找不到任何方法来声明这样函数——感觉我需要一个返回指针函数,返回指针指向又是返回指针函数……,如此往复,以至无穷。 12  数组大小 13 1.23 能否声明和传入数组大小一致局部数组,或者由...
  • 定时方法测量是待测信号周期,这种方法只设 一种量程,测量结果通过浮点数运算模块将信号周期转换成对应频率值,再将 结果送去显示。这样无论采用何种方式,只要完成一次测量即可,频率计自动开 始下一个测量...
  • 中文名: 你必须知道495个C语言问题 高清PDF中文版 原名: C Programming FAQs 作者: (美)萨米特译者: 孙云 ...5.19 如何访问位于机器地址0处的中断向量?如果我将指针值设为0,编译器可能会自动将...
  •  5.19 如何访问位于机器地址0处的中断向量?如果我将指针值设为0,编译器可能会自动将它转换为非零空指针内部表示。  5.20 运行时“null pointer assignment”错误是什么意思?应该怎样捕捉它? 第6章 数组和...
  • 可我找不到任何方法来声明这样函数——感觉我需要一个返回指针函数,返回指针指向又是返回指针函数,如此往复,以至无穷。 数组大小 1.23 能否声明和传入数组大小一致局部数组,或者由其他参数指定大小...
  • 如图 1.1所示为测试代码运行流程,通过GPIO拉高到拉低时间来判断定时器精准度。 1.2 测试方法 1.2.1 测试模型 利用ZYNQ内部私有定时器,设置定时时间250μs并绑定中断。在中断服务程序中拉高GPIO,下一次进入...
  • 可我找不到任何方法来声明这样函数——感觉我需要一个返回指针函数,返回指针指向又是返回指针函数……,如此往复,以到无穷。 41 数组大小 42 1.23 能否声明和传入数组大小一致局部数组,或者由其他...
  • 可我找不到任何方法来声明这样函数——感觉我需要一个返回指针函数,返回指针指向又是返回指针函数……,如此往复,以到无穷。 41 数组大小 42 1.23 能否声明和传入数组大小一致局部数组,或者由其他...
  • JavaScript 05 - 操作符

    2020-05-25 00:01:42
    算数运算符02 - 表达式和返回值03 - 前置递增运算符04 - 后置递增运算符05 - 递增运算符练习06 - 比较运算符07 - 逻辑运算符08 - 逻辑运算符练习09 - 短路运算(逻辑中断)10 - 赋值运算符11 - 运算符优先级 ...
  • 9.4 线程操作相关方法  9.4.1 取得和设置线程名称  9.4.2 判断线程是否启动  9.4.3 线程强制运行  9.4.4 线程休眠  9.4.5 中断线程  9.4.6 后台线程  9.4.7 线程的优先级  9.4.8 线程礼让 ...
  • 2.1、判断线程是否中断? 3、interrupt() 4、stop() 5、suspend()和resume() 6、yield() 7、线程优先级 8、守护线程 9、Synchronized实现原理 10、脏读(dirty read) 11、可重入锁 12、同步方法的弊端,...

空空如也

空空如也

1 2 3
收藏数 56
精华内容 22
关键字:

中断优先级的判断方法