Σχεδίαση κυκλωμάτων με VHDL: 2o μέρος

Transcript

1 Σχεδίαση κυκλωμάτων με VHDL: 2o μέρος Γ. Δημητρακόπουλος Περιγραφή κυκλωμάτων με προγραμματιστικές δομές υψηλού επιπέδου Κύριος στόχος των γλωσσών περιγραφής υλικού είναι να απαλλάξουν το σχεδιαστή από τις μικρές λεπτομέρειες της ψηφιακής σχεδίασης αφήνοντας τον ελεύθερο να σκεφτεί τη λειτουργία και τη δομή του κυκλώματος τους σε υψηλότερο επίπεδο χρησιμοποιώντας προγραμματιστικές δομές όμοιες με αυτές των γλωσσών προγραμματισμού, όπως συνθήκες if then, επιλογές με case καθώς και επαναληπτικές δομές τύπου for loop. Με αυτό τον τρόπο ο σχεδιαστής μπορεί να αντεπεξέλθει ευκολότερα στη σχεδίαση πολύ σύνθετων κυκλωμάτων, να επιτύχει υψηλότερες επιδόσεις, αλλά και να ολοκληρώσει τη σχεδίαση με τα λιγότερα δυνατά λάθη. Σε κάθε περίπτωση την ευθύνη της μετατροπή της αφαιρετικής περιγραφής της λειτουργίας του κυκλώματος σε ένα ισοδύναμο κύκλωμα που θα αποτελείται από πύλες και flip-flops, την αναλαμβάνει το εργαλείο της λογικής σύνθεσης. Στη VHDL οι προγραμματιστικές δομές που μας επιτρέπουν να περιγράψουμε τη λειτουργία του κυκλώματος σε ένα υψηλότερο επίπεδο αφαίρεσης μπορούν να χρησιμοποιηθούν μόνο μέσα σε διεργασίες (process). Κάθε διεργασία αναπαριστά ένα μικρό κύκλωμα το οποίο εκτελεί μια συγκεκριμένη λειτουργία ανταποκρινόμενο στις αλλαγές των εισόδων του.ολες οι διεργασίες του κυκλώματος που περιγράφουμε λειτουργούν ταυτόχρονα όπως ακριβώς θα έκαναν και οι διάφορες μονάδες υλικού σε ένα πραγματικό κύκλωμα. process(a, b) x <= a and b; if a = '1' then y <= '0' y <= '1' Στη διεργασία αυτή πραγματοποιούνται αναθέσεις στα σήματα x και y. Επομένως, αν και στις διεργασίες δεν απαιτείται να δηλώσουμε ποια σήματα λειτουργούν ως είσοδοι και ποια ως έξοδοι, παρόλα αυτά, για τη διεργασία αυτή τα σήματα x και y έμμεσα παίζουν το ρόλο των εξόδων εφόσον είναι τα μόνα στα οποία ανατίθεται μια ένα τιμή. Αντίστοιχα, τα σήματα που καθορίζουν τις τιμές των αναθέσεων στα x και y παίζουν έμμεσα το ρόλο των εισόδων της διεργασίας και δεν είναι άλλα από τα σήματα a και b. H ανάθεση στο σήμα x συνδυάζει μέσω του λογικού ΚΑΙ τα σήματα a και b, ενώ η ανάθεση στο y πραγματοποιείται μέσω της προγραμματιστικής δομής if <condition> then η συνθήκη της οποίας ελέγχεται από την τιμή του a. Επομένως, κοιτώντας και τις δύο αναθέσεις, καταλαβαίνουμε πως η λειτουργία της διεργασίας καθορίζεται από τις τιμές των σημάτων a και b. Ας υποθέσουμε πως τη χρονική στιγμή t 0 = 10ns τα σήματα a και b είχαν τις τιμές '1' και '0' αντίστοιχα. Τότε σύμφωνα με τις αναθέσεις της διεργασίας την ίδια χρονική στιγμή τα σήματα x και y θα είχαν πάρει τις τιμές '0' και '0' αντίστοιχα. Οι τιμές των x και y διατηρούνται σταθερές μέχρις ότου να αλλάξει κάποιο από τα a και b. Επομένως μετά την ανάθεση των τιμών στα x και y η διεργασία αυτή δεν εκτελεί καμιά νέα δουλειά και μπορεί να απενεργοποιηθεί. Αν όμως σε μια μεταγενέστερη χρονική στιγμή έστω τη στιγμή t 1 = 12nsec το a γίνει ίσο με 0 τότε η διεργασία οφείλει να ενεργοποιηθεί υπολογίζοντας τις νέες τιμές για τα x και y. Η στιγμή που μια διεργασία ενεργοποιείται καθορίζεται από τα σήματα που συμμετέχουν στη λίστα ενεργοποίησης της διεργασίας (sensitivity list). Όταν ένα σήμα της λίστας ενεργοποίησης αλλάξει τιμή τότε η διεργασία ενεργοποιείται υπολογίζοντας νέες τιμές για τις αναθέσεις που περιγράφονται μέσα στο σώμα της. Στο παράδειγμα μας η λίστα ενεργοποίησης της διεργασίας αποτελείται από τα σήματα a και b που βρίσκονται μέσα σε παρενθέσεις μετά τη δήλωση τη διεργασίας, δηλαδή process(a,b). Εφόσον τα σήματα x και y αντιδρούν απευθείας στις αλλαγές των σημάτων a και b που 1

2 συμμετέχουν στη λίστα ενεργοποίησης, αυτό σημαίνει πως η περιγραφή αντιστοιχεί σε ένα κύκλωμα συνδυαστικής λογικής όπου οι έξοδοι του κυκλώματος υπολογίζονται μόνο με βάση τις τρέχουσες εισόδους και όχι παλαιότερες τιμές. Process name (optional) sensitivity list name: process(s1, s2) sequential statements end process name; gtx: process(s1, s2) x <= a and b; if a = '1' then y <= '0' y <= '1' Οι διεργασίες στη VHDL μας βοηθούν να περιγράψουμε ευκολότερα τη λειτουργία μονάδων υλικού. Για να καταλάβουμε όμως τον τρόπο με τον οποίο οι περιγραφές μας «εκτελούνται» αναθέτοντας νέες τιμές στα σήματα που συμμετέχουν στο σώμα των διεργασιών πρέπει να τις αντιμετωπίσουμε σαν κομμάτια ενός προγραμμάτος λογισμικού. Αντίθετα με τις απευθείας αναθέσεις που πραγματοποιούνται ταυτόχρονα, οι αναθέσεις μέσα στις διεργασίες λαμβάνουν χώρα σειριακά η μια μετά την άλλη. Η «εκτέλεση» της κάθε διεργασίας μοιάζει με ένα ατερμονο βρόγχο όπου μετά το τέλος των αναθέσεων μιας επανάληψης η διεργασία ξαναξεκινά μόνο όταν αλλάξει κάποιο από τα σήματα που συμμετέχουν στη λίστα ενεργοποίησης (sensitivity list). Περισσότερες λεπτομέρειες για την υλοποίηση των αναθέσεων μέσα σε διεργασίες και τη σειρά με την οποία λαμβάνει χώρα το αποτέλεσμα τους θα δούμε στο τέλος αυτού του κεφαλαίου. Στο τελευταίο παράδειγμα παρατηρούμε πως οι αναθέσεις στο σήμα y είναι ανεξάρτητες από τις τιμές του b. Επομένως θα μπορούσαμε να χωρίσουμε τη διεργασία αυτή σε δύο παράλληλες και ανεξάρτητες διεργασίες στις οποίες η καθεμιά θα αναλάμβανε και την ανάθεση σε ένα σήμα. library ieee; use ieee.std_logic_1164.all; entity dummylogic is port(a : in std_logic; b : in std_logic; x : out std_logic; y : out std_logic); end dummylogic; architecture bhv of dummylogic is -- the assignment of y depends only on a process(a) if a='1' then y <= '0'; y <= '1'; - the assignment of x depends on both a and b process(a, b) x <= a and b; end bhv; Φυσικά θα μπορούσαμε να είχαμε πετύχει την ίδια λειτουργία χρησιμοποιώντας δύο απευθείας αναθέσεις στα σήματα x και y χωρίς να χρησιμοποιήσουμε τις δύο διεργασίες: architecture bhv of dummylogic is 2

3 y <= 0 when a= 1 1 ; x <= a and b; end bhv; Γι' αυτό το απλό παράδειγμα όντως κάτι τέτοιο θα ήταν η ενδεικνυόμενη λύση. Όμως για την περίπτωση πιο σύνθετων κυκλωμάτων η χρήση προγραμματιστικών δομών όπως αυτή του if-then- κάνει πιο εύκολη την περιγραφή της λειτουργίας του κυκλώματος και καθιστά τον κώδικα της VHDL ευανάγνωστο και περισσότερο κατανοητό. Πρέπει να προσέξετε πως υποσυνθήκη αναθέσεις signal <= <val1> when <condition> <val2> δεν επιτρέπονται μέσα σε process παρά μόνο έξω από αυτά ως απευθείας αναθέσεις. Από το προηγούμενο παράδειγμα μπορούμε να παρατηρήσουμε πως η δομή if-then- αντιστοιχεί απευθείας στη λειτουργία ενός πολυπλέκτη του οποίου η είσοδος ελέγχου συνδέεται στο ισοδύναμο κύκλωμα της συνθήκης του if ενώ οι είσοδοι δεδομένων του πολυπλέκτη συνδέονται στην έξοδο της λογικής που περιγράφουν η αναθέσεις μέσα στο σώμα του if. process(a, b, y) if a=b then x <= y + 1; x <= b; Σε πολλές περιπτώσεις οι συνθήκες if βρίσκονται εμφωλευμένες η μια μέσα στην άλλη περιγράφοντας έμμεσα προτεραιότητες στην ικανοποίηση των συνθηκών για κάθε ανάθεση. Οι συνθήκες που βρίσκονται στις εξωτερικέςδομές if εμφανίζουν μεγαλή προτεραιότητα καθώς ελέγχουν τους πολυπλέκτες που βρίσκονται πιο κοντά στην έξοδο του κυκλώματος. Η αντιστοιχία αυτή φαίνεται στο παράδειγμα που ακολουθεί. Ο πιο δεξιά πολυπλέκτης (πιο κοντά στην έξοδο) δίνει στο x την τιμή του b όταν η συνθήκη a= 1 δεν ικανοποιείτε. Αντίθετα, όταν a= 1 τότε το x ανατίθεται υπο-συνθήκη ανάλογα με την τιμή του b. Επομένως, σε αυτή την περίπτωση η ανάθεση του x προκύπτει από την έξοδο ενός δεύτερου πολυπλέκτη ο οποίος ελέγχεται από το b και δίνει στην έξοδο του είτε το y είτε το 0. Η έξοδος του δεύτερου πολυπλέκτη δεν περιγράφεται άμεσα σε αυτή τη διεργασία, προκύπτει όμως έμμεσα εξαιτίας του εμφωλευμένου if που αναθέτει και αυτό μια νέα τιμή στο x. process(a, b, y) if a= 1 then if b= 0 then x <= y; x <= 0 ; x <= b; Στην περίπτωση που μέσα σε ένα process με συνθήκες if ανατίθενται περισσότερα από ένα σήματα, αυτό σημαίνει πως κατά τη λογική σύνθεση γεννιούνται και περίσσότεροι πολυπλέκτες όπως στο παραδειγμα που ακολουθεί. xt <= 1 when a= 1 y; process(a, b, xt) if a= 1 then x <= xt; y <= 0 ; y <= b; x <= b; 3

4 Σto παράδειγμα αυτό πρέπει να προσέξετε πως το σήμα xt υπολογίζεται από μια απ ευθείας υπο-συνθήκη ανάθεση έξω από το process και χρησιμοποιείτε (διαβάζετε) από μια ανάθεση μέσα στο process. Μια τέτοια περιγραφή είναι πολύ συνήθης καθώς τόσο τα process (μαζί με όλες τις αναθέσεις τους) όσο και οι απευθείας αναθέσεις αντιστοιχούν σε μπλοκς υλικού τα οποία συνυπάρχουν και λειτουργούν παράλληλα και συνδέονται μεταξύ τους μέσω σημάτων. Κάθε φορά που περιγράφουμε ένα κύκλωμα συνδυαστικής λογικής χρησιμοποιώντας διεργασίες πρέπει να σεβόμαστε δύο απλούς κανόνες. Πρώτον, κάθε σήμα που λειτουργεί ως έμμεση είσοδος σε μια διεργασία, δηλαδή σήματα που συμμετέχουν σε συνθήκες if και σήματα που υπάρχουν στη δεξιά πλευρά αναθέσεων πρέπει να δηλωθούν υποχρεωτικά στη λίστα ενεργοποίησης της διεργασίας. ΛΑΘΟΣ architecture myarch signal a,b,c,y: std-logic; -- mistake: incomplete sensitivity list process (a) y <= a and b and c; end myarch; ΣΩΣΤΟ συνδυαστική λογική architecture myarch signal a,b,c,y: std-logic; -- complete sensitivity list process (a,b,c) y <= a and b and c; end myarch; Όταν το σήμα a αλλάζει η διεργασία ενεργοποιείτε και υπολογίζει μια νέα τιμή για το y. Αντίθετα, όταν τα σήματα b ή c αλλάζουν η διεργασία παραμένει ανενεργή και αναγκαστικά το σήμα y κρατάει την παλιά του τιμή. Η λειτουργία αυτή μοιάζει με τη λειτουργία ενός κυκλώματος με μνήμη το οποίο ενεργοποιείτε όταν το a μεταβαίνει στο 1. Αυτή η συμπεριφορά δεν είναι η ζητούμενη και οδηγεί σε λανθασμένο κύκλωμα κατά τη λογική σύνθεση. Η λοική πύλη των 3 εισόδων που επιθυμούμε να περιγράψουμε θα γεννηθεί μόνο αν στη λίστα ενεργοποίησης συμπεριλάβουμε όλα τα σήματα που βρίσκονται στη δεξιά πλευρά της ανάθεσης του y, δηλαδή τα a, b, c. Επίσης, η ανάθεση κάθε σήματος μέσα σε μια διεργασία που αναπαριστά την έξοδο ενός κυκλώματος συνδυαστικής λογικής πρέπει να καλύπτει όλους τους δυνατούς συνδυασμούς των έμμεσων εισόδων της διεργασίας. Στη λανθασμένη περίπτωση του παραδείγματος που ακολουθεί στο y ανατίθεται μια τιμή όταν το a είναι ίσο με 1 και όχι στην περίπτωση που το a= 0. Αυτό έχει ως αποτέλεσμα στην περίπτωση που a=0 να θυμόμαστε την παλιά τιμή του y. H συμπεριφορά αυτή ταιριάζει με αυτή του μανδαλωτή o οποίος ενεργοποιείτε όταν a=1. Για να αποφύγουμε τη γέννηση ενός μανδαλωτή πρέπει να ακολουθήσουμε το παράδειγμα της σωστής εκδοχής: ΛΑΘΟΣ process(a,b) if (a= 1 ) then y <= b; end; ΣΩΣΤΟ process(a,b) if (a= 1 ) then y <= b; y <= 0 ; end; Ακολουθιακή λογική Αυτό που ξεχωρίζει ένα ακολουθιακό από ένα αμιγώς συνδυαστικό κύκλωμα είναι ότι μπορεί και θυμάται παλαιότερες τιμές των σημάτων του με βάση τις οποίες καθορίζει την έξοδο του σε κάθε χρονική στιγμή. Τα ακολουθιακά κυκλώματα τα οποία σχεδιάζουμε χρησιμοποιούν ακμοπυροδοτητά flip-flops για την αποθήκευση ενδιάμεσων χρονικά τιμών του κυκλώματος. Σε ένα τέτοιο κύκλωμα κάθε αλλαγή των εξόδων του πραγματοποιείται μόνο κατά τις θετικές (ή αρνητικές) ακμές του ρολογιού. Σε όλη την διάρκεια του κύκλου ρολογιού τα σήματα διαδίδονται κατάλληλα μέσα στη συνδυαστική λογική και με το τέλος του υπολογισμού περιμένουν στις εισόδους των flip-flop. Με την άφιξη της ακμής του ρολογιού τα σήματα αυτά περνούν από την είσοδο του flip-flop στην έξοδο του όπου και αποθηκεύονται μέχρι την επόμενη ακμή του ρολογιού πυροδοτώντας εκ νέου ένα κύκλο υπολογισμού στα κυκλώματα της συνδυαστικής λογικής. Για να μπορέσουμε να περιγράψουμε τη λειτουργία των flip-flops και κατ' επέκταση οποιοδήποτε άλλου ακολουθιακού κυκλώματος θα πρέπει να περιγράψουμε με σαφήνεια πως όλες οι αλλαγές στις εξόδους των flip-flops πραγματοποιούνται 4

