add new matlab versions and update cafe/epics version

.gitignore

@@ -11,5 +11,4 @@ felix-cache
 readme.txt
 makefile_rel_1.1*
 makefile_rel_1.3*
-makefile_rel_1.20*
 *.*.orig

README

@@ -46,4 +46,4 @@ cp 2024a <new_matlab_version>
 #in new module, 
 module load matlab/<new_matlab_version>
 
-cp .release-2024a .release-<new_matlab_version>
+cp .release-2024a .release-<new_matlab_version>

linux-x86_64/2024b/cadelmon.m

@@ -0,0 +1,23 @@
+function cadelmon(channel)
+% cadelmon('channel')
+% Deletes monitor callback on EPICS channel
+
+% translate pv name to handle
+if ischar(channel)
+    pv = mcaisopen(channel);
+    if pv == 0
+        return;
+    end
+elseif isnumeric(channel)
+    pv = channel;
+else
+    error ('first argument must be channel name or handle');
+end
+
+% delete monitor
+mcaclearmon(pv);
+
+% if no monitor left then stop monitoring
+if isempty(mcamon) && mcamontimer
+    mcamontimer('stop')
+end

linux-x86_64/2024b/caget.m

@@ -0,0 +1,108 @@
+function value = caget(channel,cached)
+% caget('channel') returns current value and additional infos
+% of given EPICS channel. 
+% caget('channel',1) returns last value and additional infos
+% of given EPICS channel. 
+%
+% channel can be a channel name or a handle as returned from mcaopen
+%
+% return value elements:
+%   val:      value (scalar, vector or string)
+%   sevr:     severity as a number
+%   sevr_str: severity as a string
+%   stat:     status as a number
+%   stat_str: status as a string
+%   time:     timestamp as a date vector
+%   units:    units string
+
+persistent severity_str
+persistent status_str
+persistent zerotime
+persistent units
+
+if ischar(channel)    
+    pv = mocha('open',channel);
+		
+		if mocha('isConnected', channel) == false
+			  mocha('openNowAndWait', 1.5)
+		end		
+		
+    if mocha('isConnected', channel) == false
+        error('EPICS channel %s not found', channel);
+    end
+elseif isnumeric(channel)
+    pv = channel;
+else
+    error ('first argument must be channel name or handle');
+end
+if isvector(pv)
+    pv=pv(1); % truncate
+end
+
+chInfo=mocha ('getChannelInfo',pv);
+
+if nargin > 1 && cached		
+    pvStruct = mocha('getPVCache',pv);
+else
+    pvStruct = mocha('getPV', pv);
+end
+
+
+
+pvCtrl = mocha('getCtrlCache',pv);
+%pvCtrl
+
+% initialize severity and status enums
+if isempty(severity_str)
+    severity_str = {'NO_ALARM';'MINOR';'MAJOR';'INVALID'};
+    status_str = {'NO_ALARM';'READ';'WRITE';'HIHI';'HIGH';'LOLO';'LOW';'STATE';'COS';'COMM';'TIMEOUT';'HWLIMIT';'CALC';'SCAN';'LINK';'SOFT';'BAD_SUB';'UDF';'DISABLE';'SIMM';'READ_ACCESS';'WRITE_ACCESS'};
+end
+
+
+value.val = pvStruct.val;
+
+units = pvCtrl.units;
+
+
+if (pvCtrl.noEnumStrings>0) 
+    value.val_str = value.val;
+		value.val = mocha('getCache',pv,'int8'); 		
+end
+
+
+value.units=units;
+value.sevr = pvStruct.alarmSeverity;
+indx=max(pvStruct.alarmSeverity, 0);
+value.sevr_str =  severity_str{indx+1};
+value.stat = pvStruct.alarmStatus;
+indx=max(pvStruct.alarmStatus, 0);
+value.stat_str = status_str{ indx+1};
+
+
+
+timestamp = mocha('getTimestamp',pv);
+if (numel(timestamp) == 2)
+% old mca version
+% do not use mcatime here because 1. it is slow, 2. is returns UTC
+% calculating zerotime only once is faster and takes localtime into account
+% When daylight saving time begins or ends, restart the program!
+    if isempty(zerotime)
+        [status,timezone]=system('date +%z'); % get localtime offset
+        timeoffs=str2double(timezone);
+        houroffs=floor(timeoffs/100);
+        minoffs=(timeoffs-100*houroffs);
+        zerotime = datenum('1-Jan-1990') + (minoffs/60 + houroffs)/24;
+    end
+    time=timestamp(1)+timestamp(2)/1000000000;
+    if time
+        time = zerotime+time/24/3600;
+    end
+    value.time = datevec(time);
+else
+% new mca version
+    timestamp(6)=timestamp(6)+timestamp(7)/1000000000;
+    value.time = timestamp(1:6);
+end
+
+
+

linux-x86_64/2024b/cainfo.m

@@ -0,0 +1,34 @@
+function value = cainfo(pvname)
+% cainfo('pvname') returns handle,element count, native type, state, ...
+%
+ 
+
+mcaNoConnection    ={'unknown',  'disconnected','Disconnected due to server or network problem'};
+mcaConnection      ={'known',    'connected','Normal connection'};
+mcaClosedConnection={'unknown',  'disconnected','Permanently disconnected (cleared)'};
+ 
+ 
+value=struct('Handle',{}, 'PVName',{}, 'ElementCount',{},'NativeType',{},'State',{},'MCAMessage',{},'Host',{},'Units',{});
+chInfo=mocha ('getChannelInfo', pvname);
+pvCtrl=mocha ('getCtrlCache', pvname);
+value(1).Handle= mocha('getHandleFromPV', pvname);
+value(1).PVName= mocha('getPVFromHandle', value(1).Handle);
+value(1).ElementCount=chInfo.nelem;
+nativeType=strsplit(chInfo.dataType,'_');
+value(1).NativeType=nativeType{2};
+
+if (chInfo.connectFlag==1)
+  			value(1).State=mcaConnection{2}; 
+				value(1).MCAMessage=mcaConnection{3};
+else 
+  			value(1).State=mcaNoConnection{2};
+				value(1).MCAMessage=mcaNoConnection{3};
+end
+	
+
+%value(1).MCAMessage=mocha('statusInfo', mocha('getStatus', pvname));
+value(1).Host =chInfo.hostName;
+value(1).Units=pvCtrl.units;
+
+%value(1)=setfield(value(1),'Units',pvCtrl.units)
+

linux-x86_64/2024b/camon.m

@@ -0,0 +1,62 @@
+function camon(channel,callback,userarg)
+% camon('channel', 'callback') 
+% camon('channel', 'callback', userarg) 
+% camon('channel', @callback) 
+% camon('channel', @callback, userarg) 
+%
+% Installs a callback function (given as string or handle)
+% on an EPICS channel.
+% Whenever the channel updates, the callback is called
+% with a structure as defined below and an optional
+% numeric, string, or matrix user argument
+%
+% callback argument structure elements:
+%   val:      value (scalar, vector or string)
+%   sevr:     severity as a number
+%   sevr_str: severity as a string
+%   stat:     status as a number
+%   stat_str: status as a string
+%   time:     timestamp as a date vector
+%
+% A monitor can be deleted with
+% cadelmon ('channel')
+
+
+% initialize monitoring the first time
+if ~mcamontimer
+    mcamontimer('start');
+end
+
+% translate channel name to handle
+if ischar(channel)
+    pv = mcacheckopen(channel);
+    if pv == 0
+        error('EPICS channel %s not found', channel);
+    end
+elseif isnumeric(channel)
+    pv = channel;
+else
+    error ('usage: camon(''channel'',@callback,userarg)');
+end
+
+% callback can be string or function handle -- we need string
+if nargin>1
+    if isa(callback,'function_handle')
+        callback = func2str(callback);
+    elseif ~ischar(callback)
+        error ('usage: camon(''channel'',@callback,userarg)');
+    end
+end
+
+% install monitor
+if nargin==1
+    mcamon(pv);
+    return
+elseif nargin==2
+    cb=sprintf('%s(caget(%d,1))',callback,pv);
+else
+    cb=sprintf('%s(caget(%d,1),''%s'')',callback,pv,mat2str(userarg));
+end
+disp(pv)
+disp(cb)
+mcamon(pv, cb);

linux-x86_64/2024b/caput.m

@@ -0,0 +1,30 @@
+function sts = caput(pvname, value)
+%   sts=caput('pvname',value) sets the value of EPICS PV 'pvname'.
+
+%
+channel=pvname;
+
+if ischar(channel)    
+    pv = mocha('open',channel);
+
+                if mocha('isConnected', channel) == false
+                          mocha('openNowAndWait', 1.5)
+                end
+
+    if mocha('isConnected', channel) == false
+        error('EPICS channel %s not found', channel);
+    end
+elseif isnumeric(channel)
+    
+		if mocha('isConnected', channel) == false
+        error('EPICS channel with handle %d not connected', channel);
+    end
+		pv = channel;
+		
+else
+    error ('First argument must be channel name or handle');
+end
+
+
+sts= mocha('set', pv, value);
+

linux-x86_64/2024b/mcaalarm.m

@@ -0,0 +1,36 @@
+function varargout = mcaalarm(varargin)
+%MCAALARM     - read alarm status and severity for PVs previously read with MCAGET or MCAMON
+%
+% VALUE = MCAALARM(HANDLE) 
+%    returns the status and severity of a PV specified by integer HANDLE:
+%
+%    VALUE is a structure:
+%       'status'  : Status code
+%       'severity': Severity code
+%
+% Refer to the EPICS header file "alarmString.h" for the code definitions.
+%
+% [VALUE1, ... VALUEN] = MCAALARM(HANDLE1, ... , HANDLEN)
+%    returns status and severity of multiple PVs of any type and length
+%    Number of outputs must match the number of inputs
+%       
+%   See also MCAGET, MCAMON.
+%
+if nargin<1
+    error('No arguments were specified in mcaalarm')
+elseif nargin==1
+    result{1} =  mocha('getAlarm',varargin{1}); %mca(61,varargin{1});
+    varargout{1}.status = result{1}(1,1);
+    varargout{1}.severity = result{1}(1,2);        
+elseif nargin>1 
+    if nargin ~= nargout
+        error('Number of outputs must match the number of inputs')
+    end
+    %[result{1:nargin}] = mca(61,varargin{:});
+    for k = 1:nargin
+				[result{k}] = mocha('getAlarm',varargin{k});
+        varargout{k}.status=result{k}(1,1);
+        varargout{k}.severity=result{k}(1,2);
+    end
+end
+

linux-x86_64/2024b/mcacache.m

@@ -0,0 +1,40 @@
+function varargout = mcacache(varargin)
+%MCACACHE     - reads locally cached value of a PV. 
+%   MCACACHE does NOT communicate with the server or use resources of CA library  
+%   
+%   VALUE = MCACACHE(HANDLE) returns a value of a PV by integer HANDLE
+%       The type (EPICS strings are returned as MATLAB strings)
+%       All numeric EPICS types returned are as MATLAB double
+%       If a PV is is a waveform VALUE is a vector
+%
+%   [ VALUE1 , ... VALUEN ] = MCACACHE(HANDLE1, ... , HANDLEN)
+%       returns values of multiple PV's.
+%       Number of outputs must match the number of inputs
+%       
+%   Notes: The cache value for a PV does not exist until the first use of a
+%   monitor on that PV
+%   See also: MCAMON
+
+if nargin>1 && nargin~=nargout
+    error('Number of outputs must match the number of inputs')
+end
+
+
+for k = 1:nargin				
+				[varargout{k}] = mocha('getCache',varargin{k});
+			
+end
+
+%for k = 1:nargin				
+%				scalarValues(k) = varargin{k};
+%end
+
+%[a,isAllOk,s]=mocha('getScalarArrayCache',scalarValues);
+
+%for k = 1:nargin	
+%  [varargout{k}]= a(k);
+%end
+%
+
+%[varargout{1:nargin}] = mca(300,varargin{:});
+

linux-x86_64/2024b/mcacheck.m

