.module kernel.c .area data 0200 _main_frame_ptr:: 0200 .blkb 2 .area idata --- 0000 0000 .word 0 .area data 0202 _main_frame_x_ptr:: 0202 .blkb 2 .area idata --- 0002 0000 .word 0 .area data 0204 _temp_task_frame_ptr:: 0204 .blkb 2 .area idata --- 0004 0000 .word 0 .area data 0206 _kdb_trace:: 0206 .blkb 2 .area idata --- 0006 0001 .word 1 .area data 0208 _kdb_trace_cycle:: 0208 .blkb 2 .area idata --- 0008 0000 .word 0 .area data .area text 102A _error_msg:: 102A 756E696D706C696D656E746564206675 .byte 'u,'n,'i,'m,'p,'l,'i,'m,'e,'n,'t,'e,'d,32,'f,'u 103A 6E6374696F6E00 .byte 'n,'c,'t,'i,'o,'n,0 1041 0000 .byte 0,0 1043 73796E746178206572726F7200 .byte 's,'y,'n,'t,'a,'x,32,'e,'r,'r,'o,'r,0 1050 00000000000000000000 .word 0,0,0,0,0 105A 0000 .byte 0,0 105C 696C6C6567616C207461736B20494400 .byte 'i,'l,'l,'e,'g,'a,'l,32,'t,'a,'s,'k,32,'I,'D,0 106C 000000000000000000 .byte 0,0,0,0,0,0,0,0,0 1075 696C6C6567616C207461736B20737461 .byte 'i,'l,'l,'e,'g,'a,'l,32,'t,'a,'s,'k,32,'s,'t,'a 1085 746500 .byte 't,'e,0 1088 000000000000 .byte 0,0,0,0,0,0 108E 696C6C6567616C207461736B20707269 .byte 'i,'l,'l,'e,'g,'a,'l,32,'t,'a,'s,'k,32,'p,'r,'i 109E 6F7269747900 .byte 'o,'r,'i,'t,'y,0 10A4 000000 .byte 0,0,0 10A7 6F7574206F66206D656D6F727900 .byte 'o,'u,'t,32,'o,'f,32,'m,'e,'m,'o,'r,'y,0 10B5 00000000000000000000 .word 0,0,0,0,0 10BF 00 .byte 0 10C0 696C6C6567616C207265736F75726365 .byte 'i,'l,'l,'e,'g,'a,'l,32,'r,'e,'s,'o,'u,'r,'c,'e 10D0 20494400 .byte 32,'I,'D,0 10D4 0000000000 .byte 0,0,0,0,0 10D9 696C6C6567616C207265736F75726365 .byte 'i,'l,'l,'e,'g,'a,'l,32,'r,'e,'s,'o,'u,'r,'c,'e 10E9 20737461746500 .byte 32,'s,'t,'a,'t,'e,0 10F0 0000 .byte 0,0 10F2 63616E6E6F7420637265617465207461 .byte 'c,'a,'n,'n,'o,'t,32,'c,'r,'e,'a,'t,'e,32,'t,'a 1102 736B00 .byte 's,'k,0 1105 000000000000 .byte 0,0,0,0,0,0 110B _error_src:: 110B 6B65726E656C206572726F723A00 .byte 'k,'e,'r,'n,'e,'l,32,'e,'r,'r,'o,'r,58,0 1119 00000000 .byte 0,0,0,0 111D 6B65726E656C2E63206572726F723A00 .byte 'k,'e,'r,'n,'e,'l,46,'c,32,'e,'r,'r,'o,'r,58,0 112D 0000 .byte 0,0 112F 6B65726E656C20525449206572726F72 .byte 'k,'e,'r,'n,'e,'l,32,'R,'T,'I,32,'e,'r,'r,'o,'r 113F 3A00 .byte 58,0 1141 7368656C6C206572726F723A00 .byte 's,'h,'e,'l,'l,32,'e,'r,'r,'o,'r,58,0 114E 0000000000 .byte 0,0,0,0,0 1153 73656D6C69622E63206572726F723A00 .byte 's,'e,'m,'l,'i,'b,46,'c,32,'e,'r,'r,'o,'r,58,0 1163 0000 .byte 0,0 1165 ; lreg1 -> -4,x 1165 ; lreg2 -> -8,x 1165 ; ?temp -> -19,x 1165 ; ?temp -> -19,x 1165 ; ?temp -> -19,x 1165 ; ?temp -> -21,x 1165 ; ?temp -> -19,x 1165 ; id -> -17,x 1165 ; result -> -15,x 1165 ; priority_check -> -13,x 1165 ; deadline -> -12,x 1165 ; i -> -10,x 1165 _main:: 1165 34 pshx 1166 B775 tfr s,x 1168 1BF1E2 leas -30,sp 116B ; /* RLPOS: RLPotter Operating System 116B ; 116B ; Version 0.7 for the 68HC12D60A microcontroller 116B ; by Ryan Potter 116B ; ryan@rlpotter.com 116B ; 116B ; 116B ; v0.7 April 25, 2003: 11174 bytes: 116B ; - combined kernel.c & semlib.c with rlpos.c to make one big kernel.c 116B ; - changed context switch mechanism to give each task a dedicated 116B ; stack, making the kernel context switches >400% faster. 116B ; - added a basic timer task that will eventually keep system time/date. 116B ; 116B ; v0.6 April 24, 2003: 11042 bytes 116B ; - made the task block and the task control block dynamic, so that 116B ; now tasks can create tasks, and can also start/stop them 116B ; - implemented the sysInit() task for kicking off a user system 116B ; - implemented a kernel debug command for tracing code execution 116B ; - implemented small msg box system in kernel for tasks 116B ; - implemented COP watchdog reset timer 116B ; - added system resources to semlib 116B ; - added skeleton ISR_handler() code for the other interrupts 116B ; - implemented _HC12Setup.c to initialize/harden the system 116B ; 116B ; v0.5 April 16, 2003: 116B ; - added priority preemption 116B ; - finished kernel task state switcher 116B ; - it is now officially a legitimate 116B ; rate monotonic 116B ; priority preemptive 116B ; multitasking 116B ; Real Time Operating System :) 116B ; - made kernel.c and semlib.c consistent with the 116B ; rest of the kernel 116B ; - included the early framework for a msg box system 116B ; 116B ; v0.4 April 13, 2003: 8096 bytes 116B ; - gerneralized the shell command-line input parser: 116B ; cmd (up to 32 chars) 116B ; - added kernel and shell functions 116B ; 116B ; v0.3 April 12, 2003: 6155 bytes 116B ; - added a beginning shell user interface. 116B ; - added a resource control block and basic semaphore functions. 116B ; - added basic kernel functions 116B ; 116B ; v0.2 April 9, 2003: 116B ; - able to round-robin with RTI interrupt. 116B ; - bonified/certified multitasking with 3 tasks. :) 116B ; 116B ; v0.1 April 3, 2003: 116B ; - able to round-robin without interrupts. 116B ; - not multitasking, really. 116B ; 116B ; v0.0 started April 1, 2003; 0 bytes 116B ; - no idea where to start. 116B ; - don't want to look at anyone else's work. ;0) 116B ; 116B ; 116B ; 116B ; 116B ; Architecture/C assumptions: 116B ; 1) 'D' register is the accumulator 116B ; 2) 'X' register points to the top of the current stack 116B ; 3) 'Y' register is for general use in indexed operations 116B ; 4) the heap grows upward and mem segments allocated by malloc, 116B ; realloc, and calloc are linear and contiguous. 116B ; 5) the stack grows downwards, and there is no boundary checking. 116B ; 116B ; Potential problem areas: 116B ; 1) 'running' section of the kernel get's compiled using extra 116B ; push and pop instructions 116B ; 2) run out of ram (global + stack + heap) 116B ; 116B ; */ 116B ; 116B ; 116B ; 116B ; #include <912d60.h> 116B ; #include 116B ; #include 116B ; #include 116B ; #include "kernel.h" 116B ; 116B ; 116B ; 116B ; // FUNCTION PROTOTYPES 116B ; void RTI_handler(void); 116B ; void sysInit(void); 116B ; void shell(void); 116B ; void sysTime(void); 116B ; void (*task_ptr[MAXTASKS])(void); 116B ; 116B ; 116B ; 116B ; 116B ; // GLOBAL VARIABLES 116B ; unsigned char *main_frame_ptr = NULL; // bottom of main() frame 116B ; unsigned char *main_frame_x_ptr = NULL; // top of main() frame (x-reg ptr) 116B ; unsigned char *temp_task_frame_ptr = NULL; // temp CCR pointer for RTI 116B ; 116B ; 116B ; unsigned int current; // current task id number 116B ; unsigned long int system_tick; 116B ; unsigned int cop_cycle; 116B ; 116B ; unsigned long int time_tick; 116B ; unsigned long int delta_t; 116B ; unsigned long int last_time_mark; 116B ; 116B ; 116B ; // task control block 116B ; typedef struct task_block { 116B ; void (*address)(); // Address of the task 116B ; unsigned char id; // ID of task 116B ; char name[9]; // Name 116B ; enum task_state state; // State 116B ; unsigned char priority; // Priority 116B ; unsigned long int period_tick; // for determining if deadline is up 116B ; unsigned int interrupt_msg_box; // flags for pending interrupts 116B ; enum message_box message; // misc flags 116B ; unsigned char message_data[2]; // data for misc_msg_box flags 116B ; unsigned int stack_size; // heap allocated for task stack 116B ; unsigned char *top_of_stack; // top of task stack in the heap 116B ; unsigned char *frame_ptr; // CCR pointer in idle stack 116B ; }; 116B ; 116B ; 116B ; // resource control block 116B ; typedef struct resource_block { 116B ; unsigned char id; // ID of resource 116B ; char name[5]; // Name of resource 116B ; enum resource_state state; // State (busy, free...) 116B ; unsigned char owner; // Current resource owner 116B ; signed char queue[3]; // Tasks waiting on resource 116B ; unsigned char queue_ptr; // Next free spot in queue 116B ; }; 116B ; 116B ; 116B ; struct task_block *task[MAXTASKS]; 116B ; struct resource_block resource[NUMRESOURCES]; 116B ; 116B ; 116B ; int kdb_trace = 1; 116B ; int kdb_trace_cycle = 0; 116B ; 116B ; 116B ; // global interrupt flags 116B ; //unsigned int interrupt_flags_ADC; 116B ; //unsigned int interrupt_flags_TC; 116B ; 116B ; 116B ; 116B ; 116B ; // error massages 116B ; const char error_msg[][25] = {"unimplimented function", // error 0 116B ; "syntax error", // error 1 116B ; "illegal task ID", // error 2 116B ; "illegal task state", // error 3 116B ; "illegal task priority", // error 4 116B ; "out of memory", // error 5 116B ; "illegal resource ID", // error 6 116B ; "illegal resource state", // error 7 116B ; "cannot create task" // error 8 116B ; }; 116B ; const char error_src[][18] = {"kernel error:", // source 0 116B ; "kernel.c error:", // source 1 116B ; "kernel RTI error:", // source 2 116B ; "shell error:", // source 3 116B ; "semlib.c error:" // source 4 116B ; }; 116B ; 116B ; 116B ; 116B ; 116B ; 116B ; main() { 116B ; 116B ; // LOCAL VARIABLES 116B ; int result, id, i; 116B ; unsigned char priority_check; 116B ; unsigned int deadline; 116B ; extern int _bss_end, _textmode; 116B ; 116B ; 116B ; _textmode = 1; // maps '\n' to "CR/LF" for Windows terminals 116B CC0001 ldd #1 116E 7C027A std __textmode 1171 ; current = 0; // start the shell first 1171 CC0000 ldd #0 1174 7C0264 std _current 1177 ; cop_cycle = 0; // fresh watchdog 1177 CC0000 ldd #0 117A 7C025E std _cop_cycle 117D CC0000 ldd #0 1180 6C16 std -10,x 1182 L4: 1182 CC000C ldd #12 1185 ED16 ldy -10,x 1187 1813 emuls 1189 C30212 addd #_resource 118C B7C6 xgdy 118E EC16 ldd -10,x 1190 6B40 stab 0,y 1192 CC000C ldd #12 1195 ED16 ldy -10,x 1197 1813 emuls 1199 C30218 addd #_resource+6 119C B7C6 xgdy 119E 6940 clr 0,y 11A0 CC000C ldd #12 11A3 ED16 ldy -10,x 11A5 1813 emuls 11A7 C30219 addd #_resource+7 11AA B7C6 xgdy 11AC C6FF ldab #255 11AE 6B40 stab 0,y 11B0 CC000C ldd #12 11B3 ED16 ldy -10,x 11B5 1813 emuls 11B7 C3021D addd #_resource+11 11BA B7C6 xgdy 11BC 6940 clr 0,y 11BE L5: 11BE ; 11BE ; 11BE ; /* redundant... done by _startup() 11BE ; // initialize the task pointer array and the tcb array. 11BE ; for (i=0; i= KDB_CYCLES) 125B FC0208 ldd _kdb_trace_cycle 125E 8C0004 cpd #4 1261 2D06 blt L25 1263 ; kdb_trace = 0; 1263 CC0000 ldd #0 1266 7C0206 std _kdb_trace 1269 L25: 1269 ; 1269 ; #ifdef KDB_TRACE_LEVEL_1 1269 ; if (kdb_trace) puts("kDB2.1"); 1269 ; #endif 1269 ; 1269 ; 1269 ; /* No interrupts allowed inside of main(). Only allowed 1269 ; inside of non-critical sections of tasks */ 1269 ; INTR_OFF(); 1269 1410 sei 126B 126B ; 126B ; 126B ; // PET THE DOG: cop watchdog reset timer (pet freq = 2x COP freq) 126B ; if (cop_cycle == 4) { 126B FC025E ldd _cop_cycle 126E 8C0004 cpd #4 1271 2610 bne L27 1273 ; COP_PET(0x55); 1273 C655 ldab #85 1275 7B0017 stab 0x17 1278 ; COP_PET(0xAA); 1278 C6AA ldab #170 127A 7B0017 stab 0x17 127D ; cop_cycle = 0; 127D CC0000 ldd #0 1280 7C025E std _cop_cycle 1283 ; } 1283 L27: 1283 CC0000 ldd #0 1286 6C16 std -10,x 1288 L29: 1288 ; #ifdef KDB_TRACE_LEVEL_1 1288 ; if (kdb_trace) puts("kDB2.2-1"); 1288 ; #endif 1288 ; 1288 ; 1288 ; 1288 ; // CHANGE STATES ACCORDING TO MESSAGES 1288 ; // 'waiting' needs to have highest precedence here 1288 ; for (i=0; imessage && STATE_FLAG) { 1296 EC16 ldd -10,x 1298 59 lsld 1299 C30242 addd #_task 129C B7C6 xgdy 129E ED40 ldy 0,y 12A0 E7E814 tst 20,y 12A3 2732 beq L35 12A5 ; // set task state to what the message says 12A5 ; task[i]->state = task[i]->message_data[STATE_BOX]; 12A5 EC16 ldd -10,x 12A7 59 lsld 12A8 C30242 addd #_task 12AB B7C6 xgdy 12AD ED40 ldy 0,y 12AF 6DE1ED sty -19,x 12B2 EDE1ED ldy -19,x 12B5 E6E815 ldab 21,y 12B8 EDE1ED ldy -19,x 12BB 6B4C stab 12,y 12BD ; // clear the STATE_FLAG 12BD ; task[i]->message &= ~(STATE_FLAG); 12BD EC16 ldd -10,x 12BF 59 lsld 12C0 C30242 addd #_task 12C3 B7C6 xgdy 12C5 EC40 ldd 0,y 12C7 C30014 addd #20 12CA 6CE1EB std -21,x 12CD B746 tfr d,y 12CF 35 pshy ; spill 12D0 EDE1EB ldy -21,x 12D3 31 puly ; reload 12D4 0D4001 bclr 0,y,#0x1 12D7 ; #ifdef KDB_TRACE_LEVEL_2 12D7 ; if (kdb_trace) puts("kDB2.3-2a"); 12D7 ; #endif 12D7 ; } 12D7 L35: 12D7 L30: 12D7 EC16 ldd -10,x 12D9 C30001 addd #1 12DC 6C16 std -10,x 12DE EC16 ldd -10,x 12E0 8C0008 cpd #8 12E3 2DA3 blt L29 12E5 CC0000 ldd #0 12E8 6C16 std -10,x 12EA L37: 12EA ; #ifdef KDB_TRACE_LEVEL_2 12EA ; if (kdb_trace) puts("kDB2.3-2b"); 12EA ; #endif 12EA ; } 12EA ; #ifdef KDB_TRACE_LEVEL_1 12EA ; if (kdb_trace) puts("kDB2.3-1"); 12EA ; #endif 12EA ; 12EA ; 12EA ; 12EA ; // RT PRIORITY BLOCK: 12EA ; // set the current task id based on priority and deadline 12EA ; 12EA ; // determine if the deadline is up for idle tasks 12EA ; /* deadline, is equal to period plus an initial time (t0) reference 12EA ; (t0 = system_tick). Period = priority + 1. 12EA ; Changing the state from idle to PENDING occurs here. */ 12EA ; for (i=0; istate == IDLE) { 12EA EC16 ldd -10,x 12EC 59 lsld 12ED C30242 addd #_task 12F0 B7C6 xgdy 12F2 ED40 ldy 0,y 12F4 E74C tst 12,y 12F6 2655 bne L41 12F8 ; deadline = task[i]->period_tick + (task[i]->priority + 1); 12F8 EC16 ldd -10,x 12FA 59 lsld 12FB C30242 addd #_task 12FE B7C6 xgdy 1300 ED40 ldy 0,y 1302 6DE1ED sty -19,x 1305 EDE1ED ldy -19,x 1308 E64D ldab 13,y 130A 87 clra 130B C30001 addd #1 130E 163479 jsr __d2lreg2 1311 EDE1ED ldy -19,x 1314 194E leay 14,y 1316 1802401C movw 0,y,-4,x 131A 1802421E movw 2,y,-2,x 131E 1634C1 jsr __ladd 1321 163494 jsr __lreg2d 1324 6C14 std -12,x 1326 ; if (system_tick >= deadline) { 1326 CD0260 ldy #_system_tick 1329 1802401C movw 0,y,-4,x 132D 1802421E movw 2,y,-2,x 1331 EC14 ldd -12,x 1333 6C1A std -6,x 1335 1800180000 movw #0,-8,x 133A 163662 jsr __lcmp 133D 250E blo L43 133F ; task[i]->state = PENDING; // change state at deadline 133F EC16 ldd -10,x 1341 59 lsld 1342 C30242 addd #_task 1345 B7C6 xgdy 1347 ED40 ldy 0,y 1349 C601 ldab #1 134B 6B4C stab 12,y 134D ; #ifdef KDB_TRACE_LEVEL_2 134D ; if (kdb_trace) puts("kDB2.4-2"); 134D ; #endif 134D ; } 134D L43: 134D ; } 134D L41: 134D L38: 134D EC16 ldd -10,x 134F C30001 addd #1 1352 6C16 std -10,x 1354 EC16 ldd -10,x 1356 8C0008 cpd #8 1359 2D8F blt L37 135B ; // if (task[i]->message) {} ??? 135B ; } 135B ; #ifdef KDB_TRACE_LEVEL_1 135B ; if (kdb_trace) puts("kDB2.4-1"); 135B ; #endif 135B ; 135B ; 135B ; // set current = to highest priority pending/running task. 135B ; priority_check = 255; // lowest possible 135B C6FF ldab #255 135D 6B13 stab -13,x 135F CC0000 ldd #0 1362 6C16 std -10,x 1364 L45: 1364 ; 1364 ; for (i=0; istate == PENDING) || (task[i]->state == RUNNING)) { 138D ; if (task[i]->priority <= priority_check) { 138D EC16 ldd -10,x 138F 59 lsld 1390 C30242 addd #_task 1393 B7C6 xgdy 1395 ED40 ldy 0,y 1397 E64D ldab 13,y 1399 E113 cmpb -13,x 139B 2213 bhi L54 139D ; current = i; 139D EC16 ldd -10,x 139F 7C0264 std _current 13A2 ; priority_check = task[i]->priority; 13A2 EC16 ldd -10,x 13A4 59 lsld 13A5 C30242 addd #_task 13A8 B7C6 xgdy 13AA ED40 ldy 0,y 13AC E64D ldab 13,y 13AE 6B13 stab -13,x 13B0 ; #ifdef KDB_TRACE_LEVEL_2 13B0 ; if (kdb_trace) puts("kDB2.5-2"); 13B0 ; #endif 13B0 ; } 13B0 L54: 13B0 ; } 13B0 L51: 13B0 ; } 13B0 L49: 13B0 L46: 13B0 EC16 ldd -10,x 13B2 C30001 addd #1 13B5 6C16 std -10,x 13B7 EC16 ldd -10,x 13B9 8C0008 cpd #8 13BC 2DA6 blt L45 13BE FC0264 ldd _current 13C1 59 lsld 13C2 C30242 addd #_task 13C5 B7C6 xgdy 13C7 ED40 ldy 0,y 13C9 E64C ldab 12,y 13CB 87 clra 13CC 6CE1ED std -19,x 13CF 182700B1 lbeq L57 13D3 ECE1ED ldd -19,x 13D6 8C0001 cpd #1 13D9 2722 beq L60 13DB ECE1ED ldd -19,x 13DE 8C0002 cpd #2 13E1 1827007C lbeq L61 13E5 ECE1ED ldd -19,x 13E8 8C0003 cpd #3 13EB 18270095 lbeq L57 13EF ECE1ED ldd -19,x 13F2 8C0004 cpd #4 13F5 1827008B lbeq L57 13F9 1820007B lbra L56 13FD X0: 13FD ; } 13FD ; #ifdef KDB_TRACE_LEVEL_1 13FD ; if (kdb_trace) puts("kDB2.5-1"); 13FD ; #endif 13FD ; 13FD ; 13FD ; 13FD ; // DISPATCH, or otherwise deal with the current task 13FD ; // KDB_TRACE Section 3 13FD ; 13FD ; #ifdef KDB_TRACE_LEVEL_2 13FD ; if (kdb_trace) { 13FD ; printf("task[%d]->state = %d\n", current, task[current]->state); 13FD ; printf("task[%d]->prior = %d\n", current, task[current]->priority); 13FD ; } 13FD ; #endif 13FD ; 13FD ; switch (task[current]->state) { 13FD ; case IDLE: // skip task 13FD ; #ifdef KDB_TRACE_LEVEL_1 13FD ; if (kdb_trace) puts("kDB3.1-1"); 13FD ; #endif 13FD ; break; 13FD L60: 13FD ; case PENDING: // ready and waiting to run 13FD ; #ifdef KDB_TRACE_LEVEL_1 13FD ; if (kdb_trace) puts("kDB3.2-1"); 13FD ; #endif 13FD ; #ifdef KDB_TRACE_LEVEL_2 13FD ; if (kdb_trace) { 13FD ; //puts("kDB3.2-2"); 13FD ; putchar('S'); 13FD ; putchar(current+48); 13FD ; putchar('\n'); 13FD ; } 13FD ; #endif 13FD ; task[current]->state = RUNNING; 13FD FC0264 ldd _current 1400 59 lsld 1401 C30242 addd #_task 1404 B7C6 xgdy 1406 ED40 ldy 0,y 1408 C602 ldab #2 140A 6B4C stab 12,y 140C ; task[current]->period_tick = system_tick; 140C FC0264 ldd _current 140F 59 lsld 1410 C30242 addd #_task 1413 B7C6 xgdy 1415 ED40 ldy 0,y 1417 194E leay 14,y 1419 35 pshy ; spill 141A CD0260 ldy #_system_tick 141D 1802401C movw 0,y,-4,x 1421 1802421E movw 2,y,-2,x 1425 31 puly ; reload 1426 18021C40 movw -4,x,0,y 142A 18021E42 movw -2,x,2,y 142E ; temp_task_frame_ptr = task[current]->top_of_stack; 142E FC0264 ldd _current 1431 59 lsld 1432 C30242 addd #_task 1435 B7C6 xgdy 1437 ED40 ldy 0,y 1439 EDE819 ldy 25,y 143C 7D0204 sty _temp_task_frame_ptr 143F ; asm("LDS _temp_task_frame_ptr"); // set the SP 143F FF0204 LDS _temp_task_frame_ptr 1442 1442 ; (*task_ptr[current])(); // start the task 1442 FC0264 ldd _current 1445 59 lsld 1446 C30266 addd #_task_ptr 1449 B7C6 xgdy 144B ED40 ldy 0,y 144D 1540 jsr 0,y 144F ; asm("LDS _main_frame_ptr"); // reset the SP 144F FF0200 LDS _main_frame_ptr 1452 1452 ; task[current]->state = IDLE; // task finished 1452 FC0264 ldd _current 1455 59 lsld 1456 C30242 addd #_task 1459 B7C6 xgdy 145B ED40 ldy 0,y 145D 694C clr 12,y 145F ; #ifdef KDB_TRACE_LEVEL_1 145F ; if (kdb_trace) puts("kDB3.3-1"); 145F ; #endif 145F ; #ifdef KDB_TRACE_LEVEL_2 145F ; if (kdb_trace) { 145F ; //puts("kDB3.3-2"); 145F ; putchar('F'); 145F ; putchar(current+48); 145F ; putchar('\n'); 145F ; } 145F ; #endif 145F ; break; 145F 2023 bra L57 1461 L61: 1461 ; case RUNNING: // interrupted. continue running. 1461 ; // restore context and run 1461 ; temp_task_frame_ptr = task[current]->frame_ptr; 1461 FC0264 ldd _current 1464 59 lsld 1465 C30242 addd #_task 1468 B7C6 xgdy 146A ED40 ldy 0,y 146C EDE81B ldy 27,y 146F 7D0204 sty _temp_task_frame_ptr 1472 ; asm("LDS _temp_task_frame_ptr"); 1472 FF0204 LDS _temp_task_frame_ptr 1475 1475 ; asm("RTI"); 1475 0B RTI 1476 1476 ; break; 1476 200C bra L57 1478 X1: 1478 ; case WAITING: // waiting on a resource 1478 ; #ifdef KDB_TRACE_LEVEL_1 1478 ; if (kdb_trace) puts("kDB3.5-1"); 1478 ; #endif 1478 ; break; 1478 ; case STOPPED: // done running until later 1478 ; #ifdef KDB_TRACE_LEVEL_1 1478 ; if (kdb_trace) puts("kDB3.6-1"); 1478 ; #endif 1478 ; break; 1478 L56: 1478 ; default: // shouldn't happen, but, error if so. 1478 ; puts("KERNEL: task state error\n"); 1478 CC1B30 ldd #L64 147B 1636FB jsr _puts 147E ; exit(1); 147E CC0001 ldd #1 1481 161028 jsr _exit 1484 ; } // end switch 1484 L57: 1484 L23: 1484 1820FDD3 lbra L22 1488 X2: 1488 ; 1488 ; } // end while(1) 1488 ; 1488 ; return 0; 1488 CC0000 ldd #0 148B L3: 148B B757 tfr x,s 148D 30 pulx 148E .dbline 0 ; func end 148E 3D rts 148F ; lreg1 -> -4,x 148F ; lreg2 -> -8,x 148F ; local_thp -> -14,x 148F ; i -> -12,x 148F ; frame_size -> -10,x 148F _RTI_handler:: 148F 34 pshx 1490 B775 tfr s,x 1492 1B92 leas -14,sp 1494 ; 1494 ; } // end main() 1494 ; 1494 ; 1494 ; 1494 ; #pragma interrupt_handler RTI_handler() 1494 ; 1494 ; void RTI_handler(void) { 1494 ; 1494 ; size_t frame_size; 1494 ; unsigned int i; 1494 ; unsigned char *local_thp; 1494 ; 1494 ; 1494 ; //ACKNOWLEDGE THE INTERRUPT 1494 ; RTIFLG = 0x0080; // acknowledge/clear the interrupt 1494 C680 ldab #128 1496 7B0015 stab 0x15 1499 ; 1499 ; 1499 ; #ifdef KDB_TRACE_LEVEL_1 1499 ; if (kdb_trace) putchar('.'); 1499 ; #endif 1499 ; 1499 ; 1499 ; // SET THE FRAME POINTER for the interupted task. 1499 ; // should point to the CCR entry on the stack. 1499 ; asm("TFR x,d"); // start of RTI stack 1499 B754 TFR x,d 149B 149B ; asm("ADDD #2"); // adjust to CCR stack entry 149B C30002 ADDD #2 149E 149E ; asm("STD _temp_task_frame_ptr"); // put into task_frame_ptr 149E 7C0204 STD _temp_task_frame_ptr 14A1 14A1 ; task[current]->frame_ptr = temp_task_frame_ptr; 14A1 FC0264 ldd _current 14A4 59 lsld 14A5 C30242 addd #_task 14A8 B7C6 xgdy 14AA ED40 ldy 0,y 14AC FC0204 ldd _temp_task_frame_ptr 14AF 6CE81B std 27,y 14B2 ; 14B2 ; 14B2 ; 14B2 ; // update system time base and cop reset counter 14B2 ; system_tick++; 14B2 CD0260 ldy #_system_tick 14B5 1802401C movw 0,y,-4,x 14B9 1802421E movw 2,y,-2,x 14BD CD1B2C ldy #L66 14C0 18024018 movw 0,y,-8,x 14C4 1802421A movw 2,y,-6,x 14C8 1634C1 jsr __ladd 14CB CD0260 ldy #_system_tick 14CE 18021C40 movw -4,x,0,y 14D2 18021E42 movw -2,x,2,y 14D6 ; cop_cycle++; 14D6 FC025E ldd _cop_cycle 14D9 C30001 addd #1 14DC 7C025E std _cop_cycle 14DF ; 14DF ; 14DF ; 14DF ; // RETURN: simulate a RTS instruction 14DF ; // set stack pointer for main() 14DF ; asm("LDS _main_frame_ptr"); 14DF FF0200 LDS _main_frame_ptr 14E2 14E2 ; asm("LDX _main_frame_x_ptr"); 14E2 FE0202 LDX _main_frame_x_ptr 14E5 14E5 ; /* return to main() at the reentry point 14E5 ; and must be adjusted after each kernel mod/compilation!! */ 14E5 ; asm("JMP $125B"); 14E5 06125B JMP $125B 14E8 14E8 ; 14E8 ; 14E8 ; // return (0) -- NOT used 14E8 ; /* this ISR should never use the 'return x' command. 14E8 ; It doesn't make sense since it always interrupts a Task, but 14E8 ; never returns to it... but to main() instead. */ 14E8 ; 14E8 ; } 14E8 L65: 14E8 B757 tfr x,s 14EA 30 pulx 14EB .dbline 0 ; func end 14EB 0B rti 14EC ; id -> 3,x 14EC _get_task_address:: 14EC 3B pshd 14ED 34 pshx 14EE B775 tfr s,x 14F0 ; 14F0 ; 14F0 ; 14F0 ; 14F0 ; 14F0 ; // KERNEL FUNCTIONS 14F0 ; 14F0 ; int get_task_address(char id) { 14F0 ; 14F0 ; return (int)task[id]->address; 14F0 E603 ldab 3,x 14F2 87 clra 14F3 59 lsld 14F4 C30242 addd #_task 14F7 B7C6 xgdy 14F9 ECEB0000 ldd [0,y] 14FD L67: 14FD B757 tfr x,s 14FF 30 pulx 1500 1B82 leas 2,sp 1502 .dbline 0 ; func end 1502 3D rts 1503 _get_task_id:: 1503 ; 1503 ; } 1503 ; 1503 ; 1503 ; 1503 ; 1503 ; char get_task_id() { 1503 ; 1503 ; return task[current]->id; 1503 FC0264 ldd _current 1506 59 lsld 1507 C30242 addd #_task 150A B7C6 xgdy 150C ED40 ldy 0,y 150E E642 ldab 2,y 1510 87 clra 1511 L68: 1511 .dbline 0 ; func end 1511 3D rts 1512 ; id -> 3,x 1512 _get_task_name:: 1512 3B pshd 1513 34 pshx 1514 B775 tfr s,x 1516 ; } 1516 ; 1516 ; 1516 ; 1516 ; char *get_task_name(unsigned char id) { 1516 ; if (task[id] == NULL) 1516 E603 ldab 3,x 1518 87 clra 1519 59 lsld 151A C30242 addd #_task 151D B7C6 xgdy 151F EC40 ldd 0,y 1521 2605 bne L70 1523 ; return NULL; 1523 CC0000 ldd #0 1526 200E bra L69 1528 L70: 1528 ; else 1528 ; return task[id]->name; 1528 E603 ldab 3,x 152A 87 clra 152B 59 lsld 152C C30242 addd #_task 152F B7C6 xgdy 1531 EC40 ldd 0,y 1533 C30003 addd #3 1536 L69: 1536 B757 tfr x,s 1538 30 pulx 1539 1B82 leas 2,sp 153B .dbline 0 ; func end 153B 3D rts 153C ; id -> 3,x 153C _get_task_state:: 153C 3B pshd 153D 34 pshx 153E B775 tfr s,x 1540 ; } 1540 ; 1540 ; 1540 ; 1540 ; 1540 ; int get_task_state(unsigned char id) { 1540 ; 1540 ; if (task[id] == NULL) 1540 E603 ldab 3,x 1542 87 clra 1543 59 lsld 1544 C30242 addd #_task 1547 B7C6 xgdy 1549 EC40 ldd 0,y 154B 2605 bne L73 154D ; return -1; 154D CCFFFF ldd #-1 1550 2019 bra L72 1552 L73: 1552 ; else if (id < MAXTASKS) 1552 E603 ldab 3,x 1554 C108 cmpb #8 1556 2410 bhs L75 1558 ; return task[id]->state; 1558 E603 ldab 3,x 155A 87 clra 155B 59 lsld 155C C30242 addd #_task 155F B7C6 xgdy 1561 ED40 ldy 0,y 1563 E64C ldab 12,y 1565 87 clra 1566 2003 bra L72 1568 L75: 1568 ; else { 1568 ; #ifdef KERNEL_ERROR_MSG 1568 ; puts(error_src[1]); puts(error_msg[3]); 1568 ; #endif 1568 ; return -1; 1568 CCFFFF ldd #-1 156B L72: 156B B757 tfr x,s 156D 30 pulx 156E 1B82 leas 2,sp 1570 .dbline 0 ; func end 1570 3D rts 1571 ; id -> 3,x 1571 _get_task_messages:: 1571 3B pshd 1572 34 pshx 1573 B775 tfr s,x 1575 ; } 1575 ; 1575 ; } 1575 ; 1575 ; 1575 ; 1575 ; int get_task_messages(unsigned char id) { 1575 ; 1575 ; if (task[id] == NULL) 1575 E603 ldab 3,x 1577 87 clra 1578 59 lsld 1579 C30242 addd #_task 157C B7C6 xgdy 157E EC40 ldd 0,y 1580 2605 bne L78 1582 ; return -1; 1582 CCFFFF ldd #-1 1585 201A bra L77 1587 L78: 1587 ; else if (id < MAXTASKS) 1587 E603 ldab 3,x 1589 C108 cmpb #8 158B 2411 bhs L80 158D ; return task[id]->message; 158D E603 ldab 3,x 158F 87 clra 1590 59 lsld 1591 C30242 addd #_task 1594 B7C6 xgdy 1596 ED40 ldy 0,y 1598 E6E814 ldab 20,y 159B 87 clra 159C 2003 bra L77 159E L80: 159E ; else { 159E ; #ifdef KERNEL_ERROR_MSG 159E ; puts(error_src[1]); puts(error_msg[3]); 159E ; #endif 159E ; return -1; 159E CCFFFF ldd #-1 15A1 L77: 15A1 B757 tfr x,s 15A3 30 pulx 15A4 1B82 leas 2,sp 15A6 .dbline 0 ; func end 15A6 3D rts 15A7 ; id -> 3,x 15A7 _get_task_priority:: 15A7 3B pshd 15A8 34 pshx 15A9 B775 tfr s,x 15AB ; } 15AB ; 15AB ; } 15AB ; 15AB ; 15AB ; 15AB ; int get_task_priority(unsigned char id) { 15AB ; 15AB ; INTR_OFF(); 15AB 1410 sei 15AD 15AD ; 15AD ; if (id < MAXTASKS) { 15AD E603 ldab 3,x 15AF C108 cmpb #8 15B1 2412 bhs L83 15B3 ; INTR_ON(); 15B3 10EF cli 15B5 15B5 ; return task[id]->priority; 15B5 E603 ldab 3,x 15B7 87 clra 15B8 59 lsld 15B9 C30242 addd #_task 15BC B7C6 xgdy 15BE ED40 ldy 0,y 15C0 E64D ldab 13,y 15C2 87 clra 15C3 2005 bra L82 15C5 L83: 15C5 ; } 15C5 ; else { 15C5 ; #ifdef KERNEL_ERROR_MSG 15C5 ; puts(error_src[1]); puts(error_msg[4]); 15C5 ; #endif 15C5 ; INTR_ON(); 15C5 10EF cli 15C7 15C7 ; return -1; 15C7 CCFFFF ldd #-1 15CA L82: 15CA B757 tfr x,s 15CC 30 pulx 15CD 1B82 leas 2,sp 15CF .dbline 0 ; func end 15CF 3D rts 15D0 ; ?temp -> -4,x 15D0 ; ?temp -> -4,x 15D0 ; ?temp -> -4,x 15D0 ; ?temp -> -4,x 15D0 ; ?temp -> -4,x 15D0 ; ?temp -> -2,x 15D0 ; newstate -> 7,x 15D0 ; id -> 3,x 15D0 _set_task_state:: 15D0 3B pshd 15D1 34 pshx 15D2 B775 tfr s,x 15D4 1B9C leas -4,sp 15D6 ; } 15D6 ; 15D6 ; } 15D6 ; 15D6 ; 15D6 ; 15D6 ; int set_task_state(unsigned char id, unsigned char newstate) { 15D6 ; 15D6 ; 15D6 ; INTR_OFF(); 15D6 1410 sei 15D8 15D8 ; 15D8 ; 15D8 ; // check id validity 15D8 ; if (id < MAXTASKS) { 15D8 E603 ldab 3,x 15DA C108 cmpb #8 15DC 182401D9 lbhs L86 15E0 ; 15E0 ; if (task[id] == NULL) { 15E0 E603 ldab 3,x 15E2 87 clra 15E3 59 lsld 15E4 C30242 addd #_task 15E7 B7C6 xgdy 15E9 EC40 ldd 0,y 15EB 2609 bne L88 15ED ; #ifdef KERNEL_ERROR_MSG 15ED ; puts(error_src[1]); puts(error_msg[2]); 15ED ; #endif 15ED ; INTR_ON(); 15ED 10EF cli 15EF 15EF ; return -1; 15EF CCFFFF ldd #-1 15F2 182001CF lbra L85 15F6 L88: 15F6 ; } 15F6 ; 15F6 ; 15F6 ; // check newstate validity 15F6 ; if ((newstate == RUNNING) || 15F6 E607 ldab 7,x 15F8 C102 cmpb #2 15FA 270C beq L93 15FC E607 ldab 7,x 15FE C103 cmpb #3 1600 2706 beq L93 1602 E607 ldab 7,x 1604 C104 cmpb #4 1606 2309 bls L90 1608 L93: 1608 ; (newstate == WAITING) || 1608 ; (newstate > STOPPED)) { 1608 ; #ifdef KERNEL_ERROR_MSG 1608 ; puts(error_src[1]); puts(error_msg[3]); 1608 ; #endif 1608 ; INTR_ON(); 1608 10EF cli 160A 160A ; return -1; 160A CCFFFF ldd #-1 160D 182001B4 lbra L85 1611 L90: 1611 E603 ldab 3,x 1613 87 clra 1614 59 lsld 1615 C30242 addd #_task 1618 B7C6 xgdy 161A ED40 ldy 0,y 161C E64C ldab 12,y 161E 87 clra 161F 6C1E std -2,x 1621 271F beq L97 1623 EC1E ldd -2,x 1625 8C0001 cpd #1 1628 1827009C lbeq L104 162C EC1E ldd -2,x 162E 8C0002 cpd #2 1631 182700F0 lbeq L111 1635 EC1E ldd -2,x 1637 8C0004 cpd #4 163A 18270128 lbeq L114 163E 18200170 lbra L94 1642 X3: 1642 ; } 1642 ; 1642 ; // referenced to the task's current state: 1642 ; switch (task[id]->state) { 1642 L97: 1642 ; case IDLE: 1642 ; if (newstate == IDLE) { // no change 1642 E707 tst 7,x 1644 2609 bne L98 1646 ; INTR_ON(); 1646 10EF cli 1648 1648 ; return 0; 1648 CC0000 ldd #0 164B 18200176 lbra L85 164F L98: 164F ; } 164F ; else if (newstate == PENDING) { 164F E607 ldab 7,x 1651 C101 cmpb #1 1653 2632 bne L100 1655 ; // pass msg to task[id]->msgbox; 1655 ; task[id]->message |= STATE_FLAG; 1655 E603 ldab 3,x 1657 87 clra 1658 59 lsld 1659 C30242 addd #_task 165C B7C6 xgdy 165E EC40 ldd 0,y 1660 C30014 addd #20 1663 6C1C std -4,x 1665 B746 tfr d,y 1667 35 pshy ; spill 1668 ED1C ldy -4,x 166A 31 puly ; reload 166B 0C4001 bset 0,y,#1 166E ; task[id]->message_data[STATE_BOX] = PENDING; 166E E603 ldab 3,x 1670 87 clra 1671 59 lsld 1672 C30242 addd #_task 1675 B7C6 xgdy 1677 ED40 ldy 0,y 1679 C601 ldab #1 167B 6BE815 stab 21,y 167E ; INTR_ON(); 167E 10EF cli 1680 1680 ; return 0; 1680 CC0000 ldd #0 1683 1820013E lbra L85 1687 L100: 1687 ; } 1687 ; else if (newstate == STOPPED) { 1687 E607 ldab 7,x 1689 C104 cmpb #4 168B 2632 bne L102 168D ; // pass msg to task[id]->msgbox; 168D ; task[id]->message |= STATE_FLAG; 168D E603 ldab 3,x 168F 87 clra 1690 59 lsld 1691 C30242 addd #_task 1694 B7C6 xgdy 1696 EC40 ldd 0,y 1698 C30014 addd #20 169B 6C1C std -4,x 169D B746 tfr d,y 169F 35 pshy ; spill 16A0 ED1C ldy -4,x 16A2 31 puly ; reload 16A3 0C4001 bset 0,y,#1 16A6 ; task[id]->message_data[STATE_BOX] = STOPPED; 16A6 E603 ldab 3,x 16A8 87 clra 16A9 59 lsld 16AA C30242 addd #_task 16AD B7C6 xgdy 16AF ED40 ldy 0,y 16B1 C604 ldab #4 16B3 6BE815 stab 21,y 16B6 ; INTR_ON(); 16B6 10EF cli 16B8 16B8 ; return 0; 16B8 CC0000 ldd #0 16BB 18200106 lbra L85 16BF L102: 16BF ; } 16BF ; else { // nothing else is legal; 16BF ; #ifdef KERNEL_ERROR_MSG 16BF ; puts(error_src[1]); puts(error_msg[3]); 16BF ; #endif 16BF ; INTR_ON(); 16BF 10EF cli 16C1 16C1 ; return -1; 16C1 CCFFFF ldd #-1 16C4 182000FD lbra L85 16C8 X4: 16C8 ; } 16C8 ; break; 16C8 L104: 16C8 ; case PENDING: 16C8 ; if (newstate == PENDING) { // no change 16C8 E607 ldab 7,x 16CA C101 cmpb #1 16CC 2609 bne L105 16CE ; INTR_ON(); 16CE 10EF cli 16D0 16D0 ; return 0; 16D0 CC0000 ldd #0 16D3 182000EE lbra L85 16D7 L105: 16D7 ; } 16D7 ; else if (newstate == IDLE) { 16D7 E707 tst 7,x 16D9 2609 bne L107 16DB ; // pass msg to task[id]->msgbox; 16DB ; #ifdef KERNEL_ERROR_MSG 16DB ; puts(error_src[1]); puts(error_msg[0]); 16DB ; #endif 16DB ; INTR_ON(); 16DB 10EF cli 16DD 16DD ; return -1; 16DD CCFFFF ldd #-1 16E0 182000E1 lbra L85 16E4 L107: 16E4 ; } 16E4 ; else if (newstate == STOPPED) { 16E4 E607 ldab 7,x 16E6 C104 cmpb #4 16E8 2632 bne L109 16EA ; // pass msg to task[id]->msgbox; 16EA ; task[id]->message |= STATE_FLAG; 16EA E603 ldab 3,x 16EC 87 clra 16ED 59 lsld 16EE C30242 addd #_task 16F1 B7C6 xgdy 16F3 EC40 ldd 0,y 16F5 C30014 addd #20 16F8 6C1C std -4,x 16FA B746 tfr d,y 16FC 35 pshy ; spill 16FD ED1C ldy -4,x 16FF 31 puly ; reload 1700 0C4001 bset 0,y,#1 1703 ; task[id]->message_data[STATE_BOX] = STOPPED; 1703 E603 ldab 3,x 1705 87 clra 1706 59 lsld 1707 C30242 addd #_task 170A B7C6 xgdy 170C ED40 ldy 0,y 170E C604 ldab #4 1710 6BE815 stab 21,y 1713 ; INTR_ON(); 1713 10EF cli 1715 1715 ; return 0; 1715 CC0000 ldd #0 1718 182000A9 lbra L85 171C L109: 171C ; } 171C ; else { 171C ; #ifdef KERNEL_ERROR_MSG 171C ; puts(error_src[1]); puts(error_msg[3]); 171C ; #endif 171C ; INTR_ON(); 171C 10EF cli 171E 171E ; return -1; 171E CCFFFF ldd #-1 1721 182000A0 lbra L85 1725 X5: 1725 ; } 1725 ; break; 1725 L111: 1725 ; case RUNNING: 1725 ; if (newstate == STOPPED) { 1725 E607 ldab 7,x 1727 C104 cmpb #4 1729 2632 bne L112 172B ; // pass msg to task[id]->msgbox; 172B ; task[id]->message |= STATE_FLAG; 172B E603 ldab 3,x 172D 87 clra 172E 59 lsld 172F C30242 addd #_task 1732 B7C6 xgdy 1734 EC40 ldd 0,y 1736 C30014 addd #20 1739 6C1C std -4,x 173B B746 tfr d,y 173D 35 pshy ; spill 173E ED1C ldy -4,x 1740 31 puly ; reload 1741 0C4001 bset 0,y,#1 1744 ; task[id]->message_data[STATE_BOX] = STOPPED; 1744 E603 ldab 3,x 1746 87 clra 1747 59 lsld 1748 C30242 addd #_task 174B B7C6 xgdy 174D ED40 ldy 0,y 174F C604 ldab #4 1751 6BE815 stab 21,y 1754 ; 1754 ; INTR_ON(); 1754 10EF cli 1756 1756 ; return 0; 1756 CC0000 ldd #0 1759 18200068 lbra L85 175D L112: 175D ; } 175D ; else { 175D ; #ifdef KERNEL_ERROR_MSG 175D ; puts(error_src[1]); puts(error_msg[3]); 175D ; #endif 175D ; INTR_ON(); 175D 10EF cli 175F 175F ; return -1; 175F CCFFFF ldd #-1 1762 1820005F lbra L85 1766 X6: 1766 ; } 1766 ; break; 1766 L114: 1766 ; case STOPPED: 1766 ; if (newstate == STOPPED) { // no change 1766 E607 ldab 7,x 1768 C104 cmpb #4 176A 2609 bne L115 176C ; INTR_ON(); 176C 10EF cli 176E 176E ; return 0; 176E CC0000 ldd #0 1771 18200050 lbra L85 1775 L115: 1775 ; } 1775 ; else if (newstate == PENDING) { 1775 E607 ldab 7,x 1777 C101 cmpb #1 1779 2630 bne L117 177B ; // pass msg to task[id]->msgbox; 177B ; task[id]->message |= STATE_FLAG; 177B E603 ldab 3,x 177D 87 clra 177E 59 lsld 177F C30242 addd #_task 1782 B7C6 xgdy 1784 EC40 ldd 0,y 1786 C30014 addd #20 1789 6C1C std -4,x 178B B746 tfr d,y 178D 35 pshy ; spill 178E ED1C ldy -4,x 1790 31 puly ; reload 1791 0C4001 bset 0,y,#1 1794 ; task[id]->message_data[STATE_BOX] = PENDING; 1794 E603 ldab 3,x 1796 87 clra 1797 59 lsld 1798 C30242 addd #_task 179B B7C6 xgdy 179D ED40 ldy 0,y 179F C601 ldab #1 17A1 6BE815 stab 21,y 17A4 ; INTR_ON(); 17A4 10EF cli 17A6 17A6 ; return 0; 17A6 CC0000 ldd #0 17A9 201A bra L85 17AB L117: 17AB ; } 17AB ; else { 17AB ; #ifdef KERNEL_ERROR_MSG 17AB ; puts(error_src[1]); puts(error_msg[3]); 17AB ; #endif 17AB ; INTR_ON(); 17AB 10EF cli 17AD 17AD ; return -1; 17AD CCFFFF ldd #-1 17B0 2013 bra L85 17B2 X7: 17B2 ; } 17B2 ; break; 17B2 L94: 17B2 ; default: 17B2 ; #ifdef KERNEL_ERROR_MSG 17B2 ; puts(error_src[1]); puts(error_msg[3]); 17B2 ; #endif 17B2 ; INTR_ON(); 17B2 10EF cli 17B4 17B4 ; return -1; 17B4 CCFFFF ldd #-1 17B7 200C bra L85 17B9 X8: 17B9 ; break; 17B9 L86: 17B9 ; 17B9 ; } // end switch (task[id]->state) 17B9 ; 17B9 ; } // if (id < MAXTASKS) 17B9 ; 17B9 ; else { 17B9 ; #ifdef KERNEL_ERROR_MSG 17B9 ; puts(error_src[1]); puts(error_msg[2]); 17B9 ; #endif 17B9 ; INTR_ON(); 17B9 10EF cli 17BB 17BB ; return -1; 17BB CCFFFF ldd #-1 17BE 2005 bra L85 17C0 X9: 17C0 ; } 17C0 ; 17C0 ; INTR_ON(); 17C0 10EF cli 17C2 17C2 ; return 0; 17C2 CC0000 ldd #0 17C5 L85: 17C5 B757 tfr x,s 17C7 30 pulx 17C8 1B82 leas 2,sp 17CA .dbline 0 ; func end 17CA 3D rts 17CB ; priority -> 7,x 17CB ; id -> 3,x 17CB _set_task_priority:: 17CB 3B pshd 17CC 34 pshx 17CD B775 tfr s,x 17CF ; 17CF ; } 17CF ; 17CF ; 17CF ; 17CF ; int set_task_priority(unsigned char id, unsigned char priority) { 17CF ; 17CF ; if (priority == 0) // priority 0 is reserved for the shell 17CF E707 tst 7,x 17D1 2604 bne L120 17D3 ; priority = 1; 17D3 C601 ldab #1 17D5 6B07 stab 7,x 17D7 L120: 17D7 ; 17D7 ; if (id >= (MAXTASKS)) { 17D7 E603 ldab 3,x 17D9 C108 cmpb #8 17DB 2505 blo L122 17DD ; #ifdef KERNEL_ERROR_MSG 17DD ; puts(error_src[1]); puts(error_msg[4]); 17DD ; #endif 17DD ; return -1; 17DD CCFFFF ldd #-1 17E0 2021 bra L119 17E2 L122: 17E2 E607 ldab 7,x 17E4 C1FF cmpb #255 17E6 2204 bhi L126 17E8 E707 tst 7,x 17EA 2405 bhs L124 17EC L126: 17EC ; } 17EC ; else if ((priority > 255) || (priority < 0)) { 17EC ; #ifdef KERNEL_ERROR_MSG 17EC ; puts(error_src[1]); puts(error_msg[4]); 17EC ; #endif 17EC ; return -1; 17EC CCFFFF ldd #-1 17EF 2012 bra L119 17F1 L124: 17F1 ; } 17F1 ; else { 17F1 ; task[id]->priority = priority; 17F1 E603 ldab 3,x 17F3 87 clra 17F4 59 lsld 17F5 C30242 addd #_task 17F8 B7C6 xgdy 17FA ED40 ldy 0,y 17FC E607 ldab 7,x 17FE 6B4D stab 13,y 1800 ; return 0; 1800 CC0000 ldd #0 1803 L119: 1803 B757 tfr x,s 1805 30 pulx 1806 1B82 leas 2,sp 1808 .dbline 0 ; func end 1808 3D rts 1809 ; lreg1 -> -4,x 1809 ; lreg2 -> -8,x 1809 ; ?temp -> -15,x 1809 ; ?temp -> -13,x 1809 ; ?temp -> -11,x 1809 ; id -> -9,x 1809 ; stack_size -> 12,x 1809 ; state -> 10,x 1809 ; priority -> 9,x 1809 ; addr -> 6,x 1809 ; name -> 2,x 1809 _create_task:: 1809 3B pshd 180A 34 pshx 180B B775 tfr s,x 180D 1BF1EA leas -22,sp 1810 ; } 1810 ; } 1810 ; 1810 ; 1810 ; 1810 ; 1810 ; int create_task(char *name, 1810 ; void (*addr)(), 1810 ; unsigned char priority, 1810 ; int state, 1810 ; int stack_size) { 1810 ; 1810 ; // LOCAL VARIABLES 1810 ; unsigned char id; 1810 ; 1810 ; 1810 ; INTR_OFF(); // critical section 1810 1410 sei 1812 1812 6917 clr -9,x 1814 2015 bra L131 1816 L128: 1816 E617 ldab -9,x 1818 87 clra 1819 59 lsld 181A C30266 addd #_task_ptr 181D B7C6 xgdy 181F EC40 ldd 0,y 1821 270E beq L130 1823 L129: 1823 E617 ldab -9,x 1825 87 clra 1826 C30001 addd #1 1829 6B17 stab -9,x 182B L131: 182B ; 182B ; 182B ; //if (get_free_memory() > 64) { 182B ; 182B ; // determine lowest free id available to assign to this task 182B ; for (id=0; idaddress = addr; 1861 E617 ldab -9,x 1863 87 clra 1864 59 lsld 1865 C30242 addd #_task 1868 B7C6 xgdy 186A ED40 ldy 0,y 186C EC06 ldd 6,x 186E 6C40 std 0,y 1870 ; task[id]->id = id; 1870 E617 ldab -9,x 1872 87 clra 1873 59 lsld 1874 C30242 addd #_task 1877 B7C6 xgdy 1879 ED40 ldy 0,y 187B E617 ldab -9,x 187D 6B42 stab 2,y 187F ; strcpy(task[id]->name, name); 187F 18020280 movw 2,x,0,sp 1883 E617 ldab -9,x 1885 87 clra 1886 59 lsld 1887 C30242 addd #_task 188A B7C6 xgdy 188C EC40 ldd 0,y 188E C30003 addd #3 1891 1636EC jsr _strcpy 1894 ; task[id]->state = state; 1894 E617 ldab -9,x 1896 87 clra 1897 59 lsld 1898 C30242 addd #_task 189B B7C6 xgdy 189D ED40 ldy 0,y 189F EC0A ldd 10,x 18A1 6B4C stab 12,y 18A3 ; task[id]->priority = priority; 18A3 E617 ldab -9,x 18A5 87 clra 18A6 59 lsld 18A7 C30242 addd #_task 18AA B7C6 xgdy 18AC ED40 ldy 0,y 18AE E609 ldab 9,x 18B0 6B4D stab 13,y 18B2 ; task[id]->period_tick = 0; 18B2 E617 ldab -9,x 18B4 87 clra 18B5 59 lsld 18B6 C30242 addd #_task 18B9 B7C6 xgdy 18BB ED40 ldy 0,y 18BD 194E leay 14,y 18BF 35 pshy ; spill 18C0 CD1B57 ldy #L20 18C3 1802401C movw 0,y,-4,x 18C7 1802421E movw 2,y,-2,x 18CB 31 puly ; reload 18CC 18021C40 movw -4,x,0,y 18D0 18021E42 movw -2,x,2,y 18D4 ; task[id]->interrupt_msg_box = NULL; 18D4 E617 ldab -9,x 18D6 87 clra 18D7 59 lsld 18D8 C30242 addd #_task 18DB B7C6 xgdy 18DD ED40 ldy 0,y 18DF CC0000 ldd #0 18E2 6CE812 std 18,y 18E5 ; task[id]->message = NULL; 18E5 E617 ldab -9,x 18E7 87 clra 18E8 59 lsld 18E9 C30242 addd #_task 18EC B7C6 xgdy 18EE ED40 ldy 0,y 18F0 69E814 clr 20,y 18F3 ; task[id]->message_data[0] = NULL; 18F3 E617 ldab -9,x 18F5 87 clra 18F6 59 lsld 18F7 C30242 addd #_task 18FA B7C6 xgdy 18FC ED40 ldy 0,y 18FE 69E815 clr 21,y 1901 ; task[id]->message_data[1] = NULL; 1901 E617 ldab -9,x 1903 87 clra 1904 59 lsld 1905 C30242 addd #_task 1908 B7C6 xgdy 190A ED40 ldy 0,y 190C 69E816 clr 22,y 190F ; if (stack_size == 0) stack_size = DEFAULT_STACK_SIZE; 190F EC0C ldd 12,x 1911 2605 bne L136 1913 CC0040 ldd #64 1916 6C0C std 12,x 1918 L136: 1918 ; task[id]->stack_size = stack_size; 1918 E617 ldab -9,x 191A 87 clra 191B 59 lsld 191C C30242 addd #_task 191F B7C6 xgdy 1921 ED40 ldy 0,y 1923 EC0C ldd 12,x 1925 6CE817 std 23,y 1928 ; task[id]->top_of_stack = malloc(task[id]->stack_size); 1928 E617 ldab -9,x 192A 87 clra 192B 59 lsld 192C C30242 addd #_task 192F B7C6 xgdy 1931 ED40 ldy 0,y 1933 6D15 sty -11,x 1935 ED15 ldy -11,x 1937 ECE817 ldd 23,y 193A 16395A jsr _malloc 193D 6CE1EC std -20,x 1940 ED15 ldy -11,x 1942 ECE1EC ldd -20,x 1945 6CE819 std 25,y 1948 ; task[id]->top_of_stack += task[id]->stack_size; 1948 E617 ldab -9,x 194A 87 clra 194B 59 lsld 194C C30242 addd #_task 194F B7C6 xgdy 1951 ED40 ldy 0,y 1953 6D13 sty -13,x 1955 EC13 ldd -13,x 1957 C30019 addd #25 195A 6C11 std -15,x 195C ED13 ldy -13,x 195E ECE817 ldd 23,y 1961 E3E3FFF1 addd [-15,x] 1965 ED11 ldy -15,x 1967 6C40 std 0,y 1969 ; task[id]->frame_ptr = NULL; 1969 E617 ldab -9,x 196B 87 clra 196C 59 lsld 196D C30242 addd #_task 1970 B7C6 xgdy 1972 ED40 ldy 0,y 1974 CC0000 ldd #0 1977 6CE81B std 27,y 197A ; 197A ; } 197A ; //} 197A ; INTR_ON(); 197A 10EF cli 197C 197C ; 197C ; return id; 197C E617 ldab -9,x 197E 87 clra 197F L127: 197F B757 tfr x,s 1981 30 pulx 1982 1B82 leas 2,sp 1984 .dbline 0 ; func end 1984 3D rts 1985 ; rid -> 3,x 1985 _get_resource_state:: 1985 3B pshd 1986 34 pshx 1987 B775 tfr s,x 1989 ; 1989 ; } 1989 ; 1989 ; 1989 ; 1989 ; 1989 ; int get_resource_state(unsigned char rid) { 1989 ; 1989 ; if (rid < NUMRESOURCES) { 1989 E603 ldab 3,x 198B C104 cmpb #4 198D 2414 bhs L139 198F ; return resource[rid].state; 198F E603 ldab 3,x 1991 87 clra 1992 B7C6 xgdy 1994 CC000C ldd #12 1997 1813 emuls 1999 C30218 addd #_resource+6 199C B7C6 xgdy 199E E640 ldab 0,y 19A0 87 clra 19A1 2003 bra L138 19A3 L139: 19A3 ; } 19A3 ; else { 19A3 ; #ifdef KERNEL_ERROR_MSG 19A3 ; puts(error_src[1]); puts(error_msg[6]); 19A3 ; #endif 19A3 ; return -1; 19A3 CCFFFF ldd #-1 19A6 L138: 19A6 B757 tfr x,s 19A8 30 pulx 19A9 1B82 leas 2,sp 19AB .dbline 0 ; func end 19AB 3D rts 19AC ; rid -> 3,x 19AC _get_resource_owner:: 19AC 3B pshd 19AD 34 pshx 19AE B775 tfr s,x 19B0 ; } 19B0 ; 19B0 ; } 19B0 ; 19B0 ; 19B0 ; 19B0 ; 19B0 ; 19B0 ; int get_resource_owner(unsigned char rid) { 19B0 ; 19B0 ; if (rid < NUMRESOURCES) { 19B0 E603 ldab 3,x 19B2 C104 cmpb #4 19B4 2414 bhs L143 19B6 ; return resource[rid].owner; 19B6 E603 ldab 3,x 19B8 87 clra 19B9 B7C6 xgdy 19BB CC000C ldd #12 19BE 1813 emuls 19C0 C30219 addd #_resource+7 19C3 B7C6 xgdy 19C5 E640 ldab 0,y 19C7 87 clra 19C8 2003 bra L142 19CA L143: 19CA ; } 19CA ; else { 19CA ; #ifdef KERNEL_ERROR_MSG 19CA ; puts(error_src[1]); puts(error_msg[6]); 19CA ; #endif 19CA ; return -1; 19CA CCFFFF ldd #-1 19CD L142: 19CD B757 tfr x,s 19CF 30 pulx 19D0 1B82 leas 2,sp 19D2 .dbline 0 ; func end 19D2 3D rts 19D3 ; rid -> 3,x 19D3 _get_resource_queuelen:: 19D3 3B pshd 19D4 34 pshx 19D5 B775 tfr s,x 19D7 ; } 19D7 ; 19D7 ; } 19D7 ; 19D7 ; 19D7 ; 19D7 ; 19D7 ; int get_resource_queuelen(unsigned char rid) { 19D7 ; 19D7 ; if (rid < NUMRESOURCES) { 19D7 E603 ldab 3,x 19D9 C104 cmpb #4 19DB 2414 bhs L147 19DD ; return resource[rid].queue_ptr; 19DD E603 ldab 3,x 19DF 87 clra 19E0 B7C6 xgdy 19E2 CC000C ldd #12 19E5 1813 emuls 19E7 C3021D addd #_resource+11 19EA B7C6 xgdy 19EC E640 ldab 0,y 19EE 87 clra 19EF 2003 bra L146 19F1 L147: 19F1 ; } 19F1 ; else { 19F1 ; #ifdef KERNEL_ERROR_MSG 19F1 ; puts(error_src[1]); puts(error_msg[6]); 19F1 ; #endif 19F1 ; return -1; 19F1 CCFFFF ldd #-1 19F4 L146: 19F4 B757 tfr x,s 19F6 30 pulx 19F7 1B82 leas 2,sp 19F9 .dbline 0 ; func end 19F9 3D rts 19FA ; last -> -6,x 19FA ; memory -> -4,x 19FA ; i -> -2,x 19FA _get_free_memory:: 19FA 34 pshx 19FB B775 tfr s,x 19FD 1B98 leas -8,sp 19FF ; } 19FF ; 19FF ; } 19FF ; 19FF ; 19FF ; 19FF ; 19FF ; int get_free_memory(void) { 19FF ; 19FF ; // LOCAL VARIABLES 19FF ; char *memory, *last; 19FF ; int i; 19FF ; 19FF ; 19FF ; INTR_OFF(); 19FF 1410 sei 1A01 1A01 CC0000 ldd #0 1A04 6C1E std -2,x 1A06 L151: 1A06 ; // check for largest free memory block 1A06 ; for (i=0; i -6,x 1A35 ; ?temp -> -4,x 1A35 ; ?temp -> -2,x 1A35 ; rid -> 3,x 1A35 _sem_get:: 1A35 3B pshd 1A36 34 pshx 1A37 B775 tfr s,x 1A39 1B98 leas -8,sp 1A3B ; 1A3B ; } 1A3B ; 1A3B ; 1A3B ; 1A3B ; 1A3B ; int sem_get(char rid) { 1A3B ; 1A3B ; /* Gives a resource to a requesting task. 1A3B ; returns the resource id number (0,1,2,...) if free. 1A3B ; otherwise returns -1. 1A3B ; 1A3B ; At this point, semaphores are a procedural control 1A3B ; that the tasks have to follow to avoid resource contention. 1A3B ; There is no kernel control over resources yet. */ 1A3B ; 1A3B ; 1A3B ; // critical section 1A3B ; INTR_OFF(); 1A3B 1410 sei 1A3D 1A3D ; 1A3D ; 1A3D ; 1A3D ; // GET SEMAPHORE 1A3D ; // give semaphore to task 1A3D ; if (resource[rid].state == NOTBUSY) { 1A3D E603 ldab 3,x 1A3F 87 clra 1A40 B7C6 xgdy 1A42 CC000C ldd #12 1A45 1813 emuls 1A47 C30218 addd #_resource+6 1A4A B7C6 xgdy 1A4C E740 tst 0,y 1A4E 2630 bne L158 1A50 ; resource[rid].state = BUSY; 1A50 E603 ldab 3,x 1A52 87 clra 1A53 B7C6 xgdy 1A55 CC000C ldd #12 1A58 1813 emuls 1A5A C30218 addd #_resource+6 1A5D B7C6 xgdy 1A5F C601 ldab #1 1A61 6B40 stab 0,y 1A63 ; resource[rid].owner = current; 1A63 E603 ldab 3,x 1A65 87 clra 1A66 B7C6 xgdy 1A68 CC000C ldd #12 1A6B 1813 emuls 1A6D C30219 addd #_resource+7 1A70 B7C6 xgdy 1A72 FC0264 ldd _current 1A75 6B40 stab 0,y 1A77 ; 1A77 ; INTR_ON(); 1A77 10EF cli 1A79 1A79 ; return rid; 1A79 E603 ldab 3,x 1A7B 87 clra 1A7C 18200084 lbra L157 1A80 L158: 1A80 ; } 1A80 ; 1A80 ; // resource is taken/busy so make task wait 1A80 ; else { 1A80 ; task[current]->message |= STATE_FLAG; 1A80 FC0264 ldd _current 1A83 59 lsld 1A84 C30242 addd #_task 1A87 B7C6 xgdy 1A89 EC40 ldd 0,y 1A8B C30014 addd #20 1A8E 6C1E std -2,x 1A90 B746 tfr d,y 1A92 35 pshy ; spill 1A93 ED1E ldy -2,x 1A95 31 puly ; reload 1A96 0C4001 bset 0,y,#1 1A99 ; task[current]->message_data[STATE_BOX] = WAITING; 1A99 FC0264 ldd _current 1A9C 59 lsld 1A9D C30242 addd #_task 1AA0 B7C6 xgdy 1AA2 ED40 ldy 0,y 1AA4 C603 ldab #3 1AA6 6BE815 stab 21,y 1AA9 ; 1AA9 ; // put waiting task into the resources queue if there's space 1AA9 ; if (resource[rid].queue_ptr < 3) { 1AA9 E603 ldab 3,x 1AAB 87 clra 1AAC B7C6 xgdy 1AAE CC000C ldd #12 1AB1 1813 emuls 1AB3 C3021D addd #_resource+11 1AB6 B7C6 xgdy 1AB8 E640 ldab 0,y 1ABA C103 cmpb #3 1ABC 2441 bhs L163 1ABE ; resource[rid].queue[resource[rid].queue_ptr] = current; 1ABE E603 ldab 3,x 1AC0 87 clra 1AC1 B7C6 xgdy 1AC3 CC000C ldd #12 1AC6 1813 emuls 1AC8 6C1C std -4,x 1ACA C3021D addd #_resource+11 1ACD B7C6 xgdy 1ACF E640 ldab 0,y 1AD1 87 clra 1AD2 3B pshd ; spill 1AD3 EC1C ldd -4,x 1AD5 C3021A addd #_resource+8 1AD8 6C18 std -8,x 1ADA 3A puld ; reload 1ADB E318 addd -8,x 1ADD B7C6 xgdy 1ADF F60265 ldab _current+1 1AE2 6B40 stab 0,y 1AE4 ; resource[rid].queue_ptr++; 1AE4 E603 ldab 3,x 1AE6 87 clra 1AE7 B7C6 xgdy 1AE9 CC000C ldd #12 1AEC 1813 emuls 1AEE C3021D addd #_resource+11 1AF1 6C1A std -6,x 1AF3 B746 tfr d,y 1AF5 E640 ldab 0,y 1AF7 87 clra 1AF8 C30001 addd #1 1AFB ED1A ldy -6,x 1AFD 6B40 stab 0,y 1AFF ; } 1AFF L163: 1AFF ; 1AFF ; INTR_ON(); 1AFF 10EF cli 1B01 1B01 ; return -1; 1B01 CCFFFF ldd #-1 1B04 L157: 1B04 B757 tfr x,s 1B06 30 pulx 1B07 1B82 leas 2,sp 1B09 .dbline 0 ; func end 1B09 3D rts 1B0A ; rid -> 3,x 1B0A _sem_give:: 1B0A 3B pshd 1B0B 34 pshx 1B0C B775 tfr s,x 1B0E ; } 1B0E ; 1B0E ; } 1B0E ; 1B0E ; 1B0E ; 1B0E ; 1B0E ; int sem_give(char rid) { 1B0E ; 1B0E ; /* Takes a resource back from a task. 1B0E ; will (eventually) pass a message to a waiting task. 1B0E ; 1B0E ; At this point, semaphores are a procedural control 1B0E ; that the tasks have to follow to avoid resource contention. 1B0E ; There is no kernel control over resources yet. */ 1B0E ; 1B0E ; 1B0E ; // critical section 1B0E ; INTR_OFF(); 1B0E 1410 sei 1B10 1B10 ; 1B10 ; 1B10 ; // return the resource 1B10 ; resource[rid].state = NOTBUSY; 1B10 E603 ldab 3,x 1B12 87 clra 1B13 B7C6 xgdy 1B15 CC000C ldd #12 1B18 1813 emuls 1B1A C30218 addd #_resource+6 1B1D B7C6 xgdy 1B1F 6940 clr 0,y 1B21 ; //resource[rid].owner = NULL; 1B21 ; 1B21 ; INTR_ON(); 1B21 10EF cli 1B23 1B23 ; 1B23 ; return 0; 1B23 CC0000 ldd #0 1B26 L169: 1B26 B757 tfr x,s 1B28 30 pulx 1B29 1B82 leas 2,sp 1B2B .dbline 0 ; func end 1B2B 3D rts .area bss 0212 _resource:: 0212 .blkb 48 0242 _task:: 0242 .blkb 16 0252 _last_time_mark:: 0252 .blkb 4 0256 _delta_t:: 0256 .blkb 4 025A _time_tick:: 025A .blkb 4 025E _cop_cycle:: 025E .blkb 2 0260 _system_tick:: 0260 .blkb 4 0264 _current:: 0264 .blkb 2 0266 _task_ptr:: 0266 .blkb 16 .area text --- 0B02 L66: --- 0B02 00000001 .word 0,1 --- 0B06 L64: --- 0B06 4B45524E454C3A207461736B20737461 .byte 'K,'E,'R,'N,'E,'L,58,32,'t,'a,'s,'k,32,'s,'t,'a --- 0B16 7465206572726F720A00 .byte 't,'e,32,'e,'r,'r,'o,'r,10,0 --- 0B20 L21: --- 0B20 726C704F532076302E370A0A00 .byte 'r,'l,'p,'O,'S,32,'v,48,46,55,10,10,0 --- 0B2D L20: --- 0B2D 00000000 .word 0,0 --- 0B31 L19: --- 0B31 7368656C6C206661696C75726500 .byte 's,'h,'e,'l,'l,32,'f,'a,'i,'l,'u,'r,'e,0 --- 0B3F L18: --- 0B3F 7368656C6C00 .byte 's,'h,'e,'l,'l,0 --- 0B45 L15: --- 0B45 737973496E6974206661696C75726500 .byte 's,'y,'s,'I,'n,'i,'t,32,'f,'a,'i,'l,'u,'r,'e,0 --- 0B55 L14: --- 0B55 737973496E697400 .byte 's,'y,'s,'I,'n,'i,'t,0 .module shell.c .area text ; ?temp -> -49,x ; ?temp -> -47,x ; cmd_length -> -46,x ; cmd -> -44,x ; argc -> -43,x ; argv -> -41,x ; cursor1 -> -39,x ; j -> -37,x ; cursor2 -> -36,x ; command -> -34,x ; i -> -1,x 1B87 _shell:: 1B87 34 pshx 1B88 B775 tfr s,x 1B8A 1BF1C4 leas -60,sp 1B8D ; // shell.c 1B8D ; 1B8D ; #include <912d60.h> 1B8D ; #include 1B8D ; #include 1B8D ; #include 1B8D ; #include 1B8D ; #include "kernel.h" 1B8D ; #include "semlib.h" 1B8D ; 1B8D ; 1B8D ; 1B8D ; 1B8D ; // FUNCTION PROTOTYPES 1B8D ; void shellcmd_help(char *argv1); 1B8D ; void shellcmd_tcb(signed char id); 1B8D ; void shellcmd_rcb(signed char id); 1B8D ; void shellcmd_rcbPrint(signed char rid); 1B8D ; void shellcmd_ticks(void); 1B8D ; void shellcmd_startTask(unsigned char id); 1B8D ; void shellcmd_stopTask(unsigned char id); 1B8D ; void shellcmd_freeMemCheck(void); 1B8D ; void shellcmd_kdb(int onoff); 1B8D ; void shellcmd_quitShell(void); 1B8D ; /* 1B8D ; void shellcmd_setTaskPriority(unsigned char id, unsigned char priority); 1B8D ; */ 1B8D ; 1B8D ; 1B8D ; 1B8D ; 1B8D ; // GLOBAL VARIABLES 1B8D ; extern unsigned long int system_tick; 1B8D ; extern unsigned int current; // current task id number 1B8D ; 1B8D ; extern char error_msg[8][25]; 1B8D ; extern char error_src[5][18]; 1B8D ; 1B8D ; extern char kdb_trace; 1B8D ; 1B8D ; 1B8D ; 1B8D ; 1B8D ; void shell(void) { 1B8D ; 1B8D ; // LOCAL CONSTANTS 1B8D ; #define cmd_size (32+1) 1B8D ; 1B8D ; 1B8D ; 1B8D ; // LOCAL ENUMERATIONS 1B8D ; enum command_type { help = 1, 1B8D ; tcb, 1B8D ; rcb, 1B8D ; ticks, 1B8D ; start, 1B8D ; stop, 1B8D ; priority, 1B8D ; freemem, 1B8D ; kdb, 1B8D ; quit 1B8D ; }; 1B8D ; 1B8D ; 1B8D ; 1B8D ; // LOCAL VARIABLES 1B8D ; char command[cmd_size], i, j, **argv, *cursor1, *cursor2; 1B8D ; int cmd_length, argc; 1B8D ; enum command_type cmd; 1B8D ; 1B8D ; 1B8D ; 1B8D ; 1B8D ; // INITIALIZE SHELL 1B8D ; sem_get(COM1); // get COM1 semaphore 1B8D CC0003 ldd #3 1B90 161A35 jsr _sem_get 1B93 ; set_task_priority(current, 254); 1B93 CC00FE ldd #254 1B96 6C80 std 0,sp 1B98 FC0264 ldd _current 1B9B 87 clra 1B9C 1617CB jsr _set_task_priority 1B9F ; INTR_ON(); // enable interrupts 1B9F 10EF cli 1BA1 1BA1 18200559 lbra L5 1BA5 L4: 1BA5 ; 1BA5 ; 1BA5 ; 1BA5 ; 1BA5 ; 1BA5 ; // SHELL COMMAND LINE INTERPRETER 1BA5 ; while (1) { 1BA5 ; 1BA5 ; i = 0; 1BA5 691F clr -1,x 1BA7 ; cursor1 = command; 1BA7 19E1DE leay -34,x 1BAA 6DE1D9 sty -39,x 1BAD ; cursor2 = command; 1BAD 19E1DE leay -34,x 1BB0 6DE1DC sty -36,x 1BB3 ; 1BB3 ; 1BB3 ; // put a PROMPT 1BB3 ; putchar('>'); putchar('>'); putchar(' '); 1BB3 CC003E ldd #62 1BB6 163170 jsr _putchar 1BB9 CC003E ldd #62 1BBC 163170 jsr _putchar 1BBF CC0020 ldd #32 1BC2 163170 jsr _putchar 1BC5 2056 bra L8 1BC7 L7: 1BC7 ; 1BC7 ; 1BC7 ; // GET AND ECHO THE COMMAND on the console 1BC7 ; while (((command[i]=getchar()) != 0xD) && (i -- required arguments"); 1F2A CC272C ldd #L77 1F2D 1636FB jsr _puts 1F30 ; puts("[] -- optional arguments\n"); 1F30 CC2712 ldd #L78 1F33 1636FB jsr _puts 1F36 ; puts("help [cmd] -- help on a specific command"); 1F36 CC26E9 ldd #L79 1F39 1636FB jsr _puts 1F3C ; puts("tcb [task_id] -- prints task control block"); 1F3C CC26BE ldd #L80 1F3F 1636FB jsr _puts 1F42 ; puts("rcb [[task_id] | [-b]] -- prints resource control block"); 1F42 CC2686 ldd #L81 1F45 1636FB jsr _puts 1F48 ; puts("ticks -- shows system tick"); 1F48 CC266B ldd #L82 1F4B 1636FB jsr _puts 1F4E ; puts("start -- start a task"); 1F4E CC264B ldd #L83 1F51 1636FB jsr _puts 1F54 ; puts("stop -- stop a task"); 1F54 CC262C ldd #L84 1F57 1636FB jsr _puts 1F5A ; puts("priority , -- change prio"); 1F5A CC25F8 ldd #L85 1F5D 1636FB jsr _puts 1F60 ; puts("freemem -- get approximate free RAM space"); 1F60 CC25CE ldd #L86 1F63 1636FB jsr _puts 1F66 ; puts("kdb [1|0] -- turn kernel debug on/off"); 1F66 CC25A8 ldd #L87 1F69 1636FB jsr _puts 1F6C ; puts("quit -- quit the shell (carefull!)"); 1F6C CC2585 ldd #L88 1F6F 1636FB jsr _puts 1F72 ; putchar('\n'); 1F72 CC000A ldd #10 1F75 163170 jsr _putchar 1F78 ; } 1F78 18200154 lbra L71 1F7C L74: 1F7C ; else if (argc == 2) 1F7C ECE1D5 ldd -43,x 1F7F 8C0002 cpd #2 1F82 1826014A lbne L71 1F86 ; shellcmd_help(argv[1]); 1F86 EDE1D7 ldy -41,x 1F89 EC42 ldd 2,y 1F8B 16210E jsr _shellcmd_help 1F8E ; break; 1F8E 1820013E lbra L71 1F92 L91: 1F92 ; case tcb: 1F92 ; if (argc == 1) 1F92 ECE1D5 ldd -43,x 1F95 8C0001 cpd #1 1F98 260A bne L92 1F9A ; shellcmd_tcb(-1); 1F9A CCFFFF ldd #-1 1F9D 162115 jsr _shellcmd_tcb 1FA0 1820012C lbra L71 1FA4 L92: 1FA4 ; else if (argc == 2) 1FA4 ECE1D5 ldd -43,x 1FA7 8C0002 cpd #2 1FAA 2611 bne L94 1FAC ; shellcmd_tcb(atoi(argv[1])); 1FAC EDE1D7 ldy -41,x 1FAF EC42 ldd 2,y 1FB1 163B5B jsr _atoi 1FB4 B714 tfr b,d 1FB6 162115 jsr _shellcmd_tcb 1FB9 18200113 lbra L71 1FBD L94: 1FBD ; else if (argc > 2) 1FBD ECE1D5 ldd -43,x 1FC0 8C0002 cpd #2 1FC3 182F0109 lble L71 1FC7 ; puts(error_msg[1]); 1FC7 CC1043 ldd #_error_msg+25 1FCA 1636FB jsr _puts 1FCD ; break; 1FCD 182000FF lbra L71 1FD1 L99: 1FD1 ; case rcb: 1FD1 ; if (argc == 1) // print entire rcb 1FD1 ECE1D5 ldd -43,x 1FD4 8C0001 cpd #1 1FD7 260A bne L100 1FD9 ; shellcmd_rcb(-1); 1FD9 CCFFFF ldd #-1 1FDC 1621D6 jsr _shellcmd_rcb 1FDF 182000ED lbra L71 1FE3 L100: 1FE3 ; else if (argc == 2) { 1FE3 ECE1D5 ldd -43,x 1FE6 8C0002 cpd #2 1FE9 262D bne L102 1FEB ; if (!strcmp(argv[1], "-b")) { // print 'busy' only 1FEB CC2582 ldd #L106 1FEE 6C80 std 0,sp 1FF0 EDE1D7 ldy -41,x 1FF3 EC42 ldd 2,y 1FF5 163682 jsr _strcmp 1FF8 8C0000 cpd #0 1FFB 260A bne L104 1FFD ; shellcmd_rcb(-2); 1FFD CCFFFE ldd #-2 2000 1621D6 jsr _shellcmd_rcb 2003 ; } 2003 182000C9 lbra L71 2007 L104: 2007 ; else 2007 ; shellcmd_rcb(atoi(argv[1])); // single 2007 EDE1D7 ldy -41,x 200A EC42 ldd 2,y 200C 163B5B jsr _atoi 200F B714 tfr b,d 2011 1621D6 jsr _shellcmd_rcb 2014 ; } 2014 182000B8 lbra L71 2018 L102: 2018 ; else if (argc > 2) 2018 ECE1D5 ldd -43,x 201B 8C0002 cpd #2 201E 182F00AE lble L71 2022 ; puts(error_msg[1]); 2022 CC1043 ldd #_error_msg+25 2025 1636FB jsr _puts 2028 ; break; 2028 182000A4 lbra L71 202C L110: 202C ; case ticks: 202C ; if (argc > 1) 202C ECE1D5 ldd -43,x 202F 8C0001 cpd #1 2032 2F0A ble L111 2034 ; puts(error_msg[1]); 2034 CC1043 ldd #_error_msg+25 2037 1636FB jsr _puts 203A 18200092 lbra L71 203E L111: 203E ; else 203E ; shellcmd_ticks(); 203E 16229E jsr _shellcmd_ticks 2041 ; break; 2041 1820008B lbra L71 2045 L114: 2045 ; case start: 2045 ; if ((argc != 2) || 2045 ECE1D5 ldd -43,x 2048 8C0002 cpd #2 204B 2610 bne L117 204D EDE1D7 ldy -41,x 2050 ED42 ldy 2,y 2052 E640 ldab 0,y 2054 87 clra 2055 163900 jsr _isdigit 2058 8C0000 cpd #0 205B 2608 bne L115 205D L117: 205D ; (!isdigit(*argv[1]))) 205D ; puts(error_msg[1]); 205D CC1043 ldd #_error_msg+25 2060 1636FB jsr _puts 2063 206B bra L71 2065 L115: 2065 ; else 2065 ; shellcmd_startTask(atoi(argv[1])); 2065 EDE1D7 ldy -41,x 2068 EC42 ldd 2,y 206A 163B5B jsr _atoi 206D 87 clra 206E 1622C6 jsr _shellcmd_startTask 2071 ; break; 2071 205D bra L71 2073 L119: 2073 ; case stop: 2073 ; if ((argc != 2) || 2073 ECE1D5 ldd -43,x 2076 8C0002 cpd #2 2079 2610 bne L122 207B EDE1D7 ldy -41,x 207E ED42 ldy 2,y 2080 E640 ldab 0,y 2082 87 clra 2083 163900 jsr _isdigit 2086 8C0000 cpd #0 2089 2608 bne L120 208B L122: 208B ; (!isdigit(*argv[1]))) 208B ; puts(error_msg[1]); 208B CC1043 ldd #_error_msg+25 208E 1636FB jsr _puts 2091 203D bra L71 2093 L120: 2093 ; else 2093 ; shellcmd_stopTask(atoi(argv[1])); 2093 EDE1D7 ldy -41,x 2096 EC42 ldd 2,y 2098 163B5B jsr _atoi 209B 87 clra 209C 1622F1 jsr _shellcmd_stopTask 209F ; break; 209F 202F bra L71 20A1 L124: 20A1 ; case priority: 20A1 ; puts(error_msg[0]); 20A1 CC102A ldd #_error_msg 20A4 1636FB jsr _puts 20A7 ; break; 20A7 2027 bra L71 20A9 L125: 20A9 ; case freemem: 20A9 ; shellcmd_freeMemCheck(); 20A9 162318 jsr _shellcmd_freeMemCheck 20AC ; break; 20AC 2022 bra L71 20AE L126: 20AE ; case kdb: 20AE ; if (argc < 2) 20AE ECE1D5 ldd -43,x 20B1 8C0002 cpd #2 20B4 2C08 bge L127 20B6 ; puts(error_msg[1]); 20B6 CC1043 ldd #_error_msg+25 20B9 1636FB jsr _puts 20BC 2012 bra L71 20BE L127: 20BE ; else 20BE ; shellcmd_kdb(atoi(argv[1])); 20BE EDE1D7 ldy -41,x 20C1 EC42 ldd 2,y 20C3 163B5B jsr _atoi 20C6 162330 jsr _shellcmd_kdb 20C9 ; break; 20C9 2005 bra L71 20CB L130: 20CB ; case quit: 20CB ; shellcmd_quitShell(); 20CB 16233F jsr _shellcmd_quitShell 20CE ; return; 20CE 203A bra L3 20D0 X2: 20D0 ; default: 20D0 ; break; 20D0 L71: 20D0 ; 20D0 ; }} // end switch/if 20D0 L68: 20D0 ; 20D0 ; 20D0 ; 20D0 ; // free the argc and argv array memory 20D0 ; for (i=0; i 2,x 210E _shellcmd_help:: 210E ; 210E ; 210E ; 210E ; 210E ; 210E ; void shellcmd_help(char *argv1) { 210E ; 210E ; puts(error_msg[0]); 210E CC102A ldd #_error_msg 2111 1636FB jsr _puts 2114 ; } 2114 L135: 2114 .dbline 0 ; func end 2114 3D rts 2115 ; start -> -2,x 2115 ; max -> -1,x 2115 ; tid -> 3,x 2115 _shellcmd_tcb:: 2115 3B pshd 2116 34 pshx 2117 B775 tfr s,x 2119 1BF1EA leas -22,sp 211C ; 211C ; 211C ; 211C ; void shellcmd_tcb(signed char tid) { 211C ; 211C ; // Local Variables 211C ; unsigned char max, start; 211C ; 211C ; if (tid >= MAXTASKS) { 211C E603 ldab 3,x 211E C108 cmpb #8 2120 2D0A blt L137 2122 ; puts(error_msg[2]); 2122 CC105C ldd #_error_msg+50 2125 1636FB jsr _puts 2128 ; return; 2128 182000A4 lbra L136 212C L137: 212C ; } 212C ; 212C ; if (tid < 0) { 212C E703 tst 3,x 212E 2C08 bge L140 2130 ; start = 0; 2130 691E clr -2,x 2132 ; max = MAXTASKS; 2132 C608 ldab #8 2134 6B1F stab -1,x 2136 ; } 2136 200F bra L141 2138 L140: 2138 ; else { 2138 ; start = tid; 2138 E603 ldab 3,x 213A B714 tfr b,d 213C 6B1E stab -2,x 213E ; max = tid + 1; 213E E603 ldab 3,x 2140 B714 tfr b,d 2142 C30001 addd #1 2145 6B1F stab -1,x 2147 ; } 2147 L141: 2147 ; 2147 ; puts("\nTask Control Block:"); 2147 CC256D ldd #L142 214A 1636FB jsr _puts 214D E61E ldab -2,x 214F 6B03 stab 3,x 2151 2065 bra L146 2153 L143: 2153 ; for (tid=start; tid -1,x 21D6 ; option -> 3,x 21D6 _shellcmd_rcb:: 21D6 3B pshd 21D7 34 pshx 21D8 B775 tfr s,x 21DA 1B9E leas -2,sp 21DC ; 21DC ; 21DC ; 21DC ; 21DC ; void shellcmd_rcb(signed char option) { 21DC ; 21DC ; // Local Variables 21DC ; unsigned char rid; 21DC ; 21DC ; 21DC ; 21DC ; // print all 21DC ; if (option == -1) { 21DC E603 ldab 3,x 21DE C1FF cmpb #-1 21E0 261B bne L154 21E2 691F clr -1,x 21E4 200F bra L159 21E6 L156: 21E6 E61F ldab -1,x 21E8 B714 tfr b,d 21EA 162256 jsr _shellcmd_rcbPrint 21ED L157: 21ED E61F ldab -1,x 21EF 87 clra 21F0 C30001 addd #1 21F3 6B1F stab -1,x 21F5 L159: 21F5 ; for (rid=0; rid= NUMRESOURCES) { 2229 E603 ldab 3,x 222B C104 cmpb #4 222D 2D08 blt L168 222F ; puts(error_msg[6]); 222F CC10C0 ldd #_error_msg+150 2232 1636FB jsr _puts 2235 ; return; 2235 2019 bra L153 2237 L168: 2237 ; } 2237 ; else 2237 ; shellcmd_rcbPrint(option); 2237 E603 ldab 3,x 2239 B714 tfr b,d 223B 162256 jsr _shellcmd_rcbPrint 223E ; 223E ; } 223E L161: 223E L155: 223E ; 223E ; 223E ; puts ("-----------+----------+------------+------------+"); 223E CC242A ldd #L171 2241 1636FB jsr _puts 2244 ; 2244 ; puts("\nState: 0=notbusy, 1=busy"); 2244 CC2410 ldd #L172 2247 1636FB jsr _puts 224A ; puts("Owner: 0..15=task ID, 255=nobody"); 224A CC23EF ldd #L173 224D 1636FB jsr _puts 2250 ; 2250 ; } 2250 L153: 2250 B757 tfr x,s 2252 30 pulx 2253 1B82 leas 2,sp 2255 .dbline 0 ; func end 2255 3D rts 2256 ; rid -> 3,x 2256 _shellcmd_rcbPrint:: 2256 3B pshd 2257 34 pshx 2258 B775 tfr s,x 225A 1B94 leas -12,sp 225C ; 225C ; 225C ; 225C ; void shellcmd_rcbPrint(signed char rid) { 225C ; 225C ; puts ("-----------+----------+------------+------------+"); 225C CC242A ldd #L171 225F 1636FB jsr _puts 2262 ; 2262 ; INTR_OFF(); 2262 1410 sei 2264 2264 ; printf("RsrcID: %2d | State: %x | Owner: %3d | Waiting: %d |\n", 2264 E603 ldab 3,x 2266 B714 tfr b,d 2268 87 clra 2269 161985 jsr _get_resource_state 226C 6C1E std -2,x 226E E603 ldab 3,x 2270 B714 tfr b,d 2272 87 clra 2273 1619AC jsr _get_resource_owner 2276 6C1C std -4,x 2278 E603 ldab 3,x 227A B714 tfr b,d 227C 87 clra 227D 1619D3 jsr _get_resource_queuelen 2280 6C86 std 6,sp 2282 ED1C ldy -4,x 2284 6D84 sty 4,sp 2286 ED1E ldy -2,x 2288 6D82 sty 2,sp 228A E603 ldab 3,x 228C B714 tfr b,d 228E 6C80 std 0,sp 2290 CC23B9 ldd #L175 2293 163733 jsr _printf 2296 ; rid, 2296 ; get_resource_state(rid), 2296 ; get_resource_owner(rid), 2296 ; get_resource_queuelen(rid)); 2296 ; INTR_ON(); 2296 10EF cli 2298 2298 ; 2298 ; } 2298 L174: 2298 B757 tfr x,s 229A 30 pulx 229B 1B82 leas 2,sp 229D .dbline 0 ; func end 229D 3D rts 229E ; lreg1 -> -4,x 229E ; lreg2 -> -8,x 229E _shellcmd_ticks:: 229E 34 pshx 229F B775 tfr s,x 22A1 1B94 leas -12,sp 22A3 ; 22A3 ; 22A3 ; 22A3 ; void shellcmd_ticks(void) { 22A3 ; 22A3 ; INTR_OFF(); 22A3 1410 sei 22A5 22A5 ; printf("ticks: %ld\n", system_tick); 22A5 CD0260 ldy #_system_tick 22A8 1802401C movw 0,y,-4,x 22AC 1802421E movw 2,y,-2,x 22B0 1980 leay 0,sp 22B2 18021C40 movw -4,x,0,y 22B6 18021E42 movw -2,x,2,y 22BA CC23AD ldd #L177 22BD 163733 jsr _printf 22C0 ; INTR_ON(); 22C0 10EF cli 22C2 22C2 ; } 22C2 L176: 22C2 B757 tfr x,s 22C4 30 pulx 22C5 .dbline 0 ; func end 22C5 3D rts 22C6 ; id -> 3,x 22C6 _shellcmd_startTask:: 22C6 3B pshd 22C7 34 pshx 22C8 B775 tfr s,x 22CA 1B9E leas -2,sp 22CC ; 22CC ; 22CC ; 22CC ; 22CC ; void shellcmd_startTask(unsigned char id) { 22CC ; 22CC ; INTR_OFF(); 22CC 1410 sei 22CE 22CE ; if (set_task_state(id, PENDING) == 0) 22CE CC0001 ldd #1 22D1 6C80 std 0,sp 22D3 E603 ldab 3,x 22D5 87 clra 22D6 1615D0 jsr _set_task_state 22D9 8C0000 cpd #0 22DC 260B bne L179 22DE ; printf("task %d started\n", id); 22DE E603 ldab 3,x 22E0 87 clra 22E1 6C80 std 0,sp 22E3 CC239C ldd #L181 22E6 163733 jsr _printf 22E9 L179: 22E9 ; INTR_ON(); 22E9 10EF cli 22EB 22EB ; } 22EB L178: 22EB B757 tfr x,s 22ED 30 pulx 22EE 1B82 leas 2,sp 22F0 .dbline 0 ; func end 22F0 3D rts 22F1 ; id -> 3,x 22F1 _shellcmd_stopTask:: 22F1 3B pshd 22F2 34 pshx 22F3 B775 tfr s,x 22F5 1B9E leas -2,sp 22F7 ; 22F7 ; 22F7 ; 22F7 ; 22F7 ; void shellcmd_stopTask(unsigned char id) { 22F7 ; 22F7 ; if ((set_task_state(id, STOPPED)) == 0) 22F7 CC0004 ldd #4 22FA 6C80 std 0,sp 22FC E603 ldab 3,x 22FE 87 clra 22FF 1615D0 jsr _set_task_state 2302 8C0000 cpd #0 2305 260B bne L183 2307 ; printf("task %d stopped\n", id); 2307 E603 ldab 3,x 2309 87 clra 230A 6C80 std 0,sp 230C CC238B ldd #L185 230F 163733 jsr _printf 2312 L183: 2312 ; 2312 ; } 2312 L182: 2312 B757 tfr x,s 2314 30 pulx 2315 1B82 leas 2,sp 2317 .dbline 0 ; func end 2317 3D rts 2318 _shellcmd_freeMemCheck:: 2318 34 pshx 2319 B775 tfr s,x 231B 1B9E leas -2,sp 231D ; 231D ; 231D ; 231D ; void shellcmd_freeMemCheck(void) { 231D ; 231D ; 231D ; INTR_OFF(); 231D 1410 sei 231F 231F ; printf("approximate free heap memory: %d bytes\n", get_free_memory()); 231F 1619FA jsr _get_free_memory 2322 6C80 std 0,sp 2324 CC2363 ldd #L187 2327 163733 jsr _printf 232A ; INTR_ON(); 232A 10EF cli 232C 232C ; 232C ; } 232C L186: 232C B757 tfr x,s 232E 30 pulx 232F .dbline 0 ; func end 232F 3D rts 2330 ; onoff -> 2,x 2330 _shellcmd_kdb:: 2330 3B pshd 2331 34 pshx 2332 B775 tfr s,x 2334 ; 2334 ; 2334 ; 2334 ; void shellcmd_kdb(int onoff) { 2334 ; 2334 ; 2334 ; kdb_trace = onoff; 2334 EC02 ldd 2,x 2336 7B0206 stab _kdb_trace 2339 ; 2339 ; } 2339 L188: 2339 B757 tfr x,s 233B 30 pulx 233C 1B82 leas 2,sp 233E .dbline 0 ; func end 233E 3D rts 233F _shellcmd_quitShell:: 233F ; 233F ; 233F ; 233F ; 233F ; void shellcmd_quitShell(void) { 233F ; 233F ; puts("exiting shell"); 233F CC2355 ldd #L190 2342 1636FB jsr _puts 2345 ; puts("\n"); 2345 CC2353 ldd #L191 2348 1636FB jsr _puts 234B ; shellcmd_stopTask(get_task_id()); 234B 161503 jsr _get_task_id 234E 87 clra 234F 1622F1 jsr _shellcmd_stopTask 2352 ; 2352 ; } 2352 L189: 2352 .dbline 0 ; func end 2352 3D rts 2353 L191: 2353 0A00 .byte 10,0 2355 L190: 2355 65786974696E67207368656C6C00 .byte 'e,'x,'i,'t,'i,'n,'g,32,'s,'h,'e,'l,'l,0 2363 L187: 2363 617070726F78696D6174652066726565 .byte 'a,'p,'p,'r,'o,'x,'i,'m,'a,'t,'e,32,'f,'r,'e,'e 2373 2068656170206D656D6F72793A202564 .byte 32,'h,'e,'a,'p,32,'m,'e,'m,'o,'r,'y,58,32,37,'d 2383 2062797465730A00 .byte 32,'b,'y,'t,'e,'s,10,0 238B L185: 238B 7461736B2025642073746F707065640A .byte 't,'a,'s,'k,32,37,'d,32,'s,'t,'o,'p,'p,'e,'d,10 239B 00 .byte 0 239C L181: 239C 7461736B20256420737461727465640A .byte 't,'a,'s,'k,32,37,'d,32,'s,'t,'a,'r,'t,'e,'d,10 23AC 00 .byte 0 23AD L177: 23AD 7469636B733A20256C640A00 .byte 't,'i,'c,'k,'s,58,32,37,'l,'d,10,0 23B9 L175: 23B9 5273726349443A20253264207C205374 .byte 'R,'s,'r,'c,'I,'D,58,32,37,50,'d,32,124,32,'S,'t 23C9 6174653A202578207C204F776E65723A .byte 'a,'t,'e,58,32,37,'x,32,124,32,'O,'w,'n,'e,'r,58 23D9 20253364207C2057616974696E673A20 .byte 32,37,51,'d,32,124,32,'W,'a,'i,'t,'i,'n,'g,58,32 23E9 2564207C0A00 .byte 37,'d,32,124,10,0 23EF L173: 23EF 4F776E65723A20302E2E31353D746173 .byte 'O,'w,'n,'e,'r,58,32,48,46,46,49,53,61,'t,'a,'s 23FF 6B2049442C203235353D6E6F626F6479 .byte 'k,32,'I,'D,44,32,50,53,53,61,'n,'o,'b,'o,'d,'y 240F 00 .byte 0 2410 L172: 2410 0A53746174653A20303D6E6F74627573 .byte 10,'S,'t,'a,'t,'e,58,32,48,61,'n,'o,'t,'b,'u,'s 2420 792C20313D6275737900 .byte 'y,44,32,49,61,'b,'u,'s,'y,0 242A L171: 242A 2D2D2D2D2D2D2D2D2D2D2D2B2D2D2D2D .byte 45,45,45,45,45,45,45,45,45,45,45,43,45,45,45,45 243A 2D2D2D2D2D2D2B2D2D2D2D2D2D2D2D2D .byte 45,45,45,45,45,45,43,45,45,45,45,45,45,45,45,45 244A 2D2D2D2B2D2D2D2D2D2D2D2D2D2D2D2D .byte 45,45,45,43,45,45,45,45,45,45,45,45,45,45,45,45 245A 2B00 .byte 43,0 245C L152: 245C 4D6573736167653A205B206269743720 .byte 'M,'e,'s,'s,'a,'g,'e,58,32,91,32,'b,'i,'t,55,32 246C 7C2062697436207C2062697435207C20 .byte 124,32,'b,'i,'t,54,32,124,32,'b,'i,'t,53,32,124,32 247C 62697434207C2062697433207C206269 .byte 'b,'i,'t,52,32,124,32,'b,'i,'t,51,32,124,32,'b,'i 248C 7432207C207072696F207C2073746174 .byte 't,50,32,124,32,'p,'r,'i,'o,32,124,32,'s,'t,'a,'t 249C 65205D00 .byte 'e,32,93,0 24A0 L151: 24A0 0A53746174653A20303D69646C652C20 .byte 10,'S,'t,'a,'t,'e,58,32,48,61,'i,'d,'l,'e,44,32 24B0 313D70656E64696E672C20323D72756E .byte 49,61,'p,'e,'n,'d,'i,'n,'g,44,32,50,61,'r,'u,'n 24C0 6E696E672C20333D77616974696E672C .byte 'n,'i,'n,'g,44,32,51,61,'w,'a,'i,'t,'i,'n,'g,44 24D0 20343D73746F7070656400 .byte 32,52,61,'s,'t,'o,'p,'p,'e,'d,0 24DB L150: 24DB 4E616D653A20253873207C2049443A20 .byte 'N,'a,'m,'e,58,32,37,56,'s,32,124,32,'I,'D,58,32 24EB 2564207C2053746174653A202564207C .byte 37,'d,32,124,32,'S,'t,'a,'t,'e,58,32,37,'d,32,124 24FB 205072696F3A20253364207C20416464 .byte 32,'P,'r,'i,'o,58,32,37,51,'d,32,124,32,'A,'d,'d 250B 723A20253478207C204D7367733A2030 .byte 'r,58,32,37,52,'x,32,124,32,'M,'s,'g,'s,58,32,48 251B 78253278207C0A00 .byte 'x,37,50,'x,32,124,10,0 2523 L149: 2523 2D2D2D2D2D2D2D2D2D2D2D2D2D2D2D2B .byte 45,45,45,45,45,45,45,45,45,45,45,45,45,45,45,43 2533 2D2D2D2D2D2D2D2B2D2D2D2D2D2D2D2D .byte 45,45,45,45,45,45,45,43,45,45,45,45,45,45,45,45 2543 2D2D2B2D2D2D2D2D2D2D2D2D2D2D2B2D .byte 45,45,43,45,45,45,45,45,45,45,45,45,45,45,43,45 2553 2D2D2D2D2D2D2D2D2D2D2D2B2D2D2D2D .byte 45,45,45,45,45,45,45,45,45,45,45,43,45,45,45,45 2563 2D2D2D2D2D2D2D2D2B00 .byte 45,45,45,45,45,45,45,45,43,0 256D L142: 256D 0A5461736B20436F6E74726F6C20426C .byte 10,'T,'a,'s,'k,32,'C,'o,'n,'t,'r,'o,'l,32,'B,'l 257D 6F636B3A00 .byte 'o,'c,'k,58,0 2582 L106: 2582 2D6200 .byte 45,'b,0 2585 L88: 2585 71756974202D2D207175697420746865 .byte 'q,'u,'i,'t,32,45,45,32,'q,'u,'i,'t,32,'t,'h,'e 2595 207368656C6C20286361726566756C6C .byte 32,'s,'h,'e,'l,'l,32,40,'c,'a,'r,'e,'f,'u,'l,'l 25A5 212900 .byte 33,41,0 25A8 L87: 25A8 6B6462205B317C305D202D2D20747572 .byte 'k,'d,'b,32,91,49,124,48,93,32,45,45,32,'t,'u,'r 25B8 6E206B65726E656C206465627567206F .byte 'n,32,'k,'e,'r,'n,'e,'l,32,'d,'e,'b,'u,'g,32,'o 25C8 6E2F6F666600 .byte 'n,47,'o,'f,'f,0 25CE L86: 25CE 667265656D656D202D2D206765742061 .byte 'f,'r,'e,'e,'m,'e,'m,32,45,45,32,'g,'e,'t,32,'a 25DE 7070726F78696D617465206672656520 .byte 'p,'p,'r,'o,'x,'i,'m,'a,'t,'e,32,'f,'r,'e,'e,32 25EE 52414D20737061636500 .byte 'R,'A,'M,32,'s,'p,'a,'c,'e,0 25F8 L85: 25F8 7072696F72697479203C7461736B5F69 .byte 'p,'r,'i,'o,'r,'i,'t,'y,32,60,'t,'a,'s,'k,95,'i 2608 643E2C203C7461736B5F7072696F7269 .byte 'd,62,44,32,60,'t,'a,'s,'k,95,'p,'r,'i,'o,'r,'i 2618 74793E20202D2D206368616E67652070 .byte 't,'y,62,32,32,45,45,32,'c,'h,'a,'n,'g,'e,32,'p 2628 72696F00 .byte 'r,'i,'o,0 262C L84: 262C 73746F70203C7461736B5F69643E2020 .byte 's,'t,'o,'p,32,60,'t,'a,'s,'k,95,'i,'d,62,32,32 263C 2D2D2073746F702061207461736B00 .byte 45,45,32,'s,'t,'o,'p,32,'a,32,'t,'a,'s,'k,0 264B L83: 264B 7374617274203C7461736B5F69643E20 .byte 's,'t,'a,'r,'t,32,60,'t,'a,'s,'k,95,'i,'d,62,32 265B 2D2D2073746172742061207461736B00 .byte 45,45,32,'s,'t,'a,'r,'t,32,'a,32,'t,'a,'s,'k,0 266B L82: 266B 7469636B73202D2D2073686F77732073 .byte 't,'i,'c,'k,'s,32,45,45,32,'s,'h,'o,'w,'s,32,'s 267B 797374656D207469636B00 .byte 'y,'s,'t,'e,'m,32,'t,'i,'c,'k,0 2686 L81: 2686 726362205B5B7461736B5F69645D207C .byte 'r,'c,'b,32,91,91,'t,'a,'s,'k,95,'i,'d,93,32,124 2696 205B2D625D5D202D2D207072696E7473 .byte 32,91,45,'b,93,93,32,45,45,32,'p,'r,'i,'n,'t,'s 26A6 207265736F7572636520636F6E74726F .byte 32,'r,'e,'s,'o,'u,'r,'c,'e,32,'c,'o,'n,'t,'r,'o 26B6 6C20626C6F636B00 .byte 'l,32,'b,'l,'o,'c,'k,0 26BE L80: 26BE 746362205B7461736B5F69645D202D2D .byte 't,'c,'b,32,91,'t,'a,'s,'k,95,'i,'d,93,32,45,45 26CE 207072696E7473207461736B20636F6E .byte 32,'p,'r,'i,'n,'t,'s,32,'t,'a,'s,'k,32,'c,'o,'n 26DE 74726F6C20626C6F636B00 .byte 't,'r,'o,'l,32,'b,'l,'o,'c,'k,0 26E9 L79: 26E9 68656C70205B636D645D202D2D206865 .byte 'h,'e,'l,'p,32,91,'c,'m,'d,93,32,45,45,32,'h,'e 26F9 6C70206F6E2061207370656369666963 .byte 'l,'p,32,'o,'n,32,'a,32,'s,'p,'e,'c,'i,'f,'i,'c 2709 20636F6D6D616E6400 .byte 32,'c,'o,'m,'m,'a,'n,'d,0 2712 L78: 2712 5B5D202D2D206F7074696F6E616C2061 .byte 91,93,32,45,45,32,'o,'p,'t,'i,'o,'n,'a,'l,32,'a 2722 7267756D656E74730A00 .byte 'r,'g,'u,'m,'e,'n,'t,'s,10,0 272C L77: 272C 3C3E202D2D2072657175697265642061 .byte 60,62,32,45,45,32,'r,'e,'q,'u,'i,'r,'e,'d,32,'a 273C 7267756D656E747300 .byte 'r,'g,'u,'m,'e,'n,'t,'s,0 2745 L76: 2745 2D2D2D48454C502D2D2D0A00 .byte 45,45,45,'H,'E,'L,'P,45,45,45,10,0 2751 L66: 2751 00 .byte 0 2752 L63: 2752 7175697400 .byte 'q,'u,'i,'t,0 2757 L60: 2757 6B646200 .byte 'k,'d,'b,0 275B L57: 275B 667265656D656D00 .byte 'f,'r,'e,'e,'m,'e,'m,0 2763 L54: 2763 7072696F7269747900 .byte 'p,'r,'i,'o,'r,'i,'t,'y,0 276C L51: 276C 73746F7000 .byte 's,'t,'o,'p,0 2771 L48: 2771 737461727400 .byte 's,'t,'a,'r,'t,0 2777 L45: 2777 7469636B7300 .byte 't,'i,'c,'k,'s,0 277D L42: 277D 72636200 .byte 'r,'c,'b,0 2781 L39: 2781 74636200 .byte 't,'c,'b,0 2785 L36: 2785 68656C7000 .byte 'h,'e,'l,'p,0 .module sysinit.c .area text ; id -> -2,x 278A _sysInit:: 278A 34 pshx 278B B775 tfr s,x 278D 1B94 leas -12,sp 278F ; // sysInit.c 278F ; 278F ; #include <912d60.h> 278F ; #include 278F ; #include "kernel.h" 278F ; 278F ; 278F ; 278F ; 278F ; // TASK PROTOTYPES 278F ; void shell(void); 278F ; void sysTime(void); 278F ; void task1(void); 278F ; void task2(void); 278F ; 278F ; 278F ; 278F ; 278F ; 278F ; 278F ; void sysInit(void) { 278F ; 278F ; // LOCAL VARIABLES 278F ; int id; 278F ; 278F ; 278F ; /* must create all the tasks without interrupt, because this task 278F ; will die when it finishes. */ 278F ; INTR_OFF(); 278F 1410 sei 2791 2791 ; 2791 ; 2791 ; // set up the serial port 2791 ; setbaud(BAUD38K); // actually running at 19K baud due to xtal speed 2791 CC000D ldd #13 2794 1631A2 jsr _setbaud 2797 ; 2797 ; // any additional user setup goes here 2797 ; 2797 ; 2797 ; 2797 ; // create task1 2797 ; if (create_task("task1", &task1, 18, IDLE, 0) < 0) 2797 CC0000 ldd #0 279A 6C86 std 6,sp 279C CC0000 ldd #0 279F 6C84 std 4,sp 27A1 CC0012 ldd #18 27A4 6C82 std 2,sp 27A6 CC281D ldd #_task1 27A9 6C80 std 0,sp 27AB CC2817 ldd #L6 27AE 161809 jsr _create_task 27B1 8C0000 cpd #0 27B4 2C06 bge L4 27B6 ; puts("task1 failure"); 27B6 CC2809 ldd #L7 27B9 1636FB jsr _puts 27BC L4: 27BC ; 27BC ; 27BC ; // create task2 27BC ; if (create_task("timer", &task2, 0, STOPPED, 255) < 0) 27BC CC00FF ldd #255 27BF 6C86 std 6,sp 27C1 CC0004 ldd #4 27C4 6C84 std 4,sp 27C6 CC0000 ldd #0 27C9 6C82 std 2,sp 27CB CC2876 ldd #_task2 27CE 6C80 std 0,sp 27D0 CC2803 ldd #L10 27D3 161809 jsr _create_task 27D6 8C0000 cpd #0 27D9 2C06 bge L8 27DB ; puts("task2 failure"); 27DB CC27F5 ldd #L11 27DE 1636FB jsr _puts 27E1 L8: 27E1 ; 27E1 ; 27E1 ; 27E1 ; // stop this sysInit task 27E1 ; set_task_state(get_task_id(), STOPPED); 27E1 161503 jsr _get_task_id 27E4 6C1C std -4,x 27E6 CC0004 ldd #4 27E9 6C80 std 0,sp 27EB EC1C ldd -4,x 27ED 87 clra 27EE 1615D0 jsr _set_task_state 27F1 ; 27F1 ; } 27F1 L3: 27F1 B757 tfr x,s 27F3 30 pulx 27F4 .dbline 0 ; func end 27F4 3D rts 27F5 L11: 27F5 7461736B32206661696C75726500 .byte 't,'a,'s,'k,50,32,'f,'a,'i,'l,'u,'r,'e,0 2803 L10: 2803 74696D657200 .byte 't,'i,'m,'e,'r,0 2809 L7: 2809 7461736B31206661696C75726500 .byte 't,'a,'s,'k,49,32,'f,'a,'i,'l,'u,'r,'e,0 2817 L6: 2817 7461736B3100 .byte 't,'a,'s,'k,49,0 .module task1.c .area text ; i -> -2,x 281D _task1:: 281D 34 pshx 281E B775 tfr s,x 2820 1B9E leas -2,sp 2822 ; // task1.c 2822 ; 2822 ; #include 2822 ; #include <912d60.h> 2822 ; #include "semlib.h" 2822 ; 2822 ; 2822 ; 2822 ; /* dummy task to eat up time, and to give the kernel 2822 ; something to multitask with */ 2822 ; void task1 (void) { 2822 ; 2822 ; int i; 2822 ; 2822 ; //sem_get(COM1); 2822 ; INTR_ON(); 2822 10EF cli 2824 2824 CC0000 ldd #0 2827 6C1E std -2,x 2829 L4: 2829 L5: 2829 ; 2829 ; 2829 ; //puts("T1 Starting"); 2829 ; for (i=0; i<0x0800; i++); 2829 EC1E ldd -2,x 282B C30001 addd #1 282E 6C1E std -2,x 2830 EC1E ldd -2,x 2832 8C0800 cpd #2048 2835 2DF2 blt L4 2837 CC0000 ldd #0 283A 6C1E std -2,x 283C L8: 283C L9: 283C ; //puts("T1.1"); 283C ; 283C ; for (i=0; i<0x1000; i++); 283C EC1E ldd -2,x 283E C30001 addd #1 2841 6C1E std -2,x 2843 EC1E ldd -2,x 2845 8C1000 cpd #4096 2848 2DF2 blt L8 284A CC0000 ldd #0 284D 6C1E std -2,x 284F L12: 284F L13: 284F ; //puts("T1.2"); 284F ; 284F ; for (i=0; i<0x1A00; i++); 284F EC1E ldd -2,x 2851 C30001 addd #1 2854 6C1E std -2,x 2856 EC1E ldd -2,x 2858 8C1A00 cpd #6656 285B 2DF2 blt L12 285D CC0000 ldd #0 2860 6C1E std -2,x 2862 L16: 2862 L17: 2862 ; //puts("T1.3"); 2862 ; 2862 ; for (i=0; i<0x2000; i++); 2862 EC1E ldd -2,x 2864 C30001 addd #1 2867 6C1E std -2,x 2869 EC1E ldd -2,x 286B 8C2000 cpd #8192 286E 2DF2 blt L16 2870 ; //puts("T1 Finished"); 2870 ; 2870 ; //puts("-T1-"); 2870 ; 2870 ; 2870 ; INTR_OFF(); 2870 1410 sei 2872 2872 ; //sem_give(COM1); 2872 ; 2872 ; } 2872 L3: 2872 B757 tfr x,s 2874 30 pulx 2875 .dbline 0 ; func end 2875 3D rts .module task2.c .area data --- 0000 L5: --- 0000 .blkb 1 .area idata --- 0000 00 .byte 0 .area data --- 0001 L6: --- 0001 .blkb 1 .area idata --- 0001 00 .byte 0 .area data --- 0002 L7: --- 0002 .blkb 1 .area idata --- 0002 00 .byte 0 .area data --- 0003 L8: --- 0003 .blkb 1 .area idata --- 0003 00 .byte 0 .area data --- 0004 L9: --- 0004 .blkb 1 .area idata --- 0004 00 .byte 0 .area data --- 0005 L10: --- 0005 .blkb 1 .area idata --- 0005 00 .byte 0 .area data --- 0006 L11: --- 0006 .blkb 1 .area idata --- 0006 00 .byte 0 .area data .area bss --- 0000 L12: --- 0000 .blkb 4 .area data --- 0007 L13: --- 0007 .blkb 1 .area idata --- 0007 01 .byte 1 .area data .area text ; lreg1 -> -4,x ; lreg2 -> -8,x ; one_second -> -21,x ; tick_size -> -17,x ; delta_t -> -15,x ; redraw -> -11,x ; i -> -9,x 2876 _task2:: 2876 34 pshx 2877 B775 tfr s,x 2879 1BF1EA leas -22,sp 287C ; // task2.c 287C ; 287C ; #include 287C ; #include <912d60.h> 287C ; #include "kernel.h" 287C ; 287C ; 287C ; 287C ; /* counts seconds and displays them */ 287C ; void task2 (void) { 287C ; 287C ; 287C ; char i; 287C ; 287C ; extern unsigned long int system_tick; 287C ; unsigned long int delta_t; 287C ; const unsigned int tick_size = 65535; 287C CCFFFF ldd #0xffff 287F 6CE1EF std -17,x 2882 ; const unsigned long int one_second = 1000000; 2882 CD2AD2 ldy #L4 2885 1802401C movw 0,y,-4,x 2889 1802421E movw 2,y,-2,x 288D 19E1EB leay -21,x 2890 18021C40 movw -4,x,0,y 2894 18021E42 movw -2,x,2,y 2898 ; 2898 ; 2898 ; static unsigned char hh=0, hm=0, hl=0, mh=0, ml=0, sh=0, sl=0; 2898 ; static unsigned long int last_mark; 2898 ; int redraw; 2898 ; static char startup = 1; 2898 ; 2898 ; 2898 ; INTR_ON(); 2898 10EF cli 289A 289A ; 289A ; 289A ; 289A ; delta_t = (system_tick - last_mark) * tick_size; 289A CD0260 ldy #_system_tick 289D 1802401C movw 0,y,-4,x 28A1 1802421E movw 2,y,-2,x 28A5 CD0276 ldy #L12 28A8 18024018 movw 0,y,-8,x 28AC 1802421A movw 2,y,-6,x 28B0 1634D2 jsr __lsub 28B3 ECE1EF ldd -17,x 28B6 6C1A std -6,x 28B8 1800180000 movw #0,-8,x 28BD 1634E3 jsr __lmul 28C0 1911 leay -15,x 28C2 18021C40 movw -4,x,0,y 28C6 18021E42 movw -2,x,2,y 28CA ; 28CA ; if (delta_t > one_second) { 28CA 1911 leay -15,x 28CC 1802401C movw 0,y,-4,x 28D0 1802421E movw 2,y,-2,x 28D4 19E1EB leay -21,x 28D7 18024018 movw 0,y,-8,x 28DB 1802421A movw 2,y,-6,x 28DF 163662 jsr __lcmp 28E2 182301E6 lbls L14 28E6 ; last_mark = system_tick; 28E6 CD0260 ldy #_system_tick 28E9 1802401C movw 0,y,-4,x 28ED 1802421E movw 2,y,-2,x 28F1 CD0276 ldy #L12 28F4 18021C40 movw -4,x,0,y 28F8 18021E42 movw -2,x,2,y 28FC ; sl++; 28FC F60210 ldab L11 28FF 87 clra 2900 C30001 addd #1 2903 7B0210 stab L11 2906 ; redraw = 1; 2906 CC0001 ldd #1 2909 6C15 std -11,x 290B ; if (sl > 9) { 290B F60210 ldab L11 290E C109 cmpb #9 2910 2312 bls L16 2912 ; sh++; 2912 F6020F ldab L10 2915 87 clra 2916 C30001 addd #1 2919 7B020F stab L10 291C ; sl = 0; 291C 790210 clr L11 291F ; redraw = 2; 291F CC0002 ldd #2 2922 6C15 std -11,x 2924 ; } 2924 L16: 2924 ; if (sh > 5) { 2924 F6020F ldab L10 2927 C105 cmpb #5 2929 2312 bls L18 292B ; ml++; 292B F6020E ldab L9 292E 87 clra 292F C30001 addd #1 2932 7B020E stab L9 2935 ; sh = 0; 2935 79020F clr L10 2938 ; redraw = 4; 2938 CC0004 ldd #4 293B 6C15 std -11,x 293D ; } 293D L18: 293D ; if (ml > 9) { 293D F6020E ldab L9 2940 C109 cmpb #9 2942 2312 bls L20 2944 ; mh++; 2944 F6020D ldab L8 2947 87 clra 2948 C30001 addd #1 294B 7B020D stab L8 294E ; ml = 0; 294E 79020E clr L9 2951 ; redraw = 5; 2951 CC0005 ldd #5 2954 6C15 std -11,x 2956 ; } 2956 L20: 2956 ; if (mh > 5) { 2956 F6020D ldab L8 2959 C105 cmpb #5 295B 2312 bls L22 295D ; hl++; 295D F6020C ldab L7 2960 87 clra 2961 C30001 addd #1 2964 7B020C stab L7 2967 ; mh = 0; 2967 79020D clr L8 296A ; redraw = 7; 296A CC0007 ldd #7 296D 6C15 std -11,x 296F ; } 296F L22: 296F ; if (hl > 9) { 296F F6020C ldab L7 2972 C109 cmpb #9 2974 2312 bls L24 2976 ; hm++; 2976 F6020B ldab L6 2979 87 clra 297A C30001 addd #1 297D 7B020B stab L6 2980 ; hl = 0; 2980 79020C clr L7 2983 ; redraw = 8; 2983 CC0008 ldd #8 2986 6C15 std -11,x 2988 ; } 2988 L24: 2988 ; if (hm > 9) { 2988 F6020B ldab L6 298B C109 cmpb #9 298D 2312 bls L26 298F ; hh++; 298F F6020A ldab L5 2992 87 clra 2993 C30001 addd #1 2996 7B020A stab L5 2999 ; hm = 0; 2999 79020B clr L6 299C ; redraw = 9; 299C CC0009 ldd #9 299F 6C15 std -11,x 29A1 ; } 29A1 L26: 29A1 ; if (hh > 9) { 29A1 F6020A ldab L5 29A4 C109 cmpb #9 29A6 2308 bls L28 29A8 ; hh = 0; 29A8 79020A clr L5 29AB ; redraw = 9; 29AB CC0009 ldd #9 29AE 6C15 std -11,x 29B0 ; } 29B0 L28: 29B0 ; 29B0 ; 29B0 ; // display time 29B0 ; if (startup) { 29B0 F70211 tst L13 29B3 2760 beq L30 29B5 ; putchar(hh+48); 29B5 F6020A ldab L5 29B8 87 clra 29B9 C30030 addd #48 29BC 87 clra 29BD 163170 jsr _putchar 29C0 ; putchar(hm+48); 29C0 F6020B ldab L6 29C3 87 clra 29C4 C30030 addd #48 29C7 87 clra 29C8 163170 jsr _putchar 29CB ; putchar(hl+48); 29CB F6020C ldab L7 29CE 87 clra 29CF C30030 addd #48 29D2 87 clra 29D3 163170 jsr _putchar 29D6 ; putchar(':'); 29D6 CC003A ldd #58 29D9 163170 jsr _putchar 29DC ; putchar(mh+48); 29DC F6020D ldab L8 29DF 87 clra 29E0 C30030 addd #48 29E3 87 clra 29E4 163170 jsr _putchar 29E7 ; putchar(ml+48); 29E7 F6020E ldab L9 29EA 87 clra 29EB C30030 addd #48 29EE 87 clra 29EF 163170 jsr _putchar 29F2 ; putchar(':'); 29F2 CC003A ldd #58 29F5 163170 jsr _putchar 29F8 ; putchar(sh+48); 29F8 F6020F ldab L10 29FB 87 clra 29FC C30030 addd #48 29FF 87 clra 2A00 163170 jsr _putchar 2A03 ; putchar(sl+48); 2A03 F60210 ldab L11 2A06 87 clra 2A07 C30030 addd #48 2A0A 87 clra 2A0B 163170 jsr _putchar 2A0E ; 2A0E ; startup = 0; 2A0E 790211 clr L13 2A11 ; } 2A11 182000B7 lbra L31 2A15 L30: 2A15 ; else { 2A15 ; for (i=0; i 2AD6 ; #include <912d60.h> 2AD6 ; #include "kernel.h" 2AD6 ; 2AD6 ; 2AD6 ; 2AD6 ; 2AD6 ; 2AD6 ; void sysTime(void) { 2AD6 ; 2AD6 ; 2AD6 ; INTR_ON(); 2AD6 10EF cli 2AD8 2AD8 L4: 2AD8 L5: 2AD8 ; 2AD8 ; while (1) { 2AD8 20FE bra L4 2ADA X0: 2ADA ; 2ADA ; // MAINTAIN SYSTEM TIME 2ADA ; 2ADA ; } 2ADA ; 2ADA ; 2ADA ; INTR_OFF(); 2ADA 1410 sei 2ADC 2ADC ; 2ADC ; } 2ADC L3: 2ADC .dbline 0 ; func end 2ADC 3D rts .module interrupts.c .area text 2ADD _ADC_handler:: 2ADD ; // interrupts.c 2ADD ; 2ADD ; #include 2ADD ; #include <912D60.h> 2ADD ; #include "kernel.h" 2ADD ; 2ADD ; 2ADD ; 2ADD ; // FUNCTION PROTOTYPES 2ADD ; void _start(void); 2ADD ; 2ADD ; 2ADD ; 2ADD ; /* Example code flow for all of these handlers: 2ADD ; 2ADD ; // IF interrupt isn't very time critical: 2ADD ; figure out who cares, if anyone, then send a msg to the caring task 2ADD ; 2ADD ; 2ADD ; if (resource[ADC].owner != 255) 2ADD ; task[resource[ADC].owner].message |= ADC_MSG; 2ADD ; 2ADD ; 2ADD ; 2ADD ; // IF interrupt is time critical: (ie, there's data that needs to be serviced) 2ADD ; get the data, put it in a buffer, then put the data in the message buffer 2ADD ; 2ADD ; task[resource[ADC].owner].message_data[ADC_MSG] = ADC; // ADC = correct port definition? 2ADD ; */ 2ADD ; 2ADD ; 2ADD ; 2ADD ; 2ADD ; 2ADD ; // GLOBALS 2ADD ; extern unsigned int interrupt_flags_ADC; 2ADD ; extern unsigned int interrupt_flags_TC; 2ADD ; 2ADD ; 2ADD ; 2ADD ; 2ADD ; 2ADD ; #pragma interrupt_handler ADC_handler() 2ADD ; 2ADD ; void ADC_handler(void) { 2ADD ; 2ADD ; // figure out which adc interrupted 2ADD ; 2ADD ; // set appropriate global interrupt adc flag 2ADD ; 2ADD ; 2ADD ; } 2ADD L3: 2ADD .dbline 0 ; func end 2ADD 0B rti 2ADE _SCI1_handler:: 2ADE ; 2ADE ; 2ADE ; 2ADE ; /* #pragma interrupt_handler SCI0_handler() 2ADE ; 2ADE ; void SCI0_handler(void) { 2ADE ; 2ADE ; 2ADE ; 2ADE ; } */ 2ADE ; 2ADE ; 2ADE ; 2ADE ; #pragma interrupt_handler SCI1_handler() 2ADE ; 2ADE ; void SCI1_handler(void) { 2ADE ; 2ADE ; 2ADE ; 2ADE ; } 2ADE L4: 2ADE .dbline 0 ; func end 2ADE 0B rti 2ADF _SPI_handler:: 2ADF ; 2ADF ; 2ADF ; 2ADF ; #pragma interrupt_handler SPI_handler() 2ADF ; 2ADF ; void SPI_handler(void) { 2ADF ; 2ADF ; 2ADF ; 2ADF ; } 2ADF L5: 2ADF .dbline 0 ; func end 2ADF 0B rti 2AE0 _PAIE_handler:: 2AE0 ; 2AE0 ; 2AE0 ; 2AE0 ; #pragma interrupt_handler PAIE_handler() 2AE0 ; 2AE0 ; void PAIE_handler(void) { 2AE0 ; 2AE0 ; 2AE0 ; 2AE0 ; } 2AE0 L6: 2AE0 .dbline 0 ; func end 2AE0 0B rti 2AE1 _PAO_handler:: 2AE1 ; 2AE1 ; 2AE1 ; 2AE1 ; #pragma interrupt_handler PAO_handler() 2AE1 ; 2AE1 ; void PAO_handler(void) { 2AE1 ; 2AE1 ; 2AE1 ; 2AE1 ; } 2AE1 L7: 2AE1 .dbline 0 ; func end 2AE1 0B rti 2AE2 ; lreg1 -> -4,x 2AE2 ; lreg2 -> -8,x 2AE2 _TOF_handler:: 2AE2 34 pshx 2AE3 B775 tfr s,x 2AE5 1B98 leas -8,sp 2AE7 ; 2AE7 ; 2AE7 ; 2AE7 ; #pragma interrupt_handler TOF_handler() 2AE7 ; 2AE7 ; void TOF_handler(void) { 2AE7 ; 2AE7 ; // LOCAL VARIABLES 2AE7 ; extern unsigned long int time_tick; 2AE7 ; 2AE7 ; // acknowledge the interrupt 2AE7 ; TFLG2 = 0x80; 2AE7 C680 ldab #128 2AE9 7B008F stab 0x8f 2AEC ; 2AEC ; time_tick++; 2AEC CD025A ldy #_time_tick 2AEF 1802401C movw 0,y,-4,x 2AF3 1802421E movw 2,y,-2,x 2AF7 CD2B35 ldy #L9 2AFA 18024018 movw 0,y,-8,x 2AFE 1802421A movw 2,y,-6,x 2B02 1634C1 jsr __ladd 2B05 CD025A ldy #_time_tick 2B08 18021C40 movw -4,x,0,y 2B0C 18021E42 movw -2,x,2,y 2B10 ; 2B10 ; } 2B10 L8: 2B10 B757 tfr x,s 2B12 30 pulx 2B13 .dbline 0 ; func end 2B13 0B rti 2B14 _TC7_handler:: 2B14 ; 2B14 ; 2B14 ; 2B14 ; #pragma interrupt_handler TC7_handler() 2B14 ; 2B14 ; void TC7_handler(void) { 2B14 ; 2B14 ; 2B14 ; 2B14 ; } 2B14 L10: 2B14 .dbline 0 ; func end 2B14 0B rti 2B15 _TC6_handler:: 2B15 ; 2B15 ; 2B15 ; 2B15 ; #pragma interrupt_handler TC6_handler() 2B15 ; 2B15 ; void TC6_handler(void) { 2B15 ; 2B15 ; 2B15 ; 2B15 ; } 2B15 L11: 2B15 .dbline 0 ; func end 2B15 0B rti 2B16 _TC5_handler:: 2B16 ; 2B16 ; 2B16 ; 2B16 ; #pragma interrupt_handler TC5_handler() 2B16 ; 2B16 ; void TC5_handler(void) { 2B16 ; 2B16 ; 2B16 ; 2B16 ; } 2B16 L12: 2B16 .dbline 0 ; func end 2B16 0B rti 2B17 _TC4_handler:: 2B17 ; 2B17 ; 2B17 ; 2B17 ; #pragma interrupt_handler TC4_handler() 2B17 ; 2B17 ; void TC4_handler(void) { 2B17 ; 2B17 ; 2B17 ; 2B17 ; } 2B17 L13: 2B17 .dbline 0 ; func end 2B17 0B rti 2B18 _TC3_handler:: 2B18 ; 2B18 ; 2B18 ; 2B18 ; #pragma interrupt_handler TC3_handler() 2B18 ; 2B18 ; void TC3_handler(void) { 2B18 ; 2B18 ; 2B18 ; 2B18 ; } 2B18 L14: 2B18 .dbline 0 ; func end 2B18 0B rti 2B19 _TC2_handler:: 2B19 ; 2B19 ; 2B19 ; 2B19 ; #pragma interrupt_handler TC2_handler() 2B19 ; 2B19 ; void TC2_handler(void) { 2B19 ; 2B19 ; 2B19 ; 2B19 ; } 2B19 L15: 2B19 .dbline 0 ; func end 2B19 0B rti 2B1A _TC1_handler:: 2B1A ; 2B1A ; 2B1A ; 2B1A ; #pragma interrupt_handler TC1_handler() 2B1A ; 2B1A ; void TC1_handler(void) { 2B1A ; 2B1A ; 2B1A ; 2B1A ; } 2B1A L16: 2B1A .dbline 0 ; func end 2B1A 0B rti 2B1B _TC0_handler:: 2B1B ; 2B1B ; 2B1B ; 2B1B ; #pragma interrupt_handler TC0_handler() 2B1B ; 2B1B ; void TC0_handler(void) { 2B1B ; 2B1B ; 2B1B ; 2B1B ; } 2B1B L17: 2B1B .dbline 0 ; func end 2B1B 0B rti 2B1C _IRQ_handler:: 2B1C ; 2B1C ; 2B1C ; 2B1C ; #pragma interrupt_handler IRQ_handler() 2B1C ; 2B1C ; void IRQ_handler(void) { 2B1C ; 2B1C ; 2B1C ; 2B1C ; } 2B1C L18: 2B1C .dbline 0 ; func end 2B1C 0B rti 2B1D _XIRQ_handler:: 2B1D ; 2B1D ; 2B1D ; 2B1D ; #pragma interrupt_handler XIRQ_handler() 2B1D ; 2B1D ; void XIRQ_handler(void) { 2B1D ; 2B1D ; 2B1D ; 2B1D ; } 2B1D L19: 2B1D .dbline 0 ; func end 2B1D 0B rti 2B1E _SWI_handler:: 2B1E ; 2B1E ; 2B1E ; 2B1E ; #pragma interrupt_handler SWI_handler() 2B1E ; 2B1E ; void SWI_handler(void) { 2B1E ; 2B1E ; 2B1E ; 2B1E ; } 2B1E L20: 2B1E .dbline 0 ; func end 2B1E 0B rti 2B1F _COP_handler:: 2B1F ; 2B1F ; 2B1F ; 2B1F ; #pragma interrupt_handler COP_handler() 2B1F ; 2B1F ; void COP_handler(void) { 2B1F ; 2B1F ; puts("COP RESET!"); 2B1F CC2B2A ldd #L22 2B22 1636FB jsr _puts 2B25 ; _start(); 2B25 161000 jsr __start 2B28 ; 2B28 ; } 2B28 L21: 2B28 .dbline 0 ; func end 2B28 0B rti 2B29 _CLM_handler:: 2B29 ; 2B29 ; 2B29 ; 2B29 ; #pragma interrupt_handler CLM_handler() 2B29 ; 2B29 ; void CLM_handler(void) { 2B29 ; 2B29 ; 2B29 ; 2B29 ; } 2B29 L23: 2B29 .dbline 0 ; func end 2B29 0B rti 2B2A L22: 2B2A 434F502052455345542100 .byte 'C,'O,'P,32,'R,'E,'S,'E,'T,33,0 2B35 L9: 2B35 00000001 .word 0,1 .module vectors.c .area memory(abs) .org 0xffd0 FFD0 _interrupt_vectors:: FFD0 FFFF .word 65535 FFD2 2ADD .word _ADC_handler FFD4 FFFF .word 65535 FFD6 2ADE .word _SCI1_handler FFD8 2ADF .word _SPI_handler FFDA 2AE0 .word _PAIE_handler FFDC 2AE1 .word _PAO_handler FFDE 2AE2 .word _TOF_handler FFE0 2B14 .word _TC7_handler FFE2 2B15 .word _TC6_handler FFE4 2B16 .word _TC5_handler FFE6 2B17 .word _TC4_handler FFE8 2B18 .word _TC3_handler FFEA 2B19 .word _TC2_handler FFEC 2B1A .word _TC1_handler FFEE 2B1B .word _TC0_handler FFF0 148F .word _RTI_handler FFF2 2B1C .word _IRQ_handler FFF4 2B1D .word _XIRQ_handler FFF6 2B1E .word _SWI_handler FFF8 FFFF .word 65535 FFFA 2B1F .word _COP_handler FFFC 2B29 .word _CLM_handler FFFE 1000 .word __start .area data .module _HC12Setup.c .area text 2B39 __HC12Setup:: 2B39 ; // _HC12Setup.c 2B39 ; 2B39 ; #include <912d60.h> 2B39 ; #include "kernel.h" 2B39 ; 2B39 ; 2B39 ; 2B39 ; void _HC12Setup(void) { 2B39 ; 2B39 ; // set the register base to 0x800 2B39 ; //*(volatile unsigned char *)0x0011 = 0x08; 2B39 ; 2B39 ; 2B39 ; // set up the RTI INTERRUPT 2B39 ; INTR_OFF(); // disable/mask all maskable interrupts 2B39 1410 sei 2B3B 2B3B ; RTICTL = 0x86; // enable RTI at 65.536 miliseconds 2B3B C686 ldab #134 2B3D 7B0014 stab 0x14 2B40 ; //RTICTL = 0x85; // enable RTI at 32.768 miliseconds 2B40 ; RTIFLG = 0x80; // clear real time interrupt flag 2B40 C680 ldab #128 2B42 7B0015 stab 0x15 2B45 ; 2B45 ; 2B45 ; // set up the COP WATCHDOG clock monitor for 524.288 ms 2B45 ; COPCTL = 0xC5; // COP on 2B45 C6C5 ldab #197 2B47 7B0016 stab 0x16 2B4A ; //COPCTL = 0x00; // COP off 2B4A ; 2B4A ; 2B4A ; // set the TOF interrupt up 2B4A ; TMSK2 = 0x87; // set to interrupt at 65.536 microseconds 2B4A C687 ldab #135 2B4C 7B008D stab 0x8d 2B4F ; PACTL = 2B4F C680 ldab #128 2B51 7B0086 stab 0x86 2B54 C680 ldab #128 2B56 7B00A0 stab 0xa0 2B59 ; TSCR = 0x80; 2B59 ; 2B59 ; HPRIO = 0xDE; // elevate the TOF interrupt 2B59 C6DE ldab #222 2B5B 7B001F stab 0x1f 2B5E ; 2B5E ; } 2B5E L3: 2B5E .dbline 0 ; func end 2B5E 3D rts