Dal segnale nel tempo alle sue componenti in frequenza

Un segnale elettrico può apparire complesso quando lo osserviamo nel dominio del tempo, ma essere costituito dalla somma di poche oscillazioni semplici. Questa lezione insegna a usare la trasformata discreta di Fourier, calcolare uno spettro monolatero delle ampiezze, riconoscere un errore nella frequenza di campionamento e comprendere la dispersione spettrale (spectral leakage). I risultati saranno salvati come Dataset GX-TXT e rappresentati con grafici persistenti.

L’esperimento impiega esclusivamente dati sintetici, così da conoscere esattamente le frequenze e le ampiezze che dobbiamo recuperare.

Versione di riferimento: GX-TXT 0.9.8.10-dev-112, Release 2, patch P008, release GitHub. Commit dei sorgenti verificati: 17ff2a7f93de0612015a873e626f87dbeb56b6a2. Linguaggio: GNU Octave. Gli script sono concessi in licenza GPL-3.0-or-later e contengono commenti in inglese.

Cosa impareremo

Al termine della lezione sapremo definire un vettore temporale in Octave, sommare sinusoidi, calcolare frequenza di campionamento e intervallo spettrale, leggere Dataset canonici con gli identificativi delle variabili, applicare trasformazioni numeriche attraverso le API pubbliche, gestire numeri complessi e controllare l’attendibilità di uno spettro. Useremo inoltre il debugger di GX-TXT per esaminare un errore intenzionale e pubblicheremo gli elaborati senza manipolare file interni.

Collegamento con le dodici lezioni precedenti

Nelle Lezioni 01–04 abbiamo appreso sintassi, tipi numerici, numeri complessi, vettori, matrici, condizioni, cicli e funzioni. Le Lezioni 05–07 hanno introdotto Dataset, Variable ID, lettura canonica e pubblicazione; la Lezione 07 ha già costruito sinusoidi campionate con GNU Octave. La Lezione 08 ha introdotto i grafici persistenti e il debugging, ripresi nelle Lezioni 09–12 per statistica, regressione, calcolo numerico e algebra lineare.

La novità della Lezione 13 non è generare un’altra sinusoide: è scoprire quali oscillazioni compongono una misura, interpretare le informazioni di frequenza e comprendere i limiti dei risultati. Riutilizzeremo senza ridefinirli i concetti di vettore, struttura Octave, cell array, Dataset ID, Variable ID e grafico persistente. Studieremo invece passo passo FFT, frequenze discrete, normalizzazione, finestre e ricostruzione.

Conoscenza già acquisitaCome la utilizziamo quiNuovo concetto
Vettori, operazioni elemento per elemento (03, 07)Generiamo campioni temporaliCorrispondenza fra campioni e frequenze
Numeri complessi (02)Ricostruiamo coefficienti da parti reale e immaginariaModulo, fase e simmetria della FFT
Dataset canonici (05–07)Leggiamo tempo e tensione usando Variable IDControllo del passo di campionamento
Debugger GX-TXT (08–12)Ispezioniamo un parametro scorrettoErrore fisico nell’asse delle frequenze
Pubblicazione e Plot Dataset (07–12)Salviamo spettri e graficiDataset nel dominio della frequenza

L’esperimento: due componenti sinusoidali

La prima traccia è definita da

\[
v(t)=0{,}20+1{,}25\sin(2\pi\,50t+0{,}15)+0{,}50\sin(2\pi\,120t-0{,}30).
\]

La tensione è espressa in volt, il tempo in secondi. Il segnale contiene una componente continua di 0,20 V, una sinusoide di 50 Hz con ampiezza di picco 1,25 V e una sinusoide di 120 Hz con ampiezza di picco 0,50 V. Le fasi sono espresse in radianti.

Una seconda traccia conserva ampiezze e frequenza superiore, ma sostituisce la prima componente con 50,5 Hz. Questa piccola modifica permette di osservare cosa accade quando una frequenza non coincide con un bin della FFT.

La Lezione 13 usa i seguenti parametri:

GrandezzaSimboloValore
Frequenza di campionamento\(f_s\)1024 Hz
Numero di campioni\(N\)1024
Intervallo tra campioni\(\Delta t=1/f_s\)0,0009765625 s
Durata della registrazione\(T=N/f_s\)1 s
Distanza tra bin\(\Delta f=f_s/N\)1 Hz
Frequenza di Nyquist\(f_N=f_s/2\)512 Hz

In Octave la sequenza temporale si costruisce con:

sample_rate_hz = 1024;
sample_count = 1024;
time_s = (0:sample_count - 1)' / sample_rate_hz;

L’operatore : genera una sequenza, l’apostrofo ' la trasforma in vettore colonna e la divisione per la frequenza di campionamento converte gli indici in secondi. La notazione sin(2*pi*f*time_s + phase) calcola la sinusoide in ogni istante.

Grafico GX-TXT di due segnali sintetici con componenti a 50 o 50,5 Hz e a 120 Hz
I segnali sintetici nel dominio del tempo prima della trasformata di Fourier.

Dal numero del campione all’istante fisico

Nel nostro esperimento il campione con indice matematico \(n\) è osservato all’istante \(t_n=n/f_s\). Per \(n=0,\ldots,1023\) otteniamo 1024 campioni, ma l’ultimo istante è \(1023/1024=0{,}9990234375\) s. Non dobbiamo aggiungere un campione a \(t=1\) s: ripeteremmo il punto iniziale del periodo, ottenendo 1025 valori e modificando la griglia spettrale.

La durata della registrazione usata nella DFT è \(T=N/f_s=1\) s. Non va confusa con la differenza tra il primo e l’ultimo timestamp, pari a \((N-1)/f_s\). Questa distinzione rende coerenti la costruzione del vettore temporale e i bin della FFT.

Per la traccia a 50 Hz la registrazione contiene esattamente 50 periodi, e per quella a 120 Hz ne contiene 120: entrambe sono coerenti con la finestra temporale osservata. La seconda traccia contiene invece 50,5 periodi della componente inferiore. Sarà la nostra prova controllata della dispersione spettrale.

Dal tempo alla frequenza: un cambiamento di rappresentazione

L’ascissa del primo grafico è il tempo (s), l’ordinata è la tensione (V). Dopo la DFT, l’ascissa diventa la frequenza (Hz). I dati non sono nuove misure: sono una diversa rappresentazione matematica della stessa sequenza di campioni.

Il bin \(k\), per la metà non negativa dello spettro, corrisponde a \(f_k=kf_s/N\). Qui la distanza fra bin è 1 Hz. I bin 50 e 120 rappresentano quindi esattamente le due frequenze della prima traccia. Lo zero indica la componente continua; il bin 512 è la frequenza di Nyquist.

