Struct Scld 

pub struct Scld<M: PagedMemory8k, B, X, V> { /* private fields */ }

This is the emulator of SCLD chip used with Timex’s TC2048 / TC2068 / TS2068 models.

The generic type M must implement PagedMemory8k trait in addition to ZxMemory.

See Ula for description of other generic parameters.

Trait Implementations

impl<A, M, B, X, V> AudioFrame<A> for Scld<M, B, X, V>

where A: Blep, M: PagedMemory8k, Ula<M, B, X, V>: AudioFrame<A>,

fn ensure_audio_frame_time(&self, blep: &mut A, sample_rate: u32, cpu_hz: f64)

Sets up the Blep time rate and ensures there is enough room for the single frame’s audio data.

fn get_audio_frame_end_time(&self) -> FTs

Returns a timestamp to be passed to Blep to end the frame.

fn end_audio_frame(&self, blep: &mut B) -> usize

Calls Blep::end_frame to finalize the frame and prepare it for rendition.

impl<A, M, B, X, V> AyAudioFrame<A> for Scld<M, B, X, V>

where A: Blep, M: PagedMemory8k, B: AyAudioBusDevice + BusDevice, B::Timestamp: From<VFrameTs<V>>, V: VideoFrame,

fn render_ay_audio_frame<L: AmpLevels<A::SampleDelta>>( &mut self, blep: &mut A, chans: [usize; 3], )

Renders square-wave pulses via Blep interface.

impl<M: Clone + PagedMemory8k, B: Clone, X: Clone, V: Clone> Clone for Scld<M, B, X, V>

fn clone(&self) -> Scld<M, B, X, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M, B, X, V> ControlUnit for Scld<M, B, X, V>

where M: PagedMemory8k, B: BusDevice, B::Timestamp: From<VFrameTs<V>>, X: MemoryExtension, V: VideoFrame,

type BusDevice = B

A type of a chain of emulated peripheral devices should be declared here.

fn bus_device_mut(&mut self) -> &mut Self::BusDevice

Returns a mutable reference to the instance of the first bus device in the device chain.

fn bus_device_ref(&self) -> &Self::BusDevice

Returns a reference to the the instance of the first bus device in the device chain.

fn into_bus_device(self) -> Self::BusDevice

Destructs self and returns the instance of the bus device.

fn reset<C: Cpu>(&mut self, cpu: &mut C, hard: bool)

Performs a system reset.

fn nmi<C: Cpu>(&mut self, cpu: &mut C) -> bool

Triggers a non-maskable interrupt. Returns true if NMI was accepted.

fn execute_next_frame<C: Cpu>(&mut self, cpu: &mut C)

Conditionally prepares the internal state for the next frame and executes instructions on the cpu as fast as possible, until the near end of that frame.

fn ensure_next_frame(&mut self)

Conditionally prepares the internal state for the next frame, advances the frame counter, and wraps the T-state counter if it is near the end of a frame.

fn execute_single_step<C: Cpu, F: FnOnce(CpuDebug)>( &mut self, cpu: &mut C, debug: Option<F>, ) -> Result<(), ()>

Executes a single instruction on the cpu with the option to pass a debugging function.

impl<M, B, X, V> Debug for Scld<M, B, X, V>

where M: PagedMemory8k, B: BusDevice, X: MemoryExtension, V: VideoFrame,

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

Formats the value using the given formatter.

impl<M, B, X, V> Default for Scld<M, B, X, V>

where M: PagedMemory8k, V: VideoFrame, Ula<M, B, X, V>: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, M: PagedMemory8k, B, X, V> Deserialize<'de> for Scld<M, B, X, V>

where Ula<M, B, X, V>: Deserialize<'de>, V: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M, B, X, V> EarIn for Scld<M, B, X, V>

where M: PagedMemory8k, V: VideoFrame,

fn set_ear_in(&mut self, ear_in: bool, delta_fts: u32)

Sets EAR IN bit state after the provided interval in ∆ T-states counted from the last recorded change.

fn feed_ear_in<I>(&mut self, fts_deltas: I, max_frames_threshold: Option<usize>)

