Struct spectrusty::peripherals::bus::ay::serial128::SerialKeypad

pub struct SerialKeypad<T> { /* private fields */ }

The ZX Spectrum 128 extension keypad.

For the history of this rare and often omitted in emulators device see: Spectrum128Keypad.htm.

+-------+  +-------+  +-------+  +-------+
| DEL ← |  | ↑     |  | DEL → |  |TOGGLE |
|   /   |  |   *   |  |   (   |  |   )   |
+-------+  +-------+  +-------+  +-------+

+-------+  +-------+  +-------+  +-------+
| ←     |  | ↓     |  | →     |  | CMND  |
|   7   |  |   8   |  |   9   |  |   -   |
+-------+  +-------+  +-------+  +-------+

+-------+  +-------+  +-------+  +-------+
|<< DEL |  |>> DEL |  |↑↑     |  |↑↑     |
|   4   |  |   5   |  |   6   |  |   +   |
+-------+  +-------+  +-------+  +-------+

+-------+  +-------+  +-------+  +-------+
||<< DEL|  |>>| DEL|  |⭱⭱     |  |   E   |
|   1   |  |   2   |  |   3   |  |   N   |
+-------+  +-------+  +-------+  |   T   |
                                 |   E   |
+------------------+  +-------+  |   R   |
|            SHIFT |  |⭳⭳     |  |       |
|         0        |  |   .   |  |   =   |
+------------------+  +-------+  +-------+

The extension keypad communicates with Spectrum using a unique protocol over the computer’s serial connector.

This type implements SerialPortDevice bringing the extension keypad to its virtual existence.

To change the keypad state use methods directly on the implementation of this type.

Implementations

impl<T> SerialKeypad<T>

pub fn get_key_state(&self) -> KeypadKeys

Reads the current state of the keypad.

pub fn set_key_state(&mut self, keys: KeypadKeys)

Sets the state of the keypad.

Trait Implementations

impl<T> Clone for SerialKeypad<T>where
    T: Clone,

fn clone(&self) -> SerialKeypad<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for SerialKeypad<T>where
    T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for SerialKeypad<T>where
    T: Default + TimestampOps,

fn default() -> SerialKeypad<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for SerialKeypad<T>where
    T: Deserialize<'de>,

fn deserialize<__D>(
    __deserializer: __D
) -> Result<SerialKeypad<T>, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> SerialPortDevice for SerialKeypad<T>where
    T: TimestampOps,

type Timestamp = T

fn write_data(
    &mut self,
    _rxd: DataState,
    _timestamp: <SerialKeypad<T> as SerialPortDevice>::Timestamp
) -> ControlState

A device receives a current RxD state from Spectrum and should output a DTR line state.

fn poll_ready(
    &mut self,
    _timestamp: <SerialKeypad<T> as SerialPortDevice>::Timestamp
) -> ControlState

This method is being called once every frame, near the end of it, and should return a DTR line state.

fn update_cts(
    &mut self,
    cts: ControlState,
    timestamp: <SerialKeypad<T> as SerialPortDevice>::Timestamp
)

Receives an updated CTS line state.

fn read_data(
    &mut self,
    timestamp: <SerialKeypad<T> as SerialPortDevice>::Timestamp
) -> DataState

Should return a TxD line state.

fn next_frame(
    &mut self,
    eof_timestamp: <SerialKeypad<T> as SerialPortDevice>::Timestamp
)

Called when the current frame ends to allow emulators to wrap stored timestamps.

impl<T> Serialize for SerialKeypad<T>where
    T: Serialize,

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.