コード例 #1
0
ファイル: gcode_parser.cpp プロジェクト: flux3dp/fluxclient
int FLUX::GCodeParser::handle_g28(const char* linep, int offset, int size) {
    if(move_to_next_char(linep, offset, size, &offset)) {
        on_error(handler, false, "G28_PARAM_IGNORED %.*s", size, linep);
    }
    handler->home();
    return offset;
}
コード例 #2
0
ファイル: gcode_parser.cpp プロジェクト: flux3dp/fluxclient
int FLUX::GCodeParser::handle_g0g1(const char* linep, int offset, int size) {
    bool terminated = false;
    uint8_t flags = 0;
    float val;

    while(offset < size && !terminated) {
        if(move_to_next_char(linep, offset, size, &offset)) {
            char param = linep[offset];
            switch(param) {
                case ';':
                case '\n':
                    terminated = true;
                    break;
                case 'E':
                    offset = parse_command_float(linep, offset, size, &val);
                    flags |= FLAG_HAS_E(T);
                    if(from_inch) { val = inch2mm(val); }
                    if(absolute) {
                        filaments[T] = val + filaments_offset[T];
                    } else {
                        filaments[T] += val + filaments_offset[T];
                    }
                    break;
                case 'F':
                    offset = parse_command_float(linep, offset, size, &val);
                    if(flags & FLAG_HAS_FEEDRATE) { on_error(handler, false, "DULE_F"); }
                    flags |= FLAG_HAS_FEEDRATE;
                    feedrate = val;
                    break;
                case 'X':
                case 'Y':
                case 'Z':
                    offset = parse_command_float(linep, offset, size, &val);
                    if(flags & FLAG_HAS_AXIS(param)) { on_error(handler, false, "DULE_%c", param); }
                    flags |= FLAG_HAS_AXIS(param);
                    int axis = param - 'X';
                    if(from_inch) { val = inch2mm(val); }
                    if(absolute) {
                        position[axis] = val + position_offset[axis];
                    } else {
                        position[axis] += val + position_offset[axis];
                    }
                    break;
            }
        } else {
            break;
        }
    }

    handler->moveto(flags, feedrate,
                    position[0], position[1], position[2],
                    filaments[0], filaments[1], filaments[2]);
    return offset;
}
コード例 #3
0
ファイル: dll.c プロジェクト: troglobit/gul
void down(buffer_t *buf)
{
	buffer_t *backup = backup_buffer_pos(buf);

	move_to_eol(buf);
	if (!move_to_next_char(buf)) {
//      beep(); /* Finns bara i curses!! */
		restore_buffer_pos(buf, backup);
	} else {
		free(safe_state);
		buf->scr.y++;
		buf->scr.x = move_to_col(buf, buf->scr.x);
	}
}
コード例 #4
0
ファイル: gcode_parser.cpp プロジェクト: flux3dp/fluxclient
int FLUX::GCodeParser::handle_m106(const char* linep, int offset, int size) {
    if(move_to_next_char(linep, offset, size, &offset)) {
        char cmdchar = linep[offset];
        float strength;
        offset = parse_command_float(linep, offset, size, &strength);

        if(cmdchar == 'S') {
            handler->set_toolhead_fan_speed(strength / 255.0);
            return offset;
        }
    }
    on_error(handler, false, "BAD_COMMAND %.*s", size, linep);
    return offset;    
}
コード例 #5
0
ファイル: gcode_parser.cpp プロジェクト: flux3dp/fluxclient
int FLUX::GCodeParser::handle_m104m109(const char* linep, int offset, int size, bool wait) {
    if(move_to_next_char(linep, offset, size, &offset)) {
        char cmdchar = linep[offset];
        float temperature;
        offset = parse_command_float(linep, offset, size, &temperature);

        if(cmdchar == 'S') {
            handler->set_toolhead_heater_temperature(temperature, wait);
            return offset;
        }
    }
    on_error(handler, false, "BAD_COMMAND %.*s", size, linep);
    return offset;    
}
コード例 #6
0
ファイル: gcode_parser.cpp プロジェクト: flux3dp/fluxclient
int FLUX::GCodeParser::handle_x2(const char* linep, int offset, int size) {
    if(move_to_next_char(linep, offset, size, &offset)) {
        char cmdchar = linep[offset];
        float pwm;

        if(cmdchar == 'O') {
            offset = parse_command_float(linep, offset, size, &pwm);
            handler->set_toolhead_pwm(pwm / 255.0);
        } else if(cmdchar == 'F') {
            handler->set_toolhead_pwm(0);
        }
        return offset;
    }
    on_error(handler, false, "BAD_COMMAND %.*s", size, linep);
    return offset;    
}
コード例 #7
0
ファイル: dll.c プロジェクト: troglobit/gul
void right(buffer_t *buf)
{
	char previousChar;

	previousChar = get_current_char(buf);

	if (move_to_next_char(buf)) {
		if ('\n' == previousChar) {
			buf->scr.y++;
			buf->scr.x = 0;
		} else {
			buf->scr.x++;
		}
	} else {
//      beep(); /* Finns bara i curses!! */
	}
}
コード例 #8
0
ファイル: gcode_parser.cpp プロジェクト: flux3dp/fluxclient
int FLUX::GCodeParser::handle_m24m25m226(const char* linep, int offset, int size) {
    if(move_to_next_char(linep, offset, size, &offset)) {
        char cmdchar = linep[offset];
        int val;
        offset = parse_command_int(linep, offset, size, &val);
        if(cmdchar == 'Z') {
            handler->pause(val != 0);
            return offset;
        } else {
            handler->pause(true);
            return offset;
        }
    } else {
        handler->pause(true);
        return offset;
    }
    return offset;
}
コード例 #9
0
ファイル: gcode_parser.cpp プロジェクト: flux3dp/fluxclient
int FLUX::GCodeParser::handle_g4(const char* linep, int offset, int size) {
    if(move_to_next_char(linep, offset, size, &offset)) {
        char cmdchar = linep[offset];
        float timelength;
        offset = parse_command_float(linep, offset, size, &timelength);

        switch(cmdchar) {
            case 'P':
                handler->sleep(timelength * 1000);
                return offset;
            case 'S':
                handler->sleep(timelength);
                return offset;
        }
    }
    on_error(handler, false, "BAD_COMMAND %.*s", size, linep);
    return offset;
}
コード例 #10
0
ファイル: gcode_parser.cpp プロジェクト: flux3dp/fluxclient
int FLUX::GCodeParser::handle_g92(const char* linep, int offset, int size) {
    bool has_param_error = false;
    bool terminated = false;
    float val;
    int axis;

    while(offset < size && !terminated) {
        if(move_to_next_char(linep, offset, size, &offset)) {
            char param = linep[offset];
            offset = parse_command_float(linep, offset, size, &val);
            switch(param) {
                case ';':
                case '\n':
                    terminated = true;
                    break;
                case 'X':
                case 'Y':
                case 'Z':
                    if(from_inch) { val = inch2mm(val); }
                    axis = param - 'X';
                    position_offset[axis] = position[axis] - val;
                    break;
                case 'E':
                    if(from_inch) { val = inch2mm(val); }
                    axis = T;
                    filaments_offset[axis] = filaments[axis] - val;
                    break;
                default:
                    has_param_error = true;
            }
        } else {
            break;
        }
    }
    if(has_param_error) {
        on_error(handler, false, "BAD_PARAM %.*s", size, linep);
    }
    return offset;
}
コード例 #11
0
ファイル: gcode_parser.cpp プロジェクト: flux3dp/fluxclient
void FLUX::GCodeParser::parse_command(const char* linep, size_t size) {
    int cmd_offset = 0;
    if(!move_to_next_char(linep, 0, size, &cmd_offset)) { return; }

    char cmdprefix = linep[cmd_offset];
    int cmdid;
    cmd_offset = parse_command_int(linep, cmd_offset, size, &cmdid);

    switch(cmdprefix) {
        case 'G':
            switch(cmdid) {
                case 0:
                case 1:
                    cmd_offset = handle_g0g1(linep, cmd_offset, size);
                    break;
                case 4:
                    cmd_offset = handle_g4(linep, cmd_offset, size);
                    break;
                case 20:
                    from_inch = true;
                    break;
                case 21:
                    from_inch = false;
                    break;
                case 28:
                    cmd_offset = handle_g28(linep, cmd_offset, size);
                    break;
                case 90:
                    absolute = true;
                    break;
                case 91:
                    absolute = false;
                    break;
                case 92:
                    cmd_offset = handle_g92(linep, cmd_offset, size);
                    break;
                default:
                    on_error(handler, true, "BAD_COMMAND %.*s", size, linep);
                    break;
            }
            break;
        case 'M':
            switch(cmdid) {
                case 17:
                    cmd_offset = handle_m17(linep, cmd_offset, size);
                    break;
                case 18:
                case 84:
                    cmd_offset = handle_m18m84(linep, cmd_offset, size);
                    break;
                case 24:
                case 25:
                case 226:
                    cmd_offset = handle_m24m25m226(linep, cmd_offset, size);
                    break;
                case 104:
                    cmd_offset = handle_m104m109(linep, cmd_offset, size, false);
                    break;
                case 107:
                    cmd_offset = handle_m107(linep, cmd_offset, size);
                    break;
                case 109:
                    cmd_offset = handle_m104m109(linep, cmd_offset, size, true);
                    break;
                case 106:
                    cmd_offset = handle_m106(linep, cmd_offset, size);
                    break;
                default:
                    on_error(handler, true, "BAD_COMMAND %.*s", size, linep);
                    break;
            }
            break;
        case 'T':
            if(cmdid >= 0 && cmdid <= 3) {
                T = cmdid;
            } else {
                on_error(handler, true, "BAD_COMMAND %.*s", size, linep);
            }
            break;
        case 'X':
            if(cmdid == 2) {
                cmd_offset = handle_x2(linep, cmd_offset, size);
            } else {
                on_error(handler, true, "BAD_COMMAND %.*s", size, linep);
            }
            break;
        case ';':
            parse_comment(linep, 0, size);
            return;
        case '\n':
            return;
        default:
            on_error(handler, true, "BAD_COMMAND %.*s", size, linep);
            break;
    }
    parse_comment(linep, cmd_offset, size);
}