MezData-Logo Creative Commons License 390 Lösungen Button :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

  

Beschreibung:

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.

Empfänger

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