programmieren mit wincupl von atmel

[ticcoid]

hallo...

ich möchte mir ein elektronisches codeschloss bauen. soll ein ganz einfaches sein. hierzu hab ich schonmal eine schaltung entworfen, die auf dem link zu sehen ist.

http://www.1-filehost.midnightirc.info/index.php?t=dl&hash=y74tiA8wurgec0sCAywkDg8xmEB0yvF3

ich habe nun folgendes problem. ich will es mit wincupl programmieren. wenn ich bei device auf virtual bleibe dann klappt alles aber wenn ich auf device g16v8as umstelle dann klappts nicht mehr und das hat folgenden grund: ich habe nämlich zu viele ausgänge. wie kann ich das realisieren?

[guidob]

Hallo,

der Link ist mir zu nervig, aber ev. mal mit einem Gal20V10 probieren?

guidob

[Tippfix]

Hi Ticcoid


ein Codeschloß lässt sich genial einfach mit FFs des GALS 16V8A programmieren.
Zb 1o Tasten T1..T10 brauchen 10 GAL-Eingänge. Von diesen 10 können maximal 8 als richtige Zahl programmiert werden (sinnvoll sind 4 oder 5)diese richtigen Zahlen setzen das FF, die anderen tasten stellen die "falsche" zahl dar und setzen die jeweiligen FFs wieder zurück.
Bei komplett richtiger Eingabe wird das Schaltsignal auf den Ausgang gelegt.
Dafür brauchst du nur einen Ausgang und eine nachfolgende Transistorstufe, zb für den Türöffner oder sonstwas.

Mehr ist nicht nötig und das Ganze passt (sogar mit 12 tasten) noch in ein GAL 16V8a.

Viel Erfolg
Tippfix

Übrigens nehme ich für solche Sachen das Palasm, wincupl ist mir etwas überzogen.
Was ist das für ein Webhoster? Ist ja grauenvoll. Es gibt soviel freie und kostenlose Homeplagenspeicherplätze zb Freenet oder ähnliches.

[ticcoid]

vielen dank für die antwort. hab jetzt mal eine einfache version programmiert. habe das von dem bild programmiert.

hier mal der quelltext:

/* *************** INPUT PINS *********************/
PIN 2 = zahl1 ; /* */
PIN 3 = zahl2 ; /* */
PIN 5 = sammel ; /* */

/* *************** OUTPUT PINS *********************/
PIN 13 = nor1 ; /* */
PIN 14 = nor11 ; /* */
PIN 17 = und2 ; /* */
PIN 18 = nor2 ; /* */
PIN 19 = nor22 ; /* */


nor1 = !(zahl1 # nor11);
nor11 = !(sammel # nor1);
und2 = nor11 & zahl2;
nor2 = !(und2 # nor22);
nor22 = !(sammel # nor2);


und


/* *************** INPUT PINS *********************/
PIN 2 = zahl3 ; /* */
PIN 3 = zahl4 ; /* */
PIN 4 = sammel ; /* */
PIN 5 = nor22 ; /* */



/* *************** OUTPUT PINS *********************/
PIN 12 = und3 ; /* */
PIN 13 = nor3 ; /* */
PIN 14 = nor33 ; /* */
PIN 17 = und4 ; /* */
PIN 18 = nor4 ; /* */
PIN 19 = nor44 ; /* */


und3 = zahl3 & nor22;
nor3 = !(und3 # nor33);
nor33 = !(sammel # nor3);
und4 = nor33 & zahl4;
nor4 = !(und4 # nor44);
nor44 = !(sammel # nor4);


Musste leider 2 bausteine nehmen, weil ich zu viele ein und ausgänge hatte. Du sagtest was mit FFs programmieren. Ich habe SR FF mit Nor Gattern programmiert. kann man das auch kürzer fassen wie ich??? Weil deswegen passt das ja bei mir nicht auf ein gatter.

[Tippfix]

Hi Ticcoid


geht einfacher.

10 bzw 12 tasten-Pins als Eingänge sind schon richtig. Dann nimmst du für (angenommen) 4 richtige zahlen SR-FF und programmierst die so, das die erste richtige zahl den ersten FF setzt, jede falsche setzt den zurück. Dieser richtig gesetzte FF wirkt auf den 2,FF ein , únd wenn der auch richtig sitzt, geht das Spielchen weiter bis zum 4. FF und der macht dann die Türe auf.

Signallauf würde so aussehen (richtige taste angenommen)
Taste 1 setzt FF1 über S1, Rücksetz1 bekommt über ein NAND alle falschen tasten zugeführt,
ist S1 richtig und R1 keinen Falsche taste gemeldet, so geht Q1 über ein AND auf S2. Ab FF2 haben die Ands aber einen invertierenden PIN für die restlichen richtigen Tastensignale. Alles andere wie bereits beschrieben.

Q4 von FF4 schaltet dann über einen transistorstufe den Öffnermagneten.

ich habe das als Buch hier, wenn du willst , scanne ich dir das mal ein.

Gruß
Tippfix

[ticcoid]

ja genauso hab ich das ja schon. nur frage ich mich ob ich das wie oben beschrieben richtig programmiert habe. ich habe für einen FF folgenden code benutzt:

nor1 = !(zahl1 # nor11);
nor11 = !(sammel # nor1);

das ist zum bsp der erste FF. er besteht ja aus 2 nor-gattern und es geht die zahl1 in s eingang und der sammeleingang, also alle falschen in r eingang. nur kann man das auch einfacher programmieren? denn so wie ich das gemacht habe ist das ganz schön umständlich.

[guidob]

Hallo,


ich habe für einen FF folgenden code benutzt:

nor1 = !(zahl1 # nor11);
nor11 = !(sammel # nor1);


das ist aber ein genial einfacher FlipFlop, normal sieht das eher so aus:

nor1 = !zahl # (sammel & nor1);
nor11 = !sammel # (zahl1 & nor11);

Gruß

guidob

[ticcoid]

das ist aber ein genial einfacher FlipFlop, normal sieht das eher so aus:

nor1 = !zahl # (sammel & nor1);
nor11 = !sammel # (zahl1 & nor11);

hm komisch... das geht bei mir so nicht. es geht ja bei mir nur ich wollte fragen ob man einen flipflop auch kürzer schreiben kann. in der hilfe lese ich das man irgendwie ein.r oder .s setzen kann für reset bzw set. naja weißt du denn wie das geht? weil ich wollte halt nicht 2 gal bausteine beschreiben sondern nur 1. und wenn ich wüsste wie das mit .r und .s geht dann würde es noch besser sein.

[guidob]

Hallo,

etwas sparen kannst du, wenn du deine und*-Ausgänge sparst und in die
Gleichungen direkt einsetzt. Hierzu ist etwas Boolsche Algebra nötig. Zum
Beispiel:

aus: und2 = nor11 & zahl2; und nor2 = !(und2 # nor22); wird:

nor2 = !(und2 # nor22) = !und2 & !nor22 = !(norr11 & zahl2) & !nor22;

Wenn den Rest nicht wincupl macht, musst du noch etwas weiter rechnen.
Ein Ausgang (und2) gespart, ob das reicht?

Die internen FlipFlops nützen dir nichts, weil sie keine Set- bzw. Reseteingänge
haben. Sie übernehmen nur ihr Produkt bei fallender Flanke am Takteingang.

Gruß

guidob

[ticcoid]

ja genau und wie genau definiere ich dann die flipflops? das war doch was mit .s und .r oder? kannst du da mal ne zeile zu aufschreiben?

[guidob]

Das musst du in der Hilfe von wincupl nachschauen, ich kenne wincupl nicht.
Manchmal reicht es das .r anzuhängen (nor11.r = .....), manchmal muss ein
anderer Zuweisungsoperator verwendet werden (nor11 := ....).

guidob

Edit: Achso, Suchbegriff in der Hilfe: "registered Mode".

[Peter Dannegger]

Ich halte einen GAL für ein Codeschloß denkbar ungeeignet, da der die Tasten nicht entprellen kann.

Ich hatte mal eins mit nem SRAM, einem Zähler, einem 4-fach EXOR als Vergleicher und einem 2-fach Monoflop gemacht.

Die Eingabe erfolgte über einen Drehschalter.
Währende des Drehens bekam der Monoflop Impulse und startete.
Beim Stehenbleiben kippte der Monoflop zurück und mit der Flanke erfolgte der Vergleich.
Dadurch war das Prellproblem elegant beseitigt.
Auch konnte man gleiche Ziffern aufeinanderfolgend eingeben.
Der 2. Monoflop setzte den Zähler wieder in den Resetzustand, wenn man zu lange mit dem Weiterdrehen wartete.

Heutzutage würde ich aber einen MC nehmen (ATtiny2313).


Peter

[ticcoid]

hallo,

habe jetzt den code fertig und kompiliert:

/* *************** INPUT PINS *********************/

PIN 2 = zahl1 ; /* */

PIN 3 = zahl2 ; /* */

PIN 4 = zahl3 ; /* */

PIN 5 = sammel ; /* */

/* *************** OUTPUT PINS *********************/

PIN 12 = nor11 ; /* */

PIN 13 = und2 ; /* */

PIN 14 = nor22 ; /* */

PIN 17 = und3 ; /* */

PIN 18 = nor33 ; /* */

nor11 = zahl1 & !sammel # nor11 & !sammel;

und2 = zahl2 & nor11;

nor22 = und2 & !sammel # nor22 & !sammel;

und3 = zahl3 & nor22;

nor33 = und3 & !sammel # nor33 & !sammel;


Die Frage ist nur ob der FF nun auch die 1 am Qausgang speichert. Wenn ich die Zahl1 drücke dann wird an Q1 eine 1 angelegt, aber was würde passieren wenn ich die Zahl1 wieder loslasse? Mir ist klar, dass die 1 weiterhin bestehen bleiben würde aber ist das auch wirklich in Wincupl so?