diff --git a/+adi/+common b/+adi/+common
index d13b9a1..18d652f 160000
--- a/+adi/+common
+++ b/+adi/+common
@@ -1 +1 @@
-Subproject commit d13b9a109cfd4ab61b5d0e55930d0a4659f4771a
+Subproject commit 18d652fde70e79888a9c70d3e3db05988b121f6f
diff --git a/+adi/+libiio/attribute.m b/+adi/+libiio/attribute.m
index 12875a3..fb53824 100644
--- a/+adi/+libiio/attribute.m
+++ b/+adi/+libiio/attribute.m
@@ -1,67 +1,57 @@
-classdef (Abstract) attribute < handle
-    % matlabshared.libiio.attribute attribute class for base adi.libiio.support
-    %
-    % This abstract system object defines the APIs necessary to use libIIO
-    % V1.0 for MATLAB/Simulink simulation as well as codegen on a Linux
-    % target
-    
-    % Copyright 2024 Analog Devices Inc.
-    %#codegen
-    
-    %% Abstract Properties
-    properties(Abstract, Hidden, Access = protected)
-        libName
-    end
-
-    methods
-        function obj = attribute()
-            % CHANNEL constructor method for matlabshared.libiio.context
-            %
-            % Returns the matlabshared.libiio.context object
-            coder.allowpcode('plain');
-        end
-    end
+classdef attribute < handle
+    % methods
+    %     function obj = attribute()
+    %         % CHANNEL constructor method for matlabshared.libiio.context
+    %         %
+    %         % Returns the matlabshared.libiio.context object
+    %         coder.allowpcode('plain');
+    %     end
+    % end
     
     %% Internal Helper Functions
-    methods (Hidden, Access = {?handle}, Static)
-        function [status, value] = iio_attr_read_bool(obj, attrPtr)
+    methods (Static)
+        function [status, value] = iio_attr_read_bool(attrPtr)
             valPtr = libpointer('bool', 0);
-            status = calllib(obj.libName, 'iio_attr_read_bool', attrPtr, valPtr);
+            status = calllib(adi.libiio.attribute.getIIOLibName(), 'iio_attr_read_bool', attrPtr, valPtr);
             if ~status
                 value = valPtr.value;
             end
         end
 
-        function [status, value] = iio_attr_read_longlong(obj, attrPtr)
+        function [status, value] = iio_attr_read_longlong(attrPtr)
             valPtr = libpointer('int64Ptr', 0);
-            status = calllib(obj.libName, 'iio_attr_read_longlong', attrPtr, valPtr);
+            status = calllib(adi.libiio.attribute.getIIOLibName(), 'iio_attr_read_longlong', attrPtr, valPtr);
             if ~status
                 value = valPtr.value;
             end
         end
 
-        function [status, value] = iio_attr_read_double(obj, attrPtr)
+        function [status, value] = iio_attr_read_double(attrPtr)
             valPtr = libpointer('double', 0);
-            status = calllib(obj.libName, 'iio_attr_read_double', attrPtr, valPtr);
+            status = calllib(adi.libiio.attribute.getIIOLibName(), 'iio_attr_read_double', attrPtr, valPtr);
             if ~status
                 value = valPtr.value;
             end
         end
 
-        function status = iio_attr_write_string(obj, attrPtr, value)
-            status = calllib(obj.libName, 'iio_attr_write_string', attrPtr, value);
+        function status = iio_attr_write_string(attrPtr, value)
+            status = calllib(adi.libiio.attribute.getIIOLibName(), 'iio_attr_write_string', attrPtr, value);
+        end
+
+        function status = iio_attr_write_bool(attrPtr, value)
+            status = calllib(adi.libiio.attribute.getIIOLibName(), 'iio_attr_write_bool', attrPtr, value);
         end
 
-        function status = iio_attr_write_bool(obj, attrPtr, value)
-            status = calllib(obj.libName, 'iio_attr_write_bool', attrPtr, value);
+        function status = iio_attr_write_longlong(attrPtr, value)
+            status = calllib(adi.libiio.attribute.getIIOLibName(), 'iio_attr_write_longlong', attrPtr, value);
         end
 
