yohan/qmk_firmware
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

dd Honeycomb macropad (#5000)

Browse Source 
* Add Honeycome macropad

* Replace pragma, update info

* Update code based on review
This commit is contained in:
Carlos 2019-02-05 10:59:10 -07:00 committed by Drashna Jaelre
parent 612dc232d7
commit d4e1e712f6
7 changed files with 575 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
keyboards/honeycomb/config.h Executable file
View File

@ -0,0 +1,65 @@
/*
Copyright 2019 @filoxo
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "config_common.h"
/* USB Device descriptor parameter */
#define VENDOR_ID 0xFEED
#define PRODUCT_ID 0xACC8
#define DEVICE_VER 0x0001
#define MANUFACTURER Keyhive
#define PRODUCT Honeycomb Macropad
#define DESCRIPTION QMK firmware for Honeycomb Macropad
/* key matrix size */
#define MATRIX_ROWS 1
#define MATRIX_COLS 16
#define ONESHOT_TIMEOUT 500
/* disable debug print */
//#define NO_DEBUG
/* disable print */
//#define NO_PRINT
/* disable action features */
//#define NO_ACTION_LAYER
//#define NO_ACTION_TAPPING
//#define NO_ACTION_ONESHOT
//#define NO_ACTION_MACRO
//#define NO_ACTION_FUNCTION
//UART settings for communication with the RF microcontroller
#define SERIAL_UART_BAUD 1000000
#define SERIAL_UART_DATA UDR1
#define SERIAL_UART_UBRR (F_CPU / (16UL * SERIAL_UART_BAUD) - 1)
#define SERIAL_UART_TXD_READY (UCSR1A & _BV(UDRE1))
#define SERIAL_UART_RXD_PRESENT (UCSR1A & _BV(RXC1))
#define SERIAL_UART_INIT() do { \
/* baud rate */ \
UBRR1L = SERIAL_UART_UBRR; \
/* baud rate */ \
UBRR1H = SERIAL_UART_UBRR >> 8; \
/* enable TX and RX */ \
UCSR1B = _BV(TXEN1) | _BV(RXEN1); \
/* 8-bit data */ \
UCSR1C = _BV(UCSZ11) | _BV(UCSZ10); \
} while(0)

92
keyboards/honeycomb/honeycomb.c Executable file
View File

@ -0,0 +1,92 @@
#include "honeycomb.h"
#include "pointing_device.h"
#include "report.h"
void uart_init(void) {
SERIAL_UART_INIT();
}
void pointing_device_task(void){
/*report_mouse_t currentReport = {};
SERIAL_UART_INIT();
uint32_t timeout = 0;
//the m character requests the RF slave to send the mouse report
SERIAL_UART_DATA = 'm';
//trust the external inputs completely, erase old data
uint8_t uart_data[5] = {0};
//there are 10 bytes corresponding to 10 columns, and an end byte
for (uint8_t i = 0; i < 5; i++) {
//wait for the serial data, timeout if it's been too long
//this only happened in testing with a loose wire, but does no
//harm to leave it in here
while(!SERIAL_UART_RXD_PRESENT){
timeout++;
if (timeout > 10000){
xprintf("\r\nTIMED OUT");
break;
}
}
xprintf("\r\nGOT DATA for %d",i);
uart_data[i] = SERIAL_UART_DATA;
}
//check for the end packet, bytes 1-4 are movement and scroll
//but byte 5 has bits 0-3 for the scroll button state
//(1000 if pressed, 0000 if not) and bits 4-7 are always 1
//We can use this to verify the report sent properly.
if (uart_data[4] == 0x0F || uart_data[4] == 0x8F)
{
xprintf("\r\nREQUESTED MOUSE, RECEIVED %i, %i, %i, %i, %i",uart_data[0],uart_data[1],uart_data[2],uart_data[3],uart_data[4]);
currentReport = pointing_device_get_report();
//shifting and transferring the info to the mouse report varaible
//mouseReport.x = 127 max -127 min
currentReport.x = (int8_t) uart_data[0];
//mouseReport.y = 127 max -127 min
currentReport.y = (int8_t) uart_data[1];
//mouseReport.v = 127 max -127 min (scroll vertical)
currentReport.v = (int8_t) uart_data[2];
//mouseReport.h = 127 max -127 min (scroll horizontal)
currentReport.h = (int8_t) uart_data[3];
//mouseReport.buttons = 0x31 max (bitmask for mouse buttons 1-5) 0x00 min
//mouse buttons 1 and 2 are handled by the keymap, but not 3
if (uart_data[4] == 0x0F) { //then 3 is not pressed
currentReport.buttons &= ~MOUSE_BTN3; //MOUSE_BTN3 is def in report.h
} else { //3 must be pressed
currentReport.buttons |= MOUSE_BTN3;
}
pointing_device_set_report(currentReport);
} else {
xprintf("\r\nRequested packet, data 4 was %d",uart_data[4]);
}*/
pointing_device_send();
}
void led_init(void) {
setPinOutput(D1);
writePinHigh(D1);
setPinOutput(F4);
writePinHigh(F4);
setPinOutput(F5);
writePinHigh(F5);
}
void matrix_init_kb(void) {
// put your keyboard start-up code here
// runs once when the firmware starts up
matrix_init_user();
uart_init();
led_init();
}
void matrix_scan_kb(void) {
// put your looping keyboard code here
// runs every cycle (a lot)
matrix_scan_user();
}
void led_set_kb(uint8_t usb_led) {
}

