_edit.c

全自动剥线机（C语言源码＋DOC文档说明）

      indata = *d_hzptr;
      Cr_Inst_Data(flag,indata);
   }
}

/***************************************************************************

NAME:       Number_Chg()

FUNCTION:   This procedure will change the number to the show group element.

INPUTS:     the number and the number show group start address.

OUTPUTS:    NONE

***************************************************************************/
void Number_Chg(uint d_number)
{
   bit floatflag;
   bit err_flag;
   uchar a,b,c,d;
   uchar idata *d_numptr;

   d_numptr = g_numshow;
   if(d_number==CN_MAXWIREL)
   {
     *d_numptr = 0;
      d_numptr++;
     *d_numptr = 0;
      d_numptr++;
     *d_numptr = 0;
      d_numptr++;
     *d_numptr = 0;
      d_numptr++;
     *d_numptr = 1;
      d_numptr++;
     *d_numptr = CN_NWHITE;
      d_numptr++;
     *d_numptr = CN_NWHITE;
   }
   else
   {
      floatflag = FALSE;  /* default is not float number. */
      err_flag = FALSE;   /* default the data is OK. */
      if(d_number>CN_FLOATLIM)
      {
         floatflag = TRUE;
         d_number = d_number - CN_FLOATLIM;  /* the true number*10  */
         if(d_number>CN_MAXWIREL)
         {
            err_flag = TRUE;
         }   	
      }
      if(d_number>CN_MAXWIREL)
      {
         err_flag = TRUE;
      }
      if(FALSE==err_flag)
      {   
         d = d_number/1000;
         d_number = d_number%1000;
         c = d_number/100;
         d_number = d_number%100;
         b = d_number/10;
         a = d_number%10;
         if(floatflag==TRUE)
         {
            if(d==0)
            {
      	       d = CN_NWHITE;
      	       if(c==0)
      	       {
      	          c = CN_NWHITE;
               }
            }
           *d_numptr = a;
            d_numptr++;
           *d_numptr = CN_POINT;
            d_numptr++;
           *d_numptr = b;
            d_numptr++;
           *d_numptr = c;
            d_numptr++;
           *d_numptr = d;
            d_numptr++;
           *d_numptr = CN_NWHITE;
            d_numptr++;
           *d_numptr = CN_NWHITE;
         }
         else
         {
            if(d==0)
            {
      	       d = CN_NWHITE;
      	       if(c==0)
      	       {
      	          c = CN_NWHITE;
      	          if(b==0)
      	          {
      	             b = CN_NWHITE;
      	          }
               }
            }
           *d_numptr = CN_NWHITE;
            d_numptr++;
           *d_numptr = CN_NWHITE;
            d_numptr++;
           *d_numptr = a;
            d_numptr++;
           *d_numptr = b;
            d_numptr++;
           *d_numptr = c;
            d_numptr++;
           *d_numptr = d;
            d_numptr++;
           *d_numptr = CN_NWHITE;
         }
      }
      else
      {
         d_numptr = g_numshow;
        *d_numptr = CN_QUERY;
         d_numptr++;
        *d_numptr = CN_NWHITE;
         d_numptr++;
        *d_numptr = CN_NWHITE;
         d_numptr++;
        *d_numptr = CN_NWHITE;
         d_numptr++;
        *d_numptr = CN_NWHITE;
         d_numptr++;
        *d_numptr = CN_NWHITE;
         d_numptr++;
        *d_numptr = CN_NWHITE;
      }   
   }
}

/***************************************************************************

NAME:       Start_Lastchg()

FUNCTION:   This procedure will set the start-last value.

INPUTS:     the start value,the last value and the show group start address.

OUTPUTS:    NONE

***************************************************************************/
void Start_Lastchg(uchar d_dot)
{
   uchar a,b,c;
   uint d_startval;
   uint d_lastval;
   uchar idata *d_numptr;

   d_numptr = g_numshow;
   d_startval = g_uintreg0;
   d_lastval = g_uintreg1;
   c = d_startval/100;
   d_startval = d_startval%100;
   b = d_startval/10;
   a = d_startval%10;
   if(c==0)
   {
      c = CN_NWHITE;
      if(b==0)
      {
         b = CN_NWHITE;
      }
   }
   d_numptr = d_numptr+6; /* point to the max bit. */
  *d_numptr = c;
   d_numptr--;
  *d_numptr = b;
   d_numptr--;
  *d_numptr = a;
   if(d_dot==CN_DOTSHOW || d_dot==CN_LASTSHOW)
   {
      d_numptr--;
     *d_numptr = CN_BUSYF;
      if(d_dot==CN_LASTSHOW)
      {
      	 c = d_lastval/100;
         d_lastval = d_lastval%100;
         b = d_lastval/10;
         a = d_lastval%10;
      	 if(c==0)
      	 {
      	    c=b;
      	    b=a;
      	    a=CN_NWHITE;
            if(c==0)
            {
               c=b;
               b=CN_NWHITE;
            }
         }
         d_numptr--;
        *d_numptr = c;
         d_numptr--;
        *d_numptr = b;
         d_numptr--;
        *d_numptr = a;
      }
      else
      {
      	 for(a=0;a<3;a++)
      	 {
            d_numptr--;
           *d_numptr = CN_NWHITE;
         }
      }
   }
   else
   {
      for(a=0;a<4;a++)
      {
         d_numptr--;
        *d_numptr = CN_NWHITE;
      }
   }
}

