mirrors/opensteno_qmk
1
0
Fork 0
mirror of https://github.com/openstenoproject/qmk synced 2024-11-10 18:49:08 +00:00
Code Issues Projects Releases Packages Wiki Activity

perform nomal keyboard behavior. It works now!!!

Browse source
This commit is contained in:
tmk 2010-08-23 15:46:24 +09:00
parent c17f07819f
commit 3b31337cd8
9 changed files with 327 additions and 201 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Makefile
View file

@ -47,6 +47,7 @@ TARGET = mykey
# List C source files here. (C dependencies are automatically generated.) # List C source files here. (C dependencies are automatically generated.)
SRC = $(TARGET).c \ SRC = $(TARGET).c \
keymap.c \ keymap.c \
matrix.c \
usb_keyboard_debug.c \ usb_keyboard_debug.c \
print.c print.c

60
README Normal file
View file

@ -0,0 +1,60 @@
Keyboard Firmware
=================
2010/08/23 noname
VERSION
-------
0.1 2010/08/23
implemented for macway modified.
It works as normal keyboard now.
TODO
----
modulization
clean source
debouncing
anti-ghost
keymap layer
key combination switch
toggle siwtch
HHKB like cursor etc.
setting menu(wizard)
debug console
keymap setting
matrix display
HHKB support
Trackpoint(PS/2) support
Thinkpad keyboard support
target board
------------
Teensy 2.0
http://www.pjrc.com/teensy
projects based on/related to
----------------------------
PJRC USB Keyboard Example
http://www.pjrc.com/teensy/usb_keyboard.html
kbupgrade
http://github.com/rhomann/kbupgrade
http://geekhack.org/showwiki.php?title=Island:8406
c64key
http://symlink.dk/projects/c64key/
rump
http://mg8.org/rump/
http://github.com/clee/rump
dulcimer
http://www.schatenseite.de/dulcimer.html
humblehacker-keyboard
http://github.com/humblehacker
http://www.humblehacker.com/keyboard/
http://geekhack.org/showwiki.php?title=Island:6292
ps2avr
http://sourceforge.net/projects/ps2avr/
EOF

27
keymap.c
View file

@ -1,28 +1,27 @@
/* /*
* keymap for modified macway keyboard * keymap for modified macway keyboarq
*/ */
#include <avr/pgmspace.h> #include <avr/pgmspace.h>
#include "keymap.h" #include "keymap.h"
#define MATRIX_ROWS 9 static const uint8_t PROGMEM Keymap[MATRIX_ROWS][MATRIX_COLS] = {
#define MATRIX_COLS 8 { KB_LALT, KB_NO, KB_BSPACE, KB_NO, KB_LEFT, KB_NO, KB_ENTER, KB_SPACE },
{ KB_1, KB_ESCAPE, KB_TAB, KB_Q, KB_A, KB_LCTRL, KB_Z, KB_RIGHT },
static const uint8_t PROGMEM Keymap[MATRIX_COLS][MATRIX_ROWS] = { { KB_2, KB_RALT, KB_LGUI, KB_W, KB_S, KB_NO, KB_X, KB_UP },
{ KB_LALT, KB_1, KB_2, KB_3, KB_4, KB_7, KB_8, KB_9, KB_0 }, { KB_3, KB_NO, KB_RSHIFT, KB_E, KB_D, KB_BSLASH, KB_C, KB_DOWN },
{ KB_NO, KB_ESCAPE, KB_RALT, KB_NO, KB_5, KB_6, KB_EQUAL, KB_NO, KB_MINUS }, { KB_4, KB_5, KB_T, KB_R, KB_F, KB_G, KB_V, KB_B },
{ KB_BSPACE, KB_TAB, KB_LGUI, KB_RSHIFT, KB_T, KB_Y, KB_RBRACKET, KB_NO, KB_LBRACKET }, { KB_7, KB_6, KB_Y, KB_U, KB_J, KB_H, KB_M, KB_N },
{ KB_NO, KB_Q, KB_W, KB_E, KB_R, KB_U, KB_I, KB_O, KB_P }, { KB_8, KB_EQUAL, KB_RBRACKET, KB_I, KB_K, KB_NO, KB_COMMA, KB_LSHIFT },
{ KB_BSLASH, KB_A, KB_S, KB_D, KB_F, KB_J, KB_K, KB_L, KB_SCOLON }, { KB_9, KB_NO, KB_NO, KB_O, KB_L, KB_GRAVE, KB_DOT, KB_NO },
{ KB_NO, KB_LCTRL, KB_NO, KB_UP, KB_G, KB_H, KB_NO, KB_GRAVE, KB_QUOTE }, { KB_0, KB_MINUS, KB_LBRACKET, KB_P, KB_SCOLON, KB_QUOTE, KB_NO, KB_SLASH }
{ KB_ENTER, KB_Z, KB_X, KB_C, KB_V, KB_M, KB_COMMA, KB_DOWN, KB_NO },
{ KB_SPACE, KB_DOWN, KB_RIGHT, KB_LEFT, KB_B, KB_N, KB_LSHIFT, KB_NO, KB_SLASH }
}; };
uint8_t get_keycode(uint8_t row, uint8_t col) uint8_t get_keycode(uint8_t row, uint8_t col)
{ {
if (row >= MATRIX_ROWS) if (row >= MATRIX_ROWS)
return KB_NO; return KB_NO;
if (col >= MATRIX_COLS) if (col >= MATRIX_COLS)
return KB_NO; return KB_NO;
return pgm_read_byte(&Keymap[col][row]); return pgm_read_byte(&Keymap[row][col]);
} }