Che cosa calcola la FFT

La trasformata discreta di Fourier di \(N\) campioni è

\[
X[k]=\sum_{n=0}^{N-1}x[n]\,e^{-i\,2\pi kn/N},\qquad k=0,\ldots,N-1.
\]

In Octave gli indici degli array partono da 1, mentre nella formula matematica iniziano da 0. Pertanto il bin di 50 Hz, quando \(\Delta f=1\) Hz, si trova in X(51); quello di 120 Hz si trova in X(121).

Coefficienti complessi, modulo e fase

Il risultato della DFT non è direttamente una lista di ampiezze in volt: ogni coefficiente \(X[k]\) è un numero complesso. La sua parte reale e quella immaginaria contengono insieme le informazioni su ampiezza e fase. In Octave il modulo si ottiene con abs(z), mentre l’angolo si ottiene con angle(z) (radianti). Per esempio, il coefficiente della componente a 50 Hz si trova in posizione 51, perché l’indicizzazione Octave parte da uno.

Per una sinusoide reale, \(X[N-k]\) è il complesso coniugato di \(X[k]\) (quando \(k\) non è un estremo). La metà a frequenze negative ripete pertanto l’informazione della metà positiva. Questo giustifica lo spettro monolatero. Tuttavia, costruire il solo modulo \(|X[k]|\) perde le informazioni di fase: non è possibile ricostruire univocamente il segnale usando esclusivamente le ampiezze.

Un esempio pratico: due sinusoidi con la stessa ampiezza e la stessa frequenza ma fasi differenti hanno picchi di ampiezza uguale; i coefficienti complessi, invece, sono diversi.

Per segnali reali, i coefficienti della FFT sono complessi e mostrano simmetria coniugata. Uno spettro monolatero conserva soltanto le frequenze non negative. Per la normalizzazione FFT standard (backward, ossia trasformata diretta non scalata) la corretta ampiezza di picco di un tono coerente in un bin interno è

\[
A_k=\frac{2|X[k]|}{N\,G_c},
\]

dove \(G_c\) è il guadagno coerente della finestra. Il fattore 2 non va applicato alla componente continua né al bin di Nyquist, quando presente.

Perché normalizziamo lo spettro

Con l’opzione normalization = backward la trasformata diretta non viene divisa per \(N\); la normalizzazione dell’inversa è gestita dalla trasformata inversa. Per leggere un’ampiezza fisica dobbiamo perciò dividere il modulo FFT per \(N\) e correggere il guadagno coerente \(G_c\) della finestra.

Per i bin interni dello spettro monolatero si moltiplica inoltre per due: in un segnale reale la componente sinusoidale è distribuita fra le due frequenze simmetriche. Il bin DC e il bin di Nyquist non vanno raddoppiati. L’operazione pubblica oneSided applica questo trattamento; lo script divide poi il modulo per \(N G_c\).

Nel caso rettangolare, \(G_c=1\), e per le componenti esattamente centrate sui bin recuperiamo 1,25 V e 0,50 V di picco, non RMS. Per convertirle in RMS, nel caso di singole sinusoidi, occorre dividere per \(\sqrt{2}\): circa 0,884 V e 0,354 V. Il valore RMS del segnale completo richiede invece di considerare tutte le componenti e l’eventuale offset.

La PSD è un’altra grandezza, con una diversa normalizzazione e unità tipiche \(V^2/Hz\), utilizzata per studiare la distribuzione di potenza o rumore. Un grafico in V di picco non è una PSD, anche se sull’asse orizzontale compare la frequenza.

Attenzione: uno spettro delle ampiezze non è una densità spettrale di potenza (PSD). Non chiameremo PSD il risultato di questa esercitazione.

Spettro delle ampiezze FFT GX-TXT con picco di 1,25 V a 50 Hz e 0,50 V a 120 Hz
Lo spettro monolatero recupera frequenze e ampiezze delle due sinusoidi.

Il percorso negli script

Preparazione – L13_00_Prepare_Two_Tone_Signals.m

Il primo script genera i due segnali, pubblica due Dataset canonici e li rilegge tramite le API pubbliche per verificare che la memorizzazione abbia conservato i campioni. La transazione di pubblicazione è atomica.

Codice GNU Octave per analisi FFT aperto nell'editor di GX-TXT
Editor GNU Octave integrato in GX-TXT con lo script della Lezione 13.

Debugger – L13_01_Debug_Wrong_Sampling_Rate.m

Il secondo script contiene un errore scientifico intenzionale: usa \(f_s=512\) Hz per costruire l’asse delle frequenze, nonostante il vettore temporale dimostri che \(f_s=1024\) Hz. Le ampiezze dei coefficienti FFT non cambiano, ma la frequenza riportata per il massimo principale diventa 25 Hz invece di 50 Hz.

Nel GX-TXT Octave Script Workspace importiamo il file con un identificativo distinto e avviamo Run → Debug Session script. Impostiamo un breakpoint presso il commento BREAKPOINT, quindi ispezioniamo correct_sample_rate_hz, wrong_sample_rate_hz, measured_step_s e dominant_frequency_hz. Dopo Continue il Job deve terminare con l’errore didattico atteso: non è un bug del framework, ma la corretta rilevazione di un’ipotesi sbagliata.

Questo esempio non simula il fenomeno fisico dell’aliasing: modifica soltanto la frequenza usata per etichettare i bin. L’aliasing nasce invece quando il segnale viene realmente campionato a una frequenza insufficiente.

Debugger GX-TXT fermo alla riga di controllo della frequenza di campionamento
Il debugger interrompe lo script alla riga 48, prima della verifica dell’asse delle frequenze.
Messaggio di errore che segnala la frequenza FFT errata dovuta a un campionamento dichiarato scorrettamente
Il controllo scientifico rileva una frequenza dominante di 25 Hz anziché 50 Hz.

Capire l’errore prima di correggerlo

Nella prova intenzionalmente errata il vettore dei campioni rimane lo stesso e la FFT produce gli stessi coefficienti. Cambia solo il valore passato a frequencyGrid: con \(f_s=512\) Hz al posto di 1024 Hz, la distanza fra bin diventa \(0{,}5\) Hz. Di conseguenza il bin \(k=50\), che dovrebbe essere etichettato 50 Hz, viene mostrato a 25 Hz.

Il debugger serve a confrontare il passo temporale realmente letto dal Dataset, la frequenza ricavata da quel passo e la frequenza introdotta erroneamente. Il controllo che genera il fallimento intenzionale è una verifica di coerenza scientifica, non un guasto dell’algoritmo FFT.

