Merge branch 'main' into clean_beep

# Conflicts:
#	internal/routes/wait.go

internal/common/pause.go

@@ -0,0 +1,53 @@
+package common
+
+import "sync"
+
+// CtrlWait 待机暂停控制器
+type CtrlWait struct {
+	C chan int8
+
+	// 状态
+	s bool
+	m sync.RWMutex
+}
+
+// Pause 暂停
+func (c *CtrlWait) Pause() {
+	c.m.RLock()
+	defer c.m.RUnlock()
+	if c.s {
+		c.C <- 1
+	}
+}
+
+// Resume 恢复
+func (c *CtrlWait) Resume() {
+	c.m.RLock()
+	defer c.m.RUnlock()
+	if c.s {
+		c.C <- 0
+	}
+}
+
+func (c *CtrlWait) Open() {
+	c.m.Lock()
+	defer c.m.Unlock()
+	c.s = true
+}
+
+func (c *CtrlWait) Close() {
+	c.m.Lock()
+	defer c.m.Unlock()
+	c.s = false
+}
+
+// NewCtrlWait 创建一个控制等待
+func NewCtrlWait() *CtrlWait {
+	return &CtrlWait{
+		C: make(chan int8),
+		s: false,
+	}
+}
+
+// PassCtrl 全局控制等待
+var PassCtrl = NewCtrlWait()

internal/common/pause_sub.go

@@ -0,0 +1,59 @@
+package common
+
+import (
+	"context"
+	"sync"
+)
+
+type PauseSub struct {
+	ctrl  *CtrlWait
+	items []chan int8
+	m     sync.RWMutex
+}
+
+func (p *PauseSub) GetNew() chan int8 {
+	p.m.Lock()
+	defer p.m.Unlock()
+	sub := make(chan int8)
+	p.items = append(p.items, sub)
+	return sub
+}
+
+func (p *PauseSub) Close(sub chan int8) {
+	p.m.Lock()
+	defer p.m.Unlock()
+	close(sub)
+	for i, v := range p.items {
+		if v == sub {
+			p.items = append(p.items[:i], p.items[i+1:]...)
+		}
+	}
+}
+
+// Run 开始监听
+func (p *PauseSub) Run(ctx context.Context) {
+	p.ctrl.Open()
+	defer p.ctrl.Close()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case c := <-p.ctrl.C:
+			go func() {
+				p.m.RLock()
+				defer p.m.RUnlock()
+				for _, item := range p.items {
+					item <- c
+				}
+			}()
+		}
+	}
+}
+
+func NewPauseSub(c *CtrlWait) *PauseSub {
+	return &PauseSub{
+		ctrl:  c,
+		items: make([]chan int8, 0),
+	}
+}

internal/middleware/cache.go

@@ -0,0 +1,18 @@
+package middleware
+
+import (
+	"game-driver/config"
+	"game-driver/leaf"
+	"go.uber.org/zap"
+)
+
+// Cache 缓存中间件
+func Cache(cache config.Cache) leaf.HandlerFunc {
+	return func(c *leaf.Context) {
+		err := cache.Set(c.Publish)
+		if err != nil {
+			zap.S().Errorln("缓存数据失败: ", err)
+		}
+		c.Next()
+	}
+}

internal/middleware/pause_wait.go

@@ -0,0 +1,15 @@
+package middleware
+
+import (
+	"game-driver/internal/common"
+	"game-driver/leaf"
+)
+
+func PauseWait(ctrl *common.CtrlWait) leaf.HandlerFunc {
+	return func(c *leaf.Context) {
+		ctrl.Pause()
+		defer ctrl.Resume()
+
+		c.Next()
+	}
+}

internal/middleware/sound_start.go

