func (vm *Machine) feedRate(stmt *gcode.Block) {
if val, err := stmt.GetWord('F'); err == nil {
if vm.Imperial {
val *= 25.4
}
vm.State.Feedrate = val
stmt.RemoveAddress('F')
} else if vm.State.FeedMode == FeedModeInvTime {
vm.State.Feedrate = -1
}
}
// Calculates the absolute position of the given statement, including optional I, J, K parameters.
// Units are converted, and coordinate system applied unless overridden.
func (vm *Machine) calcPos(stmt gcode.Block) (newX, newY, newZ, newI, newJ, newK float64) {
pos := vm.curPos()
var err error
coordinateSystem := vm.CoordinateSystem.GetCoordinateSystem()
if vm.CoordinateSystem.OverrideActive() {
oldAbsolute := vm.AbsoluteMove
vm.AbsoluteMove = true
defer func() {
vm.AbsoluteMove = oldAbsolute
}()
}
if newX, err = stmt.GetWord('X'); err != nil {
newX = pos.X
} else {
if vm.Imperial {
newX *= 25.4
}
if !vm.AbsoluteMove {
newX += pos.X
} else {
newX += coordinateSystem.X
}
}
if newY, err = stmt.GetWord('Y'); err != nil {
newY = pos.Y
} else {
if vm.Imperial {
newY *= 25.4
}
if !vm.AbsoluteMove {
newY += pos.Y
} else {
newY += coordinateSystem.Y
}
}
if newZ, err = stmt.GetWord('Z'); err != nil {
newZ = pos.Z
} else {
if vm.Imperial {
newZ *= 25.4
}
if !vm.AbsoluteMove {
newZ += pos.Z
} else {
newZ += coordinateSystem.Z
}
}
newI = stmt.GetWordDefault('I', 0.0)
newJ = stmt.GetWordDefault('J', 0.0)
newK = stmt.GetWordDefault('K', 0.0)
if vm.Imperial {
newI *= 25.4
newJ *= 25.4
newK *= 25.4
}
if !vm.AbsoluteArc {
newI += pos.X
newJ += pos.Y
newK += pos.Z
} else {
newI += coordinateSystem.X
newJ += coordinateSystem.Y
newZ += coordinateSystem.Z
}
return newX, newY, newZ, newI, newJ, newK
}
func (vm *Machine) nonModals(stmt *gcode.Block) {
if w, err := stmt.GetModalGroup("nonModalGroup"); err == nil {
if w != nil {
if w.Address != 'G' {
unknownCommand("nonModalGroup", w)
}
switch w.Command {
case 4:
if val, err := stmt.GetWord('P'); err == nil {
if val < 0 {
invalidCommand("nonModalGroup", "dwell", "P word negative")
}
vm.dwell(val)
} else {
invalidCommand("nonModalGroup", "dwell", "P word not specified or specified multiple times")
}
stmt.RemoveAddress('P')
case 10:
if val, err := stmt.GetWord('L'); err == nil {
if val == 2 {
// Set coordinate system offsets
if cs, err := stmt.GetWord('P'); err == nil {
cs := int(cs)
x, y, z := stmt.GetWordDefault('X', 0), stmt.GetWordDefault('Y', 0), stmt.GetWordDefault('Z', 0)
x, y, z = vm.axesToMetric(x, y, z)
vm.CoordinateSystem.SetCoordinateSystem(x, y, z, cs)
stmt.RemoveAddress('X', 'Y', 'Z')
} else {
invalidCommand("nonModalGroup", "coordinate system configuration", "P word not specified or specified multiple times")
}
stmt.RemoveAddress('P')
}
} else {
invalidCommand("nonModalGroup", "G10 configuration", "L word not specified or specified multiple times")
}
stmt.RemoveAddress('L')
case 28:
oldMode := vm.State.MoveMode
vm.State.MoveMode = MoveModeRapid
if stmt.IncludesOneOf('X', 'Y', 'Z') {
newX, newY, newZ, _, _, _ := vm.calcPos(*stmt)
vm.move(newX, newY, newZ)
stmt.RemoveAddress('X', 'Y', 'Z')
}
vm.move(vm.StoredPos1.X, vm.StoredPos1.Y, vm.StoredPos1.Z)
vm.State.MoveMode = oldMode
case 28.1:
pos := vm.curPos()
vm.StoredPos1 = pos.Vector()
case 30:
oldMode := vm.State.MoveMode
vm.State.MoveMode = MoveModeRapid
if stmt.IncludesOneOf('X', 'Y', 'Z') {
newX, newY, newZ, _, _, _ := vm.calcPos(*stmt)
vm.move(newX, newY, newZ)
stmt.RemoveAddress('X', 'Y', 'Z')
}
vm.move(vm.StoredPos2.X, vm.StoredPos2.Y, vm.StoredPos2.Z)
vm.State.MoveMode = oldMode
case 30.1:
pos := vm.curPos()
vm.StoredPos2 = pos.Vector()
case 53:
vm.CoordinateSystem.Override()
case 92:
if stmt.IncludesOneOf('X', 'Y', 'Z') {
cp := vm.curPos()
x, y, z := stmt.GetWordDefault('X', 0), stmt.GetWordDefault('Y', 0), stmt.GetWordDefault('Z', 0)
x, y, z = vm.axesToMetric(x, y, z)
vm.CoordinateSystem.DisableOffset()
x, y, z = vm.CoordinateSystem.ApplyCoordinateSystem(x, y, z)
diffX, diffY, diffZ := cp.X-x, cp.Y-y, cp.Z-z
vm.CoordinateSystem.SetOffset(diffX, diffY, diffZ)
vm.CoordinateSystem.EnableOffset()
stmt.RemoveAddress('X', 'Y', 'Z')
} else {
invalidCommand("nonModalGroup", "G92 configuration", "No axis words specified")
}
case 92.1:
vm.CoordinateSystem.EraseOffset()
case 92.2:
vm.CoordinateSystem.DisableOffset()
case 92.3:
vm.CoordinateSystem.EnableOffset()
default:
unknownCommand("nonModalGroup", w)
}
stmt.Remove(w)
}
} else {
propagate(err)
}
}
func (vm *Machine) nextTool(stmt *gcode.Block) {
if val, err := stmt.GetWord('T'); err == nil {
vm.NextTool = int(val)
stmt.RemoveAddress('T')
}
}
func (vm *Machine) spindleSpeed(stmt *gcode.Block) {
if val, err := stmt.GetWord('S'); err == nil {
vm.State.SpindleSpeed = val
stmt.RemoveAddress('S')
}
}
