stat_t feedRateOverride_Macro(void)
{
switch (state)
{
case 0: cm_request_feedhold();
state++; break;
case 1: cm_request_cycle_start();
state++; break;
default:state = 0; macro_func_ptr = _command_dispatch; return (STAT_OK);
}
_execute_gcode_block();
return (STAT_OK);
}
stat_t M5_Macro(void)
{
if(configFlags[MODOMAQUINA] == MODO_PLASMA)
{
/* A macro não pode acorrer até que o buffer seja esvaziado, para que ações durante o corte tenham efeito imediato*/
if (cm_get_runtime_busy() == true ) { return (STAT_EAGAIN);} // sync to planner move ends
altura_perfuracao = configVarPl[PL_CONFIG_ALTURA_PERFURACAO];
altura_deslocamento = configVarMaq[CFG_MAQUINA_ALT_DESLOCAMENTO];
altura_corte = configVarPl[PL_CONFIG_ALTURA_CORTE];
vel_corte = configVarPl[PL_CONFIG_VELOC_CORTE];
tempo_perfuracao = configVarPl[PL_CONFIG_TEMPO_PERFURACAO];
tempo_aquecimento = 0;
}
else
{
/* A macro não pode acorrer até que o buffer seja esvaziado, para que ações durante o corte tenham efeito imediato*/
if (cm_get_runtime_busy() == true || lstop == true) { return (STAT_EAGAIN);} // sync to planner move ends
altura_perfuracao = configVarOx[OX_CONFIG_ALTURA_PERFURACAO];
altura_deslocamento = configVarMaq[CFG_MAQUINA_ALT_DESLOCAMENTO];
altura_corte = configVarOx[OX_CONFIG_ALTURA_CORTE];
vel_corte = configVarOx[OX_CONFIG_VELOC_CORTE];
tempo_perfuracao = configVarOx[OX_CONFIG_TEMPO_PERFURACAO];
tempo_aquecimento = configVarOx[OX_CONFIG_TEMPO_AQUECIMENTO];
}
// set initial state for new move
memset(&gp, 0, sizeof(gp)); // clear all parser values
memset(&cm.gf, 0, sizeof(GCodeInput_t)); // clear all next-state flags
memset(&cm.gn, 0, sizeof(GCodeInput_t)); // clear all next-state values
cm.gn.motion_mode = cm_get_motion_mode(MODEL); // get motion mode from previous block
switch (state)
{
case 0: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_MODAL_MACRO (MODAL_GROUP_M7, spindle_mode, SPINDLE_OFF);
state++; break;
case 1: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_TRAVERSE);
SET_NON_MODAL_MACRO(target[AXIS_Z], altura_deslocamento);
state++; break;
default:state = 0; macro_func_ptr = _command_dispatch; return (STAT_OK);
}
_execute_gcode_block();
return (STAT_OK);
}
stat_t jog_Macro(void)
{
bool diagonalX = false;
bool diagonalY = false;
// set initial state for new move
memset(&gp, 0, sizeof(gp)); // clear all parser values
memset(&cm.gf, 0, sizeof(GCodeInput_t)); // clear all next-state flags
memset(&cm.gn, 0, sizeof(GCodeInput_t)); // clear all next-state values
cm.gn.motion_mode = cm_get_motion_mode(MODEL); // get motion mode from previous block
switch (state)
{
case 0: SET_MODAL_MACRO (MODAL_GROUP_G3, distance_mode, INCREMENTAL_MODE);
state++; break;
case 1: SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_FEED);
if ((JogkeyPressed & KEY_RIGHT ) == KEY_RIGHT || (JogkeyPressed & KEY_LEFT ) == KEY_LEFT)
{
SET_NON_MODAL_MACRO(target[AXIS_X], jogMaxDistance[AXIS_X]);
diagonalX = true;
}
if ((JogkeyPressed & KEY_UP ) == KEY_UP || (JogkeyPressed & KEY_DOWN ) == KEY_DOWN)
{
SET_NON_MODAL_MACRO(target[AXIS_Y], jogMaxDistance[AXIS_Y]);
diagonalY = true;
}
if ((JogkeyPressed & KEY_Z_DOWN ) == KEY_Z_DOWN || (JogkeyPressed & KEY_Z_UP ) == KEY_Z_UP)
{
SET_NON_MODAL_MACRO(target[AXIS_Z], jogMaxDistance[AXIS_Z]);
}
if(diagonalX && diagonalY)
{
SET_NON_MODAL_MACRO (feed_rate, *velocidadeJog*1.41);
}
else
{
SET_NON_MODAL_MACRO (feed_rate, *velocidadeJog);
}
state++; break;
default:state = 0; macro_func_ptr = command_idle; return (STAT_OK);
}
_execute_gcode_block();
return (STAT_OK);
}
stat_t ZerarPeca_Macro(void)
{
// set initial state for new move
memset(&gp, 0, sizeof(gp)); // clear all parser values
memset(&cm.gf, 0, sizeof(GCodeInput_t)); // clear all next-state flags
memset(&cm.gn, 0, sizeof(GCodeInput_t)); // clear all next-state values
cm.gn.motion_mode = cm_get_motion_mode(MODEL); // get motion mode from previous block
intepreterRunning = true;
switch (state)
{
case 0: SET_NON_MODAL_MACRO(next_action, NEXT_ACTION_SET_ABSOLUTE_ORIGIN);
SET_NON_MODAL_MACRO(target[AXIS_X], zeroPiece[AXIS_X]);
SET_NON_MODAL_MACRO(target[AXIS_Y], zeroPiece[AXIS_Y]);
SET_NON_MODAL_MACRO(target[AXIS_Z], zeroPiece[AXIS_Z]);
state++; break;
default:state = 0; intepreterRunning = false; macro_func_ptr = command_idle; return (STAT_OK);
}
_execute_gcode_block();
return (STAT_OK);
}
stat_t G10_Macro(void)
{
// set initial state for new move
memset(&gp, 0, sizeof(gp)); // clear all parser values
memset(&cm.gf, 0, sizeof(GCodeInput_t)); // clear all next-state flags
memset(&cm.gn, 0, sizeof(GCodeInput_t)); // clear all next-state values
cm.gn.motion_mode = cm_get_motion_mode(MODEL); // get motion mode from previous block
switch (state)
{
case 0: SET_MODAL_MACRO (MODAL_GROUP_G0, next_action, NEXT_ACTION_SET_COORD_DATA);
SET_NON_MODAL_MACRO (parameter, 1);
SET_NON_MODAL_MACRO (target[AXIS_X], mp_get_runtime_absolute_position(AXIS_X));
SET_NON_MODAL_MACRO (target[AXIS_Y], mp_get_runtime_absolute_position(AXIS_Y));
SET_NON_MODAL_MACRO (target[AXIS_Z], 0);
state++; break;
default:state = 0; macro_func_ptr = _command_dispatch; return (STAT_OK);
}
_execute_gcode_block();
return (STAT_OK);
}
stat_t arcoOK_Macro(void)
{
uint32_t lRet = pdFALSE;
// set initial state for new move
// memset(&gp, 0, sizeof(gp)); // clear all parser values
// memset(&cm.gf, 0, sizeof(GCodeInput_t)); // clear all next-state flags
// memset(&cm.gn, 0, sizeof(GCodeInput_t)); // clear all next-state values
// cm.gn.motion_mode = cm_get_motion_mode(MODEL); // get motion mode from previous block
if (xMacroArcoOkSync == true)
{
switch (state)
{
case 0: pl_arcook_start();
lRet = xSemaphoreTake( xArcoOkSync, pdMS_TO_TICKS(3000) );
if (lRet == pdFALSE)
{
uint32_t qSend = ARCO_OK_FAILED;
xQueueSend( qKeyboard, &qSend, 0 );
macro_func_ptr = command_idle;
xMacroArcoOkSync = false;
// isCuttingSet(true);
return (STAT_OK);
}
else
{
cm_request_cycle_start();
stopDuringCut_Set(false);
delay_thcStartStop(true);
xMacroArcoOkSync = false; state = 0; macro_func_ptr = _command_dispatch; return (STAT_OK);
}
break;
default:
break;
}
_execute_gcode_block();
}
return (STAT_OK);
}
stat_t RunningInicial_Macro(void)
{
// set initial state for new move
memset(&gp, 0, sizeof(gp)); // clear all parser values
memset(&cm.gf, 0, sizeof(GCodeInput_t)); // clear all next-state flags
memset(&cm.gn, 0, sizeof(GCodeInput_t)); // clear all next-state values
cm.gn.motion_mode = cm_get_motion_mode(MODEL); // get motion mode from previous block
switch (state)
{
case 0: SET_MODAL_MACRO (MODAL_GROUP_G6, units_mode, MILLIMETERS);
state++; break;
case 1: SET_NON_MODAL_MACRO (absolute_override, true);
state++; break;
case 2: SET_MODAL_MACRO (MODAL_GROUP_G3, distance_mode, ABSOLUTE_MODE);
state++; break;
default:state = 0; macro_func_ptr = _command_dispatch; return (STAT_OK);
}
_execute_gcode_block();
return (STAT_OK);
}
/*
* _parse_gcode_block() - parses one line of NULL terminated G-Code.
*
* All the parser does is load the state values in gn (next model state) and set flags
* in gf (model state flags). The execute routine applies them. The buffer is assumed to
* contain only uppercase characters and signed floats (no whitespace).
*
* A number of implicit things happen when the gn struct is zeroed:
* - inverse feed rate mode is cancelled - set back to units_per_minute mode
*/
static stat_t _parse_gcode_block(char_t *buf)
{
char *pstr = (char *)buf; // persistent pointer into gcode block for parsing words
char letter; // parsed letter, eg.g. G or X or Y
float value = 0; // value parsed from letter (e.g. 2 for G2)
stat_t status = STAT_OK;
// set initial state for new move
memset(&gp, 0, sizeof(gp)); // clear all parser values
memset(&gf, 0, sizeof(gf)); // clear all next-state flags
memset(&gn, 0, sizeof(gn)); // clear all next-state values
gn.motion_mode = cm_get_model_motion_mode();// get motion mode from previous block
// extract commands and parameters
while((status = _get_next_gcode_word(&pstr, &letter, &value)) == STAT_OK) {
switch(letter) {
case 'G':
switch((uint8_t)value) {
case 0: SET_MODAL (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_TRAVERSE);
case 1: SET_MODAL (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_FEED);
case 2: SET_MODAL (MODAL_GROUP_G1, motion_mode, MOTION_MODE_CW_ARC);
case 3: SET_MODAL (MODAL_GROUP_G1, motion_mode, MOTION_MODE_CCW_ARC);
case 4: SET_NON_MODAL (next_action, NEXT_ACTION_DWELL);
case 10: SET_MODAL (MODAL_GROUP_G0, next_action, NEXT_ACTION_SET_COORD_DATA);
case 17: SET_MODAL (MODAL_GROUP_G2, select_plane, CANON_PLANE_XY);
case 18: SET_MODAL (MODAL_GROUP_G2, select_plane, CANON_PLANE_XZ);
case 19: SET_MODAL (MODAL_GROUP_G2, select_plane, CANON_PLANE_YZ);
case 20: SET_MODAL (MODAL_GROUP_G6, units_mode, INCHES);
case 21: SET_MODAL (MODAL_GROUP_G6, units_mode, MILLIMETERS);
case 28: {
switch (_point(value)) {
case 0: SET_MODAL (MODAL_GROUP_G0, next_action, NEXT_ACTION_GOTO_G28_POSITION);
case 1: SET_MODAL (MODAL_GROUP_G0, next_action, NEXT_ACTION_SET_G28_POSITION);
case 2: SET_NON_MODAL (next_action, NEXT_ACTION_SEARCH_HOME);
case 3: SET_NON_MODAL (next_action, NEXT_ACTION_SET_ABSOLUTE_ORIGIN);
default: status = STAT_UNRECOGNIZED_COMMAND;
}
break;
}
case 30: {
switch (_point(value)) {
case 0: SET_MODAL (MODAL_GROUP_G0, next_action, NEXT_ACTION_GOTO_G30_POSITION);
case 1: SET_MODAL (MODAL_GROUP_G0, next_action, NEXT_ACTION_SET_G30_POSITION);
default: status = STAT_UNRECOGNIZED_COMMAND;
}
break;
}
/* case 38:
switch (_point(value)) {
case 2: SET_NON_MODAL (next_action, NEXT_ACTION_STRAIGHT_PROBE);
default: status = STAT_UNRECOGNIZED_COMMAND;
}
break;
}
*/ case 40: break; // ignore cancel cutter radius compensation
case 49: break; // ignore cancel tool length offset comp.
case 53: SET_NON_MODAL (absolute_override, true);
case 54: SET_MODAL (MODAL_GROUP_G12, coord_system, G54);
case 55: SET_MODAL (MODAL_GROUP_G12, coord_system, G55);
case 56: SET_MODAL (MODAL_GROUP_G12, coord_system, G56);
case 57: SET_MODAL (MODAL_GROUP_G12, coord_system, G57);
case 58: SET_MODAL (MODAL_GROUP_G12, coord_system, G58);
case 59: SET_MODAL (MODAL_GROUP_G12, coord_system, G59);
case 61: {
switch (_point(value)) {
case 0: SET_MODAL (MODAL_GROUP_G13, path_control, PATH_EXACT_PATH);
case 1: SET_MODAL (MODAL_GROUP_G13, path_control, PATH_EXACT_STOP);
default: status = STAT_UNRECOGNIZED_COMMAND;
}
break;
}
case 64: SET_MODAL (MODAL_GROUP_G13,path_control, PATH_CONTINUOUS);
case 80: SET_MODAL (MODAL_GROUP_G1, motion_mode, MOTION_MODE_CANCEL_MOTION_MODE);
case 90: SET_MODAL (MODAL_GROUP_G3, distance_mode, ABSOLUTE_MODE);
case 91: SET_MODAL (MODAL_GROUP_G3, distance_mode, INCREMENTAL_MODE);
case 92: {
switch (_point(value)) {
case 0: SET_MODAL (MODAL_GROUP_G0, next_action, NEXT_ACTION_SET_ORIGIN_OFFSETS);
case 1: SET_NON_MODAL (next_action, NEXT_ACTION_RESET_ORIGIN_OFFSETS);
case 2: SET_NON_MODAL (next_action, NEXT_ACTION_SUSPEND_ORIGIN_OFFSETS);
case 3: SET_NON_MODAL (next_action, NEXT_ACTION_RESUME_ORIGIN_OFFSETS);
default: status = STAT_UNRECOGNIZED_COMMAND;
}
break;
}
case 93: SET_MODAL (MODAL_GROUP_G5, inverse_feed_rate_mode, true);
case 94: SET_MODAL (MODAL_GROUP_G5, inverse_feed_rate_mode, false);
default: status = STAT_UNRECOGNIZED_COMMAND;
}
break;
case 'M':
switch((uint8_t)value) {
case 0: case 1: case 60:
SET_MODAL (MODAL_GROUP_M4, program_flow, PROGRAM_STOP);
case 2: case 30:
SET_MODAL (MODAL_GROUP_M4, program_flow, PROGRAM_END);
case 3: SET_MODAL (MODAL_GROUP_M7, spindle_mode, SPINDLE_CW);
case 4: SET_MODAL (MODAL_GROUP_M7, spindle_mode, SPINDLE_CCW);
case 5: SET_MODAL (MODAL_GROUP_M7, spindle_mode, SPINDLE_OFF);
case 6: SET_NON_MODAL (change_tool, true);
case 7: SET_MODAL (MODAL_GROUP_M8, mist_coolant, true);
case 8: SET_MODAL (MODAL_GROUP_M8, flood_coolant, true);
case 9: SET_MODAL (MODAL_GROUP_M8, flood_coolant, false);
case 48: SET_MODAL (MODAL_GROUP_M9, override_enables, true);
case 49: SET_MODAL (MODAL_GROUP_M9, override_enables, false);
case 50: SET_MODAL (MODAL_GROUP_M9, feed_rate_override_enable, true); // conditionally true
case 51: SET_MODAL (MODAL_GROUP_M9, spindle_override_enable, true); // conditionally true
default: status = STAT_UNRECOGNIZED_COMMAND;
}
break;
case 'T': SET_NON_MODAL (tool, (uint8_t)trunc(value));
case 'F': SET_NON_MODAL (feed_rate, value);
case 'P': SET_NON_MODAL (parameter, value); // used for dwell time, G10 coord select
case 'S': SET_NON_MODAL (spindle_speed, value);
case 'X': SET_NON_MODAL (target[AXIS_X], value);
case 'Y': SET_NON_MODAL (target[AXIS_Y], value);
case 'Z': SET_NON_MODAL (target[AXIS_Z], value);
case 'A': SET_NON_MODAL (target[AXIS_A], value);
case 'B': SET_NON_MODAL (target[AXIS_B], value);
case 'C': SET_NON_MODAL (target[AXIS_C], value);
// case 'U': SET_NON_MODAL (target[AXIS_U], value); // reserved
// case 'V': SET_NON_MODAL (target[AXIS_V], value); // reserved
// case 'W': SET_NON_MODAL (target[AXIS_W], value); // reserved
case 'I': SET_NON_MODAL (arc_offset[0], value);
case 'J': SET_NON_MODAL (arc_offset[1], value);
case 'K': SET_NON_MODAL (arc_offset[2], value);
case 'R': SET_NON_MODAL (arc_radius, value);
case 'N': SET_NON_MODAL (linenum,(uint32_t)value); // line number
case 'L': break; // not used for anything
default: status = STAT_UNRECOGNIZED_COMMAND;
}
if(status != STAT_OK) break;
}
if ((status != STAT_OK) && (status != STAT_COMPLETE)) return (status);
ritorno(_validate_gcode_block());
return (_execute_gcode_block()); // if successful execute the block
}
stat_t limit_test(void)
{
if(configFlags[MODOMAQUINA] == MODO_PLASMA)
{
altura_perfuracao = configVarPl[PL_CONFIG_ALTURA_PERFURACAO];
altura_deslocamento = configVarMaq[CFG_MAQUINA_ALT_DESLOCAMENTO];
altura_corte = configVarPl[PL_CONFIG_ALTURA_CORTE];
vel_corte = configVarPl[PL_CONFIG_VELOC_CORTE];
tempo_perfuracao = configVarPl[PL_CONFIG_TEMPO_PERFURACAO];
tempo_aquecimento = 0;
}
else
{
altura_perfuracao = configVarOx[OX_CONFIG_ALTURA_PERFURACAO];
altura_deslocamento = configVarMaq[CFG_MAQUINA_ALT_DESLOCAMENTO];
altura_corte = configVarOx[OX_CONFIG_ALTURA_CORTE];
vel_corte = configVarOx[OX_CONFIG_VELOC_CORTE];
tempo_perfuracao = configVarOx[OX_CONFIG_TEMPO_PERFURACAO];
tempo_aquecimento = configVarOx[OX_CONFIG_TEMPO_AQUECIMENTO];
}
// set initial state for new move
memset(&gp, 0, sizeof(gp)); // clear all parser values
memset(&cm.gf, 0, sizeof(GCodeInput_t)); // clear all next-state flags
memset(&cm.gn, 0, sizeof(GCodeInput_t)); // clear all next-state values
cm.gn.motion_mode = cm_get_motion_mode(MODEL); // get motion mode from previous block
switch (state)
{
case 0: SET_MODAL_MACRO (MODAL_GROUP_G6, units_mode, MILLIMETERS);
state++; break;
case 1: SET_MODAL_MACRO (MODAL_GROUP_G3, distance_mode, ABSOLUTE_MODE);
state++; break;
case 2: SET_NON_MODAL_MACRO (absolute_override, true);
state++; break;
// case 3: SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_TRAVERSE);
// SET_NON_MODAL_MACRO(target[AXIS_Z], altura_deslocamento);
// state++; break;
case 3: SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_FEED);
SET_NON_MODAL_MACRO(target[AXIS_Y], 0);
SET_NON_MODAL_MACRO (feed_rate, 6000);
state++; break;
case 4: SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_FEED);
SET_NON_MODAL_MACRO(target[AXIS_X], 0);
state++; break;
// case 4: SET_NON_MODAL_MACRO (next_action, NEXT_ACTION_DWELL);
// SET_NON_MODAL_MACRO (parameter, 1000);
// state++; break;
case 5: SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_FEED);
SET_NON_MODAL_MACRO(target[AXIS_Y], Ycord);
state++; break;
// case 6: SET_NON_MODAL_MACRO (next_action, NEXT_ACTION_DWELL);
// SET_NON_MODAL_MACRO (parameter, 1000);
// state++; break;
case 6: SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_FEED);
SET_NON_MODAL_MACRO(target[AXIS_X], Xcord);
state++; break;
// case 8: SET_NON_MODAL_MACRO (next_action, NEXT_ACTION_DWELL);
// SET_NON_MODAL_MACRO (parameter, 1000);
// state++; break;
case 7: SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_FEED);
SET_NON_MODAL_MACRO(target[AXIS_Y], 0);
state++; break;
// case 10: SET_NON_MODAL_MACRO (next_action, NEXT_ACTION_DWELL);
// SET_NON_MODAL_MACRO (parameter, 1000);
// state++; break;
case 8: SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_FEED);
SET_NON_MODAL_MACRO(target[AXIS_X], 0);
state++; break;
// case 12: SET_NON_MODAL_MACRO (next_action, NEXT_ACTION_DWELL);
// SET_NON_MODAL_MACRO (parameter, 1000);
// state++; break;
case 9: SET_MODAL_MACRO (MODAL_GROUP_M4, program_flow, PROGRAM_END);
state++; break;
default:state = 0; macro_func_ptr = _command_dispatch; return (STAT_OK);
}
_execute_gcode_block();
return (STAT_OK);
}
stat_t M3_Macro(void)
{
float tempo;
/* A macro não pode acorrer até que o buffer seja esvaziado, para que ações durante o corte tenham efeito imediato*/
if (cm_get_runtime_busy() == true) { return (STAT_EAGAIN);} // sync to planner move ends
macro_buffer = M3_Macro;
// set initial state for new move
memset(&gp, 0, sizeof(gp)); // clear all parser values
memset(&cm.gf, 0, sizeof(GCodeInput_t)); // clear all next-state flags
memset(&cm.gn, 0, sizeof(GCodeInput_t)); // clear all next-state values
cm.gn.motion_mode = cm_get_motion_mode(MODEL); // get motion mode from previous block
/* A macro não pode acorrer até que o buffer seja esvaziado, para que ações durante o corte tenham efeito imediato*/
if (cm_get_runtime_busy() == true) { return (STAT_EAGAIN);} // sync to planner move ends
if(configFlags[MODOMAQUINA] == MODO_PLASMA)
{
altura_perfuracao = configVarPl[PL_CONFIG_ALTURA_PERFURACAO];
altura_deslocamento = configVarMaq[CFG_MAQUINA_ALT_DESLOCAMENTO];
altura_corte = configVarPl[PL_CONFIG_ALTURA_CORTE];
vel_corte = configVarPl[PL_CONFIG_VELOC_CORTE];
tempo_perfuracao = configVarPl[PL_CONFIG_TEMPO_PERFURACAO];
tempo_aquecimento = 0;
switch (state)
{
/* 1- Procura chapa. G38.2 -50 COM FEEDRATE DE 800MM/MIN */
case 0: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_NON_MODAL_MACRO (next_action, NEXT_ACTION_STRAIGHT_PROBE);
SET_NON_MODAL_MACRO(target[AXIS_Z], -50);
SET_NON_MODAL_MACRO (feed_rate, 800);
state++; break;
/* 2- Zera o eixo Z com G28.3 Z0*/
case 1: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_NON_MODAL_MACRO(next_action, NEXT_ACTION_SET_ABSOLUTE_ORIGIN);
SET_NON_MODAL_MACRO(target[AXIS_Z], 0);
state++; break;
/* 3- Posiciona o eixo Z para "ALTURA DE PERFURAÇÃO" */
case 2: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_TRAVERSE);
SET_NON_MODAL_MACRO(target[AXIS_Z], altura_perfuracao);
state++; break;
/* 4- CHECA SE O ESTÁ EM MODO SIMULAÇÃO, SE SIM, PULAR PARA PASSO 8. SE ESTIVER EM MODO OXICORTE, CONTINUA.
4 -Dispara a tocha */
case 3: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_MODAL_MACRO (MODAL_GROUP_M7, spindle_mode, SPINDLE_CW);
state++;
break;
/* 5 -Espera o arco OK */
case 4: if(!sim)
{
uint32_t lRet = pdFALSE;
pl_arcook_start();
lRet = xSemaphoreTake( xArcoOkSync, pdMS_TO_TICKS(3000) );
if (lRet == pdFALSE)
{
uint32_t qSend = ARCO_OK_FAILED;
xQueueSend( qKeyboard, &qSend, 0 );
macro_func_ptr = command_idle;
return (STAT_OK);
}
else
{
// isCuttingSet(true);
}
}
state++; break;
/*6- Dwell do "TEMPO DE PERFURAÇÃO" */
case 5: if (tempo_perfuracao > 0){
SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_NON_MODAL_MACRO (next_action, NEXT_ACTION_DWELL);
SET_NON_MODAL_MACRO (parameter, tempo_perfuracao*1000);
}
else
{
delay_thcStartStop(true);
}
state++; break;
/*7- Desce para a "ALTURA DE CORTE" com feedrate de 800*/
case 6: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_FEED);
SET_NON_MODAL_MACRO(target[AXIS_Z], altura_corte);
SET_NON_MODAL_MACRO (feed_rate, 800);
state++; break;
/*8- Seta o sistema com o feedrate de corte "VELOC. DE CORTE" */
case 7: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_NON_MODAL_MACRO (feed_rate, vel_corte);
state++; break;
default: state = 0; macro_func_ptr = _command_dispatch; return (STAT_OK);
}
}
else
{
altura_perfuracao = configVarOx[OX_CONFIG_ALTURA_PERFURACAO];
altura_deslocamento = configVarMaq[CFG_MAQUINA_ALT_DESLOCAMENTO];
altura_corte = configVarOx[OX_CONFIG_ALTURA_CORTE];
vel_corte = configVarOx[OX_CONFIG_VELOC_CORTE];
tempo_perfuracao = configVarOx[OX_CONFIG_TEMPO_PERFURACAO];
tempo_aquecimento = configVarOx[OX_CONFIG_TEMPO_AQUECIMENTO];
switch (state)
{
/* 1- Posiciona o eixo Z para "ALTURA DE AQUECIMENTO = ALTURA DE CORTE" */
case 0: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_TRAVERSE);
SET_NON_MODAL_MACRO(target[AXIS_Z], altura_corte);
state++; break;
/*2- Dwell do "TEMPO DE AQUECIMENTO". Pula se estiver em simulação */
case 1: if(!sim)
{
tempo = tempo_aquecimento;
}
else
{
tempo = 0;
}
if (tempo > 0){
SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_NON_MODAL_MACRO (next_action, NEXT_ACTION_DWELL);
SET_NON_MODAL_MACRO (parameter, tempo*1000);
}
else
{
delay_thcStartStop(true);
}
state++; break;
/*3- Sobe para "ALTURA DE PERFURAÇÃO" */
case 2: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_TRAVERSE);
SET_NON_MODAL_MACRO(target[AXIS_Z], altura_perfuracao);
state++; break;
/*4- Liga a tocha */
case 3: if(configFlags[MODOMAQUINA] == MODO_OXICORTE){
SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_MODAL_MACRO (MODAL_GROUP_M7, spindle_mode, SPINDLE_CW);
}
state++;
break;
/*5- Dwell do "TEMPO DE PERFURAÇÃO" */
case 4: if(configFlags[MODOMAQUINA] == MODO_OXICORTE){
if(tempo_perfuracao > 0){
SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_NON_MODAL_MACRO (next_action, NEXT_ACTION_DWELL);
SET_NON_MODAL_MACRO (parameter, tempo_perfuracao*1000);
}
else
{
delay_thcStartStop(true);
}
}
state++; break;
/*6- Desce para a "ALTURA DE CORTE" com feedrate de 800*/
case 5: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_MODAL_MACRO (MODAL_GROUP_G1, motion_mode, MOTION_MODE_STRAIGHT_FEED);
SET_NON_MODAL_MACRO(target[AXIS_Z], altura_corte);
SET_NON_MODAL_MACRO (feed_rate, 800);
state++; break;
/*7- Seta o sistema com o feedrate de corte "VELOC. DE CORTE" */
case 6: SET_NON_MODAL_MACRO (linenum,(uint32_t)linenumMacro);
SET_NON_MODAL_MACRO (feed_rate, vel_corte);
state++; break;
default: state = 0; macro_func_ptr = _command_dispatch; return (STAT_OK);
}
}
_execute_gcode_block();
return (STAT_OK);
}