5 μόνο κατά τις ακμές του ρολογιού. H VHDL μας επιτρέπει να εκφράσουμε αυτή τη συνθήκη συγχρονισμού μέσω μιας δομής ifthen- στη συνθήκη της οποίας ελέγχεται η ύπαρξη μιας θετικής ακμή του ρολογιού μέσω της συνάρτησης rising_edge(). Aς δούμε ένα παράδειγμα x <= a; Στο παράδειγμα αυτό η ανάθεση x <= a πραγματοποιείται με τη θετική ακμή του ρολογιού, περιγράφοντας τη λειτουργία ενός flip-flop με έξοδο το x και είσοδο το a. Η πλήρης περιγραφή ενός flip-flop σε VHDL φαίνεται παρακάτω: library ieee; use ieee.std_logic_1164.all; entity dff is port (clk : in std_logic; d : in std_logic; q : out std_logic); end dff; architecture bhv of dff is q <= d; end bhv; Από την περιγραφή του flip-flop πρέπει να προσέξουμε δύο νέα στοιχεία: Στη λίστα ενεργοποίησης της διεργασίας που περιγράφει το flip-flop συμμετέχει μόνο το σήμα ρολογιού clk και όχι η είσοδος d η οποία βρίσκεται στο δεξί μέρος της ανάθεσης του q. Αυτό συμβαίνει γιατί στα flip-flops η είσοδος d δεν καθορίζει τη χρονική στιγμή που θα πυροδοτηθεί το flip-flop και επομένως δεν επηρεάζει την ενεργοποίηση ή μη της διεργασίας. Στο flip-flop η είσοδος d φέρει απλά την τιμή που θα περάσει στην έξοδο με την άφιξη της ακμής του ρολογιού. Στις περιγραφές της συνδυαστικής λογικής με διεργασίες απαιτούσαμε οι αναθέσεις σε κάποιο σήμα να καλύπτουν όλες τις πιθανές εκδοχές της εισόδου, δηλαδή όταν υπάρχει ανάθεση στη μονοπάτι if-then να ακολουθεί και μια ανάθεση στο κομμάτι της συνθήκης. Η απαίτηση αυτή παρατηρούμε πως δεν τηρείται στην περιγραφή του flipflop. Έτσι όταν δεν υπάρχει θετική ακμή του ρολογιού τότε η έξοδος q θυμάται την παλιά της τιμή που είναι και το ζητούμενο. Επειδή όμως τώρα η ανανέωση της τιμής του q γίνεται μόνο στις θετικές ακμές δε υπονοείται έμμεσα ένας μανδαλωτής όπως στην περίπτωση μιας ελλιπούς περιγραφής συνδυαστικής λογικής αλλά ένα flip-flop. Ας εμβαθύνουμε περισσότερο στην περιγραφή ακολουθιακής λογικής με VHDL προσπαθώντας να περιγράψουμε ένα καταχωρητή των 4 δυαδικών ψηφίων με επίτρεψη φόρτωσης. Το κύκλωμα αυτό αποτελείται από 4 flip-flops στην είσοδο των οποίων τοποθετείται ένας πολυπλέκτης (των 4 δυαδικών ψηφίων). Ο πολυπλέκτης καθορίζει αν κάθε flip-flop θα φορτωθεί με μια νέα τιμή όταν το σήμα επίτρεψης είναι ενεργό ή αν θα φορτωθεί, μέσω της γραμμής ανάδρασης, με την παλιά τιμή που έχει ήδη αποθηκευμένη. Επομένως το κύκλωμα του καταχωρητή με επίτρεψη φόρτωσης αποτελείται από ένα αμιγώς ακολουθιακό μέρος (τα flip-flops) και ένα αμιγώς συνδυαστικό μέρος (τους πολυπλέκτες). Για την περιγραφή του κυκλώματος αυτού έχουμε 2 επιλογές. Είτε να διαχωρίσουμε πλήρως την συνδυαστική από την ακολουθιακή λογική όπως φαίνεται στο σχήμα Χ(α) είτε να τις περιγράψουμε εννοποιημένες όπως φαίνεται στο σχήμα Χ(β). library ieee; use ieee.std_logic_1164.all; entity register_with_enable is port(clk : in std_logic; load: in std_logic; din : in std_logic_vector(3 downto 0); dout : out std_logic_vector(3 downto 0)); library ieee; use ieee.std_logic_1164.all; entity register_with_enable is port(clk : in std_logic; load: in std_logic; din: in std_logic_vector(3 downto 0); dout: out std_logic_vector(3 downto 0)); 5

6 end register_with_enable; architecture bhv_a of register_with_enable is signal dcur: std_logic_vector (3 downto 0); signal dnew: std_logic_vector (3 downto 0); dout <= dcur; - mux with direct signal assignment dnew <= din when load='1' dcur; - flip-flop description: Flip-flop input -- is the output of the mux dcur <= din; end bhv_a; end register_with_enable; architecture bhv_a of register_with_enable is signal dcur: std_logic_vector (3 downto 0); dout <= dcur; -- mixed description -- combinational logic embedded inside -- the process if load= 1 then dcur <= din; end bhv_a; Στην πρώτη περίπτωση περιγράψαμε τη λειτουργία του πολυπλέκτη στην είσοδο του καταχωρητή μέσω μιας απευθείας ανάθεσης η οποία έδινε στο ενδιάμεσο σήμα dnew είτε την τιμή din είτε την τρέχουσα dcur έξοδο του καταχωρητή, ενώ η διεργασία που ακολουθούσε απλά φόρτωνε την τιμή dnew μέσα στον καταχωρητή dcur με την επόμενη ακμή του ρολογιού. Αντίθετα στη δεύτερη περίπτωση τόσο η επιλογή όσο και η ανάθεση στο dcur πραγματοποιήθηκαν μέσα στην ίδια διεργασία. Ουσιαστικά μετά την θετική ακμή του ρολογιού το dcur λαμβάνει την τιμή του din μόνο όταν το En='1'. H ανάθεση μέσα σε θετική ακμή αυτόματα σημαίνει τη γέννηση flip-flops για το dcur, ενώ η παρουσία μιας συνθήκης if παραπέμπει σε ένα πολυπλέκτη. Φυσικά για να ήταν η περιγραφή του πολυπλέκτη πλήρης θα έπρεπε να περιελάμβανε και μία ανάθεση για την περίπτωση που το Εn='0'. Εφόσον η διεργασία ελέγχεται από μια ακμή του ρολογιού μπορούμε να παραλείψουμε αυτή την ανάθεση αναγκάζοντας σε αυτή την περίπτωση το dcur να θυμάται την παλιά του τιμή (περιγράφοντας έμμεσα την ανάδραση από την έξοδο του flip-flop στη μια είσοδο δεδομένων του πολυπλέκτη). Σε κάθε περίπτωση όταν έχω μια ανάθεση μέσα σε μια διεργασία που ελέγχεται από τη θετική ακμή ενός σήματος process(clock) if rising_edge(clοck) then τότε όλες οι αναθέσεις που πραγματοποιούνται μέσα σε αυτή τη διεργασία καταλήγουν σε ένα καταχωρητή (flip-flop) ενός ή περισσότερων δυαδικών ψηφίων ανάλογα με το εύρος των σημάτων στα οποία γίνεται η ανάθεση. Οι δομες if ή(και) case που μπορεί να συνοδεύουν τις αναθέσεις αυτές απλά αντιστοιχούν στους πολυπλέκτες (ή τη συνδυαστική λογική γενικότερα) που καθορίζει ποια νέα τιμή θα εμφανιστεί στην είσοδο των καταχωρητών. Το μικρό παράδειγμα που ακολουθεί παρουσιάζει ακριβώς αυτή την ιδιότητα των περιγραφών της ακολουθιακής λογικής σε VHDL. Στο παράδειγμα μας θέλουμε να περιγράψουμε την υπο-συνθήκη ανάθεση στο σήμα z ανάλογα με την τιμή του σήματος sel. Ο κορμός της περιγραφής μας θα ήταν όπως παρακάτω: 6

7 if sel='1' then z<=a; z<=b; Ανάλογα όμως με το process που τοποθετούμε την περιγραφήαυτή οδηγούμαστε σε διαφορετικές υλοποιήσεις. Φυσικά και στις δύο είναι παρών ο πολυπλέκτης που υλοποιεί την επιλογή. process(a, b, z) if sel= 1 then z<=a; z<=b; end if sel= 1 then z<=a; z<=b; end Στην πρώτη περίπτωση ο κώδικας τοποθετήθηκε μέσα σε μια διεργασία που ελέγχεται από τα σήματα a, b και sel και οδήγησε στη σύνθεση συνδυαστικής λογικής, ενώ στη δεύτερη περίπτωση ο κώδικας τοποθετήθηκε μέσα σε μια διεργασία που ελέγχεται από ένα σήμα clk και όλη η δουλειά γίνεται μόνο στη θετική ακμή του σήματος αυτού, με αποτέλεσμα τη σύνθεση ενός flip-flop για το σήμα q. Οπως σας είναι ήδη γνωστό η έξοδος της ακολουθιακής λογικής (flip flop) επιτρέπεται να επαναχρησιμοποιείται στην αριστερή πλευράς της ανάθεσης, πχ q <= a and q καθώς η έξοδος του flip-flop από την είσοδο του είναι σαφώς διαχωρισμένες. Το ίδιο όμως δεν επιτρέπεται στα κυκλώματα συνδυαστικής λογικής (process χωρίς rising_edge()) καθώς τότε δημιουργείται κύκλος συνδυαστικής λογικής που περιπλέκει τη λογική και χρονική ανάλυση του κυκλώματος μας. Στο επόμενο παράδειγμα βλέπουμε ένα process το οποίο είτε φορτώνει νέες τιμές στους δύο καταχωρητές είτε ανταλλάσει τις τιμές τους ανάλογα με τις τιμές των σημάτων ελέγχου. if load= 1 then out1<=a; out2<=b; if swap= 1 then out1<=out2; out2<=out1; end Αρχικοποίηση ακολουθιακής λογικής Kάθε ακολουθιακό κύκλωμα βασίζει τη λειτουργία του στην εσωτερική κατάσταση που αποθηκεύει στα flip-flops από τα οποία αποτελείται. Με την έναρξη της λειτουργίας του κυκλώματος η εσωτερική κατάσταση πρέπει να αρχικοποιηθεί σε μια γνωστή εκ των προτέρων τιμή, εξασφαλίζοντας έτσι την ορθή λειτουργία του κυκλώματος και τη σωστή αντίδραση του στις αλλαγές των 7

