buffer

Mettre en mémoire tampon le vecteur d’un signal dans une matrice de trames de données

Syntaxe

y = buffer(x,n)

y = buffer(x,n,p)

y = buffer(x,n,p,opt)

[y,z] = buffer(___)

[y,z,opt] = buffer(___)

Description

y = buffer(x,n) divise un signal de longueur L nommé x en segments de données (trames) de longueur n sans chevauchement.

y = buffer(x,n,p) applique un chevauchement positif ou négatif de p échantillons entre les trames successives dans la matrice de sortie.

y = buffer(x,n,p,opt) spécifie un vecteur d’échantillons devant précéder x(1) dans une mémoire tampon à chevauchement positif ou bien le nombre d’échantillons initiaux à ignorer dans une mémoire tampon à chevauchement négatif.

[y,z] = buffer(___) divise un signal de longueur L nommé x en trames de longueur n et génère uniquement les trames complètes en sortie dans y. Le vecteur z contient les échantillons restants. Cette syntaxe peut inclure n’importe quelle combinaison des arguments en entrée indiqués dans les syntaxes précédentes.

[y,z,opt] = buffer(___) renvoie les p derniers échantillons d’une mémoire tampon à chevauchement positif dans la sortie opt.

Exemples

Mémoires tampons continues à chevauchement positif

Créez une mémoire tampon contenant 100 trames de 10 échantillons chacune.

data = buffer(1:1000,10);

Les trames (colonnes) de la matrice data représentent les sorties séquentielles d’une carte d’acquisition de données qui échantillonne un signal physique : data(:,1) est la première sortie A/D contenant les 11 premiers échantillons du signal, data(:,2) est la deuxième sortie contenant les 11 échantillons suivants, et ainsi de suite.

Vous souhaitez remettre le signal en mémoire tampon en changeant la taille de trame acquise de 11 à 4 avec un chevauchement positif de 1. Appelez la fonction buffer pour l’appliquer à chaque trame d’entrée successive en utilisant le paramètre opt pour conserver un chevauchement cohérent d’une mémoire tampon à l’autre.

Configurez les paramètres de la mémoire tampon. Spécifiez une valeur de –5 pour y(1). Le vecteur de report est initialement vide.

n = 4;
p = 1;
opt = -5;
z = [];

Appelez ensuite la fonction buffer de manière répétée en lui passant à chaque fois une nouvelle trame de signal (colonne) de data. Les échantillons en dépassement (renvoyés dans z) sont reportés et ajoutés au début de l’entrée dans l’appel suivant de la fonction buffer.

Pour les quatre premières itérations, affichez la trame d’entrée [z;x]', les valeurs d’entrée et de sortie de opt, la mémoire tampon de sortie y et le dépassement z. La taille de la matrice de sortie y peut varier d’une seule colonne entre chaque itération. Ce comportement est courant dans les opérations de mise en mémoire tampon avec chevauchement positif ou négatif.

for i = 1:size(data,2)
    x = data(:,i);
    [y,z,oppt] = buffer([z;x],n,p,opt);
    if i <= 4
        disp("Iteration " + i)
        ifrm = [z;x]'
        opts = [opt oppt]
        y
        z
        disp("-----------")
    end
    opt = oppt;
end

Iteration 1

ifrm = 1×11

    10     1     2     3     4     5     6     7     8     9    10

opts = 1×2

    -5     9

y = 4×3

    -5     3     6
     1     4     7
     2     5     8
     3     6     9

z = 
10

-----------

Iteration 2

ifrm = 1×12

    19    20    11    12    13    14    15    16    17    18    19    20

opts = 1×2

     9    18

y = 4×3

     9    12    15
    10    13    16
    11    14    17
    12    15    18

z = 2×1

    19
    20

-----------

Iteration 3

ifrm = 1×10

    21    22    23    24    25    26    27    28    29    30

opts = 1×2

    18    30

y = 4×4

    18    21    24    27
    19    22    25    28
    20    23    26    29
    21    24    27    30

z =

  0×1 empty double column vector

-----------

Iteration 4

ifrm = 1×11

    40    31    32    33    34    35    36    37    38    39    40

opts = 1×2

    30    39

y = 4×3

    30    33    36
    31    34    37
    32    35    38
    33    36    39

z = 
40

-----------

Mémoires tampons continues à chevauchement négatif

Créez une mémoire tampon contenant 100 trames de 9 échantillons chacune.

data = buffer(1:900,9);

data(:,1) représente la première sortie A/D contenant les 11 premiers échantillons du signal, data(:,2) est la deuxième sortie contenant les 11 échantillons suivants, et ainsi de suite.

