Exemple #1
0
static void lcd_sdcard_stop()
{
    card.sdprinting = false;
    card.closefile();
    quickStop();
    if(SD_FINISHED_STEPPERRELEASE)
    {
        enquecommand_P(PSTR(SD_FINISHED_RELEASECOMMAND));
    }
    autotempShutdown();
}
Exemple #2
0
static void menu_action_sdfile(const char* filename, char* longFilename)
{
    char cmd[30];
    char* c;
    sprintf_P(cmd, PSTR("M23 %s"), filename);
    for(c = &cmd[4]; *c; c++)
        *c = tolower(*c);
    enquecommand(cmd);
    enquecommand_P(PSTR("M24"));
    lcd_return_to_status();
}
static void lcd_sdcard_stop()
{
    card.sdprinting = false;
    card.closefile();
    quickStop();
    if(SD_FINISHED_STEPPERRELEASE)
    {
        enquecommand_P(PSTR(SD_FINISHED_RELEASECOMMAND));
    }
    
    cancel_heatup = true;
}
Exemple #4
0
void CardReader::printingHasFinished()
{
    st_synchronize();
    quickStop();
    sdprinting = false;
    if(SD_FINISHED_STEPPERRELEASE)
    {
        //finishAndDisableSteppers();
        enquecommand_P(PSTR(SD_FINISHED_RELEASECOMMAND));
    }
    autotempShutdown();
}
void CardReader::checkautostart(bool force)
{
  if(!force)
  {
    if(!autostart_stilltocheck)
      return;
    if(autostart_atmillis<millis())
      return;
  }
  autostart_stilltocheck=false;
  if(!cardOK)
  {
    initsd();
    if(!cardOK) //fail
      return;
  }
  
  char autoname[30];
  sprintf_P(autoname, PSTR("auto%i.g"), lastnr);
  for(int8_t i=0;i<(int8_t)strlen(autoname);i++)
    autoname[i]=tolower(autoname[i]);
  dir_t p;

  root.rewind();
  
  bool found=false;
  while (root.readDir(p, NULL) > 0) 
  {
    for(int8_t i=0;i<(int8_t)strlen((char*)p.name);i++)
    p.name[i]=tolower(p.name[i]);
    //Serial.print((char*)p.name);
    //Serial.print(" ");
    //Serial.println(autoname);
    if(p.name[9]!='~') //skip safety copies
    if(strncmp((char*)p.name,autoname,5)==0)
    {
      char cmd[30];

      sprintf_P(cmd, PSTR("M23 %s"), autoname);
      enquecommand(cmd);
      enquecommand_P(PSTR("M24"));
      found=true;
    }
  }
  if(!found)
    lastnr=-1;
  else
    lastnr++;
  clearError();
}
static void lcd_sdcard_stop()
{
    card.sdprinting = false;
    card.closefile();
    quickStop();
    if(SD_FINISHED_STEPPERRELEASE)
    {
		if (current_position[Z_AXIS] < Z_MAX_POS - 191)
		{
			enquecommand_P(PSTR(SD_FINISHED_MOVEEXTRUDERAWAY1));
			enquecommand_P(PSTR(SD_FINISHED_RELEASECOMMAND));
		}
		else
		{
			enquecommand_P(PSTR(SD_FINISHED_MOVEEXTRUDERAWAY0));
			enquecommand_P(PSTR(SD_FINISHED_RELEASECOMMAND));
		}
    }
		disable_heater();
    autotempShutdown();
	
	lcd_setstatus(MSG_PRINT_ABORTED);
}
Exemple #7
0
static void lcd_sdcard_stop()
{
    card.sdprinting = false;
    card.closefile();
    quickStop();
    if(SD_FINISHED_STEPPERRELEASE)
    {
        enquecommand_P(PSTR(SD_FINISHED_RELEASECOMMAND));
    }
    autotempShutdown();

	cancel_heatup = true;

	lcd_setstatus(MSG_PRINT_ABORTED);
}
static void lcd_menu_change_material_remove_wait_user_ready()
{
    run_history = true;
    current_position[E_AXIS] = 0;
    plan_set_e_position(current_position[E_AXIS]);
    lcd_change_to_menu(lcd_menu_change_material_insert_wait_user, MAIN_MENU_ITEM_POS(0));

    char buffer[32];
    memset (buffer,0,sizeof(buffer));

    enquecommand_P(PSTR("G28 X0 Y0"));
    sprintf_P(buffer, PSTR("G1 F%i X%i Y%i"), int(homing_feedrate[0]), int (X_MAX_LENGTH/2), 10);
    enquecommand(buffer);
    LED_GLOW();
}
static void lcd_menu_material_main()
{
    lcd_tripple_menu(PSTR("CHANGE"), PSTR("SETTINGS"), PSTR("RETURN"));

    if (lcd_lib_button_pressed)
    {
        if (IS_SELECTED_MAIN(0) && !is_command_queued())
        {
            minProgress = 0;
            char buffer[32];
            enquecommand_P(PSTR("G28 X0 Y0"));
            sprintf_P(buffer, PSTR("G1 F%i X%i Y%i"), int(homing_feedrate[0]), X_MAX_LENGTH/2, 10);
            enquecommand(buffer);
            lcd_change_to_menu_change_material(lcd_menu_material_main_return);
        }
        else if (IS_SELECTED_MAIN(1))
            lcd_change_to_menu(lcd_menu_material_select, SCROLL_MENU_ITEM_POS(0));
        else if (IS_SELECTED_MAIN(2))
            lcd_change_to_menu(lcd_menu_main);
    }

    lcd_lib_update_screen();
}
void CardReader::printingHasFinished()
{
    st_synchronize();
    if(file_subcall_ctr>0) //heading up to a parent file that called current as a procedure.
    {
      file.close();
      file_subcall_ctr--;
      openFile(filenames[file_subcall_ctr],true,true);
      setIndex(filespos[file_subcall_ctr]);
      startFileprint();
    }
    else
    {
      quickStop();
      file.close();
      sdprinting = false;
      if(SD_FINISHED_STEPPERRELEASE)
      {
          //finishAndDisableSteppers();
          enquecommand_P(PSTR(SD_FINISHED_RELEASECOMMAND));
      }
      autotempShutdown();
    }
}
void process()
{
    switch (buff_obj[0]) {
        case 'V':
            writeString((char *)"{VER:008}");
            return;

        case 'S':
            if (buff_value[0]=='E') writeString((char *)"{SYS:echo}");
/*            else if (buff_value[0]=='H')
            {
                uint8_t i,itemCount;
                
                itemCount=countFiles(false);
                //if (file_from_wifi!=0)
                {
                    writeString((char *)"{WIFI:");
                    writeInt(file_from_wifi,3);
                    put('/');
                    writeInt(itemCount,3);
                    put('}');
                }
            }*/
            else if (buff_value[0]=='L')
            {
                uint8_t i;
                uint8_t itemCount;
                
                if ( card.isFileOpen() ) {
                    writeString((char *)"{SYS:BUSY}");
                    return;
                }
				
				//card.initsd();
				//card.getWorkDirName();

                itemCount = countFiles(true);
				
				if (itemCount==0)
				{
					card.initsd();
					card.setroot();
					itemCount = countFiles(true);
				}
				
                for (i=0;i<itemCount;i++)
                {
                    ListFile(i,itemCount);
                }

                if (itemCount==0)
                {
                    if (card.cardOK) i=101;
					else i=102;
                    writeString((char *)"{ERR:");
                    writeInt(i,3);
                    put('}');
                }
                else writeString((char *)"{SYS:OK}");
            }
            else if (buff_value[0]=='I')
            {
                int16_t t;
                                
				writeString((char *)"{T0:");
				t=degHotend(0);
				if (t>999) t=999;
				writeInt(t,3);
				put('/');
				t=degTargetHotend(0);
				writeInt(t,3);
				put('}');
				
				writeString((char *)"{T1:");
				t=degHotend(1);
				if (t>999) t=999;
				writeInt(t,3);
				put('/');
				t=degTargetHotend(1);
				writeInt(t,3);
				put('}');
				
				writeString((char *)"{TP:");
				t=degBed();
				if (t>999) t=999;
				writeInt(t,3);
				put('/');
				t=degTargetBed();
				writeInt(t,3);
				put('}');
            }
            else if (buff_value[0]=='F')
            {
                /*if (buff_value[1]=='X')
                {
                    eeprom::setEepromInt64(eeprom_offsets::FILAMENT_TRIP, eeprom::getEepromInt64(eeprom_offsets::FILAMENT_LIFETIME, 0));
                    eeprom::setEepromInt64(eeprom_offsets::FILAMENT_TRIP + sizeof(int64_t), eeprom::getEepromInt64(eeprom_offsets::FILAMENT_LIFETIME + sizeof(int64_t), 0));
                }*/
                
                writeString((char *)"{TU:");
                
                uint16_t total_hours;
                uint8_t total_minutes;
                //eeprom::getBuildTime(&total_hours, &total_minutes);
				total_hours=0;
				total_minutes=0;
                writeInt(total_hours,5);
                put('.');
                writeInt(total_minutes,2);
                put('/');
                
                uint8_t build_hours;
                uint8_t build_minutes;
                //host::getPrintTime(build_hours, build_minutes);
				build_hours=0;
				build_minutes=0;
                writeInt(build_hours,3);
                put('.');
                writeInt(build_minutes,2);
                put('/');
                
                uint32_t filamentUsedA,filamentUsedB,filamentUsed;
                char str[11];
                //filamentUsedA=stepperAxisStepsToMM(eeprom::getEepromInt64(eeprom_offsets::FILAMENT_LIFETIME, 0),                  A_AXIS);
                //filamentUsedB=stepperAxisStepsToMM(eeprom::getEepromInt64(eeprom_offsets::FILAMENT_LIFETIME + sizeof(int64_t),0), B_AXIS);
                //filamentUsed=filamentUsedA+filamentUsedB;
				filamentUsed=0;
                itoa(filamentUsed,str,10);
                writeString((char *)str);
                put('/');
                
                //filamentUsedA -= stepperAxisStepsToMM(eeprom::getEepromInt64(eeprom_offsets::FILAMENT_TRIP, 0),                  A_AXIS);
                //filamentUsedB -= stepperAxisStepsToMM(eeprom::getEepromInt64(eeprom_offsets::FILAMENT_TRIP + sizeof(int64_t),0), B_AXIS);
                //filamentUsed=filamentUsedA+filamentUsedB;
				filamentUsed=0;
                itoa(filamentUsed,str,10);
                writeString((char *)str);
                put('}');
            }
            else if (buff_value[0]=='R' && 
                buff_value[1]=='E' &&
                buff_value[2]=='S' &&
                buff_value[3]=='E' &&
                buff_value[4]=='T')
            {
                //Motherboard::getBoard().reset(true);
				
            }
/*
            else if (buff_value[0]=='S')
            {
                writeString((char *)"{SYS:P");
                uint8_t i = command::pauseState();
                writeInt(i,3);
                put('/');
                put('H');
                i=host::getHostState();
                writeInt(i,3);
                put('}');
            }
            break;
            */
		
        case 'C':
            if (buff_value[0]=='P')
            {
                uint16_t t;
                
                t=atoi((const char*)buff_value+1);
                
                if (t<0 || t>150) return;
                setTargetBed(t);
            }
            else if (buff_value[0]=='T')
            {
                int16_t t;
                
                t=atoi((const char*)buff_value+2);
                if (t<0 || t>280) return;
                
                if (buff_value[1] == '0')
                {
                    setTargetHotend(t,0);
                }
                else
                {
                    setTargetHotend(t,1);
                }
            }
            else if (buff_value[0]=='S')
            {
                int16_t t;
                uint8_t i;
                
                t=atoi((const char*)buff_value+1);
                
                if (t<1) t=1;
                else if (t>50) t=50;
                
                feedmultiply=t*10;
            }
            break;
            
        case 'P':
            uint8_t i;
            if (buff_value[0]=='H')
            {
            	enquecommand_P(PSTR("G28"));
            }
            else if (buff_value[0]=='C')
            {
                //host::startOnboardBuild(utility::TOOLHEAD_CALIBRATE);
            }
            else if (buff_value[0]=='X')
            {
				extern bool cancel_heatup;
                writeString((char *)"{SYS:CANCELING}");
				//card.pauseSDPrint();
				//disable_heater();
				card.sdprinting = false;
				card.closefile();
				quickStop();
				if(SD_FINISHED_STEPPERRELEASE)
				{
					enquecommand_P(PSTR(SD_FINISHED_RELEASECOMMAND));
				}
				autotempShutdown();
				cancel_heatup = true;
				writeString((char *)"{SYS:STARTED}");
				writeString((char *)"{U:RG1R180180120P0L1S0D0O1E1H0C0X1Y1Z1A2B2N3M0}");
				
            }
            else if (buff_value[0]=='P')
            {
                writeString((char *)"{SYS:PAUSE}");
                card.pauseSDPrint();
                writeString((char *)"{SYS:PAUSED}");
            }
            else if (buff_value[0]=='R')
            {
                writeString((char *)"{SYS:RESUME}");
                card.startFileprint();
                writeString((char *)"{SYS:RESUMED}");
            }
            else if (buff_value[0]=='Z')
            {
                /*i=(buff_value[1]-'0')*100 + (buff_value[2]-'0')*10 + (buff_value[3]-'0');
                float pauseAtZPos = i;
                command::pauseAtZPos(stepperAxisMMToSteps(pauseAtZPos, Z_AXIS));*/
            }
            else
            {
                i=(buff_value[0]-'0')*100 + (buff_value[1]-'0')*10 + (buff_value[2]-'0');
                card.getfilename(i);
				if (card.filenameIsDir)
				{
					writeString((char *)"{SYS:DIR}");
					card.chdir(card.filename);
				}
				else 
				{
					char cmd[30];
					char* c;
					
					writeString((char *)"{PRINTFILE:");
					if (card.longFilename[0]!=0) writeString(card.longFilename);
					else writeString(card.filename);
					put('}');
					
					sprintf_P(cmd, PSTR("M23 %s"), card.filename);
					for(c = &cmd[4]; *c; c++)
					*c = tolower(*c);
					enquecommand(cmd);
					enquecommand_P(PSTR("M24"));
				}
            }
            break;

        case 'B':
            PrintingStatus();
            break;

/*
        case 'J':
            switch (buff_value[0])
            {
                case 'S':
                    BOARD_STATUS_SET(Motherboard::STATUS_MANUAL_MODE);
                    jog_speed=atoi((const char*)buff_value+1);
                    break;
                    
                case 'E':
                    steppers::enableAxes(0xff, false);
                    BOARD_STATUS_CLEAR(Motherboard::STATUS_MANUAL_MODE);
                    break;
                    
                case 'X':
                case 'Y':
                case 'Z':
                case 'A':
                case 'B':
                    steppers::abort();
                    uint8_t dummy;
                    Point position = steppers::getStepperPosition(&dummy);
                    
                    int32_t t;
                    t=atoi((const char*)buff_value+1);

                    if (buff_value[0]<='B') position[buff_value[0]-'A'+3] += (t<<4);
                    else position[buff_value[0]-'X'] += (t<<4);
                    
                    steppers::setTargetNew(position, jog_speed, 0, 0);
                    break;
            }
            break;
*/
/*
        case 'H':
        	if (buff_value[0]=='R')
        	{
        		extern uint32_t homePosition[PROFILES_HOME_POSITIONS_STORED];

        		writeString((char *)"{H:R");
        		eeprom_read_block(homePosition, (void *)eeprom_offsets::AXIS_HOME_POSITIONS_STEPS, PROFILES_HOME_POSITIONS_STORED * sizeof(uint32_t));
        		writeInt(homePosition[0],5);
        		put('/');
        		writeInt(homePosition[1],5);
        		put('/');
        		writeInt(homePosition[2],5);
        		put('/');
        		writeInt((int32_t)(eeprom::getEeprom32(eeprom_offsets::TOOLHEAD_OFFSET_SETTINGS, 0)),5);
        		put('/');
        		writeInt((int32_t)(eeprom::getEeprom32(eeprom_offsets::TOOLHEAD_OFFSET_SETTINGS + sizeof(int32_t), 0)),5);
        		put('}');
        	}
        	else if (buff_value[0]=='W')
        	{
        		extern uint32_t homePosition[PROFILES_HOME_POSITIONS_STORED];
        		int32_t offset[2],t;
        		uint8_t axis;
        		axis=buff_value[1]-'X';
        		if (axis>=0 && axis<=2)
        		{
        			homePosition[axis]=atoi((const char*)buff_value+2);
        			cli();
					eeprom_write_block((void *)&homePosition[axis],
					   (void*)(eeprom_offsets::AXIS_HOME_POSITIONS_STEPS + sizeof(uint32_t) * axis) ,
					   sizeof(uint32_t));
					sei();
        		}

        		axis=buff_value[1]-'x';
        		if (axis>=0 && axis<=1)
        		{
        			t=atoi((const char*)buff_value+2);

                    int32_t offset[2];
                    bool    smallOffsets;

                    offset[0]  = (int32_t)(eeprom::getEeprom32(eeprom_offsets::TOOLHEAD_OFFSET_SETTINGS, 0));
                    offset[1]  = (int32_t)(eeprom::getEeprom32(eeprom_offsets::TOOLHEAD_OFFSET_SETTINGS + sizeof(int32_t), 0));
                    smallOffsets = abs(offset[0]) < ((int32_t)stepperAxisStepsPerMM(0) << 2);

                    int32_t delta = stepperAxisMMToSteps((float)(t - 7) * 0.1f, axis);
                    if ( !smallOffsets ) delta = -delta;

                    int32_t new_offset = offset[axis] + delta;
                    eeprom_write_block((uint8_t *)&new_offset,
                           (uint8_t *)eeprom_offsets::TOOLHEAD_OFFSET_SETTINGS + axis * sizeof(int32_t),
                           sizeof(int32_t));
        		}
        	}
        	break;
*/
/*
        case 'U':
            if (buff_value[0]=='R')
            {
            	int temp;

                writeString((char *)"{U:RG");
                if (eeprom::getEeprom8(eeprom_offsets::OVERRIDE_GCODE_TEMP, 0) != 0) put('1');
                else put('0');

                put('R');
                temp=eeprom::getEeprom16(eeprom_offsets::PREHEAT_SETTINGS + preheat_eeprom_offsets::PREHEAT_LEFT_OFFSET, DEFAULT_PREHEAT_TEMP);
                writeInt(temp,3);
                //put('/');
                temp=eeprom::getEeprom16(eeprom_offsets::PREHEAT_SETTINGS + preheat_eeprom_offsets::PREHEAT_RIGHT_OFFSET, DEFAULT_PREHEAT_TEMP);
                writeInt(temp,3);
                //put('/');
                temp=eeprom::getEeprom16(eeprom_offsets::PREHEAT_SETTINGS + preheat_eeprom_offsets::PREHEAT_PLATFORM_OFFSET, DEFAULT_PREHEAT_TEMP);
                writeInt(temp,3);

                put('P');
                if (eeprom::hasHBP() != 0) put('1');
                else put('0');
                
                put('L');
                if (eeprom::getEeprom8(eeprom_offsets::ACCELERATION_SETTINGS + acceleration_eeprom_offsets::ACCELERATION_ACTIVE, 0x01) != 0) put('1');
                else put('0');
                
                put('S');
                if (eeprom::getEeprom8(eeprom_offsets::COOL_PLAT, 0) != 0) put('1');
                else put('0');
                
                put('D');
                if (eeprom::getEeprom8(eeprom_offsets::DITTO_PRINT_ENABLED, 0) != 0) put('1');
                else put('0');
                
                put('O');
                if (eeprom::getEeprom8(eeprom_offsets::TOOLHEAD_OFFSET_SYSTEM,
                                       DEFAULT_TOOLHEAD_OFFSET_SYSTEM) != 0) put('1');
                else put('0');
                
                put('E');
                if (eeprom::getEeprom8(eeprom_offsets::EXTRUDER_HOLD,
                                       DEFAULT_EXTRUDER_HOLD) != 0) put('1');
                else put('0');
                
                put('H');
                if (eeprom::getEeprom8(eeprom_offsets::HEAT_DURING_PAUSE, DEFAULT_HEAT_DURING_PAUSE) != 0) put('1');
                else put('0');
                
                put('C');
                if (eeprom::getEeprom8(eeprom_offsets::SD_USE_CRC, DEFAULT_SD_USE_CRC) != 0) put('1');
                else put('0');
                
                put('X');
                put ('0' + eeprom::getEeprom8(eeprom_offsets::STEPPER_X_CURRENT, 0));
                
                put('Y');
                put ('0' + eeprom::getEeprom8(eeprom_offsets::STEPPER_Y_CURRENT, 0));
                
                put('Z');
                put ('0' + eeprom::getEeprom8(eeprom_offsets::STEPPER_Z_CURRENT, 0));
                
                put('A');
                put ('0' + eeprom::getEeprom8(eeprom_offsets::STEPPER_A_CURRENT, 0));
                
                put('B');
                put ('0' + eeprom::getEeprom8(eeprom_offsets::STEPPER_B_CURRENT, 0));

                put('N');
                put ('0' + eeprom::getEeprom8(eeprom_offsets::LANGUAGE, 0));

                put('M');
                put ('0' + eeprom::getEeprom8(eeprom_offsets::WIFI_SD, 0));
                
                put('}');
            }
            else if (buff_value[0]=='W')
            {
                uint8_t *c;
                uint8_t cmd=0;
                
                c=buff_value;
                while (*++c!=0)
                {
                    if (*c<='9' && *c>='0')
                    {
                        uint8_t value;
                        value = *c - '0';
                        
                        switch (cmd)
                        {
                            case 'G':
                                eeprom_write_byte((uint8_t *)eeprom_offsets::OVERRIDE_GCODE_TEMP,value);
                                break;
                                
                            case 'P':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::HBP_PRESENT, value);
                                break;
                                
                            case 'L':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::ACCELERATION_SETTINGS +
                                                  acceleration_eeprom_offsets::ACCELERATION_ACTIVE,
                                                  value);
                                break;
                                
                            case 'S':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::COOL_PLAT, value);
                                break;
                                
                            case 'D':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::DITTO_PRINT_ENABLED, value);
                                break;
                                
                            case 'O':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::TOOLHEAD_OFFSET_SYSTEM, value);
                                break;
                                
                            case 'E':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::EXTRUDER_HOLD, value);
                                break;
                                
                            case 'H':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::HEAT_DURING_PAUSE, value);
                                break;
                                
                            case 'C':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::SD_USE_CRC, value);
                                break;
                                
                            case 'T':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::PSTOP_ENABLE, value);
                                break;
                                
                            case 'X':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::STEPPER_X_CURRENT, value);
                                break;
                                
                            case 'Y':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::STEPPER_Y_CURRENT, value);
                                break;
                                
                            case 'Z':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::STEPPER_Z_CURRENT, value);
                                break;
                                
                            case 'A':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::STEPPER_A_CURRENT, value);
                                break;
                                
                            case 'B':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::STEPPER_B_CURRENT, value);
                                break;

                            case 'N':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::LANGUAGE, value);
                                break;

                            case 'M':
                                eeprom_write_byte((uint8_t*)eeprom_offsets::WIFI_SD, value);
                                break;
                                
                            default:
                                break;
                        }
                    }
                    else if (*c<='Z' && *c>='A') cmd = *c;
                }
            }
            else if (buff_value[0] == 'U' &&
                    buff_value[1] == 'P' &&
                    buff_value[2] == 'D' &&
                    buff_value[3] == 'A' &&
                    buff_value[4] == 'T' &&
                    buff_value[5] == 'E')
            {
                char r;
                cli();
                wdt_disable();

                while (1)
                {
                    if (UCSR0A & (1<<RXC0))
                    {
                        r = UDR0;
                        UDR3 = r;
                    }

                    if (UCSR3A & (1<<RXC3))
                    {
                        r = UDR3;
                        UDR0 = r;
                    }
                }
            }
            else {
                if (buff_value[0]=='E' && buff_value[1]=='R' && buff_value[2]=='A' && buff_value[3]=='S' && buff_value[4]=='E')
                {
                    eeprom::factoryResetEEPROM();
                    Motherboard::getBoard().reset(true);
                }
                
                else if (buff_value[0]=='F' && buff_value[1]=='U' && buff_value[2]=='L' && buff_value[3]=='L' && buff_value[4]=='E' && buff_value[5]=='R' && buff_value[6]=='A' && buff_value[7]=='S' && buff_value[8]=='E')
                {
                    eeprom::erase();
                    host::stopBuildNow();
                }
            }
            break;
*/
        default:
            break;
    }
}
static void cancelMaterialInsert()
{
    digipot_current(2, motor_current_setting[2]);//Set E motor power to default.
    doCooldown();
    enquecommand_P(PSTR("G28 X0 Y0"));
}
static void lcd_menu_material_main_return()
{
    doCooldown();
    enquecommand_P(PSTR("G28 X0 Y0"));
    currentMenu = lcd_menu_material_main;
}
static void parkHeadForHeating()
{
    lcd_material_reset_defaults();
    enquecommand_P(PSTR("G1 F12000 X110 Y10"));
    enquecommand_P(PSTR("M84"));//Disable motor power.
}
Exemple #15
0
static void laser_test_fire(uint8_t power, uint8_t dwell) {
	enquecommand_P(PSTR("M80"));  // Enable laser accessories since we don't know if its been done (and there's no penalty for doing it again).
    laser_fire(power);
	delay(dwell);
	laser_extinguish();
}
Exemple #16
0
static void action_laser_acc_off() {
	enquecommand_P(PSTR("M81"));
}
static void parkHeadForHeating()
{
    enquecommand_P(PSTR("G1 F12000 X110 Y0"));
}
static void homeBed()
{
    add_homeing[Z_AXIS] += 0.2;//Adjust the Z homing position to account for the thickness of the paper.
    enquecommand_P(PSTR("G28 Z0"));
}
Exemple #19
0
////i2
static void lcd_calibrate_bed()
{
enquecommand_P(PSTR("G21"));//set units to millimeters
if (fil_temp == 200)
{
enquecommand_P(PSTR("M190 S60"));//wait for bed temperature to be reached
enquecommand_P(PSTR("M104 S200"));//set temperature
}
if (fil_temp == 230)	
{
enquecommand_P(PSTR("M190 S80"));//wait for bed temperature to be reached
enquecommand_P(PSTR("M104 S230"));//set temperature
}
enquecommand_P(PSTR("G28 X0 Y0"));//Home x and y axis
enquecommand_P(PSTR("G1 X20 Y20 F4000"));//Center extruder above bed
enquecommand_P(PSTR("G28 Z0"));
enquecommand_P(PSTR("G1 Z5 F5000"));//lift nozzle
if (fil_temp == 200)
{
enquecommand_P(PSTR("M109 S200"));//set temperature
}
if (fil_temp == 230)	
{
enquecommand_P(PSTR("M109 S230"));//set temperature
}
enquecommand_P(PSTR("G90"));//use absolute coordinates
enquecommand_P(PSTR("G92 E0"));
enquecommand_P(PSTR("M82"));//use absolute distances for extrusion
//if (fil_temp == 200)
//{
//enquecommand_P(PSTR("M106 S255"));
//}
enquecommand_P(PSTR("G1 E-1.00000 F1020.00000"));//
enquecommand_P(PSTR("G92 E0"));//
enquecommand_P(PSTR("G1 Z0.250 F6000.000"));//
enquecommand_P(PSTR("G1 X27.500 Y27.500 F6000.000"));//
enquecommand_P(PSTR("G1 E1.00000 F1020.00000"));//
enquecommand_P(PSTR("G1 X272.290 Y27.500 E10.32102 F1200.000"));//
enquecommand_P(PSTR("G1 X272.464 Y27.536 E10.32778"));//
enquecommand_P(PSTR("G1 X272.500 Y27.710 E10.33455"));//
enquecommand_P(PSTR("G1 X272.500 Y272.290 E19.64757"));//
enquecommand_P(PSTR("G1 X272.464 Y272.464 E19.65433"));//
enquecommand_P(PSTR("G1 X272.290 Y272.500 E19.66110"));//
enquecommand_P(PSTR("G1 X27.710 Y272.500 E28.97412"));//
enquecommand_P(PSTR("G1 X27.536 Y272.464 E28.98089"));//
enquecommand_P(PSTR("G1 X27.500 Y272.290 E28.98765"));//
enquecommand_P(PSTR("G1 X27.500 Y34.710 E38.03413"));//
enquecommand_P(PSTR("G1 X27.536 Y34.536 E38.04089"));//
enquecommand_P(PSTR("G1 X27.710 Y34.500 E38.04766"));//
enquecommand_P(PSTR("G1 X260.459 Y34.500 E46.91018"));//
enquecommand_P(PSTR("G1 E45.91018 F1020.00000"));//
enquecommand_P(PSTR("G92 E0"));//
enquecommand_P(PSTR("G1 Z3 F6000"));//
//if (fil_temp == 200)
//{
//enquecommand_P(PSTR("M107"));
//}
enquecommand_P(PSTR("G28 X0"));//turn off temperature
enquecommand_P(PSTR("M84"));
enquecommand_P(PSTR("G28 X0"));//home X axis
enquecommand_P(PSTR("M84"));//disable motors
enquecommand_P(PSTR("M140 S0"));//turn off heatbed
fil_temp = 0;
lcd_return_to_status();
}
Exemple #20
0
	static void reprapworld_keypad_move_home() {
		enquecommand_P((PSTR("G28"))); // move all axis home
	}
