Υλοποίηση αλγόριθμου ανίχνευσης ακμών σε εικόνα (Sobel)

ΑΡΙΣΤΟΤΕΛΕΙΟ ΠΑΝΕΠΙΣΤΗΜΙΟ ΘΕΣΣΑΛΟΝΙΚΗΣ ΣΧΟΛΗ ΘΕΤΙΚΩΝ ΕΠΙΣΤΗΜΩΝ - ΤΜΗΜΑ ΦΥΣΙΚΗΣ ΤΟΜΕΑΣ ΗΛΕΚΤΡΟΝΙΚΗΣ & ΗΛΕΚΤΡΟΝΙΚΩΝ ΥΠΟΛΟΓΙΣΤΩΝ ΜΕΤΑΠΤΥΧΙΑΚΟ ΠΡΟΓΡΑΜΜΑ ΗΛΕΚΤΡΟΝΙΚΗΣ ΦΥΣΙΚΗΣ - ΡΑΔΙΟΗΛΕ- ΚΤΡΟΛΟΓΙΑΣ - ΤΟΜΕΑΣ ΣΧΕΔΙΑΣΗΣ ΗΛΕΚΤΡΟΝΙΚΩΝ ΚΥΚΛΩΜΑΤΩΝ Γέντσος Χρίστος ΔΙΠΛΩΜΑΤΙΚΗ ΕΡΓΑΣΙΑ Με τίτλο Υλοποίηση αλγόριθμου ανίχνευσης ακμών σε εικόνα (Sobel) Επιβλέποντες: Σπύρος Νικολαΐδης, Αναπληρωτής Καθηγητής Θεσσαλονίκη, Μάρτιος 2010

Περίληψη Σχεδιάσαμε ένα IP core το οποίο εφαρμόζει τον τελεστή Sobel 3x3 [1] στα στοιχεία μιας εικόνας, κάτι που αποτελεί το βασικό στάδιο ενός συστήματος ανίχνευση ακμών. Το IP core σχεδιάστηκε για χρήση με το λογισμικό EDK της Xilinx. Έτσι μπορεί να ενσωματωθεί σε ένα embedded σύστημα FPGA μέσω του γραφικού περιβάλλοντος που προσφέρει το λογισμικό αυτό. Το IP core συνδέεται σαν περιφερειακό με τον επεξεργαστή (Microblaze της Xilinx) και με τη μνήμη του συστήματος ώστε αφού πάρει την αρχική εντολή από τον επεξεργαστή λειτουργεί αυτόνομα, έχοντας το δικό του δίαυλο επικοινωνίας με τη μνήμη. Η επικοινωνία αυτή γίνεται μέσω του VFBC, το οποίο είναι ένα interface επικοινωνίας με εξωτερική μνήμη DDR εξειδικευμένο για εφαρμογές εικόνας / video. Η επεξεργασία των δεδομένων γίνεται σε ομάδες των 4 pixels των 8 bit ανά κύκλο λειτουργίας, κάνοντας χρήση των δυνατοτήτων παραλληλίας των FPGA και βελτιώνοντας το throughput. Επίσης γίνεται χρήση της γρήγορης τοπικής μνήμης του FPGA ως cache για βέλτιστη αξιοποίηση του bandwidth με τη μνήμη. Κάθε κύκλος λειτουργίας διαρκεί 2 clocks και η διαδικασία του synthesis έδειξε συχνότητες χρονισμού στα 225MHz σε FPGA της σειράς Virtex5 (LX110T), άρα οι επιδόσεις του κυμαίνονται στα 450MPixels/sec. Επίσης το σχέδιο είναι αρκετά μικρό ώστε να χωράει μέχρι και σε μεσαίο FPGA της γενιάς Spartan 3E, όπου οι επιδόσεις του κυμαίνονται στα 100MHz - 200MPixels/sec. Η σωστή λειτουργία του κυκλώματος επιβεβαιώθηκε σε αναπτυξιακό της Xilinx (VUPV5-LX110T) το οποίο χρησιμοποιεί FPGA της σειράς Virtex5. Τέλος για την επιβεβαίωση της λειτουργίας αναπτύξαμε μικρό πρόγραμμα για την επικοινωνία του PC με το αναπτυξιακό και την επισκόπηση των αποτελεσμάτων της επεξεργασίας. Η έρευνα που κατέληξε στα αποτελέσματα αυτής της εργασίας χρηματοδοτήθηκε από Εθνικούς πόρους και από το Ευρωπαϊκό Ταμείο Περιφερειακής Ανάπτυξης στο πλαίσιο του ΕΣΠΑ 2007-2013 βάσει της Σύμβασης Συνεργατικού Έργου αριθ. ΜΙΚΡΟ2-49/Ε-ΙΙ-Γ.

Abstract The purpose of this thesis is to design an IP core which will apply the 3x3 Sobel operator [1] at the elements of an image. This is the key process of an edge detection system. The IP core was designed for use within the Xilinx EDK software. Thus it can be used in a FPGA embedded system via the graphic environment this software provides. The IP core is connected as a peripheral to the system main processor (Microblaze from Xilinx) and is connected to the system memory using a dedicated bus. That way the processor issues the processing command and is then free to do other processing. The communication with the memory makes use of the VFBC port, which is an interface to the DDR memory specifically designed for use in image / video processing applications. The data processing occurs in 4 pixel groups per processing cycle, taking advantage of FPGA parallelism and improving throughput. We also use the FPGA s fast local memory to cache data, thus relaxing memory bandwidth requirements. Each processing cycle lasts 2 system clocks and synthesis indicated maximum operating frequencies of 225MHz on a Virtex5 FPGA (LX110T). Our maximum processing rate is thus estimated to be 450MPixels/sec. The design is compact enough to fit in smaller devices, like the medium-range Spartan3E economical devices. On those it achieves operating frequencies of 100MHz and processing rates of 200MPixels/sec. The core s operation was verified on a Xilinx development board (XUPV5- LX110T) which utilises a Virtex5 series FPGA. Finally we developed a simple application to allow PC - board communication and verify the results of the processing.

Περιεχόμενα 1 Εισαγωγικά 1 1.1 Αλγόριθμοι επεξεργασίας εικόνας και FPGA........... 1 1.2 Αλγόριθμοι ανίχνευσης ακμών................... 1 1.3 Το EDK της Xilinx......................... 5 2 Σχεδιασμός του hardware 7 2.1 Θύρες επικοινωνίας......................... 8 2.1.1 Η θύρα FSB......................... 8 2.1.2 Οι θύρες VFBC....................... 8 2.2 Block απευθείας επεξεργασίας δεδομένων............. 10 2.2.1 Τμήμα επεξεργασίας - πράξεων.............. 10 2.2.2 Τμήμα cache........................ 11 2.2.3 Τμήμα ελέγχου....................... 12 2.3 Top-level block........................... 13 2.3.1 Επικοινωνία με το FSB................... 13 2.3.2 Ανάγνωση - εγγραφή μνήμης και επεξεργασία...... 13 3 Software δοκιμής του αλγόριθμου 15 3.1 Πρόγραμμα του microblaze..................... 15 3.2 Πρόγραμμα του PC......................... 17 4 Συμπεράσματα - πιθανές βελτιώσεις 20 4.1 Πλεονεκτήματα της αρχιτεκτονικής μας - επιδόσεις........ 20 4.2 Πιθανές βελτιώσεις......................... 20 5 Παράρτημα κώδικα 21 Αναφορές 61

Κατάλογος σχημάτων 1 Μέθοδοι συνέλιξης προτύπου.................... 2 2 Μια εικόνα μιας ατμομηχανής................... 3 3 Μια εικόνα μιας ατμομηχανής μετά την εφαρμογή του τελεστή Sobel 3 4 Το γραφικό περιβάλλον περιγραφής συστήματος XPS....... 5 5 Η παράλληλη επεξεργασία 4 pixels ελαττώνει τις αναγνώσεις από τη μνήμη.............................. 7 6 Χονδρικό block διάγραμμα..................... 8 7 Λέξεις ελέγχου για μεταφορές με το VFBC............ 9 8 Διαδικασία ανάγνωσης στο VFBC................. 9 9 Διαδικασία εγγραφής στο VFBC.................. 10 10 Για κάθε τετράδα pixels που υπολογίζουμε χρειαζόμαστε μέχρι 3 words από την κάθε cache..................... 11 11 Μαύρα pixels για γειτονικά των ακριανών............. 12 Κατάλογος Κώδικα 1 Πρόγραμμα microblaze που κάνει χρήση του περιφερειακού... 15 2 Πρόγραμμα python για επικοινωνία με το αναπτυξιακό FPGA.. 17 3 Ο κώδικας επεξεργασίας ενός pixel................ 21 4 Ο κώδικας επεξεργασίας μιας τετράδας pixels........... 22 5 Η υλοποίηση της εξειδικευμένης cache............... 26 6 Το τμήμα ελέγχου της επεξεργασίας................ 30 7 Το top level block του περιφερειακού............... 43 8 Περιγραφή των θυρών του περιφερειακού για το EDK...... 57

