localhots
/
qmk_firmware
1
0
Fork 0
Code Releases Activity

add not-so-minidox handwire keyboard (#3061) 

* add not-so-minidox handwire keyboard

* corrected keymap

* multiple adjustments to not_so_minidox keyboard

* remove I2C master left define

* update default layer set function

* move solenoid code into userspace

* minor adjustments to config.h

* update keymaps to utilize userspace

* move features and config to userspace, correct build issue

* correct solenoid pin

* adjust defaults for solenoid pin and enable

* default solenoid to on for not_so_minidox

* disable RGBLIGHT_SLEEP for xd75

* tweaking solenoid enable/disable in userspace and keymaps
This commit is contained in:
mtdjr 2018-05-31 11:30:05 -04:00 committed by Drashna Jaelre
parent 21ad968ac1
commit ee9a7aba39
31 changed files with 1792 additions and 593 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
keyboards/handwired/not_so_minidox/config.h Normal file
View File

@ -0,0 +1,84 @@
/*
Copyright 2012 Jun Wako <wakojun@gmail.com>
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/>.
*/
#ifndef CONFIG_H
#define CONFIG_H
#include "config_common.h"
/* USB Device descriptor parameter */
#define VENDOR_ID 0xFEED
#define PRODUCT_ID 0x3060
#define DEVICE_VER 0x0001
#define MANUFACTURER mtdjr
#define PRODUCT Not So MiniDox
#define DESCRIPTION A larger version of the MiniDox
/* key matrix size */
// Rows are doubled-up
#define MATRIX_ROWS 8
#define MATRIX_COLS 6
/* COL2ROW or ROW2COL */
#define DIODE_DIRECTION COL2ROW
// wiring of each half
#define MATRIX_ROW_PINS { D7, E6, B4, B5 }
#define MATRIX_COL_PINS { B6, B2, B3, B1, F7, D4 }
#define USE_SERIAL
//#define EE_HANDS
#define MASTER_LEFT
//#define MASTER_RIGHT
/* define if matrix has ghost */
//#define MATRIX_HAS_GHOST
/* number of backlight levels */
// #define BACKLIGHT_LEVELS 3
/* Set 0 if debouncing isn't needed */
#define DEBOUNCING_DELAY 5
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
#define LOCKING_SUPPORT_ENABLE
/* Locking resynchronize hack */
#define LOCKING_RESYNC_ENABLE
/* key combination for command */
#define IS_COMMAND() ( \
keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
)
/* 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
#endif

162
keyboards/handwired/not_so_minidox/i2c.c Normal file
View File

@ -0,0 +1,162 @@
#include <util/twi.h>
#include <avr/io.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#include <util/twi.h>
#include <stdbool.h>
#include "i2c.h"
#ifdef USE_I2C
// Limits the amount of we wait for any one i2c transaction.
// Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is
// 9 bits, a single transaction will take around 90μs to complete.
//
// (F_CPU/SCL_CLOCK) => # of μC cycles to transfer a bit
// poll loop takes at least 8 clock cycles to execute
#define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8
#define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE)
volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
static volatile uint8_t slave_buffer_pos;
static volatile bool slave_has_register_set = false;
// Wait for an i2c operation to finish
inline static
void i2c_delay(void) {
uint16_t lim = 0;
while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT)
lim++;
// easier way, but will wait slightly longer
// _delay_us(100);
}
// Setup twi to run at 100kHz
void i2c_master_init(void) {
// no prescaler
TWSR = 0;
// Set TWI clock frequency to SCL_CLOCK. Need TWBR>10.
// Check datasheets for more info.
TWBR = ((F_CPU/SCL_CLOCK)-16)/2;
}
// Start a transaction with the given i2c slave address. The direction of the
// transfer is set with I2C_READ and I2C_WRITE.
// returns: 0 => success
// 1 => error
uint8_t i2c_master_start(uint8_t address) {
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);
i2c_delay();
// check that we started successfully
if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
return 1;
TWDR = address;
TWCR = (1<<TWINT) | (1<<TWEN);
i2c_delay();
if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) )
return 1; // slave did not acknowledge
else
return 0; // success
}
// Finish the i2c transaction.
void i2c_master_stop(void) {
TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
uint16_t lim = 0;
while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT)
lim++;
}
// Write one byte to the i2c slave.
// returns 0 => slave ACK
// 1 => slave NACK
uint8_t i2c_master_write(uint8_t data) {
TWDR = data;
TWCR = (1<<TWINT) | (1<<TWEN);
i2c_delay();
// check if the slave acknowledged us
return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1;
}
// Read one byte from the i2c slave. If ack=1 the slave is acknowledged,
// if ack=0 the acknowledge bit is not set.
// returns: byte read from i2c device
uint8_t i2c_master_read(int ack) {
TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);
i2c_delay();
return TWDR;
}
void i2c_reset_state(void) {
TWCR = 0;
}
void i2c_slave_init(uint8_t address) {
TWAR = address << 0; // slave i2c address
// TWEN - twi enable
// TWEA - enable address acknowledgement
// TWINT - twi interrupt flag
// TWIE - enable the twi interrupt
TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
}
ISR(TWI_vect);
ISR(TWI_vect) {
uint8_t ack = 1;
switch(TW_STATUS) {
case TW_SR_SLA_ACK:
// this device has been addressed as a slave receiver
slave_has_register_set = false;
break;
case TW_SR_DATA_ACK:
// this device has received data as a slave receiver
// The first byte that we receive in this transaction sets the location
// of the read/write location of the slaves memory that it exposes over
// i2c. After that, bytes will be written at slave_buffer_pos, incrementing
// slave_buffer_pos after each write.
if(!slave_has_register_set) {
slave_buffer_pos = TWDR;
// don't acknowledge the master if this memory loctaion is out of bounds
if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) {
ack = 0;
slave_buffer_pos = 0;
}
slave_has_register_set = true;
} else {
i2c_slave_buffer[slave_buffer_pos] = TWDR;
BUFFER_POS_INC();
}
break;
case TW_ST_SLA_ACK:
case TW_ST_DATA_ACK:
// master has addressed this device as a slave transmitter and is
// requesting data.
TWDR = i2c_slave_buffer[slave_buffer_pos];
BUFFER_POS_INC();
break;
case TW_BUS_ERROR: // something went wrong, reset twi state
TWCR = 0;
default:
break;
}
// Reset everything, so we are ready for the next TWI interrupt
TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);
}
#endif

49
keyboards/handwired/not_so_minidox/i2c.h Normal file
View File

@ -0,0 +1,49 @@
#ifndef I2C_H
#define I2C_H
#include <stdint.h>
#ifndef F_CPU
#define F_CPU 16000000UL
#endif
#define I2C_READ 1
#define I2C_WRITE 0
#define I2C_ACK 1
#define I2C_NACK 0
#define SLAVE_BUFFER_SIZE 0x10
// i2c SCL clock frequency
#define SCL_CLOCK 400000L
extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
void i2c_master_init(void);
uint8_t i2c_master_start(uint8_t address);
void i2c_master_stop(void);
uint8_t i2c_master_write(uint8_t data);
uint8_t i2c_master_read(int);
void i2c_reset_state(void);
void i2c_slave_init(uint8_t address);
static inline unsigned char i2c_start_read(unsigned char addr) {
return i2c_master_start((addr << 1) | I2C_READ);
}
static inline unsigned char i2c_start_write(unsigned char addr) {
return i2c_master_start((addr << 1) | I2C_WRITE);
}
// from SSD1306 scrips
extern unsigned char i2c_rep_start(unsigned char addr);
extern void i2c_start_wait(unsigned char addr);
extern unsigned char i2c_readAck(void);
extern unsigned char i2c_readNak(void);
extern unsigned char i2c_read(unsigned char ack);
#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak();
#endif

121
keyboards/handwired/not_so_minidox/keymaps/default/keymap.c Normal file
View File

@ -0,0 +1,121 @@
#include QMK_KEYBOARD_H
extern keymap_config_t keymap_config;
// 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.
#define _QWERTY 0
#define _LOWER 1
#define _RAISE 2
#define _ADJUST 16
enum custom_keycodes {
QWERTY = SAFE_RANGE,
LOWER,
RAISE,
ADJUST,
};
// Fillers to make layering more clear
#define _______ KC_TRNS
#define XXXXXXX KC_NO
#define KC_LOWR LOWER
#define KC_RASE RAISE
#define KC_RST RESET
#define KC_CAD LCTL(LALT(KC_DEL))
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT(
// ,-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------.
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P,KC_BSPC,
// |-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------|
KC_LCTL, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L,KC_SCLN,KC_QUOT,
// |-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------|
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M,KC_COMM, KC_DOT,KC_SLSH, KC_ENT,
// '-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------'
KC_LGUI,KC_LOWR, KC_SPC, KC_SPC,KC_RASE,KC_RALT
// `-------+-------+-------` `-------+-------+-------`
),
[_LOWER] = LAYOUT(
// ,-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------.
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_DEL,
// |-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------|
_______,_______,_______,_______,_______,_______, _______,_______,_______,KC_LCBR,KC_RCBR,KC_BSLS,
// |-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------|
_______,_______,_______,_______,_______,_______, _______,_______,_______,_______,_______,_______,
// '-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------'
_______,_______,_______, _______,_______,_______
// `-------+-------+-------` `-------+-------+-------`
),
[_RAISE] = LAYOUT(
// ,-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------.
KC_GRV,KC_EXLM, KC_AT,KC_HASH, KC_DLR,KC_PERC, KC_CIRC,KC_AMPR,KC_ASTR,KC_LPRN,KC_RPRN, KC_DEL,
// |-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------|
_______,_______,_______,_______,KC_MINS, KC_EQL, _______, KC_UP,_______,KC_LBRC,KC_RBRC,KC_PIPE,
// |-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------|
_______,_______,_______,_______,_______,_______, KC_LEFT,KC_DOWN,KC_RGHT,_______,_______,_______,
// '-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------'
_______,_______,_______, _______,_______,_______
// `-------+-------+-------` `-------+-------+-------`
),
[_ADJUST] = LAYOUT(
// ,-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------.
_______,_______,_______,_______, KC_RST,_______, _______,_______,_______,_______,_______, KC_CAD,
// |-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------|
_______,_______,_______,_______,_______,_______, _______,_______,_______,_______,_______,_______,
// |-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------|
_______,_______,_______,_______,_______,_______, _______,_______,_______,_______,_______,_______,
// '-------+-------+-------+-------+-------+-------. ,-------+-------+-------+-------+-------+-------'
_______,_______,_______, _______,_______,_______
// `-------+-------+-------` `-------+-------+-------`
)
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY);
}
return false;
break;
case LOWER:
if (record->event.pressed) {
layer_on(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case RAISE:
if (record->event.pressed) {
layer_on(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case ADJUST:
if (record->event.pressed) {
layer_on(_ADJUST);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_ADJUST);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
}
return true;
}

11
keyboards/handwired/not_so_minidox/keymaps/mtdjr/config.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef CONFIG_USER_H
#define CONFIG_USER_H
#include QMK_KEYBOARD_CONFIG_H
#define SOLENOID_ENABLE
#define SOLENOID_PIN F6
#undef SOLENOID_ACTIVE
#define SOLENOID_ACTIVE true
#endif

56
keyboards/handwired/not_so_minidox/keymaps/mtdjr/keymap.c Normal file
View File

@ -0,0 +1,56 @@
#include QMK_KEYBOARD_H
#include "mtdjr.h"
extern keymap_config_t keymap_config;
#define KC_LOCK TD(TD_ALTLOCK)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_kc(
// ,----+-----+-----+-----+-----+-----, ,----+-----+-----+-----+-----+-----,
TAB, Q, W, E, R, T, Y, U, I, O, P, BSPC,
// |----+-----+-----+-----+-----+-----| |----+-----+-----+-----+-----+-----|
LCTL, A, S, D, F, G, H, J, K, L, SCLN, QUOT,
// |----+-----+-----+-----+-----+-----| |----+-----+-----+-----+-----+-----|
LSFT, Z, X, C, V, B, N, M, COMM, DOT, SLSH, ENT,
// |----+-----+-----+-----+-----+-----|-, ,-|----+-----+-----+-----+-----+-----|
LGUI, LOWR, SPC, SPC, RASE, LOCK
// `----+-----+-----` `----+-----+-----`
),
[_LOWER] = LAYOUT_kc(
// ,----+-----+-----+-----+-----+-----, ,----+-----+-----+-----+-----+-----,
ESC, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, DEL,
// |----+-----+-----+-----+-----+-----| |----+-----+-----+-----+-----+-----|
, , , , , , , , , LCBR, RCBR, BSLS,
// |----+-----+-----+-----+-----+-----| |----+-----+-----+-----+-----+-----|
, , , XCPY, XINS, , , , , , , ,
// |----+-----+-----+-----+-----+-----|-, ,-|----+-----+-----+-----+-----+-----|
, , , , ,
// `----+-----+-----` `----+-----+-----`
),
[_RAISE] = LAYOUT_kc(
// ,----+-----+-----+-----+-----+-----, ,----+-----+-----+-----+-----+-----,
GRV, EXLM, AT, HASH, DLR, PERC, CIRC, AMPR, ASTR, LPRN, RPRN, DEL,
// |----+-----+-----+-----+-----+-----| |----+-----+-----+-----+-----+-----|
, , , , MINS, EQL, , , UP, LBRC, RBRC, PIPE,
// |----+-----+-----+-----+-----+-----| |----+-----+-----+-----+-----+-----|
, , , , , , , LEFT, DOWN, RGHT, , ,
// |----+-----+-----+-----+-----+-----|-, ,-|----+-----+-----+-----+-----+-----|
, , , , ,
// `----+-----+-----` `----+-----+-----`
),
[_ADJUST] = LAYOUT_kc(
// ,----+-----+-----+-----+-----+-----, ,----+-----+-----+-----+-----+-----,
STOG, xxxx, xxxx, xxxx, RST, xxxx, ROOT, PPLY, PSEF, xxxx, xxxx, CAD,
// |----+-----+-----+-----+-----+-----| |----+-----+-----+-----+-----+-----|
SDM, SDP, SBOF, SBON, xxxx, xxxx, xxxx, xxxx, xxxx, xxxx, xxxx, xxxx,
// |----+-----+-----+-----+-----+-----| |----+-----+-----+-----+-----+-----|
xxxx, xxxx, xxxx, xxxx, xxxx, xxxx, xxxx, xxxx, xxxx, xxxx, xxxx, xxxx,
// |----+-----+-----+-----+-----+-----|-, ,-|----+-----+-----+-----+-----+-----|
xxxx, , xxxx, xxxx, , xxxx
// `----+-----+-----` `----+-----+-----`
)
};

1
keyboards/handwired/not_so_minidox/keymaps/mtdjr/rules.mk Normal file
View File

@ -0,0 +1 @@
TAP_DANCE_ENABLE = yes

307
keyboards/handwired/not_so_minidox/matrix.c Normal file
View File

@ -0,0 +1,307 @@
/*
Copyright 2012 Jun Wako <wakojun@gmail.com>
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/>.
*/
/*
* scan matrix
*/
#include <stdint.h>
#include <stdbool.h>
#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "print.h"
#include "debug.h"
#include "util.h"
#include "matrix.h"
#include "split_util.h"
#include "pro_micro.h"
#include "config.h"
#ifdef USE_I2C
# include "i2c.h"
#else // USE_SERIAL
# include "serial.h"
#endif
#ifndef DEBOUNCE
# define DEBOUNCE 5
#endif
#define ERROR_DISCONNECT_COUNT 5
static uint8_t debouncing = DEBOUNCE;
static const int ROWS_PER_HAND = MATRIX_ROWS/2;
static uint8_t error_count = 0;
static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
/* matrix state(1:on, 0:off) */
static matrix_row_t matrix[MATRIX_ROWS];
static matrix_row_t matrix_debouncing[MATRIX_ROWS];
static matrix_row_t read_cols(void);
static void init_cols(void);
static void unselect_rows(void);
static void select_row(uint8_t row);
__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)
{
debug_enable = true;
debug_matrix = true;
debug_mouse = true;
// initialize row and col
unselect_rows();
init_cols();
TX_RX_LED_INIT;
// initialize matrix state: all keys off
for (uint8_t i=0; i < MATRIX_ROWS; i++) {
matrix[i] = 0;
matrix_debouncing[i] = 0;
}
matrix_init_quantum();
}
uint8_t _matrix_scan(void)
{
// Right hand is stored after the left in the matirx so, we need to offset it
int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
select_row(i);
_delay_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols();
if (matrix_debouncing[i+offset] != cols) {
matrix_debouncing[i+offset] = cols;
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
matrix[i+offset] = matrix_debouncing[i+offset];
}
}
}
return 1;
}
#ifdef USE_I2C
// Get rows from other half over i2c
int i2c_transaction(void) {
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
if (err) goto i2c_error;
// start of matrix stored at 0x00
err = i2c_master_write(0x00);
if (err) goto i2c_error;
// Start read
err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
if (err) goto i2c_error;
if (!err) {
int i;
for (i = 0; i < ROWS_PER_HAND-1; ++i) {
matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
}
matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
i2c_master_stop();
} else {
i2c_error: // the cable is disconnceted, or something else went wrong
i2c_reset_state();
return err;
}
return 0;
}
#else // USE_SERIAL
int serial_transaction(void) {
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
if (serial_update_buffers()) {
return 1;
}
for (int i = 0; i < ROWS_PER_HAND; ++i) {
matrix[slaveOffset+i] = serial_slave_buffer[i];
}
return 0;
}
#endif
uint8_t matrix_scan(void)
{
int ret = _matrix_scan();
#ifdef USE_I2C
if( i2c_transaction() ) {
#else // USE_SERIAL
if( serial_transaction() ) {
#endif
// turn on the indicator led when halves are disconnected
TXLED1;
error_count++;
if (error_count > ERROR_DISCONNECT_COUNT) {
// reset other half if disconnected
int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
for (int i = 0; i < ROWS_PER_HAND; ++i) {
matrix[slaveOffset+i] = 0;
}
}
} else {
// turn off the indicator led on no error
TXLED0;
error_count = 0;
}
matrix_scan_quantum();
return ret;
}
void matrix_slave_scan(void) {
_matrix_scan();
int offset = (isLeftHand) ? 0 : (MATRIX_ROWS / 2);
#ifdef USE_I2C
for (int i = 0; i < ROWS_PER_HAND; ++i) {
/* i2c_slave_buffer[i] = matrix[offset+i]; */
i2c_slave_buffer[i] = matrix[offset+i];
}
#else // USE_SERIAL
for (int i = 0; i < ROWS_PER_HAND; ++i) {
serial_slave_buffer[i] = matrix[offset+i];
}
#endif
}
bool matrix_is_modified(void)
{
if (debouncing) return false;
return true;
}
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("\nr/c 0123456789ABCDEF\n");
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
phex(row); print(": ");
pbin_reverse16(matrix_get_row(row));
print("\n");
}
}
uint8_t matrix_key_count(void)
{
uint8_t count = 0;
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
count += bitpop16(matrix[i]);
}
return count;
}
static void init_cols(void)
{
for(int x = 0; x < MATRIX_COLS; x++) {
_SFR_IO8((col_pins[x] >> 4) + 1) &= ~_BV(col_pins[x] & 0xF);
_SFR_IO8((col_pins[x] >> 4) + 2) |= _BV(col_pins[x] & 0xF);
}
}
static matrix_row_t read_cols(void)
{
matrix_row_t result = 0;
for(int x = 0; x < MATRIX_COLS; x++) {
result |= (_SFR_IO8(col_pins[x] >> 4) & _BV(col_pins[x] & 0xF)) ? 0 : (1 << x);
}
return result;
}
static void unselect_rows(void)
{
for(int x = 0; x < ROWS_PER_HAND; x++) {
_SFR_IO8((row_pins[x] >> 4) + 1) &= ~_BV(row_pins[x] & 0xF);
_SFR_IO8((row_pins[x] >> 4) + 2) |= _BV(row_pins[x] & 0xF);
}
}
static void select_row(uint8_t row)
{
_SFR_IO8((row_pins[row] >> 4) + 1) |= _BV(row_pins[row] & 0xF);
_SFR_IO8((row_pins[row] >> 4) + 2) &= ~_BV(row_pins[row] & 0xF);
}

