//Check for resistor
void CheckResistor(void)
{
  Resistor_Type               *Resistor;         //Pointer to resistor
  unsigned long               Value1;            //Resistance of measurement #1
  unsigned long               Value2;            //Resistance of measurement #2
  unsigned long               Value;             //Resistance value
  unsigned long               Temp;              //Temp. value
  signed char                 Scale;             //Resistance scale
  signed char                 Scale2;            //Resistance scale
  byte                        n;                 //Counter
  //Voltages
  unsigned int                U_Rl_H;            //Voltage #1
  unsigned int                U_Ri_L;            //Voltage #2
  unsigned int                U_Rl_L;            //Voltage #3
  unsigned int                U_Ri_H;            //Voltage #4
  unsigned int                U_Rh_H;            //Voltage #5
  unsigned int                U_Rh_L;            //Voltage #6
  wdt_reset();                                   //Reset watchdog
  /*
     Resistor measurement
      - Set up a voltage divider with well known probe resistors and
        measure the voltage at the DUT.
      - For low resistance consider the internal resistors of the µC
        for pulling up/down.
      - Calculate resistance via the total current and the voltage
        at the DUT.
      - We could also use the voltage divider rule:
        (Ra / Rb) = (Ua / Ub) -> Ra = Rb * (Ua / Ub)
     check if we got a resistor
      - A resistor has the same resistance in both directions.
      - We measure both directions with both probe resistors.
  */
  //We assume: resistor between probe-1 and probe-2, set probes: Gnd -- probe-2 / probe-1 -- Rl -- Vcc
  SetADCLow();                                   //Set ADC port low low
  ADC_DDR = Probes.ADC_2;                        //Pull down probe-2 directly
  R_DDR = Probes.Rl_1;                           //Enable Rl for probe-1
  R_PORT = Probes.Rl_1;                          //Pull up probe-1 via Rl
  U_Ri_L = ReadU_5ms(Probes.Pin_2);              //Get voltage at internal R of µC
  U_Rl_H = ReadU(Probes.Pin_1);                  //Get voltage at Rl pulled up
  /*

	//Check for resistor
void CheckResistor(void)
{
  Resistor_Type               *Resistor;         //Pointer to resistor
  unsigned long               Value1;            //Resistance of measurement #1
  unsigned long               Value2;            //Resistance of measurement #2
  unsigned long               Value;             //Resistance value
  unsigned long               Temp;              //Temp. value
  signed char                 Scale;             //Resistance scale
  signed char                 Scale2;            //Resistance scale
  byte                        n;                 //Counter
  //Voltages
  unsigned int                U_Rl_H;            //Voltage #1
  unsigned int                U_Ri_L;            //Voltage #2
  unsigned int                U_Rl_L;            //Voltage #3
  unsigned int                U_Ri_H;            //Voltage #4
  unsigned int                U_Rh_H;            //Voltage #5
  unsigned int                U_Rh_L;            //Voltage #6
  wdt_reset();                                   //Reset watchdog
  /*
     Resistor measurement
      - Set up a voltage divider with well known probe resistors and
        measure the voltage at the DUT.
      - For low resistance consider the internal resistors of the µC
        for pulling up/down.
      - Calculate resistance via the total current and the voltage
        at the DUT.
      - We could also use the voltage divider rule:
        (Ra / Rb) = (Ua / Ub) -> Ra = Rb * (Ua / Ub)

     check if we got a resistor
      - A resistor has the same resistance in both directions.
      - We measure both directions with both probe resistors.
  */
  //We assume: resistor between probe-1 and probe-2, set probes: Gnd -- probe-2 / probe-1 -- Rl -- Vcc
  SetADCLow();                                   //Set ADC port low low
  ADC_DDR = Probes.ADC_2;                        //Pull down probe-2 directly
  R_DDR = Probes.Rl_1;                           //Enable Rl for probe-1
  R_PORT = Probes.Rl_1;                          //Pull up probe-1 via Rl
  U_Ri_L = ReadU_5ms(Probes.Pin_2);              //Get voltage at internal R of µC
  U_Rl_H = ReadU(Probes.Pin_1);                  //Get voltage at Rl pulled up
  /*

 /*
     Calculate capacitance
      - use factor from pre-calculated LargeCap_table
      - ignore Config.CapZero since it's in the pF range
  */
  if (Flag == 3)
  {
    Scale = -9;                                  //Factor is scaled to nF
    //Get interpolated factor from table 
    Raw = GetFactor(U_Cap + U_Drop, TABLE_LARGE_CAP);
    Raw *= Pulses;                               //C = pulses * factor 
    if (Mode & FLAG_10MS) Raw *= 10;             // *10 for 10ms charging pulses 
    if (Raw > UINT32_MAX / 1000)                 //Scale down if C >4.3mF 
    {
      Raw /= 1000;                               //Scale down by 10^3 
      Scale += 3;                                //Add 3 to the exponent 
    }
    Value = Raw;                                 //Copy raw value 
    //It seems that we got a systematic error
    Value *= 100;
    if (Mode & FLAG_10MS) Value /= 109;          //-9% for large cap 
    else Value /= 104;                           //-4% for mid cap 
    //Copy data
    Cap->A = Probes.Pin_2;                       //Pull-down probe pin 
    Cap->B = Probes.Pin_1;                       //Pull-up probe pin 
    Cap->Scale = Scale;                          //-9 or -6 
    Cap->Raw = Raw;
    Cap->Value = Value;                          //Max. 4.3*10^6nF or 100*10^3µF
  }
  return Flag;
}
//Measure cap <4.7µF between two probe pins
byte SmallCap(Capacitor_Type *Cap)
{
  byte                        Flag = 3;          //Return value 
  byte                        TempByte;          //Temp. value 
  signed char                 Scale;             //Capacitance scale 
  unsigned int                Ticks;             //Timer counter 
  unsigned int                Ticks2;            //Timer overflow counter 
  unsigned int                U_c;               //Voltage of capacitor 
  unsigned long               Raw;               //Raw capacitance value 
  unsigned long               Value;             //Corrected capacitance value
  /*
     Measurement method used for small caps < 50uF:
     We need a much better resolution for the time measurement. Therefore we
     use the µCs internal 16-bit counter and analog comparator. The counter
     inceases until the comparator detects that the voltage of the DUT is as
     high as the internal bandgap reference. To support the higher time
     resolution we use the Rh probe resistor for charging.
   
     Remark:
     The analog comparator has an Input Leakage Current of -50nA up to 50nA 
     at Vcc/2. The Input Offset is <10mV at Vcc/2.
  */
  Ticks2 = 0;                                    //Reset timer overflow counter
  //Init hardware, prepare probes
  DischargeProbes();                             //Try to discharge probes
  if (Check.Found == COMP_ERROR) return 0;       //Skip on error
  //Set probes: Gnd -- all probes / Gnd -- Rh -- probe-1
  R_PORT = 0;                                    //Set resistor port to low
  //Set ADC probe pins to output mode
  ADC_DDR = (1 << TP1) | (1 << TP2) | (1 << TP3);
  SetADCLow();                                   //Set ADC port to low 
  R_DDR = Probes.Rh_1;                           //Pull-down probe-1 via Rh 
  //Setup analog comparator
  ADCSRB = (1 << ACME);                          //Use ADC multiplexer as negative input 
  ACSR =  (1 << ACBG) | (1 << ACIC);             //Use bandgap as positive input, trigger timer1 
  ADMUX = (1 << REFS0) | Probes.Pin_1;           //Switch ADC multiplexer to probe 1 and set AREF to Vcc
  ADCSRA = ADC_CLOCK_DIV;                        //Disable ADC, but keep clock dividers
  waitus(200);
  //Setup timer
  TCCR1A = 0;                                    //Set default mode 
  TCCR1B = 0;                                    //Set more timer modes 
  //Timer stopped, falling edge detection, noise canceler disabled
  TCNT1 = 0;                                     //Set Counter1 to 0
  //Clear all flags (input capture, compare A & B, overflow
  TIFR1 = (1 << ICF1) | (1 << OCF1B) | (1 << OCF1A) | (1 << TOV1);
  R_PORT = Probes.Rh_1;                          //Pull-up probe-1 via Rh                                     
  //Enable timer
  if (Check.Found == COMP_FET)
  {
    //Keep all probe pins pulled down but probe-1
    TempByte = (((1 << TP1) | (1 << TP2) | (1 << TP3)) & ~(1 << Probes.Pin_1));    
  }
  else
  {
    TempByte = Probes.ADC_2;                     //Keep just probe-1 pulled down
  }
  //Start timer by setting clock prescaler (1/1 clock divider)
  TCCR1B = (1 << CS10);
  ADC_DDR = TempByte;                            //Start charging DUT
  //Timer loop - run until voltage is reached - detect timer overflows
  while (1)
   {
     TempByte = TIFR1;                           //Get timer1 flags
     //End loop if input capture flag is set (= same voltage)
     if (TempByte & (1 << ICF1)) break;
     //Detect timer overflow by checking the overflow flag
     if (TempByte & (1 << TOV1))
     {
       //Happens at 65.536ms for 1MHz or 8.192ms for 8MHz
       TIFR1 = (1 << TOV1);                      //Reset flag
       wdt_reset();                              //Reset watchdog
       Ticks2++;                                 //Increase overflow counter 
       //End loop if charging takes too long (13.1s)
       if (Ticks2 == (CPU_FREQ / 5000)) break;
     }
   }
  //Stop counter
  TCCR1B = 0;                                    //Stop timer 
  TIFR1 = (1 << ICF1);                           //Reset Input Capture flag
  Ticks = ICR1;                                  //Get counter value
  //Disable charging 
  R_DDR = 0;                                     //Set resistor port to HiZ mode
  //Catch missed timer overflow
  if ((TCNT1 > Ticks) && (TempByte & (1 << TOV1)))
  {
    TIFR1 = (1 << TOV1);                         //Reset overflow flag
    Ticks2++;                                    //Increase overflow counter
  }
  //Enable ADC again
  ADCSRA = (1 << ADEN) | (1 << ADIF) | ADC_CLOCK_DIV;
  //Get voltage of DUT
  U_c = ReadU(Probes.Pin_1);                     //Get voltage of cap
  //Start discharging DUT
  R_PORT = 0;                                    //Pull down probe-2 via Rh 
  R_DDR = Probes.Rh_1;                           //Enable Rh for probe-1 again 
  //Skip measurement if charging took too long 
  if (Ticks2 >= (CPU_FREQ / 5000)) Flag = 1;
  //Calculate capacitance (<50uF) - use factor from pre-calculated SmallCap_table
  if (Flag == 3)
  {
    //Combine both counter values
    Raw = (unsigned long)Ticks;                  //Set lower 16 bits 
    Raw |= (unsigned long)Ticks2 << 16;          //Set upper 16 bits 
    if (Raw > 2) Raw -= 2;                       //Subtract processing time overhead 
    Scale = -12;                                 //Default factor is for pF scale 
    if (Raw > (UINT32_MAX / 1000))               //Prevent overflow (4.3*10^6) 
    {
      Raw /= 1000;                               //Scale down by 10^3 
      Scale += 3;                                //Add 3 to the exponent (nF)
    }
    //Multiply with factor from table
    Raw *= GetFactor(Config.U_Bandgap + Config.CompOffset, TABLE_SMALL_CAP);
    //Divide by CPU frequency to get the time and multiply with table scale
    Raw /= (CPU_FREQ / 10000);
    Value = Raw;                                 //Take raw value
    //Take care about zero offset if feasable
    if (Scale == -12)                            //pF scale
    {
      if (Value >= Config.CapZero)               //If value is larger than offset
      {
        Value -= Config.CapZero;                 //Substract offset
      }
      else                                       //If value is smaller than offset
      {
        //We have to prevent a negative value
        Value = 0;                               //Set value to 0
      }
    }
    //Copy data
    Cap->A = Probes.Pin_2;                       //Pull-down probe pin 
    Cap->B = Probes.Pin_1;                       //Pull-up probe pin 
    Cap->Scale = Scale;                          //-12 or -9 
    Cap->Raw = Raw;
    Cap->Value = Value;                          //Max. 5.1*10^6pF or 125*10^3nF 
    /*
       Self-adjust the voltage offset of the analog comparator and internal
       bandgap reference if C is 100nF up to 20µF. The minimum of 100nF
       should keep the voltage stable long enough for the measurements. 
       Changed offsets will be used in next test run.
    */
    if (((Scale == -12) && (Value >= 100000)) ||
        ((Scale == -9) && (Value <= 20000)))
    {
      signed int              Offset;
      signed long             TempLong;
      /*
       *  We can self-adjust the offset of the internal bandgap reference
         by measuring a voltage lower than the bandgap reference, one time
         with the bandgap as reference and a second time with Vcc as
         reference. The common voltage source is the cap we just measured.
      */
       while (ReadU(Probes.Pin_1) > 980)
       {
         //Keep discharging
       }
       R_DDR = 0;                                //Stop discharging 
       Config.AutoScale = 0;                     //Disable auto scaling 
       Ticks = ReadU(Probes.Pin_1);              //U_c with Vcc reference 
       Config.AutoScale = 1;                     //Enable auto scaling again 
       Ticks2 = ReadU(Probes.Pin_1);             //U_c with bandgap reference 
       R_DDR = Probes.Rh_1;                      //Resume discharging 
       Offset = Ticks - Ticks2;
       //Allow some offset caused by the different voltage resolutions (4.88 vs. 1.07)
       if ((Offset < -4) || (Offset > 4))        //Offset too large 
       {
         /*
            Calculate total offset:
             - first get offset per mV: Offset / U_c
             - total offset for U_ref: (Offset / U_c) * U_ref
         */
         TempLong = Offset;
         TempLong *= Config.U_Bandgap;           // * U_ref 
         TempLong /= Ticks2;                     // / U_c 
         Config.RefOffset = (signed char)TempLong;
       }
      /*
         In the cap measurement above the analog comparator compared
         the voltages of the cap and the bandgap reference. Since the µC
         has an internal voltage drop for the bandgap reference the
         µC used actually U_bandgap - U_offset. We get that offset by
         comparing the bandgap reference with the voltage of the cap:
         U_c = U_bandgap - U_offset -> U_offset = U_c - U_bandgap
      */
      Offset = U_c - Config.U_Bandgap;
      //Limit offset to a valid range of -50mV - 50mV
      if ((Offset > -50) && (Offset < 50)) Config.CompOffset = Offset;
    }
  }
  return Flag;
}

 /*
     Calculate capacitance
      - use factor from pre-calculated LargeCap_table
      - ignore Config.CapZero since it's in the pF range
  */
  if (Flag == 3)
  {
    Scale = -9;                                  //Factor is scaled to nF
    //Get interpolated factor from table
    Raw = GetFactor(U_Cap + U_Drop, TABLE_LARGE_CAP);
    Raw *= Pulses;                               //C = pulses * factor
    if (Mode & FLAG_10MS) Raw *= 10;             // *10 for 10ms charging pulses
    if (Raw > UINT32_MAX / 1000)                 //Scale down if C >4.3mF
    {
      Raw /= 1000;                               //Scale down by 10^3
      Scale += 3;                                //Add 3 to the exponent
    }
    Value = Raw;                                 //Copy raw value
    //It seems that we got a systematic error
    Value *= 100;
    if (Mode & FLAG_10MS) Value /= 109;          //-9% for large cap
    else Value /= 104;                           //-4% for mid cap
    //Copy data
    Cap->A = Probes.Pin_2;                       //Pull-down probe pin
    Cap->B = Probes.Pin_1;                       //Pull-up probe pin
    Cap->Scale = Scale;                          //-9 or -6
    Cap->Raw = Raw;
    Cap->Value = Value;                          //Max. 4.3*10^6nF or 100*10^3µF
  }
  return Flag;
}

