aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--keyboards/handwired/dactyl_manuform/config.h87
-rw-r--r--keyboards/handwired/dactyl_manuform/dactyl_manuform.c23
-rw-r--r--keyboards/handwired/dactyl_manuform/dactyl_manuform.h71
-rw-r--r--keyboards/handwired/dactyl_manuform/i2c.c162
-rw-r--r--keyboards/handwired/dactyl_manuform/i2c.h49
-rw-r--r--keyboards/handwired/dactyl_manuform/keymaps/default/config.h37
-rw-r--r--keyboards/handwired/dactyl_manuform/keymaps/default/keymap.c119
-rw-r--r--keyboards/handwired/dactyl_manuform/keymaps/default/rules.mk3
-rw-r--r--keyboards/handwired/dactyl_manuform/keymaps/dvorak/config.h37
-rw-r--r--keyboards/handwired/dactyl_manuform/keymaps/dvorak/keymap.c119
-rw-r--r--keyboards/handwired/dactyl_manuform/keymaps/dvorak/rules.mk3
-rw-r--r--keyboards/handwired/dactyl_manuform/matrix.c466
-rw-r--r--keyboards/handwired/dactyl_manuform/readme.md147
-rw-r--r--keyboards/handwired/dactyl_manuform/rules.mk75
-rw-r--r--keyboards/handwired/dactyl_manuform/serial.c228
-rw-r--r--keyboards/handwired/dactyl_manuform/serial.h26
-rw-r--r--keyboards/handwired/dactyl_manuform/split_util.c86
-rw-r--r--keyboards/handwired/dactyl_manuform/split_util.h20
18 files changed, 1758 insertions, 0 deletions
diff --git a/keyboards/handwired/dactyl_manuform/config.h b/keyboards/handwired/dactyl_manuform/config.h
new file mode 100644
index 000000000..093d6680b
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/config.h
@@ -0,0 +1,87 @@
1/*
2Copyright 2012 Jun Wako <wakojun@gmail.com>
3Copyright 2015 Jack Humbert
4
5This program is free software: you can redistribute it and/or modify
6it under the terms of the GNU General Public License as published by
7the Free Software Foundation, either version 2 of the License, or
8(at your option) any later version.
9
10This program is distributed in the hope that it will be useful,
11but WITHOUT ANY WARRANTY; without even the implied warranty of
12MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13GNU General Public License for more details.
14
15You should have received a copy of the GNU General Public License
16along with this program. If not, see <http://www.gnu.org/licenses/>.
17*/
18
19#ifndef CONFIG_H
20#define CONFIG_H
21
22#include "config_common.h"
23
24/* USB Device descriptor parameter */
25#define VENDOR_ID 0xFEED
26#define PRODUCT_ID 0x3060
27#define DEVICE_VER 0x0001
28#define MANUFACTURER tshort
29#define PRODUCT Dactyl-Manuform
30#define DESCRIPTION A split keyboard for the cheap makers
31
32/* key matrix size */
33// Rows are doubled-up
34#define MATRIX_ROWS 10
35#define MATRIX_COLS 5
36
37// wiring of each half
38#define MATRIX_ROW_PINS { F7, B1, B3, B2, B6 }
39// #define MATRIX_COL_PINS { B5, B4, E6, D7, C6 }
40#define MATRIX_COL_PINS { C6, D7, E6, B4, B5 }
41
42/* define if matrix has ghost */
43//#define MATRIX_HAS_GHOST
44
45/* number of backlight levels */
46// #define BACKLIGHT_LEVELS 3
47
48/* Set 0 if debouncing isn't needed */
49#define DEBOUNCING_DELAY 5
50
51/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
52#define LOCKING_SUPPORT_ENABLE
53/* Locking resynchronize hack */
54#define LOCKING_RESYNC_ENABLE
55
56/* key combination for command */
57#define IS_COMMAND() ( \
58 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
59)
60
61/* ws2812 RGB LED */
62#define RGB_DI_PIN D3
63#define RGBLIGHT_TIMER
64#define RGBLED_NUM 12 // Number of LEDs
65#define ws2812_PORTREG PORTD
66#define ws2812_DDRREG DDRD
67
68/*
69 * Feature disable options
70 * These options are also useful to firmware size reduction.
71 */
72
73/* disable debug print */
74// #define NO_DEBUG
75
76/* disable print */
77// #define NO_PRINT
78
79/* disable action features */
80//#define NO_ACTION_LAYER
81//#define NO_ACTION_TAPPING
82//#define NO_ACTION_ONESHOT
83//#define NO_ACTION_MACRO
84//#define NO_ACTION_FUNCTION
85
86
87#endif
diff --git a/keyboards/handwired/dactyl_manuform/dactyl_manuform.c b/keyboards/handwired/dactyl_manuform/dactyl_manuform.c
new file mode 100644
index 000000000..17caecb4f
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/dactyl_manuform.c
@@ -0,0 +1,23 @@
1#include "dactyl_manuform.h"
2
3
4#ifdef SSD1306OLED
5void led_set_kb(uint8_t usb_led) {
6 // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
7 led_set_user(usb_led);
8}
9#endif
10
11void matrix_init_kb(void) {
12
13 // // green led on
14 // DDRD |= (1<<5);
15 // PORTD &= ~(1<<5);
16
17 // // orange led on
18 // DDRB |= (1<<0);
19 // PORTB &= ~(1<<0);
20
21 matrix_init_user();
22};
23
diff --git a/keyboards/handwired/dactyl_manuform/dactyl_manuform.h b/keyboards/handwired/dactyl_manuform/dactyl_manuform.h
new file mode 100644
index 000000000..197909823
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/dactyl_manuform.h
@@ -0,0 +1,71 @@
1#ifndef REV2_H
2#define REV2_H
3
4#include "dactyl_manuform.h"
5
6//void promicro_bootloader_jmp(bool program);
7#include "quantum.h"
8
9
10#ifdef USE_I2C
11#include <stddef.h>
12#ifdef __AVR__
13 #include <avr/io.h>
14 #include <avr/interrupt.h>
15#endif
16#endif
17
18//void promicro_bootloader_jmp(bool program);
19
20#ifndef FLIP_HALF
21
22#define KEYMAP( \
23 L00, L01, L02, L03, L04, R00, R01, R02, R03, R04, \
24 L10, L11, L12, L13, L14, R10, R11, R12, R13, R14, \
25 L20, L21, L22, L23, L24, R20, R21, R22, R23, R24, \
26 L31, L32, R33, R34, \
27 L33, L34, R31, R32, \
28 L44, L42, R43, R41, \
29 L43, L41, R44, R42 \
30 ) \
31 { \
32 { L00, L01, L02, L03, L04 }, \
33 { L10, L11, L12, L13, L14 }, \
34 { L20, L21, L22, L23, L24 }, \
35 { KC_NO, L31, L32, L33, L34 }, \
36 { KC_NO, L41, L42, L43, L44 }, \
37\
38 { R04, R03, R02, R01, R00 }, \
39 { R14, R13, R12, R11, R10 }, \
40 { R24, R23, R22, R21, R20 }, \
41 { KC_NO, R34, R33, R32, R31 }, \
42 { KC_NO, R44, R43, R42, R41 } \
43 }
44#else
45
46#define KEYMAP( \
47 L00, L01, L02, L03, L04, R00, R01, R02, R03, R04, \
48 L10, L11, L12, L13, L14, R10, R11, R12, R13, R14, \
49 L20, L21, L22, L23, L24, R20, R21, R22, R23, R24, \
50 L31, L32, L33, L34, \
51 R31, R32, R33, R34, \
52 L41, L42, L43, L44, \
53 R41, R42, R43, R44 \
54 ) \
55 { \
56 { L00, L01, L02, L03, L04 }, \
57 { L10, L11, L12, L13, L14 }, \
58 { L20, L21, L22, L23, L24 }, \
59 { KC_NO, L31, L32, L33, L34 }, \
60 { KC_NO, L41, L42, L43, L44 }, \
61\
62 { R00, R01, R02, R03, R04 }, \
63 { R10, R11, R12, R13, R14 }, \
64 { R20, R21, R22, R23, R24 }, \
65 { KC_NO, R31, R32, R33, R34 }, \
66 { KC_NO, R41, R42, R43, R44 } \
67 }
68
69#endif
70
71#endif
diff --git a/keyboards/handwired/dactyl_manuform/i2c.c b/keyboards/handwired/dactyl_manuform/i2c.c
new file mode 100644
index 000000000..084c890c4
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/i2c.c
@@ -0,0 +1,162 @@
1#include <util/twi.h>
2#include <avr/io.h>
3#include <stdlib.h>
4#include <avr/interrupt.h>
5#include <util/twi.h>
6#include <stdbool.h>
7#include "i2c.h"
8
9#ifdef USE_I2C
10
11// Limits the amount of we wait for any one i2c transaction.
12// Since were running SCL line 100kHz (=> 10μs/bit), and each transactions is
13// 9 bits, a single transaction will take around 90μs to complete.
14//
15// (F_CPU/SCL_CLOCK) => # of μC cycles to transfer a bit
16// poll loop takes at least 8 clock cycles to execute
17#define I2C_LOOP_TIMEOUT (9+1)*(F_CPU/SCL_CLOCK)/8
18
19#define BUFFER_POS_INC() (slave_buffer_pos = (slave_buffer_pos+1)%SLAVE_BUFFER_SIZE)
20
21volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
22
23static volatile uint8_t slave_buffer_pos;
24static volatile bool slave_has_register_set = false;
25
26// Wait for an i2c operation to finish
27inline static
28void i2c_delay(void) {
29 uint16_t lim = 0;
30 while(!(TWCR & (1<<TWINT)) && lim < I2C_LOOP_TIMEOUT)
31 lim++;
32
33 // easier way, but will wait slightly longer
34 // _delay_us(100);
35}
36
37// Setup twi to run at 100kHz
38void i2c_master_init(void) {
39 // no prescaler
40 TWSR = 0;
41 // Set TWI clock frequency to SCL_CLOCK. Need TWBR>10.
42 // Check datasheets for more info.
43 TWBR = ((F_CPU/SCL_CLOCK)-16)/2;
44}
45
46// Start a transaction with the given i2c slave address. The direction of the
47// transfer is set with I2C_READ and I2C_WRITE.
48// returns: 0 => success
49// 1 => error
50uint8_t i2c_master_start(uint8_t address) {
51 TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTA);
52
53 i2c_delay();
54
55 // check that we started successfully
56 if ( (TW_STATUS != TW_START) && (TW_STATUS != TW_REP_START))
57 return 1;
58
59 TWDR = address;
60 TWCR = (1<<TWINT) | (1<<TWEN);
61
62 i2c_delay();
63
64 if ( (TW_STATUS != TW_MT_SLA_ACK) && (TW_STATUS != TW_MR_SLA_ACK) )
65 return 1; // slave did not acknowledge
66 else
67 return 0; // success
68}
69
70
71// Finish the i2c transaction.
72void i2c_master_stop(void) {
73 TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
74
75 uint16_t lim = 0;
76 while(!(TWCR & (1<<TWSTO)) && lim < I2C_LOOP_TIMEOUT)
77 lim++;
78}
79
80// Write one byte to the i2c slave.
81// returns 0 => slave ACK
82// 1 => slave NACK
83uint8_t i2c_master_write(uint8_t data) {
84 TWDR = data;
85 TWCR = (1<<TWINT) | (1<<TWEN);
86
87 i2c_delay();
88
89 // check if the slave acknowledged us
90 return (TW_STATUS == TW_MT_DATA_ACK) ? 0 : 1;
91}
92
93// Read one byte from the i2c slave. If ack=1 the slave is acknowledged,
94// if ack=0 the acknowledge bit is not set.
95// returns: byte read from i2c device
96uint8_t i2c_master_read(int ack) {
97 TWCR = (1<<TWINT) | (1<<TWEN) | (ack<<TWEA);
98
99 i2c_delay();
100 return TWDR;
101}
102
103void i2c_reset_state(void) {
104 TWCR = 0;
105}
106
107void i2c_slave_init(uint8_t address) {
108 TWAR = address << 0; // slave i2c address
109 // TWEN - twi enable
110 // TWEA - enable address acknowledgement
111 // TWINT - twi interrupt flag
112 // TWIE - enable the twi interrupt
113 TWCR = (1<<TWIE) | (1<<TWEA) | (1<<TWINT) | (1<<TWEN);
114}
115
116ISR(TWI_vect);
117
118ISR(TWI_vect) {
119 uint8_t ack = 1;
120 switch(TW_STATUS) {
121 case TW_SR_SLA_ACK:
122 // this device has been addressed as a slave receiver
123 slave_has_register_set = false;
124 break;
125
126 case TW_SR_DATA_ACK:
127 // this device has received data as a slave receiver
128 // The first byte that we receive in this transaction sets the location
129 // of the read/write location of the slaves memory that it exposes over
130 // i2c. After that, bytes will be written at slave_buffer_pos, incrementing
131 // slave_buffer_pos after each write.
132 if(!slave_has_register_set) {
133 slave_buffer_pos = TWDR;
134 // don't acknowledge the master if this memory loctaion is out of bounds
135 if ( slave_buffer_pos >= SLAVE_BUFFER_SIZE ) {
136 ack = 0;
137 slave_buffer_pos = 0;
138 }
139 slave_has_register_set = true;
140 } else {
141 i2c_slave_buffer[slave_buffer_pos] = TWDR;
142 BUFFER_POS_INC();
143 }
144 break;
145
146 case TW_ST_SLA_ACK:
147 case TW_ST_DATA_ACK:
148 // master has addressed this device as a slave transmitter and is
149 // requesting data.
150 TWDR = i2c_slave_buffer[slave_buffer_pos];
151 BUFFER_POS_INC();
152 break;
153
154 case TW_BUS_ERROR: // something went wrong, reset twi state
155 TWCR = 0;
156 default:
157 break;
158 }
159 // Reset everything, so we are ready for the next TWI interrupt
160 TWCR |= (1<<TWIE) | (1<<TWINT) | (ack<<TWEA) | (1<<TWEN);
161}
162#endif
diff --git a/keyboards/handwired/dactyl_manuform/i2c.h b/keyboards/handwired/dactyl_manuform/i2c.h
new file mode 100644
index 000000000..c15b6bc50
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/i2c.h
@@ -0,0 +1,49 @@
1#ifndef I2C_H
2#define I2C_H
3
4#include <stdint.h>
5
6#ifndef F_CPU
7#define F_CPU 16000000UL
8#endif
9
10#define I2C_READ 1
11#define I2C_WRITE 0
12
13#define I2C_ACK 1
14#define I2C_NACK 0
15
16#define SLAVE_BUFFER_SIZE 0x10
17
18// i2c SCL clock frequency
19#define SCL_CLOCK 400000L
20
21extern volatile uint8_t i2c_slave_buffer[SLAVE_BUFFER_SIZE];
22
23void i2c_master_init(void);
24uint8_t i2c_master_start(uint8_t address);
25void i2c_master_stop(void);
26uint8_t i2c_master_write(uint8_t data);
27uint8_t i2c_master_read(int);
28void i2c_reset_state(void);
29void i2c_slave_init(uint8_t address);
30
31
32static inline unsigned char i2c_start_read(unsigned char addr) {
33 return i2c_master_start((addr << 1) | I2C_READ);
34}
35
36static inline unsigned char i2c_start_write(unsigned char addr) {
37 return i2c_master_start((addr << 1) | I2C_WRITE);
38}
39
40// from SSD1306 scrips
41extern unsigned char i2c_rep_start(unsigned char addr);
42extern void i2c_start_wait(unsigned char addr);
43extern unsigned char i2c_readAck(void);
44extern unsigned char i2c_readNak(void);
45extern unsigned char i2c_read(unsigned char ack);
46
47#define i2c_read(ack) (ack) ? i2c_readAck() : i2c_readNak();
48
49#endif
diff --git a/keyboards/handwired/dactyl_manuform/keymaps/default/config.h b/keyboards/handwired/dactyl_manuform/keymaps/default/config.h
new file mode 100644
index 000000000..216917ed7
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/keymaps/default/config.h
@@ -0,0 +1,37 @@
1/*
2This is the c configuration file for the keymap
3
4Copyright 2012 Jun Wako <wakojun@gmail.com>
5Copyright 2015 Jack Humbert
6
7This program is free software: you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation, either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program. If not, see <http://www.gnu.org/licenses/>.
19*/
20
21#ifndef CONFIG_USER_H
22#define CONFIG_USER_H
23
24#include "../../config.h"
25
26/* Use I2C or Serial, not both */
27
28#define USE_SERIAL
29// #define USE_I2C
30
31/* Select hand configuration */
32
33// #define MASTER_LEFT
34// #define MASTER_RIGHT
35#define EE_HANDS
36
37#endif
diff --git a/keyboards/handwired/dactyl_manuform/keymaps/default/keymap.c b/keyboards/handwired/dactyl_manuform/keymaps/default/keymap.c
new file mode 100644
index 000000000..0a74323ab
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/keymaps/default/keymap.c
@@ -0,0 +1,119 @@
1#include "dactyl_manuform.h"
2#include "action_layer.h"
3#include "eeconfig.h"
4
5extern keymap_config_t keymap_config;
6
7#define _BASE 0
8#define _NAV 1
9#define _NUM 2
10
11enum custom_keycodes {
12 QWERTY = SAFE_RANGE,
13 NAV,
14 NUM,
15};
16
17// Fillers to make layering more clear
18#define _______ KC_TRNS
19#define XXXXXXX KC_NO
20
21const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
22
23/* Base (qwerty)
24 * ,----------------------------------, ,----------------------------------,
25 * | Q | W | E | R | T | | Y | U | I | O | P |
26 * |------+------+------+------+------| |-------------+------+------+------|
27 * | A | S | D | F | G | | H | J | K | L | ; |
28 * |------+------+------+------+------| |------|------+------+------+------|
29 * | Z | X | C | V | B | | N | M | , | . | ' |
30 * |------+------+------+-------------, ,-------------+------+------+------,
31 * | [ | ] | | - | = |
32 * '------+------'-------------' '-------------'------+------'
33 * | esc | bs | | space|enter |
34 * | + | + | | + | + |
35 * | shift| ctrl | | alt |shift |
36 * '------+------' '------+------'
37 * '------+------' '------+------'
38 * | tab | home | | end | del |
39 * |------+------' '------+------|
40 * |\(NAV)| ~ | | gui |/(NUM)|
41 * '------+------' '------+------'
42 */
43
44[_BASE] = KEYMAP( \
45 KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, \
46 KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, \
47 KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_QUOT, \
48 KC_LBRC, KC_RBRC, KC_MINS, KC_EQL, \
49 SFT_T(KC_ESC), CTL_T(KC_BSPC), ALT_T(KC_SPC), SFT_T(KC_ENT), \
50 KC_TAB, KC_HOME, KC_END, KC_DEL, \
51 LT(_NAV, KC_BSLS), KC_GRV, KC_LGUI, LT(_NUM, KC_SLSH) \
52),
53
54/* Navigation layer
55 * ,----------------------------------, ,----------------------------------,
56 * | | | mup | | | | | | up | | |
57 * |------+------+------+------+------| |-------------+------+------+------|
58 * | | mleft| mdown|mright| | | | left | down |right | |
59 * |------+------+------+------+------| |------|------+------+------+------|
60 * | | | | | | | | | | | |
61 * |------+------+------+-------------, ,-------------+------+------+------,
62 * | | | | mbtn |mbtn2 |
63 * '------+------'-------------' '-------------'------+------'
64 * | | | | | |
65 * | | | | | |
66 * | | | | | |
67 * '------+------' '------+------'
68 * '------+------' '------+------'
69 * | tab | home | | end | del |
70 * '------+------' '------+------'
71 * |\(NAV)| ~ | | gui |/(NUM)|
72 * '------+------' '------+------'
73 */
74
75[_NAV] = KEYMAP( \
76 KC_TRNS, KC_TRNS, KC_MS_UP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_UP, KC_TRNS, KC_TRNS, \
77 KC_TRNS, KC_MS_LEFT, KC_MS_DOWN, KC_MS_RIGHT, KC_TRNS, KC_TRNS, KC_LEFT, KC_DOWN, KC_RIGHT, KC_TRNS, \
78 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, \
79 KC_TRNS, KC_TRNS, KC_MS_BTN1, KC_MS_BTN2, \
80 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
81 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
82 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
83),
84/* Numbers layer
85 * ,----------------------------------, ,----------------------------------,
86 * | F1 | F2 | F3 | F4 | F5 | | F6 | F7 | F8 | F9 | F10 |
87 * |------+------+------+------+------| |-------------+------+------+------|
88 * | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 10 |
89 * |------+------+------+------+------| |------|------+------+------+------|
90 * | ! | @ | # | $ | % | | ^ | & | * | ( | ) |
91 * |------+------+------+-------------, ,-------------+------+------+------,
92 * | F11 | F12 | | | |
93 * '------+------'-------------' '-------------'------+------'
94 * | | | | | |
95 * | | | | | |
96 * | | | | | |
97 * '------+------' '------+------'
98 * '------+------' '------+------'
99 * | tab | home | | end | del |
100 * '------+------' '------+------'
101 * |\(NAV)| ~ | | gui |/(NUM)|
102 * '------+------' '------+------'
103 */
104[_NUM] = KEYMAP( \
105 KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, \
106 KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, \
107 KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_UNDS, \
108 KC_F11, KC_F12, KC_TRNS, KC_TRNS, \
109 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
110 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
111 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
112)
113};
114
115void persistent_default_layer_set(uint16_t default_layer) {
116 eeconfig_update_default_layer(default_layer);
117 default_layer_set(default_layer);
118}
119
diff --git a/keyboards/handwired/dactyl_manuform/keymaps/default/rules.mk b/keyboards/handwired/dactyl_manuform/keymaps/default/rules.mk
new file mode 100644
index 000000000..457a3d01d
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/keymaps/default/rules.mk
@@ -0,0 +1,3 @@
1ifndef QUANTUM_DIR
2 include ../../../../Makefile
3endif
diff --git a/keyboards/handwired/dactyl_manuform/keymaps/dvorak/config.h b/keyboards/handwired/dactyl_manuform/keymaps/dvorak/config.h
new file mode 100644
index 000000000..216917ed7
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/keymaps/dvorak/config.h
@@ -0,0 +1,37 @@
1/*
2This is the c configuration file for the keymap
3
4Copyright 2012 Jun Wako <wakojun@gmail.com>
5Copyright 2015 Jack Humbert
6
7This program is free software: you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation, either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program. If not, see <http://www.gnu.org/licenses/>.
19*/
20
21#ifndef CONFIG_USER_H
22#define CONFIG_USER_H
23
24#include "../../config.h"
25
26/* Use I2C or Serial, not both */
27
28#define USE_SERIAL
29// #define USE_I2C
30
31/* Select hand configuration */
32
33// #define MASTER_LEFT
34// #define MASTER_RIGHT
35#define EE_HANDS
36
37#endif
diff --git a/keyboards/handwired/dactyl_manuform/keymaps/dvorak/keymap.c b/keyboards/handwired/dactyl_manuform/keymaps/dvorak/keymap.c
new file mode 100644
index 000000000..e0852f8e0
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/keymaps/dvorak/keymap.c
@@ -0,0 +1,119 @@
1#include "dactyl_manuform.h"
2#include "action_layer.h"
3#include "eeconfig.h"
4
5extern keymap_config_t keymap_config;
6
7#define _BASE 0
8#define _NAV 1
9#define _NUM 2
10
11enum custom_keycodes {
12 QWERTY = SAFE_RANGE,
13 NAV,
14 NUM,
15};
16
17// Fillers to make layering more clear
18#define _______ KC_TRNS
19#define XXXXXXX KC_NO
20
21const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
22
23/* Base (dvorak)
24 * ,----------------------------------, ,----------------------------------,
25 * | ' | , | . | p | y | | f | g | c | r | l |
26 * |------+------+------+------+------| |-------------+------+------+------|
27 * | a | o | e | u | i | | d | h | t | n | s |
28 * |------+------+------+------+------| |------|------+------+------+------|
29 * | ; | q | j | k | x | | b | m | w | v | z |
30 * |------+------+------+-------------, ,-------------+------+------+------,
31 * | [ | ] | | - | = |
32 * '------+------'-------------' '-------------'------+------'
33 * | esc | bs | | space|enter |
34 * | + | + | | + | + |
35 * | shift| ctrl | | alt |shift |
36 * '------+------' '------+------'
37 * '------+------' '------+------'
38 * | tab | home | | end | del |
39 * |------+------' '------+------|
40 * |\(NAV)| ~ | | gui |/(NUM)|
41 * '------+------' '------+------'
42 */
43
44[_BASE] = KEYMAP( \
45 KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, \
46 KC_A, KC_O, KC_E, KC_U, KC_I, KC_D, KC_H, KC_T, KC_N, KC_S, \
47 KC_SCLN, KC_Q, KC_J, KC_K, KC_X, KC_B, KC_M, KC_W, KC_V, KC_Z, \
48 KC_LBRC, KC_RBRC, KC_MINS, KC_EQL, \
49 SFT_T(KC_ESC), CTL_T(KC_BSPC), ALT_T(KC_SPC), SFT_T(KC_ENT), \
50 KC_TAB, KC_HOME, KC_END, KC_DEL, \
51 LT(_NAV, KC_BSLS), KC_GRV, KC_LGUI, LT(_NUM, KC_SLSH) \
52),
53
54/* Navigation layer
55 * ,----------------------------------, ,----------------------------------,
56 * | | | mup | | | | | | up | | |
57 * |------+------+------+------+------| |-------------+------+------+------|
58 * | | mleft| mdown|mright| | | | left | down |right | |
59 * |------+------+------+------+------| |------|------+------+------+------|
60 * | | | | | | | | | | | |
61 * |------+------+------+-------------, ,-------------+------+------+------,
62 * | | | | mbtn |mbtn2 |
63 * '------+------'-------------' '-------------'------+------'
64 * | | | | | |
65 * | | | | | |
66 * | | | | | |
67 * '------+------' '------+------'
68 * '------+------' '------+------'
69 * | tab | home | | end | del |
70 * '------+------' '------+------'
71 * |\(NAV)| ~ | | gui |/(NUM)|
72 * '------+------' '------+------'
73 */
74
75[_NAV] = KEYMAP( \
76 KC_TRNS, KC_TRNS, KC_MS_UP, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_UP, KC_TRNS, KC_TRNS, \
77 KC_TRNS, KC_MS_LEFT, KC_MS_DOWN, KC_MS_RIGHT, KC_TRNS, KC_TRNS, KC_LEFT, KC_DOWN, KC_RIGHT, KC_TRNS, \
78 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS, \
79 KC_TRNS, KC_TRNS, KC_MS_BTN1, KC_MS_BTN2, \
80 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
81 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
82 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
83),
84/* Numbers layer
85 * ,----------------------------------, ,----------------------------------,
86 * | F1 | F2 | F3 | F4 | F5 | | F6 | F7 | F8 | F9 | F10 |
87 * |------+------+------+------+------| |-------------+------+------+------|
88 * | 1 | 2 | 3 | 4 | 5 | | 6 | 7 | 8 | 9 | 10 |
89 * |------+------+------+------+------| |------|------+------+------+------|
90 * | ! | @ | # | $ | % | | ^ | & | * | ( | ) |
91 * |------+------+------+-------------, ,-------------+------+------+------,
92 * | F11 | F12 | | | |
93 * '------+------'-------------' '-------------'------+------'
94 * | | | | | |
95 * | | | | | |
96 * | | | | | |
97 * '------+------' '------+------'
98 * '------+------' '------+------'
99 * | tab | home | | end | del |
100 * '------+------' '------+------'
101 * |\(NAV)| ~ | | gui |/(NUM)|
102 * '------+------' '------+------'
103 */
104[_NUM] = KEYMAP( \
105 KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, \
106 KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, \
107 KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_UNDS, \
108 KC_F11, KC_F12, KC_TRNS, KC_TRNS, \
109 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
110 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS,
111 KC_TRNS, KC_TRNS, KC_TRNS, KC_TRNS
112)
113};
114
115void persistent_default_layer_set(uint16_t default_layer) {
116 eeconfig_update_default_layer(default_layer);
117 default_layer_set(default_layer);
118}
119
diff --git a/keyboards/handwired/dactyl_manuform/keymaps/dvorak/rules.mk b/keyboards/handwired/dactyl_manuform/keymaps/dvorak/rules.mk
new file mode 100644
index 000000000..457a3d01d
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/keymaps/dvorak/rules.mk
@@ -0,0 +1,3 @@
1ifndef QUANTUM_DIR
2 include ../../../../Makefile
3endif
diff --git a/keyboards/handwired/dactyl_manuform/matrix.c b/keyboards/handwired/dactyl_manuform/matrix.c
new file mode 100644
index 000000000..c3bfe8042
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/matrix.c
@@ -0,0 +1,466 @@
1/*
2Copyright 2012 Jun Wako <wakojun@gmail.com>
3
4This program is free software: you can redistribute it and/or modify
5it under the terms of the GNU General Public License as published by
6the Free Software Foundation, either version 2 of the License, or
7(at your option) any later version.
8
9This program is distributed in the hope that it will be useful,
10but WITHOUT ANY WARRANTY; without even the implied warranty of
11MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12GNU General Public License for more details.
13
14You should have received a copy of the GNU General Public License
15along with this program. If not, see <http://www.gnu.org/licenses/>.
16*/
17
18/*
19 * scan matrix
20 */
21#include <stdint.h>
22#include <stdbool.h>
23#include <avr/io.h>
24#include "wait.h"
25#include "print.h"
26#include "debug.h"
27#include "util.h"
28#include "matrix.h"
29#include "split_util.h"
30#include "pro_micro.h"
31#include "config.h"
32#include "timer.h"
33
34#ifdef USE_I2C
35# include "i2c.h"
36#else // USE_SERIAL
37# include "serial.h"
38#endif
39
40#ifndef DEBOUNCING_DELAY
41# define DEBOUNCING_DELAY 5
42#endif
43
44#if (DEBOUNCING_DELAY > 0)
45 static uint16_t debouncing_time;
46 static bool debouncing = false;
47#endif
48
49#if (MATRIX_COLS <= 8)
50# define print_matrix_header() print("\nr/c 01234567\n")
51# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
52# define matrix_bitpop(i) bitpop(matrix[i])
53# define ROW_SHIFTER ((uint8_t)1)
54#else
55# error "Currently only supports 8 COLS"
56#endif
57static matrix_row_t matrix_debouncing[MATRIX_ROWS];
58
59#define ERROR_DISCONNECT_COUNT 5
60
61#define ROWS_PER_HAND (MATRIX_ROWS/2)
62
63static uint8_t error_count = 0;
64
65static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
66static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
67
68/* matrix state(1:on, 0:off) */
69static matrix_row_t matrix[MATRIX_ROWS];
70static matrix_row_t matrix_debouncing[MATRIX_ROWS];
71
72#if (DIODE_DIRECTION == COL2ROW)
73 static void init_cols(void);
74 static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
75 static void unselect_rows(void);
76 static void select_row(uint8_t row);
77 static void unselect_row(uint8_t row);
78#elif (DIODE_DIRECTION == ROW2COL)
79 static void init_rows(void);
80 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
81 static void unselect_cols(void);
82 static void unselect_col(uint8_t col);
83 static void select_col(uint8_t col);
84#endif
85
86__attribute__ ((weak))
87void matrix_init_kb(void) {
88 matrix_init_user();
89}
90
91__attribute__ ((weak))
92void matrix_scan_kb(void) {
93 matrix_scan_user();
94}
95
96__attribute__ ((weak))
97void matrix_init_user(void) {
98}
99
100__attribute__ ((weak))
101void matrix_scan_user(void) {
102}
103
104inline
105uint8_t matrix_rows(void)
106{
107 return MATRIX_ROWS;
108}
109
110inline
111uint8_t matrix_cols(void)
112{
113 return MATRIX_COLS;
114}
115
116void matrix_init(void)
117{
118#ifdef DISABLE_JTAG
119 // JTAG disable for PORT F. write JTD bit twice within four cycles.
120 MCUCR |= (1<<JTD);
121 MCUCR |= (1<<JTD);
122#endif
123
124 debug_enable = true;
125 debug_matrix = true;
126 debug_mouse = true;
127 // initialize row and col
128#if (DIODE_DIRECTION == COL2ROW)
129 unselect_rows();
130 init_cols();
131#elif (DIODE_DIRECTION == ROW2COL)
132 unselect_cols();
133 init_rows();
134#endif
135
136 TX_RX_LED_INIT;
137
138 // initialize matrix state: all keys off
139 for (uint8_t i=0; i < MATRIX_ROWS; i++) {
140 matrix[i] = 0;
141 matrix_debouncing[i] = 0;
142 }
143
144 matrix_init_quantum();
145
146}
147
148uint8_t _matrix_scan(void)
149{
150 int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
151#if (DIODE_DIRECTION == COL2ROW)
152 // Set row, read cols
153 for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
154# if (DEBOUNCING_DELAY > 0)
155 bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row);
156
157 if (matrix_changed) {
158 debouncing = true;
159 debouncing_time = timer_read();
160 PORTD ^= (1 << 2);
161 }
162
163# else
164 read_cols_on_row(matrix+offset, current_row);
165# endif
166
167 }
168
169#elif (DIODE_DIRECTION == ROW2COL)
170 // Set col, read rows
171 for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
172# if (DEBOUNCING_DELAY > 0)
173 bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col);
174 if (matrix_changed) {
175 debouncing = true;
176 debouncing_time = timer_read();
177 }
178# else
179 read_rows_on_col(matrix+offset, current_col);
180# endif
181
182 }
183#endif
184
185# if (DEBOUNCING_DELAY > 0)
186 if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) {
187 for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
188 matrix[i+offset] = matrix_debouncing[i+offset];
189 }
190 debouncing = false;
191 }
192# endif
193
194 return 1;
195}
196
197#ifdef USE_I2C
198
199// Get rows from other half over i2c
200int i2c_transaction(void) {
201 int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
202
203 int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
204 if (err) goto i2c_error;
205
206 // start of matrix stored at 0x00
207 err = i2c_master_write(0x00);
208 if (err) goto i2c_error;
209
210 // Start read
211 err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
212 if (err) goto i2c_error;
213
214 if (!err) {
215 int i;
216 for (i = 0; i < ROWS_PER_HAND-1; ++i) {
217 matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
218 }
219 matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
220 i2c_master_stop();
221 } else {
222i2c_error: // the cable is disconnceted, or something else went wrong
223 i2c_reset_state();
224 return err;
225 }
226
227 return 0;
228}
229
230#else // USE_SERIAL
231
232int serial_transaction(void) {
233 int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
234
235 if (serial_update_buffers()) {
236 return 1;
237 }
238
239 for (int i = 0; i < ROWS_PER_HAND; ++i) {
240 matrix[slaveOffset+i] = serial_slave_buffer[i];
241 }
242 return 0;
243}
244#endif
245
246uint8_t matrix_scan(void)
247{
248 uint8_t ret = _matrix_scan();
249
250#ifdef USE_I2C
251 if( i2c_transaction() ) {
252#else // USE_SERIAL
253 if( serial_transaction() ) {
254#endif
255 // turn on the indicator led when halves are disconnected
256 TXLED1;
257
258 error_count++;
259
260 if (error_count > ERROR_DISCONNECT_COUNT) {
261 // reset other half if disconnected
262 int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
263 for (int i = 0; i < ROWS_PER_HAND; ++i) {
264 matrix[slaveOffset+i] = 0;
265 }
266 }
267 } else {
268 // turn off the indicator led on no error
269 TXLED0;
270 error_count = 0;
271 }
272 matrix_scan_quantum();
273 return ret;
274}
275
276void matrix_slave_scan(void) {
277 _matrix_scan();
278
279 int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
280
281#ifdef USE_I2C
282 for (int i = 0; i < ROWS_PER_HAND; ++i) {
283 i2c_slave_buffer[i] = matrix[offset+i];
284 }
285#else // USE_SERIAL
286 for (int i = 0; i < ROWS_PER_HAND; ++i) {
287 serial_slave_buffer[i] = matrix[offset+i];
288 }
289#endif
290}
291
292bool matrix_is_modified(void)
293{
294 if (debouncing) return false;
295 return true;
296}
297
298inline
299bool matrix_is_on(uint8_t row, uint8_t col)
300{
301 return (matrix[row] & ((matrix_row_t)1<<col));
302}
303
304inline
305matrix_row_t matrix_get_row(uint8_t row)
306{
307 return matrix[row];
308}
309
310void matrix_print(void)
311{
312 print("\nr/c 0123456789ABCDEF\n");
313 for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
314 phex(row); print(": ");
315 pbin_reverse16(matrix_get_row(row));
316 print("\n");
317 }
318}
319
320uint8_t matrix_key_count(void)
321{
322 uint8_t count = 0;
323 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
324 count += bitpop16(matrix[i]);
325 }
326 return count;
327}
328
329#if (DIODE_DIRECTION == COL2ROW)
330
331static void init_cols(void)
332{
333 for(uint8_t x = 0; x < MATRIX_COLS; x++) {
334 uint8_t pin = col_pins[x];
335 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
336 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
337 }
338}
339
340static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
341{
342 // Store last value of row prior to reading
343 matrix_row_t last_row_value = current_matrix[current_row];
344
345 // Clear data in matrix row
346 current_matrix[current_row] = 0;
347
348 // Select row and wait for row selecton to stabilize
349 select_row(current_row);
350 wait_us(30);
351
352 // For each col...
353 for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
354
355 // Select the col pin to read (active low)
356 uint8_t pin = col_pins[col_index];
357 uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
358
359 // Populate the matrix row with the state of the col pin
360 current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
361 }
362
363 // Unselect row
364 unselect_row(current_row);
365
366 return (last_row_value != current_matrix[current_row]);
367}
368
369static void select_row(uint8_t row)
370{
371 uint8_t pin = row_pins[row];
372 _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
373 _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
374}
375
376static void unselect_row(uint8_t row)
377{
378 uint8_t pin = row_pins[row];
379 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
380 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
381}
382
383static void unselect_rows(void)
384{
385 for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
386 uint8_t pin = row_pins[x];
387 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
388 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
389 }
390}
391
392#elif (DIODE_DIRECTION == ROW2COL)
393
394static void init_rows(void)
395{
396 for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
397 uint8_t pin = row_pins[x];
398 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
399 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
400 }
401}
402
403static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
404{
405 bool matrix_changed = false;
406
407 // Select col and wait for col selecton to stabilize
408 select_col(current_col);
409 wait_us(30);
410
411 // For each row...
412 for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++)
413 {
414
415 // Store last value of row prior to reading
416 matrix_row_t last_row_value = current_matrix[row_index];
417
418 // Check row pin state
419 if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
420 {
421 // Pin LO, set col bit
422 current_matrix[row_index] |= (ROW_SHIFTER << current_col);
423 }
424 else
425 {
426 // Pin HI, clear col bit
427 current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
428 }
429
430 // Determine if the matrix changed state
431 if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
432 {
433 matrix_changed = true;
434 }
435 }
436
437 // Unselect col
438 unselect_col(current_col);
439
440 return matrix_changed;
441}
442
443static void select_col(uint8_t col)
444{
445 uint8_t pin = col_pins[col];
446 _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
447 _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
448}
449
450static void unselect_col(uint8_t col)
451{
452 uint8_t pin = col_pins[col];
453 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
454 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
455}
456
457static void unselect_cols(void)
458{
459 for(uint8_t x = 0; x < MATRIX_COLS; x++) {
460 uint8_t pin = col_pins[x];
461 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
462 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
463 }
464}
465
466#endif
diff --git a/keyboards/handwired/dactyl_manuform/readme.md b/keyboards/handwired/dactyl_manuform/readme.md
new file mode 100644
index 000000000..354e11ee9
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/readme.md
@@ -0,0 +1,147 @@
1Dactyl manuform
2======
3
4the [Dactyl-Manuform](https://github.com/tshort/dactyl-keyboard) is a split curved keyboard based on the design of [adereth dactyl](https://github.com/adereth/dactyl-keyboard) and thumb cluster design of the [manuform](https://geekhack.org/index.php?topic=46015.0) keyboard, the hardware is similar to the let's split keyboard. all information needed for making one is in the first link.
5
6## First Time Setup
7
8Download or clone the `qmk_firmware` repo and navigate to its top level directory. Once your build environment is setup, you'll be able to generate the default .hex using:
9
10```
11$ make dactyl_manuform:dvorak
12```
13
14You will see a lot of output and if everything worked correctly you will see the built hex file:
15
16```
17dactyl_manuform_dvorak.hex
18```
19
20If you would like to use one of the alternative keymaps, or create your own, copy one of the existing [keymaps](keymaps/) and run make like so:
21
22```
23$ make dactyl_manuform:YOUR_KEYMAP_NAME
24```
25
26If everything worked correctly you will see a file:
27
28```
29dactyl_manuform_YOUR_KEYMAP_NAME.hex
30```
31
32For more information on customizing keymaps, take a look at the primary documentation for [Customizing Your Keymap](/docs/faq_keymap.md) in the main readme.md.
33
34Required Hardware
35-----------------
36
37Apart from diodes and key switches for the keyboard matrix in each half, you
38will need:
39
40* 2 Arduino Pro Micros. You can find these on AliExpress for ≈3.50USD each.
41* 2 TRRS sockets and 1 TRRS cable, or 2 TRS sockets and 1 TRS cable
42
43Alternatively, you can use any sort of cable and socket that has at least 3
44wires. If you want to use I2C to communicate between halves, you will need a
45cable with at least 4 wires and 2x 4.7kΩ pull-up resistors
46
47Optional Hardware
48-----------------
49A speaker can be hooked-up to either side to the `5` (`C6`) pin and `GND`, and turned on via `AUDIO_ENABLE`.
50
51Wiring
52------
53
54The 3 wires of the TRS/TRRS cable need to connect GND, VCC, and digital pin 3 (i.e.
55PD0 on the ATmega32u4) between the two Pro Micros.
56
57Next, wire your key matrix to any of the remaining 17 IO pins of the pro micro
58and modify the `matrix.c` accordingly.
59
60The wiring for serial:
61
62![serial wiring](https://i.imgur.com/C3D1GAQ.png)
63
64The wiring for i2c:
65
66![i2c wiring](https://i.imgur.com/Hbzhc6E.png)
67
68The pull-up resistors may be placed on either half. It is also possible
69to use 4 resistors and have the pull-ups in both halves, but this is
70unnecessary in simple use cases.
71
72You can change your configuration between serial and i2c by modifying your `config.h` file.
73
74Notes on Software Configuration
75-------------------------------
76
77the keymaps in here are for the 4x5 layout of the keyboard only.
78
79Flashing
80-------
81From the top level `qmk_firmware` directory run `make KEYBOARD:KEYMAP:avrdude` for automatic serial port resolution and flashing.
82Example: `make lets_split/rev2:default:avrdude`
83
84
85Choosing which board to plug the USB cable into (choosing Master)
86--------
87Because the two boards are identical, the firmware has logic to differentiate the left and right board.
88
89It uses two strategies to figure things out: looking at the EEPROM (memory on the chip) or looking if the current board has the usb cable.
90
91The EEPROM approach requires additional setup (flashing the eeprom) but allows you to swap the usb cable to either side.
92
93The 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.
94
95### Setting the left hand as master
96If 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.
97
98### Setting the right hand as master
99If you always plug the usb cable into the right board, add an extra flag to your `config.h`
100```
101 #define MASTER_RIGHT
102```
103
104### Setting EE_hands to use either hands as master
105If you define `EE_HANDS` in your `config.h`, you will need to set the
106EEPROM for the left and right halves.
107
108The EEPROM is used to store whether the
109half is left handed or right handed. This makes it so that the same firmware
110file will run on both hands instead of having to flash left and right handed
111versions of the firmware to each half. To flash the EEPROM file for the left
112half run:
113```
114avrdude -p atmega32u4 -P $(COM_PORT) -c avr109 -U eeprom:w:eeprom-lefthand.eep
115// or the equivalent in dfu-programmer
116
117```
118and similarly for right half
119```
120avrdude -p atmega32u4 -P $(COM_PORT) -c avr109 -U eeprom:w:eeprom-righhand.eep
121// or the equivalent in dfu-programmer
122```
123
124NOTE: replace `$(COM_PORT)` with the port of your device (e.g. `/dev/ttyACM0`)
125
126After you have flashed the EEPROM, you then need to set `EE_HANDS` in your config.h, rebuild the hex files and reflash.
127
128Note that you need to program both halves, but you have the option of using
129different keymaps for each half. You could program the left half with a QWERTY
130layout and the right half with a Colemak layout using bootmagic's default layout option.
131Then if you connect the left half to a computer by USB the keyboard will use QWERTY and Colemak when the
132right half is connected.
133
134
135Notes on Using Pro Micro 3.3V
136-----------------------------
137
138Do update the `F_CPU` parameter in `rules.mk` to `8000000` which reflects
139the frequency on the 3.3V board.
140
141Also, if the slave board is producing weird characters in certain columns,
142update the following line in `matrix.c` to the following:
143
144```
145// _delay_us(30); // without this wait read unstable value.
146_delay_us(300); // without this wait read unstable value.
147```
diff --git a/keyboards/handwired/dactyl_manuform/rules.mk b/keyboards/handwired/dactyl_manuform/rules.mk
new file mode 100644
index 000000000..6c0949b54
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/rules.mk
@@ -0,0 +1,75 @@
1SRC += matrix.c \
2 i2c.c \
3 split_util.c \
4 serial.c \
5 ssd1306.c
6
7# MCU name
8#MCU = at90usb1287
9MCU = atmega32u4
10
11# Processor frequency.
12# This will define a symbol, F_CPU, in all source code files equal to the
13# processor frequency in Hz. You can then use this symbol in your source code to
14# calculate timings. Do NOT tack on a 'UL' at the end, this will be done
15# automatically to create a 32-bit value in your source code.
16#
17# This will be an integer division of F_USB below, as it is sourced by
18# F_USB after it has run through any CPU prescalers. Note that this value
19# does not *change* the processor frequency - it should merely be updated to
20# reflect the processor speed set externally so that the code can use accurate
21# software delays.
22F_CPU = 16000000
23
24#
25# LUFA specific
26#
27# Target architecture (see library "Board Types" documentation).
28ARCH = AVR8
29
30# Input clock frequency.
31# This will define a symbol, F_USB, in all source code files equal to the
32# input clock frequency (before any prescaling is performed) in Hz. This value may
33# differ from F_CPU if prescaling is used on the latter, and is required as the
34# raw input clock is fed directly to the PLL sections of the AVR for high speed
35# clock generation for the USB and other AVR subsections. Do NOT tack on a 'UL'
36# at the end, this will be done automatically to create a 32-bit value in your
37# source code.
38#
39# If no clock division is performed on the input clock inside the AVR (via the
40# CPU clock adjust registers or the clock division fuses), this will be equal to F_CPU.
41F_USB = $(F_CPU)
42
43# Bootloader
44# This definition is optional, and if your keyboard supports multiple bootloaders of
45# different sizes, comment this out, and the correct address will be loaded
46# automatically (+60). See bootloader.mk for all options.
47BOOTLOADER = caterina
48
49# Interrupt driven control endpoint task(+60)
50OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
51
52# Build Options
53# change to "no" to disable the options, or define them in the Makefile in
54# the appropriate keymap folder that will get included automatically
55#
56BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
57MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
58EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
59CONSOLE_ENABLE = no # Console for debug(+400)
60COMMAND_ENABLE = yes # Commands for debug and configuration
61NKRO_ENABLE = no # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
62BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
63MIDI_ENABLE = no # MIDI controls
64AUDIO_ENABLE = no # Audio output on port C6
65UNICODE_ENABLE = no # Unicode
66BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
67RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight. Do not enable this with audio at the same time.
68SUBPROJECT_rev1 = yes
69USE_I2C = yes
70# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
71SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
72
73CUSTOM_MATRIX = yes
74
75LAYOUTS = ortho_4x12
diff --git a/keyboards/handwired/dactyl_manuform/serial.c b/keyboards/handwired/dactyl_manuform/serial.c
new file mode 100644
index 000000000..74bcbb6bf
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/serial.c
@@ -0,0 +1,228 @@
1/*
2 * WARNING: be careful changing this code, it is very timing dependent
3 */
4
5#ifndef F_CPU
6#define F_CPU 16000000
7#endif
8
9#include <avr/io.h>
10#include <avr/interrupt.h>
11#include <util/delay.h>
12#include <stdbool.h>
13#include "serial.h"
14
15#ifndef USE_I2C
16
17// Serial pulse period in microseconds. Its probably a bad idea to lower this
18// value.
19#define SERIAL_DELAY 24
20
21uint8_t volatile serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH] = {0};
22uint8_t volatile serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH] = {0};
23
24#define SLAVE_DATA_CORRUPT (1<<0)
25volatile uint8_t status = 0;
26
27inline static
28void serial_delay(void) {
29 _delay_us(SERIAL_DELAY);
30}
31
32inline static
33void serial_output(void) {
34 SERIAL_PIN_DDR |= SERIAL_PIN_MASK;
35}
36
37// make the serial pin an input with pull-up resistor
38inline static
39void serial_input(void) {
40 SERIAL_PIN_DDR &= ~SERIAL_PIN_MASK;
41 SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
42}
43
44inline static
45uint8_t serial_read_pin(void) {
46 return !!(SERIAL_PIN_INPUT & SERIAL_PIN_MASK);
47}
48
49inline static
50void serial_low(void) {
51 SERIAL_PIN_PORT &= ~SERIAL_PIN_MASK;
52}
53
54inline static
55void serial_high(void) {
56 SERIAL_PIN_PORT |= SERIAL_PIN_MASK;
57}
58
59void serial_master_init(void) {
60 serial_output();
61 serial_high();
62}
63
64void serial_slave_init(void) {
65 serial_input();
66
67 // Enable INT0
68 EIMSK |= _BV(INT0);
69 // Trigger on falling edge of INT0
70 EICRA &= ~(_BV(ISC00) | _BV(ISC01));
71}
72
73// Used by the master to synchronize timing with the slave.
74static
75void sync_recv(void) {
76 serial_input();
77 // This shouldn't hang if the slave disconnects because the
78 // serial line will float to high if the slave does disconnect.
79 while (!serial_read_pin());
80 serial_delay();
81}
82
83// Used by the slave to send a synchronization signal to the master.
84static
85void sync_send(void) {
86 serial_output();
87
88 serial_low();
89 serial_delay();
90
91 serial_high();
92}
93
94// Reads a byte from the serial line
95static
96uint8_t serial_read_byte(void) {
97 uint8_t byte = 0;
98 serial_input();
99 for ( uint8_t i = 0; i < 8; ++i) {
100 byte = (byte << 1) | serial_read_pin();
101 serial_delay();
102 _delay_us(1);
103 }
104
105 return byte;
106}
107
108// Sends a byte with MSB ordering
109static
110void serial_write_byte(uint8_t data) {
111 uint8_t b = 8;
112 serial_output();
113 while( b-- ) {
114 if(data & (1 << b)) {
115 serial_high();
116 } else {
117 serial_low();
118 }
119 serial_delay();
120 }
121}
122
123// interrupt handle to be used by the slave device
124ISR(SERIAL_PIN_INTERRUPT) {
125 sync_send();
126
127 uint8_t checksum = 0;
128 for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
129 serial_write_byte(serial_slave_buffer[i]);
130 sync_send();
131 checksum += serial_slave_buffer[i];
132 }
133 serial_write_byte(checksum);
134 sync_send();
135
136 // wait for the sync to finish sending
137 serial_delay();
138
139 // read the middle of pulses
140 _delay_us(SERIAL_DELAY/2);
141
142 uint8_t checksum_computed = 0;
143 for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
144 serial_master_buffer[i] = serial_read_byte();
145 sync_send();
146 checksum_computed += serial_master_buffer[i];
147 }
148 uint8_t checksum_received = serial_read_byte();
149 sync_send();
150
151 serial_input(); // end transaction
152
153 if ( checksum_computed != checksum_received ) {
154 status |= SLAVE_DATA_CORRUPT;
155 } else {
156 status &= ~SLAVE_DATA_CORRUPT;
157 }
158}
159
160inline
161bool serial_slave_DATA_CORRUPT(void) {
162 return status & SLAVE_DATA_CORRUPT;
163}
164
165// Copies the serial_slave_buffer to the master and sends the
166// serial_master_buffer to the slave.
167//
168// Returns:
169// 0 => no error
170// 1 => slave did not respond
171int serial_update_buffers(void) {
172 // this code is very time dependent, so we need to disable interrupts
173 cli();
174
175 // signal to the slave that we want to start a transaction
176 serial_output();
177 serial_low();
178 _delay_us(1);
179
180 // wait for the slaves response
181 serial_input();
182 serial_high();
183 _delay_us(SERIAL_DELAY);
184
185 // check if the slave is present
186 if (serial_read_pin()) {
187 // slave failed to pull the line low, assume not present
188 sei();
189 return 1;
190 }
191
192 // if the slave is present syncronize with it
193 sync_recv();
194
195 uint8_t checksum_computed = 0;
196 // receive data from the slave
197 for (int i = 0; i < SERIAL_SLAVE_BUFFER_LENGTH; ++i) {
198 serial_slave_buffer[i] = serial_read_byte();
199 sync_recv();
200 checksum_computed += serial_slave_buffer[i];
201 }
202 uint8_t checksum_received = serial_read_byte();
203 sync_recv();
204
205 if (checksum_computed != checksum_received) {
206 sei();
207 return 1;
208 }
209
210 uint8_t checksum = 0;
211 // send data to the slave
212 for (int i = 0; i < SERIAL_MASTER_BUFFER_LENGTH; ++i) {
213 serial_write_byte(serial_master_buffer[i]);
214 sync_recv();
215 checksum += serial_master_buffer[i];
216 }
217 serial_write_byte(checksum);
218 sync_recv();
219
220 // always, release the line when not in use
221 serial_output();
222 serial_high();
223
224 sei();
225 return 0;
226}
227
228#endif
diff --git a/keyboards/handwired/dactyl_manuform/serial.h b/keyboards/handwired/dactyl_manuform/serial.h
new file mode 100644
index 000000000..15fe4db7b
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/serial.h
@@ -0,0 +1,26 @@
1#ifndef MY_SERIAL_H
2#define MY_SERIAL_H
3
4#include "config.h"
5#include <stdbool.h>
6
7/* TODO: some defines for interrupt setup */
8#define SERIAL_PIN_DDR DDRD
9#define SERIAL_PIN_PORT PORTD
10#define SERIAL_PIN_INPUT PIND
11#define SERIAL_PIN_MASK _BV(PD0)
12#define SERIAL_PIN_INTERRUPT INT0_vect
13
14#define SERIAL_SLAVE_BUFFER_LENGTH MATRIX_ROWS/2
15#define SERIAL_MASTER_BUFFER_LENGTH 1
16
17// Buffers for master - slave communication
18extern volatile uint8_t serial_slave_buffer[SERIAL_SLAVE_BUFFER_LENGTH];
19extern volatile uint8_t serial_master_buffer[SERIAL_MASTER_BUFFER_LENGTH];
20
21void serial_master_init(void);
22void serial_slave_init(void);
23int serial_update_buffers(void);
24bool serial_slave_data_corrupt(void);
25
26#endif
diff --git a/keyboards/handwired/dactyl_manuform/split_util.c b/keyboards/handwired/dactyl_manuform/split_util.c
new file mode 100644
index 000000000..346cbc908
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/split_util.c
@@ -0,0 +1,86 @@
1#include <avr/io.h>
2#include <avr/wdt.h>
3#include <avr/power.h>
4#include <avr/interrupt.h>
5#include <util/delay.h>
6#include <avr/eeprom.h>
7#include "split_util.h"
8#include "matrix.h"
9#include "keyboard.h"
10#include "config.h"
11#include "timer.h"
12
13#ifdef USE_I2C
14# include "i2c.h"
15#else
16# include "serial.h"
17#endif
18
19volatile bool isLeftHand = true;
20
21static void setup_handedness(void) {
22 #ifdef EE_HANDS
23 isLeftHand = eeprom_read_byte(EECONFIG_HANDEDNESS);
24 #else
25 // I2C_MASTER_RIGHT is deprecated, use MASTER_RIGHT instead, since this works for both serial and i2c
26 #if defined(I2C_MASTER_RIGHT) || defined(MASTER_RIGHT)
27 isLeftHand = !has_usb();
28 #else
29 isLeftHand = has_usb();
30 #endif
31 #endif
32}
33
34static void keyboard_master_setup(void) {
35#ifdef USE_I2C
36 i2c_master_init();
37#ifdef SSD1306OLED
38 matrix_master_OLED_init ();
39#endif
40#else
41 serial_master_init();
42#endif
43}
44
45static void keyboard_slave_setup(void) {
46 timer_init();
47#ifdef USE_I2C
48 i2c_slave_init(SLAVE_I2C_ADDRESS);
49#else
50 serial_slave_init();
51#endif
52}
53
54bool has_usb(void) {
55 USBCON |= (1 << OTGPADE); //enables VBUS pad
56 _delay_us(5);
57 return (USBSTA & (1<<VBUS)); //checks state of VBUS
58}
59
60void split_keyboard_setup(void) {
61 setup_handedness();
62
63 if (has_usb()) {
64 keyboard_master_setup();
65 } else {
66 keyboard_slave_setup();
67 }
68 sei();
69}
70
71void keyboard_slave_loop(void) {
72 matrix_init();
73
74 while (1) {
75 matrix_slave_scan();
76 }
77}
78
79// this code runs before the usb and keyboard is initialized
80void matrix_setup(void) {
81 split_keyboard_setup();
82
83 if (!has_usb()) {
84 keyboard_slave_loop();
85 }
86}
diff --git a/keyboards/handwired/dactyl_manuform/split_util.h b/keyboards/handwired/dactyl_manuform/split_util.h
new file mode 100644
index 000000000..595a0659e
--- /dev/null
+++ b/keyboards/handwired/dactyl_manuform/split_util.h
@@ -0,0 +1,20 @@
1#ifndef SPLIT_KEYBOARD_UTIL_H
2#define SPLIT_KEYBOARD_UTIL_H
3
4#include <stdbool.h>
5#include "eeconfig.h"
6
7#define SLAVE_I2C_ADDRESS 0x32
8
9extern volatile bool isLeftHand;
10
11// slave version of matix scan, defined in matrix.c
12void matrix_slave_scan(void);
13
14void split_keyboard_setup(void);
15bool has_usb(void);
16void keyboard_slave_loop(void);
17
18void matrix_master_OLED_init (void);
19
20#endif
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-09 02:48:50 +0000