├── LICENSE.MIT
├── LimeSuite_Build_Thunk.h
├── README.md
├── libLimeSuite__proto.m
├── limeSDR.m
├── limeSDR_Simulink.m
└── limeSDR_XCVR.m


/LICENSE.MIT:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2016-2017 JiangWei
 2 | Copyright (c) 2013-2015 Nuand LLC
 3 | 
 4 | Permission is hereby granted, free of charge, to any person obtaining a copy
 5 | of this software and associated documentation files (the "Software"), to deal
 6 | in the Software without restriction, including without limitation the rights
 7 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 8 | copies of the Software, and to permit persons to whom the Software is
 9 | furnished to do so, subject to the following conditions:
10 | 
11 | The above copyright notice and this permission notice shall be included in
12 | all copies or substantial portions of the Software.
13 | 
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
20 | THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/LimeSuite_Build_Thunk.h:
--------------------------------------------------------------------------------
   1 | /**
   2 |  * @file lime/LimeSuite.h
   3 |  *
   4 |  * @brief LMS API library
   5 |  *
   6 |  * Copyright (C) 2016 Lime Microsystems
   7 |  *
   8 |  * Licensed under the Apache License, Version 2.0 (the "License");
   9 |  * you may not use this file except in compliance with the License.
  10 |  * You may obtain a copy of the License at
  11 |  *
  12 |  *     http://www.apache.org/licenses/LICENSE-2.0
  13 |  *
  14 |  * Unless required by applicable law or agreed to in writing, software
  15 |  * distributed under the License is distributed on an "AS IS" BASIS,
  16 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17 |  * See the License for the specific language governing permissions and
  18 |  * limitations under the License.
  19 |  */
  20 | 
  21 | #ifndef LMS7_API_H
  22 | #define LMS7_API_H
  23 | 
  24 | #include <stdint.h>
  25 | #include <stdlib.h>
  26 | 
  27 | #ifdef __cplusplus
  28 | extern "C" {
  29 | #else
  30 | /* stdbool.h is not applicable for C++ programs, as the language inherently
  31 |  * provides the bool type.
  32 |  *
  33 |  * Users of Visual Studio 2012 and earlier will need to supply a stdbool.h
  34 |  * implementation, as it is not included with the toolchain. Visual Studio 2013
  35 |  * onward supplies this header.
  36 |  */
  37 | #include <stdbool.h>
  38 | #endif
  39 | 
  40 | #if defined _WIN32 || defined __CYGWIN__
  41 | #   include <windows.h>
  42 | #   define CALL_CONV __cdecl
  43 | #   ifdef __GNUC__
  44 | #       define API_EXPORT __attribute__ ((dllexport))
  45 | #   else
  46 | #       define API_EXPORT __declspec(dllexport)
  47 | #   endif
  48 | #elif defined _DOXYGEN_ONLY_
  49 |     /** Marks an API routine to be made visible to the dynamic loader.
  50 |      *  This is OS and/or compiler-specific. */
  51 | #   define API_EXPORT
  52 |     /** Specifies calling convention, if necessary.
  53 |      *  This is OS and/or compiler-specific. */
  54 | #   define CALL_CONV
  55 | #else
  56 | #   define API_EXPORT __attribute__ ((visibility ("default")))
  57 | #   define CALL_CONV
  58 | #endif
  59 | 
  60 | ///Floating point data type
  61 | typedef double float_type;
  62 | 
  63 | ///convenience constant for good return code
  64 | static const int LMS_SUCCESS = 0;
  65 | 
  66 | /**
  67 |  * @defgroup FN_INIT    Initialization/deinitialization
  68 |  *
  69 |  * The functions in this section provide the ability to query available devices,
  70 |  * initialize them, and deinitialize them.
  71 |  * @{
  72 |  */
  73 | 
  74 | ///LMS Device handle
  75 | typedef void lms_device_t;
  76 | 
  77 | ///Convenience type for fixed length LMS Device information string
  78 | typedef char lms_info_str_t[256];
  79 | 
  80 | /**
  81 |  * Obtain a list of LMS devices attached to the system
  82 |  *
  83 |  * @param[out]  dev_list    List of available devices
  84 |  *
  85 |  * @return      number of devices in the list on success, (-1) on failure
  86 |  */
  87 | API_EXPORT int CALL_CONV LMS_GetDeviceList(lms_info_str_t *dev_list);
  88 | 
  89 | /**
  90 |  * Opens device specified by the provided ::lms_info_str_t string
  91 |  * This function should be used to open a device based upon the results of
  92 |  * LMS_GetDeviceList()
  93 |  *
  94 |  * @pre device should be initialized to NULL
  95 |  *
  96 |  * @param[out]  device      Updated with device handle on success
  97 |  * @param[in]   info        Device information string. If NULL, the first
  98 |  *                          available device will be opened.
  99 |  * @param[in]   args        additional arguments. Can be NULL.
 100 |  *
 101 |  * @return      0 on success, (-1) on failure
 102 |  */
 103 | API_EXPORT int CALL_CONV LMS_Open(lms_device_t **device, const lms_info_str_t info,
 104 |                                                          void* args);
 105 | 
 106 | /**
 107 |  * Close device
 108 |  *
 109 |  * @post     device is deallocated and may no longer be used.
 110 |  *
 111 |  * @param    device  Device handle previously obtained by LMS_Open().
 112 |  *
 113 |  * @return   0 on success, (-1) on failure
 114 |  */
 115 | API_EXPORT int CALL_CONV LMS_Close(lms_device_t *device);
 116 | 
 117 | /**
 118 |  * Disconnect device but keep configuration cache (device is not deallocated).
 119 |  *
 120 |  * @param   device  Device handle previously obtained by LMS_Open().
 121 |  *
 122 |  * @return   0 on success, (-1) on failure
 123 |  */
 124 | API_EXPORT int CALL_CONV LMS_Disconnect(lms_device_t *device);
 125 | 
 126 | /**
 127 |  * Check if device port is opened
 128 |  *
 129 |  * @param   device  Device handle previously obtained by LMS_Open().
 130 |  * @param   port    port index (ignored if device has only 1 port)
 131 |  *
 132 |  * @return   true(1) if port is open, false (0) if - closed
 133 |  */
 134 | API_EXPORT bool CALL_CONV LMS_IsOpen(lms_device_t *device, int port);
 135 | 
 136 | /** @} (End FN_INIT) */
 137 | 
 138 | /**
 139 |  * @defgroup FN_HIGH_LVL    High-level control functions
 140 |  *
 141 |  * The functions in this section provide the ability to easily configure the
 142 |  * device for operation.
 143 |  *
 144 |  * @{
 145 |  */
 146 | 
 147 | static const bool LMS_CH_TX = true;   ///<Convenience constants for TX selection
 148 | static const bool LMS_CH_RX = false;  ///<Convenience constants for RX selection
 149 | 
 150 | /** Convenience type for fixed length name string*/
 151 | typedef char lms_name_t[16];
 152 | 
 153 | /**Structure used to represent the allowed value range of various parameters*/
 154 | typedef struct
 155 | {
 156 |     float_type min;     ///<Minimum allowed value
 157 |     float_type max;     ///<Minimum allowed value
 158 |     float_type step;    ///<Minimum value step
 159 | }lms_range_t;
 160 | 
 161 | /**Enumeration of LMS7 TEST signal types*/
 162 | typedef enum
 163 | {
 164 |     LMS_TESTSIG_NONE=0,     ///<Disable test signals. Return to normal operation
 165 |     LMS_TESTSIG_NCODIV8,    ///<Test signal from NCO half scale
 166 |     LMS_TESTSIG_NCODIV4,    ///<Test signal from NCO half scale
 167 |     LMS_TESTSIG_NCODIV8F,   ///<Test signal from NCO full scale
 168 |     LMS_TESTSIG_NCODIV4F,   ///<Test signal from NCO full scale
 169 |     LMS_TESTSIG_DC          ///<DC test signal
 170 | }lms_testsig_t;
 171 | 
 172 | /**
 173 |  * Configure LMS chip with settings that make it ready for operation.
 174 |  *
 175 |  * @note This configuration differs from default LMS chip configuration which is
 176 |  * described in chip datasheet. In order to load default chip configuration use
 177 |  * LMS_Reset().
 178 |  *
 179 |  * @param[in]   device  Device handle previously obtained by LMS_Open().
 180 |  *
 181 |  * @return      0 on success, (-1) on failure
 182 |  */
 183 | API_EXPORT int CALL_CONV LMS_Init(lms_device_t *device);
 184 | 
 185 | /**
 186 |  * Obtain number of RX or TX channels. Use this to determine the maximum
 187 |  * channel index (specifying channel index is required by most API functions).
 188 |  * The maximum channel index is N-1, where N is number returned by this function
 189 |  *
 190 |  * @param device    Device handle previously obtained by LMS_Open().
 191 |  * @param dir_tx    Select RX or TX
 192 |  *
 193 |  * @return          Number of channels on success, (-1) on failure
 194 |  */
 195 | API_EXPORT int CALL_CONV LMS_GetNumChannels(lms_device_t *device, bool dir_tx);
 196 | 
 197 | /**
 198 |  * Enable or disable specified RX channel.
 199 |  *
 200 |  * @param[in]   device      Device handle previously obtained by LMS_Open().
 201 |  * @param       dir_tx      Select RX or TX
 202 |  * @param       chan        Channel index
 203 |  * @param       enabled     true(1) to enable, false(0) to disable.
 204 |  *
 205 |  * @return      0 on success, (-1) on failure
 206 |  */
 207 | API_EXPORT int CALL_CONV LMS_EnableChannel(lms_device_t *device, bool dir_tx,
 208 |                                            size_t chan, bool enabled);
 209 | 
 210 | /**
 211 |  * Set sampling rate for all RX/TX channels. Sample rate is in complex samples
 212 |  * (1 sample = I + Q). The function sets sampling rate that is used for data
 213 |  * exchange with the host. It also allows to specify higher sampling rate to be
 214 |  * used in RF by setting oversampling ratio. Valid oversampling values are 1, 2,
 215 |  * 4, 8, 16, 32 or 0 (use device default oversampling value).
 216 |  *
 217 |  * @param[in]   device      Device handle previously obtained by LMS_Open().
 218 |  * @param       rate        sampling rate in Hz to set
 219 |  * @param       oversample  RF oversampling ratio.
 220 |  *
 221 |  * @return      0 on success, (-1) on failure
 222 |  */
 223 | API_EXPORT int CALL_CONV LMS_SetSampleRate(lms_device_t *device, float_type rate,
 224 |                                            size_t oversample);
 225 | 
 226 | /**
 227 |  * Get the sampling rate of the specified RX or TX channel.
 228 |  * The function obtains the sample rate used in data interface with the host and
 229 |  * the RF sample rate used by DAC/ADC.
 230 |  *
 231 |  * @param[in]   device      Device handle previously obtained by LMS_Open().
 232 |  * @param       dir_tx      Select RX or TX
 233 |  * @param       chan        Channel index
 234 |  * @param[out]  host_Hz     sampling rate used for data exchange with the host
 235 |  * @param[out]  rf_Hz       RF sampling rate in Hz
 236 |  *
 237 |  * @return       0 on success, (-1) on failure
 238 |  */
 239 | API_EXPORT int CALL_CONV LMS_GetSampleRate(lms_device_t *device, bool dir_tx,
 240 |                            size_t chan, float_type *host_Hz, float_type *rf_Hz);
 241 | /**
 242 |  * Get the range of supported sampling rates.
 243 |  *
 244 |  * @param      device   Device handle previously obtained by LMS_Open().
 245 |  * @param      dir_tx   Select RX or TX
 246 |  * @param[out] range    Allowed sample rate range in Hz.
 247 |  *
 248 |  * @return              0 on success, (-1) on failure
 249 |  */
 250 | API_EXPORT int CALL_CONV LMS_GetSampleRateRange(lms_device_t *device, bool dir_tx,
 251 |                                                 lms_range_t *range);
 252 | 
 253 | /**
 254 |  * Set RF center frequency in Hz.
 255 |  *
 256 |  * @note setting different frequencies for A and B channels is not supported by
 257 |  * LMS7 chip. Changing frequency for one (A or B) channel will result in
 258 |  * frequency being changed for both (A and B) channels.
 259 |  *
 260 |  * @param   device      Device handle previously obtained by LMS_Open().
 261 |  * @param   dir_tx      Select RX or TX
 262 |  * @param   chan        Channel index
 263 |  * @param   frequency   Desired RF center frequency in Hz
 264 |  *
 265 |  * @return  0 on success, (-1) on failure
 266 |  */
 267 | API_EXPORT int CALL_CONV LMS_SetLOFrequency(lms_device_t *device, bool dir_tx,
 268 |                                             size_t chan, float_type frequency);
 269 | 
 270 | /**
 271 |  * Obtain the current RF center frequency in Hz.
 272 |  *
 273 |  * @param       device      Device handle previously obtained by LMS_Open().
 274 |  * @param       dir_tx      Select RX or TX
 275 |  * @param       chan        Channel index
 276 |  * @param[out]  frequency   Current RF center frequency in Hz
 277 |  *
 278 |  * @return      0 on success, (-1) on failure
 279 |  */
 280 | API_EXPORT int CALL_CONV LMS_GetLOFrequency(lms_device_t *device, bool dir_tx,
 281 |                                             size_t chan, float_type *frequency);
 282 | 
 283 | /**
 284 |  * Obtain the supported RF center frequency range in Hz.
 285 |  *
 286 |  * @param       device      Device handle previously obtained by LMS_Open().
 287 |  * @param       dir_tx      Select RX or TX
 288 |  * @param[out]  range       Supported RF center frequency in Hz
 289 |  *
 290 |  * @return      0 on success, (-1) on failure
 291 |  */
 292 | API_EXPORT int CALL_CONV LMS_GetLOFrequencyRange(lms_device_t *device, bool dir_tx,
 293 |                                                  lms_range_t *range);
 294 | 
 295 | /**
 296 |  * Obtain antenna list with names. First item in the list is the name of antenna
 297 |  * index 0.
 298 |  *
 299 |  * @param       dev     Device handle previously obtained by LMS_Open().
 300 |  * @param       dir_tx  Select RX or TX
 301 |  * @param       chan    channel index
 302 |  * @param[out]  list    List of antenna names (can be NULL)
 303 |  *
 304 |  * @return      number of available antennae, (-1) on failure
 305 |  */
 306 | API_EXPORT int CALL_CONV LMS_GetAntennaList(lms_device_t *dev, bool dir_tx,
 307 |                                             size_t chan, lms_name_t *list);
 308 | 
 309 | /**
 310 |  * Select the antenna for the specified RX or TX channel.
 311 |  *
 312 |  * @param       dev     Device handle previously obtained by LMS_Open().
 313 |  * @param       dir_tx  Select RX or TX
 314 |  * @param       chan    channel index
 315 |  * @param       index   Index of antenna to select
 316 |  *
 317 |  * @return      0 on success, (-1) on failure
 318 |  */
 319 | API_EXPORT int CALL_CONV LMS_SetAntenna(lms_device_t *dev, bool dir_tx,
 320 |                                         size_t chan, size_t index);
 321 | 
 322 | /**
 323 |  * Obtain currently selected antenna of the the specified RX or TX channel.
 324 |  *
 325 |  * @param dev       Device handle previously obtained by LMS_Open().
 326 |  * @param dir_tx    Select RX or TX
 327 |  * @param chan      channel index
 328 |  *
 329 |  * @return      Index of selected antenna on success, (-1) on failure
 330 |  */
 331 | API_EXPORT int CALL_CONV LMS_GetAntenna(lms_device_t *dev, bool dir_tx,
 332 |                                         size_t chan);
 333 | 
 334 | /**
 335 |  * Obtains bandwidth (lower and upper frequency) of the specified antenna
 336 |  *
 337 |  * @param       dev     Device handle previously obtained by LMS_Open().
 338 |  * @param       dir_tx  Select RX or TX
 339 |  * @param       chan    channel index
 340 |  * @param       index   Antenna index
 341 |  * @param[out]  range   Antenna bandwidth
 342 |  *
 343 |  * @return      0 on success, (-1) on failure
 344 |  */
 345 | API_EXPORT int CALL_CONV LMS_GetAntennaBW(lms_device_t *dev, bool dir_tx,
 346 |                                  size_t chan, size_t index, lms_range_t *range);
 347 | 
 348 | /**
 349 |  * Set the combined gain value
 350 |  * This function computes and sets the optimal gain values of various amplifiers
 351 |  * that are present in the device based on desired normalized gain value.
 352 |  *
 353 |  * @note actual gain depends on LO frequency and analog LPF configuration and
 354 |  * resulting output signal level may be different when those values are changed
 355 |  *
 356 |  * @param   device      Device handle previously obtained by LMS_Open().
 357 |  * @param   dir_tx      Select RX or TX
 358 |  * @param   chan        Channel index
 359 |  * @param   gain        Desired gain, range [0, 1.0], where 1.0 represents the
 360 |  *                      maximum gain
 361 |  * @return  0 on success, (-1) on failure
 362 |  */
 363 | API_EXPORT int CALL_CONV LMS_SetNormalizedGain(lms_device_t *device, bool dir_tx,
 364 |                                                size_t chan,float_type gain);
 365 | 
 366 | /**
 367 |  * Set the combined gain value in dB
 368 |  * This function computes and sets the optimal gain values of various amplifiers
 369 |  * that are present in the device based on desired  gain value in dB.
 370 |  *
 371 |  * @note actual gain depends on LO frequency and analog LPF configuration and
 372 |  * resulting output signal levle may be different when those values are changed
 373 |  *
 374 |  * @param   device      Device handle previously obtained by LMS_Open().
 375 |  * @param   dir_tx      Select RX or TX
 376 |  * @param   chan        Channel index
 377 |  * @param   gain        Desired gain, range [0, 70] for RX, [0, 60] for TX
 378 |  * @return  0 on success, (-1) on failure
 379 |  */
 380 | API_EXPORT int CALL_CONV LMS_SetGaindB(lms_device_t *device, bool dir_tx,
 381 |                                         size_t chan, unsigned gain);
 382 | 
 383 | /**
 384 |  * Obtain the current combined gain value
 385 |  *
 386 |  * @note actual gain depends on LO frequency and analog LPF configuration and
 387 |  * resulting output signal level may be different when those values are changed
 388 |  *
 389 |  * @param       device      Device handle previously obtained by LMS_Open().
 390 |  * @param       dir_tx      Select RX or TX
 391 |  * @param       chan        Channel index
 392 |  * @param[out]  gain        Current gain, range [0, 1.0], where 1.0 represents
 393 |  *                          the maximum gain
 394 |  * @return  0 on success, (-1) on failure
 395 |  */
 396 | API_EXPORT int CALL_CONV LMS_GetNormalizedGain(lms_device_t *device, bool dir_tx,
 397 |                                                 size_t chan, float_type *gain);
 398 | /**
 399 |  * Obtain the current combined gain value in dB
 400 |  *
 401 |  * @note actual gain depends on LO frequency and analog LPF configuration and
 402 |  * resulting output signal level may be different when those values are changed
 403 |  *
 404 |  * @param       device      Device handle previously obtained by LMS_Open().
 405 |  * @param       dir_tx      Select RX or TX
 406 |  * @param       chan        Channel index
 407 |  * @param[out]  gain        Current gain, range [0, 70], [0, 60] for TX
 408 |  * @return  0 on success, (-1) on failure
 409 |  */
 410 | API_EXPORT int CALL_CONV LMS_GetGaindB(lms_device_t *device, bool dir_tx,
 411 |                                                 size_t chan, unsigned *gain);
 412 | 
 413 | /**
 414 |  * Configure analog LPF of the LMS chip for the desired RF bandwidth.
 415 |  * This function automatically enables LPF.
 416 |  *
 417 |  * @param   device      Device handle previously obtained by LMS_Open().
 418 |  * @param   dir_tx      Select RX or TX
 419 |  * @param   chan        Channel index
 420 |  * @param   bandwidth   LPF bandwidth in Hz
 421 |  *
 422 |  * @return  0 on success, (-1) on failure
 423 |  */
 424 | API_EXPORT int CALL_CONV LMS_SetLPFBW(lms_device_t *device, bool dir_tx,
 425 |                                              size_t chan, float_type bandwidth);
 426 | 
 427 | /**
 428 |  * Get the currently configured analog LPF RF bandwidth.
 429 |  * @note readback from board is currently not supported, only returns last set
 430 |  * value cached by software.
 431 |  *
 432 |  * @param       device      Device handle previously obtained by LMS_Open().
 433 |  * @param       dir_tx      Select RX or TX
 434 |  * @param       chan        Channel index
 435 |  * @param[out]  bandwidth   Current LPF bandwidth in Hz
 436 |  *
 437 |  * @return  0 on success, (-1) on failure
 438 |  */
 439 | API_EXPORT int CALL_CONV LMS_GetLPFBW(lms_device_t *device, bool dir_tx,
 440 |                                             size_t chan, float_type *bandwidth);
 441 | 
 442 | /**
 443 |  * Get the RF bandwidth setting range supported by the analog LPF of LMS chip.
 444 |  *
 445 |  * @param       device      Device handle previously obtained by LMS_Open().
 446 |  * @param       dir_tx      Select RX or TX
 447 |  * @param[out]  range       Supported RF bandwidth range in Hz
 448 |  *
 449 |  * @return  0 on success, (-1) on failure
 450 |  */
 451 | API_EXPORT int CALL_CONV LMS_GetLPFBWRange(lms_device_t *device, bool dir_tx,
 452 |                                             lms_range_t *range);
 453 | 
 454 | /**
 455 |  * Disables or enables the analog LPF of LMS chip without reconfiguring it.
 456 |  *
 457 |  * @param   device      Device handle previously obtained by LMS_Open().
 458 |  * @param   dir_tx      Select RX or TX
 459 |  * @param   chan        Channel index
 460 |  * @param   enable      true(1) to enable, false(0) to disable
 461 |  *
 462 |  * @return  0 on success, (-1) on failure
 463 |  */
 464 | API_EXPORT int CALL_CONV LMS_SetLPF(lms_device_t *device, bool dir_tx,
 465 |                                     size_t chan, bool enable);
 466 | 
 467 | /**
 468 |  * Set up digital LPF using LMS chip GFIRS. This is a convenience function to
 469 |  * quickly configure GFIRS as LPF with desired RF bandwidth.
 470 |  *
 471 |  * @pre sampling rate must be set
 472 |  *
 473 |  * @param  device      Device handle previously obtained by LMS_Open().
 474 |  * @param  dir_tx      Select RX or TX
 475 |  * @param  chan        channel index
 476 |  * @param  enabled     Disable (false) or enable (true) GFIRS.
 477 |  * @param  bandwidth   LPF bandwidth in Hz. Has no effect if enabled is false.
 478 |  *
 479 |  * @return  0 on success, (-1) on failure
 480 |  */
 481 | API_EXPORT int CALL_CONV LMS_SetGFIRLPF(lms_device_t *device, bool dir_tx,
 482 |                                size_t chan, bool enabled, float_type bandwidth);
 483 | 
 484 | /**
 485 |  * Perform the automatic calibration of specified RX/TX channel. The automatic
 486 |  * calibration must be run after device configuration is finished because
 487 |  * calibration values are dependant on various configuration settings.
 488 |  *
 489 |  * @pre Device should be configured
 490 |  *
 491 |  * @param   device      Device handle previously obtained by LMS_Open().
 492 |  * @param   dir_tx      Select RX or TX
 493 |  * @param   chan        channel index
 494 |  * @param   bw          bandwidth
 495 |  * @param   flags       additional calibration flags (normally should be 0)
 496 |  *
 497 |  * @return  0 on success, (-1) on failure
 498 |  */
 499 | API_EXPORT int CALL_CONV LMS_Calibrate(lms_device_t *device, bool dir_tx,
 500 |                                         size_t chan, double bw, unsigned flags);
 501 | 
 502 | /**
 503 |  * Load LMS chip configuration from a file
 504 |  *
 505 |  * @note this only loads LMS chip configuration, in oder for streaming to work
 506 |  * properly FPGA has also to be configured. Use LMS_SetSampleRate() to configure
 507 |  * LMS and FPGA for streaming.
 508 |  *
 509 |  * @param   device      Device handle
 510 |  * @param   filename    path to file
 511 |  *
 512 |  * @return  0 on success, (-1) on failure
 513 |  */
 514 | API_EXPORT int CALL_CONV LMS_LoadConfig(lms_device_t *device, const char *filename);
 515 | 
 516 | /**
 517 |  * Save LMS chip configuration to a file
 518 |  *
 519 |  * @param   device      Device handle
 520 |  * @param   filename    path to file with LMS chip configuration
 521 |  *
 522 |  * @return  0 on success, (-1) on failure
 523 |  */
 524 | API_EXPORT int CALL_CONV LMS_SaveConfig(lms_device_t *device, const char *filename);
 525 | 
 526 | /**
 527 |  * Apply the specified test signal
 528 |  *
 529 |  * @param   device  Device handle previously obtained by LMS_Open().
 530 |  * @param   dir_tx  Select RX or TX.
 531 |  * @param   chan    Channel index.
 532 |  * @param   sig     Test signal. LMS_TESTSIG_NONE disables test signal.
 533 |  * @param   dc_i    DC I value for LMS_TESTSIG_DC mode. Ignored in other modes.
 534 |  * @param   dc_q    DC Q value for LMS_TESTSIG_DC mode. Ignored in other modes.
 535 |  *
 536 |  * @return  0 on success, (-1) on failure
 537 |  */
 538 | API_EXPORT int CALL_CONV LMS_SetTestSignal(lms_device_t *device, bool dir_tx,
 539 |                     size_t chan, lms_testsig_t sig, int16_t dc_i, int16_t dc_q);
 540 | /**
 541 |  * Get the currently active test signal
 542 |  *
 543 |  * @param   device      Device handle previously obtained by LMS_Open().
 544 |  * @param   dir_tx      Select RX or TX
 545 |  * @param   chan        Channel index
 546 |  * @param   sig         Currently active test signal
 547 |  *
 548 |  * @return  0 on success, (-1) on failure
 549 |  */
 550 | API_EXPORT int CALL_CONV LMS_GetTestSignal(lms_device_t *device, bool dir_tx,
 551 |                                                size_t chan, lms_testsig_t *sig);
 552 | 
 553 | /** @} (End FN_HIGH_LVL) */
 554 | 
 555 | /**
 556 |  * @defgroup FN_ADVANCED    Advanced control functions
 557 |  *
 558 |  * The functions in this section provides some additional control compared to
 559 |  * High-Level functions. They are labeled advanced because they require better
 560 |  * understanding of hardware and provide functionality that may conflict with
 561 |  * certain High-Level functions.
 562 |  * @{
 563 |  */
 564 | 
 565 | ///Enumeration of LMS7 GFIRS
 566 | typedef enum
 567 | {
 568 |     LMS_GFIR1 = 0,
 569 |     LMS_GFIR2,
 570 |     LMS_GFIR3
 571 | }lms_gfir_t;
 572 | 
 573 | ///Number of NCO frequency/phase offset values
 574 | static const int LMS_NCO_VAL_COUNT = 16;
 575 | 
 576 | /**
 577 |  * Set sampling rate for all RX or TX channels. Sample rate is in complex
 578 |  * samples (1 sample = I + Q). The function sets sampling rate that is used for
 579 |  * data exchange with the host. It also allows to specify higher sampling rate
 580 |  * to be used in RF by setting oversampling ratio. Valid oversampling values are
 581 |  * 1, 2, 4, 8, 16, 32 or 0 (use device default oversampling value).
 582 |  *
 583 |  * @note RX and TX rates sampling are closely tied in LMS7 chip. Changing RX or
 584 |  * TX will often result in change of both (RX and TX). RX/TX ratio can only be
 585 |  * power of 2 and is also limited by other factors. Use LMS_GetSampleRate() to
 586 |  * obtain actual sample rate values. The function returns success if it is able
 587 |  * to achieve  desired sample rate and oversampling for the specified direction
 588 |  * (RX or TX) ignoring possible value changes in other direction channels.
 589 |  *
 590 |  * @param[in]   device      Device handle previously obtained by LMS_Open().
 591 |  * @param       dir_tx      Select RX or TX
 592 |  * @param       rate        Sampling rate in Hz to set
 593 |  * @param       oversample  RF oversampling ratio.
 594 |  *
 595 |  * @return      0 on success, (-1) on failure
 596 |  */
 597 | API_EXPORT int CALL_CONV LMS_SetSampleRateDir(lms_device_t *device, bool dir_tx,
 598 |                                             float_type rate, size_t oversample);
 599 | 
 600 | /**
 601 |  * Configure NCO to operate in FCW mode. Configures NCO with up to 16
 602 |  * frequencies that can be quickly switched between.
 603 |  * Automatically starts NCO with frequency at index 0
 604 |  * Use LMS_SetNCOindex() to switch between NCO frequencies.
 605 |  *
 606 |  * @param       device     Device handle previously obtained by LMS_Open().
 607 |  * @param       dir_tx     Select RX or TX
 608 |  * @param       chan       Channel index
 609 |  * @param[in]   freq       List of NCO frequencies. Values cannot be negative.
 610 |  *                         Must be at least ::LMS_NCO_VAL_COUNT length;
 611 |  * @param       pho        NCO phase offset in deg
 612 |  *
 613 |  * @return      0 on success, (-1) on failure
 614 |  */
 615 | API_EXPORT int CALL_CONV LMS_SetNCOFrequency(lms_device_t *device, bool dir_tx,
 616 |                      size_t chan, const float_type *freq, float_type pho);
 617 | 
 618 | /**
 619 |  * Get the current NCO FCW mode configuration.
 620 |  *
 621 |  * @param       device     Device handle previously obtained by LMS_Open().
 622 |  * @param       dir_tx     Select RX or TX
 623 |  * @param       chan       Channel index
 624 |  * @param[out]  freq       List of NCO frequencies. Must be at least
 625 |  *                         ::LMS_NCO_VAL_COUNT length;
 626 |  * @param[out]  pho        Phase offset in deg
 627 |  *
 628 |  * @return      0 on success, (-1) on failure
 629 |  */
 630 | API_EXPORT int CALL_CONV LMS_GetNCOFrequency(lms_device_t *device, bool dir_tx,
 631 |                           size_t chan, float_type *freq, float_type *pho);
 632 | 
 633 | /**
 634 |  * Configure NCO to operate in PHO mode. Configures NCO with up to 16
 635 |  * phase offsets that can be quickly switched between.
 636 |  * Automatically starts NCO with phase at index 0
 637 |  * Use LMS_SetNCOindex() to switch between NCO phases.
 638 |  *
 639 |  * @param       device     Device handle previously obtained by LMS_Open().
 640 |  * @param       dir_tx     Select RX or TX
 641 |  * @param       chan       Channel index
 642 |  * @param[in]   phases     List of NCO phases. Values cannot be negative.
 643 |  *                         Must be at least ::LMS_NCO_VAL_COUNT length;
 644 |  * @param       fcw        NCO frequency in Hz
 645 |  *
 646 |  * @return      0 on success, (-1) on failure
 647 |  */
 648 | API_EXPORT int CALL_CONV LMS_SetNCOPhase(lms_device_t *device, bool dir_tx,
 649 |                    size_t chan, const float_type *phases, float_type fcw);
 650 | 
 651 | /**
 652 |  * Get the current NCO PHO mode configuration.
 653 |  *
 654 |  * @param       device    Device handle previously obtained by LMS_Open().
 655 |  * @param       dir_tx    Select RX or TX
 656 |  * @param       chan      channel index
 657 |  * @param[out]  phases    List of configured NCO phases
 658 |  *                        Must be at least ::LMS_NCO_VAL_COUNT length;
 659 |  * @param[out]  fcw       Current NCO frequency
 660 |  *
 661 |  * @return      0 on success, (-1) on failure
 662 |  */
 663 | API_EXPORT int CALL_CONV LMS_GetNCOPhase(lms_device_t *device, bool dir_tx,
 664 |                             size_t chan, float_type *phases, float_type *fcw);
 665 | 
 666 | /**
 667 |  * Switches between configured list of NCO frequencies/phase offsets. Also
 668 |  * Allows to switch CMIX mode to either downconvert or upconvert.
 669 |  *
 670 |  * @param device    Device handle previously obtained by LMS_Open().
 671 |  * @param dir_tx    Select RX or TX
 672 |  * @param chan      channel index
 673 |  * @param index     NCO frequency/phase index to activate or (-1) to disable NCO
 674 |  * @param downconv  true(1) CMIX downconvert, false(0) CMIX upconvert
 675 |  *
 676 |  * @return 0 on success, (-1) on failure
 677 |  */
 678 | API_EXPORT int CALL_CONV LMS_SetNCOIndex(lms_device_t *device, bool dir_tx,
 679 |                                     size_t chan, int index, bool downconv);
 680 | 
 681 | /**
 682 |  * Get the currently active NCO frequency/phase offset index
 683 |  *
 684 |  * @param       device    Device handle previously obtained by LMS_Open().
 685 |  * @param       dir_tx    Select RX or TX
 686 |  * @param       chan      Channel index
 687 |  *
 688 |  * @return Current NCO frequency/phase index on success, (-1) on failure
 689 |  */
 690 | API_EXPORT int CALL_CONV LMS_GetNCOIndex(lms_device_t *device, bool dir_tx,
 691 |                                         size_t chan);
 692 | 
 693 | /**
 694 |  * Configure LMS GFIR using specified filter coefficients. Maximum number of
 695 |  * coefficients is 40 for GFIR1 and GFIR2, and 120 for GFIR3.
 696 |  *
 697 |  * @param       device       Device handle previously obtained by LMS_Open().
 698 |  * @param       dir_tx    Select RX or TX
 699 |  * @param       chan      Channel index
 700 |  * @param       filt      GFIR to configure
 701 |  * @param[in]   coef      Array of filter coefficients. Coeff range [-1.0, 1.0].
 702 |  * @param       count     number of filter coefficients.
 703 |  *
 704 |  * @return      0 on success, (-1) on failure
 705 |  */
 706 | API_EXPORT int CALL_CONV LMS_SetGFIRCoeff(lms_device_t * device, bool dir_tx,
 707 |              size_t chan, lms_gfir_t filt, const float_type* coef,size_t count);
 708 | 
 709 | /**
 710 |  * Get currently set GFIR coefficients.
 711 |  *
 712 |  * @param       device       Device handle previously obtained by LMS_Open().
 713 |  * @param       dir_tx    Select RX or TX
 714 |  * @param       chan      Channel index
 715 |  * @param       filt      GFIR to configure
 716 |  * @param[out]  coef      Current GFIR coefficients. Array must be big enough to
 717 |  *                        hold 40 (GFIR1, GFIR2) or 120 (GFIR3) values.
 718 |  *
 719 |  * @return      0 on success, (-1) on failure
 720 |  */
 721 | API_EXPORT int CALL_CONV LMS_GetGFIRCoeff(lms_device_t * device, bool dir_tx,
 722 |                                 size_t chan, lms_gfir_t filt, float_type* coef);
 723 | 
 724 | /**
 725 |  * Enables or disables specified GFIR.
 726 |  *
 727 |  * @param device    Device handle previously obtained by LMS_Open().
 728 |  * @param dir_tx    Select RX or TX
 729 |  * @param chan      Channel index
 730 |  * @param filt      GFIR to configure
 731 |  * @param enabled   true(1) enable, false(0) disable.
 732 |  *
 733 |  * @return      0 on success, (-1) on failure
 734 |  */
 735 | API_EXPORT int CALL_CONV LMS_SetGFIR(lms_device_t * device, bool dir_tx,
 736 |                                     size_t chan, lms_gfir_t filt, bool enabled);
 737 | 
 738 | /**
 739 |  * Write value to VCTCXO trim DAC. Used to adjust/calibrate reference clock
 740 |  * generated by voltage controlled oscillator.
 741 |  * @note calling this functions switches clock source to VCTCXO
 742 |  *
 743 |  * @param   dev         Device handle previously obtained by LMS_Open().
 744 |  * @param   val         Value to write to VCTCXO trim DAC, range 0-255
 745 |  *
 746 |  * @return 0 on success, (-1) on failure
 747 |  */
 748 | API_EXPORT int CALL_CONV LMS_VCTCXOWrite(lms_device_t * dev, uint16_t val);
 749 | 
 750 | /**
 751 |  * Read value from VCTCXO trim DAC.
 752 |  *
 753 |  * @param[in]   dev     Device handle previously obtained by LMS_Open().
 754 |  * @param[out]  val     Value to read from VCTCXO trim DAC
 755 |  *
 756 |  * @return 0 on success, (-1) on failure
 757 |  */
 758 | API_EXPORT int CALL_CONV LMS_VCTCXORead(lms_device_t * dev, uint16_t *val);
 759 | 
 760 | /** @} (End FN_ADVANCED) */
 761 | 
 762 | /**
 763 |  * @defgroup FN_LOW_LVL    Low-Level control functions
 764 |  * @{
 765 |  */
 766 | 
 767 | /**
 768 |  * Send Reset signal to LMS chip. This initializes LMS chip with default
 769 |  * configuration as described in LMS chip datasheet.
 770 |  *
 771 |  * @param device  Device handle previously obtained by LMS_Open().
 772 |  *
 773 |  * @return  0 on success, (-1) on failure
 774 |  */
 775 | API_EXPORT int CALL_CONV LMS_Reset(lms_device_t *device);
 776 | 
 777 | /**
 778 |  * Read device LMS chip register
 779 |  *
 780 |  * @param device    Device handle previously obtained by LMS_Open().
 781 |  * @param address   Register address
 782 |  * @param val       Current register value
 783 |  *
 784 |  * @return  0 on success, (-1) on failure
 785 |  */
 786 | API_EXPORT int CALL_CONV LMS_ReadLMSReg(lms_device_t *device, uint32_t address,
 787 |                                         uint16_t *val);
 788 | 
 789 | /**
 790 |  * Write device LMS chip register
 791 |  *
 792 |  * @param device    Device handle previously obtained by LMS_Open().
 793 |  * @param address   Register address
 794 |  * @param val       Value to write
 795 |  *
 796 |  * @return  0 on success, (-1) on failure
 797 |  */
 798 | API_EXPORT int CALL_CONV LMS_WriteLMSReg(lms_device_t *device, uint32_t address,
 799 |                                         uint16_t val);
 800 | 
 801 | /**
 802 |  * Read device FPGA register
 803 |  *
 804 |  * @param device    Device handle previously obtained by LMS_Open().
 805 |  * @param address   Register address
 806 |  * @param val       Current register value
 807 |  *
 808 |  * @return  0 on success, (-1) on failure
 809 |  */
 810 | API_EXPORT int CALL_CONV LMS_ReadFPGAReg(lms_device_t *device, uint32_t address,
 811 |                                         uint16_t *val);
 812 | 
 813 | /**
 814 |  * Write device FPGA register
 815 |  *
 816 |  * @param device    Device handle previously obtained by LMS_Open().
 817 |  * @param address   Register address
 818 |  * @param val       Value to write
 819 |  *
 820 |  * @return  0 on success, (-1) on failure
 821 |  */
 822 | API_EXPORT int CALL_CONV LMS_WriteFPGAReg(lms_device_t *device, uint32_t address,
 823 |                                         uint16_t val);
 824 | 
 825 | /**
 826 |  * Read custom parameter from board
 827 |  *
 828 |  * @param device    Device handle previously obtained by LMS_Open().
 829 |  * @param id        Parameter identifier
 830 |  * @param val       Current register value
 831 |  * @param units     [optional] measurement units of parameter if available
 832 |  *
 833 |  * @return  0 on success, (-1) on failure
 834 |  */
 835 | API_EXPORT int CALL_CONV LMS_ReadCustomBoardParam(lms_device_t *device,
 836 |                                  uint8_t id, float_type *val, lms_name_t units);
 837 | 
 838 | /**
 839 |  * Write custom parameter from board
 840 |  *
 841 |  * @param device    Device handle previously obtained by LMS_Open().
 842 |  * @param id        Parameter identifier
 843 |  * @param val       Value to write
 844 |  * @param units     [optional] measurement units of parameter if available
 845 |  *
 846 |  * @return  0 on success, (-1) on failure
 847 |  */
 848 | API_EXPORT int CALL_CONV LMS_WriteCustomBoardParam(lms_device_t *device,
 849 |                             uint8_t id, float_type val, const lms_name_t units);
 850 | 
 851 | /**
 852 |  * @defgroup LMS_CLOCK_ID   Clock definitions
 853 |  *
 854 |  * Clock definitions for accessing specific internal clocks
 855 |  * @{
 856 |  */
 857 | #define LMS_CLOCK_REF    0x0000  ///<Chip reference clock
 858 | #define LMS_CLOCK_SXR    0x0001  ///<RX LO clock
 859 | #define LMS_CLOCK_SXT    0x0002  ///<TX LO clock
 860 | #define LMS_CLOCK_CGEN   0x0003  ///<CGEN clock
 861 | #define LMS_CLOCK_RXTSP  0x0004  ///<RXTSP reference clock
 862 | #define LMS_CLOCK_TXTSP  0x0005  ///<TXTSP reference clock
 863 | #define LMS_CLOCK_EXTREF 0x0006  ///<External reference clock
 864 | 
 865 | /** @} (End LMS_CLOCK_ID) */
 866 | 
 867 | /**
 868 |  * Get frequency of the specified clock.
 869 |  *
 870 |  * @param   dev     Device handle previously obtained by LMS_Open().
 871 |  * @param   clk_id  Clock identifier
 872 |  * @param   freq    Clock frequency in Hz
 873 |  *
 874 |  * @return 0 on success, (-1) on failure
 875 |  */
 876 | API_EXPORT int CALL_CONV LMS_GetClockFreq(lms_device_t *dev, size_t clk_id,
 877 |                                          float_type *freq);
 878 | 
 879 | /**
 880 |  * Set frequency of the specified clock
 881 |  *
 882 |  * @note setting ::LMS_CLOCK_EXTREF changes clock source to external, use
 883 |  * ::LMS_VCTCXOWrite() to change back to VCTCXO
 884 |  *
 885 |  * @param   dev     Device handle previously obtained by LMS_Open().
 886 |  * @param   clk_id  Clock identifier
 887 |  * @param   freq    Clock frequency in Hz. Pass zero or negative value to only
 888 |  *                  perform tune (if supported) without recalculating values
 889 |  *
 890 |  * @return 0 on success, (-1) on failure
 891 |  */
 892 | API_EXPORT int CALL_CONV LMS_SetClockFreq(lms_device_t *dev, size_t clk_id,
 893 |                                          float_type freq);
 894 | 
 895 | /**
 896 |  * Synchronizes register values between API cache and chip
 897 |  *
 898 |  * @param   dev         Device handle previously obtained by LMS_Open().
 899 |  * @param   toChip      if true copies values from API cache to chip.
 900 |  *
 901 |  * @return 0 on success, (-1) on failure
 902 |  */
 903 | API_EXPORT int CALL_CONV LMS_Synchronize(lms_device_t *dev, bool toChip);
 904 | 
 905 | /**
 906 |  * @param       dev     Device handle previously obtained by LMS_Open().
 907 |  * @param[in]   buffer  read values (8 GPIO values per byte, LSB first)
 908 |  * @param       len     number of bytes to read
 909 |  *
 910 |  * @return 0 on success, (-1) on failure
 911 |  */
 912 | API_EXPORT int CALL_CONV LMS_GPIORead(lms_device_t *dev, uint8_t* buffer, size_t len);
 913 | 
 914 | /**
 915 |  * @param       dev     Device handle previously obtained by LMS_Open().
 916 |  * @param[out]  buffer  values to write (8 GPIO values per byte, LSB first)
 917 |  * @param       len     number of bytes to write
 918 |  *
 919 |  * @return 0 on success, (-1) on failure
 920 |  */
 921 | API_EXPORT int CALL_CONV LMS_GPIOWrite(lms_device_t *dev, const uint8_t* buffer, size_t len);
 922 | 
 923 | /**
 924 |  * @param       dev     Device handle previously obtained by LMS_Open().
 925 |  * @param[out]  buffer  GPIO direction configuration(8 GPIO per byte, LSB first; 0 input, 1 output)
 926 |  * @param       len     number of bytes to read
 927 |  *
 928 |  * @return 0 on success, (-1) on failure
 929 |  */
 930 | API_EXPORT int CALL_CONV LMS_GPIODirRead(lms_device_t *dev, uint8_t* buffer, size_t len);
 931 | 
 932 | /**
 933 |  * @param       dev     Device handle previously obtained by LMS_Open().
 934 |  * @param[in]   buffer  GPIO direction configuration(8 GPIO per byte, LSB first; 0 input, 1 output)
 935 |  * @param       len     number of bytes to write
 936 |  *
 937 |  * @return 0 on success, (-1) on failure
 938 |  */
 939 | API_EXPORT int CALL_CONV LMS_GPIODirWrite(lms_device_t *dev, const uint8_t* buffer, size_t len);
 940 | 
 941 | /**
 942 |  *  Enables or disable caching of calibration values.
 943 |  *
 944 |  * @param   dev         Device handle previously obtained by LMS_Open().
 945 |  * @param   enable      true to enable cache
 946 |  *
 947 |  * @return 0 on success, (-1) on failure
 948 |  */
 949 | API_EXPORT int CALL_CONV LMS_EnableCalibCache(lms_device_t *dev, bool enable);
 950 | 
 951 | /**
 952 |  * Read LMS7 chip internal temperature sensor
 953 |  *
 954 |  * @param   dev         Device handle previously obtained by LMS_Open().
 955 |  * @param   ind         chip index
 956 |  * @param   temp        temperature value
 957 |  *
 958 |  * @return 0 on success, (-1) on failure
 959 |  */
 960 | API_EXPORT int CALL_CONV LMS_GetChipTemperature(lms_device_t *dev, size_t ind,
 961 |                                                 float_type *temp);
 962 | 
 963 | /** @} (End FN_LOW_LVL) */
 964 | 
 965 | /**
 966 |  * @defgroup FN_STREAM    Sample Streaming functions
 967 |  * The functions in this section provides support for sending and receiving
 968 |  * IQ data samples.
 969 |  * @{
 970 |  */
 971 | 
 972 | /**Metadata structure used in sample transfers*/
 973 | typedef struct
 974 | {
 975 |     /**
 976 |      * Timestamp is a value of HW counter with a tick based on sample rate.
 977 |      * In RX: time when the first sample in the returned buffer was received
 978 |      * In TX: time when the first sample in the submitted buffer should be send
 979 |      */
 980 |     uint64_t timestamp;
 981 | 
 982 |     /**In TX: wait for the specified HW timestamp before broadcasting data over
 983 |      * the air
 984 |      * In RX: wait for the specified HW timestamp before starting to receive
 985 |      * samples
 986 |      */
 987 |     bool waitForTimestamp;
 988 | 
 989 |     /**Indicates the end of send/receive transaction. Currently has no effect
 990 |      * @todo force send samples to HW (ignore transfer size) when selected
 991 |      */
 992 |     bool flushPartialPacket;
 993 | 
 994 | }lms_stream_meta_t;
 995 | 
 996 | /**Stream structure*/
 997 | typedef struct
 998 | {
 999 |     /**
1000 |      * Stream handle. Should not be modified manually.
1001 |      * Assigned by LMS_SetupStream().*/
1002 |     size_t handle;
1003 | 
1004 |     //! Indicates whether stream is TX (true) or RX (false)
1005 |     bool isTx;
1006 | 
1007 |     //! Channel number. Starts at 0.
1008 |     uint32_t channel;
1009 | 
1010 |     //! FIFO size (in samples) used by stream.
1011 |     uint32_t fifoSize;
1012 | 
1013 |     /**
1014 |      * Parameter for controlling configuration bias toward low latency or high
1015 |      * data throughput range [0,1.0].
1016 |      * 0 - lowest latency, usually results in lower throughput
1017 |      * 1 - higher throughput, usually results in higher latency
1018 |      */
1019 |     float throughputVsLatency;
1020 | 
1021 |     //! Data output format
1022 |     enum
1023 |     {
1024 |         LMS_FMT_F32=0,    ///<32-bit floating point
1025 |         LMS_FMT_I16,      ///<16-bit integers
1026 |         LMS_FMT_I12       ///<12-bit integers stored in 16-bit variables
1027 |     }dataFmt;
1028 | }lms_stream_t;
1029 | 
1030 | /**Streaming status structure*/
1031 | typedef struct
1032 | {
1033 |     ///Indicates whether the stream is currently active
1034 |     bool active;
1035 |     ///Number of samples in FIFO buffer
1036 |     uint32_t fifoFilledCount;
1037 |     ///Size of FIFO buffer
1038 |     uint32_t fifoSize;
1039 |     ///FIFO underrun count
1040 |     uint32_t underrun;
1041 |     ///FIFO overrun count
1042 |     uint32_t overrun;
1043 |     ///Number of dropped packets by HW
1044 |     uint32_t droppedPackets;
1045 |     ///Sampling rate of the stream
1046 |     float_type sampleRate;
1047 |     ///Combined data rate of all stream of the same direction (TX or RX)
1048 |     float_type linkRate;
1049 |     ///Current HW timestamp
1050 |     uint64_t timestamp;
1051 | 
1052 | } lms_stream_status_t;
1053 | 
1054 | /**
1055 |  * Create new stream based on parameters passed in configuration structure.
1056 |  * The structure is initialized with stream handle.
1057 |  *
1058 |  * @param device    Device handle previously obtained by LMS_Open().
1059 |  * @param stream    Stream configuration .See the ::lms_stream_t description.
1060 |  *
1061 |  * @return      0 on success, (-1) on failure
1062 |  */
1063 | API_EXPORT int CALL_CONV LMS_SetupStream(lms_device_t *device, lms_stream_t *stream);
1064 | 
1065 | /**
1066 |  * Deallocate memory used by stream.
1067 |  *
1068 |  * @param dev       Device handle previously obtained by LMS_Open().
1069 |  * @param stream    Stream structure previously initialized with LMS_SetupStream().
1070 |  *
1071 |  * @return 0 on success, (-1) on failure
1072 |  */
1073 | API_EXPORT int CALL_CONV LMS_DestroyStream(lms_device_t *dev, lms_stream_t *stream);
1074 | 
1075 | /**
1076 |  * Start stream
1077 |  *
1078 |  * @param stream Stream structure previously initialized with LMS_SetupStream().
1079 |  *
1080 |  * @return 0 on success, (-1) on failure
1081 |  */
1082 | API_EXPORT int CALL_CONV LMS_StartStream(lms_stream_t *stream);
1083 | 
1084 | /**
1085 |  * Stop stream
1086 |  *
1087 |  * @param stream Stream structure previously initialized with LMS_SetupStream().
1088 |  *
1089 |  * @return 0 on success, (-1) on failure
1090 |  */
1091 | API_EXPORT int CALL_CONV LMS_StopStream(lms_stream_t *stream);
1092 | 
1093 | /**
1094 |  * Read samples from the FIFO of the specified stream.
1095 |  * Sample buffer must be big enough to hold requested number of samples.
1096 |  *
1097 |  * @param stream        structure previously initialized with LMS_SetupStream().
1098 |  * @param samples       sample buffer.
1099 |  * @param sample_count  Number of samples to read
1100 |  * @param meta          Metadata. See the ::lms_stream_meta_t description.
1101 |  * @param timeout_ms    how long to wait for data before timing out.
1102 |  *
1103 |  * @return number of samples received on success, (-1) on failure
1104 |  */
1105 |  API_EXPORT int CALL_CONV LMS_RecvStream(lms_stream_t *stream, void *samples,
1106 |              size_t sample_count, lms_stream_meta_t *meta, unsigned timeout_ms);
1107 | 
1108 | /**
1109 |  * Get stream operation status
1110 |  *
1111 |  * @param stream    structure previously initialized with LMS_SetupStream().
1112 |  * @param status    Stream status. See the ::lms_stream_status_t for description
1113 |  *
1114 |  * @return  0 on success, (-1) on failure
1115 |  */
1116 | API_EXPORT int CALL_CONV LMS_GetStreamStatus(lms_stream_t *stream, lms_stream_status_t* status);
1117 | 
1118 | /**
1119 |  * Write samples to the FIFO of the specified stream.
1120 |  *
1121 |  * @param stream        structure previously initialized with LMS_SetupStream().
1122 |  * @param samples       sample buffer.
1123 |  * @param sample_count  Number of samples to write
1124 |  * @param meta          Metadata. See the ::lms_stream_meta_t description.
1125 |  * @param timeout_ms    how long to wait for data before timing out.
1126 |  *
1127 |  * @return number of samples send on success, (-1) on failure
1128 |  */
1129 | API_EXPORT int CALL_CONV LMS_SendStream(lms_stream_t *stream,
1130 |                             const void *samples,size_t sample_count,
1131 |                             const lms_stream_meta_t *meta, unsigned timeout_ms);
1132 | 
1133 | /**
1134 |  * Uploads waveform to on board memory for later use
1135 |  * @param device        Device handle previously obtained by LMS_Open().
1136 |  * @param samples       multiple channel samples data
1137 |  * @param chCount       number of waveform channels
1138 |  * @param sample_count  number of samples in each channel
1139 |  * @param format        waveform data format
1140 |  * @return              0 on success, (-1) on failure
1141 |  */
1142 | API_EXPORT int CALL_CONV LMS_UploadWFM(lms_device_t *device, const void **samples,
1143 |                                 uint8_t chCount, size_t sample_count, int format);
1144 | 
1145 | /**
1146 |  * Enables/Disables transmitting of uploaded waveform
1147 |  * @param device    Device handle previously obtained by LMS_Open().
1148 |  * @param chan      Channel index
1149 |  * @param active    Enable/Disable waveform playback
1150 |  * @return          0 on success, (-1) on failure
1151 |  */
1152 | API_EXPORT int CALL_CONV LMS_EnableTxWFM(lms_device_t *device, unsigned chan, bool active);
1153 | 
1154 | /** @} (End FN_STREAM) */
1155 | 
1156 | /**
1157 |  * @defgroup FN_VERSION   Version and update functions
1158 |  *
1159 |  * The functions in this section provides ability to check device version
1160 |  * and perform updates
1161 |  * @{
1162 |  */
1163 | 
1164 | /**Enumeration of programming mode*/
1165 | typedef enum
1166 | {
1167 |     LMS_PROG_MD_RAM = 0,   ///<load firmware/bitstream to volatile storage
1168 |     LMS_PROG_MD_FLASH = 1, ///<load firmware/bitstream to non-volatile storage
1169 |     LMS_PROG_MD_RST = 2    ///<reset and boot from flash
1170 | }lms_prog_md_t;
1171 | 
1172 | /**Enumeration of programmable board modules*/
1173 | typedef enum
1174 | {
1175 |     LMS_PROG_TRG_FX3 = 0,   ///<program FX3 firmware
1176 |     LMS_PROG_TRG_FPGA,      ///<program FPGA gateware
1177 |     LMS_PROG_TRG_MCU,       ///<program LMS7 MCU firmware
1178 |     LMS_PROG_TRG_HPM7,
1179 | }lms_prog_trg_t;
1180 | 
1181 | /**
1182 |  * Callback from programming processes
1183 |  * @param bsent number of bytes transferred
1184 |  * @param btotal total number of bytes to send
1185 |  * @param progressMsg string describing current progress state
1186 |  * @return 0-continue programming, 1-abort operation
1187 |  */
1188 | typedef bool (*lms_prog_callback_t)(int bsent, int btotal, const char* progressMsg);
1189 | 
1190 | /**
1191 |  * Write binary firmware/bitsteam image to specified device component.
1192 |  *
1193 |  * @param device    Device handle previously obtained by LMS_Open().
1194 |  * @param data      Pointer to memory containing firmware/bitsteam image
1195 |  * @param size      Size of firmware/bitsteam image in bytes.
1196 |  * @param target   device component to program ::lms_prog_trg_t
1197 |  * @param mode      programming mode ::lms_prog_md_t
1198 |  * @param callback  callback function for monitoring progress
1199 |  *
1200 |  * @return          0 on success, (-1) on failure
1201 |  */
1202 | API_EXPORT int CALL_CONV LMS_Program(lms_device_t *device, const char *data, size_t size,
1203 |            lms_prog_trg_t target, lms_prog_md_t mode, lms_prog_callback_t callback);
1204 | 
1205 | /**
1206 |  * Automatically update device firmware
1207 |  *
1208 |  * @param dev       Device handle previously obtained by LMS_Open().
1209 |  * @param download  True to download missing images from the web.
1210 |  * @param callback  callback function for monitoring progress
1211 |  *
1212 |  * @return          0 on success, (-1) on failure
1213 |  */
1214 | API_EXPORT int CALL_CONV LMS_ProgramUpdate(lms_device_t *dev, bool download,
1215 |                                            lms_prog_callback_t callback);
1216 | 
1217 | /**Device information structure*/
1218 | typedef struct
1219 | {
1220 |     char deviceName[32];            ///<The display name of the device
1221 |     char expansionName[32];         ///<The display name of the expansion card
1222 |     char firmwareVersion[16];       ///<The firmware version as a string
1223 |     char hardwareVersion[16];       ///<The hardware version as a string
1224 |     char protocolVersion[16];       ///<The protocol version as a string
1225 |     uint32_t boardSerialNumber;     ///<A unique board serial number
1226 |     char gatewareVersion[16];       ///<Gateware version as a string
1227 |     char gatewareRevision[16];      ///<Gateware revision as a string
1228 |     char gatewareTargetBoard[32];   ///<Which board should use this gateware
1229 | }lms_dev_info_t;
1230 | 
1231 | /**
1232 |  * Get device serial number and version information
1233 |  *
1234 |  * @note This function returns pointer to internal data structure that gets
1235 |  * deallocated when device is closed. Do not attempt to read from it after
1236 |  * closing the device. If you need to keep using device info returned by this
1237 |  * function after closing the device, make a copy before closing the device.
1238 |  *
1239 |  * @param device    Device handle previously obtained by LMS_Open().
1240 |  * @return          pointer to device info structure ::lms_dev_info_t
1241 |  */
1242 | API_EXPORT const lms_dev_info_t* CALL_CONV LMS_GetDeviceInfo(lms_device_t *device);
1243 | 
1244 | /**
1245 | * @brief Returns API library version
1246 | */
1247 | API_EXPORT const char* LMS_GetLibraryVersion();
1248 | 
1249 | /**
1250 |  * Get the error message detailing why the last error occurred.
1251 |  *
1252 |  * @return last error message.
1253 |  */
1254 | API_EXPORT const char * CALL_CONV LMS_GetLastErrorMessage(void);
1255 | 
1256 | /** @} (End FN_VERSION) */
1257 | 
1258 | #ifdef __cplusplus
1259 | } //extern "C"
1260 | #endif
1261 | 
1262 | #endif //LMS_SDR_INTERFACE_H
1263 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | #LimeSDR Matlab & Simulink interface
 2 | 
 3 | ```
 4 | device = limeSDR();
 5 | device.rx0.frequency = 100.00e6;
 6 | device.tx0.frequency = 200.00e6;
 7 | ```
 8 | 
 9 | Before starting, run `help limeSDR.build_thunk` to view instructions on how to have MATLAB build a Thunk file to use in conjunction with libLimeSuite.