//Measure cap <4.7µF between two probe pins
byte SmallCap(Capacitor_Type *Cap)
{
  byte                        Flag = 3;          //Return value
  byte                        TempByte;          //Temp. value
  signed char                 Scale;             //Capacitance scale
  unsigned int                Ticks;             //Timer counter
  unsigned int                Ticks2;            //Timer overflow counter
  unsigned int                U_c;               //Voltage of capacitor
  unsigned long               Raw;               //Raw capacitance value
  unsigned long               Value;             //Corrected capacitance value
  /*
     Measurement method used for small caps < 50uF:
     We need a much better resolution for the time measurement. Therefore we
     use the µCs internal 16-bit counter and analog comparator. The counter
     inceases until the comparator detects that the voltage of the DUT is as
     high as the internal bandgap reference. To support the higher time
     resolution we use the Rh probe resistor for charging.

     Remark:
     The analog comparator has an Input Leakage Current of -50nA up to 50nA
     at Vcc/2. The Input Offset is <10mV at Vcc/2.
  */
  Ticks2 = 0;                                    //Reset timer overflow counter
  //Init hardware, prepare probes
  DischargeProbes();                             //Try to discharge probes
  if (Check.Found == COMP_ERROR) return 0;       //Skip on error
  //Set probes: Gnd -- all probes / Gnd -- Rh -- probe-1
  R_PORT = 0;                                    //Set resistor port to low
  //Set ADC probe pins to output mode
  ADC_DDR = (1 << TP1) | (1 << TP2) | (1 << TP3);
  SetADCLow();                                   //Set ADC port to low
  R_DDR = Probes.Rh_1;                           //Pull-down probe-1 via Rh
  //Setup analog comparator
  ADCSRB = (1 << ACME);                          //Use ADC multiplexer as negative input
  ACSR =  (1 << ACBG) | (1 << ACIC);             //Use bandgap as positive input, trigger timer1
  ADMUX = (1 << REFS0) | Probes.Pin_1;           //Switch ADC multiplexer to probe 1 and set AREF to Vcc
  ADCSRA = ADC_CLOCK_DIV;                        //Disable ADC, but keep clock dividers
  waitus(200);
  //Setup timer
  TCCR1A = 0;                                    //Set default mode
  TCCR1B = 0;                                    //Set more timer modes
  //Timer stopped, falling edge detection, noise canceler disabled
  TCNT1 = 0;                                     //Set Counter1 to 0
  //Clear all flags (input capture, compare A & B, overflow
  TIFR1 = (1 << ICF1) | (1 << OCF1B) | (1 << OCF1A) | (1 << TOV1);
  R_PORT = Probes.Rh_1;                          //Pull-up probe-1 via Rh
  //Enable timer
  if (Check.Found == COMP_FET)
  {
    //Keep all probe pins pulled down but probe-1
    TempByte = (((1 << TP1) | (1 << TP2) | (1 << TP3)) & ~(1 << Probes.Pin_1));
  }
  else
  {
    TempByte = Probes.ADC_2;                     //Keep just probe-1 pulled down
  }
  //Start timer by setting clock prescaler (1/1 clock divider)
  TCCR1B = (1 << CS10);
  ADC_DDR = TempByte;                            //Start charging DUT
  //Timer loop - run until voltage is reached - detect timer overflows
  while (1)
   {
     TempByte = TIFR1;                           //Get timer1 flags
     //End loop if input capture flag is set (= same voltage)
     if (TempByte & (1 << ICF1)) break;
     //Detect timer overflow by checking the overflow flag
     if (TempByte & (1 << TOV1))
     {
       //Happens at 65.536ms for 1MHz or 8.192ms for 8MHz
       TIFR1 = (1 << TOV1);                      //Reset flag
       wdt_reset();                              //Reset watchdog
       Ticks2++;                                 //Increase overflow counter
       //End loop if charging takes too long (13.1s)
       if (Ticks2 == (CPU_FREQ / 5000)) break;
     }
   }
  //Stop counter
  TCCR1B = 0;                                    //Stop timer
  TIFR1 = (1 << ICF1);                           //Reset Input Capture flag
  Ticks = ICR1;                                  //Get counter value
  //Disable charging
  R_DDR = 0;                                     //Set resistor port to HiZ mode
  //Catch missed timer overflow
  if ((TCNT1 > Ticks) && (TempByte & (1 << TOV1)))
  {
    TIFR1 = (1 << TOV1);                         //Reset overflow flag
    Ticks2++;                                    //Increase overflow counter
  }
  //Enable ADC again
  ADCSRA = (1 << ADEN) | (1 << ADIF) | ADC_CLOCK_DIV;
  //Get voltage of DUT
  U_c = ReadU(Probes.Pin_1);                     //Get voltage of cap
  //Start discharging DUT
  R_PORT = 0;                                    //Pull down probe-2 via Rh
  R_DDR = Probes.Rh_1;                           //Enable Rh for probe-1 again
  //Skip measurement if charging took too long
  if (Ticks2 >= (CPU_FREQ / 5000)) Flag = 1;
  //Calculate capacitance (<50uF) - use factor from pre-calculated SmallCap_table
  if (Flag == 3)
  {
    //Combine both counter values
    Raw = (unsigned long)Ticks;                  //Set lower 16 bits
    Raw |= (unsigned long)Ticks2 << 16;          //Set upper 16 bits
    if (Raw > 2) Raw -= 2;                       //Subtract processing time overhead
    Scale = -12;                                 //Default factor is for pF scale
    if (Raw > (UINT32_MAX / 1000))               //Prevent overflow (4.3*10^6)
    {
      Raw /= 1000;                               //Scale down by 10^3
      Scale += 3;                                //Add 3 to the exponent (nF)
    }
    //Multiply with factor from table
    Raw *= GetFactor(Config.U_Bandgap + Config.CompOffset, TABLE_SMALL_CAP);
    //Divide by CPU frequency to get the time and multiply with table scale
    Raw /= (CPU_FREQ / 10000);
    Value = Raw;                                 //Take raw value
    //Take care about zero offset if feasable
    if (Scale == -12)                            //pF scale
    {
      if (Value >= Config.CapZero)               //If value is larger than offset
      {
        Value -= Config.CapZero;                 //Substract offset
      }
      else                                       //If value is smaller than offset
      {
        //We have to prevent a negative value
        Value = 0;                               //Set value to 0
      }
    }
    //Copy data
    Cap->A = Probes.Pin_2;                       //Pull-down probe pin
    Cap->B = Probes.Pin_1;                       //Pull-up probe pin
    Cap->Scale = Scale;                          //-12 or -9
    Cap->Raw = Raw;
    Cap->Value = Value;                          //Max. 5.1*10^6pF or 125*10^3nF
    /*
       Self-adjust the voltage offset of the analog comparator and internal
       bandgap reference if C is 100nF up to 20µF. The minimum of 100nF
       should keep the voltage stable long enough for the measurements.
       Changed offsets will be used in next test run.
    */
    if (((Scale == -12) && (Value >= 100000)) ||
        ((Scale == -9) && (Value <= 20000)))
    {
      signed int              Offset;
      signed long             TempLong;
      /*
       *  We can self-adjust the offset of the internal bandgap reference
         by measuring a voltage lower than the bandgap reference, one time
         with the bandgap as reference and a second time with Vcc as
         reference. The common voltage source is the cap we just measured.
      */
       while (ReadU(Probes.Pin_1) > 980)
       {
         //Keep discharging
       }
       R_DDR = 0;                                //Stop discharging
       Config.AutoScale = 0;                     //Disable auto scaling
       Ticks = ReadU(Probes.Pin_1);              //U_c with Vcc reference
       Config.AutoScale = 1;                     //Enable auto scaling again
       Ticks2 = ReadU(Probes.Pin_1);             //U_c with bandgap reference
       R_DDR = Probes.Rh_1;                      //Resume discharging
       Offset = Ticks - Ticks2;
       //Allow some offset caused by the different voltage resolutions (4.88 vs. 1.07)
       if ((Offset < -4) || (Offset > 4))        //Offset too large
       {
         /*
            Calculate total offset:
             - first get offset per mV: Offset / U_c
             - total offset for U_ref: (Offset / U_c) * U_ref
         */
         TempLong = Offset;
         TempLong *= Config.U_Bandgap;           // * U_ref
         TempLong /= Ticks2;                     // / U_c
         Config.RefOffset = (signed char)TempLong;
       }
      /*
         In the cap measurement above the analog comparator compared
         the voltages of the cap and the bandgap reference. Since the µC
         has an internal voltage drop for the bandgap reference the
         µC used actually U_bandgap - U_offset. We get that offset by
         comparing the bandgap reference with the voltage of the cap:
         U_c = U_bandgap - U_offset -> U_offset = U_c - U_bandgap
      */
      Offset = U_c - Config.U_Bandgap;
      //Limit offset to a valid range of -50mV - 50mV
      if ((Offset > -50) && (Offset < 50)) Config.CompOffset = Offset;
    }
  }
  return Flag;
}

    //Display Uf of a diode
