title: Simple compression Algorithm in C is not working..any suggestions?
body: <p>I am creating a project in nordic Micro that reads a value from an Analog input termninal an output it into UART. I am now trying to compress the data using  GE Proficy Historian Compression so that only changed data are outputted in the UART. But my code is not working. Outputted data are sometime still redundant.
  The idea of the program is to generate an interrupt every certain amout of time, read the adc value and if its different than previous value, output it to the UART port. 
  the algorithm is explained here 
  <a href="http://www.evsystems.net/files/GE_Historian_Compression_Overview.ppt" rel="nofollow">http://www.evsystems.net/files/GE_Historian_Compression_Overview.ppt</a>
  The main portion of the code that handles the interrupt is as shown below </p>
  
  <pre><code>void ADC_IRQHandler(void)
  {
      /* Clear dataready event */
    NRF_ADC-&gt;EVENTS_END = 0;   
      // write ADC value to UART port 
  
      // Compression Algorithm should occur here
      uint8_t current_Val= NRF_ADC-&gt;RESULT;
      //simple_uart_put(current_evaluation);
  
  
      // Construct error bands around the held point
  
      float U_tolerance = current_Val  + error_tolerance;
      float L_tolerance = current_Val - error_tolerance; // integer type is selected since lower tolerance could be negative
  
      if( first_Run == false)
      {
          float slope = ((current_Val - Archived_Val) / (held_Time - Archived_Time)) ;
          if (slope &gt; U_Slope || slope &gt; L_Slope)
          {
              Archived_Val = current_Val; // update the archived value
              held_Time = 1; // reset held time
              simple_uart_put(current_Val);
              first_Run = true;
              Archived_Val = current_Val;
          }
          else
          {
              float Upper_Slope = (U_tolerance - Archived_Val) /( held_Time - Archived_Time);
              float Lower_Slope  = (L_tolerance - Archived_Val)/(held_Time- Archived_Time);
  
              if(Upper_Slope &lt; U_Slope) // lowest upper slope is always taken as a blanket boundry
              {
                  U_Slope = Upper_Slope;
              }
              if(Lower_Slope &lt; L_Slope)
              {
                  L_Slope = Lower_Slope;
              }
              held_Time += time_increment;
          }
      }
  
      if (first_Run == true) // first held point always outputted
      {
              // calculate the slopes of the two lines 
      float Upper_Slope = (U_tolerance - Start_Up_Val) /( held_Time - Archived_Time);
      float Lower_Slope  = (L_tolerance - Start_Up_Val)/(held_Time- Archived_Time);
  
          // Update Max and Min slopes
  
      if(Upper_Slope &lt; U_Slope) // lowest upper slope is always taken as a blanket boundry
      {
              U_Slope = Upper_Slope;
      }
      if(Lower_Slope &lt; L_Slope)
      {
          L_Slope = Lower_Slope;
      }
  
  
      held_Time += time_increment;
      first_Run = false;
      Archived_Val = current_Val;
      }
  
  }
  </code></pre>
  
  <p>The veriables are defined as follow </p>
  
  <pre><code>&gt; uint32_t error_tolerance = 50; // error tolerance value for swining door algorithm
  uint8_t Start_Up_Val = 100;
  float held_Time = 1;
  int Archived_Time = 0;
  float U_Slope = 2500;
  float L_Slope = 0;
  //float slope;
  uint8_t Archived_Val;
  bool GE_Comp(uint8_t, uint8_t, uint8_t, int);
  bool first_Run = true;
  float time_increment = 0.1;
  </code></pre>