1 ΕΙΣΑΓΩΓΙΚΑ 1 1 Εισαγωγικά 1.1 Αλγόριθμοι επεξεργασίας εικόνας και FPGA Η ταχεία εξέλιξη της ψηφιακής τεχνολογίας στις εικόνες απαιτεί τη χρήση όλο και πιο περίπλοκων αλγόριθμων σε εικόνες μεγάλης ανάλυσης. Έτσι οι απαιτήσεις σε ταχύτητα ξεφεύγουν από τις δυνατότητες μιας απλής CPU. Υπάρχουν διάφορες λύσεις, η καθεμιά με τα πλεονεκτήματά και τα μειονεκτήματά της, όπως η χρήση DSP ή εξειδικευμένων κυκλωμάτων ASSP (Application Specific Standard Product). Οι πρώτοι όμως είναι ακριβοί και πάλι υστερούν απέναντι στην ταχύτητα μιας εξειδικευμένης λύσης hardware. Τα ASSP από την άλλη είναι γρήγορα αλλά είναι και αυτά ακριβά και δεν είναι καθόλου ευέλικτα, απαιτώντας επίσης μεγάλο χρόνο για ανάπτυξη. Τα τελευταία χρόνια όμως η εξέλιξη της τεχνολογίας των FPGA - στα οποία πλέον έχουν ενσωματωθεί ικανοποιητικές εσωτερικές μνήμες και hardware πολλαπλασιαστές - τα κάνει πολύ ελκυστικές λύσεις για απαιτητικές εφαρμογές επεξεργασίας εικόνας και video. Επίσης η παρουσία soft processors (επεξεργαστών που μεταφράζονται και υλοποιούνται στο υλικό του FPGA) και εργαλείων που επιτρέπουν την περιγραφή ενός ολόκληρου συστήματος (processor, memory controller, comm ports, IP cores) μέσω γραφικού περιβάλλοντος μας επιτρέπει να αναπτύξουμε γρήγορα ολόκληρα συστήματα με επεξεργαστή και εξειδικευμένα IP cores που επικοινωνούν απευθείας με τον memory controller και λοιπά περιφερειακά και εκτελούν τις απαιτητικές εργασίες χωρίς την ανάμειξη του επεξεργαστή. 1.2 Αλγόριθμοι ανίχνευσης ακμών Σε πολλές εφαρμογές χρειάζεται η επεξεργασία μιας εικόνας με σκοπό να γίνει κάποια αναγνώριση ή απαρίθμηση αντικειμένων ή κάποια μέτρηση μεγεθών. Όταν οι συνθήκες φωτισμού κατά τη λήψη της όμως δεν μπορούν να ελεγχθούν πλήρως, αυτό δυσκολεύει κατά πολύ τους αλγόριθμους επεξεργασίας. Έτσι πολλές φορές είναι πιο χρήσιμο να έχουμε την πληροφορία για τις ακμές, τα «όρια» των αντικειμένων που περιέχει η εικόνα παρά την ίδια τη τιμή της φωτεινότητάς τους. Έτσι αναπτύχθηκε μια κατηγορία αλγόριθμων επεξεργασίας εικόνας που συνήθως τροφοδοτεί τους υπόλοιπους αλγόριθμους μιας εφαρμογής, οι αλγόριθμοι ανίχνευσης ακμών. Η πλήρης διαδικασία ανίχνευσης ακμών μπορεί να χρειαστεί μέχρι τρία στάδια, ανάλογα με τις απαιτήσεις της κάθε εφαρμογής: 1. Εξομάλυνση εικόνας 2. Διαδικασία διαφόρισης

1 ΕΙΣΑΓΩΓΙΚΑ 2 Σχήμα 1: Μέθοδοι συνέλιξης προτύπου 3. Εφαρμογή threshold Το κρίσιμο (και πολλές φορές το μόνο απαραίτητο) μέρος της διαδικασίας ανίχνευσης είναι η διαφόριση. Ουσιαστικά μια ακμή σε μια εικόνα είναι μια έντονη μεταβολή στην τιμή γειτονικών pixels, δηλαδή μια μεγάλη τιμή στην κλίση. Για να πάρουμε την κλίση υπάρχουν διάφορες μέθοδοι, καθεμιά από τις οποίες προσφέρεται για διάφορες εφαρμογές. Θα ασχοληθούμε με μια κατηγορία μεθόδων, αυτή της συνέλιξης προτύπου. Σε αυτές τις τεχνικές το αποτέλεσμα παίρνεται εφαρμόζοντας έναν πίνακα - πρότυπο σε κάθε pixel της εικόνας εισόδου και τη γειτονιά του. Τα στοιχεία του πίνακα (ο οποίος είναι συνήθως τετράγωνος και το μέγεθός του περιττό) πολλαπλασιάζονται με τις τιμές της γειτονιάς του pixel εισόδου και το άθροισμά τους μας δίνει ένα pixel εξόδου. Η διαδικασία φαίνεται καλύτερα στο Σχήμα 1. Ένας πολύ απλός τελεστής για να πάρουμε την κλίση μιας εικόνας είναι ο Prewitt [1]. Στη βασική του μορφή αποτελείται από 2 πίνακες 3x3, οι οποίοι μας δίνουν το ρυθμό μεταβολής της φωτεινότητας κατά μήκος του κάθε άξονα. Επίσης καθώς λαμβάνουν υπ όψιν την πληροφορία τριών γραμμών, ενσωματώνεται και μία υποτυπώδης εξομάλυνση. Παρακάτω φαίνονται οι εξισώσεις του τελεστή. M x = M = 1 0 1 1 0 1 1 0 1, M y = M 2 x + M 2 y, θ = arctan 1 1 1 0 0 0 1 1 1 ( My Ένας ακόμα τελεστής είναι και ο Sobel [1, 2, 3]. ο οποίος αποτελείται και αυτός από 2 πίνακες (έναν για κάθε κατεύθυνση). Ο Sobel είναι βελτίωση του τελεστή Prewitt και είναι πολύ δημοφιλής, καθώς είναι απλός και δίνει αρκετά καλύτερα αποτελέσματα από τον Prewitt. Στην μορφή 3x3 οι εξισώσεις του είναι οι παρα- M x )

1 ΕΙΣΑΓΩΓΙΚΑ 3 Σχήμα 2: Μια εικόνα μιας ατμομηχανής Σχήμα 3: Μια εικόνα μιας ατμομηχανής μετά την εφαρμογή του τελεστή Sobel κάτω: G x = G = 1 0 1 2 0 2 1 0 1, G y = 1 2 1 0 0 0 1 2 1 G 2 x + G 2 y G x + G y, θ = arctan ( Gy Το κύριο πλεονέκτημα του τελεστή Sobel είναι ότι έχει πολλαπλασιασμούς μόνο με το 2, οπότε η υλοποίησή του μπορεί να γίνει ταχύτατη (μόνο προσθέσεις και αφαιρέσεις). Επίσης έχει φανεί ότι η χονδροειδής προσέγγιση της τετραγωνικής ρίζας με το άθροισμα των απόλυτων τιμών δίνει πολύ καλά αποτελέσματα στην συγκεκριμένη περίπτωση [2]. Ένα παράδειγμα εφαρμογής του τελεστή Sobel φαίνεται στα Σχήματα 2 και 3. G x )

1 ΕΙΣΑΓΩΓΙΚΑ 4 Αυτοί οι τελεστές μπορούν να παραχθούν και σε μεγαλύτερο μέγεθος, δίνοντας καλύτερα αποτελέσματα κυρίως στην ανοσία από το θόρυβο. Οι πίνακες αυτοί όμως είναι πιο πολύπλοκοι, για παράδειγμα παρακάτω φαίνονται οι πίνακες που απαρτίζουν τον 5x5 sobel. S x = 1 2 0 2 1 4 8 0 8 4 6 12 0 12 6 4 8 0 8 4 1 2 0 2 1 S =, S y = S 2 x + S 2 y 1 4 6 4 1 2 8 12 8 2 0 0 0 0 0 2 8 12 8 2 1 4 6 4 1 Όταν η εικόνα είναι μεγάλη και μια ακμή μπορεί να διανύει αρκετά pixels (η απλά η εικόνα είναι θολή) οπότε και η διαφορά της τιμής γειτονικών pixels είναι μικρή, η προσέγγιση πρώτης τάξης αποτυγχάνει να ανιχνεύσει σωστά τις ακμές. Εκεί μπορούν να χρησιμοποιηθούν τεχνικές δεύτερης τάξης συνήθως (σπάνια μεγαλύτερης) όπου από την εικόνα υπολογίζονται με πίνακες οι δεύτεροι παράγωγοι της εικόνας (G xx, G yy και G xy ) και από αυτές κατόπιν υπολογίζεται η κλίση. Ανάλογα με το είδος της εφαρμογής, εφαρμόζεται πριν από τη διαφόριση στάδιο εξομάλυνσης για ελαχιστοποίηση της επίδρασης του θορύβου στο αποτέλεσμα της διαφόρισης (έντονος θόρυβος μπορεί να προκαλέσει ανίχνευση ακμών που δεν υπάρχουν). Στην ανίχνευση ακμών Canny για την εξομάλυνση χρησιμοποιείται φίλτρο Gaussian. Αυτό το βήμα γενικά είναι απαιτητικό υπολογιστικά, οπότε σε εφαρμογές με «καθαρή» εικόνα εισόδου και μεγάλες απαιτήσεις σε ταχύτητα μπορεί να αποφευχθεί. Τέλος όταν μας ενδιαφέρουν μόνο οι πολύ έντονες ακμές της εικόνας, μπορούμε να εφαρμόσουμε ένα threshold στο αποτέλεσμα της διαφόρισης, κρατώντας μόνο τις μεγάλες τιμές της κλίσης - οι οποίες αντιστοιχούν σε πιο έντονες ακμές. Επίσης μπορεί να γίνει χρήση υστέρησης στο threshold ώστε αν εντοπιστεί ένα pixel ακμής τα γειτονικά του να είναι πιο εύκολο να αναγνωριστούν ως pixels (της ίδιας) ακμής. Έτσι μπορούμε να ανιχνεύσουμε πιο αδύνατα τμήματα κάποιων ακμών. Γενικά η δυσκολία με την εφαρμογή του threshold είναι ότι δεν μπορούμε να ορίσουμε μια τιμή για ευρεία γκάμα εικόνων χωρίς να έχουμε προβλήματα (να χάνουμε ακμές ή να αναγνωρίζουμε ψευδές ακμές). Έτσι για να πάρουμε καλά αποτελέσματα απαιτείται καλή γνώση της εφαρμογής και πληθώρα δοκιμαστικών εικόνων για λεπτομερειακή ρύθμιση της τιμής του threshold.

