main.c

记录仪

         speed_1min=temp_long/CANSHU;
         time_speed[MINUTE+5]=speed_1min;    //在速度缓冲区的后60个字节写入速度值
         if(speed_15min[number_15m][0]!=OLD_HOUR||speed_15min[number_15m][1]!=OLD_MIN)
             number_15m=(number_15m+1)%15;             //将当前分钟速度存放到15分钟速度数组
         speed_15min[number_15m][0]=OLD_HOUR;
         speed_15min[number_15m][1]=OLD_MIN;
         speed_15min[number_15m][2]=speed_1min;
         for(i=0;i<18;i++)                         //将当前驾驶证号码存放到15分钟速度数组
             speed_15min[number_15m][i+3]=cur_id[i+7];


         dif_pulse=pulse_cur_time-pulse_start_rec; //求出该小时的脉冲数

         index_stp_pls=index_pls_spdbuf;        //将当前脉冲数组下标复制给停车数组下标
         pulse_spd_buf[index_stp_pls]=dif_pulse;//存入脉冲数

         //将速度缓冲区数据复制到总记录区
         ptr_stp_min=ptr_minaero;   //将当前数据指针复制给停车数据指针
         for(j=0;j<65;j++)
         {
             j_temp=time_speed[j];
             P11=0;
             P10=0;
             *ptr_stp_min=j_temp;
             ptr_stp_min++;
             P11=1;
             P10=1;
         }
         P11=1;
         P10=1;
         flag_wr_empty=1;     //未写过数据区标志置1
         if(ptr_stp_min>=0X6B68)
         {
            flag_wr_full=1;    //写满数据区标志置1
            ptr_stp_min=0X1000;     //写满360小时，指针清0
         }

         for(i=0;i<11;i++)                             //所有人的休息时长加上stop_time
         {
           all_drv_rec[i][10]+=stop_time;
           if(all_drv_rec[i][10]>tcxxsj)   all_drv_rec[i][10]=tcxxsj+10;
         }
         stop_time=0;                                  //stop_time清0
         all_drv_rec[driver_cur][10]=0;                //当前驾驶员的休息时长清0

         for(i=0;i<5;i++)                              //记下当前驾驶员的停车时间
           all_drv_rec[driver_cur][i+5]=temp_date[i];  //temp_date[]已在停车时由中断程序用Wr_Time()函数写入

         Get_15mSpeed(number_15m);  //将15分钟速度按照时间先后排序

         Get_20sdata();             //根据停车前20秒脉冲数算出相应速度，按照时间先后排列，并加上停车时间

         //根据FL_OVERTIME是否为1，判断该记录是否为超时记录
         if(FL_OVERTIME==1)     //超时
         {
            Save_Ovrec();        //将上一条记录的起始、结束时间和驾驶员存入超时记录区
            num_ovrec=(num_ovrec+1)%21;
         }

         FL_OLDRUN=0;           //把当前行驶标志保存
         FL_BACKUPB=FL_BACKUPB&0XFB;
       }

     } //else
     scankey();                //扫描键盘

     P11=1;
     P10=1;
     Clr_WDog();       //清w-dog
  }

}
                                   //------------------------------------------------------------#################
                                   //------------------------------------------------------------#               #
                                   //------------------------------------------------------------#  中断服务程序 #
                                   //------------------------------------------------------------#               #
                                   //------------------------------------------------------------#################