È essenziale distinguere questo errore dall’aliasing: l’aliasing si verifica durante il campionamento reale, quando frequenze troppo alte non sono distinguibili con la frequenza \(f_s\) scelta. Con \(f_s=1024\) Hz, per esempio, una componente a 700 Hz può ripiegarsi a 324 Hz: \(1024-700=324\). Il valore mostrato a 25 Hz in questa lezione non è un alias.

Analisi corretta – L13_02_FFT_Spectrum_Correct.m

Il terzo script ricava la frequenza di campionamento direttamente dagli istanti del Dataset, verifica l’uniformità degli intervalli, rimuove la media, calcola FFT e asse delle frequenze mediante i servizi GX-TXT, seleziona i coefficienti monolateri e recupera le ampiezze fisiche. Confronta anche una finestra rettangolare e una finestra di Hann periodica per il segnale da 50,5 Hz, e controlla l’inversa IFFT.

Al termine crea quattro Dataset derivati e tre grafici GX-TXT persistenti: segnali nel tempo, spettro delle frequenze coerenti e confronto tra finestre.

Le API pubbliche GX-TXT impiegate

Le operazioni seguenti sono descritte nei contratti pubblici della versione indicata. In questa lezione non sono semplici nomi da copiare: costituiscono il collegamento tra codice Octave e infrastruttura scientifica.

API / operazioneScopo e significato didattico
gxtxt_api_require, gxtxt_api_has_operationVerificano che la Session esponga i contratti e le operazioni necessari prima di eseguire il calcolo
gxtxt_api_call(api, operation, args)Invoca un servizio pubblico, passando gli argomenti in una cell array
CANONICAL_DATASET_API_v2 / listElenca gli identificativi stabili dei Dataset pubblicati
CANONICAL_DATASET_API_v2 / read_rangeLegge campioni di variabili note tramite Dataset ID, Variable ID, offset e numero di righe
NUMERIC_API_v1 / detrendRimuove una media o una tendenza, senza modificare implicitamente gli istanti di campionamento
NUMERIC_API_v1 / windowGenera i pesi della finestra e fornisce il guadagno coerente necessario per correggere le ampiezze
NUMERIC_API_v1 / fftCalcola la trasformata senza normalizzazioni scientifiche nascoste; restituisce parti reale e immaginaria
NUMERIC_API_v1 / frequencyGridCalcola frequenze, \(\Delta f\) e Nyquist a partire da \(f_s\) e \(N\)
NUMERIC_API_v1 / oneSidedSeleziona le frequenze non negative e, con scaling=amplitude, raddoppia solo i bin interni
NUMERIC_API_v1 / ifftCalcola l’inversa, utile a verificare che la trasformazione conservi i dati
DATASET_PUBLICATION_API_v2 / publish_series_batchPubblica insieme serie scientifiche, metadati e provenienza
PLOT_DATASET_API_v4Crea, valida, registra, renderizza e rende consultabili grafici che puntano a Dataset canonici

Le nuove operazioni numeriche, chiamata per chiamata

Le precedenti lezioni hanno già spiegato come verificare le dipendenze e chiamare un servizio attraverso gxtxt_api_call. Qui concentriamoci sui contratti numerici introdotti per la prima volta. In tutti gli esempi il terzo argomento di gxtxt_api_call è una cell array Octave che contiene gli argomenti dell’operazione, nell’ordine previsto dal contratto.

Operazione pubblicaArgomenti usati nello scriptRisultato utilizzatoPerché serve
detrendvettore di tensioni; struttura con method = meanvaluesRimuove il valore medio prima dello spettro
windownome rectangular oppure hann; N; struttura con sampling = periodicvalues; coherent_gainFornisce i pesi e il fattore correttivo delle ampiezze
fftvettore; struttura con nfft = N e normalization = backwardreal; imaginaryCalcola i coefficienti complessi della DFT
frequencyGridfrequenza di campionamento; N; struttura con representation = one_sidedfrequencies; df e altre informazioni di grigliaAssocia unità fisiche ai bin
oneSidedreal; imaginary; struttura con scaling = amplitude e nfft = Nreal; imaginarySeleziona la metà non negativa e tratta correttamente i bin interni
ifftparti real e imaginary; struttura con nfft = N e normalization = backwardreal; imaginaryRicostruisce il segnale per controllare la trasformazione

Controlli prima della FFT. Lo script confronta gli assi temporali dei due Dataset; calcola gli intervalli con la funzione Octave diff; ne stima il passo con median; verifica che siano positivi e uniformi; infine usa \(f_s=1/\Delta t\). In questo modo non scambia un parametro di elaborazione per una proprietà realmente osservata.

Controlli sulle risposte. I valori devono avere lunghezze coerenti; frequenze e ampiezze devono riferirsi agli stessi bin; le parti reale e immaginaria devono essere combinate nello stesso ordine. L’operazione complex(re, im) è una funzione nativa Octave, mentre fft invocata attraverso NUMERIC_API_v1 è un servizio pubblico GX-TXT.

Errori da prevenire. Non confondere un Dataset ID con un file, non cambiare l’ordine degli argomenti della cell array, non chiamare frequencyGrid con una frequenza presunta, non moltiplicare una seconda volta per due lo spettro già convertito da oneSided e non applicare due volte la divisione per \(N\).

Tre chiamate da leggere nel codice

Consideriamo tre operazioni introdotte in questa lezione. Il primo argomento individua il servizio pubblico, il secondo l’operazione e il terzo racchiude i parametri in una cell array Octave.

centered = gxtxt_api_call('NUMERIC_API_v1', 'detrend', ...
  {voltage_values, struct('method', 'mean')});

grid = gxtxt_api_call('NUMERIC_API_v1', 'frequencyGrid', ...
  {1024, 1024, struct('representation', 'one_sided')});

hann_window = gxtxt_api_call('NUMERIC_API_v1', 'window', ...
  {'hann', 1024, struct('sampling', 'periodic')});

Nella prima chiamata voltage_values rappresenta il vettore di dati e centered.values contiene i valori senza media. Nella seconda chiamiamo la griglia indicando esplicitamente frequenza di campionamento e numero di campioni, entrambi necessari per interpretare le ascisse. Nella terza chiediamo i 1024 pesi della Hann periodica e il relativo coherent_gain, che useremo per esprimere le ampiezze nelle unità fisiche originali.

Nessuna di queste tre chiamate legge file interni GX-TXT: i dati provengono dalle API canoniche e l’elaborazione è affidata al contratto pubblico del servizio numerico.

