Keyboard Class Reference

Handles keystrokes. More...

#include <device/keyboard.h>

Inheritance diagram for Keyboard:

Collaboration diagram for Keyboard:

Public Member Functions
	Keyboard ()
	Constructor.
void	plugin ()
	Initialization of the keyboard.
bool	prologue () override
	Prologue of keyboard interrupts.
void	epilogue () override
	Epilogue of keyboard interrupts.
Key	getKey ()
	Application interface to retrieve a Key.
Public Member Functions inherited from Gate
	Gate ()
	Constructor.
virtual	~Gate ()
	Destructor.
bool	is_queued () const
	Status about the epilogue.
void	set_queued (bool val)
	Set epilogue status.

Private Member Functions
	Keyboard (const Keyboard &)=delete
Keyboard &	operator= (const Keyboard &)=delete

Private Attributes
BBuffer< Key, 16 >	prologue_keys
	Buffer for pressed keys in prologue.
BBuffer< Key, 64 >	epilogue_keys
	Buffer for pressed keys already processed in epilogue.
Semaphore	key_available
	Semaphore to signal an available key.

Additional Inherited Members
Protected Member Functions inherited from Queue< T, ContainerType >::Node
	Node ()

Detailed Description

Handles keystrokes.

This class ensures correct initialization of the keyboard and, above all, its interrupt handling. It also allows an application to query it for key strokes.

Constructor & Destructor Documentation

Keyboard() [1/2]

Keyboard::Keyboard ( const Keyboard &  )

privatedelete

Keyboard() [2/2]

Keyboard::Keyboard ( )

inline

Constructor.

Todo:

Modify constructor (to initialize the Semaphore with 0)

Member Function Documentation

operator=()

Keyboard & Keyboard::operator= ( const Keyboard &  )

privatedelete

plugin()

void Keyboard::plugin

(

)

Initialization of the keyboard.

Initialization of the keyboard and activation of the specific interrupt handling: The object will register itself at the Plugbox and configure the IOAPIC to receive the corresponding interrupts.

Note

The keyboard interrupts should be configured as level triggered. According to the standard we would have to check the corresponding entry in ACPI::MADS::Interrupt_Source_Override and use these values. Most likely this would suggest an edge-triggered mode – which would work as well. However, using a level-triggered mode is more forgiving because it resends the interrupt request even if an interrupt was lost (e.g. the required handling, retrieving the buffer entry, was not performed).

prologue()

bool Keyboard::prologue ( )

overridevirtual

Prologue of keyboard interrupts.

This method directly handles interrupts caused by the keyboard. Since multiple interrupts are triggered on a keystroke (press & release) it produces not always a printable ASCII character – therefore only valid keys are handled in the Keyboard::epilogue.

Since the buffer is limited, it also ensures that a valid key is not overwritten by a subsequent prologue before it was handled in the Keyboard::epilogue.

Note

If a keystroke would exceed the buffer, the new key is dropped – previous keystrokes have a higher priority in the buffer.

Returns

true if a new Key was stored in the buffer and has to be processed in the Keyboard::epilogue.

Implements Gate.

epilogue()

void Keyboard::epilogue ( )

overridevirtual

Epilogue of keyboard interrupts.

The occurrence of a keystroke is signaled to a possibly waiting thread. For this purpose, a semaphore is used whose counter indicates how many keys are available in the keyboard buffer for retrieval.

Todo:

Adjust method

Reimplemented from Gate.

getKey()

Key Keyboard::getKey

(

)

Application interface to retrieve a Key.

This method returns one pressed key (as an Key object). If no key has been pressed, the calling application thread is blocked until a key is available – this is achieved by using a Semaphore.

Returns

Pressed key

Todo:

Implement Method

Member Data Documentation

prologue_keys

BBuffer<Key, 16> Keyboard::prologue_keys

private

Buffer for pressed keys in prologue.

epilogue_keys

BBuffer<Key, 64> Keyboard::epilogue_keys

private

Buffer for pressed keys already processed in epilogue.

key_available

Semaphore Keyboard::key_available

private

Semaphore to signal an available key.

---

The documentation for this class was generated from the following files:

• device/keyboard.h
• device/keyboard.cc