From 81ff23168331de546e2359c2fba91d17a57c6052 Mon Sep 17 00:00:00 2001 From: Jesse Vincent Date: Wed, 22 Sep 2021 14:02:38 -0700 Subject: [PATCH] Check in a (non-working) Keyboardio Model 100 plugin, currently a copy of the Model 01 plugin --- .../library.properties | 7 + ...Kaleidoscope-Hardware-Keyboardio-Model01.h | 20 + .../device/keyboardio/Model01.cpp | 254 ++++++++ .../kaleidoscope/device/keyboardio/Model01.h | 168 +++++ .../src/kaleidoscope/device/keyboardio/twi.c | 574 ++++++++++++++++++ .../src/kaleidoscope/device/keyboardio/twi.h | 57 ++ .../driver/keyboardio/.Model01Side.cpp.swp | Bin 0 -> 16384 bytes .../driver/keyboardio/Model01Side.cpp | 214 +++++++ .../driver/keyboardio/Model01Side.h | 106 ++++ .../keyboardio/wire-protocol-constants.h | 51 ++ 10 files changed, 1451 insertions(+) create mode 100644 plugins/Kaleidoscope-Hardware-Keyboardio-Model100/library.properties create mode 100644 plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/Kaleidoscope-Hardware-Keyboardio-Model01.h create mode 100644 plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model01.cpp create mode 100644 plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model01.h create mode 100644 plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/twi.c create mode 100644 plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/twi.h create mode 100644 plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/.Model01Side.cpp.swp create mode 100644 plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model01Side.cpp create mode 100644 plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model01Side.h create mode 100644 plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/wire-protocol-constants.h diff --git a/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/library.properties b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/library.properties new file mode 100644 index 00000000..bf4ec989 --- /dev/null +++ b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/library.properties @@ -0,0 +1,7 @@ +name=Kaleidoscope-Hardware-Keyboardio-Model01 +version=0.0.0 +sentence=Keyboardio Model01 hardware support for Kaleidoscope +maintainer=Kaleidoscope's Developers +url=https://github.com/keyboardio/Kaleidoscope +author=Keyboardio +paragraph= diff --git a/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/Kaleidoscope-Hardware-Keyboardio-Model01.h b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/Kaleidoscope-Hardware-Keyboardio-Model01.h new file mode 100644 index 00000000..a83fd173 --- /dev/null +++ b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/Kaleidoscope-Hardware-Keyboardio-Model01.h @@ -0,0 +1,20 @@ +/* -*- mode: c++ -*- + * Kaleidoscope-Hardware-Keyboardio-Model01 -- Keyboardio Model01 hardware support for Kaleidoscope + * Copyright (C) 2017-2019 Keyboard.io, Inc + * + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the Free Software + * Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . + */ + +#pragma once + +#include "kaleidoscope/device/keyboardio/Model01.h" diff --git a/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model01.cpp b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model01.cpp new file mode 100644 index 00000000..61681091 --- /dev/null +++ b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model01.cpp @@ -0,0 +1,254 @@ +/* -*- mode: c++ -*- + * Kaleidoscope-Hardware-Model01 -- Keyboard.io Model01 hardware support for Kaleidoscope + * Copyright (C) 2017-2020 Keyboard.io, Inc + * + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the Free Software + * Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . + */ + +#ifdef ARDUINO_AVR_MODEL01 + +#include "Arduino.h" // for PROGMEM +#include "kaleidoscope/device/keyboardio/Model01.h" // for Model01LEDDriver... +#include "kaleidoscope/key_events.h" +#include "kaleidoscope/driver/keyscanner/Base_Impl.h" + +#ifndef KALEIDOSCOPE_VIRTUAL_BUILD +#include +#include +#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD + +namespace kaleidoscope { +namespace device { +namespace keyboardio { + +constexpr uint8_t Model01LEDDriverProps::key_led_map[] PROGMEM; + +#ifndef KALEIDOSCOPE_VIRTUAL_BUILD + +/********* Model01Hands *********/ + +struct Model01Hands { + static driver::keyboardio::Model01Side leftHand; + static driver::keyboardio::Model01Side rightHand; + + static void setup(); +}; + +driver::keyboardio::Model01Side Model01Hands::leftHand(0); +driver::keyboardio::Model01Side Model01Hands::rightHand(3); + +void Model01Hands::setup(void) { + // This lets the keyboard pull up to 1.6 amps from the host. + // That violates the USB spec. But it sure is pretty looking + DDRE |= _BV(6); + PORTE &= ~_BV(6); + + // Set B4, the overcurrent check to an input with an internal pull-up + DDRB &= ~_BV(4); // set bit, input + PORTB &= ~_BV(4); // set bit, enable pull-up resistor +} + +/********* LED Driver *********/ +bool Model01LEDDriver::isLEDChanged = true; + +void Model01LEDDriver::setBrightness(uint8_t brightness) { + Model01Hands::leftHand.setBrightness(brightness); + Model01Hands::rightHand.setBrightness(brightness); + isLEDChanged = true; +} + +uint8_t Model01LEDDriver::getBrightness() { + return Model01Hands::leftHand.getBrightness(); +} + +void Model01LEDDriver::setCrgbAt(uint8_t i, cRGB crgb) { + if (i < 32) { + cRGB oldColor = getCrgbAt(i); + isLEDChanged |= !(oldColor.r == crgb.r && oldColor.g == crgb.g && oldColor.b == crgb.b); + + Model01Hands::leftHand.ledData.leds[i] = crgb; + } else if (i < 64) { + cRGB oldColor = getCrgbAt(i); + isLEDChanged |= !(oldColor.r == crgb.r && oldColor.g == crgb.g && oldColor.b == crgb.b); + + Model01Hands::rightHand.ledData.leds[i - 32] = crgb; + } else { + // TODO(anyone): + // how do we want to handle debugging assertions about crazy user + // code that would overwrite other memory? + } +} + +cRGB Model01LEDDriver::getCrgbAt(uint8_t i) { + if (i >= 64) + return {0, 0, 0}; + + if (i < 32) { + return Model01Hands::leftHand.ledData.leds[i]; + } else { + return Model01Hands::rightHand.ledData.leds[i - 32]; + } +} + +void Model01LEDDriver::syncLeds() { + if (!isLEDChanged) + return; + + // LED Data is stored in four "banks" for each side + // We send it all at once to make it look nicer. + // We alternate left and right hands because otherwise + // we run into a race condition with updating the next bank + // on an ATTiny before it's done writing the previous one to memory + + Model01Hands::leftHand.sendLEDData(); + Model01Hands::rightHand.sendLEDData(); + + Model01Hands::leftHand.sendLEDData(); + Model01Hands::rightHand.sendLEDData(); + + Model01Hands::leftHand.sendLEDData(); + Model01Hands::rightHand.sendLEDData(); + + Model01Hands::leftHand.sendLEDData(); + Model01Hands::rightHand.sendLEDData(); + + isLEDChanged = false; +} + +boolean Model01LEDDriver::ledPowerFault() { + if (PINB & _BV(4)) { + return true; + } else { + return false; + } +} + +/********* Key scanner *********/ + +driver::keyboardio::keydata_t Model01KeyScanner::leftHandState; +driver::keyboardio::keydata_t Model01KeyScanner::rightHandState; +driver::keyboardio::keydata_t Model01KeyScanner::previousLeftHandState; +driver::keyboardio::keydata_t Model01KeyScanner::previousRightHandState; + +void Model01KeyScanner::enableScannerPower(void) { + // Turn on power to the LED net + DDRC |= _BV(7); + PORTC |= _BV(7); +} + +void Model01KeyScanner::setup() { + wdt_disable(); + delay(100); + enableScannerPower(); +} + +void Model01KeyScanner::readMatrix() { + //scan the Keyboard matrix looking for connections + previousLeftHandState = leftHandState; + previousRightHandState = rightHandState; + + if (Model01Hands::leftHand.readKeys()) { + leftHandState = Model01Hands::leftHand.getKeyData(); + } + + if (Model01Hands::rightHand.readKeys()) { + rightHandState = Model01Hands::rightHand.getKeyData(); + } +} + +void Model01KeyScanner::actOnHalfRow(byte row, byte colState, byte colPrevState, byte startPos) { + if ((colState != colPrevState) || (colState != 0)) { + for (byte col = 0; col < 8; col++) { + // Build up the key state for row, col + uint8_t keyState = ((bitRead(colPrevState, 0) << 0) | + (bitRead(colState, 0) << 1)); + if (keyState) + ThisType::handleKeyswitchEvent(Key_NoKey, KeyAddr(row, startPos - col), keyState); + + // Throw away the data we've just used, so we can read the next column + colState = colState >> 1; + colPrevState = colPrevState >> 1; + } + } +} + +void Model01KeyScanner::actOnMatrixScan() { + for (byte row = 0; row < 4; row++) { + actOnHalfRow(row, leftHandState.rows[row], previousLeftHandState.rows[row], 7); + actOnHalfRow(row, rightHandState.rows[row], previousRightHandState.rows[row], 15); + } +} + + +void Model01KeyScanner::scanMatrix() { + readMatrix(); + actOnMatrixScan(); +} + +void Model01KeyScanner::setKeyscanInterval(uint8_t interval) { + Model01Hands::leftHand.setKeyscanInterval(interval); + Model01Hands::rightHand.setKeyscanInterval(interval); +} + +bool Model01KeyScanner::isKeyswitchPressed(KeyAddr key_addr) { + auto row = key_addr.row(); + auto col = key_addr.col(); + if (col <= 7) { + return (bitRead(leftHandState.rows[row], 7 - col) != 0); + } else { + return (bitRead(rightHandState.rows[row], 7 - (col - 8)) != 0); + } +} + +bool Model01KeyScanner::wasKeyswitchPressed(KeyAddr key_addr) { + auto row = key_addr.row(); + auto col = key_addr.col(); + if (col <= 7) { + return (bitRead(previousLeftHandState.rows[row], 7 - col) != 0); + } else { + return (bitRead(previousRightHandState.rows[row], 7 - (col - 8)) != 0); + } +} + +uint8_t Model01KeyScanner::pressedKeyswitchCount() { + return __builtin_popcountl(leftHandState.all) + __builtin_popcountl(rightHandState.all); +} + +uint8_t Model01KeyScanner::previousPressedKeyswitchCount() { + return __builtin_popcountl(previousLeftHandState.all) + __builtin_popcountl(previousRightHandState.all); +} + +/********* Hardware plugin *********/ + +void Model01::setup() { + Model01Hands::setup(); + kaleidoscope::device::Base::setup(); + + TWBR = 12; // This is 400mhz, which is the fastest we can drive the ATTiny +} + +void Model01::enableHardwareTestMode() { + // Toggle the programming LEDS on + PORTD |= (1 << 5); + PORTB |= (1 << 0); + + // Disable the debouncer on the ATTinys + KeyScanner::setKeyscanInterval(2); +} + +#endif + +} +} +} +#endif diff --git a/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model01.h b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model01.h new file mode 100644 index 00000000..14f60631 --- /dev/null +++ b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model01.h @@ -0,0 +1,168 @@ +/* -*- mode: c++ -*- + * Kaleidoscope-Hardware-Model01 -- Keyboard.io Model01 hardware support for Kaleidoscope + * Copyright (C) 2017-2020 Keyboard.io, Inc + * + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the Free Software + * Foundation, version 3. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License along with + * this program. If not, see . + */ + +#pragma once + +#ifdef ARDUINO_AVR_MODEL01 + +#include + +#define CRGB(r,g,b) (cRGB){b, g, r} + +struct cRGB { + uint8_t b; + uint8_t g; + uint8_t r; +}; + +#include "kaleidoscope/device/ATmega32U4Keyboard.h" + +#include "kaleidoscope/driver/keyscanner/Base.h" +#include "kaleidoscope/driver/keyboardio/Model01Side.h" +#include "kaleidoscope/driver/led/Base.h" +#include "kaleidoscope/driver/bootloader/avr/Caterina.h" + +namespace kaleidoscope { +namespace device { +namespace keyboardio { + +struct Model01LEDDriverProps : public kaleidoscope::driver::led::BaseProps { + static constexpr uint8_t led_count = 64; + static constexpr uint8_t key_led_map[] PROGMEM = { + 3, 4, 11, 12, 19, 20, 26, 27, 36, 37, 43, 44, 51, 52, 59, 60, + 2, 5, 10, 13, 18, 21, 25, 28, 35, 38, 42, 45, 50, 53, 58, 61, + 1, 6, 9, 14, 17, 22, 24, 29, 34, 39, 41, 46, 49, 54, 57, 62, + 0, 7, 8, 15, 16, 23, 31, 30, 33, 32, 40, 47, 48, 55, 56, 63, + }; +}; + +#ifndef KALEIDOSCOPE_VIRTUAL_BUILD +class Model01LEDDriver : public kaleidoscope::driver::led::Base { + public: + static void syncLeds(); + static void setCrgbAt(uint8_t i, cRGB crgb); + static cRGB getCrgbAt(uint8_t i); + static void setBrightness(uint8_t brightness); + static uint8_t getBrightness(); + + static void enableHighPowerLeds(); + static boolean ledPowerFault(); + + private: + static bool isLEDChanged; +}; +#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD +class Model01LEDDriver; +#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD + +struct Model01KeyScannerProps : public kaleidoscope::driver::keyscanner::BaseProps { + static constexpr uint8_t matrix_rows = 4; + static constexpr uint8_t matrix_columns = 16; + typedef MatrixAddr KeyAddr; +}; + +#ifndef KALEIDOSCOPE_VIRTUAL_BUILD +class Model01KeyScanner : public kaleidoscope::driver::keyscanner::Base { + private: + typedef Model01KeyScanner ThisType; + public: + static void setup(); + static void scanMatrix(); + static void readMatrix(); + static void actOnMatrixScan(); + + static bool isKeyswitchPressed(KeyAddr key_addr); + static uint8_t pressedKeyswitchCount(); + + static bool wasKeyswitchPressed(KeyAddr key_addr); + static uint8_t previousPressedKeyswitchCount(); + + static void setKeyscanInterval(uint8_t interval); + + protected: + static driver::keyboardio::keydata_t leftHandState; + static driver::keyboardio::keydata_t rightHandState; + static driver::keyboardio::keydata_t previousLeftHandState; + static driver::keyboardio::keydata_t previousRightHandState; + + static void actOnHalfRow(byte row, byte colState, byte colPrevState, byte startPos); + static void enableScannerPower(); +}; +#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD +class Model01KeyScanner; +#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD + +struct Model01Props : public kaleidoscope::device::ATmega32U4KeyboardProps { + typedef Model01LEDDriverProps LEDDriverProps; + typedef Model01LEDDriver LEDDriver; + typedef Model01KeyScannerProps KeyScannerProps; + typedef Model01KeyScanner KeyScanner; + typedef kaleidoscope::driver::bootloader::avr::Caterina BootLoader; + static constexpr const char *short_name = "kbio01"; +}; + +#ifndef KALEIDOSCOPE_VIRTUAL_BUILD + +class Model01 : public kaleidoscope::device::ATmega32U4Keyboard { + public: + void setup(); + + static void enableHardwareTestMode(); +}; + +#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD + +} // namespace keyboardio +} // namespace device + +EXPORT_DEVICE(kaleidoscope::device::keyboardio::Model01) + +} + +#define PER_KEY_DATA_STACKED(dflt, \ + r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, \ + r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, \ + r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, \ + r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r2c6, \ + r0c7, r1c7, r2c7, r3c7, \ + r3c6, \ + \ + r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15, \ + r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15, \ + r2c10, r2c11, r2c12, r2c13, r2c14, r2c15, \ + r2c9, r3c10, r3c11, r3c12, r3c13, r3c14, r3c15, \ + r3c8, r2c8, r1c8, r0c8, \ + r3c9, ...) \ + \ + r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c7, r0c8, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15, \ + r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c7, r1c8, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15, \ + r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c6, r2c7, r2c8, r2c9, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15, \ + r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r3c6, r3c7, r3c8, r3c9, r3c10, r3c11, r3c12, r3c13, r3c14, RESTRICT_ARGS_COUNT((r3c15), 64, KEYMAP_STACKED, ##__VA_ARGS__) + +#define PER_KEY_DATA(dflt, \ + r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15, \ + r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15, \ + r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15, \ + r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r2c6, r2c9, r3c10, r3c11, r3c12, r3c13, r3c14, r3c15, \ + r0c7, r1c7, r2c7, r3c7, r3c8, r2c8, r1c8, r0c8, \ + r3c6, r3c9, ...) \ + r0c0, r0c1, r0c2, r0c3, r0c4, r0c5, r0c6, r0c7, r0c8, r0c9, r0c10, r0c11, r0c12, r0c13, r0c14, r0c15, \ + r1c0, r1c1, r1c2, r1c3, r1c4, r1c5, r1c6, r1c7, r1c8, r1c9, r1c10, r1c11, r1c12, r1c13, r1c14, r1c15, \ + r2c0, r2c1, r2c2, r2c3, r2c4, r2c5, r2c6, r2c7, r2c8, r2c9, r2c10, r2c11, r2c12, r2c13, r2c14, r2c15, \ + r3c0, r3c1, r3c2, r3c3, r3c4, r3c5, r3c6, r3c7, r3c8, r3c9, r3c10, r3c11, r3c12, r3c13, r3c14, RESTRICT_ARGS_COUNT((r3c15), 64, KEYMAP, ##__VA_ARGS__) + +#endif diff --git a/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/twi.c b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/twi.c new file mode 100644 index 00000000..bd00c078 --- /dev/null +++ b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/twi.c @@ -0,0 +1,574 @@ +/* + twi.c - TWI/I2C library for Wiring & Arduino + Copyright (c) 2006 Nicholas Zambetti. All right reserved. + + This library is free software: you can redistribute it and/or modify it under + the terms of the GNU Lesser General Public License as published by the Free + Software Foundation, either version 3 of the License, or (at your option) any + later version. + + This library is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + details. + + You should have received a copy of the GNU Lesser General Public License along + with this program. If not, see . + + Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts +*/ + +#if defined(__AVR__) && !defined(KALEIDOSCOPE_VIRTUAL_BUILD) + +#define ENABLE_TWI_SLAVE_MODE 0 + +#include +#include +#include +#include +#include +#include +// #include "Arduino.h" // for digitalWrite + +#define true 1 +#define false 0 + + +#ifndef cbi +#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) +#endif + +#ifndef sbi +#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit)) +#endif + +#include "pins_arduino.h" +#include "twi.h" + +static volatile uint8_t twi_state; +static volatile uint8_t twi_slarw; +static volatile uint8_t twi_sendStop; // should the transaction end with a stop +static volatile uint8_t twi_inRepStart; // in the middle of a repeated start + +static void (*twi_onSlaveTransmit)(void); +static void (*twi_onSlaveReceive)(uint8_t*, int); + +static uint8_t twi_masterBuffer[TWI_BUFFER_LENGTH]; +static volatile uint8_t twi_masterBufferIndex; +static volatile uint8_t twi_masterBufferLength; + +static uint8_t twi_txBuffer[TWI_BUFFER_LENGTH]; +static volatile uint8_t twi_txBufferIndex; +static volatile uint8_t twi_txBufferLength; + +#if ENABLE_TWI_SLAVE_MODE +static uint8_t twi_rxBuffer[TWI_BUFFER_LENGTH]; +static volatile uint8_t twi_rxBufferIndex; +#endif + +static volatile uint8_t twi_error; + +/* + * Function twi_init + * Desc readys twi pins and sets twi bitrate + * Input none + * Output none + */ +void twi_init(void) { + // initialize state + twi_state = TWI_READY; + twi_sendStop = true; // default value + twi_inRepStart = false; + + // activate internal pullups for twi. + // digitalWrite(SDA, 1); + PORTD |= _BV(0); + // digitalWrite(SCL, 1); + PORTD |= _BV(1); + + // initialize twi prescaler and bit rate + cbi(TWSR, TWPS0); + cbi(TWSR, TWPS1); + TWBR = ((F_CPU / TWI_FREQ) - 16) / 2; + + /* twi bit rate formula from atmega128 manual pg 204 + SCL Frequency = CPU Clock Frequency / (16 + (2 * TWBR)) + note: TWBR should be 10 or higher for master mode + It is 72 for a 16mhz Wiring board with 100kHz TWI */ + + // enable twi module, acks, and twi interrupt + TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA); +} + +/* + * Function twi_disable + * Desc disables twi pins + * Input none + * Output none + */ +void twi_disable(void) { + // disable twi module, acks, and twi interrupt + TWCR &= ~(_BV(TWEN) | _BV(TWIE) | _BV(TWEA)); + + // deactivate internal pullups for twi. + // digitalWrite(SDA, 0); + PORTD &= ~_BV(0); + // digitalWrite(SCL, 0); + PORTD &= ~_BV(1); +} + +/* + * Function twi_slaveInit + * Desc sets slave address and enables interrupt + * Input none + * Output none + */ +void twi_setAddress(uint8_t address) { + // set twi slave address (skip over TWGCE bit) + TWAR = address << 1; +} + +/* + * Function twi_setClock + * Desc sets twi bit rate + * Input Clock Frequency + * Output none + */ +void twi_setFrequency(uint32_t frequency) { + TWBR = ((F_CPU / frequency) - 16) / 2; + + /* twi bit rate formula from atmega128 manual pg 204 + SCL Frequency = CPU Clock Frequency / (16 + (2 * TWBR)) + note: TWBR should be 10 or higher for master mode + It is 72 for a 16mhz Wiring board with 100kHz TWI */ +} + +/* + * Function twi_readFrom + * Desc attempts to become twi bus master and read a + * series of bytes from a device on the bus + * Input address: 7bit i2c device address + * data: pointer to byte array + * length: number of bytes to read into array + * sendStop: Boolean indicating whether to send a stop at the end + * Output number of bytes read + */ +uint8_t twi_readFrom(uint8_t address, uint8_t* data, uint8_t length, uint8_t sendStop) { + uint8_t i; + + // ensure data will fit into buffer + if (TWI_BUFFER_LENGTH < length) { + return 0; + } + + // wait until twi is ready, become master receiver + while (TWI_READY != twi_state) { + continue; + } + twi_state = TWI_MRX; + twi_sendStop = sendStop; + // reset error state (0xFF.. no error occured) + twi_error = 0xFF; + + // initialize buffer iteration vars + twi_masterBufferIndex = 0; + twi_masterBufferLength = length - 1; // This is not intuitive, read on... + // On receive, the previously configured ACK/NACK setting is transmitted in + // response to the received byte before the interrupt is signalled. + // Therefor we must actually set NACK when the _next_ to last byte is + // received, causing that NACK to be sent in response to receiving the last + // expected byte of data. + + // build sla+w, slave device address + w bit + twi_slarw = TW_READ; + twi_slarw |= address << 1; + + if (true == twi_inRepStart) { + // if we're in the repeated start state, then we've already sent the start, + // (@@@ we hope), and the TWI statemachine is just waiting for the address byte. + // We need to remove ourselves from the repeated start state before we enable interrupts, + // since the ISR is ASYNC, and we could get confused if we hit the ISR before cleaning + // up. Also, don't enable the START interrupt. There may be one pending from the + // repeated start that we sent ourselves, and that would really confuse things. + twi_inRepStart = false; // remember, we're dealing with an ASYNC ISR + do { + TWDR = twi_slarw; + } while (TWCR & _BV(TWWC)); + TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE); // enable INTs, but not START + } else + // send start condition + TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTA); + + // wait for read operation to complete + while (TWI_MRX == twi_state) { + continue; + } + + if (twi_masterBufferIndex < length) + length = twi_masterBufferIndex; + + // copy twi buffer to data + for (i = 0; i < length; ++i) { + data[i] = twi_masterBuffer[i]; + } + + return length; +} + +/* + * Function twi_writeTo + * Desc attempts to become twi bus master and write a + * series of bytes to a device on the bus + * Input address: 7bit i2c device address + * data: pointer to byte array + * length: number of bytes in array + * wait: boolean indicating to wait for write or not + * sendStop: boolean indicating whether or not to send a stop at the end + * Output 0 .. success + * 1 .. length to long for buffer + * 2 .. address send, NACK received + * 3 .. data send, NACK received + * 4 .. other twi error (lost bus arbitration, bus error, ..) + */ +uint8_t twi_writeTo(uint8_t address, uint8_t* data, uint8_t length, uint8_t wait, uint8_t sendStop) { + uint8_t i; + + // ensure data will fit into buffer + if (TWI_BUFFER_LENGTH < length) { + return 1; + } + + // wait until twi is ready, become master transmitter + while (TWI_READY != twi_state) { + continue; + } + twi_state = TWI_MTX; + twi_sendStop = sendStop; + // reset error state (0xFF.. no error occured) + twi_error = 0xFF; + + // initialize buffer iteration vars + twi_masterBufferIndex = 0; + twi_masterBufferLength = length; + + // copy data to twi buffer + for (i = 0; i < length; ++i) { + twi_masterBuffer[i] = data[i]; + } + + // build sla+w, slave device address + w bit + twi_slarw = TW_WRITE; + twi_slarw |= address << 1; + + // if we're in a repeated start, then we've already sent the START + // in the ISR. Don't do it again. + // + if (true == twi_inRepStart) { + // if we're in the repeated start state, then we've already sent the start, + // (@@@ we hope), and the TWI statemachine is just waiting for the address byte. + // We need to remove ourselves from the repeated start state before we enable interrupts, + // since the ISR is ASYNC, and we could get confused if we hit the ISR before cleaning + // up. Also, don't enable the START interrupt. There may be one pending from the + // repeated start that we sent outselves, and that would really confuse things. + twi_inRepStart = false; // remember, we're dealing with an ASYNC ISR + do { + TWDR = twi_slarw; + } while (TWCR & _BV(TWWC)); + TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE); // enable INTs, but not START + } else + // send start condition + TWCR = _BV(TWINT) | _BV(TWEA) | _BV(TWEN) | _BV(TWIE) | _BV(TWSTA); // enable INTs + + // wait for write operation to complete + while (wait && (TWI_MTX == twi_state)) { + continue; + } + + switch (twi_error) { + case 0xFF: + return 0; // success + case TW_MT_SLA_NACK: + return 2; // error: address send, nack received + case TW_MT_DATA_NACK: + return 3; // error: data send, nack received + default: + return 4; // other twi error + } +} + +/* + * Function twi_transmit + * Desc fills slave tx buffer with data + * must be called in slave tx event callback + * Input data: pointer to byte array + * length: number of bytes in array + * Output 1 length too long for buffer + * 2 not slave transmitter + * 0 ok + */ +uint8_t twi_transmit(const uint8_t* data, uint8_t length) { + uint8_t i; + + // ensure data will fit into buffer + if (TWI_BUFFER_LENGTH < (twi_txBufferLength + length)) { + return 1; + } + + // ensure we are currently a slave transmitter + if (TWI_STX != twi_state) { + return 2; + } + + // set length and copy data into tx buffer + for (i = 0; i < length; ++i) { + twi_txBuffer[twi_txBufferLength + i] = data[i]; + } + twi_txBufferLength += length; + + return 0; +} + +/* + * Function twi_attachSlaveRxEvent + * Desc sets function called before a slave read operation + * Input function: callback function to use + * Output none + */ +void twi_attachSlaveRxEvent(void (*function)(uint8_t*, int)) { + twi_onSlaveReceive = function; +} + +/* + * Function twi_attachSlaveTxEvent + * Desc sets function called before a slave write operation + * Input function: callback function to use + * Output none + */ +void twi_attachSlaveTxEvent(void (*function)(void)) { + twi_onSlaveTransmit = function; +} + +/* + * Function twi_reply + * Desc sends byte or readys receive line + * Input ack: byte indicating to ack or to nack + * Output none + */ +void twi_reply(uint8_t ack) { + // transmit master read ready signal, with or without ack + if (ack) { + TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT) | _BV(TWEA); + } else { + TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWINT); + } +} + +/* + * Function twi_stop + * Desc relinquishes bus master status + * Input none + * Output none + */ +void twi_stop(void) { + // send stop condition + TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT) | _BV(TWSTO); + + // wait for stop condition to be exectued on bus + // TWINT is not set after a stop condition! + while (TWCR & _BV(TWSTO)) { + continue; + } + + // update twi state + twi_state = TWI_READY; +} + +/* + * Function twi_releaseBus + * Desc releases bus control + * Input none + * Output none + */ +void twi_releaseBus(void) { + // release bus + TWCR = _BV(TWEN) | _BV(TWIE) | _BV(TWEA) | _BV(TWINT); + + // update twi state + twi_state = TWI_READY; +} + +ISR(TWI_vect) { + switch (TW_STATUS) { + // All Master + case TW_START: // sent start condition + /* Falls through. */ + case TW_REP_START: // sent repeated start condition + // copy device address and r/w bit to output register and ack + TWDR = twi_slarw; + twi_reply(1); + break; + + // Master Transmitter + case TW_MT_SLA_ACK: // slave receiver acked address + /* Falls through. */ + case TW_MT_DATA_ACK: // slave receiver acked data + // if there is data to send, send it, otherwise stop + if (twi_masterBufferIndex < twi_masterBufferLength) { + // copy data to output register and ack + TWDR = twi_masterBuffer[twi_masterBufferIndex++]; + twi_reply(1); + } else { + if (twi_sendStop) + twi_stop(); + else { + twi_inRepStart = true; // we're gonna send the START + // don't enable the interrupt. We'll generate the start, but we + // avoid handling the interrupt until we're in the next transaction, + // at the point where we would normally issue the start. + TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN) ; + twi_state = TWI_READY; + } + } + break; + case TW_MT_SLA_NACK: // address sent, nack received + twi_error = TW_MT_SLA_NACK; + twi_stop(); + break; + case TW_MT_DATA_NACK: // data sent, nack received + twi_error = TW_MT_DATA_NACK; + twi_stop(); + break; + case TW_MT_ARB_LOST: // lost bus arbitration + twi_error = TW_MT_ARB_LOST; + twi_releaseBus(); + break; + + // Master Receiver + case TW_MR_DATA_ACK: // data received, ack sent + // put byte into buffer + twi_masterBuffer[twi_masterBufferIndex++] = TWDR; + /* intentionally fall through */ + case TW_MR_SLA_ACK: // address sent, ack received + // ack if more bytes are expected, otherwise nack + if (twi_masterBufferIndex < twi_masterBufferLength) { + twi_reply(1); + } else { + twi_reply(0); + } + break; + case TW_MR_DATA_NACK: // data received, nack sent + // put final byte into buffer + twi_masterBuffer[twi_masterBufferIndex++] = TWDR; + if (twi_sendStop) + twi_stop(); + else { + twi_inRepStart = true; // we're gonna send the START + // don't enable the interrupt. We'll generate the start, but we + // avoid handling the interrupt until we're in the next transaction, + // at the point where we would normally issue the start. + TWCR = _BV(TWINT) | _BV(TWSTA) | _BV(TWEN) ; + twi_state = TWI_READY; + } + break; + case TW_MR_SLA_NACK: // address sent, nack received + twi_stop(); + break; + // TW_MR_ARB_LOST handled by TW_MT_ARB_LOST case + +#if ENABLE_TWI_SLAVE_MODE + // Slave Receiver + case TW_SR_SLA_ACK: // addressed, returned ack + /* Falls through. */ + case TW_SR_GCALL_ACK: // addressed generally, returned ack + /* Falls through. */ + case TW_SR_ARB_LOST_SLA_ACK: // lost arbitration, returned ack + /* Falls through. */ + case TW_SR_ARB_LOST_GCALL_ACK: // lost arbitration, returned ack + // enter slave receiver mode + twi_state = TWI_SRX; + // indicate that rx buffer can be overwritten and ack + twi_rxBufferIndex = 0; + twi_reply(1); + break; + case TW_SR_DATA_ACK: // data received, returned ack + /* Falls through. */ + case TW_SR_GCALL_DATA_ACK: // data received generally, returned ack + // if there is still room in the rx buffer + if (twi_rxBufferIndex < TWI_BUFFER_LENGTH) { + // put byte in buffer and ack + twi_rxBuffer[twi_rxBufferIndex++] = TWDR; + twi_reply(1); + } else { + // otherwise nack + twi_reply(0); + } + break; + case TW_SR_STOP: // stop or repeated start condition received + // ack future responses and leave slave receiver state + twi_releaseBus(); + // put a null char after data if there's room + if (twi_rxBufferIndex < TWI_BUFFER_LENGTH) { + twi_rxBuffer[twi_rxBufferIndex] = '\0'; + } + // callback to user defined callback + twi_onSlaveReceive(twi_rxBuffer, twi_rxBufferIndex); + // since we submit rx buffer to "wire" library, we can reset it + twi_rxBufferIndex = 0; + break; + case TW_SR_DATA_NACK: // data received, returned nack + /* Falls through. */ + case TW_SR_GCALL_DATA_NACK: // data received generally, returned nack + // nack back at master + twi_reply(0); + break; + + // Slave Transmitter + case TW_ST_SLA_ACK: // addressed, returned ack + /* Falls through. */ + case TW_ST_ARB_LOST_SLA_ACK: // arbitration lost, returned ack + // enter slave transmitter mode + twi_state = TWI_STX; + // ready the tx buffer index for iteration + twi_txBufferIndex = 0; + // set tx buffer length to be zero, to verify if user changes it + twi_txBufferLength = 0; + // request for txBuffer to be filled and length to be set + // note: user must call twi_transmit(bytes, length) to do this + twi_onSlaveTransmit(); + // if they didn't change buffer & length, initialize it + if (0 == twi_txBufferLength) { + twi_txBufferLength = 1; + twi_txBuffer[0] = 0x00; + } + // transmit first byte from buffer, fall through + case TW_ST_DATA_ACK: // byte sent, ack returned + // copy data to output register + TWDR = twi_txBuffer[twi_txBufferIndex++]; + // if there is more to send, ack, otherwise nack + if (twi_txBufferIndex < twi_txBufferLength) { + twi_reply(1); + } else { + twi_reply(0); + } + break; + case TW_ST_DATA_NACK: // received nack, we are done + /* Falls through. */ + case TW_ST_LAST_DATA: // received ack, but we are done already! + // ack future responses + twi_reply(1); + // leave slave receiver state + twi_state = TWI_READY; + break; +#endif + + // All + case TW_NO_INFO: // no state information + break; + case TW_BUS_ERROR: // bus error, illegal stop/start + twi_error = TW_BUS_ERROR; + twi_stop(); + break; + } +} + +#endif diff --git a/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/twi.h b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/twi.h new file mode 100644 index 00000000..773ce9cb --- /dev/null +++ b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/twi.h @@ -0,0 +1,57 @@ +/* + twi.h - TWI/I2C library for Wiring & Arduino + Copyright (c) 2006 Nicholas Zambetti. All right reserved. + + This library is free software: you can redistribute it and/or modify it under + the terms of the GNU Lesser General Public License as published by the Free + Software Foundation, either version 3 of the License, or (at your option) any + later version. + + This library is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more + details. + + You should have received a copy of the GNU Lesser General Public License along + with this program. If not, see . +*/ + +#pragma once + +#ifdef __AVR__ + +#ifndef KALEIDOSCOPE_VIRTUAL_BUILD + +#include + +//#define ATMEGA8 + +#ifndef TWI_FREQ +#define TWI_FREQ 100000L +#endif + +#ifndef TWI_BUFFER_LENGTH +#define TWI_BUFFER_LENGTH 192 +#endif + +#define TWI_READY 0 +#define TWI_MRX 1 +#define TWI_MTX 2 +#define TWI_SRX 3 +#define TWI_STX 4 + +void twi_init(void); +void twi_disable(void); +void twi_setAddress(uint8_t); +void twi_setFrequency(uint32_t); +uint8_t twi_readFrom(uint8_t, uint8_t*, uint8_t, uint8_t); +uint8_t twi_writeTo(uint8_t, uint8_t*, uint8_t, uint8_t, uint8_t); +uint8_t twi_transmit(const uint8_t*, uint8_t); +void twi_attachSlaveRxEvent(void (*)(uint8_t*, int)); +void twi_attachSlaveTxEvent(void (*)(void)); +void twi_reply(uint8_t); +void twi_stop(void); +void twi_releaseBus(void); + +#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD +#endif diff --git a/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/.Model01Side.cpp.swp b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/.Model01Side.cpp.swp new file mode 100644 index 0000000000000000000000000000000000000000..288da4248214c9c090ac4e901276b2a8a9110b38 GIT binary patch literal 16384 zcmeI3U2No5702C=Ev2-8sDM79yV;hV?9OM>MXRK{)R}QMZYDFS$4Lm;Xz&0lbJN> z2T&DJkMh%u?Q@UMJ@?*o?>%-}#btGY9nVil_`Fk+KGk}@`C8=MQ=?o77PUm0Y za|_7@xrLd>+NrBdL{M1 z|D6Y}ktQcfMXJ`Jv4iZ|cP;(j)iAA4>Veb)sRvRIq#j5;ka{5XK|H9| zfyai;vgi@7s1=j}OzY)B~vpQV*maNIj5xAoW1%fz$)32T~8D9!Ncq zdf7~7 z;MJ1U0q+Bky-kwN0}pJ1GvE}M1toADcrUmL{OT%6dICHSz6S0Gp9BFo4c5SMAc23r zRg!)So(4YvUk4Y!N5CSef?I$JE(MQYDM^ojhrvZ~H)w*>;0QPj-VLq*e|?K2Jqw-! zkAg?QU7!h0gB!r_u0TD(o#2DuB*=lI;0PE88E_apb3l@Q3ho16244a-a07VZa!L9V zcpm%_d>4EgECU@hz_s8?Z~*)QNtiEy)8HU@8g2F)@ECX${2crYJOaK7z5?z99|vu4 zJvao$0JS#*uja#8-*&^}&5-##=sO`h!NP&v9Qby~buVLBmY-#o5gJ*hRFws#rZ+Nl zIG$ytEGv#rOFJ6q{MtG++-`QQ3)3)ywYEYI&0*hnn`aHD&vCVgE4U{cdR=2`%IAiq z@eMl&xt~c)f|_x5J5}QXbVX`nJB9W{?!RfezM?kE3zcS7sWcmlYI9aoZe3Dp<<%@} z`~0JQ?wVVuo2b}G4FVpb42sMqVi_T{U5ctwD6mc#_JXNGVK5lv@xBY{;N?xTz}T8I~!+$wA*V@#@Yvicv}7 z`yfw08$1*WU@U{RY}?#CE^#)1-dxZ3LeKP^oawniXyARGe229?e^)~cHQByyLl4=r zv3L6__D)j8T#0!uwWcfDvRvKI zIJ|!pn1-vm=#6k)=CvC~#a-?*y#GW$8GImAy|M?F6|JGxYx|kD%zf$(|A9$(Yl<`o zlQuZobhqOu4!rK;Yj;y1%5cZncWCWy5iztxi8pdsQ5Wp@5chb%sFh8lk4|c^mK`#$ z&Cb{%T3w8~Rj<#2j@NfA3_jc4q|5jbFeB>B&93d*-F~j& zK*z`Eu$2EmbTn}cN5%Z{=%_^3iuuV{v?Pv76Y*hmv6L(3<1?gAH#Sj;xTm69L?Htq zr-$f@H~MUM0~Is9K6T{8rWQv~;AlD1G5kmZ9iH*CD1fsqNSoYB!cJ7v-6JB;RyZ^J zJ|bV}Y%$A&Uwi~2nh_AOhC{z$6-(1n67@%-F9KEQdyd0>8B-P_Uot>6G5JKd_R+&a zyfuhwB+`s#IEV*%rX#BIb3JZ`++v8l8=Rqiin+khkVMfe+cAI5ry6n4j z&NdwTHg4r|)FqkFj7UrYr>1C4b)wvqD;2FdBR3Rw9+#;yBvvd@z~-SW&Wu!R=pdR+ zVlleIwj*9*0n|aYbjadu+vPhGx8eKajAa5?>9sTBsKDYQaky4oA0OW?x3}fRbH|QL zl52E%&@)U<{WX5W6E^Lfj$Y3kIW_$HCfR?;c1@>`8Eb6#N+Eu+6Vs397fu=7u2J^T zJIoM4E8iKT*4VEkKWk(5+_9(t*H96D4xQFzW96~Y`wqF6#J1JmB*znT=OmfgcHv1j zFIN?{Qg4*&i%N4@)$}E~+MHQZs}-ztjuZfE)Mxb-SyS?KP+!tneU{ZVrq)=wj!sb4 z5!l&^s?RZfPT7_w5jtK%zrfErerv3v$W^s=szHTuf)rL&c}A_OI+h|UbBd6{MHzpQ zV%!Y3(KQ@qnO@g$`&iqG+EB7g*3<@6vRSRZkR^rkl0H}08YG5Ft!nD2Ii1bbs})Q^ zY(^0`tSW34*X7zOD_3Q8ANT}CtHA`ZkjzunYIUY8V^zr-b8@ws)Kpzqtg1>S3yE@dsX|82z?-$Y4x1KK z9bs3m3!lN;nq1RWvS*epC|Y?Ahl!uaH1cfHE=+B(MXkQ9R-j=_hI1QZa3&gr8Y|Yd zN}8y?^J)zyC?8tXsA_c$+DM_{I0zs;8{yLPvCwLX6%qzN>v=wPQkJ7zAwt2pDXK$a|EQhW$PzEIBc!i@ssn9)tTMjJ5)Q)w%Z@2m(PQpY7m3FBVDqbKTa>pTM zwmW)@fgNJX6k8J%7Xcs}JA&$zTz2fP9U`z}O+%Fyt`){5b8HZ|gQ%Vn1fFSQ%C_LN z=xz0=Y}N`m#M5YRD{jRy92a$lOnID56idf)6UB)lWAkxb&D&^K)itHU5jGqrr>3Gn zIW@Ht@1~}PBAP_||L3rmJdgb-?f;YK`wwBy|5?xkC%{eM25>$2JNEzI0}p_^!5yFn z9Iy#&&;c9ZdT;<-4t|gPz;oatI1e;X09S)&kuP`{d>?!Z+y}l0J`e5%n_v~JfMswa zcn^31xr3*{Q{YMP1h^O612{MVD97*&@&@;Uo5AzQ3H%V;0~|nkf}6o4m;eXBCEzE> z2mBcP2z(BhAP-(d4&WmA4(NhSa0c86t^|L;zW*Wc32-Zz1~0&PDk5J|W z%l0fA@WYgx@o3HI^?l|I+#%bLcu4H0RI5lvk@hTh8zPS-kv6Ck%j;;DF*yOF&%!71 zPNCybx(k_`!`RDUQBP(eUu0OgU&uI?@5mLgSuF8My-`DhKZLw6Bb=}4ac_{nrLr^0mO(mpXs!w#M={*C6Ye9SlYNCKa3PqGK z`q&asBZkN``7DZ+Fk(31?=0&@beWnGQcZI^1%h5my*ldIE;1YOy{PhJHub`h(S7Lxyft5+dZ??NTHVbstnYQ>$7+e5 zp+{@UDcW|T_9DrMwE;Hb=;>Y7ay)aBhOwKV!6{N6#Z2@W%R!eot#EYb&!aupE~6F?+E*;5ON4#&y$ zdr15s!Xhe*;O6jlD2j+FBN9gn1ZfLobX*=qR6LA9#zdqt5E(?8(?Mz=dKj``n?52e pDc%**@SF)*Vv+z5T*fyQDi54uO|X*l0a$q@xYZ!{{qecX{`VN literal 0 HcmV?d00001 diff --git a/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model01Side.cpp b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model01Side.cpp new file mode 100644 index 00000000..374d1986 --- /dev/null +++ b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model01Side.cpp @@ -0,0 +1,214 @@ +/* kaleidoscope::driver::keyboardio::Model01Side + * Copyright (C) 2015-2020 Keyboard.io, Inc + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef KALEIDOSCOPE_VIRTUAL_BUILD + +#include +#include "Model01Side.h" + +extern "C" { +#include "kaleidoscope/device/keyboardio/twi.h" +} + +#include "kaleidoscope/driver/color/GammaCorrection.h" + +namespace kaleidoscope { +namespace driver { +namespace keyboardio { + +#define SCANNER_I2C_ADDR_BASE 0x58 +#define ELEMENTS(arr) (sizeof(arr) / sizeof((arr)[0])) + +uint8_t twi_uninitialized = 1; + +Model01Side::Model01Side(byte setAd01) { + ad01 = setAd01; + addr = SCANNER_I2C_ADDR_BASE | ad01; + if (twi_uninitialized--) { + twi_init(); + } +} + +// Returns the relative controller addresss. The expected range is 0-3 +uint8_t Model01Side::controllerAddress() { + return ad01; +} + +// Sets the keyscan interval. We currently do three reads. +// before declaring a key event debounced. +// +// Takes an integer value representing a counter. +// +// 0 - 0.1-0.25ms +// 1 - 0.125ms +// 10 - 0.35ms +// 25 - 0.8ms +// 50 - 1.6ms +// 100 - 3.15ms +// +// You should think of this as the _minimum_ keyscan interval. +// LED updates can cause a bit of jitter. +// +// returns the Wire.endTransmission code (0 = success) +// https://www.arduino.cc/en/Reference/WireEndTransmission +byte Model01Side::setKeyscanInterval(byte delay) { + uint8_t data[] = {TWI_CMD_KEYSCAN_INTERVAL, delay}; + uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0); + + return result; +} + + + + +// returns -1 on error, otherwise returns the scanner version integer +int Model01Side::readVersion() { + return readRegister(TWI_CMD_VERSION); +} + +// returns -1 on error, otherwise returns the scanner keyscan interval +int Model01Side::readKeyscanInterval() { + return readRegister(TWI_CMD_KEYSCAN_INTERVAL); +} + + +// returns -1 on error, otherwise returns the LED SPI Frequncy +int Model01Side::readLEDSPIFrequency() { + return readRegister(TWI_CMD_LED_SPI_FREQUENCY); +} + +// Set the LED SPI Frequency. See wire-protocol-constants.h for +// values. +// +// returns the Wire.endTransmission code (0 = success) +// https://www.arduino.cc/en/Reference/WireEndTransmission +byte Model01Side::setLEDSPIFrequency(byte frequency) { + uint8_t data[] = {TWI_CMD_LED_SPI_FREQUENCY, frequency}; + uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0); + + return result; +} + + + +int Model01Side::readRegister(uint8_t cmd) { + + byte return_value = 0; + + uint8_t data[] = {cmd}; + uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0); + + + + delayMicroseconds(15); // We may be able to drop this in the future + // but will need to verify with correctly + // sized pull-ups on both the left and right + // hands' i2c SDA and SCL lines + + uint8_t rxBuffer[1]; + + // perform blocking read into buffer + uint8_t read = twi_readFrom(addr, rxBuffer, ELEMENTS(rxBuffer), true); + if (read > 0) { + return rxBuffer[0]; + } else { + return -1; + } + +} + + +// gives information on the key that was just pressed or released. +bool Model01Side::readKeys() { + + uint8_t rxBuffer[5]; + + // perform blocking read into buffer + uint8_t read = twi_readFrom(addr, rxBuffer, ELEMENTS(rxBuffer), true); + if (rxBuffer[0] == TWI_REPLY_KEYDATA) { + keyData.rows[0] = rxBuffer[1]; + keyData.rows[1] = rxBuffer[2]; + keyData.rows[2] = rxBuffer[3]; + keyData.rows[3] = rxBuffer[4]; + return true; + } else { + return false; + } +} + +keydata_t Model01Side::getKeyData() { + return keyData; +} + +void Model01Side::sendLEDData() { + sendLEDBank(nextLEDBank++); + if (nextLEDBank == LED_BANKS) { + nextLEDBank = 0; + } +} + +auto constexpr gamma8 = kaleidoscope::driver::color::gamma_correction; + +void Model01Side::sendLEDBank(byte bank) { + uint8_t data[LED_BYTES_PER_BANK + 1]; + data[0] = TWI_CMD_LED_BASE + bank; + for (uint8_t i = 0 ; i < LED_BYTES_PER_BANK; i++) { + /* While the ATTiny controller does have a global brightness command, it is + * limited to 32 levels, and those aren't nicely spread out either. For this + * reason, we're doing our own brightness adjustment on this side, because + * that results in a considerably smoother curve. */ + uint8_t c = ledData.bytes[bank][i]; + if (c > brightness_adjustment_) + c -= brightness_adjustment_; + else + c = 0; + + data[i + 1] = pgm_read_byte(&gamma8[c]); + } + uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0); +} + +void Model01Side::setAllLEDsTo(cRGB color) { + uint8_t data[] = {TWI_CMD_LED_SET_ALL_TO, + pgm_read_byte(&gamma8[color.b]), + pgm_read_byte(&gamma8[color.g]), + pgm_read_byte(&gamma8[color.r]) + }; + uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0); +} + +void Model01Side::setOneLEDTo(byte led, cRGB color) { + uint8_t data[] = {TWI_CMD_LED_SET_ONE_TO, + led, + pgm_read_byte(&gamma8[color.b]), + pgm_read_byte(&gamma8[color.g]), + pgm_read_byte(&gamma8[color.r]) + }; + uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0); + +} + +} // namespace keyboardio +} // namespace driver +} // namespace kaleidoscope + +#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD diff --git a/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model01Side.h b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model01Side.h new file mode 100644 index 00000000..1e1743f3 --- /dev/null +++ b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model01Side.h @@ -0,0 +1,106 @@ +// -*- mode: c++ -*- +/* kaleidoscope::driver::keyboardio::Model01Side + * Copyright (C) 2015-2020 Keyboard.io, Inc + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#pragma once + +#include +#include "wire-protocol-constants.h" + +// We allow cRGB/CRGB to be defined already when this is included. +// +#ifndef CRGB +struct cRGB { + uint8_t b; + uint8_t g; + uint8_t r; +}; +#define CRGB(r,g,b) (cRGB){b, g, r} +#endif + +#define LED_BANKS 4 + +#define LEDS_PER_HAND 32 +#define LED_BYTES_PER_BANK sizeof(cRGB) * LEDS_PER_HAND/LED_BANKS + +namespace kaleidoscope { +namespace driver { +namespace keyboardio { + +typedef union { + cRGB leds[LEDS_PER_HAND]; + byte bytes[LED_BANKS][LED_BYTES_PER_BANK]; +} LEDData_t; + +typedef union { + uint8_t rows[4]; + uint32_t all; +} keydata_t; + +// config options + +#ifndef KALEIDOSCOPE_VIRTUAL_BUILD +// used to configure interrupts, configuration for a particular controller +class Model01Side { + public: + explicit Model01Side(byte setAd01); + ~Model01Side() {} + + int readVersion(); + + byte setKeyscanInterval(byte delay); + int readKeyscanInterval(); + + byte setLEDSPIFrequency(byte frequency); + int readLEDSPIFrequency(); + + void sendLEDData(); + void setOneLEDTo(byte led, cRGB color); + void setAllLEDsTo(cRGB color); + keydata_t getKeyData(); + bool readKeys(); + LEDData_t ledData; + uint8_t controllerAddress(); + + void setBrightness(uint8_t brightness) { + brightness_adjustment_ = 255 - brightness; + } + uint8_t getBrightness() { + return 255 - brightness_adjustment_; + } + + private: + uint8_t brightness_adjustment_ = 0; + int addr; + int ad01; + keydata_t keyData; + byte nextLEDBank = 0; + void sendLEDBank(byte bank); + int readRegister(uint8_t cmd); +}; +#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD +class Model01Side; +#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD + +} // namespace keyboardio +} // namespace driver +} // namespace kaleidoscope diff --git a/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/wire-protocol-constants.h b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/wire-protocol-constants.h new file mode 100644 index 00000000..67c4ca0b --- /dev/null +++ b/plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/wire-protocol-constants.h @@ -0,0 +1,51 @@ +/* KeyboardioScanner + * Copyright (C) 2015-2018 Keyboard.io, Inc + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#pragma once + +#define TWI_CMD_NONE 0x00 +#define TWI_CMD_VERSION 0x01 +#define TWI_CMD_KEYSCAN_INTERVAL 0x02 +#define TWI_CMD_LED_SET_ALL_TO 0x03 +#define TWI_CMD_LED_SET_ONE_TO 0x04 +#define TWI_CMD_COLS_USE_PULLUPS 0x05 +#define TWI_CMD_LED_SPI_FREQUENCY 0x06 + +#define LED_SPI_FREQUENCY_4MHZ 0x07 +#define LED_SPI_FREQUENCY_2MHZ 0x06 +#define LED_SPI_FREQUENCY_1MHZ 0x05 +#define LED_SPI_FREQUENCY_512KHZ 0x04 +#define LED_SPI_FREQUENCY_256KHZ 0x03 +#define LED_SPI_FREQUENCY_128KHZ 0x02 +#define LED_SPI_FREQUENCY_64KHZ 0x01 +#define LED_SPI_OFF 0x00 + + +// 512KHZ seems to be the sweet spot in early testing +// so make it the default +#define LED_SPI_FREQUENCY_DEFAULT LED_SPI_FREQUENCY_512KHZ + + +#define TWI_CMD_LED_BASE 0x80 + +#define TWI_REPLY_NONE 0x00 +#define TWI_REPLY_KEYDATA 0x01