530 lines
12 KiB
Go
530 lines
12 KiB
Go
package printer
|
|
|
|
import (
|
|
"bufio"
|
|
"context"
|
|
"fmt"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"go.bug.st/serial"
|
|
)
|
|
|
|
// Event is a state snapshot published whenever the printer state changes,
|
|
// plus a raw recv line (RecvLine != "" means "log this; State unchanged is allowed").
|
|
type Event struct {
|
|
State State
|
|
RecvLine string
|
|
SentLine string
|
|
}
|
|
|
|
type Printer struct {
|
|
mu sync.Mutex
|
|
state State
|
|
port serial.Port
|
|
events chan Event
|
|
writes chan string // outbound G-code (best-effort, non-blocking)
|
|
cancel context.CancelFunc
|
|
stopped chan struct{}
|
|
}
|
|
|
|
func New() *Printer {
|
|
return &Printer{
|
|
state: NewState(),
|
|
events: make(chan Event, 128),
|
|
writes: make(chan string, 64),
|
|
}
|
|
}
|
|
|
|
func (p *Printer) Events() <-chan Event { return p.events }
|
|
|
|
func (p *Printer) Snapshot() State {
|
|
p.mu.Lock()
|
|
defer p.mu.Unlock()
|
|
return p.state
|
|
}
|
|
|
|
// ListPorts returns plausible printer serial devices.
|
|
func ListPorts() []string {
|
|
out := []string{}
|
|
for _, pat := range []string{"/dev/ttyACM*", "/dev/ttyUSB*"} {
|
|
m, _ := filepath.Glob(pat)
|
|
out = append(out, m...)
|
|
}
|
|
return out
|
|
}
|
|
|
|
// CommonBauds is the ordered list of baud rates tried during auto-detection.
|
|
// 250000 is Marlin's historical AVR default; 115200 covers STM32 builds,
|
|
// Klipper-prep firmwares, and RepRapFirmware.
|
|
var CommonBauds = []int{250000, 115200, 230400, 500000, 57600}
|
|
|
|
// probeBaud opens the port at each candidate baud and looks for a
|
|
// recognisable Marlin/RepRap reply. Returns the working baud and an open
|
|
// port handle on success.
|
|
//
|
|
// We deliberately require an *unambiguous* match (firmware name or a
|
|
// well-formed temperature line). Short tokens like "ok" or "start" appear
|
|
// too easily in misaligned-baud garbage and would yield a false positive,
|
|
// so they are not accepted on their own.
|
|
func probeBaud(portName string, candidates []int) (int, serial.Port, error) {
|
|
tempLine := regexp.MustCompile(`(?i)(?:^|\s)(?:T\d*|B|C):\s*-?\d+(?:\.\d+)?\s*/\s*-?\d+`)
|
|
|
|
for _, b := range candidates {
|
|
sp, err := serial.Open(portName, &serial.Mode{BaudRate: b})
|
|
if err != nil {
|
|
continue
|
|
}
|
|
_ = sp.SetReadTimeout(100 * time.Millisecond)
|
|
|
|
// Many boards reset on DTR assertion and need ~2 s to boot.
|
|
// Wait, then prod the firmware twice (once early in case the boot
|
|
// already finished, once later in case the first prod was eaten).
|
|
time.Sleep(400 * time.Millisecond)
|
|
_, _ = sp.Write([]byte("\nM115\n"))
|
|
time.Sleep(1200 * time.Millisecond)
|
|
_, _ = sp.Write([]byte("\nM115\nM105\n"))
|
|
|
|
deadline := time.Now().Add(1500 * time.Millisecond)
|
|
buf := make([]byte, 256)
|
|
var acc []byte
|
|
ok := false
|
|
for time.Now().Before(deadline) {
|
|
n, _ := sp.Read(buf)
|
|
if n == 0 {
|
|
continue
|
|
}
|
|
acc = append(acc, buf[:n]...)
|
|
low := strings.ToLower(string(acc))
|
|
if strings.Contains(low, "marlin") ||
|
|
strings.Contains(low, "firmware_name") ||
|
|
strings.Contains(low, "reprapfirmware") ||
|
|
strings.Contains(low, "klipper") ||
|
|
tempLine.MatchString(string(acc)) {
|
|
ok = true
|
|
break
|
|
}
|
|
// Cap accumulator so we don't grow unbounded on garbage.
|
|
if len(acc) > 4096 {
|
|
acc = acc[len(acc)-2048:]
|
|
}
|
|
}
|
|
if ok {
|
|
return b, sp, nil
|
|
}
|
|
_ = sp.Close()
|
|
}
|
|
return 0, nil, fmt.Errorf("could not auto-detect baud rate; tried %v", candidates)
|
|
}
|
|
|
|
func (p *Printer) Connect(portName string, baud int) error {
|
|
p.Disconnect()
|
|
|
|
// Candidate ports: caller-specified, or everything that looks like a
|
|
// printer. We probe each in turn so that systems with multiple ACM/USB
|
|
// devices (modems, debug probes, etc.) don't trap us on the wrong one.
|
|
var candidates []string
|
|
if portName != "" {
|
|
candidates = []string{portName}
|
|
} else {
|
|
candidates = ListPorts()
|
|
if len(candidates) == 0 {
|
|
return fmt.Errorf("no serial port found")
|
|
}
|
|
}
|
|
|
|
var sp serial.Port
|
|
var chosenPort string
|
|
if baud <= 0 {
|
|
var lastErr error
|
|
for _, pn := range candidates {
|
|
detected, opened, err := probeBaud(pn, CommonBauds)
|
|
if err != nil {
|
|
lastErr = err
|
|
continue
|
|
}
|
|
sp = opened
|
|
baud = detected
|
|
chosenPort = pn
|
|
break
|
|
}
|
|
if sp == nil {
|
|
if lastErr != nil {
|
|
return fmt.Errorf("no responsive printer on %v: %w", candidates, lastErr)
|
|
}
|
|
return fmt.Errorf("no responsive printer on %v", candidates)
|
|
}
|
|
} else {
|
|
// Explicit baud: still try each candidate port until one opens and
|
|
// looks alive at this baud.
|
|
var lastErr error
|
|
for _, pn := range candidates {
|
|
opened, err := serial.Open(pn, &serial.Mode{BaudRate: baud})
|
|
if err != nil {
|
|
lastErr = err
|
|
continue
|
|
}
|
|
sp = opened
|
|
chosenPort = pn
|
|
break
|
|
}
|
|
if sp == nil {
|
|
return fmt.Errorf("could not open any of %v: %w", candidates, lastErr)
|
|
}
|
|
}
|
|
portName = chosenPort
|
|
_ = sp.SetReadTimeout(500 * time.Millisecond)
|
|
|
|
p.mu.Lock()
|
|
p.port = sp
|
|
p.state.Connected = true
|
|
p.state.Port = portName
|
|
p.state.Baud = baud
|
|
p.state.ErrorMsg = ""
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.publish(Event{State: snap})
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
p.cancel = cancel
|
|
p.stopped = make(chan struct{})
|
|
|
|
go p.run(ctx)
|
|
return nil
|
|
}
|
|
|
|
func (p *Printer) Disconnect() {
|
|
if p.cancel != nil {
|
|
p.cancel()
|
|
<-p.stopped
|
|
p.cancel = nil
|
|
}
|
|
p.mu.Lock()
|
|
if p.port != nil {
|
|
_ = p.port.Close()
|
|
p.port = nil
|
|
}
|
|
p.state.Connected = false
|
|
p.state.Online = false
|
|
p.state.PrintState = StateIdle
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.publish(Event{State: snap})
|
|
}
|
|
|
|
// run is the connection goroutine. It owns the serial port for the duration
|
|
// of the connection and serialises reads/writes through this single goroutine.
|
|
func (p *Printer) run(ctx context.Context) {
|
|
defer close(p.stopped)
|
|
|
|
port := p.port
|
|
if port == nil {
|
|
return
|
|
}
|
|
|
|
reader := bufio.NewReader(port)
|
|
lineCh := make(chan string, 32)
|
|
|
|
// reader goroutine
|
|
go func() {
|
|
for {
|
|
line, err := reader.ReadString('\n')
|
|
if err != nil {
|
|
if ctx.Err() != nil {
|
|
close(lineCh)
|
|
return
|
|
}
|
|
// timeout — ReadString returns partial+err; just retry
|
|
if line == "" {
|
|
continue
|
|
}
|
|
}
|
|
line = strings.TrimRight(line, "\r\n")
|
|
if line == "" {
|
|
continue
|
|
}
|
|
select {
|
|
case lineCh <- line:
|
|
case <-ctx.Done():
|
|
close(lineCh)
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
|
|
// Probe — these prime auto-reporting on firmwares that support it.
|
|
primed := false
|
|
primeAfter := time.NewTimer(2 * time.Second)
|
|
defer primeAfter.Stop()
|
|
|
|
pollTemp := time.NewTicker(2 * time.Second)
|
|
defer pollTemp.Stop()
|
|
pollSD := time.NewTicker(5 * time.Second)
|
|
defer pollSD.Stop()
|
|
|
|
prime := func() {
|
|
if primed {
|
|
return
|
|
}
|
|
primed = true
|
|
p.writeRaw("M115")
|
|
// Disable any auto-reporting Marlin may have on — our own polling is
|
|
// the single source of truth. Otherwise the two streams collide and
|
|
// produce mangled output like "TT::57.4957.49".
|
|
p.writeRaw("M155 S0")
|
|
p.writeRaw("M27 S0")
|
|
// First explicit poll so users see data fast
|
|
p.writeRaw("M105")
|
|
p.writeRaw("M27")
|
|
}
|
|
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
|
|
case <-primeAfter.C:
|
|
// Some firmwares emit "start" / "Marlin" before being ready; just prime now.
|
|
prime()
|
|
// Mark online if we got *anything* by now
|
|
p.setOnline(true)
|
|
|
|
case line, ok := <-lineCh:
|
|
if !ok {
|
|
return
|
|
}
|
|
// "start" / "Marlin" / "ok" gates online
|
|
low := strings.ToLower(line)
|
|
if strings.Contains(low, "start") || strings.HasPrefix(low, "marlin") {
|
|
prime()
|
|
p.setOnline(true)
|
|
}
|
|
if strings.HasPrefix(low, "ok") {
|
|
p.setOnline(true)
|
|
}
|
|
if strings.HasPrefix(low, "error") || strings.HasPrefix(low, "!!") {
|
|
p.setError(line)
|
|
}
|
|
|
|
p.mu.Lock()
|
|
p.state.Parse(line)
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
|
|
p.publish(Event{RecvLine: line, State: snap})
|
|
|
|
case <-pollTemp.C:
|
|
if !primed {
|
|
continue
|
|
}
|
|
p.writeRaw("M105")
|
|
|
|
case <-pollSD.C:
|
|
if !primed {
|
|
continue
|
|
}
|
|
p.writeRaw("M27")
|
|
|
|
case gcode := <-p.writes:
|
|
p.writeRaw(gcode)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *Printer) writeRaw(gcode string) {
|
|
p.mu.Lock()
|
|
port := p.port
|
|
p.mu.Unlock()
|
|
if port == nil {
|
|
return
|
|
}
|
|
line := strings.TrimSpace(gcode)
|
|
if line == "" {
|
|
return
|
|
}
|
|
_, err := port.Write([]byte(line + "\n"))
|
|
if err != nil {
|
|
p.setError(err.Error())
|
|
return
|
|
}
|
|
p.publish(Event{SentLine: line, State: p.Snapshot()})
|
|
}
|
|
|
|
// Send enqueues a raw G-code line. Non-blocking; drops if buffer full.
|
|
func (p *Printer) Send(gcode string) {
|
|
select {
|
|
case p.writes <- gcode:
|
|
default:
|
|
}
|
|
}
|
|
|
|
// -- high-level commands --------------------------------------------------
|
|
|
|
func (p *Printer) SetHotend(temp int, tool int) { p.Send(fmt.Sprintf("M104 T%d S%d", tool, temp)) }
|
|
func (p *Printer) SetBed(temp int) { p.Send(fmt.Sprintf("M140 S%d", temp)) }
|
|
|
|
func (p *Printer) SetFan(pct int) {
|
|
pct = clamp(pct, 0, 100)
|
|
if pct == 0 {
|
|
p.Send("M107")
|
|
} else {
|
|
p.Send(fmt.Sprintf("M106 S%d", pct*255/100))
|
|
}
|
|
p.mu.Lock()
|
|
p.state.FanPct = pct
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.publish(Event{State: snap})
|
|
}
|
|
|
|
func (p *Printer) SetFeedrate(pct int) {
|
|
pct = clamp(pct, 10, 300)
|
|
p.Send(fmt.Sprintf("M220 S%d", pct))
|
|
p.mu.Lock()
|
|
p.state.FeedratePct = pct
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.publish(Event{State: snap})
|
|
}
|
|
|
|
func (p *Printer) SetFlow(pct int) {
|
|
pct = clamp(pct, 50, 150)
|
|
p.Send(fmt.Sprintf("M221 S%d", pct))
|
|
p.mu.Lock()
|
|
p.state.FlowPct = pct
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.publish(Event{State: snap})
|
|
}
|
|
|
|
func (p *Printer) BabystepZ(delta float64) {
|
|
p.Send(fmt.Sprintf("M290 Z%.3f", delta))
|
|
p.mu.Lock()
|
|
p.state.BabystepZ = roundTo(p.state.BabystepZ+delta, 3)
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.publish(Event{State: snap})
|
|
}
|
|
|
|
func (p *Printer) ResetBabystep() {
|
|
p.mu.Lock()
|
|
delta := -p.state.BabystepZ
|
|
p.state.BabystepZ = 0
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.Send(fmt.Sprintf("M290 Z%.3f", delta))
|
|
p.publish(Event{State: snap})
|
|
}
|
|
|
|
func (p *Printer) Pause() {
|
|
p.mu.Lock()
|
|
if p.state.PrintState == StateSDPrinting {
|
|
p.state.PrintState = StatePaused
|
|
}
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.Send("M25")
|
|
p.publish(Event{State: snap})
|
|
}
|
|
|
|
func (p *Printer) Resume() {
|
|
p.mu.Lock()
|
|
if p.state.PrintState == StatePaused && p.state.SDTotal > 0 {
|
|
p.state.PrintState = StateSDPrinting
|
|
}
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.Send("M24")
|
|
p.publish(Event{State: snap})
|
|
}
|
|
|
|
// ListSDFiles asks the printer to enumerate its SD card. The reply is
|
|
// parsed asynchronously; the next State snapshot whose SDListing flips
|
|
// false carries the complete listing in SDFiles.
|
|
func (p *Printer) ListSDFiles() {
|
|
p.Send("M21") // init / mount SD (no-op if already mounted)
|
|
p.Send("M20")
|
|
}
|
|
|
|
// StartSDPrint selects the given filename on the SD card and starts it.
|
|
// M23 selects, M24 begins. Filename must be the 8.3 short name that
|
|
// Marlin's M20 listing reports.
|
|
func (p *Printer) StartSDPrint(filename string) {
|
|
filename = strings.TrimSpace(filename)
|
|
if filename == "" {
|
|
return
|
|
}
|
|
p.Send("M23 " + filename)
|
|
p.Send("M24")
|
|
}
|
|
|
|
func (p *Printer) Cancel() {
|
|
p.Send("M524")
|
|
p.mu.Lock()
|
|
p.state.PrintState = StateIdle
|
|
p.state.SDByte, p.state.SDTotal = 0, 0
|
|
p.state.SDStart = zeroTime
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.publish(Event{State: snap})
|
|
}
|
|
|
|
// -- internals ------------------------------------------------------------
|
|
|
|
func (p *Printer) setOnline(v bool) {
|
|
p.mu.Lock()
|
|
if p.state.Online == v {
|
|
p.mu.Unlock()
|
|
return
|
|
}
|
|
p.state.Online = v
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.publish(Event{State: snap})
|
|
}
|
|
|
|
func (p *Printer) setError(msg string) {
|
|
p.mu.Lock()
|
|
p.state.ErrorMsg = msg
|
|
p.state.PrintState = StateError
|
|
snap := p.state
|
|
p.mu.Unlock()
|
|
p.publish(Event{State: snap, RecvLine: "ERR " + msg})
|
|
}
|
|
|
|
func (p *Printer) publish(e Event) {
|
|
select {
|
|
case p.events <- e:
|
|
default:
|
|
// drop on full channel — UI will catch up on the next event
|
|
}
|
|
}
|
|
|
|
func clamp(v, lo, hi int) int {
|
|
if v < lo {
|
|
return lo
|
|
}
|
|
if v > hi {
|
|
return hi
|
|
}
|
|
return v
|
|
}
|
|
|
|
func roundTo(v float64, places int) float64 {
|
|
pow := 1.0
|
|
for i := 0; i < places; i++ {
|
|
pow *= 10
|
|
}
|
|
return float64(int64(v*pow+0.5*sign(v))) / pow
|
|
}
|
|
|
|
func sign(v float64) float64 {
|
|
if v < 0 {
|
|
return -1
|
|
}
|
|
return 1
|
|
}
|