diagram.json

6x8_vertikal_LSB_1.h

7x12_vertical_LSB_1.h

8x12_vertikal_LSB_1thin.h

24x32_vertical_LSB.h

24x32update_bitmaps.h

ArduTester_more.ino

autoconf.h


//include "Transistortester.h"
//include "Makefile.h" //J-L

//	  Calibrate_UR();		// get Ref Voltages and Pin resistance
//        lcd_line1();			// Cursor to 1. row, column 1
	  
#ifdef BAT_CHECK
void Battery_check(void) {
 uint16_t bat_voltage;
 uint16_t bat_adc;
  // Battery check is selected
  ReadADC(TPBAT);	//Dummy-Readout
  bat_adc = W5msReadADC(TPBAT); 	//with 5V reference
 #ifdef BAT_OUT
  // display Battery voltage
  // The divisor to get the voltage in 0.01V units is ((10*33)/133) witch is about 2.4812
  // A good result can be get with multiply by 4 and divide by 10 (about 0.75%).
  #if BAT_NUMERATOR <= (0xffff/U_VCC)
	  bat_voltage = (bat_adc*BAT_NUMERATOR)/BAT_DENOMINATOR + BAT_OUT;
  #else
   #if (BAT_NUMERATOR == 133) && (BAT_DENOMINATOR == 33)
	  bat_voltage = (bat_adc*4)+BAT_OUT;		// usually output only 2 digits
   #else
	  bat_voltage = ((unsigned long)bat_adc*BAT_NUMERATOR)/BAT_DENOMINATOR + BAT_OUT;
   #endif
  #endif
  #if FLASHEND > 0x1fff
          DC_Pwr_mode = 0;
   #ifdef DC_PWR
          if ((bat_voltage < 900) || (bat_voltage > DC_PWR))
   #else
          if (bat_voltage < 900) 
   #endif
          {
             // no battery present, don't check,
	     lcd_MEM_string(DC_Pwr_Mode_str);	// "DC Pwr Mode"
             lcd_clear_line();			// clear to end of line
             DC_Pwr_mode = 1;
             return;
          }
  #endif
         lcd_MEM_string(Bat_str);		//output: "Bat. "
	 Display_mV(bat_voltage,2);		// Display 2 Digits of this 10mV units
         lcd_space();
 #else    /* without battery voltage output */
    lcd_MEM_string(Bat_str);		//output: "Bat. "
 #endif  /* BAT_OUT */
 #if (BAT_POOR > 12000)
   #warning "Battery POOR level is set very high!"
 #endif
 #if (BAT_POOR < 2500)
   #warning "Battery POOR level is set very low!"
 #endif
 #if (BAT_POOR > 5300)
  // use .8 V difference to Warn-Level
  #define WARN_LEVEL (((unsigned long)(BAT_POOR+800)*(unsigned long)BAT_DENOMINATOR)/BAT_NUMERATOR)
 #elif (BAT_POOR > 3249)
  // less than 5.4 V only .4V difference to Warn-Level
  #define WARN_LEVEL (((unsigned long)(BAT_POOR+400)*(unsigned long)BAT_DENOMINATOR)/BAT_NUMERATOR)
 #elif (BAT_POOR > 1299)
  // less than 2.9 V only .2V difference to Warn-Level
  #define WARN_LEVEL (((unsigned long)(BAT_POOR+200)*(unsigned long)BAT_DENOMINATOR)/BAT_NUMERATOR)
 #else
  // less than 1.3 V only .1V difference to Warn-Level
  #define WARN_LEVEL (((unsigned long)(BAT_POOR+100)*(unsigned long)BAT_DENOMINATOR)/BAT_NUMERATOR)
 #endif
 #define POOR_LEVEL (((unsigned long)(BAT_POOR)*(unsigned long)BAT_DENOMINATOR)/BAT_NUMERATOR)

  // check the battery voltage
  if (bat_adc <  WARN_LEVEL) {
     //Vcc < 7,3V; show Warning 
     if(bat_adc < POOR_LEVEL) {	
	//Vcc <6,3V; no proper operation is possible
	lcd_MEM_string(BatEmpty);	//Battery empty!
        lcd_clear_line();			// clear to end of line
	lcd_refresh();			// write the pixels to display, ST7920 only
	wait_about5s();			// Let time to read the "empty" message
        switch_tester_off();		// switch power off
	return;
     }
     lcd_MEM_string(BatWeak);		//Battery weak
  } else { // Battery-voltage OK
     lcd_MEM_string(OK_str); 		// "OK"
  }
  lcd_clear_line();			// clear to end of line
};
#endif	/* BAT_CHECK */


Battery_check.ino

//#include <avr/pgmspace.h>
//#include "24x32update_bitmaps.h"


//*****************************************************************************
//
// The data for the bitmap bmp_one
//
// Memory usage: 7 or 5 bytes
//*****************************************************************************
#if defined (MAIN_C)
 #ifdef INVERSE_TP
  #define TP_DATA_COUNT 7
 #else
  #define TP_DATA_COUNT 5
 #endif
 const unsigned char bmp_one_data[(TP_DATA_COUNT * 1) + 2] PROGMEM ={
	TP_DATA_COUNT, /* The width of the bitmap. */
	8, /* The height of the bitmap. */
 #ifdef INVERSE_TP
        0xff, 0xff, 0xf7, 0xfb, 0x81, 0xff, 0xff
 #else
  #ifdef BIG_TP
        0x00, 0x04, 0x02, 0xff, 0x00
  #else
	0x00, 0x08, 0x04, 0x7e, 0x00
  #endif
 #endif
};
#else
 extern const unsigned char bmp_one_data[] PROGMEM ;
#endif


//*****************************************************************************
//
// The data for the bitmap bmp_two
//
// Memory usage: 7 or 5 bytes
//*****************************************************************************
#if defined (MAIN_C)
 const unsigned char bmp_two_data[(TP_DATA_COUNT * 1) + 2] PROGMEM ={
	TP_DATA_COUNT, /* The width of the bitmap. */
	8, /* The height of the bitmap. */
 #ifdef INVERSE_TP
        0xff, 0xbb, 0x9d, 0xad, 0xad, 0xb3, 0xff
 #else
  #ifdef BIG_TP
        0xc2, 0xa1, 0x91, 0x89, 0x86
  #else
	0x44, 0x62, 0x52, 0x52, 0x4c
  #endif
 #endif
};
#else
 extern const unsigned char bmp_two_data[] PROGMEM ;
#endif


//*****************************************************************************
//
// The data for the bitmap bmp_three
//
// Memory usage: 7 or 5 bytes
//*****************************************************************************
#if defined (MAIN_C)
 const unsigned char bmp_three_data[(TP_DATA_COUNT * 1) + 2] PROGMEM ={
	TP_DATA_COUNT, /* The width of the bitmap. */
	8, /* The height of the bitmap. */
 #ifdef INVERSE_TP
        0xff, 0xdb, 0xbd, 0xb5, 0xb5, 0xcb, 0xff
 #else
  #ifdef BIG_TP
        0x42, 0x81, 0x89, 0x89, 0x76
  #else
	0x24, 0x42, 0x4a, 0x4a, 0x34
  #endif
 #endif
};
#else
 extern const unsigned char bmp_three_data[] PROGMEM ;
#endif



//*****************************************************************************
//
// The data for the bitmapbmp_vakdiode
//
// Memory usage: 34 bytes
//*****************************************************************************
#if defined (MAIN_C)
 #if (ICON_TYPE == 1)
 const unsigned char bmp_vakdiode[(7 * 4) + 4] PROGMEM =
{ 
        24,
        0,
	7, // The width of the bitmap.
	32, // The height of the bitmap.
	0x04, 0x04, 0x04, 0xFC, 0x00, 0x00, 0x00,
	0x20, 0x60, 0xE0, 0xFF, 0xE0, 0x60, 0x20,
	0x02, 0x02, 0x02, 0xFF, 0x02, 0x02, 0x02,
	0x20, 0x20, 0x20, 0x3F, 0x00, 0x00, 0x00,
};
 #elif  (ICON_TYPE == 3)
 const unsigned char bmp_vakdiode[(7 * 4) + 4] PROGMEM =
{ 
        24,
        0,
	7, // The width of the bitmap.
	32, // The height of the bitmap.
	0x08, 0x08, 0x08, 0xF8, 0x00, 0x00, 0x00,
	0x20, 0x60, 0xA0, 0x3F, 0xA0, 0x60, 0x20,
	0x02, 0x02, 0x02, 0xFF, 0x02, 0x02, 0x02,
	0x10, 0x10, 0x10, 0x1F, 0x00, 0x00, 0x00,
};

 #else
 const unsigned char bmp_vakdiode[(8 * 4) + 4] PROGMEM =
{ 
        24,
        0,
	8, // The width of the bitmap.
	32, // The height of the bitmap.
	0x06, 0x06, 0x06, 0xFE, 0xFE, 0x00, 0x00, 0x00,
	0x20, 0x60, 0xE0, 0xFF, 0xFF, 0xE0, 0x60, 0x20,
	0x06, 0x06, 0x06, 0xFF, 0xFF, 0x06, 0x06, 0x06,
	0x60, 0x60, 0x60, 0x7F, 0x7F, 0x00, 0x00, 0x00, 
};
 #endif
#else
 extern const unsigned char bmp_vakdiode[] PROGMEM ;
#endif


//*****************************************************************************
//
// The data for the bitmap bmp_inductor
//
// Memory usage: 18 bytes
//*****************************************************************************
#if defined (MAIN_C)
 const unsigned char bmp_inductor_data[(16 * 1) + 2] PROGMEM ={
        16 , // The width of the bitmap.
         8, // The height of the bitmap.
	0x40, 0x7e, 0x01, 0x01,  0x3e, 0x01, 0x01, 0x3e, 
	0x01, 0x01, 0x3e, 0x01,  0x01, 0x7e, 0x40, 0x40, 
};
#else
 extern const unsigned char bmp_inductor_data[] PROGMEM ;
#endif

#if (LCD_ST_TYPE == 7920)
 #if defined (MAIN_C)
  const unsigned char set_msk[] PROGMEM = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
  const unsigned char clear_msk[] PROGMEM = { 0xfe, 0xfd, 0xfb, 0xf7, 0xef, 0xdf, 0xbf, 0x7f};
 #else
  extern const unsigned char set_msk[] PROGMEM ;
  extern const unsigned char clear_msk[] PROGMEM ;
 #endif
#endif


bitmaps.h

//#include "Transistortester.h"
//#include "Makefile.h" //J-L


void Calibrate_UR(void) {
 // get reference voltage, calibrate VCC with external 2.5V and
 // get the port output resistance
 // all measurements take  more than 170ms time

#ifdef AUTO_CAL
  uint16_t sum_rm;	// sum of 3 Pin voltages with 680 Ohm load
  uint16_t sum_rp;	// sum of 3 Pin voltages with 680 Ohm load
  uint16_t u680;	// 3 * (Voltage at 680 Ohm)
#endif


  adc_vcc_reference = U_VCC;     // set initial VCC Voltage to 5000mV
  ADCconfig.U_AVCC = adc_vcc_reference;	// set ADC to normal VCC value
  ADCconfig.Samples = R_ANZ_MESS;	// set number of ADC reads near to maximum
                                        //############################################
#if FLASHEND > 0x1fff
  uint16_t mv2500;
  ADC_PORT = TXD_VAL;                   // switch to 0V
  ADC_DDR = (1<<TPRELAY) | TXD_MSK;       // switch pin with 2.5V reference to GND
  wait20us();			// switch only short time, so that the relais do not really switch
  ADC_DDR =  TXD_MSK;		// switch pin with reference back to input
  mv2500 = W5msReadADC(TPREF); // read voltage of 2.5V precision reference
  if ((mv2500 > 2250) && (mv2500 < 2750)) {
     // precision voltage reference connected, update U_AVCC
     WithReference = 1;
     adc_vcc_reference = (unsigned long)((unsigned long)ADCconfig.U_AVCC * 2495) / mv2500;
  }
  ADCconfig.U_AVCC = adc_vcc_reference;	// set ADC to normal VCC value
#endif
#ifdef WITH_AUTO_REF
  (void) ReadADC(MUX_INT_REF);	// read reference voltage 
  ref_mv = W5msReadADC(MUX_INT_REF);	// read reference voltage 
#else
  ref_mv = DEFAULT_BAND_GAP;    // set to default Reference Voltage
#endif
  (void) RefVoltage();			//compute RHmultip = f(reference voltage)
                                        // ref_mv_offs, ADCconfig.U_Bandgap
                                        //############################################

  EntladePins();	// make sure, that no voltage is left from capacitors
#ifdef AUTO_CAL
  // measurement of internal resistance of the ADC port outputs switched to GND
  ADC_PORT =  TXD_VAL;	//ADC-Ports to GND
  ADC_DDR = 1<<TP1 | TXD_MSK;	//ADC-Pin  1 to output 0V
 #ifdef PULLUP_DISABLE
  R_PORT = (1<<PIN_RL1) | (1<<PIN_RL2) | (1<<PIN_RL3);		//R_L-PORTs to VCC
 #else
  R_PORT = 1<<PIN_RL1;		//R_L-PORT 1 to VCC
 #endif
  R_DDR = 1<<PIN_RL1;		//Pin 1 to output and over R_L to VCC
  sum_rm = W5msReadADC(TP1);
// - - - - - - - 
  ADC_DDR = 1<<TP2 | TXD_MSK;	//ADC-Pin 2 to output 0V
 #ifndef PULLUP_DISABLE
  R_PORT =  1<<PIN_RL2;		//R_L-PORT 2 to VCC
 #endif
  R_DDR = 1<<PIN_RL2;		//Pin 2 to output and over R_L to VCC
  sum_rm += W5msReadADC(TP2);
// - - - - - - - 
  ADC_DDR = 1<<TP3 | TXD_MSK;	//ADC-Pin 3 to output 0V
 #ifndef PULLUP_DISABLE
  R_PORT =  1<<PIN_RL3;		//R_L-PORT 3 to VCC
 #endif
  R_DDR = 1<<PIN_RL3;		//Pin 3 to output and over R_L to VCC
  sum_rm += W5msReadADC(TP3);	//add all three values
// - - - - - - - 

  // measurement of internal resistance of the ADC port output switched to VCC
  R_PORT = 0;			// R-Ports to GND
  ADC_PORT = 1<<TP1 | TXD_VAL;	//ADC-Port 1 to VCC
  ADC_DDR = 1<<TP1 | TXD_MSK;	//ADC-Pin  1 to output 0V
  R_DDR = 1<<PIN_RL1;		//Pin 1 to output and over R_L to GND
  sum_rp = vcc_diff(W5msReadADC(TP1));
// - - - - - - - 
      
  ADC_PORT = 1<<TP2 | TXD_VAL;	//ADC-Port 2 to VCC
  ADC_DDR = 1<<TP2 | TXD_MSK;	//ADC-Pin  2 to output 0V
  R_DDR = 1<<PIN_RL2;		//Pin 2 to output and over R_L to GND
  sum_rp += vcc_diff(W5msReadADC(TP2));
// - - - - - - - 

  ADC_PORT = 1<<TP3 | TXD_VAL;	//ADC-Port 3 to VCC
  ADC_DDR = 1<<TP3 | TXD_MSK;	//ADC-Pin  3 to output 0V
  R_DDR = 1<<PIN_RL3;		//Pin 3 to output and over R_L to GND
  sum_rp += vcc_diff(W5msReadADC(TP3));
// - - - - - - - 
  ADC_DDR =  TXD_MSK;	//ADC-Pins to input
  ADC_PORT =  TXD_VAL;	//ADC-Ports to GND
  R_DDR   = 0;

  u680 = ((ADCconfig.U_AVCC * 3) - sum_rm - sum_rp);	//three times the voltage at the 680 Ohm
  pin_rmi = (unsigned long)((unsigned long)sum_rm * (unsigned long)R_L_VAL) / (unsigned long)u680;
//  adcmv[2] = pin_rm;	// for last output in row 2
  pin_rpl = (unsigned long)((unsigned long)sum_rp * (unsigned long)R_L_VAL) / (unsigned long)u680;
  resis680pl = pin_rpl + R_L_VAL;
  resis680mi = pin_rmi + R_L_VAL;
#endif

  ADCconfig.Samples = ANZ_MESS;	// set to configured number of ADC samples
 } 
 


Calibrate_UR.ino

// new code by K.-H. Kübbeler
// CalibrateCap tries to find the value of a capacitor by measuring the load time.
// first of all the capacitor is discharged.
// The build in 16bit counter can save the counter value at external events.
// One of these events can be the output change of a build in comparator.
// The comparator can compare the voltage of any of the ADC input pins with the voltage
// of the internal reference (1.3V or 1.1V).
// After setting up the comparator and counter properly, the load of capacitor is started 
// with connecting the positive pin with the R_H resistor (470kOhm) to VCC and immediately
// the counter is started. By counting the overflow Events of the 16bit counter and watching
// the counter event flag  the total load time of the capacitor until reaching the internal
// reference voltage can be measured.
// If any of the tries to measure the load time is successful,
// the following variables are set:
// cap.cval = value of the capacitor 
// cap.cval_uncorrected = value of the capacitor uncorrected
// cap.cpre = units of cap.cval (-12==pF, -9=nF, -6=µF)
// ca   = Pin number (0-2) of the LowPin
// cb   = Pin number (0-2) of the HighPin

/*
#include <avr/io.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/

//=================================================================
#if (TPCAP >= 0)
void CalibrationCap() {
  // read voltage offsets with calibration capacitor
  unsigned int tmpint;
  unsigned int adcv0;
  unsigned int adcv1;
#ifdef INHIBIT_SLEEP_MODE
  unsigned int ovcnt16;
#endif
  uint8_t ii;

     // special handling for build in calibration capacitor
  for (ii=0; ii<20; ii++) {
     ADC_PORT = TXD_VAL;		// switch ADC-Port to GND
     ADC_DDR = (1<<TPCAP) | TXD_MSK;	// switch capacitor-Pin to output (GND)
     wait_about20ms();
     ADC_DDR = TXD_MSK;			// switch all ADC to input 
     adcv0 = ReadADC(TPCAP);		// voltage before any load 
     if (adcv0 < CAP_EMPTY_LEVEL) break;
  }

#ifdef AUTO_CAL
  pin_combination =  1;	// use one of the calibrated values
#endif


//==================================================================================
// Measurement of little capacity values
  //little capacity value, about  < 50 µF
  //measure with the R_H (470kOhm) resistor 
  R_PORT = 0;		// R_DDR ist HiPinR_L
  ADC_DDR = (1<<TPCAP) | TXD_MSK;	//switch the Cap Pin to output
  ADC_PORT = TXD_VAL;		//switch the ADC Pins to GND
  TCAP_PORT &= ~(1<<TCAP_RH);		// switch 470k resistor to GND
  TCAP_DDR |= (1<<TCAP_RH);
// setup Analog Comparator
  ADC_COMP_CONTROL = (1<<ACME);			//enable Analog Comparator Multiplexer
  ACSR =  (1<<ACBG) | (1<<ACI)  | (1<<ACIC);	// enable, 1.3V, no Interrupt, Connect to Timer1 
  ADMUX = (1<<REFS0) | TPCAP;			// switch Mux to CapPin
  ADCSRA = (1<<ADIF) | AUTO_CLOCK_DIV; //disable ADC
  wait200us();			//wait for bandgap to start up

// setup Counter1
  ovcnt16 = 0;
  TCCR1A = 0;			// set Counter1 to normal Mode
  TCNT1 = 0;			//set Counter to 0
  TI1_INT_FLAGS = (1<<ICF1) | (1<<OCF1B) | (1<<OCF1A) | (1<<TOV1);	// clear interrupt flags
#ifndef INHIBIT_SLEEP_MODE
  TIMSK1 = (1<<TOIE1) | (1<<ICIE1);	// enable Timer overflow interrupt and input capture interrupt
  unfinished = 1;
#endif
  TCAP_PORT |= (1<<TCAP_RH);		// switch 470k resistor to VCC
  TCCR1B = (0<<ICNC1) | (1<<CS10);	//Start counter 1MHz or 8MHz without Noise Canceler
  ADC_DDR &= ~(1<<TPCAP);		// charge capacitor with R_H slowly
//******************************
#ifdef INHIBIT_SLEEP_MODE
  while(1) {
     // Wait, until  Input Capture is set
     ii = TI1_INT_FLAGS;	//read Timer flags
     if (ii & (1<<ICF1))  {
        break;
     }
     if((ii & (1<<TOV1))) {	// counter overflow, 65.536 ms @ 1MHz, 8.192ms @ 8MHz
        TI1_INT_FLAGS = (1<<TOV1);	// Reset OV Flag
        wdt_reset();
        ovcnt16++;
        if(ovcnt16 == (F_CPU/5000)) {
           break; 		//Timeout for Charging, above 12 s
        }
     }
  }
  TCCR1B = (0<<ICNC1) | (0<<ICES1) | (0<<CS10);  // stop counter
  TI1_INT_FLAGS = (1<<ICF1);		// Reset Input Capture
  tmpint = ICR1;		// get previous Input Capture Counter flag
// check actual counter, if an additional overflow must be added
  if((TCNT1 > tmpint) && (ii & (1<<TOV1))) {
     // this OV was not counted, but was before the Input Capture
     TI1_INT_FLAGS = (1<<TOV1);		// Reset OV Flag
     ovcnt16++;
  }
#else
  cli();		// disable interrupts to prevent wakeup Interrupts before sleeping
  set_sleep_mode(SLEEP_MODE_IDLE);
  while(unfinished) {
    sleep_enable();
    sei();		// enable interrupts after next instruction
    sleep_cpu();	// only enable interrupts during sleeping
    sleep_disable();
    cli();		// disable interrupts again
    wdt_reset();	// reset watch dog during waiting
    if(ovcnt16 == (F_CPU/5000)) {
       break; 		//Timeout for Charging, above 12 s
    }
  }
  sei();		// enable interrupts again
  TCCR1B = (0<<ICNC1) | (0<<ICES1) | (0<<CS10);  // stop counter
  tmpint = ICR1;		// get previous Input Capture Counter flag
  TIMSK1 = (0<<TOIE1) | (0<<ICIE1);	// disable Timer overflow interrupt and input capture interrupt
#endif


//############################################################
  ADCSRA = (1<<ADEN) | (1<<ADIF) | AUTO_CLOCK_DIV; //enable ADC
  TCAP_DDR &= ~(1<<TCAP_RH);
  TCAP_PORT &= ~(1<<TCAP_RH);		// switch 470k resistor off
  adcv1 = ReadADC(TPCAP);   // get loaded voltage
  load_diff = adcv1 + REF_C_KORR - ref_mv;	// build difference of capacitor voltage to Reference Voltage
//############################################################
  if (ovcnt16 >= (F_CPU/10000)) {
     goto keinC;	// no normal end
  }
//  cap.cval_uncorrected = CombineII2Long(ovcnt16, tmpint);
  cap.cval_uncorrected.w[1] = ovcnt16;
  cap.cval_uncorrected.w[0] = tmpint;

  cap.cpre = -12;			// cap.cval unit is pF 
  if (ovcnt16 > 65) {
     cap.cval_uncorrected.dw /= 100;	// switch to next unit
     cap.cpre += 2;			// set unit, prevent overflow
  }
  cap.cval_uncorrected.dw *= RHmultip;		// 708
  cap.cval_uncorrected.dw /= (F_CPU / 10000);	// divide by 100 (@ 1MHz clock), 800 (@ 8MHz clock)
  cap.cval = cap.cval_uncorrected.dw;		// set the corrected cap.cval
  Scale_C_with_vcc();
  if (cap.cpre == -12) {
#if COMP_SLEW1 > COMP_SLEW2
     if (cap.cval < COMP_SLEW1) {
        // add slew rate dependent offset
        cap.cval += (COMP_SLEW1 / (cap.cval+COMP_SLEW2 ));
     }
#endif
#ifdef AUTO_CAL
     // auto calibration mode, cap_null can be updated in selftest section
     tmpint = eeprom_read_byte(&c_zero_tab[pin_combination]);	// read zero offset
     if (cap.cval > tmpint) {
         cap.cval -= tmpint;		//subtract zero offset (pF)
     } else {
         cap.cval = 0;			//unsigned long may not reach negativ value
     }
#else
     if (cap.cval > C_NULL) {
         cap.cval -= C_NULL;		//subtract constant offset (pF)
     } else {
         cap.cval = 0;			//unsigned long may not reach negativ value
     }
#endif
  }

#if F_CPU < 2000001
   if(cap.cval < 50)
#else 
   if(cap.cval < 25)
#endif 
     {
     // cap.cval can only be so little in pF unit, cap.cpre must not be testet!
      goto keinC;	//capacity to low, < 50pF @1MHz (25pF @8MHz)
     }
   // end low capacity 
   PartFound = PART_CAPACITOR;	//capacitor is found
   if ((cap.cpre > cap.cpre_max) || ((cap.cpre == cap.cpre_max) && (cap.cval > cap.cval_max))) {
      // we have found a greater one
      cap.cval_max = cap.cval;
      cap.cpre_max = cap.cpre;
#if FLASHEND > 0x1fff
      cap.v_loss = 0;		// lost voltage in 0.01%
#endif
      cap.ca = 0;		// save LowPin
      cap.cb = TPCAP;		// save HighPin
   }

keinC:
  // discharge capacitor again
//  EntladePins();		// discharge capacitors
  //ready
  // switch all ports to input
  ADC_DDR =  TXD_MSK;		// switch all ADC ports to input
  ADC_PORT = TXD_VAL;		// switch all ADC outputs to GND, no pull up
  R_DDR = 0;			// switch all resistor ports to input
  R_PORT = 0; 			// switch all resistor outputs to GND, no pull up
  return;
 } // end CalibrationCap()
#endif  /* (TPCAP >= 0) */


CalibrationCap.ino

config.h


/*
#include <stdlib.h>
#include <string.h>

#include "Transistortester.h"
#include "Makefile.h" //J-L
*/


#if defined(WITH_XTAL) || defined(WITH_MENU)
#define LONG_OUTPUT      // to allow more digits for crystal frequency
#endif

/* ************************************************************************
 *   display of values and units
 * ************************************************************************ */

/*
 *  display value and unit
 *  - max. 4 (7) digits excluding "." and unit
 *
 *  requires:
 *  - value
 *  - exponent of factor related to base unit (value * 10^x)
 *    e.g: p = 10^-12 -> -12
 *  - unit character (0 = none)
 *  digits = 2 to 4 
 *  for option LONG_OUTPUT  digits can also be 5, 6 and 7
 *  Flag 0x10 for output with leading zeros
 *  Flag 0x20 for '+' Output, if not '-' 
 */

void DisplayValue(signed long signedValue, int8_t Exponent, unsigned char Unit, uint8_t xdigits)
{

  char OutBuffer[14];
#ifdef LONG_OUTPUT
  unsigned long     Limit;
#else
  uint16_t      Limit;
#endif
  unsigned char     Prefix;		/* prefix character */
  unsigned char     Offset;		/* exponent of offset to next 10^3 step */
  uint8_t           Index;		/* index ID */
  uint8_t           digits;		/* xdigits without option */
  uint8_t           Length;		/* string length */
  uint8_t	    Rshift;		/* right shift of significant bits with leading '0' */


  unsigned long Value=signedValue;
  digits = xdigits & 0x0f;
  for(Prefix=0;Prefix<6;Prefix++) OutBuffer[Prefix] = '0';

#if FLASHEND > 0x1fff
  if (signedValue<0) {
     lcd_data('-');
     Value=-signedValue;
  } else {
     if ((xdigits & 0x20) != 0) lcd_data('+');
  }
#endif

  Limit = 100;				/* scale value down to 2 digits */
  if (digits == 3) Limit = 1000;	/* scale value down to 3 digits */
  if (digits == 4) Limit = 10000;	/* scale value down to 4 digits */
#ifdef LONG_OUTPUT
  if (digits == 5) Limit = 100000;	/* scale value down to 5 digits */
  if (digits == 6) Limit = 1000000;	/* scale value down to 6 digits */
  if (digits == 7) Limit = 10000000;	/* scale value down to 7 digits */
#endif

  while (Value >= Limit)
  {
    Value += 5;				/* for automatic rounding */
    // perhaps TODO: the above is not really correct, can do double rounding (2000.45 -> 2000.5 -> 2001)
    Value = Value / 10;			/* scale down by 10^1 */
    Exponent++;				/* increase exponent by 1 */
  }


  /*
   *  determine prefix
   */

#if 0
  Length = Exponent + 12;
  if ((int8_t)Length <  0) Length = 0;		/* Limit to minimum prefix */
  if (Length > 18) Length = 18;		/* Limit to maximum prefix */
  Index = Length / 3;
  Offset = Length % 3;
  if (Offset > 0)
    {
      Index++;				/* adjust index for exponent offset, take next prefix */
      Offset = 3 - Offset;		/* reverse value (1 or 2) */
    }
#endif
  // the following is much more concise
  // also removes the limits checking, since limit errors should never happen, and if they do, they'd show _incorrect_ results;
  // showing a garbage prefix character seems preferable to something correct-looking but off by some power of 10
  Index = ((unsigned char)(Exponent+17))/3;
  Offset = ((unsigned char)(6-Exponent))%3;

  /* convert value into string */

#ifdef LONG_OUTPUT
  ultoa(Value, &OutBuffer[6], 10);	// sprintf(&OutBuffer[6],"%ld%c",Value,(char)0);
#else
  utoa((uint16_t)Value, &OutBuffer[6], 10);	// sprintf(&OutBuffer[6],"%d%c",Value,(char)0);
#endif

  Length = strlen(&OutBuffer[6]);

#ifdef LONG_OUTPUT
 #ifdef NO_NANO
  if ((Length > (4+Offset))  && (Index != 0))
 #else
  if (Length > (4+Offset)) 
 #endif
    {
      Index++;			/* take next prefix for better readable string */
      Offset += 3;		/* decimal point 3 to the left */
    }
#endif

#ifdef NO_NANO
  if (Index == 2)
    { /* use no nano, prefix 'f','p','n','u','m',' ','k','M' */
      Index++;				/* use mikro instead of nano */
      Offset += 3;			/* can be 3,4 or 5 */
    }
#endif

  Prefix = MEM_read_byte((unsigned char *)(&PrefixTab[Index]));   /* look up prefix in table */

  /*

   *  display value

   */


  /* position of dot */
  if (((xdigits & 0x10) != 0) && (digits > Length)) {
     Rshift = (digits - Length);	// use previous filled '0' characters
  } else {
     Rshift = 0;
  }

  Exponent = (Length + Rshift) - Offset;		/* calculate position */

  if (Exponent <= 0)			/* we have to prepend "0." */
  {
    /* 0: factor 10 / -1: factor 100 */
//    lcd_data('0');
    lcd_data('.');

#if 0
#ifdef NO_NANO
    while (Exponent < 0)
      {
       lcd_data('0');	/* extra 0 for factor 10 */
       Exponent++;
      }
#else
    if (Exponent < 0) lcd_data('0');	/* extra 0 for factor 100 */
#endif
#else
    Rshift = Offset - Length;
#endif
  }



  if (Offset == 0) Exponent = -8;	/* disable dot if not needed */



  /* adjust position to array or disable dot if set to 0 */

//  Exponent--;


  /* display value and add dot if requested */
  Index = 0;
  while (Index < (Length+Rshift))		/* loop through string */
  {
    lcd_data(OutBuffer[Index+6-Rshift]);		/* display char */
    Index++;				/* next one */
    if (Index == Exponent) {
      lcd_data('.');			/* display dot */
    }
  }



  /* display prefix and unit */

  if (Prefix != 0) {
     lcd_data(Prefix);
  }

  if (Unit != 0) {
      lcd_data(Unit);
  }
  return;
}

void DisplayValue16(uint16_t Value, int8_t Exponent, unsigned char Unit, uint8_t digits)
{
 DisplayValue((signed long)Value, Exponent, Unit, digits);
}

void Display_mV(uint16_t xx, uint8_t ll) {
 DisplayValue((long)xx,-3,'V',ll);
}
#if defined(WITH_MENU) || defined(WITH_XTAL)
void Display_Hz(unsigned long xx, uint8_t dd) {
 DisplayValue(xx,0,'H',dd);
 lcd_data('z');
 lcd_space();
}
#endif


DisplayValue.ino

