int ISR(SERIAL_RX) { uint8_t data = UDR0; uint8_t next_head; // Pick off runtime command characters directly from the serial stream. These characters are // not passed into the buffer, but these set system state flag bits for runtime execution. switch (data) { case CMD_STATUS_REPORT: bit_true_atomic(sys.execute, EXEC_STATUS_REPORT); break; // Set as true case CMD_CYCLE_START: bit_true_atomic(sys.execute, EXEC_CYCLE_START); break; // Set as true case CMD_FEED_HOLD: bit_true_atomic(sys.execute, EXEC_FEED_HOLD); break; // Set as true case CMD_RESET: mc_reset(); break; // Call motion control reset routine. default: // Write character to buffer next_head = serial_rx_buffer_head + 1; if (next_head == RX_BUFFER_SIZE) { next_head = 0; } // Write data to buffer unless it is full. if (next_head != serial_rx_buffer_tail) { serial_rx_buffer[serial_rx_buffer_head] = data; serial_rx_buffer_head = next_head; #ifdef ENABLE_XONXOFF if ((serial_get_rx_buffer_count() >= RX_BUFFER_FULL) && flow_ctrl == XON_SENT) { flow_ctrl = SEND_XOFF; UCSR0B |= (1 << UDRIE0); // Force TX } #endif } //TODO: else alarm on overflow? } }
void serial_rxint(void) { uint8_t data = usart_recv(USART2);; uint32_t next_head; // Pick off realtime command characters directly from the serial stream. These characters are // not passed into the buffer, but these set system state flag bits for realtime execution. switch (data) { case CMD_STATUS_REPORT: bit_true_atomic(sys.rt_exec_state, EXEC_STATUS_REPORT); break; // Set as true case CMD_CYCLE_START: bit_true_atomic(sys.rt_exec_state, EXEC_CYCLE_START); break; // Set as true case CMD_FEED_HOLD: bit_true_atomic(sys.rt_exec_state, EXEC_FEED_HOLD); break; // Set as true case CMD_SAFETY_DOOR: bit_true_atomic(sys.rt_exec_state, EXEC_SAFETY_DOOR); break; // Set as true case CMD_RESET: mc_reset(); break; // Call motion control reset routine. default: // Write character to buffer next_head = serial_rx_buffer_head + 1; if (next_head == RX_BUFFER_SIZE) { next_head = 0; } // Write data to buffer unless it is full. if (next_head != serial_rx_buffer_tail) { serial_rx_buffer[serial_rx_buffer_head] = data; serial_rx_buffer_head = next_head; #ifdef ENABLE_XONXOFF if ((serial_get_rx_buffer_count() >= RX_BUFFER_FULL) && flow_ctrl == XON_SENT) { flow_ctrl = SEND_XOFF; usart_enable_tx_interrupt(USART2); } #endif } //TODO: else alarm on overflow? } }
// Fetches the first byte in the serial read buffer. Called by main program. uint8_t serial_read() { uint8_t tail = serial_rx_buffer_tail; // Temporary serial_rx_buffer_tail (to optimize for volatile) if (serial_rx_buffer_head == tail) { return SERIAL_NO_DATA; } else { uint8_t data = serial_rx_buffer[tail]; tail++; if (tail == RX_BUFFER_SIZE) { tail = 0; } serial_rx_buffer_tail = tail; #ifdef ENABLE_XONXOFF if ((serial_get_rx_buffer_count() < RX_BUFFER_LOW) && flow_ctrl == XOFF_SENT) { flow_ctrl = SEND_XON; UCSR0B |= (1 << UDRIE0); // Force TX } #endif return data; } }
// Prints real-time data. This function grabs a real-time snapshot of the stepper subprogram // and the actual location of the CNC machine. Users may change the following function to their // specific needs, but the desired real-time data report must be as short as possible. This is // requires as it minimizes the computational overhead and allows grbl to keep running smoothly, // especially during g-code programs with fast, short line segments and high frequency reports (5-20Hz). void report_realtime_status() { // **Under construction** Bare-bones status report. Provides real-time machine position relative to // the system power on location (0,0,0) and work coordinate position (G54 and G92 applied). Eventually // to be added are distance to go on block, processed block id, and feed rate. Also a settings bitmask // for a user to select the desired real-time data. uint8_t idx; int32_t current_position[N_AXIS]; // Copy current state of the system position variable memcpy(current_position,sys.position,sizeof(sys.position)); float print_position[N_AXIS]; // Report current machine state switch (sys.state) { case STATE_IDLE: printPgmString(PSTR("<Idle")); break; case STATE_MOTION_CANCEL: // Report run state. case STATE_CYCLE: printPgmString(PSTR("<Run")); break; case STATE_HOLD: printPgmString(PSTR("<Hold")); break; case STATE_HOMING: printPgmString(PSTR("<Home")); break; case STATE_ALARM: printPgmString(PSTR("<Alarm")); break; case STATE_CHECK_MODE: printPgmString(PSTR("<Check")); break; case STATE_SAFETY_DOOR: printPgmString(PSTR("<Door")); break; } // If reporting a position, convert the current step count (current_position) to millimeters. if (bit_istrue(settings.status_report_mask,(BITFLAG_RT_STATUS_MACHINE_POSITION | BITFLAG_RT_STATUS_WORK_POSITION))) { system_convert_array_steps_to_mpos(print_position,current_position); } // Report machine position if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_MACHINE_POSITION)) { printPgmString(PSTR(",MPos:")); for (idx=0; idx< N_AXIS; idx++) { printFloat_CoordValue(print_position[idx]); if (idx < (N_AXIS-1)) { printPgmString(PSTR(",")); } } } // Report work position if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_WORK_POSITION)) { printPgmString(PSTR(",WPos:")); for (idx=0; idx< N_AXIS; idx++) { // Apply work coordinate offsets and tool length offset to current position. print_position[idx] -= gc_state.coord_system[idx]+gc_state.coord_offset[idx]; if (idx == TOOL_LENGTH_OFFSET_AXIS) { print_position[idx] -= gc_state.tool_length_offset; } printFloat_CoordValue(print_position[idx]); if (idx < (N_AXIS-1)) { printPgmString(PSTR(",")); } } } // Returns the number of active blocks are in the planner buffer. if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_PLANNER_BUFFER)) { printPgmString(PSTR(",Buf:")); print_uint8_base10(plan_get_block_buffer_count()); } // Report serial read buffer status if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_SERIAL_RX)) { printPgmString(PSTR(",RX:")); print_uint8_base10(serial_get_rx_buffer_count()); } #ifdef USE_LINE_NUMBERS // Report current line number printPgmString(PSTR(",Ln:")); int32_t ln=0; plan_block_t * pb = plan_get_current_block(); if(pb != NULL) { ln = pb->line_number; } printInteger(ln); #endif #ifdef REPORT_REALTIME_RATE // Report realtime rate printPgmString(PSTR(",F:")); printFloat_RateValue(st_get_realtime_rate()); #endif if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_LIMIT_PINS)) { printPgmString(PSTR(",Lim:")); print_unsigned_int8(limits_get_state(),2,N_AXIS); } #ifdef REPORT_CONTROL_PIN_STATE printPgmString(PSTR(",Ctl:")); print_uint8_base2(CONTROL_PIN & CONTROL_MASK); #endif printPgmString(PSTR(">\r\n")); }
// Prints real-time data. This function grabs a real-time snapshot of the stepper subprogram // and the actual location of the CNC machine. Users may change the following function to their // specific needs, but the desired real-time data report must be as short as possible. This is // requires as it minimizes the computational overhead and allows grbl to keep running smoothly, // especially during g-code programs with fast, short line segments and high frequency reports (5-20Hz). void report_realtime_status() { // **Under construction** Bare-bones status report. Provides real-time machine position relative to // the system power on location (0,0,0) and work coordinate position (G54 and G92 applied). Eventually // to be added are distance to go on block, processed block id, and feed rate. Also a settings bitmask // for a user to select the desired real-time data. uint8_t i; int32_t current_position[N_AXIS]; // Copy current state of the system position variable memcpy(current_position,sys.position,sizeof(sys.position)); float print_position[N_AXIS]; // Report current machine state switch (sys.state) { case STATE_IDLE: printPgmString(PSTR("<Idle")); break; case STATE_QUEUED: printPgmString(PSTR("<Queue")); break; case STATE_CYCLE: printPgmString(PSTR("<Run")); break; case STATE_HOLD: printPgmString(PSTR("<Hold")); break; case STATE_HOMING: printPgmString(PSTR("<Home")); break; case STATE_ALARM: printPgmString(PSTR("<Alarm")); break; case STATE_CHECK_MODE: printPgmString(PSTR("<Check")); break; } // Report machine position if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_MACHINE_POSITION)) { printPgmString(PSTR(",MPos:")); // print_position[X_AXIS] = 0.5*current_position[X_AXIS]/settings.steps_per_mm[X_AXIS]; // print_position[Z_AXIS] = 0.5*current_position[Y_AXIS]/settings.steps_per_mm[Y_AXIS]; // print_position[Y_AXIS] = print_position[X_AXIS]-print_position[Z_AXIS]); // print_position[X_AXIS] -= print_position[Z_AXIS]; // print_position[Z_AXIS] = current_position[Z_AXIS]/settings.steps_per_mm[Z_AXIS]; for (i=0; i< N_AXIS; i++) { print_position[i] = current_position[i]/settings.steps_per_mm[i]; printFloat_CoordValue(print_position[i]); if (i < (N_AXIS-1)) { printPgmString(PSTR(",")); } } } // Report work position if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_WORK_POSITION)) { printPgmString(PSTR(",WPos:")); for (i=0; i< N_AXIS; i++) { print_position[i] -= gc_state.coord_system[i]+gc_state.coord_offset[i]; if (i == TOOL_LENGTH_OFFSET_AXIS) { print_position[i] -= gc_state.tool_length_offset; } printFloat_CoordValue(print_position[i]); if (i < (N_AXIS-1)) { printPgmString(PSTR(",")); } } } // Returns the number of active blocks are in the planner buffer. if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_PLANNER_BUFFER)) { printPgmString(PSTR(",Buf:")); print_uint8_base10(plan_get_block_buffer_count()); } // Report serial read buffer status if (bit_istrue(settings.status_report_mask,BITFLAG_RT_STATUS_SERIAL_RX)) { printPgmString(PSTR(",RX:")); print_uint8_base10(serial_get_rx_buffer_count()); } #ifdef USE_LINE_NUMBERS // Report current line number printPgmString(PSTR(",Ln:")); int32_t ln=0; plan_block_t * pb = plan_get_current_block(); if(pb != NULL) { ln = pb->line_number; } printInteger(ln); #endif #ifdef REPORT_REALTIME_RATE // Report realtime rate printPgmString(PSTR(",F:")); printFloat_RateValue(st_get_realtime_rate()); #endif printPgmString(PSTR(">\r\n")); }