Golang中gobot的ButtonPush事件循环无法停止

在我将循环包装在go协程中并返回后，它起作用了！

然而，我觉得这可能不是处理这个问题的最佳方式。我想每次"ButtonPush"事件触发时，我都会创建一个带有新的无限循环的完全独立的go协程？

我可以使用哪种go结构来使用包含while循环的单一go协程，但更新while循环的条件？

在你的代码中，ButtonPush 事件处理函数内部的 for 循环阻塞了Gobot的事件循环，导致后续的按钮事件无法被处理。这是因为Gobot使用单个goroutine来处理所有设备事件，当你在事件处理函数中执行长时间运行的循环时，会阻止其他事件的执行。

以下是修复后的代码：

package main

import (
	"fmt"
	"sync"
	"time"

	"gobot.io/x/gobot"
	"gobot.io/x/gobot/drivers/gpio"
	"gobot.io/x/gobot/platforms/raspi"
)

var (
	r         = raspi.NewAdaptor()
	button    = gpio.NewButtonDriver(r, "33")
	redLed    = gpio.NewLedDriver(r, "18")
	blueLed   = gpio.NewLedDriver(r, "16")
	greenLed  = gpio.NewLedDriver(r, "22")
	yellowLed = gpio.NewLedDriver(r, "32")
	leds      = [4]*gpio.LedDriver{redLed, blueLed, greenLed, yellowLed}
)

type LedController struct {
	isActive    bool
	mu          sync.Mutex
	stopChan    chan struct{}
	currentMode int
}

func NewLedController() *LedController {
	return &LedController{
		stopChan: make(chan struct{}),
	}
}

func (lc *LedController) SetActive(active bool) {
	lc.mu.Lock()
	defer lc.mu.Unlock()
	
	if lc.isActive == active {
		return
	}
	
	lc.isActive = active
	
	if active {
		lc.stopChan = make(chan struct{})
		go lc.runLedSequence()
	} else {
		close(lc.stopChan)
	}
}

func (lc *LedController) runLedSequence() {
	for {
		select {
		case <-lc.stopChan:
			return
		default:
			lc.mu.Lock()
			mode := lc.currentMode
			lc.mu.Unlock()
			
			if mode == 0 {
				for _, led := range leds {
					select {
					case <-lc.stopChan:
						return
					default:
						led.On()
						time.Sleep(250 * time.Millisecond)
						led.Off()
					}
				}
			} else {
				for i := len(leds) - 1; i >= 0; i-- {
					select {
					case <-lc.stopChan:
						return
					default:
						led := leds[i]
						led.On()
						time.Sleep(250 * time.Millisecond)
						led.Off()
					}
				}
			}
		}
	}
}

func (lc *LedController) ToggleMode() {
	lc.mu.Lock()
	defer lc.mu.Unlock()
	
	lc.currentMode = 1 - lc.currentMode
	fmt.Println("Mode changed to:", lc.currentMode)
}

func main() {
	button.DefaultState = 1

	ledController := NewLedController()
	
	work := func() {
		button.On(gpio.ButtonPush, func(data interface{}) {
			fmt.Println("Button pressed")
			
			ledController.mu.Lock()
			currentActive := ledController.isActive
			ledController.mu.Unlock()
			
			if currentActive {
				ledController.SetActive(false)
			} else {
				ledController.ToggleMode()
				ledController.SetActive(true)
			}
		})

		button.On(gpio.ButtonRelease, func(data interface{}) {
			fmt.Println("Button released")
		})
	}

	robot := gobot.NewRobot("buttonBot",
		[]gobot.Connection{r},
		[]gobot.Device{button, redLed, blueLed, greenLed, yellowLed},
		work)

	robot.Start()
}

这个解决方案的关键点：

1. 使用独立的goroutine：LED序列在单独的goroutine中运行，不会阻塞Gobot的事件循环
2. 通道控制：使用stopChan来控制LED序列的启动和停止
3. 互斥锁保护：使用sync.Mutex来保护共享状态的并发访问
4. 非阻塞检查：在LED循环中使用select语句来检查停止信号，确保能够及时响应停止请求

当按钮按下时：

• 如果LED序列正在运行，则停止它
• 如果LED序列未运行，则切换模式并启动序列

这样按钮事件可以正常处理，LED序列也不会阻塞其他事件的处理。