コード例 #1
0
ファイル: umcwriter.c プロジェクト: companje/UP3D
void umcwriter_set_bed_temp(int32_t temp, bool wait)
{
  umcwriter_planner_sync();

  UP3D_BLK blk;
 
  if( temp )
  {
    UP3D_PROG_BLK_SetParameter(&blk,0x43,temp); //TEMP FOR BED_TEMP_REACHED
   _umcwriter_write_file(&blk, 1);
  }

  UP3D_PROG_BLK_SetParameter(&blk,PARA_BED_TEMP,temp);
  _umcwriter_write_file(&blk, 1);
  UP3D_PROG_BLK_SetParameter(&blk,PARA_HEATER_BED_ON,(temp)?1:0);
  _umcwriter_write_file(&blk, 1);

  if(wait && (temp>umcwriter_bed_temp) ) //only wait if new temperature is higher
  {
    UP3D_PROG_BLK_SetParameter(&blk,PARA_RED_BLUE_BLINK,400);
    _umcwriter_write_file(&blk, 1);

    uint32_t waitsec = ((temp-umcwriter_bed_temp)/settings.heatbed_wait_factor)*60;
    umcwriter_pause(waitsec*1000);

    UP3D_PROG_BLK_SetParameter(&blk,PARA_RED_BLUE_BLINK,200);
    _umcwriter_write_file(&blk, 1);

    umcwriter_set_report_data(-1,-1);

    umcwriter_bed_temp = temp;
  }
}
コード例 #2
0
ファイル: umcwriter.c プロジェクト: companje/UP3D
void umcwriter_user_pause()
{
  umcwriter_planner_sync();

  umcwriter_print_time += 2; //2 seconds for processing

  UP3D_BLK blks[2];
  UP3D_PROG_BLK_MoveF( blks,150,0,150,0,10000,30,10000,0 );
  _umcwriter_write_file(blks, 2);

  umcwriter_beep(500);

  UP3D_BLK blk;
  
  UP3D_PROG_BLK_SetParameter(&blk,PARA_PAUSE_PROGRAM,1);
  _umcwriter_write_file(&blk, 1);

  UP3D_PROG_BLK_SetParameter(&blk,PARA_PRINT_STATUS,3);
  _umcwriter_write_file(&blk, 1);

  umcwriter_beep(500);

  UP3D_PROG_BLK_MoveF( blks,150,0,150,0,10000,-30,10000,0 );
  _umcwriter_write_file(blks, 2);
}
コード例 #3
0
ファイル: umcwriter.c プロジェクト: companje/UP3D
void umcwriter_set_report_data(int32_t layer, double height)
{
  UP3D_BLK blk;

  if( layer>=0 )
  {
    UP3D_PROG_BLK_SetParameter(&blk,PARA_REPORT_LAYER,layer);
    _umcwriter_write_file(&blk, 1);
  }

  if( height>=0 )
  {
    float h = (float)height;
    UP3D_PROG_BLK_SetParameter(&blk,PARA_REPORT_HEIGHT,*((int32_t*)&h));
    _umcwriter_write_file(&blk, 1);
  }

  UP3D_PROG_BLK_SetParameter(&blk,PARA_REPORT_TIME_REMAIN,(int32_t)umcwriter_print_time);
  _umcwriter_write_file(&blk, 1);

  UP3D_PROG_BLK_SetParameter(&blk,PARA_REPORT_PERCENT,0);
  _umcwriter_write_file(&blk, 1);
}
コード例 #4
0
ファイル: umcwriter.c プロジェクト: companje/UP3D
void umcwriter_set_extruder_temp(double temp, bool wait)
{
  umcwriter_planner_sync();

  UP3D_BLK blk;

  if( temp )
  {
    //TODO: always ???
    UP3D_PROG_BLK_SetParameter(&blk,0x17,1);              //nozzle #1 open
    _umcwriter_write_file(&blk, 1);
  }

  if( temp )
  {
    UP3D_PROG_BLK_SetParameter(&blk,0x41,temp);          //TEMP FOR NOZZLE1_TEMP_REACHED
    _umcwriter_write_file(&blk, 1);
  }

  UP3D_PROG_BLK_SetParameter(&blk,PARA_NOZZLE1_TEMP,temp);
  _umcwriter_write_file(&blk, 1);
  UP3D_PROG_BLK_SetParameter(&blk,PARA_HEATER_NOZZLE1_ON,(temp)?1:0);
  _umcwriter_write_file(&blk, 1);

  if(wait)
  {
    umcwriter_print_time += 120; //apx. 2 minutes
  
    UP3D_PROG_BLK_SetParameter(&blk,PARA_RED_BLUE_BLINK,100);
    _umcwriter_write_file(&blk, 1);

    UP3D_PROG_BLK_WaitIfNot( &blk, PARA_TEMP_REACHED_N1, 1, '=' );
    _umcwriter_write_file(&blk, 1);

    UP3D_PROG_BLK_SetParameter(&blk,PARA_RED_BLUE_BLINK,200);
    _umcwriter_write_file(&blk, 1);

    umcwriter_set_report_data(-1,-1);
  }
}
コード例 #5
0
ファイル: umcwriter.c プロジェクト: companje/UP3D
bool umcwriter_init(const char* filename, const double heightZ, const char machine_type)
{
  umcwriter_Z = 0;
  umcwriter_Z_height = heightZ;
  umcwriter_print_time = 0;
  umcwriter_machine_type = machine_type;
  umcwriter_bed_temp = 0;

  st_reset();
  plan_reset();

  umcwriter_file = fopen(filename,"wb+");
  if( !umcwriter_file )
    return false;

  umcwriter_set_report_data( 0, 0 );

  UP3D_BLK blk;
  UP3D_PROG_BLK_Power(&blk,true);
  _umcwriter_write_file(&blk, 1);

  umcwriter_pause(4000); //wait for power on complete and temperature measurement to stabilize

  UP3D_PROG_BLK_SetParameter(&blk,0x41,0);              //TEMP FOR NOZZLE1 TEMP REACHED
  _umcwriter_write_file(&blk, 1);
  UP3D_PROG_BLK_SetParameter(&blk,0x42,0);              //TEMP FOR NOZZLE2 TEMP REACHED
  _umcwriter_write_file(&blk, 1);
  UP3D_PROG_BLK_SetParameter(&blk,0x43,0);              //TEMP FOR BED TEMP REACHED
  _umcwriter_write_file(&blk, 1);

// NEEDED?
  UP3D_PROG_BLK_SetParameter(&blk,0x46,13);               //?
  _umcwriter_write_file(&blk, 1);

  if( 'm' == umcwriter_machine_type )
  {
    UP3D_PROG_BLK_SetParameter(&blk,0x49,80);           //? for up mini only!
    _umcwriter_write_file(&blk, 1);
  }

  //home all axis (needed for correct print status
  umcwriter_home(0);
  umcwriter_home(1);
  umcwriter_home(2);

  UP3D_PROG_BLK_SetParameter(&blk,PARA_PRINT_STATUS,1); //initialized
  _umcwriter_write_file(&blk, 1);
  UP3D_PROG_BLK_SetParameter(&blk,0x11,0);              //no support
  _umcwriter_write_file(&blk, 1);

// NEEDED ?
  UP3D_PROG_BLK_SetParameter(&blk,0x35,0);              //needed for heat bed!
  _umcwriter_write_file(&blk, 1);
//  UP3D_PROG_BLK_SetParameter(&blk,0x36,103);            //feedback length ?
//  _umcwriter_write_file(&blk, 1);

//  UP3D_PROG_BLK_SetParameter(&blk,0x2A,5000);           //change nozzle time
//  _umcwriter_write_file(&blk, 1);
//  UP3D_PROG_BLK_SetParameter(&blk,0x2B,0);              //jump time
//  _umcwriter_write_file(&blk, 1);

  UP3D_PROG_BLK_SetParameter(&blk,0x17,0);              //nozzle #1 not open
  _umcwriter_write_file(&blk, 1);

// PROBLEM...
//  UP3D_PROG_BLK_SetParameter(&blk,PARA_PRINT_STATUS,2); //running ==> PAUSED ???
//  _umcwriter_write_file(&blk, 1);
//

// NEEDED?
  UP3D_PROG_BLK_SetParameter(&blk,0x82,255);            //?
  _umcwriter_write_file(&blk, 1);
  UP3D_PROG_BLK_SetParameter(&blk,0x83,255);            //?
  _umcwriter_write_file(&blk, 1);
  //DEL UP3D_PROG_BLK_SetParameter(&blk,0x1D,100000);         //feed error length
  //DEL _umcwriter_write_file(&blk, 1);


/* PROBLEM...
  UP3D_PROG_BLK_SetParameter(&blk,0x1C,1);              //printing...
  _umcwriter_write_file(&blk, 1);
*/
  return true;
}
コード例 #6
0
ファイル: umcwriter.c プロジェクト: companje/UP3D
void umcwriter_finish()
{
  umcwriter_planner_sync();

  umcwriter_print_time += 1.5; //1.5 seconds for end of job

  umcwriter_beep(200);umcwriter_pause(200);
  umcwriter_beep(200);umcwriter_pause(200);
  umcwriter_beep(200);umcwriter_pause(500);

  UP3D_BLK blk;

  //post process time and perecent values
  rewind( umcwriter_file );
  double time = 0;
  for(;;)
  {
    if( fread( &blk, sizeof(UP3D_BLK), 1, umcwriter_file ) <= 0 )
      break;

    if( UP3DPCMD_SetParameter == blk.pcmd )
    {
      bool change = false;
      if( PARA_REPORT_TIME_REMAIN == blk.pdat1.l )
      {
        time = blk.pdat2.l;
        blk.pdat2.l = (int32_t)(umcwriter_print_time - time);
        change=true;
      }
      if( PARA_REPORT_PERCENT == blk.pdat1.l )
      {
        blk.pdat2.l = (time*100)/umcwriter_print_time;
        change=true;
      }

      if( change )
      {
        fseek( umcwriter_file, -sizeof(UP3D_BLK), SEEK_CUR );
        fwrite( &blk, sizeof(UP3D_BLK), 1, umcwriter_file );
        fseek( umcwriter_file, 0, SEEK_CUR ); //workaround for windows bug
      }
    }
  }

  UP3D_PROG_BLK_SetParameter(&blk,PARA_REPORT_PERCENT,100);
  _umcwriter_write_file(&blk, 1);
  UP3D_PROG_BLK_SetParameter(&blk,PARA_REPORT_TIME_REMAIN,0);
  _umcwriter_write_file(&blk, 1);

  UP3D_PROG_BLK_Power(&blk,false);
  _umcwriter_write_file(&blk, 1);

  UP3D_PROG_BLK_SetParameter(&blk,0x1C,0); //not printing...
  _umcwriter_write_file(&blk, 1);

  UP3D_PROG_BLK_SetParameter(&blk,PARA_PRINT_STATUS,0); //not ready
  _umcwriter_write_file(&blk, 1);

  UP3D_PROG_BLK_Stop(&blk);
  _umcwriter_write_file(&blk, 1);

  fclose( umcwriter_file );
  umcwriter_file = NULL;
}
コード例 #7
0
ファイル: upshell.c プロジェクト: aiQon/UP3D
int main(int argc, char *argv[])
{
  if( !UP3D_Open() )
    return -1;

  signal(SIGINT, sigfinish);   // set sigint handler
#ifdef SIGWINCH
  signal(SIGWINCH, sigwinch);  // set sigint handler
#endif

  initscr();                   // initialize the curses library
  raw();                       // line buffering disabled
  keypad(stdscr, TRUE);        // enable keyboard mapping
  nonl();                      // tell curses not to do NL->CR/NL on output
  cbreak();                    // take input chars one at a time, no wait for \n
  noecho();                    // getch no echo
  nodelay(stdscr, TRUE);       // getch nonblocking
  curs_set(0);                 // no visible cursor
  
  if( has_colors() )
  {
    start_color();
    use_default_colors();
    init_pair(1, -1, -1);
    init_pair(2, COLOR_RED,     -1);
    init_pair(3, COLOR_GREEN,   -1);
    init_pair(4, COLOR_YELLOW,  -1);
    init_pair(5, COLOR_BLUE,    -1);
    init_pair(6, COLOR_CYAN,    -1);
    init_pair(7, COLOR_MAGENTA, -1);
    init_pair(8, COLOR_WHITE,   COLOR_BLACK);

    bkgd(COLOR_PAIR(1));
  }

  //initial draw
  update_state(true);

  //the loop
  for(;;)
  {
    int c = getch();

    switch( c )
    {
      case 0x12: update_state(true); break; // CTRL-R

      case 'p':
       {
         UP3D_BLK blk;
         UP3D_ClearProgramBuf();
         UP3D_PROG_BLK_Power(&blk,true);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
         UP3D_SetParameter(0x94,999); //set best accuracy for reporting position
       }
       break;
      case 'q':
       {
         UP3D_BLK blk;
         UP3D_ClearProgramBuf();
         UP3D_PROG_BLK_Power(&blk,false);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
         sigfinish(0);
       }
       break;

      case '0':
       {
         UP3D_ClearProgramBuf();
         UP3D_InsertRomProgram(0);
         UP3D_StartResumeProgram();
       }
       break;

      case 'b':
       {
         UP3D_BLK blk;
         UP3D_ClearProgramBuf();
         UP3D_PROG_BLK_Beeper(&blk,true);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_Pause(&blk,100);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_Beeper(&blk,false);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_Pause(&blk,100);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_Beeper(&blk,true);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_Pause(&blk,100);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_Beeper(&blk,false);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
       }
       break;

      case 'h':
       {
         UP3D_BLK blk;
         UP3D_BLK blksHome[2];
         UP3D_ClearProgramBuf();
         UP3D_PROG_BLK_Home( blksHome, UP3DAXIS_Z ); UP3D_WriteBlocks(blksHome,2);
         UP3D_PROG_BLK_Home( blksHome, UP3DAXIS_Y ); UP3D_WriteBlocks(blksHome,2);
         UP3D_PROG_BLK_Home( blksHome, UP3DAXIS_X ); UP3D_WriteBlocks(blksHome,2);
         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
       }
       break;

      case '1':
       {
         UP3D_BLK blk;
         UP3D_BLK blksMoveF[2];
         UP3D_ClearProgramBuf();
         UP3D_PROG_BLK_MoveF( blksMoveF,-150,-60.0,-150,60.0,0,0,0,0);
         UP3D_WriteBlocks(blksMoveF,2);
         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
       }
       break;

      case '2':
       {
         UP3D_BLK blk;
         UP3D_ClearProgramBuf();
         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
       }
       break;

      case '3':
       {
         UP3D_BLK blk;
         UP3D_ClearProgramBuf();
UP3D_PROG_BLK_MoveL(&blk,21,23809,-7,0,0,-495,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,1581,24984,-10924,0,0,0,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,21,23809,-10403,0,0,495,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,1,100,512,0,0,0,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,21,23809,7,0,0,495,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,1581,24984,10924,0,0,0,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,1,100,512,0,0,0,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,21,23809,10403,0,0,-495,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,1,100,512,0,0,0,0,0);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
       }
       break;

      case '4':
       {
         UP3D_BLK blk;
         UP3D_ClearProgramBuf();
/*        
UP3D_PROG_BLK_MoveL(&blk,21,23809,-7,0,0,-495,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,1581,24984,-10924,0,0,0,0,0);UP3D_WriteBlock(&blk);
//UP3D_PROG_BLK_MoveL(&blk,21,23809,-10403,0,0,495,0,0);UP3D_WriteBlock(&blk);
//UP3D_PROG_BLK_MoveL(&blk,1,100,512,0,0,0,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,21,23809,-10403+24,0,0,495,0,0);UP3D_WriteBlock(&blk);
*/
UP3D_PROG_BLK_MoveL(&blk,21,23809,5,0,0,-495,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,1581,24984,-10924,0,0,0,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,21,23809,-10391,0,0,495,0,0);UP3D_WriteBlock(&blk);

         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
       }
       break;

      case '5':
       {
         UP3D_BLK blk;
         UP3D_ClearProgramBuf();
/*
UP3D_PROG_BLK_MoveL(&blk,21,23809,7,0,0,495,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,1581,24984,10924,0,0,0,0,0);UP3D_WriteBlock(&blk);
//UP3D_PROG_BLK_MoveL(&blk,1,100,512,0,0,0,0,0);UP3D_WriteBlock(&blk);
//UP3D_PROG_BLK_MoveL(&blk,21,23809,10403,0,0,-495,0,0);UP3D_WriteBlock(&blk);
//UP3D_PROG_BLK_MoveL(&blk,1,100,512,0,0,0,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,21,23809,10403+48,0,0,-495,0,0);UP3D_WriteBlock(&blk);
*/
UP3D_PROG_BLK_MoveL(&blk,21,23809,19,0,0,495,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,1581,24984,10924,0,0,0,0,0);UP3D_WriteBlock(&blk);
UP3D_PROG_BLK_MoveL(&blk,21,23809,10440,0,0,-495,0,0);UP3D_WriteBlock(&blk);

         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
       }
       break;

      case '6':
       {
         UP3D_BLK blk;
         UP3D_ClearProgramBuf();

         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
       }
       break;

      case '7':
       {
         UP3D_BLK blk;
         UP3D_ClearProgramBuf();

         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
         UP3D_StartResumeProgram();
       }
       break;

      case '8':
       {
/*
         UP3D_BLK blk;
         UP3D_ClearProgramBuf();

  UP3D_UseSDProgramBuf( 3, true );
  
  UP3D_BLK blksHome[2];
  UP3D_ClearProgramBuf();
  UP3D_PROG_BLK_Home( blksHome, UP3DAXIS_Z ); UP3D_WriteBlocks(blksHome,2);
  UP3D_PROG_BLK_Home( blksHome, UP3DAXIS_Y ); UP3D_WriteBlocks(blksHome,2);
  UP3D_PROG_BLK_Home( blksHome, UP3DAXIS_X ); UP3D_WriteBlocks(blksHome,2);

  UP3D_BLK blks[2];
  UP3D_PROG_BLK_MoveF( blks,-1000,0,-1000,0,-1000,-100,-1000,0);
  UP3D_WriteBlocks(blks,2);
  
         UP3D_PROG_BLK_Stop(&blk);UP3D_WriteBlock(&blk);
*/

         UP3D_ClearProgramBuf();
         UP3D_UseSDProgramBuf( 3, false );
         UP3D_StartResumeProgram();
       }
       break;

      case '9':
       {
         UP3D_BLK blk;
         UP3D_SetPrintJobInfo( 9, 0, 0 );
         UP3D_ClearProgramBuf();
         UP3D_UseSDProgramBuf( 9, true );

         UP3D_PROG_BLK_Power(&blk,true);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_SetParameter(&blk,PARA_BED_TEMP,100);UP3D_WriteBlock(&blk);
         UP3D_PROG_BLK_SetParameter(&blk,PARA_HEATER_BED_ON,1);UP3D_WriteBlock(&blk);

         UP3D_BLK sblk[3];
         UP3D_PROG_BLK_Stop(&sblk[0]);
         UP3D_PROG_BLK_Stop(&sblk[1]);
         UP3D_PROG_BLK_Stop(&sblk[2]);
         UP3D_WriteBlocks(sblk,3);
         UP3D_WriteBlocks(sblk,3);

         UP3D_SetPrintJobInfo( 9, 1, 0 );

         UP3D_UseSDProgramBuf( 9, false );
         UP3D_ClearProgramBuf();
//         UP3D_StartResumeProgram();
       }
       break;


      case 'a':
       UP3D_SetParameter(0x94,99); //set smaller accuracy
       break;


      case 't':
       UP3D_SetParameter(0x39,65);  //NOZZLE1 SET TEMP
       UP3D_SetParameter(0x3A,65);  //NOZZLE2 SET TEMP
       UP3D_SetParameter(0x3B,102); //BED SET TEMP
       UP3D_SetParameter(0x3C,101); //TEMP4 SET TEMP 
       break;

      case 's':
       UP3D_SetParameter(0x10,2);
       break;

      case 'x':
       UP3D_SetParameter(0x14,0); //NOZZLE1 OFF
       UP3D_SetParameter(0x15,0); //NOZZLE1 OFF
       UP3D_SetParameter(0x16,0); //BED OFF
       break;
 
      case 'n':
       UP3D_SetParameter(0x14,1); //NOZZLE1 ON
       break;
      case 'm':
       UP3D_SetParameter(0x16,1); //BED ON
       break;

    }

    update_state(false);

    napms(20);
  }

  sigfinish(0);
  return 0;
}