10 | 
11 | For more information, use the MATLAB `help limeSDR` and `doc limeSDR` commands on the files in this directory
12 | 
13 | ##### Simulink support
14 | 
15 | add **MATLAB System block** and choose limeSDR_Simulink.m file
16 | 
17 | 
18 | # License #
19 | 	
20 | This code is distributed under an [MIT License](LICENSE.MIT).


--------------------------------------------------------------------------------
/libLimeSuite__proto.m:
--------------------------------------------------------------------------------
  1 | %
  2 | % Copyright (c) 2017 JiangWei
  3 | % Copyright (c) 2015 Nuand LLC
  4 | %
  5 | % Permission is hereby granted, free of charge, to any person obtaining a copy
  6 | % of this software and associated documentation files (the "Software"), to deal
  7 | % in the Software without restriction, including without limitation the rights
  8 | % to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9 | % copies of the Software, and to permit persons to whom the Software is
 10 | % furnished to do so, subject to the following conditions:
 11 | %
 12 | % The above copyright notice and this permission notice shall be included in
 13 | % all copies or substantial portions of the Software.
 14 | %
 15 | % THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 | % IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17 | % FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18 | % AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19 | % LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 20 | % OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 21 | % THE SOFTWARE.
 22 | %
 23 | function [methodinfo,structs,enuminfo,ThunkLibName]=libLimeSuite__proto
 24 | %DELETE_THIS_FILE Create structures to define interfaces found in 'LimeSuite'.
 25 | 
 26 | %This function was generated by loadlibrary.m parser version  on Sun Nov 13 17:58:02 2016
 27 | %perl options:'LimeSuite.i -outfile=delete_this_file.m -thunkfile=libLimeSuite_thunk_pcwin64.c -header=LimeSuite.h'
 28 | ival={cell(1,0)}; % change 0 to the actual number of functions to preallocate the data.
 29 | structs=[];enuminfo=[];fcnNum=1;
 30 | fcns=struct('name',ival,'calltype',ival,'LHS',ival,'RHS',ival,'alias',ival,'thunkname', ival);
 31 | 
 32 | arch = computer('arch');
 33 | switch arch
 34 |     case 'glnxa64'
 35 |         libname   = 'libLimeSuite_thunk_glnxa64';
 36 |         libsuffix = '.so';
 37 |         u64_type = 'ulong';
 38 |         pathsep   = ':';
 39 |     case 'win64'
 40 |         libname   = 'libLimeSuite_thunk_pcwin64';
 41 |         libsuffix = '.dll';
 42 |         u64_type = 'uint64';
 43 |         pathsep   = ';';
 44 | 
 45 |     case 'maci64'
 46 |         % Additionaly type changes for this may be required for OSX support
 47 |         libname   = 'libLimeSuite_thunk_maci64';
 48 |         libsuffix = '.dylib';
 49 |         u64_type = 'ulong';
 50 |         pathsep   = ':';
 51 | 
 52 |     otherwise
 53 |         error(['Unsupported architecture: ' arch]);
 54 | end
 55 | 
 56 | search_path = [ '.'; strsplit(path, pathsep)'];
 57 | for n = 1:length(search_path)
 58 |     to_check = fullfile(search_path{n}, [libname libsuffix]);
 59 |     if exist(to_check, 'file')
 60 |         %fprintf('Found %s\n', to_check);
 61 |         ThunkLibName = to_check;
 62 |         break
 63 |     else
 64 |         %fprintf('%s does not exist.\n', to_check);
 65 |     end
 66 | end
 67 | 
 68 | if ~exist('ThunkLibName', 'var')
 69 |     error(['Failed to find ' [libname libsuffix] '. Check path().']);
 70 | end
 71 | 
 72 | %  int __cdecl LMS_GetDeviceList ( lms_info_str_t * dev_list ); 
 73 | fcns.thunkname{fcnNum}='int32voidPtrThunk';fcns.name{fcnNum}='LMS_GetDeviceList'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'int8Ptr'};fcnNum=fcnNum+1;
 74 | %  int __cdecl LMS_Open ( lms_device_t ** device , const lms_info_str_t info , void * args ); 
 75 | fcns.thunkname{fcnNum}='int32voidPtrvoidPtrvoidPtrThunk';fcns.name{fcnNum}='LMS_Open'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtrPtr', 'int8Ptr', 'voidPtr'};fcnNum=fcnNum+1;
 76 | %  int __cdecl LMS_Close ( lms_device_t * device ); 
 77 | fcns.thunkname{fcnNum}='int32voidPtrThunk';fcns.name{fcnNum}='LMS_Close'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr'};fcnNum=fcnNum+1;
 78 | %  int __cdecl LMS_Disconnect ( lms_device_t * device ); 
 79 | fcns.thunkname{fcnNum}='int32voidPtrThunk';fcns.name{fcnNum}='LMS_Disconnect'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr'};fcnNum=fcnNum+1;
 80 | %  _Bool __cdecl LMS_IsOpen ( lms_device_t * device , int port ); 
 81 | fcns.thunkname{fcnNum}='_BoolvoidPtrint32Thunk';fcns.name{fcnNum}='LMS_IsOpen'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='bool'; fcns.RHS{fcnNum}={'voidPtr', 'int32'};fcnNum=fcnNum+1;
 82 | %  int __cdecl LMS_Init ( lms_device_t * device ); 
 83 | fcns.thunkname{fcnNum}='int32voidPtrThunk';fcns.name{fcnNum}='LMS_Init'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr'};fcnNum=fcnNum+1;
 84 | %  int __cdecl LMS_GetNumChannels ( lms_device_t * device , _Bool dir_tx ); 
 85 | fcns.thunkname{fcnNum}='int32voidPtr_BoolThunk';fcns.name{fcnNum}='LMS_GetNumChannels'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool'};fcnNum=fcnNum+1;
 86 | %  int __cdecl LMS_EnableChannel ( lms_device_t * device , _Bool dir_tx , size_t chan , _Bool enabled ); 
 87 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type '_BoolThunk'];fcns.name{fcnNum}='LMS_EnableChannel'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'bool'};fcnNum=fcnNum+1;
 88 | %  int __cdecl LMS_SetSampleRate ( lms_device_t * device , float_type rate , size_t oversample ); 
 89 | fcns.thunkname{fcnNum}=['int32voidPtrdouble' u64_type 'Thunk'];fcns.name{fcnNum}='LMS_SetSampleRate'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'double', u64_type};fcnNum=fcnNum+1;
 90 | %  int __cdecl LMS_GetSampleRate ( lms_device_t * device , _Bool dir_tx , size_t chan , float_type * host_Hz , float_type * rf_Hz ); 
 91 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrvoidPtrThunk'];fcns.name{fcnNum}='LMS_GetSampleRate'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'doublePtr', 'doublePtr'};fcnNum=fcnNum+1;
 92 | %  int __cdecl LMS_GetSampleRateRange ( lms_device_t * device , _Bool dir_tx , lms_range_t * range ); 
 93 | fcns.thunkname{fcnNum}='int32voidPtr_BoolvoidPtrThunk';fcns.name{fcnNum}='LMS_GetSampleRateRange'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', 'lms_range_tPtr'};fcnNum=fcnNum+1;
 94 | %  int __cdecl LMS_SetLOFrequency ( lms_device_t * device , _Bool dir_tx , size_t chan , float_type frequency ); 
 95 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'doubleThunk'];fcns.name{fcnNum}='LMS_SetLOFrequency'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'double'};fcnNum=fcnNum+1;
 96 | %  int __cdecl LMS_GetLOFrequency ( lms_device_t * device , _Bool dir_tx , size_t chan , float_type * frequency ); 
 97 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrThunk'];fcns.name{fcnNum}='LMS_GetLOFrequency'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'doublePtr'};fcnNum=fcnNum+1;
 98 | %  int __cdecl LMS_GetLOFrequencyRange ( lms_device_t * device , _Bool dir_tx , lms_range_t * range ); 
 99 | fcns.thunkname{fcnNum}='int32voidPtr_BoolvoidPtrThunk';fcns.name{fcnNum}='LMS_GetLOFrequencyRange'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', 'lms_range_tPtr'};fcnNum=fcnNum+1;