void service_counter1(void) interrupt 3 using 1       //本中断使用using 1,每个中断使用不同的工作寄存器组，本中断为1
{
   bit T1_P11;      //中断程序保护页面地址用
   bit T1_P10;
   //bit FLAG_KGL;      //当前开关量

   ET1=0;          //关中断
   Clr_WDog();       //清w-dog

   T1_P11=P11;      //先保存页面 ,后面结束时恢复
   T1_P10=P10;

   P11=1;             //使页面为3
   P10=1;

   //每次中断必须处理1次
   OLD_YEAR=TNIAN;       //读时钟，并存放至指定地址
   OLD_MONTH=TYUE;
   OLD_DAY=TRI;
   OLD_HOUR=TSHI;
   OLD_MIN=TFEN;
   OLD_SEC=TMIAO;
   if(OLD_MIN!=TFEN)
   {
       OLD_YEAR=TNIAN;       //读时钟，并存放至指定地址
       OLD_MONTH=TYUE;
       OLD_DAY=TRI;
       OLD_HOUR=TSHI;
       OLD_MIN=TFEN;
       OLD_SEC=TMIAO;
   }
   Get_Time();           //将时间由BCD码转化为16进制
   //从计数器0读数
   t1_hp_cur=TH0;                             //读计数器0高位字节
   t1_lp_cur=TL0;                             //读计数器0低位字节
   t1_hp_cur2=TH0;                            //再读1次高字节
   if(t1_hp_cur2!=t1_hp_cur)                 //两次读的结果不相等，则再读1次
   {
      t1_hp_cur=TH0;                             //读计数器0高位字节
      t1_lp_cur=TL0;                             //读计数器0低位字节
   }
   TH0_save=t1_hp_cur;
   TL0_save=t1_lp_cur;

   //计算当前脉冲数
   t1_pls_cur=t1_hp_cur;               //当计数器的高字节
   t1_pls_cur<<=8;
   t1_pls_cur+=t1_lp_cur;              //加上计数器的低字节

   t1_long_temp=hi_counter;            //将脉冲量的高字节存入t1_long_temp
   t1_long_temp<<=16;                  //t1_long_temp左移2个字节
   t1_pls_cur+=t1_long_temp;           //再加上t1_long_temp左移2个字节，得到当前的脉冲数

   //循环存放26秒脉冲
   index_26s=(index_26s+1)%624;
   sec_cur_data[index_26s]=t1_hp_cur;
   index_26s++;
   sec_cur_data[index_26s]=t1_lp_cur;
   index_26s++;
   sec_cur_data[index_26s]=KAIGUANLIANG;

   sec_index=index_26s;

   t1_1s=(t1_1s+1)%8;         //计秒标志，加到8表示1秒

   t1_temp1=KAIGUANLIANG;  //读取开关量状态
   t1_temp1=t1_temp1&0X3F; //取低6位
   if(t1_temp1!=old_kgl)   //如果开关量状态发生变化
   {
       P11=0;
       P10=1;

       KGL[index_KGL][0]=OLD_YEAR;       //记下当时的年
       KGL[index_KGL][1]=OLD_MONTH;      //记下当时的月
       KGL[index_KGL][2]=OLD_DAY;        //记下当时的日
       KGL[index_KGL][3]=OLD_HOUR;       //记下当时的时
       KGL[index_KGL][4]=OLD_MIN;        //记下当时的分
       KGL[index_KGL][5]=OLD_SEC;        //记下当时的秒

       KGL[index_KGL][6]=t1_temp1;       //记下当时的状态
       index_KGL++;
       if(index_KGL>=4000)    index_KGL=0;

       P11=1;
       P10=1;
       old_kgl=t1_temp1;                 //将当前开关量状态保存
   }

   //每秒钟处理1次
   if(t1_1s==7)
   {
     Clr_WDog();       //清w-dog
     Clk_Init();             //每秒钟初始化时钟1次

     FL_RDSEC=1;           //允许读时间

     //计算该秒内的脉冲差，每秒大于1个且连续5秒，表示行驶
     t1_dif_pls_1s=t1_pls_cur-t1_pls_1sb;//得到1秒内的脉冲数
     t1_pls_1sb=t1_pls_cur;              //将当前脉冲数保存，留待下1秒钟用

     //计算5秒内的脉冲差
     t1_dif_pls_2s=t1_pls_cur-pulse_2s[index_pulse_2s];  //得到2秒内的脉冲数
     pulse_2s[index_pulse_2s]=t1_pls_cur;                //将当前脉冲数保存
     index_pulse_2s=(index_pulse_2s+1)%2;                //下标加1



     if(t1_dif_pls_1s>1)
     {
        t1_start_add++;              //如果该秒内的脉冲数大于1，t1_start_add自加1
        t1_end_add=0;                //t1_end_add清零
     }
     else
     {
        t1_end_add++;               //如果该秒内的脉冲数小于或等于于1，t1_end_add自加1
        t1_start_add=0;             //t1_start_add清零
     }
     if(t1_start_add>=5)            //连续5秒，每秒脉冲数都大于1
     {
        t1_start_add=4;              //t1_start_add=4，这样当下一秒的脉冲数大于1个时，t1_start_add=5

        if(!FL_RUN)
        {
           FL_RUN=1;                      //行驶标志置1
           FL_BACKUPB=FL_BACKUPB|0X08;    //保存行驶标志
        }
     }
     if(t1_end_add>=5)              //连续5秒，每秒脉冲数都小于或等于1
     {
         t1_end_add=4;                //t1_end_add=4，这样当下一秒的脉冲数小于或等于1个时，t1_end_add=5

         if(FL_RUN)
         {
            FL_RUN=0;                      //行驶标志置0
            FL_BACKUPB=FL_BACKUPB&0XF7;    //保存行驶标志
            Copy_20sdata();//如果车是刚停，将20秒数据复制到临时数组
            Wr_Time();                       //记下停车时间
         }
     }
   }


   if(t1_1s==6)
   {
     if((OLD_SEC==0x0)&&(OLD_MIN==0x0))    //1小时执行1次，当“秒”为0，且“分”也为0时
     {
         Clr_WDog();       //清w-dog
         if(flag_have_run==1)
         {
             for(t1_temp2=0;t1_temp2<65;t1_temp2++)         //将速度缓冲区速度值复制到总记录区
             {
                 t1_temp1=time_speed[t1_temp2];
                 P11=0;
                 P10=0;
                 *ptr_minaero=t1_temp1;
                 ptr_minaero++;

                 P11=1;
                 P10=1;
             }
             P11=1;
             P10=1;
             flag_wr_empty=1;     //未写过数据区标志置1
             if(ptr_minaero>=0X6B68)
             {
                 flag_wr_full=1;    //写满数据区标志置1
                 ptr_minaero=0X1000;     //写满数据区，指针清0
             }
             addr_ptr_minaero=ptr_minaero;

             pulse_end_rec=t1_pls_cur;            //将当前脉冲数作为已经过去的1小时的结束脉冲数
             dif_pulse=pulse_end_rec-pulse_start_rec; //求出已经过去的1小时内的脉冲数
             pulse_spd_buf[index_pls_spdbuf]=dif_pulse;//存入脉冲数
             index_pls_spdbuf=(index_pls_spdbuf+1)%360;

             flag_have_run=0;
         }

         //开始新的1小时记录
         time_speed[0]=OLD_YEAR;
         time_speed[1]=OLD_MONTH;
         time_speed[2]=OLD_DAY;
         time_speed[3]=OLD_HOUR;
         time_speed[4]=0;
         for(t1_temp1=5;t1_temp1<65;t1_temp1++)
         {
           Clr_WDog();       //清w-dog
           time_speed[t1_temp1]=0;       //将速度值清0
         }
         pulse_start_rec=t1_pls_cur;          //将当前脉冲数作为正开始的1小时的起始脉冲数

     }

     if((OLD_SEC==0x02)&&(OLD_MIN==0x02)&&(OLD_HOUR==0x0))    //每天执行1次，当“秒”为2，“分”为2，且“时”为0
     {
         Clr_WDog();       //清w-dog
         Write_Curday();
     }

     if(OLD_SEC==0x59)   //每分钟执行1次，当秒为59时，计算该1分钟内的速度
     {
       Clr_WDog();       //清w-dog
       t1_dif_pls_1m=t1_pls_cur-t1_pls_1mb;  //得到1分钟内的脉冲数
       t1_pls_1mb=t1_pls_cur;                //将当前脉冲数保存，留待下1分钟用


       /* 特征系数为CANSHU转/公里，每转有8个脉冲，则得到(8*CANSHU)脉冲/公里，现假设已测得1分钟内共计有C个脉冲，
       则60C为每小时的脉冲数， （60C/(8*CANSHU)）公里/小时即为该分钟内的速度。 */

       t1_long_temp=t1_dif_pls_1m;
       t1_long_temp*=60;
       t1_long_temp>>=3;
       t1_long_temp=t1_long_temp+CANSHU/2;            //为纠正成4舍5入，人为加上（CANSHU/2）
       speed_1min=t1_long_temp/CANSHU;

       time_speed[MINUTE+5]=speed_1min;                //在速度缓冲区后60个字节写入速度值

       if(speed_15min[number_15m][0]!=OLD_HOUR||speed_15min[number_15m][1]!=OLD_MIN)
           number_15m=(number_15m+1)%15;             //将当前分钟速度存放到15分钟速度数组
       speed_15min[number_15m][0]=OLD_HOUR;
       speed_15min[number_15m][1]=OLD_MIN;
       speed_15min[number_15m][2]=speed_1min;
       for(t1_temp1=0;t1_temp1<18;t1_temp1++)                         //将当前驾驶证号码存放到15分钟速度数组
       {
           Clr_WDog();       //清w-dog
           speed_15min[number_15m][t1_temp1+3]=cur_id[t1_temp1+7];
       }
       if(FL_RUN)            //1分钟到，且汽车行驶中，1分钟标志置1
       {
           FL_1M=1;           //1分钟到
           FL_BACKUPB=FL_BACKUPB|0X01;
       }
       else
       {
           //给停车时间计数
           stop_time++;                      //stop_time自加1
           if(stop_time>tcxxsj)  stop_time=tcxxsj+10;
       }

     }
   }

   if(t1_1s==5)
   {
       if(OLD_SEC==0)   //每分钟执行1次，当秒为0时，判断是否超速
       {
           if (FL1_OVERSPEED)    ctr_chaosu=5;
           else    ctr_chaosu=0;
       }
       if(ctr_chaosu>0)
       {
           P15=1;    //超速蜂鸣器鸣叫
           ctr_chaosu--;
       }
       else    P15=0;    //超速蜂鸣器静音

       if(OLD_SEC==0x30)   //每分钟执行1次，当秒为30时，判断是否超时
       {
           if (FL_OVERTIME)    ctr_chaoshi=5;
           else    ctr_chaoshi=0;
       }
       if(ctr_chaoshi>0)
       {
           P16=1;    //超时蜂鸣器鸣叫
           ctr_chaoshi--;
       }
       else    P16=0;    //超时蜂鸣器静音

   }


   P11=T1_P11;     //恢复页面
   P10=T1_P10;
   ET1=1;
}


//计数器0溢出产生高字节的中断程序
void service_counter0(void) interrupt 1 using 2
{
   TH0=0;
   TL0=0;
   Clr_WDog();       //清w-dog
   hi_counter++;
   if(hi_counter==0) hi_pls_end++;

}