@@ -0,0 +1,20 @@
+function varargout = mcacheck(varargin)
+%MCACHECK     - Same as MCASTATE
+%   See also MCAOPEN
+
+if nargin > 0  
+    %varargout{1} = mca(13,varargin{:});
+		for k = 1:nargin	
+		  if mocha('isConnected', varargin{k}) == true	
+				isConnected(k) = uint16(1);
+			else
+				isConnected(k) = uint16(0);	
+			end	
+		end	
+		varargout{1} = isConnected;
+else
+		[h,pv,state] = mocha('getHandleStates'); 
+    %[varargout{1}, varargout{2}] = mca(12);
+		varargout{1} = h;
+		varargout{2} = state;
+end

linux-x86_64/2024b/mcacheckopen.m

@@ -0,0 +1,48 @@
+function varargout = mcacheckopen(varargin)
+%MCACHECKOPEN - returns handle(s) to PV(s)
+% Returns existing handles for PVs already connected,
+% opens new connections otherwise.
+% Returns 0 for PVs that failed to connect.
+%
+% HANDLE = MCACHECKOPEN('NAME')
+%
+% [HANDLE1, ... , HANDLEN] = MCACHECKOPEN('PVNAME1', ... , 'PVNAMEN')
+%
+% HANDLES = MCACHECKOPEN(NAMES)
+%    When NAMES is a cell array of strings, HANDLES is a numeric array of
+%    handles
+%
+% Note:
+% In principle, one should open, use, close PVs.
+% But in some cases the bookkeeping of PV handles might
+% be a bit too much for quick script hacks,
+% in which case mcacheckopen can help with re-use of
+% existing handles for PVs that were opened earlier yet
+% their handles are lost.
+%
+% See also MCAOPEN, MCAISOPEN
+
+if iscellstr(varargin{1})
+    varargout{1} = zeros(size(varargin{1}));
+		
+    for i=1:length(varargin{1})
+			
+        varargout{1}(i) = mcaisopen(varargin{1}{i});
+        if ~varargout{1}(i)
+						
+            varargout{1}(i) = mcaopen(varargin{1}{i});
+        end
+    end
+else
+
+		
+    for i=1:nargin
+				
+        varargout{i} = mcaisopen(varargin{i});
+        if ~varargout{i}
+					
+            varargout{i} = mcaopen(varargin{i});
+        end
+    end
+end
+    

linux-x86_64/2024b/mcaclearmon.m

@@ -0,0 +1,19 @@
+function mcaclearmon(varargin)
+%MCACLEARMON  - uninstall monitors, previously installed with MCAMON
+% 
+% MCACLEARMON(H1,H2,...,HN)
+%    H1,H2..,HN - integer channel handles 
+%
+% Note: Monitors can be installed with MCAMON and cleared with 
+%    MCACLEARMON any number of times.
+%
+% See also MCAMON, MCAMONTIMER, MCACACHE
+
+if nargin <1
+    error('Must specify channel handles to close');
+else
+    for i=1:nargin
+        %mca(200,varargin{i})
+				mocha('monitorStop',varargin{i})
+    end
+end

linux-x86_64/2024b/mcaclose.m

@@ -0,0 +1,22 @@
+function mcaclose(varargin)
+%MCACLOSE     - permanently closes channels
+% MCACLOSE(H1,H2,...,HN) closes the channels identified by their
+%    integer handles, previously opened with MCAOPEN.
+% MCACLOSE(H) is the same for the case that H is an array of handles.
+%
+% Note:  Once a channel is closed, it can not be used
+%    by MCAGET,MCAPUT or MCAMON. It can not be reopened.
+%    Use MCAOPEN again in order to connect to the same PV.
+%
+% See also MCAOPEN, MCASTATE, MCAINFO
+if nargin <1
+    error('Must specify channel handles to close');
+else
+    for i=1:nargin
+    	pvs = varargin{i};
+    	for j=1:length(pvs)
+        	%mca(5, pvs(j))
+					mocha('close', pvs(j))
+        end
+    end
+end

linux-x86_64/2024b/mcadebug.m

@@ -0,0 +1,12 @@
+function mcadebug(onoff)
+%MCADEBUG     - Enable/disable debugging
+%
+% Used only for development, not user-callable.
+if onoff
+    %mca(9999, 1);
+		disp('Not relevant to mocha');
+else
+    %mca(9999);
+		disp('Not relevant to mocha');
+end
+

linux-x86_64/2024b/mcaegu.m

@@ -0,0 +1,34 @@
+function varargout = mcaegu(varargin)
+%MCAEGU       - read engineering units from PV's
+%
+% VALUES = MCAEGU(HANDLE) returns a string array of enum strings of the
+%    PV specified by integer HANDLE.
+% The function does not handle arrays of PV handles, but only a single PV at at time.
+%
+%
+% Error handling:
+% An empty cell string array will be returned if the PV type is not ENUM.
+% A matlab exception will be thrown when the PV handle is invalid,
+% i.e. not the result of a successful MCAOPEN.
+% Furthermore, an error can result from a 'get' timeout,
+% configurable via MCATIMEOUT.
+% In addition, an error can result from a network disconnect.
+% In principle, one can check beforehand via MCASTATE, but since
+% a disconnect might happen just between the sucessful MCASTATE call
+% and the following MCAGET, the only safe thing might be to surround
+% MCAGET calls with TRY....CATCH.
+%
+%   See also TRY, CATCH, MCASTATE, MCATIMEOUT, MCAPUT
+if nargin<1
+    error('No arguments were specified in mcaget')
+elseif nargin==1
+    if length(varargin{1})>1
+        error('Only single PV can be handled at a time')
+    else
+		    pvCtrl=mocha('getCtrlCache', varargin{1});
+        varargout{1} = {pvCtrl.units}; %mca(41,varargin{1});
+    end
+elseif nargin>1
+    error('Only single PV can be handled at a time')
+end
+ 

linux-x86_64/2024b/mcaenums.m

@@ -0,0 +1,39 @@
+function varargout = mcaenums(varargin)
+%MCAENUMS       - read enum strings from PV's
+%
+% VALUES = MCAENUMS(HANDLE) returns a string array of enum strings of the
+%    PV specified by integer HANDLE.
+% The function does not handle arrays of PV handles, but only a single PV at at time.
+%
+%
+% Error handling:
+% An empty cell string array will be returned if the PV type is not ENUM.
+% A matlab exception will be thrown when the PV handle is invalid,
+% i.e. not the result of a successful MCAOPEN.
+% Furthermore, an error can result from a 'get' timeout,
+% configurable via MCATIMEOUT.
+% In addition, an error can result from a network disconnect.
+% In principle, one can check beforehand via MCASTATE, but since
+% a disconnect might happen just between the sucessful MCASTATE call
+% and the following MCAGET, the only safe thing might be to surround
+% MCAGET calls with TRY....CATCH.
+%
+%   See also TRY, CATCH, MCASTATE, MCATIMEOUT, MCAPUT
+if nargin<1
+    error('No arguments were specified in mcaget')
+elseif nargin==1
+    if length(varargin{1})>1
+        error('Only single PV can be handled at a time')
+    else
+		 		pvCtrl=mocha('getCtrlCache', varargin{1});
+				ens13=pvCtrl.enumStrings;
+				ens=cell(max(1,pvCtrl.noEnumStrings),1);			
+				for k=1:pvCtrl.noEnumStrings			
+					ens(k)=ens13(k);
+				end	
+        varargout{1} = ens; %mca(40,varargin{1});
+    end
+elseif nargin>1
+    error('Only single PV can be handled at a time')
+end
+ 

linux-x86_64/2024b/mcaexit.m

@@ -0,0 +1,5 @@
+function mcaexit()
+%MCAEXIT      - Shut down channel access...
+%
+% Disconnects all PVs.
+mocha('close') %mca(999)

linux-x86_64/2024b/mcaget.m

@@ -0,0 +1,71 @@
+function varargout = mcaget(varargin)
+%MCAGET       - read values from PV's
+%
+% VALUE = MCAGET(HANDLE) returns a value of a PV specified by integer HANDLE.
+%    Type of return value depends on the native type and the number of elements
+%    in the EPICS record:
+%    
+%    EPICS strings are returned as MATLAB strings
+%    EPICS array of strings - MATLAB cell array of strings
+%    All numeric EPICS types are returned as MATLAB double arrays
+%
+% VALUES = MCAGET(HANDLES) an easy get for a group of scalar numeric PV's
+%    HANDLES - array of handles
+%    VALUES  - numeric array of values. 
+%              If any of the PVs is a waveform, 
+%              only the first element is returned
+%
+% [VALUE1, ... VALUEN] = MCAGET(HANDLE1, ... , HANDLEN)
+%    returns values of multiple PV's of any type and length
+%    Number of outputs must match the number of inputs
+% 
+% Error handling:
+% A matlab exception will be thrown when any of the PVs are invalid,
+% i.e. not the result of a successful MCAOPEN.
+% Furthermore, an error can result from a 'get' timeout,
+% configurable via MCATIMEOUT.
+% In addition, an error can result from a network disconnect.
+% In principle, one can check beforehand via MCASTATE, but since
+% a disconnect might happen just between the sucessful MCASTATE call
+% and the following MCAGET, the only safe thing might be to surround
+% MCAGET calls with TRY....CATCH.
+%
+%   See also TRY, CATCH, MCASTATE, MCATIMEOUT, MCAPUT
+if nargin<1
+    error('No arguments were specified in mcaget')
+elseif nargin==1
+    if length(varargin{1})>1
+				[a, isallOK]=mocha('getScalarArray', varargin{1}, 'double');
+			
+        varargout{1} = [a]; %mocha('getScalarArray', varargin{1});  %mca(51,varargin{1});
+    else
+				chInfo=mocha('getInfo', varargin{1});
+			  if( strcmp(chInfo.dataType,'DBR_ENUM') )
+				  varargout{1} = mocha('get', varargin{1},'double');
+				else
+        	varargout{1} = mocha('get', varargin{1}); %mca(50,varargin{1});
+				end
+    end
+elseif nargin>1 
+    if nargin ~= nargout
+        error('Number of outputs must match the number of inputs')
+    end
+		[a, isallOK]=mocha('getStructArray', [varargin{:}]);
+		for k=1:length(a)
+			 chInfo=mocha('getInfo', varargin{k});
+			 if( length(a(k).val) ==1 && strcmp(chInfo.dataType,'DBR_ENUM') )
+			 		varargout{k}=mocha('getCache', varargin{k}, 'double');	  
+			 %if (length(a(k).val)==1 && iscell(a(k).val))
+		   % varargout{k}=a(k).val{1};
+			 else
+			 		if (length(a(k).val)==1 && iscell(a(k).val))
+		         varargout{k}=a(k).val{1};
+					else	 
+			    	varargout{k}=a(k).val;
+					end	
+			   
+			 end	
+		end
+    %[varargout{1:nargin}] mca(50,varargin{:});
+end
+

linux-x86_64/2024b/mcagets.m

@@ -0,0 +1,76 @@
+function varargout = mcagets(varargin)
+%MCAGETS       - read values from PV's, with string output for ENUMs
+%
+% VALUE = MCAGETS(HANDLE) returns a value of a PV specified by integer HANDLE.
+%    Type of return value depends on the native type and the number of elements
+%    in the EPICS record:
+%    
+%    EPICS strings are returned as MATLAB strings
+%    EPICS array of strings - MATLAB cell array of strings
+%    All numeric EPICS types are returned as MATLAB double arrays
+%    This routine returns the string value of ENUM types, when the input
+%    parameter is a single handle. Otherwise this routine behaves
+%    identically to MCAGET
+%
+% VALUES = MCAGETS(HANDLES) an easy get for a group of scalar numeric PV's
+%    HANDLES - array of handles
+%    VALUES  - numeric array of values. 
+%              If any of the PVs is a waveform, 
+%              only the first element is returned
+%
+% [VALUE1, ... VALUEN] = MCAGETS(HANDLE1, ... , HANDLEN)
+%    returns values of multiple PV's of any type and length
+%    Number of outputs must match the number of inputs
+% 
+% Error handling:
+% A matlab exception will be thrown when any of the PVs are invalid,
+% i.e. not the result of a successful MCAOPEN.
+% Furthermore, an error can result from a 'get' timeout,
+% configurable via MCATIMEOUT.
+% In addition, an error can result from a network disconnect.
+% In principle, one can check beforehand via MCASTATE, but since
+% a disconnect might happen just between the sucessful MCASTATE call
+% and the following MCAGET, the only safe thing might be to surround
+% MCAGET calls with TRY....CATCH.
+%
+%   See also TRY, CATCH, MCASTATE, MCATIMEOUT, MCAPUT
+if nargin<1
+    error('No arguments were specified in mcaget')
+elseif nargin==1
+    if length(varargin{1})>1
+				[a, isallOK]=mocha('getScalarArray', varargin{1}, 'double');
+        varargout{1} = [a];  %mca(51,varargin{1});
+    else
+				
+		  varargout{1} = mocha('get', varargin{1});
+		  		
+       %if(strcmp(mca(43,varargin{1}),'ENUM'))
+       %    enumvalues=mca(40,varargin{1});
+       %     varargout{1}= enumvalues{mca(50,varargin{1})+1};
+       % else
+       %     varargout{1} =mca(50,varargin{1});
+       % end
+    end
+elseif nargin>1 
+     if nargin ~= nargout
+        error('Number of outputs must match the number of inputs')
+    end
+		[a, isallOK]=mocha('getStructArray', [varargin{:}]);		
+		for k=1:length(a)
+			 chInfo=mocha('getInfo', varargin{k});
+			 if( length(a(k).val) ==1 && strcmp(chInfo.dataType,'DBR_ENUM') )
+			 		varargout{k}=mocha('getCache', varargin{k}, 'double');	  
+			 
+			 else
+			 		if (length(a(k).val)==1 && iscell(a(k).val))
+		         varargout{k}=a(k).val{1};
+					else	 
+			    	varargout{k}=a(k).val;
+					end	
+			 end	
+		end
+    %[varargout{1:nargin}] mca(50,varargin{:})
+		
+end
+
+

linux-x86_64/2024b/mcainfo.m

@@ -0,0 +1,86 @@
+function varargout = mcainfo(varargin);
+%MCAINFO      - get connection status and other information about a PV 
+% INFO = MCAINFO(PV) returns information on a single PV
+%   PV can be a string PV name or an integer handle
+%   Returns a 1-by-1 structure with fields:
+%
+%       Handle
+%       PVName
+%       ElementCount:
+%       NativeType { STRING | INT |  FLOAT | ENUM | CHAR | DOUBLE }
+%       State { connected | disconnected }
+%       MCAMessage
+%       Host
+%
+% [HANDLES, INFO] = MCAINFO with no argument returns information on
+%   all open channels in a structure array.
+%       HANDLES is a numeric array of handles
+%       INFO is a structure array of inoformation on the PV in the
+%            same format as above
+%
+% Note: A channel may become disconnected
+% due to a server or network problem. This will be reflected in 
+% MCAMessage field. Any attempts to read, write or monitor this channel
+% will return an error. CA library will periodically attempt to reestablish
+% connection without any action required from the user.
+% When the connection is closed by the user with MCACLOSE,
+% that PV handle becomes invalid, and attempts to call MCAINFO
+% will result in an error. 
+%   
+% See also: MCAOPEN MCACLOSE MCASTATE
+value=struct('Handle',{}, 'PVName',{}, 'ElementCount',{},'NativeType',{},'State',{},'MCAMessage',{},'Host',{},'Units',{});
+
+
+mcaNoConnection    ={'unknown',  'disconnected','Disconnected due to server or network problem'};
+mcaConnection      ={'known',    'connected','Normal connection'};
+mcaClosedConnection={'unknown',  'disconnected','Permanently disconnected (cleared)'};
+
+if nargin>0
+    if ischar(varargin{1})
+        %[handles, names] = mca(3);
+        %matchfound = find(strcmp(varargin{1},names));
+        %if isempty(matchfound)
+        %    error(['No open channels found for a PV: ',varargin{1}]);
+        %end
+        
+        %h = handles(matchfound);
+				h(1)=mocha('getHandleFromPV',varargin{1});
+				if (h(1)==0)
+					error(['No open channels found for a PV: ',varargin{1}]);
+				end
+    elseif isnumeric(varargin{1})
+        h(1)=(varargin{1});
+    else 
+        error('Argument must be a string PV Name or an integer handle');
+    end
+    %varargout{1} = mca(11,h);
+else % Return info on all channels
+    %[varargout{1} varargout{2}] = mca(10);
+		[h,pv]=mocha('getHandles');
+end		
+		
+for k=1:length(h)
+			chInfo=mocha ('getChannelInfo', h(k));
+			pvCtrl=mocha ('getCtrlCache', h(k));
+			value(k).Handle=h(k);
+			value(k).PVName= mocha('getPVFromHandle', h(k));
+			value(k).ElementCount=chInfo.nelem;
+			nativeType=strsplit(chInfo.dataType,'_');
+			value(k).NativeType=nativeType{2};
+			if (chInfo.connectFlag==1)
+  			value(k).State=mcaConnection{2}; 
+				value(k).MCAMessage=mcaConnection{3};
+			else 
+  			value(k).State=mcaNoConnection{2};
+				value(k).MCAMessage=mcaNoConnection{3};
+			end
+			%value(k).MCAMessage=mocha('statusInfo', mocha('getStatus', h(k)));
+			value(k).Host =chInfo.hostName;
+			value(k).Units=pvCtrl.units;
+end
+if (length(h)==1)
+	varargout{1} = value;
+else
+	varargout{1} = h;
+	varargout{2} = value;
+end

linux-x86_64/2024b/mcaisopen.m

@@ -0,0 +1,20 @@
+function h = mcaisopen(PVNAMESTRING);
+%MCAISOPEN    - Check if a channel to a PV is open with MCAOPEN
+%
+%   H = MCAISOPEN(PVNAMESTRING) returns an integer handle if open
+%   and 0 otherwise.  If more than one channel is open to the 
+%   same PV, an array of handles is returned.
+%
+%   See also MCAINFO MCASTATE
+
+if ~ischar(PVNAMESTRING)
+    error('Argument must be a string')
+end
+
+[handles, names] = mcaopen;
+matchfound = find(strcmp(PVNAMESTRING,names));
+if isempty(matchfound)
+    h = 0;
+else
+    h = handles(matchfound);
+end;

linux-x86_64/2024b/mcamon.m

@@ -0,0 +1,66 @@
+function varargout = mcamon(handle,varargin)
+%MCAMON       - install or replace monitor on a PV
+%   
+% STS = MCAMON(HANDLE) installs monitor with default callback.
+%   Default callback updates local copy of the channel data
+%   every time the data changes on the server.
+%   This cached data can be read at later time into MATLAB with MCACACHE.
+%   HANDLE - integer handle to a channel previously opened with MCAOPEN
+%   Returns 1 on success, 0 on failure
+% 
+% STS = MCAMON(HANDLE,CALLBACKSTRING) installs a monitor and specifies 
+%   a callback string for each. A callback string must be a MATLAB command,
+%   sequence of commands or a name of a script/function on the MATLAB path.
+%   It is executed in the 'base' workspace (AFTER the default callback) on
+%   the next poll of the queue by the MCAMONTIMER command.
+%   Returns 1 on success, 0 on failure
+%
+% [HANDLES, CALLBACKSTRINGS]=MCAMON with no arguments returns information
+%    on all currently installed monitors
+%
+% Note: Monitors can be installed with MCAMON and cleared with 
+%    MCACLEARMON any number of times.  Use MCAMONTIMER to initialise
+%    the MATLAB timer which polls and processes the outstanding MCA Monitor
+%    callback queue.
+% 
+% Note:  Use of asynchronous features of EPICS (such as monitors) 
+%    with MATLAB requires special care - read MCA notes.
+%   
+%    1.In CA client library (EPICS R3.13.4) asynchronous callbacks run one at a time
+%    to completion. This means that MATLAB callback string installed with MCAMON
+%    may not itself contain other MCA functions that call CA library such as MCAGET
+%    For example MCAMON(H1, 'X=MCAGET(H2);') will not work.
+%    MCAMON(H1, X='MCACACHE(H2);') is OK since MCACACHE does not use CA library. 
+%
+% See also MCAMONTIMER, MCACACHE, MCAGET, MCACLEARMON.
+
+
+if nargin ==1
+    %varargout{1}=mca(100,handle);
+		monID=mocha('monitor', handle); %return monitorID
+		status=0;
+		if (monID > 4095) %1st onid is 0xff (4096)
+			status=1;
+		end
+		varargout{1}=status;
+elseif nargin==2 
+    if ischar(varargin{1})
+        %varargout{1} = mca(100,handle,varargin{1});
+				monID=mocha('monitor', handle, varargin{1} )
+				status=0;
+				if (monID > 4095)
+					status=1;
+				end
+    else
+        error('Second argument must be a string');
+    end
+elseif nargin == 0
+    if nargout == 2
+        %[varargout{1},varargout{2}]=mca(500);
+				[varargout{1},varargout{2}]=mocha ('getMonitorHandlesAndActions');
+    else
+        %varargout{1}=mca(500);    
+				varargout{1}=mocha ('getMonitorHandles');
+    end
+end
+

linux-x86_64/2024b/mcamonevents.m

@@ -0,0 +1,25 @@
+function varargout = mcamonevents(varargin)
+%MCAMONEVENTS - returns the number of monitor events which have
+%             occurred for channels since the last call to MCACACHE.
+%
+% [HANDLES, EVENTCOUNT] = MCAMONEVENTS
+%    Returns handles and event counts for all open channels
+%
+% EVENTCOUNT = MCAMONEVENTS(HANDLES)
+%    Returns event counts for specified channel(s)
+%
+% See also MCAMON, MCACACHE, MCAGET, MCACLEARMON
+
+disp('not supported in mocha');
+
+
+%[handles, count] = mca(510);
+%if nargin == 0
+%    varargout{1} = handles;
+%    varargout{2} = count;
+%elseif nargin > 0 && isnumeric(varargin{1})
+%    for i=1:length(varargin{1})
+%        ind(i)=find(handles==varargin{1}(i));
+%    end
+%    varargout{1} = count(ind);
+%end

linux-x86_64/2024b/mcamontimer.m

@@ -0,0 +1,64 @@
+function varargout = mcamontimer(varargin)
+%MCAMONTIMER  - Controls the initialisation and termination of the MATLAB
+%              timer used to poll the MCA monitor command queue.
+%
+% Started = mcamontimer - returns 1 if monitor polling has been started
+%                         returns 0 if monitor polling has not been started
+%
+% mcamontimer('start') - starts the timer polling every 0.1 seconds
+% mcamontimer('stop')  - stops the timer
+%
+% Notes: 
+% (1) If monitors are installed using mcamon but mcaTimer has not been
+%     started, the monitor events will queue up indefinitely.  There is
+%     no limit to the size of the queue, so eventually you will
+%     run out of memory and crash.
+% (2) A polling period of 0.1 seconds is used.  This may be varied if
+%     desired by modifying the 'Period' argument in the definition of
+%     mcaTimer.
+% (3) Call mcamontimer('start') once.
+%
+% See also MCAMON, MCAMONEVENTS, MCACACHE, MCACLEARMON
+%
+persistent mcaTimer TimerStarted;
+
+%mocha('test')
+
+if (nargin == 0)
+    if (TimerStarted)
+        varargout{1} = 1;
+    else
+        varargout{1} = 0;
+    end
+elseif (nargin == 1)
+    switch varargin{1}
+        case 'start'
+            if (TimerStarted)
+                error('MCA monitor polling is already started.');
+            end
+            mlock;
+            %mcaTimer = timer('TimerFcn', 'mca(600)', 'Period', 0.1, 'ExecutionMode', 'fixedSpacing');
+						
+						
+						
+						mcaTimer = timer('TimerFcn', 'mocha(402)', 'Period', 10.1, 'ExecutionMode', 'fixedSpacing');
+						%%mcaTimer.TimerFcn= {@mocha, 'monitorflushevent'};
+            start (mcaTimer);
+            TimerStarted = 1;
+        case 'stop'
+            if (TimerStarted)
+                munlock;
+                stop (mcaTimer);
+                clear mcaTimer;
+                TimerStarted = 0;
+
+                 
+            else
+                error('MCA monitor polling has not been started.');
+            end            
+        otherwise
+            error('Invalid parameter specified for mcamontimer.  Use ''start'' or ''stop''.')
+    end
+else
+    error('Invalid number of arguments in mcamontimer.')
+end

