diff --git a/@MyDpo/MyDpo.m b/@MyDpo/MyDpo.m
index 975014d..ffc9601 100644
--- a/@MyDpo/MyDpo.m
+++ b/@MyDpo/MyDpo.m
@@ -1,157 +1,157 @@
 % Class for controlling 4-channel Tektronix DPO scopes. 
 % Tested with DPO4034, DPO3034
 classdef MyDpo < MyScpiInstrument
     properties (SetAccess=protected, GetAccess=public)
         % List of the physical knobs, which can be rotated programmatically
         knob_list = {'GPKNOB1','GPKNOB2','HORZPos','HORZScale',...
             'TRIGLevel','PANKNOB1','VERTPOS','VERTSCALE','ZOOM'};
     end
     
     properties (Constant=true)
         N_CHANNELS = 4; % number of channels
     end
     
     methods (Access=public)
         function this=MyDpo(interface, address, varargin)
             this@MyScpiInstrument(interface, address, varargin{:});
             % 2e7 is the maximum trace size of DPO4034-3034 
             %(10 mln point of 2-byte integers)
             this.Device.InputBufferSize = 2.1e7; %byte 
             this.Trace.name_x='Time';
             this.Trace.name_y='Voltage';
         end
         
         function readTrace(this)
             %set data format to be signed integer, reversed byte order
-            fprintf(this.Device,'DATA:ENCDG SRIbinary');
+            fprintf(this.Device,':DATA:ENCDG SRIbinary');
             %2 bytes per measurement point
-            fprintf(this.Device,'DATA:WIDTH 2');
+            fprintf(this.Device,':DATA:WIDTH 2');
             % read the entire trace
-            fprintf(this.Device,'DATA:START 1;STOP %i;',this.point_no);
-            fprintf(this.Device,'CURVE?');
+            fprintf(this.Device,':DATA:START 1;STOP %i',this.point_no);
+            fprintf(this.Device,':CURVE?');
             y_data = int16(binblockread(this.Device,'int16'));
             
             % Reading the relevant parameters from the scope
             readProperty(this,'unit_y','unit_x',...
                 'step_x','step_y','x_zero');
                         
             % Calculating the y data
             y = double(y_data)*this.step_y; 
             n_points=length(y);
             % Calculating the x axis
             x = linspace(this.x_zero,...
                 this.x_zero+this.step_x*(n_points-1),n_points);
             
             this.Trace.x = x;
             this.Trace.y = y;
             % Discard "" when assiging the Trace labels
             this.Trace.unit_x = this.unit_x(2:end-1);
             this.Trace.unit_y = this.unit_y(2:end-1);
             triggerNewData(this);
         end
         
         function acquireContinuous(this)
             openDevice(this);
             fprintf(this.Device,...
-                'ACQuire:STOPAfter RUNSTop;:ACQuire:STATE ON');
+                ':ACQuire:STOPAfter RUNSTop;:ACQuire:STATE ON');
             closeDevice(this);
         end
         
         function acquireSingle(this)
             openDevice(this);
             fprintf(this.Device,...
-                'ACQuire:STOPAfter SEQuence;:ACQuire:STATE ON');
+                ':ACQuire:STOPAfter SEQuence;:ACQuire:STATE ON');
             closeDevice(this);
         end
         
         function turnKnob(this,knob,nturns)
             openDevice(this);
-            fprintf(this.Device, sprintf('FPAnel:TURN %s,%i',knob,nturns));
+            fprintf(this.Device, sprintf(':FPAnel:TURN %s,%i',knob,nturns));
             closeDevice(this);
         end
     end
     
     %% Protected functions
     methods (Access=protected)
         function createCommandList(this)
             % channel from which the data is transferred
