诚心求教关于软件定时器的写法

可以多设置几个定时标志。先到哪个定时时间，就先置1

加几个简单的延时程序

我试试去。。

好的，去瞧瞧

额，你这个提法没太看懂!能说具体点吗

问题已经解决了void T0_time() interrupt 1{
  TR0=0; //关中断
  ++Time1; //定时1
  ++Time2; //定时2
  ++Time3; //定时3
  ++TimeN; //定时N

  TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  TL0=0x2f;
  TR0=1;  //开中断
}

注意！这是不可取的，胡闹啊！可以中断嵌套，但是不是软件嵌套。而且注意了，尽力不要在中断中操作关定时器，会死机的！

那这样的方法不可取，那中断嵌套怎么写呢？

这个51简单啊，开启对应的优先级。注意啊，51只支持两级嵌套，不是一层一层的嵌套！但是这个和你原来设计有区别，你是为了延长定时时间还是为了计算定时中某个时间段呢！
“可以多设置几个定时标志。先到哪个定时时间，就先置1”。这个人说的对。然后在主程序中扫描。多复杂的程序都可以做，而且没有危险！

可能是你没看过。这个程序我还没发布呢，是我为大家设计的一个51开发板。中的UART程序，包括简单的协议，都可以这么做。

//函数：ISR_UART()
//描述：UART中服
//参数：无
void ISR_UART(void) interrupt 4
{
        if (RI == 1)
        {
                UART_Flag = 1;
                RI = 0;
        }
        else
                TI = 0;  
}



// 文件名称：串口文件
// 实现功能：串口的发送接受极其中断
// 日期：2015-1-1
// 备注：printf实现

#include "System.h"

***it PC_Slave_Bit = P3^5;

volatile unsigned char UART_ReceCount = 0;                        // UART接收计数
unsigned char UART_Buffer[100];                                                                        // UART接收缓存区
unsigned char data CMD_Flag = 0;                                                                // UART_CMD返回值

unsigned char data UARTStateFlag = UARTFlag_PC;        // 主机状态标志，默认与虚拟串口通讯

unsigned char code Waiting[] = {"请等待..."};
unsigned char code No_CMD[] = {"NO CMD"};

// 命令结构体
struct CMD
{
        unsigned char CMD_Num;                                // 命令标号
        unsigned char *CMD_Name;                        // 命令说明
        unsigned char Slave_List;                  // 服务器序列
        unsigned char *CMD_Data;                        // 命令       
};
// 命令参数
struct CMD code PC_CMD[]=
{
        1,// 命令1
        "PWM_Duty_Cycle",
        2,
        "pwm+",
       
        2,// 命令2
        "PWM_Duty_Cycle",
        2,
        "pwm-",
       
        3,// 命令3
        "Demand_Pressure",
        1,
        "dpress",
};

extern void Delay(unsigned int T0, unsigned int T1);