37
keyboards/honeycomb/honeycomb.h Executable file
View File

@ -0,0 +1,37 @@
#pragma once
#define HONEYCOMB_H
#include "quantum.h"
#include "matrix.h"
#include "backlight.h"
#include <stddef.h>
#define RED_LED_OFF() writePinHigh(F6)
#define RED_LED_ON() writePinLow(F6)
#define BLU_LED_OFF() writePinHigh(F5)
#define BLU_LED_ON() writePinLow(F5)
#define GRN_LED_OFF() writePinHigh(D1)
#define GRN_LED_ON() writePinLow(D1)
#define SET_LED_OFF (RED_LED_OFF(); GRN_LED_OFF(); BLU_LED_OFF(); )
#define SET_LED_RED (RED_LED_ON(); GRN_LED_OFF(); BLU_LED_OFF(); )
#define SET_LED_BLUE (RED_LED_OFF(); GRN_LED_OFF(); BLU_LED_ON(); )
#define SET_LED_GREEN (RED_LED_OFF(); GRN_LED_ON(); BLU_LED_OFF(); )
#define SET_LED_YELLOW (RED_LED_ON(); GRN_LED_ON(); BLU_LED_OFF(); )
#define SET_LED_MAGENTA (RED_LED_ON(); GRN_LED_OFF(); BLU_LED_ON(); )
#define SET_LED_CYAN (RED_LED_OFF(); GRN_LED_ON(); BLU_LED_ON(); )
#define SET_LED_WHITE (RED_LED_ON(); GRN_LED_ON(); BLU_LED_ON(); )
// This a shortcut to help you visually see your layout.
// The first section contains all of the arguements
// The second converts the arguments into a two-dimensional array
#define LAYOUT( \
k13, k14, k15, k16, \
k09, k10, k11, k12, \
k05, k06, k07, k08, \
k01, k02, k03, k04 \
) \
{ \
{ k01, k02, k03, k04, k05, k06, k07, k08, k09, k10, k11, k12, k13, k14, k15, k16 } \
}

91
keyboards/honeycomb/keymaps/default/keymap.c Executable file
View File

@ -0,0 +1,91 @@
#include QMK_KEYBOARD_H
// Each layer gets a name for readability, which is then used in the keymap matrix below.
// The underscores don't mean anything - you can have a layer called STUFF or any other name.
// Layer names don't all need to be of the same length, obviously, and you can also skip them
// entirely and just use numbers.
enum honeycomb_layers {
_BS,
_EN
};
// Macro definitions for readability
enum honeycomb_keycodes {
HW = SAFE_RANGE,
COPY,
PASTA
};
extern int8_t encoderValue;
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_BS] = LAYOUT( /* Base layout, put whatever defaults. */
HW, COPY, PASTA, KC_MUTE,
KC_4, KC_5, KC_6, KC_7,
KC_8, KC_9, KC_A, KC_B,
KC_C, KC_D, KC_E, KC_F
),
[_EN] = LAYOUT( /* Alternate layer */
_______, _______, _______, _______,
_______, _______, _______, _______,
_______, _______, _______, _______,
_______, _______, _______, _______
)
};
report_mouse_t currentReport = {};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
//uint8_t layer = biton32(layer_state); // get the current layer
// Basic example functions
switch (keycode) {
case HW:
if (record->event.pressed) {
SEND_STRING("Hello, world!");
} else {
SEND_STRING("Goodbye, cruel world!");
}
break;
case COPY:
if (record->event.pressed) {
tap_code16(LCTL(KC_C)); // Replace with tap_code16(LCMD(KC_C)) to enable for Mac
}
break;
case PASTA:
if (record->event.pressed) {
tap_code16(LCTL(KC_V)); // Replace with tap_code16(LCMD(KC_V)) to enable for Mac
}
break;
return false;
}
return true;
};
void matrix_scan_user(void) {
/* Leaving some LED stuff in here in comment form so you can see how to use it.
if (shiftLED || capsLED){
red_led_on;
} else {
red_led_off;
}
if (numLED){
grn_led_on;
} else {
grn_led_off;
}
if (mouseLED){
blu_led_on;
} else {
blu_led_off;
}*/
while (encoderValue < 0){
tap_code(KC_VOLD);
encoderValue++;
}
while (encoderValue > 0){
tap_code(KC_VOLU);
encoderValue--;
}
};