8 εισόδων του. Η αρχικοποίηση των κυκλωμάτων συνήθως πραγματοποιείται μέσω της ενεργοποίησης ενός εξωτερικού σήματος reset. Επομένως ένας απλός καταχωρητής ο οποίος αρχικοποιείται στη τιμή 000 με την έναρξη λειτουργίας του κυκλώματος (όταν το reset='1') μπορεί να μοντελοποιηθεί σε VHDL με την παρακάτω διεργασία (σύγχρονη εκδοχή). Με βάση αυτή την περιγραφή και όπως προκύπτει και από το διάγραμμα χρονισμού των σημάτων, το reset επιδρά στο κύκλωμα με την επόμενη ακμή του ρολογιού (σύγχρονο reset). Επομένως αν και το σήμα reset ενεργοποιήθηκε πριν τη θετική ακμή του ρολογιού δε θα επηρεάσει την ανάθεση του q αφού η διεργασία δε θα δει ποτέ αυτή την αλλαγή. ΣΥΓΧΡΟΝΗ ΑΡΧΙΚΟΠΟΙΗΣΗ prοcess(clk) if reset = '1' then q <= (others=> '0'); -- normal mode ΑΣΥΓΧΡΟΝΗ ΑΡΧΙΚΟΠΟΙΗΣΗ process(clk, rst) if rst = '1' then q <= (others => '0'); elsif rising_edge(clk) then --- normal mode. Αντίθετα σε πολλές περιπτώσεις τα ffs που έχουμε στη διάθεση μας, όπως για παράδειγμα αυτά που υπάρχουν μέσα στα ολοκληρωμένα κυκλώματα επαναδιατασσόμενης λογικής (FPGAs), διαθέτουν μια δικιά τους πόρτα αρχικοποίησης, η οποία μας επιτρέπει να θέσουμε την έξοδο τους στην τιμή '0', απευθείας, και ανεξάρτητα από την παρουσία της ακμής του ρολογιού (ασύγχρονη αρχικοποίηση). Ωστόσο, για να μοντελοποιήσουμε αυτή τη συμπεριφορά, πρέπει να μπορούμε να περιγράψουμε τη διεργασία μας με τέτοιο τρόπο, ώστε να είναι ευαίσθητη και στο σήμα αρχικοποίησης αλλά και στις ακμές του ρολογιού, όπως φαίνεται στη στήλη ασύγχρονη αρχικοποίηση του παραπάνω σχήματος. Σε αυτή την περίπτωση στη λίστα ενεργοποίησης της διεργασίας συμμετέχει τόσο το σήμα ρολογιού όσο και το σήμα αρχικοποίησης. Μέσα στη διεργασία ελέγχεται πρώτα η ενεργοποίηση του σήματος αρχικοποίησης οδηγώντας την έξοδο σε μια σταθερή τιμή ενώ όταν το σήμα αρχικοποίησης έχει σβήσει επανερχόμαστε στην κανονική λειτουργία του κυκλώματος. Η περίπτωση της ασύγχρονης αρχικοποίησης είναι η μοναδική στην οποία επιτρέπεται στη λίστα ενεργοποίησης μιας διεργασίας που περιγράφει ακολουθιακή λογική να συμμετέχει και κάποιο άλλο σήμα μαζί με το σήμα ρολογιού. Οποιαδήποτε άλλη περίπτωση ακολουθιακής λογικής που δεν απαιτεί ασύγχρονη αρχικοποίηση περιγράφεται αυστηρά με διεργασίες τις οποίες ενεργοποιεί μόνο οι ακμές ενός σήματος ρολογιού. Η ασύγχρονη αρχικοποίηση εμπεριέχει κινδύνους για την ορθή λειτουργία του κυκλώματος μας, κυρίως όσον αφορά την πιθανότητα πρόκλησης μετασταθερότητας στα flip-flops του κυκλώματος. Το πρόβλημα αυτό αντιμετωπίζεται αν εξωτερικά από το κύκλωμα μας έχουμε εξασφαλίσει πως οι μεταβάσεις στο σήμα reset έχουν συγχρονιστεί με το σήμα ρολογιού και πραγματοποιούνται μακρυά χρονικά από την ακμή δειγματοληψίας του ρολογιού. Μετρητές/καταχωρητές Στη συνέχεια ας δούμε πως μπορούμε να περιγράψουμε σε VHDL με τις κατάλληλες διεργασίες ευρέως χρησιμοποιούμενα κυκλώματα όπως μετρητές και ακολουθιακοί ολισθητές. Για τους απλούς δυαδικούς μετρητές θα περιγράψουμε μια πλούσια τους εκδοχή η οποία επιτρέπει στο χρήστη να επιτρέψει η όχι τη μέτρηση, να καθορίσει τη φορά της, να φορτώσει μια νέα τιμή στο μετρητή καθώς και να ελέγξει κάθε πότε ο μετρητής μηδενίζεται. Η τελευταία αυτή η ιδιότητα μας επιτρέπει να σχεδίασουμε εύκολα μετρητές χρονικών διαστημάτων (timers). library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; 8

9 entity counter is generic(n : integer := 8); port(clk : in std_logic; rst : in std_logic; cnten : in std_logic; lden : in std_logic; ldval : in std_logic_vector(n-1 downto 0); done : out std_logic; count : out std_logic_vector(n-1 downto 0)); end counter; architecture bhv of counter is signal countval: std_logic_vector(n-1 downto 0); count <= countval; done <= '1' when countval = 0 '0'; process(clk, rst) if rst = '1' then countval <= (others => '0'); els if lden = '1' then countval <= ldval; elsif cnten='1' then countval <= countval + 1; end bhv; O καταχωρητής των Ν δυαδικών ψηφίων countval διατηρεί στην έξοδο του την τρέχουσα τιμή του μετρητή. O καταχωρητής αυτός αλλάζει την τιμή του μόνο στη θετική ακμή του ρολογιού ή ασύγχρονα με την ενεργοποίηση του σήματος reset. Οταν το rst=0 και έρθει μια ακμή του ρολογιού τότε η νέα τιμή που θα φορτωθεί στο countval περνάει από δύο σε σειρά πολυπλέκτες. Αν το loaden= 1 τότε στον καταχωρητή countval φορτώνεται η εξωτερική τιμή loadval. Αν όμως το loaden=0 τότε στον καταχωρητή θα φορτωθεί είτε η αυξημένη κατά 1 τιμή του, όταν CountEn=1 ή η παλιά τιμή που ήδη είχε. Ταυτόχρονα, κάθε φορά που η τιμή του καταχωρητή countval είναι ίση με 0 τότε ενεργοποιείται το σήμα done μέσω της απευθείας αναθέσεις (έξω από το process) του παραδείγματος μας. Το κύκλωμα παραγωγής του done είναι κύκλωμα συνδυαστικής λογικής το οποίο οδηγείται από την έξοδο του καταχωρητή countval. Παρατηρήστε πως στην περιγραφή των συνθηκών για τη φόρτωση του καταχωρητή countval με μια νέα τιμή χρησιμοποιούμε τη δομή elsif ( + if) της VHDL η οποία συμπηκνώνει τον κώδικα μας και μειώνει την ανάγκη για επιπλέον Η παραπάνω περιγραφή αντιπροσωπεύει μια γενική δομή για κυκλώματα μετρητών. Αφαιρώντας μέρος της λειτουργίας του γενικού κυκλώματος μπορούμε να σχεδιάσουμε απλούστερα κυκλώματα όπως το διαιρέτη συχνότητας που φαίνεται στο παράδειγμα που ακολουθεί. library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; entity freq_divider_by_16 is 9

