Marlin/ultralcd.pde

   1 #include "language.h"
   2 #include "temperature.h"
   3 #include "ultralcd.h"
   4 #ifdef ULTRA_LCD
   5 #include "Marlin.h"
   6 #include "language.h"
   7 #include "temperature.h"
   8 #include "EEPROMwrite.h"
   9 #include <LiquidCrystal.h>
  10 //===========================================================================
  11 //=============================imported variables============================
  12 //===========================================================================
  13
  14 extern volatile int feedmultiply;
  15 extern volatile bool feedmultiplychanged;
  16
  17 extern volatile int extrudemultiply;
  18
  19 extern long position[4];
  20 #ifdef SDSUPPORT
  21 #include "cardreader.h"
  22 extern CardReader card;
  23 #endif
  24
  25 //===========================================================================
  26 //=============================public variables============================
  27 //===========================================================================
  28 volatile char buttons=0;  //the last checked buttons in a bit array.
  29 long encoderpos=0;
  30 short lastenc=0;
  31
  32
  33 //===========================================================================
  34 //=============================private  variables============================
  35 //===========================================================================
  36 static char messagetext[LCD_WIDTH]="";
  37
  38 //return for string conversion routines
  39 static char conv[8];
  40
  41 LiquidCrystal lcd(LCD_PINS_RS, LCD_PINS_ENABLE, LCD_PINS_D4, LCD_PINS_D5,LCD_PINS_D6,LCD_PINS_D7);  //RS,Enable,D4,D5,D6,D7
  42
  43 static unsigned long previous_millis_lcd=0;
  44 //static long previous_millis_buttons=0;
  45
  46
  47 #ifdef NEWPANEL
  48  static long blocking=0;
  49 #else
  50  static long blocking[8]={0,0,0,0,0,0,0,0};
  51 #endif
  52
  53 static MainMenu menu;
  54
  55
  56 void lcdProgMemprint(const char *str)
  57 {
  58   char ch=pgm_read_byte(str);
  59   while(ch)
  60   {
  61     lcd.print(ch);
  62     ch=pgm_read_byte(++str);
  63   }
  64 }
  65 #define lcdprintPGM(x) lcdProgMemprint(MYPGM(x))
  66
  67
  68 //===========================================================================
  69 //=============================functions         ============================
  70 //===========================================================================
  71
  72 int intround(const float &x){return int(0.5+x);}
  73
  74 void lcd_status(const char* message)
  75 {
  76   strncpy(messagetext,message,LCD_WIDTH);
  77   messagetext[strlen(message)]=0;
  78 }
  79
  80 void lcd_statuspgm(const char* message)
  81 {
  82   char ch=pgm_read_byte(message);
  83   char *target=messagetext;
  84   uint8_t cnt=0;
  85   while(ch &&cnt<LCD_WIDTH)
  86   {
  87     *target=ch;
  88     target++;
  89     cnt++;
  90     ch=pgm_read_byte(++message);
  91   }
  92   *target=0;
  93 }
  94
  95 FORCE_INLINE void clear()
  96 {
  97   lcd.clear();
  98 }
  99
 100
 101 void lcd_init()
 102 {
 103   //beep();
 104   #ifdef ULTIPANEL
 105     buttons_init();
 106   #endif
 107
 108   byte Degree[8] =
 109   {
 110     B01100,
 111     B10010,
 112     B10010,
 113     B01100,
 114     B00000,
 115     B00000,
 116     B00000,
 117     B00000
 118   };
 119   byte Thermometer[8] =
 120   {
 121     B00100,
 122     B01010,
 123     B01010,
 124     B01010,
 125     B01010,
 126     B10001,
 127     B10001,
 128     B01110
 129   };
 130   byte uplevel[8]={0x04, 0x0e, 0x1f, 0x04, 0x1c, 0x00, 0x00, 0x00};//thanks joris
 131   byte refresh[8]={0x00, 0x06, 0x19, 0x18, 0x03, 0x13, 0x0c, 0x00}; //thanks joris
 132   byte folder [8]={0x00, 0x1c, 0x1f, 0x11, 0x11, 0x1f, 0x00, 0x00}; //thanks joris
 133   lcd.begin(LCD_WIDTH, LCD_HEIGHT);
 134   lcd.createChar(1,Degree);
 135   lcd.createChar(2,Thermometer);
 136   lcd.createChar(3,uplevel);
 137   lcd.createChar(4,refresh);
 138   lcd.createChar(5,folder);
 139   LCD_MESSAGEPGM(WELCOME_MSG);
 140 }
 141
 142
 143 void beep()
 144 {
 145   //return;
 146   #ifdef ULTIPANEL
 147         #if (BEEPER > -1)
 148         {
 149                 pinMode(BEEPER,OUTPUT);
 150                 for(int8_t i=0;i<20;i++){
 151                 WRITE(BEEPER,HIGH);
 152                 delay(5);
 153                 WRITE(BEEPER,LOW);
 154                 delay(5);
 155                 }
 156         }
 157         #endif
 158   #endif
 159 }
 160
 161 void beepshort()
 162 {
 163   //return;
 164   #ifdef ULTIPANEL
 165         #if (BEEPER > -1)
 166         {
 167                 pinMode(BEEPER,OUTPUT);
 168                 for(int8_t i=0;i<10;i++){
 169                 WRITE(BEEPER,HIGH);
 170                 delay(3);
 171                 WRITE(BEEPER,LOW);
 172                 delay(3);
 173                 }
 174         }
 175         #endif
 176   #endif
 177 }
 178
 179 void lcd_status()
 180 {
 181   #ifdef ULTIPANEL
 182     static uint8_t oldbuttons=0;
 183     //static long previous_millis_buttons=0;
 184     //static long previous_lcdinit=0;
 185   //  buttons_check(); // Done in temperature interrupt
 186     //previous_millis_buttons=millis();
 187     long ms=millis();
 188     for(int8_t i=0; i<8; i++) {
 189       #ifndef NEWPANEL
 190       if((blocking[i]>ms))
 191         buttons &= ~(1<<i);
 192       #else
 193       if((blocking>ms))
 194         buttons &= ~(1<<i);
 195       #endif
 196     }
 197     if((buttons==oldbuttons) &&  ((millis() - previous_millis_lcd) < LCD_UPDATE_INTERVAL)   )
 198       return;
 199     oldbuttons=buttons;
 200   #else
 201
 202     if(((millis() - previous_millis_lcd) < LCD_UPDATE_INTERVAL)   )
 203       return;
 204   #endif
 205
 206   previous_millis_lcd=millis();
 207   menu.update();
 208 }
 209 #ifdef ULTIPANEL
 210
 211
 212 void buttons_init()
 213 {
 214   #ifdef NEWPANEL
 215     pinMode(BTN_EN1,INPUT);
 216     pinMode(BTN_EN2,INPUT);
 217     pinMode(BTN_ENC,INPUT);
 218     pinMode(SDCARDDETECT,INPUT);
 219     WRITE(BTN_EN1,HIGH);
 220     WRITE(BTN_EN2,HIGH);
 221     WRITE(BTN_ENC,HIGH);
 222     #if (SDCARDDETECT > -1)
 223     {
 224       WRITE(SDCARDDETECT,HIGH);
 225     }
 226     #endif
 227   #else
 228     pinMode(SHIFT_CLK,OUTPUT);
 229     pinMode(SHIFT_LD,OUTPUT);
 230     pinMode(SHIFT_EN,OUTPUT);
 231     pinMode(SHIFT_OUT,INPUT);
 232     WRITE(SHIFT_OUT,HIGH);
 233     WRITE(SHIFT_LD,HIGH);
 234     WRITE(SHIFT_EN,LOW);
 235   #endif
 236 }
 237
 238
 239 void buttons_check()
 240 {
 241
 242   #ifdef NEWPANEL
 243     uint8_t newbutton=0;
 244     if(READ(BTN_EN1)==0)  newbutton|=EN_A;
 245     if(READ(BTN_EN2)==0)  newbutton|=EN_B;
 246     if((blocking<millis()) &&(READ(BTN_ENC)==0))
 247       newbutton|=EN_C;
 248     buttons=newbutton;
 249   #else   //read it from the shift register
 250     uint8_t newbutton=0;
 251     WRITE(SHIFT_LD,LOW);
 252     WRITE(SHIFT_LD,HIGH);
 253     unsigned char tmp_buttons=0;
 254     for(int8_t i=0;i<8;i++)
 255     {
 256       newbutton = newbutton>>1;
 257       if(READ(SHIFT_OUT))
 258         newbutton|=(1<<7);
 259       WRITE(SHIFT_CLK,HIGH);
 260       WRITE(SHIFT_CLK,LOW);
 261     }
 262     buttons=~newbutton; //invert it, because a pressed switch produces a logical 0
 263   #endif
 264
 265   //manage encoder rotation
 266   char enc=0;
 267   if(buttons&EN_A)
 268     enc|=(1<<0);
 269   if(buttons&EN_B)
 270     enc|=(1<<1);
 271   if(enc!=lastenc)
 272         {
 273     switch(enc)
 274     {
 275     case encrot0:
 276       if(lastenc==encrot3)
 277         encoderpos++;
 278       else if(lastenc==encrot1)
 279         encoderpos--;
 280       break;
 281     case encrot1:
 282       if(lastenc==encrot0)
 283         encoderpos++;
 284       else if(lastenc==encrot2)
 285         encoderpos--;
 286       break;
 287     case encrot2:
 288       if(lastenc==encrot1)
 289         encoderpos++;
 290       else if(lastenc==encrot3)
 291         encoderpos--;
 292       break;
 293     case encrot3:
 294       if(lastenc==encrot2)
 295         encoderpos++;
 296       else if(lastenc==encrot0)
 297         encoderpos--;
 298       break;
 299     default:
 300       ;
 301     }
 302   }
 303   lastenc=enc;
 304 }
 305
 306 #endif
 307
 308 MainMenu::MainMenu()
 309 {
 310   status=Main_Status;
 311   displayStartingRow=0;
 312   activeline=0;
 313   force_lcd_update=true;
 314   linechanging=false;
 315   tune=false;
 316 }
 317
 318 void MainMenu::showStatus()
 319 {
 320 #if LCD_HEIGHT==4
 321   static int olddegHotEnd0=-1;
 322   static int oldtargetHotEnd0=-1;
 323   //force_lcd_update=true;
 324   if(force_lcd_update)  //initial display of content
 325   {
 326     encoderpos=feedmultiply;
 327     clear();
 328     lcd.setCursor(0,0);lcdprintPGM("\002---/---\001 ");
 329     #if defined BED_USES_THERMISTOR || defined BED_USES_AD595
 330       lcd.setCursor(10,0);lcdprintPGM("B---/---\001 ");
 331     #elif EXTRUDERS > 1
 332       lcd.setCursor(10,0);lcdprintPGM("\002---/---\001 ");
 333     #endif
 334   }
 335
 336   int tHotEnd0=intround(degHotend0());
 337   if((tHotEnd0!=olddegHotEnd0)||force_lcd_update)
 338   {
 339     lcd.setCursor(1,0);
 340     lcd.print(ftostr3(tHotEnd0));
 341     olddegHotEnd0=tHotEnd0;
 342   }
 343   int ttHotEnd0=intround(degTargetHotend0());
 344   if((ttHotEnd0!=oldtargetHotEnd0)||force_lcd_update)
 345   {
 346     lcd.setCursor(5,0);
 347     lcd.print(ftostr3(ttHotEnd0));
 348     oldtargetHotEnd0=ttHotEnd0;
 349   }
 350   #if defined BED_USES_THERMISTOR || defined BED_USES_AD595
 351     static int oldtBed=-1;
 352     static int oldtargetBed=-1;
 353     int tBed=intround(degBed());
 354     if((tBed!=oldtBed)||force_lcd_update)
 355     {
 356       lcd.setCursor(11,0);
 357       lcd.print(ftostr3(tBed));
 358       oldtBed=tBed;
 359     }
 360     int targetBed=intround(degTargetBed());
 361     if((targetBed!=oldtargetBed)||force_lcd_update)
 362     {
 363       lcd.setCursor(15,0);
 364       lcd.print(ftostr3(targetBed));
 365       oldtargetBed=targetBed;
 366     }
 367   #elif EXTRUDERS > 1
 368     static int olddegHotEnd1=-1;
 369     static int oldtargetHotEnd1=-1;
 370     int tHotEnd1=intround(degHotend1());
 371     if((tHotEnd1!=olddegHotEnd1)||force_lcd_update)
 372     {
 373       lcd.setCursor(11,0);
 374       lcd.print(ftostr3(tHotEnd1));
 375       olddegHotEnd1=tHotEnd1;
 376     }
 377     int ttHotEnd1=intround(degTargetHotend1());
 378     if((ttHotEnd1!=oldtargetHotEnd1)||force_lcd_update)
 379     {
 380       lcd.setCursor(15,0);
 381       lcd.print(ftostr3(ttHotEnd1));
 382       oldtargetHotEnd1=ttHotEnd1;
 383     }
 384   #endif
 385   //starttime=2;
 386   static uint16_t oldtime=0;
 387   if(starttime!=0)
 388   {
 389     lcd.setCursor(0,1);
 390     uint16_t time=millis()/60000-starttime/60000;
 391
 392     if(starttime!=oldtime)
 393     {
 394       lcd.print(itostr2(time/60));lcdprintPGM("h ");lcd.print(itostr2(time%60));lcdprintPGM("m");
 395       oldtime=time;
 396     }
 397   }
 398   static int oldzpos=0;
 399   int currentz=current_position[2]*100;
 400   if((currentz!=oldzpos)||force_lcd_update)
 401   {
 402     lcd.setCursor(10,1);
 403     lcdprintPGM("Z:");lcd.print(ftostr52(current_position[2]));
 404     oldzpos=currentz;
 405   }
 406
 407   static int oldfeedmultiply=0;
 408   int curfeedmultiply=feedmultiply;
 409
 410   if(feedmultiplychanged == true) {
 411     feedmultiplychanged = false;
 412     encoderpos = curfeedmultiply;
 413   }
 414
 415   if(encoderpos!=curfeedmultiply||force_lcd_update)
 416   {
 417    curfeedmultiply=encoderpos;
 418    if(curfeedmultiply<10)
 419      curfeedmultiply=10;
 420    if(curfeedmultiply>999)
 421      curfeedmultiply=999;
 422    feedmultiply=curfeedmultiply;
 423    encoderpos=curfeedmultiply;
 424   }
 425
 426   if((curfeedmultiply!=oldfeedmultiply)||force_lcd_update)
 427   {
 428    oldfeedmultiply=curfeedmultiply;
 429    lcd.setCursor(0,2);
 430    lcd.print(itostr3(curfeedmultiply));lcdprintPGM("% ");
 431   }
 432
 433   if(messagetext[0]!='\0')
 434   {
 435     lcd.setCursor(0,LCD_HEIGHT-1);
 436     lcd.print(messagetext);
 437     uint8_t n=strlen(messagetext);
 438     for(int8_t i=0;i<LCD_WIDTH-n;i++)
 439       lcd.print(" ");
 440     messagetext[0]='\0';
 441   }
 442 #ifdef SDSUPPORT
 443   static uint8_t oldpercent=101;
 444   uint8_t percent=card.percentDone();
 445   if(oldpercent!=percent ||force_lcd_update)
 446   {
 447      lcd.setCursor(10,2);
 448     lcd.print(itostr3((int)percent));
 449     lcdprintPGM("%SD");
 450   }
 451 #endif
 452 #else //smaller LCDS----------------------------------
 453   static int olddegHotEnd0=-1;
 454   static int oldtargetHotEnd0=-1;
 455   if(force_lcd_update)  //initial display of content
 456   {
 457     encoderpos=feedmultiply;
 458     lcd.setCursor(0,0);lcdprintPGM("\002---/---\001 ");
 459   }
 460
 461   int tHotEnd0=intround(degHotend0());
 462   int ttHotEnd0=intround(degTargetHotend0());
 463
 464
 465   if((abs(tHotEnd0-olddegHotEnd0)>1)||force_lcd_update)
 466   {
 467     lcd.setCursor(1,0);
 468     lcd.print(ftostr3(tHotEnd0));
 469     olddegHotEnd0=tHotEnd0;
 470   }
 471   if((ttHotEnd0!=oldtargetHotEnd0)||force_lcd_update)
 472   {
 473     lcd.setCursor(5,0);
 474     lcd.print(ftostr3(ttHotEnd0));
 475     oldtargetHotEnd0=ttHotEnd0;
 476   }
 477
 478   if(messagetext[0]!='\0')
 479   {
 480     lcd.setCursor(0,LCD_HEIGHT-1);
 481     lcd.print(messagetext);
 482     uint8_t n=strlen(messagetext);
 483     for(int8_t i=0;i<LCD_WIDTH-n;i++)
 484       lcd.print(" ");
 485     messagetext[0]='\0';
 486   }
 487
 488 #endif
 489   force_lcd_update=false;
 490 }
 491
 492 enum {ItemP_exit, ItemP_autostart,ItemP_disstep,ItemP_home, ItemP_origin, ItemP_preheat_pla, ItemP_preheat_abs, ItemP_cooldown,/*ItemP_extrude,*/ItemP_move};
 493
 494 //any action must not contain a ',' character anywhere, or this breaks:
 495 #define MENUITEM(repaint_action, click_action) \
 496   {\
 497     if(force_lcd_update)  { lcd.setCursor(0,line);  repaint_action; } \
 498     if((activeline==line) && CLICKED) {click_action} \
 499   }
 500
 501 void MainMenu::showPrepare()
 502 {
 503 #ifdef ULTIPANEL
 504  uint8_t line=0;
 505  clearIfNecessary();
 506  for(int8_t i=lineoffset;i<lineoffset+LCD_HEIGHT;i++)
 507  {
 508    //Serial.println((int)(line-lineoffset));
 509   switch(i)
 510   {
 511     case ItemP_exit:
 512       MENUITEM(  lcdprintPGM(MSG_MAIN)  ,  BLOCK;status=Main_Menu;beepshort(); ) ;
 513       break;
 514     case ItemP_autostart:
 515       MENUITEM(  lcdprintPGM(MSG_AUTOSTART)  ,  BLOCK;
 516 #ifdef SDSUPPORT
 517           card.lastnr=0;card.setroot();card.checkautostart(true);
 518 #endif
 519           beepshort(); ) ;
 520       break;
 521     case ItemP_disstep:
 522       MENUITEM(  lcdprintPGM(MSG_DISABLE_STEPPERS)  ,  BLOCK;enquecommand("M84");beepshort(); ) ;
 523       break;
 524     case ItemP_home:
 525       MENUITEM(  lcdprintPGM(MSG_AUTO_HOME)  ,  BLOCK;enquecommand("G28");beepshort(); ) ;
 526       break;
 527     case ItemP_origin:
 528       MENUITEM(  lcdprintPGM(MSG_SET_ORIGIN)  ,  BLOCK;enquecommand("G92 X0 Y0 Z0");beepshort(); ) ;
 529       break;
 530     case ItemP_preheat_pla:
 531       MENUITEM(  lcdprintPGM(MSG_PREHEAT_PLA)  ,  BLOCK;setTargetHotend0(PLA_PREHEAT_HOTEND_TEMP);setTargetBed(PLA_PREHEAT_HPB_TEMP);
 532       #if FAN_PIN > -1
 533         analogWrite(FAN_PIN, PLA_PREHEAT_FAN_SPEED);
 534       #endif
 535       beepshort(); );
 536       break;
 537     case ItemP_preheat_abs:
 538       MENUITEM(  lcdprintPGM(MSG_PREHEAT_ABS)  ,  BLOCK;setTargetHotend0(ABS_PREHEAT_HOTEND_TEMP);setTargetBed(ABS_PREHEAT_HPB_TEMP);
 539       #if FAN_PIN > -1
 540         analogWrite(FAN_PIN, ABS_PREHEAT_FAN_SPEED);
 541       #endif
 542       beepshort(); );
 543       break;
 544     case ItemP_cooldown:
 545       MENUITEM(  lcdprintPGM(MSG_COOLDOWN)  ,  BLOCK;setTargetHotend0(0);setTargetHotend1(0);setTargetHotend2(0);setTargetBed(0);beepshort(); ) ;
 546       break;
 547 //    case ItemP_extrude:
 548   //    MENUITEM(  lcdprintPGM(" Extrude")  ,  BLOCK;enquecommand("G92 E0");enquecommand("G1 F700 E50");beepshort(); ) ;
 549     //  break;
 550     case ItemP_move:
 551       MENUITEM(  lcdprintPGM(MSG_MOVE_AXIS) , BLOCK;status=Sub_PrepareMove;beepshort(); );
 552       break;
 553         default:
 554       break;
 555   }
 556   line++;
 557  }
 558  updateActiveLines(ItemP_move,encoderpos);
 559 #endif
 560 }
 561
 562 enum {
 563   ItemAM_exit,
 564   ItemAM_X, ItemAM_Y, ItemAM_Z, ItemAM_E
 565 };
 566
 567 void MainMenu::showAxisMove()
 568 {
 569    uint8_t line=0;
 570    int oldencoderpos=0;
 571    clearIfNecessary();
 572    for(int8_t i=lineoffset;i<lineoffset+LCD_HEIGHT;i++)
 573    {
 574      switch(i)
 575       {
 576           case ItemAM_exit:
 577           MENUITEM(  lcdprintPGM(MSG_PREPARE_ALT)  ,  BLOCK;status=Main_Menu;beepshort(); ) ;
 578           break;
 579           case ItemAM_X:
 580           {
 581                   //oldencoderpos=0;
 582                   if(force_lcd_update)
 583                   {
 584                     lcd.setCursor(0,line);lcdprintPGM(" X:");
 585                     lcd.setCursor(11,line);lcd.print(ftostr52(current_position[X_AXIS]));
 586                   }
 587
 588                   if((activeline!=line) )
 589                   break;
 590
 591                   if(CLICKED)
 592                   {
 593                     linechanging=!linechanging;
 594                     if(linechanging)
 595                     {
 596                         enquecommand("G91");
 597                     }
 598                     else
 599                     {
 600                       enquecommand("G90");
 601                       encoderpos=activeline*lcdslow;
 602                       beepshort();
 603                     }
 604                     BLOCK;
 605                   }
 606                   if(linechanging)
 607                   {
 608                     if (encoderpos >0)
 609                    {
 610                         enquecommand("G1 F700 X0.1");
 611                         oldencoderpos=encoderpos;
 612                         encoderpos=0;
 613                     }
 614
 615                     else if (encoderpos < 0)
 616                     {
 617                         enquecommand("G1 F700 X-0.1");
 618                         oldencoderpos=encoderpos;
 619                         encoderpos=0;
 620                     }
 621                     lcd.setCursor(11,line);lcd.print(ftostr52(current_position[X_AXIS]));
 622                   }
 623           }
 624           break;
 625           case ItemAM_Y:
 626             {
 627                   if(force_lcd_update)
 628                   {
 629                     lcd.setCursor(0,line);lcdprintPGM(" Y:");
 630                     lcd.setCursor(11,line);lcd.print(ftostr52(current_position[Y_AXIS]));
 631                   }
 632
 633                   if((activeline!=line) )
 634                   break;
 635
 636                   if(CLICKED)
 637                   {
 638                     linechanging=!linechanging;
 639                     if(linechanging)
 640                     {
 641                         enquecommand("G91");
 642                     }
 643                     else
 644                     {
 645                       enquecommand("G90");
 646                       encoderpos=activeline*lcdslow;
 647                       beepshort();
 648                     }
 649                     BLOCK;
 650                   }
 651                   if(linechanging)
 652                   {
 653                     if (encoderpos >0)
 654                    {
 655                         enquecommand("G1 F700 Y0.1");
 656                         oldencoderpos=encoderpos;
 657                         encoderpos=0;
 658                     }
 659
 660                     else if (encoderpos < 0)
 661                     {
 662                         enquecommand("G1 F700 Y-0.1");
 663                         oldencoderpos=encoderpos;
 664                         encoderpos=0;
 665                     }
 666                     lcd.setCursor(11,line);lcd.print(ftostr52(current_position[Y_AXIS]));
 667                   }
 668           }
 669           break;
 670           case ItemAM_Z:
 671           {
 672                   if(force_lcd_update)
 673                   {
 674                     lcd.setCursor(0,line);lcdprintPGM(" Z:");
 675                     lcd.setCursor(11,line);lcd.print(ftostr52(current_position[Z_AXIS]));
 676                   }
 677
 678                   if((activeline!=line) )
 679                   break;
 680
 681                    if(CLICKED)
 682                   {
 683                     linechanging=!linechanging;
 684                     if(linechanging)
 685                     {
 686                         enquecommand("G91");
 687                     }
 688                     else
 689                     {
 690                       enquecommand("G90");
 691                       encoderpos=activeline*lcdslow;
 692                       beepshort();
 693                     }
 694                     BLOCK;
 695                   }
 696                   if(linechanging)
 697                   {
 698                     if (encoderpos >0)
 699                    {
 700                         enquecommand("G1 F70 Z0.1");
 701                         oldencoderpos=encoderpos;
 702                         encoderpos=0;
 703                     }
 704
 705                     else if (encoderpos < 0)
 706                     {
 707                         enquecommand("G1 F70 Z-0.1");
 708                         oldencoderpos=encoderpos;
 709                         encoderpos=0;
 710                     }
 711                     lcd.setCursor(11,line);lcd.print(ftostr52(current_position[Z_AXIS]));
 712                   }
 713           }
 714           break;
 715           case ItemAM_E:
 716           // ErikDB: TODO: this length should be changed for volumetric.
 717           MENUITEM(  lcdprintPGM(MSG_EXTRUDE)  ,  BLOCK;enquecommand("G92 E0");enquecommand("G1 F700 E5");beepshort(); ) ;
 718           break;
 719           default:
 720           break;
 721       }
 722       line++;
 723    }
 724    updateActiveLines(ItemAM_E,encoderpos);
 725 }
 726
 727 enum {ItemT_exit,ItemT_speed,ItemT_flow,ItemT_nozzle,
 728 #if (HEATER_BED_PIN > -1)
 729 ItemT_bed,
 730 #endif
 731 ItemT_fan};
 732
 733 void MainMenu::showTune()
 734 {
 735   uint8_t line=0;
 736   clearIfNecessary();
 737  for(int8_t i=lineoffset;i<lineoffset+LCD_HEIGHT;i++)
 738  {
 739    //Serial.println((int)(line-lineoffset));
 740   switch(i)
 741   {
 742   case ItemT_exit:
 743       MENUITEM(  lcdprintPGM(MSG_MAIN)  ,  BLOCK;status=Main_Menu;beepshort(); ) ;
 744       break;
 745   case ItemT_speed:
 746     {
 747       if(force_lcd_update)
 748       {
 749         lcd.setCursor(0,line);lcdprintPGM(MSG_SPEED);
 750         lcd.setCursor(13,line);lcd.print(ftostr3(feedmultiply));
 751       }
 752
 753       if((activeline!=line) )
 754         break;
 755
 756       if(CLICKED) //AnalogWrite(FAN_PIN,  fanpwm);
 757       {
 758         linechanging=!linechanging;
 759         if(linechanging)
 760         {
 761             encoderpos=feedmultiply;
 762         }
 763         else
 764         {
 765           encoderpos=activeline*lcdslow;
 766           beepshort();
 767         }
 768         BLOCK;
 769       }
 770       if(linechanging)
 771       {
 772         if(encoderpos<1) encoderpos=1;
 773         if(encoderpos>400) encoderpos=400;
 774         feedmultiply = encoderpos;
 775         feedmultiplychanged=true;
 776         lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
 777       }
 778
 779     }break;
 780     case ItemT_nozzle:
 781       {
 782         if(force_lcd_update)
 783         {
 784           lcd.setCursor(0,line);lcdprintPGM(MSG_NOZZLE);
 785           lcd.setCursor(13,line);lcd.print(ftostr3(intround(degTargetHotend0())));
 786         }
 787
 788         if((activeline!=line) )
 789           break;
 790
 791         if(CLICKED)
 792         {
 793           linechanging=!linechanging;
 794           if(linechanging)
 795           {
 796               encoderpos=intround(degTargetHotend0());
 797           }
 798           else
 799           {
 800             setTargetHotend0(encoderpos);
 801             encoderpos=activeline*lcdslow;
 802             beepshort();
 803           }
 804           BLOCK;
 805         }
 806         if(linechanging)
 807         {
 808           if(encoderpos<0) encoderpos=0;
 809           if(encoderpos>260) encoderpos=260;
 810           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
 811         }
 812       }break;
 813       #if (HEATER_BED_PIN > -1)
 814       case ItemT_bed:
 815       {
 816         if(force_lcd_update)
 817         {
 818           lcd.setCursor(0,line);lcdprintPGM(MSG_BED);
 819           lcd.setCursor(13,line);lcd.print(ftostr3(intround(degTargetBed())));
 820         }
 821
 822         if((activeline!=line) )
 823           break;
 824
 825         if(CLICKED)
 826         {
 827           linechanging=!linechanging;
 828           if(linechanging)
 829           {
 830               encoderpos=intround(degTargetBed());
 831           }
 832           else
 833           {
 834             setTargetBed(encoderpos);
 835             encoderpos=activeline*lcdslow;
 836             beepshort();
 837           }
 838           BLOCK;
 839         }
 840         if(linechanging)
 841         {
 842           if(encoderpos<0) encoderpos=0;
 843           if(encoderpos>260) encoderpos=260;
 844           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
 845         }
 846       }break;
 847       #endif
 848
 849
 850       case ItemT_fan:
 851       {
 852         if(force_lcd_update)
 853         {
 854           lcd.setCursor(0,line);lcdprintPGM(MSG_FAN_SPEED);
 855           lcd.setCursor(13,line);lcd.print(ftostr3(FanSpeed));
 856         }
 857
 858         if((activeline!=line) )
 859           break;
 860
 861         if(CLICKED) //nalogWrite(FAN_PIN,  fanpwm);
 862         {
 863           linechanging=!linechanging;
 864           if(linechanging)
 865           {
 866               encoderpos=FanSpeed;
 867           }
 868           else
 869           {
 870             encoderpos=activeline*lcdslow;
 871             beepshort();
 872           }
 873           BLOCK;
 874         }
 875         if(linechanging)
 876         {
 877           if(encoderpos<0) encoderpos=0;
 878           if(encoderpos>255) encoderpos=255;
 879           FanSpeed=encoderpos;
 880             analogWrite(FAN_PIN,  FanSpeed);
 881           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
 882         }
 883
 884       }break;
 885       case ItemT_flow://axis_steps_per_unit[i] = code_value();
 886          {
 887       if(force_lcd_update)
 888         {
 889           lcd.setCursor(0,line);lcdprintPGM(MSG_FLOW);
 890           lcd.setCursor(13,line);lcd.print(ftostr52(axis_steps_per_unit[E_AXIS]));
 891         }
 892
 893         if((activeline!=line) )
 894           break;
 895
 896         if(CLICKED)
 897         {
 898           linechanging=!linechanging;
 899           if(linechanging)
 900           {
 901               encoderpos=(long)(axis_steps_per_unit[E_AXIS]*100.0);
 902           }
 903           else
 904           {
 905             float factor=float(encoderpos)/100.0/float(axis_steps_per_unit[E_AXIS]);
 906             position[E_AXIS]=lround(position[E_AXIS]*factor);
 907             //current_position[E_AXIS]*=factor;
 908             axis_steps_per_unit[E_AXIS]= encoderpos/100.0;
 909             encoderpos=activeline*lcdslow;
 910
 911           }
 912           BLOCK;
 913           beepshort();
 914         }
 915         if(linechanging)
 916         {
 917           if(encoderpos<5) encoderpos=5;
 918           if(encoderpos>999999) encoderpos=999999;
 919           lcd.setCursor(13,line);lcd.print(ftostr52(encoderpos/100.0));
 920         }
 921
 922       }break;
 923     default:
 924       break;
 925   }
 926   line++;
 927  }
 928  updateActiveLines(ItemT_fan,encoderpos);
 929 }
 930
 931 //does not work
 932 // #define MENUCHANGEITEM(repaint_action,  enter_action, accept_action,  change_action) \
 933 //   {\
 934 //     if(force_lcd_update)  { lcd.setCursor(0,line);  repaint_action; } \
 935 //     if(activeline==line)  \
 936 //     { \
 937 //       if(CLICKED) \
 938 //       { \
 939 //         linechanging=!linechanging; \
 940 //         if(linechanging)  {enter_action;} \
 941 //         else {accept_action;} \
 942 //       }  \
 943 //       else \
 944 //       if(linechanging) {change_action};}\
 945 //   }
 946 //
 947
 948 enum {
 949   ItemCT_exit,ItemCT_nozzle0,
 950 #ifdef AUTOTEMP
 951   ItemCT_autotempactive,
 952   ItemCT_autotempmin,ItemCT_autotempmax,ItemCT_autotempfact,
 953 #endif
 954 #if EXTRUDERS > 1
 955   ItemCT_nozzle1,
 956 #endif
 957 #if EXTRUDERS > 2
 958   ItemCT_nozzle2,
 959 #endif
 960 #if defined BED_USES_THERMISTOR || defined BED_USES_AD595
 961 ItemCT_bed,
 962 #endif
 963   ItemCT_fan,
 964   ItemCT_PID_P,ItemCT_PID_I,ItemCT_PID_D,ItemCT_PID_C
 965 };
 966
 967 void MainMenu::showControlTemp()
 968 {
 969   uint8_t line=0;
 970  clearIfNecessary();
 971  for(int8_t i=lineoffset;i<lineoffset+LCD_HEIGHT;i++)
 972  {
 973   switch(i)
 974   {
 975     case ItemCT_exit:
 976       MENUITEM(  lcdprintPGM(MSG_CONTROL)  ,  BLOCK;status=Main_Control;beepshort(); ) ;
 977       break;
 978     case ItemCT_nozzle0:
 979       {
 980         if(force_lcd_update)
 981         {
 982           lcd.setCursor(0,line);lcdprintPGM(MSG_NOZZLE);
 983           lcd.setCursor(13,line);lcd.print(ftostr3(intround(degTargetHotend0())));
 984         }
 985
 986         if((activeline!=line) )
 987           break;
 988
 989         if(CLICKED)
 990         {
 991           linechanging=!linechanging;
 992           if(linechanging)
 993           {
 994               encoderpos=intround(degTargetHotend0());
 995           }
 996           else
 997           {
 998             setTargetHotend0(encoderpos);
 999             encoderpos=activeline*lcdslow;
1000             beepshort();
1001           }
1002           BLOCK;
1003         }
1004         if(linechanging)
1005         {
1006           if(encoderpos<0) encoderpos=0;
1007           if(encoderpos>260) encoderpos=260;
1008           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1009         }
1010
1011       }break;
1012     #if EXTRUDERS > 1
1013     case ItemCT_nozzle1:
1014       {
1015         if(force_lcd_update)
1016         {
1017           lcd.setCursor(0,line);lcdprintPGM(MSG_NOZZLE1);
1018           lcd.setCursor(13,line);lcd.print(ftostr3(intround(degTargetHotend1())));
1019         }
1020
1021         if((activeline!=line) )
1022           break;
1023
1024         if(CLICKED)
1025         {
1026           linechanging=!linechanging;
1027           if(linechanging)
1028           {
1029               encoderpos=intround(degTargetHotend1());
1030           }
1031           else
1032           {
1033             setTargetHotend1(encoderpos);
1034             encoderpos=activeline*lcdslow;
1035             beepshort();
1036           }
1037           BLOCK;
1038         }
1039         if(linechanging)
1040         {
1041           if(encoderpos<0) encoderpos=0;
1042           if(encoderpos>260) encoderpos=260;
1043           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1044         }
1045
1046       }break;
1047     #endif
1048     #if EXTRUDERS > 2
1049     case ItemCT_nozzle2:
1050       {
1051         if(force_lcd_update)
1052         {
1053           lcd.setCursor(0,line);lcdprintPGM(MSG_NOZZLE2);
1054           lcd.setCursor(13,line);lcd.print(ftostr3(intround(degTargetHotend2())));
1055         }
1056
1057         if((activeline!=line) )
1058           break;
1059
1060         if(CLICKED)
1061         {
1062           linechanging=!linechanging;
1063           if(linechanging)
1064           {
1065               encoderpos=intround(degTargetHotend2());
1066           }
1067           else
1068           {
1069             setTargetHotend1(encoderpos);
1070             encoderpos=activeline*lcdslow;
1071             beepshort();
1072           }
1073           BLOCK;
1074         }
1075         if(linechanging)
1076         {
1077           if(encoderpos<0) encoderpos=0;
1078           if(encoderpos>260) encoderpos=260;
1079           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1080         }
1081
1082       }break;
1083     #endif
1084     #ifdef AUTOTEMP
1085     case ItemCT_autotempmin:
1086       {
1087         if(force_lcd_update)
1088         {
1089           lcd.setCursor(0,line);lcdprintPGM(MSG_MIN);
1090           lcd.setCursor(13,line);lcd.print(ftostr3(autotemp_min));
1091         }
1092
1093         if((activeline!=line) )
1094           break;
1095
1096         if(CLICKED)
1097         {
1098           linechanging=!linechanging;
1099           if(linechanging)
1100           {
1101               encoderpos=intround(autotemp_min);
1102           }
1103           else
1104           {
1105             autotemp_min=encoderpos;
1106             encoderpos=activeline*lcdslow;
1107             beepshort();
1108           }
1109           BLOCK;
1110         }
1111         if(linechanging)
1112         {
1113           if(encoderpos<0) encoderpos=0;
1114           if(encoderpos>260) encoderpos=260;
1115           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1116         }
1117
1118       }break;
1119     case ItemCT_autotempmax:
1120       {
1121         if(force_lcd_update)
1122         {
1123           lcd.setCursor(0,line);lcdprintPGM(MSG_MAX);
1124           lcd.setCursor(13,line);lcd.print(ftostr3(autotemp_max));
1125         }
1126
1127         if((activeline!=line) )
1128           break;
1129
1130         if(CLICKED)
1131         {
1132           linechanging=!linechanging;
1133           if(linechanging)
1134           {
1135               encoderpos=intround(autotemp_max);
1136           }
1137           else
1138           {
1139             autotemp_max=encoderpos;
1140             encoderpos=activeline*lcdslow;
1141             beepshort();
1142           }
1143           BLOCK;
1144         }
1145         if(linechanging)
1146         {
1147           if(encoderpos<0) encoderpos=0;
1148           if(encoderpos>260) encoderpos=260;
1149           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1150         }
1151
1152       }break;
1153     case ItemCT_autotempfact:
1154       {
1155         if(force_lcd_update)
1156         {
1157           lcd.setCursor(0,line);lcdprintPGM(MSG_FACTOR);
1158           lcd.setCursor(13,line);lcd.print(ftostr32(autotemp_factor));
1159         }
1160
1161         if((activeline!=line) )
1162           break;
1163
1164         if(CLICKED)
1165         {
1166           linechanging=!linechanging;
1167           if(linechanging)
1168           {
1169               encoderpos=intround(autotemp_factor*100);
1170           }
1171           else
1172           {
1173             autotemp_max=encoderpos;
1174             encoderpos=activeline*lcdslow;
1175             beepshort();
1176           }
1177           BLOCK;
1178         }
1179         if(linechanging)
1180         {
1181           if(encoderpos<0) encoderpos=0;
1182           if(encoderpos>99) encoderpos=99;
1183           lcd.setCursor(13,line);lcd.print(ftostr32(encoderpos/100.));
1184         }
1185
1186       }break;
1187     case ItemCT_autotempactive:
1188       {
1189         if(force_lcd_update)
1190         {
1191           lcd.setCursor(0,line);lcdprintPGM(MSG_AUTOTEMP);
1192           lcd.setCursor(13,line);
1193           if(autotemp_enabled)
1194             lcdprintPGM(MSG_ON);
1195           else
1196             lcdprintPGM(MSG_OFF);
1197         }
1198
1199         if((activeline!=line) )
1200           break;
1201
1202         if(CLICKED)
1203         {
1204           autotemp_enabled=!autotemp_enabled;
1205           lcd.setCursor(13,line);
1206           if(autotemp_enabled)
1207             lcdprintPGM(MSG_ON);
1208           else
1209             lcdprintPGM(MSG_OFF);
1210           BLOCK;
1211         }
1212
1213       }break;
1214     #endif //autotemp
1215     #if defined BED_USES_THERMISTOR || defined BED_USES_AD595
1216     case ItemCT_bed:
1217       {
1218         if(force_lcd_update)
1219         {
1220           lcd.setCursor(0,line);lcdprintPGM(MSG_BED);
1221           lcd.setCursor(13,line);lcd.print(ftostr3(intround(degTargetBed())));
1222         }
1223
1224         if((activeline!=line) )
1225           break;
1226
1227         if(CLICKED)
1228         {
1229           linechanging=!linechanging;
1230           if(linechanging)
1231           {
1232               encoderpos=intround(degTargetBed());
1233           }
1234           else
1235           {
1236             setTargetBed(encoderpos);
1237             encoderpos=activeline*lcdslow;
1238             beepshort();
1239           }
1240           BLOCK;
1241         }
1242         if(linechanging)
1243         {
1244           if(encoderpos<0) encoderpos=0;
1245           if(encoderpos>260) encoderpos=260;
1246           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1247         }
1248       }break;
1249     #endif
1250     case ItemCT_fan:
1251       {
1252         if(force_lcd_update)
1253         {
1254           lcd.setCursor(0,line);lcdprintPGM(MSG_FAN_SPEED);
1255           lcd.setCursor(13,line);lcd.print(ftostr3(FanSpeed));
1256         }
1257
1258         if((activeline!=line) )
1259           break;
1260
1261         if(CLICKED) //nalogWrite(FAN_PIN,  fanpwm);
1262         {
1263           linechanging=!linechanging;
1264           if(linechanging)
1265           {
1266               encoderpos=FanSpeed;
1267           }
1268           else
1269           {
1270             encoderpos=activeline*lcdslow;
1271             beepshort();
1272           }
1273           BLOCK;
1274         }
1275         if(linechanging)
1276         {
1277           if(encoderpos<0) encoderpos=0;
1278           if(encoderpos>255) encoderpos=255;
1279           FanSpeed=encoderpos;
1280             analogWrite(FAN_PIN,  FanSpeed);
1281           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1282         }
1283
1284       }break;
1285     #ifdef PIDTEMP
1286     case ItemCT_PID_P:
1287       {
1288       if(force_lcd_update)
1289         {
1290           lcd.setCursor(0,line);lcdprintPGM(" PID-P: ");
1291           lcd.setCursor(13,line);lcd.print(itostr4(Kp));
1292         }
1293
1294         if((activeline!=line) )
1295           break;
1296
1297         if(CLICKED)
1298         {
1299           linechanging=!linechanging;
1300           if(linechanging)
1301           {
1302               encoderpos=(long)Kp;
1303           }
1304           else
1305           {
1306             Kp= encoderpos;
1307             encoderpos=activeline*lcdslow;
1308
1309           }
1310           BLOCK;
1311           beepshort();
1312         }
1313         if(linechanging)
1314         {
1315           if(encoderpos<1) encoderpos=1;
1316           if(encoderpos>9990) encoderpos=9990;
1317           lcd.setCursor(13,line);lcd.print(itostr4(encoderpos));
1318         }
1319
1320       }break;
1321     case ItemCT_PID_I:
1322       {
1323       if(force_lcd_update)
1324         {
1325           lcd.setCursor(0,line);lcdprintPGM(MSG_PID_I);
1326           lcd.setCursor(13,line);lcd.print(ftostr51(Ki/PID_dT));
1327         }
1328
1329         if((activeline!=line) )
1330           break;
1331
1332         if(CLICKED)
1333         {
1334           linechanging=!linechanging;
1335           if(linechanging)
1336           {
1337               encoderpos=(long)(Ki*10/PID_dT);
1338           }
1339           else
1340           {
1341             Ki= encoderpos/10.*PID_dT;
1342             encoderpos=activeline*lcdslow;
1343
1344           }
1345           BLOCK;
1346           beepshort();
1347         }
1348         if(linechanging)
1349         {
1350           if(encoderpos<0) encoderpos=0;
1351           if(encoderpos>9990) encoderpos=9990;
1352           lcd.setCursor(13,line);lcd.print(ftostr51(encoderpos/10.));
1353         }
1354
1355       }break;
1356     case ItemCT_PID_D:
1357       {
1358       if(force_lcd_update)
1359         {
1360           lcd.setCursor(0,line);lcdprintPGM(MSG_PID_D);
1361           lcd.setCursor(13,line);lcd.print(itostr4(Kd*PID_dT));
1362         }
1363
1364         if((activeline!=line) )
1365           break;
1366
1367
1368         if(CLICKED)
1369         {
1370           linechanging=!linechanging;
1371           if(linechanging)
1372           {
1373               encoderpos=(long)(Kd/5./PID_dT);
1374           }
1375           else
1376           {
1377             Kd= encoderpos;
1378             encoderpos=activeline*lcdslow;
1379
1380           }
1381           BLOCK;
1382           beepshort();
1383         }
1384         if(linechanging)
1385         {
1386           if(encoderpos<0) encoderpos=0;
1387           if(encoderpos>9990) encoderpos=9990;
1388           lcd.setCursor(13,line);lcd.print(itostr4(encoderpos));
1389         }
1390
1391       }break;
1392     case ItemCT_PID_C:
1393       #ifdef PID_ADD_EXTRUSION_RATE
1394       {
1395       if(force_lcd_update)
1396         {
1397           lcd.setCursor(0,line);lcdprintPGM(MSG_PID_C);
1398           lcd.setCursor(13,line);lcd.print(itostr3(Kc));
1399         }
1400
1401         if((activeline!=line) )
1402           break;
1403
1404         if(CLICKED)
1405         {
1406           linechanging=!linechanging;
1407           if(linechanging)
1408           {
1409               encoderpos=(long)Kc;
1410           }
1411           else
1412           {
1413             Kc= encoderpos;
1414             encoderpos=activeline*lcdslow;
1415
1416           }
1417           BLOCK;
1418           beepshort();
1419         }
1420         if(linechanging)
1421         {
1422           if(encoderpos<0) encoderpos=0;
1423           if(encoderpos>990) encoderpos=990;
1424           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1425         }
1426
1427       }
1428       #endif
1429     #endif
1430       break;
1431     default:
1432       break;
1433   }
1434   line++;
1435  }
1436  #ifdef PID_ADD_EXTRUSION_RATE
1437   updateActiveLines(ItemCT_PID_C,encoderpos);
1438  #else
1439   updateActiveLines(ItemCT_PID_D,encoderpos);
1440  #endif
1441 }
1442
1443
1444 enum {
1445   ItemCM_exit,
1446   ItemCM_acc, ItemCM_xyjerk,
1447   ItemCM_vmaxx, ItemCM_vmaxy, ItemCM_vmaxz, ItemCM_vmaxe,
1448   ItemCM_vtravmin,ItemCM_vmin,
1449   ItemCM_amaxx, ItemCM_amaxy, ItemCM_amaxz, ItemCM_amaxe,
1450   ItemCM_aret, ItemCM_xsteps,ItemCM_ysteps, ItemCM_zsteps, ItemCM_esteps
1451 };
1452
1453
1454
1455 void MainMenu::showControlMotion()
1456 {
1457  uint8_t line=0;
1458  clearIfNecessary();
1459  for(int8_t i=lineoffset;i<lineoffset+LCD_HEIGHT;i++)
1460  {
1461   switch(i)
1462   {
1463     case ItemCM_exit:
1464       MENUITEM(  lcdprintPGM(MSG_CONTROL)  ,  BLOCK;status=Main_Control;beepshort(); ) ;
1465       break;
1466     case ItemCM_acc:
1467     {
1468       if(force_lcd_update)
1469         {
1470           lcd.setCursor(0,line);lcdprintPGM(MSG_ACC);
1471           lcd.setCursor(13,line);lcd.print(itostr3(acceleration/100));lcdprintPGM("00");
1472         }
1473
1474         if((activeline!=line) )
1475           break;
1476
1477         if(CLICKED)
1478         {
1479           linechanging=!linechanging;
1480           if(linechanging)
1481           {
1482               encoderpos=(long)acceleration/100;
1483           }
1484           else
1485           {
1486             acceleration= encoderpos*100;
1487             encoderpos=activeline*lcdslow;
1488           }
1489           BLOCK;
1490           beepshort();
1491         }
1492         if(linechanging)
1493         {
1494           if(encoderpos<5) encoderpos=5;
1495           if(encoderpos>990) encoderpos=990;
1496           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcdprintPGM("00");
1497         }
1498
1499       }break;
1500     case ItemCM_xyjerk: //max_xy_jerk
1501       {
1502       if(force_lcd_update)
1503         {
1504           lcd.setCursor(0,line);lcdprintPGM(MSG_VXY_JERK);
1505           lcd.setCursor(13,line);lcd.print(itostr3(max_xy_jerk));
1506         }
1507
1508         if((activeline!=line) )
1509           break;
1510
1511         if(CLICKED)
1512         {
1513           linechanging=!linechanging;
1514           if(linechanging)
1515           {
1516               encoderpos=(long)max_xy_jerk;
1517           }
1518           else
1519           {
1520             max_xy_jerk= encoderpos;
1521             encoderpos=activeline*lcdslow;
1522
1523           }
1524           BLOCK;
1525           beepshort();
1526         }
1527         if(linechanging)
1528         {
1529           if(encoderpos<1) encoderpos=1;
1530           if(encoderpos>990) encoderpos=990;
1531           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1532         }
1533
1534       }break;
1535
1536     case ItemCM_vmaxx:
1537     case ItemCM_vmaxy:
1538     case ItemCM_vmaxz:
1539     case ItemCM_vmaxe:
1540       {
1541       if(force_lcd_update)
1542         {
1543           lcd.setCursor(0,line);lcdprintPGM(MSG_VMAX);
1544           if(i==ItemCM_vmaxx)lcdprintPGM(MSG_X);
1545           if(i==ItemCM_vmaxy)lcdprintPGM(MSG_Y);
1546           if(i==ItemCM_vmaxz)lcdprintPGM(MSG_Z);
1547           if(i==ItemCM_vmaxe)lcdprintPGM(MSG_E);
1548           lcd.setCursor(13,line);lcd.print(itostr3(max_feedrate[i-ItemCM_vmaxx]));
1549         }
1550
1551         if((activeline!=line) )
1552           break;
1553
1554         if(CLICKED)
1555         {
1556           linechanging=!linechanging;
1557           if(linechanging)
1558           {
1559               encoderpos=(long)max_feedrate[i-ItemCM_vmaxx];
1560           }
1561           else
1562           {
1563             max_feedrate[i-ItemCM_vmaxx]= encoderpos;
1564             encoderpos=activeline*lcdslow;
1565
1566           }
1567           BLOCK;
1568           beepshort();
1569         }
1570         if(linechanging)
1571         {
1572           if(encoderpos<1) encoderpos=1;
1573           if(encoderpos>990) encoderpos=990;
1574           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1575         }
1576
1577       }break;
1578
1579     case ItemCM_vmin:
1580     {
1581       if(force_lcd_update)
1582         {
1583           lcd.setCursor(0,line);lcdprintPGM(MSG_VMIN);
1584           lcd.setCursor(13,line);lcd.print(itostr3(minimumfeedrate));
1585         }
1586
1587         if((activeline!=line) )
1588           break;
1589
1590         if(CLICKED)
1591         {
1592           linechanging=!linechanging;
1593           if(linechanging)
1594           {
1595               encoderpos=(long)(minimumfeedrate);
1596           }
1597           else
1598           {
1599             minimumfeedrate= encoderpos;
1600             encoderpos=activeline*lcdslow;
1601
1602           }
1603           BLOCK;
1604           beepshort();
1605         }
1606         if(linechanging)
1607         {
1608           if(encoderpos<0) encoderpos=0;
1609           if(encoderpos>990) encoderpos=990;
1610           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1611         }
1612
1613       }break;
1614     case ItemCM_vtravmin:
1615     {
1616       if(force_lcd_update)
1617         {
1618           lcd.setCursor(0,line);lcdprintPGM(MSG_VTRAV_MIN);
1619           lcd.setCursor(13,line);lcd.print(itostr3(mintravelfeedrate));
1620         }
1621
1622         if((activeline!=line) )
1623           break;
1624
1625         if(CLICKED)
1626         {
1627           linechanging=!linechanging;
1628           if(linechanging)
1629           {
1630               encoderpos=(long)mintravelfeedrate;
1631           }
1632           else
1633           {
1634             mintravelfeedrate= encoderpos;
1635             encoderpos=activeline*lcdslow;
1636
1637           }
1638           BLOCK;
1639           beepshort();
1640         }
1641         if(linechanging)
1642         {
1643           if(encoderpos<0) encoderpos=0;
1644           if(encoderpos>990) encoderpos=990;
1645           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));
1646         }
1647
1648       }break;
1649
1650     case ItemCM_amaxx:
1651     case ItemCM_amaxy:
1652     case ItemCM_amaxz:
1653     case ItemCM_amaxe:
1654     {
1655       if(force_lcd_update)
1656         {
1657           lcd.setCursor(0,line);lcdprintPGM(" Amax ");
1658           if(i==ItemCM_amaxx)lcdprintPGM(MSG_X);
1659           if(i==ItemCM_amaxy)lcdprintPGM(MSG_Y);
1660           if(i==ItemCM_amaxz)lcdprintPGM(MSG_Z);
1661           if(i==ItemCM_amaxe)lcdprintPGM(MSG_E);
1662           lcd.setCursor(13,line);lcd.print(itostr3(max_acceleration_units_per_sq_second[i-ItemCM_amaxx]/100));lcdprintPGM("00");
1663         }
1664
1665         if((activeline!=line) )
1666           break;
1667
1668         if(CLICKED)
1669         {
1670           linechanging=!linechanging;
1671           if(linechanging)
1672           {
1673               encoderpos=(long)max_acceleration_units_per_sq_second[i-ItemCM_amaxx]/100;
1674           }
1675           else
1676           {
1677             max_acceleration_units_per_sq_second[i-ItemCM_amaxx]= encoderpos*100;
1678             encoderpos=activeline*lcdslow;
1679           }
1680           BLOCK;
1681           beepshort();
1682         }
1683         if(linechanging)
1684         {
1685           if(encoderpos<1) encoderpos=1;
1686           if(encoderpos>990) encoderpos=990;
1687           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcdprintPGM("00");
1688         }
1689
1690       }break;
1691
1692
1693     case ItemCM_aret://float retract_acceleration = 7000;
1694     {
1695         if(force_lcd_update)
1696         {
1697           lcd.setCursor(0,line);lcdprintPGM(MSG_A_RETRACT);
1698           lcd.setCursor(13,line);lcd.print(ftostr3(retract_acceleration/100));lcdprintPGM("00");
1699         }
1700
1701         if((activeline!=line) )
1702           break;
1703
1704         if(CLICKED)
1705         {
1706           linechanging=!linechanging;
1707           if(linechanging)
1708           {
1709               encoderpos=(long)retract_acceleration/100;
1710           }
1711           else
1712           {
1713             retract_acceleration= encoderpos*100;
1714             encoderpos=activeline*lcdslow;
1715
1716           }
1717           BLOCK;
1718           beepshort();
1719         }
1720         if(linechanging)
1721         {
1722           if(encoderpos<10) encoderpos=10;
1723           if(encoderpos>990) encoderpos=990;
1724           lcd.setCursor(13,line);lcd.print(itostr3(encoderpos));lcdprintPGM("00");
1725         }
1726
1727       }break;
1728        case ItemCM_xsteps://axis_steps_per_unit[i] = code_value();
1729          {
1730       if(force_lcd_update)
1731         {
1732           lcd.setCursor(0,line);lcdprintPGM(MSG_XSTEPS);
1733           lcd.setCursor(11,line);lcd.print(ftostr52(axis_steps_per_unit[X_AXIS]));
1734         }
1735
1736         if((activeline!=line) )
1737           break;
1738
1739         if(CLICKED)
1740         {
1741           linechanging=!linechanging;
1742           if(linechanging)
1743           {
1744               encoderpos=(long)(axis_steps_per_unit[X_AXIS]*100.0);
1745           }
1746           else
1747           {
1748             float factor=float(encoderpos)/100.0/float(axis_steps_per_unit[X_AXIS]);
1749             position[X_AXIS]=lround(position[X_AXIS]*factor);
1750             //current_position[X_AXIS]*=factor;
1751             axis_steps_per_unit[X_AXIS]= encoderpos/100.0;
1752             encoderpos=activeline*lcdslow;
1753           }
1754           BLOCK;
1755           beepshort();
1756         }
1757         if(linechanging)
1758         {
1759           if(encoderpos<5) encoderpos=5;
1760           if(encoderpos>999999) encoderpos=999999;
1761           lcd.setCursor(11,line);lcd.print(ftostr52(encoderpos/100.0));
1762         }
1763
1764       }break;
1765        case ItemCM_ysteps://axis_steps_per_unit[i] = code_value();
1766          {
1767       if(force_lcd_update)
1768         {
1769           lcd.setCursor(0,line);lcdprintPGM(MSG_YSTEPS);
1770           lcd.setCursor(11,line);lcd.print(ftostr52(axis_steps_per_unit[Y_AXIS]));
1771         }
1772
1773         if((activeline!=line) )
1774           break;
1775
1776         if(CLICKED)
1777         {
1778           linechanging=!linechanging;
1779           if(linechanging)
1780           {
1781               encoderpos=(long)(axis_steps_per_unit[Y_AXIS]*100.0);
1782           }
1783           else
1784           {
1785             float factor=float(encoderpos)/100.0/float(axis_steps_per_unit[Y_AXIS]);
1786             position[Y_AXIS]=lround(position[Y_AXIS]*factor);
1787             //current_position[Y_AXIS]*=factor;
1788             axis_steps_per_unit[Y_AXIS]= encoderpos/100.0;
1789             encoderpos=activeline*lcdslow;
1790
1791           }
1792           BLOCK;
1793           beepshort();
1794         }
1795         if(linechanging)
1796         {
1797           if(encoderpos<5) encoderpos=5;
1798           if(encoderpos>999999) encoderpos=999999;
1799           lcd.setCursor(11,line);lcd.print(ftostr52(encoderpos/100.0));
1800         }
1801
1802       }break;
1803        case ItemCM_zsteps://axis_steps_per_unit[i] = code_value();
1804          {
1805       if(force_lcd_update)
1806         {
1807           lcd.setCursor(0,line);lcdprintPGM(MSG_ZSTEPS);
1808           lcd.setCursor(11,line);lcd.print(ftostr52(axis_steps_per_unit[Z_AXIS]));
1809         }
1810
1811         if((activeline!=line) )
1812           break;
1813
1814         if(CLICKED)
1815         {
1816           linechanging=!linechanging;
1817           if(linechanging)
1818           {
1819               encoderpos=(long)(axis_steps_per_unit[Z_AXIS]*100.0);
1820           }
1821           else
1822           {
1823             float factor=float(encoderpos)/100.0/float(axis_steps_per_unit[Z_AXIS]);
1824             position[Z_AXIS]=lround(position[Z_AXIS]*factor);
1825             //current_position[Z_AXIS]*=factor;
1826             axis_steps_per_unit[Z_AXIS]= encoderpos/100.0;
1827             encoderpos=activeline*lcdslow;
1828
1829           }
1830           BLOCK;
1831           beepshort();
1832         }
1833         if(linechanging)
1834         {
1835           if(encoderpos<5) encoderpos=5;
1836           if(encoderpos>999999) encoderpos=999999;
1837           lcd.setCursor(11,line);lcd.print(ftostr52(encoderpos/100.0));
1838         }
1839
1840       }break;
1841
1842     case ItemCM_esteps://axis_steps_per_unit[i] = code_value();
1843          {
1844       if(force_lcd_update)
1845         {
1846           lcd.setCursor(0,line);lcdprintPGM(MSG_ESTEPS);
1847           lcd.setCursor(11,line);lcd.print(ftostr52(axis_steps_per_unit[E_AXIS]));
1848         }
1849
1850         if((activeline!=line) )
1851           break;
1852
1853         if(CLICKED)
1854         {
1855           linechanging=!linechanging;
1856           if(linechanging)
1857           {
1858               encoderpos=(long)(axis_steps_per_unit[E_AXIS]*100.0);
1859           }
1860           else
1861           {
1862             float factor=float(encoderpos)/100.0/float(axis_steps_per_unit[E_AXIS]);
1863             position[E_AXIS]=lround(position[E_AXIS]*factor);
1864             //current_position[E_AXIS]*=factor;
1865             axis_steps_per_unit[E_AXIS]= encoderpos/100.0;
1866             encoderpos=activeline*lcdslow;
1867
1868           }
1869           BLOCK;
1870           beepshort();
1871         }
1872         if(linechanging)
1873         {
1874           if(encoderpos<5) encoderpos=5;
1875           if(encoderpos>999999) encoderpos=999999;
1876           lcd.setCursor(11,line);lcd.print(ftostr52(encoderpos/100.0));
1877         }
1878
1879       }break;
1880     default:
1881       break;
1882   }
1883   line++;
1884  }
1885  updateActiveLines(ItemCM_esteps,encoderpos);
1886 }
1887
1888
1889 enum {
1890   ItemR_exit,
1891   ItemR_autoretract,
1892   ItemR_retract_length,ItemR_retract_feedrate,ItemR_retract_zlift,
1893   ItemR_unretract_length,ItemR_unretract_feedrate,
1894
1895 };
1896
1897
1898
1899 void MainMenu::showControlRetract()
1900 {
1901 #ifdef FWRETRACT
1902  uint8_t line=0;
1903  clearIfNecessary();
1904  for(int8_t i=lineoffset;i<lineoffset+LCD_HEIGHT;i++)
1905  {
1906   switch(i)
1907   {
1908     case ItemR_exit:
1909       MENUITEM(  lcdprintPGM(MSG_CONTROL)  ,  BLOCK;status=Main_Control;beepshort(); ) ;
1910       break;
1911
1912       //float retract_length=2, retract_feedrate=1200, retract_zlift=0.4;
1913   //float retract_recover_length=0, retract_recover_feedrate=500;
1914       case ItemR_autoretract:
1915       {
1916         if(force_lcd_update)
1917         {
1918           lcd.setCursor(0,line);lcdprintPGM(MSG_AUTORETRACT);
1919           lcd.setCursor(13,line);
1920           if(autoretract_enabled)
1921             lcdprintPGM(MSG_ON);
1922           else
1923             lcdprintPGM(MSG_OFF);
1924         }
1925
1926         if((activeline!=line) )
1927           break;
1928
1929         if(CLICKED)
1930         {
1931           autoretract_enabled=!autoretract_enabled;
1932           lcd.setCursor(13,line);
1933           if(autoretract_enabled)
1934             lcdprintPGM(MSG_ON);
1935           else
1936             lcdprintPGM(MSG_OFF);
1937           BLOCK;
1938         }
1939
1940       }break;
1941
1942       case ItemR_retract_length:
1943     {
1944         if(force_lcd_update)
1945         {
1946           lcd.setCursor(0,line);lcdprintPGM(MSG_CONTROL_RETRACT);
1947           lcd.setCursor(13,line);lcd.print(ftostr52(retract_length));
1948         }
1949
1950         if((activeline!=line) )
1951           break;
1952
1953         if(CLICKED)
1954         {
1955           linechanging=!linechanging;
1956           if(linechanging)
1957           {
1958               encoderpos=(long)(retract_length*100);
1959           }
1960           else
1961           {
1962             retract_length= encoderpos/100.;
1963             encoderpos=activeline*lcdslow;
1964
1965           }
1966           BLOCK;
1967           beepshort();
1968         }
1969         if(linechanging)
1970         {
1971           if(encoderpos<1) encoderpos=1;
1972           if(encoderpos>990) encoderpos=990;
1973           lcd.setCursor(13,line);lcd.print(ftostr52(encoderpos/100.));
1974         }
1975
1976       }break;
1977       case ItemR_retract_feedrate:
1978     {
1979         if(force_lcd_update)
1980         {
1981           lcd.setCursor(0,line);lcdprintPGM(MSG_CONTROL_RETRACTF);
1982           lcd.setCursor(13,line);lcd.print(itostr4(retract_feedrate));
1983         }
1984
1985         if((activeline!=line) )
1986           break;
1987
1988         if(CLICKED)
1989         {
1990           linechanging=!linechanging;
1991           if(linechanging)
1992           {
1993               encoderpos=(long)(retract_feedrate/5);
1994           }
1995           else
1996           {
1997             retract_feedrate= encoderpos*5.;
1998             encoderpos=activeline*lcdslow;
1999
2000           }
2001           BLOCK;
2002           beepshort();
2003         }
2004         if(linechanging)
2005         {
2006           if(encoderpos<1) encoderpos=1;
2007           if(encoderpos>990) encoderpos=990;
2008           lcd.setCursor(13,line);lcd.print(itostr4(encoderpos*5));
2009         }
2010
2011       }break;
2012       case ItemR_retract_zlift://float retract_acceleration = 7000;
2013     {
2014         if(force_lcd_update)
2015         {
2016           lcd.setCursor(0,line);lcdprintPGM(MSG_CONTROL_RETRACT_ZLIFT);
2017           lcd.setCursor(13,line);lcd.print(ftostr52(retract_zlift));;
2018         }
2019
2020         if((activeline!=line) )
2021           break;
2022
2023         if(CLICKED)
2024         {
2025           linechanging=!linechanging;
2026           if(linechanging)
2027           {
2028               encoderpos=(long)(retract_zlift*10);
2029           }
2030           else
2031           {
2032             retract_zlift= encoderpos/10.;
2033             encoderpos=activeline*lcdslow;
2034
2035           }
2036           BLOCK;
2037           beepshort();
2038         }
2039         if(linechanging)
2040         {
2041           if(encoderpos<0) encoderpos=0;
2042           if(encoderpos>990) encoderpos=990;
2043           lcd.setCursor(13,line);lcd.print(ftostr52(encoderpos/10.));
2044         }
2045
2046       }break;
2047       case ItemR_unretract_length:
2048     {
2049         if(force_lcd_update)
2050         {
2051           lcd.setCursor(0,line);lcdprintPGM(MSG_CONTROL_RETRACT_RECOVER);
2052           lcd.setCursor(13,line);lcd.print(ftostr52(retract_recover_length));;
2053         }
2054
2055         if((activeline!=line) )
2056           break;
2057
2058         if(CLICKED)
2059         {
2060           linechanging=!linechanging;
2061           if(linechanging)
2062           {
2063               encoderpos=(long)(retract_recover_length*100);
2064           }
2065           else
2066           {
2067             retract_recover_length= encoderpos/100.;
2068             encoderpos=activeline*lcdslow;
2069
2070           }
2071           BLOCK;
2072           beepshort();
2073         }
2074         if(linechanging)
2075         {
2076           if(encoderpos<0) encoderpos=0;
2077           if(encoderpos>990) encoderpos=990;
2078           lcd.setCursor(13,line);lcd.print(ftostr52(encoderpos/100.));
2079         }
2080
2081       }break;
2082
2083       case ItemR_unretract_feedrate:
2084     {
2085         if(force_lcd_update)
2086         {
2087           lcd.setCursor(0,line);lcdprintPGM(MSG_CONTROL_RETRACT_RECOVERF);
2088           lcd.setCursor(13,line);lcd.print(itostr4(retract_recover_feedrate));
2089         }
2090
2091         if((activeline!=line) )
2092           break;
2093
2094         if(CLICKED)
2095         {
2096           linechanging=!linechanging;
2097           if(linechanging)
2098           {
2099               encoderpos=(long)retract_recover_feedrate/5;
2100           }
2101           else
2102           {
2103             retract_recover_feedrate= encoderpos*5.;
2104             encoderpos=activeline*lcdslow;
2105
2106           }
2107           BLOCK;
2108           beepshort();
2109         }
2110         if(linechanging)
2111         {
2112           if(encoderpos<1) encoderpos=1;
2113           if(encoderpos>990) encoderpos=990;
2114           lcd.setCursor(13,line);lcd.print(itostr4(encoderpos*5));
2115         }
2116
2117       }break;
2118
2119     default:
2120       break;
2121   }
2122   line++;
2123  }
2124  updateActiveLines(ItemR_unretract_feedrate,encoderpos);
2125 #endif
2126 }
2127
2128
2129
2130 enum {
2131   ItemC_exit,ItemC_temp,ItemC_move,
2132 #ifdef FWRETRACT
2133   ItemC_rectract,
2134 #endif
2135   ItemC_store, ItemC_load,ItemC_failsafe
2136 };
2137
2138 void MainMenu::showControl()
2139 {
2140  uint8_t line=0;
2141  clearIfNecessary();
2142  for(int8_t i=lineoffset;i<lineoffset+LCD_HEIGHT;i++)
2143  {
2144   switch(i)
2145   {
2146     case ItemC_exit:
2147       MENUITEM(  lcdprintPGM(MSG_MAIN_WIDE)  ,  BLOCK;status=Main_Menu;beepshort(); ) ;
2148       break;
2149     case ItemC_temp:
2150       MENUITEM(  lcdprintPGM(MSG_TEMPERATURE_WIDE)  ,  BLOCK;status=Sub_TempControl;beepshort(); ) ;
2151       break;
2152    case ItemC_move:
2153       MENUITEM(  lcdprintPGM(MSG_MOTION_WIDE)  ,  BLOCK;status=Sub_MotionControl;beepshort(); ) ;
2154       break;
2155 #ifdef FWRETRACT
2156     case ItemC_rectract:
2157       MENUITEM(  lcdprintPGM(MSG_RECTRACT_WIDE)  ,  BLOCK;status=Sub_RetractControl;beepshort(); ) ;
2158       break;
2159 #endif
2160     case ItemC_store:
2161     {
2162       if(force_lcd_update)
2163       {
2164         lcd.setCursor(0,line);lcdprintPGM(MSG_STORE_EPROM);
2165       }
2166       if((activeline==line) && CLICKED)
2167       {
2168         //enquecommand("M84");
2169         beepshort();
2170         BLOCK;
2171         EEPROM_StoreSettings();
2172       }
2173     }break;
2174     case ItemC_load:
2175     {
2176       if(force_lcd_update)
2177       {
2178         lcd.setCursor(0,line);lcdprintPGM(MSG_LOAD_EPROM);
2179       }
2180       if((activeline==line) && CLICKED)
2181       {
2182         //enquecommand("M84");
2183         beepshort();
2184         BLOCK;
2185         EEPROM_RetrieveSettings();
2186       }
2187     }break;
2188     case ItemC_failsafe:
2189     {
2190       if(force_lcd_update)
2191       {
2192         lcd.setCursor(0,line);lcdprintPGM(MSG_RESTORE_FAILSAFE);
2193       }
2194       if((activeline==line) && CLICKED)
2195       {
2196         //enquecommand("M84");
2197         beepshort();
2198         BLOCK;
2199         EEPROM_RetrieveSettings(true);
2200       }
2201     }break;
2202     default:
2203       break;
2204   }
2205   line++;
2206  }
2207  updateActiveLines(ItemC_failsafe,encoderpos);
2208 }
2209
2210
2211
2212
2213
2214 void MainMenu::showSD()
2215 {
2216 #ifdef SDSUPPORT
2217  uint8_t line=0;
2218
2219  clearIfNecessary();
2220  static uint8_t nrfiles=0;
2221  if(force_lcd_update)
2222  {
2223   if(card.cardOK)
2224   {
2225     nrfiles=card.getnrfilenames();
2226   }
2227   else
2228   {
2229     nrfiles=0;
2230     lineoffset=0;
2231   }
2232  }
2233  bool enforceupdate=false;
2234  for(int8_t i=lineoffset;i<lineoffset+LCD_HEIGHT;i++)
2235  {
2236   switch(i)
2237   {
2238     case 0:
2239       MENUITEM(  lcdprintPGM(MSG_MAIN)  ,  BLOCK;status=Main_Menu;beepshort(); ) ;
2240       break;
2241 //     case 1:
2242 //       {
2243 //         if(force_lcd_update)
2244 //         {
2245 //           lcd.setCursor(0,line);
2246 //            #ifdef CARDINSERTED
2247 //           if(CARDINSERTED)
2248 //           #else
2249 //           if(true)
2250 //           #endif
2251 //           {
2252 //             lcdprintPGM(" \004Refresh");
2253 //           }
2254 //           else
2255 //           {
2256 //             lcdprintPGM(" \004Insert Card");
2257 //           }
2258 //
2259 //         }
2260 //         if((activeline==line) && CLICKED)
2261 //         {
2262 //           BLOCK;
2263 //           beepshort();
2264 //           card.initsd();
2265 //           force_lcd_update=true;
2266 //            nrfiles=card.getnrfilenames();
2267 //         }
2268 //       }break;
2269     case 1:
2270       MENUITEM(  lcd.print(" ");card.getWorkDirName();
2271           if(card.filename[0]=='/') lcdprintPGM(MSG_REFRESH);
2272           else {
2273                   lcd.print("\005");
2274                   lcd.print(card.filename);
2275                   lcd.print("/..");
2276                         }  ,
2277         BLOCK;
2278                         if(SDCARDDETECT == -1) card.initsd();
2279                         card.updir();
2280                         enforceupdate=true;
2281                         lineoffset=0;
2282                         beepshort(); ) ;
2283
2284       break;
2285     default:
2286     {
2287       #define FIRSTITEM 2
2288       if(i-FIRSTITEM<nrfiles)
2289       {
2290         if(force_lcd_update)
2291         {
2292           card.getfilename(i-FIRSTITEM);
2293           //Serial.print("Filenr:");Serial.println(i-2);
2294           lcd.setCursor(0,line);lcdprintPGM(" ");
2295           if(card.filenameIsDir) lcd.print("\005");
2296           lcd.print(card.filename);
2297         }
2298         if((activeline==line) && CLICKED)
2299         {
2300           BLOCK
2301           card.getfilename(i-FIRSTITEM);
2302           if(card.filenameIsDir)
2303           {
2304             for(int8_t i=0;i<strlen(card.filename);i++)
2305               card.filename[i]=tolower(card.filename[i]);
2306             card.chdir(card.filename);
2307             lineoffset=0;
2308             enforceupdate=true;
2309           }
2310           else
2311           {
2312             char cmd[30];
2313             for(int8_t i=0;i<strlen(card.filename);i++)
2314               card.filename[i]=tolower(card.filename[i]);
2315             sprintf(cmd,"M23 %s",card.filename);
2316             //sprintf(cmd,"M115");
2317             enquecommand(cmd);
2318             enquecommand("M24");
2319             beep();
2320             status=Main_Status;
2321             lcd_status(card.filename);
2322           }
2323         }
2324       }
2325
2326     }
2327       break;
2328   }
2329   line++;
2330  }
2331  updateActiveLines(FIRSTITEM+nrfiles-1,encoderpos);
2332  if(enforceupdate)
2333  {
2334    force_lcd_update=true;
2335    enforceupdate=false;
2336  }
2337 #endif
2338 }
2339
2340
2341 enum {ItemM_watch, ItemM_prepare, ItemM_control, ItemM_file };
2342 void MainMenu::showMainMenu()
2343 {
2344
2345   #ifndef ULTIPANEL
2346     force_lcd_update=false;
2347   #endif
2348   if(tune)
2349   {
2350     if(!(movesplanned() || IS_SD_PRINTING))
2351     {
2352       force_lcd_update=true;
2353       tune=false;
2354     }
2355   }
2356   else
2357   {
2358     if(movesplanned() || IS_SD_PRINTING)
2359     {
2360       force_lcd_update=true;
2361       tune=true;
2362     }
2363   }
2364   clearIfNecessary();
2365   uint8_t line=0;
2366   for(int8_t i=lineoffset;i<lineoffset+LCD_HEIGHT;i++)
2367   {
2368     switch(i)
2369     {
2370       case ItemM_watch:
2371         MENUITEM(  lcdprintPGM(MSG_WATCH)  ,  BLOCK;status=Main_Status;beepshort(); ) ;
2372        break;
2373       case ItemM_prepare:
2374         MENUITEM(  if(!tune) lcdprintPGM(MSG_PREPARE);else  lcdprintPGM(MSG_TUNE); ,  BLOCK;status=Main_Prepare;beepshort(); ) ;
2375       break;
2376
2377       case ItemM_control:
2378         MENUITEM(  lcdprintPGM(MSG_CONTROL_ARROW)  ,  BLOCK;status=Main_Control;beepshort(); ) ;
2379       break;
2380       #ifdef SDSUPPORT
2381       case ItemM_file:
2382       {
2383         if(force_lcd_update)
2384         {
2385           lcd.setCursor(0,line);
2386           #ifdef CARDINSERTED
2387             if(CARDINSERTED)
2388           #else
2389             if(true)
2390           #endif
2391           {
2392             if(card.sdprinting)
2393               lcdprintPGM(MSG_STOP_PRINT);
2394             else
2395               lcdprintPGM(MSG_CARD_MENU);
2396           }
2397           else
2398           {
2399            lcdprintPGM(MSG_NO_CARD);
2400           }
2401         }
2402         #ifdef CARDINSERTED
2403           if(CARDINSERTED)
2404         #endif
2405         if((activeline==line)&&CLICKED)
2406         {
2407           card.printingHasFinished();
2408           BLOCK;
2409           status=Main_SD;
2410           beepshort();
2411         }
2412       }break;
2413       #else
2414       case ItemM_file:
2415         break;
2416       #endif
2417       default:
2418         SERIAL_ERROR_START;
2419         SERIAL_ERRORLNPGM(MSG_SERIAL_ERROR_MENU_STRUCTURE);
2420       break;
2421     }
2422     line++;
2423   }
2424   updateActiveLines(3,encoderpos);
2425 }
2426
2427 void MainMenu::update()
2428 {
2429   static MainStatus oldstatus=Main_Menu;  //init automatically causes foce_lcd_update=true
2430   static long timeoutToStatus=0;
2431   static bool oldcardstatus=false;
2432   #ifdef CARDINSERTED
2433     if((CARDINSERTED != oldcardstatus))
2434     {
2435       force_lcd_update=true;
2436       oldcardstatus=CARDINSERTED;
2437       lcd_init(); // to maybe revive the lcd if static electricty killed it.
2438       //Serial.println("echo: SD CHANGE");
2439       if(CARDINSERTED)
2440       {
2441         card.initsd();
2442         LCD_MESSAGEPGM(MSG_SD_INSERTED);
2443       }
2444       else
2445       {
2446         card.release();
2447         LCD_MESSAGEPGM(MSG_SD_REMOVED);
2448       }
2449     }
2450   #endif
2451
2452   if(status!=oldstatus)
2453   {
2454     force_lcd_update=true;
2455     encoderpos=0;
2456     lineoffset=0;
2457
2458     oldstatus=status;
2459   }
2460   if( (encoderpos!=lastencoderpos) || CLICKED)
2461     timeoutToStatus=millis()+STATUSTIMEOUT;
2462
2463   switch(status)
2464   {
2465       case Main_Status:
2466       {
2467         showStatus();
2468         if(CLICKED)
2469         {
2470            linechanging=false;
2471            BLOCK
2472            status=Main_Menu;
2473            timeoutToStatus=millis()+STATUSTIMEOUT;
2474         }
2475       }break;
2476       case Main_Menu:
2477       {
2478         showMainMenu();
2479         linechanging=false;
2480       }break;
2481       case Main_Prepare:
2482       {
2483         if(tune)
2484         {
2485           showTune();
2486         }
2487         else
2488         {
2489           showPrepare();
2490         }
2491       }break;
2492       case Sub_PrepareMove:
2493       {
2494             showAxisMove();
2495       }break;
2496       case Main_Control:
2497       {
2498         showControl();
2499       }break;
2500       case Sub_MotionControl:
2501       {
2502         showControlMotion();
2503       }break;
2504       case Sub_RetractControl:
2505       {
2506         showControlRetract();
2507       }break;
2508       case Sub_TempControl:
2509       {
2510         showControlTemp();
2511       }break;
2512       case Main_SD:
2513       {
2514         showSD();
2515       }break;
2516   }
2517
2518   if(timeoutToStatus<millis())
2519     status=Main_Status;
2520   //force_lcd_update=false;
2521   lastencoderpos=encoderpos;
2522 }
2523
2524
2525
2526
2527
2528
2529 //  convert float to string with +123.4 format
2530 char *ftostr3(const float &x)
2531 {
2532   //sprintf(conv,"%5.1f",x);
2533   int xx=x;
2534   conv[0]=(xx/100)%10+'0';
2535   conv[1]=(xx/10)%10+'0';
2536   conv[2]=(xx)%10+'0';
2537   conv[3]=0;
2538   return conv;
2539 }
2540
2541 char *itostr2(const uint8_t &x)
2542 {
2543   //sprintf(conv,"%5.1f",x);
2544   int xx=x;
2545   conv[0]=(xx/10)%10+'0';
2546   conv[1]=(xx)%10+'0';
2547   conv[2]=0;
2548   return conv;
2549 }
2550
2551 //  convert float to string with +123.4 format
2552 char *ftostr31(const float &x)
2553 {
2554   int xx=x*10;
2555   conv[0]=(xx>=0)?'+':'-';
2556   xx=abs(xx);
2557   conv[1]=(xx/1000)%10+'0';
2558   conv[2]=(xx/100)%10+'0';
2559   conv[3]=(xx/10)%10+'0';
2560   conv[4]='.';
2561   conv[5]=(xx)%10+'0';
2562   conv[6]=0;
2563   return conv;
2564 }
2565
2566 char *ftostr32(const float &x)
2567 {
2568   int xx=x*100;
2569   conv[0]=(xx>=0)?'+':'-';
2570   xx=abs(xx);
2571   conv[1]=(xx/100)%10+'0';
2572   conv[2]='.';
2573   conv[3]=(xx/10)%10+'0';
2574   conv[4]=(xx)%10+'0';
2575   conv[6]=0;
2576   return conv;
2577 }
2578
2579 char *itostr31(const int &xx)
2580 {
2581   conv[0]=(xx>=0)?'+':'-';
2582   conv[1]=(xx/1000)%10+'0';
2583   conv[2]=(xx/100)%10+'0';
2584   conv[3]=(xx/10)%10+'0';
2585   conv[4]='.';
2586   conv[5]=(xx)%10+'0';
2587   conv[6]=0;
2588   return conv;
2589 }
2590
2591 char *itostr3(const int &xx)
2592 {
2593   conv[0]=(xx/100)%10+'0';
2594   conv[1]=(xx/10)%10+'0';
2595   conv[2]=(xx)%10+'0';
2596   conv[3]=0;
2597   return conv;
2598 }
2599
2600 char *itostr4(const int &xx)
2601 {
2602   conv[0]=(xx/1000)%10+'0';
2603   conv[1]=(xx/100)%10+'0';
2604   conv[2]=(xx/10)%10+'0';
2605   conv[3]=(xx)%10+'0';
2606   conv[4]=0;
2607   return conv;
2608 }
2609
2610 //  convert float to string with +1234.5 format
2611 char *ftostr51(const float &x)
2612 {
2613   int xx=x*10;
2614   conv[0]=(xx>=0)?'+':'-';
2615   xx=abs(xx);
2616   conv[1]=(xx/10000)%10+'0';
2617   conv[2]=(xx/1000)%10+'0';
2618   conv[3]=(xx/100)%10+'0';
2619   conv[4]=(xx/10)%10+'0';
2620   conv[5]='.';
2621   conv[6]=(xx)%10+'0';
2622   conv[7]=0;
2623   return conv;
2624 }
2625
2626 //  convert float to string with +123.45 format
2627 char *ftostr52(const float &x)
2628 {
2629   int xx=x*100;
2630   conv[0]=(xx>=0)?'+':'-';
2631   xx=abs(xx);
2632   conv[1]=(xx/10000)%10+'0';
2633   conv[2]=(xx/1000)%10+'0';
2634   conv[3]=(xx/100)%10+'0';
2635   conv[4]='.';
2636   conv[5]=(xx/10)%10+'0';
2637   conv[6]=(xx)%10+'0';
2638   conv[7]=0;
2639   return conv;
2640 }
2641
2642 #endif //ULTRA_LCD
2643
2644