Retro-Projekt: NE555 basierter Elektronischer Würfel in THT

[Tim . (cpldcpu)]

Anbei ein kleines Retro-Projekt in through-hole-technology, ein 
elektronischer Würfel.

Die Schaltung kommt mit nur drei NE555 aus und ist in der Zahl der 
Bauteile absolut minimiert. Es gibt keinen Zähler IC, wie CD4017. Kommt 
jemand darauf, wie er funktioniert? ;)

(Die 1µF Kondensatoren sind in Ermangelung von Elkos übrigens als SMD 
auf der Rückseite bestückt)

Das Projekt ist das Ergebnis einiger Optimierungsrunden hier:
https://hackaday.io/project/183938-circuit-golf-electronic-dice-edition

Details zur Implementierung:
https://hackaday.io/project/183938-circuit-golf-electronic-dice-edition/log/203213

Wer kann die Schaltung noch weiter vereinfachen?

https://youtu.be/87U51SCs45A

[Gerald B. (gerald_b)]

Ohne jetzt dem Link gefolgt zu sein, wenn es keinen Zähler gibt, dann 
werden die einzelnen 3 relevanten Bits mit jeweils einem 555 erwürfelt. 
Es sind quasi 3 Zufallsgeneratoren :-)

[Jabba (Gast)]

Der NE555 ist jetzt 50 Jahre alt geworden.

[Tim . (cpldcpu)]

Gerald B. schrieb:
> Ohne jetzt dem Link gefolgt zu sein, wenn es keinen Zähler gibt, dann
> werden die einzelnen 3 relevanten Bits mit jeweils einem 555 erwürfelt.
> Es sind quasi 3 Zufallsgeneratoren :-)

Drei bits sind allerdings 8 Zustände. Es werden genau 6 gebraucht :)

[Martin (Gast)]

Gratuliere zum echten Rückschritt: statt eines ATtiny13(a), drei NE555, 
drei Transistoren plus Kleinkram.

[MaWin (Gast)]

Tim  . schrieb:
> Wer kann die Schaltung noch weiter vereinfachen?

Die Schaltung würfelt nicht statistisch sauber, jede Augenzahl kommt 
unterschiedlich oft.

Ganz viele Würfel

http://pegons-web.de/555game.html

ganz ohne IC

http://www.dieelektronikerseite.de/Circuits/Elektronischer%20Wuerfel.htm

[Tim . (cpldcpu)]

MaWin schrieb:
> Die Schaltung würfelt nicht statistisch sauber, jede Augenzahl kommt
> unterschiedlich oft.

Wie kommst Du darauf? Das stimmt nicht.

[Tim . (cpldcpu)]

MaWin schrieb:
> http://www.dieelektronikerseite.de/Circuits/Elektronischer%20Wuerfel.htm

Danke! Interessante Implementierung.

[MaWin (Gast)]

Tim  . schrieb:
> Wie kommst Du darauf? Das stimmt nicht.

Die Phasenverschiebung ist nicht exakt 60 Grad sondern von den Bauteilen 
abhängig.

[Michael M. (Firma: Autotronic) (michael_metzer)]

Theoretisch genügt ein einziger 7492 und ein Taktgeber. Die beiden 7402 
(NOR) können weitestgehend durch ODER-Dioden ersetzt werden. Die 
Invertierung der LED QA (grüner Kreis) wird durch Umklemmen an GND 
realisiert. Lediglich die UND-Verknüpfung LED QA und QC (roter Kreis) 
muss mit einem Transistor umgesetzt werden (De Morgan anwenden).

Alle anderen Treiber-Transistoren können wegen modernen LEDs entfallen.

[Tim . (cpldcpu)]

MaWin schrieb:
> Die Phasenverschiebung ist nicht exakt 60 Grad sondern von den Bauteilen
> abhängig.

Ja, das stimmmt. Ist aber eher nur über eine sehr große Statistik zu 
sehen.

[Tim . (cpldcpu)]

Michael M. schrieb:
> ediglich die UND-Verknüpfung LED QA und QC (roter Kreis)
> muss mit einem Transistor umgesetzt werden (De Morgan anwenden).

Könnte man auch durch Dioden parallel zur LED ersetzen. Siehe hier:

https://hackaday.io/project/183938-circuit-golf-electronic-dice-edition/log/203107-005-dice3904-8-minimal-transistor-based-dice

Aber ein Zähler-IC ist irgendwie geschummelt :)

[Schlaumaier (Gast)]

Geht auch ohne 555 :)

Du brauchst

7 Lampen
4 x BC 108
4 x 4.7k Ohm
2 x 1k OHM
2 x Elko 10 MF
1 Taster
1 x 7402
1 x 7404
1 x 7492

Fertig :)

Das waren noch Zeiten als ich mit der 74.er Serie gespielt habe.

Zusammenstellung aus einen Fachbuch. War damals mein erstes Projekt.
Ich habe 2 Versuche gebraucht bis er funktioniert ;)

[Tim . (cpldcpu)]

Schlaumaier schrieb:
> Geht auch ohne 555

Tatsächlich? :)

Schlaumaier schrieb:
> 7 Lampen
> 1 x 7492

Schöne Retro-Implementierung mit Glühlampen und Original-TTL. Bietet 
jemend Röhren? Relais hatten wir auch schon :)

[Arne (Gast)]

Tim  . schrieb:
> 
https://hackaday.io/project/183938-circuit-golf-electronic-dice-edition/log/203107-005-dice3904-8-minimal-transistor-based-dice