-        function status = iio_attr_write_longlong(obj, attrPtr, value)
-            status = calllib(obj.libName, 'iio_attr_write_longlong', attrPtr, value);
+        function status = iio_attr_write_double(attrPtr, value)
+            status = calllib(adi.libiio.attribute.getIIOLibName(), 'iio_attr_write_double', attrPtr, value);
         end
 
-        function status = iio_attr_write_double(obj, attrPtr, value)
-            status = calllib(obj.libName, 'iio_attr_write_double', attrPtr, value);
+        function libName = getIIOLibName()
+            libName = 'libiio1';
         end
     end
 end
\ No newline at end of file
diff --git a/+adi/+libiio/base.m b/+adi/+libiio/base.m
index 1273107..894a8c4 100644
--- a/+adi/+libiio/base.m
+++ b/+adi/+libiio/base.m
@@ -1,7 +1,4 @@
-classdef (Abstract) base < adi.libiio.device & ...
-        adi.libiio.channel & ...
-        adi.libiio.context & ...
-        adi.libiio.top & ...
+classdef (Abstract) base < adi.libiio.top & ...
         adi.libiio.low_level & ...
         matlab.System
     properties (Hidden, Access = {?handle}, Abstract)
@@ -58,7 +55,7 @@
         % function status = cPtrCheck(obj,ptr)
         %     % Returns 0 if ptr is a valid pointer, negative error code
         %     % otherwise
-        %     status = -int32(isNull(ptr));            
+        %     status = -int32(isNull(ptr));
         % end
     end
 
@@ -77,7 +74,7 @@ function setupImpl(obj)
             
             % Get context
             % obj.iioCtx = calllib(obj.libName, 'iio_create_context', obj.iioCtxParams, obj.uri);
-            obj.iioCtx = adi.libiio.context.iio_create_context(obj, obj.iioCtxParams, obj.uri);
+            obj.iioCtx = adi.libiio.context.iio_create_context(obj.iioCtxParams, obj.uri);
             status = -int32(isNull(obj.iioCtx));% cPtrCheck(obj,obj.iioCtx);
             
             % Set context timeout
@@ -85,7 +82,7 @@ function setupImpl(obj)
 
             % Get AD9361 PHY device
             % obj.iioDev = calllib(obj.libName, 'iio_context_find_device', obj.iioCtx, 'ad9361-phy');
-            [status, obj.iioDev] = adi.libiio.context.iio_context_find_device(obj, obj.iioCtx, 'ad9361-phy');
+            obj.iioDev = adi.libiio.context.iio_context_find_device(obj.iioCtx, 'ad9361-phy');
 
             obj.needsTeardown = true;
 
@@ -94,7 +91,7 @@ function setupImpl(obj)
 
             % Find AD9361 LO channel
             % obj.iioChn = calllib(obj.libName, 'iio_device_find_channel', obj.iioDev, 'altvoltage0', true);
-            obj.iioChn = adi.libiio.device.iio_device_find_channel(obj, obj.iioDev, 'altvoltage0', true);
+            obj.iioChn = adi.libiio.device.iio_device_find_channel(obj.iioDev, 'altvoltage0', true);
             
             % obj.iioAttr = calllib(obj.libName, 'iio_channel_find_attr', obj.iioChn, 'frequency');
 
diff --git a/+adi/+libiio/channel.m b/+adi/+libiio/channel.m
index 09bbb37..5d3e7ce 100644
--- a/+adi/+libiio/channel.m
+++ b/+adi/+libiio/channel.m
@@ -1,18 +1,4 @@
-classdef (Abstract) channel < adi.libiio.attribute
-    % matlabshared.libiio.channel_V1p0 channel class for base matlabshared.libiio.support
-    %
-    % This abstract system object defines the APIs necessary to use libIIO
-    % V1.0 for MATLAB/Simulink simulation as well as codegen on a Linux
-    % target
-    
-    % Copyright 2024 Analog Devices Inc.
-    %#codegen
-    
-    %% Abstract Properties
-    properties(Abstract, Hidden, Access = protected)
-        libName
-    end
-
+classdef channel < handle
     methods
         function obj = channel()
             % CHANNEL constructor method for matlabshared.libiio.context
