1 void PISV10_CalculateRedSignalWatingTimeOfSignal()
   2 {
   3     UNIT8 ucSum        = 0;
   4     UNIT8 ucRemain     = 0;
   5     UNIT8 ucIndex      = 0;
   6     UNIT8 ucFlag       = TRUE;
   7     UNIT8 ucTotalCount = 0;
   8     UNIT8 ucRedAcc     = 0;
   9     UNIT8 ucCurSig     = 0, ucNextSig = 0;  
  10     UNIT8 ucRemainFlag = 0;
  11 
  12 
  13 
  14     /////////////////////////////////////////////////////
  15     // A Signal 
  16     /////////////////////////////////////////////////////
  17     // calcurate the reamining time of Green Time of an signal map
  18     for (ucIndex = 0; ucIndex < ucASignalNum; ucIndex++) 
  19     {
  20         ucSum += ucASignalGreenTime[ucIndex];
  21         if (ucCurFreq <= ucSum)
  22         {
  23             if (ucCurFreq == ucSum)
  24             {
  25                 ucRemainFlag = 1;
  26             }
  27             ucRemain = ucSum - ucCurFreq;
  28             ucCurSig = ucIndex; // Set Operating Singal;
  29             break;
  30         }
  31     }
  32 
  33 
  34     // calculate the red time
  35     ucTotalCount = ucASignalNum;
  36     ucRedAcc = ucRemain;
  37     if (ucCurSig == ucTotalCount)
  38     {
  39         ucNextSig = 0;
  40     }
  41     else
  42     {
  43         ucNextSig = ucCurSig +1;
  44     }
  45 
  46 
  47     do {
  48         // find the first signal of red signal
  49 
  50 
  51         if (ucNextSig == ucCurSig)
  52         {
  53             if (ucRemainFlag == 1)
  54             {
  55                 ucARedWaitingTime[ucNextSig] = ucRedAcc;
  56             }
  57             else
  58             {
  59                 ucARedWaitingTime[ucNextSig] = 0; 
  60             }
  61             ucFlag = FALSE;
  62         }
  63         else
  64         {
  65             ucARedWaitingTime[ucNextSig] = ucRedAcc;
  66             ucRedAcc += ucASignalGreenTime[ucNextSig];
  67         }
  68 
  69 
  70         ucNextSig++;
  71         if (ucNextSig >= ucASignalNum)
  72         {
  73             ucNextSig = 0;
  74         }
  75     } while (ucFlag == TRUE);
  76 
  77 
  78     /////////////////////////////////////////////////////
  79     // B Signal
  80     /////////////////////////////////////////////////////
  81     ucSum        = 0;
  82     ucFlag       = TRUE;     
  83     ucRemainFlag = 0;           
  84     // calcurate the reamining time of Green Time of an signal map
  85     for (ucIndex = 0; ucIndex < ucBSignalNum; ucIndex++)
  86     {
  87         ucSum += ucBSignalGreenTime[ucIndex];
  88         if (ucCurFreq <= ucSum)
  89         { 
  90             if (ucCurFreq == ucSum)
  91             {
  92                 ucRemainFlag = 1;
  93             }
  94             ucRemain = ucSum - ucCurFreq;
  95             ucCurSig = ucIndex; // Set Operating Singal;
  96             break;
  97         }
  98     }
  99 
 100 
 101     // calculate the red time
 102     ucTotalCount = ucBSignalNum;
 103     ucRedAcc  = ucRemain;
 104     ucNextSig = (ucCurSig != ucTotalCount) ? ucCurSig+1 : 0;
 105 
 106 
 107     do {
 108         // find the first signal of red signal
 109 
 110         if (ucNextSig == ucCurSig)
 111         {
 112             ucBRedWaitingTime[ucNextSig] = (ucRemainFlag == 1) ? ucRedAcc : 0;
 113             ucFlag = FALSE;
 114         }
 115         else
 116         {
 117             ucBRedWaitingTime[ucNextSig] = ucRedAcc;
 118             ucRedAcc += ucBSignalGreenTime[ucNextSig];
 119         }
 120 
 121         ucNextSig = (ucNextSig < ucBSignalNum-1) ? ucNextSig+1 : 0;
 122     } while(ucFlag == TRUE);
 123 }