dd Honeycomb macropad (#5000)

* Add Honeycome macropad

* Replace pragma, update info

* Update code based on review

keyboards/honeycomb/config.h

@@ -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)

keyboards/honeycomb/honeycomb.c

@@ -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) {
+
+}

keyboards/honeycomb/honeycomb.h

@@ -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 } \
+}

keyboards/honeycomb/keymaps/default/keymap.c

@@ -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--;
+	}
+};

keyboards/honeycomb/matrix.c

@@ -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;
+}

keyboards/honeycomb/rules.mk

@@ -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)