@@ -23,40 +9,43 @@
     end
     
     %% Internal Helper Functions
-    methods (Hidden, Access = {?handle}, Static)
-        function [status, attrPtr] = iio_channel_find_attr(obj,chanPtr,attr)
-            attrPtr = calllib(obj.libName, 'iio_channel_find_attr', chanPtr, attr);
-            status = cPtrCheck(obj,attrPtr);
+    methods (Static)
+        function attrPtr = iio_channel_find_attr(chanPtr,attr)
+            attrPtr = calllib(adi.libiio.channel.getIIOLibName(), 'iio_channel_find_attr', chanPtr, attr);
         end
 
-        function [status, value] = iio_channel_attr_read_bool(obj,chanPtr,attr)
-            [status, attrPtr] = adi.libiio.channel.iio_channel_find_attr(obj,chanPtr,attr);
-            cstatus(obj,status,['Attribute: ' attr ' not found']);            
-            [status, value] = adi.libiio.attribute.iio_attr_read_bool(obj,attrPtr);
+        function [status, value] = iio_channel_attr_read_bool(chanPtr,attr)
+            attrPtr = adi.libiio.channel.iio_channel_find_attr(chanPtr,attr);
+            % cstatus(status,['Attribute: ' attr ' not found']);            
+            [status, value] = adi.libiio.attribute.iio_attr_read_bool(attrPtr);
         end
 
-        function [status, value] = iio_channel_attr_read_longlong(obj,chanPtr,attr)
-            [status, attrPtr] = adi.libiio.channel.iio_channel_find_attr(obj,chanPtr,attr);
-            cstatus(obj,status,['Attribute: ' attr ' not found']);            
-            [status, value] = adi.libiio.attribute.iio_attr_read_longlong(obj,attrPtr);
+        function [status, value] = iio_channel_attr_read_longlong(chanPtr,attr)
+            attrPtr = adi.libiio.channel.iio_channel_find_attr(chanPtr,attr);
+            % cstatus(status,['Attribute: ' attr ' not found']);            
+            [status, value] = adi.libiio.attribute.iio_attr_read_longlong(attrPtr);
         end
 
-        function status = iio_channel_attr_write_bool(obj,chanPtr,attr,value)
-            [status, attrPtr] = adi.libiio.channel.iio_channel_find_attr(obj,chanPtr,attr);
-            cstatus(obj,status,['Attribute: ' attr ' not found']);
+        function status = iio_channel_attr_write_bool(chanPtr,attr,value)
+            attrPtr = adi.libiio.channel.iio_channel_find_attr(chanPtr,attr);
+            % cstatus(status,['Attribute: ' attr ' not found']);
             status = adi.libiio.attribute.iio_attr_write_bool(attrPtr, value);
         end
 
-        function status = iio_channel_attr_write_longlong(obj,chanPtr,attr,value)
-            [status, attrPtr] = adi.libiio.channel.iio_channel_find_attr(obj,chanPtr,attr);
-            cstatus(obj,status,['Attribute: ' attr ' not found']);
+        function status = iio_channel_attr_write_longlong(chanPtr,attr,value)
+            attrPtr = adi.libiio.channel.iio_channel_find_attr(chanPtr,attr);
+            % cstatus(status,['Attribute: ' attr ' not found']);
             status = adi.libiio.attribute.iio_attr_write_longlong(attrPtr, value);
         end
 
-        function nBytes = iio_channel_attr_write(obj, chanPtr, attr, src)
-            [status, attrPtr] = adi.libiio.channel.iio_channel_find_attr(obj,chanPtr,attr);
-            cstatus(obj,status,['Attribute: ' attr ' not found']);
+        function nBytes = iio_channel_attr_write(chanPtr, attr, src)
+            attrPtr = adi.libiio.channel.iio_channel_find_attr(chanPtr,attr);
+            % cstatus(status,['Attribute: ' attr ' not found']);
             nBytes = adi.libiio.attribute.iio_attr_write_string(attrPtr, src);
         end
+
+        function libName = getIIOLibName()
+            libName = 'libiio1';
+        end
     end
 end
