Initial Art-Net protocol library
This commit is contained in:
Ian Gulliver
261
discovery.go
Normal file
261
discovery.go
Normal file
@@ -0,0 +1,261 @@
|
|||||||
|
package artnet
|
||||||
|
|
||||||
|
import (
|
||||||
|
"net"
|
||||||
|
"sync"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
type Node struct {
|
||||||
|
IP net.IP
|
||||||
|
Port uint16
|
||||||
|
MAC net.HardwareAddr
|
||||||
|
ShortName string
|
||||||
|
LongName string
|
||||||
|
Inputs []Universe
|
||||||
|
Outputs []Universe
|
||||||
|
LastSeen time.Time
|
||||||
|
}
|
||||||
|
|
||||||
|
type Discovery struct {
|
||||||
|
sender *Sender
|
||||||
|
receiver *Receiver
|
||||||
|
nodes map[string]*Node
|
||||||
|
nodesMu sync.RWMutex
|
||||||
|
localIP [4]byte
|
||||||
|
localMAC [6]byte
|
||||||
|
broadcast net.IP
|
||||||
|
shortName string
|
||||||
|
longName string
|
||||||
|
inputUnivs []Universe
|
||||||
|
outputUnivs []Universe
|
||||||
|
pollTargets []*net.UDPAddr
|
||||||
|
done chan struct{}
|
||||||
|
onChange func(*Node)
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewDiscovery(sender *Sender, shortName, longName string, inputUnivs, outputUnivs []Universe, pollTargets []*net.UDPAddr) *Discovery {
|
||||||
|
return &Discovery{
|
||||||
|
sender: sender,
|
||||||
|
nodes: map[string]*Node{},
|
||||||
|
shortName: shortName,
|
||||||
|
longName: longName,
|
||||||
|
inputUnivs: inputUnivs,
|
||||||
|
outputUnivs: outputUnivs,
|
||||||
|
pollTargets: pollTargets,
|
||||||
|
done: make(chan struct{}),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) Start() {
|
||||||
|
d.detectInterface()
|
||||||
|
go d.pollLoop()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) Stop() {
|
||||||
|
close(d.done)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) SetReceiver(r *Receiver) {
|
||||||
|
d.receiver = r
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) SetOnChange(fn func(*Node)) {
|
||||||
|
d.onChange = fn
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) pollLoop() {
|
||||||
|
d.sendPolls()
|
||||||
|
|
||||||
|
ticker := time.NewTicker(10 * time.Second)
|
||||||
|
defer ticker.Stop()
|
||||||
|
|
||||||
|
cleanupTicker := time.NewTicker(30 * time.Second)
|
||||||
|
defer cleanupTicker.Stop()
|
||||||
|
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case <-d.done:
|
||||||
|
return
|
||||||
|
case <-ticker.C:
|
||||||
|
d.sendPolls()
|
||||||
|
case <-cleanupTicker.C:
|
||||||
|
d.cleanup()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) sendPolls() {
|
||||||
|
for _, target := range d.pollTargets {
|
||||||
|
d.sender.SendPoll(target)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) cleanup() {
|
||||||
|
d.nodesMu.Lock()
|
||||||
|
defer d.nodesMu.Unlock()
|
||||||
|
|
||||||
|
cutoff := time.Now().Add(-60 * time.Second)
|
||||||
|
for ip, node := range d.nodes {
|
||||||
|
if node.LastSeen.Before(cutoff) {
|
||||||
|
delete(d.nodes, ip)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) HandlePollReply(src *net.UDPAddr, pkt *PollReplyPacket) {
|
||||||
|
d.nodesMu.Lock()
|
||||||
|
defer d.nodesMu.Unlock()
|
||||||
|
|
||||||
|
ip := src.IP.String()
|
||||||
|
|
||||||
|
localIP := net.IP(d.localIP[:])
|
||||||
|
if src.IP.Equal(localIP) {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
node, exists := d.nodes[ip]
|
||||||
|
if !exists {
|
||||||
|
node = &Node{
|
||||||
|
IP: src.IP,
|
||||||
|
Port: pkt.Port,
|
||||||
|
}
|
||||||
|
d.nodes[ip] = node
|
||||||
|
}
|
||||||
|
|
||||||
|
node.ShortName = pkt.GetShortName()
|
||||||
|
node.LongName = pkt.GetLongName()
|
||||||
|
node.MAC = pkt.MACAddr()
|
||||||
|
node.LastSeen = time.Now()
|
||||||
|
|
||||||
|
for _, u := range pkt.InputUniverses() {
|
||||||
|
if !containsUniverse(node.Inputs, u) {
|
||||||
|
node.Inputs = append(node.Inputs, u)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for _, u := range pkt.OutputUniverses() {
|
||||||
|
if !containsUniverse(node.Outputs, u) {
|
||||||
|
node.Outputs = append(node.Outputs, u)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if d.onChange != nil {
|
||||||
|
d.onChange(node)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) HandlePoll(src *net.UDPAddr) {
|
||||||
|
if d.receiver == nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
dst := &net.UDPAddr{IP: d.broadcast, Port: Port}
|
||||||
|
d.sendPollReplies(dst, d.inputUnivs, true)
|
||||||
|
d.sendPollReplies(dst, d.outputUnivs, false)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) sendPollReplies(dst *net.UDPAddr, universes []Universe, isInput bool) {
|
||||||
|
groups := map[uint16][]Universe{}
|
||||||
|
for _, u := range universes {
|
||||||
|
key := uint16(u.Net())<<8 | uint16(u.SubNet())<<4
|
||||||
|
groups[key] = append(groups[key], u)
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, univs := range groups {
|
||||||
|
for i := 0; i < len(univs); i += 4 {
|
||||||
|
end := i + 4
|
||||||
|
if end > len(univs) {
|
||||||
|
end = len(univs)
|
||||||
|
}
|
||||||
|
chunk := univs[i:end]
|
||||||
|
pkt := BuildPollReplyPacket(d.localIP, d.localMAC, d.shortName, d.longName, chunk, isInput)
|
||||||
|
d.receiver.SendTo(pkt, dst)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) GetNodesForUniverse(universe Universe) []*Node {
|
||||||
|
d.nodesMu.RLock()
|
||||||
|
defer d.nodesMu.RUnlock()
|
||||||
|
|
||||||
|
var result []*Node
|
||||||
|
for _, node := range d.nodes {
|
||||||
|
for _, u := range node.Outputs {
|
||||||
|
if u == universe {
|
||||||
|
result = append(result, node)
|
||||||
|
break
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) GetAllNodes() []*Node {
|
||||||
|
d.nodesMu.RLock()
|
||||||
|
defer d.nodesMu.RUnlock()
|
||||||
|
|
||||||
|
result := make([]*Node, 0, len(d.nodes))
|
||||||
|
for _, node := range d.nodes {
|
||||||
|
result = append(result, node)
|
||||||
|
}
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) SetLocalIP(ip net.IP) {
|
||||||
|
if ip4 := ip.To4(); ip4 != nil {
|
||||||
|
copy(d.localIP[:], ip4)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (d *Discovery) detectInterface() {
|
||||||
|
d.broadcast = net.IPv4bcast
|
||||||
|
|
||||||
|
ifaces, err := net.Interfaces()
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, iface := range ifaces {
|
||||||
|
if iface.Flags&net.FlagLoopback != 0 || iface.Flags&net.FlagUp == 0 {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
addrs, err := iface.Addrs()
|
||||||
|
if err != nil {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, addr := range addrs {
|
||||||
|
ipnet, ok := addr.(*net.IPNet)
|
||||||
|
if !ok {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
ip4 := ipnet.IP.To4()
|
||||||
|
if ip4 == nil {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
copy(d.localIP[:], ip4)
|
||||||
|
|
||||||
|
if len(iface.HardwareAddr) == 6 {
|
||||||
|
copy(d.localMAC[:], iface.HardwareAddr)
|
||||||
|
}
|
||||||
|
|
||||||
|
bcast := make(net.IP, 4)
|
||||||
|
for i := 0; i < 4; i++ {
|
||||||
|
bcast[i] = ip4[i] | ^ipnet.Mask[i]
|
||||||
|
}
|
||||||
|
d.broadcast = bcast
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func containsUniverse(slice []Universe, val Universe) bool {
|
||||||
|
for _, v := range slice {
|
||||||
|
if v == val {
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false
|
||||||
|
}
|
||||||
104
poller.go
Normal file
104
poller.go
Normal file
@@ -0,0 +1,104 @@
|
|||||||
|
package artnet
|
||||||
|
|
||||||
|
import (
|
||||||
|
"net"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
type Poller struct {
|
||||||
|
sender *Sender
|
||||||
|
targets []*net.UDPAddr
|
||||||
|
interval time.Duration
|
||||||
|
done chan struct{}
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewPoller(sender *Sender, targets []*net.UDPAddr, interval time.Duration) *Poller {
|
||||||
|
return &Poller{
|
||||||
|
sender: sender,
|
||||||
|
targets: targets,
|
||||||
|
interval: interval,
|
||||||
|
done: make(chan struct{}),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewBroadcastPoller(sender *Sender, interval time.Duration) *Poller {
|
||||||
|
return &Poller{
|
||||||
|
sender: sender,
|
||||||
|
targets: []*net.UDPAddr{{IP: net.IPv4bcast, Port: Port}},
|
||||||
|
interval: interval,
|
||||||
|
done: make(chan struct{}),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Poller) Start() {
|
||||||
|
go p.loop()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Poller) Stop() {
|
||||||
|
close(p.done)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Poller) Poll() {
|
||||||
|
for _, target := range p.targets {
|
||||||
|
p.sender.SendPoll(target)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Poller) loop() {
|
||||||
|
p.Poll()
|
||||||
|
|
||||||
|
ticker := time.NewTicker(p.interval)
|
||||||
|
defer ticker.Stop()
|
||||||
|
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case <-p.done:
|
||||||
|
return
|
||||||
|
case <-ticker.C:
|
||||||
|
p.Poll()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Poller) SetTargets(targets []*net.UDPAddr) {
|
||||||
|
p.targets = targets
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *Poller) AddTarget(target *net.UDPAddr) {
|
||||||
|
p.targets = append(p.targets, target)
|
||||||
|
}
|
||||||
|
|
||||||
|
func BroadcastAddr() *net.UDPAddr {
|
||||||
|
return &net.UDPAddr{IP: net.IPv4bcast, Port: Port}
|
||||||
|
}
|
||||||
|
|
||||||
|
func UnicastAddr(ip net.IP) *net.UDPAddr {
|
||||||
|
return &net.UDPAddr{IP: ip, Port: Port}
|
||||||
|
}
|
||||||
|
|
||||||
|
func InterfaceBroadcast(iface net.Interface) *net.UDPAddr {
|
||||||
|
addrs, err := iface.Addrs()
|
||||||
|
if err != nil {
|
||||||
|
return BroadcastAddr()
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, addr := range addrs {
|
||||||
|
ipnet, ok := addr.(*net.IPNet)
|
||||||
|
if !ok {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
ip4 := ipnet.IP.To4()
|
||||||
|
if ip4 == nil {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
bcast := make(net.IP, 4)
|
||||||
|
for i := 0; i < 4; i++ {
|
||||||
|
bcast[i] = ip4[i] | ^ipnet.Mask[i]
|
||||||
|
}
|
||||||
|
return &net.UDPAddr{IP: bcast, Port: Port}
|
||||||
|
}
|
||||||
|
|
||||||
|
return BroadcastAddr()
|
||||||
|
}
|
||||||
322
protocol.go
Normal file
322
protocol.go
Normal file
@@ -0,0 +1,322 @@
|
|||||||
|
package artnet
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"encoding/binary"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"net"
|
||||||
|
"strings"
|
||||||
|
)
|
||||||
|
|
||||||
|
const (
|
||||||
|
Port = 6454
|
||||||
|
ProtocolVersion = 14
|
||||||
|
|
||||||
|
OpPoll uint16 = 0x2000
|
||||||
|
OpPollReply uint16 = 0x2100
|
||||||
|
OpDmx uint16 = 0x5000
|
||||||
|
OpSync uint16 = 0x5200
|
||||||
|
OpAddress uint16 = 0x6000
|
||||||
|
OpInput uint16 = 0x7000
|
||||||
|
OpTodData uint16 = 0x8100
|
||||||
|
OpTodControl uint16 = 0x8200
|
||||||
|
OpRdm uint16 = 0x8300
|
||||||
|
|
||||||
|
PortTypeOutput uint8 = 0x80
|
||||||
|
PortTypeInput uint8 = 0x40
|
||||||
|
|
||||||
|
GoodOutputDataTransmitted uint8 = 0x80
|
||||||
|
GoodInputDataReceived uint8 = 0x80
|
||||||
|
|
||||||
|
StyleNode uint8 = 0x00
|
||||||
|
StyleController uint8 = 0x01
|
||||||
|
StyleMedia uint8 = 0x02
|
||||||
|
StyleRoute uint8 = 0x03
|
||||||
|
StyleBackup uint8 = 0x04
|
||||||
|
StyleConfig uint8 = 0x05
|
||||||
|
StyleVisual uint8 = 0x06
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
ID = [8]byte{'A', 'r', 't', '-', 'N', 'e', 't', 0x00}
|
||||||
|
|
||||||
|
ErrInvalidHeader = errors.New("invalid Art-Net header")
|
||||||
|
ErrPacketTooShort = errors.New("packet too short")
|
||||||
|
)
|
||||||
|
|
||||||
|
type Universe uint16
|
||||||
|
|
||||||
|
func NewUniverse(netVal, subnet, universe uint8) Universe {
|
||||||
|
return Universe((uint16(netVal&0x7F) << 8) | (uint16(subnet&0x0F) << 4) | uint16(universe&0x0F))
|
||||||
|
}
|
||||||
|
|
||||||
|
func (u Universe) Net() uint8 { return uint8((u >> 8) & 0x7F) }
|
||||||
|
func (u Universe) SubNet() uint8 { return uint8((u >> 4) & 0x0F) }
|
||||||
|
func (u Universe) Universe() uint8 { return uint8(u & 0x0F) }
|
||||||
|
func (u Universe) String() string { return fmt.Sprintf("%d.%d.%d", u.Net(), u.SubNet(), u.Universe()) }
|
||||||
|
|
||||||
|
type DMXPacket struct {
|
||||||
|
ProtocolVersion uint16
|
||||||
|
Sequence uint8
|
||||||
|
Physical uint8
|
||||||
|
Universe Universe
|
||||||
|
Length uint16
|
||||||
|
Data [512]byte
|
||||||
|
}
|
||||||
|
|
||||||
|
type PollPacket struct {
|
||||||
|
ProtocolVersion uint16
|
||||||
|
Flags uint8
|
||||||
|
DiagPriority uint8
|
||||||
|
}
|
||||||
|
|
||||||
|
type PollReplyPacket struct {
|
||||||
|
IPAddress [4]byte
|
||||||
|
Port uint16
|
||||||
|
VersionInfo uint16
|
||||||
|
NetSwitch uint8
|
||||||
|
SubSwitch uint8
|
||||||
|
OemHi uint8
|
||||||
|
Oem uint8
|
||||||
|
UbeaVersion uint8
|
||||||
|
Status1 uint8
|
||||||
|
EstaMan uint16
|
||||||
|
ShortName [18]byte
|
||||||
|
LongName [64]byte
|
||||||
|
NodeReport [64]byte
|
||||||
|
NumPortsHi uint8
|
||||||
|
NumPortsLo uint8
|
||||||
|
PortTypes [4]byte
|
||||||
|
GoodInput [4]byte
|
||||||
|
GoodOutput [4]byte
|
||||||
|
SwIn [4]byte
|
||||||
|
SwOut [4]byte
|
||||||
|
SwVideo uint8
|
||||||
|
SwMacro uint8
|
||||||
|
SwRemote uint8
|
||||||
|
Style uint8
|
||||||
|
MAC [6]byte
|
||||||
|
BindIP [4]byte
|
||||||
|
BindIndex uint8
|
||||||
|
Status2 uint8
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *PollReplyPacket) IP() net.IP {
|
||||||
|
return net.IPv4(p.IPAddress[0], p.IPAddress[1], p.IPAddress[2], p.IPAddress[3])
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *PollReplyPacket) MACAddr() net.HardwareAddr {
|
||||||
|
return net.HardwareAddr(p.MAC[:])
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *PollReplyPacket) GetShortName() string {
|
||||||
|
return strings.TrimRight(string(p.ShortName[:]), "\x00")
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *PollReplyPacket) GetLongName() string {
|
||||||
|
return strings.TrimRight(string(p.LongName[:]), "\x00")
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *PollReplyPacket) NumPorts() int {
|
||||||
|
n := int(p.NumPortsLo)
|
||||||
|
if n > 4 {
|
||||||
|
n = 4
|
||||||
|
}
|
||||||
|
return n
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *PollReplyPacket) InputUniverses() []Universe {
|
||||||
|
var result []Universe
|
||||||
|
for i := 0; i < p.NumPorts(); i++ {
|
||||||
|
if p.PortTypes[i]&PortTypeInput != 0 {
|
||||||
|
u := NewUniverse(p.NetSwitch, p.SubSwitch, p.SwIn[i])
|
||||||
|
result = append(result, u)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
func (p *PollReplyPacket) OutputUniverses() []Universe {
|
||||||
|
var result []Universe
|
||||||
|
for i := 0; i < p.NumPorts(); i++ {
|
||||||
|
if p.PortTypes[i]&PortTypeOutput != 0 {
|
||||||
|
u := NewUniverse(p.NetSwitch, p.SubSwitch, p.SwOut[i])
|
||||||
|
result = append(result, u)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
func ParsePacket(data []byte) (uint16, interface{}, error) {
|
||||||
|
if len(data) < 10 {
|
||||||
|
return 0, nil, ErrPacketTooShort
|
||||||
|
}
|
||||||
|
|
||||||
|
if !bytes.Equal(data[:8], ID[:]) {
|
||||||
|
return 0, nil, ErrInvalidHeader
|
||||||
|
}
|
||||||
|
|
||||||
|
opCode := binary.LittleEndian.Uint16(data[8:10])
|
||||||
|
|
||||||
|
switch opCode {
|
||||||
|
case OpDmx:
|
||||||
|
pkt, err := parseDMXPacket(data)
|
||||||
|
return opCode, pkt, err
|
||||||
|
case OpPoll:
|
||||||
|
pkt, err := parsePollPacket(data)
|
||||||
|
return opCode, pkt, err
|
||||||
|
case OpPollReply:
|
||||||
|
pkt, err := parsePollReplyPacket(data)
|
||||||
|
return opCode, pkt, err
|
||||||
|
default:
|
||||||
|
return opCode, nil, nil
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func parseDMXPacket(data []byte) (*DMXPacket, error) {
|
||||||
|
if len(data) < 18 {
|
||||||
|
return nil, ErrPacketTooShort
|
||||||
|
}
|
||||||
|
|
||||||
|
pkt := &DMXPacket{
|
||||||
|
ProtocolVersion: binary.BigEndian.Uint16(data[10:12]),
|
||||||
|
Sequence: data[12],
|
||||||
|
Physical: data[13],
|
||||||
|
Universe: Universe(binary.LittleEndian.Uint16(data[14:16])),
|
||||||
|
Length: binary.BigEndian.Uint16(data[16:18]),
|
||||||
|
}
|
||||||
|
|
||||||
|
dataLen := int(pkt.Length)
|
||||||
|
if dataLen > 512 {
|
||||||
|
dataLen = 512
|
||||||
|
}
|
||||||
|
if len(data) >= 18+dataLen {
|
||||||
|
copy(pkt.Data[:], data[18:18+dataLen])
|
||||||
|
}
|
||||||
|
|
||||||
|
return pkt, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func parsePollPacket(data []byte) (*PollPacket, error) {
|
||||||
|
if len(data) < 14 {
|
||||||
|
return nil, ErrPacketTooShort
|
||||||
|
}
|
||||||
|
|
||||||
|
return &PollPacket{
|
||||||
|
ProtocolVersion: binary.BigEndian.Uint16(data[10:12]),
|
||||||
|
Flags: data[12],
|
||||||
|
DiagPriority: data[13],
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func parsePollReplyPacket(data []byte) (*PollReplyPacket, error) {
|
||||||
|
if len(data) < 207 {
|
||||||
|
return nil, ErrPacketTooShort
|
||||||
|
}
|
||||||
|
|
||||||
|
pkt := &PollReplyPacket{
|
||||||
|
Port: binary.LittleEndian.Uint16(data[14:16]),
|
||||||
|
VersionInfo: binary.BigEndian.Uint16(data[16:18]),
|
||||||
|
NetSwitch: data[18],
|
||||||
|
SubSwitch: data[19],
|
||||||
|
OemHi: data[20],
|
||||||
|
Oem: data[21],
|
||||||
|
UbeaVersion: data[22],
|
||||||
|
Status1: data[23],
|
||||||
|
EstaMan: binary.LittleEndian.Uint16(data[24:26]),
|
||||||
|
NumPortsHi: data[172],
|
||||||
|
NumPortsLo: data[173],
|
||||||
|
Style: data[200],
|
||||||
|
BindIndex: data[212],
|
||||||
|
Status2: data[213],
|
||||||
|
}
|
||||||
|
|
||||||
|
copy(pkt.IPAddress[:], data[10:14])
|
||||||
|
copy(pkt.ShortName[:], data[26:44])
|
||||||
|
copy(pkt.LongName[:], data[44:108])
|
||||||
|
copy(pkt.NodeReport[:], data[108:172])
|
||||||
|
copy(pkt.PortTypes[:], data[174:178])
|
||||||
|
copy(pkt.GoodInput[:], data[178:182])
|
||||||
|
copy(pkt.GoodOutput[:], data[182:186])
|
||||||
|
copy(pkt.SwIn[:], data[186:190])
|
||||||
|
copy(pkt.SwOut[:], data[190:194])
|
||||||
|
copy(pkt.MAC[:], data[201:207])
|
||||||
|
copy(pkt.BindIP[:], data[207:211])
|
||||||
|
|
||||||
|
return pkt, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func BuildDMXPacket(universe Universe, sequence uint8, data []byte) []byte {
|
||||||
|
dataLen := len(data)
|
||||||
|
if dataLen > 512 {
|
||||||
|
dataLen = 512
|
||||||
|
}
|
||||||
|
if dataLen%2 != 0 {
|
||||||
|
dataLen++
|
||||||
|
}
|
||||||
|
|
||||||
|
buf := make([]byte, 18+dataLen)
|
||||||
|
copy(buf[0:8], ID[:])
|
||||||
|
binary.LittleEndian.PutUint16(buf[8:10], OpDmx)
|
||||||
|
binary.BigEndian.PutUint16(buf[10:12], ProtocolVersion)
|
||||||
|
buf[12] = sequence
|
||||||
|
buf[13] = 0
|
||||||
|
binary.LittleEndian.PutUint16(buf[14:16], uint16(universe))
|
||||||
|
binary.BigEndian.PutUint16(buf[16:18], uint16(dataLen))
|
||||||
|
copy(buf[18:], data[:dataLen])
|
||||||
|
|
||||||
|
return buf
|
||||||
|
}
|
||||||
|
|
||||||
|
func BuildPollPacket() []byte {
|
||||||
|
buf := make([]byte, 14)
|
||||||
|
copy(buf[0:8], ID[:])
|
||||||
|
binary.LittleEndian.PutUint16(buf[8:10], OpPoll)
|
||||||
|
binary.BigEndian.PutUint16(buf[10:12], ProtocolVersion)
|
||||||
|
buf[12] = 0x00
|
||||||
|
buf[13] = 0x00
|
||||||
|
return buf
|
||||||
|
}
|
||||||
|
|
||||||
|
func BuildPollReplyPacket(ip [4]byte, mac [6]byte, shortName, longName string, universes []Universe, isInput bool) []byte {
|
||||||
|
buf := make([]byte, 240)
|
||||||
|
copy(buf[0:8], ID[:])
|
||||||
|
binary.LittleEndian.PutUint16(buf[8:10], OpPollReply)
|
||||||
|
copy(buf[10:14], ip[:])
|
||||||
|
binary.LittleEndian.PutUint16(buf[14:16], Port)
|
||||||
|
binary.BigEndian.PutUint16(buf[16:18], ProtocolVersion)
|
||||||
|
|
||||||
|
if len(universes) > 0 {
|
||||||
|
buf[18] = universes[0].Net()
|
||||||
|
buf[19] = universes[0].SubNet()
|
||||||
|
}
|
||||||
|
|
||||||
|
copy(buf[26:44], shortName)
|
||||||
|
copy(buf[44:108], longName)
|
||||||
|
|
||||||
|
numPorts := len(universes)
|
||||||
|
if numPorts > 4 {
|
||||||
|
numPorts = 4
|
||||||
|
}
|
||||||
|
buf[173] = byte(numPorts)
|
||||||
|
|
||||||
|
for i := 0; i < numPorts; i++ {
|
||||||
|
if isInput {
|
||||||
|
buf[174+i] = PortTypeInput
|
||||||
|
buf[178+i] = GoodInputDataReceived
|
||||||
|
buf[186+i] = universes[i].Universe()
|
||||||
|
} else {
|
||||||
|
buf[174+i] = PortTypeOutput
|
||||||
|
buf[182+i] = GoodOutputDataTransmitted
|
||||||
|
buf[190+i] = universes[i].Universe()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
copy(buf[201:207], mac[:])
|
||||||
|
copy(buf[207:211], ip[:])
|
||||||
|
buf[211] = 1
|
||||||
|
buf[212] = 0x08
|
||||||
|
|
||||||
|
return buf
|
||||||
|
}
|
||||||
107
receiver.go
Normal file
107
receiver.go
Normal file
@@ -0,0 +1,107 @@
|
|||||||
|
package artnet
|
||||||
|
|
||||||
|
import (
|
||||||
|
"net"
|
||||||
|
"time"
|
||||||
|
)
|
||||||
|
|
||||||
|
type Handler interface {
|
||||||
|
HandleDMX(src *net.UDPAddr, pkt *DMXPacket)
|
||||||
|
HandlePoll(src *net.UDPAddr, pkt *PollPacket)
|
||||||
|
HandlePollReply(src *net.UDPAddr, pkt *PollReplyPacket)
|
||||||
|
}
|
||||||
|
|
||||||
|
type Receiver struct {
|
||||||
|
conn *net.UDPConn
|
||||||
|
handler Handler
|
||||||
|
done chan struct{}
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewReceiver(addr *net.UDPAddr, handler Handler) (*Receiver, error) {
|
||||||
|
conn, err := net.ListenUDP("udp4", addr)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return &Receiver{
|
||||||
|
conn: conn,
|
||||||
|
handler: handler,
|
||||||
|
done: make(chan struct{}),
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewDefaultReceiver(handler Handler) (*Receiver, error) {
|
||||||
|
return NewReceiver(&net.UDPAddr{Port: Port}, handler)
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Receiver) Start() {
|
||||||
|
go r.loop()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Receiver) Stop() {
|
||||||
|
close(r.done)
|
||||||
|
r.conn.Close()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Receiver) Conn() *net.UDPConn {
|
||||||
|
return r.conn
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Receiver) LocalAddr() net.Addr {
|
||||||
|
return r.conn.LocalAddr()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Receiver) SendTo(data []byte, addr *net.UDPAddr) error {
|
||||||
|
_, err := r.conn.WriteToUDP(data, addr)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Receiver) loop() {
|
||||||
|
buf := make([]byte, 1024)
|
||||||
|
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case <-r.done:
|
||||||
|
return
|
||||||
|
default:
|
||||||
|
}
|
||||||
|
|
||||||
|
r.conn.SetReadDeadline(time.Now().Add(1 * time.Second))
|
||||||
|
n, src, err := r.conn.ReadFromUDP(buf)
|
||||||
|
if err != nil {
|
||||||
|
if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
select {
|
||||||
|
case <-r.done:
|
||||||
|
return
|
||||||
|
default:
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
r.handle(src, buf[:n])
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (r *Receiver) handle(src *net.UDPAddr, data []byte) {
|
||||||
|
opCode, pkt, err := ParsePacket(data)
|
||||||
|
if err != nil {
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
switch opCode {
|
||||||
|
case OpDmx:
|
||||||
|
if dmx, ok := pkt.(*DMXPacket); ok {
|
||||||
|
r.handler.HandleDMX(src, dmx)
|
||||||
|
}
|
||||||
|
case OpPoll:
|
||||||
|
if poll, ok := pkt.(*PollPacket); ok {
|
||||||
|
r.handler.HandlePoll(src, poll)
|
||||||
|
}
|
||||||
|
case OpPollReply:
|
||||||
|
if reply, ok := pkt.(*PollReplyPacket); ok {
|
||||||
|
r.handler.HandlePollReply(src, reply)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
71
sender.go
Normal file
71
sender.go
Normal file
@@ -0,0 +1,71 @@
|
|||||||
|
package artnet
|
||||||
|
|
||||||
|
import (
|
||||||
|
"net"
|
||||||
|
"sync"
|
||||||
|
)
|
||||||
|
|
||||||
|
type Sender struct {
|
||||||
|
conn *net.UDPConn
|
||||||
|
sequences map[Universe]uint8
|
||||||
|
seqMu sync.Mutex
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewSender() (*Sender, error) {
|
||||||
|
conn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4zero, Port: 0})
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return &Sender{
|
||||||
|
conn: conn,
|
||||||
|
sequences: map[Universe]uint8{},
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func NewSenderFromConn(conn *net.UDPConn) *Sender {
|
||||||
|
return &Sender{
|
||||||
|
conn: conn,
|
||||||
|
sequences: map[Universe]uint8{},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Sender) SendDMX(addr *net.UDPAddr, universe Universe, data []byte) error {
|
||||||
|
s.seqMu.Lock()
|
||||||
|
seq := s.sequences[universe]
|
||||||
|
seq++
|
||||||
|
if seq == 0 {
|
||||||
|
seq = 1
|
||||||
|
}
|
||||||
|
s.sequences[universe] = seq
|
||||||
|
s.seqMu.Unlock()
|
||||||
|
|
||||||
|
pkt := BuildDMXPacket(universe, seq, data)
|
||||||
|
_, err := s.conn.WriteToUDP(pkt, addr)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Sender) SendPoll(addr *net.UDPAddr) error {
|
||||||
|
pkt := BuildPollPacket()
|
||||||
|
_, err := s.conn.WriteToUDP(pkt, addr)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Sender) SendPollReply(addr *net.UDPAddr, localIP [4]byte, localMAC [6]byte, shortName, longName string, universes []Universe, isInput bool) error {
|
||||||
|
pkt := BuildPollReplyPacket(localIP, localMAC, shortName, longName, universes, isInput)
|
||||||
|
_, err := s.conn.WriteToUDP(pkt, addr)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Sender) SendRaw(addr *net.UDPAddr, data []byte) error {
|
||||||
|
_, err := s.conn.WriteToUDP(data, addr)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Sender) Close() error {
|
||||||
|
return s.conn.Close()
|
||||||
|
}
|
||||||
|
|
||||||
|
func (s *Sender) LocalAddr() net.Addr {
|
||||||
|
return s.conn.LocalAddr()
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user