In simulink, how can I make a parameter of a simulink block continuously updated during the simulation time by MATLAB function block?

Hi, I'm building a simple electrical network that consists of sinusoidal voltage source + inductor-capacitor-resistor series network.

The sinusoidal voltage source has a parameterized frequency, 'freq', which is defined in my base workspace, and I want to update the value of the parameter 'freq' that is calculated in my MATLAB function block whenever some conditions are met.

So, I tried using the assignin() function in my MATLAB function block, as shown in the below code :

function [average_RF_phase_difference_time, array_buffer, phase_update_time_out, freq_tracking] = fcn(new_period_start, new_period_start_prev, RF_phase_difference_time, RF_phase_difference_time_array, time_simulation, phase_update_time, f_max, freq)
    
    array_buffer = RF_phase_difference_time_array;
    average_RF_phase_difference_time = mean(array_buffer);

    phase_update_time_out = phase_update_time;

    if (new_period_start_prev == false) && (new_period_start == true) && (phase_update_time_out + 1/(2*f_max) <= time_simulation)
        
        phase_update_time_out = time_simulation;

        RF_phase_difference_time_array_temp = circshift(RF_phase_difference_time_array, -1);
        RF_phase_difference_time_array_temp(end) = RF_phase_difference_time;

        array_buffer = RF_phase_difference_time_array_temp;
        average_RF_phase_difference_time = mean(array_buffer);

        new_freq = freq;
        del_freq_clk = 1/(1/new_freq - 5e-9) - new_freq;
        m = average_RF_phase_difference_time / (5e-9) / 4;
    
        assignin('base','freq', new_freq - del_freq_clk * m );
        freq_tracking = freq;
    
        return
    end 
    
    freq_tracking = freq;

end

The simulation ran without any error, but the result was different from my expectaion.

The frequency of the sinusoidal voltage source, 'freq', didn't get updated not during the simulation, but it changed after finishing the simulation as I checked from the base workspace. What I expected was the actual frequency of the sinusoidal voltage source is changed during the simulation run according to the calculation from the MATLAB function block.

So as the second step, I tried another way like below :

I tried to use the Data Store Memory block, but the variable defined in the Data Store Memory block cannot be recognized by the sinusoidal voltage source.

How can I realize as I intended? : making the actual frequency of the sinusoidal voltage source is changed "during the simulation run" according to the calculation from the MATLAB function block.

I really appreciate your helpful experiences in advance.

Answer 1

[Paul]

Hi Yeonghoon,

One option to try would be the Parameter Writer. Don't know if the particular block and block parameter in question are eligible for this approach.

If not, then I think you can try an Assertion Block that is fed by some other block that detects when the parameter in question changes. When the assertion is true, use the callback function with set_param commands to pause the simulation, update the diagram (having already assigned the new value of the variable in the base workspace in fcn), then restart the simulation.

TBH, I haven't ever tried either of these approaches, but I think I've seen an example of the latter in the doc, and there is blog post on the former that may be of interest.

Either approach will probably work better if your Matlab Function fcn is set to run with a discrete sample time, though a continuous sample time might be o.k., at least in principle.

Edit 23 Dec 2024: The callback code in the Assertion block does not need to pause, update, and restart. All that's needed is a block diagram update. At least that worked for me for a simple case, though using an assertion this way feels a bit kludgy.

[Yeonghoon]

Hi, Paul.

Thank you for your comment. I tried a couple of things based on your comments and the results were :

Using Parameter Writer)

The Parameter Write block didn't provide the access to 'voltage source' block. It allowed access to other blocks like 'Edge Detector', 'Sample and Hold', 'Constant', etc.

Using Assertion Block & set_param function)

When I tried to change 'ac voltage frequency' of my 'voltage source' block with set_param function, the simulation error occured saying

"Cannot change parameter 'AC voltage frequency (ac_frequency)' of 'freqtracktest_4/Voltage Source' while simulation is running".

function [phase_difference_buffer_update, frequency_update, voltage_out, frequency_update_time_update] = fcn(volt_rising, volt_rising_prev, time_current_falling, time_voltage_falling, phase_difference_buffer, frequency, time, frequency_update_time, time_prev)

coder.extrinsic('set_param');

phase_difference_buffer_update = phase_difference_buffer;
phase_difference_average = mean(phase_difference_buffer);
frequency_update = frequency;

frequency_update_time_update = frequency_update_time;
voltage_out = 300*sin(2*pi*frequency_update*(time-frequency_update_time_update));