\ No newline at end of file
diff --git a/+adi/+libiio/context.m b/+adi/+libiio/context.m
index 533208e..05aefc3 100644
--- a/+adi/+libiio/context.m
+++ b/+adi/+libiio/context.m
@@ -1,38 +1,17 @@
-classdef (Abstract) context < handle% & matlabshared.libiio.context & ...
-        %matlabshared.libiio.device
-    % matlabshared.libiio.contextV1p0 context class for base matlabshared.libiio.support
-    %
-    % This abstract system object defines the APIs necessary to use libIIO
-    % V1.0 for MATLAB/Simulink simulation as well as codegen on a Linux
-    % target
-    
-    % Copyright 2024 Analog Devices Inc.
-    %#codegen
-    
-    %% Abstract Properties
-    properties(Abstract, Hidden, Access = protected)
-        libName
-    end
-    
-    methods
-        function obj = context()
-            % CONTEXT constructor method for matlabshared.libiio.context
-            %
-            % Returns the matlabshared.libiio.context object
-            coder.allowpcode('plain');
-        end
-    end
-    
+classdef context < handle
     %% Internal Helper Functions
-    methods (Hidden, Access = {?handle}, Static)
+    methods (Static)
         %% Context Methods
-        function ctxPtr = iio_create_context(obj, ctxParamsPtr, uri)
-            ctxPtr = calllib(obj.libName, 'iio_create_context', ctxParamsPtr, uri);
+        function ctxPtr = iio_create_context(ctxParamsPtr, uri)
+            ctxPtr = calllib(adi.libiio.context.getIIOLibName(), 'iio_create_context', ctxParamsPtr, uri);
         end
 
-        function [status, devPtr] = iio_context_find_device(obj, ctxPtr, name)
-            devPtr = calllib(obj.libName, 'iio_context_find_device', ctxPtr, name);
-            status = cPtrCheck(obj,devPtr);
-        end        
+        function devPtr = iio_context_find_device(ctxPtr, name)
+            devPtr = calllib(adi.libiio.context.getIIOLibName(), 'iio_context_find_device', ctxPtr, name);
+        end
+
+        function libName = getIIOLibName()
+            libName = 'libiio1';
+        end
     end
 end
\ No newline at end of file
diff --git a/+adi/+libiio/device.m b/+adi/+libiio/device.m
index 27bb290..4612a2e 100644
--- a/+adi/+libiio/device.m
+++ b/+adi/+libiio/device.m
@@ -1,63 +1,40 @@
-classdef (Abstract) device < adi.libiio.attribute% & matlabshared.libiio.device
-    % matlabshared.libiio.contextV1p0 context class for base matlabshared.libiio.support
-    %
-    % This abstract system object defines the APIs necessary to use libIIO
-    % V1.0 for MATLAB/Simulink simulation as well as codegen on a Linux
-    % target
-    
-    % Copyright 2024 Analog Devices Inc.
-    %#codegen
-    
-    %% Abstract Properties
-    properties(Abstract, Hidden, Access = protected)
-        libName
-    end
-    
-    methods
-        function obj = device()
-            % CONTEXT constructor method for matlabshared.libiio.context
-            %
-            % Returns the matlabshared.libiio.context object
-            coder.allowpcode('plain');
-        end
-    end
-    
+classdef device < handle
     %% Internal Helper Functions
-    methods (Hidden, Access = {?handle}, Static)
+    methods (Static)
         %% Device Methods
-        function ctxPtr = iio_device_get_context(obj, devPtr)   
-            ctxPtr = calllib(obj.libName, 'iio_device_get_context', devPtr);
-        end
-
-        function id = iio_device_get_id(obj, devPtr)
-            id = calllib(obj.libName, 'iio_device_get_id', devPtr);
+        function ctxPtr = iio_device_get_context(devPtr)   
+            ctxPtr = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_get_context', devPtr);
         end
 
-        function name = iio_device_get_name(obj, devPtr)
-            name = calllib(obj.libName, 'iio_device_get_name', devPtr);
-        end
-
-        function label = iio_device_get_label(obj, devPtr)
-            label = calllib(obj.libName, 'iio_device_get_label', devPtr);
-        end
+        % function id = iio_device_get_id(devPtr)
+        %     id = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_get_id', devPtr);
+        % end
+        % 
+        % function name = iio_device_get_name(devPtr)
+        %     name = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_get_name', devPtr);
+        % end
+        % 
+        % function label = iio_device_get_label(devPtr)
+        %     label = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_get_label', devPtr);
+        % end
 