linux-x86_64/2024b/mcaopen.m

@@ -0,0 +1,61 @@
+function varargout = mcaopen(varargin);
+%MCAOPEN      - open a Channel Access connection to an EPICS Process Variable
+%
+%   H = MCAOPEN(PVNAME);
+%       If successful H is a unique nonzero integer handle associated with this PV.
+%       Returned handle is 0 if a connection could not be established
+%       
+%   [H1, ... ,Hn] = MCAOPEN(PVNAME1, ... ,PVNAMEn);
+%       Is equivalent to but more efficient than multiple single-argument calls
+%           H1 = MCAOPEN(PVNAME1);
+%           ...
+%           Hn = MCAOPEN(PVNAMEn);
+%        
+%   HANDLES  = MCAOPEN(NAMES) is convenient when working with long lists of PV names
+%       HANDLES is a numeric array of assigned handles
+%       NAMES is a cell array of strings with PV names
+%   
+%   [HANDLES, NAMES] = MCAOPEN with no arguments returns a list of PV Names for all open connections. 
+%       HANDLES is a numeric array of handles
+%       NAMES is a cell array of strings with PV names
+%
+%   Note:
+%   When done, one should probably use MCACLOSE on the handle.
+%   When you use the same channel again "later", you might keep it open.
+%   See MCACHECKOPEN for a lazy person's bookkeeping helper.
+%
+%   See also: MCACHECKOPEN, MCAISOPEN, MCACLOSE
+
+if nargin>1  &&  nargin ~= nargout
+    error('Number of outputs must match the number of inputs')
+end
+
+
+if nargin==0
+    [varargout{1} varargout{2}] = mocha('getHandles'); %mca(3); 
+		
+elseif iscellstr(varargin) && nargin ==1		
+		varargout{1} = mocha('open', varargin{1} );
+		
+elseif iscellstr(varargin{1}) && nargin==1
+    if length(varargin{1}) > 1
+		 	mocha ('openPrepare');
+			varargout{1} = mocha('open', varargin{1} );
+			mocha ('openNow')
+		else			
+    	varargout{1} = mocha('open', varargin{1} ); % mca(2,varargin{1});
+		end		
+		
+elseif iscellstr(varargin) 
+	  mocha('openPrepare'); 
+    %[varargout{1:nargin}] = 	
+		h1=mocha('openArray',{varargin{:}})  %mca(1,varargin{:}); 
+		for i = 1:length(h1)
+			[varargout{i}] = h1(i);	
+		end		
+		mocha('openNow');	
+else
+    error('All arguments must be strings')
+end
+
+    

linux-x86_64/2024b/mcapoll.m

@@ -0,0 +1,4 @@
+function mcapoll()
+%MCAPOLL      - poll channel access...
+%mca(30)
+mocha('capoll')

linux-x86_64/2024b/mcaprec.m

@@ -0,0 +1,35 @@
+function varargout = mcaprec(varargin)
+%MCAPREC       - read precision from PV's
+%
+% VALUES = MCAPREC(HANDLE) returns the precision field of a channel as a double
+%
+% The function does not handle arrays of PV handles, but only a single PV at at time.
+%
+%
+% Error handling:
+% An empty cell string array will be returned if the PV type is not ENUM.
+% A matlab exception will be thrown when the PV handle is invalid,
+% i.e. not the result of a successful MCAOPEN.
+% Furthermore, an error can result from a 'get' timeout,
+% configurable via MCATIMEOUT.
+% In addition, an error can result from a network disconnect.
+% In principle, one can check beforehand via MCASTATE, but since
+% a disconnect might happen just between the successful MCASTATE call
+% and the following MCAGET, the only safe thing might be to surround
+% MCAGET calls with TRY....CATCH.
+%
+%   See also TRY, CATCH, MCASTATE, MCATIMEOUT, MCAPUT
+if nargin<1
+    error('No arguments were specified in mcaget')
+elseif nargin==1
+    if length(varargin{1})>1
+        error('Only single PV can be handled at a time')
+    else
+        %varargout{1} = mca(42,varargin{1});
+			  pvCtrl = mocha('getCtrl', varargin{1});	
+				varargout{1} =pvCtrl.precision();
+    end
+elseif nargin>1
+    error('Only single PV can be handled at a time')
+end
+ 

linux-x86_64/2024b/mcaput.m

@@ -0,0 +1,109 @@
+function sts = mcaput(varargin)
+%MCAPUT       - Write values to EPICS Process Variables
+%
+% MCAPUT(HANDLE1, VALUE1) - one handle, one value
+% MCAPUT(HANDLE1, VALUE1, ... , HANDLE_N, VALUE_N) - handles and values in pairs
+%
+% EPICS STRING values are passed as MATLAB strings. For example:
+%    >> mcaput(H, 'MATLAB')
+%    >> mcaput(H1, 'MATLAB', H2, 'EPICS')
+% or cell arrays of strings.
+%
+% MCAPUT(HANDLES_CELL_ARRAY, VALUES_CELL_ARRAY) - arguments are grouped
+%    in cell array of integer handles and a cell array of values
+%    of equal length.
+% 
+% Returns an array of status values: 1 success, 0 failure, -1 timeout
+% 
+% MCAPUT is implemented as a call to the ca_put_array_callback
+% function in CA client library.
+% MCAPUT returns 1 or 0 if we get an OK respectively error status within
+% the timeout, or -1 if we don't get any response within the timeout.
+%
+% Note:
+% The special case of MCAPUT([PV, PV, ...], [SCALAR, SCALAR, ...])
+% will simply write the scalar values to the PVs without waiting for the
+% callback.
+%    
+% See also MCAGET, MCATIMEOUT.
+
+if nargin==2
+    if iscell(varargin{1}) && iscell(varargin{2})
+        % {pv, pv, pv, ...}, {value, value, value, ...}
+        if length(varargin{1}) ~= length(varargin{2})
+            error('Cell array of MCA handles and cell array of values must be the same length')
+        end
+        HANDLES = varargin{1}; VALUES = varargin{2};
+        ARGS = reshape([HANDLES(:)';VALUES(:)'],1,2*length(varargin{1}));
+        %sts = mca(70,ARGS{:});
+				mocha('setputwait',HANDLES);
+				[gsts,sts]=mocha('setScalarArray', HANDLES, VALUES);
+    elseif isnumeric(varargin{1})
+        if length(varargin{1})>1
+            if length(varargin{1}) ~= length(varargin{2})
+                error('Array of handles and array of values must be the same length');
+            end
+	        % [pv, pv, pv, ...], [value, value, value, ...]
+            %sts = mca(80,varargin{1},varargin{2});
+						mocha('setputwait', varargin{1});
+						[gsts,sts]=mocha('setScalarArray',  varargin{1},varargin{2});
+        else
+            ARGS = varargin;
+			% (pv, value)
+			      if (isnumeric(ARGS{2}(1)))
+            %if (isnumeric(ARGS(2)))
+                %sts = mca(70,ARGS{:});
+								mocha('setputwait',ARGS{1});
+								sts = mocha('set',ARGS(1), ARGS(2));
+            else
+								chInfo=mocha('getInfo', varargin{1});	
+							  if(strcmp(chInfo.dataType,'DBR_ENUM')&&~isnumeric(varargin{2}))
+                %if(strcmp(mca(43,varargin{1}),'ENUM')&&~isnumeric(varargin{2}))
+							    	pvCtrl=mocha('getCtrlCache', varargin{1});
+                    enumvalues= pvCtrl.enumStrings;  %mca(40,varargin{1});
+                    %enumvalues=mca(40,varargin{1});
+                    found = 0;
+                    for ind = 1:numel(enumvalues)
+                        if(strcmp(ARGS(2),enumvalues(ind)))
+                            valueToPut=ind-1;
+                            found=1;
+                        end
+                    end
+                    if(found)
+                        ARGS{2}=valueToPut;
+												mocha('setputwait',ARGS(1));
+                        sts =  mocha('set',ARGS(1), ARGS(2)); % mca(70,ARGS{:});
+                    else
+                        strings = sprintf(' "%s" ',enumvalues{:});
+                        error('mcaput:enumCheck','Invalid value for this channel. Try one of: [%s]',strings);
+                    end
+                else
+                    %sts = mca(70,ARGS{:});
+										mocha('setputwait',ARGS(1));
+                    sts =  mocha('set',ARGS(1), ARGS(2));
+                end
+            end
+        end
+    else
+    	error('Invalid mcaput args, need PV, VALUE');
+    end
+elseif mod(nargin,2) == 0
+	% 'pv, value, pv, value, ...'
+    %sts = mca(70,varargin{:});
+		
+   
+	  j=uint16(0);
+		for i=1:2:nargin
+				j=j+1;
+        handles(j)=varargin{i};	
+				values{j}=varargin{i+1};			
+    end
+		
+
+    
+		mocha('setputnowait',handles);
+		[gsts,sts]=mocha('setMany', handles, values{1:j});
+	 
+else
+    error('Incorrect number of inputs, need a sequence of PV, VALUE')
+end

linux-x86_64/2024b/mcaputnowait.m

@@ -0,0 +1,118 @@
+function sts = mcaputnowait(varargin)
+%MCAPUT       - Write values to EPICS Process Variables
+%
+% MCAPUT(HANDLE1, VALUE1) - one handle, one value
+% MCAPUT(HANDLE1, VALUE1, ... , HANDLE_N, VALUE_N) - handles and values in pairs
+%
+% EPICS STRING values are passed as MATLAB strings. For example:
+%    >> mcaput(H, 'MATLAB')
+%    >> mcaput(H1, 'MATLAB', H2, 'EPICS')
+% or cell arrays of strings.
+%
+% MCAPUT(HANDLES_CELL_ARRAY, VALUES_CELL_ARRAY) - arguments are grouped
+%    in cell array of integer handles and a cell array of values
+%    of equal length.
+% 
+% Returns an array of status values: 1 success, 0 failure, -1 timeout
+% 
+% MCAPUT is implemented as a call to the ca_put_array_callback
+% function in CA client library.
+% MCAPUT returns 1 or 0 if we get an OK respectively error status within
+% the timeout, or -1 if we don't get any response within the timeout.
+%
+% Note:
+% The special case of MCAPUT([PV, PV, ...], [SCALAR, SCALAR, ...])
+% will simply write the scalar values to the PVs without waiting for the
+% callback.
+%    
+% See also MCAGET, MCATIMEOUT.
+
+if nargin==2
+    if iscell(varargin{1}) && iscell(varargin{2})
+        % {pv, pv, pv, ...}, {value, value, value, ...}
+        if length(varargin{1}) ~= length(varargin{2})
+            error('Cell array of MCA handles and cell array of values must be the same length')
+        end
+        HANDLES = cell2mat(varargin{1}); VALUES = cell2mat(varargin{2});
+        disp('first call to mca 80')				
+        %sts = mca(80,HANDLES,VALUES);
+				mocha('setputnowait',HANDLES);
+				[gsts,sts]=mocha('setScalarArray', HANDLES, VALUES);
+    elseif isnumeric(varargin{1})
+        if length(varargin{1})>1
+            if length(varargin{1}) ~= length(varargin{2})
+                error('Array of handles and array of values must be the same length');
+            end
+	        % [pv, pv, pv, ...], [value, value, value, ...]
+            disp('call mca 80')
+            %sts = mca(80,varargin{1},varargin{2});
+						mocha('setputnowait', varargin{1});
+						[gsts,sts]=mocha('setScalarArray',  varargin{1},varargin{2});
+        else
+            ARGS = varargin;
+						%a=ARGS{1};
+						%b=ARGS{2};
+					
+			% (pv, value)
+            if (isnumeric(ARGS{2}(1)))           %(ARGS(2)))								
+                %sts = mca(80,ARGS{:});
+								mocha('setputnowait',ARGS{1});
+								sts = mocha('set',ARGS(1), ARGS(2));
+            else
+								chInfo=mocha('getInfo', varargin{1});						
+                %if(strcmp(mca(43,varargin{1}),'ENUM')&&~isnumeric(varargin{2}))
+								if(strcmp(chInfo.dataType,'DBR_ENUM')&&~isnumeric(varargin{2}))
+										pvCtrl=mocha('getCtrlCache', varargin{1});
+                    enumvalues= pvCtrl.enumStrings;  %mca(40,varargin{1});
+										
+                    found = 0;
+                    for ind = 1:numel(enumvalues)
+                        if(strcmp(ARGS(2),enumvalues(ind)))
+                            valueToPut=ind-1;
+                            found=1;
+                        end
+                    end
+                    if(found)
+                        ARGS{2}=valueToPut;
+												mocha('setputnowait',ARGS(1));
+                        sts =  mocha('set',ARGS(1), ARGS(2)); %  mca(70,ARGS{:});
+                    else
+                        strings = sprintf(' "%s" ',enumvalues{:});
+                        error('mcaput:enumCheck','Invalid value for this channel. Try one of: [%s]',strings);
+                    end
+                else
+								    mocha('setputnowait',ARGS(1));
+                    sts =  mocha('set',ARGS(1), ARGS(2)); %mca(80,ARGS{:});
+										
+                end
+            end
+        end
+    else
+    	error('Invalid mcaput args, need PV, VALUE');
+    end
+elseif mod(nargin,2) == 0
+	% 'pv, value, pv, value, ...'
+	% sts = mca(80,handles,values);
+    %for i=1:nargin
+        %params(i)=varargin{i};				
+    %end
+    %nargin;
+    %data=reshape(params,2,nargin/2);
+    %handles=data(1,:);
+    %values=data(2,:);
+		j=uint16(0);
+		for i=1:2:nargin
+				j=j+1;
+        handles(j)=varargin{i};	
+				values{j}=varargin{i+1};			
+    end
+		
+		disp(handles)
+		disp(values)
+    
+		mocha('setputnowait',handles);
+		[gsts,sts]=mocha('setMany', handles, values{1:j});
+    %disp('pv,val,pv,val')
+else
+    error('Incorrect number of inputs, need a sequence of PV, VALUE')
+end