1
keyboards/handwired/not_so_minidox/not_so_minidox.c Normal file
View File

@ -0,0 +1 @@
#include "not_so_minidox.h"

42
keyboards/handwired/not_so_minidox/not_so_minidox.h Normal file
View File

@ -0,0 +1,42 @@
#ifndef NOSOTMINIDOX_H
#define NOSOTMINIDOX_H
#include "quantum.h"
#define LAYOUT( \
L00, L01, L02, L03, L04, L05, R05, R04, R03, R02, R01, R00, \
L10, L11, L12, L13, L14, L15, R15, R14, R13, R12, R11, R10, \
L20, L21, L22, L23, L24, L25, R25, R24, R23, R22, R21, R20, \
LT1, LT2, LT3, RT3, RT2, RT1 \
) \
{ \
{ L00, L01, L02, L03, L04, L05 }, \
{ L10, L11, L12, L13, L14, L15 }, \
{ L20, L21, L22, L23, L24, L25 }, \
{ KC_NO, KC_NO, KC_NO, LT1, LT2, LT3 }, \
{ R00, R01, R02, R03, R04, R05 }, \
{ R10, R11, R12, R13, R14, R15 }, \
{ R20, R21, R22, R23, R24, R25 }, \
{ KC_NO, KC_NO, KC_NO, RT1, RT2, RT3 }, \
}
// Used to create a keymap using only KC_ prefixed keys
#define LAYOUT_kc( \
L00, L01, L02, L03, L04, L05, R05, R04, R03, R02, R01, R00, \
L10, L11, L12, L13, L14, L15, R15, R14, R13, R12, R11, R10, \
L20, L21, L22, L23, L24, L25, R25, R24, R23, R22, R21, R20, \
LT1, LT2, LT3, RT3, RT2, RT1 \
) \
{ \
{ KC_##L00, KC_##L01, KC_##L02, KC_##L03, KC_##L04, KC_##L05 }, \
{ KC_##L10, KC_##L11, KC_##L12, KC_##L13, KC_##L14, KC_##L15 }, \
{ KC_##L20, KC_##L21, KC_##L22, KC_##L23, KC_##L24, KC_##L25 }, \
{ KC_NO, KC_NO, KC_NO, KC_##LT1, KC_##LT2, KC_##LT3 }, \
{ KC_##R00, KC_##R01, KC_##R02, KC_##R03, KC_##R04, KC_##R05 }, \
{ KC_##R10, KC_##R11, KC_##R12, KC_##R13, KC_##R14, KC_##R15 }, \
{ KC_##R20, KC_##R21, KC_##R22, KC_##R23, KC_##R24, KC_##R25 }, \
{ KC_NO, KC_NO, KC_NO, KC_##RT1, KC_##RT2, KC_##RT3 }, \
}
#endif

71
keyboards/handwired/not_so_minidox/readme.md Normal file
View File

@ -0,0 +1,71 @@
not_so_minidox
=====
![not_so_minidox]()
A slightly larger version of the MiniDox
Keyboard Maintainer: mtdjr
Hardware Supported: None yet/ProMicro
Make example for this keyboard (after setting up your build environment):
make not_so_minidox/rev1:default
See [build environment setup](https://docs.qmk.fm/build_environment_setup.html) then the [make instructions](https://docs.qmk.fm/make_instructions.html) for more information.
Flashing
-------
Note: Most of this is copied from the Let's Split readme, because it is awesome
From the root directory run `make PROJECT:KEYMAP:avrdude` for automatic serial port resolution and flashing.
Example: `make not_so_minidox/rev1:default:avrdude`
Choosing which board to plug the USB cable into (choosing Master)
--------
Because the two boards are identical, the firmware has logic to differentiate the left and right board.
It uses two strategies to figure things out: look at the EEPROM (memory on the chip) or looks if the current board has the usb cable.
The EEPROM approach requires additional setup (flashing the eeeprom) but allows you to swap the usb cable to either side.
The USB cable approach is easier to setup and if you just want the usb cable on the left board, you do not need to do anything extra.
### Setting the left hand as master
If you always plug the usb cable into the left board, nothing extra is needed as this is the default. Comment out `EE_HANDS` and comment out `I2C_MASTER_RIGHT` or `MASTER_RIGHT` if for some reason it was set.
### Setting the right hand as master
If you always plug the usb cable into the right board, add an extra flag to your `config.h`
```
#define MASTER_RIGHT
```
### Setting EE_hands to use either hands as master
If you define `EE_HANDS` in your `config.h`, you will need to set the
EEPROM for the left and right halves.
The EEPROM is used to store whether the
half is left handed or right handed. This makes it so that the same firmware
file will run on both hands instead of having to flash left and right handed
versions of the firmware to each half. To flash the EEPROM file for the left
half run:
```
avrdude -p atmega32u4 -P $(COM_PORT) -c avr109 -U eeprom:w:eeprom-lefthand.eep
// or the equivalent in dfu-programmer
```
and similarly for right half
```
avrdude -p atmega32u4 -P $(COM_PORT) -c avr109 -U eeprom:w:eeprom-righhand.eep
// or the equivalent in dfu-programmer
```
NOTE: replace `$(COM_PORT)` with the port of your device (e.g. `/dev/ttyACM0`)
After you have flashed the EEPROM, you then need to set `EE_HANDS` in your config.h, rebuild the hex files and reflash.
Note that you need to program both halves, but you have the option of using
different keymaps for each half. You could program the left half with a QWERTY
layout and the right half with a Colemak layout using bootmagic's default layout option.
Then if you connect the left half to a computer by USB the keyboard will use QWERTY and Colemak when the
right half is connected.

71
keyboards/handwired/not_so_minidox/rules.mk Normal file
View File

@ -0,0 +1,71 @@
SRC += matrix.c \
i2c.c \
split_util.c \
serial.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)
# Bootloader
# This definition is optional, and if your keyboard supports multiple bootloaders of
# different sizes, comment this out, and the correct address will be loaded
# automatically (+60). See bootloader.mk for all options.
BOOTLOADER = caterina
# Interrupt driven control endpoint task(+60)
OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
# Build Options
# change to "no" to disable the options, or define them in the Makefile in
# the appropriate keymap folder that will get included automatically
#
BOOTMAGIC_ENABLE ?= no # Virtual DIP switch configuration(+1000)
MOUSEKEY_ENABLE ?= yes # Mouse keys(+4700)
EXTRAKEY_ENABLE ?= no # Audio control and System control(+450)
CONSOLE_ENABLE ?= no # Console for debug(+400)
COMMAND_ENABLE ?= yes # Commands for debug and configuration
NKRO_ENABLE ?= no # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
BACKLIGHT_ENABLE ?= no # Enable keyboard backlight functionality
MIDI_ENABLE ?= no # MIDI controls
AUDIO_ENABLE ?= no # Audio output on port C6
UNICODE_ENABLE ?= no # Unicode
BLUETOOTH_ENABLE ?= no # Enable Bluetooth with the Adafruit EZ-Key HID
RGBLIGHT_ENABLE ?= no # Enable WS2812 RGB underlight. Do not enable this with audio at the same time.
USE_I2C ?= no
# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
SLEEP_LED_ENABLE ?= no # Breathing sleep LED during USB suspend
CUSTOM_MATRIX = yes

228
keyboards/handwired/not_so_minidox/serial.c Normal file
View File

@ -0,0 +1,228 @@
/*
* WARNING: be careful changing this code, it is very timing dependent
*/
#ifndef F_CPU
#define F_CPU 16000000
#endif
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdbool.h>
#include "serial.h"
#ifndef USE_I2C
// Serial pulse period in microseconds. Its probably a bad idea to lower this
// value.
#define SERIAL_DELAY 24
uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
#define SLAVE_DATA_CORRUPT (1<<0)
volatile uint8_t status = 0;
inline static
void serial_delay(void) {
_delay_us(SERIAL_DELAY);
}
inline static
void serial_output(void) {
SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
}
// make the serial pin an input with pull-up resistor
inline static
void serial_input(void) {
SERIAL_PIN_DDR &= ~SERIAL_PIN_MASK;
SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
}
inline static
uint8_t serial_read_pin(void) {
return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
}
inline static
void serial_low(void) {
SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
}
inline static
void serial_high(void) {
SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
}
void serial_master_init(void) {
serial_output();
serial_high();
}
void serial_slave_init(void) {
serial_input();
// Enable INT0
EIMSK |= _BV(INT0);
// Trigger on falling edge of INT0
EICRA &= ~(_BV(ISC00) | _BV(ISC01));
}
// Used by the master to synchronize timing with the slave.
static
void sync_recv(void) {
serial_input();
// This shouldn't hang if the slave disconnects because the
// serial line will float to high if the slave does disconnect.
while (!serial_read_pin());
serial_delay();
}
// Used by the slave to send a synchronization signal to the master.
static
void sync_send(void) {
serial_output();
serial_low();
serial_delay();
serial_high();
}
// Reads a byte from the serial line
static
uint8_t serial_read_byte(void) {
uint8_t byte = 0;
serial_input();
for ( uint8_t i = 0; i < 8; ++i) {
byte = (byte << 1) | serial_read_pin();
serial_delay();
_delay_us(1);
}
return byte;
}
// Sends a byte with MSB ordering
static
void serial_write_byte(uint8_t data) {
uint8_t b = 8;
serial_output();
while( b-- ) {
if(data & (1 << b)) {
serial_high();
} else {
serial_low();
}
serial_delay();
}
}
// interrupt handle to be used by the slave device
ISR(SERIAL_PIN_INTERRUPT) {
sync_send();
uint8_t checksum = 0;
for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
serial_write_byte(serial_slave_buffer[i]);
sync_send();
checksum += serial_slave_buffer[i];
}
serial_write_byte(checksum);
sync_send();
// wait for the sync to finish sending
serial_delay();
// read the middle of pulses
_delay_us(SERIAL_DELAY/2);
uint8_t checksum_computed = 0;
for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
serial_master_buffer[i] = serial_read_byte();
sync_send();
checksum_computed += serial_master_buffer[i];
}
uint8_t checksum_received = serial_read_byte();
sync_send();
serial_input(); // end transaction
if ( checksum_computed != checksum_received ) {
status |= SLAVE_DATA_CORRUPT;
} else {
status &= ~SLAVE_DATA_CORRUPT;
}
}
inline
bool serial_slave_DATA_CORRUPT(void) {
return status & SLAVE_DATA_CORRUPT;
}
// Copies the serial_slave_buffer to the master and sends the
// serial_master_buffer to the slave.
//
// Returns:
// 0 => no error
// 1 => slave did not respond
int serial_update_buffers(void) {
// this code is very time dependent, so we need to disable interrupts
cli();
// signal to the slave that we want to start a transaction
serial_output();
serial_low();
_delay_us(1);
// wait for the slaves response
serial_input();
serial_high();
_delay_us(SERIAL_DELAY);
// check if the slave is present
if (serial_read_pin()) {
// slave failed to pull the line low, assume not present
sei();
return 1;
}
// if the slave is present syncronize with it
sync_recv();
uint8_t checksum_computed = 0;
// receive data from the slave
for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
serial_slave_buffer[i] = serial_read_byte();
sync_recv();
checksum_computed += serial_slave_buffer[i];
}
uint8_t checksum_received = serial_read_byte();
sync_recv();
if (checksum_computed != checksum_received) {
sei();
return 1;
}
uint8_t checksum = 0;
// send data to the slave
for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
serial_write_byte(serial_master_buffer[i]);
sync_recv();
checksum += serial_master_buffer[i];
}
serial_write_byte(checksum);
sync_recv();
// always, release the line when not in use
serial_output();
serial_high();
sei();
return 0;
}
#endif

26
keyboards/handwired/not_so_minidox/serial.h Normal file
View File

@ -0,0 +1,26 @@
#ifndef MY_SERIAL_H
#define MY_SERIAL_H
#include "config.h"
#include <stdbool.h>
/* TODO: some defines for interrupt setup */
#define SERIAL_PIN_DDR DDRD
#define SERIAL_PIN_PORT PORTD
#define SERIAL_PIN_INPUT PIND
#define SERIAL_PIN_MASK _BV(PD0)
#define SERIAL_PIN_INTERRUPT INT0_vect
#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
#define SERIAL_MASTER_BUFFER_LENGTH 1
// Buffers for master - slave communication
extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
void serial_master_init(void);
void serial_slave_init(void);
int serial_update_buffers(void);
bool serial_slave_data_corrupt(void);
#endif

84
keyboards/handwired/not_so_minidox/split_util.c Normal file
View File

@ -0,0 +1,84 @@
#include <avr/io.h>
#include <avr/wdt.h>
#include <avr/power.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <avr/eeprom.h>
#include "split_util.h"
#include "matrix.h"
#include "keyboard.h"
#include "config.h"
#ifdef USE_I2C
# include "i2c.h"
#else
# include "serial.h"
#endif
volatile bool isLeftHand = true;
static void setup_handedness(void) {
#ifdef EE_HANDS
isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);
#else
// I2C_MASTER_RIGHT is deprecated, use MASTER_RIGHT instead, since this works for both serial and i2c
#if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT)
isLeftHand = !has_usb();
#else
isLeftHand = has_usb();
#endif
#endif
}
static void keyboard_master_setup(void) {
#ifdef USE_I2C
i2c_master_init();
#ifdef SSD1306OLED
matrix_master_OLED_init ();
#endif
#else
serial_master_init();
#endif
}
static void keyboard_slave_setup(void) {
#ifdef USE_I2C
i2c_slave_init(SLAVE_I2C_ADDRESS);
#else
serial_slave_init();
#endif
}
bool has_usb(void) {
USBCON |= (1 << OTGPADE); //enables VBUS pad
_delay_us(5);
return (USBSTA & (1<<VBUS)); //checks state of VBUS
}
void split_keyboard_setup(void) {
setup_handedness();
if (has_usb()) {
keyboard_master_setup();
} else {
keyboard_slave_setup();
}
sei();
}
void keyboard_slave_loop(void) {
matrix_init();
while (1) {
matrix_slave_scan();
}
}
// this code runs before the usb and keyboard is initialized
void matrix_setup(void) {
split_keyboard_setup();
if (!has_usb()) {
keyboard_slave_loop();
}
}

20
keyboards/handwired/not_so_minidox/split_util.h Normal file
View File

@ -0,0 +1,20 @@
#ifndef SPLIT_KEYBOARD_UTIL_H
#define SPLIT_KEYBOARD_UTIL_H
#include <stdbool.h>
#include "eeconfig.h"
#define SLAVE_I2C_ADDRESS 0x32
extern volatile bool isLeftHand;
// slave version of matix scan, defined in matrix.c
void matrix_slave_scan(void);
void split_keyboard_setup(void);
bool has_usb(void);
void keyboard_slave_loop(void);
void matrix_master_OLED_init (void);
#endif

5
keyboards/iris/keymaps/mtdjr/config.h
View File

@ -20,6 +20,9 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "config_common.h" #include "config_common.h"
#define SOLENOID_ENABLE
#define SOLENOID_PIN C6
/* Use I2C or Serial, not both */ /* Use I2C or Serial, not both */
#define USE_SERIAL #define USE_SERIAL
@ -28,7 +31,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
/* Select hand configuration */ /* Select hand configuration */
#define MASTER_LEFT #define MASTER_LEFT
#define TAPPING_TERM 250
// #define MASTER_RIGHT // #define MASTER_RIGHT
// #define EE_HANDS // #define EE_HANDS

278
keyboards/iris/keymaps/mtdjr/keymap.c
View File

@ -1,145 +1,8 @@
#include "iris.h" #include QMK_KEYBOARD_H
#include "action_layer.h" #include "mtdjr.h"
#include "eeconfig.h"
#include "action_macro.h"
#include <timer.h>
#include "pincontrol.h"
extern keymap_config_t keymap_config; extern keymap_config_t keymap_config;
#define _QWERTY 0
#define _LOWER 1
#define _RAISE 2
#define _SUPER 3
#define _ADJUST 16
#define SOLENOID_DEFAULT_DWELL 12
#define SOLENOID_MAX_DWELL 100
#define SOLENOID_MIN_DWELL 4
#define SOLENOID_PIN C6
bool solenoid_enabled = false;
bool solenoid_on = false;
bool solenoid_buzz = false;
bool solenoid_buzzing = false;
uint16_t solenoid_start = 0;
uint8_t solenoid_dwell = SOLENOID_DEFAULT_DWELL;
void solenoid_buzz_on(void) {
solenoid_buzz = true;
}
void solenoid_buzz_off(void) {
solenoid_buzz = false;
}
void solenoid_dwell_minus(void) {
if (solenoid_dwell > 0) solenoid_dwell--;
}
void solenoid_dwell_plus(void) {
if (solenoid_dwell < SOLENOID_MAX_DWELL) solenoid_dwell++;
}
void solenoid_toggle(void) {
solenoid_enabled = !solenoid_enabled;
}
void solenoid_stop(void) {
digitalWrite(SOLENOID_PIN, PinLevelLow);
solenoid_on = false;
solenoid_buzzing = false;
}
void solenoid_fire(void) {
if (!solenoid_enabled) return;
if (!solenoid_buzz && solenoid_on) return;
if (solenoid_buzz && solenoid_buzzing) return;
solenoid_on = true;
solenoid_buzzing = true;
solenoid_start = timer_read();
digitalWrite(SOLENOID_PIN, PinLevelHigh);
}
void solenoid_check(void) {
uint16_t elapsed = 0;
if (!solenoid_on) return;
elapsed = timer_elapsed(solenoid_start);
//Check if it's time to finish this solenoid click cycle
if (elapsed > solenoid_dwell) {
solenoid_stop();
return;
}
//Check whether to buzz the solenoid on and off
if (solenoid_buzz) {
if (elapsed / SOLENOID_MIN_DWELL % 2 == 0){
if (!solenoid_buzzing) {
solenoid_buzzing = true;
digitalWrite(SOLENOID_PIN, PinLevelHigh);
}
}
else {
if (solenoid_buzzing) {
solenoid_buzzing = false;
digitalWrite(SOLENOID_PIN, PinLevelLow);
}
}
}
}
void solenoid_setup(void) {
pinMode(SOLENOID_PIN, PinDirectionOutput);
}
void matrix_init_user(void) {
solenoid_setup();
}
void matrix_scan_user(void) {
solenoid_check();
}
enum custom_keycodes {
QWERTY = SAFE_RANGE,
LOWER,
RAISE,
SUPER,
ADJUST,
SOL_TOG,
SOLENOID_DWELL_MINUS,
SOLENOID_DWELL_PLUS,
SOLENOID_BUZZ_ON,
SOLENOID_BUZZ_OFF,
TD_ESC = 0,
};
#define KC_ KC_TRNS
#define _______ KC_TRNS
#define KC_LOWR LOWER
#define KC_RASE RAISE
#define KC_SUPR SUPER
#define KC_RST RESET
#define KC_BL_S BL_STEP
#define KC_EXC TD(TD_ESC)
#define SOLTOG SOLENOID_TOG
// Macro Declarations
#define UM_ROOT M(0)
#define UM_PPLY M(1)
#define UM_PSEF M(2)
#define KC_XCPY M(3)
#define KC_XINS M(4)
#define UM_CAD M(5)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = LAYOUT_kc( [_QWERTY] = LAYOUT_kc(
@ -152,7 +15,7 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
//|----+----+----+----+----+----+----. ,----|----+----+----+----+----+----| //|----+----+----+----+----+----+----. ,----|----+----+----+----+----+----|
EQL, Z , X , C , V , B ,LGUI, LALT, N , M ,COMM,DOT ,SLSH,MINS, EQL, Z , X , C , V , B ,LGUI, LALT, N , M ,COMM,DOT ,SLSH,MINS,
//`----+----+----+--+-+----+----+----/ \----+----+----+----+----+----+----' //`----+----+----+--+-+----+----+----/ \----+----+----+----+----+----+----'
LCTL,RASE,SPC , SPC ,LOWR,SUPR LCTL,RASE,SPC , SPC ,LOWR,xxxx
// `----+----+----' `----+----+----' // `----+----+----' `----+----+----'
), ),
@ -178,130 +41,23 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
//|----+----+----+----+----+----| |----+----+----+----+----+----| //|----+----+----+----+----+----| |----+----+----+----+----+----|
, F9 ,F10 ,F11 ,F12 , , , , , , , , , F9 ,F10 ,F11 ,F12 , , , , , , , ,
//|----+----+----+----+----+----+----. ,----|----+----+----+----+----+----| //|----+----+----+----+----+----+----. ,----|----+----+----+----+----+----|
, , ,XCPY,XINS, , , , , , , , ,PLUS, , , ,XCPY,XINS, , , , , , , , , ,
//`----+----+----+--+-+----+----+----/ \----+----+----+----+----+----+----' //`----+----+----+--+-+----+----+----/ \----+----+----+----+----+----+----'
, , , , , , , , , ,
// `----+----+----' `----+----+----' // `----+----+----' `----+----+----'
), ),
[_SUPER] = LAYOUT( [_ADJUST] = LAYOUT_kc(
//,--------+--------+--------+--------+--------+--------. ,--------+--------+--------+--------+--------+--------. //,----+----+----+----+----+----. ,----+----+----+----+----+----.
SOL_TOG, UM_ROOT, UM_PPLY, UM_PSEF, _______, _______, _______, _______, _______, _______, _______, _______, STOG,ROOT,PPLY,PSEF,xxxx,xxxx, xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| //|----+----+----+----+----+----| |----+----+----+----+----+----|
_______, _______, _______, _______, _______, _______, _______, KC_LBRC, _______, _______, _______, _______, xxxx,xxxx,xxxx,xxxx,xxxx,xxxx, xxxx,xxxx,xxxx,xxxx,xxxx,BSLS,
//|--------+--------+--------+--------+--------+--------| |--------+--------+--------+--------+--------+--------| //|----+----+----+----+----+----| |----+----+----+----+----+----|
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, UM_CAD , xxxx,xxxx,xxxx,xxxx,xxxx,xxxx, xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,
//|--------+--------+--------+--------+--------+--------+--------. ,--------|--------+--------+--------+--------+--------+--------| //|----+----+----+----+----+----+----. ,----|----+----+----+----+----+----|
_______, _______, _______, _______, _______, _______, _______, _______, _______, KC_MUTE, KC_VOLD, KC_VOLU, KC_MNXT, KC_MPLY, xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx, xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,
//`--------+--------+--------+----+---+--------+--------+--------/ \--------+--------+--------+---+----+--------+--------+--------' //`----+----+----+--+-+----+----+----/ \----+----+----+----+----+----+----'
_______, _______, _______, _______, _______, _______ xxxx, ,xxxx, xxxx, ,
// `--------+--------+--------' `--------+--------+--------' // `----+----+----' `----+----+----'
) )
};
void persistent_default_layer_set(uint16_t default_layer) {
eeconfig_update_default_layer(default_layer);
default_layer_set(default_layer);
}
qk_tap_dance_action_t tap_dance_actions[] = {
//Tap once for grave accent, twice for ESC
[TD_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_GRV, KC_ESC)
};
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
if (record->event.pressed) {
solenoid_fire();
}
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
persistent_default_layer_set(1UL<<_QWERTY);
}
return false;
break;
case LOWER:
if (record->event.pressed) {
layer_on(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case RAISE:
if (record->event.pressed) {
layer_on(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case SUPER:
if (record->event.pressed) {
layer_on(_SUPER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_SUPER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case SOLTOG:
if (record->event.pressed) {
solenoid_toggle();
}
break;
case SOLENOID_DWELL_MINUS:
if (record->event.pressed) {
solenoid_dwell_minus();
}
break;
case SOLENOID_DWELL_PLUS:
if (record->event.pressed) {
solenoid_dwell_plus();
}
break;
case SOLENOID_BUZZ_ON:
if (record->event.pressed) {
solenoid_buzz_on();
}
break;
case SOLENOID_BUZZ_OFF:
if (record->event.pressed) {
solenoid_buzz_off();
}
break;
}
return true;
};
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
if (record->event.pressed) {
switch(id) {
case 0:
SEND_STRING("sudo su -\n");
return false; break;
case 1:
SEND_STRING("puppet apply /etc/puppetlabs/code/environments/production/manifests/site.pp\n");
return false; break;
case 2:
SEND_STRING("ps -ef | grep ");
return false; break;
case 3:
return MACRO(D(LCTL), T(INS), U(LCTL), END);
break;
case 4:
return MACRO(D(LSFT), T(INS), U(LSFT), END);
break;
case 5:
return MACRO(D(LCTL), D(RALT), T(DEL), END);
break;
}
}
return MACRO_NONE;
}; };

1
keyboards/iris/keymaps/mtdjr/rules.mk
View File

@ -1,6 +1,5 @@
RGBLIGHT_ENABLE = no RGBLIGHT_ENABLE = no
BACKLIGHT_ENABLE = no BACKLIGHT_ENABLE = no
TAP_DANCE_ENABLE = no
ifndef QUANTUM_DIR ifndef QUANTUM_DIR
include ../../../../Makefile include ../../../../Makefile

4
keyboards/lets_split/keymaps/mtdjr/config.h
View File

@ -23,11 +23,13 @@ along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "../../config.h" #include "../../config.h"
#define SOLENOID_ENABLE
#define SOLENOID_PIN F4
/* Use I2C or Serial, not both */ /* Use I2C or Serial, not both */
// #define USE_SERIAL // #define USE_SERIAL
#define USE_I2C #define USE_I2C
#define TAPPING_TERM 250
/* Select hand configuration */ /* Select hand configuration */
// #define MASTER_LEFT // #define MASTER_LEFT

253
keyboards/lets_split/keymaps/mtdjr/keymap.c
View File

@ -1,194 +1,81 @@
#include "lets_split.h" #include QMK_KEYBOARD_H
#include "action_layer.h" #include "mtdjr.h"
#include "eeconfig.h"
#include "action_macro.h"
extern keymap_config_t keymap_config; extern keymap_config_t keymap_config;
// 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.
#define _QWERTY 0
#define _LOWER 1
#define _RAISE 2
#define _ADJUST 16
enum custom_keycodes {
QWERTY = SAFE_RANGE,
LOWER,
RAISE,
ADJUST,
TD_ESC = 0
};
// Fillers to make layering more clear
#define _______ KC_TRNS
#define XXXXXXX KC_NO
// Macro Declarations
#define UM_ROOT M(0)
#define UM_PPLY M(1)
#define UM_COPY M(2)
#define UM_INSR M(3)
#define UM_PSEF M(4)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Qwerty /* Qwerty
* ,-----------------------------------------. ,-----------------------------------------. * ,-----------------------------------------. ,-----------------------------------------.
* | Tab | Q | W | E | R | T | | Y | U | I | O | P | Bksp | * | Tab | Q | W | E | R | T | | Y | U | I | O | P | Bksp |
* |------+------+------+------+------+------| |------+------+------+------+------+------| * |------+------+------+------+------+------| |------+------+------+------+------+------|
* |Esc/~ | A | S | D | F | G | | H | J | K | L | ; | '/" | * |Esc/~ | A | S | D | F | G | | H | J | K | L | ; | '/" |
* |------+------+------+------+------+------| |------+------+------+------+------+------| * |------+------+------+------+------+------| |------+------+------+------+------+------|
* | Shift| Z | X | C | V | B | | N | M | , | . | / |Enter | * | Shift| Z | X | C | V | B | | N | M | , | . | / |Enter |
* |------+------+------+------+------+------| |------+------+------+------+------+------| * |------+------+------+------+------+------| |------+------+------+------+------+------|
* |Adjust| Ctrl | Alt | GUI |Lower |Space | |Space |Raise | Left | Up | Down |Right | * |Adjust| Ctrl | Alt | GUI |Lower |Space | |Space |Raise | Left | Up | Down |Right |
* `-----------------------------------------' '-----------------------------------------' * `-----------------------------------------' '-----------------------------------------'
*/ */
[_QWERTY] = LAYOUT( \ [_QWERTY] = LAYOUT( \
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, \ KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, \
TD(TD_ESC), KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, \ KC_EXC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, \
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT , \ KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT , \
ADJUST, KC_LCTL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_UP, KC_DOWN, KC_RGHT \ ADJUST, KC_LCTL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_UP, KC_DOWN, KC_RGHT \
), ),
/* Lower /* Lower
* ,-----------------------------------------. ,-----------------------------------------. * ,-----------------------------------------. ,-----------------------------------------.
* | ~ | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | Bksp | * | ~ | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 0 | Bksp |
* |------+------+------+------+------+------| |------+------+------+------+------+------| * |------+------+------+------+------+------| |------+------+------+------+------+------|
* | | | [ | ] | { | } | | | 4 | 5 | 6 | * | \ | * | | | [ | ] | { | } | | | 4 | 5 | 6 | * | \ |
* |------+------+------+------+------+------| |------+------+------+------+------+------| * |------+------+------+------+------+------| |------+------+------+------+------+------|
* |Shift | | | copy |insert| | | | 1 | 2 | 3 | + | - | * |Shift | | | copy |insert| | | | 1 | 2 | 3 | + | - |
* |------+------+------+------+------+------| |------+------+------+------+------+------| * |------+------+------+------+------+------| |------+------+------+------+------+------|
* |Adjust| Ctrl | Alt | GUI |Lower |Space | |Space |Raise | 0 | . | = | _ | * |Adjust| Ctrl | Alt | GUI |Lower |Space | |Space |Raise | 0 | . | = | _ |
* `-----------------------------------------' '-----------------------------------------' * `-----------------------------------------' '-----------------------------------------'
*/ */
[_LOWER] = LAYOUT( \ [_LOWER] = LAYOUT( \
KC_TILD, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, _______, \ KC_TILD, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, _______, \
XXXXXXX, XXXXXXX, KC_LBRC, KC_RBRC, KC_LCBR, KC_RCBR, XXXXXXX, KC_4, KC_5, KC_6, KC_ASTR, KC_BSLS, \ XXXXXXX, XXXXXXX, KC_LBRC, KC_RBRC, KC_LCBR, KC_RCBR, XXXXXXX, KC_4, KC_5, KC_6, KC_ASTR, KC_BSLS, \
_______, XXXXXXX, XXXXXXX, UM_COPY, UM_INSR, XXXXXXX, XXXXXXX, KC_1, KC_2, KC_3, KC_PLUS, KC_MINS, \ _______, XXXXXXX, XXXXXXX, KC_XCPY, KC_XINS, XXXXXXX, XXXXXXX, KC_1, KC_2, KC_3, KC_PLUS, KC_MINS, \
_______, _______, _______, _______, _______, _______, _______, _______, KC_0, KC_DOT, KC_EQL, KC_UNDS \ _______, _______, _______, _______, _______, _______, _______, _______, KC_0, KC_DOT, KC_EQL, KC_UNDS \
), ),
/* Raise /* Raise
* ,-----------------------------------------. ,-----------------------------------------. * ,-----------------------------------------. ,-----------------------------------------.
* | ` | ! | @ | # | $ | % | | ^ | & | * | ( | ) | Bksp | * | ` | ! | @ | # | $ | % | | ^ | & | * | ( | ) | Bksp |
* |------+------+------+------+------+------| |------+------+------+------+------+------| * |------+------+------+------+------+------| |------+------+------+------+------+------|
* | | | | | | | | | | | | \ | | | * | | | | | | | | | | | | \ | | |
* |------+------+------+------+------+------| |------+------+------+------+------+------| * |------+------+------+------+------+------| |------+------+------+------+------+------|
* |Shift | | | | | | | | | | | | | * |Shift | | | | | | | | | | | | |
* |------+------+------+------+------+------| |------+------+------+------+------+------| * |------+------+------+------+------+------| |------+------+------+------+------+------|
* |Adjust| Ctrl | Alt | GUI |Lower |Space | |Space |Raise | Next | Vol- | Vol+ | Play | * |Adjust| Ctrl | Alt | GUI |Lower |Space | |Space |Raise | Next | Vol- | Vol+ | Play |
* `-----------------------------------------' '-----------------------------------------' * `-----------------------------------------' '-----------------------------------------'
*/ */
[_RAISE] = LAYOUT( \ [_RAISE] = LAYOUT( \
KC_GRV, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, _______, \ KC_GRV, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, _______, \
XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_BSLS, KC_PIPE,\ XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, KC_BSLS, KC_PIPE,\
_______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, _______, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,
_______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY \ _______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY \
), ),
/* Adjust (Lower + Raise)
* ,-----------------------------------------. ,-----------------------------------------.
* | | Reset| | | | | | ROOT | PPLY | PSEF | | | Del |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | | | |Aud on|Audoff| | | F1 | F2 | F3 | F4 | F5 | F6 |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | | UNDO | CUT | COPY |PASTE | | | F7 | F8 | F9 | F10 | F11 | F12 |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
* | | | | | | | | | | Home | | | End |
* `-----------------------------------------' '-----------------------------------------'
*/
[_ADJUST] = LAYOUT( \
_______, UM_ROOT, UM_PPLY, UM_PSEF, _______, _______, RESET, _______, _______, _______, _______, KC_DEL, \
_______, _______, _______, AU_ON, AU_OFF, _______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, \
_______, KC_UNDO, KC_CUT, UM_COPY, UM_INSR, _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, \
_______, _______, _______, _______, _______, _______, _______, _______, KC_HOME, _______, _______, KC_END \
)
}; /* Adjust (Lower + Raise)
* ,-----------------------------------------. ,-----------------------------------------.
#ifdef AUDIO_ENABLE * | | Reset| | | | | | ROOT | PPLY | PSEF | | | Del |
float tone_qwerty[][2] = SONG(QWERTY_SOUND); * |------+------+------+------+------+------| |------+------+------+------+------+------|
#endif * | | | |Aud on|Audoff| | | F1 | F2 | F3 | F4 | F5 | F6 |
* |------+------+------+------+------+------| |------+------+------+------+------+------|
void persistent_default_layer_set(uint16_t default_layer) { * | | UNDO | CUT | COPY |PASTE | | | F7 | F8 | F9 | F10 | F11 | F12 |
eeconfig_update_default_layer(default_layer); * |------+------+------+------+------+------| |------+------+------+------+------+------|
default_layer_set(default_layer); * | | | | | | | | | | Home | | | End |
} * `-----------------------------------------' '-----------------------------------------'
*/
qk_tap_dance_action_t tap_dance_actions[] = { [_ADJUST] = LAYOUT( \
//Tap once for nothing, twice for ESC KC_STOG, KC_ROOT, KC_PPLY, KC_PSEF, _______, _______, RESET, _______, _______, _______, _______, KC_DEL, \
[TD_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_NO, KC_ESC) _______, _______, _______, AU_ON, AU_OFF, _______, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, \
}; _______, KC_UNDO, KC_CUT, KC_XCPY, KC_XINS, _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, \
_______, _______, _______, _______, _______, _______, _______, _______, KC_HOME, _______, _______, KC_END \
bool process_record_user(uint16_t keycode, keyrecord_t *record) { )
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
#ifdef AUDIO_ENABLE
PLAY_SONG(tone_qwerty);
#endif
persistent_default_layer_set(1UL<<_QWERTY);
}
return false;
break;
case LOWER:
if (record->event.pressed) {
layer_on(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case RAISE:
if (record->event.pressed) {
layer_on(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case ADJUST:
if (record->event.pressed) {
layer_on(_ADJUST);
} else {
layer_off(_ADJUST);
}
return false;
break;
}
return true;
};
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
if (record->event.pressed) {
switch(id) {
case 0:
SEND_STRING("sudo su -\n");
return false; break;
case 1:
SEND_STRING("puppet apply /etc/puppetlabs/code/environments/production/manifests/site.pp\n");
return false; break;
case 2:
return MACRO(D(LCTL), T(INS), U(LCTL), END);
break;
case 3:
return MACRO(D(LSFT), T(INS), U(LSFT), END);
break;
case 4:
SEND_STRING("ps -ef | grep ");
return false; break;
}
}
return MACRO_NONE;
}; };

1
keyboards/lets_split/keymaps/mtdjr/rules.mk
View File

@ -1,4 +1,3 @@
TAP_DANCE_ENABLE = yes
ifndef QUANTUM_DIR ifndef QUANTUM_DIR
include ../../../../Makefile include ../../../../Makefile
endif endif

57
keyboards/tada68/keymaps/mtdjr/keymap.c
View File

@ -1,22 +1,5 @@
#include "tada68.h" #include QMK_KEYBOARD_H
#include "action_macro.h" #include "mtdjr.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.
#define _BL 0
#define _FL 1
// Macro Declarations
#define UM_ROOT M(0)
#define UM_PPLY M(1)
#define UM_PSEF M(2)
#define UM_XCPY M(3)
#define UM_XINS M(4)
#define UM_CAD M(5)
#define _______ KC_TRNS
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/* Keymap _BL: (Base Layer) Default Layer /* Keymap _BL: (Base Layer) Default Layer
@ -32,12 +15,12 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* |Ctrl|Alt |Gui | Space |Alt| FN|Ctrl|Lef|Dow|Rig | * |Ctrl|Alt |Gui | Space |Alt| FN|Ctrl|Lef|Dow|Rig |
* `----------------------------------------------------------------' * `----------------------------------------------------------------'
*/ */
[_BL] = KEYMAP_ANSI( [_QWERTY] = KEYMAP_ANSI(
KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_INS, \ KC_ESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSPC, KC_INS, \
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC,KC_BSLS, KC_DEL, \ KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC,KC_BSLS, KC_DEL, \
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGUP, \ KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT, KC_PGUP, \
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, KC_SLSH, KC_RSFT,KC_UP, KC_PGDN, \ KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM,KC_DOT, KC_SLSH, KC_RSFT,KC_UP, KC_PGDN, \
KC_LCTL,KC_LALT,KC_LGUI, KC_SPC, KC_RALT,MO(_FL), KC_RCTRL, KC_LEFT,KC_DOWN, KC_RGHT), KC_LCTL,KC_LALT,KC_LGUI, KC_SPC, KC_RALT,KC_LOWR, KC_RCTRL, KC_LEFT,KC_DOWN, KC_RGHT),
/* Keymap _FL: Function Layer /* Keymap _FL: Function Layer
* ,----------------------------------------------------------------. * ,----------------------------------------------------------------.
@ -52,36 +35,10 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
* | | | | | | | |MsL|MsD|MsR | * | | | | | | | |MsL|MsD|MsR |
* `----------------------------------------------------------------' * `----------------------------------------------------------------'
*/ */
[_FL] = KEYMAP_ANSI( [_LOWER] = KEYMAP_ANSI(
_______, KC_F1 , KC_F2 , KC_F3 , KC_F4 , KC_F5 , KC_F6 , KC_F7 , KC_F8 , KC_F9 , KC_F10, KC_F11, KC_F12, KC_DEL, KC_GRV, \ _______, KC_F1 , KC_F2 , KC_F3 , KC_F4 , KC_F5 , KC_F6 , KC_F7 , KC_F8 , KC_F9 , KC_F10, KC_F11, KC_F12, KC_DEL, KC_GRV, \
_______,UM_ROOT,UM_PPLY,UM_PSEF,_______,_______,_______,_______,_______,_______,KC_PSCR,_______,_______,_______, KC_HOME, \ _______,KC_ROOT,KC_PPLY,KC_PSEF,_______,_______,_______,_______,_______,_______,KC_PSCR,_______,_______,_______, KC_HOME, \
_______,BL_DEC ,BL_TOGG,BL_INC,BL_BRTG,_______,_______,_______,_______,_______,_______,_______, _______, KC_END, \ _______,BL_DEC ,BL_TOGG,BL_INC,BL_BRTG,_______,_______,_______,_______,_______,_______,_______, _______, KC_END, \
_______,_______ ,_______,UM_XCPY,UM_XINS,_______,KC_MPLY,KC_MNXT,KC_MUTE,KC_VOLD,KC_VOLU,KC_BTN1,KC_MS_U,KC_BTN2, \ _______,_______ ,_______,KC_XCPY,KC_XINS,_______,KC_MPLY,KC_MNXT,KC_MUTE,KC_VOLD,KC_VOLU,KC_BTN1,KC_MS_U,KC_BTN2, \
_______,_______,_______, _______, _______,_______,_______,KC_MS_L,KC_MS_D,KC_MS_R), _______,_______,_______, _______, _______,_______,_______,KC_MS_L,KC_MS_D,KC_MS_R),
}; };
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
if (record->event.pressed) {
switch(id) {
case 0:
SEND_STRING("sudo su -\n");
return false; break;
case 1:
SEND_STRING("puppet apply /etc/puppetlabs/code/environments/production/manifests/site.pp\n");
return false; break;
case 2:
SEND_STRING("ps -ef | grep ");
return false; break;
case 3:
return MACRO(D(LCTL), T(INS), U(LCTL), END);
break;
case 4:
return MACRO(D(LSFT), T(INS), U(LSFT), END);
break;
case 5:
return MACRO(D(LCTL), D(RALT), T(DEL), END);
break;
}
}
return MACRO_NONE;
};