100 | %  int __cdecl LMS_GetAntennaList ( lms_device_t * dev , _Bool dir_tx , size_t chan , lms_name_t * list ); 
101 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrThunk'];fcns.name{fcnNum}='LMS_GetAntennaList'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'int8Ptr'};fcnNum=fcnNum+1;
102 | %  int __cdecl LMS_SetAntenna ( lms_device_t * dev , _Bool dir_tx , size_t chan , size_t index ); 
103 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type '' u64_type 'Thunk'];fcns.name{fcnNum}='LMS_SetAntenna'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, u64_type};fcnNum=fcnNum+1;
104 | %  int __cdecl LMS_GetAntenna ( lms_device_t * dev , _Bool dir_tx , size_t chan ); 
105 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'Thunk'];fcns.name{fcnNum}='LMS_GetAntenna'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type};fcnNum=fcnNum+1;
106 | %  int __cdecl LMS_GetAntennaBW ( lms_device_t * dev , _Bool dir_tx , size_t chan , size_t index , lms_range_t * range ); 
107 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type '' u64_type 'voidPtrThunk'];fcns.name{fcnNum}='LMS_GetAntennaBW'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, u64_type, 'lms_range_tPtr'};fcnNum=fcnNum+1;
108 | %  int __cdecl LMS_SetNormalizedGain ( lms_device_t * device , _Bool dir_tx , size_t chan , float_type gain ); 
109 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'doubleThunk'];fcns.name{fcnNum}='LMS_SetNormalizedGain'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'double'};fcnNum=fcnNum+1;
110 | %  int __cdecl LMS_SetGaindB ( lms_device_t * device , _Bool dir_tx , size_t chan , unsigned gain ); 
111 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'uint32Thunk'];fcns.name{fcnNum}='LMS_SetGaindB'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'uint32'};fcnNum=fcnNum+1;
112 | %  int __cdecl LMS_GetNormalizedGain ( lms_device_t * device , _Bool dir_tx , size_t chan , float_type * gain ); 
113 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrThunk'];fcns.name{fcnNum}='LMS_GetNormalizedGain'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'doublePtr'};fcnNum=fcnNum+1;
114 | %  int __cdecl LMS_GetGaindB ( lms_device_t * device , _Bool dir_tx , size_t chan , unsigned * gain ); 
115 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrThunk'];fcns.name{fcnNum}='LMS_GetGaindB'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'uint32Ptr'};fcnNum=fcnNum+1;
116 | %  int __cdecl LMS_SetLPFBW ( lms_device_t * device , _Bool dir_tx , size_t chan , float_type bandwidth ); 
117 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'doubleThunk'];fcns.name{fcnNum}='LMS_SetLPFBW'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'double'};fcnNum=fcnNum+1;
118 | %  int __cdecl LMS_GetLPFBW ( lms_device_t * device , _Bool dir_tx , size_t chan , float_type * bandwidth ); 
119 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrThunk'];fcns.name{fcnNum}='LMS_GetLPFBW'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'doublePtr'};fcnNum=fcnNum+1;
120 | %  int __cdecl LMS_GetLPFBWRange ( lms_device_t * device , _Bool dir_tx , lms_range_t * range ); 
121 | fcns.thunkname{fcnNum}='int32voidPtr_BoolvoidPtrThunk';fcns.name{fcnNum}='LMS_GetLPFBWRange'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', 'lms_range_tPtr'};fcnNum=fcnNum+1;
122 | %  int __cdecl LMS_SetLPF ( lms_device_t * device , _Bool dir_tx , size_t chan , _Bool enable ); 
123 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type '_BoolThunk'];fcns.name{fcnNum}='LMS_SetLPF'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'bool'};fcnNum=fcnNum+1;
124 | %  int __cdecl LMS_SetGFIRLPF ( lms_device_t * device , _Bool dir_tx , size_t chan , _Bool enabled , float_type bandwidth ); 
125 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type '_BooldoubleThunk'];fcns.name{fcnNum}='LMS_SetGFIRLPF'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'bool', 'double'};fcnNum=fcnNum+1;
126 | %  int __cdecl LMS_Calibrate ( lms_device_t * device , _Bool dir_tx , size_t chan , double bw , unsigned flags ); 
127 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'doubleuint32Thunk'];fcns.name{fcnNum}='LMS_Calibrate'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'double', 'uint32'};fcnNum=fcnNum+1;
128 | %  int __cdecl LMS_LoadConfig ( lms_device_t * device , const char * filename ); 
129 | fcns.thunkname{fcnNum}='int32voidPtrcstringThunk';fcns.name{fcnNum}='LMS_LoadConfig'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'cstring'};fcnNum=fcnNum+1;
130 | %  int __cdecl LMS_SaveConfig ( lms_device_t * device , const char * filename ); 
131 | fcns.thunkname{fcnNum}='int32voidPtrcstringThunk';fcns.name{fcnNum}='LMS_SaveConfig'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'cstring'};fcnNum=fcnNum+1;
132 | %  int __cdecl LMS_SetTestSignal ( lms_device_t * device , _Bool dir_tx , size_t chan , lms_testsig_t sig , int16_t dc_i , int16_t dc_q ); 
133 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'lms_testsig_tint16int16Thunk'];fcns.name{fcnNum}='LMS_SetTestSignal'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'lms_testsig_t', 'int16', 'int16'};fcnNum=fcnNum+1;
134 | %  int __cdecl LMS_GetTestSignal ( lms_device_t * device , _Bool dir_tx , size_t chan , lms_testsig_t * sig ); 
135 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrThunk'];fcns.name{fcnNum}='LMS_GetTestSignal'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'lms_testsig_tPtr'};fcnNum=fcnNum+1;
136 | %  int __cdecl LMS_SetSampleRateDir ( lms_device_t * device , _Bool dir_tx , float_type rate , size_t oversample ); 
137 | fcns.thunkname{fcnNum}=['int32voidPtr_Booldouble' u64_type 'Thunk'];fcns.name{fcnNum}='LMS_SetSampleRateDir'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', 'double', u64_type};fcnNum=fcnNum+1;
138 | %  int __cdecl LMS_SetNCOFrequency ( lms_device_t * device , _Bool dir_tx , size_t chan , const float_type * freq , float_type pho ); 
139 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrdoubleThunk'];fcns.name{fcnNum}='LMS_SetNCOFrequency'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'doublePtr', 'double'};fcnNum=fcnNum+1;
140 | %  int __cdecl LMS_GetNCOFrequency ( lms_device_t * device , _Bool dir_tx , size_t chan , float_type * freq , float_type * pho ); 
141 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrvoidPtrThunk'];fcns.name{fcnNum}='LMS_GetNCOFrequency'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'doublePtr', 'doublePtr'};fcnNum=fcnNum+1;
142 | %  int __cdecl LMS_SetNCOPhase ( lms_device_t * device , _Bool dir_tx , size_t chan , const float_type * phases , float_type fcw ); 
143 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrdoubleThunk'];fcns.name{fcnNum}='LMS_SetNCOPhase'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'doublePtr', 'double'};fcnNum=fcnNum+1;
144 | %  int __cdecl LMS_GetNCOPhase ( lms_device_t * device , _Bool dir_tx , size_t chan , float_type * phases , float_type * fcw ); 
145 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'voidPtrvoidPtrThunk'];fcns.name{fcnNum}='LMS_GetNCOPhase'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'doublePtr', 'doublePtr'};fcnNum=fcnNum+1;
146 | %  int __cdecl LMS_SetNCOIndex ( lms_device_t * device , _Bool dir_tx , size_t chan , int index , _Bool downconv ); 
147 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'int32_BoolThunk'];fcns.name{fcnNum}='LMS_SetNCOIndex'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'int32', 'bool'};fcnNum=fcnNum+1;
148 | %  int __cdecl LMS_GetNCOIndex ( lms_device_t * device , _Bool dir_tx , size_t chan ); 
149 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'Thunk'];fcns.name{fcnNum}='LMS_GetNCOIndex'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type};fcnNum=fcnNum+1;
150 | %  int __cdecl LMS_SetGFIRCoeff ( lms_device_t * device , _Bool dir_tx , size_t chan , lms_gfir_t filt , const float_type * coef , size_t count ); 
151 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'lms_gfir_tvoidPtr' u64_type 'Thunk'];fcns.name{fcnNum}='LMS_SetGFIRCoeff'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'lms_gfir_t', 'doublePtr', u64_type};fcnNum=fcnNum+1;
152 | %  int __cdecl LMS_GetGFIRCoeff ( lms_device_t * device , _Bool dir_tx , size_t chan , lms_gfir_t filt , float_type * coef ); 
153 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'lms_gfir_tvoidPtrThunk'];fcns.name{fcnNum}='LMS_GetGFIRCoeff'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'lms_gfir_t', 'doublePtr'};fcnNum=fcnNum+1;
154 | %  int __cdecl LMS_SetGFIR ( lms_device_t * device , _Bool dir_tx , size_t chan , lms_gfir_t filt , _Bool enabled ); 
155 | fcns.thunkname{fcnNum}=['int32voidPtr_Bool' u64_type 'lms_gfir_t_BoolThunk'];fcns.name{fcnNum}='LMS_SetGFIR'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool', u64_type, 'lms_gfir_t', 'bool'};fcnNum=fcnNum+1;
156 | %  int __cdecl LMS_VCTCXOWrite ( lms_device_t * dev , uint16_t val ); 
157 | fcns.thunkname{fcnNum}='int32voidPtruint16Thunk';fcns.name{fcnNum}='LMS_VCTCXOWrite'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint16'};fcnNum=fcnNum+1;
158 | %  int __cdecl LMS_VCTCXORead ( lms_device_t * dev , uint16_t * val ); 
159 | fcns.thunkname{fcnNum}='int32voidPtrvoidPtrThunk';fcns.name{fcnNum}='LMS_VCTCXORead'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint16Ptr'};fcnNum=fcnNum+1;
160 | %  int __cdecl LMS_Reset ( lms_device_t * device ); 
161 | fcns.thunkname{fcnNum}='int32voidPtrThunk';fcns.name{fcnNum}='LMS_Reset'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr'};fcnNum=fcnNum+1;
162 | %  int __cdecl LMS_ReadLMSReg ( lms_device_t * device , uint32_t address , uint16_t * val ); 
163 | fcns.thunkname{fcnNum}='int32voidPtruint32voidPtrThunk';fcns.name{fcnNum}='LMS_ReadLMSReg'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint32', 'uint16Ptr'};fcnNum=fcnNum+1;
164 | %  int __cdecl LMS_WriteLMSReg ( lms_device_t * device , uint32_t address , uint16_t val ); 
165 | fcns.thunkname{fcnNum}='int32voidPtruint32uint16Thunk';fcns.name{fcnNum}='LMS_WriteLMSReg'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint32', 'uint16'};fcnNum=fcnNum+1;
166 | %  int __cdecl LMS_ReadFPGAReg ( lms_device_t * device , uint32_t address , uint16_t * val ); 
167 | fcns.thunkname{fcnNum}='int32voidPtruint32voidPtrThunk';fcns.name{fcnNum}='LMS_ReadFPGAReg'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint32', 'uint16Ptr'};fcnNum=fcnNum+1;
168 | %  int __cdecl LMS_WriteFPGAReg ( lms_device_t * device , uint32_t address , uint16_t val ); 
169 | fcns.thunkname{fcnNum}='int32voidPtruint32uint16Thunk';fcns.name{fcnNum}='LMS_WriteFPGAReg'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint32', 'uint16'};fcnNum=fcnNum+1;
170 | %  int __cdecl LMS_ReadCustomBoardParam ( lms_device_t * device , uint8_t id , float_type * val , lms_name_t units ); 
171 | fcns.thunkname{fcnNum}='int32voidPtruint8voidPtrvoidPtrThunk';fcns.name{fcnNum}='LMS_ReadCustomBoardParam'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint8', 'doublePtr', 'int8Ptr'};fcnNum=fcnNum+1;
172 | %  int __cdecl LMS_WriteCustomBoardParam ( lms_device_t * device , uint8_t id , float_type val , const lms_name_t units ); 
173 | fcns.thunkname{fcnNum}='int32voidPtruint8doublevoidPtrThunk';fcns.name{fcnNum}='LMS_WriteCustomBoardParam'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint8', 'double', 'int8Ptr'};fcnNum=fcnNum+1;
174 | %  int __cdecl LMS_GetClockFreq ( lms_device_t * dev , size_t clk_id , float_type * freq ); 
175 | fcns.thunkname{fcnNum}=['int32voidPtr' u64_type 'voidPtrThunk'];fcns.name{fcnNum}='LMS_GetClockFreq'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', u64_type, 'doublePtr'};fcnNum=fcnNum+1;
176 | %  int __cdecl LMS_SetClockFreq ( lms_device_t * dev , size_t clk_id , float_type freq ); 
177 | fcns.thunkname{fcnNum}=['int32voidPtr' u64_type 'doubleThunk'];fcns.name{fcnNum}='LMS_SetClockFreq'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', u64_type, 'double'};fcnNum=fcnNum+1;
178 | %  int __cdecl LMS_Synchronize ( lms_device_t * dev , _Bool toChip ); 
179 | fcns.thunkname{fcnNum}='int32voidPtr_BoolThunk';fcns.name{fcnNum}='LMS_Synchronize'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool'};fcnNum=fcnNum+1;
180 | %  int __cdecl LMS_GPIORead ( lms_device_t * dev , uint8_t * buffer , size_t len ); 
181 | fcns.thunkname{fcnNum}=['int32voidPtrvoidPtr' u64_type 'Thunk'];fcns.name{fcnNum}='LMS_GPIORead'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint8Ptr', u64_type};fcnNum=fcnNum+1;
182 | %  int __cdecl LMS_GPIOWrite ( lms_device_t * dev , const uint8_t * buffer , size_t len ); 
183 | fcns.thunkname{fcnNum}=['int32voidPtrvoidPtr' u64_type 'Thunk'];fcns.name{fcnNum}='LMS_GPIOWrite'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint8Ptr', u64_type};fcnNum=fcnNum+1;
184 | %  int __cdecl LMS_GPIODirRead ( lms_device_t * dev , uint8_t * buffer , size_t len ); 
185 | fcns.thunkname{fcnNum}=['int32voidPtrvoidPtr' u64_type 'Thunk'];fcns.name{fcnNum}='LMS_GPIODirRead'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint8Ptr', u64_type};fcnNum=fcnNum+1;
186 | %  int __cdecl LMS_GPIODirWrite ( lms_device_t * dev , const uint8_t * buffer , size_t len ); 
187 | fcns.thunkname{fcnNum}=['int32voidPtrvoidPtr' u64_type 'Thunk'];fcns.name{fcnNum}='LMS_GPIODirWrite'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint8Ptr', u64_type};fcnNum=fcnNum+1;
188 | %  int __cdecl LMS_EnableCalibCache ( lms_device_t * dev , _Bool enable ); 
189 | fcns.thunkname{fcnNum}='int32voidPtr_BoolThunk';fcns.name{fcnNum}='LMS_EnableCalibCache'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'bool'};fcnNum=fcnNum+1;
190 | %  int __cdecl LMS_GetChipTemperature ( lms_device_t * dev , size_t ind , float_type * temp ); 
191 | fcns.thunkname{fcnNum}=['int32voidPtr' u64_type 'voidPtrThunk'];fcns.name{fcnNum}='LMS_GetChipTemperature'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', u64_type, 'doublePtr'};fcnNum=fcnNum+1;
192 | %  int __cdecl LMS_SetupStream ( lms_device_t * device , lms_stream_t * stream ); 
193 | fcns.thunkname{fcnNum}='int32voidPtrvoidPtrThunk';fcns.name{fcnNum}='LMS_SetupStream'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'lms_stream_tPtr'};fcnNum=fcnNum+1;
194 | %  int __cdecl LMS_DestroyStream ( lms_device_t * dev , lms_stream_t * stream ); 
195 | fcns.thunkname{fcnNum}='int32voidPtrvoidPtrThunk';fcns.name{fcnNum}='LMS_DestroyStream'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'lms_stream_tPtr'};fcnNum=fcnNum+1;
196 | %  int __cdecl LMS_StartStream ( lms_stream_t * stream ); 
197 | fcns.thunkname{fcnNum}='int32voidPtrThunk';fcns.name{fcnNum}='LMS_StartStream'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'lms_stream_tPtr'};fcnNum=fcnNum+1;
198 | %  int __cdecl LMS_StopStream ( lms_stream_t * stream ); 
199 | fcns.thunkname{fcnNum}='int32voidPtrThunk';fcns.name{fcnNum}='LMS_StopStream'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'lms_stream_tPtr'};fcnNum=fcnNum+1;
200 | %  int __cdecl LMS_RecvStream ( lms_stream_t * stream , void * samples , size_t sample_count , lms_stream_meta_t * meta , unsigned timeout_ms ); 
201 | fcns.thunkname{fcnNum}=['int32voidPtrvoidPtr' u64_type 'voidPtruint32Thunk'];fcns.name{fcnNum}='LMS_RecvStream'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'lms_stream_tPtr', 'voidPtr', u64_type, 'lms_stream_meta_tPtr', 'uint32'};fcnNum=fcnNum+1;
202 | %  int __cdecl LMS_GetStreamStatus ( lms_stream_t * stream , lms_stream_status_t * status ); 
203 | fcns.thunkname{fcnNum}='int32voidPtrvoidPtrThunk';fcns.name{fcnNum}='LMS_GetStreamStatus'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'lms_stream_tPtr', 'lms_stream_status_tPtr'};fcnNum=fcnNum+1;
204 | %  int __cdecl LMS_SendStream ( lms_stream_t * stream , const void * samples , size_t sample_count , const lms_stream_meta_t * meta , unsigned timeout_ms ); 
205 | fcns.thunkname{fcnNum}=['int32voidPtrvoidPtr' u64_type 'voidPtruint32Thunk'];fcns.name{fcnNum}='LMS_SendStream'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'lms_stream_tPtr', 'voidPtr', u64_type, 'lms_stream_meta_tPtr', 'uint32'};fcnNum=fcnNum+1;
206 | %  int __cdecl LMS_UploadWFM ( lms_device_t * device , const void ** samples , uint8_t chCount , size_t sample_count , int format ); 
207 | fcns.thunkname{fcnNum}=['int32voidPtrvoidPtruint8' u64_type 'int32Thunk'];fcns.name{fcnNum}='LMS_UploadWFM'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'voidPtrPtr', 'uint8', u64_type, 'int32'};fcnNum=fcnNum+1;
208 | %  int __cdecl LMS_EnableTxWFM ( lms_device_t * device , unsigned chan , _Bool active ); 
209 | fcns.thunkname{fcnNum}='int32voidPtruint32_BoolThunk';fcns.name{fcnNum}='LMS_EnableTxWFM'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='int32'; fcns.RHS{fcnNum}={'voidPtr', 'uint32', 'bool'};fcnNum=fcnNum+1;
210 | %  const lms_dev_info_t * __cdecl LMS_GetDeviceInfo ( lms_device_t * device ); 
211 | fcns.thunkname{fcnNum}='voidPtrvoidPtrThunk';fcns.name{fcnNum}='LMS_GetDeviceInfo'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='lms_dev_info_tPtr'; fcns.RHS{fcnNum}={'voidPtr'};fcnNum=fcnNum+1;
212 | %  const char * LMS_GetLibraryVersion (); 
213 | fcns.thunkname{fcnNum}='cstringThunk';fcns.name{fcnNum}='LMS_GetLibraryVersion'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='cstring'; fcns.RHS{fcnNum}=[];fcnNum=fcnNum+1;
214 | %  const char * __cdecl LMS_GetLastErrorMessage ( void ); 
215 | fcns.thunkname{fcnNum}='cstringvoidThunk';fcns.name{fcnNum}='LMS_GetLastErrorMessage'; fcns.calltype{fcnNum}='Thunk'; fcns.LHS{fcnNum}='cstring'; fcns.RHS{fcnNum}=[];fcnNum=fcnNum+1;
216 | structs.lms_range_t.members=struct('min', 'double', 'max', 'double', 'step', 'double');
217 | structs.lms_stream_meta_t.members=struct('timestamp', u64_type, 'waitForTimestamp', 'bool', 'flushPartialPacket', 'bool');
218 | structs.lms_stream_t.members=struct('handle', u64_type, 'isTx', 'bool', 'channel', 'uint32', 'fifoSize', 'uint32', 'throughputVsLatency', 'single', 'error0', 'voidPtr');
219 | structs.lms_stream_status_t.members=struct('active', 'bool', 'fifoFilledCount', 'uint32', 'fifoSize', 'uint32', 'underrun', 'uint32', 'overrun', 'uint32', 'droppedPackets', 'uint32', 'sampleRate', 'double', 'linkRate', 'double', 'timestamp', u64_type);
220 | structs.lms_dev_info_t.members=struct('deviceName', 'int8#32', 'expansionName', 'int8#32', 'firmwareVersion', 'int8#16', 'hardwareVersion', 'int8#16', 'protocolVersion', 'int8#16', 'boardSerialNumber', 'uint32', 'gatewareVersion', 'int8#16', 'gatewareRevision', 'int8#16', 'gatewareTargetBoard', 'int8#32');
221 | enuminfo.lms_gfir_t=struct('LMS_GFIR1',0,'LMS_GFIR2',1,'LMS_GFIR3',2);
222 | enuminfo.lms_testsig_t=struct('LMS_TESTSIG_NONE',0,'LMS_TESTSIG_NCODIV8',1,'LMS_TESTSIG_NCODIV4',2,'LMS_TESTSIG_NCODIV8F',3,'LMS_TESTSIG_NCODIV4F',4,'LMS_TESTSIG_DC',5);
223 | enuminfo.lms_prog_trg_t=struct('LMS_PROG_TRG_FX3',0,'LMS_PROG_TRG_FPGA',1,'LMS_PROG_TRG_MCU',2,'LMS_PROG_TRG_HPM7',3);
224 | enuminfo.lms_prog_md_t=struct('LMS_PROG_MD_RAM',0,'LMS_PROG_MD_FLASH',1,'LMS_PROG_MD_RST',2);
225 | methodinfo=fcns;