/*
#include <avr/io.h>
#include <avr/eeprom.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/


// check some EEprom values for correct values 
void EE_check_init(void) {
#if (!defined(SamplingADC)  || (PROCESSOR_TYP != 328)) && !defined(USE_EEPROM)
  uint8_t tt;		// read test value
  tt = (uint8_t)eeprom_read_byte(&EE_ESR_ZEROtab[0]);
  // this value will never be changed by calibration
  if (tt != ESR_ZERO) goto init_ee;
 #ifdef AUTO_CAL
  uint8_t tt0;		// value of first c_zero_tab
  uint8_t ww;		// loop counter
  tt0 = tt;			// init tt0 value
  for (ww=0;ww<7;ww++) {		//checking loop
      tt = (uint8_t)eeprom_read_byte(&c_zero_tab[ww]);
      if (ww == 0) tt0 = tt;		// save first value
      // for forth element, tt must be tt0 or tt0+1
      if ((ww == 3) && ((tt != tt0) && (tt != (tt0+1)) && (tt != (tt0+2)) )) goto init_ee;
      if ((tt > 190) || (tt < 10)) goto init_ee;	// value too low or too big
  }
 #endif
 return;

init_ee:
 // init all EEprom values
 lcd_line1();
 lcd_data('E');
 lcd_data('E');
 #ifdef AUTO_CAL
 // write the correction value for ADC internal 1.1V reference 
 (void) eeprom_write_byte((uint8_t *)(&RefDiff), (uint8_t)REF_R_KORR);	// offset for true reference Voltage
 // write the correction value for comparator 1.1V reference
 (void) eeprom_write_word((uint16_t *)(&ref_offset), REF_C_KORR);	// hold zero offset + slew rate dependend offset
 // write all 7 c_zero_tab values
 (void) eeprom_write_word((uint16_t *)(&c_zero_tab[0]),((C_NULL)*256) + (C_NULL));
 (void) eeprom_write_byte((uint8_t *)(&c_zero_tab[2]),(C_NULL+TP2_CAP_OFFSET));
 (void) eeprom_write_byte((uint8_t *)(&c_zero_tab[3]),(C_NULL+2));
 (void) eeprom_write_byte((uint8_t *)(&c_zero_tab[4]),(C_NULL+TP2_CAP_OFFSET));
 (void) eeprom_write_word((uint16_t *)(&c_zero_tab[5]),((C_NULL)*256) + (C_NULL));
 #endif
 // write 4 EE_ESR_ZEROtab values
 (void) eeprom_write_word((uint16_t *)(&EE_ESR_ZEROtab[0]),(ESR_ZERO*256)+ESR_ZERO);
 (void) eeprom_write_word((uint16_t *)(&EE_ESR_ZEROtab[2]),(ESR_ZERO*256)+ESR_ZERO);
 #if ((LCD_ST_TYPE == 7565) || (LCD_ST_TYPE == 1306))
 (void) eeprom_write_byte((uint8_t *)(&EE_Volume_Value), VOLUME_VALUE);
 #endif
 #ifdef WITH_ROTARY_SWITCH
// (void) eeprom_write_byte(&EE_RotarySwitch,0); 		// no switch is detected
 #endif
 wait_about1s();	// time to read the "EE" message, initialization of EEprom finished
#endif
}


EE_check_init.ino

/*
#include <avr/io.h>
#include <avr/pgmspace.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/


// first discharge any charge of capacitors
void EntladePins() {
  uint8_t adc_gnd;		// Mask of ADC-outputs, which can be directly connected to GND
  unsigned int adcmv[3];	// voltages of 3 Pins in mV
  unsigned int clr_cnt;		// Clear Counter
  uint8_t lop_cnt;		// loop counter
// max. time of discharge in ms  (10000/20) == 10s
#define MAX_ENTLADE_ZEIT  (10000/20)
#if DebugOut == 99
  uart_putc('L');		//Debug
#endif
  for(lop_cnt=0;lop_cnt<10;lop_cnt++) {
     adc_gnd = TXD_MSK;		// put all ADC to Input
     ADC_DDR = adc_gnd;
     ADC_PORT = TXD_VAL;		// ADC-outputs auf 0
     R_PORT = 0;			// R-outputs auf 0
//     R_DDR = (1<<PIN_RH3) | (1<<PIN_RH2) | (1<<PIN_RH1); // R_H for all Pins to GND
     R_DDR = (1<<PIN_RH3) | (1<<PIN_RL3) | (1<<PIN_RH2) | (1<<PIN_RL2) | (1<<PIN_RH1) | (1<<PIN_RL1); // R_H and R_L for all Pins to GND
     adcmv[0] = W5msReadADC(TP1);	// which voltage has Pin 1?
     adcmv[1] = ReadADC(TP2);	// which voltage has Pin 2?
     adcmv[2] = ReadADC(TP3);	// which voltage has Pin 3?
#if DebugOut == 99
        lcd_line3();
        uart_putc('T');
        u2lcd_space(adcmv[0]);	// lcd_string(utoa(adcmv[0], outval, 10)); lcd_space();
        u2lcd_space(adcmv[1]);	// lcd_string(utoa(adcmv[1], outval, 10)); lcd_space();
        u2lcd(adcmv[2]);		// lcd_string(utoa(adcmv[2], outval, 10));
        wait2s();
#endif
     if ((PartFound == PART_CELL) || ((adcmv[0] < CAP_EMPTY_LEVEL) && (adcmv[1] < CAP_EMPTY_LEVEL) && (adcmv[2] < CAP_EMPTY_LEVEL))) {
        ADC_DDR = TXD_MSK;		// switch all ADC-Pins to input
        R_DDR = 0;			// switch all R_L Ports (and R_H) to input
#if FLASHEND > 0x3fff
        cell_mv[0] = adcmv[0];		// save the voltage of pin 1
        cell_mv[1] = adcmv[1];		// save the voltage of pin 2
        cell_mv[2] = adcmv[2];		// save the voltage of pin 3
#endif
#if DebugOut == 99
        uart_putc('l');		//Debug
#endif
        return;			// all is discharged
     }
     // all Pins with voltage lower than 1V can be connected directly to GND (ADC-Port)
     if (adcmv[0] < 1000) {
        adc_gnd |= (1<<TP1);	//Pin 1 directly to GND
     }
     if (adcmv[1] < 1000) {
        adc_gnd |= (1<<TP2);	//Pin 2 directly to GND
     }
     if (adcmv[2] < 1000) {
        adc_gnd |= (1<<TP3);	//Pin 3 directly to  GND
     }
     ADC_DDR = adc_gnd;		// switch all selected ADC-Ports at the same time

     // additionally switch the leaving Ports with R_L to GND.
     // since there is no disadvantage for the already directly switched pins, we can
     // simply switch all  R_L resistors to GND
//     R_DDR = (1<<PIN_RL3) | (1<<PIN_RL2) | (1<<PIN_RL1);	// Pins across R_L resistors to GND
     for(clr_cnt=0;clr_cnt<MAX_ENTLADE_ZEIT;clr_cnt++) {
        wdt_reset();
        adcmv[0] = W20msReadADC(TP1);	// which voltage has Pin 1?
        adcmv[1] = ReadADC(TP2);	// which voltage has Pin 2?
        adcmv[2] = ReadADC(TP3);	// which voltage has Pin 3?
        if (adcmv[0] < 1300) {
           ADC_DDR |= (1<<TP1);	// below 1.3V , switch directly with ADC-Port to GND
        }
        if (adcmv[1] < 1300) {
           ADC_DDR |= (1<<TP2);	// below 1.3V, switch directly with ADC-Port to GND
        }
        if (adcmv[2] < 1300) {
           ADC_DDR |= (1<<TP3);	// below 1.3V, switch directly with ADC-Port to GND
        }
        if ((adcmv[0] < (CAP_EMPTY_LEVEL+2)) && (adcmv[1] < (CAP_EMPTY_LEVEL+2)) && (adcmv[2] < (CAP_EMPTY_LEVEL+2))) {
           break;
        }
     }
     if (clr_cnt == MAX_ENTLADE_ZEIT) {
        PartFound = PART_CELL;	// mark as Battery
        // there is charge on capacitor, warn later!
     }
#if DebugOut == 99
        lcd_line4();
        u2lcd_space(adcmv[0]);	// lcd_string(utoa(adcmv[0], outval, 10)); lcd_space();
        u2lcd_space(adcmv[1]);	// lcd_string(utoa(adcmv[1], outval, 10)); lcd_space();
        u2lcd(adcmv[2]);		// lcd_string(utoa(adcmv[2], outval, 10));
#endif
     for(adcmv[0]=0;adcmv[0]<clr_cnt;adcmv[0]++) {
        // for safety, discharge 5% of discharge  time
        wait1ms();
     }
  } // end for lop_cnt
#if DebugOut == 99
  uart_putc('x');		//Debug
#endif
 }


EntladePins.ino

#if (LCD_GRAPHIC_TYPE != 0)


#if defined(FONT_5X8) || defined(FONT_5x8) 
   #define FONT_WIDTH 6
   #define FONT_HEIGHT 8
   #include "fonts/5x8_vertikal_LSB_1.h"   //******Font_5x8 (create by mike0815 *** 23-09-2015 )
 #define FONT_SELECTED
 #endif
 

 #if defined(FONT_6X8) || defined (FONT_6x8)
  #define FONT_WIDTH 6
  #define FONT_HEIGHT 8
  #include "fonts/6x8_vertikal_LSB_1.h"
  #define FONT_SELECTED
 #endif

 #if defined(FONT_8X16) || defined(FONT_8x16) 
  #ifdef FONT_SELECTED
   #warning Multiple fonts selected, please select only one!
  #else
   #define FONT_SELECTED
   #define FONT_WIDTH 8
   #define FONT_HEIGHT 16
   #include "fonts/8x16_vertikal_LSB_1.h"
  #endif
 #endif

 #if defined(FONT_8X16thin) || defined(FONT_8x16thin) 
  #ifdef FONT_SELECTED
   #warning Multiple fonts selected, please select only one!
  #else
   #define FONT_SELECTED
   #define FONT_WIDTH 8
   #define FONT_HEIGHT 16
   #include "fonts/8x16_vertikal_LSB_1thin.h"
  #endif
 #endif

 #if defined(FONT_8X15) || defined(FONT_8x15) 
  #ifdef FONT_SELECTED
   #warning Multiple fonts selected, please select only one!
  #else
   #define FONT_SELECTED
   #define FONT_WIDTH 8
   #define FONT_HEIGHT 15
   #include "fonts/8x15_vertikal_LSB_1.h"
  #endif
 #endif

 #if defined(FONT_8X14) || defined(FONT_8x14) 
  #ifdef FONT_SELECTED
   #warning Multiple fonts selected, please select only one!
  #else
   #define FONT_SELECTED
   #define FONT_WIDTH 8
   #define FONT_HEIGHT 14
   #include "fonts/8x14_vertikal_LSB_1.h"
  #endif
 #endif

 #if defined(FONT_8X12) || defined(FONT_8x12) 
  #ifdef FONT_SELECTED
   #warning Multiple fonts selected, please select only one!
  #else
   #define FONT_SELECTED
   #define FONT_WIDTH 8
   #define FONT_HEIGHT 12
   #include "fonts/8x12_vertikal_LSB_1.h"
  #endif
 #endif

 #if defined(FONT_8X12thin) || defined(FONT_8x12thin) 
  #ifdef FONT_SELECTED
   #warning Multiple fonts selected, please select only one!
  #else
   #define FONT_SELECTED
   #define FONT_WIDTH 8
   #define FONT_HEIGHT 12
   #include "8x12_vertikal_LSB_1thin.h"
  #endif
 #endif

 #if defined(FONT_7X12) || defined(FONT_7x12) 
  #ifdef FONT_SELECTED
   #warning Multiple fonts selected, please select only one!
  #else
   #define FONT_SELECTED
   #define FONT_WIDTH 7
   #define FONT_HEIGHT 12
   #include "7x12_vertical_LSB_1.h"
  #endif
 #endif

 #if defined(FONT_8X8) || defined(FONT_8x8) 
  #ifdef FONT_SELECTED
   #warning Multiple fonts selected, please select only one!
  #else
   #define FONT_SELECTED
   #define FONT_WIDTH 8
   #define FONT_HEIGHT 8
   #include "fonts/8x8_vertikal_LSB_1.h"
  #endif
 #endif

 #ifndef FONT_SELECTED
   #warning No Font specified. Check Makefile!
   #define FONT_WIDTH 6
   #define FONT_HEIGHT 8
   #include "6x8_vertikal_LSB_1.h"
   #define FONT_SELECTED
 #endif

#endif /* LCD_GRAPHIC_TYPE != 0 */


font.h

function_menu.ino

/*
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/


// get_log interpolate a table with the function -1000*log(1 - (permil/1000))
uint16_t get_log(uint16_t permil) {
// for remember:
// uint16_t LogTab[] PROGMEM = {0, 20, 41, 62, 83, 105, 128, 151, 174, 198, 223, 248, 274, 301, 329, 357, 386, 416, 446, 478, 511, 545, 580, 616, 654, 693, 734, 777, 821, 868, 916, 968,1022,1079,1139,1204,1273,1347,1427,1514,1609,1715,1833,1966,2120,2303,2526,2813,3219,3912,9210};


#define Log_Tab_Distance 20              // displacement of table is 20 mil

  uint16_t y1, y2;			// table values
  uint16_t result;			// result of interpolation
  uint8_t tabind;			// index to table value
  uint8_t tabres;			// distance to lower table value, fraction of Log_Tab_Distance

  tabind = permil / Log_Tab_Distance;	// index to table
  tabres = permil % Log_Tab_Distance;	// fraction of table distance
  // interpolate the table of factors
  y1 = pgm_read_word(&LogTab[tabind]);	// get the lower table value
  y2 = pgm_read_word(&LogTab[tabind+1]); // get the higher table value
  result = ((y2 - y1) * tabres ) / Log_Tab_Distance + y1; // interpolate
  return(result);
 }


get_log.ino

//#include <avr/io.h>
//#include <stdlib.h>
//#include "Transistortester.h"
//#warning Please use the tome optimized Assembler version of GetESR

#include "wait1000ms.h"

#define MAX_CNT 255

/* The sleep mode for ADC can be used. It is implemented for 8MHz and 16MHz operation */
/* But the ESR result is allways higher than the results with wait mode. */
/* The time of ESR measurement is higher with the sleep mode (checked with oszilloscope) */
/* The reason for the different time is unknown, the start of the next ADC measurement */
/* should be initiated before the next ADC-clock (8 us). One ADC takes 13 ADC clock + 1 clock setup. */
/* The setting to sleep mode takes 10 clock tics, the wakeup takes about 24 clock tics, but 8us are 64 clock tics. */
/* I have found no reason, why a reset of the ADC clock divider should occur during ESR measurement. */ 
//#define ADC_Sleep_Mode

#define ESR_DEBUG

#ifdef ADC_Sleep_Mode
//  #define StartADCwait() ADCSRA = (1<<ADEN) | (1<<ADIF) | (1<<ADIE) | AUTO_CLOCK_DIV; /* enable ADC and Interrupt */
//  #define StartADCwait() set_sleep_mode(SLEEP_MODE_ADC);
//    sleep_mode()		/* Start ADC, return if ADC has finished */
    #define StartADCwait() sleep_cpu()
#else
//  #define StartADCwait() ADCSRA = (1<<ADSC) | (1<<ADEN) | (1<<ADIF) | AUTO_CLOCK_DIV; /* enable ADC and start */
    #define StartADCwait() ADCSRA = (1<<ADSC)|(1<<ADEN)|(1<<ADIF)|AUTO_CLOCK_DIV; /* Start conversion */\
    while (ADCSRA & (1 << ADSC))  /* wait until conversion is done */
#endif

/************************************************************************/
/* Predefine the wait time for switch off the load current for big caps */
/************************************************************************/
//         wdt_reset();		// with wdt_reset the timing can be adjusted,
				// when time is too short, voltage is down before SH of ADC
				// when time is too long, capacitor will be overloaded.
				// That will cause too high voltage without current.
#ifdef ADC_Sleep_Mode
            /* Interrupt mode, big cap */
 #if F_CPU == 8000000UL
    #define DelayBigCap() wait30us();	/* 2.5 ADC clocks = 20us */ \
           wait1us();		/*  */ \
           wait1us();	/* with only 17 us delay the voltage goes down before SH */ \
            /* delay 17us + 3 clock tics (CALL instead of RCALL) = 17.375 us @ 8 MHz */ \
            /* + 21 clock tics delay from interrupt return, +2.625us = 20.0 */	\
            wdt_reset();	/* 20.125 us  */ \
            wdt_reset()		/* 20.25  us  */
 #endif
 #if F_CPU == 16000000UL
    #define DelayBigCap() wait10us();	/* 2.5 ADC clocks = 20us */ \
           wait5us();		/*  */ \
           wait3us();	/* with only 18 us delay the voltage goes down before SH */ \
            /* delay 18us + 3 clock tics (CALL instead of RCALL) = 18.1875 us */ \
            /* + 21 clock tics delay from interrupt return, +1.3125us = 19.5 */ \
            wait500ns(); 	/* 20.0626us   */ \
            wdt_reset();	/* 20.125 us  */ \
            wdt_reset();	/* 20.1875us  */ \
            wdt_reset()		/* 20.25  us  */
 #endif
#else
            /* Polling mode, big cap */
 #if F_CPU == 8000000UL
    #define DelayBigCap() wait20us();	/* 2.5 ADC clocks = 20us */ \
           wait5us();		/*  */ \
           wait2us();	/* pulse length 27.375 us */ 
//	   wdt_reset(); 
            /* delay 19us + 3 clock tics (CALL instead of RCALL) = 19.375 us @ 8 MHz */ 
            /* + 7 clock tics delay from while loop, +0.875us  = 20.25 */ 
 //             wdt_reset()	/* 20.375 us + */
 #endif
 #if F_CPU == 16000000UL
    #define DelayBigCap() wait10us();	/* 2.5 ADC clocks = 20us */ \
           wait5us();		/*  */ \
           wait4us();	/* with only 18 us delay the voltage goes down before SH */ \
         /* delay 19us + 3 clock tics (CALL instead of RCALL) = 19.1875 us */ \
         /* + 7 clock tics delay from "while (ADCSRA&(1<<ADSC))" loop = 19.625 */ \
            wait500ns(); 	/* 20.1875us   */ 
//            wdt_reset();	/* 20.250 us + */ 
//            wdt_reset()		/* 20.3125us + */
 #endif
#endif

/************************************************************************/
/* Predefine the wait time for switch off the load current for small caps */
/************************************************************************/
      	/* SH at 2.5 ADC clocks behind start = 5 us */
#ifdef ADC_Sleep_Mode
            /* Interrupt mode, small cap */
 #if F_CPU == 8000000UL
    #define DelaySmallCap() wait2us();	/* with only 4 us delay the voltage goes down before SH */ \
            /* delay 2us + 1 clock tics (CALL instead of RCALL) = 2.125 us @ 8 MHz */ \
            /* + 21 clock tics delay from interrupt return, +2.625us = 4.75 */ \
            wdt_reset();	/* 4.8750 us  */ \
            wdt_reset();	/* 5.0    us  */ \
            wdt_reset()		/* 5.125  us  */
 #endif
 #if F_CPU == 16000000UL
    #define DelaySmallCap() wait3us();	/* with only 18 us delay the voltage goes down before SH */ \
            /* delay 3us + 1 clock tics (CALL instead of RCALL) = 3.0625 us */ \
            /* + 21 clock tics delay from interrupt return, +1.3125us = 4.375 */ \
            wdt_reset();	/* 4.4375 us  */ \
            wait500ns(); 	/* 5.0    us  */ \
            wdt_reset();	/* 5.0625 us  */ \
            wdt_reset()		/* 5.1250 us  */ 
 #endif
#else
            /* Polling mode, small cap */
 #if F_CPU == 8000000UL
    #define DelaySmallCap() wait5us();	/* with only 4 us delay the voltage goes down before SH */ \
            /* delay 4us + 1 clock tics (CALL instead of RCALL) = 4.125 us @ 8 MHz */ \
            /* + 7 clock tics delay from while loop, +0.875us  = 5.000 */ 
//            wdt_reset()		/* 5.125 us   */
 #endif
 #if F_CPU == 16000000UL
    #define DelaySmallCap() wait4us();	/* with only 4 us delay the voltage goes down before SH */ \
            /* delay 4us + 1 clock tics (CALL instead of RCALL) = 4.0625 us */ \
            /* + 7 clock tics delay from "while (ADCSRA&(1<<ADSC))" loop, +0.4375 = 4.5000 */ \
            wait500ns(); 	/* 5.0625 us  */ \
            wdt_reset()		/* 5.1250 us  */ 
 #endif
#endif

//=================================================================
uint16_t GetESR(uint8_t hipin, uint8_t lopin) {
#if FLASHEND > 0x1fff
  //  measure the ESR value of capacitor
  unsigned int adcv[4];		// array for 4 ADC readings
  unsigned long sumvolt[4];	// array for 3 sums of ADC readings
  unsigned long cap_val_nF;	// measured capacity value in nF units
  uint16_t esrvalue;
  uint8_t HiPinR_L;		// used to switch 680 Ohm to HighPin
  uint8_t HiADC;		// used to switch Highpin directly to GND or VCC
  uint8_t LoPinR_L;		// used to switch 680 Ohm to LowPin
  uint8_t LoADC;		// used to switch Lowpin directly to GND or VCC
  uint8_t ii;			// tempory value
  int8_t pp;			// tempory prefix
  uint8_t StartADCmsk;		// Bit mask to start the ADC
  uint8_t SelectLowPin,SelectHighPin;
  int8_t esr0;			// used for ESR zero correction

  cap_val_nF = 32000;
  if (PartFound == PART_CAPACITOR) {
     pp = cap.cpre_max;
     if (cap.cval_max < 0) cap_val_nF = -cap.cval_max;
     else                  cap_val_nF =  cap.cval_max;
     cap_val_nF = cap.cval_max;
     while (pp < -9) { // set cval to nF unit
         cap_val_nF /= 10;		// reduce value by factor ten
         pp++;		// take next decimal prefix
     }
#ifdef ESR_LONG_PULSE
     if (cap_val_nF < (1800/10)) return(0xffff);			//capacity lower than 0.18 uF
#else
     if (cap_val_nF < (900/10)) return(0xffff);			//capacity lower than 90 nF
#endif
     if ((pp > -9) || (cap_val_nF > 32000)) {
        // limit cap_val_nF to prevent overflow
        cap_val_nF = 32000;
     }
#ifdef ADC_Sleep_Mode
        StartADCmsk = (1<<ADEN) | (1<<ADIF) | (1<<ADIE) | AUTO_CLOCK_DIV; /* enable ADC and Interrupt */
        ADCSRA = StartADCmsk;		/* enable ADC and Interrupt */
#else
        StartADCmsk =  (1<<ADSC) | (1<<ADEN) | (1<<ADIF) | AUTO_CLOCK_DIV; /* enable and start ADC */
#endif

  }
#if (((PIN_RL1 + 1) != PIN_RH1) || ((PIN_RL2 + 1) != PIN_RH2) || ((PIN_RL3 + 1) != PIN_RH3))
  LoADC = pgm_read_byte((&PinRLRHADCtab[6])+lopin-TP_MIN) | TXD_MSK;
  HiADC = pgm_read_byte((&PinRLRHADCtab[6])+hipin-TP_MIN) | TXD_MSK;
#else
  LoADC = pgm_read_byte((&PinRLRHADCtab[3])+lopin-TP_MIN) | TXD_MSK;
  HiADC = pgm_read_byte((&PinRLRHADCtab[3])+hipin-TP_MIN) | TXD_MSK;
#endif
  LoPinR_L = pgm_read_byte(&PinRLRHADCtab[lopin-TP_MIN]);  //R_L mask for LowPin R_L load
  HiPinR_L = pgm_read_byte(&PinRLRHADCtab[hipin-TP_MIN]);	//R_L mask for HighPin R_L load

#if (PROCESSOR_TYP == 644) || (PROCESSOR_TYP == 1280)
    /* ATmega640/1280/2560 1.1V Reference with REFS0=0 */
  SelectLowPin = (lopin | (1<<REFS1) | (0<<REFS0));	// switch ADC to LowPin, Internal Ref. 
  SelectHighPin = (hipin | (1<<REFS1) | (0<<REFS0));	// switch ADC to HighPin, Internal Ref. 
#else
  SelectLowPin = (lopin | (1<<REFS1) | (1<<REFS0));	// switch ADC to LowPin, Internal Ref. 
  SelectHighPin = (hipin | (1<<REFS1) | (1<<REFS0));	// switch ADC to HighPin, Internal Ref. 
#endif


// Measurement of ESR of capacitors AC Mode
   sumvolt[0] = 1;		// set sum of LowPin voltage to 1 to prevent divide by zero
   sumvolt[2] = 1;		// clear sum of HighPin voltage with current
                                // offset is about (x*10*200)/34000 in 0.01 Ohm units
   sumvolt[1] = 0;		// clear sum of HighPin voltage without current
   sumvolt[3] = 0;		// clear sum of HighPin voltage without current
   EntladePins();		// discharge capacitor
   ADC_PORT = TXD_VAL;		// switch ADC-Port to GND
   ADMUX = SelectLowPin;	// set Mux input and Voltage Reference to internal 1.1V
#ifdef NO_AREF_CAP
   wait100us();			/* time for voltage stabilization */
#else
   wait_about10ms();		/* time for voltage stabilization with 100nF */
#endif
   /* start voltage must be negativ */
   ADC_DDR = HiADC;				// switch High Pin to GND
   R_PORT = LoPinR_L;			// switch R-Port to VCC
   R_DDR = LoPinR_L;			// switch R_L port for HighPin to output (VCC)
   wait10us();
   wait2us();
   R_DDR = 0;				// switch off current
   R_PORT = 0;
   StartADCwait();				// set ADCSRA Interrupt Mode, sleep

   // Measurement frequency is given by sum of ADC-Reads < 680 Hz for normal ADC speed.
   // For fast ADC mode the frequency is below 2720 Hz (used for capacity value below 3.6 uF).
   // ADC Sample and Hold (SH) is done 1.5 ADC clock number after real start of conversion.
   // Real ADC-conversion is started with the next ADC-Clock (125kHz) after setting the ADSC bit.
   for(ii=0;ii<MAX_CNT;ii++) {
      ADC_DDR = LoADC;				// switch Low-Pin to output (GND)
      R_PORT = LoPinR_L;			// switch R-Port to VCC
      R_DDR = LoPinR_L;			// switch R_L port for LowPin to output (VCC)
      ADMUX = SelectLowPin;
      StartADCwait();			// set ADCSRA Interrupt Mode, sleep
      StartADCwait();			// set ADCSRA Interrupt Mode, sleep
      adcv[0] = ADCW;			// Voltage LowPin with current
      ADMUX = SelectHighPin;
         StartADCwait();			// ADCSRA = (1<<ADEN) | (1<<ADIF) | (1<<ADIE) | AUTO_CLOCK_DIV;	
         ADCSRA = (1<<ADSC) | (1<<ADEN) | (1<<ADIF) | AUTO_CLOCK_DIV; // enable ADC and start with ADSC
         wait4us();
         R_PORT = HiPinR_L;			// switch R-Port to VCC
         R_DDR = HiPinR_L;			// switch R_L port for HighPin to output (VCC)
         DelayBigCap();		// wait predefined time
      R_DDR = 0;				// switch current off,  SH is 1.5 ADC clock behind real start
      R_PORT = 0;
      while (ADCSRA&(1<<ADSC));		// wait for conversion finished
      adcv[1] = ADCW;			// Voltage HighPin with current
#ifdef ADC_Sleep_Mode
      ADCSRA = StartADCmsk;		/* enable ADC and Interrupt */
#endif
      wdt_reset();
      /* ********* Reverse direction, connect High side with GND *********** */
      ADC_DDR = HiADC;				// switch High Pin to GND
      R_PORT = HiPinR_L;			// switch R-Port to VCC
      R_DDR = HiPinR_L;			// switch R_L port for HighPin to output (VCC)
      wdt_reset();
      ADMUX = SelectHighPin;
      StartADCwait();			// set ADCSRA Interrupt Mode, sleep
      StartADCwait();			// set ADCSRA Interrupt Mode, sleep
      adcv[2] = ADCW;			// Voltage HighPin with current
      ADMUX = SelectLowPin;
         StartADCwait();			// set ADCSRA Interrupt Mode, sleep
         ADCSRA = (1<<ADSC) | (1<<ADEN) | (1<<ADIF) | AUTO_CLOCK_DIV; // enable ADC and start with ADSC
         wait4us();
         R_PORT = LoPinR_L;
         R_DDR = LoPinR_L;			// switch LowPin with 680 Ohm to VCC
         DelayBigCap();		// wait predefined time
      R_DDR = 0;				// switch current off
      R_PORT = 0;
      while (ADCSRA&(1<<ADSC));		// wait for conversion finished
      adcv[3] = ADCW;			//  Voltage LowPin with current
#ifdef ADC_Sleep_Mode
      ADCSRA = StartADCmsk;		/* enable ADC and Interrupt */
#endif
      sumvolt[0] += adcv[0];			// add sum of both LowPin voltages with current
      sumvolt[1] += adcv[1];			// add  HighPin voltages with current
      sumvolt[2] += adcv[2];			// add  LowPin voltages with current
      sumvolt[3] += adcv[3];			// add  HighPin voltages with current
   } // end for


   sumvolt[0] += sumvolt[2];
#ifdef ESR_DEBUG
   lcd_testpin(hipin);
   lcd_testpin(lopin);
   lcd_data(' ');
   DisplayValue(sumvolt[0],0,'L',4);	// LowPin 1
   lcd_line3();
   DisplayValue(sumvolt[1],0,'h',4);	// HighPin 1
   lcd_data(' ');
   DisplayValue(sumvolt[3],0,'H',4);	// LowPin 2
   lcd_line4();
#endif


   if ((sumvolt[1] + sumvolt[3]) > sumvolt[0]) {
      sumvolt[2] = (sumvolt[1] + sumvolt[3]) - sumvolt[0];	// difference HighPin - LowPin Voltage with current
   } else {
      sumvolt[2] = 0;
   }
  if (PartFound == PART_CAPACITOR) {
      sumvolt[2] -= (1745098UL*MAX_CNT) / (cap_val_nF * (cap_val_nF + 19));
  }

#ifdef ESR_DEBUG
   DisplayValue(sumvolt[2],0,'d',4);	// HighPin - LowPin
   lcd_data(' ');
#endif
   esrvalue = (sumvolt[2] * 10 * (unsigned long)RRpinMI) / (sumvolt[0]+sumvolt[2]);
   esrvalue += esrvalue / 14;		/* esrvalue + 7% */
   esr0 = (int8_t)eeprom_read_byte(&EE_ESR_ZEROtab[hipin-TP_MIN+lopin-TP_MIN]);
   if (esrvalue > esr0) {
      esrvalue -= esr0;
   } else {
#ifdef AUTO_CAL
      if (((esrvalue + R_LIMIT_TO_UNCALIBRATED) < esr0) && (cap_val_nF > 4500)) {
         mark_as_uncalibrated();
      }
#endif
      esrvalue = 0;
   }


 #ifdef ADC_Sleep_Mode
     SMCR = (0 << SM0) | (0 << SE);	/* clear ADC Noise Reduction and Sleep Enable */
 #endif
  return (esrvalue);
#else
  return (0);
#endif
}


GetESR.ino

// new code by K.-H. Kübbeler

/*
#include <avr/io.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
#include "config.h" //J-L
*/

//=================================================================
// measure frequency at external pin T0 (PD4@mega328 or PB0@mega644) with Counter 0
//   for mega1280 or mega2560 the T3 (PE6) is used with Counter 3
#if F_CPU > 12000000
 #define FMAX_PERIOD 50020
#else
// #define FMAX_PERIOD 25050
 #define FMAX_PERIOD 33010
#endif
#define FMAX_INPUT 2004000
#define FREQ_DIV 16

#if PROCESSOR_TYP == 1280
 #define PCINTx_vect INT6_vect
#elif PROCESSOR_TYP == 644
 /* Pin change interrupt is PCINT8 (PB0) */
 #define PCI_ENABLE_BIT PCIE1
 #define PCI_CLEAR_BIT PCIF1
 #define PCINTx_vect PCINT1_vect
#else
 /* Pin change interrupt is PCINT20 (PD4) */
 #define PCI_ENABLE_BIT PCIE2
 #define PCI_CLEAR_BIT PCIF2
 #define PCINTx_vect PCINT2_vect
#endif

#if defined(WITH_MENU) && !defined(NO_FREQ_COUNTER)

