Checkpoint

This commit is contained in:
maze authored and maze committed 2026-10-29 17:29:41 +01:00
1 parent 0295eb1ad2
commit b8a493b93d
138 files changed
+1898 -57607

No files matched your search

-46
View File
@@ -1,46 +0,0 @@
package main
import (
"log"
"sync"
"git.maze.io/go/bragi/hardware/display/sdl"
"git.maze.io/go/bragi/hardware/input"
)
func main() {
d, err := sdl.New()
if err != nil {
log.Fatalln(err)
}
inputs, err := input.Detect()
if err != nil {
log.Fatalln("failed to detect input sources:", err)
}
log.Printf("detected %d input sources:", len(inputs))
for _, input := range inputs {
log.Println("input:", input.Name())
}
var wait sync.WaitGroup
for _, s := range inputs {
wait.Add(1)
go func(s input.Source, wait *sync.WaitGroup) {
defer wait.Done()
events, err := s.Events()
if err != nil {
log.Println("failed to get events from source:", s.Name(), err)
return
}
for e := range events {
log.Println("event:", e)
}
}(s, &wait)
}
log.Fatalln(d.Run())
wait.Wait()
}
-74
View File
@@ -1,74 +0,0 @@
package main
import (
"flag"
"image/color"
"sync"
"git.maze.io/go/bragi/hardware/display/gc9a01"
"periph.io/x/conn/v3/gpio/gpioreg"
"periph.io/x/conn/v3/spi/spireg"
"periph.io/x/host/v3"
)
func main() {
var (
config gc9a01.Config
reset string
dc string
cs string
bl string
)
flag.StringVar(&config.Port, "spi-bus", "", "SPI bus (empty for default)")
flag.StringVar(&reset, "gpio-reset", "GPIO6", "reset pin")
flag.StringVar(&dc, "gpio-dc", "GPIO7", "data/command pin")
flag.StringVar(&cs, "gpio-cs", "GPIO8", "chip select pin")
flag.StringVar(&bl, "gpio-bl", "GPIO9", "backlight pin")
flag.IntVar(&config.Width, "width", 240, "display width")
flag.IntVar(&config.Height, "height", 240, "display height")
flag.IntVar(&config.VSyncLines, "vsync", 2, "number of VSync lines")
flag.IntVar(&config.RowOffset, "row-offset", 0, "row offset")
flag.IntVar(&config.ColumnOffset, "column-offset", 0, "column offset")
flag.Parse()
config.Reset = gpioreg.ByName(reset)
config.DC = gpioreg.ByName(dc)
config.CS = gpioreg.ByName(cs)
config.BL = gpioreg.ByName(bl)
_, err := host.Init()
if err != nil {
panic(err)
}
p, err := spireg.Open(config.Port)
if err != nil {
panic(err)
}
defer p.Close()
d, err := gc9a01.New(p, config)
if err != nil {
panic(err)
}
bounds := d.Bounds()
width, height := bounds.Dx(), bounds.Dy()
white := color.RGBA{255, 255, 255, 255}
red := color.RGBA{255, 0, 0, 255}
blue := color.RGBA{0, 0, 255, 255}
green := color.RGBA{0, 255, 0, 255}
black := color.RGBA{0, 0, 0, 255}
d.FillRectangle(0, 0, width, height, black)
d.FillRectangle(0, 0, width/2, height/2, white)
d.FillRectangle(width/2, 0, width/2, height/2, red)
d.FillRectangle(0, height/2, width/2, height/2, green)
d.FillRectangle(width/2, height/2, width/2, height/2, blue)
d.FillRectangle(width/4, height/4, width/2, height/2, black)
var wait sync.WaitGroup
wait.Add(1)
wait.Wait()
}
-44
View File
@@ -1,44 +0,0 @@
package main
import (
"fmt"
"sync"
"git.maze.io/go/bragi/hardware/input"
"github.com/sirupsen/logrus"
)
func main() {
logrus.SetLevel(logrus.TraceLevel)
sources, err := input.Detect()
if err != nil {
panic(err)
}
var wait sync.WaitGroup
for _, s := range sources {
wait.Add(1)
go test(s, &wait)
}
wait.Wait()
}
func test(s input.Source, wait *sync.WaitGroup) {
defer wait.Done()
events, err := s.Events()
if err != nil {
panic(err)
}
for e := range events {
fmt.Println(e)
switch e.Type {
case input.RotaryClockwise:
println("clockwise")
case input.RotaryCounterClockwise:
println("counter clockwise")
}
}
}
-1
View File
@@ -1 +0,0 @@
package main
-36
View File
@@ -1,36 +0,0 @@
package main
import (
"github.com/sirupsen/logrus"
bragi "git.maze.io/go/bragi"
)
func main() {
logrus.SetLevel(logrus.DebugLevel)
s := bragi.NewMPD("volumio.local:6600")
log := logrus.WithField("source", s.Name())
log.Info("created source")
for e := range s.Events() {
switch e := e.(type) {
case *bragi.ConnectedEvent:
log.Info("connected")
case *bragi.DisconnectedEvent:
log.Info("disconnected")
case *bragi.StatusEvent:
t := e.Status.Track
if t != nil {
logrus.
WithField("track", t).
WithField("file", t.Path).
Info("received track")
}
default:
log.WithField("event", e).Info("received event")
}
}
}
+36
View File
@@ -0,0 +1,36 @@
package main
import (
"os"
"path/filepath"
"github.com/kyoh86/xdg"
"github.com/sirupsen/logrus"
)
const (
configFileBase = "harmon.conf"
configFileBaseAlt = "harmon.cfg"
)
func findConfigFile() string {
var name string
for _, dir := range append(xdg.AllConfigDirs(), ".") {
// Base
name = filepath.Join(dir, configFileBase)
logrus.WithField("name", name).Trace("auto detecting configuration file")
if i, err := os.Stat(name); err == nil && !i.IsDir() {
logrus.WithField("name", name).Trace("found configuration file")
return name
}
// Alt
name = filepath.Join(dir, configFileBaseAlt)
logrus.WithField("name", name).Trace("auto detecting configuration file")
if i, err := os.Stat(name); err == nil && !i.IsDir() {
logrus.WithField("name", name).Trace("found configuration file")
return name
}
}
return ""
}
+36 -148
View File
@@ -1,179 +1,67 @@
package main
import (
"errors"
"fmt"
"io"
"context"
"flag"
"os"
"os/signal"
"path/filepath"
"strings"
"runtime"
"github.com/adrg/xdg"
"github.com/sirupsen/logrus"
"github.com/spf13/cobra"
"github.com/spf13/viper"
"periph.io/x/host/v3"
"git.maze.io/go/harmon/config"
"git.maze.io/go/harmon/display"
_ "git.maze.io/go/harmon/display/all" // Load all display drivers
)
"go.maze.io/harmon"
"go.maze.io/harmon/config"
var (
configurationPath = append(makeConfigurationPath(), ".")
configurationFile string
configuration *config.Structure
logFile string
logDebug bool
logTrace bool
_ "go.maze.io/harmon/hardware/display/all" // Display drivers
_ "go.maze.io/harmon/player/all" // Player drivers
)
func main() {
var entrypoint = &cobra.Command{
Use: "harmon",
Short: "Harmon is a music player frontend for graphic displays",
Args: entrypointArgs,
Run: entrypoint,
}
configFlag := flag.String("config", "", "configuration file path (default: auto detect)")
debugFlag := flag.Bool("debug", false, "enable debug log messages")
traceFlag := flag.Bool("trace", false, "enable trace log messages (very noisy!)")
flag.Parse()
flag := entrypoint.PersistentFlags()
flag.StringVarP(&configurationFile, "config", "c", "", "configuration file (default is look in "+strings.Join(configurationPath, ",")+")")
flag.BoolVarP(&logDebug, "debug", "D", false, "enable debug log messages")
flag.BoolVarP(&logTrace, "trace", "T", false, "enable trace log messages")
flag.StringVarP(&logFile, "log", "l", "", "log file (default: use standard output)")
entrypoint.MarkFlagRequired("config")
if err := entrypoint.Execute(); err != nil {
fatal(err)
}
}
func fatal(err error) {
fmt.Fprintf(os.Stderr, "Fatal error: %v\n", err)
os.Exit(1)
}
func setup() {
viper.SetConfigFile("harmon.conf")
viper.AddConfigPath(".")
viper.SetConfigName(".harmon")
viper.SetDefault("license", "MIT")
}
func makeConfigurationPath() []string {
dirs := make([]string, len(xdg.ConfigDirs))
for i, dir := range xdg.ConfigDirs {
dirs[i] = filepath.Join(dir, "harmon")
}
return dirs
}
func entrypointArgs(cmd *cobra.Command, args []string) (err error) {
// Setup logger
if logFile != "" {
logrus.WithField("path", logFile).Info("logging to file")
var w io.Writer
if w, err = os.OpenFile(logFile, os.O_RDWR|os.O_APPEND|os.O_CREATE, 0640); err != nil {
return
}
logrus.SetOutput(w)
}
if logTrace {
if *traceFlag {
logrus.SetLevel(logrus.TraceLevel)
} else if logDebug {
} else if *debugFlag {
logrus.SetLevel(logrus.DebugLevel)
}
// Load configuration
if configurationFile == "" {
for _, dir := range configurationPath {
if dir, err = filepath.Abs(dir); err != nil {
return
}
logrus.WithField("path", dir).Trace("looking for harmon.conf")
if i, ferr := os.Stat(filepath.Join(dir, "harmon.conf")); ferr == nil && !i.IsDir() {
if configurationFile, err = filepath.Abs(i.Name()); err != nil {
return
}
logrus.WithField("path", configurationFile).Trace("using for harmon.conf")
break
}
logrus.WithFields(logrus.Fields{
"version": harmon.Version,
"host_os": runtime.GOOS,
"host_arch": runtime.GOARCH,
}).Info("Harmon starting")
if *configFlag == "" {
if *configFlag = findConfigFile(); *configFlag == "" {
logrus.Fatal("could not auto detect configuration file; supply one with -config")
}
}
if configuration, err = config.Load(configurationFile); err != nil {
if config.ExplainError(configurationFile, err) {
return errors.New("configuration failed")
}
return err
config, err := config.Load(*configFlag)
if err != nil {
logrus.WithError(err).Fatal("configuration file contains errors")
}
return
}
func entrypoint(cmd *cobra.Command, args []string) {
if len(configuration.Display) == 0 {
logrus.Fatal("no displays configured")
}
var (
displays = make(map[string]display.Display)
err error
)
teardown := func() {
for _, d := range displays {
logrus.WithField("display", d.String()).Debug("halting...")
if d != nil {
_ = d.Halt()
}
}
}
defer teardown()
// Configure host
if _, err = host.Init(); err != nil {
controller, err := harmon.NewController(config)
if err != nil {
logrus.WithError(err).Fatal("host setup failed")
}
// Configure displays
for _, config := range configuration.Display {
var (
log = logrus.WithFields(logrus.Fields{
"name": config.Name,
"type": config.Type,
})
output display.Display
)
log.Info("setting up display")
if output, err = display.New(config); err != nil {
log.WithError(err).Fatal("display setup failed")
}
if err = display.DrawImageFile(output, "harmon-color.png"); err != nil {
logrus.
WithField("display", config.Name).
WithError(err).
Fatal("display splash failed")
}
if err = output.Refresh(); err != nil {
logrus.
WithField("display", config.Name).
WithError(err).
Fatal("display refresh failed")
}
displays[config.Name] = output
}
ctx, cancel := context.WithCancel(context.Background())
signals := make(chan os.Signal)
signal.Notify(signals, os.Interrupt)
signal.Notify(signals, os.Kill)
go func(signals <-chan os.Signal, cancel func()) {
defer cancel()
signal := <-signals
logrus.WithField("signal", signal).Warn("terminating by signal")
}(signals, cancel)
fmt.Println("idling...")
for {
s := <-signals
logrus.WithField("signal", s.String()).Info("terminating")
return
if err = controller.Run(ctx); err != nil && err != context.Canceled {
logrus.WithError(err).Fatal("terminating by fatal error")
}
}
-50
View File
@@ -1,50 +0,0 @@
// Copyright 2018 The Periph Authors. All rights reserved.
// Use of this source code is governed under the Apache License, Version 2.0
// that can be found in the LICENSE file.
package main
import (
"image"
"log"
"golang.org/x/image/font"
"golang.org/x/image/font/basicfont"
"golang.org/x/image/math/fixed"
"periph.io/x/conn/v3/i2c/i2creg"
"periph.io/x/devices/v3/ssd1306"
"periph.io/x/devices/v3/ssd1306/image1bit"
"periph.io/x/host/v3"
)
func main() {
// Make sure periph is initialized.
if _, err := host.Init(); err != nil {
log.Fatal(err)
}
// Use i2creg I²C bus registry to find the first available I²C bus.
b, err := i2creg.Open("")
if err != nil {
log.Fatal(err)
}
defer b.Close()
dev, err := ssd1306.NewI2C(b, &ssd1306.DefaultOpts)
if err != nil {
log.Fatalf("failed to initialize ssd1306: %v", err)
}
img := image1bit.NewVerticalLSB(dev.Bounds())
f := basicfont.Face7x13
drawer := font.Drawer{
Dst: img,
Src: &image.Uniform{image1bit.On},
Face: f,
Dot: fixed.P(0, img.Bounds().Dy()-1-f.Descent),
}
drawer.DrawString("Hello from periph!")
if err := dev.Draw(dev.Bounds(), img, image.Point{}); err != nil {
log.Fatal(err)
}
}
-57
View File
@@ -1,57 +0,0 @@
// Copyright 2018 The Periph Authors. All rights reserved.
// Use of this source code is governed under the Apache License, Version 2.0
// that can be found in the LICENSE file.
package main
import (
"image"
"log"
"git.maze.io/go/harmon/display/ssd1326"
"golang.org/x/image/font"
"golang.org/x/image/font/basicfont"
"golang.org/x/image/math/fixed"
"periph.io/x/conn/v3/i2c/i2creg"
"periph.io/x/devices/v3/ssd1306/image1bit"
"periph.io/x/host/v3"
)
func main() {
// Make sure periph is initialized.
if _, err := host.Init(); err != nil {
log.Fatal(err)
}
// Use i2creg I²C bus registry to find the first available I²C bus.
b, err := i2creg.Open("")
if err != nil {
log.Fatal(err)
}
defer b.Close()
/*
dev, err := ssd1322.NewI2C(b, &ssd1322.DefaultOpts)
if err != nil {
log.Fatalf("failed to initialize ssd1322: %v", err)
}
*/
dev, err := ssd1326.NewI2C(b, 0x3C)
if err != nil {
log.Fatal(err)
}
//img := image1bit.NewVerticalLSB(dev.Bounds())
f := basicfont.Face7x13
drawer := font.Drawer{
Dst: dev,
Src: &image.Uniform{image1bit.On},
Face: f,
Dot: fixed.P(0, dev.Bounds().Dy()-1-f.Descent),
}
drawer.DrawString("Hello from periph!")
if err := dev.Refresh(); err != nil {
log.Fatal(err)
}
}
-90
View File
@@ -1,90 +0,0 @@
package main
import (
"encoding/binary"
"flag"
"fmt"
"image"
"image/color"
"os"
"git.maze.io/go/bragi/audio"
"git.maze.io/go/bragi/display"
"git.maze.io/go/bragi/hardware/display/console"
audioinput "git.maze.io/go/bragi/hardware/input/audio"
"git.maze.io/go/bragi/internal/pixel"
"periph.io/x/conn/v3/physic"
)
func main() {
fifoFlag := flag.String("fifo", "", "PCM16 audio FIFO stream")
tcpFlag := flag.String("tcp", "locaclhost:6601", "PCM16 audio stream")
beFlag := flag.Bool("be", false, "PCM16 data is big endian (default: use little endian)")
channelsFlag := flag.Int("channels", 2, "audio channels")
sampleRateFlag := flag.Int("samplerate", 44100, "audio sample rate")
flag.Parse()
var (
byteOrder binary.ByteOrder = binary.LittleEndian
sampleRate = physic.Frequency(*sampleRateFlag) * physic.Hertz
d display.Image
s audioinput.Reader
err error
)
if *beFlag {
byteOrder = binary.BigEndian
}
if *fifoFlag != "" {
s, err = audioinput.OpenPCM16(*fifoFlag, byteOrder, *channelsFlag, sampleRate)
} else {
s, err = audioinput.OpenPCM16TCP(*tcpFlag, byteOrder, *channelsFlag, sampleRate)
}
if err != nil {
fatal(err)
}
defer s.Halt()
if d, err = console.New(nil); err != nil {
fatal(err)
}
defer d.Halt()
var (
rate = 10
//img = image.NewGray(image.Rect(0, 0, 128, 60))
//visual = audioinput.NewPeak(40, *channelsFlag, rate)
visual = audioinput.NewVUMeter(40, 1, *channelsFlag)
samples = make(audio.Int16, (*sampleRateFlag**channelsFlag)/rate)
)
for {
if _, err = s.ReadSamples(samples); err != nil {
fatal(err)
}
visual.Process(samples)
visual.Render(d, image.Point{}, color.White)
if err = d.Refresh(); err != nil {
fatal(err)
}
//displayText(img)
}
}
func fatal(err error) {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
func displayText(img image.Image) {
fmt.Print("\x1b[2J") // clear screen
size := img.Bounds().Size()
for y := 0; y < size.Y; y++ {
for x := 0; x < size.X; x++ {
if pixel.IsOn(img.At(x, y)) {
fmt.Print("#")
} else {
fmt.Print(" ")
}
}
fmt.Print("\n")
}
}
-46
View File
@@ -1,46 +0,0 @@
package main
import (
"flag"
"fmt"
"log"
"os"
"git.maze.io/go/harmon/config"
)
func main() {
configFlag := flag.String("config", "bragi.toml", "config file")
flag.Parse()
// Load the configuration file.
cfg, err := config.Load(*configFlag)
if err != nil {
if config.ExplainError(*configFlag, err) {
os.Exit(1)
}
log.Fatalln("failed to load configuration:", err)
}
fmt.Printf("configured player:\n")
fmt.Printf(" %s@%s\n", cfg.Player.Type, cfg.Player.Host)
fmt.Printf("configured %d display(s):\n", len(cfg.Display))
for _, display := range cfg.Display {
fmt.Printf(" %s:\n", display.Name)
fmt.Printf(" %s %dx%d\n", display.Type, display.Size[0], display.Size[1])
}
fmt.Printf("configured %d input(s):\n", len(cfg.Input))
/*
if cfg.Input != nil {
fmt.Printf("configured inputs:\n")
if cfg.Input.Rotary != nil {
fmt.Printf(" rotary encoders:\n")
for name, _ := range cfg.Input.Rotary {
fmt.Printf(" - %s\n", name)
}
}
}
*/
}
-76
View File
@@ -1,76 +0,0 @@
package main
import (
"flag"
"fmt"
"os"
"sync"
"github.com/sirupsen/logrus"
"git.maze.io/go/harmon/config"
"git.maze.io/go/harmon/display"
_ "git.maze.io/go/harmon/display/all" // Load all drivers
)
func main() {
var cfg config.Display
cfg.Bus = new(string)
flag.StringVar(&cfg.Name, "name", "", "name")
flag.StringVar(&cfg.Type, "type", "test", "driver type, use 'help' to get a list of available drivers")
flag.StringVar(cfg.Bus, "bus", "", "bus is the I²C or SPI bus")
flag.StringVar(&cfg.Host, "host", "", "driver host address")
flag.StringVar(&cfg.Port, "port", "", "driver port number or name")
debugFlag := flag.Bool("debug", false, "enable debug messages")
traceFlag := flag.Bool("trace", false, "enable trace messages")
flag.Parse()
if *traceFlag {
logrus.SetLevel(logrus.TraceLevel)
} else if *debugFlag {
logrus.SetLevel(logrus.DebugLevel)
}
if cfg.Type == "" || cfg.Type == "help" || cfg.Type == "list" {
fmt.Println("available drivers:")
for _, driver := range display.List() {
fmt.Println(" -", driver)
}
os.Exit(0)
}
d, err := display.New(&cfg)
if err != nil {
fatal(err)
}
defer func() {
_ = d.Halt()
}()
if err = testDisplay(d); err != nil {
fatal(err)
}
var wait sync.WaitGroup
wait.Add(1)
wait.Wait()
}
func fatal(err error) {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
/*
func testTextDisplay(d display.Text) (err error) {
d.Text(0, 0, "hello, world! this is Braghi")
for y := 1; y < d.Rows(); y++ {
d.Text(0, y, fmt.Sprintf("extra row %d", y))
}
return
}
*/
func testDisplay(d display.Display) (err error) {
return
}
-37
View File
@@ -1,37 +0,0 @@
package main
import (
"flag"
"log"
"git.maze.io/go/bragi/player/mpd"
"github.com/sirupsen/logrus"
)
func main() {
addrFlag := flag.String("addr", mpd.DefaultAddr, "mpd server address")
passwordFlag := flag.String("password", "", "mpd password")
debugFlag := flag.Bool("debug", false, "enable debug logging")
traceFlag := flag.Bool("trace", false, "enable trace logging")
flag.Parse()
if *traceFlag {
logrus.SetLevel(logrus.TraceLevel)
} else if *debugFlag {
logrus.SetLevel(logrus.DebugLevel)
}
c, err := mpd.New(*addrFlag, *passwordFlag, "test")
if err != nil {
log.Fatalln(err)
}
//log.Fatalln(c.Close())
events, err := c.Events()
if err != nil {
log.Fatalln(err)
}
for event := range events {
log.Println(event)
}
}