-            addCommand(this,'channel','DATa:SOUrce','default',1,...
+            addCommand(this,'channel',':DATa:SOUrce','default',1,...
                 'str_spec','CH%i');
             % currently selected in the scope display channel
-            addCommand(this, 'ctrl_channel', 'SELect:CONTROl',...
+            addCommand(this, 'ctrl_channel', ':SELect:CONTROl',...
                 'default',1, 'str_spec','CH%i');
             % units and scale for x and y waveform data
-            addCommand(this,'unit_x','WFMOutpre:XUNit','access','r',...
+            addCommand(this,'unit_x',':WFMOutpre:XUNit','access','r',...
                 'classes',{'char'});
-            addCommand(this,'unit_y','WFMOutpre:YUNit','access','r',...
+            addCommand(this,'unit_y',':WFMOutpre:YUNit','access','r',...
                 'classes',{'char'});
-            addCommand(this,'step_y','WFMOutpre:YMUlt','access','r',...
+            addCommand(this,'step_y',':WFMOutpre:YMUlt','access','r',...
                 'classes',{'numeric'});
-            addCommand(this,'step_x','WFMOutpre:XINcr','access','r',...
+            addCommand(this,'step_x',':WFMOutpre:XINcr','access','r',...
                 'classes',{'numeric'});
-            addCommand(this,'x_zero','WFMOutpre:XZEro','access','r',...
+            addCommand(this,'x_zero',':WFMOutpre:XZEro','access','r',...
                 'classes',{'numeric'});           
             % numbers of points
-            addCommand(this, 'point_no','HORizontal:RECOrdlength',...
+            addCommand(this, 'point_no',':HORizontal:RECOrdlength',...
                 'default', 100000,...
                 'val_list', {1000, 10000, 100000, 1000000, 10000000},...
                 'str_spec','%i');
             % time scale in s per div
-            addCommand(this, 'time_scale','HORizontal:SCAle',...
+            addCommand(this, 'time_scale',':HORizontal:SCAle',...
                 'default',10E-3,...
                 'str_spec','%e');           
             % trigger level
-            addCommand(this, 'trig_lev', 'TRIGger:A:LEVel',...
+            addCommand(this, 'trig_lev', ':TRIGger:A:LEVel',...
                 'default',1,...
                 'str_spec','%e');
             % trigger slope
-            addCommand(this, 'trig_slope', 'TRIGger:A:EDGE:SLOpe',...
+            addCommand(this, 'trig_slope', ':TRIGger:A:EDGE:SLOpe',...
                 'default', 'RISe', 'val_list',{'RISe','RIS','FALL'},...
                 'str_spec','%s');
             % trigger source
-            addCommand(this, 'trig_source', 'TRIGger:A:EDGE:SOUrce',...
+            addCommand(this, 'trig_source', ':TRIGger:A:EDGE:SOUrce',...
                 'default', 'AUX', 'val_list', {'CH1','CH2','CH3','CH4',...
                 'AUX','EXT','LINE'},...
                 'str_spec','%s');
             % trigger mode
-            addCommand(this, 'trig_mode', 'TRIGger:A:MODe',...
+            addCommand(this, 'trig_mode', ':TRIGger:A:MODe',...
                 'default', 'AUTO', 'val_list',{'AUTO','NORMal','NORM'},...
                 'str_spec','%s');
             % state of the data acquisition by the scope
-            addCommand(this, 'acq_state', 'ACQuire:STATE',...
+            addCommand(this, 'acq_state', ':ACQuire:STATE',...
                 'default',true, 'str_spec','%b');
             % acquisition mode
-            addCommand(this, 'acq_mode', 'ACQuire:MODe',...
+            addCommand(this, 'acq_mode', ':ACQuire:MODe',...
                 'default', 'HIR', 'val_list',{'SAM','PEAK','HIR','AVE',...
                 'ENV','SAMple','PEAKdetect','HIRes','AVErage','ENVelope'},...
                 'str_spec','%s');
            
             % Parametric commands
             for i = 1:this.N_CHANNELS
                 i_str = num2str(i);
                 % coupling, AC, DC or GND
                 addCommand(this,...
-                    ['cpl',i_str],['CH',i_str,':COUP'],...
+                    ['cpl',i_str],[':CH',i_str,':COUP'],...
                     'default','DC', 'val_list', {'AC','DC','GND'},...
                     'str_spec','%s');              
                 % impedances, 1MOhm or 50 Ohm
                 addCommand(this,...
-                    ['imp',i_str],['CH',i_str,':IMPedance'],...
+                    ['imp',i_str],[':CH',i_str,':IMPedance'],...
                     'default','MEG', 'val_list', {'FIFty','FIF','MEG'},...
                     'str_spec','%s');
                 % offset
                 addCommand(this,...
-                    ['offset',i_str],['CH',i_str,':OFFSet'],'default',0,...
+                    ['offset',i_str],[':CH',i_str,':OFFSet'],'default',0,...
                     'str_spec','%e');
                 % scale, V/Div
                 addCommand(this,...
-                    ['scale',i_str],['CH',i_str,':SCAle'],'default',1,...
+                    ['scale',i_str],[':CH',i_str,':SCAle'],'default',1,...
                     'str_spec','%e');
                 % channel enabled
                 addCommand(this,...
-                    ['enable',i_str],['SEL:CH',i_str],'default',true,...
+                    ['enable',i_str],[':SEL:CH',i_str],'default',true,...
                     'str_spec','%b');
             end
         end
     end
 end
\ No newline at end of file
diff --git a/@MyDso/MyDso.m b/@MyDso/MyDso.m
index e12c345..005ae92 100644
--- a/@MyDso/MyDso.m
+++ b/@MyDso/MyDso.m
@@ -1,168 +1,168 @@
 % Class for controlling 4-channel Agilent DSO scopes. 
 % Tested with DSO7034A
 classdef MyDso <MyScpiInstrument
     properties (SetAccess=protected, GetAccess=public)
         % properties, read a a preamble during the trace reading
         step_x;
         step_y;
         x_zero;
         y_zero;
         point_no;
     end
     properties (Constant=true)
         N_CHANNELS = 4; % number of channels
     end
     
     methods (Access=public)
         function this=MyDso(interface, address, varargin)
             this@MyScpiInstrument(interface, address, varargin{:});
             % 1.6e7 is the maximum trace size of DSO7034A 
             %(8 mln point of 2-byte integers)
             this.Device.InputBufferSize = 2e7; %byte 
             this.Trace.name_x='Time';
             this.Trace.name_y='Voltage';
             this.Trace.unit_x = 's';
             this.Trace.unit_y = 'V';
         end
         
         function readTrace(this)
             % set data format to be signed integer, reversed byte order,
             % 2 bytes per measurement point, and also read the maximun
             % avaliable number of points
-            fprintf(this.Device,['WAVeform:BYTeorder LSBFirst;',...
+            fprintf(this.Device,[':WAVeform:BYTeorder LSBFirst;',...
                 ':WAVeform:FORMat WORD;:WAVeform:POINts:MODE MAX;',...
                 ':WAVeform:UNSigned OFF']);
             % read preamble
-            pre_str = query(this.Device, 'WAVeform:PREamble?');
+            pre_str = query(this.Device, ':WAVeform:PREamble?');
             % drop the end-of-the-string symbol and split
             pre = str2double(split(pre_str(1:end-1),','));
             this.point_no = pre(3);
             this.step_x = pre(5);
             this.step_y = pre(8);
             this.x_zero = pre(6);
             this.y_zero = pre(9);
             % read the trace
-            fprintf(this.Device,'WAVeform:DATA?');
+            fprintf(this.Device,':WAVeform:DATA?');
             y_data = int16(binblockread(this.Device,'int16'));            
             % Calculating the y data
             y = double(y_data)*this.step_y+this.y_zero; 
             n_points=length(y);
             % Calculating the x axis
             x = linspace(this.x_zero,...
                 this.x_zero+this.step_x*(n_points-1),n_points);
             this.Trace.x = x;
             this.Trace.y = y;
             triggerNewData(this);
         end
         
         function acquireContinuous(this)
             openDevice(this);
-            fprintf(this.Device,'RUN');
+            fprintf(this.Device,':RUN');
             closeDevice(this);
         end
         
         function acquireSingle(this)
             openDevice(this);
-            fprintf(this.Device,'SINGLe');
+            fprintf(this.Device,':SINGLe');
             closeDevice(this);
         end
         
         function stopAcquisition(this)
             openDevice(this);
-            fprintf(this.Device,'STOP');
+            fprintf(this.Device,':STOP');
             closeDevice(this);
         end
         
         % Emulates the physical knob turning, works with nturns=+-1
         function turnKnob(this,knob,nturns)
             switch upper(knob)
                 case 'HORZSCALE'
                     % timebase is changed
                     if nturns==-1
                         sc = this.time_scale*2;
                     elseif nturns==1
                         sc = this.time_scale/2;
                     else
                         return
                     end
                     writePropertyHedged(this, 'time_scale', sc);
                 case {'VERTSCALE1', 'VERTSCALE2'}
                     % vertical scale is changed
                     n_ch = sscanf(upper(knob), 'VERTSCALE%i');
                     tag = sprintf('scale%i', n_ch);
                     if nturns==-1
                         sc = this.(tag)*2;
                     elseif nturns==1
                         sc = this.(tag)/2;
                     else
                         return
                     end
                     writePropertyHedged(this, sprintf('scale%i',n_ch), sc);
             end
         end
     end
     
     %% Protected functions
     methods (Access=protected)
         function createCommandList(this)
             % channel from which the data is transferred
-            addCommand(this,'channel','WAVeform:SOURce','default',1,...
+            addCommand(this,'channel',':WAVeform:SOURce','default',1,...
                 'str_spec','CHAN%i');
             % time scale in s per div
-            addCommand(this, 'time_scale','TIMebase:SCALe',...
+            addCommand(this, 'time_scale',':TIMebase:SCALe',...
                 'default',10E-3,...
                 'str_spec','%e');           
             % trigger level
-            addCommand(this, 'trig_lev', 'TRIGger:LEVel',...
+            addCommand(this, 'trig_lev', ':TRIGger:LEVel',...
                 'default',1,...
                 'str_spec','%e');
             % trigger slope - works, but incompatible with Tektronix
-            addCommand(this, 'trig_slope', 'TRIGger:SLOpe',...
+            addCommand(this, 'trig_slope', ':TRIGger:SLOpe',...
                 'default', 'RISe', 'val_list',{'NEG','POS','EITH','ALT',... 
                 'NEGative','POSitive','EITHer','ALTernate'},...
                 'str_spec','%s');
             % trigger source
-            addCommand(this, 'trig_source', 'TRIGger:SOUrce',...
+            addCommand(this, 'trig_source', ':TRIGger:SOUrce',...
                 'default', 'AUX', 'val_list', {'CHAN1','CHAN2','CHAN3',...
                 'CHAN4','EXT','LINE'},...
                 'str_spec','%s');
             % trigger mode
-            addCommand(this, 'trig_mode', 'TRIGger:SWEep',...
+            addCommand(this, 'trig_mode', ':TRIGger:SWEep',...
                 'default', 'AUTO', 'val_list',{'AUTO','NORMal','NORM'},...
                 'str_spec','%s');
             % acquisition mode
-            addCommand(this, 'acq_mode', 'ACQuire:TYPE',...
+            addCommand(this, 'acq_mode', ':ACQuire:TYPE',...
                 'default', 'NORM', 'val_list',{'NORM','AVER','HRES',...
                 'NORMal','AVERage','HRESolution','PEAK'},...
                 'str_spec','%s');
 
             % Parametric commands
             for i = 1:this.N_CHANNELS
                 i_str = num2str(i);
                 % coupling, AC, DC or GND
                 addCommand(this,...
-                    ['cpl',i_str],['CHANnel',i_str,':COUPling'],...
+                    ['cpl',i_str],[':CHANnel',i_str,':COUPling'],...
                     'default','DC', 'val_list', {'AC','DC','GND'},...
                     'str_spec','%s');              
                 % impedances, 1MOhm or 50 Ohm works but incompatible with DPO
                 addCommand(this,...
-                    ['imp',i_str],['CHANnel',i_str,':IMPedance'],...
+                    ['imp',i_str],[':CHANnel',i_str,':IMPedance'],...
                     'default','ONEMeg',...
                     'val_list', {'FIFty','FIF','ONEMeg','ONEM'},...
                     'str_spec','%s');
                 % offset
                 addCommand(this,...
-                    ['offset',i_str],['CHANnel',i_str,':OFFSet'],'default',0,...
+                    ['offset',i_str],[':CHANnel',i_str,':OFFSet'],'default',0,...
                     'str_spec','%e');
                 % scale, V/Div
                 addCommand(this,...
-                    ['scale',i_str],['CHANnel',i_str,':SCAle'],'default',1,...
+                    ['scale',i_str],[':CHANnel',i_str,':SCAle'],'default',1,...
                     'str_spec','%e');
                 % channel enabled
                 addCommand(this,...
-                    ['enable',i_str],['CHANnel',i_str,':DISPlay'],'default',true,...
+                    ['enable',i_str],[':CHANnel',i_str,':DISPlay'],'default',true,...
                     'str_spec','%b');
             end
         end
     end
 end
\ No newline at end of file
diff --git a/@MyNa/MyNa.m b/@MyNa/MyNa.m
index 3321bd9..2e210e9 100644
--- a/@MyNa/MyNa.m
+++ b/@MyNa/MyNa.m
@@ -1,166 +1,166 @@
 % The class for communication with Agilent E5061B Network Analyzer
 classdef MyNa < MyScpiInstrument
     properties (SetAccess=protected, GetAccess=public)
         active_trace = -1; % manipulating with active traces seems unavoidable 
         % for selecting the data format. -1 stands for unknown
         
         % data formats for the traces 1-2, options:
         % 'PHAS', 'SLIN', 'SLOG', 'SCOM', 'SMIT', 'SADM', 'MLOG', 'MLIN', 
         %'PLIN', 'PLOG', 'POL'
         form1 = 'MLOG';
         form2 = 'PHAS';
         
         Trace1 = MyTrace();
         Trace2 = MyTrace();
     end
 
     methods
         function this=MyNa(interface, address, varargin)
             this@MyScpiInstrument(interface, address, varargin{:});
             
             %Tests if device is working.
             try
                 openDevice(this);
                 closeDevice(this);
             catch
                 error(['Failed to open communications with device.',...
                     ' Check that the address and interface is correct.',...
                     ' Currently the address is %s and the interface is ',...
                     '%s.'],this.address,this.interface)
             end
             
             this.Trace1.unit_x = 'Hz';
             this.Trace1.name_x = 'Frequency';
             this.Trace2.unit_x = 'Hz';
             this.Trace2.name_x = 'Frequency';
         end
         
         function data = readTrace(this, nTrace)
             this.writeActiveTrace(nTrace);
-            freq_str = strsplit(query(this.Device,'SENS1:FREQ:DATA?'),',');
-            data_str = strsplit(query(this.Device,'CALC1:DATA:FDAT?'),',');
+            freq_str = strsplit(query(this.Device,':SENS1:FREQ:DATA?'),',');
+            data_str = strsplit(query(this.Device,':CALC1:DATA:FDAT?'),',');
             data = struct();
             data.x = str2double(freq_str);
             % In the returned string there is in general 2 values for each
             % frequency point. In the Smith data format this can be used to
             % transfer magnitude and phase of the signal in one trace. With
             % MLOG, MLIN and PHAS format settings every 2-nd element should
             % be 0
             data.y1 = str2double(data_str(1:2:end));
             data.y2 = str2double(data_str(2:2:end));
             
             % set the Trace properties
             trace_tag = sprintf('Trace%i', nTrace);
             this.(trace_tag).x = data.x;
             this.(trace_tag).y = data.y1;
         end
         
         function writeActiveTrace(this, nTrace)
-            fprintf(this.Device, sprintf('CALC1:PAR%i:SEL',nTrace));
+            fprintf(this.Device, sprintf(':CALC1:PAR%i:SEL',nTrace));
             this.active_trace = nTrace;
         end
         
         function writeTraceFormat(this, nTrace, fmt)
             this.writeActiveTrace(nTrace);
             n_str = num2str(nTrace);
             this.(['form',n_str]) = fmt;
-            fprintf(this.Device, sprintf('CALC1:FORM %s', fmt));
+            fprintf(this.Device, sprintf(':CALC1:FORM %s', fmt));
         end
         
         function singleSweep(this)
             this.openDevice(); 
             this.writeProperty('cont_trig', true);
             % Set the triger source to remote control
             this.writeProperty('trig_source', 'BUS');
             % Start a sweep cycle
             fprintf(this.Device,':TRIG:SING');
             % Wait for the sweep to finish (for the query to return 1)
             query(this.Device,'*OPC?');
-            this.closeDevice();
+            closeDevice(this);
         end
         
         function startContSweep(this)
             this.openDevice(); 
             this.writeProperty('cont_trig', true);
             % Set the triger source to be internal
             this.writeProperty('trig_source', 'INT');
             this.closeDevice();
         end
         
         function abortSweep(this)
             this.openDevice();
             this.writeProperty('trig_source', 'BUS');
             fprintf(this.Device,':ABOR');
             this.closeDevice();
         end
     end
     
     %% Protected functions
     methods (Access=protected)
         % Command attributes are {class, attributtes} accepted by
         % validateattributes()
         function createCommandList(this)
             addCommand(this,...
-                'cent_freq','SENS1:FREQ:CENT', 'default',1.5e6,...
-                'str_spec','d');
+                'cent_freq',':SENS1:FREQ:CENT', 'default',1.5e6,...
+                'str_spec','%e');
             addCommand(this,...
-                'start_freq','SENS1:FREQ:START', 'default',1e6,...
-                'str_spec','d');
+                'start_freq',':SENS1:FREQ:START', 'default',1e6,...
+                'str_spec','%e');
             addCommand(this,...
-                'stop_freq','SENS1:FREQ:STOP', 'default',2e6,...
-                'str_spec','d');
+                'stop_freq',':SENS1:FREQ:STOP', 'default',2e6,...
+                'str_spec','%e');
             addCommand(this,...
-                'span','SENS1:FREQ:SPAN', 'default',1e6,...
-                'str_spec','d');
+                'span',':SENS1:FREQ:SPAN', 'default',1e6,...
+                'str_spec','%e');
             % IF bandwidth
             addCommand(this,...
-                'ifbw','SENS1:BAND', 'default',100,...
-                'str_spec','d');
+                'ifbw',':SENS1:BAND', 'default',100,...
+                'str_spec','%e');
             % number of points in the sweep
             addCommand(this,...
-                'point_no','SENS1:SWE:POIN', 'default',1000,...
-                'str_spec','i');
+                'point_no',':SENS1:SWE:POIN', 'default',1000,...
+                'str_spec','%i');
             % number of averages
             addCommand(this,...
-                'average_no','SENS1:AVER:COUN', 'default',1,...
-                'str_spec','i');
+                'average_no',':SENS1:AVER:COUN', 'default',1,...
+                'str_spec','%i');
             % number of traces
             addCommand(this,...
-                'trace_no','CALC1:PAR:COUN', 'default',1,...
-                'str_spec','i');
+                'trace_no',':CALC1:PAR:COUN', 'default',1,...
+                'str_spec','%i');
             % linear or log sweep
             addCommand(this,...
-                'sweep_type','SENS1:SWE:TYPE', 'default','LIN',...
-                'str_spec','s');
+                'sweep_type',':SENS1:SWE:TYPE', 'default','LIN',...
+                'str_spec','%s');
             % switch the output signal on/off
             addCommand(this,...
-                'enable_out','OUTP', 'default',0,...
-                'str_spec','b');
+                'enable_out',':OUTP', 'default',0,...
+                'str_spec','%b');
             % probe power [dB]
             addCommand(this,...
-                'power','SOUR:POW:LEV:IMM:AMPL', 'default',-10,...
-                'str_spec','d');
+                'power',':SOUR:POW:LEV:IMM:AMPL', 'default',-10,...
+                'str_spec','%e');
             % windows arrangement at the display, e.g 'D1'
             addCommand(this,...
-                'disp_type','DISP:WIND1:SPL', 'default','D1',...
-                'str_spec','s');
+                'disp_type',':DISP:WIND1:SPL', 'default','D1',...
+                'str_spec','%s');
             % Continuous sweep triggering 
             addCommand(this,...
                 'cont_trig',':INIT1:CONT', 'default', 0,...
-                'str_spec','b');
+                'str_spec','%b');
             addCommand(this,...
                 'trig_source', ':TRIG:SOUR', 'default', 'BUS',...
-                'str_spec','s')
+                'str_spec','%s')
             
             % Parametric commands for traces, i can be extended to 4
             for i = 1:2
                 % measurement parameters for the traces 1-2, e.g. 'S21'
                 i_str = num2str(i);
                 addCommand(this,...
-                    ['meas_par',i_str],['CALC1:PAR',i_str,':DEF'],...
+                    ['meas_par',i_str],[':CALC1:PAR',i_str,':DEF'],...
                     'default','S21',...
-                    'str_spec','s');
+                    'str_spec','%s');
             end
         end
     end
 end
diff --git a/@MyRsa/MyRsa.m b/@MyRsa/MyRsa.m
index 71e178d..d309c2b 100644
--- a/@MyRsa/MyRsa.m
+++ b/@MyRsa/MyRsa.m
@@ -1,107 +1,107 @@
 % Class for controlling Tektronix RSA5103 and RSA5106 spectrum analyzers 
 classdef MyRsa < MyScpiInstrument
     %% Constructor and destructor
     methods (Access=public)
         function this=MyRsa(interface, address, varargin)
             this@MyScpiInstrument(interface, address, varargin{:});
             
             this.Trace.unit_x='Hz';
             this.Trace.unit_y='$\mathrm{V}^2/\mathrm{Hz}$';
             this.Trace.name_y='Power';
             this.Trace.name_x='Frequency';
         end
     end
     
     %% Protected functions
     methods (Access=protected)
         
         function createCommandList(this)
             % Resolution bandwidth (Hz)
-            addCommand(this, 'rbw','DPX:BAND:RES',...
+            addCommand(this, 'rbw',':DPX:BAND:RES',...
                 'default',1e3,'str_spec','%e');
             % If the rbw is auto-set
-            addCommand(this, 'auto_rbw','DPX:BAND:RES:AUTO',...
+            addCommand(this, 'auto_rbw',':DPX:BAND:RES:AUTO',...
                 'default',true,'str_spec','%b');
-            addCommand(this, 'span', 'DPX:FREQ:SPAN',...
+            addCommand(this, 'span', ':DPX:FREQ:SPAN',...
                 'default',1e6,'str_spec','%e');
-            addCommand(this,  'start_freq','DPX:FREQ:STAR',...
+            addCommand(this,  'start_freq',':DPX:FREQ:STAR',...
                 'default',1e6,'str_spec','%e');
-            addCommand(this, 'stop_freq','DPX:FREQ:STOP',...
+            addCommand(this, 'stop_freq',':DPX:FREQ:STOP',...
                 'default',2e6,'str_spec','%e');
-            addCommand(this, 'cent_freq','DPX:FREQ:CENT',...
+            addCommand(this, 'cent_freq',':DPX:FREQ:CENT',...
                 'default',1.5e6,'str_spec','%e');
             % Initiate and abort data acquisition, don't take arguments
-            addCommand(this, 'abort_acq','ABORt', 'access','w',...
+            addCommand(this, 'abort_acq',':ABORt', 'access','w',...
                 'str_spec','');
-            addCommand(this, 'init_acq','INIT', 'access','w',...
+            addCommand(this, 'init_acq',':INIT', 'access','w',...
                 'str_spec','');
             % Continuous triggering
-            addCommand(this, 'init_cont','INIT:CONT','default',true,...
+            addCommand(this, 'init_cont',':INIT:CONT','default',true,...
                 'str_spec','%b');
             % Number of points in trace
-            addCommand(this, 'point_no','DPSA:POIN:COUN',...
+            addCommand(this, 'point_no',':DPSA:POIN:COUN',...
                 'default',10401, 'val_list',{801,2401,4001,10401},...
                 'str_spec','P%i');
             % Reference level (dB)
-            addCommand(this, 'ref_level','INPut:RLEVel','default',0,...
+            addCommand(this, 'ref_level',':INPut:RLEVel','default',0,...
                 'str_spec','%e');
             % Display scale per division (dBm/div)
-            addCommand(this, 'disp_y_scale','DISPlay:DPX:Y:PDIVision',...
+            addCommand(this, 'disp_y_scale',':DISPlay:DPX:Y:PDIVision',...
                 'default',10,'str_spec','%e');
             % Display vertical offset (dBm)
-            addCommand(this, 'disp_y_offset','DISPLAY:DPX:Y:OFFSET',...
+            addCommand(this, 'disp_y_offset',':DISPLAY:DPX:Y:OFFSET',...
                 'default',0,'str_spec','%e');
             
             % Parametric commands
             for i = 1:3
                 i_str = num2str(i);
                 % Display trace
                 addCommand(this, ['disp_trace',i_str],...
-                    ['TRAC',i_str,':DPX'],...
+                    [':TRAC',i_str,':DPX'],...
                     'default',false,'str_spec','%b');
                 % Trace Detection
                 addCommand(this, ['det_trace',i_str],...
-                    ['TRAC',i_str,':DPX:DETection'],...
+                    [':TRAC',i_str,':DPX:DETection'],...
                     'val_list',{'AVER','AVERage','NEG','NEGative',...
                     'POS','POSitive'},...
                     'default','AVER','str_spec','%s');
                 % Trace Function
                 addCommand(this, ['func_trace',i_str],...
-                    ['TRAC',i_str,':DPX:FUNCtion'],...
+                    [':TRAC',i_str,':DPX:FUNCtion'],...
                     'val_list',{'AVER','AVERage','HOLD','NORM','NORMal'},...
                     'default','AVER','str_spec','%s');
                 % Number of averages
                 addCommand(this, ['average_no',i_str],...
-                    ['TRAC',i_str,':DPX:AVER:COUN'],...
+                    [':TRAC',i_str,':DPX:AVER:COUN'],...
                     'default',1,'str_spec','%i');
                 % Count completed averages
                 addCommand(this, ['cnt_trace',i_str],...
-                    ['TRACe',i_str,':DPX:COUNt:ENABle'],...
+                    [':TRACe',i_str,':DPX:COUNt:ENABle'],...
                     'default',false,'str_spec','%b');
             end
         end
     end
     
     %% Public functions including callbacks
     methods (Access=public)
         
         function readSingle(this, n_trace)
             fetch_cmd = sprintf('fetch:dpsa:res:trace%i?', n_trace);  
             fwrite(this.Device, fetch_cmd);
             data = binblockread(this.Device,'float');
             readProperty(this, 'start_freq','stop_freq','point_no');
             x_vec=linspace(this.start_freq,this.stop_freq,...
                 this.point_no);
             %Calculates the power spectrum from the data, which is in dBm.
             %Output is in V^2/Hz
             power_spectrum = (10.^(data/10))/this.rbw*50*0.001;
             %Trace object is created containing the data and its units
             this.Trace.x = x_vec;
             this.Trace.y = power_spectrum;
 
             %Trigger acquired data event (inherited from MyInstrument)
             triggerNewData(this);
         end
     end
 end
 
diff --git a/@MyScpiInstrument/MyScpiInstrument.m b/@MyScpiInstrument/MyScpiInstrument.m
index ab55541..82816b4 100644
--- a/@MyScpiInstrument/MyScpiInstrument.m
+++ b/@MyScpiInstrument/MyScpiInstrument.m
@@ -1,381 +1,380 @@
 % Class for instruments supporting SCPI, features specialized framework for
 % read/write commands
 classdef MyScpiInstrument < MyInstrument
     
     properties (SetAccess=protected, GetAccess=public)
         %Contains a list of the commands available for the instrument as
         %well as the default values and input requirements
         CommandList=struct();
         %Parses commands using an inputParser object
         CommandParser;
     end
         
     properties (Dependent=true)
         command_names;
         command_no;
         write_commands;
         read_commands;
     end
     
     methods (Access=public)
         %% Class constructor
         function this=MyScpiInstrument(interface, address, varargin)
             this@MyInstrument(interface, address, varargin{:});
             createCommandList(this);
             createCommandParser(this);
         end
         
         %% Low-level functions for reading and writing textual data to the device
         % These functions can be overloaded if the instrument does not
         % support visa communication or use non-standard command separators
         
         function writeCommand(this, varargin)
             if ~isempty(varargin)
                 % Concatenate commands and send to the device
-                cmd_str=join(varargin,';:');
-                cmd_str=[cmd_str{1},';'];
+                cmd_str=join(varargin,';');
+                cmd_str=cmd_str{1};
                 fprintf(this.Device, cmd_str);
             end
         end
         
         % Query commands and return resut as cell array of strings
         function res_list=queryCommand(this, varargin)
             if ~isempty(varargin)
                 % Concatenate commands and send to the device
-                cmd_str=join(varargin,';:');
-                cmd_str=[':',cmd_str{1}];
+                cmd_str=join(varargin,';');
+                cmd_str=cmd_str{1};
                 res_str=query(this.Device, cmd_str);
                 % Drop the end-of-the-string symbol and split
                 res_list=split(deblank(res_str),';');
-                disp(cmd_str)
             else
                 res_list={};
             end
         end
         
         %% Read and write commands
         
         %Writes properties to device. Can take multiple inputs. With the
         %option all, the function writes default to all the
         %available writeable parameters.
         function writeProperty(this, varargin)
             %Parses the inputs using the CommandParser
             parse(this.CommandParser, varargin{:});
 
             if this.CommandParser.Results.all
                 % If the 'all' is true, write all the commands
                 exec=this.write_commands;
             else
                 % Check which commands were passed values
                 ind_val=cellfun(@(x)...
                     (~ismember(x, this.CommandParser.UsingDefaults)),...
                     this.write_commands);
                 exec=this.write_commands(ind_val);
             end
             
             % create a list of textual strings to be sent to device
             exec_commands=cell(1,length(exec));
             for i=1:length(exec)
                 %Create command using the right string spec
                 cmd=[this.CommandList.(exec{i}).command,...
                     ' ',this.CommandList.(exec{i}).str_spec];
                 val=this.CommandParser.Results.(exec{i});
                 exec_commands{i}=sprintf(cmd, val);
             end
             %Sends commands to device
             writeCommand(this, exec_commands{:});
             for i=1:length(exec)
                 %Assign written values to instrument properties
                 this.(exec{i})=this.CommandParser.Results.(exec{i});
             end
         end
         
         % Wrapper for writeProperty that opens and closes the device
         function writePropertyHedged(this, varargin)
             openDevice(this);
             try
                 writeProperty(this, varargin{:});
             catch
                 warning('Error while writing the properties:');
                 disp(varargin);
             end
             readProperty(this, 'all');
             closeDevice(this);
         end
         
         function result=readProperty(this, varargin)
             result = struct();
             read_all_flag = any(strcmp('all',varargin));          
             if read_all_flag
                 % Read all the commands with read access 
                 exec=this.read_commands;
             else
                 ind_r=ismember(varargin,this.read_commands);
                 exec=varargin(ind_r);
                 if any(~ind_r)
                     % Issue warnings for commands not in the command_names
                     warning('The following are not valid read commands:');
                     disp(varargin(~ind_r));
                 end
             end
             % Create a list of textual strings to be sent to device
             exec_commands=cellfun(...
                 @(cmd)[this.CommandList.(cmd).command,'?'],exec,...
                 'UniformOutput',false);
             % Query device
             res_list=queryCommand(this, exec_commands{:});
             % Assign outputs to the class properties
             if length(exec)==length(res_list)
                 for i=1:length(exec)
                     result.(exec{i})=sscanf(res_list{i},...
                         this.CommandList.(exec{i}).str_spec);
                     %Assign the values to the MyInstrument properties
                     this.(exec{i})=result.(exec{i});
                 end
             else
                 warning(['Not all the properties could be read, ',...
                     'no instrument class values are not updated']);
             end
         end
         
         % Wrapper for readProperty that opens and closes the device
         function result=readPropertyHedged(this, varargin)
             openDevice(this);
             try
                 result = readProperty(this, varargin{:});
             catch
                 warning('Error while reading the properties:');
                 disp(varargin);
             end
             closeDevice(this);
         end
         
         % Re-define readHeader function
         function HdrStruct=readHeader(this)
            Values=readPropertyHedged(this,'all');
            for i=1:length(this.read_commands)
                HdrStruct.(this.read_commands{i}).value=...
                    Values.(this.read_commands{i});
                HdrStruct.(this.read_commands{i}).str_spec=...
                    this.CommandList.(this.read_commands{i}).str_spec;
            end
         end
         
         %% Processing of the class variable values
         % Extend the property value based on val_list 
         function std_val = standardizeValue(this, cmd, varargin)
             if ~ismember(cmd,this.command_names)
                 warning('%s is not a valid command',cmd);
                 std_val = '';
                 return
             end
             vlist = this.CommandList.(cmd).val_list;
             % The value to normalize can be explicitly passed as
             % varargin{1}, otherwise use this.cmd as value
             if isempty(varargin)
                 val = this.(cmd);
             else
                 val = varargin{1};
             end
             % find matching commands
             ismatch = false(1,length(vlist));
             for i=1:length(vlist)
                 n = min([length(val), length(vlist{i})]);
                 % compare first n symbols disregarding case
                 ismatch(i) = strncmpi(val, vlist{i},n);
             end
             % out of matching names pick the longest
             if any(ismatch)
                 mvlist = vlist(ismatch);
                 %Finds the length of each element of mvlist
                 n_el=cellfun(@(x) length(x), mvlist);
                 %Sets std_val to the longest element
                 std_val=mvlist{n_el==max(n_el)};
 
                 % sets the property if value was not given explicitly 
                 if isempty(varargin)
                     this.(cmd) = std_val;
                 end
             else
                 warning(['The value %s is not in the val_list ',...
                     'of %s command'], val, cmd)
                 std_val = val;
             end
         end
         
         % Return the list of long command values excluding abbreviations
         function std_val_list = stdValueList(this, cmd)
             if ~ismember(cmd,this.command_names)
                 warning('%s is not a valid command',cmd);
                 std_val_list = {};
                 return
             end
             vlist = this.CommandList.(cmd).val_list;
             % Select the commands, which appear only once in the beginnings 
             % of the strings in val_list
             long_val_ind = cellfun(...
                 @(x)(sum(startsWith(vlist,x,'IgnoreCase',true))==1),vlist);
             std_val_list = vlist(long_val_ind); 
         end
         
         %% Auxiliary functions for auto format assignment to commands
         function str_spec=formatSpecFromAttributes(~,classes,attributes)
             if ismember('char',classes)
                 str_spec='%s';
             elseif ismember('logical',classes)||...
                     (ismember('numeric',classes)&&...
                     ismember('integer',attributes))
                 str_spec='%i';
             else
                 %assign default value, i.e. double
                 str_spec='%e';
             end
         end
         
         function [class,attribute]=attributesFromFormatSpec(~, str_spec)
             % find index of the first letter after the % sign
             ind_p=strfind(str_spec,'%');
             ind=ind_p+find(isletter(str_spec(ind_p:end)),1)-1;
             str_spec_letter=str_spec(ind);
             switch str_spec_letter
                 case {'d','f','e','g'}
                     class={'numeric'};
                     attribute={};
                 case 'i'
                     class={'numeric'};
                     attribute={'integer'};
                 case 's'
                     class={'char'};
                     attribute={};
                 case 'b'
                     class={'logical'};
                     attribute={};
                 otherwise
                     % Any of the above classes will pass
                     class={'numeric','char','logical'};
                     attribute={};
             end
         end
     end
     
     methods (Access=protected)
         %% Command list handling
         %Adds a command to the CommandList
         function addCommand(this, tag, command, varargin)
             p=inputParser();
             addRequired(p,'tag',@ischar);
             addRequired(p,'command',@ischar);
             addParameter(p,'default','placeholder');
             addParameter(p,'classes',{},@iscell);
             addParameter(p,'attributes',{},@iscell);
             addParameter(p,'str_spec','%e',@ischar);
             % list of the values the variable can take, {} means no
             % restriction
             addParameter(p,'val_list',{},@iscell);
             addParameter(p,'access','rw',@ischar);
             parse(p,tag,command,varargin{:});
 
             %Adds the command to be sent to the device
             this.CommandList.(tag).command=command;
             this.CommandList.(tag).access=p.Results.access;
             this.CommandList.(tag).write_flag=contains(p.Results.access,'w');
             this.CommandList.(tag).read_flag=contains(p.Results.access,'r');
             this.CommandList.(tag).default=p.Results.default;
             this.CommandList.(tag).val_list=p.Results.val_list;
             
             % Adds the string specifier to the list. if the format
             % specifier is not given explicitly, try to infer
             if ismember('str_spec', p.UsingDefaults)
                 this.CommandList.(tag).str_spec=...
                     formatSpecFromAttributes(this,p.Results.classes...
                     ,p.Results.attributes);
             elseif strcmp(p.Results.str_spec,'%b')
                 % b is a non-system specifier to represent the
                 % logical type
                 this.CommandList.(tag).str_spec='%i';
             else
                 this.CommandList.(tag).str_spec=p.Results.str_spec;
             end
             % Adds the attributes for the input to the command. If not
             % given explicitly, infer from the format specifier
             if ismember('classes',p.UsingDefaults)
                 [this.CommandList.(tag).classes,...
                 this.CommandList.(tag).attributes]=...
                 attributesFromFormatSpec(this, p.Results.str_spec);
             else
                 this.CommandList.(tag).classes=p.Results.classes;
                 this.CommandList.(tag).attributes=p.Results.attributes;
             end
             
             % Adds a property to the class corresponding to the tag
             if ~isprop(this,tag)
                 addprop(this,tag);
             end
             this.(tag)=p.Results.default;
         end
         
         %Creates inputParser using the command list
         function p = createCommandParser(this)
             %Use input parser
             %Requires input of the appropriate class
             p=inputParser;
             p.StructExpand=0;
             %Flag for whether the command should initialize the device with
             %defaults
             addParameter(p, 'all',false,@islogical);
             
             for i=1:length(this.write_commands)
                 %Adds optional inputs for each command, with the
                 %appropriate default value from the command list and the
                 %required attributes for the command input.
                 tag=this.write_commands{i};
                 % Create validation function based on properties: 
                 % class, attributes and list of values
                 if ~isempty(this.CommandList.(tag).val_list)
                     if all(cellfun(@ischar, this.CommandList.(tag).val_list))
                         % for textual values use case insentice string comparison
                         v_func = @(x) any(cellfun(@(y) strcmpi(y, x),...
                             this.CommandList.(tag).val_list));
                     else
                         % for everything else compare as it is
                         v_func = @(x) any(cellfun(@(y) isequal(y, x),...
                             this.CommandList.(tag).val_list));
                     end
                 else
                     v_func = @(x) validateattributes(x,...
                     this.CommandList.(tag).classes,...
                     this.CommandList.(tag).attributes);
                 end
                 addParameter(p, tag,...
                     this.CommandList.(tag).default, v_func);
             end
             this.CommandParser=p;
         end
         
         %Dummy empty function that needs to be redefined in a subclass and
         %contain addCommand statements
         function createCommandList(~)
         end
     end
     
     %% Get functions
     methods
         function command_names=get.command_names(this)
             command_names=fieldnames(this.CommandList);
         end
         
         function write_commands=get.write_commands(this)
             ind_w=structfun(@(x) x.write_flag, this.CommandList);
             write_commands=this.command_names(ind_w);
         end
         
         function read_commands=get.read_commands(this)
             ind_r=structfun(@(x) x.read_flag, this.CommandList);
             read_commands=this.command_names(ind_r);
         end
         
         function command_no=get.command_no(this)
             command_no=length(this.command_names);
         end
     end
 end
\ No newline at end of file
diff --git a/@MyTds/MyTds.m b/@MyTds/MyTds.m
index 176b2a3..7a69c03 100644
--- a/@MyTds/MyTds.m
+++ b/@MyTds/MyTds.m
@@ -1,155 +1,155 @@
 % Class for controlling 2-channel Tektronix TDS scopes. 
 classdef MyTds <MyScpiInstrument
     properties (Constant=true)
         N_CHANNELS = 2; % number of channels
         POINT_NO = 2500; % number of points is fixed for this device
     end
     
     methods (Access=public)
         function this=MyTds(interface, address, varargin)
             this@MyScpiInstrument(interface, address, varargin{:});
 
             % 5e3 is the maximum trace size of TDS2022 
             %(2500 point of 2-byte integers)
             this.Device.InputBufferSize = 1e4; %byte 
             this.Trace.name_x='Time';
             this.Trace.name_y='Voltage';
         end
         
         function readTrace(this)
             %set data format to be signed integer, reversed byte order
             fprintf(this.Device,'DATA:ENCDG SRIbinary');
             %2 bytes per measurement point
             fprintf(this.Device,'DATA:WIDTH 2');
             % read the entire trace
             fprintf(this.Device,'DATA:START 1;STOP %i;',this.POINT_NO);
             fprintf(this.Device,'CURVE?');
             y_data = int16(binblockread(this.Device,'int16'));
             
             % Reading the relevant parameters from the scope
             readProperty(this,'unit_y','unit_x',...
                 'step_x','step_y','x_zero');
                         
             % Calculating the y data
             y = double(y_data)*this.step_y; 
             n_points=length(y);
             % Calculating the x axis
             x = linspace(this.x_zero,...
                 this.x_zero+this.step_x*(n_points-1),n_points);
             
             this.Trace.x = x;
             this.Trace.y = y;
             % Discard "" when assiging the Trace labels
             this.Trace.unit_x = this.unit_x(2:end-1);
             this.Trace.unit_y = this.unit_y(2:end-1);
             triggerNewData(this);
         end
         
         function acquireContinuous(this)
             openDevice(this);
             fprintf(this.Device,...
                 'ACQuire:STOPAfter RUNSTop;:ACQuire:STATE ON');
             closeDevice(this);
         end
         
         function acquireSingle(this)
             openDevice(this);
             fprintf(this.Device,...
                 'ACQuire:STOPAfter SEQuence;:ACQuire:STATE ON');
             closeDevice(this);
         end
         
         % Emulates the physical knob turning, works with nturns=+-1
         function turnKnob(this,knob,nturns)
             openDevice(this);
             switch upper(knob)
                 case 'HORZSCALE'
                     % timebase is changed
                     if nturns==-1
                         sc = this.time_scale*2;
                     elseif nturns==1
                         sc = this.time_scale/2;
                     else
                         return
                     end
                     fprintf(this.Device,...
                         sprintf('HORizontal:MAIn:SCAle %i',sc));
                 case {'VERTSCALE1', 'VERTSCALE2'}
                     % vertical scale is changed
                     n_ch = sscanf(upper(knob), 'VERTSCALE%i');
                     tag = sprintf('scale%i', n_ch);
                     if nturns==-1
                         sc = this.(tag)*2;
                     elseif nturns==1
                         sc = this.(tag)/2;
                     else
                         return
                     end
                     fprintf(this.Device, sprintf('CH%i:SCAle %i',n_ch,sc));
             end
             closeDevice(this);
         end
     end
     
     %% Protected functions
     methods (Access=protected)
         
         function createCommandList(this)
             % channel from which the data is transferred
-            addCommand(this,'channel','DATa:SOUrce','default',1,...
+            addCommand(this,'channel',':DATa:SOUrce','default',1,...
                 'str_spec','CH%i');
             % units and scale for x and y waveform data
-            addCommand(this,'unit_x','WFMPre:XUNit','access','r',...
+            addCommand(this,'unit_x',':WFMPre:XUNit','access','r',...
                 'classes',{'char'});
-            addCommand(this,'unit_y','WFMPre:YUNit','access','r',...
+            addCommand(this,'unit_y',':WFMPre:YUNit','access','r',...
                 'classes',{'char'});
-            addCommand(this,'step_y','WFMPre:YMUlt','access','r',...
+            addCommand(this,'step_y',':WFMPre:YMUlt','access','r',...
                 'classes',{'numeric'});
-            addCommand(this,'step_x','WFMPre:XINcr','access','r',...
+            addCommand(this,'step_x',':WFMPre:XINcr','access','r',...
                 'classes',{'numeric'});
-            addCommand(this,'x_zero','WFMPre:XZEro','access','r',...
+            addCommand(this,'x_zero',':WFMPre:XZEro','access','r',...
                 'classes',{'numeric'});           
             % time scale in s per div
-            addCommand(this, 'time_scale','HORizontal:MAIn:SCAle',...
+            addCommand(this, 'time_scale',':HORizontal:MAIn:SCAle',...
                 'default',10E-3,...
                 'str_spec','%e');           
             % trigger level
-            addCommand(this, 'trig_lev', 'TRIGger:MAIn:LEVel',...
+            addCommand(this, 'trig_lev', ':TRIGger:MAIn:LEVel',...
                 'default',1,...
                 'str_spec','%e');
             % trigger slope
-            addCommand(this, 'trig_slope', 'TRIGger:MAIn:EDGE:SLOpe',...
+            addCommand(this, 'trig_slope', ':TRIGger:MAIn:EDGE:SLOpe',...
                 'default', 'RISe', 'val_list',{'RISe','RIS','FALL'},...
                 'str_spec','%s');
             % trigger source
-            addCommand(this, 'trig_source', 'TRIGger:MAIn:EDGE:SOUrce',...
+            addCommand(this, 'trig_source', ':TRIGger:MAIn:EDGE:SOUrce',...
                 'default', 'AUX', 'val_list', {'CH1','CH2',...
                 'EXT','EXT5','EXT10','AC LINE'}, 'str_spec','%s');
             % trigger mode
-            addCommand(this, 'trig_mode', 'TRIGger:MAIn:MODe',...
+            addCommand(this, 'trig_mode', ':TRIGger:MAIn:MODe',...
                 'default', 'AUTO', 'val_list',{'AUTO','NORMal','NORM'},...
                 'str_spec','%s');
             % state of the data acquisition by the scope
-            addCommand(this, 'acq_state', 'ACQuire:STATE',...
+            addCommand(this, 'acq_state', ':ACQuire:STATE',...
                 'default',true, 'str_spec','%b');
            
             % Parametric commands
             for i = 1:this.N_CHANNELS
                 i_str = num2str(i);
                 % coupling, AC, DC or GND
                 addCommand(this,...
-                    ['cpl',i_str],['CH',i_str,':COUP'],...
+                    ['cpl',i_str],[':CH',i_str,':COUP'],...
                     'default','DC', 'val_list', {'AC','DC','GND'},...
                     'str_spec','%s');              
                 % scale, V/Div
                 addCommand(this,...
-                    ['scale',i_str],['CH',i_str,':SCAle'],'default',1,...
+                    ['scale',i_str],[':CH',i_str,':SCAle'],'default',1,...
                     'str_spec','%e');
                 % channel enabled
                 addCommand(this,...
-                    ['enable',i_str],['SEL:CH',i_str],'default',true,...
+                    ['enable',i_str],[':SEL:CH',i_str],'default',true,...
                     'str_spec','%b');
             end
         end
     end
 end
\ No newline at end of file
diff --git a/@MyTlb6700/MyTlb6700.m b/@MyTlb6700/MyTlb6700.m
index 4de35d3..a4d0119 100644
--- a/@MyTlb6700/MyTlb6700.m
+++ b/@MyTlb6700/MyTlb6700.m
@@ -1,176 +1,179 @@
 % Class for communication with NewFocus TLB6700 tunable laser controllers
 % Needs UsbDllWrap.dll from Newport USB driver on Matlab path
 % Address field is ignored for this class. 
 % Start instrument as MyTlb6700('','USBaddr'), where USBaddr is indicated
 % in the instrument menu. Example: MyTlb6700('','1')
 
 classdef MyTlb6700 < MyScpiInstrument
     
     properties (SetAccess=protected, GetAccess=public)
         NetAsm; % .NET assembly
         QueryData; % auxiliary variable for device communication
     end
     
     %% Constructor and destructor
     methods (Access=public)
         function this=MyTlb6700(interface, address, varargin)
             this@MyScpiInstrument(interface, address, varargin{:});
             % Data read from the instrument is assigned 
             % to QueryData and can be then converted to char
             this.QueryData=System.Text.StringBuilder(64);
             % Interface field is not used in this instrument, but is
             % assigned value for the purpose of information
             this.interface='usb';
             % Convert address to number
             this.address=str2double(this.address);
         end
     end
     
     %% Protected functions
     methods (Access=protected)  
         function createCommandList(this)
+            % Commands for this class do not start from ':', as the
+            % protocol does not fully comply with SCPI standard
+            
             % Output wavelength, nm
             addCommand(this, 'wavelength','SENSe:WAVElength',...
                 'access','r','default',780,'str_spec','%e');
             % Diode current, mA
             addCommand(this, 'current','SENSe:CURRent:DIODe',...
                 'access','r','default',1,'str_spec','%e');
             % Diode temperature, C
             addCommand(this, 'temp_diode','SENSe:TEMPerature:DIODe',...
                 'access','r','default',10,'str_spec','%e');
             % Output power, mW
             addCommand(this, 'power','SENSe:POWer:DIODe',...
                 'access','r','default',1,'str_spec','%e');
             
             % Wavelength setpoint, nm
             addCommand(this, 'wavelength_sp','SOURce:WAVElength',...
                 'default',780,'str_spec','%e');
             % Constant power mode on/off
             addCommand(this, 'const_power','SOURce:CPOWer',...
                 'default',true,'str_spec','%b');
             % Power setpoint, mW
             addCommand(this, 'power_sp','SOURce:POWer:DIODe',...
                 'default',1,'str_spec','%e');
             
             % Control mode local/remote
             addCommand(this, 'control_mode','SYSTem:MCONtrol',...
                 'val_list',{'LOC','REM'},...
                 'default','LOC','str_spec','%s');
             % Output on/off
             addCommand(this, 'enable_output','OUTPut:STATe',...
                 'default',false,'str_spec','%b');
             % Wavelength track on/off
             addCommand(this, 'wavelength_track','OUTPut:TRACk',...
                 'default',true,'str_spec','%b');
         end
         
     end
     
     %% Public functions including callbacks
     methods (Access=public)
         % NewFocus lasers no not support visa communication, thus need to
         % overload connectDevice, writeCommand and queryCommand methods
         function connectDevice(this)
             % In this case 'interface' property is ignored and 'address' is
             % the USB address, indicated in the controller menu
             dll_path = which('UsbDllWrap.dll');
             if isempty(dll_path)
                 error(['UsbDllWrap.dll is not found. This library ',...
                     'is a part of Newport USB driver and needs ',...
                     'to be present on Matlab path.'])
             end
             this.NetAsm=NET.addAssembly(dll_path);
             % Create an instance of Newport.USBComm.USB class
             Type=GetType(this.NetAsm.AssemblyHandle,'Newport.USBComm.USB');
             this.Device=System.Activator.CreateInstance(Type);
             
             % Operation of opening device is time-consuming in this case,
             % on the other hand multiple open devices do not interfere. So
             % keep the device open for the whole session;
             openDevice(this);
         end
          
         function openDevice(this)
             OpenDevices(this.Device, hex2num('100A'));
         end
         
         % Overload isopen method of MyInstrument
         function bool=isopen(this)
             % Could not find a better way to check if device is open other
             % than attempting communication with it
             bool=false;
             try
                 stat = Query(this.Device, this.address, '*IDN?',...
                     this.QueryData);
                 if stat==0
                     bool=true;
                 end
             catch
             end
         end
         
         function closeDevice(this)
             CloseDevices(this.Device);
         end
         
         function stat_list=writeCommand(this, varargin)
             if ~isempty(varargin)
                 n_cmd=length(varargin);
                 stat_list=cell(n_cmd,1);
                 % Send commands one by one as sending one query seems
                 % to sometimes give errors if the string is very long
                 for i=1:n_cmd
                     cmd = [varargin{i},';'];
                     Query(this.Device, this.address, cmd, this.QueryData);
                     stat_list{i} = char(ToString(this.QueryData));
                 end
             end
         end
         
         function res_list=queryCommand(this, varargin)
             if ~isempty(varargin)
                 n_cmd=length(varargin);
                 res_list=cell(n_cmd,1);
                 % Query commands one by one as sending one query seems
                 % to sometimes give errors if the string is very long
                 for i=1:n_cmd
                     cmd = [varargin{i},';'];
                     Query(this.Device, this.address, cmd, this.QueryData);
                     res_list{i} = char(ToString(this.QueryData));
                 end
             else
                 res_list={};
             end
         end
         
         function stat = setMaxOutPower(this)
             % Depending on if the laser in the constat power or current
             % mode, set value to max
             if this.const_power
                 Query(this.Device, this.address, ...
                     'SOURce:CURRent:DIODe MAX;', this.QueryData);
             else
                 Query(this.Device, this.address, ...
                     'SOURce:POWer:DIODe MAX;', this.QueryData);
             end
             stat = char(ToString(this.QueryData));
         end
         
         function scanSingle(this, start_wl, stop_wl, speed)
             % Do not switch the laser off during the backward scan
             fprintf(this.Device,'SOURce:WAVE:SCANCFG 1;');
             % single scan
             fprintf(this.Device,'SOURce:WAVE:DESSCANS 1;');
             % Set start and stop wavelengths
             fprintf(this.Device,'SOURce:WAVE:START %e',start_wl);
             fprintf(this.Device,'SOURce:WAVE:STOP %e',stop_wl);
             fprintf(this.Device,'SOURce:WAVE:SLEW:FORWard %e',speed);
             % Return at maximum speed 
             fprintf(this.Device,'SOURce:WAVE:SLEW:RETurn MAX');
             
             % Start scan
             fprintf(this.Device,'OUTPut:SCAN:START');
         end
     end
 end
 
diff --git a/GUIs/GuiNa.mlapp b/GUIs/GuiNa.mlapp
index d75d740..e3b8280 100644
Binary files a/GUIs/GuiNa.mlapp and b/GUIs/GuiNa.mlapp differ