void GetFrequency(uint8_t range) {
  unsigned char taste;			// set if key is pressed during measurement
 #if PROCESSOR_TYP == 644
  unsigned long freq_count;		// the counted pulses in 1 second
 #endif
  unsigned long long ext_period;
  unsigned long freq_from_per;
  uint8_t ii;
  uint8_t mm;
  /* range has set the lowest bit to use the 16:1 frequency divider permanently. */
  /* The upper bits of range specifies the input selection. */
  /* 0 = external input, 2 = channel 2, 4 = HF Quartz, 6 = LF Quartz */
  
 #if PROCESSOR_TYP == 644
  FDIV_DDR |= (1<<FDIV_PIN);		//switch to output
  if ((range & 0x01) == 0) {
     FDIV_PORT &= ~(1<<FDIV_PIN);	// switch off the 16:1 divider
  } else {
     FDIV_PORT |= (1<<FDIV_PIN);	// use frequency divider for next measurement
  }
  FINP_DDR |= (1<<FINP_P0) | (1<<FINP_P1);	// switch both pins to output

 FINP_PORT &= ~(1<<FINP_P0);		// clear lower bit of input selection
 FINP_PORT &= ~(1<<FINP_P1);		// clear higher bit of input selection
 if (range == 0) {  
    message_key_released(FREQ_str);	// Frequency: in line 1
 } else if (range == 1) { 
    message_key_released(HFREQ_str);	// High Frequency: in line 1
 } else if (range < 4) { /* 2+3 */
    FINP_PORT |= (1<<FINP_P0);		// set lower bit of input selection
    FINP_PORT &= ~(1<<FINP_P1);		// clear higher bit of input selection
 } else if (range < 6) { /* 4+5 */
    FINP_PORT &= ~(1<<FINP_P0);		// clear lower bit of input selection
    FINP_PORT |= (1<<FINP_P1);		// set higher bit of input selection
    message_key_released(H_CRYSTAL_str);	// HF Quarz: in line 1
 } else {  /* 6+7 */
    FINP_PORT |= (1<<FINP_P0);		// set lower bit of input selection
    FINP_PORT |= (1<<FINP_P1);		// set higher bit of input selection
    message_key_released(L_CRYSTAL_str);	// LF Quarz: in line 1
 }

 #else
  message_key_released(FREQ_str);	// Frequency: in line 1
  #ifdef WITH_FREQUENCY_DIVIDER
  uint16_t freq_factor;
  freq_factor = (1<<eeprom_read_byte((uint8_t *)&f_scaler));
  if (freq_factor != 1) {
   #if LCD_LINE_LENGTH > 20
    #define SCALER_POSITION (20 - 5)	// not too wide right
   #else
    #define SCALER_POSITION (LCD_LINE_LENGTH - 5)
   #endif
     lcd_set_cursor(0 * PAGES_PER_LINE, SCALER_POSITION); 
     lcd_data('/');
     u2lcd(freq_factor);	// show the frequency scaler, if not 1
  }
  #endif	/* WITH_FREQUENCY_DIVIDER */
 #endif		/* PROCESSOR_TYP */
  taste = 0;				// reset flag for key pressed
  for (mm=0;mm<240;mm++) {
     // *************************************************************************
     // *********** straight frequency measurement by counting 1 second *********
     // *************************************************************************
     //set up Counter 0
     // Counter 0 is used to count the external signal connected to T0 (PD4 or PB0)
     FREQINP_DDR &= ~(1<<FREQINP_PIN);	// switch frequency pin to input
     wait1ms();				// let capacitor time to load to 2.4V input
#if PROCESSOR_TYP == 1280
     TCCR3A = 0; 			// normal operation, no output
     TCNT3 = 0;				// set counter 3 to zero
     ext_freq.dw = 0;			// set external frequency to zero
     TIFR3 = (1<<TOV3);			// clear OV interrupt of timer 3
     TIMSK3 = (1<<TOIE3);		// enable OV interrupt of timer 3
#else
     TCCR0A = 0; 			// normal operation, no output
     TCNT0 = 0;				// set counter to zero
     ext_freq.dw = 0;			// set external frequency to zero
     TIFR0 = (1<<TOV0);			// clear OV interrupt of timer 0
     TIMSK0 = (1<<TOIE0);		// enable OV interrupt of timer 0
#endif
     // start counter after starting second counter timer 1

     // set up counter 1 to measure one second
     TCCR1A = 0;			// normal operation
#define CNT1_END_VAL ((F_CPU / 256UL) + 1)
#define CNT1_DIVIDER (1<<CS12)
#if (CNT1_END_VAL > 0xffff) && (F_CPU == ((F_CPU / 1024UL) * 1024UL))
 #undef CNT1_END_VAL
 #undef CNT1_DIVIDER
 #define CNT1_END_VAL ((F_CPU / 1024UL) + 1)
 #define CNT1_DIVIDER ((1<<CS12) | (1<<CS10))
#else 
 #if F_CPU != ((F_CPU / 256UL) * 256UL)
  #warning F_CPU can not be divided by 256, measured frequency is wrong!
 #endif
#endif
     OCR1B = (CNT1_END_VAL & 0xffff);	// set to 1 second  (counter 0 is started with 1)
     OCR1A = 1;				// start counter 0 with first count
     TCNT1 = 0;				// set counter to zero
     GTCCR  |= (1<<PSRSYNC);		// reset clock precounter
     TIFR1 = (1<<OCF1B) | (1<<OCF1A);	// clear Output compare match
#if CNT1_END_VAL > 0xffff
     TIMSK1 =  (1<<OCIE1A);		// enable the Compare A match interrupt
#else
     TIMSK1 = (1<<OCIE1B) | (1<<OCIE1A);	// enable the Compare A match and Compare B match interrupt
#endif
     sei();				// set interrupt enable
     TCCR1B = CNT1_DIVIDER;		// divide CPU clock by 256, start counter
     // both counter are running now, wait for counter 1 reach OCR1A
     for (ii=0;ii<50;ii++) {
        wait20ms();			// first count of counter 1 (<32us) has started the counter 0
#if CNT1_END_VAL > 0xffff
        TIMSK1 &=  ~(1<<OCIE1A);	// disable the Compare A match interrupt
        if ((TIFR1 & (1<<TOV1)) != 0) {
          TIFR1 = (1<<OCF1B)|(1<<TOV1);		// reset TOV1 Overflow and Output compare B match Flag
          TIMSK1 = (1<<OCIE1B);		// enable the Compare B match interrupt
        }
#endif
        wdt_reset();
        if (!(RST_PIN_REG & (1<<RST_PIN))) taste = 1;	// user request stop of operation
#if PROCESSOR_TYP == 1280
        if (TCCR3B == 0) break;		// timer 3 is stopped by interrupt
#else
        if (TCCR0B == 0) break;		// timer 0 is stopped by interrupt
#endif
     }
     // one second is counted
#if PROCESSOR_TYP == 1280
     TCCR3B = 0;		// stop timer 3, if not stopped by timer 1 compare interrupt
     ext_freq.w[0] = TCNT3;	// add lower 16 bit to get total counts
#else
     TCCR0B = 0;		// stop timer 0, if not stopped by timer 1 compare interrupt
     ext_freq.b[0] = TCNT0;	// add lower 8 bit to get total counts
#endif
 #if PROCESSOR_TYP == 644
     freq_count = ext_freq.dw;	// save the frequency counter
 #endif
 #if (LCD_LINES > 3)
     lcd_line3();
     lcd_clear_line();
     lcd_line4();
     lcd_clear_line();
     lcd_clear_line2();
 #else
     lcd_clear();		// clear total display
 #endif
     lcd_data('f');
     lcd_equal();		// lcd_data('=');
 #if PROCESSOR_TYP == 644
     if ((FDIV_PORT&(1<<FDIV_PIN)) == 0) {
        Display_Hz(ext_freq.dw, 7);
        lcd_space();		// Frequency divider is not activ
     } else {
        // frequency divider is activ
        Display_Hz(ext_freq.dw*FREQ_DIV, 7);
        lcd_data('/');		// Frequency divider is activ
     }
     lcd_space();
 #else
     // ATmega328 ...
  #ifdef WITH_FREQUENCY_DIVIDER
     uint16_t freq_factor;
     freq_factor = (1<<eeprom_read_byte((uint8_t *)&f_scaler));
     Display_Hz(ext_freq.dw*freq_factor, 7);
  #else
     Display_Hz(ext_freq.dw, 7);
  #endif
 #endif  /* PROCESSOR_TYP 644 or other */
     FREQINP_DDR &= ~(1<<FREQINP_PIN);	// switch frequency pin to input
     if (TCCR1B != 0) {
       // Exact 1000ms period is only with "end of period" from timer1 interrupt.
       // When stopped with the for loop, the time is too long because wait call does not
       // respect CPU time used for interrupts and loop itself.
       // For this case show ? behind the Hz. 
       lcd_data('?');
     }
     TCCR1B = 0;		// stop timer 1
     TIMSK1 = 0;		// disable all timer 1 interrupts
     if ((ext_freq.dw < FMAX_PERIOD) && (ext_freq.dw > 0)) {
     // *************************************************************************
     // ******** Period measurement by counting some periods ******************** 
     // *************************************************************************
        pinchange_max = ((10 * (unsigned long)ext_freq.dw) + MHZ_CPU) / MHZ_CPU;	// about 10000000 clock tics
        pinchange_max += pinchange_max;	// * 2 for up and down change
        FREQINP_DDR &= ~(1<<FREQINP_PIN);	// switch frequency pin to input
        wait1ms();			// let capacitor time to load to 2.4V input
#if PROCESSOR_TYP == 1280
        TCNT3 = 0;			// set counter 3 to zero
        ext_freq.dw = 0;		// reset counter to zero
        TIFR3 = (1<<TOV3);		// clear OV interrupt
        TIMSK3 = (1<<TOIE3);		// enable OV interrupt
        // counter 3 ist started with first pin change interrupt
        pinchange_count = 0;
	EICRB = (0<<ISC61) | (1<<ISC60); // set int6 pin change
        EIFR  |= (1<<INTF6);		// clear interrupt 6 flag
        PCMSK_FREQ |= (1<<PCINT_FREQ); // enable int6
#else
        // other than PROCESSOR_TYP 1280
        TCNT0 = 0;			// set counter 0 to zero
        ext_freq.dw = 0;		// reset counter to zero
        TIFR0 = (1<<TOV0);		// clear OV interrupt
        TIMSK0 = (1<<TOIE0);		// enable OV interrupt
        // counter 0 ist started with first pin change interrupt
        pinchange_count = 0;
        PCIFR  = (1<<PCI_CLEAR_BIT);		// clear Pin Change Status
        PCICR  |= (1<<PCI_ENABLE_BIT);		// enable pin change interrupt
#endif  /* PROCESSOR_1280 or other */
        sei();
        PCMSK_FREQ |= (1<<PCINT_FREQ);	// monitor PD4 PCINT20 or PB0 PCINT8 pin change
        for (ii=0;ii<250;ii++) {
           wait20ms();
           wdt_reset();
           if (!(RST_PIN_REG & (1<<RST_PIN))) taste = 1;	// user request stop of operation
           if ((PCMSK_FREQ & (1<<PCINT_FREQ)) == 0) break;		// monitoring is disabled by interrupt
        } /* end for ii */
#if PROCESSOR_TYP == 1280
        TCCR3B = 0;		// stop counter 3
        PCMSK_FREQ &= ~(1<<PCINT_FREQ); // disable int6
        ext_freq.w[0] = TCNT3;		// add lower 16 bit to get total counts
#else
        TCCR0B = 0;		// stop counter 0
        PCMSK_FREQ &= ~(1<<PCINT_FREQ);		// stop monitor PD4 PCINT20 or PB0 PCINT8 pin change
        PCICR &= ~(1<<PCI_ENABLE_BIT);	// disable the interrupt
        ext_freq.b[0] = TCNT0;		// add lower 8 bit to get total counts
#endif
//        lcd_clear_line2();
//        wait50ms();		// let LCD flicker to 
//	---------------------------------------
//	Show the result from period measurement
//	---------------------------------------
 #if (LCD_LINES > 3)
        lcd_line3();		// use line3 to report the period with 4-line LCD
 #else
        lcd_line2();		// report period on line 2 of 2-line LCD
 #endif
        lcd_data('T');
        lcd_equal();		// lcd_data('=');
        ext_period = ((unsigned long long)ext_freq.dw * (200000/MHZ_CPU)) / pinchange_max;
 #if PROCESSOR_TYP == 644
        if ((FDIV_PORT&(1<<FDIV_PIN)) != 0) {
           // frequency divider is activ, period is measured too long
           ext_period = ext_period / FREQ_DIV;
        }
 #endif
 #if (PROCESSOR_TYP != 644) && defined(WITH_FREQUENCY_DIVIDER)
        ext_period /= freq_factor;
 #endif
        if (pinchange_max > 127) {
           DisplayValue(ext_period,-11,'s',7);	// show period converted to 0.01ns units
        } else {
           //prevent overflow of 32-Bit
           DisplayValue((unsigned long)(ext_period/100),-9,'s',7);	// show period converted to 1ns units
        }
//	---------------------------------------
        if (ii == 250) {
           lcd_data('?');		// wait loop has regular finished
					// probably the input frequency has changed
        } else {
           if (ext_period > 46566) {
//	      ----------------------------------------------------
//	      Show the frequency recalculated from measured period
//	      ----------------------------------------------------
 #if (LCD_LINES > 3)
              lcd_line4();		// use line 4 of 4-line LCD to report the computed frequency
 #else
              lcd_line1();		// overwrite line 1 of 2-line LCD to report the computed frequency
 #endif
              lcd_data('f');
              lcd_equal();		// lcd_data('=');
              if (ext_period > 1000000000) {
                 // frequency in 0.000001Hz (1e11*1e6)/(0.01ns count)
                 freq_from_per = (unsigned long long)(100000000000000000) / ext_period;
                 DisplayValue(freq_from_per,-6,'H',7);  // display with  0.000001 Hz resolution
              } else {
                 // prevent unsigned long overflow, scale to 0.0001 Hz
                 // frequency in 0.001Hz (1e11*1e3)/(0.01ns count)
                 freq_from_per = (unsigned long long)(100000000000000) / ext_period;
                 DisplayValue(freq_from_per,-3,'H',7);  // display with  0.001 Hz resolution
              }
              lcd_data('z');
              FREQINP_DDR &= ~(1<<FREQINP_PIN);	// switch frequency pin to input
//	      ----------------------------------------------------
           }
        }
     }  /* end if 1 < ext_freq < FMAX_PERIOD */
 #if PROCESSOR_TYP == 644
     if ((FDIV_PORT & (1<<FDIV_PIN)) == 0) {
        // frequency divider is not activ
        if ( ((freq_count >= FMAX_PERIOD) && (freq_count < ((unsigned long)FMAX_PERIOD*FREQ_DIV))) ||
            (freq_count > FMAX_INPUT) ){
           FDIV_PORT |= (1<<FDIV_PIN);			// use frequency divider for next measurement
        }
     } else {
        // frequency divider is activ
        if ((freq_count < (FMAX_PERIOD/FREQ_DIV)) && ((range & 0x01) == 0)) {
           FDIV_PORT &= ~(1<<FDIV_PIN);			// switch off the 16:1 divider
        }
     }
 #endif
//     taste += wait_for_key_ms(SHORT_WAIT_TIME/2);
     TIMSK0 = 0;		// disable all timer 0 interrupts
     taste += wait_for_key_ms(2000);
 #ifdef WITH_ROTARY_SWITCH
     if ((taste != 0) || (rotary.incre > 2)) break;
 #else
     if (taste != 0) break;
 #endif
  }  /* end for mm  */
 
  return;
 } // end GetFrequency()

#if PROCESSOR_TYP == 1280
/* ************************************************************ */
/* timer 3 Overflow interrupt                                   */
/* timer 3 count up to 0xffff, then OV occur. update upper part */
/* to build the total counts within one second or               */
/* to build the total counts within the specified pin changes.  */
/* ************************************************************ */
ISR(TIMER3_OVF_vect, ISR_BLOCK) {
  sei();		// set interrupt enable
  ext_freq.w[1] += 1;	// add 65536 clock tics to the total time
}
#else
/* ************************************************************ */
/* timer 0 Overflow interrupt                                   */
/* timer 0 count up to 0xff, then OV occur. update upper part   */
/* to build the total counts within one second or               */
/* to build the total counts within the specified pin changes.  */
/* ************************************************************ */
ISR(TIMER0_OVF_vect, ISR_BLOCK) {
  sei();		// set interrupt enable
  ext_freq.dw += 256;	// add 256 clock tics to the total time
}
#endif

#endif // WITH_MENU

#if defined(WITH_MENU) || ( defined(SamplingADC) && !defined(SamplingADC_CNT))
/* ************************************************************ */
/* Timer 1 Compare A interrupts with count 1 to start counter 0 */
/* This is defined as start of the measurement second.          */
/* ************************************************************ */
// this handler is also used by SamplingADC.S, where simply any dummy interrupt handler is usable; but if timing of this handler changes, need to adapt SamplingADC.S as well
ISR(TIMER1_COMPA_vect, ISR_BLOCK) {
#if PROCESSOR_TYP == 1280
  TCCR3B = (1<<CS32) | (1<<CS31) | (0<<CS30);	// start the counter 3 with external input T3
#else
  TCCR0B = (1<<CS02) | (1<<CS01) | (0<<CS00);	// now start the counter 0 with external input T0
#endif
}
#endif  // WITH_MENU or SamplingADC

#ifdef WITH_MENU
/* ************************************************************ */
/* Timer 1 Compare B interrupt after 1 second to stop counter 0 */
/* ************************************************************ */
ISR(TIMER1_COMPB_vect, ISR_BLOCK) {
  // The TIMER1_COMPB_vect uses one push and one ldi more than this interrupt.
  // Therefore we stop timer 1 first and ajust to same time with wdt_reset();
  wdt_reset();			// for adjusting to same time as TIMER1_COMPB_vect
  TCCR1B = 0;			// stop counter 1
#if PROCESSOR_TYP == 1280
  TCCR3B = 0;			// stop counter 3
#else
  TCCR0B = 0;			// stop counter 0
#endif
}

/* ************************************************************ */
/* Pin change Interrupt                                         */
/* this interrupt is used to measure the period of input signal */
/* the counter 0 is started with pin change interrupt and       */
/* stopped after pin_changed_max changes                        */
/* The pin_changed_max value should be equal to measure         */
/* full periods  (no half period)				*/
/* ************************************************************ */


ISR(PCINTx_vect, ISR_BLOCK)
{
  if (pinchange_count == 0) {
#if PROCESSOR_TYP == 1280
     TCCR3B = (1<<CS30);	// start the counter 3 with full CPU clock
#else
     TCCR0B = (1<<CS00);	// start the counter 0 with full CPU clock
#endif
  }
  if (pinchange_count >= pinchange_max) {
#if PROCESSOR_TYP == 1280
     // stop the counter 3, when maximum value has reached.
     TCCR3B = 0;		// stop counter 3
     PCMSK_FREQ &= ~(1<<PCINT_FREQ);	// disable int6
#else
     // stop the counter 0, when maximum value has reached.
     TCCR0B = 0;		// stop counter 0
     PCMSK_FREQ &= ~(1<<PCINT_FREQ);	// disable monitoring of PD4 PCINT20 or PB0 PCINT8 pin change
#endif
//     PCICR &= ~(1<<PCI_ENABLE_BIT);	// disable the interrupt
  }
  pinchange_count++;
}
#endif


GetFrequency.ino

/*
#include <avr/io.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/

//******************************************************************
void GetResistance(uint8_t HighPin, uint8_t LowPin)
  {
  /*
  Function for checking the resistance of a component with the following pin assignment 
  parameters:
  HighPin: Pin, which will be switched to VCC at the beginning
  LowPin: Pin, which will be switch to GND at the beginning
*/
  struct {
     unsigned int hp1;
     unsigned int hp2;
     unsigned int lp1;
     unsigned int lp2;
     unsigned int tp1;
     unsigned int tp2;
  }adc;

uint8_t LoPinRL;		// mask to switch the LowPin with R_L
uint8_t LoPinRH;		// mask to switch the LowPin with R_H
uint8_t HiPinRL;		// mask to switch the HighPin with R_L
uint8_t HiPinRH;		// mask to switch the HighPin with R_H
uint8_t LoADCp;			// mask to switch the ADC port LowPin
uint8_t HiADCp;			// mask to switch the ADC port HighPin

#if FLASHEND > 0x1fff
  uint8_t ii;			// temporary variable
  int udiff;
#endif


  unsigned long lrx1;
  unsigned long lirx1;
  unsigned long lirx2;
  const uint8_t	*addr;
  uint8_t resnum;
  /*
    switch HighPin directls to VCC 
    switch R_L port for LowPin to GND 
    TristatePin remains switched to input , no action required 
  */
  wdt_reset();
  addr = &PinRLRHADCtab[LowPin-TP_MIN];		// address of the combined RL / RH / ADC pin table
  LoPinRL = pgm_read_byte(addr);		// instruction for LowPin R_L
#if (((PIN_RL1 + 1) != PIN_RH1) || ((PIN_RL2 + 1) != PIN_RH2) || ((PIN_RL3 + 1) != PIN_RH3))
  addr += 3;			// address of PinRHtab[LowPin]
  LoPinRH = pgm_read_byte(addr);		// instruction for LowPin R_H
#else
  LoPinRH = (LoPinRL + LoPinRL);
#endif
  addr += 3;			// address of PinADCtab[LowPin]
  LoADCp = pgm_read_byte(addr);		// instruction for ADC Low-Pin, including | TXD_VAL

  addr = &PinRLRHADCtab[HighPin-TP_MIN];
  HiPinRL = pgm_read_byte(addr);		// instruction for HighPin R_L
#if (((PIN_RL1 + 1) != PIN_RH1) || ((PIN_RL2 + 1) != PIN_RH2) || ((PIN_RL3 + 1) != PIN_RH3))
  addr += 3;			// address of PinRLtab[HighPin]
  HiPinRH = pgm_read_byte(addr);		// instruction for HighPin R_H
#else
  HiPinRH = (HiPinRL + HiPinRL);
#endif
  addr += 3;			// address of PinADCtab[HighPin]
  HiADCp = pgm_read_byte(addr);		// instruction for ADC High-Pin, including | TXD_VAL

//##########################################################################################
// Search for resistors
//##########################################################################################
  if ((ptrans.count  + ntrans.count) > 0) {
     return;	// no resistors are searched, if transistors are detected
  }
  resnum = (LowPin - TP_MIN + HighPin - TP_MIN - 1);	// resistor-Number 0:1 = 0, 0:2 = 1, 1:2 = 2
  // resistor measurement
  wdt_reset();
// U_SCALE can be set to 4 for better resolution of ReadADC result
#if U_SCALE != 1
  ADCconfig.U_AVCC = (adc_vcc_reference * U_SCALE);	// scale to higher resolution, mV scale is not required
  ADCconfig.U_Bandgap = (adc_internal_reference * U_SCALE);
#endif
#if R_ANZ_MESS != ANZ_MESS
  ADCconfig.Samples = R_ANZ_MESS;	// switch to special number of repetitions
#endif
  #define MAX_REPEAT (700 / (5 + R_ANZ_MESS/8))
#if FLASHEND > 0x1fff
  for (ii=0; ii<NumOfDiodes; ii++) {
     // never search a resistor at the same place, where a diode is detected
     if ((diodes.Anode[ii] + diodes.Cathode[ii]) ==  (HighPin + LowPin)) goto testend;
  }
#endif
  ADC_PORT = TXD_VAL;
  ADC_DDR = LoADCp | TXD_MSK;		//switch Low-Pin to output (GND)
  R_DDR = HiPinRL;		//switch R_L port for High-Pin to output (VCC)
  R_PORT = HiPinRL;	
#if FLASHEND > 0x1fff
  adc.hp2 = 0;
  for (ii=1;ii<MAX_REPEAT;ii++) {
     // wait until voltage is stable
     adc.tp1 = W5msReadADC(LowPin);	// low-voltage at Rx with load
     adc.hp1 = ReadADC(HighPin);		// voltage at resistor Rx with R_L
     udiff = adc.hp1 - adc.hp2;
     if (udiff < 0) udiff = -udiff;
     if (udiff < 3) break;
     adc.hp2 = adc.hp1;
     wdt_reset();
  }
  if (ii == MAX_REPEAT) {
 #if (DEBUG_OUT == 1)
     lcd_data('a');
 #endif
     goto testend;
  }
#else
  adc.tp1 = W5msReadADC(LowPin);	// low-voltage at Rx with load
  adc.hp1 = ReadADC(HighPin);		// voltage at resistor Rx with R_L
#endif
  if (adc.tp1 > adc.hp1) {
     adc.tp1 = adc.hp1;
  }
  R_PORT = 0;
  R_DDR = HiPinRH;		//switch R_H port for High-Pin to output (GND)
  adc.hp2 = W5msReadADC(HighPin);	// read voltage, should be down
  if (adc.hp2 > (20*U_SCALE)) {
     // if resistor, voltage should be down
 #if (DEBUG_OUT == 1)
     lcd_data('b');
 #endif
     goto testend;
  }
  R_PORT = HiPinRH;		//switch R_H for High-Pin to VCC
  adc.hp2 = W5msReadADC(HighPin);	// voltage at resistor Rx with R_H

  ADC_DDR = HiADCp | TXD_MSK;		//switch High-Pin to output
  ADC_PORT = HiADCp;		//switch High-Pin to VCC
  R_PORT = 0;
  R_DDR = LoPinRL;			//switch R_L for Low-Pin to GND
#if FLASHEND > 0x1fff
  adc.lp2 = 0;
  for (ii=1;ii<MAX_REPEAT;ii++) {
     // wait until voltage is stable
					// L--RL--RyyX--H
     adc.tp2 = W5msReadADC(HighPin);	//high voltage with load
     adc.lp1 = ReadADC(LowPin);		//voltage at the other end of Rx
     udiff = adc.lp1 - adc.lp2;
     if (udiff < 0) udiff = -udiff;
     if (udiff < 3) break;
     adc.lp2 = adc.lp1;
     wdt_reset();
  }
  if (ii == MAX_REPEAT) {
 #if (DEBUG_OUT == 1)
     lcd_data('c');
 #endif
     goto testend;
  }
#else
  adc.tp2 = W5msReadADC(HighPin);	//high voltage with load
  adc.lp1 = ReadADC(LowPin);		//voltage at the other end of Rx
#endif
  if (adc.tp2 < adc.lp1) {
     adc.tp2 = adc.lp1;
  }
					// L--RH--RX--H
  R_DDR = LoPinRH;			//switch R_H for Low-Pin to GND
  adc.lp2 = W5msReadADC(LowPin);
		
  if((adc.hp1 < (4400*U_SCALE)) && (adc.hp2 > (97*U_SCALE))) {
     //voltage break down isn't insufficient 
 #if (DEBUG_OUT == 1)
     lcd_data('d');
 #endif
     goto testend; 
  }
//    if((adc.hp2 + (adc.hp2 / 61)) < adc.hp1)
  if (adc.hp2 < (4972*U_SCALE)) { 
     // voltage breaks down with low test current and it is not nearly shorted  => resistor
//     if (adc.lp1 < 120)  // take measurement with R_H 
     if (adc.lp1 < (169*U_SCALE)) { // take measurement with R_H 
        if (adc.lp2 < (38*U_SCALE)) {
           // measurement > 60MOhm too big resistance
 #if (DEBUG_OUT == 1)
     lcd_data('e');
 #endif
           goto testend;
        }
        // two measurements with R_H resistors (470k) are made:
        // lirx1 (measurement at HighPin)
        lirx1 = (unsigned long)((unsigned int)R_H_VAL) * (unsigned long)adc.hp2 / vcc_diff(adc.hp2);
        // lirx2 (measurement at LowPin)
        lirx2 = (unsigned long)((unsigned int)R_H_VAL) * (unsigned long)vcc_diff(adc.lp2) / adc.lp2;
#define U_INT_LIMIT (990*U_SCALE)		// 1V switch limit in ReadADC for atmega family
#ifdef __AVR_ATmega8__
#define FAKT_LOW 2		//resolution is about twice as good
#else
#define FAKT_LOW 4		//resolution is about four times better
#endif
#ifdef AUTOSCALE_ADC
        if (adc.hp2 < U_INT_LIMIT) {
           lrx1 = (lirx1*FAKT_LOW + lirx2) / (FAKT_LOW+1);	//weighted average of both R_H measurements
        } else if (adc.lp2 < U_INT_LIMIT){
           lrx1 = (lirx2*FAKT_LOW + lirx1) / (FAKT_LOW+1);	//weighted average of both R_H measurements
        } else 
#endif
        {
           lrx1 = (lirx1 + lirx2) / 2;		//average of both R_H measurements
        }
        lrx1 *= 100;
        lrx1 += RH_OFFSET;			// add constant for correction of systematic error
     } else {
        // two measurements with R_L resistors (680) are made:
        // lirx1 (measurement at HighPin)
        if (adc.tp1 > adc.hp1) {
           adc.hp1 = adc.tp1;		//diff negativ is illegal
        }
        lirx1 =(unsigned long)RR680PL * (unsigned long)unsigned_diff(adc.hp1, adc.tp1) / vcc_diff(adc.hp1);
        if (adc.tp2 < adc.lp1) {
           adc.lp1 = adc.tp2;		//diff negativ is illegal
        }
        // lirx2 (Measurement at LowPin)
        lirx2 =(unsigned long)RR680MI * (unsigned long)unsigned_diff(adc.tp2, adc.lp1) / adc.lp1;

#ifdef AUTOSCALE_ADC
        if (adc.hp1 < U_INT_LIMIT) {
           lrx1 = (lirx1*FAKT_LOW + lirx2) / (FAKT_LOW+1);	//weighted average of both R_L measurements
        } else if (adc.lp1 < U_INT_LIMIT) {
           lrx1 = (lirx2*FAKT_LOW + lirx1) / (FAKT_LOW+1);	//weighted average of both R_L measurements
        } else
#endif
        {
           lrx1 = (lirx1 + lirx2) / 2;		//average of both R_L measurements
        }
     }
     // measurement is finished, lrx1 is the resistance value of one direction
     if(PartFound < PART_TRANSISTOR) {
        if (ResistorChecked[resnum] != 0) {
           // must be measurement with inverse polarity 
           // resolution is 0.1 Ohm, 1 Ohm = 10 !
           lirx1 = (labs((long)lrx1 - (long)ResistorVal[resnum]) * 10) / (lrx1 + ResistorVal[resnum] + 100);
           if (lirx1  > 0) {
              // mismatch of the two measurements
//              ResistorsFound--;		// this one isn't a resistor
//              goto testend; // <10% mismatch
 #if (DEBUG_OUT == 1)
     lcd_line3();
     DisplayValue(lrx1,-1,' ',4);
     DisplayValue(ResistorVal[resnum],-1,' ',4);
 #endif
           } else {
              // resistor has the same value in both directions
              if (PartFound < PART_DIODE) {
                 PartFound = PART_RESISTOR;	// only mark as resistor, if no other part found
              }
              ResistorChecked[resnum] = 2;		// mark as checked in both direction
              ResistorList[ResistorsFound] = resnum;	// save number of this resistor
              ResistorsFound++;			// 1 more resistor found
           }
           goto testend;
        } else {		// resistor is never checked before
           // must be a new one with other pins
           ResistorVal[resnum] = lrx1;	// save register value
           ResistorChecked[resnum] = 1;		// is checked in one direction

        } // end  ResistorChecked[] != 0
     }	/* end if (PartFound < PART_TRANSISTOR) */
  }
  testend:			// end of resistor measurement
#if U_SCALE != 1
  ADCconfig.U_AVCC = adc_vcc_reference;	// scale to higher resolution, mV scale is not required
  ADCconfig.U_Bandgap = adc_internal_reference;	// set back to normal resolution
#endif
#if R_ANZ_MESS != ANZ_MESS
  ADCconfig.Samples = ANZ_MESS;		// switch back to standard number of repetition
#endif

  return;
} // end GetResistance()


GetResistance.ino

/*
#include <avr/io.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/


unsigned int GetRLmultip(unsigned int cvolt) {

// interpolate table RLtab corresponding to voltage cvolt
// Widerstand 680 Ohm          300   325   350   375   400   425   450   475   500   525   550   575   600   625   650   675   700   725   750   775   800   825   850   875   900   925   950   975  1000  1025  1050  1075  1100  1125  1150  1175  1200  1225  1250  1275  1300  1325  1350  1375  1400  mV
//uint16_t RLtab[] MEM_TEXT = {22447,20665,19138,17815,16657,15635,14727,13914,13182,12520,11918,11369,10865,10401, 9973, 9577, 9209, 8866, 8546, 8247, 7966, 7702, 7454, 7220, 6999, 6789, 6591, 6403, 6224, 6054, 5892, 5738, 5590, 5449, 5314, 5185, 5061, 4942, 4828, 4718, 4613, 4511, 4413, 4319, 4228};

#define RL_Tab_Abstand 25       // displacement of table 25mV
#define RL_Tab_Beginn 300       // begin of table ist 300mV
#define RL_Tab_Length 1100      // length of table is 1400-300

  unsigned int uvolt;
  unsigned int y1, y2;
  uint8_t tabind;
  uint8_t tabres;
  if (cvolt >= RL_Tab_Beginn) {
     uvolt = cvolt - RL_Tab_Beginn;
  } else {
     uvolt = 0;			// limit to begin of table
  }
  tabind = uvolt / RL_Tab_Abstand;
  tabres = uvolt % RL_Tab_Abstand;
  tabres = RL_Tab_Abstand - tabres;
  if (tabind > ((RL_Tab_Length/RL_Tab_Abstand)-1)) {
     tabind = (RL_Tab_Length/RL_Tab_Abstand)-1;	// limit to end of table
     tabres = 0;
  }
  y1 = MEM_read_word(&RLtab[tabind]);
  y2 = MEM_read_word(&RLtab[tabind+1]);
  return ( ((y1 - y2) * tabres + (RL_Tab_Abstand/2)) / RL_Tab_Abstand + y2); // interpolate table
}


GetRLmultip.ino

// new code by K.-H. Kübbeler
// ca   = Pin number (0-2) of the LowPin
// cb   = Pin number (0-2) of the HighPin

/*
#include <avr/io.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/

//=================================================================
void GetVloss() {
#if FLASHEND > 0x1fff
  // measure voltage drop after load pulse
  unsigned int tmpint;
  unsigned int adcv[4];
  union t_combi{
  unsigned long dw;     // capacity value  in 100nF units
  uint16_t w[2];
  } lval;
  uint8_t ii;
  uint8_t HiPinR_L;
  uint8_t LoADC;

  if (cap.v_loss > 0) {
     return;		// Voltage loss is already known (big Capacitor)
  }
#if (((PIN_RL1 + 1) != PIN_RH1) || ((PIN_RL2 + 1) != PIN_RH2) || ((PIN_RL3 + 1) != PIN_RH3))
  LoADC = pgm_read_byte((&PinRLRHADCtab[6])+cap.ca-TP_MIN) | TXD_MSK;
#else
  LoADC = pgm_read_byte((&PinRLRHADCtab[3])+cap.ca-TP_MIN) | TXD_MSK;
#endif
  HiPinR_L = pgm_read_byte(&PinRLRHADCtab[cap.cb-TP_MIN]);	//R_L mask for HighPin R_L load

  EntladePins();			// discharge capacitor
  ADC_PORT = TXD_VAL;			// switch ADC-Port to GND
  R_PORT = 0;				// switch R-Port to GND
  ADC_DDR = LoADC;			// switch Low-Pin to output (GND)
  R_DDR = HiPinR_L;			// switch R_L port for HighPin to output (GND)
  adcv[0] = ReadADC(cap.cb);		// voltage before any load 
// ******** should adcv[0] be measured without current???
  if ((cap.cpre_max > -9) || (cap.cpre_max < -12)) return;	// too much or too less capacity
  lval.dw = cap.cval_max;
  for (ii=cap.cpre_max+15;ii<7;ii++) {
     lval.dw = (lval.dw + 5) / 10;
  }
  if (lval.dw > 5000) {
     /* capacity more than 50uF, Voltage loss is already measured  */
     return;
  }
  if (lval.w[0] < 5) return;		// Capacity below 5nF
  R_PORT = HiPinR_L;			//R_L to 1 (VCC) 
  R_DDR = HiPinR_L;			//switch Pin to output, across R to GND or VCC
  for (tmpint=0;tmpint<lval.w[0];tmpint+=2) {
//     wait50us();			// wait exactly 50us
     wait5us();			// wait exactly 5us
  }
  R_DDR = 0;				// switch back to input
  R_PORT = 0;			// no Pull up
 // wait10us();			//wait a little time
  wdt_reset();
  // read voltage without current
  ADCconfig.Samples = 5;		// set ADC to only 5 samples
  adcv[2] = ReadADC(cap.cb);
  if (adcv[2] > adcv[0]) {
     adcv[2] -= adcv[0];		//difference to beginning voltage
  } else {
     adcv[2] = 0;			// voltage is lower or same as beginning voltage
  }
  // wait 2x the time which was required for loading
  for (tmpint=0;tmpint<lval.w[0];tmpint++) {
//     wait50us();
     wait5us();
  }
  adcv[3] = ReadADC(cap.cb);	// read voltage again, is discharged only a little bit ?
  ADCconfig.Samples = ANZ_MESS;		// set ADC back to configured No. of samples
  wdt_reset();
  if (adcv[3] > adcv[0]) {
     adcv[3] -= adcv[0];		// difference to beginning voltage
  } else {
     adcv[3] = 0;			// voltage is lower or same as beginning voltage
  }
  if (adcv[2] > adcv[3]) {
     // build difference to load voltage
     adcv[1] = adcv[2] - adcv[3];	// lost voltage during load time wait
  } else {
     adcv[1] = 0;			// no lost voltage
  }
  // compute voltage drop as part from loaded voltage
  if (adcv[1] > 0) {
     // there is any voltage drop (adcv[1]) !
     // adcv[2] is the loaded voltage.
     cap.v_loss = (unsigned long)(adcv[1] * 500UL) / adcv[2];
  }