10 port(corexclk : in std_logic; ResetxN : in std_logic; Div16xClk : out std_logic); end freq_divider_by_16; architecture bhv of freq_divider_by_16 is signal CountReg : std_logic_vector(3 downto 0); process(corexclk, ResetXN) if ResetxN = '0' then CountReg <= (others => '0'); elsif rising_edge(corexclk) then CountReg <= CountReg + 1; Div16xClk <= CountReg[3]; end bhv; Ένα επιπλέον χρήσιμο παράδειγμα μετρητή είναι αυτό του μετρητή Johnson του οποίου η περιγραφή και το σχηματικό φαίνονται στο παρακάτω σχήμα. O μετρητής Johnson δεν είναι τίποτε άλλο από ένα ακολουθιακό καταχωρητή ολίσθησης (shift register) ο οποίος επανατροφοδοτεί το λιγότερο σημαντικό ψηφίο του καταχωρητή με την ανεστραμμένη εκδοχή του πιο σημαντικού ψηφίου που ολισθαίνει έξω από τον καταχωρητή. library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; entity johnson is generic(n : integer := 8); port(clk : in std_logic; count : out std_logic_vector(n-1 downto 0)); end johnson; architecture bhv of johnson is signal countval : std_logic_vector(n-1 downto 0); count <= countval; --left shift countval(ν-1 downto 1) <= countval(n-2 downto 0); countval(0) <= not countval(n-1); end bhv; Δύο διεργασίες μπορούν να επικοινωνήσουν μέσω των αναθέσεων των σημάτων τους καθορίζοντας από κοινού τη λειτουργία του κυκλώματος. Σε αυτή την περίπτωση οι έμμεσες έξοδοι κάθε διεργασίας (τα σήματα που αναθέτει στο σώμα της) χρησιμοποιούνται ως είσοδοι σε μια άλλη διεργασία είτε στις συνθήκες των δομών if είτε στην δεξιά πλευρά των αναθέσεων. Στη συνέχεια παρουσιάζουμε δύο τέτοια παραδείγμα. architecture test of. signal s1, s2, s3, s4: std_logic; process(s1, s2) if s1 = 1 then s3 <= s2; s3 <= 0 ; process(s1, s3) if s1= 1 then 10

11 s4 <= s3; s4 <= s1; end test; architecture test of. signal cnt_a: std_logic_vector(3 downto 0); signal cnt_b: std_logic_vector(3 downto 0); process(clk, rst) if rst = 1 then cnt_a <= (others=> 0 ); els cnt_a <= cnt_a + 1; process(clk, rst) if rst= 1 then cnt_b <= (others=> 0 ); if cnt_a = 0 then cnt_b <= cnt_b+1; end test; Στην πρώτη περίπτωση η έξοδος s3 της πρώτης διεργασίας χρησιμοποιείτε ως είσοδος στην άλλη διεργασία (βρίσκεται στη δεξιά πλευρά της ανάθεσης). Για να είναι σωστή η περιγραφή της συνδυαστικής λογικής που περιγράφουν από κοινού οι δύο διεργασίες εφόσον το s3 συμμετέχει ως είσοδος στη δεύτερη διεργασία πρέπει να συμμετέχει στη λίστα ενεργοποίησης της διεργασίας αυτής. Στην δεύτερη περίπτωση οι δύο διεργασίες περιγράφουν δύο μετρητές των 4 δυαδικών ψηφίων, τον cnt_a και τον cnt_b. O πρώτος μετρητής περιγράφεται στην πρώτη διεργασία και αυξάνει την τιμή του σε κάθε κύκλο ρολογιού ενώ ο δεύτερος αυξάνει την τιμή του μόνο σε εκείνους τους κύκλους (μετά από θετική ακμή) που η τιμή του μετρητή cnt_a είναι ίση με 0. Ενώ οι αναθέσεις σε ένα σήμα πρέπει να γίνονται όλες στο ίδιο process (ή σε μια απευθείας ανάθεση) για την αποφυγή πολλαπλών οδηγητών στο ίδιο σήμα, οι αναγνώσεις του σήματος μπορεί να γίνονται σε πολλά σημεία στην περιγραφή της VHDL. ΑΡΧΕΙΟ ΚΑΤΑΧΩΡΗΤΩΝ Ο τρόπος που μοντελοποιήσαμε τους καταχωρητές, τους μετρητές και τους ολισθητές μπορεί να χρησιμοποιηθεί για τη μοντελοποίηση μικρών αρχείων καταχωρητών που διαλέγουμε να υλοποιήσουμε μέσω flip-flop και λογικών πυλών. Για μεγαλύτερες μονάδες μνήμης μέσα στα ολοκληρωμένα κυκλώματα αντί για αρχεία καταχωρητών είμαστε υποχρεωμένοι να χρησιμοποιήσουμε έτοιμες προσχεδιασμένες SRAM οι οποίες σχεδιάζονται σε επίπεδο τρανζίστορ και δεν μπορούν να προκύψουν μέσω περιγραφών σε VHDL και λογικής σύνθεσης. Σε αυτή την περίπτωση η μόνη αυτοματοποίηση που μας παρέχεται είναι η επιλογή του μεγέθους των μνημών αυτών και ίσως και της γεωμετρίας του φυσικού τους σχεδίου μέσω ειδικών memory compilers οι οποίοι συνθέτουν το φυσικό σχέδιο των μνημων τρανζίστορ προς τρανζίστορ. Η περιγραφή της λειτουργίας ενός σύγχρονου αρχείου καταχωρητών με μια πόρτα ανάγνωσης και εγγραφής φαίνεται στο παράδειγμα που ακολουθεί. library ieee; use ieee.std_logic_1164.all; use ieee.std_logic_unsigned.all; entity ram_32_4 is port ( clk, we : in std_logic; -- Clock and write enable 11

12 addr : in std_logic_vector(4 downto 0); -- address di : in std_logic_vector(3 downto 0); -- Data in do : out std_logic_vector(3 downto 0));-- Data out end ram_32_4; architecture imp of ram_32_4 is type ram_type is array(31 to 0) of unsigned(3 downto 0); signal ram : ram_type; process (Clk) if rising_edge(clk) then if we = 1 then ram(conv_interger(addr)) <= di; do <= di; -- write-through do <= ram(conv_integer(addr)); end imp; Τα στοιχεία που πρέπει να προσέξετε από αυτήν την περιγραφή είναι δύο. Το πρώτο είναι η δήλωση του σήματος που χρησιμοποιείται για τη μοντελοποίηση όλων των flip-flops του αρχείου καταχωρητών. Στο παράδειγμα αυτό θέλουμε να μοντελοποιήσουμε ένα αρχείο καταχωρητών των 32 θέσεων (επομένως θα χρειαστούμε 5 bits για κάθε διεύθυνση) των 4 bits η καθεμία. Για να το κάνουμε αυτό χρειαζόμαστε ένα πίνανα (array) των 32 θέσεων όπου σε κάθε θέση θα βρίσκαμε ένα std_logic_vector(3 downto 0), δηλαδή μια δυαδική λέξη των 4 δυαδικών ψηφίων. Για να εμφανίσουμε στη VHDL μια τέτοια δισδιάστατη δομή από σήματα χρειάζεται να δηλώσουμε ένα νέο τύπο ως εξης: type ram_type is array(31 to 0) of unsigned(3 downto 0); Το σήμα ram που μοντελοποιεί όλα τα flip flops του αρχείου καταχωρητών ακολουθεί αυτόν τον τύπο. Κάθε φορά που απευθυνόμαστε σε μια θέση του σήματος ram θα διαχεριζόμαστε ένα τύπο std_logic_vector. Ετσι θα μπορούμε να γράψουμε την παρακάτω ανάθεση: ram(2) <= 0101 ; Εφόσον κάθε ram(i) είναι ένα std_logic_vector σημαίνει πως μπορούμε να απευθυνθούμε στα bits του vector αυτού χρησιμοποιώντας ακόμη μια παρένθεση. Δηλάδή αν γράψουμε X <= ram(2)(3); αμέσως μετά την προηγούμενη ανάθεση, θα περιμένουμε το σήμα x να πάρει την τιμή 1. Το δεύτερο στοιχείο που πρέπει να προσέξετε από την περιγραφή είναι η ίδια λειτουργία της μνήμης και πως απευθυνόμαστε σε όλες τις θέσεις της ανάλογα με την τιμή της διεύθυνσης addr. Για να προσπελάσουμε είτε για εγγραφή είτε για ανάγνωση το στοιχείο που δείχνει η διεύθυνση addr πρέπει πρώτα να μετατρέψουμε το std_logic_vector του addr σε ένα ακέραιο αριθμό. Αυτό πραγματοποιείτε μέσω της conv_integer(). Επομένως η περιγραφή ram(conv_integer(addr)) οδηγεί το εργαλείο λογικής σύνθεσης να γεννήσει ένα αποκωδιποιητή ο οποίος ανάλογα με την τιμή του addr προσπελαύνει είτε για εγγραφή είτε για ανάγνωση το αντίστοιχο std_logic_vector του ram. Εφόσον όλες οι αναθέσεις στο σήμα ram γίνονται μετά την ακμή του ρολογιού, για κάθε ένα από τα bit του δημιουργείται και ένα flip-flop. Οταν το σήμα επίτρεψης εγγραφής wen=1 τότε η είσοδος γράφεται στη αντίστοιχη θέση και την ίδια στιγμή εμφανίζεται και στην έξοδο (write through). Αντίθετα όταν πραγματοποιείται ανάγνωση η έξοδος do οδηγείται από κάποιο καταχωρητή της μνήμης ο οποίος επιλέγεται μέσω ενός πολυπλέκτη ανάλογα με την τιμή του addr. Σε αυτή την περίπτωση αποκωδικοποιητής και πολυπλέκτης είναι το ίδιο πράγμα και οδηγούν σε μια υλοποίηση με AND OR πύλες για την αποκωδικοποιήση και συλλογή του τελικού αποτελέσματος. Αυτό που πρέπει να προσέξετε είναι πως πέρα από τα flip flops του αρχείου καταχωρητών κατά τη λογική σύνθεση γεννιέται και ακόμη ένας καταχωρητής για την έξοδο do. Στα παραδείγματα θα δούμε πως μπορούμε να προσθέσουμε περισσότερες πόρτες ανάγνωσης ή εγγραφής στο βασικό αρχείο καταχωρητών. Περιγραφή FSM Οι μηχανές πεπερασμένων καταστάσεων χρησιμοποιούνται ευρέως στα ψηφιακά κυκλώματα που σχεδιάζουμε. Η περιγραφή του ισοδύναμου κυκλώματος της FSM σε VHDL ακολουθεί μια τυποποιημένη περιγραφή που αποτελείται από δύο βασικά μέρη όπως θα δούμε παρακάτω. Στην εικόνα που ακολουθεί φαίνεται μια FSM στην οποία διακρίνουμε τα εξής μέρη: 12

