fix(dispenser): wait for delivery clearance before FC7

This commit is contained in:
2026-09-26 19:27:30 +01:00
parent cb5a09e710
commit 99c74f49b6
4 changed files with 557 additions and 26 deletions
+141 -20
View File
@@ -3,6 +3,7 @@ package dispenser
import (
"context"
"errors"
"fmt"
"sync"
"time"
@@ -26,9 +27,12 @@ type cmdReq struct {
respCh chan cmdResp
}
var errDeliveryPending = errors.New("next-card preparation deferred: previous delivery is not clear")
type cmdResp struct {
status []byte
err error
deliveryPending bool
status []byte
err error
}
type sequenceTiming struct {
@@ -49,6 +53,10 @@ type Client struct {
reqCh chan cmdReq
done chan struct{}
// Owned exclusively by the serial worker.
deliveryPending bool
deliveryStarted time.Time
sequenceTiming sequenceTiming
// status cache
@@ -189,21 +197,26 @@ func (c *Client) handle(req cmdReq) {
switch req.typ {
case cmdStatus:
st, err := checkDispenserStatus(req.ctx, c.port)
if err == nil && len(st) == 4 {
c.mu.Lock()
c.lastStatus = append([]byte(nil), st...)
c.lastStatusT = time.Now()
c.mu.Unlock()
// publish stock/cardwell
c.setStock(st)
}
req.respCh <- cmdResp{status: st, err: err}
st, err := c.readWorkerStatus(req.ctx)
req.respCh <- cmdResp{status: st, err: err, deliveryPending: c.deliveryPending}
case cmdToEncoder:
if c.deliveryPending {
// Stay inside port ownership: never enqueue a request from the worker.
st, err := c.readWorkerStatus(req.ctx)
if err == nil {
_, err = deliveryClearance(st)
}
if err == nil && c.deliveryPending {
err = errDeliveryPending
log.Debugf("next-card preparation deferred; raw status: % X", st)
}
if err != nil {
req.respCh <- cmdResp{err: err}
return
}
}
err := cardToEncoderPosition(req.ctx, c.port)
// A movement command makes any previously cached position unreliable.
c.invalidateStatusCache()
req.respCh <- cmdResp{err: err}
@@ -213,7 +226,12 @@ func (c *Client) handle(req cmdReq) {
req.respCh <- cmdResp{err: err}
case cmdOutOfMouth:
err := cardOutOfMouth(req.ctx, c.port)
attempted, err := cardOutOfMouth(req.ctx, c.port)
if attempted {
c.deliveryPending = true
c.deliveryStarted = time.Now()
log.Info("delivery ENQ attempted; awaiting mechanical clearance")
}
// A movement command makes any previously cached position unreliable.
c.invalidateStatusCache()
req.respCh <- cmdResp{err: err}
@@ -223,21 +241,68 @@ func (c *Client) handle(req cmdReq) {
}
}
// deliveryClearance deliberately does not apply encoder-success precedence.
func deliveryClearance(status []byte) (bool, error) {
if err := validateDispenserStatusData(status); err != nil {
return false, err
}
if isCardWellEmpty(status) {
return false, ErrCardWellEmpty
}
if isPreparationMoving(status) {
return false, nil
}
if err := dispenserStatusError(status); err != nil {
return false, err
}
return status[0] == 0x30 && status[1] == 0x30 && status[3] == 0x30, nil
}
// readWorkerStatus is called only by the serial worker and always reads fresh AP.
func (c *Client) readWorkerStatus(ctx context.Context) ([]byte, error) {
st, err := checkDispenserStatus(ctx, c.port)
if err != nil {
return st, err
}
if c.deliveryPending {
clear, clearanceErr := deliveryClearance(st)
if clearanceErr != nil {
log.Warnf("delivery clearance failed: %v; %s raw status: % X", clearanceErr, statusDescription(st), st)
} else if clear {
c.deliveryPending = false
log.Infof("previous delivery cleared after %s; FC7 permitted", time.Since(c.deliveryStarted))
}
}
if len(st) == 4 {
c.mu.Lock()
c.lastStatus = append([]byte(nil), st...)
c.lastStatusT = time.Now()
c.mu.Unlock()
c.setStock(st)
}
return st, nil
}
func (c *Client) do(ctx context.Context, typ cmdType) ([]byte, error) {
r := c.doResponse(ctx, typ)
return r.status, r.err
}
func (c *Client) doResponse(ctx context.Context, typ cmdType) cmdResp {
rch := make(chan cmdResp, 1)
req := cmdReq{typ: typ, ctx: ctx, respCh: rch}
select {
case c.reqCh <- req:
case <-ctx.Done():
return nil, ctx.Err()
return cmdResp{err: ctx.Err()}
}
select {
case r := <-rch:
return r.status, r.err
return r
case <-ctx.Done():
return nil, ctx.Err()
return cmdResp{err: ctx.Err()}
}
}
@@ -322,7 +387,11 @@ func (c *Client) DispenserPrepare(ctx context.Context) (string, error) {
}
func (c *Client) readSequenceStatus(ctx context.Context, operation string) ([]byte, string, error) {
status, err := c.do(ctx, cmdStatus)
response := c.doResponse(ctx, cmdStatus)
status, err := response.status, response.err
if err == nil && response.deliveryPending {
err = errDeliveryPending
}
if err != nil {
if ctxErr := ctx.Err(); ctxErr != nil {
return nil, "", fmt.Errorf("[%s] read status: %w", operation, ctxErr)
@@ -513,8 +582,60 @@ func (c *Client) pollForEncoderPosition(ctx context.Context, operation string) (
}
}
// waitForDeliveryClearance reuses the first clear AP as the initial preparation sample.
// Its bounded window is separate from recovery, which starts after initial FC7.
func (c *Client) waitForDeliveryClearance(ctx context.Context, operation string) (status []byte, stock string, resultErr error) {
ctx, cancel := context.WithTimeout(ctx, sequenceTimeout)
defer cancel()
deadline := c.sequenceTiming.now().Add(sequenceTimeout)
var lastStatus []byte
defer func() {
if resultErr != nil {
log.Warnf("[%s] delivery clearance stopped: %v; %s raw status: % X", operation, resultErr, statusDescription(lastStatus), lastStatus)
}
}()
for {
if err := ctx.Err(); err != nil {
return nil, stock, fmt.Errorf("[%s] delivery clearance: %w", operation, err)
}
if !c.sequenceTiming.now().Before(deadline) {
return nil, stock, fmt.Errorf("[%s] delivery clearance: %w", operation, context.DeadlineExceeded)
}
r := c.doResponse(ctx, cmdStatus)
if len(r.status) > 0 {
lastStatus = r.status
}
if r.err != nil {
return nil, stock, fmt.Errorf("[%s] delivery clearance status: %w", operation, r.err)
}
if len(r.status) == 4 {
stock = stockTake(r.status)
c.setStock(r.status)
}
if err := ctx.Err(); err != nil {
return nil, stock, err
}
if !c.sequenceTiming.now().Before(deadline) {
return nil, stock, fmt.Errorf("[%s] delivery clearance: %w", operation, context.DeadlineExceeded)
}
if !r.deliveryPending {
return r.status, stock, nil
}
if _, err := deliveryClearance(r.status); err != nil {
return nil, stock, fmt.Errorf("[%s] delivery clearance: %w", operation, err)
}
wait := sequencePollInterval
if remaining := deadline.Sub(c.sequenceTiming.now()); remaining < wait {
wait = remaining
}
if err := c.sequenceTiming.wait(ctx, wait); err != nil {
return nil, stock, fmt.Errorf("[%s] delivery clearance: %w", operation, err)
}
}
}
func (c *Client) prepareCardAtEncoder(ctx context.Context, operation string) (string, error) {
status, stockStatus, err := c.readSequenceStatus(ctx, operation)
status, stockStatus, err := c.waitForDeliveryClearance(ctx, operation)
if err != nil {
return stockStatus, err
}