void mVAusgabe(uint8_t nn) {
if (nn < 3) {
// Output in mV units
DisplayValue(diodes.Voltage[nn],-3,'V',3);
lcd_space();
}
}
//******************************************************************
// 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 display_menu() {
uint8_t ii;
rawSerial = 1;
lcd_data('\n');
lcd_data('-');
lcd_data('-');
lcd_data('-');
for (ii = 0; ii < MODE_LAST; ii++) {
if (ii == last_func_number) lcd_data('>');
else lcd_space();
message2line(ii);
}
lcd_data('\n');
lcd_data('-');
lcd_data('-');
lcd_data('-');
rawSerial = 0;
}
/* ****************************************************************** */
void message2line(uint8_t number) {
if (number > MODE_LAST) number -= (MODE_LAST + 1);
if (number == MODE_TRANS) lcd_MEM2_string(TESTER_str);
if (number == MODE_FREQ) lcd_MEM2_string(FREQ_str);
#if PROCESSOR_TYP == 644
if (number == MODE_HFREQ) lcd_MEM2_string(HFREQ_str);
if (number == MODE_H_CRYSTAL) lcd_MEM2_string(H_CRYSTAL_str);
if (number == MODE_L_CRYSTAL) lcd_MEM2_string(L_CRYSTAL_str);
#endif
if (number == MODE_FGEN) lcd_MEM2_string(F_GEN_str);
if (number == MODE_PWM) lcd_MEM2_string(PWM_10bit_str);
if (number == MODE_ESR) lcd_MEM2_string(C_ESR_str);
if (number == MODE_RESIS) lcd_MEM_string(RESIS_13_str);
if (number == MODE_CAP13) lcd_MEM_string(CAP_13_str);
if (number == MODE_ROTARY) lcd_MEM2_string(RotaryEncoder_str);
if (number == MODE_BIG_CAP_CORR) lcd_MEM2_string(SetCapCorr_str);
#ifdef WITH_SELFTEST
if (number == MODE_SELFTEST) lcd_MEM2_string(FULLCHECK_str);
#endif
#ifdef WITH_VEXT
if (number == MODE_VEXT) lcd_MEM_string(VOLTAGE_str);
#endif
#if ((LCD_ST_TYPE == 7565) || (LCD_ST_TYPE == 8814) || (LCD_ST_TYPE == 8812) || (LCD_ST_TYPE == 1306) || defined(LCD_DOGM))
if (number == MODE_CONTRAST) lcd_MEM_string(CONTRAST_str);
#endif
if (number == MODE_SHOW) {
lcd_MEM2_string(SHOW_str);
}
if (number == MODE_OFF) {
lcd_MEM2_string(OFF_str);
}
while (_lcd_column<LCD_LINE_LENGTH) {
lcd_space();
}
}
// 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%16) == 0) {
// begin new line
if((cc%64) == 0) {
wait_for_key_ms(ShowTime);
lcd_clear();
}
lcd_set_cursor(((cc/16)%4)*2,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%16) == 0) {
// begin new line
lcd_set_cursor(((cc/16)%4)*2,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
}
/* *************************************************** */
void do_10bit_PWM() {
uint8_t key_pressed;
uint8_t percent; // requestet duty-cycle in %
uint8_t old_perc; // old duty-cycle in %
unsigned int pwm_flip; // value for counter to flip the state
message_key_released(PWM_10bit_str); // display PWM-Generator and wait for key released
// OC1B is connected with 680 Ohm resistor to TP2 (middle test pin)
TCCR1A = (1<<COM1B1) | (0<<COM1B0) | (1<<WGM11) | (1<<WGM10); // fast PWM mode, mode 7: count to 10 bit
TIMSK1 = 0; // no interrupt used
OCR1B = 0xff; // toggle OC1B at this count
TIFR1 = (1<<OCF1A) | (1<<OCF1A) | (1<<TOV1); // reset interrupt flags
TCCR1C = 0;
R_PORT = 0; // set all resistor port outputs to GND
#if PROCESSOR_TYP == 644
R_DDR = (1<<PIN_RL1) | (1<<PIN_RL2) | (1<<PIN_RL3); // set TP1, DDD4(TP2) and TP3 to output
#else
R_DDR = (1<<PIN_RL1) | (1<<PIN_RL3); // set TP1 and TP3 to output
#endif
ADC_PORT = TXD_VAL;
ADC_DDR = (1<<TP1) | TXD_MSK; //connect TP1 to GND
#if PROCESSOR_TYP == 1280
DDRB |= (1<<DDB6); // set output enable for OC1B
#else
DDRB |= (1<<DDB2); // set output enable
#endif
#ifdef PWM_SERVO
TCCR1B = (1<<WGM13) | (1<<WGM12) | SERVO_START; // mode 15, clock divide by 8 or 64
OCR1A = PWM_MAX_COUNT - 1; // clock tics for 20 ms
#else
OCR1A = 1; // highest frequency
TCCR1B = (0<<WGM13) | (1<<WGM12) | (0<<CS12) | (0<<CS11) | (1<<CS10); // mode 7, no clock divide
#endif
key_pressed = 0;
old_perc = 0;
percent = (SERVO_MAX + SERVO_MIN) / 2; // set to middle
#ifdef POWER_OFF
uint8_t times; // time limit
for (times=0; times<240; )
#else
while (1) /* wait endless without option POWER_OFF */
#endif
{
if (percent != old_perc) {
// new duty cycle is requested
if (percent >= SERVO_MAX) {
percent -= (SERVO_MAX - SERVO_MIN); // reset near to mininum value
}
#ifdef PWM_SERVO
pwm_flip = (((unsigned long)PWM_MAX_COUNT * percent) + 500) / 1000;
#else
pwm_flip = (((unsigned long)PWM_MAX_COUNT * percent) + 50) / 100;
#endif
OCR1B = pwm_flip; // new percentage
lcd_line2(); // goto line 2
#ifdef PWM_SERVO
DisplayValue(((unsigned long)pwm_flip * SERVO_DIV)/MHZ_CPU ,-6,'s',3);
lcd_space();
lcd_data('/');
lcd_space();
DisplayValue16(((unsigned long)PWM_MAX_COUNT * SERVO_DIV)/MHZ_CPU, -6,'s',3);
#else
DisplayValue16((((unsigned long)pwm_flip * 1000) + (PWM_MAX_COUNT/2)) / PWM_MAX_COUNT,-1,'%',5);
#endif
lcd_clear_line();
old_perc = percent; // update the old duty cycle
if (key_pressed > 40) {
wait_about300ms(); // wait some time to release the button
}
} /* end if percent != old_perc */
key_pressed = wait_for_key_ms(1600);
if(key_pressed > 130) break; // more than 1.3 seconds
#ifdef WITH_ROTARY_SWITCH
if (rotary.incre > FAST_ROTATION) break; // fast rotation ends voltage measurement
if (rotary.count >= 0) {
percent += rotary.count; // increase the duty cycle by rotary.count
} else {
percent += ((SERVO_MAX-SERVO_MIN) + rotary.count); // decrease the duty cycle by rotary.count
}
#endif
if (key_pressed > 50) {
percent += 10; // duty cycle will be increased with 10
} else {
if (key_pressed > 0) percent += 1; // duty cycle will be increased with 1
}
#ifdef POWER_OFF
#ifdef WITH_ROTARY_SWITCH
if ((key_pressed > 0) || (rotary.incre > 0)) times = 0; // reset the loop counter, operator is active
#else
if (key_pressed > 0) times = 0; //reset the loop counter, operator is active
#endif
#endif
#ifdef POWER_OFF
times = Pwr_mode_check(times); // no time limit with DC_Pwr_mode
#endif
} /* end for times */
ADC_DDR = TXD_MSK; // disconnect TP1
TCCR1B = 0; // stop counter
TCCR1A = 0; // stop counter
R_DDR = 0; // switch resistor ports to Input
#if PROCESSOR_TYP == 1280
DDRB &= ~(1<<DDB6); // disable output
#else
DDRB &= ~(1<<DDB2); // disable output
#endif
} /* end do_10bit_PWM */
/* ****************************************************************** */
void function_menu() {
uint8_t ii;
uint8_t func_number;
#ifdef PAGE_MODE
uint8_t page_nr;
uint8_t p_nr;
uint8_t ff;
page_nr = MODE_LAST;
#ifdef WITH_ROTARY_SWITCH
rotary.count = 0;
#endif
#endif
func_number = 0;
message_key_released(SELECTION_str);
#ifdef POWER_OFF
uint8_t ll;
for (ll=0;ll<((MODE_LAST+1)*10);ll++)
#else
while (1) /* without end, if no power off specified */
#endif
{
if (func_number > MODE_LAST) func_number -= (MODE_LAST + 1);
#if (LCD_LINES > 3)
uint8_t mm;
#ifdef PAGE_MODE
ff = 0;
mm = 0;
do {
p_nr = page_nr + mm;
if (p_nr > MODE_LAST) p_nr -= (MODE_LAST + 1);
if (func_number == p_nr) ff = 1; // number is found
} while (++mm < MENU_LINES);
if (ff == 0) {
// func_number is not in page list
#ifdef WITH_ROTARY_SWITCH
if (rotary.count >= 0) {
page_nr = (func_number + MODE_LAST -1); // page_nr = func_number - 2
} else {
page_nr = func_number; // for backward, set page_nr to func_number
}
if (page_nr > MODE_LAST) page_nr -= (MODE_LAST + 1);
#else
page_nr = func_number;
#endif
}
mm= 0;
do {
p_nr = page_nr + mm;
if (p_nr > MODE_LAST) p_nr -= (MODE_LAST + 1);
lcd_set_cursor((mm+1)*PAGES_PER_LINE,0);
if (func_number == p_nr) {
lcd_data('>');
} else {
lcd_space(); // put a blank to 1. row of line 2
}
message2line(p_nr); // show page function
} while (++mm < MENU_LINES);
#else /* no PAGE_MODE */
uint8_t f_nr;
mm = 0;
do {
lcd_set_cursor((mm+1)*PAGES_PER_LINE,0);
if (mm == MENU_MIDDLE) {
lcd_data('>'); // put a '>' marker to row 1 of line 4
} else {
lcd_space(); // put a blank to 1. row of line 2
}
f_nr = func_number + MODE_LAST + 1 - MENU_MIDDLE + mm;
if (f_nr > MODE_LAST) f_nr -= (MODE_LAST +1);
message2line(f_nr); // show function for this line
} while (++mm < MENU_LINES);
#endif /* PAGE_MODE */
#else /* not LCD_LINES > 3 */
lcd_line2();
message2line(func_number);
#endif /* (LCD_LINES > 3) */
#ifdef POWER_OFF
ii = wait_for_key_ms(SHORT_WAIT_TIME); // wait about 5 seconds
if (ii > 0) ll = 0; // reset timer, operator present
if (DC_Pwr_mode == 1) ll = 0;
#else
ii = wait_for_key_ms(0); // wait endless
#endif
#ifdef WITH_ROTARY_SWITCH
if ((ii >= MIN_SELECT_TIME) || ((rotary_switch_present != 0) && (ii > 0)))
#else
if (ii >= MIN_SELECT_TIME)
#endif
{
// selection only with key-press
if (func_number == MODE_TRANS) break; // return to TransistorTester
if (func_number == MODE_FREQ) GetFrequency(0);
#if PROCESSOR_TYP == 644
if (func_number == MODE_HFREQ) GetFrequency(1); // measure high frequency with 16:1 divider
if (func_number == MODE_H_CRYSTAL) GetFrequency(5); // HF crystal input + 16:1 divider
if (func_number == MODE_L_CRYSTAL) GetFrequency(6); // LF crystal input, 1:1 divider
#endif
if (func_number == MODE_FGEN) {
make_frequency(); // make some sample frequencies
}
if (func_number == MODE_PWM) {
do_10bit_PWM(); // generate 10bit PWM
}
if (func_number == MODE_ESR) {
show_C_ESR(); // measure capacity and ESR at TP1 and TP3
}
if (func_number == MODE_RESIS) {
show_Resis13(); // measure resistor at TP1 and TP3
}
if (func_number == MODE_CAP13) {
lcd_clear();
show_Cap13(); // measure capacitor at TP1 and TP3
}
if (func_number == MODE_ROTARY) {
CheckRotaryEncoder(); // check rotary encoder
}
if (func_number == MODE_BIG_CAP_CORR) {
set_big_cap_corr();
}
#ifdef WITH_SELFTEST
if (func_number == MODE_SELFTEST) AutoCheck(0x11); // Full selftest with calibration
#endif
if (func_number == MODE_VEXT) show_vext();
#if ((LCD_ST_TYPE == 7565) || (LCD_ST_TYPE == 1306) || (LCD_ST_TYPE == 8812) || (LCD_ST_TYPE == 8814) || defined(LCD_DOGM))
if (func_number == MODE_CONTRAST) set_contrast();
#endif
if (func_number == MODE_SHOW) {
ShowData(); // Show Calibration Data
}
if (func_number == MODE_OFF) {
ON_PORT &= ~(1<<ON_PIN); //switch off power
wait_for_key_ms(0); //never ending loop
}
// don't increase function number for easier selection the same function
ii = 0; // function was executed before, do not increase func_number
#ifdef WITH_ROTARY_SWITCH
rotary.incre = 0; // reset all rotary information
rotary.count = 0;
#endif
message_key_released(SELECTION_str); //write Line 1 with Selection:
} /* end if (ii >= MIN_SELECT_TIME) */
#ifdef WITH_ROTARY_SWITCH
if (rotary.incre >= FAST_ROTATION) break; // to much rotation
#ifdef POWER_OFF
if (rotary.count != 0) ll = 0; // someone is working, reset timer
#endif
if (rotary.count >= 0) {
func_number += rotary.count; // function number is increased by rotary steps
} else {
func_number += (MODE_LAST + 1 + rotary.count); // function is decreased by rotary steps
}
#endif
if (ii > 0) func_number++; // increase the function number with key press
} /* end for ll */
return;
} // end function_menu()
//=================================================================
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;
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
uint8_t LowPin; // number of pin with low voltage
uint8_t HighPin; // number of pin with high voltage
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
inductor_lpre = 0; // H units, mark inductor as 0
if(PartFound != PART_RESISTOR) {
return; //We have found no resistor
}
if (ResistorsFound != 1) {
return; // do not search for inductance, more than 1 resistor
}
if (resis[0].rx > 21000) return;
// 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
LowPin = resis[0].ra;
HighPin = resis[0].rb;
} else {
// third and fourth pass, direction 2
LowPin = resis[0].rb;
HighPin = resis[0].ra;
}
HiADC = pgm_read_byte(&PinADCtab[HighPin]); // Table of ADC Pins including | TXD_VAL
LoPinR_L = pgm_read_byte(&PinRLtab[LowPin]); //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 ((resis[0].rx < 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<<LowPin) | 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(LowPin);
total_r = ReadADC(HighPin);
if ((umax < 2) && (total_r < 2)) 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) | LowPin; // 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.13 s
}
}
}
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(LowPin);
total_r = ReadADC(HighPin);
if ((umax < 2) && (total_r < 2)) break; // low current detected
}
#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 + resis[0].rx + 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); // -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();
DisplayValue(tmpint,-3,'V',4);
lcd_space();
DisplayValue(umax,-3,'V',4);
lcd_space();
DisplayValue(per_ref2,-1,'%',4);
wait_about4s();
wait_about2s();
}
#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) || (resis[0].rx >= 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()
// 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)
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(PC0); // which voltage has Pin 1?
adcmv[1] = ReadADC(PC1); // which voltage has Pin 2?
adcmv[2] = ReadADC(PC2); // which voltage has Pin 3?
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
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<<PC0); //Pin 1 directly to GND
}
if (adcmv[1] < 1000) {
adc_gnd |= (1<<PC1); //Pin 2 directly to GND
}
if (adcmv[2] < 1000) {
adc_gnd |= (1<<PC2); //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(PC0); // which voltage has Pin 1?
adcmv[1] = ReadADC(PC1); // which voltage has Pin 2?
adcmv[2] = ReadADC(PC2); // which voltage has Pin 3?
if (adcmv[0] < 1300) {
ADC_DDR |= (1<<PC0); // below 1.3V , switch directly with ADC-Port to GND
}
if (adcmv[1] < 1300) {
ADC_DDR |= (1<<PC1); // below 1.3V, switch directly with ADC-Port to GND
}
if (adcmv[2] < 1300) {
ADC_DDR |= (1<<PC2); // 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(adcmv[0]; // lcd_string(utoa(adcmv[0], outval, 10));
lcd_space();
u2lcd(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
}
/* *************************************************** */
void do_10bit_PWM() {
uint8_t key_pressed;
uint8_t percent; // requestet duty-cycle in %
uint8_t old_perc; // old duty-cycle in %
unsigned int pwm_flip; // value for counter to flip the state
message_key_released(PWM_10bit_str); // display PWM-Generator and wait for key released
// OC1B is connected with 680 Ohm resistor to TP2 (middle test pin)
TCCR1A = (1<<COM1B1) | (0<<COM1B0) | (1<<WGM11) | (1<<WGM10); // fast PWM mode, count to 10 bit
TIMSK1 = 0; // no interrupt used
OCR1A = 1; // highest frequency
OCR1B = 0xff; // toggle OC1B at this count
TIFR1 = (1<<OCF1A) | (1<<OCF1A) | (1<<TOV1); // reset interrupt flags
TCCR1C = 0;
R_PORT = 0; // set all resistor port outputs to GND
#if PROCESSOR_TYP == 644
R_DDR = (1<<PIN_RL1) | (1<<PIN_RL2) | (1<<PIN_RL3); // set TP1, DDD4(TP2) and TP3 to output
#else
R_DDR = (1<<PIN_RL1) | (1<<PIN_RL3); // set TP1 and TP3 to output
#endif
ADC_PORT = TXD_VAL;
ADC_DDR = (1<<TP1) | TXD_MSK; //connect TP1 to GND
DDRB |= (1<<DDB2); // set output enable
TCCR1B = (0<<WGM13) | (1<<WGM12) | (0<<CS12) | (0<<CS11) | (1<<CS10); // no clock divide
key_pressed = 0;
old_perc = 0;
percent = 10;
#ifdef POWER_OFF
uint8_t times; // time limit
for (times=0; times<240; times++)
#else
while (1) /* wait endless without option POWER_OFF */
#endif
{
if (percent != old_perc) {
// new duty cycle is requested
if (percent >= 100) {
percent -= 100; //reset to 0 percent or higher
}
pwm_flip = (((unsigned long)0x3ff * percent) + 50) / 100;
OCR1B = pwm_flip; // new percentage
lcd_line2(); // set cursor to begin of line 2
lcd_clear_line(); // clear line 2
lcd_line2(); // set cursor to row 1 of line 2
DisplayValue((((unsigned long)pwm_flip * 1000) + 0x1ff) / 0x3ff,-1,'%',5);
#if 0
lcd_space();
if (rotary.count >= 0) { // actual count for debugging
lcd_data('+');
lcd_data('0'+rotary.count);
} else {
lcd_data('-');
lcd_data('0'-rotary.count);
}
lcd_line3();
uint8_t kk;
kk = (rotary.ind + 1) & ROT_MSK;
do {
lcd_data('0'+rotary.state[kk]); // debugging output of rotary state
kk = (kk + 1) & ROT_MSK;
} while (kk != rotary.ind);
#endif
old_perc = percent; // update the old duty cycle
if (key_pressed > 40) {
wait_about300ms(); // wait some time to release the button
}
} /* end if percent != old_perc */
key_pressed = wait_for_key_ms(1600);
if(key_pressed > 130) break; // more than 1.3 seconds
#ifdef WITH_ROTARY_SWITCH
if (rotary.incre > FAST_ROTATION) break; // fast rotation ends voltage measurement
if (rotary.count >= 0) {
percent += rotary.count; // increase the duty cycle by rotary.count
} else {
percent += (100 + rotary.count); // decrease the duty cycle by rotary.count
}
#endif
if (key_pressed > 50) {
percent += 10; // duty cycle will be increased with 10
} else {
if (key_pressed > 0) percent += 1; // duty cycle will be increased with 1
}
#ifdef POWER_OFF
#ifdef WITH_ROTARY_SWITCH
if ((key_pressed > 0) || (rotary.incre > 0)) times = 0; // reset the loop counter, operator is active
#else
if (key_pressed > 0) times = 0; //reset the loop counter, operator is active
#endif
#endif
} /* end for times */
ADC_DDR = TXD_MSK; // disconnect TP1
TCCR1B = 0; // stop counter
TCCR1A = 0; // stop counter
R_DDR = 0; // switch resistor ports to Input
DDRB &= ~(1<<DDB2); // disable output
} /* end do_10bit_PWM */
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
#endif
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
#undef CNT1_END_VAL
#undef CNT1_DIVIDER
#define CNT1_END_VAL ((F_CPU / 1024UL) + 1)
#define CNT1_DIVIDER ((1<<CS12) | (1<<CS10))
#if F_CPU != ((F_CPU / 1024UL) * 1024UL)
#warning F_CPU can not be divided by 1024, measured frequency is wrong!
#endif
#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; // 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
TIMSK1 = (1<<OCIE1B) | (1<<OCIE1A); // enable the Compare A match and Compare B match interrupt
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
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);
} else {
// frequency divider is activ
Display_Hz(ext_freq.dw*FREQ_DIV, 7);
}
#else
Display_Hz(ext_freq.dw, 7);
#endif
#if PROCESSOR_TYP == 644
lcd_space();
if ((FDIV_PORT&(1<<FDIV_PIN)) != 0) {
lcd_data('/'); // Frequency divider is activ
} else {
lcd_space(); // Frequency divider is not activ
}
#endif
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
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
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
#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 (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
} else {
if (ext_period > 249500) {
#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.0001Hz (1e11*1e4)/(0.01ns count)
freq_from_per = (unsigned long long)(1000000000000000) / ext_period;
DisplayValue(freq_from_per,-4,'H',7); // display with 0.0001 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()
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();
#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
}
void AutoCheck(uint8_t test_mode) {
/* (test_mode & 0x0f) == 0 , only calibration without T1-T7 */
/* (test_mode & 0x0f) == 1 , calibration and additional T1-T7 */
/* (test_mode & 0xf0) == 0 , check for shorted probes, if unshorted, return */
/* (test_mode & 0xf0) == 0x10 , ask for shorted probes */
uint8_t ww; // counter for repeating the tests
int adcmv[7];
#ifdef EXTENDED_TESTS
uint16_t u680; // 3 * (Voltage at 680 Ohm)
uint8_t taste; // ist key pressed? 0 = no
#else
#ifndef NO_TEST_T1_T7
#warning "Selftest without extended tests T1 to T7!"
#endif
#endif
#if defined(EXTENDED_TESTS) || defined(WITH_MENU)
uint8_t tt; // number of running test
#endif
#ifdef FREQUENCY_50HZ
uint8_t ff50; // loop counter for 2s
#endif
// define the maximum count of repetitions MAX_REP
#define MAX_REP 4
#ifdef AUTO_CAL
uint8_t cap_found; // counter for found capacitor
#ifdef AUTOSCALE_ADC
int8_t udiff; // difference between ADC Voltage with VCC or Bandgap reference
int8_t udiff2;
#endif
#endif
PartFound = PART_NONE; // no part found before
if ((test_mode & 0xf0) == 0) {
// probed should be shorted already to begin selftest
if (AllProbesShorted() != 3) return;
lcd_clear();
lcd_MEM_string(SELFTEST); // "Selftest mode.."
lcd_line2();
lcd_data('?'); // wait for key pressed for confirmation
if (wait_for_key_ms(2000) > 10) goto begin_selftest; // key is pressed again
#ifdef WITH_MENU
} else {
// report to user, that probes should be shorted
ww = 0;
for (tt=0;tt<150;tt++) { /* wait about 30 seconds for shorted probes */
lcd_clear();
lcd_MEM2_string(SHORT_PROBES_str); // message "Short probes!" to LCD
if (AllProbesShorted() == 3) {
ww++; // all probes now shorted
} else {
ww = 0; // connection not stable, retry
}
if (ww > 3) break; // connection seems to be stable
lcd_refresh(); // write the pixels to display, ST7920 only
wait_about200ms(); // wait 200ms and try again
} /* end for (tt...) */
if (tt < 150) goto begin_selftest; // is shorted before time limit
goto no_zero_resistance; // skip measuring of the zero resistance
#endif
}
// no key pressed for 2s
lcd_clear();
lcd_MEM_string(VERSION_str); //"Version ..."
return;
begin_selftest:
lcd_line2();
lcd_MEM2_string(R0_str); // "R0="
eeprom_write_byte((uint8_t *)(&EE_ESR_ZEROtab[2]), (uint8_t)0); // clear zero offset
eeprom_write_byte((uint8_t *)(&EE_ESR_ZEROtab[3]), (uint8_t)0); // clear zero offset
eeprom_write_byte((uint8_t *)(&EE_ESR_ZEROtab[1]), (uint8_t)0); // clear zero offset
adcmv[0] = GetESR(TP3, TP1);
adcmv[1] = GetESR(TP3, TP2);
adcmv[2] = GetESR(TP2, TP1);
DisplayValue16(adcmv[0],-2,' ',3);
DisplayValue16(adcmv[1],-2,' ',3);
DisplayValue16(adcmv[2],-2,LCD_CHAR_OMEGA,3);
if (adcmv[0] >= 90) {
adcmv[0] = ESR_ZERO; // set back to default value
}
eeprom_write_byte((uint8_t *)(&EE_ESR_ZEROtab[2]), (uint8_t)adcmv[0]); // fix zero offset
if (adcmv[1] >= 90) {
adcmv[1] = ESR_ZERO; // set back to default value
}
eeprom_write_byte((uint8_t *)(&EE_ESR_ZEROtab[3]), (uint8_t)adcmv[1]); // fix zero offset
if (adcmv[2] >= 90) {
adcmv[2] = ESR_ZERO; // set back to default value
}
eeprom_write_byte((uint8_t *)(&EE_ESR_ZEROtab[1]), (uint8_t)adcmv[2]); // fix zero offset
last_line_used = 2;
wait_for_key_5s_line2(); // wait up to 5 seconds and clear line 2
#ifdef WITH_MENU
no_zero_resistance:
#endif
#ifdef EXTENDED_TESTS
#define TEST_COUNT 8
if((test_mode & 0x0f) == 1) { /* full test requested */
for(tt=1;tt<TEST_COUNT;tt++) { // loop for all Tests
for(ww=0;ww<MAX_REP;ww++) { // repeat the test MAX_REP times
lcd_clear_line2(); // clear total line 2
lcd_clear_line1(); // clear total line 1
lcd_data('T'); //output the Testmode "T"
u2lcd(tt); //lcd_string(utoa(tt, outval, 10)); //output Test number
lcd_space();
//############################################
if (tt == 1) { // output of reference voltage and factors for capacity measurement
lcd_MEM2_string(URef_str); //"URef="
Calibrate_UR(); // get Reference voltage, Pin resistance
Display_mV(ref_mv,4);
lcd_line2(); //Cursor to column 1, row 2
lcd_MEM2_string(RHfakt_str); //"RHf="
u2lcd(RHmultip); //lcd_string(utoa(RHmultip, outval, 10));
ADCconfig.Samples = R_ANZ_MESS; // set number of ADC reads near to maximum
}
//############################################
if (tt == 2) { // how equal are the RL resistors?
u680 = ((long)ADCconfig.U_AVCC * (PIN_RM + R_L_VAL) / (PIN_RM + R_L_VAL + R_L_VAL + PIN_RP));
R_PORT = 1<<PIN_RL1; //RL1 to VCC
R_DDR = (1<<PIN_RL1) | (1<<PIN_RL2); //RL2 to -
adcmv[0] = W20msReadADC(TP1);
adcmv[0] -= u680;
R_DDR = (1<<PIN_RL1) | (1<<PIN_RL3); //RL3 to -
adcmv[1] = W20msReadADC(TP1);
adcmv[1] -= u680;
R_PORT = 1<<PIN_RL2; //RL2 to VCC
R_DDR = (1<<PIN_RL2) | (1<<PIN_RL3); //RL3 to -
adcmv[2] = W20msReadADC(TP2);
adcmv[2] -= u680;
lcd_MEM_string(RLRL_str); // "RLRL"
}
//############################################
if (tt == 3) { // how equal are the RH resistors
R_PORT = 1<<PIN_RH1; //RH1 to VCC
R_DDR = (1<<PIN_RH1) | (1<<PIN_RH2); //RH2 to -
adcmv[0] = W20msReadADC(TP1);
adcmv[3] = ADCconfig.U_AVCC / 2;
adcmv[0] -= adcmv[3];
R_DDR = (1<<PIN_RH1) | (1<<PIN_RH3); //RH3 to -
adcmv[1] = W20msReadADC(TP1);
adcmv[1] -= adcmv[3];
R_PORT = 1<<PIN_RH2; //RH2 to VCC
R_DDR = (1<<PIN_RH2) | (1<<PIN_RH3); //RH3 to -
adcmv[2] = W20msReadADC(TP2);
adcmv[2] -= adcmv[3];
lcd_MEM_string(RHRH_str); // "RHRH"
}
//############################################
if (tt == 4) { // Text release probes
lcd_MEM_string(RELPROBE); // "Release Probes"
if (AllProbesShorted() != 0) ww = MAX_REP-2;
}
//############################################
if (tt == 5) { // can we switch the ADC pins to GND across R_H resistor?
R_PORT = 0;
R_DDR = 1<<PIN_RH1; //Pin 1 over R_H to GND
adcmv[0] = W20msReadADC(TP1);
R_DDR = 1<<PIN_RH2; //Pin 2 over R_H to GND
adcmv[1] = W20msReadADC(TP2);
R_DDR = 1<<PIN_RH3; //Pin 3 over R_H to GND
adcmv[2] = W20msReadADC(TP3);
lcd_MEM_string(RH1L_str); // "RH_Lo="
}
//############################################
if (tt == 6) { // can we switch the ADC pins to VCC across the R_H resistor?
R_DDR = 1<<PIN_RH1; //Pin 1 over R_H to VCC
R_PORT = 1<<PIN_RH1;
adcmv[0] = W20msReadADC(TP1) - ADCconfig.U_AVCC;
R_DDR = 1<<PIN_RH2; //Pin 2 over R_H to VCC
R_PORT = 1<<PIN_RH2;
adcmv[1] = W20msReadADC(TP2) - ADCconfig.U_AVCC;
R_DDR = 1<<PIN_RH3; //Pin 3 over R_H to VCC
R_PORT = 1<<PIN_RH3;
adcmv[2] = W20msReadADC(TP3) - ADCconfig.U_AVCC;
lcd_MEM_string(RH1H_str); // "RH_Hi="
}
if (tt == 7) { // is the voltage of all R_H / R_L dividers correct?
u680 = ((long)ADCconfig.U_AVCC * (PIN_RM + R_L_VAL) / (PIN_RM + R_L_VAL + (unsigned long)R_H_VAL*100));
R_PORT = 1<<PIN_RH1; //RH1 to VCC
R_DDR = (1<<PIN_RH1) | (1<<PIN_RL1); //RH1 to +, RL1 to -
adcmv[0] = W20msReadADC(TP1);
adcmv[0] -= u680;
R_PORT = 1<<PIN_RH2; //RH2 to VCC
R_DDR = (1<<PIN_RH2) | (1<<PIN_RL2); //RH2 to +, RL2 to -
adcmv[1] = W20msReadADC(TP2);
adcmv[1] -= u680;
R_PORT = 1<<PIN_RH3; //RH3 to VCC
R_DDR = (1<<PIN_RH3) | (1<<PIN_RL3); //RH3 to +, RL3 to -
adcmv[2] = W20msReadADC(TP3);
adcmv[2] -= u680;
lcd_MEM_string(RHRL_str); // "RH/RL"
}
//############################################
if (tt > 1) { // output 3 voltages
lcd_line2(); //Cursor to column 1, row 2
i2lcd(adcmv[0]); // lcd_string(itoa(adcmv[0], outval, 10)); //output voltage 1
lcd_space();
i2lcd(adcmv[1]); // lcd_string(itoa(adcmv[1], outval, 10)); //output voltage 2
lcd_space();
i2lcd(adcmv[2]); // lcd_string(itoa(adcmv[2], outval, 10)); //output voltage 3
}
ADC_DDR = TXD_MSK; // all-Pins to Input
ADC_PORT = TXD_VAL; // all ADC-Ports to GND
R_DDR = 0; // all R-Ports to Input
R_PORT = 0;
taste = wait_for_key_ms(1000); // wait up to 1 second or key is pressed
if ((tt != 4) && (taste > 10)) {
// don't finish repetition for T4 with pressed key
break; // if key is pressed, don't repeat
}
} //end for ww
wait_for_key_ms(1000); // wait up to 1 second or key is pressed
} //end for tt
#if PROCESSOR_TYP == 1280
lcd_clear();
lcd_testpin(TP1);
lcd_data('L');
lcd_equal(); // lcd_data('=');
ADC_PORT = TXD_VAL;
ADC_DDR = (1<<TP1) | TXD_MSK;
R_PORT = (1<<PIN_RL1);
R_DDR = (1<<PIN_RL1);
adcmv[0] = W5msReadADC(TP1);
ADCSRB = (1<<MUX5); // switch to upper 8 MUX inputs
adcmv[1] = ReadADC(PIN_RL1);
ADCSRB = 0; // switch back to lower 8 MUX inputs
ResistorVal[0] = (adcmv[0] * (unsigned long)R_L_VAL) / (adcmv[1] - adcmv[0]);
DisplayValue(ResistorVal[0],-1,LCD_CHAR_OMEGA,3);
lcd_space();
lcd_data('H');
lcd_equal(); // lcd_data('=');
ResistorVal[1] = ((ADCconfig.U_AVCC - adcmv[1]) * (unsigned long)R_L_VAL) / (adcmv[1] - adcmv[0]);
DisplayValue(ResistorVal[1],-1,LCD_CHAR_OMEGA,3);
lcd_line2();
lcd_testpin(TP1);
lcd_space();
lcd_data('H');
lcd_equal(); // lcd_data('=');
ADC_PORT = (1<<TP1) | TXD_VAL;
R_PORT = 0;
adcmv[0] = W5msReadADC(TP1);
ADCSRB = (1<<MUX5); // switch to upper 8 MUX inputs
adcmv[1] = ReadADC(PIN_RL1);
ADCSRB = 0; // switch back to lower 8 MUX inputs
ResistorVal[1] = ((ADCconfig.U_AVCC - adcmv[0]) * (unsigned long)R_L_VAL) / (adcmv[0] - adcmv[1]);
DisplayValue(ResistorVal[1],-1,LCD_CHAR_OMEGA,3);
lcd_space();
lcd_data('L');
lcd_equal(); // lcd_data('=');
ResistorVal[0] = (adcmv[1] * (unsigned long)R_L_VAL) / (adcmv[0] - adcmv[1]);
DisplayValue(ResistorVal[0],-1,LCD_CHAR_OMEGA,3);
wait_about1s(); // only for mega1280
last_line_used = 2;
wait_for_key_5s_line2(); // wait up to 5 seconds and clear line 2
//
lcd_clear();
lcd_testpin(TP2);
lcd_data('L');
lcd_equal(); // lcd_data('=');
ADC_PORT = TXD_VAL;
ADC_DDR = (1<<TP2) | TXD_MSK;
R_PORT = (1<<PIN_RL2);
R_DDR = (1<<PIN_RL2);
adcmv[0] = W5msReadADC(TP2);
ADCSRB = (1<<MUX5); // switch to upper 8 MUX inputs
adcmv[1] = ReadADC(PIN_RL2);
ADCSRB = 0; // switch back to lower 8 MUX inputs
ResistorVal[0] = (adcmv[0] * (unsigned long)R_L_VAL) / (adcmv[1] - adcmv[0]);
DisplayValue(ResistorVal[0],-1,LCD_CHAR_OMEGA,3);
lcd_space();
lcd_data('H');
lcd_equal(); // lcd_data('=');
ResistorVal[1] = ((ADCconfig.U_AVCC - adcmv[1]) * (unsigned long)R_L_VAL) / (adcmv[1] - adcmv[0]);
DisplayValue(ResistorVal[1],-1,LCD_CHAR_OMEGA,3);
lcd_line2();
lcd_testpin(TP2);
lcd_data('H');
lcd_equal(); // lcd_data('=');
ADC_PORT = (1<<TP2) | TXD_VAL;
R_PORT = 0;
adcmv[0] = W5msReadADC(TP2);
ADCSRB = (1<<MUX5); // switch to upper 8 MUX inputs
adcmv[1] = ReadADC(PIN_RL2);
ADCSRB = 0; // switch back to lower 8 MUX inputs
ResistorVal[1] = ((ADCconfig.U_AVCC - adcmv[0]) * (unsigned long)R_L_VAL) / (adcmv[0] - adcmv[1]);
DisplayValue(ResistorVal[1],-1,LCD_CHAR_OMEGA,3);
lcd_space();
lcd_data('L');
lcd_equal(); // lcd_data('=');
ResistorVal[0] = (adcmv[1] * (unsigned long)R_L_VAL) / (adcmv[0] - adcmv[1]);
DisplayValue(ResistorVal[0],-1,LCD_CHAR_OMEGA,3);
wait_about1s(); // only for mega1280
last_line_used = 2;
wait_for_key_5s_line2(); // wait up to 5 seconds and clear line 2
//
lcd_clear();
lcd_testpin(TP3);
lcd_data('L');
lcd_equal(); // lcd_data('=');
ADC_DDR = (1<<TP3) | TXD_MSK;
R_PORT = (1<<PIN_RL3);
R_DDR = (1<<PIN_RL3);
adcmv[0] = W5msReadADC(TP3);
ADCSRB = (1<<MUX5); // switch to upper 8 MUX inputs
adcmv[1] = ReadADC(PIN_RL3);
ADCSRB = 0;
ResistorVal[0] = (adcmv[0] * (unsigned long)R_L_VAL) / (adcmv[1] - adcmv[0]);
DisplayValue(ResistorVal[0],-1,LCD_CHAR_OMEGA,3);
lcd_space();
lcd_data('H');
lcd_equal(); // lcd_data('=');
ResistorVal[1] = ((ADCconfig.U_AVCC - adcmv[1]) * (unsigned long)R_L_VAL) / (adcmv[1] - adcmv[0]);
DisplayValue(ResistorVal[1],-1,LCD_CHAR_OMEGA,3);
lcd_line2();
lcd_testpin(TP3);
lcd_data('H');
lcd_equal(); // lcd_data('=');
ADC_PORT = (1<<TP3) | TXD_VAL;
R_PORT = 0;
adcmv[0] = W5msReadADC(TP3);
ADCSRB = (1<<MUX5); // switch to upper 8 MUX inputs
adcmv[1] = ReadADC(PIN_RL3);
ADCSRB = 0; // switch back to lower 8 MUX inputs
ResistorVal[1] = ((ADCconfig.U_AVCC - adcmv[0]) * (unsigned long)R_L_VAL) / (adcmv[0] - adcmv[1]);
DisplayValue(ResistorVal[1],-1,LCD_CHAR_OMEGA,3);
lcd_space();
lcd_data('L');
lcd_equal(); // lcd_data('=');
ResistorVal[0] = (adcmv[1] * (unsigned long)R_L_VAL) / (adcmv[0] - adcmv[1]);
DisplayValue(ResistorVal[0],-1,LCD_CHAR_OMEGA,3);
wait_about1s(); // only for mega1280
last_line_used = 2;
wait_for_key_5s_line2(); // wait up to 5 seconds and clear line 2
#endif /* PROCESSOR_TYP == 1280 */
} /* end if((test_mode & 0x0f) == 1) */
#endif /* end EXTENDED_TESTS */
for (ww=0;ww<120;ww++) {
// wait up to 1 minute for releasing the probes
if (AllProbesShorted() == 0) break;
lcd_clear_line2(); // clear total line2
lcd_MEM_string(RELPROBE); // "Release Probes"
lcd_refresh(); // write the pixels to display, ST7920 only
wait_about500ms();
}
lcd_clear();
lcd_MEM_string(RIHI_str); // "RiHi="
DisplayValue16(RRpinPL,-1,LCD_CHAR_OMEGA,3);
lcd_line2();
lcd_MEM_string(RILO_str); // "RiLo="
DisplayValue16(RRpinMI,-1,LCD_CHAR_OMEGA,3);
last_line_used = 2;
wait_for_key_5s_line2(); // wait up to 5 seconds and clear line 2
//measure Zero offset for Capacity measurement
PartFound = PART_NONE;
lcd_clear();
lcd_MEM_string(C0_str); //output "C0 "
ReadCapacity(TP3, TP1);
adcmv[5] = (unsigned int) cap.cval_uncorrected.dw; //save capacity value of empty Pin 1:3
ReadCapacity(TP3, TP2);
adcmv[6] = (unsigned int) cap.cval_uncorrected.dw; //save capacity value of empty Pin 2:3
ReadCapacity(TP2, TP1);
adcmv[2] = (unsigned int) cap.cval_uncorrected.dw; //save capacity value of empty Pin 1:2
ReadCapacity(TP1, TP3);
adcmv[1] = (unsigned int) cap.cval_uncorrected.dw; //save capacity value of empty Pin 3:1
ReadCapacity(TP2, TP3);
adcmv[4] = (unsigned int) cap.cval_uncorrected.dw; //save capacity value of empty Pin 3:2
ReadCapacity(TP1, TP2);
adcmv[0] = (unsigned int) cap.cval_uncorrected.dw; //save capacity value of empty Pin 2:1
#ifdef WITH_MENU
if (((test_mode & 0x0f) == 1) || (UnCalibrated == 2))
#else
if (UnCalibrated == 2)
#endif
{
adcmv[3] = adcmv[0] + 2; // mark as uncalibrated until Cap > 100nF has success
} else {
adcmv[3] = adcmv[0]; // mark as calibrated, short calibration is finished
UnCalibrated = 0; // clear the UnCalibrated Flag
lcd_cursor_off(); // switch cursor off
}
u2lcd_space(adcmv[5]); //DisplayValue(adcmv[5],0,' ',3); //output cap0 1:3
u2lcd_space(adcmv[6]); //DisplayValue(adcmv[6],0,' ',3); //output cap0 2:3
DisplayValue(adcmv[2],-12,'F',3); //output cap0 1:2
#ifdef AUTO_CAL
for (ww=0;ww<7;ww++) { //checking loop
if ((adcmv[ww] > 190) || (adcmv[ww] < 10)) goto no_c0save;
}
for (ww=0;ww<7;ww++) {
// write all zero offsets to the EEprom
(void) eeprom_write_byte((uint8_t *)(&c_zero_tab[ww]),adcmv[ww]+(COMP_SLEW1 / (CC0 + CABLE_CAP + COMP_SLEW2)));
}
lcd_line2();
lcd_MEM_string(OK_str); // output "OK"
no_c0save:
#endif
last_line_used = 2;
wait_for_key_5s_line2(); // wait up to 5 seconds and clear line 2
#ifdef SamplingADC
sampling_cap_calibrate(); // measure zero capacity for samplingADC
#endif
#ifdef AUTO_CAL
#ifdef WITH_MENU
if (((test_mode & 0x0f) == 1) || (UnCalibrated == 2))
#endif
// without menu function the capacitor is requested every time,
// because there is no way to request recaltbration again
// With menu function the capacitor is only requested for first time
// calibration (UnCalibrated = 2) or for the full selftest call (test_mode = 1)
// of the menu function, not with the automatically call (test_mode = 1).
{
// for full test or first time calibration, use external capacitor
// Message C > 100nF at TP1 and TP3
cap_found = 0;
for (ww=0;ww<64;ww++) {
init_parts();
#if (TPCAP >= 0)
CalibrationCap(); // measure with internal calibration capacitor
#else
lcd_clear();
lcd_testpin(TP1);
lcd_MEM_string(CapZeich); // "-||-"
lcd_testpin(TP3);
lcd_MEM2_string(MinCap_str); // " >100nF!"
PartFound = PART_NONE;
ReadCapacity(TP3, TP1); // look for capacitor > 100nF
#endif
while (cap.cpre < -9) {
cap.cpre++;
cap.cval /= 10;
}
if ((cap.cpre == -9) && (cap.cval > 95) && (cap.cval < 22000) &&
(load_diff > -150) && (load_diff < 150)) {
cap_found++;
} else {
cap_found = 0; // wait for stable connection
}
if (cap_found > 4) {
// value of capacitor is correct
(void) eeprom_write_word((uint16_t *)(&ref_offset), load_diff); // hold zero offset + slew rate dependend offset
lcd_clear();
lcd_MEM2_string(REF_C_str); // "REF_C="
i2lcd(load_diff); // lcd_string(itoa(load_diff, outval, 10)); //output REF_C_KORR
RefVoltage(); // new ref_mv_offs and RHmultip
#if 0
//#######################################
// Test for switching level of the digital input of port TP3
for (tt=0;tt<8;tt++) {
ADC_PORT = TXD_VAL; //ADC-Port 1 to GND
ADC_DDR = 1<<TP1 | TXD_MSK; //ADC-Pin 1 to output 0V
R_PORT = 1<<PIN_RH3; //Pin 3 over R_H to VCC
R_DDR = 1<<PIN_RH3; //Pin 3 over R_H to VCC
while (1) {
wdt_reset();
if ((ADC_PIN&(1<<TP3)) == (1<<TP3)) break;
}
R_DDR = 0; //Pin 3 without current
R_PORT = 0;
adcmv[0] = ReadADC(TP3);
lcd_line3();
Display_mV(adcmv[0],4);
R_DDR = 1<<PIN_RH3; //Pin 3 over R_H to GND
while (1) {
wdt_reset();
if ((ADC_PIN&(1<<TP3)) != (1<<TP3)) break;
}
R_DDR = 0; //Pin 3 without current
lcd_line4();
adcmv[0] = ReadADC(TP3);
Display_mV(adcmv[0],4);
last_line_used = 2;
wait_for_key_5s_line2(); // wait up to 5 seconds and clear line 2
}
//#######################################
#endif
#ifdef AUTOSCALE_ADC
#if (TPCAP >= 0)
#define CAP_ADC TPCAP /* Cap >100nF is integrated at TPCAP */
TCAP_PORT &= ~(1<<TCAP_RH); // 470k resistor to GND
TCAP_DDR |= (1<<TCAP_RH); // enable output
#else
#define CAP_ADC TP3 /* Cap >100nF at TP3 */
ADC_PORT = TXD_VAL; //ADC-Port 1 to GND
ADC_DDR = 1<<TP1 | TXD_MSK; //ADC-Pin 1 to output 0V
R_DDR = 1<<PIN_RH3; //Pin 3 over R_H to GND
#endif
do {
adcmv[0] = ReadADC(CAP_ADC);
} while (adcmv[0] > 980);
#if (TPCAP >= 0)
TCAP_DDR &= ~(1<<TCAP_RH); // 470k resistor port to input mode
#else
R_DDR = 0; //all Pins to input
#endif
ADCconfig.U_Bandgap = 0; // do not use internal Ref
adcmv[0] = ReadADC(CAP_ADC); // get cap voltage with VCC reference
ADCconfig.U_Bandgap = adc_internal_reference;
adcmv[1] = ReadADC(CAP_ADC); // get cap voltage with internal reference
adcmv[1] += adcmv[1]; // double the value
ADCconfig.U_Bandgap = 0; // do not use internal Ref
adcmv[2] = ReadADC(CAP_ADC); // get cap voltage with VCC reference
ADCconfig.U_Bandgap = adc_internal_reference;
udiff = (int8_t)(((signed long)(adcmv[0] + adcmv[2] - adcmv[1])) * adc_internal_reference / adcmv[1])+REF_R_KORR;
lcd_line2();
lcd_MEM2_string(REF_R_str); // "REF_R="
udiff2 = udiff + (int8_t)eeprom_read_byte((uint8_t *)(&RefDiff));
(void) eeprom_write_byte((uint8_t *)(&RefDiff), (uint8_t)udiff2); // hold offset for true reference Voltage
i2lcd(udiff2); // output correction voltage
RefVoltage(); // set new ADCconfig.U_Bandgap
#endif /* end AUTOSCALE_ADC */
last_line_used = 2;
wait_for_key_5s_line2(); // wait up to 5 seconds and clear line 2
UnCalibrated = 0; // clear the UnCalibrated Flag
lcd_cursor_off(); // switch cursor off
cap_found = eeprom_read_byte((uint8_t *)&c_zero_tab[0]); // read first capacity zero offset
eeprom_write_byte((uint8_t *)&c_zero_tab[3], cap_found); // mark as calibrated permanent
break; // leave the ww for loop
} /* end if (cap_found > 4) */
lcd_line2();
DisplayValue(cap.cval,cap.cpre,'F',4);
lcd_refresh(); // write the pixels to display, ST7920 only
wait_about200ms(); // wait additional time
} // end for ww
} /* end if((test_mode & 0x0f) == 1) */
#endif /* end AUTO_CAL */
ADCconfig.Samples = ANZ_MESS; // set to configured number of ADC samples
#ifdef SamplingADC
sampling_lc_calibrate(); // Cap for L-meas
#endif
#ifdef FREQUENCY_50HZ
//#define TEST_SLEEP_MODE /* only select for checking the sleep delay */
lcd_clear();
lcd_MEM_string(T50HZ); //" 50Hz"
lcd_refresh(); // write the pixels to display, ST7920 only
ADC_PORT = TXD_VAL;
ADC_DDR = 1<<TP1 | TXD_MSK; // Pin 1 to GND
R_DDR = (1<<PIN_RL3) | (1<<PIN_RL2);
for(ww=0;ww<30;ww++) { // repeat the signal up to 30 times (1 minute)
for (ff50=0;ff50<100;ff50++) { // for 2 s generate 50 Hz
R_PORT = (1<<PIN_RL2); // Pin 2 over R_L to VCC, Pin 3 over R_L to GND
#ifdef TEST_SLEEP_MODE
sleep_5ms(2); // test of timing of sleep mode call
#else
wait10ms(); // normal delay
#endif
R_PORT = (1<<PIN_RL3); // Pin 3 over R_L to VCC, Pin 2 over R_L to GND
#ifdef TEST_SLEEP_MODE
sleep_5ms(2); // test of timing of sleep mode call
#else
wait10ms(); // normal delay
#endif
wdt_reset();
} /* end for ff50 */
if (!(RST_PIN_REG & (1<<RST_PIN))) {
// if key is pressed, don't repeat
break;
}
} /* end for ww */
#endif /* end FREQUENCY_50HZ */
lcd_clear();
lcd_MEM_string(VERSION_str); //"Version ..."
lcd_line2();
lcd_MEM_string(ATE); //"Selftest End"
PartFound = PART_NONE;
last_line_used = 2;
wait_for_key_5s_line2(); // wait up to 5 seconds and clear line 2
} /* end AutoCheck */
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
};
//begin of transistortester program
int main(void) {
uint8_t ii;
unsigned int max_time;
#ifdef SEARCH_PARASITIC
unsigned long n_cval; // capacitor value of NPN B-E diode, for deselecting the parasitic Transistor
int8_t n_cpre; // capacitor prefix of NPN B-E diode
#endif
#ifdef WITH_GRAPHICS
unsigned char options;
#endif
uint8_t vak_diode_nr; // number of the protection diode of BJT
union {
uint16_t pw;
uint8_t pb[2];
} rpins;
uint8_t x, y, z;
//switch on
ON_DDR = (1<<ON_PIN); // switch to output
ON_PORT = (1<<ON_PIN); // switch power on
#ifndef PULLUP_DISABLE
RST_PORT |= (1<<RST_PIN); // enable internal Pullup for Start-Pin
#endif
uint8_t tmp;
//ADC-Init
ADCSRA = (1<<ADEN) | AUTO_CLOCK_DIV; //prescaler=8 or 64 (if 8Mhz clock)
#ifdef __AVR_ATmega8__
// #define WDRF_HOME MCU_STATUS_REG
#define WDRF_HOME MCUCSR
#else
#define WDRF_HOME MCUSR
#if FLASHEND > 0x3fff
// probably was a bootloader active, disable the UART
UCSR0B = 0; // disable UART, if started with bootloader
#endif
#endif
wait500ms();
#if (PROCESSOR_TYP == 644) || (PROCESSOR_TYP == 1280)
#define BAUD_RATE 9600
// UBRR0H = (F_CPU / 16 / BAUD_RATE - 1) >> 8;
// UBRR0L = (F_CPU / 16 / BAUD_RATE - 1) & 0xff;
// UCSR0B = (1<<TXEN0);
// UCSR0C = (1<<USBS0) | (3<<UCSZ00); // 2 stop bits, 8-bit
// while (!(UCSR0A & (1<<UDRE0))) { }; // wait for send data port ready
#ifdef SWUART_INVERT
SERIAL_PORT &= ~(1<<SERIAL_BIT);
#else
SERIAL_PORT |= (1<<SERIAL_BIT);
#endif
SERIAL_DDR |= (1<<SERIAL_BIT);
#endif
tmp = (WDRF_HOME & ((1<<WDRF))); // save Watch Dog Flag
WDRF_HOME &= ~(1<<WDRF); //reset Watch Dog flag
wdt_disable(); // disable Watch Dog
#ifndef INHIBIT_SLEEP_MODE
// switch off unused Parts
#if PROCESSOR_TYP == 644
#ifdef PRUSART1
PRR0 = (1<<PRTWI) | (1<<PRSPI) | (1<<PRUSART1);
#else
PRR0 = (1<<PRTWI) | (1<<PRSPI) ;
#endif
// PRR1 = (1<<PRTIM3) ;
#elif PROCESSOR_TYP == 1280
PRR0 = (1<<PRTWI) | (1<<PRSPI) | (1<<PRUSART1);
PRR1 = (1<<PRTIM5) | (1<<PRTIM4) | (1<<PRTIM3) | (1<<PRUSART3) | (1<<PRUSART2) | (1<<PRUSART3);
#else
PRR = (1<<PRTWI) | (1<<PRSPI) | (1<<PRUSART0);
#endif
// disable digital inputs of Analog pins, but TP1-3 digital inputs must be left enabled for VGS measurement
DIDR0 = ((1<<ADC5D) | (1<<ADC4D) | (1<<ADC3D) | (1<<ADC2D) | (1<<ADC1D) | (1<<ADC0D)) & ~((1<<TP3) | (1<<TP2) | (1<<TP1));
TCCR2A = (0<<WGM21) | (0<<WGM20); // Counter 2 normal mode
TCCR2B = CNTR2_PRESCALER; //prescaler set in autoconf
#endif /* INHIBIT_SLEEP_MODE */
sei(); // enable interrupts
lcd_init(); //initialize LCD
// ADC_PORT = TXD_VAL;
// ADC_DDR = TXD_MSK;
if(tmp) {
// check if Watchdog-Event
// this happens, if the Watchdog is not reset for 2s
// can happen, if any loop in the Program doen't finish.
lcd_line1();
lcd_MEM_string(TestTimedOut); //Output Timeout
wait_about3s(); // time to read the Timeout message
switch_tester_off();
return 0;
}
#ifdef PULLUP_DISABLE
#ifdef __AVR_ATmega8__
SFIOR = (1<<PUD); // disable Pull-Up Resistors mega8
#else
MCUCR = (1<<PUD); // disable Pull-Up Resistors mega168 family
#endif
#endif
//#if POWER_OFF+0 > 1
// tester display time selection
#ifndef USE_EEPROM
EE_check_init(); // init EEprom, if unset
#endif
#ifdef WITH_ROTARY_SWITCH
// rotary_switch_present = eeprom_read_byte(&EE_RotarySwitch);
rotary.ind = ROT_MSK+1; //initilize state history with next call of check_rotary()
#endif
#ifdef WITH_HARDWARE_SERIAL
// ii = 60;
ii = 30;
#else
#if 1
for (ii=0; ii<60; ii++) {
if (RST_PIN_REG & (1 << RST_PIN))
break; // button is released
wait_about10ms();
}
#else
ii = 0;
if (!(RST_PIN_REG & (1<<RST_PIN))) {
// key is still pressed
ii = wait_for_key_ms(700);
}
#endif
display_time = OFF_WAIT_TIME; // LONG_WAIT_TIME for single mode, else SHORT_WAIT_TIME
if (ii > 30) {
display_time = LONG_WAIT_TIME; // ... set long time display anyway
}
#endif // WITH_HARDWARE_SERIAL
#if POWER_OFF+0 > 1
empty_count = 0;
mess_count = 0;
#endif
ADCconfig.RefFlag = 0;
Calibrate_UR(); // get Ref Voltages and Pin resistance
#ifdef WDT_enabled
wdt_enable(WDTO_2S); //Watchdog on
#endif
#ifdef WITH_MENU
if (ii >= 60) {
while(function_menu()); // selection of function
}
#endif
//*****************************************************************
//Entry: if start key is pressed before shut down
loop_start:
#if ((LCD_ST_TYPE == 7565) || (LCD_ST_TYPE == 1306))
lcd_command(CMD_DISPLAY_ON);
lcd_command(CMD_SET_ALLPTS_NORMAL); // 0xa4
#endif
lcd_clear(); // clear the LCD
ADC_DDR = TXD_MSK; // activate Software-UART
init_parts(); // reset parts info to nothing found
Calibrate_UR(); // get Ref Voltages and Pin resistance
lcd_line1(); // Cursor to 1. row, column 1
#ifdef BAT_CHECK
// Battery check is selected
Battery_check();
#else
lcd_MEM_string(VERSION_str); // if no Battery check, Version .. in row 1
#endif /* BAT_CHECK */
// begin tests
#if FLASHEND > 0x1fff
if (WithReference) {
/* 2.5V precision reference is checked OK */
#if POWER_OFF+0 > 1
if ((mess_count == 0) && (empty_count == 0))
#endif
{
/* display VCC= only first time */
lcd_line2();
lcd_MEM_string(VCC_str); // VCC=
Display_mV(ADCconfig.U_AVCC,3); // Display 3 Digits of this mV units
lcd_refresh(); // write the pixels to display, ST7920 only
wait_about1s(); // time to read the VCC= message
}
}
#endif
#ifdef WITH_VEXT
unsigned int Vext;
// show the external voltage
while (!(RST_PIN_REG & (1<<RST_PIN))) {
lcd_clear_line2();
lcd_MEM_string(Vext_str); // Vext=
ADC_DDR = 0; //deactivate Software-UART
Vext = W5msReadADC(TPext); // read external voltage
// ADC_DDR = TXD_MSK; //activate Software-UART
uart_newline(); // MAURO replaced uart_putc(' ') by uart_newline(), 'Z'
#if EXT_NUMERATOR <= (0xffff/U_VCC)
Display_mV(Vext*EXT_NUMERATOR/EXT_DENOMINATOR,3); // Display 3 Digits of this mV units
#else
DisplayValue((unsigned long)Vext*EXT_NUMERATOR/EXT_DENOMINATOR,-3,'V',3); // Display 3 Digits of this mV units
#endif
lcd_refresh(); // write the pixels to display, ST7920 only
wait_about300ms(); // delay to read the Vext= message
}
#endif /* WITH_VEXT */
#ifndef DebugOut
lcd_line2(); //LCD position row 2, column 1
#endif
EntladePins(); // discharge all capacitors!
if(PartFound == PART_CELL) {
lcd_clear();
lcd_MEM_string(Cell_str); // display "Cell!"
#if FLASHEND > 0x3fff
lcd_line2(); // use LCD line 2
Display_mV(cell_mv[0],3);
lcd_space();
Display_mV(cell_mv[1],3);
lcd_space();
Display_mV(cell_mv[2],3);
#endif
#ifdef WITH_SELFTEST
lcd_refresh(); // write the pixels to display, ST7920 only
wait_about2s();
AutoCheck(0x11); // full Selftest with "Short probes" message
#endif
goto tt_end;
}
#ifdef WITH_SELFTEST
#ifdef AUTO_CAL
lcd_cursor_off();
UnCalibrated = (eeprom_read_byte(&c_zero_tab[3]) - eeprom_read_byte(&c_zero_tab[0]));
if (UnCalibrated != 0) {
// if calibrated, both c_zero_tab values are identical! c_zero_tab[3] is not used otherwise
lcd_cursor_on();
}
#endif
#ifdef WITH_MENU
AutoCheck(0x00); //check, if selftest should be done, only calibration
#else
AutoCheck(0x01); //check, if selftest should be done, full selftest without MENU
#endif
#endif
#if FLASHEND > 0x1fff
lcd_clear_line2(); //LCD position row2, column 1
#else
lcd_line2(); //LCD position row2, column 1
#endif
lcd_MEM_string(TestRunning); //String: testing...
lcd_refresh(); // write the pixels to display, ST7920 only
#ifdef WITH_UART
uart_putc(0x03); // ETX, start of new measurement
uart_newline(); // MAURO Added
#endif
//
// check all 6 combinations for the 3 pins
// High Low Tri
CheckPins(TP1, TP2, TP3);
CheckPins(TP2, TP1, TP3);
CheckPins(TP1, TP3, TP2);
CheckPins(TP3, TP1, TP2);
CheckPins(TP2, TP3, TP1);
CheckPins(TP3, TP2, TP1);
// Capacity measurement is only possible correctly with two Pins connected.
// A third connected pin will increase the capacity value!
// if(((PartFound == PART_NONE) || (PartFound == PART_RESISTOR) || (PartFound == PART_DIODE)) ) {
if(PartFound == PART_NONE) {
// If no part is found yet, check separate if is is a capacitor
#ifdef DebugOut
lcd_data('C');
#endif
EntladePins(); // discharge capacities
//measurement of capacities in all 3 combinations
ReadCapacity(TP3, TP1);
#ifdef DebugOut
lcd_data('K');
#endif
#if DebugOut != 10
ReadCapacity(TP3, TP2);
#ifdef DebugOut
lcd_data('K');
#endif
ReadCapacity(TP2, TP1);
#ifdef DebugOut
lcd_data('K');
#endif
#endif
}
#ifdef WITH_UJT
// check for UJT
if (PartFound==PART_DIODE
&& NumOfDiodes==2 // UJT is detected as 2 diodes E-B1 and E-B2...
// && ResistorsFound==1 // ...and a resistor B1-B2
&& diodes.Anode[0]==diodes.Anode[1] // check diodes have common anode
// && (unsigned char)(ResistorList[0]+diodes.Anode[0])==2 // and resistor is between cathodes
)
// note: there also exist CUJTs (complementary UJTs); they seem to be (even) rarer than UJTs, and are not supported for now
{
CheckUJT();
}
#endif /* defined WITH_UJT */
#ifdef WITH_XTAL
if (PartFound==PART_NONE || ((PartFound==PART_CAPACITOR) && (cap.cpre_max == -12))) {
// still not recognized anything? then check for ceramic resonator or crystal
// these tests are time-consuming, so we do them last, and only on TP1/TP3
sampling_test_xtal();
}
#endif
//All checks are done, output result to display
#ifdef DebugOut
// only clear two lines of LCD
lcd_clear_line1();
#else
lcd_clear(); // clear total display
#endif
_trans = &ntrans; // default transistor structure to show
if (PartFound == PART_THYRISTOR) {
#ifdef WITH_GRAPHICS
lcd_big_icon(THYRISTOR|LCD_UPPER_LEFT);
lcd_draw_trans_pins(-8, 16);
lcd_set_cursor(0,TEXT_RIGHT_TO_ICON); // position behind the icon, Line 1
lcd_MEM_string(Thyristor); //"Thyristor"
#else
lcd_MEM_string(Thyristor); //"Thyristor"
PinLayout(Cathode_char,'G','A'); // CGA= or 123=...
#endif
goto TyUfAusgabe;
}
if (PartFound == PART_TRIAC) {
#ifdef WITH_GRAPHICS
lcd_big_icon(TRIAC|LCD_UPPER_LEFT);
lcd_draw_trans_pins(-8, 16);
lcd_set_cursor(0,TEXT_RIGHT_TO_ICON); // position behind the icon, Line 1
lcd_MEM_string(Triac); //"Triac"
#else
lcd_MEM_string(Triac); //"Triac"
PinLayout('1','G','2'); // CGA= or 123=...
#endif
goto TyUfAusgabe;
}
#ifdef WITH_PUT
if (PartFound == PART_PUT) {
static const unsigned char PUT_str[] MEM_TEXT = "PUT";
lcd_MEM_string(PUT_str);
_trans=&ptrans;
PinLayout('A','G',Cathode_char);
goto TyUfAusgabe;
}
#endif
#ifdef WITH_UJT
if (PartFound == PART_UJT) {
static const unsigned char UJT_str[] MEM_TEXT = "UJT";
lcd_MEM_string(UJT_str);
PinLayout('1','E','2');
#ifdef SamplingADC
static const unsigned char eta_str[] MEM_TEXT = " eta=";
lcd_next_line(0);
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]
DisplayValue(ResistorVal[ntrans.e - TP_MIN + ntrans.c - TP_MIN - 1],-1,LCD_CHAR_OMEGA,2);
lcd_MEM_string(eta_str); //"eta="
DisplayValue(ntrans.gthvoltage,0,'%',3);
#else /* ! SamplingADC */
static const unsigned char R12_str[] MEM_TEXT = "R12=";
lcd_next_line(0);
lcd_MEM_string(R12_str); //"R12="
DisplayValue(ResistorVal[ntrans.e - TP_MIN + ntrans.c - TP_MIN - 1],-1,LCD_CHAR_OMEGA,2);
lcd_data(',');
DisplayValue(((RR680PL * (unsigned long)(ADCconfig.U_AVCC - ntrans.uBE)) / ntrans.uBE)-RRpinPL,-1,LCD_CHAR_OMEGA,3);
#endif /* SamplingADC */
goto tt_end;
}
#endif /* WITH_UJT */
if (PartFound == PART_CAPACITOR) {
#if FLASHEND > 0x3fff
if ((cap.ca + cap.cb) == (TP1 + TP3)) {
show_Cap13(); // repeated capacity measurement
goto shut_off; // key was pressed or timeout
}
show_cap(0); // show capacity in normal way and measure additional parameters
#else
show_cap_simple(); // show capacity in normal way and measure additional parameters
#endif
goto tt_end;
} /* end PartFound == PART_CAPACITOR */
#ifdef WITH_XTAL
if (PartFound == PART_CERAMICRESONATOR) {
// static const unsigned char cerres_str[] MEM_TEXT = "Cer.resonator ";
lcd_MEM_string(cerres_str);
if (sampling_measure_xtal()) goto loop_start;
goto tt_end;
}
if (PartFound == PART_XTAL) {
// static const unsigned char xtal_str[] MEM_TEXT = "Crystal ";
lcd_MEM_string(xtal_str);
if (sampling_measure_xtal()) goto loop_start;
goto tt_end;
}
#endif
// ========================================
if(PartFound == PART_DIODE) {
// ========================================
if(NumOfDiodes == 1) { //single Diode
// lcd_MEM_string(Diode); //"Diode: "
#if FLASHEND > 0x1fff
// enough memory (>8k) to sort the pins and additional Ir=
DiodeSymbol_withPins(0);
GetIr(diodes.Cathode[0],diodes.Anode[0]); // measure and output Ir=x.xuA
#else
// too less memory to sort the pins
DiodeSymbol_withPins(0);
#endif
UfAusgabe(0x70); // mark for additional resistor and output Uf= in line 2
#ifndef SamplingADC
/* load current of capacity is (5V-1.1V)/(470000 Ohm) = 8298nA */
ReadCapacity(diodes.Cathode[0],diodes.Anode[0]); // Capacity opposite flow direction
if (cap.cpre < -3) { /* capacity is measured */
#if (LCD_LINES > 2)
lcd_line3(); // output Capacity in line 3
#endif
lcd_MEM_string(Cap_str); //"C="
#if LCD_LINE_LENGTH > 16
DisplayValue(cap.cval,cap.cpre,'F',3);
#else
DisplayValue(cap.cval,cap.cpre,'F',2);
#endif
}
#else // SamplingADC
showdiodecap:
cap.cval=sampling_cap(diodes.Cathode[0],diodes.Anode[0],0); // at low voltage
lcd_next_line_wait(0); // next line, wait 5s and clear line 2
DisplayValue(cap.cval,sampling_cap_pre,'F',2);
#ifdef PULLUP_DISABLE
lcd_data('-');
cap.cval=sampling_cap(diodes.Cathode[0],diodes.Anode[0],1); // at high voltage
if (cap.cval < 0) cap.cval = 0; // don't show negativ value
DisplayValue(cap.cval,sampling_cap_pre,'F',2);
#if LCD_LINE_LENGTH > 16
lcd_MEM_string(AT05volt); // " @0-5V"
#else
lcd_MEM_string(AT05volt+1); // "@0-5V"
#endif
uart_newline(); // MAURO Diode ('A')
#else
#warning Capacity measurement from high to low not possible for diodes without PULLUP_DISABLE option!
#endif /* PULLUP_DISABLE */
#endif
goto end3;
} else if(NumOfDiodes == 2) { // double diode
lcd_data('2');
lcd_MEM_string(Dioden); //"diodes "
if(diodes.Anode[0] == diodes.Anode[1]) { //Common Anode
DiodeSymbol_CpinApin(0); // 1-|<-2
DiodeSymbol_ACpin(1); // ->|-3
UfAusgabe(0x01);
#ifdef SamplingADC
goto showdiodecap; // double diodes are often varicap; measure capacitance of one of them
#else
goto end3;
#endif
}
if(diodes.Cathode[0] == diodes.Cathode[1]) { //Common Cathode
DiodeSymbol_ApinCpin(0); // 1->|-2
DiodeSymbol_CApin(1); // -|<-3
UfAusgabe(0x01);
#ifdef SamplingADC
goto showdiodecap; // double diodes are often varicap; measure capacitance of one of them
#else
goto end3;
#endif
// else if ((diodes.Cathode[0] == diodes.Anode[1]) && (diodes.Cathode[1] == diodes.Anode[0]))
}
if (diodes.Cathode[0] == diodes.Anode[1]) {
// normaly two serial diodes are detected as three diodes, but if the threshold is high
// for both diodes, the third diode is not detected.
// can also be Antiparallel
diode_sequence = 0x01; // 0 1
SerienDiodenAusgabe();
goto end3;
}
if (diodes.Cathode[1] == diodes.Anode[0]) {
diode_sequence = 0x10; // 1 0
SerienDiodenAusgabe();
goto end3;
}
} else if(NumOfDiodes == 3) {
//Serial of 2 Diodes; was detected as 3 Diodes
diode_sequence = 0x33; // 3 3
/* Check for any constellation of 2 serial diodes:
Only once the pin No of anyone Cathode is identical of another anode.
two diodes in series is additionally detected as third big diode.
*/
if (diodes.Cathode[0] == diodes.Anode[1]) {
diode_sequence = 0x01; // 0 1
}
if (diodes.Anode[0] == diodes.Cathode[1]) {
diode_sequence = 0x10; // 1 0
}
if (diodes.Cathode[0] == diodes.Anode[2]) {
diode_sequence = 0x02; // 0 2
}
if (diodes.Anode[0] == diodes.Cathode[2]) {
diode_sequence = 0x20; // 2 0
}
if (diodes.Cathode[1] == diodes.Anode[2]) {
diode_sequence = 0x12; // 1 2
}
if (diodes.Anode[1] == diodes.Cathode[2]) {
diode_sequence = 0x21; // 2 1
}
// if((ptrans.b<3) && (ptrans.c<3))
if(diode_sequence < 0x22) {
lcd_data('3');
lcd_MEM_string(Dioden); //"Diodes "
SerienDiodenAusgabe();
goto end3;
}
} // end (NumOfDiodes == 3)
lcd_MEM_string(Bauteil); //"Bauteil"
lcd_MEM_string(Unknown); //" unbek."
lcd_line2(); //2. row
lcd_data(NumOfDiodes + '0');
lcd_data('*');
lcd_MEM_string(AnKat_str); //"->|-"
lcd_MEM_string(Detected); //" detected"
goto not_known;
// end (PartFound == PART_DIODE)
// ========================================
} else if (PartFound == PART_TRANSISTOR) {
// ========================================
#ifdef SEARCH_PARASITIC
if ((ptrans.count != 0) && (ntrans.count !=0)) {
// Special Handling of NPNp and PNPn Transistor.
// If a protection diode is built on the same structur as the NPN-Transistor,
// a parasitic PNP-Transistor will be detected.
ReadCapacity(ntrans.e, ntrans.b); // read capacity of NPN base-emitter
n_cval = cap.cval; // save the found capacity value
n_cpre = cap.cpre; // and dimension
ReadCapacity(ptrans.b, ptrans.e); // read capacity of PNP base-emitter
// check if one hfe is very low. If yes, simulate a very low BE capacity
if ((ntrans.hfe < 500) && (ptrans.hfe >= 500)) n_cpre = -16; // set NPN BE capacity to low value
if ((ptrans.hfe < 500) && (ntrans.hfe >= 500)) cap.cpre = -16; // set PNP BE capacity to low value
if (((n_cpre == cap.cpre) && (cap.cval > n_cval))
|| (cap.cpre > n_cpre)) {
// the capacity value or dimension of the PNP B-E is greater than the NPN B-E
PartMode = PART_MODE_PNP;
} else {
PartMode = PART_MODE_NPN;
}
} /* end ((ptrans.count != 0) && (ntrans.count !=0)) */
#endif
// not possible for mega8, change Pin sequence instead.
if ((ptrans.count != 0) && (ntrans.count != 0)
&& (!(RST_PIN_REG & (1 << RST_PIN)))) {
// if the Start key is still pressed, use the other Transistor
#if 0
if (PartMode == PART_MODE_NPN) {
PartMode = PART_MODE_PNP; // switch to parasitic transistor
} else {
PartMode = PART_MODE_NPN; // switch to parasitic transistor
}
#else
PartMode ^= (PART_MODE_PNP - PART_MODE_NPN);
#endif
}
#ifdef WITH_GRAPHICS
lcd_set_cursor(0,TEXT_RIGHT_TO_ICON); // position behind the icon, Line 1
lcd_big_icon(BJT_NPN|LCD_UPPER_LEFT); // show the NPN Icon at lower left corner
if(PartMode == PART_MODE_NPN) {
// _trans = &ntrans; is allready selected a default
lcd_MEM_string(NPN_str); //"NPN "
if (ptrans.count != 0) {
lcd_data('p'); // mark for parasitic PNp
}
} else {
_trans = &ptrans; // change transistor structure
lcd_update_icon(bmp_pnp); // update for PNP
lcd_MEM_string(PNP_str); //"PNP "
if (ntrans.count != 0) {
lcd_data('n'); // mark for parasitic NPn
}
}
#else /* only character display */
if(PartMode == PART_MODE_NPN) {
// _trans = &ntrans; is allready selected a default
lcd_MEM_string(NPN_str); //"NPN "
if (ptrans.count != 0) {
lcd_data('p'); // mark for parasitic PNp
}
} else {
_trans = &ptrans; // change transistor structure
lcd_MEM_string(PNP_str); //"PNP "
if (ntrans.count != 0) {
lcd_data('n'); // mark for parasitic NPn
}
}
lcd_space();
#endif
// show the protection diode of the BJT
vak_diode_nr = search_vak_diode();
if (vak_diode_nr < 5) {
// no side of the diode is connected to the base, this must be the protection diode
#ifdef WITH_GRAPHICS
options = 0;
if (_trans->c != diodes.Anode[vak_diode_nr])
options |= OPT_VREVERSE;
lcd_update_icon_opt(bmp_vakdiode,options); // show the protection diode right to the Icon
#else /* only character display, show the diode in correct direction */
char an_cat; // diode is anode-cathode type
an_cat = 0;
#ifdef EBC_STYLE
#if EBC_STYLE == 321
// Layout with 321= style
an_cat = (((PartMode == PART_MODE_NPN) && (ntrans.c < ntrans.e)) ||
((PartMode != PART_MODE_NPN) && (ptrans.c > ptrans.e)));
#else
// Layout with EBC= style
an_cat = (PartMode == PART_MODE_NPN);
#endif
#else
// Layout with 123= style
an_cat = (((PartMode == PART_MODE_NPN) && (ntrans.c > ntrans.e))
|| ((PartMode != PART_MODE_NPN) && (ptrans.c < ptrans.e)));
#endif
if (an_cat) {
lcd_MEM_string(AnKat_str); //"->|-"
} else {
lcd_MEM_string(KatAn_str); //"-|<-"
}
#endif /* !WITH_GRAPHICS */
} /* endif vak_diode_nr < 6 */
#ifdef WITH_GRAPHICS
lcd_draw_trans_pins(-7, 16); // show the pin numbers
lcd_next_line(TEXT_RIGHT_TO_ICON); // position behind the icon, Line 2
lcd_MEM_string(hfe_str); //"B=" (hFE)
DisplayValue(_trans->hfe,-2,0,3);
lcd_next_line(TEXT_RIGHT_TO_ICON+1-LOW_H_SPACE); // position behind the icon+1, Line 3
lcd_data('I');
if (_trans->current >= 10000) {
lcd_data('e'); // emitter current has 10mA offset
_trans->current -= 10000;
} else {
lcd_data('c');
}
lcd_equal(); // lcd_data('=');
DisplayValue16(_trans->current,-6,'A',2); // display Ic or Ie current
lcd_next_line(TEXT_RIGHT_TO_ICON); // position behind the icon, Line 4
lcd_MEM_string(Ube_str); //"Ube="
Display_mV(_trans->uBE,3-LOW_H_SPACE);
last_line_used = 1;
#ifdef SHOW_ICE
if (_trans->ice0 > 0) {
lcd_next_line_wait(TEXT_RIGHT_TO_ICON-1-LOW_H_SPACE); // position behind the icon, Line 4 & wait and clear last line
lcd_MEM2_string(ICE0_str); // "ICE0="
DisplayValue16(_trans->ice0,-6,'A',2); // display ICEO
}
if (_trans->ices > 0) {
lcd_next_line_wait(TEXT_RIGHT_TO_ICON-1-LOW_H_SPACE); // position behind the icon, Line 4 & wait and clear last line
lcd_MEM2_string(ICEs_str); // "ICEs="
DisplayValue16(_trans->ices,-6,'A',2); // display ICEs
}
#endif
#else /* character display */
PinLayout('E','B','C'); // EBC= or 123=...
lcd_line2(); //2. row
lcd_MEM_string(hfe_str); //"B=" (hFE)
DisplayValue(_trans->hfe,-2,0,3);
#if FLASHEND > 0x1fff
lcd_space();
lcd_data('I');
if (_trans->current >= 10000) {
lcd_data('e'); // emitter current has 10mA offset
_trans->current -= 10000;
} else {
lcd_data('c');
}
lcd_equal(); // lcd_data('=');
DisplayValue16(_trans->current,-6,'A',2); // display Ic or Ie current
#endif
#if defined(SHOW_ICE)
lcd_next_line_wait(0); // next line, wait 5s and clear line 2
lcd_MEM_string(Ube_str); //"Ube="
Display_mV(_trans->uBE,3);
if (_trans->ice0 > 0) {
lcd_next_line_wait(0); // next line, wait 5s and clear line 2
lcd_MEM2_string(ICE0_str); // "ICE0="
DisplayValue16(_trans->ice0,-6,'A',3);
}
if (_trans->ices > 0) {
lcd_next_line_wait(0); // next line, wait 5s and clear line 2
lcd_MEM2_string(ICEs_str); // "ICEs="
DisplayValue16(_trans->ices,-6,'A',3);
}
#endif
#endif /* WITH_GRAPHICS */
#ifdef SHOW_VAKDIODE
if (vak_diode_nr < 5) {
lcd_next_line_wait(0); // next line, wait 5s and clear line 2/4
DiodeSymbol_withPins(vak_diode_nr);
lcd_MEM_string(Uf_str); //"Uf="
mVAusgabe(vak_diode_nr);
uart_newline(); // MAURO not verified ('D')
} /* end if (vak_diode_nr < 5) */
#endif
#ifdef WITH_GRAPHICS
PinLayoutLine('E','B','C'); // Pin 1=E ...
uart_newline(); // MAURO OK BJT ('E')
#endif
goto tt_end;
// end (PartFound == PART_TRANSISTOR)
// ========================================
} else if (PartFound == PART_FET) { /* JFET or MOSFET */
// ========================================
#ifdef WITH_GRAPHICS
unsigned char fetidx = 0;
lcd_set_cursor(0,TEXT_RIGHT_TO_ICON); // position behind the icon, Line 1
#endif
if((PartMode&P_CHANNEL) == P_CHANNEL) {
lcd_data('P'); //P-channel
_trans = &ptrans;
#ifdef WITH_GRAPHICS
fetidx = 2;
#endif
} else {
lcd_data('N'); //N-channel
// _trans = &ntrans; is allready selected as default
}
lcd_data('-'); // minus is used for JFET, D-MOS, E-MOS ...
uint8_t part_code;
part_code = PartMode&0x0f;
#ifdef WITH_GRAPHICS
if (part_code == PART_MODE_JFET) {
lcd_MEM_string(jfet_str); //"JFET"
lcd_big_icon(N_JFET|LCD_UPPER_LEFT);
if (fetidx != 0) {
lcd_update_icon(bmp_p_jfet); // update the n_jfet bitmap to p_jfet
}
} else { // no JFET
if ((PartMode&D_MODE) == D_MODE) {
lcd_data('D'); // N-D or P-D
fetidx += 1;
} else {
lcd_data('E'); // N-E or P-E
}
if (part_code == (PART_MODE_IGBT)) {
lcd_MEM_string(igbt_str); //"-IGBT"
lcd_big_icon(N_E_IGBT|LCD_UPPER_LEFT);
if (fetidx == 1) lcd_update_icon(bmp_n_d_igbt);
if (fetidx == 2) lcd_update_icon(bmp_p_e_igbt);
if (fetidx == 3) lcd_update_icon(bmp_p_d_igbt);
} else {
lcd_MEM_string(mosfet_str); //"-MOS "
lcd_big_icon(N_E_MOS|LCD_UPPER_LEFT);
if (fetidx == 1) lcd_update_icon(bmp_n_d_mos);
if (fetidx == 2) lcd_update_icon(bmp_p_e_mos);
if (fetidx == 3) lcd_update_icon(bmp_p_d_mos);
}
} /* end PART_MODE_JFET */
#else /* normal character display */
if (part_code == PART_MODE_JFET) {
lcd_MEM_string(jfet_str); //"-JFET"
} else { // no JFET
if ((PartMode&D_MODE) == D_MODE) {
lcd_data('D'); // N-D or P-D
} else {
lcd_data('E'); // N-E or P-E
}
if (part_code == (PART_MODE_IGBT)) {
lcd_MEM_string(igbt_str); //"-IGBT"
} else {
lcd_MEM_string(mosfet_str); //"-MOS "
}
} /* end PART_MODE_JFET */
if (part_code == PART_MODE_IGBT) {
PinLayout('E','G','C'); // SGD= or 123=...
} else if (part_code == PART_MODE_JFET) {
PinLayout('?','G','?'); // ?G?= or 123=...
} else {
PinLayout('S','G','D'); // SGD= or 123=...
}
#endif /* WITH_GRAPHICS */
vak_diode_nr = search_vak_diode();
if(vak_diode_nr < 5) {
//MOSFET with protection diode; only with enhancement-FETs
#ifndef WITH_GRAPHICS
#if FLASHEND <= 0x1fff
char an_cat; // diode is anode-cathode type
an_cat = 0;
#ifdef EBC_STYLE
#if EBC_STYLE == 321
// layout with 321= style
an_cat = (((PartMode&P_CHANNEL) && (ptrans.c > ptrans.e)) || ((!(PartMode&P_CHANNEL)) && (ntrans.c < ntrans.e)));
#else
// Layout with SGD= style
an_cat = (PartMode&P_CHANNEL); /* N or P MOS */
#endif
#else /* EBC_STYLE not defined */
// layout with 123= style
an_cat = (((PartMode & P_CHANNEL) && (ptrans.c < ptrans.e))
|| ((!(PartMode & P_CHANNEL)) && (ntrans.c > ntrans.e)));
#endif /* end ifdef EBC_STYLE */
// show diode symbol in right direction (short form for less flash memory)
if (an_cat) {
lcd_data(LCD_CHAR_DIODE1); //show Diode symbol >|
} else {
lcd_data(LCD_CHAR_DIODE2); //show Diode symbol |<
}
#endif
#endif /* not WITH_GRAPHICS */
#ifdef WITH_GRAPHICS
options = 0;
if (_trans->c != diodes.Anode[vak_diode_nr])
options |= OPT_VREVERSE;
lcd_update_icon_opt(bmp_vakdiode,options); // update Icon with protection diode
#endif
} /* end if NumOfDiodes == 1 */
#ifdef WITH_GRAPHICS
lcd_draw_trans_pins(-7, 16); // update of pin numbers must be done after diode update
lcd_next_line(TEXT_RIGHT_TO_ICON); // position text behind the icon, Line 2
#if LCD_LINES > 6
lcd_next_line(TEXT_RIGHT_TO_ICON); // double line
#endif
if((PartMode&D_MODE) != D_MODE) { //enhancement-MOSFET
lcd_MEM_string(vt_str+1); // "Vt="
Display_mV(_trans->gthvoltage,2); //Gate-threshold voltage
//Gate capacity
ReadCapacity(_trans->b,_trans->e); //measure capacity
lcd_next_line(TEXT_RIGHT_TO_ICON); // position text behind the icon, Line 3
lcd_show_Cg(); // show Cg=xxxpF
#ifdef SHOW_R_DS
lcd_show_rds(TEXT_RIGHT_TO_ICON-1); // show RDS at column behind the icon -1
#endif
} else { /* depletion mode */
if ((PartMode&0x0f) != PART_MODE_JFET) { /* kein JFET */
ReadCapacity(_trans->b,_trans->e); //measure capacity
lcd_show_Cg(); // show Cg=xxxpF
#ifdef FET_Idss
} else { // it is a JFET
// display the I_DSS, if measured
if (_trans->uBE!=0) {
static const unsigned char str_Idss[] MEM_TEXT = "Idss=";
lcd_MEM_string(str_Idss);
DisplayValue16(_trans->uBE,-6,'A',2);
}
#endif
}
// set cursor below the icon
#define LINE_BELOW_ICON ((ICON_HEIGHT/8)/((FONT_HEIGHT+7)/8))
#if LCD_LINES > 6
lcd_set_cursor((LINE_BELOW_ICON + 1) * PAGES_PER_LINE,0);
#else
lcd_set_cursor(LINE_BELOW_ICON * PAGES_PER_LINE,0);
#endif
lcd_data('I');
#if (LCD_LINE_LENGTH > 17)
lcd_data('d');
#endif
lcd_equal(); // lcd_data('=');
DisplayValue16(_trans->current,-6,'A',2);
lcd_MEM_string(Vgs_str); // "@Vg="
Display_mV(_trans->gthvoltage,2); //Gate-threshold voltage
#ifdef SHOW_ICE
// Display also the cutoff gate voltage, idea from Pieter-Tjerk
if (_trans->ice0<4800) { // can't trust cutoff voltage if close to 5V supply voltage, since then the transistor may not have been cut off at all
lcd_next_line_wait(0);
lcd_data('I');
#if (LCD_LINE_LENGTH > 17)
lcd_data('d');
#endif
lcd_equal(); // lcd_data('=');
DisplayValue16(0,-5,'A',2);
lcd_MEM_string(Vgs_str); // "@Vg="
Display_mV(_trans->ice0,2); // cutoff Gate voltage
#endif
}
#ifdef SHOW_R_DS
lcd_show_rds(0); // show Drain-Source resistance RDS at column 0
#endif
} /* end of enhancement or depletion mode WITH_GRAPHICS */
#else /* character display */
if((PartMode&D_MODE) != D_MODE) { //enhancement-MOSFET
//Gate capacity
lcd_line2(); // line 2
ReadCapacity(_trans->b,_trans->e); //measure capacity
lcd_show_Cg(); // show Cg=xxxpF
lcd_MEM_string(vt_str); // " Vt="
Display_mV(_trans->gthvoltage,2); //Gate-threshold voltage
#ifdef SHOW_R_DS
lcd_show_rds(0); // show Drain-Source resistance RDS at column 0
#endif
} else {
// depletion
#if FLASHEND > 0x1fff
if ((PartMode&0x0f) != PART_MODE_JFET) { /* kein JFET */
lcd_next_line(0); // line 2
ReadCapacity(_trans->b,_trans->e); //measure capacity
lcd_show_Cg(); // show Cg=xxxpF
#ifdef FET_Idss
} else { // it is a JFET
// display the I_DSS, if measured
if (_trans->uBE!=0) {
lcd_next_line(0);
static const unsigned char str_Idss[] MEM_TEXT = "Idss=";
lcd_MEM_string(str_Idss);
DisplayValue16(_trans->uBE,-6,'A',2);
}
#endif
}
lcd_next_line_wait(0); // line 2 or 3, if possible & wait and clear last line
#endif
lcd_data('I'); // show I=xmA@Vg=y.yV at line 2 or 3
#if (LCD_LINE_LENGTH > 17)
lcd_data('d');
#endif
lcd_equal(); // lcd_data('=');
DisplayValue16(_trans->current,-6,'A',2);
lcd_MEM_string(Vgs_str); // "@Vg="
Display_mV(_trans->gthvoltage,2); //Gate-threshold voltage
#ifdef SHOW_ICE
// Display also the cutoff gate voltage, idea from Pieter-Tjerk
if (_trans->ice0<4800) { // can't trust cutoff voltage if close to 5V supply voltage, since then the transistor may not have been cut off at all
lcd_next_line_wait(0);
lcd_data('I');
#if (LCD_LINE_LENGTH > 17)
lcd_data('d');
#endif
lcd_equal(); // lcd_data('=');
DisplayValue16(0,-5,'A',2);
lcd_MEM_string(Vgs_str); // "@Vg="
Display_mV(_trans->ice0,2); // cutoff Gate voltage
}
#endif
#ifdef SHOW_R_DS
lcd_show_rds(0); // show Drain-Source resistance RDS at column 0
#endif
} /* end of enhancement or depletion mode */
/* *************************************************** */
void make_frequency() {
#define MAX_FREQ_NR 19
uint8_t key_pressed;
uint8_t freq_nr;
uint8_t old_freq;
message_key_released(F_GEN_str); // display f-Generator and wait for key released
// OC1B is connected with 680 Ohm resistor to TP2 (middle test pin)
TCCR1A = (0<<COM1B1) | (1<<COM1B0) | (0<<WGM11) | (0<<WGM10); // CTC mode, count to OCR1A
TIMSK1 = 0; // no interrupt used
OCR1A = 1; // highest frequency
OCR1B = 0; // toggle OC1B at this count
TIFR1 = (1<<OCF1A) | (1<<OCF1A) | (1<<TOV1); // reset interrupt flags
TCCR1C = 0;
TCCR1B = (0<<WGM13) | (1<<WGM12) | (0<<CS12) | (0<<CS11) | (0<<CS10); // set counter mode
R_PORT = 0; // set all resistor port outputs to GND
#if PROCESSOR_TYP == 644
R_DDR = (1<<PIN_RL1) | (1<<PIN_RL2) | (1<<PIN_RL3); // set TP1, DDD4(TP2) and TP3 to output
#else
R_DDR = (1<<PIN_RL1) | (1<<PIN_RL3); // set TP1 and TP3 to output
#endif
ADC_PORT = TXD_VAL;
ADC_DDR = (1<<TP1) | TXD_MSK; //connect TP1 to GND
DDRB |= (1<<DDB2); // set output enable
TCCR1B = (0<<WGM13) | (1<<WGM12) | (0<<CS12) | (0<<CS11) | (1<<CS10); // no clock divide
old_freq = 0;
freq_nr = MAX_FREQ_NR - 1; // start with 1 MHz
#ifdef POWER_OFF
uint8_t new_points; // one point for every 30 seconds wait time
uint8_t shown_points; // one point for every 30 seconds wait time
uint8_t times; // total wait time
shown_points = 0;
for (times=0; times<240; times++)
#else
while (1) /* wait endless without option POWER_OFF */
#endif
{
#define KEYPRESS_LENGTH_10ms 0
#ifdef POWER_OFF
new_points = (times+10) / 30;
if (new_points != shown_points) {
// count of points has changed, build LCD line1 new
lcd_line1();
lcd_clear_line(); // clear line 1
lcd_line1();
lcd_MEM2_string(F_GEN_str); // display f-Generator
shown_points = new_points;
for (new_points=0; new_points<shown_points ;new_points++) {
lcd_data('.'); // show elapsed time, one point is 30 seconds
}
}
#undef KEYPRESS_LENGTH_10ms
#define KEYPRESS_LENGTH_10ms 20 /* change frequency only with >200ms key press */
#endif
if (old_freq != freq_nr) {
// new frequency is selected
if (freq_nr > MAX_FREQ_NR) freq_nr -= (MAX_FREQ_NR + 1);
old_freq = freq_nr; // update the last active frequency number
#ifdef FOUR_LINE_LCD
lcd_line2();
lcd_clear_line(); // clear line 2 for previous frequency
lcd_line2();
lcd_space(); // add a space to row 1 of line2
switch_frequency(freq_nr + MAX_FREQ_NR);
lcd_line4();
lcd_clear_line(); // clear line 4 for next frequency
lcd_line4();
lcd_space(); // add a space to row 1 of line4
switch_frequency(freq_nr + 1);
lcd_line3();
lcd_clear_line(); // clear line 3 for new frequency
lcd_line3();
lcd_data('>');
switch_frequency(freq_nr);
#else
lcd_line2();
lcd_clear_line(); // clear line 2 for next frequency
lcd_line2();
switch_frequency(freq_nr);
#endif
} /* end if (old_freq != freq_nr) */
key_pressed = wait_for_key_ms(1000);
#ifdef POWER_OFF
#ifdef WITH_ROTARY_SWITCH
if ((key_pressed != 0) || (rotary.incre > 0)) times = 0; // reset counter, operator is active
#else
if (key_pressed != 0) times = 0; // reset counter, operator is active
#endif
#endif
#ifdef WITH_ROTARY_SWITCH
if (rotary.incre > FAST_ROTATION) break; // fast rotation ends voltage measurement
if (rotary.count >= 0) {
freq_nr += rotary.count; // increase the frequency number by rotary.count
} else {
freq_nr += (MAX_FREQ_NR + 1 + rotary.count); // decrease the frequency by rotary.count
}
#endif
if (key_pressed > KEYPRESS_LENGTH_10ms) freq_nr++; // longer key press select next frequency
if(key_pressed >= 80) break; // more than 0.8 seconds
} /* end for times */
TCCR1B = 0; // stop counter
TCCR1A = 0; // stop counter
ADC_DDR = TXD_MSK; // disconnect TP1
R_DDR = 0; // switch resistor ports to Input
DDRB &= ~(1<<DDB2); // disable output
} /* end make frequency */
uint8_t function_menu() {
uint8_t ii;
uint8_t func_number;
#ifdef PAGE_MODE
uint8_t page_nr;
uint8_t p_nr;
uint8_t ff;
page_nr = MODE_LAST;
#ifdef WITH_ROTARY_SWITCH
rotary.count = 0;
#endif
#endif
func_number = 0;
message_key_released(SELECTION_str);
#ifdef POWER_OFF
uint8_t ll;
for (ll=0;ll<((MODE_LAST+1)*10);ll++)
#else
while (1) /* without end, if no power off specified */
#endif
{
if (func_number > MODE_LAST) func_number -= (MODE_LAST + 1);
#if (LCD_LINES > 3)
uint8_t mm;
#ifdef WITH_HARDWARE_SERIAL
uart_newline(); // start of new measurement
for (mm=0;mm<LCD_LINE_LENGTH;mm++) uart_putc('=');
message_key_released(SELECTION_str); //write Line 1 with Selection:
#endif
#ifdef PAGE_MODE
ff = 0;
mm = 0;
do {
p_nr = page_nr + mm;
if (p_nr > MODE_LAST) p_nr -= (MODE_LAST + 1);
if (func_number == p_nr) ff = 1; // number is found
} while (++mm < MENU_LINES);
if (ff == 0) {
// func_number is not in page list
#ifdef WITH_ROTARY_SWITCH
if (rotary.count >= 0) {
page_nr = (func_number + MODE_LAST -1); // page_nr = func_number - 2
} else {
page_nr = func_number; // for backward, set page_nr to func_number
}
if (page_nr > MODE_LAST) page_nr -= (MODE_LAST + 1);
#else
page_nr = func_number;
#endif
}
mm= 0;
do {
p_nr = page_nr + mm;
if (p_nr > MODE_LAST) p_nr -= (MODE_LAST + 1);
lcd_set_cursor((mm+1)*PAGES_PER_LINE,0);
if (func_number == p_nr) {
lcd_data('>');
} else {
lcd_space(); // put a blank to 1. row of line 2
}
message2line(p_nr); // show page function
} while (++mm < MENU_LINES);
#else /* no PAGE_MODE */
uint8_t f_nr;
mm = 0;
do {
lcd_set_cursor((mm+1)*PAGES_PER_LINE,0);
if (mm == MENU_MIDDLE) {
lcd_data('>'); // put a '>' marker to row 1 of line 4
} else {
lcd_space(); // put a blank to 1. row of line 2
}
f_nr = func_number + MODE_LAST + 1 - MENU_MIDDLE + mm;
if (f_nr > MODE_LAST) f_nr -= (MODE_LAST +1);
message2line(f_nr); // show function for this line
} while (++mm < MENU_LINES);
#endif /* PAGE_MODE */
#else /* not LCD_LINES > 3 */
lcd_line2();
message2line(func_number);
#endif /* (LCD_LINES > 3) */
#ifdef POWER_OFF
ii = wait_for_key_ms(SHORT_WAIT_TIME); // wait about 5 seconds
if (ii > 0) ll = 0; // reset timer, operator present
if (DC_Pwr_mode == 1) ll = 0;
#else
ii = wait_for_key_ms(0); // wait endless
#endif
#ifdef WITH_ROTARY_SWITCH
if ((ii >= MIN_SELECT_TIME) || ((rotary_switch_present != 0) && (ii > 0)))
#else
if (ii >= MIN_SELECT_TIME)
#endif
{
// selection only with key-press
if (func_number == MODE_TRANS) return 0; // return to TransistorTester
do_menu(func_number);
// don't increase function number for easier selection the same function
ii = 0; // function was executed before, do not increase func_number
#ifdef WITH_ROTARY_SWITCH
rotary.incre = 0; // reset all rotary information
rotary.count = 0;
#endif
message_key_released(SELECTION_str); //write Line 1 with Selection:
} /* end if (ii >= MIN_SELECT_TIME) */
#ifdef WITH_ROTARY_SWITCH
if (rotary.incre >= FAST_ROTATION) break; // to much rotation
#ifdef POWER_OFF
if (rotary.count != 0) ll = 0; // someone is working, reset timer
#endif
if (rotary.count >= 0) {
func_number += rotary.count; // function number is increased by rotary steps
} else {
func_number += (MODE_LAST + 1 + rotary.count); // function is decreased by rotary steps
}
#endif
if (ii > 0) func_number++; // increase the function number with key press
} /* end for ll */
return 0;
} // end function_menu()
/* ****************************************************************** */
void function_menu() {
uint8_t ii;
uint8_t func_number;
#ifdef PAGE_MODE
uint8_t page_nr;
uint8_t p_nr;
uint8_t ff;
page_nr = MODE_LAST;
#ifdef WITH_ROTARY_SWITCH
rotary.count = 0;
#endif
#endif
func_number = 0;
#ifdef POWER_OFF
uint8_t ll;
for (ll=0;ll<((MODE_LAST+1)*10);ll++)
#else
while (1) /* without end, if no power off specified */
#endif
{
if (func_number > MODE_LAST) func_number -= (MODE_LAST + 1);
message_key_released(SELECTION_str);
#ifdef FOUR_LINE_LCD
#ifdef PAGE_MODE
ff = 0;
if (func_number == page_nr) ff = 1; // number is found
p_nr = page_nr + 1;
if (p_nr > MODE_LAST) p_nr -= (MODE_LAST + 1);
if (func_number == p_nr) ff = 1; // number is found
p_nr = page_nr + 2;
if (p_nr > MODE_LAST) p_nr -= (MODE_LAST + 1);
if (func_number == p_nr) ff = 1; // number is found
if (ff == 0) {
// func_number is not in page list
#ifdef WITH_ROTARY_SWITCH
if (rotary.count >= 0) {
page_nr = (func_number + MODE_LAST -1); // page_nr = func_number - 2
} else {
page_nr = func_number; // for backward, set page_nr to func_number
}
if (page_nr > MODE_LAST) page_nr -= (MODE_LAST + 1);
#else
page_nr = func_number;
#endif
}
if (ff == 0) {
lcd_line2();
lcd_clear_line(); // clear line 2
}
lcd_line2(); // reset cursor to begin of line 2
if (func_number == page_nr) {
lcd_data('>');
} else {
lcd_space(); // put a blank to 1. row of line 2
}
message2line(page_nr); // show first page function
if (ff == 0) {
lcd_line3();
lcd_clear_line(); // clear line 3
}
lcd_line3(); // reset cursor to begin of line 3
p_nr = page_nr + 1;
if (p_nr > MODE_LAST) p_nr -= (MODE_LAST + 1);
if (func_number == p_nr) {
lcd_data('>');
} else {
lcd_space(); // put a blank to 1. row of line 3
}
message2line(p_nr); // show 2. page function
if (ff == 0) {
lcd_line4();
lcd_clear_line(); // clear line 4
}
lcd_line4(); // reset cursor to begin of line 4
p_nr = page_nr + 2;
if (p_nr > MODE_LAST) p_nr -= (MODE_LAST + 1);
if (func_number == p_nr) {
lcd_data('>');
} else {
lcd_space(); // put a blank to 1. row of line 4
}
message2line(p_nr); // show 3. page function
#else /* no PAGE_MODE */
lcd_line2();
lcd_clear_line(); // clear line 2
lcd_line2(); // reset cursor to begin of line 2
lcd_space(); // put a blank to 1. row of line 2
message2line(func_number + MODE_LAST); // show lower (previous) function
lcd_line3();
lcd_clear_line(); // clear line 3
lcd_line3(); // reset cursor to begin of line 3
lcd_data('>'); // put a '>' marker to row 1 of line 3
message2line(func_number); // show selectable function
lcd_line4();
lcd_clear_line(); // clear line 4
lcd_line4(); // reset cursor to begin of line 4
lcd_space(); // put a blank to 1. row of line 4
message2line(func_number + 1); // show higher (next) function
#endif /* PAGE_MODE */
#else /* no FOUR_LINE_LCD */
lcd_line2();
lcd_clear_line(); // clear line 2
lcd_line2(); // reset cursor to begin of line 2
message2line(func_number);
#endif /* FOUR_LINE_LCD */
#ifdef POWER_OFF
ii = wait_for_key_ms(SHORT_WAIT_TIME); // wait about 5 seconds
if (ii > 0) ll = 0; // reset timer, operator present
#else
ii = wait_for_key_ms(0); // wait endless
#endif
#ifdef WITH_ROTARY_SWITCH
if ((ii >= MIN_SELECT_TIME) || ((rotary_switch_present != 0) && (ii > 0)))
#else
if (ii >= MIN_SELECT_TIME)
#endif
{
// selection only with key-press
if (func_number == MODE_TRANS) break; // return to TransistorTester
if (func_number == MODE_FREQ) GetFrequency(0);
#if PROCESSOR_TYP == 644
if (func_number == MODE_HFREQ) GetFrequency(1); // measure high frequency with 16:1 divider
if (func_number == MODE_H_CRYSTAL) GetFrequency(5); // HF crystal input + 16:1 divider
if (func_number == MODE_L_CRYSTAL) GetFrequency(6); // LF crystal input, 1:1 divider
#endif
if (func_number == MODE_FGEN) {
make_frequency(); // make some sample frequencies
}
if (func_number == MODE_PWM) {
do_10bit_PWM(); // generate 10bit PWM
}
if (func_number == MODE_ESR) {
show_C_ESR(); // measure capacity and ESR at TP1 and TP3
}
if (func_number == MODE_ROTARY) {
CheckRotaryEncoder(); // check rotary encoder
}
#ifdef WITH_SELFTEST
if (func_number == MODE_SELFTEST) AutoCheck(0x11); // Full selftest with calibration
#endif
if (func_number == MODE_VEXT) show_vext();
#if (LCD_ST_TYPE == 7565)
if (func_number == MODE_CONTRAST) set_contrast();
#endif
if (func_number == MODE_SHOW) {
ShowData(); // Show Calibration Data
}
if (func_number == MODE_OFF) {
ON_PORT &= ~(1<<ON_PIN); //switch off power
wait_for_key_ms(0); //never ending loop
}
// don't increase function number for easier selection the same function
ii = 0; // function was executed before, do not increase func_number
#ifdef WITH_ROTARY_SWITCH
rotary.incre = 0; // reset all rotary information
rotary.count = 0;
#endif
} /* end if (ii >= MIN_SELECT_TIME) */
#ifdef WITH_ROTARY_SWITCH
if (rotary.incre >= FAST_ROTATION) break; // to much rotation
#ifdef POWER_OFF
if (rotary.count != 0) ll = 0; // someone is working, reset timer
#endif
if (rotary.count >= 0) {
func_number += rotary.count; // function number is increased by rotary steps
} else {
func_number += (MODE_LAST + 1 + rotary.count); // function is decreased by rotary steps
}
#endif
if (ii > 0) func_number++; // increase the function number with key press
} /* end for ll */
return;
} // end function_menu()
void ShowData(void) {
#ifdef WITH_ROTARY_SWITCH
show_page_1:
#endif
lcd_clear();
lcd_MEM2_string(VERSION_str); // "Version x.xxk"
lcd_line2();
lcd_MEM2_string(R0_str); // "R0="
DisplayValue(eeprom_read_byte(&EE_ESR_ZEROtab[2]),-2,' ',3);
DisplayValue(eeprom_read_byte(&EE_ESR_ZEROtab[3]),-2,' ',3);
DisplayValue(eeprom_read_byte(&EE_ESR_ZEROtab[1]),-2,LCD_CHAR_OMEGA,3);
#ifdef FOUR_LINE_LCD
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); // "RiHi="
DisplayValue(RRpinPL,-1,LCD_CHAR_OMEGA,3);
#ifdef FOUR_LINE_LCD
lcd_line4();
#else
lcd_line2();
#endif
/* output line 4 */
lcd_MEM_string(RILO); // "RiLo="
DisplayValue(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
#ifdef FOUR_LINE_LCD
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 "
DisplayValue(eeprom_read_byte(&c_zero_tab[5]),0,' ',3); //output cap0 1:3
DisplayValue(eeprom_read_byte(&c_zero_tab[6]),0,' ',3); //output cap0 2:3
DisplayValue(eeprom_read_byte(&c_zero_tab[2]),-12,'F',3); //output cap0 1:2
lcd_line2();
lcd_space();
lcd_space();
lcd_space();
DisplayValue(eeprom_read_byte(&c_zero_tab[1]),0,' ',3); //output cap0 3:1
DisplayValue(eeprom_read_byte(&c_zero_tab[4]),0,' ',3); //output cap0 3:2
DisplayValue(eeprom_read_byte(&c_zero_tab[0]),-12,'F',3); //output cap0 2:1
#ifdef FOUR_LINE_LCD
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)));
#ifdef FOUR_LINE_LCD
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)));
wait_for_key_ms(MIDDLE_WAIT_TIME);
#ifdef WITH_ROTARY_SWITCH
if (rotary.incre > FAST_ROTATION) return; // fast rotation ends the function
#ifdef FOUR_LINE_LCD
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
}