/** * @brief Main program. * @param None * @retval None */ int main(void) { RCC_ClocksTypeDef RCC_Clocks; /* SysTick end of count event each 10ms */ RCC_GetClocksFreq(&RCC_Clocks); SysTick_Config(RCC_Clocks.HCLK_Frequency / 100); /********************输出 初始化 ******************/ PWM_init(); STM324xG_LCD_Init(); LCD_Clear(BLACK);/* Clear the LCD */ LCD_SetBackColor(BLACK);/* Set the LCD Back Color */ LCD_SetTextColor(WHITE);/* Set the LCD Text Color */ LCD_DisplayStringLine(LINE(0), " Hello jaja. I'm xiaohei01"); /********************输入 初始化 ******************/ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_3);/*!< 3 bits for pre-emption priority 1 bits for subpriority */ Encoder_init(); //encoder tim8 usart_init();//通信COM usart2 115200 IMU_init(); if (get_mode()==1) { IMU_BE10(); } KEY_init(); AD_Init(); GPS_int(); TIM2_Configuration(); printf("uart init OK 2 \r\n"); while(1) { if(LCD_flag) { LCD_flag=0; lcd_refresh(); } } }
/*! \param s the string only the first 5 characters will be displayed. if there are less than 5 characters, the remaining display positions will be cleared. */ void cputs(char *s) { int i; cputc_native(0, 5); for (i = 4; (*s) && (i >= 0);) cputc(*(s++), i--); while (i >= 1) cputc_native(0, i--); #if !defined(CONF_LCD_REFRESH) lcd_refresh(); #endif }
uint8_t function_menu() { uint8_t func_number; display_menu(); func_number = read_menu(); if (func_number == 0) { return 0; } else { do_menu(func_number); lcd_MEM2_string(Done_str); // "Done.\n" lcd_refresh(); return 1; } }
/*! \param word the hexword position 0 is unaffected by this call. */ void cputw(unsigned word) { int i; cputc_native(0, 5); for (i = 1; i <= 4; i++) { cputc_hex(word & 0x0f, i); word >>= 4; } #if !defined(CONF_LCD_REFRESH) lcd_refresh(); #endif }
void main () { setup_timer_3 (T3_DISABLED|T3_DIV_BY_1); pwm_init (0); pwm_duty (0, 50); usb_init (); lcd_init (); lcd_putc ('\f'); delay_ms (1); lcd_refresh (); while (TRUE) { usb_task (); if (usb_enumerated ()) { if (usb_kbhit (1)) { rx_msg_len = usb_get_packet (1, &rx_msg, sizeof (rx_msg)); process_usb_data (); } } lcd_refresh (); delay_ms (100); } }
void main() { setup_timer_3 (T3_DISABLED|T3_DIV_BY_1); usb_init (); lcd_init (); lcd_putc ('\f'); delay_ms (1); while (TRUE) { lcd_refresh (); usb_task (); if (usb_enumerated ()) { if (usb_kbhit (1)) rxdata_len = usb_get_packet (1, rxdata, sizeof (rxdata)); } delay_ms (100); } }
//! show OFF string extern inline void show_off(void) { cls(); #ifdef CONF_ASCII cputs("OFF"); #else #ifdef CONF_CONIO cputc_native_4(0x7e); cputc_native_3(0x1d); cputc_native_2(0x1d); #else lcd_digit(0); #endif #endif #ifndef CONF_LCD_REFRESH lcd_refresh(); #endif }
T_VOID Fwl_LCDVMSetRefresh(T_U16 left, T_U16 top, T_U32 width, T_U32 height, T_BOOL reversed) { T_RECT rect; if (Lcd_Lock) { return; } rect.left = left; rect.top = top; rect.width = (T_U16)width; rect.height = (T_U16)height; store_all_int(); lcd_refresh(&rect, AK_NULL); restore_all_int(); }
/*! \param s the string Only the first 5 characters will be displayed, unless the first character is '-', in which case an additional character will be displayed. If there are fewer characters than display positions, the remaining "user" display positions will be cleared. */ void cputs(const char *s) { int i; // Determine if the first character is a dash if ('-' == (*s)) { cputc(*(s++), 5); } else { cputc_native(0, 5); } for (i = 4; (*s) && (i >= 0);) cputc(*(s++), i--); while (i >= 1) cputc_native(0, i--); #if !defined(CONF_LCD_REFRESH) lcd_refresh(); #endif }
T_VOID Fwl_RefreshRect(T_U16 left, T_U16 top, T_U16 width, T_U16 height, const T_U8 *content, T_BOOL reversed) { //if(left + width > MAIN_LCD_WIDTH || top+height > MAIN_LCD_HEIGHT) //{ // AK_DEBUG_OUTPUT("show out of LCd l:%d,t:%d,w:%d,h:%d\r\n",left,top,width,height); //} T_RECT rect; if (Lcd_Lock) { return; } rect.left = left; rect.top = top; rect.width = width; rect.height = height; lcd_refresh(&rect, content); }
//! show ON string extern inline void show_on(void) { cls(); #ifdef CONF_ASCII cputs("ON"); #else #ifdef CONF_CONIO cputc_native_4(0x38); cputc_native_3(0x3d); cputc_native_2(0x7c); cputc_native_1(0x7e); cputc_native_0(0x6d); #else lcd_digit(1); #endif #endif #ifndef CONF_LCD_REFRESH lcd_refresh(); #endif delay(250); }
void process_usb_data () { pwm_init (rx_msg.u.enabled); pwm_duty (rx_msg.u.pwm1_duty_percent, rx_msg.u.pwm2_duty_percent); lcd_refresh (); }
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 kmain(void) { int reset_after_shutdown=0; #ifdef CONF_DKEY int c; #endif /* Install the text.hi segment in the correct place. The * firmware loader puts it in the bss segment, we copy it * to it's final location. */ memcpy(&__text_hi, &__bss, &__etext_hi - &__text_hi); reset_vector = rom_reset_vector; /* Turn off motor, since writing to hitext manipulates motors */ motor_controller = 0; memset(&__bss, 0, &__bss_end - &__bss); #ifdef CONF_MM mm_init(); #endif while (1) { power_init(); #ifdef CONF_AUTOSHUTOFF shutoff_init(); #endif lcd_init(); #ifdef CONF_DSOUND dsound_init(); #endif #ifdef CONF_TIME systime_init(); #endif #ifdef CONF_DSENSOR ds_init(); #endif #ifdef CONF_DMOTOR dm_init(); #endif #ifdef CONF_LNP lnp_init(); lnp_logical_init(); #endif #ifdef CONF_TM tm_init(); #endif #ifdef CONF_PROGRAM program_init(); #endif show_on(); // wait till power key released // #ifdef CONF_DKEY dkey_multi=KEY_ANY; while((c=dkey_multi) & KEY_ONOFF); #else while (PRESSED(dbutton(), BUTTON_ONOFF)); delay(100); #endif cls(); #ifndef CONF_PROGRAM lcd_show(man_run); #ifndef CONF_LCD_REFRESH lcd_refresh(); #endif #endif // run app // #ifdef CONF_TM #ifndef CONF_PROGRAM execi(&main,0,0,PRIO_NORMAL,DEFAULT_STACK_SIZE); #endif tm_start(); #else main(0,0); #endif show_off(); // ON/OFF + PROGRAM -> erase firmware #ifdef CONF_DKEY while((c=dkey_multi) & KEY_ONOFF) if(c&KEY_PRGM) reset_after_shutdown=1; #else while (PRESSED(dbutton(), BUTTON_ONOFF)) if (PRESSED(dbutton(), BUTTON_PROGRAM)) reset_after_shutdown=1; #endif #ifdef CONF_PROGRAM program_shutdown(); #endif #ifdef CONF_LNP lnp_logical_shutdown(); #endif #ifdef CONF_DMOTOR dm_shutdown(); #endif #ifdef CONF_DSENSOR ds_shutdown(); #endif #ifdef CONF_TIME systime_shutdown(); #endif if (reset_after_shutdown) rom_reset(); lcd_clear(); lcd_power_off(); power_off(); } }
static CYG_BYTE KeyboardAscii(CYG_BYTE scancode) { CYG_BYTE ascii = 0xFF; // Start by handling all shift/ctl keys: switch( scancode ) { case 0xe0: KBFlags |= KBExtend; return 0xFF; case 0xfa: KBFlags |= KBAck; return 0xFF; case 0xfe: KBFlags |= KBResend; return 0xFF; case LSHIFT: KBFlags |= KBShiftL; return 0xFF; case LSHIFT | BREAK: KBFlags &= ~KBShiftL; return 0xFF; case RSHIFT: KBFlags |= KBShiftR; return 0xFF; case RSHIFT | BREAK: KBFlags &= ~KBShiftR; return 0xFF; case CTRL: if( KBFlags & KBExtend ) { KBFlags |= KBCtrlR; KBFlags &= ~KBExtend; } else KBFlags |= KBCtrlL; return 0xFF; case CTRL | BREAK: if( KBFlags & KBExtend ) { KBFlags &= ~KBCtrlR; KBFlags &= ~KBExtend; } else KBFlags &= ~KBCtrlL; return 0xFF; case ALT: if( KBFlags & KBExtend ) { KBFlags |= KBAltR; KBFlags &= ~KBExtend; } else KBFlags |= KBAltL; return 0xFF; case ALT | BREAK: if( KBFlags & KBExtend ) { KBFlags &= ~KBAltR; KBFlags &= ~KBExtend; } else KBFlags &= ~KBAltL; return 0xFF; case CAPS: KBFlags ^= KBCapsLock; case CAPS | BREAK: return 0xFF; case NUMS: KBFlags ^= KBNumLock; case NUMS | BREAK: return 0xFF; case KBArrowUp: case KBArrowDown: #if 0 // Not really needed on this display screen_pan = 0; lcd_refresh(); #endif break; case KBArrowLeft: #if 0 // Not really needed on this display screen_pan -= SCREEN_PAN; if (screen_pan < 0) screen_pan = 0; lcd_refresh(); #endif break; case KBArrowRight: #if 0 // Not really needed on this display screen_pan += SCREEN_PAN; if (screen_pan > (SCREEN_WIDTH-SCREEN_PAN)) screen_pan = SCREEN_WIDTH-SCREEN_PAN; lcd_refresh(); #endif break; } // Clear Extend flag if set KBFlags &= ~KBExtend; // Ignore all other BREAK codes if( scancode & 0x80 ) return 0xFF; // Here the scancode is for something we can turn // into an ASCII value ascii = KBScanTable[scancode & 0x7F][KBIndexTab[KBFlags & KBIndex]]; return ascii; } /* KeyboardAscii */
//! receive a byte, decoding LNP packets with a state machine. void lnp_integrity_byte(unsigned char b) { static unsigned char buffer[256+3]; static int bytesRead,endOfData; static unsigned char chk; if(lnp_integrity_state==LNPwaitHeader) bytesRead=0; buffer[bytesRead++]=b; switch(lnp_integrity_state) { case LNPwaitHeader: // valid headers are 0xf0 .. 0xf7 // if(((b & 0xf8) == 0xf0) || (b == 0x55)) { #ifdef CONF_VIS if (lnp_logical_range_is_far()) { dlcd_show(LCD_IR_UPPER); dlcd_show(LCD_IR_LOWER); } else { dlcd_hide(LCD_IR_UPPER); dlcd_show(LCD_IR_LOWER); } #ifndef CONF_LCD_REFRESH lcd_refresh(); #endif #endif // Init checksum lnp_checksum_init( chk ); // switch on protocol header if (b == 0x55) { #if defined(CONF_RCX_PROTOCOL) || defined(CONF_RCX_MESSAGE) // 0x55 is header for standard firmware message lnp_integrity_state = LNPwaitRMH1; #else lnp_integrity_reset(); #endif } else { lnp_integrity_state++; } } break; case LNPwaitLength: endOfData=b+2; lnp_integrity_state++; break; case LNPwaitData: if(bytesRead==endOfData) lnp_integrity_state++; break; case LNPwaitCRC: if(b==chk) lnp_receive_packet(buffer); lnp_integrity_reset(); break; #if defined(CONF_RCX_PROTOCOL) || defined (CONF_RCX_MESSAGE) // state machine to handle remote case LNPwaitRMH1: case LNPwaitRMH2: // waiting for header bytes if ( b == lnp_rcx_header[ lnp_integrity_state-LNPwaitRMH1 ] ) lnp_integrity_state++; else lnp_integrity_reset(); break; case LNPwaitRMH3: case LNPwaitRMH4: if ( b == lnp_rcx_remote_op[ lnp_integrity_state-LNPwaitRMH3 ] ) lnp_integrity_state++; #if defined(CONF_RCX_MESSAGE) else if ( b == lnp_rcx_msg_op[ lnp_integrity_state-LNPwaitRMH3 ] ) lnp_integrity_state = LNPwaitMH4; #endif else lnp_integrity_reset(); break; case LNPwaitRB0: lnp_rcx_temp0 = b; lnp_integrity_state++; break; case LNPwaitRB0I: if ( (unsigned char)~b == lnp_rcx_temp0 ) lnp_integrity_state++; else lnp_integrity_reset(); break; case LNPwaitRB1: lnp_rcx_temp1 = b; lnp_integrity_state++; break; case LNPwaitRB1I: if ( (unsigned char)~b == lnp_rcx_temp1 ) lnp_integrity_state++; else lnp_integrity_reset(); break; case LNPwaitRC: lnp_rcx_checksum = 0xd2 + lnp_rcx_temp0 + lnp_rcx_temp1; if ( b == lnp_rcx_checksum ) lnp_integrity_state++; else lnp_integrity_reset(); break; case LNPwaitRCI: // if checksum valid and remote handler has been installed, call remote handler if ( b == (unsigned char)~lnp_rcx_checksum) { #if defined(CONF_RCX_MESSAGE) // if a message, set message number and exit if (lnp_rcx_temp1 & 0x07) { lnp_rcx_message = (lnp_rcx_temp1 > 2) ? 3 : lnp_rcx_temp1; } else #endif { // Invoke remote handler if any lnp_remote_handler_t rmth = lnp_remote_handler; if (rmth) rmth( (lnp_rcx_temp0<<8)+lnp_rcx_temp1 ); } } // reset state machine when done lnp_integrity_reset(); break; #endif #if defined(CONF_RCX_MESSAGE) // state machine to handle RCX protocol messages case LNPwaitMH3: case LNPwaitMH4: if ( b == lnp_rcx_msg_op[ lnp_integrity_state-LNPwaitMH3 ] ) lnp_integrity_state++; else lnp_integrity_reset(); break; case LNPwaitMN: lnp_rcx_temp0 = b; lnp_integrity_state++; break; case LNPwaitMNC: if ( (unsigned char)~b == lnp_rcx_temp0 ) lnp_integrity_state++; else lnp_integrity_reset(); break; case LNPwaitMC: lnp_rcx_temp1 = 0xf7 + lnp_rcx_temp0; if (b == lnp_rcx_temp1) lnp_integrity_state++; else lnp_integrity_reset(); break; case LNPwaitMCC: // set message variable if it is valid message if ( (unsigned char)~b == lnp_rcx_temp1 ) lnp_rcx_message = lnp_rcx_temp0; // reset state machine lnp_integrity_reset(); break; #endif } // Accumulate checksum lnp_checksum_step( chk, b ); }
void lcd_loop() { lcd_init(); lcd_refresh(); temp_t temp_tab [DS18B20_NR]; for (uint8_t i = 0; i < DS18B20_NR; i++) temp_tab[i] = i; ds18b20_get_temp_tab(DS18B20_NR, RESOLUTION_9, 2, temp_tab); int8_t temp_tab_int [DS18B20_NR]; for (uint8_t i = 0; i < DS18B20_NR; i++) temp_tab_int[i] = TEMP2I(temp_tab[i]); #if 0 lprintf(0, 0, "His|Hle|Pec|Kol|Rad?" " | | | | " " | | | | " " | | | | "); lprintf(1, 0, "%3d", temp_tab_int[DS18B20_HOUSE_0 ]); lprintf(2, 0, "%3d", temp_tab_int[DS18B20_HOUSE_S_T]); lprintf(3, 0, "%3d", temp_tab_int[DS18B20_HOUSE_S_B]); lprintf(0, 3, "%c", pumping_state == PUMPING_S2H ? '<' : (pumping_state == PUMPING_H2S ? '>' : '|')); lprintf(1, 4, "%3d", temp_tab_int[DS18B20_STABLE_S_T]); lprintf(2, 4, "%3d", temp_tab_int[DS18B20_STABLE_S_B]); lprintf(1, 8, "%3d", temp_tab_int[DS18B20_FURNACE_T]); lprintf(2, 8, "%3d", temp_tab_int[DS18B20_FURNACE_B]); lprintf(3, 8, "%c", relay_get(RELAY_PUMP_FURNACE) ? '*' : ' '); lprintf(3, 10, "%c", valve_opened(VALVE_FURNACE) ? '|' : (valve_closed(VALVE_FURNACE) ? '-' : '/')); lprintf(1, 12, "%3d", temp_tab_int[DS18B20_COLLECTOR]); lprintf(3, 12, "%c", relay_get(RELAY_PUMP_COLLECTOR) ? '*' : ' '); lprintf(1, 16, "%3d", temp_tab_int[DS18B20_RADIATOR_U]); lprintf(2, 16, "%3d", temp_tab_int[DS18B20_RADIATOR_D]); lprintf(3, 16, "%c", relay_get(RELAY_PUMP_RADIATOR) ? '*' : ' '); lprintf(3, 18, "%c", valve_opened(VALVE_RADIATOR) ? '|' : (valve_closed(VALVE_RADIATOR) ? '-' : '/')); #else char sf [] = " ||"; valve_state_t vf = valve_get(VALVE_FURNACE); if (VALVE_STATE_MIN < vf && vf < VALVE_STATE_MAX) sprintf(sf, "%02d%%", vf); else if (vf) sf[1] = '-'; char sr [] = " | "; valve_state_t vr = valve_get(VALVE_RADIATOR); if (VALVE_STATE_MIN < vr && vr < VALVE_STATE_MAX) sprintf(sr, "%02d%%", vr); else if (vr) sr[1] = '-'; lprintf(0, 0, "His%cHle|Pec|Kol|Rad " "%3d|%3d|%3d|%3d|%3d " "%3d|%3d|%3d|%3d|%3d " "%3d|%3d|%c%03s%c |%c%03s", pumping_state == PUMPING_S2H ? '<' : (pumping_state == PUMPING_H2S ? '>' : '|'), temp_tab_int[DS18B20_HOUSE_0 ], temp_tab_int[DS18B20_STABLE_0 ], temp_tab_int[DS18B20_FURNACE_T ], temp_tab_int[DS18B20_COLLECTOR ], temp_tab_int[DS18B20_RADIATOR_U], temp_tab_int[DS18B20_HOUSE_S_T ], temp_tab_int[DS18B20_STABLE_S_T], temp_tab_int[DS18B20_FURNACE_B ], temp_tab_int[DS18B20_OUTSIDE ], temp_tab_int[DS18B20_RADIATOR_D], temp_tab_int[DS18B20_HOUSE_S_B ], temp_tab_int[DS18B20_STABLE_S_B], relay_get(RELAY_PUMP_FURNACE) ? '*' : ' ', sf, relay_get(RELAY_PUMP_COLLECTOR) ? '*' : ' ', relay_get(RELAY_PUMP_RADIATOR) ? '*' : ' ', sr); #endif }
/** * @file * @brief draw a specified rect for black white lcd * different OS * * @author Justin.Zhao * @date 2008-5-9 * @version 1.0 */ T_VOID Fwl_DrawRect(T_U16 left, T_U16 top, T_U16 width, T_U16 height, T_U16 color, T_U8 filled_flag) { T_U8 filled = filled_flag & 0x01; T_U8 left_fill = !(filled_flag & 0x02); T_U8 right_fill = !(filled_flag & 0x04); #if (!USE_COLOR_LCD) //T_U8* commbuf = Gbl_GetCommBuff(); //T_U32 commbufsize = Gbl_GetCommBuffSize(); T_U8* commbuf = AK_NULL; T_U32 commbufsize = 0; #endif if (Lcd_Lock) { return; } #if (USE_COLOR_LCD) if (filled) { Fwl_FillRect(left, top, width, height, color); return; } else { Fwl_FillRect(left, top, width, 1, color); if(left_fill) Fwl_FillRect(left, top, 1, height, color); else Fwl_FillRect(left, top, 1, 1, color); Fwl_FillRect(left, (T_POS)(top+height-1), width, 1, color); if(right_fill) Fwl_FillRect((T_POS)(left+width-1), top, 1, height, color); else Fwl_FillRect((T_POS)(left+width-1), top, 1, 1, color); } #else T_U8 drawtop, drawheight, row, col,lasttop, drawrow; T_U8 *pbyte; if ((top == (top & ~(LCD_HEIGHT_UNIT-1))) && (height == (height & ~(LCD_HEIGHT_UNIT-1))) && filled) { Fwl_FillRect(left, top, width, height, color); return; } commbufsize = DISPLAY_COMMONBUFFSIZE; commbuf = LoadMem_CommBuffMalloc(DISPLAY_COMMONBUFFSIZE); if (AK_NULL == commbuf) { AK_DEBUG_OUTPUT("malloc common buff is null.\n\r"); return; } drawtop = top & ~(LCD_HEIGHT_UNIT-1); drawheight = ((height + top + LCD_HEIGHT_UNIT - 1) & ~(LCD_HEIGHT_UNIT-1)) - drawtop; lasttop = drawtop; memset(commbuf, 0, commbufsize); for(drawrow = drawtop; drawrow < drawtop+drawheight; ) { //draw 8 lines for(col = (T_U8)left; col < (T_U8)(left+width); col++) { //seek the buffer place pbyte = commbuf+((drawrow-lasttop)/BYTE_WIDTH)*width + col - left; //draw 8 pixels: 1 byte. for(row=drawrow; row < drawrow+LCD_HEIGHT_UNIT; row++) { if ((top <= row && row <= (top+height-1)) && (filled || row == top || row == (top+height-1) || col == left || col == (left+width-1))) { if (color) { if((col==left+width-1) && !right_fill) { if((row!=top) && (row!=top+height-1)) continue; } if((col==left) && !left_fill) { if((row!=top) && (row!=top+height-1)) continue; } *pbyte |= (1 << (row & (BYTE_WIDTH-1))); } } else if (!color) *pbyte |= (1 << (row & (BYTE_WIDTH-1))); } } drawrow += LCD_HEIGHT_UNIT; //if buff is full, refresh lcd if ((T_U32)(((drawrow-lasttop)/BYTE_WIDTH+1)*width)>=commbufsize) { T_RECT rect; rect.left = left; rect.top = lasttop; rect.width = width; rect.height = (T_U8)(drawrow - lasttop); lcd_refresh(&rect, commbuf); memset(commbuf, 0, commbufsize); lasttop = drawrow; } } if (lasttop != drawrow) { T_RECT rect; rect.left = left; rect.top = lasttop; rect.width = width; rect.height = (T_U8)(drawrow - lasttop); lcd_refresh(&rect, commbuf); } LoadMem_CommBuffFree(); #endif }
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 };
int main(void) { /* Early system initialisation */ early_board_init(); system_init_early(); leds_init(); set_busy_led(1); set_dirty_led(0); /* Due to an erratum in the LPC17xx chips anything that may change */ /* peripheral clock scalers must come before system_init_late() */ uart_init(); #ifndef SPI_LATE_INIT spi_init(SPI_SPEED_SLOW); #endif timer_init(); i2c_init(); /* Second part of system initialisation, switches to full speed on ARM */ system_init_late(); enable_interrupts(); /* Prompt software name and version string */ uart_puts_P(PSTR("\r\nNODISKEMU " VERSION "\r\n")); /* Internal-only initialisation, called here because it's faster */ buffers_init(); buttons_init(); /* Anything that does something which needs the system clock */ /* should be placed after system_init_late() */ rtc_init(); // accesses I2C disk_init(); // accesses card read_configuration(); // restores configuration, may change device address filesystem_init(0); // FIXME: change_init(); #ifdef CONFIG_REMOTE_DISPLAY /* at this point all buffers should be free, */ /* so just use the data area of the first to build the string */ uint8_t *strbuf = buffers[0].data; ustrcpy_P(strbuf, versionstr); ustrcpy_P(strbuf+ustrlen(strbuf), longverstr); if (display_init(ustrlen(strbuf), strbuf)) { display_address(device_address); display_current_part(0); } #endif set_busy_led(0); #if defined(HAVE_SD) /* card switch diagnostic aid - hold down PREV button to use */ if (menu_system_enabled && get_key_press(KEY_PREV)) board_diagnose(); #endif if (menu_system_enabled) lcd_splashscreen(); bus_interface_init(); bus_init(); read_configuration(); late_board_init(); for (;;) { if (menu_system_enabled) lcd_refresh(); else { lcd_clear(); lcd_printf("#%d", device_address); } /* Unit number may depend on hardware and stored settings */ /* so present it here at last */ printf("#%02d\r\n", device_address); bus_mainloop(); bus_interface_init(); bus_init(); // needs delay, inits device address with HW settings } }
void lnp_integrity_reset(void) { #else HANDLER_WRAPPER("lnp_integrity_reset","lnp_integrity_reset_core"); void lnp_integrity_reset_core(void) { #endif #ifndef CONF_HOST if(tx_state>TX_IDLE) { txend_handler(); tx_state=TX_COLL; } else #endif if(lnp_integrity_state!=LNPwaitHeader) { lnp_integrity_state=LNPwaitHeader; #ifdef CONF_VIS dlcd_hide(LCD_IR_LOWER); dlcd_hide(LCD_IR_UPPER); #ifndef CONF_LCD_REFRESH lcd_refresh(); #endif #endif } } //! return whether a packet is currently being received /*! \return 1 if yes, else zero */ int lnp_integrity_active(void) { return lnp_integrity_state!=LNPwaitHeader; } //! reset the inter-byte timeout counter. #if defined(CONF_RCX_COMPILER) || defined(CONF_HOST) void lnp_timeout_reset(void) { #else HANDLER_WRAPPER("lnp_timeout_reset","lnp_timeout_reset_core"); void lnp_timeout_reset_core(void) { #endif lnp_timeout_counter=lnp_timeout; } //! set the inter-byte timeout and reset the timeout counter to that value. /*! \param timeout the new timeout value */ void lnp_timeout_set(unsigned short timeout) { lnp_timeout_counter=lnp_timeout=timeout; } //! Initialise protocol handlers /*! Adressing port 0 is reserved for the program handler. */ void lnp_init(void) { int k; for(k=1; k<=LNP_PORTMASK; k++) lnp_addressing_handler[k]=LNP_DUMMY_ADDRESSING; lnp_integrity_handler=LNP_DUMMY_INTEGRITY; #if defined(CONF_RCX_PROTOCOL) lnp_remote_handler=LNP_DUMMY_REMOTE; #endif #if defined(CONF_RCX_MESSAGE) clear_msg(); #endif }
//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 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 */