package main

import (
    "fmt"
    "time"
    "net"

    "gitlab.com/patopest/go-sacn"
    "gitlab.com/patopest/go-sacn/packet"
)

func main() {
    itf, _ := net.InterfaceByName("en0") // change based on your machine
    receiver := sacn.NewReceiver(itf)
    receiver.JoinUniverse(1)
    receiver.RegisterPacketCallback(packet.PacketTypeData, dataPacketCallback)
    receiver.Start()

    for {
        time.Sleep(1)
    }
}

func dataPacketCallback(p packet.SACNPacket, info sacn.PacketInfo) {
    d, ok := p.(*packet.DataPacket)
    if !ok {
        return
    }
    data := d.GetData()
    fmt.Printf("Received Data Packet for universe %d from %s: %v ...\n", d.Universe, info.Source.IP.String(), data[:min(10, len(data))])
}

package main

import (
    "log"
    "time"

    "gitlab.com/patopest/go-sacn"
    "gitlab.com/patopest/go-sacn/packet"
)

func main() {
    opts := sacn.SenderOptions{
        SourceName: "go-sacn test source",
    }
    sender, err := sacn.NewSender("192.168.1.200", &opts) // change IP to interface you want to send from
    if err != nil {
        log.Fatal(err)
    }

    universe, err := sender.StartUniverse(123)
    if err != nil {
        log.Fatal(err)
    }
    sender.SetMulticast(123, true)

    p := packet.NewDataPacket()
    p.SetData([]uint8{1, 2, 3, 4})
    sender.Send(123, p)

    sender.StopUniverse(123)

    time.Sleep(1 * time.Second)
    sender.Close()
}

// Create a new receiver bound to a network interface
receiver := sacn.NewReceiver(itf)

// Join a universe to start receiving data
receiver.JoinUniverse(1)

// Register callbacks for packet types
receiver.RegisterPacketCallback(packet.PacketTypeData, dataCallback)
receiver.RegisterPacketCallback(packet.PacketTypeSync, syncCallback)
receiver.RegisterPacketCallback(packet.PacketTypeDiscovery, discoveryCallback)

// Register callback for universe stream termination
receiver.RegisterTerminationCallback(terminationCallback)

// Start the receiver
receiver.Start()

// Stop the receiver
receiver.Stop()

// Create a sender bound to an IP address (required for multicast)
sender, err := sacn.NewSender("192.168.1.100", &sacn.SenderOptions{
    SourceName: "My Application",
})

// Start a universe and get a channel for sending packets
ch, err := sender.StartUniverse(1)

// Enable multicast for a universe
sender.SetMulticast(1, true)

// Add unicast destinations
sender.AddDestination(1, "192.168.1.200")

// Send packets via channel or direct send
ch <- dataPacket
sender.Send(1, dataPacket)

// Stop a universe (sends stream termination notification)
sender.StopUniverse(1)

// Clean up
sender.Close()

p := packet.NewDataPacket()
p.SetData([]uint8{1, 2, 3, 4})           // Set up to 512 bytes of DMX data
p.SetSourceName("My Controller")         // Optional: override default source name
p.SetPriority(100)                       // Optional: set priority (default 100)
p.SetPreviewData(true)                   // Optional: preview data flag
p.SetStreamTerminated(true)              // Optional: signal stream termination