202
keyboards/honeycomb/matrix.c Executable file
View File

@ -0,0 +1,202 @@
/*
Copyright 2012 Jun Wako
Copyright 2014 Jack Humbert
Copyright 2019 @filoxo
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdint.h>
#include <stdbool.h>
#if defined(__AVR__)
#include <avr/io.h>
#endif
#include "wait.h"
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h"
#include "timer.h"
#include "honeycomb.h"
#include "pointing_device.h"
#include "report.h"
#if (MATRIX_COLS <= 8)
# define print_matrix_header() print("\nr/c 01234567\n")
# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
# define matrix_bitpop(i) bitpop(matrix[i])
# define ROW_SHIFTER ((uint8_t)1)
#elif (MATRIX_COLS <= 16)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse16(matrix_get_row(row))
# define matrix_bitpop(i) bitpop16(matrix[i])
# define ROW_SHIFTER ((uint16_t)1)
#elif (MATRIX_COLS <= 32)
# define print_matrix_header() print("\nr/c 0123456789ABCDEF0123456789ABCDEF\n")
# define print_matrix_row(row) print_bin_reverse32(matrix_get_row(row))
# define matrix_bitpop(i) bitpop32(matrix[i])
# define ROW_SHIFTER ((uint32_t)1)
#endif
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
//extern int8_t encoderValue;
int8_t encoderValue = 0;
__attribute__ ((weak))
void matrix_init_quantum(void) {
matrix_init_kb();
}
__attribute__ ((weak))
void matrix_scan_quantum(void) {
matrix_scan_kb();
}
__attribute__ ((weak))
void matrix_init_kb(void) {
matrix_init_user();
}
__attribute__ ((weak))
void matrix_scan_kb(void) {
matrix_scan_user();
}
__attribute__ ((weak))
void matrix_init_user(void) {
}
__attribute__ ((weak))
void matrix_scan_user(void) {
}
inline
uint8_t matrix_rows(void) {
return MATRIX_ROWS;
}
inline
uint8_t matrix_cols(void) {
return MATRIX_COLS;
}
void matrix_init(void) {
matrix_init_quantum();
}
uint8_t matrix_scan(void)
{
SERIAL_UART_INIT();
uint32_t timeout = 0;
// The 's' character requests the RF slave to send the matrix
SERIAL_UART_DATA = 's';
// Trust the external keystates entirely, erase the last data
uint8_t uart_data[4] = {0};
// There are 3 bytes corresponding to the data, and a checksum
for (uint8_t i = 0; i < 4; i++) {
// Wait for the serial data, timeout if it's been too long
// This only happened in testing with a loose wire, but does no
// harm to leave it in here
while(!SERIAL_UART_RXD_PRESENT){
timeout++;
if (timeout > 10000){
xprintf("\r\nTime out in keyboard.");
break;
}
}
uart_data[i] = SERIAL_UART_DATA;
}
// Check for the end packet, it's our checksum.
// Will only be a match if the correct bytes were recieved
if (uart_data[3] == (uart_data[0] ^ uart_data[1] ^ uart_data[2])) { // This is an arbitrary checksum calculated by XORing all the data.
// Transferring the keystates to the QMK matrix variable
/* ASSUMING MSB FIRST */
matrix[0] = ((uint16_t) uart_data[0] << 8) | ((uint16_t) uart_data[1]);
encoderValue += (int8_t) uart_data[2];
if ((uart_data[0] | uart_data[1] | uart_data[2])!=0){
xprintf("\r\n0x%0X%02X%02X",uart_data[0],uart_data[1], uart_data[2]);
}
/* OK, TURNS OUT THAT WAS A BAD ASSUMPTION */
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
// I've unpacked these into the mirror image of what QMK expects them to be, so...
matrix[i] = bitrev16(matrix[i]);
// So I'll reverse it, and this should be fine now.
}
// A mouse report for scrolling would go here, but I don't plan on doing scrolling with the encoder. So.
report_mouse_t currentReport = {};
/*
currentReport = pointing_device_get_report();
//mouseReport.x = 127 max -127 min
currentReport.x = (int8_t) uart_data[6];
//mouseReport.y = 127 max -127 min
currentReport.y = (int8_t) uart_data[7];
//mouseReport.v = 127 max -127 min (scroll vertical)
currentReport.v = (int8_t) uart_data[8];
//mouseReport.h = 127 max -127 min (scroll horizontal)
currentReport.h = (int8_t) uart_data[9];
*/
/*
currentReport.x = 0;
currentReport.y = 0;
currentReport.v = 0;
currentReport.h = 0;*/
pointing_device_set_report(currentReport);
} else {
xprintf("\r\nRequested packet, data 3 was %d",uart_data[3]);
}
matrix_scan_quantum();
return 1;
}
inline
bool matrix_is_on(uint8_t row, uint8_t col)
{
return (matrix[row] & ((matrix_row_t)1<col));
}
inline
matrix_row_t matrix_get_row(uint8_t row)
{
return matrix[row];
}
void matrix_print(void)
{
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
phex(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += matrix_bitpop(i);
}
return count;
}