linux-x86_64/2024b/mcastate.m

@@ -0,0 +1,46 @@
+function varargout = mcastate(varargin);
+%MCASTATE     - returns an array of connection states for open channels
+% MCASTATE is used as diagnostics prior to issuing other
+% MCA commands such as MCAGET, MCAPUT and MCAMON
+%
+% STATES = MCASTATE(H1,H2,...,HN) returns the states of 
+%   the specified channels previously opened with MCAOPEN.
+%   STATES = an array of the states of the channels listed in the HANDLES
+%   array
+%
+% [HANDLES, STATES] = MCASTATE is an array of states of all 
+%   currently open channels.
+%   HANDLES = an array of all the currently open channels
+%   STATES = an array of the states of the channels listed in the HANDLES
+%   array
+%
+% Possible values
+% 1 - Connected: MCAGET, MCAPUT and MCAMON are valid
+% 0 - Disconnected: MCAGET, MCAPUT and MCAMON will return invalid
+%     data or fail. This may be due to a server/network problem
+%
+% See also MCAINFO, MCAOPEN, MCACLOSE.
+
+%if nargin > 0
+%    varargout{1} = mca(13,varargin{:});
+%else
+%    [varargout{1}, varargout{2}] = mca(12);
+%end
+
+
+if nargin > 0  
+    %varargout{1} = mca(13,varargin{:});
+		for k = 1:nargin	
+		  if mocha('isConnected', varargin{k}) == true	
+				isConnected(k) = uint16(1);
+			else
+				isConnected(k) = uint16(0);	
+			end	
+		end	
+		varargout{1} = isConnected;
+else
+		[h,pv,state] = mocha('getHandleStates'); 
+    %[varargout{1}, varargout{2}] = mca(12);
+		varargout{1} = h;
+		varargout{2} = state;
+end

linux-x86_64/2024b/mcatime.m

@@ -0,0 +1,44 @@
+function varargout = mcatime(varargin)
+%MCATIME      - read timestamps for PVs previously read with MCAGET or MCAMON
+%
+% The timestamp is returned as a MATLAB serial date number suitable
+% for use in the DATESTR function.
+%
+% The original time stamp is in the UTC timezone,
+% but since Matlab doesn't handle timezones in datenum/datastr,
+% it's converted to the 'local' timezone, so that
+%    datestr(mcatime(pv))
+% should give a time that is close to the wall clock
+% for channels that changed recently.
+%
+% VALUE = MCATIME(HANDLE) 
+%    returns the timestamp of a PV specified by integer HANDLE.
+%
+% [VALUE1, ... VALUEN] = MCATIME(HANDLE1, ... , HANDLEN)
+%    returns timestamps of multiple PVs of any type and length
+%    Number of outputs must match the number of inputs
+%       
+%   See also MCAGET, MCAMON.
+%
+for i=1:nargin
+   
+	% We get y/m/d H:M:S plus nanosecs...
+    %pieces = mca(60,varargin{i});		
+    % but datenum doesn't handle nanosecs
+    %varargout{i} = datenum(pieces(1:6));
+		timestamp=mocha('getTimeStamp',varargin{i});
+		timestamp=double(timestamp);
+		
+	  timestamp(6)=timestamp(6)+timestamp(7)/double(1000000000);
+		%value.time(1)=double(timestamp(1));
+		%value.time(2)=(timestamp(2));
+		%value.time(3)=(timestamp(3));
+		%value.time(4)=(timestamp(4));
+		%value.time(5)=(timestamp(5));
+	
+		%varargout{i}(1:5)=value.time(1:5);=		
+		%varargout{i}(6)=double(timestamp6);
+		varargout{i}=timestamp(1:6); 
+		%format longG;
+end                              
+

linux-x86_64/2024b/mcatimeout.m

@@ -0,0 +1,64 @@
+function varargout = mcatimeout(varargin)
+%MCATIMEOUT   - set or display MCA timeout setings
+%   
+%   MCATIMEOUT('open', t1)  
+%       'open' option sets the internal variable MCA_SEARCH_TIMEOUT to t1 (sec)
+%
+%   MCATIMEOUT('get', t1)  
+%       'get' option sets the internal variable MCA_GET_TIMEOUT to t1 (sec)
+%
+%   MCATIMEOUT('put', t1)  
+%       'put' option sets the internal variable MCA_PUT_TIMEOUT to t1 (sec)
+%
+%   MCATIMEOUT('default') sets the default values
+%       MCA_SEARCH_TIMEOUT = 1.0 (sec)
+%       MCA_GET_TIMEOUT = 5.0 (sec)
+%       MCA_PUT_TIMEOUT = 0.01 (sec)
+%   
+%   TIMEOUTS = MCATIMEOUT with no arguments returns a vector of currently set timeouts
+%       in the format [MCA_SEARCH_TIMEOUT MCA_GET_TIMEOUT  MCA_PUT_TIMEOUT]  
+% 
+%   Notes: 
+%   See also: MCA.cpp
+%
+switch nargin
+    case 0
+		    a=mocha('getTimeout');
+				%a(1) Put %a(2)Get
+			  b=mocha('getOpenWaitTime');
+				AB=[b(1); a(2); a(1)]; %search, get, put
+        varargout{1} = AB(1:3); %mca(1000);
+    case 1
+        if strcmp(varargin{1}, 'default')
+				    a=mocha('setTimeOutDefault');
+						b=mocha('openWaitWithTimeDefault');
+						AB=[b(1); a(2); a(1)]; %search, get, put
+            varargout{1} = AB(1:3); %mca(1004);
+        else
+            error ('Invalid command option.')
+        end
+    case 2
+        if strcmp(varargin{1}, 'open')
+        	if ~isnumeric(varargin{2})  ||  varargin{2} <= 0
+        	    error('Second argument must be numeric, positive seconds');
+        	end
+					  mocha('openWaitWithTime',varargin{2});
+            %mca(1001,varargin{2});
+        elseif strcmp(varargin{1}, 'get')
+        	if ~isnumeric(varargin{2})  ||  varargin{2} <= 0
+        	    error('Second argument must be numeric, positive seconds');
+        	end
+					  mocha('setTimeoutGet',varargin{2});
+            %mca(1002,varargin{2});						
+        elseif strcmp(varargin{1}, 'put')
+        	if ~isnumeric(varargin{2})  ||  varargin{2} <= 0
+        	    error('Second argument must be numeric, positive seconds');
+        	end
+					  mocha('setTimeoutPut',varargin{2});
+            %mca(1003,varargin{2});
+        else
+            error('Invalid command option.')
+        end       
+    otherwise
+        error ('Invalid number of arguments.')
+end

linux-x86_64/2024b/mcaunlock.m

@@ -0,0 +1,11 @@
+function mcaunlock;
+%MCAUNLOCK    - unlocks the MCAMAIN mex-file 
+% .. so that it can be cleared from memory with CLEAR
+%
+% MCAMAIN starts in a locked state 
+% to protect from it from being 
+% accidentally cleared and
+% loosing channel access connections.
+%mca(0);
+mocha('mexUnlock');
+%disp('mca mex-file is now UNLOCKED');

linux-x86_64/2024b/mcaversion.m

@@ -0,0 +1,8 @@
+function ver = mcaversion()
+%MCAVERSION   - get version info 
+% ver = mcaversion()
+%
+% returns the mca version as a string
+
+%ver = mca(-1);
+ver = mocha('version'); 

linux-x86_64/2024b/monitorAction.m

@@ -0,0 +1,16 @@
+function varargout = monActionLocal(varargin)
+disp('monitorAction called for:');
+pvName=mocha('getPVFromHandle', varargin{1});
+disp(pvName);
+X=['Handle =', num2str(varargin{1})];
+disp(X);
+
+%[varargout{1} varargout{2}] = mocha ('getCache', varargin{1});
+[var1,var2]=mocha ('getCache', varargin{1});
+[s,t]=mocha('getStatus',  varargin{1});
+%X=['Value=', num2str(varargout{1}), ' Status=', num2str(s), ' [',t(1), ' ', t(2),']'];
+X=['Value =', num2str(var1)];
+Y=['Status=', num2str(s)];
+disp(X)
+disp(Y)   
+disp([t(1),t(2)])

linux-x86_64/2024b/pvtable.m

@@ -0,0 +1,48 @@
+function pvt = pvtable()
+%
+% pvt=pvtable()
+% returns a table displaying all pvs and their status
+%
+[hpv,pvn,state] = mocha('getHandleStates');
+
+pvt=[];
+if (isempty(hpv)) 
+	disp('THERE ARE NO CHANNELS!');
+  return;
+end	
+	   
+%If monitor then uses cache value
+mocha('getAsyn', hpv);
+mocha('sendNow'); %otherwise getPVCache will do the send!
+dstruct =  mocha('getPVCache', hpv); 
+
+%If NaN then following warning given from struct2table:
+%Warning: Out of range or non-integer values truncated during
+%conversion to character
+%
+t=struct2table(dstruct);
+
+for n=1:length(hpv)
+        s1(n).handle=hpv(n);
+	s1(n).pv=pvn(n);
+	s1(n).cs=state(n);
+	s1(n).nmon=mocha('getNoMonitors', hpv(n));
+end 
+
+t1=struct2table(s1);
+
+if (string(class(t.val)) == string('char'))
+	t.val=string(t.val);
+end
+
+pvt=table(t1.handle,t1.pv, t.val, t.status, t1.cs, t1.nmon);
+pvt.Properties.VariableNames={'h','pv', 'val', 'stat','c', 'm'};
+%tNew.Properties.VariableNames{'Var1'}= 'handle';
+%tNew.Properties.VariableNames{'Var2'}= 'pv';
+%tNew.Properties.VariableNames{'Var3'}= 'val'; 
+
+
+%2017a
+%setColHeading(tNew, 1, 'handle');
+%setColHeading(tNew, 2, 'pv');
+%setColHeading(tNew, 3, 'val');

linux-x86_64/2024b/test.xml

