FPGA Implementation of Keyboard Learner using Spartan3 FPGA Image processing kit

Call for Price

The main objective of the KBL project is to provide it’s users an easy and straight-forward way to learn, practice and improve the use of the keyboard in typewriting.

Features:

key board and VGA interfacing with fpga processor

Shipping : 2 to 3 working days from the Date of purchase

Package Includes:

  • Complete Hardware Kit

  • Demo Video-Embedded Below

  • Abstract

  • Reference Paper

  • !!! Online Support !!!

SKU: FPGA Implementation of Keyboard Learner SP3 Categories: , ,

Description

Abstract

The main objective of the KBL project is to provide it’s users an easy and straight-forward way to learn, practice and improve the use of the keyboard in typewriting. The proposed solution for reaching this objective is a clean application, with no unnecessary artwork and with a few options for customizing the user-experience. The Spartan3 FPGA Image Processing Kit  based Keyboard  learner system generates and displays random character codes, with a very small possibility of the code being an actual word. This forces the user to keep his eyes on the screen, and not at the keyboard. If the system would use intelligible words, the user would just read them and switch his eyes to the keyboard to type them. The effect of using this system is that users will start typing faster, and with fewer spelling errors, eventually without even looking to the keys.

Demonstration Video

Tool required

Software:

  • Xilinx ISE 11.1i

Language:

  • VHDL

Hardware:

Block Diagram for FPGA Implementation of Keyboard Learner using Spartan3 FPGA Image Processing Kit

Block_Dgm_Keyboard_Learner

ARC_Dgm_Keyboard_Learner

Introduction:

The Keyboard Learner gets its user inputs from the PS/2 keyboard. Each input characters must be compared with a generated character, and the score modified accordingly, and displayed. From this single sentence, some of the main components of the design can be easily identified: a random character generator, a keyboard input reader, a comparator, a score updater and a display unit. Also, code sequences must be memorized and the custom settings for the timer and the length of the sequence must be handled. Most of the components are based on registers and counters and use comparators, multiplexers and demultiplexers. Figure 3.1 shows the top level block diagram, with all the components used in the design and the links between them.

Functional Description

This section describes the flow of events that can take place while using the KBL system.

The Menu Screen

The system starts in the Menu Screen – the state signal is set to logical ‘0’. This screen displays on two different lines the labels for the timer (T) and level (L) settings together with their default values. The third line contains the GO label, used to start the application. The first line, corresponding to the timer setting is highlighted (yellow). The system waits for user input.

The user can change the timer value, or switch the selected item to the next line, from where he/she can change the level value, or step to the third line and start the application. A minimum of 3 keys must be pressed in order to get to the Application Screen. These 3 keystrokes are used in the background to generate the first random character sequence and store it, each character in its corresponding register. Therefore, the default level value must be less than or equal to 3, so that all the characters are generated.

The units used during the Menu Screen are: KB_UNIT, MENU, VGA_CTRL, COLORIZER and NUM_CNTR, and, unnoticeably for the user, the RANDOMIZER, CRST and REG_PIPE.

The Application Screen

When in Application Screen, the screen contains the generated character code in the centre and the user score in the upper right corner. Initially the score is null (000). The system waits for the user to type the code displayed.

As each character is typed in, it is compared to the one in the code. If they match, the score is incremented. If not, the score is decremented (if it is still positive). The colours of the typed characters changes with regard to the past comparison results. A green character signifies a correct match, while a red one means that character was mistyped.

If the user has set a non-null timer value, then the ready-for-display registers are cleared after the specified amount of time and the code disappears from screen, the application becoming a memory test.

All the units are functional when the system is in Application Screen.:

⇛The KB_UNIT reads the user input;

⇛The NUM_CNTR iterates the character sequence;

⇛The RANDOMIZER generates a new character code at each key stroke;

⇛The REG_PIPE stores the codes, moves them into the pipe and outputs them to the COUNTER or the COLORIZER;

⇛The COUNTER compares the generated and the read character code and computes the score and sends it to the COLORIZER;

⇛The COLORIZER computes the colour channels value for each character

⇛The VGA_CTRL selects the current character, character line and pixel, and generates the synchronization signals;

⇛The HIDER clears generated code from the screen if the time limit has been reached;

⇛The MENU identifies the ESC (escape) keystroke, and sends the system back in Menu Screen.

Keyboard Learner output image

Keyboard Learner output image

 

Keyboard Learner output image

Keyboard Learner output image

 

Conclusion

Typewriting skills are an important asset for anyone in the modern society. There are many tools and systems (hardware and software) for learning, developing and improving this ability. The Keyboard Learner is one of them. It achieves its goal of being a self-educational tool by its simplicity and ease of use at a low cost.

The additional option of using a limited display time period makes out of KBL not only an educational tool, but also a memory game, fun for children in growing phase, when developing attention and memory capability is very important.

The project uses a hierarchical and modular design implemented in Spartan3 FPGA Image Processing Kit, which has the advantage of being easy to follow and understand. It is event oriented, so it can be easily translated into natural language. The reusability of independent units is not one of the project’s strong points. This is caused by the high dependency between components and can be seen as a drawback. On the other hand, the components are designed to be dedicated to the specific role that they have within the Keyboard Learner.

For more FPGA Projects Click Here

Additional information

Weight 1.000000 kg

Reviews

There are no reviews yet.

Be the first to review “FPGA Implementation of Keyboard Learner using Spartan3 FPGA Image processing kit”

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.