1 ΕΙΣΑΓΩΓΙΚΑ 5 Σχήμα 4: Το γραφικό περιβάλλον περιγραφής συστήματος XPS 1.3 Το EDK της Xilinx Το EDK [4] της Xilinx είναι ένα περιβάλλον το οποίο επιτρέπει την ανάπτυξη ολοκληρωμένων συστημάτων που χρησιμοποιούν FPGA της Xilinx, σε επίπεδο hardware και software. Σε επίπεδο hardware ο χρήστης μπορεί να προσθέσει στο σύστημα soft processors, μνήμες επί του FPGA (BRAM), ελεγκτή μνήμης DDR / DDR2-3, διάφορα περιφερειακά επικοινωνίας (UART, USB, Ethernet κ.α.), εξειδικευμένα IP cores και διαύλους συστήματος χρησιμοποιώντας γραφικό περιβάλλον (Σχήμα 4). Έτσι οι διασυνδέσεις και οι δίαυλοι μεταξύ των περιφερειακών γίνονται πολύ γρήγορα σε αντίθεση με παραδοσιακές μεθόδους HDL ή schematic. Το EDK διαθέτει λογισμικό SDK βασισμένο στο open source πακέτο Eclipse και τον compiler gcc για την ανάπτυξη του λογισμικού του συστήματος, με έτοιμους drivers σε γλώσσα C για πολλά από τα έτοιμα περιφερειακά που διαθέτονται, καθώς και για τον έλεγχο των διαφόρων διαύλων επικοινωνίας του επεξεργαστή. Σημαντικό είναι επίσης να πούμε ότι οι διευθύνσεις των περιφερειακών στο δίαυλο του επεξεργαστή (PLB) συγχρονίζονται αυτόματα με το XPS, δηλαδή προσθέτοντας, αφαιρώντας και μεταβάλλοντας περιφερειακά στο επίπεδο hardware ρυθμίζονται αυτόματα και παράμετροι / διευθύνσεις στις οποίες θα τα προσπελάσει ο επεξεργαστής Microblaze.

1 ΕΙΣΑΓΩΓΙΚΑ 6 Ο στόχος μας είναι να υλοποιήσουμε ένα IP core το οποίο θα μπορεί να ενσωματωθεί σε ένα σύστημα στο περιβάλλον EDK με γραφικό τρόπο, όπως και τα έτοιμα IP cores που παρέχονται από τη Xilinx. Η χρήση του από το software θα γίνεται με μία μόνο εντολή που θα παρέχει πληροφορίες για τη διεύθυνση μνήμης, το μέγεθος της εικόνας εισόδου και τη διεύθυνση εγγραφής του αποτελέσματος της επεξεργασίας, μετά από την έκδοση της οποίας ο επεξεργαστής θα μπορεί να είναι ελεύθερος να κάνει άλλες λειτουργίες.

2 ΣΧΕΔΙΑΣΜΟΣ ΤΟΥ HARDWARE 7 2 Σχεδιασμός του hardware Για την επίτευξη καλών επιδόσεων σχεδιάσαμε μια αρχιτεκτονική που κάνει χρήση του παραλληλισμού ο οποίος είναι διαθέσιμος στα FPGA και διάφορες άλλες δυνατότητες τους όπως τοπικές μνήμες Block RAM πολύ υψηλών επιδόσεων. Συγκεκριμένα οι υπολογισμοί γίνονται για 4 pixels ταυτόχρονα, αυξάνοντας το throughput και ταυτόχρονα ελαττώνοντας τις προσβάσεις στη μνήμη. Στο Σχήμα 5 φαίνεται ότι για τον υπολογισμό ενός pixel χρειάζεται να διαβάσουμε 8 γειτονικά pixels, ενώ για 4 γειτονικά pixels θα χρειαστούμε μόνο 14. Αυτό αντιστοιχεί σε πάνω από 50% μείωση στις προσβάσεις στη μνήμη, μαζί με το x4 στο throughput που παίρνουμε υπολογίζοντάς τα παράλληλα. Σχήμα 5: Η παράλληλη επεξεργασία 4 pixels ελαττώνει τις αναγνώσεις από τη μνήμη Καθώς για κάθε pixel χρειάζεται πληροφορία από τα pixels της προηγούμενης και της επόμενης γραμμής, αποφασίσαμε να χρησιμοποιήσουμε μια τεχνική caching 3 γραμμών. Έτσι κάθε στιγμή που διαβάζονται τα περιεχόμενα μιας γραμμής από την κυρίως μνήμη του συστήματος εγγράφονται σε μια γραμμή cache, ενώ παράλληλα στις 2 υπόλοιπες cache βρίσκονται αποθηκευμένα τα δεδομένα των δυο προηγούμενων γραμμών. Τέλος για την πρόσβαση στη μνήμη κάναμε χρήση μιας εξειδικευμένης θύρας του ελεγκτή μνήμης της Xilinx η οποία προσφέρεται ειδικά για εφαρμογές επεξεργασίας εικόνας και video. Η θύρα αυτή κάνει δυνατή την πολύ γρήγορη ανάγνωση και εγγραφή της μνήμης σε «ριπές» (burst read / write). Οι ριπές αυτές μπορούν να έχουν μέγεθος από μερικά pixels μέχρι και ολόκληρη την εικόνα (μέχρι 16MB) με μία μόνο εντολή προς τον ελεγκτή μνήμης. Ένα χονδρικό block διάγραμμα των στοιχείων της αρχιτεκτονικής μας φαίνεται στο Σχήμα 6. Τα χαρακτηριστικά της επικοινωνίας με τον επεξεργαστή και τη μνήμη και τις λεπτομέρειες της αρχιτεκτονικής τις παρουσιάζουμε παρακάτω.

2 ΣΧΕΔΙΑΣΜΟΣ ΤΟΥ HARDWARE 8 Σχήμα 6: Χονδρικό block διάγραμμα 2.1 Θύρες επικοινωνίας 2.1.1 Η θύρα FSB Οι επεξεργαστές Microblaze [5] για να επικοινωνούν με ειδικά σχεδιασμένα περιφερειακά με μεγάλη ταχύτητα διαθέτουν μέχρι 16 θύρες FSB (Fast Simplex Link). Η κάθε τέτοια θύρα είναι μονής κατεύθυνσης (ο επεξεργαστής ή το περιφερειακό είναι Master ή Slave του καναλιού και ο Master στέλνει δεδομένα) και η επικοινωνία γίνεται με μία υλοποίηση FIFO. Το FSL (όταν είναι συνδεδεμένο με τον Microblaze) έχει πλάτος λέξης 32 bit και είναι ουσιαστικά μια απευθείας σύνδεση με το pipeline του επεξεργαστή προσφέροντας γρήγορη και άμεση (low latency) επικοινωνία. Οι ιδιότητες του αυτές και το γεγονός ότι η μετάδοση των δεδομένων γίνεται μέσω FIFO (το μέγεθος μπορεί να καθοριστεί από 1word έως 8k) το καθιστούν ιδανικό για τη σύνδεση coprocessors υψηλών επιδόσεων στον επεξεργαστή. 2.1.2 Οι θύρες VFBC Ο ελεγκτής μνήμης MPMC [6] προσφέρει μέχρι 8 ports επικοινωνίας με τη μνήμη, καθεμιά από τις οποίες μπορεί να χρησιμοποιεί διαφορετικό interface και πρωτόκολλο επικοινωνίας (η ίδια τα ονομάζει PIMs - Personality Interface Modules) ανάλογα με τις ανάγκες του κάθε περιφερειακού. Ένα από αυτά τα PIMs είναι το VFBC (Video Frame Buffer Control), το οποίο είναι σχεδιασμένο για τις ανάγκες περιφερειακών επεξεργασίας εικόνας / video.

2 ΣΧΕΔΙΑΣΜΟΣ ΤΟΥ HARDWARE 9 Σχήμα 7: Λέξεις ελέγχου για μεταφορές με το VFBC Σχήμα 8: Διαδικασία ανάγνωσης στο VFBC Η επικοινωνία με αυτό γίνεται μέσω τριών FIFO (εντολών ελέγχου, εγγραφής δεδομένων και ανάγνωσης δεδομένων) ούτως ώστε η λειτουργία του να είναι ασύγχρονη και πρακτικά να μπορεί το περιφερειακό μας να χρονιστεί σε διαφορετική συχνότητα ρολογιού από το υπόλοιπο σύστημα. Η έναρξη κάθε συνδιαλλαγής (transaction) με τη μνήμη γίνεται γράφοντας στη FIFO ελέγχου 4 words των 32 bit που καθορίζουν τις παραμέτρους της (διεύθυνση έναρξης, μήκος γραμμής, απόσταση γραμμών στη μνήμη, αριθμό γραμμών και εγγραφή / ανάγνωση). Πιο αναλυτικά οι λέξεις ελέγχου φαίνονται στο Σχήμα 7. Αν η λειτουργία είναι ανάγνωσης, μετά από κάποιους κύκλους στη FIFO ανάγνωσης εμφανίζονται δεδομένα τα οποία μπορούμε να διαβάσουμε απευθείας με ταχύτητα που εξαρτάται από την ταχύτητα της μνήμης και το μέγεθος της μνήμης FIFO. Αν η ταχύτητα ανάγνωσης μας υπερβαίνει την ταχύτητα της μνήμης η FIFO θα αδειάσει και θα πρέπει να περιμένουμε να έρθουν τα επόμενα δεδομένα για να τη γεμίσουν. Σήματα για ένα παράδειγμα ανάγνωσης φαίνονται στο Σχήμα 8. Στη λειτουργία εγγραφής αντίστοιχα μπορούμε να αρχίσουμε να γράφουμε δεδομένα στη FIFO εγγραφής. Αν η ταχύτητά μας υπερβαίνει αυτή της μνήμης η FIFO προφανώς θα γεμίσει και πρέπει να περιμένουμε να εγγραφούν τα δεδομένα που υπάρχουν μέχρι να αρχίσουμε να ξαναγράφουμε. Σήματα για ένα παράδειγμα εγγραφής φαίνονται στο Σχήμα 9.

