You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
163 lines
4.0 KiB
163 lines
4.0 KiB
package main |
|
|
|
import ( |
|
"log" |
|
"os" |
|
"path" |
|
"errors" |
|
|
|
"github.com/fsnotify/fsnotify" |
|
"github.com/mkideal/cli" |
|
"github.com/tarm/serial" |
|
) |
|
|
|
func stop(exitCode int) { |
|
log.Println("Have a nice day.") |
|
os.Exit(exitCode) |
|
} |
|
|
|
type message struct { |
|
msgType byte |
|
data []byte |
|
} |
|
|
|
const ( |
|
MSG_TYPE_ANSWER_OK = 0x01 |
|
MSG_TYPE_ANSWER_NOOK = 0x02 |
|
MSG_TYPE_AGENTID = 0x03 |
|
MSG_TYPE_CONFIG = 0x04 |
|
) |
|
|
|
func decodeByteString(bytes []byte, num int) (msg message, err error) { |
|
if bytes[0] == 0x3c && bytes[1] == 0x3e && |
|
bytes[num-1] == 0x0A && bytes[num-2] == 0x0D { |
|
return message{msgType: bytes[2], data: bytes[3:num-2]}, nil |
|
} |
|
|
|
return message{msgType: 0x00, data: make([]byte, 1)}, errors.New("Can't decode the byte array.") |
|
} |
|
|
|
func waitAndExecuteCommandsFromDevice(serial *serial.Port) { |
|
buffer := make([]byte, 40) |
|
for { |
|
num, err := serial.Read(buffer) |
|
|
|
if err != nil { |
|
log.Fatal(err) |
|
} |
|
|
|
input, err := decodeByteString(buffer, num) |
|
if err != nil { |
|
log.Fatal(err) |
|
} else { |
|
switch (input.msgType) { |
|
case MSG_TYPE_AGENTID: |
|
log.Printf("Key pressed: %d", input.data[0]) |
|
default: |
|
log.Fatal("Can't recognize the message type.") |
|
} |
|
} |
|
} |
|
} |
|
|
|
func watchForConfigChanges(configFile string, serial *serial.Port) { |
|
watcher, err := fsnotify.NewWatcher() |
|
if err != nil { |
|
log.Fatal(err) |
|
} |
|
defer watcher.Close() |
|
|
|
done := make(chan bool) |
|
go func() { |
|
for { |
|
select { |
|
case event := <-watcher.Events: |
|
// The file is changed. This is the only event we are interested |
|
// in. If the file is renamed, removed or something else, we drop |
|
// an error to the user. |
|
if event.Op&fsnotify.Write == fsnotify.Write || |
|
event.Op&fsnotify.Remove == fsnotify.Remove { |
|
|
|
if _, err := os.Stat(event.Name); err == nil { |
|
log.Println("Reload the config file ...") |
|
// TODO: Parse the config file |
|
// TODO: Handle errors in the config file |
|
// TODO: Write a mapping for the mapping of the keys to the binary format the avr wants. |
|
// TODO: Establish a connection to the device |
|
// TODO: Transfer the new key mappings |
|
// TODO: Close the connection? |
|
} |
|
} |
|
|
|
// Some editors have a feature called "swap save" (like vim), which |
|
// will trigger a simple WRITE event, instead it wil trigger RENAME |
|
// -> CHMOD -> REMOVE in that order. So we lost track of the file. |
|
// To prevent this, we add the file again, if it exist after a |
|
// REMOVE event. |
|
if event.Op&fsnotify.Remove == fsnotify.Remove { |
|
if _, err := os.Stat(event.Name); err == nil { |
|
watcher.Add(event.Name) |
|
} else { |
|
log.Fatal("Lost the configuration file. We stop now.") |
|
stop(1) |
|
} |
|
} |
|
case err := <-watcher.Errors: |
|
log.Println("We have the following problem with the configuration file: ", err) |
|
log.Println("Try the fix this problem by yourself and restart the agent.") |
|
stop(2) |
|
} |
|
} |
|
}() |
|
|
|
err = watcher.Add(configFile) |
|
if err != nil { |
|
log.Fatal("Can't find the configuration file. Please create one.") |
|
} |
|
<-done |
|
} |
|
|
|
type argT struct { |
|
cli.Helper |
|
ConfigFile string `cli:"c,config" usage:"specify a keymap config file"` |
|
Device string `cli:"d,device" usage:"specify the serial port, the n3rdpad is hooked to"` |
|
} |
|
|
|
func main() { |
|
configPath, _ := os.Getwd() |
|
configFile := path.Join(configPath, "keymap.conf") |
|
|
|
cli.Run(&argT{}, func(ctx *cli.Context) error { |
|
args := ctx.Argv().(*argT) |
|
if args.ConfigFile != "" { |
|
configFile = args.ConfigFile |
|
} |
|
if args.Device == "" { |
|
log.Fatal("You need to specify the serial device with the --device parameter.") |
|
stop(3) |
|
} |
|
|
|
if !args.Help { |
|
// Start up the application |
|
log.Println("Using the configuration file", configFile) |
|
|
|
// Open the serial connection |
|
config := &serial.Config{Name: args.Device, Baud: 115200} |
|
serial, err := serial.OpenPort(config) |
|
|
|
if err != nil { |
|
log.Fatal(err) |
|
return nil |
|
} |
|
|
|
log.Printf("Open the connection to the n3rdpad over %s", args.Device) |
|
|
|
go watchForConfigChanges(configFile, serial) |
|
waitAndExecuteCommandsFromDevice(serial) |
|
|
|
stop(0) |
|
} |
|
|
|
return nil |
|
}) |
|
}
|
|
|