1
0
mirror of https://github.com/TomHarte/CLK.git synced 2024-12-13 00:29:14 +00:00
CLK/Machines/Amiga/Keyboard.cpp
2023-05-16 16:40:09 -04:00

189 lines
5.7 KiB
C++

//
// Keyboard.cpp
// Clock Signal
//
// Created by Thomas Harte on 29/07/2021.
// Copyright © 2021 Thomas Harte. All rights reserved.
//
#include "Keyboard.hpp"
// Notes to self:
//
//
// Before
// the transmission starts, both KCLK and KDAT are high. The keyboard starts
// the transmission by putting out the first data bit (on KDAT), followed by
// a pulse on KCLK (low then high); then it puts out the second data bit and
// pulses KCLK until all eight data bits have been sent.
//
// When the computer has received the eighth bit, it must pulse KDAT low for
// at least 1 (one) microsecond, as a handshake signal to the keyboard. The
// keyboard must be able to detect pulses greater than or equal
// to 1 microsecond. Software MUST pulse the line low for 85 microseconds to
// ensure compatibility with all keyboard models.
//
//
// If the handshake pulse does not arrive within
// 143 ms of the last clock of the transmission, the keyboard will assume
// that the computer is still waiting for the rest of the transmission and is
// therefore out of sync. The keyboard will then attempt to restore sync by
// going into "resync mode." In this mode, the keyboard clocks out a 1 and
// waits for a handshake pulse. If none arrives within 143 ms, it clocks out
// another 1 and waits again.
//
// The keyboard Hard Resets the Amiga by pulling KCLK low and starting a 500
// millisecond timer. When one or more of the keys is released and 500
// milliseconds have passed, the keyboard will release KCLK.
//
// The usual sequence of events will therefore be: power-up; synchronize;
// transmit "initiate power-up key stream" ($FD); transmit "terminate key
// stream" ($FE).
using namespace Amiga;
Keyboard::Keyboard(Serial::Line<true> &output) : output_(output) {
output_.set_writer_clock_rate(HalfCycles(1'000'000)); // Use µs.
}
/*uint8_t Keyboard::update(uint8_t input) {
// If a bit transmission is ongoing, continue that, up to and including
// the handshake. If no handshake comes, set a macro state of synchronising.
switch(shift_state_) {
case ShiftState::Shifting:
// The keyboard processor sets the KDAT line about 20 microseconds before it
// pulls KCLK low. KCLK stays low for about 20 microseconds, then goes high
// again. The processor waits another 20 microseconds before changing KDAT.
switch(bit_phase_) {
default: break;
case 0: lines_ = Lines::Clock | (shift_sequence_ & 1); break;
case 20: lines_ = (shift_sequence_ & 1); break;
case 40: lines_ = Lines::Clock | (shift_sequence_ & 1); break;
}
bit_phase_ = (bit_phase_ + 1) % 60;
if(!bit_phase_) {
--bits_remaining_;
shift_sequence_ >>= 1;
if(!bits_remaining_) {
shift_state_ = ShiftState::AwaitingHandshake;
}
}
return lines_;
case ShiftState::AwaitingHandshake:
if(!(input & Lines::Data)) {
shift_state_ = ShiftState::Idle;
}
++bit_phase_;
if(bit_phase_ == 143) {
// shift_state_ = ShiftState::Synchronising;
}
return lines_;
default: break;
}
switch(state_) {
case State::Startup:
bit_phase_ = 0;
shift_sequence_ = 0xff;
shift_state_ = ShiftState::Shifting;
break;
}
return lines_;
}*/
void Keyboard::set_key_state(uint16_t key, bool is_pressed) {
if(pressed_[key] == is_pressed) {
return;
}
pressed_[key] = is_pressed;
output_.write<false>(
HalfCycles(60),
uint8_t(((key << 1) | (is_pressed ? 0 : 1)) ^ 0xff)
);
}
void Keyboard::clear_all_keys() {
for(uint16_t c = 0; c < uint16_t(pressed_.size()); c++) {
if(pressed_[c]) set_key_state(c, false);
}
}
// MARK: - KeyboardMapper.
uint16_t KeyboardMapper::mapped_key_for_key(Inputs::Keyboard::Key key) const {
#define BIND(source, dest) case Inputs::Keyboard::Key::source: return uint16_t(Key::dest)
#define DIRECTBIND(source) BIND(source, source)
switch(key) {
default: break;
DIRECTBIND(Escape);
DIRECTBIND(Delete);
DIRECTBIND(F1); DIRECTBIND(F2); DIRECTBIND(F3); DIRECTBIND(F4); DIRECTBIND(F5);
DIRECTBIND(F6); DIRECTBIND(F7); DIRECTBIND(F8); DIRECTBIND(F9); DIRECTBIND(F10);
BIND(BackTick, Tilde);
DIRECTBIND(k1); DIRECTBIND(k2); DIRECTBIND(k3); DIRECTBIND(k4); DIRECTBIND(k5);
DIRECTBIND(k6); DIRECTBIND(k7); DIRECTBIND(k8); DIRECTBIND(k9); DIRECTBIND(k0);
DIRECTBIND(Hyphen);
DIRECTBIND(Equals);
DIRECTBIND(Backslash);
DIRECTBIND(Backspace);
DIRECTBIND(Tab);
DIRECTBIND(CapsLock);
BIND(LeftControl, Control);
BIND(RightControl, Control);
DIRECTBIND(LeftShift);
DIRECTBIND(RightShift);
BIND(LeftOption, Alt);
BIND(RightOption, Alt);
BIND(LeftMeta, LeftAmiga);
BIND(RightMeta, RightAmiga);
DIRECTBIND(Q); DIRECTBIND(W); DIRECTBIND(E); DIRECTBIND(R); DIRECTBIND(T);
DIRECTBIND(Y); DIRECTBIND(U); DIRECTBIND(I); DIRECTBIND(O); DIRECTBIND(P);
DIRECTBIND(A); DIRECTBIND(S); DIRECTBIND(D); DIRECTBIND(F); DIRECTBIND(G);
DIRECTBIND(H); DIRECTBIND(J); DIRECTBIND(K); DIRECTBIND(L); DIRECTBIND(Z);
DIRECTBIND(X); DIRECTBIND(C); DIRECTBIND(V); DIRECTBIND(B); DIRECTBIND(N);
DIRECTBIND(M);
DIRECTBIND(OpenSquareBracket);
DIRECTBIND(CloseSquareBracket);
DIRECTBIND(Help);
BIND(Insert, Help);
BIND(Home, Help);
BIND(End, Help);
BIND(Enter, Return);
DIRECTBIND(Semicolon);
DIRECTBIND(Quote);
DIRECTBIND(Comma);
DIRECTBIND(FullStop);
DIRECTBIND(ForwardSlash);
DIRECTBIND(Space);
DIRECTBIND(Up);
DIRECTBIND(Down);
DIRECTBIND(Left);
DIRECTBIND(Right);
DIRECTBIND(Keypad0); DIRECTBIND(Keypad1); DIRECTBIND(Keypad2);
DIRECTBIND(Keypad3); DIRECTBIND(Keypad4); DIRECTBIND(Keypad5);
DIRECTBIND(Keypad6); DIRECTBIND(Keypad7); DIRECTBIND(Keypad8);
DIRECTBIND(Keypad9);
DIRECTBIND(KeypadDecimalPoint);
DIRECTBIND(KeypadMinus);
DIRECTBIND(KeypadEnter);
}
#undef DIRECTBIND
#undef BIND
return MachineTypes::MappedKeyboardMachine::KeyNotMapped;
}