2 ΣΧΕΔΙΑΣΜΟΣ ΤΟΥ HARDWARE 10 Σχήμα 9: Διαδικασία εγγραφής στο VFBC 2.2 Block απευθείας επεξεργασίας δεδομένων Το core μας είναι χωρισμένο σε δυο μέρη: ένα που επικοινωνεί με τους διαύλους μνήμης και επεξεργαστή και ένα που κάνει την κυρίως επεξεργασία. Αυτό κάθε 2 κύκλους ρολογιού παίρνει μια τετράδα pixels εισόδου και αφού αρχίσει να λαμβάνει τη δεύτερη γραμμή αρχίζει να δίνει τα pixels του αποτελέσματος σε τετράδες, πάλι κάθε 2 κύκλους ρολογιού. Οι παράμετροι που χρειάζεται για τη λειτουργία του είναι το πλάτος γραμμής (μέχρι 2048 pixels) και ο αριθμός των γραμμών (επίσης μέχρι 2048 pixels). Τα κύρια κομμάτια που το απαρτίζουν είναι το επεξεργαστικό κομμάτι που παράγει 4 pixels εξόδου από 4 pixels εισόδου και τη γειτονιά τους, το κομμάτι που υλοποιεί τις cache 4 θυρών και το top-level block που συντονίζει τη διαδικασία και παράγει τα σήματα ελέγχου. 2.2.1 Τμήμα επεξεργασίας - πράξεων Στο Πλαίσιο Κώδικα 3, σελ. 21, φαίνεται το βασικό block επεξεργασίας, στο οποίο γίνονται οι υπολογισμοί για ένα pixel εξόδου. Χρησιμοποιούμε pipelining αφού το latency (4 κύκλοι) είναι αμελητέο για μια εικόνα των χιλιάδων pixels ενώ η συχνότητα λειτουργίας επωφελείται σημαντικά. Εσωτερικά χρησιμοποιούμε προσημασμένους αριθμούς 11bit ούτως ώστε να μη γίνει overflow. Η είσοδος είναι μη προσημασμένοι αριθμοί 8 bit. Έχουμε έναν πολλαπλασιασμό με το 2 οπότε χρειαζόμαστε 9 bit, και αν λάβουμε υπ όψιν τις προσθέσεις και τις αφαιρέσεις θέλουμε ένα δέκατο bit για τυχόν overflow και ένα ενδέκατο για το sign extension. Η έξοδος ωστόσο είναι 8 bit, οπότε χρειάζεται να κάνουμε truncation, στο οποίο χάνουμε 2 bit ακρίβειας. Στο Πλαίσιο Κώδικα 4, σελ. 22, φαίνεται το ολοκληρωμένο block επεξεργασίας για 4 pixels, το οποίο αποτελείται από 4 μονάδες επεξεργασίας 1 bit συνδεδεμένες

2 ΣΧΕΔΙΑΣΜΟΣ ΤΟΥ HARDWARE 11 Σχήμα 10: Για κάθε τετράδα pixels που υπολογίζουμε χρειαζόμαστε μέχρι 3 words από την κάθε cache παράλληλα. 2.2.2 Τμήμα cache Στο πλαίσιο κώδικα 5, σελ. 26, φαίνεται η υλοποίηση της εξειδικευμένης cache που χρησιμοποιούμε. Τα δεδομένα αποθηκεύονται σε λέξεις των 32 bit (4 pixels). Η cache αυτή πρέπει να έχει δυνατότητα σε κάθε κύκλο λειτουργίας να αποθηκεύει 4 pixels και ταυτόχρονα να διαβάζει 6, όπως φαίνεται στο Σχήμα 5. Λόγω της στοίχισης των pixels σε λέξεις των 4, αυτό θα πει ότι πρέπει να μπορούμε να διαβάσουμε μέχρι 3 λέξεις σε έναν κύκλο λειτουργίας. Αυτό φαίνεται καλύτερα στο Σχήμα 10. Τα FPGA μας παρέχουν ορισμένους τύπους μνήμης που μπορούμε να χρησιμοποιήσουμε. Ο πιο εξελιγμένος από αυτές είναι ο true dual-port BRAM. Σε μία τέτοια μνήμη μπορούμε να έχουμε προσπέλαση (ανάγνωσης ή εγγραφής) σε δυο διαφορετικές διευθύνσεις της μνήμης ταυτόχρονα, στον ίδιο κύκλο ρολογιού. Η ταυτόχρονη εγγραφή μιας λέξης και η ανάγνωση τριών με χρήση μνημών true dual-port BRAM μπορεί να γίνει με 2 τρόπους ανάλογα με τη διαθεσιμότητά τους. Ο ένας τρόπος είναι να χρησιμοποιήσουμε 3 BRAM ανά γραμμή εικόνας, οπότε σε κάθε κύκλο (ταυτόχρονα) να διαβάζουμε από διαφορετική διεύθυνση από την καθεμία και να γράφουμε τη λέξη εισόδου στην ίδια διεύθυνση και στις τρεις μνήμες (για να παραμένουν τα δεδομένα τους συγχρονισμένα). Ο άλλος τρόπος είναι να χρησιμοποιήσουμε μόνο μία BRAM ανά γραμμή, χωρίζοντας όμως τον κύκλο λειτουργίας σε δυο κύκλους ρολογιού. Στον πρώτο κύκλο θα γράφεται η λέξη εισόδου και θα διαβάζεται μια λέξη εξόδου, και στον δεύτερο κύκλο θα διαβάζονται άλλες 2 λέξεις εξόδου και θα εξάγεται το αποτέλεσμα. Εμείς αποφασίσαμε να χρησιμοποιήσουμε τον δεύτερο τρόπο. Αυτός αν και έχει θεωρητικά το μισό throughput του άλλου και είναι πιο δύσκολος στην υλοποί-

2 ΣΧΕΔΙΑΣΜΟΣ ΤΟΥ HARDWARE 12 Σχήμα 11: Μαύρα pixels για γειτονικά των ακριανών ηση, επιτρέπει στο core να χωρέσει και σε μικρότερα και πιο οικονομικά FPGA όπως αυτά της σειράς Spartan 3E. Από την άλλη όμως και στα πιο μεγάλα FPGA που θα ταίριαζε καλύτερα ο πρώτος τρόπος (δεν θα περιοριζόμασταν από τον αριθμό διαθέσιμων BRAM) το throughput πιθανότατα θα περιοριζόταν από το bandwidth με τη μνήμη (στα 200MHz θα χρειαζόμασταν 800MB/s για ανάγνωση και άλλα 800MB/s για εγγραφή). Έτσι χάριν ευελιξίας διαλέξαμε να χρησιμοποιήσουμε αυτή τη μέθοδο. 2.2.3 Τμήμα ελέγχου Στο Πλαίσιο Κώδικα 6, σελ. 30, φαίνεται το τμήμα που ελέγχει τη διαδικασία υπολογισμού και caching και παράγει τα σήματα ελέγχου και επικοινωνίας με το υπόλοιπο. Η ροή των δεδομένων έχει ως εξής: Τα δεδομένα διαβάζονται από τη μνήμη στις 3 cache, και από τις cache πηγαίνουν στο block επεξεργασίας για να παραχθεί η έξοδος. Επίσης για τα pixels που βρίσκονται στις ακμές και τις γωνίες της εικόνας εισόδου - π.χ. για το 1ο pixel της εικόνας που δεν έχει γειτονικά pixels πάνω και αριστερά του - χρησιμοποιούμε μαύρο για τα pixels που δεν υπάρχουν (Σχήμα 11). Η διαδικασία της επεξεργασίας μπορεί να εξηγηθεί καλύτερα με την περιγραφή της για τις 4-5 πρώτες γραμμές. Οι γραμμές της εικόνας εισόδου θα συμβολιστούν με I1, I2, I3 κ.ο.κ., οι γραμμές cache με C1, C2, C3, οι γραμμές εξόδου με O1, O2, O3 και η εικονική μαύρη γραμμή (πριν την πρώτη γραμμή εισόδου) με _. Αρχικά η I1 γράφεται στην C1. Κατόπιν η I2 αρχίζει να γράφεται στην C2 και παράλληλα (ξεκινάει μετά την πρώτη εγγραφή) υπολογίζεται η O1 (με χρήση των _-C1-C2). Ύστερα η Ι3 γράφεται στην C3 και υπολογίζεται η O2 (από τις C1-C2- C3). Η Ι4 γράφεται στην C1 (τα παλιά της περιεχόμενα δεν χρειάζονται πλέον) και ταυτόχρονα υπολογίζεται η O3 (από τις C2-C3-C1). Στη συνέχεια η Ι5 γράφεται στην C2 και υπολογίζεται η Ο4 (από τις C3-C1-C2). Η διαδικασία συνεχίζεται μέχρι να φτάσουμε στην τελευταία γραμμή.

