MODULE SRG8send "Serieller Datensender: 8 parallele Datenbits d7..d0 werden mit Start- und Stoppbit seriell gesendet. Übertragungsgeschwindigkeit mit Takt einstellbar. "Datenbyte mit S3 bis S6 (DIP) und Buchsenleiste 37 bis 40 (Drähte) einstellbar "Taster T1 drücken: 1 Byte wird gesendet "Schalter S1 oben: Byte wiederholt senden, z.B. zum oszilloskopieren DECLARATIONS takt PIN 11; "Takt vom Taktgenerator send1x PIN 16; "Taster 1 mal Senden senddauernd PIN 19; "Schalter dauernd senden startbit = 0; stoppbit = 1; d7..d0 PIN 40,39,38,37,25,26,27,28; "parallele Dateneingänge daten = [ d7..d0 ,startbit ]; "Nachladewert für SRG: 8 Datenbit, 1 Startbit bit7..bit0 NODE ISTYPE 'BUFFER,REG'; "SRG-FFs seraus PIN 29 ISTYPE 'BUFFER,REG'; "serieller Datenausgang ausinv PIN 30 ISTYPE 'BUFFER,REG'; "invertierter serieller Datenausgang srg = [bit7..bit0,seraus ]; "Schieberegister aus 9 Bit z3..z0 NODE ISTYPE'BUFFER,REG'; "FFs für STATE-DIAGRAM zustand = [z3,z2,z1,z0]; "Zustands-FFs ladenR,ladenS,ladenQ NODE ISTYPE'BUFFER,COM'; "RS-Flipflop Laden SRG mit neuen Daten "****************** Name der Zustände für Parallel-Seriell-Umsetzung **************** anfang = [0,0,0,0]; "nach Reset warten = [0,0,0,0]; "Grundzustand: Leitung ist H, warten Tastendruck sendstartbit = [0,0,0,1]; "Startbit senden: 0 sendbit0 = [0,0,1,0]; "Datenbit LSB sendbit1 = [0,0,1,1]; sendbit2 = [0,1,0,0]; sendbit3 = [0,1,0,1]; sendbit4 = [0,1,1,0]; sendbit5 = [0,1,1,1]; sendbit6 = [1,0,0,0]; sendbit7 = [1,0,0,1]; "Datenbit MSB sendstoppbit = [1,0,1,0]; "Stoppbit senden: 1 wartenlosgelassen = [1,0,1,1]; "Warten, falls Taster 1x senden noch gedrückt ist. EQUATIONS "*********************** Funktionsgleichungen ******************************** "SR-FF um neue parallele Daten ins SRG zu laden: Setzen beim Zustand warten "Rücksetzen beim Zustand Startbit senden ladenS = send1x & (zustand == warten) "Lade-FF setzen wenn 1x senden gedrückt # senddauernd & (zustand == warten); "oder Schalter dauend senden aktiv ladenR = (zustand == sendstartbit); "und rücksetzen # (zustand == anfang); "rücksetzen nach dem Einschalten ladenQ = (ladenQ & !ladenR) # (ladenS & !ladenR); "Rücksetzdominates SR-FF Laden ausinv = !seraus; "Invertierung des seriellen Ausgangs when (zustand == anfang) then srg.d = [1,1,1,1,1,1,1,1,1]; "Grundzust. der Leitg ins SRG when ladenQ "Lade-FF abfragen then srg.d = daten; "Daten parallel laden wenn FF gesetzt (im Zustand warten) else {seraus.d = bit0.q; bit0.d = bit1.q; "Daten schieben wenn FF rückgesetzt während des bit1.d = bit2.q; "Übertragungsvorgangs bit2.d = bit3.q; bit3.d = bit4.q; bit4.d = bit5.q; bit5.d = bit6.q; bit6.d = bit7.q; bit7.d = stoppbit; "mit Stoppbit=Grundzustand der Leitung nachfüllen } srg.clk = takt; "Takt für Schieberegister zustand.clk = takt; "Takt für Zustands-FFs STATE_DIAGRAM zustand; "** Steuerung Parallel/Seriell-Umsetzung mit Zustandsdiagramm *** STATE anfang: goto warten; "Nach dem Einschalten STATE warten: if ladenQ then sendstartbit else warten;"warten bis 1x senden "oder dauernd senden gedrückt STATE sendstartbit: goto sendbit0; STATE sendbit0: goto sendbit1; STATE sendbit1: goto sendbit2; STATE sendbit2: goto sendbit3; STATE sendbit3: goto sendbit4; STATE sendbit4: goto sendbit5; STATE sendbit5: goto sendbit6; STATE sendbit6: goto sendbit7; STATE sendbit7: if send1x then wartenlosgelassen else warten; STATE wartenlosgelassen: if send1x then wartenlosgelassen else warten; "Taster noch gedrückt TEST_VECTORS "********************* Simulation ***************************************** ([takt,send1x,senddauernd,d7..d0 ] -> seraus); @repeat 4 {[.c. , 0 , 0 ,1,1,0,1,1,1,0,1] -> .x.;} "Grundzustand [.c. , 1 , 0 ,1,1,0,1,1,1,0,1] -> .x.; "1x senden @repeat 12 {[.c. , 0 , 0 ,1,1,0,1,1,1,0,1] -> .x.;} @repeat 25 {[.c. , 0 , 1 ,1,0,0,1,0,0,0,1] -> .x.;} "dauernd senden @repeat 10 {[.c. , 0 , 0 ,1,0,0,1,0,0,0,1] -> .x.;} END
Mit dem ersten Takt nach dem Reset geht die serielle Übertragungs-Leitung ?seraus? in den Grundzustand H. Der Zustand ?warten? [0,0,0,1] ist erreicht.
Ein Tastendruck (1) setzt das SR-Flipflop LadenQ (2).
Beim nächsten Takt wird das Schieberegister mit den parallelen 8Bit-Daten und dem Starbit geladen, die Übertragung beginnt. Das FF LadenQ wird rückgesetzt.
Mit jedem Takt werden die Daten im SRG um eine Stelle weitergeschoben und dadurch nacheinander beim letzten FF des SRG ?seraus? ausgegeben.
Das Stoppbit bringt die Leitung nach 9 Takten wieder in den Grundzustand. Eine neue Übertragung kann nach einem Tastendruck beginnen.
MODULE SRG8empf Serieller Datenempfänger: serieller Empfang eines Signals mit Start- und Stoppbit, parallele Ausgabe an die LEDs "Takt = 8 x Übertragungsgeschwindigkeit!!!! DECLARATIONS "************ Ein- und Ausgänge, Sets ************************************* takt PIN 11; "Takt vom Taktgenerator --> 8x Übertragungsgesschwindigkeit!! serein PIN 29; "serieller Dateneingang d7..d0 PIN 3,4,5,6,7,8,9,10 ISTYPE'BUFFER,REG'; "parallele Datenausgänge des Latch latch = [d7..d0]; bit7..bit0 NODE ISTYPE 'BUFFER,REG'; "SRG-FFs für seriell/parallel-Umsetzung srg = [bit7..bit0 ]; "Schieberegister aus 8 Bit z3..z0 NODE ISTYPE'BUFFER,REG'; "FFs für Zustandschreibung zustand = [z3,z2,z1,z0]; "Zustands-FFs für State-Diagram t2..t0 NODE ISTYPE'BUFFER,REG'; "FFs für Frequenzteiler durch 8 ctrdiv8 = [t2..t0]; "Takt ist 8x Takt-SRG startbit = 0; stoppbit = 1; "************************ Zustände für Parallel-Seriell-Umsetzung ******************** warten = [0,0,0,0]; "Grundzustand: Leitung ist H, warten Tastendruck liesstartbit = [0,0,0,1]; "Startbit liesen: 0 liesbit0 = [0,0,1,0]; "Datenbit LSB liesbit1 = [0,0,1,1]; liesbit2 = [0,1,0,0]; liesbit3 = [0,1,0,1]; liesbit4 = [0,1,1,0]; liesbit5 = [0,1,1,1]; liesbit6 = [1,0,0,0]; liesbit7 = [1,0,0,1]; "Datenbit MSB liesstoppbit = [1,0,1,0]; "Stoppbit lesen: 1 "************************* Zustände für Frequenzteiler durch 8 *********************** null = [0,0,0]; "Zählerzustände 0 bis 7 eins = [0,0,1]; zwei = [0,1,0]; drei = [0,1,1]; vier = [1,0,0]; fuenf= [1,0,1]; sechs= [1,1,0]; sieben= [1,1,1]; EQUATIONS "******************* Funktionsgleichungen ************************************ ctrdiv8.clk = takt; "Takt für Frequenzteiler durch 8 vom Generator bit7.d = serein; "Schieberegister: serielle Daten einlesen bit6.d = bit7.q; "und bitweise weiterschieben bit5.d = bit6.q; bit4.d = bit5.q; bit3.d = bit4.q; bit2.d = bit3.q; bit1.d = bit2.q; bit0.d = bit1.q; srg.clk = t2.q; "Takt für Schieberegister geht nach 4 Generatortakten auf H. "d.h. Einlesen der Seriellen Daten immer in der Bit-Mitte "dieser Takt wird erst nach erkanntem Startbit erzeugt "und endet mit dem Stoppbit zustand.clk = t2.q; "Takt für Zustands-FFs latch.clk = t2.q; "Takt für Übernahme der Daten aus dem SRG in das Latch when (zustand == liesbit7) then latch.d = srg.q; "Daten-Übernahme von SRG in Latch "einen Takt nach Bit7, dh. mit dem Stoppbit else latch.d = latch.q; "bei allen anderen Takten "bleiben die Daten im Latch unverändert STATE_DIAGRAM ctrdiv8; "******* Zustandsdiagramm für Frequenzteiler durch 8 ************ "ctrdiv8 = [t2..t0]. t2 ist der durch 8 geteilte Generatortakt, "ergibt den Schiebetakt den Takt für das STATE_Diagram zustand. STATE null : if ((zustand == warten) & (serein == startbit)) "Startbit erkannt? # (zustand != warten) then eins "Übertragung läuft else null; "warten auf Startbit STATE eins : goto zwei; STATE zwei : goto drei; STATE drei : goto vier; STATE vier : if ((zustand == warten) & (serein == startbit)) "nochmal prüfen: Startbit? then fuenf "Startbit erkannt! else {if (zustand != warten) then fuenf "Übertragung läuft else null;}; "kein Startbit, warten "bei State vier geht das FF t2 erstmals auf H, dies ist die ansteigende Taktflanke für "SRG, Latch, Zustands-FFs. Hier in der Bitmitte werden die seriellen Daten eingelesen. STATE fuenf : if (zustand == warten) "Stoppbit!" then null "Ende: von vorne else sechs; "während der Übertragung STATE sechs: goto sieben; STATE sieben: goto null; STATE_DIAGRAM zustand; "********** Zustandsdiagramm für Parallel-Seriell-Umsetzung ***** STATE warten: goto liesstartbit; STATE liesstartbit: goto liesbit0; STATE liesbit0: goto liesbit1; STATE liesbit1: goto liesbit2; STATE liesbit2: goto liesbit3; STATE liesbit3: goto liesbit4; STATE liesbit4: goto liesbit5; STATE liesbit5: goto liesbit6; STATE liesbit6: goto liesbit7; STATE liesbit7: goto warten; TEST_VECTORS "********************* Simulation ***************************************** ([takt,serein] -> latch); @repeat 20 {[.c. , 1 ] -> .x.;} "Grundzustand der Leitung: 1 @repeat 8 {[.c. , 0 ] -> .x.;} "Startbit 0 @repeat 8 {[.c. , 1 ] -> .x.;} "erstes Übertragungs-Bit (LSB) @repeat 8 {[.c. , 1 ] -> .x.;} @repeat 8 {[.c. , 0 ] -> .x.;} "Daten = d0 .. d7 = 1100 1010 @repeat 8 {[.c. , 0 ] -> .x.;} @repeat 8 {[.c. , 1 ] -> .x.;} @repeat 8 {[.c. , 0 ] -> .x.;} @repeat 8 {[.c. , 1 ] -> .x.;} @repeat 8 {[.c. , 0 ] -> .x.;} "letztes Übertragungs-Bit (MSB) @repeat 5 {[.c. , 1 ] -> .x.;} "Stoppbit = Grundzustand der Leitung: 1 "nur 5 Takte H simuliert: Takt Empfänger zu langsam @repeat 8 {[.c. , 0 ] -> .x.;} "Startbit 0 @repeat 8 {[.c. , 1 ] -> .x.;} "erstes Übertragungs-Bit (LSB) @repeat 8 {[.c. , 0 ] -> .x.;} @repeat 8 {[.c. , 0 ] -> .x.;} @repeat 8 {[.c. , 1 ] -> .x.;} "daten = d0 .. d7 = 1001 1010 @repeat 8 {[.c. , 1 ] -> .x.;} @repeat 8 {[.c. , 0 ] -> .x.;} @repeat 8 {[.c. , 1 ] -> .x.;} @repeat 8 {[.c. , 0 ] -> .x.;} "letztes Übertragungs-Bit (MSB) @repeat 30 {[.c. , 1 ] -> .x.;} "Stoppbit = Grundzustand der Leitung: 1 END
Simulationsergebnis
Funktion des Schieberegisters