Definizione del comportamento del grafico tramite l’utilizzo delle azioni

Passaggio 2 di 7 in Modellazione di macchine a stati finiti

Le azioni di stato e di transizione sono istruzioni che si scrivono all'interno di uno stato o accanto a una transizione per definire il comportamento di un grafico Stateflow^® durante la simulazione. Per ulteriori informazioni, vedere Modellazione di macchine a stati finiti.

Esempio di azioni di stato e di transizione

Questo esempio utilizza:

Apri modello

Le azioni di questo grafico definiscono una macchina a stati che verifica empiricamente un'istanza della congettura di Collatz. Per un dato input numerico $u$ , il grafico calcola la sequenza di Hailstone $n_0 = u,$ $n_1,$ $n_2,$ $n_3,$ ... iterando la seguente regola:

Se è pari, allora $n_{i+1} = n_i / 2$ .
Se è dispari, allora $n_{i+1} = 3n_i+1$ .

La congettura di Collatz afferma che ogni intero positivo ha una sequenza di Hailstone che alla fine raggiunge l'uno.

Il grafico è composto da tre stati. All'inizio della simulazione, lo stato Init inizializza i dati del grafico:

I dati locali n sono impostati sul valore dell'input u.
I dati locali n2 sono impostati sul resto quando n viene diviso per due.
I dati di output y sono impostati su false.

A seconda della parità dell'input, il grafico passa allo stato Even o Odd. Quando l'attività dello stato si sposta tra gli stati Even e Odd, il grafico calcola i numeri della sequenza di Hailstone. Quando la sequenza raggiunge il valore di uno, i dati di output y diventano true e attivano un blocco Stop Simulation (Simulink) nel modello Simulink®.

Tipi di azioni di stato

Le azioni di stato definiscono cosa fa un grafico Stateflow mentre uno stato è attivo. I tipi più comuni di azioni di stato sono entry, during e exit.

Tipo di azione di stato	Abbreviazione	Descrizione
`entry`	`en`	L'azione si verifica a un passaggio temporale in cui lo stato diventa attivo.
`during`	`du`	L'azione si verifica a un passaggio temporale in cui lo stato è già attivo e il grafico non esce dallo stato.
`exit`	`ex`	L'azione si verifica a un passaggio temporale in cui il grafico esce dallo stato.

È possibile specificare il tipo di azione di stato con la parola chiave completa (entry, during, exit) o con la sua abbreviazione (en, du, ex). Puoi anche raggruppare i tipi di azioni di stato utilizzando le virgole. Ad esempio, un'azione con il tipo combinato entry,during si verifica al passaggio temporale in cui lo stato diventa attivo e a ogni passaggio temporale successivo finché lo stato rimane attivo.

La seguente tabella elenca il risultato di ogni azione di stato nel grafico di Hailstone.

Stato	Azione	Risultato
`Init`	entry: n2 = rem(n,2); y = false;	Quando `Init` diventa attivo all'inizio della simulazione, determina la parità di `n` e imposta `y` su `false`.
`Init`	exit: y = isequal(n,1);	Quando esce da `Init` dopo un passaggio temporale, determina se `n` è uguale a uno.
`Even`	entry,during: n = n/2; n2 = rem(n,2);	Calcola il numero successivo della sequenza di Hailstone (`n` / 2) e aggiorna la sua parità: Al passaggio temporale in cui `Even` diventa attivo per la prima volta. A ogni passaggio temporale successivo in cui `Even` è attivo.
`Odd`	entry,during: n = 3*(n-y)+1; n2 = rem(n,2);	Calcola il numero successivo della sequenza di Hailstone (3`n`+1) e aggiorna la sua parità: Al passaggio temporale in cui `Odd` diventa attivo per la prima volta. A ogni passaggio temporale successivo in cui `Odd` è attivo. Per la maggior parte della simulazione, `y` ha valore zero. All'ultimo passaggio temporale, quando `n` = 1, `y` ha valore uno, quindi questa azione non modifica `n` o `n2` prima che la simulazione si arresti.

Tipi di azioni di transizione

Le azioni di transizione definiscono cosa fa un grafico Stateflow quando una transizione si allontana da uno stato attivo. I tipi più comuni di azioni di transizione sono le condizioni e le azioni condizionali. Per specificare le azioni di transizione, utilizzare un'etichetta con la seguente sintassi:

