Derivazione e integrazione

Calcolo infinitesimale (calculus)

Derivazione "derive"¹

La funzione derive() deriva rispetto al tempo il segnale di ingresso $x(t)$ .

y = \frac{d}{dt}x(t), \quad [y] = \frac{[x]}{\mathrm{s}}

Senza configurazione JSON, derive() calcola il quoziente istantaneo $\Delta x / \Delta t$ tra due istanti di valutazione consecutivi. Questa modalità semplice ha senso solo se il segnale di ingresso è effettivamente interpolabile in modo lineare, ad esempio valori misurati campionati in modo equidistante con #interpolateLin.

Per andamenti del segnale equidistanti si raccomanda la modalità a griglia: con fOut il segnale di ingresso viene ricampionato su una griglia temporale uniforme e derivato con un filtro differenziatore FIR mobile di ordine nFilt. Il filtro FIR forma un quoziente differenziale pesato sugli ultimi $2 \cdot \texttt{nFilt}$ punti della griglia e consente così un compromesso tra soppressione del rumore e ritardo di fase.

Per segnali con intervallo di valori ciclico (ad es. contatori angolari 0°..360° o encoder incrementali con overflow) il parametro modulo attiva una correzione dell'overflow. La funzione rileva gli overflow mediante la zona di overflow ovflz e corregge il gradiente in modo che nel risultato della derivazione non si verifichi alcun salto di segno.

y1 = derive(x);
y2 = derive(x, { fOut:      <dbl>|'def'
               , nFilt:     <uint>
               , reduction: <uint>
               , modulo:    <dbl>
               , ovflz:     <dbl>
               });

Proprietà	Valore	Descrizione
fOut	`def/<dbl>`	Frequenza di campionamento di uscita della modalità a griglia in Hz. `'def'` utilizza il tempo di campionamento globale (discreteSampleTimeMs). Valore minimo: 0,1 Hz.
nFilt	`<uint>`	Ordine del filtro differenziatore FIR mobile. Valori più alti riducono il rumore a scapito del ritardo di fase. Efficace solo nella modalità a griglia. Default: 2, intervallo di valori: $[2 \ldots 10]$
reduction	`<uint>`	Emette solo ogni n-esimo punto della griglia calcolato. Consente una frequenza di uscita inferiore a `fOut`. I valori ≤ 1 vengono ignorati.
modulo	`<dbl>`	Attiva la correzione dell'overflow per segnali ciclici. Indica l'intero intervallo di valori (ad es. `360.0` per angoli in gradi, `6.2832` per angoli in radianti). Intervallo di valori: $> 0.0$
ovflz	`<dbl>`	Zona di overflow come frazione di `modulo`. Un overflow viene rilevato quando il nuovo valore occupa la zona $[0,\ \mathtt{ovflz} \cdot \mathtt{modulo}[$ e quello precedente la zona $](1-\mathtt{ovflz}) \cdot \mathtt{modulo},\ \mathtt{modulo}]$ (o viceversa). Default: 0,333, intervallo di valori: $]0,0; 0,5[$

note

Poiché lo smartCORE, di norma, scrive in un canale i valori di segnali non equidistanti solo quando il valore è cambiato, il valore tra due punti di appoggio espliciti deve sempre essere assunto come costante e manca l'informazione per l'ultimo intervallo di campionamento reale. Tra i punti di appoggio vale sempre il valore del segnale a sinistra (mantenimento di ordine zero). Ne risulta un andamento del segnale a gradini.

L'applicazione della derivazione a segnali non equidistanti con andamento a gradini è priva di senso. Il risultato sarebbe $0$ oppure $\pm \infty$

Integrazione "integrate"

La funzione integrate() fornisce l'integrale nel tempo della funzione di ingresso x

y = \int_0^tx(\tau)d\tau

Poiché $x(\tau)$ fornisce sempre singoli punti di appoggio a istanti non equidistanti $t_0, t_1, t_2, ... t_n$ , tra i quali il valore della funzione a sinistra viene assunto come costante, l'integrale può essere scritto anche come somma:

y = \sum_{n=0}^{N-1}x(t_n)(t_{n+1}-t_n)

L'unità fisica del risultato è estesa di una dimensione temporale: $[y] = [x] \cdot \rm{s}$ .

note

Per i segnali equidistanti è prevista in futuro un'integrazione trapezoidale.

I1 = integrate(y);
I2 = integrate(y, reset);
I3 = integrate(y, reset, preset);
// Optionale Konfiguration für alle Varianten
Ix = integrate(..., { start: <dbl>
                    , preset: <dbl>
                    , lower: off|<dbl>
                    , upper: off|<dbl>
                    , storage: <str> 
                    });

Se tramite il parametro opzionale reset viene fornito un true, l'integrale viene riportato al valore stabilito con preset (come parametro o proprietà, default 0.0) e mantenuto. Immediatamente prima del ripristino viene inserito un ulteriore campione con cui viene emesso l'ultimo valore dell'integrale accumulato fino a quel momento ("true peak").

Proprietà	Valore	Descrizione
start	`<dbl>`	Primo valore iniziale per l'integrale all'avvio del Math Module
preset	`<dbl>`	Valore fisso per il ripristino dell'integrale tramite il parametro reset
lower	`off/<dbl>`	Limita inferiormente il valore dell'integrale, se attivato. Ciò è necessario ad es. per l'implementazione di strutture di regolazione o modelli in cui il processo di integrazione è limitato da un limite fisico.
upper	`off/<dbl>`	Limita superiormente il valore dell'integrale, se attivato. Ciò è necessario ad es. per l'implementazione di strutture di regolazione o modelli in cui il processo di integrazione è limitato da un limite fisico.
storage	`<str>`	Nome di una memoria persistente per il valore interno dell'integrale. In questo modo, dopo un riavvio del sistema, l'integrazione prosegue dall'ultimo valore memorizzato. Il contenuto di questa memoria non è utilizzabile in nessun altro punto dello smartCORE.

Esempio:

Nell'Esempio 1a la funzione integrate() viene utilizzata per calcolare l'energia elettrica a partire dagli andamenti temporali di corrente e tensione.

Nell'Esempio 10 la funzione integrate() viene utilizzata per la misura di tempi.

Somma "sumup"

La funzione sumup() fornisce la somma dei singoli valori del segnale di ingresso x agli istanti di un fronte positivo sul parametro trigger

y = \sum_{n=0}^{N-1}x(t_n)\quad\rm{mit}\quad t_n=time(posedge(trigger))

S1 = sumup(x, trigger);
S2 = sumup(x, trigger, reset);
// Optionale Konfiguration für alle Varianten
Sx = sumup(... , { storage: <str>
                 });

Se tramite il parametro opzionale reset viene fornito un true, la somma viene riportata a 0.0 e mantenuta.

Proprietà	Valore	Descrizione
storage	`<str>`	Nome di una memoria persistente per il valore interno della somma. In questo modo, dopo un riavvio del sistema, la somma prosegue dall'ultimo valore memorizzato. Il contenuto di questa memoria non è utilizzabile in nessun altro punto dello smartCORE.

Disponibile a partire dalla versione di catalogo 13. ↩

Calcolo infinitesimale (calculus)​

Derivazione "derive"1​

Integrazione "integrate"​

Esempio:​

Somma "sumup"​

Footnotes​

Calcolo infinitesimale (calculus)

Derivazione "derive"¹

Integrazione "integrate"

Esempio:

Somma "sumup"

Footnotes