7.4 Buffering Data in SIMULINK

A common question regarding SIMULINK is how to buffer previous values of the input to use at later times. This can be useful for various reasons, one example being the Spectrum Analyzer block in the Extras library. This block buffers some data and then uses fft analysis to provide a frequency plot. So, how can this be done?

A buffering scheme can be created via an S-function. One common S-function trick is to use discrete states to store information. The following two examples are commented S-functions, which realize two variations of a buffering scheme. The first example, sbuffer.m, creates a sliding window over the last three input values and outputs the sum of these values. The second example, sbuffer2.m, stores the last three values in a buffer, and holds the output value constant as the buffer is filling. For example, if the current sum of the buffered values is 5, the output will be held to 5 for the next three integration steps. At that time, the buffer will contain three new values. The sum of these new values will be the new output.

------------------------ sbuffer.m ------------------------

function [sys,x0] = sbuffer(t,x,u,flag)
%  This S-function stores the past three values of the input in a
%  buffer and outputs the sum of those values.  It demonstrates how
%  discrete states can be used as memory elements that store
%  specified4 values.
if flag == 0,            % 0 ==> return sizes
  sys = [0 3 1 1 0 0];   % 3 discrete states to hold the "old" values
  x0 = zeros(1,3);
elseif abs(flag) == 2,   % 2 ==> return next discrete state
  sys = zeros(3,1);      % initialize sys
  sys(3) = x(2);         % here we are setting the values for x(3),
  sys(2) = x(1);         % x(2), and x(1) respectively, for the
  sys(1) = u;            % NEXT integration step
elseif abs(flag) == 3,   % 3 ==> return outputs
  sys = sum( x );        % output the sum of the past three values
else                     % all other flags return an empty set, []
  sys = [];
end

---------------------- sbuffer2.m ----------------------

function [sys,x0] = sbuffer2(t,x,u,flag)
%  This S-function stores the input at the last three integration
%  steps in a buffer and also stores the sum of these values.  The
%  output is held constant while the buffer is being filled.  So, if
%  the current sum of the buffered values is 5, the output will be
%  held to 5 for the next three integration steps.  At that time, 
%  the buffer will contain three new values.  The sum of these new
%  values will be the new output.
%
%   A convenient method of testing this function is to set the min
%  and max step size to 1 and the stop time to 10.  Use a clock as
%  input and examine the results in the workspace.
if flag == 0,            % 0 ==> return sizes
  %  5 discrete states:
  %    1st three to store the previous values
  %    4th to count the number of integration steps
  %    5th to hold the current sum
  sys = [0 5 1 1 0 0];
  x0 = zeros(1,5);
elseif abs(flag) == 2,  % 2 ==> return next discrete state
  sys = zeros(5,1);    % initialize sys
  sys(3) = x(2);
  sys(2) = x(1);
  sys(1) = u;
  % count the number of steps and when reach 3, reset to zero
  count = x(4) + 1;  %increment counter
  if rem(count,3) == 0,
     sys(4) = 0;                         % reset counter at 3rd step
     sys(5) = sum(x(1:3));   % store the current sum
  else
     sys(4) = count;     % store the current count
     sys(5) = x(5);      % don't change the 5th state
  end
elseif abs(flag) == 3,   % 3 ==> return outputs
  if x(4) ~= (3-1),
    sys = x(5);          % if not the 3rd step, output the old sum
  else
    sys = sum(x(1:3));  % output the sum of the past
                                    % three values
  end
else                      % all other flags return an empty set, []
  sys = [];
end