alpha
/
Kaleidoscope
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Format codebase with `clang-format`

Browse Source 
Signed-off-by: Michael Richters <gedankenexperimenter@gmail.com>
pull/1143/head
Michael Richters 2 years ago
parent dfd9bff7bd
commit e5d67efd58
No known key found for this signature in database
GPG Key ID: 1288FD13E4EEF0C0
294 changed files with 3486 additions and 3626 deletions
Show Stats Download Patch File Download Diff File

8
examples/Features/AppSwitcher/AppSwitcher.cpp
Unescape View File

@ -64,16 +64,16 @@ EventHandlerResult AppSwitcher::onKeyEvent(KeyEvent &event) {
// have any effect. Then we turn the event for that key's press into an
// event for the release of the AppSwitcher's modifier key.
live_keys.mask(event.addr);
event.addr = active_addr_;
event.addr = active_addr_;
event.state = WAS_PRESSED | INJECTED;
event.key = live_keys[event.addr];
event.key = live_keys[event.addr];
// Turn off AppSwitcher:
active_addr_.clear();
}
return EventHandlerResult::OK;
}
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
kaleidoscope::plugin::AppSwitcher AppSwitcher;

5
examples/Features/AppSwitcher/AppSwitcher.h
Unescape View File

@ -34,10 +34,9 @@ class AppSwitcher : public kaleidoscope::Plugin {
private:
KeyAddr active_addr_ = KeyAddr::none();
};
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
extern kaleidoscope::plugin::AppSwitcher AppSwitcher;

13
plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShift.cpp
Unescape View File