Per esempio, la chiamata

fft_result = gxtxt_api_call('NUMERIC_API_v1', 'fft', ...
  {voltage_values, struct('nfft', 1024, 'normalization', 'backward')});
complex_bins = complex(fft_result.real, fft_result.imaginary);

mostra che gxtxt_api_call non riceve direttamente una lista variabile di argomenti Octave: l’ultimo parametro è una cell array. Il servizio restituisce parti reale e immaginaria separate; con complex ricostruiamo i coefficienti complessi per il calcolo di abs.

La funzione frequencyGrid non può ricavare automaticamente \(f_s\) dal solo array FFT: la frequenza di campionamento è un’informazione proveniente dall’acquisizione. Per questo la ricaviamo e la controlliamo sul Dataset temporale.

Finestratura: perché cambiare i pesi ai campioni?

La DFT interpreta i \(N\) campioni come un periodo di una sequenza che si ripete indefinitamente. Se il segnale contiene un numero intero di periodi nella registrazione, i due estremi si raccordano periodicamente e il tono si concentra su un bin. Se la sinusoide contiene 50,5 periodi, il raccordo presenta una discontinuità: la sua energia si distribuisce su numerosi bin. È la dispersione spettrale (spectral leakage).

La finestra rettangolare assegna peso 1 a ogni campione. La Hann periodica applica invece, per \(n=0,\ldots,N-1\),

\[
w[n]=\frac12-\frac12\cos\!\left(\frac{2\pi n}{N}\right).
\]

I campioni vicini agli estremi vengono attenuati, limitando la discontinuità del raccordo. Il risultato ha code laterali più basse, ma un lobo principale più largo: non è una trasformazione gratuita. Per la Hann periodica il guadagno coerente è \(G_c=0{,}5\); per la rettangolare è 1.

Guadagno coerente e scalloping loss non sono la stessa cosa. La correzione con \(G_c\) ripristina l’ampiezza di un tono allineato al bin dopo la finestratura. Se il tono cade tra due bin, il massimo può risultare inferiore al valore reale anche dopo questa correzione: è la scalloping loss. Perciò non bisogna leggere il massimo di un solo bin come misura esatta di un tono non coerente.

Un secondo compromesso riguarda l’identificazione di due frequenze vicine. La larghezza del lobo principale può far apparire meno separati due toni; la soppressione delle code laterali può invece rendere visibile una componente debole accanto a una forte. La finestra si sceglie in base allo scopo dell’analisi.

Finestratura e dispersione spettrale

La traccia a 50,5 Hz non contiene un numero intero di cicli nel secondo osservato; con la finestra rettangolare l’energia si distribuisce su più bin. Una finestra Hann periodica attenua le code laterali ma allarga il lobo principale. Il suo guadagno coerente, qui pari a 0,5, va considerato nella scala delle ampiezze.

La finestra Hann non rende perfettamente esatta l’ampiezza di un tono non centrato su un bin: rimane una perdita dovuta al disallineamento (scalloping loss). Non bisogna interpretare l’altezza del massimo isolato come stima esatta in ogni situazione.

Nella nostra verifica numerica, per il solo esempio sintetico e al bin di 70 Hz, l’ampiezza associata alla dispersione scende da circa \(0{,}0170\) V (rettangolare) a \(0{,}0000536\) V (Hann). Questo confronto riguarda quel bin, non una promessa di riduzione uniforme sull’intero spettro.

Confronto nello spettro FFT GX-TXT fra finestra rettangolare e finestra Hann su un tono a 50,5 Hz
La finestra Hann riduce le code laterali, modificando la forma del lobo principale.

Risoluzione spettrale, durata e zero-padding

La distanza fra bin è \(\Delta f=f_s/N=1/T\). Se manteniamo \(f_s=1024\) Hz e osserviamo per 2 s, useremo 2048 campioni e otterremo \(\Delta f=0{,}5\) Hz. Cambia la durata dell’osservazione; la frequenza di Nyquist rimane invece \(512\) Hz, perché dipende da \(f_s\).

Portare nfft a un valore superiore al numero di campioni, riempiendo il segnale con zeri (zero-padding), crea una griglia più fitta, ma non aggiunge informazione temporale. Può facilitare la lettura e l’interpolazione dei picchi; non ha lo stesso effetto di raddoppiare la durata della misura. Nello script utilizziamo \(nfft=N=1024\), così campionamento, durata e griglia mantengono un legame trasparente.

Inversa FFT

Con ifft ricostruiamo il segnale centrato sui dati, quindi ripristiniamo la componente continua. La differenza massima tra campioni originari e ricostruiti deve risultare prossima alla precisione numerica della macchina. Questa verifica controlla coerenza e ordine dei coefficienti, non dimostra da sola che la nostra interpretazione fisica dello spettro sia corretta.

Come valutiamo la ricostruzione

Per il segnale coerente lo script rimuove il valore medio prima di calcolare la FFT, passa all’IFFT i coefficienti complessi non limitati alla metà positiva e somma nuovamente la media al vettore ricostruito. La prova consiste nel calcolare il massimo valore assoluto della differenza campione per campione.

Un errore molto piccolo verifica che le due trasformate sono coerenti nella precisione numerica disponibile. Non dimostra, da solo, che il campionamento iniziale abbia rispettato Nyquist o che uno spettro descriva fedelmente un sistema fisico reale: l’IFFT sa ricostruire anche una sequenza campionata male.

Risultati numerici attesi

VerificaRisultato atteso
Frequenza principale50,000 Hz
Seconda frequenza120,000 Hz
Ampiezza principale1,250 V di picco
Seconda ampiezza0,500 V di picco
Intervallo dei bin1 Hz
Nyquist512 Hz
Guadagno coerente Hann periodica0,5
Dataset di ingresso / derivati2 / 4
Grafici persistenti3

Questi valori costituiscono un riferimento per controllare i risultati della propria esecuzione, distinguendo la correttezza del calcolo dall’interpretazione fisica dello spettro.

Elenco GX-TXT Script Jobs con preparazione e analisi FFT completate e prova del debugger fallita intenzionalmente
Gli Script Jobs distinguono la preparazione, l’errore atteso e l’analisi corretta.

Come riprodurre la lezione

Creare una nuova Session autonoma in GX-TXT, aprire Viewers → Octave Scripts, importare L13_00, assegnare un identificativo Script distinto e salvarlo. Eseguire lo script da Run → Open Script Runner e verificarne il completamento. Aprire L13_01 in un secondo Script ID e osservare, mediante il debugger, l’errore intenzionale. Infine importare ed eseguire L13_02 con un terzo Script ID; controllare i Dataset e i grafici nella finestra principale.