#if 0
  lcd_line3();
  DisplayValue16(adcv[2],0,' ',4);
  DisplayValue16(adcv[1],0,' ',4);
  lcd_line4();
  DisplayValue16(lval.w[0],0,'x',4);
#endif

  // discharge capacitor again
  EntladePins();		// discharge capacitors
  //ready
  // switch all ports to input
  ADC_DDR =  TXD_MSK;		// switch all ADC ports to input
  ADC_PORT = TXD_VAL;		// switch all ADC outputs to GND, no pull up
  R_DDR = 0;			// switch all resistor ports to input
  R_PORT = 0; 			// switch all resistor outputs to GND, no pull up
#endif
  return;
 } // end GetVloss()


GetVloss.ino

/*
#include <avr/io.h>

#include "Transistortester.h"
#include "Makefile.h" //J-L
*/

//******************************************************************

void ChargePin10ms(uint8_t PinToCharge, uint8_t ChargeDirection) {
   //Load the specified pin to the specified direction with 680 Ohm for 10ms.
   //Will be used by discharge of MOSFET Gates or to load big capacities.
   //Parameters:
   //PinToCharge: specifies the pin as mask for R-Port
   //ChargeDirection: 0 = switch to GND (N-Kanal-FET), 1= switch to VCC(P-Kanal-FET)

   if(ChargeDirection&1) {
      R_PORT |= PinToCharge;	//R_PORT to 1 (VCC) 
   } else {
      R_PORT &= ~PinToCharge; // or 0 (GND)
   }
   R_DDR |= PinToCharge;		//switch Pin to output, across R to GND or VCC
   wait_about10ms();			// wait about 10ms
   // switch back Input, no current
   R_DDR &= ~PinToCharge;	// switch back to input
   R_PORT &= ~PinToCharge;	// no Pull up
}


ChargePin10ms.ino

CheckPins.ino

// new code by K.-H. Kübbeler

/*
#include <avr/io.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/

//=================================================================
// CheckRotaryEndoder

#ifdef WITH_MENU
 #ifdef WITH_ROTARY_CHECK
void CheckRotaryEncoder(void) {
  unsigned int TP13tab[4];	//count of state of the bits TP1 and TP3
  unsigned int TP23tab[4];	//count of state of the bits TP2 and TP3
  unsigned int TP12tab[4];	//count of state of the bits TP1 and TP2
  uint8_t index;	// Table offset, 0=nobit set, 1=lower, 2=upper, 3=both bit set
  uint8_t start_index23=0;	// start index of TP2:TP3
  uint8_t ii;
  uint8_t iim;
  uint8_t taste;
  uint8_t open_state;	// flag is set, if many times a open state is found fpr both switches
  uint8_t close_state;	// flag is set, if many times a closed state is found for both switches
  uint8_t switch1;	// pin number of first switch
  uint8_t switch2;	// pin number of second switch
  uint8_t switchm;	// common pin number of both switches
  unsigned int kk;	// loop counter for polling the pins

  message_key_released(RotaryEncoder_str);	// RotaryEncoder in line 1
  lcd_line2();
  lcd_MEM_string(TURN_str);			// "turn!" at line 2 of LCD
  lcd_refresh();		// write the pixels to display, ST7920 only
  
  for (ii=0;ii<4;ii++) {
     TP13tab[ii] = 0;		//reset count of bit TP1:TP3 to zero
     TP23tab[ii] = 0;		//reset count of bit TP2:TP3 to zero
     TP12tab[ii] = 0;		//reset count of bit TP1:TP2 to zero
  }  
  R_PORT = (1<<PIN_RL1) | (1<<PIN_RL2) | (1<<PIN_RL3); // all ports with 470k to VCC
  R_DDR = (1<<PIN_RL1) | (1<<PIN_RL2) | (1<<PIN_RL3); // all ports with 470k to VCC
  switch1 = TP1;		// no middle pin found, set all pins equal
  switch2 = TP1;
  switchm = TP1;
  open_state = 0;		// open state for both switches is not often found
  close_state = 0;		// close state for both switches is not often found
  for (kk=0; kk<63001; kk++) {
     ADC_PORT = TXD_VAL;		// all ADC output are preset to GND
     ADC_DDR = (1<<TP1) | TXD_MSK;	// switch TP1 to GND level
     wait2us();
     // look, what the other two levels are (TP2 and TP3)
     index = 0;			// index for both switches closed
     ii = ADC_PIN;		// Read port
     if ((ii & (1<<TP2)) != 0) index += 1;	// index for first switch open is 1 or 3
     if ((ii & (1<<TP3)) != 0) index += 2;	// index for second switch open is 2 or 3
     if (kk == 0) {
        start_index23 = index;		// save the start state
     } else {
        if (index != start_index23) {
           TP23tab[index]++;		// add one to the found state of TP2:TP3
        } else {
           start_index23 = 4;		// now every state will be counted
        }
     }

     ADC_DDR = (1<<TP2) | TXD_MSK;	// switch TP2 to GND level
     wait2us();
     // look, what the other two levels are (TP1 and TP3)
     index = 0;			// index for both switches closed
     ii = ADC_PIN;		// Read port
     if ((ii & (1<<TP1)) != 0) index += 1;	// index for first switch open is 1 or 3
     if ((ii & (1<<TP3)) != 0) index += 2;	// index for second switch open is 2 or 3
     if (start_index23 == 4) {
        TP13tab[index]++;		//add one to the found state of TP1:TP3
     }

     ADC_DDR = (1<<TP3) | TXD_MSK;	// switch TP3 to GND level
     wait2us();
     // look, what the other two levels are (TP1 and TP3)
     index = 0;			// index for both switches closed
     ii = ADC_PIN;		// Read port
     if ((ii & (1<<TP1)) != 0) index += 1;	// index for first switch open is 1 or 3
     if ((ii & (1<<TP2)) != 0) index += 2;	// index for second switch open is 2 or 3
     if (start_index23 == 4) {
        TP12tab[index]++;		//add one to the found state of TP1:TP2
     }
     wdt_reset();
     wait1ms();			// wait a little for next sample
     if ((RST_PIN_REG & (1<<RST_PIN)) == 0) goto end_rotary;
     if ((TP13tab[0] > 20) &&(TP13tab[1] > 20) && (TP13tab[2] > 20) && (TP13tab[3] > 20)) {
        switch1 = TP1;
        switch2 = TP3;
        switchm = TP2;
        if ((TP13tab[1] + TP13tab[2]) < TP13tab[0]) {
           close_state = 1;	// both switches are often monitored in close state
        }
        if ((TP13tab[1] + TP13tab[2]) < TP13tab[3]) {
           open_state = 1; 	// both switches are often monitored in open state
        }
        break;
     } 
     if ((TP23tab[0] > 20) &&(TP23tab[1] > 20) && (TP23tab[2] > 20) && (TP23tab[3] > 20)) {
        switch1 = TP2;
        switch2 = TP3;
        switchm = TP1;
        if ((TP23tab[1] + TP23tab[2]) < TP23tab[0]) {
           close_state = 1;	// both switches are often monitored in close state
        }
        if ((TP23tab[1] + TP23tab[2]) < TP23tab[3]) {
           open_state = 1; 	// both switches are often monitored in open state
        }
        break;
     } 
     if ((TP12tab[0] > 20) &&(TP12tab[1] > 20) && (TP12tab[2] > 20) && (TP12tab[3] > 20)) {
        switch1 = TP1;
        switch2 = TP2;
        switchm = TP3;
        if ((TP12tab[1] + TP12tab[2]) < TP12tab[0]) {
           close_state = 1;	// both switches are often monitored in close state
        }
        if ((TP12tab[1] + TP12tab[2]) < TP12tab[3]) {
           open_state = 1; 	// both switches are often monitored in open state
        }
        break;
     } 
  }
  if (switch1 == switch2) return;	// no rotary encoder found
  
  lcd_clear_line2();		// clear line 2 of LCD
  for (ii=0;ii<120;ii++) {
     lcd_line2();
     lcd_testpin(switch1);
     lcd_data('-');
     if ((ii & 0x01) == 0) {
        lcd_data('-');		// close state of switch
     } else {
        lcd_data('/');		// open state of switch
     }
     lcd_data('-');
     lcd_testpin(switchm);		// show the found pin number of the common pin
     lcd_data('-');
     if ((ii & 0x02) == 0) {
        lcd_data('-');		// close state of switch
     } else {
        lcd_data('/');		// open state of switch
     }
     lcd_data('-');
     lcd_testpin(switch2);
     lcd_space();
     iim = (ii & 0x03);
     if (((iim == 0) && (close_state != 0)) || ((iim  == 3) && (open_state != 0))) {
        if (iim == 0) lcd_data('C');
        if (iim == 3) lcd_data('o');
        taste = wait_for_key_ms(2000);	// this state is monitored for a long time
     } else {
        lcd_space();
        taste = wait_for_key_ms(400);	// this state is monitored only for a short time
     }
     if (taste != 0) break;
  } /* end for ii */
end_rotary:
  R_PORT = 0; // all resistor ports  to GND
  R_DDR = 0;	// all resistor ports to input
  ADC_DDR = TXD_MSK;	// switch ADC port to input
}
 #endif  /* WITH_ROTARY_CHECK */
#endif /* WITH_MENU */


CheckRotaryEncoder.ino

//#include "Transistortester.h"
//#include "Makefile.h" //J-L

#ifdef WITH_UJT
void CheckUJT(void) {
 #ifdef SamplingADC
             uint8_t B1pin, B2pin, Epin;
             Epin = diodes.Anode[0];
             B1pin = diodes.Cathode[0];
             B2pin = diodes.Cathode[1];
ujt_exch_b:;
             uint8_t port0, port1, ddr0, ddr1;
             // B1 to ground via 0 ohm
             // B2 to plus via 680 ohm
             // discharge: E to ground via 680 ohm
             // charge: E to plus via 470 k

             port0 = pinmaskRL(B2pin);
             ddr0 = port0 | pinmaskRL(Epin);
             port0 |= pinmaskRH(Epin);
             port1 = port0;
             ddr1 = port1;
              ADMUX = Epin|(1<<REFS0);	// switch Multiplexer to emitter and use 5V reference voltage
              ADC_DDR = pinmaskADC(B1pin);
              ADC_PORT = TXD_VAL;
              R_PORT = 0;
              R_DDR = 0;			
              wait_aref_stabilize();
              unsigned int uu[64];
              samplingADC((16<<smplADC_span), uu, 64, port1, ddr1, port0, ddr0);
//              myuart_putc('s'); myuart_putc(' '); uart_int(port1); uart_int(ddr1); uart_int(port0); uart_int(ddr0); uart_newline();
              uint8_t i;
              uint8_t max=0;
              uint8_t maxm;
              for (i=10;i<64;i++) {
                 uint8_t v=uu[i]>>2;  // 8-bit arithmetic is enough for this
                 if (v>max) max=v;
                 else break;
              }
              // found first maximum
              // now check whether after this, the voltage drops significantly, if so, we've detected oscillation
              maxm = max - (max>>3);
              for (;i<64;i++) {
                 uint8_t v=uu[i]>>2;  // 8-bit arithmetic is enough for this
                 if (v<maxm) {
                    // significant voltage drop, oscillation found: must be an UJT
                    PartFound=PART_UJT;
                    ntrans.e=B1pin;
                    ntrans.b=Epin;
                    ntrans.c=B2pin;
                    // calculate eta
                    ResistorChecked[ntrans.e - TP_MIN + ntrans.c - TP_MIN - 1] = 0;	// forget last resistance measurement
                    GetResistance(ntrans.c, ntrans.e);	// resistor value is in ResistorVal[resnum]
                    uint32_t v;
                    uint32_t r=ResistorVal[ntrans.e - TP_MIN + ntrans.c - TP_MIN - 1];
                    v=(r<<8)/(r+R_L_VAL);      // Vbb in units of supplyvoltage/256 ; perhaps should also take into account the about 20 ohm internal resistance?
                    max-=35;               // subtract about 0.7 volts (1 diode voltage drop) from the maximum emitter voltage seen; 35 is 0.7/5*256.
                    ntrans.gthvoltage=100ul*max/v;     // this is eta in percent, cf. http://www.allaboutcircuits.com/textbook/semiconductors/chpt-7/unijunction-transistor-ujt/
                    goto ujtdone;
                 }
              } /* end for i */
              // didn't find oscillation yet
              if (B1pin == diodes.Cathode[0]) {
                 // try exchanging the two base connections
                 B1pin=B2pin;
                 B2pin=diodes.Cathode[0];
                 goto ujt_exch_b;
              }
ujtdone:;

//   uart_newline(); for (i=0;i<64;i++) { myuart_putc('a'); myuart_putc(' '); uart_int(uu[i<<2]); uart_newline(); wdt_reset(); }
//   uart_newline(); for (i=0;i<64;i++) { myuart_putc('a'); myuart_putc(' '); uart_int(uu[i]); uart_newline(); wdt_reset(); }
//              myuart_putc('v'); myuart_putc(' '); uart_int(min); uart_int(max); uart_newline();
 #else		/* ! SamplingADC */
             uint16_t v0,v1,v2;
             ntrans.b = diodes.Anode[0];			// common anode must be emitter of UJT
             ADC_DDR = pinmaskADC(diodes.Cathode[0]);
             ADC_PORT =  TXD_VAL;   // UJT B1 to GND
             R_PORT = pinmaskRL(ntrans.b) | pinmaskRL(diodes.Cathode[1]);	// UJT emitter and B2 with RL to VCC
             R_DDR = R_PORT;
             v1 = vcc_diff(W5msReadADC(diodes.Cathode[1]));			// read voltage at B2
             R_PORT = pinmaskRL(diodes.Cathode[1]);	// UJT B2 with RL to VCC, emitter open
             R_DDR = R_PORT;
             v0 = vcc_diff(W5msReadADC(diodes.Cathode[1]));			// read voltage at B2
             if (v0 < v1) v1 -= v0;

             R_PORT = pinmaskRL(ntrans.b) | pinmaskRL(diodes.Cathode[0]);	// UJT emitter and B2 with RL to VCC
             R_DDR = R_PORT;
             ADC_DDR = pinmaskADC(diodes.Cathode[1]);
             v2 = vcc_diff(W5msReadADC(diodes.Cathode[0]));			// read voltage at B2
             R_PORT = pinmaskRL(diodes.Cathode[0]);	// UJT B2 with RL to VCC, emitter open
             R_DDR = R_PORT;
             v0 = vcc_diff(W5msReadADC(diodes.Cathode[0]));			// read voltage at B2
             if (v0 < v2) v2 -= v0;
             if (v1 > v2) {
                ntrans.uBE = v1;
                ntrans.e = diodes.Cathode[0];
                ntrans.c = diodes.Cathode[1];
             } else {
                ntrans.uBE = v2;
                ntrans.e = diodes.Cathode[1];
                ntrans.c = diodes.Cathode[0];
             }
             if (ntrans.uBE > 1500) {
                ResistorChecked[ntrans.e - TP_MIN + ntrans.c - TP_MIN - 1] = 0;	// forget last resistance measurement
                GetResistance(ntrans.c, ntrans.e);	// resistor value is in ResistorVal[resnum]
                PartFound = PART_UJT;
             }
           
 #endif		/* defined SamplingADC */
}
#endif


CheckUJT.ino

/*
#include <avr/io.h>
#include <avr/common.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "lcd_routines.h"
*/


#if FLASHEND > 0x1fff
void i2lcd(int iw) {
  if (iw < 0) {
     lcd_data('-');
     iw = -iw;
  }
  lcd_string(utoa((unsigned int)iw, outval, 10));
}
#endif

void u2lcd(uint16_t uw) {
  lcd_string(utoa(uw, outval, 10));
}

void u2lcd_space(uint16_t uw) {
  u2lcd(uw);
  lcd_space();
}

#if FLASHEND > 0x1fff
void i2lcd_space(int16_t uw) {
  i2lcd(uw);
  lcd_space();
}
#endif


i2lcd.ino



// Options for lcd_pgm_bitmap option parameter:
#define OPT_HREVERSE    1 // Display bitmap reversed horizontally
#define OPT_VREVERSE    2 // Display bitmap reversed vertically
#define OPT_CINVERSE	4 // color is inverted (black to white ...) not used!

#define SCREEN_WIDTH  128
#define SCREEN_HEIGHT  64

// configure the LINE_LENGTH and LCD_LINES for character Display
#ifdef FOUR_LINE_LCD
 #if FOUR_LINE_LCD == 1
  #define LCD_LINES 4
  #define PAGES_PER_LINE 1
  #ifndef LCD_LINE_LENGTH
   #define LCD_LINE_LENGTH 20  /* usually a 20 character line */
  #endif
 #else
  #define LCD_LINES FOUR_LINE_LCD
  #define PAGES_PER_LINE 1
  #ifndef LCD_LINE_LENGTH
   #define LCD_LINE_LENGTH 16  /* usually a 16 character line */
  #endif
 #endif
#else  /* no FOUR_LINE_LCD */
  #define PAGES_PER_LINE 1
  #define LCD_LINES 2
  #define LCD_LINE_LENGTH 16
#endif
#if (LCD_ST_TYPE != 7735) && (LCD_ST_TYPE != 9163) && (LCD_ST_TYPE != 9341)
 #undef LCD_CHANGE_COLOR
#endif
#ifndef LCD_SCREEN_ROTATE
 #define LCD_SCREEN_ROTATE 0
#endif


/* *********************************************************************************************************** */
#if ((LCD_ST_TYPE == 7565) || (LCD_ST_TYPE == 1306))

//LCD-commands
	#define CMD_DISPLAY_OFF         0xAE
	#define CMD_DISPLAY_ON          0xAF

	#define CMD_SET_DISP_START_LINE 0x40
	#define CMD_SET_PAGE            0xB0

	#define CMD_SET_COLUMN_UPPER    0x10
	#define CMD_SET_COLUMN_LOWER    0x00

	#define CMD_SET_ADC_NORMAL      0xA0
	#define CMD_SET_ADC_REVERSE     0xA1

	#define CMD_SET_DISP_NORMAL     0xA6
	#define CMD_SET_DISP_REVERSE    0xA7

	#define CMD_SET_ALLPTS_NORMAL   0xA4
	#define CMD_SET_ALLPTS_ON       0xA5
	#define CMD_SET_BIAS_9          0xA2 
	#define CMD_SET_BIAS_7          0xA3

	#define CMD_RMW                 0xE0
	#define CMD_RMW_CLEAR           0xEE
	#define CMD_INTERNAL_RESET      0xE2
	#define CMD_SET_COM_NORMAL      0xC0
	#define CMD_SET_COM_REVERSE     0xC8
	#define CMD_SET_POWER_CONTROL   0x28
	#define CMD_SET_RESISTOR_RATIO  0x20
	#define CMD_SET_VOLUME_FIRST    0x81
 #if (LCD_ST_TYPE == 1306)
  #ifndef VOLUME_VALUE
 	#define VOLUME_VALUE   60	/* second byte of CMD_SET_VOLUME == volume value */
  #endif
 	#define CMD_SET_MEMORY_ADDR_MODE 0x20
 	#define CMD_SET_ChargePump	0x8D
 	#define CMD_SET_MUX_RATIO	0xA8
 	#define CMD_SET_DISPLAY_OFFSET	0xD3
 	#define CMD_SET_DIVIDE_RATIO	0xD5
 	#define CMD_SET_PreCharge_PERIOD 0xD9
 	#define CMD_SET_COM_Pins_CONFIG 0xDA
 	#define CMD_SET_Vcomh_DESELECT_LEVEL 0xDB
 #else
  #ifndef VOLUME_VALUE
 	#define VOLUME_VALUE   40	/* second byte of CMD_SET_VOLUME == volume value */
  #endif
 #endif
	#define CMD_SET_STATIC_OFF      0xAC
	#define CMD_SET_STATIC_ON       0xAD
	#define CMD_SET_STATIC_REG      0x0
	#define CMD_SET_BOOSTER_FIRST   0xF8
	#define CMD_SET_BOOSTER_234     0
	#define CMD_SET_BOOSTER_5       1
	#define CMD_SET_BOOSTER_6       3
	#define CMD_NOP                 0xE3
	#define CMD_TEST                0xF0

//Makros for LCD
	#define lcd_write_data(data)                   _lcd_hw_write(0x01, data);
	#define lcd_shift_right() // ignored
	#define lcd_shift_left()  // ignored

	#define LCDLoadCustomChar(addr) //load Custom-character (ignored)
	#define lcd_cursor_on()  // ignored
	#define lcd_cursor_off() // ignored

/* *********************************************************************************************************** */
#elif (LCD_ST_TYPE == 7108) 	/* not (LCD_ST_TYPE == 7565 || 1306) */
	#define CMD_DISPLAY_OFF	0x3e
	#define CMD_DISPLAY_ON	0x3f
	#define CMD_SET_COLUMN_ADDR	0x40
	#define CMD_SET_PAGE		0xb8
	#define CMD_SET_START_LINE	0xC0		/* set the start line for ST7108, Z address */

//Makros for LCD
	#define lcd_write_data(data)                   _lcd_hw_write(0x01, data);
	#define lcd_cursor_on()  // ignored
	#define lcd_cursor_off() // ignored

/* *********************************************************************************************************** */
#elif (LCD_ST_TYPE == 7920) 	/* not (LCD_ST_TYPE == 7565 || 1306 || == 7108) */
	#define lcd_write_init(data_length)            _lcd_hw_write(0x80, CMD_SetIFOptions | (data_length << 4))
	#define lcd_cursor_on()  // ignored
	#define lcd_cursor_off() // ignored
	#define CMD_CLEAR	0x01		/* clear display, basic Instruction */
	#define CMD_CGRAM_SELECT 0x02		/* SR=0, enable CGRAM address */
	#define CMD_SET_ENTRY_MODE 0x04		/* set cursor posistion and shift for read/write */
 	#define MODE_RIGHT_MOVE 0x02
	#define CMD_DISPLAY_CONTROL	0x08	/* display control, basic Instruction */
 	#define DISPLAY_ON 0x4
 	#define CURSOR_ON 0x02
 	#define BLINK_ON 0x01
	#define CMD_DISPLAY_ON	(CMD_DISPLAY_CONTROL | DISPLAY_ON)
	#define CMD_DISPLAY_OFF	CMD_DISPLAY_CONTROL
	#define CMD_CURSOR_DISPLAY_CONTROL 0x10
	#define CMD_SET_FUNCTION 0x20		/* basic + extended Instruction */
 	#define MODE_8_BIT 0x10		/* Bit 4 is 8 bit mode */
 	#define MODE_EXTENDED 0x04		/* Bit 2 is used for extended Intruction */
 	#define GRAPHIC_DISPLAY_ON 0x02	/* Bit 1 is used for graphic display on, only extended Instruction */
	#define CMD_SET_GDRAM_ADDRESS 0x80	/* set graphic display RAM address ,extended Instruction */
					/* 2x, first vertical address 5:0, second horizontal address 3:0 */
					/* followed by pairs of horizontal data (16-bit) */
//Makros for LCD
	#define lcd_write_data(data)                   _lcd_hw_write(0x01, data);
	#define lcd_cursor_on()  // ignored
	#define lcd_cursor_off() // ignored

/* *********************************************************************************************************** */
#elif (LCD_ST_TYPE == 8812) 	/* not (LCD_ST_TYPE == 7565 || 1306 || 7108 || 7920)) */
 // support for PCF8812
	#undef SCREEN_WIDTH
	#define SCREEN_WIDTH  102	/* for ST8812 */
	#define CMD_SET_EXTENDED_INSTRUCTION 0x21	/* Function set with H */
	#define CMD_SET_NORMAL_INSTRUCTION 0x20	/* Function set  */
	#define ECMD_SET_HV_STAGES 0x08		/* set multiplication of HV-gen  (0 <= m <= 3) */
	#define ECMD_SET_TEMP_COEF 0x04		/* set temperature coefficient   (0 <= T <= 3) */
	#define ECMD_SET_BIAS 0x10		/* set bias system  (0 <= B <= 7) */
	#define ECMD_SET_CONTRAST 0x80		/* set Vop  value   (0 <= V <= 127) */
	#define CMD_SET_DISPLAY_INVERS  0x0D	/* D and E bit set */
	#define CMD_SET_DISPLAY_NORMAL  0x0C	/* D bit set */
	#define CMD_SET_DISPLAY_WHITE   0x09	/* E bit set */
	#define CMD_SET_DISPLAY_BLACK   0x80	/* no bit set */
	#define CMD_SET_PAGE		0x40		/* set Y address of RAM (0 <= Y <= 8) */

	#define CMD_SET_COLUMN		0x80		/* set X address of RAM (0 <= X < 102) */
//Makros for LCD
	#define lcd_write_data(data)                   _lcd_hw_write(0x01, data);
	#define lcd_cursor_on()  // ignored
	#define lcd_cursor_off() // ignored
/* *********************************************************************************************************** */
#elif (LCD_ST_TYPE == 8814) 	/* not ((LCD_ST_TYPE == 7565 || 1306 || 7108 || 7920 || 8812) */
 // support for PCF8814 , used for Nokia 1100
	#undef SCREEN_WIDTH		
	#define SCREEN_WIDTH  96		/* for ST8814 */
        #undef SCREEN_HEIGHT 
        #define SCREEN_HEIGHT  65
	#define CMD_SET_VOP_UPPER 0x20		/* upper 3 bits of Vop */
	#define CMD_SET_VOP_LOWER 0x80		/* lower 5 bits of Vop */
	#define CMD_SET_ALLPTS_NORMAL   0xA4
	#define CMD_SET_POWER_CONTROL   0x28
	#define CMD_SET_COM_NORMAL      0xC0
	#define CMD_SET_COM_REVERSE     0xC8
	#define CMD_DISPLAY_OFF         0xAE
	#define CMD_DISPLAY_ON          0xAF
	#define CMD_SET_PAGE            0xB0
	#define CMD_SET_START_LINE		0x40    /* set the start line for ST8814, Z address */
	#define CMD_SET_COLUMN_UPPER    0x10
	#define CMD_SET_COLUMN_LOWER    0x00
//Makros for LCD
	#define lcd_write_data(data)                   _lcd_hw_write(0x01, data);
	#define lcd_cursor_on()  // ignored
	#define lcd_cursor_off() // ignored
/* *********************************************************************************************************** */
#elif (LCD_ST_TYPE == 7735)
	#define CMD_EXIT_SLEEP 0x11
	#define CMD_SET_GAMMA 0x26
	#define CMD_DISPLAY_ON 0x29
 	#define CMD_CASET  0x2a
 	#define CMD_RASET  0x2b
 	#define CMD_RAMWR  0x2c
	#define CMD_MEMORY_ADDRESS_CONTROL 0x36
	#define CMD_SET_COLOR_FORMAT 0x3a
	#define CMD_FRAME_RATE_CONTROL 0xb1
	#define CMD_INVERSION_CONTROL 0xb4
	#define CMD_POWER_CONTROL1 0xc0
	#define CMD_POWER_CONTROL2 0xc1
	#define CMD_VCOM_CONTROL1 0xc5
	#undef SCREEN_HEIGHT
	#undef SCREEN_WIDTH
#if LCD_SCREEN_ROTATE != 0
        #define SCREEN_HEIGHT 128
        #define SCREEN_WIDTH 160
#else
        #define SCREEN_HEIGHT 160
        #define SCREEN_WIDTH 128
#endif
//Makros for LCD
	#define lcd_write_data(data)                   _lcd_hw_write(0x01, data);
	#define lcd_cursor_on()  // ignored
	#define lcd_cursor_off() // ignored
 #ifndef LCD_ST7565_V_OFFSET
	#define LCD_ST7565_V_OFFSET 0
 #endif
 #ifndef LCD_BG_COLOR
	#define LCD_BG_COLOR 0x0000	/* 5 bit red, 6 bit green, 5 bit blue */
 #endif
 #ifndef LCD_FG_COLOR
	#define LCD_FG_COLOR 0xffff	/* 5 bit red, 6 bit green, 5 bit blue */
 #endif
	#define ST_DIVA 14
	#define ST_VPA 20

/* *********************************************************************************************************** */
#elif (LCD_ST_TYPE == 9341)
	#define CMD_EXIT_SLEEP 0x11
	#define CMD_SET_GAMMA 0x26
	#define CMD_DISPLAY_ON 0x29
 	#define CMD_CASET  0x2a		/* set column address */
 	#define CMD_RASET  0x2b		/* set row (page) address */
	#define CMD_RAMWR 0x2c		/* write data to RAM */
	#define CMD_MEMORY_ADDRESS_CONTROL 0x36
	#define CMD_SET_COLOR_FORMAT 0x3a
	#define CMD_FRAME_RATE_CONTROL 0xb1
	#define CMD_POWER_CONTROL1 0xc0
	#define CMD_POWER_CONTROL2 0xc1
	#define CMD_VCOM_CONTROL1 0xc5
	#undef SCREEN_HEIGHT
	#undef SCREEN_WIDTH
#if LCD_SCREEN_ROTATE != 0
        #define SCREEN_HEIGHT 320
        #define SCREEN_WIDTH 240
#else
        #define SCREEN_HEIGHT 240
        #define SCREEN_WIDTH 320
#endif
//Makros for LCD
	#define lcd_write_data(data)                   _lcd_hw_write(0x01, data);
	#define lcd_cursor_on()  // ignored
	#define lcd_cursor_off() // ignored
 #ifndef LCD_ST7565_V_OFFSET
	#define LCD_ST7565_V_OFFSET 0
 #endif
 #ifndef LCD_BG_COLOR
	#define LCD_BG_COLOR 0x0000	/* 5 bit red, 6 bit green, 5 bit blue */
 #endif
 #ifndef LCD_FG_COLOR
	#define LCD_FG_COLOR 0xffff	/* 5 bit red, 6 bit green, 5 bit blue */
 #endif
        
/* *********************************************************************************************************** */
#elif (LCD_ST_TYPE == 9163)
	#define CMD_EXIT_SLEEP 0x11
	#define CMD_SET_GAMMA 0x26
	#define CMD_DISPLAY_ON 0x29
 	#define CMD_CASET  0x2a
 	#define CMD_RASET  0x2b
 	#define CMD_RAMWR  0x2c
	#define CMD_MEMORY_ADDRESS_CONTROL 0x36
	#define CMD_SET_COLOR_FORMAT 0x3a
	#define CMD_FRAME_RATE_CONTROL 0xb1
	#define CMD_INVERSION_CONTROL 0xb4
	#define CMD_POWER_CONTROL1 0xc0
	#define CMD_POWER_CONTROL2 0xc1
	#define CMD_VCOM_CONTROL1 0xc5
//Makros for LCD
	#define lcd_write_data(data)                   _lcd_hw_write(0x01, data);
	#define lcd_cursor_on()  // ignored
	#define lcd_cursor_off() // ignored

	#undef SCREEN_HEIGHT
        #define SCREEN_HEIGHT 128
//	#undef SCREEN_WIDTH
//	#define SCREEN_WIDTH 128
 #ifndef LCD_ST7565_V_OFFSET
	#define LCD_ST7565_V_OFFSET 32	/* 160 - 128 */
 #endif
 #ifndef LCD_BG_COLOR
	#define LCD_BG_COLOR 0x0000	/* 5 bit red, 6 bit green, 5 bit blue */
 #endif
 #ifndef LCD_FG_COLOR
	#define LCD_FG_COLOR 0xffff	/* 5 bit red, 6 bit green, 5 bit blue */
 #endif
	#define ST_DIVA 17
	#define ST_VPA 20

/* *********************************************************************************************************** */
#elif (LCD_ST_TYPE == 1327)
//LCD-commands
 	#define CMD_CASET  0x15
 	#define CMD_RASET  0x75
	#define CMD_SET_CONTRAST_CONTROL 0x81
        #define CMD_DISPLAY_OFF 0xae
	#define CMD_DISPLAY_ON 0xaf
//Makros for LCD
	#define lcd_write_data(data)                   _lcd_hw_write(0x01, data);
	#define lcd_cursor_on()  // ignored
	#define lcd_cursor_off() // ignored
	#undef SCREEN_HEIGHT
        #define SCREEN_HEIGHT 128
	#undef SCREEN_WIDTH
	#define SCREEN_WIDTH 128

/* *********************************************************************************************************** */
#else /* not ((LCD_ST_TYPE == 7565 || 1306 || 7920 || 7108 || 8812 || 8814 || 7735 || 9341 || 9163) */
/* must be a character display! */
	#define lcd_write_data(data)                   _lcd_hw_write(0x01, data); wait50us();
	#define lcd_write_init(data_length)            _lcd_hw_write(0x80, CMD_SetIFOptions | (data_length << 4))

 #ifndef VOLUME_VALUE
	#define VOLUME_VALUE   36	/* volume value , default contrast */
 #endif


//LCD-commands
	#define CMD_CLEAR_DISPLAY 0x01
	#define CMD_CURSOR_HOME 0x02
	#define CMD_SetEntryMode         0x04
	#define CMD_SetDisplayAndCursor  0x08
	#define CMD_SetIFOptions         0x20
	#define CMD_SetCGRAMAddress      0x40    // for Custom character
	#define CMD_SetDDRAMAddress      0x80    // set Cursor 
	#define CMD1_SetBias             0x10	// set Bias (instruction table 1, DOGM)
	#define CMD1_PowerControl        0x50	// Power Control, set Contrast C5:C4 (instruction table 1, DOGM)
	#define CMD1_FollowerControl     0x60	// Follower Control, amplified ratio (instruction table 1, DOGM)
	#define CMD1_SetContrast         0x70	// set Contrast C3:C0 (instruction table 1, DOGM)
	#define CMD_DISPLAY_OFF          0x08
	#define CMD_DISPLAY_ON           0x0c

