I'm trying to port GRBL 1.1 to the STM32F746 chip. Tell me the solution, thanks.
Diff: grbl/system.c
- Revision:
- 0:9dcf85d9b2f3
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/grbl/system.c Mon Sep 04 12:05:05 2017 +0000 @@ -0,0 +1,578 @@ +/* + system.c - Handles system level commands and real-time processes + Part of Grbl + + Copyright (c) 2014-2016 Sungeun K. Jeon for Gnea Research LLC + + Grbl is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + Grbl is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with Grbl. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include "grbl.h" + + +void system_init() +{ +#ifdef AVRTARGET + CONTROL_DDR &= ~(CONTROL_MASK); // Configure as input pins + #ifdef DISABLE_CONTROL_PIN_PULL_UP + CONTROL_PORT &= ~(CONTROL_MASK); // Normal low operation. Requires external pull-down. + #else + CONTROL_PORT |= CONTROL_MASK; // Enable internal pull-up resistors. Normal high operation. + #endif + CONTROL_PCMSK |= CONTROL_MASK; // Enable specific pins of the Pin Change Interrupt + PCICR |= (1 << CONTROL_INT); // Enable Pin Change Interrupt +#endif +#ifdef STM32F103C8 + GPIO_InitTypeDef GPIO_InitStructure; + RCC_APB2PeriphClockCmd(RCC_CONTROL_PORT | RCC_APB2Periph_AFIO, ENABLE); + GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; +#ifdef DISABLE_CONTROL_PIN_PULL_UP + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; +#else + GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; +#endif + GPIO_InitStructure.GPIO_Pin = CONTROL_MASK; + GPIO_Init(CONTROL_PORT, &GPIO_InitStructure); + + GPIO_EXTILineConfig(GPIO_CONTROL_PORT, CONTROL_RESET_BIT); + GPIO_EXTILineConfig(GPIO_CONTROL_PORT, CONTROL_FEED_HOLD_BIT); + GPIO_EXTILineConfig(GPIO_CONTROL_PORT, CONTROL_CYCLE_START_BIT); + GPIO_EXTILineConfig(GPIO_CONTROL_PORT, CONTROL_SAFETY_DOOR_BIT); + + EXTI_InitTypeDef EXTI_InitStructure; + EXTI_InitStructure.EXTI_Line = CONTROL_MASK; // + EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; //Interrupt mode, optional values for the interrupt EXTI_Mode_Interrupt and event EXTI_Mode_Event. + EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //Trigger mode, can be a falling edge trigger EXTI_Trigger_Falling, the rising edge triggered EXTI_Trigger_Rising, or any level (rising edge and falling edge trigger EXTI_Trigger_Rising_Falling) + EXTI_InitStructure.EXTI_LineCmd = ENABLE; + EXTI_Init(&EXTI_InitStructure); + + NVIC_InitTypeDef NVIC_InitStructure; + NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn; //Enable keypad external interrupt channel + NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x02; //Priority 2, + NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x02; //Sub priority 2 + NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //Enable external interrupt channel + NVIC_Init(&NVIC_InitStructure); +#endif +} + + +// Returns control pin state as a uint8 bitfield. Each bit indicates the input pin state, where +// triggered is 1 and not triggered is 0. Invert mask is applied. Bitfield organization is +// defined by the CONTROL_PIN_INDEX in the header file. +uint8_t system_control_get_state() +{ + uint8_t control_state = 0; +#ifdef AVRTARGET + uint8_t pin = (CONTROL_PIN & CONTROL_MASK); +#endif +#ifdef WIN32 + uint8_t pin = 0; +#endif +#ifdef STM32F103C8 + uint16_t pin= GPIO_ReadInputData(CONTROL_PIN_PORT); +#endif + #ifdef INVERT_CONTROL_PIN_MASK + pin ^= INVERT_CONTROL_PIN_MASK; + #endif + if (pin) { + #ifdef ENABLE_SAFETY_DOOR_INPUT_PIN + if (bit_isfalse(pin,(1<<CONTROL_SAFETY_DOOR_BIT))) { control_state |= CONTROL_PIN_INDEX_SAFETY_DOOR; } + #endif + if (bit_isfalse(pin,(1<<CONTROL_RESET_BIT))) { control_state |= CONTROL_PIN_INDEX_RESET; } + if (bit_isfalse(pin,(1<<CONTROL_FEED_HOLD_BIT))) { control_state |= CONTROL_PIN_INDEX_FEED_HOLD; } + if (bit_isfalse(pin,(1<<CONTROL_CYCLE_START_BIT))) { control_state |= CONTROL_PIN_INDEX_CYCLE_START; } + } + return(control_state); +} + + +// Pin change interrupt for pin-out commands, i.e. cycle start, feed hold, and reset. Sets +// only the realtime command execute variable to have the main program execute these when +// its ready. This works exactly like the character-based realtime commands when picked off +// directly from the incoming serial data stream. +#ifdef AVRTARGET +ISR(CONTROL_INT_vect) +{ + uint8_t pin = system_control_get_state(); + if (pin) { + if (bit_istrue(pin,CONTROL_PIN_INDEX_RESET)) { + mc_reset(); + } else if (bit_istrue(pin,CONTROL_PIN_INDEX_CYCLE_START)) { + bit_true(sys_rt_exec_state, EXEC_CYCLE_START); + #ifndef ENABLE_SAFETY_DOOR_INPUT_PIN + } else if (bit_istrue(pin,CONTROL_PIN_INDEX_FEED_HOLD)) { + bit_true(sys_rt_exec_state, EXEC_FEED_HOLD); + #else + } else if (bit_istrue(pin,CONTROL_PIN_INDEX_SAFETY_DOOR)) { + bit_true(sys_rt_exec_state, EXEC_SAFETY_DOOR); + #endif + } + } +} +#endif +#if defined (STM32F103C8) +void EXTI9_5_IRQHandler(void) +{ + EXTI_ClearITPendingBit((1 << CONTROL_RESET_BIT) | (1 << CONTROL_FEED_HOLD_BIT) | (1 << CONTROL_CYCLE_START_BIT) | (1 << CONTROL_SAFETY_DOOR_BIT)); + uint8_t pin = system_control_get_state(); + if (pin) + { + if (bit_istrue(pin,CONTROL_PIN_INDEX_RESET)) + { + mc_reset(); + } + else if (bit_istrue(pin, CONTROL_PIN_INDEX_CYCLE_START)) + { + bit_true(sys_rt_exec_state, EXEC_CYCLE_START); + } +#ifndef ENABLE_SAFETY_DOOR_INPUT_PIN + else if (bit_istrue(pin, CONTROL_PIN_INDEX_FEED_HOLD)) + { + bit_true(sys_rt_exec_state, EXEC_FEED_HOLD); + } +#else + else if (bit_istrue(pin, CONTROL_PIN_INDEX_SAFETY_DOOR)) + { + bit_true(sys_rt_exec_state, EXEC_SAFETY_DOOR); + } +#endif + NVIC_ClearPendingIRQ(EXTI9_5_IRQn); +} +} +#endif + +// Returns if safety door is ajar(T) or closed(F), based on pin state. +uint8_t system_check_safety_door_ajar() +{ + #ifdef ENABLE_SAFETY_DOOR_INPUT_PIN + return(system_control_get_state() & CONTROL_PIN_INDEX_SAFETY_DOOR); + #else + return(false); // Input pin not enabled, so just return that it's closed. + #endif +} + + +// Executes user startup script, if stored. +void system_execute_startup(char *line) +{ + uint8_t n; + for (n=0; n < N_STARTUP_LINE; n++) { + if (!(settings_read_startup_line(n, line))) { + line[0] = 0; + report_execute_startup_message(line,STATUS_SETTING_READ_FAIL); + } else { + if (line[0] != 0) { + uint8_t status_code = gc_execute_line(line); + report_execute_startup_message(line,status_code); + } + } + } +} + + +// Directs and executes one line of formatted input from protocol_process. While mostly +// incoming streaming g-code blocks, this also executes Grbl internal commands, such as +// settings, initiating the homing cycle, and toggling switch states. This differs from +// the realtime command module by being susceptible to when Grbl is ready to execute the +// next line during a cycle, so for switches like block delete, the switch only effects +// the lines that are processed afterward, not necessarily real-time during a cycle, +// since there are motions already stored in the buffer. However, this 'lag' should not +// be an issue, since these commands are not typically used during a cycle. +uint8_t system_execute_line(char *line) +{ + uint8_t char_counter = 1; + uint8_t helper_var = 0; // Helper variable + float parameter, value; + switch( line[char_counter] ) { + case 0 : report_grbl_help(); break; + case 'J' : // Jogging + // Execute only if in IDLE or JOG states. + if (sys.state != STATE_IDLE && sys.state != STATE_JOG) { return(STATUS_IDLE_ERROR); } + if(line[2] != '=') { return(STATUS_INVALID_STATEMENT); } + return(gc_execute_line(line)); // NOTE: $J= is ignored inside g-code parser and used to detect jog motions. + break; + case '$': case 'G': case 'C': case 'X': + if ( line[2] != 0 ) { return(STATUS_INVALID_STATEMENT); } + switch( line[1] ) { + case '$' : // Prints Grbl settings + if ( sys.state & (STATE_CYCLE | STATE_HOLD) ) { return(STATUS_IDLE_ERROR); } // Block during cycle. Takes too long to print. + else { report_grbl_settings(); } + break; + case 'G' : // Prints gcode parser state + // TODO: Move this to realtime commands for GUIs to request this data during suspend-state. + report_gcode_modes(); + break; + case 'C' : // Set check g-code mode [IDLE/CHECK] + // Perform reset when toggling off. Check g-code mode should only work if Grbl + // is idle and ready, regardless of alarm locks. This is mainly to keep things + // simple and consistent. + if ( sys.state == STATE_CHECK_MODE ) { + mc_reset(); + report_feedback_message(MESSAGE_DISABLED); + } else { + if (sys.state) { return(STATUS_IDLE_ERROR); } // Requires no alarm mode. + sys.state = STATE_CHECK_MODE; + report_feedback_message(MESSAGE_ENABLED); + } + break; + case 'X' : // Disable alarm lock [ALARM] + if (sys.state == STATE_ALARM) { + // Block if safety door is ajar. + if (system_check_safety_door_ajar()) { return(STATUS_CHECK_DOOR); } + report_feedback_message(MESSAGE_ALARM_UNLOCK); + sys.state = STATE_IDLE; + // Don't run startup script. Prevents stored moves in startup from causing accidents. + } // Otherwise, no effect. + break; + } + break; + default : + // Block any system command that requires the state as IDLE/ALARM. (i.e. EEPROM, homing) + if ( !(sys.state == STATE_IDLE || sys.state == STATE_ALARM) ) { return(STATUS_IDLE_ERROR); } + switch( line[1] ) { + case '#' : // Print Grbl NGC parameters + if ( line[2] != 0 ) { return(STATUS_INVALID_STATEMENT); } + else { report_ngc_parameters(); } + break; + case 'H' : // Perform homing cycle [IDLE/ALARM] + if (bit_isfalse(settings.flags,BITFLAG_HOMING_ENABLE)) {return(STATUS_SETTING_DISABLED); } + if (system_check_safety_door_ajar()) { return(STATUS_CHECK_DOOR); } // Block if safety door is ajar. + sys.state = STATE_HOMING; // Set system state variable + if (line[2] == 0) { + mc_homing_cycle(HOMING_CYCLE_ALL); + #ifdef HOMING_SINGLE_AXIS_COMMANDS + } else if (line[3] == 0) { + switch (line[2]) { + case 'X': mc_homing_cycle(HOMING_CYCLE_X); break; + case 'Y': mc_homing_cycle(HOMING_CYCLE_Y); break; + case 'Z': mc_homing_cycle(HOMING_CYCLE_Z); break; + default: return(STATUS_INVALID_STATEMENT); + } + #endif + } else { return(STATUS_INVALID_STATEMENT); } + if (!sys.abort) { // Execute startup scripts after successful homing. + sys.state = STATE_IDLE; // Set to IDLE when complete. + st_go_idle(); // Set steppers to the settings idle state before returning. + if (line[2] == 0) { system_execute_startup(line); } + } + break; + case 'S' : // Puts Grbl to sleep [IDLE/ALARM] + if ((line[2] != 'L') || (line[3] != 'P') || (line[4] != 0)) { return(STATUS_INVALID_STATEMENT); } + system_set_exec_state_flag(EXEC_SLEEP); // Set to execute sleep mode immediately + break; + case 'I' : // Print or store build info. [IDLE/ALARM] + if ( line[++char_counter] == 0 ) { + settings_read_build_info(line); + report_build_info(line); + #ifdef ENABLE_BUILD_INFO_WRITE_COMMAND + } else { // Store startup line [IDLE/ALARM] + if(line[char_counter++] != '=') { return(STATUS_INVALID_STATEMENT); } + helper_var = char_counter; // Set helper variable as counter to start of user info line. + do { + line[char_counter-helper_var] = line[char_counter]; + } while (line[char_counter++] != 0); + settings_store_build_info(line); + #endif + } + break; + case 'R' : // Restore defaults [IDLE/ALARM] + if ((line[2] != 'S') || (line[3] != 'T') || (line[4] != '=') || (line[6] != 0)) { return(STATUS_INVALID_STATEMENT); } + switch (line[5]) { + #ifdef ENABLE_RESTORE_EEPROM_DEFAULT_SETTINGS + case '$': settings_restore(SETTINGS_RESTORE_DEFAULTS); break; + #endif + #ifdef ENABLE_RESTORE_EEPROM_CLEAR_PARAMETERS + case '#': settings_restore(SETTINGS_RESTORE_PARAMETERS); break; + #endif + #ifdef ENABLE_RESTORE_EEPROM_WIPE_ALL + case '*': settings_restore(SETTINGS_RESTORE_ALL); break; + #endif + default: return(STATUS_INVALID_STATEMENT); + } + report_feedback_message(MESSAGE_RESTORE_DEFAULTS); + mc_reset(); // Force reset to ensure settings are initialized correctly. + break; + case 'N' : // Startup lines. [IDLE/ALARM] + if ( line[++char_counter] == 0 ) { // Print startup lines + for (helper_var=0; helper_var < N_STARTUP_LINE; helper_var++) { + if (!(settings_read_startup_line(helper_var, line))) { + report_status_message(STATUS_SETTING_READ_FAIL); + } else { + report_startup_line(helper_var,line); + } + } + break; + } else { // Store startup line [IDLE Only] Prevents motion during ALARM. + if (sys.state != STATE_IDLE) { return(STATUS_IDLE_ERROR); } // Store only when idle. + helper_var = true; // Set helper_var to flag storing method. + // No break. Continues into default: to read remaining command characters. + } + default : // Storing setting methods [IDLE/ALARM] + if(!read_float(line, &char_counter, ¶meter)) { return(STATUS_BAD_NUMBER_FORMAT); } + if(line[char_counter++] != '=') { return(STATUS_INVALID_STATEMENT); } + if (helper_var) { // Store startup line + // Prepare sending gcode block to gcode parser by shifting all characters + helper_var = char_counter; // Set helper variable as counter to start of gcode block + do { + line[char_counter-helper_var] = line[char_counter]; + } while (line[char_counter++] != 0); + // Execute gcode block to ensure block is valid. + helper_var = gc_execute_line(line); // Set helper_var to returned status code. + if (helper_var) { return(helper_var); } + else { + helper_var = truncf(parameter); // Set helper_var to int value of parameter + settings_store_startup_line(helper_var,line); + } + } else { // Store global setting. + if(!read_float(line, &char_counter, &value)) { return(STATUS_BAD_NUMBER_FORMAT); } + if((line[char_counter] != 0) || (parameter > 255)) { return(STATUS_INVALID_STATEMENT); } + return(settings_store_global_setting((uint8_t)parameter, value)); + } + } + } + return(STATUS_OK); // If '$' command makes it to here, then everything's ok. +} + + + +void system_flag_wco_change() +{ + #ifdef FORCE_BUFFER_SYNC_DURING_WCO_CHANGE + protocol_buffer_synchronize(); + #endif + sys.report_wco_counter = 0; +} + + +// Returns machine position of axis 'idx'. Must be sent a 'step' array. +// NOTE: If motor steps and machine position are not in the same coordinate frame, this function +// serves as a central place to compute the transformation. +float system_convert_axis_steps_to_mpos(int32_t *steps, uint8_t idx) +{ + float pos; + #ifdef COREXY + if (idx==X_AXIS) { + pos = (float)system_convert_corexy_to_x_axis_steps(steps) / settings.steps_per_mm[idx]; + } else if (idx==Y_AXIS) { + pos = (float)system_convert_corexy_to_y_axis_steps(steps) / settings.steps_per_mm[idx]; + } else { + pos = steps[idx]/settings.steps_per_mm[idx]; + } + #else + pos = steps[idx]/settings.steps_per_mm[idx]; + #endif + return(pos); +} + + +void system_convert_array_steps_to_mpos(float *position, int32_t *steps) +{ + uint8_t idx; + for (idx=0; idx<N_AXIS; idx++) { + position[idx] = system_convert_axis_steps_to_mpos(steps, idx); + } + return; +} + + +// CoreXY calculation only. Returns x or y-axis "steps" based on CoreXY motor steps. +#ifdef COREXY + int32_t system_convert_corexy_to_x_axis_steps(int32_t *steps) + { + return( (steps[A_MOTOR] + steps[B_MOTOR])/2 ); + } + int32_t system_convert_corexy_to_y_axis_steps(int32_t *steps) + { + return( (steps[A_MOTOR] - steps[B_MOTOR])/2 ); + } +#endif + + +// Checks and reports if target array exceeds machine travel limits. +uint8_t system_check_travel_limits(float *target) +{ + uint8_t idx; + for (idx=0; idx<N_AXIS; idx++) { + #ifdef HOMING_FORCE_SET_ORIGIN + // When homing forced set origin is enabled, soft limits checks need to account for directionality. + // NOTE: max_travel is stored as negative + if (bit_istrue(settings.homing_dir_mask,bit(idx))) { + if (target[idx] < 0 || target[idx] > -settings.max_travel[idx]) { return(true); } + } else { + if (target[idx] > 0 || target[idx] < settings.max_travel[idx]) { return(true); } + } + #else + // NOTE: max_travel is stored as negative + if (target[idx] > 0 || target[idx] < settings.max_travel[idx]) { return(true); } + #endif + } + return(false); +} + +#ifdef WIN32 +extern CRITICAL_SECTION CriticalSection; +#endif + +// Special handlers for setting and clearing Grbl's real-time execution flags. +void system_set_exec_state_flag(uint8_t mask) { +#ifdef AVRTARGET + uint8_t sreg = SREG; + cli(); + sys_rt_exec_state |= (mask); + SREG = sreg; +#endif +#ifdef WIN32 + EnterCriticalSection(&CriticalSection); + sys_rt_exec_state |= (mask); + LeaveCriticalSection(&CriticalSection); +#endif +#ifdef STM32F103C8 + __disable_irq(); + sys_rt_exec_state |= (mask); + __enable_irq(); +#endif +} + +void system_clear_exec_state_flag(uint8_t mask) { +#ifdef AVRTARGET + uint8_t sreg = SREG; + cli(); + sys_rt_exec_state &= ~(mask); + SREG = sreg; +#endif +#ifdef WIN32 + EnterCriticalSection(&CriticalSection); + sys_rt_exec_state &= ~(mask); + LeaveCriticalSection(&CriticalSection); +#endif +#ifdef STM32F103C8 + __disable_irq(); + sys_rt_exec_state &= ~(mask); + __enable_irq(); +#endif +} + +void system_set_exec_alarm(uint8_t code) { +#ifdef AVRTARGET + uint8_t sreg = SREG; + cli(); + sys_rt_exec_alarm = code; + SREG = sreg; +#endif +#ifdef WIN32 + EnterCriticalSection(&CriticalSection); + sys_rt_exec_alarm |= (code); + LeaveCriticalSection(&CriticalSection); +#endif +#ifdef STM32F103C8 + __disable_irq(); + sys_rt_exec_alarm |= (code); + __enable_irq(); +#endif +} + +void system_clear_exec_alarm() { +#ifdef AVRTARGET + uint8_t sreg = SREG; + cli(); + sys_rt_exec_alarm = 0; + SREG = sreg; +#endif +#ifdef WIN32 + EnterCriticalSection(&CriticalSection); + sys_rt_exec_alarm = 0; + LeaveCriticalSection(&CriticalSection); +#endif +#ifdef STM32F103C8 + __disable_irq(); + sys_rt_exec_alarm = 0; + __enable_irq(); +#endif +} + +void system_set_exec_motion_override_flag(uint8_t mask) { +#ifdef AVRTARGET + uint8_t sreg = SREG; + cli(); + sys_rt_exec_motion_override |= (mask); + SREG = sreg; +#endif +#ifdef WIN32 + EnterCriticalSection(&CriticalSection); + sys_rt_exec_motion_override |= (mask); + LeaveCriticalSection(&CriticalSection); +#endif +#ifdef STM32F103C8 + __disable_irq(); + sys_rt_exec_motion_override |= (mask); + __enable_irq(); +#endif +} + +void system_set_exec_accessory_override_flag(uint8_t mask) { +#ifdef AVRTARGET + uint8_t sreg = SREG; + cli(); + sys_rt_exec_accessory_override |= (mask); + SREG = sreg; +#endif +#ifdef WIN32 + EnterCriticalSection(&CriticalSection); + sys_rt_exec_accessory_override |= (mask); + LeaveCriticalSection(&CriticalSection); +#endif +#ifdef STM32F103C8 + __disable_irq(); + sys_rt_exec_accessory_override |= (mask); + __enable_irq(); +#endif +} + +void system_clear_exec_motion_overrides() { +#ifdef AVRTARGET + uint8_t sreg = SREG; + cli(); + sys_rt_exec_motion_override = 0; + SREG = sreg; +#endif +#ifdef WIN32 + EnterCriticalSection(&CriticalSection); + sys_rt_exec_motion_override = 0; + LeaveCriticalSection(&CriticalSection); +#endif +#ifdef STM32F103C8 + __disable_irq(); + sys_rt_exec_motion_override = 0; + __enable_irq(); +#endif +} + +void system_clear_exec_accessory_overrides() { +#ifdef AVRTARGET + uint8_t sreg = SREG; + cli(); + sys_rt_exec_accessory_override = 0; + SREG = sreg; +#endif +#ifdef WIN32 + EnterCriticalSection(&CriticalSection); + sys_rt_exec_accessory_override = 0; + LeaveCriticalSection(&CriticalSection); +#endif +#ifdef STM32F103C8 + __disable_irq(); + sys_rt_exec_accessory_override = 0; + __enable_irq(); +#endif +}