Gefaellt mir. Ich habe vor 1½ Jahren auch einen Transistor-Wuerfel 
gebaut, aber auf die Idee mit dem Johnson-Zaehler bin ich gar nicht 
gekommen. Mit einem Binaerzaehler mit Rueckkopplung, um zwei 
Zaehlerstaende zu ueberspringen, kommt man auf eine aehnliche Anzahl 
Bauteile: <http://arnerossius.de/temp/PNP-Dice/>;.

Total: 61 components (9 C, 8 D, 7 LED, 28 R, 1 S, 8 T).

Die Transistoren sind alle 2N2646: ein echter und 7 gefaelschte, die in 
Wirklichkeit PNP-Transistoren sind ;-).

Verwendet man einen Taster mit zwei Oeffnerkontakten, kann man sogar 
noch einen Transistor einsparen, indem man den Oszillator und die erste 
Zaehlerstufe kombiniert: 
<http://www.recursion.jp/prose/dice/index.html>;.

[Arne (Gast)]

Grmpf, in der Vorschau haben die Links funktioniert ... Hier nochmal in 
(hoffentlich) richtig:

http://arnerossius.de/temp/PNP-Dice/

http://www.recursion.jp/prose/dice/index.html

[Markus M. (mmvisual)]

Tim  . schrieb:
> Anbei ein kleines Retro-Projekt in through-hole-technology, ein
> elektronischer Würfel.
>
> Die Schaltung kommt mit nur drei NE555 aus und ist in der Zahl der
> Bauteile absolut minimiert. Es gibt keinen Zähler IC, wie CD4017. Kommt
> jemand darauf, wie er funktioniert? ;)
>
> (Die 1µF Kondensatoren sind in Ermangelung von Elkos übrigens als SMD
> auf der Rückseite bestückt)
>
> Das Projekt ist das Ergebnis einiger Optimierungsrunden hier:
> https://hackaday.io/project/183938-circuit-golf-electronic-dice-edition
>
> Details zur Implementierung:
> 
https://hackaday.io/project/183938-circuit-golf-electronic-dice-edition/log/203213
>
> Wer kann die Schaltung noch weiter vereinfachen?
>
> https://youtu.be/87U51SCs45A

Nettes Projekt, tolle Idee und supereinfach zum Umsetzen!

Ja, es geht!!!!
Man kann nochmal 2 Transistoren und 2 Widerstände sparen.
Anstatt die 3 Taktleitungen zu unterbrechen lege ich ControlVoltage auf 
VDD, wenn er nicht zählen soll. Daher braucht es noch einen Transistor 
um den Taster zu negieren. Wenn man statt dem Schließer-Taster einen 
Öffner nimmt, dann kann man auch noch auf den Transi+Widerstand 
verzichten.
Im Anhang der Schaltplan (geänderte Leiterbahnen rot) und ein Foto vom 
Brett-Aufbau.

Ich hatte keine 3x NE555 in DIP, daher ist der Versuchsaufbau mit 1x 
NE556 und 1x NE555. Und damit ich da was Blinken sehe verwende ich für 
den Versuch 22µF statt 100nF. Der echte Würfel sollte natürlich 100nF 
haben.

Der Wettberwerb geht weiter ... geht noch mehr?

[Tim . (cpldcpu)]

Arne schrieb:
> Gefaellt mir. Ich habe vor 1½ Jahren auch einen Transistor-Wuerfel
> gebaut, aber auf die Idee mit dem Johnson-Zaehler bin ich gar nicht
> gekommen. Mit einem Binaerzaehler mit Rueckkopplung, um zwei
> Zaehlerstaende zu ueberspringen, kommt man auf eine aehnliche Anzahl
> Bauteile: http://arnerossius.de/temp/PNP-Dice/
>
> Total: 61 components (9 C, 8 D, 7 LED, 28 R, 1 S, 8 T).

Interessant! Du hast also drei Toggle-FF zu einem ripple-counter in 
Serie geschaltet. Die Rückkopplung ist über R13/C7 realisiert? Sieht 
ziemlich clever aus.

Was ich noch nicht ganz verstehe: Wie funktioniert der Oszillator mit 
T8? Da fehlt mir irgendwie die Rückkopplung?

Übrigens schöne Realisierung. Bei der Platine habe ich natürlich etwas 
geschummelt, die hätte man früher selbst gezeichnet und geätzt :)

[Tim . (cpldcpu)]

Arne schrieb:
> http://www.recursion.jp/prose/dice/index.html

Die analoge Version gefällt mir! Ist aber wahrscheinlich ziemlich schwer 
zu stabilisieren - die Kondensatorwerte und das Timing müssen genau 
passen.

[Tim . (cpldcpu)]

Markus M. schrieb:
> Nettes Projekt, tolle Idee und supereinfach zum Umsetzen!
>
> Ja, es geht!!!!
> Man kann nochmal 2 Transistoren und 2 Widerstände sparen.
> Anstatt die 3 Taktleitungen zu unterbrechen lege ich ControlVoltage auf
> VDD, wenn er nicht zählen soll. Daher braucht es noch einen Transistor
> um den Taster zu negieren. Wenn man statt dem Schließer-Taster einen
> Öffner nimmt, dann kann man auch noch auf den Transi+Widerstand
> verzichten.
> Im Anhang der Schaltplan (geänderte Leiterbahnen rot) und ein Foto vom
> Brett-Aufbau.
>
> Ich hatte keine 3x NE555 in DIP, daher ist der Versuchsaufbau mit 1x
> NE556 und 1x NE555. Und damit ich da was Blinken sehe verwende ich für
> den Versuch 22µF statt 100nF. Der echte Würfel sollte natürlich 100nF
> haben.
>
> Der Wettberwerb geht weiter ... geht noch mehr?