//Makros for LCD
	#define lcd_shift_right() lcd_command(0x1c)
	#define lcd_shift_left() lcd_command(0x18)

	#define LCDLoadCustomChar(addr) lcd_command(CMD_SetCGRAMAddress | (addr<<3))	//load Custom-character
	#define lcd_cursor_on()  lcd_command(CMD_SetDisplayAndCursor | 0x06)
	#define lcd_cursor_off() lcd_command(CMD_SetDisplayAndCursor | 0x04)

//Addresses of lines
 #ifndef DD_RAM_OFFSET
  #define DD_RAM_OFFSET 0
 #endif
 #if (defined(LCD_DOGM) && defined(FOUR_LINE_LCD))
  #if FOUR_LINE_LCD == 3
        /* lines for a ST7036 controller, 3 lines */
    	#define LCD_Row1	0x00+DD_RAM_OFFSET
	#define LCD_Row2	0x10+DD_RAM_OFFSET
	#define LCD_Row3	0x20+DD_RAM_OFFSET
	#define LCD_Row4	0x30+DD_RAM_OFFSET
  #else
        /* lines for a SSD1803 controller */
    	#define LCD_Row1	0x00+DD_RAM_OFFSET
	#define LCD_Row2	0x20+DD_RAM_OFFSET
	#define LCD_Row3	0x40+DD_RAM_OFFSET
	#define LCD_Row4	0x60+DD_RAM_OFFSET
  #endif
 #else
  #if LCD_LINE_LENGTH == 20
    	#define LCD_Row1	0x00+DD_RAM_OFFSET
	#define LCD_Row2	0x40+DD_RAM_OFFSET
	#define LCD_Row3	0x14+DD_RAM_OFFSET
	#define LCD_Row4	0x54+DD_RAM_OFFSET
  #else
   #if LCD_LINE_LENGTH < 16
    #warning LCD_LINE_LENGTH not correctly set!
   #endif
    	#define LCD_Row1	0x00+DD_RAM_OFFSET
	#define LCD_Row2	0x40+DD_RAM_OFFSET
	#define LCD_Row3	0x10+DD_RAM_OFFSET
	#define LCD_Row4	0x50+DD_RAM_OFFSET
  #endif
 #endif

#endif

//defines for the cyrillic character set
#if ((LCD_ST_TYPE == 7565) || (LCD_ST_TYPE == 1306) || (LCD_ST_TYPE == 7920) || (LCD_ST_TYPE == 7108) || (LCD_ST_TYPE == 8812) || (LCD_ST_TYPE == 8814) || (LCD_ST_TYPE == 9163) || (LCD_ST_TYPE == 7735) || (LCD_ST_TYPE==9341))
 	#define GR_OFFSET1 0x20	/* shift 0xa0 to 0x80, direct behind ASCII table, to save place in font table */
 	#define GR_OFFSET2 0xd0	/* shift 0xe0 to 0x10, before the ASCII table */  
#else
 	#define GR_OFFSET1 0
 	#define GR_OFFSET2 0
#endif

#define Cyr_B	(0xa0 - GR_OFFSET1)
#define Cyr_G	(0xa1 - GR_OFFSET1)
#define Cyr_Jo	(0xa2 - GR_OFFSET1)
#define Cyr_Zsch (0xa3 - GR_OFFSET1)
#define Cyr_Z	(0xa4 - GR_OFFSET1)
#define Cyr_I	(0xa5 - GR_OFFSET1)
#define Cyr_J	(0xa6 - GR_OFFSET1)
#define Cyr_L	(0xa7 - GR_OFFSET1)
#define Cyr_P	(0xa8 - GR_OFFSET1)
#define Cyr_U	(0xa9 - GR_OFFSET1)
#define Cyr_F	(0xaa - GR_OFFSET1)
#define Cyr_Tsch (0xab - GR_OFFSET1)
#define Cyr_Sch (0xac - GR_OFFSET1)
#define Cyr_HH	(0xad - GR_OFFSET1)
#define Cyr_Y	(0xae - GR_OFFSET1)
#define Cyr_E	(0xaf - GR_OFFSET1)

#define Cyr_Ju	(0xb0 - GR_OFFSET1)
#define Cyr_Ja	(0xb1 - GR_OFFSET1)
#define Cyr_b	(0xb2 - GR_OFFSET1)
#define Cyr_v	(0xb3 - GR_OFFSET1)
#define Cyr_g	(0xb4 - GR_OFFSET1)
#define Cyr_jo	(0xb5 - GR_OFFSET1)
#define Cyr_zsch (0xb6 - GR_OFFSET1)
#define Cyr_z	(0xb7 - GR_OFFSET1)
#define Cyr_i	(0xb8 - GR_OFFSET1)
#define Cyr_j	(0xb9 - GR_OFFSET1)
#define Cyr_k	(0xba - GR_OFFSET1)
#define Cyr_l	(0xbb - GR_OFFSET1)
#define Cyr_m	(0xbc - GR_OFFSET1)
#define Cyr_n	(0xbd - GR_OFFSET1)
#define Cyr_p	(0xbe - GR_OFFSET1)
#define Cyr_t	(0xbf - GR_OFFSET1)

#define Cyr_tsch (0xc0 - GR_OFFSET1)
#define Cyr_sch (0xc1 - GR_OFFSET1)
#define Cyr_hh	(0xc2 - GR_OFFSET1)
#define Cyr_y	(0xc3 - GR_OFFSET1)
#define Cyr_ww	(0xc4 - GR_OFFSET1)
#define Cyr_e	(0xc5 - GR_OFFSET1)
#define Cyr_ju	(0xc6 - GR_OFFSET1)
#define Cyr_ja	(0xc7 - GR_OFFSET1)

#define Cyr_D	(0xe0 - GR_OFFSET2)
#define Cyr_C	(0xe1 - GR_OFFSET2)
#define Cyr_Schtsch (0xe2 - GR_OFFSET2)
#define Cyr_d	(0xe3 - GR_OFFSET2)
#define Cyr_f	(0xe4 - GR_OFFSET2)
#define Cyr_c	(0xe5 - GR_OFFSET2)
#define Cyr_schtsch (0xe6 - GR_OFFSET2)

 #ifdef LCD_ST_TYPE
 // is graphical display, use special czech characters
 #define Cz_a	0x10
 #define Cz_c	0x11
 #define Cz_d	0x12
 #define Cz_e	0x13
 #define Cz_ee	0x14
 #define Cz_i	0x15
 #define Cz_n	0x16
 #define Cz_o	0x17
 #define Cz_r	0x18
 #define Cz_s	0x19
 #define Cz_t	0x1a
 #define Cz_u	0x1b
 #define Cz_uu	0x1c
 #define Cz_y	0x1d
 #define Cz_z	0x1e
 #define Cz_Z	0x1f
 // CaractÃ¨res accentues francais
 #define Fr_a_grave	0x10
 #define Fr_a_circ	0x11
 #define Fr_e_aigu	0x12
 #define Fr_e_circ	0x13
 #define Fr_e_grave 0x14 
#else 	
 // use ASCII replacements for czech characters
 #define Cz_a	'a'
 #define Cz_c	'c'
 #define Cz_d	'd'
 #define Cz_e	'e'
 #define Cz_ee	'e'
 #define Cz_i	'i'
 #define Cz_n	'n'
 #define Cz_o	'o'
 #define Cz_r	'r'
 #define Cz_s	's'
 #define Cz_t	't'
 #define Cz_u	'u'
 #define Cz_uu	'u'
 #define Cz_y	'y'
 #define Cz_z	'z'
 #define Cz_Z	'Z'
 // CaractÃ¨res ASCII de remplacement pour accentues francais
 #define Fr_a_grave	'a'
 #define Fr_a_circ	'a'
 #define Fr_e_aigu	'e'
 #define Fr_e_circ	'e'
 #define Fr_e_grave 'e' 

#endif

//defines for the big special "character" set, the graphical symbols
#define ICON_WIDTH 24
#define ICON_HEIGHT 32
#define BJT_NPN 0
#define N_E_IGBT 1
#define N_E_MOS 2
#define N_JFET 3
#define TRIAC 4
#define THYRISTOR 5
#define QUESTION 6
#define INDUCTOR 7
#define RESISTOR 8
#define CAPACITOR 9
#define DIODE_C_A 10
#define DIODES_C_A_C_A 11
#define DIODES_A_C_C_A 12
#define DIODES_C_A_A_C 13
#define RESISTORS 14
// define the positioning bits for lcd_big_icon
#define LCD_UPPER_LEFT 0xC0
#define LCD_UPPER_RIGHT 0x80
#define LCD_LOWER_LEFT 0x40
#define LCD_LOWER_RIGHT 0x00


lcd_defines.h

// file lcd-draw.c

//#include "Transistortester.h"
//#include "Makefile.h" //J-L

#ifdef WITH_GRAPHICS
//#include "bitmaps.h"
extern const unsigned char bmp_one_data[] PROGMEM;
extern const unsigned char bmp_two_data[] PROGMEM;
extern const unsigned char bmp_three_data[] PROGMEM;
extern uint8_t icon_xx;
extern uint8_t icon_yy;
static const unsigned char * const bmp_number[3] PROGMEM =
{
   bmp_one_data,
   bmp_two_data,
   bmp_three_data
};


//*****************************************************************************
// draw the pin number index to the relative position of the last icon location

void lcd_draw_pin(unsigned char index, char dx, char dy)
{
   const unsigned char *pbmp;

   pbmp = (const unsigned char *)pgm_read_word(&bmp_number[index]);
   lcd_pgm_bitmap(pbmp, icon_xx + dx, icon_yy + dy, 0);
}

//*****************************************************************************
// Draw the transistor pin numbers of transistor _trans to the last icon location
// only the position of the base pin is selectable
void lcd_draw_trans_pins( char dxb, char dyb)
{
//   const unsigned char *pbmp;

   lcd_draw_pin(_trans->e, 30, 24);	// relative to icon position
   lcd_draw_pin(_trans->b, dxb, dyb);	// relative to icon position
   lcd_draw_pin(_trans->c, 30, 0);	// relative to icon position
}

//*****************************************************************************
 #ifdef SHOW_ICONS
 // not enough Flash space for ShowIcons at ATmega328
// Show all Icons on the screen, up to four at one screen
void ShowIcons(void) {
#define ShowTime 15000  /* 15 seconds wait time, or key press, or rotary encoder movement */
 uint8_t cc;
 lcd_clear();
 lcd_big_icon(BJT_NPN|LCD_UPPER_LEFT);
 lcd_update_icon_opt(bmp_vakdiode, OPT_VREVERSE);
 lcd_big_icon(BJT_NPN|LCD_UPPER_RIGHT);
 lcd_update_icon(bmp_pnp);	// update for PNP
 lcd_set_cursor(5,0);
 lcd_MEM_string(NPN_str);
 lcd_set_cursor(5,(LCD_LINE_LENGTH / 2));
 lcd_MEM_string(PNP_str);
 wait_for_key_ms(ShowTime);

 lcd_clear();
 lcd_big_icon(N_JFET|LCD_LOWER_LEFT);
 lcd_big_icon(N_JFET|LCD_LOWER_RIGHT);
 lcd_update_icon(bmp_p_jfet);	// update to P_JFET
 lcd_set_cursor(2,1);
 lcd_data('N');		// N-Type
 lcd_data('-');
 lcd_MEM_string(jfet_str);
 lcd_set_cursor(2,1+(LCD_LINE_LENGTH / 2));
 lcd_data('P');		// P-Type
 lcd_data('-');
 lcd_MEM_string(jfet_str);
 wait_for_key_ms(ShowTime);

 lcd_clear();
 lcd_big_icon(N_E_IGBT|LCD_UPPER_LEFT);
 lcd_big_icon(N_E_IGBT|LCD_UPPER_RIGHT);
 lcd_update_icon(bmp_p_e_igbt);	// update to P-E-IGBT
 lcd_set_cursor(5,0);
 lcd_data('N');		// N-Type
 lcd_data('-');
 lcd_data('E');		// Enhancement Type
 lcd_MEM_string(igbt_str);
 lcd_set_cursor(6,(LCD_LINE_LENGTH / 2));
 lcd_data('P');		// P-Type
 lcd_data('-');
 lcd_data('E');		// Enhancement Type
 lcd_MEM_string(igbt_str);
 wait_for_key_ms(ShowTime);

 lcd_clear();
 lcd_big_icon(N_E_IGBT|LCD_LOWER_LEFT);
 lcd_update_icon(bmp_n_d_igbt);	// update to N-D-IGBT
 lcd_big_icon(N_E_IGBT|LCD_LOWER_RIGHT);
 lcd_update_icon(bmp_p_d_igbt);	// update to P-D-IGBT
 lcd_set_cursor(1,0);
 lcd_data('N');		// N-Type
 lcd_data('-');
 lcd_data('D');		// Depletion Type
 lcd_MEM_string(igbt_str);
 lcd_set_cursor(2,(LCD_LINE_LENGTH / 2));
 lcd_data('P');		// P-Type
 lcd_data('-');
 lcd_data('D');		// Depletion Type
 lcd_MEM_string(igbt_str);
 wait_for_key_ms(ShowTime);

 lcd_clear();
 lcd_big_icon(N_E_MOS|LCD_UPPER_LEFT);
 lcd_big_icon(N_E_MOS|LCD_UPPER_RIGHT);
 lcd_update_icon(bmp_p_e_mos);  // update to P-E-MOS
 lcd_set_cursor(5,0);
 lcd_data('N');		// N-Type
 lcd_data('-');
 lcd_data('E');		// Enhancement Type
 lcd_MEM_string(mosfet_str);
 lcd_set_cursor(6,(LCD_LINE_LENGTH / 2));
 lcd_data('P');		// P-Type
 lcd_data('-');
 lcd_data('E');		// Enhancement Type
 lcd_MEM_string(mosfet_str);
 wait_for_key_ms(ShowTime);

 lcd_clear();
 lcd_big_icon(N_E_MOS|LCD_LOWER_LEFT);
 lcd_update_icon(bmp_n_d_mos);  // update to N-D-MOS
 lcd_big_icon(N_E_MOS|LCD_LOWER_RIGHT);
 lcd_update_icon(bmp_p_d_mos);  // update to P-D-MOS
 lcd_set_cursor(1,1);
 lcd_data('N');		// N-Type
 lcd_data('-');
 lcd_data('D');		// Depletion Type
 lcd_MEM_string(mosfet_str);
 lcd_set_cursor(2,1+(LCD_LINE_LENGTH / 2));
 lcd_data('P');		// P-Type
 lcd_data('-');
 lcd_data('D');		// Depletion Type
 lcd_MEM_string(mosfet_str);
 wait_for_key_ms(ShowTime);
 #if (ICON_ELEMENTS == 14)
 lcd_clear();
 lcd_big_icon(TRIAC|LCD_UPPER_LEFT);
 lcd_big_icon(THYRISTOR|LCD_UPPER_RIGHT);
 wait_for_key_ms(ShowTime);

 lcd_clear();
 lcd_big_icon(INDUCTOR|LCD_LOWER_LEFT);
 lcd_big_icon(CAPACITOR|LCD_LOWER_RIGHT);
 lcd_big_icon(RESISTOR|LCD_UPPER_LEFT);
 lcd_big_icon(RESISTORS|LCD_UPPER_RIGHT);
 wait_for_key_ms(ShowTime);

 lcd_clear();
 lcd_big_icon(DIODE_C_A|LCD_UPPER_LEFT);
 lcd_big_icon(DIODES_C_A_C_A|LCD_UPPER_RIGHT);
 lcd_big_icon(DIODES_A_C_C_A|LCD_LOWER_LEFT);
 lcd_big_icon(DIODES_C_A_A_C|LCD_LOWER_RIGHT);
 wait_for_key_ms(ShowTime);
 #endif

 
 lcd_clear();
 lcd_line1();
 lcd_MEM_string(Resistor_str);    // -[=]-
 lcd_line2();
 lcd_MEM_string(Inductor_str);         // -ww-
 lcd_line3();
 lcd_MEM_string(CapZeich);          // capacitor sign
 lcd_line4();
 lcd_MEM_string(AnKat_str);       //"->|-"
 lcd_space();
 lcd_MEM_string(KatAn_str);       //"-|<-"


// show character set
 for (cc=0;cc<(0x7f-0x20);cc++) {
   if ((cc%LCD_LINE_LENGTH) == 0) {
     // begin new line
     if(((cc/LCD_LINE_LENGTH) % LCD_LINES) == 0) {
       wait_for_key_ms(ShowTime);
       lcd_clear();
     }
     lcd_set_cursor(((cc/LCD_LINE_LENGTH)%LCD_LINES)*PAGES_PER_LINE,0);
   }
  lcd_data(cc+0x20);
 } /* end for cc */
 wait_for_key_ms(ShowTime);

 lcd_clear();
  #ifdef LCD_CYRILLIC
 for (cc=0;cc<((Cyr_ja+1-Cyr_B)+(Cyr_schtsch+1-Cyr_D));cc++) {
   if ((cc%LCD_LINE_LENGTH) == 0) {
     // begin new line
     lcd_set_cursor(((cc/LCD_LINE_LENGTH)%LCD_LINES)*PAGES_PER_LINE,0);
   }
   if (cc <= (Cyr_ja-Cyr_B))
   {
     lcd_data(cc + Cyr_B);
   } else {
     lcd_data(cc + Cyr_D - (Cyr_ja + 1 - Cyr_B));
   }
 } /* end for cc */
 wait_for_key_ms(ShowTime);

 lcd_clear();
  #endif

}
 #endif  /* defined(SamplingADC) || (FLASHEND > 0x7fff)  */
#else
 #warning "no WITH_GRAPHICS" 
#endif  /* WITH_GRAPHICS */


lcd_draw.ino

lcd_hw_4_bit.ino

//#include <stdint.h>
//#include "Makefile.h" //J-L


// Interfacing of a HD44780 compatible LCD with 4-Bit-Interface mode
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
//

extern void _lcd_hw_write(uint8_t flags, uint8_t data);
extern void _lcd_hw_select(uint8_t flags);

//LCD
void lcd_testpin(unsigned char temp);
void lcd_data(unsigned char temp1);
void lcd_big_icon(unsigned char temp1);
void lcd_update_icon(const unsigned char * ubitmap);
void lcd_update_icon_opt(const unsigned char * ubitmap, unsigned char options);
void lcd_space(void);			// clear one character
void lcd_equal(void);			// send = character to display
void lcd_spaces(int8_t number);	        // clear number characters (number negative -> no chars cleared)
void lcd_command(unsigned char temp1);
void lcd_string(char *data);
void lcd_init(void);
void lcd_clear(void);
void lcd_fix_string(const unsigned char *data);
void lcd_pgm_string(const unsigned char *data);
void lcd_fix_customchar(const unsigned char *chardata);
void lcd_clear_line(void);		// clear 20 characters
void lcd_clear_line1(void);		// clear line 1 of display
void lcd_clear_line2(void);		// clear line 2 of display
void lcd_set_cursor(unsigned char y, unsigned char x);
uint8_t lcd_save_position(void);	// save the last Character position (line,column) and returns the line
void lcd_restore_position(void);	// restore the character position, saved with lcd_save_position()
void lcd_next_line(uint8_t xx);		// y is incremented by 1
void lcd_next_line_wait(uint8_t xx);		// y is incremented by 1 and call wait_for_key_5s_line2
void lcd_powersave(void);
void lcd_line1(void);
void lcd_line2(void);
void lcd_line3(void);
void lcd_line4(void);

unsigned char reverse_byte(unsigned char);
void lcd_show_Cg(void);		// show Cg=xxxpF
void lcd_show_rds(uint8_t xpos);      // show Rgs at column xpos
// Graphics display only: Some drawing functions for graphics LCD
void lcd_pgm_bitmap(const unsigned char * pbitmap,
                    unsigned char x, unsigned char y,
                    unsigned char options);
void lcd_set_pixels(const unsigned char * pdata,
                    unsigned char x, unsigned char y,
                    unsigned char options,
                    unsigned char width, unsigned char height);
#ifdef WITH_GRAPHICS
void ShowIcons(void);		/* show the different Icons */
void lcd_draw_pin(unsigned char index, char dx, char dy);
void lcd_draw_trans_pins( char dxb, char dyb);
#endif
#if (LCD_ST_TYPE == 7920)
void lcd_refresh(void);		/* for ST7920 controller only*/
#endif

//Software-UART
void uart_putc(uint8_t data);
#ifdef WITH_UART
 void uart_newline(void);
#endif


lcd_routines.h

lcd_routines.ino

// Interfacing a HD44780 compatible LCD with  4-Bit-Interface mode
// http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial
//
// Pin selection can be changed in lcd-routines.h with define

//#include "Transistortester.h"

#ifdef WITH_HARDWARE_SERIAL

void uart_putc(unsigned char passed_char){	
 Serial.write(passed_char);  // Print to serial monitor
}
    


void uart_newline(void) {
     uart_putc('\r');
     uart_putc('\n');
}

uint8_t rawSerial = 0;

void outString(char *s) {
	while(*s) {
		uart_putc(*s);
		s++;
	}
}

uint8_t last_text_line;
uint8_t last_text_column;

/* ******************************************************************************* */
// sends numeric character (Pin Number) to the LCD 
// from binary 0 we send ASCII 1 ....
void lcd_testpin(unsigned char temp) {
	lcd_data(temp + '1' + TP_OFFSET - TP_MIN);
}

/* ******************************************************************************* */
// send space character to LCD
void lcd_space(void) {
   lcd_data(' ');	// output one space to LCD and UART
}

void lcd_spaces(int8_t nn) {
   while (nn > 0) {
     lcd_space();	// output one space to LCD and UART
     nn--;
   }
}
// send equal character to LCD
void lcd_equal(void) {
   lcd_data('=');
}

/* ******************************************************************************* */
//move to the beginning of the 1. row
void lcd_line1() {
   lcd_text_line = 0;
   _lcd_column = 0;
   uart_newline();
}

/* ******************************************************************************* */
//move to the beginning of the 2. row
// for the ST7920 you can select a accurate vertical pixel positioning of line with:
// or you can select a 8-line rounding of the positioning of the lines with: 
//#define FONT_V_SPACE (((FONT_HEIGHT + 7) / 8) * 8)
void lcd_line2() {
   lcd_text_line = 1;
   _lcd_column = 0;
   uart_newline();
}

/* ******************************************************************************* */
//move to the beginning of the 3. row
void lcd_line3() {
   lcd_text_line = 2;
   _lcd_column = 0;
   uart_newline();
}

/* ******************************************************************************* */
//move to the beginning of the 4. row
void lcd_line4() {
   lcd_text_line = 3;
   _lcd_column = 0;
   uart_newline();
}

/* ******************************************************************************* */
// position to next line to column xx
// Text_line number is incremented by 1, if possible (not yet at the last line).
// If already at the last line of the display, last_line_used is set to 1 .
void lcd_next_line(uint8_t xx) {
   lcd_clear_line();
   lcd_text_line ++;
   if (lcd_text_line > (LCD_LINES - 1))  {
      // Limit is reached
      lcd_text_line = (LCD_LINES - 1);
      last_line_used = 1;
   } else {
      last_line_used = 0;
   }
   _lcd_column = xx;
   uart_newline();
}
/* ******************************************************************************* */
#ifdef WAIT_LINE2_CLEAR
void lcd_next_line_wait(uint8_t xx) {
   lcd_next_line(xx);
   wait_for_key_5s_line2();		// wait 5s and clear last line
}
#endif

/* ************************************************************************************** */
/* Set the character position to x,y , where x specifies the character number in a text line. */
/* The y position is the page address (8 line units).                                     */
/* For most controllers the y position must be increased by (Height + 7) / 8 for the next text line */
void lcd_set_cursor(uint8_t y, uint8_t x) {
	lcd_text_line = y;
    _lcd_column = x;
    if (x == 0) uart_newline();
}

#if FLASHEND > 0x1fff
/* ************************************************************************************** */
uint8_t lcd_save_position(void) {
 last_text_column = _lcd_column;
 last_text_line = lcd_text_line;
 return(last_text_line);
}
/* ************************************************************************************** */
void lcd_restore_position(void) {
 lcd_set_cursor((uint8_t)last_text_line, (uint8_t)last_text_column);
}
#endif

/* ******************************************************************************* */
/* ******************************************************************************* */
// sends a character to the LCD 
void lcd_data(unsigned char temp1) {
/* -------------------------------------------------------------------------- */

 _lcd_column++;
 switch(temp1) {
    case LCD_CHAR_DIODE1:
    	uart_putc('>');
    	uart_putc('|');
        _lcd_column++;
   	break;
    case LCD_CHAR_DIODE2:
    	uart_putc('|');
    	uart_putc('<');
        _lcd_column++;
   	break;
    case LCD_CHAR_CAP:
    	uart_putc('|');
    	uart_putc('|');
        _lcd_column++;
    	break;
    case LCD_CHAR_RESIS1:
    case LCD_CHAR_RESIS2:
    	uart_putc('R');
    	break;
    case LCD_CHAR_LINE1:
    	uart_putc('-');
        break;
//    case LCD_CHAR_DEGREE:	// degree sign
//    	uart_putc(0xf8);	// codepage 437 or 850 has degree
//    	break;
    case LCD_CHAR_U:		// Âµ
    	uart_putc('u');
    	break;
    case LCD_CHAR_OMEGA:	//Omega
    	uart_putc('O');
    	uart_putc('h');
    	uart_putc('m');
        _lcd_column += 2;
    	break;
 #if LCD_CHAR_INDUCTOR1 != 'w'
    case LCD_CHAR_INDUCTOR1:
    case LCD_CHAR_INDUCTOR2:
    	uart_putc('L');
        break;
 #endif
    default:
    	uart_putc(temp1);
 }
} /* end lcd_data() */


 
// sends a command to the LCD
 
void lcd_command(unsigned char temp1) {
}
 
/* ******************************************************************************* */
// Initialise: 
// Must be called first .
// every controller has its own initialize sequence!
 
/* -------------------------------------------------------------------------- */
void lcd_init(void) {
       // setup UART 
 #define BAUD_SET ((F_CPU / 8 / BAUDRATE ) - 1)
 #if (((F_CPU == 16000000UL) && (BAUDRATE == 57600)) | (BAUD_SET > 4095))
  // hardcoded exception for 57600 for compatibility with the bootloader
  // shipped with the Duemilanove and previous boards and the firmware
  // on the 8U2 on the Uno and Mega 2560. Also, The baud_setting cannot
  // be > 4095, so switch back to non-u2x mode if the baud rate is too
  // low.

        UCSR0A = 0;
        UBRR0H = (uint8_t) (((F_CPU / 16 / BAUDRATE) - 1) >> 8);
        UBRR0L = (uint8_t) (((F_CPU / 16 / BAUDRATE) - 1));
 #else
        UCSR0A = (1 << U2X0);
        UBRR0H = (uint8_t) (BAUD_SET >> 8);
        UBRR0L = (uint8_t) (BAUD_SET);
 #endif
//        UCSR0C = (1<<USBS0) | (1<<UCSZ00);	// 8 bit mode, 1 Stop bit, no parity
        UCSR0C = (1<<USBS0) | (3<<UCSZ00);	// 8 bit mode, 2 Stop bit, no parity
        UCSR0B = (1<<RXEN0) | (1<<TXEN0);	// enable TX and RX data transfer

}

/* ******************************************************************************* */
// send the command to clear the display 
 
void lcd_clear(void) {
        uart_newline();
	for(uint8_t x = 0; x < LCD_LINE_LENGTH; x++) {
                uart_putc(' ');
	}
	lcd_line1();
}
 
/* ******************************************************************************* */
// writes a string to the LCD 
 
void lcd_string(char *data) {
	outString(data);
}

#ifdef use_lcd_pgm
//Load string from PGM  and send to LCD 
void lcd_pgm_string(const unsigned char *data) {
   unsigned char cc;
   while(1) {
      cc = pgm_read_byte(data);
      if((cc==0) || (cc==128)) {
         return;
      }
      lcd_data(cc);
      data++;
   }
}
#endif

/* ******************************************************************************* */
#ifdef USE_EEPROM
//Load string from PGM or EEprom and send to LCD 
void lcd_fix_string(const unsigned char *data) {
   unsigned char cc;
   while(1) {
      cc = MEM_read_byte(data);
      if((cc==0) || (cc==128)) {
         return;
      }
      lcd_data(cc);
      data++;
   }
}
#endif

/* ******************************************************************************* */
// load custom character from PGM or EEprom and send to LCD
void lcd_fix_customchar(const unsigned char *chardata) {	
#if (LCD_ST_TYPE == 0)
    uint8_t ii;
    for (ii=0;ii<8;ii++) {
        lcd_data(MEM_read_byte(chardata++));
    }
#endif
}

/* ******************************************************************************* */
void lcd_clear_line(void) {
 // writes spaces up to LCD_LINE_LENGTH to LCD-Display, Cursor can be positioned to any column
    lcd_spaces(LCD_LINE_LENGTH - _lcd_column);
}

#ifdef LCD_CLEAR
void lcd_clear_line1(void) {
    lcd_line1();
    lcd_clear_line();
    lcd_line1();
}
void lcd_clear_line2(void) {
    lcd_line2();
    lcd_clear_line();
    lcd_line2();
}
#endif

/* ******************************************************************************* */
/* Function lcd_set pixels                                                         */
/* pdata is a pointer to the byte array in the program memory holding the pixel data. */
/* x,y specifies the target position of this data at the display.                  */
/* The parameter options can specify a inverted position in x or/and y direction.  */
/* width and height specifies the dimension of the pixel field.                    */
/* The different controller types uses different ways of loading the pixels.       */
/* For the ST7920 controller the changes are only made in a memory field (RAM).    */
/* ******************************************************************************* */
void lcd_set_pixels(const unsigned char *pdata, unsigned char x, unsigned char y,
unsigned char options, unsigned char width, unsigned char height) {
//	serialPrintf("lcd_set_pixels not implemented\n");
}
/* ******************************************************************************* */
void lcd_show_Cg(void) {
   lcd_MEM_string(GateCap_str);             //"Cg="
   if (cap.cpre < -3) {
	  DisplayValue(cap.cval,cap.cpre,'F',3);
   } else {
	  lcd_data('?');
   }
}
#ifdef SHOW_R_DS
void lcd_show_rds(uint8_t xpos)
{
       if ((PartMode&0x0f) == PART_MODE_MOS) {     /* kein JFET or IGBT */
          lcd_next_line_wait(xpos);
          lcd_MEM_string(RDS_str);		// "RDS=
          DisplayValue16(_trans->uBE,-1,LCD_CHAR_OMEGA,2);	// Drain-Source resistance
       }
}
#endif
#endif // end #ifdef WITH_HARDWARE_SERIAL


lcd_routines_serial.ino

/***************************************************************
* Makefile Options setting Arduino/Genuino UNO  or Mega 2560   *
***************************************************************/

// current file is set for MEGA with OLED 1306 I2C


/* Board selection  UNO or MEGA */
//#define PARTNO m2560 // uncomment in case of MEGA 2560 board
#define ARDUINO_UNO // uncomment in case of UNO board
#define NO_FREQ_COUNTER // uncomment when UNO Board , FREQ counter function only with MEGA 2560 Board


/* if no Display at all, use Serial Monitor Output
   uncomment these lines */
//#define WITH_HARDWARE_SERIAL
//#define BAUDRATE 115200
//#define WITH_UART 0


/* if no Serial Monitor and no Graphic Display below uncommented
, its 4 bits parallel mode 1602 LCD by default */


/* if the 1602 LCD has a I2C interface 
uncomment these 2 line */
#define WITH_1602_I2C
#define LCD_I2C_ADDR 0x27


/* with OLED 1306  I2C interface uncomment this lines */
//#define FOUR_LINE_LCD 0
//#define WITH_LCD_ST7565 1306
//#define LCD_INTERFACE_MODE 2
//#define LCD_ST_TYPE 1306
//#define LCD_I2C_ADDR 0x3c


/* with OLED 1306  SPI interface uncomment this lines */
//#define FOUR_LINE_LCD 0
//#define WITH_LCD_ST7565 1306
//#define LCD_ST_TYPE 1306
//#define LCD_ST7565_RESISTOR_RATIO 4


/* with LCD 7920 serial, uncomment next 3 lines */
//#define FOUR_LINE_LCD 0
//#define WITH_LCD_ST7565 7920
//#define LCD_INTERFACE_MODE 5


/* with LCD ST 7735, uncomment next lines */ 
//#define FOUR_LINE_LCD 0
//#define WITH_LCD_ST7565 1
//#define LCD_ST_TYPE 7735 
//#define LCD_ST7565_RESISTOR_RATIO 4
//#define FONT_8X12thin
//#define ICON_TYPE 2
//#define BIG_TP
//#define LCD_INTERFACE_MODE MODE_SPI
//#define VOLUME_VALUE 25
//#define DLCD_ST7565_V_FLIP 1
//#define DLCD_ST7565_H_FLIP 1
//#define DLCD_ST7565_H_OFFSET 4


/* with LCD 7108 display uncomment this lines */
//#define FOUR_LINE_LCD 0
//#define WITH_LCD_ST7565 7108
//#define ST_CS_LOW
//#define LCD_INTERFACE_MODE MODE_7108_SERIAL
//#define LCD_INTERFACE_MODE MODE_SPI


/* with LCD 1327  I2C */
//#define FOUR_LINE_LCD 0
//#define WITH_LCD_ST7565 1327
//#define LCD_INTERFACE_MODE 2
//#define LCD_I2C_ADDR 0x3d
//#define LCD_ST_TYPE 1327


#define WITH_MENU 0 
#define UI_LANGUAGE LANG_ENGLISH
#define WITH_SELFTEST
#define AUTO_CAL
#define SHORT_UNCAL_MSG

#define WITH_SamplingADC 1
#define SamplingADC
#define FET_Idss
#define WITH_AUTO_REF
#define REF_C_KORR 12
#define REF_L_KORR 40
#define C_H_KORR 0