where I: Iterator<Item = NonZeroU32>,

Feeds the EAR IN buffer with changes.

fn purge_ear_in_changes(&mut self, ear_in: bool)

Removes all buffered so far EAR IN changes.

fn read_ear_in_count(&self) -> u32

Returns the counter of how many times the EAR input line was read since the beginning of the current frame.

fn read_ear_mode(&self) -> ReadEarMode

Returns the current mode.

fn set_read_ear_mode(&mut self, mode: ReadEarMode)

Changes the current mode.

impl<A, M, B, X, F> EarInAudioFrame<A> for Scld<M, B, X, F>

where A: Blep, M: PagedMemory8k, F: VideoFrame,

fn render_ear_in_audio_frame<V: AmpLevels<A::SampleDelta>>( &self, blep: &mut A, channel: usize, )

Renders EAR input as square-wave pulses via Blep interface.

impl<A, M, B, X, F> EarMicOutAudioFrame<A> for Scld<M, B, X, F>

where A: Blep, M: PagedMemory8k, F: VideoFrame,

fn render_earmic_out_audio_frame<V: AmpLevels<A::SampleDelta>>( &self, blep: &mut A, channel: usize, )

Renders EAR/MIC output as square-wave pulses via Blep interface.

impl<M: PagedMemory8k, B, X> HostConfig for Scld<M, B, X, UlaVideoFrame>

const CPU_HZ: u32 = 3_500_000u32

The number of CPU cycles (T-states) per second.

const FRAME_TSTATES: FTs = 69_888i32

The number of CPU cycles (T-states) in a single execution frame.

fn effective_cpu_rate(multiplier: f64) -> f64

Returns the CPU rate (T-states / second) after multiplying it by the multiplier.

fn effective_frame_duration_nanos(multiplier: f64) -> u32

Returns the duration of a single execution frame in nanoseconds after multiplying the CPU rate by the multiplier.

fn effective_frame_duration(multiplier: f64) -> Duration

Returns the duration of a single execution frame after multiplying the CPU rate by the multiplier.

fn frame_duration_nanos() -> u32

Returns the duration of a single execution frame in nanoseconds.

fn frame_duration() -> Duration

Returns the duration of a single execution frame.

impl<M, B, X, V> InnerAccess for Scld<M, B, X, V>

where M: PagedMemory8k,

type Inner = Ula<M, B, X, V>

fn inner_ref(&self) -> &Self::Inner

Returns a reference to the inner chipset.

fn inner_mut(&mut self) -> &mut Self::Inner

Returns a mutable reference to the inner chipset.

fn into_inner(self) -> Self::Inner

Destructs self and returns the inner chipset.

impl<M, B, X, V> Io for Scld<M, B, X, V>

where M: PagedMemory8k, B: BusDevice, B::Timestamp: From<VFrameTs<V>>, V: VideoFrame,

type Timestamp = VideoTs

This type is being used for timestamping I/O operations. See also Clock::Timestamp.

type WrIoBreak = ()

A value of this type is returned when a break is being requested by Io::write_io.

type RetiBreak = ()

A value of this type is returned when a break is being requested by Io::reti.

fn is_irq(&mut self, ts: VideoTs) -> bool

Should return true if the interrupt request signal - the INT line - is active.

fn read_io(&mut self, port: u16, ts: VideoTs) -> (u8, Option<NonZeroU16>)

Called during the IO_IORQ cycle when executing one of the IN instructions.

fn write_io( &mut self, port: u16, data: u8, ts: VideoTs, ) -> (Option<()>, Option<NonZeroU16>)

Called during the IO_IORQ cycle when executing one of the OUT instructions.

fn irq_data( &mut self, pc: u16, timestamp: Self::Timestamp, ) -> (u8, Option<NonZero<u16>>)

Called during the INT_IORQ cycle when the maskable interrupt has been requested and accepted.

fn reti( &mut self, address: u16, timestamp: Self::Timestamp, ) -> Option<Self::RetiBreak>

When RETI instruction is being executed this method is being called to update the device implementation instance, so another interrupt signal can be set up if necessary.