if ( (volt_rising == true) && (volt_rising_prev == false) && (time > frequency_update_time + 1/2 * 1/frequency) )

    %frequency_update_time_update = time;
    
    phase_difference = time_current_falling - time_voltage_falling;
    phase_difference_buffer_update = circshift(phase_difference_buffer, -1);
    phase_difference_buffer_update(end) = phase_difference;
    
    phase_difference_average = mean(phase_difference_buffer_update);
    
    %frequency_update = frequency_update - 0.01e6;
    %
    %set_param('freqtracktest_4/Voltage Source', 'ac_frequency', sprintf('%f', frequency_update));

end

if ( (frequency_update_time_update + 0.00001) <= time && 300*sin(2*pi*frequency_update*(time-frequency_update_time_update)) >= 0 && 300*sin(2*pi*frequency_update*(time_prev-frequency_update_time_update)) <0 )
    
    %frequency_update = frequency_update - 0.5e6;
    frequency_update = frequency_update - ( 1/(1/frequency_update-5e-9) - frequency_update ) * phase_difference_average / (5e-9) / 10;
    frequency_update_time_update = time;
    set_param('freqtracktest_4/Voltage Source', 'ac_frequency', sprintf('%f', frequency_update));
end


end

What I did)

So, I tried to use "Controlled Voltage Source" block instead of "Voltage Source" block. The controlled input of the "Controlled Voltage Source" was fed by my "MATLAB function" block, that generates sinusoidal voltage whose frequency is changing according to my codes. Then it works now.

[Paul]

Glad to hear you found a solution and it sounds like a good approach based on the names of the blocks.

I did not suggest using set_param from inside fcn and am not surprised that did not work.

Did you actually try using your original fcn with the assignin command in combination with the Assertion block and its callback code, which is what I did suggest? No need to do that now if you haven't already; just curious if you did try it and it did not work.

[Yeonghoon]

Hi Paul,

Thank you for your comment.

I tried using Assertion block, while the variable 'freq' is a base workspace variable and is used as a parameter('AC voltage frequency') of my 'Voltage Source' block.

I made my 'MATLAB function' block to generate '0' assertion signal to the Aeertion block, when 'freq' needs to be updated.

When I run simulation, I found there were two weird things occured.

1) I expected simulation resumes "automatically" after the assertion event according to the 'set_param(bdroot,'SimulationCommand','continue');' command in my assertion block.

However, I need to resume the simulation "manually" by clocking 'Continue' button at the top of the simulink screen every time.

2) I could see the base workspace variable 'freq' is actually changing by -0.5e6 Hz at every assertion event, from the base workspace window.

However, when I check the voltage waveform of my 'Voltage Source' block, the actual frequency, which is set to freq, does not change during the simulation but it keeps its initial value.

Changing to "assignin('base', 'freq', 'out.frequency_update(end)')" also showed same result.

So, now I'm using the other method that utilizes "controlled voltage source" where its controlled input is generated from my MATLAB function.

[Paul]

The callback code needs a

set_param(bdroot,'SimulationCommand','update')

after the update to freq. The 'pause' and 'continue' might not be needed based on a simple case I tried.

It sounds like you've found a better solution. Approaches the rely on updating models in the middle of a run should be a last resort, IMO.

[Yeonghoon]

Hi Pual,

When I use 'update' instead of 'pause' and 'continue', now my simulink starts to update automatically..! I don't need to manually continue the simulation whenever it pauses.

However the parameter value for 'AC frequency', which is set to equal to base workspace variable 'freq', of my 'voltage source' block still doesn't update actually. I had the following warning from Diagnostic Viewer :

Failed to change the value of parameter 'ac_frequency' of block 'freqtracktest_4/Voltage_Source' during simulation as it is non-tunable. This might be because the value of 'ac_frequency' references a tunable variable whose value has changed. Restart the simulation or turn off fast restart to use the new value.

It seems the parameter 'ac_frequency' that I'm going to continuously update is not tunable. Maybe there are some parameters which are not allowed to be changed during simulation.

Thank you so much for your comments. It helped me a lot.

[Paul]

It appears that the waring in the Diagnostic Viewer arises because the "Configurability" parameter under "AC Voltage Frequency" is set to Compile-Time. The warning goes away if it's set to "Run-Time."

However, that doesn't really help because the masked parameter "ac frequency" has its Tunable attribute set to 'off', (right click on the Voltage Source block, then click Mask -> View Mask). If the Tunable attribute is 'off', then Simulink ignores changes to the mask parameter (freq_2 in the model in the question) on a diagram update while the simulation is running (even if paused).

I should've mentioned the tunability constraint in the original answer.

Just wanted to clarify what's happening.

The Controlled Voltage Source block is the far-superior solution.