void ShowDiode_Uf(Diode_Type *Diode)
{
  //Sanity check
  if (Diode == NULL) return;
  //Display Vf
  DisplayValue(Diode->V_f, -3, 'V');
}
//Display capacitance of a diode
void ShowDiode_C(Diode_Type *Diode)
{
  //Sanity check
  if (Diode == NULL) return;
  //Get capacitance (opposite of flow direction)
  MeasureCap(Diode->C, Diode->A, 0);
  //And show capacitance
  DisplayValue(Caps[0].Value, Caps[0].Scale, 'F');
}
//Show diode
void ShowDiode(void)
{
  Diode_Type                  *D1;               //Pointer to diode #1
  Diode_Type                  *D2 = NULL;        //Pointer to diode #2
  byte                        SkipFlag = 0;      //Flag for anti-parallel diodes
  byte                        A = 5;             //ID of common anode
  byte                        C = 5;             //ID of common cothode
  unsigned int                I_leak;            //Leakage current
  D1 = &Diodes[0];                               //Pointer to first diode
  //Figure out which diodes to display
  if (Check.Diodes == 1)                         //Single diode
  {
    C = D1->C;                                   //Make anode first pin
  }
  else if (Check.Diodes == 2)                    //Two diodes
  {
    D2 = D1;
    D2++;                                        //Pointer to second diode
    if (D1->A == D2->A)                          //Common anode
    {
      A = D1->A;                                 //Save common anode
    }
    else if (D1->C == D2->C)                     //Common cathode
    {
      C = D1->C;                                 //Save common cathode
    }
    //Anti-parallel
    else if ((D1->A == D2->C) && (D1->C == D2->A))
    {
      A = D1->A;                                 //Anode and cathode
      C = A;                                     //Are the same
      SkipFlag = 1;                              //Signal anti-parallel diodes
    }
  }
  else if (Check.Diodes == 3)                    //Three diodes
  {
    byte                      n;
    byte                      m;
    /*
       Two diodes in series are additionally detected as third big diode:
        - Check for any possible way of 2 diodes be connected in series.
        - Only once the cathode of diode #1 matches the anode of diode #2.
    */
    for (n = 0; n <= 2; n++)                     //Loop for first diode
    {
      D1 = &Diodes[n];                           //Get pointer of first diode
      for (m = 0; m <= 2; m++)                   //Loop for second diode
      {
        D2 = &Diodes[m];                         //Get pointer of second diode
        if (n != m)                              //Don't check same diode :-)
        {
          if (D1->C == D2->A)                    //Got match
          {
            n = 5;                               //End loops
            m = 5;
          }
        }
      }
    }
    if (n < 5) D2 = NULL;                        //No match found
    C = D1->C;                                   //Cathode of first diode
    A = 3;                                       //In series mode
  }
  else                                           //To much diodes
  {
    D1 = NULL;                                   //Don't display any diode
    ShowFail();                                  //And tell user
    return;
  }
  //Display pins, first Diode
  if (A < 3) lcd_testpin(D1->C);                 //Common anode
  else lcd_testpin(D1->A);                       //Common cathode
  if (A < 3) lcd_fixed_string(Diode_CA_str);     //Common anode
  else lcd_fixed_string(Diode_AC_str);           //Common cathode
  if (A < 3) lcd_testpin(A);                     //Common anode
  else lcd_testpin(C);                           //Common cathode
  if (D2)                                        //Second diode
  {
    if (A <= 3) lcd_fixed_string(Diode_AC_str);  //Common anode or in series
    else lcd_fixed_string(Diode_CA_str);         //Common cathode
    if (A == C) lcd_testpin(D2->A);              //Anti parallel
    else if (A <= 3) lcd_testpin(D2->C);         //Common anode or in series
    else lcd_testpin(D2->A);                     //Common cathode
  }
  /*
     display:
      - Uf (forward voltage)
      - reverse leakage current (for single diodes)
      - capacitance (not for anti-parallel diodes)
  */
  //Uf
  lcd_line(2);                                   //Go to line #2
  lcd_fixed_string(Vf_str);                      //Display: Vf=
  ShowDiode_Uf(D1);                              //First diode
  lcd_space();
  if (D2 == NULL)                                //Single diode
  {
    //Display low current Uf if it's quite low (Ge/Schottky diode)
    if (D1->V_f2 < 250)
    {
      lcd_data('(');
      DisplayValue(D1->V_f2, 0, 0);
      lcd_data(')');
    }
    //Reverse leakage current
    UpdateProbes(D1->C, D1->A, 0);               //Reverse diode
    I_leak = GetLeakageCurrent();                //Get current (in µA)
    if (I_leak > 0)                              //Show if not zero
    {
      #ifdef BUTTON_INST
        TestKey(USER_WAIT, 11);                  //Next page
      #else
        delay(3000);
      #endif
      lcd_clear_line(2);                         //Only change line #2
      lcd_fixed_string(I_R_str);                 //Display: I_R=
      DisplayValue(I_leak, -6, 'A');             //Display current
    }
  }
  else
  {
    ShowDiode_Uf(D2);                            //Second diode (optional)
  }
  //Capacitance
  if (SkipFlag == 0)
  {
    #ifdef BUTTON_INST
      TestKey(USER_WAIT, 11);                    //Next page
    #else
      delay(3000);
    #endif
    lcd_clear_line(2);                           //Only change line #2
    lcd_fixed_string(DiodeCap_str);              //Display: C=
    ShowDiode_C(D1);                             //First diode
    lcd_space();
    ShowDiode_C(D2);                             //Second diode (optional)
  }
}

	//Display Uf of a diode
	void ShowDiode_Uf(Diode_Type *Diode)
	{
	  //Sanity check
	  if (Diode == NULL) return;
	  //Display Vf
	  DisplayValue(Diode->V_f, -3, 'V');
	}

	//Display capacitance of a diode
	void ShowDiode_C(Diode_Type *Diode)
	{
	  //Sanity check
	  if (Diode == NULL) return;
	  //Get capacitance (opposite of flow direction)
	  MeasureCap(Diode->C, Diode->A, 0);
	  //And show capacitance
	  DisplayValue(Caps[0].Value, Caps[0].Scale, 'F');
	}

	//Show diode
	void ShowDiode(void)
	{
	  Diode_Type                  *D1;               //Pointer to diode #1
	  Diode_Type                  *D2 = NULL;        //Pointer to diode #2
	  byte                        SkipFlag = 0;      //Flag for anti-parallel diodes
	  byte                        A = 5;             //ID of common anode
	  byte                        C = 5;             //ID of common cothode
	  unsigned int                I_leak;            //Leakage current
	  D1 = &Diodes[0];                               //Pointer to first diode
	  //Figure out which diodes to display
	  if (Check.Diodes == 1)                         //Single diode
	  {
	    C = D1->C;                                   //Make anode first pin
	  }
	  else if (Check.Diodes == 2)                    //Two diodes
	  {
	    D2 = D1;
	    D2++;                                        //Pointer to second diode
	    if (D1->A == D2->A)                          //Common anode
	    {
	      A = D1->A;                                 //Save common anode
	    }
	    else if (D1->C == D2->C)                     //Common cathode
	    {
	      C = D1->C;                                 //Save common cathode
	    }
	    //Anti-parallel
	    else if ((D1->A == D2->C) && (D1->C == D2->A))
	    {
	      A = D1->A;                                 //Anode and cathode
	      C = A;                                     //Are the same
	      SkipFlag = 1;                              //Signal anti-parallel diodes
	    }
	  }
	  else if (Check.Diodes == 3)                    //Three diodes
	  {
	    byte                      n;
	    byte                      m;
	    /*
	       Two diodes in series are additionally detected as third big diode:
	        - Check for any possible way of 2 diodes be connected in series.
	        - Only once the cathode of diode #1 matches the anode of diode #2.
	    */
	    for (n = 0; n <= 2; n++)                     //Loop for first diode
	    {
	      D1 = &Diodes[n];                           //Get pointer of first diode
	      for (m = 0; m <= 2; m++)                   //Loop for second diode
	      {
	        D2 = &Diodes[m];                         //Get pointer of second diode
	        if (n != m)                              //Don't check same diode :-)
	        {
	          if (D1->C == D2->A)                    //Got match
	          {
	            n = 5;                               //End loops
	            m = 5;
	          }
	        }
	      }
	    }
	    if (n < 5) D2 = NULL;                        //No match found
	    C = D1->C;                                   //Cathode of first diode
	    A = 3;                                       //In series mode
	  }
	  else                                           //To much diodes
	  {
	    D1 = NULL;                                   //Don't display any diode
	    ShowFail();                                  //And tell user
	    return;
	  }
	  //Display pins, first Diode
	  if (A < 3) lcd_testpin(D1->C);                 //Common anode
	  else lcd_testpin(D1->A);                       //Common cathode
	  if (A < 3) lcd_fixed_string(Diode_CA_str);     //Common anode
	  else lcd_fixed_string(Diode_AC_str);           //Common cathode
	  if (A < 3) lcd_testpin(A);                     //Common anode
	  else lcd_testpin(C);                           //Common cathode
	  if (D2)                                        //Second diode
	  {
	    if (A <= 3) lcd_fixed_string(Diode_AC_str);  //Common anode or in series
	    else lcd_fixed_string(Diode_CA_str);         //Common cathode
	    if (A == C) lcd_testpin(D2->A);              //Anti parallel
	    else if (A <= 3) lcd_testpin(D2->C);         //Common anode or in series
	    else lcd_testpin(D2->A);                     //Common cathode
	  }
	  /*
	     display:
	      - Uf (forward voltage)
	      - reverse leakage current (for single diodes)
	      - capacitance (not for anti-parallel diodes)
	  */
	  //Uf
	  lcd_line(2);                                   //Go to line #2
	  lcd_fixed_string(Vf_str);                      //Display: Vf=
	  ShowDiode_Uf(D1);                              //First diode
	  lcd_space();
	  if (D2 == NULL)                                //Single diode
	  {
	    //Display low current Uf if it's quite low (Ge/Schottky diode)
	    if (D1->V_f2 < 250)
	    {
	      lcd_data('(');
	      DisplayValue(D1->V_f2, 0, 0);
	      lcd_data(')');
	    }
	    //Reverse leakage current
	    UpdateProbes(D1->C, D1->A, 0);               //Reverse diode
	    I_leak = GetLeakageCurrent();                //Get current (in µA)
	    if (I_leak > 0)                              //Show if not zero
	    {
	      #ifdef BUTTON_INST
	        TestKey(USER_WAIT, 11);                  //Next page
	      #else
	        delay(3000);
	      #endif
	      lcd_clear_line(2);                         //Only change line #2
	      lcd_fixed_string(I_R_str);                 //Display: I_R=
	      DisplayValue(I_leak, -6, 'A');             //Display current
	    }
	  }
	  else
	  {
	    ShowDiode_Uf(D2);                            //Second diode (optional)
	  }
	  //Capacitance
	  if (SkipFlag == 0)
	  {
	    #ifdef BUTTON_INST
	      TestKey(USER_WAIT, 11);                    //Next page
	    #else
	      delay(3000);
	    #endif
	    lcd_clear_line(2);                           //Only change line #2
	    lcd_fixed_string(DiodeCap_str);              //Display: C=
	    ShowDiode_C(D1);                             //First diode
	    lcd_space();
	    ShowDiode_C(D2);                             //Second diode (optional)
	  }
	}