Simulateur de circuits logiques

Les entrées sont en train de se faire - ça viendra aujourd'hui.

Je ne dessinerai pas les valeurs à l'intérieur du schéma. Il ne faut pas oublier qu'il s'agit en réalité d'une bitmap. Chaque élément dessiné devient partie intégrante de la bitmap et n'est plus dissociable du reste du dessin. Je ne créerais que des superpositions rendant le tout illisible. Mais pour chaque valeur à vérifier, et en particulier les valeurs de sortie, tu peux faire un lien avec un des 30 contacts, et tu veras l'état 1 (coché) ou 0 (décoché).

J'ai prévu une base de temps pouvant servir à fournir des tics d'horloge, avec un délai réglable. Et on pourra spécifier un nombre précis d'itérations, ou alors stopper l'action par un bouton.

En effet, ça répond bien.
Par contre, si on a un problème (comme en Panoramic) comme les contacts, ce serait bien de pouvoir suivre dans la même fenêtre (celle des contacts) une porte (sortie) en particulier.

Après, la base de temps, c'est nickel pour les horloges. Je ne sais pas si on trouve encore les circuits TTL que j'avais à l'époque et que j'ai encore dans mon sous-sol avec ma console WEKA de test ...

Oui, on les trouve toujours. Mais je ne parle de TTL que parce que c'était la première technologie que j'ai utilisée. Par nostalgie, quoi. Mais il y a aussi Low Power TTL, Schottky TTL, C-Mos, ECL, ... il y a une multitude de technologies, et on trouve des circuits intégrés dans toutes ces technologies.

Pour ma part, j'ai fait une simulation "logique" qui peut être utilisée pour tout ça. Ce n'est pas une technologie "physique" tenant compte des temps de transition, des fronts montants et descendants, des effets d'états intermédiaires etc.

Nouvelle version: les entrées sont disponibles ! De 1 à 8 entrées pour NAND, AND et OR, 2 entrées pour XOR et JK. Les entrées sont orientées à gauche, et le programme en tient compte.

Je pense qu'on peut commencer à faire de jolis circuits avec ça. Je fais la sauvegarde/reprise maintenant.

En effet, ça prend forme:
Pour ce circuit:

Code:

; flipflop JK
; portes commandées
nand,a1,3,1
position,a1,40,31
nand,a2,3,1
position,a2,40,91
lien,J,#2,a1/2
lien,Tick1,#3,a1/3
lien,Tick2,#3,a2/1
lien,K,#4,a2/2
; puis un flipflop RS
nand,b1,2,0
position,B1,90,36
nand,b2,2,1
position,B2,90,86
; entrées
lien,l1,a1,b1/1
lien,l2,a2,b2/2
; liens croisés
lien,l3,b1,b2/1
lien,l4,b2,b1/2
; sorties
lien,l5,b1,#13
lien,l6,b2,#14
; liens de rebouclage
lien,l7,b1,a2/3
lien,l8,b2,a1/1

Après modification des segments, j'obtiens:


Seul reproche, il manque la possibilité de mettre des "pastilles" aux intersections ou il y a contact ou liaison pour améliorer la lecture du schéma. Je pense que tu pourrais créer un objet "pastille" qui serait un point de liaison de tes liens. Etat de sortie = état d'entrée. Ça simplifierait juste les tracés "directement bon dès le départ"
Dans la bascule JK, on ferait par exemple la liaison B1-p1, la liaison p1-#13, la liaison p1-b1/1
Ca fait 3 liaison au lieu de 2, mais en positionnant p1 dans le code, on n'aurait pas à modifier les segments après.

Autre amélioration possible, quand on utilise le bouton Dessiner les portes, il ne demande plus si on veut déplacer les portes, il dessine le circuit, mais tu pourrais ajouter comme pour les lien, un bouton déplacer les portes qui permette de bouger les portes sur le schéma et qui mettrait à jour la ligne position de la porte modifiée.

Merci pour tes commentaires constructifs - je vais y réfléchir.

Pour le moment, je fais les boutons Enregistrer/Ouvrir - c'est pour bientôt.

Nouvelle version:

Il y a maintenant un bouton "Enregistrer" et un bouton "Ouvrir". L'enregistrement se fait dans un fichier texte, mais il vaut mieux ne pas le modifier avec un éditeur: pour la facilité, c'est une série de lignes avec une seule valeur, et l'ordre détermine leur rechargement par le bouton "Ouvrir". On sauvegarde tout sauf le graphiqme proprement dit: le script, les objets, les liens avec tous les segments.