[condition]{conditional_action}

condition è un'espressione booleana che determina se la transizione si verifica. Se non si specifica una condizione, viene assunta una condizione implicita che vale vero.

conditional_action è un'istruzione che viene eseguita quando la condizione che protegge la transizione è vera. L'azione condizionale avviene dopo la condizione ma prima di qualsiasi azione di stato exit o entry.

La seguente tabella elenca il risultato di ogni azione di transizione nel grafico di Hailstone.

Transizione	Azione	Tipo di azione	Risultato
Transizione predefinita in `Init`	n = u	Azione condizionale	All'inizio della simulazione, assegna il valore di input `u` ai dati locali `n`.
Transizione da `Init` a `Even`	n2 == 0	Condizione	Quando `n` è pari, si verifica la transizione. Il numero 1 all'origine di questa transizione indica che viene valutata prima della transizione a `Odd`.
Transizione da `Init` a `Odd`		Nessuna	Quando `n` è dispari, si verifica la transizione. Il numero 2 all'origine di questa transizione indica che viene valutata dopo la transizione a `Even`.
Transizione da `Odd` a `Even`	n2 == 0	Condizione	Quando `n` è pari, si verifica la transizione.
Transizione da `Even` a `Odd`	n2 ~= 0	Condizione	Quando `n` è dispari, si verifica la transizione.
Transizione da `Even` a `Odd`	y = isequal(n,1)	Azione condizionale	Quando si verifica la transizione, determina se `n` è uguale a uno.

Analisi del comportamento del grafico

Supponiamo che si voglia calcolare la sequenza di Hailstone che inizia con un valore di nove.

Nel blocco Constant (Simulink), inserire un valore di 9.
Nella scheda Simulation, fare clic su Run .
Il grafico risponde con le seguenti azioni:
- Al tempo t = 0, si verifica la transizione predefinita a Init.
  - L'azione di transizione imposta il valore di n su 9.
  - Lo stato Init diventa attivo.
  - Le azioni entry in Init impostano n2 su 1 e y su false.
- Al tempo t = 1, la condizione n2 == 0 è falsa e il grafico si prepara a passare a Odd.
  - L'azione exit in Init imposta y su false.
  - Lo stato Init diventa inattivo.
  - Lo stato Odd diventa attivo.
  - Le azioni entry in Odd impostano n su 28 e n2 su 0.
- Al tempo t = 2, la condizione n2 == 0 è vera, quindi il grafico si prepara a passare a Even.
  - Lo stato Odd diventa inattivo.
  - Lo stato Even diventa attivo.
  - Le azioni entry in Even impostano n su 14 e n2 su 0.
- Al tempo t = 3, la condizione n2 ~= 0 è falsa, quindi il grafico non esegue una transizione.
  - Lo stato Even rimane attivo.
  - Le azioni during in Even impostano n su 7 e n2 su 1.
- Al tempo t = 4, la condizione n2 ~= 0 è vera, quindi il grafico si prepara a passare a Odd.
  - L'azione di transizione imposta y su false.
  - Lo stato Even diventa inattivo.
  - Lo stato Odd diventa attivo.
  - Le azioni entry in Odd impostano n su 22 e n2 su 0.
- Il grafico continua a calcolare la sequenza di Hailstone finché non raggiunge il valore n = 1 al tempo t = 19.
- Al tempo t = 20, il grafico si prepara a passare da Even a Odd.
  - Prima che lo stato Even diventi inattivo, l'azione di transizione imposta y su true.
  - Lo stato Odd diventa attivo.
  - Le azioni entry in Odd non modificano n o n2.
  - Il blocco Stop Simulation (Simulink) collegato al segnale di output y interrompe la simulazione.
Nella scheda Simulation, sotto Review Results, fare clic su Data Inspector .
Per vedere i valori della sequenza di Hailstone, selezionare il segnale registrato n in Simulation Data Inspector (Controllo dei dati di simulazione).

Simulation Data Inspector showing the output of the chart.

La sequenza di Hailstone raggiunge il valore di uno dopo 19 iterazioni.

Argomenti complementari

Modellazione di macchine a stati finiti

Avanti