3
keymap.h
View file

@ -6,4 +6,7 @@
uint8_t get_keycode(uint8_t row, uint8_t col); uint8_t get_keycode(uint8_t row, uint8_t col);
#define MATRIX_ROWS 9
#define MATRIX_COLS 8
#endif #endif

144
matrix.c Normal file
View file

@ -0,0 +1,144 @@
/*
* scan matrix
*/
#include <avr/io.h>
#include <util/delay.h>
#include "keymap.h"
#include "matrix.h"
#include "print.h"
uint8_t *matrix;
uint8_t *prev_matrix;
static uint8_t _matrix0[MATRIX_ROWS];
static uint8_t _matrix1[MATRIX_ROWS];
static uint8_t read_col(void);
static void select_row(uint8_t row);
void matrix_init(void)
{
// Column: input w/pullup
DDRB = 0x00;
PORTB = 0xFF;
// Row: Hi-Z(unselected)
// PD:0,1,2,3,6,7
// PC:6,7
// PF:7
DDRD = 0x00;
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
for (int i=0; i < MATRIX_ROWS; i++) {
_matrix0[i] = 0xFF;
_matrix1[i] = 0xFF;
}
matrix = _matrix0;
prev_matrix = _matrix1;
}
uint8_t matrix_scan(void)
{
uint8_t row, state;
uint8_t *tmp;
tmp = prev_matrix;
prev_matrix = matrix;
matrix = tmp;
for (row = 0; row < MATRIX_ROWS; row++) {
select_row(row);
_delay_us(30); // without this wait read unstable value.
state = read_col();
matrix[row] = state;
}
return 1;
}
static uint8_t read_col(void)
{
return PINB;
}
static void select_row(uint8_t row)
{
switch (row) {
case 0:
DDRD = (1<<0);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 1:
DDRD = (1<<1);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 2:
DDRD = (1<<2);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 3:
DDRD = (1<<3);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 4:
DDRD = (1<<6);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 5:
DDRD = (1<<7);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 6:
DDRD = 0x00;
PORTD = 0x00;
DDRC = (1<<6);
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 7:
DDRD = 0x00;
PORTD = 0x00;
DDRC = (1<<7);
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 8:
DDRD = 0x00;
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = (1<<7);
PORTF = 0x00;
break;
}
}

6
matrix.h Normal file
View file

@ -0,0 +1,6 @@
extern uint8_t *matrix;
extern uint8_t *prev_matrix;
void matrix_init(void);
uint8_t matrix_scan(void);

277
mykey.c
View file