#define RMETER_WITH_L 0 
#define CAP_EMPTY_LEVEL 4
#define AUTOSCALE_ADC
#define REF_R_KORR 3
#define ESR_ZERO 20
#define OP_MHZ 16
#define MHZ_CPU OP_MHZ 
#define PULLUP_DISABLE
#define ANZ_MESS 25
#define POWER_OFF 0 
#define BAT_OUT 150
#define BAT_POOR 6400
#define INHIBIT_SLEEP_MODE 1

//#define VEXT

// if other RH , RL resistors
//#define R_H_VAL 10000 // 100kOhm instead of 470k
//#define R_L_VAL 3300  // 330 Ohm instead of 680


Makefile.h

/*
#include <avr/io.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/

//=================================================================
// Clear display, show Message XX_str and wait for key release

#if FLASHEND > 0x3fff
void message_key_released(const unsigned char XX_str[]) {
 
  uint8_t times;
//#ifdef WITH_ROTARY_SWITCH
//  lcd_line1();
//  lcd_clear_line();
//  lcd_line2();
//  lcd_clear_line();
//  lcd_line1();
//#else
  lcd_clear();
//#endif
  lcd_MEM2_string(XX_str);		// display MEM2_str in row 1
  for (times=0;times<100;times++) {
     wait_about10ms();
    if((RST_PIN_REG & (1<<RST_PIN))) break;	// key is released
  }
  lcd_line2();
  return;
} /* end message_key_released() */

#endif


message_key_released.ino


//definitions of parts  (values for global variable PartFound)
#define PART_NONE 0
#define PART_RESISTOR 1
#define PART_UJT 2
#define PART_DIODE 3
#define PART_TRANSISTOR 4
#define PART_FET 5
#define PART_THYRISTOR 6
#define PART_TRIAC 7
#define PART_CAPACITOR 8
#define PART_CELL 9
#define PART_PUT 10
#define PART_CERAMICRESONATOR 11
#define PART_XTAL 12

//End (parts)

//special definition for different parts   (values for global variable PartMode)
//FETs , even numbers are N-type
#define PART_MODE_NONE 0
#define PART_MODE_MOS 2
#define PART_MODE_IGBT 3
#define PART_MODE_JFET 4
#define P_CHANNEL 0x10
#define N_CHANNEL 0x00
#define D_MODE 0x20
#define E_MODE 0x00

//Bipolar
#define PART_MODE_NPN 12
#define PART_MODE_PNP 13


part_defs.h

/*
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/

// show the Pin Layout of the device 
void PinLayout(char pin1, char pin2, char pin3) {
// pin1-3 is EBC or SGD or CGA
#ifndef EBC_STYLE
   // Layout with 123= style
   uint8_t ipp;
   lcd_MEM_string(N123_str);		//" 123="
   for (ipp=0;ipp<3;ipp++) {
       if (ipp == _trans->e)  lcd_data(pin1);	// Output Character in right order
       if (ipp == _trans->b)  lcd_data(pin2);
       if (ipp == _trans->c)  lcd_data(pin3);
   }
#else	/* EBC_STYLE is defined */
 #if EBC_STYLE == 321
   // Layout with 321= style
   uint8_t ipp;
   lcd_MEM_string(N321_str);		//" 321="
   ipp = 3;
   while (ipp != 0) {
       ipp--;
       if (ipp == _trans->e)  lcd_data(pin1);	// Output Character in right order
       if (ipp == _trans->b)  lcd_data(pin2);
       if (ipp == _trans->c)  lcd_data(pin3);
   }
 #else 
   // Layout with EBC= style
   lcd_space();
   lcd_data(pin1);
   lcd_data(pin2);
   lcd_data(pin3);
   lcd_equal();		// lcd_data('=');
   lcd_testpin(_trans->e);
   lcd_testpin(_trans->b);
   lcd_testpin(_trans->c);
 #endif
#endif
}

#ifdef WITH_GRAPHICS
void PinLayoutLine(char pin1, char pin2, char pin3) {
   lcd_next_line_wait(0);
 #ifdef NO_LONG_PINLAYOUT
   lcd_space();
   lcd_MEM_string(Pin_str);		//"Pin "
   PinLayout(pin1, pin2, pin3);		// short form of Layout
 #else
   lcd_MEM_string(Pin_str);		//"Pin "
// pin1-3 is EBC or SGD or CGA
  #ifndef EBC_STYLE
   // Layout with 1=  2=  3=  style
   uint8_t ipp;
   for (ipp=0;ipp<3;ipp++) {
      lcd_testpin(ipp);
      lcd_equal();		// lcd_data('=');
      if (ipp == _trans->e)  lcd_data(pin1);	// Output Character in right order
      if (ipp == _trans->b)  lcd_data(pin2);
      if (ipp == _trans->c)  lcd_data(pin3);
      lcd_space();
   }
  #else	/* EBC_STYLE is defined */
   #if EBC_STYLE == 321
   // Layout with 3=  2=  1=  style
   uint8_t ipp;
   ipp = 3;
   while (ipp != 0) {
       ipp--;
       lcd_testpin(ipp);
       lcd_equal();		// lcd_data('=');
       if (ipp == _trans->e)  lcd_data(pin1);	// Output Character in right order
       if (ipp == _trans->b)  lcd_data(pin2);
       if (ipp == _trans->c)  lcd_data(pin3);
       lcd_space();
   }
   #else 
   // Layout with E=  B=  C=  style
   lcd_data(pin1);
   lcd_equal();		// lcd_data('=');
   lcd_testpin(_trans->e);
   lcd_space();
   lcd_data(pin2);
   lcd_equal();		// lcd_data('=');
   lcd_testpin(_trans->b);
   lcd_space();
   lcd_data(pin3);
   lcd_equal();		// lcd_data('=');
   lcd_testpin(_trans->c);
   #endif
  #endif
 #endif  /* NO_LONG_PINLAYOUT */
}
#endif  /* WITH_GRAPHICS */

/* ********************************************************** */
/* Rnum2pins computes two pin numbers for resistor number num */
uint16_t Rnum2pins(uint8_t num) {
uint8_t x,y;

  x = TP1;
  y = TP3;
  if (num == 0) y = TP2;
  if (num == 2) x = TP2;
  return ((uint16_t)(y<<8) | x);
}


PinLayout.ino

/*
#include <avr/io.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/


/*
extern struct ADCconfig_t{
  uint8_t Samples;              // number of ADC samples to take
  uint8_t RefFlag;              // save Reference type VCC of IntRef
  uint16_t U_Bandgap;           // Reference Voltage in mV
  uint16_t U_AVCC;		// Voltage of AVCC
} ADCconfig;
*/


#ifdef INHIBIT_SLEEP_MODE
//  #define StartADCwait() ADCSRA = (1<<ADSC) | (1<<ADEN) | (1<<ADIF) | AUTO_CLOCK_DIV; /* enable ADC and start */
    #define StartADCwait() ADCSRA = (1<<ADSC)|(1<<ADEN)|(1<<ADIF)|AUTO_CLOCK_DIV; /* Start conversion */\
    while (ADCSRA & (1 << ADSC));  /* wait until conversion is done */
#else
    #define StartADCwait() ADCSRA = (1<<ADEN) | (1<<ADIF) | (1<<ADIE) | AUTO_CLOCK_DIV; /*enable ADC and Interrupt */\
    set_sleep_mode(SLEEP_MODE_ADC);\
    sleep_mode();	/* Start ADC, return, if ADC has finished */
#endif

/***********************************************************************************/
/* ReadADC takes ADCconfig.Samples ADC reads and build a sum of the data           */
/* One ADC read take a time period about 112us.                                    */
/* So 25 ADC reads take more than 2.8ms time.                                      */
/* for resistor and other measurements 190 ADC reads are done with more than 21ms  */


unsigned int ReadADC (uint8_t Probe) {
 unsigned int U; /* return value (mV) */
 uint8_t samples; /* loop counter */
 unsigned long Value; /* ADC value */

 Probe |= (1 << REFS0); /* use internal reference anyway */

#ifdef AUTOSCALE_ADC
get_sample:
#endif  /* AUTOSCALE_ADC */

#if (PROCESSOR_TYP == 644) || (PROCESSOR_TYP == 1280)
 if (Probe & (1 << REFS1)) Probe &= ~(1<<REFS0);	/* ATmega640/1280/2560 1.1V Reference with REFS0=0 */
#endif

 ADMUX = Probe; /* set input channel and U reference */

#ifdef AUTOSCALE_ADC
 /* if voltage reference changes, wait for voltage stabilization */
 if ((Probe & (1<<REFS1)) != ADCconfig.RefFlag) {
    //  Reference is switched, delay depends on NO_AREF_CAP option
    ADCconfig.RefFlag = (Probe & (1<<REFS1));	// save new reference state
 #ifdef NO_AREF_CAP
    wait100us(); /* time for voltage stabilization */
 #else
    wait_about10ms(); /* time for voltage stabilization */
 #endif
// allways do one dummy read of ADC, 112us
    StartADCwait();		/* start ADC and wait */
 }
#endif  /* AUTOSCALE_ADC */

 /* * sample ADC readings */
 Value = 0UL; /* reset sampling variable */
 samples = 0; /* number of samples to take */
 while (samples < ADCconfig.Samples) /* take samples */ {
    StartADCwait();		/* start ADC and wait */
    Value += ADCW; /* add ADC reading */
#ifdef AUTOSCALE_ADC
    /* auto-switch voltage reference for low readings */
    if ((samples == 4) && (ADCconfig.U_Bandgap > 255) && ((uint16_t)Value < 1024) && !(Probe & (1<<REFS1))) {
       Probe |= (1 << REFS1); /* select internal bandgap reference */
       goto get_sample; /* re-run sampling */
    }
#endif
    samples++; /* one more done */
 }  /* end while */
#ifdef AUTOSCALE_ADC
 /* * convert ADC reading to voltage * - single sample: U = ADC reading * U_ref / 1024 */
 /* get voltage of reference used */
 if (Probe & (1 << REFS1)) U = ADCconfig.U_Bandgap; /* bandgap reference */
 else U = ADCconfig.U_AVCC; /* Vcc reference */
#else
 U = ADCconfig.U_AVCC; /* Vcc reference */
#endif

 /* convert to voltage; */
 Value *= U; /* ADC readings * U_ref */
 Value /= 1023; /* / 1024 for 10bit ADC */
 /* de-sample to get average voltage */
 Value /= ADCconfig.Samples;
 U = (unsigned int)Value;
 return U;
//   return ((unsigned int)(Value / (1023 * (unsigned long)ADCconfig.Samples)));
}
unsigned int W5msReadADC (uint8_t Probe) {
  wait_about5ms();
  return (ReadADC(Probe));
}
unsigned int W10msReadADC (uint8_t Probe) {
  wait_about10ms();
  return (ReadADC(Probe));
}
unsigned int W20msReadADC (uint8_t Probe) {
  wait_about20ms();
  return (ReadADC(Probe));
}

uint16_t unsigned_diff(uint16_t v1, uint16_t v2)
{
  if (v1 > v2) return (v1 - v2);
  else         return (0);
}
uint16_t abs_diff(uint16_t v1, uint16_t v2)
{
  if (v1 > v2) return (v1 - v2);
  else         return (v2 - v1);
}

uint16_t vcc_diff(uint16_t v2)
{
  return unsigned_diff(ADCconfig.U_AVCC, v2);
//  if (ADCconfig.U_AVCC > v2) return (ADCconfig.U_AVCC - v2);
//  else         return (0);
}


ReadADC.ino

// new code by K.-H. Kübbeler
// ReadBigCap tries to find the value of a capacitor by measuring the load time.
// first of all the capacitor is discharged.
// Then a series of up to 1000 load pulses with 1ms duration each is done across the R_L (680Ohm)
// resistor.
// After each load pulse the voltage of the capacitor is measured without any load current.
// If voltage reaches a value of more than 300mV and is below 1.3V, the capacity can be
// computed from load time and voltage by a interpolating a build in table.
// If the voltage reaches a value of more than 1.3V with only one load pulse,
// the cap value is too low.
// If the measurement the load time is successful,
// the following variables are set:
// cap.cval = value of the capacitor 
// cap.cval_uncorrected = value of the capacitor uncorrected
// cap.esr = serial resistance of capacitor,  0.01 Ohm units
// cap.cpre = units of cap.cval ( -9=nF, -6=µF)
// ca   = Pin number (0-2) of the LowPin
// cb   = Pin number (0-2) of the HighPin


/*
#include <avr/io.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/

#ifdef WITH_MENU
//=================================================================
void ReadBigCap(uint8_t HighPin, uint8_t LowPin) {
  // check if capacitor and measure the capacity value
  // unsigned int adcv[4];
  int residual_voltage;
  int cap_voltage1;
#ifdef INHIBIT_SLEEP_MODE
  unsigned int ovcnt16;
#endif
  uint8_t HiPinR_L;
  uint8_t LoPinR_L;
  uint8_t LoADC;

//#ifdef AUTO_CAL
//  pin_combination = ((HighPin - TP_MIN) * 3) + LowPin - TP_MIN - 1;	// coded Pin combination for capacity zero offset
//#endif

#if (((PIN_RL1 + 1) != PIN_RH1) || ((PIN_RL2 + 1) != PIN_RH2) || ((PIN_RL3 + 1) != PIN_RH3))
  LoADC = pgm_read_byte((&PinRLRHADCtab[6])+LowPin-TP_MIN) | TXD_MSK;
#else
  LoADC = pgm_read_byte((&PinRLRHADCtab[3])+LowPin-TP_MIN) | TXD_MSK;
#endif
  HiPinR_L = pgm_read_byte(&PinRLRHADCtab[HighPin-TP_MIN]);	//R_L mask for HighPin R_L load
  LoPinR_L = pgm_read_byte(&PinRLRHADCtab[LowPin-TP_MIN]);	//R_L mask for LowPin R_L load

#if FLASHEND > 0x1fff
  cap.esr = 0;				// set ESR of capacitor to zero
#endif
  cap.cval = 0;				// set capacity value to zero
  cap.cpre = -9;			//default unit is nF
  EntladePins();			// discharge capacitor
  ADC_PORT = TXD_VAL;			// switch ADC-Port to GND
// The polarity of residual voltage of the capacitor depends on the measurement
// history.   Because the ADC can not measure a negative Voltage,
// the LowPin voltage is shifted to 139mV with the R_L resistor.
// The voltage of the capacitor is build as difference between HighPin and LowPin voltage.
  ADC_DDR = LoADC;			// switch Low-Pin to output (GND)
  R_DDR = LoPinR_L;			// switch R_L Port of LoPin to VCC
  R_PORT = LoPinR_L;			// switch R_L Port of LoPin to VCC
  residual_voltage = ReadADC(HighPin) - ReadADC(LowPin);	// capacitor voltage before any load 
  R_DDR = 0;				// switch all R_L Port to input
  cap_voltage1 = 0;			// preset to prevent compiler warning
  
  ovcnt16 = 0;
#define MAX_LOAD_TIME 12500
#define MIN_VOLTAGE 300
  while (ovcnt16 < MAX_LOAD_TIME) {
     R_PORT = HiPinR_L;			//R_L to 1 (VCC) 
     if ((ovcnt16 == 0) || ((MIN_VOLTAGE-cap_voltage1) < (cap_voltage1*10/ovcnt16))) {
        R_DDR = HiPinR_L;		//switch Pin to output, across R to VCC
        wait200us();			// wait exactly 0.2ms, do not sleep
        R_DDR = 0;			// switch back to input
        ovcnt16++;
     } else if ((ovcnt16 > 10) && ((MIN_VOLTAGE-cap_voltage1) > ((cap_voltage1*100)/ovcnt16))){
        R_DDR = HiPinR_L;		//switch Pin to output, across R to VCC
        wait20ms();			// wait exactly 20ms, do not sleep
        R_DDR = 0;			// switch back to input
        ovcnt16 += 100;
     } else {
        R_DDR = HiPinR_L;		//switch Pin to output, across R to VCC
        wait2ms();			// wait exactly 2ms, do not sleep
        R_DDR = 0;			// switch back to input
        ovcnt16 += 10;
     }
     R_PORT = 0;			// no Pull up
     wait50us();			//wait a little time
     wdt_reset();
     // read voltage without current, is already charged enough?
     cap_voltage1 = ReadADC(HighPin) - residual_voltage;	// voltage loaded to capacitor
     if ((ovcnt16 > (MAX_LOAD_TIME/8)) && (cap_voltage1 < (MIN_VOLTAGE/8))) {
        // 300mV can not be reached well-timed 
        break;		// don't try to load any more
     }
     // probably 50mF can be charged well-timed 
     if (cap_voltage1 > MIN_VOLTAGE) {
        break;		// lowest voltage to get capacity from load time is reached
     }
  }
  // wait 5ms and read voltage again, does the capacitor keep the voltage?
//  adcv[1] = W5msReadADC(HighPin) - adcv[0];
//  wdt_reset();
  if (cap_voltage1 <= MIN_VOLTAGE) {
     goto keinC;		// was never charged enough, >20mF or shorted
  }
  //voltage is rised properly and keeps the voltage enough
  if ((ovcnt16 == 1 ) && (cap_voltage1 > 1300)) {
     goto keinC;		// Voltage of more than 1300mV is reached in one pulse, too fast loaded
  }
  // Capacity is more than about 50µF
  cap.cval_uncorrected.dw = ovcnt16*2;
  // compute factor with load voltage + lost voltage during the voltage load time
//  cap.cval_uncorrected.dw *= GetRLmultip(cap_voltage1);	// get factor to convert time to capacity from table
  cap.cval_uncorrected.dw *= GetRLmultip(cap_voltage1 + cap_voltage1/40);	// get factor to convert time to capacity from table
   cap.cval = cap.cval_uncorrected.dw;	// set result to uncorrected
   Scale_C_with_vcc();
   // cap.cval for this type is at least 40000nF, so the last digit will be never shown
//   cap.cval -= ((cap.cval * C_H_KORR) / 1000);	// correct with C_H_KORR with 0.1% resolution, but prevent overflow
//   cap.cval /= 10;
#ifdef WITH_MENU
   cap.cval *= (1000 - (int8_t)eeprom_read_byte((uint8_t *)&big_cap_corr));	// correct with actual big_cap_korr at 0.1% resolution
#else
   cap.cval *= (1000 - C_H_KORR);	// correct with C_H_KORR at 0.1% resolution
#endif
   cap.cval /= 10000;

//==================================================================================

   PartFound = PART_CAPACITOR;	//capacitor is found
      cap.cval_max = cap.cval;
      cap.cpre_max = cap.cpre;
#if FLASHEND > 0x1fff
      cap.v_loss = 0;			// set lost voltage to zero
#endif
      cap.ca = LowPin;		// save LowPin
      cap.cb = HighPin;		// save HighPin

keinC:
  // discharge capacitor again
//  EntladePins();		// discharge capacitors
  //ready
  // switch all ports to input
  ADC_DDR =  TXD_MSK;		// switch all ADC ports to input
  ADC_PORT = TXD_VAL;		// switch all ADC outputs to GND, no pull up
  R_DDR = 0;			// switch all resistor ports to input
  R_PORT = 0; 			// switch all resistor outputs to GND, no pull up
  return;
 } // end ReadBigCap()

#endif


ReadBigCap.ino

ReadCapacity.ino

// new code by K.-H. Kübbeler
// The 680 Ohm resistor (R_L_VAL) at the Lowpin will be used as current sensor
// The current with a coil will with (1 - e**(-t*R/L)), where R is
// the sum of Pin_RM , R_L_VAL , Resistance of coil and Pin_RP.
// L in the inductance of the coil.

/*
#include <avr/io.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/


//=================================================================
void ReadInductance(void) {
#if FLASHEND > 0x1fff
  // check if inductor and measure the inductance value
  unsigned int tmpint;
  unsigned int umax;
  unsigned int total_r;		// total resistance of current loop
  unsigned int mess_r;		// value of resistor used for current measurement
  unsigned long inductance[4];	// four inductance values for different measurements
  union t_combi{
  unsigned long dw;     // time_constant
  uint16_t w[2];
  } timeconstant;
  unsigned int resistor;
  uint8_t res_num;
  uint16_t per_ref1,per_ref2;	// percentage
  uint8_t LoPinR_L;	// Mask for switching R_L resistor of low pin
  uint8_t HiADC;	// Mask for switching the high pin direct to VCC
  uint8_t ii;
  uint8_t count;	// counter for the different measurements
  uint8_t cnt_diff;     // resistance dependent offset
  int8_t ukorr;		// correction of comparator voltage
  uint8_t nr_pol1;	// number of successfull inductance measurement with polarity 1
  uint8_t nr_pol2;	// number of successfull inductance measurement with polarity 2
  union {
  uint16_t pw;		// return value from Rnum2pins()
  uint8_t pb[2];	// the pin numbers LowPin and HighPin
  } rpins;	// resistor pin structure to prevent two return parameters


  inductor_lpre = 2;	// H units, mark inductor as 1, if resistor is too big
  if(PartFound != PART_RESISTOR) {
     return;	//We have found no resistor  
  }
  if (ResistorsFound != 1) {
     return;	// do not search for inductance, more than 1 resistor
  }
     res_num = ResistorList[0];
     if (ResistorVal[res_num] > 21000) return;
     resistor = ResistorVal[res_num];

     // we can check for Inductance, if resistance is below 2100 Ohm
     for (count=0;count<4;count++) {
        // Try four times (different direction and with delayed counter start)
        if (count < 2) {
           // first and second pass, direction 1
           rpins.pw = Rnum2pins(res_num);	// compute the two pinnumbers for resistor res_num
        } else {
           // third and fourth pass, direction 2
           rpins.pw = Rnum2pins(res_num);	// compute the two pinnumbers for resistor res_num
           ii = rpins.pb[0];
           rpins.pb[0] = rpins.pb[1];		// swap the pins LowPin and HighPin
           rpins.pb[1] = ii;
        }
#if (((PIN_RL1 + 1) != PIN_RH1) || ((PIN_RL2 + 1) != PIN_RH2) || ((PIN_RL3 + 1) != PIN_RH3))
        HiADC = pgm_read_byte((&PinRLRHADCtab[6])+rpins.pb[1]-TP_MIN);	// Table of ADC Pins including | TXD_VAL
#else
        HiADC = pgm_read_byte((&PinRLRHADCtab[3])+rpins.pb[1]-TP_MIN);	// Table of ADC Pins including | TXD_VAL
#endif
        LoPinR_L = pgm_read_byte(&PinRLRHADCtab[rpins.pb[0]]-TP_MIN);	//R_L mask for HighPin R_L load
        //==================================================================================
        // Measurement of Inductance values
        R_PORT = 0;		// switch R port to GND
        ADC_PORT =   TXD_VAL;		// switch ADC-Port to GND
        if ((resistor < 240) && ((count & 0x01) == 0)) {
           // we can use PinR_L for measurement
           mess_r = RR680MI - R_L_VAL;			// use only pin output resistance
           ADC_DDR = HiADC | (1<<rpins.pb[0]) | TXD_MSK;	// switch HiADC and Low Pin to GND, 
        } else {
           R_DDR = LoPinR_L;   		// switch R_L resistor port for LowPin to output (GND)
           ADC_DDR = HiADC | TXD_MSK;	// switch HiADC Pin to GND 
           mess_r = RR680MI;			// use 680 Ohm and PinR_L for current measurement
        }
        // Look, if we can detect any current
        for (ii=0;ii<20;ii++) {
            // wait for current is near zero
            umax = W10msReadADC(rpins.pb[0]);
            total_r =  ReadADC(rpins.pb[1]);
            if ((umax < CAP_EMPTY_LEVEL) && (total_r < CAP_EMPTY_LEVEL)) break;	// low current detected
        }
        // setup Analog Comparator
        ADC_COMP_CONTROL = (1<<ACME);			//enable Analog Comparator Multiplexer
        ACSR =  (1<<ACBG) | (1<<ACI)  | (1<<ACIC);	// enable, 1.3V, no Interrupt, Connect to Timer1 
        ADMUX = (1<<REFS0) | rpins.pb[0];			// switch Mux to Low-Pin
        ADCSRA = (1<<ADIF) | AUTO_CLOCK_DIV; //disable ADC
   
      // setup Counter1
        timeconstant.w[1] = 0;		// set ov counter to 0
        TCCR1A = 0;			// set Counter1 to normal Mode
        TCNT1 = 0;			//set Counter to 0
        TI1_INT_FLAGS = (1<<ICF1) | (1<<OCF1B) | (1<<OCF1A) | (1<<TOV1);	// reset TIFR or TIFR1
//        HiADC |= TXD_VAL;
        wait200us();			// wait for bandgap to start up
        if ((count & 0x01) == 0 ) {
           //first start counter, then start current
           TCCR1B =  (1<<ICNC1) | (0<<ICES1) | (1<<CS10);	//start counter 1MHz or 8MHz
           ADC_PORT = HiADC;		// switch ADC-Port to VCC
        } else {
           //first start current, then start counter with delay
           //parasitic capacity of coil can cause high current at the beginning
           ADC_PORT = HiADC;		// switch ADC-Port to VCC
      #if F_CPU >= 8000000UL
           wait3us();		// ignore current peak from capacity
      #else
           wdt_reset();			// delay
           wdt_reset();			// delay
      #endif
           TI1_INT_FLAGS = (1<<ICF1);	// Reset Input Capture
           TCCR1B =  (1<<ICNC1) | (0<<ICES1) | (1<<CS10);	//start counter 1MHz or 8MHz
        }
      
      //******************************
        while(1) {
           // Wait, until  Input Capture is set
           ii = TI1_INT_FLAGS;		//read Timer flags
           if (ii & (1<<ICF1))  {
              break;
           }
           if((ii & (1<<TOV1))) {		// counter overflow, 65.536 ms @ 1MHz, 8.192ms @ 8MHz
              TI1_INT_FLAGS = (1<<TOV1);	// Reset OV Flag
              wdt_reset();
              timeconstant.w[1]++;		// count one OV
              if(timeconstant.w[1] == (F_CPU/100000UL)) {
                 break; 	//Timeout for Charging, above 0.65 s
              }
           }
        }
        ADC_PORT = TXD_VAL;		// switch ADC-Port to GND
        TCCR1B = (0<<ICNC1) | (0<<ICES1) | (0<<CS10);  // stop counter
        TI1_INT_FLAGS = (1<<ICF1);			// Reset Input Capture
        timeconstant.w[0] = ICR1;		// get previous Input Capture Counter flag
      // check actual counter, if an additional overflow must be added
        if((TCNT1 > timeconstant.w[0]) && (ii & (1<<TOV1))) {
           // this OV was not counted, but was before the Input Capture
           TI1_INT_FLAGS = (1<<TOV1);		// Reset OV Flag
           timeconstant.w[1]++;			// count one additional OV
        }

//        ADC_PORT = TXD_VAL;		// switch ADC-Port to GND
        ADCSRA = (1<<ADEN) | (1<<ADIF) | AUTO_CLOCK_DIV; //enable ADC
        for (ii=0;ii<20;ii++) {
            // wait for current is near zero
            umax = W10msReadADC(rpins.pb[0]);
            total_r =  ReadADC(rpins.pb[1]);
            if ((umax < CAP_EMPTY_LEVEL) && (total_r < CAP_EMPTY_LEVEL)) break;	// low current detected
        }  /* end for ii */
  #define CNT_ZERO_42 6
  #define CNT_ZERO_720 7
//#if F_CPU == 16000000UL
//  #undef CNT_ZERO_42
//  #undef CNT_ZERO_720
//  #define CNT_ZERO_42 7
//  #define CNT_ZERO_720 10
//#endif
        total_r = (mess_r + resistor + RRpinMI);
//        cnt_diff = 0;
//        if (total_r > 7000) cnt_diff = 1;
//        if (total_r > 14000) cnt_diff = 2;
        cnt_diff = total_r / ((14000UL * 8) / (F_CPU/1000000UL));
        tmpint = ref_mv_offs;		// corrected reference voltage (for C)
        if (mess_r < R_L_VAL) {
           // measurement without 680 Ohm
           cnt_diff = CNT_ZERO_42;
           if (timeconstant.dw < 225) {
              ukorr = (timeconstant.w[0] / 5) - 20;
           } else {
              ukorr = 25;
           }
           tmpint -= (((REF_L_KORR * 10) / 10) + ukorr);
        } else {
           // measurement with 680 Ohm resistor
           // if 680 Ohm resistor is used, use REF_L_KORR for correction
           cnt_diff += CNT_ZERO_720;
           tmpint += REF_L_KORR;
        }
        if (timeconstant.dw > cnt_diff) timeconstant.dw -= cnt_diff;
        else          timeconstant.dw = 0;
       
        if ((count&0x01) == 1) {
           // second pass with delayed counter start
           timeconstant.dw += (3 * (F_CPU/1000000UL))+10;
        }
        if (timeconstant.w[1] >= (F_CPU/100000UL)) timeconstant.dw = 0; // no transition found
        if (timeconstant.dw > 10) {
           timeconstant.dw -= 1;
        }
        // compute the maximum Voltage umax with the Resistor of the coil
        umax = ((unsigned long)mess_r * (unsigned long)ADCconfig.U_AVCC) / total_r;
        per_ref1 = ((unsigned long)tmpint * 1000) / umax;
//        per_ref2 = (uint8_t)MEM2_read_byte(&LogTab[per_ref1]);	// -log(1 - per_ref1/100)
        per_ref2 = get_log(per_ref1);		// -1000*log(1 - per_ref1/1000)
/* ********************************************************* */
#if 0
          if (count == 0) {
             lcd_line3();
             DisplayValue(count,0,' ',4);
             DisplayValue(timeconstant.dw,0,'+',4);
             DisplayValue(cnt_diff,0,' ',4);
             DisplayValue(total_r,-1,'r',4);
             lcd_space();
             DisplayValue(per_ref1,-1,'%',4);
             lcd_line4();
             Display_mV(tmpint,4);
             lcd_space();
             Display_mV(umax,4);
             lcd_space();
             DisplayValue(per_ref2,-1,'%',4);
             wait_about4s();	// debug delay
             wait_about2s();	// debug delay
          }
#endif
/* ********************************************************* */
        // inductor_lx in 0.01mH units,  L = Tau * R
        per_ref1 = ((per_ref2 * (F_CPU/1000000UL)) + 5) / 10;
        inductance[count] = (timeconstant.dw * total_r ) / per_ref1;
        if (((count&0x01) == 0) && (timeconstant.dw > ((F_CPU/1000000UL)+3))) {
           // transition is found, measurement with delayed counter start is not necessary
           inductance[count+1] = inductance[count];	// set delayed measurement to same value
           count++;		// skip the delayed measurement
        }
        wdt_reset();
     }  //end for count
     ADC_PORT = TXD_VAL;		// switch ADC Port to GND
     wait_about20ms();
     nr_pol1 = 0;
     if (inductance[1] > inductance[0]) { nr_pol1 = 1; } 
     nr_pol2 = 2;
     if (inductance[3] > inductance[2]) { nr_pol2 = 3; } 
     if (inductance[nr_pol2] < inductance[nr_pol1]) nr_pol1 = nr_pol2;
     inductor_lx = inductance[nr_pol1];
     inductor_lpre = -5;	// 10 uH units
     if (((nr_pol1 & 1) == 1) || (resistor >= 240)) {
        // with 680 Ohm resistor total_r is more than 7460
        inductor_lpre = -4;	// 100 uH units
        inductor_lx = (inductor_lx + 5) / 10;
     } 
     if (inductor_lx == 0) inductor_lpre = 0;	//mark as zero

  // switch all ports to input
  ADC_DDR =  TXD_MSK;		// switch all ADC ports to input
  R_DDR = 0;			// switch all resistor ports to input
#endif
  return;
 } // end ReadInductance()


ReadInductance.ino

/*
#include <avr/io.h>
#include <avr/eeprom.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/


// computes RHmultip, adc_internal_reference (ADCconfig.U_Bandgap) and ref_mv_offs

void RefVoltage(void) {
// RefVoltage interpolates table RHtab corresponding to voltage ref_mv_offs .
// RHtab contain the factors to get capacity from load time with 470k for
// different Band gab reference voltages.
// for remember:
//resistor     470000 Ohm      1000 1050 1100 1150 1200 1250 1300 1350 1400  mV
//uint16_t RHTAB[] MEM_TEXT = { 954, 903, 856, 814, 775, 740, 707, 676, 648};

#define Ref_Tab_Abstand 50		// displacement of table is 50mV
#define Ref_Tab_Beginn 1000		// begin of table is 1000mV

  unsigned int referenz;
  unsigned int y1, y2;
  uint8_t tabind;
  uint8_t tabres;

#ifdef AUTO_CAL
  referenz = ref_mv + (int16_t)eeprom_read_word((uint16_t *)(&ref_offset));
#else
  referenz = ref_mv + REF_C_KORR;
#endif
  ref_mv_offs = referenz;
#ifdef AUTO_RH
  if (referenz >= Ref_Tab_Beginn) {
     referenz -= Ref_Tab_Beginn;
  } else  {
     referenz = 0;		// limit to begin of table
  }
  tabind = referenz / Ref_Tab_Abstand;
  tabres = referenz % Ref_Tab_Abstand;
  tabres = Ref_Tab_Abstand-tabres;
  if (tabind > 7) {
     tabind = 7;		// limit to end of table
  }
  // interpolate the table of factors
  y1 = pgm_read_word(&RHtab[tabind]);
  y2 = pgm_read_word(&RHtab[tabind+1]);
  // RHmultip is the interpolated factor to compute capacity from load time with 470k
  RHmultip = ((y1 - y2) * tabres + (Ref_Tab_Abstand/2)) / Ref_Tab_Abstand + y2;
//########################################
#else
  RHmultip = DEFAULT_RH_FAKT;	// default Multiplier for capacity measurement with R_H (470KOhm)
#endif

#if PROCESSOR_TYP == 8
  referenz = 2560;		// use defined internal ADC Voltage
#else
  referenz = ref_mv;		// use the read out internal Reference voltage
#endif
#ifdef AUTO_CAL
  ADCconfig.U_Bandgap = (referenz + (int8_t)eeprom_read_byte((uint8_t *)&RefDiff));
#else
  ADCconfig.U_Bandgap = (referenz + REF_R_KORR);
#endif
  adc_internal_reference = ADCconfig.U_Bandgap;
 } /* end of RefVoltage */


RefVoltage.ino

