sacn 0.11.1

A Rust implementation of the ANSI E1.31 Streaming ACN protocol, tested against protocol version ANSI E1.31-2018.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

// Copyright 2025 sacn Developers
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
//
// Simply listens on the given universe and shows the current data.

extern crate crossterm;
extern crate sacn;

use crossterm::style::Print;
use crossterm::{cursor, execute, queue, terminal};
use std::io::{self, Stdout, Write};
use std::net::SocketAddr;
use std::time::{Duration, Instant};

use sacn::packet::ACN_SDT_MULTICAST_PORT;
use sacn::receive::{DMXData, SacnReceiver};

fn main() {
    let interface_ip = "127.0.0.1";
    let universe = 1;
    let duration = Duration::from_secs(12);
    let max_wait = Duration::from_secs(1);
    let mut dmx_recv = SacnReceiver::with_ip(
        SocketAddr::new(interface_ip.parse().unwrap(), ACN_SDT_MULTICAST_PORT),
        None,
    )
    .unwrap();
    dmx_recv.listen_universes(&[universe]).unwrap();

    println!("Started");

    let start = Instant::now();
    let mut remaining = duration
        .checked_sub(start.elapsed())
        .unwrap_or(Duration::from_millis(0));

    let mut stdout = io::stdout();
    execute!(stdout, terminal::Clear(terminal::ClearType::All)).unwrap();
    while remaining > Duration::from_millis(250) {
        match dmx_recv.recv(Some(max_wait)) {
            Ok(data) => {
                display_data(&mut stdout, &remaining, &data[0]);
            }
            Err(e) => {
                execute!(
                    stdout,
                    cursor::MoveTo(0, 0),
                    terminal::Clear(terminal::ClearType::All)
                )
                .unwrap();
                println!(
                    "{} - universe {}: {}ms left",
                    e,
                    universe,
                    remaining.as_millis()
                );
            }
        }
        remaining = duration
            .checked_sub(start.elapsed())
            .unwrap_or(Duration::from_millis(0));
    }
    execute!(stdout, terminal::Clear(terminal::ClearType::All)).unwrap();
}

fn display_data(stdout: &mut Stdout, remaining: &Duration, data: &DMXData) {
    // Don't worry about this bit - its just for actually displaying the data
    execute!(stdout, terminal::Clear(terminal::ClearType::All)).unwrap();
    queue!(
        stdout,
        cursor::MoveTo(0, 0),
        Print(format!(
            "Received from universe {}: {}ms left",
            data.universe,
            remaining.as_millis()
        ))
    )
    .unwrap();
    for y in 0..16 {
        let cursor_y = y + 1;
        queue!(stdout, cursor::MoveTo(0, cursor_y), Print("|")).unwrap();
        for x in 0..32 {
            let data_index = ((y * 16 + x) + 1) as usize;
            let cursor_x = x * 4 + 1;
            queue!(
                stdout,
                cursor::MoveTo(cursor_x, cursor_y),
                Print(format!("{:03}|", data.values[data_index]))
            )
            .unwrap();
        }
    }
    stdout.flush().unwrap();
}