Vous souhaitez remettre le signal en mémoire tampon en changeant la taille de trame acquise de 11 à 4 avec un chevauchement négatif de 2. Pour ce faire, vous allez appeler la fonction buffer de manière répétée afin de l’appliquer à chaque trame d’entrée successive en utilisant le paramètre opt pour conserver un chevauchement cohérent d’une mémoire tampon à l’autre.

Configurez les paramètres de la mémoire tampon. Spécifiez une nouvelle taille de trame égale à 4 et un chevauchement négatif de –2. Ignorez le premier élément en entrée x(1) en définissant opt à 1. Le vecteur de report est initialement vide.

n = 4;
p = -2;
opt = 1;
z = [];

Appelez ensuite la fonction buffer de manière répétée en lui passant à chaque fois une nouvelle trame de signal (colonne) de data. Les échantillons en dépassement (renvoyés dans z) sont reportés et ajoutés au début de l’entrée dans l’appel suivant de la fonction buffer.

Pour les trois premières itérations, affichez la trame d’entrée [z';x]', les valeurs d’entrée et de sortie de opt, la mémoire tampon de sortie y et le dépassement z. La taille de la matrice de sortie y peut varier d’une seule colonne entre chaque itération. Ce comportement est courant dans les opérations de mise en mémoire tampon avec chevauchement positif ou négatif.

for i = 1:size(data,2)
   x = data(:,i);
   [y,z,oppt] = buffer([z';x],n,p,opt);
   if i <= 3
       disp("Iteration "+ i)
       ifrm = [z';x]'
       opts = [opt oppt]
       y
       z
       disp("-----------")
   end
   opt = oppt;
end

Iteration 1

ifrm = 1×11

     8     9     1     2     3     4     5     6     7     8     9

opts = 1×2

     1     0

y = 4×1

     2
     3
     4
     5

z = 1×2

     8     9

-----------

Iteration 2

ifrm = 1×9

    10    11    12    13    14    15    16    17    18

opts = 1×2

     0     1

y = 4×2

     8    14
     9    15
    10    16
    11    17

z =

  1×0 empty double row vector

-----------

Iteration 3

ifrm = 1×11

    26    27    19    20    21    22    23    24    25    26    27

opts = 1×2

     1     0

y = 4×1

    20
    21
    22
    23

z = 1×2

    26    27

-----------

Arguments d'entrée

x — Signal d’entrée

vecteur

Signal d’entrée, défini par un vecteur.

n — Longueur de trame

scalaire entier positif

Longueur de trame, définie par un scalaire entier positif.

p — Nombre d’échantillons qui se chevauchent

0 (par défaut) | scalaire entier

Nombre d’échantillons qui se chevauchent, défini par un scalaire entier.

• Pour 0 < p < n (chevauchement positif), buffer répète les p derniers échantillons de chaque trame au début de la suivante. Par exemple, si x = 1:30 et n = 7, un chevauchement positif p = 3 se présente comme suit.

  La première trame commence par p zéros (condition initiale par défaut) et le nombre de colonnes de y est égal à ceil(L/(n-p)).

• Pour p < 0 (chevauchement négatif), buffer ignore p échantillons entre les trames consécutives. Par exemple, si x = 1:30 et n = 7, une mémoire tampon avec un chevauchement négatif p = -3 se présente comme suit.

  Le nombre de colonnes de y est égal à ceil(L/(n-p)).

opt — Option

zeros(p,1) (par défaut) | "nodelay" | vecteur | entier

Option, définie par un vecteur ou un nombre entier.

• Pour 0 < p < n (chevauchement positif), opt spécifie un vecteur de longueur p à insérer avant x(1) dans la mémoire tampon. Ce vecteur peut être considéré comme une condition initiale qui est nécessaire lorsque l’opération de mise en mémoire tampon en cours fait partie d’une série d’opérations de mise en mémoire tampon consécutives. Pour conserver le chevauchement de trames positif souhaité d’une mémoire tampon à l’autre, opt doit contenir les p derniers échantillons de la mémoire tampon précédente de la séquence. Reportez-vous à Mise en mémoire tampon continue ci-dessous.

  Par défaut, opt est défini sur zeros(p,1) pour une mémoire tampon à chevauchement positif. Définissez opt sur "nodelay" pour ignorer la condition initiale et commencer immédiatement à remplir la mémoire tampon avec x(1). Dans ce cas, L doit être supérieur ou égal à length(p). Par exemple, si x = 1:30 et n = 7, une mémoire tampon avec un chevauchement positif p = 3 se présente comme suit.

• Pour p < 0 (chevauchement négatif), opt est une valeur entière comprise dans la plage [0,-p] qui spécifie le nombre d’échantillons d’entrée initiaux x(1:opt) à ignorer avant d’ajouter des échantillons à la mémoire tampon. La première valeur de la mémoire tampon est donc x(opt+1). Par défaut, opt est égal à zéro pour une mémoire tampon à chevauchement négatif.

  Cette option est particulièrement utile lorsque l’opération de mise en mémoire tampon en cours fait partie d’une série d’opérations de mise en mémoire tampon consécutives. Pour conserver le chevauchement de trames négatif souhaité d’une mémoire tampon à l’autre, opt doit être égal à la différence entre le nombre total de points à ignorer entre les trames (p) et le nombre de points pouvant être ignorés dans l’entrée précédente de buffer. Si l’entrée précédente contenait moins de p points pouvant être ignorés une fois la dernière trame remplie pour cette mémoire tampon, les opt points restants doivent être supprimés de la première trame de la mémoire tampon actuelle. Pour un exemple concret illustrant ce fonctionnement, veuillez consulter Mise en mémoire tampon continue.

Arguments de sortie

y — Trame de données

matrice

Trame de données, renvoyée sous la forme d’une matrice. Chaque trame de données occupe une colonne de y, qui contient n lignes et ceil(L/n) colonnes. Si L n’est pas exactement divisible par n, la dernière colonne est remplie avec des zéros jusqu’à atteindre la longueur n.

• Si y est une mémoire tampon à chevauchement positif, elle contient n lignes et m colonnes, où m = floor(L/(n-p)) quand length(opt) = p ou m = ceil((L-p)/(n-p)) quand opt = "nodelay".

• Si y est une mémoire tampon à chevauchement négatif, elle contient n lignes et m colonnes, où m = floor((L-opt)/(n-p)) + (rem((L-opt),(n-p)) >= n).

z — Échantillons restants

vecteur

Échantillons restants, renvoyés sous la forme d’un vecteur. Si le nombre d’échantillons du vecteur d’entrée (après les opérations de chevauchement positif ou négatif appropriées) est supérieur au nombre de places disponibles dans la mémoire tampon de n x m, les échantillons restants de x sont stockés dans le vecteur z en sortie. Pour une mémoire tampon à chevauchement positif, la longueur de ce vecteur est égale à L - m*(n-p) quand length(opt) = p ou à L - ((m-1)*(n-p)+n) quand opt = "nodelay". Pour une mémoire tampon à chevauchement négatif, elle est égale à (L-opt) - m*(n-p).

• Si y est une mémoire tampon à chevauchement positif ou sans chevauchement, z a la même orientation (ligne ou colonne) que x.

• Si y est une mémoire tampon à chevauchement négatif, z est renvoyé sous la forme d’un vecteur ligne.

S’il ne reste aucun échantillon dans l’entrée une fois que la mémoire tampon a été remplie avec le chevauchement positif ou négatif spécifié, z est un vecteur vide.

opt — p derniers échantillons

vecteur

p derniers échantillons, renvoyés sous la forme d’un vecteur. Dans une mémoire tampon à chevauchement négatif, opt est égal à la différence entre le nombre total de points à ignorer entre les trames (-p) et le nombre de points de x pouvant être ignorés une fois la dernière trame remplie. Dans une série d’opérations de mise en mémoire tampon, la sortie opt de chaque opération doit être utilisée comme entrée opt de l’opération de mise en mémoire tampon suivante. Cela garantit que le chevauchement de trames positif ou négatif souhaité est conservé d’une mémoire tampon à l’autre, mais aussi d’une trame à l’autre dans la même mémoire tampon. Pour un exemple concret illustrant ce fonctionnement, veuillez consulter Mise en mémoire tampon continue.

• Pour 0 < p < n (chevauchement positif), opt (en tant que sortie) contient les p derniers échantillons de la dernière trame de la mémoire tampon. Ce vecteur peut être utilisé comme condition initiale de l’opération de mise en mémoire tampon suivante dans une série d’opérations de mise en mémoire tampon consécutives. Le chevauchement de trames positif souhaité peut ainsi être conservé d’une mémoire tampon à l’autre.

• Pour p < 0 (chevauchement négatif), opt (en tant que sortie) est égal à la différence entre le nombre total de points à ignorer entre les trames (p) et le nombre de points de x pouvant être ignorés une fois la dernière trame remplie : opt = m*(n-p) + opt - L, où opt à droite est l’argument en entrée de buffer et opt à gauche est l’argument en sortie. z est le vecteur vide. Ici, m est le nombre de colonnes de la mémoire tampon, avec m = floor((L-opt)/(n-p)) + (rem((L-opt),(n-p))>=n).

  Notez qu’en sortie d’une mémoire tampon à chevauchement négatif, opt est toujours égal à zéro quand la sortie z contient des données.

  La sortie opt pour une mémoire tampon à chevauchement négatif est particulièrement utile lorsque l’opération de mise en mémoire tampon en cours fait partie d’une série d’opérations de mise en mémoire tampon consécutives. La sortie opt de chaque opération de mise en mémoire tampon spécifie le nombre d’échantillons à ignorer au début de l’opération de mise en mémoire tampon suivante pour conserver le chevauchement de trames négatif souhaité d’une mémoire tampon à l’autre. Si le nombre de points pouvant être ignorés une fois la dernière trame remplie dans la mémoire tampon actuelle est inférieur à p, les opt points restants doivent être supprimés de la première trame de la mémoire tampon suivante.

Diagnostics

Des messages d’erreur s’affichent lorsque p ≥ n ou que length(opt) ≠ length(p) dans le cas d’une mémoire tampon à chevauchement positif :

Frame overlap P must be less than the buffer size N. (Le chevauchement de trames positif P doit être inférieur à la taille de mémoire tampon N.)
Initial conditions must be specified as a length-P vector. (Les conditions initiales doivent être spécifiées sous la forme d’un vecteur de longueur P.)

En savoir plus

Mise en mémoire tampon continue

Dans une opération de mise en mémoire tampon continue, le vecteur en entrée de la fonction buffer représente une seule trame dans une série de trames composant un signal discret. Ces trames de signal peuvent provenir d’un processus d’acquisition de données basé sur des trames ou d’un algorithme basé sur des trames tel que FFT.

Par exemple, vous pouvez acquérir les données d’une carte A/D par trames de 64 échantillons. Dans le plus simple des cas, vous pouvez remettre les données en mémoire tampon par trames de 16 échantillons. La fonction buffer avec n = 16 crée une mémoire tampon contenant quatre trames pour chaque trame de 64 éléments en entrée. Le résultat est la conversion du signal ayant une taille de trame de 64 en un signal ayant une taille de trame de 16 sans ajout ni suppression d’échantillons.

Dans le cas général où la taille de trame L du signal d’origine n’est pas exactement divisible par la nouvelle taille de trame n, le dépassement de la dernière trame doit être capturé et recyclé dans la mémoire tampon suivante. Pour ce faire, vous pouvez appeler buffer de manière itérative sur l’entrée x avec la syntaxe à deux arguments en sortie :

[y,z] = buffer([z;x],n)     % x is a column vector.
[y,z] = buffer([z,x],n)     % x is a row vector.

Cette syntaxe offre un moyen simple de capturer tout dépassement de mémoire tampon dans z et d’ajouter ces données au début de l’entrée suivante dans le prochain appel de buffer. Là encore, le signal d’entrée x ayant une taille de trame L est converti en un signal ayant une taille de trame n sans insertion ni suppression d’échantillons.

Notez qu’il est impossible d’effectuer une mise en mémoire tampon continue avec la syntaxe à une seule sortie y = buffer(...), car dans ce cas, la dernière trame de y est remplie avec des zéros, ce qui ajoute de nouveaux échantillons au signal.

En cas de chevauchement positif ou négatif, la mise en mémoire tampon continue s’effectue en utilisant le paramètre opt à la fois comme entrée et sortie de buffer. Les deux exemples de cette page montrent comment utiliser le paramètre opt.

Capacités étendues

Génération de code C/C++

Générez du code C et C++ avec MATLAB® Coder™.

Notes d’usage et limitations :

• L’entrée p doit être constante au moment de la compilation.

Génération de code GPU

Générez du code CUDA® pour les GPU NVIDIA® avec GPU Coder™.

Consultez les notes d’usage et limitations à la section « Génération de code C/C++ ». Les mêmes notes d’usage et limitations s’appliquent à la génération de code GPU.

GPU Arrays

Accélérez le code en exécutant les calculs sur une unité de traitement graphique (GPU) avec Parallel Computing Toolbox™.

Cette fonction supporte complètement les GPU arrays. Pour plus d’informations, veuillez consulter Exécuter les fonctions MATLAB sur un GPU (Parallel Computing Toolbox).

Historique des versions

Introduit avant R2006a

R2023b: Utiliser des arguments en entrée non doubles

La fonction buffer supporte les arguments en entrée non doubles.

R2023a: Générer du code C et C++

Générez du code C et C++ pour la fonction buffer. Vous devez disposer de MATLAB^® Coder™ pour utiliser cette fonctionnalité.

Voir aussi

reshape