/*
#include <avr/io.h>
#include <avr/eeprom.h>
#include <avr/pgmspace.h>

#include "Transistortester.h"
#include "Makefile.h" //J-L
*/


void RvalOut(uint8_t nrr) {	
   // output of resistor value
  union {
  uint16_t pw;          // return value from Rnum2pins()
  uint8_t pb[2];        // the pin numbers LowPin and HighPin
  } rpins;      // resistor pin structure to prevent two return parameters

#if FLASHEND > 0x1fff
   uint16_t rr;
   if ((ResistorVal[nrr] < 100) && (inductor_lpre >= 0)) {
      rpins.pw = Rnum2pins(nrr);	// compute the pin numbers for resistor nrr
      rr = GetESR(rpins.pb[1], rpins.pb[0]);
      DisplayValue16(rr,-2,LCD_CHAR_OMEGA,3);
   } else {
      DisplayValue(ResistorVal[nrr],-1,LCD_CHAR_OMEGA,4);
   }
#else
   DisplayValue(ResistorVal[nrr],-1,LCD_CHAR_OMEGA,4);
#endif
   lcd_space();
 }


RvalOut.ino


// June-Sept 2015, pa3fwm@amsat.org

#ifdef SamplingADC

//#include <avr/io.h>
//#include <stdlib.h>
//#include "Transistortester.h"
//#include "Makefile.h" //J-L


typedef uint8_t byte;

//const uint16_t c_zero_tab2_lo[] EEMEM = { 0,0,0,0,0,0,0 };   // zero offsets for SamplingADC capacitance measurement, in 0.01 pF, lo voltage
//const uint16_t c_zero_tab2_hi[] EEMEM = { 0,0,0,0,0,0,0 };   // same, hi voltage




// calculate -32768*ln(1-y/32768)
static unsigned int mylog(unsigned int y)
{
   unsigned long int a,b;
   b=y;

// optimized to give more accurate results for small y
// reason is that in the end, we determine the slope (using least-squares) roughly between y=0 and some larger y (larger for smaller caps)
// mylog(32768*(1-exp(-x/20000))) / x  does not deviate by more than 1 % for x=0...17600
// 17600/20000 = 0.88, so good for times up to 88% of the RC timeconstant
// we measure up to 230 clockcycles, so at 16 MHz, that 88% of RC, with 470 kOhm, is 35 pF, which is the typicaly parasitic capacitance we see
// TODO: at 8 MHz, we'll need a mylog() function which is good also for larger y, or use fewer of the samples; latter may be best, to restrict the voltage range on the cap (important for varicaps)

/*
   a = (b<<16);
   a += b* ((y>>1) + (y>>2) + (y>>4));
   b = b*y;
   a += y * ((b>>15) + (b>>16));
   return a>>16;
*/

/*
   // version which uses more 16-bit rather than 32-bit arithmetic; produces larger code though :(
   unsigned short int bb;
   b=y;
   a = (b<<16);
   a += b* ((y>>1) + (y>>2) + (y>>4));
   bb = (y>>6)*(y>>7);
   a += y * ((bb>>2) + (bb>>3));
   return a>>16;
*/

   // newer version: uses one more term for better accuracy (0.2% instead of 1% in the test mentioned above)
   // only 30 bytes longer than the 1% version
   unsigned short int bb;
   b=y;
   a = (b<<16);
   a += b* (y+(y>>4)+(y>>8));
   b = b*y;
   bb = b>>16;
   bb>>=2;                                     // not integrated in previous line because then compiler does an 18-position shift of a 32-bit variable :-(
   unsigned short bb2=bb>>2;                   // without this intermediate variable, compiler does some of >> multiple times
   a += y * (unsigned long int) (bb - bb2);
   bb = (bb2>>1)*(y>>8);            
   a += y * (unsigned long int)(bb - (bb>>3));
   return a>>16;
} /* end mylog */


int32_t sampling_cap(byte HighPin, byte LowPin, byte opts)
{
  EntladePins();

  uint8_t HiPinR_L, HiPinR_H;
  uint8_t LoADC;
  uint16_t samp_opt;
  HiPinR_L = pgm_read_byte(&PinRLRHADCtab[HighPin]);	//R_L mask for HighPin R_L load
#if (((PIN_RL1 + 1) != PIN_RH1) || ((PIN_RL2 + 1) != PIN_RH2) || ((PIN_RL3 + 1) != PIN_RH3))
  HiPinR_H = pgm_read_byte((&PinRLRHADCtab[3])+HighPin);	//R_H mask for HighPin R_H load
  LoADC = pgm_read_byte((&PinRLRHADCtab[6])+LowPin) | TXD_MSK;
#else
  HiPinR_H = HiPinR_L + HiPinR_L;	//double for HighPin R_H load
  LoADC = pgm_read_byte((&PinRLRHADCtab[3])+LowPin) | TXD_MSK;
#endif

   byte i=0;

   unsigned int uu[256];
   ADC_DDR = LoADC;			// switch Low-Pin to output (GND)
   R_PORT = 0;			//R_L to 0 (GND) 
   R_DDR = HiPinR_L;			
//   wait200us();			// let the last ADC cycle finish

   ADMUX = HighPin|(1<<REFS0);	// switch Multiplexer to Highpin and use 5V reference voltage
#ifdef NO_AREF_CAP
    wait100us(); /* time for voltage stabilization */
#else
    wait_about10ms(); /* time for voltage stabilization */
#endif

//   lcd_line1();
//   lcd_string(itoa(ADCSRA, outval, 16));
//   wait_about500ms();

//   memset(uu,0,sizeof(uu));

   // we'll do the least-squares calculation over samples N1..N2 (inclusive), excluding N3..(N4-1)
#if MHZ_CPU>=16
   #define N1 70     // skip the initial part, which seems to behave a bit differently
   #define N2 230    // skip the last part where the sampling switch starts to affect the results
   #define N3 182    // skip the part just before sample 192 where the ADC mux switch slightly affects results
   #define N4 193
#elif MHZ_CPU==8
   // at 8 MHz, we only use half the possible range of samples, because otherwise the voltage on the cap changes by too much during the measurement if cap is small, like the 35 pF or so if nothing connected
   #define N1 35     // skip the initial part, which seems to behave a bit differently
   #define N2 115    // skip the last part where the sampling switch starts to affect the results
   #define N3 200
   #define N4 200
#else
   #error Clock frequency not supported!
#endif

   #define N (N2-N1+1-(N4-N3))
   #define sumx (unsigned long)((N2*(N2+1l)/2)-(N4*(N4-1l)/2)+(N3*(N3-1l)/2)-(N1*(N1-1l)/2))
   unsigned long sumxx=(unsigned long)((N2*(N2+1l)*(2*N2+1l)/6)-(N4*(N4-1l)*(2*N4-1l)/6)+(N3*(N3-1l)*(2*N3-1l)/6)-(N1*(N1-1l)*(2*N1-1l)/6));
#ifdef SamplingADC_CNT
   samp_opt = 1;		// sample distance 1
#else
   samp_opt = 0;
#endif
   byte d=( (opts&1) ? HiPinR_L : HiPinR_H );

   for (i=0;i<32;i++) {
      samplingADC(samp_opt, uu, N2+1, d, HiPinR_H, d, HiPinR_L);
      samp_opt |= samplingADC_cumul;
   }
//   uart_newline(); for (i=0;i<N2;i++) { myuart_putc('a'); myuart_putc(' '); uart_int(uu[i]); uart_newline(); wdt_reset(); }

   R_DDR = 0;			
#if (DEB_SAM == 1)
//------------------------------------------------------------------
 #warning "sampling_cap with test output enabled! "
   uint16_t kk;
   int16_t udiff;
   uint16_t old_uu;
// #define Step3 ((N2-N1)/15)
// define NN1 N1
#define Step3 1
#define NN1 0

   old_uu = uu[NN1];
   for (kk=(NN1+Step3); kk<(NN1+(Step3*16)); kk+=Step3) {
     udiff = uu[kk] - old_uu;
     if (udiff < 0) udiff = -udiff;	// absolute value
     old_uu = uu[kk];
     if ( ((kk-NN1-Step3) % (3*Step3)) == 0) lcd_next_line_wait(0);
     DisplayValue16((uint16_t)(udiff)/32,0,' ',4);
   }
   lcd_next_line_wait(0);
   DisplayValue16(uu[0]/32,0,'a',5);
   DisplayValue16(uu[1]/32,0,'b',5);
   lcd_clear_line();
   lcd_refresh();
   wait_about5s();
//------------------------------------------------------------------
#endif

   // we use the least-squares algorithm to find the slope
   // cf. e.g. https://en.wikipedia.org/wiki/Ordinary_least_squares
   unsigned long sumy, sumxy;
   sumy=sumxy=0;
   for (i=N1;i<=N2;i++) {	/* 70-230 @16MHz, 35-115 @8MHz */
      if (i==N3) i=N4;		// skip from N3 to (N4-1), 182-192 @16MHz, 200-200 @8MHz
      unsigned int z;
      if (opts&1) z=mylog(32768-uu[i]);
      else z=mylog(uu[i]);
      sumy+=z;
      sumxy+=(unsigned long int)i*z;
   }
   // maximum magnitudes at 16 MHz clock:
   // N ~ 2^8
   // sumx ~ 2^15
   // sumxx ~ 2^23  (in practice with our N1..4 choice: <2^22)
   // sumy ~ 2^22
   // sumxy ~ 2^30
   // at 8 MHz, we sum roughly half as many sample samples, and x will get only half as big, so sumxy will be about 1/4, and sumxx 1/8
   sumxx -= sumx*sumx/N;
   // now sumxx ~ <2^19 , as it turns out; note that sumxx is a constant, depending only on N and N1..4; it was a variable previously, hence this code
   sumxy -= sumx*(sumy/N);
   // now sumxy/sumxx is a least-squares estimate for the slope, in units of 32768 per-clockcycle
   // this slope is 1/RC, where R is the (nominally) 470 kOhm test resistor
   // thus C = 1/(slope*R) = sumxx/(sumxy*f*R/32768) = sumxx/sumxy * 32768/(f*R)
   // we scale sumxx and sumxy for least errors in the coming calculation
   // at 16 MHz, and aiming for units of 10^{-14} Farad, the constant becomes 32768e14/16e6/R = 2048e8/R
   // for R=470000, this is 435744.68
   // if 8 MHz, we correct for the extra factor 2 in the bitshift of sumxx, so as to not lose bits
#if MHZ_CPU>=16
   sumxx>>=3;   // bitshift such that sumxx fits in 16 bits
   sumxy>>=6;   // we shift sumxy by 3 bits more than sumxx because a few lines down we have an extra /8 to make things fit 
#elif MHZ_CPU==8
   sumxx>>=0;
   sumxy>>=4;
#endif
   unsigned long int c3;
#if MHZ_CPU == 20
   // at 20 MHz, and aiming for units of 10^{-14} Farad, the constant becomes 32768e14/20e6/R = 16384e7/R
   c3 = sumxx*((uint32_t)(((16384000000./R_H_VAL)+4)/8))/sumxy;  // units of 0.01 pF
#else
   c3 = sumxx*((uint32_t)(((20480000000./R_H_VAL)+4)/8))/sumxy;  // units of 0.01 pF
#endif
   // the /8 is to make the (...) factor (about 435745) fit in 16 bits
   // note that the /8 is compensated for by the different bitshifts of sumxx and sumxy, and the +4 rounds this number properly
   if (!(opts&2)) 
   {
      byte k = ((HighPin - TP_MIN)*3) + LowPin - TP_MIN -1;
      if (opts&1) c3-= eeprom_read_word(c_zero_tab2_hi+k);
      else c3-= eeprom_read_word(c_zero_tab2_lo+k);
   }
   return c3;
}  /* end sampling_cap */





void sampling_cap_calibrate()
{
   // measure capacitance of all combinations without anything connected
   byte i,j;
   for (i=0;i<=2;i++)
      for (j=0;j<=2;j++)
         if (i!=j) {
            unsigned int c;
            c=sampling_cap(i,j,2);
#ifdef PULLUP_DISABLE
            unsigned int d;
            d=sampling_cap(i,j,3);
#endif
            lcd_clear();
            lcd_MEM2_string(C0samp_str);			//output "C0samp "
            lcd_space();				// lcd_data(' ');
            lcd_testpin(i);
            lcd_data(':');
            lcd_testpin(j);
            lcd_space();				//lcd_data(' ');
            lcd_line2();
            byte k=3*i+j-1;
#ifdef PULLUP_DISABLE
            DisplayValue16(c,-2,' ',4);
            DisplayValue16(d,-14,'F',4);
            eeprom_write_word((void*)(c_zero_tab2_lo+k),c); /* C0 from 0 to 1 */
            eeprom_write_word((void*)(c_zero_tab2_hi+k),d); /* C0 from 1 to 0 */
#else
            DisplayValue16(c,-14,' ',4);
            eeprom_write_word((void*)(c_zero_tab2_lo+k),c); /* C0 from 0 to 1 */
            eeprom_write_word((void*)(c_zero_tab2_hi+k),c); /* set 1to0 same as 0to1 */
#endif
            lcd_clear_line();
            lcd_refresh();
         }
   lcd_line1();
   lcd_MEM_string(OK_str);	// "OK"
   lcd_clear_line();
   lcd_refresh();
   wait_about200ms();
} /* end sampling_cap_calibrate */



#endif


Sampling_cap.ino

sampling_lc.ino

sampling_xtal.ino

uint16_t samplingADC(unsigned int, void*, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char){
  
}


samplingADC.ino

// show_Resis_Cap.c , new code by K.-H. Kübbeler


#include <avr/io.h>
#include <stdlib.h>
//#include "Transistortester.h"
//#include "Makefile.h" //J-L




typedef uint8_t byte;


// display formats for R, L, and resonance measurement:
// |....|....|....|   (16 characters line length)

// nothing found:
// 1-RR-3      [RL]
// ?

// only resistance:
// 1-RR-3      [RL]
// 12.34kO

// resistance and inductance
// 1-RR-LL-3   [RL]
// 12.34kO L=12.3uH
// 334.5kHz Q=12.3    <--- only  if resonance detected

// resistance and inductance measured through resonance, rather tight format to fit on 3 lines
// 1-RR-LL-3 12.34kO   (the ohm sign doesn't fit this way, but most likely, there's no 'k' sign since coils tend to not have that much resistance)
// 12.3uH if 22.0nF
// 334.5kHz Q=12.3

// same case but on bigger screens:  <---- not yet implemented!
// 1-RR-LL-3
// 12.34kO
// 12.3uH if 22.0nF
// 334.5kHz Q=12.3


#if FLASHEND > 0x1fff

 #if FLASHEND > 0x3fff
 // EXTRASPACES contains any extra spaces needed to fill out the line if wider than 16 characters, i.e., LCD_LINE_LENGTH-16 spaces
  #if LCD_LINE_LENGTH==16
   #define EXTRASPACES
  #elif LCD_LINE_LENGTH==17
   #define EXTRASPACES ' ',
  #elif LCD_LINE_LENGTH==18
   #define EXTRASPACES ' ',' ',
  #elif LCD_LINE_LENGTH==19
   #define EXTRASPACES ' ',' ',' ',
  #elif LCD_LINE_LENGTH==20
   #define EXTRASPACES ' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==21
   #define EXTRASPACES ' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==22
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==23
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==24
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==25
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==26
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==27
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==28
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==29
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==30
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==31
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==32
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ', 
  #elif LCD_LINE_LENGTH==33
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==34
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==35
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==36
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==37
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==38
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #elif LCD_LINE_LENGTH==39
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',   
  #elif LCD_LINE_LENGTH==40
   #define EXTRASPACES ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',
  #else
   #warning Please add support for your LCD_LINE_LENGTH
   #define EXTRASPACES
  #endif
// strings to fill out the topline with "[RL]" or "[ R]"
// they include precisely enough extra space to start from the 7th position on the line
// if already k characters more have been written, just add k to the starting address
  #ifdef RMETER_WITH_L
// strings to fill out the topline with "[RL]" or "[ R]"
// they include precisely enough extra space to start from the 7th position on the line
// if already k characters more have been written, just add k to the starting address
#ifdef RMETER_WITH_L
const unsigned char RL_METER_str[] MEM2_TEXT = {' ',' ',' ',' ',' ',EXTRASPACES ' ','[','R','L',']',0};
#else
const unsigned char RL_METER_str[] MEM2_TEXT = {' ',' ',' ',' ',' ',EXTRASPACES ' ',' ','[','R',']',0};
#endif
  #else
const unsigned char RESIS_str_R2[] MEM2_TEXT = {' ',' ',' ',' ',' ',EXTRASPACES ' ',' ','[','R',']',0};
  #endif
 #endif  /* FLASHEND > 0x3fff */

void show_resis(byte pin1, byte pin2, byte how)
// can be invoked both from main() and from show_Resis13()
// pin1 and pin2 are resistor's pin numbers, but ResistorList[0] should also be correctly filled
// assumes resistance has already been measured, but will do inductance measurements as appropriate
// "how" flag tells how to show the results: if set [R] or [RL] will be shown in top right corner
{
 #ifdef RMETER_WITH_L
           lcd_testpin(pin1);
           lcd_MEM_string(Resistor_str);	// -[==]-
           lcd_refresh();
	   ReadInductance();	// measure inductance, possible only with R<2.1k

  #ifdef SamplingADC
           sampling_lc(pin1,pin2);    // measure inductance using resonance method

           // draw first line: the pin numbers, RR and possibly LL symbol, and possibly [R] or [RL]
           byte lclx0=(lc_lx==0);
           if (inductor_lpre < 0 || !lclx0) 
  #else 
           if (inductor_lpre < 0)
  #endif

           {
              lcd_MEM_string(Inductor_str+1);            // "LL-"
           }
           lcd_testpin(pin2);

           // second line: measured R value (but that goes on first line if lc_lx!=0), and measured inductance, if applicable

 #ifdef SamplingADC
           if (!lclx0) {  /* inductance measured by sampling method */
              lcd_space();
              RvalOut(ResistorList[0]);		// show Resistance, probably ESR, still on first line
           }
  #endif
 
  #if FLASHEND > 0x3fff
           if (how) {
              // still need to write "[RL]" or "[R]" at the end of first line, if it fits
              if (_lcd_column<=LCD_LINE_LENGTH-4) {
                 lcd_MEM_string(RL_METER_str+(_lcd_column-6));	// " [R]" or "[RL]"
              }
           }
  #else
           lcd_clear_line();
  #endif
//           lcd_line2();
           lcd_next_line_wait(0);
  #ifdef SamplingADC
           if (!lclx0) {  /* Frequency found */
//              lcd_next_line(0);
              DisplayValue(lc_lx,lc_lpre,'H',3);	// output inductance
              lcd_MEM2_string(iF_str);		// " if "
              uint16_t lc_cpar;    // value of parallel capacitor used for calculating inductance, in pF
              lc_cpar=eeprom_read_word((uint16_t *)&lc_cpar_ee);
   #if (LCD_LINES<3) && (LCD_LINE_LENGTH<17)
              DisplayValue16(lc_cpar,-12,'F',2);	        // on 2-line dispaly show parallel capacitance with only 2 digits to make room for the '+' sign at the end of the line
   #else
              DisplayValue16(lc_cpar,-12,'F',3);	        // show parallel capacitance
   #endif
           } else 
  #endif
           {
//              lcd_next_line_wait(0);
              RvalOut(ResistorList[0]);		// show Resistance, probably ESR

              if (inductor_lpre < -2) {
                 // resistor has also inductance
                 lcd_MEM_string(Lis_str);		// "L="
                 DisplayValue(inductor_lx,inductor_lpre,'H',3);        // output classic inductance
              }

           }
           // third line: measured resonance frequency and Q, if applicable

  #ifdef SamplingADC
           if (lc_fx) {
              lcd_next_line_wait(0);
              DisplayValue(lc_fx,lc_fpre,'H',4);
              lcd_MEM2_string(zQ_str);		// "z Q="
              DisplayValue16(lc_qx, lc_qpre,' ',3);
              lcd_clear_line();
           } else {
//  #if LCD_LINES>2
//              // make sure we clean the third line, but only if the display actually has a 3rd line
//              lcd_next_line(0);
//  #endif
              lcd_next_line(0);
	      if (last_line_used == 0) {
                 lcd_clear_line();
              }
           }
  #endif
 #else		/* without Inductance measurement, only show resistance */
           lcd_line2();
           inductor_lpre = -1;		// prevent ESR measurement because Inductance is not tested
           RvalOut(ResistorList[0]);	// show Resistance, no ESR
 #endif
}

#endif //   FLASHEND > 0x1fff


#if FLASHEND > 0x3fff
//=================================================================
// selection of different functions

/* ****************************************************************** */
/* show_Resis13 measures the resistance of a part connected to TP1 and TP3 */
/* if RMETER_WITH_L is configured, inductance is also measured */
/* ****************************************************************** */

void show_Resis13(void) {
  uint8_t key_pressed;
  message_key_released(RESIS_13_str);	// "1-|=|-3 .."
#ifndef RMETER_WITH_L
  lcd_set_cursor(0,6);
  lcd_MEM_string(RL_METER_str);	// " [R]" or "[RL]"
#endif
#ifdef POWER_OFF
  uint8_t times;
  for (times=0;times<250;) 
 #else
  while (1)		/* wait endless without the POWER_OFF option */
 #endif
  {
        init_parts();		// set all parts to nothing found 
        GetResistance(TP3, TP1);
        GetResistance(TP1, TP3);
	lcd_line1();		// lcd_set_cursor(0,0);
        if (ResistorsFound != 0) {
           show_resis(TP1,TP3,1);
        } else {		/* no resistor found */
 #if defined(SamplingADC) && defined(AUTO_LC_CAP)
	   sampling_lc_calibrate(249);		// try a short time to fetch new capacity value
 #endif
 #ifdef RMETER_WITH_L
           lcd_MEM_string(RESIS_13_str);
           lcd_MEM_string(RL_METER_str+4);	// " [R]" or "[RL]"
 #endif
           lcd_line2();
           lcd_data('?');		// too big
 #if LCD_LINES>2
           lcd_next_line(0);
 #endif
           lcd_clear_line();
        }
 #if defined(POWER_OFF) && defined(BAT_CHECK)
     Bat_update(times);
 #endif
     key_pressed = wait_for_key_ms(1000);
 #ifdef WITH_ROTARY_SWITCH
     if ((key_pressed != 0) || (rotary.incre > 3)) break;
 #else
     if (key_pressed != 0) break;
 #endif
 #if defined(POWER_OFF)
     times = Pwr_mode_check(times);	// no time limit with DC_Pwr_mode
 #endif
  }  /* end for times */
  lcd_clear();
} /* end show_Resis13() */
#endif  /* FLASHEND > 0x3fff */
 
/* ****************************************************************** */
/* show cap display the capacity measurement results */
/* ****************************************************************** */
#if FLASHEND > 0x3fff
void show_cap(uint8_t how)
#else
void show_cap_simple(void)
#endif
{
//     lcd_MEM_string(Capacitor);
  lcd_line1();
  lcd_testpin(cap.ca);               //Pin number 1
  lcd_MEM_string(CapZeich);          // capacitor sign
#if FLASHEND > 0x1fff
  uint8_t present_res;	// true, if resistor symbol is shown in Row 1
  uint8_t present_esr;
  uint8_t present_vloss;
  GetVloss();              
  cap.esr = GetESR(cap.cb, cap.ca);          // get ESR of capacitor

  present_esr = (cap.esr < 65530);
  present_vloss = (cap.v_loss != 0);
 #if (LCD_LINES > 2)
  present_res = present_esr; // show every time a well ESR value is detected, Vloss extra line
 #else
  #if FLASHEND > 0x3fff
  present_res = (present_esr  && (!present_vloss || how));
  #else
  present_res = (present_esr  && (!present_vloss));
  #endif
  // show Vloss additionally in line 2 , or no Vloss
 #endif
  if (present_res)
  {
     lcd_MEM_string(Resistor_str+1);   // [=]-
  }
#endif   /* FLASHEND > 0x1fff */
  lcd_testpin(cap.cb);               //Pin number 2

#if FLASHEND > 0x1fff
 #if FLASHEND > 0x3fff
  if (how) {
     // Vloss is allways shown in separate line
     lcd_spaces(LCD_LINE_LENGTH - 3 - _lcd_column);
     lcd_MEM2_string(CMETER_13_str);       // "[C]" at the end of line 1
  } else {
 #endif  /* FLASHENF > 0x3fff */

 #if (LCD_LINES <= 2) /* Vloss in line 1 */
     if (cap.v_loss != 0) {
        lcd_MEM_string(VLOSS_str);      // " Vloss=" 
        DisplayValue16(cap.v_loss,-1,'%',2);
     }
 #endif
     lcd_clear_line();		// clear to end of line

 #if FLASHEND > 0x3fff
  }    /* end of if (how) */
 #endif
#else
  lcd_clear_line();		// clear to end of line
#endif  /* FLASHEND > 0x1fff */

// - - - - - - - - - - - - - - - - - - - - - -
  lcd_line2();                       //2. row 
  DisplayValue(cap.cval_max,cap.cpre_max,'F',4);

#if FLASHEND > 0x1fff
  if (present_esr) {
     lcd_MEM_string(ESR_str);        // " ESR="
     DisplayValue16(cap.esr,-2,LCD_CHAR_OMEGA,2);
  }
  lcd_clear_line();
// - - - - - - - - - - - - - - - - - - - - - -
 #if LCD_LINES > 2
     lcd_line3();
     if (present_vloss ) {
        lcd_MEM_string(&VLOSS_str[1]);      // "Vloss=" 
        DisplayValue16(cap.v_loss,-1,'%',2);
     }
     lcd_clear_line();
 #else  /* only two lines */
  #if FLASHEND > 0x3fff
  if (how && present_vloss)
  {
     lcd_next_line_wait(0);		// show vloss after waiting
     lcd_MEM_string(&VLOSS_str[1]);      // "Vloss=" 
     DisplayValue16(cap.v_loss,-1,'%',2);
  }
  lcd_clear_line();		// clear to end of line
  #endif
 #endif
#else
  lcd_clear_line();
#endif  /* FLASHEND > 0x1fff */
} /* end show_cap or show_cap_simple */

#if FLASHEND > 0x3fff
/* ****************************************************************** */
/* show_Cap13 measures the capacity of a part connected to TP1 and TP3 */
/* ****************************************************************** */
 #if (LCD_LINES > 2)
  #define SCREEN_TIME 1000
 #else
  #define SCREEN_TIME 2000	/* line 2 is multi use, wait longer to read */
 #endif
void show_Cap13(void) {
  uint8_t key_pressed;

//  lcd_clear();
 #ifdef POWER_OFF
  uint8_t times;
  for (times=0;times<250;) 
 #else
  while (1)		/* wait endless without the POWER_OFF option */
 #endif
  {
     init_parts();		// set all parts to nothing found 
//     cap.v_loss = 0;		// clear vloss  for low capacity values (<25pF)!
     ReadCapacity(TP3, TP1);
     PartFound = PART_CAPACITOR;
 #ifdef SamplingADC
     if (cap.cpre==-12 && cap.cval<100) {
        // if below 100 pF, try the alternative measuring method for small capacitors
        cap.cval = sampling_cap(TP3,TP1,0);
        cap.cpre = sampling_cap_pre;
     }
 #endif
     if (cap.cpre > -15) {	/* Capacity below the detection limit */
       cap.cpre_max = cap.cpre;		// show_cap will display the cap.cval_max value
       cap.cval_max = cap.cval;
       show_cap(1);		// with [C] at the end of line
     } else { /* no cap detected */
       lcd_line1();
       lcd_MEM2_string(CAP_13_str);	// 1-||-3
       lcd_spaces(LCD_LINE_LENGTH - 3 - _lcd_column);
       lcd_MEM2_string(CMETER_13_str);       // "[C]" at the end of line 1
       lcd_line2();
       lcd_data('?');
       lcd_clear_line();		// clear to end of line 2
 #if (LCD_LINES > 2)
       lcd_line3();	
       lcd_clear_line();	// clear old Vloss= message
 #endif
     }
 #if defined(POWER_OFF) && defined(BAT_CHECK)
     Bat_update(times);
 #endif
     key_pressed = wait_for_key_ms(SCREEN_TIME);
 #ifdef WITH_ROTARY_SWITCH
     if ((key_pressed != 0) || (rotary.incre > 3)) break;
 #else
     if (key_pressed != 0) break;
 #endif
 #if defined(POWER_OFF)
     times = Pwr_mode_check(times);	// no time limit with DC_Pwr_mode
 #endif
  }  /* end for times */
  lcd_clear();		// clear to end of line
} /* end show_Cap13() */
#endif  /* FLASHEND > 0x3fff */

#if defined(POWER_OFF) && defined(BAT_CHECK)
// monitor Battery in line 4 or line2, if a two line display 
void Bat_update(uint8_t tt) {
  if((tt % 16) == 0) {
 #if (LCD_LINES > 3)
     lcd_line4();
     Battery_check();
 #else
     wait_about1s();	/* time delay before overwiting line2 with Bat= message */
  #if (LCD_LINES == 3)
     lcd_line3();	// use the last line for Bat=
  #else
     lcd_line2();	// use the last line for Bat=
  #endif
     Battery_check();
     wait_about1s();	/* time delay for reading the Bat= message */
 #endif
  }
};	/* end Bat_update() */
#endif
#if defined(POWER_OFF)
uint8_t Pwr_mode_check(uint8_t tt) {
 #if FLASHEND > 0x1fff
 if ((tt == 15) && (DC_Pwr_mode == 1)) return(0);  // when DC_Mode, next cycle start with 0
 #else
 if (tt == 15)  return(0);  // when DC_Mode, next cycle start with 0
 #endif
 return(tt + 1);	// otherwise increase
};
#endif


show_Resis_Cap.ino

//#include "Transistortester.h"
//#include "Makefile.h" //J-L

/*  ShowData shows the Software version number and */
/*  the calibration data at the 2-line or 4-line LCD */
#ifdef WITH_MENU
void ShowData(void) {
#ifdef SamplingADC
  uint8_t ii,jj,kk;
  uint16_t cc,dd;
#endif

#ifdef WITH_ROTARY_SWITCH
show_page_1:
#endif
  lcd_clear();
  lcd_MEM_string(VERSION_str);	// "Version x.xxk"
  lcd_line2();
  lcd_MEM2_string(R0_str);	// "R0="
  DisplayValue16(eeprom_read_byte(&EE_ESR_ZEROtab[2]),-2,' ',3);
  DisplayValue16(eeprom_read_byte(&EE_ESR_ZEROtab[3]),-2,' ',3);
  DisplayValue16(eeprom_read_byte(&EE_ESR_ZEROtab[1]),-2,LCD_CHAR_OMEGA,3);
#if (LCD_LINES > 3)
  lcd_line3();
#else
  wait_for_key_ms(MIDDLE_WAIT_TIME);
 #ifdef WITH_ROTARY_SWITCH
  if (rotary.incre > FAST_ROTATION) return;	// fast rotation ends the function
  if (rotary.count < 0) goto show_page_1;
show_page_2:
 #endif
  lcd_clear();
#endif
  /* output line 3 */
  lcd_MEM_string(RIHI_str); // "RiHi="
  DisplayValue16(RRpinPL,-1,LCD_CHAR_OMEGA,3);
#if (LCD_LINES > 3)
  lcd_line4();
#else
  lcd_line2();
#endif
  /* output line 4 */
  lcd_MEM_string(RILO_str); // "RiLo="
  DisplayValue16(RRpinMI,-1,LCD_CHAR_OMEGA,3);

  wait_for_key_ms(MIDDLE_WAIT_TIME);
#ifdef WITH_ROTARY_SWITCH
  if (rotary.incre > FAST_ROTATION) return;	// fast rotation ends the function
#if (LCD_LINES > 3)
  if (rotary.count < 0) goto show_page_1;
 #else
  if (rotary.count < -1) goto show_page_1;
  if (rotary.count < 0) goto show_page_2;
 #endif
show_page_3:
#endif
  lcd_clear();
  lcd_MEM_string(C0_str);                       //output "C0 "
  u2lcd_space(eeprom_read_byte(&c_zero_tab[5]) -(COMP_SLEW1 / (CC0 + CABLE_CAP + COMP_SLEW2)));		//output cap0 1:3
  u2lcd_space(eeprom_read_byte(&c_zero_tab[6]) -(COMP_SLEW1 / (CC0 + CABLE_CAP + COMP_SLEW2)));		//output cap0 2:3
  DisplayValue16(eeprom_read_byte(&c_zero_tab[2]) -(COMP_SLEW1 / (CC0 + CABLE_CAP + COMP_SLEW2)) ,-12,'F',3);		//output cap0 1:2
  lcd_line2();
  lcd_spaces(3);
  u2lcd_space(eeprom_read_byte(&c_zero_tab[1]) -(COMP_SLEW1 / (CC0 + CABLE_CAP + COMP_SLEW2)));		//output cap0 3:1
  u2lcd_space(eeprom_read_byte(&c_zero_tab[4]) -(COMP_SLEW1 / (CC0 + CABLE_CAP + COMP_SLEW2)));		//output cap0 3:2
  DisplayValue16(eeprom_read_byte(&c_zero_tab[0]) -(COMP_SLEW1 / (CC0 + CABLE_CAP + COMP_SLEW2)) ,-12,'F',3);		//output cap0 2:1
#if (LCD_LINES > 3)
  lcd_line3();
#else
  wait_for_key_ms(MIDDLE_WAIT_TIME);
 #ifdef WITH_ROTARY_SWITCH
  if (rotary.incre > FAST_ROTATION) return;	// fast rotation ends the function
  if (rotary.count < -2) goto show_page_1;
  if (rotary.count < -1) goto show_page_2;
  if (rotary.count < 0) goto show_page_3;
show_page_4:
 #endif
  lcd_clear();
#endif
  /* output line 7 */
  lcd_MEM2_string(REF_C_str);	// "REF_C="
  i2lcd((int16_t)eeprom_read_word((uint16_t *)(&ref_offset)));
#if (LCD_LINES > 3)
  lcd_line4();
#else
  lcd_line2();
#endif
  /* output line 8 */
  lcd_MEM2_string(REF_R_str);  // "REF_R="
  i2lcd((int8_t)eeprom_read_byte((uint8_t *)(&RefDiff)));

#ifdef SamplingADC
#ifdef WITH_ROTARY_SWITCH
show_page_5:
#endif
  /* modified output from sampling_cap_calibrate */
  lcd_set_cursor((LCD_LINES-1)*PAGES_PER_LINE,0);      // set for initial clear screen
  for (ii=0;ii<=2;ii++)
    for (jj=0;jj<=2;jj++)
       if (ii != jj) {
          kk = (ii * 3) + jj - 1;
          cc = eeprom_read_word((void *)(c_zero_tab2_lo+kk));
          dd = eeprom_read_word((void *)(c_zero_tab2_hi+kk));
          if (lcd_text_line > (LCD_LINES - 2)) {
             wait_for_key_ms(MIDDLE_WAIT_TIME);
 #ifdef WITH_ROTARY_SWITCH
             if (rotary.incre > FAST_ROTATION) return;	// fast rotation ends the function
  #if (LCD_LINES > 3)
             if (rotary.count < -2) goto show_page_1;	// page_2 is shown together with _page_1
             if (rotary.count < -1) goto show_page_3;	// page_4 is shown together with _page 3
             if (rotary.count < 0) goto show_page_5;
  #else
             if (rotary.count < -4) goto show_page_1;
             if (rotary.count < -3) goto show_page_2;
             if (rotary.count < -2) goto show_page_3;
             if (rotary.count < -1) goto show_page_4;
             if (rotary.count < 0) goto show_page_5;
  #endif
 #endif  /* WITH_ROTARY_SWITCH */
             lcd_clear();
          } else {  
	     lcd_next_line(0);
          }
          lcd_MEM_string(C0samp_str);	// "C0samp "
	  lcd_testpin(ii);
	  lcd_data(':');
          lcd_testpin(jj);
	  lcd_next_line(0);
	  DisplayValue16(cc,-2,' ',3);
	  DisplayValue16(dd,-12-2,'F',3);
       }
#else  /* without SamplingADC */
 #ifdef WITH_ROTARY_SWITCH
  wait_for_key_ms(MIDDLE_WAIT_TIME);
  if (rotary.incre > FAST_ROTATION) return;	// fast rotation ends the function
  #if (LCD_LINES > 3)
  if (rotary.count < -1) goto show_page_1;
  if (rotary.count < 0) goto show_page_3;
  #else
  if (rotary.count < -3) goto show_page_1;
  if (rotary.count < -2) goto show_page_2;
  if (rotary.count < -1) goto show_page_3;
  if (rotary.count < 0) goto show_page_4;
  #endif
 #endif

#endif  /* SamplingADC */
  wait_for_key_ms(MIDDLE_WAIT_TIME);
//#if  defined(WITH_GRAPHICS) && !defined(SamplingADC)
#ifdef SHOW_ICONS
 ShowIcons();		// show all Icons
#endif
}
#endif