@@ -14,8 +14,10 @@ func SoundStart() leaf.HandlerFunc {
 
 		defer func() {
 			switch leaf.Value[leaf.EndType](c, leaf.EndKey) {
-			case leaf.EndTimer:
+			case leaf.End:
 				tts.DefaultTTS.Sound(pm.TTS.End)
+			case leaf.EndTimeout:
+				tts.DefaultTTS.Sound(pm.TTS.Timeout)
 			case leaf.EndStop:
 				tts.DefaultTTS.Sound(pm.TTS.Stop)
 			}

internal/middleware/stop.go

@@ -4,6 +4,7 @@ import (
 	"game-driver/internal/common"
 	"game-driver/leaf"
 	"go.uber.org/zap"
+	"sync"
 )
 
 // EmergencyStop 紧急停止中间件
@@ -12,14 +13,21 @@ func EmergencyStop(stopper common.Stopper) leaf.HandlerFunc {
 		cancel := leaf.WithCancel(c)
 		defer stopper.Reset()
 
+		zap.S().Infoln("监听停止信号")
+		defer zap.S().Infoln("结束停止信号监听")
+
+		// 等待组
+		var wait sync.WaitGroup
+		defer wait.Wait()
+
 		// 结束信号通道
 		a := make(chan struct{})
 		// 发送结束信号
 		defer close(a)
 
-		zap.S().Infoln("监听停止信号")
+		wait.Add(1)
 		go func() {
-			defer zap.S().Infoln("结束停止信号监听")
+			defer wait.Done()
 
 			select {
 			case <-a:

internal/middleware/ticker.go

@@ -9,6 +9,7 @@ import (
 	"time"
 )
 
+// TickerAction 定时器动作,用于在指定时间点执行打印和语音播报
 func TickerAction() leaf.HandlerFunc {
 	return func(c *leaf.Context) {
 		pm := leaf.Value[*schema.PlayModal](c, PayloadJSONKey)

internal/middleware/timer.go

@@ -8,7 +8,7 @@ import (
 	"time"
 )
 
-// TimeoutOver 定时器中间件，用于定时触发屏幕打印和语音播报。 t 是语音播报实例
+// TimeoutOver 超时停止
 func TimeoutOver(maxTimeout int) leaf.HandlerFunc {
 	return func(c *leaf.Context) {
 		pm := leaf.Value[*schema.PlayModal](c, PayloadJSONKey)
@@ -46,7 +46,7 @@ func TimeoutOver(maxTimeout int) leaf.HandlerFunc {
 				{
 					zap.S().Infoln("超时 Timer 触发")
 					cancel()
-					leaf.WithValue[leaf.EndType](c, leaf.EndKey, leaf.EndTimer)
+					leaf.WithValue[leaf.EndType](c, leaf.EndKey, leaf.EndTimeout)
 				}
 			}
 		}()

internal/middleware/unique.go

@@ -12,7 +12,7 @@ func Unique(stopper common.Stopper) leaf.HandlerFunc {
 	var lock sync.Mutex
 	return func(c *leaf.Context) {
 		if !lock.TryLock() {
-			zap.S().Infoln("尝试加锁失败，执行停止任务")
+			zap.S().Infoln("停止之前的任务，再尝试加锁")
 			stopper.Stop()
 			lock.Lock()
 		}

internal/routes/play.go

@@ -19,11 +19,14 @@ func switchPoint(ctx context.Context, point int) leaf.HandlerFunc {
 	switch point {
 	case 2: // 镇水塔点位
 		return play.OnlyVideo
-	case 4:
-		// 4号点位(发卡机)
-		return play.PushCard(ctx)
 	case 5:
-		// 5号点位(等待插卡)
+		// 登龙云台(激光秀)
+		return play.LaserShow
+	case 10:
+		// 10号点位(发卡机)
+		return play.PushCard(ctx)
+	case 11:
+		// 11号点位(等待插卡)
 		return play.WaitCard(ctx)
 	default:
 		return play.Default

internal/routes/play/laser.go

@@ -0,0 +1,45 @@
+package play
+
+import (
+	"game-driver/config/game"
+	"game-driver/internal/middleware"
+	"game-driver/internal/schema"
+	"game-driver/leaf"
+	"game-driver/pkg/oscx"
+	"go.uber.org/zap"
+	"time"
+)
+
+func LaserShow(c *leaf.Context) {
+	cfg := (game.C).(game.LaserConfig)
+
+	payload := leaf.Value[*schema.PlayModal](c, middleware.PayloadJSONKey)
+
+	if data, ok := payload.Game["osc"].(string); ok {
+		zap.S().Infoln("开始播放激光秀:", data)
+
+		o := oscx.New(cfg.Host, cfg.Port)
+		err := o.EnableLaserOutput()
+		if err != nil {
+			zap.S().Warnln("激光打开异常:", err)
+			return
+		} else {
+			defer zap.S().Infoln("激光秀播放结束:", data)
+			defer o.DisableLaserOutput()
+
+			err = o.StartCue(data)
+			if err != nil {
+				zap.S().Warnln("播放激光节目异常:", err)
+				return
+			}
+		}
+	}
+	if w, ok := payload.Game["wait"]; ok {
+		if v, ok := w.(float64); ok {
+			select {
+			case <-c.Done():
+			case <-time.After(time.Duration(v) * time.Second):
+			}
+		}
+	}
+}

internal/routes/play/only_video.go

@@ -16,11 +16,11 @@ func OnlyVideo(c *leaf.Context) {
 	defer utils.BlankClose()
 
 	if url, ok := payload.Game["video"]; ok {
-		local, err := utils.LinkVideo(url.(string))
+		path, local, err := utils.LinkVideo(url.(string))
 		if err != nil {
 			zap.S().Errorln("视频文件获取异常: ", err)
 			return
 		}
-		_ = video.Play(c, local)
+		_ = video.Play(c, path, local)
 	}
 }

internal/routes/play/push_card.go

@@ -28,14 +28,14 @@ type ResponseBody struct {
 }
 
 func PushCard(ctx context.Context) leaf.HandlerFunc {
-	g := (game.G).(game.ConfigPush)
+	g := (game.C).(game.ConfigPush)
 
 	readers := make([]card_reader.Reader, len(g.PushGroups))
 	devices := make([]*card_pusher.Device, len(g.PushGroups))
 	for i, group := range g.PushGroups {
 		// 解析配置
 		gv, _ := json.Marshal(group)
-		zap.S().Info("关卡配置:", string(gv))
+		zap.S().Infof("关卡配置[%v]: %s", i, string(gv))
 
 		// 开始连接读卡器
 		if group.Read != "" {
@@ -63,7 +63,7 @@ func PushCard(ctx context.Context) leaf.HandlerFunc {
 			zap.S().Panicln("初始化发卡器失败: ", err)
 		}
 
-		// 保存读卡器和发卡器
+		// 保存发卡器
 		devices[i] = device
 	}
 	go func() {

internal/routes/play/wait_card.go

@@ -18,7 +18,7 @@ import (
 )
 
 func WaitCard(ctx context.Context) leaf.HandlerFunc {
-	g := (game.G).(game.ConfigWait)
+	g := (game.C).(game.ConfigWait)
 
 	reader, err := card_reader.NewReader(g.Addr)
 	if err != nil {

internal/routes/standby.go

@@ -0,0 +1,101 @@
+package routes
+
+import (
+	"context"
+	"game-driver/internal/common"
+	"game-driver/internal/middleware"
+	"game-driver/internal/routes/standby"
+	"game-driver/internal/routes/standby_ctrl"
+	"game-driver/internal/schema"
+	"game-driver/leaf"
+	"github.com/go-pkgz/cronrange"
+	"go.uber.org/zap"
+	"sync"
+)
+
+// StandbyAction 待机任务，支持音乐、TTS、继电器、视频、网页、投影仪、大型激光秀 ctrl
+func StandbyAction(ctrl *common.CtrlWait, device *common.Device) leaf.HandlerFunc {
+	ps := common.NewPauseSub(ctrl)
+
+	return func(c *leaf.Context) {
+		payload := leaf.Value[*schema.WaitModel](c, middleware.PayloadJSONKey)
+
+		// 设定默认时间规则,ctrl
+		if payload.Cron == "" {
+			payload.Cron = "* * * *"
+		}
+
+		rules, err := cronrange.Parse(payload.Cron)
+		if err != nil {
+			zap.S().Errorln("解析时间规则异常: ", err)
+			return
+		}
+
+		// 等待组
+		var waitGroup sync.WaitGroup
+		defer waitGroup.Wait()
+
+		// 开启暂停监听
+		waitGroup.Add(1)
+		go func() {
+			defer waitGroup.Done()
+			ps.Run(c)
+		}()
+
+		// 处理每个待机控制
+		handleItem := func(title string, item schema.WaitItemModel, f func(c context.Context) error) {
+			waitGroup.Add(1)
+			go func() {
+				defer waitGroup.Done()
+				if f == nil {
+					return
+				}
+				f = standby_ctrl.Duration(item.Duration, f)
+				if f == nil {
+					return
+				}
+				f = standby_ctrl.Device(device, item.Lock, f)
+				if f == nil {
+					return
+				}
+				f = standby_ctrl.Interval(item.Interval, f)
+				if f == nil {
+					return
+				}
+				f = standby_ctrl.Pause(ps, item.Pause, f)
+				if f == nil {
+					return
+				}
+				f = standby_ctrl.Cron(rules, item.Cron, f)
+				if f == nil {
+					return
+				}
+				e := f(c)
+				if e != nil {
+					zap.S().Errorf("%s异常: %s\n", title, e)
+				}
+			}()
+		}
+
+		for _, item := range payload.Items {
+			switch item.Type {
+			case schema.WaitAudio:
+				handleItem("音乐待机控制", item, standby.Audio(item))
+			case schema.WaitTTS:
+				handleItem("TTS待机控制", item, standby.TTS(item))
+			case schema.WaitRelay:
+				handleItem("继电器待机控制", item, standby.Relay(item))
+			case schema.WaitVideo:
+				handleItem("视频待机控制", item, standby.Video(item))
+			case schema.WaitWeb:
+				handleItem("网页待机控制", item, standby.Web(item))
+			case schema.WaitPJLink:
+				handleItem("投影仪待机控制", item, standby.PJLink(item))
+			case schema.WaitLaserShow:
+				handleItem("大型激光秀控制", item, standby.LaserShow(item))
+			default:
+				zap.S().Infof("不支持的类型: %d\n", item.Type)
+			}
+		}
+	}
+}

internal/routes/standby/audio.go

@@ -0,0 +1,40 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/internal/schema"
+	"game-driver/pkg/audio"
+	"game-driver/pkg/utils"
+	"github.com/gopxl/beep/v2/speaker"
+	"go.uber.org/zap"
+)
+
+func Audio(item schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		data, err := utils.LinkAudio(item.Data)
+		if err != nil {
+			return fmt.Errorf("音频数据获取异常: %w", err)
+		}
+		if data == nil {
+			return fmt.Errorf("音频数据获取为空")
+		}
+
+		zap.S().Infoln("播放待机音乐")
+		defer zap.S().Infoln("结束待机音乐")
+
+		ctrl, closer, e := audio.PlayBgmMP3(data)
+		defer closer()
+		if e != nil {
+			return fmt.Errorf("播放待机音乐异常: %w", e)
+		}
+
+		<-c.Done()
+
+		speaker.Lock()
+		ctrl.Streamer = nil
+		speaker.Unlock()
+
+		return nil
+	}
+}

internal/routes/standby/laser.go

@@ -0,0 +1,35 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/config/game"
+	"game-driver/internal/schema"
+	"game-driver/pkg/oscx"
+	"go.uber.org/zap"
+)
+
+func LaserShow(item schema.WaitItemModel) func(c context.Context) error {
+	cfg := (game.C).(game.LaserConfig)
+
+	return func(c context.Context) error {
+		zap.S().Infoln("开始播放大型激光秀")
+
+		o := oscx.New(cfg.Host, cfg.Port)
+		err := o.EnableLaserOutput()
+		if err != nil {
+			return fmt.Errorf("激光打开异常: %w", err)
+		} else {
+			defer zap.S().Infoln("大型激光秀播放结束:", item.Data)
+			defer o.DisableLaserOutput()
+
+			err = o.StartCue(item.Data)
+			if err != nil {
+				return fmt.Errorf("播放大型激光节目异常: %w", err)
+			}
+		}
+
+		<-c.Done()
+		return nil
+	}
+}

internal/routes/standby/pjlink.go

@@ -0,0 +1,49 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/config/wait"
+	"game-driver/internal/schema"
+	"game-driver/pkg/pjlink"
+	"go.uber.org/zap"
+	"time"
+)
+
+func PJLink(_ schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		cfg := (wait.C).(wait.PJLink)
+		pjc := pjlink.NewClient(cfg.Ip, cfg.Port, cfg.Password, cfg.Id)
+
+		zap.S().Infoln("打开待机投影仪")
+		resp, err := pjc.PowerOnSync()
+		if err != nil {
+			return fmt.Errorf("打开投影仪异常: %w", err)
+		}
+		zap.S().Infoln("打开投影仪结果：", resp)
+
+		run := true
+		for run {
+			select {
+			case <-c.Done():
+				zap.S().Infoln("关闭待机投影仪")
+				resp, err = pjc.PowerOffSync()
+				if err != nil {
+					return fmt.Errorf("关闭投影仪异常: %w", err)
+				}
+				zap.S().Infoln("关闭投影仪结果：", resp)
+				run = false
+				break
+			case <-time.After(time.Minute * 30):
+				zap.S().Infoln("轮询待机投影仪")
+				resp, err = pjc.PowerOnSync()
+				if err != nil {
+					return fmt.Errorf("轮询投影仪异常: %w", err)
+				}
+				zap.S().Infoln("轮询投影仪结果：", resp)
+			}
+		}
+
+		return nil
+	}
+}

internal/routes/standby/relay.go

@@ -0,0 +1,28 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/internal/schema"
+	"game-driver/pkg/relay"
+	"go.uber.org/zap"
+)
+
+func Relay(item schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		r, err := relay.New(item.Data)
+		if err != nil {
+			return fmt.Errorf("继电器初始化异常: %w", err)
+		}
+		defer r.Close()
+
+		zap.S().Infoln("待机继电器供电")
+		defer zap.S().Infoln("待机继电器断电")
+
+		_ = r.On(0)
+		<-c.Done()
+		_ = r.Off(0)
+
+		return nil
+	}
+}

internal/routes/standby/tts.go

@@ -0,0 +1,26 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/internal/schema"
+	"game-driver/pkg/audio"
+	"game-driver/pkg/tts"
+	"go.uber.org/zap"
+)
+
+func TTS(item schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		reader, err := tts.DefaultTTS.Get(item.Data)
+		if err != nil {
+			return fmt.Errorf("语音合成异常: %w", err)
+		}
+
+		zap.S().Infoln("播放待机 TTS 语音")
+		defer zap.S().Infoln("结束待机 TTS 语音")
+
+		audio.PlayWav(c, reader)
+
+		return nil
+	}
+}

internal/routes/standby/video.go

@@ -0,0 +1,31 @@
+package standby
+
+import (
+	"context"
+	"fmt"
+	"game-driver/internal/schema"
+	"game-driver/pkg/utils"
+	"game-driver/pkg/video"
+	"go.uber.org/zap"
+)
+
+func Video(item schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		path, local, err := utils.LinkVideo(item.Data)
+		if err != nil {
+			return fmt.Errorf("视频文件获取异常: %w", err)
+		}
+
+		zap.S().Infoln("播放待机视频")
+		defer zap.S().Infoln("结束待机视频")
+
+		utils.BlankOpen()
+		defer utils.BlankClose()
+
+		err = video.Play(c, path, local)
+		if err != nil {
+			return fmt.Errorf("视频播放异常: %w", err)
+		}
+		return nil
+	}
+}

internal/routes/standby/web.go

@@ -0,0 +1,22 @@
+package standby
+
+import (
+	"context"
+	"game-driver/internal/schema"
+	"game-driver/pkg/browser"
+	"game-driver/pkg/utils"
+	"go.uber.org/zap"
+)
+
+func Web(item schema.WaitItemModel) func(c context.Context) error {
+	return func(c context.Context) error {
+		zap.S().Infoln("打开待机网页")
+
+		// 控制背光
+		utils.BlankOpen()
+		defer utils.BlankClose()
+
+		browser.OpenApp(c, item.Data)
+		return nil
+	}
+}

internal/routes/standby_ctrl/cron.go

@@ -0,0 +1,94 @@
+package standby_ctrl
+
+import (
+	"context"
+	"github.com/go-pkgz/cronrange"
+	"go.uber.org/zap"
+	"sync"
+	"time"
+)
+
+// Cron 时间控制器
+func Cron(rootRules []cronrange.Rule, cron string, play func(c context.Context) error) func(c context.Context) error {
+	// 设定默认时间规则
+	if cron == "" {
+		cron = "* * * *"
+	}
+
+	rules, err := cronrange.Parse(cron)
+	if err != nil {
+		zap.S().Errorln("解析时间规则异常: ", err)
+		return nil
+	}
+
+	return func(c context.Context) error {
+		a := make(chan bool)
+		defer close(a)
+
+		zap.S().Infoln("待机时间控制器")
+		defer zap.S().Infoln("待机时间控制器结束")
+
+		// 等待组
+		var waitGroup sync.WaitGroup
+		defer waitGroup.Wait()
+
+		ticker := time.NewTicker(time.Second)
+		defer ticker.Stop()
+
+		waitGroup.Add(1)
+		go func() {
+			defer waitGroup.Done()
+			for {
+				select {
+				case <-c.Done():
+					return
+				case <-ticker.C:
+					if cronrange.Match(rules, time.Now()) && cronrange.Match(rootRules, time.Now()) {
+						a <- true
+					} else {
+						a <- false
+					}
+				}
+			}
+		}()
+
+		var cancel context.CancelFunc
+		var m sync.Mutex
+		for {
+			select {
+			case <-c.Done():
+				if cancel != nil {
+					cancel()
+					cancel = nil
+				}
+				return nil
+			case r := <-a:
+				if r {
+					if ok := m.TryLock(); ok {
+						ctx, cc := context.WithCancel(context.TODO())
+						cancel = cc
+						waitGroup.Add(1)
+						go func() {
+							defer waitGroup.Done()
+							defer m.Unlock()
+							defer func() { cancel = nil }()
+
+							err := play(ctx)
+							if err != nil {
+								zap.S().Errorln("执行动作异常: ", err)
+								select {
+								case <-ctx.Done():
+									return
+								case <-time.After(time.Minute):
+								}
+							}
+						}()
+					}
+				} else if cancel != nil {
+					cancel()
+					cancel = nil
+				}
+			}
+		}
+	}
+}

internal/routes/standby_ctrl/device.go

@@ -0,0 +1,22 @@
+package standby_ctrl
+
+import (
+	"context"
+	"game-driver/internal/common"
+	"go.uber.org/zap"
+)
+
+// Device 设备锁定控制器
+func Device(d *common.Device, lock bool, play func(c context.Context) error) func(c context.Context) error {
+	return func(c context.Context) error {
+		if lock {
+			zap.S().Infoln("待机任务锁定设备")
+			defer zap.S().Infoln("待机任务解锁设备")
+
+			d.Lock()
+			defer d.Unlock()
+		}
+
+		return play(c)
+	}
+}

internal/routes/standby_ctrl/duration.go

@@ -0,0 +1,23 @@
+package standby_ctrl
+
+import (
+	"context"
+	"go.uber.org/zap"
+	"time"
+)
+
+// Duration 持续时长控制器
+func Duration(duration int64, play func(c context.Context) error) func(c context.Context) error {
+	return func(c context.Context) error {
+		zap.S().Infoln("待机持续时长控制器: ", duration)
+		defer zap.S().Infoln("待机持续时长控制器结束: ", duration)
+
+		if duration > 0 {
+			ctx, cancel := context.WithTimeout(c, time.Duration(duration)*time.Second)
+			defer cancel()
+			c = ctx
+		}
+
+		return play(c)
+	}
+}

internal/routes/standby_ctrl/interval.go

@@ -0,0 +1,35 @@
+package standby_ctrl
+
+import (
+	"context"
+	"go.uber.org/zap"
+	"time"
+)
+
+// Interval 循环间隔控制器
+func Interval(interval int64, play func(c context.Context) error) func(c context.Context) error {
+	return func(c context.Context) error {
+		zap.S().Infoln("待机间隔控制器: ", interval)
+		defer zap.S().Infoln("待机间隔控制器结束: ", interval)
+
+		for {
+			err := play(c)
+			if err != nil {
+				zap.S().Errorln("执行后续操作异常: ", err)
+			}
+			if interval > 0 {
+				select {
+				case <-c.Done():
+					return nil
+				case <-time.After(time.Duration(interval) * time.Second):
+				}
+			} else {
+				select {
+				case <-c.Done():
+					return nil
+				default:
+				}
+			}
+		}
+	}
+}

internal/routes/standby_ctrl/pause.go

@@ -0,0 +1,64 @@
+package standby_ctrl
+
+import (
+	"context"
+	"game-driver/internal/common"
+	"go.uber.org/zap"
+	"sync"
+)
+
+// Pause 暂停控制器
+func Pause(ps *common.PauseSub, isPause bool, play func(c context.Context) error) func(c context.Context) error {
+	return func(c context.Context) error {
+		var cancel context.CancelFunc
+		run := true
+
+		if isPause {
+			zap.S().Infoln("待机暂停控制器")
+			defer zap.S().Infoln("待机暂停控制器结束")
+
+			p := ps.GetNew()
+			defer ps.Close(p)
+
+			// 等待组
+			var wait sync.WaitGroup
+			defer wait.Wait()
+
+			wait.Add(1)
+			go func() {
+				defer wait.Done()
+				for {
+					select {
+					case <-c.Done():
+						return
+					case v := <-p:
+						if v == 1 {
+							zap.S().Infoln("待机控制器 Pause 触发")
+							run = false
+							cancel()
+						} else {
+							zap.S().Infoln("待机控制器 Resume 触发")
+							run = true
+						}
+					}
+				}
+			}()
+		}
+
+		for {
+			select {
+			case <-c.Done():
+				return nil
+			default:
+				if run {
+					nc, cc := context.WithCancel(c)
+					cancel = cc
+					err := play(nc)
+					if err != nil {
+						zap.S().Infoln("执行后续操作异常: ", err)
+					}
+				}
+			}
+		}
+	}
+}

internal/schema/play.go

@@ -6,10 +6,11 @@ type TTSTimer struct {
 }
 
 type TTSModal struct {
-	Start string     `json:"start"`
-	End   string     `json:"end"`
-	Stop  string     `json:"stop"`
-	Timer []TTSTimer `json:"timer"`
+	Start   string     `json:"start"`
+	End     string     `json:"end"`
+	Stop    string     `json:"stop"`
+	Timeout string     `json:"timeout"`
+	Timer   []TTSTimer `json:"timer"`
 }
 
 type PrintModal struct {

internal/schema/wait.go

@@ -8,22 +8,22 @@ const (
 	WaitTTS
 	WaitRelay
 	WaitWeb
+	WaitPJLink
+	WaitLaserShow
 )
 
-type TimeModel struct {
-	Start int64 `json:"start"`
-	End   int64 `json:"end"`
-}
-
 type WaitItemModel struct {
-	TimeModel
-	Type     WaitType `json:"type"`
-	Data     string   `json:"data"`
-	Interval int64    `json:"interval"`
+	Cron     string   `json:"cron"`     // 时间规则
+	Type     WaitType `json:"type"`     // 类型
+	Data     string   `json:"data"`     // 执行数据
+	Duration int64    `json:"duration"` // 持续时长
+	Interval int64    `json:"interval"` // 间隔时间
+	Pause    bool     `json:"pause"`    // 是否暂停
+	Lock     bool     `json:"lock"`     // 是否锁定
 }
 
 type WaitModel struct {
 	JsonModel
-	TimeModel
+	Cron  string          `json:"cron"`
 	Items []WaitItemModel `json:"items"`
 }

internal/server.go

@@ -13,14 +13,17 @@ import (
 	"game-driver/pkg/relay"
 	"game-driver/pkg/tts"
 	"game-driver/pkg/utils"
-	"github.com/eclipse/paho.golang/autopaho"
-	"github.com/eclipse/paho.golang/paho"
-	"go.uber.org/zap"
+	"log"
+	"net"
 	"net/url"
 	"os"
 	"os/signal"
 	"syscall"
 	"time"
+
+	"github.com/eclipse/paho.golang/autopaho"
+	"github.com/eclipse/paho.golang/paho"
+	"go.uber.org/zap"
 )
 
 func buildMqtt(c config.MqttConfig, r *leaf.Engine, subTopics ...string) autopaho.ClientConfig {
@@ -38,6 +41,7 @@ func buildMqtt(c config.MqttConfig, r *leaf.Engine, subTopics ...string) autopah
 	mqttConfig := autopaho.ClientConfig{
 		ServerUrls:                    []*url.URL{u},
 		KeepAlive:                     20,
+		ConnectPassword:               []byte(c.Password),
 		CleanStartOnInitialConnection: false,
 		SessionExpiryInterval:         60,
 		OnConnectionUp: func(cm *autopaho.ConnectionManager, _ *paho.Connack) {
@@ -54,7 +58,7 @@ func buildMqtt(c config.MqttConfig, r *leaf.Engine, subTopics ...string) autopah
 			zap.S().Infof("MQTT 连接异常: %s\n", err)
 		},
 		ClientConfig: paho.ClientConfig{
-			ClientID: "TestSubscriber",
+			ClientID: c.ClientID,
 			OnPublishReceived: []func(paho.PublishReceived) (bool, error){
 				func(pr paho.PublishReceived) (bool, error) {
 					r.Route(pr.Packet.Packet())
@@ -76,10 +80,29 @@ func buildMqtt(c config.MqttConfig, r *leaf.Engine, subTopics ...string) autopah
 }
 
 func Run() {
-	logger.InitLogger()
+	cls, err := logger.NewTenCls(fmt.Sprintf("game-driver-%s-%v", config.C.Location, config.C.Point))
+	if err != nil {
+		log.Println("初始化腾讯云日志服务异常: ", err)
+	}
+	cls.Start()
+	defer cls.Close()
+
+	logger.InitProLogger(cls)
+
+	//logger.InitDevLogger()
 	// 应用退出时刷新所有缓冲日志
 	defer logger.Sync()
 
+	// 获取当前IP，并打印当前IP
+	addrs, err := net.InterfaceAddrs()
+	if err != nil {
+		log.Panicln("网络连接异常: ", err)
+	}
+	zap.S().Infoln("当前IP: ", addrs)
+
+	// 启动时关闭屏幕
+	utils.BlankClose()
+
 	topicPrefix := fmt.Sprintf("server/%s/%v/", config.C.Location, config.C.Point)
 	publishTopic := fmt.Sprintf("device/%s/%v/status", config.C.Location, config.C.Point)
 
@@ -88,23 +111,13 @@ func Run() {
 
 	router := leaf.Default(ctx)
 
-	log, _ := zap.NewStdLogAt(zap.L(), zap.DebugLevel)
-	router.SetDebugLogger(log)
+	logAt, _ := zap.NewStdLogAt(zap.L(), zap.DebugLevel)
+	router.SetDebugLogger(logAt)
 
 	router.DefaultHandler(func(c *leaf.Context) {
 		zap.S().Infof("未处理消息，topic: %s\n payload: %s\n", c.Topic, c.Payload)
 	})
 
-	// 构建 MQTT 连接
-	mqttBuild := buildMqtt(config.C.Mqtt, router, topicPrefix+"#")
-
-	// 连接 MQTT
-	cm, err := autopaho.NewConnection(ctx, mqttBuild)
-	if err != nil {
-		zap.S().Panicln("连接 MQTT 异常: ", err)
-	}
-	utils.GlobalMqttClient = cm
-
 	// 构建语音合成对象
 	tts.DefaultTTS = tts.New(ctx, config.C.Aliyun)
 
@@ -113,7 +126,7 @@ func Run() {
 	if config.C.Relay != "" {
 		r, err = relay.New(config.C.Relay)
 		if err != nil {
-			zap.S().Panicln("继电器连接异常: ", err)
+			zap.S().Errorln("继电器连接异常: ", err)
 		}
 		defer r.Close()
 	}
@@ -128,6 +141,7 @@ func Run() {
 		middleware.RunLog(),
 		middleware.PayloadJSON[schema.PlayModal](),
 		middleware.DeviceLock(device),
+		middleware.PauseWait(common.PassCtrl),
 		middleware.EmergencyStop(common.GlobalStopper),
 		middleware.SoundStart(),
 		middleware.RelayMaster(r),
@@ -140,9 +154,10 @@ func Run() {
 	router.RegisterHandler(topicPrefix+"wait",
 		middleware.RunLog(),
 		middleware.PayloadJSON[schema.WaitModel](),
+		middleware.Cache(config.C.StandbyCache),
 		middleware.Unique(common.GlobalBgStopper),
 		middleware.EmergencyStop(common.GlobalBgStopper),
-		routes.WaitAction,
+		routes.StandbyAction(common.PassCtrl, device),
 	)
 	// 处理指令
 	router.RegisterHandler(topicPrefix+"command",
@@ -150,10 +165,26 @@ func Run() {
 		routes.Command(device),
 	)
 
+	// 从缓存中读取待机报文，如果存在则直接执行
+	publish, err := config.C.StandbyCache.Get()
+	if err != nil {
+		zap.S().Infoln("读取待机缓存失败: ", err)
+	} else {
+		router.HandlerRun(topicPrefix+"wait", publish)
+	}
+
+	// 构建 MQTT 连接
+	mqttBuild := buildMqtt(config.C.Mqtt, router, topicPrefix+"#")
+
+	// 开始连接 MQTT
+	cm, err := autopaho.NewConnection(ctx, mqttBuild)
+	if err != nil {
+		zap.S().Panicln("创建 MQTT 连接器异常: ", err)
+	}
+	utils.GlobalMqttClient = cm
+
 	// 启动完成发送一次设备状态
 	device.PublishStatus()
-	// 启动完成关闭屏幕
-	utils.BlankClose()
 
 	sig := make(chan os.Signal, 1)
 	signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
@@ -166,6 +197,9 @@ func Run() {
 	if e := cm.Disconnect(ctx); e != nil {
 		zap.S().Errorln("断开连接异常", e)
 	}
+	if e := router.Disconnect(ctx); e != nil {
+		zap.S().Errorln("停止所以任务超时", e)
+	}
 
 	zap.S().Infoln("关闭完成")
 }