Gli script pubblicano identificativi canonici in modalità create-only. Per ripetere l’esperimento completo occorre una nuova Session, senza eliminare o modificare i file di registrazione interni.

Pannello Dataset di GX-TXT con variabili frequency_hz e amplitude_V e unità Hz e V
Il Dataset derivato conserva identificativi di variabile e unità scientifiche.

Che cosa rende questo esperimento riproducibile

La sequenza da controllare è: descrizione del segnale sintetico e della sua frequenza di campionamento, pubblicazione dei due Dataset con unità fisiche, lettura canonica senza accedere ai file interni, verifica degli intervalli temporali, analisi numerica mediante API pubbliche, pubblicazione dei quattro Dataset derivati e registrazione dei tre grafici persistenti.

Il confronto fra valori previsti e osservati distingue la correttezza delle operazioni matematiche dall’interpretazione della misura. Una frequenza mostrata sull’asse X ha significato solo se deriva dal reale passo temporale; un’ampiezza espressa in V richiede una normalizzazione coerente con la convenzione adottata.

Esercizi

  1. Modificare l’ampiezza della componente a 120 Hz e prevedere come cambierà il bin corrispondente.
  2. Aumentare \(N\) mantenendo la stessa \(f_s\). Che cosa accade alla durata e alla distanza tra bin?
  3. Confrontare una finestra rettangolare e una Hann su una frequenza non coerente; spiegare perché il lobo principale cambia larghezza.
  4. Aggiungere una componente a 700 Hz, campionata realmente a 1024 Hz, e prevedere la frequenza alias \(1024-700=324\) Hz. Distinguere questo fenomeno dall’errore intenzionale nel secondo script.

Riferimenti ai sorgenti pubblici

Gli script completi, con commenti in inglese, sono disponibili nei riquadri espandibili in fondo all’articolo e nel materiale scaricabile del corso.


Script GNU Octave completi

Aprire i riquadri per consultare o copiare i tre script. I commenti del codice sono in inglese.

L13_00_Prepare_Two_Tone_Signals.m
% Lesson 13 - Publish synthetic signals for the Fourier transform.
% Course: GNU Octave with GX-TXT | DEV112 Release 2 + P008
% GitHub commit: 17ff2a7f93de0612015a873e626f87dbeb56b6a2
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Execute once in a new managed GX-TXT Session.
% The two traces are deterministic synthetic examples, not measurements.

dataset_api = 'CANONICAL_DATASET_API_v2';
publication_api = 'DATASET_PUBLICATION_API_v2';
gxtxt_api_require({dataset_api, publication_api});
assert(gxtxt_api_has_operation(dataset_api, 'list'));
assert(gxtxt_api_has_operation(dataset_api, 'read_range'));
assert(gxtxt_api_has_operation(publication_api, 'publish_series_batch'));

sample_rate_hz = 1024;
sample_count = 1024;
time_s = (0:sample_count - 1)' / sample_rate_hz;
fundamental_amplitude_v = 1.25;
second_amplitude_v = 0.50;
offset_v = 0.20;

% Integer-cycle tones occupy exactly one FFT bin per component.
coherent_v = offset_v + ...
  fundamental_amplitude_v * sin(2*pi*50*time_s + 0.15) + ...
  second_amplitude_v * sin(2*pi*120*time_s - 0.30);

% A half-bin frequency demonstrates spectral leakage without random noise.
offbin_v = offset_v + ...
  fundamental_amplitude_v * sin(2*pi*50.5*time_s + 0.15) + ...
  second_amplitude_v * sin(2*pi*120*time_s - 0.30);
assert(numel(time_s) == sample_count);
assert(all(isfinite(coherent_v)) && all(isfinite(offbin_v)));

ids = {'lesson13_signal_coherent', 'lesson13_signal_offbin'};
existing = gxtxt_api_call(dataset_api, 'list', {});
for k = 1:numel(ids)
  if any(strcmp(existing, ids{k}))
    error('Source Dataset already exists: %s. Use a fresh Session.', ids{k});
  endif
endfor

time_var = struct('variable_id', 'time_s', ...
  'name', 'time_s', 'display_label', 'Elapsed time', ...
  'unit', 's', 'dtype', 'float64', 'value_kind', 'number', ...
  'semantic_source', 'generator');
voltage_var = struct('variable_id', 'voltage_V', ...
  'name', 'voltage_V', 'display_label', 'Synthetic voltage', ...
  'unit', 'V', 'dtype', 'float64', 'value_kind', 'number', ...
  'semantic_source', 'generator');

all_values = {coherent_v, offbin_v};
all_labels = {'Two coherent sinusoids at 50 and 120 Hz', ...
              'Half-bin tone at 50.5 Hz plus coherent 120 Hz'};
series = cell(1, 2);
for k = 1:2
  metadata = struct();
  metadata.('simulation.synthetic') = true;
  metadata.('simulation.sample_rate_hz') = sample_rate_hz;
  metadata.('simulation.sample_count') = sample_count;
  metadata.('simulation.offset_v') = offset_v;
  metadata.('simulation.description') = all_labels{k};
  series{k} = struct('dataset_id', ids{k}, 'contract', 'table.generic', ...
    'storage', 'auto', 'x_values', time_s, 'y_values', all_values{k}, ...
    'x_variable', time_var, 'y_variable', voltage_var, ...
    'producer_version', '1.0.0', ...
    'source', 'GX-TXT GNU Octave Lesson 13', ...
    'provenance', 'Deterministic simulated two-tone voltage records', ...
    'notes', all_labels{k}, 'structured_metadata', metadata);
endfor

receipt = gxtxt_api_call(publication_api, 'publish_series_batch', ...
  {struct('series', {series})});
if !receipt.atomic || receipt.output_count != 2
  error('Atomic publication failed to confirm two source Datasets.');
endif

% Read back through the canonical public Dataset API, not the storage files.
for k = 1:2
  result = gxtxt_api_call(dataset_api, 'read_range', ...
    {ids{k}, {'time_s', 'voltage_V'}, 0, sample_count});
  assert(numel(result.time_s.values) == sample_count);
  assert(max(abs(result.time_s.values(:) - time_s)) < 1e-12);
  assert(max(abs(result.voltage_V.values(:) - all_values{k})) < 1e-10);
endfor

fprintf('PASS: 2 canonical synthetic source Datasets published.\n');
fprintf('Sampling: fs=%g Hz, N=%d, duration=%.3f s, df=%.3f Hz.\n', ...
        sample_rate_hz, sample_count, ...
        sample_count/sample_rate_hz, sample_rate_hz/sample_count);
