Struct DMXSerial 

pub struct DMXSerial { /* private fields */ }

A DMX-Interface which writes to the SerialPort independently from the main thread.

It uses the RS-485 standard (aka. Open DMX) to send DMX data over a SerialPort.

Implementations

impl DMXSerial

pub fn open(port: &str) -> Result<DMXSerial, Error>

Opens a new DMX-Interface on the given path. Returns an [DMXError] if the port could not be opened.

The path should look something like this:

• Windows: COM3
• Linux: /dev/ttyUSB0

The interface can be set to synchronous or asynchronous mode (default).

In synchronous mode, no data will be sent to the SerialPort unti DMXSerial::update() is called. If updates are not sent regularly in synchronous mode, DMX-Devices might not react to the changes.

In asynchronous mode, the data will be polled automatically to the SerialPort.

Example

Basic usage:

use open_dmx::DMXSerial;
 
fn main() {
   let mut dmx = DMXSerial::open("COM3").unwrap();
  dmx.set_channels([255; 512]);
  dmx.set_channel(1, 0).unwrap();
}

Examples found in repository

examples/basic.rs (line 4)

fn main() {
    let mut dmx = DMXSerial::open("COM3").unwrap();
    dmx.set_channels([255; 512]);
    dmx.set_channel(1, 0).unwrap();
}

examples/checkerboard.rs (line 3)

fn main() {
    let mut dmx = DMXSerial::open("COM3").unwrap();
    let mut channels = [0; DMX_CHANNELS];
    channels.iter_mut().enumerate().for_each(|(i, value)| *value = if i % 2 == 0 { 255 } else { 0 });
    dmx.set_channels(channels);
}

examples/sync_strobe.rs (line 4)

fn main() -> Result<(), Box<dyn std::error::Error>>{
    let mut dmx = DMXSerial::open("COM3").unwrap();
    dmx.set_sync();
    //strobe
    loop {
        dmx.set_channels([255; 512]);
        dmx.update()?;
        dmx.set_channels([0; 512]);
        dmx.update()?;
    }
}

examples/reopen.rs (line 4)

fn main() {
    let mut dmx = DMXSerial::open("COM3").unwrap();
    dmx.set_sync();
    loop {
        let _ = strobe(&mut dmx);
        println!("Device has been disconnected! Reopening...");
        match dmx.reopen() {
            Ok(_) => println!("Device has been reopened!"),
            Err(e) => {
                println!("Error reopening device: {}", e);
                println!("Waiting 1 second before trying again...");
                std::thread::sleep(std::time::Duration::from_secs(1));
            },
        }
    }
}

pub fn open_sync(port: &str) -> Result<DMXSerial, Error>

Does the same as DMXSerial::open but sets the DMXSerial to sync mode.

Example

Basic strobe effect:

use open_dmx::DMXSerial;
fn main() {
    let mut dmx = DMXSerial::open_sync("COM3").unwrap();
    //strobe
    loop {
        dmx.set_channels([255; 512]);
        dmx.update(); //returns once the data is sent
        dmx.set_channels([0; 512]);
        dmx.update();
    }
}

pub fn reopen(&mut self) -> Result<(), Error>

Reopens the DMXSerial on the same path.

It keeps the current channel values.

Examples found in repository

examples/reopen.rs (line 9)

fn main() {
    let mut dmx = DMXSerial::open("COM3").unwrap();
    dmx.set_sync();
    loop {
        let _ = strobe(&mut dmx);
        println!("Device has been disconnected! Reopening...");
        match dmx.reopen() {
            Ok(_) => println!("Device has been reopened!"),
            Err(e) => {
                println!("Error reopening device: {}", e);
                println!("Waiting 1 second before trying again...");
                std::thread::sleep(std::time::Duration::from_secs(1));
            },
        }
    }
}

pub fn name(&self) -> &str

Gets the name of the Path on which the DMXSerial is opened.

Example

Basic usage:

let mut dmx = DMXSerial::open("COM3").unwrap();
assert_eq!(dmx.name(), "COM3");

pub fn set_channel( &mut self, channel: usize, value: u8, ) -> Result<(), DMXChannelValidityError>

Sets the specified channel to the given value.

Example

Basic usage:

dmx.set_channel(1, 255); //sets the first channel to 255

Examples found in repository

examples/basic.rs (line 6)

fn main() {
    let mut dmx = DMXSerial::open("COM3").unwrap();
    dmx.set_channels([255; 512]);
    dmx.set_channel(1, 0).unwrap();
}

pub fn set_channels(&mut self, channels: [u8; 512])

Sets all channels to the given value via a array of size DMX_CHANNELS.

Example

Checkerboard effect:

   let mut dmx = DMXSerial::open("COM3").unwrap();
   let mut channels = [0; DMX_CHANNELS];
   channels.iter_mut().enumerate().for_each(|(i, value)| *value = if i % 2 == 0 { 255 } else { 0 });
   dmx.set_channels(channels);

Examples found in repository

examples/basic.rs (line 5)