2 ΣΧΕΔΙΑΣΜΟΣ ΤΟΥ HARDWARE 13 2.3 Top-level block Το top-level block του περιφερειακού αποτελείται από 2 state machines, μία για την επικοινωνία με το δίαυλο FSB και μία που είναι υπεύθυνη για την ανάγνωση και εγγραφή από τη μνήμη και την επεξεργασία. Να σημειώσουμε πως οι 2 state machines θα μπορούσαν να συγχωνευθούν εύκολα, αλλά αυτό δεν έγινε για να αφήσουμε τη δυνατότητα στο μέρος της επεξεργασίας να δουλεύει με διαφορετικό (πιο γρήγορο) χρονισμό από το υπόλοιπο σύστημα. 2.3.1 Επικοινωνία με το FSB Από τον επεξεργαστή περιμένουμε 5 παραμέτρους για τη λειτουργία του περιφερειακού. Διεύθυνση πηγαίας εικόνας Διεύθυνση αποθήκευσης αποτελέσματος Πλάτος γραμμής Αριθμός γραμμών Συνολικός αριθμός pixels Τον αριθμό pixels τον παίρνουμε από τον επεξεργαστή καθώς ένας πολλαπλασιασμός σε ολόκληρη την εικόνα δεν επηρεάζει την απόδοση, οπότε το να δεσμεύαμε hardware πολλαπλασιαστή θα ήταν ουσιαστικά σπατάλη χώρου. Αφού αναγνωστούν οι 5 αυτές τιμές από το δίαυλο, ενεργοποιούμε ένα σήμα start που ενεργοποιεί τη state machine επεξεργασίας, η οποία όταν τελειώσει στέλνει με τη σειρά της ένα σήμα finished. Μόλις το λάβουμε, δίνουμε ένα αποτέλεσμα στον επεξεργαστή και επιστρέφουμε στο idle state (κατάσταση αναμονής). Το αποτέλεσμα που στέλνουμε στον επεξεργαστή είναι δεδομένο και δεν περιέχει χρήσιμες πληροφορίες εκτός από το ότι έληξε η λειτουργία, αφού δεν ενσωματώσαμε κάποιο υλικό ελέγχου σφαλμάτων στο περιφερειακό μας. 2.3.2 Ανάγνωση - εγγραφή μνήμης και επεξεργασία Αυτό είναι το κύριο μέρος του top level module του περιφερειακού μας, καθώς εδώ γίνεται όλη η επικοινωνία με το δίαυλο VFBC της μνήμης και ο συντονισμός της επεξεργασίας. Αρχικά στέλνονται οι εντολές στα VFBC ανάγνωσης και εγγραφής. Μετά περιμένουμε να εμφανιστούν δεδομένα στη FIFO ανάγνωσης, αυτό διαρκεί μερικές δεκάδες κύκλους ρολογιού. Κατόπιν περνάμε τα δεδομένα στο block επεξεργασίας

2 ΣΧΕΔΙΑΣΜΟΣ ΤΟΥ HARDWARE 14 και φροντίζουμε η ανάγνωση να γίνεται κάθε δυο κύκλους ρολογιού αφού αυτός είναι ο ρυθμός επεξεργασίας των δεδομένων. Σε κάθε ανάγνωση ελέγχουμε αν υπάρχουν αρκετά δεδομένα στη FIFO ανάγνωσης, καθώς αν διαβάζουμε πιο γρήγορα από τις δυνατότητες της μνήμης κάποια στιγμή θα αδειάσει. Αν συμβεί αυτό «παγώνουμε» το block επεξεργασίας με ένα σήμα και περιμένουμε να ξαναεμφανιστούν δεδομένα για να συνεχίσουμε (εκτός και αν δεν εμφανιστούν σε 255 κύκλους, οπότε στέλνεται κατευθείαν το σήμα finished). Επίσης σε κάθε επιτυχημένη ανάγνωση αυξάνουμε ένα μετρητή, και όταν αυτός γίνει ίσος με τον αριθμό των pixels της εικόνας δια 4 (αφού κάθε ανάγνωση αντιστοιχεί σε λέξη 4 pixels) η διαδικασία ανάγνωσης σταματάει. Εκεί περιμένουμε να πάρουμε το σήμα από το block επεξεργασίας ότι η διαδικασία τελείωσε και ότι έχει παραχθεί το τελευταίο pixel, στέλνουμε στην άλλη state machine το σήμα finished και επιστρέφουμε στην κατάσταση idle.

3 SOFTWARE ΔΟΚΙΜΗΣ ΤΟΥ ΑΛΓΟΡΙΘΜΟΥ 15 3 Software δοκιμής του αλγόριθμου Για την επιβεβαίωση της ορθής λειτουργίας του περιφερειακού, αναπτύξαμε μια μικρή εφαρμογή. Αυτή αποτελείται από ένα πρόγραμμα που τρέχει στον Microblaze και ένα που τρέχει σε PC. Το αναπτυξιακό επικοινωνεί με ένα PC για να λάβει μια εικόνα μέσω σειριακής θύρας (που διαβάζεται από αρχείο jpeg), την αποθηκεύει στην μνήμη DDR, χρησιμοποιεί το περιφερειακό στην εικόνα αυτή και τέλος στέλνει το αποτέλεσμα της επεξεργασίας πίσω στο PC όπου και αποθηκεύει την εικόνα του αποτελέσματος. 3.1 Πρόγραμμα του microblaze Το απλό αυτό πρόγραμμα αρχικά λαμβάνει τις παραμέτρους της εικόνας από τη σειριακή. Εδώ μπορούμε να σημειώσουμε τον εύκολο τρόπο χρήσης της σειριακής, κάνοντας χρήση των drivers που μας παρέχει το EDK για το περιφερειακό επικοινωνίας. Κατόπιν λαμβάνοντας τα pixels της εικόνας τα γράφει στη μνήμη DDR. Πάλι μπορούμε να τονίσουμε το ρόλο του EDK στην ευκολία ανάπτυξης του προγράμματος, καθώς η διεύθυνση της DDR στο χώρο διευθύνσεων του επεξεργαστή καθορίζεται στο στάδιο όπου ορίζουμε το hardware, και εδώ τη χρησιμοποιούμε απευθείας. Κατόπιν δίνουμε δίνει τις παραμέτρους της εικόνας στο περιφερειακό χρησιμοποιώντας την εντολή putfsl που γράφει στο δίαυλο FSL, και με την εντολή getfsl περιμένουμε αυτό να τελειώσει τη λειτουργία του. Τέλος το πρόγραμμα επιστρέφει μέσω της σειριακής τα pixels της εικόνας - αποτελέσματος. Ο κώδικας του προγράμματος φαίνεται στο Πλαίσιο Κώδικα 1 στη σελ. 15. Πλαίσιο Κώδικα 1: Πρόγραμμα microblaze που κάνει χρήση του περιφερειακού 1 / / Located i n : m i c r o b l a z e _ 0 / i n c l u d e / x p a r a m e t e r s. h # i n c l u d e x p a r a m e t e r s. h # i n c l u d e m b _ i n t e r f a c e. h # i n c l u d e s t d i o. h # i n c l u d e x u a r t l i t e _ l. h # i n c l u d e x u t i l. h / / ==================================================== i n t main ( void ) { 11 unsigned i n t p i x ; i n t i ;

3 SOFTWARE ΔΟΚΙΜΗΣ ΤΟΥ ΑΛΓΟΡΙΘΜΟΥ 16 while ( 1 ) { unsigned i n t dimx, dimy, dims ; dimx = 256* XUartLite_RecvByte ( XPAR_UARTLITE_0_BASEADDR) ; dimx += XUartLite_RecvByte (XPAR_UARTLITE_0_BASEADDR) ; dimy = 256* XUartLite_RecvByte ( XPAR_UARTLITE_0_BASEADDR) ; 21 dimy += XUartLite_RecvByte (XPAR_UARTLITE_0_BASEADDR) ; dims = dimx*dimy ; Xuint32 * p ; p = ( Xuint32 *)XPAR_DDR2_SDRAM_MPMC_BASEADDR; f o r ( i = 0 ; i < dims / 4 ; i ++) { p i x = XUartLite_RecvByte (XPAR_UARTLITE_0_BASEADDR) ; p i x += XUartLite_RecvByte (XPAR_UARTLITE_0_BASEADDR ) << 8 ; p i x += XUartLite_RecvByte (XPAR_UARTLITE_0_BASEADDR ) << 1 6 ; p i x += XUartLite_RecvByte (XPAR_UARTLITE_0_BASEADDR ) << 2 4 ; 31 *p = p i x ; p = p +1; } unsigned i n t s o b e l _ r e s = 0 ; p u t f s l (XPAR_DDR2_SDRAM_MPMC_BASEADDR, 0) ; p u t f s l (XPAR_DDR2_SDRAM_MPMC_BASEADDR, 0) ; p u t f s l ( dimx, 0) ; p u t f s l ( dims / 4, 0) ; p u t f s l ( dimy, 0) ; 41 g e t f s l ( s o b e l _ r e s, 0 ) ; p = ( Xuint32 *) (XPAR_DDR2_SDRAM_MPMC_BASEADDR) ; f o r ( i = 0 ; i < dims / 4 ; i ++) { p i x = *p ;

3 SOFTWARE ΔΟΚΙΜΗΣ ΤΟΥ ΑΛΓΟΡΙΘΜΟΥ 17 51 } x i l _ p r i n t f ( %c, ( p i x&0x000000ff ) ) ; x i l _ p r i n t f ( %c, ( p i x&0x0000ff00 ) > >8) ; x i l _ p r i n t f ( %c, ( p i x&0x00ff0000 ) > >16) ; x i l _ p r i n t f ( %c, ( p i x&0xff000000 ) > >24) ; p = p +1; } } return 0 ; 3.2 Πρόγραμμα του PC Για την επικοινωνία του PC με το αναπτυξιακό FPGA αναπτύξαμε ένα απλό πρόγραμμα σε python. Το πρόγραμμα αυτό μπορεί να εκτελεστεί χωρίς αλλαγές σε διάφορα λειτουργικά συστήματα (όπως windows, linux, macintosh, solaris κ.α.) αρκεί να υπάρχουν εγκατεστημένες η Python (>2.2) και η βιβλιοθήκη PIL (Python Imaging Library). Αρχικά το πρόγραμμα διαβάζει μια εικόνα και τα στοιχεία της από το σκληρό δίσκο (η εικόνα μπορεί να είναι πολλών συχνά χρησιμοποιούμενων τύπων που υποστηρίζονται από το PIL). Κατόπιν τη μετατρέπει σε grayscale και τη στέλνει μέσω σειριακής θύρας στο αναπτυξιακό. Στη συνέχεια περιμένει μέχρι να λάβει τον αριθμό των pixels που αντιστοιχεί στις διαστάσεις της εικόνας εισόδου και με αυτά δημιουργεί μια καινούρια εικόνα που αποθηκεύει σε άλλο αρχείο στο δίσκο. Πρέπει να τονίσουμε ότι το πρόγραμμα αυτό έγινε για να δοκιμάσουμε τη λειτουργία του περιφερειακού και ως εκ τούτου μερικές παράμετροι (όπως το όνομα των αρχείων in/out και η σειριακή θύρα) είναι ενσωματωμένοι στον κώδικα και δε δίνονται σε μενού από τον χρήστη. Ο κώδικας του προγράμματος φαίνεται στο Πλαίσιο Κώδικα 2 στη σελ. 17. Πλαίσιο Κώδικα 2: Πρόγραμμα python για επικοινωνία με το αναπτυξιακό FPGA #! / u s r / b i n / p y t h o n # * c o d i n g : u t f 8 * 4 import s e r i a l import s y s import s e l e c t import os import t t y

