DOS编程：TSR程序实现原理与实时运动控制

1
2
3
4
5

普通程序：  加载 → 执行 → 终止 → 释放全部内存

TSR 程序：  加载 → 初始化 → 挂接中断 → "终止但驻留"
         ↓
    内存里的代码持续通过中断被调用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

#include <dos.h>

void keep_resident(unsigned int paragraphs, unsigned char exit_code) {
    union REGS regs;
regs.h.ah = 0x31;      // Keep Process (TSR)
    regs.h.al = exit_code; // 退出码
    regs.x.dx = paragraphs; // 驻留内存大小（以16字节为单位）
    int86(0x21, &regs, &regs);
    // 此调用不会返回
}

1

paragraphs = (4096 + 15) / 16;  // 向上取整

1
2
3
4
5
6
7
8
9

地址       中断号   用途
0000:0000    INT 00h   除零错误
0000:0004    INT 01h   单步调试
...
0000:0020    INT 08h   系统定时器（18.2 次/秒，关键！）
...
0000:0024    INT 09h   键盘中断
...
0000:00CC    INT 33h   鼠标服务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <dos.h>

void interrupt (*old_timer_handler)();

void interrupt new_timer_handler() {
    // === 你的实时任务代码 ===
    do_interpolation_step();  // 插补计算的一步
    output_pulse();   // 输出伺服脉冲
    
    // 调用原处理程序（维持系统时钟正常）
    (*old_timer_handler)();
}

void install_tsr() {
    old_timer_handler = getvect(0x08);   // 保存原向量
    setvect(0x08, new_timer_handler);    // 挂接新向量
}

void uninstall_tsr() {
    setvect(0x08, old_timer_handler);    // 恢复原向量（退出前必须！）
}

1

中断频率 = 1193182 / 分频值

1
2
3
4
5
6
7
8
9

#include <dos.h>

void set_timer_frequency(unsigned int freq_hz) {
    unsigned int divisor = 1193182L / freq_hz;
    
 outportb(0x43, 0x36);   // 控制字：通道0，先写低字节后高字节，模式3
    outportb(0x40, divisor & 0xFF);    // 分频值低字节
    outportb(0x40, (divisor >> 8) & 0xFF); // 分频值高字节
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <dos.h>

#define TICK_RATIO  (10000 / 18) // 新频率相对于18.2Hz的倍数（近似）

void interrupt (*old_timer_handler)();
volatile unsigned long tick_counter = 0;
volatile long accumulator = 0;

void interrupt new_timer_handler() {
    // === 高频实时任务（每次都执行）===
    do_interpolation_step();
    output_servo_pulse();
    
    tick_counter++;
    
    // === 低频任务：模拟原始18.2Hz节拍，维持DOS时钟正常 ===
    accumulator += 18;
    if (accumulator >= 10000) {
        accumulator -= 10000;
 (*old_timer_handler)();  // 触发原BIOS时钟处理
 } else {
        outportb(0x20, 0x20);    // 手动向 8259 PIC 发送 EOI（中断结束）信号
    }
}

1
2

8259 PIC 端口 0x20：主控制器命令端口
写入 0x20 = EOI（非特定结束）命令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

volatile int pulse_request_flag = 0;
volatile long position_x = 0, position_y = 0;

void interrupt new_timer_handler() {
    // 中断内：只做最简单的硬件操作
    if (need_pulse()) {
        outportb(PULSE_PORT, PULSE_HIGH);
        pulse_request_flag = 1;  // 标记，交给主循环处理
    }
    outportb(0x20, 0x20);  // EOI
}

int main() {
    install_tsr();
 
    while (1) {
        if (pulse_request_flag) {
            pulse_request_flag = 0;
       // 复杂的插补计算、DOS文件I/O、屏幕显示等都放这里
     calculate_next_interpolation_point();
            update_display();
        }
    }
}

1
2
3
4
5
6
7
8
9

#include <dos.h>

long read_position_safely() {
    long result;
    disable();       // CLI 指令，关中断
    result = position_x;     // 32位读取，非原子操作，需要保护
    enable();    // STI 指令，开中断
    return result;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#define ISR_STACK_SIZE 1024
unsigned char isr_stack[ISR_STACK_SIZE];
unsigned int saved_ss, saved_sp;

void interrupt new_timer_handler() {
    asm {
        mov saved_ss, ss
        mov saved_sp, sp
        mov ax, seg isr_stack
        mov ss, ax
        mov sp, offset isr_stack + ISR_STACK_SIZE
    }
    
    // === 中断处理逻辑，现在用的是独立栈 ===
    do_interpolation_step();
 
    asm {
    mov ss, saved_ss
      mov sp, saved_sp
    }
    
    outportb(0x20, 0x20);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include <dos.h>
#include <stdio.h>

/* ---- 全局状态（中断与主循环共享）---- */
volatile long current_x = 0, current_y = 0;
volatile long target_x = 0, target_y = 0;
volatile int running = 1;

void interrupt (*old_timer)();

/* ---- 直线插补的一步（简化的Bresenham思路）---- */
void interrupt timer_isr() {
    static long err = 0;
    long dx = target_x - current_x;
    long dy = target_y - current_y;
    
    if (dx != 0 || dy != 0) {
        // 简化的逐点比较插补算法
        if (labs(dx) > labs(dy)) {
            current_x += (dx > 0) ? 1 : -1;
     outportb(0x300, 0x01);  // X轴脉冲（示例端口）
        } else {
            current_y += (dy > 0) ? 1 : -1;
     outportb(0x300, 0x02);  // Y轴脉冲
 }
    }
    
    outportb(0x20, 0x20);  // EOI
}

void install() {
    old_timer = getvect(0x08);
    
    disable();
    set_timer_frequency(5000);  // 5kHz插补节拍
    setvect(0x08, timer_isr);
    enable();
}

void restore() {
    disable();
 set_timer_frequency(18);    // 恢复标准18.2Hz（约）
    setvect(0x08, old_timer);
    enable();
}

int main() {
    printf("线切割机插补控制器 - TSR 模式启动\n");
    install();
  
    /* 主循环：负责非实时逻辑（G代码解析、显示、通信）*/
 while (running) {
        parse_next_gcode_line();  // 解析下一条加工指令，更新 target_x/y
    update_status_display();
 if (kbhit() && getch() == 27) running = 0;  // ESC 退出
    }
    
    restore();
    printf("已恢复系统定时器，安全退出\n");
    return 0;
}