@ -1,3 +1,6 @@
/* 2010/08/23 noname
* keyboard firmware based on PJRC USB keyboard example
*/
/* Keyboard example with debug channel, for Teensy USB Development Board /* Keyboard example with debug channel, for Teensy USB Development Board
* http://www.pjrc.com/teensy/usb_keyboard.html * http://www.pjrc.com/teensy/usb_keyboard.html
* Copyright (c) 2008 PJRC.COM, LLC * Copyright (c) 2008 PJRC.COM, LLC
@ -27,211 +30,115 @@
#include <util/delay.h> #include <util/delay.h>
#include "usb_keyboard_debug.h" #include "usb_keyboard_debug.h"
#include "print.h" #include "print.h"
#include "matrix.h"
#include "keymap.h" #include "keymap.h"
#define LED_CONFIG (DDRD |= (1<<6)) #define LED_CONFIG (DDRD |= (1<<6))
#define LED_ON (PORTD &= ~(1<<6)) #define LED_ON (PORTD &= ~(1<<6))
#define LED_OFF (PORTD |= (1<<6)) #define LED_OFF (PORTD |= (1<<6))
#define CPU_PRESCALE(n) (CLKPR = 0x80, CLKPR = (n)) #define CPU_PRESCALE(n) (CLKPR = 0x80, CLKPR = (n))
uint8_t number_keys[10]=
{KEY_0,KEY_1,KEY_2,KEY_3,KEY_4,KEY_5,KEY_6,KEY_7,KEY_8,KEY_9};
uint16_t idle_count=0; uint16_t idle_count=0;
//
// scan matrix
//
uint8_t MAX_ROW = 9;
// initialize ports for matrix
void port_setup(void)
{
// Column: input w/pullup
DDRB = 0x00;
PORTB = 0xFF;
// Row: Hi-Z(unselected)
// PD:0,1,2,3,6,7
// PC:6,7
// PF:7
DDRD = 0x00;
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
}
// select a row of matrix for read
void select_row(uint8_t row)
{
switch (row) {
case 0:
DDRD = (1<<0);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 1:
DDRD = (1<<1);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 2:
DDRD = (1<<2);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 3:
DDRD = (1<<3);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 4:
DDRD = (1<<6);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 5:
DDRD = (1<<7);
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 6:
DDRD = 0x00;
PORTD = 0x00;
DDRC = (1<<6);
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 7:
DDRD = 0x00;
PORTD = 0x00;
DDRC = (1<<7);
PORTC = 0x00;
DDRF = 0x00;
PORTF = 0x00;
break;
case 8:
DDRD = 0x00;
PORTD = 0x00;
DDRC = 0x00;
PORTC = 0x00;
DDRF = (1<<7);
PORTF = 0x00;
break;
}
}
uint8_t read_col(void)
{
return PINB;
}
int main(void) int main(void)
{ {
uint8_t i, reset_idle; uint8_t modified = 0;
uint8_t prev_state[MAX_ROW]; uint8_t key_index = 0;
for (int i=0; i < MAX_ROW; i++) prev_state[i] = 0xFF;
// set for 16 MHz clock // set for 16 MHz clock
CPU_PRESCALE(0); CPU_PRESCALE(0);
port_setup(); matrix_init();
// Initialize the USB, and then wait for the host to set configuration. // Initialize the USB, and then wait for the host to set configuration.
// If the Teensy is powered without a PC connected to the USB port, // If the Teensy is powered without a PC connected to the USB port,
// this will wait forever. // this will wait forever.
usb_init(); usb_init();
while (!usb_configured()) /* wait */ ; while (!usb_configured()) /* wait */ ;
// Wait an extra second for the PC's operating system to load drivers // Wait an extra second for the PC's operating system to load drivers
// and do whatever it does to actually be ready for input // and do whatever it does to actually be ready for input
_delay_ms(1000); _delay_ms(1000);
// Configure timer 0 to generate a timer overflow interrupt every // Configure timer 0 to generate a timer overflow interrupt every
// 256*1024 clock cycles, or approx 61 Hz when using 16 MHz clock // 256*1024 clock cycles, or approx 61 Hz when using 16 MHz clock
// This demonstrates how to use interrupts to implement a simple // This demonstrates how to use interrupts to implement a simple
// inactivity timeout. // inactivity timeout.
TCCR0A = 0x00; TCCR0A = 0x00;
TCCR0B = 0x05; TCCR0B = 0x05;
TIMSK0 = (1<<TOIE0); TIMSK0 = (1<<TOIE0);
print("Begin keyboard example program\n"); print("keyboard firmware 0.1 for t.m.k.\n");
print("All Port B or Port D pins are inputs with pullup resistors.\n");
print("Any connection to ground on Port B or D pins will result in\n");
print("keystrokes sent to the PC (and debug messages here).\n");
uint8_t col; while (1) {
uint8_t code; uint8_t row, col, code;
while (1) {
reset_idle = 0;
for (uint8_t r=0; r < MAX_ROW; r++) { modified = 0;
select_row(r);
// without this read unstable value. matrix_scan();
_delay_us(30);
col = read_col(); keyboard_modifier_keys = 0;
if (col != prev_state[r]) { for (int i = 0; i < 6; i++)
prev_state[r] = col; keyboard_keys[i] = KB_NO;
phex(r); key_index = 0;
print(": ");
pbin(col);
print("\n");
for (int c = 0; c < 8; c++) { for (row = 0; row < MATRIX_ROWS; row++) {
if (col & 1<<c) continue; if (matrix[row] != prev_matrix[row]) {
code = get_keycode(r, c); modified = 1;
phex(code);
print("\n");
usb_keyboard_press(code, 0);
}
reset_idle = 1;
}
} }
for (col = 0; col < MATRIX_COLS; col++) {
if (matrix[row] & 1<<col) continue;
code = get_keycode(row, col);
// Modifier keycode: 0xE0-0xE7
if (KB_LCTRL <= code && code <= KB_RGUI) {
keyboard_modifier_keys |= 1<<(code&0x07);
} else {
if (key_index < 6) {
keyboard_keys[key_index] = code;
}
key_index++;
}
}
}
if (key_index > 6) {
//Rollover
}
// if any keypresses were detected, reset the idle counter // if any keypresses were detected, reset the idle counter
if (reset_idle) { if (modified) {
// variables shared with interrupt routines must be print(" 01234567\n");
// accessed carefully so the interrupt routine doesn't for (row = 0; row < MATRIX_ROWS; row++) {
// try to use the variable in the middle of our access phex(row); print(": "); pbin_reverse(matrix[row]); print("\n");
cli(); }
idle_count = 0; print("keys: ");
sei(); for (int i = 0; i < 6; i++) { phex(keyboard_keys[i]); print(" "); }
} print("\n");
print("mod: "); phex(keyboard_modifier_keys); print("\n");
usb_keyboard_send();
// now the current pins will be the previous, and // variables shared with interrupt routines must be
// wait a short delay so we're not highly sensitive // accessed carefully so the interrupt routine doesn't
// to mechanical "bounce". // try to use the variable in the middle of our access
_delay_ms(2); cli();
} idle_count = 0;
sei();
}
// now the current pins will be the previous, and
// wait a short delay so we're not highly sensitive
// to mechanical "bounce".
_delay_ms(2);
}
} }
// This interrupt routine is run approx 61 times per second. // This interrupt routine is run approx 61 times per second.
@ -240,12 +147,10 @@ int main(void)
// hid_listen debug message window. // hid_listen debug message window.
ISR(TIMER0_OVF_vect) ISR(TIMER0_OVF_vect)
{ {
idle_count++; idle_count++;
if (idle_count > 61 * 8) { if (idle_count > 61 * 8) {
idle_count = 0; idle_count = 0;
print("Timer Event :)\n"); //print("Timer Event :)\n");
//usb_keyboard_press(KEY_SPACE, 0); //usb_keyboard_press(KEY_SPACE, 0);
} }
} }

9
print.c
View file

@ -60,7 +60,14 @@ void phex16(unsigned int i)
void pbin(unsigned char c) void pbin(unsigned char c)
{ {
for (int i=7; i>=0; i--) { for (int i = 7; i >= 0; i--) {
usb_debug_putchar((c & (1<<i)) ? '1' : '0');
}
}
void pbin_reverse(unsigned char c)
{
for (int i = 0; i < 8; i++) {
usb_debug_putchar((c & (1<<i)) ? '1' : '0'); usb_debug_putchar((c & (1<<i)) ? '1' : '0');
} }
} }

1
print.h
View file

@ -13,5 +13,6 @@ void print_P(const char *s);
void phex(unsigned char c); void phex(unsigned char c);
void phex16(unsigned int i); void phex16(unsigned int i);
void pbin(unsigned char c); void pbin(unsigned char c);
void pbin_reverse(unsigned char c);
#endif #endif