示例#1
0
// do_blink listens on the provided channel for specified color and blinks it at an
// interval.
func do_blink(color <-chan byte) {
	var c byte
	var intensity byte

	tick := time.NewTicker(BLINK_INTERVAL)

LOOP:
	for {
		select {
		case c_new, ok := <-color:
			if !ok {
				break LOOP
			}
			piglow.Ring(c, 0)
			c = c_new
		case <-tick.C:
			if intensity == 0 {
				intensity = INTENSITY_MAX
			} else {
				intensity = 0
			}
			piglow.Ring(c, intensity)
		}
	}
	err := piglow.ShutDown()
	if err != nil {
		log.Printf("failed to shutdown piglow: %v", err)
	}
}
示例#2
0
func main() {
	if ok := piglow.HasPiGlow(); !ok {
		log.Fatalf("piglow not available")
	}

	colors := make(chan byte)
	go do_blink(colors)

	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

	interval := time.NewTicker(Refresh)
MAINLOOP:
	for {
		select {
		case <-interval.C:
			colors <- piglow.Orange

			current, err := get_juju_status()
			if err != nil {
				log.Printf("error: %v", err)
				continue
			}

			color := piglow.Green
			if len(current.Status[WatchedBranch]) != 0 {
				color = piglow.Red
			}
			colors <- color
		case <-sigChan:
			break MAINLOOP
		}
	}

	log.Printf("got sig kill - shutting down")
	err := piglow.ShutDown()
	if err != nil {
		log.Printf("failed to shutdown piglow: %v", err)
		os.Exit(1)
	}
	os.Exit(0)

}
示例#3
0
文件: main.go 项目: kyrofa/piglowtop
// main is the entry point of this program. It accepts two command-line
// parameters:
//
// - brightness: Percentage of max LED brightness (between 0 and 1.0).
// - period: CPU poll period (in milliseconds).
func main() {
	signals := make(chan os.Signal, 1)
	signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM)

	pollPeriodParameter := flag.Int("period", 200,
		"CPU poll period (in milliseconds)")
	brightnessParameter := flag.Float64("brightness", 0.02,
		"LED brightness (% of max brightness)")
	flag.Parse()

	if *brightnessParameter < 0 || *brightnessParameter > 1.0 {
		log.Fatalf("Brightness must be a value between 0 and 1.0 (got %v)",
			*brightnessParameter)
	}

	// Make sure we have a PiGlow to use. If we don't, provide a helpful error
	// message and exit, but wait several seconds before doing so in case systemd
	// respawns us. We don't want to hit its start limit.
	if !piglow.HasPiGlow() {
		log.Println("Unable to access PiGlow. Perhaps you need to hw-assign it?")
		time.Sleep(6 * time.Second)
		os.Exit(1)
	}

	// Initialize the CPU info so we can start out with a history
	previousStat := cpuStats()

	ticker := time.NewTicker(time.Duration(*pollPeriodParameter) *
		time.Millisecond)

	// Run this loop in a go routine so we can stop on demand.
	go func() {
		for _ = range ticker.C {
			currentStat := cpuStats()

			// Calculate previous idle and total ticks
			previousIdle := previousStat.Idle + previousStat.IOWait
			previousTotal := previousStat.User + previousStat.Nice +
				previousStat.System + previousStat.Idle +
				previousStat.IOWait + previousStat.IRQ +
				previousStat.SoftIRQ

			// Calculate current idle and total ticks
			currentIdle := currentStat.Idle + currentStat.IOWait
			currentTotal := currentStat.User + currentStat.Nice +
				currentStat.System + currentStat.Idle +
				currentStat.IOWait + currentStat.IRQ +
				currentStat.SoftIRQ

			// Calculating idle here since it's less typing. We'll invert it later.
			percentIdle := float64(currentIdle-previousIdle) /
				float64(currentTotal-previousTotal)

			displayUtilization(1.0-percentIdle, *brightnessParameter)

			previousStat = currentStat
		}
	}()

	<-signals         // Wait for request to stop
	ticker.Stop()     // We've been asked to stop
	piglow.ShutDown() // Turn off all LEDs
}