/** * Turn on the bed and nozzle heat and * wait for them to get up to temperature. */ bool unified_bed_leveling::turn_on_heaters() { millis_t next = millis() + 5000UL; #if HAS_TEMP_BED #if ENABLED(ULTRA_LCD) if (g26_bed_temp > 25) { lcd_setstatusPGM(PSTR("G26 Heating Bed."), 99); lcd_quick_feedback(); #endif has_control_of_lcd_panel = true; thermalManager.setTargetBed(g26_bed_temp); while (abs(thermalManager.degBed() - g26_bed_temp) > 3) { #if ENABLED(NEWPANEL) if (ubl_lcd_clicked()) return exit_from_g26(); #endif if (PENDING(millis(), next)) { next = millis() + 5000UL; print_heaterstates(); } idle(); } #if ENABLED(ULTRA_LCD) } lcd_setstatusPGM(PSTR("G26 Heating Nozzle."), 99); lcd_quick_feedback(); #endif #endif // Start heating the nozzle and wait for it to reach temperature. thermalManager.setTargetHotend(g26_hotend_temp, 0); while (abs(thermalManager.degHotend(0) - g26_hotend_temp) > 3) { #if ENABLED(NEWPANEL) if (ubl_lcd_clicked()) return exit_from_g26(); #endif if (PENDING(millis(), next)) { next = millis() + 5000UL; print_heaterstates(); } idle(); } #if ENABLED(ULTRA_LCD) lcd_reset_status(); lcd_quick_feedback(); #endif return UBL_OK; }
/** * M0: Unconditional stop - Wait for user button press on LCD * M1: Conditional stop - Wait for user button press on LCD */ void GcodeSuite::M0_M1() { const char * const args = parser.string_arg; millis_t ms = 0; bool hasP = false, hasS = false; if (parser.seenval('P')) { ms = parser.value_millis(); // milliseconds to wait hasP = ms > 0; } if (parser.seenval('S')) { ms = parser.value_millis_from_seconds(); // seconds to wait hasS = ms > 0; } #if ENABLED(ULTIPANEL) if (!hasP && !hasS && args && *args) lcd_setstatus(args, true); else { LCD_MESSAGEPGM(MSG_USERWAIT); #if ENABLED(LCD_PROGRESS_BAR) && PROGRESS_MSG_EXPIRE > 0 dontExpireStatus(); #endif } #else if (!hasP && !hasS && args && *args) { SERIAL_ECHO_START(); SERIAL_ECHOLN(args); } #endif KEEPALIVE_STATE(PAUSED_FOR_USER); wait_for_user = true; stepper.synchronize(); refresh_cmd_timeout(); if (ms > 0) { ms += previous_cmd_ms; // wait until this time for a click while (PENDING(millis(), ms) && wait_for_user) idle(); } else { #if ENABLED(ULTIPANEL) if (lcd_detected()) { while (wait_for_user) idle(); IS_SD_PRINTING ? LCD_MESSAGEPGM(MSG_RESUMING) : LCD_MESSAGEPGM(WELCOME_MSG); } #else while (wait_for_user) idle(); #endif } wait_for_user = false; KEEPALIVE_STATE(IN_HANDLER); }
_nc_hash_map(void) { HASHMAP *sp; register int i; int start, shift, size; if (screen_lines > lines_alloc) { if (hashtab) free(hashtab); hashtab = typeMalloc(HASHMAP, (screen_lines + 1) * 2); if (!hashtab) { if (oldhash) { FreeAndNull(oldhash); } lines_alloc = 0; return; } lines_alloc = screen_lines; } if (oldhash && newhash) { /* re-hash only changed lines */ for (i = 0; i < screen_lines; i++) { if (PENDING(i)) newhash[i] = hash(NEWTEXT(i)); } } else { /* re-hash all */ if (oldhash == 0) oldhash = typeCalloc(unsigned long, (unsigned) screen_lines); if (newhash == 0) newhash = typeCalloc(unsigned long, (unsigned) screen_lines); if (!oldhash || !newhash) return; /* malloc failure */ for (i = 0; i < screen_lines; i++) { newhash[i] = hash(NEWTEXT(i)); oldhash[i] = hash(OLDTEXT(i)); } } #ifdef HASH_VERIFY for (i = 0; i < screen_lines; i++) { if (newhash[i] != hash(NEWTEXT(i))) fprintf(stderr, "error in newhash[%d]\n", i); if (oldhash[i] != hash(OLDTEXT(i))) fprintf(stderr, "error in oldhash[%d]\n", i); } #endif /* * Set up and count line-hash values. */ memset(hashtab, '\0', sizeof(*hashtab) * (screen_lines + 1) * 2); for (i = 0; i < screen_lines; i++) { unsigned long hashval = oldhash[i]; for (sp = hashtab; sp->hashval; sp++) if (sp->hashval == hashval) break; sp->hashval = hashval; /* in case this is a new entry */ sp->oldcount++; sp->oldindex = i; } for (i = 0; i < screen_lines; i++) { unsigned long hashval = newhash[i]; for (sp = hashtab; sp->hashval; sp++) if (sp->hashval == hashval) break; sp->hashval = hashval; /* in case this is a new entry */ sp->newcount++; sp->newindex = i; OLDNUM(i) = _NEWINDEX; /* initialize old indices array */ } /* * Mark line pairs corresponding to unique hash pairs. * * We don't mark lines with offset 0, because it can make fail * extending hunks by cost_effective. Otherwise, it does not * have any side effects. */ for (sp = hashtab; sp->hashval; sp++) if (sp->oldcount == 1 && sp->newcount == 1 && sp->oldindex != sp->newindex) { TR(TRACE_UPDATE | TRACE_MOVE, ("new line %d is hash-identical to old line %d (unique)", sp->newindex, sp->oldindex)); OLDNUM(sp->newindex) = sp->oldindex; } grow_hunks(); /* * Eliminate bad or impossible shifts -- this includes removing * those hunks which could not grow because of conflicts, as well * those which are to be moved too far, they are likely to destroy * more than carry. */ for (i = 0; i < screen_lines;) { while (i < screen_lines && OLDNUM(i) == _NEWINDEX) i++; if (i >= screen_lines) break; start = i; shift = OLDNUM(i) - i; i++; while (i < screen_lines && OLDNUM(i) != _NEWINDEX && OLDNUM(i) - i == shift) i++; size = i - start; if (size < 3 || size + min(size / 8, 2) < abs(shift)) { while (start < i) { OLDNUM(start) = _NEWINDEX; start++; } } } /* After clearing invalid hunks, try grow the rest. */ grow_hunks(); }
void HAL_init() { // Support the 4 LEDs some LPC176x boards have #if PIN_EXISTS(LED) SET_DIR_OUTPUT(LED_PIN); WRITE_PIN_CLR(LED_PIN); #if PIN_EXISTS(LED2) SET_DIR_OUTPUT(LED2_PIN); WRITE_PIN_CLR(LED2_PIN); #if PIN_EXISTS(LED3) SET_DIR_OUTPUT(LED3_PIN); WRITE_PIN_CLR(LED3_PIN); #if PIN_EXISTS(LED4) SET_DIR_OUTPUT(LED4_PIN); WRITE_PIN_CLR(LED4_PIN); #endif #endif #endif // Flash status LED 3 times to indicate Marlin has started booting for (uint8_t i = 0; i < 6; ++i) { TOGGLE(LED_PIN); delay(100); } #endif //debug_frmwrk_init(); //_DBG("\n\nDebug running\n"); // Initialise the SD card chip select pins as soon as possible #if PIN_EXISTS(SS) WRITE(SS_PIN, HIGH); SET_OUTPUT(SS_PIN); #endif #if defined(ONBOARD_SD_CS) && ONBOARD_SD_CS > -1 WRITE(ONBOARD_SD_CS, HIGH); SET_OUTPUT(ONBOARD_SD_CS); #endif USB_Init(); // USB Initialization USB_Connect(FALSE); // USB clear connection delay(1000); // Give OS time to notice USB_Connect(TRUE); #if DISABLED(USB_SD_DISABLED) MSC_SD_Init(0); // Enable USB SD card access #endif const millis_t usb_timeout = millis() + 2000; while (!USB_Configuration && PENDING(millis(), usb_timeout)) { delay(50); HAL_idletask(); #if PIN_EXISTS(LED) TOGGLE(LED_PIN); // Flash quickly during USB initialization #endif } #if NUM_SERIAL > 0 MYSERIAL0.begin(BAUDRATE); #if NUM_SERIAL > 1 MYSERIAL1.begin(BAUDRATE); #endif SERIAL_PRINTF("\n\necho:%s (%dMhz) Initialized\n", isLPC1769() ? "LPC1769" : "LPC1768", SystemCoreClock / 1000000); SERIAL_FLUSHTX(); #endif HAL_timer_init(); }