319 lines
7.3 KiB
Go
319 lines
7.3 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"encoding/binary"
|
|
"fmt"
|
|
"log"
|
|
|
|
"github.com/pterm/pterm"
|
|
"go.bug.st/serial"
|
|
)
|
|
|
|
type ParserState int
|
|
|
|
const (
|
|
WAITING_FOR_START_BYTE ParserState = iota
|
|
ESCAPED_MESSAGE_ID
|
|
GET_MESSAGE_ID
|
|
IN_PAYLOD
|
|
ESCAPED_PAYLOAD_BYTE
|
|
)
|
|
|
|
const (
|
|
START_BYTE = 0xAA
|
|
ESCAPE_BYTE = 0xBB
|
|
END_BYTE = 0xCC
|
|
)
|
|
|
|
type ParseError int
|
|
|
|
const (
|
|
WRONG_CHECKSUM ParseError = iota
|
|
UNEXPECETD_BYTE
|
|
)
|
|
|
|
type MessageReceive struct {
|
|
raw_message []byte
|
|
parsed_message []byte
|
|
checksum byte
|
|
error ParseError
|
|
state ParserState
|
|
write_index int
|
|
raw_write_index int
|
|
}
|
|
|
|
func initMessageReceive(mr *MessageReceive) {
|
|
mr.raw_message = make([]byte, 1024*4)
|
|
mr.parsed_message = make([]byte, 1024*4)
|
|
mr.checksum = 0
|
|
mr.error = 0
|
|
mr.write_index = 0
|
|
mr.raw_write_index = 0
|
|
mr.state = WAITING_FOR_START_BYTE
|
|
}
|
|
|
|
func addByteToRawBuffer(mr *MessageReceive, pbyte byte) {
|
|
mr.raw_message[mr.raw_write_index] = pbyte
|
|
mr.raw_write_index += 1
|
|
}
|
|
func addByteToParsedBuffer(mr *MessageReceive, pbyte byte) {
|
|
mr.parsed_message[mr.write_index] = pbyte
|
|
mr.write_index += 1
|
|
mr.checksum ^= pbyte
|
|
}
|
|
|
|
func parse_03_payload(payloadBuffer []byte, payload_len int) {
|
|
|
|
type payload_data struct {
|
|
ClientID uint8
|
|
IsAvailable uint8
|
|
SlotIsUsed uint8
|
|
MACAddr [6]uint8
|
|
LastPing uint32
|
|
LastSuccessfulPing uint32
|
|
Version uint16
|
|
}
|
|
|
|
tableHeaders := pterm.TableData{
|
|
{"Client ID", "Verfügbar", "Genutzt", "MAC-Adresse", "Last Ping", "Letzter Erfolg Ping", "Version"},
|
|
}
|
|
|
|
tableData := tableHeaders
|
|
|
|
currentOffset := 2
|
|
|
|
const (
|
|
ENTRY_LEN = 19
|
|
OFFSET_MAC_ADDR = 3
|
|
OFFSET_LAST_PING = 9
|
|
OFFSET_LAST_SUCCESS_PING = 13
|
|
OFFSET_VERSION = 17
|
|
)
|
|
|
|
for i := 0; i < int(payloadBuffer[1]); i++ {
|
|
if currentOffset+ENTRY_LEN > payload_len {
|
|
fmt.Printf("Fehler: Payload zu kurz für Client-Eintrag %d\n", i)
|
|
break
|
|
}
|
|
|
|
entryBytes := payloadBuffer[currentOffset : currentOffset+ENTRY_LEN]
|
|
|
|
var clientData payload_data
|
|
|
|
clientData.ClientID = entryBytes[0]
|
|
clientData.IsAvailable = entryBytes[1]
|
|
clientData.SlotIsUsed = entryBytes[2]
|
|
|
|
copy(clientData.MACAddr[:], entryBytes[OFFSET_MAC_ADDR:OFFSET_MAC_ADDR+6])
|
|
|
|
clientData.LastPing = binary.LittleEndian.Uint32(entryBytes[OFFSET_LAST_PING : OFFSET_LAST_PING+4])
|
|
clientData.LastSuccessfulPing = binary.LittleEndian.Uint32(entryBytes[OFFSET_LAST_SUCCESS_PING : OFFSET_LAST_SUCCESS_PING+4])
|
|
clientData.Version = binary.LittleEndian.Uint16(entryBytes[OFFSET_VERSION : OFFSET_VERSION+2])
|
|
|
|
// Füge die geparsten Daten als String-Slice zur Tabelle hinzu
|
|
tableData = append(tableData, []string{
|
|
fmt.Sprintf("%d", clientData.ClientID),
|
|
fmt.Sprintf("%d", clientData.IsAvailable),
|
|
fmt.Sprintf("%d", clientData.SlotIsUsed),
|
|
fmt.Sprintf("%X:%X:%X:%X:%X:%X",
|
|
clientData.MACAddr[0], clientData.MACAddr[1], clientData.MACAddr[2],
|
|
clientData.MACAddr[3], clientData.MACAddr[4], clientData.MACAddr[5]),
|
|
fmt.Sprintf("%d", clientData.LastPing),
|
|
fmt.Sprintf("%d", clientData.LastSuccessfulPing),
|
|
fmt.Sprintf("%d", clientData.Version),
|
|
})
|
|
|
|
currentOffset += ENTRY_LEN
|
|
}
|
|
err := pterm.DefaultTable.WithHasHeader().WithBoxed().WithData(tableData).Render()
|
|
if err != nil {
|
|
fmt.Printf("Fehler beim Rendern der Tabelle: %s\n", err)
|
|
}
|
|
}
|
|
|
|
func message_receive_callback(mr MessageReceive) {
|
|
log.Printf("Message Received: % 02X\n", mr.raw_message[:mr.raw_write_index])
|
|
switch mr.parsed_message[0] {
|
|
case 0x01:
|
|
break
|
|
case 0x02:
|
|
break
|
|
case 0x03:
|
|
parse_03_payload(mr.parsed_message, mr.write_index)
|
|
break
|
|
}
|
|
}
|
|
|
|
func message_receive_failed_callback(mr MessageReceive) {
|
|
log.Printf("Error Message Received: % 02X\n", mr.raw_message[:mr.raw_write_index])
|
|
}
|
|
|
|
func parseByte(mr *MessageReceive, pbyte byte) {
|
|
addByteToRawBuffer(mr, pbyte)
|
|
switch mr.state {
|
|
case WAITING_FOR_START_BYTE:
|
|
if pbyte == START_BYTE {
|
|
initMessageReceive(mr)
|
|
mr.state = GET_MESSAGE_ID
|
|
addByteToRawBuffer(mr, pbyte)
|
|
}
|
|
// ignore every other byte
|
|
break
|
|
case GET_MESSAGE_ID:
|
|
if pbyte == ESCAPE_BYTE {
|
|
mr.state = ESCAPED_MESSAGE_ID
|
|
} else {
|
|
addByteToParsedBuffer(mr, pbyte)
|
|
mr.state = IN_PAYLOD
|
|
}
|
|
break
|
|
case ESCAPED_MESSAGE_ID:
|
|
addByteToParsedBuffer(mr, pbyte)
|
|
mr.state = IN_PAYLOD
|
|
break
|
|
case IN_PAYLOD:
|
|
if pbyte == ESCAPE_BYTE {
|
|
mr.state = ESCAPED_PAYLOAD_BYTE
|
|
break
|
|
}
|
|
if pbyte == START_BYTE {
|
|
mr.error = UNEXPECETD_BYTE
|
|
message_receive_failed_callback(*mr)
|
|
initMessageReceive(mr)
|
|
return
|
|
}
|
|
if pbyte == END_BYTE {
|
|
if mr.checksum != 0 { // checksum wrong
|
|
mr.error = WRONG_CHECKSUM
|
|
message_receive_failed_callback(*mr)
|
|
initMessageReceive(mr)
|
|
return
|
|
}
|
|
message_receive_callback(*mr)
|
|
initMessageReceive(mr)
|
|
break
|
|
}
|
|
// normal case
|
|
addByteToParsedBuffer(mr, pbyte)
|
|
break
|
|
case ESCAPED_PAYLOAD_BYTE:
|
|
addByteToParsedBuffer(mr, pbyte)
|
|
mr.state = IN_PAYLOD
|
|
break
|
|
default:
|
|
panic(fmt.Sprintf("unexpected main.ParserState: %#v", mr.state))
|
|
}
|
|
}
|
|
|
|
func buildMessage(payloadBuffer []byte, payload_len int, sendBuffer []byte) int {
|
|
var writeIndex int
|
|
checksum := byte(0x00)
|
|
writeIndex = 0
|
|
sendBuffer[writeIndex] = START_BYTE
|
|
writeIndex++
|
|
for i := range payload_len {
|
|
b := payloadBuffer[i]
|
|
if b == START_BYTE || b == ESCAPE_BYTE || b == END_BYTE {
|
|
sendBuffer[writeIndex] = ESCAPE_BYTE
|
|
writeIndex++
|
|
}
|
|
sendBuffer[writeIndex] = b
|
|
writeIndex++
|
|
checksum ^= b
|
|
}
|
|
sendBuffer[writeIndex] = checksum
|
|
writeIndex++
|
|
sendBuffer[writeIndex] = END_BYTE
|
|
writeIndex++
|
|
return writeIndex
|
|
}
|
|
|
|
func sendMessage(port serial.Port, sendBuffer []byte) {
|
|
n, err := port.Write(sendBuffer)
|
|
if err != nil {
|
|
log.Printf("Could not Send %v to Serial Port", sendBuffer)
|
|
}
|
|
if n < len(sendBuffer) {
|
|
log.Printf("Did not send all data %v, only send %v", len(sendBuffer), n)
|
|
}
|
|
fmt.Printf("Send Message % 02X\n", sendBuffer[:n])
|
|
}
|
|
|
|
func main() {
|
|
mode := &serial.Mode{
|
|
BaudRate: 115200,
|
|
}
|
|
port, err := serial.Open("/dev/ttyUSB0", mode)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
ctx, cancle := context.WithCancel(context.Background())
|
|
defer cancle()
|
|
|
|
go func() {
|
|
buff := make([]byte, 1024)
|
|
mr := MessageReceive{}
|
|
initMessageReceive(&mr)
|
|
for {
|
|
select {
|
|
case <-ctx.Done():
|
|
return
|
|
default:
|
|
n, err := port.Read(buff)
|
|
if err != nil {
|
|
log.Print(err)
|
|
break
|
|
}
|
|
if n == 0 {
|
|
fmt.Println("\nEOF")
|
|
break
|
|
}
|
|
for _, b := range buff[:n] {
|
|
parseByte(&mr, b)
|
|
}
|
|
//fmt.Printf("Empfangen: % 02X\n", string(buff[:n]))
|
|
break
|
|
}
|
|
}
|
|
}()
|
|
|
|
for {
|
|
var input string
|
|
_, err := fmt.Scanln(&input)
|
|
if err != nil {
|
|
log.Fatalf("Could not read from stdin")
|
|
}
|
|
fmt.Printf("Input %v", input)
|
|
|
|
switch input {
|
|
case "q":
|
|
return
|
|
case "1":
|
|
payload_buffer := make([]byte, 1024)
|
|
send_buffer := make([]byte, 1024)
|
|
payload_buffer[0] = 0x01
|
|
n := buildMessage(payload_buffer, 1, send_buffer)
|
|
sendMessage(port, send_buffer[:n])
|
|
break
|
|
case "2":
|
|
payload_buffer := make([]byte, 1024)
|
|
send_buffer := make([]byte, 1024)
|
|
payload_buffer[0] = 0x02
|
|
n := buildMessage(payload_buffer, 1, send_buffer)
|
|
sendMessage(port, send_buffer[:n])
|
|
break
|
|
case "3":
|
|
payload_buffer := make([]byte, 1024)
|
|
send_buffer := make([]byte, 1024)
|
|
payload_buffer[0] = 0x03
|
|
n := buildMessage(payload_buffer, 1, send_buffer)
|
|
sendMessage(port, send_buffer[:n])
|
|
break
|
|
default:
|
|
fmt.Printf("Not a valid input")
|
|
}
|
|
}
|
|
}
|