13 1. Την αρχική κατάσταση η οποία αναπαρίσταται με έναν διπλό κύκλο (δεν είναι δεσμευτικό). Στην περίπτωση ενεργοποίησης του σήματος αρχικοποίησης Reset μεταβαίνουμε σε αυτήν την κατάσταση ανεξάρτητα από την τρέχουσα κατάσταση του κυκλώματος. 2. Τις καταστάσεις της FSM οι οποίες αναπαρίστανται με ένα κύκλο και συνοδεύονται από ένα όνομα. 3. Τα βέλη των μεταβασεων που ενώνουν δύο καταστάσεις (ή καταλήγουν στην ίδια κατάσταση) τα οποία μπορεί είτε να ελέγχονται από κάποια συνθήκη είτε όχι, π.χ., η μετάβαση S0 -> S1 πραγματοποιείται όταν η είσοδος start παίρνει την τιμή 1, ενώ η μετάβαση S3 -> S4 συμβαίνει ανεξάρτητα από τις τρέχουσες τιμές των εισόδων. Δεν πρέπει να ξεχνάμε πως οι μεταβάσεις πραγματοποιούνται σε κάθε θετική ακμή του ρολογιού. 4. Τις τιμές των εξόδων που αντιστοιχούν σε κάθε κατάσταση. Για να καταφέρουμε να μοντελοποιήσουμε μια μηχανή πεπερασμένων καταστάσεων πρέπει: 1. Να αναπαραστήσουμε τις καταστάσεις. 2. Να μπορούμε να αποθηκεύσουμε την τρέχουσα κατάσταση. 3. Να καθορίσουμε τις μεταβάσεις από τη μια κατάσταση στην άλλη. 4. Να υπολογίζουμε τις τιμές εξόδου που αφορούν την κάθε κατάσταση. Στη συνέχεια θα περιγράψουμε έναν πρότυπο τρόπο, ο οποίος μας επιτρέπει να καλύψουμε με απλό τρόπο όλες τις παραπάνω προυποθέσεις. Για την περιγραφή της FSM χρησιμοποιούμε μία process για τον υπολογισμό της επόμενης κατάστασης και την αποθήκευση της τρέχουσας κατάστασης. Η process αυτή ουσιαστικά μοντελοποιεί με έναν ενοποιημένο τρόπο τη λογική επόμενης κατάστασης και τον καταχωρητή κατάστασης της FSM. Αντίθετα με το σύνολο των απευθείας αναθέσεων περιγράφουμε τη λογική εξόδου που δίνει τιμές στα σήματα εξόδου της FSM λαμβάνοντας υπόψιν την τρέχουσα κατάσταση. To παράδειγμα που ακολουθεί υλοποιεί την αρχική fsm σύμφωνα με την πρότυπη περιγραφή. architecture bhv of fsm is type fsm_state is enum (sidle, stoken, sspray); signal state : fsm_state; -- state holding registers and state transition logic process(clk, rst) if rst= 1 then state <= sidle; els case state is when sidle => if token= 1 then state <= stoken; state <= sidle; --redundant can be omitted 13

14 when stoken => state <= sspray; when sspray => if tdone= 1 then state <= sidle; state <= sspray; --redundant can be omitted when others => state <= sidle; -- output logic clrt <= 1 when state=stoken 0 ; spray <= 1 when state=stoken or state=sspray 0 ; end bhv; Η πρώτη προϋπόθεση της πρότυπης περιγραφής FSM έχει να κάνει με την κωδικοποιήση των καταστάσεων. Στην περιγραφή μας αποφεύγουμε να διαλέξουμε οποιαδήποτε κωδικοποίηση και συνεχίζουμε να αναφερόμαστε στις καταστάσεις με τα συμβολικά τους ονόματα. Για να το κάνουμε αυτό πρέπει να ορίσουμε ένα τύπο enumeration στον οποίο να συμπεριλάβουμε μια συμβολική ονομασία για κάθε κατάσταση. Στο παράδειγμα ορίζουμε τον τύπο fsm_state τον οποίο ακολουθεί και ο καταχωρητής κατάστασης της FSM που ονομάσαμε state. Ανάλογα με την κωδικοποίηση που θα διαλέξει το εργαλείο της λογικής σύνθεσης θα αλλάξει και το πλήθος των flip-flop από τα οποά αποτελείται ο καταχωρητής state. Με την ενεργοποίηση του reset αναθέτουμε στον καταχωρητή state την τιμή της αρχικής κατάστασης (η IDLE στην περίπτωση μας). Στη συνέχεια όταν το reset είναι απενεργοποιημένο σε κάθε θετική ακμή του ρολογιού αναθέτουμε στον καταχωρητή κατάστασης μια νέα κατάσταση λαμβάνοντας υπόψιν την τρέχουσα κατάσταση (μέσω του case state is) και των τιμών των εισόδων που εμφανίζονται ως συνθήκες σε κάποιες από τις μεταβάσεις της FSM. case state is when S1=> Τρέχουσα κατάσταση if in= 1 then state <= S2 Σύνθηκη εισόδου για μετάβαση από S1 σε S2 Εφόσον όλες οι αλλαγές στο state πραγματοποιούνται στις θετικές ακμές του ρολογιού, αυτό σημαίνει πως το εργαλείο λογικής σύνθεσης θα αναθέσει το state σε ένα σύνολο από flip-flops. Στη συνθήκη case ελέγχουμε την έξοδο αυτών των flip-flops (παλιά τιμή του state) και υπολογίζουμε μια κανούρια κατάσταση που ανατίθεται στο state. Αν καμμιά από τις συνθήκες αλλαγής κατάστασης δεν ενεργοποιηθεί τότε η τιμή της κατάστασης της FSM παραμένει ίδια με αυτή του προηγούμενου κύκλου. Αυτή τη συμπεριφορά δεν είναι ανάγκη να την περιγράψουμε καθώς στις περιπτώσεις που το state δε παίρνει νέα τιμή το αναγκάζουμε να θυμάται την παλιά του. H επιλογή case διαφέρει από τις εμφωλευμένες if καθώς επιτρέπει παράλληλες επιλογές δημιουργώντας έτσι ένα μεγάλο πολυπλέκτη ανάλογα με τις επιλογές when που εμφανίζονται. Η περιγραφή της FSM ολοκληρώνεται με την περιγραφή της λογικής εξόδου μέσα από ένα σύνολο απευθείας αναθέσεων ίσο με το πλήθος των εξόδων της FSM. H κάθε ανάθεση ακολουθεί την ίδια μορφή: output <= 1 when state=<> or state=<> or or state<> 0 ; Δηλάδη, ελέγχουμε σε ποια κατάσταση βρίσκεται το state και δίνουμε αντίστοιχα τη σωστή τιμή στο σήμα εξόδου. Οπως φαίνεται στην ανάθεση που ακολουθεί το σήμα εξόδου output_xy μπορεί να οδηγείται σε περισσότερες από δύο τιμές ανάλγα με την κατάσταση της fsm. output_xy <= 00 when state=χο 01 when state=χ1 or state=υο 10 ; 14

