Modifiled files for hand wired van 44 keyboard. Use the teensy_lc_onekey as a base
/* | |
Copyright 2015 Jun Wako <wakojun@gmail.com> | |
This program is free software: you can redistribute it and/or modify | |
it under the terms of the GNU General Public License as published by | |
the Free Software Foundation, either version 2 of the License, or | |
(at your option) any later version. | |
This program is distributed in the hope that it will be useful, | |
but WITHOUT ANY WARRANTY; without even the implied warranty of | |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
GNU General Public License for more details. | |
You should have received a copy of the GNU General Public License | |
along with this program. If not, see <http://www.gnu.org/licenses/>. | |
*/ | |
#ifndef CONFIG_H | |
#define CONFIG_H | |
/* USB Device descriptor parameter */ | |
#define VENDOR_ID 0xFEED | |
#define PRODUCT_ID 0x6464 | |
#define DEVICE_VER 0x0001 | |
/* in python2: list(u"whatever".encode('utf-16-le')) */ | |
/* at most 32 characters or the ugly hack in usb_main.c borks */ | |
#define MANUFACTURER "TMK" | |
#define USBSTR_MANUFACTURER 'T', '\x00', 'M', '\x00', 'K', '\x00', ' ', '\x00', '\xc6', '\x00' | |
#define PRODUCT "ChibiOS TMK test" | |
#define USBSTR_PRODUCT 'C', '\x00', 'h', '\x00', 'i', '\x00', 'b', '\x00', 'i', '\x00', 'O', '\x00', 'S', '\x00', ' ', '\x00', 'T', '\x00', 'M', '\x00', 'K', '\x00', ' ', '\x00', 't', '\x00', 'e', '\x00', 's', '\x00', 't', '\x00' | |
#define DESCRIPTION "TMK keyboard firmware over ChibiOS" | |
/* key matrix size */ | |
#define MATRIX_ROWS 4 | |
#define MATRIX_COLS 12 | |
/* define if matrix has ghost */ | |
//#define MATRIX_HAS_GHOST | |
/* Set 0 if debouncing isn't needed */ | |
#define DEBOUNCE 5 | |
/* Mechanical locking support. Use KC_LCAP, KC_LNUM or KC_LSCR instead in keymap */ | |
#define LOCKING_SUPPORT_ENABLE | |
/* Locking resynchronize hack */ | |
#define LOCKING_RESYNC_ENABLE | |
/* key combination for command */ | |
#define IS_COMMAND() ( \ | |
keyboard_report->mods == (MOD_BIT(KC_LSHIFT) | MOD_BIT(KC_RSHIFT)) \ | |
) | |
/* | |
* Feature disable options | |
* These options are also useful to firmware size reduction. | |
*/ | |
/* disable debug print */ | |
//#define NO_DEBUG | |
/* disable print */ | |
//#define NO_PRINT | |
/* disable action features */ | |
//#define NO_ACTION_LAYER | |
//#define NO_ACTION_TAPPING | |
//#define NO_ACTION_ONESHOT | |
//#define NO_ACTION_MACRO | |
//#define NO_ACTION_FUNCTION | |
#endif |
/* | |
Copyright 2012,2013 Jun Wako <wakojun@gmail.com> | |
This program is free software: you can redistribute it and/or modify | |
it under the terms of the GNU General Public License as published by | |
the Free Software Foundation, either version 2 of the License, or | |
(at your option) any later version. | |
This program is distributed in the hope that it will be useful, | |
but WITHOUT ANY WARRANTY; without even the implied warranty of | |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
GNU General Public License for more details. | |
You should have received a copy of the GNU General Public License | |
along with this program. If not, see <http://www.gnu.org/licenses/>. | |
*/ | |
#include "keymap_common.h" | |
/* translates key to keycode */ | |
uint8_t keymap_key_to_keycode(uint8_t layer, keypos_t key) | |
{ | |
return pgm_read_byte(&keymaps[(layer)][(key.row)][(key.col)]); | |
} | |
/* translates Fn keycode to action */ | |
action_t keymap_fn_to_action(uint8_t keycode) | |
{ | |
return (action_t){ .code = pgm_read_word(&fn_actions[FN_INDEX(keycode)]) }; | |
} |
/* | |
Copyright 2012,2013 Jun Wako <wakojun@gmail.com> | |
This program is free software: you can redistribute it and/or modify | |
it under the terms of the GNU General Public License as published by | |
the Free Software Foundation, either version 2 of the License, or | |
(at your option) any later version. | |
This program is distributed in the hope that it will be useful, | |
but WITHOUT ANY WARRANTY; without even the implied warranty of | |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
GNU General Public License for more details. | |
You should have received a copy of the GNU General Public License | |
along with this program. If not, see <http://www.gnu.org/licenses/>. | |
*/ | |
#ifndef KEYMAP_COMMON_H | |
#define KEYMAP_COMMON_H | |
#include <stdint.h> | |
#include <stdbool.h> | |
#include "keycode.h" | |
#include "action.h" | |
#include "action_macro.h" | |
#include "action_layer.h" | |
#include "report.h" | |
#include "host.h" | |
#include "print.h" | |
#include "debug.h" | |
#include "keymap.h" | |
extern const uint8_t keymaps[][MATRIX_ROWS][MATRIX_COLS]; | |
extern const uint16_t fn_actions[]; | |
/* TV44 keymap definition macro | |
*/ | |
#define KEYMAP( \ | |
K00, K01, K02, K03, K04, K05, K06, K07, K08, K09, K0A, K0B, \ | |
K10, K11, K12, K13, K14, K15, K16, K17, K18, K19, K1A, K1B, \ | |
K20, K21, K22, K23, K24, K25, K26, K27, K28, K29, K2A, K2B, \ | |
K30, K31, K32, K33, K37, K38, K39, K3B \ | |
) { \ | |
{ KC_##K00, KC_##K01, KC_##K02, KC_##K03, KC_##K04, KC_##K05, KC_##K06, KC_##K07, KC_##K08, KC_##K09, KC_##K0A, KC_##K0B }, \ | |
{ KC_##K10, KC_##K11, KC_##K12, KC_##K13, KC_##K14, KC_##K15, KC_##K16, KC_##K17, KC_##K18, KC_##K19, KC_##K1A, KC_##K1B }, \ | |
{ KC_##K20, KC_##K21, KC_##K22, KC_##K23, KC_##K24, KC_##K25, KC_##K26, KC_##K27, KC_##K28, KC_##K29, KC_##K2A, KC_##K2B }, \ | |
{ KC_##K30, KC_##K31, KC_##K32, KC_##K33, KC_NO, KC_NO, KC_NO, KC_##K37, KC_##K38, KC_##K39, KC_NO, KC_##K3B } \ | |
} | |
#endif |
#include "keymap_common.h" | |
const uint8_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = { | |
/* 0: qerty */ | |
KEYMAP(ESC, Q, W, E, R, T, Y, U, I, O, P, BSPC, \ | |
FN0, A, S, D, F, G, H, J, K, L, SCLN,QUOT, \ | |
LSFT, Z, X, C, V, B, N, M, COMM,DOT,SLSH,FN20, \ | |
LCTL, LGUI, LALT, FN1, FN2, RALT, APP, RCTL), | |
/* 1: FN 1 */ | |
KEYMAP(FN3, FN4, FN5, FN6, FN7, FN8, FN9,FN10,FN11,FN12,FN13, DEL, \ | |
TRNS, TRNS,TRNS,PAUS,TRNS,TRNS,TRNS,FN16,FN17,FN18,FN19,FN14, \ | |
TRNS, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, TRNS, \ | |
TRNS, TRNS, TRNS, TRNS, TRNS, MNXT, MUTE, MPLY), | |
/* 2: FN 2 */ | |
KEYMAP(GRV, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, DEL, \ | |
TRNS, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,MINS,EQL,LBRC,RBRC, BSLS, \ | |
TRNS, F11, F12, F13, F14, F15, F16, F17, F18,PGUP,F20, TRNS, \ | |
TRNS, TRNS, TRNS, TRNS, TRNS, HOME, PGDN, END), | |
/* 3: TAB */ | |
KEYMAP(TRNS, CALC,WHOM,MAIL,TRNS,MYCM,TRNS,TRNS,TRNS,TRNS,PSCR, DEL, \ | |
TRNS, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS, \ | |
TRNS, TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,TRNS,UP, TRNS,TRNS, \ | |
TRNS, TRNS, TRNS, TRNS, TRNS, LEFT, DOWN, RGHT), | |
}; | |
const uint16_t PROGMEM fn_actions[] = { | |
[0] = ACTION_LAYER_TAP_KEY(3, KC_TAB), | |
[1] = ACTION_LAYER_TAP_KEY(1, KC_SPC), | |
[2] = ACTION_LAYER_TAP_KEY(2, KC_SPC), | |
[3] = ACTION_MODS_KEY(MOD_LSFT, KC_GRV), | |
[4] = ACTION_MODS_KEY(MOD_LSFT, KC_1), | |
[5] = ACTION_MODS_KEY(MOD_LSFT, KC_2), | |
[6] = ACTION_MODS_KEY(MOD_LSFT, KC_3), | |
[7] = ACTION_MODS_KEY(MOD_LSFT, KC_4), | |
[8] = ACTION_MODS_KEY(MOD_LSFT, KC_5), | |
[9] = ACTION_MODS_KEY(MOD_LSFT, KC_6), | |
[10] = ACTION_MODS_KEY(MOD_LSFT, KC_7), | |
[11] = ACTION_MODS_KEY(MOD_LSFT, KC_8), | |
[12] = ACTION_MODS_KEY(MOD_LSFT, KC_9), | |
[13] = ACTION_MODS_KEY(MOD_LSFT, KC_0), | |
[14] = ACTION_MODS_KEY(MOD_LSFT, KC_BSLS), | |
[15] = ACTION_MODS_KEY(MOD_LSFT, KC_QUOT), | |
[16] = ACTION_MODS_KEY(MOD_LSFT, KC_MINS), | |
[17] = ACTION_MODS_KEY(MOD_LSFT, KC_EQL), | |
[18] = ACTION_MODS_KEY(MOD_LSFT, KC_LBRC), | |
[19] = ACTION_MODS_KEY(MOD_LSFT, KC_RBRC), | |
[20] = ACTION_MODS_TAP_KEY(MOD_RSFT, KC_ENT), | |
}; | |
/* | |
Copyright 2012 Jun Wako <wakojun@gmail.com> | |
This program is free software: you can redistribute it and/or modify | |
it under the terms of the GNU General Public License as published by | |
the Free Software Foundation, either version 2 of the License, or | |
(at your option) any later version. | |
This program is distributed in the hope that it will be useful, | |
but WITHOUT ANY WARRANTY; without even the implied warranty of | |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
GNU General Public License for more details. | |
You should have received a copy of the GNU General Public License | |
along with this program. If not, see <http://www.gnu.org/licenses/>. | |
*/ | |
#include "hal.h" | |
#include "led.h" | |
void led_set(uint8_t usb_led) { | |
if (usb_led & (1<<USB_LED_CAPS_LOCK)) { | |
// output high | |
palSetPadMode(TEENSY_PIN13_IOPORT, TEENSY_PIN13, PAL_MODE_OUTPUT_PUSHPULL); | |
palSetPad(TEENSY_PIN13_IOPORT, TEENSY_PIN13); | |
} else { | |
// Hi-Z | |
palSetPadMode(TEENSY_PIN13_IOPORT, TEENSY_PIN13, PAL_MODE_INPUT); | |
} | |
} |
# Target file name (without extension). | |
PROJECT = tv44_tlc | |
# Directory common source files exist | |
TMK_DIR = ../../tmk_core | |
# Directory keyboard dependent files exist | |
TARGET_DIR = . | |
# project specific files | |
SRC = matrix.c \ | |
keymap_common.c \ | |
led.c | |
ifdef KEYMAP | |
SRC := keymap_$(KEYMAP).c $(SRC) | |
else | |
SRC := keymap_tv44.c $(SRC) | |
endif | |
CONFIG_H = config.h | |
## chip/board settings | |
# - the next two should match the directories in | |
# <chibios>/os/hal/ports/$(MCU_FAMILY)/$(MCU_SERIES) | |
# - For Teensies, FAMILY = KINETIS and SERIES is either | |
# KL2x (LC) or K20x (3.0,3.1,3.2). | |
MCU_FAMILY = KINETIS | |
MCU_SERIES = KL2x | |
# Linker script to use | |
# - it should exist either in <chibios>/os/common/ports/ARMCMx/compilers/GCC/ld/ | |
# or <this_dir>/ld/ | |
# - NOTE: a custom ld script is needed for EEPROM on Teensy LC | |
# - LDSCRIPT = | |
# - MKL26Z64 for Teensy LC | |
# - MK20DX128 for Teensy 3.0 | |
# - MK20DX256 for Teensy 3.1 and 3.2 | |
MCU_LDSCRIPT = MKL26Z64 | |
# Startup code to use | |
# - it should exist in <chibios>/os/common/ports/ARMCMx/compilers/GCC/mk/ | |
# - STARTUP = | |
# - kl2x for Teensy LC | |
# - k20x5 for Teensy 3.0 | |
# - k20x7 for Teensy 3.1 and 3.2 | |
MCU_STARTUP = kl2x | |
# Board: it should exist either in <chibios>/os/hal/boards/ | |
# or <this_dir>/boards | |
# - BOARD = | |
# - PJRC_TEENSY_LC for Teensy LC | |
# - PJRC_TEENSY_3 for Teensy 3.0 | |
# - PJRC_TEENSY_3_1 for Teensy 3.1 or 3.2 | |
BOARD = PJRC_TEENSY_LC | |
# Cortex version | |
# Teensy LC is cortex-m0plus; Teensy 3.x are cortex-m4 | |
MCU = cortex-m0plus | |
# ARM version, CORTEX-M0/M1 are 6, CORTEX-M3/M4/M7 are 7 | |
# I.e. 6 for Teensy LC; 7 for Teensy 3.x | |
ARMV = 6 | |
# Build Options | |
# comment out to disable the options. | |
# | |
BOOTMAGIC_ENABLE = yes # Virtual DIP switch configuration | |
## (Note that for BOOTMAGIC on Teensy LC you have to use a custom .ld script.) | |
MOUSEKEY_ENABLE = yes # Mouse keys | |
EXTRAKEY_ENABLE = yes # Audio control and System control | |
CONSOLE_ENABLE = yes # Console for debug | |
COMMAND_ENABLE = yes # Commands for debug and configuration | |
SLEEP_LED_ENABLE = yes # Breathing sleep LED during USB suspend | |
NKRO_ENABLE = yes # USB Nkey Rollover | |
include $(TMK_DIR)/tool/chibios/common.mk | |
include $(TMK_DIR)/tool/chibios/chibios.mk |
/* | |
Copyright 2012 Jun Wako <wakojun@gmail.com> | |
This program is free software: you can redistribute it and/or modify | |
it under the terms of the GNU General Public License as published by | |
the Free Software Foundation, either version 2 of the License, or | |
(at your option) any later version. | |
This program is distributed in the hope that it will be useful, | |
but WITHOUT ANY WARRANTY; without even the implied warranty of | |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
GNU General Public License for more details. | |
You should have received a copy of the GNU General Public License | |
along with this program. If not, see <http://www.gnu.org/licenses/>. | |
*/ | |
#include "ch.h" | |
#include "hal.h" | |
/* | |
* scan matrix | |
*/ | |
#include "print.h" | |
#include "debug.h" | |
#include "util.h" | |
#include "matrix.h" | |
#include "wait.h" | |
#ifndef DEBOUNCE | |
# define DEBOUNCE 5 | |
#endif | |
static uint8_t debouncing = DEBOUNCE; | |
/* matrix state(1:on, 0:off) */ | |
static matrix_row_t matrix[MATRIX_ROWS]; | |
static matrix_row_t matrix_debouncing[MATRIX_ROWS]; | |
static matrix_row_t read_cols(void); | |
static void init_cols(void); | |
static void unselect_rows(void); | |
static void select_row(uint8_t row); | |
inline | |
uint8_t matrix_rows(void) | |
{ | |
return MATRIX_ROWS; | |
} | |
inline | |
uint8_t matrix_cols(void) | |
{ | |
return MATRIX_COLS; | |
} | |
#define LED_ON() do { palSetPad(TEENSY_PIN13_IOPORT, TEENSY_PIN13) ;} while (0) | |
#define LED_OFF() do { palClearPad(TEENSY_PIN13_IOPORT, TEENSY_PIN13); } while (0) | |
#define LED_TGL() do { palTogglePad(TEENSY_PIN13_IOPORT, TEENSY_PIN13); } while (0) | |
void matrix_init(void) | |
{ | |
// initialize row and col | |
unselect_rows(); | |
init_cols(); | |
// initialize matrix state: all keys off | |
for (uint8_t i=0; i < MATRIX_ROWS; i++) { | |
matrix[i] = 0; | |
matrix_debouncing[i] = 0; | |
} | |
//debug | |
debug_matrix = true; | |
LED_ON(); | |
wait_ms(500); | |
LED_OFF(); | |
} | |
uint8_t matrix_scan(void) | |
{ | |
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { | |
select_row(i); | |
//wait_us(30); // without this wait read unstable value. | |
for (uint8_t i=0; i < 3; i++) { // Loop for very short delay, wait_us is returning a 1ms delay | |
LED_TGL(); // toggle the onboard LED attached to pin 13 | |
} | |
matrix_row_t cols = read_cols(); | |
if (matrix_debouncing[i] != cols) { | |
matrix_debouncing[i] = cols; | |
if (debouncing) { | |
debug("bounce!: "); debug_hex(debouncing); debug("\n"); | |
} | |
debouncing = DEBOUNCE; | |
} | |
unselect_rows(); | |
} | |
if (debouncing) { | |
if (--debouncing) { | |
wait_ms(1); | |
} else { | |
for (uint8_t i = 0; i < MATRIX_ROWS; i++) { | |
matrix[i] = matrix_debouncing[i]; | |
} | |
} | |
} | |
return 1; | |
} | |
inline | |
bool matrix_is_on(uint8_t row, uint8_t col) | |
{ | |
return (matrix[row] & ((matrix_row_t)1<<col)); | |
} | |
inline | |
matrix_row_t matrix_get_row(uint8_t row) | |
{ | |
return matrix[row]; | |
} | |
void matrix_print(void) | |
{ | |
print("\nr/c 0123456789ABCDEF\n"); | |
for (uint8_t row = 0; row < MATRIX_ROWS; row++) { | |
phex(row); print(": "); | |
pbin_reverse16(matrix_get_row(row)); | |
print("\n"); | |
} | |
} | |
/* Column pin configuration | |
*/ | |
static void init_cols(void) | |
{ | |
// internal pull-up | |
palSetPadMode(TEENSY_PIN10_IOPORT, TEENSY_PIN10, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN11_IOPORT, TEENSY_PIN11, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN12_IOPORT, TEENSY_PIN12, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN14_IOPORT, TEENSY_PIN14, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN15_IOPORT, TEENSY_PIN15, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN16_IOPORT, TEENSY_PIN16, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN18_IOPORT, TEENSY_PIN18, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN19_IOPORT, TEENSY_PIN19, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN20_IOPORT, TEENSY_PIN20, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN21_IOPORT, TEENSY_PIN21, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN22_IOPORT, TEENSY_PIN22, PAL_MODE_INPUT_PULLUP); | |
palSetPadMode(TEENSY_PIN23_IOPORT, TEENSY_PIN23, PAL_MODE_INPUT_PULLUP); | |
} | |
/* Returns status of switches(1:on, 0:off) */ | |
static matrix_row_t read_cols(void) | |
{ | |
return ((palReadPad(TEENSY_PIN10_IOPORT, TEENSY_PIN10)==PAL_HIGH) ? 0 : (1<<0)) | |
| ((palReadPad(TEENSY_PIN11_IOPORT, TEENSY_PIN11)==PAL_HIGH) ? 0 : (1<<1)) | |
| ((palReadPad(TEENSY_PIN12_IOPORT, TEENSY_PIN12)==PAL_HIGH) ? 0 : (1<<2)) | |
| ((palReadPad(TEENSY_PIN14_IOPORT, TEENSY_PIN14)==PAL_HIGH) ? 0 : (1<<3)) | |
| ((palReadPad(TEENSY_PIN15_IOPORT, TEENSY_PIN15)==PAL_HIGH) ? 0 : (1<<4)) | |
| ((palReadPad(TEENSY_PIN16_IOPORT, TEENSY_PIN16)==PAL_HIGH) ? 0 : (1<<5)) | |
| ((palReadPad(TEENSY_PIN18_IOPORT, TEENSY_PIN18)==PAL_HIGH) ? 0 : (1<<6)) | |
| ((palReadPad(TEENSY_PIN19_IOPORT, TEENSY_PIN19)==PAL_HIGH) ? 0 : (1<<7)) | |
| ((palReadPad(TEENSY_PIN20_IOPORT, TEENSY_PIN20)==PAL_HIGH) ? 0 : (1<<8)) | |
| ((palReadPad(TEENSY_PIN21_IOPORT, TEENSY_PIN21)==PAL_HIGH) ? 0 : (1<<9)) | |
| ((palReadPad(TEENSY_PIN22_IOPORT, TEENSY_PIN22)==PAL_HIGH) ? 0 : (1<<10)) | |
| ((palReadPad(TEENSY_PIN23_IOPORT, TEENSY_PIN23)==PAL_HIGH) ? 0 : (1<<11)) | |
| ((palReadPad(TEENSY_PIN23_IOPORT, TEENSY_PIN23)==PAL_HIGH) ? 0 : (1<<11)); | |
} | |
/* Row pin configuration | |
*/ | |
static void unselect_rows(void) | |
{ | |
palSetPadMode(TEENSY_PIN6_IOPORT, TEENSY_PIN6, PAL_MODE_INPUT); // hi-Z | |
palSetPadMode(TEENSY_PIN7_IOPORT, TEENSY_PIN7, PAL_MODE_INPUT); // hi-Z | |
palSetPadMode(TEENSY_PIN8_IOPORT, TEENSY_PIN8, PAL_MODE_INPUT); // hi-Z | |
palSetPadMode(TEENSY_PIN9_IOPORT, TEENSY_PIN9, PAL_MODE_INPUT); // hi-Z | |
} | |
static void select_row(uint8_t row) | |
{ | |
(void)row; | |
// Output low to select | |
switch (row) { | |
case 0: | |
palSetPadMode(TEENSY_PIN6_IOPORT, TEENSY_PIN6, PAL_MODE_OUTPUT_PUSHPULL); | |
palClearPad(TEENSY_PIN6_IOPORT, TEENSY_PIN6); | |
break; | |
case 1: | |
palSetPadMode(TEENSY_PIN7_IOPORT, TEENSY_PIN7, PAL_MODE_OUTPUT_PUSHPULL); | |
palClearPad(TEENSY_PIN7_IOPORT, TEENSY_PIN7); | |
break; | |
case 2: | |
palSetPadMode(TEENSY_PIN8_IOPORT, TEENSY_PIN8, PAL_MODE_OUTPUT_PUSHPULL); | |
palClearPad(TEENSY_PIN8_IOPORT, TEENSY_PIN8); | |
break; | |
case 3: | |
palSetPadMode(TEENSY_PIN9_IOPORT, TEENSY_PIN9, PAL_MODE_OUTPUT_PUSHPULL); | |
palClearPad(TEENSY_PIN9_IOPORT, TEENSY_PIN9); | |
break; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
This comment has been minimized.
For a cleaner and more accurate delay on ARM with ChibiOS:
https://techoverflow.net/2015/09/09/accurate-short-long-delays-on-microcontrollers-using-chibios/