impl<M, B, X, V> KeyboardInterface for Scld<M, B, X, V>

where M: PagedMemory8k,

fn get_key_state(&self) -> ZXKeyboardMap

Reads the current state of the keyboard.

fn set_key_state(&mut self, keymap: ZXKeyboardMap)

Sets the state of the keyboard.

impl<M, B, X, V> Memory for Scld<M, B, X, V>

where M: PagedMemory8k, X: MemoryExtension, V: VideoFrame,

type Timestamp = VideoTs

This type is being used for timestamping memory operations. See also Clock::Timestamp.

fn read_debug(&self, addr: u16) -> u8

Should return a single byte read from the memory present at the given address.

fn read_mem(&self, addr: u16, _ts: VideoTs) -> u8

Should return a single byte read from the memory present at the given address.

fn read_mem16(&self, addr: u16, _ts: VideoTs) -> u16

Should return the unaligned, 2 consecutive bytes from the memory present at the given address as a 16-bit unsigned integer in a LE (least significant byte first) order.

fn read_opcode(&mut self, pc: u16, _ir: u16, _ts: VideoTs) -> u8

Should return a single byte read from the memory present at the given pc address.

fn write_mem(&mut self, addr: u16, val: u8, ts: VideoTs)

Should write a byte value into the memory at the given address.

impl<M, B, X, V> MemoryAccess for Scld<M, B, X, V>

where M: PagedMemory8k, X: MemoryExtension,

type Memory = M

type MemoryExt = X

fn memory_ext_ref(&self) -> &Self::MemoryExt

Returns a read-only reference to the memory extension.

fn memory_ext_mut(&mut self) -> &mut Self::MemoryExt

Returns a mutable reference to the memory extension.

fn memory_mut(&mut self) -> &mut Self::Memory

Returns a mutable reference to the memory.

fn memory_ref(&self) -> &Self::Memory

Returns a reference to the memory.

fn memory_with_ext_mut(&mut self) -> (&mut Self::Memory, &mut Self::MemoryExt)

Returns mutable references to both the memory and the memory extension.

impl<'a, M, B: 'a, X: 'a, V> MicOut<'a> for Scld<M, B, X, V>

where M: PagedMemory8k + 'a, V: VideoFrame + 'a,

type PulseIter = <Ula<M, B, X, V> as MicOut<'a>>::PulseIter

