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
}
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
}
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 */
}
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 */
}
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 */
}
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"));
}
}
}
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 */
}