-        function count = iio_device_get_channels_count(obj, devPtr)
-            count = calllib(obj.libName, 'iio_device_get_channels_count', devPtr);
-        end
-
-        function count = iio_device_get_attrs_count(obj, devPtr)
-            count = calllib(obj.libName, 'iio_device_get_attrs_count', devPtr);
-        end
+        % function count = iio_device_get_channels_count(devPtr)
+        %     count = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_get_channels_count', devPtr);
+        % end
+        % 
+        % function count = iio_device_get_attrs_count(devPtr)
+        %     count = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_get_attrs_count', devPtr);
+        % end
+        % 
+        % function chanPtr = iio_device_get_channel(devPtr, index)
+        %     chanPtr = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_get_channel', devPtr, index);
+        % end
+        % 
+        % function attrPtr = iio_device_get_attr(devPtr, index)
+        %     attrPtr = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_get_attr', devPtr, index);
+        % end
 
-        function chanPtr = iio_device_get_channel(obj, devPtr, index)
-            chanPtr = calllib(obj.libName, 'iio_device_get_channel', devPtr, index);
-        end
-
-        function attrPtr = iio_device_get_attr(obj, devPtr, index)
-            attrPtr = calllib(obj.libName, 'iio_device_get_attr', devPtr, index);
-        end
-
-        function chanPtr = iio_device_find_channel(obj, dev, id, output)
+        function chanPtr = iio_device_find_channel(dev, id, output)
             % iio_device_find_channel(const struct iio_device *dev, const char *name, bool output)
             % 
             % Find channel by name or channel ID.
@@ -73,43 +50,47 @@
             %   On success, a pointer to an iio_channel structure. If the
             %   name or ID does not correspond to any known channel of the
             %   given device, NULL is returned.
-            chanPtr = calllib(obj.libName, 'iio_device_find_channel', dev, id, output);
-        end
-
-        function [status, attrPtr] = iio_device_find_attr(obj, devPtr, attr)
-            attrPtr = calllib(obj.libName, 'iio_device_find_attr', devPtr, attr);
-            status = cPtrCheck(obj,attrPtr);
+            chanPtr = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_find_channel', dev, id, output);
         end
 
-        function iio_device_set_data(obj, devPtr, voidPtrToData)
-            calllib(obj.libName, 'iio_device_set_data', devPtr, voidPtrToData);
+        function [status, attrPtr] = iio_device_find_attr(devPtr, attr)
+            attrPtr = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_find_attr', devPtr, attr);
+            status = -int32(isNull(attrPtr));
         end
 
-        function voidPtr = iio_device_get_data(obj, devPtr)
-            voidPtr = calllib(obj.libName, 'iio_device_get_data', devPtr);
-        end
-
-        function status = iio_device_set_trigger(obj, devPtr, triggerPtr)
-            triggerPtr = calllib(obj.libName, 'iio_device_set_trigger', devPtr, triggerPtr);
-            status = cPtrCheck(obj,triggerPtr);
-        end
-
-        function triggerPtr = iio_device_get_trigger(obj, devPtr)
-            triggerPtr = calllib(obj.libName, 'iio_device_get_trigger', devPtr);
-        end
+        % function iio_device_set_data(devPtr, voidPtrToData)
+        %     calllib(adi.libiio.device.getIIOLibName(), 'iio_device_set_data', devPtr, voidPtrToData);
+        % end
+        % 
+        % function voidPtr = iio_device_get_data(devPtr)
+        %     voidPtr = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_get_data', devPtr);
+        % end
+        % 
+        % function status = iio_device_set_trigger(devPtr, triggerPtr)
+        %     triggerPtr = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_set_trigger', devPtr, triggerPtr);
+        %     status = cPtrCheck(obj,triggerPtr);
+        % end
+        % 
+        % function triggerPtr = iio_device_get_trigger(devPtr)
+        %     triggerPtr = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_get_trigger', devPtr);
+        % end
+        % 
+        % function isTrigger = iio_device_is_trigger(devPtr)
+        %     isTrigger = calllib(adi.libiio.device.getIIOLibName(), 'iio_device_is_trigger', devPtr);
+        % end
 
