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
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181

#![allow(dead_code)]
use std::os::raw::c_char;

pub type Offset = u32;
pub type Session = u32;
pub type Status = i32;

#[link(name = "NiFpga")]
extern "C" {
    #[link_name = "NiFpgaDll_Open"]
    pub fn Open(
        bitfile: *const c_char,
        signature: *const c_char,
        resource: *const c_char,
        attribute: u32,
        session: *mut Session,
    ) -> Status;
    #[link_name = "NiFpgaDll_Close"]
    pub fn Close(session: Session, attribute: u32) -> Status;

    #[link_name = "NiFpgaDll_ReadBool"]
    pub fn ReadBool(session: Session, indicator: Offset, value: *mut bool) -> Status;
    #[link_name = "NiFpgaDll_ReadArrayBool"]
    pub fn ReadArrayBool(
        session: Session,
        indicator: Offset,
        array: *mut bool,
        size: usize,
    ) -> Status;
    #[link_name = "NiFpgaDll_WriteBool"]
    pub fn WriteBool(session: Session, indicator: Offset, value: bool) -> Status;
    #[link_name = "NiFpgaDll_WriteArrayBool"]
    pub fn WriteArrayBool(
        session: Session,
        indicator: Offset,
        array: *const bool,
        size: usize,
    ) -> Status;

    #[link_name = "NiFpgaDll_ReadU8"]
    pub fn ReadU8(session: Session, indicator: Offset, value: *mut u8) -> Status;
    #[link_name = "NiFpgaDll_ReadArrayU8"]
    pub fn ReadArrayU8(session: Session, indicator: Offset, array: *mut u8, size: usize) -> Status;
    #[link_name = "NiFpgaDll_WriteU8"]
    pub fn WriteU8(session: Session, indicator: Offset, value: u8) -> Status;
    #[link_name = "NiFpgaDll_WriteArrayU8"]
    pub fn WriteArrayU8(
        session: Session,
        indicator: Offset,
        array: *const u8,
        size: usize,
    ) -> Status;

    #[link_name = "NiFpgaDll_ReadU16"]
    pub fn ReadU16(session: Session, indicator: Offset, value: *mut u16) -> Status;
    #[link_name = "NiFpgaDll_ReadArrayU16"]
    pub fn ReadArrayU16(
        session: Session,
        indicator: Offset,
        array: *mut u16,
        size: usize,
    ) -> Status;
    #[link_name = "NiFpgaDll_WriteU16"]
    pub fn WriteU16(session: Session, indicator: Offset, value: u16) -> Status;
    #[link_name = "NiFpgaDll_WriteArrayU16"]
    pub fn WriteArrayU16(
        session: Session,
        indicator: Offset,
        array: *const u16,
        size: usize,
    ) -> Status;

    #[link_name = "NiFpgaDll_ReadU32"]
    pub fn ReadU32(session: Session, indicator: Offset, value: *mut u32) -> Status;
    #[link_name = "NiFpgaDll_ReadArrayU32"]
    pub fn ReadArrayU32(
        session: Session,
        indicator: Offset,
        array: *mut u32,
        size: usize,
    ) -> Status;
    #[link_name = "NiFpgaDll_WriteU32"]
    pub fn WriteU32(session: Session, indicator: Offset, value: u32) -> Status;
    #[link_name = "NiFpgaDll_WriteArrayU32"]
    pub fn WriteArrayU32(
        session: Session,
        indicator: Offset,
        array: *const u32,
        size: usize,
    ) -> Status;

    #[link_name = "NiFpgaDll_ReadU64"]
    pub fn ReadU64(session: Session, indicator: Offset, value: *mut u64) -> Status;
    #[link_name = "NiFpgaDll_ReadArrayU64"]
    pub fn ReadArrayU64(
        session: Session,
        indicator: Offset,
        array: *mut u64,
        size: usize,
    ) -> Status;
    #[link_name = "NiFpgaDll_WriteU64"]
    pub fn WriteU64(session: Session, indicator: Offset, value: u64) -> Status;
    #[link_name = "NiFpgaDll_WriteArrayU64"]
    pub fn WriteArrayU64(
        session: Session,
        indicator: Offset,
        array: *const u64,
        size: usize,
    ) -> Status;

    #[link_name = "NiFpgaDll_ReadI8"]
    pub fn ReadI8(session: Session, indicator: Offset, value: *mut i8) -> Status;
    #[link_name = "NiFpgaDll_ReadArrayI8"]
    pub fn ReadArrayI8(session: Session, indicator: Offset, array: *mut i8, size: usize) -> Status;
    #[link_name = "NiFpgaDll_WriteI8"]
    pub fn WriteI8(session: Session, indicator: Offset, value: i8) -> Status;
    #[link_name = "NiFpgaDll_WriteArrayI8"]
    pub fn WriteArrayI8(
        session: Session,
        indicator: Offset,
        array: *const i8,
        size: usize,
    ) -> Status;

    #[link_name = "NiFpgaDll_ReadI16"]
    pub fn ReadI16(session: Session, indicator: Offset, value: *mut i16) -> Status;
    #[link_name = "NiFpgaDll_ReadArrayI16"]
    pub fn ReadArrayI16(
        session: Session,
        indicator: Offset,
        array: *mut i16,
        size: usize,
    ) -> Status;
    #[link_name = "NiFpgaDll_WriteI16"]
    pub fn WriteI16(session: Session, indicator: Offset, value: i16) -> Status;
    #[link_name = "NiFpgaDll_WriteArrayI16"]
    pub fn WriteArrayI16(
        session: Session,
        indicator: Offset,
        array: *const i16,
        size: usize,
    ) -> Status;

    #[link_name = "NiFpgaDll_ReadI32"]
    pub fn ReadI32(session: Session, indicator: Offset, value: *mut i32) -> Status;
    #[link_name = "NiFpgaDll_ReadArrayI32"]
    pub fn ReadArrayI32(
        session: Session,
        indicator: Offset,
        array: *mut i32,
        size: usize,
    ) -> Status;
    #[link_name = "NiFpgaDll_WriteI32"]
    pub fn WriteI32(session: Session, indicator: Offset, value: i32) -> Status;
    #[link_name = "NiFpgaDll_WriteArrayI32"]
    pub fn WriteArrayI32(
        session: Session,
        indicator: Offset,
        array: *const i32,
        size: usize,
    ) -> Status;

    #[link_name = "NiFpgaDll_ReadI64"]
    pub fn ReadI64(session: Session, indicator: Offset, value: *mut i64) -> Status;
    #[link_name = "NiFpgaDll_ReadArrayI64"]
    pub fn ReadArrayI64(
        session: Session,
        indicator: Offset,
        array: *mut i64,
        size: usize,
    ) -> Status;
    #[link_name = "NiFpgaDll_WriteI64"]
    pub fn WriteI64(session: Session, indicator: Offset, value: i64) -> Status;
    #[link_name = "NiFpgaDll_WriteArrayI64"]
    pub fn WriteArrayI64(
        session: Session,
        indicator: Offset,
        array: *const i64,
        size: usize,
    ) -> Status;
}