15 Συνήθη λάθη περιγραφών ακολουθιακής λογικής Τα παραδείγματα που ακολουθούν παρουσιάζουν συνηθισμένα λάθη στις περιγραφές ακολουθιακής λογικής με VHDL. if (clk= 1 ) then y <= z; gclk <= clk and en; process (glk) if rising_edge(gclk) then q <= d; process(clk, en) if en= 1 then q <= d; Το process ενεργοποιείτε μόνο όταν το σήμα clk αλλάζει ενώ η ανάθεση του q συμβαίνει όταν clk= 1. Επομένως, το q μεταβάλλεται μόνο όταν το clk κάνει μια μετάβαση από το 0 στο 1. Αν και στην προσωμοίωση η περιγραφή αυτή συμπεριφέρεται ακριβώς όπως ένα flipflop, τα εργαλεία λογικής σύνθεσης την αντιστοιχίζουν σε latches επιβάλλοντας τη χρήση του rising_edge(clk) στη συνθήκη του if. Αυτή η περιγραφή οδηγεί το εργαλείο λογικής σύνθεση να γεννήσει λογικές πύλες πάνω στο ρολόι (clock gating) οι οποίες είναι πολύ επικίνδυνες εξαιτίας πιθανών glitches Η περιγραφή δε μετατρέπεται σε υλικό καθώς περιγράφει μια συνθήκη κάτω από την οποία θα ενεργοποιηθεί μια ακμή του ρολογιού. Μοιάζει με το προηγούμενο αλλά είναι δεν είναι από πλευράς VHDL. Πως υπολογίζονται οι αναθέσεις Στο παράδειγμα που ακολουθεί πραγματοποιούνται δύο αναθέσεις μέσα σε μια διεργασία κατά τη θετική ακμή του ρολογιού. Η μία στο σήμα FCA και η άλλη στο σήμα claim. Επειδή οι αναθέσεις αυτές πραγματοποιούνται στη θετική ακμή του ρολογιού προκύπτει πως μετά τη λογική σύνθεση τα σήματα αυτά θα ανατεθούν στις εξόδους δύο flip-flop. Η υπολοιπη λογική που περιγράφεται αντιστοιχεί σε κομμάτια συνδυαστικής λογικής όπως πύλες OR, AND και πολυπλέκτες η οποία καταλήγει στις εισόδους των δύο flip-flop που αφορούν στα σήματα FCR και claim 01: 02 : 03: 04: FCR <= ER or xmit; 05: if merge= 0 then 06: claim <= FCR; 07: 08: claim <= FDDI; 09: 10: 11: end 15

16 Όταν παρατηρήσουμε την περιγραφή σε VHDL και τις κυματομορφές βλέπουμε πως ενώ το FCR οδηγείται στο λογικό 1 στον κύκλο Χ, η τιμή αυτή δεν «περνάει» στο claim αμέσως (ανάθεση στη γραμμή 06) αλλά στον επόμενο κύκλο ρολογιού. Η συμπεριφορά αυτή είναι λογική καθώς το FCR που βρίσκεται στη δεξιά πλευρά της ανάθεσης του claim προέρχεται από την έξοδο του flip-flop που αντιστοιχεί στο FCR και επομένως θα λάβει τη νέα του τιμή με την επόμενη ακμή του ρολογιού. Για να μπορέσετε να καταλάβετε καλύτερα την παραπάνω συμπεριφορά και πως γενικεύεται ακόμη και στην περίπτωση της συνδυαστικής λογικής πρέπει να κατανοήσετε τον τρόπο που υπολογιζόνται οι αναθέσεις μέσα στις διεργασίες. Με την ενεργοποίηση μιας διεργασίας μετά την αλλαγή ενός από τα σήματα που συμμετέχουν στη λίστα ενεργοποίησης (sensitivity list) αρχικά υπολογίζονται όλα τα δεξιά μέρη των αναθέσεων χρησιμοποιώντας ταυτόχρονα για όλες τις αναθέσεις τις παλιές γνωστές τιμές των σημάτων. Επειδή μια ανάθεση προηγείται μιας άλλης αυτό δε σημαίνει πως μπλοκάρει ή αναγκάζει την επόμενη να την περιμένει. Ολες οι αναθέσεις εξετάζονται ταυτόχρονα. Μετά τον υπολογισμό του δεξιού μέρους όλων των αναθέσεων με το τέλος του process οι τιμές που έχουν υπολογιστεί ανατίθενται ταυτόχρονα στα σήματα στη αριστερή πλευρά των αναθέσεων. To παράδειγμα που ακολουθεί αποτελείται από τρείς αναθέσεις, οι οποίες δείχνουν να εξαρτώνται η μία από το αποτέλεσμα της άλλης. Πως όμως αυτό «εκτελείτε» σε VHDL; Πριν την εκκίνηση θεωρούμε πως όλα τα σήματα είχαν την τιμή 0 process(a,b,c) b <= a; c <= b; d <= c; end; Το α αλλάζει 0->1 => Η διεργασία ενεργοποιείτε Το b προγραμματίζεται να γίνει 1 στο τέλος της διεργαίας Το c προγραμματίζεται να γίνει 0 στο τέλος της διεργασίας (μέχρι τώρα γνωστή τιμή του b) Το d προγραμματίζεται να γίνει 0 στο τέλος της διεργασίας (μέχρι τώρα γνωστή τιμή του c) Με το τέλος της διεργασίας γίνονται όλες οι αναθέσεις ταυτόχρονα: b <-1, c<-0, d <- 0. Η λειτουργία που αντιστοιχεί στον παραπάνω κώδικα VHDL είναι η εξής: «Οταν η λίστα ενεργοποίησης ενεργοποιηθεί, υπολογίζεται πρώτα τη δεξιά πλευρά όλων των αναθέσεων ταυτόχρονα χρησιμοποιώντας τις τιμές που γνωρίζουμε εκείνη τη στιγμή (τις παλιές τιμές). Αφού ολοκληρωθεί το βήμα αυτό, όλες οι αναθέσεις πραγματοποιούνται ταυτόχρονα στο τέλος. Ετσι με άλλα λόγια, το Β παίρνει την τιμή του Α, το C παίρνει την παλιά τιμή του B, και το C παίρνει την παλιά τιμή του D. Αν και η ανάθεση στο C γράφηκε μέτα την ανάθεση του B αυτό δε σημαίνει πως το C θα περιμένει να ολοκληρωθεί η ανάθεση στο B ώστε τελικά να δει την τιμή του να ισούται με A. Εφόσον όλες οι αναθέσεις πραγματοποιούνται στο τέλος κάθε process μπορούμε να χρησιμοποιήσουμε περισσότερες από μια αναθέσεις στο ίδιο σήμα μέσα σε κάθε process χωρίς αυτό να δημιουργεί τον κίνδυνο πολλάπλής οδήγησης. Στην περίπτωση αυτή μόνο η τελευταία στη σειρά ανάθεση (πιο κοντά στο τέλος του process) θα χρησιμοποιηθεί και οι τιμές όλων των υπολοίπων θα αγνοηθούν. Για παράδειγμα το παρακάτω κομμάτι κώδικα περιλαμβάνει 3 αναθέσεις στο σήμα y. a,b,c,d,y: std-logic; process (a, b, c, d) y <= a or c; y <= a and b; y <= c and d; a,b,c,d,y: std-logic; process (a, b, c, d) y <= c and d; Το γεγονός ότι μόνο η τελευταία ανάθεση σε ένα process θα χρησιμοποιηθεί τελικά μας επιτρέπει να περιγράψουμε αναθέσεις με προτεραιότητες με δύο τρόπους: process () if sel(0)= 1 then if sel(3)= 1 then process () if sel(3)= 0 then Ζ<= 0 if sel(0) then 16