--------------------------------------------------------------------------------
/limeSDR.m:
--------------------------------------------------------------------------------
  1 | %
  2 | % Copyright (c) 2017 JiangWei
  3 | % Copyright (c) 2015 Nuand LLC
  4 | %
  5 | % Permission is hereby granted, free of charge, to any person obtaining a copy
  6 | % of this software and associated documentation files (the "Software"), to deal
  7 | % in the Software without restriction, including without limitation the rights
  8 | % to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9 | % copies of the Software, and to permit persons to whom the Software is
 10 | % furnished to do so, subject to the following conditions:
 11 | %
 12 | % The above copyright notice and this permission notice shall be included in
 13 | % all copies or substantial portions of the Software.
 14 | %
 15 | % THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 | % IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17 | % FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18 | % AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19 | % LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 20 | % OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 21 | % THE SOFTWARE.
 22 | %
 23 | % LimeSDR MATLAB interface
 24 | %
 25 | % (1) Open a device handle:
 26 | %
 27 | %   dev = limeSDR(); % Open device
 28 | %
 29 | % (2) Setup device parameters. These may be changed while the device
 30 | %     is actively streaming.
 31 | %
 32 | %   dev.rx0.frequency  = 917.45e6;
 33 | %   dev.rx0.samplerate = 5e6;
 34 | %   dev.rx0.gain = 30;
 35 | %   dev.rx0.antenna = 2;
 36 | %
 37 | % (3) Enable stream parameters. These may NOT be changed while the device
 38 | %     is streaming.
 39 | %
 40 | %   dev.rx0.enable;
 41 | %
 42 | % (4) Start the module
 43 | %
 44 | %   dev.start();
 45 | %
 46 | % (5) Receive 5000 samples on RX0 channel
 47 | %
 48 | %  samples = dev.receive(5000,0);
 49 | %
 50 | % (6) Cleanup and shutdown by stopping the RX stream and having MATLAB
 51 | %     delete the handle object.
 52 | %
 53 | %  dev.stop();
 54 | %  clear dev;
 55 | 
 56 | %% Top-level limesdr object
 57 | classdef limeSDR < handle
 58 |     
 59 |     properties (Access={?limeSDR_XCVR})
 60 |         device  % Device handle
 61 |         rx0_stream % rx stream handle
 62 |         tx0_stream % tx stream handle
 63 |         rx1_stream % rx stream handle
 64 |         tx1_stream % tx stream handle
 65 |     end
 66 |     
 67 |     properties
 68 |         rx0          % Receive chain
 69 |         tx0          % Transmit chain
 70 |         rx1          % Receive chain
 71 |         tx1          % Transmit chain
 72 |     end
 73 |     
 74 |     properties (Access = private)
 75 |         running
 76 |     end
 77 |     
 78 |     properties(SetAccess=immutable)
 79 |         info        % Information about device properties and state
 80 |         versions    % Device and library version information
 81 |     end
 82 |     
 83 |     methods(Static, Hidden)
 84 |         function check_status(status)
 85 |             if status ~= 0
 86 |                 err_str = calllib('libLimeSuite', 'LMS_GetLastErrorMessage');
 87 |                 error([ 'LimeSDR error: ' err_str]);
 88 |             end
 89 |         end
 90 |     end
 91 |     
 92 |     methods(Static)
 93 |         function build_thunk
 94 |         % Build the MATLAB thunk library for use with the LimeSDR MATLAB wrapper
 95 |         %
 96 |         % limeSDR.build_thunk();
 97 |         %
 98 |         % This function is intended to provide developers with the means to
 99 |         % regenerate the libLimeSuite_thunk_<arch>.<library extension> files.