/***************************************************************************

NAME:       Signal_Show()

FUNCTION:   This procedure will show the signal.

INPUTS:     item counter,signal type.

OUTPUTS:    NONE

***************************************************************************/
void Signal_Show(uchar d_itemcnter,uchar d_signtype)
{
   uchar code *d_numptr;
   uchar i;
   uchar indata;
   bit flag;

   if(d_itemcnter%2==0) /* the left side number. i.e. 0,2,4,6 item number  */
   {AD_CR_A2 = 0; AD_CR_A1 = 1;}
   else                 /* the right side number. i.e. 1,3,5,7 item number */
   {AD_CR_A2 = 1; AD_CR_A1 = 0;}
   flag = CN_CR_IN;
   indata = CN_CR_XSTA+ADMD_X[d_itemcnter];
   Cr_Inst_Data(flag,indata);  /* write the x start address. */
   indata = CN_CR_YSTA+ADMD_Y[d_itemcnter];
   Cr_Inst_Data(flag,indata);  /* write the y start address. */
   d_numptr=&ADNUMLIBUP[ADNUC[d_signtype]];
   for(i=0;i<7;i++)
   {
      flag = CN_CR_DA;
      indata = *d_numptr;
      Cr_Inst_Data(flag,indata);
      d_numptr++;
   }
   flag = CN_CR_IN;
   indata = CN_CR_XSTA+ADMD_X[d_itemcnter]+1;
   Cr_Inst_Data(flag,indata);  /* write the x start address. */
   indata = CN_CR_YSTA+ADMD_Y[d_itemcnter];
   Cr_Inst_Data(flag,indata);  /* write the y start address. */
   d_numptr=&ADNUMLIBDOWN[ADNUC[d_signtype]];
   for(i=0;i<7;i++)
   {
      flag = CN_CR_DA;
      indata = *d_numptr;
      Cr_Inst_Data(flag,indata);
      d_numptr++;
   }
}