Exemple #21
0
static void menu_action_gcode(const char* pgcode)
{
    enquecommand_P(pgcode);
}
 static void reprapworld_keypad_move_home() {
     //enquecommand_P((PSTR("G28"))); // move all axis home
     // TODO gregor: move all axis home, i have currently only one axis on my prusa i3
     enquecommand_P((PSTR("G28 Y")));
 }
Exemple #23
0
static void action_laser_test_100_30000ms() {
	enquecommand_P(PSTR("M6"));
}
static void lcd_menu_print_tune()
{
    lcd_scroll_menu(PSTR("TUNE"), 7 + EXTRUDERS * 2, tune_item_callback, tune_item_details_callback);
    if (lcd_lib_button_pressed)
    {
        if (IS_SELECTED_SCROLL(0))
        {
            if (card.sdprinting)
                lcd_change_to_menu(lcd_menu_print_printing);
            else
                lcd_change_to_menu(lcd_menu_print_heatup);
        }else if (IS_SELECTED_SCROLL(1))
        {
            if (card.sdprinting)
            {
                if (card.pause)
                {
                    if (movesplanned() < 1)
                    {
                        card.pause = false;
                        lcd_lib_beep();
                    }
                }
                else
                {
                    if (movesplanned() > 0 && commands_queued() < BUFSIZE)
                    {
                        lcd_lib_beep();
                        card.pause = true;
                        if (current_position[Z_AXIS] < 170)
                            enquecommand_P(PSTR("M601 X10 Y20 Z20 L30"));
                        else if (current_position[Z_AXIS] < 200)
                            enquecommand_P(PSTR("M601 X10 Y20 Z2 L30"));
                        else
                            enquecommand_P(PSTR("M601 X10 Y20 Z0 L30"));
                    }
                }
            }
        }else if (IS_SELECTED_SCROLL(2))
            LCD_EDIT_SETTING(feedmultiply, "Print speed", "%", 10, 1000);
        else if (IS_SELECTED_SCROLL(3))
            lcd_change_to_menu(lcd_menu_print_tune_heatup_nozzle0, 0);
#if EXTRUDERS > 1
        else if (IS_SELECTED_SCROLL(4))
            lcd_change_to_menu(lcd_menu_print_tune_heatup_nozzle1, 0);
#endif
        else if (IS_SELECTED_SCROLL(3 + EXTRUDERS))
            lcd_change_to_menu(lcd_menu_maintenance_advanced_bed_heatup, 0);//Use the maintainace heatup menu, which shows the current temperature.
        else if (IS_SELECTED_SCROLL(4 + EXTRUDERS))
            LCD_EDIT_SETTING_BYTE_PERCENT(fanSpeed, "Fan speed", "%", 0, 100);
        else if (IS_SELECTED_SCROLL(5 + EXTRUDERS))
            LCD_EDIT_SETTING(extrudemultiply[0], "Material flow", "%", 10, 1000);
#if EXTRUDERS > 1
        else if (IS_SELECTED_SCROLL(6 + EXTRUDERS))
            LCD_EDIT_SETTING(extrudemultiply[1], "Material flow 2", "%", 10, 1000);
#endif
        else if (IS_SELECTED_SCROLL(5 + EXTRUDERS * 2))
            lcd_change_to_menu(lcd_menu_print_tune_retraction);
        else if (IS_SELECTED_SCROLL(6 + EXTRUDERS * 2))
            LCD_EDIT_SETTING(led_brightness_level, "Brightness", "%", 0, 100);
    }
}
void lcd_menu_print_select()
{
    if (!card.sdInserted)
    {
        LED_GLOW();
        lcd_lib_encoder_pos = MAIN_MENU_ITEM_POS(0);
        lcd_info_screen(lcd_menu_main);
        lcd_lib_draw_string_centerP(15, PSTR("No SD-CARD!"));
        lcd_lib_draw_string_centerP(25, PSTR("Please insert card"));
        lcd_lib_update_screen();
        card.release();
        return;
    }
    if (!card.isOk())
    {
        lcd_info_screen(lcd_menu_main);
        lcd_lib_draw_string_centerP(16, PSTR("Reading card..."));
        lcd_lib_update_screen();
        lcd_clear_cache();
        card.initsd();
        return;
    }
    
    if (LCD_CACHE_NR_OF_FILES() == 0xFF)
        LCD_CACHE_NR_OF_FILES() = card.getnrfilenames();
    if (card.errorCode())
    {
        LCD_CACHE_NR_OF_FILES() = 0xFF;
        return;
    }
    uint8_t nrOfFiles = LCD_CACHE_NR_OF_FILES();
    if (nrOfFiles == 0)
    {
        if (card.atRoot())
            lcd_info_screen(lcd_menu_main, NULL, PSTR("OK"));
        else
            lcd_info_screen(lcd_menu_print_select, cardUpdir, PSTR("OK"));
        lcd_lib_draw_string_centerP(25, PSTR("No files found!"));
        lcd_lib_update_screen();
        lcd_clear_cache();
        return;
    }
    
    if (lcd_lib_button_pressed)
    {
        uint8_t selIndex = uint16_t(SELECTED_SCROLL_MENU_ITEM());
        if (selIndex == 0)
        {
            if (card.atRoot())
            {
                lcd_change_to_menu(lcd_menu_main);
            }else{
                lcd_clear_cache();
                lcd_lib_beep();
                card.updir();
            }
        }else{
            card.getfilename(selIndex - 1);
            if (!card.filenameIsDir)
            {
                //Start print
                active_extruder = 0;
                card.openFile(card.filename, true);
                if (card.isFileOpen() && !is_command_queued())
                {
                    if (led_mode == LED_MODE_WHILE_PRINTING || led_mode == LED_MODE_BLINK_ON_DONE)
                        analogWrite(LED_PIN, 255 * int(led_brightness_level) / 100);
                    if (!card.longFilename[0])
                        strcpy(card.longFilename, card.filename);
                    card.longFilename[20] = '\0';
                    if (strchr(card.longFilename, '.')) strchr(card.longFilename, '.')[0] = '\0';
                    
                    char buffer[64];
                    card.fgets(buffer, sizeof(buffer));
                    buffer[sizeof(buffer)-1] = '\0';
                    while (strlen(buffer) > 0 && buffer[strlen(buffer)-1] < ' ') buffer[strlen(buffer)-1] = '\0';
                    if (strcmp_P(buffer, PSTR(";FLAVOR:UltiGCode")) != 0)
                    {
                        card.fgets(buffer, sizeof(buffer));
                        buffer[sizeof(buffer)-1] = '\0';
                        while (strlen(buffer) > 0 && buffer[strlen(buffer)-1] < ' ') buffer[strlen(buffer)-1] = '\0';
                    }
                    card.setIndex(0);
                    if (strcmp_P(buffer, PSTR(";FLAVOR:UltiGCode")) == 0)
                    {
                        //New style GCode flavor without start/end code.
                        // Temperature settings, filament settings, fan settings, start and end-code are machine controlled.
                        target_temperature_bed = 0;
                        fanSpeedPercent = 0;
                        for(uint8_t e=0; e<EXTRUDERS; e++)
                        {
                            if (LCD_DETAIL_CACHE_MATERIAL(e) < 1)
                                continue;
                            target_temperature[e] = 0;//material[e].temperature;
                            target_temperature_bed = max(target_temperature_bed, material[e].bed_temperature);
                            fanSpeedPercent = max(fanSpeedPercent, material[0].fan_speed);
                            volume_to_filament_length[e] = 1.0 / (M_PI * (material[e].diameter / 2.0) * (material[e].diameter / 2.0));
                            extrudemultiply[e] = material[e].flow;
                        }
                        
                        fanSpeed = 0;
                        enquecommand_P(PSTR("G28"));
                        enquecommand_P(PSTR("G1 F12000 X5 Y10"));
                        lcd_change_to_menu(lcd_menu_print_heatup);
                    }else{
                        //Classic gcode file
                        
                        //Set the settings to defaults so the classic GCode has full control
                        fanSpeedPercent = 100;
                        for(uint8_t e=0; e<EXTRUDERS; e++)
                        {
                            volume_to_filament_length[e] = 1.0;
                            extrudemultiply[e] = 100;
                        }
                        
                        lcd_change_to_menu(lcd_menu_print_classic_warning, MAIN_MENU_ITEM_POS(0));
                    }
                }
            }else{
                lcd_lib_beep();
                lcd_clear_cache();
                card.chdir(card.filename);
                SELECT_SCROLL_MENU_ITEM(0);
            }
            return;//Return so we do not continue after changing the directory or selecting a file. The nrOfFiles is invalid at this point.
        }
    }
    lcd_scroll_menu(PSTR("SD CARD"), nrOfFiles+1, lcd_sd_menu_filename_callback, lcd_sd_menu_details_callback);
}
Exemple #26
0
////i2
static void lcd_calibrate_bed()
{
enquecommand_P(PSTR("G21"));//set units to millimeters
if (fil_temp == 200)
{
enquecommand_P(PSTR("M104 S200"));//set temperature
}
if (fil_temp == 230)	
{
enquecommand_P(PSTR("M190 S100"));//wait for bed temperature to be reached
enquecommand_P(PSTR("M104 S230"));//set temperature
}
enquecommand_P(PSTR("G28 X0 Y0"));//Home x and y axis
enquecommand_P(PSTR("G1 X20 Y20 F4000"));//Center extruder above bed
enquecommand_P(PSTR("G28 Z0"));
enquecommand_P(PSTR("G1 Z5 F5000"));//lift nozzle
if (fil_temp == 200)
{
enquecommand_P(PSTR("M109 S200"));//set temperature
}
if (fil_temp == 230)	
{
enquecommand_P(PSTR("M109 S230"));//set temperature
}
enquecommand_P(PSTR("G90"));//use absolute coordinates
enquecommand_P(PSTR("G92 E0"));
enquecommand_P(PSTR("M82"));//use absolute distances for extrusion
//if (fil_temp == 200)
//{
//enquecommand_P(PSTR("M106 S255"));
//}
enquecommand_P(PSTR("G1 F900.000 E-0.90000"));
enquecommand_P(PSTR("G92 E0"));
enquecommand_P(PSTR("G1 Z0.250 F1002"));
enquecommand_P(PSTR("G1 X9.985 Y9.985 F9000"));
enquecommand_P(PSTR("G1 E0.0000 F297"));
enquecommand_P(PSTR("G92 E0"));
enquecommand_P(PSTR("G1 X140.015 Y9.985 E5.6763 F864"));
enquecommand_P(PSTR("G1 X140.015 Y135.015 E11.1344"));
enquecommand_P(PSTR("G1 X20.210 Y135.015 E16.3643"));
enquecommand_P(PSTR("G1 X20.210 Y134.985 E16.3656"));
enquecommand_P(PSTR("G1 X139.985 Y134.985 E21.5943"));
enquecommand_P(PSTR("G1 X139.985 Y10.015 E27.0497"));
enquecommand_P(PSTR("G1 X10.015 Y10.015 E32.7234"));
enquecommand_P(PSTR("G1 X10.015 Y139.985 E38.3971"));
enquecommand_P(PSTR("G1 X139.790 Y139.985 E44.0623"));
enquecommand_P(PSTR("G1 X139.790 Y140.015 E44.0636"));
enquecommand_P(PSTR("G1 X9.985 Y140.015 E49.7301"));
enquecommand_P(PSTR("G1 X9.985 Y9.985 E55.4064"));
enquecommand_P(PSTR("G92 E0"));
enquecommand_P(PSTR("G1 Z5"));
//if (fil_temp == 200)
//{
//enquecommand_P(PSTR("M107"));
//}
enquecommand_P(PSTR("G28 X0"));//turn off temperature
enquecommand_P(PSTR("M84"));
enquecommand_P(PSTR("G28 X0"));//home X axis
enquecommand_P(PSTR("M84"));//disable motors
//enquecommand_P(PSTR("M140 S0"));//turn off heatbed
fil_temp = 0;
lcd_return_to_status();
}