Après avoir rechargé un circuit sauvegardé, il suffit de faire "Afficher le schéma", puis "Dessiner" (ou l'ordre inverse) et le schéma exact est reconstitué. Ne pas utiliser le bouton "Générer" car il va recréer les tracés par défaut.

J'attaque la suite...

EDIT

Voici le fichier "flipflop JK.plc" qui est le projet d'une bascule JK tel que Jicehel l'a publiée ci-devant. avec ce projet et le nouveau bouton "Ouvrir", tout le monde peut le charger et l'avoir à l'écran, tout prêt:

Code:

flipflop JK
16
; flipflop JK
; portes commandées
nand,a1,3,1
position,a1,40,31
nand,a2,3,1
position,a2,40,91
lien,J,#2,a1/2
lien,Tick1,#3,a1/3
lien,Tick2,#3,a2/1
lien,K,#4,a2/2
; puis un flipflop RS
nand,b1,2,0
position,B1,90,36
nand,b2,2,1
position,B2,90,86
; entrées
lien,l1,a1,b1/1
lien,l2,a2,b2/2
; liens croisés
lien,l3,b1,b2/1
lien,l4,b2,b1/2
; sorties
lien,l5,b1,#13
lien,l6,b2,#14
; liens de rebouclage
lien,l7,b1,a2/3
lien,l8,b2,a1/1
*****
2
a1
3
0
0
0
1
0
40
31
0
2
a2
3
0
0
0
1
0
40
91
0
1
j
1
-2
1
2
0
0
1
0
45
1
40
45
3
1
tick1
1
-3
1
3
0
0
3
0
75
1
35
75
1
35
52
4
40
52
3
1
tick2
1
-3
2
1
0
0
3
0
75
1
35
75
1
35
98
2
40
98
3
1
k
1
-4
2
2
0
0
1
0
105
1
40
105
3
2
b1
2
0
0
0
0
90
36
0
2
b2
2
0
0
1
0
90
86
0
1
l1
1
1
7
1
0
0
1
60
46
1
90
46
3
1
l2
1
2
8
2
0
0
1
60
106
1
90
106
3
1
l3
1
7
8
1
0
0
5
110
51
1
120
51
1
120
81
2
85
81
3
85
96
2
90
96
3
1
l4
1
8
7
2
0
0
5
110
101
1
115
101
1
115
71
4
85
71
3
85
56
4
90
56
3
1
l5
1
7
-13
0
0
0
2
110
51
1
205
51
1
205
0
2
1
l6
1
8
-14
0
0
0
2
110
101
1
265
101
1
265
0
2
1
l7
1
7
2
3
0
0
5
110
51
1
140
51
1
140
122
2
35
122
3
35
112
2
40
112
3
1
l8
1
8
1
1
0
0
5
110
101
1
130
101
1
130
28
4
35
28
3
35
38
4
40
38
3

Test OK pour le chargement / tracé / modification / sauvegarde / chargement / tracé ...
Le circuit se ré affiche bien avec les modifications dans tous les cas testés.
PS: bien les commentaires dans le script, je n'avais pas fais attention avant, mais c'est pratique
D'ailleurs, plus tard, tu pourras peut être créer un objet texte sans entrée ni sortie pour mettre des commentaires sur le schéma, mais bon, ça c'est vraiment un truc secondaire...

Nouvelle version:

J'ai retenu ta suggestion, Jicehel, pour définir une "soudure" permettant de relier plusieurs fils.

Pour ce faire, j'ai créé l'objet PLOT. La commande est la suivante:
PLOT,nom,val

Cet objet a 4 entrées et une sortie. Il agit actuellement comme un OR des 4 entrées. Comme pour les autres objets, les entrées et la sortie sont orientées. Il y a 4 directions possibles, qui sont identifiées par un code numérique (le même que celui utilisé en interne par le programme):
1 = à droite
2 = en bas
3 = à gauche
4 = en haut
C'est donc le numéro d'entrée (1 à 4) qui définit dans quel sens on arrive sur le plot.

Pour orienter la sortie, j'ai choisi d'utiliser la même syntaxe que pour choisir l'entrée: on ajoute /1.../4 au nom du plot.

Donc:

Code:

PLOT,neud
lien,fil1,#3,neud/3
lien,fil2,neud/4,#15

produit un fil du contact 3 vers la GAUCHE du plot (car ../3), et un fil sortant du HAUT du plot (car ..4) vers le contact 15.

J'ai essayé: techniquement, c'est impeccable: il suffit de déplacer le plot, de changer d'entrée ou de réorienter sa sortie pour dénouer les fils.

Un petit détail: pour être exactement dans l'axe verticalement et horizontalement, il faut respecter un décalage de +3 dans les deux axes, étant donné que les coordonnées d'un objet se rapportent au coin en haut à gauche.

PS

J'ai supprimé la question si l'on veut déplacer les portes, lors du traçage du schéma. Cela n'avait effectivement plus de sens et était plutôt un résidu le la période de conception initiale. On peut facilement modifier les positions dans le mémo, puis regénérer.


Ceci est un EDIT du poste d'origine, annonçant une version plus logique et cohérente de la gestion de l'orientation de la sortie du PLOT.

Après correction de bugs mineurs, voici une version stable. Et pour montrer le résultat, j'ai adapté le flipflop JK du circuit proposé par Jicehel, avec utilisation des objets PLOT pour marquer les soudures et clarifier le câblage. Il suffit de charger le projet, afficher le schéma et dessiner les portes.

Voici le projet:

Code:

flipflop JK
26
nand,a1,3
position,a1,100,61
nand,a2,3
position,a2,100,181
nand,b1,2
position,b1,300,66
nand,b2,2
position,b2,300,176
plot,p1
position,p1,50,132
plot,p2
position,p2,360,78
plot,p3
position,p3,360,120
plot,p4
position,p4,390,188
plot,p5
position,p5,390,150
lien,J,#3,a1/2
lien,tick,#5,p1/3
lien,K,#7,a2/2
lien,tick1,p1/4,a1/3
lien,tick2,p1/2,a2/1
lien,int1,a1,b1/1
lien,int2,a2,b2/2
lien,int3,b1,p2/3
lien,int4,b2,p4/3
lien,int5,p2/2,p3/4
lien,int6,p4/4,p5/2
lien,int7,p3/2,a2/3
lien,int8,p5/4,a1/1
lien,int9,p3/3,b2/1
lien,int10,p5/2,b1/2
lien,Q,p2/1,#23
lien,Qnot,p4/1,#27
*****
2
a1
3
0
0
0
0
0
100
61
0
2
a2
3
0
0
0
0
0
100
181
0
2
b1
2
0
0
0
0
300
66
0
2
b2
2
0
0
0
0
300
176
0
7
p1
4
0
0
0
0
0
0
50
132
0
7
p2
4
0
0
0
0
0
0
360
78
0
7
p3
4
0
0
0
0
0
0
360
120
0
7
p4
4
0
0
0
0
0
0
390
188
0
7
p5
4
0
0
0
0
0
0
390
150
0
1
j
1
-3
1
2
0
0
1
0
75
1
100
75
3
1
tick
1
-5
5
3
0
0
1
0
135
1
50
135
3
1
k
1
-7
2
2
0
0
1
0
195
1
100
195
3
1
tick1
1
5
1
3
0
0
2
53
132
4
53
82
4
100
82
3
1
tick2
1
5
2
1
0
0
2
53
138
2
53
188
2
100
188
3
1
int1
1
1
3
1
0
0
1
120
76
1
300
76
3
1
int2
1
2
4
2
0
0
1
120
196
1
300
196
3
1
int3
1
3
6
3
0
0
1
320
81
1
360
81
3
1
int4
1
4
8
3
0
0
1
320
191
1
390
191
3
1
int5
1
6
7
4
0
0
1
363
84
2
363
120
4
1
int6
1
8
9
2
0
0
1
393
188
4
393
156
2
1
int7
1
7
2
3
0
0
4
363
126
2
363
217
2
95
217
3
95
202
2
100
202
3
1
int8
1
9
1
1
0
0
4
393
150
4
393
53
4
95
53
3
95
68
4
100
68
3
1
int9
1
7
4
1
0
0
3
360
123
3
295
123
3
295
186
2
300
186
3
1
int10
1
9
3
2
0
0
4
393
156
2
398
156
1
285
156
3
285
86
4
300
86
3
1
q
1
6
-23
0
0
0
3
366
81
1
705
81
1
705
75
4
710
75
3
1
qnot
1
8
-27
0
0
0
3
396
191
1
705
191
1
705
195
2
710
195
3

et voici le résultat:

Extra Klaus, content d'avoir pu le voir avant d'aller dormir.
Je pense que l'on peut dire que maintenant, cette phase de dessin du circuit logique est opérationnel complétement.
Tu as d'autres objectifs pour ce programme ?

Déjà une nouvelle version:
- après un chargement d'un projet, la visualisation des contacts n'était plus assuré. C'est corrigé.
- le schéma s'affiche maintenant automatiquement, après chaque génération, et après chaque chargement par le bouton Ouvrir. C'est plus simple et plus convivial comme ça.

D'autres projets par rapport à ce programme ? Mais oui !
- D'abord, je vais réaliser l'objet TEXT que tu as suggéré - ce n'est pas compliqué et j'en vois bien sûr l'utilité.

- Ensuite, je vais faire une base de temps, accessibles par des bornes apparaissant en bas du schéma (en réalité, les bornes 31 à 40). Ces bornes seront en lecture seule et alimentées automatiquement par le programme. Chaque borne représente une fréquence particulière et peut être utilisée pour alimenter l'entrée "clock" d'une bascule JK, par exemple, un compteur, ... La fréquence sera réglable, et on pourra laisser exécuter un nombre défini de cycles, ou indéfiniment, en l'arrêtant par un bouton d'interruption. Ce sera un bel ajout et nécessite un peu plus de travail. Mais ce qui me fait plaisir, c'est qu'il s'agit d'ajouts uniquement périphériques au programme, et rien ne touche au moteur interne de simulation qui sera seulement sollicité en boucle au lieu de l'être uniquement sur un clic de bouton.

D'ailleurs, une remarque. Si l'on considère les portes logiques, dans un sens plus abstrait, comme des moyens de prendre une décision en fonction de valeurs en entrée et d'une règle de décision précise, on peut utiliser ce programme pour construire un outil de prise de décision en fonction de valeurs en entrée. Il suffit de coder les conditions sur 10, 15, 20, ... contacts, d'écrire l'expression logique, puis de la réaliser en circuit - on obtient une réponse en 1 ou 0, qui peut signifier vrai/faux, autorisé/interdit, possible/impossible, etc.

Ceci juste pour sourire un peu, car un peu de réflexion conduit (ou devrait conduire) au même résultat.

Nouvelle version:

Ajout de l'objet TEXT !

Format de la commande: TEXT,x,y,text
Les guillemets ne sont pas utiles. Le 3ème paramètre en totalité sera pris comme texte.

C'est un objet "neutre": il est inactif et ne peut pas être lié, il n'a ni nom ni entrée ni sortie.

Voici le projet JK avec quelques textes comme libellés:

Code:

flipflop JK
30
nand,a1,3
position,a1,100,61
nand,a2,3
position,a2,100,181
nand,b1,2
position,b1,300,66
nand,b2,2
position,b2,300,176
plot,p1
position,p1,50,132
plot,p2
position,p2,360,78
plot,p3
position,p3,360,120
plot,p4
position,p4,390,188
plot,p5
position,p5,390,150
lien,J,#3,a1/2
lien,tick,#5,p1/3
lien,K,#7,a2/2
lien,tick1,p1/4,a1/3
lien,tick2,p1/2,a2/1
lien,int1,a1,b1/1
lien,int2,a2,b2/2
lien,int3,b1,p2/3
lien,int4,b2,p4/3
lien,int5,p2/2,p3/4
lien,int6,p4/4,p5/2
lien,int7,p3/2,a2/3
lien,int8,p5/4,a1/1
lien,int9,p3/3,b2/1
lien,int10,p5/2,b1/2
lien,Q,p2/1,#23
lien,Qnot,p4/1,#27
text,150,130,Bascule JK
text,10,60,J
text,10,120,Tick
text,10,180,K
*****
2
a1
3
0
0
0
0
0
100
61
0
2
a2
3
0
0
0
0
0
100
181
0
2
b1
2
0
0
0
0
300
66
0
2
b2
2
0
0
0
0
300
176
0
7
p1
4
0
0
0
0
0
0
50
132
0
7
p2
4
0
0
0
0
0
0
360
78
0
7
p3
4
0
0
0
0
0
0
360
120
0
7
p4
4
0
0
0
0
0
0
390
188
0
7
p5
4
0
0
0
0
0
0
390
150
0
1
j
1
-3
1
2
0
0
1
0
75
1
100
75
3
1
tick
1
-5
5
3
0
0
1
0
135
1
50
135
3
1
k
1
-7
2
2
0
0
1
0
195
1
100
195
3
1
tick1
1
5
1
3
0
0
2
53
132
4
53
82
4
100
82
3
1
tick2
1
5
2
1
0
0
2
53
138
2
53
188
2
100
188
3
1
int1
1
1
3
1
0
0
1
120
76
1
300
76
3
1
int2
1
2
4
2
0
0
1
120
196
1
300
196
3
1
int3
1
3
6
3
0
0
1
320
81
1
360
81
3
1
int4
1
4
8
3
0
0
1
320
191
1
390
191
3
1
int5
1
6
7
4
0
0
1
363
84
2
363
120
4
1
int6
1
8
9
2
0
0
1
393
188
4
393
156
2
1
int7
1
7
2
3
0
0
4
363
126
2
363
217
2
95
217
3
95
202
2
100
202
3
1
int8
1
9
1
1
0
0
4
393
150
4
393
53
4
95
53
3
95
68
4
100
68
3
1
int9
1
7
4
1
0
0
3
360
123
3
295
123
3
295
186
2
300
186
3
1
int10
1
9
3
2
0
0
4
393
156
2
398
156
1
285
156
3
285
86
4
300
86
3
1
q
1
6
-23
0
0
0
3
366
81
1
705
81
1
705
75
4
710
75
3
1
qnot
1
8
-27
0
0
0
3
396
191
1
705
191
1
705
195
2
710
195
3
8
../..
0
0
1
0
150
130
0
8
../..
0
0
2
0
10
60
0
8
../..
0
0
3
0
10
120
0
8
../..
0
0
4
0
10
180
0
4
Bascule JK
J
Tick
K

Tiens comme tu utilises le terme libellé, petite proposition, est-ce que justement, tu ne metterais pas un libellé (objet texte avec coordonnées automatiques) pour chaque porte ?
L'avantage serait de standardiser l'affichage d'une part et d'en tenir compte pour le tracé des liens.
C'est une facilité, puisque quand tu tapes ton circuit tu rempli juste le champ sans avoir à calculer les coordonnées.

Un peu comma la commande POSITION qui est générée automatiquement ? C'est à voir...

Toutefois, pour le moment, 'encombrement des objets n'est pas pris en compte pour le calcul du tracé des liens. C'est encore un gros morceau que j'ai repoussé à plus tard, si toutefois il y en a besoin. Car alors, cela reviendrait à résoudre par un algorithme une problématique qui correspond à un labyrinthe, et c'est pour le moment au-delà des buts de ce petit programme.

Avant d'attaquer les bases de temps, j'ai décidé de couper le bouton de génération en deux; un bouton pour regénérer tout, et un autre pour générer les objets nouveaux, sans toucher au circuit existant. Ceci permettra d'ajouter des liens ou des textes sans modifier le tracé. Il faudra aussi que je fasse une possibilité se duppression d'un objet, non seulement dans le mémo, mais aussi dans le circuit généré ainsi que dans le trace. Ca viendra.

Cool C'est vrai que ce n'est pas marrant de devoir refaire les ségments correctement si on veut ajouter une porte ... Tant que les circuits sont simples, ce n'est pas trop génant, mais quand cela se compliquera, tout bien faire du premier coup risque d'être plus compliqué, du coup, en effet, devoir replacer tous les ségments à leur place quand on regénère le circuit serait fastidieux.

Le fait de pouvoir juste le mettre à jour sera bien pratique.

Nouvelle version: le bouton de génération est scindé en deux: d'une part la génération de "tout", et d'autre part, la génération des "nouveaux" objets.

La génération des "nouveaux" ne prend PAS en compte des modifications dans ce qui existe déjà (positions, nombre d"entrées, etc. Pour cela, il faut toujours faire une génération complète. Je suis en train d'étudier une prise en compte des modifications des positions an ne modifiant que les liens concernés sur le segment concerné, mais c'est plus complexe.