/***************************************************************************

NAME:       Current_Progparam()

FUNCTION:   This procedure will get the current program parameter

INPUTS:     current program number

OUTPUTS:    None

***************************************************************************/
void Current_Progparam(uint d_prognum)
{	
   idata uint   d_uintreg0; 
   uchar xdata *d_char_ptr; 
   uint  xdata *d_uint_ptr;
   idata ulong  d_ulongreg0;
   idata uchar  i; 
   bit          d_dotflag; 
   
   d_char_ptr = (uchar xdata *)AD_CURPROG;
   if(d_prognum>=CN_COMPROG)
   {
      g_char_ptr = (uchar xdata *)(AD_MIDSRAM+(d_prognum-CN_COMPROG)*CN_MIDBYTE);
      for(i=0;i<CN_MIDBYTE;i++)
      {
        *d_char_ptr = *g_char_ptr;
         d_char_ptr++;
         g_char_ptr++;
      }
      g_uint_ptr = (uint xdata *)(AD_CURPROG+AD_WIRELONG);
      for(i=0;i<10;i++)
      {
      	 if(i==5)
      	 {
      	    g_uint_ptr = (uint xdata *)(AD_CURPROG+AD_MIDSTRIP0);
      	 }   	
      	 d_dotflag = FALSE; /* default is not the float. */
         d_uintreg0 = *g_uint_ptr;
         if(d_uintreg0>CN_FLOATLIM)
         {
            d_dotflag = TRUE;	
            d_uintreg0 = d_uintreg0-CN_FLOATLIM;
         }
         d_ulongreg0 = d_uintreg0;
         d_ulongreg0 = d_ulongreg0*CN_UPCOEFF;
         if(d_dotflag==FALSE)  /* no float. */
         {
            if((d_ulongreg0%CN_DOWNCOEFF)>(CN_DOWNCOEFF/2))	
            { d_ulongreg0 = d_ulongreg0/CN_DOWNCOEFF+1; }
            else
            { d_ulongreg0 = d_ulongreg0/CN_DOWNCOEFF; }
         }
         else                  /* float.    */
         {
            d_uintreg0 = CN_DOWNCOEFF*10;	
            if((d_ulongreg0%d_uintreg0)>(d_uintreg0/2))	
            { d_ulongreg0 = d_ulongreg0/(CN_DOWNCOEFF*10)+1; }
            else
            { d_ulongreg0 = d_ulongreg0/(CN_DOWNCOEFF*10); } 	
         }
        *g_uint_ptr = (uint)(d_ulongreg0);
         g_uint_ptr++;  /* point to the next uint. */        
      }
      d_uint_ptr = (uint xdata *)AD_TEMPMID;
      for(i=0;i<4;i++)
      {
        *d_uint_ptr = 0;
         d_uint_ptr++;
      }
      g_uint_ptr = (uint xdata *)(AD_CURPROG+AD_MIDSTRIP0);
      d_uint_ptr = (uint xdata *)AD_TEMPMID;
      for(i=0;i<4;i++)  
      {
         d_uintreg0 = *g_uint_ptr;
         if(d_uintreg0!=0)
         {
            *d_uint_ptr = d_uintreg0;
             d_uint_ptr++;
         }    
         g_uint_ptr++;
      }
      /* compositor to ensure the middle strip value in the front. */
      g_uint_ptr = (uint xdata *)(AD_CURPROG+AD_MIDSTRIP0);
      d_uint_ptr = (uint xdata *)AD_TEMPMID;      		
      for(i=0;i<4;i++)
      {
         d_uintreg0 = *d_uint_ptr;
        *g_uint_ptr = d_uintreg0;
         d_uint_ptr++;
         g_uint_ptr++;
      }   
   }
   else
   {
      g_char_ptr = (uchar xdata *)(AD_PROGRAM+d_prognum*CN_COMBYTE);	 
      for(i=0;i<CN_COMBYTE;i++)
      {
        *d_char_ptr = *g_char_ptr;
         d_char_ptr++;
         g_char_ptr++;
      }
      g_uint_ptr = (uint xdata *)(AD_CURPROG+AD_WIRELONG);
      for(i=0;i<5;i++)
      {
         d_dotflag = FALSE; /* default is not the float. */
         d_uintreg0 = *g_uint_ptr;
         if(d_uintreg0>CN_FLOATLIM)
         {
            d_dotflag = TRUE;	
            d_uintreg0 = d_uintreg0-CN_FLOATLIM;
         }
         d_ulongreg0 = d_uintreg0;
         d_ulongreg0 = d_ulongreg0*CN_UPCOEFF;
         if(d_dotflag==FALSE)  /* no float. */
         {
            if((d_ulongreg0%CN_DOWNCOEFF)>(CN_DOWNCOEFF/2))	
            { d_ulongreg0 = d_ulongreg0/CN_DOWNCOEFF+1; }
            else
            { d_ulongreg0 = d_ulongreg0/CN_DOWNCOEFF; }
         }
         else                  /* float.    */
         {
            d_uintreg0 = CN_DOWNCOEFF*10;	
            if((d_ulongreg0%d_uintreg0)>(d_uintreg0/2))	
            { d_ulongreg0 = d_ulongreg0/(CN_DOWNCOEFF*10)+1; }
            else
            { d_ulongreg0 = d_ulongreg0/(CN_DOWNCOEFF*10); } 	
         }
        *g_uint_ptr = (uint)(d_ulongreg0);
         g_uint_ptr++;  /* point to the next uint. */        
      }    
   }
}

/***************************************************************************

NAME:       Set_Shortflag()

FUNCTION:   This procedure will check and assure if set the short wire flag.

INPUTS:     NONE

OUTPUTS:    NONE

***************************************************************************/
void Set_Shortflag()
{
   idata uint d_uintreg0;
   uint  xdata *d_uint_ptr;

   g_currentisshort = FALSE; /* default is not the short wire mode. */
   d_uint_ptr = (uint xdata *)(AD_CURPROG+AD_WIRELONG);
   d_uintreg0 = *d_uint_ptr;
   d_uint_ptr = (uint xdata *)(AD_CURPROG+AD_WIREHEAD);
   if(d_uintreg0>=(*d_uint_ptr))
   { d_uintreg0 = d_uintreg0-*d_uint_ptr; }  /* wirelong-wirehead */
   else
   { d_uintreg0 = 0; } 
   d_uint_ptr = (uint xdata *)(AD_CURPROG+AD_WIRERAIL);
   if(d_uintreg0>=(*d_uint_ptr))
   { d_uintreg0 = d_uintreg0-*d_uint_ptr; }  /* wirelong-wirehead-wirerail */
   else
   { d_uintreg0 = 0; } 
   if(d_uintreg0<=CN_SHORTPULSE)
   {
      Signal_Show(2,CN_SHORT); /* show the short wire flag. */
      g_currentisshort = TRUE;