code: def make_fixed_length_events(
      raw,
      id=1,
      start=0,
      stop=None,
      duration=1.0,
      first_samp=True,
      overlap=0.0,
  ):
      """Make a set of :term:`events` separated by a fixed duration.
  
      Parameters
      ----------
      raw : instance of Raw
          A raw object to use the data from.
      id : int
          The id to use (default 1).
      start : float
          Time of first event (in seconds).
      stop : float | None
          Maximum time of last event (in seconds). If None, events extend to the
          end of the recording.
      duration : float
          The duration to separate events by (in seconds).
      first_samp : bool
          If True (default), times will have :term:`first_samp` added to them, as
          in :func:`mne.find_events`. This behavior is not desirable if the
          returned events will be combined with event times that already
          have :term:`first_samp` added to them, e.g. event times that come
          from :func:`mne.find_events`.
      overlap : float
          The overlap between events (in seconds).
          Must be ``0 <= overlap < duration``.
  
          .. versionadded:: 0.18
  
      Returns
      -------
      %(events)s
      """
      from .io import BaseRaw
  
      _validate_type(raw, BaseRaw, "raw")
      _validate_type(id, "int", "id")
      _validate_type(duration, "numeric", "duration")
      _validate_type(overlap, "numeric", "overlap")
      duration, overlap = float(duration), float(overlap)
      if not 0 <= overlap < duration:
          raise ValueError(
              f"overlap must be >=0 but < duration ({duration}), got {overlap}"
          )
  
      start = raw.time_as_index(start, use_rounding=True)[0]
      if stop is not None:
          stop = raw.time_as_index(stop, use_rounding=True)[0]
      else:
          stop = raw.last_samp + 1
      if first_samp:
          start = start + raw.first_samp
          stop = min([stop + raw.first_samp, raw.last_samp + 1])
      else:
          stop = min([stop, len(raw.times)])
      # Make sure we don't go out the end of the file:
      stop -= int(np.round(raw.info["sfreq"] * duration))
      # This should be inclusive due to how we generally use start and stop...
      ts = np.arange(
          start, stop + 1, raw.info["sfreq"] * (duration - overlap)
      ).astype(int)
      n_events = len(ts)
      if n_events == 0:
          raise ValueError(
              "No events produced, check the values of start, "
              "stop, and duration"
          )
      events = np.c_[
          ts,
          np.zeros(n_events, dtype=int),
          id * np.ones(n_events, dtype=int),
      ]
      return events
  
imports: from collections.abc import Sequence
  from pathlib import Path
  import numpy
  from ._fiff.constants import FIFF
  from ._fiff.open import fiff_open
  from ._fiff.pick import pick_channels
  from ._fiff.tag import read_tag
  from ._fiff.tree import dir_tree_find
  from ._fiff.write import end_block, start_and_end_file, start_block, write_int
  from .utils import _check_fname, _check_integer_or_list, _check_on_missing, _check_option, _get_stim_channel, _on_missing, _pl, _validate_type, check_fname, fill_doc, logger, verbose, warn
label_desc: Use image node_id 14 for calling a global function with example usage: make_fixed_length_events(raw, id, start, stop, duration, first_samp, overlap) and returns: events