闲着没事，研究了一些M3的任务切换模型,贴出代码来,大家...

zhouwenjing

就弄了两个任务，两个死循环,没有考虑中断什么的，仅供学习之用啊，呵呵

程序运行于非特权模式，使用PSP寄存器

1. 
   
2. #include <LPC17xx.H>
   
3. 
   
4. void task2(void);
   
5. void task1(void);
   
6. 
   
7. int stack1[256];
   
8. int stack2[256];
   
9. 
   
10. int *spt1=&stack1[256-1];
    
11. int *spt2=&stack2[256];
    
12. 
    
13. extern void SVC_CALL(int );
    
14. void SVC_CALLin(void);
    
15. void main(void)
    
16. {
    
17.      //register int i=10,t=19;
    
18.      //8个自动压栈内容，最底下四个个是r0-r3,通过这几个寄存器可以给任务传递参数，创建带参数的任务
    
19.      *spt1--=0x21000000;//程序装态寄存器
    
20.      *spt1--=(unsigned long)task1;//任务入口地址，你懂的
    
21.      *spt1--=0x44d;
    
22.      *spt1--=0;
    
23.      *spt1--=0;
    
24.      *spt1--=0;
    
25.      *spt1--=0;
    
26.      *spt1=0;
    
27. 
    
28.      
    
29.      //*spt2=(unsigned long)task2;
    
30.      *spt2--=0x21000000;
    
31.      *spt2--=(unsigned long)task2;
    
32.      *spt2--=0x44d;
    
33.      *spt2--=0;
    
34.      *spt2--=0;
    
35.      *spt2--=0;
    
36.      *spt2--=0;
    
37.      *spt2=0;
    
38.      
    
39.      //启动任务
    
40.     SVC_CALLin();
    
41.    
    
42. 
    
43. }
    
44. 
    
45. 
    
46. __asm void SVC_Handler(void)
    
47. {
    
48.         import spt1
    
49.         import spt2
    
50.         tst lr,#4
    
51.         mrseq r0,msp
    
52.         mrsne r0,psp
    
53.         ldr r1,[r0,#24]
    
54.         ldrb r1,[r1,#-2]
    
55.         ;//根据以前的栈内容，确定SVC指令后面的标号
    
56.      ;//存放于R1中
    
57.         
    
58.      CMP r1,#0x0
    
59.         ;//如果标号为0，表示从main函数中进入，
    
60.      bne sw_context;//否则是任务切换请求，跳转到任务指令位置
    
61.      ldr r2,=spt1
    
62.         ldr r0,[r2]
    
63.         msr psp,r0   
    
64.         bx lr
    
65.         
    
66. sw_context
    
67.         ;//任务切换指令位置                  
    
68.      CMP r1,#1
    
69.         bne sw_task2
    
70. sw_task1
    
71.         ldr r2,=spt1
    
72.         ldr r3,=spt2
    
73.         b ret
    
74. sw_task2        
    
75.         ldr r2,=spt2
    
76.         ldr r3,=spt1
    
77. 
    
78. ret
    
79.         ldr r0,[r2]
    
80.         mrs r1,psp  ;//将当前栈保存到指针
    
81.      str r1,[r3]
    
82.         msr psp,r0  ;//将下一个任务的栈指针保存到psp，进行任务切换
    
83.      bx lr       ;//
    
84. }
    
85. 
    
86. __asm void SVC_CALL(int id)
    
87. {
    
88.     push {R4-r12};//压栈，保存现场,P1-p3,lr,进入异常模式时自动压栈，这里不用处理
    
89.   
    
90.    CMP r0,#1  
    
91.     SVCEQ #1   
    
92.     SVCNE #2
    
93.     pop {r4-r12};//异常返回后。出栈
    
94.    bx lr;
    
95. 
    
96. }
    
97. 
    
98. __asm void SVC_CALLin(void)
    
99. {
    
100.     SVC #0
     
101.     bx lr
     
102. }
     
103. 
     
104. void task1(void)
     
105. {
     
106.     int i,n;
     
107.     for(i=0;i<100000000;i++)
     
108.     {
     
109.         for(n=0;n<1999;n++);
     
110.         SVC_CALL(2);//切换到任务2
     
111.     }
     
112.     ;
     
113. }
     
114. 
     
115. 
     
116. 
     
117. 
     
118. void task2(void)
     
119. {
     
120.     int i,n;
     
121.     for(i=0;i<100000000;i+=2)
     
122.     {
     
123.         for(n=0;n<3000;n++);
     
124.         SVC_CALL(1);//切换到任务1
     
125.     }
     
126.     ;
     
127. }
     
128. 
     

复制代码

learner123

为了换取ID还真不容易啊

zhouwenjing

确实，挺麻烦的
第一步，读lr的值，判断之前用的是哪一个栈指针寄存器
第二步，读栈指针寄存器到通用寄存器
第三步，找到对应栈中PC的位置，为什么是24，因为前面有24个字节:r0,r1,r2,r3,r12,lr
第四步，读取SVC代码内容，获取标号,注意偏移量

sam_zhang

支持一下，很好

zhouwenjing

后面，有空写个定时任务调度器，玩玩

zhouwenjing

后面，有时间写个任务定时调度器玩玩

wkong501

谢谢，SVCall 调用程序