ShowData.ino

Arduino Mega 2560

sketch.json

/*
#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/wdt.h>
#include <stdlib.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/


/* set the processor to sleep state */
/* wake up will be done with compare match interrupt of counter 2 */
void sleep_5ms(uint8_t spause){
uint16_t pause;		// pause is the delay in 5ms units
uint8_t t2_offset;

pause = spause;
// spause = 202 = 2s
// spause = 203 = 3s
// spause = 204 = 4s
// spause = 205 = 5s
if (spause > 200) {
    pause = (spause-200) * 200;
}

while (pause > 0)
  {
 #if (F_CPU / 400) > RESTART_DELAY_TICS
   /* 2 ms are more tics than RESTART_DELAY_TICS */
   if ((TCCR1B & ((1<<CS12)|(1<<CS11)|(1<<CS10))) != 0) {
      // timer 1 is running, don't sleep 
      wait5ms();
      pause -= 1;
   } else {
   if (pause > 1)
     {
      t2_offset = ((F_CPU / 100) - RESTART_DELAY_TICS) / TICS_PER_T2_COUNT;
      pause -= 2;
     } else {
      t2_offset = ((F_CPU / 200) - RESTART_DELAY_TICS) / TICS_PER_T2_COUNT;
      pause = 0;
     }
   
   OCR2A = TCNT2 + t2_offset;	/* set the compare value */
   TIMSK2 = (0<<OCIE2B) | (1<<OCIE2A) | (0<<TOIE2); /* enable output compare match A interrupt */ 
// TIMSK2 |= (1<<OCIE2A); /* enable output compare match A interrupt */ 
   set_sleep_mode(SLEEP_MODE_PWR_SAVE);
   sleep_mode();
// wake up after output compare match interrupt
   TIMSK2 = (0<<OCIE2B) | (0<<OCIE2A) | (0<<TOIE2); /* disable output compare match A interrupt */ 
// TIMSK2 &= ~(1<<OCIE2A); /* disable output compare match A interrupt */ 
   wdt_reset();
  }
 #else
   // Startup time is too long with 1MHz Clock!!!!
   // restart delay ist too long, use normal delay of 5ms
   wait5ms();		// wait5ms includes wdt_reset
   pause -= 1;
 #endif
  }
}


sleep_5ms.ino

Transistortester.h

/*
#include "wait1000ms.h"
#include "lcd_routines.h"
#include "Makefile.h" //J-L
*/

void CheckPins(uint8_t HighPin, uint8_t LowPin, uint8_t TristatePin);
void GetResistance(uint8_t HighPin, uint8_t LowPin);
void ChargePin10ms(uint8_t PinToCharge, uint8_t ChargeDirection);
unsigned int ReadADC(uint8_t mux);		// read Routine for ADC
unsigned int W5msReadADC(uint8_t mux);		// wait 5ms and read than ADC
unsigned int W10msReadADC(uint8_t mux);		// wait 10ms and read than ADC
unsigned int W20msReadADC(uint8_t mux);		// wait 20ms and read then ADC
void ReadCapacity(uint8_t HighPin, uint8_t LowPin);	//capacity measurement
void ReadInductance(void);		//inductance measurement
uint16_t GetESR(uint8_t hipin, uint8_t lopin);	//get ESR of capacitor
void GetVloss(void);			//get Voltage loss of capacitor
void GetIr(uint8_t HighPin, uint8_t LowPin);	// get residual current of diode
void SerienDiodenAusgabe();		// output diodes as ->|-->|- with voltages
void DiodeSymbol_withPins(uint8_t nn); // Output the diode symbol with pins like 1->|-3
void DiodeSymbol_ApinCpin(uint8_t nn);	// output diode symbpl with pins 1->|-3
void DiodeSymbol_ACpin(uint8_t nn);	// output diode symbpl with pins  ->|-3
void DiodeSymbol_CpinApin(uint8_t nn);	// output diode symbpl with pins 1-|<-3
void DiodeSymbol_CApin(uint8_t nn);	// output diode symbpl with pins  -|<-3
void UfAusgabe(uint8_t bcdchar);	// Output of the threshold voltage(s) Uf
void mVAusgabe(uint8_t nn);		// Output of the theshold voltage for Diode nn 
void RvalOut(uint8_t nrr);		// Output of the resistor value(s)
void ShowResistor(void);		// show one or two Resistors
void EntladePins(void);			// discharge capacitors
void RefVoltage(void);			// compensate the reference voltage for comparator 
void AutoCheck(uint8_t test_mode);	// check if self-test should be done 
unsigned int GetRLmultip(unsigned int cvolt);  // get C-Multiplikator for voltage cvolt
void Scale_C_with_vcc(void);		// scale capacity value for different VCC Voltages
void scale_intref_adc(void);		// get scale factors for ReadADC with internal reference
//uint8_t value_out(unsigned long vval,uint8_t pp);    // output 4 digits with (pp-1) digits after point
void DisplayValue(signed long vval,int8_t Expo,unsigned char Unit, uint8_t Digits); //output Digits characters with exponent and unit
void DisplayValue16(uint16_t vval,int8_t Expo,unsigned char Unit, uint8_t Digits); //output Digits characters with exponent and unit
void Display_mV(uint16_t val, uint8_t dd);		// show mV with dd digits
void Display_Hz(unsigned long val, uint8_t dd);		// show Hz with dd digits
unsigned int compute_hfe(unsigned int lpx, unsigned int tpy);
void sleep_5ms(uint8_t xxx);		// set processor to sleep state for xxx times 5ms, xxx>200  (xxx-200)*100  
void PinLayout(char pin1, char pin2, char pin3); // show pin layout with EBC= or 123=
void PinLayoutLine(char pin1, char pin2, char pin3); // show pin layout with Pin 1=...
void Calibrate_UR(void);		// get reference voltages and port resistance
uint16_t get_log(uint16_t permil);	// get -1000*log(1-(permil/1000))
uint8_t ShortedProbes(uint8_t p1, uint8_t p2);	// check if two probes are shorted
uint8_t AllProbesShorted();		// check if all probes are shorted, return 3 if true
void mark_as_uncalibrated();		// mark in EEprom as uncalibrated device
uint8_t wait_for_key_ms(int max_time); // wait max_time ms units for key is pressed
void wait_for_key_5s_line2(void);	// wait 5 seconds and clear line 2
void i2lcd(int iw);			// output integer value to LCD
void u2lcd(uint16_t iw);		// output unsigned integer value to LCD
void i2lcd_space(int iw);		// output integer value to LCD and ' '
void u2lcd_space(uint16_t iw);		// output unsigned integer value to LCD and ' '
void EE_check_init(void);		// check calibration values and init the values if unset
void GetFrequency(uint8_t range);	// measure Frequency and display 
uint8_t function_menu();			// menu for selecting extra function
void show_vext();			// show external voltage (zener) 
void set_big_cap_corr();		// set the correction value for big capacitor measurement
void message_key_released(const unsigned char XX_str[]); // clear display, show message XX_str and wait for released key
void make_frequency(void);		// start counter 1 to make frequency at middle pin
void do_10bit_PWM(void);		// start counter 1 to make fixed frequency with PWM
void show_C_ESR();			// show big capacity values and ESR 
void show_Resis13();			// show Resistor value at TP1:TP3 , measuring continuously
void show_Cap13(void);		        // show Capacitor value at TP1:TP3, measuring continuously
void show_resis(uint8_t pin1, uint8_t pin2, uint8_t how);   // show resistor (and inductance) between pin1 and pin2
void show_cap(uint8_t how);		// show capacity and measure additional values
void show_cap_simple(void);		// show capacity and measure additional values without [C]
void ReadBigCap(uint8_t HighPin, uint8_t LowPin);	//capacity measurement only for big capacitors
void CheckRotaryEncoder(void);				// check rotary puls generator
void check_rotary(void);			// check state of rotary switch	for menu function
void message2line(uint8_t number);	// write menue message number to lcd line
void switch_frequency(uint8_t freq_num);	// switch frequency and write actual frequency to LCD
void CalibrationCap(void);		// read voltage offsets with calibration capacitor
void set_contrast(void);		// set the contrast value of ST7565 controller
void ShowData(void);			// show software revision and calibration parameters
void Battery_check(void);		// check and report the battery state
uint8_t Pwr_mode_check(uint8_t ll);	// give next counter state depending on DC_Pwr_mode
void Bat_update(uint8_t tt);		// Update Battery voltage
void init_parts(void);			// initialize all parts to nothing found
void i2c_init(void);			// init the I2C interface
uint16_t Rnum2pins(uint8_t num);	// compute Pin-Numbers of the resistor number
void myuart_putc(uint8_t bb);
void uart_int(uint16_t num);
void CheckUJT(void);		// measure UJT
void select_color(uint8_t xc);		// select color function 
void switch_tester_off(void);		// switch power off
uint8_t search_vak_diode(void);		// search the diode number of the diode connected to emitter and collector
void mVOut(uint16_t vv);		// mV output for debug
void setFScaler();			// ask for new frequency scaler
uint16_t unsigned_diff(uint16_t v1, uint16_t v2);	// build difference v1-v2, but 0 instead of negative
uint16_t vcc_diff(uint16_t v2);		// build ADCconfig.U_AVCC-v2
uint16_t abs_diff(uint16_t v1, uint16_t v2);	// build absolute value of v1-v2

#ifdef SamplingADC
uint16_t samplingADC(   // code is in sampling_ADC.S
   uint16_t what, 	// what to measure? see smplADC_... defs in config.h, R24:R25
   void *ptr,           // output pointer (note: ptr[0] will contain incorrect data; ptr[1]...ptr[n-1] will be valid) R22:R23
   uint8_t n,           // number of samples (n=0 for 256), R20
   uint8_t Rport_1,	
   uint8_t Rddr_1,	
   uint8_t Rport_0,	
   uint8_t Rddr_0      
   );
// ptr can point to an array of either 8 or 16 bit data (with or without smplADC_8bit, respectively)
// and either signed or unsigned (with or without smplADC_hpf, respectively)
//
// you can find the defines for bits in "what" in config.h
//
// The meaning of Rport_1, Rddr_1, Rport_0 and Rddr_0 are now as follows.
// The measurement cycle consist of three phases, henceforth called idle, pulse, and active, in that order.
// Measurements are performed duing 'active' period.
// Rport_0 and Rddr_0 apply during idle.
// Rport_0 and Rddr_1 apply during active.
// If the samplingADC_direct option is NOT used, during pulse Rddr_0 and Rport_1 apply (duration of pulse is between 1 and 16 CPU cycles, controlled by lower bits of 'what' parameter).
//  (note though that currently the non-direct mode is only used for step response measurements, with Rport_1=Port_0, so effectively no pulse is applied)
// If the samplingADC_direct option is used, a 1 CPU-cycle pulse is applied via de ADC pin corresponding to a 1 bit in Rddr_0.




int32_t sampling_cap(uint8_t HighPin, uint8_t LowPin, uint8_t opts);   
// returns measured capacitance in 0.01 pF units
// opts&1 is flag demands measurement at 5 V rather than at 0 V
// opts&2 is flag to not subtract the parasitic capacitance
void sampling_lc(uint8_t LowPin, uint8_t HighPin);
#define sampling_cap_pre -14
void sampling_cap_calibrate(void);	// calibrate the sampling cap method
void sampling_lc_calibrate(uint8_t count);	// calibrate the sampling  LC method

#ifdef WITH_XTAL
void sampling_test_xtal(void);          // test presence of resonator or crystal between pin 1 and 3 (hardcoded)
uint8_t sampling_measure_xtal(void);    // measure resonator or crystal between pin 1 and 3 (hardcoded),
                                        //   uses data already gathered in previous sampling_test_xtal() call
                                        //   prints output to LCD too
                                        //   returns nonzero if user interrupts this (time-consuming) measurement

// version to be called when using samlingADC_freq option, to pass the desired frequency:
uint16_t samplingADC_freqgen(uint16_t, void*, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t freq);
// version to be called when using samlingADC_sck option, to also pass the desired short circuit duration:
uint16_t samplingADC_freqgen_sck(uint16_t, void*, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint16_t freq, uint8_t shortcircuitduration);
#endif
#endif


tt_function.h

#if defined(MAIN_C)
unsigned long ResistorVal[3];	// Values of resistor 0:1, 0:2, 1:2
uint8_t ResistorList[3];	// list of the found resistor Numbers
uint8_t ResistorChecked[3];	// 2, if resistor is checked in both directions
uint8_t ResistorsFound;	//Number of found resistors

 #if FLASHEND > 0x1fff
   unsigned long inductor_lx;	// inductance 10uH or 100uH
   int8_t inductor_lpre;	// prefix for inductance
 #endif

#else  /* no main */

extern unsigned long ResistorVal[3];	// Values of resistor 0:1, 0:2, 1:2, in units of 0.1 ohms
extern uint8_t ResistorList[3];	// list of the found resistor Numbers
extern uint8_t ResistorChecked[3];	// 2, if resistor is checked in both directions
extern  uint8_t ResistorsFound;	//Number of found resistors

 #if FLASHEND > 0x1fff
   unsigned long inductor_lx;	// inductance 10uH or 100uH
   int8_t inductor_lpre;	// prefix for inductance
 #endif
#endif

#ifdef SamplingADC
// these belong to the LC resonant frequency measurement 
extern uint32_t  lc_fx;      // measured resonant frequency
#define          lc_fpre 0          // ... and its (fixed) prefix
extern uint16_t  lc_qx;     // measured resonance Q
#define          lc_qpre -1         // ... fixed prefix for Q: units of 10^{-1}
extern uint32_t  lc_lx;      // measured inductance using the samplingADC method
#define          lc_lpre -9         // ... and fixed prefix
extern uint16_t  lc_cpar;    // value of parallel capacitor used for calculating inductance, in pF
extern uint16_t  lc_cpartmp;    // used to "exfiltrate" the raw capacitance value from ReadCapacitance()
extern const uint16_t lc_cpar_ee EEMEM;         // place for lc_cpar as calibration constant in eeprom
#endif


tt_resistor.h

/*
#include <avr/io.h>
#include "Transistortester.h"
#include "Makefile.h" //J-L
*/

void DiodeSymbol_withPins(uint8_t nn) {
  uint8_t anode_nr;
  uint8_t cathode_nr;
  anode_nr = diodes.Anode[nn];
  cathode_nr = diodes.Cathode[nn];
#if FLASHEND > 0x1fff
 // enough memory (>8k) to sort the pins
 #if EBC_STYLE == 321
  // the higher test pin number is left side
  if (anode_nr > cathode_nr) {
     DiodeSymbol_ApinCpin(nn);		// 1->|-3
  } else {
     DiodeSymbol_CpinApin(nn);	 // 1-|<-3
  }
 #else
  // the higher test pin number is right side
  if (anode_nr < cathode_nr) {
     DiodeSymbol_ApinCpin(nn);		// 1->|-3
  } else {
     DiodeSymbol_CpinApin(nn);	 // 1-|<-3
  }
 #endif
#else
  // too less memory to sort the pins
  DiodeSymbol_ApinCpin(nn);		// 1->|-3
#endif
  lcd_space();
}
void DiodeSymbol_ApinCpin(uint8_t nn) {
  lcd_testpin(diodes.Anode[nn]);
  DiodeSymbol_ACpin(nn);
}
void DiodeSymbol_ACpin(uint8_t nn) {
  lcd_MEM_string(AnKat_str);	// "->|-"
  lcd_testpin(diodes.Cathode[nn]);
}
void DiodeSymbol_CpinApin(uint8_t nn) {
  lcd_testpin(diodes.Cathode[nn]);
  DiodeSymbol_CApin(nn);
}
void DiodeSymbol_CApin(uint8_t nn) {
  lcd_MEM_string(KatAn_str);	// "-|<-"
  lcd_testpin(diodes.Anode[nn]);
}

void SerienDiodenAusgabe() {
   uint8_t first;
   uint8_t second;
   first = diode_sequence >> 4;
   second = diode_sequence & 3;
   DiodeSymbol_ApinCpin(first);		// 1->|-2
   DiodeSymbol_ACpin(second);		//  ->|-3
   UfAusgabe(diode_sequence);
}


//******************************************************************
// output of flux voltage for 1-2 diodes in row 2
// bcdnum = Numbers of both Diodes:
// higher 4 Bit  number of first Diode
// lower 4 Bit  number of second Diode (Structure diodes[nn])
// if number >= 3  no output is done
void UfAusgabe(uint8_t bcdnum) {
   if (ResistorsFound > 0) { //also Resistor(s) found
      lcd_space();
      lcd_data(LCD_CHAR_RESIS3);	// special symbol or R
   }
   lcd_line2(); 				//2. row
   lcd_MEM_string(Uf_str);			//"Uf="
   mVAusgabe(bcdnum >> 4);
   mVAusgabe(bcdnum & 0x0f);
}
void mVAusgabe(uint8_t nn) {
   if (nn < 6) {
      // Output in mV units
      Display_mV(diodes.Voltage[nn],3);
      lcd_space();
   }
}


UfAusgabe.ino

/*
#include <avr/io.h>
#include "Transistortester.h"
#include "lcd_routines.h"
#include "Makefile.h" //J-L
*/

#define MAX_CS 200	/* maximum key hold time in 10ms units  */

/* *********************************************************** */
/* wait max_time or previous key press */
/* return value: !=0 == key is pressed for x*10ms, 0 == no key pressed, time has expired */
/* Additionally the movement of rotary encoder is monitored, if */
/* the constant WITH_ROTARY_SWITCH is defined.                  */
/* *********************************************************** */
uint8_t wait_for_key_ms(int max_time) {
  uint8_t key_cs;			// period of key hold down in 10ms units
  int8_t kk;
  uint8_t key_pressed;
  int count_time;

#if WITH_ROTARY_SWITCH != 4
 // normal rotary encoder operation, sampling with 200us
 #define WWend 25
 #define WaitRotary wait200us
#else
 // separate Up / Down key instead of rotary encoder, sample with 1ms
 #define WWend 5
 #define WaitRotary wait1ms
#endif

#if (LCD_ST_TYPE == 7920)
  lcd_refresh();
#endif

#ifdef WITH_ROTARY_SWITCH
  uint8_t wait_time;
  // update the state of rotary switch 
  ROTARY_A_DDR &= ~(1<<ROTARY_A_PIN);	// switch A to input
  ROTARY_B_DDR &= ~(1<<ROTARY_B_PIN);	// switch B to input
  wait1ms();
 #if WITH_ROTARY_SWITCH == 4
  rotary.ind = ROT_MSK+1;		//initilize with next call of check_rotary()
 #else
  rotary.count = 0;			// clear count, but don't clear the state history
  rotary.state[(rotary.ind+ROT_MSK-2)&ROT_MSK] = ' ' - '0';  // for debugging
 #endif
#endif

  kk = 100;
  while (kk >= 0)  { /* wait up to 500ms until key is released */
#ifdef WITH_ROTARY_SWITCH
     uint8_t ww;
     for (ww=0; ww < WWend; ww++) {
        check_rotary();		// check for change of switch state of the rotary encoder
        if ((RST_PIN_REG & (1<<RST_PIN)) != 0)  break; // key is released
        WaitRotary();		// wait the predefined time
     }
     if (ww < WWend) break;
#else
     if ((RST_PIN_REG & (1<<RST_PIN)) != 0)  break; // key is released
     wait_about5ms();		// wait 5 ms (sleep)
#endif
     kk--;
  }
// wait 28 seconds or 5 seconds (if repeat function)
  key_cs = 0;				// set key flag to not pressed
  key_pressed = 0x55;
  count_time = max_time;
#ifdef WITH_ROTARY_SWITCH
  wait_time = 0;
#endif
  while (count_time >= 0) {
#ifdef WITH_ROTARY_SWITCH
     // monitor rotary switch during wait
     uint8_t ww;
     for (ww=0; ww < (WWend*2) ;ww++) {
        check_rotary();		// check for change of switch state of the rotary encoder
        WaitRotary();		// wait the predefined time, total 10ms
     }
#else
     wait_about10ms();
#endif
     key_pressed += key_pressed;	// multiply with 2 is shift to left
     if ((RST_PIN_REG & (1<<RST_PIN)) == 0) key_pressed++; // append a 1
     key_pressed &= 0x3f;
     if(key_pressed == 0x3f) {
        // If the key is pressed again... 
        if (key_cs == 0) {
           // first time, when key down is detected
           key_cs = 4;	// must be 7 times for 10ms hold down
           count_time = max_time;	// begin new time period
        }
        key_cs++;			// count the time, the key is hold down
        if (key_cs >= MAX_CS) break;
     } else {
        // key_pressed is zero, if the key is not pressed for 80 ms
        if ((key_pressed == 0) && (key_cs != 0)) break;	// return, if key is released again
     }
     wdt_reset();
//     wait_time++;
     if (count_time > 0) {		// count only, if counter > 0
        count_time -= 10;		// 10 ms are done, count down
        if (count_time == 0) count_time = -1;	// never count to zero, zero is endless!
     }
#ifdef WITH_ROTARY_SWITCH
     if (rotary.incre != 0) {
        wait_time++;	// start time window of 200ms
        if (rotary_switch_present == 0) {
           rotary_switch_present = 1;		// set flag for rotary switch detected
//         eeprom_write_byte((uint8_t *)&EE_RotarySwitch, rotary_switch_present);  // make rotary switch permanent detected 
        }
     }
     if ((wait_time > 20) && (rotary.count != 0)) break;
     if (wait_time > 20) wait_time = 0;		// reset time window
#endif
  } /* end while (count_time >= 0) */
 return(key_cs);		// return period key is pressed within the specified time
}  /* end wait_for_key_5ms(  ) */

#ifdef WITH_ROTARY_SWITCH
/* *********************************************************** */
/* Check for state change of rotary encoder switches and save  */
/* the history. If right turn or left turn is detected,        */
/* increment or decrement the rotary.count                     */
/* The absolute value of rotary steps are hold in rotary.incre . */
/* *********************************************************** */
void check_rotary(void) {
 #if WITH_ROTARY_SWITCH != 4
  // normal rotary encoder with two switches
  uint8_t new_state;
  uint8_t old_ind;
  new_state = 0;		// reset to A and B switch at low level
  if ((ROTARY_A_REG & (1<<ROTARY_A_PIN)) != 0)  new_state = 1;	// switch A is high
  if ((ROTARY_B_REG & (1<<ROTARY_B_PIN)) != 0)  new_state |= 2;	// switch B is high
  if (rotary.ind > ROT_MSK) {	// index is out of range, initialize
//    rotary.state[0] = new_state;
    rotary.state[0] = '>' - '0';
    rotary.state[1] = new_state;
//    for (rotary.ind=2; rotary.ind<16;rotary.ind++) rotary.state[rotary.ind] = ' ' - '0';
    rotary.count = 0;	// reset counter to zero
    rotary.ind = 1;	// set initial index to 1
  }
  if (rotary.state[rotary.ind] != new_state) {
     // state of rotary encoder has changed
     // If the WITH_ROTARY_SWITCH is set to 5, all right state changes cause a count of rotary.count
     // This setting can be used for rotary switch without indexed positions (intends), to get
     // the highest resolution. It can also be used for rotary switches, which have four times
     // more indexed positions than switch cycles per turn (360 degree) for counting  every
     // indexed position.
     // If the WITH_ROTARY_SWITCH is set to 1, only 2 of 4 state changes are counted.
     // If the WITH_ROTARY_SWITCH is set to 2 or 3, only one of 4 state changes are counted.
     // Use setting of 2 or 3, if you operate a rotary switch type, which has the same count of 
     // indexed positions as switch cycles per turn to get one count for every indexed position.

     // There are three states to monitor, the new_state, the last rotary.state[rotary.ind] and
     // the state before rotary.state[old_ind] .
     old_ind = (rotary.ind + ROT_MSK) & ROT_MSK;	// the index of the state before rotary.ind
  #if WITH_ROTARY_SWITCH != 3
     // type 1, 2 and 5
     if ((new_state == 0) && (rotary.state[rotary.ind] == 2) && (rotary.state[old_ind] == 3)) {
        // 320 +
        rotary.count++;
     }
     if ((new_state == 0) && (rotary.state[rotary.ind] == 1) && (rotary.state[old_ind] == 3)) {
        // 310 -
        rotary.count--;
     }
  #endif
  #if WITH_ROTARY_SWITCH != 2
     // type 1, 3 and 5
     if ((new_state == 3) && (rotary.state[rotary.ind] == 2) && (rotary.state[old_ind] == 0)) {
        // 023 -
        rotary.count--;
     }
     if ((new_state == 3) && (rotary.state[rotary.ind] == 1) && (rotary.state[old_ind] == 0)) {
        // 013 +
        rotary.count++;
     }
  #endif
  #if WITH_ROTARY_SWITCH == 5
     if ((new_state == 1) && (rotary.state[rotary.ind] == 3) && (rotary.state[old_ind] == 2)) {
        // 231 -
        rotary.count--;
     }
     if ((new_state == 2) && (rotary.state[rotary.ind] == 3) && (rotary.state[old_ind] == 1)) {
        // 132 +
        rotary.count++;
     }
     if ((new_state == 1) && (rotary.state[rotary.ind] == 0) && (rotary.state[old_ind] == 2)) {
        // 201 +
        rotary.count++;
     }
     if ((new_state == 2) && (rotary.state[rotary.ind] == 0) && (rotary.state[old_ind] == 1)) {
        // 102 -
        rotary.count--;
     }
  #endif
    
     rotary.ind = (rotary.ind + 1) & ROT_MSK;	// update to next entry
     rotary.state[rotary.ind] = new_state;	// save the new state to the history
  }
 #else	/* WITH_ROTARY_SWITCH == 4 */
  // special handling with separate up and down switches instead of rotary switch
  if (rotary.ind > ROT_MSK) {	// index is out of range, initialize
     rotary.a_state = 0x55;
     rotary.b_state = 0x55;
     rotary.count = 0;	// reset counter to zero
     rotary.ind = 0;
      
  }
  rotary.a_state = (rotary.a_state + rotary.a_state); 	// *2 = shift left
  if ((ROTARY_A_REG & (1<<ROTARY_A_PIN)) != 0)  rotary.a_state += 1;	// switch A is high
  if (rotary.a_state == 0x80) {
     rotary.count = 1;		// set counter to 1
  }
  rotary.b_state = (rotary.b_state + rotary.b_state); 	// *2 = shift left
  if ((ROTARY_B_REG & (1<<ROTARY_B_PIN)) != 0)  rotary.b_state += 1;	// switch B is high
  if (rotary.b_state == 0x80) {
     rotary.count = -1;		// set counter to -1
  }
 #endif	/* WITH_ROTARY_SWITCH == 4 */
  if (rotary.count >= 0) {
     rotary.incre = rotary.count;	// absolute value of count
  } else {
     rotary.incre = -rotary.count;	// absolute value of count
  }
}  /* end check_rotary() */
#endif	/* ifdef WITH_ROTARY_SWITCH */

#ifdef WAIT_LINE2_CLEAR
/* *********************************************************** */
/* wait 5 seconds or previous key press, then clear last line  of LCD and */
/* set the cursor to the beginning of last line */
/* *********************************************************** */
void wait_for_key_5s_line2(void) {
  uint8_t current_line;
  current_line = lcd_save_position();
  if (last_line_used != 0) {
  if ((last_line_used == 1) && (current_line == (LCD_LINES-1))) {
     // add a + sign at the last location of screen
     lcd_set_cursor(((LCD_LINES - 1) * PAGES_PER_LINE), (LCD_LINE_LENGTH - 1));
     lcd_data('+');
     lcd_set_cursor(((LCD_LINES - 1) * PAGES_PER_LINE), (LCD_LINE_LENGTH - 1));
  };
 #ifdef WITH_ROTARY_SWITCH
  do {
     if (wait_for_key_ms(SHORT_WAIT_TIME) > 0) break;
     // continue waiting, if the key is not pressed, but rotary switch is rotated
  } while (rotary.incre > 0);
 #else
  wait_for_key_ms(SHORT_WAIT_TIME);	// wait until time is elapsed or key is pressed
 #endif
  if ((current_line == (LCD_LINES - 1)) && (last_line_used == 1)) {
     lcd_set_cursor((LCD_LINES-1) * PAGES_PER_LINE,0);
     lcd_clear_line();		// clear the whole line
  }
  lcd_restore_position();
  }  /* end if last_line_used */
}  /* end wait_for_key_5s_line2() */
#endif


wait_for_key_ms.ino

// Definitions of wait loops (assembly coded)
//void wait5s(void);
//void wait4s(void);
void wait3s(void);
void wait2s(void);
void wait1s(void);
//void wait1000ms(void);
void wait500ms(void);
//void wait400ms(void);
void wait300ms(void);
void wait200ms(void);
void wait100ms(void);
void wait50ms(void);
//void wait40ms(void);
//void wait30ms(void);
void wait20ms(void);
void wait10ms(void);
void wait5ms(void);
//void wait4ms(void);
//void wait3ms(void);
void wait2ms(void);
void wait1ms(void);
void wait500us(void);
//void wait400us(void);
void wait300us(void);
void wait200us(void);
void wait100us(void);
void wait50us(void);
//void wait40us(void);
//void wait30us(void);
void wait20us(void);
void wait10us(void);
// for 1 Mhz clock is  wait10us the last useable function!
void wait5us(void);
void wait4us(void);
void wait3us(void);
void wait2us(void);
//void wait1us(void); //only possible at clock frequency of 8Mhz
void wait500ns(void); //only possible at clock frequency of 16Mhz


wait1000ms.h

// wait loops , sketch compatible


/****   delayMicroseconds()   ****
Pauses the program for the amount of time (in microseconds) specified as parameter.
Currently, the largest value that will produce an accurate delay is 16383.
This could change in future Arduino releases.
For delays longer than a few thousand microseconds, you should use delay() instead.
This function works very accurately in the range 3 microseconds and up.
We cannot assure that delayMicroseconds will perform precisely for smaller delay-times.

As of Arduino 0018, delayMicroseconds() no longer disables interrupts.
*/



void wait3s(void){
  delay(3000);
}

void wait2s(void){
  delay(2000);
}

void wait1s(void){
  delay(1000);
}

void wait500ms(void){
  delay(500);
}

void wait300ms(void){
    delay(300);
}

void wait200ms(void){
    delay(200);
}

void wait100ms(void){
    delay(100);
}

void wait50ms(void){
    delay(50);
}

void wait20ms(void){
    delay(20);
}

void wait10ms(void){
  delayMicroseconds(10000);
}

void wait5ms(void){
  delayMicroseconds(5000);
}

void wait2ms(void){
  delayMicroseconds(2000);
}

void wait1ms(void){
  delayMicroseconds(1000);
}

void wait500us(void){
  delayMicroseconds(500);
}

void wait300us(void){
  delayMicroseconds(300);
}

void wait200us(void){
  delayMicroseconds(200);
}

void wait100us(void){
  delayMicroseconds(100);
}

void wait50us(void){
  delayMicroseconds(50);
}

void wait20us(void){
  delayMicroseconds(20);
}

void wait10us(void){
  delayMicroseconds(10);
}

void wait5us(void){
  delayMicroseconds(5);
}

void wait4us(void){
  delayMicroseconds(4);
}

void wait3us(void){
  delayMicroseconds(3);
}

void wait2us(void){
 asm volatile (
    "nop \n"
    "nop \n"
    );
//delayMicroseconds(2);
}

void wait500ns(void){
 asm volatile (
    "nop \n"
    );
//  delayMicroseconds(1);
}