-        function isTrigger = iio_device_is_trigger(obj, devPtr)
-            isTrigger = calllib(obj.libName, 'iio_device_is_trigger', devPtr);
+        function libName = getIIOLibName()
+            libName = 'libiio1';
         end
     end
 
     % Wrappers not present in iio.h of v1.0
     % Implemented for backwards compatibility
-    methods (Hidden, Access = {?handle}, Static)
-        function nBytes = iio_device_attr_write(obj,devPtr,attr,src)
-            [status, attrPtr] = adi.libiio.device.iio_device_find_attr(obj, devPtr, attr);
-            cstatus(obj,status,['Attribute: ' attr ' not found']);
-            nBytes = adi.libiio.attribute.iio_attr_write_string(obj, attrPtr, src);
+    methods (Static)
+        function nBytes = iio_device_attr_write(devPtr,attr,src)
+            [status, attrPtr] = adi.libiio.device.iio_device_find_attr(devPtr, attr);
+            % cstatus(obj,status,['Attribute: ' attr ' not found']);
+            nBytes = adi.libiio.attribute.iio_attr_write_string(attrPtr, src);
         end
     end
 end
\ No newline at end of file
diff --git a/+adi/examples/ad9361_iiostream.m b/+adi/examples/ad9361_iiostream.m
new file mode 100644
index 0000000..253fa54
--- /dev/null
+++ b/+adi/examples/ad9361_iiostream.m
@@ -0,0 +1,46 @@
+clear;
+
+[notfound,warnings]=loadlibrary('libiio1','iio.h');
+
+uri = 'ip:pluto.local';
+% Rx stream config
+RxCfg.BWHz = 2e6;
+RxCfg.FsHz = 2.5e6;
+RxCfg.LOHz = 2.5e6;
+RxCfg.RFPort = 'A_BALANCED';
+
+% Tx stream config
+TxCfg.BWHz = 1.5e6;
+TxCfg.FsHz = 2.5e6;
+TxCfg.LOHz = 2.5e6;
+TxCfg.RFPort = 'A';
+
+fprintf("* Acquiring IIO context\n");
+iioCtxParams = libpointer;
+iioCtx = adi.iio.iio_create_context(iioCtxParams, uri);
+count = adi.iio.iio_context_get_devices_count(iioCtx);
+
+fprintf("* Acquiring AD9361 streaming devices\n");
+iioDevTx = adi.iio.iio_context_find_device(iioCtx, 'cf-ad9361-dds-core-lpc');
+iioDevRx = adi.iio.iio_context_find_device(iioCtx, 'cf-ad9361-lpc');
+
+fprintf("* Configuring AD9361 for streaming\n");
+chid = 0;
+fprintf("* Acquiring AD9361 phy channel %d\n", chid);
+ad9361PhyDev = adi.iio.iio_context_find_device(iioCtx, 'ad9361-phy');
+ad9361RxChn = adi.iio.iio_device_find_channel(ad9361PhyDev, ['voltage' num2str(chid)], false);
+ad9361TxChn = adi.iio.iio_device_find_channel(ad9361PhyDev, ['voltage' num2str(chid)], true);
+
+% Rx
+rfPortSelectAttr = adi.iio.iio_channel_find_attr(ad9361RxChn, RxCfg.RFPort);
+status = adi.iio.iio_attr_write_string(rfPortSelectAttr, RxCfg.RFPort);
+assert(status==0);
+
+rfBWAttr = adi.iio.iio_channel_find_attr(ad9361RxChn, 'rf_bandwidth');
+status = adi.iio.iio_attr_write_longlong(rfBWAttr, RxCfg.BWHz);
+assert(status==0);
+fsAttr = adi.iio.iio_channel_find_attr(ad9361RxChn, 'sampling_frequency');
+status = adi.iio.iio_attr_write_longlong(rfBWAttr, RxCfg.FsHz);
+assert(status==0);
+
+unloadlibrary('libiio1');
\ No newline at end of file