Wow! Gute Idee, das muss ich gleich einmal ausprobieren. Hatte auch kurz 
darüber nachgedacht, etwas mit dem Eingang zu machen, habe mich aber 
nicht getraut den Node extern zu biasen. Allerdings hängen da ja auch 
nur drei 5kohm Widerstände dran - warum also nicht.

Erreicht der Zähler denn alle Zustände mit gleiche Wahrscheinlichkeit? 
Der TRESH-Eingang wirde deaktiviert, wenn man CONT auf VCC zieht, der 
TRIG-Eingang ist aber noch aktiv?

[Markus M. (mmvisual)]

Tim  . schrieb:
> Erreicht der Zähler denn alle Zustände mit gleiche Wahrscheinlichkeit?
> Der TRESH-Eingang wirde deaktiviert, wenn man CONT auf VCC zieht, der
> TRIG-Eingang ist aber noch aktiv?

Das kann ich schlecht nach kontrollieren, ich hatte in ja nur die 3 
LED's auf dem Steckboard dran. Sah jedoch danach aus.

[Tim T. (tim_taylor)]

Tim  . schrieb:
> Wer kann die Schaltung noch weiter vereinfachen?

Der Zufallsgenerator besteht praktisch nur daraus das alle Würfelmuster 
hintereinander ausgegeben werden solange man den Taster drückt, wenn 
dieser losgelassen wird, bleibt der Würfel stehen. Da dies aber viel 
schneller passiert als das menschliche Auge, oder auch eine Kamera es 
erfassen kann, ist das Ergebnis tatsächlich zufällig.

[Markus M. (mmvisual)]

Hab noch eine Platine designt:
- Mit Spannungsregler, damit man das an 9V anschließen kann
- Verpolungsschutz
- Daher 5 Bauteile extra
- Größe der Platine 45x45mm

[Markus M. (mmvisual)]

Mich lässt die Würfel-Schaltung noch nicht in ruhe...
Leider habe ich doch keinen 7805 in SOT89 in meiner Kiste, nur einen in 
TO220 und das war mir zu hoch.
Die LED's und den Taster habe ich nun doppelt gezeichnet, einmal als SMD 
und THT, damit hat man etwas mehr Freiheiten was man gerade in der Kiste 
liegen hat.

Daher habe ich mich nun doch zu einem Step-Down Spannungsregler 
entschieden. Und da er ein "Enable" Pin hat, dachte es müsste doch 
irgendwie möglich sein, dass man mit dem "Würfeln" die Schaltung 
aktiviert und diese sich nach 20..60 Sekunden dann wieder schlafen legt. 
Im Schlaf liefert der "Enable" Eingang einen konstanten Strom von 2µA, 
damit sollte eine 9V Batterie so ziemlich lange leben.

Falls jemand mag, bitte schaut mal auf den Schaltplan und gebt Bescheid 
ob der Trick mit dem "Würfeln" und dem "Aktivieren" der Stromversorgung 
so funktioniert wie ich mir das ausdachte.

Zu meinen Gedanken zur Funktion und den verwendeten Werten:
Zwischen Basis und Emitter von T1 dürfen lt. Datenblatt maximal 6V sein, 
daher D19.
R12 mit 10K, denn wenn der Taster betätigt wird und am Eingang 24V 
Versorgung anliegen, so würde durch den Widerstand 1,9mA fließen 
(24V-5V=19V) und die Spannung würde damit auch nicht über 5V angehoben 
werden, da die 2mA durch die LED's fließen.
Die Abschaltdauer ist nicht so einfach zu errechnen, Schwelle von EN ist 
1,24V mit einer Konstantstromquelle von 2µA. Sobald der Widerstand R11 > 
als 620KOhm ist würde der Spannungsregler nicht mehr abschalten. C9 ist 
ein optionaler Platz, falls man etwas mehr Kapazität braucht. Und sollte 
das doch nicht so funktionieren, so kann mit J1-Lötbrücke und 
Umbestückung die Funktion vom Taster wie vom zuvorigen Thread erreicht 
werden.

[Tim . (cpldcpu)]

Ich habe mal eines von meinen PCBs umgebaut (siehe Bild, mit fliegendem 
PNP-Transistor).

Leider sieht es so aus, als wenn nur die Patters 1,2,6 angezeigt werden. 
Ich vermute, dass bei den anderen der Würfel auch dann "weiter rollt", 
wenn er angehalten ist. Möglicherweise ein Problem mit dem noch aktiven 
TRIG-Eingang. Muss später einmal darüber nachdenken.

[Tim . (cpldcpu)]

Markus M. schrieb:
> Leider habe ich doch keinen 7805 in SOT89 in meiner Kiste, nur einen in
> TO220 und das war mir zu hoch.

Benötigst Du wirklich einen Spannsungsregler? Alle Bauteile können einen 
relativ großen Spannungsbereich ab. Bei höheren Spannungen werden 
lediglich die LEDs etwas heller. Kann meinen Würfel problemlos zwischen 
4-10V betreiben.

[Markus M. (mmvisual)]

Ich wollte den mit 9V Batterie betreiben, auch mit 12V Akkus oder mal 
24V.
Und die Doppel-LED's hab ich in Reihe geschaltet, daher läuft meine 
Schaltung mit 4V nicht mehr, bzw. sollte relativ exakt 5V haben. Bei 9V 
würde wegen dem LED Vorwiderstand, der für 5V ausgelegt ist, viel zu 
viel Strom durch die LED's fließen. Auch sollten die LED's schön gleich 
hell leuchten, daher nicht parallel.

> als wenn nur die Patters 1,2,6 angezeigt werden
Ich müsste mein Steckbrett auch nochmal zusammen stecken, hab mir leider 
kein Video gedreht.

[Arne (Gast)]

Tim  . schrieb:
> Interessant! Du hast also drei Toggle-FF zu einem ripple-counter in
> Serie geschaltet. Die Rückkopplung ist über R13/C7 realisiert? Sieht
> ziemlich clever aus.

Ich habe zum Thema Transistor-Zaehler vor einiger Zeit mal intensiv 
recherchiert, und diese Idee IIRC in einem US-Patent gefunden. Leider 
kann ich es auf die Schnelle nicht mehr wiederfinden. Die Service 
Manuals zu den alten HP-Frequenzzaehlern sind auch einen Blick wert 
(z.B. AC-4, Roehrenbestueckter BCD-Zaehler, oder etwas moderner 5245L 
mit Transistoren).

> Was ich noch nicht ganz verstehe: Wie funktioniert der Oszillator mit
> T8? Da fehlt mir irgendwie die Rückkopplung?

T8 ist ein UJT, da gibt es einen Bereich mit negativem Widerstand 
aehnlich wie bei einer Glimmlampe (oder sogar BJT: 
https://www.dos4ever.com/ring/ring.html#amazing), aber bei niedrigerer 
Spannung. Die hier verwendete Oszillatorschaltung findet man so oder 
aehlich auch in mehreren Elektor-Schaltungen aus den 1970ern -- spaeter 
waren dann wohl zwei BJT billiger ;-).

Tim  . schrieb:
> Die analoge Version gefällt mir! Ist aber wahrscheinlich ziemlich schwer
> zu stabilisieren - die Kondensatorwerte und das Timing müssen genau
> passen.

Das dachte ich mir auch, daher habe ich lieber auf die digitale 
Schaltung gesetzt. Offenbar bekommt man die analoge Version aber sogar 
mit noch mehr Stufen zuverlaessig hin: 
http://www.fernekes.com/2020/04/all-transistor-clock/

[Tim . (cpldcpu)]

Tim  . schrieb:
> Ich habe mal eines von meinen PCBs umgebaut (siehe Bild, mit fliegendem
> PNP-Transistor).
>
> Leider sieht es so aus, als wenn nur die Patterns 1,2,6 angezeigt werden.
> Ich vermute, dass bei den anderen der Würfel auch dann "weiter rollt",
> wenn er angehalten ist. Möglicherweise ein Problem mit dem noch aktiven
> TRIG-Eingang. Muss später einmal darüber nachdenken.

Ok, bin leider erst jetzt dazu gekommen. (Ja, wenn man mitten in der 
Nacht aufwacht...)

Die Sequenz des Ring-Zählers ist wie folgt:

001    3
011    1
010    5
110    6
100    4
101    2

Das Mapping auf die Augenzahlen steht daneben.

Wie man sehen kann, ändert sich immer ein Bit zur Zeit. Entweder von 
einer 1 auf eine 0, oder umgekehrt.

Wie oben schon geschrieben, deaktiviert man durch das Hochziehen da 
CONT/CA Pins auf VCC den TRSH eingang. Der TRIG-Eingang ist aber 
trotzdem noch aktiv.

Ein LO Pegel am TRIG-Eingang zieht den Ausgang auf HI. Dass heisst immer 
dann, wenn der nächste Bitübergang einer von 0 auf 1 ist, wird dieser 
durch CONT/CA nicht gestoppt.

D.h. die Übergange des Zählers 3->1, 5->6 und 4->2 finden auch be 
gestopptem Würfel statt. Das erklärt, warum der Würfel nur bei 1,2,6 
stehen bleibt.

[Tim . (cpldcpu)]

Arne schrieb:
> T8 ist ein UJT, da gibt es einen Bereich mit negativem Widerstand
> aehnlich wie bei einer Glimmlampe (oder sogar BJT:
> https://www.dos4ever.com/ring/ring.html#amazing), aber bei niedrigerer
> Spannung. Die hier verwendete Oszillatorschaltung findet man so oder
> aehlich auch in mehreren Elektor-Schaltungen aus den 1970ern -- spaeter
> waren dann wohl zwei BJT billiger ;-).

https://en.wikipedia.org/wiki/Unijunction_transistor
https://saliterman.umn.edu/sites/saliterman.dl.umn.edu/files/general/solid_state_power_switching.pdf

Ah ok, war mir als Device noch gar nicht bekannt. Interessant! 
Allerdings heute wohl sehr exotisch.

[Markus M. (mmvisual)]

Tim  . schrieb:
> D.h. die Übergange des Zählers 3->1, 5->6 und 4->2 finden auch be
> gestopptem Würfel statt. Das erklärt, warum der Würfel nur bei 1,2,6
> stehen bleibt.

Danke für die Erklärung!
Dann ist meine Idee der Optimierung eher Suboptimal. Erhöht zwar die 
Chancen eine 6 zu bekommen, dafür auch die kleine Zahlen zu bekommen.

[Tim . (cpldcpu)]

Markus M. schrieb:
> Erhöht zwar die
> Chancen eine 6 zu bekommen, dafür auch die kleine Zahlen zu bekommen.

Naja, die Wahrscheinlichkeit eine 1,2 oder 6 zu bekommen liegt bei 
jeweils 33.3% (+- Bauteiletoleranz), während sie für 3,4,5 bei 0% liegt.

[Tim . (cpldcpu)]

Tim T. schrieb:
> Tim  . schrieb:
>> Wer kann die Schaltung noch weiter vereinfachen?
>
> Der Zufallsgenerator besteht praktisch nur daraus das alle Würfelmuster
> hintereinander ausgegeben werden solange man den Taster drückt, wenn
> dieser losgelassen wird, bleibt der Würfel stehen. Da dies aber viel
> schneller passiert als das menschliche Auge, oder auch eine Kamera es
> erfassen kann, ist das Ergebnis tatsächlich zufällig.

Einen µC zu nutzen ist natürlich geschummelt. :) Trotzdem kann man den 
MCU-Würfel noch weiter vereinfachen:

https://cpldcpu.wordpress.com/2016/11/26/dice10-electronic-dice-controlled-by-two-gpio/
https://cpldcpu.wordpress.com/2015/05/24/plexingplus/

[Markus M. (mmvisual)]

Ein µC wollte ich jetzt auch nicht nutzen, ich hab das schon den ganzen 
Tag von Beruf wegen.
Das ist mal was "Analoges" etwas entspanntes dazwischen ganz gut.

[Tim T. (tim_taylor)]

Tim  . schrieb:
>
> Einen µC zu nutzen ist natürlich geschummelt. :)

Naja, ich bin von den Anforderungen THT, wenig Bauteile und preiswert 
ausgegangen. Generell nutze ich den NE555 schon lange nicht mehr, da ein 
Tiny13A bei mir praktisch immer die einfachere und flexiblere Variante 
darstellt.

[Claus K. (claus_k246)]

Guten Abend, liebe Gemeinde ;)
Wer einen prellenden Taster hat, braucht für einen elektronischen Würfel 
keinen Oszillator.
Und da es hier um Retro ging, wollte ich gerne auch noch einmal posten, 
was ich mir vor 48 Jahren überlegt hatte: Nur 2 ICs sollten es sein, 
Treiber inklusive. Damals brauchte eine LED noch 20 mA, so dass die 40 
mA, die ein 7447 schafft, gut passten. Um herauszufinden, wie der 7447 
am Eingang und am Ausgang zu beschalten ist, hat mir ein Kumpel damals 
ein Lochkarten-Programm geschrieben. Das lief dann 12 Stunden, bis es 
die Lösung fand. Ich habe dieselbe Aufgabe heute meinem ESP gestellt. Er 
brauchte 1600 Millisekunden, um 8 LÖsungen zu finden.

[Claus K. (claus_k246)]

... und falls sich jemand dafür interessiert, wie man sowas lösen kann, 
hier noch der Code:

/*
 * 
 * 1/ Aufgabenstellug:
 * ===================
 * Es soll ein elektronischer Würfel mit 7 LEDs realisiert werden.
 * Als Zähler soll ein 7492 oder 74LS97 o.ä. eingesetzt werden. 
 * Die LEDs sollen an einen zweckentfremdeten 7-Segment-Decoder/Treiber 
 * 7447 oder 74LS47 angeschlossen werden (Ausgangsstrom: 40 bzw. 24 mA). 
 * 
 * 2/ Nomenklatur:
 * ===============
 * M = LED in der Mitte des Würfels (für die Würfelbilder 1, 3 und 5)
 * L = LED-Paar von links unten nach rechts oben (für die 2, 3, 4, 5, 6)
 * R = LED-Paar von rechts unten nach links oben (für die 4, 5, 6) 
 * Q = LED-Paar quer (für die 6)
 * a, b, c, d, e, f, g = Ausgänge des Decoder/Treibers 7447/74LS47
 * A, B, C, D          = Eingänge des Decoder/Treibers 
 * U, V, W             = der Eindeutigkeit halber umbenannte Ausgänge
 *                       des Zählers 7492/74LS92 (eigentlich: QB, QC, QD) 
 * X                   = Festpotenzial, wahlweise low(0) oder high(1) 
 * 
 * 3/ Lösungsansatz
 * ================
 * a/ Die LED-Anschlüsse M,L,R,Q können auf unterschiedliche Weise mit
 *    den Decoder/Treiber-Ausgängen a,b,c,d,e,f,g verbunden werden.
 * b/ Die Eingänge des Decoder/Treibers können auf unterschiedliche Weise mit
 *    den Zählerausgängen U,V,W (s.o.) und dem Festpotenzial X verbunden werden. 
 *    Das Festpotenzial X kann 0 oder 1 sein. 
 * c/ Für jede der Kombinationen aus /a/ und /b/ ist zu prüfen, ob damit dann 
 *    die 6 Zustände des Zählers: 0, 1, 2, 4, 5, 6
 *    die 6 gewünschten Würfelbilder ergeben, wobei die Reihenfolge einerlei ist; 
 *    es muss nur die Häufigkeit des Auftretens gezählt werden. 
 *    
 * 4/ Lösung
 * ========= 
 * Drei ineinander verschchtelte Prozeduren, darin jeweils einige ineinander 
 * verschachtelte Schleifen simulieren die o.g. Kombinationen /a/ und /b/. 
 * In der innersten Prozedur /c/ wird das Durchlaufen des Zähler simuliert 
 * und geprüft, ob jedes der gewünschten Würfelbilder mindestens einmal auftritt. 
 * Falls ja, wird das Ergebns über die Serial ausgegeben. 
 * Während der Entwicklung waren weitere Ausgaben über die Serial hilfreich. 
 * Diese können mit der Variable 'debugLevel' freigeschaltet oder unterdrückt werden. 
 * 
 * 5/ Ergebnis
 * ===========
 * Die nachfolgenden Prozeduren wurden auf einer Node-MCU V.3 / ESP-12E implementiert:  
 * 1.451.520 verschachtelte Schleifen benötigten 1604 ms und ergaben 8 Lösungen. 
 * Einzelheiten siehe RESULTATE im Kommentar am Ende dieses Sketches.  
 * Eine der 8 Lösungen wurde für den Stromlaufplan übernommen. 
 * 
 * 
 */

// ********** Deklarationen ********** // 

// ---------- Konstanten ------------- //
#define countof(a) (sizeof(a) / sizeof(a[0]))

const unsigned int debugLevelA = 9 ; // auf Ebene: SchleifeEINgangsBeschaltung()
const unsigned int debugLevelB = 8 ; // auf Ebene: SchleifeAUSgangsBeschaltung()
const unsigned int debugLevelC = 7 ; // auf Ebene: SchleifeWuerfelBilderUeberZaehlerStaende()
const unsigned int debugLevel  = 7 ; // freigeben bzw. unterdrücken der Debug-Ausgaben via Serial 

const char cntOut[]       =   "UVWX"   ;  // SN7492: R=QB, S=QC, T=QD, X=Dauer-0 oder Dauer-1 
const char decInp[]       =   "ABCD"   ; 
const char decOut[]       =   "abcdefg"; 
const char Decoder[17][8] = { "1111110",  // 0 - Abbild des 7-Segment-Decoders: SN7447/SN74LS47 
                             //abcdefg//         hier gilt: 0=OFF, 1=ON (und nicht: 0=low, 1=high) 
                              "0110000",  // 1
                              "1101101",  // 2
                              "1111001",  // 3
                              "1001100",  // 4
                              "1011011",  // 5
                              "0011111",  // 6
                              "1110000",  // 7
                              "1111111",  // 8
                              "1110011",  // 9
                              "0001101",  // 10
                              "0011001",  // 11
                              "0100011",  // 12
                              "1001011",  // 13
                              "0001111",  // 14
                              "0000000"}; // 15

const char Wuerfel[7][5] =  { "????",  // pseudo-0 
                           //  QLRM    // 
                              "0001",  // 1
                              "0010",  // 2
                              "0011",  // 3
                              "0110",  // 4
                              "0111",  // 5
                              "1110"}; // 6

// Ausgangssignale des SN7492 an den Pins QB=0, QC=1, QD=2, bit-pos 3=FestPotenzial 
const int cntSteps[2][6][4] = {{{ 0,0,0,0 },    // 0 - ab hier Dauer-LOW
              // Bit-Position     0,1,2,3       //   - LSB ist hier links !
                                { 1,0,0,0 },    // 1 
                                { 0,1,0,0 },    // 2
                                { 0,0,1,0 },    // 4
                                { 1,0,1,0 },    // 5 
                                { 0,1,1,0 }},   // 6                
                               {{ 0,0,0,1 },    // 0 - ab hier Dauer-HIGH
                                { 1,0,0,1 },    // 1 
                                { 0,1,0,1 },    // 2
                                { 0,0,1,1 },    // 4
                                { 1,0,1,1 },    // 5 
                                { 0,1,1,1 }}};  // 6            


// ---------- Variablen -------------- //
                        
char PrintString[100];    // im ESP ist Platz genug... 
int successCount[7];      // 1(!) ... 6(!), zur Überprüfung, ob jedes Würfelbild mindestens einmal auftritt 
int hurra = 0;            // Erfolgszähler für passende Beschaltungs-Kombinationen 
int M, L, R, Q ;          // legt die Eingänge des Würfels auf 0..6, das sind die 7 Ausgänge a..g des Decoders 
int A, B, C, D ;          // legt die Eingänge des Decoders auf 0..3, das sind die 3+1 Ausgänge B,C,D + Hi or Lo des Zählers 
int FP;                   // FestPotenzial: 0 oder 1 für low oder high 
int DecInpVal ;           // Decoder-Input-Value in Abhängigkeit von der Eingangsbeschaltung und dem Zählerstand 
int CntOutNum ;           // Zählerstand 0..5, obgleich der Zähler anders zählt: 0,1,2,4,5,6 plus FestPotential 
long int rowCnt =0 ;      // numeriert die Zeilen für die Debug-Ausgaben via Serial 
long int LoopCnt=0 ;      // zählt die ineinander verschachtelten Schleifen 




// ***** ***** IMPLEMENTIERUNG ***** ***** // 
// ----- ----- Haupt-Routinen  ----- ----- //

void loop() {
  delay( 1000 );   // hier gibt es ansonsten nix zu tun 
}


void setup() {
  Serial.begin( 115200 );   delay( 1000 ); 
  Serial.println(); 
  Serial.println( F( "Elektronischer Würfel mit 2 ICs: Suchlauf für Eingangs- und Ausgangs-Matrix" )); 
  Serial.println( F( "SN7492(012456) --> E-Matrix --> SN7447 --> A-Matrix --> Würfel(MLRQ)" )); 
  Serial.println( F( "***** START *****" )); 
  Serial.println(); 

  long stoppUhr = millis(); 
    SchleifeEingangsBeschaltung(); 
  stoppUhr = millis() - stoppUhr; 
  Serial.println(); 
  snprintf_P( PrintString, countof( PrintString ),         
    PSTR( "*** fertig! *** %d verschachtelte Schleifen benötigten %d ms und ergaben %d Lösungen" ), 
          LoopCnt, stoppUhr, hurra ); 
    Serial.println( PrintString );     
}




// ----- ----- Unter-Routinen  ----- ----- //

void SerialPrintInputOutput(){
  snprintf_P( PrintString, 
    countof( PrintString ),         
//  PSTR( "%5d  Eingang: A=%c  B=%c  C=%c  D=%c  X=%d  /  Ausgang: M=%c  L=%c  R=%c  Q=%c" ),
//  rowCnt, cntOut[A], cntOut[B], cntOut[C], cntOut[D], FP, decOut[M], decOut[L], decOut[R], decOut[Q] ); 
    PSTR(      "Eingang: A=%c  B=%c  C=%c  D=%c  X=%d  /  Ausgang: M=%c  L=%c  R=%c  Q=%c" ),
            cntOut[A], cntOut[B], cntOut[C], cntOut[D], FP, decOut[M], decOut[L], decOut[R], decOut[Q] ); 
  Serial.println( PrintString ); 
}


void SchleifeEingangsBeschaltung(){  
// Die 4 EingangsPins A,B,C,D des Decoders werden in allen möglichen Kombinationen ...
// ... auf die 3 AusgangsPins B,C,D des Zählers SN7492 sowie ein FestPotenzial gelegt.
// Die AusgangsPins B,C,D sind auf die BitPositionen 0,1,2 gemappt, das FestPotenzial auf Pos.3 
// cntSteps[2][6][4] 
  for( FP=0;   FP<=1;  FP++ ){
    for( A=0;   A<4;   A++ ){
      for( B=0;   B<4;   B++ ){
        for( C=0;   C<4;   C++ ){
          for( D=0;   D<4;   D++ ){
            if( A!=B && A!=C && A!=D && B!=C && B!=D && C!=D ){
              if( debugLevel >= debugLevelA ){
                snprintf_P( PrintString,                               
                  countof( PrintString ),         
                  PSTR( "Eingang:  A=%d  B=%d  C=%d  D=%d  FP=%d  -->  " ),
                                   A, B, C, D, FP ); 
                Serial.print( PrintString ); 
              } // end of debugLevel >= debugLevelA
              SchleifeAusgangsBeschaltung() ; 
            } // end of keine Doppel
          } // D
        } // C
      } // B
    } // A
  } // FP 
} // end of loopLevelA


void SchleifeAusgangsBeschaltung(){ 
// Die 4 EingangsPins M,L,R,Q des Decoders werden in allen möglichen Kombinationen ...
// ... auf die 7 AusgangsPins a,b,c,d,e,f,g des Decoders SN7447 gelegt.
  for( M=0;   M<7;   M++ ){
    for( L=0;   L<7;   L++ ){
      for( R=0;   R<7;   R++ ){
        for( Q=0;   Q<7;   Q++ ){
          if( M!=L && M!=R && M!=Q && L!=R && L!=Q && R!=Q ){
            rowCnt++; 
            if( debugLevel >= debugLevelB ){ SerialPrintInputOutput(); }             
            SchleifeWuerfelBilderUeberZaehlerStaende(); // prüft, ob hierbei die gewünschten Würfel-Kombinationen auftreten
          } // end of keine Duplikate 
        } // Q
      } // R
    } // L
  } // M
} // end of SchleifeAusgangsBeschaltung()


void SchleifeWuerfelBilderUeberZaehlerStaende(){
// Mittels Variable CntOutNum werden die 6 Zustände 0..5 des Zählers simuliert 
// Der Zähler selbst zählt: 0,1,2,4,5,6 plus Dauer-Low oder -High 
// Was davon am Decoder-Eingang ankommt (DecInpVal), bestimmt die SchleifeEingangsBeschaltung()  
// cntSteps[2][6][4]
  for( int i=1;   i<=6;   i++ ){ successCount[i] = 0; } // ErgebnisSpeicher löschen/initialisieren 
  for( CntOutNum=0;   CntOutNum<=5;   CntOutNum++ ){    // Schleife über die 6 ZählerStände 
    DecInpVal = cntSteps[ FP ][ CntOutNum ][ A ]
              + cntSteps[ FP ][ CntOutNum ][ B ] * 2
              + cntSteps[ FP ][ CntOutNum ][ C ] * 4
              + cntSteps[ FP ][ CntOutNum ][ D ] * 8 ;        
    int found=0 ; 
    char vector[ 10 ]; 
    vector[0] = Decoder[ DecInpVal ][ Q ] ;   // war: [ M ] ;
    vector[1] = Decoder[ DecInpVal ][ R ] ;   // war: [ L ] ;
    vector[2] = Decoder[ DecInpVal ][ L ] ;   // war: [ R ] ;
    vector[3] = Decoder[ DecInpVal ][ M ] ;   // war: [ Q ] ;
    vector[4] = 0 ;
    for( int j=1;   j<=6;   j++ ){    // Würfel zählt von 1 bis 6 
      LoopCnt++ ;
      if( strcmp( vector, Wuerfel[j]) == 0 ){ // ist der Vector ein Würfelbild? 
        found=j; 
        successCount[j]++; 
      } // end of Vector ist ein Würfelbild  
    } // end of loop over j=1 to 6
  } // end of Durchlaufen der 6 Zählerstände
  int help=true; 
  for( int i=1;   i<=6;   i++ ){      // kam in der Schleife oben jedes Würfelbild einmal vor 
    if( successCount[i] < 1 ){ help=false; }    // war  !=1  
  } // end of Untersuchung der 6 Häufigkeiten 
  if( help==true ){ 
    hurra++; 
    if( debugLevel >= debugLevelC ){ SerialPrintInputOutput(); } 
  } // end of if help=true  
} // end of SchleifeWuerfelBilderUeberZaehlerStaende() 




/* ***** ***** RESULTATE ***** ***** // 
   vom Serial Monitor aufgezeichnet: 
   ---------------------------------
 
Elektronischer Würfel mit 2 ICs: Suchlauf für Eingangs- und Ausgangs-Matrix
SN7492(012456) --> E-Matrix --> SN7447 --> A-Matrix --> Würfel(MLRQ)
***** START *****

Eingang: A=W  B=X  C=U  D=V  X=1  /  Ausgang: M=a  L=d  R=e  Q=f     <---<< diese Variante für den Schaltplan verwendet 
Eingang: A=W  B=X  C=U  D=V  X=1  /  Ausgang: M=a  L=g  R=e  Q=f    
Eingang: A=W  B=X  C=U  D=V  X=1  /  Ausgang: M=b  L=d  R=e  Q=f
Eingang: A=W  B=X  C=U  D=V  X=1  /  Ausgang: M=b  L=g  R=e  Q=f
Eingang: A=W  B=X  C=V  D=U  X=1  /  Ausgang: M=a  L=d  R=e  Q=f
Eingang: A=W  B=X  C=V  D=U  X=1  /  Ausgang: M=a  L=g  R=e  Q=f
Eingang: A=W  B=X  C=V  D=U  X=1  /  Ausgang: M=b  L=d  R=e  Q=f
Eingang: A=W  B=X  C=V  D=U  X=1  /  Ausgang: M=b  L=g  R=e  Q=f

*** fertig! *** 1451520 verschachtelte Schleifen benötigten 1604 ms und ergaben 8 Lösungen



*/

[Claus K. (claus_k246)]

Korrektur: Der Anschluss "/BI-/RBO" muss offen bleiben

[Tim . (cpldcpu)]

Claus K. schrieb:
> Guten Abend, liebe Gemeinde ;)
> Wer einen prellenden Taster hat, braucht für einen elektronischen Würfel
> keinen Oszillator.

hmm... Kann man das irgendwie optimieren? :)

> Und da es hier um Retro ging, wollte ich gerne auch noch einmal posten,
> was ich mir vor 48 Jahren überlegt hatte: Nur 2 ICs sollten es sein,
> Treiber inklusive. Damals brauchte eine LED noch 20 mA, so dass die 40
> mA, die ein 7447 schafft, gut passten. Um herauszufinden, wie der 7447
> am Eingang und am Ausgang zu beschalten ist, hat mir ein Kumpel damals
> ein Lochkarten-Programm geschrieben. Das lief dann 12 Stunden, bis es
> die Lösung fand. Ich habe dieselbe Aufgabe heute meinem ESP gestellt. Er
> brauchte 1600 Millisekunden, um 8 LÖsungen zu finden.

Cleverer Ansatz! Der 74LS82 ist so konfiguriert, dass er von 0-5 zählt? 
(mit durch zwei geteilter clock)

Auf was für einem Rechner lief Dein ursprüngliches Programm? 12 Stunden 
klingt schon nach wirklich viel, sieht allerdinsg auch nach Brute-Force 
Anbsatz aus, oder?`

Könnte man einen CD4026 mit einem ähnlichen Ansatz nutzen? 
(Vorausgesetzt man findet einen Weg, den zähler zu resetten).

[loeti2 (Gast)]

Hab das Programm mal in (ich hoffe) standard-C++ "portiert".
Da läuft es auf meinem i7-Rechner im Releasemode 8 Millisekunden.

[Claus K. (claus_k246)]

Tim  . schrieb:
> Auf was für einem Rechner lief Dein ursprüngliches Programm? 12 Stunden
> klingt schon nach wirklich viel, sieht allerdinsg auch nach Brute-Force
> Anbsatz aus, oder?`

Brute-Force-Ansatz stimmt. - Die 12 Stunden mögen eher die gefühlte 
Brutto- als die tatsächliche Netto-Rechenzeit gewesen sein. Wenn ich 
jetzt mal grob überschlage: 1,5 Mio Schleifendurchläufe je 10 
Assemblerzeilen je 10 Takte ergibt 150 Mio Takte; das wären 150 
Sekunden, wenn so ein Rechner 1974 vielleicht mit 1 MHz lief? Allerdings 
bekam man diese Rechenzeit nicht am Stück, sondern nur im 
Time-Sharing-Verfahren. Als Studenten mussten wir damals solche 
Programme in den Nachtlauf geben, und am anderen Tag lag dann das 
Ergebnis im Ausgabefach.

Tim  . schrieb:
> Der 74LS82 ist so konfiguriert, dass er von 0-5 zählt?
> (mit durch zwei geteilter clock)

74LS92: via CKA und QA könnte man die clock durch zwei Teilen, ist aber 
nicht erforderlich; ich lege den Takt direkt an CKB, das ist der Eingang 
für den 3-stelligen Zähler mit den Ausgängen QB, QC, QD. Dieser ist 
intern so konfiguriert, dass er die 6 Zählerstände {0,1,2,4,5,6} liefert 
(wenn man QB als LSB und QD als MSB betrachtet).

Tim  . schrieb:
> Könnte man einen CD4026 mit einem ähnlichen Ansatz nutzen?

Im CD4026 ist ja ein 7-Segment-Decoder fest verdrahtet mit einem Zähler. 
Die Lösungen, die mein Programm gefunden hat, benötigen allesamt eine 
davon abweichende Zuordnung der Decoder-Eingänge {A,B,C,D} mit den 
Zähler-Ausgängen (die ich im Programm {U,V,W,X} genannt habe).