@@ -0,0 +1,18 @@
+<!--A simple, minimalistic TEST XML file-->
+
+<cafe:config>
+  <cafe:group id="gTest">
+	<cafe:member> <cafe:name> ARIDI-BPM-01LE:X-AVG </cafe:name> </cafe:member>
+	<!--
+	<cafe:member> <cafe:name> ARIDI-BPM-01LB:X-AVG </cafe:name> </cafe:member>
+	<cafe:member> <cafe:name> ARIDI-BPM-01SE:X-AVG </cafe:name> </cafe:member>
+        <cafe:member> <cafe:name> ARIDI-BPM-01SB:X-AVG </cafe:name> </cafe:member>
+	-->        
+        <cafe:member> <cafe:name> ARIDI-BPM-01LE:Y-AVG </cafe:name> </cafe:member>
+	<!--
+        <cafe:member> <cafe:name> ARIDI-BPM-01LB:X-AVG </cafe:name> </cafe:member>
+        <cafe:member> <cafe:name> ARIDI-BPM-01SE:X-AVG </cafe:name> </cafe:member>
+        <cafe:member> <cafe:name> ARIDI-BPM-01SB:X-AVG </cafe:name> </cafe:member>    
+	-->
+  </cafe:group>
+</cafe:config>

macchinettaSwitch.cpp

@@ -501,7 +501,7 @@ void macchinettaFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prh
         break;
 
     case MOCHA_VERSION:
-        plhs[0]=mxCreateString((char *) "mocha-1.21.0 : 12 July 2024; Contact: Felix Armborst");
+        plhs[0]=mxCreateString((char *) "mocha-1.22.0 : 6 October 2025; Contact: Felix.Armborst@psi.ch");
         break;
 
     case SHOW:

makefile_rel_1.20-gcc-10.4.0

