Example #1
0
void jog_btn_release() {
  uint8_t jog_bits;
  do {
    jog_bits = (~JOGSW_PIN) & JOGSW_MASK; // active low         
    protocol_process(); // process the serial protocol while waiting
    protocol_execute_runtime();
  }
  while (jog_bits); // until released
}    
Example #2
0
void spindle_btn_release() {
  uint8_t spindle_bits;
  do {
    spindle_bits = (~PINOUT_PIN) & (1<<PIN_SPIN_TOGGLE); // active low          
    protocol_process(); // process the serial protocol while waiting
    protocol_execute_runtime();
  }
  while (spindle_bits); // until released
}
Example #3
0
int main(void)
{
  protocol_init();        
  settings_init();  
  plan_init();      
  st_init();        
  spindle_init();   
  gc_init();
  limits_init();  
                    
  for(;;){
    sleep_mode(); // Wait for it ...
    protocol_process(); // ... process the serial protocol
  }
  return 0;   /* never reached */
}
Example #4
0
int main(void)
{
  sei(); // Enable interrupts
  
  serial_init(BAUD_RATE);
  protocol_init();        
  settings_init();  
  plan_init();      
  st_init();        
  spindle_init();   
  gc_init();
  limits_init();
                    
  while (1) {
//     sleep_mode(); // Wait for it ...
    protocol_process(); // ... process the serial protocol
  }
  return 0;   /* never reached */
}
/*! \fn       void app_task_uarttocan(void *pdata)
*
*  \brief     串口转换CAN任务
*
*  \param     无
*
*  \exception 无
*
*  \return    无
*/
void app_task_uarttocan(void *pdata)
{
    /* 防止编译器告警 */
    pdata = pdata;
    /*! 初始化CAN */
    can_init();
    
    /*! 任务循环 */
    for( ; ; )
    {
        /*! 通信协议 */
        if(EXIT_FAILURE == protocol_process())
        {
            debug_msg("E:Protocol process error!", __FILE__, __LINE__);
        }
        else
        {
            /* 任务延时 */
            OSTimeDlyHMSM(0, 0, 0, 1);
        }

        print_can_frame();
    }
}
int startGrbl(void)
{
  // Initialize system
  serial_init(); // Setup serial baud rate and interrupts
  settings_init(); // Load grbl settings from EEPROM
  st_init(); // Setup stepper pins and interrupt timers
  sei(); // Enable interrupts
  
  memset(&sys, 0, sizeof(sys));  // Clear all system variables
  sys.abort = true;   // Set abort to complete initialization
  sys.state = STATE_INIT;  // Set alarm state to indicate unknown initial position
    
//  Wire.begin();

    
    
  for(;;) {

    // Execute system reset upon a system abort, where the main program will return to this loop.
    // Once here, it is safe to re-initialize the system. At startup, the system will automatically
    // reset to finish the initialization process.
    if (sys.abort) {
      // Reset system.
      serial_reset_read_buffer(); // Clear serial read buffer
      plan_init(); // Clear block buffer and planner variables
      gc_init(); // Set g-code parser to default state
      protocol_init(); // Clear incoming line data and execute startup lines
      spindle_init();
      coolant_init();
      limits_init();
      st_reset(); // Clear stepper subsystem variables.
      
        syspos(&encdr_x,&encdr_y,&encdr_z);
        ofst_x=encdr_x;
        ofst_y=encdr_y;
        ofst_z=encdr_z;
        
      // Sync cleared gcode and planner positions to current system position, which is only
      // cleared upon startup, not a reset/abort. 
      sys_sync_current_position();
        
      // Reset system variables.
      sys.abort = false;
      sys.execute = 0;
      if (bit_istrue(settings.flags,BITFLAG_AUTO_START)) { sys.auto_start = true; }
      
      // Check for power-up and set system alarm if homing is enabled to force homing cycle
      // by setting Grbl's alarm state. Alarm locks out all g-code commands, including the
      // startup scripts, but allows access to settings and internal commands. Only a homing
      // cycle '$H' or kill alarm locks '$X' will disable the alarm.
      // NOTE: The startup script will run after successful completion of the homing cycle, but
      // not after disabling the alarm locks. Prevents motion startup blocks from crashing into
      // things uncontrollably. Very bad.
      #ifdef HOMING_INIT_LOCK
        if (sys.state == STATE_INIT && bit_istrue(settings.flags,BITFLAG_HOMING_ENABLE)) { sys.state = STATE_ALARM; }
      #endif
      
      // Check for and report alarm state after a reset, error, or an initial power up.
      if (sys.state == STATE_ALARM) {
        report_feedback_message(MESSAGE_ALARM_LOCK); 
      } else {
        // All systems go. Set system to ready and execute startup script.
        sys.state = STATE_IDLE;
        protocol_execute_startup(); 
      }
    }
      
      

    protocol_execute_runtime();

 //   syspos(&encdr_x,&encdr_y);
      
    protocol_process(); // ... process the serial protocol
    
    
      
  }
  return 0;   /* never reached */
}
Example #7
0
int main(void)
{
  // Initialize system
  serial_init(BAUD_RATE); // Setup serial baud rate and interrupts
  st_init(); // Setup stepper pins and interrupt timers
  sei(); // Enable interrupts

  memset(&sys, 0, sizeof(sys));  // Clear all system variables
  sys.abort = true;   // Set abort to complete initialization

  for(;;) {

    // Execute system reset upon a system abort, where the main program will return to this loop.
    // Once here, it is safe to re-initialize the system. At startup, the system will automatically
    // reset to finish the initialization process.
    if (sys.abort) {

      // Retain last known machine position and work coordinate offset(s). If the system abort
      // occurred while in motion, machine position is not guaranteed, since a hard stop can cause
      // the steppers to lose steps. Always perform a feedhold before an abort, if maintaining
      // accurate machine position is required.
      // TODO: Report last position and coordinate offset to users to help relocate origins. Future
      // releases will auto-reset the machine position back to [0,0,0] if an abort is used while
      // grbl is moving the machine.
/// by LETARTARE 3-> 4
      int32_t last_position[4];
      double last_coord_system[N_COORDINATE_SYSTEM][3];
      memcpy(last_position, sys.position, sizeof(sys.position)); // last_position[] = sys.position[]
      memcpy(last_coord_system, sys.coord_system, sizeof(sys.coord_system)); // last_coord_system[] = sys.coord_system[]

      // Reset system.
      memset(&sys, 0, sizeof(sys)); // Clear all system variables
      serial_reset_read_buffer(); // Clear serial read buffer
      settings_init(); // Load grbl settings from EEPROM
      protocol_init(); // Clear incoming line data
      plan_init(); // Clear block buffer and planner variables
      gc_init(); // Set g-code parser to default state
      spindle_init();
      limits_init();
      coolant_init();
      st_reset(); // Clear stepper subsystem variables.

      // Reload last known machine position and work systems. G92 coordinate offsets are reset.
      memcpy(sys.position, last_position, sizeof(last_position)); // sys.position[] = last_position[]
      memcpy(sys.coord_system, last_coord_system, sizeof(last_coord_system)); // sys.coord_system[] = last_coord_system[]
      gc_set_current_position(last_position[X_AXIS],last_position[Y_AXIS],last_position[Z_AXIS],last_position[C_AXIS]);
      plan_set_current_position(last_position[X_AXIS],last_position[Y_AXIS],last_position[Z_AXIS],last_position[C_AXIS]);

      // Set system runtime defaults
      // TODO: Eventual move to EEPROM from config.h when all of the new settings are worked out.
      // Mainly to avoid having to maintain several different versions.
      #ifdef CYCLE_AUTO_START
        sys.auto_start = true;
      #endif
      // TODO: Install G20/G21 unit default into settings and load appropriate settings.
    }

    protocol_execute_runtime();
    protocol_process(); // ... process the serial protocol

  }
  return 0;   /* never reached */
}
Example #8
0
void gcode_process_line() {
  int status_code;
    
	protocol_process();
 //// process line
  if (strlen(rx_line) > 0) {          // Line is complete. Then execute!
    // handle position update after a stop
    if (position_update_requested) {
      gc.position[X_AXIS] = stepper_get_position_x();
      gc.position[Y_AXIS] = stepper_get_position_y();
      gc.position[Z_AXIS] = stepper_get_position_z();
      position_update_requested = false;
      //printString("gcode pos update\n");  // debug
    }
    
    if (stepper_stop_requested()) {
      status_code = stepper_stop_status();
    } else if (rx_line[0] == '$') {
      printPgmString(PSTR("\nLasaurGrbl " LASAURGRBL_VERSION));
      printPgmString(PSTR("\nSee config.h for configuration.\n"));
      status_code = STATUS_OK;
    } else if (rx_line[0] == '?') {
      printString("X");
      printFloat(stepper_get_position_x());
      printString(" Y");
      printFloat(stepper_get_position_y());
      printString("\n");
      status_code = STATUS_OK;
    } else {
      // process gcode
      status_code = gcode_execute_line(rx_line);
    }    
  } else { 
    // empty or comment line, send ok for consistency
    status_code = STATUS_OK;
  }
  
  //// return status
  if (status_code == STATUS_OK) {
    printPgmString(PSTR("ok\n"));
  } else {
    switch(status_code) {      
      case STATUS_BAD_NUMBER_FORMAT:
        printPgmString(PSTR("Error: Bad number format\n")); break;
      case STATUS_EXPECTED_COMMAND_LETTER:
        printPgmString(PSTR("Error: Expected command letter\n")); break;
      case STATUS_UNSUPPORTED_STATEMENT:
        printPgmString(PSTR("Error: Unsupported statement\n")); break;
      case STATUS_FLOATING_POINT_ERROR:
        printPgmString(PSTR("Error: Floating point error\n")); break;
      case STATUS_STOP_POWER_OFF:
        printPgmString(PSTR("Error: Power Off\n")); break;
      case STATUS_STOP_CHILLER_OFF:
        printPgmString(PSTR("Error: Chiller Off\n")); break;
      case STATUS_STOP_LIMIT_HIT:
        printPgmString(PSTR("Error: Limit Hit\n")); break;                    
      default:
        printPgmString(PSTR("Error: "));
        printInteger(status_code);
        printPgmString(PSTR("\n"));        
    }
  }   
}
Example #9
0
int main(void)
{
#ifdef PART_LM4F120H5QR // ARM code
  SysCtlClockSet( SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_XTAL_16MHZ | SYSCTL_OSC_MAIN ); //set system clock to 80 MHz
  FPUEnable(); //enable the Floating Point Unit
//  FPULazyStackingEnable(); // Enable stacking for interrupt handlers
#endif

  // Initialize system
  serial_init(); // Setup serial baud rate and interrupts
  settings_init(); // Load grbl settings from EEPROM
  st_init(); // Setup stepper pins and interrupt timers

#ifdef PART_LM4F120H5QR // ARM code
  IntMasterEnable();
#else // AVR code
  sei(); // Enable interrupts
#endif
  
  memset(&sys, 0, sizeof(sys));  // Clear all system variables
  sys.abort = true;   // Set abort to complete initialization
  sys.state = STATE_INIT;  // Set alarm state to indicate unknown initial position
  
  for(;;) {
  
    // Execute system reset upon a system abort, where the main program will return to this loop.
    // Once here, it is safe to re-initialize the system. At startup, the system will automatically
    // reset to finish the initialization process.
    if (sys.abort) {
      // Reset system.
      serial_reset_read_buffer(); // Clear serial read buffer
      plan_init(); // Clear block buffer and planner variables
      gc_init(); // Set g-code parser to default state
      protocol_init(); // Clear incoming line data and execute startup lines
      spindle_init();
      coolant_init();
      limits_init();
      st_reset(); // Clear stepper subsystem variables.

      // Sync cleared gcode and planner positions to current system position, which is only
      // cleared upon startup, not a reset/abort. 
      sys_sync_current_position();

      // Reset system variables.
      sys.abort = false;
      sys.execute = 0;
      if (bit_istrue(settings.flags,BITFLAG_AUTO_START)) { sys.auto_start = true; }
      
      // Check for power-up and set system alarm if homing is enabled to force homing cycle
      // by setting Grbl's alarm state. Alarm locks out all g-code commands, including the
      // startup scripts, but allows access to settings and internal commands. Only a homing
      // cycle '$H' or kill alarm locks '$X' will disable the alarm.
      // NOTE: The startup script will run after successful completion of the homing cycle, but
      // not after disabling the alarm locks. Prevents motion startup blocks from crashing into
      // things uncontrollably. Very bad.
      #ifdef HOMING_INIT_LOCK
        if (sys.state == STATE_INIT && bit_istrue(settings.flags,BITFLAG_HOMING_ENABLE)) { sys.state = STATE_ALARM; }
      #endif
      
      // Check for and report alarm state after a reset, error, or an initial power up.
      if (sys.state == STATE_ALARM) {
        report_feedback_message(MESSAGE_ALARM_LOCK); 
      } else {
        // All systems go. Set system to ready and execute startup script.
        sys.state = STATE_IDLE;
        protocol_execute_startup(); 
      }
    }
    
    protocol_execute_runtime();
    protocol_process(); // ... process the serial protocol
    
    // When the serial protocol returns, there are no more characters in the serial read buffer to
    // be processed and executed. This indicates that individual commands are being issued or 
    // streaming is finished. In either case, auto-cycle start, if enabled, any queued moves.
    if (sys.auto_start) { st_cycle_start(); }
    
  }
  // return 0;   /* never reached */
}