📄 schedule.lis
字号:
.module schedule.c
.area text(rom, con, rel)
; result -> R16
.even
0000 _atomic_start::
0000 ; #include <iom128v.h>
0000 ; #include <macros.h>
0000 ; #include "schedule.h"
0000 ; #include "timer.h"
0000 ;
0000 ; typedef struct {
0000 ; void (*tp) ();
0000 ; } TOSH_sched_entry_T;
0000 ; typedef unsigned char uint8_t;
0000 ; enum {
0000 ;
0000 ; TOSH_MAX_TASKS = 8,
0000 ; TOSH_TASK_BITMASK = (TOSH_MAX_TASKS - 1)
0000 ; };
0000 ;
0000 ; volatile TOSH_sched_entry_T TOSH_queue[TOSH_MAX_TASKS];
0000 ; uint8_t TOSH_sched_full;
0000 ; volatile uint8_t TOSH_sched_free;
0000 ;
0000 ; uint8_t atomic_start(void)
0000 ; {
0000 ; uint8_t result = SREG;
0000 0FB7 in R16,0x3f
0002 ; CLI();
0002 F894 cli
0004 ; return result;
0004 L3:
0004 .dbline 0 ; func end
0004 0895 ret
0006 ; oldSreg -> R16
.even
0006 _atomic_end::
0006 ; }
0006 ;
0006 ; void atomic_end(uint8_t oldSreg)
0006 ; {
0006 ; SREG=oldSreg;
0006 0FBF out 0x3f,R16
0008 L4:
0008 .dbline 0 ; func end
0008 0895 ret
.even
000A _TOSH_wait::
000A ; }
000A ;
000A ;
000A ; /* These are provided in HPL.td */
000A ; void TOSH_wait()
000A ; {
000A ; asm("nop");
000A 0000 nop
000C ; asm("nop");
000C 0000 nop
000E L5:
000E .dbline 0 ; func end
000E 0895 ret
.even
0010 _TOSH_sleep::
0010 ;
0010 ; }
0010 ;
0010 ; void TOSH_sleep()
0010 ; {
0010 ; MCUCR |= 1<<5;
0010 85B7 in R24,0x35
0012 8062 ori R24,32
0014 85BF out 0x35,R24
0016 L6:
0016 .dbline 0 ; func end
0016 0895 ret
0018 ; i -> R20,R21
.even
0018 _sched_init::
0018 0E940000 xcall push_gset1
001C ; // asm("sleep");
001C ; //MCUCR =0x0;
001C ;
001C ; //sbi(MCUCR, 5);
001C ; //sbi(MCUCR, SE);
001C ; //asm volatile ("sleep");
001C ; }
001C ;
001C ; void sched_init(void)
001C ; {
001C ; int i;
001C ; TOSH_sched_free = 0;
001C 2224 clr R2
001E 20920000 sts _TOSH_sched_free,R2
0022 ; TOSH_sched_full = 0;
0022 20920100 sts _TOSH_sched_full,R2
0026 ; for (i = 0; i < TOSH_MAX_TASKS; i++)
0026 4427 clr R20
0028 5527 clr R21
002A L8:
002A 02E0 ldi R16,2
002C 10E0 ldi R17,0
002E 9A01 movw R18,R20
0030 0E940000 xcall empy16s
0034 F801 movw R30,R16
0036 80E0 ldi R24,<_TOSH_queue
0038 90E0 ldi R25,>_TOSH_queue
003A E80F add R30,R24
003C F91F adc R31,R25
003E 2224 clr R2
0040 3324 clr R3
0042 3182 std z+1,R3
0044 2082 std z+0,R2
0046 L9:
0046 4F5F subi R20,255 ; offset = 1
0048 5F4F sbci R21,255
004A 4830 cpi R20,8
004C E0E0 ldi R30,0
004E 5E07 cpc R21,R30
0050 64F3 brlt L8
0052 L7:
0052 0E940000 xcall pop_gset1
0056 .dbline 0 ; func end
0056 0895 ret
0058 ; fInterruptFlags -> R20
0058 ; tmp -> R10
0058 ; tp -> R22,R23
.even
0058 _post::
0058 0E940000 xcall push_gset3
005C B801 movw R22,R16
005E ; TOSH_queue[i].tp = 0x0;
005E ; }
005E ;
005E ; /*
005E ; * TOS_post (thread_pointer)
005E ; *
005E ; * Put the task pointer into the next free slot.
005E ; * Return 1 if successful, 0 if there is no free slot.
005E ; *
005E ; * This function uses a critical section to protect TOSH_sched_free.
005E ; * As tasks can be posted in both interrupt and non-interrupt context,
005E ; * this is necessary.
005E ; */
005E ; char post(void (*tp) ()) {
005E ; uint8_t fInterruptFlags;
005E ; uint8_t tmp;
005E ;
005E ; fInterruptFlags = atomic_start();
005E D0DF xcall _atomic_start
0060 402F mov R20,R16
0062 ;
0062 ; tmp = TOSH_sched_free;
0062 A0900000 lds R10,_TOSH_sched_free
0066 ;
0066 ; if (TOSH_queue[tmp].tp == 0x0) {
0066 82E0 ldi R24,2
0068 8A9D mul R24,R10
006A F001 movw R30,R0
006C 80E0 ldi R24,<_TOSH_queue
006E 90E0 ldi R25,>_TOSH_queue
0070 E80F add R30,R24
0072 F91F adc R31,R25
0074 2080 ldd R2,z+0
0076 3180 ldd R3,z+1
0078 2220 tst R2
007A A1F4 brne L13
007C 3320 tst R3
007E 91F4 brne L13
0080 X0:
0080 ; TOSH_sched_free = (tmp + 1) & TOSH_TASK_BITMASK;
0080 8A2D mov R24,R10
0082 8F5F subi R24,255 ; addi 1
0084 8770 andi R24,7
0086 80930000 sts _TOSH_sched_free,R24
008A ; TOSH_queue[tmp].tp = tp;
008A 82E0 ldi R24,2
008C 8A9D mul R24,R10
008E F001 movw R30,R0
0090 80E0 ldi R24,<_TOSH_queue
0092 90E0 ldi R25,>_TOSH_queue
0094 E80F add R30,R24
0096 F91F adc R31,R25
0098 7183 std z+1,R23
009A 6083 std z+0,R22
009C ; atomic_end(fInterruptFlags);
009C 042F mov R16,R20
009E B3DF xcall _atomic_end
00A0 ; return 1;
00A0 01E0 ldi R16,1
00A2 03C0 xjmp L12
00A4 L13:
00A4 ; }
00A4 ; else {
00A4 ; atomic_end(fInterruptFlags);
00A4 042F mov R16,R20
00A6 AFDF xcall _atomic_end
00A8 ; return 0;
00A8 0027 clr R16
00AA L12:
00AA 0E940000 xcall pop_gset3
00AE .dbline 0 ; func end
00AE 0895 ret
00B0 ; fInterruptFlags -> R22
00B0 ; func -> R20,R21
00B0 ; old_full -> R10
.even
00B0 _TOSH_run_next_task::
00B0 0E940000 xcall push_gset3
00B4 ; }
00B4 ; }
00B4 ;
00B4 ; /*
00B4 ; * TOSH_schedule_task()
00B4 ; *
00B4 ; * Remove the task at the head of the queue and execute it, freeing
00B4 ; * the queue entry. Return 1 if a task was executed, 0 if the queue
00B4 ; * is empty.
00B4 ; */
00B4 ;
00B4 ; int TOSH_run_next_task ()
00B4 ; {
00B4 ; uint8_t fInterruptFlags;
00B4 ; uint8_t old_full;
00B4 ; void (*func)(void);
00B4 ;
00B4 ; fInterruptFlags = atomic_start();
00B4 A5DF xcall _atomic_start
00B6 602F mov R22,R16
00B8 ; old_full = TOSH_sched_full;
00B8 A0900100 lds R10,_TOSH_sched_full
00BC ; func = TOSH_queue[old_full].tp;
00BC 82E0 ldi R24,2
00BE 8A9D mul R24,R10
00C0 F001 movw R30,R0
00C2 80E0 ldi R24,<_TOSH_queue
00C4 90E0 ldi R25,>_TOSH_queue
00C6 E80F add R30,R24
00C8 F91F adc R31,R25
00CA 4081 ldd R20,z+0
00CC 5181 ldd R21,z+1
00CE ; if (func == 0x0)
00CE 4030 cpi R20,0
00D0 4507 cpc R20,R21
00D2 29F4 brne L16
00D4 X1:
00D4 ; {
00D4 ; atomic_end(fInterruptFlags);
00D4 062F mov R16,R22
00D6 97DF xcall _atomic_end
00D8 ; // printf("return 0\n");
00D8 ; return 0;
00D8 0027 clr R16
00DA 1127 clr R17
00DC 17C0 xjmp L15
00DE L16:
00DE ; }
00DE ;
00DE ; TOSH_queue[old_full].tp = 0x0;
00DE 82E0 ldi R24,2
00E0 8A9D mul R24,R10
00E2 F001 movw R30,R0
00E4 80E0 ldi R24,<_TOSH_queue
00E6 90E0 ldi R25,>_TOSH_queue
00E8 E80F add R30,R24
00EA F91F adc R31,R25
00EC 2224 clr R2
00EE 3324 clr R3
00F0 3182 std z+1,R3
00F2 2082 std z+0,R2
00F4 ; TOSH_sched_full = (old_full + 1) & TOSH_TASK_BITMASK;
00F4 8A2D mov R24,R10
00F6 8F5F subi R24,255 ; addi 1
00F8 8770 andi R24,7
00FA 80930100 sts _TOSH_sched_full,R24
00FE ; atomic_end(fInterruptFlags);
00FE 062F mov R16,R22
0100 82DF xcall _atomic_end
0102 ; func();
0102 FA01 movw R30,R20
0104 0E940000 xcall xicall
0108 ; // printf("tsk\n");
0108 ; //printf("running task %d",old_full);
0108 ; return 1;
0108 01E0 ldi R16,1
010A 10E0 ldi R17,0
010C L15:
010C 0E940000 xcall pop_gset3
0110 .dbline 0 ; func end
0110 0895 ret
0112 ; x -> <dead>
0112 ; fInterruptFlags -> <dead>
.even
0112 _run_task::
0112 ; }
0112 ; extern sleep_flag;
0112 ; void run_task() {
0112 L19:
0112 L20:
0112 ; uint8_t fInterruptFlags,x;
0112 ; while (TOSH_run_next_task())
0112 CEDF xcall _TOSH_run_next_task
0114 0030 cpi R16,0
0116 0107 cpc R16,R17
0118 E1F7 brne L19
011A X2:
011A ; ;
011A ; /* fInterruptFlags = atomic_start();
011A ; x = (T1.on==1) ||(T2.on==1)||(T3.on==1);
011A ; atomic_end(fInterruptFlags);
011A ; if (x)//||(sleep_flag==0))
011A ; */
011A ; if((T1.on==1) ||(T2.on==1)||(T3.on==1))
011A 80910100 lds R24,_T1+1
011E 8130 cpi R24,1
0120 41F0 breq L28
0122 80910100 lds R24,_T2+1
0126 8130 cpi R24,1
0128 21F0 breq L28
012A 80910100 lds R24,_T3+1
012E 8130 cpi R24,1
0130 09F4 brne L30
0132 L28:
0132 ; ;
0132 06C0 xjmp L23
0134 X3:
0134 ; else
0134 ; {
0134 L29:
0134 L30:
0134 ; while (TOSH_run_next_task())
0134 BDDF xcall _TOSH_run_next_task
0136 0030 cpi R16,0
0138 0107 cpc R16,R17
013A E1F7 brne L29
013C X4:
013C ; ;
013C ; TOSH_sleep();
013C 69DF xcall _TOSH_sleep
013E ; TOSH_wait();
013E 65DF xcall _TOSH_wait
0140 ; }
0140 L23:
0140 L18:
0140 .dbline 0 ; func end
0140 0895 ret
.even
0142 ___nesc_enable_interrupt::
0142 ;
0142 ;
0142 ; //printf("wkup\n");
0142 ; //delay_x(1000);
0142 ;
0142 ; }
0142 ;
0142 ;
0142 ;
0142 ; void __nesc_enable_interrupt() {
0142 ; SEI();
0142 7894 sei
0144 L32:
0144 .dbline 0 ; func end
0144 0895 ret
.area bss(ram, con, rel)
0000 _TOSH_sched_free::
0000 .blkb 1
0001 _TOSH_sched_full::
0001 .blkb 1
0002 _TOSH_queue::
0002 .blkb 16
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -