Un circuito elettrico fornisce un esempio concreto di come i numeri complessi diventino strumenti di calcolo scientifico. In questa lezione simuliamo un circuito RLC serie, calcoliamo la risposta armonica, ricaviamo i diagrammi di Bode di modulo e fase e impariamo a individuare un errore di unità mediante il debugger Octave. I dati scientifici vengono pubblicati e visualizzati nel framework GX-TXT usando esclusivamente API pubbliche.

Obiettivi e prerequisiti

Alla fine sapremo costruire vettori a spaziatura logaritmica, rappresentare impedenze con numeri complessi, effettuare operazioni elemento per elemento, passare dal rapporto di tensione ai decibel, calcolare la fase in gradi e verificare un modello rispetto a una soluzione analitica. Richiamiamo vettori e matrici (Lezione 03), funzioni e controlli (Lezione 04), Dataset (Lezioni 05–07), grafici (Lezione 08), debugging (Lezioni 09–14) e numeri complessi nell’analisi numerica.

Collegamento con le prime quattordici lezioni

Le Lezioni 01–04 hanno introdotto Script Bridge, tipi, numeri complessi, vettori e operatori. Le Lezioni 05–08 hanno spiegato l’identificazione, la lettura, la pubblicazione e la visualizzazione dei Dataset; le Lezioni 09–12 hanno aggiunto verifiche scientifiche, residui e algebra lineare. Nella Lezione 13 abbiamo studiato il modulo e la fase dei coefficienti FFT; nella Lezione 14 abbiamo risolto equazioni differenziali nel tempo.

Concetto già studiatoNovità scientifica della Lezione 15
Numeri complessi e 1i (02, 12–13)Fasori e impedenze di un circuito
Vettori e operazioni elemento per elemento (02–03)Risposta valutata a molte frequenze
abs e angle sui coefficienti FFT (13)Modulo e fase del rapporto uscita/ingresso
Equazioni differenziali (04, 14)Regime armonico stazionario anziché transitorio
Debugger e controlli (08–14)Errore di unità fisica che non causa un errore sintattico
Dataset canonici e Plot Dataset v4 (05–12)Diagrammi di Bode persistenti con frequenza logaritmica

Il problema nuovo non consiste nella sintassi di un vettore, ma nel passaggio da leggi fisiche nel tempo a una funzione complessa della frequenza.

Il circuito: R, L e C in serie

Colleghiamo in serie una resistenza \(R\), un’induttanza \(L\) e un condensatore \(C\). Applichiamo una tensione sinusoidale e scegliamo come uscita la tensione ai capi della resistenza. Questa scelta è essenziale: una tensione misurata ai capi del condensatore o dell’induttore avrebbe una diversa funzione di trasferimento.

Per l’esperimento impostiamo:

GrandezzaValoreUnità
Resistenza \(R\)20\(\Omega\)
Induttanza \(L\)10mH
Capacità \(C\)1\(\mu\mathrm F\)
Frequenze100–31623Hz
Campioni402, incluso \(f_0\)—

Consideriamo componenti ideali, generatore ideale e regime sinusoidale stazionario. Il modello non incorpora resistenza serie dell’induttore, perdite dielettriche, capacità parassite o incertezze dei componenti.

Perché proprio un passa-banda?

A frequenza molto bassa il condensatore presenta una reattanza di grande modulo: nella serie passa poca corrente e la tensione sulla resistenza è piccola. A frequenza molto alta è l’induttore a opporsi alla variazione di corrente. Fra questi due estremi esiste una frequenza in cui le reattanze si compensano, la corrente diventa massima e, per il circuito ideale, la tensione resistiva raggiunge quella di ingresso.

Il risultato dipende dalla scelta dell’uscita ai capi di R. Misurare ai capi di L o C produrrebbe una funzione di trasferimento differente. Anche la polarità è significativa: invertire i morsetti dell’uscita cambia il segno del rapporto complesso e ne sposta la fase di 180°, lasciando invariato il modulo.

Impedenza complessa e funzione di trasferimento

L’impedenza è una grandezza complessa. L’unità immaginaria \(j\) è rappresentata in Octave da 1i. Per una pulsazione \(\omega=2\pi f\):

\[
Z_R=R,\qquad Z_L=j\omega L,\qquad
Z_C=\frac{1}{j\omega C}.
\]

La somma delle tre impedenze è

\[
Z_{\mathrm{tot}}=R+j\left(\omega L-\frac{1}{\omega C}\right).
\]

Poiché la corrente attraversa tutti gli elementi, il rapporto fra tensione resistiva e tensione applicata è

\[
H(j\omega)=\frac{V_R}{V_{\mathrm{in}}}
=\frac{R}{R+j(\omega L-1/(\omega C))}.
\]

Il valore assoluto di \(H\) fornisce il guadagno in ampiezza, non quello in potenza. Poiché \(R\) è positiva e le reattanze si cancellano alla risonanza, \(|H|\le 1\): questo sistema ha una risposta passa-banda.

Dai segnali sinusoidali ai fasori

Nella Lezione 13 abbiamo incontrato la fase dei coefficienti di Fourier; qui introduciamo il fasore, numero complesso che rappresenta ampiezza e fase di una sinusoide a frequenza fissata. Usando la convenzione temporale \(e^{j\omega t}\), scriviamo

\[
v(t)=\operatorname{Re}\{\widehat V e^{j\omega t}\},\qquad
i(t)=\operatorname{Re}\{\widehat I e^{j\omega t}\}.
\]

I fasori \(\widehat V\) e \(\widehat I\) non sono campioni nel tempo. Con la convenzione indicata, derivare rispetto al tempo equivale a moltiplicare per \(j\omega\):

\[
\frac{d}{dt}(\widehat I e^{j\omega t})=j\omega\widehat I e^{j\omega t}.
\]

Dalle leggi dell’induttore \(v_L=L\,di/dt\) e del condensatore \(i_C=C\,dv_C/dt\) ricaviamo allora \(\widehat V_L=j\omega L\widehat I\) e \(\widehat V_C=\widehat I/(j\omega C)\). La relazione differenziale si è trasformata in un’equazione algebrica. Questo passaggio è valido nel regime sinusoidale stazionario, non durante il transitorio di accensione.

Le impedenze si misurano in ohm. Occorre convertire \(10\ \mathrm{mH}=0{,}010\ \mathrm H\) e \(1\ \mu\mathrm F=10^{-6}\ \mathrm F\). Infatti \(\omega L\), con \(\omega\) in rad/s, ha unità di ohm; altrettanto vale per \(1/(\omega C)\). La correttezza delle unità è indipendente da quella della sintassi Octave.

Derivazione della funzione di trasferimento

La legge di Kirchhoff fornisce \(\widehat V_{\rm in}=\widehat I(Z_R+Z_L+Z_C)\). Sulla resistenza vale \(\widehat V_R=\widehat I R\). Dividendo membro a membro:

\[
H(j\omega)=\frac{\widehat V_R}{\widehat V_{\rm in}}
=\frac{R}{R+jX(\omega)},\qquad
X(\omega)=\omega L-\frac1{\omega C}.
\]

La funzione di trasferimento è quindi il rapporto fra due fasori alla stessa frequenza: il modulo misura il rapporto fra le ampiezze e l’argomento misura la fase dell’uscita rispetto all’ingresso. Ponendo \(X\) reale otteniamo una verifica analitica indipendente:

\[
|H|=\frac{R}{\sqrt{R^2+X^2}},\qquad
\arg H=-\operatorname{atan2}(X,R).
\]

I valori seguenti sono calcoli teorici, non misure:

FrequenzaReattanza \(X\)\(|H|\)GuadagnoFase
1000 Hz−96,32 \(\Omega\)0,2033−13,84 dB+78,27°
1591,549 Hz0 \(\Omega\)1,00000 dB0°
2500 Hz+93,42 \(\Omega\)0,2093−13,58 dB−77,92°

La fase è positiva sotto risonanza, dove la reattanza netta è capacitiva, e negativa sopra risonanza, dove è induttiva. La variazione di segno ha una causa fisica, non dipende dal disegno del grafico.

Numeri complessi, vettorizzazione e asse logaritmico

In GNU Octave generiamo un vettore con logspace e lo trasformiamo in colonna usando l’apice di trasposizione. Uniamo al reticolo il valore esatto di risonanza, così non confondiamo il massimo campionato con quello teorico.

R = 20;
L = 10e-3;
C = 1e-6;
f0 = 1/(2*pi*sqrt(L*C));
frequency_hz = sort([logspace(2,4.5,401)';f0]);
omega = 2*pi*frequency_hz;
z_total = R + 1i*omega*L + 1./(1i*omega*C);
H = R ./ z_total;

Le operazioni ./ sono divisioni elemento per elemento: ogni frequenza produce una diversa impedenza. L’operatore /, invece, può indicare una divisione matriciale e non è intercambiabile con ./. Analogamente .^ indica la potenza elemento per elemento.

Le frequenze sono distribuite su una scala logaritmica: la distanza grafica fra 100 e 1000 Hz è la stessa che fra 1000 e 10000 Hz. logspace definisce il campionamento; la proprietà scale=‘log’ del Plot Dataset definisce come visualizzarlo. Si tratta di due operazioni distinte.

Campionamento logaritmico: quale istruzione fa che cosa?

La funzione logspace(2,4.5,401) genera 401 frequenze da \(10^2\) a \(10^{4,5}\) Hz, con passo costante nel logaritmo, non in hertz. Una decade è un intervallo in cui la frequenza cresce di un fattore dieci: il nostro intervallo contiene 2,5 decadi. La trasposizione ’ produce un vettore colonna reale, la concatenazione aggiunge \(f_0\) e sort ripristina l’ordine crescente.

frequency_hz = sort([logspace(2,4.5,401)'; f0]);
assert(iscolumn(frequency_hz));
assert(numel(frequency_hz) == 402);
assert(all(diff(frequency_hz) > 0));

Inserire il valore teorico di risonanza evita di scambiare il massimo di 401 punti campionati per il massimo fisico esatto. Il campionamento stabilisce dove calcolare la risposta, mentre l’opzione scale=‘log’ nel Plot Dataset stabilisce come mostrarla. Cambiare la scala del grafico non modifica i Dataset.

Perché 20 e non 10 davanti al logaritmo?

Il decibel esprime un rapporto. Per le potenze si utilizza \(10\log_{10}(P_2/P_1)\); per un rapporto di ampiezze di tensione come \(V_R/V_{\rm in}\) si utilizza \(20\log_{10}|V_R/V_{\rm in}|\). Il coefficiente 20 è coerente con una potenza proporzionale al quadrato della tensione, quando il riferimento resistivo è lo stesso.

Rapporto fra ampiezzeGuadagno in dBInterpretazione
10Stessa ampiezza
\(1/\sqrt2\approx0{,}7071\)−3,0103Metà potenza, a riferimento resistivo invariato
0,5−6,0206Ampiezza dimezzata

Un guadagno in dB negativo non significa tensione negativa: significa attenuazione. Il Bode del modulo ha asse X logaritmico in hertz e asse Y numericamente lineare in dB; i decibel non richiedono un secondo logaritmo sul grafico.

Fase di un trasferimento e fase FFT

Nella Lezione 13 angle descriveva la fase di un coefficiente FFT. Qui \(\arg H=\arg\widehat V_R-\arg\widehat V_{\rm in}\) è una differenza di fase fra ingresso e uscita alla stessa frequenza. La funzione è la stessa; il significato fisico no.

angle restituisce radianti. unwrap può rimuovere salti artificiali di \(2\pi\) fra campioni vicini, ma non converte i radianti in gradi e non corregge un modello sbagliato. In questo circuito la fase resta tra +90° e −90°, quindi non attraversa un salto di 360°: l’operazione di unwrapping è qui una precauzione, non la ragione della curva continua.

Decibel, fase e diagrammi di Bode

Il modulo della funzione di trasferimento è abs(H). Il diagramma di Bode del modulo, per un rapporto di ampiezze di tensione, impiega

\[
G_{\mathrm{dB}}(f)=20\log_{10}|H(j2\pi f)|.
\]

Non usare \(10\log_{10}|H|\): il coefficiente 10 è quello dei rapporti di potenza, e si applica al quadrato dell’ampiezza solo quando le impedenze di riferimento sono appropriate.

La fase è l’argomento complesso:

\[
\varphi(f)=\arg H(j2\pi f)\,\frac{180}{\pi}.
\]

gain_linear = abs(H);
gain_db = 20*log10(gain_linear);
phase_deg = unwrap(angle(H))*180/pi;

angle restituisce radianti. unwrap corregge eventuali salti artificiali di \(2\pi\) nella rappresentazione della fase. In questo circuito la fase continua attraversa lo zero alla risonanza; la conversione in gradi resta comunque necessaria.

Frequenza di risonanza, banda e fattore Q

La risonanza si verifica quando le reattanze induttiva e capacitiva si compensano:

\[
f_0=\frac{1}{2\pi\sqrt{LC}}
\approx1591{,}549\ \mathrm{Hz}.
\]

Alla risonanza il denominatore di \(H\) è reale: il guadagno resistivo è 1 (0 dB) e la fase è 0°. Il fattore di qualità per il circuito serie è

\[
Q=\frac{1}{R}\sqrt{\frac{L}{C}}=5.
\]

Le frequenze di taglio a \(-3{,}0103\) dB soddisfano \(|H|=1/\sqrt{2}\). Con \(R,L,C>0\), si ricavano:

\[
\omega_1=\frac{-R+\sqrt{R^2+4L/C}}{2L},
\qquad
\omega_2=\frac{R+\sqrt{R^2+4L/C}}{2L}.
\]

Ne derivano \(f_1\approx1440{,}332\ \mathrm{Hz}\), \(f_2\approx1758{,}642\ \mathrm{Hz}\), \(\Delta f=f_2-f_1=R/(2\pi L)\approx318{,}310\ \mathrm{Hz}\). Al primo taglio la fase vale +45° e al secondo −45°; sotto risonanza il circuito è prevalentemente capacitivo, sopra prevalentemente induttivo.

Controllo di correttezza: \(\sqrt{f_1f_2}=f_0\) e \(Q=f_0/\Delta f\). Il controllo sulla risonanza e quello sulla larghezza di banda sono indipendenti dalla modalità di disegno del grafico.

Dalle frequenze di mezza potenza al fattore di qualità

A parità di riferimento resistivo, la potenza dissipata è proporzionale a \(|H|^2\). Alle due frequenze di mezza potenza chiediamo \(|H|^2=1/2\). Sostituendo la formula del modulo:

\[
\frac{R^2}{R^2+X^2}=\frac12
\quad\Longrightarrow\quad |X|=R.
\]

Sotto risonanza si ha \(X=-R\), sopra \(X=+R\). Risolvendo queste due equazioni in \(\omega\) si ricavano esattamente le formule di \(\omega_1\) e \(\omega_2\) esposte in precedenza. Le frequenze di taglio non sono scelte arbitrarie sul grafico. La larghezza di banda \(\Delta f=f_2-f_1\) non va confusa con \(f_0\).

Il fattore di qualità \(Q\) descrive la selettività della risonanza. La sua interpretazione energetica confronta l’energia massima immagazzinata negli elementi reattivi con l’energia dissipata per ciclo. Per il circuito serie ideale \(Q=\omega_0L/R=f_0/\Delta f\). Aumentando \(R\), a \(L\) e \(C\) costanti, la banda si allarga e \(Q\) diminuisce; il massimo ideale ai capi di R resta però 0 dB.

Possiamo infine dedurre gli andamenti asintotici lontano dalla risonanza:

\[
f\ll f_0:\quad |H|\simeq R\omega C
\quad(+20\ \mathrm{dB/decade}),
\]

\[
f\gg f_0:\quad |H|\simeq \frac{R}{\omega L}
\quad(-20\ \mathrm{dB/decade}).
\]

In un intervallo sufficientemente lontano dal picco, moltiplicare la frequenza per dieci aumenta il guadagno di circa 20 dB a bassa frequenza e lo diminuisce di circa 20 dB ad alta frequenza. Non si tratta di rette esatte vicino alla risonanza.

Primo script: una soluzione analitica di riferimento

Lo script L15_00_Prepare_RLC_Reference.m calcola il guadagno e la fase mediante due espressioni reali indipendenti dalla divisione complessa usata successivamente:

\[
|H|=\frac{R}{\sqrt{R^2+(\omega L-1/\omega C)^2}},
\qquad
\varphi=-\operatorname{atan2}(\omega L-1/\omega C,R).
\]

Questi risultati non sono misure sperimentali: sono dati sintetici analitici. Lo script pubblica due Dataset, uno per il guadagno in dB e uno per la fase in gradi, entrambi con variabile indipendente frequency_hz e metadati scientifici che dichiarano R, L, C e la provenienza.

Perché prepariamo un riferimento con formule diverse

Il programma 00 calcola il modulo mediante una radice quadrata e la fase mediante atan2, usando espressioni reali. Il programma 02 usa invece la divisione complessa e le funzioni abs e angle. Il confronto fra due formulazioni matematicamente equivalenti ma implementate diversamente è più affidabile della ripetizione dello stesso calcolo.

Questo confronto verifica la coerenza numerica del modello, non la sua accuratezza sperimentale: entrambi i programmi assumono componenti ideali. Distinguiamo correttezza sintattica, correttezza matematica e adeguatezza del modello fisico; il successo di uno di questi controlli non garantisce gli altri.

Secondo script: debugging di un errore di unità

Lo script L15_01_Debug_Phase_Units.m ricostruisce correttamente la funzione di trasferimento, ma contiene intenzionalmente:

phase_deg_wrong = angle(transfer);

Il nome della variabile suggerisce gradi, mentre il risultato è in radianti. È un errore pericoloso perché i valori sono regolari e possono essere rappresentati graficamente: il programma non si arresterebbe da solo. Confrontiamo quindi la serie con il riferimento analitico. Lo scostamento massimo risulta molto superiore alla soglia scelta, perciò il Job termina con l’errore atteso GXTXT:Lesson15:PhaseUnits.

Dal menu Run → Debug Session script impostiamo un breakpoint sul commento BREAKPOINT. Osserviamo phase_deg_wrong, expected_phase_deg, maximum_phase_error_deg e la frequenza dell’ultimo campione. Premendo Continue vediamo scattare il controllo scientifico. Il Job fallito è un risultato didattico previsto, non un difetto del framework.

Script GNU Octave nel visualizzatore GX-TXT con la riga angle(transfer) che restituisce radianti anziché gradi.
Un errore scientifico da individuare: angle() restituisce radianti, non gradi.

Il debugger individua un difetto di significato fisico

Il numero \(\pi/2\) corrisponde a circa 1,571 radianti, ma a 90 gradi. La riga intenzionalmente errata assegna angle(transfer) a una variabile denominata phase_deg_wrong: i numeri sono regolari e disegnabili, ma l’unità dichiarata è falsa. Il debugger permette di osservare la discrepanza prima della pubblicazione.

Al breakpoint confrontiamo le due fasi allo stesso indice di frequenza. Prima controlliamo il significato delle variabili, poi la grandezza numerica: vicino a una fase teorica di 90° comparirà un valore intorno a 1,57. La correzione è unwrap(angle(transfer))*180/pi, non il cambio dell’etichetta dell’asse Y. Cambiare soltanto l’unità dichiarata nasconderebbe l’errore invece di correggerlo.

Il Job fallisce appositamente quando i numeri non possiedono le unità che lo script intende pubblicare. È una verifica scientifica eseguibile, analoga ai controlli di rango della Lezione 12 e di bilancio di materia della Lezione 14.

Terzo script: calcolo corretto e verifica indipendente

Nel file L15_02_RLC_Bode_Correct.m usiamo 1i, abs, angle, unwrap, log10 e operatori vettorizzati per ottenere la risposta complessa. Il risultato è confrontato con i Dataset analitici mediante un errore massimo assoluto per modulo in dB e fase in gradi. Verifichiamo inoltre la passività del circuito, l’andamento della fase, la risonanza e le relazioni fra le frequenze di taglio.

Questi test intercettano errori che un controllo sintattico non rileverebbe: uso di un rapporto di tensione invertito, fase con segno errato, conversione in gradi dimenticata o confusione tra moltiplicazione e divisione matriciale.

Visualizzatore dei sorgenti GX-TXT con lo script GNU Octave per il circuito RLC e le API Dataset e Plot Dataset.
Il sorgente della simulazione RLC nel visualizzatore Script Library di GX-TXT.
Interfaccia Dataset GX-TXT con due serie analitiche e quattro serie derivate della simulazione RLC.
I due Dataset di riferimento e i quattro Dataset calcolati sono registrati nella Session.

Le API pubbliche GX-TXT usate nella lezione

Il linguaggio Octave calcola vettori, impedenze e proprietà matematiche. GX-TXT gestisce la vita dei dati scientifici nella Session, la loro identità, la pubblicazione e i grafici persistenti. Nessuno script apre direttamente i file interni del framework.

API e operazioneScopo e risultato
gxtxt_api_requireVerifica che le API richieste siano disponibili nel contesto Script Bridge
gxtxt_api_has_operationVerifica una specifica operazione prima di invocarla
gxtxt_api_callEsegue una chiamata ad API, operazione e argomenti posizionali
CANONICAL_DATASET_API_v2 / listElenca gli ID dei Dataset canonici accessibili
CANONICAL_DATASET_API_v2 / read_rangeLegge variabili nominate per ID da una sequenza esplicita di righe
DATASET_PUBLICATION_API_v2 / publish_series_batchPubblica in modo atomico più Dataset dichiarando valori, unità e provenienza
PLOT_DATASET_API_v4 / new_specInizializza una specifica PlotSpec
validate_specControlla la coerenza della specifica
upsert_plotRegistra o aggiorna un grafico persistente
render e artifactsGenerano la rappresentazione e recuperano i descrittori degli output

Una lettura effettiva nel terzo script è:

data = gxtxt_api_call('CANONICAL_DATASET_API_v2', ...
  'read_range', ...
  {'lesson15_reference_gain_db',{'frequency_hz','gain_db'},0,402});
gain_reference = data.gain_db.values(:);

Il primo argomento individua l’API; il secondo l’operazione; il terzo è una cella con Dataset ID, elenco di Variable ID, indice iniziale zero-based e numero di righe. I valori ritornano in uno struct indicizzato tramite gli ID delle variabili. La lettura è esplicita e riproducibile; non dipende dal nome di un file o da un percorso HDF5.

Per pubblicare, definiamo le variabili con variable_id, unit, tipo e descrizione, e poi chiamiamo:

receipt = gxtxt_api_call('DATASET_PUBLICATION_API_v2', ...
  'publish_series_batch',{struct('series',{series})});

La ricevuta fornisce atomic e output_count, che controlliamo prima di rileggere i risultati salvati. L’atomicità evita che una pubblicazione composta produca un insieme parziale di Dataset.

Per i grafici creiamo una PlotSpec plot.dataset.xy con asse X logaritmico e curve che fanno riferimento a Dataset ID e Variable ID canonici, senza creare grafici Octave esterni. La successione è new_spec → validate_spec → upsert_plot → render → artifacts. Sono previsti tre grafici persistenti: Bode del modulo, Bode della fase e residuo del guadagno rispetto al riferimento analitico.

Un’API già nota, ma un nuovo problema di rappresentazione

read_range è stato introdotto nella Lezione 06, publish_series_batch nella 07 e il ciclo di vita PlotSpec nella 08. Non sono nuove API: la novità è preservare il significato scientifico di una funzione complessa di trasferimento quando pubblichiamo grandezze reali con unità precise.

La funzione \(H\) è un risultato intermedio complesso. Nei Dataset pubblichiamo frequenze in Hz, guadagni in dB, fasi in gradi e residui identificati con Variable ID distinti. Un residuo in dB non è una tensione in volt; una fase in radianti non diventa una fase in gradi modificando i metadati.

  1. Lettura: read_range usa un indice iniziale da zero per il contratto GX-TXT, mentre il primo elemento di un vettore Octave ha indice 1. Il Variable ID, non la posizione della colonna, identifica la misura.
  2. Validazione: oltre a verificare lunghezza e finitezza, bisogna accertare che le frequenze corrispondano punto per punto fra due Dataset. Array della stessa lunghezza non sono necessariamente allineati.
  3. Pubblicazione: lo schema dichiara unità e provenienza; la ricevuta di publish_series_batch permette di controllare atomic e output_count, prima di rileggere i valori pubblicati.
  4. Grafico: new_spec → validate_spec → upsert_plot → render → artifacts produce una rappresentazione persistente riferita a Dataset ID e Variable ID. Il grafico non sostituisce il dato canonico.

La scala logaritmica di frequenza richiede valori X strettamente positivi: a \(f=0\) la formula dell’impedenza capacitiva va interpretata tramite un limite, non eseguendo una divisione per zero.

Risultati: i grafici di Bode e il confronto analitico

Il diagramma del modulo mostra il massimo di 0 dB alla risonanza, con sovrapposizione delle risposte ottenute dalla divisione complessa e dalla formula analitica.

Grafico GX-TXT del modulo in decibel in funzione della frequenza logaritmica, con massimo di zero decibel a circa 1591,55 hertz.
Modulo del trasferimento ai capi della resistenza: picco di 0 dB alla risonanza.

Il diagramma della fase evolve da circa +90° a circa −90°, attraversando 0° alla frequenza di risonanza. Le due curve si sovrappongono.

Grafico GX-TXT della fase tra circa più novanta e meno novanta gradi con attraversamento dello zero alla risonanza.
La fase attraversa 0° a circa 1591,55 Hz, passando dal comportamento capacitivo a quello induttivo.

Il residuo del modulo è dell’ordine di 10^−14 dB: si tratta della precisione numerica delle operazioni in doppia precisione, non di rumore sperimentale.

Grafico GX-TXT del residuo del guadagno in decibel vicino allo zero, con scarti dell'ordine di dieci alla meno quattordicesima.
Residuo dell’ordine di 10^−14 dB: arrotondamento numerico, non rumore sperimentale.

Interpretare i grafici e il residuo senza attribuire precisioni inesistenti

Nel modulo, il massimo di 0 dB segnala la risonanza ideale: controlliamo anche la salita alle basse frequenze e la discesa alle alte frequenze. Nella fase, lo zero indica che alla risonanza uscita resistiva e ingresso sono in fase; il segno cambia ai due lati.

Il grafico dei residui confronta due metodi numerici dello stesso modello, non una teoria e un insieme di misure fisiche. Uno scostamento dell’ordine di \(10^{-14}\) dB è compatibile con l’arrotondamento in doppia precisione; non significa accuratezza strumentale di quattordici cifre né assenza di rumore in un esperimento reale.

Procedura nel GX-TXT Octave Script Workspace

Creiamo una nuova Session GX-TXT e importiamo i tre script, ciascuno con un Script ID distinto. Eseguiamo L15_00 e controlliamo che i due Dataset analitici siano stati pubblicati. Apriamo L15_01 nel debugger, esaminiamo le variabili al breakpoint e lasciamo proseguire fino all’errore intenzionale. Infine eseguiamo L15_02 e apriamo i tre grafici dalla gestione nativa Plot Dataset. Per ripetere integralmente la lezione senza collisioni di ID, utilizziamo una nuova Session, senza cancellare file di Dataset dall’esterno.

ProgrammaRisultato atteso
L15_00_Prepare_RLC_Reference.m2 Dataset analitici di riferimento
L15_01_Debug_Phase_Units.mJob intenzionalmente fallito, nessuna pubblicazione
L15_02_RLC_Bode_Correct.m4 Dataset derivati, 3 grafici GX-TXT

Interpretazione scientifica ed esercizi

Il picco a circa 1,59 kHz non è un’oscillazione temporale calcolata con ode45: è una risposta armonica stazionaria nel dominio delle frequenze. È possibile ottenere informazioni complementari studiando il transitorio del circuito con equazioni differenziali, come introdotto nella Lezione 14. Un diagramma numerico liscio non sostituisce la verifica delle unità e delle ipotesi fisiche.

  1. Raddoppiare \(R\) e prevedere come cambiano \(Q\), banda passante e picco alla risonanza. La risonanza ideale resta invariata.
  2. Raddoppiare \(C\) e calcolare prima analiticamente la nuova frequenza \(f_0\).
  3. Usare una griglia più rada e spiegare perché il massimo campionato può non cadere esattamente a \(f_0\), quando non viene inserito il valore analitico.
  4. Calcolare la fase in radianti e in gradi per le due frequenze di taglio.
  5. Modificare il rapporto di uscita, prendendo la tensione ai capi di \(C\), e derivare una nuova funzione di trasferimento prima di tentare una pubblicazione; non riutilizzare i confronti analitici del passa-banda resistivo.

Versione e riferimenti pubblici

Repository autorevole: GX-TXT su GitHub. Ramo: maintenance/dev112. Commit dei contratti controllati: 9f79a30661d6a3fe4a05d723be66aabd06ef2ebe (16 novembre 2026). Patch pubblicata: DEV112 Release 2 P011. Le chiamate didattiche sono basate sui seguenti contratti disponibili a tale commit:

Gli script sono distribuiti con licenza GPL-3.0-or-later. I commenti e la documentazione interna del codice sono in inglese.

Compatibilità di esecuzione verificata: la prova degli script, la pubblicazione dei sei Dataset e il rendering dei tre grafici sono stati eseguiti con GX-TXT DEV112 R2 + P008. Il commit P011 riportato sopra identifica invece i sorgenti e i contratti pubblici più recenti consultati su GitHub; non costituisce una dichiarazione di collaudo dell’installazione P011.

Script GNU Octave completi

Apri i riquadri per consultare e copiare i sorgenti.

Programma 00 — L15_00_Prepare_RLC_Reference.m
% Lesson 15 - Publish analytical reference data for a series RLC band-pass circuit.
% Course: GNU Octave with GX-TXT | public API reference DEV112 R2 P011
% Tested GX-TXT runtime: DEV112 R2 P008
% Pinned GitHub source: 9f79a30661d6a3fe4a05d723be66aabd06ef2ebe
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Run once in a new managed GX-TXT Session.
% This script publishes deterministic analytical references, not measurements.

dataset_api = 'CANONICAL_DATASET_API_v2';
publication_api = 'DATASET_PUBLICATION_API_v2';
gxtxt_api_require({dataset_api, publication_api});
required = {dataset_api, 'list'; dataset_api, 'read_range'; ...
            publication_api, 'publish_series_batch'};
for k = 1:rows(required)
  if !gxtxt_api_has_operation(required{k,1}, required{k,2})
    error('Missing public GX-TXT operation: %s/%s.', ...
          required{k,1}, required{k,2});
  endif
endfor

% A series RLC circuit, driven by a 1 V sinusoidal input.
% The observed output voltage is the voltage across the resistance.
resistance_ohm = 20;
inductance_h = 10e-3;
capacitance_f = 1e-6;
f0_hz = 1 / (2*pi*sqrt(inductance_h*capacitance_f));
quality_factor = sqrt(inductance_h/capacitance_f) / resistance_ohm;
bandwidth_hz = resistance_ohm / (2*pi*inductance_h);

% Include the exact resonance frequency in the logarithmic sampling grid.
frequency_hz = sort([logspace(2, 4.5, 401)'; f0_hz]);
n = numel(frequency_hz);
assert(n == 402 && all(diff(frequency_hz) > 0));
omega = 2*pi*frequency_hz;

% Analytically evaluate |H| and angle(H) without a complex quotient.
% H(j*w) = R / (R + j*(w*L - 1/(w*C))).
reactance_ohm = omega*inductance_h - 1./(omega*capacitance_f);
gain_reference_db = 20*log10(resistance_ohm ./ ...
  sqrt(resistance_ohm^2 + reactance_ohm.^2));
phase_reference_deg = -atan2(reactance_ohm, resistance_ohm)*180/pi;
assert(all(isfinite(gain_reference_db)) && all(isfinite(phase_reference_deg)));
[~, resonance_row] = min(abs(frequency_hz-f0_hz));
assert(abs(gain_reference_db(resonance_row)) < 1e-11);
assert(abs(phase_reference_deg(resonance_row)) < 1e-11);

dataset_ids = {'lesson15_reference_gain_db', 'lesson15_reference_phase_deg'};
existing_ids = gxtxt_api_call(dataset_api, 'list', {});
for k = 1:numel(dataset_ids)
  if any(strcmp(existing_ids, dataset_ids{k}))
    error('Reference Dataset already exists: %s. Use a new Session.', ...
          dataset_ids{k});
  endif
endfor

frequency_variable = struct('variable_id','frequency_hz', ...
  'name','frequency_hz', 'display_label','Frequency', 'unit','Hz', ...
  'dtype','float64', 'value_kind','number','semantic_source','generator');
gain_variable = struct('variable_id','gain_db', ...
  'name','gain_db','display_label','Magnitude', 'unit','dB', ...
  'dtype','float64','value_kind','number','semantic_source','generator');
phase_variable = struct('variable_id','phase_deg', ...
  'name','phase_deg','display_label','Phase', 'unit','deg', ...
  'dtype','float64','value_kind','number','semantic_source','generator');

values = {gain_reference_db, phase_reference_deg};
definitions = {gain_variable, phase_variable};
descriptions = {'Analytical magnitude of resistor output, in dB', ...
                'Analytical phase of resistor output, in degrees'};
series = cell(1, numel(dataset_ids));
for k = 1:numel(dataset_ids)
  metadata = struct();
  metadata.('rlc.synthetic') = true;
  metadata.('rlc.topology') = 'series_resistor_output';
  metadata.('rlc.resistance_ohm') = resistance_ohm;
  metadata.('rlc.inductance_h') = inductance_h;
  metadata.('rlc.capacitance_f') = capacitance_f;
  metadata.('rlc.resonance_hz') = f0_hz;
  metadata.('rlc.quality_factor') = quality_factor;
  metadata.('rlc.method') = 'closed_form_reference';
  series{k} = struct('dataset_id', dataset_ids{k}, ...
    'contract','table.generic','storage','auto', ...
    'x_values',frequency_hz,'y_values',values{k}, ...
    'x_variable',frequency_variable,'y_variable',definitions{k}, ...
    'source','GX-TXT GNU Octave Lesson 15', ...
    'producer_version','1.0.0', ...
    'provenance','Deterministic analytical series RLC model', ...
    '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 != 2
  error('Atomic publication did not confirm two reference Datasets.');
endif
for k = 1:numel(dataset_ids)
  saved = gxtxt_api_call(dataset_api,'read_range', ...
    {dataset_ids{k}, {'frequency_hz',definitions{k}.variable_id},0,n});
  assert(max(abs(saved.frequency_hz.values(:)-frequency_hz)) < 1e-9);
  actual = saved.(definitions{k}.variable_id).values(:);
  assert(max(abs(actual-values{k})) < 1e-9);
endfor

fprintf('PASS: 2 analytical RLC reference Datasets published.\n');
fprintf('R = %.3f Ohm; L = %.5f H; C = %.9f F.\n', ...
        resistance_ohm, inductance_h, capacitance_f);
fprintf('f0 = %.6f Hz; Q = %.6f; bandwidth = %.6f Hz.\n', ...
        f0_hz, quality_factor, bandwidth_hz);
Programma 01 — L15_01_Debug_Phase_Units.m
% Lesson 15 - Debug a deliberate phase-unit error in a complex RLC transfer.
% Course: GNU Octave with GX-TXT | public API reference DEV112 R2 P011
% Tested GX-TXT runtime: DEV112 R2 P008
% Pinned GitHub source: 9f79a30661d6a3fe4a05d723be66aabd06ef2ebe
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Run after L15_00. Add a native debugger breakpoint at BREAKPOINT below.
% This Job is expected to fail; it creates no Dataset and no Plot Dataset.

dataset_api = 'CANONICAL_DATASET_API_v2';
gxtxt_api_require({dataset_api});
if !gxtxt_api_has_operation(dataset_api,'read_range')
  error('Missing public GX-TXT operation: read_range.');
endif

reference = gxtxt_api_call(dataset_api,'read_range', ...
  {'lesson15_reference_phase_deg',{'frequency_hz','phase_deg'},0,402});
frequency_hz = reference.frequency_hz.values(:);
expected_phase_deg = reference.phase_deg.values(:);
assert(numel(frequency_hz) == 402 && all(diff(frequency_hz)>0));

resistance_ohm = 20;
inductance_h = 10e-3;
capacitance_f = 1e-6;
omega = 2*pi*frequency_hz;
impedance_ohm = resistance_ohm + ...
  1i*(omega*inductance_h - 1./(omega*capacitance_f));
transfer = resistance_ohm ./ impedance_ohm;

% INTENTIONAL ERROR: angle() returns radians, not degrees.
% A phase plotted with a "degrees" label would be scientifically misleading.
phase_deg_wrong = angle(transfer);
maximum_phase_error_deg = max(abs(phase_deg_wrong - expected_phase_deg));
[~,high_frequency_row] = max(frequency_hz);

% BREAKPOINT: inspect phase_deg_wrong, expected_phase_deg,
% high_frequency_row, and maximum_phase_error_deg.
fprintf('At %.1f Hz: wrong phase = %.5f (radians).\n', ...
  frequency_hz(high_frequency_row),phase_deg_wrong(high_frequency_row));
fprintf('Correct phase = %.5f degrees; mismatch = %.5f.\n', ...
  expected_phase_deg(high_frequency_row),maximum_phase_error_deg);

% The expected FAILED Job prevents silent use of incorrectly labelled data.
if maximum_phase_error_deg > 30
  error('GXTXT:Lesson15:PhaseUnits', ...
    'The phase is in radians, not degrees. Multiply by 180/pi.');
endif
error('Unexpected success: the intentional phase-unit error escaped.');
Programma 02 — L15_02_RLC_Bode_Correct.m
% Lesson 15 - Complex RLC transfer, validation and GX-TXT Bode plots.
% Course: GNU Octave with GX-TXT | public API reference DEV112 R2 P011
% Tested GX-TXT runtime: DEV112 R2 P008
% Pinned GitHub source: 9f79a30661d6a3fe4a05d723be66aabd06ef2ebe
% SPDX-License-Identifier: GPL-3.0-or-later
%
% Run in a managed GX-TXT Session after L15_00.
% Native Octave computes complex impedances; all GX-TXT Session, Dataset and
% Plot operations use documented public APIs through the Script Bridge.

dataset_api = 'CANONICAL_DATASET_API_v2';
publication_api = 'DATASET_PUBLICATION_API_v2';
plot_api = 'PLOT_DATASET_API_v4';
gxtxt_api_require({dataset_api, publication_api, plot_api});
required = {
  dataset_api,'list'; dataset_api,'read_range';
  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 public GX-TXT operation: %s/%s.', ...
      required{k,1},required{k,2});
  endif
endfor

% Step 1: read the immutable analytical references by Dataset and Variable ID.
source_ids = {'lesson15_reference_gain_db','lesson15_reference_phase_deg'};
existing_ids = gxtxt_api_call(dataset_api,'list',{});
for k=1:numel(source_ids)
  if !any(strcmp(existing_ids,source_ids{k}))
    error('Missing reference Dataset %s. Run L15_00 first.',source_ids{k});
  endif
endfor
ref_gain = gxtxt_api_call(dataset_api,'read_range', ...
  {source_ids{1},{'frequency_hz','gain_db'},0,402});
ref_phase = gxtxt_api_call(dataset_api,'read_range', ...
  {source_ids{2},{'frequency_hz','phase_deg'},0,402});
frequency_hz = ref_gain.frequency_hz.values(:);
reference_gain_db = ref_gain.gain_db.values(:);
reference_phase_deg = ref_phase.phase_deg.values(:);
n = numel(frequency_hz);
if n != 402 || any(diff(frequency_hz)<=0) || ...
  max(abs(frequency_hz-ref_phase.frequency_hz.values(:)))>1e-9
  error('Reference frequency grids are missing or incompatible.');
endif

% Step 2: write the impedance equations with complex-valued Octave arrays.
resistance_ohm = 20;
inductance_h = 10e-3;
capacitance_f = 1e-6;
omega = 2*pi*frequency_hz;
z_resistor = resistance_ohm;
z_inductor = 1i*omega*inductance_h;
z_capacitor = 1./(1i*omega*capacitance_f);
z_total = z_resistor + z_inductor + z_capacitor;
transfer = z_resistor ./ z_total;
gain_linear = abs(transfer);
gain_db = 20*log10(gain_linear);
phase_deg = unwrap(angle(transfer))*180/pi;

% Step 3: independent physical and mathematical consistency checks.
f0_hz = 1/(2*pi*sqrt(inductance_h*capacitance_f));
quality_factor = sqrt(inductance_h/capacitance_f)/resistance_ohm;
bandwidth_hz = resistance_ohm/(2*pi*inductance_h);
omega_low = (-resistance_ohm + ...
  sqrt(resistance_ohm^2+4*inductance_h/capacitance_f)) / (2*inductance_h);
omega_high = (resistance_ohm + ...
  sqrt(resistance_ohm^2+4*inductance_h/capacitance_f)) / (2*inductance_h);
f_low = omega_low/(2*pi);
f_high = omega_high/(2*pi);
assert(abs((f_high-f_low)-bandwidth_hz)<1e-9);
assert(abs(sqrt(f_low*f_high)-f0_hz)<1e-9);

[~,resonance_row] = min(abs(frequency_hz-f0_hz));
if abs(frequency_hz(resonance_row)-f0_hz)>1e-9 || ...
   abs(gain_db(resonance_row))>1e-10 || ...
   abs(phase_deg(resonance_row))>1e-9
  error('At resonance the resistor output must be 0 dB and 0 degrees.');
endif
if any(gain_db>1e-8) || any(!isfinite(gain_db)) || ...
   any(!isfinite(phase_deg)) || ...
   phase_deg(1)<0 || phase_deg(end)>0
  error('Passive RLC magnitude or phase is unphysical.');
endif

gain_error_db = gain_db-reference_gain_db;
phase_error_deg = phase_deg-reference_phase_deg;
max_gain_error_db = max(abs(gain_error_db));
max_phase_error_deg = max(abs(phase_error_deg));
if max_gain_error_db>1e-8 || max_phase_error_deg>1e-7
  error('Complex impedance response disagrees with the analytical reference.');
endif
fprintf('R=%.1f Ohm, L=%.5f H, C=%.9f F.\n', ...
  resistance_ohm,inductance_h,capacitance_f);
fprintf('f0=%.6f Hz, Q=%.6f, -3 dB points=%.4f and %.4f Hz.\n', ...
  f0_hz,quality_factor,f_low,f_high);
fprintf('Max error: gain %.3g dB, phase %.3g deg.\n', ...
  max_gain_error_db,max_phase_error_deg);

% Step 4: atomically publish all derived series with physical units.
derived_ids = {'lesson15_gain_db','lesson15_phase_deg', ...
               'lesson15_gain_error_db','lesson15_phase_error_deg'};
for k=1:numel(derived_ids)
  if any(strcmp(existing_ids,derived_ids{k}))
    error('Derived Dataset exists: %s. Use a new Session.',derived_ids{k});
  endif
endfor
frequency_variable = struct('variable_id','frequency_hz', ...
  'name','frequency_hz','display_label','Frequency','unit','Hz', ...
  'dtype','float64','value_kind','number','semantic_source','plugin');
gain_variable = struct('variable_id','gain_db', ...
  'name','gain_db','display_label','Magnitude','unit','dB', ...
  'dtype','float64','value_kind','number','semantic_source','plugin');
phase_variable = struct('variable_id','phase_deg', ...
  'name','phase_deg','display_label','Phase','unit','deg', ...
  'dtype','float64','value_kind','number','semantic_source','plugin');
gain_error_variable = struct('variable_id','gain_error_db', ...
  'name','gain_error_db','display_label','Magnitude residual','unit','dB', ...
  'dtype','float64','value_kind','number','semantic_source','plugin');
phase_error_variable = struct('variable_id','phase_error_deg', ...
  'name','phase_error_deg','display_label','Phase residual','unit','deg', ...
  'dtype','float64','value_kind','number','semantic_source','plugin');
values = {gain_db,phase_deg,gain_error_db,phase_error_deg};
variables = {gain_variable,phase_variable, ...
             gain_error_variable,phase_error_variable};
descriptions = {'Complex impedance transfer magnitude in dB', ...
  'Complex impedance transfer phase in degrees', ...
  'Magnitude difference from analytical closed-form reference', ...
  'Phase difference from analytical closed-form reference'};
series = cell(1,numel(derived_ids));
for k=1:numel(derived_ids)
  metadata = struct();
  metadata.('rlc.synthetic') = true;
  metadata.('rlc.topology') = 'series_resistor_output';
  metadata.('rlc.resistance_ohm') = resistance_ohm;
  metadata.('rlc.inductance_h') = inductance_h;
  metadata.('rlc.capacitance_f') = capacitance_f;
  metadata.('rlc.resonance_hz') = f0_hz;
  metadata.('rlc.quality_factor') = quality_factor;
  metadata.('rlc.method') = descriptions{k};
  series{k} = struct('dataset_id',derived_ids{k}, ...
    'contract','table.generic','storage','auto', ...
    'x_values',frequency_hz,'y_values',values{k}, ...
    'x_variable',frequency_variable,'y_variable',variables{k}, ...
    'source','GX-TXT GNU Octave Lesson 15','producer_version','1.0.0', ...
    'source_dataset_ids',{source_ids}, ...
    'provenance','GNU Octave complex RLC and public GX-TXT Dataset services', ...
    '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

% Step 5: verify every stored Dataset through public read_range.
for k=1:numel(derived_ids)
  saved = gxtxt_api_call(dataset_api,'read_range', ...
    {derived_ids{k},{'frequency_hz',variables{k}.variable_id},0,n});
  actual = saved.(variables{k}.variable_id).values(:);
  if numel(actual)!=n || ...
     max(abs(saved.frequency_hz.values(:)-frequency_hz))>1e-9 || ...
     max(abs(actual-values{k}))>1e-8
    error('Read-back verification failed for %s.',derived_ids{k});
  endif
endfor

% Step 6: create native persistent plots with logarithmic frequency axes.
plot_definitions = {
  'lesson15_bode_gain','Series RLC Bode magnitude', ...
  {'Complex transfer','Analytical reference'}, ...
  {'lesson15_gain_db','lesson15_reference_gain_db'}, ...
  {'gain_db','gain_db'}, 'Magnitude [dB]';
  'lesson15_bode_phase','Series RLC Bode phase', ...
  {'Complex transfer','Analytical reference'}, ...
  {'lesson15_phase_deg','lesson15_reference_phase_deg'}, ...
  {'phase_deg','phase_deg'}, 'Phase [deg]';
  'lesson15_bode_gain_residual','RLC magnitude residual', ...
  {'Complex minus analytical'}, {'lesson15_gain_error_db'}, ...
  {'gain_error_db'}, 'Magnitude residual [dB]'
};
for p=1:rows(plot_definitions)
  plot_id = plot_definitions{p,1};
  title_text = plot_definitions{p,2};
  labels = plot_definitions{p,3};
  dataset_list = plot_definitions{p,4};
  variable_list = plot_definitions{p,5};
  ylabel_text = plot_definitions{p,6};
  spec = gxtxt_api_call(plot_api,'new_spec',{'plot.dataset.xy',title_text});
  panel = spec.panels{1};
  panel.id = ['bode_panel_',num2str(p)];
  panel.title = title_text;
  panel.axes = struct('x',struct('label','Frequency [Hz]','scale','log'), ...
    'y_left',struct('label',ylabel_text,'scale','linear'));
  curves=cell(1,numel(labels));
  for k=1:numel(labels)
    curves{k}=struct('id',['rlc_trace_',num2str(k)], ...
      'label',labels{k},'dataset_id',dataset_list{k}, ...
      'x_variable_id','frequency_hz', ...
      'y_variable_id',variable_list{k},'axis','left','kind','line');
  endfor
  panel.series=curves;
  spec.panels={panel};
  if !gxtxt_api_call(plot_api,'validate_spec',{spec})
    error('PlotSpec validation failed for %s.',plot_id);
  endif
  plot_ref=gxtxt_api_call(plot_api,'upsert_plot',{plot_id,spec});
  gxtxt_api_call(plot_api,'render',{plot_ref});
  artifacts=gxtxt_api_call(plot_api,'artifacts',{plot_ref});
  fprintf('Created native Plot Dataset %s.\n',plot_id);
  disp(artifacts);
endfor
fprintf('PASS: 4 derived canonical Datasets and 3 native Bode plots.\n');
fprintf('PASS: resonance, bandwidth, gain and phase validated.\n');

#circuiti RLC #Debugging #diagrammi di Bode #elettronica #GNU Octave #GX-TXT #impedenza complessa #Plot Dataset #risonanza #Script Bridge

Altre tappe del progetto

Lascia un commento

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