aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--keyboards/levinson/config.h31
-rw-r--r--keyboards/levinson/i2c.c162
-rw-r--r--keyboards/levinson/i2c.h49
-rw-r--r--keyboards/levinson/keymaps/bakingpy2u/config.h30
-rw-r--r--keyboards/levinson/keymaps/bakingpy2u/keymap.c206
-rw-r--r--keyboards/levinson/keymaps/bakingpy2u/rules.mk6
-rw-r--r--keyboards/levinson/keymaps/default/config.h37
-rw-r--r--keyboards/levinson/keymaps/default/keymap.c214
-rw-r--r--keyboards/levinson/keymaps/default/rules.mk3
-rw-r--r--keyboards/levinson/levinson.c16
-rw-r--r--keyboards/levinson/levinson.h25
-rw-r--r--keyboards/levinson/matrix.c477
-rw-r--r--keyboards/levinson/readme.md20
-rw-r--r--keyboards/levinson/rev1/config.h88
-rw-r--r--keyboards/levinson/rev1/rev1.c39
-rw-r--r--keyboards/levinson/rev1/rev1.h60
-rw-r--r--keyboards/levinson/rev1/rules.mk1
-rw-r--r--keyboards/levinson/rules.mk78
-rw-r--r--keyboards/levinson/serial.c228
-rw-r--r--keyboards/levinson/serial.h26
-rw-r--r--keyboards/levinson/split_util.c86
-rw-r--r--keyboards/levinson/split_util.h20
-rw-r--r--keyboards/levinson/subproject.mk1
23 files changed, 1903 insertions, 0 deletions
diff --git a/keyboards/levinson/config.h b/keyboards/levinson/config.h
new file mode 100644
index 000000000..591c656a2
--- /dev/null
+++ b/keyboards/levinson/config.h
@@ -0,0 +1,31 @@
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#ifdef SUBPROJECT_rev1
25 #include "rev1/config.h"
26#endif
27#ifdef SUBPROJECT_rev2
28 #include "rev2/config.h"
29#endif
30
31#endif
diff --git a/keyboards/levinson/i2c.c b/keyboards/levinson/i2c.c
new file mode 100644
index 000000000..084c890c4
--- /dev/null
+++ b/keyboards/levinson/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/levinson/i2c.h b/keyboards/levinson/i2c.h
new file mode 100644
index 000000000..c15b6bc50
--- /dev/null
+++ b/keyboards/levinson/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/levinson/keymaps/bakingpy2u/config.h b/keyboards/levinson/keymaps/bakingpy2u/config.h
new file mode 100644
index 000000000..6b409bf0d
--- /dev/null
+++ b/keyboards/levinson/keymaps/bakingpy2u/config.h
@@ -0,0 +1,30 @@
1#ifndef CONFIG_USER_H
2#define CONFIG_USER_H
3
4#include "../../config.h"
5
6/* Use I2C or Serial, not both */
7
8#define USE_SERIAL
9// #define USE_I2C
10
11/* Select hand configuration */
12
13#define MASTER_LEFT
14// #define _MASTER_RIGHT
15// #define EE_HANDS
16
17#define TAPPING_TERM 150
18
19#undef RGBLED_NUM
20#define RGBLIGHT_ANIMATIONS
21#define RGBLED_NUM 12
22#define RGBLIGHT_HUE_STEP 8
23#define RGBLIGHT_SAT_STEP 8
24#define RGBLIGHT_VAL_STEP 8
25
26#define BACKLIGHT_PIN B6
27//#define BACKLIGHT_BREATHING
28#define BACKLIGHT_LEVELS 7
29
30#endif \ No newline at end of file
diff --git a/keyboards/levinson/keymaps/bakingpy2u/keymap.c b/keyboards/levinson/keymaps/bakingpy2u/keymap.c
new file mode 100644
index 000000000..bea3f5daa
--- /dev/null
+++ b/keyboards/levinson/keymaps/bakingpy2u/keymap.c
@@ -0,0 +1,206 @@
1#include "levinson.h"
2#include "action_layer.h"
3#include "eeconfig.h"
4
5extern keymap_config_t keymap_config;
6
7#define _QWERTY 0
8#define _COLEMAK 1
9#define _DVORAK 2
10#define _LOWER 3
11#define _RAISE 4
12#define _FN3 5
13#define _FN4 6
14#define _ADJUST 16
15
16enum custom_keycodes {
17 QWERTY = SAFE_RANGE,
18 COLEMAK,
19 DVORAK,
20 LOWER,
21 RAISE,
22 FN3,
23 FN4,
24 ADJUST,
25};
26
27#define KC_ KC_TRNS
28#define _______ KC_TRNS
29
30#define KC_CAPW LGUI(LSFT(KC_3)) // Capture whole screen
31#define KC_CPYW LGUI(LSFT(LCTL(KC_3))) // Copy whole screen
32#define KC_CAPP LGUI(LSFT(KC_4)) // Capture portion of screen
33#define KC_CPYP LGUI(LSFT(LCTL(KC_4))) // Copy portion of screen
34#define KC_X0 MT(MOD_LCTL, KC_ESC)
35#define KC_X1 LOWER
36#define KC_X2 RAISE
37#define KC_X3 LT(_FN3, KC_GRV)
38#define KC_X4 MT(MOD_LSFT, KC_ENT)
39#define KC_X5 BL_STEP
40
41const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
42
43 [_QWERTY] = KC_KEYMAP(
44 //,----+----+----+----+----+----. ,----+----+----+----+----+----.
45 TAB , Q , W , E , R , T , Y , U , I , O , P ,MINS,
46 //|----+----+----+----+----+----| |----+----+----+----+----+----|
47 X0 , A , S , D , F , G , H , J , K , L ,SCLN,QUOT,
48 //|----+----+----+----+----+----| |----+----+----+----+----+----|
49 LSFT, Z , X , C , V , B , N , M ,COMM,DOT ,SLSH, X4 ,
50 //|----+----+----+----+----+----| |----+----+----+----+----+----|
51 X3 ,LCTL, X1 ,LGUI,SPC ,SPC , BSPC,BSPC, X2 ,RALT, UP ,RGHT
52 //`----+----+----+----+----+----' `----+----+----+----+----+----'
53 ),
54
55 [_COLEMAK] = KC_KEYMAP(
56 //,----+----+----+----+----+----. ,----+----+----+----+----+----.
57 TAB , Q , W , F , P , G , J , L , U , Y ,SCLN,MINS,
58 //|----+----+----+----+----+----| |----+----+----+----+----+----|
59 X0 , A , R , S , T , D , H , N , E , I , O ,QUOT,
60 //|----+----+----+----+----+----| |----+----+----+----+----+----|
61 LSFT, Z , X , C , V , B , K , M ,COMM,DOT ,SLSH, X4 ,
62 //|----+----+----+----+----+----| |----+----+----+----+----+----|
63 X3 ,LCTL, X1 ,LGUI,SPC ,SPC , BSPC,BSPC, X2 ,RALT, UP ,RGHT
64 //`----+----+----+----+----+----' `----+----+----+----+----+----'
65 ),
66
67 [_DVORAK] = KC_KEYMAP(
68 //,----+----+----+----+----+----. ,----+----+----+----+----+----.
69 TAB ,QUOT,COMM,DOT , P , Y , F , G , C , R , L ,MINS,
70 //|----+----+----+----+----+----| |----+----+----+----+----+----|
71 X0 , A , O , E , U , I , D , H , T , N , S ,SLSH,
72 //|----+----+----+----+----+----| |----+----+----+----+----+----|
73 LSFT,SCLN, Q , J , K , X , B , M , W , V , Z , X4 ,
74 //|----+----+----+----+----+----| |----+----+----+----+----+----|
75 X3 ,LCTL, X1 ,LGUI,SPC ,SPC , BSPC,BSPC, X2 ,RALT, UP ,RGHT
76 //`----+----+----+----+----+----' `----+----+----+----+----+----'
77 ),
78
79 [_LOWER] = KC_KEYMAP(
80 //,----+----+----+----+----+----. ,----+----+----+----+----+----.
81 X5 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 0 , ,
82 //|----+----+----+----+----+----| |----+----+----+----+----+----|
83 DEL ,CAPP,LEFT,RGHT, UP ,LBRC, RBRC, P4 , P5 , P6 ,PLUS,PIPE,
84 //|----+----+----+----+----+----| |----+----+----+----+----+----|
85 ,CPYP, , ,DOWN,LCBR, RCBR, P1 , P2 , P3 ,MINS, ,
86 //|----+----+----+----+----+----| |----+----+----+----+----+----|
87 , , , , ,DEL , DEL , , P0 ,PDOT, ,
88 //`----+----+----+----+----+----' `----+----+----+----+----+----'
89 ),
90
91 [_RAISE] = KC_KEYMAP(
92 //,----+----+----+----+----+----. ,----+----+----+----+----+----.
93 ,EXLM, AT ,HASH,DLR ,PERC, CIRC,AMPR,ASTR,LPRN,RPRN, ,
94 //|----+----+----+----+----+----| |----+----+----+----+----+----|
95 DEL ,MPRV,MNXT,VOLU,PGUP,UNDS, EQL ,HOME, , , ,BSLS,
96 //|----+----+----+----+----+----| |----+----+----+----+----+----|
97 MUTE,MSTP,MPLY,VOLD,PGDN,MINS, PLUS,END , , , , ,
98 //|----+----+----+----+----+----| |----+----+----+----+----+----|
99 , , , , , , , , , , ,
100 //`----+----+----+----+----+----' `----+----+----+----+----+----'
101 ),
102
103 [_FN3] = KC_KEYMAP(
104 //,----+----+----+----+----+----. ,----+----+----+----+----+----.
105 F12 , F1 , F2 , F3 , F4 , F5 , F6 , F7 , F8 , F9 ,F10 ,F11 ,
106 //|----+----+----+----+----+----| |----+----+----+----+----+----|
107 , , , , , , , , , , , ,
108 //|----+----+----+----+----+----| |----+----+----+----+----+----|
109 , , , , , , , , , , , ,
110 //|----+----+----+----+----+----| |----+----+----+----+----+----|
111 , , , , , , , , , , ,
112 //`----+----+----+----+----+----' `----+----+----+----+----+----'
113 ),
114
115/* Adjust (Lower + Raise)
116 * ,-----------------------------------------------------------------------------------.
117 * | | Reset|RGB Tg|RGB Md|Hue Up|Hue Dn|Sat Up|Sat Dn|Val Up|Val Dn| | |
118 * |------+------+------+------+------+-------------+------+------+------+------+------|
119 * | | | |Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk|Dvorak| | |
120 * |------+------+------+------+------+------|------+------+------+------+------+------|
121 * | | | | | | | | | | | | |
122 * |------+------+------+------+------+------+------+------+------+------+------+------|
123 * | | | | | | | | | | | |
124 * `-----------------------------------------------------------------------------------'
125 */
126 [_ADJUST] = KEYMAP( \
127 _______, RESET , RGB_TOG, RGB_MOD, RGB_HUD, RGB_HUI, RGB_SAD, RGB_SAI, RGB_VAD, RGB_VAI, _______, _______, \
128 _______, _______, _______, AU_ON, AU_OFF, AG_NORM, AG_SWAP, QWERTY, COLEMAK, DVORAK, _______, _______, \
129 _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
130 _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ \
131 )
132
133
134};
135
136#ifdef AUDIO_ENABLE
137float tone_qwerty[][2] = SONG(QWERTY_SOUND);
138float tone_dvorak[][2] = SONG(DVORAK_SOUND);
139float tone_colemak[][2] = SONG(COLEMAK_SOUND);
140#endif
141
142void persistent_default_layer_set(uint16_t default_layer) {
143 eeconfig_update_default_layer(default_layer);
144 default_layer_set(default_layer);
145}
146
147bool process_record_user(uint16_t keycode, keyrecord_t *record) {
148 switch (keycode) {
149 case QWERTY:
150 if (record->event.pressed) {
151 #ifdef AUDIO_ENABLE
152 PLAY_SONG(tone_qwerty);
153 #endif
154 persistent_default_layer_set(1UL<<_QWERTY);
155 }
156 return false;
157 break;
158 case COLEMAK:
159 if (record->event.pressed) {
160 #ifdef AUDIO_ENABLE
161 PLAY_SONG(tone_colemak);
162 #endif
163 persistent_default_layer_set(1UL<<_COLEMAK);
164 }
165 return false;
166 break;
167 case DVORAK:
168 if (record->event.pressed) {
169 #ifdef AUDIO_ENABLE
170 PLAY_SONG(tone_dvorak);
171 #endif
172 persistent_default_layer_set(1UL<<_DVORAK);
173 }
174 return false;
175 break;
176 case LOWER:
177 if (record->event.pressed) {
178 layer_on(_LOWER);
179 update_tri_layer(_LOWER, _RAISE, _ADJUST);
180 } else {
181 layer_off(_LOWER);
182 update_tri_layer(_LOWER, _RAISE, _ADJUST);
183 }
184 return false;
185 break;
186 case RAISE:
187 if (record->event.pressed) {
188 layer_on(_RAISE);
189 update_tri_layer(_LOWER, _RAISE, _ADJUST);
190 } else {
191 layer_off(_RAISE);
192 update_tri_layer(_LOWER, _RAISE, _ADJUST);
193 }
194 return false;
195 break;
196 case ADJUST:
197 if (record->event.pressed) {
198 layer_on(_ADJUST);
199 } else {
200 layer_off(_ADJUST);
201 }
202 return false;
203 break;
204 }
205 return true;
206}
diff --git a/keyboards/levinson/keymaps/bakingpy2u/rules.mk b/keyboards/levinson/keymaps/bakingpy2u/rules.mk
new file mode 100644
index 000000000..22b6ec476
--- /dev/null
+++ b/keyboards/levinson/keymaps/bakingpy2u/rules.mk
@@ -0,0 +1,6 @@
1RGBLIGHT_ENABLE = yes
2BACKLIGHT_ENABLE = yes
3
4ifndef QUANTUM_DIR
5 include ../../../../Makefile
6endif
diff --git a/keyboards/levinson/keymaps/default/config.h b/keyboards/levinson/keymaps/default/config.h
new file mode 100644
index 000000000..7f33a4363
--- /dev/null
+++ b/keyboards/levinson/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 \ No newline at end of file
diff --git a/keyboards/levinson/keymaps/default/keymap.c b/keyboards/levinson/keymaps/default/keymap.c
new file mode 100644
index 000000000..4bee2c5e6
--- /dev/null
+++ b/keyboards/levinson/keymaps/default/keymap.c
@@ -0,0 +1,214 @@
1#include "levinson.h"
2#include "action_layer.h"
3#include "eeconfig.h"
4
5extern keymap_config_t keymap_config;
6
7// Each layer gets a name for readability, which is then used in the keymap matrix below.
8// The underscores don't mean anything - you can have a layer called STUFF or any other name.
9// Layer names don't all need to be of the same length, obviously, and you can also skip them
10// entirely and just use numbers.
11#define _QWERTY 0
12#define _COLEMAK 1
13#define _DVORAK 2
14#define _LOWER 3
15#define _RAISE 4
16#define _ADJUST 16
17
18enum custom_keycodes {
19 QWERTY = SAFE_RANGE,
20 COLEMAK,
21 DVORAK,
22 LOWER,
23 RAISE,
24 ADJUST,
25};
26
27// Fillers to make layering more clear
28#define _______ KC_TRNS
29#define XXXXXXX KC_NO
30
31const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
32
33/* Qwerty
34 * ,-----------------------------------------------------------------------------------.
35 * | Tab | Q | W | E | R | T | Y | U | I | O | P | Bksp |
36 * |------+------+------+------+------+-------------+------+------+------+------+------|
37 * | Esc | A | S | D | F | G | H | J | K | L | ; | " |
38 * |------+------+------+------+------+------|------+------+------+------+------+------|
39 * | Shift| Z | X | C | V | B | N | M | , | . | / |Enter |
40 * |------+------+------+------+------+------+------+------+------+------+------+------|
41 * |Adjust| Ctrl | Alt | GUI |Lower |Space |Space |Raise | Left | Down | Up |Right |
42 * `-----------------------------------------------------------------------------------'
43 */
44[_QWERTY] = KEYMAP( \
45 KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_BSPC, \
46 KC_ESC, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, \
47 KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT , \
48 ADJUST, KC_LCTL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT \
49),
50
51/* Colemak
52 * ,-----------------------------------------------------------------------------------.
53 * | Tab | Q | W | F | P | G | J | L | U | Y | ; | Bksp |
54 * |------+------+------+------+------+-------------+------+------+------+------+------|
55 * | Esc | A | R | S | T | D | H | N | E | I | O | " |
56 * |------+------+------+------+------+------|------+------+------+------+------+------|
57 * | Shift| Z | X | C | V | B | K | M | , | . | / |Enter |
58 * |------+------+------+------+------+------+------+------+------+------+------+------|
59 * |Adjust| Ctrl | Alt | GUI |Lower |Space |Space |Raise | Left | Down | Up |Right |
60 * `-----------------------------------------------------------------------------------'
61 */
62[_COLEMAK] = KEYMAP( \
63 KC_TAB, KC_Q, KC_W, KC_F, KC_P, KC_G, KC_J, KC_L, KC_U, KC_Y, KC_SCLN, KC_BSPC, \
64 KC_ESC, KC_A, KC_R, KC_S, KC_T, KC_D, KC_H, KC_N, KC_E, KC_I, KC_O, KC_QUOT, \
65 KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_K, KC_M, KC_COMM, KC_DOT, KC_SLSH, KC_ENT , \
66 ADJUST, KC_LCTL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT \
67),
68
69/* Dvorak
70 * ,-----------------------------------------------------------------------------------.
71 * | Tab | " | , | . | P | Y | F | G | C | R | L | Bksp |
72 * |------+------+------+------+------+-------------+------+------+------+------+------|
73 * | Esc | A | O | E | U | I | D | H | T | N | S | / |
74 * |------+------+------+------+------+------|------+------+------+------+------+------|
75 * | Shift| ; | Q | J | K | X | B | M | W | V | Z |Enter |
76 * |------+------+------+------+------+------+------+------+------+------+------+------|
77 * |Adjust| Ctrl | Alt | GUI |Lower |Space |Space |Raise | Left | Down | Up |Right |
78 * `-----------------------------------------------------------------------------------'
79 */
80[_DVORAK] = KEYMAP( \
81 KC_TAB, KC_QUOT, KC_COMM, KC_DOT, KC_P, KC_Y, KC_F, KC_G, KC_C, KC_R, KC_L, KC_BSPC, \
82 KC_ESC, KC_A, KC_O, KC_E, KC_U, KC_I, KC_D, KC_H, KC_T, KC_N, KC_S, KC_SLSH, \
83 KC_LSFT, KC_SCLN, KC_Q, KC_J, KC_K, KC_X, KC_B, KC_M, KC_W, KC_V, KC_Z, KC_ENT , \
84 ADJUST, KC_LCTL, KC_LALT, KC_LGUI, LOWER, KC_SPC, KC_SPC, RAISE, KC_LEFT, KC_DOWN, KC_UP, KC_RGHT \
85),
86
87/* Lower
88 * ,-----------------------------------------------------------------------------------.
89 * | ~ | ! | @ | # | $ | % | ^ | & | * | ( | ) | Bksp |
90 * |------+------+------+------+------+-------------+------+------+------+------+------|
91 * | Del | F1 | F2 | F3 | F4 | F5 | F6 | _ | + | | \ | | |
92 * |------+------+------+------+------+------|------+------+------+------+------+------|
93 * | | F7 | F8 | F9 | F10 | F11 | F12 |ISO ~ |ISO | | | |Enter |
94 * |------+------+------+------+------+------+------+------+------+------+------+------|
95 * | | | | | | | | Next | Vol- | Vol+ | Play |
96 * `-----------------------------------------------------------------------------------'
97 */
98[_LOWER] = KEYMAP( \
99 KC_TILD, KC_EXLM, KC_AT, KC_HASH, KC_DLR, KC_PERC, KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_BSPC, \
100 KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_UNDS, KC_PLUS, KC_LCBR, KC_RCBR, KC_PIPE, \
101 _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12,S(KC_NUHS),S(KC_NUBS),_______, _______, _______, \
102 _______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY \
103),
104
105/* Raise
106 * ,-----------------------------------------------------------------------------------.
107 * | ` | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | Bksp |
108 * |------+------+------+------+------+-------------+------+------+------+------+------|
109 * | Del | F1 | F2 | F3 | F4 | F5 | F6 | - | = | [ | ] | \ |
110 * |------+------+------+------+------+------|------+------+------+------+------+------|
111 * | | F7 | F8 | F9 | F10 | F11 | F12 |ISO # |ISO / | | |Enter |
112 * |------+------+------+------+------+------+------+------+------+------+------+------|
113 * | | | | | | | | Next | Vol- | Vol+ | Play |
114 * `-----------------------------------------------------------------------------------'
115 */
116[_RAISE] = KEYMAP( \
117 KC_GRV, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_BSPC, \
118 KC_DEL, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_MINS, KC_EQL, KC_LBRC, KC_RBRC, KC_BSLS, \
119 _______, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, KC_NUHS, KC_NUBS, _______, _______, _______, \
120 _______, _______, _______, _______, _______, _______, _______, _______, KC_MNXT, KC_VOLD, KC_VOLU, KC_MPLY \
121),
122
123/* Adjust (Lower + Raise)
124 * ,-----------------------------------------------------------------------------------.
125 * | | Reset| | | | | | | | | | Del |
126 * |------+------+------+------+------+-------------+------+------+------+------+------|
127 * | | | |Aud on|Audoff|AGnorm|AGswap|Qwerty|Colemk|Dvorak| | |
128 * |------+------+------+------+------+------|------+------+------+------+------+------|
129 * | | | | | | | | | | | | |
130 * |------+------+------+------+------+------+------+------+------+------+------+------|
131 * | | | | | | | | | | | |
132 * `-----------------------------------------------------------------------------------'
133 */
134[_ADJUST] = KEYMAP( \
135 _______, RESET, _______, _______, _______, _______, _______, _______, _______, _______, _______, KC_DEL, \
136 _______, _______, _______, AU_ON, AU_OFF, AG_NORM, AG_SWAP, QWERTY, COLEMAK, DVORAK, _______, _______, \
137 _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, \
138 _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______ \
139)
140
141
142};
143
144#ifdef AUDIO_ENABLE
145float tone_qwerty[][2] = SONG(QWERTY_SOUND);
146float tone_dvorak[][2] = SONG(DVORAK_SOUND);
147float tone_colemak[][2] = SONG(COLEMAK_SOUND);
148#endif
149
150void persistent_default_layer_set(uint16_t default_layer) {
151 eeconfig_update_default_layer(default_layer);
152 default_layer_set(default_layer);
153}
154
155bool process_record_user(uint16_t keycode, keyrecord_t *record) {
156 switch (keycode) {
157 case QWERTY:
158 if (record->event.pressed) {
159 #ifdef AUDIO_ENABLE
160 PLAY_SONG(tone_qwerty);
161 #endif
162 persistent_default_layer_set(1UL<<_QWERTY);
163 }
164 return false;
165 break;
166 case COLEMAK:
167 if (record->event.pressed) {
168 #ifdef AUDIO_ENABLE
169 PLAY_SONG(tone_colemak);
170 #endif
171 persistent_default_layer_set(1UL<<_COLEMAK);
172 }
173 return false;
174 break;
175 case DVORAK:
176 if (record->event.pressed) {
177 #ifdef AUDIO_ENABLE
178 PLAY_SONG(tone_dvorak);
179 #endif
180 persistent_default_layer_set(1UL<<_DVORAK);
181 }
182 return false;
183 break;
184 case LOWER:
185 if (record->event.pressed) {
186 layer_on(_LOWER);
187 update_tri_layer(_LOWER, _RAISE, _ADJUST);
188 } else {
189 layer_off(_LOWER);
190 update_tri_layer(_LOWER, _RAISE, _ADJUST);
191 }
192 return false;
193 break;
194 case RAISE:
195 if (record->event.pressed) {
196 layer_on(_RAISE);
197 update_tri_layer(_LOWER, _RAISE, _ADJUST);
198 } else {
199 layer_off(_RAISE);
200 update_tri_layer(_LOWER, _RAISE, _ADJUST);
201 }
202 return false;
203 break;
204 case ADJUST:
205 if (record->event.pressed) {
206 layer_on(_ADJUST);
207 } else {
208 layer_off(_ADJUST);
209 }
210 return false;
211 break;
212 }
213 return true;
214} \ No newline at end of file
diff --git a/keyboards/levinson/keymaps/default/rules.mk b/keyboards/levinson/keymaps/default/rules.mk
new file mode 100644
index 000000000..457a3d01d
--- /dev/null
+++ b/keyboards/levinson/keymaps/default/rules.mk
@@ -0,0 +1,3 @@
1ifndef QUANTUM_DIR
2 include ../../../../Makefile
3endif
diff --git a/keyboards/levinson/levinson.c b/keyboards/levinson/levinson.c
new file mode 100644
index 000000000..2c993daec
--- /dev/null
+++ b/keyboards/levinson/levinson.c
@@ -0,0 +1,16 @@
1#include "levinson.h"
2
3#ifdef ONEHAND_ENABLE
4__attribute__ ((weak))
5const keypos_t hand_swap_config[MATRIX_ROWS][MATRIX_COLS] = {
6
7 {{5, 4}, {4, 4}, {3, 4}, {2, 4}, {1, 4}, {0, 4}},
8 {{5, 5}, {4, 5}, {3, 5}, {2, 5}, {1, 5}, {0, 5}},
9 {{5, 6}, {4, 6}, {3, 6}, {2, 6}, {1, 6}, {0, 6}},
10 {{5, 7}, {4, 7}, {3, 7}, {2, 7}, {1, 7}, {0, 7}},
11 {{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}},
12 {{0, 1}, {1, 1}, {2, 1}, {3, 1}, {4, 1}, {5, 1}},
13 {{0, 2}, {1, 2}, {2, 2}, {3, 2}, {4, 2}, {5, 2}},
14 {{0, 3}, {1, 3}, {2, 3}, {3, 3}, {4, 3}, {5, 3}},
15};
16#endif
diff --git a/keyboards/levinson/levinson.h b/keyboards/levinson/levinson.h
new file mode 100644
index 000000000..c69a06fab
--- /dev/null
+++ b/keyboards/levinson/levinson.h
@@ -0,0 +1,25 @@
1#ifndef LEVINSON_H
2#define LEVINSON_H
3
4#include "quantum.h"
5
6#include QMK_SUBPROJECT_H
7
8// Used to create a keymap using only KC_ prefixed keys
9#define KC_KEYMAP( \
10 L00, L01, L02, L03, L04, L05, R00, R01, R02, R03, R04, R05, \
11 L10, L11, L12, L13, L14, L15, R10, R11, R12, R13, R14, R15, \
12 L20, L21, L22, L23, L24, L25, R20, R21, R22, R23, R24, R25, \
13 L30, L31, L32, L33, L34, L35, R30, R31, R32, R33, R34, R35 \
14 ) \
15 KEYMAP( \
16 KC_##L00, KC_##L01, KC_##L02, KC_##L03, KC_##L04, KC_##L05, KC_##R00, KC_##R01, KC_##R02, KC_##R03, KC_##R04, KC_##R05, \
17 KC_##L10, KC_##L11, KC_##L12, KC_##L13, KC_##L14, KC_##L15, KC_##R10, KC_##R11, KC_##R12, KC_##R13, KC_##R14, KC_##R15, \
18 KC_##L20, KC_##L21, KC_##L22, KC_##L23, KC_##L24, KC_##L25, KC_##R20, KC_##R21, KC_##R22, KC_##R23, KC_##R24, KC_##R25, \
19 KC_##L30, KC_##L31, KC_##L32, KC_##L33, KC_##L34, KC_##L35, KC_##R30, KC_##R31, KC_##R32, KC_##R33, KC_##R34, KC_##R35 \
20 )
21
22#define LAYOUT_ortho_4x12 KEYMAP
23#define KC_LAYOUT_ortho_4x12 KC_KEYMAP
24
25#endif \ No newline at end of file
diff --git a/keyboards/levinson/matrix.c b/keyboards/levinson/matrix.c
new file mode 100644
index 000000000..9d8a14d19
--- /dev/null
+++ b/keyboards/levinson/matrix.c
@@ -0,0 +1,477 @@
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#include "backlight.h"
34
35#ifdef USE_I2C
36# include "i2c.h"
37#else // USE_SERIAL
38# include "serial.h"
39#endif
40
41#ifndef DEBOUNCING_DELAY
42# define DEBOUNCING_DELAY 5
43#endif
44
45#if (DEBOUNCING_DELAY > 0)
46 static uint16_t debouncing_time;
47 static bool debouncing = false;
48#endif
49
50#if (MATRIX_COLS <= 8)
51# define print_matrix_header() print("\nr/c 01234567\n")
52# define print_matrix_row(row) print_bin_reverse8(matrix_get_row(row))
53# define matrix_bitpop(i) bitpop(matrix[i])
54# define ROW_SHIFTER ((uint8_t)1)
55#else
56# error "Currently only supports 8 COLS"
57#endif
58static matrix_row_t matrix_debouncing[MATRIX_ROWS];
59
60#define ERROR_DISCONNECT_COUNT 5
61
62#define SERIAL_LED_ADDR 0x00
63
64#define ROWS_PER_HAND (MATRIX_ROWS/2)
65
66static uint8_t error_count = 0;
67
68static const uint8_t row_pins[MATRIX_ROWS] = MATRIX_ROW_PINS;
69static const uint8_t col_pins[MATRIX_COLS] = MATRIX_COL_PINS;
70
71/* matrix state(1:on, 0:off) */
72static matrix_row_t matrix[MATRIX_ROWS];
73static matrix_row_t matrix_debouncing[MATRIX_ROWS];
74
75#if (DIODE_DIRECTION == COL2ROW)
76 static void init_cols(void);
77 static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row);
78 static void unselect_rows(void);
79 static void select_row(uint8_t row);
80 static void unselect_row(uint8_t row);
81#elif (DIODE_DIRECTION == ROW2COL)
82 static void init_rows(void);
83 static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col);
84 static void unselect_cols(void);
85 static void unselect_col(uint8_t col);
86 static void select_col(uint8_t col);
87#endif
88__attribute__ ((weak))
89void matrix_init_quantum(void) {
90 matrix_init_kb();
91}
92
93__attribute__ ((weak))
94void matrix_scan_quantum(void) {
95 matrix_scan_kb();
96}
97
98__attribute__ ((weak))
99void matrix_init_kb(void) {
100 matrix_init_user();
101}
102
103__attribute__ ((weak))
104void matrix_scan_kb(void) {
105 matrix_scan_user();
106}
107
108__attribute__ ((weak))
109void matrix_init_user(void) {
110}
111
112__attribute__ ((weak))
113void matrix_scan_user(void) {
114}
115
116inline
117uint8_t matrix_rows(void)
118{
119 return MATRIX_ROWS;
120}
121
122inline
123uint8_t matrix_cols(void)
124{
125 return MATRIX_COLS;
126}
127
128void matrix_init(void)
129{
130 debug_enable = true;
131 debug_matrix = true;
132 debug_mouse = true;
133 // initialize row and col
134 unselect_rows();
135 init_cols();
136
137 TX_RX_LED_INIT;
138
139 // initialize matrix state: all keys off
140 for (uint8_t i=0; i < MATRIX_ROWS; i++) {
141 matrix[i] = 0;
142 matrix_debouncing[i] = 0;
143 }
144
145 matrix_init_quantum();
146
147}
148
149uint8_t _matrix_scan(void)
150{
151 int offset = isLeftHand ? 0 : (ROWS_PER_HAND);
152#if (DIODE_DIRECTION == COL2ROW)
153 // Set row, read cols
154 for (uint8_t current_row = 0; current_row < ROWS_PER_HAND; current_row++) {
155# if (DEBOUNCING_DELAY > 0)
156 bool matrix_changed = read_cols_on_row(matrix_debouncing+offset, current_row);
157
158 if (matrix_changed) {
159 debouncing = true;
160 debouncing_time = timer_read();
161 PORTD ^= (1 << 2);
162 }
163
164# else
165 read_cols_on_row(matrix+offset, current_row);
166# endif
167
168 }
169
170#elif (DIODE_DIRECTION == ROW2COL)
171 // Set col, read rows
172 for (uint8_t current_col = 0; current_col < MATRIX_COLS; current_col++) {
173# if (DEBOUNCING_DELAY > 0)
174 bool matrix_changed = read_rows_on_col(matrix_debouncing+offset, current_col);
175 if (matrix_changed) {
176 debouncing = true;
177 debouncing_time = timer_read();
178 }
179# else
180 read_rows_on_col(matrix+offset, current_col);
181# endif
182
183 }
184#endif
185
186# if (DEBOUNCING_DELAY > 0)
187 if (debouncing && (timer_elapsed(debouncing_time) > DEBOUNCING_DELAY)) {
188 for (uint8_t i = 0; i < ROWS_PER_HAND; i++) {
189 matrix[i+offset] = matrix_debouncing[i+offset];
190 }
191 debouncing = false;
192 }
193# endif
194
195 return 1;
196}
197
198#ifdef USE_I2C
199
200// Get rows from other half over i2c
201int i2c_transaction(void) {
202 int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
203
204 int err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_WRITE);
205 if (err) goto i2c_error;
206
207 // start of matrix stored at 0x00
208 err = i2c_master_write(0x00);
209 if (err) goto i2c_error;
210
211 // Start read
212 err = i2c_master_start(SLAVE_I2C_ADDRESS + I2C_READ);
213 if (err) goto i2c_error;
214
215 if (!err) {
216 int i;
217 for (i = 0; i < ROWS_PER_HAND-1; ++i) {
218 matrix[slaveOffset+i] = i2c_master_read(I2C_ACK);
219 }
220 matrix[slaveOffset+i] = i2c_master_read(I2C_NACK);
221 i2c_master_stop();
222 } else {
223i2c_error: // the cable is disconnceted, or something else went wrong
224 i2c_reset_state();
225 return err;
226 }
227
228 return 0;
229}
230
231#else // USE_SERIAL
232
233int serial_transaction(void) {
234 int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
235
236 if (serial_update_buffers()) {
237 return 1;
238 }
239
240 for (int i = 0; i < ROWS_PER_HAND; ++i) {
241 matrix[slaveOffset+i] = serial_slave_buffer[i];
242 }
243
244#ifdef BACKLIGHT_ENABLE
245 // Write backlight level for slave to read
246 serial_master_buffer[SERIAL_LED_ADDR] = get_backlight_level();
247#endif
248 return 0;
249}
250#endif
251
252uint8_t matrix_scan(void)
253{
254 uint8_t ret = _matrix_scan();
255
256#ifdef USE_I2C
257 if( i2c_transaction() ) {
258#else // USE_SERIAL
259 if( serial_transaction() ) {
260#endif
261 // turn on the indicator led when halves are disconnected
262 TXLED1;
263
264 error_count++;
265
266 if (error_count > ERROR_DISCONNECT_COUNT) {
267 // reset other half if disconnected
268 int slaveOffset = (isLeftHand) ? (ROWS_PER_HAND) : 0;
269 for (int i = 0; i < ROWS_PER_HAND; ++i) {
270 matrix[slaveOffset+i] = 0;
271 }
272 }
273 } else {
274 // turn off the indicator led on no error
275 TXLED0;
276 error_count = 0;
277 }
278 matrix_scan_quantum();
279 return ret;
280}
281
282void matrix_slave_scan(void) {
283 _matrix_scan();
284
285 int offset = (isLeftHand) ? 0 : ROWS_PER_HAND;
286
287#ifdef USE_I2C
288 for (int i = 0; i < ROWS_PER_HAND; ++i) {
289 i2c_slave_buffer[i] = matrix[offset+i];
290 }
291#else // USE_SERIAL
292 for (int i = 0; i < ROWS_PER_HAND; ++i) {
293 serial_slave_buffer[i] = matrix[offset+i];
294 }
295
296#ifdef BACKLIGHT_ENABLE
297 // Read backlight level sent from master and update level on slave
298 backlight_set(serial_master_buffer[SERIAL_LED_ADDR]);
299#endif
300#endif
301}
302
303bool matrix_is_modified(void)
304{
305 if (debouncing) return false;
306 return true;
307}
308
309inline
310bool matrix_is_on(uint8_t row, uint8_t col)
311{
312 return (matrix[row] & ((matrix_row_t)1<<col));
313}
314
315inline
316matrix_row_t matrix_get_row(uint8_t row)
317{
318 return matrix[row];
319}
320
321void matrix_print(void)
322{
323 print("\nr/c 0123456789ABCDEF\n");
324 for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
325 phex(row); print(": ");
326 pbin_reverse16(matrix_get_row(row));
327 print("\n");
328 }
329}
330
331uint8_t matrix_key_count(void)
332{
333 uint8_t count = 0;
334 for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
335 count += bitpop16(matrix[i]);
336 }
337 return count;
338}
339
340#if (DIODE_DIRECTION == COL2ROW)
341
342static void init_cols(void)
343{
344 for(uint8_t x = 0; x < MATRIX_COLS; x++) {
345 uint8_t pin = col_pins[x];
346 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
347 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
348 }
349}
350
351static bool read_cols_on_row(matrix_row_t current_matrix[], uint8_t current_row)
352{
353 // Store last value of row prior to reading
354 matrix_row_t last_row_value = current_matrix[current_row];
355
356 // Clear data in matrix row
357 current_matrix[current_row] = 0;
358
359 // Select row and wait for row selecton to stabilize
360 select_row(current_row);
361 wait_us(30);
362
363 // For each col...
364 for(uint8_t col_index = 0; col_index < MATRIX_COLS; col_index++) {
365
366 // Select the col pin to read (active low)
367 uint8_t pin = col_pins[col_index];
368 uint8_t pin_state = (_SFR_IO8(pin >> 4) & _BV(pin & 0xF));
369
370 // Populate the matrix row with the state of the col pin
371 current_matrix[current_row] |= pin_state ? 0 : (ROW_SHIFTER << col_index);
372 }
373
374 // Unselect row
375 unselect_row(current_row);
376
377 return (last_row_value != current_matrix[current_row]);
378}
379
380static void select_row(uint8_t row)
381{
382 uint8_t pin = row_pins[row];
383 _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
384 _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
385}
386
387static void unselect_row(uint8_t row)
388{
389 uint8_t pin = row_pins[row];
390 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
391 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
392}
393
394static void unselect_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
403#elif (DIODE_DIRECTION == ROW2COL)
404
405static void init_rows(void)
406{
407 for(uint8_t x = 0; x < ROWS_PER_HAND; x++) {
408 uint8_t pin = row_pins[x];
409 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
410 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
411 }
412}
413
414static bool read_rows_on_col(matrix_row_t current_matrix[], uint8_t current_col)
415{
416 bool matrix_changed = false;
417
418 // Select col and wait for col selecton to stabilize
419 select_col(current_col);
420 wait_us(30);
421
422 // For each row...
423 for(uint8_t row_index = 0; row_index < ROWS_PER_HAND; row_index++)
424 {
425
426 // Store last value of row prior to reading
427 matrix_row_t last_row_value = current_matrix[row_index];
428
429 // Check row pin state
430 if ((_SFR_IO8(row_pins[row_index] >> 4) & _BV(row_pins[row_index] & 0xF)) == 0)
431 {
432 // Pin LO, set col bit
433 current_matrix[row_index] |= (ROW_SHIFTER << current_col);
434 }
435 else
436 {
437 // Pin HI, clear col bit
438 current_matrix[row_index] &= ~(ROW_SHIFTER << current_col);
439 }
440
441 // Determine if the matrix changed state
442 if ((last_row_value != current_matrix[row_index]) && !(matrix_changed))
443 {
444 matrix_changed = true;
445 }
446 }
447
448 // Unselect col
449 unselect_col(current_col);
450
451 return matrix_changed;
452}
453
454static void select_col(uint8_t col)
455{
456 uint8_t pin = col_pins[col];
457 _SFR_IO8((pin >> 4) + 1) |= _BV(pin & 0xF); // OUT
458 _SFR_IO8((pin >> 4) + 2) &= ~_BV(pin & 0xF); // LOW
459}
460
461static void unselect_col(uint8_t col)
462{
463 uint8_t pin = col_pins[col];
464 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
465 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
466}
467
468static void unselect_cols(void)
469{
470 for(uint8_t x = 0; x < MATRIX_COLS; x++) {
471 uint8_t pin = col_pins[x];
472 _SFR_IO8((pin >> 4) + 1) &= ~_BV(pin & 0xF); // IN
473 _SFR_IO8((pin >> 4) + 2) |= _BV(pin & 0xF); // HI
474 }
475}
476
477#endif
diff --git a/keyboards/levinson/readme.md b/keyboards/levinson/readme.md
new file mode 100644
index 000000000..1fcad3c1b
--- /dev/null
+++ b/keyboards/levinson/readme.md
@@ -0,0 +1,20 @@
1Levinson
2========
3
4A split 40% split 4x12 ortholinear keyboard made and sold by Keebio. It's essentially a Let's Split with LED backlight support and 2u thumb key support. [More info at Keebio](https://keeb.io).
5
6Keyboard Maintainer: [Bakingpy/nooges](https://github.com/nooges)
7Hardware Supported: Pro Micro
8Hardware Availability: [Keebio](https://keeb.io)
9
10Make example for this keyboard (after setting up your build environment):
11
12 make levinson-rev1-default
13
14Example of flashing this keyboard:
15
16 make levinson-rev1-default-avrdude
17
18See [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.
19
20A build guide for this keyboard can be found here: [Nyquist Build Guide](https://docs.keeb.io)
diff --git a/keyboards/levinson/rev1/config.h b/keyboards/levinson/rev1/config.h
new file mode 100644
index 000000000..696722cfb
--- /dev/null
+++ b/keyboards/levinson/rev1/config.h
@@ -0,0 +1,88 @@
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 REV1_CONFIG_H
20#define REV1_CONFIG_H
21
22#include "../config.h"
23
24/* USB Device descriptor parameter */
25#define VENDOR_ID 0xCEEB
26#define PRODUCT_ID 0x1146
27#define DEVICE_VER 0x0100
28#define MANUFACTURER Keebio
29#define PRODUCT Levinson
30#define DESCRIPTION Split 40 percent ortholinear keyboard
31
32/* key matrix size */
33// Rows are doubled-up
34#define MATRIX_ROWS 8
35#define MATRIX_COLS 6
36
37// wiring of each half
38#define MATRIX_ROW_PINS { D7, E6, B4, B5 }
39#define MATRIX_COL_PINS { F6, F7, B1, B3, B2, F4 }
40
41#define CATERINA_BOOTLOADER
42
43/* define if matrix has ghost */
44//#define MATRIX_HAS_GHOST
45
46/* number of backlight levels */
47#define BACKLIGHT_LEVELS 7
48
49/* Set 0 if debouncing isn't needed */
50#define DEBOUNCING_DELAY 5
51
52/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */
53#define LOCKING_SUPPORT_ENABLE
54/* Locking resynchronize hack */
55#define LOCKING_RESYNC_ENABLE
56
57/* key combination for command */
58#define IS_COMMAND() ( \
59 keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \
60)
61
62/* ws2812 RGB LED */
63#define RGB_DI_PIN D3
64#define RGBLIGHT_TIMER
65#define RGBLED_NUM 12 // Number of LEDs
66#define ws2812_PORTREG PORTD
67#define ws2812_DDRREG DDRD
68
69/*
70 * Feature disable options
71 * These options are also useful to firmware size reduction.
72 */
73
74/* disable debug print */
75// #define NO_DEBUG
76
77/* disable print */
78// #define NO_PRINT
79
80/* disable action features */
81//#define NO_ACTION_LAYER
82//#define NO_ACTION_TAPPING
83//#define NO_ACTION_ONESHOT
84//#define NO_ACTION_MACRO
85//#define NO_ACTION_FUNCTION
86
87
88#endif
diff --git a/keyboards/levinson/rev1/rev1.c b/keyboards/levinson/rev1/rev1.c
new file mode 100644
index 000000000..f849b5c4e
--- /dev/null
+++ b/keyboards/levinson/rev1/rev1.c
@@ -0,0 +1,39 @@
1#include "levinson.h"
2
3#ifdef AUDIO_ENABLE
4 float tone_startup[][2] = SONG(STARTUP_SOUND);
5 float tone_goodbye[][2] = SONG(GOODBYE_SOUND);
6#endif
7
8#ifdef SSD1306OLED
9void led_set_kb(uint8_t usb_led) {
10 // put your keyboard LED indicator (ex: Caps Lock LED) toggling code here
11 led_set_user(usb_led);
12}
13#endif
14
15void matrix_init_kb(void) {
16
17 #ifdef AUDIO_ENABLE
18 _delay_ms(20); // gets rid of tick
19 PLAY_SONG(tone_startup);
20 #endif
21
22 // // green led on
23 // DDRD |= (1<<5);
24 // PORTD &= ~(1<<5);
25
26 // // orange led on
27 // DDRB |= (1<<0);
28 // PORTB &= ~(1<<0);
29
30 matrix_init_user();
31};
32
33void shutdown_user(void) {
34 #ifdef AUDIO_ENABLE
35 PLAY_SONG(tone_goodbye);
36 _delay_ms(150);
37 stop_all_notes();
38 #endif
39}
diff --git a/keyboards/levinson/rev1/rev1.h b/keyboards/levinson/rev1/rev1.h
new file mode 100644
index 000000000..968095cba
--- /dev/null
+++ b/keyboards/levinson/rev1/rev1.h
@@ -0,0 +1,60 @@
1#ifndef REV2_H
2#define REV2_H
3
4#include "../levinson.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// Standard Keymap
22// (TRRS jack on the left half is to the right, TRRS jack on the right half is to the left)
23#define KEYMAP( \
24 L00, L01, L02, L03, L04, L05, R00, R01, R02, R03, R04, R05, \
25 L10, L11, L12, L13, L14, L15, R10, R11, R12, R13, R14, R15, \
26 L20, L21, L22, L23, L24, L25, R20, R21, R22, R23, R24, R25, \
27 L30, L31, L32, L33, L34, L35, R30, R31, R32, R33, R34, R35 \
28 ) \
29 { \
30 { L00, L01, L02, L03, L04, L05 }, \
31 { L10, L11, L12, L13, L14, L15 }, \
32 { L20, L21, L22, L23, L24, L25 }, \
33 { L30, L31, L32, L33, L34, L35 }, \
34 { R05, R04, R03, R02, R01, R00 }, \
35 { R15, R14, R13, R12, R11, R10 }, \
36 { R25, R24, R23, R22, R21, R20 }, \
37 { R35, R34, R33, R32, R31, R30 } \
38 }
39#else
40// Keymap with right side flipped
41// (TRRS jack on both halves are to the right)
42#define KEYMAP( \
43 L00, L01, L02, L03, L04, L05, R00, R01, R02, R03, R04, R05, \
44 L10, L11, L12, L13, L14, L15, R10, R11, R12, R13, R14, R15, \
45 L20, L21, L22, L23, L24, L25, R20, R21, R22, R23, R24, R25, \
46 L30, L31, L32, L33, L34, L35, R30, R31, R32, R33, R34, R35 \
47 ) \
48 { \
49 { L00, L01, L02, L03, L04, L05 }, \
50 { L10, L11, L12, L13, L14, L15 }, \
51 { L20, L21, L22, L23, L24, L25 }, \
52 { L30, L31, L32, L33, L34, L35 }, \
53 { R00, R01, R02, R03, R04, R05 }, \
54 { R10, R11, R12, R13, R14, R15 }, \
55 { R20, R21, R22, R23, R24, R25 }, \
56 { R30, R31, R32, R33, R34, R35 } \
57 }
58#endif
59
60#endif
diff --git a/keyboards/levinson/rev1/rules.mk b/keyboards/levinson/rev1/rules.mk
new file mode 100644
index 000000000..bd518d8f2
--- /dev/null
+++ b/keyboards/levinson/rev1/rules.mk
@@ -0,0 +1 @@
BACKLIGHT_ENABLE = yes
diff --git a/keyboards/levinson/rules.mk b/keyboards/levinson/rules.mk
new file mode 100644
index 000000000..7b7224fd4
--- /dev/null
+++ b/keyboards/levinson/rules.mk
@@ -0,0 +1,78 @@
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# Interrupt driven control endpoint task(+60)
44OPT_DEFS += -DINTERRUPT_CONTROL_ENDPOINT
45
46
47# Boot Section Size in *bytes*
48# Teensy halfKay 512
49# Teensy++ halfKay 1024
50# Atmel DFU loader 4096
51# LUFA bootloader 4096
52# USBaspLoader 2048
53OPT_DEFS += -DBOOTLOADER_SIZE=4096
54
55# Build Options
56# change to "no" to disable the options, or define them in the Makefile in
57# the appropriate keymap folder that will get included automatically
58#
59BOOTMAGIC_ENABLE = no # Virtual DIP switch configuration(+1000)
60MOUSEKEY_ENABLE = yes # Mouse keys(+4700)
61EXTRAKEY_ENABLE = yes # Audio control and System control(+450)
62CONSOLE_ENABLE = no # Console for debug(+400)
63COMMAND_ENABLE = yes # Commands for debug and configuration
64NKRO_ENABLE = no # Nkey Rollover - if this doesn't work, see here: https://github.com/tmk/tmk_keyboard/wiki/FAQ#nkro-doesnt-work
65BACKLIGHT_ENABLE = no # Enable keyboard backlight functionality
66MIDI_ENABLE = no # MIDI controls
67AUDIO_ENABLE = no # Audio output on port C6
68UNICODE_ENABLE = no # Unicode
69BLUETOOTH_ENABLE = no # Enable Bluetooth with the Adafruit EZ-Key HID
70RGBLIGHT_ENABLE = no # Enable WS2812 RGB underlight. Do not enable this with audio at the same time.
71SUBPROJECT_rev1 = yes
72USE_I2C = yes
73# Do not enable SLEEP_LED_ENABLE. it uses the same timer as BACKLIGHT_ENABLE
74SLEEP_LED_ENABLE = no # Breathing sleep LED during USB suspend
75
76CUSTOM_MATRIX = yes
77
78LAYOUTS = ortho_4x12 \ No newline at end of file
diff --git a/keyboards/levinson/serial.c b/keyboards/levinson/serial.c
new file mode 100644
index 000000000..74bcbb6bf
--- /dev/null
+++ b/keyboards/levinson/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/levinson/serial.h b/keyboards/levinson/serial.h
new file mode 100644
index 000000000..15fe4db7b
--- /dev/null
+++ b/keyboards/levinson/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/levinson/split_util.c b/keyboards/levinson/split_util.c
new file mode 100644
index 000000000..7f200e6c9
--- /dev/null
+++ b/keyboards/levinson/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/levinson/split_util.h b/keyboards/levinson/split_util.h
new file mode 100644
index 000000000..595a0659e
--- /dev/null
+++ b/keyboards/levinson/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
diff --git a/keyboards/levinson/subproject.mk b/keyboards/levinson/subproject.mk
new file mode 100644
index 000000000..928b1edd0
--- /dev/null
+++ b/keyboards/levinson/subproject.mk
@@ -0,0 +1 @@
SUBPROJECT_DEFAULT = rev1
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-12 10:25:27 +0000