fn main() {
    let mut dmx = DMXSerial::open("COM3").unwrap();
    dmx.set_channels([255; 512]);
    dmx.set_channel(1, 0).unwrap();
}

examples/checkerboard.rs (line 6)

fn main() {
    let mut dmx = DMXSerial::open("COM3").unwrap();
    let mut channels = [0; DMX_CHANNELS];
    channels.iter_mut().enumerate().for_each(|(i, value)| *value = if i % 2 == 0 { 255 } else { 0 });
    dmx.set_channels(channels);
}

examples/reopen.rs (line 23)

fn strobe(dmx: &mut DMXSerial) -> Result<(), Box<dyn std::error::Error>>{
    println!("Sending strobe packets...");
    loop {
        dmx.set_channels([255; 512]);
        dmx.update()?;
        dmx.set_channels([0; 512]);
        dmx.update()?;
    }
}

examples/sync_strobe.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>>{
    let mut dmx = DMXSerial::open("COM3").unwrap();
    dmx.set_sync();
    //strobe
    loop {
        dmx.set_channels([255; 512]);
        dmx.update()?;
        dmx.set_channels([0; 512]);
        dmx.update()?;
    }
}

pub fn get_channel(&self, channel: usize) -> Result<u8, DMXChannelValidityError>

Tries to get the value of the specified channel.

Returns [DMXError::NotValid] if the given channel is not in the range of DMX_CHANNELS.

Example

Basic usage:

dmx.set_channel(1, 255).unwrap();
assert_eq!(dmx.get_channel(1).unwrap(), 255);

pub fn get_channels(&self) -> [u8; 512]

Returns the value of all channels via a array of size DMX_CHANNELS.

Example

Basic usage:

dmx.set_channels([255; DMX_CHANNELS]).unwrap();
assert_eq!(dmx.get_channels(), [255; DMX_CHANNELS]);

pub fn reset_channels(&mut self)

Resets all channels to 0.

Example

Basic usage:

dmx.set_channels([255; DMX_CHANNELS]).unwrap();
assert_eq!(dmx.get_channels(), [255; DMX_CHANNELS]);
dmx.reset_channels();
assert_eq!(dmx.get_channels(), [0; DMX_CHANNELS]);

pub fn update(&mut self) -> Result<(), DMXDisconnectionError>

Updates the DMX data.

Returns after the data has been sent.

Works both in sync and async mode.

Example

Basic Usage

Examples found in repository

examples/reopen.rs (line 24)

fn strobe(dmx: &mut DMXSerial) -> Result<(), Box<dyn std::error::Error>>{
    println!("Sending strobe packets...");
    loop {
        dmx.set_channels([255; 512]);
        dmx.update()?;
        dmx.set_channels([0; 512]);
        dmx.update()?;
    }
}

examples/sync_strobe.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>>{
    let mut dmx = DMXSerial::open("COM3").unwrap();
    dmx.set_sync();
    //strobe
    loop {
        dmx.set_channels([255; 512]);
        dmx.update()?;
        dmx.set_channels([0; 512]);
        dmx.update()?;
    }
}

pub fn update_async(&self) -> Result<(), DMXDisconnectionError>

Updates the DMX data but returns immediately.

Useless in async mode.

pub fn set_sync(&mut self)

Sets the DMX mode to sync.

Examples found in repository

examples/sync_strobe.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>>{
    let mut dmx = DMXSerial::open("COM3").unwrap();
    dmx.set_sync();
    //strobe
    loop {
        dmx.set_channels([255; 512]);
        dmx.update()?;
        dmx.set_channels([0; 512]);
        dmx.update()?;
    }
}

examples/reopen.rs (line 5)

fn main() {
    let mut dmx = DMXSerial::open("COM3").unwrap();
    dmx.set_sync();
    loop {
        let _ = strobe(&mut dmx);
        println!("Device has been disconnected! Reopening...");
        match dmx.reopen() {
            Ok(_) => println!("Device has been reopened!"),
            Err(e) => {
                println!("Error reopening device: {}", e);
                println!("Waiting 1 second before trying again...");
                std::thread::sleep(std::time::Duration::from_secs(1));
            },
        }
    }
}

pub fn set_async(&mut self)

Sets the DMX mode to async.

pub fn is_sync(&self) -> bool

Returns true if the DMX mode is sync.

pub fn is_async(&self) -> bool

Returns true if the DMX mode is async.

pub fn set_packet_time(&mut self, time: Duration)

Sets the minimum Duration between two DMX packets.

Default

• 22.7 ms

Some devices may require a longer time between two packets.

See the DMX512-Standard for timing.

pub fn get_packet_time(&self) -> Duration

Returns the minimum Duration between two DMX packets.

pub fn check_agent(&self) -> Result<(), DMXDisconnectionError>

Checks if the DMXSerial device is still connected.

Example

Basic usage:

assert!(dmx.check_agent().is_ok()); // If not, the device got disconnected

Trait Implementations

impl Debug for DMXSerial

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.