3 SOFTWARE ΔΟΚΙΜΗΣ ΤΟΥ ΑΛΓΟΡΙΘΜΟΥ 18 import t e r m i o s import s t r i n g import b i n a s c i i from PIL import Image 14 def i s D a t a ( ) : return s e l e c t. s e l e c t ( [ s y s. s t d i n ], [ ], [ ], 0) == ( [ s y s. s t d i n ], [ ], [ ] ) def main ( ) : o l d _ s e t t i n g s = t e r m i o s. t c g e t a t t r ( s y s. s t d i n ) t r y : t t y. s e t c b r e a k ( s y s. s t d i n. f i l e n o ( ) ) s e r = s e r i a l. S e r i a l ( 24 p o r t = / dev / ttyusb0, b a u d r a t e =115200, t i m e o u t =2) s e r. open ( ) s e r. isopen ( ) while 1 : o u t = i f s e r. i n W a i t i n g ( ) > 0 : 34 o u t = s e r. r e a d ( 1 ) s y s. s t d o u t. w r i t e ( o u t ) i f i s D a t a ( ) : c = s y s. s t d i n. r e a d ( 1 ) i f c == q : break i f c == s : im = Image. open ( i n p u t. j p g ) im = im. c o n v e r t ( L ) 44 i f os. p a t h. e x i s t s ( o u t p u t. bmp ) : os. remove ( o u t p u t. bmp ) s e r. w r i t e ( c h r ( im. s i z e [ 0 ] / 2 5 6 ) ) s e r. w r i t e ( c h r ( im. s i z e [0]%256) )

3 SOFTWARE ΔΟΚΙΜΗΣ ΤΟΥ ΑΛΓΟΡΙΘΜΟΥ 19 s e r. w r i t e ( c h r ( im. s i z e [ 1 ] / 2 5 6 ) ) s e r. w r i t e ( c h r ( im. s i z e [1]%256) ) s y s. s t d i n. r e a d ( 1 ) i =0 f o r p i x e l in l i s t ( im. g e t d a t a ( ) ) : s e r. w r i t e ( c h r ( p i x e l ) ) 54 i +=1 p r i n t P i x e l s s e n t t o d e v i c e outim = Image. new ( im. mode, im. s i z e ) outx = 0 outy = 0 p i x e l s r e a d = 0 while p i x e l s r e a d < im. s i z e [ 0 ] * im. s i z e [ 1 ] : while s e r. i n W a i t i n g ( ) > 0 : p i x e l = s e r. r e a d ( 1 ) outim. p u t p i x e l ( ( outx, o uty ), ord ( p i x e l ) ) 64 outx = o utx + 1 i f ( outx > im. s i z e [ 0 ] 1) : outx = 0 outy = o uty + 1 p i x e l s r e a d = p i x e l s r e a d + 1 i f p i x e l s r e a d == im. s i z e [ 0 ] * im. s i z e [ 1 ] : break outim. s ave ( o u t p u t. bmp ) f i n a l l y : 74 s e r. c l o s e ( ) t e r m i o s. t c s e t a t t r ( s y s. s t d i n, o l d _ s e t t i n g s ) t e r m i o s. TCSADRAIN, main ( )