@@ -0,0 +1,105 @@
+#
+# Jan Chrin
+# Version: July 2019 - Qt5 
+#
+# makefile to build mocha mex file
+# printenv | grep MATLAB to reveal your MATLAB Directory
+#
+#
+# local executables are built in  ./${EPICS_HOST_ARCH}/$(MVER)
+# where the MATLAB version is grepped from $(MATLAB)
+
+MATLAB_ROOT=${MATLAB}
+MATLAB_VERSION=$(notdir $(MATLAB_ROOT))
+
+##### CHANGE AS APPROPRIATE #################
+#Mocha Version to install
+MOCHA_VERSION=mocha-1.20.1-gcc-10.4.0
+#CAFE version to link to
+CAFE_VERSION=cafe-1.20.1-gcc-10.4.0
+
+EPICS_BASE=${EPICS}/base-7.0.7
+#CAFE project base
+CAFE_BASE=/opt/gfa/cafe
+CAFE_MOCHA_BASE=${CAFE_BASE}/mocha
+CAFE_CPP_BASE=$(CAFE_BASE)/cpp/$(CAFE_VERSION)
+BOOST_BASE=${CAFE_BASE}/boost/boost_1_61_0/include
+
+CAFE_OBJS_DIR = $(CAFE_BASE)/cpp/$(CAFE_VERSION)/lib/$(EPICS_HOST_ARCH)/libcafe.a
+
+#if qt5 has libQt5Core.so link
+#QT5_DIR= /opt/psi/Cafe/cafe-matlab/${MATLAB_VERSION}/libexec
+QT5_DIR= ${MATLAB_ROOT}/bin/glnxa64
+
+INSTALL_MOCHA_LIBDIR= $(CAFE_MOCHA_BASE)/$(MOCHA_VERSION)/lib/$(EPICS_HOST_ARCH)/$(MATLAB_VERSION)
+#############################################
+
+
+#First deteremine if we are on a 32/64 bit machine
+#as mex file extensions are named differently
+pattern64=x86_64
+pattern32=i386
+
+PWD=$(shell pwd)
+      #hardware platform   
+      HW=$(shell uname -i)
+      ifeq ($(pattern64),$(findstring $(pattern64), $(HW)))
+        MEXE=mexa64
+	      MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa64 
+      else
+	ifeq ($(pattern32),$(findstring $(pattern32), $(HW)))	
+	  MEXE=mexglx
+	  MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa86 
+	endif
+      endif
+
+INSTALL_PATH?=$(INSTALL_MOCHA_LIBDIR)
+OBJ_DIR= ${EPICS_HOST_ARCH}/$(MATLAB_VERSION)
+
+INCLUDEPATH_MOCHA += -I$(MATLAB_ROOT)/extern/include \
+ -I$(CAFE_CPP_BASE)/include -I./ \
+ -I$(EPICS_BASE)/include -I$(EPICS_BASE)/include/os/Linux \
+ -I$(EPICS_BASE)/include/compiler/gcc
+
+INCLUDEPATH_MACHINETTA += $(INCLUDEPATH_MOCHA) -I$(BOOST_BASE) -I$(BOOST_BASE)/boost 
+
+
+# linkage to qt5 required if cafe built with Qt5
+#-lboost_system -lboost_thread-mt
+LIBS += -ldl -lca -lCom -lmx -lmex -lmat -lQt5Core -lQt5Xml
+#LIBS += -lmx -lmex -lmat
+
+$(OBJ_DIR)/mocha.$(MEXE): mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o
+	mex CXXFLAGS='$(CXXFLAGS) -v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH}  -L${QT5_DIR} -Wl,-rpath,${QT5_DIR} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' \
+	 mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) \
+	-outdir $(OBJ_DIR) -output mocha.$(MEXE) \
+	$(INCLUDEPATH_MOCHA)
+	cp example.m $(OBJ_DIR)
+	cp scripts/*.m $(OBJ_DIR)
+	cp scripts/test.xml  $(OBJ_DIR)
+
+
+$(OBJ_DIR)/macchinettaSwitch.o: macchinettaSwitch.cpp macchinettaHelper.h \
+					macchinetta.h containerMochaccino.h
+	mex CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	-c macchinettaSwitch.cpp $(INCLUDEPATH_MACHINETTA) 'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' -outdir $(OBJ_DIR)   
+
+install: $(OBJ_DIR)/mocha.$(MEXE)
+	mkdir -p $(INSTALL_PATH)
+	mex  CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) -outdir $(INSTALL_PATH) -output mocha.$(MEXE) $(INCLUDEPATH_MOCHA) \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB)  $(LIBS)'
+
+	cp example.m $(INSTALL_PATH)
+	cp scripts/*.m $(INSTALL_PATH)
+	cp scripts/test.xml  $(INSTALL_PATH)
+
+install_lib: $(OBJ_DIR)/libmacchinetta.so
+	mkdir -p $(INSTALL_PATH)
+	cp $(OBJ_DIR)/libmacchinetta.so  $(INSTALL_PATH)
+
+clean:
+	rm -f $(OBJ_DIR)/*.o $(OBJ_DIR)/*.so $(OBJ_DIR)/*.$(MEXE)
+
+print-%  : ; @echo $* = $($*)

makefile_rel_1.20-gcc-4.7.4

@@ -0,0 +1,104 @@
+#
+# Jan Chrin
+# Version: July 2019 - Qt5 
+#
+# makefile to build mocha mex file
+# printenv | grep MATLAB to reveal your MATLAB Directory
+#
+#
+# local executables are built in  ./${EPICS_HOST_ARCH}/$(MVER)
+# where the MATLAB version is grepped from $(MATLAB)
+
+MATLAB_ROOT=${MATLAB}
+MATLAB_VERSION=$(notdir $(MATLAB_ROOT))
+
+##### CHANGE AS APPROPRIATE #################
+#Mocha Version to install
+MOCHA_VERSION=mocha-1.20.1-gcc-4.7.4
+#CAFE version to link to
+CAFE_VERSION=cafe-1.20.1-gcc-7.3.0
+
+EPICS_BASE=${EPICS}/base-7.0.7
+#CAFE project base
+CAFE_BASE=/opt/gfa/cafe
+CAFE_MOCHA_BASE=${CAFE_BASE}/mocha
+CAFE_CPP_BASE=$(CAFE_BASE)/cpp/$(CAFE_VERSION)
+BOOST_BASE=${CAFE_BASE}/boost/boost_1_61_0/include
+
+CAFE_OBJS_DIR = $(CAFE_BASE)/cpp/$(CAFE_VERSION)/lib/$(EPICS_HOST_ARCH)/libcafe.a
+
+#if qt5 has libQt5Core.so link
+#QT5_DIR= /opt/psi/Cafe/cafe-matlab/${MATLAB_VERSION}/libexec
+QT5_DIR= ${MATLAB_ROOT}/bin/glnxa64
+
+INSTALL_MOCHA_LIBDIR= $(CAFE_MOCHA_BASE)/$(MOCHA_VERSION)/lib/$(EPICS_HOST_ARCH)/$(MATLAB_VERSION)
+#############################################
+
+
+#First deteremine if we are on a 32/64 bit machine
+#as mex file extensions are named differently
+pattern64=x86_64
+pattern32=i386
+
+PWD=$(shell pwd)
+      #hardware platform   
+      HW=$(shell uname -i)
+      ifeq ($(pattern64),$(findstring $(pattern64), $(HW)))
+        MEXE=mexa64
+	      MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa64 
+      else
+	ifeq ($(pattern32),$(findstring $(pattern32), $(HW)))	
+	  MEXE=mexglx
+	  MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa86 
+	endif
+      endif
+
+INSTALL_PATH?=$(INSTALL_MOCHA_LIBDIR)
+OBJ_DIR= ${EPICS_HOST_ARCH}/$(MATLAB_VERSION)
+
+INCLUDEPATH_MOCHA += -I$(MATLAB_ROOT)/extern/include \
+ -I$(CAFE_CPP_BASE)/include -I./ \
+ -I$(EPICS_BASE)/include -I$(EPICS_BASE)/include/os/Linux \
+ -I$(EPICS_BASE)/include/compiler/gcc
+
+INCLUDEPATH_MACHINETTA += $(INCLUDEPATH_MOCHA) -I$(BOOST_BASE) -I$(BOOST_BASE)/boost 
+
+
+# linkage to qt5 required if cafe built with Qt5
+#-lboost_system -lboost_thread-mt
+LIBS += -ldl -lca -lCom -lmx -lmex -lmat -lQt5Core -lQt5Xml
+#LIBS += -lmx -lmex -lmat
+
+$(OBJ_DIR)/mocha.$(MEXE): mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o
+	mex CXXFLAGS='$(CXXFLAGS) -v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH}  -L${QT5_DIR} -Wl,-rpath,${QT5_DIR} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' \
+	 mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) \
+	-outdir $(OBJ_DIR) -output mocha.$(MEXE) \
+	$(INCLUDEPATH_MOCHA)
+
+
+
+$(OBJ_DIR)/macchinettaSwitch.o: macchinettaSwitch.cpp macchinettaHelper.h \
+					macchinetta.h containerMochaccino.h
+	mex CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	-c macchinettaSwitch.cpp $(INCLUDEPATH_MACHINETTA) 'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' -outdir $(OBJ_DIR)   
+
+install: $(OBJ_DIR)/mocha.$(MEXE)
+	mkdir -p $(INSTALL_PATH)
+	mex  CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) -outdir $(INSTALL_PATH) -output mocha.$(MEXE) $(INCLUDEPATH_MOCHA) \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB)  $(LIBS)'
+
+	cp example.m $(INSTALL_PATH)
+	cp scripts/monitorAction.m $(INSTALL_PATH)
+	cp scripts/pvtable.m $(INSTALL_PATH)
+	cp scripts/test.xml  $(INSTALL_PATH)
+
+install_lib: $(OBJ_DIR)/libmacchinetta.so
+	mkdir -p $(INSTALL_PATH)
+	cp $(OBJ_DIR)/libmacchinetta.so  $(INSTALL_PATH)
+
+clean:
+	rm -f $(OBJ_DIR)/*.o $(OBJ_DIR)/*.so $(OBJ_DIR)/*.$(MEXE)
+
+print-%  : ; @echo $* = $($*)

makefile_rel_1.20-gcc-7.3.0

@@ -0,0 +1,103 @@
+#
+# Jan Chrin
+# Version: July 2019 - Qt5 
+#
+# makefile to build mocha mex file
+# printenv | grep MATLAB to reveal your MATLAB Directory
+#
+#
+# local executables are built in  ./${EPICS_HOST_ARCH}/$(MVER)
+# where the MATLAB version is grepped from $(MATLAB)
+
+MATLAB_ROOT=${MATLAB}
+MATLAB_VERSION=$(notdir $(MATLAB_ROOT))
+
+##### CHANGE AS APPROPRIATE #################
+#Mocha Version to install
+MOCHA_VERSION=mocha-1.20.1-gcc-7.3.0
+#CAFE version to link to
+CAFE_VERSION=cafe-1.20.1-gcc-7.3.0
+
+EPICS_BASE=${EPICS}/base-7.0.7
+#CAFE project base
+CAFE_BASE=/opt/gfa/cafe
+CAFE_MOCHA_BASE=${CAFE_BASE}/mocha
+CAFE_CPP_BASE=$(CAFE_BASE)/cpp/$(CAFE_VERSION)
+BOOST_BASE=${CAFE_BASE}/boost/boost_1_61_0/include
+
+CAFE_OBJS_DIR = $(CAFE_BASE)/cpp/$(CAFE_VERSION)/lib/$(EPICS_HOST_ARCH)/libcafe.a
+
+#if qt5 has libQt5Core.so link
+#QT5_DIR= /opt/psi/Cafe/cafe-matlab/${MATLAB_VERSION}/libexec
+QT5_DIR= ${MATLAB_ROOT}/bin/glnxa64
+
+INSTALL_MOCHA_LIBDIR= $(CAFE_MOCHA_BASE)/$(MOCHA_VERSION)/lib/$(EPICS_HOST_ARCH)/$(MATLAB_VERSION)
+#############################################
+
+
+#First deteremine if we are on a 32/64 bit machine
+#as mex file extensions are named differently
+pattern64=x86_64
+pattern32=i386
+
+PWD=$(shell pwd)
+      #hardware platform   
+      HW=$(shell uname -i)
+      ifeq ($(pattern64),$(findstring $(pattern64), $(HW)))
+        MEXE=mexa64
+	      MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa64 
+      else
+	ifeq ($(pattern32),$(findstring $(pattern32), $(HW)))	
+	  MEXE=mexglx
+	  MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa86 
+	endif
+      endif
+
+INSTALL_PATH?=$(INSTALL_MOCHA_LIBDIR)
+OBJ_DIR= ${EPICS_HOST_ARCH}/$(MATLAB_VERSION)
+
+INCLUDEPATH_MOCHA += -I$(MATLAB_ROOT)/extern/include \
+ -I$(CAFE_CPP_BASE)/include -I./ \
+ -I$(EPICS_BASE)/include -I$(EPICS_BASE)/include/os/Linux \
+ -I$(EPICS_BASE)/include/compiler/gcc
+
+INCLUDEPATH_MACHINETTA += $(INCLUDEPATH_MOCHA) -I$(BOOST_BASE) -I$(BOOST_BASE)/boost 
+
+
+# linkage to qt5 required if cafe built with Qt5
+#-lboost_system -lboost_thread-mt
+LIBS += -ldl -lca -lCom -lmx -lmex -lmat -lQt5Core -lQt5Xml
+#LIBS += -lmx -lmex -lmat
+
+$(OBJ_DIR)/mocha.$(MEXE): mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o
+	mex CXXFLAGS='$(CXXFLAGS) -v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH}  -L${QT5_DIR} -Wl,-rpath,${QT5_DIR} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' \
+	 mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) \
+	-outdir $(OBJ_DIR) -output mocha.$(MEXE) \
+	$(INCLUDEPATH_MOCHA)
+
+
+
+$(OBJ_DIR)/macchinettaSwitch.o: macchinettaSwitch.cpp macchinettaHelper.h \
+					macchinetta.h containerMochaccino.h
+	mex CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	-c macchinettaSwitch.cpp $(INCLUDEPATH_MACHINETTA) 'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' -outdir $(OBJ_DIR)   
+
+install: $(OBJ_DIR)/mocha.$(MEXE)
+	mkdir -p $(INSTALL_PATH)
+	mex  CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) -outdir $(INSTALL_PATH) -output mocha.$(MEXE) $(INCLUDEPATH_MOCHA) \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB)  $(LIBS)'
+
+	cp example.m $(INSTALL_PATH)
+	cp scripts/*.m $(INSTALL_PATH)
+	cp scripts/test.xml  $(INSTALL_PATH)
+
+install_lib: $(OBJ_DIR)/libmacchinetta.so
+	mkdir -p $(INSTALL_PATH)
+	cp $(OBJ_DIR)/libmacchinetta.so  $(INSTALL_PATH)
+
+clean:
+	rm -f $(OBJ_DIR)/*.o $(OBJ_DIR)/*.so $(OBJ_DIR)/*.$(MEXE)
+
+print-%  : ; @echo $* = $($*)

makefile_rel_1.21-gcc-6.3.0

@@ -0,0 +1,105 @@
+#
+# Jan Chrin
+# Version: July 2019 - Qt5 
+#
+# makefile to build mocha mex file
+# printenv | grep MATLAB to reveal your MATLAB Directory
+#
+#
+# local executables are built in  ./${EPICS_HOST_ARCH}/$(MVER)
+# where the MATLAB version is grepped from $(MATLAB)
+
+MATLAB_ROOT=${MATLAB}
+MATLAB_VERSION=$(notdir $(MATLAB_ROOT))
+
+##### CHANGE AS APPROPRIATE #################
+#Mocha Version to install
+MOCHA_VERSION=mocha-1.21.0-gcc-6.3.0
+#CAFE version to link to
+CAFE_VERSION=cafe-1.21.0-gcc-6.3.0
+
+EPICS_BASE=${EPICS}/base-7.0.8
+#CAFE project base
+CAFE_BASE=/opt/gfa/cafe
+CAFE_MOCHA_BASE=${CAFE_BASE}/mocha
+CAFE_CPP_BASE=$(CAFE_BASE)/cpp/$(CAFE_VERSION)
+BOOST_BASE=${CAFE_BASE}/boost/boost_1_61_0/include
+
+CAFE_OBJS_DIR = $(CAFE_BASE)/cpp/$(CAFE_VERSION)/lib/$(EPICS_HOST_ARCH)/libcafe.a
+
+#if qt5 has libQt5Core.so link
+#QT5_DIR= /opt/psi/Cafe/cafe-matlab/${MATLAB_VERSION}/libexec
+QT5_DIR= ${MATLAB_ROOT}/bin/glnxa64
+
+INSTALL_MOCHA_LIBDIR= $(CAFE_MOCHA_BASE)/$(MOCHA_VERSION)/lib/$(EPICS_HOST_ARCH)/$(MATLAB_VERSION)
+#############################################
+
+
+#First deteremine if we are on a 32/64 bit machine
+#as mex file extensions are named differently
+pattern64=x86_64
+pattern32=i386
+
+PWD=$(shell pwd)
+      #hardware platform   
+      HW=$(shell uname -i)
+      ifeq ($(pattern64),$(findstring $(pattern64), $(HW)))
+        MEXE=mexa64
+	      MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa64 
+      else
+	ifeq ($(pattern32),$(findstring $(pattern32), $(HW)))	
+	  MEXE=mexglx
+	  MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa86 
+	endif
+      endif
+
+INSTALL_PATH?=$(INSTALL_MOCHA_LIBDIR)
+OBJ_DIR= ${EPICS_HOST_ARCH}/$(MATLAB_VERSION)
+
+INCLUDEPATH_MOCHA += -I$(MATLAB_ROOT)/extern/include \
+ -I$(CAFE_CPP_BASE)/include -I./ \
+ -I$(EPICS_BASE)/include -I$(EPICS_BASE)/include/os/Linux \
+ -I$(EPICS_BASE)/include/compiler/gcc
+
+INCLUDEPATH_MACHINETTA += $(INCLUDEPATH_MOCHA) -I$(BOOST_BASE) -I$(BOOST_BASE)/boost 
+
+
+# linkage to qt5 required if cafe built with Qt5
+#-lboost_system -lboost_thread-mt
+LIBS += -ldl -lca -lCom -lmx -lmex -lmat -lQt5Core -lQt5Xml
+#LIBS += -lmx -lmex -lmat
+
+$(OBJ_DIR)/mocha.$(MEXE): mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o
+	mex CXXFLAGS='$(CXXFLAGS) -v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH}  -L${QT5_DIR} -Wl,-rpath,${QT5_DIR} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' \
+	 mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) \
+	-outdir $(OBJ_DIR) -output mocha.$(MEXE) \
+	$(INCLUDEPATH_MOCHA)
+	cp example.m $(OBJ_DIR)
+	cp scripts/*.m $(OBJ_DIR)
+	cp scripts/test.xml  $(OBJ_DIR)
+
+
+$(OBJ_DIR)/macchinettaSwitch.o: macchinettaSwitch.cpp macchinettaHelper.h \
+					macchinetta.h containerMochaccino.h
+	mex CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	-c macchinettaSwitch.cpp $(INCLUDEPATH_MACHINETTA) 'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' -outdir $(OBJ_DIR)   
+
+install: $(OBJ_DIR)/mocha.$(MEXE)
+	mkdir -p $(INSTALL_PATH)
+	mex  CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) -outdir $(INSTALL_PATH) -output mocha.$(MEXE) $(INCLUDEPATH_MOCHA) \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB)  $(LIBS)'
+
+	cp example.m $(INSTALL_PATH)
+	cp scripts/*.m $(INSTALL_PATH)
+	cp scripts/test.xml  $(INSTALL_PATH)
+
+install_lib: $(OBJ_DIR)/libmacchinetta.so
+	mkdir -p $(INSTALL_PATH)
+	cp $(OBJ_DIR)/libmacchinetta.so  $(INSTALL_PATH)
+
+clean:
+	rm -f $(OBJ_DIR)/*.o $(OBJ_DIR)/*.so $(OBJ_DIR)/*.$(MEXE)
+
+print-%  : ; @echo $* = $($*)

makefile_rel_1.21-gcc-6.3.0.sh

@@ -0,0 +1,5 @@
+module unload gcc
+module load gcc/6.3.0
+echo "$1"
+action=$1
+make -f makefile_rel_1.21-gcc-6.3.0 -s $action

makefile_rel_1.21-gcc-6.4.0

@@ -0,0 +1,105 @@
+#
+# Jan Chrin
+# Version: July 2019 - Qt5 
+#
+# makefile to build mocha mex file
+# printenv | grep MATLAB to reveal your MATLAB Directory
+#
+#
+# local executables are built in  ./${EPICS_HOST_ARCH}/$(MVER)
+# where the MATLAB version is grepped from $(MATLAB)
+
+MATLAB_ROOT=${MATLAB}
+MATLAB_VERSION=$(notdir $(MATLAB_ROOT))
+
+##### CHANGE AS APPROPRIATE #################
+#Mocha Version to install
+MOCHA_VERSION=mocha-1.21.0-gcc-6.3.0
+#CAFE version to link to
+CAFE_VERSION=cafe-1.21.0-gcc-6.3.0
+
+EPICS_BASE=${EPICS}/base-7.0.8
+#CAFE project base
+CAFE_BASE=/opt/gfa/cafe
+CAFE_MOCHA_BASE=${CAFE_BASE}/mocha
+CAFE_CPP_BASE=$(CAFE_BASE)/cpp/$(CAFE_VERSION)
+BOOST_BASE=${CAFE_BASE}/boost/boost_1_61_0/include
+
+CAFE_OBJS_DIR = $(CAFE_BASE)/cpp/$(CAFE_VERSION)/lib/$(EPICS_HOST_ARCH)/libcafe.a
+
+#if qt5 has libQt5Core.so link
+#QT5_DIR= /opt/psi/Cafe/cafe-matlab/${MATLAB_VERSION}/libexec
+QT5_DIR= ${MATLAB_ROOT}/bin/glnxa64
+
+INSTALL_MOCHA_LIBDIR= $(CAFE_MOCHA_BASE)/$(MOCHA_VERSION)/lib/$(EPICS_HOST_ARCH)/$(MATLAB_VERSION)
+#############################################
+
+
+#First deteremine if we are on a 32/64 bit machine
+#as mex file extensions are named differently
+pattern64=x86_64
+pattern32=i386
+
+PWD=$(shell pwd)
+      #hardware platform   
+      HW=$(shell uname -i)
+      ifeq ($(pattern64),$(findstring $(pattern64), $(HW)))
+        MEXE=mexa64
+	      MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa64 
+      else
+	ifeq ($(pattern32),$(findstring $(pattern32), $(HW)))	
+	  MEXE=mexglx
+	  MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa86 
+	endif
+      endif
+
+INSTALL_PATH?=$(INSTALL_MOCHA_LIBDIR)
+OBJ_DIR= ${EPICS_HOST_ARCH}/$(MATLAB_VERSION)
+
+INCLUDEPATH_MOCHA += -I$(MATLAB_ROOT)/extern/include \
+ -I$(CAFE_CPP_BASE)/include -I./ \
+ -I$(EPICS_BASE)/include -I$(EPICS_BASE)/include/os/Linux \
+ -I$(EPICS_BASE)/include/compiler/gcc
+
+INCLUDEPATH_MACHINETTA += $(INCLUDEPATH_MOCHA) -I$(BOOST_BASE) -I$(BOOST_BASE)/boost 
+
+
+# linkage to qt5 required if cafe built with Qt5
+#-lboost_system -lboost_thread-mt
+LIBS += -ldl -lca -lCom -lmx -lmex -lmat -lQt5Core -lQt5Xml
+#LIBS += -lmx -lmex -lmat
+
+$(OBJ_DIR)/mocha.$(MEXE): mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o
+	mex CXXFLAGS='$(CXXFLAGS) -v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH}  -L${QT5_DIR} -Wl,-rpath,${QT5_DIR} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' \
+	 mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) \
+	-outdir $(OBJ_DIR) -output mocha.$(MEXE) \
+	$(INCLUDEPATH_MOCHA)
+	cp example.m $(OBJ_DIR)
+	cp scripts/*.m $(OBJ_DIR)
+	cp scripts/test.xml  $(OBJ_DIR)
+
+
+$(OBJ_DIR)/macchinettaSwitch.o: macchinettaSwitch.cpp macchinettaHelper.h \
+					macchinetta.h containerMochaccino.h
+	mex CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	-c macchinettaSwitch.cpp $(INCLUDEPATH_MACHINETTA) 'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' -outdir $(OBJ_DIR)   
+
+install: $(OBJ_DIR)/mocha.$(MEXE)
+	mkdir -p $(INSTALL_PATH)
+	mex  CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) -outdir $(INSTALL_PATH) -output mocha.$(MEXE) $(INCLUDEPATH_MOCHA) \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB)  $(LIBS)'
+
+	cp example.m $(INSTALL_PATH)
+	cp scripts/*.m $(INSTALL_PATH)
+	cp scripts/test.xml  $(INSTALL_PATH)
+
+install_lib: $(OBJ_DIR)/libmacchinetta.so
+	mkdir -p $(INSTALL_PATH)
+	cp $(OBJ_DIR)/libmacchinetta.so  $(INSTALL_PATH)
+
+clean:
+	rm -f $(OBJ_DIR)/*.o $(OBJ_DIR)/*.so $(OBJ_DIR)/*.$(MEXE)
+
+print-%  : ; @echo $* = $($*)

makefile_rel_1.22-gcc-10.4.0

@@ -0,0 +1,105 @@
+#
+# Jan Chrin
+# Version: July 2019 - Qt5 
+#
+# makefile to build mocha mex file
+# printenv | grep MATLAB to reveal your MATLAB Directory
+#
+#
+# local executables are built in  ./${EPICS_HOST_ARCH}/$(MVER)
+# where the MATLAB version is grepped from $(MATLAB)
+
+MATLAB_ROOT=${MATLAB}
+MATLAB_VERSION=$(notdir $(MATLAB_ROOT))
+
+##### CHANGE AS APPROPRIATE #################
+#Mocha Version to install
+MOCHA_VERSION=mocha-1.22.0-gcc-10.4.0
+#CAFE version to link to
+CAFE_VERSION=cafe-1.22.0-gcc-10.4.0
+
+EPICS_BASE=${EPICS}/base-7.0.9
+#CAFE project base
+CAFE_BASE=/opt/gfa/cafe
+CAFE_MOCHA_BASE=${CAFE_BASE}/mocha
+CAFE_CPP_BASE=$(CAFE_BASE)/cpp/$(CAFE_VERSION)
+BOOST_BASE=${CAFE_BASE}/boost/boost_1_61_0/include
+
+CAFE_OBJS_DIR = $(CAFE_BASE)/cpp/$(CAFE_VERSION)/lib/$(EPICS_HOST_ARCH)/libcafe.a
+
+#if qt5 has libQt5Core.so link
+#QT5_DIR= /opt/psi/Cafe/cafe-matlab/${MATLAB_VERSION}/libexec
+QT5_DIR= ${MATLAB_ROOT}/bin/glnxa64
+
+INSTALL_MOCHA_LIBDIR= $(CAFE_MOCHA_BASE)/$(MOCHA_VERSION)/lib/$(EPICS_HOST_ARCH)/$(MATLAB_VERSION)
+#############################################
+
+
+#First deteremine if we are on a 32/64 bit machine
+#as mex file extensions are named differently
+pattern64=x86_64
+pattern32=i386
+
+PWD=$(shell pwd)
+      #hardware platform   
+      HW=$(shell uname -i)
+      ifeq ($(pattern64),$(findstring $(pattern64), $(HW)))
+        MEXE=mexa64
+	      MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa64 
+      else
+	ifeq ($(pattern32),$(findstring $(pattern32), $(HW)))	
+	  MEXE=mexglx
+	  MATLAB_LIB = $(MATLAB_ROOT)/bin/glnxa86 
+	endif
+      endif
+
+INSTALL_PATH?=$(INSTALL_MOCHA_LIBDIR)
+OBJ_DIR= ${EPICS_HOST_ARCH}/$(MATLAB_VERSION)
+
+INCLUDEPATH_MOCHA += -I$(MATLAB_ROOT)/extern/include \
+ -I$(CAFE_CPP_BASE)/include -I./ \
+ -I$(EPICS_BASE)/include -I$(EPICS_BASE)/include/os/Linux \
+ -I$(EPICS_BASE)/include/compiler/gcc
+
+INCLUDEPATH_MACHINETTA += $(INCLUDEPATH_MOCHA) -I$(BOOST_BASE) -I$(BOOST_BASE)/boost 
+
+
+# linkage to qt5 required if cafe built with Qt5
+#-lboost_system -lboost_thread-mt
+LIBS += -ldl -lca -lCom -lmx -lmex -lmat -lQt5Core -lQt5Xml
+#LIBS += -lmx -lmex -lmat
+
+$(OBJ_DIR)/mocha.$(MEXE): mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o
+	mex CXXFLAGS='$(CXXFLAGS) -v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH}  -L${QT5_DIR} -Wl,-rpath,${QT5_DIR} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' \
+	 mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) \
+	-outdir $(OBJ_DIR) -output mocha.$(MEXE) \
+	$(INCLUDEPATH_MOCHA)
+	cp example.m $(OBJ_DIR)
+	cp scripts/*.m $(OBJ_DIR)
+	cp scripts/test.xml  $(OBJ_DIR)
+
+
+$(OBJ_DIR)/macchinettaSwitch.o: macchinettaSwitch.cpp macchinettaHelper.h \
+					macchinetta.h containerMochaccino.h
+	mex CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	-c macchinettaSwitch.cpp $(INCLUDEPATH_MACHINETTA) 'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB) $(LIBS)' -outdir $(OBJ_DIR)   
+
+install: $(OBJ_DIR)/mocha.$(MEXE)
+	mkdir -p $(INSTALL_PATH)
+	mex  CXXFLAGS='-v -largeArrayDims -ansi -fexceptions -fPIC -fno-omit-frame-pointer -pthread -std=c++1z' \
+	mocha.cpp $(OBJ_DIR)/macchinettaSwitch.o $(CAFE_OBJS_DIR) -outdir $(INSTALL_PATH) -output mocha.$(MEXE) $(INCLUDEPATH_MOCHA) \
+	'LDFLAGS=-L$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -Wl,-rpath,$(EPICS_BASE)/lib/${EPICS_HOST_ARCH} -L$(MATLAB_LIB) -Wl,-rpath,$(MATLAB_LIB)  $(LIBS)'
+
+	cp example.m $(INSTALL_PATH)
+	cp scripts/*.m $(INSTALL_PATH)
+	cp scripts/test.xml  $(INSTALL_PATH)
+
+install_lib: $(OBJ_DIR)/libmacchinetta.so
+	mkdir -p $(INSTALL_PATH)
+	cp $(OBJ_DIR)/libmacchinetta.so  $(INSTALL_PATH)
+
+clean:
+	rm -f $(OBJ_DIR)/*.o $(OBJ_DIR)/*.so $(OBJ_DIR)/*.$(MEXE)
+
+print-%  : ; @echo $* = $($*)

makefile_rel_1.22-gcc-10.4.0.sh

@@ -0,0 +1,5 @@
+module unload gcc
+module load gcc/10.4.0
+echo "$1"
+action=$1
+make -f makefile_rel_1.22-gcc-10.4.0 -s $action

setup_each_matlab.sh

@@ -17,14 +17,15 @@ done
 ca office network
 module use Cafe
 vrhel=${RHREL}
-vcafe=1.21.0
-vepics=7.0.8
+vcafe=1.22.0
+vcafem=1.22
+vepics=7.0.9
 
-for vmatlab in 2024a 2023b 2023a 2022b 2022a 2021b 2021a 2020b 2020a 2019b 2019a 2018b 2018a
+for vmatlab in 2025a 2024b 2024a 2023b 2023a 2022b 2022a 2021b 2021a 2020b 2020a 2019b 2019a 2018b 2018a
 do
 	if [[ "$vmatlab" =~ ^(2018a|2018b|2019a|2019b|2020a|2020b|2021a|2021b)$ ]]; then
 		vgcc=7.3.0
-	elif [[ "$vmatlab" =~ ^(2022a|2022b|2023a|2023b|2024a)$ ]]; then
+	elif [[ "$vmatlab" =~ ^(2022a|2022b|2023a|2023b|2024a|2024b|2025a)$ ]]; then
 		vgcc=10.4.0
 	fi
 	printf "\n\n\n=======================================================================\n"
@@ -46,15 +47,15 @@ do
 	
 	if [ $step -eq 0 ]; then
 		echo "0 - cleanup (make clean)"
-		make -f makefile_rel_1.21-gcc-$vgcc clean
+		make -f makefile_rel_$vcafem-gcc-$vgcc clean
 
 	elif [ $step -eq 1 ]; then
 		echo "1 - local build (make)"
-		make -f makefile_rel_1.21-gcc-$vgcc
+		make -f makefile_rel_$vcafem-gcc-$vgcc
 
 	elif [ $step -eq 2 ]; then
 		echo "2 - test local build (matlab -batch ...)"
-		if [[ "$vmatlab" =~ ^(2019a|2019b|2020a|2020b|2021a|2021b|2022a|2022b|2023a|2023b|2024a)$ ]]; then
+		if [[ "$vmatlab" =~ ^(2019a|2019b|2020a|2020b|2021a|2021b|2022a|2022b|2023a|2023b|2024a|2024b|2025a)$ ]]; then
 			matlab -batch "cd RHEL8-x86_64/$vmatlab;disp(mocha('version'));example"
 		else
 			matlab -nodisplay -nosplash -nodesktop -r "cd RHEL8-x86_64/$vmatlab;disp(mocha('version'));example;exit"
@@ -62,7 +63,7 @@ do
 
 	elif [ $step -eq 3 ]; then
 		echo "3 - install build to /opt/gfa/cafe/mocha/ (make install)"
-		make -f makefile_rel_1.21-gcc-$vgcc install
+		make -f makefile_rel_$vcafem-gcc-$vgcc install
 
 	elif [ $step -eq 4 ]; then
 		echo "4 - deploy build to pmodules"
@@ -99,7 +100,7 @@ do
 		module help cafe-matlab/$vmatlab
 		module load cafe-matlab/$vmatlab
 		module list
-		if [[ "$vmatlab" =~ ^(2019a|2019b|2020a|2020b|2021a|2021b|2022a|2022b|2023a|2023b|2024a)$ ]]; then
+		if [[ "$vmatlab" =~ ^(2019a|2019b|2020a|2020b|2021a|2021b|2022a|2022b|2023a|2023b|2024a|2024b|2025a)$ ]]; then
 			matlab -batch "cd RHEL8-x86_64/$vmatlab;disp(mocha('version'));example"
 		else
 			matlab -nodisplay -nosplash -nodesktop -r "cd RHEL8-x86_64/$vmatlab;disp(mocha('version'));example;exit"