17 Z<= 0 ; Στην πρώτη περίπτωση που φαίνεται στο αριστερό κομμάτι κώδικα η συμπεριφορά περιγράφεται με ανεξάρτητες if δομές, από τις οποίες η τελευταία έχε την υψηλότερη προτεραιότητα. Στη δεύτερη περίπτωση όλες οι περιπτώσεις είναι περιγεγγραμένες πιο αυστήρα χρησιμοποιώντας εμφωλευμένες if επιτρέποντας έτσι μόνο μια ανάθεση στο Z ανάλογα με τους συνδυασμούς τωβν σημάτων sel. Ενώ και οι δύο δομές είναι ισοδύναμες μεταξύ τους όσον αφορά στο υλικό που περιγράφουν παρόλα αυτά προτείνετε η χρήση των εμφωλευμένων if. Επειδή όλες οι αναθέσεις θα ολοκληρωθούν με την έξοδο από το process μόνο η τελευταία θα έχει πραγματικό αποτέλεσμα. Επομένως, η παραπάνω διεργασία είναι ισοδύναμη με αυτή που φαίνεται στη δεξιά πλευρά. Θα μπορούσαμε να χρησιμοποιήσουμε τις πολλαπλές αναθέσεις στο ίδιο σήμα για να αποφύγουμε τη γέννηση latches στην περίπτωση κυκλωμάτων συνδυαστικής λογικής απλά φροντίζοντας να δώσουμε αρχικές τιμές στα σήματα μας. process(a, b) Begin Y <= 0 ; --default values if (a= 1 ) then Y <= b ; process(a, b) C<=a or b; if (a and b = 1 ) then C<= 0 ; Στα δύο παραδείγματα, οι δομές if δεν διαθέτουν το απαιτούμενο μονοπάτι. Η παράλειψη αυτή δε δημιουργεί πρόβλημα καθώς με την ενεργοποίηση του process τα σήματα y και c, αντίστοιχα, λαμβάνουν μια τιμή η οποία θα παραμείνει μέχρι το τέλος αν δε ικανοποιηθούν οι συνθήκες των if. Έτσι, σε κάθε περίπτωση τα σήματα y και c θα οδηγούνται σε μια τιμή χωρίς την ανάγκη να θυμούνται τις παλιές τους τιμές. Αυτός ο τρόπος χρονοπρογραμματισμού των αναθέσεων μέσα σε process δυσκολεύει κάποιες φορές τις περιγραφές κυκλωμάτων συνδυαστικής λογικής. Γενικά στις περιγραφές συνδυαστικής λογικής θα θέλαμε οι νέες τιμές που αναθέτουμε σε ένα σήμα να μπορούν να είναι άμεσα ορατές στις αναθέσεις των επόμενων σημάτων, ότι δηλαδή θα συνέβαινε στην κανονική λειτουργία ενός κυκλώματος συνδυαστικής λογικής. Για να πετύχουμε αυτή τη συμπεριφορά μέσα σε ένα process πρέπει να χρησιμοποιήσουμε τόσο ένα νέο τύπο δεδομένων, το variable, αντί για signal όσο και μια νέα μορφή ανάθεσης, την := έναντι του <=. Οι αναθέσεις σε variable πραγματοποιούνται και γινονται ορατές απ ευθείας και δεν περιμένουν την ολοκλήρωση του process. signal a,b,c: std_logic; signal y: std_logic; process(a, b, c) variable vx: std_logic; vx := a or b; if c= 1 then vx := 0 ; y <= vx; Πριν την εκκίνηση θεωρούμε πως τα σήματα είχαν την τιμή 0 Το α αλλάζει 0->1 => Η διεργασία ενεργοποιείτε To variable δηλώνεται μόνο μέσα σε process Το vx παίρνει αμέσως την τιμή 1 or 0=1 H συνθήκη δεν ενεργοποιείται. Το vx μένει στο 1 από την προηγούμενη ανάθεση Το y προγραμματίζεται να γίνει όσο και το vx στο τέλος της διεργασίας, δηλαδή ίσο με την τρέχουσα τιμή (1) του vx που έχει πάρει από την πρώτη ανάθεση Με το τέλος της διεργασίας γίνονται όλες οι αναθέσεις στα σήματα ταυτόχρονα: y <-1 Ενώ τα variables είναι πολύ καλά για την περιγραφή συνδυαστικής λογικής καταλήγουν να δημιουργούν πολλά προβλήματα στην περιγραφή ακολουθιακής λογικής όπου όλες οι αναθέσεις στα σήματα μας πρέπει να πραγματοποιηθούν στην ακμή ενός σήματος ρολογιού. Στο παράδειγμα που ακολουθεί περιγράφουμε τη λειτουργία ενός καταχωρητή ολίσθησης ο οποίος μπορεί να αρχικοποιηθεί με την ενεργοποίηση ενός σήματος ρολογιού. 17

18 if reset= 1 then s_q1 <= 0 ; s_q2 <= 0 ; q3 <= 0 ; q3 <= s_q2; s_q2 <= s_q1; s_q1 <= d; if reset= 1 then s_q1 <= 0 ; s_q2 <= 0 ; q3 <= 0 ; s_q1 <= d; s_q2 <= s_q1; q3 <= s_q2; Οπως ήταν αναμενόμενο εφόσον οι αναθέσεις στα σήματα q3, s_q2, s_q1 γίνονται στη θετική ακμή του ρολογιού αντιστοιχίζεται σε κάθε ένα από αυτά και ένα flip flop. Επίσης, εφόσον και τα τρία σήματα είναι τύπου signal όλες οι αναθέσεις σε αυτά προγραμματίζονται κατά τη διάρκεια του process και «εκτελούνται» με το τέλος του περιμένοντας την εκ νέου ενεργοποίηση του. Έτσι όταν το reset=0, to q3 παίρνει την παλιά τιμή του s_q2 (έξοδος αντίστοιχου flip flop), το s_q2 την παλιά τιμή του s_q1 (έξοδος αντίστοιχου flip flop) και το s_q1 την τιμή του d. Εξαιτίας της ταυτόχρονης ανάθεσης στο τέλος του process αυτή η συμπεριφορά παραμένει αναλλοίωτη ακόμη και αν αλλάξει στην περιγραφή της VHDL η σειρά των αναθέσεων όπως φαίνεται στη δεξιά ισοδύναμη περιγραφή. Αν στην περιγραφή είχαμε υιοθετήσει τη χρήση variables για την ακολουθιακή λογική, τότε το αποτέλεσμα που θα πέρναμε μετά τη λογική σύνθεση θα ήταν πολύ διαφορετικό. variable v_q2: std_logic; if reset= 1 then s_q1 <= 0 ; v_q2 <= 0 ; q3 <= 0 ; q3 <= v_q2; v_q2 := s_q1; s_q1 <= d; variable v_q2: std_logic; if reset= 1 then s_q1 <= 0 ; v_q2 := 0 ; q3 <= 0 ; s_q1 <= d; v_q2 := s_q1; q3 <= v_q2; O λόγος για την εξαφάνιση του ενός καταχωρητή στην περίπτωση της δεύτερης περιγραφής σε VHDL είναι η ανάθεση στο variable v_q2 και η χρησιμοποίηση του για την ανάθεση του q3. H ανάθεση στο v_q2 επιβάλλει την άμεση ενημέρωση του v_q2 με την τρέχουσα τιμή του s_q1, αυτή δηλαδή που είχε με την έναρξη του process (έξοδος του flip-flop s_q1). Η τιμή αυτή είναι αυτή που τελικά θα ανατεθεί στο q3 στο τέλος του process. Επειδή το v_q2 είναι ένα απλό αντίγραφο της τιμής του s_q1, το flip flop που αντιστοιχούσε πριν στο s_q2 δεν έχει λόγο να υφίσταται αφού η τιμή του s_q1 περνά απευθείας στο q3 μέσω της ανάθεσης στο variable v_q2. 18

19 Στο επόμενο παράδειγμα θα δείξουμε πως τα variables μπορούν να χρησιμοποιηθούν για την περιγραφή επαναληπτικών δομών συνδυαστικής λογικής. Μας δίνεται μια 8μπιτη ποσότητα και θέλουμε να υπολογίσουμε την ισοτιμία (parity) αυτών των bits. Ουσιαστικά πρόκειται για το xor όλων των bits της εισόδου του κυκλώματος. Η πρώτη περιγραφή που σκεφτήκαμε φαίνεται στην αριστερή πλευρά του σχήματος που ακολουθεί. Οργανώσαμε τον υπολογισμό μας σε ένα for loop το οποίο εξετάζει ένα-ένα τα δυαδικά ψηφία του αριθμού και υπολογίζει τη μέχρι τώρα ισοτιμία προσθέτωντας σε κάθε «επανάληψη» και ένα επιπλέον δυαδικό ψηφίο. To for. loop συντάσεται ακριβώς όπως το for generate που χρησιμοποιείται για την επαναληπτική δημιουργία υποκυκλωμάτων. architecture beh_sig of parity is signal parity : std_logic; process(in_vec) parity <= '0'; for i in 7 downto 0 loop parity <= parity xor in_vec(i); end loop; out1 <= parity; end beh_sig; architecture beh_var of parity is process(in_vec) variable parity : std_logic; parity := '0'; for i in 7 downto 0 loop parity := parity xor in_vec(i); end loop; out1 <= parity; end beh_var; Εφόσον οι αναθέσεις στα σήματα (signals) μέσα σε ένα process πραγματοποιούνται όλες μαζί στο τέλος του process, αυτό έχει ως αποτέλεσμα το σήμα parity να κρατήσει μόνο την τιμή από την τελευταία επανάληψη, ενώ ταυτόχρονα δημιουργεί και ένα συνδυαστικό loop το οποίο πρέπει να αποφεύγεται. Η λειτουργία που θέλουμε να επιτύχουμε ουσιαστικά απαιτεί να μεταφέρουμε το ενδιάμεσο αποτέλεσμα από τη μια επανάληψη του loop στην επόμενη. Αυτό μπορούμε να το πετύχουμε μόνο μέσω ενός variable που επιβάλλει την άμεση ανάθεση του. Έτσι, σε κάθε επανάληψη το variable parity διατηρεί το xor των μέχρι τώρα ψηφίων της εισόδου. Θα μπορούσαμε να είχαμε κάνει ακριβώς την ίδια δουλειά χρησιμοποιώντας περισσότερα signals αντί για ένα variable. O τρόπος που θα μπορούσε να γίνει αυτό φαίνεται στο παράδειγμα που ακολουθεί. Ουσιαστικά αντικαστήσαμε το variable μέ ένα χωριστό καλώδιο parity(i) ένα για κάθε επανάληψη. architecture beh_var of parity is signal parity: std_logic_vector(8 downto 0); process(in_vec) parity(0) <= '0'; for i in 0 to 7 loop parity(i+1) <= parity(i) xor in_vec(i); end loop; out1 <= parity(8); end beh_var; 19