nifpga-dll-rs,

Interface to NI FPGAs for Windows using the APIs of the library NiFpga.dll.

It allows to open a NI FPGA session, read and set registers, and read data out from FIFOs!!

The nifpga-dll-rs project is released under MIT License. It is derived and uses code from the two projects: - nifpga-rs https://github.com/DBTaylor/nifpga-rs author David Taylor released on crates.io under MIT License and - ni-fpga-rs https://github.com/first-rust-competition/ni-fpga-rs under MIT License and it is available on crates.io author Connor Worley.

FAQ

Where I can find the signature of my FPGA bit file?

The NI FPGA .lvbitx files are XML text files. The signature that you need to open the FPGA Session you can find in the .lvbitx file by searching for <SignatureRegister>.

An example of usage:

```rust extern crate nifpga_dll;

use nifpga::{NifpgaError, Session};

fn main() -> Result<(), NifpgaError>{ //open the session //it will be closed when it goes out of scope let session = Session::open( "/home/admin/fpga.lvbitx", "0DA1668CDC2C6C492F1437AE6DC2151E",//signature search in the .lvbitx "RIO0", true, //run on open true //reset on close )?;

//reserve an IRQ context and wait on IRQ 0
//the context will be unreserved when it goes out of scope
session.reserve_irq_context()?.wait_on_irqs(1, 1000)?;

//acknowledge IRQ 0
session.acknowledge_irqs(1)?;

//open a target-to-host FIFO
//this configures the FIFO and starts it
//it will be stopped when it goes out of scope
let (reader, _) = session.open_read_fifo::<f32>(0, 100)?;

//open a host-to-target FIFO
let (writer, _) = session.open_write_fifo::<f32>(1, 100)?;

//write 2 values to the FIFO
writer.write(&[5.0, 5.0], 1000)?;

// unsafe{
//     //acquire 4 elements in the host write buffer
//     //these elements will not be sent to the target until they go out of scope
//     //this method is unsafe because elements must be dropped in the order they are acquired
//     let( elements, _, _) = writer.acquire_elements(4, 1000)?;
//     elements.slice.iter_mut().for_each(|el| {*el = 1.0});
// }

//read 3 elements from the FIFO
let mut read_buff = [0.0; 3];
reader.read(&mut read_buff, 1000)?;
println!("{:?}", read_buff);
// unsafe{
//     //acquire 3 elements in the host read buffer
//     //this section of the buffer will not be available for the FIFO until these elements are dropped
//     //this method is unsafe because elements must be dropped in the order they are acquired
//     let(elements, _, _) = reader.acquire_elements(3, 1000)?;
//     println!("{:?}", elements.slice)
// }

//write to control x18004
session.write::<f32>(0x18004, 5.0)?;
//read from indicator x1800C
println!("{:?}", session.read::<f32>(0x1800C)?);

//write contents of array to control x18000
let array = [5.0, 5.0];
session.write_array::<f32>(0x18000, &array)?;

//read indicator 0x18008 into array
let mut array = [0.0; 2];
session.read_array::<f32>(0x18008, &mut array)?;
println!("{:?}", array);

Ok(())

} ```