20
keyboards/honeycomb/readme.md Executable file
View File

@ -0,0 +1,20 @@
Honeycomb Keyboard Firmware
======================
These configuration files use a completely different 'matrix scan' system than other keyboards, it relies on an external nRF51822 microcontroller maintaining a matrix of keystates received from the macropad - it also receives rotary encoder information from the macropad. The matrix.c file contains the code to poll the external microcontroller for the key matrix, and the keymap.c file contains example code for encoder use. As long as the relevant functions in these files are not changed, all other QMK features are supported.
## Building
Run the following command in your terminal:
```
make honeycomb:default
# or use this to automatically flash the controller
make honeycomb:default:avrdude
```
Follow the QMK guide for this or ask in Discord.
### Other Keymaps
Because this is a totally custom macropad, it is recommended that you copy the `default/` folder, rename it as desired, and modify the `keymap.c` to your liking.

68
keyboards/honeycomb/rules.mk Executable file
View File

@ -0,0 +1,68 @@
# # project specific files
SRC += matrix.c
# MCU name
#MCU = at90usb1287
MCU = atmega32u4
# Processor frequency.
# This will define a symbol, F_CPU, in all source code files equal to the
# processor frequency in Hz. You can then use this symbol in your source code to
# calculate timings. Do NOT tack on a 'UL' at the end, this will be done
# automatically to create a 32-bit value in your source code.
#
# This will be an integer division of F_USB below, as it is sourced by
# F_USB after it has run through any CPU prescalers. Note that this value
# does not *change* the processor frequency - it should merely be updated to
# reflect the processor speed set externally so that the code can use accurate
# software delays.
F_CPU = 16000000
#
# LUFA specific
#
# Target architecture (see library "Board Types" documentation).
ARCH = AVR8
# Input clock frequency.
# This will define a symbol, F_USB, in all source code files equal to the
# input clock frequency (before any prescaling is performed) in Hz. This value may
# differ from F_CPU if prescaling is used on the latter, and is required as the
# raw input clock is fed directly to the PLL sections of the AVR for high speed
# clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
# at the end, this will be done automatically to create a 32-bit value in your
# source code.
#
# If no clock division is performed on the input clock inside the AVR (via the
# CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
F_USB = $(F_CPU)
# Interrupt driven control endpoint task(+60)
OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
BOOTLOADER = caterina
# Build Options
# comment out to disable the options.
#
#BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration(+1000)
#MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
POINTING_DEVICE_ENABLE = yes # Generic Pointer, not as big as mouse keys hopefully.
EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
CONSOLE_ENABLE = yes # Console for debug(+400)
COMMAND_ENABLE = yes # Commands for debug and configuration
CUSTOM_MATRIX = yes # Remote matrix from the wireless bridge
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
# SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend
NKRO_ENABLE = yes # USB Nkey Rollover - not yet supported in LUFA
# BACKLIGHT_ENABLE = yes # Enable keyboard backlight functionality
# MIDI_ENABLE = YES # MIDI controls
UNICODE_ENABLE = YES # Unicode
# BLUETOOTH_ENABLE = yes # Enable Bluetooth with the Adafruit EZ-Key HID
USB = /dev/ttyACM0
#upload: build
# $(honeycomb_UPLOAD_COMMAND)