fn mic_out_pulse_iter(&'a self) -> Self::PulseIter

Returns a frame buffered MIC output as a pulse iterator.

impl<M, B, X, V> ScreenDataProvider for Scld<M, B, X, V>

where M: ZxMemory + PagedMemory8k, X: MemoryExtension, V: VideoFrame,

fn get_screen_mode(&self) -> ScrMode

Should return a currently selected screen mode.

fn set_screen_mode(&mut self, mode: ScrMode) -> bool

Should set a requested screen mode and return true. If the provided mode can not be set this method should return false.

fn screen_primary_ref(&self) -> &ScreenArray

Should return a reference to the primary screen data.

fn screen_primary_mut(&mut self) -> &mut ScreenArray

Should return a mutable reference to the primary screen data.

fn screen_secondary_ref(&self) -> &ScreenArray

Should return a reference to the secondary screen data.

fn screen_secondary_mut(&mut self) -> &mut ScreenArray

Should return a mutable reference to the secondary screen data.

fn screen_palette_ref(&self) -> &[u8; 64]

Should return a reference to the ULAplus palette.

fn screen_palette_mut(&mut self) -> &mut [u8; 64]

Should return a mutable reference to the ULAplus palette.

impl<M: PagedMemory8k, B, X, V> Serialize for Scld<M, B, X, V>

where Ula<M, B, X, V>: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<M, B, X, V> UlaControl for Scld<M, B, X, V>

where M: PagedMemory8k, V: VideoFrame,

fn has_late_timings(&self) -> bool

Returns the state of the “late timings” mode.

fn set_late_timings(&mut self, late_timings: bool)

Sets the “late timings” mode on or off.

fn scld_ctrl_port_value(&self) -> Option<ScldCtrlFlags>

Returns the last value sent to the memory port 0xFF.

fn set_scld_ctrl_port_value(&mut self, value: ScldCtrlFlags) -> bool

Sets the current value of the memory port 0xFF. Returns true if supported. Otherwise, returns false and no writing is performed.

fn scld_mmu_port_value(&self) -> Option<u8>

Returns the last value sent to the memory port 0xF4.

fn set_scld_mmu_port_value(&mut self, value: u8) -> bool

Sets the current value of the memory port 0xF4. Returns true if supported. Otherwise, returns false and no writing is performed.

fn ula128_mem_port_value(&self) -> Option<Ula128MemFlags>

Returns the last value sent to the memory port 0x7FFD if supported.

fn set_ula128_mem_port_value(&mut self, _value: Ula128MemFlags) -> bool

Sets the current value of the memory port 0x7FFD. Returns true if supported. Otherwise, returns false and no writing is performed.

fn ula3_ctrl_port_value(&self) -> Option<Ula3CtrlFlags>

Returns the last value sent to the memory port 0x1FFD if supported.

fn set_ula3_ctrl_port_value(&mut self, _value: Ula3CtrlFlags) -> bool

Sets the current value of the memory port 0x1FFD. Returns true if supported. Otherwise, returns false and no writing is performed.

fn ulaplus_reg_port_value(&self) -> Option<UlaPlusRegFlags>

Returns the last value sent to the register port 0xBF3B.

fn set_ulaplus_reg_port_value(&mut self, _value: UlaPlusRegFlags) -> bool

Sets the current value of the memory port 0xBF3B. Returns true if supported. Otherwise, returns false and no writing is performed.

fn ulaplus_data_port_value(&self) -> Option<u8>

Returns the last value sent to the data port 0xFF3B.

fn set_ulaplus_data_port_value(&mut self, _value: u8) -> bool

Sets the current value of the memory port 0xFF3B. Returns true if supported. Otherwise, returns false and no writing is performed.

impl<M, B, X, V> UlaControlExt for Scld<M, B, X, V>

where M: PagedMemory8k, B: BusDevice, B::Timestamp: From<VFrameTs<V>>, V: VideoFrame,

fn prepare_next_frame<C: MemoryContention>( &mut self, vtsc: VFrameTsCounter<V, C>, ) -> VFrameTsCounter<V, C>

This method is used by wrappers with a different contention scheme.

fn ensure_next_frame_vtsc( &mut self, ) -> VFrameTsCounter<Self::VideoFrame, Self::Contention>

impl<M, D, X, V> Video for Scld<M, D, X, V>

where M: PagedMemory8k, V: VideoFrame,

const PIXEL_DENSITY: u32 = 2u32

The horizontal pixel density.

type VideoFrame = V

The type implementing VideoFrame, that is being used by the chipset emulator.

type Contention = UlaMemoryContention

The type implementing MemoryContention, that is being used by the chipset emulator.

fn border_color(&self) -> BorderColor

Returns the current border color.

fn set_border_color(&mut self, border: BorderColor)

Force sets the border area to the given color.

fn render_video_frame<'a, B: PixelBuffer<'a>, P: Palette<Pixel = B::Pixel>>( &mut self, buffer: &'a mut [u8], pitch: usize, border_size: BorderSize, )

Renders last emulated frame’s video data into the provided pixel buffer.

fn current_video_ts(&self) -> VideoTs

Returns the current value of the video T-state counter.

fn current_video_clock( &self, ) -> VFrameTsCounter<Self::VideoFrame, Self::Contention>

Returns the current value of the video T-state clock.

fn set_video_ts(&mut self, vts: VideoTs)

Modifies the current value of the video T-state counter.

fn flash_state(&self) -> bool

Returns the temporary video flash attribute state.

fn render_size_pixels(border_size: BorderSize) -> (u32, u32)

Returns rendered screen pixel size (horizontal, vertical), including the border area, measured in pixels depending on Video::PIXEL_DENSITY.

fn pixel_density() -> u32

Returns the horizontal pixel density.

fn visible_screen_bank(&self) -> usize

Returns the screen bank index of the currently visible screen.