L13_01_Debug_Wrong_Sampling_Rate.m
% Lesson 13 - An intentional sampling-frequency error for the debugger.
% Course: GNU Octave with GX-TXT | DEV112 Release 2 + P008
% GitHub commit: 17ff2a7f93de0612015a873e626f87dbeb56b6a2
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Run after L13_00. Set a breakpoint at the marked line.
% This program MUST fail its scientific frequency validation.
% It publishes no Dataset and creates no plot.

dataset_api = 'CANONICAL_DATASET_API_v2';
numeric_api = 'NUMERIC_API_v1';
gxtxt_api_require({dataset_api, numeric_api});
assert(gxtxt_api_has_operation(dataset_api, 'read_range'));
assert(gxtxt_api_has_operation(numeric_api, 'fft'));
assert(gxtxt_api_has_operation(numeric_api, 'frequencyGrid'));
assert(gxtxt_api_has_operation(numeric_api, 'oneSided'));

n = 1024;
data = gxtxt_api_call(dataset_api, 'read_range', ...
  {'lesson13_signal_coherent', {'time_s', 'voltage_V'}, 0, n});
t = data.time_s.values(:);
v = data.voltage_V.values(:);
if numel(t) != n || numel(v) != n || any(diff(t) <= 0)
  error('Missing or invalid source record: run L13_00 first.');
endif

measured_step_s = median(diff(t));
correct_sample_rate_hz = 1 / measured_step_s;

% INTENTIONAL ERROR: the assumed sample rate is half the true value.
% Fourier coefficients remain unchanged, but every displayed Hz value halves.
wrong_sample_rate_hz = 512;
raw_fft = gxtxt_api_call(numeric_api, 'fft', ...
  {v - mean(v), struct('nfft', n, 'normalization', 'backward')});
wrong_grid = gxtxt_api_call(numeric_api, 'frequencyGrid', ...
  {wrong_sample_rate_hz, n, struct('representation', 'one_sided')});
positive = gxtxt_api_call(numeric_api, 'oneSided', ...
  {raw_fft.real, raw_fft.imaginary, struct('scaling', 'amplitude')});
amplitude_v = abs(complex(positive.real(:),positive.imaginary(:))) / n;
frequency_hz = wrong_grid.frequency(:);

[~, idx] = max(amplitude_v(2:end));
dominant_frequency_hz = frequency_hz(idx + 1);
wrong_df_hz = wrong_grid.df;

% BREAKPOINT: inspect correct_sample_rate_hz, wrong_sample_rate_hz,
% measured_step_s, dominant_frequency_hz, wrong_df_hz, frequency_hz.
fprintf('Measured sample rate: %.1f Hz; assumed: %.1f Hz.\n', ...
        correct_sample_rate_hz, wrong_sample_rate_hz);
fprintf('Incorrect dominant peak: %.2f Hz (expected 50.00 Hz).\n', ...
        dominant_frequency_hz);

% Expected FAILED Job: a scientifically invalid frequency axis is rejected.
if abs(dominant_frequency_hz - 50.0) > 0.5
  error('GXTXT:Lesson13:WrongSamplingRate', ...
        'FFT frequency axis is wrong: verify dt and fs = 1/dt.');
endif
error('Unexpected success: intentional sampling-rate error escaped detection.');
L13_02_FFT_Spectrum_Correct.m
% Lesson 13 - Public FFT, frequency grids, windows and persistent plots.
% Course: GNU Octave with GX-TXT | DEV112 Release 2 + P008
% GitHub release: https://github.com/giuxlab-hub/GX-TXT/releases/tag/v0.9.8.10-dev-112-r2-p008
% Pinned commit: 17ff2a7f93de0612015a873e626f87dbeb56b6a2
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Execute after L13_00 in the same fresh managed GX-TXT Session.
% All Dataset, numerical-service and plot calls use public GX-TXT APIs.

dataset_api = 'CANONICAL_DATASET_API_v2';
numeric_api = 'NUMERIC_API_v1';
publication_api = 'DATASET_PUBLICATION_API_v2';
plot_api = 'PLOT_DATASET_API_v4';
gxtxt_api_require({dataset_api, numeric_api, publication_api, plot_api});
required = {
  dataset_api, 'list'; dataset_api, 'read_range';
  numeric_api, 'fft'; numeric_api, 'ifft';
  numeric_api, 'frequencyGrid'; numeric_api, 'oneSided';
  numeric_api, 'detrend'; numeric_api, 'window';
  publication_api, 'publish_series_batch';
  plot_api, 'new_spec'; plot_api, 'validate_spec';
  plot_api, 'upsert_plot'; plot_api, 'render'; plot_api, 'artifacts'
};
for k = 1:rows(required)
  if !gxtxt_api_has_operation(required{k, 1}, required{k, 2})
    error('Missing GX-TXT public operation: %s/%s.', ...
          required{k, 1}, required{k, 2});
  endif
endfor

% Step 1: read and verify both canonical sample records.
n = 1024;
source_ids = {'lesson13_signal_coherent', 'lesson13_signal_offbin'};
dataset_ids = gxtxt_api_call(dataset_api, 'list', {});
signals = cell(1, 2);
time_s = [];
for k = 1:2
  if !any(strcmp(dataset_ids, source_ids{k}))
    error('Missing %s: run L13_00 in this Session first.', source_ids{k});
  endif
  data = gxtxt_api_call(dataset_api, 'read_range', ...
    {source_ids{k}, {'time_s', 'voltage_V'}, 0, n});
  t = data.time_s.values(:);
  v = data.voltage_V.values(:);
  if numel(t) != n || numel(v) != n || ...
     !all(isfinite(t)) || !all(isfinite(v))
    error('Source Dataset contains incomplete or nonfinite samples.');
  endif
  if k == 1
    time_s = t;
  elseif max(abs(time_s - t)) > 1e-12
    error('Source signals use different sample-time grids.');
  endif
  signals{k} = v;
endfor

% Step 2: derive fs from the actual Dataset time axis.
sample_steps = diff(time_s);
sample_step_s = median(sample_steps);
if sample_step_s <= 0 || ...
   max(abs(sample_steps - sample_step_s)) > 1e-10 * sample_step_s
  error('FFT requires a strictly uniform sample-time grid.');
endif
sample_rate_hz = 1 / sample_step_s;
record_duration_s = n * sample_step_s;
nyquist_hz = sample_rate_hz / 2;
grid = gxtxt_api_call(numeric_api, 'frequencyGrid', ...
  {sample_rate_hz, n, struct('representation', 'one_sided')});
