fix(dispenser): wait for delivery clearance before FC7
This commit is contained in:
@@ -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
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user