# Weihnachtsrätsel 2017



## Thomas_v2.1 (17 Dezember 2017)

Für ein einfaches SPS-Projekt wurde eine kleine SPS eingesetzt die von der Funktionalität her jedoch "etwas" eingeschränkt ist.
Sie beherrscht keine arithmetischen Rechenoperationen und nur die Negation als Bitoperation.

Wie es so ist, kommt der Kunde aber auf die Idee schnell noch eine kleine Berechnung in der Steuerung vornehmen zu sollen.
Dabei sollen zwei 4-Bit Integerzahlen addiert werden.
"Kann doch nicht sein, dass es mit der Steuerung die ihr uns verkauft hat nicht möglich ist!"

Was haben wir da:
Zwei digitale Ausgangskarten mit je 32 Ausgängen, und eine digitale Eingangskarte mit 32 Eingängen.
Die Ausgangskarten sind jedoch Relaiskarten mit nur einem einzigen potenzialfreien Schließerkontakt pro Ausgang.

Verdrahtungsmaterial ist da - da lässt sich doch bestimmt mit einer passenden Beschaltung etwas realisieren.

Operand A liegt in den 4 Bits von MW0 (M0.0, M0.1, M0.2, M0.3)
Operand B liegt in den 4 Bits von MW2 (M2.0, M2.1, M2.2, M2.3)

Das Ergebnis von A+B soll nach der "Berechnung" in den 5 Bits von MW4 (M4.0, M4.1, M4.2, M4.3, M4.4) vorliegen.

Das Programm kann in einer beliebigen Programmiersprache (z.B. AWL oder SCL/ST) geschrieben werden.
Die Programmiersprache erlaubt jedoch nur Bit-Zuweisungen und die Negation. Beispiele:


```
// AWL
U M0.0
= A0.0

U M1.0
NOT
= A1.0

// SCL / ST
A0.0 := M0.0;
A1.0 := NOT M1.0;
```

Logische Verknüpfungen wie UND / ODER (falls notwendig) müssen über eine entsprechende Verschaltung der Relaiskontakte vorgenommen werden.
Ziel ist das Verwenden von möglichst wenigen Ein- und Ausgängen.

Wie viele Ein- und wie viele Ausgänge werden für die Hilfsschaltung bei der 4-Bit Addition benötigt?

Als Antworten vorerst nur euer Endergebnis (Anzahl Ausgänge: x, Eingänge y) posten.


----------



## StructuredTrash (18 Dezember 2017)

Schade dass ich nicht mitmachen kann . Ich kenne mich mit S7-1500 nicht aus .


----------



## JesperMP (18 Dezember 2017)

Soll den Ergebniss ein 4-bit Zahl sein, oder z.B. ein 8-bit Zahl ?
Wenn 4-bit Zahl, was passiert bei Überlauf ? D.H. wenn den Ergebniss grösser als 15 wird ?

Wenn den Ergebniss nur ein 4-bit Zahl ist, dann wäre es einfach eine Tabelle zu erstellen (da nur 16 Kombinationen). Das ist durchaus einfach zu machen, egal ob AWL, SCL oder KOP.
Dann braucht man auch nicht über Eingänge oder Asugänge zu gehen.
Aber ich nehme an, die Augabe ist zu zeigen wie man bitwise addiert, und nur mit Negationen.
Ohne die Lösung auf die Stelle zu haben, denke ich kenne den Weg. Hier ein Tip:


> mit Nand- oder Nor-Gates kann man alle andere Bit-operationen erstellen.


----------



## Heinileini (18 Dezember 2017)

JesperMP schrieb:


> Soll den Ergebniss ein 4-bit Zahl sein, oder z.B. ein 8-bit Zahl ?
> Wenn 4-bit Zahl, was passiert bei Überlauf ? D.H. wenn den Ergebniss grösser als 15 wird ?





Thomas_v2.1 schrieb:


> ... Das Ergebnis von A+B soll nach der "Berechnung" in den *5 Bits *von MW4 (M4.0, M4.1, M4.2, M4.3, M4.4) vorliegen. ...





JesperMP schrieb:


> Wenn den Ergebniss nur ein 4-bit Zahl ist, dann wäre es einfach eine Tabelle zu erstellen (da nur 16 Kombinationen).


Auf solche Ideen kommt man nur, wenn man nur unter Verwendung von Negationen addieren will.
Die EingangsVariablen sind zwei (in Worten: 2) 4-bit Zahlen ==> 4 + 4 = 8 Bit ==> 256 Kombinationen


JesperMP schrieb:


> Aber ich nehme an, die Augabe ist zu zeigen wie man bitwise addiert, und nur mit Negationen.


Die Aufgabe ist, zu zeigen, dass man mit potentialfreien SchliesserRelaisKontakten UND/ODER Verknüpfungen, aber keine Negationen realisieren kann (es sei denn, man hat  Widerstände zur Verfügung - haben wir in dieser Aufgabe aber nicht).
Nur mit Negationen kann man nicht addieren, weil man 2 Bit zu Bit 1 verknüpfen muss. Eine Negation mit 2 Eingängen gibt es aber nicht.


JesperMP schrieb:


> Dann braucht man auch nicht über Eingänge oder Asugänge zu gehen.


Sondern? Ohne Eingänge und Ausgänge untergehen?


JesperMP schrieb:


> Ohne die Lösung auf die Stelle zu haben, denke ich kenne den Weg. Hier ein Tip:


Das ist der schönste Tipp, den ich in diesem Forum je gesehen habe!
Lässt sehr viel Raum für ganz viele Interpretationen!

Gruss, Heinileini


----------



## DeltaMikeAir (18 Dezember 2017)

Hallo Heinileini,

ich dachte auch zuerst, da ist kein Tipp. Markiere mal sein Zitat Feld.


----------



## JesperMP (18 Dezember 2017)

Heinileini schrieb:


> _Das Ergebnis von A+B soll nach der "Berechnung" in den _*5 Bits von MW4 (M4.0, M4.1, M4.2, M4.3, M4.4) vorliegen. ...*


Habe ich verpasst. OK, also 5 bit.



Heinileini schrieb:


> Die EingangsVariablen sind zwei (in Worten: 2) 4-bit Zahlen ==> 4 + 4 = 8 Bit ==> 256 Kombinationen


Näh, Ergebniss 5 bits ==> 32 Kombinationen !


----------



## PN/DP (18 Dezember 2017)

StructuredTrash schrieb:


> Schade dass ich nicht mitmachen kann . Ich kenne mich mit S7-1500 nicht aus .


Das ist keine S7-1500 sondern eine fiktive SPS, die nichts weiter kann als einzelne Bits direkt oder negiert zu kopieren. Diese zwei Befehle können in AWL oder SCL oder ST programmiert werden. Sämtliche Verknüpfungen müssen außerhalb der SPS durch Verdrahtung realisiert werden.



JesperMP schrieb:


> Näh, Ergebniss 5 bits ==> 32 Kombinationen !


Bei der Addition von (0..15) + (0..15) kann nur (0..30) rauskommen = 31 verschiedene Ergebnisse.
Problem: die Ausgangsrelais haben nur 1 Schließer - das macht Probleme wenn man einen Operanden mehrmals verknüpfen will. Mit "Verdrahtungsmaterial" sind bestimmt nur Drähte gemeint, von Hilfsrelais und Dioden steht nichts in der Aufgabe.

@Thomas_v2.1
Nach maximal wie vielen Programmzyklen soll das Ergebnis vorliegen?

Harald


----------



## LargoD (18 Dezember 2017)

Ich lehne mich jetzt mal sehr weit aus dem Fenster und wage eine Prognose, ohne die Lösung schon parat zu haben:
*Das Problem lässt sich mit zwei Ausgängen und einem Eingang lösen*.
Überlegungen:
- Mit einer Reihenschaltung der zwei Ausgänge kann ich ein AND auf dem Eingang einlesen.
- durch Invertieren von Ein- und Ausgängen kann ich (Morgan lässt grüßen) NAND, OR und NOR erzeugen.
Der Rest ist "nur" noch Software.
Gruß
Erich
p.s.: Das Ganze setzt natürlich voraus, das das Schreiben der Ausgänge sofort wirksam wird auf dem Eingang. (Aber von einer Reaktionszeit war ja in der Aufgabe keine Rede)


----------



## Heinileini (18 Dezember 2017)

DeltaMikeAir schrieb:


> ich dachte auch zuerst, da ist kein Tipp. Markiere mal sein Zitat Feld.


@Jesper & DeltaMikeAir
Das ist ja der angewandte SchweizerKriegsFlaggenTrick! Weisses Kreuz auf weissem Untergrund!
Nicht einmal die ZitierFunktion dieses Forums hat erkannt, dass da noch etwas kommt, das mit ZauberTinte geschrieben ist.

@Jesper
Jesper, Du hast natürlich Recht mit Deinem Tipp. Aus NAND bzw. NOR kann man tatsächlich alle erdenklichen Verknüpfungen basteln.
Sogar Negationen. Aber ... umgekehrt geht es leider nicht ;o(
Was in positiver Logik eine UND-Verküpfung darstellt (Ausgang nur 1, wenn alle Eingänge 1), ist in negativer Logik eine ODER-Verknüpfung (Ausgang 0, sobald mindestens 1 Eingang 0) u.s.w. etc. ...

@Jesper & Harald
Wollt ihr damit sagen, dass es nur auf die Anzahl (bzw. Anzahl -1) der (unterschiedlichen) Kombinationen der 5 ErgebnisBits ankommt und nicht auf die Anzahl der Kombinationen der 8 Eingänge?
Sorry, verstehe ich nicht. Wahrscheinlich denke ich nur zu geradeaus?

@Erich
Das ist ja ein HorrorSzenario, das Du da ausmalst! Der PLC-BefehlsSatz der Ursprungs-Sinumerik 810 war schon der totale Albtraum, aber die BitVerknüpfungsMöglichkeiten auf 2 Ausgänge und 1 Eingang zu reduzieren, das artet aus. Irgendwie wird das gehen. In einer Schrittkette, für deren Verknüpfungen ebenfalls 2 Ausgänge und 1 Eingang missbraucht werden müssen?


----------



## JesperMP (18 Dezember 2017)

Vielleicht habe ich den ersten Eintrag falsch verstanden.
Es gibt als Befehle nur U (für Laden) und NEG, und =.
Aber dazu darf man nur als Zwischenablage die Ausgänge/Eingänge verwenden ?
Das habe ich nicht erkennt.
In den Fall geht es nicht mit ein grossen "Truth Table".


----------



## Heinileini (18 Dezember 2017)

JesperMP schrieb:


> Es gibt als Befehle nur U (für Laden) und NEG, und =.
> Aber dazu darf man nur als Zwischenablage die Ausgänge/Eingänge verwenden ?


Ich ahne noch ein paar freie MerkerBits in den genannten MerkerWorten. Vielleicht stehen sogar noch ungenannte MerkerWorte zur Verfügung?



JesperMP schrieb:


> In den Fall geht es nicht mit ein grossen "Truth Table".


Gross ist wie gross? 4, 5, 16, 256?



Thomas_v2.1 schrieb:


> Für ein einfaches SPS-Projekt wurde eine kleine SPS eingesetzt die von der Funktionalität her jedoch "etwas" eingeschränkt ist.
> Sie beherrscht keine arithmetischen Rechenoperationen und nur die Negation als Bitoperation.


Vermutlich auch keine SchiebeOperationen (Multiplikation mit bzw. Division durch ZweierPotenzen).




Thomas_v2.1 schrieb:


> ```
> // AWL
> U M0.0
> = A0.0
> ```


Bei den BitOperationen beherrscht die SPS also die Erstverknüpfung und die Zuweisung.



Thomas_v2.1 schrieb:


> ```
> U M1.0
> NOT
> = A1.0
> ```


Und, könnte man sogar sagen, sie beherrscht mehrere, direkt aufeinander folgende NOT-Operationen (aber Vorsicht bei der Aussprache dieses Begriffs!!!).
Das erkläre ich jetzt aber nicht im Detail.



Thomas_v2.1 schrieb:


> Logische Verknüpfungen wie UND / ODER (falls notwendig) müssen über eine entsprechende Verschaltung der Relaiskontakte vorgenommen werden.
> Ziel ist das Verwenden von möglichst wenigen Ein- und Ausgängen.


Wortweises UND bzw. ODER geht also auch nicht. Aber wie sieht es mit XOR aus? Hat der TE sicherlich auszuschliessen vergessen.
Bedingte Sprünge wurden auch nicht grundsätzlich ausgeschlossen und auch nicht Sprünge in AkkuInhalt-abhängigen SprungWeiten - Jesper: Ist das hier Dein Ansatz mit den Tabellen?
Oder was macht man mit Tabellen, wenn man nicht Zeiger errechnen kann?


----------



## JesperMP (18 Dezember 2017)

JesperMP schrieb:
			
		

> _In den Fall geht es nicht mit ein grossen "Truth Table"._





Heinileini schrieb:


> Gross ist wie gross? 4, 5, 16, 256?


Es wurde 5 separaten Truth Tables sein, ein pro Ausgangsbit. Jeder braucht 256 Zeilen, wegen 8 Eingänge (die 2-mal 4 bit).
Also ziemlich gross !


----------



## PN/DP (18 Dezember 2017)

Thomas_v2.1 schrieb:


> Wie viele Ein- und wie viele Ausgänge werden für die Hilfsschaltung bei der 4-Bit Addition benötigt?
> 
> Als Antworten vorerst nur euer Endergebnis (Anzahl Ausgänge: x, Eingänge y) posten.


Ich habe eine Lösung mit 35 Ausgängen und 11 Eingängen.

Harald


----------



## Thomas_v2.1 (18 Dezember 2017)

Wie viele Zyklen das Programm bis zum Endergebnis benötigt ist nicht relevant, es sind also auch mehrere Zyklen erlaubt solange das Endergebnis am Ende stabil in den Ergebnisbits stehen bleibt.

Und die SPS hat wirklich nur die Operation NOT/NEGIEREN für Bools im Befehlssatz, da wurde richtig günstig eingekauft.

Dioden wurden im Werkzeugkasten noch keine gefunden, vielleicht finden sich später noch welche um das Werk zu optimieren.

35 A und 11 E hört sich schonmal gut an, da muss ich doch glatt nochmal gucken was sich bei meiner bisherigen Schaltung optimieren lässt.


----------



## PN/DP (19 Dezember 2017)

JesperMP schrieb:


> Es wurde 5 separaten Truth Tables sein, ein pro Ausgangsbit. Jeder braucht 256 Zeilen, wegen 8 Eingänge (die 2-mal 4 bit).
> Also ziemlich gross !


Die "Truth Tables" (Wahrheitstabellen) brauchen nicht so groß sein. 

Wir haben zwei 4-Bit-Operanden A und B, deren Addition ergibt eine Summe S mit 5 Bits:

```
Überträge:  + C4 C3 C2 C1 --        C 1110

Operand A:       A3 A2 A1 A0  z.B.     1010
Operand B:  +    B3 B2 B1 B0        +  1111
Summe   S:  = S4 S3 S2 S1 S0        = 11001
```

Das Ergebnisbit S0 ist nur von den beiden Bits A0 und B0 abhängig - braucht also eine Wahrheitstabelle mit nur 4 Zeilen. Aus A0 und B0 wird außerdem noch ein Übertragsbit C1 gebildet. Man findet leicht die Verknüpfungen:

```
S0 := A0 XOR B0;
C1 := A0 AND B0;
```
(das ist übrigens ein Halbaddierer)

Das Ergebnisbit S1 ist nur von den Bits A1 und B1 und dem Eingangs-Übertrag C1 abhängig - braucht also eine Wahrheitstabelle mit nur 8 Zeilen. Es entsteht zusätzlich noch ein Ausgangs-Übertrag C2. (das entspricht einem Volladdierer)

Die Ergebnisbits S2 und S3 funktionieren analog zu S1 ...

Das Ergebnisbit S4 ist das Übertragsbit C4 von der Addition A3 + B3 + C3

Bits werden addiert mit der XOR-Verknüpfung, wozu man die Operanden Ai und Bi (und ggf. Ci) leider auch negiert braucht. Für die Negierungen braucht man die SPS und zusätzliche Ausgänge, sowie Eingang+Ausgang für zu negierende Zustände welche außerhalb der SPS durch die Verdrahtung gebildet werden. Beim Verknüpfen werden Operanden mehrfach benötigt, diese muß die SPS an mehreren Ausgängen zur Verfügung stellen, weil die Ausgangsrelais jeweils nur 1 Schließer-Kontakt haben. Optimierung: An einigen (wenigen) Stellen kann man einen Ausgangskontakt für 2 Verknüpfungen verwenden.


Vielleicht findet jemand eine andere Optimierung der Wahrheitstabellen ohne XOR, welche eventuell weniger Operanden und Negationen braucht? Vielleicht gar eine Addition bzw. Verknüpfung, die sofort in nur einem Zyklus das Ergebnis liefert? Oder einen ganz anderen Weg, z.b. eine serielle Addition?

Harald


----------



## Ralle (19 Dezember 2017)

PN/DP

Du spoilerst aber! 

0E/0A


----------



## Loenne (19 Dezember 2017)

Thomas_v2.1 schrieb:


> Als Antworten vorerst nur euer Endergebnis (Anzahl Ausgänge: x, Eingänge y) posten.



Ganz klar, das Ergebnis ist 42 !


----------



## Heinileini (20 Dezember 2017)

Moin Harald!



PN/DP schrieb:


> Die "Truth Tables" (Wahrheitstabellen) brauchen nicht so groß sein. ...


Mal unabhängig von der Grösse der Tabellen, hast Du denn schon eine Idee, wie man in dieser SonderPostenSPS eine Tabelle auswerten könnte?
Ich meine per SPS-Programm, das auf Logik- und Arithmetik- (inkl. Inkrement- und Dekrement)-Befehle verzichtet?



> Vielleicht findet jemand eine andere Optimierung der Wahrheitstabellen ohne XOR, welche eventuell weniger Operanden und Negationen braucht? Vielleicht gar eine
> Addition bzw. Verknüpfung, die *sofort in nur einem Zyklus *das Ergebnis liefert?


Das klingt nach viel Aufwand für "look ahead carry".



> Oder einen ganz anderen Weg, z.B. eine serielle Addition?


Serielle Addition? Zuerst Bit0, dann Bit1, dann Bit2, dann Bit 3 und 4 - das ist doch schon seriell in ReinKultur!
Noch ein winziges Bisschen serieller wäre es vielleicht, wenn man 7 HA und 3 OR statt 1 HA und 3 VA verwendet?

Ohne XOR? Du? Ich habe jetzt eine Variante mit 
- 4 Stück "Entweder-Und-Oder-Oder-Verknüpfungen" und 4 Stück XOR (für 4 Bit VA; 16 Eingänge und 28 Ausgänge)
  bzw.
- 3 Stück "Entweder-Und-Oder-Oder-Verknüpfungen" und 4 Stück XOR und 1 Stück AND (für 3 Bit VA + 1 Bit HA; 14 Eingänge und 24 Ausgänge)

Ach, übrigens: jede "Entweder-Und-Oder-Oder-Verknüpfung" besteht aus 3 Stück XOR und 1 Stück AND (und ich habe sie so genannt, weil sie entweder eine AND-Verknüpfung darstellt oder eine OR-Verknüpfung, Du weisst, was ich meine ;o)
Die Sache hat nur einen gaaanz grossen Haken: die Ausgänge müssen Wechsler-Kontakte haben!
Vorteilhaft ist natürlich, dass die SPS nicht einmal die Kunst des Negierens beherrschen muss.

Kehrt man wieder zu Ausgängen mit jeweils "1 S potenzialfrei Kontakten" zurück und schliesst hier Relais mit 1xUm bzw. 2xUm an, dann kann man noch einen kleinen Schritt weitergehen und die SPS ganz einsparen! (7 Relais mit 1xUm und 10  Relais mit 2xUm)

Sooo, genug gelabert. Wünsche, ein schönes WE gehabt zu haben

Gruss, Heinileini


----------



## PN/DP (20 Dezember 2017)

Moin Heinrich,

sämtliche Verknüpfungen sind allein durch Verdrahtung der Ausgangs-Relais-Schließer zu realisieren. Ohne weitere Bauelemente, nur Drähte. Die SPS ist nur für Negierungen und für Kontaktvervielfältigungen nutzbar. Wie reine Relais-Technik, nur ohne Spulen und ohne Wechsler. So lautet die Aufgabenstellung.

Welche Verknüpfungen man braucht kann man aus den Wahrheitstabellen entnehmen oder man bastelt halt den 4-Bit-Addierer.

Mit "serielle Addition" meine ich, nur einen einzigen VA zu benutzen und die Operanden nacheinander an diesen VA anzuschalten. (Ich weiß jetzt nur nicht wie.)

Harald


----------



## Ralle (20 Dezember 2017)

PN/DP schrieb:


> Moin Heinrich,
> 
> sämtliche Verknüpfungen sind allein durch Verdrahtung der Ausgangs-Relais-Schließer zu realisieren. Ohne weitere Bauelemente, nur Drähte. Die SPS ist nur für Negierungen und für Kontaktvervielfältigungen nutzbar. Wie reine Relais-Technik, nur ohne Spulen und ohne Wechsler. So lautet die Aufgabenstellung.
> 
> Harald



Na ja, dann hab ich das falsch verstanden, Bitzuweisungen mit U habe ich wörtlich genommen und so auch UND-Glieder zugelassen.
Hätte die Aufgabenstellung halt Hardwareverdrahtung zur Bedingung machen können, für Deppen wie mich. ;-) Hätte man vermuten können, aber dazu war ich zu faul, arbeiten muß man ja auch noch...
Dann gehts natürlich nicht mit 0/0.


----------



## Heinileini (22 Dezember 2017)

Moin, liebe MitRätselnde!

Meine vorläufig-endgültige Lösung lautet *35A + 11E*.
Habe es bisher leider nicht geschafft, Harald zu unterbieten.
Ich ahne zwar noch ein Bisschen SparPotenzial bei den Ausgängen, aber meine jetzige Lösung finde ich gerade noch so übersichtlich und "rund", dass ich mir weiteres KopfzErbrechen eigentlich ersparen möchte.


```
Ausgänge(1S) : 35 = 3 x 10 + 5   
Eingänge     : 11 = 3 x  3 + 2   
Dioden       :  0   
Negationen   : 14 = 3 x  4 + 2
```

Wann ist eigentlich EinsEndeSchluss?

@Harald
Jetzt habe ich kapiert, was Du mit "seriell" gemeint hast. Das war meine erste Idee zu dem Thema. Habe ich aber sehr schnell wieder gekippt, weil ich so etwas mit einer SchrittKette angehen würde. Dies aber ausgerechnet auf der SonderPostenSPS in Angriff zu nehmen, die absolut nix kann (das ist im Detail leider nicht so ganz eindeutig definiert, wird aber ziemlich deutlich suggeriert), wäre der absolute Wahnsinn.   
Du hattest anscheinend den Eindruck, ich hätte die AufgabenStellung nicht richtig verstanden - das stimmt nur im folgenden Punkt:
ich hatte anfangs überlesen, dass 64 Ausgänge zur Verfügung stehen und war von bescheidenen 32 ausgegangen. 
Aus lauter Ver2flung hatte ich dann für mich eine Alternative mit WechslerKontakten überlegt. Ich bin doch - wie Du auch - ein XOR-Fan. Deshalb nehme ich an, dass Du "nicht zufällig" auf Deine mir unbekannte 35A-11E-Lösung gekommen bist.

Allen hier im Forum: Frohe Weihnachten & ein Gutes Neues Jahr!

Gruss, Heinileini


----------



## Heinileini (22 Dezember 2017)

Nachschlag:
Anhang anzeigen VA-div.pdf


----------



## Thomas_v2.1 (22 Dezember 2017)

Ich bin immer noch bei 47 A + 8 E, irgendwie stehe ich auf'm Schlauch. Wenn ich mehr zusammenfassen will komme ich ohne Dioden nicht weiter.
Ohne Optimierung braucht es 60 A + 8 E.


----------



## Heinileini (25 Dezember 2017)

Sooo, Ende der FahnenStange - weiterklettern zwecklos(?)

Bin jetzt bei *29A + 11E* angekommen: 


```
[FONT=courier new]Ausgänge(1S) : 29 = 3 x 8 + 5 
Eingänge     : 11 = 3 x 3 + 2   
Dioden       :  0   
Negationen   : 14 = 3 x 4 + 2[/FONT]
```



Zwischenweihnachtlicher Gruss, Heinileini


----------



## Thomas_v2.1 (25 Dezember 2017)

Also da bin ich ja mal gespannt.
Ich würde sagen morgen Abend veröffentlichen.


----------



## Heinileini (26 Dezember 2017)

*Lösungen zu SonderPostenSPS-4BitAddierer (35A+11E, 32A+11E, 29A+11E)*

Konnte leider die XL-Datei nicht hochladen und XL hat 2 pdf-Dateien aus dem gemacht, was nur 1 pdf-Datei werden sollte.
Here they come:

Anhang anzeigen VA-17c26-S1.pdf

Anhang anzeigen VA-17c26-S2-5.pdf


Gruss, Heinileini


----------



## Thomas_v2.1 (26 Dezember 2017)

Ah mit Hilfsmerker klar.
Und ich mal mir hier KV-Diagramme auf und wundere mich warum da nichts geht...

Im Anhang meine Lösung, ich habe aber immer nur einen VA gezeichnet. Einmal die "unoptimierte" und mit Zusammenfassung zu 47A + 8E, sieht eher nach Trostpreis aus.


----------



## PN/DP (26 Dezember 2017)

In meiner ersten Lösung (35 A + 11 E) hatte ich einen Fehler beim Kaskadieren der Überträge C1..C2..C3, da hätte ich noch 3 Dioden gebraucht. 

Hier jetzt meine Lösung mit 38 Ausgängen und 11 Eingängen.

Die Formeln für den Halbaddierer (HA):

```
[COLOR="#008000"]// Summe S := A + B[/COLOR]
S0 := A0 XOR B0;

[COLOR="#008000"]// Übertrag Cout[/COLOR]
C1 := A0 AND B0;
```

Die Formeln für den Volladdierer (VA) (mit Klammern für bessere Lesbarkeit):

```
[COLOR="#008000"]// Summe S := A + B + Cin[/COLOR]
S := A XOR B XOR Cin;

[COLOR="#008000"]// Übertrag Cout := (A AND B) OR (A AND Cin) OR (B AND Cin)[/COLOR]
[COLOR="#008000"]// für weniger Operanden das Cin ausklammern:[/COLOR]
Cout := (A AND B) OR (Cin AND (A OR B));
```

Wie habe ich XOR mit Schließer-Kontakten gebildet?

```
XOR = Antivalenz, bei mehr als 2 Eingängen werden XOR kaskadiert:
S := (A XOR B) XOR Cin

     (A XOR B) = A AND NOT(B) OR B AND NOT(A)

     (A XOR B) XOR Cin = (A XOR B) AND NOT(Cin) OR NOT(A XOR B) AND Cin
```

macht diese Schaltung:

```
B0
           +---| |---------------------------oE C1
           |
           |
      A0   |   /B0
+ ---| |---+---| |---+-----------------------oE S0
                     |
     /A0        B0   |
+ ---| |-------| |---+


      C1        A1
+ ---| |---+---| |---+
           |         |
           |    B1   |
           +---| |---+
                     |
                B1   |
           +---| |---+-----------------------oE C2
           |
      A1   |   /B1                 /C1
+ ---| |---+---| |---+-------------| |---+---oE S1
                     |                   |
     /A1        B1   |   -------    C1   |
+ ---| |-------| |---+--oE NOT Ao--| |---+
                         -------

      C2        A2
+ ---| |---+---| |---+
           |         |
           |    B2   |
           +---| |---+
                     |
                B2   |
           +---| |---+-----------------------oE C3
           |
      A2   |   /B2                 /C2
+ ---| |---+---| |---+-------------| |---+---oE S2
                     |                   |
     /A2        B2   |   -------    C2   |
+ ---| |-------| |---+--oE NOT Ao--| |---+
                         -------

      C3        A3
+ ---| |---+---| |---+
           |         |
           |    B3   |
           +---| |---+
                     |
                B3   |
           +---| |---+-----------------------oE C4=S4
           |
      A3   |   /B3                 /C3
+ ---| |---+---| |---+-------------| |---+---oE S3
                     |                   |
     /A3        B3   |   -------    C3   |
+ ---| |-------| |---+--oE NOT Ao--| |---+
                         -------
```
"-| |-" : Ausgang (Schließer)
"-oE NOT Ao-" : Eingang + NOT + Ausgang (A-Schließer beginnt mit neuem +)

Harald


----------



## LargoD (29 Dezember 2017)

Frohe Weihnachten
Jetzt habe ich mal Zeit gefunden, meine Idee ( Beitrag #8 )mit den zwei Ausgängen und dem einen Eingang in die Tat um zu setzen.
Die Kontakte der beiden Ausgänge A0.1 und A0.2 sind in Reihe geschaltet auf den Eingang E0.1.
Das Programm funktioniert nur mit einer SPS, die zusätzlich zu den Eigenschaften der Aufgabenstellung noch zwei Besonderheiten hat.
1. Die SPS hat kein PAE und PAA, sondern schreibt direkt in die Ausgangsbits und liest direkt aus den Eingangsbits.
2. Die CPU ist so langsam, dass die Schaltzeit der Relaiskontakte keine Rolle spielt.

Das Programm ist natürlich nicht händisch entstanden, sondern ist das Resultat von fünf Macros (AND,OR,XOR,HALB-ADDIERER,VOLL-ADDIERER) die ich durch einen Macro-Preprocessor gequält habe.
Allen im Forum wünsche ich einen Guten Rutsch
Erich


```
// Halbaddierer
//start:semi-adder M0.0,M2.0 M4.0,M0.6
      U     M      0.0; //start:xor M0.0,M2.0,M4.0
      NOT   ; 
      =     A      0.1; 
      U     M      2.0; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      0.7; 
      U     M      0.0; 
      =     A      0.1; 
      U     M      2.0; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     A      0.1; 
      U     M      0.7; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      4.0; //end:xor   
      U     M      0.0; //start:and M0.0,M2.0,M0.6
      =     A      0.1; 
      U     M      2.0; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      0.6; //end:and   //end:semi-adder
// 1. Volladdierer
//start:adder M0.1,M2.1,M0.6  M4.1,M0.6
      U     M      0.1; //start:xor M0.1,M2.1,M2.7
      NOT   ; 
      =     A      0.1; 
      U     M      2.1; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      0.7; 
      U     M      0.1; 
      =     A      0.1; 
      U     M      2.1; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     A      0.1; 
      U     M      0.7; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      2.7; //end:xor   
      U     M      2.7; //start:xor M2.7,M0.6,M4.1
      NOT   ; 
      =     A      0.1; 
      U     M      0.6; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      0.7; 
      U     M      2.7; 
      =     A      0.1; 
      U     M      0.6; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     A      0.1; 
      U     M      0.7; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      4.1; //end:xor
      U     M      2.7; //start:and M2.7,M0.6,M2.6
      =     A      0.1; 
      U     M      0.6; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      2.6; //end:and
      U     M      0.1; //start:and M0.1,M2.1,M2.5
      =     A      0.1; 
      U     M      2.1; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      2.5; //end:and
      U     M      2.5; //start:or M2.5,M2.6,M0.6
      NOT   ; 
      =     A      0.1; 
      U     M      2.6; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      0.6; //end:or   //end:adder
// 2. Volladdierer
//start:adder M0.2,M2.2,M0.6  M4.2,M0.6
      U     M      0.2; //start:xor M0.2,M2.2,M2.7
      NOT   ; 
      =     A      0.1; 
      U     M      2.2; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      0.7; 
      U     M      0.2; 
      =     A      0.1; 
      U     M      2.2; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     A      0.1; 
      U     M      0.7; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      2.7; //end:xor   
      U     M      2.7; //start:xor M2.7,M0.6,M4.2
      NOT   ; 
      =     A      0.1; 
      U     M      0.6; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      0.7; 
      U     M      2.7; 
      =     A      0.1; 
      U     M      0.6; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     A      0.1; 
      U     M      0.7; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      4.2; //end:xor
      U     M      2.7; //start:and M2.7,M0.6,M2.6
      =     A      0.1; 
      U     M      0.6; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      2.6; //end:and
      U     M      0.2; //start:and M0.2,M2.2,M2.5
      =     A      0.1; 
      U     M      2.2; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      2.5; //end:and
      U     M      2.5; //start:or M2.5,M2.6,M0.6
      NOT   ; 
      =     A      0.1; 
      U     M      2.6; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      0.6; //end:or   //end:adder
// 3. Volladdierer
//start:adder M0.3,M2.3,M0.6  M4.3,M4.4
      U     M      0.3; //start:xor M0.3,M2.3,M2.7
      NOT   ; 
      =     A      0.1; 
      U     M      2.3; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      0.7; 
      U     M      0.3; 
      =     A      0.1; 
      U     M      2.3; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     A      0.1; 
      U     M      0.7; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      2.7; //end:xor   
      U     M      2.7; //start:xor M2.7,M0.6,M4.3
      NOT   ; 
      =     A      0.1; 
      U     M      0.6; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      0.7; 
      U     M      2.7; 
      =     A      0.1; 
      U     M      0.6; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     A      0.1; 
      U     M      0.7; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      4.3; //end:xor
      U     M      2.7; //start:and M2.7,M0.6,M2.6
      =     A      0.1; 
      U     M      0.6; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      2.6; //end:and
      U     M      0.3; //start:and M0.3,M2.3,M2.5
      =     A      0.1; 
      U     M      2.3; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      2.5; //end:and
      U     M      2.5; //start:or M2.5,M2.6,M4.4
      NOT   ; 
      =     A      0.1; 
      U     M      2.6; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      4.4; //end:or   //end:adder
// Schmiermerker loeschen
      U     M      2.5; //start:xor M2.5,M2.5,M2.5
      NOT   ; 
      =     A      0.1; 
      U     M      2.5; 
      =     A      0.2; 
      U     E      0.1; 
      =     M      0.7; 
      U     M      2.5; 
      =     A      0.1; 
      U     M      2.5; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     A      0.1; 
      U     M      0.7; 
      NOT   ; 
      =     A      0.2; 
      U     E      0.1; 
      NOT   ; 
      =     M      2.5; //end:xor
      U     M      2.5; 
      =     M      2.6; 
      =     M      2.7; 
      =     M      0.6; 
      =     M      0.7;
```


----------



## Thomas_v2.1 (29 Dezember 2017)

@LargoD
Mit einem Eliminieren deiner "Schmiermerker" kämen dann noch 4A + 4E dazu, wenn diese 1:1 miteinander verbunden wären. Das wären dann zumindest 6A + 5E.


----------



## Onkel Dagobert (30 Dezember 2017)

Hallo Erich,

das ist ganz schön irre! Ich will den Code gar nicht verstehen, aber es würde mich mal interessieren, was du für Werkzeuge verwendet hast?

Gruß, Onkel


----------



## LargoD (30 Dezember 2017)

Hier ein paar Infos, wie mein Bandwurm-AWL-Kode entstanden ist
Als Werkzeug kann man einen Macro-Preprocessor benutzen, wie er zu jedem C-Compiler gehört, z. B diesen M4

Hier ist der Macro-Code, der eine vollständige AWL-Quelle für einen OB1 erzeugt (Step-7-Classic, CPU-300).
Die Definition der entscheidenden fünf Macros beginnt ab Zeile fünf, der AWL-Code wird ab Zeile 50 erzeugt.
Zum Testen des Codes auf einer Siemens-CPU (real oder simuliert) habe ich das Lesen des Eingangs E0.1 durch ein Macro namens RESULT ersetzt.
Wenn man beim Aufruf von M4 die Option -D SIMULATE angibt, wird statt U E0.1 die Und-Verküpfung der beiden Ausgänge A0.1 und A0.2 eingesetzt.
Auf diese Weise kann man die Funktion des Programms testen. (Summanden in MB0 und MB2, Summe in MB4)
Der Code ist mit heißer Nadel gestrickt und lässt sich sicher noch optimieren, besonders im Hinblick auf die Anzahl der verwendeten "Schmiermerker".
Wer Lust dazu hat, nur zu!
Achtung: Der Preprocessor ist case-sensitiv, also auf Groß/Kleinschreibung achten.

Guten Rutsch
Erich

```
changequote(<,>)dnl
ifdef(<SIMULATE>,<define(RESULT,<clr; // Simulation der Reihenschaltung
  U A0.1;  // von Ausgangsrelais 1
  U A0.2;  // und Ausgangsrelais 2>)>,<define(RESULT,<U E0.1;>)>)
define(AND,<U $1;   //start:and $1,$2,$3
  = A0.1;
  U $2;
  = A0.2;
  RESULT
  = $3;   //end:and>)dnl
define(OR,<U $1;   //start:or $1,$2,$3
  NOT; 
  = A0.1;
  U $2;
  NOT;
  = A0.2;
  RESULT
  NOT;
  = $3;   //end:or>)dnl
define(XOR,<U $1;   //start:xor $1,$2,$3
  NOT; 
  = A0.1;
  U $2;
  = A0.2;
  RESULT
  = M0.7;
  U $1;
  = A0.1;
  U $2;
  NOT;
  = A0.2;
  RESULT
  NOT;
  = A0.1;
  U M0.7;
  NOT;
  = A0.2;
  RESULT
  NOT;
  = $3;   //end:xor>)dnl
define(ADDER,<//start:adder $1,$2,$3  $4,$5
  XOR($1,$2,M2.7)   
  XOR(M2.7,$3,$4)
  AND(M2.7,$3,M2.6)
  AND($1,$2,M2.5)
  OR(M2.5,M2.6,$5)   //end:adder>)dnl
define(SEMI,<//start:semi-adder $1,$2 $3,$4
  XOR($1,$2,$3)   
  AND($1,$2,$4)   //end:semi-adder>)dnl

ORGANIZATION_BLOCK "CYCL_EXC"
TITLE = "Main Program Sweep (Cycle)"
VERSION : 0.1


VAR_TEMP
  OB1_EV_CLASS : BYTE ;    //Bits 0-3 = 1 (Coming event), Bits 4-7 = 1 (Event class 1)
  OB1_SCAN_1 : BYTE ;    //1 (Cold restart scan 1 of OB 1), 3 (Scan 2-n of OB 1)
  OB1_PRIORITY : BYTE ;    //Priority of OB Execution
  OB1_OB_NUMBR : BYTE ;    //1 (Organization block 1, OB1)
  OB1_RESERVED_1 : BYTE ;    //Reserved for system
  OB1_RESERVED_2 : BYTE ;    //Reserved for system
  OB1_PREV_CYCLE : INT ;    //Cycle time of previous OB1 scan (milliseconds)
  OB1_MIN_CYCLE : INT ;    //Minimum cycle time of OB1 (milliseconds)
  OB1_MAX_CYCLE : INT ;    //Maximum cycle time of OB1 (milliseconds)
  OB1_DATE_TIME : DATE_AND_TIME ;    //Date and time OB1 started
END_VAR
BEGIN
NETWORK
TITLE =

// Halbaddierer
  SEMI(<M0.0>,<M2.0>,<M4.0>,<M0.6>)
// 1. Volladdierer
  ADDER(<M0.1>,<M2.1>,<M0.6>,<M4.1>,<M0.6>)
// 2. Volladdierer
  ADDER(<M0.2>,<M2.2>,<M0.6>,<M4.2>,<M0.6>)
// 3. Volladdierer
  ADDER(<M0.3>,<M2.3>,<M0.6>,<M4.3>,<M4.4>)
// Schmiermerker loeschen
  XOR(<M2.5>,<M2.5>,<M2.5>)
  U M2.5;
  = M2.6;
  = M2.7;
  = M0.6;
  = M0.7;
END_ORGANIZATION_BLOCK
```


----------



## PN/DP (30 Dezember 2017)

Heinileini schrieb:


> Konnte leider die XL-Datei nicht hochladen


Dateien, die die Forumssoftware als Anhang nicht unterstützt, kann man vorher in ein zip-Archiv packen oder einfach die Dateiendung umbenennen (z.B. VA-17c26.xls.zip oder VA-17c26.xls.txt oder VA-17c26.xls.bmp)




Heinileini schrieb:


> Ich bin doch - wie Du auch - ein XOR-Fan. Deshalb nehme ich an, dass Du "nicht zufällig" auf Deine mir unbekannte 35A-11E-Lösung gekommen bist.


XOR - Jaaa! Das XOR ist schon eine erstaunliche Verknüpfung ...  

Dummerweise habe ich bei meiner Entnahme der Ausgangsformel aus der Wahrheitstabelle geschlampt (und schon unkorrekterweise vereinfacht anstatt zunächst die komplette disjunktive Normalform aufzuschreiben) und habe deshalb das entscheidende XOR nicht gesehen.  Meine (trotzdem funktionierende) Lösung unterscheidet sich im Grunde nur minimal von Deiner korrekten Lösung - die korrekte Lösung läßt sich wegen dem XOR aber erstaunlicherweise viel mehr optimieren als meine Lösung mit dem nicht ganz richtigen OR. Gratulation Heinileini!

```
[COLOR="#008000"]// Volladdierer Übertrag Cout[/COLOR]

[COLOR="#008000"]// PN/DP:  nicht korrekt vereinfachte Ausgangsformel:[/COLOR]
Cout := (A AND B             ) OR (A            AND Cin) OR (           B AND Cin);

[COLOR="#008000"]// Heinileini: korrekte Ausgangsformel:[/COLOR]
Cout := (A AND B AND NOT(Cin)) OR (A AND NOT(B) AND Cin) OR (NOT(A) AND B AND Cin);


[COLOR="#008000"]// PN/DP: vereinfacht:[/COLOR]
Cout := (A AND B) OR (Cin AND (A [COLOR="#FF0000"]OR[/COLOR] B));

[COLOR="#008000"]// Heinileini: vereinfacht:[/COLOR]
Cout := (A AND B) OR (Cin AND (A [COLOR="#0000FF"]XOR[/COLOR] B));
```

Harald


----------



## Heinileini (31 Dezember 2017)

Moin Harald!
Danke für die Blumen! Das war wohl eher ein Zufallstreffer beim Betrachten der Tabelle durch die XOR-Brille ;o)
Der VA ist eigentlich mindestens genau so eine "erstaunliche Verknüpfung": man kann die drei Eingänge beliebig tauschen, will sagen, es ist egal, welchen man zum ÜbertragsEingang deklariert . Das ErgebnisBit ist immer 1, wenn eine ungerade Anzahl der EingangsBits 1 sind und der CarryAusgang hat 1 sobald mindestens 2 der EingangsBits 1 haben.
Im ExcelTabellenBlattSlang formuliert:
S1=REST(A1+B1+C1;2) // (ErgebnisBit) enthält Deine geliebte ModuloFunktion!
C2=0+(A1+B1+C1>1) // (CarryOut) rechnet mit einer logischen Verknüpfung. ABS(A1+B1+C1>1) tut's auch.
Danke für Deine Tipps zum beamen von XL-Dateien. Mit gepackten Dateien stehe ich auf KriegsFuss - das werde ich erst dann versuchen, wenn nichts anderes funktioniert.
Mit dem Vortäuschen eines anderen DateiTyps hatte ich's hier im Forum doch schonmal vergeblich (mit jpg) versucht - aber das war nicht wirklich vergleichbar (jedoch entmutigend ;o).
Bin noch dabei, meine XL-Datei umzustricken. Habe Thomas "ihm seine" Lösung und Deine noch reingenommen und wollte noch ein Bisschen FehlerDiagnose einbauen.
Seitdem habe ich (Ironie des Schicksals) Fehler drin, an deren Diagnose ich im Moment scheitere. Melde mich aber wieder, sobald es rund läuft.
Bis dahin ... guten Rutsch wünscht Heinileini


----------



## Heinileini (1 Januar 2018)

*ReparaturVersuch*



PN/DP schrieb:


> Dateien, die die Forumssoftware als Anhang nicht unterstützt, kann man vorher in ein zip-Archiv packen oder einfach die Dateiendung umbenennen (z.B. VA-17c26.xls.zip oder VA-17c26.xls.txt oder VA-17c26.xls.bmp)





Scheint nicht egal zu sein, welchen Typ man zum Austricksen verwendet. Beim Typ bmp und jpg wird anscheinend der Inhalt der Datei auf Konformität geprüft.
Also ...




ADD-35-11-V2.xlsm.txt​
Hier meine gesammelten Werke zum Thema 4-Bit-Addition-mit-SonderPostenSPS.
Datei wurde mit Excel-2010 erzeugt.
Tipps zur Bedienung:
Zellen, die 1 oder 0 enthalten, wechseln ihren Inhalt beim Anklicken - es sei denn, sie enthalten eine Formel.
Blätter, die in ihrem Namen "V2" enthalten: hier muss die Berechnung durch einen Doppelklick gestartet werden.
Wenn nichts mehr geht, kann das bedeuten, dass VBA bei einem Fehler die Notbremse gezogen hat ;o(
Gruss, Heinileini


----------



## LargoD (1 Januar 2018)

Laut Hint-Message heißt die Datei WillNich.jpg und ist 91kB groß.
Runterladen kann ich sie nicht mit Firefox 57.0.3.

Es kommt folgende Meldung:
___________________________________________________________________________________________
*vBulletin-Systemmitteilung*

                           Ungültige Angabe: Anhang
Wenn Sie einem normalen, gültigen Link im Forum gefolgt sind, wenden Sie sich bitte an den Webmaster.
___________________________________________________________________________________________

Gruß
Erich


----------



## Heinileini (1 Januar 2018)

Komisch - das Problem tritt jetzt (erst) auch bei mir auf - beim Versuch vorhin klappte es noch!


----------



## PN/DP (1 Januar 2018)

Uploadtest...

OK, bei BMP wird das Dateiformat überprüft. Bei TXT nicht - damit kann man (noch) einfach die Dateiendung ändern.
Ich bevorzuge aber echte zip.


----------



## Heinileini (1 Januar 2018)

Anhang anzeigen ADD-35-11-V2.xlsm.txt

Noch'n Versuch - sieht aber nicht anders aus.


----------



## hucki (1 Januar 2018)

PN/DP schrieb:


> Ich bevorzuge aber echte zip.


Die zulässigen Dateigrößen sprechen meistens auch eher dafür, zumindest .zip, .pdf oder .rar zum Anhängen auszuwählen (wenn schon nicht echt gepackt):


----------



## hucki (1 Januar 2018)

Heinileini schrieb:


> Anhang anzeigen 39876
> 
> Noch'n Versuch - sieht aber nicht anders aus.


So läßt es sich aber, im Gegensatz zu den vorigen Versuchen, herunterladen.


----------



## LargoD (1 Januar 2018)

Der Link in Beitrag #39 hat bei mir eben gerade funktioniert
Gruß
Erich


----------



## Heinileini (1 Januar 2018)

Die DateiGrösse kann's aber nicht gewesen sein, sie war/ist 400,0 KB (laut Explorer) und 585,9KB soll die Obergrenze sein für txt.
Und der download hat bei mir funktioniert, als ich ihn getestet habe!


----------



## hucki (2 Januar 2018)

Heinileini schrieb:


> Die DateiGrösse kann's aber nicht gewesen sein, sie war/ist 400,0 KB (laut Explorer) und 585,9KB soll die Obergrenze sein für txt.


Das hab' ich ja auch nicht behauptet.


----------



## Heinileini (2 Januar 2018)

Hi hucki!
Ich habe auch nicht behauptet, Du hättest es behauptet ;o)
Habe in dem Trubel vergessen, mich für Deinen Hinweis zu bedanken - die unterschiedlichen Obergrenzen waren mir tatsächlich nicht sooo detailliert bewusst.
Was nun schief gelaufen war ... keine Ahnung. Ich habe den Eindruck, dass meine beim ersten Versuch hochgeladene Datei im Forum gelöscht wurde, obwohl sie nicht unbenutzt war.



Der anfangs angezeigte DateiName wurde später durch Anhang 39869 ersetzt, ohne dass ich etwas geändert hätte.
Die Datei, die ich im zweiten Versuch hochgeladen habe, ist übrigens das Exemplar, das ich zuvor aus dem Forum heruntergeladen hatte - aus reiner Bequemlichkeit, denn mein Original hatte längst wieder umbenannt.
Gruss, Heinileini


----------