frequency_hz = grid.frequency(:);
if length(frequency_hz) != n/2 + 1 || ...
   abs(grid.df - 1.0) > 1e-10 || abs(grid.nyquist - 512) > 1e-9
  error('Public FFT grid differs from the expected 1-Hz frequency bins.');
endif

% Step 3: remove the mean and compute the coherent rectangular spectrum.
centered = gxtxt_api_call(numeric_api, 'detrend', ...
  {signals{1}, struct('method', 'mean')});
rect_window = gxtxt_api_call(numeric_api, 'window', ...
  {'rectangular', n, struct('sampling', 'periodic')});
coherent_fft = gxtxt_api_call(numeric_api, 'fft', ...
  {centered.values(:) .* rect_window.values(:), ...
   struct('nfft', n, 'normalization', 'backward')});
coherent_positive = gxtxt_api_call(numeric_api, 'oneSided', ...
  {coherent_fft.real, coherent_fft.imaginary, ...
   struct('scaling', 'amplitude', 'nfft', n)});
coherent_amp_v = abs(complex(coherent_positive.real(:), ...
  coherent_positive.imaginary(:))) / (n * rect_window.coherent_gain);

% FFT indices start at 1 in Octave: frequency 50 Hz corresponds to index 51.
a50_v = coherent_amp_v(51);
a120_v = coherent_amp_v(121);
if abs(a50_v - 1.25) > 1e-9 || abs(a120_v - 0.50) > 1e-9
  error('Recovered coherent tone amplitudes differ from the known source.');
endif

% Step 4: demonstrate off-bin leakage and periodic Hann-window correction.
offbin_centered = gxtxt_api_call(numeric_api, 'detrend', ...
  {signals{2}, struct('method', 'mean')});
hann_window = gxtxt_api_call(numeric_api, 'window', ...
  {'hann', n, struct('sampling', 'periodic')});
rect_fft = gxtxt_api_call(numeric_api, 'fft', ...
  {offbin_centered.values(:), ...
   struct('nfft', n, 'normalization', 'backward')});
hann_fft = gxtxt_api_call(numeric_api, 'fft', ...
  {offbin_centered.values(:) .* hann_window.values(:), ...
   struct('nfft', n, 'normalization', 'backward')});
rect_positive = gxtxt_api_call(numeric_api, 'oneSided', ...
  {rect_fft.real, rect_fft.imaginary, ...
   struct('scaling', 'amplitude', 'nfft', n)});
hann_positive = gxtxt_api_call(numeric_api, 'oneSided', ...
  {hann_fft.real, hann_fft.imaginary, ...
   struct('scaling', 'amplitude', 'nfft', n)});
rect_amp_v = abs(complex(rect_positive.real(:), ...
  rect_positive.imaginary(:))) / n;
hann_amp_v = abs(complex(hann_positive.real(:), ...
  hann_positive.imaginary(:))) / (n * hann_window.coherent_gain);
if rect_amp_v(71) < hann_amp_v(71) * 10
  error('The expected far-bin Hann leakage reduction was not observed.');
endif

% Step 5: verify FFT/IFFT reversibility through the public Numeric API.
inverse = gxtxt_api_call(numeric_api, 'ifft', ...
  {coherent_fft.real, coherent_fft.imaginary, ...
   struct('nfft', n, 'normalization', 'backward')});
reconstructed_v = inverse.real(:) + mean(signals{1});
inverse_max_error_v = max(abs(reconstructed_v - signals{1}));
if inverse_max_error_v > 1e-10 || ...
   max(abs(inverse.imaginary(:))) > 1e-10
  error('Public FFT/IFFT reconstruction failed.');
endif
fprintf('Correct fs=%.1f Hz, N=%d, duration=%.3f s, df=%.1f Hz.\n', ...
        sample_rate_hz, n, record_duration_s, grid.df);
fprintf('Nyquist=%.1f Hz; recovered amplitudes: 50 Hz=%.6f V, 120 Hz=%.6f V.\n', ...
        nyquist_hz, a50_v, a120_v);
fprintf('Hann coherent gain=%.6f; reconstruction error=%.3g V.\n', ...
        hann_window.coherent_gain, inverse_max_error_v);

% Step 6: atomically publish the derived spectral and time-domain results.
derived_ids = {'lesson13_coherent_amplitude', ...
               'lesson13_offbin_rectangular', ...
               'lesson13_offbin_hann', ...
               'lesson13_ifft_reconstruction'};
for k = 1:numel(derived_ids)
  if any(strcmp(dataset_ids, derived_ids{k}))
    error('Derived Dataset exists: %s. Start a fresh Session.', derived_ids{k});
  endif
endfor
frequency_var = struct('variable_id', 'frequency_hz', ...
  'name', 'frequency_hz', 'display_label', 'Fourier frequency', ...
  'unit', 'Hz', 'dtype', 'float64', 'value_kind', 'number', ...
  'semantic_source', 'plugin');
time_var = struct('variable_id', 'time_s', ...
  'name', 'time_s', 'display_label', 'Elapsed time', ...
  'unit', 's', 'dtype', 'float64', 'value_kind', 'number', ...
  'semantic_source', 'plugin');
amplitude_var = struct('variable_id', 'amplitude_V', ...
  'name', 'amplitude_V', 'display_label', 'One-sided peak amplitude', ...
  'unit', 'V', 'dtype', 'float64', 'value_kind', 'number', ...
  'semantic_source', 'plugin');
reconstruction_var = struct('variable_id', 'voltage_V', ...
  'name', 'voltage_V', 'display_label', 'Inverse Fourier reconstruction', ...
  'unit', 'V', 'dtype', 'float64', 'value_kind', 'number', ...
  'semantic_source', 'plugin');
x_values = {frequency_hz, frequency_hz, frequency_hz, time_s};
y_values = {coherent_amp_v, rect_amp_v, hann_amp_v, reconstructed_v};
x_vars = {frequency_var, frequency_var, frequency_var, time_var};
y_vars = {amplitude_var, amplitude_var, amplitude_var, reconstruction_var};
descriptions = {'Coherent rectangular one-sided amplitude spectrum', ...
  'Off-bin rectangular spectrum with leakage', ...
  'Off-bin periodic Hann spectrum with coherent-gain correction', ...
  'Inverse FFT reconstruction of the coherent time signal'};