//函数：Uart_Send()
//描述：UART发送数据
//参数：Data        待发送数据
void Uart_Send(unsigned char Data)
{
        SBUF = Data;
        while(TI == 0);
        TI = 0;
}
//函数：Uart_SendBrush()
//描述：UART连续发送数据
//参数：Data        待发送数据
void Uart_SendBrush(unsigned char *Data)
{
        while(*Data != '')
        {
                Uart_Send(*Data);
                Data++;
        }       
}
//函数：Uart_nBrush_Send()
//描述：UART连续发送数据
//参数：Data        待发送数据
static void Uart_nBrush_Send(unsigned char *Data, unsigned char Num)
{
        unsigned char i;
       
        for(i=0; i                 Uart_Send(Data[i]);
}
//函数：UART_PC_CMD()
//描述：UART接受PC命令处理
//参数：return        命令参数
static unsigned char UART_PC_CMD(void)
{
  unsigned char i,j;

  UART_Buffer[UART_ReceCount] = SBUF;                                                                // 接受记录数据
  Uart_Send(UART_Buffer[UART_ReceCount]);                                         // 返回接受信息
  if(UART_Buffer[UART_ReceCount] == 'r')                                                // 请求执行
  {
                UART_ReceCount = 0;                                                                                                                 // 清空数据计数记录
                for(i=0;i<3;i++)                                                                                                                                // 查询命令
                {
                        j = 0;
                        while(PC_CMD[i].CMD_Data[j] != '')
                        {
                                if(PC_CMD[i].CMD_Data[j] != UART_Buffer[j])                               
                                        break;
                                else
                                        j++;
                        }
                        if(j == strlen(PC_CMD[i].CMD_Data))
                        {
                                Uart_SendBrush(Waiting);                                                                                // 命令成功，发送等待响应
                                Uart_Send('r');
                                return PC_CMD[i].CMD_Num;                                                                                // 返回命令标号
                        }                       
                }
                Uart_SendBrush(No_CMD);                                                                                                        // 命令失败，发送命令警告
                Uart_Send('r');
                return 0;
  }
        else if(UART_Buffer[UART_ReceCount] == 'b')                         // 删除上一个字符
        {
                UART_Buffer[UART_ReceCount] = '';
                UART_ReceCount--;
                UART_Buffer[UART_ReceCount] = '';
        }
  else
                UART_ReceCount++;                                                                                                                                // 命令计数自加
  return 0;
}
//函数：UART_Slave_Response()
//描述：UART接受Slave命令处理
//参数：return        1         比对成功
//                                                        0                比对失败
unsigned char UART_Slave_Response(void)
{
  UART_Buffer[UART_ReceCount] = SBUF;                                                        // 接受记录数据
  if(UART_Buffer[UART_ReceCount] == 'r')                                        // 请求执行
                return 1;
        else
                UART_ReceCount++;
        return 0;
}
// 函数：UART()
// 描述：UART中断处理
// 参数：无
void UART(void)
{
        switch(UARTStateFlag)
        {
                case UARTFlag_PC: // 与主机通讯
                        CMD_Flag = UART_PC_CMD();
                        if(CMD_Flag != 0)
                        {
                                // 转换UART对接口，寻找Slave
                                PC_Slave_Bit = 0;
                                Delay(3,3);
                                // 发送地址
                                SM2 = 1;
                                TB8 = 1;
                                RB8 = 0;
                                Uart_Send(PC_CMD[CMD_Flag-1].Slave_List);
                                // 状态切换为等待地址回应
                                UARTStateFlag = UARTFlag_WaitingAddressACK;
                        }
                        break;
                case UARTFlag_WaitingAddressACK:
                        if(SBUF == PC_CMD[CMD_Flag-1].Slave_List) // 核查地址
                        {
                                // 发送命令
                                SM2 = 0;
                                TB8 = 0;
                                RB8 = 0;
                                Uart_SendBrush(PC_CMD[CMD_Flag-1].CMD_Data);
                                Uart_Send('r');
                                // 状态切换为等待命令响应
                                UARTStateFlag = UARTFlag_WaitingCMDACK;
                        }       
                        break;
                case UARTFlag_WaitingCMDACK:
                        if(UART_Slave_Response() == 1)
                        {
                                // 状态切换为与PC通讯
                                UARTStateFlag = UARTFlag_PC;
                                // 命令结束
                                CMD_Flag = 0;
                                // 转换UART对接口，与PC对话
                                PC_Slave_Bit = 1;
                                Delay(3,3);
                                // 回复PC命令响应情况
                                Uart_nBrush_Send(UART_Buffer,UART_ReceCount);
                                Uart_Send('r');
                                UART_ReceCount = 0;
                        }
                default : break;
        }
        UART_Flag = 0;
}

里面包括很多不同标记，和不同标记值的跳转。等我一些时候，把AVR，PIC，430，LPC都全部写完，在给你们一起看。

本帖最后由 gu709108631 于 2015-2-12 22:08 编辑



我想做的是一个定时器可用于软件定时20ms，40ms，60ms等等（我这里没有用其他中断）所以如果写成这样是否可以？关于标志位我也懂一点，好像中断里不能写这么多吧，麻烦指点一二，谢谢
void T0_time() interrupt 1
{
  TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
  TL0=0x2f;
  if(T1==1)  //开关变量                （这里的T1，T2，TN是标志位）
  {
     ++Time1; //定时1
  }
  if(T2==1)  //开关变量
  {
     ++Time2; //定时2
  }
  if(TN==1)  //开关变量
  {
     ++TimeN; //定时N
  }
}

volatile unsigned char Timer_Flag = 0;
unsigned char Timer_Count = 0;
#define Timer_N20MS  1

void T0_time() interrupt 1
{
   TH0=0xf8;   //重装初始值(65535-2000)=63535=0xf82f
   TL0=0x2f;   Timer_Count ++;
   if(Timer_Count == Timer_N20MS )  {
     Timer_Flag  = 1;
     Timer_Count  = 0;
  }
}



通过改不同的 Timer_N20MS 值，到达不同20ms的倍数。

好的，谢谢你，我懂了

客气