| % Copyright 2014(c) Analog Devices, Inc. |
| % |
| % All rights reserved. |
| % |
| % Redistribution and use in source and binary forms, with or without modification, |
| % are permitted provided that the following conditions are met: |
| % - Redistributions of source code must retain the above copyright |
| % notice, this list of conditions and the following disclaimer. |
| % - Redistributions in binary form must reproduce the above copyright |
| % notice, this list of conditions and the following disclaimer in |
| % the documentation and/or other materials provided with the |
| % distribution. |
| % - Neither the name of Analog Devices, Inc. nor the names of its |
| % contributors may be used to endorse or promote products derived |
| % from this software without specific prior written permission. |
| % - The use of this software may or may not infringe the patent rights |
| % of one or more patent holders. This license does not release you |
| % from the requirement that you obtain separate licenses from these |
| % patent holders to use this software. |
| % - Use of the software either in source or binary form or filter designs |
| % resulting from the use of this software, must be connected to, run |
| % on or loaded to an Analog Devices Inc. component. |
| % |
| % THIS SOFTWARE IS PROVIDED BY ANALOG DEVICES "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| % INCLUDING, BUT NOT LIMITED TO, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A |
| % PARTICULAR PURPOSE ARE DISCLAIMED. |
| % |
| % IN NO EVENT SHALL ANALOG DEVICES BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| % EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, INTELLECTUAL PROPERTY |
| % RIGHTS, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR |
| % BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| % STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF |
| % THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| classdef libiio_if < handle |
| % libiio_if Interface object for for IIO devices |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Protected properties |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| properties (Access = protected) |
| libname = 'libiio'; |
| hname = 'iio-wrapper.h'; |
| dev_name = ''; |
| data_ch_no = 0; |
| data_ch_size = 0; |
| dev_type = ''; |
| iio_ctx = {}; |
| iio_dev = {}; |
| iio_buffer = {}; |
| iio_channel = {}; |
| iio_buf_size = 8192; |
| iio_scan_elm_no = 0; |
| if_initialized = 0; |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Static private methods |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| methods (Static, Access = private) |
| function out = modInstanceCnt(val) |
| % Manages the number of object instances to handle proper DLL unloading |
| persistent instance_cnt; |
| if isempty(instance_cnt) |
| instance_cnt = 0; |
| end |
| instance_cnt = instance_cnt + val; |
| out = instance_cnt; |
| end |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Protected methods |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| methods (Access = protected) |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Creates the network context |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function [ret, err_msg, msg_log] = createNetworkContext(obj, ip_address) |
| % Initialize the return values |
| ret = -1; |
| err_msg = ''; |
| msg_log = []; |
| |
| % Create the network context |
| obj.iio_ctx = calllib(obj.libname, 'iio_create_network_context', ip_address); |
| |
| % Check if the network context is valid |
| if (isNull(obj.iio_ctx)) |
| obj.iio_ctx = {}; |
| err_msg = 'Could not connect to the IIO server!'; |
| return; |
| end |
| |
| % Increase the object's instance count |
| libiio_if.modInstanceCnt(1); |
| msg_log = [msg_log sprintf('%s: Connected to IP %s\n', class(obj), ip_address)]; |
| |
| % Set the return code to success |
| ret = 0; |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Releases the network context and unload the libiio library |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function releaseContext(obj) |
| calllib(obj.libname, 'iio_context_destroy', obj.iio_ctx); |
| obj.iio_ctx = {}; |
| instCnt = libiio_if.modInstanceCnt(-1); |
| if(instCnt == 0) |
| unloadlibrary(obj.libname); |
| end |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Checks the compatibility of the different software modules. |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function [ret, err_msg, msg_log] = checkVersions(obj) |
| % Initialize the return values |
| ret = -1; |
| err_msg = ''; |
| msg_log = []; |
| |
| % Create a set of pointers to read the iiod and dll versions |
| data = zeros(1, 10); |
| remote_pMajor = libpointer('uint32Ptr', data(1)); |
| remote_pMinor = libpointer('uint32Ptr', data(2)); |
| remote_pGitTag = libpointer('int8Ptr', [int8(data(3:end)) 0]); |
| local_pMajor = libpointer('uint32Ptr', data(1)); |
| local_pMinor = libpointer('uint32Ptr', data(2)); |
| local_pGitTag = libpointer('int8Ptr', [int8(data(3:end)) 0]); |
| |
| % get remote libiio version |
| calllib(obj.libname, 'iio_context_get_version', obj.iio_ctx, remote_pMajor, remote_pMinor, remote_pGitTag); |
| % extract git hash without trailing null char |
| remote_githash = remote_pGitTag.Value(1:7); |
| remote_version_str = sprintf('Remote libiio version: %d.%d, (git-%s)', remote_pMajor.Value, remote_pMinor.Value, remote_githash); |
| msg_log = [msg_log sprintf('%s: %s\n', class(obj), remote_version_str)]; |
| |
| % get local libiio version |
| calllib(obj.libname, 'iio_library_get_version', local_pMajor, local_pMinor, local_pGitTag); |
| local_githash = local_pGitTag.Value(1:7); |
| local_version_str = sprintf('Local libiio version: %d.%d, (git-%s)', local_pMajor.Value, local_pMinor.Value, local_githash); |
| msg_log = [msg_log sprintf('%s: %s\n', class(obj), local_version_str)]; |
| |
| if(remote_pMajor.Value < local_pMajor.Value) |
| err_msg = ['The libiio version running on the device is outdated! ' ... |
| 'Run the adi_update_tools.sh script to get libiio up to date.']; |
| return; |
| elseif(remote_pMajor.Value > local_pMajor.Value) |
| err_msg = ['The libiio version on the local host is outdated! ' ... |
| 'On Windows, reinstall the dll using the latest installer ' ... |
| 'from the Analog Devices wiki.']; |
| return; |
| end |
| |
| % Set the return code to success |
| ret = 0; |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Detect if the specified device is present in the system |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function [ret, err_msg, msg_log] = initDevice(obj, dev_name) |
| % Initialize the return values |
| ret = -1; |
| err_msg = ''; |
| msg_log = []; |
| |
| % Store the device name |
| obj.dev_name = dev_name; |
| |
| % Get the number of devices |
| nb_devices = calllib(obj.libname, 'iio_context_get_devices_count', obj.iio_ctx); |
| |
| % If no devices are present return with error |
| if(nb_devices == 0) |
| err_msg = 'No devices were detected in the system!'; |
| return; |
| end |
| msg_log = [msg_log sprintf('%s: Found %d devices in the system\n', class(obj), nb_devices)]; |
| |
| % Detect if the targeted device is installed |
| dev_found = 0; |
| for i = 0 : nb_devices - 1 |
| dev = calllib(obj.libname, 'iio_context_get_device', obj.iio_ctx, i); |
| name = calllib(obj.libname, 'iio_device_get_name', dev); |
| if(strcmp(name, dev_name)) |
| obj.iio_dev = dev; |
| dev_found = 1; |
| break; |
| end |
| clear dev; |
| end |
| |
| % Check if the target device was detected |
| if(dev_found == 0) |
| err_msg = 'Could not find target configuration device!'; |
| return; |
| end |
| |
| msg_log = [msg_log sprintf('%s: %s was found in the system\n', class(obj), obj.dev_name)]; |
| |
| % Set the return code to success |
| ret = 0; |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Initializes the output data channels |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function [ret, err_msg, msg_log] = initOutputDataChannels(obj, ch_no, ch_size) |
| % Initialize the return values |
| ret = -1; |
| err_msg = ''; |
| msg_log = []; |
| |
| % Save the number of channels and size |
| obj.data_ch_no = ch_no; |
| obj.data_ch_size = ch_size; |
| |
| % Get the number of channels that the device has |
| nb_channels = calllib(obj.libname, 'iio_device_get_channels_count', obj.iio_dev); |
| if(nb_channels == 0) |
| err_msg = 'The selected device does not have any channels!'; |
| return; |
| end |
| |
| % Enable the data channels |
| if(ch_no ~= 0) |
| % Check if the device has output channels. The |
| % logic here assumes that a device can have |
| % only input or only output channels |
| obj.iio_channel{1} = calllib(obj.libname, 'iio_device_get_channel', obj.iio_dev, 0); |
| is_output = calllib(obj.libname, 'iio_channel_is_output', obj.iio_channel{1}); |
| if(is_output == 0) |
| err_msg = 'The selected device does not have output channels!'; |
| return; |
| end |
| % Enable all the channels |
| for j = 0 : nb_channels - 1 |
| obj.iio_channel{j+1} = calllib(obj.libname, 'iio_device_get_channel', obj.iio_dev, j); |
| calllib(obj.libname, 'iio_channel_enable', obj.iio_channel{j+1}); |
| is_scan_element = calllib(obj.libname, 'iio_channel_is_scan_element', obj.iio_channel{j+1}); |
| if(is_scan_element == 1) |
| obj.iio_scan_elm_no = obj.iio_scan_elm_no + 1; |
| end |
| end |
| msg_log = [msg_log sprintf('%s: Found %d output channels for the device %s\n', class(obj), obj.iio_scan_elm_no, obj.dev_name)]; |
| |
| % Check if the number of channels in the device |
| % is greater or equal to the system object |
| % input channels |
| if(obj.iio_scan_elm_no < ch_no) |
| obj.iio_channel = {}; |
| err_msg = 'The selected device does not have enough output channels!'; |
| return; |
| end |
| |
| % Enable the DAC buffer output |
| obj.if_initialized = 1; |
| ret = writeAttributeString(obj, 'altvoltage0*raw', '0'); |
| obj.if_initialized = 0; |
| if(ret < 0) |
| obj.iio_channel = {}; |
| err_msg = 'Could not enable the DAC buffer output!'; |
| return; |
| end |
| |
| % Create the IIO buffer used to write data |
| obj.iio_buf_size = obj.data_ch_size * obj.iio_scan_elm_no; |
| obj.iio_buffer = calllib(obj.libname, 'iio_device_create_buffer', obj.iio_dev,... |
| obj.data_ch_size, 1); |
| end |
| |
| msg_log = [msg_log sprintf('%s: %s output data channels successfully initialized\n', class(obj), obj.dev_name)]; |
| |
| % Set the return code to success |
| ret = 0; |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Initializes the input data channels |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function [ret, err_msg, msg_log] = initInputDataChannels(obj, ch_no, ch_size) |
| % Initialize the return values |
| ret = -1; |
| err_msg = ''; |
| msg_log = []; |
| |
| % Save the number of channels and size |
| obj.data_ch_no = ch_no; |
| obj.data_ch_size = ch_size; |
| |
| % Get the number of channels that the device has |
| nb_channels = calllib(obj.libname, 'iio_device_get_channels_count', obj.iio_dev); |
| if(nb_channels == 0) |
| err_msg = 'The selected device does not have any channels!'; |
| return; |
| end |
| |
| % Enable the system object output channels |
| if(ch_no ~= 0) |
| % Check if the device has input channels. The |
| % logic here assumes that a device can have |
| % only input or only output channels |
| obj.iio_channel{1} = calllib(obj.libname, 'iio_device_get_channel', obj.iio_dev, 0); |
| is_output = calllib(obj.libname, 'iio_channel_is_output', obj.iio_channel{1}); |
| if(is_output == 1) |
| err_msg = 'The selected device does not have input channels!'; |
| return; |
| end |
| msg_log = [msg_log sprintf('%s: Found %d input channels for the device %s\n', class(obj), nb_channels, obj.dev_name)]; |
| |
| % Check if the number of channels in the device |
| % is greater or equal to the system object |
| % output channels |
| if(nb_channels < ch_no) |
| obj.iio_channel = {}; |
| err_msg = 'The selected device does not have enough input channels!'; |
| return; |
| end |
| |
| % Enable the channels |
| for j = 0 : ch_no - 1 |
| obj.iio_channel{j+1} = calllib(obj.libname, 'iio_device_get_channel', obj.iio_dev, j); |
| calllib(obj.libname, 'iio_channel_enable', obj.iio_channel{j+1}); |
| end |
| for j = ch_no : nb_channels - 1 |
| obj.iio_channel{j+1} = calllib(obj.libname, 'iio_device_get_channel', obj.iio_dev, j); |
| calllib(obj.libname, 'iio_channel_disable', obj.iio_channel{j+1}); |
| end |
| % Create the IIO buffer used to read data |
| obj.iio_buf_size = obj.data_ch_size * obj.data_ch_no; |
| obj.iio_buffer = calllib(obj.libname, 'iio_device_create_buffer', obj.iio_dev, obj.iio_buf_size, 0); |
| end |
| |
| msg_log = [msg_log sprintf('%s: %s input data channels successfully initialized\n', class(obj), obj.dev_name)]; |
| |
| % Set the return code to success |
| ret = 0; |
| end |
| |
| end |
| |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Public methods |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| methods |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Constructor |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function obj = libiio_if() |
| % Constructor |
| obj.if_initialized = 0; |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Destructor |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function delete(obj) |
| % Release any resources used by the system object. |
| if((obj.if_initialized == 1) && libisloaded(obj.libname)) |
| if(~isempty(obj.iio_buffer)) |
| calllib(obj.libname, 'iio_buffer_destroy', obj.iio_buffer); |
| end |
| if(~isempty(obj.iio_ctx)) |
| calllib(obj.libname, 'iio_context_destroy', obj.iio_ctx); |
| end |
| obj.iio_buffer = {}; |
| obj.iio_channel = {}; |
| obj.iio_dev = {}; |
| obj.iio_ctx = {}; |
| instCnt = libiio_if.modInstanceCnt(-1); |
| if(instCnt == 0) |
| unloadlibrary(obj.libname); |
| end |
| end |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Initializes the libiio interface |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function [ret, err_msg, msg_log] = init(obj, ip_address, ... |
| dev_name, dev_type, ... |
| data_ch_no, data_ch_size) |
| % Initialize the return values |
| ret = -1; |
| err_msg = ''; |
| msg_log = []; |
| |
| % Save the device type |
| obj.dev_type = dev_type; |
| |
| % Set the initialization status to fail |
| obj.if_initialized = 0; |
| |
| % Load the libiio library |
| if(~libisloaded(obj.libname)) |
| try |
| % ignore unknown type warnings due to header parsing limitations |
| warnState = warning('off', 'MATLAB:loadlibrary:TypeNotFound'); |
| cleanupObj = onCleanup(@()warning(warnState)); |
| [notfound, warnings] = loadlibrary(obj.libname, obj.hname, 'addheader', 'iio.h'); |
| cleanupObj = []; % restore the warning state |
| catch exception |
| err_msg = exception.message; |
| return; |
| end |
| end |
| |
| if(~libisloaded(obj.libname)) |
| err_msg = 'Could not load the libiio library!'; |
| return; |
| end |
| |
| % Create the network context |
| [ret, err_msg, msg_log] = createNetworkContext(obj, ip_address); |
| if(ret < 0) |
| return; |
| end |
| |
| % Check the software versions |
| [ret, err_msg, msg_log_new] = checkVersions(obj); |
| msg_log = [msg_log msg_log_new]; |
| if(ret < 0) |
| releaseContext(obj); |
| return; |
| end |
| |
| % Initialize the device |
| [ret, err_msg, msg_log_new] = initDevice(obj, dev_name); |
| msg_log = [msg_log msg_log_new]; |
| if(ret < 0) |
| releaseContext(obj); |
| return; |
| end |
| |
| % Initialize the output data channels |
| if(strcmp(dev_type, 'OUT')) |
| [ret, err_msg, msg_log_new] = initOutputDataChannels(obj, data_ch_no, data_ch_size); |
| msg_log = [msg_log msg_log_new]; |
| if(ret < 0) |
| releaseContext(obj); |
| return; |
| end |
| end |
| |
| % Initialize the input data channels |
| if(strcmp(dev_type, 'IN')) |
| [ret, err_msg, msg_log_new] = initInputDataChannels(obj, data_ch_no, data_ch_size); |
| msg_log = [msg_log msg_log_new]; |
| if(ret < 0) |
| releaseContext(obj); |
| return; |
| end |
| end |
| |
| % Set the initialization status to success |
| obj.if_initialized = 1; |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Implement the data capture flow |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function [ret, data] = readData(obj) |
| % Initialize the return values |
| ret = -1; |
| data = cell(1, obj.data_ch_no); |
| for i = 1 : obj.data_ch_no |
| data{i} = zeros(obj.data_ch_size, 1); |
| end |
| |
| % Check if the interface is initialized |
| if(obj.if_initialized == 0) |
| return; |
| end |
| |
| % Check if the device type is output |
| if(~strcmp(obj.dev_type, 'IN')) |
| return; |
| end |
| |
| % Read the data |
| calllib(obj.libname, 'iio_buffer_refill', obj.iio_buffer); |
| buffer = calllib(obj.libname, 'iio_buffer_first', obj.iio_buffer, obj.iio_channel{1}); |
| setdatatype(buffer, 'int16Ptr', obj.iio_buf_size); |
| for i = 1 : obj.data_ch_no |
| data{i} = double(buffer.Value(i:obj.data_ch_no:end)); |
| end |
| |
| % Set the return code to success |
| ret = 0; |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Implement the data transmit flow |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function ret = writeData(obj, data) |
| % Initialize the return values |
| ret = -1; |
| |
| % Check if the interface is initialized |
| if(obj.if_initialized == 0) |
| return; |
| end |
| |
| % Check if the device type is input |
| if(~strcmp(obj.dev_type, 'OUT')) |
| return; |
| end |
| |
| % Destroy the buffer |
| calllib(obj.libname, 'iio_buffer_destroy', obj.iio_buffer); |
| obj.iio_buffer = {}; |
| |
| % Enable the DAC buffer output |
| ret = writeAttributeString(obj, 'altvoltage0*raw', '0'); |
| if(ret < 0) |
| obj.iio_channel = {}; |
| err_msg = 'Could not enable the DAC buffer output!'; |
| return; |
| end |
| |
| % Create the IIO buffer used to write data |
| obj.iio_buf_size = obj.data_ch_size * obj.iio_scan_elm_no; |
| obj.iio_buffer = calllib(obj.libname, 'iio_device_create_buffer', obj.iio_dev,... |
| obj.data_ch_size, 1); |
| |
| % Transmit the data |
| buffer = calllib(obj.libname, 'iio_buffer_start', obj.iio_buffer); |
| setdatatype(buffer, 'int16Ptr', obj.iio_buf_size); |
| for i = 1 : obj.data_ch_no |
| buffer.Value(i : obj.iio_scan_elm_no : obj.iio_buf_size) = int16(data{i}); |
| end |
| for i = obj.data_ch_no + 1 : obj.iio_scan_elm_no |
| buffer.Value(i : obj.iio_scan_elm_no : obj.iio_buf_size) = 0; |
| end |
| calllib(obj.libname, 'iio_buffer_push', obj.iio_buffer); |
| |
| % Set the return code to success |
| ret = 0; |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Find an attribute based on the name. The name can contain wildcard '*' characters |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function [ret, ch, attr] = findAttribute(obj, attr_name) |
| % Initialize the return values |
| ret = -1; |
| ch = 0; |
| attr = ''; |
| |
| % Check if the interface is initialized |
| if(obj.if_initialized == 0) |
| return; |
| end |
| |
| % Check if this is a device attribute |
| name = calllib(obj.libname, 'iio_device_find_attr', obj.iio_dev, attr_name); |
| if(~isempty(name)) |
| ret = 0; |
| return; |
| end |
| |
| % This is a channel attribute, search for the corresponding channel |
| chn_no = calllib(obj.libname, 'iio_device_get_channels_count', obj.iio_dev); |
| for k = 0 : chn_no - 1 |
| ch = calllib(obj.libname, 'iio_device_get_channel', obj.iio_dev, k); |
| attr_no = calllib(obj.libname, 'iio_channel_get_attrs_count', ch); |
| attr_found = 0; |
| for l = 0 : attr_no - 1 |
| attr = calllib(obj.libname, 'iio_channel_get_attr', ch, l); |
| name = calllib(obj.libname, 'iio_channel_attr_get_filename', ch, attr); |
| % The attribute to find can contain wildcard '*' characters, |
| % search for all the substrings in the attribute name |
| str_find = strsplit(attr_name, '*'); |
| str_find = str_find(find(~strcmp(str_find, ''))); |
| has_wildcard = ~isempty(strfind(attr_name, '*')); |
| attr_found = 1; |
| for i = 1 : length(str_find) |
| if(has_wildcard == 0) |
| ret = strcmp(name, str_find{i}); |
| if(ret == 0) |
| ret = []; |
| end |
| else |
| ret = strfind(name, str_find{i}); |
| end |
| if(isempty(ret)) |
| attr_found = 0; |
| break; |
| end |
| end |
| if(attr_found == 1) |
| break; |
| end |
| clear attr; |
| end |
| % Check if the attribute was found |
| if(attr_found == 0) |
| clear ch; |
| else |
| ret = 1; |
| break; |
| end |
| end |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Read an attribute as a double value |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function [ret, val] = readAttributeDouble(obj, attr_name) |
| % Find the attribute |
| [ret, ch, attr] = findAttribute(obj, attr_name); |
| if(ret < 0) |
| val = 0; |
| return; |
| end |
| |
| % Create a double pointer to be used for data read |
| data = zeros(1, 10); |
| pData = libpointer('doublePtr', data(1)); |
| |
| % Read the attribute value |
| if(ret > 0) |
| calllib(obj.libname, 'iio_channel_attr_read_double', ch, attr, pData); |
| clear ch; |
| clear attr; |
| else |
| calllib(obj.libname, 'iio_device_attr_read_double', obj.iio_dev, attr_name, pData); |
| end |
| val = pData.Value; |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Read an attribute as a string value |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function [ret, val] = readAttributeString(obj, attr_name) |
| % Find the attribute |
| [ret, ch, attr] = findAttribute(obj, attr_name); |
| if(ret < 0) |
| val = ''; |
| return; |
| end |
| |
| % Create a pointer to be used for data read |
| data = char(ones(1, 512)); |
| pData = libpointer('stringPtr', data); |
| |
| % Read the attribute value |
| if(ret > 0) |
| [~, ~, ~, val] = calllib(obj.libname, 'iio_channel_attr_read', ch, attr, pData, 512); |
| clear ch; |
| clear attr; |
| else |
| [~, ~, ~, val] = calllib(obj.libname, 'iio_device_attr_read', obj.iio_dev, attr_name, pData, 512); |
| end |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Write a string double value |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function ret = writeAttributeDouble(obj, attr_name, val) |
| % Find the attribute |
| [ret, ch, attr] = findAttribute(obj, attr_name); |
| if(ret < 0) |
| return; |
| end |
| |
| % Write the attribute |
| if(ret > 0) |
| calllib(obj.libname, 'iio_channel_attr_write_double', ch, attr, val); |
| clear ch; |
| clear attr; |
| else |
| calllib(obj.libname, 'iio_device_attr_write_double', obj.iio_dev, attr_name, val); |
| end |
| end |
| |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| %% Write a string attribute value |
| %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% |
| function ret = writeAttributeString(obj, attr_name, str) |
| % Find the attribute |
| [ret, ch, attr] = findAttribute(obj, attr_name); |
| if(ret < 0) |
| return; |
| end |
| |
| % Write the attribute |
| if(ret > 0) |
| calllib(obj.libname, 'iio_channel_attr_write', ch, attr, str); |
| clear ch; |
| clear attr; |
| else |
| calllib(obj.libname, 'iio_device_attr_write', obj.iio_dev, attr_name, str); |
| end |
| end |
| end |
| end |