series = cell(1, numel(derived_ids));
for k = 1:numel(derived_ids)
  metadata = struct();
  metadata.('analysis.synthetic') = true;
  metadata.('analysis.sample_rate_hz') = sample_rate_hz;
  metadata.('analysis.nfft') = n;
  metadata.('analysis.frequency_resolution_hz') = grid.df;
  metadata.('analysis.nyquist_hz') = grid.nyquist;
  metadata.('analysis.method') = descriptions{k};
  series{k} = struct('dataset_id', derived_ids{k}, ...
    'contract', 'table.generic', 'storage', 'auto', ...
    'x_values', x_values{k}, 'y_values', y_values{k}, ...
    'x_variable', x_vars{k}, 'y_variable', y_vars{k}, ...
    'producer_version', '1.0.0', ...
    'source', 'GX-TXT GNU Octave Lesson 13', ...
    'source_dataset_ids', {source_ids}, ...
    'provenance', 'Published from public NUMERIC_API_v1 Fourier transforms', ...
    'notes', descriptions{k}, 'structured_metadata', metadata);
endfor
receipt = gxtxt_api_call(publication_api, 'publish_series_batch', ...
  {struct('series', {series})});
if !receipt.atomic || receipt.output_count != numel(derived_ids)
  error('Atomic publication did not confirm four derived Datasets.');
endif
for k = 1:numel(derived_ids)
  recovered = gxtxt_api_call(dataset_api, 'read_range', ...
    {derived_ids{k}, {x_vars{k}.variable_id, y_vars{k}.variable_id}, ...
     0, numel(y_values{k})});
  saved = recovered.(y_vars{k}.variable_id).values(:);
  if length(saved) != length(y_values{k}) || ...
     max(abs(saved - y_values{k})) > 1e-9
    error('Public Dataset read-back mismatch: %s.', derived_ids{k});
  endif
endfor

% Step 7: build three persistent GX-TXT Plot Dataset v4 graphics.
time_plot = gxtxt_api_call(plot_api, 'new_spec', ...
  {'plot.dataset.xy', 'Lesson 13: Two-tone signals'});
tp = time_plot.panels{1};
tp.id = 'two_tone_time';
tp.title = 'Synthetic coherent and off-bin voltage signals';
tp.axes = struct('x', struct('label', 'Time [s]', 'scale', 'linear'), ...
  'y_left', struct('label', 'Voltage [V]', 'scale', 'linear'));
tp.series = {
  struct('id', 'coherent_time', 'label', 'Coherent 50 + 120 Hz', ...
    'dataset_id', source_ids{1}, 'x_variable_id', 'time_s', ...
    'y_variable_id', 'voltage_V', 'axis', 'left', 'kind', 'line'),
  struct('id', 'offbin_time', 'label', 'Off-bin 50.5 + 120 Hz', ...
    'dataset_id', source_ids{2}, 'x_variable_id', 'time_s', ...
    'y_variable_id', 'voltage_V', 'axis', 'left', 'kind', 'line')
};
time_plot.panels = {tp};
if !gxtxt_api_call(plot_api, 'validate_spec', {time_plot})
  error('Time-domain PlotSpec failed validation.');
endif
time_ref = gxtxt_api_call(plot_api, 'upsert_plot', ...
  {'lesson13_two_tone_time', time_plot});
gxtxt_api_call(plot_api, 'render', {time_ref});
time_artifacts = gxtxt_api_call(plot_api, 'artifacts', {time_ref});

spectrum_plot = gxtxt_api_call(plot_api, 'new_spec', ...
  {'plot.dataset.xy', 'Lesson 13: Coherent FFT amplitude'});
sp = spectrum_plot.panels{1};
sp.id = 'coherent_fft';
sp.title = 'One-sided spectrum: 50 and 120 Hz';
sp.axes = struct('x', struct('label', 'Frequency [Hz]', 'scale', 'linear'), ...
  'y_left', struct('label', 'Peak amplitude [V]', 'scale', 'linear'));
sp.series = {struct('id', 'coherent_fft', ...
  'label', 'Coherent rectangular spectrum', ...
  'dataset_id', derived_ids{1}, 'x_variable_id', 'frequency_hz', ...
  'y_variable_id', 'amplitude_V', 'axis', 'left', 'kind', 'line')};
spectrum_plot.panels = {sp};
if !gxtxt_api_call(plot_api, 'validate_spec', {spectrum_plot})
  error('Coherent-spectrum PlotSpec failed validation.');
endif
spectrum_ref = gxtxt_api_call(plot_api, 'upsert_plot', ...
  {'lesson13_coherent_spectrum', spectrum_plot});
gxtxt_api_call(plot_api, 'render', {spectrum_ref});
spectrum_artifacts = gxtxt_api_call(plot_api, 'artifacts', {spectrum_ref});

leakage_plot = gxtxt_api_call(plot_api, 'new_spec', ...
  {'plot.dataset.xy', 'Lesson 13: Leakage and Hann window'});
lp = leakage_plot.panels{1};
lp.id = 'fft_leakage';
lp.title = 'Off-bin 50.5 Hz: rectangular versus periodic Hann';
lp.axes = struct('x', struct('label', 'Frequency [Hz]', 'scale', 'linear'), ...
  'y_left', struct('label', 'Peak amplitude [V]', 'scale', 'linear'));
lp.series = {
  struct('id', 'rectangular', 'label', 'Rectangular window', ...
    'dataset_id', derived_ids{2}, 'x_variable_id', 'frequency_hz', ...
    'y_variable_id', 'amplitude_V', 'axis', 'left', 'kind', 'line'),
  struct('id', 'hann', 'label', 'Periodic Hann window', ...
    'dataset_id', derived_ids{3}, 'x_variable_id', 'frequency_hz', ...
    'y_variable_id', 'amplitude_V', 'axis', 'left', 'kind', 'line')
};
leakage_plot.panels = {lp};
if !gxtxt_api_call(plot_api, 'validate_spec', {leakage_plot})
  error('Leakage PlotSpec failed validation.');
endif
leakage_ref = gxtxt_api_call(plot_api, 'upsert_plot', ...
  {'lesson13_leakage_windows', leakage_plot});
gxtxt_api_call(plot_api, 'render', {leakage_ref});
leakage_artifacts = gxtxt_api_call(plot_api, 'artifacts', {leakage_ref});

fprintf('PASS: 4 derived Datasets, 3 native plots, public FFT/IFFT checks.\n');
disp(time_artifacts);
disp(spectrum_artifacts);
disp(leakage_artifacts);

#analisi spettrale #campionamento #Dataset scientifici #debugger #elaborazione segnali #FFT #finestra Hann #GNU Octave #GX-TXT #leakage spettrale #Nyquist #trasformata di Fourier

Altre tappe del progetto

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *