:ISP: Serielle Datenübertragung :ISP: Serielle Datenübertragung
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
