From 86e5e0b4ccc0fc4ca09a8e829ee1db3e9bbbd064 Mon Sep 17 00:00:00 2001 From: dpu1778 Date: Mon, 16 Mar 2015 13:00:03 -0400 Subject: [PATCH] uploaded the MATLAB version initial upload --- iio_sys_obj_matlab.m | 283 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 283 insertions(+) create mode 100644 iio_sys_obj_matlab.m diff --git a/iio_sys_obj_matlab.m b/iio_sys_obj_matlab.m new file mode 100644 index 0000000..dd736c1 --- /dev/null +++ b/iio_sys_obj_matlab.m @@ -0,0 +1,283 @@ +classdef iio_sys_obj_matlab + % iio_sys_obj System Object block for IIO devices + + properties (Access = public) + % Public, non-tunable properties. + + %ip_address IP address + ip_address = ''; + + %dev_name Device name + dev_name = ''; + + %in_ch_no Number of input data channels + in_ch_no = 0; + + %in_ch_size Input data channel size [samples] + in_ch_size = 8192; + + %out_ch_no Number of output data channels + out_ch_no = 0; + + %out_ch_size Output data channel size [samples] + out_ch_size = 8192; + end + + properties (Access = public) + % Protected class properties. + + %iio_dev_cfg Device configuration structure + iio_dev_cfg = []; + end + + properties (Access = private) + % Private class properties. + + %libiio_data_in_dev libiio IIO interface object for the input data device + libiio_data_in_dev = {}; + + %libiio_data_out_dev libiio IIO interface object for the output data device + libiio_data_out_dev = {}; + + %libiio_ctrl_dev libiio IIO interface object for the control device + libiio_ctrl_dev = {}; + + %sys_obj_initialized Holds the initialization status of the system object + sys_obj_initialized = 0; + end + + properties (Access = private) + % Discrete state properties. + + %num_cfg_in Numeric type input control channels data + num_cfg_in; + + %str_cfg_in String type input control channels data + str_cfg_in; + end + + methods + %% Constructor + function obj = iio_sys_obj_matlab(varargin) + % Construct the libiio interface objects + obj.libiio_data_in_dev = libiio_if(); + obj.libiio_data_out_dev = libiio_if(); + obj.libiio_ctrl_dev = libiio_if(); + end + end + + methods (Access = protected) + %% Utility functions + + function config = getObjConfig(obj) + % Read the selected device configuration + + % Open the configuration file + fname = sprintf('%s.cfg', obj.dev_name); + fp_cfg = fopen(fname); + if(fp_cfg < 0) + config = {}; + return; + end + + % Build the object configuration structure + config = struct('data_in_device', '',... % Pointer to the data input device + 'data_out_device', '',... % Pointer to the data output device + 'ctrl_device', '',... % Pointer to the control device + 'cfg_ch', [],... % Configuration channels list + 'mon_ch', []); % Monitoring channels list + + % Build the configuration/monitoring channels structure + ch_cfg = struct('port_name', '',... % Name of the port to be displayed on the object block + 'port_attr', '',... % Associated device attribute name + 'ctrl_dev_name', '',... % Control device name + 'ctrl_dev', 0); % Pointer to the control device object + + % Read the object's configuration + while(~feof(fp_cfg)) + line = fgets(fp_cfg); + if(strfind(line,'#')) + continue; + end + if(~isempty(strfind(line, 'channel'))) + % Get the associated configuration/monitoring channels + idx = strfind(line, '='); + line = line(idx+1:end); + line = strsplit(line, ','); + ch_cfg.port_name = strtrim(line{1}); + ch_cfg.port_attr = strtrim(line{3}); + if(length(line) > 4) + ch_cfg.ctrl_dev_name = strtrim(line{4}); + else + ch_cfg.ctrl_dev_name = 'ctrl_device'; + end + if(strcmp(strtrim(line{2}), 'IN')) + config.cfg_ch = [config.cfg_ch ch_cfg]; + elseif(strcmp(strtrim(line{2}), 'OUT')) + config.mon_ch = [config.mon_ch ch_cfg]; + end + elseif(~isempty(strfind(line, 'data_in_device'))) + % Get the associated data input device + idx = strfind(line, '='); + tmp = line(idx+1:end); + tmp = strtrim(tmp); + config.data_in_device = tmp; + elseif(~isempty(strfind(line, 'data_out_device'))) + % Get the associated data output device + idx = strfind(line, '='); + tmp = line(idx+1:end); + tmp = strtrim(tmp); + config.data_out_device = tmp; + elseif(~isempty(strfind(line, 'ctrl_device'))) + % Get the associated control device + idx = strfind(line, '='); + tmp = line(idx+1:end); + tmp = strtrim(tmp); + config.ctrl_device = tmp; + end + end + fclose(fp_cfg); + end + + end + + methods (Access = public) + %% Common functions + function ret = setupImpl(obj) + % Implement tasks that need to be performed only once. + + % Set the initialization status to fail + obj.sys_obj_initialized = 0; + + % Read the object's configuration from the associated configuration file + obj.iio_dev_cfg = getObjConfig(obj); + if(isempty(obj.iio_dev_cfg)) + msgbox('Could not read device configuration!', 'Error','error'); + return; + end + + % Initialize discrete-state properties. + obj.num_cfg_in = zeros(1, length(obj.iio_dev_cfg.cfg_ch)); + obj.str_cfg_in = zeros(length(obj.iio_dev_cfg.cfg_ch), 64); + + % Initialize the libiio data input device + if(obj.in_ch_no ~= 0) + [ret, err_msg, msg_log] = init(obj.libiio_data_in_dev, obj.ip_address, ... + obj.iio_dev_cfg.data_in_device, 'OUT', ... + obj.in_ch_no, obj.in_ch_size); + fprintf('%s', msg_log); + if(ret < 0) + msgbox(err_msg, 'Error','error'); + return; + end + end + + % Initialize the libiio data output device + if(obj.out_ch_no ~= 0) + [ret, err_msg, msg_log] = init(obj.libiio_data_out_dev, obj.ip_address, ... + obj.iio_dev_cfg.data_out_device, 'IN', ... + obj.out_ch_no, obj.out_ch_size); + fprintf('%s', msg_log); + if(ret < 0) + msgbox(err_msg, 'Error','error'); + return; + end + end + + % Initialize the libiio control device + if(~isempty(obj.iio_dev_cfg.ctrl_device)) + [ret, err_msg, msg_log] = init(obj.libiio_ctrl_dev, obj.ip_address, ... + obj.iio_dev_cfg.ctrl_device, '', ... + 0, 0); + fprintf('%s', msg_log); + if(ret < 0) + msgbox(err_msg, 'Error','error'); + return; + end + end + + % Assign the control device for each monitoring channel + for i = 1 : length(obj.iio_dev_cfg.mon_ch) + if(strcmp(obj.iio_dev_cfg.mon_ch(i).ctrl_dev_name, 'data_in_device')) + obj.iio_dev_cfg.mon_ch(i).ctrl_dev = obj.libiio_data_in_dev; + elseif(strcmp(obj.iio_dev_cfg.mon_ch(i).ctrl_dev_name, 'data_out_device')) + obj.iio_dev_cfg.mon_ch(i).ctrl_dev = obj.libiio_data_out_dev; + else + obj.iio_dev_cfg.mon_ch(i).ctrl_dev = obj.libiio_ctrl_dev; + end + end + + % Assign the control device for each configuration channel + for i = 1 : length(obj.iio_dev_cfg.cfg_ch) + if(strcmp(obj.iio_dev_cfg.cfg_ch(i).ctrl_dev_name, 'data_in_device')) + obj.iio_dev_cfg.cfg_ch(i).ctrl_dev = obj.libiio_data_in_dev; + elseif(strcmp(obj.iio_dev_cfg.cfg_ch(i).ctrl_dev_name, 'data_out_device')) + obj.iio_dev_cfg.cfg_ch(i).ctrl_dev = obj.libiio_data_out_dev; + else + obj.iio_dev_cfg.cfg_ch(i).ctrl_dev = obj.libiio_ctrl_dev; + end + end + + % Set the initialization status to success + obj.sys_obj_initialized = 1; + ret = obj; + end + + function releaseImpl(obj) + % Release any resources used by the system object. + obj.iio_dev_cfg = {}; + delete(obj.libiio_data_in_dev); + delete(obj.libiio_data_out_dev); + delete(obj.libiio_ctrl_dev); + end + + function ret = stepImpl(obj, varargin) + % Implement the system object's processing flow. + varargout = cell(1, obj.out_ch_no + length(obj.iio_dev_cfg.mon_ch)); + if(obj.sys_obj_initialized == 0) + return; + end + + % Implement the device configuration flow + for i = 1 : length(obj.iio_dev_cfg.cfg_ch) + if(~isempty(varargin{1}{i + obj.in_ch_no})) + if(length(varargin{1}{i + obj.in_ch_no}) == 1) + new_data = (varargin{1}{i + obj.in_ch_no} ~= obj.num_cfg_in(i)); + else + new_data = ~strncmp(char(varargin{1}{i + obj.in_ch_no}'), char(obj.str_cfg_in(i,:)), length(varargin{1}{i + obj.in_ch_no})); + end + if(new_data == 1) + if(length(varargin{1}{i + obj.in_ch_no}) == 1) + obj.num_cfg_in(i) = varargin{1}{i + obj.in_ch_no}; + str = num2str(obj.num_cfg_in(i)); + else + for j = 1:length(varargin{1}{i + obj.in_ch_no}) + obj.str_cfg_in(i,j) = varargin{1}{i + obj.in_ch_no}(j); + end + obj.str_cfg_in(i,j+1) = 0; + str = char(obj.str_cfg_in(i,:)); + end + writeAttributeString(obj.iio_dev_cfg.cfg_ch(i).ctrl_dev, obj.iio_dev_cfg.cfg_ch(i).port_attr, str); + end + end + end + + % Implement the data transmit flow + writeData(obj.libiio_data_in_dev, varargin{1}); + + % Implement the data capture flow + [~, data] = readData(obj.libiio_data_out_dev); + for i = 1 : obj.out_ch_no + varargout{i} = data{i}; + end + + % Implement the parameters monitoring flow + for i = 1 : length(obj.iio_dev_cfg.mon_ch) + [~, val] = readAttributeDouble(obj.iio_dev_cfg.mon_ch(i).ctrl_dev, obj.iio_dev_cfg.mon_ch(i).port_attr); + varargout{obj.out_ch_no + i} = val; + end + + ret=varargout; + end + end +end \ No newline at end of file