3
keyboards/xd75/keymaps/mtdjr/config.h
View File

@ -20,7 +20,8 @@
#include "../../config.h" #include "../../config.h"
// place overrides here // place overrides here
#define RGBLIGHT_SLEEP #undef MANUFACTURER
#undef DESCRIPTION
#define MANUFACTURER mtdjr #define MANUFACTURER mtdjr
#define PRODUCT XD75 #define PRODUCT XD75
#define DESCRIPTION XD75Re #define DESCRIPTION XD75Re

108
keyboards/xd75/keymaps/mtdjr/keymap.c
View File

@ -1,68 +1,13 @@
/* Copyright 2017 Wunder #include QMK_KEYBOARD_H
* #include "mtdjr.h"
* 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 "xd75.h"
#include "action_layer.h"
#define KC_LOCK TD(TD_ENDLOCK)
enum custom_keycodes {
// TD_ESC = 0,
TD_LOCK = 0,
};
// Layers
#define _QWERTY 0
#define _LOWER 1
#define _RAISE 2
// Shortcuts
#define KC_____ KC_NO
#define KC_ KC_TRNS
#define KC_RST RESET
#define KC_RASE MO(_RAISE)
#define KC_LOWR MO(_LOWER)
// RGB and Backlighting
#define KC_RGB RGB_TOG
#define KC_RHUI RGB_HUI
#define KC_RHUD RGB_HUD
#define KC_RSAI RGB_SAI
#define KC_RSAD RGB_SAD
#define KC_RVAI RGB_VAI
#define KC_RVAD RGB_VAD
#define KC_BLT BL_TOGG
#define KC_BLS BL_STEP
#define KC_BLI BL_INC
#define KC_BLD BL_DEC
// Tapdance
//#define KC_EXC TD(TD_ESC)
#define KC_LOCK TD(TD_LOCK)
// Macros
#define KC_ROOT M(0)
#define KC_PPLY M(1)
#define KC_PSEF M(2)
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
[_QWERTY] = KC_KEYMAP( [_QWERTY] = KC_KEYMAP(
// .--------------------------------------------------------------------------. // .--------------------------------------------------------------------------.
ESC, 1 , 2 , 3 , 4 , 5 ,PGUP,PSCR,PGDN, 6 , 7 , 8 , 9 , 0 ,BSPC, EXC, 1 , 2 , 3 , 4 , 5 ,PGUP,xxxx,PGDN, 6 , 7 , 8 , 9 , 0 ,BSPC,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
TAB, Q , W , E , R , T , INS,BSLS, DEL, Y , U , I , O , P ,QUOT, TAB, Q , W , E , R , T , INS,BSLS, DEL, Y , U , I , O , P ,QUOT,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
@ -70,44 +15,39 @@ const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
LSFT, Z , X , C , V , B ,LBRC,MINS,RBRC, N , M ,COMM, DOT,SLSH,RSFT, LSFT, Z , X , C , V , B ,LBRC,MINS,RBRC, N , M ,COMM, DOT,SLSH,RSFT,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
LOWR,LCTL,LALT,LGUI,____, SPC,RASE, GRV,LOWR, SPC,____,LEFT,DOWN,UP ,RGHT LOWR,LCTL,LALT,LGUI,xxxx, SPC, SPC,RASE,SPC, SPC,xxxx,LEFT,DOWN,UP ,RGHT
// '----+----+----+----+----+----+----+----+----+----+----+----+----+----+----' // '----+----+----+----+----+----+----+----+----+----+----+----+----+----+----'
), ),
[_LOWER] = KC_KEYMAP( [_LOWER] = KC_KEYMAP(
// .--------------------------------------------------------------------------. // .--------------------------------------------------------------------------.
____, F1, F2, F3, F4, F5, F6,____, F7, F8, F9, F10, F11, F12,____, xxxx, F1, F2, F3, F4, F5, F6,xxxx, F7, F8, F9, F10, F11, F12, DEL,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
____,ROOT,PPLY,PSEF,____,____,____,____,____,____,____,____,____,____,____, xxxx,ROOT,PPLY,PSEF,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
____,____,____,____,____,____,____,____,____,____,____,____,____,____,____, xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
____,____,____,____,____,____,____,____,____,____,____,____,____,____,MUTE, xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,MUTE,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
,____,____,____,____,____, ,____, ,MPLY,____,MPRV,VOLD,VOLU,MNXT ,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx, ,xxxx,MPLY,xxxx,MPRV,VOLD,VOLU,MNXT
// '----+----+----+----+----+----+----+----+----+----+----+----+----+----+----' // '----+----+----+----+----+----+----+----+----+----+----+----+----+----+----'
), ),
[_RAISE] = KC_KEYMAP( [_RAISE] = KC_KEYMAP(
// .--------------------------------------------------------------------------. // .--------------------------------------------------------------------------.
____,____,____,____,____,____,____,____,____,____,____,____,____,____,____, xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
____,____,____,____, RST,____,____,____,____,____,____,____,____,____,____, xxxx,xxxx,xxxx,xxxx, RST,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
CAPS,____,____,____,____,____,____, BLI,____,____,____,____,____,____,____, CAPS,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx, BLI,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
RGB,RHUI,RHUD,RSAI,RSAD,RVAI,RVAD, BLD,____,____,____,____,BTN1,BTN2,____, RGB,RHUI,RHUD,RSAI,RSAD,RVAI,RVAD, BLD,xxxx,xxxx,xxxx,xxxx,BTN1,BTN2,xxxx,
// |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----| // |----+----+----+----+----+----+----+----+----+----+----+----+----+----+----|
,____,____,____,____,____, ,____, ,____,____,MS_L,MS_D,MS_U,MS_R ,xxxx,xxxx,xxxx,xxxx,xxxx,xxxx, ,xxxx,xxxx,xxxx,MS_L,MS_D,MS_U,MS_R
// '----+----+----+----+----+----+----+----+----+----+----+----+----+----+----' // '----+----+----+----+----+----+----+----+----+----+----+----+----+----+----'
) )
}; };
qk_tap_dance_action_t tap_dance_actions[] = {
//Tap once for left ctrl, twice for ESC
//[TD_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_LCTL, KC_ESC),
[TD_LOCK] = ACTION_TAP_DANCE_DOUBLE(KC_END, LGUI(KC_L))
};
void led_set_user(uint8_t usb_led) { void led_set_user(uint8_t usb_led) {
if (usb_led & (1<<USB_LED_CAPS_LOCK)) { if (usb_led & (1<<USB_LED_CAPS_LOCK)) {
capslock_led_on(); capslock_led_on();
@ -115,21 +55,3 @@ void led_set_user(uint8_t usb_led) {
capslock_led_off(); capslock_led_off();
} }
} }
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
if (record->event.pressed) {
switch(id) {
case 0:
SEND_STRING("sudo su -\n");
return false; break;
case 1:
SEND_STRING("puppet apply /etc/puppetlabs/code/environments/production/manifests/site.pp\n");
return false; break;
case 2:
SEND_STRING("ps -ef | grep ");
return false; break;
}
}
return MACRO_NONE;
};

7
users/mtdjr/config.h Normal file
View File

@ -0,0 +1,7 @@
#ifndef USERSPACE_CONFIG_H
#define USERSPACE_CONFIG_H
// Put normal config.h settings here:
#define TAPPING_TERM 250
#endif // !USERSPACE_CONFIG_H

137
users/mtdjr/mtdjr.c Normal file
View File

@ -0,0 +1,137 @@
#include "mtdjr.h"
#ifdef SOLENOID_ENABLE
#include "solenoid.h"
void solenoid_buzz_on(void);
void solenoid_buzz_off(void);
void solenoid_dwell_minus(void);
void solenoid_dwell_plus(void);
void solenoid_toggle(void);
void solenoid_stop(void);
void solenoid_fire(void);
void solenoid_check(void);
void solenoid_setup(void);
void matrix_init_user(void);
void matrix_scan_user(void);
#endif
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
#ifdef SOLENOID_ENABLE
if (record->event.pressed) {
solenoid_fire();
}
#endif
switch (keycode) {
case QWERTY:
if (record->event.pressed) {
set_single_persistent_default_layer(_QWERTY);
}
return false;
break;
case LOWER:
if (record->event.pressed) {
layer_on(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_LOWER);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case RAISE:
if (record->event.pressed) {
layer_on(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_RAISE);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case ADJUST:
if (record->event.pressed) {
layer_on(_ADJUST);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
} else {
layer_off(_ADJUST);
update_tri_layer(_LOWER, _RAISE, _ADJUST);
}
return false;
break;
case SOLENOID_TOG:
#ifdef SOLENOID_ENABLE
if (record->event.pressed) {
solenoid_toggle();
}
#endif
break;
case SOLENOID_DWELL_MINUS:
#ifdef SOLENOID_ENABLE
if (record->event.pressed) {
solenoid_dwell_minus();
}
#endif
break;
case SOLENOID_DWELL_PLUS:
#ifdef SOLENOID_ENABLE
if (record->event.pressed) {
solenoid_dwell_plus();
}
#endif
break;
case SOLENOID_BUZZ_ON:
#ifdef SOLENOID_ENABLE
if (record->event.pressed) {
solenoid_buzz_on();
}
#endif
break;
case SOLENOID_BUZZ_OFF:
#ifdef SOLENOID_ENABLE
if (record->event.pressed) {
solenoid_buzz_off();
}
#endif
break;
}
return true;
};
//Tap Dance Definitions
qk_tap_dance_action_t tap_dance_actions[] = {
[TD_ESC] = ACTION_TAP_DANCE_DOUBLE(KC_GRV, KC_ESC),
[TD_ALTLOCK] = ACTION_TAP_DANCE_DOUBLE(KC_RALT, LGUI(KC_L)),
[TD_ENDLOCK] = ACTION_TAP_DANCE_DOUBLE(KC_END, LGUI(KC_L)),
//[TD_PRNT] = ACTION_TAP_DANCE_DOUBLE(PRINT, PRINT_SEL)
};
const macro_t *action_get_macro(keyrecord_t *record, uint8_t id, uint8_t opt) {
if (record->event.pressed) {
switch(id) {
case 0:
SEND_STRING("sudo su -\n");
return false; break;
case 1:
SEND_STRING("puppet apply /etc/puppetlabs/code/environments/production/manifests/site.pp\n");
return false; break;
case 2:
SEND_STRING("ps -ef | grep ");
return false; break;
case 3: // control + insert
return MACRO(D(LCTL), T(INS), U(LCTL), END);
break;
case 4: // shift + insert
return MACRO(D(LSFT), T(INS), U(LSFT), END);
break;
case 5: // control + alt + delete
return MACRO(D(LCTL), D(RALT), T(DEL), U(LCTL), U(LALT), END);
break;
case 6: // lgui + L
return MACRO(D(LGUI), T(L), U(LGUI), END);
break;
}
}
return MACRO_NONE;
};

76
users/mtdjr/mtdjr.h Normal file
View File

@ -0,0 +1,76 @@
#ifndef USERSPACE
#define USERSPACE
#include "quantum.h"
#define _QWERTY 0
#define _LOWER 1
#define _RAISE 2
#define _SUPER 3
#define _ADJUST 16
enum user_layers {
QWERTY = SAFE_RANGE,
LOWER,
RAISE,
SUPER,
ADJUST,
};
enum user_tapdance {
TD_ENDLOCK,
TD_ALTLOCK,
TD_ESC,
};
enum user_solenoid {
SOLENOID_TOG,
SOLENOID_DWELL_MINUS,
SOLENOID_DWELL_PLUS,
SOLENOID_BUZZ_ON,
SOLENOID_BUZZ_OFF,
};
#define KC_STOG SOLENOID_TOG
#define KC_SDM SOLENOID_DWELL_MINUS
#define KC_SDP SOLENOID_DWELL_PLUS
#define KC_SBON SOLENOID_BUZZ_ON
#define KC_SBOF SOLENOID_BUZZ_OFF
#define KC_ KC_TRNS
#define _______ KC_TRNS
#define XXXXXXX KC_NO
#define KC_xxxx KC_NO
#define KC_LOWR LOWER
#define KC_RASE RAISE
#define KC_SUPR SUPER
#define KC_RST RESET
// TapDance Keycodes
#define KC_EXC TD_ESC
// Macro Declarations
#define KC_ROOT M(0)
#define KC_PPLY M(1)
#define KC_PSEF M(2)
#define KC_XCPY M(3)
#define KC_XINS M(4)
#define KC_CAD M(5)
#define UM_LOCK M(6)
// RGB and Backlighting
#define KC_RGB RGB_TOG
#define KC_RHUI RGB_HUI
#define KC_RHUD RGB_HUD
#define KC_RSAI RGB_SAI
#define KC_RSAD RGB_SAD
#define KC_RVAI RGB_VAI
#define KC_RVAD RGB_VAD
#define KC_BLT BL_TOGG
#define KC_BLS BL_STEP
#define KC_BLI BL_INC
#define KC_BLD BL_DEC
#endif

14
users/mtdjr/readme.md Normal file
View File

@ -0,0 +1,14 @@
Copyright 2018 @mtdjr
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/>.

2
users/mtdjr/rules.mk Normal file
View File

@ -0,0 +1,2 @@
SRC += mtdjr.c
TAP_DANCE_ENABLE = yes

103
users/mtdjr/solenoid.h Normal file
View File

@ -0,0 +1,103 @@
#ifndef SOLENOID_H
#define SOLENOID_H
#include <timer.h>
#include "pincontrol.h"
#define SOLENOID_DEFAULT_DWELL 12
#define SOLENOID_MAX_DWELL 100
#define SOLENOID_MIN_DWELL 4
#ifndef SOLENOID_ACTIVE
#define SOLENOID_ACTIVE false
#endif
//#define SOLENOID_PIN F6
bool solenoid_enabled = SOLENOID_ACTIVE;
bool solenoid_on = false;
bool solenoid_buzz = false;
bool solenoid_buzzing = false;
uint16_t solenoid_start = 0;
uint8_t solenoid_dwell = SOLENOID_DEFAULT_DWELL;
void solenoid_buzz_on(void) {
solenoid_buzz = true;
}
void solenoid_buzz_off(void) {
solenoid_buzz = false;
}
void solenoid_dwell_minus(void) {
if (solenoid_dwell > 0) solenoid_dwell--;
}
void solenoid_dwell_plus(void) {
if (solenoid_dwell < SOLENOID_MAX_DWELL) solenoid_dwell++;
}
void solenoid_toggle(void) {
solenoid_enabled = !solenoid_enabled;
}
void solenoid_stop(void) {
digitalWrite(SOLENOID_PIN, PinLevelLow);
solenoid_on = false;
solenoid_buzzing = false;
}
void solenoid_fire(void) {
if (!solenoid_enabled) return;
if (!solenoid_buzz && solenoid_on) return;
if (solenoid_buzz && solenoid_buzzing) return;
solenoid_on = true;
solenoid_buzzing = true;
solenoid_start = timer_read();
digitalWrite(SOLENOID_PIN, PinLevelHigh);
}
void solenoid_check(void) {
uint16_t elapsed = 0;
if (!solenoid_on) return;
elapsed = timer_elapsed(solenoid_start);
//Check if it's time to finish this solenoid click cycle
if (elapsed > solenoid_dwell) {
solenoid_stop();
return;
}
//Check whether to buzz the solenoid on and off
if (solenoid_buzz) {
if (elapsed / SOLENOID_MIN_DWELL % 2 == 0){
if (!solenoid_buzzing) {
solenoid_buzzing = true;
digitalWrite(SOLENOID_PIN, PinLevelHigh);
}
}
else {
if (solenoid_buzzing) {
solenoid_buzzing = false;
digitalWrite(SOLENOID_PIN, PinLevelLow);
}
}
}
}
void solenoid_setup(void) {
pinMode(SOLENOID_PIN, PinDirectionOutput);
}
void matrix_init_user(void) {
solenoid_setup();
}
void matrix_scan_user(void) {
solenoid_check();
}
#endif