100 |         % Users of pre-built binaries need not concern themselves with this
101 |         % function.
102 |         %
103 |         % Use of this function requires that:
104 |         %   - The system contains a MATLAB-compatible compiler
105 |         %   - Any required libraries, DLLs, headers, etc. are in the search path or current working directory.
106 |         %
107 |         % For Windows users, the simplest approach is to copy the following
108 |         % to this directory:
109 |         %   - LimeSuite.dll
110 | 
111 |             if libisloaded('libLimeSuite') == true
112 |                 unloadlibrary('libLimeSuite');
113 |             end
114 |             
115 |             arch = computer('arch');
116 |             this_dir = pwd;
117 |             proto_output = 'delete_this_file';
118 |             switch arch
119 |                 case 'win64'
120 |                     [notfound, warnings] = loadlibrary('LimeSuite', 'LimeSuite_Build_Thunk.h', 'includepath', this_dir, 'alias', 'libLimeSuite', 'notempdir', 'mfilename', proto_output);
121 |                 case 'glnxa64'
122 |                     [notfound, warnings] = loadlibrary('libLimeSuite', 'LimeSuite_Build_Thunk.h', 'includepath', this_dir, 'notempdir', 'mfilename', proto_output);
123 |                 case 'maci64'
124 |                     [notfound, warnings] = loadlibrary('libLimeSuite.dylib', 'LimeSuite_Build_Thunk.h', 'includepath', this_dir, 'notempdir', 'mfilename', proto_output);
125 |                 otherwise
126 |                     error(strcat('Unsupported architecture: ', arch))
127 |             end
128 |             
129 |             % Remove the generated protofile that we don't want folks to
130 |             % use. Our hand-crafted protofile contains workarounds for
131 |             % loadlibrary() issues that the autogenerated file does not.
132 |             delete 'delete_this_file.m'
133 |             
134 |             if isempty(notfound) == false
135 |                 fprintf('\nMissing functions:\n');
136 |                 disp(notfound.');
137 |                 error('Failed to find the above functions in libLimeSuite.');
138 |             end
139 |             
140 |             if isempty(warnings) == false
141 |                 warning('Encountered the following warnings while loading libLimeSuite:\n%s\n', warnings);
142 |             end
143 |         end
144 |         function [major, minor, patch] = version()
145 |             major = 0;
146 |             minor = 0;
147 |             patch = 1;
148 |         end
149 |         function [version_string] = library_version()
150 |             limeSDR.load_library();
151 |             version_string=char(calllib('libLimeSuite', 'LMS_GetLibraryVersion'));
152 |         end
153 |         function devs = devices
154 |             limeSDR.load_library();
155 |             pdevlist = libpointer('int8Ptr');
156 |             
157 |             [count, ~] = calllib('libLimeSuite', 'LMS_GetDeviceList', pdevlist);
158 |             if count < 0
159 |                 error(calllib('libLimeSuite', 'LMS_GetLastErrorMessage'));
160 |             end
161 |             
162 |             if count > 0
163 |                 devs = repmat(struct('deviceName', [], 'expansionName', [], 'firmwareVersion', [], 'hardwareVersion', [], 'protocolVersion', [], 'boardSerialNumber', [], 'gatewareVersion', [], 'gatewareRevision', [], 'gatewareTargetBoard', []), 1, count);
164 |                 for x = 0:(count-1)
165 |                     dptr = libpointer('voidPtrPtr');
166 |                     calllib('libLimeSuite', 'LMS_Open', dptr,pdevlist+x,0);
167 |                     dinfo=libstruct('lms_dev_info_t',calllib('libLimeSuite', 'LMS_GetDeviceInfo', dptr));
168 |                     devs(x+1).deviceName=char(dinfo.deviceName);
169 |                     devs(x+1).expansionName=char(dinfo.expansionName);
170 |                     devs(x+1).firmwareVersion=char(dinfo.firmwareVersion);
171 |                     devs(x+1).hardwareVersion=char(dinfo.hardwareVersion);
172 |                     devs(x+1).protocolVersion=char(dinfo.protocolVersion);
173 |                     devs(x+1).gatewareVersion=char(dinfo.gatewareVersion);
174 |                     devs(x+1).gatewareRevision=char(dinfo.gatewareRevision);
175 |                     devs(x+1).gatewareTargetBoard=char(dinfo.gatewareTargetBoard);
176 |                     calllib('libLimeSuite', 'LMS_Close', dptr);
177 |                 end
178 |             else
179 |                 devs = [];
180 |             end
181 |         end
182 |     end
183 |     
184 |     methods(Static, Access = private)
185 |         function load_library
186 |             if libisloaded('libLimeSuite') == false
187 |                 arch = computer('arch');
188 |                 switch arch
189 |                     case 'win64'
190 |                         [notfound, warnings] = loadlibrary('LimeSuite', @libLimeSuite__proto, 'alias', 'libLimeSuite');
191 |                     case 'glnxa64'
192 |                         [notfound, warnings] = loadlibrary('libLimeSuite', @libLimeSuite__proto);
193 |                     case 'maci64'
194 |                         [notfound, warnings] = loadlibrary('libLimeSuite.dylib', @libLimeSuite__proto);
195 |                     otherwise
196 |                         error(strcat('Unsupported architecture: ', arch))
197 |                 end
198 |                 
199 |                 if isempty(notfound) == false
200 |                     error('Failed to find functions in libLimeSuite.');
201 |                 end
202 |                 
203 |                 if isempty(warnings) == false
204 |                     warning('Encountered the following warnings while loading libLimeSuite:\n%s\n', warnings);
205 |                 end
206 |             end
207 |             
208 |         end
209 |     end
210 |     
211 |     methods
212 |         function obj = limeSDR(serial)
213 |             
214 |             if nargin < 1
215 |                 serial = '';
216 |             end
217 |             
218 |             limeSDR.load_library();
219 |             %TODO serial select device
220 |             pdevlist = libpointer('int8Ptr');
221 |             
222 |             [count, ~] = calllib('libLimeSuite', 'LMS_GetDeviceList', pdevlist);
223 |             if count < 0
224 |                 error(calllib('libLimeSuite', 'LMS_GetLastErrorMessage'));
225 |             end
226 |             
227 |             dptr = libpointer('voidPtrPtr');
228 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_Open', dptr,pdevlist,0));
229 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_Init', dptr));
230 |             obj.device=dptr;
231 |             
232 |             dinfo=libstruct('lms_dev_info_t',calllib('libLimeSuite', 'LMS_GetDeviceInfo', obj.device));
233 |             obj.info.deviceName=char(dinfo.deviceName);
234 |             obj.info.expansionName=char(dinfo.expansionName);
235 |             obj.info.firmwareVersion=char(dinfo.firmwareVersion);
236 |             obj.info.hardwareVersion=char(dinfo.hardwareVersion);
237 |             obj.info.protocolVersion=char(dinfo.protocolVersion);
238 |             obj.info.gatewareVersion=char(dinfo.gatewareVersion);
239 |             obj.info.gatewareRevision=char(dinfo.gatewareRevision);
240 |             obj.info.gatewareTargetBoard=char(dinfo.gatewareTargetBoard);
241 |             
242 |             obj.versions.library_version=char(calllib('libLimeSuite', 'LMS_GetLibraryVersion'));
243 |             
244 |             obj.rx0 = limeSDR_XCVR(obj, 'RX',0);
245 |             obj.rx1 = limeSDR_XCVR(obj, 'RX',1);
246 |             obj.tx0 = limeSDR_XCVR(obj, 'TX',0);
247 |             obj.tx1 = limeSDR_XCVR(obj, 'TX',1);            
248 |             obj.running= false;
249 |             
250 |         end
251 |         
252 |         function delete(obj)
253 |             
254 |             %disp('Delete limeSDR called');
255 |             if isempty(obj.device) == false
256 |                 calllib('libLimeSuite', 'LMS_Close', obj.device);
257 |             end
258 |             
259 |         end
260 |         
261 |         function [samples, timestamp_out, actual_count, overrun] = receive(obj, num_samples, chan,timeout_ms, timestamp_in)
262 |             
263 |             if nargin < 3
264 |                 chan = 0;
265 |             end
266 |             
267 |             if nargin < 4
268 |                 timeout_ms = 1000;
269 |             end
270 |             
271 |             if nargin < 5
272 |                 timestamp_in = 0;
273 |             end
274 |             
275 |             if ~obj.running
276 |                 error('please start device');
277 |             end
278 |             
279 |             f32=single(zeros(2*num_samples, 1));
280 |             
281 |             metad = libstruct('lms_stream_meta_t');
282 |             
283 |             if timestamp_in == 0
284 |                 metad.waitForTimestamp=false;
285 |             else
286 |                 metad.waitForTimestamp=true;
287 |             end
288 |             metad.timestamp=timestamp_in;
289 |             if chan==0
290 |                 rx_stream=obj.rx0_stream;
291 |                 if isempty(rx_stream)
292 |                     error('rx0 stream not enabled');
293 |                 end
294 |             else
295 |                 rx_stream=obj.rx1_stream;
296 |                 
297 |                 if isempty(rx_stream)
298 |                     error('rx1 stream not enabled');
299 |                 end
300 |             end
301 |             
302 |             [actual_count, ~, f32, ~]=calllib('libLimeSuite', 'LMS_RecvStream', rx_stream,f32,num_samples,metad,timeout_ms);
303 |             samples=(double(f32(1:2:end)) + double(f32(2:2:end))*1j);
304 |             timestamp_out = metad.timestamp;
305 |         end
306 |         
307 |         function transmit(obj, samples,chan, timeout_ms, timestamp_in)
308 |             if nargin < 3
309 |                 chan = 0;
310 |             end
311 |             
312 |             if nargin < 4
313 |                 timeout_ms = 1000;
314 |             end
315 |             
316 |             if nargin < 5
317 |                 timestamp_in = 0;
318 |             end
319 |             
320 |             if ~obj.running
321 |                 error('please start device');
322 |             end
323 |             
324 |             metad = libstruct('lms_stream_meta_t');
325 |             
326 |             if timestamp_in == 0
327 |                 metad.waitForTimestamp=false;
328 |             else
329 |                 metad.waitForTimestamp=true;
330 |             end
331 |             metad.timestamp=timestamp_in;
332 |             
333 |             
334 |             if chan==0
335 |                 tx_stream=obj.tx0_stream;
336 |                 if isempty(tx_stream)
337 |                     error('tx0 stream not enabled');
338 |                 end
339 |             else
340 |                 tx_stream=obj.tx1_stream;
341 |                 if isempty(tx_stream)
342 |                     error('tx1 stream not enabled');
343 |                 end
344 |             end
345 |             
346 |             f32 = zeros(2 * length(samples), 1, 'single');
347 |             f32(1:2:end) = real(samples);
348 |             f32(2:2:end) = imag(samples);
349 |             
350 |             calllib('libLimeSuite', 'LMS_SendStream', tx_stream,f32,length(samples),metad,timeout_ms);
351 |         end
352 |         
353 |         function start(obj)
354 |             if isempty(obj.rx0_stream)==false
355 |                 limeSDR.check_status(calllib('libLimeSuite', 'LMS_StartStream', obj.rx0_stream));
356 |             end
357 |             
358 |             if isempty(obj.rx1_stream)==false
359 |                 limeSDR.check_status(calllib('libLimeSuite', 'LMS_StartStream', obj.rx1_stream));
360 |             end
361 |             
362 |             if isempty(obj.tx0_stream)==false
363 |                 limeSDR.check_status(calllib('libLimeSuite', 'LMS_StartStream', obj.tx0_stream));
364 |             end
365 |             
366 |             if isempty(obj.tx1_stream)==false
367 |                 limeSDR.check_status(calllib('libLimeSuite', 'LMS_StartStream', obj.tx1_stream));
368 |             end
369 |             
370 |             obj.running=true;
371 |         end
372 |         
373 |         function stop(obj)
374 |             
375 |             if obj.rx0.running
376 |                 obj.rx0.disable();
377 |             end
378 |             if obj.rx1.running
379 |                 obj.rx1.disable();
380 |             end
381 |             
382 |             if obj.tx0.running
383 |                 obj.tx0.disable();
384 |             end
385 |             
386 |             if obj.tx1.running
387 |                 obj.tx1.disable();
388 |             end
389 |             
390 |             if isempty(obj.rx0_stream)==false
391 |                 limeSDR.check_status(calllib('libLimeSuite', 'LMS_DestroyStream',obj.device, obj.rx0_stream));
392 |                 obj.rx0_stream=[];
393 |             end
394 |             
395 |             if isempty(obj.rx1_stream)==false
396 |                 limeSDR.check_status(calllib('libLimeSuite', 'LMS_DestroyStream',obj.device, obj.rx1_stream));
397 |                 obj.rx1_stream=[];
398 |             end
399 |             
400 |             if isempty(obj.tx0_stream)==false
401 |                 limeSDR.check_status(calllib('libLimeSuite', 'LMS_DestroyStream',obj.device, obj.tx0_stream));
402 |                 obj.tx0_stream=[];
403 |             end
404 |             
405 |             if isempty(obj.tx1_stream)==false
406 |                 limeSDR.check_status(calllib('libLimeSuite', 'LMS_DestroyStream',obj.device, obj.tx1_stream));
407 |                 obj.tx1_stream=[];
408 |             end
409 |             
410 |         end
411 |         
412 |         function loadconfig(obj,filename)
413 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_LoadConfig', obj.device,filename));
414 |         end
415 |     end
416 |     
417 | end


--------------------------------------------------------------------------------
/limeSDR_Simulink.m:
--------------------------------------------------------------------------------
  1 | classdef limeSDR_Simulink < matlab.System & ...
  2 |         matlab.system.mixin.Propagates & ...
  3 |         matlab.system.mixin.CustomIcon & ...
  4 |         matlab.system.mixin.internal.SampleTime
  5 |     %% Properties
  6 |     properties
  7 |         verbosity           = 'Info'    % limeSDR verbosity
  8 |         
  9 |         rx_frequency        = 915e6;    % Frequency [100e6, 3.8e9]
 10 |         
 11 |         rx0_gain =0.5;			% Gain [0, 1]
 12 |         rx1_gain =0.5;			% Gain [0, 1]
 13 |         
 14 |         tx_frequency = 920e6;    % Frequency [100e6, 3.8e9]      
 15 | 	
 16 |         tx0_gain =0.5;		 % Gain [0, 1]
 17 |         tx1_gain =0.5;		 % Gain [0, 1]
 18 |     end
 19 |     
 20 |     
 21 |     
 22 |     properties(Nontunable)
 23 |         device_string       = '';       % Device specification string
 24 |         
 25 |         rx_samplerate       = 3e6;      % Sample rate
 26 |         rx_step_size        = 16384;	% Frame
 27 |         rx_timeout_ms       = 5000;     % Stream timeout (ms)
 28 |         
 29 |         rx0_bandwidth        = '1.5';    % LPF Bandwidth (MHz)
 30 |         rx0_antenna   = 2;              %1=LNA_H 2=LNA_L 3=LNA_W
 31 |         
 32 |         rx1_bandwidth        = '1.5';    % LPF Bandwidth (MHz)
 33 |         rx1_antenna   = 2;%1=LNA_H 2=LNA_L 3=LNA_W
 34 |         
 35 |      
 36 |         tx_samplerate       = 3e6;      % Sample rate
 37 |         tx_step_size        = 16384;	% Frame
 38 |         tx_timeout_ms       = 5000;     % Stream timeout (ms)
 39 |         
 40 |         tx0_bandwidth        = '1.5';    % LPF Bandwidth (MHz)
 41 |         tx0_antenna   = 1;               %1=TX_PATH1 2=TX_PATH2
 42 | 
 43 |         
 44 |         tx1_bandwidth        = '1.5';    % LPF Bandwidth (MHz)
 45 |         tx1_antenna   = 1;%1=TX_PATH1 2=TX_PATH2
 46 | 
 47 |     end
 48 |     
 49 |     properties(Logical, Nontunable)
 50 |         enable_rx0           = true;     % Enable Receiver
 51 |         enable_rx1           = false;     % Enable Receiver
 52 |         
 53 |         enable_tx0           = false;    % Enable Transmitter
 54 |         enable_tx1           = false;    % Enable Transmitter
 55 |         
 56 |     end
 57 |     
 58 |     properties(Hidden, Transient)
 59 |         rx0_bandwidthSet = matlab.system.StringSet({ ...
 60 |             '1.5',  '1.75', '2.5',  '2.75',  ...
 61 |             '3',    '3.84', '5',    '5.5',   ...
 62 |             '6',    '7',    '8.75', '10',    ...
 63 |             '12',   '14',   '20',   '28'     ...
 64 |             });
 65 |         
 66 |         rx1_bandwidthSet = matlab.system.StringSet({ ...
 67 |             '1.5',  '1.75', '2.5',  '2.75',  ...
 68 |             '3',    '3.84', '5',    '5.5',   ...
 69 |             '6',    '7',    '8.75', '10',    ...
 70 |             '12',   '14',   '20',   '28'     ...
 71 |             });
 72 |         
 73 |         tx0_bandwidthSet = matlab.system.StringSet({ ...
 74 |             '1.5',  '1.75', '2.5',  '2.75',  ...
 75 |             '3',    '3.84', '5',    '5.5',   ...
 76 |             '6',    '7',    '8.75', '10',    ...
 77 |             '12',   '14',   '20',   '28'     ...
 78 |             });
 79 |         
 80 |         tx1_bandwidthSet = matlab.system.StringSet({ ...
 81 |             '1.5',  '1.75', '2.5',  '2.75',  ...
 82 |             '3',    '3.84', '5',    '5.5',   ...
 83 |             '6',    '7',    '8.75', '10',    ...
 84 |             '12',   '14',   '20',   '28'     ...
 85 |             });
 86 |     end
 87 |     
 88 |     properties (Access = private)
 89 |         device = []
 90 |         running
 91 |     end
 92 |     
 93 |     %% Static Methods
 94 |     methods (Static, Access = protected)
 95 |         function groups = getPropertyGroupsImpl
 96 |             device_section_group = matlab.system.display.SectionGroup(...
 97 |                 'Title', 'Device', ...
 98 |                 'PropertyList', {'device_string' } ...
 99 |                 );
100 |             
101 |             %%RX
102 |             
103 |             rx0_group = matlab.system.display.Section(...
104 |                 'Title','RX0 parameters',...
105 |                 'PropertyList',{'enable_rx0','rx0_antenna','rx0_bandwidth','rx0_gain'});
106 |             
107 |             rx1_group = matlab.system.display.Section(...
108 |                 'Title','RX1 parameters',...
109 |                 'PropertyList',{'enable_rx1','rx1_antenna','rx1_bandwidth','rx1_gain'});
110 |             
111 |             rx_stream_section = matlab.system.display.Section(...
112 |                 'Title', 'RX config', ...
113 |                 'PropertyList', {'rx_frequency','rx_samplerate', 'rx_timeout_ms', 'rx_step_size', } ...
114 |                 );
115 |             
116 |             rx_section_group = matlab.system.display.SectionGroup(...
117 |                 'Title', 'RX Configuration', ...
118 |                 'Sections', [ rx0_group, rx1_group, rx_stream_section] ...
119 |                 );
120 |             
121 |             %%TX
122 |             
123 |            tx0_group = matlab.system.display.Section(...
124 |                 'Title','TX0 parameters',...
125 |                 'PropertyList',{'enable_tx0','tx0_antenna','tx0_bandwidth','tx0_gain'});
126 |             
127 |             tx1_group = matlab.system.display.Section(...
128 |                 'Title','TX1 parameters',...
129 |                 'PropertyList',{'enable_tx1','tx1_antenna','tx1_bandwidth','tx1_gain'});
130 |             
131 |             tx_stream_section = matlab.system.display.Section(...
132 |                 'Title', 'TX config', ...
133 |                 'PropertyList', {'tx_frequency','tx_samplerate', 'tx_timeout_ms', 'tx_step_size', } ...
134 |                 );
135 |             
136 |             tx_section_group = matlab.system.display.SectionGroup(...
137 |                 'Title', 'TX Configuration', ...
138 |                 'Sections', [ tx0_group, tx1_group, tx_stream_section] ...
139 |                 );
140 |             
141 |             %     groups = [device_section_group,rx0_section_group,rx1_section_group, tx0_section_group, tx1_section_group ];
142 |             groups = [device_section_group,rx_section_group,tx_section_group ];
143 |             
144 |         end
145 |         
146 |         function simMode = getSimulateUsingImpl
147 |             % Return only allowed simulation mode in System block dialog
148 |             simMode = 'Interpreted execution';
149 |         end
150 |         
151 |         function flag = showSimulateUsingImpl
152 |             % Return false if simulation mode hidden in System block dialog
153 |             flag = false;
154 |         end
155 |         
156 |         function header = getHeaderImpl
157 |             text = 'This block provides access to a LimeSDR device via limeSDR MATLAB bindings.';
158 |             header = matlab.system.display.Header('limeSDR_Simulink', ...
159 |                 'Title', 'limeSDR', 'Text',  text ...
160 |                 );
161 |         end
162 |     end
163 |     
164 |     methods (Access = protected)
165 |         %% Output setup
166 |         function count = getNumOutputsImpl(obj)
167 |             if obj.enable_rx0 == true
168 |                 count = 1;
169 |             else
170 |                 count = 0;
171 |             end
172 |             
173 |             if obj.enable_rx1 == true
174 |                 count = count + 1;
175 |             end
176 |         end
177 |         
178 |         function varargout = getOutputNamesImpl(obj)
179 |             if obj.enable_rx0 == true
180 |                 varargout{1} = 'RX0 Samples';
181 |                 n = 2;
182 |             else
183 |                 n = 1;
184 |             end
185 |             
186 |             if obj.enable_rx1 ==true
187 |                 varargout{n} = 'RX1 Samples';
188 |                 n=n+1;
189 |             end
190 |         end
191 |         
192 |         function varargout = getOutputDataTypeImpl(obj)
193 |             if obj.enable_rx0 == true
194 |                 varargout{1} = 'double';    % RX0 Samples
195 |                 n = 2;
196 |             else
197 |                 n = 1;
198 |             end
199 |             
200 |             if obj.enable_rx1 == true
201 |                 varargout{n} = 'double';    % RX1 Samples
202 |             end
203 |             
204 |         end
205 |         
206 |         function st = getSampleTimeImpl(obj)
207 |                 st=1/obj.rx_samplerate*obj.rx_step_size;        
208 |         end
209 |         
210 |         
211 |         function varargout = getOutputSizeImpl(obj)
212 |             if obj.enable_rx0 == true
213 |                 varargout{1} = [obj.rx_step_size 1];  % RX0 Samples
214 |                 n = 2;
215 |             else
216 |                 n = 1;
217 |             end
218 |             
219 |             if obj.enable_rx1 == true
220 |                 varargout{n} = [obj.rx_step_size 1];  % RX1 Samples
221 |                 n=n+1;
222 |             end
223 |         end
224 |         
225 |         function varargout = isOutputComplexImpl(obj)
226 |             if obj.enable_rx0 == true
227 |                 varargout{1} = true;    % RX0 Samples
228 |                 n = 2;
229 |             else
230 |                 n = 1;
231 |             end
232 |             
233 |             if obj.enable_rx1 == true
234 |                 varargout{n} = true;   % RX1 Samples
235 |                 n = n + 1;
236 |             end
237 |         end
238 |         
239 |         function varargout  = isOutputFixedSizeImpl(obj)
240 |             if obj.enable_rx0 == true
241 |                 varargout{1} = true;    % RX0 Samples
242 |                 n = 2;
243 |             else
244 |                 n = 1;
245 |             end
246 |             
247 |             if obj.enable_rx1 == true
248 |                 varargout{n} = true;    % RX1 Samples
249 |             end
250 |             
251 |         end
252 |         
253 |         
254 |         %% Input setup
255 |         function count = getNumInputsImpl(obj)
256 |             if obj.enable_tx0 == true
257 |                 count = 1;
258 |             else
259 |                 count = 0;
260 |             end
261 |             
262 |             if obj.enable_tx1 == true
263 |                 count=count+1;
264 |             end
265 |         end
266 |         
267 |         function varargout = getInputNamesImpl(obj)
268 |             if obj.enable_tx0 == true
269 |                 varargout{1} = 'TX0 Samples';
270 |                 n = 2;
271 |             else
272 |                 n = 1;
273 |             end
274 |             
275 |             if obj.enable_tx1 == true
276 |                 varargout{n} = 'TX1 Samples';
277 |             end
278 |             
279 |         end
280 |         
281 |         %% Property and Execution Handlers
282 |         function icon = getIconImpl(~)
283 |             icon = sprintf('LimeSDR');
284 |         end
285 |         
286 |         function setupImpl(obj)
287 |             
288 |             %% Device setup
289 |             obj.device = limeSDR(obj.device_string);
290 |             
291 |             %% RX0 Setup
292 |             if obj.enable_rx0 == true
293 |                 obj.device.rx0.frequency  = obj.rx_frequency;
294 |                 obj.device.rx0.gain = obj.rx0_gain;
295 |                 obj.device.rx0.samplerate=obj.rx_samplerate;
296 |                 obj.device.rx0.antenna=obj.rx0_antenna;
297 |             end
298 |             
299 |             %% RX1 Setup
300 |             if obj.enable_rx1 == true
301 |                 obj.device.rx1.frequency  = obj.rx_frequency;
302 |                 obj.device.rx1.gain = obj.rx1_gain;
303 |                 obj.device.rx1.samplerate=obj.rx_samplerate;
304 |                 obj.device.rx1.antenna=obj.rx1_antenna;
305 |             end
306 |             
307 |             %% TX0 Setup
308 |             if obj.enable_tx0 == true
309 |                      obj.device.tx0.frequency  = obj.tx_frequency;
310 |                      obj.device.tx0.samplerate=obj.tx_samplerate;
311 |                      obj.device.tx0.gain = obj.tx0_gain;
312 |                      obj.device.tx0.antenna=obj.tx0_antenna;
313 |             end
314 |             
315 |             if obj.enable_tx1 == true
316 |                 %% TX1 Setup
317 |                        obj.device.tx1.frequency  = obj.tx_frequency;
318 |                        obj.device.tx1.samplerate=obj.tx_samplerate;
319 |                        obj.device.tx1.gain = obj.tx1_gain;
320 |                        obj.device.tx1.antenna=obj.tx1_antenna;
321 |             end
322 |             obj.running=false;
323 |             
324 |         end
325 |         
326 |         function releaseImpl(obj)
327 |             delete(obj.device);
328 |         end
329 |         
330 |         function resetImpl(obj)
331 |             obj.device.stop();
332 |         end
333 |         
334 |         % Perform a read of received samples and an 'overrun' array that denotes whether
335 |         % the associated samples is invalid due to a detected overrun.
336 |         function varargout = stepImpl(obj, varargin)
337 |             varargout = {};
338 |             
339 |             if obj.enable_rx0 == true
340 |                 if obj.device.rx0.running == false
341 |                     obj.device.rx0.enable();
342 |                 end
343 |             end
344 |             
345 |             if obj.enable_rx1 == true
346 |                 if obj.device.rx1.running == false
347 |                     obj.device.rx1.enable();
348 |                 end
349 |             end
350 |             
351 |             if obj.enable_tx0 == true
352 |                 if obj.device.tx0.running == false
353 |                     obj.device.tx0.enable();
354 |                 end
355 |             end
356 |             
357 |             if obj.enable_tx1 == true
358 |                 if obj.device.tx1.running == false
359 |                     obj.device.tx1.enable();
360 |                 end
361 |             end
362 |             
363 |             if ~obj.running
364 |                 obj.device.start();
365 |                 obj.running=true;
366 |             end
367 |             
368 |             if obj.enable_rx0 == true
369 |                 
370 |                 [rx_samples0, ~] = obj.device.receive(obj.rx_step_size,0);
371 |                 varargout{1} = rx_samples0;
372 |                 out_idx = 2;
373 |             else
374 |                 out_idx = 1;
375 |             end
376 |             
377 |             if obj.enable_rx1 == true
378 |                 
379 |                 [rx_samples1, ~] = obj.device.receive(obj.rx_step_size,1);
380 |                 
381 |                 varargout{out_idx} = rx_samples1;
382 |             end
383 |             
384 |             if obj.enable_tx0 == true
385 |                 obj.device.transmit(varargin{1},0);
386 |                 in_idx=2;
387 |             else
388 |                 in_idx=1;
389 |             end
390 |             
391 |             if obj.enable_tx1 == true
392 |                 if obj.device.tx1.running == false
393 |                     obj.device.tx1.start();
394 |                 end
395 |                 obj.device.transmit(varargin{in_idx},1);
396 |             end
397 |         end
398 |         
399 |         function processTunedPropertiesImpl(obj)
400 |             
401 |             %% RX Properties
402 |             
403 |                if isChangedProperty(obj, 'rx_frequency')
404 |                      if obj.enable_rx0 ==true
405 |                         obj.device.rx0.frequency = obj.rx_frequency;
406 |                      end
407 |                      
408 |                     if obj.enable_rx1 ==true
409 |                         obj.device.rx1.frequency = obj.rx_frequency;
410 |                      end
411 |                     %disp('Updated RX frequency');
412 |                 end
413 |             
414 |             if obj.enable_rx0 ==true
415 |                 if isChangedProperty(obj, 'rx0_gain')
416 |                     obj.device.rx0.gain = obj.rx0_gain;
417 |                     %disp('Updated RX0 gain');
418 |                 end
419 |             end
420 |             
421 |             if obj.enable_rx1 ==true
422 |                 if isChangedProperty(obj, 'rx1_gain')
423 |                     obj.device.rx1.gain = obj.rx1_gain;
424 |                     %disp('Updated RX1 gain');
425 |                 end
426 |             end
427 |             %% TX Properties
428 |             
429 |              if isChangedProperty(obj, 'tx_frequency')
430 |                   if obj.enable_tx0 ==true
431 |                     obj.device.tx0.frequency = obj.tx_frequency;
432 |                   end
433 |                   
434 |                    if obj.enable_tx1 ==true
435 |                        obj.device.tx1.frequency = obj.tx_frequency;
436 |                    end
437 |                     %disp('Updated TX frequency');
438 |                 end
439 |             
440 |             if obj.enable_tx0 ==true
441 |                 if isChangedProperty(obj, 'tx0_frequency')
442 |                     obj.device.tx0.frequency = obj.tx0_frequency;
443 |                     %disp('Updated TX frequency');
444 |                 end
445 |                 
446 |                 if isChangedProperty(obj, 'tx0_gain')
447 |                     obj.device.tx0.gain = obj.tx0_gain;
448 |                     %disp('Updated TX VGA1 gain');
449 |                 end
450 |                 
451 |                 
452 |             end
453 |             
454 |             
455 |             if obj.enable_tx1 ==true
456 |                 if isChangedProperty(obj, 'tx1_gain')
457 |                     obj.device.tx1.gain = obj.tx1_gain;
458 |                     %disp('Updated TX VGA1 gain');
459 |                 end           
460 |             end
461 |             
462 |         end
463 |         
464 |         function validatePropertiesImpl(obj)
465 |             if obj.enable_rx0 == false && obj.enable_tx0 == false && obj.enable_rx1 == false && obj.enable_tx1 == false
466 |                 warning('LimeSDR RX or TX is enabled. One or both should be enabled.');
467 |             end
468 |             
469 |             %% Validate RX properties
470 |             
471 |             if obj.rx_timeout_ms < 0
472 |                 error('rx_timeout_ms must be >= 0.');
473 |             end
474 |             
475 |             if obj.rx_step_size <= 0
476 |                 error('rx_step_size must be > 0.');
477 |             end
478 |             
479 |             if obj.rx_samplerate < 160.0e3
480 |                 error('rx_samplerate must be >= 160 kHz.');
481 |             elseif obj.rx_samplerate > 40e6
482 |                 error('rx_samplerate must be <= 40 MHz.')
483 |             end
484 |             
485 |             if obj.rx_frequency < 100e3
486 |                 error('rx_frequency must be >= 100 kHz');
487 |             elseif obj.rx_frequency > 3.8e9
488 |                 error('rx_frequency must be <= 3.8 GHz.');
489 |             end
490 |             
491 |             if obj.rx0_gain < 0
492 |                 error('rx0_gain gain must be >= 0.');
493 |             elseif obj.rx0_gain > 1
494 |                 error('rx0_gain gain must be <= 1.');
495 |             end
496 |             
497 |             if obj.rx0_antenna <0
498 |                 error('rx0_antenna must be >= 0.');
499 |             elseif obj.rx0_antenna >3
500 |                 error('rx0_antenna must be <= 3.');
501 |             end
502 |             
503 |             
504 |             if obj.rx1_gain < 0
505 |                 error('rx1_gain gain must be >= 0.');
506 |             elseif obj.rx1_gain > 1
507 |                 error('rx1_gain gain must be <= 1.');
508 |             end
509 |             
510 |             if obj.rx1_antenna <0
511 |                 error('rx1_antenna must be >= 0.');
512 |             elseif obj.rx1_antenna >3
513 |                 error('rx1_antenna must be <= 3.');
514 |             end
515 |             
516 |             %% Validate TX0 Properties
517 |             
518 |             if obj.tx_timeout_ms < 0
519 |                 error('tx_timeout_ms must be >= 0.');
520 |             end
521 |             
522 |             if obj.tx_step_size <= 0
523 |                 error('tx_step_size must be > 0.');
524 |             end
525 |             
526 |             if obj.tx_samplerate < 160.0e3
527 |                 error('tx_samplerate must be >= 160 kHz.');
528 |             elseif obj.tx_samplerate > 40e6
529 |                 error('tx_samplerate must be <= 40 MHz.')
530 |             end
531 |             
532 |             if obj.tx_frequency < 100e6;
533 |                 error('tx_frequency must be >= 100 kHz.');
534 |             elseif obj.tx_frequency > 3.8e9
535 |                 error('tx_frequency must be <= 3.8 GHz.');
536 |             end
537 |             
538 |             if obj.tx0_gain < 0
539 |                 error('tx_vga2 gain must be >= 0.');
540 |             elseif obj.tx0_gain > 1
541 |                 error('tx_vga2 gain must be <= 1.');
542 |             end
543 |             
544 |             if obj.tx0_antenna <0
545 |                 error('rx0_antenna must be >= 0.');
546 |             elseif obj.tx0_antenna >2
547 |                 error('rx0_antenna must be <= 2.');
548 |             end
549 |             
550 |             if obj.tx1_gain < 0
551 |                 error('tx1_gain gain must be >= 0.');
552 |             elseif obj.tx1_gain > 1
553 |                 error('tx1_gain gain must be <= 1.');
554 |             end
555 |             
556 |             if obj.tx1_antenna <0
557 |                 error('tx1_antenna must be >= 0.');
558 |             elseif obj.tx1_antenna >2
559 |                 error('tx1_antenna must be <= 2.');
560 |             end
561 |             
562 |         end
563 |     end
564 | end
565 | 


--------------------------------------------------------------------------------
/limeSDR_XCVR.m:
--------------------------------------------------------------------------------
  1 | %
  2 | % Copyright (c) 2017 JiangWei
  3 | % Copyright (c) 2015 Nuand LLC
  4 | %
  5 | % Permission is hereby granted, free of charge, to any person obtaining a copy
  6 | % of this software and associated documentation files (the "Software"), to deal
  7 | % in the Software without restriction, including without limitation the rights
  8 | % to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  9 | % copies of the Software, and to permit persons to whom the Software is
 10 | % furnished to do so, subject to the following conditions:
 11 | %
 12 | % The above copyright notice and this permission notice shall be included in
 13 | % all copies or substantial portions of the Software.
 14 | %
 15 | % THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16 | % IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 17 | % FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 18 | % AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 19 | % LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 20 | % OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 21 | % THE SOFTWARE.
 22 | %
 23 | classdef limeSDR_XCVR < handle
 24 |     
 25 |     properties(Dependent = true)
 26 |         samplerate      % Samplerate. Must be within 160 kHz and 40 MHz. A 2-3 MHz minimum is suggested unless external filters are being used.
 27 |         frequency       % Frequency. Must be within [237.5 MHz, 3.8 GHz] when no XB-200 is attached, or [0 GHz, 3.8 GHz] when an XB-200 is attached.
 28 |         bandwidth       % LPF bandwidth seting. This is rounded to the nearest of the available discrete settings. It is recommended to set this and read back the actual value.
 29 |         antenna
 30 |         gain
 31 |         channal
 32 |     end
 33 |     
 34 |     properties(SetAccess = private)
 35 |         running         % Denotes whether or not the module is enabled to stream samples.
 36 |         timestamp       % Provides a coarse readback of the timestamp counter.
 37 |     end
 38 |     
 39 |     properties (Access = private)
 40 |         
 41 |         
 42 |         
 43 |     end
 44 |     
 45 |     properties(SetAccess = immutable, Hidden=true)
 46 |         limesdr         % Associated limeSDR device handle
 47 |         isTx            % Module specifier (as a libLimeSuite enum)
 48 |         chan
 49 |     end
 50 |     
 51 |     methods
 52 |         
 53 |         function set.samplerate(obj, val)
 54 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_SetSampleRate', obj.limesdr.device,val,0));
 55 |         end
 56 |         
 57 |         function samplerate_val = get.samplerate(obj)
 58 |             host_Hz=libpointer('doublePtr',0);
 59 |             rf_Hz=libpointer('doublePtr',0);
 60 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_GetSampleRate', obj.limesdr.device,obj.isTx,obj.chan,host_Hz,rf_Hz));
 61 |             samplerate_val=host_Hz.value;
 62 |         end
 63 |         
 64 |         function set.frequency(obj, val)
 65 |             %  limeSDR.check_status(calllib('libLimeSuite', 'LMS_SetLOFrequency', obj.limesdr.device,obj.isTx,obj.chan,val));
 66 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_SetLOFrequency', obj.limesdr.device,obj.isTx,0,val));
 67 |         end
 68 |         
 69 |         function freq_val = get.frequency(obj)
 70 |             freq_hz=libpointer('doublePtr',0);
 71 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_GetLOFrequency', obj.limesdr.device,obj.isTx,obj.chan,freq_hz));
 72 |             freq_val=freq_hz.value;
 73 |         end
 74 |         
 75 |         function set.bandwidth(obj, val)
 76 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_SetLPFBW', obj.limesdr.device,obj.isTx,obj.chan,val));
 77 |         end
 78 |         
 79 |         function bw_val = get.bandwidth(obj)
 80 |             bw=libpointer('doublePtr',0);
 81 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_GetLPFBW', obj.limesdr.device,obj.isTx,obj.chan,bw));
 82 |             bw_val=bw.value;
 83 |         end
 84 |         
 85 |         function set.antenna(obj,index)            
 86 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_SetAntenna', obj.limesdr.device,obj.isTx,obj.chan,index));           
 87 |         end
 88 |         
 89 |         function ant_index = get.antenna(obj)
 90 |             ant_index= calllib('libLimeSuite', 'LMS_GetAntenna', obj.limesdr.device,obj.isTx,0);
 91 |         end
 92 |         
 93 |         function set.gain(obj,val)            
 94 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_SetGaindB', obj.limesdr.device,obj.isTx,obj.chan,val));
 95 |         end
 96 |         
 97 |         function val = get.gain(obj)           
 98 |             gain_val=libpointer('doublePtr',0);
 99 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_GetGaindB', obj.limesdr.device,obj.isTx,obj.chan,gain_val));
100 |             val=gain_val.value;
101 |         end
102 |         
103 |         function obj = limeSDR_XCVR(dev, dir, chan)
104 |             
105 |             if nargin < 3
106 |                 chan = 0;
107 |             end
108 |             
109 |             if strcmpi(dir,'RX') == false && strcmpi(dir,'TX') == false
110 |                 error('Invalid direction specified');
111 |             end
112 |             
113 |             obj.chan=chan;
114 |             obj.limesdr=dev;
115 |             
116 |             if strcmpi(dir,'RX') == true
117 |                 obj.isTx = 0;
118 |                 obj.antenna=2;%LNA_L
119 |             else
120 |                 obj.isTx = 1;
121 |                 obj.antenna=1;%TX_PATH1
122 |             end
123 |             obj.samplerate = 3e6;
124 |             obj.frequency = 100e6;
125 |             %  obj.bandwidth = 30e6;
126 |             
127 |             obj.running = false;
128 |             
129 |         end
130 |         
131 |         function enable(obj)
132 |             obj.running = true;
133 |             
134 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_EnableChannel', obj.limesdr.device,obj.isTx,obj.chan,1));
135 |             stream=libstruct('lms_stream_t');
136 |             
137 |             stream.isTx=obj.isTx;
138 |             stream.channel=obj.chan;
139 |             stream.fifoSize=1024*128;
140 |             stream.throughputVsLatency=1.0;
141 |             
142 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_SetupStream',obj.limesdr.device, stream));
143 |             
144 |             if(obj.isTx)
145 |                 if obj.chan==0
146 |                     obj.limesdr.tx0_stream=stream;
147 |                 else
148 |                     obj.limesdr.tx1_stream=stream;
149 |                 end
150 |                 
151 |             else
152 |                 if obj.chan==0
153 |                     obj.limesdr.rx0_stream=stream;
154 |                 else
155 |                     obj.limesdr.rx1_stream=stream;
156 |                 end
157 |             end
158 |             
159 |         end
160 |         
161 |         function disable(obj)
162 |             if(obj.isTx)
163 |                 if obj.chan==0
164 |                     stream=obj.limesdr.tx0_stream;
165 |                 else
166 |                     stream=obj.limesdr.tx1_stream;
167 |                 end
168 |             else
169 |                 if obj.chan==0
170 |                     stream=obj.limesdr.rx0_stream;
171 |                 else
172 |                     stream=obj.limesdr.rx1_stream;
173 |                 end
174 |             end
175 |             
176 |             if ~isempty(stream)
177 |                 limeSDR.check_status(calllib('libLimeSuite', 'LMS_StopStream', stream));
178 |             end
179 |             
180 |             limeSDR.check_status(calllib('libLimeSuite', 'LMS_EnableChannel', obj.limesdr.device,obj.isTx,obj.chan,0));
181 |             obj.running = false;
182 |             
183 |         end
184 |         
185 |     end
186 | end


--------------------------------------------------------------------------------