4 ΣΥΜΠΕΡΑΣΜΑΤΑ - ΠΙΘΑΝΕΣ ΒΕΛΤΙΩΣΕΙΣ 20 4 Συμπεράσματα - πιθανές βελτιώσεις 4.1 Πλεονεκτήματα της αρχιτεκτονικής μας - επιδόσεις Μπορούμε να συγκρίνουμε τις επιδόσεις του περιφερειακού μας με τις επιδόσεις που θα είχε ο microblaze αν εφάρμοζε απευθείας τον τελεστή sobel σε μία εικόνα. Ο επεξεργαστής για να τις πράξεις που απαιτεί ο υπολογισμός ενός pixel εξόδου θα έκανε περίπου 15 κύκλους. Για να διαβάσει τα pixels εισόδου θα έκανε 6 η 12 κύκλους (αν τα διαβάσει σαν λέξη 32 bit και ανάλογα με τη στοίχιση) και για να τα γράψει άλλους 2, άρα χονδρικά θα έκανε κάπου 26 κύκλους ανά pixel. Αυτό έχοντας υποθέσει ότι μια τυχαία πρόσβαση στη μνήμη DDR χρειάζεται δυο κύκλους ρολογιού ενώ στην πραγματικότητα είναι πολύ πιο αργή. Το περιφερειακό μας ολοκληρώνει τη διαδικασία για 4 pixels σε 2 κύκλους, άρα είναι περίπου 50 φορές γρηγορότερο (στην πραγματικότητα ο microblaze μόνος του είναι ακόμα πιο αργός λόγω της πρόσβασης στη μνήμη). Σε ένα Spartan3E XCS500E (το οποίο θεωρείται μικρό και οικονομικό FPGA) το περιφερειακό καταλαμβάνει το 25% του χώρου της συσκευής και μπορεί να δουλέψει σε συχνότητες έως 100MHz, δίνοντάς μας ένα ρυθμό επεξεργασίας στα 200MPixels/sec. Σε ένα μεγαλύτερο FPGA (Virtex5 LX110T) καταλαμβάνει μόλις 2% του διαθέσιμου χώρου και οι συχνότητα λειτουργίας φτάνει τα 225MHz, με ρυθμό επεξεργασίας στα 450MPixels/sec. 4.2 Πιθανές βελτιώσεις Η κύρια βελτίωση που μπορούμε να κάνουμε είναι να βελτιώσουμε την αξιοπιστία της επικοινωνίας με τη μνήμη και να στέλνουμε σήμα σφάλματος στον επεξεργαστή αν υπάρξει τελικά πρόβλημα στην εγγραφή ή στην ανάγνωση. Πρόβλημα μπορεί να προκύψει όταν π.χ. τη μνήμη χρησιμοποιούν έντονα και άλλα περιφερειακά ή ο επεξεργαστής και τους έχει δοθεί μεγαλύτερη προτεραιότητα, θα υπάρχει μεγάλη καθυστέρηση στην μεταφορά των δεδομένων (η FIFO ανάγνωσης θα παραμένει άδεια για μεγάλα διαστήματα και ανάλογα η FIFO εγγραφής θα μένει γεμάτη). Σε αυτή την περίπτωση μπορούμε να επιστρέψουμε ένα σήμα προειδοποίησης στον επεξεργαστή εν μέσω επεξεργασίας ώστε να ρυθμίσει τις ενέργειές του ή των άλλων περιφερειακών, ή και σήμα λάθους διακόπτοντας εντελώς την επεξεργασία για να τελειώσουν οι άλλες τυχόν απαιτητικές διεργασίες. Επίσης για εξαιρετικά απαιτητικές εφαρμογές θα μπορούσαμε να αυξήσουμε το δίαυλο με τη μνήμη στα 64 bit και να επεξεργαζόμαστε 8 pixels ταυτόχρονα. Για να έχουμε όφελος από αυτό όμως χρειάζεται να έχουμε εξαιρετικά γρήγορο interface με τη μνήμη καθώς το throughput θα ήταν σχεδόν διπλάσιο και θα περιοριζόμασταν από το bandwidth.

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 21 5 Παράρτημα κώδικα Πλαίσιο Κώδικα 3: Ο κώδικας επεξεργασίας ενός pixel l i b r a r y IEEE ; 2 use IEEE. STD_LOGIC_1164.ALL; use IEEE. STD_LOGIC_ARITH.ALL; u s e IEEE. STD_LOGIC_UNSIGNED. ALL; e n t i t y s o b e l _ 1 p i s Port ( pix11 : in STD_LOGIC_VECTOR (7 downto 0) ; pix12 : in STD_LOGIC_VECTOR (7 downto 0) ; pix13 : in STD_LOGIC_VECTOR (7 downto 0) ; pix21 : in STD_LOGIC_VECTOR (7 downto 0) ; pix23 : in STD_LOGIC_VECTOR (7 downto 0) ; 12 pix31 : in STD_LOGIC_VECTOR (7 downto 0) ; pix32 : in STD_LOGIC_VECTOR (7 downto 0) ; pix33 : in STD_LOGIC_VECTOR (7 downto 0) ; p i x o u t 2 2 : out STD_LOGIC_VECTOR (7 downto 0) ; r s t : in s t d _ l o g i c ; s t a l l : in s t d _ l o g i c ; c l k : in STD_LOGIC ) ; end s o b e l _ 1 p ; a r c h i t e c t u r e B e h a v i o r a l of s o b e l _ 1 p i s 22 s i g n a l outxabs, o u t y a b s : s i g n e d (10 downto 0) ; s i g n a l outxs, o u t y s : s i g n e d (10 downto 0) ; s i g n a l outxsp, o u t y s p : s i g n e d (10 downto 0) ; s i g n a l outxsn, o u t y s n : s i g n e d (10 downto 0) ; begin p r o c e s s ( clk, r s t ) v a r i a b l e p i x o u t _ t : s t d _ l o g i c _ v e c t o r (10 downto 0) ; begin i f ( r s t = 1 ) then 32 o u t x s p <= ( o t h e r s => 0 ) ; o u t x s n <= ( o t h e r s => 0 ) ; o u t y s p <= ( o t h e r s => 0 ) ; o u t y s n <= ( o t h e r s => 0 ) ;

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 22 o u t x s <= ( o t h e r s => 0 ) ; o u t y s <= ( o t h e r s => 0 ) ; outxabs <= ( o t h e r s => 0 ) ; outyabs <= ( o t h e r s => 0 ) ; p i x o u t 2 2 <= ( o t h e r s => 0 ) ; 42 e l s i f ( r i s i n g _ e d g e ( c l k ) ) then i f ( s t a l l = 0 ) then o u t x s p <= s i g n e d ( 000 & pix11 ) + s i g n e d ( 00 & pix21 & 0 ) + s i g n e d ( 000 & pix31 ) ; o u t x s n <= s i g n e d ( 000 & pix13 ) + s i g n e d ( 00 & pix23 & 0 ) + s i g n e d ( 000 & pix33 ) ; o u t y s p <= s i g n e d ( 000 & pix11 ) + s i g n e d ( 00 & pix12 & 0 ) + s i g n e d ( 000 & pix13 ) ; o u t y s n <= s i g n e d ( 000 & pix31 ) + s i g n e d ( 00 & pix32 & 0 ) + s i g n e d ( 000 & pix33 ) ; o u t x s <= o u t x s p o u t x s n ; o u t y s <= o u t y s p o u t y s n ; 52 o u t x a b s <= abs ( o u t x s ) ; o u t y a b s <= abs ( o u t y s ) ; p i x o u t _ t := s t d _ l o g i c _ v e c t o r ( o u t x a b s ) + s t d _ l o g i c _ v e c t o r ( o u t y a b s ) ; i f ( p i x o u t _ t ( 1 0 ) = 0 ) then p i x o u t 2 2 <= p i x o u t _ t (9 downto 2) ; p i x o u t 2 2 <= ( o t h e r s => 1 ) ; 62 end p r o c e s s ; end B e h a v i o r a l ; Πλαίσιο Κώδικα 4: Ο κώδικας επεξεργασίας μιας τετράδας pixels l i b r a r y IEEE ; use IEEE. STD_LOGIC_1164.ALL;

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 23 use IEEE. STD_LOGIC_ARITH.ALL; 4 u s e IEEE. STD_LOGIC_UNSIGNED. ALL; e n t i t y s o b e l _ 4 p i s Port ( pix11 : in STD_LOGIC_VECTOR (7 downto 0) ; pix12 : in STD_LOGIC_VECTOR (7 downto 0) ; pix13 : in STD_LOGIC_VECTOR (7 downto 0) ; pix14 : in STD_LOGIC_VECTOR (7 downto 0) ; pix15 : in STD_LOGIC_VECTOR (7 downto 0) ; pix16 : in STD_LOGIC_VECTOR (7 downto 0) ; pix21 : in STD_LOGIC_VECTOR (7 downto 0) ; 14 pix22 : in STD_LOGIC_VECTOR (7 downto 0) ; pix23 : in STD_LOGIC_VECTOR (7 downto 0) ; pix24 : in STD_LOGIC_VECTOR (7 downto 0) ; pix25 : in STD_LOGIC_VECTOR (7 downto 0) ; pix26 : in STD_LOGIC_VECTOR (7 downto 0) ; pix31 : in STD_LOGIC_VECTOR (7 downto 0) ; pix32 : in STD_LOGIC_VECTOR (7 downto 0) ; pix33 : in STD_LOGIC_VECTOR (7 downto 0) ; pix34 : in STD_LOGIC_VECTOR (7 downto 0) ; pix35 : in STD_LOGIC_VECTOR (7 downto 0) ; 24 pix36 : in STD_LOGIC_VECTOR (7 downto 0) ; p i x o u t 2 2 : out STD_LOGIC_VECTOR (7 downto 0) ; p i x o u t 2 3 : out STD_LOGIC_VECTOR (7 downto 0) ; p i x o u t 2 4 : out STD_LOGIC_VECTOR (7 downto 0) ; p i x o u t 2 5 : out STD_LOGIC_VECTOR (7 downto 0) ; r s t : in s t d _ l o g i c ; s t a l l : in s t d _ l o g i c ; c l k : in STD_LOGIC ) ; end s o b e l _ 4 p ; 34 a r c h i t e c t u r e B e h a v i o r a l of s o b e l _ 4 p i s component s o b e l _ 1 p i s Port ( pix11 : in STD_LOGIC_VECTOR (7 downto 0) ; pix12 : in STD_LOGIC_VECTOR (7 downto 0) ;

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 24 pix13 : in STD_LOGIC_VECTOR (7 downto 0) ; pix21 : in STD_LOGIC_VECTOR (7 downto 0) ; pix23 : in STD_LOGIC_VECTOR (7 downto 0) ; pix31 : in STD_LOGIC_VECTOR (7 downto 0) ; pix32 : in STD_LOGIC_VECTOR (7 downto 0) ; 44 pix33 : in STD_LOGIC_VECTOR (7 downto 0) ; p i x o u t 2 2 : out STD_LOGIC_VECTOR (7 downto 0) ; r s t : in s t d _ l o g i c ; s t a l l : in s t d _ l o g i c ; c l k : in STD_LOGIC ) ; end component ; begin s o b e l 2 2 : s o b e l _ 1 p 54 port map( pix11 => pix11, pix12 => pix12, pix13 => pix13, pix21 => pix21, pix23 => pix23, pix31 => pix31, pix32 => pix32, pix33 => pix33, p i x o u t 2 2 => pixout22, 64 s t a l l => s t a l l, c l k => clk, r s t => r s t ) ; s o b e l 2 3 : s o b e l _ 1 p port map( pix11 => pix12, pix12 => pix13, pix13 => pix14, 74 pix21 => pix22, pix23 => pix24, pix31 => pix32, pix32 => pix33,

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 25 pix33 => pix34, p i x o u t 2 2 => pixout23, s t a l l => s t a l l, c l k => clk, r s t => r s t ) ; 84 s o b e l 2 4 : s o b e l _ 1 p port map( pix11 => pix13, pix12 => pix14, pix13 => pix15, pix21 => pix23, pix23 => pix25, pix31 => pix33, pix32 => pix34, 94 pix33 => pix35, p i x o u t 2 2 => pixout24, s t a l l => s t a l l, c l k => clk, r s t => r s t ) ; s o b e l 2 5 : s o b e l _ 1 p port map( pix11 => pix14, 104 pix12 => pix15, pix13 => pix16, pix21 => pix24, pix23 => pix26, pix31 => pix34, pix32 => pix35, pix33 => pix36, p i x o u t 2 2 => pixout25, s t a l l => s t a l l, c l k => clk, 114 r s t => r s t ) ; end B e h a v i o r a l ;

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 26 Πλαίσιο Κώδικα 5: Η υλοποίηση της εξειδικευμένης cache l i b r a r y IEEE ; 2 use IEEE. STD_LOGIC_1164.ALL; use IEEE. STD_LOGIC_ARITH.ALL; u s e IEEE. STD_LOGIC_UNSIGNED. ALL; e n t i t y linemem i s Port ( c l k : in STD_LOGIC ; r s t : in STD_LOGIC ; linew : s t d _ l o g i c _ v e c t o r (10 downto 0) ; w r i t e _ a d d r : in STD_LOGIC_VECTOR (8 downto 0) ; d a t a _ i n : in STD_LOGIC_VECTOR (31 downto 0) ; 12 en : in s t d _ l o g i c ; we : i n STD_LOGIC ; s t a l l : in s t d _ l o g i c ; r e a d _ a d d r : in STD_LOGIC_VECTOR (8 downto 0) ; d a t a _ o u t : out STD_LOGIC_VECTOR (47 downto 0) ; v a l i d _ o u t p u t : out s t d _ l o g i c ; o u t _ a d d r : out s t d _ l o g i c _ v e c t o r (8 downto 0) ) ; end linemem ; a r c h i t e c t u r e B e h a v i o r a l of linemem i s 22 component bram i s port ( c l k a : IN s t d _ l o g i c ; d i n a : IN std_logic_vector (31 downto 0) ; a d d r a : IN std_logic_vector (8 downto 0) ; wea : IN std_logic_vector (0 downto 0) ; d o u t a : OUT std_logic_vector (31 downto 0) ; c l k b : IN s t d _ l o g i c ; dinb : IN std_logic_vector (31 downto 0) ; 32 addrb : IN std_logic_vector (8 downto 0) ; web : IN std_logic_vector (0 downto 0) ; doutb : OUT std_logic_vector (31 downto 0) ) ; end component ; s i g n a l mem_we : s t d _ l o g i c ;

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 27 42 s i g n a l s i g _ o u t _ a, s i g _ o u t _ b, d a t a _ a : s t d _ l o g i c _ v e c t o r (31 downto 0) ; s i g n a l s i g _ a d d r _ a, s i g _ a d d r _ b : s t d _ l o g i c _ v e c t o r (8 downto 0) ; s i g n a l s t a t e : s t d _ l o g i c ; s i g n a l t e m p _ r e s : s t d _ l o g i c _ v e c t o r (31 downto 0) ; s i g n a l p r e v _ r e a d _ a d d r, r e a d _ a d d r _ t : s t d _ l o g i c _ v e c t o r (8 downto 0) ; s i g n a l r e a d _ a d d r _ i, p r e v _ r e a d _ a d d r _ i : s t d _ l o g i c _ v e c t o r (8 downto 0) ; s i g n a l temp1, temp2, temp3 : s t d _ l o g i c _ v e c t o r (8 downto 0) ; s i g n a l linewd4m1 : s t d _ l o g i c _ v e c t o r (8 downto 0) ; begin linewd4m1 <= linew (10 downto 2) 1 ; 52 mem: bram port map ( c l k a => clk, d i n a => data_a, a d d r a => s i g _ a d d r _ a, wea ( 0 ) => mem_we, d o u t a => s i g _ o u t _ a, c l k b => clk, dinb => ( o t h e r s => 0 ), 62 addrb => s i g _ a d d r _ b, web ( 0 ) => 0, doutb => s i g _ o u t _ b ) ; p r o c e s s ( clk, r s t ) begin i f ( r s t = 1 ) then s t a t e <= 0 ; d a t a _ o u t <= ( o t h e r s => 0 ) ; 72 d a t a _ a <= ( o t h e r s => 0 ) ;

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 28 mem_we <= 0 ; s i g _ a d d r _ a <= ( o t h e r s => 0 ) ; s i g _ a d d r _ b <= ( o t h e r s => 0 ) ; r e a d _ a d d r _ t <= ( o t h e r s => 0 ) ; p r e v _ r e a d _ a d d r <= ( o t h e r s => 0 ) ; t e m p _ r e s <= ( o t h e r s => 0 ) ; r e a d _ a d d r _ i <= ( o t h e r s => 0 ) ; p r e v _ r e a d _ a d d r _ i <= ( o t h e r s => 0 ) ; o u t _ a d d r <= ( o t h e r s => 0 ) ; 82 v a l i d _ o u t p u t <= 0 ; temp1 <= ( o t h e r s => 0 ) ; temp2 <= ( o t h e r s => 0 ) ; temp3 <= ( o t h e r s => 0 ) ; i f ( r i s i n g _ e d g e ( c l k ) ) then i f ( s t a l l = 0 ) then i f ( en = 0 ) then s t a t e <= 0 ; 92 mem_we <= 0 ; v a l i d _ o u t p u t <= 0 ; d a t a _ o u t <= ( o t h e r s => 0 ) ; i f s t a t e = 0 then i f ( we = 1 ) then s i g _ a d d r _ a <= w r i t e _ a d d r ; d a t a _ a <= d a t a _ i n ; mem_we <= 1 ; 102 s i g _ a d d r _ a <= ( o t h e r s => 0 ) ; d a t a _ a <= ( o t h e r s => 0 ) ; mem_we <= 0 ; s i g _ a d d r _ b <= r e a d _ a d d r ; t e m p _ r e s <= s i g _ o u t _ b ; r e a d _ a d d r _ i <= r e a d _ a d d r ; p r e v _ r e a d _ a d d r _ i <= p r e v _ r e a d _ a d d r ; r e a d _ a d d r _ t <= r e a d _ a d d r ; v a l i d _ o u t p u t <= 0 ; 112 temp1 <= r e a d _ a d d r ;

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 29 temp3 <= temp2 ; s t a t e <= 1 ; mem_we <= 0 ; i f ( r e a d _ a d d r _ i = 000000000 ) then s i g _ a d d r _ a <= ( o t h e r s => 0 ) ; s i g _ a d d r _ b <= r e a d _ a d d r + 1 ; e l s i f ( r e a d _ a d d r _ i =linewd4m1 ) then s i g _ a d d r _ a <= r e a d _ a d d r 1 ; 122 s i g _ a d d r _ b <= ( o t h e r s => 0 ) ; s i g _ a d d r _ a <= r e a d _ a d d r 1 ; s i g _ a d d r _ b <= r e a d _ a d d r + 1 ; d a t a _ o u t (39 downto 8) <= t e m p _ r e s ; temp2 <= temp1 ; o u t _ a d d r <= temp3 ; v a l i d _ o u t p u t <= 1 ; i f ( p r e v _ r e a d _ a d d r _ i = 000000000 ) then 132 d a t a _ o u t (47 downto 40) <= 00000000 ; d a t a _ o u t (7 downto 0) <= s i g _ o u t _ b (31 downto 24) ; e l s i f ( p r e v _ r e a d _ a d d r _ i =linewd4m1 ) then d a t a _ o u t (47 downto 40) <= s i g _ o u t _ a (7 downto 0) ; d a t a _ o u t (7 downto 0) <= 00000000 ; d a t a _ o u t (47 downto 40) <= s i g _ o u t _ a (7 downto 0) ; d a t a _ o u t (7 downto 0) <= s i g _ o u t _ b (31 downto 24) ; p r e v _ r e a d _ a d d r <= r e a d _ a d d r _ t ; 142 s t a t e <= 0 ;

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 30 end p r o c e s s ; end B e h a v i o r a l ; Πλαίσιο Κώδικα 6: Το τμήμα ελέγχου της επεξεργασίας l i b r a r y IEEE ; use IEEE. STD_LOGIC_1164.ALL; use IEEE. STD_LOGIC_ARITH.ALL; u s e IEEE. STD_LOGIC_UNSIGNED. ALL; e n t i t y s o b e l _ i m a g e i s Port ( c l k : in STD_LOGIC ; 8 r s t : in STD_LOGIC ; en : i n STD_LOGIC ; l i n e s : in s t d _ l o g i c _ v e c t o r (10 downto 0) ; linew : in s t d _ l o g i c _ v e c t o r (10 downto 0) ; d a t a _ i n : in STD_LOGIC_VECTOR (31 downto 0) ; d a t a _ o u t : out STD_LOGIC_VECTOR (31 downto 0) ; l a s t p i x : out s t d _ l o g i c ; d a t a _ v a l i d : out STD_LOGIC ) ; end s o b e l _ i m a g e ; 18 a r c h i t e c t u r e B e h a v i o r a l of s o b e l _ i m a g e i s component s o b e l _ 4 p i s Port ( pix11 : in STD_LOGIC_VECTOR (7 downto 0) ; pix12 : in STD_LOGIC_VECTOR (7 downto 0) ; pix13 : in STD_LOGIC_VECTOR (7 downto 0) ; pix14 : in STD_LOGIC_VECTOR (7 downto 0) ; pix15 : in STD_LOGIC_VECTOR (7 downto 0) ; pix16 : in STD_LOGIC_VECTOR (7 downto 0) ; 28 pix21 : in STD_LOGIC_VECTOR (7 downto 0) ; pix22 : in STD_LOGIC_VECTOR (7 downto 0) ; pix23 : in STD_LOGIC_VECTOR (7 downto 0) ; pix24 : in STD_LOGIC_VECTOR (7 downto 0) ; pix25 : in STD_LOGIC_VECTOR (7 downto 0) ;

5 ΠΑΡΑΡΤΗΜΑ ΚΩΔΙΚΑ 31 pix26 : in STD_LOGIC_VECTOR (7 downto 0) ; pix31 : in STD_LOGIC_VECTOR (7 downto 0) ; pix32 : in STD_LOGIC_VECTOR (7 downto 0) ; pix33 : in STD_LOGIC_VECTOR (7 downto 0) ; pix34 : in STD_LOGIC_VECTOR (7 downto 0) ; 38 pix35 : in STD_LOGIC_VECTOR (7 downto 0) ; pix36 : in STD_LOGIC_VECTOR (7 downto 0) ; p i x o u t 2 2 : out STD_LOGIC_VECTOR (7 downto 0) ; p i x o u t 2 3 : out STD_LOGIC_VECTOR (7 downto 0) ; p i x o u t 2 4 : out STD_LOGIC_VECTOR (7 downto 0) ; p i x o u t 2 5 : out STD_LOGIC_VECTOR (7 downto 0) ; r s t : in s t d _ l o g i c ; s t a l l : in s t d _ l o g i c ; c l k : in STD_LOGIC ) ; end component ; 48 component linemem i s Port ( c l k : in STD_LOGIC ; r s t : in STD_LOGIC ; linew : in s t d _ l o g i c _ v e c t o r (10 downto 0) ; w r i t e _ a d d r : in STD_LOGIC_VECTOR (8 downto 0) ; d a t a _ i n : in STD_LOGIC_VECTOR (31 downto 0) ; en : in s t d _ l o g i c ; we : i n STD_LOGIC ; s t a l l : in s t d _ l o g i c ; r e a d _ a d d r : in STD_LOGIC_VECTOR (8 downto 0) ; 58 d a t a _ o u t : out STD_LOGIC_VECTOR (47 downto 0) ; v a l i d _ o u t p u t : out s t d _ l o g i c ; o u t _ a d d r : out s t d _ l o g i c _ v e c t o r (8 downto 0) ) ; end component ; C o n n e c t i n g s i g n a l s