Test séquentiel

La fonctionnalité Vecteur de test prend en charge les tests de circuits combinatoires et séquentiels. Par défaut, les tests sont combinatoires : le circuit est réinitialisé avant chaque test, garantissant que chaque test est indépendant.

Pour les circuits séquentiels, vous pouvez spécifier des séquences de test en utilisant les colonnes d'en-tête spéciales <set> et <seq> :

<set> : Définit l'identifiant de séquence - les tests avec le même numéro de set appartiennent à la même séquence et s'exécutent ensemble. L'état du circuit est préservé entre les étapes dans le même set. Les tests sont par défaut dans le set 0 s'il n'est pas spécifié.
<seq> : Définit le numéro d'étape dans un set - cela détermine l'ordre d'exécution des tests dans le même set. Les tests sont exécutés dans l'ordre de leur valeur <seq> dans chaque <set>. Les tests avec <seq> de 0 ou manquant sont traités comme combinatoires (le circuit se réinitialise entre les tests, même s'ils partagent le même set).

Voici un exemple de vecteur de test séquentiel :

# Test séquentiel pour un compteur
Clock Reset Count <set> <seq>
0     0     0     1     1
1     0     0     1     2
0     0     1     1     3
1     0     1     1     4
0     0     2     1     5
1     0     2     1     6
0     1     0     2     1

Dans cet exemple, les six premiers tests ont tous <set> 1 avec des valeurs <seq> 1-6, donc ils forment une séquence qui s'exécute dans l'ordre (seq 1, puis 2, puis 3, etc.) sans réinitialisation entre les étapes. Le dernier test a <set> 2, donc il démarre une nouvelle séquence et le circuit est réinitialisé avant son exécution.

Note also that Clock could be an input pin here. But it could also be a labeled clock component (see below).

Règles d'exécution de séquence

Les tests avec le même numéro <set> (> 0) appartiennent à la même séquence
Dans chaque set, les tests sont exécutés dans l'ordre de leur valeur <seq> (seq 1, puis 2, puis 3, etc.)
L'état du circuit est maintenu entre les tests dans le même set (même identifiant de set)
Le circuit est réinitialisé lors du démarrage d'un nouveau set (numéro <set> différent)
Tests with <seq> = 0 or missing must also have <set> = 0 or missing and are always combinational (reset between tests)

Exemple complet

Voici un exemple complet combinant toutes les fonctionnalités :

<clk> D Q NotQ  <set> <seq>
  0   0 0   1     1     1
  1   0 0   1     1     2
  0   1 0   1     1     3
  1   1 1   0     1     4
  0   1 1   0     1     5
  1   1 1   0     1     6
  0   0 1   0     1     7

Dans cet exemple :

Les trois premiers tests sont combinatoires (seq=0), donc le circuit se réinitialise entre chaque test, même s'ils partagent le set 0.
Les trois tests suivants ont tous le set 1 avec des valeurs seq 1-3, donc ils forment une séquence qui s'exécute dans l'ordre sans réinitialisation.
Le dernier test a le set 2, donc il démarre une nouvelle séquence et le circuit se réinitialise avant son exécution.
Le sixième test utilise <DC> pour la sortie, donc toute valeur de sortie passe.
Le dernier test utilise <float> pour la sortie, attendant une valeur flottante.

Using the Clock

In a sequential test, the first step begins with a reset. In every step after the first, it begins with a simulation tick. Any Clock components in the simulation will be updated by that tick and their signals will be propagated along with any input pin values for that step. You may add a column to the test to show the ticks. The column will be checked against the clock in the circuit as if it were an output pin to verify it describes the clocks behavior. Here is an example for a simple positive edge-triggered D flip-flop test with a standard clock:

<clk> D Q NotQ  <set> <seq>
  0   0 0   1     1     1
  1   0 0   1     1     2
  0   1 0   1     1     3
  1   1 1   0     1     4
  0   1 1   0     1     5
  1   1 1   0     1     6
  0   0 1   0     1     7

The <clk> header is a special name for an unlabeled clock component. You may also label the clock and use the label as the column header (see earlier example).

We recommend that when using a Clock, you should not change the values of memory inputs during the same step that the clock makes a triggering transition. Doing so may allow an input signal to reach the component at near the same time as the clock signal giving surprising behavior. In the example above, the D input does not change in steps with a rising edge of the clock.

Complete Example

Here is a complete example combining all features:

# Mixed combinational and sequential tests
A B C Out     <clk> <set> <seq>
0 0 0 0       0     0     0
0 0 1 1       0     0     0
1 1 0 1       0     1     1
0 1 0 0       1     1     2
1 1 1 1       0     1     3
0 0 0 <DC>    0     2     1
1 0 1 <float> 1     2     2

In this example:

Notice how the clock resets to 0 in each line that does a reset.
The first two tests are combinational (seq=0), so the circuit resets between each test, even though they share set 0.
The next three tests all have set 1 with seq values 1-3, so they form one sequence that runs in order without reset between each other only resetting before the first test in the set runs.
The last test has set 2 seq 1&2, so it starts a new sequence and the circuit resets before it runs but not between tests in the set.
The sixth test uses <DC> for the output, so any output value passes.
The last test uses <float> for the output, expecting a floating value.

Thus the execution might look like this:

Reset, set A=0, B=0, C=0 and check that Out==0 and clk=0
Reset, set A=0, B=0, C=1 and check that Out==1 and clk=0
Reset, set A=1, B=1, C=0 and check that Out==1 and clk=0
Tick, set A=0, B=1, C=0 and check that Out==0 and clk=1
Tick, set A=1, B=1, C=1 and check that Out==1 and clk=0
Reset, set A=0, B=0, C=0 and not check Out but clk=0
Tick, set A=1, B=0, C=1 and check that Out is floating (in Logisim this is notated as U) and clk=1
Test Vector is complete

Précédent : Valeurs spéciales | Suivant : Utilisation en ligne de commande.