@ -34,8 +34,8 @@ namespace plugin {
// Configuration settings that can be saved to persistent storage.
AutoShift::Settings AutoShift::settings_ = {
.enabled = true,
.timeout = 175,
.enabled = true,
.timeout = 175,
.enabled_categories = AutoShift::Categories::printableKeys(),
};
@ -62,8 +62,7 @@ void AutoShift::disable() {
// -----------------------------------------------------------------------------
// Test for whether or not to apply AutoShift to a given `Key`. This function
// can be overridden from the user sketch.
__attribute__((weak))
bool AutoShift::isAutoShiftable(Key key) {
__attribute__((weak)) bool AutoShift::isAutoShiftable(Key key) {
return enabledForKey(key);
}
@ -207,7 +206,7 @@ void AutoShift::flushEvent(bool is_long_press) {
return;
KeyEvent event = queue_.event(0);
if (is_long_press) {
event.key = Runtime.lookupKey(event.addr);
event.key = Runtime.lookupKey(event.addr);
uint8_t flags = event.key.getFlags();
flags ^= SHIFT_HELD;
event.key.setFlags(flags);
@ -216,7 +215,7 @@ void AutoShift::flushEvent(bool is_long_press) {
Runtime.handleKeyswitchEvent(event);
}
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
kaleidoscope::plugin::AutoShift AutoShift;

21
plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShift.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint8_t, uint16_t
#include <stdint.h> // for uint8_t, uint16_t
#include "kaleidoscope/KeyAddrEventQueue.h" // for KeyAddrEventQueue
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
@ -63,16 +63,17 @@ class AutoShift : public Plugin {
uint8_t raw_bits_{0};
// constants for bits in the `raw_bits_` bitfield
static constexpr uint8_t LETTERS = 1 << 0;
static constexpr uint8_t NUMBERS = 1 << 1;
static constexpr uint8_t SYMBOLS = 1 << 2;
static constexpr uint8_t ARROWS = 1 << 3;
static constexpr uint8_t FUNCTIONS = 1 << 4;
static constexpr uint8_t ALL = 1 << 7;
static constexpr uint8_t LETTERS = 1 << 0;
static constexpr uint8_t NUMBERS = 1 << 1;
static constexpr uint8_t SYMBOLS = 1 << 2;
static constexpr uint8_t ARROWS = 1 << 3;
static constexpr uint8_t FUNCTIONS = 1 << 4;
static constexpr uint8_t ALL = 1 << 7;
public:
// Basic un-checked constructor
constexpr Categories(uint8_t raw_bits) : raw_bits_(raw_bits) {}
constexpr Categories(uint8_t raw_bits)
: raw_bits_(raw_bits) {}
static constexpr Categories letterKeys() {
return Categories(LETTERS);
@ -276,8 +277,8 @@ class AutoShiftConfig : public Plugin {
static uint16_t settings_base_;
};
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
extern kaleidoscope::plugin::AutoShift AutoShift;
extern kaleidoscope::plugin::AutoShiftConfig AutoShiftConfig;

12
plugins/Kaleidoscope-AutoShift/src/kaleidoscope/plugin/AutoShiftConfig.cpp
Unescape View File

@ -17,10 +17,10 @@
#include "kaleidoscope/plugin/AutoShift.h" // IWYU pragma: associated
#include <Arduino.h> // for PSTR, strcmp_P, str...
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t, uint8_t
#include <Arduino.h> // for PSTR, strcmp_P, str...
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t, uint8_t
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/device/Base.h" // for Base<>::Storage
@ -118,7 +118,7 @@ EventHandlerResult AutoShiftConfig::onFocusEvent(const char *command) {
return EventHandlerResult::EVENT_CONSUMED;
}
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
kaleidoscope::plugin::AutoShiftConfig AutoShiftConfig;

18
plugins/Kaleidoscope-CharShift/src/kaleidoscope/plugin/CharShift.cpp
Unescape View File

@ -17,9 +17,9 @@
#include "kaleidoscope/plugin/CharShift.h"
#include <Arduino.h> // for F, __FlashS...
#include <Kaleidoscope-FocusSerial.h> // for Focus, Focu...
#include <Kaleidoscope-Ranges.h> // for CS_FIRST
#include <Arduino.h> // for F, __FlashS...
#include <Kaleidoscope-FocusSerial.h> // for Focus, Focu...
#include <Kaleidoscope-Ranges.h> // for CS_FIRST
#include "kaleidoscope/KeyAddrMap.h" // for KeyAddrMap<...
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
@ -38,7 +38,7 @@ namespace plugin {
// =============================================================================
// CharShift class variables
CharShift::KeyPair const * CharShift::progmem_keypairs_{nullptr};
CharShift::KeyPair const *CharShift::progmem_keypairs_{nullptr};
uint8_t CharShift::num_keypairs_{0};
bool CharShift::reverse_shift_state_{false};
@ -131,13 +131,15 @@ CharShift::KeyPair CharShift::decodeCharShiftKey(Key key) {
// This should be overridden if the KeyPairs array is stored in EEPROM
__attribute__((weak))
uint8_t CharShift::numKeyPairs() {
uint8_t
CharShift::numKeyPairs() {
return numProgmemKeyPairs();
}
// This should be overridden if the KeyPairs array is stored in EEPROM
__attribute__((weak))
CharShift::KeyPair CharShift::readKeyPair(uint8_t n) {
CharShift::KeyPair
CharShift::readKeyPair(uint8_t n) {
return readKeyPairFromProgmem(n);
}
@ -149,7 +151,7 @@ CharShift::KeyPair CharShift::readKeyPairFromProgmem(uint8_t n) {
return cloneFromProgmem(progmem_keypairs_[n]);
}
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
kaleidoscope::plugin::CharShift CharShift;

29
plugins/Kaleidoscope-CharShift/src/kaleidoscope/plugin/CharShift.h
Unescape View File

@ -17,8 +17,8 @@
#pragma once
#include <Kaleidoscope-Ranges.h> // for CS_FIRST
#include <stdint.h> // for uint8_t
#include <Kaleidoscope-Ranges.h> // for CS_FIRST
#include <stdint.h> // for uint8_t
#include "Arduino.h" // for PROGMEM
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
@ -59,7 +59,8 @@ class CharShift : public Plugin {
///
/// This constructor is used when defining an array of `KeyPair` objects in
/// PROGMEM (though it can also be used elsewhere).
constexpr KeyPair(Key lower, Key upper) : lower(lower), upper(upper) {}
constexpr KeyPair(Key lower, Key upper)
: lower(lower), upper(upper) {}
/// Constructor for reading from PROGMEM
///
@ -75,15 +76,15 @@ class CharShift : public Plugin {
/// `keypairs` array given, which must be a fixed-sized array, not a pointer.
/// Generally, it will be called via the `KEYPAIRS()` preprocessor macro, not
/// directly by user code.
template <uint8_t _num_keypairs>
static void setProgmemKeyPairs(KeyPair const(&keypairs)[_num_keypairs]) {
template<uint8_t _num_keypairs>
static void setProgmemKeyPairs(KeyPair const (&keypairs)[_num_keypairs]) {
progmem_keypairs_ = keypairs;
num_keypairs_ = _num_keypairs;
num_keypairs_ = _num_keypairs;
}
private:
// A pointer to an array of `KeyPair` objects in PROGMEM
static KeyPair const * progmem_keypairs_;
static KeyPair const *progmem_keypairs_;
// The size of the PROGMEM array of `KeyPair` objects
static uint8_t num_keypairs_;
@ -114,8 +115,8 @@ class CharShift : public Plugin {
static KeyPair readKeyPairFromProgmem(uint8_t n);
};
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
extern kaleidoscope::plugin::CharShift CharShift;
@ -125,12 +126,12 @@ extern kaleidoscope::plugin::CharShift CharShift;
/// defines them as an array in PROGMEM, and configures `CharShift` to use that
/// array, automatically setting the count correctly to prevent out-of-bounds
/// lookups.
#define CS_KEYS(keypairs...) { \
#define CS_KEYS(keypairs...) \
{ \
static kaleidoscope::plugin::CharShift::KeyPair const kp_table[] PROGMEM = { \
keypairs \
}; \
CharShift.setProgmemKeyPairs(kp_table); \
}
keypairs}; \
CharShift.setProgmemKeyPairs(kp_table); \
}
/// Define an `KeyPair` entry in a keymap
///

13
plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/Colormap.cpp
Unescape View File

@ -17,10 +17,10 @@
#include "kaleidoscope/plugin/Colormap.h"
#include <Arduino.h> // for F, PSTR, __FlashStrin...
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <Kaleidoscope-LED-Palette-Theme.h> // for LEDPaletteTheme
#include <stdint.h> // for uint8_t, uint16_t
#include <Arduino.h> // for F, PSTR, __FlashStrin...
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <Kaleidoscope-LED-Palette-Theme.h> // for LEDPaletteTheme
#include <stdint.h> // for uint8_t, uint16_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
@ -40,7 +40,7 @@ void ColormapEffect::max_layers(uint8_t max_) {
return;
max_layers_ = max_;
map_base_ = ::LEDPaletteTheme.reserveThemes(max_layers_);
map_base_ = ::LEDPaletteTheme.reserveThemes(max_layers_);
}
EventHandlerResult ColormapEffect::onNameQuery() {
@ -68,8 +68,7 @@ EventHandlerResult ColormapEffect::onLayerChange() {
}
EventHandlerResult ColormapEffect::onFocusEvent(const char *command) {
return ::LEDPaletteTheme.themeFocusEvent(command, PSTR("colormap.map"),
map_base_, max_layers_);
return ::LEDPaletteTheme.themeFocusEvent(command, PSTR("colormap.map"), map_base_, max_layers_);
}
} // namespace plugin

13
plugins/Kaleidoscope-Colormap/src/kaleidoscope/plugin/Colormap.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint8_t, uin...
#include <stdint.h> // for uint8_t, uin...
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/event_handler_result.h" // for EventHandler...
@ -29,8 +29,8 @@
namespace kaleidoscope {
namespace plugin {
class ColormapEffect : public Plugin,
public LEDModeInterface,
public AccessTransientLEDMode {
public LEDModeInterface,
public AccessTransientLEDMode {
public:
ColormapEffect(void) {}
@ -44,21 +44,20 @@ class ColormapEffect : public Plugin,
//
class TransientLEDMode : public LEDMode {
public:
// Please note that storing the parent ptr is only required
// for those LED modes that require access to
// members of their parent class. Most LED modes can do without.
//
explicit TransientLEDMode(const ColormapEffect *parent) : parent_(parent) {}
explicit TransientLEDMode(const ColormapEffect *parent)
: parent_(parent) {}
protected:
friend class ColormapEffect;
void onActivate(void) final;
void refreshAt(KeyAddr key_addr) final;
private:
private:
const ColormapEffect *parent_;
};

11
plugins/Kaleidoscope-Cycle/src/kaleidoscope/plugin/Cycle.cpp
Unescape View File

@ -17,10 +17,10 @@
#include "kaleidoscope/plugin/Cycle.h"
#include <Arduino.h> // for F, __FlashStringHelper
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <Kaleidoscope-Ranges.h> // for CYCLE
#include <stdint.h> // for uint8_t
#include <Arduino.h> // for F, __FlashStringHelper
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <Kaleidoscope-Ranges.h> // for CYCLE
#include <stdint.h> // for uint8_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr, MatrixAddr
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
@ -113,8 +113,7 @@ uint8_t Cycle::toModFlag(uint8_t keyCode) {
} // namespace plugin
} // namespace kaleidoscope
__attribute__((weak))
void cycleAction(Key previous_key, uint8_t cycle_count) {
__attribute__((weak)) void cycleAction(Key previous_key, uint8_t cycle_count) {
}
kaleidoscope::plugin::Cycle Cycle;

12
plugins/Kaleidoscope-Cycle/src/kaleidoscope/plugin/Cycle.h
Unescape View File

@ -17,8 +17,8 @@
#pragma once
#include <Kaleidoscope-Ranges.h> // for CYCLE
#include <stdint.h> // for uint8_t
#include <Kaleidoscope-Ranges.h> // for CYCLE
#include <stdint.h> // for uint8_t
#include "Arduino.h" // for PROGMEM
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
@ -29,10 +29,10 @@
constexpr Key Key_Cycle = Key(kaleidoscope::ranges::CYCLE);
#define cycleThrough(...) ({ \
static const Key __k[] PROGMEM = { __VA_ARGS__ }; \
Cycle.replace(sizeof(__k) / sizeof(Key), &__k[0]); \
})
#define cycleThrough(...) ({ \
static const Key __k[] PROGMEM = {__VA_ARGS__}; \
Cycle.replace(sizeof(__k) / sizeof(Key), &__k[0]); \
})
namespace kaleidoscope {
namespace plugin {

9
plugins/Kaleidoscope-CycleTimeReport/src/kaleidoscope/plugin/CycleTimeReport.cpp
Unescape View File

@ -17,9 +17,9 @@
#include "kaleidoscope/plugin/CycleTimeReport.h"
#include <Arduino.h> // for micros, F, __FlashStr...
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t, uint32_t
#include <Arduino.h> // for micros, F, __FlashStr...
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t, uint32_t
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
@ -62,8 +62,7 @@ EventHandlerResult CycleTimeReport::afterEachCycle() {
} // namespace kaleidoscope
__attribute__((weak)) void cycleTimeReport(void) {
Focus.send(Focus.COMMENT, F("average loop time:"), CycleTimeReport.average_loop_time,
Focus.NEWLINE);
Focus.send(Focus.COMMENT, F("average loop time:"), CycleTimeReport.average_loop_time, Focus.NEWLINE);
}
kaleidoscope::plugin::CycleTimeReport CycleTimeReport;

2
plugins/Kaleidoscope-CycleTimeReport/src/kaleidoscope/plugin/CycleTimeReport.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint32_t, uint16_t
#include <stdint.h> // for uint32_t, uint16_t
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
#include "kaleidoscope/plugin.h" // for Plugin

42
plugins/Kaleidoscope-Devel-ArduinoTrace/src/ArduinoTrace.h
Unescape View File

@ -57,7 +57,7 @@ constexpr size_t strlen(const char *str) {
return str[0] ? strlen(str + 1) + 1 : 0;
}
template <char... chars>
template<char... chars>
struct string {
#if ARDUINOTRACE_ENABLE_PROGMEM
const __FlashStringHelper *data() {
@ -72,52 +72,47 @@ struct string {
#endif
};
template <typename TSourceString, size_t remainingLength,
char... collectedChars>
template<typename TSourceString, size_t remainingLength, char... collectedChars>
struct string_maker {
using result =
typename string_maker < TSourceString, remainingLength - 1,
TSourceString::data()[remainingLength - 1],
collectedChars... >::result;
typename string_maker<TSourceString, remainingLength - 1, TSourceString::data()[remainingLength - 1], collectedChars...>::result;
};
#if ARDUINOTRACE_ENABLE_FULLPATH == 0
template <typename TSourceString, size_t remainingLength,
char... collectedChars>
template<typename TSourceString, size_t remainingLength, char... collectedChars>
struct string_maker<TSourceString, remainingLength, '/', collectedChars...> {
using result = string<collectedChars..., '\0'>;
};
template <typename TSourceString, size_t remainingLength,
char... collectedChars>
template<typename TSourceString, size_t remainingLength, char... collectedChars>
struct string_maker<TSourceString, remainingLength, '\\', collectedChars...> {
using result = string<collectedChars..., '\0'>;
};
#endif
template <typename TSourceString, char... collectedChars>
template<typename TSourceString, char... collectedChars>
struct string_maker<TSourceString, 0, collectedChars...> {
using result = string<collectedChars..., '\0'>;
};
template <typename TStringSource>
template<typename TStringSource>
using make_string =
typename string_maker<TStringSource, strlen(TStringSource::data())>::result;
struct Initializer {
template <typename TSerial>
template<typename TSerial>
Initializer(TSerial &serial, int bauds) {
serial.begin(bauds);
while (!serial) continue;
}
};
template <typename TFilename, typename TPrefix>
template<typename TFilename, typename TPrefix>
struct Printer {
template <typename TSerial, typename TValue>
template<typename TSerial, typename TValue>
Printer(TSerial &serial, const TValue &content) {
serial.print(make_string<TFilename> {}.data());
serial.print(make_string<TPrefix> {}.data());
serial.print(make_string<TFilename>{}.data());
serial.print(make_string<TPrefix>{}.data());
serial.println(content);
serial.flush();
}
@ -154,7 +149,7 @@ struct Printer {
#define ARDUINOTRACE_INITIALIZE(id, bauds) \
ArduinoTrace::Initializer ARDUINOTRACE_CONCAT(__initializer, id)( \
ARDUINOTRACE_SERIAL, bauds);
ARDUINOTRACE_SERIAL, bauds);
#define ARDUINOTRACE_TRACE_PREFIX(line) ":" ARDUINOTRACE_STRINGIFY(line) ": "
@ -172,19 +167,16 @@ struct Printer {
// Call this macro anywhere, including at global scope.
// However, if you use it at global scope, you need to call ARDUINOTRACE_INIT()
// first, otherwise, the Serial port will not be ready.
#define TRACE() \
ARDUINOTRACE_PRINT(__COUNTER__, __FILE__, \
ARDUINOTRACE_TRACE_PREFIX(__LINE__), \
ARDUINOTRACE_FUNCTION_NAME)
#define TRACE() \
ARDUINOTRACE_PRINT(__COUNTER__, __FILE__, ARDUINOTRACE_TRACE_PREFIX(__LINE__), ARDUINOTRACE_FUNCTION_NAME)
// Prints the value of a variable.
//
// This function will print the name and the value of the variable to the
// Serial. If you use it at global scope, you need to call ARDUINOTRACE_INIT()
// first, otherwise, the Serial port will not be ready.
#define DUMP(variable) \
ARDUINOTRACE_PRINT(__COUNTER__, __FILE__, \
ARDUINOTRACE_DUMP_PREFIX(__LINE__, variable), variable)
#define DUMP(variable) \
ARDUINOTRACE_PRINT(__COUNTER__, __FILE__, ARDUINOTRACE_DUMP_PREFIX(__LINE__, variable), variable)
#else // ie ARDUINOTRACE_ENABLE == 0

2
plugins/Kaleidoscope-DynamicMacros/src/Kaleidoscope-DynamicMacros.h
Unescape View File

@ -16,6 +16,6 @@
#pragma once
#include <Kaleidoscope-Macros.h> // IWYU pragma: keep
#include <Kaleidoscope-Macros.h> // IWYU pragma: keep
#include "kaleidoscope/plugin/DynamicMacros.h" // IWYU pragma: export

32
plugins/Kaleidoscope-DynamicMacros/src/kaleidoscope/plugin/DynamicMacros.cpp
Unescape View File

@ -16,16 +16,16 @@
#include "kaleidoscope/plugin/DynamicMacros.h"
#include <Arduino.h> // for delay, PSTR, strc...
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <Kaleidoscope-Ranges.h> // for DYNAMIC_MACRO_FIRST
#include <Arduino.h> // for delay, PSTR, strc...
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <Kaleidoscope-Ranges.h> // for DYNAMIC_MACRO_FIRST
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/device/device.h" // for VirtualProps::Sto...
#include "kaleidoscope/keyswitch_state.h" // for INJECTED, IS_PRESSED
#include "kaleidoscope/plugin/EEPROM-Settings.h" // for EEPROMSettings
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/device/device.h" // for VirtualProps::Sto...
#include "kaleidoscope/keyswitch_state.h" // for INJECTED, IS_PRESSED
#include "kaleidoscope/plugin/EEPROM-Settings.h" // for EEPROMSettings
// This is a special exception to the rule of only including a plugin's
// top-level header file, because DynamicMacros doesn't depend on the Macros
@ -67,9 +67,9 @@ void DynamicMacros::tap(Key key) {
}
void DynamicMacros::updateDynamicMacroCache() {
uint16_t pos = storage_base_;
uint8_t current_id = 0;
macro_t macro = MACRO_ACTION_END;
uint16_t pos = storage_base_;
uint8_t current_id = 0;
macro_t macro = MACRO_ACTION_END;
bool previous_macro_ended = false;
map_[0] = 0;
@ -103,7 +103,7 @@ void DynamicMacros::updateDynamicMacroCache() {
previous_macro_ended = false;
uint8_t keyCode, flags;
do {
flags = Runtime.storage().read(pos++);
flags = Runtime.storage().read(pos++);
keyCode = Runtime.storage().read(pos++);
} while (!(flags == 0 && keyCode == 0));
break;
@ -132,7 +132,7 @@ void DynamicMacros::updateDynamicMacroCache() {
// public
void DynamicMacros::play(uint8_t macro_id) {
macro_t macro = MACRO_ACTION_END;
macro_t macro = MACRO_ACTION_END;
uint8_t interval = 0;
uint16_t pos;
Key key;
@ -289,7 +289,7 @@ void DynamicMacros::reserve_storage(uint16_t size) {
updateDynamicMacroCache();
}
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
kaleidoscope::plugin::DynamicMacros DynamicMacros;

10
plugins/Kaleidoscope-DynamicMacros/src/kaleidoscope/plugin/DynamicMacros.h
Unescape View File

@ -16,15 +16,15 @@
#pragma once
#include <Kaleidoscope-Ranges.h> // for DYNAMIC_MACRO_FIRST
#include <stdint.h> // for uint16_t, uint8_t
#include <Kaleidoscope-Ranges.h> // for DYNAMIC_MACRO_FIRST
#include <stdint.h> // for uint16_t, uint8_t
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
#include "kaleidoscope/key_defs.h" // for Key
#include "kaleidoscope/plugin.h" // for Plugin
#define DM(n) ::kaleidoscope::plugin::DynamicMacrosKey(n)
#define DM(n) ::kaleidoscope::plugin::DynamicMacrosKey(n)
#define MAX_CONCURRENT_DYNAMIC_MACRO_KEYS 8
@ -56,7 +56,7 @@ class DynamicMacros : public kaleidoscope::Plugin {
static void tap(Key key);
};
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
extern kaleidoscope::plugin::DynamicMacros DynamicMacros;

21
plugins/Kaleidoscope-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.cpp
Unescape View File

@ -17,10 +17,10 @@
#include "kaleidoscope/plugin/DynamicTapDance.h"
#include <Arduino.h> // for PSTR, F, __FlashStrin...
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t, uint8_t
#include <Arduino.h> // for PSTR, F, __FlashStrin...
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t, uint8_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
@ -42,12 +42,12 @@ uint8_t DynamicTapDance::dance_count_;
constexpr uint8_t DynamicTapDance::reserved_tap_dance_key_count_;
void DynamicTapDance::updateDynamicTapDanceCache() {
uint16_t pos = storage_base_;
uint8_t current_id = 0;
uint16_t pos = storage_base_;
uint8_t current_id = 0;
bool previous_dance_ended = false;
dance_count_ = 0;
map_[0] = 0;
map_[0] = 0;
while (pos < storage_base_ + storage_size_) {
uint16_t raw_key = Runtime.storage().read(pos);
@ -68,9 +68,8 @@ void DynamicTapDance::updateDynamicTapDanceCache() {
}
}
bool DynamicTapDance::dance(uint8_t tap_dance_index, KeyAddr key_addr,
uint8_t tap_count, TapDance::ActionType tap_dance_action) {
uint16_t pos = map_[tap_dance_index - offset_] + ((tap_count - 1) * 2);
bool DynamicTapDance::dance(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, TapDance::ActionType tap_dance_action) {
uint16_t pos = map_[tap_dance_index - offset_] + ((tap_count - 1) * 2);
uint16_t next_pos = map_[tap_dance_index - offset_ + 1];
if (next_pos <= pos || (tap_dance_index > offset_ + dance_count_))
return false;
@ -136,7 +135,7 @@ EventHandlerResult DynamicTapDance::onFocusEvent(const char *command) {
void DynamicTapDance::setup(uint8_t dynamic_offset, uint16_t size) {
storage_base_ = ::EEPROMSettings.requestSlice(size);
storage_size_ = size;
offset_ = dynamic_offset;
offset_ = dynamic_offset;
updateDynamicTapDanceCache();
}

11
plugins/Kaleidoscope-DynamicTapDance/src/kaleidoscope/plugin/DynamicTapDance.h
Unescape View File

@ -17,9 +17,9 @@
#pragma once
#include <Kaleidoscope-Ranges.h> // for TD_FIRST, TD_LAST
#include <Kaleidoscope-TapDance.h> // for TapDance, TapDance::A...
#include <stdint.h> // for uint8_t, uint16_t
#include <Kaleidoscope-Ranges.h> // for TD_FIRST, TD_LAST
#include <Kaleidoscope-TapDance.h> // for TapDance, TapDance::A...
#include <stdint.h> // for uint8_t, uint16_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
@ -28,7 +28,7 @@
namespace kaleidoscope {
namespace plugin {
class DynamicTapDance: public kaleidoscope::Plugin {
class DynamicTapDance : public kaleidoscope::Plugin {
public:
DynamicTapDance() {}
@ -37,8 +37,7 @@ class DynamicTapDance: public kaleidoscope::Plugin {
static void setup(uint8_t dynamic_offset, uint16_t size);
static bool dance(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count,
TapDance::ActionType tap_dance_action);
static bool dance(uint8_t tap_dance_index, KeyAddr key_addr, uint8_t tap_count, TapDance::ActionType tap_dance_action);
private:
static uint16_t storage_base_;

12
plugins/Kaleidoscope-EEPROM-Keymap-Programmer/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.cpp
Unescape View File

@ -17,10 +17,10 @@
#include "kaleidoscope/plugin/EEPROM-Keymap-Programmer.h"
#include <Arduino.h> // for PSTR, strcmp_P
#include <Kaleidoscope-EEPROM-Keymap.h> // for EEPROMKeymap
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t, uint8_t
#include <Arduino.h> // for PSTR, strcmp_P
#include <Kaleidoscope-EEPROM-Keymap.h> // for EEPROMKeymap
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t, uint8_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
@ -60,8 +60,8 @@ void EEPROMKeymapProgrammer::nextState(void) {
void EEPROMKeymapProgrammer::cancel(void) {
update_position_ = 0;
new_key_ = Key_NoKey;
state_ = INACTIVE;
new_key_ = Key_NoKey;
state_ = INACTIVE;
}
EventHandlerResult EEPROMKeymapProgrammer::onKeyEvent(KeyEvent &event) {

2
plugins/Kaleidoscope-EEPROM-Keymap-Programmer/src/kaleidoscope/plugin/EEPROM-Keymap-Programmer.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint16_t
#include <stdint.h> // for uint16_t
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult

20
plugins/Kaleidoscope-EEPROM-Keymap/src/kaleidoscope/plugin/EEPROM-Keymap.cpp
Unescape View File

@ -17,10 +17,10 @@
#include "kaleidoscope/plugin/EEPROM-Keymap.h"
#include <Arduino.h> // for PSTR, strcmp_P, F
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint8_t, uint16_t
#include <Arduino.h> // for PSTR, strcmp_P, F
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint8_t, uint16_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr, MatrixAddr
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
@ -57,7 +57,7 @@ void EEPROMKeymap::setup(uint8_t max) {
}
void EEPROMKeymap::max_layers(uint8_t max) {
max_layers_ = max;
max_layers_ = max;
keymap_base_ = ::EEPROMSettings.requestSlice(max_layers_ * Runtime.device().numKeys() * 2);
}
@ -67,8 +67,8 @@ Key EEPROMKeymap::getKey(uint8_t layer, KeyAddr key_addr) {
uint16_t pos = ((layer * Runtime.device().numKeys()) + key_addr.toInt()) * 2;
return Key(Runtime.storage().read(keymap_base_ + pos + 1), // key_code
Runtime.storage().read(keymap_base_ + pos)); // flags
return Key(Runtime.storage().read(keymap_base_ + pos + 1), // key_code
Runtime.storage().read(keymap_base_ + pos)); // flags
}
Key EEPROMKeymap::getKeyExtended(uint8_t layer, KeyAddr key_addr) {
@ -91,7 +91,7 @@ void EEPROMKeymap::updateKey(uint16_t base_pos, Key key) {
Runtime.storage().update(keymap_base_ + base_pos * 2 + 1, key.getKeyCode());
}
void EEPROMKeymap::dumpKeymap(uint8_t layers, Key(*getkey)(uint8_t, KeyAddr)) {
void EEPROMKeymap::dumpKeymap(uint8_t layers, Key (*getkey)(uint8_t, KeyAddr)) {
for (uint8_t layer = 0; layer < layers; layer++) {
for (auto key_addr : KeyAddr::all()) {
Key k = (*getkey)(layer, key_addr);
@ -134,7 +134,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
// we actully want.
//
dumpKeymap(progmem_layers_,
static_cast<Key(*)(uint8_t, KeyAddr)>(Layer_::getKeyFromPROGMEM));
static_cast<Key (*)(uint8_t, KeyAddr)>(Layer_::getKeyFromPROGMEM));
return EventHandlerResult::EVENT_CONSUMED;
}
@ -146,7 +146,7 @@ EventHandlerResult EEPROMKeymap::onFocusEvent(const char *command) {
// tell the compiler which overload of getKey
// we actually want.
//
dumpKeymap(max_layers_, static_cast<Key(*)(uint8_t, KeyAddr)>(getKey));
dumpKeymap(max_layers_, static_cast<Key (*)(uint8_t, KeyAddr)>(getKey));
} else {
uint16_t i = 0;

4
plugins/Kaleidoscope-EEPROM-Keymap/src/kaleidoscope/plugin/EEPROM-Keymap.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint8_t, uint16_t
#include <stdint.h> // for uint8_t, uint16_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
@ -57,7 +57,7 @@ class EEPROMKeymap : public kaleidoscope::Plugin {
static Key parseKey(void);
static void printKey(Key key);
static void dumpKeymap(uint8_t layers, Key(*getkey)(uint8_t, KeyAddr));
static void dumpKeymap(uint8_t layers, Key (*getkey)(uint8_t, KeyAddr));
};
} // namespace plugin

8
plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings.cpp
Unescape View File

@ -17,9 +17,9 @@
#include "kaleidoscope/plugin/EEPROM-Settings.h"
#include <Arduino.h> // for PSTR, strcmp_P, F
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t, uint8_t
#include <Arduino.h> // for PSTR, strcmp_P, F
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t, uint8_t
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/device/device.h" // for VirtualProps::S...
@ -47,7 +47,7 @@ EventHandlerResult EEPROMSettings::onSetup() {
uninitialized state, we do not override them, to avoid overwriting user
settings. */
settings_.ignore_hardcoded_layers = false;
settings_.default_layer = 0;
settings_.default_layer = 0;
}
/* If the version is undefined, we'll set it to our current one. */

6
plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint8_t, uint16_t
#include <stdint.h> // for uint8_t, uint16_t
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
#include "kaleidoscope/plugin.h" // for Plugin
@ -74,8 +74,8 @@ class EEPROMSettings : public kaleidoscope::Plugin {
static bool sealed_;
static struct settings {
uint8_t default_layer: 7;
bool ignore_hardcoded_layers: 1;
uint8_t default_layer : 7;
bool ignore_hardcoded_layers : 1;
uint8_t version;
uint16_t crc;
} settings_;

6
plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings/crc.cpp
Unescape View File

@ -28,8 +28,7 @@
#include "crc.h"
void
CRC_::reflect(uint8_t len) {
void CRC_::reflect(uint8_t len) {
uint8_t i;
uint16_t newCRC;
@ -42,8 +41,7 @@ CRC_::reflect(uint8_t len) {
crc = newCRC;
}
void
CRC_::update(const void *data, uint8_t len) {
void CRC_::update(const void *data, uint8_t len) {
const uint8_t *d = (const uint8_t *)data;
uint8_t i;
bool bit;

2
plugins/Kaleidoscope-EEPROM-Settings/src/kaleidoscope/plugin/EEPROM-Settings/crc.h
Unescape View File

@ -34,7 +34,7 @@ class CRC_ {
public:
uint16_t crc = 0;
CRC_(void) {};
CRC_(void){};
void update(const void *data, uint8_t len);
void finalize(void) {

12
plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot-Config.cpp
Unescape View File

@ -17,10 +17,10 @@
#include "kaleidoscope/plugin/Escape-OneShot.h" // IWYU pragma: associated
#include <Arduino.h> // for PSTR, F, __FlashStrin...
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t
#include <Arduino.h> // for PSTR, F, __FlashStrin...
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint16_t
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/device/device.h" // for VirtualProps::Storage
@ -71,7 +71,7 @@ EventHandlerResult EscapeOneShotConfig::onFocusEvent(const char *command) {
return EventHandlerResult::EVENT_CONSUMED;
}
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
kaleidoscope::plugin::EscapeOneShotConfig EscapeOneShotConfig;

5
plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot.cpp
Unescape View File

@ -17,7 +17,7 @@
#include "kaleidoscope/plugin/Escape-OneShot.h"
#include <Kaleidoscope-OneShot.h> // for OneShot
#include <Kaleidoscope-OneShot.h> // for OneShot
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
@ -28,8 +28,7 @@ namespace kaleidoscope {
namespace plugin {
EscapeOneShot::Settings EscapeOneShot::settings_ = {
.cancel_oneshot_key = Key_Escape
};
.cancel_oneshot_key = Key_Escape};
EventHandlerResult EscapeOneShot::onKeyEvent(KeyEvent &event) {
// We only act on an escape key (or `cancel_oneshot_key_`, if that has been

8
plugins/Kaleidoscope-Escape-OneShot/src/kaleidoscope/plugin/Escape-OneShot.h
Unescape View File

@ -17,8 +17,8 @@
#pragma once
#include <Kaleidoscope-Ranges.h> // for OS_CANCEL
#include <stdint.h> // for uint16_t
#include <Kaleidoscope-Ranges.h> // for OS_CANCEL
#include <stdint.h> // for uint16_t
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
@ -27,8 +27,8 @@
// DEPRECATED: `OneShotCancelKey` doesn't match our normal naming, and should
// eventually be removed.
constexpr Key OneShotCancelKey {kaleidoscope::ranges::OS_CANCEL};
constexpr Key Key_OneShotCancel {kaleidoscope::ranges::OS_CANCEL};
constexpr Key OneShotCancelKey{kaleidoscope::ranges::OS_CANCEL};
constexpr Key Key_OneShotCancel{kaleidoscope::ranges::OS_CANCEL};
namespace kaleidoscope {
namespace plugin {

14
plugins/Kaleidoscope-FingerPainter/src/kaleidoscope/plugin/FingerPainter.cpp
Unescape View File

@ -17,11 +17,11 @@
#include "kaleidoscope/plugin/FingerPainter.h"
#include <Arduino.h> // for PSTR, strcmp_P, F
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <Kaleidoscope-LED-Palette-Theme.h> // for LEDPaletteTheme
#include <stdint.h> // for uint16_t, uint8_t
#include <string.h> // for memcmp
#include <Arduino.h> // for PSTR, strcmp_P, F
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <Kaleidoscope-LED-Palette-Theme.h> // for LEDPaletteTheme
#include <stdint.h> // for uint16_t, uint8_t
#include <string.h> // for memcmp
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
@ -71,8 +71,8 @@ EventHandlerResult FingerPainter::onKeyEvent(KeyEvent &event) {
// TODO(anyone): The following works only for keyboards with LEDs for each key.
uint8_t color_index = ::LEDPaletteTheme
.lookupColorIndexAtPosition(color_base_,
Runtime.device().getLedIndex(event.addr));
.lookupColorIndexAtPosition(color_base_,
Runtime.device().getLedIndex(event.addr));
// Find the next color in the palette that is different.
// But do not loop forever!

2
plugins/Kaleidoscope-FingerPainter/src/kaleidoscope/plugin/FingerPainter.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint16_t
#include <stdint.h> // for uint16_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/KeyEvent.h" // for KeyEvent

3
plugins/Kaleidoscope-FirmwareDump/src/kaleidoscope/plugin/FirmwareDump.h
Unescape View File

@ -23,7 +23,7 @@
#ifdef __AVR__
#include <stdint.h> // for uint16_t
#include <stdint.h> // for uint16_t
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
#include "kaleidoscope/plugin.h" // for Plugin
@ -37,6 +37,7 @@ class FirmwareDump : public kaleidoscope::Plugin {
EventHandlerResult onSetup();
EventHandlerResult onFocusEvent(const char *command);
private:
uint16_t bootloader_size_;
};

20
plugins/Kaleidoscope-FocusSerial/src/kaleidoscope/plugin/FocusSerial.cpp
Unescape View File

@ -17,10 +17,10 @@
#include "kaleidoscope/plugin/FocusSerial.h"
#include <Arduino.h> // for __FlashStringHelper, F
#include <HardwareSerial.h> // for HardwareSerial
#include <stdint.h> // for uint8_t
#include <string.h> // for memset
#include <Arduino.h> // for __FlashStringHelper, F
#include <HardwareSerial.h> // for HardwareSerial
#include <stdint.h> // for uint8_t
#include <string.h> // for memset
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
@ -44,10 +44,7 @@ EventHandlerResult FocusSerial::afterEachCycle() {
do {
command_[buf_cursor_++] = Runtime.serialPort().read();
} while (command_[buf_cursor_ - 1] != SEPARATOR
&& buf_cursor_ < sizeof(command_)
&& Runtime.serialPort().available()
&& (Runtime.serialPort().peek() != NEWLINE));
} while (command_[buf_cursor_ - 1] != SEPARATOR && buf_cursor_ < sizeof(command_) && Runtime.serialPort().available() && (Runtime.serialPort().peek() != NEWLINE));
// If there was no command, there's nothing to do
@ -57,9 +54,7 @@ EventHandlerResult FocusSerial::afterEachCycle() {
return EventHandlerResult::OK;
}
if ((command_[buf_cursor_ - 1] != SEPARATOR) && (Runtime.serialPort().peek() != NEWLINE)
&& buf_cursor_ < sizeof(command_)
) {
if ((command_[buf_cursor_ - 1] != SEPARATOR) && (Runtime.serialPort().peek() != NEWLINE) && buf_cursor_ < sizeof(command_)) {
// We don't have enough command to work with yet.
// Let's leave the buffer around for another cycle
return EventHandlerResult::OK;
@ -74,7 +69,7 @@ EventHandlerResult FocusSerial::afterEachCycle() {
// Then process the command
Runtime.onFocusEvent(command_);
while (Runtime.serialPort().available()) {
char c = Runtime.serialPort().read();
char c = Runtime.serialPort().read();
if (c == NEWLINE) {
// newline serves as an end-of-command marker
// don't drain the buffer past there
@ -86,7 +81,6 @@ EventHandlerResult FocusSerial::afterEachCycle() {
buf_cursor_ = 0;
memset(command_, 0, sizeof(command_));
return EventHandlerResult::OK;
}
bool FocusSerial::handleHelp(const char *command,

16
plugins/Kaleidoscope-FocusSerial/src/kaleidoscope/plugin/FocusSerial.h
Unescape View File

@ -17,9 +17,9 @@
#pragma once
#include <Arduino.h> // for __FlashStringHelper
#include <HardwareSerial.h> // for HardwareSerial
#include <stdint.h> // for uint8_t, uint16_t
#include <Arduino.h> // for __FlashStringHelper
#include <HardwareSerial.h> // for HardwareSerial
#include <stdint.h> // for uint8_t, uint16_t
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/device/device.h" // for cRGB
@ -33,9 +33,9 @@ class FocusSerial : public kaleidoscope::Plugin {
public:
FocusSerial(void) {}
static constexpr char COMMENT = '#';
static constexpr char COMMENT = '#';
static constexpr char SEPARATOR = ' ';
static constexpr char NEWLINE = '\n';
static constexpr char NEWLINE = '\n';
bool handleHelp(const char *command,
const char *help_message);
@ -57,19 +57,19 @@ class FocusSerial : public kaleidoscope::Plugin {
printBool(b);
Runtime.serialPort().print(SEPARATOR);
}
template <typename V>
template<typename V>
void send(V v) {
Runtime.serialPort().print(v);
Runtime.serialPort().print(SEPARATOR);
}
template <typename Var, typename... Vars>
template<typename Var, typename... Vars>
void send(Var v, Vars... vars) {
send(v);
send(vars...);
}
void sendRaw() {}
template <typename Var, typename... Vars>
template<typename Var, typename... Vars>
void sendRaw(Var v, Vars... vars) {
Runtime.serialPort().print(v);
sendRaw(vars...);

8
plugins/Kaleidoscope-GhostInTheFirmware/src/kaleidoscope/plugin/GhostInTheFirmware.cpp
Unescape View File

@ -17,7 +17,7 @@
#include "kaleidoscope/plugin/GhostInTheFirmware.h"
#include <stdint.h> // for uint16_t
#include <stdint.h> // for uint16_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
@ -29,7 +29,7 @@
namespace kaleidoscope {
namespace plugin {
const GhostInTheFirmware::GhostKey *GhostInTheFirmware::ghost_keys;
bool GhostInTheFirmware::is_active_ = false;
bool GhostInTheFirmware::is_active_ = false;
uint16_t GhostInTheFirmware::current_pos_ = 0;
uint16_t GhostInTheFirmware::start_time_;
@ -53,9 +53,9 @@ EventHandlerResult GhostInTheFirmware::afterEachCycle() {
// value (i.e. KeyAddr::none()). If we read this sentinel value, reset and
// deactivate.
if (!ghost_key.addr.isValid()) {
current_pos_ = 0;
current_pos_ = 0;
ghost_key.delay = 0;
is_active_ = false;
is_active_ = false;
return EventHandlerResult::OK;
}
// If we're not at the end of the sequence, send the first keypress event,

2
plugins/Kaleidoscope-GhostInTheFirmware/src/kaleidoscope/plugin/GhostInTheFirmware.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint16_t
#include <stdint.h> // for uint16_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult

32
plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/Raise.cpp
Unescape View File

@ -28,13 +28,13 @@
#include "kaleidoscope/driver/keyscanner/Base_Impl.h"
#include "kaleidoscope/util/crc16.h"
#define I2C_CLOCK_KHZ 100
#define I2C_FLASH_CLOCK_KHZ 100 // flashing doesn't work reliably at higher clock speeds
#define I2C_CLOCK_KHZ 100
#define I2C_FLASH_CLOCK_KHZ 100 // flashing doesn't work reliably at higher clock speeds
#define SIDE_POWER 1 // side power switch pa10
#define SIDE_POWER 1 // side power switch pa10
#define LAYOUT_ISO 0
#define LAYOUT_ANSI 1
#define LAYOUT_ISO 0
#define LAYOUT_ANSI 1
namespace kaleidoscope {
namespace device {
@ -148,7 +148,7 @@ void RaiseLEDDriver::setBrightness(uint8_t brightness) {
RaiseHands::leftHand.setBrightness(brightness);
RaiseHands::rightHand.setBrightness(brightness);
for (uint8_t i = 0; i < LED_BANKS; i++) {
isLEDChangedLeft[i] = true;
isLEDChangedLeft[i] = true;
isLEDChangedRight[i] = true;
}
}
@ -159,7 +159,7 @@ uint8_t RaiseLEDDriver::getBrightness() {
void RaiseLEDDriver::syncLeds() {
// left and right sides
for (uint8_t i = 0; i < LED_BANKS; i ++) {
for (uint8_t i = 0; i < LED_BANKS; i++) {
// only send the banks that have changed - try to improve jitter performance
if (isLEDChangedLeft[i]) {
RaiseHands::leftHand.sendLEDBank(i);
@ -180,7 +180,7 @@ void RaiseLEDDriver::syncLeds() {
void RaiseLEDDriver::updateNeuronLED() {
static constexpr struct {
uint8_t r, g, b;
} pins = { 3, 5, 4 };
} pins = {3, 5, 4};
auto constexpr gamma8 = kaleidoscope::driver::color::gamma_correction;
// invert as these are common anode, and make sure we reach 65535 to be able
@ -207,13 +207,13 @@ void RaiseLEDDriver::setCrgbAt(uint8_t i, cRGB crgb) {
// get the SLED index
uint8_t sled_num = led_map[RaiseHands::layout][i];
if (sled_num < LEDS_PER_HAND) {
cRGB oldColor = RaiseHands::leftHand.led_data.leds[sled_num];
cRGB oldColor = RaiseHands::leftHand.led_data.leds[sled_num];
RaiseHands::leftHand.led_data.leds[sled_num] = crgb;
isLEDChangedLeft[uint8_t(sled_num / 8)] |= !(oldColor.r == crgb.r &&
oldColor.g == crgb.g &&
oldColor.b == crgb.b);
} else if (sled_num < 2 * LEDS_PER_HAND) {
cRGB oldColor = RaiseHands::rightHand.led_data.leds[sled_num - LEDS_PER_HAND];
cRGB oldColor = RaiseHands::rightHand.led_data.leds[sled_num - LEDS_PER_HAND];
RaiseHands::rightHand.led_data.leds[sled_num - LEDS_PER_HAND] = crgb;
isLEDChangedRight[uint8_t((sled_num - LEDS_PER_HAND) / 8)] |=
!(oldColor.r == crgb.r &&
@ -253,7 +253,7 @@ void RaiseLEDDriver::setup() {
delay(10);
RaiseHands::setSidePower(true);
delay(500); // wait for sides to power up and finish bootloader
delay(500); // wait for sides to power up and finish bootloader
}
/********* Key scanner *********/
@ -266,7 +266,7 @@ bool RaiseKeyScanner::lastLeftOnline;
bool RaiseKeyScanner::lastRightOnline;
void RaiseKeyScanner::readMatrix() {
previousLeftHandState = leftHandState;
previousLeftHandState = leftHandState;
previousRightHandState = rightHandState;
if (RaiseHands::leftHand.readKeys()) {
@ -275,8 +275,8 @@ void RaiseKeyScanner::readMatrix() {
if (RaiseHands::layout == LAYOUT_ANSI) {
// only swap if bits are different
if ((leftHandState.rows[3] & (1 << 0)) ^ leftHandState.rows[3] & (1 << 1)) {
leftHandState.rows[3] ^= (1 << 0); // flip the bit
leftHandState.rows[3] ^= (1 << 1); // flip the bit
leftHandState.rows[3] ^= (1 << 0); // flip the bit
leftHandState.rows[3] ^= (1 << 1); // flip the bit
}
}
}
@ -305,7 +305,7 @@ void RaiseKeyScanner::readMatrix() {
rightHandState.all = 0;
// store previous state of whether the sides are plugged in
lastLeftOnline = RaiseHands::leftHand.online;
lastLeftOnline = RaiseHands::leftHand.online;
lastRightOnline = RaiseHands::rightHand.online;
}
@ -383,7 +383,7 @@ void RaiseKeyScanner::setup() {
}
void RaiseKeyScanner::reset() {
leftHandState.all = 0;
leftHandState.all = 0;
rightHandState.all = 0;
Runtime.hid().keyboard().releaseAllKeys();
Runtime.hid().keyboard().sendReport();

16
plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/Raise.h
Unescape View File

@ -23,7 +23,8 @@
#include "kaleidoscope/device/dygma/raise/RaiseSide.h"
#define CRGB(r,g,b) (cRGB){b, g, r}
#define CRGB(r, g, b) \
(cRGB) { b, g, r }
#include "kaleidoscope/device/Base.h"
#include "kaleidoscope/driver/bootloader/samd/Bossac.h"
@ -67,6 +68,7 @@ class RaiseLEDDriver : public kaleidoscope::driver::led::Base<RaiseLEDDriverProp
static uint8_t getBrightness();
static void updateNeuronLED();
private:
static bool isLEDChangedNeuron;
static uint8_t isLEDChangedLeft[LED_BANKS];
@ -114,11 +116,11 @@ class RaiseLEDDriver : public kaleidoscope::driver::led::Base<RaiseLEDDriverProp
};
struct RaiseKeyScannerProps : public kaleidoscope::driver::keyscanner::BaseProps {
static constexpr uint8_t matrix_rows = 5;
static constexpr uint8_t matrix_rows = 5;
static constexpr uint8_t matrix_columns = 16;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
static constexpr uint8_t left_columns = 8;
static constexpr uint8_t left_columns = 8;
static constexpr uint8_t right_columns = matrix_columns - left_columns;
};
@ -126,6 +128,7 @@ class RaiseKeyScanner : public kaleidoscope::driver::keyscanner::Base<RaiseKeySc
private:
typedef RaiseKeyScanner ThisType;
typedef RaiseKeyScannerProps Props_;
public:
static void setup();
static void scanMatrix();
@ -161,7 +164,7 @@ struct RaiseSideFlasherProps : public kaleidoscope::util::flasher::BaseProps {};
struct RaiseProps : kaleidoscope::device::BaseProps {
typedef kaleidoscope::driver::hid::KeyboardioProps HIDProps;
typedef kaleidoscope::driver::hid::Keyboardio<HIDProps> HID;
typedef RaiseLEDDriverProps LEDDriverProps;
typedef RaiseLEDDriverProps LEDDriverProps;
typedef RaiseLEDDriver LEDDriver;
typedef RaiseKeyScannerProps KeyScannerProps;
typedef RaiseKeyScanner KeyScanner;
@ -174,9 +177,10 @@ struct RaiseProps : kaleidoscope::device::BaseProps {
static constexpr const char *short_name = "raise";
};
class Raise: public kaleidoscope::device::Base<RaiseProps> {
class Raise : public kaleidoscope::device::Base<RaiseProps> {
private:
static RaiseProps::SideFlasher SideFlasher;
public:
static void setup();
@ -208,7 +212,7 @@ class Raise: public kaleidoscope::device::Base<RaiseProps> {
void prepareForFlash();
// Side bootloader addresses
static constexpr uint8_t left_boot_address = 0x50;
static constexpr uint8_t left_boot_address = 0x50;
static constexpr uint8_t right_boot_address = 0x51;
} side;

60
plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/RaiseSide.cpp
Unescape View File

@ -29,42 +29,42 @@ namespace device {
namespace dygma {
namespace raise {
#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 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 TWI_CMD_LED_GLOBAL_BRIGHTNESS 0x07
#define TWI_CMD_SLED_STATUS 0x08
#define TWI_CMD_LED_OPEN 0x09
#define TWI_CMD_LED_SHORT 0x0A
#define TWI_CMD_JOINED 0x0B
#define TWI_CMD_LAYOUT 0x0C
#define TWI_CMD_SLED_CURRENT 0x0D
#define TWI_CMD_SLED_SELF_TEST 0x0E
#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
#define TWI_CMD_SLED_STATUS 0x08
#define TWI_CMD_LED_OPEN 0x09
#define TWI_CMD_LED_SHORT 0x0A
#define TWI_CMD_JOINED 0x0B
#define TWI_CMD_LAYOUT 0x0C
#define TWI_CMD_SLED_CURRENT 0x0D
#define TWI_CMD_SLED_SELF_TEST 0x0E
#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_CMD_LED_BASE 0x80
#define TWI_REPLY_NONE 0x00
#define TWI_REPLY_KEYDATA 0x01
#define TWI_REPLY_NONE 0x00
#define TWI_REPLY_KEYDATA 0x01
#define ELEMENTS(arr) (sizeof(arr) / sizeof((arr)[0]))
#define ELEMENTS(arr) (sizeof(arr) / sizeof((arr)[0]))
// Returns the relative controller addresss. The expected range is 0-3
uint8_t RaiseSide::controllerAddress() {
@ -221,9 +221,9 @@ void RaiseSide::sendLEDData() {
auto constexpr gamma8 = kaleidoscope::driver::color::gamma_correction;
void RaiseSide::sendLEDBank(uint8_t bank) {
uint8_t data[LED_BYTES_PER_BANK + 1]; // + 1 for the update LED command itself
data[0] = TWI_CMD_LED_BASE + bank;
for (uint8_t i = 0 ; i < LED_BYTES_PER_BANK; i++) {
uint8_t data[LED_BYTES_PER_BANK + 1]; // + 1 for the update LED command itself
data[0] = TWI_CMD_LED_BASE + bank;
for (uint8_t i = 0; i < LED_BYTES_PER_BANK; i++) {
uint8_t c = led_data.bytes[bank][i];
if (c > brightness_adjustment_)
c -= brightness_adjustment_;

11
plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/RaiseSide.h
Unescape View File

@ -35,11 +35,11 @@ namespace device {
namespace dygma {
namespace raise {
#define LED_BANKS 9
#define LED_BANKS 9
#define LEDS_PER_HAND 72
#define LPH LEDS_PER_HAND
#define LEDS_PER_BANK 8
#define LEDS_PER_HAND 72
#define LPH LEDS_PER_HAND
#define LEDS_PER_BANK 8
#define LED_BYTES_PER_BANK (sizeof(cRGB) * LEDS_PER_BANK)
typedef union {
@ -57,7 +57,8 @@ typedef union {
class RaiseSide {
public:
explicit RaiseSide(uint8_t ad01) : ad01_(ad01), twi_(i2c_addr_base_ | ad01) {}
explicit RaiseSide(uint8_t ad01)
: ad01_(ad01), twi_(i2c_addr_base_ | ad01) {}
int readVersion();
int readSLEDVersion();

15
plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/SideFlash.h
Unescape View File

@ -28,10 +28,11 @@ namespace device {
namespace dygma {
namespace raise {
template <typename _Firmware>
template<typename _Firmware>
class SideFlash : public kaleidoscope::Plugin {
private:
_Firmware firmware;
public:
EventHandlerResult onFocusEvent(const char *command) {
if (::Focus.handleHelp(command, PSTR("hardware.flash_left_side\nhardware.flash_right_side\nhardware.verify_left_side\nhardware.verify_right_side")))
@ -40,8 +41,8 @@ class SideFlash : public kaleidoscope::Plugin {
if (strncmp_P(command, PSTR("hardware."), 9) != 0)
return EventHandlerResult::OK;
auto sideFlasher = Runtime.device().sideFlasher();
uint8_t left_boot_address = Runtime.device().side.left_boot_address;
auto sideFlasher = Runtime.device().sideFlasher();
uint8_t left_boot_address = Runtime.device().side.left_boot_address;
uint8_t right_boot_address = Runtime.device().side.right_boot_address;
enum {
FLASH,
@ -51,16 +52,16 @@ class SideFlash : public kaleidoscope::Plugin {
if (strcmp_P(command + 9, PSTR("flash_left_side")) == 0) {
sub_command = FLASH;
address = left_boot_address;
address = left_boot_address;
} else if (strcmp_P(command + 9, PSTR("flash_right_side")) == 0) {
sub_command = FLASH;
address = right_boot_address;
address = right_boot_address;
} else if (strcmp_P(command + 9, PSTR("verify_left_side")) == 0) {
sub_command = VERIFY;
address = left_boot_address;
address = left_boot_address;
} else if (strcmp_P(command + 9, PSTR("verify_right_side")) == 0) {
sub_command = VERIFY;
address = right_boot_address;
address = right_boot_address;
} else {
return EventHandlerResult::OK;
}

8
plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/TWI.cpp
Unescape View File

@ -32,7 +32,7 @@ uint8_t TWI::writeTo(uint8_t *data, size_t length) {
Wire.beginTransmission(addr_);
// calc cksum
uint16_t crc16 = 0xffff;
uint16_t crc16 = 0xffff;
uint8_t *buffer = data;
for (uint8_t i = 0; i < length; i++) {
crc16 = _crc_ccitt_update(crc16, *buffer);
@ -50,12 +50,12 @@ uint8_t TWI::writeTo(uint8_t *data, size_t length) {
return 0;
}
uint8_t TWI::readFrom(uint8_t* data, size_t length) {
uint8_t TWI::readFrom(uint8_t *data, size_t length) {
uint8_t counter = 0;
uint32_t timeout;
uint8_t *buffer = data;
if (!Wire.requestFrom(addr_, length + 2, true)) { // + 2 for the cksum
if (!Wire.requestFrom(addr_, length + 2, true)) { // + 2 for the cksum
// in case slave is not responding - return 0 (0 length of received data).
return 0;
}
@ -65,7 +65,7 @@ uint8_t TWI::readFrom(uint8_t* data, size_t length) {
counter++;
}
uint16_t crc16 = 0xffff;
uint16_t crc16 = 0xffff;
uint16_t rx_cksum = (Wire.read() << 8) + Wire.read();
for (uint8_t i = 0; i < length; i++) {
crc16 = _crc_ccitt_update(crc16, *buffer);

5
plugins/Kaleidoscope-Hardware-Dygma-Raise/src/kaleidoscope/device/dygma/raise/TWI.h
Unescape View File

@ -29,10 +29,11 @@ namespace raise {
class TWI {
public:
explicit TWI(int addr) : addr_(addr), crc_errors_(0) {}
explicit TWI(int addr)
: addr_(addr), crc_errors_(0) {}
uint8_t writeTo(uint8_t *data, size_t length);
uint8_t readFrom(uint8_t* data, size_t length);
uint8_t readFrom(uint8_t *data, size_t length);
void disable();
void init(uint16_t clock_khz);
uint8_t crc_errors() {

17
plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox.cpp
Unescape View File

@ -53,12 +53,12 @@ void ErgoDox::setup(void) {
TCCR1A = 0b10101001;
TCCR1B = 0b00001001;
DDRB &= ~(1 << 4);
DDRB &= ~(1 << 4);
PORTB &= ~(1 << 4);
DDRC &= ~(1 << 7);
DDRD &= ~(1 << 5 | 1 << 4);
DDRE &= ~(1 << 6);
DDRC &= ~(1 << 7);
DDRD &= ~(1 << 5 | 1 << 4);
DDRE &= ~(1 << 6);
PORTC |= (1 << 7);
PORTD |= (1 << 5 | 1 << 4);
PORTE |= (1 << 6);
@ -75,7 +75,7 @@ void ErgoDox::setup(void) {
const uint32_t cycles = (F_CPU / 2000000) * 1700;
ICR1 = cycles;
ICR1 = cycles;
TCCR1B = _BV(WGM13) | _BV(CS10);
TIMSK1 = _BV(TOIE1);
@ -148,9 +148,8 @@ void ErgoDox::setStatusLED(uint8_t led, bool state) {
}
void ErgoDox::setStatusLEDBrightness(uint8_t led, uint8_t brightness) {
(led == 1) ? (OCR1A = brightness) :
(led == 2) ? (OCR1B = brightness) :
(OCR1C = brightness);
(led == 1) ? (OCR1A = brightness) : (led == 2) ? (OCR1B = brightness)
: (OCR1C = brightness);
}
uint8_t ErgoDox::debounceMaskForRow(uint8_t row) {
@ -215,4 +214,4 @@ uint8_t ErgoDox::pressedKeyswitchCount() {
} // namespace kaleidoscope
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

12
plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox.h
Unescape View File

@ -33,14 +33,15 @@ struct cRGB {
uint8_t r, g, b;
};
#define CRGB(r,g,b) (cRGB){b, g, r}
#define CRGB(r, g, b) \
(cRGB) { b, g, r }
#include "kaleidoscope/device/ATmega32U4Keyboard.h"
#include "kaleidoscope/driver/bootloader/avr/HalfKay.h"
#include "kaleidoscope/driver/keyscanner/Base.h"
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#include "kaleidoscope/device/ez/ErgoDox/ErgoDoxScanner.h"
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
namespace kaleidoscope {
namespace device {
@ -48,10 +49,9 @@ namespace ez {
struct ErgoDoxProps : public kaleidoscope::device::ATmega32U4KeyboardProps {
struct KeyScannerProps : kaleidoscope::driver::keyscanner::BaseProps {
static constexpr uint8_t matrix_rows = 14;
static constexpr uint8_t matrix_rows = 14;
static constexpr uint8_t matrix_columns = 6;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
};
typedef kaleidoscope::driver::bootloader::avr::HalfKay Bootloader;
static constexpr const char *short_name = "ErgoDox-EZ";
@ -92,9 +92,9 @@ class ErgoDox : public kaleidoscope::device::ATmega32U4Keyboard<ErgoDoxProps> {
static void debounceRow(uint8_t change, uint8_t row);
static void readMatrixRow(uint8_t row);
};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class ErgoDox;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// clang-format off

46
plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox/ErgoDoxScanner.cpp
Unescape View File

@ -34,17 +34,17 @@
#include "kaleidoscope/device/avr/pins_and_ports.h"
#include "kaleidoscope/device/ez/ErgoDox/i2cmaster.h"
#define I2C_ADDR 0b0100000
#define I2C_ADDR_WRITE ( (I2C_ADDR<<1) | I2C_WRITE )
#define I2C_ADDR_READ ( (I2C_ADDR<<1) | I2C_READ )
#define IODIRA 0x00
#define IODIRB 0x01
#define GPPUA 0x0C
#define GPPUB 0x0D
#define GPIOA 0x12
#define GPIOB 0x13
#define OLATA 0x14
#define OLATB 0x15
#define I2C_ADDR 0b0100000
#define I2C_ADDR_WRITE ((I2C_ADDR << 1) | I2C_WRITE)
#define I2C_ADDR_READ ((I2C_ADDR << 1) | I2C_READ)
#define IODIRA 0x00
#define IODIRB 0x01
#define GPPUA 0x0C
#define GPPUB 0x0D
#define GPIOA 0x12
#define GPIOB 0x13
#define OLATA 0x14
#define OLATB 0x15
namespace kaleidoscope {
namespace device {
@ -90,20 +90,19 @@ out:
return status;
}
void
ErgoDoxScanner::begin() {
void ErgoDoxScanner::begin() {
expander_error_ = initExpander();
// Init columns
DDRF &= ~(1 << 7 | 1 << 6 | 1 << 5 | 1 << 4 | 1 << 1 | 1 << 0);
DDRF &= ~(1 << 7 | 1 << 6 | 1 << 5 | 1 << 4 | 1 << 1 | 1 << 0);
PORTF |= (1 << 7 | 1 << 6 | 1 << 5 | 1 << 4 | 1 << 1 | 1 << 0);
// Init rows
DDRB |= (1 << 0 | 1 << 1 | 1 << 2 | 1 << 3);
DDRB |= (1 << 0 | 1 << 1 | 1 << 2 | 1 << 3);
PORTB |= (1 << 0 | 1 << 1 | 1 << 2 | 1 << 3);
DDRD |= (1 << 2 | 1 << 3);
DDRD |= (1 << 2 | 1 << 3);
PORTD |= (1 << 2 | 1 << 3);
DDRC |= (1 << 6);
DDRC |= (1 << 6);
PORTC |= (1 << 6);
}
@ -118,13 +117,13 @@ void __attribute__((optimize(3))) ErgoDoxScanner::selectExtenderRow(int row) {
expander_error_ = i2c_write(0xFF & ~(1 << row));
if (expander_error_)
goto out;
out:
out:
i2c_stop();
}
}
void __attribute__((optimize(3))) ErgoDoxScanner::toggleATMegaRow(int row) {
static uint8_t row_pins[] = { PIN_B0, PIN_B1, PIN_B2, PIN_B3, PIN_D2, PIN_D3, PIN_C6 };
static uint8_t row_pins[] = {PIN_B0, PIN_B1, PIN_B2, PIN_B3, PIN_D2, PIN_D3, PIN_C6};
OUTPUT_TOGGLE(row_pins[row]);
}
@ -148,7 +147,7 @@ ErgoDoxScanner::readCols(int row) {
data = i2c_readNak();
data = ~data;
out:
out:
i2c_stop();
return data;
} else {
@ -156,8 +155,7 @@ out:
}
}
void
ErgoDoxScanner::reattachExpanderOnError() {
void ErgoDoxScanner::reattachExpanderOnError() {
static uint32_t start_time = millis();
if (!expander_error_)
@ -167,7 +165,7 @@ ErgoDoxScanner::reattachExpanderOnError() {
return;
expander_error_ = initExpander();
start_time = millis();
start_time = millis();
}
} // namespace ez
@ -175,4 +173,4 @@ ErgoDoxScanner::reattachExpanderOnError() {
} // namespace kaleidoscope
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

57
plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox/i2cmaster.cpp
Unescape View File

@ -21,7 +21,7 @@
#endif
/* I2C clock in Hz */
#define SCL_CLOCK 400000L
#define SCL_CLOCK 400000L
/*************************************************************************
@ -36,10 +36,10 @@ void i2c_init(void) {
* for more details, see 20.5.2 in ATmega16/32 secification
*/
TWSR = 0; /* no prescaler */
TWBR = 10; /* must be >= 10 for stable operation */
TWSR = 0; /* no prescaler */
TWBR = 10; /* must be >= 10 for stable operation */
}/* i2c_init */
} /* i2c_init */
/*************************************************************************
@ -47,13 +47,14 @@ void i2c_init(void) {
return 0 = device accessible, 1= failed to access device
*************************************************************************/
unsigned char i2c_start(unsigned char address) {
uint8_t twst;
uint8_t twst;
// send START condition
TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN);
// wait until transmission completed
while (!(TWCR & (1 << TWINT)));
while (!(TWCR & (1 << TWINT)))
;
// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
@ -64,7 +65,8 @@ unsigned char i2c_start(unsigned char address) {
TWCR = (1 << TWINT) | (1 << TWEN);
// wail until transmission completed and ACK/NACK has been received
while (!(TWCR & (1 << TWINT)));
while (!(TWCR & (1 << TWINT)))
;
// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
@ -72,7 +74,7 @@ unsigned char i2c_start(unsigned char address) {
return 0;
}/* i2c_start */
} /* i2c_start */
/*************************************************************************
@ -82,7 +84,7 @@ unsigned char i2c_start(unsigned char address) {
Input: address and transfer direction of I2C device
*************************************************************************/
void i2c_start_wait(unsigned char address) {
uint8_t twst;
uint8_t twst;
while (1) {
@ -90,7 +92,8 @@ void i2c_start_wait(unsigned char address) {
TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN);
// wait until transmission completed
while (!(TWCR & (1 << TWINT)));
while (!(TWCR & (1 << TWINT)))
;
// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
@ -101,7 +104,8 @@ void i2c_start_wait(unsigned char address) {
TWCR = (1 << TWINT) | (1 << TWEN);
// wail until transmission completed
while (!(TWCR & (1 << TWINT)));
while (!(TWCR & (1 << TWINT)))
;
// check value of TWI Status Register. Mask prescaler bits.
twst = TW_STATUS & 0xF8;
@ -110,7 +114,8 @@ void i2c_start_wait(unsigned char address) {
TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
// wait until stop condition is executed and bus released
while (TWCR & (1 << TWSTO));
while (TWCR & (1 << TWSTO))
;
continue;
}
@ -118,7 +123,7 @@ void i2c_start_wait(unsigned char address) {
break;
}
}/* i2c_start_wait */
} /* i2c_start_wait */
/*************************************************************************
@ -132,7 +137,7 @@ void i2c_start_wait(unsigned char address) {
unsigned char i2c_rep_start(unsigned char address) {
return i2c_start(address);
}/* i2c_rep_start */
} /* i2c_rep_start */
/*************************************************************************
@ -143,9 +148,10 @@ void i2c_stop(void) {
TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO);
// wait until stop condition is executed and bus released
while (TWCR & (1 << TWSTO));
while (TWCR & (1 << TWSTO))
;
}/* i2c_stop */
} /* i2c_stop */
/*************************************************************************
@ -156,21 +162,22 @@ void i2c_stop(void) {
1 write failed
*************************************************************************/
unsigned char i2c_write(unsigned char data) {
uint8_t twst;
uint8_t twst;
// send data to the previously addressed device
TWDR = data;
TWCR = (1 << TWINT) | (1 << TWEN);
// wait until transmission completed
while (!(TWCR & (1 << TWINT)));
while (!(TWCR & (1 << TWINT)))
;
// check value of TWI Status Register. Mask prescaler bits
twst = TW_STATUS & 0xF8;
if (twst != TW_MT_DATA_ACK) return 1;
return 0;
}/* i2c_write */
} /* i2c_write */
/*************************************************************************
@ -180,11 +187,12 @@ unsigned char i2c_write(unsigned char data) {
*************************************************************************/
unsigned char i2c_readAck(void) {
TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
while (!(TWCR & (1 << TWINT)));
while (!(TWCR & (1 << TWINT)))
;
return TWDR;
}/* i2c_readAck */
} /* i2c_readAck */
/*************************************************************************
@ -194,11 +202,12 @@ unsigned char i2c_readAck(void) {
*************************************************************************/
unsigned char i2c_readNak(void) {
TWCR = (1 << TWINT) | (1 << TWEN);
while (!(TWCR & (1 << TWINT)));
while (!(TWCR & (1 << TWINT)))
;
return TWDR;
}/* i2c_readNak */
} /* i2c_readNak */
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

6
plugins/Kaleidoscope-Hardware-EZ-ErgoDox/src/kaleidoscope/device/ez/ErgoDox/i2cmaster.h
Unescape View File

@ -89,10 +89,10 @@
#include <avr/io.h>
/** defines the data direction (reading from I2C device) in i2c_start(),i2c_rep_start() */
#define I2C_READ 1
#define I2C_READ 1
/** defines the data direction (writing to I2C device) in i2c_start(),i2c_rep_start() */
#define I2C_WRITE 0
#define I2C_WRITE 0
/**
@ -172,7 +172,7 @@ extern unsigned char i2c_readNak(void);
@return byte read from I2C device
*/
extern unsigned char i2c_read(unsigned char ack);
#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak();
#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak();
/**@}*/

8
plugins/Kaleidoscope-Hardware-GD32-Eval/src/kaleidoscope/device/gd32/Eval.cpp
Unescape View File

@ -24,8 +24,8 @@ namespace kaleidoscope {
namespace device {
namespace gd32 {
} // namespace gd32
} // namespace device
} // namespace kaleidoscope
} // namespace gd32
} // namespace device
} // namespace kaleidoscope
#endif // ifdef ARDUINO_GD32F303ZE_EVAL
#endif // ifdef ARDUINO_GD32F303ZE_EVAL

12
plugins/Kaleidoscope-Hardware-GD32-Eval/src/kaleidoscope/device/gd32/Eval.h
Unescape View File

@ -30,9 +30,9 @@ namespace kaleidoscope {
namespace device {
namespace gd32 {
struct EvalStorageProps: kaleidoscope::driver::storage::GD32FlashProps {};
struct EvalStorageProps : kaleidoscope::driver::storage::GD32FlashProps {};
struct EvalProps: kaleidoscope::device::BaseProps {
struct EvalProps : kaleidoscope::device::BaseProps {
typedef kaleidoscope::driver::bootloader::gd32::Base BootLoader;
typedef eval::KeyScannerProps KeyScannerProps;
typedef eval::KeyScanner KeyScanner;
@ -41,7 +41,7 @@ struct EvalProps: kaleidoscope::device::BaseProps {
static constexpr const char *short_name = "GD32Eval";
};
class Eval: public kaleidoscope::device::Base<EvalProps> {};
class Eval : public kaleidoscope::device::Base<EvalProps> {};
// clang-format off
#define PER_KEY_DATA(dflt, \
@ -50,11 +50,11 @@ class Eval: public kaleidoscope::device::Base<EvalProps> {};
R0C0, R0C1
// clang-format on
} // namespace gd32
} // namespace device
} // namespace gd32
} // namespace device
EXPORT_DEVICE(kaleidoscope::device::gd32::Eval)
} // namespace kaleidoscope
} // namespace kaleidoscope
#endif

8
plugins/Kaleidoscope-Hardware-GD32-Eval/src/kaleidoscope/device/gd32/eval/KeyScanner.cpp
Unescape View File

@ -160,9 +160,9 @@ uint8_t KeyScanner::previousPressedKeyswitchCount() {
return count;
}
} // namespace eval
} // namespace gd32
} // namespace device
} // namespace kaleidoscope
} // namespace eval
} // namespace gd32
} // namespace device
} // namespace kaleidoscope
#endif

22
plugins/Kaleidoscope-Hardware-GD32-Eval/src/kaleidoscope/device/gd32/eval/KeyScanner.h
Unescape View File

@ -29,19 +29,20 @@ namespace gd32 {
namespace eval {
struct KeyScannerProps : public kaleidoscope::driver::keyscanner::BaseProps {
static constexpr uint8_t matrix_rows = 1;
static constexpr uint8_t matrix_rows = 1;
static constexpr uint8_t matrix_columns = 2;
static constexpr uint8_t matrix_row_pins[] = { PA3 };
static constexpr uint8_t matrix_col_pins[] = { PE4, PD12 };
static constexpr uint8_t matrix_row_pins[] = {PA3};
static constexpr uint8_t matrix_col_pins[] = {PE4, PD12};
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
};
class KeyScanner: public kaleidoscope::driver::keyscanner::Base<KeyScannerProps> {
class KeyScanner : public kaleidoscope::driver::keyscanner::Base<KeyScannerProps> {
private:
typedef KeyScanner ThisType;
typedef KeyScannerProps Props_;
public:
static bool do_scan;
@ -55,6 +56,7 @@ class KeyScanner: public kaleidoscope::driver::keyscanner::Base<KeyScannerProps>
static bool wasKeyswitchPressed(KeyAddr key_addr);
static uint8_t previousPressedKeyswitchCount();
private:
/*
each of these variables are storing the state for a row of keys
@ -63,8 +65,8 @@ class KeyScanner: public kaleidoscope::driver::keyscanner::Base<KeyScannerProps>
and the state in debounced_state[0].
*/
struct debounce_t {
uint16_t db0; // counter bit 0
uint16_t db1; // counter bit 1
uint16_t db0; // counter bit 0
uint16_t db1; // counter bit 1
uint16_t debounced_state; // debounced state
};
@ -79,9 +81,9 @@ class KeyScanner: public kaleidoscope::driver::keyscanner::Base<KeyScannerProps>
static uint16_t readRows();
};
} // namespace eval
} // namespace gd32
} // namespace device
} // namespace kaleidoscope
} // namespace eval
} // namespace gd32
} // namespace device
} // namespace kaleidoscope
#endif

13
plugins/Kaleidoscope-Hardware-KBDFans-KBD4x/src/kaleidoscope/device/kbdfans/KBD4x.cpp
Unescape View File

@ -26,7 +26,7 @@
// in the global namespace within the scope of this file. We'll use these
// aliases to simplify some template initialization code below.
using KeyScannerProps = typename kaleidoscope::device::kbdfans::KBD4xProps::KeyScannerProps;
using KeyScanner = typename kaleidoscope::device::kbdfans::KBD4xProps::KeyScanner;
using KeyScanner = typename kaleidoscope::device::kbdfans::KBD4xProps::KeyScanner;
namespace kaleidoscope {
namespace device {
@ -44,7 +44,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
// `KeyScanner` here refers to the alias set up above, just like in the
// `KeyScannerProps` case above.
template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
template<>
KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
// We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
// cannot be in a header-only driver, and must be placed here.
@ -58,9 +59,9 @@ ISR(TIMER1_OVF_vect) {
Runtime.device().keyScanner().do_scan_ = true;
}
} // namespace kbdfans
} // namespace device
} // namespace kaleidoscope
} // namespace kbdfans
} // namespace device
} // namespace kaleidoscope
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

18
plugins/Kaleidoscope-Hardware-KBDFans-KBD4x/src/kaleidoscope/device/kbdfans/KBD4x.h
Unescape View File

@ -32,19 +32,19 @@ namespace device {
namespace kbdfans {
struct KBD4xProps : kaleidoscope::device::ATmega32U4KeyboardProps {
struct MCUProps: public kaleidoscope::driver::mcu::ATmega32U4Props {
static constexpr bool disable_jtag = true;
struct MCUProps : public kaleidoscope::driver::mcu::ATmega32U4Props {
static constexpr bool disable_jtag = true;
static constexpr bool disable_clock_division = true;
};
typedef kaleidoscope::driver::mcu::ATmega32U4<MCUProps> MCU;
struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_columns = 12;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
static constexpr uint8_t matrix_col_pins[matrix_columns] = { PIN_F0, PIN_F1, PIN_F4, PIN_F5, PIN_F6, PIN_F7, PIN_B3, PIN_B1, PIN_B0, PIN_D5, PIN_B7, PIN_C7 };
#endif // KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_F0, PIN_F1, PIN_F4, PIN_F5, PIN_F6, PIN_F7, PIN_B3, PIN_B1, PIN_B0, PIN_D5, PIN_B7, PIN_C7};
#endif // KALEIDOSCOPE_VIRTUAL_BUILD
};
typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
typedef kaleidoscope::driver::bootloader::avr::FLIP Bootloader;
@ -52,8 +52,8 @@ struct KBD4xProps : kaleidoscope::device::ATmega32U4KeyboardProps {
};
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class KBD4x: public kaleidoscope::device::ATmega32U4Keyboard<KBD4xProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class KBD4x : public kaleidoscope::device::ATmega32U4Keyboard<KBD4xProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
/* Device definition omitted for virtual device builds.
* We need to forward declare the device name, though, as there are
* some legacy extern references to boards whose definition
@ -61,7 +61,7 @@ class KBD4x: public kaleidoscope::device::ATmega32U4Keyboard<KBD4xProps> {};
*/
class KBD4x;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// clang-format off
#define PER_KEY_DATA(dflt, \

7
plugins/Kaleidoscope-Hardware-Keyboardio-Atreus/src/kaleidoscope/device/keyboardio/Atreus2.cpp
Unescape View File

@ -27,7 +27,7 @@
// in the global namespace within the scope of this file. We'll use these
// aliases to simplify some template initialization code below.
using KeyScannerProps = typename kaleidoscope::device::keyboardio::AtreusProps::KeyScannerProps;
using KeyScanner = typename kaleidoscope::device::keyboardio::AtreusProps::KeyScanner;
using KeyScanner = typename kaleidoscope::device::keyboardio::AtreusProps::KeyScanner;
namespace kaleidoscope {
namespace device {
@ -45,7 +45,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
// `KeyScanner` here refers to the alias set up above, just like in the
// `KeyScannerProps` case above.
template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
template<>
KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
// We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
// cannot be in a header-only driver, and must be placed here.
@ -64,4 +65,4 @@ ISR(TIMER1_OVF_vect) {
} // namespace kaleidoscope
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

12
plugins/Kaleidoscope-Hardware-Keyboardio-Atreus/src/kaleidoscope/device/keyboardio/Atreus2.h
Unescape View File

@ -35,13 +35,13 @@ struct AtreusProps : kaleidoscope::device::ATmega32U4KeyboardProps {
struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_columns = 12;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_F6, PIN_F5, PIN_F4, PIN_F1};
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_F6, PIN_F5, PIN_F4, PIN_F1};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_F7, PIN_E2, PIN_C7, PIN_C6, PIN_B6, PIN_B5, PIN_D7, PIN_D6, PIN_D4, PIN_D5, PIN_D3, PIN_D2};
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
};
typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
@ -50,8 +50,8 @@ struct AtreusProps : kaleidoscope::device::ATmega32U4KeyboardProps {
};
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Atreus: public kaleidoscope::device::ATmega32U4Keyboard<AtreusProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Atreus : public kaleidoscope::device::ATmega32U4Keyboard<AtreusProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
/* Device definition omitted for virtual device builds.
* We need to forward declare the device name, though, as there are
* some legacy extern references to boards whose definition
@ -59,7 +59,7 @@ class Atreus: public kaleidoscope::device::ATmega32U4Keyboard<AtreusProps> {};
*/
class Atreus;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// clang-format off

47
plugins/Kaleidoscope-Hardware-Keyboardio-Imago/src/kaleidoscope/device/keyboardio/Imago.cpp
Unescape View File

@ -24,7 +24,7 @@ extern "C" {
#include "twi.h"
}
#define ELEMENTS(arr) (sizeof(arr) / sizeof((arr)[0]))
#define ELEMENTS(arr) (sizeof(arr) / sizeof((arr)[0]))
#define LED_DRIVER_ADDR 0x30
@ -32,7 +32,7 @@ extern "C" {
// in the global namespace within the scope of this file. We'll use these
// aliases to simplify some template initialization code below.
using KeyScannerProps = typename kaleidoscope::device::keyboardio::ImagoProps::KeyScannerProps;
using KeyScanner = typename kaleidoscope::device::keyboardio::ImagoProps::KeyScanner;
using KeyScanner = typename kaleidoscope::device::keyboardio::ImagoProps::KeyScanner;
namespace kaleidoscope {
namespace device {
@ -42,18 +42,18 @@ constexpr uint8_t ImagoLEDDriverProps::key_led_map[] PROGMEM;
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t CMD_SET_REGISTER = 0xFD;
static constexpr uint8_t CMD_WRITE_ENABLE = 0xFE;
static constexpr uint8_t CMD_SET_REGISTER = 0xFD;
static constexpr uint8_t CMD_WRITE_ENABLE = 0xFE;
static constexpr uint8_t WRITE_ENABLE_ONCE = 0b11000101;
static constexpr uint8_t LED_REGISTER_PWM0 = 0x00;
static constexpr uint8_t LED_REGISTER_PWM1 = 0x01;
static constexpr uint8_t LED_REGISTER_DATA0 = 0x02;
static constexpr uint8_t LED_REGISTER_DATA1 = 0x03;
static constexpr uint8_t LED_REGISTER_PWM0 = 0x00;
static constexpr uint8_t LED_REGISTER_PWM1 = 0x01;
static constexpr uint8_t LED_REGISTER_DATA0 = 0x02;
static constexpr uint8_t LED_REGISTER_DATA1 = 0x03;
static constexpr uint8_t LED_REGISTER_CONTROL = 0x04;
static constexpr uint8_t LED_REGISTER_PWM0_SIZE = 0xB4;
static constexpr uint8_t LED_REGISTER_PWM1_SIZE = 0xAB;
static constexpr uint8_t LED_REGISTER_PWM0_SIZE = 0xB4;
static constexpr uint8_t LED_REGISTER_PWM1_SIZE = 0xAB;
static constexpr uint8_t LED_REGISTER_DATA0_SIZE = 0xB4;
static constexpr uint8_t LED_REGISTER_DATA1_SIZE = 0xAB;
@ -71,7 +71,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
// `KeyScanner` here refers to the alias set up above, just like in the
// `KeyScannerProps` case above.
template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
template<>
KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
// We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
// cannot be in a header-only driver, and must be placed here.
@ -92,17 +93,17 @@ uint8_t ImagoLEDDriver::brightness_adjustment_;
void ImagoLEDDriver::setup() {
setAllPwmTo(0xFF);
selectRegister(LED_REGISTER_CONTROL);
twiSend(LED_DRIVER_ADDR, 0x01, 0xFF); //global current
twiSend(LED_DRIVER_ADDR, 0x00, 0x01); //normal operation
twiSend(LED_DRIVER_ADDR, 0x01, 0xFF); //global current
twiSend(LED_DRIVER_ADDR, 0x00, 0x01); //normal operation
}
void ImagoLEDDriver::twiSend(uint8_t addr, uint8_t Reg_Add, uint8_t Reg_Dat) {
uint8_t data[] = {Reg_Add, Reg_Dat };
uint8_t data[] = {Reg_Add, Reg_Dat};
uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0);
}
void ImagoLEDDriver::unlockRegister(void) {
twiSend(LED_DRIVER_ADDR, CMD_WRITE_ENABLE, WRITE_ENABLE_ONCE); //unlock
twiSend(LED_DRIVER_ADDR, CMD_WRITE_ENABLE, WRITE_ENABLE_ONCE); //unlock
}
void ImagoLEDDriver::selectRegister(uint8_t page) {
@ -139,18 +140,18 @@ uint8_t ImagoLEDDriver::adjustBrightness(uint8_t value) {
}
void ImagoLEDDriver::syncLeds() {
// if (!isLEDChanged)
// return;
// if (!isLEDChanged)
// return;
uint8_t data[LED_REGISTER_DATA_LARGEST + 1];
data[0] = 0;// the address of the first byte to copy in
data[0] = 0; // the address of the first byte to copy in
uint8_t last_led = 0;
// Write the first LED bank
selectRegister(LED_REGISTER_DATA0);
for (auto i = 1; i < LED_REGISTER_DATA0_SIZE; i += 3) {
data[i] = adjustBrightness(led_data[last_led].b);
data[i] = adjustBrightness(led_data[last_led].b);
data[i + 1] = adjustBrightness(led_data[last_led].g);
data[i + 2] = adjustBrightness(led_data[last_led].r);
last_led++;
@ -170,7 +171,7 @@ void ImagoLEDDriver::syncLeds() {
selectRegister(LED_REGISTER_DATA1);
for (auto i = 1; i < LED_REGISTER_DATA1_SIZE; i += 3) {
data[i] = adjustBrightness(led_data[last_led].b);
data[i] = adjustBrightness(led_data[last_led].b);
data[i + 1] = adjustBrightness(led_data[last_led].g);
data[i + 2] = adjustBrightness(led_data[last_led].r);
last_led++;
@ -186,11 +187,10 @@ void ImagoLEDDriver::setAllPwmTo(uint8_t step) {
selectRegister(LED_REGISTER_PWM0);
uint8_t data[0xB5] = {};
data[0] = 0;
data[0] = 0;
// PWM Register 0 is 0x00 to 0xB3
for (auto i = 1; i <= 0xB4; i++) {
data[i] = step;
}
twi_writeTo(LED_DRIVER_ADDR, data, 0xB5, 1, 0);
@ -198,7 +198,6 @@ void ImagoLEDDriver::setAllPwmTo(uint8_t step) {
// PWM Register 1 is 0x00 to 0xAA
for (auto i = 1; i <= LED_REGISTER_PWM1_SIZE; i++) {
data[i] = step;
}
twi_writeTo(LED_DRIVER_ADDR, data, 0xAC, 1, 0);
}
@ -215,7 +214,7 @@ void Imago::setup() {
kaleidoscope::device::ATmega32U4Keyboard<ImagoProps>::setup();
}
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
} // namespace keyboardio
} // namespace device

29
plugins/Kaleidoscope-Hardware-Keyboardio-Imago/src/kaleidoscope/device/keyboardio/Imago.h
Unescape View File

@ -27,7 +27,8 @@ struct cRGB {
uint8_t r;
};
#define CRGB(r,g,b) (cRGB){b, g, r}
#define CRGB(r, g, b) \
(cRGB) { b, g, r }
#include "kaleidoscope/device/ATmega32U4Keyboard.h"
#include "kaleidoscope/driver/bootloader/avr/Caterina.h"
@ -40,8 +41,8 @@ namespace keyboardio {
using kaleidoscope::driver::led::no_led;
struct ImagoLEDDriverProps: public kaleidoscope::driver::led::BaseProps {
static constexpr uint8_t led_count = 78;
struct ImagoLEDDriverProps : public kaleidoscope::driver::led::BaseProps {
static constexpr uint8_t led_count = 78;
static constexpr uint8_t key_led_map[/* 5*16 */] PROGMEM = {
// clang-format off
104, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 115, 12, 116,
@ -62,14 +63,14 @@ class ImagoLEDDriver : public kaleidoscope::driver::led::Base<ImagoLEDDriverProp
static cRGB getCrgbAt(uint8_t i);
static void setBrightness(uint8_t brightness) {
brightness_adjustment_ = 255 - brightness;
isLEDChanged = true;
isLEDChanged = true;
}
static uint8_t getBrightness() {
return 255 - brightness_adjustment_;
}
static cRGB led_data[117]; // 117 is the number of LEDs the chip drives
// until we clean stuff up a bit, it's easiest to just have the whole struct around
static cRGB led_data[117]; // 117 is the number of LEDs the chip drives
// until we clean stuff up a bit, it's easiest to just have the whole struct around
private:
static uint8_t brightness_adjustment_;
@ -81,19 +82,19 @@ class ImagoLEDDriver : public kaleidoscope::driver::led::Base<ImagoLEDDriverProp
static void setAllPwmTo(uint8_t);
static void twiSend(uint8_t addr, uint8_t Reg_Add, uint8_t Reg_Dat);
};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class ImagoLEDDriver;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
struct ImagoProps : kaleidoscope::device::ATmega32U4KeyboardProps {
struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
static constexpr uint8_t matrix_rows = 5;
static constexpr uint8_t matrix_rows = 5;
static constexpr uint8_t matrix_columns = 16;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_F6, PIN_F5, PIN_F4, PIN_F1, PIN_F0};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_B2, PIN_B7, PIN_E2, PIN_C7, PIN_C6, PIN_B6, PIN_B5, PIN_B4, PIN_D7, PIN_D6, PIN_D4, PIN_D5, PIN_D3, PIN_D2, PIN_E6, PIN_F7};
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_F6, PIN_F5, PIN_F4, PIN_F1, PIN_F0};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_B2, PIN_B7, PIN_E2, PIN_C7, PIN_C6, PIN_B6, PIN_B5, PIN_B4, PIN_D7, PIN_D6, PIN_D4, PIN_D5, PIN_D3, PIN_D2, PIN_E6, PIN_F7};
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
};
typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
typedef ImagoLEDDriverProps LEDDriverProps;
@ -103,11 +104,11 @@ struct ImagoProps : kaleidoscope::device::ATmega32U4KeyboardProps {
};
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Imago: public kaleidoscope::device::ATmega32U4Keyboard<ImagoProps> {
class Imago : public kaleidoscope::device::ATmega32U4Keyboard<ImagoProps> {
public:
void setup();
};
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// clang-format off
#define PER_KEY_DATA(dflt, \

10
plugins/Kaleidoscope-Hardware-Keyboardio-Imago/src/kaleidoscope/device/keyboardio/twi.h
Unescape View File

@ -44,14 +44,14 @@ 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));
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 // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif

18
plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/device/keyboardio/Model01.cpp
Unescape View File

@ -20,15 +20,15 @@
#include "kaleidoscope/device/keyboardio/Model01.h"
// System headers
#include <stdint.h> // for uint8_t
#include <stdint.h> // for uint8_t
// Arduino headers
#include <Arduino.h> // for PROGMEM
#include <Arduino.h> // for PROGMEM
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#include <KeyboardioHID.h>
#include <avr/wdt.h>
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// Kaleidoscope headers
#include "kaleidoscope/driver/keyscanner/Base_Impl.h" // IWYU pragma: keep
@ -63,8 +63,8 @@ void Model01Hands::setup(void) {
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
DDRB &= ~_BV(4); // set bit, input
PORTB &= ~_BV(4); // set bit, enable pull-up resistor
}
/********* LED Driver *********/
@ -163,7 +163,7 @@ void Model01KeyScanner::setup() {
void Model01KeyScanner::readMatrix() {
//scan the Keyboard matrix looking for connections
previousLeftHandState = leftHandState;
previousLeftHandState = leftHandState;
previousRightHandState = rightHandState;
if (Model01Hands::leftHand.readKeys()) {
@ -180,12 +180,12 @@ void Model01KeyScanner::actOnHalfRow(uint8_t row, uint8_t colState, uint8_t colP
for (uint8_t col = 0; col < 8; col++) {
// Build up the key state for row, col
uint8_t keyState = ((bitRead(colPrevState, 0) << 0) |
(bitRead(colState, 0) << 1));
(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;
colState = colState >> 1;
colPrevState = colPrevState >> 1;
}
}
@ -243,7 +243,7 @@ void Model01::setup() {
Model01Hands::setup();
kaleidoscope::device::Base<Model01Props>::setup();
TWBR = 12; // This is 400mhz, which is the fastest we can drive the ATTiny
TWBR = 12; // This is 400mhz, which is the fastest we can drive the ATTiny
}
void Model01::enableHardwareTestMode() {

34
plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/device/keyboardio/Model01.h
Unescape View File

@ -22,15 +22,16 @@
#ifdef ARDUINO_AVR_MODEL01
// System headers
#include <stdint.h> // for uint8_t
#include <stdint.h> // for uint8_t
// Arduino headers
#include <Arduino.h> // for PROGMEM
#include <Arduino.h> // for PROGMEM
// Kaleidoscope headers
#include "kaleidoscope/MatrixAddr.h" // for MatrixAddr
#include "kaleidoscope/macro_helpers.h" // for RESTRICT_AR...
#include "kaleidoscope/MatrixAddr.h" // for MatrixAddr
#include "kaleidoscope/macro_helpers.h" // for RESTRICT_AR...
#define CRGB(r,g,b) (cRGB){b, g, r}
#define CRGB(r, g, b) \
(cRGB) { b, g, r }
struct cRGB {
uint8_t b;
@ -44,14 +45,14 @@ struct cRGB {
#include "kaleidoscope/driver/led/Base.h" // for BaseProps
// Kaleidoscope-Hardware-Keyboardio-Model01 headers
#include "kaleidoscope/driver/keyboardio/Model01Side.h" // for keydata_t
#include "kaleidoscope/driver/keyboardio/Model01Side.h" // for keydata_t
namespace kaleidoscope {
namespace device {
namespace keyboardio {
struct Model01LEDDriverProps : public kaleidoscope::driver::led::BaseProps {
static constexpr uint8_t led_count = 64;
static constexpr uint8_t led_count = 64;
static constexpr uint8_t key_led_map[] PROGMEM = {
// clang-format off
3, 4, 11, 12, 19, 20, 26, 27, 36, 37, 43, 44, 51, 52, 59, 60,
@ -77,12 +78,12 @@ class Model01LEDDriver : public kaleidoscope::driver::led::Base<Model01LEDDriver
private:
static bool isLEDChanged;
};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Model01LEDDriver;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
struct Model01KeyScannerProps : public kaleidoscope::driver::keyscanner::BaseProps {
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_columns = 16;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
};
@ -91,6 +92,7 @@ struct Model01KeyScannerProps : public kaleidoscope::driver::keyscanner::BasePro
class Model01KeyScanner : public kaleidoscope::driver::keyscanner::Base<Model01KeyScannerProps> {
private:
typedef Model01KeyScanner ThisType;
public:
static void setup();
static void scanMatrix();
@ -114,12 +116,12 @@ class Model01KeyScanner : public kaleidoscope::driver::keyscanner::Base<Model01K
static void actOnHalfRow(byte row, byte colState, byte colPrevState, byte startPos);
static void enableScannerPower();
};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Model01KeyScanner;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
struct Model01Props : public kaleidoscope::device::ATmega32U4KeyboardProps {
typedef Model01LEDDriverProps LEDDriverProps;
typedef Model01LEDDriverProps LEDDriverProps;
typedef Model01LEDDriver LEDDriver;
typedef Model01KeyScannerProps KeyScannerProps;
typedef Model01KeyScanner KeyScanner;
@ -136,10 +138,10 @@ class Model01 : public kaleidoscope::device::ATmega32U4Keyboard<Model01Props> {
static void enableHardwareTestMode();
};
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
} // namespace keyboardio
} // namespace device
} // namespace keyboardio
} // namespace device
EXPORT_DEVICE(kaleidoscope::device::keyboardio::Model01)

10
plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/device/keyboardio/twi.h
Unescape View File

@ -44,14 +44,14 @@ 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));
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 // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif

28
plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/driver/keyboardio/Model01Side.cpp
Unescape View File

@ -40,7 +40,7 @@ namespace driver {
namespace keyboardio {
#define SCANNER_I2C_ADDR_BASE 0x58
#define ELEMENTS(arr) (sizeof(arr) / sizeof((arr)[0]))
#define ELEMENTS(arr) (sizeof(arr) / sizeof((arr)[0]))
uint8_t twi_uninitialized = 1;
@ -82,8 +82,6 @@ uint8_t Model01Side::setKeyscanInterval(uint8_t delay) {
}
// returns -1 on error, otherwise returns the scanner version integer
int Model01Side::readVersion() {
return readRegister(TWI_CMD_VERSION);
@ -113,7 +111,6 @@ uint8_t Model01Side::setLEDSPIFrequency(uint8_t frequency) {
}
int Model01Side::readRegister(uint8_t cmd) {
uint8_t return_value = 0;
@ -122,8 +119,7 @@ int Model01Side::readRegister(uint8_t cmd) {
uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0);
delayMicroseconds(15); // We may be able to drop this in the future
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
@ -137,7 +133,6 @@ int Model01Side::readRegister(uint8_t cmd) {
} else {
return -1;
}
}
@ -174,8 +169,8 @@ auto constexpr gamma8 = kaleidoscope::driver::color::gamma_correction;
void Model01Side::sendLEDBank(uint8_t 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++) {
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
@ -195,8 +190,7 @@ 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])
};
pgm_read_byte(&gamma8[color.r])};
uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0);
}
@ -205,14 +199,12 @@ void Model01Side::setOneLEDTo(uint8_t led, cRGB color) {
led,
pgm_read_byte(&gamma8[color.b]),
pgm_read_byte(&gamma8[color.g]),
pgm_read_byte(&gamma8[color.r])
};
pgm_read_byte(&gamma8[color.r])};
uint8_t result = twi_writeTo(addr, data, ELEMENTS(data), 1, 0);
}
} // namespace keyboardio
} // namespace driver
} // namespace kaleidoscope
} // namespace keyboardio
} // namespace driver
} // namespace kaleidoscope
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

17
plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/driver/keyboardio/Model01Side.h
Unescape View File

@ -34,13 +34,14 @@ struct cRGB {
uint8_t g;
uint8_t r;
};
#define CRGB(r,g,b) (cRGB){b, g, r}
#define CRGB(r, g, b) \
(cRGB) { b, g, r }
#endif
#define LED_BANKS 4
#define LED_BANKS 4
#define LEDS_PER_HAND 32
#define LED_BYTES_PER_BANK sizeof(cRGB) * LEDS_PER_HAND/LED_BANKS
#define LEDS_PER_HAND 32
#define LED_BYTES_PER_BANK sizeof(cRGB) * LEDS_PER_HAND / LED_BANKS
namespace kaleidoscope {
namespace driver {
@ -97,8 +98,8 @@ class Model01Side {
void sendLEDBank(uint8_t bank);
int readRegister(uint8_t cmd);
};
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
} // namespace keyboardio
} // namespace driver
} // namespace kaleidoscope
} // namespace keyboardio
} // namespace driver
} // namespace kaleidoscope

34
plugins/Kaleidoscope-Hardware-Keyboardio-Model01/src/kaleidoscope/driver/keyboardio/wire-protocol-constants.h
Unescape View File

@ -22,22 +22,22 @@
#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_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
#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
@ -45,7 +45,7 @@
#define LED_SPI_FREQUENCY_DEFAULT LED_SPI_FREQUENCY_512KHZ
#define TWI_CMD_LED_BASE 0x80
#define TWI_CMD_LED_BASE 0x80
#define TWI_REPLY_NONE 0x00
#define TWI_REPLY_KEYDATA 0x01
#define TWI_REPLY_NONE 0x00
#define TWI_REPLY_KEYDATA 0x01

18
plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model100.cpp
Unescape View File

@ -19,8 +19,8 @@
#include "kaleidoscope/device/keyboardio/Model100.h"
#include <Arduino.h> // for PROGMEM
#include <Wire.h> // for Wire
#include <Arduino.h> // for PROGMEM
#include <Wire.h> // for Wire
#include "kaleidoscope/driver/keyscanner/Base_Impl.h" // For Base<>
@ -48,7 +48,6 @@ void Model100Hands::setup(void) {
Model100KeyScanner::enableScannerPower();
Wire.begin();
Wire.setClock(400000);
}
/********* LED Driver *********/
@ -125,9 +124,9 @@ driver::keyboardio::keydata_t Model100KeyScanner::previousLeftHandState;
driver::keyboardio::keydata_t Model100KeyScanner::previousRightHandState;
void Model100KeyScanner::enableScannerPower(void) {
// Turn on the switched 5V network.
// make sure this happens at least 100ms after USB connect
// to satisfy inrush limits
// Turn on the switched 5V network.
// make sure this happens at least 100ms after USB connect
// to satisfy inrush limits
//
pinMode(PB9, OUTPUT_OPEN_DRAIN);
digitalWrite(PB9, LOW);
@ -141,7 +140,6 @@ void Model100KeyScanner::disableScannerPower(void) {
}
void Model100KeyScanner::setup() {
enableScannerPower();
delay(250);
@ -149,7 +147,7 @@ void Model100KeyScanner::setup() {
void Model100KeyScanner::readMatrix() {
//scan the Keyboard matrix looking for connections
previousLeftHandState = leftHandState;
previousLeftHandState = leftHandState;
previousRightHandState = rightHandState;
if (Model100Hands::leftHand.readKeys()) {
@ -166,12 +164,12 @@ void Model100KeyScanner::actOnHalfRow(uint8_t row, uint8_t colState, uint8_t col
for (uint8_t col = 0; col < 8; col++) {
// Build up the key state for row, col
uint8_t keyState = ((bitRead(colPrevState, 0) << 0) |
(bitRead(colState, 0) << 1));
(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;
colState = colState >> 1;
colPrevState = colPrevState >> 1;
}
}

28
plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/device/keyboardio/Model100.h
Unescape View File

@ -25,7 +25,8 @@
#include <Arduino.h>
#define CRGB(r,g,b) (cRGB){b, g, r}
#define CRGB(r, g, b) \
(cRGB) { b, g, r }
struct cRGB {
uint8_t b;
@ -47,13 +48,13 @@ namespace kaleidoscope {
namespace device {
namespace keyboardio {
struct Model100StorageProps: public kaleidoscope::driver::storage::GD32FlashProps {
struct Model100StorageProps : public kaleidoscope::driver::storage::GD32FlashProps {
static constexpr uint16_t length = EEPROM_EMULATION_SIZE;
};
struct Model100LEDDriverProps : public kaleidoscope::driver::led::BaseProps {
static constexpr uint8_t led_count = 64;
static constexpr uint8_t led_count = 64;
static constexpr uint8_t key_led_map[] PROGMEM = {
// clang-format off
3, 4, 11, 12, 19, 20, 26, 27, 36, 37, 43, 44, 51, 52, 59, 60,
@ -78,12 +79,12 @@ class Model100LEDDriver : public kaleidoscope::driver::led::Base<Model100LEDDriv
private:
static bool isLEDChanged;
};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Model100LEDDriver;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
struct Model100KeyScannerProps : public kaleidoscope::driver::keyscanner::BaseProps {
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_columns = 16;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
};
@ -92,6 +93,7 @@ struct Model100KeyScannerProps : public kaleidoscope::driver::keyscanner::BasePr
class Model100KeyScanner : public kaleidoscope::driver::keyscanner::Base<Model100KeyScannerProps> {
private:
typedef Model100KeyScanner ThisType;
public:
static void setup();
static void scanMatrix();
@ -116,13 +118,13 @@ class Model100KeyScanner : public kaleidoscope::driver::keyscanner::Base<Model10
static void actOnHalfRow(uint8_t row, uint8_t colState, uint8_t colPrevState, uint8_t startPos);
};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Model100KeyScanner;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// If we need to override HID props:
struct Model100HIDProps: public kaleidoscope::driver::hid::KeyboardioProps {
struct Model100HIDProps : public kaleidoscope::driver::hid::KeyboardioProps {
//typedef kaleidoscope::driver::hid::base::AbsoluteMouseProps AbsoluteMouseProps;
//typedef kaleidoscope::driver::hid::base::AbsoluteMouse<AbsoluteMouseProps> AbsoluteMouse;
};
@ -132,7 +134,7 @@ struct Model100Props : public kaleidoscope::device::BaseProps {
typedef Model100HIDProps HIDProps;
typedef kaleidoscope::driver::hid::Keyboardio<HIDProps> HID;
typedef Model100LEDDriverProps LEDDriverProps;
typedef Model100LEDDriverProps LEDDriverProps;
typedef Model100LEDDriver LEDDriver;
typedef Model100KeyScannerProps KeyScannerProps;
@ -158,10 +160,10 @@ class Model100 : public kaleidoscope::device::Base<Model100Props> {
static void enableHardwareTestMode();
};
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
} // namespace keyboardio
} // namespace device
} // namespace keyboardio
} // namespace device
EXPORT_DEVICE(kaleidoscope::device::keyboardio::Model100)

47
plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model100Side.cpp
Unescape View File

@ -36,7 +36,7 @@ namespace driver {
namespace keyboardio {
#define SCANNER_I2C_ADDR_BASE 0x58
#define ELEMENTS(arr) (sizeof(arr) / sizeof((arr)[0]))
#define ELEMENTS(arr) (sizeof(arr) / sizeof((arr)[0]))
uint8_t twi_uninitialized = 1;
@ -75,8 +75,6 @@ uint8_t Model100Side::setKeyscanInterval(uint8_t delay) {
}
// returns -1 on error, otherwise returns the scanner version integer
int Model100Side::readVersion() {
return readRegister(TWI_CMD_VERSION);
@ -100,7 +98,7 @@ int Model100Side::readLEDSPIFrequency() {
// https://www.arduino.cc/en/Reference/WireEndTransmission
uint8_t Model100Side::setLEDSPIFrequency(uint8_t frequency) {
uint8_t data[] = {TWI_CMD_LED_SPI_FREQUENCY, frequency};
uint8_t result = writeData(data, ELEMENTS(data));
uint8_t result = writeData(data, ELEMENTS(data));
return result;
}
@ -134,11 +132,10 @@ bool Model100Side::isDeviceAvailable() {
// we've decremented the counter, but it's not time to probe for the device yet.
return false;
}
}
void Model100Side::markDeviceUnavailable() {
unavailable_device_check_countdown_ = 1; // We think there was a comms problem. Check on the next cycle
unavailable_device_check_countdown_ = 1; // We think there was a comms problem. Check on the next cycle
}
uint8_t Model100Side::writeData(uint8_t *data, uint8_t length) {
@ -156,15 +153,15 @@ uint8_t Model100Side::writeData(uint8_t *data, uint8_t length) {
int Model100Side::readRegister(uint8_t cmd) {
uint8_t return_value = 0;
uint8_t data[] = {cmd};
uint8_t result = writeData(data, ELEMENTS(data));
uint8_t data[] = {cmd};
uint8_t result = writeData(data, ELEMENTS(data));
// If the setup failed, return. This means there was a problem asking for the register
if (result) {
return -1;
}
delayMicroseconds(50); // TODO We may be able to drop this in the future
delayMicroseconds(50); // TODO 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
@ -173,14 +170,13 @@ int Model100Side::readRegister(uint8_t cmd) {
// perform blocking read into buffer
Wire.requestFrom(addr, 1); // request 1 byte from the keyscanner
Wire.requestFrom(addr, 1); // request 1 byte from the keyscanner
if (Wire.available()) {
return Wire.read();
} else {
markDeviceUnavailable();
return -1;
}
}
@ -192,9 +188,9 @@ bool Model100Side::readKeys() {
uint8_t row_counter = 0;
// perform blocking read into buffer
uint8_t read = 0;
uint8_t read = 0;
uint8_t bytes_returned = 0;
bytes_returned = Wire.requestFrom(addr, 5); // request 5 bytes from the keyscanner
bytes_returned = Wire.requestFrom(addr, 5); // request 5 bytes from the keyscanner
if (bytes_returned < 5) {
return false;
}
@ -224,8 +220,8 @@ void Model100Side::sendLEDData() {
void Model100Side::sendLEDBank(uint8_t 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++) {
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
@ -238,16 +234,15 @@ void Model100Side::sendLEDBank(uint8_t bank) {
data[i + 1] = c;
}
uint8_t result = writeData(data, ELEMENTS(data));
uint8_t result = writeData(data, ELEMENTS(data));
}
void Model100Side::setAllLEDsTo(cRGB color) {
uint8_t data[] = {TWI_CMD_LED_SET_ALL_TO,
color.b,
color.g,
color.r
};
uint8_t result = writeData(data, ELEMENTS(data));
color.r};
uint8_t result = writeData(data, ELEMENTS(data));
}
void Model100Side::setOneLEDTo(uint8_t led, cRGB color) {
@ -255,14 +250,12 @@ void Model100Side::setOneLEDTo(uint8_t led, cRGB color) {
led,
color.b,
color.g,
color.r
};
uint8_t result = writeData(data, ELEMENTS(data));
color.r};
uint8_t result = writeData(data, ELEMENTS(data));
}
} // namespace keyboardio
} // namespace driver
} // namespace kaleidoscope
} // namespace keyboardio
} // namespace driver
} // namespace kaleidoscope
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

23
plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/Model100Side.h
Unescape View File

@ -34,13 +34,14 @@ struct cRGB {
uint8_t g;
uint8_t r;
};
#define CRGB(r,g,b) (cRGB){b, g, r}
#define CRGB(r, g, b) \
(cRGB) { b, g, r }
#endif
#define LED_BANKS 4
#define LED_BANKS 4
#define LEDS_PER_HAND 32
#define LED_BYTES_PER_BANK sizeof(cRGB) * LEDS_PER_HAND/LED_BANKS
#define LEDS_PER_HAND 32
#define LED_BYTES_PER_BANK sizeof(cRGB) * LEDS_PER_HAND / LED_BANKS
namespace kaleidoscope {
namespace driver {
@ -98,15 +99,15 @@ class Model100Side {
keydata_t keyData;
// a value of 0 is "device seen" - anything else is how many cycles before we should
// check for the device
uint16_t unavailable_device_check_countdown_ = 0;
uint16_t unavailable_device_check_countdown_ = 0;
static const uint16_t UNAVAILABLE_DEVICE_COUNTDOWN_MAX = 0x00FFU;
byte nextLEDBank = 0;
byte nextLEDBank = 0;
void sendLEDBank(byte bank);
int readRegister(uint8_t cmd);
uint8_t writeData(uint8_t* data, uint8_t length);
uint8_t writeData(uint8_t *data, uint8_t length);
};
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
} // namespace keyboardio
} // namespace driver
} // namespace kaleidoscope
} // namespace keyboardio
} // namespace driver
} // namespace kaleidoscope

34
plugins/Kaleidoscope-Hardware-Keyboardio-Model100/src/kaleidoscope/driver/keyboardio/wire-protocol-constants.h
Unescape View File

@ -22,22 +22,22 @@
#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_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
#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
@ -45,7 +45,7 @@
#define LED_SPI_FREQUENCY_DEFAULT LED_SPI_FREQUENCY_512KHZ
#define TWI_CMD_LED_BASE 0x80
#define TWI_CMD_LED_BASE 0x80
#define TWI_REPLY_NONE 0x00
#define TWI_REPLY_KEYDATA 0x01
#define TWI_REPLY_NONE 0x00
#define TWI_REPLY_KEYDATA 0x01

13
plugins/Kaleidoscope-Hardware-OLKB-Planck/src/kaleidoscope/device/olkb/Planck.cpp
Unescape View File

@ -27,7 +27,7 @@
// in the global namespace within the scope of this file. We'll use these
// aliases to simplify some template initialization code below.
using KeyScannerProps = typename kaleidoscope::device::olkb::PlanckProps::KeyScannerProps;
using KeyScanner = typename kaleidoscope::device::olkb::PlanckProps::KeyScanner;
using KeyScanner = typename kaleidoscope::device::olkb::PlanckProps::KeyScanner;
namespace kaleidoscope {
namespace device {
@ -45,7 +45,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
// `KeyScanner` here refers to the alias set up above, just like in the
// `KeyScannerProps` case above.
template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
template<>
KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
// We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
// cannot be in a header-only driver, and must be placed here.
@ -59,9 +60,9 @@ ISR(TIMER1_OVF_vect) {
Runtime.device().keyScanner().do_scan_ = true;
}
} // namespace olkb
} // namespace device
} // namespace kaleidoscope
} // namespace olkb
} // namespace device
} // namespace kaleidoscope
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

12
plugins/Kaleidoscope-Hardware-OLKB-Planck/src/kaleidoscope/device/olkb/Planck.h
Unescape View File

@ -31,13 +31,13 @@ namespace olkb {
struct PlanckProps : kaleidoscope::device::ATmega32U4KeyboardProps {
struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_columns = 12;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D5, PIN_B5, PIN_B6};
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D5, PIN_B5, PIN_B6};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_F0, PIN_F1, PIN_F4, PIN_F5, PIN_F6, PIN_F7, PIN_B3, PIN_B1, PIN_B0, PIN_D5, PIN_B7, PIN_C7};
#endif // KALEIDOSCOPE_VIRTUAL_BUILD
#endif // KALEIDOSCOPE_VIRTUAL_BUILD
};
typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
typedef kaleidoscope::driver::bootloader::avr::HalfKay Bootloader;
@ -45,8 +45,8 @@ struct PlanckProps : kaleidoscope::device::ATmega32U4KeyboardProps {
};
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Planck: public kaleidoscope::device::ATmega32U4Keyboard<PlanckProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Planck : public kaleidoscope::device::ATmega32U4Keyboard<PlanckProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
/* Device definition omitted for virtual device builds.
* We need to forward declare the device name, though, as there are
* some legacy extern references to boards whose definition
@ -54,7 +54,7 @@ class Planck: public kaleidoscope::device::ATmega32U4Keyboard<PlanckProps> {};
*/
class Planck;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// clang-format off
#define PER_KEY_DATA(dflt, \

13
plugins/Kaleidoscope-Hardware-SOFTHRUF-Splitography/src/kaleidoscope/device/softhruf/Splitography.cpp
Unescape View File

@ -34,7 +34,7 @@
// in the global namespace within the scope of this file. We'll use these
// aliases to simplify some template initialization code below.
using KeyScannerProps = typename kaleidoscope::device::softhruf::SplitographyProps::KeyScannerProps;
using KeyScanner = typename kaleidoscope::device::softhruf::SplitographyProps::KeyScanner;
using KeyScanner = typename kaleidoscope::device::softhruf::SplitographyProps::KeyScanner;
namespace kaleidoscope {
namespace device {
@ -52,7 +52,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
// `KeyScanner` here refers to the alias set up above, just like in the
// `KeyScannerProps` case above.
template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
template<>
KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
// We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
// cannot be in a header-only driver, and must be placed here.
@ -66,9 +67,9 @@ ISR(TIMER1_OVF_vect) {
Runtime.device().keyScanner().do_scan_ = true;
}
} // namespace softhruf
} // namespace device
} // namespace kaleidoscope
} // namespace softhruf
} // namespace device
} // namespace kaleidoscope
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

16
plugins/Kaleidoscope-Hardware-SOFTHRUF-Splitography/src/kaleidoscope/device/softhruf/Splitography.h
Unescape View File

@ -39,18 +39,18 @@ namespace device {
namespace softhruf {
struct SplitographyProps : kaleidoscope::device::ATmega32U4KeyboardProps {
struct MCUProps: kaleidoscope::driver::mcu::ATmega32U4Props {
struct MCUProps : kaleidoscope::driver::mcu::ATmega32U4Props {
static constexpr bool disable_jtag = true;
};
typedef kaleidoscope::driver::mcu::ATmega32U4<MCUProps> MCU;
struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_columns = 12;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
static constexpr uint8_t matrix_col_pins[matrix_columns] = { PIN_F0, PIN_F1, PIN_F4, PIN_F5, PIN_F6, PIN_F7, PIN_C7, PIN_C6, PIN_B6, PIN_B5, PIN_B4, PIN_D7 };
#endif // KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_F0, PIN_F1, PIN_F4, PIN_F5, PIN_F6, PIN_F7, PIN_C7, PIN_C6, PIN_B6, PIN_B5, PIN_B4, PIN_D7};
#endif // KALEIDOSCOPE_VIRTUAL_BUILD
};
typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
typedef kaleidoscope::driver::bootloader::avr::FLIP BootLoader;
@ -58,15 +58,15 @@ struct SplitographyProps : kaleidoscope::device::ATmega32U4KeyboardProps {
};
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Splitography: public kaleidoscope::device::ATmega32U4Keyboard<SplitographyProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Splitography : public kaleidoscope::device::ATmega32U4Keyboard<SplitographyProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
/* Device definition omitted for virtual device builds.
* We need to forward declare the device name, though, as there are
* some legacy extern references to boards whose definition
* depends on this.
*/
class Splitography;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// clang-format off

2
plugins/Kaleidoscope-Hardware-Technomancy-Atreus/src/Kaleidoscope-Hardware-Technomancy-Atreus.h
Unescape View File

@ -18,7 +18,7 @@
#pragma once
#if !defined(KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR) && \
#if !defined(KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR) && \
!defined(KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR_DOWN) && \
!defined(KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_LEGACY_TEENSY2)
#define KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR 1

13
plugins/Kaleidoscope-Hardware-Technomancy-Atreus/src/kaleidoscope/device/technomancy/Atreus.cpp
Unescape View File

@ -36,7 +36,7 @@
// in the global namespace within the scope of this file. We'll use these
// aliases to simplify some template initialization code below.
using KeyScannerProps = typename kaleidoscope::device::technomancy::AtreusProps::KeyScannerProps;
using KeyScanner = typename kaleidoscope::device::technomancy::AtreusProps::KeyScanner;
using KeyScanner = typename kaleidoscope::device::technomancy::AtreusProps::KeyScanner;
namespace kaleidoscope {
@ -55,7 +55,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
// `KeyScanner` here refers to the alias set up above, just like in the
// `KeyScannerProps` case above.
template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
template<>
KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
// We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
// cannot be in a header-only driver, and must be placed here.
@ -69,9 +70,9 @@ ISR(TIMER1_OVF_vect) {
Runtime.device().keyScanner().do_scan_ = true;
}
} // namespace technomancy
} // namespace device
} // namespace kaleidoscope
} // namespace technomancy
} // namespace device
} // namespace kaleidoscope
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

16
plugins/Kaleidoscope-Hardware-Technomancy-Atreus/src/kaleidoscope/device/technomancy/Atreus.h
Unescape View File

@ -40,28 +40,28 @@ namespace technomancy {
struct AtreusProps : kaleidoscope::device::ATmega32U4KeyboardProps {
struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_rows = 4;
static constexpr uint8_t matrix_columns = 12;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#ifdef KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D3, PIN_D2};
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D3, PIN_D2};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_D7, PIN_C6, PIN_B5, PIN_B4, PIN_E6, PIN_D4, PIN_B6, PIN_F6, PIN_F7, PIN_D6, PIN_B7};
#endif
#ifdef KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_ASTAR_DOWN
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D3, PIN_D2};
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D3, PIN_D2};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_B7, PIN_D6, PIN_F7, PIN_F6, PIN_B6, PIN_D4, PIN_E6, PIN_B4, PIN_B5, PIN_C6, PIN_D7};
#endif
#ifdef KALEIDOSCOPE_HARDWARE_ATREUS_PINOUT_LEGACY_TEENSY2
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_D0, PIN_D1, PIN_D2, PIN_D3};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_F6, PIN_F5, PIN_F4, PIN_B7, PIN_B6, PIN_B5, PIN_B4, PIN_B3, PIN_B2, PIN_B1, PIN_B0};
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
};
typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
@ -75,15 +75,15 @@ struct AtreusProps : kaleidoscope::device::ATmega32U4KeyboardProps {
};
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Atreus: public kaleidoscope::device::ATmega32U4Keyboard<AtreusProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class Atreus : public kaleidoscope::device::ATmega32U4Keyboard<AtreusProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
/* Device definition omitted for virtual device builds.
* We need to forward declare the device name, though, as there are
* some legacy extern references to boards whose definition
* depends on this.
*/
class Atreus;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// clang-format off

13
plugins/Kaleidoscope-Hardware-gHeavy-ButterStick/src/kaleidoscope/device/gheavy/ButterStick.cpp
Unescape View File

@ -27,7 +27,7 @@
// in the global namespace within the scope of this file. We'll use these
// aliases to simplify some template initialization code below.
using KeyScannerProps = typename kaleidoscope::device::gheavy::ButterStickProps::KeyScannerProps;
using KeyScanner = typename kaleidoscope::device::gheavy::ButterStickProps::KeyScanner;
using KeyScanner = typename kaleidoscope::device::gheavy::ButterStickProps::KeyScanner;
namespace kaleidoscope {
namespace device {
@ -45,7 +45,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
// `KeyScanner` here refers to the alias set up above, just like in the
// `KeyScannerProps` case above.
template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
template<>
KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
// We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
// cannot be in a header-only driver, and must be placed here.
@ -59,9 +60,9 @@ ISR(TIMER1_OVF_vect) {
Runtime.device().keyScanner().do_scan_ = true;
}
} // namespace gheavy
} // namespace device
} // namespace kaleidoscope
} // namespace gheavy
} // namespace device
} // namespace kaleidoscope
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

20
plugins/Kaleidoscope-Hardware-gHeavy-ButterStick/src/kaleidoscope/device/gheavy/ButterStick.h
Unescape View File

@ -33,13 +33,13 @@ namespace gheavy {
struct ButterStickProps : kaleidoscope::device::ATmega32U4KeyboardProps {
struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
static constexpr uint8_t matrix_rows = 2;
static constexpr uint8_t matrix_rows = 2;
static constexpr uint8_t matrix_columns = 10;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = { PIN_F4, PIN_F5 };
static constexpr uint8_t matrix_col_pins[matrix_columns] = { PIN_B0, PIN_B1, PIN_B2, PIN_B3, PIN_B4, PIN_B5, PIN_B6, PIN_B7, PIN_C6, PIN_C7 };
#endif // KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_F4, PIN_F5};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_B0, PIN_B1, PIN_B2, PIN_B3, PIN_B4, PIN_B5, PIN_B6, PIN_B7, PIN_C6, PIN_C7};
#endif // KALEIDOSCOPE_VIRTUAL_BUILD
};
typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
typedef kaleidoscope::driver::bootloader::avr::FLIP Bootloader;
@ -47,8 +47,8 @@ struct ButterStickProps : kaleidoscope::device::ATmega32U4KeyboardProps {
};
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class ButterStick: public kaleidoscope::device::ATmega32U4Keyboard<ButterStickProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class ButterStick : public kaleidoscope::device::ATmega32U4Keyboard<ButterStickProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
/* Device definition omitted for virtual device builds.
* We need to forward declare the device name, though, as there are
* some legacy extern references to boards whose definition
@ -56,7 +56,7 @@ class ButterStick: public kaleidoscope::device::ATmega32U4Keyboard<ButterStickPr
*/
class ButterStick;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// clang-format off
#define PER_KEY_DATA(dflt, \
@ -67,11 +67,11 @@ class ButterStick;
R1C9, R1C8, R1C7, R1C6, R1C5, R1C4, R1C3, R1C2, R1C1, R1C0
// clang-format on
} // namespace gheavy
} // namespace device
} // namespace gheavy
} // namespace device
EXPORT_DEVICE(kaleidoscope::device::gheavy::ButterStick)
} // namespace kaleidoscope
} // namespace kaleidoscope
#endif

13
plugins/Kaleidoscope-Hardware-gHeavy-FaunchPad/src/kaleidoscope/device/gheavy/FaunchPad.cpp
Unescape View File

@ -27,7 +27,7 @@
// in the global namespace within the scope of this file. We'll use these
// aliases to simplify some template initialization code below.
using KeyScannerProps = typename kaleidoscope::device::gheavy::FaunchPadProps::KeyScannerProps;
using KeyScanner = typename kaleidoscope::device::gheavy::FaunchPadProps::KeyScanner;
using KeyScanner = typename kaleidoscope::device::gheavy::FaunchPadProps::KeyScanner;
namespace kaleidoscope {
namespace device {
@ -45,7 +45,8 @@ constexpr uint8_t KeyScannerProps::matrix_col_pins[matrix_columns];
// `KeyScanner` here refers to the alias set up above, just like in the
// `KeyScannerProps` case above.
template<> KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
template<>
KeyScanner::row_state_t KeyScanner::matrix_state_[KeyScannerProps::matrix_rows] = {};
// We set up the TIMER1 interrupt vector here. Due to dependency reasons, this
// cannot be in a header-only driver, and must be placed here.
@ -59,9 +60,9 @@ ISR(TIMER1_OVF_vect) {
Runtime.device().keyScanner().do_scan_ = true;
}
} // namespace gheavy
} // namespace device
} // namespace kaleidoscope
} // namespace gheavy
} // namespace device
} // namespace kaleidoscope
#endif
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD

20
plugins/Kaleidoscope-Hardware-gHeavy-FaunchPad/src/kaleidoscope/device/gheavy/FaunchPad.h
Unescape View File

@ -33,13 +33,13 @@ namespace gheavy {
struct FaunchPadProps : kaleidoscope::device::ATmega32U4KeyboardProps {
struct KeyScannerProps : public kaleidoscope::driver::keyscanner::ATmegaProps {
static constexpr uint8_t matrix_rows = 2;
static constexpr uint8_t matrix_rows = 2;
static constexpr uint8_t matrix_columns = 4;
typedef MatrixAddr<matrix_rows, matrix_columns> KeyAddr;
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = { PIN_F4, PIN_F5 };
static constexpr uint8_t matrix_col_pins[matrix_columns] = { PIN_B3, PIN_B2, PIN_B1, PIN_B0 };
#endif // KALEIDOSCOPE_VIRTUAL_BUILD
static constexpr uint8_t matrix_row_pins[matrix_rows] = {PIN_F4, PIN_F5};
static constexpr uint8_t matrix_col_pins[matrix_columns] = {PIN_B3, PIN_B2, PIN_B1, PIN_B0};
#endif // KALEIDOSCOPE_VIRTUAL_BUILD
};
typedef kaleidoscope::driver::keyscanner::ATmega<KeyScannerProps> KeyScanner;
typedef kaleidoscope::driver::bootloader::avr::FLIP Bootloader;
@ -47,8 +47,8 @@ struct FaunchPadProps : kaleidoscope::device::ATmega32U4KeyboardProps {
};
#ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class FaunchPad: public kaleidoscope::device::ATmega32U4Keyboard<FaunchPadProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
class FaunchPad : public kaleidoscope::device::ATmega32U4Keyboard<FaunchPadProps> {};
#else // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
/* Device definition omitted for virtual device builds.
* We need to forward declare the device name, though, as there are
* some legacy extern references to boards whose definition
@ -56,7 +56,7 @@ class FaunchPad: public kaleidoscope::device::ATmega32U4Keyboard<FaunchPadProps>
*/
class FaunchPad;
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
#endif // ifndef KALEIDOSCOPE_VIRTUAL_BUILD
// clang-format off
#define PER_KEY_DATA(dflt, \
@ -66,11 +66,11 @@ class FaunchPad;
R0C4, R0C5, R0C6, R0C7
// clang-format on
} // namespace gheavy
} // namespace device
} // namespace gheavy
} // namespace device
EXPORT_DEVICE(kaleidoscope::device::gheavy::FaunchPad)
} // namespace kaleidoscope
} // namespace kaleidoscope
#endif

22
plugins/Kaleidoscope-HardwareTestMode/src/kaleidoscope/plugin/HardwareTestMode.cpp
Unescape View File

@ -16,7 +16,7 @@
#include "kaleidoscope/plugin/HardwareTestMode.h"
#include <stdint.h> // for uint8_t
#include <stdint.h> // for uint8_t
#include "kaleidoscope/KeyAddr.h" // for MatrixAddr
#include "kaleidoscope/Runtime.h" // for Runtime
@ -41,7 +41,7 @@ void HardwareTestMode::waitForKeypress() {
while (1) {
Runtime.device().readMatrix();
if (Runtime.device().isKeyswitchPressed(actionKey) &&
! Runtime.device().wasKeyswitchPressed(actionKey)) {
!Runtime.device().wasKeyswitchPressed(actionKey)) {
break;
}
}
@ -54,9 +54,9 @@ void HardwareTestMode::setLeds(cRGB color) {
}
void HardwareTestMode::testLeds(void) {
constexpr cRGB red = CRGB(255, 0, 0);
constexpr cRGB blue = CRGB(0, 0, 255);
constexpr cRGB green = CRGB(0, 255, 0);
constexpr cRGB red = CRGB(255, 0, 0);
constexpr cRGB blue = CRGB(0, 0, 255);
constexpr cRGB green = CRGB(0, 255, 0);
constexpr cRGB brightWhite = CRGB(160, 160, 160);
// rainbow for 10 seconds
@ -75,18 +75,16 @@ void HardwareTestMode::testLeds(void) {
setLeds(blue);
setLeds(green);
setLeds(red);
}
void HardwareTestMode::testMatrix() {
// Reset bad keys from previous tests.
chatter_data state[Runtime.device().numKeys()] = {{0, 0, 0}};
constexpr cRGB red = CRGB(201, 0, 0);
constexpr cRGB blue = CRGB(0, 0, 201);
constexpr cRGB green = CRGB(0, 201, 0);
constexpr cRGB red = CRGB(201, 0, 0);
constexpr cRGB blue = CRGB(0, 0, 201);
constexpr cRGB green = CRGB(0, 201, 0);
constexpr cRGB yellow = CRGB(201, 100, 0);
while (1) {
@ -95,7 +93,7 @@ void HardwareTestMode::testMatrix() {
uint8_t keynum = key_addr.toInt();
// If the key is toggled on
if (Runtime.device().isKeyswitchPressed(key_addr) && ! Runtime.device().wasKeyswitchPressed(key_addr)) {
if (Runtime.device().isKeyswitchPressed(key_addr) && !Runtime.device().wasKeyswitchPressed(key_addr)) {
// And it's too soon (in terms of cycles between changes)
state[keynum].tested = 1;
if (state[keynum].cyclesSinceStateChange < CHATTER_CYCLE_LIMIT) {
@ -113,7 +111,7 @@ void HardwareTestMode::testMatrix() {
Runtime.device().setCrgbAt(key_addr, red);
} else if (state[keynum].tested == 0) {
Runtime.device().setCrgbAt(key_addr, yellow);
} else if (! Runtime.device().isKeyswitchPressed(key_addr)) {
} else if (!Runtime.device().isKeyswitchPressed(key_addr)) {
// If the key is not currently pressed and was not just released and is not marked bad
Runtime.device().setCrgbAt(key_addr, blue);
}

8
plugins/Kaleidoscope-HardwareTestMode/src/kaleidoscope/plugin/HardwareTestMode.h
Unescape View File

@ -16,7 +16,7 @@
#pragma once
#include <stdint.h> // for uint8_t
#include <stdint.h> // for uint8_t
#include "kaleidoscope/device/device.h" // for cRGB
#include "kaleidoscope/plugin.h" // for Plugin
@ -26,11 +26,10 @@ namespace plugin {
class HardwareTestMode : public kaleidoscope::Plugin {
public:
typedef struct {
uint8_t bad : 1,
tested : 1,
cyclesSinceStateChange: 6;
tested : 1,
cyclesSinceStateChange : 6;
} chatter_data;
static uint8_t actionKey;
@ -38,6 +37,7 @@ class HardwareTestMode : public kaleidoscope::Plugin {
static void runTests();
static void setActionKey(uint8_t key);
private:
static void testLeds();
static void testMatrix();

13
plugins/Kaleidoscope-Heatmap/src/kaleidoscope/plugin/Heatmap.cpp
Unescape View File

@ -17,8 +17,8 @@
#include "kaleidoscope/plugin/Heatmap.h"
#include <Arduino.h> // for pgm_read_byte, PROGMEM
#include <stdint.h> // for uint16_t, uint8_t
#include <Arduino.h> // for pgm_read_byte, PROGMEM
#include <stdint.h> // for uint16_t, uint8_t
#include "kaleidoscope/KeyAddr.h" // for MatrixAddr, MatrixAdd...
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
@ -36,19 +36,18 @@ namespace plugin {
static const cRGB heat_colors_default_[] PROGMEM = {{0, 0, 0}, {25, 255, 25}, {25, 255, 255}, {25, 25, 255}};
// colors from cold to hot
const cRGB *Heatmap::heat_colors = heat_colors_default_;
const cRGB *Heatmap::heat_colors = heat_colors_default_;
uint8_t Heatmap::heat_colors_length = 4;
// number of millisecond to wait between each heatmap computation
uint16_t Heatmap::update_delay = 1000;
Heatmap::TransientLEDMode::TransientLEDMode(const Heatmap *parent)
: // store the number of times each key has been strock
: // store the number of times each key has been strock
heatmap_{},
// max of heatmap_ (we divide by it so we start at 1)
highest_(1),
// last heatmap computation time
last_heatmap_comp_time_(Runtime.millisAtCycleStart())
{}
last_heatmap_comp_time_(Runtime.millisAtCycleStart()) {}
cRGB Heatmap::TransientLEDMode::computeColor(float v) {
// compute the color corresponding to a value between 0 and 1
@ -98,7 +97,7 @@ cRGB Heatmap::TransientLEDMode::computeColor(float v) {
// static_cast<int>(5.9) → 5
idx1 = static_cast<int>(val);
idx2 = idx1 + 1;
fb = val - static_cast<float>(idx1);
fb = val - static_cast<float>(idx1);
}
uint8_t r = static_cast<uint8_t>((pgm_read_byte(&(heat_colors[idx2].r)) - pgm_read_byte(&(heat_colors[idx1].r))) * fb + pgm_read_byte(&(heat_colors[idx1].r)));

9
plugins/Kaleidoscope-Heatmap/src/kaleidoscope/plugin/Heatmap.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint16_t
#include <stdint.h> // for uint16_t
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/Runtime.h" // for Runtime, Run...
@ -31,8 +31,8 @@
namespace kaleidoscope {
namespace plugin {
class Heatmap : public Plugin,
public LEDModeInterface,
public AccessTransientLEDMode {
public LEDModeInterface,
public AccessTransientLEDMode {
public:
Heatmap(void) {}
@ -48,7 +48,6 @@ class Heatmap : public Plugin,
//
class TransientLEDMode : public LEDMode {
public:
// Please note that storing the parent ptr is only required
// for those LED modes that require access to
// members of their parent class. Most LED modes can do without.
@ -60,11 +59,9 @@ class Heatmap : public Plugin,
EventHandlerResult beforeEachCycle();
protected:
void update() final;
private:
uint16_t heatmap_[Runtime.device().numKeys()];
uint16_t highest_;
uint16_t last_heatmap_comp_time_;

2
plugins/Kaleidoscope-HostOS/src/Kaleidoscope-HostOS.h
Unescape View File

@ -18,4 +18,4 @@
#pragma once
#include "kaleidoscope/plugin/HostOS-Focus.h" // IWYU pragma: export
#include "kaleidoscope/plugin/HostOS.h" // IWYU pragma: export
#include "kaleidoscope/plugin/HostOS.h" // IWYU pragma: export

8
plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS-Focus.cpp
Unescape View File

@ -17,9 +17,9 @@
#include "kaleidoscope/plugin/HostOS-Focus.h"
#include <Arduino.h> // for PSTR, strcmp_P
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint8_t
#include <Arduino.h> // for PSTR, strcmp_P
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint8_t
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
#include "kaleidoscope/plugin/HostOS.h" // for HostOS, Type
@ -40,7 +40,7 @@ EventHandlerResult FocusHostOSCommand::onFocusEvent(const char *command) {
} else {
uint8_t new_os;
::Focus.read(new_os);
::HostOS.os((hostos::Type) new_os);
::HostOS.os((hostos::Type)new_os);
}
return EventHandlerResult::EVENT_CONSUMED;

2
plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS.cpp
Unescape View File

@ -17,7 +17,7 @@
#include "kaleidoscope/plugin/HostOS.h"
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/device/device.h" // for VirtualProps::Storage

4
plugins/Kaleidoscope-HostOS/src/kaleidoscope/plugin/HostOS.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint16_t
#include <stdint.h> // for uint16_t
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
#include "kaleidoscope/plugin.h" // for Plugin
@ -34,7 +34,7 @@ typedef enum {
OTHER,
UNKNOWN = 0xff,
AUTO = UNKNOWN
AUTO = UNKNOWN
} Type;
}

4
plugins/Kaleidoscope-HostPowerManagement/src/kaleidoscope/plugin/HostPowerManagement.cpp
Unescape View File

@ -18,7 +18,7 @@
#include "kaleidoscope/plugin/HostPowerManagement.h"
#include <Arduino.h> // IWYU pragma: keep
#include <stdint.h> // for uint8_t
#include <stdint.h> // for uint8_t
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
@ -29,7 +29,7 @@ extern uint8_t _usbSuspendState;
namespace kaleidoscope {
namespace plugin {
bool HostPowerManagement::was_suspended_ = false;
bool HostPowerManagement::was_suspended_ = false;
bool HostPowerManagement::initial_suspend_ = true;
EventHandlerResult HostPowerManagement::beforeEachCycle() {

10
plugins/Kaleidoscope-IdleLEDs/src/kaleidoscope/plugin/IdleLEDs.cpp
Unescape View File

@ -18,10 +18,10 @@
#include "kaleidoscope/plugin/IdleLEDs.h"
#include <Arduino.h> // for F, PSTR, __FlashStrin...
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint32_t, uint16_t
#include <Arduino.h> // for F, PSTR, __FlashStrin...
#include <Kaleidoscope-EEPROM-Settings.h> // for EEPROMSettings
#include <Kaleidoscope-FocusSerial.h> // for Focus, FocusSerial
#include <stdint.h> // for uint32_t, uint16_t
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
@ -32,7 +32,7 @@
namespace kaleidoscope {
namespace plugin {
uint32_t IdleLEDs::idle_time_limit = 600000; // 10 minutes
uint32_t IdleLEDs::idle_time_limit = 600000; // 10 minutes
uint32_t IdleLEDs::start_time_ = 0;
bool IdleLEDs::idle_;

5
plugins/Kaleidoscope-IdleLEDs/src/kaleidoscope/plugin/IdleLEDs.h
Unescape View File

@ -18,7 +18,7 @@
#pragma once
#include <stdint.h> // for uint32_t, uint16_t
#include <stdint.h> // for uint32_t, uint16_t
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
@ -27,7 +27,7 @@
namespace kaleidoscope {
namespace plugin {
class IdleLEDs: public kaleidoscope::Plugin {
class IdleLEDs : public kaleidoscope::Plugin {
public:
IdleLEDs(void) {}
@ -51,6 +51,7 @@ class PersistentIdleLEDs : public IdleLEDs {
EventHandlerResult onFocusEvent(const char *command);
static void setIdleTimeoutSeconds(uint32_t new_limit);
private:
static uint16_t settings_base_;
};

7
plugins/Kaleidoscope-LED-ActiveLayerColor/src/kaleidoscope/plugin/LED-ActiveLayerColor.cpp
Unescape View File

@ -17,8 +17,8 @@
#include "kaleidoscope/plugin/LED-ActiveLayerColor.h"
#include <Arduino.h> // for pgm_read_byte
#include <stdint.h> // for uint8_t
#include <Arduino.h> // for pgm_read_byte
#include <stdint.h> // for uint8_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
@ -34,8 +34,7 @@ const cRGB *LEDActiveLayerColorEffect::colormap_;
LEDActiveLayerColorEffect::TransientLEDMode::TransientLEDMode(
const LEDActiveLayerColorEffect *parent)
: parent_(parent),
active_color_{0, 0, 0}
{}
active_color_{0, 0, 0} {}
void LEDActiveLayerColorEffect::setColormap(const cRGB colormap[]) {
colormap_ = colormap;

8
plugins/Kaleidoscope-LED-ActiveLayerColor/src/kaleidoscope/plugin/LED-ActiveLayerColor.h
Unescape View File

@ -28,8 +28,8 @@
namespace kaleidoscope {
namespace plugin {
class LEDActiveLayerColorEffect : public Plugin,
public LEDModeInterface,
public AccessTransientLEDMode {
public LEDModeInterface,
public AccessTransientLEDMode {
public:
LEDActiveLayerColorEffect(void) {}
@ -40,7 +40,6 @@ class LEDActiveLayerColorEffect : public Plugin,
//
class TransientLEDMode : public LEDMode {
public:
// Please note that storing the parent ptr is only required
// for those LED modes that require access to
// members of their parent class. Most LED modes can do without.
@ -48,12 +47,10 @@ class LEDActiveLayerColorEffect : public Plugin,
explicit TransientLEDMode(const LEDActiveLayerColorEffect *parent);
protected:
void onActivate(void) final;
void refreshAt(KeyAddr key_addr) final;
private:
const LEDActiveLayerColorEffect *parent_;
cRGB active_color_;
@ -64,7 +61,6 @@ class LEDActiveLayerColorEffect : public Plugin,
};
private:
static const cRGB *colormap_;
};

16
plugins/Kaleidoscope-LED-ActiveModColor/src/kaleidoscope/plugin/LED-ActiveModColor.cpp
Unescape View File

@ -17,8 +17,8 @@
#include "kaleidoscope/plugin/LED-ActiveModColor.h"
#include <Kaleidoscope-OneShot.h> // for OneShot
#include <Kaleidoscope-OneShotMetaKeys.h> // for OneShot_ActiveStickyKey
#include <Kaleidoscope-OneShot.h> // for OneShot
#include <Kaleidoscope-OneShotMetaKeys.h> // for OneShot_ActiveStickyKey
#include "kaleidoscope/KeyAddr.h" // for KeyAddr, MatrixAddr
#include "kaleidoscope/KeyAddrBitfield.h" // for KeyAddrBitfield, KeyA...
@ -37,14 +37,14 @@ KeyAddrBitfield ActiveModColorEffect::mod_key_bits_;
bool ActiveModColorEffect::highlight_normal_modifiers_ = true;
cRGB ActiveModColorEffect::highlight_color_ = CRGB(160, 160, 160);
cRGB ActiveModColorEffect::oneshot_color_ = CRGB(160, 160, 0);
cRGB ActiveModColorEffect::sticky_color_ = CRGB(160, 0, 0);
cRGB ActiveModColorEffect::oneshot_color_ = CRGB(160, 160, 0);
cRGB ActiveModColorEffect::sticky_color_ = CRGB(160, 0, 0);
// -----------------------------------------------------------------------------
EventHandlerResult ActiveModColorEffect::onKeyEvent(KeyEvent &event) {
// If `event.addr` is not a physical key address, ignore it:
if (! event.addr.isValid()) {
if (!event.addr.isValid()) {
return EventHandlerResult::OK;
}
@ -70,7 +70,7 @@ EventHandlerResult ActiveModColorEffect::onKeyEvent(KeyEvent &event) {
mod_key_bits_.set(entry_addr);
}
}
} else { // if (keyToggledOff(event.state))
} else { // if (keyToggledOff(event.state))
// Things get a bit ugly here because this plugin might come before OneShot
// in the order, so we can't just count on OneShot stopping the suppressed
// release event before we see it here.
@ -104,7 +104,7 @@ EventHandlerResult ActiveModColorEffect::beforeSyncingLeds() {
return EventHandlerResult::OK;
}
} // namespace plugin
} // namespace kaleidoscope
} // namespace plugin
} // namespace kaleidoscope
kaleidoscope::plugin::ActiveModColorEffect ActiveModColorEffect;

4
plugins/Kaleidoscope-LED-AlphaSquare/src/Kaleidoscope-LED-AlphaSquare.h
Unescape View File

@ -17,6 +17,6 @@
#pragma once
#include "kaleidoscope/plugin/LED-AlphaSquare.h" // IWYU pragma: export
#include "kaleidoscope/plugin/LED-AlphaSquare/Effect.h" // IWYU pragma: export
#include "kaleidoscope/plugin/LED-AlphaSquare.h" // IWYU pragma: export
#include "kaleidoscope/plugin/LED-AlphaSquare/Effect.h" // IWYU pragma: export
#include "kaleidoscope/plugin/LED-AlphaSquare/Symbols.h" // IWYU pragma: export

21
plugins/Kaleidoscope-LED-AlphaSquare/src/kaleidoscope/plugin/LED-AlphaSquare.cpp
Unescape View File

@ -17,14 +17,14 @@
#include "kaleidoscope/plugin/LED-AlphaSquare.h"
#include <Arduino.h> // for bitRead
#include <stdint.h> // for uint16_t
#include <Arduino.h> // for bitRead
#include <stdint.h> // for uint16_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/Runtime.h" // for Runtime
#include "kaleidoscope/device/device.h" // for cRGB
#include "kaleidoscope/key_defs.h" // for Key, Key_A
#include "kaleidoscope/plugin/LEDControl.h" // for LEDControl
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/Runtime.h" // for Runtime
#include "kaleidoscope/device/device.h" // for cRGB
#include "kaleidoscope/key_defs.h" // for Key, Key_A
#include "kaleidoscope/plugin/LEDControl.h" // for LEDControl
#include "kaleidoscope/plugin/LED-AlphaSquare/Font-4x4.h" // for ALPHASQUAR...
@ -67,8 +67,7 @@ static const uint16_t alphabet[] PROGMEM = {
ALPHASQUARE_SYMBOL_7,
ALPHASQUARE_SYMBOL_8,
ALPHASQUARE_SYMBOL_9,
ALPHASQUARE_SYMBOL_0
};
ALPHASQUARE_SYMBOL_0};
cRGB AlphaSquare::color = {0x80, 0x80, 0x80};
@ -80,7 +79,7 @@ void AlphaSquare::display(Key key, KeyAddr key_addr, cRGB key_color) {
if (key < Key_A || key > Key_0)
return;
uint8_t index = key.getKeyCode() - Key_A.getKeyCode();
uint8_t index = key.getKeyCode() - Key_A.getKeyCode();
uint16_t symbol = pgm_read_word(&alphabet[index]);
display(symbol, key_addr, key_color);
@ -122,7 +121,7 @@ bool AlphaSquare::isSymbolPart(Key key,
if (key < Key_A || key > Key_0)
return false;
uint8_t index = key.getKeyCode() - Key_A.getKeyCode();
uint8_t index = key.getKeyCode() - Key_A.getKeyCode();
uint16_t symbol = pgm_read_word(&alphabet[index]);
return isSymbolPart(symbol, displayLedAddr, key_addr);

3
plugins/Kaleidoscope-LED-AlphaSquare/src/kaleidoscope/plugin/LED-AlphaSquare.h
Unescape View File

@ -17,7 +17,7 @@
#pragma once
#include <stdint.h> // for uint16_t, uint8_t
#include <stdint.h> // for uint16_t, uint8_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/key_defs.h" // for Key
@ -42,7 +42,6 @@ namespace kaleidoscope {
namespace plugin {
class AlphaSquare : public kaleidoscope::Plugin {
public:
AlphaSquare(void) {}
static void display(Key key, KeyAddr key_addr, cRGB key_color);

39
plugins/Kaleidoscope-LED-AlphaSquare/src/kaleidoscope/plugin/LED-AlphaSquare/Effect.cpp
Unescape View File

@ -17,16 +17,16 @@
#include "kaleidoscope/plugin/LED-AlphaSquare/Effect.h"
#include <stdint.h> // for uint16_t, uint8_t
#include <stdint.h> // for uint16_t, uint8_t
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/device/device.h" // for Device, CRGB
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
#include "kaleidoscope/key_defs.h" // for Key, Key_NoKey, Key_0
#include "kaleidoscope/keyswitch_state.h" // for keyIsInjected
#include "kaleidoscope/plugin/LEDControl.h" // for LEDControl
#include "kaleidoscope/KeyAddr.h" // for KeyAddr
#include "kaleidoscope/KeyEvent.h" // for KeyEvent
#include "kaleidoscope/Runtime.h" // for Runtime, Runtime_
#include "kaleidoscope/device/device.h" // for Device, CRGB
#include "kaleidoscope/event_handler_result.h" // for EventHandlerResult
#include "kaleidoscope/key_defs.h" // for Key, Key_NoKey, Key_0
#include "kaleidoscope/keyswitch_state.h" // for keyIsInjected
#include "kaleidoscope/plugin/LEDControl.h" // for LEDControl
#include "kaleidoscope/plugin/LED-AlphaSquare.h" // for AlphaSquare
@ -35,10 +35,9 @@ namespace plugin {
uint16_t AlphaSquareEffect::length = 1000;
AlphaSquareEffect::TransientLEDMode::TransientLEDMode(AlphaSquareEffect */*parent*/) // NOLINT(readability/casting)
AlphaSquareEffect::TransientLEDMode::TransientLEDMode(AlphaSquareEffect * /*parent*/) // NOLINT(readability/casting)
: last_key_left_(Key_NoKey),
last_key_right_(Key_NoKey)
{}
last_key_right_(Key_NoKey) {}
void AlphaSquareEffect::TransientLEDMode::update(void) {
if (!Runtime.has_leds)
@ -59,14 +58,14 @@ void AlphaSquareEffect::TransientLEDMode::update(void) {
void AlphaSquareEffect::TransientLEDMode::refreshAt(KeyAddr key_addr) {
bool timed_out;
uint8_t display_col = 2;
Key key = last_key_left_;
Key key = last_key_left_;
if (key_addr.col() < Runtime.device().matrix_columns / 2) {
timed_out = Runtime.hasTimeExpired(start_time_left_, length);
} else {
key = last_key_right_;
key = last_key_right_;
display_col = 10;
timed_out = Runtime.hasTimeExpired(start_time_right_, length);
timed_out = Runtime.hasTimeExpired(start_time_right_, length);
}
if (!::AlphaSquare.isSymbolPart(key, KeyAddr(0, display_col), key_addr) || timed_out)
@ -90,18 +89,18 @@ EventHandlerResult AlphaSquareEffect::onKeyEvent(KeyEvent &event) {
// return EventHandlerResult::OK;
uint8_t display_col = 2;
auto this_led_mode = ::LEDControl.get_mode<TransientLEDMode>();
auto this_led_mode = ::LEDControl.get_mode<TransientLEDMode>();
Key prev_key = this_led_mode->last_key_left_;
if (event.addr.col() < Runtime.device().matrix_columns / 2) {
this_led_mode->last_key_left_ = event.key;
this_led_mode->last_key_left_ = event.key;
this_led_mode->start_time_left_ = Runtime.millisAtCycleStart();
} else {
prev_key = this_led_mode->last_key_right_;
this_led_mode->last_key_right_ = event.key;
prev_key = this_led_mode->last_key_right_;
this_led_mode->last_key_right_ = event.key;
this_led_mode->start_time_right_ = Runtime.millisAtCycleStart();
display_col = 10;
display_col = 10;
}
if (prev_key != event.key)

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save